llvm/test/CodeGen/PowerPC/aix-cc-byval-mem.ll

   1 ; RUN: llc -verify-machineinstrs -stop-before=ppc-vsx-copy \
   2 ; RUN:  -mcpu=pwr4 -mattr=-altivec \
   3 ; RUN:  -mtriple powerpc-ibm-aix-xcoff < %s | \
   4 ; RUN: FileCheck --check-prefixes=CHECK,32BIT %s
   5
   6 ; RUN: llc -verify-machineinstrs -mcpu=pwr4 -mattr=-altivec \
   7 ; RUN:  -mtriple powerpc-ibm-aix-xcoff < %s | \
   8 ; RUN: FileCheck --check-prefixes=CHECKASM,ASM32BIT %s
   9
  10 ; RUN: llc -verify-machineinstrs -stop-before=ppc-vsx-copy \
  11 ; RUN:  -mcpu=pwr4 -mattr=-altivec \
  12 ; RUN:  -mtriple powerpc64-ibm-aix-xcoff < %s | \
  13 ; RUN: FileCheck --check-prefixes=CHECK,64BIT %s
  14
  15 ; RUN: llc -verify-machineinstrs -mcpu=pwr4 -mattr=-altivec \
  16 ; RUN:  -mtriple powerpc64-ibm-aix-xcoff < %s | \
  17 ; RUN: FileCheck --check-prefixes=CHECKASM,ASM64BIT %s
  18
  19 %struct_S1 = type { i8 }
  20
  21 @gS1 = external global %struct_S1, align 1
  22
  23 define void @call_test_byval_mem1() {
  24 entry:
  25   %call = call zeroext i8 @test_byval_mem1(i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, %struct_S1* byval(%struct_S1) align 1 @gS1)
  26   ret void
  27 }
  28
  29
  30 ; CHECKASM-LABEL: .call_test_byval_mem1:
  31
  32 ; ASM32BIT:       stwu 1, -64(1)
  33 ; ASM32BIT:       lwz [[REG1:[0-9]+]], L..C{{[0-9]+}}(2)
  34 ; ASM32BIT:       lbz [[REG2:[0-9]+]], 0([[REG1]])
  35 ; ASM32BIT:       stb [[REG2]], 56(1)
  36 ; ASM32BIT:       bl .test_byval_mem1
  37 ; ASM32BIT:       addi 1, 1, 64
  38
  39 ; ASM64BIT:       stdu 1, -128(1)
  40 ; ASM64BIT:       ld [[REG1:[0-9]+]], L..C{{[0-9]+}}(2)
  41 ; ASM64BIT:       lbz [[REG2:[0-9]+]], 0([[REG1]])
  42 ; ASM64BIT:       stb [[REG2]], 112(1)
  43 ; ASM64BIT:       bl .test_byval_mem1
  44 ; ASM64BIT:       addi 1, 1, 128
  45
  46 define zeroext  i8 @test_byval_mem1(i32, i32, i32, i32, i32, i32, i32, i32, %struct_S1* byval(%struct_S1) align 1 %s) {
  47 entry:
  48   %gep = getelementptr inbounds %struct_S1, %struct_S1* %s, i32 0, i32 0
  49   %load = load i8, i8* %gep, align 1
  50   ret i8 %load
  51 }
  52
  53 ; CHECK-LABEL: name:            test_byval_mem1
  54
  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
  61
  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
  68
  69
  70 %struct_S256 = type { [256 x i8] }
  71
  72 @gS256 = external global %struct_S256, align 1
  73
  74 define void @call_test_byval_mem2() {
  75 entry:
  76   %call = call zeroext i8 @test_byval_mem2(i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, %struct_S256* byval(%struct_S256) align 1 @gS256)
  77   ret void
  78 }
  79
  80
  81 ; CHECK-LABEL:    name: call_test_byval_mem2
  82
  83 ; Confirm the expected memcpy call is independent of the call to test_byval_mem2.
  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 (s32) 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 $r3, implicit $r4, implicit $r5, implicit $r2, implicit-def $r1, implicit-def $r3
  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 $rm, implicit $r3, implicit $r4, implicit $r5, implicit $r6, implicit $r7, implicit $r8, implicit $r9, implicit $r10, implicit $r2, implicit-def $r1
 103 ; 32BIT-NEXT:     ADJCALLSTACKUP 312, 0, implicit-def dead $r1, implicit $r1
 104
 105 ; CHECKASM-LABEL: .call_test_byval_mem2:
 106
 107 ; ASM32BIT:       stwu 1, -320(1)
 108 ; ASM32BIT-DAG:   addi 3, 1, 56
 109 ; ASM32BIT-DAG:   lwz 4, L..C{{[0-9]+}}(2)
 110 ; ASM32BIT-DAG:   li 5, 256
 111 ; ASM32BIT-NEXT:  bl .memcpy[PR]
 112 ; ASM32BIT:       bl .test_byval_mem2
 113 ; ASM32BIT:       addi 1, 1, 320
 114
 115 ; Confirm the expected memcpy call is independent of the call to test_byval_mem2.
 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 &".memcpy[PR]", csr_ppc64, implicit-def dead $lr8, implicit $rm, implicit $x3, implicit $x4, implicit $x5, implicit $x2, implicit-def $r1, implicit-def $x3
 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 $rm, implicit $x3, implicit $x4, implicit $x5, implicit $x6, implicit $x7, implicit $x8, implicit $x9, implicit $x10, implicit $x2, implicit-def $r1
 135 ; 64BIT-NEXT:     ADJCALLSTACKUP 368, 0, implicit-def dead $r1, implicit $r1
 136
 137 ; ASM64BIT:       stdu 1, -368(1)
 138 ; ASM64BIT-DAG:   addi 3, 1, 112
 139 ; ASM64BIT-DAG:   ld 4, L..C{{[0-9]+}}(2)
 140 ; ASM64BIT-DAG:   li 5, 256
 141 ; ASM64BIT-NEXT:  bl .memcpy[PR]
 142 ; ASM64BIT:       bl .test_byval_mem2
 143 ; ASM64BIT:       addi 1, 1, 368
 144
 145
 146 define zeroext i8 @test_byval_mem2(i32, i32, i32, i32, i32, i32, i32, i32, %struct_S256* byval(%struct_S256) align 1 %s) {
 147 entry:
 148   %gep = getelementptr inbounds %struct_S256, %struct_S256* %s, i32 0, i32 0, i32 255
 149   %load = load i8, i8* %gep, align 1
 150   ret i8 %load
 151 }
 152
 153 ; CHECK-LABEL: name:            test_byval_mem2
 154
 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
 161
 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
 168
 169 %struct_S57 = type { [57 x i8] }
 170
 171 @gS57 = external global %struct_S57, align 1
 172
 173 define void @call_test_byval_mem3() {
 174 entry:
 175   call void @test_byval_mem3(i32 42, float 0x40091EB860000000, %struct_S57* byval(%struct_S57) align 1 @gS57)
 176   ret void
 177 }
 178
 179 ; CHECK-LABEL:    name: call_test_byval_mem3
 180
 181 ; Confirm the expected memcpy call is independent of the call to test_byval_mem3.
 182 ; 32BIT:          ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
 183 ; 32BIT-NEXT:     %0:gprc_and_gprc_nor0 = LWZtoc @gS57, $r2 :: (load (s32) 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 $r3, implicit $r4, implicit $r5, implicit $r2, implicit-def $r1, implicit-def $r3
 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 $rm, implicit $r3, implicit $f1, implicit $r5, implicit $r6, implicit $r7, implicit $r8, implicit $r9, implicit $r10, implicit $r2, implicit-def $r1
 202 ; 32BIT-NEXT:     ADJCALLSTACKUP 92, 0, implicit-def dead $r1, implicit $r1
 203
 204 ; CHECKASM-LABEL: .call_test_byval_mem3:
 205
 206 ; ASM32BIT:       stwu 1, -96(1)
 207 ; ASM32BIT-DAG:   lwz [[REG:[0-9]+]], L..C{{[0-9]+}}(2)
 208 ; ASM32BIT-DAG:   addi 3, 1, 56
 209 ; ASM32BIT-DAG:   addi 4, [[REG]], 24
 210 ; ASM32BIT-DAG:   li 5, 33
 211 ; ASM32BIT-NEXT:  bl .memcpy[PR]
 212 ; ASM32BIT-DAG:   lwz 5, 0([[REG]])
 213 ; ASM32BIT-DAG:   lwz 6, 4([[REG]])
 214 ; ASM32BIT-DAG:   lwz 7, 8([[REG]])
 215 ; ASM32BIT-DAG:   lwz 8, 12([[REG]])
 216 ; ASM32BIT-DAG:   lwz 9, 16([[REG]])
 217 ; ASM32BIT-DAG:   lwz 10, 20([[REG]])
 218 ; ASM32BIT:       bl .test_byval_mem3
 219 ; ASM32BIT:       addi 1, 1, 96
 220
 221 ; The memcpy call was inlined in 64-bit so MIR test is redundant and omitted.
 222 ; ASM64BIT:       stdu 1, -128(1)
 223 ; ASM64BIT-DAG:   ld [[REG1:[0-9]+]], L..C{{[0-9]+}}(2)
 224 ; ASM64BIT-DAG:   ld [[REG2:[0-9]+]], 48([[REG1]])
 225 ; ASM64BIT-DAG:   std [[REG2]], 112(1)
 226 ; ASM64BIT-DAG:   lbz [[REG3:[0-9]+]], 56([[REG1]])
 227 ; ASM64BIT-DAG:   stb [[REG3]], 120(1)
 228 ; ASM64BIT-DAG:   ld 5, 0([[REG1]])
 229 ; ASM64BIT-DAG:   ld 6, 8([[REG1]])
 230 ; ASM64BIT-DAG:   ld 7, 16([[REG1]])
 231 ; ASM64BIT-DAG:   ld 8, 24([[REG1]])
 232 ; ASM64BIT-DAG:   ld 9, 32([[REG1]])
 233 ; ASM64BIT-DAG:   ld 10, 40([[REG1]])
 234 ; ASM64BIT:       bl .test_byval_mem3
 235 ; ASM64BIT:       addi 1, 1, 128
 236
 237 define void @test_byval_mem3(i32, float, %struct_S57* byval(%struct_S57) align 1 %s) {
 238 entry:
 239   ret void
 240 }
 241
 242
 243 ;CHECK-LABEL:  name:            test_byval_mem3
 244
 245 ; 32BIT:      fixedStack:
 246 ; 32BIT-NEXT:   - { id: 0, type: default, offset: 32, size: 60, alignment: 16, stack-id: default,
 247
 248 ; 32BIT:      bb.0.entry:
 249 ; 32BIT-NEXT:   liveins: $r5, $r6, $r7, $r8, $r9, $r10
 250
 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 (s32) into %fixed-stack.0
 258 ; 32BIT-DAG:    STW %3, 4, %fixed-stack.0 :: (store (s32) into %fixed-stack.0 + 4
 259 ; 32BIT-DAG:    STW %4, 8, %fixed-stack.0 :: (store (s32) into %fixed-stack.0 + 8
 260 ; 32BIT-DAG:    STW %5, 12, %fixed-stack.0 :: (store (s32) into %fixed-stack.0 + 12
 261 ; 32BIT-DAG:    STW %6, 16, %fixed-stack.0 :: (store (s32) into %fixed-stack.0 + 16
 262 ; 32BIT-DAG:    STW %7, 20, %fixed-stack.0 :: (store (s32) into %fixed-stack.0 + 20
 263 ; 32BIT-NEXT:   BLR implicit $lr, implicit $rm
 264
 265 ; 64BIT:      fixedStack:
 266 ; 64BIT-NEXT:   - { id: 0, type: default, offset: 64, size: 64, alignment: 16, stack-id: default,
 267
 268 ; 64BIT:      bb.0.entry
 269 ; 64BIT-NEXT:   liveins: $x5, $x6, $x7, $x8, $x9, $x10
 270
 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 (s64) into %fixed-stack.0, align 16)
 278 ; 64BIT-DAG:    STD %3, 8, %fixed-stack.0 :: (store (s64) into %fixed-stack.0 + 8)
 279 ; 64BIT-DAG:    STD %4, 16, %fixed-stack.0 :: (store (s64) into %fixed-stack.0 + 16, align 16)
 280 ; 64BIT-DAG:    STD %5, 24, %fixed-stack.0 :: (store (s64) into %fixed-stack.0 + 24)
 281 ; 64BIT-DAG:    STD %6, 32, %fixed-stack.0 :: (store (s64) into %fixed-stack.0 + 32, align 16)
 282 ; 64BIT-DAG:    STD %7, 40, %fixed-stack.0 :: (store (s64) into %fixed-stack.0 + 40)
 283 ; 64BIT-NEXT:   BLR8 implicit $lr8, implicit $rm
 284
 285 %struct_S31 = type { [31 x i8] }
 286
 287 @gS31 = external global %struct_S31, align 1
 288
 289 define void @call_test_byval_mem4() {
 290 entry:
 291   call void @test_byval_mem4(i32 42, %struct_S31* byval(%struct_S31) align 1 @gS31, %struct_S256* byval(%struct_S256) align 1 @gS256)
 292   ret void
 293 }
 294
 295
 296 ; CHECK-LABEL: name: call_test_byval_mem4
 297
 298 ; CHECKASM-LABEL: .call_test_byval_mem4:
 299
 300 ; Confirm the expected memcpy call is independent of the call to test_byval_mem4.
 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 (s32) 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 $r3, implicit $r4, implicit $r5, implicit $r2, implicit-def $r1, implicit-def $r3
 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 $rm, implicit $r3, implicit $r4, implicit $r5, implicit $r6, implicit $r7, implicit $r8, implicit $r9, implicit $r10, implicit $r2, implicit-def $r1
 320 ; 32BIT-NEXT:     ADJCALLSTACKUP 316, 0, implicit-def dead $r1, implicit $r1
 321
 322 ; ASM32BIT:       stwu 1, -320(1)
 323 ; ASM32BIT-NEXT:  stw [[REG1:[0-9]+]], {{[0-9]+}}(1)
 324 ; ASM32BIT:       lwz [[REG1]], L..C{{[0-9]+}}(2)
 325 ; ASM32BIT-DAG:   lhz [[REG2:[0-9]+]], 28([[REG1]])
 326 ; ASM32BIT-DAG:   sth [[REG2]], 56(1)
 327 ; ASM32BIT-DAG:   lbz [[REG3:[0-9]+]], 30([[REG1]])
 328 ; ASM32BIT-DAG:   stb [[REG3]], 58(1)
 329 ; ASM32BIT-DAG:   addi 3, 1, 60
 330 ; ASM32BIT-DAG:   lwz 4, L..C{{[0-9]+}}(2)
 331 ; ASM32BIT-DAG:   li 5, 256
 332 ; ASM32BIT-NEXT:  bl .memcpy[PR]
 333 ; ASM32BIT-DAG:   lwz 4, 0([[REG1]])
 334 ; ASM32BIT-DAG:   lwz 5, 4([[REG1]])
 335 ; ASM32BIT-DAG:   lwz 6, 8([[REG1]])
 336 ; ASM32BIT-DAG:   lwz 7, 12([[REG1]])
 337 ; ASM32BIT-DAG:   lwz 8, 16([[REG1]])
 338 ; ASM32BIT-DAG:   lwz 9, 20([[REG1]])
 339 ; ASM32BIT-DAG:   lwz 10, 24([[REG1]])
 340 ; ASM32BIT:       bl .test_byval_mem4
 341 ; ASM32BIT:       addi 1, 1, 320
 342
 343 ; Confirm the expected memcpy call is independent of the call to test_byval_mem4.
 344 ; 64BIT:          ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
 345 ; 64BIT-NEXT:     %0:g8rc_and_g8rc_nox0 = LDtoc @gS256, $x2 :: (load (s64) 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 $x3, implicit $x4, implicit $x5, implicit $x2, implicit-def $r1, implicit-def $x3
 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 $rm, implicit $x3, implicit $x4, implicit $x5, implicit $x6, implicit $x7, implicit $x8, implicit $x9, implicit $x10, implicit $x2, implicit-def $r1
 364 ; 64BIT-NEXT:     ADJCALLSTACKUP 344, 0, implicit-def dead $r1, implicit $r1
 365
 366 ; ASM64BIT:       stdu 1, -352(1)
 367 ; ASM64BIT-DAG:   ld [[REG1:[0-9]+]], L..C{{[0-9]+}}(2)
 368 ; ASM64BIT-DAG:   addi 3, 1, 112
 369 ; ASM64BIT-DAG:   addi 4, [[REG1]], 24
 370 ; ASM64BIT-DAG:   li 5, 232
 371 ; ASM64BIT-NEXT:  bl .memcpy[PR]
 372 ; ASM64BIT-DAG:   ld [[REG2:[0-9]+]], L..C{{[0-9]+}}(2)
 373 ; ASM64BIT-DAG:   ld 4, 0([[REG2]])
 374 ; ASM64BIT-DAG:   ld 5, 8([[REG2]])
 375 ; ASM64BIT-DAG:   ld 6, 16([[REG2]])
 376 ; ASM64BIT-DAG:   lwz [[REG3:[0-9]+]], 24([[REG2]])
 377 ; ASM64BIT-DAG:   lhz [[REG4:[0-9]+]], 28([[REG2]])
 378 ; ASM64BIT-DAG:   lbz 7, 30([[REG2]])
 379 ; ASM64BIT-DAG:   rlwinm 7, 7, 8, 16, 23
 380 ; ASM64BIT-DAG:   rlwimi 7, [[REG4]], 16, 0, 15
 381 ; ASM64BIT-DAG:   rldimi 7, [[REG3]], 32, 0
 382 ; ASM64BIT-DAG:   ld 8, 0([[REG1]])
 383 ; ASM64BIT-DAG:   ld 9, 8([[REG1]])
 384 ; ASM64BIT-DAG:   ld 10, 16([[REG1]])
 385 ; ASM64BIT:       bl .test_byval_mem4
 386 ; ASM64BIT:       addi 1, 1, 352
 387
 388 define void @test_byval_mem4(i32, %struct_S31* byval(%struct_S31) align 1, %struct_S256* byval(%struct_S256) align 1 %s) {
 389 entry:
 390   ret void
 391 }
 392
 393 ; CHECK-LABEL:    name:            test_byval_mem4
 394
 395 ; 32BIT:          fixedStack:
 396 ; 32BIT:            - { id: 0, type: default, offset: 60, size: 256, alignment: 4, stack-id: default,
 397 ; 32BIT:            - { id: 1, type: default, offset: 28, size: 32, alignment: 4, stack-id: default,
 398 ; 32BIT:          stack:           []
 399
 400 ; 32BIT:          bb.0.entry:
 401 ; 32BIT-NEXT:       liveins: $r4, $r5, $r6, $r7, $r8, $r9, $r10
 402
 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 (s32) into %fixed-stack.1
 411 ; 32BIT-DAG:      STW %2, 4, %fixed-stack.1 :: (store (s32) into %fixed-stack.1 + 4
 412 ; 32BIT-DAG:      STW %3, 8, %fixed-stack.1 :: (store (s32) into %fixed-stack.1 + 8
 413 ; 32BIT-DAG:      STW %4, 12, %fixed-stack.1 :: (store (s32) into %fixed-stack.1 + 12
 414 ; 32BIT-DAG:      STW %5, 16, %fixed-stack.1 :: (store (s32) into %fixed-stack.1 + 16
 415 ; 32BIT-DAG:      STW %6, 20, %fixed-stack.1 :: (store (s32) into %fixed-stack.1 + 20
 416 ; 32BIT-DAG:      STW %7, 24, %fixed-stack.1 :: (store (s32) into %fixed-stack.1 + 24
 417 ; 32BIT-NEXT:     BLR implicit $lr, implicit $rm
 418
 419 ; 64BIT:          fixedStack:
 420 ; 64BIT:            - { id: 0, type: default, offset: 88, size: 256, alignment: 8, stack-id: default,
 421 ; 64BIT:            - { id: 1, type: default, offset: 56, size: 32, alignment: 8, stack-id: default,
 422 ; 64BIT:          stack:           []
 423
 424 ; 64BIT:          bb.0.entry:
 425 ; 64BIT-NEXT:       liveins: $x4, $x5, $x6, $x7, $x8, $x9, $x10
 426
 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 (s64) into %fixed-stack.1
 435 ; 64BIT-DAG:      STD %2, 8, %fixed-stack.1 :: (store (s64) into %fixed-stack.1 + 8
 436 ; 64BIT-DAG:      STD %3, 16, %fixed-stack.1 :: (store (s64) into %fixed-stack.1 + 16
 437 ; 64BIT-DAG:      STD %4, 24, %fixed-stack.1 :: (store (s64) into %fixed-stack.1 + 24
 438 ; 64BIT-DAG:      STD %5, 0, %fixed-stack.0 :: (store (s64) into %fixed-stack.0
 439 ; 64BIT-DAG:      STD %6, 8, %fixed-stack.0 :: (store (s64) into %fixed-stack.0 + 8
 440 ; 64BIT-DAG:      STD %7, 16, %fixed-stack.0 :: (store (s64) into %fixed-stack.0 + 16
 441 ; 64BIT-NEXT:     BLR8 implicit $lr8, implicit $rm