1188 lines · plain
1; Verifies correctness of load/store of parameters and return values.2; RUN: llc < %s -mtriple=nvptx64 -mcpu=sm_35 -O0 -verify-machineinstrs | FileCheck -allow-deprecated-dag-overlap %s3; RUN: %if ptxas %{ llc < %s -mtriple=nvptx64 -mcpu=sm_35 -O0 -verify-machineinstrs | %ptxas-verify %}4 5%s_i1 = type { i1 }6%s_i8 = type { i8 }7%s_i16 = type { i16 }8%s_f16 = type { half }9%s_i32 = type { i32 }10%s_f32 = type { float }11%s_i64 = type { i64 }12%s_f64 = type { double }13 14; More complicated types. i64 is used to increase natural alignment15; requirement for the type.16%s_i32x4 = type { i32, i32, i32, i32, i64}17%s_i32f32 = type { i32, float, i32, float, i64}18%s_i8i32x4 = type { i32, i32, i8, i32, i32, i64}19%s_i8i32x4p = type <{ i32, i32, i8, i32, i32, i64}>20%s_crossfield = type { i32, [2 x i32], <4 x i32>, [3 x {i32, i32, i32}]}21; All scalar parameters must be at least 32 bits in size.22; i1 is loaded/stored as i8.23 24; CHECK: .func (.param .b32 func_retval0)25; CHECK-LABEL: test_i1(26; CHECK-NEXT: .param .b32 test_i1_param_027; CHECK: ld.param.b8 [[A8:%rs[0-9]+]], [test_i1_param_0];28; CHECK: and.b16 [[A:%rs[0-9]+]], [[A8]], 1;29; CHECK: setp.ne.b16 %p1, [[A]], 030; CHECK-DAG: .param .b32 param0;31; CHECK-DAG: .param .b32 retval0;32; CHECK: cvt.u32.u16 [[B:%r[0-9]+]], [[A8]]33; CHECK-DAG: st.param.b32 [param0], [[B]]34; CHECK: call.uni (retval0), test_i1,35; CHECK: ld.param.b32 [[R8:%r[0-9]+]], [retval0];36; CHECK: st.param.b32 [func_retval0], [[R8]];37; CHECK: ret;38define i1 @test_i1(i1 %a) {39 %r = tail call i1 @test_i1(i1 %a);40 ret i1 %r;41}42 43; Signed i1 is a somewhat special case. We only care about one bit and44; then us neg.s32 to convert it to 32-bit -1 if it's set.45; CHECK: .func (.param .b32 func_retval0)46; CHECK-LABEL: test_i1s(47; CHECK-NEXT: .param .b32 test_i1s_param_048; CHECK: ld.param.b8 [[A8:%rs[0-9]+]], [test_i1s_param_0];49; CHECK: cvt.u32.u16 [[A32:%r[0-9]+]], [[A8]];50; CHECK: .param .b32 param0;51; CHECK: .param .b32 retval0;52; CHECK: and.b32 [[A1:%r[0-9]+]], [[A32]], 1;53; CHECK: neg.s32 [[A:%r[0-9]+]], [[A1]];54; CHECK: st.param.b32 [param0], [[A]];55; CHECK: call.uni56; CHECK: ld.param.b32 [[R8:%r[0-9]+]], [retval0];57; CHECK: and.b32 [[R1:%r[0-9]+]], [[R8]], 1;58; CHECK: neg.s32 [[R:%r[0-9]+]], [[R1]];59; CHECK: st.param.b32 [func_retval0], [[R]];60; CHECK-NEXT: ret;61define signext i1 @test_i1s(i1 signext %a) {62 %r = tail call signext i1 @test_i1s(i1 signext %a);63 ret i1 %r;64}65 66; Make sure that i1 loads are vectorized as i8 loads, respecting each element alignment.67; CHECK: .func (.param .align 1 .b8 func_retval0[1])68; CHECK-LABEL: test_v3i1(69; CHECK-NEXT: .param .align 1 .b8 test_v3i1_param_0[1]70; CHECK-DAG: ld.param.b8 [[E2:%rs[0-9]+]], [test_v3i1_param_0+2];71; CHECK-DAG: ld.param.b8 [[E0:%rs[0-9]+]], [test_v3i1_param_0]72; CHECK: .param .align 1 .b8 param0[1];73; CHECK: .param .align 1 .b8 retval0[1];74; CHECK-DAG: st.param.b8 [param0], [[E0]];75; CHECK-DAG: st.param.b8 [param0+2], [[E2]];76; CHECK: call.uni (retval0), test_v3i1,77; CHECK-DAG: ld.param.b8 [[RE0:%rs[0-9]+]], [retval0];78; CHECK-DAG: ld.param.b8 [[RE2:%rs[0-9]+]], [retval0+2];79; CHECK-DAG: st.param.b8 [func_retval0], [[RE0]]80; CHECK-DAG: st.param.b8 [func_retval0+2], [[RE2]];81; CHECK-NEXT: ret;82define <3 x i1> @test_v3i1(<3 x i1> %a) {83 %r = tail call <3 x i1> @test_v3i1(<3 x i1> %a);84 ret <3 x i1> %r;85}86 87; CHECK: .func (.param .align 1 .b8 func_retval0[1])88; CHECK-LABEL: test_v4i1(89; CHECK-NEXT: .param .align 1 .b8 test_v4i1_param_0[1]90; CHECK: ld.param.b8 [[E0:%rs[0-9]+]], [test_v4i1_param_0]91; CHECK: .param .align 1 .b8 param0[1];92; CHECK: .param .align 1 .b8 retval0[1];93; CHECK: st.param.b8 [param0], [[E0]];94; CHECK: call.uni (retval0), test_v4i1,95; CHECK: ld.param.b8 [[RE0:%rs[0-9]+]], [retval0];96; CHECK: ld.param.b8 [[RE1:%rs[0-9]+]], [retval0+1];97; CHECK: ld.param.b8 [[RE2:%rs[0-9]+]], [retval0+2];98; CHECK: ld.param.b8 [[RE3:%rs[0-9]+]], [retval0+3];99; CHECK: st.param.b8 [func_retval0], [[RE0]];100; CHECK: st.param.b8 [func_retval0+1], [[RE1]];101; CHECK: st.param.b8 [func_retval0+2], [[RE2]];102; CHECK: st.param.b8 [func_retval0+3], [[RE3]];103; CHECK-NEXT: ret;104define <4 x i1> @test_v4i1(<4 x i1> %a) {105 %r = tail call <4 x i1> @test_v4i1(<4 x i1> %a);106 ret <4 x i1> %r;107}108 109; CHECK: .func (.param .align 1 .b8 func_retval0[1])110; CHECK-LABEL: test_v5i1(111; CHECK-NEXT: .param .align 1 .b8 test_v5i1_param_0[1]112; CHECK-DAG: ld.param.b8 [[E4:%rs[0-9]+]], [test_v5i1_param_0+4];113; CHECK-DAG: ld.param.b8 [[E0:%rs[0-9]+]], [test_v5i1_param_0]114; CHECK: .param .align 1 .b8 param0[1];115; CHECK: .param .align 1 .b8 retval0[1];116; CHECK-DAG: st.param.b8 [param0], [[E0]];117; CHECK-DAG: st.param.b8 [param0+4], [[E4]];118; CHECK: call.uni (retval0), test_v5i1,119; CHECK-DAG: ld.param.b8 [[RE0:%rs[0-9]+]], [retval0];120; CHECK-DAG: ld.param.b8 [[RE4:%rs[0-9]+]], [retval0+4];121; CHECK-DAG: st.param.b8 [func_retval0], [[RE0]]122; CHECK-DAG: st.param.b8 [func_retval0+4], [[RE4]];123; CHECK-NEXT: ret;124define <5 x i1> @test_v5i1(<5 x i1> %a) {125 %r = tail call <5 x i1> @test_v5i1(<5 x i1> %a);126 ret <5 x i1> %r;127}128 129; CHECK: .func (.param .b32 func_retval0)130; CHECK-LABEL: test_i2(131; CHECK-NEXT: .param .b32 test_i2_param_0132; CHECK: ld.param.b8 {{%rs[0-9]+}}, [test_i2_param_0];133; CHECK: .param .b32 param0;134; CHECK: .param .b32 retval0;135; CHECK: st.param.b32 [param0], {{%r[0-9]+}};136; CHECK: call.uni (retval0), test_i2,137; CHECK: ld.param.b32 {{%r[0-9]+}}, [retval0];138; CHECK: st.param.b32 [func_retval0], {{%r[0-9]+}};139; CHECK-NEXT: ret;140define i2 @test_i2(i2 %a) {141 %r = tail call i2 @test_i2(i2 %a);142 ret i2 %r;143}144 145; CHECK: .func (.param .b32 func_retval0)146; CHECK-LABEL: test_i3(147; CHECK-NEXT: .param .b32 test_i3_param_0148; CHECK: ld.param.b8 {{%rs[0-9]+}}, [test_i3_param_0];149; CHECK: .param .b32 param0;150; CHECK: .param .b32 retval0;151; CHECK: st.param.b32 [param0], {{%r[0-9]+}};152; CHECK: call.uni (retval0), test_i3,153; CHECK: ld.param.b32 {{%r[0-9]+}}, [retval0];154; CHECK: st.param.b32 [func_retval0], {{%r[0-9]+}};155; CHECK-NEXT: ret;156define i3 @test_i3(i3 %a) {157 %r = tail call i3 @test_i3(i3 %a);158 ret i3 %r;159}160 161; Unsigned i8 is loaded directly into 32-bit register.162; CHECK: .func (.param .b32 func_retval0)163; CHECK-LABEL: test_i8(164; CHECK-NEXT: .param .b32 test_i8_param_0165; CHECK: ld.param.b8 [[A8:%rs[0-9]+]], [test_i8_param_0];166; CHECK: .param .b32 param0;167; CHECK: .param .b32 retval0;168; CHECK: cvt.u32.u16 [[A32:%r[0-9]+]], [[A8]];169; CHECK: st.param.b32 [param0], [[A32]];170; CHECK: call.uni (retval0), test_i8,171; CHECK: ld.param.b32 [[R32:%r[0-9]+]], [retval0];172; CHECK: st.param.b32 [func_retval0], [[R32]];173; CHECK-NEXT: ret;174define i8 @test_i8(i8 %a) {175 %r = tail call i8 @test_i8(i8 %a);176 ret i8 %r;177}178 179; signed i8 is loaded into 16-bit register which is then sign-extended to i32.180; CHECK: .func (.param .b32 func_retval0)181; CHECK-LABEL: test_i8s(182; CHECK-NEXT: .param .b32 test_i8s_param_0183; CHECK: ld.param.s8 [[A8:%rs[0-9]+]], [test_i8s_param_0];184; CHECK: .param .b32 param0;185; CHECK: .param .b32 retval0;186; CHECK: cvt.s32.s16 [[A:%r[0-9]+]], [[A8]];187; CHECK: st.param.b32 [param0], [[A]];188; CHECK: call.uni (retval0), test_i8s,189; CHECK: ld.param.b32 [[R32:%r[0-9]+]], [retval0];190; -- This is suspicious (though correct) -- why not cvt.u8.u32, cvt.s8.s32 ?191; CHECK: cvt.u16.u32 [[R16:%rs[0-9]+]], [[R32]];192; CHECK: cvt.s32.s16 [[R:%r[0-9]+]], [[R16]];193; CHECK: st.param.b32 [func_retval0], [[R]];194; CHECK-NEXT: ret;195define signext i8 @test_i8s(i8 signext %a) {196 %r = tail call signext i8 @test_i8s(i8 signext %a);197 ret i8 %r;198}199 200; CHECK: .func (.param .align 4 .b8 func_retval0[4])201; CHECK-LABEL: test_v3i8(202; CHECK-NEXT: .param .align 4 .b8 test_v3i8_param_0[4]203; CHECK: ld.param.b32 [[R:%r[0-9]+]], [test_v3i8_param_0];204; CHECK: .param .align 4 .b8 param0[4];205; CHECK: .param .align 4 .b8 retval0[4];206; CHECK: st.param.b32 [param0], [[R]]207; CHECK: call.uni (retval0), test_v3i8,208; CHECK: ld.param.b32 [[RE:%r[0-9]+]], [retval0];209; v4i8/i32->{v3i8 elements}->v4i8/i32 conversion is messy and not very210; interesting here, so it's skipped.211; CHECK: st.param.b32 [func_retval0],212; CHECK-NEXT: ret;213define <3 x i8> @test_v3i8(<3 x i8> %a) {214 %r = tail call <3 x i8> @test_v3i8(<3 x i8> %a);215 ret <3 x i8> %r;216}217 218; CHECK: .func (.param .align 4 .b8 func_retval0[4])219; CHECK-LABEL: test_v4i8(220; CHECK-NEXT: .param .align 4 .b8 test_v4i8_param_0[4]221; CHECK: ld.param.b32 [[R:%r[0-9]+]], [test_v4i8_param_0]222; CHECK: .param .align 4 .b8 param0[4];223; CHECK: .param .align 4 .b8 retval0[4];224; CHECK: st.param.b32 [param0], [[R]];225; CHECK: call.uni (retval0), test_v4i8,226; CHECK: ld.param.b32 [[RET:%r[0-9]+]], [retval0];227; CHECK: st.param.b32 [func_retval0], [[RET]];228; CHECK-NEXT: ret;229define <4 x i8> @test_v4i8(<4 x i8> %a) {230 %r = tail call <4 x i8> @test_v4i8(<4 x i8> %a);231 ret <4 x i8> %r;232}233 234; CHECK: .func (.param .align 8 .b8 func_retval0[8])235; CHECK-LABEL: test_v5i8(236; CHECK-NEXT: .param .align 8 .b8 test_v5i8_param_0[8]237; CHECK-DAG: ld.param.b32 [[E0:%r[0-9]+]], [test_v5i8_param_0]238; CHECK-DAG: ld.param.b8 [[E4:%rs[0-9]+]], [test_v5i8_param_0+4];239; CHECK: .param .align 8 .b8 param0[8];240; CHECK: .param .align 8 .b8 retval0[8];241; CHECK-DAG: st.param.b32 [param0], [[E0]];242; CHECK-DAG: st.param.b8 [param0+4], [[E4]];243; CHECK: call.uni (retval0), test_v5i8,244; CHECK-DAG: ld.param.b32 [[RE0:%r[0-9]+]], [retval0];245; CHECK-DAG: ld.param.b8 [[RE4:%rs[0-9]+]], [retval0+4];246; CHECK-DAG: st.param.b32 [func_retval0], [[RE0]];247; CHECK-DAG: st.param.b8 [func_retval0+4], [[RE4]];248; CHECK-NEXT: ret;249define <5 x i8> @test_v5i8(<5 x i8> %a) {250 %r = tail call <5 x i8> @test_v5i8(<5 x i8> %a);251 ret <5 x i8> %r;252}253 254; CHECK: .func (.param .b32 func_retval0)255; CHECK-LABEL: test_i11(256; CHECK-NEXT: .param .b32 test_i11_param_0257; CHECK: ld.param.b16 {{%rs[0-9]+}}, [test_i11_param_0];258; CHECK: .param .b32 retval0;259; CHECK: st.param.b32 [param0], {{%r[0-9]+}};260; CHECK: call.uni (retval0), test_i11,261; CHECK: ld.param.b32 {{%r[0-9]+}}, [retval0];262; CHECK: st.param.b32 [func_retval0], {{%r[0-9]+}};263; CHECK-NEXT: ret;264define i11 @test_i11(i11 %a) {265 %r = tail call i11 @test_i11(i11 %a);266 ret i11 %r;267}268 269; CHECK: .func (.param .b32 func_retval0)270; CHECK-LABEL: test_i16(271; CHECK-NEXT: .param .b32 test_i16_param_0272; CHECK: ld.param.b16 [[E16:%rs[0-9]+]], [test_i16_param_0];273; CHECK: .param .b32 param0;274; CHECK: .param .b32 retval0;275; CHECK: cvt.u32.u16 [[E32:%r[0-9]+]], [[E16]];276; CHECK: st.param.b32 [param0], [[E32]];277; CHECK: call.uni (retval0), test_i16,278; CHECK: ld.param.b32 [[RE32:%r[0-9]+]], [retval0];279; CHECK: st.param.b32 [func_retval0], [[RE32]];280; CHECK-NEXT: ret;281define i16 @test_i16(i16 %a) {282 %r = tail call i16 @test_i16(i16 %a);283 ret i16 %r;284}285 286; CHECK: .func (.param .b32 func_retval0)287; CHECK-LABEL: test_i16s(288; CHECK-NEXT: .param .b32 test_i16s_param_0289; CHECK: ld.param.b16 [[E16:%rs[0-9]+]], [test_i16s_param_0];290; CHECK: .param .b32 param0;291; CHECK: .param .b32 retval0;292; CHECK: cvt.s32.s16 [[E32:%r[0-9]+]], [[E16]];293; CHECK: st.param.b32 [param0], [[E32]];294; CHECK: call.uni (retval0), test_i16s,295; CHECK: ld.param.b32 [[RE32:%r[0-9]+]], [retval0];296; CHECK: cvt.s32.s16 [[R:%r[0-9]+]], [[RE32]];297; CHECK: st.param.b32 [func_retval0], [[R]];298; CHECK-NEXT: ret;299define signext i16 @test_i16s(i16 signext %a) {300 %r = tail call signext i16 @test_i16s(i16 signext %a);301 ret i16 %r;302}303 304; CHECK: .func (.param .align 8 .b8 func_retval0[8])305; CHECK-LABEL: test_v3i16(306; CHECK-NEXT: .param .align 8 .b8 test_v3i16_param_0[8]307; CHECK-DAG: ld.param.b16 [[E2:%rs[0-9]+]], [test_v3i16_param_0+4];308; CHECK-DAG: ld.param.b32 [[E0:%r[0-9]+]], [test_v3i16_param_0];309; CHECK: .param .align 8 .b8 param0[8];310; CHECK: .param .align 8 .b8 retval0[8];311; CHECK-DAG: st.param.b32 [param0], [[E0]];312; CHECK-DAG: st.param.b16 [param0+4], [[E2]];313; CHECK: call.uni (retval0), test_v3i16,314; CHECK: ld.param.b32 [[RE:%r[0-9]+]], [retval0];315; CHECK: ld.param.b16 [[RE2:%rs[0-9]+]], [retval0+4];316; CHECK-DAG: mov.b32 {[[RE0:%rs[0-9]+]], [[RE1:%rs[0-9]+]]}, [[RE]];317; CHECK-DAG: st.param.v2.b16 [func_retval0], {[[RE0]], [[RE1]]};318; CHECK-DAG: st.param.b16 [func_retval0+4], [[RE2]];319; CHECK-NEXT: ret;320define <3 x i16> @test_v3i16(<3 x i16> %a) {321 %r = tail call <3 x i16> @test_v3i16(<3 x i16> %a);322 ret <3 x i16> %r;323}324 325; CHECK: .func (.param .align 8 .b8 func_retval0[8])326; CHECK-LABEL: test_v4i16(327; CHECK-NEXT: .param .align 8 .b8 test_v4i16_param_0[8]328; CHECK: ld.param.v2.b32 {[[E0:%r[0-9]+]], [[E1:%r[0-9]+]]}, [test_v4i16_param_0]329; CHECK: .param .align 8 .b8 param0[8];330; CHECK: .param .align 8 .b8 retval0[8];331; CHECK: st.param.v2.b32 [param0], {[[E0]], [[E1]]};332; CHECK: call.uni (retval0), test_v4i16,333; CHECK: ld.param.v2.b32 {[[RE0:%r[0-9]+]], [[RE1:%r[0-9]+]]}, [retval0];334; CHECK: st.param.v2.b32 [func_retval0], {[[RE0]], [[RE1]]}335; CHECK-NEXT: ret;336define <4 x i16> @test_v4i16(<4 x i16> %a) {337 %r = tail call <4 x i16> @test_v4i16(<4 x i16> %a);338 ret <4 x i16> %r;339}340 341; CHECK: .func (.param .align 16 .b8 func_retval0[16])342; CHECK-LABEL: test_v5i16(343; CHECK-NEXT: .param .align 16 .b8 test_v5i16_param_0[16]344; CHECK-DAG: ld.param.b16 [[E4:%rs[0-9]+]], [test_v5i16_param_0+8];345; CHECK-DAG: ld.param.v2.b32 {[[E0:%r[0-9]+]], [[E1:%r[0-9]+]]}, [test_v5i16_param_0]346; CHECK: .param .align 16 .b8 param0[16];347; CHECK: .param .align 16 .b8 retval0[16];348; CHECK-DAG: st.param.v2.b32 [param0], {[[E0]], [[E1]]};349; CHECK-DAG: st.param.b16 [param0+8], [[E4]];350; CHECK: call.uni (retval0), test_v5i16,351; CHECK-DAG: ld.param.v2.b32 {[[RE0:%r[0-9]+]], [[RE1:%r[0-9]+]]}, [retval0];352; CHECK-DAG: ld.param.b16 [[RE4:%rs[0-9]+]], [retval0+8];353; CHECK-DAG: st.param.v2.b32 [func_retval0], {[[RE0]], [[RE1]]}354; CHECK-DAG: st.param.b16 [func_retval0+8], [[RE4]];355; CHECK-NEXT: ret;356define <5 x i16> @test_v5i16(<5 x i16> %a) {357 %r = tail call <5 x i16> @test_v5i16(<5 x i16> %a);358 ret <5 x i16> %r;359}360 361; CHECK: .func (.param .align 2 .b8 func_retval0[2])362; CHECK-LABEL: test_f16(363; CHECK-NEXT: .param .align 2 .b8 test_f16_param_0[2]364; CHECK: ld.param.b16 [[E:%rs[0-9]+]], [test_f16_param_0];365; CHECK: .param .align 2 .b8 param0[2];366; CHECK: .param .align 2 .b8 retval0[2];367; CHECK: st.param.b16 [param0], [[E]];368; CHECK: call.uni (retval0), test_f16,369; CHECK: ld.param.b16 [[R:%rs[0-9]+]], [retval0];370; CHECK: st.param.b16 [func_retval0], [[R]]371; CHECK-NEXT: ret;372define half @test_f16(half %a) {373 %r = tail call half @test_f16(half %a);374 ret half %r;375}376 377; CHECK: .func (.param .align 4 .b8 func_retval0[4])378; CHECK-LABEL: test_v2f16(379; CHECK-NEXT: .param .align 4 .b8 test_v2f16_param_0[4]380; CHECK: ld.param.b32 [[E:%r[0-9]+]], [test_v2f16_param_0];381; CHECK: .param .align 4 .b8 param0[4];382; CHECK: .param .align 4 .b8 retval0[4];383; CHECK: st.param.b32 [param0], [[E]];384; CHECK: call.uni (retval0), test_v2f16,385; CHECK: ld.param.b32 [[R:%r[0-9]+]], [retval0];386; CHECK: st.param.b32 [func_retval0], [[R]]387; CHECK-NEXT: ret;388define <2 x half> @test_v2f16(<2 x half> %a) {389 %r = tail call <2 x half> @test_v2f16(<2 x half> %a);390 ret <2 x half> %r;391}392 393; CHECK: .func (.param .align 2 .b8 func_retval0[2])394; CHECK-LABEL: test_bf16(395; CHECK-NEXT: .param .align 2 .b8 test_bf16_param_0[2]396; CHECK: ld.param.b16 [[E:%rs[0-9]+]], [test_bf16_param_0];397; CHECK: .param .align 2 .b8 param0[2];398; CHECK: .param .align 2 .b8 retval0[2];399; CHECK: st.param.b16 [param0], [[E]];400; CHECK: call.uni (retval0), test_bf16,401; CHECK: ld.param.b16 [[R:%rs[0-9]+]], [retval0];402; CHECK: st.param.b16 [func_retval0], [[R]]403; CHECK-NEXT: ret;404define bfloat @test_bf16(bfloat %a) {405 %r = tail call bfloat @test_bf16(bfloat %a);406 ret bfloat %r;407}408 409; CHECK: .func (.param .align 4 .b8 func_retval0[4])410; CHECK-LABEL: test_v2bf16(411; CHECK-NEXT: .param .align 4 .b8 test_v2bf16_param_0[4]412; CHECK: ld.param.b32 [[E:%r[0-9]+]], [test_v2bf16_param_0];413; CHECK: .param .align 4 .b8 param0[4];414; CHECK: .param .align 4 .b8 retval0[4];415; CHECK: st.param.b32 [param0], [[E]];416; CHECK: call.uni (retval0), test_v2bf16,417; CHECK: ld.param.b32 [[R:%r[0-9]+]], [retval0];418; CHECK: st.param.b32 [func_retval0], [[R]]419; CHECK-NEXT: ret;420define <2 x bfloat> @test_v2bf16(<2 x bfloat> %a) {421 %r = tail call <2 x bfloat> @test_v2bf16(<2 x bfloat> %a);422 ret <2 x bfloat> %r;423}424 425 426; CHECK:.func (.param .align 8 .b8 func_retval0[8])427; CHECK-LABEL: test_v3f16(428; CHECK: .param .align 8 .b8 test_v3f16_param_0[8]429; CHECK-DAG: ld.param.b32 [[E0:%r[0-9]+]], [test_v3f16_param_0];430; CHECK-DAG: ld.param.b16 [[E2:%rs[0-9]+]], [test_v3f16_param_0+4];431; CHECK: .param .align 8 .b8 param0[8];432; CHECK: .param .align 8 .b8 retval0[8];433; CHECK-DAG: st.param.b32 [param0], [[E0]];434; CHECK-DAG: st.param.b16 [param0+4], [[E2]];435; CHECK: call.uni (retval0), test_v3f16,436; CHECK-DAG: ld.param.b32 [[R:%r[0-9]+]], [retval0];437; CHECK-DAG: ld.param.b16 [[R2:%rs[0-9]+]], [retval0+4];438; CHECK-DAG: mov.b32 {[[R0:%rs[0-9]+]], [[R1:%rs[0-9]+]]}, [[R]];439; CHECK-DAG: st.param.v2.b16 [func_retval0], {[[R0]], [[R1]]};440; CHECK-DAG: st.param.b16 [func_retval0+4], [[R2]];441; CHECK: ret;442define <3 x half> @test_v3f16(<3 x half> %a) {443 %r = tail call <3 x half> @test_v3f16(<3 x half> %a);444 ret <3 x half> %r;445}446 447; CHECK:.func (.param .align 8 .b8 func_retval0[8])448; CHECK-LABEL: test_v4f16(449; CHECK: .param .align 8 .b8 test_v4f16_param_0[8]450; CHECK: ld.param.v2.b32 {[[R01:%r[0-9]+]], [[R23:%r[0-9]+]]}, [test_v4f16_param_0];451; CHECK: .param .align 8 .b8 param0[8];452; CHECK: .param .align 8 .b8 retval0[8];453; CHECK: st.param.v2.b32 [param0], {[[R01]], [[R23]]};454; CHECK: call.uni (retval0), test_v4f16,455; CHECK: ld.param.v2.b32 {[[RH01:%r[0-9]+]], [[RH23:%r[0-9]+]]}, [retval0];456; CHECK: st.param.v2.b32 [func_retval0], {[[RH01]], [[RH23]]};457; CHECK: ret;458define <4 x half> @test_v4f16(<4 x half> %a) {459 %r = tail call <4 x half> @test_v4f16(<4 x half> %a);460 ret <4 x half> %r;461}462 463; CHECK:.func (.param .align 16 .b8 func_retval0[16])464; CHECK-LABEL: test_v5f16(465; CHECK: .param .align 16 .b8 test_v5f16_param_0[16]466; CHECK-DAG: ld.param.v2.b32 {[[E0:%r[0-9]+]], [[E1:%r[0-9]+]]}, [test_v5f16_param_0];467; CHECK-DAG: ld.param.b16 [[E4:%rs[0-9]+]], [test_v5f16_param_0+8];468; CHECK: .param .align 16 .b8 param0[16];469; CHECK: .param .align 16 .b8 retval0[16];470; CHECK-DAG: st.param.v2.b32 [param0], {[[E0]], [[E1]]};471; CHECK-DAG: st.param.b16 [param0+8], [[E4]];472; CHECK: call.uni (retval0), test_v5f16,473; CHECK-DAG: ld.param.v2.b32 {[[R0:%r[0-9]+]], [[R1:%r[0-9]+]]}, [retval0];474; CHECK-DAG: ld.param.b16 [[R4:%rs[0-9]+]], [retval0+8];475; CHECK-DAG: st.param.v2.b32 [func_retval0], {[[R0]], [[R1]]};476; CHECK-DAG: st.param.b16 [func_retval0+8], [[R4]];477; CHECK: ret;478define <5 x half> @test_v5f16(<5 x half> %a) {479 %r = tail call <5 x half> @test_v5f16(<5 x half> %a);480 ret <5 x half> %r;481}482 483; CHECK:.func (.param .align 16 .b8 func_retval0[16])484; CHECK-LABEL: test_v8f16(485; CHECK: .param .align 16 .b8 test_v8f16_param_0[16]486; CHECK: ld.param.v4.b32 {[[R01:%r[0-9]+]], [[R23:%r[0-9]+]], [[R45:%r[0-9]+]], [[R67:%r[0-9]+]]}, [test_v8f16_param_0];487; CHECK: .param .align 16 .b8 param0[16];488; CHECK: .param .align 16 .b8 retval0[16];489; CHECK: st.param.v4.b32 [param0], {[[R01]], [[R23]], [[R45]], [[R67]]};490; CHECK: call.uni (retval0), test_v8f16,491; CHECK: ld.param.v4.b32 {[[RH01:%r[0-9]+]], [[RH23:%r[0-9]+]], [[RH45:%r[0-9]+]], [[RH67:%r[0-9]+]]}, [retval0];492; CHECK: st.param.v4.b32 [func_retval0], {[[RH01]], [[RH23]], [[RH45]], [[RH67]]};493; CHECK: ret;494define <8 x half> @test_v8f16(<8 x half> %a) {495 %r = tail call <8 x half> @test_v8f16(<8 x half> %a);496 ret <8 x half> %r;497}498 499; CHECK:.func (.param .align 32 .b8 func_retval0[32])500; CHECK-LABEL: test_v9f16(501; CHECK: .param .align 32 .b8 test_v9f16_param_0[32]502; CHECK-DAG: ld.param.v2.b32 {[[E0:%r[0-9]+]], [[E1:%r[0-9]+]]}, [test_v9f16_param_0];503; CHECK-DAG: ld.param.v2.b32 {[[E2:%r[0-9]+]], [[E3:%r[0-9]+]]}, [test_v9f16_param_0+8];504; CHECK-DAG: ld.param.b16 [[E8:%rs[0-9]+]], [test_v9f16_param_0+16];505; CHECK: .param .align 32 .b8 param0[32];506; CHECK: .param .align 32 .b8 retval0[32];507; CHECK-DAG: st.param.v2.b32 [param0], {[[E0]], [[E1]]};508; CHECK-DAG: st.param.v2.b32 [param0+8], {[[E2]], [[E3]]};509; CHECK-DAG: st.param.b16 [param0+16], [[E8]];510; CHECK: call.uni (retval0), test_v9f16,511; CHECK-DAG: ld.param.v2.b32 {[[R0:%r[0-9]+]], [[R1:%r[0-9]+]]}, [retval0];512; CHECK-DAG: ld.param.v2.b32 {[[R2:%r[0-9]+]], [[R3:%r[0-9]+]]}, [retval0+8];513; CHECK-DAG: ld.param.b16 [[R8:%rs[0-9]+]], [retval0+16];514; CHECK-DAG: st.param.v2.b32 [func_retval0], {[[R0]], [[R1]]};515; CHECK-DAG: st.param.v2.b32 [func_retval0+8], {[[R2]], [[R3]]};516; CHECK-DAG: st.param.b16 [func_retval0+16], [[R8]];517; CHECK: ret;518define <9 x half> @test_v9f16(<9 x half> %a) {519 %r = tail call <9 x half> @test_v9f16(<9 x half> %a);520 ret <9 x half> %r;521}522 523; CHECK: .func (.param .b32 func_retval0)524; CHECK-LABEL: test_i19(525; CHECK-NEXT: .param .b32 test_i19_param_0526; CHECK: ld.param.b32 {{%r[0-9]+}}, [test_i19_param_0];527; CHECK: .param .b32 param0;528; CHECK: .param .b32 retval0;529; CHECK: st.param.b32 [param0], {{%r[0-9]+}};530; CHECK: call.uni (retval0), test_i19,531; CHECK: ld.param.b32 {{%r[0-9]+}}, [retval0];532; CHECK: st.param.b32 [func_retval0], {{%r[0-9]+}};533; CHECK-NEXT: ret;534define i19 @test_i19(i19 %a) {535 %r = tail call i19 @test_i19(i19 %a);536 ret i19 %r;537}538 539; CHECK: .func (.param .b32 func_retval0)540; CHECK-LABEL: test_i23(541; CHECK-NEXT: .param .b32 test_i23_param_0542; CHECK: ld.param.b32 {{%r[0-9]+}}, [test_i23_param_0];543; CHECK: .param .b32 param0;544; CHECK: .param .b32 retval0;545; CHECK: st.param.b32 [param0], {{%r[0-9]+}};546; CHECK: call.uni (retval0), test_i23,547; CHECK: ld.param.b32 {{%r[0-9]+}}, [retval0];548; CHECK: st.param.b32 [func_retval0], {{%r[0-9]+}};549; CHECK-NEXT: ret;550define i23 @test_i23(i23 %a) {551 %r = tail call i23 @test_i23(i23 %a);552 ret i23 %r;553}554 555; CHECK: .func (.param .b32 func_retval0)556; CHECK-LABEL: test_i24(557; CHECK-NEXT: .param .b32 test_i24_param_0558; CHECK: ld.param.b32 {{%r[0-9]+}}, [test_i24_param_0];559; CHECK: .param .b32 param0;560; CHECK: .param .b32 retval0;561; CHECK: st.param.b32 [param0], {{%r[0-9]+}};562; CHECK: call.uni (retval0), test_i24,563; CHECK: ld.param.b32 {{%r[0-9]+}}, [retval0];564; CHECK: st.param.b32 [func_retval0], {{%r[0-9]+}};565; CHECK-NEXT: ret;566define i24 @test_i24(i24 %a) {567 %r = tail call i24 @test_i24(i24 %a);568 ret i24 %r;569}570 571; CHECK: .func (.param .b32 func_retval0)572; CHECK-LABEL: test_i29(573; CHECK-NEXT: .param .b32 test_i29_param_0574; CHECK: ld.param.b32 {{%r[0-9]+}}, [test_i29_param_0];575; CHECK: .param .b32 param0;576; CHECK: .param .b32 retval0;577; CHECK: st.param.b32 [param0], {{%r[0-9]+}};578; CHECK: call.uni (retval0), test_i29,579; CHECK: ld.param.b32 {{%r[0-9]+}}, [retval0];580; CHECK: st.param.b32 [func_retval0], {{%r[0-9]+}};581; CHECK-NEXT: ret;582define i29 @test_i29(i29 %a) {583 %r = tail call i29 @test_i29(i29 %a);584 ret i29 %r;585}586 587; CHECK: .func (.param .b32 func_retval0)588; CHECK-LABEL: test_i32(589; CHECK-NEXT: .param .b32 test_i32_param_0590; CHECK: ld.param.b32 [[E:%r[0-9]+]], [test_i32_param_0];591; CHECK: .param .b32 param0;592; CHECK: .param .b32 retval0;593; CHECK: st.param.b32 [param0], [[E]];594; CHECK: call.uni (retval0), test_i32,595; CHECK: ld.param.b32 [[R:%r[0-9]+]], [retval0];596; CHECK: st.param.b32 [func_retval0], [[R]];597; CHECK-NEXT: ret;598define i32 @test_i32(i32 %a) {599 %r = tail call i32 @test_i32(i32 %a);600 ret i32 %r;601}602 603; CHECK: .func (.param .align 16 .b8 func_retval0[16])604; CHECK-LABEL: test_v3i32(605; CHECK-NEXT: .param .align 16 .b8 test_v3i32_param_0[16]606; CHECK-DAG: ld.param.b32 [[E2:%r[0-9]+]], [test_v3i32_param_0+8];607; CHECK-DAG: ld.param.v2.b32 {[[E0:%r[0-9]+]], [[E1:%r[0-9]+]]}, [test_v3i32_param_0];608; CHECK-DAG: .param .align 16 .b8 param0[16];609; CHECK-DAG: .param .align 16 .b8 retval0[16];610; CHECK-DAG: st.param.v2.b32 [param0], {[[E0]], [[E1]]};611; CHECK-DAG: st.param.b32 [param0+8], [[E2]];612; CHECK: call.uni (retval0), test_v3i32,613; CHECK: ld.param.v2.b32 {[[RE0:%r[0-9]+]], [[RE1:%r[0-9]+]]}, [retval0];614; CHECK: ld.param.b32 [[RE2:%r[0-9]+]], [retval0+8];615; CHECK-DAG: st.param.v2.b32 [func_retval0], {[[RE0]], [[RE1]]};616; CHECK-DAG: st.param.b32 [func_retval0+8], [[RE2]];617; CHECK-NEXT: ret;618define <3 x i32> @test_v3i32(<3 x i32> %a) {619 %r = tail call <3 x i32> @test_v3i32(<3 x i32> %a);620 ret <3 x i32> %r;621}622 623; CHECK: .func (.param .align 16 .b8 func_retval0[16])624; CHECK-LABEL: test_v4i32(625; CHECK-NEXT: .param .align 16 .b8 test_v4i32_param_0[16]626; CHECK: ld.param.v4.b32 {[[E0:%r[0-9]+]], [[E1:%r[0-9]+]], [[E2:%r[0-9]+]], [[E3:%r[0-9]+]]}, [test_v4i32_param_0]627; CHECK-DAG: .param .align 16 .b8 param0[16];628; CHECK-DAG: .param .align 16 .b8 retval0[16];629; CHECK-DAG: st.param.v4.b32 [param0], {[[E0]], [[E1]], [[E2]], [[E3]]};630; CHECK: call.uni (retval0), test_v4i32,631; CHECK: ld.param.v4.b32 {[[RE0:%r[0-9]+]], [[RE1:%r[0-9]+]], [[RE2:%r[0-9]+]], [[RE3:%r[0-9]+]]}, [retval0];632; CHECK: st.param.v4.b32 [func_retval0], {[[RE0]], [[RE1]], [[RE2]], [[RE3]]}633; CHECK-NEXT: ret;634define <4 x i32> @test_v4i32(<4 x i32> %a) {635 %r = tail call <4 x i32> @test_v4i32(<4 x i32> %a);636 ret <4 x i32> %r;637}638 639; CHECK: .func (.param .align 32 .b8 func_retval0[32])640; CHECK-LABEL: test_v5i32(641; CHECK-NEXT: .param .align 32 .b8 test_v5i32_param_0[32]642; CHECK-DAG: ld.param.b32 [[E4:%r[0-9]+]], [test_v5i32_param_0+16];643; CHECK-DAG: ld.param.v4.b32 {[[E0:%r[0-9]+]], [[E1:%r[0-9]+]], [[E2:%r[0-9]+]], [[E3:%r[0-9]+]]}, [test_v5i32_param_0]644; CHECK: .param .align 32 .b8 param0[32];645; CHECK: .param .align 32 .b8 retval0[32];646; CHECK-DAG: st.param.v4.b32 [param0], {[[E0]], [[E1]], [[E2]], [[E3]]};647; CHECK-DAG: st.param.b32 [param0+16], [[E4]];648; CHECK: call.uni (retval0), test_v5i32,649; CHECK-DAG: ld.param.v4.b32 {[[RE0:%r[0-9]+]], [[RE1:%r[0-9]+]], [[RE2:%r[0-9]+]], [[RE3:%r[0-9]+]]}, [retval0];650; CHECK-DAG: ld.param.b32 [[RE4:%r[0-9]+]], [retval0+16];651; CHECK-DAG: st.param.v4.b32 [func_retval0], {[[RE0]], [[RE1]], [[RE2]], [[RE3]]}652; CHECK-DAG: st.param.b32 [func_retval0+16], [[RE4]];653; CHECK-NEXT: ret;654define <5 x i32> @test_v5i32(<5 x i32> %a) {655 %r = tail call <5 x i32> @test_v5i32(<5 x i32> %a);656 ret <5 x i32> %r;657}658 659; CHECK: .func (.param .b32 func_retval0)660; CHECK-LABEL: test_f32(661; CHECK-NEXT: .param .b32 test_f32_param_0662; CHECK: ld.param.b32 [[E:%r[0-9]+]], [test_f32_param_0];663; CHECK: .param .b32 param0;664; CHECK: .param .b32 retval0;665; CHECK: st.param.b32 [param0], [[E]];666; CHECK: call.uni (retval0), test_f32,667; CHECK: ld.param.b32 [[R:%r[0-9]+]], [retval0];668; CHECK: st.param.b32 [func_retval0], [[R]];669; CHECK-NEXT: ret;670define float @test_f32(float %a) {671 %r = tail call float @test_f32(float %a);672 ret float %r;673}674 675; CHECK: .func (.param .b64 func_retval0)676; CHECK-LABEL: test_i40(677; CHECK-NEXT: .param .b64 test_i40_param_0678; CHECK: ld.param.b64 {{%rd[0-9]+}}, [test_i40_param_0];679; CHECK: .param .b64 param0;680; CHECK: .param .b64 retval0;681; CHECK: st.param.b64 [param0], {{%rd[0-9]+}};682; CHECK: call.uni (retval0), test_i40,683; CHECK: ld.param.b64 {{%rd[0-9]+}}, [retval0];684; CHECK: st.param.b64 [func_retval0], {{%rd[0-9]+}};685; CHECK-NEXT: ret;686define i40 @test_i40(i40 %a) {687 %r = tail call i40 @test_i40(i40 %a);688 ret i40 %r;689}690 691; CHECK: .func (.param .b64 func_retval0)692; CHECK-LABEL: test_i47(693; CHECK-NEXT: .param .b64 test_i47_param_0694; CHECK: ld.param.b64 {{%rd[0-9]+}}, [test_i47_param_0];695; CHECK: .param .b64 param0;696; CHECK: .param .b64 retval0;697; CHECK: st.param.b64 [param0], {{%rd[0-9]+}};698; CHECK: call.uni (retval0), test_i47,699; CHECK: ld.param.b64 {{%rd[0-9]+}}, [retval0];700; CHECK: st.param.b64 [func_retval0], {{%rd[0-9]+}};701; CHECK-NEXT: ret;702define i47 @test_i47(i47 %a) {703 %r = tail call i47 @test_i47(i47 %a);704 ret i47 %r;705}706 707; CHECK: .func (.param .b64 func_retval0)708; CHECK-LABEL: test_i48(709; CHECK-NEXT: .param .b64 test_i48_param_0710; CHECK: ld.param.b64 {{%rd[0-9]+}}, [test_i48_param_0];711; CHECK: .param .b64 param0;712; CHECK: .param .b64 retval0;713; CHECK: st.param.b64 [param0], {{%rd[0-9]+}};714; CHECK: call.uni (retval0), test_i48,715; CHECK: ld.param.b64 {{%rd[0-9]+}}, [retval0];716; CHECK: st.param.b64 [func_retval0], {{%rd[0-9]+}};717; CHECK-NEXT: ret;718define i48 @test_i48(i48 %a) {719 %r = tail call i48 @test_i48(i48 %a);720 ret i48 %r;721}722 723; CHECK: .func (.param .b64 func_retval0)724; CHECK-LABEL: test_i51(725; CHECK-NEXT: .param .b64 test_i51_param_0726; CHECK: ld.param.b64 {{%rd[0-9]+}}, [test_i51_param_0];727; CHECK: .param .b64 param0;728; CHECK: .param .b64 retval0;729; CHECK: st.param.b64 [param0], {{%rd[0-9]+}};730; CHECK: call.uni (retval0), test_i51,731; CHECK: ld.param.b64 {{%rd[0-9]+}}, [retval0];732; CHECK: st.param.b64 [func_retval0], {{%rd[0-9]+}};733; CHECK-NEXT: ret;734define i51 @test_i51(i51 %a) {735 %r = tail call i51 @test_i51(i51 %a);736 ret i51 %r;737}738 739; CHECK: .func (.param .b64 func_retval0)740; CHECK-LABEL: test_i56(741; CHECK-NEXT: .param .b64 test_i56_param_0742; CHECK: ld.param.b64 {{%rd[0-9]+}}, [test_i56_param_0];743; CHECK: .param .b64 param0;744; CHECK: .param .b64 retval0;745; CHECK: st.param.b64 [param0], {{%rd[0-9]+}};746; CHECK: call.uni (retval0), test_i56,747; CHECK: ld.param.b64 {{%rd[0-9]+}}, [retval0];748; CHECK: st.param.b64 [func_retval0], {{%rd[0-9]+}};749; CHECK-NEXT: ret;750define i56 @test_i56(i56 %a) {751 %r = tail call i56 @test_i56(i56 %a);752 ret i56 %r;753}754 755; CHECK: .func (.param .b64 func_retval0)756; CHECK-LABEL: test_i57(757; CHECK-NEXT: .param .b64 test_i57_param_0758; CHECK: ld.param.b64 {{%rd[0-9]+}}, [test_i57_param_0];759; CHECK: .param .b64 param0;760; CHECK: .param .b64 retval0;761; CHECK: st.param.b64 [param0], {{%rd[0-9]+}};762; CHECK: call.uni (retval0), test_i57,763; CHECK: ld.param.b64 {{%rd[0-9]+}}, [retval0];764; CHECK: st.param.b64 [func_retval0], {{%rd[0-9]+}};765; CHECK-NEXT: ret;766define i57 @test_i57(i57 %a) {767 %r = tail call i57 @test_i57(i57 %a);768 ret i57 %r;769}770 771; CHECK: .func (.param .b64 func_retval0)772; CHECK-LABEL: test_i64(773; CHECK-NEXT: .param .b64 test_i64_param_0774; CHECK: ld.param.b64 [[E:%rd[0-9]+]], [test_i64_param_0];775; CHECK: .param .b64 param0;776; CHECK: .param .b64 retval0;777; CHECK: st.param.b64 [param0], [[E]];778; CHECK: call.uni (retval0), test_i64,779; CHECK: ld.param.b64 [[R:%rd[0-9]+]], [retval0];780; CHECK: st.param.b64 [func_retval0], [[R]];781; CHECK-NEXT: ret;782define i64 @test_i64(i64 %a) {783 %r = tail call i64 @test_i64(i64 %a);784 ret i64 %r;785}786 787; CHECK: .func (.param .align 32 .b8 func_retval0[32])788; CHECK-LABEL: test_v3i64(789; CHECK-NEXT: .param .align 32 .b8 test_v3i64_param_0[32]790; CHECK-DAG: ld.param.b64 [[E2:%rd[0-9]+]], [test_v3i64_param_0+16];791; CHECK-DAG: ld.param.v2.b64 {[[E0:%rd[0-9]+]], [[E1:%rd[0-9]+]]}, [test_v3i64_param_0];792; CHECK: .param .align 32 .b8 param0[32];793; CHECK: .param .align 32 .b8 retval0[32];794; CHECK-DAG: st.param.v2.b64 [param0], {[[E0]], [[E1]]};795; CHECK-DAG: st.param.b64 [param0+16], [[E2]];796; CHECK: call.uni (retval0), test_v3i64,797; CHECK: ld.param.v2.b64 {[[RE0:%rd[0-9]+]], [[RE1:%rd[0-9]+]]}, [retval0];798; CHECK: ld.param.b64 [[RE2:%rd[0-9]+]], [retval0+16];799; CHECK-DAG: st.param.v2.b64 [func_retval0], {[[RE0]], [[RE1]]};800; CHECK-DAG: st.param.b64 [func_retval0+16], [[RE2]];801; CHECK-DAG: st.param.v2.b64 [func_retval0], {[[RE0]], [[RE1]]};802; CHECK-DAG: st.param.b64 [func_retval0+16], [[RE2]];803; CHECK-NEXT: ret;804define <3 x i64> @test_v3i64(<3 x i64> %a) {805 %r = tail call <3 x i64> @test_v3i64(<3 x i64> %a);806 ret <3 x i64> %r;807}808 809; For i64 vector loads are limited by PTX to 2 elements.810; CHECK: .func (.param .align 32 .b8 func_retval0[32])811; CHECK-LABEL: test_v4i64(812; CHECK-NEXT: .param .align 32 .b8 test_v4i64_param_0[32]813; CHECK-DAG: ld.param.v2.b64 {[[E2:%rd[0-9]+]], [[E3:%rd[0-9]+]]}, [test_v4i64_param_0+16];814; CHECK-DAG: ld.param.v2.b64 {[[E0:%rd[0-9]+]], [[E1:%rd[0-9]+]]}, [test_v4i64_param_0];815; CHECK: .param .align 32 .b8 param0[32];816; CHECK: .param .align 32 .b8 retval0[32];817; CHECK-DAG: st.param.v2.b64 [param0], {[[E0]], [[E1]]};818; CHECK-DAG: st.param.v2.b64 [param0+16], {[[E2]], [[E3]]};819; CHECK: call.uni (retval0), test_v4i64,820; CHECK: ld.param.v2.b64 {[[RE0:%rd[0-9]+]], [[RE1:%rd[0-9]+]]}, [retval0];821; CHECK: ld.param.v2.b64 {[[RE2:%rd[0-9]+]], [[RE3:%rd[0-9]+]]}, [retval0+16];822; CHECK-DAG: st.param.v2.b64 [func_retval0+16], {[[RE2]], [[RE3]]};823; CHECK-DAG: st.param.v2.b64 [func_retval0], {[[RE0]], [[RE1]]};824; CHECK-NEXT: ret;825define <4 x i64> @test_v4i64(<4 x i64> %a) {826 %r = tail call <4 x i64> @test_v4i64(<4 x i64> %a);827 ret <4 x i64> %r;828}829 830; Aggregates, on the other hand, do not get extended.831 832; CHECK: .func (.param .align 1 .b8 func_retval0[1])833; CHECK-LABEL: test_s_i1(834; CHECK-NEXT: .align 1 .b8 test_s_i1_param_0[1]835; CHECK: ld.param.b8 [[A:%rs[0-9]+]], [test_s_i1_param_0];836; CHECK: .param .align 1 .b8 param0[1];837; CHECK: .param .align 1 .b8 retval0[1];838; CHECK: st.param.b8 [param0], [[A]]839; CHECK: call.uni (retval0), test_s_i1,840; CHECK: ld.param.b8 [[R:%rs[0-9]+]], [retval0];841; CHECK: st.param.b8 [func_retval0], [[R]];842; CHECK-NEXT: ret;843define %s_i1 @test_s_i1(%s_i1 %a) {844 %r = tail call %s_i1 @test_s_i1(%s_i1 %a);845 ret %s_i1 %r;846}847 848; CHECK: .func (.param .align 1 .b8 func_retval0[1])849; CHECK-LABEL: test_s_i8(850; CHECK-NEXT: .param .align 1 .b8 test_s_i8_param_0[1]851; CHECK: ld.param.b8 [[A:%rs[0-9]+]], [test_s_i8_param_0];852; CHECK: .param .align 1 .b8 param0[1];853; CHECK: .param .align 1 .b8 retval0[1];854; CHECK: st.param.b8 [param0], [[A]]855; CHECK: call.uni (retval0), test_s_i8,856; CHECK: ld.param.b8 [[R:%rs[0-9]+]], [retval0];857; CHECK: st.param.b8 [func_retval0], [[R]];858; CHECK-NEXT: ret;859define %s_i8 @test_s_i8(%s_i8 %a) {860 %r = tail call %s_i8 @test_s_i8(%s_i8 %a);861 ret %s_i8 %r;862}863 864; CHECK: .func (.param .align 2 .b8 func_retval0[2])865; CHECK-LABEL: test_s_i16(866; CHECK-NEXT: .param .align 2 .b8 test_s_i16_param_0[2]867; CHECK: ld.param.b16 [[A:%rs[0-9]+]], [test_s_i16_param_0];868; CHECK: .param .align 2 .b8 param0[2];869; CHECK: .param .align 2 .b8 retval0[2];870; CHECK: st.param.b16 [param0], [[A]]871; CHECK: call.uni (retval0), test_s_i16,872; CHECK: ld.param.b16 [[R:%rs[0-9]+]], [retval0];873; CHECK: st.param.b16 [func_retval0], [[R]];874; CHECK-NEXT: ret;875define %s_i16 @test_s_i16(%s_i16 %a) {876 %r = tail call %s_i16 @test_s_i16(%s_i16 %a);877 ret %s_i16 %r;878}879 880; CHECK: .func (.param .align 2 .b8 func_retval0[2])881; CHECK-LABEL: test_s_f16(882; CHECK-NEXT: .param .align 2 .b8 test_s_f16_param_0[2]883; CHECK: ld.param.b16 [[A:%rs[0-9]+]], [test_s_f16_param_0];884; CHECK: .param .align 2 .b8 param0[2];885; CHECK: .param .align 2 .b8 retval0[2];886; CHECK: st.param.b16 [param0], [[A]]887; CHECK: call.uni (retval0), test_s_f16,888; CHECK: ld.param.b16 [[R:%rs[0-9]+]], [retval0];889; CHECK: st.param.b16 [func_retval0], [[R]];890; CHECK-NEXT: ret;891define %s_f16 @test_s_f16(%s_f16 %a) {892 %r = tail call %s_f16 @test_s_f16(%s_f16 %a);893 ret %s_f16 %r;894}895 896; CHECK: .func (.param .align 4 .b8 func_retval0[4])897; CHECK-LABEL: test_s_i32(898; CHECK-NEXT: .param .align 4 .b8 test_s_i32_param_0[4]899; CHECK: ld.param.b32 [[E:%r[0-9]+]], [test_s_i32_param_0];900; CHECK: .param .align 4 .b8 param0[4]901; CHECK: .param .align 4 .b8 retval0[4];902; CHECK: st.param.b32 [param0], [[E]];903; CHECK: call.uni (retval0), test_s_i32,904; CHECK: ld.param.b32 [[R:%r[0-9]+]], [retval0];905; CHECK: st.param.b32 [func_retval0], [[R]];906; CHECK-NEXT: ret;907define %s_i32 @test_s_i32(%s_i32 %a) {908 %r = tail call %s_i32 @test_s_i32(%s_i32 %a);909 ret %s_i32 %r;910}911 912; CHECK: .func (.param .align 4 .b8 func_retval0[4])913; CHECK-LABEL: test_s_f32(914; CHECK-NEXT: .param .align 4 .b8 test_s_f32_param_0[4]915; CHECK: ld.param.b32 [[E:%r[0-9]+]], [test_s_f32_param_0];916; CHECK: .param .align 4 .b8 param0[4]917; CHECK: .param .align 4 .b8 retval0[4];918; CHECK: st.param.b32 [param0], [[E]];919; CHECK: call.uni (retval0), test_s_f32,920; CHECK: ld.param.b32 [[R:%r[0-9]+]], [retval0];921; CHECK: st.param.b32 [func_retval0], [[R]];922; CHECK-NEXT: ret;923define %s_f32 @test_s_f32(%s_f32 %a) {924 %r = tail call %s_f32 @test_s_f32(%s_f32 %a);925 ret %s_f32 %r;926}927 928; CHECK: .func (.param .align 8 .b8 func_retval0[8])929; CHECK-LABEL: test_s_i64(930; CHECK-NEXT: .param .align 8 .b8 test_s_i64_param_0[8]931; CHECK: ld.param.b64 [[E:%rd[0-9]+]], [test_s_i64_param_0];932; CHECK: .param .align 8 .b8 param0[8];933; CHECK: .param .align 8 .b8 retval0[8];934; CHECK: st.param.b64 [param0], [[E]];935; CHECK: call.uni (retval0), test_s_i64,936; CHECK: ld.param.b64 [[R:%rd[0-9]+]], [retval0];937; CHECK: st.param.b64 [func_retval0], [[R]];938; CHECK-NEXT: ret;939define %s_i64 @test_s_i64(%s_i64 %a) {940 %r = tail call %s_i64 @test_s_i64(%s_i64 %a);941 ret %s_i64 %r;942}943 944; Fields that have different types, but identical sizes are not vectorized.945; CHECK: .func (.param .align 8 .b8 func_retval0[24])946; CHECK-LABEL: test_s_i32f32(947; CHECK: .param .align 8 .b8 test_s_i32f32_param_0[24]948; CHECK-DAG: ld.param.b64 [[E4:%rd[0-9]+]], [test_s_i32f32_param_0+16];949; CHECK-DAG: ld.param.b32 [[E3:%r[0-9]+]], [test_s_i32f32_param_0+12];950; CHECK-DAG: ld.param.b32 [[E2:%r[0-9]+]], [test_s_i32f32_param_0+8];951; CHECK-DAG: ld.param.b32 [[E1:%r[0-9]+]], [test_s_i32f32_param_0+4];952; CHECK-DAG: ld.param.b32 [[E0:%r[0-9]+]], [test_s_i32f32_param_0];953; CHECK: .param .align 8 .b8 param0[24];954; CHECK: .param .align 8 .b8 retval0[24];955; CHECK-DAG: st.param.b32 [param0], [[E0]];956; CHECK-DAG: st.param.b32 [param0+4], [[E1]];957; CHECK-DAG: st.param.b32 [param0+8], [[E2]];958; CHECK-DAG: st.param.b32 [param0+12], [[E3]];959; CHECK-DAG: st.param.b64 [param0+16], [[E4]];960; CHECK: call.uni (retval0), test_s_i32f32,961; CHECK-DAG: ld.param.b32 [[RE0:%r[0-9]+]], [retval0];962; CHECK-DAG: ld.param.b32 [[RE1:%r[0-9]+]], [retval0+4];963; CHECK-DAG: ld.param.b32 [[RE2:%r[0-9]+]], [retval0+8];964; CHECK-DAG: ld.param.b32 [[RE3:%r[0-9]+]], [retval0+12];965; CHECK-DAG: ld.param.b64 [[RE4:%rd[0-9]+]], [retval0+16];966; CHECK-DAG: st.param.b32 [func_retval0], [[RE0]];967; CHECK-DAG: st.param.b32 [func_retval0+4], [[RE1]];968; CHECK-DAG: st.param.b32 [func_retval0+8], [[RE2]];969; CHECK-DAG: st.param.b32 [func_retval0+12], [[RE3]];970; CHECK-DAG: st.param.b64 [func_retval0+16], [[RE4]];971; CHECK: ret;972define %s_i32f32 @test_s_i32f32(%s_i32f32 %a) {973 %r = tail call %s_i32f32 @test_s_i32f32(%s_i32f32 %a);974 ret %s_i32f32 %r;975}976 977; We do vectorize consecutive fields with matching types.978; CHECK:.visible .func (.param .align 8 .b8 func_retval0[24])979; CHECK-LABEL: test_s_i32x4(980; CHECK: .param .align 8 .b8 test_s_i32x4_param_0[24]981; CHECK-DAG: ld.param.b64 [[RD1:%rd[0-9]+]], [test_s_i32x4_param_0+16];982; CHECK-DAG: ld.param.v2.b32 {[[E2:%r[0-9]+]], [[E3:%r[0-9]+]]}, [test_s_i32x4_param_0+8];983; CHECK-DAG: ld.param.v2.b32 {[[E0:%r[0-9]+]], [[E1:%r[0-9]+]]}, [test_s_i32x4_param_0];984; CHECK: .param .align 8 .b8 param0[24];985; CHECK: .param .align 8 .b8 retval0[24];986; CHECK-DAG: st.param.v2.b32 [param0], {[[E0]], [[E1]]};987; CHECK-DAG: st.param.v2.b32 [param0+8], {[[E2]], [[E3]]};988; CHECK-DAG: st.param.b64 [param0+16], [[E4]];989; CHECK: call.uni (retval0), test_s_i32x4,990; CHECK: ld.param.v2.b32 {[[RE0:%r[0-9]+]], [[RE1:%r[0-9]+]]}, [retval0];991; CHECK: ld.param.v2.b32 {[[RE2:%r[0-9]+]], [[RE3:%r[0-9]+]]}, [retval0+8];992; CHECK: ld.param.b64 [[RE4:%rd[0-9]+]], [retval0+16];993; CHECK-DAG: st.param.v2.b32 [func_retval0], {[[RE0]], [[RE1]]};994; CHECK-DAG: st.param.v2.b32 [func_retval0+8], {[[RE2]], [[RE3]]};995; CHECK-DAG: st.param.b64 [func_retval0+16], [[RE4]];996; CHECK: ret;997 998define %s_i32x4 @test_s_i32x4(%s_i32x4 %a) {999 %r = tail call %s_i32x4 @test_s_i32x4(%s_i32x4 %a);1000 ret %s_i32x4 %r;1001}1002 1003; CHECK:.visible .func (.param .align 8 .b8 func_retval0[32])1004; CHECK-LABEL: test_s_i1i32x4(1005; CHECK: .param .align 8 .b8 test_s_i1i32x4_param_0[32]1006; CHECK: ld.param.b64 [[E5:%rd[0-9]+]], [test_s_i1i32x4_param_0+24];1007; CHECK: ld.param.b32 [[E4:%r[0-9]+]], [test_s_i1i32x4_param_0+16];1008; CHECK: ld.param.b32 [[E3:%r[0-9]+]], [test_s_i1i32x4_param_0+12];1009; CHECK: ld.param.b8 [[E2:%rs[0-9]+]], [test_s_i1i32x4_param_0+8];1010; CHECK: ld.param.v2.b32 {[[E0:%r[0-9]+]], [[E1:%r[0-9]+]]}, [test_s_i1i32x4_param_0];1011; CHECK: .param .align 8 .b8 param0[32];1012; CHECK: .param .align 8 .b8 retval0[32];1013; CHECK-DAG: st.param.v2.b32 [param0], {[[E0]], [[E1]]};1014; CHECK-DAG: st.param.b8 [param0+8], [[E2]];1015; CHECK-DAG: st.param.b32 [param0+12], [[E3]];1016; CHECK-DAG: st.param.b32 [param0+16], [[E4]];1017; CHECK-DAG: st.param.b64 [param0+24], [[E5]];1018; CHECK: call.uni (retval0), test_s_i1i32x4, (param0);1019; CHECK: ld.param.v2.b32 {[[RE0:%r[0-9]+]], [[RE1:%r[0-9]+]]}, [retval0];1020; CHECK: ld.param.b8 [[RE2:%rs[0-9]+]], [retval0+8];1021; CHECK: ld.param.b32 [[RE3:%r[0-9]+]], [retval0+12];1022; CHECK: ld.param.b32 [[RE4:%r[0-9]+]], [retval0+16];1023; CHECK: ld.param.b64 [[RE5:%rd[0-9]+]], [retval0+24];1024; CHECK: st.param.v2.b32 [func_retval0], {[[RE0]], [[RE1]]};1025; CHECK: st.param.b8 [func_retval0+8], [[RE2]];1026; CHECK: st.param.b32 [func_retval0+12], [[RE3]];1027; CHECK: st.param.b32 [func_retval0+16], [[RE4]];1028; CHECK: st.param.b64 [func_retval0+24], [[RE5]];1029; CHECK: ret;1030 1031define %s_i8i32x4 @test_s_i1i32x4(%s_i8i32x4 %a) {1032 %r = tail call %s_i8i32x4 @test_s_i1i32x4(%s_i8i32x4 %a);1033 ret %s_i8i32x4 %r;1034}1035 1036; -- All loads/stores from parameters aligned by one must be done one1037; -- byte at a time.1038; CHECK:.visible .func (.param .align 1 .b8 func_retval0[25])1039; CHECK-LABEL: test_s_i1i32x4p(1040; CHECK-DAG: .param .align 1 .b8 test_s_i1i32x4p_param_0[25]1041; CHECK-DAG: ld.param.b8 %r{{.*}}, [test_s_i1i32x4p_param_0+24];1042; CHECK-DAG: ld.param.b8 %r{{.*}}, [test_s_i1i32x4p_param_0+23];1043; CHECK-DAG: ld.param.b8 %r{{.*}}, [test_s_i1i32x4p_param_0+22];1044; CHECK-DAG: ld.param.b8 %r{{.*}}, [test_s_i1i32x4p_param_0+21];1045; CHECK-DAG: ld.param.b8 %r{{.*}}, [test_s_i1i32x4p_param_0+20];1046; CHECK-DAG: ld.param.b8 %r{{.*}}, [test_s_i1i32x4p_param_0+19];1047; CHECK-DAG: ld.param.b8 %r{{.*}}, [test_s_i1i32x4p_param_0+18];1048; CHECK-DAG: ld.param.b8 %r{{.*}}, [test_s_i1i32x4p_param_0+17];1049; CHECK-DAG: ld.param.b8 %r{{.*}}, [test_s_i1i32x4p_param_0+16];1050; CHECK-DAG: ld.param.b8 %r{{.*}}, [test_s_i1i32x4p_param_0+15];1051; CHECK-DAG: ld.param.b8 %r{{.*}}, [test_s_i1i32x4p_param_0+14];1052; CHECK-DAG: ld.param.b8 %r{{.*}}, [test_s_i1i32x4p_param_0+13];1053; CHECK-DAG: ld.param.b8 %r{{.*}}, [test_s_i1i32x4p_param_0+12];1054; CHECK-DAG: ld.param.b8 %r{{.*}}, [test_s_i1i32x4p_param_0+11];1055; CHECK-DAG: ld.param.b8 %r{{.*}}, [test_s_i1i32x4p_param_0+10];1056; CHECK-DAG: ld.param.b8 %r{{.*}}, [test_s_i1i32x4p_param_0+9];1057; CHECK-DAG: ld.param.b8 %r{{.*}}, [test_s_i1i32x4p_param_0+8];1058; CHECK-DAG: ld.param.b8 %r{{.*}}, [test_s_i1i32x4p_param_0+7];1059; CHECK-DAG: ld.param.b8 %r{{.*}}, [test_s_i1i32x4p_param_0+6];1060; CHECK-DAG: ld.param.b8 %r{{.*}}, [test_s_i1i32x4p_param_0+5];1061; CHECK-DAG: ld.param.b8 %r{{.*}}, [test_s_i1i32x4p_param_0+4];1062; CHECK-DAG: ld.param.b8 %r{{.*}}, [test_s_i1i32x4p_param_0+3];1063; CHECK-DAG: ld.param.b8 %r{{.*}}, [test_s_i1i32x4p_param_0+2];1064; CHECK-DAG: ld.param.b8 %r{{.*}}, [test_s_i1i32x4p_param_0+1];1065; CHECK-DAG: ld.param.b8 %r{{.*}}, [test_s_i1i32x4p_param_0];1066; CHECK: .param .align 1 .b8 param0[25];1067; CHECK: .param .align 1 .b8 retval0[25];1068; CHECK-DAG: st.param.b8 [param0],1069; CHECK-DAG: st.param.b8 [param0+1],1070; CHECK-DAG: st.param.b8 [param0+2],1071; CHECK-DAG: st.param.b8 [param0+3],1072; CHECK-DAG: st.param.b8 [param0+4],1073; CHECK-DAG: st.param.b8 [param0+5],1074; CHECK-DAG: st.param.b8 [param0+6],1075; CHECK-DAG: st.param.b8 [param0+7],1076; CHECK-DAG: st.param.b8 [param0+8],1077; CHECK-DAG: st.param.b8 [param0+9],1078; CHECK-DAG: st.param.b8 [param0+10],1079; CHECK-DAG: st.param.b8 [param0+11],1080; CHECK-DAG: st.param.b8 [param0+12],1081; CHECK-DAG: st.param.b8 [param0+13],1082; CHECK-DAG: st.param.b8 [param0+14],1083; CHECK-DAG: st.param.b8 [param0+15],1084; CHECK-DAG: st.param.b8 [param0+16],1085; CHECK-DAG: st.param.b8 [param0+17],1086; CHECK-DAG: st.param.b8 [param0+18],1087; CHECK-DAG: st.param.b8 [param0+19],1088; CHECK-DAG: st.param.b8 [param0+20],1089; CHECK-DAG: st.param.b8 [param0+21],1090; CHECK-DAG: st.param.b8 [param0+22],1091; CHECK-DAG: st.param.b8 [param0+23],1092; CHECK-DAG: st.param.b8 [param0+24],1093; CHECK: call.uni (retval0), test_s_i1i32x4p, (param0);1094; CHECK-DAG: ld.param.b8 %rs{{[0-9]+}}, [retval0+8];1095; CHECK-DAG: ld.param.b8 %r{{[0-9]+}}, [retval0+3];1096; CHECK-DAG: ld.param.b8 %r{{[0-9]+}}, [retval0+2];1097; CHECK-DAG: ld.param.b8 %r{{[0-9]+}}, [retval0+1];1098; CHECK-DAG: ld.param.b8 %r{{[0-9]+}}, [retval0];1099; CHECK-DAG: ld.param.b8 %r{{[0-9]+}}, [retval0+7];1100; CHECK-DAG: ld.param.b8 %r{{[0-9]+}}, [retval0+6];1101; CHECK-DAG: ld.param.b8 %r{{[0-9]+}}, [retval0+5];1102; CHECK-DAG: ld.param.b8 %r{{[0-9]+}}, [retval0+4];1103; CHECK-DAG: ld.param.b8 %r{{[0-9]+}}, [retval0+12];1104; CHECK-DAG: ld.param.b8 %r{{[0-9]+}}, [retval0+11];1105; CHECK-DAG: ld.param.b8 %r{{[0-9]+}}, [retval0+10];1106; CHECK-DAG: ld.param.b8 %r{{[0-9]+}}, [retval0+9];1107; CHECK-DAG: ld.param.b8 %r{{[0-9]+}}, [retval0+16];1108; CHECK-DAG: ld.param.b8 %r{{[0-9]+}}, [retval0+15];1109; CHECK-DAG: ld.param.b8 %r{{[0-9]+}}, [retval0+14];1110; CHECK-DAG: ld.param.b8 %r{{[0-9]+}}, [retval0+13];1111; CHECK-DAG: ld.param.b8 %rd{{[0-9]+}}, [retval0+24];1112; CHECK-DAG: ld.param.b8 %rd{{[0-9]+}}, [retval0+23];1113; CHECK-DAG: ld.param.b8 %rd{{[0-9]+}}, [retval0+22];1114; CHECK-DAG: ld.param.b8 %rd{{[0-9]+}}, [retval0+21];1115; CHECK-DAG: ld.param.b8 %rd{{[0-9]+}}, [retval0+20];1116; CHECK-DAG: ld.param.b8 %rd{{[0-9]+}}, [retval0+19];1117; CHECK-DAG: ld.param.b8 %rd{{[0-9]+}}, [retval0+18];1118; CHECK-DAG: ld.param.b8 %rd{{[0-9]+}}, [retval0+17];1119; CHECK: } // callseq1120; CHECK-DAG: st.param.b8 [func_retval0],1121; CHECK-DAG: st.param.b8 [func_retval0+1],1122; CHECK-DAG: st.param.b8 [func_retval0+2],1123; CHECK-DAG: st.param.b8 [func_retval0+3],1124; CHECK-DAG: st.param.b8 [func_retval0+4],1125; CHECK-DAG: st.param.b8 [func_retval0+5],1126; CHECK-DAG: st.param.b8 [func_retval0+6],1127; CHECK-DAG: st.param.b8 [func_retval0+7],1128; CHECK-DAG: st.param.b8 [func_retval0+8],1129; CHECK-DAG: st.param.b8 [func_retval0+9],1130; CHECK-DAG: st.param.b8 [func_retval0+10],1131; CHECK-DAG: st.param.b8 [func_retval0+11],1132; CHECK-DAG: st.param.b8 [func_retval0+12],1133; CHECK-DAG: st.param.b8 [func_retval0+13],1134; CHECK-DAG: st.param.b8 [func_retval0+14],1135; CHECK-DAG: st.param.b8 [func_retval0+15],1136; CHECK-DAG: st.param.b8 [func_retval0+16],1137; CHECK-DAG: st.param.b8 [func_retval0+17],1138; CHECK-DAG: st.param.b8 [func_retval0+18],1139; CHECK-DAG: st.param.b8 [func_retval0+19],1140; CHECK-DAG: st.param.b8 [func_retval0+20],1141; CHECK-DAG: st.param.b8 [func_retval0+21],1142; CHECK-DAG: st.param.b8 [func_retval0+22],1143; CHECK-DAG: st.param.b8 [func_retval0+23],1144; CHECK-DAG: st.param.b8 [func_retval0+24],1145 1146define %s_i8i32x4p @test_s_i1i32x4p(%s_i8i32x4p %a) {1147 %r = tail call %s_i8i32x4p @test_s_i1i32x4p(%s_i8i32x4p %a);1148 ret %s_i8i32x4p %r;1149}1150 1151; Check that we can vectorize loads that span multiple aggregate fields.1152; CHECK:.visible .func (.param .align 16 .b8 func_retval0[80])1153; CHECK-LABEL: test_s_crossfield(1154; CHECK: .param .align 16 .b8 test_s_crossfield_param_0[80]1155; CHECK: ld.param.b32 [[E15:%r[0-9]+]], [test_s_crossfield_param_0+64];1156; CHECK: ld.param.v4.b32 {[[E11:%r[0-9]+]], [[E12:%r[0-9]+]], [[E13:%r[0-9]+]], [[E14:%r[0-9]+]]}, [test_s_crossfield_param_0+48];1157; CHECK: ld.param.v4.b32 {[[E7:%r[0-9]+]], [[E8:%r[0-9]+]], [[E9:%r[0-9]+]], [[E10:%r[0-9]+]]}, [test_s_crossfield_param_0+32];1158; CHECK: ld.param.v4.b32 {[[E3:%r[0-9]+]], [[E4:%r[0-9]+]], [[E5:%r[0-9]+]], [[E6:%r[0-9]+]]}, [test_s_crossfield_param_0+16];1159; CHECK: ld.param.b32 [[E2:%r[0-9]+]], [test_s_crossfield_param_0+8];1160; CHECK: ld.param.v2.b32 {[[E0:%r[0-9]+]], [[E1:%r[0-9]+]]}, [test_s_crossfield_param_0];1161; CHECK: .param .align 16 .b8 param0[80];1162; CHECK: .param .align 16 .b8 retval0[80];1163; CHECK-DAG: st.param.v2.b32 [param0], {[[E0]], [[E1]]};1164; CHECK-DAG: st.param.b32 [param0+8], [[E2]];1165; CHECK-DAG: st.param.v4.b32 [param0+16], {[[E3]], [[E4]], [[E5]], [[E6]]};1166; CHECK-DAG: st.param.v4.b32 [param0+32], {[[E7]], [[E8]], [[E9]], [[E10]]};1167; CHECK-DAG: st.param.v4.b32 [param0+48], {[[E11]], [[E12]], [[E13]], [[E14]]};1168; CHECK-DAG: st.param.b32 [param0+64], [[E15]];1169; CHECK: call.uni (retval0), test_s_crossfield,1170; CHECK: ld.param.v2.b32 {[[RE0:%r[0-9]+]], [[RE1:%r[0-9]+]]}, [retval0];1171; CHECK: ld.param.b32 [[RE2:%r[0-9]+]], [retval0+8];1172; CHECK: ld.param.v4.b32 {[[RE3:%r[0-9]+]], [[RE4:%r[0-9]+]], [[RE5:%r[0-9]+]], [[RE6:%r[0-9]+]]}, [retval0+16];1173; CHECK: ld.param.v4.b32 {[[RE7:%r[0-9]+]], [[RE8:%r[0-9]+]], [[RE9:%r[0-9]+]], [[RE10:%r[0-9]+]]}, [retval0+32];1174; CHECK: ld.param.v4.b32 {[[RE11:%r[0-9]+]], [[RE12:%r[0-9]+]], [[RE13:%r[0-9]+]], [[RE14:%r[0-9]+]]}, [retval0+48];1175; CHECK: ld.param.b32 [[RE15:%r[0-9]+]], [retval0+64];1176; CHECK: st.param.v2.b32 [func_retval0], {[[RE0]], [[RE1]]};1177; CHECK: st.param.b32 [func_retval0+8], [[RE2]];1178; CHECK: st.param.v4.b32 [func_retval0+16], {[[RE3]], [[RE4]], [[RE5]], [[RE6]]};1179; CHECK: st.param.v4.b32 [func_retval0+32], {[[RE7]], [[RE8]], [[RE9]], [[RE10]]};1180; CHECK: st.param.v4.b32 [func_retval0+48], {[[RE11]], [[RE12]], [[RE13]], [[RE14]]};1181; CHECK: st.param.b32 [func_retval0+64], [[RE15]];1182; CHECK: ret;1183 1184define %s_crossfield @test_s_crossfield(%s_crossfield %a) {1185 %r = tail call %s_crossfield @test_s_crossfield(%s_crossfield %a);1186 ret %s_crossfield %r;1187}1188