test/CodeGen/X86/fast-isel-x86-64.ll

   1 ; RUN: llc < %s -mattr=-avx -fast-isel -mcpu=core2 -O0 -regalloc=fast -asm-verbose=0 -fast-isel-abort=1 | FileCheck %s
   2 ; RUN: llc < %s -mattr=+avx -fast-isel -mcpu=core2 -O0 -regalloc=fast -asm-verbose=0 -fast-isel-abort=1 | FileCheck %s --check-prefix=AVX
   3
   4 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
   5 target triple = "x86_64-apple-darwin10.0.0"
   6
   7 ; Make sure that fast-isel folds the immediate into the binop even though it
   8 ; is non-canonical.
   9 define i32 @test1(i32 %i) nounwind ssp {
  10   %and = and i32 8, %i
  11   ret i32 %and
  12 }
  13
  14 ; CHECK-LABEL: test1:
  15 ; CHECK: andl   $8,
  16
  17
  18 ; rdar://9289512 - The load should fold into the compare.
  19 define void @test2(i64 %x) nounwind ssp {
  20 entry:
  21   %x.addr = alloca i64, align 8
  22   store i64 %x, i64* %x.addr, align 8
  23   %tmp = load i64, i64* %x.addr, align 8
  24   %cmp = icmp sgt i64 %tmp, 42
  25   br i1 %cmp, label %if.then, label %if.end
  26
  27 if.then:                                          ; preds = %entry
  28   br label %if.end
  29
  30 if.end:                                           ; preds = %if.then, %entry
  31   ret void
  32 ; CHECK-LABEL: test2:
  33 ; CHECK: movq   %rdi, -8(%rsp)
  34 ; CHECK: cmpq   $42, -8(%rsp)
  35 }
  36
  37
  38
  39
  40 @G = external global i32
  41 define i64 @test3() nounwind {
  42   %A = ptrtoint i32* @G to i64
  43   ret i64 %A
  44 ; CHECK-LABEL: test3:
  45 ; CHECK: movq _G@GOTPCREL(%rip), %rax
  46 ; CHECK-NEXT: ret
  47 }
  48
  49
  50
  51 ; rdar://9289558
  52 @rtx_length = external global [153 x i8]
  53
  54 define i32 @test4(i64 %idxprom9) nounwind {
  55   %arrayidx10 = getelementptr inbounds [153 x i8], [153 x i8]* @rtx_length, i32 0, i64 %idxprom9
  56   %tmp11 = load i8, i8* %arrayidx10, align 1
  57   %conv = zext i8 %tmp11 to i32
  58   ret i32 %conv
  59
  60 ; CHECK-LABEL: test4:
  61 ; CHECK: movq   _rtx_length@GOTPCREL(%rip), %rax
  62 ; CHECK-NEXT: movzbl    (%rax,%rdi), %eax
  63 ; CHECK-NEXT: ret
  64 }
  65
  66
  67 ; PR3242 - Out of range shifts should not be folded by fastisel.
  68 define void @test5(i32 %x, i32* %p) nounwind {
  69   %y = ashr i32 %x, 50000
  70   store i32 %y, i32* %p
  71   ret void
  72
  73 ; CHECK-LABEL: test5:
  74 ; CHECK: movl   $50000, %ecx
  75 ; CHECK: sarl   %cl, %edi
  76 ; CHECK: ret
  77 }
  78
  79 ; rdar://9289501 - fast isel should fold trivial multiplies to shifts.
  80 define i64 @test6(i64 %x) nounwind ssp {
  81 entry:
  82   %mul = mul nsw i64 %x, 8
  83   ret i64 %mul
  84
  85 ; CHECK-LABEL: test6:
  86 ; CHECK: shlq   $3, %rdi
  87 }
  88
  89 define i32 @test7(i32 %x) nounwind ssp {
  90 entry:
  91   %mul = mul nsw i32 %x, 8
  92   ret i32 %mul
  93 ; CHECK-LABEL: test7:
  94 ; CHECK: shll   $3, %edi
  95 }
  96
  97
  98 ; rdar://9289507 - folding of immediates into 64-bit operations.
  99 define i64 @test8(i64 %x) nounwind ssp {
 100 entry:
 101   %add = add nsw i64 %x, 7
 102   ret i64 %add
 103
 104 ; CHECK-LABEL: test8:
 105 ; CHECK: addq   $7, %rdi
 106 }
 107
 108 define i64 @test9(i64 %x) nounwind ssp {
 109 entry:
 110   %add = mul nsw i64 %x, 7
 111   ret i64 %add
 112 ; CHECK-LABEL: test9:
 113 ; CHECK: imulq  $7, %rdi, %rax
 114 }
 115
 116 ; rdar://9297011 - Don't reject udiv by a power of 2.
 117 define i32 @test10(i32 %X) nounwind {
 118   %Y = udiv i32 %X, 8
 119   ret i32 %Y
 120 ; CHECK-LABEL: test10:
 121 ; CHECK: shrl   $3,
 122 }
 123
 124 define i32 @test11(i32 %X) nounwind {
 125   %Y = sdiv exact i32 %X, 8
 126   ret i32 %Y
 127 ; CHECK-LABEL: test11:
 128 ; CHECK: sarl   $3,
 129 }
 130
 131
 132 ; rdar://9297006 - Trunc to bool.
 133 define void @test12(i8 %tmp) nounwind ssp noredzone {
 134 entry:
 135   %tobool = trunc i8 %tmp to i1
 136   br i1 %tobool, label %if.then, label %if.end
 137
 138 if.then:                                          ; preds = %entry
 139   call void @test12(i8 0) noredzone
 140   br label %if.end
 141
 142 if.end:                                           ; preds = %if.then, %entry
 143   ret void
 144 ; CHECK-LABEL: test12:
 145 ; CHECK: testb  $1,
 146 ; CHECK-NEXT: je L
 147 ; CHECK-NEXT: xorl %edi, %edi
 148 ; CHECK-NEXT: callq
 149 }
 150
 151 declare void @test13f(i1 %X)
 152
 153 define void @test13() nounwind {
 154   call void @test13f(i1 0)
 155   ret void
 156 ; CHECK-LABEL: test13:
 157 ; CHECK: xorl %edi, %edi
 158 ; CHECK-NEXT: callq
 159 }
 160
 161
 162
 163 ; rdar://9297003 - fast isel bails out on all functions taking bools
 164 define void @test14(i8 %tmp) nounwind ssp noredzone {
 165 entry:
 166   %tobool = trunc i8 %tmp to i1
 167   call void @test13f(i1 zeroext %tobool) noredzone
 168   ret void
 169 ; CHECK-LABEL: test14:
 170 ; CHECK: andb   $1,
 171 ; CHECK: callq
 172 }
 173
 174 declare void @llvm.memcpy.p0i8.p0i8.i64(i8*, i8*, i64, i32, i1)
 175
 176 ; rdar://9289488 - fast-isel shouldn't bail out on llvm.memcpy
 177 define void @test15(i8* %a, i8* %b) nounwind {
 178   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %a, i8* %b, i64 4, i32 4, i1 false)
 179   ret void
 180 ; CHECK-LABEL: test15:
 181 ; CHECK-NEXT: movl      (%rsi), %eax
 182 ; CHECK-NEXT: movl      %eax, (%rdi)
 183 ; CHECK-NEXT: ret
 184 }
 185
 186 ; Handling for varargs calls
 187 declare void @test16callee(...) nounwind
 188 define void @test16() nounwind {
 189 ; CHECK-LABEL: test16:
 190 ; CHECK: movl $1, %edi
 191 ; CHECK: movb $0, %al
 192 ; CHECK: callq _test16callee
 193   call void (...)* @test16callee(i32 1)
 194   br label %block2
 195
 196 block2:
 197 ; CHECK: movsd LCP{{.*}}_{{.*}}(%rip), %xmm0
 198 ; CHECK: movb $1, %al
 199 ; CHECK: callq _test16callee
 200
 201 ; AVX: vmovsd LCP{{.*}}_{{.*}}(%rip), %xmm0
 202 ; AVX: movb $1, %al
 203 ; AVX: callq _test16callee
 204   call void (...)* @test16callee(double 1.000000e+00)
 205   ret void
 206 }
 207
 208
 209 declare void @foo() unnamed_addr ssp align 2
 210
 211 ; Verify that we don't fold the load into the compare here.  That would move it
 212 ; w.r.t. the call.
 213 define i32 @test17(i32 *%P) ssp nounwind {
 214 entry:
 215   %tmp = load i32, i32* %P
 216   %cmp = icmp ne i32 %tmp, 5
 217   call void @foo()
 218   br i1 %cmp, label %if.then, label %if.else
 219
 220 if.then:                                          ; preds = %entry
 221   ret i32 1
 222
 223 if.else:                                          ; preds = %entry
 224   ret i32 2
 225 ; CHECK-LABEL: test17:
 226 ; CHECK: movl   (%rdi), %eax
 227 ; CHECK: callq _foo
 228 ; CHECK: cmpl   $5, %eax
 229 ; CHECK-NEXT: je
 230 }
 231
 232 ; Check that 0.0 is materialized using xorps
 233 define void @test18(float* %p1) {
 234   store float 0.0, float* %p1
 235   ret void
 236 ; CHECK-LABEL: test18:
 237 ; CHECK: xorps
 238 }
 239
 240 ; Without any type hints, doubles use the smaller xorps instead of xorpd.
 241 define void @test19(double* %p1) {
 242   store double 0.0, double* %p1
 243   ret void
 244 ; CHECK-LABEL: test19:
 245 ; CHECK: xorps
 246 }
 247
 248 ; Check that we fast-isel sret
 249 %struct.a = type { i64, i64, i64 }
 250 define void @test20() nounwind ssp {
 251 entry:
 252   %tmp = alloca %struct.a, align 8
 253   call void @test20sret(%struct.a* sret %tmp)
 254   ret void
 255 ; CHECK-LABEL: test20:
 256 ; CHECK: leaq (%rsp), %rdi
 257 ; CHECK: callq _test20sret
 258 }
 259 declare void @test20sret(%struct.a* sret)
 260
 261 ; Check that -0.0 is not materialized using xor
 262 define void @test21(double* %p1) {
 263   store double -0.0, double* %p1
 264   ret void
 265 ; CHECK-LABEL: test21:
 266 ; CHECK-NOT: xor
 267 ; CHECK: movsd  LCPI
 268 }
 269
 270 ; Check that immediate arguments to a function
 271 ; do not cause massive spilling and are used
 272 ; as immediates just before the call.
 273 define void @test22() nounwind {
 274 entry:
 275   call void @foo22(i32 0)
 276   call void @foo22(i32 1)
 277   call void @foo22(i32 2)
 278   call void @foo22(i32 3)
 279   ret void
 280 ; CHECK-LABEL: test22:
 281 ; CHECK: xorl   %edi, %edi
 282 ; CHECK: callq  _foo22
 283 ; CHECK: movl   $1, %edi
 284 ; CHECK: callq  _foo22
 285 ; CHECK: movl   $2, %edi
 286 ; CHECK: callq  _foo22
 287 ; CHECK: movl   $3, %edi
 288 ; CHECK: callq  _foo22
 289 }
 290
 291 declare void @foo22(i32)
 292
 293 ; PR13563
 294 define void @test23(i8* noalias sret %result) {
 295   %a = alloca i8
 296   %b = call i8* @foo23()
 297   ret void
 298 ; CHECK-LABEL: test23:
 299 ; CHECK: call
 300 ; CHECK: movq  %rdi, %rax
 301 ; CHECK: ret
 302 }
 303
 304 declare i8* @foo23()
 305
 306 declare void @takesi32ptr(i32* %arg)
 307
 308 ; CHECK-LABEL: allocamaterialize
 309 define void @allocamaterialize() {
 310   %a = alloca i32
 311 ; CHECK: leaq {{.*}}, %rdi
 312   call void @takesi32ptr(i32* %a)
 313   ret void
 314 }