Lines Matching refs:BIT
2 ; RUN: FileCheck --check-prefixes=CHECK,32BIT %s
9 ; RUN: FileCheck --check-prefixes=CHECK,64BIT %s
23 ; 32BIT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
24 ; 32BIT: $r3 = LI 97
25 ; 32BIT: $r4 = LI 97
26 ; 32BIT: $r5 = LI 97
27 ; 32BIT: $r6 = LI 97
28 ; 32BIT: BL_NOP <mcsymbol .test_chars>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit ki…
29 ; 32BIT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
31 ; 64BIT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
32 ; 64BIT: $x3 = LI8 97
33 ; 64BIT: $x4 = LI8 97
34 ; 64BIT: $x5 = LI8 97
35 ; 64BIT: $x6 = LI8 97
36 ; 64BIT: BL8_NOP <mcsymbol .test_chars>, csr_ppc64, implicit-def dead $lr8, implicit $rm, implicit …
37 ; 64BIT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
54 ; 32BIT: liveins:
55 ; 32BIT-NEXT: - { reg: '$r3', virtual-reg: '' }
56 ; 32BIT-NEXT: - { reg: '$r4', virtual-reg: '' }
57 ; 32BIT-NEXT: - { reg: '$r5', virtual-reg: '' }
58 ; 32BIT-NEXT: - { reg: '$r6', virtual-reg: '' }
59 ; 32BIT: body:
60 ; 32BIT-NEXT: bb.0.entry:
61 ; 32BIT-NEXT: liveins: $r3, $r4, $r5, $r6
63 ; 64BIT: liveins:
64 ; 64BIT-NEXT: - { reg: '$x3', virtual-reg: '' }
65 ; 64BIT-NEXT: - { reg: '$x4', virtual-reg: '' }
66 ; 64BIT-NEXT: - { reg: '$x5', virtual-reg: '' }
67 ; 64BIT-NEXT: - { reg: '$x6', virtual-reg: '' }
68 ; 64BIT: body:
69 ; 64BIT-NEXT: bb.0.entry:
70 ; 64BIT-NEXT: liveins: $x3, $x4, $x5, $x6
80 ; 32BIT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
81 ; 32BIT: $r3 = LI 97
82 ; 32BIT: $r4 = LI 225
83 ; 32BIT: $r5 = LI 97
84 ; 32BIT: $r6 = LI -31
85 ; 32BIT: BL_NOP <mcsymbol .test_chars_mix>, csr_aix32, implicit-def dead $lr, implicit $rm, implici…
86 ; 32BIT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
88 ; 64BIT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
89 ; 64BIT: $x3 = LI8 97
90 ; 64BIT: $x4 = LI8 225
91 ; 64BIT: $x5 = LI8 97
92 ; 64BIT: $x6 = LI8 -31
93 ; 64BIT: BL8_NOP <mcsymbol .test_chars_mix>, csr_ppc64, implicit-def dead $lr8, implicit $rm, impli…
94 ; 64BIT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
111 ; 32BIT: liveins:
112 ; 32BIT-NEXT: - { reg: '$r3', virtual-reg: '' }
113 ; 32BIT-NEXT: - { reg: '$r4', virtual-reg: '' }
114 ; 32BIT-NEXT: - { reg: '$r5', virtual-reg: '' }
115 ; 32BIT-NEXT: - { reg: '$r6', virtual-reg: '' }
116 ; 32BIT: body:
117 ; 32BIT-NEXT: bb.0.entry:
118 ; 32BIT-NEXT: liveins: $r3, $r4, $r5, $r6
120 ; 64BIT: liveins:
121 ; 64BIT-NEXT: - { reg: '$x3', virtual-reg: '' }
122 ; 64BIT-NEXT: - { reg: '$x4', virtual-reg: '' }
123 ; 64BIT-NEXT: - { reg: '$x5', virtual-reg: '' }
124 ; 64BIT-NEXT: - { reg: '$x6', virtual-reg: '' }
125 ; 64BIT: body:
126 ; 64BIT-NEXT: bb.0.entry:
127 ; 64BIT-NEXT: liveins: $x3, $x4, $x5, $x6
138 ; 32BIT: liveins:
139 ; 32BIT-NEXT: - { reg: '$r3', virtual-reg: '' }
140 ; 32BIT: body: |
141 ; 32BIT-NEXT: bb.0.entry:
142 ; 32BIT-NEXT: liveins: $r3
143 ; 32BIT: renamable $r3 = RLWINM killed renamable $r3, 0, 31, 31
144 ; 32BIT-NEXT: STB killed renamable $r3, 0, killed renamable $r4 :: (store (s8) into @global_i1)
146 ; 64BIT: liveins:
147 ; 64BIT-NEXT: - { reg: '$x3', virtual-reg: '' }
148 ; 64BIT: body: |
149 ; 64BIT-NEXT: bb.0.entry:
150 ; 64BIT-NEXT: liveins: $x3
151 ; 64BIT: renamable $r[[REG1:[0-9]+]] = RLWINM renamable $r[[REG1]], 0, 31, 31, implicit k…
152 ; 64BIT-NEXT: STB killed renamable $r[[REG1]], 0, killed renamable $x4 :: (store (s8) into @gl…
161 ; 32BIT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
162 ; 32BIT: $r3 = LI 1
163 ; 32BIT: BL_NOP <mcsymbol .test_i1>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit kille…
164 ; 32BIT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
166 ; 64BIT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
167 ; 64BIT: $x3 = LI8 1
168 ; 64BIT: BL8_NOP <mcsymbol .test_i1>, csr_ppc64, implicit-def dead $lr8, implicit $rm, implicit kil…
169 ; 64BIT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
178 ; 32BIT: liveins:
179 ; 32BIT-NEXT: - { reg: '$r3', virtual-reg: '' }
180 ; 32BIT: body: |
181 ; 32BIT-NEXT: bb.0.entry:
182 ; 32BIT-NEXT: liveins: $r3
184 ; 32BIT: STB killed renamable $r3, 0, killed renamable $r4 :: (store (s8) into @global_i1)
186 ; 64BIT: liveins:
187 ; 64BIT-NEXT: - { reg: '$x3', virtual-reg: '' }
188 ; 64BIT: body: |
189 ; 64BIT-NEXT: bb.0.entry:
190 ; 64BIT-NEXT: liveins: $x3
192 ; 64BIT: STB8 killed renamable $x3, 0, killed renamable $x4 :: (store (s8) into @global_i…
208 ; 32BIT: liveins:
209 ; 32BIT-NEXT: - { reg: '$r3', virtual-reg: '' }
210 ; 32BIT-NEXT: - { reg: '$r4', virtual-reg: '' }
211 ; 32BIT-NEXT: - { reg: '$r5', virtual-reg: '' }
212 ; 32BIT-NEXT: - { reg: '$r6', virtual-reg: '' }
213 ; 32BIT-NEXT: - { reg: '$r7', virtual-reg: '' }
214 ; 32BIT-NEXT: - { reg: '$r8', virtual-reg: '' }
215 ; 32BIT-NEXT: - { reg: '$r9', virtual-reg: '' }
216 ; 32BIT-NEXT: - { reg: '$r10', virtual-reg: '' }
217 ; 32BIT: body: |
218 ; 32BIT-NEXT: bb.0.entry:
219 ; 32BIT-NEXT: liveins: $r3, $r4, $r5, $r6, $r7, $r8, $r9, $r10
221 ; 64BIT: liveins:
222 ; 64BIT-NEXT: - { reg: '$x3', virtual-reg: '' }
223 ; 64BIT-NEXT: - { reg: '$x4', virtual-reg: '' }
224 ; 64BIT-NEXT: - { reg: '$x5', virtual-reg: '' }
225 ; 64BIT-NEXT: - { reg: '$x6', virtual-reg: '' }
226 ; 64BIT-NEXT: - { reg: '$x7', virtual-reg: '' }
227 ; 64BIT-NEXT: - { reg: '$x8', virtual-reg: '' }
228 ; 64BIT-NEXT: - { reg: '$x9', virtual-reg: '' }
229 ; 64BIT-NEXT: - { reg: '$x10', virtual-reg: '' }
230 ; 64BIT: body: |
231 ; 64BIT-NEXT: bb.0.entry:
232 ; 64BIT-NEXT: liveins: $x3, $x4, $x5, $x6, $x7, $x8, $x9, $x10
242 ; 64BIT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
243 ; 64BIT: renamable $x3 = LI8 1
244 ; 64BIT: renamable $x5 = RLDIC killed renamable $x3, 31, 32
245 ; 64BIT: $x3 = LI8 1
246 ; 64BIT: $x4 = LI8 1
247 ; 64BIT: $x6 = LIS8 32768
248 ; 64BIT: $x7 = LI8 1
249 ; 64BIT: $x8 = LI8 1
250 ; 64BIT: $x9 = LI8 1
251 ; 64BIT: $x10 = LI8 1
252 ; 64BIT: BL8_NOP <mcsymbol .test_ints>, csr_ppc64, implicit-def dead $lr8, implicit $rm, implicit …
253 ; 64BIT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
263 ; 32BIT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
264 ; 32BIT: $r3 = LI 0
265 ; 32BIT: $r4 = LI 1
266 ; 32BIT: $r5 = LI 0
267 ; 32BIT: $r6 = LI 2
268 ; 32BIT: $r7 = LI 0
269 ; 32BIT: $r8 = LI 3
270 ; 32BIT: $r9 = LI 0
271 ; 32BIT: $r10 = LI 4
272 ; 32BIT: BL_NOP <mcsymbol .test_i64>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit kill…
273 ; 32BIT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
275 ; 64BIT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
276 ; 64BIT: $x3 = LI8 1
277 ; 64BIT: $x4 = LI8 2
278 ; 64BIT: $x5 = LI8 3
279 ; 64BIT: $x6 = LI8 4
280 ; 64BIT: BL8_NOP <mcsymbol .test_i64>, csr_ppc64, implicit-def dead $lr8, implicit $rm, implicit ki…
281 ; 64BIT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
293 ; 32BIT: liveins:
294 ; 32BIT-NEXT: - { reg: '$r3', virtual-reg: '' }
295 ; 32BIT-NEXT: - { reg: '$r4', virtual-reg: '' }
296 ; 32BIT-NEXT: - { reg: '$r5', virtual-reg: '' }
297 ; 32BIT-NEXT: - { reg: '$r6', virtual-reg: '' }
298 ; 32BIT-NEXT: - { reg: '$r7', virtual-reg: '' }
299 ; 32BIT-NEXT: - { reg: '$r8', virtual-reg: '' }
300 ; 32BIT-NEXT: - { reg: '$r9', virtual-reg: '' }
301 ; 32BIT-NEXT: - { reg: '$r10', virtual-reg: '' }
302 ; 32BIT: body: |
303 ; 32BIT-NEXT: bb.0.entry:
304 ; 32BIT-NEXT: liveins: $r3, $r4, $r5, $r6, $r7, $r8, $r9, $r10
306 ; 64BIT: liveins:
307 ; 64BIT-NEXT: - { reg: '$x3', virtual-reg: '' }
308 ; 64BIT-NEXT: - { reg: '$x4', virtual-reg: '' }
309 ; 64BIT-NEXT: - { reg: '$x5', virtual-reg: '' }
310 ; 64BIT-NEXT: - { reg: '$x6', virtual-reg: '' }
311 ; 64BIT: body: |
312 ; 64BIT-NEXT: bb.0.entry:
313 ; 64BIT-NEXT: liveins: $x3, $x4, $x5, $x6
325 ; 32BIT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
326 ; 32BIT: renamable $r3 = ADDI %stack.0.b, 0
327 ; 32BIT: BL_NOP <mcsymbol .test_int_ptr>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit …
328 ; 32BIT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
330 ; 64BIT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
331 ; 64BIT: renamable $x3 = ADDI8 %stack.0.b, 0
332 ; 64BIT: BL8_NOP <mcsymbol .test_int_ptr>, csr_ppc64, implicit-def dead $lr8, implicit $rm, implici…
333 ; 64BIT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
344 ; 32BIT: liveins:
345 ; 32BIT-NEXT: - { reg: '$r3', virtual-reg: '' }
346 ; 32BIT: body: |
347 ; 32BIT-NEXT: bb.0.entry:
348 ; 32BIT-NEXT: liveins: $r3
349 ; 32BIT: STW killed renamable $r3, 0, %stack.0.a.addr :: (store (s32) into %ir.a.addr, al…
351 ; 64BIT: liveins:
352 ; 64BIT-NEXT: - { reg: '$x3', virtual-reg: '' }
353 ; 64BIT: body: |
354 ; 64BIT-NEXT: bb.0.entry:
355 ; 64BIT-NEXT: liveins: $x3
356 ; 64BIT: STD killed renamable $x3, 0, %stack.0.a.addr :: (store (s64) into %ir.a.addr)
378 ; 32BIT: liveins:
379 ; 32BIT-NEXT: - { reg: '$r3', virtual-reg: '' }
380 ; 32BIT: body: |
381 ; 32BIT-NEXT: bb.0.entry:
382 ; 32BIT: liveins: $r3
383 ; 32BIT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
384 ; 32BIT: BL_NOP <mcsymbol .call_test_bool[PR]>, csr_aix32, implicit-def dead $lr, implicit…
385 ; 32BIT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
387 ; 64BIT: liveins:
388 ; 64BIT-NEXT: - { reg: '$x3', virtual-reg: '' }
389 ; 64BIT: body: |
390 ; 64BIT-NEXT: bb.0.entry:
391 ; 64BIT-NEXT: liveins: $x3
392 ; 64BIT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
393 ; 64BIT: BL8_NOP <mcsymbol .call_test_bool[PR]>, csr_ppc64, implicit-def dead $lr8, implic…
394 ; 64BIT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
408 ; 32BIT: renamable $r3 = LWZtoc @f1, $r2 :: (load (s32) from got)
409 ; 32BIT-NEXT: renamable $f1 = LFS 0, killed renamable $r3 :: (dereferenceable load (s32) from @f1)
410 ; 32BIT-NEXT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
411 ; 32BIT-NEXT: $f2 = COPY renamable $f1
412 ; 32BIT-NEXT: $f3 = COPY renamable $f1
413 ; 32BIT-NEXT: BL_NOP <mcsymbol .test_floats>, csr_aix32, implicit-def dead $lr, implicit $rm, impli…
414 ; 32BIT-NEXT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
416 ; 64BIT: renamable $x3 = LDtoc @f1, $x2 :: (load (s64) from got)
417 ; 64BIT-NEXT: renamable $f1 = LFS 0, killed renamable $x3 :: (dereferenceable load (s32) from @f1)
418 ; 64BIT-NEXT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
419 ; 64BIT-NEXT: $f2 = COPY renamable $f1
420 ; 64BIT-NEXT: $f3 = COPY renamable $f1
421 ; 64BIT-NEXT: BL8_NOP <mcsymbol .test_floats>, csr_ppc64, implicit-def dead $lr8, implicit $rm, imp…
422 ; 64BIT-NEXT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
450 ; 32BIT: renamable $r[[REG:[0-9]+]] = LWZtoc @d1, $r2 :: (load (s32) from got)
451 ; 32BIT-NEXT: renamable $f1 = LFD 0, killed renamable $r[[REG]] :: (dereferenceable load (s64) from…
452 ; 32BIT-NEXT: ADJCALLSTACKDOWN 128, 0, implicit-def dead $r1, implicit $r1
453 ; 32BIT-DAG: STFD renamable $f1, 56, $r1 :: (store (s64))
454 ; 32BIT-DAG: STFD renamable $f1, 64, $r1 :: (store (s64))
455 ; 32BIT-DAG: STFD renamable $f1, 72, $r1 :: (store (s64))
456 ; 32BIT-DAG: STFD renamable $f1, 80, $r1 :: (store (s64))
457 ; 32BIT-DAG: STFD renamable $f1, 88, $r1 :: (store (s64))
458 ; 32BIT-DAG: STFD renamable $f1, 96, $r1 :: (store (s64))
459 ; 32BIT-DAG: STFD renamable $f1, 104, $r1 :: (store (s64))
460 ; 32BIT-DAG: STFD renamable $f1, 112, $r1 :: (store (s64))
461 ; 32BIT-DAG: STFD renamable $f1, 120, $r1 :: (store (s64))
462 ; 32BIT-DAG: $f2 = COPY renamable $f1
463 ; 32BIT-DAG: $f3 = COPY renamable $f1
464 ; 32BIT-DAG: $f4 = COPY renamable $f1
465 ; 32BIT-DAG: $f5 = COPY renamable $f1
466 ; 32BIT-DAG: $f6 = COPY renamable $f1
467 ; 32BIT-DAG: $f7 = COPY renamable $f1
468 ; 32BIT-DAG: $f8 = COPY renamable $f1
469 ; 32BIT-DAG: $f9 = COPY renamable $f1
470 ; 32BIT-DAG: $f10 = COPY renamable $f1
471 ; 32BIT-DAG: $f11 = COPY renamable $f1
472 ; 32BIT-DAG: $f12 = COPY renamable $f1
473 ; 32BIT-DAG: $f13 = COPY renamable $f1
474 ; 32BIT-NEXT: BL_NOP <mcsymbol .test_fpr_max>, csr_aix32, implicit-def dead $lr, implicit $rm, impl…
475 ; 32BIT-NEXT: ADJCALLSTACKUP 128, 0, implicit-def dead $r1, implicit $r1
507 ; 64BIT: renamable $x[[REGD1ADDR:[0-9]+]] = LDtoc @d1, $x2 :: (load (s64) from got)
508 ; 64BIT-NEXT: renamable $f1 = LFD 0, killed renamable $x[[REGD1ADDR:[0-9]+]] :: (dereferenceable lo…
509 ; 64BIT-NEXT: ADJCALLSTACKDOWN 152, 0, implicit-def dead $r1, implicit $r1
510 ; 64BIT-DAG: STFD renamable $f1, 112, $x1 :: (store (s64))
511 ; 64BIT-DAG: STFD renamable $f1, 120, $x1 :: (store (s64))
512 ; 64BIT-DAG: STFD renamable $f1, 128, $x1 :: (store (s64))
513 ; 64BIT-DAG: STFD renamable $f1, 136, $x1 :: (store (s64))
514 ; 64BIT-DAG: STFD renamable $f1, 144, $x1 :: (store (s64))
515 ; 64BIT-DAG: $f2 = COPY renamable $f1
516 ; 64BIT-DAG: $f3 = COPY renamable $f1
517 ; 64BIT-DAG: $f4 = COPY renamable $f1
518 ; 64BIT-DAG: $f5 = COPY renamable $f1
519 ; 64BIT-DAG: $f6 = COPY renamable $f1
520 ; 64BIT-DAG: $f7 = COPY renamable $f1
521 ; 64BIT-DAG: $f8 = COPY renamable $f1
522 ; 64BIT-DAG: $f9 = COPY renamable $f1
523 ; 64BIT-DAG: $f10 = COPY renamable $f1
524 ; 64BIT-DAG: $f11 = COPY renamable $f1
525 ; 64BIT-DAG: $f12 = COPY renamable $f1
526 ; 64BIT-DAG: $f13 = COPY renamable $f1
527 ; 64BIT-NEXT: BL8_NOP <mcsymbol .test_fpr_max>, csr_ppc64, implicit-def dead $lr8, implicit $rm, im…
528 ; 64BIT-NEXT: ADJCALLSTACKUP 152, 0, implicit-def dead $r1, implicit $r1
601 ; 32BIT: renamable $r[[REG1:[0-9]+]] = LWZtoc @f1, $r2 :: (load (s32) from got)
602 ; 32BIT-NEXT: renamable $r[[REG2:[0-9]+]] = LWZtoc @d1, $r2 :: (load (s32) from got)
603 ; 32BIT-NEXT: renamable $f1 = LFS 0, killed renamable $r[[REG1]] :: (dereferenceable load (s32) fro…
604 ; 32BIT-NEXT: renamable $f2 = LFD 0, killed renamable $r[[REG2]] :: (dereferenceable load (s64) fro…
605 ; 32BIT-NEXT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
606 ; 32BIT-NEXT: $r4 = LI 1
607 ; 32BIT-NEXT: $r7 = LI 97
608 ; 32BIT-NEXT: BL_NOP <mcsymbol .test_mix>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit…
609 ; 32BIT-NEXT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
611 ; 64BIT: renamable $x[[REG1:[0-9]+]] = LDtoc @f1, $x2 :: (load (s64) from got)
612 ; 64BIT-NEXT: renamable $x[[REG2:[0-9]+]] = LDtoc @d1, $x2 :: (load (s64) from got)
613 ; 64BIT-NEXT: renamable $f1 = LFS 0, killed renamable $x[[REG1]] :: (dereferenceable load (s32) fro…
614 ; 64BIT-NEXT: renamable $f2 = LFD 0, killed renamable $x[[REG2]] :: (dereferenceable load (s64) fro…
615 ; 64BIT-NEXT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
616 ; 64BIT-NEXT: $x4 = LI8 1
617 ; 64BIT-NEXT: $x6 = LI8 97
618 ; 64BIT-NEXT: BL8_NOP <mcsymbol .test_mix>, csr_ppc64, implicit-def dead $lr8, implicit $rm, implic…
619 ; 64BIT-NEXT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
636 ; 32BIT: liveins:
637 ; 32BIT-NEXT: - { reg: '$f1', virtual-reg: '' }
638 ; 32BIT-NEXT: - { reg: '$r4', virtual-reg: '' }
639 ; 32BIT-NEXT: - { reg: '$f2', virtual-reg: '' }
640 ; 32BIT-NEXT: - { reg: '$r7', virtual-reg: '' }
641 ; 32BIT: body: |
642 ; 32BIT-NEXT: bb.0.entry:
643 ; 32BIT-NEXT: liveins: $f1, $f2, $r4, $r7
645 ; 64BIT: liveins:
646 ; 64BIT-NEXT: - { reg: '$f1', virtual-reg: '' }
647 ; 64BIT-NEXT: - { reg: '$x4', virtual-reg: '' }
648 ; 64BIT-NEXT: - { reg: '$f2', virtual-reg: '' }
649 ; 64BIT-NEXT: - { reg: '$x6', virtual-reg: '' }
650 ; 64BIT: body: |
651 ; 64BIT-NEXT: bb.0.entry:
652 ; 64BIT-NEXT: liveins: $f1, $f2, $x4, $x6
669 ; 32BIT: liveins:
670 ; 32BIT-NEXT: - { reg: '$r3', virtual-reg: '' }
671 ; 32BIT-NEXT: - { reg: '$r4', virtual-reg: '' }
672 ; 32BIT-NEXT: - { reg: '$r5', virtual-reg: '' }
673 ; 32BIT-NEXT: - { reg: '$r6', virtual-reg: '' }
674 ; 32BIT-NEXT: - { reg: '$r7', virtual-reg: '' }
675 ; 32BIT-NEXT: - { reg: '$r8', virtual-reg: '' }
676 ; 32BIT: body: |
677 ; 32BIT-NEXT: bb.0.entry:
678 ; 32BIT-NEXT: liveins: $r3, $r4, $r5, $r6, $r7, $r8
680 ; 64BIT: liveins:
681 ; 64BIT-NEXT: - { reg: '$x3', virtual-reg: '' }
682 ; 64BIT-NEXT: - { reg: '$x4', virtual-reg: '' }
683 ; 64BIT-NEXT: - { reg: '$x5', virtual-reg: '' }
684 ; 64BIT-NEXT: - { reg: '$x6', virtual-reg: '' }
685 ; 64BIT-NEXT: - { reg: '$x7', virtual-reg: '' }
686 ; 64BIT: body: |
687 ; 64BIT-NEXT: bb.0.entry:
688 ; 64BIT-NEXT: liveins: $x3, $x4, $x5, $x6, $x7
703 ; 32BIT: renamable $r[[REG:[0-9]+]] = LWZtoc @f1, $r2 :: (load (s32) from got)
704 ; 32BIT-NEXT: renamable $f1 = LFS 0, killed renamable $r[[REG]] :: (dereferenceable load (s32) from…
705 ; 32BIT-NEXT: renamable $r[[REG:[0-9]+]] = LWZtoc @d1, $r2 :: (load (s32) from got)
706 ; 32BIT-NEXT: STFD renamable $f1, 0, %stack.[[SLOT1:[0-9]+]] :: (store (s64) into %stack.[[SLOT1]])
707 ; 32BIT-NEXT: renamable $r4 = LWZ 0, %stack.[[SLOT1]] :: (load (s32) from %stack.[[SLOT1]], align 8)
708 ; 32BIT-NEXT: renamable $f2 = LFD 0, killed renamable $r[[REG]] :: (dereferenceable load (s64) from…
709 ; 32BIT-NEXT: renamable $r5 = LWZ 4, %stack.[[SLOT1]] :: (load (s32) from %stack.[[SLOT1]] + 4)
710 ; 32BIT-NEXT: STFD renamable $f2, 0, %stack.[[SLOT2:[0-9]+]] :: (store (s64) into %stack.[[SLOT2]])
711 ; 32BIT-NEXT: renamable $r6 = LWZ 0, %stack.[[SLOT2]] :: (load (s32) from %stack.[[SLOT2]], align 8)
712 ; 32BIT-NEXT: renamable $r7 = LWZ 4, %stack.[[SLOT2]] :: (load (s32) from %stack.[[SLOT2]] + 4)
713 ; 32BIT-NEXT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
714 ; 32BIT-NEXT: $r3 = LI 42
715 ; 32BIT-NEXT: BL_NOP <mcsymbol .test_vararg[PR]>, csr_aix32, implicit-def dead $lr, implicit $rm, i…
716 ; 32BIT-NEXT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
735 ; 64BIT: renamable $x[[REG:[0-9]+]] = LDtoc @f1, $x2 :: (load (s64) from got)
736 ; 64BIT-NEXT: renamable $f1 = LFS 0, killed renamable $x[[REG]] :: (dereferenceable load (s32) from…
737 ; 64BIT-NEXT: renamable $x[[REG:[0-9]+]] = LDtoc @d1, $x2 :: (load (s64) from got)
738 ; 64BIT-NEXT: STFD renamable $f1, 0, %stack.[[SLOT1:[0-9]+]] :: (store (s64) into %stack.[[SLOT1]])
739 ; 64BIT-NEXT: renamable $f2 = LFD 0, killed renamable $x[[REG]] :: (dereferenceable load (s64) from…
740 ; 64BIT-NEXT: renamable $x4 = LD 0, %stack.[[SLOT1]] :: (load (s64) from %stack.[[SLOT1]])
741 ; 64BIT-NEXT: STFD renamable $f2, 0, %stack.[[SLOT2:[0-9]+]] :: (store (s64) into %stack.[[SLOT2]])
742 ; 64BIT-NEXT: renamable $x5 = LD 0, %stack.[[SLOT2]] :: (load (s64) from %stack.[[SLOT2]])
743 ; 64BIT-NEXT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
744 ; 64BIT-NEXT: $x3 = LI8 42
745 ; 64BIT-NEXT: BL8_NOP <mcsymbol .test_vararg[PR]>, csr_ppc64, implicit-def dead $lr8, implicit $rm,…
746 ; 64BIT-NEXT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
772 ; 32BIT: renamable $r[[REG:[0-9]+]] = LWZtoc @f1, $r2 :: (load (s32) from got)
773 ; 32BIT-NEXT: renamable $f1 = LFS 0, killed renamable $r[[REG]] :: (dereferenceable load (s32) from…
774 ; 32BIT-NEXT: renamable $r[[REG:[0-9]+]] = LWZtoc @d1, $r2 :: (load (s32) from got)
775 ; 32BIT-NEXT: STFD renamable $f1, 0, %stack.[[SLOT1:[0-9]+]] :: (store (s64) into %stack.[[SLOT1]])
776 ; 32BIT-NEXT: renamable $r4 = LWZ 0, %stack.[[SLOT1]] :: (load (s32) from %stack.[[SLOT1]], align 8)
777 ; 32BIT-NEXT: renamable $f2 = LFD 0, killed renamable $r[[REG]] :: (dereferenceable load (s64) from…
778 ; 32BIT-NEXT: renamable $r5 = LWZ 4, %stack.[[SLOT1]] :: (load (s32) from %stack.[[SLOT1]] + 4)
779 ; 32BIT-NEXT: STFD renamable $f2, 0, %stack.[[SLOT2:[0-9]+]] :: (store (s64) into %stack.[[SLOT2]])
780 ; 32BIT-NEXT: renamable $r7 = LWZ 0, %stack.[[SLOT2]] :: (load (s32) from %stack.[[SLOT2]], align 8)
781 ; 32BIT-NEXT: renamable $r8 = LWZ 4, %stack.[[SLOT2]] :: (load (s32) from %stack.[[SLOT2]] + 4)
782 ; 32BIT-NEXT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
783 ; 32BIT-NEXT: $r3 = LI 42
784 ; 32BIT-NEXT: $r6 = LI 42
785 ; 32BIT-NEXT: BL_NOP <mcsymbol .test_vararg[PR]>, csr_aix32, implicit-def dead $lr, implicit $rm, i…
786 ; 32BIT-NEXT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
804 ; 64BIT: renamable $x[[REG:[0-9]+]] = LDtoc @f1, $x2 :: (load (s64) from got)
805 ; 64BIT-NEXT: renamable $f1 = LFS 0, killed renamable $x[[REG]] :: (dereferenceable load (s32) from…
806 ; 64BIT-NEXT: renamable $x[[REG:[0-9]+]] = LDtoc @d1, $x2 :: (load (s64) from got)
807 ; 64BIT-NEXT: STFD renamable $f1, 0, %stack.[[SLOT1:[0-9]+]] :: (store (s64) into %stack.[[SLOT1]])
808 ; 64BIT-NEXT: renamable $f2 = LFD 0, killed renamable $x[[REG]] :: (dereferenceable load (s64) from…
809 ; 64BIT-NEXT: renamable $x4 = LD 0, %stack.[[SLOT1]] :: (load (s64) from %stack.[[SLOT1]])
810 ; 64BIT-NEXT: STFD renamable $f2, 0, %stack.[[SLOT2:[0-9]+]] :: (store (s64) into %stack.[[SLOT2]])
811 ; 64BIT-NEXT: renamable $x6 = LD 0, %stack.[[SLOT2]] :: (load (s64) from %stack.[[SLOT2]])
812 ; 64BIT-NEXT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
813 ; 64BIT-NEXT: $x3 = LI8 42
814 ; 64BIT-NEXT: $x5 = LI8 42
815 ; 64BIT-NEXT: BL8_NOP <mcsymbol .test_vararg[PR]>, csr_ppc64, implicit-def dead $lr8, implicit $rm,…
816 ; 64BIT-NEXT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
843 ; 32BIT: renamable $r[[REG:[0-9]+]] = LWZtoc @f1, $r2 :: (load (s32) from got)
844 ; 32BIT-NEXT: renamable $f1 = LFS 0, killed renamable $r[[REG]] :: (dereferenceable load (s32) from…
845 ; 32BIT-NEXT: renamable $r[[REG:[0-9]+]] = LWZtoc @d1, $r2 :: (load (s32) from got)
846 ; 32BIT-NEXT: STFD renamable $f1, 0, %stack.[[SLOT1:[0-9]+]] :: (store (s64) into %stack.[[SLOT1]])
847 ; 32BIT-NEXT: renamable $r4 = LWZ 0, %stack.[[SLOT1]] :: (load (s32) from %stack.[[SLOT1]], align 8)
848 ; 32BIT-NEXT: renamable $f2 = LFD 0, killed renamable $r[[REG]] :: (dereferenceable load (s64) from…
849 ; 32BIT-NEXT: renamable $r5 = LWZ 4, %stack.[[SLOT1]] :: (load (s32) from %stack.[[SLOT1]] + 4)
850 ; 32BIT-NEXT: STFD renamable $f2, 0, %stack.[[SLOT2:[0-9]+]] :: (store (s64) into %stack.[[SLOT2]])
851 ; 32BIT-NEXT: renamable $r8 = LWZ 0, %stack.[[SLOT2]] :: (load (s32) from %stack.[[SLOT2]], align 8)
852 ; 32BIT-NEXT: renamable $r9 = LWZ 4, %stack.[[SLOT2]] :: (load (s32) from %stack.[[SLOT2]] + 4)
853 ; 32BIT-NEXT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
854 ; 32BIT-NEXT: $r3 = LI 42
855 ; 32BIT-NEXT: $r6 = LI 0
856 ; 32BIT-NEXT: $r7 = LI 42
857 ; 32BIT-NEXT: BL_NOP <mcsymbol .test_vararg[PR]>, csr_aix32, implicit-def dead $lr, implicit $rm, i…
858 ; 32BIT-NEXT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
877 ; 64BIT: renamable $x[[REG:[0-9]+]] = LDtoc @f1, $x2 :: (load (s64) from got)
878 ; 64BIT-NEXT: renamable $f1 = LFS 0, killed renamable $x[[REG]] :: (dereferenceable load (s32) from…
879 ; 64BIT-NEXT: renamable $x[[REG:[0-9]+]] = LDtoc @d1, $x2 :: (load (s64) from got)
880 ; 64BIT-NEXT: STFD renamable $f1, 0, %stack.[[SLOT1:[0-9]+]] :: (store (s64) into %stack.[[SLOT1]])
881 ; 64BIT-NEXT: renamable $f2 = LFD 0, killed renamable $x[[REG]] :: (dereferenceable load (s64) from…
882 ; 64BIT-NEXT: renamable $x4 = LD 0, %stack.[[SLOT1]] :: (load (s64) from %stack.[[SLOT1]])
883 ; 64BIT-NEXT: STFD renamable $f2, 0, %stack.[[SLOT2:[0-9]+]] :: (store (s64) into %stack.[[SLOT2]])
884 ; 64BIT-NEXT: renamable $x6 = LD 0, %stack.[[SLOT2]] :: (load (s64) from %stack.[[SLOT2]])
885 ; 64BIT-NEXT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
886 ; 64BIT-NEXT: $x3 = LI8 42
887 ; 64BIT-NEXT: $x5 = LI8 42
888 ; 64BIT-NEXT: BL8_NOP <mcsymbol .test_vararg[PR]>, csr_ppc64, implicit-def dead $lr8, implicit $rm,…
889 ; 64BIT-NEXT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
914 ; 32BIT: renamable $r[[REG:[0-9]+]] = LWZtoc @f1, $r2 :: (load (s32) from got)
915 ; 32BIT-NEXT: renamable $f1 = LFS 0, killed renamable $r[[REG]] :: (dereferenceable load (s32) from…
916 ; 32BIT-NEXT: STFS renamable $f1, 0, %stack.[[SLOT:[0-9]+]] :: (store (s32) into %stack.[[SLOT]])
917 ; 32BIT-NEXT: renamable $r4 = LWZ 0, %stack.[[SLOT]] :: (load (s32) from %stack.[[SLOT]])
918 ; 32BIT-NEXT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
919 ; 32BIT-NEXT: $r3 = LI 42
920 ; 32BIT-NEXT: BL_NOP <mcsymbol .test_vararg[PR]>, csr_aix32, implicit-def dead $lr, implicit $rm, i…
921 ; 32BIT-NEXT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
932 ; 64BIT: renamable $x[[REG:[0-9]+]] = LDtoc @f1, $x2 :: (load (s64) from got)
933 ; 64BIT-NEXT: renamable $f1 = LFS 0, killed renamable $x[[REG]] :: (dereferenceable load (s32) from…
934 ; 64BIT-NEXT: STFS renamable $f1, 0, %stack.[[SLOT:[0-9]+]] :: (store (s32) into %stack.[[SLOT]])
935 ; 64BIT-NEXT: renamable $x4 = LWZ8 0, %stack.[[SLOT]] :: (load (s32) from %stack.[[SLOT]])
936 ; 64BIT-NEXT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
937 ; 64BIT-NEXT: $x3 = LI8 42
938 ; 64BIT-NEXT: BL8_NOP <mcsymbol .test_vararg[PR]>, csr_ppc64, implicit-def dead $lr8, implicit $rm,…
939 ; 64BIT-NEXT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
974 ; 32BIT-DAG: ADJCALLSTACKDOWN 80, 0, implicit-def dead $r1, implicit $r1
975 ; 32BIT-DAG: $r3 = LI 1
976 ; 32BIT-DAG: $r4 = LI 2
977 ; 32BIT-DAG: $r5 = LI 3
978 ; 32BIT-DAG: $r6 = LI 4
979 ; 32BIT-DAG: $r7 = LI 5
980 ; 32BIT-DAG: $r8 = LI 6
981 ; 32BIT-DAG: $r9 = LI 7
982 ; 32BIT-DAG: $r10 = LI 8
983 ; 32BIT-DAG: renamable $r[[REGCADDR:[0-9]+]] = LWZtoc @c, $r2 :: (load (s32) from got)
984 ; 32BIT-DAG: renamable $r[[REGC:[0-9]+]] = LBZ 0, killed renamable $r[[REGCADDR]] :: (dereferencea…
985 ; 32BIT-DAG: STW killed renamable $r[[REGC]], 56, $r1 :: (store (s32))
986 ; 32BIT-DAG: renamable $r[[REGSIADDR:[0-9]+]] = LWZtoc @si, $r2 :: (load (s32) from got)
987 ; 32BIT-DAG: renamable $r[[REGSI:[0-9]+]] = LHA 0, killed renamable $r[[REGSIADDR]] :: (dereferenc…
988 ; 32BIT-DAG: STW killed renamable $r[[REGSI]], 60, $r1 :: (store (s32))
989 ; 32BIT-DAG: renamable $r[[REGIADDR:[0-9]+]] = LWZtoc @i, $r2 :: (load (s32) from got)
990 ; 32BIT-DAG: renamable $r[[REGI:[0-9]+]] = LWZ 0, killed renamable $r[[REGIADDR]] :: (dereferencea…
991 ; 32BIT-DAG: STW killed renamable $r[[REGI]], 64, $r1 :: (store (s32))
992 ; 32BIT-DAG: renamable $r[[REGLLIADDR:[0-9]+]] = LWZtoc @lli, $r2 :: (load (s32) from got)
993 ; 32BIT-DAG: renamable $r[[REGLLI1:[0-9]+]] = LWZ 0, renamable $r[[REGLLIADDR]] :: (dereferenceabl…
994 ; 32BIT-DAG: STW killed renamable $r[[REGLLI1]], 68, $r1 :: (store (s32))
995 ; 32BIT-DAG: renamable $r[[REGLLI2:[0-9]+]] = LWZ 4, killed renamable $r[[REGLLIADDR]] :: (derefer…
996 ; 32BIT-DAG: STW killed renamable $r[[REGLLI2]], 72, $r1 :: (store (s32))
997 ; 32BIT-DAG: STW renamable $r[[REGI]], 76, $r1 :: (store (s32))
998 ; 32BIT-NEXT: BL_NOP <mcsymbol .test_stackarg_int[PR]>, csr_aix32, implicit-def dead $lr, implicit …
999 ; 32BIT-NEXT: ADJCALLSTACKUP 80, 0, implicit-def dead $r1, implicit $r1
1032 ; 64BIT-DAG: ADJCALLSTACKDOWN 152, 0, implicit-def dead $r1, implicit $r1
1033 ; 64BIT-DAG: $x3 = LI8 1
1034 ; 64BIT-DAG: $x4 = LI8 2
1035 ; 64BIT-DAG: $x5 = LI8 3
1036 ; 64BIT-DAG: $x6 = LI8 4
1037 ; 64BIT-DAG: $x7 = LI8 5
1038 ; 64BIT-DAG: $x8 = LI8 6
1039 ; 64BIT-DAG: $x9 = LI8 7
1040 ; 64BIT-DAG: $x10 = LI8 8
1041 ; 64BIT-DAG: renamable $x[[REGCADDR:[0-9]+]] = LDtoc @c, $x2 :: (load (s64) from got)
1042 ; 64BIT-DAG: renamable $x[[REGC:[0-9]+]] = LBZ8 0, killed renamable $x[[REGCADDR]] :: (dereferenc…
1043 ; 64BIT-DAG: STD killed renamable $x[[REGC]], 112, $x1 :: (store (s64))
1044 ; 64BIT-DAG: renamable $x[[REGSIADDR:[0-9]+]] = LDtoc @si, $x2 :: (load (s64) from got)
1045 ; 64BIT-DAG: renamable $x[[REGSI:[0-9]+]] = LHA8 0, killed renamable $x[[REGSIADDR]] :: (derefere…
1046 ; 64BIT-DAG: STD killed renamable $x[[REGSI]], 120, $x1 :: (store (s64))
1047 ; 64BIT-DAG: renamable $x[[REGIADDR:[0-9]+]] = LDtoc @i, $x2 :: (load (s64) from got)
1048 ; 64BIT-DAG: renamable $x[[REGI:[0-9]+]] = LWZ8 0, killed renamable $x[[REGIADDR]] :: (dereferenc…
1049 ; 64BIT-DAG: STD killed renamable $x[[REGI]], 128, $x1 :: (store (s64))
1050 ; 64BIT-DAG: renamable $x[[REGLLIADDR:[0-9]+]] = LDtoc @lli, $x2 :: (load (s64) from got)
1051 ; 64BIT-DAG: renamable $x[[REGLLI:[0-9]+]] = LD 0, killed renamable $x[[REGLLIADDR]] :: (derefere…
1052 ; 64BIT-DAG: STD killed renamable $x[[REGLLI]], 136, $x1 :: (store (s64))
1053 ; 64BIT-DAG: STD renamable $x[[REGI]], 144, $x1 :: (store (s64))
1054 ; 64BIT-NEXT: BL8_NOP <mcsymbol .test_stackarg_int[PR]>, csr_ppc64, implicit-def dead $lr8, implic…
1055 ; 64BIT-NEXT: ADJCALLSTACKUP 152, 0, implicit-def dead $r1, implicit $r1
1098 ; 32BIT-DAG: ADJCALLSTACKDOWN 68, 0, implicit-def dead $r1, implicit $r1
1099 ; 32BIT-DAG: $r3 = LI 1
1100 ; 32BIT-DAG: $r4 = LI 2
1101 ; 32BIT-DAG: $r5 = LI 3
1102 ; 32BIT-DAG: $r6 = LI 4
1103 ; 32BIT-DAG: $r7 = LI 5
1104 ; 32BIT-DAG: $r8 = LI 6
1105 ; 32BIT-DAG: $r9 = LI 7
1106 ; 32BIT-DAG: $r10 = LI 8
1107 ; 32BIT-DAG: renamable $r[[REGF:[0-9]+]] = LWZtoc @f, $r2 :: (load (s32) from got)
1108 ; 32BIT-DAG: renamable $f1 = LFS 0, killed renamable $r[[REGF]] :: (dereferenceable load (s32) fr…
1109 ; 32BIT-DAG: renamable $r[[REGD:[0-9]+]] = LWZtoc @d, $r2 :: (load (s32) from got)
1110 ; 32BIT-DAG: renamable $f2 = LFD 0, killed renamable $r[[REGD]] :: (dereferenceable load (s64) fr…
1111 ; 32BIT-DAG: STFS renamable $f1, 56, $r1 :: (store (s32))
1112 ; 32BIT-DAG: STFD renamable $f2, 60, $r1 :: (store (s64))
1113 ; 32BIT-NEXT: BL_NOP <mcsymbol .test_stackarg_float[PR]>, csr_aix32, implicit-def dead $lr, implic…
1114 ; 32BIT-NEXT: ADJCALLSTACKUP 68, 0, implicit-def dead $r1, implicit $r1
1139 ; 64BIT-DAG: ADJCALLSTACKDOWN 128, 0, implicit-def dead $r1, implicit $r1
1140 ; 64BIT-DAG: $x3 = LI8 1
1141 ; 64BIT-DAG: $x4 = LI8 2
1142 ; 64BIT-DAG: $x5 = LI8 3
1143 ; 64BIT-DAG: $x6 = LI8 4
1144 ; 64BIT-DAG: $x7 = LI8 5
1145 ; 64BIT-DAG: $x8 = LI8 6
1146 ; 64BIT-DAG: $x9 = LI8 7
1147 ; 64BIT-DAG: $x10 = LI8 8
1148 ; 64BIT-DAG: renamable $x[[REGF:[0-9]+]] = LDtoc @f, $x2 :: (load (s64) from got)
1149 ; 64BIT-DAG: renamable $f1 = LFS 0, killed renamable $x[[REGF]] :: (dereferenceable load (s32) fr…
1150 ; 64BIT-DAG: renamable $x[[REGD:[0-9]+]] = LDtoc @d, $x2 :: (load (s64) from got)
1151 ; 64BIT-DAG: renamable $f2 = LFD 0, killed renamable $x[[REGD]] :: (dereferenceable load (s64) fr…
1152 ; 64BIT-DAG: STFS renamable $f1, 112, $x1 :: (store (s32))
1153 ; 64BIT-DAG: STFD renamable $f2, 120, $x1 :: (store (s64))
1154 ; 64BIT-NEXT: BL8_NOP <mcsymbol .test_stackarg_float[PR]>, csr_ppc64, implicit-def dead $lr8, impl…
1155 ; 64BIT-NEXT: ADJCALLSTACKUP 128, 0, implicit-def dead $r1, implicit $r1
1189 ; 32BIT-DAG: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
1190 ; 32BIT-DAG: $r3 = LI 1
1191 ; 32BIT-DAG: $r4 = LI 2
1192 ; 32BIT-DAG: $r5 = LI 3
1193 ; 32BIT-DAG: $r6 = LI 4
1194 ; 32BIT-DAG: $r7 = LI 5
1195 ; 32BIT-DAG: $r8 = LI 6
1196 ; 32BIT-DAG: renamable $r[[REG:[0-9]+]] = LWZtoc @d, $r2 :: (load (s32) from got)
1197 ; 32BIT-DAG: renamable $f1 = LFD 0, killed renamable $r[[REG]] :: (dereferenceable load (s64) fro…
1198 ; 32BIT-DAG: STFD renamable $f1, 0, %stack.0 :: (store (s64) into %stack.0)
1199 ; 32BIT-DAG: renamable $r9 = LWZ 0, %stack.0 :: (load (s32) from %stack.0, align 8)
1200 ; 32BIT-DAG: renamable $r10 = LWZ 4, %stack.0 :: (load (s32) from %stack.0 + 4)
1201 ; 32BIT-NEXT: BL_NOP <mcsymbol .test_stackarg_float2[PR]>, csr_aix32, implicit-def dead $lr, impl…
1202 ; 32BIT-NEXT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
1224 ; 64BIT-DAG: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
1225 ; 64BIT-DAG: $x3 = LI8 1
1226 ; 64BIT-DAG: $x4 = LI8 2
1227 ; 64BIT-DAG: $x5 = LI8 3
1228 ; 64BIT-DAG: $x6 = LI8 4
1229 ; 64BIT-DAG: $x7 = LI8 5
1230 ; 64BIT-DAG: $x8 = LI8 6
1231 ; 64BIT-DAG: renamable $x[[REG:[0-9]+]] = LDtoc @d, $x2 :: (load (s64) from got)
1232 ; 64BIT-DAG: renamable $f1 = LFD 0, killed renamable $x[[REG]] :: (dereferenceable load (s64) fro…
1233 ; 64BIT-DAG: STFD renamable $f1, 0, %stack.0 :: (store (s64) into %stack.0)
1234 ; 64BIT-DAG: renamable $x9 = LD 0, %stack.0 :: (load (s64) from %stack.0)
1235 ; 64BIT-NEXT: BL8_NOP <mcsymbol .test_stackarg_float2[PR]>, csr_ppc64, implicit-def dead $lr8, imp…
1236 ; 64BIT-NEXT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
1269 ; 32BIT-DAG: ADJCALLSTACKDOWN 64, 0, implicit-def dead $r1, implicit $r1
1270 ; 32BIT-DAG: $r3 = LI 1
1271 ; 32BIT-DAG: $r4 = LI 2
1272 ; 32BIT-DAG: $r5 = LI 3
1273 ; 32BIT-DAG: $r6 = LI 4
1274 ; 32BIT-DAG: $r7 = LI 5
1275 ; 32BIT-DAG: $r8 = LI 6
1276 ; 32BIT-DAG: $r9 = LI 7
1277 ; 32BIT-DAG: renamable $r[[REGD:[0-9]+]] = LWZtoc @d, $r2 :: (load (s32) from got)
1278 ; 32BIT-DAG: renamable $f1 = LFD 0, killed renamable $r[[REGD]] :: (dereferenceable load (s64) fr…
1279 ; 32BIT-DAG: renamable $r[[REGF:[0-9]+]] = LWZtoc @f, $r2 :: (load (s32) from got)
1280 ; 32BIT-DAG: renamable $f2 = LFS 0, killed renamable $r[[REGF]] :: (dereferenceable load (s32) fr…
1281 ; 32BIT-DAG: STFD renamable $f1, 52, $r1 :: (store (s64))
1282 ; 32BIT-DAG: STFS renamable $f2, 60, $r1 :: (store (s32))
1283 ; 32BIT-DAG: STFD renamable $f1, 0, %stack.0 :: (store (s64) into %stack.0)
1284 ; 32BIT-DAG: renamable $r10 = LWZ 0, %stack.0 :: (load (s32) from %stack.0, align 8)
1285 ; 32BIT-NEXT: BL_NOP <mcsymbol .test_stackarg_float3[PR]>, csr_aix32, implicit-def dead $lr, impli…
1286 ; 32BIT-NEXT: ADJCALLSTACKUP 64, 0, implicit-def dead $r1, implicit $r1
1313 ; 64BIT-DAG: ADJCALLSTACKDOWN 120, 0, implicit-def dead $r1, implicit $r1
1314 ; 64BIT-DAG: $x3 = LI8 1
1315 ; 64BIT-DAG: $x4 = LI8 2
1316 ; 64BIT-DAG: $x5 = LI8 3
1317 ; 64BIT-DAG: $x6 = LI8 4
1318 ; 64BIT-DAG: $x7 = LI8 5
1319 ; 64BIT-DAG: $x8 = LI8 6
1320 ; 64BIT-DAG: $x9 = LI8 7
1321 ; 64BIT-DAG: renamable $x[[REGD:[0-9]+]] = LDtoc @d, $x2 :: (load (s64) from got)
1322 ; 64BIT-DAG: renamable $f1 = LFD 0, killed renamable $x[[REGD]] :: (dereferenceable load (s64) fr…
1323 ; 64BIT-DAG: renamable $x[[REGF:[0-9]+]] = LDtoc @f, $x2 :: (load (s64) from got)
1324 ; 64BIT-DAG: renamable $f2 = LFS 0, killed renamable $x[[REGF]] :: (dereferenceable load (s32) fr…
1325 ; 64BIT-DAG: STFS renamable $f2, 112, $x1 :: (store (s32))
1326 ; 64BIT-DAG: STFD renamable $f1, 0, %stack.0 :: (store (s64) into %stack.0)
1327 ; 64BIT-DAG: renamable $x10 = LD 0, %stack.0 :: (load (s64) from %stack.0)
1328 ; 64BIT-NEXT: BL8_NOP <mcsymbol .test_stackarg_float3[PR]>, csr_ppc64, implicit-def dead $lr8, imp…
1330 ; 64BIT-NEXT: ADJCALLSTACKUP 120, 0, implicit-def dead $r1, implicit $r1
1381 ; 32BIT-LABEL: liveins:
1382 ; 32BIT-DAG: - { reg: '$r3', virtual-reg: '' }
1383 ; 32BIT-DAG: - { reg: '$r4', virtual-reg: '' }
1384 ; 32BIT-DAG: - { reg: '$r5', virtual-reg: '' }
1385 ; 32BIT-DAG: - { reg: '$r6', virtual-reg: '' }
1386 ; 32BIT-DAG: - { reg: '$r7', virtual-reg: '' }
1387 ; 32BIT-DAG: - { reg: '$r8', virtual-reg: '' }
1388 ; 32BIT-DAG: - { reg: '$r9', virtual-reg: '' }
1389 ; 32BIT-DAG: - { reg: '$r10', virtual-reg: '' }
1391 ; 32BIT-LABEL: fixedStack:
1392 ; 32BIT-DAG: - { id: 9, type: default, offset: 56, size: 4
1393 ; 32BIT-DAG: - { id: 8, type: default, offset: 60, size: 4
1394 ; 32BIT-DAG: - { id: 7, type: default, offset: 64, size: 4
1395 ; 32BIT-DAG: - { id: 6, type: default, offset: 68, size: 4
1396 ; 32BIT-DAG: - { id: 5, type: default, offset: 72, size: 4
1397 ; 32BIT-DAG: - { id: 4, type: default, offset: 76, size: 4
1398 ; 32BIT-DAG: - { id: 3, type: default, offset: 80, size: 4
1399 ; 32BIT-DAG: - { id: 2, type: default, offset: 84, size: 4
1400 ; 32BIT-DAG: - { id: 1, type: default, offset: 88, size: 4
1401 ; 32BIT-DAG: - { id: 0, type: default, offset: 92, size: 4
1403 ; 32BIT-LABEL: body: |
1404 ; 32BIT-DAG: bb.0.entry:
1405 ; 32BIT-DAG: liveins: $r3, $r4, $r5, $r6, $r7, $r8, $r9, $r10
1407 ; 64BIT-LABEL: liveins:
1408 ; 64BIT-DAG: - { reg: '$x3', virtual-reg: '' }
1409 ; 64BIT-DAG: - { reg: '$x4', virtual-reg: '' }
1410 ; 64BIT-DAG: - { reg: '$x5', virtual-reg: '' }
1411 ; 64BIT-DAG: - { reg: '$x6', virtual-reg: '' }
1412 ; 64BIT-DAG: - { reg: '$x7', virtual-reg: '' }
1413 ; 64BIT-DAG: - { reg: '$x8', virtual-reg: '' }
1414 ; 64BIT-DAG: - { reg: '$x9', virtual-reg: '' }
1415 ; 64BIT-DAG: - { reg: '$x10', virtual-reg: '' }
1417 ; 64BIT-LABEL: fixedStack:
1418 ; 64BIT-DAG: - { id: 7, type: default, offset: 112, size: 8
1419 ; 64BIT-DAG: - { id: 6, type: default, offset: 124, size: 4
1420 ; 64BIT-DAG: - { id: 5, type: default, offset: 132, size: 4
1421 ; 64BIT-DAG: - { id: 4, type: default, offset: 140, size: 4
1422 ; 64BIT-DAG: - { id: 3, type: default, offset: 148, size: 4
1423 ; 64BIT-DAG: - { id: 2, type: default, offset: 152, size: 8
1424 ; 64BIT-DAG: - { id: 1, type: default, offset: 164, size: 4
1425 ; 64BIT-DAG: - { id: 0, type: default, offset: 172, size: 4
1426 ; 64BIT-DAG: body: |
1427 ; 64BIT-DAG: bb.0.entry:
1428 ; 64BIT-DAG: liveins: $x3, $x4, $x5, $x6, $x7, $x8, $x9, $x10
1477 ; 32BIT-DAG: $r3 = LI 1
1478 ; 32BIT-DAG: $r4 = LI 2
1479 ; 32BIT-DAG: $r5 = LI 3
1480 ; 32BIT-DAG: $r6 = LI 4
1481 ; 32BIT-DAG: $r7 = LI 5
1482 ; 32BIT-DAG: $r8 = LI 6
1483 ; 32BIT-DAG: $r9 = LI 7
1484 ; 32BIT-DAG: $r10 = LI 8
1485 ; 32BIT-DAG: renamable $r[[REGLL1ADDR:[0-9]+]] = LWZtoc @ll1, $r2 :: (load (s32) from got)
1486 ; 32BIT-DAG: renamable $r[[REGLL1A:[0-9]+]] = LWZ 0, renamable $r[[REGLL1ADDR]] :: (dereferenceab…
1487 ; 32BIT-DAG: renamable $r[[REGLL1B:[0-9]+]] = LWZ 4, killed renamable $r[[REGLL1ADDR]] :: (derefe…
1488 ; 32BIT-DAG: STW killed renamable $r[[REGLL1A]], 56, $r1 :: (store (s32))
1489 ; 32BIT-DAG: STW killed renamable $r[[REGLL1B]], 60, $r1 :: (store (s32))
1490 ; 32BIT-DAG: renamable $r[[REGSIADDR:[0-9]+]] = LWZtoc @si1, $r2 :: (load (s32) from got)
1491 ; 32BIT-DAG: renamable $r[[REGSI:[0-9]+]] = LHA 0, killed renamable $r[[REGSIADDR]] :: (dereferen…
1492 ; 32BIT-DAG: STW killed renamable $r[[REGSI]], 64, $r1 :: (store (s32))
1493 ; 32BIT-DAG: renamable $r[[REGCHADDR:[0-9]+]] = LWZtoc @ch, $r2 :: (load (s32) from got)
1494 ; 32BIT-DAG: renamable $r[[REGCH:[0-9]+]] = LBZ 0, killed renamable $r[[REGCHADDR]] :: (dereferen…
1495 ; 32BIT-DAG: STW killed renamable $r[[REGCH]], 68, $r1 :: (store (s32))
1496 ; 32BIT-DAG: renamable $r[[REGUIADDR:[0-9]+]] = LWZtoc @ui, $r2 :: (load (s32) from got)
1497 ; 32BIT-DAG: renamable $r[[REGUI:[0-9]+]] = LWZ 0, killed renamable $r[[REGUIADDR]] :: (dereferen…
1498 ; 32BIT-DAG: STW killed renamable $r[[REGUI]], 72, $r1 :: (store (s32))
1499 ; 32BIT-DAG: renamable $r[[REGSIADDR:[0-9]+]] = LWZtoc @sint, $r2 :: (load (s32) from got)
1500 ; 32BIT-DAG: renamable $r[[REGSI:[0-9]+]] = LWZ 0, killed renamable $r[[REGSIADDR]] :: (dereferen…
1501 ; 32BIT-DAG: STW killed renamable $r[[REGSI]], 76, $r1 :: (store (s32))
1502 ; 32BIT-DAG: renamable $r[[REGLL2ADDR:[0-9]+]] = LWZtoc @ll2, $r2 :: (load (s32) from got)
1503 ; 32BIT-DAG: renamable $r[[REGLL2A:[0-9]+]] = LWZ 0, renamable $r[[REGLL2ADDR]] :: (dereferenceab…
1504 ; 32BIT-DAG: renamable $r[[REGLL2B:[0-9]+]] = LWZ 4, killed renamable $r[[REGLL2ADDR]] :: (derefe…
1505 ; 32BIT-DAG: STW killed renamable $r[[REGLL2A]], 80, $r1 :: (store (s32))
1506 ; 32BIT-DAG: STW killed renamable $r[[REGLL2B]], 84, $r1 :: (store (s32))
1507 ; 32BIT-DAG: renamable $r[[REGUCADDR:[0-9]+]] = LWZtoc @uc1, $r2 :: (load (s32) from got)
1508 ; 32BIT-DAG: renamable $r[[REGUC:[0-9]+]] = LBZ 0, killed renamable $r[[REGUCADDR]] :: (dereferen…
1509 ; 32BIT-DAG: STW killed renamable $r[[REGUC]], 88, $r1 :: (store (s32))
1510 ; 32BIT-DAG: renamable $r[[REGIADDR:[0-9]+]] = LWZtoc @i1, $r2 :: (load (s32) from got)
1511 ; 32BIT-DAG: renamable $r[[REGI:[0-9]+]] = LWZ 0, killed renamable $r[[REGIADDR]] :: (dereference…
1512 ; 32BIT-DAG: STW killed renamable $r[[REGI]], 92, $r1 :: (store (s32))
1513 ; 32BIT-DAG: ADJCALLSTACKDOWN 96, 0, implicit-def dead $r1, implicit $r1
1514 ; 32BIT-NEXT: BL_NOP <mcsymbol .test_ints_stack>, csr_aix32, implicit-def dead $lr, implicit $rm, …
1515 ; 32BIT-NEXT: ADJCALLSTACKUP 96, 0, implicit-def dead $r1, implicit $r1
1517 ; 64BIT-DAG: $x3 = LI8 1
1518 ; 64BIT-DAG: $x4 = LI8 2
1519 ; 64BIT-DAG: $x5 = LI8 3
1520 ; 64BIT-DAG: $x6 = LI8 4
1521 ; 64BIT-DAG: $x7 = LI8 5
1522 ; 64BIT-DAG: $x8 = LI8 6
1523 ; 64BIT-DAG: $x9 = LI8 7
1524 ; 64BIT-DAG: $x10 = LI8 8
1525 ; 64BIT-DAG: renamable $x[[REGLL1ADDR:[0-9]+]] = LDtoc @ll1, $x2 :: (load (s64) from got)
1526 ; 64BIT-DAG: renamable $x[[REGLL1:[0-9]+]] = LD 0, killed renamable $x[[REGLL1ADDR]] :: (derefere…
1527 ; 64BIT-DAG: STD killed renamable $x[[REGLL1]], 112, $x1 :: (store (s64))
1528 ; 64BIT-DAG: renamable $x[[REGSIADDR:[0-9]+]] = LDtoc @si1, $x2 :: (load (s64) from got)
1529 ; 64BIT-DAG: renamable $x[[REGSI:[0-9]+]] = LHA8 0, killed renamable $x[[REGSIADDR]] :: (derefere…
1530 ; 64BIT-DAG: STD killed renamable $x[[REGSI]], 120, $x1 :: (store (s64))
1531 ; 64BIT-DAG: renamable $x[[REGCHADDR:[0-9]+]] = LDtoc @ch, $x2 :: (load (s64) from got)
1532 ; 64BIT-DAG: renamable $x[[REGCH:[0-9]+]] = LBZ8 0, killed renamable $x[[REGCHADDR]] :: (derefere…
1533 ; 64BIT-DAG: STD killed renamable $x[[REGCH]], 128, $x1 :: (store (s64))
1534 ; 64BIT-DAG: renamable $x[[REGUIADDR:[0-9]+]] = LDtoc @ui, $x2 :: (load (s64) from got)
1535 ; 64BIT-DAG: renamable $x[[REGUI:[0-9]+]] = LWZ8 0, killed renamable $x[[REGUIADDR]] :: (derefere…
1536 ; 64BIT-DAG: STD killed renamable $x[[REGUI]], 136, $x1 :: (store (s64))
1537 ; 64BIT-DAG: renamable $x[[REGSIADDR:[0-9]+]] = LDtoc @sint, $x2 :: (load (s64) from got)
1538 ; 64BIT-DAG: renamable $x[[REGSI:[0-9]+]] = LWZ8 0, killed renamable $x[[REGSIADDR]] :: (derefere…
1539 ; 64BIT-DAG: STD killed renamable $x[[REGSI]], 144, $x1 :: (store (s64))
1540 ; 64BIT-DAG: renamable $x[[REGLL2ADDR:[0-9]+]] = LDtoc @ll2, $x2 :: (load (s64) from got)
1541 ; 64BIT-DAG: renamable $x[[REGLL2:[0-9]+]] = LD 0, killed renamable $x[[REGLL2ADDR]] :: (derefere…
1542 ; 64BIT-DAG: STD killed renamable $x[[REGLL2]], 152, $x1 :: (store (s64))
1543 ; 64BIT-DAG: renamable $x[[REGUCADDR:[0-9]+]] = LDtoc @uc1, $x2 :: (load (s64) from got)
1544 ; 64BIT-DAG: renamable $x[[REGUC:[0-9]+]] = LBZ8 0, killed renamable $x[[REGUCADDR]] :: (derefere…
1545 ; 64BIT-DAG: STD killed renamable $x[[REGUC]], 160, $x1 :: (store (s64))
1546 ; 64BIT-DAG: renamable $x[[REGIADDR:[0-9]+]] = LDtoc @i1, $x2 :: (load (s64) from got)
1547 ; 64BIT-DAG: renamable $x[[REGI:[0-9]+]] = LWZ8 0, killed renamable $x[[REGIADDR]] :: (dereferenc…
1548 ; 64BIT-DAG: STD killed renamable $x[[REGI]], 168, $x1 :: (store (s64))
1549 ; 64BIT-DAG: ADJCALLSTACKDOWN 176, 0, implicit-def dead $r1, implicit $r1
1550 ; 64BIT-NEXT: BL8_NOP <mcsymbol .test_ints_stack>, csr_ppc64, implicit-def dead $lr8, implicit $rm…
1551 ; 64BIT-NEXT: ADJCALLSTACKUP 176, 0, implicit-def dead $r1, implicit $r1
1552 ; 64BIT-NEXT: BLR8 implicit $lr8, implicit $rm
1655 ; 32BIT-LABEL: fixedStack:
1656 ; 32BIT-DAG: - { id: 0, type: default, offset: 59, size: 1
1657 ; 32BIT-DAG: body: |
1658 ; 32BIT-DAG: bb.0.entry:
1659 ; 32BIT-DAG: renamable $r[[REGB:[0-9]+]] = LBZ 0, %fixed-stack.0 :: (load (s8) from %fixed-stac…
1660 ; 32BIT-DAG: renamable $r[[REGBTOC:[0-9]+]] = LWZtoc @globali1, $r2 :: (load (s32) from got)
1661 ; 32BIT-DAG: STB killed renamable $r[[REGB]], 0, killed renamable $r[[REGBTOC]] :: (store (s8) …
1663 ; 64BIT-LABEL: fixedStack:
1664 ; 64BIT-DAG: - { id: 0, type: default, offset: 119, size: 1
1665 ; 64BIT-DAG: body: |
1666 ; 64BIT-DAG: bb.0.entry:
1667 ; 64BIT-DAG: renamable $r[[REGB:[0-9]+]] = LBZ 0, %fixed-stack.0 :: (load (s8) from %fixed-st…
1668 ; 64BIT-DAG: renamable $x[[REGBTOC:[0-9]+]] = LDtoc @globali1, $x2 :: (load (s64) from got)
1669 ; 64BIT-DAG: STB killed renamable $r[[SCRATCHREG:[0-9]+]], 0, killed renamable $x[[REGBTOC]] …
1670 ; 64BIT-DAG: BLR8 implicit $lr8, implicit $rm
1692 ; 32BIT-DAG: ADJCALLSTACKDOWN 60, 0, implicit-def dead $r1, implicit $r1
1693 ; 32BIT-DAG: $r3 = LI 1
1694 ; 32BIT-DAG: $r4 = LI 2
1695 ; 32BIT-DAG: $r5 = LI 3
1696 ; 32BIT-DAG: $r6 = LI 4
1697 ; 32BIT-DAG: $r7 = LI 5
1698 ; 32BIT-DAG: $r8 = LI 6
1699 ; 32BIT-DAG: $r9 = LI 7
1700 ; 32BIT-DAG: $r10 = LI 8
1701 ; 32BIT-DAG: renamable $r[[REGBOOLADDR:[0-9]+]] = LI 1
1702 ; 32BIT-DAG: STW killed renamable $r[[REGBOOLADDR]], 56, $r1 :: (store (s32))
1703 ; 32BIT-DAG: BL_NOP <mcsymbol .test_i1_stack>, csr_aix32, implicit-def dead $lr, implicit $rm, im…
1704 ; 32BIT-DAG: ADJCALLSTACKUP 60, 0, implicit-def dead $r1, implicit $r1
1706 ; 64BIT-DAG: ADJCALLSTACKDOWN 120, 0, implicit-def dead $r1, implicit $r1
1707 ; 64BIT-DAG: $x3 = LI8 1
1708 ; 64BIT-DAG: $x4 = LI8 2
1709 ; 64BIT-DAG: $x5 = LI8 3
1710 ; 64BIT-DAG: $x6 = LI8 4
1711 ; 64BIT-DAG: $x7 = LI8 5
1712 ; 64BIT-DAG: $x8 = LI8 6
1713 ; 64BIT-DAG: $x9 = LI8 7
1714 ; 64BIT-DAG: $x10 = LI8 8
1715 ; 64BIT-DAG: renamable $x[[REGBOOLADDR:[0-9]+]] = LI8 1
1716 ; 64BIT-DAG: STD killed renamable $x[[REGBOOLADDR]], 112, $x1 :: (store (s64))
1717 ; 64BIT-DAG: BL8_NOP <mcsymbol .test_i1_stack>, csr_ppc64, implicit-def dead $lr8, implicit $rm, i…
1718 ; 64BIT-DAG: ADJCALLSTACKUP 120, 0, implicit-def dead $r1, implicit $r1
1776 ; 32BIT-DAG: - { id: 2, type: default, offset: 128, size: 4
1777 ; 32BIT-DAG: - { id: 1, type: default, offset: 132, size: 8
1778 ; 32BIT-DAG: - { id: 0, type: default, offset: 140, size: 4
1780 ; 64BIT-DAG: - { id: 2, type: default, offset: 152, size: 4
1781 ; 64BIT-DAG: - { id: 1, type: default, offset: 160, size: 8
1782 ; 64BIT-DAG: - { id: 0, type: default, offset: 168, size: 4
1819 ; 32BIT-DAG: renamable $r[[SCRATCHREG:[0-9]+]] = LWZtoc %const.0, $r2 :: (load (s32) from got)
1820 ; 32BIT-DAG: renamable $r[[SCRATCHREG:[0-9]+]] = LWZtoc %const.1, $r2 :: (load (s32) from got)
1821 ; 32BIT-DAG: renamable $r[[SCRATCHREG:[0-9]+]] = LWZtoc %const.2, $r2 :: (load (s32) from got)
1822 ; 32BIT-DAG: renamable $r[[SCRATCHREG:[0-9]+]] = LWZtoc %const.3, $r2 :: (load (s32) from got)
1823 ; 32BIT-DAG: renamable $r[[SCRATCHREG:[0-9]+]] = LWZtoc %const.4, $r2 :: (load (s32) from got)
1824 ; 32BIT-DAG: renamable $r[[SCRATCHREG:[0-9]+]] = LWZtoc %const.5, $r2 :: (load (s32) from got)
1825 ; 32BIT-DAG: renamable $r[[SCRATCHREG:[0-9]+]] = LWZtoc %const.6, $r2 :: (load (s32) from got)
1826 ; 32BIT-DAG: renamable $r[[SCRATCHREG:[0-9]+]] = LWZtoc %const.7, $r2 :: (load (s32) from got)
1827 ; 32BIT-DAG: renamable $r[[SCRATCHREG:[0-9]+]] = LWZtoc %const.8, $r2 :: (load (s32) from got)
1828 ; 32BIT-DAG: renamable $r[[SCRATCHREG:[0-9]+]] = LWZtoc %const.9, $r2 :: (load (s32) from got)
1829 ; 32BIT-DAG: renamable $r[[SCRATCHREG:[0-9]+]] = LWZtoc %const.10, $r2 :: (load (s32) from got)
1830 ; 32BIT-DAG: renamable $r[[SCRATCHREG:[0-9]+]] = LWZtoc %const.11, $r2 :: (load (s32) from got)
1831 ; 32BIT-DAG: STW killed renamable $r[[SCRATCHREG:[0-9]+]], 56, $r1 :: (store (s32), align 8)
1832 ; 32BIT-DAG: STW killed renamable $r[[SCRATCHREG:[0-9]+]], 60, $r1 :: (store (s32) into unknown-a…
1833 ; 32BIT-DAG: STW killed renamable $r[[SCRATCHREG:[0-9]+]], 64, $r1 :: (store (s32), align 8)
1834 ; 32BIT-DAG: STW killed renamable $r[[SCRATCHREG:[0-9]+]], 68, $r1 :: (store (s32) into unknown-a…
1835 ; 32BIT-DAG: STW killed renamable $r[[SCRATCHREG:[0-9]+]], 72, $r1 :: (store (s32), align 8)
1836 ; 32BIT-DAG: STW killed renamable $r[[SCRATCHREG:[0-9]+]], 76, $r1 :: (store (s32) into unknown-a…
1837 ; 32BIT-DAG: STW killed renamable $r[[SCRATCHREG:[0-9]+]], 80, $r1 :: (store (s32), align 8)
1838 ; 32BIT-DAG: STW renamable $r[[SCRATCHREG:[0-9]+]], 84, $r1 :: (store (s32) into unknown-address …
1839 ; 32BIT-DAG: STW killed renamable $r[[SCRATCHREG:[0-9]+]], 88, $r1 :: (store (s32), align 8)
1840 ; 32BIT-DAG: STW killed renamable $r[[SCRATCHREG:[0-9]+]], 92, $r1 :: (store (s32) into unknown-a…
1841 ; 32BIT-DAG: STW killed renamable $r[[SCRATCHREG:[0-9]+]], 96, $r1 :: (store (s32), align 8)
1842 ; 32BIT-DAG: STW killed renamable $r[[SCRATCHREG:[0-9]+]], 100, $r1 :: (store (s32) into unknown-…
1843 ; 32BIT-DAG: STW killed renamable $r[[SCRATCHREG:[0-9]+]], 104, $r1 :: (store (s32), align 8)
1844 ; 32BIT-DAG: STW killed renamable $r[[SCRATCHREG:[0-9]+]], 108, $r1 :: (store (s32) into unknown-…
1845 ; 32BIT-DAG: STW killed renamable $r[[SCRATCHREG:[0-9]+]], 112, $r1 :: (store (s32), align 8)
1846 ; 32BIT-DAG: STW killed renamable $r[[SCRATCHREG:[0-9]+]], 116, $r1 :: (store (s32) into unknown-…
1847 ; 32BIT-DAG: STW killed renamable $r[[SCRATCHREG:[0-9]+]], 120, $r1 :: (store (s32), align 8)
1848 ; 32BIT-DAG: STW killed renamable $r[[SCRATCHREG:[0-9]+]], 124, $r1 :: (store (s32) into unknown-…
1849 ; 32BIT-DAG: STW killed renamable $r[[SCRATCHREG:[0-9]+]], 128, $r1 :: (store (s32))
1850 ; 32BIT-DAG: renamable $r[[REGF1:[0-9]+]] = LWZtoc @f14, $r2 :: (load (s32) from got)
1851 ; 32BIT-DAG: renamable $r3 = LWZ 0, killed renamable $r[[REGF1]] :: (load (s32) from @f14)
1852 ; 32BIT-DAG: STFD killed renamable $f0, 132, $r1 :: (store (s64))
1853 ; 32BIT-DAG: renamable $r[[REGD:[0-9]+]] = LWZtoc @d15, $r2 :: (load (s32) from got)
1854 ; 32BIT-DAG: renamable $f0 = LFD 0, killed renamable $r[[REGD]] :: (dereferenceable load (s64) fr…
1855 ; 32BIT-DAG: STW killed renamable $r[[SCRATCHREG:[0-9]+]], 140, $r1 :: (store (s32))
1856 ; 32BIT-DAG: renamable $r[[REGF2:[0-9]+]] = LWZtoc @f16, $r2 :: (load (s32) from got)
1857 ; 32BIT-DAG: renamable $r[[SCRATCHREG:[0-9]+]] = LWZ 0, killed renamable $r[[REGF2]] :: (load (s3…
1858 ; 32BIT-DAG: renamable $f1 = LFD 0, killed renamable $r[[SCRATCHREG:[0-9]+]] :: (load (s64) from …
1859 ; 32BIT-DAG: renamable $f2 = LFD 0, killed renamable $r[[SCRATCHREG:[0-9]+]] :: (load (s64) from …
1860 ; 32BIT-DAG: renamable $f3 = LFD 0, killed renamable $r[[SCRATCHREG:[0-9]+]] :: (load (s64) from …
1861 ; 32BIT-DAG: renamable $f4 = LFD 0, killed renamable $r[[SCRATCHREG:[0-9]+]] :: (load (s64) from …
1862 ; 32BIT-DAG: renamable $f5 = LFS 0, killed renamable $r[[SCRATCHREG:[0-9]+]] :: (load (s32) from …
1863 ; 32BIT-DAG: renamable $f6 = LFD 0, killed renamable $r[[SCRATCHREG:[0-9]+]] :: (load (s64) from …
1864 ; 32BIT-DAG: renamable $f7 = LFD 0, killed renamable $r[[SCRATCHREG:[0-9]+]] :: (load (s64) from …
1865 ; 32BIT-DAG: renamable $f8 = LFD 0, killed renamable $r[[SCRATCHREG:[0-9]+]] :: (load (s64) from …
1866 ; 32BIT-DAG: renamable $f9 = LFD 0, killed renamable $r[[SCRATCHREG:[0-9]+]] :: (load (s64) from …
1867 ; 32BIT-DAG: $f10 = COPY renamable $f1
1868 ; 32BIT-DAG: renamable $f11 = LFD 0, killed renamable $r[[SCRATCHREG:[0-9]+]] :: (load (s64) from…
1869 ; 32BIT-DAG: renamable $f12 = LFD 0, killed renamable $r[[SCRATCHREG:[0-9]+]] :: (load (s64) from…
1870 ; 32BIT-DAG: renamable $f13 = LFD 0, killed renamable $r[[SCRATCHREG:[0-9]+]] :: (load (s64) from…
1871 ; 32BIT-NEXT: BL_NOP <mcsymbol .test_fpr_stack>, csr_aix32, implicit-def dead $lr, implicit $rm, i…
1872 ; 32BIT-NEXT: ADJCALLSTACKUP 144, 0, implicit-def dead $r1, implicit $r1
1874 ; 64BIT-DAG: renamable $x[[SCRATCHREG:[0-9]+]] = LDtocCPT %const.0, $x2 :: (load (s64) from got)
1875 ; 64BIT-DAG: renamable $x[[SCRATCHREG:[0-9]+]] = LDtocCPT %const.1, $x2 :: (load (s64) from got)
1876 ; 64BIT-DAG: renamable $x[[SCRATCHREG:[0-9]+]] = LDtocCPT %const.2, $x2 :: (load (s64) from got)
1877 ; 64BIT-DAG: renamable $x[[SCRATCHREG:[0-9]+]] = LDtocCPT %const.[[SCRATCHREG:[0-9]+]], $x2 :: (l…
1878 ; 64BIT-DAG: renamable $x[[SCRATCHREG:[0-9]+]] = LDtocCPT %const.4, $x2 :: (load (s64) from got)
1879 ; 64BIT-DAG: renamable $x[[SCRATCHREG:[0-9]+]] = LDtocCPT %const.5, $x2 :: (load (s64) from got)
1880 ; 64BIT-DAG: renamable $x[[SCRATCHREG:[0-9]+]] = LDtocCPT %const.6, $x2 :: (load (s64) from got)
1881 ; 64BIT-DAG: renamable $x[[SCRATCHREG:[0-9]+]] = LDtocCPT %const.7, $x2 :: (load (s64) from got)
1882 ; 64BIT-DAG: renamable $x[[SCRATCHREG:[0-9]+]] = LDtocCPT %const.8, $x2 :: (load (s64) from got)
1883 ; 64BIT-DAG: renamable $x[[SCRATCHREG:[0-9]+]] = LDtocCPT %const.9, $x2 :: (load (s64) from got)
1884 ; 64BIT-DAG: renamable $x[[SCRATCHREG:[0-9]+]] = LDtocCPT %const.10, $x2 :: (load (s64) from got)
1885 ; 64BIT-DAG: renamable $x[[REGF1:[0-9]+]] = LDtoc @f14, $x2 :: (load (s64) from got)
1886 ; 64BIT-DAG: renamable $r3 = LWZ 0, killed renamable $x[[REGF1]] :: (load (s32) from @f14)
1887 ; 64BIT-DAG: renamable $x[[REGF2:[0-9]+]] = LDtoc @f16, $x2 :: (load (s64) from got)
1888 ; 64BIT-DAG: renamable $r5 = LWZ 0, killed renamable $x[[REGF2]] :: (load (s32) from @f16)
1889 ; 64BIT-DAG: renamable $x[[REGD:[0-9]+]] = LDtoc @d15, $x2 :: (load (s64) from got)
1890 ; 64BIT-DAG: renamable $x4 = LD 0, killed renamable $x[[REGD]] :: (load (s64) from @d15)
1891 ; 64BIT-DAG: ADJCALLSTACKDOWN 176, 0, implicit-def dead $r1, implicit $r1
1892 ; 64BIT-DAG: renamable $f1 = LFD 0, killed renamable $x[[SCRATCHREG:[0-9]+]] :: (load (s64) from …
1893 ; 64BIT-DAG: renamable $f2 = LFD 0, killed renamable $x[[SCRATCHREG:[0-9]+]] :: (load (s64) from …
1894 ; 64BIT-DAG: renamable $f[[SCRATCHREG:[0-9]+]] = LFD 0, killed renamable $x[[SCRATCHREG:[0-9]+]] …
1895 ; 64BIT-DAG: renamable $f4 = LFD 0, killed renamable $x[[SCRATCHREG:[0-9]+]] :: (load (s64) from …
1896 ; 64BIT-DAG: renamable $f5 = LFS 0, killed renamable $x[[SCRATCHREG:[0-9]+]] :: (load (s32) from …
1897 ; 64BIT-DAG: renamable $f6 = LFD 0, killed renamable $x[[SCRATCHREG:[0-9]+]] :: (load (s64) from …
1898 ; 64BIT-DAG: renamable $f7 = LFD 0, killed renamable $x[[SCRATCHREG:[0-9]+]] :: (load (s64) from …
1899 ; 64BIT-DAG: renamable $f8 = LFD 0, killed renamable $x[[SCRATCHREG:[0-9]+]] :: (load (s64) from …
1900 ; 64BIT-DAG: renamable $f9 = LFD 0, killed renamable $x[[SCRATCHREG:[0-9]+]] :: (load (s64) from …
1901 ; 64BIT-DAG: $f10 = COPY renamable $f1
1902 ; 64BIT-DAG: renamable $f11 = LFD 0, killed renamable $x[[SCRATCHREG:[0-9]+]] :: (load (s64) from…
1903 ; 64BIT-DAG: renamable $f12 = LFD 0, killed renamable $x[[SCRATCHREG:[0-9]+]] :: (load (s64) from…
1904 ; 64BIT-DAG: renamable $f13 = LFD 0, killed renamable $x[[SCRATCHREG:[0-9]+]] :: (load (s64) from…
1905 ; 64BIT-DAG: BL8_NOP <mcsymbol .test_fpr_stack>, csr_ppc64, implicit-def dead $lr8, implicit $rm,…
1906 ; 64BIT-NEXT: ADJCALLSTACKUP 176, 0, implicit-def dead $r1, implicit $r1
1907 ; 64BIT-NEXT: BLR8 implicit $lr8, implicit $rm
1987 ; 32BIT-LABEL: liveins:
1988 ; 32BIT-DAG: - { reg: '$f1', virtual-reg: '' }
1989 ; 32BIT-DAG: - { reg: '$f2', virtual-reg: '' }
1990 ; 32BIT-DAG: - { reg: '$f3', virtual-reg: '' }
1991 ; 32BIT-DAG: - { reg: '$f4', virtual-reg: '' }
1993 ; 32BIT-LABEL: fixedStack:
1994 ; 32BIT-DAG: - { id: 6, type: default, offset: 56, size: 4
1995 ; 32BIT-DAG: - { id: 5, type: default, offset: 60, size: 4
1996 ; 32BIT-DAG: - { id: 4, type: default, offset: 64, size: 4
1997 ; 32BIT-DAG: - { id: 3, type: default, offset: 68, size: 4
1998 ; 32BIT-DAG: - { id: 2, type: default, offset: 72, size: 4
1999 ; 32BIT-DAG: - { id: 1, type: default, offset: 76, size: 4
2000 ; 32BIT-DAG: - { id: 0, type: default, offset: 80, size: 4
2002 ; 32BIT-LABEL: body: |
2003 ; 32BIT-DAG: bb.0.entry:
2004 ; 32BIT-DAG: liveins: $f1, $f2, $f3, $f4
2006 ; 64BIT-LABEL: liveins:
2007 ; 64BIT-DAG: - { reg: '$f1', virtual-reg: '' }
2008 ; 64BIT-DAG: - { reg: '$f2', virtual-reg: '' }
2009 ; 64BIT-DAG: - { reg: '$f3', virtual-reg: '' }
2010 ; 64BIT-DAG: - { reg: '$f4', virtual-reg: '' }
2011 ; 64BIT-DAG: - { reg: '$x7', virtual-reg: '' }
2012 ; 64BIT-DAG: - { reg: '$x8', virtual-reg: '' }
2013 ; 64BIT-DAG: - { reg: '$x9', virtual-reg: '' }
2014 ; 64BIT-DAG: - { reg: '$x10', virtual-reg: '' }
2016 ; 64BIT-LABEL: fixedStack:
2017 ; 64BIT-DAG: - { id: 1, type: default, offset: 116, size: 4
2018 ; 64BIT-DAG: - { id: 0, type: default, offset: 124, size: 4
2020 ; 64BIT-LABEL: body: |
2021 ; 64BIT-DAG: bb.0.entry:
2022 ; 64BIT-DAG: liveins: $f1, $f2, $f3, $f4, $x7, $x8, $x9, $x10
2048 ; 32BIT-DAG: ADJCALLSTACKDOWN 84, 0, implicit-def dead $r1, implicit $r1
2049 ; 32BIT-DAG: renamable $r[[SCRATCHREG:[0-9]+]] = LWZtoc %const.0, $r2 :: (load (s32) from got)
2050 ; 32BIT-DAG: renamable $f1 = LFD 0, killed renamable $r[[SCRATCHREG:[0-9]+]] :: (load (s64) from …
2051 ; 32BIT-DAG: renamable $r[[SCRATCHREG:[0-9]+]] = LWZtoc %const.1, $r2 :: (load (s32) from got)
2052 ; 32BIT-DAG: renamable $f2 = LFD 0, killed renamable $r[[SCRATCHREG:[0-9]+]] :: (load (s64) from …
2053 ; 32BIT-DAG: renamable $r[[SCRATCHREG:[0-9]+]] = LWZtoc %const.2, $r2 :: (load (s32) from got)
2054 ; 32BIT-DAG: renamable $f3 = LFD 0, killed renamable $r[[SCRATCHREG:[0-9]+]] :: (load (s64) from …
2055 ; 32BIT-DAG: renamable $r[[SCRATCHREG:[0-9]+]] = LWZtoc %const.3, $r2 :: (load (s32) from got)
2056 ; 32BIT-DAG: renamable $f4 = LFD 0, killed renamable $r[[SCRATCHREG:[0-9]+]] :: (load (s64) from …
2057 ; 32BIT-DAG: renamable $r[[SCRATCHREG:[0-9]+]] = LI 1
2058 ; 32BIT-DAG: renamable $r[[SCRATCHREG:[0-9]+]] = LI 2
2059 ; 32BIT-DAG: renamable $r[[SCRATCHREG:[0-9]+]] = LIS 457
2060 ; 32BIT-DAG: renamable $r[[SCRATCHREG:[0-9]+]] = LI 0
2061 ; 32BIT-DAG: renamable $r[[SCRATCHREG:[0-9]+]] = LI 40
2062 ; 32BIT-DAG: renamable $r[[SCRATCHREG:[0-9]+]] = LI 50
2063 ; 32BIT-DAG: renamable $r[[SCRATCHREG:[0-9]+]] = LI 60
2064 ; 32BIT-DAG: STW killed renamable $r[[REG1:[0-9]+]], 56, $r1 :: (store (s32))
2065 ; 32BIT-DAG: STW killed renamable $r[[REG2:[0-9]+]], 60, $r1 :: (store (s32))
2066 ; 32BIT-DAG: STW killed renamable $r[[REG3:[0-9]+]], 64, $r1 :: (store (s32))
2067 ; 32BIT-DAG: STW killed renamable $r[[REG4:[0-9]+]], 68, $r1 :: (store (s32))
2068 ; 32BIT-DAG: STW killed renamable $r[[REG5:[0-9]+]], 72, $r1 :: (store (s32))
2069 ; 32BIT-DAG: STW killed renamable $r[[REG6:[0-9]+]], 76, $r1 :: (store (s32))
2070 ; 32BIT-DAG: STW killed renamable $r[[REG7:[0-9]+]], 80, $r1 :: (store (s32))
2071 ; 32BIT-DAG: BL_NOP <mcsymbol .mix_callee>, csr_aix32, implicit-def dead $lr, implicit $rm, impli…
2072 ; 32BIT-DAG: ADJCALLSTACKUP 84, 0, implicit-def dead $r1, implicit $r1
2073 ; 32BIT-NEXT: BLR implicit $lr, implicit $rm
2075 ; 64BIT-DAG: ADJCALLSTACKDOWN 128, 0, implicit-def dead $r1, implicit $r1
2076 ; 64BIT-DAG: renamable $x[[SCRATCHREG:[0-9]+]] = LDtocCPT %const.0, $x2 :: (load (s64) from got)
2077 ; 64BIT-DAG: renamable $x[[SCRATCHREG:[0-9]+]] = LDtocCPT %const.1, $x2 :: (load (s64) from got)
2078 ; 64BIT-DAG: renamable $x[[SCRATCHREG:[0-9]+]] = LDtocCPT %const.2, $x2 :: (load (s64) from got)
2079 ; 64BIT-DAG: renamable $x[[SCRATCHREG:[0-9]+]] = LDtocCPT %const.3, $x2 :: (load (s64) from got)
2080 ; 64BIT-DAG: renamable $f1 = LFD 0, killed renamable $x[[SCRATCHREG:[0-9]+]] :: (load (s64) from …
2081 ; 64BIT-DAG: renamable $f2 = LFD 0, killed renamable $x[[SCRATCHREG:[0-9]+]] :: (load (s64) from …
2082 ; 64BIT-DAG: renamable $f3 = LFD 0, killed renamable $x[[SCRATCHREG:[0-9]+]] :: (load (s64) from …
2083 ; 64BIT-DAG: renamable $f4 = LFD 0, killed renamable $x[[SCRATCHREG:[0-9]+]] :: (load (s64) from …
2084 ; 64BIT-DAG: renamable $x[[SCRATCHREG:[0-9]+]] = LI8 50
2085 ; 64BIT-DAG: renamable $x[[SCRATCHREG:[0-9]+]] = LI8 60
2086 ; 64BIT-DAG: renamable $x[[SCRATCHREG:[0-9]+]] = LIS8 457
2087 ; 64BIT-DAG: $x7 = LI8 1
2088 ; 64BIT-DAG: $x8 = LI8 2
2089 ; 64BIT-DAG: $x10 = LI8 40
2090 ; 64BIT-DAG: STD killed renamable $x[[REG1:[0-9]+]], 112, $x1 :: (store (s64))
2091 ; 64BIT-DAG: STD killed renamable $x[[REG2:[0-9]+]], 120, $x1 :: (store (s64))
2092 ; 64BIT: ADJCALLSTACKUP 128, 0, implicit-def dead $r1, implicit $r1
2093 ; 64BIT-NEXT: BLR8 implicit $lr8, implicit $rm
2145 ; 32BIT-LABEL: liveins:
2146 ; 32BIT-DAG: - { reg: '$r3', virtual-reg: '' }
2147 ; 32BIT-DAG: - { reg: '$r4', virtual-reg: '' }
2148 ; 32BIT-DAG: - { reg: '$r5', virtual-reg: '' }
2149 ; 32BIT-DAG: - { reg: '$r6', virtual-reg: '' }
2150 ; 32BIT-DAG: - { reg: '$r7', virtual-reg: '' }
2151 ; 32BIT-DAG: - { reg: '$r8', virtual-reg: '' }
2152 ; 32BIT-DAG: - { reg: '$r9', virtual-reg: '' }
2153 ; 32BIT-DAG: - { reg: '$r10', virtual-reg: '' }
2154 ; 32BIT-DAG: - { reg: '$f1', virtual-reg: '' }
2155 ; 32BIT-DAG: - { reg: '$f2', virtual-reg: '' }
2156 ; 32BIT-DAG: - { reg: '$f3', virtual-reg: '' }
2157 ; 32BIT-DAG: - { reg: '$f4', virtual-reg: '' }
2158 ; 32BIT-DAG: - { reg: '$f5', virtual-reg: '' }
2159 ; 32BIT-DAG: - { reg: '$f6', virtual-reg: '' }
2160 ; 32BIT-DAG: - { reg: '$f7', virtual-reg: '' }
2161 ; 32BIT-DAG: - { reg: '$f8', virtual-reg: '' }
2162 ; 32BIT-DAG: - { reg: '$f9', virtual-reg: '' }
2163 ; 32BIT-DAG: - { reg: '$f10', virtual-reg: '' }
2164 ; 32BIT-DAG: - { reg: '$f11', virtual-reg: '' }
2165 ; 32BIT-DAG: - { reg: '$f12', virtual-reg: '' }
2166 ; 32BIT-DAG: - { reg: '$f13', virtual-reg: '' }
2168 ; 32BIT-LABEL: fixedStack:
2169 ; 32BIT-DAG: - { id: 0, type: default, offset: 160, size: 8
2171 ; 32BIT-LABEL: body: |
2172 ; 32BIT-DAG: bb.0.entry:
2173 ; 32BIT-DAG: liveins: $f1, $f2, $f3, $f4, $f5, $f6, $f7, $f8, $f9, $f10, $f11, $f12, $f13, $r…
2175 ; 64BIT-DAG: liveins:
2176 ; 64BIT-DAG: - { reg: '$x3', virtual-reg: '' }
2177 ; 64BIT-DAG: - { reg: '$x4', virtual-reg: '' }
2178 ; 64BIT-DAG: - { reg: '$x5', virtual-reg: '' }
2179 ; 64BIT-DAG: - { reg: '$x6', virtual-reg: '' }
2180 ; 64BIT-DAG: - { reg: '$x7', virtual-reg: '' }
2181 ; 64BIT-DAG: - { reg: '$x8', virtual-reg: '' }
2182 ; 64BIT-DAG: - { reg: '$x9', virtual-reg: '' }
2183 ; 64BIT-DAG: - { reg: '$x10', virtual-reg: '' }
2184 ; 64BIT-DAG: - { reg: '$f1', virtual-reg: '' }
2185 ; 64BIT-DAG: - { reg: '$f2', virtual-reg: '' }
2186 ; 64BIT-DAG: - { reg: '$f3', virtual-reg: '' }
2187 ; 64BIT-DAG: - { reg: '$f4', virtual-reg: '' }
2188 ; 64BIT-DAG: - { reg: '$f5', virtual-reg: '' }
2189 ; 64BIT-DAG: - { reg: '$f6', virtual-reg: '' }
2190 ; 64BIT-DAG: - { reg: '$f7', virtual-reg: '' }
2191 ; 64BIT-DAG: - { reg: '$f8', virtual-reg: '' }
2192 ; 64BIT-DAG: - { reg: '$f9', virtual-reg: '' }
2193 ; 64BIT-DAG: - { reg: '$f10', virtual-reg: '' }
2194 ; 64BIT-DAG: - { reg: '$f11', virtual-reg: '' }
2195 ; 64BIT-DAG: - { reg: '$f12', virtual-reg: '' }
2196 ; 64BIT-DAG: - { reg: '$f13', virtual-reg: '' }
2198 ; 64BIT-LABEL: fixedStack:
2199 ; 64BIT-DAG: - { id: 0, type: default, offset: 216, size: 8
2201 ; 64BIT-LABEL: body: |
2202 ; 64BIT-DAG: bb.0.entry:
2203 ; 64BIT-DAG: liveins: $f1, $f2, $f3, $f4, $f5, $f6, $f7, $f8, $f9, $f10, $f11, $f12, $f13, $x…
2223 ; 32BIT-DAG: ADJCALLSTACKDOWN 168, 0, implicit-def dead $r1, implicit $r1
2224 ; 32BIT-DAG: $r3 = LI 1
2225 ; 32BIT-DAG: $r4 = LI 2
2226 ; 32BIT-DAG: $r5 = LI 3
2227 ; 32BIT-DAG: $r6 = LI 4
2228 ; 32BIT-DAG: $r7 = LI 5
2229 ; 32BIT-DAG: $r8 = LI 6
2230 ; 32BIT-DAG: $r9 = LI 7
2231 ; 32BIT-DAG: $r10 = LI 8
2232 ; 32BIT-DAG: STW killed renamable $r[[REG1:[0-9]+]], 56, $r1 :: (store (s32), align 8)
2233 ; 32BIT-DAG: STW renamable $r[[REG2:[0-9]+]], 60, $r1 :: (store (s32) into unknown-address + 4, b…
2234 ; 32BIT-DAG: STW killed renamable $r[[REG3:[0-9]+]], 64, $r1 :: (store (s32), align 8)
2235 ; 32BIT-DAG: STW renamable $r[[REG4:[0-9]+]], 68, $r1 :: (store (s32) into unknown-address + 4, b…
2236 ; 32BIT-DAG: STW killed renamable $r[[REG5:[0-9]+]], 72, $r1 :: (store (s32), align 8)
2237 ; 32BIT-DAG: STW renamable $r[[REG6:[0-9]+]], 76, $r1 :: (store (s32) into unknown-address + 4, b…
2238 ; 32BIT-DAG: STW killed renamable $r[[REG7:[0-9]+]], 80, $r1 :: (store (s32), align 8)
2239 ; 32BIT-DAG: STW renamable $r[[REG8:[0-9]+]], 84, $r1 :: (store (s32) into unknown-address + 4, b…
2240 ; 32BIT-DAG: STW killed renamable $r[[REG9:[0-9]+]], 88, $r1 :: (store (s32), align 8)
2241 ; 32BIT-DAG: STW renamable $r[[REG10:[0-9]+]], 92, $r1 :: (store (s32) into unknown-address + 4, …
2242 ; 32BIT-DAG: STW killed renamable $r[[REG11:[0-9]+]], 96, $r1 :: (store (s32), align 8)
2243 ; 32BIT-DAG: STW renamable $r[[REG12:[0-9]+]], 100, $r1 :: (store (s32) into unknown-address + 4,…
2244 ; 32BIT-DAG: STW killed renamable $r[[REG13:[0-9]+]], 104, $r1 :: (store (s32), align 8)
2245 ; 32BIT-DAG: STW renamable $r[[REG14:[0-9]+]], 108, $r1 :: (store (s32) into unknown-address + 4,…
2246 ; 32BIT-DAG: STW killed renamable $r[[REG15:[0-9]+]], 112, $r1 :: (store (s32), align 8)
2247 ; 32BIT-DAG: STW renamable $r[[REG16:[0-9]+]], 116, $r1 :: (store (s32) into unknown-address + 4,…
2248 ; 32BIT-DAG: STW killed renamable $r[[REG17:[0-9]+]], 120, $r1 :: (store (s32), align 8)
2249 ; 32BIT-DAG: STW killed renamable $r[[REG18:[0-9]+]], 128, $r1 :: (store (s32), align 8)
2250 ; 32BIT-DAG: STW renamable $r[[REG19:[0-9]+]], 124, $r1 :: (store (s32) into unknown-address + 4,…
2251 ; 32BIT-DAG: STW killed renamable $r[[REG20:[0-9]+]], 132, $r1 :: (store (s32) into unknown-addre…
2252 ; 32BIT-DAG: STW killed renamable $r[[REG21:[0-9]+]], 136, $r1 :: (store (s32), align 8)
2253 ; 32BIT-DAG: STW killed renamable $r[[REG22:[0-9]+]], 140, $r1 :: (store (s32) into unknown-addre…
2254 ; 32BIT-DAG: STW killed renamable $r[[REG23:[0-9]+]], 144, $r1 :: (store (s32), align 8)
2255 ; 32BIT-DAG: STW killed renamable $r[[REG24:[0-9]+]], 148, $r1 :: (store (s32) into unknown-addre…
2256 ; 32BIT-DAG: STW killed renamable $r[[REG25:[0-9]+]], 152, $r1 :: (store (s32), align 8)
2257 ; 32BIT-DAG: STW killed renamable $r[[REG26:[0-9]+]], 156, $r1 :: (store (s32) into unknown-addre…
2258 ; 32BIT-DAG: STW killed renamable $r[[REG27:[0-9]+]], 160, $r1 :: (store (s32), align 8)
2259 ; 32BIT-DAG: STW killed renamable $r[[REG28:[0-9]+]], 164, $r1 :: (store (s32) into unknown-addre…
2260 ; 32BIT-NEXT: BL_NOP <mcsymbol .mix_floats>, csr_aix32, implicit-def dead $lr, implicit $rm, impli…
2261 ; 32BIT-NEXT: ADJCALLSTACKUP 168, 0, implicit-def dead $r1, implicit $r1
2264 ; 64BIT-DAG: ADJCALLSTACKDOWN 224, 0, implicit-def dead $r1, implicit $r1
2265 ; 64BIT-DAG: $x3 = LI8 1
2266 ; 64BIT-DAG: $x4 = LI8 2
2267 ; 64BIT-DAG: $x5 = LI8 3
2268 ; 64BIT-DAG: $x6 = LI8 4
2269 ; 64BIT-DAG: $x7 = LI8 5
2270 ; 64BIT-DAG: $x8 = LI8 6
2271 ; 64BIT-DAG: $x9 = LI8 7
2272 ; 64BIT-DAG: $x10 = LI8 8
2273 ; 64BIT-DAG: STD killed renamable $x[[REG1:[0-9]+]], 112, $x1 :: (store (s64))
2274 ; 64BIT-DAG: STD killed renamable $x[[REG2:[0-9]+]], 120, $x1 :: (store (s64))
2275 ; 64BIT-DAG: STD killed renamable $x[[REG3:[0-9]+]], 128, $x1 :: (store (s64))
2276 ; 64BIT-DAG: STD killed renamable $x[[REG4:[0-9]+]], 136, $x1 :: (store (s64))
2277 ; 64BIT-DAG: STD killed renamable $x[[REG5:[0-9]+]], 144, $x1 :: (store (s64))
2278 ; 64BIT-DAG: STD killed renamable $x[[REG6:[0-9]+]], 152, $x1 :: (store (s64))
2279 ; 64BIT-DAG: STD killed renamable $x[[REG7:[0-9]+]], 160, $x1 :: (store (s64))
2280 ; 64BIT-DAG: STD killed renamable $x[[REG8:[0-9]+]], 168, $x1 :: (store (s64))
2281 ; 64BIT-DAG: STD killed renamable $x[[REG9:[0-9]+]], 176, $x1 :: (store (s64))
2282 ; 64BIT-DAG: STD killed renamable $x[[REG10:[0-9]+]], 184, $x1 :: (store (s64))
2283 ; 64BIT-DAG: STD killed renamable $x[[REG12:[0-9]+]], 192, $x1 :: (store (s64))
2284 ; 64BIT-DAG: STD killed renamable $x[[REG13:[0-9]+]], 200, $x1 :: (store (s64))
2285 ; 64BIT-DAG: STD killed renamable $x[[REG14:[0-9]+]], 208, $x1 :: (store (s64))
2286 ; 64BIT-DAG: STD killed renamable $x[[REG15:[0-9]+]], 216, $x1 :: (store (s64))
2287 ; 64BIT-DAG: BL8_NOP <mcsymbol .mix_floats>, csr_ppc64, implicit-def dead $lr8, implicit $rm, imp…
2288 ; 64BIT-NEXT: ADJCALLSTACKUP 224, 0, implicit-def dead $r1, implicit $r1