← Back to branch summary

~pali/+junk/llvm-toolchain-3.7

« back to all changes in this revision

Viewing changes to test/CodeGen/X86/fast-isel-x86-64.ll

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2015-07-15 17:51:08 UTC
  • Revision ID: package-import@ubuntu.com-20150715175108-l8mynwovkx4zx697
Tags: upstream-3.7~+rc2
Import upstream version 3.7~+rc2

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
}