test/CodeGen/X86/fp128-i128.ll

   1 ; RUN: llc < %s -O2 -mtriple=x86_64-linux-android -mattr=+mmx | FileCheck %s
   2 ; RUN: llc < %s -O2 -mtriple=x86_64-linux-gnu -mattr=+mmx | FileCheck %s
   3
   4 ; These tests were generated from simplified libm C code.
   5 ; When compiled for the x86_64-linux-android target,
   6 ; long double is mapped to f128 type that should be passed
   7 ; in SSE registers. When the f128 type calling convention
   8 ; problem was fixed, old llvm code failed to handle f128 values
   9 ; in several f128/i128 type operations. These unit tests hopefully
  10 ; will catch regression in any future change in this area.
  11 ; To modified or enhance these test cases, please consult libm
  12 ; code pattern and compile with -target x86_64-linux-android
  13 ; to generate IL. The __float128 keyword if not accepted by
  14 ; clang, just define it to "long double".
  15 ;
  16
  17 ; typedef long double __float128;
  18 ; union IEEEl2bits {
  19 ;   __float128 e;
  20 ;   struct {
  21 ;     unsigned long manl :64;
  22 ;     unsigned long manh :48;
  23 ;     unsigned int exp :15;
  24 ;     unsigned int sign :1;
  25 ;   } bits;
  26 ;   struct {
  27 ;     unsigned long manl :64;
  28 ;     unsigned long manh :48;
  29 ;     unsigned int expsign :16;
  30 ;   } xbits;
  31 ; };
  32
  33 ; C code:
  34 ; void foo(__float128 x);
  35 ; void TestUnionLD1(__float128 s, unsigned long n) {
  36 ;      union IEEEl2bits u;
  37 ;      __float128 w;
  38 ;      u.e = s;
  39 ;      u.bits.manh = n;
  40 ;      w = u.e;
  41 ;      foo(w);
  42 ; }
  43 define void @TestUnionLD1(fp128 %s, i64 %n) #0 {
  44 entry:
  45   %0 = bitcast fp128 %s to i128
  46   %1 = zext i64 %n to i128
  47   %bf.value = shl nuw i128 %1, 64
  48   %bf.shl = and i128 %bf.value, 5192296858534809181786422619668480
  49   %bf.clear = and i128 %0, -5192296858534809181786422619668481
  50   %bf.set = or i128 %bf.shl, %bf.clear
  51   %2 = bitcast i128 %bf.set to fp128
  52   tail call void @foo(fp128 %2) #2
  53   ret void
  54 ; CHECK-LABEL: TestUnionLD1:
  55 ; CHECK:       movaps %xmm0, -24(%rsp)
  56 ; CHECK-NEXT:  movq -24(%rsp), %rax
  57 ; CHECK-NEXT:  movabsq $281474976710655, %rcx
  58 ; CHECK-NEXT:  andq %rdi, %rcx
  59 ; CHECK-NEXT:  movabsq $-281474976710656, %rdx
  60 ; CHECK-NEXT:  andq -16(%rsp), %rdx
  61 ; CHECK-NEXT:  movq %rax, -40(%rsp)
  62 ; CHECK-NEXT:  orq %rcx, %rdx
  63 ; CHECK-NEXT:  movq %rdx, -32(%rsp)
  64 ; CHECK-NEXT:  movaps -40(%rsp), %xmm0
  65 ; CHECK-NEXT:  jmp foo
  66 }
  67
  68 ; C code:
  69 ; __float128 TestUnionLD2(__float128 s) {
  70 ;      union IEEEl2bits u;
  71 ;      __float128 w;
  72 ;      u.e = s;
  73 ;      u.bits.manl = 0;
  74 ;      w = u.e;
  75 ;      return w;
  76 ; }
  77 define fp128 @TestUnionLD2(fp128 %s) #0 {
  78 entry:
  79   %0 = bitcast fp128 %s to i128
  80   %bf.clear = and i128 %0, -18446744073709551616
  81   %1 = bitcast i128 %bf.clear to fp128
  82   ret fp128 %1
  83 ; CHECK-LABEL: TestUnionLD2:
  84 ; CHECK:       movaps %xmm0, -24(%rsp)
  85 ; CHECK-NEXT:  movq -16(%rsp), %rax
  86 ; CHECK-NEXT:  movq %rax, -32(%rsp)
  87 ; CHECK-NEXT:  movq $0, -40(%rsp)
  88 ; CHECK-NEXT:  movaps -40(%rsp), %xmm0
  89 ; CHECK-NEXT:  retq
  90 }
  91
  92 ; C code:
  93 ; __float128 TestI128_1(__float128 x)
  94 ; {
  95 ;  union IEEEl2bits z;
  96 ;  z.e = x;
  97 ;  z.bits.sign = 0;
  98 ;  return (z.e < 0.1L) ? 1.0L : 2.0L;
  99 ; }
 100 define fp128 @TestI128_1(fp128 %x) #0 {
 101 entry:
 102   %0 = bitcast fp128 %x to i128
 103   %bf.clear = and i128 %0, 170141183460469231731687303715884105727
 104   %1 = bitcast i128 %bf.clear to fp128
 105   %cmp = fcmp olt fp128 %1, 0xL999999999999999A3FFB999999999999
 106   %cond = select i1 %cmp, fp128 0xL00000000000000003FFF000000000000, fp128 0xL00000000000000004000000000000000
 107   ret fp128 %cond
 108 ; CHECK-LABEL: TestI128_1:
 109 ; CHECK:       movaps %xmm0,
 110 ; CHECK:       movabsq $9223372036854775807,
 111 ; CHECK:       callq __lttf2
 112 ; CHECK:       testl %eax, %eax
 113 ; CHECK:       movaps {{.*}}, %xmm0
 114 ; CHECK:       retq
 115 }
 116
 117 ; C code:
 118 ; __float128 TestI128_2(__float128 x, __float128 y)
 119 ; {
 120 ;  unsigned short hx;
 121 ;  union IEEEl2bits ge_u;
 122 ;  ge_u.e = x;
 123 ;  hx = ge_u.xbits.expsign;
 124 ;  return (hx & 0x8000) == 0 ? x : y;
 125 ; }
 126 define fp128 @TestI128_2(fp128 %x, fp128 %y) #0 {
 127 entry:
 128   %0 = bitcast fp128 %x to i128
 129   %cmp = icmp sgt i128 %0, -1
 130   %cond = select i1 %cmp, fp128 %x, fp128 %y
 131   ret fp128 %cond
 132 ; CHECK-LABEL: TestI128_2:
 133 ; CHECK:       movaps %xmm0, -24(%rsp)
 134 ; CHECK-NEXT:  cmpq $0, -16(%rsp)
 135 ; CHECK-NEXT:  jns
 136 ; CHECK:       movaps %xmm1, %xmm0
 137 ; CHECK:       retq
 138 }
 139
 140 ; C code:
 141 ; __float128 TestI128_3(__float128 x, int *ex)
 142 ; {
 143 ;  union IEEEl2bits u;
 144 ;  u.e = x;
 145 ;  if (u.bits.exp == 0) {
 146 ;    u.e *= 0x1.0p514;
 147 ;    u.bits.exp = 0x3ffe;
 148 ;  }
 149 ;  return (u.e);
 150 ; }
 151 define fp128 @TestI128_3(fp128 %x, i32* nocapture readnone %ex) #0 {
 152 entry:
 153   %0 = bitcast fp128 %x to i128
 154   %bf.cast = and i128 %0, 170135991163610696904058773219554885632
 155   %cmp = icmp eq i128 %bf.cast, 0
 156   br i1 %cmp, label %if.then, label %if.end
 157
 158 if.then:                                          ; preds = %entry
 159   %mul = fmul fp128 %x, 0xL00000000000000004201000000000000
 160   %1 = bitcast fp128 %mul to i128
 161   %bf.clear4 = and i128 %1, -170135991163610696904058773219554885633
 162   %bf.set = or i128 %bf.clear4, 85060207136517546210586590865283612672
 163   br label %if.end
 164
 165 if.end:                                           ; preds = %if.then, %entry
 166   %u.sroa.0.0 = phi i128 [ %bf.set, %if.then ], [ %0, %entry ]
 167   %2 = bitcast i128 %u.sroa.0.0 to fp128
 168   ret fp128 %2
 169 ; CHECK-LABEL: TestI128_3:
 170 ; CHECK:       movaps %xmm0,
 171 ; CHECK:       movabsq $9223090561878065152,
 172 ; CHECK:       testq
 173 ; CHECK:       callq __multf3
 174 ; CHECK-NEXT:  movaps %xmm0
 175 ; CHECK:       movabsq $-9223090561878065153,
 176 ; CHECK:       movabsq $4611123068473966592,
 177 ; CHECK:       retq
 178 }
 179
 180 ; C code:
 181 ; __float128 TestI128_4(__float128 x)
 182 ; {
 183 ;  union IEEEl2bits u;
 184 ;  __float128 df;
 185 ;  u.e = x;
 186 ;  u.xbits.manl = 0;
 187 ;  df = u.e;
 188 ;  return x + df;
 189 ; }
 190 define fp128 @TestI128_4(fp128 %x) #0 {
 191 entry:
 192   %0 = bitcast fp128 %x to i128
 193   %bf.clear = and i128 %0, -18446744073709551616
 194   %1 = bitcast i128 %bf.clear to fp128
 195   %add = fadd fp128 %1, %x
 196   ret fp128 %add
 197 ; CHECK-LABEL: TestI128_4:
 198 ; CHECK:       movaps %xmm0, %xmm1
 199 ; CHECK-NEXT:  movaps %xmm1, 16(%rsp)
 200 ; CHECK-NEXT:  movq 24(%rsp), %rax
 201 ; CHECK-NEXT:  movq %rax, 8(%rsp)
 202 ; CHECK-NEXT:  movq $0, (%rsp)
 203 ; CHECK-NEXT:  movaps (%rsp), %xmm0
 204 ; CHECK-NEXT:  callq __addtf3
 205 ; CHECK:       retq
 206 }
 207
 208 @v128 = common global i128 0, align 16
 209 @v128_2 = common global i128 0, align 16
 210
 211 ; C code:
 212 ; unsigned __int128 v128, v128_2;
 213 ; void TestShift128_2() {
 214 ;   v128 = ((v128 << 96) | v128_2);
 215 ; }
 216 define void @TestShift128_2() #2 {
 217 entry:
 218   %0 = load i128, i128* @v128, align 16
 219   %shl = shl i128 %0, 96
 220   %1 = load i128, i128* @v128_2, align 16
 221   %or = or i128 %shl, %1
 222   store i128 %or, i128* @v128, align 16
 223   ret void
 224 ; CHECK-LABEL: TestShift128_2:
 225 ; CHECK:       movq v128(%rip), %rax
 226 ; CHECK-NEXT:  shlq $32, %rax
 227 ; CHECK-NEXT:  movq v128_2(%rip), %rcx
 228 ; CHECK-NEXT:  orq v128_2+8(%rip), %rax
 229 ; CHECK-NEXT:  movq %rcx, v128(%rip)
 230 ; CHECK-NEXT:  movq %rax, v128+8(%rip)
 231 ; CHECK-NEXT:  retq
 232 }
 233
 234 define fp128 @acosl(fp128 %x) #0 {
 235 entry:
 236   %0 = bitcast fp128 %x to i128
 237   %bf.clear = and i128 %0, -18446744073709551616
 238   %1 = bitcast i128 %bf.clear to fp128
 239   %add = fadd fp128 %1, %x
 240   ret fp128 %add
 241 ; CHECK-LABEL: acosl:
 242 ; CHECK:       movaps %xmm0, %xmm1
 243 ; CHECK-NEXT:  movaps %xmm1, 16(%rsp)
 244 ; CHECK-NEXT:  movq 24(%rsp), %rax
 245 ; CHECK-NEXT:  movq %rax, 8(%rsp)
 246 ; CHECK-NEXT:  movq $0, (%rsp)
 247 ; CHECK-NEXT:  movaps (%rsp), %xmm0
 248 ; CHECK-NEXT:  callq __addtf3
 249 ; CHECK:       retq
 250 }
 251
 252 ; Compare i128 values and check i128 constants.
 253 define fp128 @TestComp(fp128 %x, fp128 %y) #0 {
 254 entry:
 255   %0 = bitcast fp128 %x to i128
 256   %cmp = icmp sgt i128 %0, -1
 257   %cond = select i1 %cmp, fp128 %x, fp128 %y
 258   ret fp128 %cond
 259 ; CHECK-LABEL: TestComp:
 260 ; CHECK:       movaps %xmm0, -24(%rsp)
 261 ; CHECK-NEXT:  cmpq $0, -16(%rsp)
 262 ; CHECK-NEXT:  jns
 263 ; CHECK:       movaps %xmm1, %xmm0
 264 ; CHECK:       retq
 265 }
 266
 267 declare void @foo(fp128) #1
 268
 269 ; Test logical operations on fp128 values.
 270 define fp128 @TestFABS_LD(fp128 %x) #0 {
 271 entry:
 272   %call = tail call fp128 @fabsl(fp128 %x) #2
 273   ret fp128 %call
 274 ; CHECK-LABEL: TestFABS_LD
 275 ; CHECK:       andps {{.*}}, %xmm0
 276 ; CHECK-NEXT:  retq
 277 }
 278
 279 declare fp128 @fabsl(fp128) #1
 280
 281 declare fp128 @copysignl(fp128, fp128) #1
 282
 283 ; Test more complicated logical operations generated from copysignl.
 284 define void @TestCopySign({ fp128, fp128 }* noalias nocapture sret %agg.result, { fp128, fp128 }* byval nocapture readonly align 16 %z) #0 {
 285 entry:
 286   %z.realp = getelementptr inbounds { fp128, fp128 }, { fp128, fp128 }* %z, i64 0, i32 0
 287   %z.real = load fp128, fp128* %z.realp, align 16
 288   %z.imagp = getelementptr inbounds { fp128, fp128 }, { fp128, fp128 }* %z, i64 0, i32 1
 289   %z.imag4 = load fp128, fp128* %z.imagp, align 16
 290   %cmp = fcmp ogt fp128 %z.real, %z.imag4
 291   %sub = fsub fp128 %z.imag4, %z.imag4
 292   br i1 %cmp, label %if.then, label %cleanup
 293
 294 if.then:                                          ; preds = %entry
 295   %call = tail call fp128 @fabsl(fp128 %sub) #2
 296   br label %cleanup
 297
 298 cleanup:                                          ; preds = %entry, %if.then
 299   %z.real.sink = phi fp128 [ %z.real, %if.then ], [ %sub, %entry ]
 300   %call.sink = phi fp128 [ %call, %if.then ], [ %z.real, %entry ]
 301   %call5 = tail call fp128 @copysignl(fp128 %z.real.sink, fp128 %z.imag4) #2
 302   %0 = getelementptr inbounds { fp128, fp128 }, { fp128, fp128 }* %agg.result, i64 0, i32 0
 303   %1 = getelementptr inbounds { fp128, fp128 }, { fp128, fp128 }* %agg.result, i64 0, i32 1
 304   store fp128 %call.sink, fp128* %0, align 16
 305   store fp128 %call5, fp128* %1, align 16
 306   ret void
 307 ; CHECK-LABEL: TestCopySign
 308 ; CHECK-NOT:   call
 309 ; CHECK:       callq __subtf3
 310 ; CHECK-NOT:   call
 311 ; CHECK:       callq __gttf2
 312 ; CHECK-NOT:   call
 313 ; CHECK:       andps {{.*}}, %xmm0
 314 ; CHECK:       retq
 315 }
 316
 317
 318 attributes #0 = { nounwind uwtable "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+ssse3,+sse3,+popcnt,+sse,+sse2,+sse4.1,+sse4.2" "unsafe-fp-math"="false" "use-soft-float"="false" }
 319 attributes #1 = { "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+ssse3,+sse3,+popcnt,+sse,+sse2,+sse4.1,+sse4.2" "unsafe-fp-math"="false" "use-soft-float"="false" }
 320 attributes #2 = { nounwind readnone }