Lines Matching refs:BIT

4 ; RUN: FileCheck --check-prefixes=CHECK,32BIT %s
13 ; RUN: FileCheck --check-prefixes=CHECK,64BIT %s
55 ; 32BIT:       fixedStack:
56 ; 32BIT-NEXT:    - { id: 0, type: default, offset: 56, size: 4, alignment: 8, stack-id: default,
57 ; 32BIT:       bb.0.entry:
58 ; 32BIT-NEXT:    %[[VAL:[0-9]+]]:gprc = LBZ 0, %fixed-stack.0
59 ; 32BIT-NEXT:    $r3 = COPY %[[VAL]]
60 ; 32BIT-NEXT:    BLR
62 ; 64BIT:       fixedStack:
63 ; 64BIT-NEXT:    - { id: 0, type: default, offset: 112, size: 8, alignment: 16, stack-id: default,
64 ; 64BIT:       bb.0.entry:
65 ; 64BIT-NEXT:    %[[VAL:[0-9]+]]:g8rc = LBZ8 0, %fixed-stack.0
66 ; 64BIT-NEXT:    $x3 = COPY %[[VAL]]
67 ; 64BIT-NEXT:    BLR8
84 ; 32BIT:          ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
85 ; 32BIT-NEXT:     %0:gprc = nuw ADDI $r1, 56
86 ; 32BIT-NEXT:     %1:gprc = LWZtoc @gS256, $r2 :: (load 4 from got)
87 ; 32BIT-NEXT:     %2:gprc = LI 256
88 ; 32BIT-DAG:      $r3 = COPY %0
89 ; 32BIT-DAG:      $r4 = COPY %1
90 ; 32BIT-DAG:      $r5 = COPY %2
91 ; 32BIT-NEXT:     BL_NOP &".memcpy[PR]", csr_aix32, implicit-def dead $lr, implicit $rm, implicit $…
92 ; 32BIT-NEXT:     ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
93 ; 32BIT:          ADJCALLSTACKDOWN 312, 0, implicit-def dead $r1, implicit $r1
94 ; 32BIT-DAG:      $r3 = COPY %{{[0-9]+}}
95 ; 32BIT-DAG:      $r4 = COPY %{{[0-9]+}}
96 ; 32BIT-DAG:      $r5 = COPY %{{[0-9]+}}
97 ; 32BIT-DAG:      $r6 = COPY %{{[0-9]+}}
98 ; 32BIT-DAG:      $r7 = COPY %{{[0-9]+}}
99 ; 32BIT-DAG:      $r8 = COPY %{{[0-9]+}}
100 ; 32BIT-DAG:      $r9 = COPY %{{[0-9]+}}
101 ; 32BIT-DAG:      $r10 = COPY %{{[0-9]+}}
102 ; 32BIT-NEXT:     BL_NOP <mcsymbol .test_byval_mem2>, csr_aix32, implicit-def dead $lr, implicit $r…
103 ; 32BIT-NEXT:     ADJCALLSTACKUP 312, 0, implicit-def dead $r1, implicit $r1
116 ; 64BIT:          ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
117 ; 64BIT-NEXT:     %0:g8rc = nuw ADDI8 $x1, 112
118 ; 64BIT-NEXT:     %1:g8rc = LDtoc @gS256, $x2 :: (load 8 from got)
119 ; 64BIT-NEXT:     %2:g8rc = LI8 256
120 ; 64BIT-DAG:      $x3 = COPY %0
121 ; 64BIT-DAG:      $x4 = COPY %1
122 ; 64BIT-DAG:      $x5 = COPY %2
123 ; 64BIT-NEXT:     BL8_NOP &".memcpy[PR]", csr_ppc64, implicit-def dead $lr8, implicit $rm, implicit…
124 ; 64BIT-NEXT:     ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
125 ; 64BIT:          ADJCALLSTACKDOWN 368, 0, implicit-def dead $r1, implicit $r1
126 ; 64BIT-DAG:      $x3 = COPY %{{[0-9]+}}
127 ; 64BIT-DAG:      $x4 = COPY %{{[0-9]+}}
128 ; 64BIT-DAG:      $x5 = COPY %{{[0-9]+}}
129 ; 64BIT-DAG:      $x6 = COPY %{{[0-9]+}}
130 ; 64BIT-DAG:      $x7 = COPY %{{[0-9]+}}
131 ; 64BIT-DAG:      $x8 = COPY %{{[0-9]+}}
132 ; 64BIT-DAG:      $x9 = COPY %{{[0-9]+}}
133 ; 64BIT-DAG:      $x10 = COPY %{{[0-9]+}}
134 ; 64BIT-NEXT:     BL8_NOP <mcsymbol .test_byval_mem2>, csr_ppc64, implicit-def dead $lr8, implicit …
135 ; 64BIT-NEXT:     ADJCALLSTACKUP 368, 0, implicit-def dead $r1, implicit $r1
155 ; 32BIT:      fixedStack:
156 ; 32BIT-NEXT:   - { id: 0, type: default, offset: 56, size: 256, alignment: 8, stack-id: default,
157 ; 32BIT:      bb.0.entry:
158 ; 32BIT-NEXT:   %[[VAL:[0-9]+]]:gprc = LBZ 255, %fixed-stack.0
159 ; 32BIT-NEXT:   $r3 = COPY %[[VAL]]
160 ; 32BIT-NEXT:   BLR
162 ; 64BIT:      fixedStack:
163 ; 64BIT-NEXT:   - { id: 0, type: default, offset: 112, size: 256, alignment: 16, stack-id: default,
164 ; 64BIT:      bb.0.entry:
165 ; 64BIT-NEXT:   %[[VAL:[0-9]+]]:g8rc = LBZ8 255, %fixed-stack.0
166 ; 64BIT-NEXT:   $x3 = COPY %[[VAL]]
167 ; 64BIT-NEXT:   BLR8
182 ; 32BIT:          ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
183 ; 32BIT-NEXT:     %0:gprc_and_gprc_nor0 = LWZtoc @gS57, $r2 :: (load 4 from got)
184 ; 32BIT-NEXT:     %1:gprc = nuw ADDI %0, 24
185 ; 32BIT-NEXT:     %2:gprc = nuw ADDI $r1, 56
186 ; 32BIT-NEXT:     %3:gprc = LI 33
187 ; 32BIT-DAG:      $r3 = COPY %2
188 ; 32BIT-DAG:      $r4 = COPY %1
189 ; 32BIT-DAG:      $r5 = COPY %3
190 ; 32BIT-NEXT:     BL_NOP &".memcpy[PR]", csr_aix32, implicit-def dead $lr, implicit $rm, implicit $…
191 ; 32BIT-NEXT:     ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
192 ; 32BIT:          ADJCALLSTACKDOWN 92, 0, implicit-def dead $r1, implicit $r1
193 ; 32BIT-DAG:      $r3 = COPY %{{[0-9]+}}
194 ; 32BIT-DAG:      $f1 = COPY %{{[0-9]+}}
195 ; 32BIT-DAG:      $r5 = COPY %{{[0-9]+}}
196 ; 32BIT-DAG:      $r6 = COPY %{{[0-9]+}}
197 ; 32BIT-DAG:      $r7 = COPY %{{[0-9]+}}
198 ; 32BIT-DAG:      $r8 = COPY %{{[0-9]+}}
199 ; 32BIT-DAG:      $r9 = COPY %{{[0-9]+}}
200 ; 32BIT-DAG:      $r10 = COPY %{{[0-9]+}}
201 ; 32BIT-NEXT:     BL_NOP <mcsymbol .test_byval_mem3>, csr_aix32, implicit-def dead $lr, implicit $r…
202 ; 32BIT-NEXT:     ADJCALLSTACKUP 92, 0, implicit-def dead $r1, implicit $r1
245 ; 32BIT:      fixedStack:
246 ; 32BIT-NEXT:   - { id: 0, type: default, offset: 32, size: 60, alignment: 16, stack-id: default,
248 ; 32BIT:      bb.0.entry:
249 ; 32BIT-NEXT:   liveins: $r5, $r6, $r7, $r8, $r9, $r10
251 ; 32BIT-DAG:    %2:gprc = COPY $r5
252 ; 32BIT-DAG:    %3:gprc = COPY $r6
253 ; 32BIT-DAG:    %4:gprc = COPY $r7
254 ; 32BIT-DAG:    %5:gprc = COPY $r8
255 ; 32BIT-DAG:    %6:gprc = COPY $r9
256 ; 32BIT-DAG:    %7:gprc = COPY $r10
257 ; 32BIT-NEXT:   STW %2, 0, %fixed-stack.0 :: (store 4 into %fixed-stack.0
258 ; 32BIT-DAG:    STW %3, 4, %fixed-stack.0 :: (store 4 into %fixed-stack.0 + 4
259 ; 32BIT-DAG:    STW %4, 8, %fixed-stack.0 :: (store 4 into %fixed-stack.0 + 8
260 ; 32BIT-DAG:    STW %5, 12, %fixed-stack.0 :: (store 4 into %fixed-stack.0 + 12
261 ; 32BIT-DAG:    STW %6, 16, %fixed-stack.0 :: (store 4 into %fixed-stack.0 + 16
262 ; 32BIT-DAG:    STW %7, 20, %fixed-stack.0 :: (store 4 into %fixed-stack.0 + 20
263 ; 32BIT-NEXT:   BLR implicit $lr, implicit $rm
265 ; 64BIT:      fixedStack:
266 ; 64BIT-NEXT:   - { id: 0, type: default, offset: 64, size: 64, alignment: 16, stack-id: default,
268 ; 64BIT:      bb.0.entry
269 ; 64BIT-NEXT:   liveins: $x5, $x6, $x7, $x8, $x9, $x10
271 ; 64BIT-DAG:    %2:g8rc = COPY $x5
272 ; 64BIT-DAG:    %3:g8rc = COPY $x6
273 ; 64BIT-DAG:    %4:g8rc = COPY $x7
274 ; 64BIT-DAG:    %5:g8rc = COPY $x8
275 ; 64BIT-DAG:    %6:g8rc = COPY $x9
276 ; 64BIT-DAG:    %7:g8rc = COPY $x10
277 ; 64BIT-NEXT:   STD %2, 0, %fixed-stack.0 :: (store 8 into %fixed-stack.0, align 16)
278 ; 64BIT-DAG:    STD %3, 8, %fixed-stack.0 :: (store 8 into %fixed-stack.0 + 8)
279 ; 64BIT-DAG:    STD %4, 16, %fixed-stack.0 :: (store 8 into %fixed-stack.0 + 16, align 16)
280 ; 64BIT-DAG:    STD %5, 24, %fixed-stack.0 :: (store 8 into %fixed-stack.0 + 24)
281 ; 64BIT-DAG:    STD %6, 32, %fixed-stack.0 :: (store 8 into %fixed-stack.0 + 32, align 16)
282 ; 64BIT-DAG:    STD %7, 40, %fixed-stack.0 :: (store 8 into %fixed-stack.0 + 40)
283 ; 64BIT-NEXT:   BLR8 implicit $lr8, implicit $rm
301 ; 32BIT:          ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
302 ; 32BIT-NEXT:     %3:gprc = nuw ADDI $r1, 60
303 ; 32BIT-NEXT:     %4:gprc = LWZtoc @gS256, $r2 :: (load 4 from got)
304 ; 32BIT-NEXT:     %5:gprc = LI 256
305 ; 32BIT-DAG:      $r3 = COPY %3
306 ; 32BIT-DAG:      $r4 = COPY %4
307 ; 32BIT-DAG:      $r5 = COPY %5
308 ; 32BIT-NEXT:     BL_NOP &".memcpy[PR]", csr_aix32, implicit-def dead $lr, implicit $rm, implicit $…
309 ; 32BIT-NEXT:     ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
310 ; 32BIT:          ADJCALLSTACKDOWN 316, 0, implicit-def dead $r1, implicit $r1
311 ; 32BIT-DAG:      $r3 = COPY %{{[0-9]+}}
312 ; 32BIT-DAG:      $r4 = COPY %{{[0-9]+}}
313 ; 32BIT-DAG:      $r5 = COPY %{{[0-9]+}}
314 ; 32BIT-DAG:      $r6 = COPY %{{[0-9]+}}
315 ; 32BIT-DAG:      $r7 = COPY %{{[0-9]+}}
316 ; 32BIT-DAG:      $r8 = COPY %{{[0-9]+}}
317 ; 32BIT-DAG:      $r9 = COPY %{{[0-9]+}}
318 ; 32BIT-DAG:      $r10 = COPY %{{[0-9]+}}
319 ; 32BIT-NEXT:     BL_NOP <mcsymbol .test_byval_mem4>, csr_aix32, implicit-def dead $lr, implicit $r…
320 ; 32BIT-NEXT:     ADJCALLSTACKUP 316, 0, implicit-def dead $r1, implicit $r1
344 ; 64BIT:          ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
345 ; 64BIT-NEXT:     %0:g8rc_and_g8rc_nox0 = LDtoc @gS256, $x2 :: (load 8 from got)
346 ; 64BIT-NEXT:     %1:g8rc = nuw ADDI8 %0, 24
347 ; 64BIT-NEXT:     %2:g8rc = nuw ADDI8 $x1, 112
348 ; 64BIT-NEXT:     %3:g8rc = LI8 232
349 ; 64BIT-DAG:      $x3 = COPY %2
350 ; 64BIT-DAG:      $x4 = COPY %1
351 ; 64BIT-DAG:      $x5 = COPY %3
352 ; 64BIT-NEXT:     BL8_NOP &".memcpy[PR]", csr_ppc64, implicit-def dead $lr8, implicit $rm, implicit…
353 ; 64BIT-NEXT:     ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
354 ; 64BIT:          ADJCALLSTACKDOWN 344, 0, implicit-def dead $r1, implicit $r1
355 ; 64BIT-DAG:      $x3 = COPY %{{[0-9]+}}
356 ; 64BIT-DAG:      $x4 = COPY %{{[0-9]+}}
357 ; 64BIT-DAG:      $x5 = COPY %{{[0-9]+}}
358 ; 64BIT-DAG:      $x6 = COPY %{{[0-9]+}}
359 ; 64BIT-DAG:      $x7 = COPY %{{[0-9]+}}
360 ; 64BIT-DAG:      $x8 = COPY %{{[0-9]+}}
361 ; 64BIT-DAG:      $x9 = COPY %{{[0-9]+}}
362 ; 64BIT-DAG:      $x10 = COPY %{{[0-9]+}}
363 ; 64BIT-NEXT:     BL8_NOP <mcsymbol .test_byval_mem4>, csr_ppc64, implicit-def dead $lr8, implicit …
364 ; 64BIT-NEXT:     ADJCALLSTACKUP 344, 0, implicit-def dead $r1, implicit $r1
395 ; 32BIT:          fixedStack:
396 ; 32BIT:            - { id: 0, type: default, offset: 60, size: 256, alignment: 4, stack-id: defaul…
397 ; 32BIT:            - { id: 1, type: default, offset: 28, size: 32, alignment: 4, stack-id: default,
398 ; 32BIT:          stack:           []
400 ; 32BIT:          bb.0.entry:
401 ; 32BIT-NEXT:       liveins: $r4, $r5, $r6, $r7, $r8, $r9, $r10
403 ; 32BIT-DAG:      %1:gprc = COPY $r4
404 ; 32BIT-DAG:      %2:gprc = COPY $r5
405 ; 32BIT-DAG:      %3:gprc = COPY $r6
406 ; 32BIT-DAG:      %4:gprc = COPY $r7
407 ; 32BIT-DAG:      %5:gprc = COPY $r8
408 ; 32BIT-DAG:      %6:gprc = COPY $r9
409 ; 32BIT-DAG:      %7:gprc = COPY $r10
410 ; 32BIT-NEXT:     STW %1, 0, %fixed-stack.1 :: (store 4 into %fixed-stack.1
411 ; 32BIT-DAG:      STW %2, 4, %fixed-stack.1 :: (store 4 into %fixed-stack.1 + 4
412 ; 32BIT-DAG:      STW %3, 8, %fixed-stack.1 :: (store 4 into %fixed-stack.1 + 8
413 ; 32BIT-DAG:      STW %4, 12, %fixed-stack.1 :: (store 4 into %fixed-stack.1 + 12
414 ; 32BIT-DAG:      STW %5, 16, %fixed-stack.1 :: (store 4 into %fixed-stack.1 + 16
415 ; 32BIT-DAG:      STW %6, 20, %fixed-stack.1 :: (store 4 into %fixed-stack.1 + 20
416 ; 32BIT-DAG:      STW %7, 24, %fixed-stack.1 :: (store 4 into %fixed-stack.1 + 24
417 ; 32BIT-NEXT:     BLR implicit $lr, implicit $rm
419 ; 64BIT:          fixedStack:
420 ; 64BIT:            - { id: 0, type: default, offset: 88, size: 256, alignment: 8, stack-id: defaul…
421 ; 64BIT:            - { id: 1, type: default, offset: 56, size: 32, alignment: 8, stack-id: default,
422 ; 64BIT:          stack:           []
424 ; 64BIT:          bb.0.entry:
425 ; 64BIT-NEXT:       liveins: $x4, $x5, $x6, $x7, $x8, $x9, $x10
427 ; 64BIT-DAG:      %1:g8rc = COPY $x4
428 ; 64BIT-DAG:      %2:g8rc = COPY $x5
429 ; 64BIT-DAG:      %3:g8rc = COPY $x6
430 ; 64BIT-DAG:      %4:g8rc = COPY $x7
431 ; 64BIT-DAG:      %5:g8rc = COPY $x8
432 ; 64BIT-DAG:      %6:g8rc = COPY $x9
433 ; 64BIT-DAG:      %7:g8rc = COPY $x10
434 ; 64BIT-NEXT:     STD %1, 0, %fixed-stack.1 :: (store 8 into %fixed-stack.1
435 ; 64BIT-DAG:      STD %2, 8, %fixed-stack.1 :: (store 8 into %fixed-stack.1 + 8
436 ; 64BIT-DAG:      STD %3, 16, %fixed-stack.1 :: (store 8 into %fixed-stack.1 + 16
437 ; 64BIT-DAG:      STD %4, 24, %fixed-stack.1 :: (store 8 into %fixed-stack.1 + 24
438 ; 64BIT-DAG:      STD %5, 0, %fixed-stack.0 :: (store 8 into %fixed-stack.0
439 ; 64BIT-DAG:      STD %6, 8, %fixed-stack.0 :: (store 8 into %fixed-stack.0 + 8
440 ; 64BIT-DAG:      STD %7, 16, %fixed-stack.0 :: (store 8 into %fixed-stack.0 + 16
441 ; 64BIT-NEXT:     BLR8 implicit $lr8, implicit $rm