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 23define void @call_test_byval_mem1() { 24entry: 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 46define zeroext i8 @test_byval_mem1(i32, i32, i32, i32, i32, i32, i32, i32, %struct_S1* byval(%struct_S1) align 1 %s) { 47entry: 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 74define void @call_test_byval_mem2() { 75entry: 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 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 $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 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 $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 146define zeroext i8 @test_byval_mem2(i32, i32, i32, i32, i32, i32, i32, i32, %struct_S256* byval(%struct_S256) align 1 %s) { 147entry: 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 173define void @call_test_byval_mem3() { 174entry: 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 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 $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, -112(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, 112 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 237define void @test_byval_mem3(i32, float, %struct_S57* byval(%struct_S57) align 1 %s) { 238entry: 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 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 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 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 284 285%struct_S31 = type { [31 x i8] } 286 287@gS31 = external global %struct_S31, align 1 288 289define void @call_test_byval_mem4() { 290entry: 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 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 $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, -336(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, 336 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 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 $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, -368(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, 368 387 388define void @test_byval_mem4(i32, %struct_S31* byval(%struct_S31) align 1, %struct_S256* byval(%struct_S256) align 1 %s) { 389entry: 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 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 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 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 442