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