Lines Matching full:bit

4 ; RUN: FileCheck --check-prefixes=CHECK,32BIT %s
13 ; RUN: FileCheck --check-prefixes=CHECK,64BIT %s
54 ; 32BIT:       fixedStack:
55 ; 32BIT-NEXT:    - { id: 0, type: default, offset: 56, size: 4, alignment: 8, stack-id: default,
56 ; 32BIT:       bb.0.entry:
57 ; 32BIT-NEXT:    %[[VAL:[0-9]+]]:gprc = LBZ 0, %fixed-stack.0
58 ; 32BIT-NEXT:    $r3 = COPY %[[VAL]]
59 ; 32BIT-NEXT:    BLR
61 ; 64BIT:       fixedStack:
62 ; 64BIT-NEXT:    - { id: 0, type: default, offset: 112, size: 8, alignment: 16, stack-id: default,
63 ; 64BIT:       bb.0.entry:
64 ; 64BIT-NEXT:    %[[VAL:[0-9]+]]:g8rc = LBZ8 0, %fixed-stack.0
65 ; 64BIT-NEXT:    $x3 = COPY %[[VAL]]
66 ; 64BIT-NEXT:    BLR8
83 ; 32BIT:          ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
84 ; 32BIT-NEXT:     %0:gprc = nuw ADDI $r1, 56
85 ; 32BIT-NEXT:     %1:gprc = LWZtoc @gS256, $r2 :: (load (s32) from got)
86 ; 32BIT-NEXT:     %2:gprc = LI 256
87 ; 32BIT-DAG:      $r3 = COPY %0
88 ; 32BIT-DAG:      $r4 = COPY %1
89 ; 32BIT-DAG:      $r5 = COPY %2
90 ; 32BIT-NEXT:     BL_NOP &".___memmove[PR]", csr_aix32, implicit-def dead $lr, implicit $rm, implic…
91 ; 32BIT-NEXT:     ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
92 ; 32BIT:          ADJCALLSTACKDOWN 312, 0, implicit-def dead $r1, implicit $r1
93 ; 32BIT-DAG:      $r3 = COPY %{{[0-9]+}}
94 ; 32BIT-DAG:      $r4 = COPY %{{[0-9]+}}
95 ; 32BIT-DAG:      $r5 = COPY %{{[0-9]+}}
96 ; 32BIT-DAG:      $r6 = COPY %{{[0-9]+}}
97 ; 32BIT-DAG:      $r7 = COPY %{{[0-9]+}}
98 ; 32BIT-DAG:      $r8 = COPY %{{[0-9]+}}
99 ; 32BIT-DAG:      $r9 = COPY %{{[0-9]+}}
100 ; 32BIT-DAG:      $r10 = COPY %{{[0-9]+}}
101 ; 32BIT-NEXT:     BL_NOP <mcsymbol .test_byval_mem2>, csr_aix32, implicit-def dead $lr, implicit $r…
102 ; 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 (s64) 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 &".___memmove64[PR]", csr_ppc64, implicit-def dead $lr8, implicit $rm, im…
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
156 ; 32BIT:      fixedStack:
157 ; 32BIT-NEXT:   - { id: 0, type: default, offset: 56, size: 256, alignment: 8, stack-id: default,
158 ; 32BIT:      bb.0.entry:
159 ; 32BIT-NEXT:   %[[VAL:[0-9]+]]:gprc = LBZ 255, %fixed-stack.0
160 ; 32BIT-NEXT:   $r3 = COPY %[[VAL]]
161 ; 32BIT-NEXT:   BLR
163 ; 64BIT:      fixedStack:
164 ; 64BIT-NEXT:   - { id: 0, type: default, offset: 112, size: 256, alignment: 16, stack-id: default,
165 ; 64BIT:      bb.0.entry:
166 ; 64BIT-NEXT:   %[[VAL:[0-9]+]]:g8rc = LBZ8 255, %fixed-stack.0
167 ; 64BIT-NEXT:   $x3 = COPY %[[VAL]]
168 ; 64BIT-NEXT:   BLR8
183 ; 32BIT:          ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
184 ; 32BIT-NEXT:     %0:gprc_and_gprc_nor0 = LWZtoc @gS57, $r2 :: (load (s32) from got)
185 ; 32BIT-NEXT:     %1:gprc = nuw ADDI %0, 24
186 ; 32BIT-NEXT:     %2:gprc = nuw ADDI $r1, 56
187 ; 32BIT-NEXT:     %3:gprc = LI 33
188 ; 32BIT-DAG:      $r3 = COPY %2
189 ; 32BIT-DAG:      $r4 = COPY %1
190 ; 32BIT-DAG:      $r5 = COPY %3
191 ; 32BIT-NEXT:     BL_NOP &".___memmove[PR]", csr_aix32, implicit-def dead $lr, implicit $rm, implic…
192 ; 32BIT-NEXT:     ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
193 ; 32BIT:          ADJCALLSTACKDOWN 92, 0, implicit-def dead $r1, implicit $r1
194 ; 32BIT-DAG:      $r3 = COPY %{{[0-9]+}}
195 ; 32BIT-DAG:      $f1 = COPY %{{[0-9]+}}
196 ; 32BIT-DAG:      $r5 = COPY %{{[0-9]+}}
197 ; 32BIT-DAG:      $r6 = COPY %{{[0-9]+}}
198 ; 32BIT-DAG:      $r7 = COPY %{{[0-9]+}}
199 ; 32BIT-DAG:      $r8 = COPY %{{[0-9]+}}
200 ; 32BIT-DAG:      $r9 = COPY %{{[0-9]+}}
201 ; 32BIT-DAG:      $r10 = COPY %{{[0-9]+}}
202 ; 32BIT-NEXT:     BL_NOP <mcsymbol .test_byval_mem3>, csr_aix32, implicit-def dead $lr, implicit $r…
203 ; 32BIT-NEXT:     ADJCALLSTACKUP 92, 0, implicit-def dead $r1, implicit $r1
222 ; The memcpy call was inlined in 64-bit so MIR test is redundant and omitted.
246 ; 32BIT:      fixedStack:
247 ; 32BIT-NEXT:   - { id: 0, type: default, offset: 32, size: 60, alignment: 16, stack-id: default,
249 ; 32BIT:      bb.0.entry:
250 ; 32BIT-NEXT:   liveins: $r5, $r6, $r7, $r8, $r9, $r10
252 ; 32BIT-DAG:    %2:gprc = COPY $r5
253 ; 32BIT-DAG:    %3:gprc = COPY $r6
254 ; 32BIT-DAG:    %4:gprc = COPY $r7
255 ; 32BIT-DAG:    %5:gprc = COPY $r8
256 ; 32BIT-DAG:    %6:gprc = COPY $r9
257 ; 32BIT-DAG:    %7:gprc = COPY $r10
258 ; 32BIT-NEXT:   STW %2, 0, %fixed-stack.0 :: (store (s32) into %fixed-stack.0
259 ; 32BIT-DAG:    STW %3, 4, %fixed-stack.0 :: (store (s32) into %fixed-stack.0 + 4
260 ; 32BIT-DAG:    STW %4, 8, %fixed-stack.0 :: (store (s32) into %fixed-stack.0 + 8
261 ; 32BIT-DAG:    STW %5, 12, %fixed-stack.0 :: (store (s32) into %fixed-stack.0 + 12
262 ; 32BIT-DAG:    STW %6, 16, %fixed-stack.0 :: (store (s32) into %fixed-stack.0 + 16
263 ; 32BIT-DAG:    STW %7, 20, %fixed-stack.0 :: (store (s32) into %fixed-stack.0 + 20
264 ; 32BIT-NEXT:   BLR implicit $lr, implicit $rm
266 ; 64BIT:      fixedStack:
267 ; 64BIT-NEXT:   - { id: 0, type: default, offset: 64, size: 64, alignment: 16, stack-id: default,
269 ; 64BIT:      bb.0.entry
270 ; 64BIT-NEXT:   liveins: $x5, $x6, $x7, $x8, $x9, $x10
272 ; 64BIT-DAG:    %2:g8rc = COPY $x5
273 ; 64BIT-DAG:    %3:g8rc = COPY $x6
274 ; 64BIT-DAG:    %4:g8rc = COPY $x7
275 ; 64BIT-DAG:    %5:g8rc = COPY $x8
276 ; 64BIT-DAG:    %6:g8rc = COPY $x9
277 ; 64BIT-DAG:    %7:g8rc = COPY $x10
278 ; 64BIT-NEXT:   STD %2, 0, %fixed-stack.0 :: (store (s64) into %fixed-stack.0, align 16)
279 ; 64BIT-DAG:    STD %3, 8, %fixed-stack.0 :: (store (s64) into %fixed-stack.0 + 8)
280 ; 64BIT-DAG:    STD %4, 16, %fixed-stack.0 :: (store (s64) into %fixed-stack.0 + 16, align 16)
281 ; 64BIT-DAG:    STD %5, 24, %fixed-stack.0 :: (store (s64) into %fixed-stack.0 + 24)
282 ; 64BIT-DAG:    STD %6, 32, %fixed-stack.0 :: (store (s64) into %fixed-stack.0 + 32, align 16)
283 ; 64BIT-DAG:    STD %7, 40, %fixed-stack.0 :: (store (s64) into %fixed-stack.0 + 40)
284 ; 64BIT-NEXT:   BLR8 implicit $lr8, implicit $rm
302 ; 32BIT:          ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
303 ; 32BIT-NEXT:     %3:gprc = nuw ADDI $r1, 60
304 ; 32BIT-NEXT:     %4:gprc = LWZtoc @gS256, $r2 :: (load (s32) from got)
305 ; 32BIT-NEXT:     %5:gprc = LI 256
306 ; 32BIT-DAG:      $r3 = COPY %3
307 ; 32BIT-DAG:      $r4 = COPY %4
308 ; 32BIT-DAG:      $r5 = COPY %5
309 ; 32BIT-NEXT:     BL_NOP &".___memmove[PR]", csr_aix32, implicit-def dead $lr, implicit $rm, implic…
310 ; 32BIT-NEXT:     ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
311 ; 32BIT:          ADJCALLSTACKDOWN 316, 0, implicit-def dead $r1, implicit $r1
312 ; 32BIT-DAG:      $r3 = COPY %{{[0-9]+}}
313 ; 32BIT-DAG:      $r4 = COPY %{{[0-9]+}}
314 ; 32BIT-DAG:      $r5 = COPY %{{[0-9]+}}
315 ; 32BIT-DAG:      $r6 = COPY %{{[0-9]+}}
316 ; 32BIT-DAG:      $r7 = COPY %{{[0-9]+}}
317 ; 32BIT-DAG:      $r8 = COPY %{{[0-9]+}}
318 ; 32BIT-DAG:      $r9 = COPY %{{[0-9]+}}
319 ; 32BIT-DAG:      $r10 = COPY %{{[0-9]+}}
320 ; 32BIT-NEXT:     BL_NOP <mcsymbol .test_byval_mem4>, csr_aix32, implicit-def dead $lr, implicit $r…
321 ; 32BIT-NEXT:     ADJCALLSTACKUP 316, 0, implicit-def dead $r1, implicit $r1
346 ; 64BIT:          ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
347 ; 64BIT-NEXT:     %0:g8rc_and_g8rc_nox0 = LDtoc @gS256, $x2 :: (load (s64) from got)
348 ; 64BIT-NEXT:     %1:g8rc = nuw ADDI8 %0, 24
349 ; 64BIT-NEXT:     %2:g8rc = nuw ADDI8 $x1, 112
350 ; 64BIT-NEXT:     %3:g8rc = LI8 232
351 ; 64BIT-DAG:      $x3 = COPY %2
352 ; 64BIT-DAG:      $x4 = COPY %1
353 ; 64BIT-DAG:      $x5 = COPY %3
354 ; 64BIT-NEXT:     BL8_NOP &".___memmove64[PR]", csr_ppc64, implicit-def dead $lr8, implicit $rm, im…
355 ; 64BIT-NEXT:     ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
356 ; 64BIT:          ADJCALLSTACKDOWN 344, 0, implicit-def dead $r1, implicit $r1
357 ; 64BIT-DAG:      $x3 = COPY %{{[0-9]+}}
358 ; 64BIT-DAG:      $x4 = COPY %{{[0-9]+}}
359 ; 64BIT-DAG:      $x5 = COPY %{{[0-9]+}}
360 ; 64BIT-DAG:      $x6 = COPY %{{[0-9]+}}
361 ; 64BIT-DAG:      $x7 = COPY %{{[0-9]+}}
362 ; 64BIT-DAG:      $x8 = COPY %{{[0-9]+}}
363 ; 64BIT-DAG:      $x9 = COPY %{{[0-9]+}}
364 ; 64BIT-DAG:      $x10 = COPY %{{[0-9]+}}
365 ; 64BIT-NEXT:     BL8_NOP <mcsymbol .test_byval_mem4>, csr_ppc64, implicit-def dead $lr8, implicit …
366 ; 64BIT-NEXT:     ADJCALLSTACKUP 344, 0, implicit-def dead $r1, implicit $r1
397 ; 32BIT:          fixedStack:
398 ; 32BIT:            - { id: 0, type: default, offset: 60, size: 256, alignment: 4, stack-id: defaul…
399 ; 32BIT:            - { id: 1, type: default, offset: 28, size: 32, alignment: 4, stack-id: default,
400 ; 32BIT:          stack:           []
402 ; 32BIT:          bb.0.entry:
403 ; 32BIT-NEXT:       liveins: $r4, $r5, $r6, $r7, $r8, $r9, $r10
405 ; 32BIT-DAG:      %1:gprc = COPY $r4
406 ; 32BIT-DAG:      %2:gprc = COPY $r5
407 ; 32BIT-DAG:      %3:gprc = COPY $r6
408 ; 32BIT-DAG:      %4:gprc = COPY $r7
409 ; 32BIT-DAG:      %5:gprc = COPY $r8
410 ; 32BIT-DAG:      %6:gprc = COPY $r9
411 ; 32BIT-DAG:      %7:gprc = COPY $r10
412 ; 32BIT-NEXT:     STW %1, 0, %fixed-stack.1 :: (store (s32) into %fixed-stack.1
413 ; 32BIT-DAG:      STW %2, 4, %fixed-stack.1 :: (store (s32) into %fixed-stack.1 + 4
414 ; 32BIT-DAG:      STW %3, 8, %fixed-stack.1 :: (store (s32) into %fixed-stack.1 + 8
415 ; 32BIT-DAG:      STW %4, 12, %fixed-stack.1 :: (store (s32) into %fixed-stack.1 + 12
416 ; 32BIT-DAG:      STW %5, 16, %fixed-stack.1 :: (store (s32) into %fixed-stack.1 + 16
417 ; 32BIT-DAG:      STW %6, 20, %fixed-stack.1 :: (store (s32) into %fixed-stack.1 + 20
418 ; 32BIT-DAG:      STW %7, 24, %fixed-stack.1 :: (store (s32) into %fixed-stack.1 + 24
419 ; 32BIT-NEXT:     BLR implicit $lr, implicit $rm
421 ; 64BIT:          fixedStack:
422 ; 64BIT:            - { id: 0, type: default, offset: 88, size: 256, alignment: 8, stack-id: defaul…
423 ; 64BIT:            - { id: 1, type: default, offset: 56, size: 32, alignment: 8, stack-id: default,
424 ; 64BIT:          stack:           []
426 ; 64BIT:          bb.0.entry:
427 ; 64BIT-NEXT:       liveins: $x4, $x5, $x6, $x7, $x8, $x9, $x10
429 ; 64BIT-DAG:      %1:g8rc = COPY $x4
430 ; 64BIT-DAG:      %2:g8rc = COPY $x5
431 ; 64BIT-DAG:      %3:g8rc = COPY $x6
432 ; 64BIT-DAG:      %4:g8rc = COPY $x7
433 ; 64BIT-DAG:      %5:g8rc = COPY $x8
434 ; 64BIT-DAG:      %6:g8rc = COPY $x9
435 ; 64BIT-DAG:      %7:g8rc = COPY $x10
436 ; 64BIT-NEXT:     STD %1, 0, %fixed-stack.1 :: (store (s64) into %fixed-stack.1
437 ; 64BIT-DAG:      STD %2, 8, %fixed-stack.1 :: (store (s64) into %fixed-stack.1 + 8
438 ; 64BIT-DAG:      STD %3, 16, %fixed-stack.1 :: (store (s64) into %fixed-stack.1 + 16
439 ; 64BIT-DAG:      STD %4, 24, %fixed-stack.1 :: (store (s64) into %fixed-stack.1 + 24
440 ; 64BIT-DAG:      STD %5, 0, %fixed-stack.0 :: (store (s64) into %fixed-stack.0
441 ; 64BIT-DAG:      STD %6, 8, %fixed-stack.0 :: (store (s64) into %fixed-stack.0 + 8
442 ; 64BIT-DAG:      STD %7, 16, %fixed-stack.0 :: (store (s64) into %fixed-stack.0 + 16
443 ; 64BIT-NEXT:     BLR8 implicit $lr8, implicit $rm