This is an archive of the discontinued LLVM Phabricator instance.

Differential D123842

[NVPTX] Use opaque pointers in param space vectorization tests
ClosedPublic

Authored by kovdan01 on Apr 15 2022, 12:50 AM.

Details

Reviewers
tra
jlebar
jholewinski
Commits
rGeb3d64695f27: [NVPTX] Use opaque pointers in param space vectorization tests
Summary

Opaque pointers are enabled by default since D123300, so test IR should be
regenerated correspondingly.

Diff Detail

Event Timeline

kovdan01 created this revision.Apr 15 2022, 12:50 AM
Herald added a project: Restricted Project. · View Herald TranscriptApr 15 2022, 12:50 AM
Herald added subscribers: mattd, gchakrabarti, asavonic, dexonsmith. · View Herald Transcript
kovdan01 requested review of this revision.Apr 15 2022, 12:50 AM
Herald added a project: Restricted Project. · View Herald TranscriptApr 15 2022, 12:50 AM
Herald added a subscriber: llvm-commits. · View Herald Transcript
Harbormaster completed remote builds in B159790: Diff 423032.Apr 15 2022, 3:24 AM
tra accepted this revision.Apr 15 2022, 11:28 AM
This revision is now accepted and ready to land.Apr 15 2022, 11:28 AM
This revision was landed with ongoing or failed builds.Apr 17 2022, 9:09 AM
Closed by commit rGeb3d64695f27: [NVPTX] Use opaque pointers in param space vectorization tests (authored by kovdan01). · Explain Why
This revision was automatically updated to reflect the committed changes.
kovdan01 added a commit: rGeb3d64695f27: [NVPTX] Use opaque pointers in param space vectorization tests.

Revision Contents

PathSize
llvm/
test/
CodeGen/
NVPTX/
474 lines
368 lines

Diff 423299

llvm/test/CodeGen/NVPTX/param-vectorize-device.ll

Show First 20 Lines • Show All 71 Lines • ▼ Show 20 Lines
%struct.St8x2 = type { [2 x i64] } %struct.St8x2 = type { [2 x i64] }
%struct.St8x3 = type { [3 x i64] } %struct.St8x3 = type { [3 x i64] }
%struct.St8x4 = type { [4 x i64] } %struct.St8x4 = type { [4 x i64] }
; Section 1 - checking that: ; Section 1 - checking that:
; - function argument (including retval) vectorization is done with internal linkage; ; - function argument (including retval) vectorization is done with internal linkage;
; - caller and callee specify correct alignment for callee's params. ; - caller and callee specify correct alignment for callee's params.
define dso_local void @caller_St4x1(%struct.St4x1* nocapture noundef readonly byval(%struct.St4x1) align 4 %in, %struct.St4x1* nocapture noundef writeonly %ret) { define dso_local void @caller_St4x1(ptr nocapture noundef readonly byval(%struct.St4x1) align 4 %in, ptr nocapture noundef writeonly %ret) {
; CHECK-LABEL: .visible .func caller_St4x1( ; CHECK-LABEL: .visible .func caller_St4x1(
; CHECK: .param .align 4 .b8 caller_St4x1_param_0[4], ; CHECK: .param .align 4 .b8 caller_St4x1_param_0[4],
; CHECK: .param .b32 caller_St4x1_param_1 ; CHECK: .param .b32 caller_St4x1_param_1
; CHECK: ) ; CHECK: )
; CHECK: .param .b32 param0; ; CHECK: .param .b32 param0;
; CHECK: st.param.b32 [param0+0], {{%r[0-9]+}}; ; CHECK: st.param.b32 [param0+0], {{%r[0-9]+}};
; CHECK: .param .align 16 .b8 retval0[4]; ; CHECK: .param .align 16 .b8 retval0[4];
; CHECK: call.uni (retval0), ; CHECK: call.uni (retval0),
; CHECK-NEXT: callee_St4x1, ; CHECK-NEXT: callee_St4x1,
; CHECK-NEXT: ( ; CHECK-NEXT: (
; CHECK-NEXT: param0 ; CHECK-NEXT: param0
; CHECK-NEXT: ); ; CHECK-NEXT: );
; CHECK: ld.param.b32 {{%r[0-9]+}}, [retval0+0]; ; CHECK: ld.param.b32 {{%r[0-9]+}}, [retval0+0];
%1 = getelementptr inbounds %struct.St4x1, %struct.St4x1* %in, i64 0, i32 0, i64 0 %1 = load i32, ptr %in, align 4
%2 = load i32, i32* %1, align 4 %call = tail call fastcc [1 x i32] @callee_St4x1(i32 %1) #2
%call = tail call fastcc [1 x i32] @callee_St4x1(i32 %2)
%.fca.0.extract = extractvalue [1 x i32] %call, 0 %.fca.0.extract = extractvalue [1 x i32] %call, 0
%ref.tmp.sroa.0.0..sroa_idx = getelementptr inbounds %struct.St4x1, %struct.St4x1* %ret, i64 0, i32 0, i64 0 store i32 %.fca.0.extract, ptr %ret, align 4
store i32 %.fca.0.extract, i32* %ref.tmp.sroa.0.0..sroa_idx, align 4
ret void ret void
} }
define internal fastcc [1 x i32] @callee_St4x1(i32 %in.0.val) { define internal fastcc [1 x i32] @callee_St4x1(i32 %in.0.val) {
; CHECK: .func (.param .align 16 .b8 func_retval0[4]) ; CHECK: .func (.param .align 16 .b8 func_retval0[4])
; CHECK-LABEL: callee_St4x1( ; CHECK-LABEL: callee_St4x1(
; CHECK-NEXT: .param .b32 callee_St4x1_param_0 ; CHECK-NEXT: .param .b32 callee_St4x1_param_0
; CHECK: ld.param.u32 [[R1:%r[0-9]+]], [callee_St4x1_param_0]; ; CHECK: ld.param.u32 [[R1:%r[0-9]+]], [callee_St4x1_param_0];
; CHECK: st.param.b32 [func_retval0+0], [[R1]]; ; CHECK: st.param.b32 [func_retval0+0], [[R1]];
; CHECK-NEXT: ret; ; CHECK-NEXT: ret;
%oldret = insertvalue [1 x i32] poison, i32 %in.0.val, 0 %oldret = insertvalue [1 x i32] poison, i32 %in.0.val, 0
ret [1 x i32] %oldret ret [1 x i32] %oldret
} }
define dso_local void @caller_St4x2(%struct.St4x2* nocapture noundef readonly byval(%struct.St4x2) align 4 %in, %struct.St4x2* nocapture noundef writeonly %ret) { define dso_local void @caller_St4x2(ptr nocapture noundef readonly byval(%struct.St4x2) align 4 %in, ptr nocapture noundef writeonly %ret) {
; CHECK-LABEL: .visible .func caller_St4x2( ; CHECK-LABEL: .visible .func caller_St4x2(
; CHECK: .param .align 4 .b8 caller_St4x2_param_0[8], ; CHECK: .param .align 4 .b8 caller_St4x2_param_0[8],
; CHECK: .param .b32 caller_St4x2_param_1 ; CHECK: .param .b32 caller_St4x2_param_1
; CHECK: ) ; CHECK: )
; CHECK: .param .align 16 .b8 param0[8]; ; CHECK: .param .align 16 .b8 param0[8];
; CHECK: st.param.v2.b32 [param0+0], {{{%r[0-9]+}}, {{%r[0-9]+}}}; ; CHECK: st.param.v2.b32 [param0+0], {{{%r[0-9]+}}, {{%r[0-9]+}}};
; CHECK: .param .align 16 .b8 retval0[8]; ; CHECK: .param .align 16 .b8 retval0[8];
; CHECK: call.uni (retval0), ; CHECK: call.uni (retval0),
; CHECK-NEXT: callee_St4x2, ; CHECK-NEXT: callee_St4x2,
; CHECK-NEXT: ( ; CHECK-NEXT: (
; CHECK-NEXT: param0 ; CHECK-NEXT: param0
; CHECK-NEXT: ); ; CHECK-NEXT: );
; CHECK: ld.param.v2.b32 {{{%r[0-9]+}}, {{%r[0-9]+}}}, [retval0+0]; ; CHECK: ld.param.v2.b32 {{{%r[0-9]+}}, {{%r[0-9]+}}}, [retval0+0];
%agg.tmp = alloca i64, align 8 %agg.tmp = alloca %struct.St4x2, align 8
%tmpcast = bitcast i64* %agg.tmp to %struct.St4x2* %1 = load i64, ptr %in, align 4
%1 = bitcast %struct.St4x2* %in to i64* store i64 %1, ptr %agg.tmp, align 8
%2 = load i64, i64* %1, align 4 %call = tail call fastcc [2 x i32] @callee_St4x2(ptr noundef nonnull byval(%struct.St4x2) align 4 %agg.tmp) #2
store i64 %2, i64* %agg.tmp, align 8
%call = tail call fastcc [2 x i32] @callee_St4x2(%struct.St4x2* noundef nonnull byval(%struct.St4x2) align 4 %tmpcast)
%.fca.0.extract = extractvalue [2 x i32] %call, 0 %.fca.0.extract = extractvalue [2 x i32] %call, 0
%.fca.1.extract = extractvalue [2 x i32] %call, 1 %.fca.1.extract = extractvalue [2 x i32] %call, 1
%ref.tmp.sroa.0.0..sroa_idx = getelementptr inbounds %struct.St4x2, %struct.St4x2* %ret, i64 0, i32 0, i64 0 store i32 %.fca.0.extract, ptr %ret, align 4
store i32 %.fca.0.extract, i32* %ref.tmp.sroa.0.0..sroa_idx, align 4 %ref.tmp.sroa.4.0..sroa_idx = getelementptr inbounds i8, ptr %ret, i64 4
%ref.tmp.sroa.4.0..sroa_idx3 = getelementptr inbounds %struct.St4x2, %struct.St4x2* %ret, i64 0, i32 0, i64 1 store i32 %.fca.1.extract, ptr %ref.tmp.sroa.4.0..sroa_idx, align 4
store i32 %.fca.1.extract, i32* %ref.tmp.sroa.4.0..sroa_idx3, align 4
ret void ret void
} }
define internal fastcc [2 x i32] @callee_St4x2(%struct.St4x2* nocapture noundef readonly byval(%struct.St4x2) align 4 %in) { define internal fastcc [2 x i32] @callee_St4x2(ptr nocapture noundef readonly byval(%struct.St4x2) align 4 %in) {
; CHECK: .func (.param .align 16 .b8 func_retval0[8]) ; CHECK: .func (.param .align 16 .b8 func_retval0[8])
; CHECK-LABEL: callee_St4x2( ; CHECK-LABEL: callee_St4x2(
; CHECK-NEXT: .param .align 16 .b8 callee_St4x2_param_0[8] ; CHECK-NEXT: .param .align 16 .b8 callee_St4x2_param_0[8]
; CHECK: ld.param.v2.u32 {[[R1:%r[0-9]+]], [[R2:%r[0-9]+]]}, [callee_St4x2_param_0]; ; CHECK: ld.param.v2.u32 {[[R1:%r[0-9]+]], [[R2:%r[0-9]+]]}, [callee_St4x2_param_0];
; CHECK: st.param.v2.b32 [func_retval0+0], {[[R1]], [[R2]]}; ; CHECK: st.param.v2.b32 [func_retval0+0], {[[R1]], [[R2]]};
; CHECK-NEXT: ret; ; CHECK-NEXT: ret;
%arrayidx = getelementptr inbounds %struct.St4x2, %struct.St4x2* %in, i64 0, i32 0, i64 0 %1 = load i32, ptr %in, align 4
%1 = load i32, i32* %arrayidx, align 4 %arrayidx.1 = getelementptr inbounds [2 x i32], ptr %in, i64 0, i64 1
%arrayidx.1 = getelementptr inbounds %struct.St4x2, %struct.St4x2* %in, i64 0, i32 0, i64 1 %2 = load i32, ptr %arrayidx.1, align 4
%2 = load i32, i32* %arrayidx.1, align 4
%3 = insertvalue [2 x i32] poison, i32 %1, 0 %3 = insertvalue [2 x i32] poison, i32 %1, 0
%oldret = insertvalue [2 x i32] %3, i32 %2, 1 %oldret = insertvalue [2 x i32] %3, i32 %2, 1
ret [2 x i32] %oldret ret [2 x i32] %oldret
} }
define dso_local void @caller_St4x3(%struct.St4x3* nocapture noundef readonly byval(%struct.St4x3) align 4 %in, %struct.St4x3* nocapture noundef writeonly %ret) { define dso_local void @caller_St4x3(ptr nocapture noundef readonly byval(%struct.St4x3) align 4 %in, ptr nocapture noundef writeonly %ret) {
; CHECK-LABEL: .visible .func caller_St4x3( ; CHECK-LABEL: .visible .func caller_St4x3(
; CHECK: .param .align 4 .b8 caller_St4x3_param_0[12], ; CHECK: .param .align 4 .b8 caller_St4x3_param_0[12],
; CHECK: .param .b32 caller_St4x3_param_1 ; CHECK: .param .b32 caller_St4x3_param_1
; CHECK: ) ; CHECK: )
; CHECK: .param .align 16 .b8 param0[12]; ; CHECK: .param .align 16 .b8 param0[12];
; CHECK: st.param.v2.b32 [param0+0], {{{%r[0-9]+}}, {{%r[0-9]+}}}; ; CHECK: st.param.v2.b32 [param0+0], {{{%r[0-9]+}}, {{%r[0-9]+}}};
; CHECK: st.param.b32 [param0+8], {{%r[0-9]+}}; ; CHECK: st.param.b32 [param0+8], {{%r[0-9]+}};
; CHECK: .param .align 16 .b8 retval0[12]; ; CHECK: .param .align 16 .b8 retval0[12];
; CHECK: call.uni (retval0), ; CHECK: call.uni (retval0),
; CHECK-NEXT: callee_St4x3, ; CHECK-NEXT: callee_St4x3,
; CHECK-NEXT: ( ; CHECK-NEXT: (
; CHECK-NEXT: param0 ; CHECK-NEXT: param0
; CHECK-NEXT: ); ; CHECK-NEXT: );
; CHECK: ld.param.v2.b32 {{{%r[0-9]+}}, {{%r[0-9]+}}}, [retval0+0]; ; CHECK: ld.param.v2.b32 {{{%r[0-9]+}}, {{%r[0-9]+}}}, [retval0+0];
; CHECK: ld.param.b32 {{%r[0-9]+}}, [retval0+8]; ; CHECK: ld.param.b32 {{%r[0-9]+}}, [retval0+8];
%call = tail call fastcc [3 x i32] @callee_St4x3(%struct.St4x3* noundef nonnull byval(%struct.St4x3) align 4 %in) %call = tail call fastcc [3 x i32] @callee_St4x3(ptr noundef nonnull byval(%struct.St4x3) align 4 %in) #2
%.fca.0.extract = extractvalue [3 x i32] %call, 0 %.fca.0.extract = extractvalue [3 x i32] %call, 0
%.fca.1.extract = extractvalue [3 x i32] %call, 1 %.fca.1.extract = extractvalue [3 x i32] %call, 1
%.fca.2.extract = extractvalue [3 x i32] %call, 2 %.fca.2.extract = extractvalue [3 x i32] %call, 2
%ref.tmp.sroa.0.0..sroa_idx = getelementptr inbounds %struct.St4x3, %struct.St4x3* %ret, i64 0, i32 0, i64 0 store i32 %.fca.0.extract, ptr %ret, align 4
store i32 %.fca.0.extract, i32* %ref.tmp.sroa.0.0..sroa_idx, align 4 %ref.tmp.sroa.4.0..sroa_idx = getelementptr inbounds i8, ptr %ret, i64 4
%ref.tmp.sroa.4.0..sroa_idx2 = getelementptr inbounds %struct.St4x3, %struct.St4x3* %ret, i64 0, i32 0, i64 1 store i32 %.fca.1.extract, ptr %ref.tmp.sroa.4.0..sroa_idx, align 4
store i32 %.fca.1.extract, i32* %ref.tmp.sroa.4.0..sroa_idx2, align 4 %ref.tmp.sroa.5.0..sroa_idx = getelementptr inbounds i8, ptr %ret, i64 8
%ref.tmp.sroa.5.0..sroa_idx4 = getelementptr inbounds %struct.St4x3, %struct.St4x3* %ret, i64 0, i32 0, i64 2 store i32 %.fca.2.extract, ptr %ref.tmp.sroa.5.0..sroa_idx, align 4
store i32 %.fca.2.extract, i32* %ref.tmp.sroa.5.0..sroa_idx4, align 4
ret void ret void
} }
define internal fastcc [3 x i32] @callee_St4x3(ptr nocapture noundef readonly byval(%struct.St4x3) align 4 %in) {
define internal fastcc [3 x i32] @callee_St4x3(%struct.St4x3* nocapture noundef readonly byval(%struct.St4x3) align 4 %in) {
; CHECK: .func (.param .align 16 .b8 func_retval0[12]) ; CHECK: .func (.param .align 16 .b8 func_retval0[12])
; CHECK-LABEL: callee_St4x3( ; CHECK-LABEL: callee_St4x3(
; CHECK-NEXT: .param .align 16 .b8 callee_St4x3_param_0[12] ; CHECK-NEXT: .param .align 16 .b8 callee_St4x3_param_0[12]
; CHECK: ld.param.v2.u32 {[[R1:%r[0-9]+]], [[R2:%r[0-9]+]]}, [callee_St4x3_param_0]; ; CHECK: ld.param.v2.u32 {[[R1:%r[0-9]+]], [[R2:%r[0-9]+]]}, [callee_St4x3_param_0];
; CHECK: ld.param.u32 [[R3:%r[0-9]+]], [callee_St4x3_param_0+8]; ; CHECK: ld.param.u32 [[R3:%r[0-9]+]], [callee_St4x3_param_0+8];
; CHECK: st.param.v2.b32 [func_retval0+0], {[[R1]], [[R2]]}; ; CHECK: st.param.v2.b32 [func_retval0+0], {[[R1]], [[R2]]};
; CHECK: st.param.b32 [func_retval0+8], [[R3]]; ; CHECK: st.param.b32 [func_retval0+8], [[R3]];
; CHECK-NEXT: ret; ; CHECK-NEXT: ret;
%arrayidx = getelementptr inbounds %struct.St4x3, %struct.St4x3* %in, i64 0, i32 0, i64 0 %1 = load i32, ptr %in, align 4
%1 = load i32, i32* %arrayidx, align 4 %arrayidx.1 = getelementptr inbounds [3 x i32], ptr %in, i64 0, i64 1
%arrayidx.1 = getelementptr inbounds %struct.St4x3, %struct.St4x3* %in, i64 0, i32 0, i64 1 %2 = load i32, ptr %arrayidx.1, align 4
%2 = load i32, i32* %arrayidx.1, align 4 %arrayidx.2 = getelementptr inbounds [3 x i32], ptr %in, i64 0, i64 2
%arrayidx.2 = getelementptr inbounds %struct.St4x3, %struct.St4x3* %in, i64 0, i32 0, i64 2 %3 = load i32, ptr %arrayidx.2, align 4
%3 = load i32, i32* %arrayidx.2, align 4
%4 = insertvalue [3 x i32] poison, i32 %1, 0 %4 = insertvalue [3 x i32] poison, i32 %1, 0
%5 = insertvalue [3 x i32] %4, i32 %2, 1 %5 = insertvalue [3 x i32] %4, i32 %2, 1
%oldret = insertvalue [3 x i32] %5, i32 %3, 2 %oldret = insertvalue [3 x i32] %5, i32 %3, 2
ret [3 x i32] %oldret ret [3 x i32] %oldret
} }
define dso_local void @caller_St4x4(ptr nocapture noundef readonly byval(%struct.St4x4) align 4 %in, ptr nocapture noundef writeonly %ret) {
define dso_local void @caller_St4x4(%struct.St4x4* nocapture noundef readonly byval(%struct.St4x4) align 4 %in, %struct.St4x4* nocapture noundef writeonly %ret) {
; CHECK-LABEL: .visible .func caller_St4x4( ; CHECK-LABEL: .visible .func caller_St4x4(
; CHECK: .param .align 4 .b8 caller_St4x4_param_0[16], ; CHECK: .param .align 4 .b8 caller_St4x4_param_0[16],
; CHECK: .param .b32 caller_St4x4_param_1 ; CHECK: .param .b32 caller_St4x4_param_1
; CHECK: ) ; CHECK: )
; CHECK: .param .align 16 .b8 param0[16]; ; CHECK: .param .align 16 .b8 param0[16];
; CHECK: st.param.v4.b32 [param0+0], {{{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}}; ; CHECK: st.param.v4.b32 [param0+0], {{{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}};
; CHECK: .param .align 16 .b8 retval0[16]; ; CHECK: .param .align 16 .b8 retval0[16];
; CHECK: call.uni (retval0), ; CHECK: call.uni (retval0),
; CHECK-NEXT: callee_St4x4, ; CHECK-NEXT: callee_St4x4,
; CHECK-NEXT: ( ; CHECK-NEXT: (
; CHECK-NEXT: param0 ; CHECK-NEXT: param0
; CHECK-NEXT: ); ; CHECK-NEXT: );
; CHECK: ld.param.v4.b32 {{{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}}, [retval0+0]; ; CHECK: ld.param.v4.b32 {{{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}}, [retval0+0];
%call = tail call fastcc [4 x i32] @callee_St4x4(%struct.St4x4* noundef nonnull byval(%struct.St4x4) align 4 %in) %call = tail call fastcc [4 x i32] @callee_St4x4(ptr noundef nonnull byval(%struct.St4x4) align 4 %in) #2
%.fca.0.extract = extractvalue [4 x i32] %call, 0 %.fca.0.extract = extractvalue [4 x i32] %call, 0
%.fca.1.extract = extractvalue [4 x i32] %call, 1 %.fca.1.extract = extractvalue [4 x i32] %call, 1
%.fca.2.extract = extractvalue [4 x i32] %call, 2 %.fca.2.extract = extractvalue [4 x i32] %call, 2
%.fca.3.extract = extractvalue [4 x i32] %call, 3 %.fca.3.extract = extractvalue [4 x i32] %call, 3
%ref.tmp.sroa.0.0..sroa_idx = getelementptr inbounds %struct.St4x4, %struct.St4x4* %ret, i64 0, i32 0, i64 0 store i32 %.fca.0.extract, ptr %ret, align 4
store i32 %.fca.0.extract, i32* %ref.tmp.sroa.0.0..sroa_idx, align 4 %ref.tmp.sroa.4.0..sroa_idx = getelementptr inbounds i8, ptr %ret, i64 4
%ref.tmp.sroa.4.0..sroa_idx3 = getelementptr inbounds %struct.St4x4, %struct.St4x4* %ret, i64 0, i32 0, i64 1 store i32 %.fca.1.extract, ptr %ref.tmp.sroa.4.0..sroa_idx, align 4
store i32 %.fca.1.extract, i32* %ref.tmp.sroa.4.0..sroa_idx3, align 4 %ref.tmp.sroa.5.0..sroa_idx = getelementptr inbounds i8, ptr %ret, i64 8
%ref.tmp.sroa.5.0..sroa_idx5 = getelementptr inbounds %struct.St4x4, %struct.St4x4* %ret, i64 0, i32 0, i64 2 store i32 %.fca.2.extract, ptr %ref.tmp.sroa.5.0..sroa_idx, align 4
store i32 %.fca.2.extract, i32* %ref.tmp.sroa.5.0..sroa_idx5, align 4 %ref.tmp.sroa.6.0..sroa_idx = getelementptr inbounds i8, ptr %ret, i64 12
%ref.tmp.sroa.6.0..sroa_idx7 = getelementptr inbounds %struct.St4x4, %struct.St4x4* %ret, i64 0, i32 0, i64 3 store i32 %.fca.3.extract, ptr %ref.tmp.sroa.6.0..sroa_idx, align 4
store i32 %.fca.3.extract, i32* %ref.tmp.sroa.6.0..sroa_idx7, align 4
ret void ret void
} }
define internal fastcc [4 x i32] @callee_St4x4(ptr nocapture noundef readonly byval(%struct.St4x4) align 4 %in) {
define internal fastcc [4 x i32] @callee_St4x4(%struct.St4x4* nocapture noundef readonly byval(%struct.St4x4) align 4 %in) {
; CHECK: .func (.param .align 16 .b8 func_retval0[16]) ; CHECK: .func (.param .align 16 .b8 func_retval0[16])
; CHECK-LABEL: callee_St4x4( ; CHECK-LABEL: callee_St4x4(
; CHECK-NEXT: .param .align 16 .b8 callee_St4x4_param_0[16] ; CHECK-NEXT: .param .align 16 .b8 callee_St4x4_param_0[16]
; CHECK: ld.param.v4.u32 {[[R1:%r[0-9]+]], [[R2:%r[0-9]+]], [[R3:%r[0-9]+]], [[R4:%r[0-9]+]]}, [callee_St4x4_param_0]; ; CHECK: ld.param.v4.u32 {[[R1:%r[0-9]+]], [[R2:%r[0-9]+]], [[R3:%r[0-9]+]], [[R4:%r[0-9]+]]}, [callee_St4x4_param_0];
; CHECK: st.param.v4.b32 [func_retval0+0], {[[R1]], [[R2]], [[R3]], [[R4]]}; ; CHECK: st.param.v4.b32 [func_retval0+0], {[[R1]], [[R2]], [[R3]], [[R4]]};
; CHECK-NEXT: ret; ; CHECK-NEXT: ret;
%arrayidx = getelementptr inbounds %struct.St4x4, %struct.St4x4* %in, i64 0, i32 0, i64 0 %1 = load i32, ptr %in, align 4
%1 = load i32, i32* %arrayidx, align 4 %arrayidx.1 = getelementptr inbounds [4 x i32], ptr %in, i64 0, i64 1
%arrayidx.1 = getelementptr inbounds %struct.St4x4, %struct.St4x4* %in, i64 0, i32 0, i64 1 %2 = load i32, ptr %arrayidx.1, align 4
%2 = load i32, i32* %arrayidx.1, align 4 %arrayidx.2 = getelementptr inbounds [4 x i32], ptr %in, i64 0, i64 2
%arrayidx.2 = getelementptr inbounds %struct.St4x4, %struct.St4x4* %in, i64 0, i32 0, i64 2 %3 = load i32, ptr %arrayidx.2, align 4
%3 = load i32, i32* %arrayidx.2, align 4 %arrayidx.3 = getelementptr inbounds [4 x i32], ptr %in, i64 0, i64 3
%arrayidx.3 = getelementptr inbounds %struct.St4x4, %struct.St4x4* %in, i64 0, i32 0, i64 3 %4 = load i32, ptr %arrayidx.3, align 4
%4 = load i32, i32* %arrayidx.3, align 4
%5 = insertvalue [4 x i32] poison, i32 %1, 0 %5 = insertvalue [4 x i32] poison, i32 %1, 0
%6 = insertvalue [4 x i32] %5, i32 %2, 1 %6 = insertvalue [4 x i32] %5, i32 %2, 1
%7 = insertvalue [4 x i32] %6, i32 %3, 2 %7 = insertvalue [4 x i32] %6, i32 %3, 2
%oldret = insertvalue [4 x i32] %7, i32 %4, 3 %oldret = insertvalue [4 x i32] %7, i32 %4, 3
ret [4 x i32] %oldret ret [4 x i32] %oldret
} }
define dso_local void @caller_St4x5(ptr nocapture noundef readonly byval(%struct.St4x5) align 4 %in, ptr nocapture noundef writeonly %ret) {
define dso_local void @caller_St4x5(%struct.St4x5* nocapture noundef readonly byval(%struct.St4x5) align 4 %in, %struct.St4x5* nocapture noundef writeonly %ret) {
; CHECK-LABEL: .visible .func caller_St4x5( ; CHECK-LABEL: .visible .func caller_St4x5(
; CHECK: .param .align 4 .b8 caller_St4x5_param_0[20], ; CHECK: .param .align 4 .b8 caller_St4x5_param_0[20],
; CHECK: .param .b32 caller_St4x5_param_1 ; CHECK: .param .b32 caller_St4x5_param_1
; CHECK: ) ; CHECK: )
; CHECK: .param .align 16 .b8 param0[20]; ; CHECK: .param .align 16 .b8 param0[20];
; CHECK: st.param.v4.b32 [param0+0], {{{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}}; ; CHECK: st.param.v4.b32 [param0+0], {{{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}};
; CHECK: st.param.b32 [param0+16], {{%r[0-9]+}}; ; CHECK: st.param.b32 [param0+16], {{%r[0-9]+}};
; CHECK: .param .align 16 .b8 retval0[20]; ; CHECK: .param .align 16 .b8 retval0[20];
; CHECK: call.uni (retval0), ; CHECK: call.uni (retval0),
; CHECK-NEXT: callee_St4x5, ; CHECK-NEXT: callee_St4x5,
; CHECK-NEXT: ( ; CHECK-NEXT: (
; CHECK-NEXT: param0 ; CHECK-NEXT: param0
; CHECK-NEXT: ); ; CHECK-NEXT: );
; CHECK: ld.param.v4.b32 {{{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}}, [retval0+0]; ; CHECK: ld.param.v4.b32 {{{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}}, [retval0+0];
; CHECK: ld.param.b32 {{%r[0-9]+}}, [retval0+16]; ; CHECK: ld.param.b32 {{%r[0-9]+}}, [retval0+16];
%call = tail call fastcc [5 x i32] @callee_St4x5(%struct.St4x5* noundef nonnull byval(%struct.St4x5) align 4 %in) %call = tail call fastcc [5 x i32] @callee_St4x5(ptr noundef nonnull byval(%struct.St4x5) align 4 %in) #2
%.fca.0.extract = extractvalue [5 x i32] %call, 0 %.fca.0.extract = extractvalue [5 x i32] %call, 0
%.fca.1.extract = extractvalue [5 x i32] %call, 1 %.fca.1.extract = extractvalue [5 x i32] %call, 1
%.fca.2.extract = extractvalue [5 x i32] %call, 2 %.fca.2.extract = extractvalue [5 x i32] %call, 2
%.fca.3.extract = extractvalue [5 x i32] %call, 3 %.fca.3.extract = extractvalue [5 x i32] %call, 3
%.fca.4.extract = extractvalue [5 x i32] %call, 4 %.fca.4.extract = extractvalue [5 x i32] %call, 4
%ref.tmp.sroa.0.0..sroa_idx = getelementptr inbounds %struct.St4x5, %struct.St4x5* %ret, i64 0, i32 0, i64 0 store i32 %.fca.0.extract, ptr %ret, align 4
store i32 %.fca.0.extract, i32* %ref.tmp.sroa.0.0..sroa_idx, align 4 %ref.tmp.sroa.4.0..sroa_idx = getelementptr inbounds i8, ptr %ret, i64 4
%ref.tmp.sroa.4.0..sroa_idx3 = getelementptr inbounds %struct.St4x5, %struct.St4x5* %ret, i64 0, i32 0, i64 1 store i32 %.fca.1.extract, ptr %ref.tmp.sroa.4.0..sroa_idx, align 4
store i32 %.fca.1.extract, i32* %ref.tmp.sroa.4.0..sroa_idx3, align 4 %ref.tmp.sroa.5.0..sroa_idx = getelementptr inbounds i8, ptr %ret, i64 8
%ref.tmp.sroa.5.0..sroa_idx5 = getelementptr inbounds %struct.St4x5, %struct.St4x5* %ret, i64 0, i32 0, i64 2 store i32 %.fca.2.extract, ptr %ref.tmp.sroa.5.0..sroa_idx, align 4
store i32 %.fca.2.extract, i32* %ref.tmp.sroa.5.0..sroa_idx5, align 4 %ref.tmp.sroa.6.0..sroa_idx = getelementptr inbounds i8, ptr %ret, i64 12
%ref.tmp.sroa.6.0..sroa_idx7 = getelementptr inbounds %struct.St4x5, %struct.St4x5* %ret, i64 0, i32 0, i64 3 store i32 %.fca.3.extract, ptr %ref.tmp.sroa.6.0..sroa_idx, align 4
store i32 %.fca.3.extract, i32* %ref.tmp.sroa.6.0..sroa_idx7, align 4 %ref.tmp.sroa.7.0..sroa_idx = getelementptr inbounds i8, ptr %ret, i64 16
%ref.tmp.sroa.7.0..sroa_idx9 = getelementptr inbounds %struct.St4x5, %struct.St4x5* %ret, i64 0, i32 0, i64 4 store i32 %.fca.4.extract, ptr %ref.tmp.sroa.7.0..sroa_idx, align 4
store i32 %.fca.4.extract, i32* %ref.tmp.sroa.7.0..sroa_idx9, align 4
ret void ret void
} }
define internal fastcc [5 x i32] @callee_St4x5(ptr nocapture noundef readonly byval(%struct.St4x5) align 4 %in) {
define internal fastcc [5 x i32] @callee_St4x5(%struct.St4x5* nocapture noundef readonly byval(%struct.St4x5) align 4 %in) {
; CHECK: .func (.param .align 16 .b8 func_retval0[20]) ; CHECK: .func (.param .align 16 .b8 func_retval0[20])
; CHECK-LABEL: callee_St4x5( ; CHECK-LABEL: callee_St4x5(
; CHECK-NEXT: .param .align 16 .b8 callee_St4x5_param_0[20] ; CHECK-NEXT: .param .align 16 .b8 callee_St4x5_param_0[20]
; CHECK: ld.param.v4.u32 {[[R1:%r[0-9]+]], [[R2:%r[0-9]+]], [[R3:%r[0-9]+]], [[R4:%r[0-9]+]]}, [callee_St4x5_param_0]; ; CHECK: ld.param.v4.u32 {[[R1:%r[0-9]+]], [[R2:%r[0-9]+]], [[R3:%r[0-9]+]], [[R4:%r[0-9]+]]}, [callee_St4x5_param_0];
; CHECK: ld.param.u32 [[R5:%r[0-9]+]], [callee_St4x5_param_0+16]; ; CHECK: ld.param.u32 [[R5:%r[0-9]+]], [callee_St4x5_param_0+16];
; CHECK: st.param.v4.b32 [func_retval0+0], {[[R1]], [[R2]], [[R3]], [[R4]]}; ; CHECK: st.param.v4.b32 [func_retval0+0], {[[R1]], [[R2]], [[R3]], [[R4]]};
; CHECK: st.param.b32 [func_retval0+16], [[R5]]; ; CHECK: st.param.b32 [func_retval0+16], [[R5]];
; CHECK-NEXT: ret; ; CHECK-NEXT: ret;
%arrayidx = getelementptr inbounds %struct.St4x5, %struct.St4x5* %in, i64 0, i32 0, i64 0 %1 = load i32, ptr %in, align 4
%1 = load i32, i32* %arrayidx, align 4 %arrayidx.1 = getelementptr inbounds [5 x i32], ptr %in, i64 0, i64 1
%arrayidx.1 = getelementptr inbounds %struct.St4x5, %struct.St4x5* %in, i64 0, i32 0, i64 1 %2 = load i32, ptr %arrayidx.1, align 4
%2 = load i32, i32* %arrayidx.1, align 4 %arrayidx.2 = getelementptr inbounds [5 x i32], ptr %in, i64 0, i64 2
%arrayidx.2 = getelementptr inbounds %struct.St4x5, %struct.St4x5* %in, i64 0, i32 0, i64 2 %3 = load i32, ptr %arrayidx.2, align 4
%3 = load i32, i32* %arrayidx.2, align 4 %arrayidx.3 = getelementptr inbounds [5 x i32], ptr %in, i64 0, i64 3
%arrayidx.3 = getelementptr inbounds %struct.St4x5, %struct.St4x5* %in, i64 0, i32 0, i64 3 %4 = load i32, ptr %arrayidx.3, align 4
%4 = load i32, i32* %arrayidx.3, align 4 %arrayidx.4 = getelementptr inbounds [5 x i32], ptr %in, i64 0, i64 4
%arrayidx.4 = getelementptr inbounds %struct.St4x5, %struct.St4x5* %in, i64 0, i32 0, i64 4 %5 = load i32, ptr %arrayidx.4, align 4
%5 = load i32, i32* %arrayidx.4, align 4
%6 = insertvalue [5 x i32] poison, i32 %1, 0 %6 = insertvalue [5 x i32] poison, i32 %1, 0
%7 = insertvalue [5 x i32] %6, i32 %2, 1 %7 = insertvalue [5 x i32] %6, i32 %2, 1
%8 = insertvalue [5 x i32] %7, i32 %3, 2 %8 = insertvalue [5 x i32] %7, i32 %3, 2
%9 = insertvalue [5 x i32] %8, i32 %4, 3 %9 = insertvalue [5 x i32] %8, i32 %4, 3
%oldret = insertvalue [5 x i32] %9, i32 %5, 4 %oldret = insertvalue [5 x i32] %9, i32 %5, 4
ret [5 x i32] %oldret ret [5 x i32] %oldret
} }
define dso_local void @caller_St4x6(ptr nocapture noundef readonly byval(%struct.St4x6) align 4 %in, ptr nocapture noundef writeonly %ret) {
define dso_local void @caller_St4x6(%struct.St4x6* nocapture noundef readonly byval(%struct.St4x6) align 4 %in, %struct.St4x6* nocapture noundef writeonly %ret) {
; CHECK-LABEL: .visible .func caller_St4x6( ; CHECK-LABEL: .visible .func caller_St4x6(
; CHECK: .param .align 4 .b8 caller_St4x6_param_0[24], ; CHECK: .param .align 4 .b8 caller_St4x6_param_0[24],
; CHECK: .param .b32 caller_St4x6_param_1 ; CHECK: .param .b32 caller_St4x6_param_1
; CHECK: ) ; CHECK: )
; CHECK: .param .align 16 .b8 param0[24]; ; CHECK: .param .align 16 .b8 param0[24];
; CHECK: st.param.v4.b32 [param0+0], {{{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}}; ; CHECK: st.param.v4.b32 [param0+0], {{{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}};
; CHECK: st.param.v2.b32 [param0+16], {{{%r[0-9]+}}, {{%r[0-9]+}}}; ; CHECK: st.param.v2.b32 [param0+16], {{{%r[0-9]+}}, {{%r[0-9]+}}};
; CHECK: .param .align 16 .b8 retval0[24]; ; CHECK: .param .align 16 .b8 retval0[24];
; CHECK: call.uni (retval0), ; CHECK: call.uni (retval0),
; CHECK-NEXT: callee_St4x6, ; CHECK-NEXT: callee_St4x6,
; CHECK-NEXT: ( ; CHECK-NEXT: (
; CHECK-NEXT: param0 ; CHECK-NEXT: param0
; CHECK-NEXT: ); ; CHECK-NEXT: );
; CHECK: ld.param.v4.b32 {{{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}}, [retval0+0]; ; CHECK: ld.param.v4.b32 {{{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}}, [retval0+0];
; CHECK: ld.param.v2.b32 {{{%r[0-9]+}}, {{%r[0-9]+}}}, [retval0+16]; ; CHECK: ld.param.v2.b32 {{{%r[0-9]+}}, {{%r[0-9]+}}}, [retval0+16];
%call = tail call fastcc [6 x i32] @callee_St4x6(%struct.St4x6* noundef nonnull byval(%struct.St4x6) align 4 %in) %call = tail call fastcc [6 x i32] @callee_St4x6(ptr noundef nonnull byval(%struct.St4x6) align 4 %in) #2
%.fca.0.extract = extractvalue [6 x i32] %call, 0 %.fca.0.extract = extractvalue [6 x i32] %call, 0
%.fca.1.extract = extractvalue [6 x i32] %call, 1 %.fca.1.extract = extractvalue [6 x i32] %call, 1
%.fca.2.extract = extractvalue [6 x i32] %call, 2 %.fca.2.extract = extractvalue [6 x i32] %call, 2
%.fca.3.extract = extractvalue [6 x i32] %call, 3 %.fca.3.extract = extractvalue [6 x i32] %call, 3
%.fca.4.extract = extractvalue [6 x i32] %call, 4 %.fca.4.extract = extractvalue [6 x i32] %call, 4
%.fca.5.extract = extractvalue [6 x i32] %call, 5 %.fca.5.extract = extractvalue [6 x i32] %call, 5
%ref.tmp.sroa.0.0..sroa_idx = getelementptr inbounds %struct.St4x6, %struct.St4x6* %ret, i64 0, i32 0, i64 0 store i32 %.fca.0.extract, ptr %ret, align 4
store i32 %.fca.0.extract, i32* %ref.tmp.sroa.0.0..sroa_idx, align 4 %ref.tmp.sroa.4.0..sroa_idx = getelementptr inbounds i8, ptr %ret, i64 4
%ref.tmp.sroa.4.0..sroa_idx2 = getelementptr inbounds %struct.St4x6, %struct.St4x6* %ret, i64 0, i32 0, i64 1 store i32 %.fca.1.extract, ptr %ref.tmp.sroa.4.0..sroa_idx, align 4
store i32 %.fca.1.extract, i32* %ref.tmp.sroa.4.0..sroa_idx2, align 4 %ref.tmp.sroa.5.0..sroa_idx = getelementptr inbounds i8, ptr %ret, i64 8
%ref.tmp.sroa.5.0..sroa_idx4 = getelementptr inbounds %struct.St4x6, %struct.St4x6* %ret, i64 0, i32 0, i64 2 store i32 %.fca.2.extract, ptr %ref.tmp.sroa.5.0..sroa_idx, align 4
store i32 %.fca.2.extract, i32* %ref.tmp.sroa.5.0..sroa_idx4, align 4 %ref.tmp.sroa.6.0..sroa_idx = getelementptr inbounds i8, ptr %ret, i64 12
%ref.tmp.sroa.6.0..sroa_idx6 = getelementptr inbounds %struct.St4x6, %struct.St4x6* %ret, i64 0, i32 0, i64 3 store i32 %.fca.3.extract, ptr %ref.tmp.sroa.6.0..sroa_idx, align 4
store i32 %.fca.3.extract, i32* %ref.tmp.sroa.6.0..sroa_idx6, align 4 %ref.tmp.sroa.7.0..sroa_idx = getelementptr inbounds i8, ptr %ret, i64 16
%ref.tmp.sroa.7.0..sroa_idx8 = getelementptr inbounds %struct.St4x6, %struct.St4x6* %ret, i64 0, i32 0, i64 4 store i32 %.fca.4.extract, ptr %ref.tmp.sroa.7.0..sroa_idx, align 4
store i32 %.fca.4.extract, i32* %ref.tmp.sroa.7.0..sroa_idx8, align 4 %ref.tmp.sroa.8.0..sroa_idx = getelementptr inbounds i8, ptr %ret, i64 20
%ref.tmp.sroa.8.0..sroa_idx10 = getelementptr inbounds %struct.St4x6, %struct.St4x6* %ret, i64 0, i32 0, i64 5 store i32 %.fca.5.extract, ptr %ref.tmp.sroa.8.0..sroa_idx, align 4
store i32 %.fca.5.extract, i32* %ref.tmp.sroa.8.0..sroa_idx10, align 4
ret void ret void
} }
define internal fastcc [6 x i32] @callee_St4x6(ptr nocapture noundef readonly byval(%struct.St4x6) align 4 %in) {
define internal fastcc [6 x i32] @callee_St4x6(%struct.St4x6* nocapture noundef readonly byval(%struct.St4x6) align 4 %in) {
; CHECK: .func (.param .align 16 .b8 func_retval0[24]) ; CHECK: .func (.param .align 16 .b8 func_retval0[24])
; CHECK-LABEL: callee_St4x6( ; CHECK-LABEL: callee_St4x6(
; CHECK-NEXT: .param .align 16 .b8 callee_St4x6_param_0[24] ; CHECK-NEXT: .param .align 16 .b8 callee_St4x6_param_0[24]
; CHECK: ld.param.v4.u32 {[[R1:%r[0-9]+]], [[R2:%r[0-9]+]], [[R3:%r[0-9]+]], [[R4:%r[0-9]+]]}, [callee_St4x6_param_0]; ; CHECK: ld.param.v4.u32 {[[R1:%r[0-9]+]], [[R2:%r[0-9]+]], [[R3:%r[0-9]+]], [[R4:%r[0-9]+]]}, [callee_St4x6_param_0];
; CHECK: ld.param.v2.u32 {[[R5:%r[0-9]+]], [[R6:%r[0-9]+]]}, [callee_St4x6_param_0+16]; ; CHECK: ld.param.v2.u32 {[[R5:%r[0-9]+]], [[R6:%r[0-9]+]]}, [callee_St4x6_param_0+16];
; CHECK: st.param.v4.b32 [func_retval0+0], {[[R1]], [[R2]], [[R3]], [[R4]]}; ; CHECK: st.param.v4.b32 [func_retval0+0], {[[R1]], [[R2]], [[R3]], [[R4]]};
; CHECK: st.param.v2.b32 [func_retval0+16], {[[R5]], [[R6]]}; ; CHECK: st.param.v2.b32 [func_retval0+16], {[[R5]], [[R6]]};
; CHECK-NEXT: ret; ; CHECK-NEXT: ret;
%arrayidx = getelementptr inbounds %struct.St4x6, %struct.St4x6* %in, i64 0, i32 0, i64 0 %1 = load i32, ptr %in, align 4
%1 = load i32, i32* %arrayidx, align 4 %arrayidx.1 = getelementptr inbounds [6 x i32], ptr %in, i64 0, i64 1
%arrayidx.1 = getelementptr inbounds %struct.St4x6, %struct.St4x6* %in, i64 0, i32 0, i64 1 %2 = load i32, ptr %arrayidx.1, align 4
%2 = load i32, i32* %arrayidx.1, align 4 %arrayidx.2 = getelementptr inbounds [6 x i32], ptr %in, i64 0, i64 2
%arrayidx.2 = getelementptr inbounds %struct.St4x6, %struct.St4x6* %in, i64 0, i32 0, i64 2 %3 = load i32, ptr %arrayidx.2, align 4
%3 = load i32, i32* %arrayidx.2, align 4 %arrayidx.3 = getelementptr inbounds [6 x i32], ptr %in, i64 0, i64 3
%arrayidx.3 = getelementptr inbounds %struct.St4x6, %struct.St4x6* %in, i64 0, i32 0, i64 3 %4 = load i32, ptr %arrayidx.3, align 4
%4 = load i32, i32* %arrayidx.3, align 4 %arrayidx.4 = getelementptr inbounds [6 x i32], ptr %in, i64 0, i64 4
%arrayidx.4 = getelementptr inbounds %struct.St4x6, %struct.St4x6* %in, i64 0, i32 0, i64 4 %5 = load i32, ptr %arrayidx.4, align 4
%5 = load i32, i32* %arrayidx.4, align 4 %arrayidx.5 = getelementptr inbounds [6 x i32], ptr %in, i64 0, i64 5
%arrayidx.5 = getelementptr inbounds %struct.St4x6, %struct.St4x6* %in, i64 0, i32 0, i64 5 %6 = load i32, ptr %arrayidx.5, align 4
%6 = load i32, i32* %arrayidx.5, align 4
%7 = insertvalue [6 x i32] poison, i32 %1, 0 %7 = insertvalue [6 x i32] poison, i32 %1, 0
%8 = insertvalue [6 x i32] %7, i32 %2, 1 %8 = insertvalue [6 x i32] %7, i32 %2, 1
%9 = insertvalue [6 x i32] %8, i32 %3, 2 %9 = insertvalue [6 x i32] %8, i32 %3, 2
%10 = insertvalue [6 x i32] %9, i32 %4, 3 %10 = insertvalue [6 x i32] %9, i32 %4, 3
%11 = insertvalue [6 x i32] %10, i32 %5, 4 %11 = insertvalue [6 x i32] %10, i32 %5, 4
%oldret = insertvalue [6 x i32] %11, i32 %6, 5 %oldret = insertvalue [6 x i32] %11, i32 %6, 5
ret [6 x i32] %oldret ret [6 x i32] %oldret
} }
define dso_local void @caller_St4x7(ptr nocapture noundef readonly byval(%struct.St4x7) align 4 %in, ptr nocapture noundef writeonly %ret) {
define dso_local void @caller_St4x7(%struct.St4x7* nocapture noundef readonly byval(%struct.St4x7) align 4 %in, %struct.St4x7* nocapture noundef writeonly %ret) {
; CHECK-LABEL: .visible .func caller_St4x7( ; CHECK-LABEL: .visible .func caller_St4x7(
; CHECK: .param .align 4 .b8 caller_St4x7_param_0[28], ; CHECK: .param .align 4 .b8 caller_St4x7_param_0[28],
; CHECK: .param .b32 caller_St4x7_param_1 ; CHECK: .param .b32 caller_St4x7_param_1
; CHECK: ) ; CHECK: )
; CHECK: .param .align 16 .b8 param0[28]; ; CHECK: .param .align 16 .b8 param0[28];
; CHECK: st.param.v4.b32 [param0+0], {{{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}}; ; CHECK: st.param.v4.b32 [param0+0], {{{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}};
; CHECK: st.param.v2.b32 [param0+16], {{{%r[0-9]+}}, {{%r[0-9]+}}}; ; CHECK: st.param.v2.b32 [param0+16], {{{%r[0-9]+}}, {{%r[0-9]+}}};
; CHECK: st.param.b32 [param0+24], {{%r[0-9]+}}; ; CHECK: st.param.b32 [param0+24], {{%r[0-9]+}};
; CHECK: .param .align 16 .b8 retval0[28]; ; CHECK: .param .align 16 .b8 retval0[28];
; CHECK: call.uni (retval0), ; CHECK: call.uni (retval0),
; CHECK-NEXT: callee_St4x7, ; CHECK-NEXT: callee_St4x7,
; CHECK-NEXT: ( ; CHECK-NEXT: (
; CHECK-NEXT: param0 ; CHECK-NEXT: param0
; CHECK-NEXT: ); ; CHECK-NEXT: );
; CHECK: ld.param.v4.b32 {{{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}}, [retval0+0]; ; CHECK: ld.param.v4.b32 {{{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}}, [retval0+0];
; CHECK: ld.param.v2.b32 {{{%r[0-9]+}}, {{%r[0-9]+}}}, [retval0+16]; ; CHECK: ld.param.v2.b32 {{{%r[0-9]+}}, {{%r[0-9]+}}}, [retval0+16];
; CHECK: ld.param.b32 {{%r[0-9]+}}, [retval0+24]; ; CHECK: ld.param.b32 {{%r[0-9]+}}, [retval0+24];
%call = tail call fastcc [7 x i32] @callee_St4x7(%struct.St4x7* noundef nonnull byval(%struct.St4x7) align 4 %in) %call = tail call fastcc [7 x i32] @callee_St4x7(ptr noundef nonnull byval(%struct.St4x7) align 4 %in) #2
%.fca.0.extract = extractvalue [7 x i32] %call, 0 %.fca.0.extract = extractvalue [7 x i32] %call, 0
%.fca.1.extract = extractvalue [7 x i32] %call, 1 %.fca.1.extract = extractvalue [7 x i32] %call, 1
%.fca.2.extract = extractvalue [7 x i32] %call, 2 %.fca.2.extract = extractvalue [7 x i32] %call, 2
%.fca.3.extract = extractvalue [7 x i32] %call, 3 %.fca.3.extract = extractvalue [7 x i32] %call, 3
%.fca.4.extract = extractvalue [7 x i32] %call, 4 %.fca.4.extract = extractvalue [7 x i32] %call, 4
%.fca.5.extract = extractvalue [7 x i32] %call, 5 %.fca.5.extract = extractvalue [7 x i32] %call, 5
%.fca.6.extract = extractvalue [7 x i32] %call, 6 %.fca.6.extract = extractvalue [7 x i32] %call, 6
%ref.tmp.sroa.0.0..sroa_idx = getelementptr inbounds %struct.St4x7, %struct.St4x7* %ret, i64 0, i32 0, i64 0 store i32 %.fca.0.extract, ptr %ret, align 4
store i32 %.fca.0.extract, i32* %ref.tmp.sroa.0.0..sroa_idx, align 4 %ref.tmp.sroa.4.0..sroa_idx = getelementptr inbounds i8, ptr %ret, i64 4
%ref.tmp.sroa.4.0..sroa_idx2 = getelementptr inbounds %struct.St4x7, %struct.St4x7* %ret, i64 0, i32 0, i64 1 store i32 %.fca.1.extract, ptr %ref.tmp.sroa.4.0..sroa_idx, align 4
store i32 %.fca.1.extract, i32* %ref.tmp.sroa.4.0..sroa_idx2, align 4 %ref.tmp.sroa.5.0..sroa_idx = getelementptr inbounds i8, ptr %ret, i64 8
%ref.tmp.sroa.5.0..sroa_idx4 = getelementptr inbounds %struct.St4x7, %struct.St4x7* %ret, i64 0, i32 0, i64 2 store i32 %.fca.2.extract, ptr %ref.tmp.sroa.5.0..sroa_idx, align 4
store i32 %.fca.2.extract, i32* %ref.tmp.sroa.5.0..sroa_idx4, align 4 %ref.tmp.sroa.6.0..sroa_idx = getelementptr inbounds i8, ptr %ret, i64 12
%ref.tmp.sroa.6.0..sroa_idx6 = getelementptr inbounds %struct.St4x7, %struct.St4x7* %ret, i64 0, i32 0, i64 3 store i32 %.fca.3.extract, ptr %ref.tmp.sroa.6.0..sroa_idx, align 4
store i32 %.fca.3.extract, i32* %ref.tmp.sroa.6.0..sroa_idx6, align 4 %ref.tmp.sroa.7.0..sroa_idx = getelementptr inbounds i8, ptr %ret, i64 16
%ref.tmp.sroa.7.0..sroa_idx8 = getelementptr inbounds %struct.St4x7, %struct.St4x7* %ret, i64 0, i32 0, i64 4 store i32 %.fca.4.extract, ptr %ref.tmp.sroa.7.0..sroa_idx, align 4
store i32 %.fca.4.extract, i32* %ref.tmp.sroa.7.0..sroa_idx8, align 4 %ref.tmp.sroa.8.0..sroa_idx = getelementptr inbounds i8, ptr %ret, i64 20
%ref.tmp.sroa.8.0..sroa_idx10 = getelementptr inbounds %struct.St4x7, %struct.St4x7* %ret, i64 0, i32 0, i64 5 store i32 %.fca.5.extract, ptr %ref.tmp.sroa.8.0..sroa_idx, align 4
store i32 %.fca.5.extract, i32* %ref.tmp.sroa.8.0..sroa_idx10, align 4 %ref.tmp.sroa.9.0..sroa_idx = getelementptr inbounds i8, ptr %ret, i64 24
%ref.tmp.sroa.9.0..sroa_idx12 = getelementptr inbounds %struct.St4x7, %struct.St4x7* %ret, i64 0, i32 0, i64 6 store i32 %.fca.6.extract, ptr %ref.tmp.sroa.9.0..sroa_idx, align 4
store i32 %.fca.6.extract, i32* %ref.tmp.sroa.9.0..sroa_idx12, align 4
ret void ret void
} }
define internal fastcc [7 x i32] @callee_St4x7(ptr nocapture noundef readonly byval(%struct.St4x7) align 4 %in) {
define internal fastcc [7 x i32] @callee_St4x7(%struct.St4x7* nocapture noundef readonly byval(%struct.St4x7) align 4 %in) {
; CHECK: .func (.param .align 16 .b8 func_retval0[28]) ; CHECK: .func (.param .align 16 .b8 func_retval0[28])
; CHECK-LABEL: callee_St4x7( ; CHECK-LABEL: callee_St4x7(
; CHECK-NEXT: .param .align 16 .b8 callee_St4x7_param_0[28] ; CHECK-NEXT: .param .align 16 .b8 callee_St4x7_param_0[28]
; CHECK: ld.param.v4.u32 {[[R1:%r[0-9]+]], [[R2:%r[0-9]+]], [[R3:%r[0-9]+]], [[R4:%r[0-9]+]]}, [callee_St4x7_param_0]; ; CHECK: ld.param.v4.u32 {[[R1:%r[0-9]+]], [[R2:%r[0-9]+]], [[R3:%r[0-9]+]], [[R4:%r[0-9]+]]}, [callee_St4x7_param_0];
; CHECK: ld.param.v2.u32 {[[R5:%r[0-9]+]], [[R6:%r[0-9]+]]}, [callee_St4x7_param_0+16]; ; CHECK: ld.param.v2.u32 {[[R5:%r[0-9]+]], [[R6:%r[0-9]+]]}, [callee_St4x7_param_0+16];
; CHECK: ld.param.u32 [[R7:%r[0-9]+]], [callee_St4x7_param_0+24]; ; CHECK: ld.param.u32 [[R7:%r[0-9]+]], [callee_St4x7_param_0+24];
; CHECK: st.param.v4.b32 [func_retval0+0], {[[R1]], [[R2]], [[R3]], [[R4]]}; ; CHECK: st.param.v4.b32 [func_retval0+0], {[[R1]], [[R2]], [[R3]], [[R4]]};
; CHECK: st.param.v2.b32 [func_retval0+16], {[[R5]], [[R6]]}; ; CHECK: st.param.v2.b32 [func_retval0+16], {[[R5]], [[R6]]};
; CHECK: st.param.b32 [func_retval0+24], [[R7]]; ; CHECK: st.param.b32 [func_retval0+24], [[R7]];
; CHECK-NEXT: ret; ; CHECK-NEXT: ret;
%arrayidx = getelementptr inbounds %struct.St4x7, %struct.St4x7* %in, i64 0, i32 0, i64 0 %1 = load i32, ptr %in, align 4
%1 = load i32, i32* %arrayidx, align 4 %arrayidx.1 = getelementptr inbounds [7 x i32], ptr %in, i64 0, i64 1
%arrayidx.1 = getelementptr inbounds %struct.St4x7, %struct.St4x7* %in, i64 0, i32 0, i64 1 %2 = load i32, ptr %arrayidx.1, align 4
%2 = load i32, i32* %arrayidx.1, align 4 %arrayidx.2 = getelementptr inbounds [7 x i32], ptr %in, i64 0, i64 2
%arrayidx.2 = getelementptr inbounds %struct.St4x7, %struct.St4x7* %in, i64 0, i32 0, i64 2 %3 = load i32, ptr %arrayidx.2, align 4
%3 = load i32, i32* %arrayidx.2, align 4 %arrayidx.3 = getelementptr inbounds [7 x i32], ptr %in, i64 0, i64 3
%arrayidx.3 = getelementptr inbounds %struct.St4x7, %struct.St4x7* %in, i64 0, i32 0, i64 3 %4 = load i32, ptr %arrayidx.3, align 4
%4 = load i32, i32* %arrayidx.3, align 4 %arrayidx.4 = getelementptr inbounds [7 x i32], ptr %in, i64 0, i64 4
%arrayidx.4 = getelementptr inbounds %struct.St4x7, %struct.St4x7* %in, i64 0, i32 0, i64 4 %5 = load i32, ptr %arrayidx.4, align 4
%5 = load i32, i32* %arrayidx.4, align 4 %arrayidx.5 = getelementptr inbounds [7 x i32], ptr %in, i64 0, i64 5
%arrayidx.5 = getelementptr inbounds %struct.St4x7, %struct.St4x7* %in, i64 0, i32 0, i64 5 %6 = load i32, ptr %arrayidx.5, align 4
%6 = load i32, i32* %arrayidx.5, align 4 %arrayidx.6 = getelementptr inbounds [7 x i32], ptr %in, i64 0, i64 6
%arrayidx.6 = getelementptr inbounds %struct.St4x7, %struct.St4x7* %in, i64 0, i32 0, i64 6 %7 = load i32, ptr %arrayidx.6, align 4
%7 = load i32, i32* %arrayidx.6, align 4
%8 = insertvalue [7 x i32] poison, i32 %1, 0 %8 = insertvalue [7 x i32] poison, i32 %1, 0
%9 = insertvalue [7 x i32] %8, i32 %2, 1 %9 = insertvalue [7 x i32] %8, i32 %2, 1
%10 = insertvalue [7 x i32] %9, i32 %3, 2 %10 = insertvalue [7 x i32] %9, i32 %3, 2
%11 = insertvalue [7 x i32] %10, i32 %4, 3 %11 = insertvalue [7 x i32] %10, i32 %4, 3
%12 = insertvalue [7 x i32] %11, i32 %5, 4 %12 = insertvalue [7 x i32] %11, i32 %5, 4
%13 = insertvalue [7 x i32] %12, i32 %6, 5 %13 = insertvalue [7 x i32] %12, i32 %6, 5
%oldret = insertvalue [7 x i32] %13, i32 %7, 6 %oldret = insertvalue [7 x i32] %13, i32 %7, 6
ret [7 x i32] %oldret ret [7 x i32] %oldret
} }
define dso_local void @caller_St4x8(ptr nocapture noundef readonly byval(%struct.St4x8) align 4 %in, ptr nocapture noundef writeonly %ret) {
define dso_local void @caller_St4x8(%struct.St4x8* nocapture noundef readonly byval(%struct.St4x8) align 4 %in, %struct.St4x8* nocapture noundef writeonly %ret) {
; CHECK-LABEL: .visible .func caller_St4x8( ; CHECK-LABEL: .visible .func caller_St4x8(
; CHECK: .param .align 4 .b8 caller_St4x8_param_0[32], ; CHECK: .param .align 4 .b8 caller_St4x8_param_0[32],
; CHECK: .param .b32 caller_St4x8_param_1 ; CHECK: .param .b32 caller_St4x8_param_1
; CHECK: ) ; CHECK: )
; CHECK: .param .align 16 .b8 param0[32]; ; CHECK: .param .align 16 .b8 param0[32];
; CHECK: st.param.v4.b32 [param0+0], {{{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}}; ; CHECK: st.param.v4.b32 [param0+0], {{{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}};
; CHECK: st.param.v4.b32 [param0+16], {{{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}}; ; CHECK: st.param.v4.b32 [param0+16], {{{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}};
; CHECK: .param .align 16 .b8 retval0[32]; ; CHECK: .param .align 16 .b8 retval0[32];
; CHECK: call.uni (retval0), ; CHECK: call.uni (retval0),
; CHECK-NEXT: callee_St4x8, ; CHECK-NEXT: callee_St4x8,
; CHECK-NEXT: ( ; CHECK-NEXT: (
; CHECK-NEXT: param0 ; CHECK-NEXT: param0
; CHECK-NEXT: ); ; CHECK-NEXT: );
; CHECK: ld.param.v4.b32 {{{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}}, [retval0+0]; ; CHECK: ld.param.v4.b32 {{{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}}, [retval0+0];
; CHECK: ld.param.v4.b32 {{{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}}, [retval0+16]; ; CHECK: ld.param.v4.b32 {{{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}, {{%r[0-9]+}}}, [retval0+16];
%call = tail call fastcc [8 x i32] @callee_St4x8(%struct.St4x8* noundef nonnull byval(%struct.St4x8) align 4 %in) %call = tail call fastcc [8 x i32] @callee_St4x8(ptr noundef nonnull byval(%struct.St4x8) align 4 %in) #2
%.fca.0.extract = extractvalue [8 x i32] %call, 0 %.fca.0.extract = extractvalue [8 x i32] %call, 0
%.fca.1.extract = extractvalue [8 x i32] %call, 1 %.fca.1.extract = extractvalue [8 x i32] %call, 1
%.fca.2.extract = extractvalue [8 x i32] %call, 2 %.fca.2.extract = extractvalue [8 x i32] %call, 2
%.fca.3.extract = extractvalue [8 x i32] %call, 3 %.fca.3.extract = extractvalue [8 x i32] %call, 3
%.fca.4.extract = extractvalue [8 x i32] %call, 4 %.fca.4.extract = extractvalue [8 x i32] %call, 4
%.fca.5.extract = extractvalue [8 x i32] %call, 5 %.fca.5.extract = extractvalue [8 x i32] %call, 5
%.fca.6.extract = extractvalue [8 x i32] %call, 6 %.fca.6.extract = extractvalue [8 x i32] %call, 6
%.fca.7.extract = extractvalue [8 x i32] %call, 7 %.fca.7.extract = extractvalue [8 x i32] %call, 7
%ref.tmp.sroa.0.0..sroa_idx = getelementptr inbounds %struct.St4x8, %struct.St4x8* %ret, i64 0, i32 0, i64 0 store i32 %.fca.0.extract, ptr %ret, align 4
store i32 %.fca.0.extract, i32* %ref.tmp.sroa.0.0..sroa_idx, align 4 %ref.tmp.sroa.4.0..sroa_idx = getelementptr inbounds i8, ptr %ret, i64 4
%ref.tmp.sroa.4.0..sroa_idx2 = getelementptr inbounds %struct.St4x8, %struct.St4x8* %ret, i64 0, i32 0, i64 1 store i32 %.fca.1.extract, ptr %ref.tmp.sroa.4.0..sroa_idx, align 4
store i32 %.fca.1.extract, i32* %ref.tmp.sroa.4.0..sroa_idx2, align 4 %ref.tmp.sroa.5.0..sroa_idx = getelementptr inbounds i8, ptr %ret, i64 8
%ref.tmp.sroa.5.0..sroa_idx4 = getelementptr inbounds %struct.St4x8, %struct.St4x8* %ret, i64 0, i32 0, i64 2 store i32 %.fca.2.extract, ptr %ref.tmp.sroa.5.0..sroa_idx, align 4
store i32 %.fca.2.extract, i32* %ref.tmp.sroa.5.0..sroa_idx4, align 4 %ref.tmp.sroa.6.0..sroa_idx = getelementptr inbounds i8, ptr %ret, i64 12
%ref.tmp.sroa.6.0..sroa_idx6 = getelementptr inbounds %struct.St4x8, %struct.St4x8* %ret, i64 0, i32 0, i64 3 store i32 %.fca.3.extract, ptr %ref.tmp.sroa.6.0..sroa_idx, align 4
store i32 %.fca.3.extract, i32* %ref.tmp.sroa.6.0..sroa_idx6, align 4 %ref.tmp.sroa.7.0..sroa_idx = getelementptr inbounds i8, ptr %ret, i64 16
%ref.tmp.sroa.7.0..sroa_idx8 = getelementptr inbounds %struct.St4x8, %struct.St4x8* %ret, i64 0, i32 0, i64 4 store i32 %.fca.4.extract, ptr %ref.tmp.sroa.7.0..sroa_idx, align 4
store i32 %.fca.4.extract, i32* %ref.tmp.sroa.7.0..sroa_idx8, align 4 %ref.tmp.sroa.8.0..sroa_idx = getelementptr inbounds i8, ptr %ret, i64 20
%ref.tmp.sroa.8.0..sroa_idx10 = getelementptr inbounds %struct.St4x8, %struct.St4x8* %ret, i64 0, i32 0, i64 5 store i32 %.fca.5.extract, ptr %ref.tmp.sroa.8.0..sroa_idx, align 4
store i32 %.fca.5.extract, i32* %ref.tmp.sroa.8.0..sroa_idx10, align 4 %ref.tmp.sroa.9.0..sroa_idx = getelementptr inbounds i8, ptr %ret, i64 24
%ref.tmp.sroa.9.0..sroa_idx12 = getelementptr inbounds %struct.St4x8, %struct.St4x8* %ret, i64 0, i32 0, i64 6 store i32 %.fca.6.extract, ptr %ref.tmp.sroa.9.0..sroa_idx, align 4
store i32 %.fca.6.extract, i32* %ref.tmp.sroa.9.0..sroa_idx12, align 4 %ref.tmp.sroa.10.0..sroa_idx = getelementptr inbounds i8, ptr %ret, i64 28
%ref.tmp.sroa.10.0..sroa_idx14 = getelementptr inbounds %struct.St4x8, %struct.St4x8* %ret, i64 0, i32 0, i64 7 store i32 %.fca.7.extract, ptr %ref.tmp.sroa.10.0..sroa_idx, align 4
store i32 %.fca.7.extract, i32* %ref.tmp.sroa.10.0..sroa_idx14, align 4
ret void ret void
} }
define internal fastcc [8 x i32] @callee_St4x8(ptr nocapture noundef readonly byval(%struct.St4x8) align 4 %in) {
define internal fastcc [8 x i32] @callee_St4x8(%struct.St4x8* nocapture noundef readonly byval(%struct.St4x8) align 4 %in) {
; CHECK: .func (.param .align 16 .b8 func_retval0[32]) ; CHECK: .func (.param .align 16 .b8 func_retval0[32])
; CHECK-LABEL: callee_St4x8( ; CHECK-LABEL: callee_St4x8(
; CHECK-NEXT: .param .align 16 .b8 callee_St4x8_param_0[32] ; CHECK-NEXT: .param .align 16 .b8 callee_St4x8_param_0[32]
; CHECK: ld.param.v4.u32 {[[R1:%r[0-9]+]], [[R2:%r[0-9]+]], [[R3:%r[0-9]+]], [[R4:%r[0-9]+]]}, [callee_St4x8_param_0]; ; CHECK: ld.param.v4.u32 {[[R1:%r[0-9]+]], [[R2:%r[0-9]+]], [[R3:%r[0-9]+]], [[R4:%r[0-9]+]]}, [callee_St4x8_param_0];
; CHECK: ld.param.v4.u32 {[[R5:%r[0-9]+]], [[R6:%r[0-9]+]], [[R7:%r[0-9]+]], [[R8:%r[0-9]+]]}, [callee_St4x8_param_0+16]; ; CHECK: ld.param.v4.u32 {[[R5:%r[0-9]+]], [[R6:%r[0-9]+]], [[R7:%r[0-9]+]], [[R8:%r[0-9]+]]}, [callee_St4x8_param_0+16];
; CHECK: st.param.v4.b32 [func_retval0+0], {[[R1]], [[R2]], [[R3]], [[R4]]}; ; CHECK: st.param.v4.b32 [func_retval0+0], {[[R1]], [[R2]], [[R3]], [[R4]]};
; CHECK: st.param.v4.b32 [func_retval0+16], {[[R5]], [[R6]], [[R7]], [[R8]]}; ; CHECK: st.param.v4.b32 [func_retval0+16], {[[R5]], [[R6]], [[R7]], [[R8]]};
; CHECK-NEXT: ret; ; CHECK-NEXT: ret;
%arrayidx = getelementptr inbounds %struct.St4x8, %struct.St4x8* %in, i64 0, i32 0, i64 0 %1 = load i32, ptr %in, align 4
%1 = load i32, i32* %arrayidx, align 4 %arrayidx.1 = getelementptr inbounds [8 x i32], ptr %in, i64 0, i64 1
%arrayidx.1 = getelementptr inbounds %struct.St4x8, %struct.St4x8* %in, i64 0, i32 0, i64 1 %2 = load i32, ptr %arrayidx.1, align 4
%2 = load i32, i32* %arrayidx.1, align 4 %arrayidx.2 = getelementptr inbounds [8 x i32], ptr %in, i64 0, i64 2
%arrayidx.2 = getelementptr inbounds %struct.St4x8, %struct.St4x8* %in, i64 0, i32 0, i64 2 %3 = load i32, ptr %arrayidx.2, align 4
%3 = load i32, i32* %arrayidx.2, align 4 %arrayidx.3 = getelementptr inbounds [8 x i32], ptr %in, i64 0, i64 3
%arrayidx.3 = getelementptr inbounds %struct.St4x8, %struct.St4x8* %in, i64 0, i32 0, i64 3 %4 = load i32, ptr %arrayidx.3, align 4
%4 = load i32, i32* %arrayidx.3, align 4 %arrayidx.4 = getelementptr inbounds [8 x i32], ptr %in, i64 0, i64 4
%arrayidx.4 = getelementptr inbounds %struct.St4x8, %struct.St4x8* %in, i64 0, i32 0, i64 4 %5 = load i32, ptr %arrayidx.4, align 4
%5 = load i32, i32* %arrayidx.4, align 4 %arrayidx.5 = getelementptr inbounds [8 x i32], ptr %in, i64 0, i64 5
%arrayidx.5 = getelementptr inbounds %struct.St4x8, %struct.St4x8* %in, i64 0, i32 0, i64 5 %6 = load i32, ptr %arrayidx.5, align 4
%6 = load i32, i32* %arrayidx.5, align 4 %arrayidx.6 = getelementptr inbounds [8 x i32], ptr %in, i64 0, i64 6
%arrayidx.6 = getelementptr inbounds %struct.St4x8, %struct.St4x8* %in, i64 0, i32 0, i64 6 %7 = load i32, ptr %arrayidx.6, align 4
%7 = load i32, i32* %arrayidx.6, align 4 %arrayidx.7 = getelementptr inbounds [8 x i32], ptr %in, i64 0, i64 7
%arrayidx.7 = getelementptr inbounds %struct.St4x8, %struct.St4x8* %in, i64 0, i32 0, i64 7 %8 = load i32, ptr %arrayidx.7, align 4
%8 = load i32, i32* %arrayidx.7, align 4
%9 = insertvalue [8 x i32] poison, i32 %1, 0 %9 = insertvalue [8 x i32] poison, i32 %1, 0
%10 = insertvalue [8 x i32] %9, i32 %2, 1 %10 = insertvalue [8 x i32] %9, i32 %2, 1
%11 = insertvalue [8 x i32] %10, i32 %3, 2 %11 = insertvalue [8 x i32] %10, i32 %3, 2
%12 = insertvalue [8 x i32] %11, i32 %4, 3 %12 = insertvalue [8 x i32] %11, i32 %4, 3
%13 = insertvalue [8 x i32] %12, i32 %5, 4 %13 = insertvalue [8 x i32] %12, i32 %5, 4
%14 = insertvalue [8 x i32] %13, i32 %6, 5 %14 = insertvalue [8 x i32] %13, i32 %6, 5
%15 = insertvalue [8 x i32] %14, i32 %7, 6 %15 = insertvalue [8 x i32] %14, i32 %7, 6
%oldret = insertvalue [8 x i32] %15, i32 %8, 7 %oldret = insertvalue [8 x i32] %15, i32 %8, 7
ret [8 x i32] %oldret ret [8 x i32] %oldret
} }
define dso_local void @caller_St8x1(ptr nocapture noundef readonly byval(%struct.St8x1) align 8 %in, ptr nocapture noundef writeonly %ret) {
define dso_local void @caller_St8x1(%struct.St8x1* nocapture noundef readonly byval(%struct.St8x1) align 8 %in, %struct.St8x1* nocapture noundef writeonly %ret) {
; CHECK-LABEL: .visible .func caller_St8x1( ; CHECK-LABEL: .visible .func caller_St8x1(
; CHECK: .param .align 8 .b8 caller_St8x1_param_0[8], ; CHECK: .param .align 8 .b8 caller_St8x1_param_0[8],
; CHECK: .param .b32 caller_St8x1_param_1 ; CHECK: .param .b32 caller_St8x1_param_1
; CHECK: ) ; CHECK: )
; CHECK: .param .b64 param0; ; CHECK: .param .b64 param0;
; CHECK: st.param.b64 [param0+0], {{%rd[0-9]+}}; ; CHECK: st.param.b64 [param0+0], {{%rd[0-9]+}};
; CHECK: .param .align 16 .b8 retval0[8]; ; CHECK: .param .align 16 .b8 retval0[8];
; CHECK: call.uni (retval0), ; CHECK: call.uni (retval0),
; CHECK-NEXT: callee_St8x1, ; CHECK-NEXT: callee_St8x1,
; CHECK-NEXT: ( ; CHECK-NEXT: (
; CHECK-NEXT: param0 ; CHECK-NEXT: param0
; CHECK-NEXT: ); ; CHECK-NEXT: );
; CHECK: ld.param.b64 {{%rd[0-9]+}}, [retval0+0]; ; CHECK: ld.param.b64 {{%rd[0-9]+}}, [retval0+0];
%1 = getelementptr inbounds %struct.St8x1, %struct.St8x1* %in, i64 0, i32 0, i64 0 %1 = load i64, ptr %in, align 8
%2 = load i64, i64* %1, align 8 %call = tail call fastcc [1 x i64] @callee_St8x1(i64 %1) #2
%call = tail call fastcc [1 x i64] @callee_St8x1(i64 %2)
%.fca.0.extract = extractvalue [1 x i64] %call, 0 %.fca.0.extract = extractvalue [1 x i64] %call, 0
%ref.tmp.sroa.0.0..sroa_idx = getelementptr inbounds %struct.St8x1, %struct.St8x1* %ret, i64 0, i32 0, i64 0 store i64 %.fca.0.extract, ptr %ret, align 8
store i64 %.fca.0.extract, i64* %ref.tmp.sroa.0.0..sroa_idx, align 8
ret void ret void
} }
define internal fastcc [1 x i64] @callee_St8x1(i64 %in.0.val) { define internal fastcc [1 x i64] @callee_St8x1(i64 %in.0.val) {
; CHECK: .func (.param .align 16 .b8 func_retval0[8]) ; CHECK: .func (.param .align 16 .b8 func_retval0[8])
; CHECK-LABEL: callee_St8x1( ; CHECK-LABEL: callee_St8x1(
; CHECK-NEXT: .param .b64 callee_St8x1_param_0 ; CHECK-NEXT: .param .b64 callee_St8x1_param_0
; CHECK: ld.param.u64 [[RD1:%rd[0-9]+]], [callee_St8x1_param_0]; ; CHECK: ld.param.u64 [[RD1:%rd[0-9]+]], [callee_St8x1_param_0];
; CHECK: st.param.b64 [func_retval0+0], [[RD1]]; ; CHECK: st.param.b64 [func_retval0+0], [[RD1]];
; CHECK-NEXT: ret; ; CHECK-NEXT: ret;
%oldret = insertvalue [1 x i64] poison, i64 %in.0.val, 0 %oldret = insertvalue [1 x i64] poison, i64 %in.0.val, 0
ret [1 x i64] %oldret ret [1 x i64] %oldret
} }
define dso_local void @caller_St8x2(ptr nocapture noundef readonly byval(%struct.St8x2) align 8 %in, ptr nocapture noundef writeonly %ret) {
define dso_local void @caller_St8x2(%struct.St8x2* nocapture noundef readonly byval(%struct.St8x2) align 8 %in, %struct.St8x2* nocapture noundef writeonly %ret) {
; CHECK-LABEL: .visible .func caller_St8x2( ; CHECK-LABEL: .visible .func caller_St8x2(
; CHECK: .param .align 8 .b8 caller_St8x2_param_0[16], ; CHECK: .param .align 8 .b8 caller_St8x2_param_0[16],
; CHECK: .param .b32 caller_St8x2_param_1 ; CHECK: .param .b32 caller_St8x2_param_1
; CHECK: ) ; CHECK: )
; CHECK: .param .align 16 .b8 param0[16]; ; CHECK: .param .align 16 .b8 param0[16];
; CHECK: st.param.v2.b64 [param0+0], {{{%rd[0-9]+}}, {{%rd[0-9]+}}}; ; CHECK: st.param.v2.b64 [param0+0], {{{%rd[0-9]+}}, {{%rd[0-9]+}}};
; CHECK: .param .align 16 .b8 retval0[16]; ; CHECK: .param .align 16 .b8 retval0[16];
; CHECK: call.uni (retval0), ; CHECK: call.uni (retval0),
; CHECK-NEXT: callee_St8x2, ; CHECK-NEXT: callee_St8x2,
; CHECK-NEXT: ( ; CHECK-NEXT: (
; CHECK-NEXT: param0 ; CHECK-NEXT: param0
; CHECK-NEXT: ); ; CHECK-NEXT: );
; CHECK: ld.param.v2.b64 {{{%rd[0-9]+}}, {{%rd[0-9]+}}}, [retval0+0]; ; CHECK: ld.param.v2.b64 {{{%rd[0-9]+}}, {{%rd[0-9]+}}}, [retval0+0];
%call = tail call fastcc [2 x i64] @callee_St8x2(%struct.St8x2* noundef nonnull byval(%struct.St8x2) align 8 %in) %call = tail call fastcc [2 x i64] @callee_St8x2(ptr noundef nonnull byval(%struct.St8x2) align 8 %in) #2
%.fca.0.extract = extractvalue [2 x i64] %call, 0 %.fca.0.extract = extractvalue [2 x i64] %call, 0
%.fca.1.extract = extractvalue [2 x i64] %call, 1 %.fca.1.extract = extractvalue [2 x i64] %call, 1
%ref.tmp.sroa.0.0..sroa_idx = getelementptr inbounds %struct.St8x2, %struct.St8x2* %ret, i64 0, i32 0, i64 0 store i64 %.fca.0.extract, ptr %ret, align 8
store i64 %.fca.0.extract, i64* %ref.tmp.sroa.0.0..sroa_idx, align 8 %ref.tmp.sroa.4.0..sroa_idx = getelementptr inbounds i8, ptr %ret, i64 8
%ref.tmp.sroa.4.0..sroa_idx3 = getelementptr inbounds %struct.St8x2, %struct.St8x2* %ret, i64 0, i32 0, i64 1 store i64 %.fca.1.extract, ptr %ref.tmp.sroa.4.0..sroa_idx, align 8
store i64 %.fca.1.extract, i64* %ref.tmp.sroa.4.0..sroa_idx3, align 8
ret void ret void
} }
define internal fastcc [2 x i64] @callee_St8x2(ptr nocapture noundef readonly byval(%struct.St8x2) align 8 %in) {
define internal fastcc [2 x i64] @callee_St8x2(%struct.St8x2* nocapture noundef readonly byval(%struct.St8x2) align 8 %in) {
; CHECK: .func (.param .align 16 .b8 func_retval0[16]) ; CHECK: .func (.param .align 16 .b8 func_retval0[16])
; CHECK-LABEL: callee_St8x2( ; CHECK-LABEL: callee_St8x2(
; CHECK-NEXT: .param .align 16 .b8 callee_St8x2_param_0[16] ; CHECK-NEXT: .param .align 16 .b8 callee_St8x2_param_0[16]
; CHECK: ld.param.v2.u64 {[[RD1:%rd[0-9]+]], [[RD2:%rd[0-9]+]]}, [callee_St8x2_param_0]; ; CHECK: ld.param.v2.u64 {[[RD1:%rd[0-9]+]], [[RD2:%rd[0-9]+]]}, [callee_St8x2_param_0];
; CHECK: st.param.v2.b64 [func_retval0+0], {[[RD1]], [[RD2]]}; ; CHECK: st.param.v2.b64 [func_retval0+0], {[[RD1]], [[RD2]]};
; CHECK-NEXT: ret; ; CHECK-NEXT: ret;
%arrayidx = getelementptr inbounds %struct.St8x2, %struct.St8x2* %in, i64 0, i32 0, i64 0 %1 = load i64, ptr %in, align 8
%1 = load i64, i64* %arrayidx, align 8 %arrayidx.1 = getelementptr inbounds [2 x i64], ptr %in, i64 0, i64 1
%arrayidx.1 = getelementptr inbounds %struct.St8x2, %struct.St8x2* %in, i64 0, i32 0, i64 1 %2 = load i64, ptr %arrayidx.1, align 8
%2 = load i64, i64* %arrayidx.1, align 8
%3 = insertvalue [2 x i64] poison, i64 %1, 0 %3 = insertvalue [2 x i64] poison, i64 %1, 0
%oldret = insertvalue [2 x i64] %3, i64 %2, 1 %oldret = insertvalue [2 x i64] %3, i64 %2, 1
ret [2 x i64] %oldret ret [2 x i64] %oldret
} }
define dso_local void @caller_St8x3(ptr nocapture noundef readonly byval(%struct.St8x3) align 8 %in, ptr nocapture noundef writeonly %ret) {
define dso_local void @caller_St8x3(%struct.St8x3* nocapture noundef readonly byval(%struct.St8x3) align 8 %in, %struct.St8x3* nocapture noundef writeonly %ret) {
; CHECK-LABEL: .visible .func caller_St8x3( ; CHECK-LABEL: .visible .func caller_St8x3(
; CHECK: .param .align 8 .b8 caller_St8x3_param_0[24], ; CHECK: .param .align 8 .b8 caller_St8x3_param_0[24],
; CHECK: .param .b32 caller_St8x3_param_1 ; CHECK: .param .b32 caller_St8x3_param_1
; CHECK: ) ; CHECK: )
; CHECK: .param .align 16 .b8 param0[24]; ; CHECK: .param .align 16 .b8 param0[24];
; CHECK: st.param.v2.b64 [param0+0], {{{%rd[0-9]+}}, {{%rd[0-9]+}}}; ; CHECK: st.param.v2.b64 [param0+0], {{{%rd[0-9]+}}, {{%rd[0-9]+}}};
; CHECK: st.param.b64 [param0+16], {{%rd[0-9]+}}; ; CHECK: st.param.b64 [param0+16], {{%rd[0-9]+}};
; CHECK: .param .align 16 .b8 retval0[24]; ; CHECK: .param .align 16 .b8 retval0[24];
; CHECK: call.uni (retval0), ; CHECK: call.uni (retval0),
; CHECK-NEXT: callee_St8x3, ; CHECK-NEXT: callee_St8x3,
; CHECK-NEXT: ( ; CHECK-NEXT: (
; CHECK-NEXT: param0 ; CHECK-NEXT: param0
; CHECK-NEXT: ); ; CHECK-NEXT: );
; CHECK: ld.param.v2.b64 {{{%rd[0-9]+}}, {{%rd[0-9]+}}}, [retval0+0]; ; CHECK: ld.param.v2.b64 {{{%rd[0-9]+}}, {{%rd[0-9]+}}}, [retval0+0];
; CHECK: ld.param.b64 {{%rd[0-9]+}}, [retval0+16]; ; CHECK: ld.param.b64 {{%rd[0-9]+}}, [retval0+16];
%call = tail call fastcc [3 x i64] @callee_St8x3(%struct.St8x3* noundef nonnull byval(%struct.St8x3) align 8 %in) %call = tail call fastcc [3 x i64] @callee_St8x3(ptr noundef nonnull byval(%struct.St8x3) align 8 %in) #2
%.fca.0.extract = extractvalue [3 x i64] %call, 0 %.fca.0.extract = extractvalue [3 x i64] %call, 0
%.fca.1.extract = extractvalue [3 x i64] %call, 1 %.fca.1.extract = extractvalue [3 x i64] %call, 1
%.fca.2.extract = extractvalue [3 x i64] %call, 2 %.fca.2.extract = extractvalue [3 x i64] %call, 2
%ref.tmp.sroa.0.0..sroa_idx = getelementptr inbounds %struct.St8x3, %struct.St8x3* %ret, i64 0, i32 0, i64 0 store i64 %.fca.0.extract, ptr %ret, align 8
store i64 %.fca.0.extract, i64* %ref.tmp.sroa.0.0..sroa_idx, align 8 %ref.tmp.sroa.4.0..sroa_idx = getelementptr inbounds i8, ptr %ret, i64 8
%ref.tmp.sroa.4.0..sroa_idx2 = getelementptr inbounds %struct.St8x3, %struct.St8x3* %ret, i64 0, i32 0, i64 1 store i64 %.fca.1.extract, ptr %ref.tmp.sroa.4.0..sroa_idx, align 8
store i64 %.fca.1.extract, i64* %ref.tmp.sroa.4.0..sroa_idx2, align 8 %ref.tmp.sroa.5.0..sroa_idx = getelementptr inbounds i8, ptr %ret, i64 16
%ref.tmp.sroa.5.0..sroa_idx4 = getelementptr inbounds %struct.St8x3, %struct.St8x3* %ret, i64 0, i32 0, i64 2 store i64 %.fca.2.extract, ptr %ref.tmp.sroa.5.0..sroa_idx, align 8
store i64 %.fca.2.extract, i64* %ref.tmp.sroa.5.0..sroa_idx4, align 8
ret void ret void
} }
define internal fastcc [3 x i64] @callee_St8x3(ptr nocapture noundef readonly byval(%struct.St8x3) align 8 %in) {
define internal fastcc [3 x i64] @callee_St8x3(%struct.St8x3* nocapture noundef readonly byval(%struct.St8x3) align 8 %in) {
; CHECK: .func (.param .align 16 .b8 func_retval0[24]) ; CHECK: .func (.param .align 16 .b8 func_retval0[24])
; CHECK-LABEL: callee_St8x3( ; CHECK-LABEL: callee_St8x3(
; CHECK-NEXT: .param .align 16 .b8 callee_St8x3_param_0[24] ; CHECK-NEXT: .param .align 16 .b8 callee_St8x3_param_0[24]
; CHECK: ld.param.v2.u64 {[[RD1:%rd[0-9]+]], [[RD2:%rd[0-9]+]]}, [callee_St8x3_param_0]; ; CHECK: ld.param.v2.u64 {[[RD1:%rd[0-9]+]], [[RD2:%rd[0-9]+]]}, [callee_St8x3_param_0];
; CHECK: ld.param.u64 [[RD3:%rd[0-9]+]], [callee_St8x3_param_0+16]; ; CHECK: ld.param.u64 [[RD3:%rd[0-9]+]], [callee_St8x3_param_0+16];
; CHECK: st.param.v2.b64 [func_retval0+0], {[[RD1]], [[RD2]]}; ; CHECK: st.param.v2.b64 [func_retval0+0], {[[RD1]], [[RD2]]};
; CHECK: st.param.b64 [func_retval0+16], [[RD3]]; ; CHECK: st.param.b64 [func_retval0+16], [[RD3]];
; CHECK-NEXT: ret; ; CHECK-NEXT: ret;
%arrayidx = getelementptr inbounds %struct.St8x3, %struct.St8x3* %in, i64 0, i32 0, i64 0 %1 = load i64, ptr %in, align 8
%1 = load i64, i64* %arrayidx, align 8 %arrayidx.1 = getelementptr inbounds [3 x i64], ptr %in, i64 0, i64 1
%arrayidx.1 = getelementptr inbounds %struct.St8x3, %struct.St8x3* %in, i64 0, i32 0, i64 1 %2 = load i64, ptr %arrayidx.1, align 8
%2 = load i64, i64* %arrayidx.1, align 8 %arrayidx.2 = getelementptr inbounds [3 x i64], ptr %in, i64 0, i64 2
%arrayidx.2 = getelementptr inbounds %struct.St8x3, %struct.St8x3* %in, i64 0, i32 0, i64 2 %3 = load i64, ptr %arrayidx.2, align 8
%3 = load i64, i64* %arrayidx.2, align 8
%4 = insertvalue [3 x i64] poison, i64 %1, 0 %4 = insertvalue [3 x i64] poison, i64 %1, 0
%5 = insertvalue [3 x i64] %4, i64 %2, 1 %5 = insertvalue [3 x i64] %4, i64 %2, 1
%oldret = insertvalue [3 x i64] %5, i64 %3, 2 %oldret = insertvalue [3 x i64] %5, i64 %3, 2
ret [3 x i64] %oldret ret [3 x i64] %oldret
} }
define dso_local void @caller_St8x4(ptr nocapture noundef readonly byval(%struct.St8x4) align 8 %in, ptr nocapture noundef writeonly %ret) {
define dso_local void @caller_St8x4(%struct.St8x4* nocapture noundef readonly byval(%struct.St8x4) align 8 %in, %struct.St8x4* nocapture noundef writeonly %ret) {
; CHECK-LABEL: .visible .func caller_St8x4( ; CHECK-LABEL: .visible .func caller_St8x4(
; CHECK: .param .align 8 .b8 caller_St8x4_param_0[32], ; CHECK: .param .align 8 .b8 caller_St8x4_param_0[32],
; CHECK: .param .b32 caller_St8x4_param_1 ; CHECK: .param .b32 caller_St8x4_param_1
; CHECK: ) ; CHECK: )
; CHECK: .param .align 16 .b8 param0[32]; ; CHECK: .param .align 16 .b8 param0[32];
; CHECK: st.param.v2.b64 [param0+0], {{{%rd[0-9]+}}, {{%rd[0-9]+}}}; ; CHECK: st.param.v2.b64 [param0+0], {{{%rd[0-9]+}}, {{%rd[0-9]+}}};
; CHECK: st.param.v2.b64 [param0+16], {{{%rd[0-9]+}}, {{%rd[0-9]+}}}; ; CHECK: st.param.v2.b64 [param0+16], {{{%rd[0-9]+}}, {{%rd[0-9]+}}};
; CHECK: .param .align 16 .b8 retval0[32]; ; CHECK: .param .align 16 .b8 retval0[32];
; CHECK: call.uni (retval0), ; CHECK: call.uni (retval0),
; CHECK-NEXT: callee_St8x4, ; CHECK-NEXT: callee_St8x4,
; CHECK-NEXT: ( ; CHECK-NEXT: (
; CHECK-NEXT: param0 ; CHECK-NEXT: param0
; CHECK-NEXT: ); ; CHECK-NEXT: );
; CHECK: ld.param.v2.b64 {{{%rd[0-9]+}}, {{%rd[0-9]+}}}, [retval0+0]; ; CHECK: ld.param.v2.b64 {{{%rd[0-9]+}}, {{%rd[0-9]+}}}, [retval0+0];
; CHECK: ld.param.v2.b64 {{{%rd[0-9]+}}, {{%rd[0-9]+}}}, [retval0+16]; ; CHECK: ld.param.v2.b64 {{{%rd[0-9]+}}, {{%rd[0-9]+}}}, [retval0+16];
%call = tail call fastcc [4 x i64] @callee_St8x4(%struct.St8x4* noundef nonnull byval(%struct.St8x4) align 8 %in) %call = tail call fastcc [4 x i64] @callee_St8x4(ptr noundef nonnull byval(%struct.St8x4) align 8 %in) #2
%.fca.0.extract = extractvalue [4 x i64] %call, 0 %.fca.0.extract = extractvalue [4 x i64] %call, 0
%.fca.1.extract = extractvalue [4 x i64] %call, 1 %.fca.1.extract = extractvalue [4 x i64] %call, 1
%.fca.2.extract = extractvalue [4 x i64] %call, 2 %.fca.2.extract = extractvalue [4 x i64] %call, 2
%.fca.3.extract = extractvalue [4 x i64] %call, 3 %.fca.3.extract = extractvalue [4 x i64] %call, 3
%ref.tmp.sroa.0.0..sroa_idx = getelementptr inbounds %struct.St8x4, %struct.St8x4* %ret, i64 0, i32 0, i64 0 store i64 %.fca.0.extract, ptr %ret, align 8
store i64 %.fca.0.extract, i64* %ref.tmp.sroa.0.0..sroa_idx, align 8 %ref.tmp.sroa.4.0..sroa_idx = getelementptr inbounds i8, ptr %ret, i64 8
%ref.tmp.sroa.4.0..sroa_idx3 = getelementptr inbounds %struct.St8x4, %struct.St8x4* %ret, i64 0, i32 0, i64 1 store i64 %.fca.1.extract, ptr %ref.tmp.sroa.4.0..sroa_idx, align 8
store i64 %.fca.1.extract, i64* %ref.tmp.sroa.4.0..sroa_idx3, align 8 %ref.tmp.sroa.5.0..sroa_idx = getelementptr inbounds i8, ptr %ret, i64 16
%ref.tmp.sroa.5.0..sroa_idx5 = getelementptr inbounds %struct.St8x4, %struct.St8x4* %ret, i64 0, i32 0, i64 2 store i64 %.fca.2.extract, ptr %ref.tmp.sroa.5.0..sroa_idx, align 8
store i64 %.fca.2.extract, i64* %ref.tmp.sroa.5.0..sroa_idx5, align 8 %ref.tmp.sroa.6.0..sroa_idx = getelementptr inbounds i8, ptr %ret, i64 24
%ref.tmp.sroa.6.0..sroa_idx7 = getelementptr inbounds %struct.St8x4, %struct.St8x4* %ret, i64 0, i32 0, i64 3 store i64 %.fca.3.extract, ptr %ref.tmp.sroa.6.0..sroa_idx, align 8
store i64 %.fca.3.extract, i64* %ref.tmp.sroa.6.0..sroa_idx7, align 8
ret void ret void
} }
define internal fastcc [4 x i64] @callee_St8x4(ptr nocapture noundef readonly byval(%struct.St8x4) align 8 %in) {
define internal fastcc [4 x i64] @callee_St8x4(%struct.St8x4* nocapture noundef readonly byval(%struct.St8x4) align 8 %in) {
; CHECK: .func (.param .align 16 .b8 func_retval0[32]) ; CHECK: .func (.param .align 16 .b8 func_retval0[32])
; CHECK-LABEL: callee_St8x4( ; CHECK-LABEL: callee_St8x4(
; CHECK-NEXT: .param .align 16 .b8 callee_St8x4_param_0[32] ; CHECK-NEXT: .param .align 16 .b8 callee_St8x4_param_0[32]
; CHECK: ld.param.v2.u64 {[[RD1:%rd[0-9]+]], [[RD2:%rd[0-9]+]]}, [callee_St8x4_param_0]; ; CHECK: ld.param.v2.u64 {[[RD1:%rd[0-9]+]], [[RD2:%rd[0-9]+]]}, [callee_St8x4_param_0];
; CHECK: ld.param.v2.u64 {[[RD3:%rd[0-9]+]], [[RD4:%rd[0-9]+]]}, [callee_St8x4_param_0+16]; ; CHECK: ld.param.v2.u64 {[[RD3:%rd[0-9]+]], [[RD4:%rd[0-9]+]]}, [callee_St8x4_param_0+16];
; CHECK: st.param.v2.b64 [func_retval0+0], {[[RD1]], [[RD2]]}; ; CHECK: st.param.v2.b64 [func_retval0+0], {[[RD1]], [[RD2]]};
; CHECK: st.param.v2.b64 [func_retval0+16], {[[RD3]], [[RD4]]}; ; CHECK: st.param.v2.b64 [func_retval0+16], {[[RD3]], [[RD4]]};
; CHECK-NEXT: ret; ; CHECK-NEXT: ret;
%arrayidx = getelementptr inbounds %struct.St8x4, %struct.St8x4* %in, i64 0, i32 0, i64 0 %1 = load i64, ptr %in, align 8
%1 = load i64, i64* %arrayidx, align 8 %arrayidx.1 = getelementptr inbounds [4 x i64], ptr %in, i64 0, i64 1
%arrayidx.1 = getelementptr inbounds %struct.St8x4, %struct.St8x4* %in, i64 0, i32 0, i64 1 %2 = load i64, ptr %arrayidx.1, align 8
%2 = load i64, i64* %arrayidx.1, align 8 %arrayidx.2 = getelementptr inbounds [4 x i64], ptr %in, i64 0, i64 2
%arrayidx.2 = getelementptr inbounds %struct.St8x4, %struct.St8x4* %in, i64 0, i32 0, i64 2 %3 = load i64, ptr %arrayidx.2, align 8
%3 = load i64, i64* %arrayidx.2, align 8 %arrayidx.3 = getelementptr inbounds [4 x i64], ptr %in, i64 0, i64 3
%arrayidx.3 = getelementptr inbounds %struct.St8x4, %struct.St8x4* %in, i64 0, i32 0, i64 3 %4 = load i64, ptr %arrayidx.3, align 8
%4 = load i64, i64* %arrayidx.3, align 8
%5 = insertvalue [4 x i64] poison, i64 %1, 0 %5 = insertvalue [4 x i64] poison, i64 %1, 0
%6 = insertvalue [4 x i64] %5, i64 %2, 1 %6 = insertvalue [4 x i64] %5, i64 %2, 1
%7 = insertvalue [4 x i64] %6, i64 %3, 2 %7 = insertvalue [4 x i64] %6, i64 %3, 2
%oldret = insertvalue [4 x i64] %7, i64 %4, 3 %oldret = insertvalue [4 x i64] %7, i64 %4, 3
ret [4 x i64] %oldret ret [4 x i64] %oldret
} }
; Section 2 - checking that function argument (including retval) vectorization is done with private linkage. ; Section 2 - checking that function argument (including retval) vectorization is done with private linkage.
define private fastcc [4 x i32] @callee_St4x4_private(%struct.St4x4* nocapture noundef readonly byval(%struct.St4x4) align 4 %in) { define private fastcc [4 x i32] @callee_St4x4_private(ptr nocapture noundef readonly byval(%struct.St4x4) align 4 %in) {
; CHECK: .func (.param .align 16 .b8 func_retval0[16]) ; CHECK: .func (.param .align 16 .b8 func_retval0[16])
; CHECK-LABEL: callee_St4x4_private( ; CHECK-LABEL: callee_St4x4_private(
; CHECK-NEXT: .param .align 16 .b8 callee_St4x4_private_param_0[16] ; CHECK-NEXT: .param .align 16 .b8 callee_St4x4_private_param_0[16]
; CHECK: ld.param.v4.u32 {[[R1:%r[0-9]+]], [[R2:%r[0-9]+]], [[R3:%r[0-9]+]], [[R4:%r[0-9]+]]}, [callee_St4x4_private_param_0]; ; CHECK: ld.param.v4.u32 {[[R1:%r[0-9]+]], [[R2:%r[0-9]+]], [[R3:%r[0-9]+]], [[R4:%r[0-9]+]]}, [callee_St4x4_private_param_0];
; CHECK: st.param.v4.b32 [func_retval0+0], {[[R1]], [[R2]], [[R3]], [[R4]]}; ; CHECK: st.param.v4.b32 [func_retval0+0], {[[R1]], [[R2]], [[R3]], [[R4]]};
; CHECK-NEXT: ret; ; CHECK-NEXT: ret;
%arrayidx = getelementptr inbounds %struct.St4x4, %struct.St4x4* %in, i64 0, i32 0, i64 0 %1 = load i32, ptr %in, align 4
%1 = load i32, i32* %arrayidx, align 4 %arrayidx.1 = getelementptr inbounds [4 x i32], ptr %in, i64 0, i64 1
%arrayidx.1 = getelementptr inbounds %struct.St4x4, %struct.St4x4* %in, i64 0, i32 0, i64 1 %2 = load i32, ptr %arrayidx.1, align 4
%2 = load i32, i32* %arrayidx.1, align 4 %arrayidx.2 = getelementptr inbounds [4 x i32], ptr %in, i64 0, i64 2
%arrayidx.2 = getelementptr inbounds %struct.St4x4, %struct.St4x4* %in, i64 0, i32 0, i64 2 %3 = load i32, ptr %arrayidx.2, align 4
%3 = load i32, i32* %arrayidx.2, align 4 %arrayidx.3 = getelementptr inbounds [4 x i32], ptr %in, i64 0, i64 3
%arrayidx.3 = getelementptr inbounds %struct.St4x4, %struct.St4x4* %in, i64 0, i32 0, i64 3 %4 = load i32, ptr %arrayidx.3, align 4
%4 = load i32, i32* %arrayidx.3, align 4
%5 = insertvalue [4 x i32] poison, i32 %1, 0 %5 = insertvalue [4 x i32] poison, i32 %1, 0
%6 = insertvalue [4 x i32] %5, i32 %2, 1 %6 = insertvalue [4 x i32] %5, i32 %2, 1
%7 = insertvalue [4 x i32] %6, i32 %3, 2 %7 = insertvalue [4 x i32] %6, i32 %3, 2
%oldret = insertvalue [4 x i32] %7, i32 %4, 3 %oldret = insertvalue [4 x i32] %7, i32 %4, 3
ret [4 x i32] %oldret ret [4 x i32] %oldret
} }
; Section 3 - checking that function argument (including retval) vectorization ; Section 3 - checking that function argument (including retval) vectorization
; is NOT done with linkage types other than internal and private. ; is NOT done with linkage types other than internal and private.
define external fastcc [4 x i32] @callee_St4x4_external(%struct.St4x4* nocapture noundef readonly byval(%struct.St4x4) align 4 %in) { define external fastcc [4 x i32] @callee_St4x4_external(ptr nocapture noundef readonly byval(%struct.St4x4) align 4 %in) {
; CHECK: .func (.param .align 4 .b8 func_retval0[16]) ; CHECK: .func (.param .align 4 .b8 func_retval0[16])
; CHECK-LABEL: callee_St4x4_external( ; CHECK-LABEL: callee_St4x4_external(
; CHECK-NEXT: .param .align 4 .b8 callee_St4x4_external_param_0[16] ; CHECK-NEXT: .param .align 4 .b8 callee_St4x4_external_param_0[16]
; CHECK: ld.param.u32 [[R1:%r[0-9]+]], [callee_St4x4_external_param_0]; ; CHECK: ld.param.u32 [[R1:%r[0-9]+]], [callee_St4x4_external_param_0];
; CHECK: ld.param.u32 [[R2:%r[0-9]+]], [callee_St4x4_external_param_0+4]; ; CHECK: ld.param.u32 [[R2:%r[0-9]+]], [callee_St4x4_external_param_0+4];
; CHECK: ld.param.u32 [[R3:%r[0-9]+]], [callee_St4x4_external_param_0+8]; ; CHECK: ld.param.u32 [[R3:%r[0-9]+]], [callee_St4x4_external_param_0+8];
; CHECK: ld.param.u32 [[R4:%r[0-9]+]], [callee_St4x4_external_param_0+12]; ; CHECK: ld.param.u32 [[R4:%r[0-9]+]], [callee_St4x4_external_param_0+12];
; CHECK: st.param.b32 [func_retval0+0], [[R1]]; ; CHECK: st.param.b32 [func_retval0+0], [[R1]];
; CHECK: st.param.b32 [func_retval0+4], [[R2]]; ; CHECK: st.param.b32 [func_retval0+4], [[R2]];
; CHECK: st.param.b32 [func_retval0+8], [[R3]]; ; CHECK: st.param.b32 [func_retval0+8], [[R3]];
; CHECK: st.param.b32 [func_retval0+12], [[R4]]; ; CHECK: st.param.b32 [func_retval0+12], [[R4]];
; CHECK-NEXT: ret; ; CHECK-NEXT: ret;
%arrayidx = getelementptr inbounds %struct.St4x4, %struct.St4x4* %in, i64 0, i32 0, i64 0 %1 = load i32, ptr %in, align 4
%1 = load i32, i32* %arrayidx, align 4 %arrayidx.1 = getelementptr inbounds [4 x i32], ptr %in, i64 0, i64 1
%arrayidx.1 = getelementptr inbounds %struct.St4x4, %struct.St4x4* %in, i64 0, i32 0, i64 1 %2 = load i32, ptr %arrayidx.1, align 4
%2 = load i32, i32* %arrayidx.1, align 4 %arrayidx.2 = getelementptr inbounds [4 x i32], ptr %in, i64 0, i64 2
%arrayidx.2 = getelementptr inbounds %struct.St4x4, %struct.St4x4* %in, i64 0, i32 0, i64 2 %3 = load i32, ptr %arrayidx.2, align 4
%3 = load i32, i32* %arrayidx.2, align 4 %arrayidx.3 = getelementptr inbounds [4 x i32], ptr %in, i64 0, i64 3
%arrayidx.3 = getelementptr inbounds %struct.St4x4, %struct.St4x4* %in, i64 0, i32 0, i64 3 %4 = load i32, ptr %arrayidx.3, align 4
%4 = load i32, i32* %arrayidx.3, align 4
%5 = insertvalue [4 x i32] poison, i32 %1, 0 %5 = insertvalue [4 x i32] poison, i32 %1, 0
%6 = insertvalue [4 x i32] %5, i32 %2, 1 %6 = insertvalue [4 x i32] %5, i32 %2, 1
%7 = insertvalue [4 x i32] %6, i32 %3, 2 %7 = insertvalue [4 x i32] %6, i32 %3, 2
%oldret = insertvalue [4 x i32] %7, i32 %4, 3 %oldret = insertvalue [4 x i32] %7, i32 %4, 3
ret [4 x i32] %oldret ret [4 x i32] %oldret
} }

llvm/test/CodeGen/NVPTX/param-vectorize-kernel.ll

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Lines
%struct.St4x6 = type { [6 x i32] } %struct.St4x6 = type { [6 x i32] }
%struct.St4x7 = type { [7 x i32] } %struct.St4x7 = type { [7 x i32] }
%struct.St4x8 = type { [8 x i32] } %struct.St4x8 = type { [8 x i32] }
%struct.St8x1 = type { [1 x i64] } %struct.St8x1 = type { [1 x i64] }
%struct.St8x2 = type { [2 x i64] } %struct.St8x2 = type { [2 x i64] }
%struct.St8x3 = type { [3 x i64] } %struct.St8x3 = type { [3 x i64] }
%struct.St8x4 = type { [4 x i64] } %struct.St8x4 = type { [4 x i64] }
define dso_local void @foo_St4x1(%struct.St4x1* nocapture noundef readonly byval(%struct.St4x1) align 4 %in, %struct.St4x1* nocapture noundef writeonly %ret) { define dso_local void @foo_St4x1(ptr nocapture noundef readonly byval(%struct.St4x1) align 4 %in, ptr nocapture noundef writeonly %ret) {
; CHECK-LABEL: .visible .func foo_St4x1( ; CHECK-LABEL: .visible .func foo_St4x1(
; CHECK: .param .align 4 .b8 foo_St4x1_param_0[4], ; CHECK: .param .align 4 .b8 foo_St4x1_param_0[4],
; CHECK: .param .b32 foo_St4x1_param_1 ; CHECK: .param .b32 foo_St4x1_param_1
; CHECK: ) ; CHECK: )
; CHECK: ld.param.u32 [[R1:%r[0-9]+]], [foo_St4x1_param_1]; ; CHECK: ld.param.u32 [[R1:%r[0-9]+]], [foo_St4x1_param_1];
; CHECK: ld.param.u32 [[R2:%r[0-9]+]], [foo_St4x1_param_0]; ; CHECK: ld.param.u32 [[R2:%r[0-9]+]], [foo_St4x1_param_0];
; CHECK: st.u32 [[[R1]]], [[R2]]; ; CHECK: st.u32 [[[R1]]], [[R2]];
; CHECK: ret; ; CHECK: ret;
%arrayidx = getelementptr inbounds %struct.St4x1, %struct.St4x1* %in, i64 0, i32 0, i64 0 %1 = load i32, ptr %in, align 4
%1 = load i32, i32* %arrayidx, align 4 store i32 %1, ptr %ret, align 4
%arrayidx3 = getelementptr inbounds %struct.St4x1, %struct.St4x1* %ret, i64 0, i32 0, i64 0
store i32 %1, i32* %arrayidx3, align 4
ret void ret void
} }
define dso_local void @foo_St4x2(%struct.St4x2* nocapture noundef readonly byval(%struct.St4x2) align 4 %in, %struct.St4x2* nocapture noundef writeonly %ret) { define dso_local void @foo_St4x2(ptr nocapture noundef readonly byval(%struct.St4x2) align 4 %in, ptr nocapture noundef writeonly %ret) {
; CHECK-LABEL: .visible .func foo_St4x2( ; CHECK-LABEL: .visible .func foo_St4x2(
; CHECK: .param .align 4 .b8 foo_St4x2_param_0[8], ; CHECK: .param .align 4 .b8 foo_St4x2_param_0[8],
; CHECK: .param .b32 foo_St4x2_param_1 ; CHECK: .param .b32 foo_St4x2_param_1
; CHECK: ) ; CHECK: )
; CHECK: ld.param.u32 [[R1:%r[0-9]+]], [foo_St4x2_param_1]; ; CHECK: ld.param.u32 [[R1:%r[0-9]+]], [foo_St4x2_param_1];
; CHECK: ld.param.u32 [[R2:%r[0-9]+]], [foo_St4x2_param_0]; ; CHECK: ld.param.u32 [[R2:%r[0-9]+]], [foo_St4x2_param_0];
; CHECK: st.u32 [[[R1]]], [[R2]]; ; CHECK: st.u32 [[[R1]]], [[R2]];
; CHECK: ld.param.u32 [[R3:%r[0-9]+]], [foo_St4x2_param_0+4]; ; CHECK: ld.param.u32 [[R3:%r[0-9]+]], [foo_St4x2_param_0+4];
; CHECK: st.u32 [[[R1]]+4], [[R3]]; ; CHECK: st.u32 [[[R1]]+4], [[R3]];
; CHECK: ret; ; CHECK: ret;
%arrayidx = getelementptr inbounds %struct.St4x2, %struct.St4x2* %in, i64 0, i32 0, i64 0 %1 = load i32, ptr %in, align 4
%1 = load i32, i32* %arrayidx, align 4 store i32 %1, ptr %ret, align 4
%arrayidx3 = getelementptr inbounds %struct.St4x2, %struct.St4x2* %ret, i64 0, i32 0, i64 0 %arrayidx.1 = getelementptr inbounds [2 x i32], ptr %in, i64 0, i64 1
store i32 %1, i32* %arrayidx3, align 4 %2 = load i32, ptr %arrayidx.1, align 4
%arrayidx.1 = getelementptr inbounds %struct.St4x2, %struct.St4x2* %in, i64 0, i32 0, i64 1 %arrayidx3.1 = getelementptr inbounds [2 x i32], ptr %ret, i64 0, i64 1
%2 = load i32, i32* %arrayidx.1, align 4 store i32 %2, ptr %arrayidx3.1, align 4
%arrayidx3.1 = getelementptr inbounds %struct.St4x2, %struct.St4x2* %ret, i64 0, i32 0, i64 1
store i32 %2, i32* %arrayidx3.1, align 4
ret void ret void
} }
define dso_local void @foo_St4x3(%struct.St4x3* nocapture noundef readonly byval(%struct.St4x3) align 4 %in, %struct.St4x3* nocapture noundef writeonly %ret) { define dso_local void @foo_St4x3(ptr nocapture noundef readonly byval(%struct.St4x3) align 4 %in, ptr nocapture noundef writeonly %ret) {
; CHECK-LABEL: .visible .func foo_St4x3( ; CHECK-LABEL: .visible .func foo_St4x3(
; CHECK: .param .align 4 .b8 foo_St4x3_param_0[12], ; CHECK: .param .align 4 .b8 foo_St4x3_param_0[12],
; CHECK: .param .b32 foo_St4x3_param_1 ; CHECK: .param .b32 foo_St4x3_param_1
; CHECK: ) ; CHECK: )
; CHECK: ld.param.u32 [[R1:%r[0-9]+]], [foo_St4x3_param_1]; ; CHECK: ld.param.u32 [[R1:%r[0-9]+]], [foo_St4x3_param_1];
; CHECK: ld.param.u32 [[R2:%r[0-9]+]], [foo_St4x3_param_0]; ; CHECK: ld.param.u32 [[R2:%r[0-9]+]], [foo_St4x3_param_0];
; CHECK: st.u32 [[[R1]]], [[R2]]; ; CHECK: st.u32 [[[R1]]], [[R2]];
; CHECK: ld.param.u32 [[R3:%r[0-9]+]], [foo_St4x3_param_0+4]; ; CHECK: ld.param.u32 [[R3:%r[0-9]+]], [foo_St4x3_param_0+4];
; CHECK: st.u32 [[[R1]]+4], [[R3]]; ; CHECK: st.u32 [[[R1]]+4], [[R3]];
; CHECK: ld.param.u32 [[R4:%r[0-9]+]], [foo_St4x3_param_0+8]; ; CHECK: ld.param.u32 [[R4:%r[0-9]+]], [foo_St4x3_param_0+8];
; CHECK: st.u32 [[[R1]]+8], [[R4]]; ; CHECK: st.u32 [[[R1]]+8], [[R4]];
; CHECK: ret; ; CHECK: ret;
%arrayidx = getelementptr inbounds %struct.St4x3, %struct.St4x3* %in, i64 0, i32 0, i64 0 %1 = load i32, ptr %in, align 4
%1 = load i32, i32* %arrayidx, align 4 store i32 %1, ptr %ret, align 4
%arrayidx3 = getelementptr inbounds %struct.St4x3, %struct.St4x3* %ret, i64 0, i32 0, i64 0 %arrayidx.1 = getelementptr inbounds [3 x i32], ptr %in, i64 0, i64 1
store i32 %1, i32* %arrayidx3, align 4 %2 = load i32, ptr %arrayidx.1, align 4
%arrayidx.1 = getelementptr inbounds %struct.St4x3, %struct.St4x3* %in, i64 0, i32 0, i64 1 %arrayidx3.1 = getelementptr inbounds [3 x i32], ptr %ret, i64 0, i64 1
%2 = load i32, i32* %arrayidx.1, align 4 store i32 %2, ptr %arrayidx3.1, align 4
%arrayidx3.1 = getelementptr inbounds %struct.St4x3, %struct.St4x3* %ret, i64 0, i32 0, i64 1 %arrayidx.2 = getelementptr inbounds [3 x i32], ptr %in, i64 0, i64 2
store i32 %2, i32* %arrayidx3.1, align 4 %3 = load i32, ptr %arrayidx.2, align 4
%arrayidx.2 = getelementptr inbounds %struct.St4x3, %struct.St4x3* %in, i64 0, i32 0, i64 2 %arrayidx3.2 = getelementptr inbounds [3 x i32], ptr %ret, i64 0, i64 2
%3 = load i32, i32* %arrayidx.2, align 4 store i32 %3, ptr %arrayidx3.2, align 4
%arrayidx3.2 = getelementptr inbounds %struct.St4x3, %struct.St4x3* %ret, i64 0, i32 0, i64 2
store i32 %3, i32* %arrayidx3.2, align 4
ret void ret void
} }
define dso_local void @foo_St4x4(%struct.St4x4* nocapture noundef readonly byval(%struct.St4x4) align 4 %in, %struct.St4x4* nocapture noundef writeonly %ret) { define dso_local void @foo_St4x4(ptr nocapture noundef readonly byval(%struct.St4x4) align 4 %in, ptr nocapture noundef writeonly %ret) {
; CHECK-LABEL: .visible .func foo_St4x4( ; CHECK-LABEL: .visible .func foo_St4x4(
; CHECK: .param .align 4 .b8 foo_St4x4_param_0[16], ; CHECK: .param .align 4 .b8 foo_St4x4_param_0[16],
; CHECK: .param .b32 foo_St4x4_param_1 ; CHECK: .param .b32 foo_St4x4_param_1
; CHECK: ) ; CHECK: )
; CHECK: ld.param.u32 [[R1:%r[0-9]+]], [foo_St4x4_param_1]; ; CHECK: ld.param.u32 [[R1:%r[0-9]+]], [foo_St4x4_param_1];
; CHECK: ld.param.u32 [[R2:%r[0-9]+]], [foo_St4x4_param_0]; ; CHECK: ld.param.u32 [[R2:%r[0-9]+]], [foo_St4x4_param_0];
; CHECK: st.u32 [[[R1]]], [[R2]]; ; CHECK: st.u32 [[[R1]]], [[R2]];
; CHECK: ld.param.u32 [[R3:%r[0-9]+]], [foo_St4x4_param_0+4]; ; CHECK: ld.param.u32 [[R3:%r[0-9]+]], [foo_St4x4_param_0+4];
; CHECK: st.u32 [[[R1]]+4], [[R3]]; ; CHECK: st.u32 [[[R1]]+4], [[R3]];
; CHECK: ld.param.u32 [[R4:%r[0-9]+]], [foo_St4x4_param_0+8]; ; CHECK: ld.param.u32 [[R4:%r[0-9]+]], [foo_St4x4_param_0+8];
; CHECK: st.u32 [[[R1]]+8], [[R4]]; ; CHECK: st.u32 [[[R1]]+8], [[R4]];
; CHECK: ld.param.u32 [[R5:%r[0-9]+]], [foo_St4x4_param_0+12]; ; CHECK: ld.param.u32 [[R5:%r[0-9]+]], [foo_St4x4_param_0+12];
; CHECK: st.u32 [[[R1]]+12], [[R5]]; ; CHECK: st.u32 [[[R1]]+12], [[R5]];
; CHECK: ret; ; CHECK: ret;
%arrayidx = getelementptr inbounds %struct.St4x4, %struct.St4x4* %in, i64 0, i32 0, i64 0 %1 = load i32, ptr %in, align 4
%1 = load i32, i32* %arrayidx, align 4 store i32 %1, ptr %ret, align 4
%arrayidx3 = getelementptr inbounds %struct.St4x4, %struct.St4x4* %ret, i64 0, i32 0, i64 0 %arrayidx.1 = getelementptr inbounds [4 x i32], ptr %in, i64 0, i64 1
store i32 %1, i32* %arrayidx3, align 4 %2 = load i32, ptr %arrayidx.1, align 4
%arrayidx.1 = getelementptr inbounds %struct.St4x4, %struct.St4x4* %in, i64 0, i32 0, i64 1 %arrayidx3.1 = getelementptr inbounds [4 x i32], ptr %ret, i64 0, i64 1
%2 = load i32, i32* %arrayidx.1, align 4 store i32 %2, ptr %arrayidx3.1, align 4
%arrayidx3.1 = getelementptr inbounds %struct.St4x4, %struct.St4x4* %ret, i64 0, i32 0, i64 1 %arrayidx.2 = getelementptr inbounds [4 x i32], ptr %in, i64 0, i64 2
store i32 %2, i32* %arrayidx3.1, align 4 %3 = load i32, ptr %arrayidx.2, align 4
%arrayidx.2 = getelementptr inbounds %struct.St4x4, %struct.St4x4* %in, i64 0, i32 0, i64 2 %arrayidx3.2 = getelementptr inbounds [4 x i32], ptr %ret, i64 0, i64 2
%3 = load i32, i32* %arrayidx.2, align 4 store i32 %3, ptr %arrayidx3.2, align 4
%arrayidx3.2 = getelementptr inbounds %struct.St4x4, %struct.St4x4* %ret, i64 0, i32 0, i64 2 %arrayidx.3 = getelementptr inbounds [4 x i32], ptr %in, i64 0, i64 3
store i32 %3, i32* %arrayidx3.2, align 4 %4 = load i32, ptr %arrayidx.3, align 4
%arrayidx.3 = getelementptr inbounds %struct.St4x4, %struct.St4x4* %in, i64 0, i32 0, i64 3 %arrayidx3.3 = getelementptr inbounds [4 x i32], ptr %ret, i64 0, i64 3
%4 = load i32, i32* %arrayidx.3, align 4 store i32 %4, ptr %arrayidx3.3, align 4
%arrayidx3.3 = getelementptr inbounds %struct.St4x4, %struct.St4x4* %ret, i64 0, i32 0, i64 3
store i32 %4, i32* %arrayidx3.3, align 4
ret void ret void
} }
define dso_local void @foo_St4x5(%struct.St4x5* nocapture noundef readonly byval(%struct.St4x5) align 4 %in, %struct.St4x5* nocapture noundef writeonly %ret) { define dso_local void @foo_St4x5(ptr nocapture noundef readonly byval(%struct.St4x5) align 4 %in, ptr nocapture noundef writeonly %ret) {
; CHECK-LABEL: .visible .func foo_St4x5( ; CHECK-LABEL: .visible .func foo_St4x5(
; CHECK: .param .align 4 .b8 foo_St4x5_param_0[20], ; CHECK: .param .align 4 .b8 foo_St4x5_param_0[20],
; CHECK: .param .b32 foo_St4x5_param_1 ; CHECK: .param .b32 foo_St4x5_param_1
; CHECK: ) ; CHECK: )
; CHECK: ld.param.u32 [[R1:%r[0-9]+]], [foo_St4x5_param_1]; ; CHECK: ld.param.u32 [[R1:%r[0-9]+]], [foo_St4x5_param_1];
; CHECK: ld.param.u32 [[R2:%r[0-9]+]], [foo_St4x5_param_0]; ; CHECK: ld.param.u32 [[R2:%r[0-9]+]], [foo_St4x5_param_0];
; CHECK: st.u32 [[[R1]]], [[R2]]; ; CHECK: st.u32 [[[R1]]], [[R2]];
; CHECK: ld.param.u32 [[R3:%r[0-9]+]], [foo_St4x5_param_0+4]; ; CHECK: ld.param.u32 [[R3:%r[0-9]+]], [foo_St4x5_param_0+4];
; CHECK: st.u32 [[[R1]]+4], [[R3]]; ; CHECK: st.u32 [[[R1]]+4], [[R3]];
; CHECK: ld.param.u32 [[R4:%r[0-9]+]], [foo_St4x5_param_0+8]; ; CHECK: ld.param.u32 [[R4:%r[0-9]+]], [foo_St4x5_param_0+8];
; CHECK: st.u32 [[[R1]]+8], [[R4]]; ; CHECK: st.u32 [[[R1]]+8], [[R4]];
; CHECK: ld.param.u32 [[R5:%r[0-9]+]], [foo_St4x5_param_0+12]; ; CHECK: ld.param.u32 [[R5:%r[0-9]+]], [foo_St4x5_param_0+12];
; CHECK: st.u32 [[[R1]]+12], [[R5]]; ; CHECK: st.u32 [[[R1]]+12], [[R5]];
; CHECK: ld.param.u32 [[R6:%r[0-9]+]], [foo_St4x5_param_0+16]; ; CHECK: ld.param.u32 [[R6:%r[0-9]+]], [foo_St4x5_param_0+16];
; CHECK: st.u32 [[[R1]]+16], [[R6]]; ; CHECK: st.u32 [[[R1]]+16], [[R6]];
; CHECK: ret; ; CHECK: ret;
%arrayidx = getelementptr inbounds %struct.St4x5, %struct.St4x5* %in, i64 0, i32 0, i64 0 %1 = load i32, ptr %in, align 4
%1 = load i32, i32* %arrayidx, align 4 store i32 %1, ptr %ret, align 4
%arrayidx3 = getelementptr inbounds %struct.St4x5, %struct.St4x5* %ret, i64 0, i32 0, i64 0 %arrayidx.1 = getelementptr inbounds [5 x i32], ptr %in, i64 0, i64 1
store i32 %1, i32* %arrayidx3, align 4 %2 = load i32, ptr %arrayidx.1, align 4
%arrayidx.1 = getelementptr inbounds %struct.St4x5, %struct.St4x5* %in, i64 0, i32 0, i64 1 %arrayidx3.1 = getelementptr inbounds [5 x i32], ptr %ret, i64 0, i64 1
%2 = load i32, i32* %arrayidx.1, align 4 store i32 %2, ptr %arrayidx3.1, align 4
%arrayidx3.1 = getelementptr inbounds %struct.St4x5, %struct.St4x5* %ret, i64 0, i32 0, i64 1 %arrayidx.2 = getelementptr inbounds [5 x i32], ptr %in, i64 0, i64 2
store i32 %2, i32* %arrayidx3.1, align 4 %3 = load i32, ptr %arrayidx.2, align 4
%arrayidx.2 = getelementptr inbounds %struct.St4x5, %struct.St4x5* %in, i64 0, i32 0, i64 2 %arrayidx3.2 = getelementptr inbounds [5 x i32], ptr %ret, i64 0, i64 2
%3 = load i32, i32* %arrayidx.2, align 4 store i32 %3, ptr %arrayidx3.2, align 4
%arrayidx3.2 = getelementptr inbounds %struct.St4x5, %struct.St4x5* %ret, i64 0, i32 0, i64 2 %arrayidx.3 = getelementptr inbounds [5 x i32], ptr %in, i64 0, i64 3
store i32 %3, i32* %arrayidx3.2, align 4 %4 = load i32, ptr %arrayidx.3, align 4
%arrayidx.3 = getelementptr inbounds %struct.St4x5, %struct.St4x5* %in, i64 0, i32 0, i64 3 %arrayidx3.3 = getelementptr inbounds [5 x i32], ptr %ret, i64 0, i64 3
%4 = load i32, i32* %arrayidx.3, align 4 store i32 %4, ptr %arrayidx3.3, align 4
%arrayidx3.3 = getelementptr inbounds %struct.St4x5, %struct.St4x5* %ret, i64 0, i32 0, i64 3 %arrayidx.4 = getelementptr inbounds [5 x i32], ptr %in, i64 0, i64 4
store i32 %4, i32* %arrayidx3.3, align 4 %5 = load i32, ptr %arrayidx.4, align 4
%arrayidx.4 = getelementptr inbounds %struct.St4x5, %struct.St4x5* %in, i64 0, i32 0, i64 4 %arrayidx3.4 = getelementptr inbounds [5 x i32], ptr %ret, i64 0, i64 4
%5 = load i32, i32* %arrayidx.4, align 4 store i32 %5, ptr %arrayidx3.4, align 4
%arrayidx3.4 = getelementptr inbounds %struct.St4x5, %struct.St4x5* %ret, i64 0, i32 0, i64 4
store i32 %5, i32* %arrayidx3.4, align 4
ret void ret void
} }
define dso_local void @foo_St4x6(%struct.St4x6* nocapture noundef readonly byval(%struct.St4x6) align 4 %in, %struct.St4x6* nocapture noundef writeonly %ret) { define dso_local void @foo_St4x6(ptr nocapture noundef readonly byval(%struct.St4x6) align 4 %in, ptr nocapture noundef writeonly %ret) {
; CHECK-LABEL: .visible .func foo_St4x6( ; CHECK-LABEL: .visible .func foo_St4x6(
; CHECK: .param .align 4 .b8 foo_St4x6_param_0[24], ; CHECK: .param .align 4 .b8 foo_St4x6_param_0[24],
; CHECK: .param .b32 foo_St4x6_param_1 ; CHECK: .param .b32 foo_St4x6_param_1
; CHECK: ) ; CHECK: )
; CHECK: ld.param.u32 [[R1:%r[0-9]+]], [foo_St4x6_param_1]; ; CHECK: ld.param.u32 [[R1:%r[0-9]+]], [foo_St4x6_param_1];
; CHECK: ld.param.u32 [[R2:%r[0-9]+]], [foo_St4x6_param_0]; ; CHECK: ld.param.u32 [[R2:%r[0-9]+]], [foo_St4x6_param_0];
; CHECK: st.u32 [[[R1]]], [[R2]]; ; CHECK: st.u32 [[[R1]]], [[R2]];
; CHECK: ld.param.u32 [[R3:%r[0-9]+]], [foo_St4x6_param_0+4]; ; CHECK: ld.param.u32 [[R3:%r[0-9]+]], [foo_St4x6_param_0+4];
; CHECK: st.u32 [[[R1]]+4], [[R3]]; ; CHECK: st.u32 [[[R1]]+4], [[R3]];
; CHECK: ld.param.u32 [[R4:%r[0-9]+]], [foo_St4x6_param_0+8]; ; CHECK: ld.param.u32 [[R4:%r[0-9]+]], [foo_St4x6_param_0+8];
; CHECK: st.u32 [[[R1]]+8], [[R4]]; ; CHECK: st.u32 [[[R1]]+8], [[R4]];
; CHECK: ld.param.u32 [[R5:%r[0-9]+]], [foo_St4x6_param_0+12]; ; CHECK: ld.param.u32 [[R5:%r[0-9]+]], [foo_St4x6_param_0+12];
; CHECK: st.u32 [[[R1]]+12], [[R5]]; ; CHECK: st.u32 [[[R1]]+12], [[R5]];
; CHECK: ld.param.u32 [[R6:%r[0-9]+]], [foo_St4x6_param_0+16]; ; CHECK: ld.param.u32 [[R6:%r[0-9]+]], [foo_St4x6_param_0+16];
; CHECK: st.u32 [[[R1]]+16], [[R6]]; ; CHECK: st.u32 [[[R1]]+16], [[R6]];
; CHECK: ld.param.u32 [[R7:%r[0-9]+]], [foo_St4x6_param_0+20]; ; CHECK: ld.param.u32 [[R7:%r[0-9]+]], [foo_St4x6_param_0+20];
; CHECK: st.u32 [[[R1]]+20], [[R7]]; ; CHECK: st.u32 [[[R1]]+20], [[R7]];
; CHECK: ret; ; CHECK: ret;
%arrayidx = getelementptr inbounds %struct.St4x6, %struct.St4x6* %in, i64 0, i32 0, i64 0 %1 = load i32, ptr %in, align 4
%1 = load i32, i32* %arrayidx, align 4 store i32 %1, ptr %ret, align 4
%arrayidx3 = getelementptr inbounds %struct.St4x6, %struct.St4x6* %ret, i64 0, i32 0, i64 0 %arrayidx.1 = getelementptr inbounds [6 x i32], ptr %in, i64 0, i64 1
store i32 %1, i32* %arrayidx3, align 4 %2 = load i32, ptr %arrayidx.1, align 4
%arrayidx.1 = getelementptr inbounds %struct.St4x6, %struct.St4x6* %in, i64 0, i32 0, i64 1 %arrayidx3.1 = getelementptr inbounds [6 x i32], ptr %ret, i64 0, i64 1
%2 = load i32, i32* %arrayidx.1, align 4 store i32 %2, ptr %arrayidx3.1, align 4
%arrayidx3.1 = getelementptr inbounds %struct.St4x6, %struct.St4x6* %ret, i64 0, i32 0, i64 1 %arrayidx.2 = getelementptr inbounds [6 x i32], ptr %in, i64 0, i64 2
store i32 %2, i32* %arrayidx3.1, align 4 %3 = load i32, ptr %arrayidx.2, align 4
%arrayidx.2 = getelementptr inbounds %struct.St4x6, %struct.St4x6* %in, i64 0, i32 0, i64 2 %arrayidx3.2 = getelementptr inbounds [6 x i32], ptr %ret, i64 0, i64 2
%3 = load i32, i32* %arrayidx.2, align 4 store i32 %3, ptr %arrayidx3.2, align 4
%arrayidx3.2 = getelementptr inbounds %struct.St4x6, %struct.St4x6* %ret, i64 0, i32 0, i64 2 %arrayidx.3 = getelementptr inbounds [6 x i32], ptr %in, i64 0, i64 3
store i32 %3, i32* %arrayidx3.2, align 4 %4 = load i32, ptr %arrayidx.3, align 4
%arrayidx.3 = getelementptr inbounds %struct.St4x6, %struct.St4x6* %in, i64 0, i32 0, i64 3 %arrayidx3.3 = getelementptr inbounds [6 x i32], ptr %ret, i64 0, i64 3
%4 = load i32, i32* %arrayidx.3, align 4 store i32 %4, ptr %arrayidx3.3, align 4
%arrayidx3.3 = getelementptr inbounds %struct.St4x6, %struct.St4x6* %ret, i64 0, i32 0, i64 3 %arrayidx.4 = getelementptr inbounds [6 x i32], ptr %in, i64 0, i64 4
store i32 %4, i32* %arrayidx3.3, align 4 %5 = load i32, ptr %arrayidx.4, align 4
%arrayidx.4 = getelementptr inbounds %struct.St4x6, %struct.St4x6* %in, i64 0, i32 0, i64 4 %arrayidx3.4 = getelementptr inbounds [6 x i32], ptr %ret, i64 0, i64 4
%5 = load i32, i32* %arrayidx.4, align 4 store i32 %5, ptr %arrayidx3.4, align 4
%arrayidx3.4 = getelementptr inbounds %struct.St4x6, %struct.St4x6* %ret, i64 0, i32 0, i64 4 %arrayidx.5 = getelementptr inbounds [6 x i32], ptr %in, i64 0, i64 5
store i32 %5, i32* %arrayidx3.4, align 4 %6 = load i32, ptr %arrayidx.5, align 4
%arrayidx.5 = getelementptr inbounds %struct.St4x6, %struct.St4x6* %in, i64 0, i32 0, i64 5 %arrayidx3.5 = getelementptr inbounds [6 x i32], ptr %ret, i64 0, i64 5
%6 = load i32, i32* %arrayidx.5, align 4 store i32 %6, ptr %arrayidx3.5, align 4
%arrayidx3.5 = getelementptr inbounds %struct.St4x6, %struct.St4x6* %ret, i64 0, i32 0, i64 5
store i32 %6, i32* %arrayidx3.5, align 4
ret void ret void
} }
define dso_local void @foo_St4x7(%struct.St4x7* nocapture noundef readonly byval(%struct.St4x7) align 4 %in, %struct.St4x7* nocapture noundef writeonly %ret) { define dso_local void @foo_St4x7(ptr nocapture noundef readonly byval(%struct.St4x7) align 4 %in, ptr nocapture noundef writeonly %ret) {
; CHECK-LABEL: .visible .func foo_St4x7( ; CHECK-LABEL: .visible .func foo_St4x7(
; CHECK: .param .align 4 .b8 foo_St4x7_param_0[28], ; CHECK: .param .align 4 .b8 foo_St4x7_param_0[28],
; CHECK: .param .b32 foo_St4x7_param_1 ; CHECK: .param .b32 foo_St4x7_param_1
; CHECK: ) ; CHECK: )
; CHECK: ld.param.u32 [[R1:%r[0-9]+]], [foo_St4x7_param_1]; ; CHECK: ld.param.u32 [[R1:%r[0-9]+]], [foo_St4x7_param_1];
; CHECK: ld.param.u32 [[R2:%r[0-9]+]], [foo_St4x7_param_0]; ; CHECK: ld.param.u32 [[R2:%r[0-9]+]], [foo_St4x7_param_0];
; CHECK: st.u32 [[[R1]]], [[R2]]; ; CHECK: st.u32 [[[R1]]], [[R2]];
; CHECK: ld.param.u32 [[R3:%r[0-9]+]], [foo_St4x7_param_0+4]; ; CHECK: ld.param.u32 [[R3:%r[0-9]+]], [foo_St4x7_param_0+4];
; CHECK: st.u32 [[[R1]]+4], [[R3]]; ; CHECK: st.u32 [[[R1]]+4], [[R3]];
; CHECK: ld.param.u32 [[R4:%r[0-9]+]], [foo_St4x7_param_0+8]; ; CHECK: ld.param.u32 [[R4:%r[0-9]+]], [foo_St4x7_param_0+8];
; CHECK: st.u32 [[[R1]]+8], [[R4]]; ; CHECK: st.u32 [[[R1]]+8], [[R4]];
; CHECK: ld.param.u32 [[R5:%r[0-9]+]], [foo_St4x7_param_0+12]; ; CHECK: ld.param.u32 [[R5:%r[0-9]+]], [foo_St4x7_param_0+12];
; CHECK: st.u32 [[[R1]]+12], [[R5]]; ; CHECK: st.u32 [[[R1]]+12], [[R5]];
; CHECK: ld.param.u32 [[R6:%r[0-9]+]], [foo_St4x7_param_0+16]; ; CHECK: ld.param.u32 [[R6:%r[0-9]+]], [foo_St4x7_param_0+16];
; CHECK: st.u32 [[[R1]]+16], [[R6]]; ; CHECK: st.u32 [[[R1]]+16], [[R6]];
; CHECK: ld.param.u32 [[R7:%r[0-9]+]], [foo_St4x7_param_0+20]; ; CHECK: ld.param.u32 [[R7:%r[0-9]+]], [foo_St4x7_param_0+20];
; CHECK: st.u32 [[[R1]]+20], [[R7]]; ; CHECK: st.u32 [[[R1]]+20], [[R7]];
; CHECK: ld.param.u32 [[R8:%r[0-9]+]], [foo_St4x7_param_0+24]; ; CHECK: ld.param.u32 [[R8:%r[0-9]+]], [foo_St4x7_param_0+24];
; CHECK: st.u32 [[[R1]]+24], [[R8]]; ; CHECK: st.u32 [[[R1]]+24], [[R8]];
; CHECK: ret; ; CHECK: ret;
%arrayidx = getelementptr inbounds %struct.St4x7, %struct.St4x7* %in, i64 0, i32 0, i64 0 %1 = load i32, ptr %in, align 4
%1 = load i32, i32* %arrayidx, align 4 store i32 %1, ptr %ret, align 4
%arrayidx3 = getelementptr inbounds %struct.St4x7, %struct.St4x7* %ret, i64 0, i32 0, i64 0 %arrayidx.1 = getelementptr inbounds [7 x i32], ptr %in, i64 0, i64 1
store i32 %1, i32* %arrayidx3, align 4 %2 = load i32, ptr %arrayidx.1, align 4
%arrayidx.1 = getelementptr inbounds %struct.St4x7, %struct.St4x7* %in, i64 0, i32 0, i64 1 %arrayidx3.1 = getelementptr inbounds [7 x i32], ptr %ret, i64 0, i64 1
%2 = load i32, i32* %arrayidx.1, align 4 store i32 %2, ptr %arrayidx3.1, align 4
%arrayidx3.1 = getelementptr inbounds %struct.St4x7, %struct.St4x7* %ret, i64 0, i32 0, i64 1 %arrayidx.2 = getelementptr inbounds [7 x i32], ptr %in, i64 0, i64 2
store i32 %2, i32* %arrayidx3.1, align 4 %3 = load i32, ptr %arrayidx.2, align 4
%arrayidx.2 = getelementptr inbounds %struct.St4x7, %struct.St4x7* %in, i64 0, i32 0, i64 2 %arrayidx3.2 = getelementptr inbounds [7 x i32], ptr %ret, i64 0, i64 2
%3 = load i32, i32* %arrayidx.2, align 4 store i32 %3, ptr %arrayidx3.2, align 4
%arrayidx3.2 = getelementptr inbounds %struct.St4x7, %struct.St4x7* %ret, i64 0, i32 0, i64 2 %arrayidx.3 = getelementptr inbounds [7 x i32], ptr %in, i64 0, i64 3
store i32 %3, i32* %arrayidx3.2, align 4 %4 = load i32, ptr %arrayidx.3, align 4
%arrayidx.3 = getelementptr inbounds %struct.St4x7, %struct.St4x7* %in, i64 0, i32 0, i64 3 %arrayidx3.3 = getelementptr inbounds [7 x i32], ptr %ret, i64 0, i64 3
%4 = load i32, i32* %arrayidx.3, align 4 store i32 %4, ptr %arrayidx3.3, align 4
%arrayidx3.3 = getelementptr inbounds %struct.St4x7, %struct.St4x7* %ret, i64 0, i32 0, i64 3 %arrayidx.4 = getelementptr inbounds [7 x i32], ptr %in, i64 0, i64 4
store i32 %4, i32* %arrayidx3.3, align 4 %5 = load i32, ptr %arrayidx.4, align 4
%arrayidx.4 = getelementptr inbounds %struct.St4x7, %struct.St4x7* %in, i64 0, i32 0, i64 4 %arrayidx3.4 = getelementptr inbounds [7 x i32], ptr %ret, i64 0, i64 4
%5 = load i32, i32* %arrayidx.4, align 4 store i32 %5, ptr %arrayidx3.4, align 4
%arrayidx3.4 = getelementptr inbounds %struct.St4x7, %struct.St4x7* %ret, i64 0, i32 0, i64 4 %arrayidx.5 = getelementptr inbounds [7 x i32], ptr %in, i64 0, i64 5
store i32 %5, i32* %arrayidx3.4, align 4 %6 = load i32, ptr %arrayidx.5, align 4
%arrayidx.5 = getelementptr inbounds %struct.St4x7, %struct.St4x7* %in, i64 0, i32 0, i64 5 %arrayidx3.5 = getelementptr inbounds [7 x i32], ptr %ret, i64 0, i64 5
%6 = load i32, i32* %arrayidx.5, align 4 store i32 %6, ptr %arrayidx3.5, align 4
%arrayidx3.5 = getelementptr inbounds %struct.St4x7, %struct.St4x7* %ret, i64 0, i32 0, i64 5 %arrayidx.6 = getelementptr inbounds [7 x i32], ptr %in, i64 0, i64 6
store i32 %6, i32* %arrayidx3.5, align 4 %7 = load i32, ptr %arrayidx.6, align 4
%arrayidx.6 = getelementptr inbounds %struct.St4x7, %struct.St4x7* %in, i64 0, i32 0, i64 6 %arrayidx3.6 = getelementptr inbounds [7 x i32], ptr %ret, i64 0, i64 6
%7 = load i32, i32* %arrayidx.6, align 4 store i32 %7, ptr %arrayidx3.6, align 4
%arrayidx3.6 = getelementptr inbounds %struct.St4x7, %struct.St4x7* %ret, i64 0, i32 0, i64 6
store i32 %7, i32* %arrayidx3.6, align 4
ret void ret void
} }
define dso_local void @foo_St4x8(%struct.St4x8* nocapture noundef readonly byval(%struct.St4x8) align 4 %in, %struct.St4x8* nocapture noundef writeonly %ret) { define dso_local void @foo_St4x8(ptr nocapture noundef readonly byval(%struct.St4x8) align 4 %in, ptr nocapture noundef writeonly %ret) {
; CHECK-LABEL: .visible .func foo_St4x8( ; CHECK-LABEL: .visible .func foo_St4x8(
; CHECK: .param .align 4 .b8 foo_St4x8_param_0[32], ; CHECK: .param .align 4 .b8 foo_St4x8_param_0[32],
; CHECK: .param .b32 foo_St4x8_param_1 ; CHECK: .param .b32 foo_St4x8_param_1
; CHECK: ) ; CHECK: )
; CHECK: ld.param.u32 [[R1:%r[0-9]+]], [foo_St4x8_param_1]; ; CHECK: ld.param.u32 [[R1:%r[0-9]+]], [foo_St4x8_param_1];
; CHECK: ld.param.u32 [[R2:%r[0-9]+]], [foo_St4x8_param_0]; ; CHECK: ld.param.u32 [[R2:%r[0-9]+]], [foo_St4x8_param_0];
; CHECK: st.u32 [[[R1]]], [[R2]]; ; CHECK: st.u32 [[[R1]]], [[R2]];
; CHECK: ld.param.u32 [[R3:%r[0-9]+]], [foo_St4x8_param_0+4]; ; CHECK: ld.param.u32 [[R3:%r[0-9]+]], [foo_St4x8_param_0+4];
; CHECK: st.u32 [[[R1]]+4], [[R3]]; ; CHECK: st.u32 [[[R1]]+4], [[R3]];
; CHECK: ld.param.u32 [[R4:%r[0-9]+]], [foo_St4x8_param_0+8]; ; CHECK: ld.param.u32 [[R4:%r[0-9]+]], [foo_St4x8_param_0+8];
; CHECK: st.u32 [[[R1]]+8], [[R4]]; ; CHECK: st.u32 [[[R1]]+8], [[R4]];
; CHECK: ld.param.u32 [[R5:%r[0-9]+]], [foo_St4x8_param_0+12]; ; CHECK: ld.param.u32 [[R5:%r[0-9]+]], [foo_St4x8_param_0+12];
; CHECK: st.u32 [[[R1]]+12], [[R5]]; ; CHECK: st.u32 [[[R1]]+12], [[R5]];
; CHECK: ld.param.u32 [[R6:%r[0-9]+]], [foo_St4x8_param_0+16]; ; CHECK: ld.param.u32 [[R6:%r[0-9]+]], [foo_St4x8_param_0+16];
; CHECK: st.u32 [[[R1]]+16], [[R6]]; ; CHECK: st.u32 [[[R1]]+16], [[R6]];
; CHECK: ld.param.u32 [[R7:%r[0-9]+]], [foo_St4x8_param_0+20]; ; CHECK: ld.param.u32 [[R7:%r[0-9]+]], [foo_St4x8_param_0+20];
; CHECK: st.u32 [[[R1]]+20], [[R7]]; ; CHECK: st.u32 [[[R1]]+20], [[R7]];
; CHECK: ld.param.u32 [[R8:%r[0-9]+]], [foo_St4x8_param_0+24]; ; CHECK: ld.param.u32 [[R8:%r[0-9]+]], [foo_St4x8_param_0+24];
; CHECK: st.u32 [[[R1]]+24], [[R8]]; ; CHECK: st.u32 [[[R1]]+24], [[R8]];
; CHECK: ld.param.u32 [[R9:%r[0-9]+]], [foo_St4x8_param_0+28]; ; CHECK: ld.param.u32 [[R9:%r[0-9]+]], [foo_St4x8_param_0+28];
; CHECK: st.u32 [[[R1]]+28], [[R9]]; ; CHECK: st.u32 [[[R1]]+28], [[R9]];
; CHECK: ret; ; CHECK: ret;
%arrayidx = getelementptr inbounds %struct.St4x8, %struct.St4x8* %in, i64 0, i32 0, i64 0 %1 = load i32, ptr %in, align 4
%1 = load i32, i32* %arrayidx, align 4 store i32 %1, ptr %ret, align 4
%arrayidx3 = getelementptr inbounds %struct.St4x8, %struct.St4x8* %ret, i64 0, i32 0, i64 0 %arrayidx.1 = getelementptr inbounds [8 x i32], ptr %in, i64 0, i64 1
store i32 %1, i32* %arrayidx3, align 4 %2 = load i32, ptr %arrayidx.1, align 4
%arrayidx.1 = getelementptr inbounds %struct.St4x8, %struct.St4x8* %in, i64 0, i32 0, i64 1 %arrayidx3.1 = getelementptr inbounds [8 x i32], ptr %ret, i64 0, i64 1
%2 = load i32, i32* %arrayidx.1, align 4 store i32 %2, ptr %arrayidx3.1, align 4
%arrayidx3.1 = getelementptr inbounds %struct.St4x8, %struct.St4x8* %ret, i64 0, i32 0, i64 1 %arrayidx.2 = getelementptr inbounds [8 x i32], ptr %in, i64 0, i64 2
store i32 %2, i32* %arrayidx3.1, align 4 %3 = load i32, ptr %arrayidx.2, align 4
%arrayidx.2 = getelementptr inbounds %struct.St4x8, %struct.St4x8* %in, i64 0, i32 0, i64 2 %arrayidx3.2 = getelementptr inbounds [8 x i32], ptr %ret, i64 0, i64 2
%3 = load i32, i32* %arrayidx.2, align 4 store i32 %3, ptr %arrayidx3.2, align 4
%arrayidx3.2 = getelementptr inbounds %struct.St4x8, %struct.St4x8* %ret, i64 0, i32 0, i64 2 %arrayidx.3 = getelementptr inbounds [8 x i32], ptr %in, i64 0, i64 3
store i32 %3, i32* %arrayidx3.2, align 4 %4 = load i32, ptr %arrayidx.3, align 4
%arrayidx.3 = getelementptr inbounds %struct.St4x8, %struct.St4x8* %in, i64 0, i32 0, i64 3 %arrayidx3.3 = getelementptr inbounds [8 x i32], ptr %ret, i64 0, i64 3
%4 = load i32, i32* %arrayidx.3, align 4 store i32 %4, ptr %arrayidx3.3, align 4
%arrayidx3.3 = getelementptr inbounds %struct.St4x8, %struct.St4x8* %ret, i64 0, i32 0, i64 3 %arrayidx.4 = getelementptr inbounds [8 x i32], ptr %in, i64 0, i64 4
store i32 %4, i32* %arrayidx3.3, align 4 %5 = load i32, ptr %arrayidx.4, align 4
%arrayidx.4 = getelementptr inbounds %struct.St4x8, %struct.St4x8* %in, i64 0, i32 0, i64 4 %arrayidx3.4 = getelementptr inbounds [8 x i32], ptr %ret, i64 0, i64 4
%5 = load i32, i32* %arrayidx.4, align 4 store i32 %5, ptr %arrayidx3.4, align 4
%arrayidx3.4 = getelementptr inbounds %struct.St4x8, %struct.St4x8* %ret, i64 0, i32 0, i64 4 %arrayidx.5 = getelementptr inbounds [8 x i32], ptr %in, i64 0, i64 5
store i32 %5, i32* %arrayidx3.4, align 4 %6 = load i32, ptr %arrayidx.5, align 4
%arrayidx.5 = getelementptr inbounds %struct.St4x8, %struct.St4x8* %in, i64 0, i32 0, i64 5 %arrayidx3.5 = getelementptr inbounds [8 x i32], ptr %ret, i64 0, i64 5
%6 = load i32, i32* %arrayidx.5, align 4 store i32 %6, ptr %arrayidx3.5, align 4
%arrayidx3.5 = getelementptr inbounds %struct.St4x8, %struct.St4x8* %ret, i64 0, i32 0, i64 5 %arrayidx.6 = getelementptr inbounds [8 x i32], ptr %in, i64 0, i64 6
store i32 %6, i32* %arrayidx3.5, align 4 %7 = load i32, ptr %arrayidx.6, align 4
%arrayidx.6 = getelementptr inbounds %struct.St4x8, %struct.St4x8* %in, i64 0, i32 0, i64 6 %arrayidx3.6 = getelementptr inbounds [8 x i32], ptr %ret, i64 0, i64 6
%7 = load i32, i32* %arrayidx.6, align 4 store i32 %7, ptr %arrayidx3.6, align 4
%arrayidx3.6 = getelementptr inbounds %struct.St4x8, %struct.St4x8* %ret, i64 0, i32 0, i64 6 %arrayidx.7 = getelementptr inbounds [8 x i32], ptr %in, i64 0, i64 7
store i32 %7, i32* %arrayidx3.6, align 4 %8 = load i32, ptr %arrayidx.7, align 4
%arrayidx.7 = getelementptr inbounds %struct.St4x8, %struct.St4x8* %in, i64 0, i32 0, i64 7 %arrayidx3.7 = getelementptr inbounds [8 x i32], ptr %ret, i64 0, i64 7
%8 = load i32, i32* %arrayidx.7, align 4 store i32 %8, ptr %arrayidx3.7, align 4
%arrayidx3.7 = getelementptr inbounds %struct.St4x8, %struct.St4x8* %ret, i64 0, i32 0, i64 7
store i32 %8, i32* %arrayidx3.7, align 4
ret void ret void
} }
define dso_local void @foo_St8x1(%struct.St8x1* nocapture noundef readonly byval(%struct.St8x1) align 8 %in, %struct.St8x1* nocapture noundef writeonly %ret) { define dso_local void @foo_St8x1(ptr nocapture noundef readonly byval(%struct.St8x1) align 8 %in, ptr nocapture noundef writeonly %ret) {
; CHECK-LABEL: .visible .func foo_St8x1( ; CHECK-LABEL: .visible .func foo_St8x1(
; CHECK: .param .align 8 .b8 foo_St8x1_param_0[8], ; CHECK: .param .align 8 .b8 foo_St8x1_param_0[8],
; CHECK: .param .b32 foo_St8x1_param_1 ; CHECK: .param .b32 foo_St8x1_param_1
; CHECK: ) ; CHECK: )
; CHECK: ld.param.u32 [[R1:%r[0-9]+]], [foo_St8x1_param_1]; ; CHECK: ld.param.u32 [[R1:%r[0-9]+]], [foo_St8x1_param_1];
; CHECK: ld.param.u64 [[RD1:%rd[0-9]+]], [foo_St8x1_param_0]; ; CHECK: ld.param.u64 [[RD1:%rd[0-9]+]], [foo_St8x1_param_0];
; CHECK: st.u64 [[[R1]]], [[RD1]]; ; CHECK: st.u64 [[[R1]]], [[RD1]];
; CHECK: ret; ; CHECK: ret;
%arrayidx = getelementptr inbounds %struct.St8x1, %struct.St8x1* %in, i64 0, i32 0, i64 0 %1 = load i64, ptr %in, align 8
%1 = load i64, i64* %arrayidx, align 8 store i64 %1, ptr %ret, align 8
%arrayidx3 = getelementptr inbounds %struct.St8x1, %struct.St8x1* %ret, i64 0, i32 0, i64 0
store i64 %1, i64* %arrayidx3, align 8
ret void ret void
} }
define dso_local void @foo_St8x2(%struct.St8x2* nocapture noundef readonly byval(%struct.St8x2) align 8 %in, %struct.St8x2* nocapture noundef writeonly %ret) { define dso_local void @foo_St8x2(ptr nocapture noundef readonly byval(%struct.St8x2) align 8 %in, ptr nocapture noundef writeonly %ret) {
; CHECK-LABEL: .visible .func foo_St8x2( ; CHECK-LABEL: .visible .func foo_St8x2(
; CHECK: .param .align 8 .b8 foo_St8x2_param_0[16], ; CHECK: .param .align 8 .b8 foo_St8x2_param_0[16],
; CHECK: .param .b32 foo_St8x2_param_1 ; CHECK: .param .b32 foo_St8x2_param_1
; CHECK: ) ; CHECK: )
; CHECK: ld.param.u32 [[R1:%r[0-9]+]], [foo_St8x2_param_1]; ; CHECK: ld.param.u32 [[R1:%r[0-9]+]], [foo_St8x2_param_1];
; CHECK: ld.param.u64 [[RD1:%rd[0-9]+]], [foo_St8x2_param_0]; ; CHECK: ld.param.u64 [[RD1:%rd[0-9]+]], [foo_St8x2_param_0];
; CHECK: st.u64 [[[R1]]], [[RD1]]; ; CHECK: st.u64 [[[R1]]], [[RD1]];
; CHECK: ld.param.u64 [[RD2:%rd[0-9]+]], [foo_St8x2_param_0+8]; ; CHECK: ld.param.u64 [[RD2:%rd[0-9]+]], [foo_St8x2_param_0+8];
; CHECK: st.u64 [[[R1]]+8], [[RD2]]; ; CHECK: st.u64 [[[R1]]+8], [[RD2]];
; CHECK: ret; ; CHECK: ret;
%arrayidx = getelementptr inbounds %struct.St8x2, %struct.St8x2* %in, i64 0, i32 0, i64 0 %1 = load i64, ptr %in, align 8
%1 = load i64, i64* %arrayidx, align 8 store i64 %1, ptr %ret, align 8
%arrayidx3 = getelementptr inbounds %struct.St8x2, %struct.St8x2* %ret, i64 0, i32 0, i64 0 %arrayidx.1 = getelementptr inbounds [2 x i64], ptr %in, i64 0, i64 1
store i64 %1, i64* %arrayidx3, align 8 %2 = load i64, ptr %arrayidx.1, align 8
%arrayidx.1 = getelementptr inbounds %struct.St8x2, %struct.St8x2* %in, i64 0, i32 0, i64 1 %arrayidx3.1 = getelementptr inbounds [2 x i64], ptr %ret, i64 0, i64 1
%2 = load i64, i64* %arrayidx.1, align 8 store i64 %2, ptr %arrayidx3.1, align 8
%arrayidx3.1 = getelementptr inbounds %struct.St8x2, %struct.St8x2* %ret, i64 0, i32 0, i64 1
store i64 %2, i64* %arrayidx3.1, align 8
ret void ret void
} }
define dso_local void @foo_St8x3(%struct.St8x3* nocapture noundef readonly byval(%struct.St8x3) align 8 %in, %struct.St8x3* nocapture noundef writeonly %ret) { define dso_local void @foo_St8x3(ptr nocapture noundef readonly byval(%struct.St8x3) align 8 %in, ptr nocapture noundef writeonly %ret) {
; CHECK-LABEL: .visible .func foo_St8x3( ; CHECK-LABEL: .visible .func foo_St8x3(
; CHECK: .param .align 8 .b8 foo_St8x3_param_0[24], ; CHECK: .param .align 8 .b8 foo_St8x3_param_0[24],
; CHECK: .param .b32 foo_St8x3_param_1 ; CHECK: .param .b32 foo_St8x3_param_1
; CHECK: ) ; CHECK: )
; CHECK: ld.param.u32 [[R1:%r[0-9]+]], [foo_St8x3_param_1]; ; CHECK: ld.param.u32 [[R1:%r[0-9]+]], [foo_St8x3_param_1];
; CHECK: ld.param.u64 [[RD1:%rd[0-9]+]], [foo_St8x3_param_0]; ; CHECK: ld.param.u64 [[RD1:%rd[0-9]+]], [foo_St8x3_param_0];
; CHECK: st.u64 [[[R1]]], [[RD1]]; ; CHECK: st.u64 [[[R1]]], [[RD1]];
; CHECK: ld.param.u64 [[RD2:%rd[0-9]+]], [foo_St8x3_param_0+8]; ; CHECK: ld.param.u64 [[RD2:%rd[0-9]+]], [foo_St8x3_param_0+8];
; CHECK: st.u64 [[[R1]]+8], [[RD2]]; ; CHECK: st.u64 [[[R1]]+8], [[RD2]];
; CHECK: ld.param.u64 [[RD3:%rd[0-9]+]], [foo_St8x3_param_0+16]; ; CHECK: ld.param.u64 [[RD3:%rd[0-9]+]], [foo_St8x3_param_0+16];
; CHECK: st.u64 [[[R1]]+16], [[RD3]]; ; CHECK: st.u64 [[[R1]]+16], [[RD3]];
; CHECK: ret; ; CHECK: ret;
%arrayidx = getelementptr inbounds %struct.St8x3, %struct.St8x3* %in, i64 0, i32 0, i64 0 %1 = load i64, ptr %in, align 8
%1 = load i64, i64* %arrayidx, align 8 store i64 %1, ptr %ret, align 8
%arrayidx3 = getelementptr inbounds %struct.St8x3, %struct.St8x3* %ret, i64 0, i32 0, i64 0 %arrayidx.1 = getelementptr inbounds [3 x i64], ptr %in, i64 0, i64 1
store i64 %1, i64* %arrayidx3, align 8 %2 = load i64, ptr %arrayidx.1, align 8
%arrayidx.1 = getelementptr inbounds %struct.St8x3, %struct.St8x3* %in, i64 0, i32 0, i64 1 %arrayidx3.1 = getelementptr inbounds [3 x i64], ptr %ret, i64 0, i64 1
%2 = load i64, i64* %arrayidx.1, align 8 store i64 %2, ptr %arrayidx3.1, align 8
%arrayidx3.1 = getelementptr inbounds %struct.St8x3, %struct.St8x3* %ret, i64 0, i32 0, i64 1 %arrayidx.2 = getelementptr inbounds [3 x i64], ptr %in, i64 0, i64 2
store i64 %2, i64* %arrayidx3.1, align 8 %3 = load i64, ptr %arrayidx.2, align 8
%arrayidx.2 = getelementptr inbounds %struct.St8x3, %struct.St8x3* %in, i64 0, i32 0, i64 2 %arrayidx3.2 = getelementptr inbounds [3 x i64], ptr %ret, i64 0, i64 2
%3 = load i64, i64* %arrayidx.2, align 8 store i64 %3, ptr %arrayidx3.2, align 8
%arrayidx3.2 = getelementptr inbounds %struct.St8x3, %struct.St8x3* %ret, i64 0, i32 0, i64 2
store i64 %3, i64* %arrayidx3.2, align 8
ret void ret void
} }
define dso_local void @foo_St8x4(%struct.St8x4* nocapture noundef readonly byval(%struct.St8x4) align 8 %in, %struct.St8x4* nocapture noundef writeonly %ret) { define dso_local void @foo_St8x4(ptr nocapture noundef readonly byval(%struct.St8x4) align 8 %in, ptr nocapture noundef writeonly %ret) {
; CHECK-LABEL: .visible .func foo_St8x4( ; CHECK-LABEL: .visible .func foo_St8x4(
; CHECK: .param .align 8 .b8 foo_St8x4_param_0[32], ; CHECK: .param .align 8 .b8 foo_St8x4_param_0[32],
; CHECK: .param .b32 foo_St8x4_param_1 ; CHECK: .param .b32 foo_St8x4_param_1
; CHECK: ) ; CHECK: )
; CHECK: ld.param.u32 [[R1:%r[0-9]+]], [foo_St8x4_param_1]; ; CHECK: ld.param.u32 [[R1:%r[0-9]+]], [foo_St8x4_param_1];
; CHECK: ld.param.u64 [[RD1:%rd[0-9]+]], [foo_St8x4_param_0]; ; CHECK: ld.param.u64 [[RD1:%rd[0-9]+]], [foo_St8x4_param_0];
; CHECK: st.u64 [[[R1]]], [[RD1]]; ; CHECK: st.u64 [[[R1]]], [[RD1]];
; CHECK: ld.param.u64 [[RD2:%rd[0-9]+]], [foo_St8x4_param_0+8]; ; CHECK: ld.param.u64 [[RD2:%rd[0-9]+]], [foo_St8x4_param_0+8];
; CHECK: st.u64 [[[R1]]+8], [[RD2]]; ; CHECK: st.u64 [[[R1]]+8], [[RD2]];
; CHECK: ld.param.u64 [[RD3:%rd[0-9]+]], [foo_St8x4_param_0+16]; ; CHECK: ld.param.u64 [[RD3:%rd[0-9]+]], [foo_St8x4_param_0+16];
; CHECK: st.u64 [[[R1]]+16], [[RD3]]; ; CHECK: st.u64 [[[R1]]+16], [[RD3]];
; CHECK: ld.param.u64 [[RD4:%rd[0-9]+]], [foo_St8x4_param_0+24]; ; CHECK: ld.param.u64 [[RD4:%rd[0-9]+]], [foo_St8x4_param_0+24];
; CHECK: st.u64 [[[R1]]+24], [[RD4]]; ; CHECK: st.u64 [[[R1]]+24], [[RD4]];
; CHECK: ret; ; CHECK: ret;
%arrayidx = getelementptr inbounds %struct.St8x4, %struct.St8x4* %in, i64 0, i32 0, i64 0 %1 = load i64, ptr %in, align 8
%1 = load i64, i64* %arrayidx, align 8 store i64 %1, ptr %ret, align 8
%arrayidx3 = getelementptr inbounds %struct.St8x4, %struct.St8x4* %ret, i64 0, i32 0, i64 0 %arrayidx.1 = getelementptr inbounds [4 x i64], ptr %in, i64 0, i64 1
store i64 %1, i64* %arrayidx3, align 8 %2 = load i64, ptr %arrayidx.1, align 8
%arrayidx.1 = getelementptr inbounds %struct.St8x4, %struct.St8x4* %in, i64 0, i32 0, i64 1 %arrayidx3.1 = getelementptr inbounds [4 x i64], ptr %ret, i64 0, i64 1
%2 = load i64, i64* %arrayidx.1, align 8 store i64 %2, ptr %arrayidx3.1, align 8
%arrayidx3.1 = getelementptr inbounds %struct.St8x4, %struct.St8x4* %ret, i64 0, i32 0, i64 1 %arrayidx.2 = getelementptr inbounds [4 x i64], ptr %in, i64 0, i64 2
store i64 %2, i64* %arrayidx3.1, align 8 %3 = load i64, ptr %arrayidx.2, align 8
%arrayidx.2 = getelementptr inbounds %struct.St8x4, %struct.St8x4* %in, i64 0, i32 0, i64 2 %arrayidx3.2 = getelementptr inbounds [4 x i64], ptr %ret, i64 0, i64 2
%3 = load i64, i64* %arrayidx.2, align 8 store i64 %3, ptr %arrayidx3.2, align 8
%arrayidx3.2 = getelementptr inbounds %struct.St8x4, %struct.St8x4* %ret, i64 0, i32 0, i64 2 %arrayidx.3 = getelementptr inbounds [4 x i64], ptr %in, i64 0, i64 3
store i64 %3, i64* %arrayidx3.2, align 8 %4 = load i64, ptr %arrayidx.3, align 8
%arrayidx.3 = getelementptr inbounds %struct.St8x4, %struct.St8x4* %in, i64 0, i32 0, i64 3 %arrayidx3.3 = getelementptr inbounds [4 x i64], ptr %ret, i64 0, i64 3
%4 = load i64, i64* %arrayidx.3, align 8 store i64 %4, ptr %arrayidx3.3, align 8
%arrayidx3.3 = getelementptr inbounds %struct.St8x4, %struct.St8x4* %ret, i64 0, i32 0, i64 3
store i64 %4, i64* %arrayidx3.3, align 8
ret void ret void
} }