AArch64: enable Cortex-A57 FP balancing on Cortex-A53.
[oota-llvm.git] / test / CodeGen / AArch64 / aarch64-a57-fp-load-balancing.ll
1 ; RUN: llc < %s -mcpu=cortex-a57 -aarch64-a57-fp-load-balancing-override=1 -aarch64-a57-fp-load-balancing-force-all | FileCheck %s --check-prefix CHECK --check-prefix CHECK-A57 --check-prefix CHECK-EVEN
2 ; RUN: llc < %s -mcpu=cortex-a57 -aarch64-a57-fp-load-balancing-override=2 -aarch64-a57-fp-load-balancing-force-all | FileCheck %s --check-prefix CHECK --check-prefix CHECK-A57 --check-prefix CHECK-ODD
3 ; RUN: llc < %s -mcpu=cortex-a53 -aarch64-a57-fp-load-balancing-override=1 -aarch64-a57-fp-load-balancing-force-all | FileCheck %s --check-prefix CHECK --check-prefix CHECK-A53 --check-prefix CHECK-EVEN
4 ; RUN: llc < %s -mcpu=cortex-a53 -aarch64-a57-fp-load-balancing-override=2 -aarch64-a57-fp-load-balancing-force-all | FileCheck %s --check-prefix CHECK --check-prefix CHECK-A53 --check-prefix CHECK-ODD
5
6 ; Test the AArch64A57FPLoadBalancing pass. This pass relies heavily on register allocation, so
7 ; our test strategy is to:
8 ;   * Force the pass to always perform register swapping even if the dest register is of the
9 ;     correct color already (-force-all)
10 ;   * Force the pass to ignore all hints it obtained from regalloc (-deterministic-balance),
11 ;     and run it twice, once where it always hints odd, and once where it always hints even.
12 ;
13 ; We then use regex magic to check that in the two cases the register allocation is
14 ; different; this is what gives us the testing coverage and distinguishes cases where
15 ; the pass has done some work versus accidental regalloc.
16
17 target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128"
18 target triple = "aarch64"
19
20 ; Non-overlapping groups - shouldn't need any changing at all.
21
22 ; CHECK-LABEL: f1:
23 ; CHECK-EVEN: fmadd [[x:d[0-9]*[02468]]]
24 ; CHECK-ODD: fmadd [[x:d[0-9]*[13579]]]
25 ; CHECK: fmadd [[x]]
26 ; CHECK: fmsub [[x]]
27 ; CHECK: fmadd [[x]]
28 ; CHECK: str [[x]]
29
30 define void @f1(double* nocapture readonly %p, double* nocapture %q) #0 {
31 entry:
32   %0 = load double* %p, align 8
33   %arrayidx1 = getelementptr inbounds double* %p, i64 1
34   %1 = load double* %arrayidx1, align 8
35   %arrayidx2 = getelementptr inbounds double* %p, i64 2
36   %2 = load double* %arrayidx2, align 8
37   %arrayidx3 = getelementptr inbounds double* %p, i64 3
38   %3 = load double* %arrayidx3, align 8
39   %arrayidx4 = getelementptr inbounds double* %p, i64 4
40   %4 = load double* %arrayidx4, align 8
41   %mul = fmul fast double %0, %1
42   %add = fadd fast double %mul, %4
43   %mul5 = fmul fast double %1, %2
44   %add6 = fadd fast double %mul5, %add
45   %mul7 = fmul fast double %1, %3
46   %sub = fsub fast double %add6, %mul7
47   %mul8 = fmul fast double %2, %3
48   %add9 = fadd fast double %mul8, %sub
49   store double %add9, double* %q, align 8
50   %arrayidx11 = getelementptr inbounds double* %p, i64 5
51   %5 = load double* %arrayidx11, align 8
52   %arrayidx12 = getelementptr inbounds double* %p, i64 6
53   %6 = load double* %arrayidx12, align 8
54   %arrayidx13 = getelementptr inbounds double* %p, i64 7
55   %7 = load double* %arrayidx13, align 8
56   %mul15 = fmul fast double %6, %7
57   %mul16 = fmul fast double %0, %5
58   %add17 = fadd fast double %mul16, %mul15
59   %mul18 = fmul fast double %5, %6
60   %add19 = fadd fast double %mul18, %add17
61   %arrayidx20 = getelementptr inbounds double* %q, i64 1
62   store double %add19, double* %arrayidx20, align 8
63   ret void
64 }
65
66 ; Overlapping groups - coloring needed.
67
68 ; CHECK-LABEL: f2:
69 ; CHECK-EVEN: fmadd [[x:d[0-9]*[02468]]]
70 ; CHECK-EVEN: fmul [[y:d[0-9]*[13579]]]
71 ; CHECK-ODD: fmadd [[x:d[0-9]*[13579]]]
72 ; CHECK-ODD: fmul [[y:d[0-9]*[02468]]]
73 ; CHECK: fmadd [[x]]
74 ; CHECK: fmadd [[y]]
75 ; CHECK: fmsub [[x]]
76 ; CHECK: fmadd [[y]]
77 ; CHECK: fmadd [[x]]
78 ; CHECK-A57: stp [[x]], [[y]]
79 ; CHECK-A53-DAG: str [[x]]
80 ; CHECK-A53-DAG: str [[y]]
81
82 define void @f2(double* nocapture readonly %p, double* nocapture %q) #0 {
83 entry:
84   %0 = load double* %p, align 8
85   %arrayidx1 = getelementptr inbounds double* %p, i64 1
86   %1 = load double* %arrayidx1, align 8
87   %arrayidx2 = getelementptr inbounds double* %p, i64 2
88   %2 = load double* %arrayidx2, align 8
89   %arrayidx3 = getelementptr inbounds double* %p, i64 3
90   %3 = load double* %arrayidx3, align 8
91   %arrayidx4 = getelementptr inbounds double* %p, i64 4
92   %4 = load double* %arrayidx4, align 8
93   %arrayidx5 = getelementptr inbounds double* %p, i64 5
94   %5 = load double* %arrayidx5, align 8
95   %arrayidx6 = getelementptr inbounds double* %p, i64 6
96   %6 = load double* %arrayidx6, align 8
97   %arrayidx7 = getelementptr inbounds double* %p, i64 7
98   %7 = load double* %arrayidx7, align 8
99   %mul = fmul fast double %0, %1
100   %add = fadd fast double %mul, %7
101   %mul8 = fmul fast double %5, %6
102   %mul9 = fmul fast double %1, %2
103   %add10 = fadd fast double %mul9, %add
104   %mul11 = fmul fast double %3, %4
105   %add12 = fadd fast double %mul11, %mul8
106   %mul13 = fmul fast double %1, %3
107   %sub = fsub fast double %add10, %mul13
108   %mul14 = fmul fast double %4, %5
109   %add15 = fadd fast double %mul14, %add12
110   %mul16 = fmul fast double %2, %3
111   %add17 = fadd fast double %mul16, %sub
112   store double %add17, double* %q, align 8
113   %arrayidx19 = getelementptr inbounds double* %q, i64 1
114   store double %add15, double* %arrayidx19, align 8
115   ret void
116 }
117
118 ; Dest register is live on block exit - fixup needed.
119
120 ; CHECK-LABEL: f3:
121 ; CHECK-EVEN: fmadd [[x:d[0-9]*[02468]]]
122 ; CHECK-ODD: fmadd [[x:d[0-9]*[13579]]]
123 ; CHECK: fmadd [[x]]
124 ; CHECK: fmsub [[x]]
125 ; CHECK: fmadd [[y:d[0-9]+]], {{.*}}, [[x]]
126 ; CHECK: str [[y]]
127
128 define void @f3(double* nocapture readonly %p, double* nocapture %q) #0 {
129 entry:
130   %0 = load double* %p, align 8
131   %arrayidx1 = getelementptr inbounds double* %p, i64 1
132   %1 = load double* %arrayidx1, align 8
133   %arrayidx2 = getelementptr inbounds double* %p, i64 2
134   %2 = load double* %arrayidx2, align 8
135   %arrayidx3 = getelementptr inbounds double* %p, i64 3
136   %3 = load double* %arrayidx3, align 8
137   %arrayidx4 = getelementptr inbounds double* %p, i64 4
138   %4 = load double* %arrayidx4, align 8
139   %mul = fmul fast double %0, %1
140   %add = fadd fast double %mul, %4
141   %mul5 = fmul fast double %1, %2
142   %add6 = fadd fast double %mul5, %add
143   %mul7 = fmul fast double %1, %3
144   %sub = fsub fast double %add6, %mul7
145   %mul8 = fmul fast double %2, %3
146   %add9 = fadd fast double %mul8, %sub
147   %cmp = fcmp oeq double %3, 0.000000e+00
148   br i1 %cmp, label %if.then, label %if.end
149
150 if.then:                                          ; preds = %entry
151   tail call void bitcast (void (...)* @g to void ()*)() #2
152   br label %if.end
153
154 if.end:                                           ; preds = %if.then, %entry
155   store double %add9, double* %q, align 8
156   ret void
157 }
158
159 declare void @g(...) #1
160
161 ; Single precision version of f2.
162
163 ; CHECK-LABEL: f4:
164 ; CHECK-EVEN: fmadd [[x:s[0-9]*[02468]]]
165 ; CHECK-EVEN: fmul [[y:s[0-9]*[13579]]]
166 ; CHECK-ODD: fmadd [[x:s[0-9]*[13579]]]
167 ; CHECK-ODD: fmul [[y:s[0-9]*[02468]]]
168 ; CHECK: fmadd [[x]]
169 ; CHECK: fmadd [[y]]
170 ; CHECK: fmsub [[x]]
171 ; CHECK: fmadd [[y]]
172 ; CHECK: fmadd [[x]]
173 ; CHECK-A57: stp [[x]], [[y]]
174 ; CHECK-A53-DAG: str [[x]]
175 ; CHECK-A53-DAG: str [[y]]
176
177 define void @f4(float* nocapture readonly %p, float* nocapture %q) #0 {
178 entry:
179   %0 = load float* %p, align 4
180   %arrayidx1 = getelementptr inbounds float* %p, i64 1
181   %1 = load float* %arrayidx1, align 4
182   %arrayidx2 = getelementptr inbounds float* %p, i64 2
183   %2 = load float* %arrayidx2, align 4
184   %arrayidx3 = getelementptr inbounds float* %p, i64 3
185   %3 = load float* %arrayidx3, align 4
186   %arrayidx4 = getelementptr inbounds float* %p, i64 4
187   %4 = load float* %arrayidx4, align 4
188   %arrayidx5 = getelementptr inbounds float* %p, i64 5
189   %5 = load float* %arrayidx5, align 4
190   %arrayidx6 = getelementptr inbounds float* %p, i64 6
191   %6 = load float* %arrayidx6, align 4
192   %arrayidx7 = getelementptr inbounds float* %p, i64 7
193   %7 = load float* %arrayidx7, align 4
194   %mul = fmul fast float %0, %1
195   %add = fadd fast float %mul, %7
196   %mul8 = fmul fast float %5, %6
197   %mul9 = fmul fast float %1, %2
198   %add10 = fadd fast float %mul9, %add
199   %mul11 = fmul fast float %3, %4
200   %add12 = fadd fast float %mul11, %mul8
201   %mul13 = fmul fast float %1, %3
202   %sub = fsub fast float %add10, %mul13
203   %mul14 = fmul fast float %4, %5
204   %add15 = fadd fast float %mul14, %add12
205   %mul16 = fmul fast float %2, %3
206   %add17 = fadd fast float %mul16, %sub
207   store float %add17, float* %q, align 4
208   %arrayidx19 = getelementptr inbounds float* %q, i64 1
209   store float %add15, float* %arrayidx19, align 4
210   ret void
211 }
212
213 ; Single precision version of f3
214
215 ; CHECK-LABEL: f5:
216 ; CHECK-EVEN: fmadd [[x:s[0-9]*[02468]]]
217 ; CHECK-ODD: fmadd [[x:s[0-9]*[13579]]]
218 ; CHECK: fmadd [[x]]
219 ; CHECK: fmsub [[x]]
220 ; CHECK: fmadd [[y:s[0-9]+]], {{.*}}, [[x]]
221 ; CHECK: str [[y]]
222
223 define void @f5(float* nocapture readonly %p, float* nocapture %q) #0 {
224 entry:
225   %0 = load float* %p, align 4
226   %arrayidx1 = getelementptr inbounds float* %p, i64 1
227   %1 = load float* %arrayidx1, align 4
228   %arrayidx2 = getelementptr inbounds float* %p, i64 2
229   %2 = load float* %arrayidx2, align 4
230   %arrayidx3 = getelementptr inbounds float* %p, i64 3
231   %3 = load float* %arrayidx3, align 4
232   %arrayidx4 = getelementptr inbounds float* %p, i64 4
233   %4 = load float* %arrayidx4, align 4
234   %mul = fmul fast float %0, %1
235   %add = fadd fast float %mul, %4
236   %mul5 = fmul fast float %1, %2
237   %add6 = fadd fast float %mul5, %add
238   %mul7 = fmul fast float %1, %3
239   %sub = fsub fast float %add6, %mul7
240   %mul8 = fmul fast float %2, %3
241   %add9 = fadd fast float %mul8, %sub
242   %cmp = fcmp oeq float %3, 0.000000e+00
243   br i1 %cmp, label %if.then, label %if.end
244
245 if.then:                                          ; preds = %entry
246   tail call void bitcast (void (...)* @g to void ()*)() #2
247   br label %if.end
248
249 if.end:                                           ; preds = %if.then, %entry
250   store float %add9, float* %q, align 4
251   ret void
252 }
253
254 ; Test that regmask clobbering stops a chain sequence.
255
256 ; CHECK-LABEL: f6:
257 ; CHECK-EVEN: fmadd [[x:d[0-9]*[02468]]]
258 ; CHECK-ODD: fmadd [[x:d[0-9]*[13579]]]
259 ; CHECK: fmadd [[x]]
260 ; CHECK: fmsub [[x]]
261 ; CHECK: fmadd d0, {{.*}}, [[x]]
262 ; CHECK: bl hh
263 ; CHECK: str d0
264
265 define void @f6(double* nocapture readonly %p, double* nocapture %q) #0 {
266 entry:
267   %0 = load double* %p, align 8
268   %arrayidx1 = getelementptr inbounds double* %p, i64 1
269   %1 = load double* %arrayidx1, align 8
270   %arrayidx2 = getelementptr inbounds double* %p, i64 2
271   %2 = load double* %arrayidx2, align 8
272   %arrayidx3 = getelementptr inbounds double* %p, i64 3
273   %3 = load double* %arrayidx3, align 8
274   %arrayidx4 = getelementptr inbounds double* %p, i64 4
275   %4 = load double* %arrayidx4, align 8
276   %mul = fmul fast double %0, %1
277   %add = fadd fast double %mul, %4
278   %mul5 = fmul fast double %1, %2
279   %add6 = fadd fast double %mul5, %add
280   %mul7 = fmul fast double %1, %3
281   %sub = fsub fast double %add6, %mul7
282   %mul8 = fmul fast double %2, %3
283   %add9 = fadd fast double %mul8, %sub
284   %call = tail call double @hh(double %add9) #2
285   store double %call, double* %q, align 8
286   ret void
287 }
288
289 declare double @hh(double) #1
290
291 ; Check that we correctly deal with repeated operands.
292 ; The following testcase creates:
293 ;   %D1<def> = FADDDrr %D0<kill>, %D0
294 ; We'll get a crash if we naively look at the first operand, remove it
295 ; from the substitution list then look at the second operand.
296
297 ; CHECK: fmadd [[x:d[0-9]+]]
298 ; CHECK: fadd d1, [[x]], [[x]]
299
300 define void @f7(double* nocapture readonly %p, double* nocapture %q) #0 {
301 entry:
302   %0 = load double* %p, align 8
303   %arrayidx1 = getelementptr inbounds double* %p, i64 1
304   %1 = load double* %arrayidx1, align 8
305   %arrayidx2 = getelementptr inbounds double* %p, i64 2
306   %2 = load double* %arrayidx2, align 8
307   %arrayidx3 = getelementptr inbounds double* %p, i64 3
308   %3 = load double* %arrayidx3, align 8
309   %arrayidx4 = getelementptr inbounds double* %p, i64 4
310   %4 = load double* %arrayidx4, align 8
311   %mul = fmul fast double %0, %1
312   %add = fadd fast double %mul, %4
313   %mul5 = fmul fast double %1, %2
314   %add6 = fadd fast double %mul5, %add
315   %mul7 = fmul fast double %1, %3
316   %sub = fsub fast double %add6, %mul7
317   %mul8 = fmul fast double %2, %3
318   %add9 = fadd fast double %mul8, %sub
319   %add10 = fadd fast double %add9, %add9
320   call void @hhh(double 0.0, double %add10)
321   ret void
322 }
323
324 declare void @hhh(double, double)
325
326 attributes #0 = { nounwind "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="true" "no-nans-fp-math"="true" "stack-protector-buffer-size"="8" "unsafe-fp-math"="true" "use-soft-float"="false" }
327 attributes #1 = { "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="true" "no-nans-fp-math"="true" "stack-protector-buffer-size"="8" "unsafe-fp-math"="true" "use-soft-float"="false" }
328 attributes #2 = { nounwind }
329