xref: /llvm-project/llvm/test/CodeGen/RISCV/rvv/vlsegff-rv32.ll (revision b6c0f1bfa79a3a32d841ac5ab1f94c3aee3b5d90) 
1; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
2; RUN: llc -mtriple=riscv32 -mattr=+zve64d,+f,+d,+zvfh,+zvfbfmin \
3; RUN:     -verify-machineinstrs < %s | FileCheck %s
4
5declare {target("riscv.vector.tuple", <vscale x 1 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv1i8_2t(target("riscv.vector.tuple", <vscale x 1 x i8>, 2), ptr, i32, i32)
6declare {target("riscv.vector.tuple", <vscale x 1 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv1i8_2t.nxv1i1(target("riscv.vector.tuple", <vscale x 1 x i8>, 2), ptr, <vscale x 1 x i1>, i32, i32, i32)
7
8define <vscale x 1 x i8> @test_vlseg2ff_nxv1i8_triscv.vector.tuple_nxv1i8_2t(ptr %base, i32 %vl, ptr %outvl) {
9; CHECK-LABEL: test_vlseg2ff_nxv1i8_triscv.vector.tuple_nxv1i8_2t:
10; CHECK:       # %bb.0: # %entry
11; CHECK-NEXT:    vsetvli zero, a1, e8, mf8, ta, ma
12; CHECK-NEXT:    vlseg2e8ff.v v7, (a0)
13; CHECK-NEXT:    csrr a0, vl
14; CHECK-NEXT:    sw a0, 0(a2)
15; CHECK-NEXT:    ret
16entry:
17  %0 = tail call {target("riscv.vector.tuple", <vscale x 1 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv1i8_2t(target("riscv.vector.tuple", <vscale x 1 x i8>, 2) undef, ptr %base, i32 %vl, i32 3)
18  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 1 x i8>, 2), i32} %0, 0
19  %2 = call <vscale x 1 x i8> @llvm.riscv.tuple.extract.nxv1i8.triscv.vector.tuple_nxv1i8_2t(target("riscv.vector.tuple", <vscale x 1 x i8>, 2) %1, i32 1)
20  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 1 x i8>, 2), i32} %0, 1
21  store i32 %3, ptr %outvl
22  ret <vscale x 1 x i8> %2
23}
24
25define <vscale x 1 x i8> @test_vlseg2ff_mask_nxv1i8_triscv.vector.tuple_nxv1i8_2t(target("riscv.vector.tuple", <vscale x 1 x i8>, 2) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
26; CHECK-LABEL: test_vlseg2ff_mask_nxv1i8_triscv.vector.tuple_nxv1i8_2t:
27; CHECK:       # %bb.0: # %entry
28; CHECK-NEXT:    vsetvli zero, a1, e8, mf8, ta, mu
29; CHECK-NEXT:    vmv1r.v v7, v8
30; CHECK-NEXT:    vmv1r.v v8, v9
31; CHECK-NEXT:    vlseg2e8ff.v v7, (a0), v0.t
32; CHECK-NEXT:    csrr a0, vl
33; CHECK-NEXT:    sw a0, 0(a2)
34; CHECK-NEXT:    ret
35entry:
36  %0 = tail call {target("riscv.vector.tuple", <vscale x 1 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv1i8_2t.nxv1i1(target("riscv.vector.tuple", <vscale x 1 x i8>, 2) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 3)
37  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 1 x i8>, 2), i32} %0, 0
38  %2 = call <vscale x 1 x i8> @llvm.riscv.tuple.extract.nxv1i8.triscv.vector.tuple_nxv1i8_2t(target("riscv.vector.tuple", <vscale x 1 x i8>, 2) %1, i32 1)
39  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 1 x i8>, 2), i32} %0, 1
40  store i32 %3, ptr %outvl
41  ret <vscale x 1 x i8> %2
42}
43
44declare {target("riscv.vector.tuple", <vscale x 2 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv2i8_2t(target("riscv.vector.tuple", <vscale x 2 x i8>, 2), ptr, i32, i32)
45declare {target("riscv.vector.tuple", <vscale x 2 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv2i8_2t.nxv2i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 2), ptr, <vscale x 2 x i1>, i32, i32, i32)
46
47define <vscale x 2 x i8> @test_vlseg2ff_nxv2i8_triscv.vector.tuple_nxv2i8_2t(ptr %base, i32 %vl, ptr %outvl) {
48; CHECK-LABEL: test_vlseg2ff_nxv2i8_triscv.vector.tuple_nxv2i8_2t:
49; CHECK:       # %bb.0: # %entry
50; CHECK-NEXT:    vsetvli zero, a1, e8, mf4, ta, ma
51; CHECK-NEXT:    vlseg2e8ff.v v7, (a0)
52; CHECK-NEXT:    csrr a0, vl
53; CHECK-NEXT:    sw a0, 0(a2)
54; CHECK-NEXT:    ret
55entry:
56  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv2i8_2t(target("riscv.vector.tuple", <vscale x 2 x i8>, 2) undef, ptr %base, i32 %vl, i32 3)
57  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 2), i32} %0, 0
58  %2 = call <vscale x 2 x i8> @llvm.riscv.tuple.extract.nxv2i8.triscv.vector.tuple_nxv2i8_2t(target("riscv.vector.tuple", <vscale x 2 x i8>, 2) %1, i32 1)
59  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 2), i32} %0, 1
60  store i32 %3, ptr %outvl
61  ret <vscale x 2 x i8> %2
62}
63
64define <vscale x 2 x i8> @test_vlseg2ff_mask_nxv2i8_triscv.vector.tuple_nxv2i8_2t(target("riscv.vector.tuple", <vscale x 2 x i8>, 2) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
65; CHECK-LABEL: test_vlseg2ff_mask_nxv2i8_triscv.vector.tuple_nxv2i8_2t:
66; CHECK:       # %bb.0: # %entry
67; CHECK-NEXT:    vsetvli zero, a1, e8, mf4, ta, mu
68; CHECK-NEXT:    vmv1r.v v7, v8
69; CHECK-NEXT:    vmv1r.v v8, v9
70; CHECK-NEXT:    vlseg2e8ff.v v7, (a0), v0.t
71; CHECK-NEXT:    csrr a0, vl
72; CHECK-NEXT:    sw a0, 0(a2)
73; CHECK-NEXT:    ret
74entry:
75  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv2i8_2t.nxv2i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 2) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 3)
76  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 2), i32} %0, 0
77  %2 = call <vscale x 2 x i8> @llvm.riscv.tuple.extract.nxv2i8.triscv.vector.tuple_nxv2i8_2t(target("riscv.vector.tuple", <vscale x 2 x i8>, 2) %1, i32 1)
78  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 2), i32} %0, 1
79  store i32 %3, ptr %outvl
80  ret <vscale x 2 x i8> %2
81}
82
83declare {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv4i8_2t(target("riscv.vector.tuple", <vscale x 4 x i8>, 2), ptr, i32, i32)
84declare {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv4i8_2t.nxv4i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 2), ptr, <vscale x 4 x i1>, i32, i32, i32)
85
86define <vscale x 4 x i8> @test_vlseg2ff_nxv4i8_triscv.vector.tuple_nxv4i8_2t(ptr %base, i32 %vl, ptr %outvl) {
87; CHECK-LABEL: test_vlseg2ff_nxv4i8_triscv.vector.tuple_nxv4i8_2t:
88; CHECK:       # %bb.0: # %entry
89; CHECK-NEXT:    vsetvli zero, a1, e8, mf2, ta, ma
90; CHECK-NEXT:    vlseg2e8ff.v v7, (a0)
91; CHECK-NEXT:    csrr a0, vl
92; CHECK-NEXT:    sw a0, 0(a2)
93; CHECK-NEXT:    ret
94entry:
95  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv4i8_2t(target("riscv.vector.tuple", <vscale x 4 x i8>, 2) undef, ptr %base, i32 %vl, i32 3)
96  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} %0, 0
97  %2 = call <vscale x 4 x i8> @llvm.riscv.tuple.extract.nxv4i8.triscv.vector.tuple_nxv4i8_2t(target("riscv.vector.tuple", <vscale x 4 x i8>, 2) %1, i32 1)
98  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} %0, 1
99  store i32 %3, ptr %outvl
100  ret <vscale x 4 x i8> %2
101}
102
103define <vscale x 4 x i8> @test_vlseg2ff_mask_nxv4i8_triscv.vector.tuple_nxv4i8_2t(target("riscv.vector.tuple", <vscale x 4 x i8>, 2) %val, ptr %base, i32 %vl, <vscale x 4 x i1> %mask, ptr %outvl) {
104; CHECK-LABEL: test_vlseg2ff_mask_nxv4i8_triscv.vector.tuple_nxv4i8_2t:
105; CHECK:       # %bb.0: # %entry
106; CHECK-NEXT:    vsetvli zero, a1, e8, mf2, ta, mu
107; CHECK-NEXT:    vmv1r.v v7, v8
108; CHECK-NEXT:    vmv1r.v v8, v9
109; CHECK-NEXT:    vlseg2e8ff.v v7, (a0), v0.t
110; CHECK-NEXT:    csrr a0, vl
111; CHECK-NEXT:    sw a0, 0(a2)
112; CHECK-NEXT:    ret
113entry:
114  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv4i8_2t.nxv4i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 2) %val, ptr %base, <vscale x 4 x i1> %mask, i32 %vl, i32 1, i32 3)
115  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} %0, 0
116  %2 = call <vscale x 4 x i8> @llvm.riscv.tuple.extract.nxv4i8.triscv.vector.tuple_nxv4i8_2t(target("riscv.vector.tuple", <vscale x 4 x i8>, 2) %1, i32 1)
117  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} %0, 1
118  store i32 %3, ptr %outvl
119  ret <vscale x 4 x i8> %2
120}
121
122declare {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv8i8_2t(target("riscv.vector.tuple", <vscale x 8 x i8>, 2), ptr, i32, i32)
123declare {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv8i8_2t.nxv8i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 2), ptr, <vscale x 8 x i1>, i32, i32, i32)
124
125define <vscale x 8 x i8> @test_vlseg2ff_nxv8i8_triscv.vector.tuple_nxv8i8_2t(ptr %base, i32 %vl, ptr %outvl) {
126; CHECK-LABEL: test_vlseg2ff_nxv8i8_triscv.vector.tuple_nxv8i8_2t:
127; CHECK:       # %bb.0: # %entry
128; CHECK-NEXT:    vsetvli zero, a1, e8, m1, ta, ma
129; CHECK-NEXT:    vlseg2e8ff.v v7, (a0)
130; CHECK-NEXT:    csrr a0, vl
131; CHECK-NEXT:    sw a0, 0(a2)
132; CHECK-NEXT:    ret
133entry:
134  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv8i8_2t(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) undef, ptr %base, i32 %vl, i32 3)
135  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} %0, 0
136  %2 = call <vscale x 8 x i8> @llvm.riscv.tuple.extract.nxv8i8.triscv.vector.tuple_nxv8i8_2t(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) %1, i32 1)
137  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} %0, 1
138  store i32 %3, ptr %outvl
139  ret <vscale x 8 x i8> %2
140}
141
142define <vscale x 8 x i8> @test_vlseg2ff_mask_nxv8i8_triscv.vector.tuple_nxv8i8_2t(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) %val, ptr %base, i32 %vl, <vscale x 8 x i1> %mask, ptr %outvl) {
143; CHECK-LABEL: test_vlseg2ff_mask_nxv8i8_triscv.vector.tuple_nxv8i8_2t:
144; CHECK:       # %bb.0: # %entry
145; CHECK-NEXT:    vsetvli zero, a1, e8, m1, ta, mu
146; CHECK-NEXT:    vmv1r.v v7, v8
147; CHECK-NEXT:    vmv1r.v v8, v9
148; CHECK-NEXT:    vlseg2e8ff.v v7, (a0), v0.t
149; CHECK-NEXT:    csrr a0, vl
150; CHECK-NEXT:    sw a0, 0(a2)
151; CHECK-NEXT:    ret
152entry:
153  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv8i8_2t.nxv8i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) %val, ptr %base, <vscale x 8 x i1> %mask, i32 %vl, i32 1, i32 3)
154  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} %0, 0
155  %2 = call <vscale x 8 x i8> @llvm.riscv.tuple.extract.nxv8i8.triscv.vector.tuple_nxv8i8_2t(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) %1, i32 1)
156  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} %0, 1
157  store i32 %3, ptr %outvl
158  ret <vscale x 8 x i8> %2
159}
160
161declare {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv16i8_2t(target("riscv.vector.tuple", <vscale x 16 x i8>, 2), ptr, i32, i32)
162declare {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv16i8_2t.nxv16i1(target("riscv.vector.tuple", <vscale x 16 x i8>, 2), ptr, <vscale x 16 x i1>, i32, i32, i32)
163
164define <vscale x 16 x i8> @test_vlseg2ff_nxv16i8_triscv.vector.tuple_nxv16i8_2t(ptr %base, i32 %vl, ptr %outvl) {
165; CHECK-LABEL: test_vlseg2ff_nxv16i8_triscv.vector.tuple_nxv16i8_2t:
166; CHECK:       # %bb.0: # %entry
167; CHECK-NEXT:    vsetvli zero, a1, e8, m2, ta, ma
168; CHECK-NEXT:    vlseg2e8ff.v v6, (a0)
169; CHECK-NEXT:    csrr a0, vl
170; CHECK-NEXT:    sw a0, 0(a2)
171; CHECK-NEXT:    ret
172entry:
173  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv16i8_2t(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) undef, ptr %base, i32 %vl, i32 3)
174  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} %0, 0
175  %2 = call <vscale x 16 x i8> @llvm.riscv.tuple.extract.nxv16i8.triscv.vector.tuple_nxv16i8_2t(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) %1, i32 1)
176  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} %0, 1
177  store i32 %3, ptr %outvl
178  ret <vscale x 16 x i8> %2
179}
180
181define <vscale x 16 x i8> @test_vlseg2ff_mask_nxv16i8_triscv.vector.tuple_nxv16i8_2t(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) %val, ptr %base, i32 %vl, <vscale x 16 x i1> %mask, ptr %outvl) {
182; CHECK-LABEL: test_vlseg2ff_mask_nxv16i8_triscv.vector.tuple_nxv16i8_2t:
183; CHECK:       # %bb.0: # %entry
184; CHECK-NEXT:    vsetvli zero, a1, e8, m2, ta, mu
185; CHECK-NEXT:    vmv2r.v v6, v8
186; CHECK-NEXT:    vmv2r.v v8, v10
187; CHECK-NEXT:    vlseg2e8ff.v v6, (a0), v0.t
188; CHECK-NEXT:    csrr a0, vl
189; CHECK-NEXT:    sw a0, 0(a2)
190; CHECK-NEXT:    ret
191entry:
192  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv16i8_2t.nxv16i1(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) %val, ptr %base, <vscale x 16 x i1> %mask, i32 %vl, i32 1, i32 3)
193  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} %0, 0
194  %2 = call <vscale x 16 x i8> @llvm.riscv.tuple.extract.nxv16i8.triscv.vector.tuple_nxv16i8_2t(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) %1, i32 1)
195  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} %0, 1
196  store i32 %3, ptr %outvl
197  ret <vscale x 16 x i8> %2
198}
199
200declare {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv32i8_2t(target("riscv.vector.tuple", <vscale x 32 x i8>, 2), ptr, i32, i32)
201declare {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv32i8_2t.nxv32i1(target("riscv.vector.tuple", <vscale x 32 x i8>, 2), ptr, <vscale x 32 x i1>, i32, i32, i32)
202
203define <vscale x 32 x i8> @test_vlseg2ff_nxv32i8_triscv.vector.tuple_nxv32i8_2t(ptr %base, i32 %vl, ptr %outvl) {
204; CHECK-LABEL: test_vlseg2ff_nxv32i8_triscv.vector.tuple_nxv32i8_2t:
205; CHECK:       # %bb.0: # %entry
206; CHECK-NEXT:    vsetvli zero, a1, e8, m4, ta, ma
207; CHECK-NEXT:    vlseg2e8ff.v v4, (a0)
208; CHECK-NEXT:    csrr a0, vl
209; CHECK-NEXT:    sw a0, 0(a2)
210; CHECK-NEXT:    ret
211entry:
212  %0 = tail call {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv32i8_2t(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) undef, ptr %base, i32 %vl, i32 3)
213  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} %0, 0
214  %2 = call <vscale x 32 x i8> @llvm.riscv.tuple.extract.nxv32i8.triscv.vector.tuple_nxv32i8_2t(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) %1, i32 1)
215  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} %0, 1
216  store i32 %3, ptr %outvl
217  ret <vscale x 32 x i8> %2
218}
219
220define <vscale x 32 x i8> @test_vlseg2ff_mask_nxv32i8_triscv.vector.tuple_nxv32i8_2t(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) %val, ptr %base, i32 %vl, <vscale x 32 x i1> %mask, ptr %outvl) {
221; CHECK-LABEL: test_vlseg2ff_mask_nxv32i8_triscv.vector.tuple_nxv32i8_2t:
222; CHECK:       # %bb.0: # %entry
223; CHECK-NEXT:    vsetvli zero, a1, e8, m4, ta, mu
224; CHECK-NEXT:    vmv4r.v v4, v8
225; CHECK-NEXT:    vmv4r.v v8, v12
226; CHECK-NEXT:    vlseg2e8ff.v v4, (a0), v0.t
227; CHECK-NEXT:    csrr a0, vl
228; CHECK-NEXT:    sw a0, 0(a2)
229; CHECK-NEXT:    ret
230entry:
231  %0 = tail call {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv32i8_2t.nxv32i1(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) %val, ptr %base, <vscale x 32 x i1> %mask, i32 %vl, i32 1, i32 3)
232  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} %0, 0
233  %2 = call <vscale x 32 x i8> @llvm.riscv.tuple.extract.nxv32i8.triscv.vector.tuple_nxv32i8_2t(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) %1, i32 1)
234  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} %0, 1
235  store i32 %3, ptr %outvl
236  ret <vscale x 32 x i8> %2
237}
238
239declare {target("riscv.vector.tuple", <vscale x 1 x i8>, 3), i32} @llvm.riscv.vlseg3ff.triscv.vector.tuple_nxv1i8_3t(target("riscv.vector.tuple", <vscale x 1 x i8>, 3), ptr, i32, i32)
240declare {target("riscv.vector.tuple", <vscale x 1 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv1i8_3t.nxv1i1(target("riscv.vector.tuple", <vscale x 1 x i8>, 3), ptr, <vscale x 1 x i1>, i32, i32, i32)
241
242define <vscale x 1 x i8> @test_vlseg3ff_nxv1i8_triscv.vector.tuple_nxv1i8_3t(ptr %base, i32 %vl, ptr %outvl) {
243; CHECK-LABEL: test_vlseg3ff_nxv1i8_triscv.vector.tuple_nxv1i8_3t:
244; CHECK:       # %bb.0: # %entry
245; CHECK-NEXT:    vsetvli zero, a1, e8, mf8, ta, ma
246; CHECK-NEXT:    vlseg3e8ff.v v7, (a0)
247; CHECK-NEXT:    csrr a0, vl
248; CHECK-NEXT:    sw a0, 0(a2)
249; CHECK-NEXT:    ret
250entry:
251  %0 = tail call {target("riscv.vector.tuple", <vscale x 1 x i8>, 3), i32} @llvm.riscv.vlseg3ff.triscv.vector.tuple_nxv1i8_3t(target("riscv.vector.tuple", <vscale x 1 x i8>, 3) undef, ptr %base, i32 %vl, i32 3)
252  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 1 x i8>, 3), i32} %0, 0
253  %2 = call <vscale x 1 x i8> @llvm.riscv.tuple.extract.nxv1i8.triscv.vector.tuple_nxv1i8_3t(target("riscv.vector.tuple", <vscale x 1 x i8>, 3) %1, i32 1)
254  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 1 x i8>, 3), i32} %0, 1
255  store i32 %3, ptr %outvl
256  ret <vscale x 1 x i8> %2
257}
258
259define <vscale x 1 x i8> @test_vlseg3ff_mask_nxv1i8_triscv.vector.tuple_nxv1i8_3t(target("riscv.vector.tuple", <vscale x 1 x i8>, 3) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
260; CHECK-LABEL: test_vlseg3ff_mask_nxv1i8_triscv.vector.tuple_nxv1i8_3t:
261; CHECK:       # %bb.0: # %entry
262; CHECK-NEXT:    vsetvli zero, a1, e8, mf8, ta, mu
263; CHECK-NEXT:    vmv1r.v v7, v8
264; CHECK-NEXT:    vmv1r.v v8, v9
265; CHECK-NEXT:    vmv1r.v v9, v10
266; CHECK-NEXT:    vlseg3e8ff.v v7, (a0), v0.t
267; CHECK-NEXT:    csrr a0, vl
268; CHECK-NEXT:    sw a0, 0(a2)
269; CHECK-NEXT:    ret
270entry:
271  %0 = tail call {target("riscv.vector.tuple", <vscale x 1 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv1i8_3t.nxv1i1(target("riscv.vector.tuple", <vscale x 1 x i8>, 3) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 3)
272  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 1 x i8>, 3), i32} %0, 0
273  %2 = call <vscale x 1 x i8> @llvm.riscv.tuple.extract.nxv1i8.triscv.vector.tuple_nxv1i8_3t(target("riscv.vector.tuple", <vscale x 1 x i8>, 3) %1, i32 1)
274  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 1 x i8>, 3), i32} %0, 1
275  store i32 %3, ptr %outvl
276  ret <vscale x 1 x i8> %2
277}
278
279declare {target("riscv.vector.tuple", <vscale x 2 x i8>, 3), i32} @llvm.riscv.vlseg3ff.triscv.vector.tuple_nxv2i8_3t(target("riscv.vector.tuple", <vscale x 2 x i8>, 3), ptr, i32, i32)
280declare {target("riscv.vector.tuple", <vscale x 2 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv2i8_3t.nxv2i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 3), ptr, <vscale x 2 x i1>, i32, i32, i32)
281
282define <vscale x 2 x i8> @test_vlseg3ff_nxv2i8_triscv.vector.tuple_nxv2i8_3t(ptr %base, i32 %vl, ptr %outvl) {
283; CHECK-LABEL: test_vlseg3ff_nxv2i8_triscv.vector.tuple_nxv2i8_3t:
284; CHECK:       # %bb.0: # %entry
285; CHECK-NEXT:    vsetvli zero, a1, e8, mf4, ta, ma
286; CHECK-NEXT:    vlseg3e8ff.v v7, (a0)
287; CHECK-NEXT:    csrr a0, vl
288; CHECK-NEXT:    sw a0, 0(a2)
289; CHECK-NEXT:    ret
290entry:
291  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 3), i32} @llvm.riscv.vlseg3ff.triscv.vector.tuple_nxv2i8_3t(target("riscv.vector.tuple", <vscale x 2 x i8>, 3) undef, ptr %base, i32 %vl, i32 3)
292  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 3), i32} %0, 0
293  %2 = call <vscale x 2 x i8> @llvm.riscv.tuple.extract.nxv2i8.triscv.vector.tuple_nxv2i8_3t(target("riscv.vector.tuple", <vscale x 2 x i8>, 3) %1, i32 1)
294  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 3), i32} %0, 1
295  store i32 %3, ptr %outvl
296  ret <vscale x 2 x i8> %2
297}
298
299define <vscale x 2 x i8> @test_vlseg3ff_mask_nxv2i8_triscv.vector.tuple_nxv2i8_3t(target("riscv.vector.tuple", <vscale x 2 x i8>, 3) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
300; CHECK-LABEL: test_vlseg3ff_mask_nxv2i8_triscv.vector.tuple_nxv2i8_3t:
301; CHECK:       # %bb.0: # %entry
302; CHECK-NEXT:    vsetvli zero, a1, e8, mf4, ta, mu
303; CHECK-NEXT:    vmv1r.v v7, v8
304; CHECK-NEXT:    vmv1r.v v8, v9
305; CHECK-NEXT:    vmv1r.v v9, v10
306; CHECK-NEXT:    vlseg3e8ff.v v7, (a0), v0.t
307; CHECK-NEXT:    csrr a0, vl
308; CHECK-NEXT:    sw a0, 0(a2)
309; CHECK-NEXT:    ret
310entry:
311  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv2i8_3t.nxv2i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 3) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 3)
312  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 3), i32} %0, 0
313  %2 = call <vscale x 2 x i8> @llvm.riscv.tuple.extract.nxv2i8.triscv.vector.tuple_nxv2i8_3t(target("riscv.vector.tuple", <vscale x 2 x i8>, 3) %1, i32 1)
314  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 3), i32} %0, 1
315  store i32 %3, ptr %outvl
316  ret <vscale x 2 x i8> %2
317}
318
319declare {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} @llvm.riscv.vlseg3ff.triscv.vector.tuple_nxv4i8_3t(target("riscv.vector.tuple", <vscale x 4 x i8>, 3), ptr, i32, i32)
320declare {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv4i8_3t.nxv4i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 3), ptr, <vscale x 4 x i1>, i32, i32, i32)
321
322define <vscale x 4 x i8> @test_vlseg3ff_nxv4i8_triscv.vector.tuple_nxv4i8_3t(ptr %base, i32 %vl, ptr %outvl) {
323; CHECK-LABEL: test_vlseg3ff_nxv4i8_triscv.vector.tuple_nxv4i8_3t:
324; CHECK:       # %bb.0: # %entry
325; CHECK-NEXT:    vsetvli zero, a1, e8, mf2, ta, ma
326; CHECK-NEXT:    vlseg3e8ff.v v7, (a0)
327; CHECK-NEXT:    csrr a0, vl
328; CHECK-NEXT:    sw a0, 0(a2)
329; CHECK-NEXT:    ret
330entry:
331  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} @llvm.riscv.vlseg3ff.triscv.vector.tuple_nxv4i8_3t(target("riscv.vector.tuple", <vscale x 4 x i8>, 3) undef, ptr %base, i32 %vl, i32 3)
332  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} %0, 0
333  %2 = call <vscale x 4 x i8> @llvm.riscv.tuple.extract.nxv4i8.triscv.vector.tuple_nxv4i8_3t(target("riscv.vector.tuple", <vscale x 4 x i8>, 3) %1, i32 1)
334  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} %0, 1
335  store i32 %3, ptr %outvl
336  ret <vscale x 4 x i8> %2
337}
338
339define <vscale x 4 x i8> @test_vlseg3ff_mask_nxv4i8_triscv.vector.tuple_nxv4i8_3t(target("riscv.vector.tuple", <vscale x 4 x i8>, 3) %val, ptr %base, i32 %vl, <vscale x 4 x i1> %mask, ptr %outvl) {
340; CHECK-LABEL: test_vlseg3ff_mask_nxv4i8_triscv.vector.tuple_nxv4i8_3t:
341; CHECK:       # %bb.0: # %entry
342; CHECK-NEXT:    vsetvli zero, a1, e8, mf2, ta, mu
343; CHECK-NEXT:    vmv1r.v v7, v8
344; CHECK-NEXT:    vmv1r.v v8, v9
345; CHECK-NEXT:    vmv1r.v v9, v10
346; CHECK-NEXT:    vlseg3e8ff.v v7, (a0), v0.t
347; CHECK-NEXT:    csrr a0, vl
348; CHECK-NEXT:    sw a0, 0(a2)
349; CHECK-NEXT:    ret
350entry:
351  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv4i8_3t.nxv4i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 3) %val, ptr %base, <vscale x 4 x i1> %mask, i32 %vl, i32 1, i32 3)
352  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} %0, 0
353  %2 = call <vscale x 4 x i8> @llvm.riscv.tuple.extract.nxv4i8.triscv.vector.tuple_nxv4i8_3t(target("riscv.vector.tuple", <vscale x 4 x i8>, 3) %1, i32 1)
354  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} %0, 1
355  store i32 %3, ptr %outvl
356  ret <vscale x 4 x i8> %2
357}
358
359declare {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} @llvm.riscv.vlseg3ff.triscv.vector.tuple_nxv8i8_3t(target("riscv.vector.tuple", <vscale x 8 x i8>, 3), ptr, i32, i32)
360declare {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv8i8_3t.nxv8i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 3), ptr, <vscale x 8 x i1>, i32, i32, i32)
361
362define <vscale x 8 x i8> @test_vlseg3ff_nxv8i8_triscv.vector.tuple_nxv8i8_3t(ptr %base, i32 %vl, ptr %outvl) {
363; CHECK-LABEL: test_vlseg3ff_nxv8i8_triscv.vector.tuple_nxv8i8_3t:
364; CHECK:       # %bb.0: # %entry
365; CHECK-NEXT:    vsetvli zero, a1, e8, m1, ta, ma
366; CHECK-NEXT:    vlseg3e8ff.v v7, (a0)
367; CHECK-NEXT:    csrr a0, vl
368; CHECK-NEXT:    sw a0, 0(a2)
369; CHECK-NEXT:    ret
370entry:
371  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} @llvm.riscv.vlseg3ff.triscv.vector.tuple_nxv8i8_3t(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) undef, ptr %base, i32 %vl, i32 3)
372  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} %0, 0
373  %2 = call <vscale x 8 x i8> @llvm.riscv.tuple.extract.nxv8i8.triscv.vector.tuple_nxv8i8_3t(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) %1, i32 1)
374  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} %0, 1
375  store i32 %3, ptr %outvl
376  ret <vscale x 8 x i8> %2
377}
378
379define <vscale x 8 x i8> @test_vlseg3ff_mask_nxv8i8_triscv.vector.tuple_nxv8i8_3t(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) %val, ptr %base, i32 %vl, <vscale x 8 x i1> %mask, ptr %outvl) {
380; CHECK-LABEL: test_vlseg3ff_mask_nxv8i8_triscv.vector.tuple_nxv8i8_3t:
381; CHECK:       # %bb.0: # %entry
382; CHECK-NEXT:    vsetvli zero, a1, e8, m1, ta, mu
383; CHECK-NEXT:    vmv1r.v v7, v8
384; CHECK-NEXT:    vmv1r.v v8, v9
385; CHECK-NEXT:    vmv1r.v v9, v10
386; CHECK-NEXT:    vlseg3e8ff.v v7, (a0), v0.t
387; CHECK-NEXT:    csrr a0, vl
388; CHECK-NEXT:    sw a0, 0(a2)
389; CHECK-NEXT:    ret
390entry:
391  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv8i8_3t.nxv8i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) %val, ptr %base, <vscale x 8 x i1> %mask, i32 %vl, i32 1, i32 3)
392  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} %0, 0
393  %2 = call <vscale x 8 x i8> @llvm.riscv.tuple.extract.nxv8i8.triscv.vector.tuple_nxv8i8_3t(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) %1, i32 1)
394  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} %0, 1
395  store i32 %3, ptr %outvl
396  ret <vscale x 8 x i8> %2
397}
398
399declare {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} @llvm.riscv.vlseg3ff.triscv.vector.tuple_nxv16i8_3t(target("riscv.vector.tuple", <vscale x 16 x i8>, 3), ptr, i32, i32)
400declare {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv16i8_3t.nxv16i1(target("riscv.vector.tuple", <vscale x 16 x i8>, 3), ptr, <vscale x 16 x i1>, i32, i32, i32)
401
402define <vscale x 16 x i8> @test_vlseg3ff_nxv16i8_triscv.vector.tuple_nxv16i8_3t(ptr %base, i32 %vl, ptr %outvl) {
403; CHECK-LABEL: test_vlseg3ff_nxv16i8_triscv.vector.tuple_nxv16i8_3t:
404; CHECK:       # %bb.0: # %entry
405; CHECK-NEXT:    vsetvli zero, a1, e8, m2, ta, ma
406; CHECK-NEXT:    vlseg3e8ff.v v6, (a0)
407; CHECK-NEXT:    csrr a0, vl
408; CHECK-NEXT:    sw a0, 0(a2)
409; CHECK-NEXT:    ret
410entry:
411  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} @llvm.riscv.vlseg3ff.triscv.vector.tuple_nxv16i8_3t(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) undef, ptr %base, i32 %vl, i32 3)
412  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} %0, 0
413  %2 = call <vscale x 16 x i8> @llvm.riscv.tuple.extract.nxv16i8.triscv.vector.tuple_nxv16i8_3t(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) %1, i32 1)
414  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} %0, 1
415  store i32 %3, ptr %outvl
416  ret <vscale x 16 x i8> %2
417}
418
419define <vscale x 16 x i8> @test_vlseg3ff_mask_nxv16i8_triscv.vector.tuple_nxv16i8_3t(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) %val, ptr %base, i32 %vl, <vscale x 16 x i1> %mask, ptr %outvl) {
420; CHECK-LABEL: test_vlseg3ff_mask_nxv16i8_triscv.vector.tuple_nxv16i8_3t:
421; CHECK:       # %bb.0: # %entry
422; CHECK-NEXT:    vsetvli zero, a1, e8, m2, ta, mu
423; CHECK-NEXT:    vmv2r.v v6, v8
424; CHECK-NEXT:    vmv2r.v v8, v10
425; CHECK-NEXT:    vmv2r.v v10, v12
426; CHECK-NEXT:    vlseg3e8ff.v v6, (a0), v0.t
427; CHECK-NEXT:    csrr a0, vl
428; CHECK-NEXT:    sw a0, 0(a2)
429; CHECK-NEXT:    ret
430entry:
431  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv16i8_3t.nxv16i1(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) %val, ptr %base, <vscale x 16 x i1> %mask, i32 %vl, i32 1, i32 3)
432  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} %0, 0
433  %2 = call <vscale x 16 x i8> @llvm.riscv.tuple.extract.nxv16i8.triscv.vector.tuple_nxv16i8_3t(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) %1, i32 1)
434  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} %0, 1
435  store i32 %3, ptr %outvl
436  ret <vscale x 16 x i8> %2
437}
438
439declare {target("riscv.vector.tuple", <vscale x 1 x i8>, 4), i32} @llvm.riscv.vlseg4ff.triscv.vector.tuple_nxv1i8_4t(target("riscv.vector.tuple", <vscale x 1 x i8>, 4), ptr, i32, i32)
440declare {target("riscv.vector.tuple", <vscale x 1 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv1i8_4t.nxv1i1(target("riscv.vector.tuple", <vscale x 1 x i8>, 4), ptr, <vscale x 1 x i1>, i32, i32, i32)
441
442define <vscale x 1 x i8> @test_vlseg4ff_nxv1i8_triscv.vector.tuple_nxv1i8_4t(ptr %base, i32 %vl, ptr %outvl) {
443; CHECK-LABEL: test_vlseg4ff_nxv1i8_triscv.vector.tuple_nxv1i8_4t:
444; CHECK:       # %bb.0: # %entry
445; CHECK-NEXT:    vsetvli zero, a1, e8, mf8, ta, ma
446; CHECK-NEXT:    vlseg4e8ff.v v7, (a0)
447; CHECK-NEXT:    csrr a0, vl
448; CHECK-NEXT:    sw a0, 0(a2)
449; CHECK-NEXT:    ret
450entry:
451  %0 = tail call {target("riscv.vector.tuple", <vscale x 1 x i8>, 4), i32} @llvm.riscv.vlseg4ff.triscv.vector.tuple_nxv1i8_4t(target("riscv.vector.tuple", <vscale x 1 x i8>, 4) undef, ptr %base, i32 %vl, i32 3)
452  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 1 x i8>, 4), i32} %0, 0
453  %2 = call <vscale x 1 x i8> @llvm.riscv.tuple.extract.nxv1i8.triscv.vector.tuple_nxv1i8_4t(target("riscv.vector.tuple", <vscale x 1 x i8>, 4) %1, i32 1)
454  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 1 x i8>, 4), i32} %0, 1
455  store i32 %3, ptr %outvl
456  ret <vscale x 1 x i8> %2
457}
458
459define <vscale x 1 x i8> @test_vlseg4ff_mask_nxv1i8_triscv.vector.tuple_nxv1i8_4t(target("riscv.vector.tuple", <vscale x 1 x i8>, 4) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
460; CHECK-LABEL: test_vlseg4ff_mask_nxv1i8_triscv.vector.tuple_nxv1i8_4t:
461; CHECK:       # %bb.0: # %entry
462; CHECK-NEXT:    vsetvli zero, a1, e8, mf8, ta, mu
463; CHECK-NEXT:    vmv1r.v v7, v8
464; CHECK-NEXT:    vmv1r.v v8, v9
465; CHECK-NEXT:    vmv1r.v v9, v10
466; CHECK-NEXT:    vmv1r.v v10, v11
467; CHECK-NEXT:    vlseg4e8ff.v v7, (a0), v0.t
468; CHECK-NEXT:    csrr a0, vl
469; CHECK-NEXT:    sw a0, 0(a2)
470; CHECK-NEXT:    ret
471entry:
472  %0 = tail call {target("riscv.vector.tuple", <vscale x 1 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv1i8_4t.nxv1i1(target("riscv.vector.tuple", <vscale x 1 x i8>, 4) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 3)
473  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 1 x i8>, 4), i32} %0, 0
474  %2 = call <vscale x 1 x i8> @llvm.riscv.tuple.extract.nxv1i8.triscv.vector.tuple_nxv1i8_4t(target("riscv.vector.tuple", <vscale x 1 x i8>, 4) %1, i32 1)
475  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 1 x i8>, 4), i32} %0, 1
476  store i32 %3, ptr %outvl
477  ret <vscale x 1 x i8> %2
478}
479
480declare {target("riscv.vector.tuple", <vscale x 2 x i8>, 4), i32} @llvm.riscv.vlseg4ff.triscv.vector.tuple_nxv2i8_4t(target("riscv.vector.tuple", <vscale x 2 x i8>, 4), ptr, i32, i32)
481declare {target("riscv.vector.tuple", <vscale x 2 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv2i8_4t.nxv2i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 4), ptr, <vscale x 2 x i1>, i32, i32, i32)
482
483define <vscale x 2 x i8> @test_vlseg4ff_nxv2i8_triscv.vector.tuple_nxv2i8_4t(ptr %base, i32 %vl, ptr %outvl) {
484; CHECK-LABEL: test_vlseg4ff_nxv2i8_triscv.vector.tuple_nxv2i8_4t:
485; CHECK:       # %bb.0: # %entry
486; CHECK-NEXT:    vsetvli zero, a1, e8, mf4, ta, ma
487; CHECK-NEXT:    vlseg4e8ff.v v7, (a0)
488; CHECK-NEXT:    csrr a0, vl
489; CHECK-NEXT:    sw a0, 0(a2)
490; CHECK-NEXT:    ret
491entry:
492  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 4), i32} @llvm.riscv.vlseg4ff.triscv.vector.tuple_nxv2i8_4t(target("riscv.vector.tuple", <vscale x 2 x i8>, 4) undef, ptr %base, i32 %vl, i32 3)
493  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 4), i32} %0, 0
494  %2 = call <vscale x 2 x i8> @llvm.riscv.tuple.extract.nxv2i8.triscv.vector.tuple_nxv2i8_4t(target("riscv.vector.tuple", <vscale x 2 x i8>, 4) %1, i32 1)
495  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 4), i32} %0, 1
496  store i32 %3, ptr %outvl
497  ret <vscale x 2 x i8> %2
498}
499
500define <vscale x 2 x i8> @test_vlseg4ff_mask_nxv2i8_triscv.vector.tuple_nxv2i8_4t(target("riscv.vector.tuple", <vscale x 2 x i8>, 4) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
501; CHECK-LABEL: test_vlseg4ff_mask_nxv2i8_triscv.vector.tuple_nxv2i8_4t:
502; CHECK:       # %bb.0: # %entry
503; CHECK-NEXT:    vsetvli zero, a1, e8, mf4, ta, mu
504; CHECK-NEXT:    vmv1r.v v7, v8
505; CHECK-NEXT:    vmv1r.v v8, v9
506; CHECK-NEXT:    vmv1r.v v9, v10
507; CHECK-NEXT:    vmv1r.v v10, v11
508; CHECK-NEXT:    vlseg4e8ff.v v7, (a0), v0.t
509; CHECK-NEXT:    csrr a0, vl
510; CHECK-NEXT:    sw a0, 0(a2)
511; CHECK-NEXT:    ret
512entry:
513  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv2i8_4t.nxv2i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 4) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 3)
514  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 4), i32} %0, 0
515  %2 = call <vscale x 2 x i8> @llvm.riscv.tuple.extract.nxv2i8.triscv.vector.tuple_nxv2i8_4t(target("riscv.vector.tuple", <vscale x 2 x i8>, 4) %1, i32 1)
516  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 4), i32} %0, 1
517  store i32 %3, ptr %outvl
518  ret <vscale x 2 x i8> %2
519}
520
521declare {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} @llvm.riscv.vlseg4ff.triscv.vector.tuple_nxv4i8_4t(target("riscv.vector.tuple", <vscale x 4 x i8>, 4), ptr, i32, i32)
522declare {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv4i8_4t.nxv4i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 4), ptr, <vscale x 4 x i1>, i32, i32, i32)
523
524define <vscale x 4 x i8> @test_vlseg4ff_nxv4i8_triscv.vector.tuple_nxv4i8_4t(ptr %base, i32 %vl, ptr %outvl) {
525; CHECK-LABEL: test_vlseg4ff_nxv4i8_triscv.vector.tuple_nxv4i8_4t:
526; CHECK:       # %bb.0: # %entry
527; CHECK-NEXT:    vsetvli zero, a1, e8, mf2, ta, ma
528; CHECK-NEXT:    vlseg4e8ff.v v7, (a0)
529; CHECK-NEXT:    csrr a0, vl
530; CHECK-NEXT:    sw a0, 0(a2)
531; CHECK-NEXT:    ret
532entry:
533  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} @llvm.riscv.vlseg4ff.triscv.vector.tuple_nxv4i8_4t(target("riscv.vector.tuple", <vscale x 4 x i8>, 4) undef, ptr %base, i32 %vl, i32 3)
534  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} %0, 0
535  %2 = call <vscale x 4 x i8> @llvm.riscv.tuple.extract.nxv4i8.triscv.vector.tuple_nxv4i8_4t(target("riscv.vector.tuple", <vscale x 4 x i8>, 4) %1, i32 1)
536  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} %0, 1
537  store i32 %3, ptr %outvl
538  ret <vscale x 4 x i8> %2
539}
540
541define <vscale x 4 x i8> @test_vlseg4ff_mask_nxv4i8_triscv.vector.tuple_nxv4i8_4t(target("riscv.vector.tuple", <vscale x 4 x i8>, 4) %val, ptr %base, i32 %vl, <vscale x 4 x i1> %mask, ptr %outvl) {
542; CHECK-LABEL: test_vlseg4ff_mask_nxv4i8_triscv.vector.tuple_nxv4i8_4t:
543; CHECK:       # %bb.0: # %entry
544; CHECK-NEXT:    vsetvli zero, a1, e8, mf2, ta, mu
545; CHECK-NEXT:    vmv1r.v v7, v8
546; CHECK-NEXT:    vmv1r.v v8, v9
547; CHECK-NEXT:    vmv1r.v v9, v10
548; CHECK-NEXT:    vmv1r.v v10, v11
549; CHECK-NEXT:    vlseg4e8ff.v v7, (a0), v0.t
550; CHECK-NEXT:    csrr a0, vl
551; CHECK-NEXT:    sw a0, 0(a2)
552; CHECK-NEXT:    ret
553entry:
554  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv4i8_4t.nxv4i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 4) %val, ptr %base, <vscale x 4 x i1> %mask, i32 %vl, i32 1, i32 3)
555  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} %0, 0
556  %2 = call <vscale x 4 x i8> @llvm.riscv.tuple.extract.nxv4i8.triscv.vector.tuple_nxv4i8_4t(target("riscv.vector.tuple", <vscale x 4 x i8>, 4) %1, i32 1)
557  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} %0, 1
558  store i32 %3, ptr %outvl
559  ret <vscale x 4 x i8> %2
560}
561
562declare {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} @llvm.riscv.vlseg4ff.triscv.vector.tuple_nxv8i8_4t(target("riscv.vector.tuple", <vscale x 8 x i8>, 4), ptr, i32, i32)
563declare {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv8i8_4t.nxv8i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 4), ptr, <vscale x 8 x i1>, i32, i32, i32)
564
565define <vscale x 8 x i8> @test_vlseg4ff_nxv8i8_triscv.vector.tuple_nxv8i8_4t(ptr %base, i32 %vl, ptr %outvl) {
566; CHECK-LABEL: test_vlseg4ff_nxv8i8_triscv.vector.tuple_nxv8i8_4t:
567; CHECK:       # %bb.0: # %entry
568; CHECK-NEXT:    vsetvli zero, a1, e8, m1, ta, ma
569; CHECK-NEXT:    vlseg4e8ff.v v7, (a0)
570; CHECK-NEXT:    csrr a0, vl
571; CHECK-NEXT:    sw a0, 0(a2)
572; CHECK-NEXT:    ret
573entry:
574  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} @llvm.riscv.vlseg4ff.triscv.vector.tuple_nxv8i8_4t(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) undef, ptr %base, i32 %vl, i32 3)
575  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} %0, 0
576  %2 = call <vscale x 8 x i8> @llvm.riscv.tuple.extract.nxv8i8.triscv.vector.tuple_nxv8i8_4t(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) %1, i32 1)
577  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} %0, 1
578  store i32 %3, ptr %outvl
579  ret <vscale x 8 x i8> %2
580}
581
582define <vscale x 8 x i8> @test_vlseg4ff_mask_nxv8i8_triscv.vector.tuple_nxv8i8_4t(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) %val, ptr %base, i32 %vl, <vscale x 8 x i1> %mask, ptr %outvl) {
583; CHECK-LABEL: test_vlseg4ff_mask_nxv8i8_triscv.vector.tuple_nxv8i8_4t:
584; CHECK:       # %bb.0: # %entry
585; CHECK-NEXT:    vsetvli zero, a1, e8, m1, ta, mu
586; CHECK-NEXT:    vmv1r.v v7, v8
587; CHECK-NEXT:    vmv1r.v v8, v9
588; CHECK-NEXT:    vmv1r.v v9, v10
589; CHECK-NEXT:    vmv1r.v v10, v11
590; CHECK-NEXT:    vlseg4e8ff.v v7, (a0), v0.t
591; CHECK-NEXT:    csrr a0, vl
592; CHECK-NEXT:    sw a0, 0(a2)
593; CHECK-NEXT:    ret
594entry:
595  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv8i8_4t.nxv8i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) %val, ptr %base, <vscale x 8 x i1> %mask, i32 %vl, i32 1, i32 3)
596  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} %0, 0
597  %2 = call <vscale x 8 x i8> @llvm.riscv.tuple.extract.nxv8i8.triscv.vector.tuple_nxv8i8_4t(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) %1, i32 1)
598  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} %0, 1
599  store i32 %3, ptr %outvl
600  ret <vscale x 8 x i8> %2
601}
602
603declare {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} @llvm.riscv.vlseg4ff.triscv.vector.tuple_nxv16i8_4t(target("riscv.vector.tuple", <vscale x 16 x i8>, 4), ptr, i32, i32)
604declare {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv16i8_4t.nxv16i1(target("riscv.vector.tuple", <vscale x 16 x i8>, 4), ptr, <vscale x 16 x i1>, i32, i32, i32)
605
606define <vscale x 16 x i8> @test_vlseg4ff_nxv16i8_triscv.vector.tuple_nxv16i8_4t(ptr %base, i32 %vl, ptr %outvl) {
607; CHECK-LABEL: test_vlseg4ff_nxv16i8_triscv.vector.tuple_nxv16i8_4t:
608; CHECK:       # %bb.0: # %entry
609; CHECK-NEXT:    vsetvli zero, a1, e8, m2, ta, ma
610; CHECK-NEXT:    vlseg4e8ff.v v6, (a0)
611; CHECK-NEXT:    csrr a0, vl
612; CHECK-NEXT:    sw a0, 0(a2)
613; CHECK-NEXT:    ret
614entry:
615  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} @llvm.riscv.vlseg4ff.triscv.vector.tuple_nxv16i8_4t(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) undef, ptr %base, i32 %vl, i32 3)
616  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} %0, 0
617  %2 = call <vscale x 16 x i8> @llvm.riscv.tuple.extract.nxv16i8.triscv.vector.tuple_nxv16i8_4t(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) %1, i32 1)
618  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} %0, 1
619  store i32 %3, ptr %outvl
620  ret <vscale x 16 x i8> %2
621}
622
623define <vscale x 16 x i8> @test_vlseg4ff_mask_nxv16i8_triscv.vector.tuple_nxv16i8_4t(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) %val, ptr %base, i32 %vl, <vscale x 16 x i1> %mask, ptr %outvl) {
624; CHECK-LABEL: test_vlseg4ff_mask_nxv16i8_triscv.vector.tuple_nxv16i8_4t:
625; CHECK:       # %bb.0: # %entry
626; CHECK-NEXT:    vsetvli zero, a1, e8, m2, ta, mu
627; CHECK-NEXT:    vmv2r.v v6, v8
628; CHECK-NEXT:    vmv2r.v v8, v10
629; CHECK-NEXT:    vmv2r.v v10, v12
630; CHECK-NEXT:    vmv2r.v v12, v14
631; CHECK-NEXT:    vlseg4e8ff.v v6, (a0), v0.t
632; CHECK-NEXT:    csrr a0, vl
633; CHECK-NEXT:    sw a0, 0(a2)
634; CHECK-NEXT:    ret
635entry:
636  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv16i8_4t.nxv16i1(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) %val, ptr %base, <vscale x 16 x i1> %mask, i32 %vl, i32 1, i32 3)
637  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} %0, 0
638  %2 = call <vscale x 16 x i8> @llvm.riscv.tuple.extract.nxv16i8.triscv.vector.tuple_nxv16i8_4t(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) %1, i32 1)
639  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} %0, 1
640  store i32 %3, ptr %outvl
641  ret <vscale x 16 x i8> %2
642}
643
644declare {target("riscv.vector.tuple", <vscale x 1 x i8>, 5), i32} @llvm.riscv.vlseg5ff.triscv.vector.tuple_nxv1i8_5t(target("riscv.vector.tuple", <vscale x 1 x i8>, 5), ptr, i32, i32)
645declare {target("riscv.vector.tuple", <vscale x 1 x i8>, 5), i32} @llvm.riscv.vlseg5ff.mask.triscv.vector.tuple_nxv1i8_5t.nxv1i1(target("riscv.vector.tuple", <vscale x 1 x i8>, 5), ptr, <vscale x 1 x i1>, i32, i32, i32)
646
647define <vscale x 1 x i8> @test_vlseg5ff_nxv1i8_triscv.vector.tuple_nxv1i8_5t(ptr %base, i32 %vl, ptr %outvl) {
648; CHECK-LABEL: test_vlseg5ff_nxv1i8_triscv.vector.tuple_nxv1i8_5t:
649; CHECK:       # %bb.0: # %entry
650; CHECK-NEXT:    vsetvli zero, a1, e8, mf8, ta, ma
651; CHECK-NEXT:    vlseg5e8ff.v v7, (a0)
652; CHECK-NEXT:    csrr a0, vl
653; CHECK-NEXT:    sw a0, 0(a2)
654; CHECK-NEXT:    ret
655entry:
656  %0 = tail call {target("riscv.vector.tuple", <vscale x 1 x i8>, 5), i32} @llvm.riscv.vlseg5ff.triscv.vector.tuple_nxv1i8_5t(target("riscv.vector.tuple", <vscale x 1 x i8>, 5) undef, ptr %base, i32 %vl, i32 3)
657  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 1 x i8>, 5), i32} %0, 0
658  %2 = call <vscale x 1 x i8> @llvm.riscv.tuple.extract.nxv1i8.triscv.vector.tuple_nxv1i8_5t(target("riscv.vector.tuple", <vscale x 1 x i8>, 5) %1, i32 1)
659  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 1 x i8>, 5), i32} %0, 1
660  store i32 %3, ptr %outvl
661  ret <vscale x 1 x i8> %2
662}
663
664define <vscale x 1 x i8> @test_vlseg5ff_mask_nxv1i8_triscv.vector.tuple_nxv1i8_5t(target("riscv.vector.tuple", <vscale x 1 x i8>, 5) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
665; CHECK-LABEL: test_vlseg5ff_mask_nxv1i8_triscv.vector.tuple_nxv1i8_5t:
666; CHECK:       # %bb.0: # %entry
667; CHECK-NEXT:    vsetvli zero, a1, e8, mf8, ta, mu
668; CHECK-NEXT:    vmv1r.v v7, v8
669; CHECK-NEXT:    vmv1r.v v8, v9
670; CHECK-NEXT:    vmv1r.v v9, v10
671; CHECK-NEXT:    vmv1r.v v10, v11
672; CHECK-NEXT:    vmv1r.v v11, v12
673; CHECK-NEXT:    vlseg5e8ff.v v7, (a0), v0.t
674; CHECK-NEXT:    csrr a0, vl
675; CHECK-NEXT:    sw a0, 0(a2)
676; CHECK-NEXT:    ret
677entry:
678  %0 = tail call {target("riscv.vector.tuple", <vscale x 1 x i8>, 5), i32} @llvm.riscv.vlseg5ff.mask.triscv.vector.tuple_nxv1i8_5t.nxv1i1(target("riscv.vector.tuple", <vscale x 1 x i8>, 5) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 3)
679  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 1 x i8>, 5), i32} %0, 0
680  %2 = call <vscale x 1 x i8> @llvm.riscv.tuple.extract.nxv1i8.triscv.vector.tuple_nxv1i8_5t(target("riscv.vector.tuple", <vscale x 1 x i8>, 5) %1, i32 1)
681  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 1 x i8>, 5), i32} %0, 1
682  store i32 %3, ptr %outvl
683  ret <vscale x 1 x i8> %2
684}
685
686declare {target("riscv.vector.tuple", <vscale x 2 x i8>, 5), i32} @llvm.riscv.vlseg5ff.triscv.vector.tuple_nxv2i8_5t(target("riscv.vector.tuple", <vscale x 2 x i8>, 5), ptr, i32, i32)
687declare {target("riscv.vector.tuple", <vscale x 2 x i8>, 5), i32} @llvm.riscv.vlseg5ff.mask.triscv.vector.tuple_nxv2i8_5t.nxv2i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 5), ptr, <vscale x 2 x i1>, i32, i32, i32)
688
689define <vscale x 2 x i8> @test_vlseg5ff_nxv2i8_triscv.vector.tuple_nxv2i8_5t(ptr %base, i32 %vl, ptr %outvl) {
690; CHECK-LABEL: test_vlseg5ff_nxv2i8_triscv.vector.tuple_nxv2i8_5t:
691; CHECK:       # %bb.0: # %entry
692; CHECK-NEXT:    vsetvli zero, a1, e8, mf4, ta, ma
693; CHECK-NEXT:    vlseg5e8ff.v v7, (a0)
694; CHECK-NEXT:    csrr a0, vl
695; CHECK-NEXT:    sw a0, 0(a2)
696; CHECK-NEXT:    ret
697entry:
698  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 5), i32} @llvm.riscv.vlseg5ff.triscv.vector.tuple_nxv2i8_5t(target("riscv.vector.tuple", <vscale x 2 x i8>, 5) undef, ptr %base, i32 %vl, i32 3)
699  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 5), i32} %0, 0
700  %2 = call <vscale x 2 x i8> @llvm.riscv.tuple.extract.nxv2i8.triscv.vector.tuple_nxv2i8_5t(target("riscv.vector.tuple", <vscale x 2 x i8>, 5) %1, i32 1)
701  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 5), i32} %0, 1
702  store i32 %3, ptr %outvl
703  ret <vscale x 2 x i8> %2
704}
705
706define <vscale x 2 x i8> @test_vlseg5ff_mask_nxv2i8_triscv.vector.tuple_nxv2i8_5t(target("riscv.vector.tuple", <vscale x 2 x i8>, 5) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
707; CHECK-LABEL: test_vlseg5ff_mask_nxv2i8_triscv.vector.tuple_nxv2i8_5t:
708; CHECK:       # %bb.0: # %entry
709; CHECK-NEXT:    vsetvli zero, a1, e8, mf4, ta, mu
710; CHECK-NEXT:    vmv1r.v v7, v8
711; CHECK-NEXT:    vmv1r.v v8, v9
712; CHECK-NEXT:    vmv1r.v v9, v10
713; CHECK-NEXT:    vmv1r.v v10, v11
714; CHECK-NEXT:    vmv1r.v v11, v12
715; CHECK-NEXT:    vlseg5e8ff.v v7, (a0), v0.t
716; CHECK-NEXT:    csrr a0, vl
717; CHECK-NEXT:    sw a0, 0(a2)
718; CHECK-NEXT:    ret
719entry:
720  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 5), i32} @llvm.riscv.vlseg5ff.mask.triscv.vector.tuple_nxv2i8_5t.nxv2i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 5) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 3)
721  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 5), i32} %0, 0
722  %2 = call <vscale x 2 x i8> @llvm.riscv.tuple.extract.nxv2i8.triscv.vector.tuple_nxv2i8_5t(target("riscv.vector.tuple", <vscale x 2 x i8>, 5) %1, i32 1)
723  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 5), i32} %0, 1
724  store i32 %3, ptr %outvl
725  ret <vscale x 2 x i8> %2
726}
727
728declare {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} @llvm.riscv.vlseg5ff.triscv.vector.tuple_nxv4i8_5t(target("riscv.vector.tuple", <vscale x 4 x i8>, 5), ptr, i32, i32)
729declare {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} @llvm.riscv.vlseg5ff.mask.triscv.vector.tuple_nxv4i8_5t.nxv4i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 5), ptr, <vscale x 4 x i1>, i32, i32, i32)
730
731define <vscale x 4 x i8> @test_vlseg5ff_nxv4i8_triscv.vector.tuple_nxv4i8_5t(ptr %base, i32 %vl, ptr %outvl) {
732; CHECK-LABEL: test_vlseg5ff_nxv4i8_triscv.vector.tuple_nxv4i8_5t:
733; CHECK:       # %bb.0: # %entry
734; CHECK-NEXT:    vsetvli zero, a1, e8, mf2, ta, ma
735; CHECK-NEXT:    vlseg5e8ff.v v7, (a0)
736; CHECK-NEXT:    csrr a0, vl
737; CHECK-NEXT:    sw a0, 0(a2)
738; CHECK-NEXT:    ret
739entry:
740  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} @llvm.riscv.vlseg5ff.triscv.vector.tuple_nxv4i8_5t(target("riscv.vector.tuple", <vscale x 4 x i8>, 5) undef, ptr %base, i32 %vl, i32 3)
741  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} %0, 0
742  %2 = call <vscale x 4 x i8> @llvm.riscv.tuple.extract.nxv4i8.triscv.vector.tuple_nxv4i8_5t(target("riscv.vector.tuple", <vscale x 4 x i8>, 5) %1, i32 1)
743  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} %0, 1
744  store i32 %3, ptr %outvl
745  ret <vscale x 4 x i8> %2
746}
747
748define <vscale x 4 x i8> @test_vlseg5ff_mask_nxv4i8_triscv.vector.tuple_nxv4i8_5t(target("riscv.vector.tuple", <vscale x 4 x i8>, 5) %val, ptr %base, i32 %vl, <vscale x 4 x i1> %mask, ptr %outvl) {
749; CHECK-LABEL: test_vlseg5ff_mask_nxv4i8_triscv.vector.tuple_nxv4i8_5t:
750; CHECK:       # %bb.0: # %entry
751; CHECK-NEXT:    vsetvli zero, a1, e8, mf2, ta, mu
752; CHECK-NEXT:    vmv1r.v v7, v8
753; CHECK-NEXT:    vmv1r.v v8, v9
754; CHECK-NEXT:    vmv1r.v v9, v10
755; CHECK-NEXT:    vmv1r.v v10, v11
756; CHECK-NEXT:    vmv1r.v v11, v12
757; CHECK-NEXT:    vlseg5e8ff.v v7, (a0), v0.t
758; CHECK-NEXT:    csrr a0, vl
759; CHECK-NEXT:    sw a0, 0(a2)
760; CHECK-NEXT:    ret
761entry:
762  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} @llvm.riscv.vlseg5ff.mask.triscv.vector.tuple_nxv4i8_5t.nxv4i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 5) %val, ptr %base, <vscale x 4 x i1> %mask, i32 %vl, i32 1, i32 3)
763  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} %0, 0
764  %2 = call <vscale x 4 x i8> @llvm.riscv.tuple.extract.nxv4i8.triscv.vector.tuple_nxv4i8_5t(target("riscv.vector.tuple", <vscale x 4 x i8>, 5) %1, i32 1)
765  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} %0, 1
766  store i32 %3, ptr %outvl
767  ret <vscale x 4 x i8> %2
768}
769
770declare {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} @llvm.riscv.vlseg5ff.triscv.vector.tuple_nxv8i8_5t(target("riscv.vector.tuple", <vscale x 8 x i8>, 5), ptr, i32, i32)
771declare {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} @llvm.riscv.vlseg5ff.mask.triscv.vector.tuple_nxv8i8_5t.nxv8i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 5), ptr, <vscale x 8 x i1>, i32, i32, i32)
772
773define <vscale x 8 x i8> @test_vlseg5ff_nxv8i8_triscv.vector.tuple_nxv8i8_5t(ptr %base, i32 %vl, ptr %outvl) {
774; CHECK-LABEL: test_vlseg5ff_nxv8i8_triscv.vector.tuple_nxv8i8_5t:
775; CHECK:       # %bb.0: # %entry
776; CHECK-NEXT:    vsetvli zero, a1, e8, m1, ta, ma
777; CHECK-NEXT:    vlseg5e8ff.v v7, (a0)
778; CHECK-NEXT:    csrr a0, vl
779; CHECK-NEXT:    sw a0, 0(a2)
780; CHECK-NEXT:    ret
781entry:
782  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} @llvm.riscv.vlseg5ff.triscv.vector.tuple_nxv8i8_5t(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) undef, ptr %base, i32 %vl, i32 3)
783  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} %0, 0
784  %2 = call <vscale x 8 x i8> @llvm.riscv.tuple.extract.nxv8i8.triscv.vector.tuple_nxv8i8_5t(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) %1, i32 1)
785  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} %0, 1
786  store i32 %3, ptr %outvl
787  ret <vscale x 8 x i8> %2
788}
789
790define <vscale x 8 x i8> @test_vlseg5ff_mask_nxv8i8_triscv.vector.tuple_nxv8i8_5t(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) %val, ptr %base, i32 %vl, <vscale x 8 x i1> %mask, ptr %outvl) {
791; CHECK-LABEL: test_vlseg5ff_mask_nxv8i8_triscv.vector.tuple_nxv8i8_5t:
792; CHECK:       # %bb.0: # %entry
793; CHECK-NEXT:    vsetvli zero, a1, e8, m1, ta, mu
794; CHECK-NEXT:    vmv1r.v v7, v8
795; CHECK-NEXT:    vmv1r.v v8, v9
796; CHECK-NEXT:    vmv1r.v v9, v10
797; CHECK-NEXT:    vmv1r.v v10, v11
798; CHECK-NEXT:    vmv1r.v v11, v12
799; CHECK-NEXT:    vlseg5e8ff.v v7, (a0), v0.t
800; CHECK-NEXT:    csrr a0, vl
801; CHECK-NEXT:    sw a0, 0(a2)
802; CHECK-NEXT:    ret
803entry:
804  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} @llvm.riscv.vlseg5ff.mask.triscv.vector.tuple_nxv8i8_5t.nxv8i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) %val, ptr %base, <vscale x 8 x i1> %mask, i32 %vl, i32 1, i32 3)
805  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} %0, 0
806  %2 = call <vscale x 8 x i8> @llvm.riscv.tuple.extract.nxv8i8.triscv.vector.tuple_nxv8i8_5t(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) %1, i32 1)
807  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} %0, 1
808  store i32 %3, ptr %outvl
809  ret <vscale x 8 x i8> %2
810}
811
812declare {target("riscv.vector.tuple", <vscale x 1 x i8>, 6), i32} @llvm.riscv.vlseg6ff.triscv.vector.tuple_nxv1i8_6t(target("riscv.vector.tuple", <vscale x 1 x i8>, 6), ptr, i32, i32)
813declare {target("riscv.vector.tuple", <vscale x 1 x i8>, 6), i32} @llvm.riscv.vlseg6ff.mask.triscv.vector.tuple_nxv1i8_6t.nxv1i1(target("riscv.vector.tuple", <vscale x 1 x i8>, 6), ptr, <vscale x 1 x i1>, i32, i32, i32)
814
815define <vscale x 1 x i8> @test_vlseg6ff_nxv1i8_triscv.vector.tuple_nxv1i8_6t(ptr %base, i32 %vl, ptr %outvl) {
816; CHECK-LABEL: test_vlseg6ff_nxv1i8_triscv.vector.tuple_nxv1i8_6t:
817; CHECK:       # %bb.0: # %entry
818; CHECK-NEXT:    vsetvli zero, a1, e8, mf8, ta, ma
819; CHECK-NEXT:    vlseg6e8ff.v v7, (a0)
820; CHECK-NEXT:    csrr a0, vl
821; CHECK-NEXT:    sw a0, 0(a2)
822; CHECK-NEXT:    ret
823entry:
824  %0 = tail call {target("riscv.vector.tuple", <vscale x 1 x i8>, 6), i32} @llvm.riscv.vlseg6ff.triscv.vector.tuple_nxv1i8_6t(target("riscv.vector.tuple", <vscale x 1 x i8>, 6) undef, ptr %base, i32 %vl, i32 3)
825  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 1 x i8>, 6), i32} %0, 0
826  %2 = call <vscale x 1 x i8> @llvm.riscv.tuple.extract.nxv1i8.triscv.vector.tuple_nxv1i8_6t(target("riscv.vector.tuple", <vscale x 1 x i8>, 6) %1, i32 1)
827  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 1 x i8>, 6), i32} %0, 1
828  store i32 %3, ptr %outvl
829  ret <vscale x 1 x i8> %2
830}
831
832define <vscale x 1 x i8> @test_vlseg6ff_mask_nxv1i8_triscv.vector.tuple_nxv1i8_6t(target("riscv.vector.tuple", <vscale x 1 x i8>, 6) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
833; CHECK-LABEL: test_vlseg6ff_mask_nxv1i8_triscv.vector.tuple_nxv1i8_6t:
834; CHECK:       # %bb.0: # %entry
835; CHECK-NEXT:    vsetvli zero, a1, e8, mf8, ta, mu
836; CHECK-NEXT:    vmv1r.v v7, v8
837; CHECK-NEXT:    vmv1r.v v8, v9
838; CHECK-NEXT:    vmv1r.v v9, v10
839; CHECK-NEXT:    vmv1r.v v10, v11
840; CHECK-NEXT:    vmv1r.v v11, v12
841; CHECK-NEXT:    vmv1r.v v12, v13
842; CHECK-NEXT:    vlseg6e8ff.v v7, (a0), v0.t
843; CHECK-NEXT:    csrr a0, vl
844; CHECK-NEXT:    sw a0, 0(a2)
845; CHECK-NEXT:    ret
846entry:
847  %0 = tail call {target("riscv.vector.tuple", <vscale x 1 x i8>, 6), i32} @llvm.riscv.vlseg6ff.mask.triscv.vector.tuple_nxv1i8_6t.nxv1i1(target("riscv.vector.tuple", <vscale x 1 x i8>, 6) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 3)
848  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 1 x i8>, 6), i32} %0, 0
849  %2 = call <vscale x 1 x i8> @llvm.riscv.tuple.extract.nxv1i8.triscv.vector.tuple_nxv1i8_6t(target("riscv.vector.tuple", <vscale x 1 x i8>, 6) %1, i32 1)
850  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 1 x i8>, 6), i32} %0, 1
851  store i32 %3, ptr %outvl
852  ret <vscale x 1 x i8> %2
853}
854
855declare {target("riscv.vector.tuple", <vscale x 2 x i8>, 6), i32} @llvm.riscv.vlseg6ff.triscv.vector.tuple_nxv2i8_6t(target("riscv.vector.tuple", <vscale x 2 x i8>, 6), ptr, i32, i32)
856declare {target("riscv.vector.tuple", <vscale x 2 x i8>, 6), i32} @llvm.riscv.vlseg6ff.mask.triscv.vector.tuple_nxv2i8_6t.nxv2i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 6), ptr, <vscale x 2 x i1>, i32, i32, i32)
857
858define <vscale x 2 x i8> @test_vlseg6ff_nxv2i8_triscv.vector.tuple_nxv2i8_6t(ptr %base, i32 %vl, ptr %outvl) {
859; CHECK-LABEL: test_vlseg6ff_nxv2i8_triscv.vector.tuple_nxv2i8_6t:
860; CHECK:       # %bb.0: # %entry
861; CHECK-NEXT:    vsetvli zero, a1, e8, mf4, ta, ma
862; CHECK-NEXT:    vlseg6e8ff.v v7, (a0)
863; CHECK-NEXT:    csrr a0, vl
864; CHECK-NEXT:    sw a0, 0(a2)
865; CHECK-NEXT:    ret
866entry:
867  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 6), i32} @llvm.riscv.vlseg6ff.triscv.vector.tuple_nxv2i8_6t(target("riscv.vector.tuple", <vscale x 2 x i8>, 6) undef, ptr %base, i32 %vl, i32 3)
868  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 6), i32} %0, 0
869  %2 = call <vscale x 2 x i8> @llvm.riscv.tuple.extract.nxv2i8.triscv.vector.tuple_nxv2i8_6t(target("riscv.vector.tuple", <vscale x 2 x i8>, 6) %1, i32 1)
870  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 6), i32} %0, 1
871  store i32 %3, ptr %outvl
872  ret <vscale x 2 x i8> %2
873}
874
875define <vscale x 2 x i8> @test_vlseg6ff_mask_nxv2i8_triscv.vector.tuple_nxv2i8_6t(target("riscv.vector.tuple", <vscale x 2 x i8>, 6) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
876; CHECK-LABEL: test_vlseg6ff_mask_nxv2i8_triscv.vector.tuple_nxv2i8_6t:
877; CHECK:       # %bb.0: # %entry
878; CHECK-NEXT:    vsetvli zero, a1, e8, mf4, ta, mu
879; CHECK-NEXT:    vmv1r.v v7, v8
880; CHECK-NEXT:    vmv1r.v v8, v9
881; CHECK-NEXT:    vmv1r.v v9, v10
882; CHECK-NEXT:    vmv1r.v v10, v11
883; CHECK-NEXT:    vmv1r.v v11, v12
884; CHECK-NEXT:    vmv1r.v v12, v13
885; CHECK-NEXT:    vlseg6e8ff.v v7, (a0), v0.t
886; CHECK-NEXT:    csrr a0, vl
887; CHECK-NEXT:    sw a0, 0(a2)
888; CHECK-NEXT:    ret
889entry:
890  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 6), i32} @llvm.riscv.vlseg6ff.mask.triscv.vector.tuple_nxv2i8_6t.nxv2i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 6) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 3)
891  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 6), i32} %0, 0
892  %2 = call <vscale x 2 x i8> @llvm.riscv.tuple.extract.nxv2i8.triscv.vector.tuple_nxv2i8_6t(target("riscv.vector.tuple", <vscale x 2 x i8>, 6) %1, i32 1)
893  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 6), i32} %0, 1
894  store i32 %3, ptr %outvl
895  ret <vscale x 2 x i8> %2
896}
897
898declare {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} @llvm.riscv.vlseg6ff.triscv.vector.tuple_nxv4i8_6t(target("riscv.vector.tuple", <vscale x 4 x i8>, 6), ptr, i32, i32)
899declare {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} @llvm.riscv.vlseg6ff.mask.triscv.vector.tuple_nxv4i8_6t.nxv4i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 6), ptr, <vscale x 4 x i1>, i32, i32, i32)
900
901define <vscale x 4 x i8> @test_vlseg6ff_nxv4i8_triscv.vector.tuple_nxv4i8_6t(ptr %base, i32 %vl, ptr %outvl) {
902; CHECK-LABEL: test_vlseg6ff_nxv4i8_triscv.vector.tuple_nxv4i8_6t:
903; CHECK:       # %bb.0: # %entry
904; CHECK-NEXT:    vsetvli zero, a1, e8, mf2, ta, ma
905; CHECK-NEXT:    vlseg6e8ff.v v7, (a0)
906; CHECK-NEXT:    csrr a0, vl
907; CHECK-NEXT:    sw a0, 0(a2)
908; CHECK-NEXT:    ret
909entry:
910  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} @llvm.riscv.vlseg6ff.triscv.vector.tuple_nxv4i8_6t(target("riscv.vector.tuple", <vscale x 4 x i8>, 6) undef, ptr %base, i32 %vl, i32 3)
911  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} %0, 0
912  %2 = call <vscale x 4 x i8> @llvm.riscv.tuple.extract.nxv4i8.triscv.vector.tuple_nxv4i8_6t(target("riscv.vector.tuple", <vscale x 4 x i8>, 6) %1, i32 1)
913  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} %0, 1
914  store i32 %3, ptr %outvl
915  ret <vscale x 4 x i8> %2
916}
917
918define <vscale x 4 x i8> @test_vlseg6ff_mask_nxv4i8_triscv.vector.tuple_nxv4i8_6t(target("riscv.vector.tuple", <vscale x 4 x i8>, 6) %val, ptr %base, i32 %vl, <vscale x 4 x i1> %mask, ptr %outvl) {
919; CHECK-LABEL: test_vlseg6ff_mask_nxv4i8_triscv.vector.tuple_nxv4i8_6t:
920; CHECK:       # %bb.0: # %entry
921; CHECK-NEXT:    vsetvli zero, a1, e8, mf2, ta, mu
922; CHECK-NEXT:    vmv1r.v v7, v8
923; CHECK-NEXT:    vmv1r.v v8, v9
924; CHECK-NEXT:    vmv1r.v v9, v10
925; CHECK-NEXT:    vmv1r.v v10, v11
926; CHECK-NEXT:    vmv1r.v v11, v12
927; CHECK-NEXT:    vmv1r.v v12, v13
928; CHECK-NEXT:    vlseg6e8ff.v v7, (a0), v0.t
929; CHECK-NEXT:    csrr a0, vl
930; CHECK-NEXT:    sw a0, 0(a2)
931; CHECK-NEXT:    ret
932entry:
933  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} @llvm.riscv.vlseg6ff.mask.triscv.vector.tuple_nxv4i8_6t.nxv4i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 6) %val, ptr %base, <vscale x 4 x i1> %mask, i32 %vl, i32 1, i32 3)
934  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} %0, 0
935  %2 = call <vscale x 4 x i8> @llvm.riscv.tuple.extract.nxv4i8.triscv.vector.tuple_nxv4i8_6t(target("riscv.vector.tuple", <vscale x 4 x i8>, 6) %1, i32 1)
936  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} %0, 1
937  store i32 %3, ptr %outvl
938  ret <vscale x 4 x i8> %2
939}
940
941declare {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} @llvm.riscv.vlseg6ff.triscv.vector.tuple_nxv8i8_6t(target("riscv.vector.tuple", <vscale x 8 x i8>, 6), ptr, i32, i32)
942declare {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} @llvm.riscv.vlseg6ff.mask.triscv.vector.tuple_nxv8i8_6t.nxv8i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 6), ptr, <vscale x 8 x i1>, i32, i32, i32)
943
944define <vscale x 8 x i8> @test_vlseg6ff_nxv8i8_triscv.vector.tuple_nxv8i8_6t(ptr %base, i32 %vl, ptr %outvl) {
945; CHECK-LABEL: test_vlseg6ff_nxv8i8_triscv.vector.tuple_nxv8i8_6t:
946; CHECK:       # %bb.0: # %entry
947; CHECK-NEXT:    vsetvli zero, a1, e8, m1, ta, ma
948; CHECK-NEXT:    vlseg6e8ff.v v7, (a0)
949; CHECK-NEXT:    csrr a0, vl
950; CHECK-NEXT:    sw a0, 0(a2)
951; CHECK-NEXT:    ret
952entry:
953  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} @llvm.riscv.vlseg6ff.triscv.vector.tuple_nxv8i8_6t(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) undef, ptr %base, i32 %vl, i32 3)
954  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} %0, 0
955  %2 = call <vscale x 8 x i8> @llvm.riscv.tuple.extract.nxv8i8.triscv.vector.tuple_nxv8i8_6t(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) %1, i32 1)
956  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} %0, 1
957  store i32 %3, ptr %outvl
958  ret <vscale x 8 x i8> %2
959}
960
961define <vscale x 8 x i8> @test_vlseg6ff_mask_nxv8i8_triscv.vector.tuple_nxv8i8_6t(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) %val, ptr %base, i32 %vl, <vscale x 8 x i1> %mask, ptr %outvl) {
962; CHECK-LABEL: test_vlseg6ff_mask_nxv8i8_triscv.vector.tuple_nxv8i8_6t:
963; CHECK:       # %bb.0: # %entry
964; CHECK-NEXT:    vsetvli zero, a1, e8, m1, ta, mu
965; CHECK-NEXT:    vmv1r.v v7, v8
966; CHECK-NEXT:    vmv1r.v v8, v9
967; CHECK-NEXT:    vmv1r.v v9, v10
968; CHECK-NEXT:    vmv1r.v v10, v11
969; CHECK-NEXT:    vmv1r.v v11, v12
970; CHECK-NEXT:    vmv1r.v v12, v13
971; CHECK-NEXT:    vlseg6e8ff.v v7, (a0), v0.t
972; CHECK-NEXT:    csrr a0, vl
973; CHECK-NEXT:    sw a0, 0(a2)
974; CHECK-NEXT:    ret
975entry:
976  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} @llvm.riscv.vlseg6ff.mask.triscv.vector.tuple_nxv8i8_6t.nxv8i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) %val, ptr %base, <vscale x 8 x i1> %mask, i32 %vl, i32 1, i32 3)
977  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} %0, 0
978  %2 = call <vscale x 8 x i8> @llvm.riscv.tuple.extract.nxv8i8.triscv.vector.tuple_nxv8i8_6t(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) %1, i32 1)
979  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} %0, 1
980  store i32 %3, ptr %outvl
981  ret <vscale x 8 x i8> %2
982}
983
984declare {target("riscv.vector.tuple", <vscale x 1 x i8>, 7), i32} @llvm.riscv.vlseg7ff.triscv.vector.tuple_nxv1i8_7t(target("riscv.vector.tuple", <vscale x 1 x i8>, 7), ptr, i32, i32)
985declare {target("riscv.vector.tuple", <vscale x 1 x i8>, 7), i32} @llvm.riscv.vlseg7ff.mask.triscv.vector.tuple_nxv1i8_7t.nxv1i1(target("riscv.vector.tuple", <vscale x 1 x i8>, 7), ptr, <vscale x 1 x i1>, i32, i32, i32)
986
987define <vscale x 1 x i8> @test_vlseg7ff_nxv1i8_triscv.vector.tuple_nxv1i8_7t(ptr %base, i32 %vl, ptr %outvl) {
988; CHECK-LABEL: test_vlseg7ff_nxv1i8_triscv.vector.tuple_nxv1i8_7t:
989; CHECK:       # %bb.0: # %entry
990; CHECK-NEXT:    vsetvli zero, a1, e8, mf8, ta, ma
991; CHECK-NEXT:    vlseg7e8ff.v v7, (a0)
992; CHECK-NEXT:    csrr a0, vl
993; CHECK-NEXT:    sw a0, 0(a2)
994; CHECK-NEXT:    ret
995entry:
996  %0 = tail call {target("riscv.vector.tuple", <vscale x 1 x i8>, 7), i32} @llvm.riscv.vlseg7ff.triscv.vector.tuple_nxv1i8_7t(target("riscv.vector.tuple", <vscale x 1 x i8>, 7) undef, ptr %base, i32 %vl, i32 3)
997  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 1 x i8>, 7), i32} %0, 0
998  %2 = call <vscale x 1 x i8> @llvm.riscv.tuple.extract.nxv1i8.triscv.vector.tuple_nxv1i8_7t(target("riscv.vector.tuple", <vscale x 1 x i8>, 7) %1, i32 1)
999  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 1 x i8>, 7), i32} %0, 1
1000  store i32 %3, ptr %outvl
1001  ret <vscale x 1 x i8> %2
1002}
1003
1004define <vscale x 1 x i8> @test_vlseg7ff_mask_nxv1i8_triscv.vector.tuple_nxv1i8_7t(target("riscv.vector.tuple", <vscale x 1 x i8>, 7) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
1005; CHECK-LABEL: test_vlseg7ff_mask_nxv1i8_triscv.vector.tuple_nxv1i8_7t:
1006; CHECK:       # %bb.0: # %entry
1007; CHECK-NEXT:    vsetvli zero, a1, e8, mf8, ta, mu
1008; CHECK-NEXT:    vmv1r.v v7, v8
1009; CHECK-NEXT:    vmv1r.v v8, v9
1010; CHECK-NEXT:    vmv1r.v v9, v10
1011; CHECK-NEXT:    vmv1r.v v10, v11
1012; CHECK-NEXT:    vmv1r.v v11, v12
1013; CHECK-NEXT:    vmv1r.v v12, v13
1014; CHECK-NEXT:    vmv1r.v v13, v14
1015; CHECK-NEXT:    vlseg7e8ff.v v7, (a0), v0.t
1016; CHECK-NEXT:    csrr a0, vl
1017; CHECK-NEXT:    sw a0, 0(a2)
1018; CHECK-NEXT:    ret
1019entry:
1020  %0 = tail call {target("riscv.vector.tuple", <vscale x 1 x i8>, 7), i32} @llvm.riscv.vlseg7ff.mask.triscv.vector.tuple_nxv1i8_7t.nxv1i1(target("riscv.vector.tuple", <vscale x 1 x i8>, 7) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 3)
1021  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 1 x i8>, 7), i32} %0, 0
1022  %2 = call <vscale x 1 x i8> @llvm.riscv.tuple.extract.nxv1i8.triscv.vector.tuple_nxv1i8_7t(target("riscv.vector.tuple", <vscale x 1 x i8>, 7) %1, i32 1)
1023  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 1 x i8>, 7), i32} %0, 1
1024  store i32 %3, ptr %outvl
1025  ret <vscale x 1 x i8> %2
1026}
1027
1028declare {target("riscv.vector.tuple", <vscale x 2 x i8>, 7), i32} @llvm.riscv.vlseg7ff.triscv.vector.tuple_nxv2i8_7t(target("riscv.vector.tuple", <vscale x 2 x i8>, 7), ptr, i32, i32)
1029declare {target("riscv.vector.tuple", <vscale x 2 x i8>, 7), i32} @llvm.riscv.vlseg7ff.mask.triscv.vector.tuple_nxv2i8_7t.nxv2i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 7), ptr, <vscale x 2 x i1>, i32, i32, i32)
1030
1031define <vscale x 2 x i8> @test_vlseg7ff_nxv2i8_triscv.vector.tuple_nxv2i8_7t(ptr %base, i32 %vl, ptr %outvl) {
1032; CHECK-LABEL: test_vlseg7ff_nxv2i8_triscv.vector.tuple_nxv2i8_7t:
1033; CHECK:       # %bb.0: # %entry
1034; CHECK-NEXT:    vsetvli zero, a1, e8, mf4, ta, ma
1035; CHECK-NEXT:    vlseg7e8ff.v v7, (a0)
1036; CHECK-NEXT:    csrr a0, vl
1037; CHECK-NEXT:    sw a0, 0(a2)
1038; CHECK-NEXT:    ret
1039entry:
1040  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 7), i32} @llvm.riscv.vlseg7ff.triscv.vector.tuple_nxv2i8_7t(target("riscv.vector.tuple", <vscale x 2 x i8>, 7) undef, ptr %base, i32 %vl, i32 3)
1041  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 7), i32} %0, 0
1042  %2 = call <vscale x 2 x i8> @llvm.riscv.tuple.extract.nxv2i8.triscv.vector.tuple_nxv2i8_7t(target("riscv.vector.tuple", <vscale x 2 x i8>, 7) %1, i32 1)
1043  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 7), i32} %0, 1
1044  store i32 %3, ptr %outvl
1045  ret <vscale x 2 x i8> %2
1046}
1047
1048define <vscale x 2 x i8> @test_vlseg7ff_mask_nxv2i8_triscv.vector.tuple_nxv2i8_7t(target("riscv.vector.tuple", <vscale x 2 x i8>, 7) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
1049; CHECK-LABEL: test_vlseg7ff_mask_nxv2i8_triscv.vector.tuple_nxv2i8_7t:
1050; CHECK:       # %bb.0: # %entry
1051; CHECK-NEXT:    vsetvli zero, a1, e8, mf4, ta, mu
1052; CHECK-NEXT:    vmv1r.v v7, v8
1053; CHECK-NEXT:    vmv1r.v v8, v9
1054; CHECK-NEXT:    vmv1r.v v9, v10
1055; CHECK-NEXT:    vmv1r.v v10, v11
1056; CHECK-NEXT:    vmv1r.v v11, v12
1057; CHECK-NEXT:    vmv1r.v v12, v13
1058; CHECK-NEXT:    vmv1r.v v13, v14
1059; CHECK-NEXT:    vlseg7e8ff.v v7, (a0), v0.t
1060; CHECK-NEXT:    csrr a0, vl
1061; CHECK-NEXT:    sw a0, 0(a2)
1062; CHECK-NEXT:    ret
1063entry:
1064  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 7), i32} @llvm.riscv.vlseg7ff.mask.triscv.vector.tuple_nxv2i8_7t.nxv2i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 7) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 3)
1065  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 7), i32} %0, 0
1066  %2 = call <vscale x 2 x i8> @llvm.riscv.tuple.extract.nxv2i8.triscv.vector.tuple_nxv2i8_7t(target("riscv.vector.tuple", <vscale x 2 x i8>, 7) %1, i32 1)
1067  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 7), i32} %0, 1
1068  store i32 %3, ptr %outvl
1069  ret <vscale x 2 x i8> %2
1070}
1071
1072declare {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} @llvm.riscv.vlseg7ff.triscv.vector.tuple_nxv4i8_7t(target("riscv.vector.tuple", <vscale x 4 x i8>, 7), ptr, i32, i32)
1073declare {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} @llvm.riscv.vlseg7ff.mask.triscv.vector.tuple_nxv4i8_7t.nxv4i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 7), ptr, <vscale x 4 x i1>, i32, i32, i32)
1074
1075define <vscale x 4 x i8> @test_vlseg7ff_nxv4i8_triscv.vector.tuple_nxv4i8_7t(ptr %base, i32 %vl, ptr %outvl) {
1076; CHECK-LABEL: test_vlseg7ff_nxv4i8_triscv.vector.tuple_nxv4i8_7t:
1077; CHECK:       # %bb.0: # %entry
1078; CHECK-NEXT:    vsetvli zero, a1, e8, mf2, ta, ma
1079; CHECK-NEXT:    vlseg7e8ff.v v7, (a0)
1080; CHECK-NEXT:    csrr a0, vl
1081; CHECK-NEXT:    sw a0, 0(a2)
1082; CHECK-NEXT:    ret
1083entry:
1084  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} @llvm.riscv.vlseg7ff.triscv.vector.tuple_nxv4i8_7t(target("riscv.vector.tuple", <vscale x 4 x i8>, 7) undef, ptr %base, i32 %vl, i32 3)
1085  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} %0, 0
1086  %2 = call <vscale x 4 x i8> @llvm.riscv.tuple.extract.nxv4i8.triscv.vector.tuple_nxv4i8_7t(target("riscv.vector.tuple", <vscale x 4 x i8>, 7) %1, i32 1)
1087  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} %0, 1
1088  store i32 %3, ptr %outvl
1089  ret <vscale x 4 x i8> %2
1090}
1091
1092define <vscale x 4 x i8> @test_vlseg7ff_mask_nxv4i8_triscv.vector.tuple_nxv4i8_7t(target("riscv.vector.tuple", <vscale x 4 x i8>, 7) %val, ptr %base, i32 %vl, <vscale x 4 x i1> %mask, ptr %outvl) {
1093; CHECK-LABEL: test_vlseg7ff_mask_nxv4i8_triscv.vector.tuple_nxv4i8_7t:
1094; CHECK:       # %bb.0: # %entry
1095; CHECK-NEXT:    vsetvli zero, a1, e8, mf2, ta, mu
1096; CHECK-NEXT:    vmv1r.v v7, v8
1097; CHECK-NEXT:    vmv1r.v v8, v9
1098; CHECK-NEXT:    vmv1r.v v9, v10
1099; CHECK-NEXT:    vmv1r.v v10, v11
1100; CHECK-NEXT:    vmv1r.v v11, v12
1101; CHECK-NEXT:    vmv1r.v v12, v13
1102; CHECK-NEXT:    vmv1r.v v13, v14
1103; CHECK-NEXT:    vlseg7e8ff.v v7, (a0), v0.t
1104; CHECK-NEXT:    csrr a0, vl
1105; CHECK-NEXT:    sw a0, 0(a2)
1106; CHECK-NEXT:    ret
1107entry:
1108  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} @llvm.riscv.vlseg7ff.mask.triscv.vector.tuple_nxv4i8_7t.nxv4i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 7) %val, ptr %base, <vscale x 4 x i1> %mask, i32 %vl, i32 1, i32 3)
1109  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} %0, 0
1110  %2 = call <vscale x 4 x i8> @llvm.riscv.tuple.extract.nxv4i8.triscv.vector.tuple_nxv4i8_7t(target("riscv.vector.tuple", <vscale x 4 x i8>, 7) %1, i32 1)
1111  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} %0, 1
1112  store i32 %3, ptr %outvl
1113  ret <vscale x 4 x i8> %2
1114}
1115
1116declare {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} @llvm.riscv.vlseg7ff.triscv.vector.tuple_nxv8i8_7t(target("riscv.vector.tuple", <vscale x 8 x i8>, 7), ptr, i32, i32)
1117declare {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} @llvm.riscv.vlseg7ff.mask.triscv.vector.tuple_nxv8i8_7t.nxv8i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 7), ptr, <vscale x 8 x i1>, i32, i32, i32)
1118
1119define <vscale x 8 x i8> @test_vlseg7ff_nxv8i8_triscv.vector.tuple_nxv8i8_7t(ptr %base, i32 %vl, ptr %outvl) {
1120; CHECK-LABEL: test_vlseg7ff_nxv8i8_triscv.vector.tuple_nxv8i8_7t:
1121; CHECK:       # %bb.0: # %entry
1122; CHECK-NEXT:    vsetvli zero, a1, e8, m1, ta, ma
1123; CHECK-NEXT:    vlseg7e8ff.v v7, (a0)
1124; CHECK-NEXT:    csrr a0, vl
1125; CHECK-NEXT:    sw a0, 0(a2)
1126; CHECK-NEXT:    ret
1127entry:
1128  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} @llvm.riscv.vlseg7ff.triscv.vector.tuple_nxv8i8_7t(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) undef, ptr %base, i32 %vl, i32 3)
1129  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} %0, 0
1130  %2 = call <vscale x 8 x i8> @llvm.riscv.tuple.extract.nxv8i8.triscv.vector.tuple_nxv8i8_7t(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) %1, i32 1)
1131  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} %0, 1
1132  store i32 %3, ptr %outvl
1133  ret <vscale x 8 x i8> %2
1134}
1135
1136define <vscale x 8 x i8> @test_vlseg7ff_mask_nxv8i8_triscv.vector.tuple_nxv8i8_7t(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) %val, ptr %base, i32 %vl, <vscale x 8 x i1> %mask, ptr %outvl) {
1137; CHECK-LABEL: test_vlseg7ff_mask_nxv8i8_triscv.vector.tuple_nxv8i8_7t:
1138; CHECK:       # %bb.0: # %entry
1139; CHECK-NEXT:    vsetvli zero, a1, e8, m1, ta, mu
1140; CHECK-NEXT:    vmv1r.v v7, v8
1141; CHECK-NEXT:    vmv1r.v v8, v9
1142; CHECK-NEXT:    vmv1r.v v9, v10
1143; CHECK-NEXT:    vmv1r.v v10, v11
1144; CHECK-NEXT:    vmv1r.v v11, v12
1145; CHECK-NEXT:    vmv1r.v v12, v13
1146; CHECK-NEXT:    vmv1r.v v13, v14
1147; CHECK-NEXT:    vlseg7e8ff.v v7, (a0), v0.t
1148; CHECK-NEXT:    csrr a0, vl
1149; CHECK-NEXT:    sw a0, 0(a2)
1150; CHECK-NEXT:    ret
1151entry:
1152  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} @llvm.riscv.vlseg7ff.mask.triscv.vector.tuple_nxv8i8_7t.nxv8i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) %val, ptr %base, <vscale x 8 x i1> %mask, i32 %vl, i32 1, i32 3)
1153  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} %0, 0
1154  %2 = call <vscale x 8 x i8> @llvm.riscv.tuple.extract.nxv8i8.triscv.vector.tuple_nxv8i8_7t(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) %1, i32 1)
1155  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} %0, 1
1156  store i32 %3, ptr %outvl
1157  ret <vscale x 8 x i8> %2
1158}
1159
1160declare {target("riscv.vector.tuple", <vscale x 1 x i8>, 8), i32} @llvm.riscv.vlseg8ff.triscv.vector.tuple_nxv1i8_8t(target("riscv.vector.tuple", <vscale x 1 x i8>, 8), ptr, i32, i32)
1161declare {target("riscv.vector.tuple", <vscale x 1 x i8>, 8), i32} @llvm.riscv.vlseg8ff.mask.triscv.vector.tuple_nxv1i8_8t.nxv1i1(target("riscv.vector.tuple", <vscale x 1 x i8>, 8), ptr, <vscale x 1 x i1>, i32, i32, i32)
1162
1163define <vscale x 1 x i8> @test_vlseg8ff_nxv1i8_triscv.vector.tuple_nxv1i8_8t(ptr %base, i32 %vl, ptr %outvl) {
1164; CHECK-LABEL: test_vlseg8ff_nxv1i8_triscv.vector.tuple_nxv1i8_8t:
1165; CHECK:       # %bb.0: # %entry
1166; CHECK-NEXT:    vsetvli zero, a1, e8, mf8, ta, ma
1167; CHECK-NEXT:    vlseg8e8ff.v v7, (a0)
1168; CHECK-NEXT:    csrr a0, vl
1169; CHECK-NEXT:    sw a0, 0(a2)
1170; CHECK-NEXT:    ret
1171entry:
1172  %0 = tail call {target("riscv.vector.tuple", <vscale x 1 x i8>, 8), i32} @llvm.riscv.vlseg8ff.triscv.vector.tuple_nxv1i8_8t(target("riscv.vector.tuple", <vscale x 1 x i8>, 8) undef, ptr %base, i32 %vl, i32 3)
1173  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 1 x i8>, 8), i32} %0, 0
1174  %2 = call <vscale x 1 x i8> @llvm.riscv.tuple.extract.nxv1i8.triscv.vector.tuple_nxv1i8_8t(target("riscv.vector.tuple", <vscale x 1 x i8>, 8) %1, i32 1)
1175  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 1 x i8>, 8), i32} %0, 1
1176  store i32 %3, ptr %outvl
1177  ret <vscale x 1 x i8> %2
1178}
1179
1180define <vscale x 1 x i8> @test_vlseg8ff_mask_nxv1i8_triscv.vector.tuple_nxv1i8_8t(target("riscv.vector.tuple", <vscale x 1 x i8>, 8) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
1181; CHECK-LABEL: test_vlseg8ff_mask_nxv1i8_triscv.vector.tuple_nxv1i8_8t:
1182; CHECK:       # %bb.0: # %entry
1183; CHECK-NEXT:    vsetvli zero, a1, e8, mf8, ta, mu
1184; CHECK-NEXT:    vmv1r.v v7, v8
1185; CHECK-NEXT:    vmv1r.v v8, v9
1186; CHECK-NEXT:    vmv1r.v v9, v10
1187; CHECK-NEXT:    vmv1r.v v10, v11
1188; CHECK-NEXT:    vmv1r.v v11, v12
1189; CHECK-NEXT:    vmv1r.v v12, v13
1190; CHECK-NEXT:    vmv1r.v v13, v14
1191; CHECK-NEXT:    vmv1r.v v14, v15
1192; CHECK-NEXT:    vlseg8e8ff.v v7, (a0), v0.t
1193; CHECK-NEXT:    csrr a0, vl
1194; CHECK-NEXT:    sw a0, 0(a2)
1195; CHECK-NEXT:    ret
1196entry:
1197  %0 = tail call {target("riscv.vector.tuple", <vscale x 1 x i8>, 8), i32} @llvm.riscv.vlseg8ff.mask.triscv.vector.tuple_nxv1i8_8t.nxv1i1(target("riscv.vector.tuple", <vscale x 1 x i8>, 8) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 3)
1198  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 1 x i8>, 8), i32} %0, 0
1199  %2 = call <vscale x 1 x i8> @llvm.riscv.tuple.extract.nxv1i8.triscv.vector.tuple_nxv1i8_8t(target("riscv.vector.tuple", <vscale x 1 x i8>, 8) %1, i32 1)
1200  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 1 x i8>, 8), i32} %0, 1
1201  store i32 %3, ptr %outvl
1202  ret <vscale x 1 x i8> %2
1203}
1204
1205declare {target("riscv.vector.tuple", <vscale x 2 x i8>, 8), i32} @llvm.riscv.vlseg8ff.triscv.vector.tuple_nxv2i8_8t(target("riscv.vector.tuple", <vscale x 2 x i8>, 8), ptr, i32, i32)
1206declare {target("riscv.vector.tuple", <vscale x 2 x i8>, 8), i32} @llvm.riscv.vlseg8ff.mask.triscv.vector.tuple_nxv2i8_8t.nxv2i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 8), ptr, <vscale x 2 x i1>, i32, i32, i32)
1207
1208define <vscale x 2 x i8> @test_vlseg8ff_nxv2i8_triscv.vector.tuple_nxv2i8_8t(ptr %base, i32 %vl, ptr %outvl) {
1209; CHECK-LABEL: test_vlseg8ff_nxv2i8_triscv.vector.tuple_nxv2i8_8t:
1210; CHECK:       # %bb.0: # %entry
1211; CHECK-NEXT:    vsetvli zero, a1, e8, mf4, ta, ma
1212; CHECK-NEXT:    vlseg8e8ff.v v7, (a0)
1213; CHECK-NEXT:    csrr a0, vl
1214; CHECK-NEXT:    sw a0, 0(a2)
1215; CHECK-NEXT:    ret
1216entry:
1217  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 8), i32} @llvm.riscv.vlseg8ff.triscv.vector.tuple_nxv2i8_8t(target("riscv.vector.tuple", <vscale x 2 x i8>, 8) undef, ptr %base, i32 %vl, i32 3)
1218  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 8), i32} %0, 0
1219  %2 = call <vscale x 2 x i8> @llvm.riscv.tuple.extract.nxv2i8.triscv.vector.tuple_nxv2i8_8t(target("riscv.vector.tuple", <vscale x 2 x i8>, 8) %1, i32 1)
1220  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 8), i32} %0, 1
1221  store i32 %3, ptr %outvl
1222  ret <vscale x 2 x i8> %2
1223}
1224
1225define <vscale x 2 x i8> @test_vlseg8ff_mask_nxv2i8_triscv.vector.tuple_nxv2i8_8t(target("riscv.vector.tuple", <vscale x 2 x i8>, 8) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
1226; CHECK-LABEL: test_vlseg8ff_mask_nxv2i8_triscv.vector.tuple_nxv2i8_8t:
1227; CHECK:       # %bb.0: # %entry
1228; CHECK-NEXT:    vsetvli zero, a1, e8, mf4, ta, mu
1229; CHECK-NEXT:    vmv1r.v v7, v8
1230; CHECK-NEXT:    vmv1r.v v8, v9
1231; CHECK-NEXT:    vmv1r.v v9, v10
1232; CHECK-NEXT:    vmv1r.v v10, v11
1233; CHECK-NEXT:    vmv1r.v v11, v12
1234; CHECK-NEXT:    vmv1r.v v12, v13
1235; CHECK-NEXT:    vmv1r.v v13, v14
1236; CHECK-NEXT:    vmv1r.v v14, v15
1237; CHECK-NEXT:    vlseg8e8ff.v v7, (a0), v0.t
1238; CHECK-NEXT:    csrr a0, vl
1239; CHECK-NEXT:    sw a0, 0(a2)
1240; CHECK-NEXT:    ret
1241entry:
1242  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 8), i32} @llvm.riscv.vlseg8ff.mask.triscv.vector.tuple_nxv2i8_8t.nxv2i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 8) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 3)
1243  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 8), i32} %0, 0
1244  %2 = call <vscale x 2 x i8> @llvm.riscv.tuple.extract.nxv2i8.triscv.vector.tuple_nxv2i8_8t(target("riscv.vector.tuple", <vscale x 2 x i8>, 8) %1, i32 1)
1245  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 8), i32} %0, 1
1246  store i32 %3, ptr %outvl
1247  ret <vscale x 2 x i8> %2
1248}
1249
1250declare {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} @llvm.riscv.vlseg8ff.triscv.vector.tuple_nxv4i8_8t(target("riscv.vector.tuple", <vscale x 4 x i8>, 8), ptr, i32, i32)
1251declare {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} @llvm.riscv.vlseg8ff.mask.triscv.vector.tuple_nxv4i8_8t.nxv4i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 8), ptr, <vscale x 4 x i1>, i32, i32, i32)
1252
1253define <vscale x 4 x i8> @test_vlseg8ff_nxv4i8_triscv.vector.tuple_nxv4i8_8t(ptr %base, i32 %vl, ptr %outvl) {
1254; CHECK-LABEL: test_vlseg8ff_nxv4i8_triscv.vector.tuple_nxv4i8_8t:
1255; CHECK:       # %bb.0: # %entry
1256; CHECK-NEXT:    vsetvli zero, a1, e8, mf2, ta, ma
1257; CHECK-NEXT:    vlseg8e8ff.v v7, (a0)
1258; CHECK-NEXT:    csrr a0, vl
1259; CHECK-NEXT:    sw a0, 0(a2)
1260; CHECK-NEXT:    ret
1261entry:
1262  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} @llvm.riscv.vlseg8ff.triscv.vector.tuple_nxv4i8_8t(target("riscv.vector.tuple", <vscale x 4 x i8>, 8) undef, ptr %base, i32 %vl, i32 3)
1263  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} %0, 0
1264  %2 = call <vscale x 4 x i8> @llvm.riscv.tuple.extract.nxv4i8.triscv.vector.tuple_nxv4i8_8t(target("riscv.vector.tuple", <vscale x 4 x i8>, 8) %1, i32 1)
1265  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} %0, 1
1266  store i32 %3, ptr %outvl
1267  ret <vscale x 4 x i8> %2
1268}
1269
1270define <vscale x 4 x i8> @test_vlseg8ff_mask_nxv4i8_triscv.vector.tuple_nxv4i8_8t(target("riscv.vector.tuple", <vscale x 4 x i8>, 8) %val, ptr %base, i32 %vl, <vscale x 4 x i1> %mask, ptr %outvl) {
1271; CHECK-LABEL: test_vlseg8ff_mask_nxv4i8_triscv.vector.tuple_nxv4i8_8t:
1272; CHECK:       # %bb.0: # %entry
1273; CHECK-NEXT:    vsetvli zero, a1, e8, mf2, ta, mu
1274; CHECK-NEXT:    vmv1r.v v7, v8
1275; CHECK-NEXT:    vmv1r.v v8, v9
1276; CHECK-NEXT:    vmv1r.v v9, v10
1277; CHECK-NEXT:    vmv1r.v v10, v11
1278; CHECK-NEXT:    vmv1r.v v11, v12
1279; CHECK-NEXT:    vmv1r.v v12, v13
1280; CHECK-NEXT:    vmv1r.v v13, v14
1281; CHECK-NEXT:    vmv1r.v v14, v15
1282; CHECK-NEXT:    vlseg8e8ff.v v7, (a0), v0.t
1283; CHECK-NEXT:    csrr a0, vl
1284; CHECK-NEXT:    sw a0, 0(a2)
1285; CHECK-NEXT:    ret
1286entry:
1287  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} @llvm.riscv.vlseg8ff.mask.triscv.vector.tuple_nxv4i8_8t.nxv4i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 8) %val, ptr %base, <vscale x 4 x i1> %mask, i32 %vl, i32 1, i32 3)
1288  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} %0, 0
1289  %2 = call <vscale x 4 x i8> @llvm.riscv.tuple.extract.nxv4i8.triscv.vector.tuple_nxv4i8_8t(target("riscv.vector.tuple", <vscale x 4 x i8>, 8) %1, i32 1)
1290  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} %0, 1
1291  store i32 %3, ptr %outvl
1292  ret <vscale x 4 x i8> %2
1293}
1294
1295declare {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} @llvm.riscv.vlseg8ff.triscv.vector.tuple_nxv8i8_8t(target("riscv.vector.tuple", <vscale x 8 x i8>, 8), ptr, i32, i32)
1296declare {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} @llvm.riscv.vlseg8ff.mask.triscv.vector.tuple_nxv8i8_8t.nxv8i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 8), ptr, <vscale x 8 x i1>, i32, i32, i32)
1297
1298define <vscale x 8 x i8> @test_vlseg8ff_nxv8i8_triscv.vector.tuple_nxv8i8_8t(ptr %base, i32 %vl, ptr %outvl) {
1299; CHECK-LABEL: test_vlseg8ff_nxv8i8_triscv.vector.tuple_nxv8i8_8t:
1300; CHECK:       # %bb.0: # %entry
1301; CHECK-NEXT:    vsetvli zero, a1, e8, m1, ta, ma
1302; CHECK-NEXT:    vlseg8e8ff.v v7, (a0)
1303; CHECK-NEXT:    csrr a0, vl
1304; CHECK-NEXT:    sw a0, 0(a2)
1305; CHECK-NEXT:    ret
1306entry:
1307  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} @llvm.riscv.vlseg8ff.triscv.vector.tuple_nxv8i8_8t(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) undef, ptr %base, i32 %vl, i32 3)
1308  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} %0, 0
1309  %2 = call <vscale x 8 x i8> @llvm.riscv.tuple.extract.nxv8i8.triscv.vector.tuple_nxv8i8_8t(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) %1, i32 1)
1310  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} %0, 1
1311  store i32 %3, ptr %outvl
1312  ret <vscale x 8 x i8> %2
1313}
1314
1315define <vscale x 8 x i8> @test_vlseg8ff_mask_nxv8i8_triscv.vector.tuple_nxv8i8_8t(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) %val, ptr %base, i32 %vl, <vscale x 8 x i1> %mask, ptr %outvl) {
1316; CHECK-LABEL: test_vlseg8ff_mask_nxv8i8_triscv.vector.tuple_nxv8i8_8t:
1317; CHECK:       # %bb.0: # %entry
1318; CHECK-NEXT:    vsetvli zero, a1, e8, m1, ta, mu
1319; CHECK-NEXT:    vmv1r.v v7, v8
1320; CHECK-NEXT:    vmv1r.v v8, v9
1321; CHECK-NEXT:    vmv1r.v v9, v10
1322; CHECK-NEXT:    vmv1r.v v10, v11
1323; CHECK-NEXT:    vmv1r.v v11, v12
1324; CHECK-NEXT:    vmv1r.v v12, v13
1325; CHECK-NEXT:    vmv1r.v v13, v14
1326; CHECK-NEXT:    vmv1r.v v14, v15
1327; CHECK-NEXT:    vlseg8e8ff.v v7, (a0), v0.t
1328; CHECK-NEXT:    csrr a0, vl
1329; CHECK-NEXT:    sw a0, 0(a2)
1330; CHECK-NEXT:    ret
1331entry:
1332  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} @llvm.riscv.vlseg8ff.mask.triscv.vector.tuple_nxv8i8_8t.nxv8i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) %val, ptr %base, <vscale x 8 x i1> %mask, i32 %vl, i32 1, i32 3)
1333  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} %0, 0
1334  %2 = call <vscale x 8 x i8> @llvm.riscv.tuple.extract.nxv8i8.triscv.vector.tuple_nxv8i8_8t(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) %1, i32 1)
1335  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} %0, 1
1336  store i32 %3, ptr %outvl
1337  ret <vscale x 8 x i8> %2
1338}
1339
1340declare {target("riscv.vector.tuple", <vscale x 2 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv2i8_2t.nxv1i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 2), ptr, <vscale x 1 x i1>, i32, i32, i32)
1341
1342define <vscale x 1 x i16> @test_vlseg2ff_nxv1i16_triscv.vector.tuple_nxv2i8_2t(ptr %base, i32 %vl, ptr %outvl) {
1343; CHECK-LABEL: test_vlseg2ff_nxv1i16_triscv.vector.tuple_nxv2i8_2t:
1344; CHECK:       # %bb.0: # %entry
1345; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, ma
1346; CHECK-NEXT:    vlseg2e16ff.v v7, (a0)
1347; CHECK-NEXT:    csrr a0, vl
1348; CHECK-NEXT:    sw a0, 0(a2)
1349; CHECK-NEXT:    ret
1350entry:
1351  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv2i8_2t(target("riscv.vector.tuple", <vscale x 2 x i8>, 2) undef, ptr %base, i32 %vl, i32 4)
1352  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 2), i32} %0, 0
1353  %2 = call <vscale x 1 x i16> @llvm.riscv.tuple.extract.nxv1i16.triscv.vector.tuple_nxv2i8_2t(target("riscv.vector.tuple", <vscale x 2 x i8>, 2) %1, i32 1)
1354  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 2), i32} %0, 1
1355  store i32 %3, ptr %outvl
1356  ret <vscale x 1 x i16> %2
1357}
1358
1359define <vscale x 1 x i16> @test_vlseg2ff_mask_nxv1i16_triscv.vector.tuple_nxv2i8_2t(target("riscv.vector.tuple", <vscale x 2 x i8>, 2) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
1360; CHECK-LABEL: test_vlseg2ff_mask_nxv1i16_triscv.vector.tuple_nxv2i8_2t:
1361; CHECK:       # %bb.0: # %entry
1362; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, mu
1363; CHECK-NEXT:    vmv1r.v v7, v8
1364; CHECK-NEXT:    vmv1r.v v8, v9
1365; CHECK-NEXT:    vlseg2e16ff.v v7, (a0), v0.t
1366; CHECK-NEXT:    csrr a0, vl
1367; CHECK-NEXT:    sw a0, 0(a2)
1368; CHECK-NEXT:    ret
1369entry:
1370  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv2i8_2t.nxv1i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 2) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 4)
1371  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 2), i32} %0, 0
1372  %2 = call <vscale x 1 x i16> @llvm.riscv.tuple.extract.nxv1i16.triscv.vector.tuple_nxv2i8_2t(target("riscv.vector.tuple", <vscale x 2 x i8>, 2) %1, i32 1)
1373  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 2), i32} %0, 1
1374  store i32 %3, ptr %outvl
1375  ret <vscale x 1 x i16> %2
1376}
1377
1378declare {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv4i8_2t.nxv2i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 2), ptr, <vscale x 2 x i1>, i32, i32, i32)
1379
1380define <vscale x 2 x i16> @test_vlseg2ff_nxv2i16_triscv.vector.tuple_nxv4i8_2t(ptr %base, i32 %vl, ptr %outvl) {
1381; CHECK-LABEL: test_vlseg2ff_nxv2i16_triscv.vector.tuple_nxv4i8_2t:
1382; CHECK:       # %bb.0: # %entry
1383; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, ma
1384; CHECK-NEXT:    vlseg2e16ff.v v7, (a0)
1385; CHECK-NEXT:    csrr a0, vl
1386; CHECK-NEXT:    sw a0, 0(a2)
1387; CHECK-NEXT:    ret
1388entry:
1389  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv4i8_2t(target("riscv.vector.tuple", <vscale x 4 x i8>, 2) undef, ptr %base, i32 %vl, i32 4)
1390  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} %0, 0
1391  %2 = call <vscale x 2 x i16> @llvm.riscv.tuple.extract.nxv2i16.triscv.vector.tuple_nxv4i8_2t(target("riscv.vector.tuple", <vscale x 4 x i8>, 2) %1, i32 1)
1392  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} %0, 1
1393  store i32 %3, ptr %outvl
1394  ret <vscale x 2 x i16> %2
1395}
1396
1397define <vscale x 2 x i16> @test_vlseg2ff_mask_nxv2i16_triscv.vector.tuple_nxv4i8_2t(target("riscv.vector.tuple", <vscale x 4 x i8>, 2) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
1398; CHECK-LABEL: test_vlseg2ff_mask_nxv2i16_triscv.vector.tuple_nxv4i8_2t:
1399; CHECK:       # %bb.0: # %entry
1400; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, mu
1401; CHECK-NEXT:    vmv1r.v v7, v8
1402; CHECK-NEXT:    vmv1r.v v8, v9
1403; CHECK-NEXT:    vlseg2e16ff.v v7, (a0), v0.t
1404; CHECK-NEXT:    csrr a0, vl
1405; CHECK-NEXT:    sw a0, 0(a2)
1406; CHECK-NEXT:    ret
1407entry:
1408  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv4i8_2t.nxv2i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 2) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 4)
1409  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} %0, 0
1410  %2 = call <vscale x 2 x i16> @llvm.riscv.tuple.extract.nxv2i16.triscv.vector.tuple_nxv4i8_2t(target("riscv.vector.tuple", <vscale x 4 x i8>, 2) %1, i32 1)
1411  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} %0, 1
1412  store i32 %3, ptr %outvl
1413  ret <vscale x 2 x i16> %2
1414}
1415
1416declare {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv8i8_2t.nxv4i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 2), ptr, <vscale x 4 x i1>, i32, i32, i32)
1417
1418define <vscale x 4 x i16> @test_vlseg2ff_nxv4i16_triscv.vector.tuple_nxv8i8_2t(ptr %base, i32 %vl, ptr %outvl) {
1419; CHECK-LABEL: test_vlseg2ff_nxv4i16_triscv.vector.tuple_nxv8i8_2t:
1420; CHECK:       # %bb.0: # %entry
1421; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, ma
1422; CHECK-NEXT:    vlseg2e16ff.v v7, (a0)
1423; CHECK-NEXT:    csrr a0, vl
1424; CHECK-NEXT:    sw a0, 0(a2)
1425; CHECK-NEXT:    ret
1426entry:
1427  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv8i8_2t(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) undef, ptr %base, i32 %vl, i32 4)
1428  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} %0, 0
1429  %2 = call <vscale x 4 x i16> @llvm.riscv.tuple.extract.nxv4i16.triscv.vector.tuple_nxv8i8_2t(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) %1, i32 1)
1430  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} %0, 1
1431  store i32 %3, ptr %outvl
1432  ret <vscale x 4 x i16> %2
1433}
1434
1435define <vscale x 4 x i16> @test_vlseg2ff_mask_nxv4i16_triscv.vector.tuple_nxv8i8_2t(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) %val, ptr %base, i32 %vl, <vscale x 4 x i1> %mask, ptr %outvl) {
1436; CHECK-LABEL: test_vlseg2ff_mask_nxv4i16_triscv.vector.tuple_nxv8i8_2t:
1437; CHECK:       # %bb.0: # %entry
1438; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, mu
1439; CHECK-NEXT:    vmv1r.v v7, v8
1440; CHECK-NEXT:    vmv1r.v v8, v9
1441; CHECK-NEXT:    vlseg2e16ff.v v7, (a0), v0.t
1442; CHECK-NEXT:    csrr a0, vl
1443; CHECK-NEXT:    sw a0, 0(a2)
1444; CHECK-NEXT:    ret
1445entry:
1446  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv8i8_2t.nxv4i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) %val, ptr %base, <vscale x 4 x i1> %mask, i32 %vl, i32 1, i32 4)
1447  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} %0, 0
1448  %2 = call <vscale x 4 x i16> @llvm.riscv.tuple.extract.nxv4i16.triscv.vector.tuple_nxv8i8_2t(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) %1, i32 1)
1449  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} %0, 1
1450  store i32 %3, ptr %outvl
1451  ret <vscale x 4 x i16> %2
1452}
1453
1454declare {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv16i8_2t.nxv8i1(target("riscv.vector.tuple", <vscale x 16 x i8>, 2), ptr, <vscale x 8 x i1>, i32, i32, i32)
1455
1456define <vscale x 8 x i16> @test_vlseg2ff_nxv8i16_triscv.vector.tuple_nxv16i8_2t(ptr %base, i32 %vl, ptr %outvl) {
1457; CHECK-LABEL: test_vlseg2ff_nxv8i16_triscv.vector.tuple_nxv16i8_2t:
1458; CHECK:       # %bb.0: # %entry
1459; CHECK-NEXT:    vsetvli zero, a1, e16, m2, ta, ma
1460; CHECK-NEXT:    vlseg2e16ff.v v6, (a0)
1461; CHECK-NEXT:    csrr a0, vl
1462; CHECK-NEXT:    sw a0, 0(a2)
1463; CHECK-NEXT:    ret
1464entry:
1465  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv16i8_2t(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) undef, ptr %base, i32 %vl, i32 4)
1466  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} %0, 0
1467  %2 = call <vscale x 8 x i16> @llvm.riscv.tuple.extract.nxv8i16.triscv.vector.tuple_nxv16i8_2t(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) %1, i32 1)
1468  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} %0, 1
1469  store i32 %3, ptr %outvl
1470  ret <vscale x 8 x i16> %2
1471}
1472
1473define <vscale x 8 x i16> @test_vlseg2ff_mask_nxv8i16_triscv.vector.tuple_nxv16i8_2t(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) %val, ptr %base, i32 %vl, <vscale x 8 x i1> %mask, ptr %outvl) {
1474; CHECK-LABEL: test_vlseg2ff_mask_nxv8i16_triscv.vector.tuple_nxv16i8_2t:
1475; CHECK:       # %bb.0: # %entry
1476; CHECK-NEXT:    vsetvli zero, a1, e16, m2, ta, mu
1477; CHECK-NEXT:    vmv2r.v v6, v8
1478; CHECK-NEXT:    vmv2r.v v8, v10
1479; CHECK-NEXT:    vlseg2e16ff.v v6, (a0), v0.t
1480; CHECK-NEXT:    csrr a0, vl
1481; CHECK-NEXT:    sw a0, 0(a2)
1482; CHECK-NEXT:    ret
1483entry:
1484  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv16i8_2t.nxv8i1(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) %val, ptr %base, <vscale x 8 x i1> %mask, i32 %vl, i32 1, i32 4)
1485  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} %0, 0
1486  %2 = call <vscale x 8 x i16> @llvm.riscv.tuple.extract.nxv8i16.triscv.vector.tuple_nxv16i8_2t(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) %1, i32 1)
1487  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} %0, 1
1488  store i32 %3, ptr %outvl
1489  ret <vscale x 8 x i16> %2
1490}
1491
1492declare {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv32i8_2t.nxv16i1(target("riscv.vector.tuple", <vscale x 32 x i8>, 2), ptr, <vscale x 16 x i1>, i32, i32, i32)
1493
1494define <vscale x 16 x i16> @test_vlseg2ff_nxv16i16_triscv.vector.tuple_nxv32i8_2t(ptr %base, i32 %vl, ptr %outvl) {
1495; CHECK-LABEL: test_vlseg2ff_nxv16i16_triscv.vector.tuple_nxv32i8_2t:
1496; CHECK:       # %bb.0: # %entry
1497; CHECK-NEXT:    vsetvli zero, a1, e16, m4, ta, ma
1498; CHECK-NEXT:    vlseg2e16ff.v v4, (a0)
1499; CHECK-NEXT:    csrr a0, vl
1500; CHECK-NEXT:    sw a0, 0(a2)
1501; CHECK-NEXT:    ret
1502entry:
1503  %0 = tail call {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv32i8_2t(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) undef, ptr %base, i32 %vl, i32 4)
1504  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} %0, 0
1505  %2 = call <vscale x 16 x i16> @llvm.riscv.tuple.extract.nxv16i16.triscv.vector.tuple_nxv32i8_2t(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) %1, i32 1)
1506  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} %0, 1
1507  store i32 %3, ptr %outvl
1508  ret <vscale x 16 x i16> %2
1509}
1510
1511define <vscale x 16 x i16> @test_vlseg2ff_mask_nxv16i16_triscv.vector.tuple_nxv32i8_2t(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) %val, ptr %base, i32 %vl, <vscale x 16 x i1> %mask, ptr %outvl) {
1512; CHECK-LABEL: test_vlseg2ff_mask_nxv16i16_triscv.vector.tuple_nxv32i8_2t:
1513; CHECK:       # %bb.0: # %entry
1514; CHECK-NEXT:    vsetvli zero, a1, e16, m4, ta, mu
1515; CHECK-NEXT:    vmv4r.v v4, v8
1516; CHECK-NEXT:    vmv4r.v v8, v12
1517; CHECK-NEXT:    vlseg2e16ff.v v4, (a0), v0.t
1518; CHECK-NEXT:    csrr a0, vl
1519; CHECK-NEXT:    sw a0, 0(a2)
1520; CHECK-NEXT:    ret
1521entry:
1522  %0 = tail call {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv32i8_2t.nxv16i1(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) %val, ptr %base, <vscale x 16 x i1> %mask, i32 %vl, i32 1, i32 4)
1523  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} %0, 0
1524  %2 = call <vscale x 16 x i16> @llvm.riscv.tuple.extract.nxv16i16.triscv.vector.tuple_nxv32i8_2t(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) %1, i32 1)
1525  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} %0, 1
1526  store i32 %3, ptr %outvl
1527  ret <vscale x 16 x i16> %2
1528}
1529
1530declare {target("riscv.vector.tuple", <vscale x 2 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv2i8_3t.nxv1i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 3), ptr, <vscale x 1 x i1>, i32, i32, i32)
1531
1532define <vscale x 1 x i16> @test_vlseg3ff_nxv1i16_triscv.vector.tuple_nxv2i8_3t(ptr %base, i32 %vl, ptr %outvl) {
1533; CHECK-LABEL: test_vlseg3ff_nxv1i16_triscv.vector.tuple_nxv2i8_3t:
1534; CHECK:       # %bb.0: # %entry
1535; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, ma
1536; CHECK-NEXT:    vlseg3e16ff.v v7, (a0)
1537; CHECK-NEXT:    csrr a0, vl
1538; CHECK-NEXT:    sw a0, 0(a2)
1539; CHECK-NEXT:    ret
1540entry:
1541  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 3), i32} @llvm.riscv.vlseg3ff.triscv.vector.tuple_nxv2i8_3t(target("riscv.vector.tuple", <vscale x 2 x i8>, 3) undef, ptr %base, i32 %vl, i32 4)
1542  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 3), i32} %0, 0
1543  %2 = call <vscale x 1 x i16> @llvm.riscv.tuple.extract.nxv1i16.triscv.vector.tuple_nxv2i8_3t(target("riscv.vector.tuple", <vscale x 2 x i8>, 3) %1, i32 1)
1544  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 3), i32} %0, 1
1545  store i32 %3, ptr %outvl
1546  ret <vscale x 1 x i16> %2
1547}
1548
1549define <vscale x 1 x i16> @test_vlseg3ff_mask_nxv1i16_triscv.vector.tuple_nxv2i8_3t(target("riscv.vector.tuple", <vscale x 2 x i8>, 3) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
1550; CHECK-LABEL: test_vlseg3ff_mask_nxv1i16_triscv.vector.tuple_nxv2i8_3t:
1551; CHECK:       # %bb.0: # %entry
1552; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, mu
1553; CHECK-NEXT:    vmv1r.v v7, v8
1554; CHECK-NEXT:    vmv1r.v v8, v9
1555; CHECK-NEXT:    vmv1r.v v9, v10
1556; CHECK-NEXT:    vlseg3e16ff.v v7, (a0), v0.t
1557; CHECK-NEXT:    csrr a0, vl
1558; CHECK-NEXT:    sw a0, 0(a2)
1559; CHECK-NEXT:    ret
1560entry:
1561  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv2i8_3t.nxv1i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 3) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 4)
1562  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 3), i32} %0, 0
1563  %2 = call <vscale x 1 x i16> @llvm.riscv.tuple.extract.nxv1i16.triscv.vector.tuple_nxv2i8_3t(target("riscv.vector.tuple", <vscale x 2 x i8>, 3) %1, i32 1)
1564  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 3), i32} %0, 1
1565  store i32 %3, ptr %outvl
1566  ret <vscale x 1 x i16> %2
1567}
1568
1569declare {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv4i8_3t.nxv2i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 3), ptr, <vscale x 2 x i1>, i32, i32, i32)
1570
1571define <vscale x 2 x i16> @test_vlseg3ff_nxv2i16_triscv.vector.tuple_nxv4i8_3t(ptr %base, i32 %vl, ptr %outvl) {
1572; CHECK-LABEL: test_vlseg3ff_nxv2i16_triscv.vector.tuple_nxv4i8_3t:
1573; CHECK:       # %bb.0: # %entry
1574; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, ma
1575; CHECK-NEXT:    vlseg3e16ff.v v7, (a0)
1576; CHECK-NEXT:    csrr a0, vl
1577; CHECK-NEXT:    sw a0, 0(a2)
1578; CHECK-NEXT:    ret
1579entry:
1580  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} @llvm.riscv.vlseg3ff.triscv.vector.tuple_nxv4i8_3t(target("riscv.vector.tuple", <vscale x 4 x i8>, 3) undef, ptr %base, i32 %vl, i32 4)
1581  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} %0, 0
1582  %2 = call <vscale x 2 x i16> @llvm.riscv.tuple.extract.nxv2i16.triscv.vector.tuple_nxv4i8_3t(target("riscv.vector.tuple", <vscale x 4 x i8>, 3) %1, i32 1)
1583  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} %0, 1
1584  store i32 %3, ptr %outvl
1585  ret <vscale x 2 x i16> %2
1586}
1587
1588define <vscale x 2 x i16> @test_vlseg3ff_mask_nxv2i16_triscv.vector.tuple_nxv4i8_3t(target("riscv.vector.tuple", <vscale x 4 x i8>, 3) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
1589; CHECK-LABEL: test_vlseg3ff_mask_nxv2i16_triscv.vector.tuple_nxv4i8_3t:
1590; CHECK:       # %bb.0: # %entry
1591; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, mu
1592; CHECK-NEXT:    vmv1r.v v7, v8
1593; CHECK-NEXT:    vmv1r.v v8, v9
1594; CHECK-NEXT:    vmv1r.v v9, v10
1595; CHECK-NEXT:    vlseg3e16ff.v v7, (a0), v0.t
1596; CHECK-NEXT:    csrr a0, vl
1597; CHECK-NEXT:    sw a0, 0(a2)
1598; CHECK-NEXT:    ret
1599entry:
1600  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv4i8_3t.nxv2i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 3) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 4)
1601  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} %0, 0
1602  %2 = call <vscale x 2 x i16> @llvm.riscv.tuple.extract.nxv2i16.triscv.vector.tuple_nxv4i8_3t(target("riscv.vector.tuple", <vscale x 4 x i8>, 3) %1, i32 1)
1603  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} %0, 1
1604  store i32 %3, ptr %outvl
1605  ret <vscale x 2 x i16> %2
1606}
1607
1608declare {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv8i8_3t.nxv4i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 3), ptr, <vscale x 4 x i1>, i32, i32, i32)
1609
1610define <vscale x 4 x i16> @test_vlseg3ff_nxv4i16_triscv.vector.tuple_nxv8i8_3t(ptr %base, i32 %vl, ptr %outvl) {
1611; CHECK-LABEL: test_vlseg3ff_nxv4i16_triscv.vector.tuple_nxv8i8_3t:
1612; CHECK:       # %bb.0: # %entry
1613; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, ma
1614; CHECK-NEXT:    vlseg3e16ff.v v7, (a0)
1615; CHECK-NEXT:    csrr a0, vl
1616; CHECK-NEXT:    sw a0, 0(a2)
1617; CHECK-NEXT:    ret
1618entry:
1619  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} @llvm.riscv.vlseg3ff.triscv.vector.tuple_nxv8i8_3t(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) undef, ptr %base, i32 %vl, i32 4)
1620  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} %0, 0
1621  %2 = call <vscale x 4 x i16> @llvm.riscv.tuple.extract.nxv4i16.triscv.vector.tuple_nxv8i8_3t(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) %1, i32 1)
1622  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} %0, 1
1623  store i32 %3, ptr %outvl
1624  ret <vscale x 4 x i16> %2
1625}
1626
1627define <vscale x 4 x i16> @test_vlseg3ff_mask_nxv4i16_triscv.vector.tuple_nxv8i8_3t(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) %val, ptr %base, i32 %vl, <vscale x 4 x i1> %mask, ptr %outvl) {
1628; CHECK-LABEL: test_vlseg3ff_mask_nxv4i16_triscv.vector.tuple_nxv8i8_3t:
1629; CHECK:       # %bb.0: # %entry
1630; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, mu
1631; CHECK-NEXT:    vmv1r.v v7, v8
1632; CHECK-NEXT:    vmv1r.v v8, v9
1633; CHECK-NEXT:    vmv1r.v v9, v10
1634; CHECK-NEXT:    vlseg3e16ff.v v7, (a0), v0.t
1635; CHECK-NEXT:    csrr a0, vl
1636; CHECK-NEXT:    sw a0, 0(a2)
1637; CHECK-NEXT:    ret
1638entry:
1639  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv8i8_3t.nxv4i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) %val, ptr %base, <vscale x 4 x i1> %mask, i32 %vl, i32 1, i32 4)
1640  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} %0, 0
1641  %2 = call <vscale x 4 x i16> @llvm.riscv.tuple.extract.nxv4i16.triscv.vector.tuple_nxv8i8_3t(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) %1, i32 1)
1642  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} %0, 1
1643  store i32 %3, ptr %outvl
1644  ret <vscale x 4 x i16> %2
1645}
1646
1647declare {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv16i8_3t.nxv8i1(target("riscv.vector.tuple", <vscale x 16 x i8>, 3), ptr, <vscale x 8 x i1>, i32, i32, i32)
1648
1649define <vscale x 8 x i16> @test_vlseg3ff_nxv8i16_triscv.vector.tuple_nxv16i8_3t(ptr %base, i32 %vl, ptr %outvl) {
1650; CHECK-LABEL: test_vlseg3ff_nxv8i16_triscv.vector.tuple_nxv16i8_3t:
1651; CHECK:       # %bb.0: # %entry
1652; CHECK-NEXT:    vsetvli zero, a1, e16, m2, ta, ma
1653; CHECK-NEXT:    vlseg3e16ff.v v6, (a0)
1654; CHECK-NEXT:    csrr a0, vl
1655; CHECK-NEXT:    sw a0, 0(a2)
1656; CHECK-NEXT:    ret
1657entry:
1658  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} @llvm.riscv.vlseg3ff.triscv.vector.tuple_nxv16i8_3t(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) undef, ptr %base, i32 %vl, i32 4)
1659  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} %0, 0
1660  %2 = call <vscale x 8 x i16> @llvm.riscv.tuple.extract.nxv8i16.triscv.vector.tuple_nxv16i8_3t(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) %1, i32 1)
1661  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} %0, 1
1662  store i32 %3, ptr %outvl
1663  ret <vscale x 8 x i16> %2
1664}
1665
1666define <vscale x 8 x i16> @test_vlseg3ff_mask_nxv8i16_triscv.vector.tuple_nxv16i8_3t(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) %val, ptr %base, i32 %vl, <vscale x 8 x i1> %mask, ptr %outvl) {
1667; CHECK-LABEL: test_vlseg3ff_mask_nxv8i16_triscv.vector.tuple_nxv16i8_3t:
1668; CHECK:       # %bb.0: # %entry
1669; CHECK-NEXT:    vsetvli zero, a1, e16, m2, ta, mu
1670; CHECK-NEXT:    vmv2r.v v6, v8
1671; CHECK-NEXT:    vmv2r.v v8, v10
1672; CHECK-NEXT:    vmv2r.v v10, v12
1673; CHECK-NEXT:    vlseg3e16ff.v v6, (a0), v0.t
1674; CHECK-NEXT:    csrr a0, vl
1675; CHECK-NEXT:    sw a0, 0(a2)
1676; CHECK-NEXT:    ret
1677entry:
1678  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv16i8_3t.nxv8i1(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) %val, ptr %base, <vscale x 8 x i1> %mask, i32 %vl, i32 1, i32 4)
1679  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} %0, 0
1680  %2 = call <vscale x 8 x i16> @llvm.riscv.tuple.extract.nxv8i16.triscv.vector.tuple_nxv16i8_3t(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) %1, i32 1)
1681  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} %0, 1
1682  store i32 %3, ptr %outvl
1683  ret <vscale x 8 x i16> %2
1684}
1685
1686declare {target("riscv.vector.tuple", <vscale x 2 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv2i8_4t.nxv1i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 4), ptr, <vscale x 1 x i1>, i32, i32, i32)
1687
1688define <vscale x 1 x i16> @test_vlseg4ff_nxv1i16_triscv.vector.tuple_nxv2i8_4t(ptr %base, i32 %vl, ptr %outvl) {
1689; CHECK-LABEL: test_vlseg4ff_nxv1i16_triscv.vector.tuple_nxv2i8_4t:
1690; CHECK:       # %bb.0: # %entry
1691; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, ma
1692; CHECK-NEXT:    vlseg4e16ff.v v7, (a0)
1693; CHECK-NEXT:    csrr a0, vl
1694; CHECK-NEXT:    sw a0, 0(a2)
1695; CHECK-NEXT:    ret
1696entry:
1697  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 4), i32} @llvm.riscv.vlseg4ff.triscv.vector.tuple_nxv2i8_4t(target("riscv.vector.tuple", <vscale x 2 x i8>, 4) undef, ptr %base, i32 %vl, i32 4)
1698  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 4), i32} %0, 0
1699  %2 = call <vscale x 1 x i16> @llvm.riscv.tuple.extract.nxv1i16.triscv.vector.tuple_nxv2i8_4t(target("riscv.vector.tuple", <vscale x 2 x i8>, 4) %1, i32 1)
1700  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 4), i32} %0, 1
1701  store i32 %3, ptr %outvl
1702  ret <vscale x 1 x i16> %2
1703}
1704
1705define <vscale x 1 x i16> @test_vlseg4ff_mask_nxv1i16_triscv.vector.tuple_nxv2i8_4t(target("riscv.vector.tuple", <vscale x 2 x i8>, 4) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
1706; CHECK-LABEL: test_vlseg4ff_mask_nxv1i16_triscv.vector.tuple_nxv2i8_4t:
1707; CHECK:       # %bb.0: # %entry
1708; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, mu
1709; CHECK-NEXT:    vmv1r.v v7, v8
1710; CHECK-NEXT:    vmv1r.v v8, v9
1711; CHECK-NEXT:    vmv1r.v v9, v10
1712; CHECK-NEXT:    vmv1r.v v10, v11
1713; CHECK-NEXT:    vlseg4e16ff.v v7, (a0), v0.t
1714; CHECK-NEXT:    csrr a0, vl
1715; CHECK-NEXT:    sw a0, 0(a2)
1716; CHECK-NEXT:    ret
1717entry:
1718  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv2i8_4t.nxv1i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 4) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 4)
1719  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 4), i32} %0, 0
1720  %2 = call <vscale x 1 x i16> @llvm.riscv.tuple.extract.nxv1i16.triscv.vector.tuple_nxv2i8_4t(target("riscv.vector.tuple", <vscale x 2 x i8>, 4) %1, i32 1)
1721  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 4), i32} %0, 1
1722  store i32 %3, ptr %outvl
1723  ret <vscale x 1 x i16> %2
1724}
1725
1726declare {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv4i8_4t.nxv2i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 4), ptr, <vscale x 2 x i1>, i32, i32, i32)
1727
1728define <vscale x 2 x i16> @test_vlseg4ff_nxv2i16_triscv.vector.tuple_nxv4i8_4t(ptr %base, i32 %vl, ptr %outvl) {
1729; CHECK-LABEL: test_vlseg4ff_nxv2i16_triscv.vector.tuple_nxv4i8_4t:
1730; CHECK:       # %bb.0: # %entry
1731; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, ma
1732; CHECK-NEXT:    vlseg4e16ff.v v7, (a0)
1733; CHECK-NEXT:    csrr a0, vl
1734; CHECK-NEXT:    sw a0, 0(a2)
1735; CHECK-NEXT:    ret
1736entry:
1737  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} @llvm.riscv.vlseg4ff.triscv.vector.tuple_nxv4i8_4t(target("riscv.vector.tuple", <vscale x 4 x i8>, 4) undef, ptr %base, i32 %vl, i32 4)
1738  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} %0, 0
1739  %2 = call <vscale x 2 x i16> @llvm.riscv.tuple.extract.nxv2i16.triscv.vector.tuple_nxv4i8_4t(target("riscv.vector.tuple", <vscale x 4 x i8>, 4) %1, i32 1)
1740  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} %0, 1
1741  store i32 %3, ptr %outvl
1742  ret <vscale x 2 x i16> %2
1743}
1744
1745define <vscale x 2 x i16> @test_vlseg4ff_mask_nxv2i16_triscv.vector.tuple_nxv4i8_4t(target("riscv.vector.tuple", <vscale x 4 x i8>, 4) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
1746; CHECK-LABEL: test_vlseg4ff_mask_nxv2i16_triscv.vector.tuple_nxv4i8_4t:
1747; CHECK:       # %bb.0: # %entry
1748; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, mu
1749; CHECK-NEXT:    vmv1r.v v7, v8
1750; CHECK-NEXT:    vmv1r.v v8, v9
1751; CHECK-NEXT:    vmv1r.v v9, v10
1752; CHECK-NEXT:    vmv1r.v v10, v11
1753; CHECK-NEXT:    vlseg4e16ff.v v7, (a0), v0.t
1754; CHECK-NEXT:    csrr a0, vl
1755; CHECK-NEXT:    sw a0, 0(a2)
1756; CHECK-NEXT:    ret
1757entry:
1758  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv4i8_4t.nxv2i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 4) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 4)
1759  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} %0, 0
1760  %2 = call <vscale x 2 x i16> @llvm.riscv.tuple.extract.nxv2i16.triscv.vector.tuple_nxv4i8_4t(target("riscv.vector.tuple", <vscale x 4 x i8>, 4) %1, i32 1)
1761  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} %0, 1
1762  store i32 %3, ptr %outvl
1763  ret <vscale x 2 x i16> %2
1764}
1765
1766declare {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv8i8_4t.nxv4i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 4), ptr, <vscale x 4 x i1>, i32, i32, i32)
1767
1768define <vscale x 4 x i16> @test_vlseg4ff_nxv4i16_triscv.vector.tuple_nxv8i8_4t(ptr %base, i32 %vl, ptr %outvl) {
1769; CHECK-LABEL: test_vlseg4ff_nxv4i16_triscv.vector.tuple_nxv8i8_4t:
1770; CHECK:       # %bb.0: # %entry
1771; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, ma
1772; CHECK-NEXT:    vlseg4e16ff.v v7, (a0)
1773; CHECK-NEXT:    csrr a0, vl
1774; CHECK-NEXT:    sw a0, 0(a2)
1775; CHECK-NEXT:    ret
1776entry:
1777  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} @llvm.riscv.vlseg4ff.triscv.vector.tuple_nxv8i8_4t(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) undef, ptr %base, i32 %vl, i32 4)
1778  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} %0, 0
1779  %2 = call <vscale x 4 x i16> @llvm.riscv.tuple.extract.nxv4i16.triscv.vector.tuple_nxv8i8_4t(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) %1, i32 1)
1780  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} %0, 1
1781  store i32 %3, ptr %outvl
1782  ret <vscale x 4 x i16> %2
1783}
1784
1785define <vscale x 4 x i16> @test_vlseg4ff_mask_nxv4i16_triscv.vector.tuple_nxv8i8_4t(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) %val, ptr %base, i32 %vl, <vscale x 4 x i1> %mask, ptr %outvl) {
1786; CHECK-LABEL: test_vlseg4ff_mask_nxv4i16_triscv.vector.tuple_nxv8i8_4t:
1787; CHECK:       # %bb.0: # %entry
1788; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, mu
1789; CHECK-NEXT:    vmv1r.v v7, v8
1790; CHECK-NEXT:    vmv1r.v v8, v9
1791; CHECK-NEXT:    vmv1r.v v9, v10
1792; CHECK-NEXT:    vmv1r.v v10, v11
1793; CHECK-NEXT:    vlseg4e16ff.v v7, (a0), v0.t
1794; CHECK-NEXT:    csrr a0, vl
1795; CHECK-NEXT:    sw a0, 0(a2)
1796; CHECK-NEXT:    ret
1797entry:
1798  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv8i8_4t.nxv4i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) %val, ptr %base, <vscale x 4 x i1> %mask, i32 %vl, i32 1, i32 4)
1799  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} %0, 0
1800  %2 = call <vscale x 4 x i16> @llvm.riscv.tuple.extract.nxv4i16.triscv.vector.tuple_nxv8i8_4t(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) %1, i32 1)
1801  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} %0, 1
1802  store i32 %3, ptr %outvl
1803  ret <vscale x 4 x i16> %2
1804}
1805
1806declare {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv16i8_4t.nxv8i1(target("riscv.vector.tuple", <vscale x 16 x i8>, 4), ptr, <vscale x 8 x i1>, i32, i32, i32)
1807
1808define <vscale x 8 x i16> @test_vlseg4ff_nxv8i16_triscv.vector.tuple_nxv16i8_4t(ptr %base, i32 %vl, ptr %outvl) {
1809; CHECK-LABEL: test_vlseg4ff_nxv8i16_triscv.vector.tuple_nxv16i8_4t:
1810; CHECK:       # %bb.0: # %entry
1811; CHECK-NEXT:    vsetvli zero, a1, e16, m2, ta, ma
1812; CHECK-NEXT:    vlseg4e16ff.v v6, (a0)
1813; CHECK-NEXT:    csrr a0, vl
1814; CHECK-NEXT:    sw a0, 0(a2)
1815; CHECK-NEXT:    ret
1816entry:
1817  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} @llvm.riscv.vlseg4ff.triscv.vector.tuple_nxv16i8_4t(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) undef, ptr %base, i32 %vl, i32 4)
1818  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} %0, 0
1819  %2 = call <vscale x 8 x i16> @llvm.riscv.tuple.extract.nxv8i16.triscv.vector.tuple_nxv16i8_4t(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) %1, i32 1)
1820  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} %0, 1
1821  store i32 %3, ptr %outvl
1822  ret <vscale x 8 x i16> %2
1823}
1824
1825define <vscale x 8 x i16> @test_vlseg4ff_mask_nxv8i16_triscv.vector.tuple_nxv16i8_4t(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) %val, ptr %base, i32 %vl, <vscale x 8 x i1> %mask, ptr %outvl) {
1826; CHECK-LABEL: test_vlseg4ff_mask_nxv8i16_triscv.vector.tuple_nxv16i8_4t:
1827; CHECK:       # %bb.0: # %entry
1828; CHECK-NEXT:    vsetvli zero, a1, e16, m2, ta, mu
1829; CHECK-NEXT:    vmv2r.v v6, v8
1830; CHECK-NEXT:    vmv2r.v v8, v10
1831; CHECK-NEXT:    vmv2r.v v10, v12
1832; CHECK-NEXT:    vmv2r.v v12, v14
1833; CHECK-NEXT:    vlseg4e16ff.v v6, (a0), v0.t
1834; CHECK-NEXT:    csrr a0, vl
1835; CHECK-NEXT:    sw a0, 0(a2)
1836; CHECK-NEXT:    ret
1837entry:
1838  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv16i8_4t.nxv8i1(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) %val, ptr %base, <vscale x 8 x i1> %mask, i32 %vl, i32 1, i32 4)
1839  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} %0, 0
1840  %2 = call <vscale x 8 x i16> @llvm.riscv.tuple.extract.nxv8i16.triscv.vector.tuple_nxv16i8_4t(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) %1, i32 1)
1841  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} %0, 1
1842  store i32 %3, ptr %outvl
1843  ret <vscale x 8 x i16> %2
1844}
1845
1846declare {target("riscv.vector.tuple", <vscale x 2 x i8>, 5), i32} @llvm.riscv.vlseg5ff.mask.triscv.vector.tuple_nxv2i8_5t.nxv1i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 5), ptr, <vscale x 1 x i1>, i32, i32, i32)
1847
1848define <vscale x 1 x i16> @test_vlseg5ff_nxv1i16_triscv.vector.tuple_nxv2i8_5t(ptr %base, i32 %vl, ptr %outvl) {
1849; CHECK-LABEL: test_vlseg5ff_nxv1i16_triscv.vector.tuple_nxv2i8_5t:
1850; CHECK:       # %bb.0: # %entry
1851; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, ma
1852; CHECK-NEXT:    vlseg5e16ff.v v7, (a0)
1853; CHECK-NEXT:    csrr a0, vl
1854; CHECK-NEXT:    sw a0, 0(a2)
1855; CHECK-NEXT:    ret
1856entry:
1857  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 5), i32} @llvm.riscv.vlseg5ff.triscv.vector.tuple_nxv2i8_5t(target("riscv.vector.tuple", <vscale x 2 x i8>, 5) undef, ptr %base, i32 %vl, i32 4)
1858  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 5), i32} %0, 0
1859  %2 = call <vscale x 1 x i16> @llvm.riscv.tuple.extract.nxv1i16.triscv.vector.tuple_nxv2i8_5t(target("riscv.vector.tuple", <vscale x 2 x i8>, 5) %1, i32 1)
1860  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 5), i32} %0, 1
1861  store i32 %3, ptr %outvl
1862  ret <vscale x 1 x i16> %2
1863}
1864
1865define <vscale x 1 x i16> @test_vlseg5ff_mask_nxv1i16_triscv.vector.tuple_nxv2i8_5t(target("riscv.vector.tuple", <vscale x 2 x i8>, 5) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
1866; CHECK-LABEL: test_vlseg5ff_mask_nxv1i16_triscv.vector.tuple_nxv2i8_5t:
1867; CHECK:       # %bb.0: # %entry
1868; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, mu
1869; CHECK-NEXT:    vmv1r.v v7, v8
1870; CHECK-NEXT:    vmv1r.v v8, v9
1871; CHECK-NEXT:    vmv1r.v v9, v10
1872; CHECK-NEXT:    vmv1r.v v10, v11
1873; CHECK-NEXT:    vmv1r.v v11, v12
1874; CHECK-NEXT:    vlseg5e16ff.v v7, (a0), v0.t
1875; CHECK-NEXT:    csrr a0, vl
1876; CHECK-NEXT:    sw a0, 0(a2)
1877; CHECK-NEXT:    ret
1878entry:
1879  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 5), i32} @llvm.riscv.vlseg5ff.mask.triscv.vector.tuple_nxv2i8_5t.nxv1i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 5) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 4)
1880  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 5), i32} %0, 0
1881  %2 = call <vscale x 1 x i16> @llvm.riscv.tuple.extract.nxv1i16.triscv.vector.tuple_nxv2i8_5t(target("riscv.vector.tuple", <vscale x 2 x i8>, 5) %1, i32 1)
1882  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 5), i32} %0, 1
1883  store i32 %3, ptr %outvl
1884  ret <vscale x 1 x i16> %2
1885}
1886
1887declare {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} @llvm.riscv.vlseg5ff.mask.triscv.vector.tuple_nxv4i8_5t.nxv2i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 5), ptr, <vscale x 2 x i1>, i32, i32, i32)
1888
1889define <vscale x 2 x i16> @test_vlseg5ff_nxv2i16_triscv.vector.tuple_nxv4i8_5t(ptr %base, i32 %vl, ptr %outvl) {
1890; CHECK-LABEL: test_vlseg5ff_nxv2i16_triscv.vector.tuple_nxv4i8_5t:
1891; CHECK:       # %bb.0: # %entry
1892; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, ma
1893; CHECK-NEXT:    vlseg5e16ff.v v7, (a0)
1894; CHECK-NEXT:    csrr a0, vl
1895; CHECK-NEXT:    sw a0, 0(a2)
1896; CHECK-NEXT:    ret
1897entry:
1898  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} @llvm.riscv.vlseg5ff.triscv.vector.tuple_nxv4i8_5t(target("riscv.vector.tuple", <vscale x 4 x i8>, 5) undef, ptr %base, i32 %vl, i32 4)
1899  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} %0, 0
1900  %2 = call <vscale x 2 x i16> @llvm.riscv.tuple.extract.nxv2i16.triscv.vector.tuple_nxv4i8_5t(target("riscv.vector.tuple", <vscale x 4 x i8>, 5) %1, i32 1)
1901  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} %0, 1
1902  store i32 %3, ptr %outvl
1903  ret <vscale x 2 x i16> %2
1904}
1905
1906define <vscale x 2 x i16> @test_vlseg5ff_mask_nxv2i16_triscv.vector.tuple_nxv4i8_5t(target("riscv.vector.tuple", <vscale x 4 x i8>, 5) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
1907; CHECK-LABEL: test_vlseg5ff_mask_nxv2i16_triscv.vector.tuple_nxv4i8_5t:
1908; CHECK:       # %bb.0: # %entry
1909; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, mu
1910; CHECK-NEXT:    vmv1r.v v7, v8
1911; CHECK-NEXT:    vmv1r.v v8, v9
1912; CHECK-NEXT:    vmv1r.v v9, v10
1913; CHECK-NEXT:    vmv1r.v v10, v11
1914; CHECK-NEXT:    vmv1r.v v11, v12
1915; CHECK-NEXT:    vlseg5e16ff.v v7, (a0), v0.t
1916; CHECK-NEXT:    csrr a0, vl
1917; CHECK-NEXT:    sw a0, 0(a2)
1918; CHECK-NEXT:    ret
1919entry:
1920  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} @llvm.riscv.vlseg5ff.mask.triscv.vector.tuple_nxv4i8_5t.nxv2i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 5) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 4)
1921  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} %0, 0
1922  %2 = call <vscale x 2 x i16> @llvm.riscv.tuple.extract.nxv2i16.triscv.vector.tuple_nxv4i8_5t(target("riscv.vector.tuple", <vscale x 4 x i8>, 5) %1, i32 1)
1923  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} %0, 1
1924  store i32 %3, ptr %outvl
1925  ret <vscale x 2 x i16> %2
1926}
1927
1928declare {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} @llvm.riscv.vlseg5ff.mask.triscv.vector.tuple_nxv8i8_5t.nxv4i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 5), ptr, <vscale x 4 x i1>, i32, i32, i32)
1929
1930define <vscale x 4 x i16> @test_vlseg5ff_nxv4i16_triscv.vector.tuple_nxv8i8_5t(ptr %base, i32 %vl, ptr %outvl) {
1931; CHECK-LABEL: test_vlseg5ff_nxv4i16_triscv.vector.tuple_nxv8i8_5t:
1932; CHECK:       # %bb.0: # %entry
1933; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, ma
1934; CHECK-NEXT:    vlseg5e16ff.v v7, (a0)
1935; CHECK-NEXT:    csrr a0, vl
1936; CHECK-NEXT:    sw a0, 0(a2)
1937; CHECK-NEXT:    ret
1938entry:
1939  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} @llvm.riscv.vlseg5ff.triscv.vector.tuple_nxv8i8_5t(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) undef, ptr %base, i32 %vl, i32 4)
1940  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} %0, 0
1941  %2 = call <vscale x 4 x i16> @llvm.riscv.tuple.extract.nxv4i16.triscv.vector.tuple_nxv8i8_5t(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) %1, i32 1)
1942  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} %0, 1
1943  store i32 %3, ptr %outvl
1944  ret <vscale x 4 x i16> %2
1945}
1946
1947define <vscale x 4 x i16> @test_vlseg5ff_mask_nxv4i16_triscv.vector.tuple_nxv8i8_5t(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) %val, ptr %base, i32 %vl, <vscale x 4 x i1> %mask, ptr %outvl) {
1948; CHECK-LABEL: test_vlseg5ff_mask_nxv4i16_triscv.vector.tuple_nxv8i8_5t:
1949; CHECK:       # %bb.0: # %entry
1950; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, mu
1951; CHECK-NEXT:    vmv1r.v v7, v8
1952; CHECK-NEXT:    vmv1r.v v8, v9
1953; CHECK-NEXT:    vmv1r.v v9, v10
1954; CHECK-NEXT:    vmv1r.v v10, v11
1955; CHECK-NEXT:    vmv1r.v v11, v12
1956; CHECK-NEXT:    vlseg5e16ff.v v7, (a0), v0.t
1957; CHECK-NEXT:    csrr a0, vl
1958; CHECK-NEXT:    sw a0, 0(a2)
1959; CHECK-NEXT:    ret
1960entry:
1961  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} @llvm.riscv.vlseg5ff.mask.triscv.vector.tuple_nxv8i8_5t.nxv4i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) %val, ptr %base, <vscale x 4 x i1> %mask, i32 %vl, i32 1, i32 4)
1962  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} %0, 0
1963  %2 = call <vscale x 4 x i16> @llvm.riscv.tuple.extract.nxv4i16.triscv.vector.tuple_nxv8i8_5t(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) %1, i32 1)
1964  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} %0, 1
1965  store i32 %3, ptr %outvl
1966  ret <vscale x 4 x i16> %2
1967}
1968
1969declare {target("riscv.vector.tuple", <vscale x 2 x i8>, 6), i32} @llvm.riscv.vlseg6ff.mask.triscv.vector.tuple_nxv2i8_6t.nxv1i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 6), ptr, <vscale x 1 x i1>, i32, i32, i32)
1970
1971define <vscale x 1 x i16> @test_vlseg6ff_nxv1i16_triscv.vector.tuple_nxv2i8_6t(ptr %base, i32 %vl, ptr %outvl) {
1972; CHECK-LABEL: test_vlseg6ff_nxv1i16_triscv.vector.tuple_nxv2i8_6t:
1973; CHECK:       # %bb.0: # %entry
1974; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, ma
1975; CHECK-NEXT:    vlseg6e16ff.v v7, (a0)
1976; CHECK-NEXT:    csrr a0, vl
1977; CHECK-NEXT:    sw a0, 0(a2)
1978; CHECK-NEXT:    ret
1979entry:
1980  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 6), i32} @llvm.riscv.vlseg6ff.triscv.vector.tuple_nxv2i8_6t(target("riscv.vector.tuple", <vscale x 2 x i8>, 6) undef, ptr %base, i32 %vl, i32 4)
1981  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 6), i32} %0, 0
1982  %2 = call <vscale x 1 x i16> @llvm.riscv.tuple.extract.nxv1i16.triscv.vector.tuple_nxv2i8_6t(target("riscv.vector.tuple", <vscale x 2 x i8>, 6) %1, i32 1)
1983  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 6), i32} %0, 1
1984  store i32 %3, ptr %outvl
1985  ret <vscale x 1 x i16> %2
1986}
1987
1988define <vscale x 1 x i16> @test_vlseg6ff_mask_nxv1i16_triscv.vector.tuple_nxv2i8_6t(target("riscv.vector.tuple", <vscale x 2 x i8>, 6) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
1989; CHECK-LABEL: test_vlseg6ff_mask_nxv1i16_triscv.vector.tuple_nxv2i8_6t:
1990; CHECK:       # %bb.0: # %entry
1991; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, mu
1992; CHECK-NEXT:    vmv1r.v v7, v8
1993; CHECK-NEXT:    vmv1r.v v8, v9
1994; CHECK-NEXT:    vmv1r.v v9, v10
1995; CHECK-NEXT:    vmv1r.v v10, v11
1996; CHECK-NEXT:    vmv1r.v v11, v12
1997; CHECK-NEXT:    vmv1r.v v12, v13
1998; CHECK-NEXT:    vlseg6e16ff.v v7, (a0), v0.t
1999; CHECK-NEXT:    csrr a0, vl
2000; CHECK-NEXT:    sw a0, 0(a2)
2001; CHECK-NEXT:    ret
2002entry:
2003  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 6), i32} @llvm.riscv.vlseg6ff.mask.triscv.vector.tuple_nxv2i8_6t.nxv1i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 6) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 4)
2004  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 6), i32} %0, 0
2005  %2 = call <vscale x 1 x i16> @llvm.riscv.tuple.extract.nxv1i16.triscv.vector.tuple_nxv2i8_6t(target("riscv.vector.tuple", <vscale x 2 x i8>, 6) %1, i32 1)
2006  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 6), i32} %0, 1
2007  store i32 %3, ptr %outvl
2008  ret <vscale x 1 x i16> %2
2009}
2010
2011declare {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} @llvm.riscv.vlseg6ff.mask.triscv.vector.tuple_nxv4i8_6t.nxv2i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 6), ptr, <vscale x 2 x i1>, i32, i32, i32)
2012
2013define <vscale x 2 x i16> @test_vlseg6ff_nxv2i16_triscv.vector.tuple_nxv4i8_6t(ptr %base, i32 %vl, ptr %outvl) {
2014; CHECK-LABEL: test_vlseg6ff_nxv2i16_triscv.vector.tuple_nxv4i8_6t:
2015; CHECK:       # %bb.0: # %entry
2016; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, ma
2017; CHECK-NEXT:    vlseg6e16ff.v v7, (a0)
2018; CHECK-NEXT:    csrr a0, vl
2019; CHECK-NEXT:    sw a0, 0(a2)
2020; CHECK-NEXT:    ret
2021entry:
2022  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} @llvm.riscv.vlseg6ff.triscv.vector.tuple_nxv4i8_6t(target("riscv.vector.tuple", <vscale x 4 x i8>, 6) undef, ptr %base, i32 %vl, i32 4)
2023  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} %0, 0
2024  %2 = call <vscale x 2 x i16> @llvm.riscv.tuple.extract.nxv2i16.triscv.vector.tuple_nxv4i8_6t(target("riscv.vector.tuple", <vscale x 4 x i8>, 6) %1, i32 1)
2025  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} %0, 1
2026  store i32 %3, ptr %outvl
2027  ret <vscale x 2 x i16> %2
2028}
2029
2030define <vscale x 2 x i16> @test_vlseg6ff_mask_nxv2i16_triscv.vector.tuple_nxv4i8_6t(target("riscv.vector.tuple", <vscale x 4 x i8>, 6) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
2031; CHECK-LABEL: test_vlseg6ff_mask_nxv2i16_triscv.vector.tuple_nxv4i8_6t:
2032; CHECK:       # %bb.0: # %entry
2033; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, mu
2034; CHECK-NEXT:    vmv1r.v v7, v8
2035; CHECK-NEXT:    vmv1r.v v8, v9
2036; CHECK-NEXT:    vmv1r.v v9, v10
2037; CHECK-NEXT:    vmv1r.v v10, v11
2038; CHECK-NEXT:    vmv1r.v v11, v12
2039; CHECK-NEXT:    vmv1r.v v12, v13
2040; CHECK-NEXT:    vlseg6e16ff.v v7, (a0), v0.t
2041; CHECK-NEXT:    csrr a0, vl
2042; CHECK-NEXT:    sw a0, 0(a2)
2043; CHECK-NEXT:    ret
2044entry:
2045  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} @llvm.riscv.vlseg6ff.mask.triscv.vector.tuple_nxv4i8_6t.nxv2i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 6) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 4)
2046  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} %0, 0
2047  %2 = call <vscale x 2 x i16> @llvm.riscv.tuple.extract.nxv2i16.triscv.vector.tuple_nxv4i8_6t(target("riscv.vector.tuple", <vscale x 4 x i8>, 6) %1, i32 1)
2048  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} %0, 1
2049  store i32 %3, ptr %outvl
2050  ret <vscale x 2 x i16> %2
2051}
2052
2053declare {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} @llvm.riscv.vlseg6ff.mask.triscv.vector.tuple_nxv8i8_6t.nxv4i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 6), ptr, <vscale x 4 x i1>, i32, i32, i32)
2054
2055define <vscale x 4 x i16> @test_vlseg6ff_nxv4i16_triscv.vector.tuple_nxv8i8_6t(ptr %base, i32 %vl, ptr %outvl) {
2056; CHECK-LABEL: test_vlseg6ff_nxv4i16_triscv.vector.tuple_nxv8i8_6t:
2057; CHECK:       # %bb.0: # %entry
2058; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, ma
2059; CHECK-NEXT:    vlseg6e16ff.v v7, (a0)
2060; CHECK-NEXT:    csrr a0, vl
2061; CHECK-NEXT:    sw a0, 0(a2)
2062; CHECK-NEXT:    ret
2063entry:
2064  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} @llvm.riscv.vlseg6ff.triscv.vector.tuple_nxv8i8_6t(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) undef, ptr %base, i32 %vl, i32 4)
2065  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} %0, 0
2066  %2 = call <vscale x 4 x i16> @llvm.riscv.tuple.extract.nxv4i16.triscv.vector.tuple_nxv8i8_6t(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) %1, i32 1)
2067  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} %0, 1
2068  store i32 %3, ptr %outvl
2069  ret <vscale x 4 x i16> %2
2070}
2071
2072define <vscale x 4 x i16> @test_vlseg6ff_mask_nxv4i16_triscv.vector.tuple_nxv8i8_6t(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) %val, ptr %base, i32 %vl, <vscale x 4 x i1> %mask, ptr %outvl) {
2073; CHECK-LABEL: test_vlseg6ff_mask_nxv4i16_triscv.vector.tuple_nxv8i8_6t:
2074; CHECK:       # %bb.0: # %entry
2075; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, mu
2076; CHECK-NEXT:    vmv1r.v v7, v8
2077; CHECK-NEXT:    vmv1r.v v8, v9
2078; CHECK-NEXT:    vmv1r.v v9, v10
2079; CHECK-NEXT:    vmv1r.v v10, v11
2080; CHECK-NEXT:    vmv1r.v v11, v12
2081; CHECK-NEXT:    vmv1r.v v12, v13
2082; CHECK-NEXT:    vlseg6e16ff.v v7, (a0), v0.t
2083; CHECK-NEXT:    csrr a0, vl
2084; CHECK-NEXT:    sw a0, 0(a2)
2085; CHECK-NEXT:    ret
2086entry:
2087  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} @llvm.riscv.vlseg6ff.mask.triscv.vector.tuple_nxv8i8_6t.nxv4i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) %val, ptr %base, <vscale x 4 x i1> %mask, i32 %vl, i32 1, i32 4)
2088  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} %0, 0
2089  %2 = call <vscale x 4 x i16> @llvm.riscv.tuple.extract.nxv4i16.triscv.vector.tuple_nxv8i8_6t(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) %1, i32 1)
2090  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} %0, 1
2091  store i32 %3, ptr %outvl
2092  ret <vscale x 4 x i16> %2
2093}
2094
2095declare {target("riscv.vector.tuple", <vscale x 2 x i8>, 7), i32} @llvm.riscv.vlseg7ff.mask.triscv.vector.tuple_nxv2i8_7t.nxv1i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 7), ptr, <vscale x 1 x i1>, i32, i32, i32)
2096
2097define <vscale x 1 x i16> @test_vlseg7ff_nxv1i16_triscv.vector.tuple_nxv2i8_7t(ptr %base, i32 %vl, ptr %outvl) {
2098; CHECK-LABEL: test_vlseg7ff_nxv1i16_triscv.vector.tuple_nxv2i8_7t:
2099; CHECK:       # %bb.0: # %entry
2100; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, ma
2101; CHECK-NEXT:    vlseg7e16ff.v v7, (a0)
2102; CHECK-NEXT:    csrr a0, vl
2103; CHECK-NEXT:    sw a0, 0(a2)
2104; CHECK-NEXT:    ret
2105entry:
2106  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 7), i32} @llvm.riscv.vlseg7ff.triscv.vector.tuple_nxv2i8_7t(target("riscv.vector.tuple", <vscale x 2 x i8>, 7) undef, ptr %base, i32 %vl, i32 4)
2107  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 7), i32} %0, 0
2108  %2 = call <vscale x 1 x i16> @llvm.riscv.tuple.extract.nxv1i16.triscv.vector.tuple_nxv2i8_7t(target("riscv.vector.tuple", <vscale x 2 x i8>, 7) %1, i32 1)
2109  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 7), i32} %0, 1
2110  store i32 %3, ptr %outvl
2111  ret <vscale x 1 x i16> %2
2112}
2113
2114define <vscale x 1 x i16> @test_vlseg7ff_mask_nxv1i16_triscv.vector.tuple_nxv2i8_7t(target("riscv.vector.tuple", <vscale x 2 x i8>, 7) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
2115; CHECK-LABEL: test_vlseg7ff_mask_nxv1i16_triscv.vector.tuple_nxv2i8_7t:
2116; CHECK:       # %bb.0: # %entry
2117; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, mu
2118; CHECK-NEXT:    vmv1r.v v7, v8
2119; CHECK-NEXT:    vmv1r.v v8, v9
2120; CHECK-NEXT:    vmv1r.v v9, v10
2121; CHECK-NEXT:    vmv1r.v v10, v11
2122; CHECK-NEXT:    vmv1r.v v11, v12
2123; CHECK-NEXT:    vmv1r.v v12, v13
2124; CHECK-NEXT:    vmv1r.v v13, v14
2125; CHECK-NEXT:    vlseg7e16ff.v v7, (a0), v0.t
2126; CHECK-NEXT:    csrr a0, vl
2127; CHECK-NEXT:    sw a0, 0(a2)
2128; CHECK-NEXT:    ret
2129entry:
2130  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 7), i32} @llvm.riscv.vlseg7ff.mask.triscv.vector.tuple_nxv2i8_7t.nxv1i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 7) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 4)
2131  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 7), i32} %0, 0
2132  %2 = call <vscale x 1 x i16> @llvm.riscv.tuple.extract.nxv1i16.triscv.vector.tuple_nxv2i8_7t(target("riscv.vector.tuple", <vscale x 2 x i8>, 7) %1, i32 1)
2133  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 7), i32} %0, 1
2134  store i32 %3, ptr %outvl
2135  ret <vscale x 1 x i16> %2
2136}
2137
2138declare {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} @llvm.riscv.vlseg7ff.mask.triscv.vector.tuple_nxv4i8_7t.nxv2i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 7), ptr, <vscale x 2 x i1>, i32, i32, i32)
2139
2140define <vscale x 2 x i16> @test_vlseg7ff_nxv2i16_triscv.vector.tuple_nxv4i8_7t(ptr %base, i32 %vl, ptr %outvl) {
2141; CHECK-LABEL: test_vlseg7ff_nxv2i16_triscv.vector.tuple_nxv4i8_7t:
2142; CHECK:       # %bb.0: # %entry
2143; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, ma
2144; CHECK-NEXT:    vlseg7e16ff.v v7, (a0)
2145; CHECK-NEXT:    csrr a0, vl
2146; CHECK-NEXT:    sw a0, 0(a2)
2147; CHECK-NEXT:    ret
2148entry:
2149  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} @llvm.riscv.vlseg7ff.triscv.vector.tuple_nxv4i8_7t(target("riscv.vector.tuple", <vscale x 4 x i8>, 7) undef, ptr %base, i32 %vl, i32 4)
2150  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} %0, 0
2151  %2 = call <vscale x 2 x i16> @llvm.riscv.tuple.extract.nxv2i16.triscv.vector.tuple_nxv4i8_7t(target("riscv.vector.tuple", <vscale x 4 x i8>, 7) %1, i32 1)
2152  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} %0, 1
2153  store i32 %3, ptr %outvl
2154  ret <vscale x 2 x i16> %2
2155}
2156
2157define <vscale x 2 x i16> @test_vlseg7ff_mask_nxv2i16_triscv.vector.tuple_nxv4i8_7t(target("riscv.vector.tuple", <vscale x 4 x i8>, 7) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
2158; CHECK-LABEL: test_vlseg7ff_mask_nxv2i16_triscv.vector.tuple_nxv4i8_7t:
2159; CHECK:       # %bb.0: # %entry
2160; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, mu
2161; CHECK-NEXT:    vmv1r.v v7, v8
2162; CHECK-NEXT:    vmv1r.v v8, v9
2163; CHECK-NEXT:    vmv1r.v v9, v10
2164; CHECK-NEXT:    vmv1r.v v10, v11
2165; CHECK-NEXT:    vmv1r.v v11, v12
2166; CHECK-NEXT:    vmv1r.v v12, v13
2167; CHECK-NEXT:    vmv1r.v v13, v14
2168; CHECK-NEXT:    vlseg7e16ff.v v7, (a0), v0.t
2169; CHECK-NEXT:    csrr a0, vl
2170; CHECK-NEXT:    sw a0, 0(a2)
2171; CHECK-NEXT:    ret
2172entry:
2173  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} @llvm.riscv.vlseg7ff.mask.triscv.vector.tuple_nxv4i8_7t.nxv2i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 7) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 4)
2174  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} %0, 0
2175  %2 = call <vscale x 2 x i16> @llvm.riscv.tuple.extract.nxv2i16.triscv.vector.tuple_nxv4i8_7t(target("riscv.vector.tuple", <vscale x 4 x i8>, 7) %1, i32 1)
2176  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} %0, 1
2177  store i32 %3, ptr %outvl
2178  ret <vscale x 2 x i16> %2
2179}
2180
2181declare {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} @llvm.riscv.vlseg7ff.mask.triscv.vector.tuple_nxv8i8_7t.nxv4i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 7), ptr, <vscale x 4 x i1>, i32, i32, i32)
2182
2183define <vscale x 4 x i16> @test_vlseg7ff_nxv4i16_triscv.vector.tuple_nxv8i8_7t(ptr %base, i32 %vl, ptr %outvl) {
2184; CHECK-LABEL: test_vlseg7ff_nxv4i16_triscv.vector.tuple_nxv8i8_7t:
2185; CHECK:       # %bb.0: # %entry
2186; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, ma
2187; CHECK-NEXT:    vlseg7e16ff.v v7, (a0)
2188; CHECK-NEXT:    csrr a0, vl
2189; CHECK-NEXT:    sw a0, 0(a2)
2190; CHECK-NEXT:    ret
2191entry:
2192  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} @llvm.riscv.vlseg7ff.triscv.vector.tuple_nxv8i8_7t(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) undef, ptr %base, i32 %vl, i32 4)
2193  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} %0, 0
2194  %2 = call <vscale x 4 x i16> @llvm.riscv.tuple.extract.nxv4i16.triscv.vector.tuple_nxv8i8_7t(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) %1, i32 1)
2195  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} %0, 1
2196  store i32 %3, ptr %outvl
2197  ret <vscale x 4 x i16> %2
2198}
2199
2200define <vscale x 4 x i16> @test_vlseg7ff_mask_nxv4i16_triscv.vector.tuple_nxv8i8_7t(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) %val, ptr %base, i32 %vl, <vscale x 4 x i1> %mask, ptr %outvl) {
2201; CHECK-LABEL: test_vlseg7ff_mask_nxv4i16_triscv.vector.tuple_nxv8i8_7t:
2202; CHECK:       # %bb.0: # %entry
2203; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, mu
2204; CHECK-NEXT:    vmv1r.v v7, v8
2205; CHECK-NEXT:    vmv1r.v v8, v9
2206; CHECK-NEXT:    vmv1r.v v9, v10
2207; CHECK-NEXT:    vmv1r.v v10, v11
2208; CHECK-NEXT:    vmv1r.v v11, v12
2209; CHECK-NEXT:    vmv1r.v v12, v13
2210; CHECK-NEXT:    vmv1r.v v13, v14
2211; CHECK-NEXT:    vlseg7e16ff.v v7, (a0), v0.t
2212; CHECK-NEXT:    csrr a0, vl
2213; CHECK-NEXT:    sw a0, 0(a2)
2214; CHECK-NEXT:    ret
2215entry:
2216  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} @llvm.riscv.vlseg7ff.mask.triscv.vector.tuple_nxv8i8_7t.nxv4i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) %val, ptr %base, <vscale x 4 x i1> %mask, i32 %vl, i32 1, i32 4)
2217  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} %0, 0
2218  %2 = call <vscale x 4 x i16> @llvm.riscv.tuple.extract.nxv4i16.triscv.vector.tuple_nxv8i8_7t(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) %1, i32 1)
2219  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} %0, 1
2220  store i32 %3, ptr %outvl
2221  ret <vscale x 4 x i16> %2
2222}
2223
2224declare {target("riscv.vector.tuple", <vscale x 2 x i8>, 8), i32} @llvm.riscv.vlseg8ff.mask.triscv.vector.tuple_nxv2i8_8t.nxv1i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 8), ptr, <vscale x 1 x i1>, i32, i32, i32)
2225
2226define <vscale x 1 x i16> @test_vlseg8ff_nxv1i16_triscv.vector.tuple_nxv2i8_8t(ptr %base, i32 %vl, ptr %outvl) {
2227; CHECK-LABEL: test_vlseg8ff_nxv1i16_triscv.vector.tuple_nxv2i8_8t:
2228; CHECK:       # %bb.0: # %entry
2229; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, ma
2230; CHECK-NEXT:    vlseg8e16ff.v v7, (a0)
2231; CHECK-NEXT:    csrr a0, vl
2232; CHECK-NEXT:    sw a0, 0(a2)
2233; CHECK-NEXT:    ret
2234entry:
2235  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 8), i32} @llvm.riscv.vlseg8ff.triscv.vector.tuple_nxv2i8_8t(target("riscv.vector.tuple", <vscale x 2 x i8>, 8) undef, ptr %base, i32 %vl, i32 4)
2236  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 8), i32} %0, 0
2237  %2 = call <vscale x 1 x i16> @llvm.riscv.tuple.extract.nxv1i16.triscv.vector.tuple_nxv2i8_8t(target("riscv.vector.tuple", <vscale x 2 x i8>, 8) %1, i32 1)
2238  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 8), i32} %0, 1
2239  store i32 %3, ptr %outvl
2240  ret <vscale x 1 x i16> %2
2241}
2242
2243define <vscale x 1 x i16> @test_vlseg8ff_mask_nxv1i16_triscv.vector.tuple_nxv2i8_8t(target("riscv.vector.tuple", <vscale x 2 x i8>, 8) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
2244; CHECK-LABEL: test_vlseg8ff_mask_nxv1i16_triscv.vector.tuple_nxv2i8_8t:
2245; CHECK:       # %bb.0: # %entry
2246; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, mu
2247; CHECK-NEXT:    vmv1r.v v7, v8
2248; CHECK-NEXT:    vmv1r.v v8, v9
2249; CHECK-NEXT:    vmv1r.v v9, v10
2250; CHECK-NEXT:    vmv1r.v v10, v11
2251; CHECK-NEXT:    vmv1r.v v11, v12
2252; CHECK-NEXT:    vmv1r.v v12, v13
2253; CHECK-NEXT:    vmv1r.v v13, v14
2254; CHECK-NEXT:    vmv1r.v v14, v15
2255; CHECK-NEXT:    vlseg8e16ff.v v7, (a0), v0.t
2256; CHECK-NEXT:    csrr a0, vl
2257; CHECK-NEXT:    sw a0, 0(a2)
2258; CHECK-NEXT:    ret
2259entry:
2260  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 8), i32} @llvm.riscv.vlseg8ff.mask.triscv.vector.tuple_nxv2i8_8t.nxv1i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 8) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 4)
2261  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 8), i32} %0, 0
2262  %2 = call <vscale x 1 x i16> @llvm.riscv.tuple.extract.nxv1i16.triscv.vector.tuple_nxv2i8_8t(target("riscv.vector.tuple", <vscale x 2 x i8>, 8) %1, i32 1)
2263  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 8), i32} %0, 1
2264  store i32 %3, ptr %outvl
2265  ret <vscale x 1 x i16> %2
2266}
2267
2268declare {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} @llvm.riscv.vlseg8ff.mask.triscv.vector.tuple_nxv4i8_8t.nxv2i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 8), ptr, <vscale x 2 x i1>, i32, i32, i32)
2269
2270define <vscale x 2 x i16> @test_vlseg8ff_nxv2i16_triscv.vector.tuple_nxv4i8_8t(ptr %base, i32 %vl, ptr %outvl) {
2271; CHECK-LABEL: test_vlseg8ff_nxv2i16_triscv.vector.tuple_nxv4i8_8t:
2272; CHECK:       # %bb.0: # %entry
2273; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, ma
2274; CHECK-NEXT:    vlseg8e16ff.v v7, (a0)
2275; CHECK-NEXT:    csrr a0, vl
2276; CHECK-NEXT:    sw a0, 0(a2)
2277; CHECK-NEXT:    ret
2278entry:
2279  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} @llvm.riscv.vlseg8ff.triscv.vector.tuple_nxv4i8_8t(target("riscv.vector.tuple", <vscale x 4 x i8>, 8) undef, ptr %base, i32 %vl, i32 4)
2280  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} %0, 0
2281  %2 = call <vscale x 2 x i16> @llvm.riscv.tuple.extract.nxv2i16.triscv.vector.tuple_nxv4i8_8t(target("riscv.vector.tuple", <vscale x 4 x i8>, 8) %1, i32 1)
2282  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} %0, 1
2283  store i32 %3, ptr %outvl
2284  ret <vscale x 2 x i16> %2
2285}
2286
2287define <vscale x 2 x i16> @test_vlseg8ff_mask_nxv2i16_triscv.vector.tuple_nxv4i8_8t(target("riscv.vector.tuple", <vscale x 4 x i8>, 8) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
2288; CHECK-LABEL: test_vlseg8ff_mask_nxv2i16_triscv.vector.tuple_nxv4i8_8t:
2289; CHECK:       # %bb.0: # %entry
2290; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, mu
2291; CHECK-NEXT:    vmv1r.v v7, v8
2292; CHECK-NEXT:    vmv1r.v v8, v9
2293; CHECK-NEXT:    vmv1r.v v9, v10
2294; CHECK-NEXT:    vmv1r.v v10, v11
2295; CHECK-NEXT:    vmv1r.v v11, v12
2296; CHECK-NEXT:    vmv1r.v v12, v13
2297; CHECK-NEXT:    vmv1r.v v13, v14
2298; CHECK-NEXT:    vmv1r.v v14, v15
2299; CHECK-NEXT:    vlseg8e16ff.v v7, (a0), v0.t
2300; CHECK-NEXT:    csrr a0, vl
2301; CHECK-NEXT:    sw a0, 0(a2)
2302; CHECK-NEXT:    ret
2303entry:
2304  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} @llvm.riscv.vlseg8ff.mask.triscv.vector.tuple_nxv4i8_8t.nxv2i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 8) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 4)
2305  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} %0, 0
2306  %2 = call <vscale x 2 x i16> @llvm.riscv.tuple.extract.nxv2i16.triscv.vector.tuple_nxv4i8_8t(target("riscv.vector.tuple", <vscale x 4 x i8>, 8) %1, i32 1)
2307  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} %0, 1
2308  store i32 %3, ptr %outvl
2309  ret <vscale x 2 x i16> %2
2310}
2311
2312declare {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} @llvm.riscv.vlseg8ff.mask.triscv.vector.tuple_nxv8i8_8t.nxv4i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 8), ptr, <vscale x 4 x i1>, i32, i32, i32)
2313
2314define <vscale x 4 x i16> @test_vlseg8ff_nxv4i16_triscv.vector.tuple_nxv8i8_8t(ptr %base, i32 %vl, ptr %outvl) {
2315; CHECK-LABEL: test_vlseg8ff_nxv4i16_triscv.vector.tuple_nxv8i8_8t:
2316; CHECK:       # %bb.0: # %entry
2317; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, ma
2318; CHECK-NEXT:    vlseg8e16ff.v v7, (a0)
2319; CHECK-NEXT:    csrr a0, vl
2320; CHECK-NEXT:    sw a0, 0(a2)
2321; CHECK-NEXT:    ret
2322entry:
2323  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} @llvm.riscv.vlseg8ff.triscv.vector.tuple_nxv8i8_8t(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) undef, ptr %base, i32 %vl, i32 4)
2324  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} %0, 0
2325  %2 = call <vscale x 4 x i16> @llvm.riscv.tuple.extract.nxv4i16.triscv.vector.tuple_nxv8i8_8t(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) %1, i32 1)
2326  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} %0, 1
2327  store i32 %3, ptr %outvl
2328  ret <vscale x 4 x i16> %2
2329}
2330
2331define <vscale x 4 x i16> @test_vlseg8ff_mask_nxv4i16_triscv.vector.tuple_nxv8i8_8t(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) %val, ptr %base, i32 %vl, <vscale x 4 x i1> %mask, ptr %outvl) {
2332; CHECK-LABEL: test_vlseg8ff_mask_nxv4i16_triscv.vector.tuple_nxv8i8_8t:
2333; CHECK:       # %bb.0: # %entry
2334; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, mu
2335; CHECK-NEXT:    vmv1r.v v7, v8
2336; CHECK-NEXT:    vmv1r.v v8, v9
2337; CHECK-NEXT:    vmv1r.v v9, v10
2338; CHECK-NEXT:    vmv1r.v v10, v11
2339; CHECK-NEXT:    vmv1r.v v11, v12
2340; CHECK-NEXT:    vmv1r.v v12, v13
2341; CHECK-NEXT:    vmv1r.v v13, v14
2342; CHECK-NEXT:    vmv1r.v v14, v15
2343; CHECK-NEXT:    vlseg8e16ff.v v7, (a0), v0.t
2344; CHECK-NEXT:    csrr a0, vl
2345; CHECK-NEXT:    sw a0, 0(a2)
2346; CHECK-NEXT:    ret
2347entry:
2348  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} @llvm.riscv.vlseg8ff.mask.triscv.vector.tuple_nxv8i8_8t.nxv4i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) %val, ptr %base, <vscale x 4 x i1> %mask, i32 %vl, i32 1, i32 4)
2349  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} %0, 0
2350  %2 = call <vscale x 4 x i16> @llvm.riscv.tuple.extract.nxv4i16.triscv.vector.tuple_nxv8i8_8t(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) %1, i32 1)
2351  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} %0, 1
2352  store i32 %3, ptr %outvl
2353  ret <vscale x 4 x i16> %2
2354}
2355
2356declare {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv4i8_2t.nxv1i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 2), ptr, <vscale x 1 x i1>, i32, i32, i32)
2357
2358define <vscale x 1 x i32> @test_vlseg2ff_nxv1i32_triscv.vector.tuple_nxv4i8_2t(ptr %base, i32 %vl, ptr %outvl) {
2359; CHECK-LABEL: test_vlseg2ff_nxv1i32_triscv.vector.tuple_nxv4i8_2t:
2360; CHECK:       # %bb.0: # %entry
2361; CHECK-NEXT:    vsetvli zero, a1, e32, mf2, ta, ma
2362; CHECK-NEXT:    vlseg2e32ff.v v7, (a0)
2363; CHECK-NEXT:    csrr a0, vl
2364; CHECK-NEXT:    sw a0, 0(a2)
2365; CHECK-NEXT:    ret
2366entry:
2367  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv4i8_2t(target("riscv.vector.tuple", <vscale x 4 x i8>, 2) undef, ptr %base, i32 %vl, i32 5)
2368  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} %0, 0
2369  %2 = call <vscale x 1 x i32> @llvm.riscv.tuple.extract.nxv1i32.triscv.vector.tuple_nxv4i8_2t(target("riscv.vector.tuple", <vscale x 4 x i8>, 2) %1, i32 1)
2370  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} %0, 1
2371  store i32 %3, ptr %outvl
2372  ret <vscale x 1 x i32> %2
2373}
2374
2375define <vscale x 1 x i32> @test_vlseg2ff_mask_nxv1i32_triscv.vector.tuple_nxv4i8_2t(target("riscv.vector.tuple", <vscale x 4 x i8>, 2) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
2376; CHECK-LABEL: test_vlseg2ff_mask_nxv1i32_triscv.vector.tuple_nxv4i8_2t:
2377; CHECK:       # %bb.0: # %entry
2378; CHECK-NEXT:    vsetvli zero, a1, e32, mf2, ta, mu
2379; CHECK-NEXT:    vmv1r.v v7, v8
2380; CHECK-NEXT:    vmv1r.v v8, v9
2381; CHECK-NEXT:    vlseg2e32ff.v v7, (a0), v0.t
2382; CHECK-NEXT:    csrr a0, vl
2383; CHECK-NEXT:    sw a0, 0(a2)
2384; CHECK-NEXT:    ret
2385entry:
2386  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv4i8_2t.nxv1i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 2) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 5)
2387  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} %0, 0
2388  %2 = call <vscale x 1 x i32> @llvm.riscv.tuple.extract.nxv1i32.triscv.vector.tuple_nxv4i8_2t(target("riscv.vector.tuple", <vscale x 4 x i8>, 2) %1, i32 1)
2389  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} %0, 1
2390  store i32 %3, ptr %outvl
2391  ret <vscale x 1 x i32> %2
2392}
2393
2394declare {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv8i8_2t.nxv2i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 2), ptr, <vscale x 2 x i1>, i32, i32, i32)
2395
2396define <vscale x 2 x i32> @test_vlseg2ff_nxv2i32_triscv.vector.tuple_nxv8i8_2t(ptr %base, i32 %vl, ptr %outvl) {
2397; CHECK-LABEL: test_vlseg2ff_nxv2i32_triscv.vector.tuple_nxv8i8_2t:
2398; CHECK:       # %bb.0: # %entry
2399; CHECK-NEXT:    vsetvli zero, a1, e32, m1, ta, ma
2400; CHECK-NEXT:    vlseg2e32ff.v v7, (a0)
2401; CHECK-NEXT:    csrr a0, vl
2402; CHECK-NEXT:    sw a0, 0(a2)
2403; CHECK-NEXT:    ret
2404entry:
2405  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv8i8_2t(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) undef, ptr %base, i32 %vl, i32 5)
2406  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} %0, 0
2407  %2 = call <vscale x 2 x i32> @llvm.riscv.tuple.extract.nxv2i32.triscv.vector.tuple_nxv8i8_2t(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) %1, i32 1)
2408  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} %0, 1
2409  store i32 %3, ptr %outvl
2410  ret <vscale x 2 x i32> %2
2411}
2412
2413define <vscale x 2 x i32> @test_vlseg2ff_mask_nxv2i32_triscv.vector.tuple_nxv8i8_2t(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
2414; CHECK-LABEL: test_vlseg2ff_mask_nxv2i32_triscv.vector.tuple_nxv8i8_2t:
2415; CHECK:       # %bb.0: # %entry
2416; CHECK-NEXT:    vsetvli zero, a1, e32, m1, ta, mu
2417; CHECK-NEXT:    vmv1r.v v7, v8
2418; CHECK-NEXT:    vmv1r.v v8, v9
2419; CHECK-NEXT:    vlseg2e32ff.v v7, (a0), v0.t
2420; CHECK-NEXT:    csrr a0, vl
2421; CHECK-NEXT:    sw a0, 0(a2)
2422; CHECK-NEXT:    ret
2423entry:
2424  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv8i8_2t.nxv2i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 5)
2425  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} %0, 0
2426  %2 = call <vscale x 2 x i32> @llvm.riscv.tuple.extract.nxv2i32.triscv.vector.tuple_nxv8i8_2t(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) %1, i32 1)
2427  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} %0, 1
2428  store i32 %3, ptr %outvl
2429  ret <vscale x 2 x i32> %2
2430}
2431
2432declare {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv16i8_2t.nxv4i1(target("riscv.vector.tuple", <vscale x 16 x i8>, 2), ptr, <vscale x 4 x i1>, i32, i32, i32)
2433
2434define <vscale x 4 x i32> @test_vlseg2ff_nxv4i32_triscv.vector.tuple_nxv16i8_2t(ptr %base, i32 %vl, ptr %outvl) {
2435; CHECK-LABEL: test_vlseg2ff_nxv4i32_triscv.vector.tuple_nxv16i8_2t:
2436; CHECK:       # %bb.0: # %entry
2437; CHECK-NEXT:    vsetvli zero, a1, e32, m2, ta, ma
2438; CHECK-NEXT:    vlseg2e32ff.v v6, (a0)
2439; CHECK-NEXT:    csrr a0, vl
2440; CHECK-NEXT:    sw a0, 0(a2)
2441; CHECK-NEXT:    ret
2442entry:
2443  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv16i8_2t(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) undef, ptr %base, i32 %vl, i32 5)
2444  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} %0, 0
2445  %2 = call <vscale x 4 x i32> @llvm.riscv.tuple.extract.nxv4i32.triscv.vector.tuple_nxv16i8_2t(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) %1, i32 1)
2446  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} %0, 1
2447  store i32 %3, ptr %outvl
2448  ret <vscale x 4 x i32> %2
2449}
2450
2451define <vscale x 4 x i32> @test_vlseg2ff_mask_nxv4i32_triscv.vector.tuple_nxv16i8_2t(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) %val, ptr %base, i32 %vl, <vscale x 4 x i1> %mask, ptr %outvl) {
2452; CHECK-LABEL: test_vlseg2ff_mask_nxv4i32_triscv.vector.tuple_nxv16i8_2t:
2453; CHECK:       # %bb.0: # %entry
2454; CHECK-NEXT:    vsetvli zero, a1, e32, m2, ta, mu
2455; CHECK-NEXT:    vmv2r.v v6, v8
2456; CHECK-NEXT:    vmv2r.v v8, v10
2457; CHECK-NEXT:    vlseg2e32ff.v v6, (a0), v0.t
2458; CHECK-NEXT:    csrr a0, vl
2459; CHECK-NEXT:    sw a0, 0(a2)
2460; CHECK-NEXT:    ret
2461entry:
2462  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv16i8_2t.nxv4i1(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) %val, ptr %base, <vscale x 4 x i1> %mask, i32 %vl, i32 1, i32 5)
2463  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} %0, 0
2464  %2 = call <vscale x 4 x i32> @llvm.riscv.tuple.extract.nxv4i32.triscv.vector.tuple_nxv16i8_2t(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) %1, i32 1)
2465  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} %0, 1
2466  store i32 %3, ptr %outvl
2467  ret <vscale x 4 x i32> %2
2468}
2469
2470declare {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv32i8_2t.nxv8i1(target("riscv.vector.tuple", <vscale x 32 x i8>, 2), ptr, <vscale x 8 x i1>, i32, i32, i32)
2471
2472define <vscale x 8 x i32> @test_vlseg2ff_nxv8i32_triscv.vector.tuple_nxv32i8_2t(ptr %base, i32 %vl, ptr %outvl) {
2473; CHECK-LABEL: test_vlseg2ff_nxv8i32_triscv.vector.tuple_nxv32i8_2t:
2474; CHECK:       # %bb.0: # %entry
2475; CHECK-NEXT:    vsetvli zero, a1, e32, m4, ta, ma
2476; CHECK-NEXT:    vlseg2e32ff.v v4, (a0)
2477; CHECK-NEXT:    csrr a0, vl
2478; CHECK-NEXT:    sw a0, 0(a2)
2479; CHECK-NEXT:    ret
2480entry:
2481  %0 = tail call {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv32i8_2t(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) undef, ptr %base, i32 %vl, i32 5)
2482  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} %0, 0
2483  %2 = call <vscale x 8 x i32> @llvm.riscv.tuple.extract.nxv8i32.triscv.vector.tuple_nxv32i8_2t(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) %1, i32 1)
2484  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} %0, 1
2485  store i32 %3, ptr %outvl
2486  ret <vscale x 8 x i32> %2
2487}
2488
2489define <vscale x 8 x i32> @test_vlseg2ff_mask_nxv8i32_triscv.vector.tuple_nxv32i8_2t(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) %val, ptr %base, i32 %vl, <vscale x 8 x i1> %mask, ptr %outvl) {
2490; CHECK-LABEL: test_vlseg2ff_mask_nxv8i32_triscv.vector.tuple_nxv32i8_2t:
2491; CHECK:       # %bb.0: # %entry
2492; CHECK-NEXT:    vsetvli zero, a1, e32, m4, ta, mu
2493; CHECK-NEXT:    vmv4r.v v4, v8
2494; CHECK-NEXT:    vmv4r.v v8, v12
2495; CHECK-NEXT:    vlseg2e32ff.v v4, (a0), v0.t
2496; CHECK-NEXT:    csrr a0, vl
2497; CHECK-NEXT:    sw a0, 0(a2)
2498; CHECK-NEXT:    ret
2499entry:
2500  %0 = tail call {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv32i8_2t.nxv8i1(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) %val, ptr %base, <vscale x 8 x i1> %mask, i32 %vl, i32 1, i32 5)
2501  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} %0, 0
2502  %2 = call <vscale x 8 x i32> @llvm.riscv.tuple.extract.nxv8i32.triscv.vector.tuple_nxv32i8_2t(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) %1, i32 1)
2503  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} %0, 1
2504  store i32 %3, ptr %outvl
2505  ret <vscale x 8 x i32> %2
2506}
2507
2508declare {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv4i8_3t.nxv1i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 3), ptr, <vscale x 1 x i1>, i32, i32, i32)
2509
2510define <vscale x 1 x i32> @test_vlseg3ff_nxv1i32_triscv.vector.tuple_nxv4i8_3t(ptr %base, i32 %vl, ptr %outvl) {
2511; CHECK-LABEL: test_vlseg3ff_nxv1i32_triscv.vector.tuple_nxv4i8_3t:
2512; CHECK:       # %bb.0: # %entry
2513; CHECK-NEXT:    vsetvli zero, a1, e32, mf2, ta, ma
2514; CHECK-NEXT:    vlseg3e32ff.v v7, (a0)
2515; CHECK-NEXT:    csrr a0, vl
2516; CHECK-NEXT:    sw a0, 0(a2)
2517; CHECK-NEXT:    ret
2518entry:
2519  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} @llvm.riscv.vlseg3ff.triscv.vector.tuple_nxv4i8_3t(target("riscv.vector.tuple", <vscale x 4 x i8>, 3) undef, ptr %base, i32 %vl, i32 5)
2520  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} %0, 0
2521  %2 = call <vscale x 1 x i32> @llvm.riscv.tuple.extract.nxv1i32.triscv.vector.tuple_nxv4i8_3t(target("riscv.vector.tuple", <vscale x 4 x i8>, 3) %1, i32 1)
2522  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} %0, 1
2523  store i32 %3, ptr %outvl
2524  ret <vscale x 1 x i32> %2
2525}
2526
2527define <vscale x 1 x i32> @test_vlseg3ff_mask_nxv1i32_triscv.vector.tuple_nxv4i8_3t(target("riscv.vector.tuple", <vscale x 4 x i8>, 3) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
2528; CHECK-LABEL: test_vlseg3ff_mask_nxv1i32_triscv.vector.tuple_nxv4i8_3t:
2529; CHECK:       # %bb.0: # %entry
2530; CHECK-NEXT:    vsetvli zero, a1, e32, mf2, ta, mu
2531; CHECK-NEXT:    vmv1r.v v7, v8
2532; CHECK-NEXT:    vmv1r.v v8, v9
2533; CHECK-NEXT:    vmv1r.v v9, v10
2534; CHECK-NEXT:    vlseg3e32ff.v v7, (a0), v0.t
2535; CHECK-NEXT:    csrr a0, vl
2536; CHECK-NEXT:    sw a0, 0(a2)
2537; CHECK-NEXT:    ret
2538entry:
2539  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv4i8_3t.nxv1i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 3) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 5)
2540  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} %0, 0
2541  %2 = call <vscale x 1 x i32> @llvm.riscv.tuple.extract.nxv1i32.triscv.vector.tuple_nxv4i8_3t(target("riscv.vector.tuple", <vscale x 4 x i8>, 3) %1, i32 1)
2542  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} %0, 1
2543  store i32 %3, ptr %outvl
2544  ret <vscale x 1 x i32> %2
2545}
2546
2547declare {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv8i8_3t.nxv2i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 3), ptr, <vscale x 2 x i1>, i32, i32, i32)
2548
2549define <vscale x 2 x i32> @test_vlseg3ff_nxv2i32_triscv.vector.tuple_nxv8i8_3t(ptr %base, i32 %vl, ptr %outvl) {
2550; CHECK-LABEL: test_vlseg3ff_nxv2i32_triscv.vector.tuple_nxv8i8_3t:
2551; CHECK:       # %bb.0: # %entry
2552; CHECK-NEXT:    vsetvli zero, a1, e32, m1, ta, ma
2553; CHECK-NEXT:    vlseg3e32ff.v v7, (a0)
2554; CHECK-NEXT:    csrr a0, vl
2555; CHECK-NEXT:    sw a0, 0(a2)
2556; CHECK-NEXT:    ret
2557entry:
2558  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} @llvm.riscv.vlseg3ff.triscv.vector.tuple_nxv8i8_3t(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) undef, ptr %base, i32 %vl, i32 5)
2559  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} %0, 0
2560  %2 = call <vscale x 2 x i32> @llvm.riscv.tuple.extract.nxv2i32.triscv.vector.tuple_nxv8i8_3t(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) %1, i32 1)
2561  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} %0, 1
2562  store i32 %3, ptr %outvl
2563  ret <vscale x 2 x i32> %2
2564}
2565
2566define <vscale x 2 x i32> @test_vlseg3ff_mask_nxv2i32_triscv.vector.tuple_nxv8i8_3t(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
2567; CHECK-LABEL: test_vlseg3ff_mask_nxv2i32_triscv.vector.tuple_nxv8i8_3t:
2568; CHECK:       # %bb.0: # %entry
2569; CHECK-NEXT:    vsetvli zero, a1, e32, m1, ta, mu
2570; CHECK-NEXT:    vmv1r.v v7, v8
2571; CHECK-NEXT:    vmv1r.v v8, v9
2572; CHECK-NEXT:    vmv1r.v v9, v10
2573; CHECK-NEXT:    vlseg3e32ff.v v7, (a0), v0.t
2574; CHECK-NEXT:    csrr a0, vl
2575; CHECK-NEXT:    sw a0, 0(a2)
2576; CHECK-NEXT:    ret
2577entry:
2578  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv8i8_3t.nxv2i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 5)
2579  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} %0, 0
2580  %2 = call <vscale x 2 x i32> @llvm.riscv.tuple.extract.nxv2i32.triscv.vector.tuple_nxv8i8_3t(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) %1, i32 1)
2581  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} %0, 1
2582  store i32 %3, ptr %outvl
2583  ret <vscale x 2 x i32> %2
2584}
2585
2586declare {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv16i8_3t.nxv4i1(target("riscv.vector.tuple", <vscale x 16 x i8>, 3), ptr, <vscale x 4 x i1>, i32, i32, i32)
2587
2588define <vscale x 4 x i32> @test_vlseg3ff_nxv4i32_triscv.vector.tuple_nxv16i8_3t(ptr %base, i32 %vl, ptr %outvl) {
2589; CHECK-LABEL: test_vlseg3ff_nxv4i32_triscv.vector.tuple_nxv16i8_3t:
2590; CHECK:       # %bb.0: # %entry
2591; CHECK-NEXT:    vsetvli zero, a1, e32, m2, ta, ma
2592; CHECK-NEXT:    vlseg3e32ff.v v6, (a0)
2593; CHECK-NEXT:    csrr a0, vl
2594; CHECK-NEXT:    sw a0, 0(a2)
2595; CHECK-NEXT:    ret
2596entry:
2597  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} @llvm.riscv.vlseg3ff.triscv.vector.tuple_nxv16i8_3t(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) undef, ptr %base, i32 %vl, i32 5)
2598  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} %0, 0
2599  %2 = call <vscale x 4 x i32> @llvm.riscv.tuple.extract.nxv4i32.triscv.vector.tuple_nxv16i8_3t(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) %1, i32 1)
2600  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} %0, 1
2601  store i32 %3, ptr %outvl
2602  ret <vscale x 4 x i32> %2
2603}
2604
2605define <vscale x 4 x i32> @test_vlseg3ff_mask_nxv4i32_triscv.vector.tuple_nxv16i8_3t(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) %val, ptr %base, i32 %vl, <vscale x 4 x i1> %mask, ptr %outvl) {
2606; CHECK-LABEL: test_vlseg3ff_mask_nxv4i32_triscv.vector.tuple_nxv16i8_3t:
2607; CHECK:       # %bb.0: # %entry
2608; CHECK-NEXT:    vsetvli zero, a1, e32, m2, ta, mu
2609; CHECK-NEXT:    vmv2r.v v6, v8
2610; CHECK-NEXT:    vmv2r.v v8, v10
2611; CHECK-NEXT:    vmv2r.v v10, v12
2612; CHECK-NEXT:    vlseg3e32ff.v v6, (a0), v0.t
2613; CHECK-NEXT:    csrr a0, vl
2614; CHECK-NEXT:    sw a0, 0(a2)
2615; CHECK-NEXT:    ret
2616entry:
2617  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv16i8_3t.nxv4i1(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) %val, ptr %base, <vscale x 4 x i1> %mask, i32 %vl, i32 1, i32 5)
2618  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} %0, 0
2619  %2 = call <vscale x 4 x i32> @llvm.riscv.tuple.extract.nxv4i32.triscv.vector.tuple_nxv16i8_3t(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) %1, i32 1)
2620  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} %0, 1
2621  store i32 %3, ptr %outvl
2622  ret <vscale x 4 x i32> %2
2623}
2624
2625declare {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv4i8_4t.nxv1i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 4), ptr, <vscale x 1 x i1>, i32, i32, i32)
2626
2627define <vscale x 1 x i32> @test_vlseg4ff_nxv1i32_triscv.vector.tuple_nxv4i8_4t(ptr %base, i32 %vl, ptr %outvl) {
2628; CHECK-LABEL: test_vlseg4ff_nxv1i32_triscv.vector.tuple_nxv4i8_4t:
2629; CHECK:       # %bb.0: # %entry
2630; CHECK-NEXT:    vsetvli zero, a1, e32, mf2, ta, ma
2631; CHECK-NEXT:    vlseg4e32ff.v v7, (a0)
2632; CHECK-NEXT:    csrr a0, vl
2633; CHECK-NEXT:    sw a0, 0(a2)
2634; CHECK-NEXT:    ret
2635entry:
2636  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} @llvm.riscv.vlseg4ff.triscv.vector.tuple_nxv4i8_4t(target("riscv.vector.tuple", <vscale x 4 x i8>, 4) undef, ptr %base, i32 %vl, i32 5)
2637  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} %0, 0
2638  %2 = call <vscale x 1 x i32> @llvm.riscv.tuple.extract.nxv1i32.triscv.vector.tuple_nxv4i8_4t(target("riscv.vector.tuple", <vscale x 4 x i8>, 4) %1, i32 1)
2639  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} %0, 1
2640  store i32 %3, ptr %outvl
2641  ret <vscale x 1 x i32> %2
2642}
2643
2644define <vscale x 1 x i32> @test_vlseg4ff_mask_nxv1i32_triscv.vector.tuple_nxv4i8_4t(target("riscv.vector.tuple", <vscale x 4 x i8>, 4) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
2645; CHECK-LABEL: test_vlseg4ff_mask_nxv1i32_triscv.vector.tuple_nxv4i8_4t:
2646; CHECK:       # %bb.0: # %entry
2647; CHECK-NEXT:    vsetvli zero, a1, e32, mf2, ta, mu
2648; CHECK-NEXT:    vmv1r.v v7, v8
2649; CHECK-NEXT:    vmv1r.v v8, v9
2650; CHECK-NEXT:    vmv1r.v v9, v10
2651; CHECK-NEXT:    vmv1r.v v10, v11
2652; CHECK-NEXT:    vlseg4e32ff.v v7, (a0), v0.t
2653; CHECK-NEXT:    csrr a0, vl
2654; CHECK-NEXT:    sw a0, 0(a2)
2655; CHECK-NEXT:    ret
2656entry:
2657  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv4i8_4t.nxv1i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 4) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 5)
2658  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} %0, 0
2659  %2 = call <vscale x 1 x i32> @llvm.riscv.tuple.extract.nxv1i32.triscv.vector.tuple_nxv4i8_4t(target("riscv.vector.tuple", <vscale x 4 x i8>, 4) %1, i32 1)
2660  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} %0, 1
2661  store i32 %3, ptr %outvl
2662  ret <vscale x 1 x i32> %2
2663}
2664
2665declare {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv8i8_4t.nxv2i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 4), ptr, <vscale x 2 x i1>, i32, i32, i32)
2666
2667define <vscale x 2 x i32> @test_vlseg4ff_nxv2i32_triscv.vector.tuple_nxv8i8_4t(ptr %base, i32 %vl, ptr %outvl) {
2668; CHECK-LABEL: test_vlseg4ff_nxv2i32_triscv.vector.tuple_nxv8i8_4t:
2669; CHECK:       # %bb.0: # %entry
2670; CHECK-NEXT:    vsetvli zero, a1, e32, m1, ta, ma
2671; CHECK-NEXT:    vlseg4e32ff.v v7, (a0)
2672; CHECK-NEXT:    csrr a0, vl
2673; CHECK-NEXT:    sw a0, 0(a2)
2674; CHECK-NEXT:    ret
2675entry:
2676  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} @llvm.riscv.vlseg4ff.triscv.vector.tuple_nxv8i8_4t(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) undef, ptr %base, i32 %vl, i32 5)
2677  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} %0, 0
2678  %2 = call <vscale x 2 x i32> @llvm.riscv.tuple.extract.nxv2i32.triscv.vector.tuple_nxv8i8_4t(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) %1, i32 1)
2679  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} %0, 1
2680  store i32 %3, ptr %outvl
2681  ret <vscale x 2 x i32> %2
2682}
2683
2684define <vscale x 2 x i32> @test_vlseg4ff_mask_nxv2i32_triscv.vector.tuple_nxv8i8_4t(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
2685; CHECK-LABEL: test_vlseg4ff_mask_nxv2i32_triscv.vector.tuple_nxv8i8_4t:
2686; CHECK:       # %bb.0: # %entry
2687; CHECK-NEXT:    vsetvli zero, a1, e32, m1, ta, mu
2688; CHECK-NEXT:    vmv1r.v v7, v8
2689; CHECK-NEXT:    vmv1r.v v8, v9
2690; CHECK-NEXT:    vmv1r.v v9, v10
2691; CHECK-NEXT:    vmv1r.v v10, v11
2692; CHECK-NEXT:    vlseg4e32ff.v v7, (a0), v0.t
2693; CHECK-NEXT:    csrr a0, vl
2694; CHECK-NEXT:    sw a0, 0(a2)
2695; CHECK-NEXT:    ret
2696entry:
2697  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv8i8_4t.nxv2i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 5)
2698  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} %0, 0
2699  %2 = call <vscale x 2 x i32> @llvm.riscv.tuple.extract.nxv2i32.triscv.vector.tuple_nxv8i8_4t(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) %1, i32 1)
2700  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} %0, 1
2701  store i32 %3, ptr %outvl
2702  ret <vscale x 2 x i32> %2
2703}
2704
2705declare {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv16i8_4t.nxv4i1(target("riscv.vector.tuple", <vscale x 16 x i8>, 4), ptr, <vscale x 4 x i1>, i32, i32, i32)
2706
2707define <vscale x 4 x i32> @test_vlseg4ff_nxv4i32_triscv.vector.tuple_nxv16i8_4t(ptr %base, i32 %vl, ptr %outvl) {
2708; CHECK-LABEL: test_vlseg4ff_nxv4i32_triscv.vector.tuple_nxv16i8_4t:
2709; CHECK:       # %bb.0: # %entry
2710; CHECK-NEXT:    vsetvli zero, a1, e32, m2, ta, ma
2711; CHECK-NEXT:    vlseg4e32ff.v v6, (a0)
2712; CHECK-NEXT:    csrr a0, vl
2713; CHECK-NEXT:    sw a0, 0(a2)
2714; CHECK-NEXT:    ret
2715entry:
2716  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} @llvm.riscv.vlseg4ff.triscv.vector.tuple_nxv16i8_4t(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) undef, ptr %base, i32 %vl, i32 5)
2717  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} %0, 0
2718  %2 = call <vscale x 4 x i32> @llvm.riscv.tuple.extract.nxv4i32.triscv.vector.tuple_nxv16i8_4t(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) %1, i32 1)
2719  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} %0, 1
2720  store i32 %3, ptr %outvl
2721  ret <vscale x 4 x i32> %2
2722}
2723
2724define <vscale x 4 x i32> @test_vlseg4ff_mask_nxv4i32_triscv.vector.tuple_nxv16i8_4t(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) %val, ptr %base, i32 %vl, <vscale x 4 x i1> %mask, ptr %outvl) {
2725; CHECK-LABEL: test_vlseg4ff_mask_nxv4i32_triscv.vector.tuple_nxv16i8_4t:
2726; CHECK:       # %bb.0: # %entry
2727; CHECK-NEXT:    vsetvli zero, a1, e32, m2, ta, mu
2728; CHECK-NEXT:    vmv2r.v v6, v8
2729; CHECK-NEXT:    vmv2r.v v8, v10
2730; CHECK-NEXT:    vmv2r.v v10, v12
2731; CHECK-NEXT:    vmv2r.v v12, v14
2732; CHECK-NEXT:    vlseg4e32ff.v v6, (a0), v0.t
2733; CHECK-NEXT:    csrr a0, vl
2734; CHECK-NEXT:    sw a0, 0(a2)
2735; CHECK-NEXT:    ret
2736entry:
2737  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv16i8_4t.nxv4i1(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) %val, ptr %base, <vscale x 4 x i1> %mask, i32 %vl, i32 1, i32 5)
2738  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} %0, 0
2739  %2 = call <vscale x 4 x i32> @llvm.riscv.tuple.extract.nxv4i32.triscv.vector.tuple_nxv16i8_4t(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) %1, i32 1)
2740  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} %0, 1
2741  store i32 %3, ptr %outvl
2742  ret <vscale x 4 x i32> %2
2743}
2744
2745declare {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} @llvm.riscv.vlseg5ff.mask.triscv.vector.tuple_nxv4i8_5t.nxv1i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 5), ptr, <vscale x 1 x i1>, i32, i32, i32)
2746
2747define <vscale x 1 x i32> @test_vlseg5ff_nxv1i32_triscv.vector.tuple_nxv4i8_5t(ptr %base, i32 %vl, ptr %outvl) {
2748; CHECK-LABEL: test_vlseg5ff_nxv1i32_triscv.vector.tuple_nxv4i8_5t:
2749; CHECK:       # %bb.0: # %entry
2750; CHECK-NEXT:    vsetvli zero, a1, e32, mf2, ta, ma
2751; CHECK-NEXT:    vlseg5e32ff.v v7, (a0)
2752; CHECK-NEXT:    csrr a0, vl
2753; CHECK-NEXT:    sw a0, 0(a2)
2754; CHECK-NEXT:    ret
2755entry:
2756  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} @llvm.riscv.vlseg5ff.triscv.vector.tuple_nxv4i8_5t(target("riscv.vector.tuple", <vscale x 4 x i8>, 5) undef, ptr %base, i32 %vl, i32 5)
2757  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} %0, 0
2758  %2 = call <vscale x 1 x i32> @llvm.riscv.tuple.extract.nxv1i32.triscv.vector.tuple_nxv4i8_5t(target("riscv.vector.tuple", <vscale x 4 x i8>, 5) %1, i32 1)
2759  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} %0, 1
2760  store i32 %3, ptr %outvl
2761  ret <vscale x 1 x i32> %2
2762}
2763
2764define <vscale x 1 x i32> @test_vlseg5ff_mask_nxv1i32_triscv.vector.tuple_nxv4i8_5t(target("riscv.vector.tuple", <vscale x 4 x i8>, 5) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
2765; CHECK-LABEL: test_vlseg5ff_mask_nxv1i32_triscv.vector.tuple_nxv4i8_5t:
2766; CHECK:       # %bb.0: # %entry
2767; CHECK-NEXT:    vsetvli zero, a1, e32, mf2, ta, mu
2768; CHECK-NEXT:    vmv1r.v v7, v8
2769; CHECK-NEXT:    vmv1r.v v8, v9
2770; CHECK-NEXT:    vmv1r.v v9, v10
2771; CHECK-NEXT:    vmv1r.v v10, v11
2772; CHECK-NEXT:    vmv1r.v v11, v12
2773; CHECK-NEXT:    vlseg5e32ff.v v7, (a0), v0.t
2774; CHECK-NEXT:    csrr a0, vl
2775; CHECK-NEXT:    sw a0, 0(a2)
2776; CHECK-NEXT:    ret
2777entry:
2778  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} @llvm.riscv.vlseg5ff.mask.triscv.vector.tuple_nxv4i8_5t.nxv1i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 5) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 5)
2779  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} %0, 0
2780  %2 = call <vscale x 1 x i32> @llvm.riscv.tuple.extract.nxv1i32.triscv.vector.tuple_nxv4i8_5t(target("riscv.vector.tuple", <vscale x 4 x i8>, 5) %1, i32 1)
2781  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} %0, 1
2782  store i32 %3, ptr %outvl
2783  ret <vscale x 1 x i32> %2
2784}
2785
2786declare {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} @llvm.riscv.vlseg5ff.mask.triscv.vector.tuple_nxv8i8_5t.nxv2i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 5), ptr, <vscale x 2 x i1>, i32, i32, i32)
2787
2788define <vscale x 2 x i32> @test_vlseg5ff_nxv2i32_triscv.vector.tuple_nxv8i8_5t(ptr %base, i32 %vl, ptr %outvl) {
2789; CHECK-LABEL: test_vlseg5ff_nxv2i32_triscv.vector.tuple_nxv8i8_5t:
2790; CHECK:       # %bb.0: # %entry
2791; CHECK-NEXT:    vsetvli zero, a1, e32, m1, ta, ma
2792; CHECK-NEXT:    vlseg5e32ff.v v7, (a0)
2793; CHECK-NEXT:    csrr a0, vl
2794; CHECK-NEXT:    sw a0, 0(a2)
2795; CHECK-NEXT:    ret
2796entry:
2797  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} @llvm.riscv.vlseg5ff.triscv.vector.tuple_nxv8i8_5t(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) undef, ptr %base, i32 %vl, i32 5)
2798  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} %0, 0
2799  %2 = call <vscale x 2 x i32> @llvm.riscv.tuple.extract.nxv2i32.triscv.vector.tuple_nxv8i8_5t(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) %1, i32 1)
2800  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} %0, 1
2801  store i32 %3, ptr %outvl
2802  ret <vscale x 2 x i32> %2
2803}
2804
2805define <vscale x 2 x i32> @test_vlseg5ff_mask_nxv2i32_triscv.vector.tuple_nxv8i8_5t(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
2806; CHECK-LABEL: test_vlseg5ff_mask_nxv2i32_triscv.vector.tuple_nxv8i8_5t:
2807; CHECK:       # %bb.0: # %entry
2808; CHECK-NEXT:    vsetvli zero, a1, e32, m1, ta, mu
2809; CHECK-NEXT:    vmv1r.v v7, v8
2810; CHECK-NEXT:    vmv1r.v v8, v9
2811; CHECK-NEXT:    vmv1r.v v9, v10
2812; CHECK-NEXT:    vmv1r.v v10, v11
2813; CHECK-NEXT:    vmv1r.v v11, v12
2814; CHECK-NEXT:    vlseg5e32ff.v v7, (a0), v0.t
2815; CHECK-NEXT:    csrr a0, vl
2816; CHECK-NEXT:    sw a0, 0(a2)
2817; CHECK-NEXT:    ret
2818entry:
2819  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} @llvm.riscv.vlseg5ff.mask.triscv.vector.tuple_nxv8i8_5t.nxv2i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 5)
2820  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} %0, 0
2821  %2 = call <vscale x 2 x i32> @llvm.riscv.tuple.extract.nxv2i32.triscv.vector.tuple_nxv8i8_5t(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) %1, i32 1)
2822  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} %0, 1
2823  store i32 %3, ptr %outvl
2824  ret <vscale x 2 x i32> %2
2825}
2826
2827declare {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} @llvm.riscv.vlseg6ff.mask.triscv.vector.tuple_nxv4i8_6t.nxv1i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 6), ptr, <vscale x 1 x i1>, i32, i32, i32)
2828
2829define <vscale x 1 x i32> @test_vlseg6ff_nxv1i32_triscv.vector.tuple_nxv4i8_6t(ptr %base, i32 %vl, ptr %outvl) {
2830; CHECK-LABEL: test_vlseg6ff_nxv1i32_triscv.vector.tuple_nxv4i8_6t:
2831; CHECK:       # %bb.0: # %entry
2832; CHECK-NEXT:    vsetvli zero, a1, e32, mf2, ta, ma
2833; CHECK-NEXT:    vlseg6e32ff.v v7, (a0)
2834; CHECK-NEXT:    csrr a0, vl
2835; CHECK-NEXT:    sw a0, 0(a2)
2836; CHECK-NEXT:    ret
2837entry:
2838  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} @llvm.riscv.vlseg6ff.triscv.vector.tuple_nxv4i8_6t(target("riscv.vector.tuple", <vscale x 4 x i8>, 6) undef, ptr %base, i32 %vl, i32 5)
2839  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} %0, 0
2840  %2 = call <vscale x 1 x i32> @llvm.riscv.tuple.extract.nxv1i32.triscv.vector.tuple_nxv4i8_6t(target("riscv.vector.tuple", <vscale x 4 x i8>, 6) %1, i32 1)
2841  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} %0, 1
2842  store i32 %3, ptr %outvl
2843  ret <vscale x 1 x i32> %2
2844}
2845
2846define <vscale x 1 x i32> @test_vlseg6ff_mask_nxv1i32_triscv.vector.tuple_nxv4i8_6t(target("riscv.vector.tuple", <vscale x 4 x i8>, 6) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
2847; CHECK-LABEL: test_vlseg6ff_mask_nxv1i32_triscv.vector.tuple_nxv4i8_6t:
2848; CHECK:       # %bb.0: # %entry
2849; CHECK-NEXT:    vsetvli zero, a1, e32, mf2, ta, mu
2850; CHECK-NEXT:    vmv1r.v v7, v8
2851; CHECK-NEXT:    vmv1r.v v8, v9
2852; CHECK-NEXT:    vmv1r.v v9, v10
2853; CHECK-NEXT:    vmv1r.v v10, v11
2854; CHECK-NEXT:    vmv1r.v v11, v12
2855; CHECK-NEXT:    vmv1r.v v12, v13
2856; CHECK-NEXT:    vlseg6e32ff.v v7, (a0), v0.t
2857; CHECK-NEXT:    csrr a0, vl
2858; CHECK-NEXT:    sw a0, 0(a2)
2859; CHECK-NEXT:    ret
2860entry:
2861  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} @llvm.riscv.vlseg6ff.mask.triscv.vector.tuple_nxv4i8_6t.nxv1i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 6) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 5)
2862  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} %0, 0
2863  %2 = call <vscale x 1 x i32> @llvm.riscv.tuple.extract.nxv1i32.triscv.vector.tuple_nxv4i8_6t(target("riscv.vector.tuple", <vscale x 4 x i8>, 6) %1, i32 1)
2864  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} %0, 1
2865  store i32 %3, ptr %outvl
2866  ret <vscale x 1 x i32> %2
2867}
2868
2869declare {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} @llvm.riscv.vlseg6ff.mask.triscv.vector.tuple_nxv8i8_6t.nxv2i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 6), ptr, <vscale x 2 x i1>, i32, i32, i32)
2870
2871define <vscale x 2 x i32> @test_vlseg6ff_nxv2i32_triscv.vector.tuple_nxv8i8_6t(ptr %base, i32 %vl, ptr %outvl) {
2872; CHECK-LABEL: test_vlseg6ff_nxv2i32_triscv.vector.tuple_nxv8i8_6t:
2873; CHECK:       # %bb.0: # %entry
2874; CHECK-NEXT:    vsetvli zero, a1, e32, m1, ta, ma
2875; CHECK-NEXT:    vlseg6e32ff.v v7, (a0)
2876; CHECK-NEXT:    csrr a0, vl
2877; CHECK-NEXT:    sw a0, 0(a2)
2878; CHECK-NEXT:    ret
2879entry:
2880  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} @llvm.riscv.vlseg6ff.triscv.vector.tuple_nxv8i8_6t(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) undef, ptr %base, i32 %vl, i32 5)
2881  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} %0, 0
2882  %2 = call <vscale x 2 x i32> @llvm.riscv.tuple.extract.nxv2i32.triscv.vector.tuple_nxv8i8_6t(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) %1, i32 1)
2883  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} %0, 1
2884  store i32 %3, ptr %outvl
2885  ret <vscale x 2 x i32> %2
2886}
2887
2888define <vscale x 2 x i32> @test_vlseg6ff_mask_nxv2i32_triscv.vector.tuple_nxv8i8_6t(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
2889; CHECK-LABEL: test_vlseg6ff_mask_nxv2i32_triscv.vector.tuple_nxv8i8_6t:
2890; CHECK:       # %bb.0: # %entry
2891; CHECK-NEXT:    vsetvli zero, a1, e32, m1, ta, mu
2892; CHECK-NEXT:    vmv1r.v v7, v8
2893; CHECK-NEXT:    vmv1r.v v8, v9
2894; CHECK-NEXT:    vmv1r.v v9, v10
2895; CHECK-NEXT:    vmv1r.v v10, v11
2896; CHECK-NEXT:    vmv1r.v v11, v12
2897; CHECK-NEXT:    vmv1r.v v12, v13
2898; CHECK-NEXT:    vlseg6e32ff.v v7, (a0), v0.t
2899; CHECK-NEXT:    csrr a0, vl
2900; CHECK-NEXT:    sw a0, 0(a2)
2901; CHECK-NEXT:    ret
2902entry:
2903  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} @llvm.riscv.vlseg6ff.mask.triscv.vector.tuple_nxv8i8_6t.nxv2i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 5)
2904  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} %0, 0
2905  %2 = call <vscale x 2 x i32> @llvm.riscv.tuple.extract.nxv2i32.triscv.vector.tuple_nxv8i8_6t(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) %1, i32 1)
2906  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} %0, 1
2907  store i32 %3, ptr %outvl
2908  ret <vscale x 2 x i32> %2
2909}
2910
2911declare {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} @llvm.riscv.vlseg7ff.mask.triscv.vector.tuple_nxv4i8_7t.nxv1i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 7), ptr, <vscale x 1 x i1>, i32, i32, i32)
2912
2913define <vscale x 1 x i32> @test_vlseg7ff_nxv1i32_triscv.vector.tuple_nxv4i8_7t(ptr %base, i32 %vl, ptr %outvl) {
2914; CHECK-LABEL: test_vlseg7ff_nxv1i32_triscv.vector.tuple_nxv4i8_7t:
2915; CHECK:       # %bb.0: # %entry
2916; CHECK-NEXT:    vsetvli zero, a1, e32, mf2, ta, ma
2917; CHECK-NEXT:    vlseg7e32ff.v v7, (a0)
2918; CHECK-NEXT:    csrr a0, vl
2919; CHECK-NEXT:    sw a0, 0(a2)
2920; CHECK-NEXT:    ret
2921entry:
2922  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} @llvm.riscv.vlseg7ff.triscv.vector.tuple_nxv4i8_7t(target("riscv.vector.tuple", <vscale x 4 x i8>, 7) undef, ptr %base, i32 %vl, i32 5)
2923  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} %0, 0
2924  %2 = call <vscale x 1 x i32> @llvm.riscv.tuple.extract.nxv1i32.triscv.vector.tuple_nxv4i8_7t(target("riscv.vector.tuple", <vscale x 4 x i8>, 7) %1, i32 1)
2925  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} %0, 1
2926  store i32 %3, ptr %outvl
2927  ret <vscale x 1 x i32> %2
2928}
2929
2930define <vscale x 1 x i32> @test_vlseg7ff_mask_nxv1i32_triscv.vector.tuple_nxv4i8_7t(target("riscv.vector.tuple", <vscale x 4 x i8>, 7) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
2931; CHECK-LABEL: test_vlseg7ff_mask_nxv1i32_triscv.vector.tuple_nxv4i8_7t:
2932; CHECK:       # %bb.0: # %entry
2933; CHECK-NEXT:    vsetvli zero, a1, e32, mf2, ta, mu
2934; CHECK-NEXT:    vmv1r.v v7, v8
2935; CHECK-NEXT:    vmv1r.v v8, v9
2936; CHECK-NEXT:    vmv1r.v v9, v10
2937; CHECK-NEXT:    vmv1r.v v10, v11
2938; CHECK-NEXT:    vmv1r.v v11, v12
2939; CHECK-NEXT:    vmv1r.v v12, v13
2940; CHECK-NEXT:    vmv1r.v v13, v14
2941; CHECK-NEXT:    vlseg7e32ff.v v7, (a0), v0.t
2942; CHECK-NEXT:    csrr a0, vl
2943; CHECK-NEXT:    sw a0, 0(a2)
2944; CHECK-NEXT:    ret
2945entry:
2946  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} @llvm.riscv.vlseg7ff.mask.triscv.vector.tuple_nxv4i8_7t.nxv1i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 7) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 5)
2947  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} %0, 0
2948  %2 = call <vscale x 1 x i32> @llvm.riscv.tuple.extract.nxv1i32.triscv.vector.tuple_nxv4i8_7t(target("riscv.vector.tuple", <vscale x 4 x i8>, 7) %1, i32 1)
2949  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} %0, 1
2950  store i32 %3, ptr %outvl
2951  ret <vscale x 1 x i32> %2
2952}
2953
2954declare {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} @llvm.riscv.vlseg7ff.mask.triscv.vector.tuple_nxv8i8_7t.nxv2i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 7), ptr, <vscale x 2 x i1>, i32, i32, i32)
2955
2956define <vscale x 2 x i32> @test_vlseg7ff_nxv2i32_triscv.vector.tuple_nxv8i8_7t(ptr %base, i32 %vl, ptr %outvl) {
2957; CHECK-LABEL: test_vlseg7ff_nxv2i32_triscv.vector.tuple_nxv8i8_7t:
2958; CHECK:       # %bb.0: # %entry
2959; CHECK-NEXT:    vsetvli zero, a1, e32, m1, ta, ma
2960; CHECK-NEXT:    vlseg7e32ff.v v7, (a0)
2961; CHECK-NEXT:    csrr a0, vl
2962; CHECK-NEXT:    sw a0, 0(a2)
2963; CHECK-NEXT:    ret
2964entry:
2965  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} @llvm.riscv.vlseg7ff.triscv.vector.tuple_nxv8i8_7t(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) undef, ptr %base, i32 %vl, i32 5)
2966  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} %0, 0
2967  %2 = call <vscale x 2 x i32> @llvm.riscv.tuple.extract.nxv2i32.triscv.vector.tuple_nxv8i8_7t(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) %1, i32 1)
2968  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} %0, 1
2969  store i32 %3, ptr %outvl
2970  ret <vscale x 2 x i32> %2
2971}
2972
2973define <vscale x 2 x i32> @test_vlseg7ff_mask_nxv2i32_triscv.vector.tuple_nxv8i8_7t(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
2974; CHECK-LABEL: test_vlseg7ff_mask_nxv2i32_triscv.vector.tuple_nxv8i8_7t:
2975; CHECK:       # %bb.0: # %entry
2976; CHECK-NEXT:    vsetvli zero, a1, e32, m1, ta, mu
2977; CHECK-NEXT:    vmv1r.v v7, v8
2978; CHECK-NEXT:    vmv1r.v v8, v9
2979; CHECK-NEXT:    vmv1r.v v9, v10
2980; CHECK-NEXT:    vmv1r.v v10, v11
2981; CHECK-NEXT:    vmv1r.v v11, v12
2982; CHECK-NEXT:    vmv1r.v v12, v13
2983; CHECK-NEXT:    vmv1r.v v13, v14
2984; CHECK-NEXT:    vlseg7e32ff.v v7, (a0), v0.t
2985; CHECK-NEXT:    csrr a0, vl
2986; CHECK-NEXT:    sw a0, 0(a2)
2987; CHECK-NEXT:    ret
2988entry:
2989  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} @llvm.riscv.vlseg7ff.mask.triscv.vector.tuple_nxv8i8_7t.nxv2i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 5)
2990  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} %0, 0
2991  %2 = call <vscale x 2 x i32> @llvm.riscv.tuple.extract.nxv2i32.triscv.vector.tuple_nxv8i8_7t(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) %1, i32 1)
2992  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} %0, 1
2993  store i32 %3, ptr %outvl
2994  ret <vscale x 2 x i32> %2
2995}
2996
2997declare {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} @llvm.riscv.vlseg8ff.mask.triscv.vector.tuple_nxv4i8_8t.nxv1i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 8), ptr, <vscale x 1 x i1>, i32, i32, i32)
2998
2999define <vscale x 1 x i32> @test_vlseg8ff_nxv1i32_triscv.vector.tuple_nxv4i8_8t(ptr %base, i32 %vl, ptr %outvl) {
3000; CHECK-LABEL: test_vlseg8ff_nxv1i32_triscv.vector.tuple_nxv4i8_8t:
3001; CHECK:       # %bb.0: # %entry
3002; CHECK-NEXT:    vsetvli zero, a1, e32, mf2, ta, ma
3003; CHECK-NEXT:    vlseg8e32ff.v v7, (a0)
3004; CHECK-NEXT:    csrr a0, vl
3005; CHECK-NEXT:    sw a0, 0(a2)
3006; CHECK-NEXT:    ret
3007entry:
3008  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} @llvm.riscv.vlseg8ff.triscv.vector.tuple_nxv4i8_8t(target("riscv.vector.tuple", <vscale x 4 x i8>, 8) undef, ptr %base, i32 %vl, i32 5)
3009  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} %0, 0
3010  %2 = call <vscale x 1 x i32> @llvm.riscv.tuple.extract.nxv1i32.triscv.vector.tuple_nxv4i8_8t(target("riscv.vector.tuple", <vscale x 4 x i8>, 8) %1, i32 1)
3011  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} %0, 1
3012  store i32 %3, ptr %outvl
3013  ret <vscale x 1 x i32> %2
3014}
3015
3016define <vscale x 1 x i32> @test_vlseg8ff_mask_nxv1i32_triscv.vector.tuple_nxv4i8_8t(target("riscv.vector.tuple", <vscale x 4 x i8>, 8) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
3017; CHECK-LABEL: test_vlseg8ff_mask_nxv1i32_triscv.vector.tuple_nxv4i8_8t:
3018; CHECK:       # %bb.0: # %entry
3019; CHECK-NEXT:    vsetvli zero, a1, e32, mf2, ta, mu
3020; CHECK-NEXT:    vmv1r.v v7, v8
3021; CHECK-NEXT:    vmv1r.v v8, v9
3022; CHECK-NEXT:    vmv1r.v v9, v10
3023; CHECK-NEXT:    vmv1r.v v10, v11
3024; CHECK-NEXT:    vmv1r.v v11, v12
3025; CHECK-NEXT:    vmv1r.v v12, v13
3026; CHECK-NEXT:    vmv1r.v v13, v14
3027; CHECK-NEXT:    vmv1r.v v14, v15
3028; CHECK-NEXT:    vlseg8e32ff.v v7, (a0), v0.t
3029; CHECK-NEXT:    csrr a0, vl
3030; CHECK-NEXT:    sw a0, 0(a2)
3031; CHECK-NEXT:    ret
3032entry:
3033  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} @llvm.riscv.vlseg8ff.mask.triscv.vector.tuple_nxv4i8_8t.nxv1i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 8) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 5)
3034  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} %0, 0
3035  %2 = call <vscale x 1 x i32> @llvm.riscv.tuple.extract.nxv1i32.triscv.vector.tuple_nxv4i8_8t(target("riscv.vector.tuple", <vscale x 4 x i8>, 8) %1, i32 1)
3036  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} %0, 1
3037  store i32 %3, ptr %outvl
3038  ret <vscale x 1 x i32> %2
3039}
3040
3041declare {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} @llvm.riscv.vlseg8ff.mask.triscv.vector.tuple_nxv8i8_8t.nxv2i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 8), ptr, <vscale x 2 x i1>, i32, i32, i32)
3042
3043define <vscale x 2 x i32> @test_vlseg8ff_nxv2i32_triscv.vector.tuple_nxv8i8_8t(ptr %base, i32 %vl, ptr %outvl) {
3044; CHECK-LABEL: test_vlseg8ff_nxv2i32_triscv.vector.tuple_nxv8i8_8t:
3045; CHECK:       # %bb.0: # %entry
3046; CHECK-NEXT:    vsetvli zero, a1, e32, m1, ta, ma
3047; CHECK-NEXT:    vlseg8e32ff.v v7, (a0)
3048; CHECK-NEXT:    csrr a0, vl
3049; CHECK-NEXT:    sw a0, 0(a2)
3050; CHECK-NEXT:    ret
3051entry:
3052  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} @llvm.riscv.vlseg8ff.triscv.vector.tuple_nxv8i8_8t(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) undef, ptr %base, i32 %vl, i32 5)
3053  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} %0, 0
3054  %2 = call <vscale x 2 x i32> @llvm.riscv.tuple.extract.nxv2i32.triscv.vector.tuple_nxv8i8_8t(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) %1, i32 1)
3055  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} %0, 1
3056  store i32 %3, ptr %outvl
3057  ret <vscale x 2 x i32> %2
3058}
3059
3060define <vscale x 2 x i32> @test_vlseg8ff_mask_nxv2i32_triscv.vector.tuple_nxv8i8_8t(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
3061; CHECK-LABEL: test_vlseg8ff_mask_nxv2i32_triscv.vector.tuple_nxv8i8_8t:
3062; CHECK:       # %bb.0: # %entry
3063; CHECK-NEXT:    vsetvli zero, a1, e32, m1, ta, mu
3064; CHECK-NEXT:    vmv1r.v v7, v8
3065; CHECK-NEXT:    vmv1r.v v8, v9
3066; CHECK-NEXT:    vmv1r.v v9, v10
3067; CHECK-NEXT:    vmv1r.v v10, v11
3068; CHECK-NEXT:    vmv1r.v v11, v12
3069; CHECK-NEXT:    vmv1r.v v12, v13
3070; CHECK-NEXT:    vmv1r.v v13, v14
3071; CHECK-NEXT:    vmv1r.v v14, v15
3072; CHECK-NEXT:    vlseg8e32ff.v v7, (a0), v0.t
3073; CHECK-NEXT:    csrr a0, vl
3074; CHECK-NEXT:    sw a0, 0(a2)
3075; CHECK-NEXT:    ret
3076entry:
3077  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} @llvm.riscv.vlseg8ff.mask.triscv.vector.tuple_nxv8i8_8t.nxv2i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 5)
3078  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} %0, 0
3079  %2 = call <vscale x 2 x i32> @llvm.riscv.tuple.extract.nxv2i32.triscv.vector.tuple_nxv8i8_8t(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) %1, i32 1)
3080  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} %0, 1
3081  store i32 %3, ptr %outvl
3082  ret <vscale x 2 x i32> %2
3083}
3084
3085declare {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv8i8_2t.nxv1i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 2), ptr, <vscale x 1 x i1>, i32, i32, i32)
3086
3087define <vscale x 1 x i64> @test_vlseg2ff_nxv1i64_triscv.vector.tuple_nxv8i8_2t(ptr %base, i32 %vl, ptr %outvl) {
3088; CHECK-LABEL: test_vlseg2ff_nxv1i64_triscv.vector.tuple_nxv8i8_2t:
3089; CHECK:       # %bb.0: # %entry
3090; CHECK-NEXT:    vsetvli zero, a1, e64, m1, ta, ma
3091; CHECK-NEXT:    vlseg2e64ff.v v7, (a0)
3092; CHECK-NEXT:    csrr a0, vl
3093; CHECK-NEXT:    sw a0, 0(a2)
3094; CHECK-NEXT:    ret
3095entry:
3096  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv8i8_2t(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) undef, ptr %base, i32 %vl, i32 6)
3097  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} %0, 0
3098  %2 = call <vscale x 1 x i64> @llvm.riscv.tuple.extract.nxv1i64.triscv.vector.tuple_nxv8i8_2t(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) %1, i32 1)
3099  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} %0, 1
3100  store i32 %3, ptr %outvl
3101  ret <vscale x 1 x i64> %2
3102}
3103
3104define <vscale x 1 x i64> @test_vlseg2ff_mask_nxv1i64_triscv.vector.tuple_nxv8i8_2t(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
3105; CHECK-LABEL: test_vlseg2ff_mask_nxv1i64_triscv.vector.tuple_nxv8i8_2t:
3106; CHECK:       # %bb.0: # %entry
3107; CHECK-NEXT:    vsetvli zero, a1, e64, m1, ta, mu
3108; CHECK-NEXT:    vmv1r.v v7, v8
3109; CHECK-NEXT:    vmv1r.v v8, v9
3110; CHECK-NEXT:    vlseg2e64ff.v v7, (a0), v0.t
3111; CHECK-NEXT:    csrr a0, vl
3112; CHECK-NEXT:    sw a0, 0(a2)
3113; CHECK-NEXT:    ret
3114entry:
3115  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv8i8_2t.nxv1i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 6)
3116  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} %0, 0
3117  %2 = call <vscale x 1 x i64> @llvm.riscv.tuple.extract.nxv1i64.triscv.vector.tuple_nxv8i8_2t(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) %1, i32 1)
3118  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} %0, 1
3119  store i32 %3, ptr %outvl
3120  ret <vscale x 1 x i64> %2
3121}
3122
3123declare {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv16i8_2t.nxv2i1(target("riscv.vector.tuple", <vscale x 16 x i8>, 2), ptr, <vscale x 2 x i1>, i32, i32, i32)
3124
3125define <vscale x 2 x i64> @test_vlseg2ff_nxv2i64_triscv.vector.tuple_nxv16i8_2t(ptr %base, i32 %vl, ptr %outvl) {
3126; CHECK-LABEL: test_vlseg2ff_nxv2i64_triscv.vector.tuple_nxv16i8_2t:
3127; CHECK:       # %bb.0: # %entry
3128; CHECK-NEXT:    vsetvli zero, a1, e64, m2, ta, ma
3129; CHECK-NEXT:    vlseg2e64ff.v v6, (a0)
3130; CHECK-NEXT:    csrr a0, vl
3131; CHECK-NEXT:    sw a0, 0(a2)
3132; CHECK-NEXT:    ret
3133entry:
3134  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv16i8_2t(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) undef, ptr %base, i32 %vl, i32 6)
3135  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} %0, 0
3136  %2 = call <vscale x 2 x i64> @llvm.riscv.tuple.extract.nxv2i64.triscv.vector.tuple_nxv16i8_2t(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) %1, i32 1)
3137  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} %0, 1
3138  store i32 %3, ptr %outvl
3139  ret <vscale x 2 x i64> %2
3140}
3141
3142define <vscale x 2 x i64> @test_vlseg2ff_mask_nxv2i64_triscv.vector.tuple_nxv16i8_2t(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
3143; CHECK-LABEL: test_vlseg2ff_mask_nxv2i64_triscv.vector.tuple_nxv16i8_2t:
3144; CHECK:       # %bb.0: # %entry
3145; CHECK-NEXT:    vsetvli zero, a1, e64, m2, ta, mu
3146; CHECK-NEXT:    vmv2r.v v6, v8
3147; CHECK-NEXT:    vmv2r.v v8, v10
3148; CHECK-NEXT:    vlseg2e64ff.v v6, (a0), v0.t
3149; CHECK-NEXT:    csrr a0, vl
3150; CHECK-NEXT:    sw a0, 0(a2)
3151; CHECK-NEXT:    ret
3152entry:
3153  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv16i8_2t.nxv2i1(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 6)
3154  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} %0, 0
3155  %2 = call <vscale x 2 x i64> @llvm.riscv.tuple.extract.nxv2i64.triscv.vector.tuple_nxv16i8_2t(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) %1, i32 1)
3156  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} %0, 1
3157  store i32 %3, ptr %outvl
3158  ret <vscale x 2 x i64> %2
3159}
3160
3161declare {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv32i8_2t.nxv4i1(target("riscv.vector.tuple", <vscale x 32 x i8>, 2), ptr, <vscale x 4 x i1>, i32, i32, i32)
3162
3163define <vscale x 4 x i64> @test_vlseg2ff_nxv4i64_triscv.vector.tuple_nxv32i8_2t(ptr %base, i32 %vl, ptr %outvl) {
3164; CHECK-LABEL: test_vlseg2ff_nxv4i64_triscv.vector.tuple_nxv32i8_2t:
3165; CHECK:       # %bb.0: # %entry
3166; CHECK-NEXT:    vsetvli zero, a1, e64, m4, ta, ma
3167; CHECK-NEXT:    vlseg2e64ff.v v4, (a0)
3168; CHECK-NEXT:    csrr a0, vl
3169; CHECK-NEXT:    sw a0, 0(a2)
3170; CHECK-NEXT:    ret
3171entry:
3172  %0 = tail call {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv32i8_2t(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) undef, ptr %base, i32 %vl, i32 6)
3173  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} %0, 0
3174  %2 = call <vscale x 4 x i64> @llvm.riscv.tuple.extract.nxv4i64.triscv.vector.tuple_nxv32i8_2t(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) %1, i32 1)
3175  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} %0, 1
3176  store i32 %3, ptr %outvl
3177  ret <vscale x 4 x i64> %2
3178}
3179
3180define <vscale x 4 x i64> @test_vlseg2ff_mask_nxv4i64_triscv.vector.tuple_nxv32i8_2t(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) %val, ptr %base, i32 %vl, <vscale x 4 x i1> %mask, ptr %outvl) {
3181; CHECK-LABEL: test_vlseg2ff_mask_nxv4i64_triscv.vector.tuple_nxv32i8_2t:
3182; CHECK:       # %bb.0: # %entry
3183; CHECK-NEXT:    vsetvli zero, a1, e64, m4, ta, mu
3184; CHECK-NEXT:    vmv4r.v v4, v8
3185; CHECK-NEXT:    vmv4r.v v8, v12
3186; CHECK-NEXT:    vlseg2e64ff.v v4, (a0), v0.t
3187; CHECK-NEXT:    csrr a0, vl
3188; CHECK-NEXT:    sw a0, 0(a2)
3189; CHECK-NEXT:    ret
3190entry:
3191  %0 = tail call {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv32i8_2t.nxv4i1(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) %val, ptr %base, <vscale x 4 x i1> %mask, i32 %vl, i32 1, i32 6)
3192  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} %0, 0
3193  %2 = call <vscale x 4 x i64> @llvm.riscv.tuple.extract.nxv4i64.triscv.vector.tuple_nxv32i8_2t(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) %1, i32 1)
3194  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} %0, 1
3195  store i32 %3, ptr %outvl
3196  ret <vscale x 4 x i64> %2
3197}
3198
3199declare {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv8i8_3t.nxv1i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 3), ptr, <vscale x 1 x i1>, i32, i32, i32)
3200
3201define <vscale x 1 x i64> @test_vlseg3ff_nxv1i64_triscv.vector.tuple_nxv8i8_3t(ptr %base, i32 %vl, ptr %outvl) {
3202; CHECK-LABEL: test_vlseg3ff_nxv1i64_triscv.vector.tuple_nxv8i8_3t:
3203; CHECK:       # %bb.0: # %entry
3204; CHECK-NEXT:    vsetvli zero, a1, e64, m1, ta, ma
3205; CHECK-NEXT:    vlseg3e64ff.v v7, (a0)
3206; CHECK-NEXT:    csrr a0, vl
3207; CHECK-NEXT:    sw a0, 0(a2)
3208; CHECK-NEXT:    ret
3209entry:
3210  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} @llvm.riscv.vlseg3ff.triscv.vector.tuple_nxv8i8_3t(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) undef, ptr %base, i32 %vl, i32 6)
3211  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} %0, 0
3212  %2 = call <vscale x 1 x i64> @llvm.riscv.tuple.extract.nxv1i64.triscv.vector.tuple_nxv8i8_3t(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) %1, i32 1)
3213  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} %0, 1
3214  store i32 %3, ptr %outvl
3215  ret <vscale x 1 x i64> %2
3216}
3217
3218define <vscale x 1 x i64> @test_vlseg3ff_mask_nxv1i64_triscv.vector.tuple_nxv8i8_3t(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
3219; CHECK-LABEL: test_vlseg3ff_mask_nxv1i64_triscv.vector.tuple_nxv8i8_3t:
3220; CHECK:       # %bb.0: # %entry
3221; CHECK-NEXT:    vsetvli zero, a1, e64, m1, ta, mu
3222; CHECK-NEXT:    vmv1r.v v7, v8
3223; CHECK-NEXT:    vmv1r.v v8, v9
3224; CHECK-NEXT:    vmv1r.v v9, v10
3225; CHECK-NEXT:    vlseg3e64ff.v v7, (a0), v0.t
3226; CHECK-NEXT:    csrr a0, vl
3227; CHECK-NEXT:    sw a0, 0(a2)
3228; CHECK-NEXT:    ret
3229entry:
3230  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv8i8_3t.nxv1i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 6)
3231  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} %0, 0
3232  %2 = call <vscale x 1 x i64> @llvm.riscv.tuple.extract.nxv1i64.triscv.vector.tuple_nxv8i8_3t(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) %1, i32 1)
3233  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} %0, 1
3234  store i32 %3, ptr %outvl
3235  ret <vscale x 1 x i64> %2
3236}
3237
3238declare {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv16i8_3t.nxv2i1(target("riscv.vector.tuple", <vscale x 16 x i8>, 3), ptr, <vscale x 2 x i1>, i32, i32, i32)
3239
3240define <vscale x 2 x i64> @test_vlseg3ff_nxv2i64_triscv.vector.tuple_nxv16i8_3t(ptr %base, i32 %vl, ptr %outvl) {
3241; CHECK-LABEL: test_vlseg3ff_nxv2i64_triscv.vector.tuple_nxv16i8_3t:
3242; CHECK:       # %bb.0: # %entry
3243; CHECK-NEXT:    vsetvli zero, a1, e64, m2, ta, ma
3244; CHECK-NEXT:    vlseg3e64ff.v v6, (a0)
3245; CHECK-NEXT:    csrr a0, vl
3246; CHECK-NEXT:    sw a0, 0(a2)
3247; CHECK-NEXT:    ret
3248entry:
3249  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} @llvm.riscv.vlseg3ff.triscv.vector.tuple_nxv16i8_3t(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) undef, ptr %base, i32 %vl, i32 6)
3250  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} %0, 0
3251  %2 = call <vscale x 2 x i64> @llvm.riscv.tuple.extract.nxv2i64.triscv.vector.tuple_nxv16i8_3t(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) %1, i32 1)
3252  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} %0, 1
3253  store i32 %3, ptr %outvl
3254  ret <vscale x 2 x i64> %2
3255}
3256
3257define <vscale x 2 x i64> @test_vlseg3ff_mask_nxv2i64_triscv.vector.tuple_nxv16i8_3t(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
3258; CHECK-LABEL: test_vlseg3ff_mask_nxv2i64_triscv.vector.tuple_nxv16i8_3t:
3259; CHECK:       # %bb.0: # %entry
3260; CHECK-NEXT:    vsetvli zero, a1, e64, m2, ta, mu
3261; CHECK-NEXT:    vmv2r.v v6, v8
3262; CHECK-NEXT:    vmv2r.v v8, v10
3263; CHECK-NEXT:    vmv2r.v v10, v12
3264; CHECK-NEXT:    vlseg3e64ff.v v6, (a0), v0.t
3265; CHECK-NEXT:    csrr a0, vl
3266; CHECK-NEXT:    sw a0, 0(a2)
3267; CHECK-NEXT:    ret
3268entry:
3269  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv16i8_3t.nxv2i1(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 6)
3270  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} %0, 0
3271  %2 = call <vscale x 2 x i64> @llvm.riscv.tuple.extract.nxv2i64.triscv.vector.tuple_nxv16i8_3t(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) %1, i32 1)
3272  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} %0, 1
3273  store i32 %3, ptr %outvl
3274  ret <vscale x 2 x i64> %2
3275}
3276
3277declare {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv8i8_4t.nxv1i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 4), ptr, <vscale x 1 x i1>, i32, i32, i32)
3278
3279define <vscale x 1 x i64> @test_vlseg4ff_nxv1i64_triscv.vector.tuple_nxv8i8_4t(ptr %base, i32 %vl, ptr %outvl) {
3280; CHECK-LABEL: test_vlseg4ff_nxv1i64_triscv.vector.tuple_nxv8i8_4t:
3281; CHECK:       # %bb.0: # %entry
3282; CHECK-NEXT:    vsetvli zero, a1, e64, m1, ta, ma
3283; CHECK-NEXT:    vlseg4e64ff.v v7, (a0)
3284; CHECK-NEXT:    csrr a0, vl
3285; CHECK-NEXT:    sw a0, 0(a2)
3286; CHECK-NEXT:    ret
3287entry:
3288  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} @llvm.riscv.vlseg4ff.triscv.vector.tuple_nxv8i8_4t(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) undef, ptr %base, i32 %vl, i32 6)
3289  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} %0, 0
3290  %2 = call <vscale x 1 x i64> @llvm.riscv.tuple.extract.nxv1i64.triscv.vector.tuple_nxv8i8_4t(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) %1, i32 1)
3291  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} %0, 1
3292  store i32 %3, ptr %outvl
3293  ret <vscale x 1 x i64> %2
3294}
3295
3296define <vscale x 1 x i64> @test_vlseg4ff_mask_nxv1i64_triscv.vector.tuple_nxv8i8_4t(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
3297; CHECK-LABEL: test_vlseg4ff_mask_nxv1i64_triscv.vector.tuple_nxv8i8_4t:
3298; CHECK:       # %bb.0: # %entry
3299; CHECK-NEXT:    vsetvli zero, a1, e64, m1, ta, mu
3300; CHECK-NEXT:    vmv1r.v v7, v8
3301; CHECK-NEXT:    vmv1r.v v8, v9
3302; CHECK-NEXT:    vmv1r.v v9, v10
3303; CHECK-NEXT:    vmv1r.v v10, v11
3304; CHECK-NEXT:    vlseg4e64ff.v v7, (a0), v0.t
3305; CHECK-NEXT:    csrr a0, vl
3306; CHECK-NEXT:    sw a0, 0(a2)
3307; CHECK-NEXT:    ret
3308entry:
3309  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv8i8_4t.nxv1i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 6)
3310  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} %0, 0
3311  %2 = call <vscale x 1 x i64> @llvm.riscv.tuple.extract.nxv1i64.triscv.vector.tuple_nxv8i8_4t(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) %1, i32 1)
3312  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} %0, 1
3313  store i32 %3, ptr %outvl
3314  ret <vscale x 1 x i64> %2
3315}
3316
3317declare {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv16i8_4t.nxv2i1(target("riscv.vector.tuple", <vscale x 16 x i8>, 4), ptr, <vscale x 2 x i1>, i32, i32, i32)
3318
3319define <vscale x 2 x i64> @test_vlseg4ff_nxv2i64_triscv.vector.tuple_nxv16i8_4t(ptr %base, i32 %vl, ptr %outvl) {
3320; CHECK-LABEL: test_vlseg4ff_nxv2i64_triscv.vector.tuple_nxv16i8_4t:
3321; CHECK:       # %bb.0: # %entry
3322; CHECK-NEXT:    vsetvli zero, a1, e64, m2, ta, ma
3323; CHECK-NEXT:    vlseg4e64ff.v v6, (a0)
3324; CHECK-NEXT:    csrr a0, vl
3325; CHECK-NEXT:    sw a0, 0(a2)
3326; CHECK-NEXT:    ret
3327entry:
3328  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} @llvm.riscv.vlseg4ff.triscv.vector.tuple_nxv16i8_4t(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) undef, ptr %base, i32 %vl, i32 6)
3329  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} %0, 0
3330  %2 = call <vscale x 2 x i64> @llvm.riscv.tuple.extract.nxv2i64.triscv.vector.tuple_nxv16i8_4t(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) %1, i32 1)
3331  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} %0, 1
3332  store i32 %3, ptr %outvl
3333  ret <vscale x 2 x i64> %2
3334}
3335
3336define <vscale x 2 x i64> @test_vlseg4ff_mask_nxv2i64_triscv.vector.tuple_nxv16i8_4t(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
3337; CHECK-LABEL: test_vlseg4ff_mask_nxv2i64_triscv.vector.tuple_nxv16i8_4t:
3338; CHECK:       # %bb.0: # %entry
3339; CHECK-NEXT:    vsetvli zero, a1, e64, m2, ta, mu
3340; CHECK-NEXT:    vmv2r.v v6, v8
3341; CHECK-NEXT:    vmv2r.v v8, v10
3342; CHECK-NEXT:    vmv2r.v v10, v12
3343; CHECK-NEXT:    vmv2r.v v12, v14
3344; CHECK-NEXT:    vlseg4e64ff.v v6, (a0), v0.t
3345; CHECK-NEXT:    csrr a0, vl
3346; CHECK-NEXT:    sw a0, 0(a2)
3347; CHECK-NEXT:    ret
3348entry:
3349  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv16i8_4t.nxv2i1(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 6)
3350  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} %0, 0
3351  %2 = call <vscale x 2 x i64> @llvm.riscv.tuple.extract.nxv2i64.triscv.vector.tuple_nxv16i8_4t(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) %1, i32 1)
3352  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} %0, 1
3353  store i32 %3, ptr %outvl
3354  ret <vscale x 2 x i64> %2
3355}
3356
3357declare {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} @llvm.riscv.vlseg5ff.mask.triscv.vector.tuple_nxv8i8_5t.nxv1i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 5), ptr, <vscale x 1 x i1>, i32, i32, i32)
3358
3359define <vscale x 1 x i64> @test_vlseg5ff_nxv1i64_triscv.vector.tuple_nxv8i8_5t(ptr %base, i32 %vl, ptr %outvl) {
3360; CHECK-LABEL: test_vlseg5ff_nxv1i64_triscv.vector.tuple_nxv8i8_5t:
3361; CHECK:       # %bb.0: # %entry
3362; CHECK-NEXT:    vsetvli zero, a1, e64, m1, ta, ma
3363; CHECK-NEXT:    vlseg5e64ff.v v7, (a0)
3364; CHECK-NEXT:    csrr a0, vl
3365; CHECK-NEXT:    sw a0, 0(a2)
3366; CHECK-NEXT:    ret
3367entry:
3368  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} @llvm.riscv.vlseg5ff.triscv.vector.tuple_nxv8i8_5t(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) undef, ptr %base, i32 %vl, i32 6)
3369  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} %0, 0
3370  %2 = call <vscale x 1 x i64> @llvm.riscv.tuple.extract.nxv1i64.triscv.vector.tuple_nxv8i8_5t(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) %1, i32 1)
3371  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} %0, 1
3372  store i32 %3, ptr %outvl
3373  ret <vscale x 1 x i64> %2
3374}
3375
3376define <vscale x 1 x i64> @test_vlseg5ff_mask_nxv1i64_triscv.vector.tuple_nxv8i8_5t(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
3377; CHECK-LABEL: test_vlseg5ff_mask_nxv1i64_triscv.vector.tuple_nxv8i8_5t:
3378; CHECK:       # %bb.0: # %entry
3379; CHECK-NEXT:    vsetvli zero, a1, e64, m1, ta, mu
3380; CHECK-NEXT:    vmv1r.v v7, v8
3381; CHECK-NEXT:    vmv1r.v v8, v9
3382; CHECK-NEXT:    vmv1r.v v9, v10
3383; CHECK-NEXT:    vmv1r.v v10, v11
3384; CHECK-NEXT:    vmv1r.v v11, v12
3385; CHECK-NEXT:    vlseg5e64ff.v v7, (a0), v0.t
3386; CHECK-NEXT:    csrr a0, vl
3387; CHECK-NEXT:    sw a0, 0(a2)
3388; CHECK-NEXT:    ret
3389entry:
3390  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} @llvm.riscv.vlseg5ff.mask.triscv.vector.tuple_nxv8i8_5t.nxv1i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 6)
3391  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} %0, 0
3392  %2 = call <vscale x 1 x i64> @llvm.riscv.tuple.extract.nxv1i64.triscv.vector.tuple_nxv8i8_5t(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) %1, i32 1)
3393  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} %0, 1
3394  store i32 %3, ptr %outvl
3395  ret <vscale x 1 x i64> %2
3396}
3397
3398declare {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} @llvm.riscv.vlseg6ff.mask.triscv.vector.tuple_nxv8i8_6t.nxv1i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 6), ptr, <vscale x 1 x i1>, i32, i32, i32)
3399
3400define <vscale x 1 x i64> @test_vlseg6ff_nxv1i64_triscv.vector.tuple_nxv8i8_6t(ptr %base, i32 %vl, ptr %outvl) {
3401; CHECK-LABEL: test_vlseg6ff_nxv1i64_triscv.vector.tuple_nxv8i8_6t:
3402; CHECK:       # %bb.0: # %entry
3403; CHECK-NEXT:    vsetvli zero, a1, e64, m1, ta, ma
3404; CHECK-NEXT:    vlseg6e64ff.v v7, (a0)
3405; CHECK-NEXT:    csrr a0, vl
3406; CHECK-NEXT:    sw a0, 0(a2)
3407; CHECK-NEXT:    ret
3408entry:
3409  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} @llvm.riscv.vlseg6ff.triscv.vector.tuple_nxv8i8_6t(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) undef, ptr %base, i32 %vl, i32 6)
3410  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} %0, 0
3411  %2 = call <vscale x 1 x i64> @llvm.riscv.tuple.extract.nxv1i64.triscv.vector.tuple_nxv8i8_6t(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) %1, i32 1)
3412  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} %0, 1
3413  store i32 %3, ptr %outvl
3414  ret <vscale x 1 x i64> %2
3415}
3416
3417define <vscale x 1 x i64> @test_vlseg6ff_mask_nxv1i64_triscv.vector.tuple_nxv8i8_6t(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
3418; CHECK-LABEL: test_vlseg6ff_mask_nxv1i64_triscv.vector.tuple_nxv8i8_6t:
3419; CHECK:       # %bb.0: # %entry
3420; CHECK-NEXT:    vsetvli zero, a1, e64, m1, ta, mu
3421; CHECK-NEXT:    vmv1r.v v7, v8
3422; CHECK-NEXT:    vmv1r.v v8, v9
3423; CHECK-NEXT:    vmv1r.v v9, v10
3424; CHECK-NEXT:    vmv1r.v v10, v11
3425; CHECK-NEXT:    vmv1r.v v11, v12
3426; CHECK-NEXT:    vmv1r.v v12, v13
3427; CHECK-NEXT:    vlseg6e64ff.v v7, (a0), v0.t
3428; CHECK-NEXT:    csrr a0, vl
3429; CHECK-NEXT:    sw a0, 0(a2)
3430; CHECK-NEXT:    ret
3431entry:
3432  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} @llvm.riscv.vlseg6ff.mask.triscv.vector.tuple_nxv8i8_6t.nxv1i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 6)
3433  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} %0, 0
3434  %2 = call <vscale x 1 x i64> @llvm.riscv.tuple.extract.nxv1i64.triscv.vector.tuple_nxv8i8_6t(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) %1, i32 1)
3435  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} %0, 1
3436  store i32 %3, ptr %outvl
3437  ret <vscale x 1 x i64> %2
3438}
3439
3440declare {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} @llvm.riscv.vlseg7ff.mask.triscv.vector.tuple_nxv8i8_7t.nxv1i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 7), ptr, <vscale x 1 x i1>, i32, i32, i32)
3441
3442define <vscale x 1 x i64> @test_vlseg7ff_nxv1i64_triscv.vector.tuple_nxv8i8_7t(ptr %base, i32 %vl, ptr %outvl) {
3443; CHECK-LABEL: test_vlseg7ff_nxv1i64_triscv.vector.tuple_nxv8i8_7t:
3444; CHECK:       # %bb.0: # %entry
3445; CHECK-NEXT:    vsetvli zero, a1, e64, m1, ta, ma
3446; CHECK-NEXT:    vlseg7e64ff.v v7, (a0)
3447; CHECK-NEXT:    csrr a0, vl
3448; CHECK-NEXT:    sw a0, 0(a2)
3449; CHECK-NEXT:    ret
3450entry:
3451  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} @llvm.riscv.vlseg7ff.triscv.vector.tuple_nxv8i8_7t(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) undef, ptr %base, i32 %vl, i32 6)
3452  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} %0, 0
3453  %2 = call <vscale x 1 x i64> @llvm.riscv.tuple.extract.nxv1i64.triscv.vector.tuple_nxv8i8_7t(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) %1, i32 1)
3454  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} %0, 1
3455  store i32 %3, ptr %outvl
3456  ret <vscale x 1 x i64> %2
3457}
3458
3459define <vscale x 1 x i64> @test_vlseg7ff_mask_nxv1i64_triscv.vector.tuple_nxv8i8_7t(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
3460; CHECK-LABEL: test_vlseg7ff_mask_nxv1i64_triscv.vector.tuple_nxv8i8_7t:
3461; CHECK:       # %bb.0: # %entry
3462; CHECK-NEXT:    vsetvli zero, a1, e64, m1, ta, mu
3463; CHECK-NEXT:    vmv1r.v v7, v8
3464; CHECK-NEXT:    vmv1r.v v8, v9
3465; CHECK-NEXT:    vmv1r.v v9, v10
3466; CHECK-NEXT:    vmv1r.v v10, v11
3467; CHECK-NEXT:    vmv1r.v v11, v12
3468; CHECK-NEXT:    vmv1r.v v12, v13
3469; CHECK-NEXT:    vmv1r.v v13, v14
3470; CHECK-NEXT:    vlseg7e64ff.v v7, (a0), v0.t
3471; CHECK-NEXT:    csrr a0, vl
3472; CHECK-NEXT:    sw a0, 0(a2)
3473; CHECK-NEXT:    ret
3474entry:
3475  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} @llvm.riscv.vlseg7ff.mask.triscv.vector.tuple_nxv8i8_7t.nxv1i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 6)
3476  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} %0, 0
3477  %2 = call <vscale x 1 x i64> @llvm.riscv.tuple.extract.nxv1i64.triscv.vector.tuple_nxv8i8_7t(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) %1, i32 1)
3478  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} %0, 1
3479  store i32 %3, ptr %outvl
3480  ret <vscale x 1 x i64> %2
3481}
3482
3483declare {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} @llvm.riscv.vlseg8ff.mask.triscv.vector.tuple_nxv8i8_8t.nxv1i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 8), ptr, <vscale x 1 x i1>, i32, i32, i32)
3484
3485define <vscale x 1 x i64> @test_vlseg8ff_nxv1i64_triscv.vector.tuple_nxv8i8_8t(ptr %base, i32 %vl, ptr %outvl) {
3486; CHECK-LABEL: test_vlseg8ff_nxv1i64_triscv.vector.tuple_nxv8i8_8t:
3487; CHECK:       # %bb.0: # %entry
3488; CHECK-NEXT:    vsetvli zero, a1, e64, m1, ta, ma
3489; CHECK-NEXT:    vlseg8e64ff.v v7, (a0)
3490; CHECK-NEXT:    csrr a0, vl
3491; CHECK-NEXT:    sw a0, 0(a2)
3492; CHECK-NEXT:    ret
3493entry:
3494  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} @llvm.riscv.vlseg8ff.triscv.vector.tuple_nxv8i8_8t(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) undef, ptr %base, i32 %vl, i32 6)
3495  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} %0, 0
3496  %2 = call <vscale x 1 x i64> @llvm.riscv.tuple.extract.nxv1i64.triscv.vector.tuple_nxv8i8_8t(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) %1, i32 1)
3497  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} %0, 1
3498  store i32 %3, ptr %outvl
3499  ret <vscale x 1 x i64> %2
3500}
3501
3502define <vscale x 1 x i64> @test_vlseg8ff_mask_nxv1i64_triscv.vector.tuple_nxv8i8_8t(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
3503; CHECK-LABEL: test_vlseg8ff_mask_nxv1i64_triscv.vector.tuple_nxv8i8_8t:
3504; CHECK:       # %bb.0: # %entry
3505; CHECK-NEXT:    vsetvli zero, a1, e64, m1, ta, mu
3506; CHECK-NEXT:    vmv1r.v v7, v8
3507; CHECK-NEXT:    vmv1r.v v8, v9
3508; CHECK-NEXT:    vmv1r.v v9, v10
3509; CHECK-NEXT:    vmv1r.v v10, v11
3510; CHECK-NEXT:    vmv1r.v v11, v12
3511; CHECK-NEXT:    vmv1r.v v12, v13
3512; CHECK-NEXT:    vmv1r.v v13, v14
3513; CHECK-NEXT:    vmv1r.v v14, v15
3514; CHECK-NEXT:    vlseg8e64ff.v v7, (a0), v0.t
3515; CHECK-NEXT:    csrr a0, vl
3516; CHECK-NEXT:    sw a0, 0(a2)
3517; CHECK-NEXT:    ret
3518entry:
3519  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} @llvm.riscv.vlseg8ff.mask.triscv.vector.tuple_nxv8i8_8t.nxv1i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 6)
3520  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} %0, 0
3521  %2 = call <vscale x 1 x i64> @llvm.riscv.tuple.extract.nxv1i64.triscv.vector.tuple_nxv8i8_8t(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) %1, i32 1)
3522  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} %0, 1
3523  store i32 %3, ptr %outvl
3524  ret <vscale x 1 x i64> %2
3525}
3526
3527
3528define <vscale x 1 x half> @test_vlseg2ff_nxv1f16_triscv.vector.tuple_nxv2i8_2t(ptr %base, i32 %vl, ptr %outvl) {
3529; CHECK-LABEL: test_vlseg2ff_nxv1f16_triscv.vector.tuple_nxv2i8_2t:
3530; CHECK:       # %bb.0: # %entry
3531; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, ma
3532; CHECK-NEXT:    vlseg2e16ff.v v7, (a0)
3533; CHECK-NEXT:    csrr a0, vl
3534; CHECK-NEXT:    sw a0, 0(a2)
3535; CHECK-NEXT:    ret
3536entry:
3537  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv2i8_2t(target("riscv.vector.tuple", <vscale x 2 x i8>, 2) undef, ptr %base, i32 %vl, i32 4)
3538  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 2), i32} %0, 0
3539  %2 = call <vscale x 1 x half> @llvm.riscv.tuple.extract.nxv1f16.triscv.vector.tuple_nxv2i8_2t(target("riscv.vector.tuple", <vscale x 2 x i8>, 2) %1, i32 1)
3540  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 2), i32} %0, 1
3541  store i32 %3, ptr %outvl
3542  ret <vscale x 1 x half> %2
3543}
3544
3545define <vscale x 1 x half> @test_vlseg2ff_mask_nxv1f16_triscv.vector.tuple_nxv2i8_2t(target("riscv.vector.tuple", <vscale x 2 x i8>, 2) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
3546; CHECK-LABEL: test_vlseg2ff_mask_nxv1f16_triscv.vector.tuple_nxv2i8_2t:
3547; CHECK:       # %bb.0: # %entry
3548; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, mu
3549; CHECK-NEXT:    vmv1r.v v7, v8
3550; CHECK-NEXT:    vmv1r.v v8, v9
3551; CHECK-NEXT:    vlseg2e16ff.v v7, (a0), v0.t
3552; CHECK-NEXT:    csrr a0, vl
3553; CHECK-NEXT:    sw a0, 0(a2)
3554; CHECK-NEXT:    ret
3555entry:
3556  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv2i8_2t.nxv1i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 2) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 4)
3557  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 2), i32} %0, 0
3558  %2 = call <vscale x 1 x half> @llvm.riscv.tuple.extract.nxv1f16.triscv.vector.tuple_nxv2i8_2t(target("riscv.vector.tuple", <vscale x 2 x i8>, 2) %1, i32 1)
3559  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 2), i32} %0, 1
3560  store i32 %3, ptr %outvl
3561  ret <vscale x 1 x half> %2
3562}
3563
3564
3565define <vscale x 2 x half> @test_vlseg2ff_nxv2f16_triscv.vector.tuple_nxv4i8_2t(ptr %base, i32 %vl, ptr %outvl) {
3566; CHECK-LABEL: test_vlseg2ff_nxv2f16_triscv.vector.tuple_nxv4i8_2t:
3567; CHECK:       # %bb.0: # %entry
3568; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, ma
3569; CHECK-NEXT:    vlseg2e16ff.v v7, (a0)
3570; CHECK-NEXT:    csrr a0, vl
3571; CHECK-NEXT:    sw a0, 0(a2)
3572; CHECK-NEXT:    ret
3573entry:
3574  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv4i8_2t(target("riscv.vector.tuple", <vscale x 4 x i8>, 2) undef, ptr %base, i32 %vl, i32 4)
3575  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} %0, 0
3576  %2 = call <vscale x 2 x half> @llvm.riscv.tuple.extract.nxv2f16.triscv.vector.tuple_nxv4i8_2t(target("riscv.vector.tuple", <vscale x 4 x i8>, 2) %1, i32 1)
3577  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} %0, 1
3578  store i32 %3, ptr %outvl
3579  ret <vscale x 2 x half> %2
3580}
3581
3582define <vscale x 2 x half> @test_vlseg2ff_mask_nxv2f16_triscv.vector.tuple_nxv4i8_2t(target("riscv.vector.tuple", <vscale x 4 x i8>, 2) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
3583; CHECK-LABEL: test_vlseg2ff_mask_nxv2f16_triscv.vector.tuple_nxv4i8_2t:
3584; CHECK:       # %bb.0: # %entry
3585; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, mu
3586; CHECK-NEXT:    vmv1r.v v7, v8
3587; CHECK-NEXT:    vmv1r.v v8, v9
3588; CHECK-NEXT:    vlseg2e16ff.v v7, (a0), v0.t
3589; CHECK-NEXT:    csrr a0, vl
3590; CHECK-NEXT:    sw a0, 0(a2)
3591; CHECK-NEXT:    ret
3592entry:
3593  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv4i8_2t.nxv2i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 2) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 4)
3594  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} %0, 0
3595  %2 = call <vscale x 2 x half> @llvm.riscv.tuple.extract.nxv2f16.triscv.vector.tuple_nxv4i8_2t(target("riscv.vector.tuple", <vscale x 4 x i8>, 2) %1, i32 1)
3596  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} %0, 1
3597  store i32 %3, ptr %outvl
3598  ret <vscale x 2 x half> %2
3599}
3600
3601
3602define <vscale x 4 x half> @test_vlseg2ff_nxv4f16_triscv.vector.tuple_nxv8i8_2t(ptr %base, i32 %vl, ptr %outvl) {
3603; CHECK-LABEL: test_vlseg2ff_nxv4f16_triscv.vector.tuple_nxv8i8_2t:
3604; CHECK:       # %bb.0: # %entry
3605; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, ma
3606; CHECK-NEXT:    vlseg2e16ff.v v7, (a0)
3607; CHECK-NEXT:    csrr a0, vl
3608; CHECK-NEXT:    sw a0, 0(a2)
3609; CHECK-NEXT:    ret
3610entry:
3611  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv8i8_2t(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) undef, ptr %base, i32 %vl, i32 4)
3612  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} %0, 0
3613  %2 = call <vscale x 4 x half> @llvm.riscv.tuple.extract.nxv4f16.triscv.vector.tuple_nxv8i8_2t(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) %1, i32 1)
3614  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} %0, 1
3615  store i32 %3, ptr %outvl
3616  ret <vscale x 4 x half> %2
3617}
3618
3619define <vscale x 4 x half> @test_vlseg2ff_mask_nxv4f16_triscv.vector.tuple_nxv8i8_2t(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) %val, ptr %base, i32 %vl, <vscale x 4 x i1> %mask, ptr %outvl) {
3620; CHECK-LABEL: test_vlseg2ff_mask_nxv4f16_triscv.vector.tuple_nxv8i8_2t:
3621; CHECK:       # %bb.0: # %entry
3622; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, mu
3623; CHECK-NEXT:    vmv1r.v v7, v8
3624; CHECK-NEXT:    vmv1r.v v8, v9
3625; CHECK-NEXT:    vlseg2e16ff.v v7, (a0), v0.t
3626; CHECK-NEXT:    csrr a0, vl
3627; CHECK-NEXT:    sw a0, 0(a2)
3628; CHECK-NEXT:    ret
3629entry:
3630  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv8i8_2t.nxv4i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) %val, ptr %base, <vscale x 4 x i1> %mask, i32 %vl, i32 1, i32 4)
3631  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} %0, 0
3632  %2 = call <vscale x 4 x half> @llvm.riscv.tuple.extract.nxv4f16.triscv.vector.tuple_nxv8i8_2t(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) %1, i32 1)
3633  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} %0, 1
3634  store i32 %3, ptr %outvl
3635  ret <vscale x 4 x half> %2
3636}
3637
3638
3639define <vscale x 8 x half> @test_vlseg2ff_nxv8f16_triscv.vector.tuple_nxv16i8_2t(ptr %base, i32 %vl, ptr %outvl) {
3640; CHECK-LABEL: test_vlseg2ff_nxv8f16_triscv.vector.tuple_nxv16i8_2t:
3641; CHECK:       # %bb.0: # %entry
3642; CHECK-NEXT:    vsetvli zero, a1, e16, m2, ta, ma
3643; CHECK-NEXT:    vlseg2e16ff.v v6, (a0)
3644; CHECK-NEXT:    csrr a0, vl
3645; CHECK-NEXT:    sw a0, 0(a2)
3646; CHECK-NEXT:    ret
3647entry:
3648  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv16i8_2t(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) undef, ptr %base, i32 %vl, i32 4)
3649  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} %0, 0
3650  %2 = call <vscale x 8 x half> @llvm.riscv.tuple.extract.nxv8f16.triscv.vector.tuple_nxv16i8_2t(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) %1, i32 1)
3651  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} %0, 1
3652  store i32 %3, ptr %outvl
3653  ret <vscale x 8 x half> %2
3654}
3655
3656define <vscale x 8 x half> @test_vlseg2ff_mask_nxv8f16_triscv.vector.tuple_nxv16i8_2t(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) %val, ptr %base, i32 %vl, <vscale x 8 x i1> %mask, ptr %outvl) {
3657; CHECK-LABEL: test_vlseg2ff_mask_nxv8f16_triscv.vector.tuple_nxv16i8_2t:
3658; CHECK:       # %bb.0: # %entry
3659; CHECK-NEXT:    vsetvli zero, a1, e16, m2, ta, mu
3660; CHECK-NEXT:    vmv2r.v v6, v8
3661; CHECK-NEXT:    vmv2r.v v8, v10
3662; CHECK-NEXT:    vlseg2e16ff.v v6, (a0), v0.t
3663; CHECK-NEXT:    csrr a0, vl
3664; CHECK-NEXT:    sw a0, 0(a2)
3665; CHECK-NEXT:    ret
3666entry:
3667  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv16i8_2t.nxv8i1(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) %val, ptr %base, <vscale x 8 x i1> %mask, i32 %vl, i32 1, i32 4)
3668  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} %0, 0
3669  %2 = call <vscale x 8 x half> @llvm.riscv.tuple.extract.nxv8f16.triscv.vector.tuple_nxv16i8_2t(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) %1, i32 1)
3670  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} %0, 1
3671  store i32 %3, ptr %outvl
3672  ret <vscale x 8 x half> %2
3673}
3674
3675
3676define <vscale x 16 x half> @test_vlseg2ff_nxv16f16_triscv.vector.tuple_nxv32i8_2t(ptr %base, i32 %vl, ptr %outvl) {
3677; CHECK-LABEL: test_vlseg2ff_nxv16f16_triscv.vector.tuple_nxv32i8_2t:
3678; CHECK:       # %bb.0: # %entry
3679; CHECK-NEXT:    vsetvli zero, a1, e16, m4, ta, ma
3680; CHECK-NEXT:    vlseg2e16ff.v v4, (a0)
3681; CHECK-NEXT:    csrr a0, vl
3682; CHECK-NEXT:    sw a0, 0(a2)
3683; CHECK-NEXT:    ret
3684entry:
3685  %0 = tail call {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv32i8_2t(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) undef, ptr %base, i32 %vl, i32 4)
3686  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} %0, 0
3687  %2 = call <vscale x 16 x half> @llvm.riscv.tuple.extract.nxv16f16.triscv.vector.tuple_nxv32i8_2t(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) %1, i32 1)
3688  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} %0, 1
3689  store i32 %3, ptr %outvl
3690  ret <vscale x 16 x half> %2
3691}
3692
3693define <vscale x 16 x half> @test_vlseg2ff_mask_nxv16f16_triscv.vector.tuple_nxv32i8_2t(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) %val, ptr %base, i32 %vl, <vscale x 16 x i1> %mask, ptr %outvl) {
3694; CHECK-LABEL: test_vlseg2ff_mask_nxv16f16_triscv.vector.tuple_nxv32i8_2t:
3695; CHECK:       # %bb.0: # %entry
3696; CHECK-NEXT:    vsetvli zero, a1, e16, m4, ta, mu
3697; CHECK-NEXT:    vmv4r.v v4, v8
3698; CHECK-NEXT:    vmv4r.v v8, v12
3699; CHECK-NEXT:    vlseg2e16ff.v v4, (a0), v0.t
3700; CHECK-NEXT:    csrr a0, vl
3701; CHECK-NEXT:    sw a0, 0(a2)
3702; CHECK-NEXT:    ret
3703entry:
3704  %0 = tail call {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv32i8_2t.nxv16i1(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) %val, ptr %base, <vscale x 16 x i1> %mask, i32 %vl, i32 1, i32 4)
3705  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} %0, 0
3706  %2 = call <vscale x 16 x half> @llvm.riscv.tuple.extract.nxv16f16.triscv.vector.tuple_nxv32i8_2t(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) %1, i32 1)
3707  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} %0, 1
3708  store i32 %3, ptr %outvl
3709  ret <vscale x 16 x half> %2
3710}
3711
3712
3713define <vscale x 1 x half> @test_vlseg3ff_nxv1f16_triscv.vector.tuple_nxv2i8_3t(ptr %base, i32 %vl, ptr %outvl) {
3714; CHECK-LABEL: test_vlseg3ff_nxv1f16_triscv.vector.tuple_nxv2i8_3t:
3715; CHECK:       # %bb.0: # %entry
3716; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, ma
3717; CHECK-NEXT:    vlseg3e16ff.v v7, (a0)
3718; CHECK-NEXT:    csrr a0, vl
3719; CHECK-NEXT:    sw a0, 0(a2)
3720; CHECK-NEXT:    ret
3721entry:
3722  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 3), i32} @llvm.riscv.vlseg3ff.triscv.vector.tuple_nxv2i8_3t(target("riscv.vector.tuple", <vscale x 2 x i8>, 3) undef, ptr %base, i32 %vl, i32 4)
3723  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 3), i32} %0, 0
3724  %2 = call <vscale x 1 x half> @llvm.riscv.tuple.extract.nxv1f16.triscv.vector.tuple_nxv2i8_3t(target("riscv.vector.tuple", <vscale x 2 x i8>, 3) %1, i32 1)
3725  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 3), i32} %0, 1
3726  store i32 %3, ptr %outvl
3727  ret <vscale x 1 x half> %2
3728}
3729
3730define <vscale x 1 x half> @test_vlseg3ff_mask_nxv1f16_triscv.vector.tuple_nxv2i8_3t(target("riscv.vector.tuple", <vscale x 2 x i8>, 3) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
3731; CHECK-LABEL: test_vlseg3ff_mask_nxv1f16_triscv.vector.tuple_nxv2i8_3t:
3732; CHECK:       # %bb.0: # %entry
3733; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, mu
3734; CHECK-NEXT:    vmv1r.v v7, v8
3735; CHECK-NEXT:    vmv1r.v v8, v9
3736; CHECK-NEXT:    vmv1r.v v9, v10
3737; CHECK-NEXT:    vlseg3e16ff.v v7, (a0), v0.t
3738; CHECK-NEXT:    csrr a0, vl
3739; CHECK-NEXT:    sw a0, 0(a2)
3740; CHECK-NEXT:    ret
3741entry:
3742  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv2i8_3t.nxv1i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 3) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 4)
3743  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 3), i32} %0, 0
3744  %2 = call <vscale x 1 x half> @llvm.riscv.tuple.extract.nxv1f16.triscv.vector.tuple_nxv2i8_3t(target("riscv.vector.tuple", <vscale x 2 x i8>, 3) %1, i32 1)
3745  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 3), i32} %0, 1
3746  store i32 %3, ptr %outvl
3747  ret <vscale x 1 x half> %2
3748}
3749
3750
3751define <vscale x 2 x half> @test_vlseg3ff_nxv2f16_triscv.vector.tuple_nxv4i8_3t(ptr %base, i32 %vl, ptr %outvl) {
3752; CHECK-LABEL: test_vlseg3ff_nxv2f16_triscv.vector.tuple_nxv4i8_3t:
3753; CHECK:       # %bb.0: # %entry
3754; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, ma
3755; CHECK-NEXT:    vlseg3e16ff.v v7, (a0)
3756; CHECK-NEXT:    csrr a0, vl
3757; CHECK-NEXT:    sw a0, 0(a2)
3758; CHECK-NEXT:    ret
3759entry:
3760  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} @llvm.riscv.vlseg3ff.triscv.vector.tuple_nxv4i8_3t(target("riscv.vector.tuple", <vscale x 4 x i8>, 3) undef, ptr %base, i32 %vl, i32 4)
3761  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} %0, 0
3762  %2 = call <vscale x 2 x half> @llvm.riscv.tuple.extract.nxv2f16.triscv.vector.tuple_nxv4i8_3t(target("riscv.vector.tuple", <vscale x 4 x i8>, 3) %1, i32 1)
3763  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} %0, 1
3764  store i32 %3, ptr %outvl
3765  ret <vscale x 2 x half> %2
3766}
3767
3768define <vscale x 2 x half> @test_vlseg3ff_mask_nxv2f16_triscv.vector.tuple_nxv4i8_3t(target("riscv.vector.tuple", <vscale x 4 x i8>, 3) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
3769; CHECK-LABEL: test_vlseg3ff_mask_nxv2f16_triscv.vector.tuple_nxv4i8_3t:
3770; CHECK:       # %bb.0: # %entry
3771; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, mu
3772; CHECK-NEXT:    vmv1r.v v7, v8
3773; CHECK-NEXT:    vmv1r.v v8, v9
3774; CHECK-NEXT:    vmv1r.v v9, v10
3775; CHECK-NEXT:    vlseg3e16ff.v v7, (a0), v0.t
3776; CHECK-NEXT:    csrr a0, vl
3777; CHECK-NEXT:    sw a0, 0(a2)
3778; CHECK-NEXT:    ret
3779entry:
3780  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv4i8_3t.nxv2i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 3) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 4)
3781  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} %0, 0
3782  %2 = call <vscale x 2 x half> @llvm.riscv.tuple.extract.nxv2f16.triscv.vector.tuple_nxv4i8_3t(target("riscv.vector.tuple", <vscale x 4 x i8>, 3) %1, i32 1)
3783  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} %0, 1
3784  store i32 %3, ptr %outvl
3785  ret <vscale x 2 x half> %2
3786}
3787
3788
3789define <vscale x 4 x half> @test_vlseg3ff_nxv4f16_triscv.vector.tuple_nxv8i8_3t(ptr %base, i32 %vl, ptr %outvl) {
3790; CHECK-LABEL: test_vlseg3ff_nxv4f16_triscv.vector.tuple_nxv8i8_3t:
3791; CHECK:       # %bb.0: # %entry
3792; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, ma
3793; CHECK-NEXT:    vlseg3e16ff.v v7, (a0)
3794; CHECK-NEXT:    csrr a0, vl
3795; CHECK-NEXT:    sw a0, 0(a2)
3796; CHECK-NEXT:    ret
3797entry:
3798  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} @llvm.riscv.vlseg3ff.triscv.vector.tuple_nxv8i8_3t(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) undef, ptr %base, i32 %vl, i32 4)
3799  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} %0, 0
3800  %2 = call <vscale x 4 x half> @llvm.riscv.tuple.extract.nxv4f16.triscv.vector.tuple_nxv8i8_3t(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) %1, i32 1)
3801  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} %0, 1
3802  store i32 %3, ptr %outvl
3803  ret <vscale x 4 x half> %2
3804}
3805
3806define <vscale x 4 x half> @test_vlseg3ff_mask_nxv4f16_triscv.vector.tuple_nxv8i8_3t(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) %val, ptr %base, i32 %vl, <vscale x 4 x i1> %mask, ptr %outvl) {
3807; CHECK-LABEL: test_vlseg3ff_mask_nxv4f16_triscv.vector.tuple_nxv8i8_3t:
3808; CHECK:       # %bb.0: # %entry
3809; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, mu
3810; CHECK-NEXT:    vmv1r.v v7, v8
3811; CHECK-NEXT:    vmv1r.v v8, v9
3812; CHECK-NEXT:    vmv1r.v v9, v10
3813; CHECK-NEXT:    vlseg3e16ff.v v7, (a0), v0.t
3814; CHECK-NEXT:    csrr a0, vl
3815; CHECK-NEXT:    sw a0, 0(a2)
3816; CHECK-NEXT:    ret
3817entry:
3818  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv8i8_3t.nxv4i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) %val, ptr %base, <vscale x 4 x i1> %mask, i32 %vl, i32 1, i32 4)
3819  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} %0, 0
3820  %2 = call <vscale x 4 x half> @llvm.riscv.tuple.extract.nxv4f16.triscv.vector.tuple_nxv8i8_3t(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) %1, i32 1)
3821  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} %0, 1
3822  store i32 %3, ptr %outvl
3823  ret <vscale x 4 x half> %2
3824}
3825
3826
3827define <vscale x 8 x half> @test_vlseg3ff_nxv8f16_triscv.vector.tuple_nxv16i8_3t(ptr %base, i32 %vl, ptr %outvl) {
3828; CHECK-LABEL: test_vlseg3ff_nxv8f16_triscv.vector.tuple_nxv16i8_3t:
3829; CHECK:       # %bb.0: # %entry
3830; CHECK-NEXT:    vsetvli zero, a1, e16, m2, ta, ma
3831; CHECK-NEXT:    vlseg3e16ff.v v6, (a0)
3832; CHECK-NEXT:    csrr a0, vl
3833; CHECK-NEXT:    sw a0, 0(a2)
3834; CHECK-NEXT:    ret
3835entry:
3836  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} @llvm.riscv.vlseg3ff.triscv.vector.tuple_nxv16i8_3t(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) undef, ptr %base, i32 %vl, i32 4)
3837  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} %0, 0
3838  %2 = call <vscale x 8 x half> @llvm.riscv.tuple.extract.nxv8f16.triscv.vector.tuple_nxv16i8_3t(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) %1, i32 1)
3839  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} %0, 1
3840  store i32 %3, ptr %outvl
3841  ret <vscale x 8 x half> %2
3842}
3843
3844define <vscale x 8 x half> @test_vlseg3ff_mask_nxv8f16_triscv.vector.tuple_nxv16i8_3t(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) %val, ptr %base, i32 %vl, <vscale x 8 x i1> %mask, ptr %outvl) {
3845; CHECK-LABEL: test_vlseg3ff_mask_nxv8f16_triscv.vector.tuple_nxv16i8_3t:
3846; CHECK:       # %bb.0: # %entry
3847; CHECK-NEXT:    vsetvli zero, a1, e16, m2, ta, mu
3848; CHECK-NEXT:    vmv2r.v v6, v8
3849; CHECK-NEXT:    vmv2r.v v8, v10
3850; CHECK-NEXT:    vmv2r.v v10, v12
3851; CHECK-NEXT:    vlseg3e16ff.v v6, (a0), v0.t
3852; CHECK-NEXT:    csrr a0, vl
3853; CHECK-NEXT:    sw a0, 0(a2)
3854; CHECK-NEXT:    ret
3855entry:
3856  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv16i8_3t.nxv8i1(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) %val, ptr %base, <vscale x 8 x i1> %mask, i32 %vl, i32 1, i32 4)
3857  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} %0, 0
3858  %2 = call <vscale x 8 x half> @llvm.riscv.tuple.extract.nxv8f16.triscv.vector.tuple_nxv16i8_3t(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) %1, i32 1)
3859  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} %0, 1
3860  store i32 %3, ptr %outvl
3861  ret <vscale x 8 x half> %2
3862}
3863
3864
3865define <vscale x 1 x half> @test_vlseg4ff_nxv1f16_triscv.vector.tuple_nxv2i8_4t(ptr %base, i32 %vl, ptr %outvl) {
3866; CHECK-LABEL: test_vlseg4ff_nxv1f16_triscv.vector.tuple_nxv2i8_4t:
3867; CHECK:       # %bb.0: # %entry
3868; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, ma
3869; CHECK-NEXT:    vlseg4e16ff.v v7, (a0)
3870; CHECK-NEXT:    csrr a0, vl
3871; CHECK-NEXT:    sw a0, 0(a2)
3872; CHECK-NEXT:    ret
3873entry:
3874  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 4), i32} @llvm.riscv.vlseg4ff.triscv.vector.tuple_nxv2i8_4t(target("riscv.vector.tuple", <vscale x 2 x i8>, 4) undef, ptr %base, i32 %vl, i32 4)
3875  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 4), i32} %0, 0
3876  %2 = call <vscale x 1 x half> @llvm.riscv.tuple.extract.nxv1f16.triscv.vector.tuple_nxv2i8_4t(target("riscv.vector.tuple", <vscale x 2 x i8>, 4) %1, i32 1)
3877  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 4), i32} %0, 1
3878  store i32 %3, ptr %outvl
3879  ret <vscale x 1 x half> %2
3880}
3881
3882define <vscale x 1 x half> @test_vlseg4ff_mask_nxv1f16_triscv.vector.tuple_nxv2i8_4t(target("riscv.vector.tuple", <vscale x 2 x i8>, 4) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
3883; CHECK-LABEL: test_vlseg4ff_mask_nxv1f16_triscv.vector.tuple_nxv2i8_4t:
3884; CHECK:       # %bb.0: # %entry
3885; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, mu
3886; CHECK-NEXT:    vmv1r.v v7, v8
3887; CHECK-NEXT:    vmv1r.v v8, v9
3888; CHECK-NEXT:    vmv1r.v v9, v10
3889; CHECK-NEXT:    vmv1r.v v10, v11
3890; CHECK-NEXT:    vlseg4e16ff.v v7, (a0), v0.t
3891; CHECK-NEXT:    csrr a0, vl
3892; CHECK-NEXT:    sw a0, 0(a2)
3893; CHECK-NEXT:    ret
3894entry:
3895  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv2i8_4t.nxv1i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 4) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 4)
3896  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 4), i32} %0, 0
3897  %2 = call <vscale x 1 x half> @llvm.riscv.tuple.extract.nxv1f16.triscv.vector.tuple_nxv2i8_4t(target("riscv.vector.tuple", <vscale x 2 x i8>, 4) %1, i32 1)
3898  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 4), i32} %0, 1
3899  store i32 %3, ptr %outvl
3900  ret <vscale x 1 x half> %2
3901}
3902
3903
3904define <vscale x 2 x half> @test_vlseg4ff_nxv2f16_triscv.vector.tuple_nxv4i8_4t(ptr %base, i32 %vl, ptr %outvl) {
3905; CHECK-LABEL: test_vlseg4ff_nxv2f16_triscv.vector.tuple_nxv4i8_4t:
3906; CHECK:       # %bb.0: # %entry
3907; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, ma
3908; CHECK-NEXT:    vlseg4e16ff.v v7, (a0)
3909; CHECK-NEXT:    csrr a0, vl
3910; CHECK-NEXT:    sw a0, 0(a2)
3911; CHECK-NEXT:    ret
3912entry:
3913  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} @llvm.riscv.vlseg4ff.triscv.vector.tuple_nxv4i8_4t(target("riscv.vector.tuple", <vscale x 4 x i8>, 4) undef, ptr %base, i32 %vl, i32 4)
3914  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} %0, 0
3915  %2 = call <vscale x 2 x half> @llvm.riscv.tuple.extract.nxv2f16.triscv.vector.tuple_nxv4i8_4t(target("riscv.vector.tuple", <vscale x 4 x i8>, 4) %1, i32 1)
3916  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} %0, 1
3917  store i32 %3, ptr %outvl
3918  ret <vscale x 2 x half> %2
3919}
3920
3921define <vscale x 2 x half> @test_vlseg4ff_mask_nxv2f16_triscv.vector.tuple_nxv4i8_4t(target("riscv.vector.tuple", <vscale x 4 x i8>, 4) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
3922; CHECK-LABEL: test_vlseg4ff_mask_nxv2f16_triscv.vector.tuple_nxv4i8_4t:
3923; CHECK:       # %bb.0: # %entry
3924; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, mu
3925; CHECK-NEXT:    vmv1r.v v7, v8
3926; CHECK-NEXT:    vmv1r.v v8, v9
3927; CHECK-NEXT:    vmv1r.v v9, v10
3928; CHECK-NEXT:    vmv1r.v v10, v11
3929; CHECK-NEXT:    vlseg4e16ff.v v7, (a0), v0.t
3930; CHECK-NEXT:    csrr a0, vl
3931; CHECK-NEXT:    sw a0, 0(a2)
3932; CHECK-NEXT:    ret
3933entry:
3934  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv4i8_4t.nxv2i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 4) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 4)
3935  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} %0, 0
3936  %2 = call <vscale x 2 x half> @llvm.riscv.tuple.extract.nxv2f16.triscv.vector.tuple_nxv4i8_4t(target("riscv.vector.tuple", <vscale x 4 x i8>, 4) %1, i32 1)
3937  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} %0, 1
3938  store i32 %3, ptr %outvl
3939  ret <vscale x 2 x half> %2
3940}
3941
3942
3943define <vscale x 4 x half> @test_vlseg4ff_nxv4f16_triscv.vector.tuple_nxv8i8_4t(ptr %base, i32 %vl, ptr %outvl) {
3944; CHECK-LABEL: test_vlseg4ff_nxv4f16_triscv.vector.tuple_nxv8i8_4t:
3945; CHECK:       # %bb.0: # %entry
3946; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, ma
3947; CHECK-NEXT:    vlseg4e16ff.v v7, (a0)
3948; CHECK-NEXT:    csrr a0, vl
3949; CHECK-NEXT:    sw a0, 0(a2)
3950; CHECK-NEXT:    ret
3951entry:
3952  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} @llvm.riscv.vlseg4ff.triscv.vector.tuple_nxv8i8_4t(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) undef, ptr %base, i32 %vl, i32 4)
3953  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} %0, 0
3954  %2 = call <vscale x 4 x half> @llvm.riscv.tuple.extract.nxv4f16.triscv.vector.tuple_nxv8i8_4t(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) %1, i32 1)
3955  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} %0, 1
3956  store i32 %3, ptr %outvl
3957  ret <vscale x 4 x half> %2
3958}
3959
3960define <vscale x 4 x half> @test_vlseg4ff_mask_nxv4f16_triscv.vector.tuple_nxv8i8_4t(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) %val, ptr %base, i32 %vl, <vscale x 4 x i1> %mask, ptr %outvl) {
3961; CHECK-LABEL: test_vlseg4ff_mask_nxv4f16_triscv.vector.tuple_nxv8i8_4t:
3962; CHECK:       # %bb.0: # %entry
3963; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, mu
3964; CHECK-NEXT:    vmv1r.v v7, v8
3965; CHECK-NEXT:    vmv1r.v v8, v9
3966; CHECK-NEXT:    vmv1r.v v9, v10
3967; CHECK-NEXT:    vmv1r.v v10, v11
3968; CHECK-NEXT:    vlseg4e16ff.v v7, (a0), v0.t
3969; CHECK-NEXT:    csrr a0, vl
3970; CHECK-NEXT:    sw a0, 0(a2)
3971; CHECK-NEXT:    ret
3972entry:
3973  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv8i8_4t.nxv4i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) %val, ptr %base, <vscale x 4 x i1> %mask, i32 %vl, i32 1, i32 4)
3974  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} %0, 0
3975  %2 = call <vscale x 4 x half> @llvm.riscv.tuple.extract.nxv4f16.triscv.vector.tuple_nxv8i8_4t(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) %1, i32 1)
3976  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} %0, 1
3977  store i32 %3, ptr %outvl
3978  ret <vscale x 4 x half> %2
3979}
3980
3981
3982define <vscale x 8 x half> @test_vlseg4ff_nxv8f16_triscv.vector.tuple_nxv16i8_4t(ptr %base, i32 %vl, ptr %outvl) {
3983; CHECK-LABEL: test_vlseg4ff_nxv8f16_triscv.vector.tuple_nxv16i8_4t:
3984; CHECK:       # %bb.0: # %entry
3985; CHECK-NEXT:    vsetvli zero, a1, e16, m2, ta, ma
3986; CHECK-NEXT:    vlseg4e16ff.v v6, (a0)
3987; CHECK-NEXT:    csrr a0, vl
3988; CHECK-NEXT:    sw a0, 0(a2)
3989; CHECK-NEXT:    ret
3990entry:
3991  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} @llvm.riscv.vlseg4ff.triscv.vector.tuple_nxv16i8_4t(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) undef, ptr %base, i32 %vl, i32 4)
3992  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} %0, 0
3993  %2 = call <vscale x 8 x half> @llvm.riscv.tuple.extract.nxv8f16.triscv.vector.tuple_nxv16i8_4t(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) %1, i32 1)
3994  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} %0, 1
3995  store i32 %3, ptr %outvl
3996  ret <vscale x 8 x half> %2
3997}
3998
3999define <vscale x 8 x half> @test_vlseg4ff_mask_nxv8f16_triscv.vector.tuple_nxv16i8_4t(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) %val, ptr %base, i32 %vl, <vscale x 8 x i1> %mask, ptr %outvl) {
4000; CHECK-LABEL: test_vlseg4ff_mask_nxv8f16_triscv.vector.tuple_nxv16i8_4t:
4001; CHECK:       # %bb.0: # %entry
4002; CHECK-NEXT:    vsetvli zero, a1, e16, m2, ta, mu
4003; CHECK-NEXT:    vmv2r.v v6, v8
4004; CHECK-NEXT:    vmv2r.v v8, v10
4005; CHECK-NEXT:    vmv2r.v v10, v12
4006; CHECK-NEXT:    vmv2r.v v12, v14
4007; CHECK-NEXT:    vlseg4e16ff.v v6, (a0), v0.t
4008; CHECK-NEXT:    csrr a0, vl
4009; CHECK-NEXT:    sw a0, 0(a2)
4010; CHECK-NEXT:    ret
4011entry:
4012  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv16i8_4t.nxv8i1(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) %val, ptr %base, <vscale x 8 x i1> %mask, i32 %vl, i32 1, i32 4)
4013  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} %0, 0
4014  %2 = call <vscale x 8 x half> @llvm.riscv.tuple.extract.nxv8f16.triscv.vector.tuple_nxv16i8_4t(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) %1, i32 1)
4015  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} %0, 1
4016  store i32 %3, ptr %outvl
4017  ret <vscale x 8 x half> %2
4018}
4019
4020
4021define <vscale x 1 x half> @test_vlseg5ff_nxv1f16_triscv.vector.tuple_nxv2i8_5t(ptr %base, i32 %vl, ptr %outvl) {
4022; CHECK-LABEL: test_vlseg5ff_nxv1f16_triscv.vector.tuple_nxv2i8_5t:
4023; CHECK:       # %bb.0: # %entry
4024; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, ma
4025; CHECK-NEXT:    vlseg5e16ff.v v7, (a0)
4026; CHECK-NEXT:    csrr a0, vl
4027; CHECK-NEXT:    sw a0, 0(a2)
4028; CHECK-NEXT:    ret
4029entry:
4030  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 5), i32} @llvm.riscv.vlseg5ff.triscv.vector.tuple_nxv2i8_5t(target("riscv.vector.tuple", <vscale x 2 x i8>, 5) undef, ptr %base, i32 %vl, i32 4)
4031  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 5), i32} %0, 0
4032  %2 = call <vscale x 1 x half> @llvm.riscv.tuple.extract.nxv1f16.triscv.vector.tuple_nxv2i8_5t(target("riscv.vector.tuple", <vscale x 2 x i8>, 5) %1, i32 1)
4033  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 5), i32} %0, 1
4034  store i32 %3, ptr %outvl
4035  ret <vscale x 1 x half> %2
4036}
4037
4038define <vscale x 1 x half> @test_vlseg5ff_mask_nxv1f16_triscv.vector.tuple_nxv2i8_5t(target("riscv.vector.tuple", <vscale x 2 x i8>, 5) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
4039; CHECK-LABEL: test_vlseg5ff_mask_nxv1f16_triscv.vector.tuple_nxv2i8_5t:
4040; CHECK:       # %bb.0: # %entry
4041; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, mu
4042; CHECK-NEXT:    vmv1r.v v7, v8
4043; CHECK-NEXT:    vmv1r.v v8, v9
4044; CHECK-NEXT:    vmv1r.v v9, v10
4045; CHECK-NEXT:    vmv1r.v v10, v11
4046; CHECK-NEXT:    vmv1r.v v11, v12
4047; CHECK-NEXT:    vlseg5e16ff.v v7, (a0), v0.t
4048; CHECK-NEXT:    csrr a0, vl
4049; CHECK-NEXT:    sw a0, 0(a2)
4050; CHECK-NEXT:    ret
4051entry:
4052  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 5), i32} @llvm.riscv.vlseg5ff.mask.triscv.vector.tuple_nxv2i8_5t.nxv1i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 5) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 4)
4053  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 5), i32} %0, 0
4054  %2 = call <vscale x 1 x half> @llvm.riscv.tuple.extract.nxv1f16.triscv.vector.tuple_nxv2i8_5t(target("riscv.vector.tuple", <vscale x 2 x i8>, 5) %1, i32 1)
4055  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 5), i32} %0, 1
4056  store i32 %3, ptr %outvl
4057  ret <vscale x 1 x half> %2
4058}
4059
4060
4061define <vscale x 2 x half> @test_vlseg5ff_nxv2f16_triscv.vector.tuple_nxv4i8_5t(ptr %base, i32 %vl, ptr %outvl) {
4062; CHECK-LABEL: test_vlseg5ff_nxv2f16_triscv.vector.tuple_nxv4i8_5t:
4063; CHECK:       # %bb.0: # %entry
4064; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, ma
4065; CHECK-NEXT:    vlseg5e16ff.v v7, (a0)
4066; CHECK-NEXT:    csrr a0, vl
4067; CHECK-NEXT:    sw a0, 0(a2)
4068; CHECK-NEXT:    ret
4069entry:
4070  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} @llvm.riscv.vlseg5ff.triscv.vector.tuple_nxv4i8_5t(target("riscv.vector.tuple", <vscale x 4 x i8>, 5) undef, ptr %base, i32 %vl, i32 4)
4071  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} %0, 0
4072  %2 = call <vscale x 2 x half> @llvm.riscv.tuple.extract.nxv2f16.triscv.vector.tuple_nxv4i8_5t(target("riscv.vector.tuple", <vscale x 4 x i8>, 5) %1, i32 1)
4073  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} %0, 1
4074  store i32 %3, ptr %outvl
4075  ret <vscale x 2 x half> %2
4076}
4077
4078define <vscale x 2 x half> @test_vlseg5ff_mask_nxv2f16_triscv.vector.tuple_nxv4i8_5t(target("riscv.vector.tuple", <vscale x 4 x i8>, 5) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
4079; CHECK-LABEL: test_vlseg5ff_mask_nxv2f16_triscv.vector.tuple_nxv4i8_5t:
4080; CHECK:       # %bb.0: # %entry
4081; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, mu
4082; CHECK-NEXT:    vmv1r.v v7, v8
4083; CHECK-NEXT:    vmv1r.v v8, v9
4084; CHECK-NEXT:    vmv1r.v v9, v10
4085; CHECK-NEXT:    vmv1r.v v10, v11
4086; CHECK-NEXT:    vmv1r.v v11, v12
4087; CHECK-NEXT:    vlseg5e16ff.v v7, (a0), v0.t
4088; CHECK-NEXT:    csrr a0, vl
4089; CHECK-NEXT:    sw a0, 0(a2)
4090; CHECK-NEXT:    ret
4091entry:
4092  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} @llvm.riscv.vlseg5ff.mask.triscv.vector.tuple_nxv4i8_5t.nxv2i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 5) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 4)
4093  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} %0, 0
4094  %2 = call <vscale x 2 x half> @llvm.riscv.tuple.extract.nxv2f16.triscv.vector.tuple_nxv4i8_5t(target("riscv.vector.tuple", <vscale x 4 x i8>, 5) %1, i32 1)
4095  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} %0, 1
4096  store i32 %3, ptr %outvl
4097  ret <vscale x 2 x half> %2
4098}
4099
4100
4101define <vscale x 4 x half> @test_vlseg5ff_nxv4f16_triscv.vector.tuple_nxv8i8_5t(ptr %base, i32 %vl, ptr %outvl) {
4102; CHECK-LABEL: test_vlseg5ff_nxv4f16_triscv.vector.tuple_nxv8i8_5t:
4103; CHECK:       # %bb.0: # %entry
4104; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, ma
4105; CHECK-NEXT:    vlseg5e16ff.v v7, (a0)
4106; CHECK-NEXT:    csrr a0, vl
4107; CHECK-NEXT:    sw a0, 0(a2)
4108; CHECK-NEXT:    ret
4109entry:
4110  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} @llvm.riscv.vlseg5ff.triscv.vector.tuple_nxv8i8_5t(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) undef, ptr %base, i32 %vl, i32 4)
4111  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} %0, 0
4112  %2 = call <vscale x 4 x half> @llvm.riscv.tuple.extract.nxv4f16.triscv.vector.tuple_nxv8i8_5t(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) %1, i32 1)
4113  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} %0, 1
4114  store i32 %3, ptr %outvl
4115  ret <vscale x 4 x half> %2
4116}
4117
4118define <vscale x 4 x half> @test_vlseg5ff_mask_nxv4f16_triscv.vector.tuple_nxv8i8_5t(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) %val, ptr %base, i32 %vl, <vscale x 4 x i1> %mask, ptr %outvl) {
4119; CHECK-LABEL: test_vlseg5ff_mask_nxv4f16_triscv.vector.tuple_nxv8i8_5t:
4120; CHECK:       # %bb.0: # %entry
4121; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, mu
4122; CHECK-NEXT:    vmv1r.v v7, v8
4123; CHECK-NEXT:    vmv1r.v v8, v9
4124; CHECK-NEXT:    vmv1r.v v9, v10
4125; CHECK-NEXT:    vmv1r.v v10, v11
4126; CHECK-NEXT:    vmv1r.v v11, v12
4127; CHECK-NEXT:    vlseg5e16ff.v v7, (a0), v0.t
4128; CHECK-NEXT:    csrr a0, vl
4129; CHECK-NEXT:    sw a0, 0(a2)
4130; CHECK-NEXT:    ret
4131entry:
4132  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} @llvm.riscv.vlseg5ff.mask.triscv.vector.tuple_nxv8i8_5t.nxv4i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) %val, ptr %base, <vscale x 4 x i1> %mask, i32 %vl, i32 1, i32 4)
4133  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} %0, 0
4134  %2 = call <vscale x 4 x half> @llvm.riscv.tuple.extract.nxv4f16.triscv.vector.tuple_nxv8i8_5t(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) %1, i32 1)
4135  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} %0, 1
4136  store i32 %3, ptr %outvl
4137  ret <vscale x 4 x half> %2
4138}
4139
4140
4141define <vscale x 1 x half> @test_vlseg6ff_nxv1f16_triscv.vector.tuple_nxv2i8_6t(ptr %base, i32 %vl, ptr %outvl) {
4142; CHECK-LABEL: test_vlseg6ff_nxv1f16_triscv.vector.tuple_nxv2i8_6t:
4143; CHECK:       # %bb.0: # %entry
4144; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, ma
4145; CHECK-NEXT:    vlseg6e16ff.v v7, (a0)
4146; CHECK-NEXT:    csrr a0, vl
4147; CHECK-NEXT:    sw a0, 0(a2)
4148; CHECK-NEXT:    ret
4149entry:
4150  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 6), i32} @llvm.riscv.vlseg6ff.triscv.vector.tuple_nxv2i8_6t(target("riscv.vector.tuple", <vscale x 2 x i8>, 6) undef, ptr %base, i32 %vl, i32 4)
4151  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 6), i32} %0, 0
4152  %2 = call <vscale x 1 x half> @llvm.riscv.tuple.extract.nxv1f16.triscv.vector.tuple_nxv2i8_6t(target("riscv.vector.tuple", <vscale x 2 x i8>, 6) %1, i32 1)
4153  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 6), i32} %0, 1
4154  store i32 %3, ptr %outvl
4155  ret <vscale x 1 x half> %2
4156}
4157
4158define <vscale x 1 x half> @test_vlseg6ff_mask_nxv1f16_triscv.vector.tuple_nxv2i8_6t(target("riscv.vector.tuple", <vscale x 2 x i8>, 6) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
4159; CHECK-LABEL: test_vlseg6ff_mask_nxv1f16_triscv.vector.tuple_nxv2i8_6t:
4160; CHECK:       # %bb.0: # %entry
4161; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, mu
4162; CHECK-NEXT:    vmv1r.v v7, v8
4163; CHECK-NEXT:    vmv1r.v v8, v9
4164; CHECK-NEXT:    vmv1r.v v9, v10
4165; CHECK-NEXT:    vmv1r.v v10, v11
4166; CHECK-NEXT:    vmv1r.v v11, v12
4167; CHECK-NEXT:    vmv1r.v v12, v13
4168; CHECK-NEXT:    vlseg6e16ff.v v7, (a0), v0.t
4169; CHECK-NEXT:    csrr a0, vl
4170; CHECK-NEXT:    sw a0, 0(a2)
4171; CHECK-NEXT:    ret
4172entry:
4173  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 6), i32} @llvm.riscv.vlseg6ff.mask.triscv.vector.tuple_nxv2i8_6t.nxv1i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 6) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 4)
4174  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 6), i32} %0, 0
4175  %2 = call <vscale x 1 x half> @llvm.riscv.tuple.extract.nxv1f16.triscv.vector.tuple_nxv2i8_6t(target("riscv.vector.tuple", <vscale x 2 x i8>, 6) %1, i32 1)
4176  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 6), i32} %0, 1
4177  store i32 %3, ptr %outvl
4178  ret <vscale x 1 x half> %2
4179}
4180
4181
4182define <vscale x 2 x half> @test_vlseg6ff_nxv2f16_triscv.vector.tuple_nxv4i8_6t(ptr %base, i32 %vl, ptr %outvl) {
4183; CHECK-LABEL: test_vlseg6ff_nxv2f16_triscv.vector.tuple_nxv4i8_6t:
4184; CHECK:       # %bb.0: # %entry
4185; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, ma
4186; CHECK-NEXT:    vlseg6e16ff.v v7, (a0)
4187; CHECK-NEXT:    csrr a0, vl
4188; CHECK-NEXT:    sw a0, 0(a2)
4189; CHECK-NEXT:    ret
4190entry:
4191  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} @llvm.riscv.vlseg6ff.triscv.vector.tuple_nxv4i8_6t(target("riscv.vector.tuple", <vscale x 4 x i8>, 6) undef, ptr %base, i32 %vl, i32 4)
4192  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} %0, 0
4193  %2 = call <vscale x 2 x half> @llvm.riscv.tuple.extract.nxv2f16.triscv.vector.tuple_nxv4i8_6t(target("riscv.vector.tuple", <vscale x 4 x i8>, 6) %1, i32 1)
4194  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} %0, 1
4195  store i32 %3, ptr %outvl
4196  ret <vscale x 2 x half> %2
4197}
4198
4199define <vscale x 2 x half> @test_vlseg6ff_mask_nxv2f16_triscv.vector.tuple_nxv4i8_6t(target("riscv.vector.tuple", <vscale x 4 x i8>, 6) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
4200; CHECK-LABEL: test_vlseg6ff_mask_nxv2f16_triscv.vector.tuple_nxv4i8_6t:
4201; CHECK:       # %bb.0: # %entry
4202; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, mu
4203; CHECK-NEXT:    vmv1r.v v7, v8
4204; CHECK-NEXT:    vmv1r.v v8, v9
4205; CHECK-NEXT:    vmv1r.v v9, v10
4206; CHECK-NEXT:    vmv1r.v v10, v11
4207; CHECK-NEXT:    vmv1r.v v11, v12
4208; CHECK-NEXT:    vmv1r.v v12, v13
4209; CHECK-NEXT:    vlseg6e16ff.v v7, (a0), v0.t
4210; CHECK-NEXT:    csrr a0, vl
4211; CHECK-NEXT:    sw a0, 0(a2)
4212; CHECK-NEXT:    ret
4213entry:
4214  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} @llvm.riscv.vlseg6ff.mask.triscv.vector.tuple_nxv4i8_6t.nxv2i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 6) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 4)
4215  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} %0, 0
4216  %2 = call <vscale x 2 x half> @llvm.riscv.tuple.extract.nxv2f16.triscv.vector.tuple_nxv4i8_6t(target("riscv.vector.tuple", <vscale x 4 x i8>, 6) %1, i32 1)
4217  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} %0, 1
4218  store i32 %3, ptr %outvl
4219  ret <vscale x 2 x half> %2
4220}
4221
4222
4223define <vscale x 4 x half> @test_vlseg6ff_nxv4f16_triscv.vector.tuple_nxv8i8_6t(ptr %base, i32 %vl, ptr %outvl) {
4224; CHECK-LABEL: test_vlseg6ff_nxv4f16_triscv.vector.tuple_nxv8i8_6t:
4225; CHECK:       # %bb.0: # %entry
4226; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, ma
4227; CHECK-NEXT:    vlseg6e16ff.v v7, (a0)
4228; CHECK-NEXT:    csrr a0, vl
4229; CHECK-NEXT:    sw a0, 0(a2)
4230; CHECK-NEXT:    ret
4231entry:
4232  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} @llvm.riscv.vlseg6ff.triscv.vector.tuple_nxv8i8_6t(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) undef, ptr %base, i32 %vl, i32 4)
4233  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} %0, 0
4234  %2 = call <vscale x 4 x half> @llvm.riscv.tuple.extract.nxv4f16.triscv.vector.tuple_nxv8i8_6t(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) %1, i32 1)
4235  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} %0, 1
4236  store i32 %3, ptr %outvl
4237  ret <vscale x 4 x half> %2
4238}
4239
4240define <vscale x 4 x half> @test_vlseg6ff_mask_nxv4f16_triscv.vector.tuple_nxv8i8_6t(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) %val, ptr %base, i32 %vl, <vscale x 4 x i1> %mask, ptr %outvl) {
4241; CHECK-LABEL: test_vlseg6ff_mask_nxv4f16_triscv.vector.tuple_nxv8i8_6t:
4242; CHECK:       # %bb.0: # %entry
4243; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, mu
4244; CHECK-NEXT:    vmv1r.v v7, v8
4245; CHECK-NEXT:    vmv1r.v v8, v9
4246; CHECK-NEXT:    vmv1r.v v9, v10
4247; CHECK-NEXT:    vmv1r.v v10, v11
4248; CHECK-NEXT:    vmv1r.v v11, v12
4249; CHECK-NEXT:    vmv1r.v v12, v13
4250; CHECK-NEXT:    vlseg6e16ff.v v7, (a0), v0.t
4251; CHECK-NEXT:    csrr a0, vl
4252; CHECK-NEXT:    sw a0, 0(a2)
4253; CHECK-NEXT:    ret
4254entry:
4255  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} @llvm.riscv.vlseg6ff.mask.triscv.vector.tuple_nxv8i8_6t.nxv4i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) %val, ptr %base, <vscale x 4 x i1> %mask, i32 %vl, i32 1, i32 4)
4256  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} %0, 0
4257  %2 = call <vscale x 4 x half> @llvm.riscv.tuple.extract.nxv4f16.triscv.vector.tuple_nxv8i8_6t(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) %1, i32 1)
4258  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} %0, 1
4259  store i32 %3, ptr %outvl
4260  ret <vscale x 4 x half> %2
4261}
4262
4263
4264define <vscale x 1 x half> @test_vlseg7ff_nxv1f16_triscv.vector.tuple_nxv2i8_7t(ptr %base, i32 %vl, ptr %outvl) {
4265; CHECK-LABEL: test_vlseg7ff_nxv1f16_triscv.vector.tuple_nxv2i8_7t:
4266; CHECK:       # %bb.0: # %entry
4267; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, ma
4268; CHECK-NEXT:    vlseg7e16ff.v v7, (a0)
4269; CHECK-NEXT:    csrr a0, vl
4270; CHECK-NEXT:    sw a0, 0(a2)
4271; CHECK-NEXT:    ret
4272entry:
4273  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 7), i32} @llvm.riscv.vlseg7ff.triscv.vector.tuple_nxv2i8_7t(target("riscv.vector.tuple", <vscale x 2 x i8>, 7) undef, ptr %base, i32 %vl, i32 4)
4274  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 7), i32} %0, 0
4275  %2 = call <vscale x 1 x half> @llvm.riscv.tuple.extract.nxv1f16.triscv.vector.tuple_nxv2i8_7t(target("riscv.vector.tuple", <vscale x 2 x i8>, 7) %1, i32 1)
4276  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 7), i32} %0, 1
4277  store i32 %3, ptr %outvl
4278  ret <vscale x 1 x half> %2
4279}
4280
4281define <vscale x 1 x half> @test_vlseg7ff_mask_nxv1f16_triscv.vector.tuple_nxv2i8_7t(target("riscv.vector.tuple", <vscale x 2 x i8>, 7) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
4282; CHECK-LABEL: test_vlseg7ff_mask_nxv1f16_triscv.vector.tuple_nxv2i8_7t:
4283; CHECK:       # %bb.0: # %entry
4284; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, mu
4285; CHECK-NEXT:    vmv1r.v v7, v8
4286; CHECK-NEXT:    vmv1r.v v8, v9
4287; CHECK-NEXT:    vmv1r.v v9, v10
4288; CHECK-NEXT:    vmv1r.v v10, v11
4289; CHECK-NEXT:    vmv1r.v v11, v12
4290; CHECK-NEXT:    vmv1r.v v12, v13
4291; CHECK-NEXT:    vmv1r.v v13, v14
4292; CHECK-NEXT:    vlseg7e16ff.v v7, (a0), v0.t
4293; CHECK-NEXT:    csrr a0, vl
4294; CHECK-NEXT:    sw a0, 0(a2)
4295; CHECK-NEXT:    ret
4296entry:
4297  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 7), i32} @llvm.riscv.vlseg7ff.mask.triscv.vector.tuple_nxv2i8_7t.nxv1i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 7) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 4)
4298  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 7), i32} %0, 0
4299  %2 = call <vscale x 1 x half> @llvm.riscv.tuple.extract.nxv1f16.triscv.vector.tuple_nxv2i8_7t(target("riscv.vector.tuple", <vscale x 2 x i8>, 7) %1, i32 1)
4300  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 7), i32} %0, 1
4301  store i32 %3, ptr %outvl
4302  ret <vscale x 1 x half> %2
4303}
4304
4305
4306define <vscale x 2 x half> @test_vlseg7ff_nxv2f16_triscv.vector.tuple_nxv4i8_7t(ptr %base, i32 %vl, ptr %outvl) {
4307; CHECK-LABEL: test_vlseg7ff_nxv2f16_triscv.vector.tuple_nxv4i8_7t:
4308; CHECK:       # %bb.0: # %entry
4309; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, ma
4310; CHECK-NEXT:    vlseg7e16ff.v v7, (a0)
4311; CHECK-NEXT:    csrr a0, vl
4312; CHECK-NEXT:    sw a0, 0(a2)
4313; CHECK-NEXT:    ret
4314entry:
4315  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} @llvm.riscv.vlseg7ff.triscv.vector.tuple_nxv4i8_7t(target("riscv.vector.tuple", <vscale x 4 x i8>, 7) undef, ptr %base, i32 %vl, i32 4)
4316  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} %0, 0
4317  %2 = call <vscale x 2 x half> @llvm.riscv.tuple.extract.nxv2f16.triscv.vector.tuple_nxv4i8_7t(target("riscv.vector.tuple", <vscale x 4 x i8>, 7) %1, i32 1)
4318  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} %0, 1
4319  store i32 %3, ptr %outvl
4320  ret <vscale x 2 x half> %2
4321}
4322
4323define <vscale x 2 x half> @test_vlseg7ff_mask_nxv2f16_triscv.vector.tuple_nxv4i8_7t(target("riscv.vector.tuple", <vscale x 4 x i8>, 7) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
4324; CHECK-LABEL: test_vlseg7ff_mask_nxv2f16_triscv.vector.tuple_nxv4i8_7t:
4325; CHECK:       # %bb.0: # %entry
4326; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, mu
4327; CHECK-NEXT:    vmv1r.v v7, v8
4328; CHECK-NEXT:    vmv1r.v v8, v9
4329; CHECK-NEXT:    vmv1r.v v9, v10
4330; CHECK-NEXT:    vmv1r.v v10, v11
4331; CHECK-NEXT:    vmv1r.v v11, v12
4332; CHECK-NEXT:    vmv1r.v v12, v13
4333; CHECK-NEXT:    vmv1r.v v13, v14
4334; CHECK-NEXT:    vlseg7e16ff.v v7, (a0), v0.t
4335; CHECK-NEXT:    csrr a0, vl
4336; CHECK-NEXT:    sw a0, 0(a2)
4337; CHECK-NEXT:    ret
4338entry:
4339  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} @llvm.riscv.vlseg7ff.mask.triscv.vector.tuple_nxv4i8_7t.nxv2i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 7) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 4)
4340  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} %0, 0
4341  %2 = call <vscale x 2 x half> @llvm.riscv.tuple.extract.nxv2f16.triscv.vector.tuple_nxv4i8_7t(target("riscv.vector.tuple", <vscale x 4 x i8>, 7) %1, i32 1)
4342  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} %0, 1
4343  store i32 %3, ptr %outvl
4344  ret <vscale x 2 x half> %2
4345}
4346
4347
4348define <vscale x 4 x half> @test_vlseg7ff_nxv4f16_triscv.vector.tuple_nxv8i8_7t(ptr %base, i32 %vl, ptr %outvl) {
4349; CHECK-LABEL: test_vlseg7ff_nxv4f16_triscv.vector.tuple_nxv8i8_7t:
4350; CHECK:       # %bb.0: # %entry
4351; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, ma
4352; CHECK-NEXT:    vlseg7e16ff.v v7, (a0)
4353; CHECK-NEXT:    csrr a0, vl
4354; CHECK-NEXT:    sw a0, 0(a2)
4355; CHECK-NEXT:    ret
4356entry:
4357  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} @llvm.riscv.vlseg7ff.triscv.vector.tuple_nxv8i8_7t(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) undef, ptr %base, i32 %vl, i32 4)
4358  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} %0, 0
4359  %2 = call <vscale x 4 x half> @llvm.riscv.tuple.extract.nxv4f16.triscv.vector.tuple_nxv8i8_7t(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) %1, i32 1)
4360  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} %0, 1
4361  store i32 %3, ptr %outvl
4362  ret <vscale x 4 x half> %2
4363}
4364
4365define <vscale x 4 x half> @test_vlseg7ff_mask_nxv4f16_triscv.vector.tuple_nxv8i8_7t(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) %val, ptr %base, i32 %vl, <vscale x 4 x i1> %mask, ptr %outvl) {
4366; CHECK-LABEL: test_vlseg7ff_mask_nxv4f16_triscv.vector.tuple_nxv8i8_7t:
4367; CHECK:       # %bb.0: # %entry
4368; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, mu
4369; CHECK-NEXT:    vmv1r.v v7, v8
4370; CHECK-NEXT:    vmv1r.v v8, v9
4371; CHECK-NEXT:    vmv1r.v v9, v10
4372; CHECK-NEXT:    vmv1r.v v10, v11
4373; CHECK-NEXT:    vmv1r.v v11, v12
4374; CHECK-NEXT:    vmv1r.v v12, v13
4375; CHECK-NEXT:    vmv1r.v v13, v14
4376; CHECK-NEXT:    vlseg7e16ff.v v7, (a0), v0.t
4377; CHECK-NEXT:    csrr a0, vl
4378; CHECK-NEXT:    sw a0, 0(a2)
4379; CHECK-NEXT:    ret
4380entry:
4381  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} @llvm.riscv.vlseg7ff.mask.triscv.vector.tuple_nxv8i8_7t.nxv4i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) %val, ptr %base, <vscale x 4 x i1> %mask, i32 %vl, i32 1, i32 4)
4382  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} %0, 0
4383  %2 = call <vscale x 4 x half> @llvm.riscv.tuple.extract.nxv4f16.triscv.vector.tuple_nxv8i8_7t(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) %1, i32 1)
4384  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} %0, 1
4385  store i32 %3, ptr %outvl
4386  ret <vscale x 4 x half> %2
4387}
4388
4389
4390define <vscale x 1 x half> @test_vlseg8ff_nxv1f16_triscv.vector.tuple_nxv2i8_8t(ptr %base, i32 %vl, ptr %outvl) {
4391; CHECK-LABEL: test_vlseg8ff_nxv1f16_triscv.vector.tuple_nxv2i8_8t:
4392; CHECK:       # %bb.0: # %entry
4393; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, ma
4394; CHECK-NEXT:    vlseg8e16ff.v v7, (a0)
4395; CHECK-NEXT:    csrr a0, vl
4396; CHECK-NEXT:    sw a0, 0(a2)
4397; CHECK-NEXT:    ret
4398entry:
4399  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 8), i32} @llvm.riscv.vlseg8ff.triscv.vector.tuple_nxv2i8_8t(target("riscv.vector.tuple", <vscale x 2 x i8>, 8) undef, ptr %base, i32 %vl, i32 4)
4400  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 8), i32} %0, 0
4401  %2 = call <vscale x 1 x half> @llvm.riscv.tuple.extract.nxv1f16.triscv.vector.tuple_nxv2i8_8t(target("riscv.vector.tuple", <vscale x 2 x i8>, 8) %1, i32 1)
4402  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 8), i32} %0, 1
4403  store i32 %3, ptr %outvl
4404  ret <vscale x 1 x half> %2
4405}
4406
4407define <vscale x 1 x half> @test_vlseg8ff_mask_nxv1f16_triscv.vector.tuple_nxv2i8_8t(target("riscv.vector.tuple", <vscale x 2 x i8>, 8) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
4408; CHECK-LABEL: test_vlseg8ff_mask_nxv1f16_triscv.vector.tuple_nxv2i8_8t:
4409; CHECK:       # %bb.0: # %entry
4410; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, mu
4411; CHECK-NEXT:    vmv1r.v v7, v8
4412; CHECK-NEXT:    vmv1r.v v8, v9
4413; CHECK-NEXT:    vmv1r.v v9, v10
4414; CHECK-NEXT:    vmv1r.v v10, v11
4415; CHECK-NEXT:    vmv1r.v v11, v12
4416; CHECK-NEXT:    vmv1r.v v12, v13
4417; CHECK-NEXT:    vmv1r.v v13, v14
4418; CHECK-NEXT:    vmv1r.v v14, v15
4419; CHECK-NEXT:    vlseg8e16ff.v v7, (a0), v0.t
4420; CHECK-NEXT:    csrr a0, vl
4421; CHECK-NEXT:    sw a0, 0(a2)
4422; CHECK-NEXT:    ret
4423entry:
4424  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 8), i32} @llvm.riscv.vlseg8ff.mask.triscv.vector.tuple_nxv2i8_8t.nxv1i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 8) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 4)
4425  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 8), i32} %0, 0
4426  %2 = call <vscale x 1 x half> @llvm.riscv.tuple.extract.nxv1f16.triscv.vector.tuple_nxv2i8_8t(target("riscv.vector.tuple", <vscale x 2 x i8>, 8) %1, i32 1)
4427  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 8), i32} %0, 1
4428  store i32 %3, ptr %outvl
4429  ret <vscale x 1 x half> %2
4430}
4431
4432
4433define <vscale x 2 x half> @test_vlseg8ff_nxv2f16_triscv.vector.tuple_nxv4i8_8t(ptr %base, i32 %vl, ptr %outvl) {
4434; CHECK-LABEL: test_vlseg8ff_nxv2f16_triscv.vector.tuple_nxv4i8_8t:
4435; CHECK:       # %bb.0: # %entry
4436; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, ma
4437; CHECK-NEXT:    vlseg8e16ff.v v7, (a0)
4438; CHECK-NEXT:    csrr a0, vl
4439; CHECK-NEXT:    sw a0, 0(a2)
4440; CHECK-NEXT:    ret
4441entry:
4442  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} @llvm.riscv.vlseg8ff.triscv.vector.tuple_nxv4i8_8t(target("riscv.vector.tuple", <vscale x 4 x i8>, 8) undef, ptr %base, i32 %vl, i32 4)
4443  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} %0, 0
4444  %2 = call <vscale x 2 x half> @llvm.riscv.tuple.extract.nxv2f16.triscv.vector.tuple_nxv4i8_8t(target("riscv.vector.tuple", <vscale x 4 x i8>, 8) %1, i32 1)
4445  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} %0, 1
4446  store i32 %3, ptr %outvl
4447  ret <vscale x 2 x half> %2
4448}
4449
4450define <vscale x 2 x half> @test_vlseg8ff_mask_nxv2f16_triscv.vector.tuple_nxv4i8_8t(target("riscv.vector.tuple", <vscale x 4 x i8>, 8) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
4451; CHECK-LABEL: test_vlseg8ff_mask_nxv2f16_triscv.vector.tuple_nxv4i8_8t:
4452; CHECK:       # %bb.0: # %entry
4453; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, mu
4454; CHECK-NEXT:    vmv1r.v v7, v8
4455; CHECK-NEXT:    vmv1r.v v8, v9
4456; CHECK-NEXT:    vmv1r.v v9, v10
4457; CHECK-NEXT:    vmv1r.v v10, v11
4458; CHECK-NEXT:    vmv1r.v v11, v12
4459; CHECK-NEXT:    vmv1r.v v12, v13
4460; CHECK-NEXT:    vmv1r.v v13, v14
4461; CHECK-NEXT:    vmv1r.v v14, v15
4462; CHECK-NEXT:    vlseg8e16ff.v v7, (a0), v0.t
4463; CHECK-NEXT:    csrr a0, vl
4464; CHECK-NEXT:    sw a0, 0(a2)
4465; CHECK-NEXT:    ret
4466entry:
4467  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} @llvm.riscv.vlseg8ff.mask.triscv.vector.tuple_nxv4i8_8t.nxv2i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 8) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 4)
4468  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} %0, 0
4469  %2 = call <vscale x 2 x half> @llvm.riscv.tuple.extract.nxv2f16.triscv.vector.tuple_nxv4i8_8t(target("riscv.vector.tuple", <vscale x 4 x i8>, 8) %1, i32 1)
4470  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} %0, 1
4471  store i32 %3, ptr %outvl
4472  ret <vscale x 2 x half> %2
4473}
4474
4475
4476define <vscale x 4 x half> @test_vlseg8ff_nxv4f16_triscv.vector.tuple_nxv8i8_8t(ptr %base, i32 %vl, ptr %outvl) {
4477; CHECK-LABEL: test_vlseg8ff_nxv4f16_triscv.vector.tuple_nxv8i8_8t:
4478; CHECK:       # %bb.0: # %entry
4479; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, ma
4480; CHECK-NEXT:    vlseg8e16ff.v v7, (a0)
4481; CHECK-NEXT:    csrr a0, vl
4482; CHECK-NEXT:    sw a0, 0(a2)
4483; CHECK-NEXT:    ret
4484entry:
4485  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} @llvm.riscv.vlseg8ff.triscv.vector.tuple_nxv8i8_8t(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) undef, ptr %base, i32 %vl, i32 4)
4486  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} %0, 0
4487  %2 = call <vscale x 4 x half> @llvm.riscv.tuple.extract.nxv4f16.triscv.vector.tuple_nxv8i8_8t(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) %1, i32 1)
4488  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} %0, 1
4489  store i32 %3, ptr %outvl
4490  ret <vscale x 4 x half> %2
4491}
4492
4493define <vscale x 4 x half> @test_vlseg8ff_mask_nxv4f16_triscv.vector.tuple_nxv8i8_8t(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) %val, ptr %base, i32 %vl, <vscale x 4 x i1> %mask, ptr %outvl) {
4494; CHECK-LABEL: test_vlseg8ff_mask_nxv4f16_triscv.vector.tuple_nxv8i8_8t:
4495; CHECK:       # %bb.0: # %entry
4496; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, mu
4497; CHECK-NEXT:    vmv1r.v v7, v8
4498; CHECK-NEXT:    vmv1r.v v8, v9
4499; CHECK-NEXT:    vmv1r.v v9, v10
4500; CHECK-NEXT:    vmv1r.v v10, v11
4501; CHECK-NEXT:    vmv1r.v v11, v12
4502; CHECK-NEXT:    vmv1r.v v12, v13
4503; CHECK-NEXT:    vmv1r.v v13, v14
4504; CHECK-NEXT:    vmv1r.v v14, v15
4505; CHECK-NEXT:    vlseg8e16ff.v v7, (a0), v0.t
4506; CHECK-NEXT:    csrr a0, vl
4507; CHECK-NEXT:    sw a0, 0(a2)
4508; CHECK-NEXT:    ret
4509entry:
4510  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} @llvm.riscv.vlseg8ff.mask.triscv.vector.tuple_nxv8i8_8t.nxv4i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) %val, ptr %base, <vscale x 4 x i1> %mask, i32 %vl, i32 1, i32 4)
4511  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} %0, 0
4512  %2 = call <vscale x 4 x half> @llvm.riscv.tuple.extract.nxv4f16.triscv.vector.tuple_nxv8i8_8t(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) %1, i32 1)
4513  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} %0, 1
4514  store i32 %3, ptr %outvl
4515  ret <vscale x 4 x half> %2
4516}
4517
4518
4519define <vscale x 1 x float> @test_vlseg2ff_nxv1f32_triscv.vector.tuple_nxv4i8_2t(ptr %base, i32 %vl, ptr %outvl) {
4520; CHECK-LABEL: test_vlseg2ff_nxv1f32_triscv.vector.tuple_nxv4i8_2t:
4521; CHECK:       # %bb.0: # %entry
4522; CHECK-NEXT:    vsetvli zero, a1, e32, mf2, ta, ma
4523; CHECK-NEXT:    vlseg2e32ff.v v7, (a0)
4524; CHECK-NEXT:    csrr a0, vl
4525; CHECK-NEXT:    sw a0, 0(a2)
4526; CHECK-NEXT:    ret
4527entry:
4528  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv4i8_2t(target("riscv.vector.tuple", <vscale x 4 x i8>, 2) undef, ptr %base, i32 %vl, i32 5)
4529  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} %0, 0
4530  %2 = call <vscale x 1 x float> @llvm.riscv.tuple.extract.nxv1f32.triscv.vector.tuple_nxv4i8_2t(target("riscv.vector.tuple", <vscale x 4 x i8>, 2) %1, i32 1)
4531  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} %0, 1
4532  store i32 %3, ptr %outvl
4533  ret <vscale x 1 x float> %2
4534}
4535
4536define <vscale x 1 x float> @test_vlseg2ff_mask_nxv1f32_triscv.vector.tuple_nxv4i8_2t(target("riscv.vector.tuple", <vscale x 4 x i8>, 2) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
4537; CHECK-LABEL: test_vlseg2ff_mask_nxv1f32_triscv.vector.tuple_nxv4i8_2t:
4538; CHECK:       # %bb.0: # %entry
4539; CHECK-NEXT:    vsetvli zero, a1, e32, mf2, ta, mu
4540; CHECK-NEXT:    vmv1r.v v7, v8
4541; CHECK-NEXT:    vmv1r.v v8, v9
4542; CHECK-NEXT:    vlseg2e32ff.v v7, (a0), v0.t
4543; CHECK-NEXT:    csrr a0, vl
4544; CHECK-NEXT:    sw a0, 0(a2)
4545; CHECK-NEXT:    ret
4546entry:
4547  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv4i8_2t.nxv1i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 2) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 5)
4548  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} %0, 0
4549  %2 = call <vscale x 1 x float> @llvm.riscv.tuple.extract.nxv1f32.triscv.vector.tuple_nxv4i8_2t(target("riscv.vector.tuple", <vscale x 4 x i8>, 2) %1, i32 1)
4550  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} %0, 1
4551  store i32 %3, ptr %outvl
4552  ret <vscale x 1 x float> %2
4553}
4554
4555
4556define <vscale x 2 x float> @test_vlseg2ff_nxv2f32_triscv.vector.tuple_nxv8i8_2t(ptr %base, i32 %vl, ptr %outvl) {
4557; CHECK-LABEL: test_vlseg2ff_nxv2f32_triscv.vector.tuple_nxv8i8_2t:
4558; CHECK:       # %bb.0: # %entry
4559; CHECK-NEXT:    vsetvli zero, a1, e32, m1, ta, ma
4560; CHECK-NEXT:    vlseg2e32ff.v v7, (a0)
4561; CHECK-NEXT:    csrr a0, vl
4562; CHECK-NEXT:    sw a0, 0(a2)
4563; CHECK-NEXT:    ret
4564entry:
4565  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv8i8_2t(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) undef, ptr %base, i32 %vl, i32 5)
4566  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} %0, 0
4567  %2 = call <vscale x 2 x float> @llvm.riscv.tuple.extract.nxv2f32.triscv.vector.tuple_nxv8i8_2t(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) %1, i32 1)
4568  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} %0, 1
4569  store i32 %3, ptr %outvl
4570  ret <vscale x 2 x float> %2
4571}
4572
4573define <vscale x 2 x float> @test_vlseg2ff_mask_nxv2f32_triscv.vector.tuple_nxv8i8_2t(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
4574; CHECK-LABEL: test_vlseg2ff_mask_nxv2f32_triscv.vector.tuple_nxv8i8_2t:
4575; CHECK:       # %bb.0: # %entry
4576; CHECK-NEXT:    vsetvli zero, a1, e32, m1, ta, mu
4577; CHECK-NEXT:    vmv1r.v v7, v8
4578; CHECK-NEXT:    vmv1r.v v8, v9
4579; CHECK-NEXT:    vlseg2e32ff.v v7, (a0), v0.t
4580; CHECK-NEXT:    csrr a0, vl
4581; CHECK-NEXT:    sw a0, 0(a2)
4582; CHECK-NEXT:    ret
4583entry:
4584  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv8i8_2t.nxv2i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 5)
4585  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} %0, 0
4586  %2 = call <vscale x 2 x float> @llvm.riscv.tuple.extract.nxv2f32.triscv.vector.tuple_nxv8i8_2t(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) %1, i32 1)
4587  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} %0, 1
4588  store i32 %3, ptr %outvl
4589  ret <vscale x 2 x float> %2
4590}
4591
4592
4593define <vscale x 4 x float> @test_vlseg2ff_nxv4f32_triscv.vector.tuple_nxv16i8_2t(ptr %base, i32 %vl, ptr %outvl) {
4594; CHECK-LABEL: test_vlseg2ff_nxv4f32_triscv.vector.tuple_nxv16i8_2t:
4595; CHECK:       # %bb.0: # %entry
4596; CHECK-NEXT:    vsetvli zero, a1, e32, m2, ta, ma
4597; CHECK-NEXT:    vlseg2e32ff.v v6, (a0)
4598; CHECK-NEXT:    csrr a0, vl
4599; CHECK-NEXT:    sw a0, 0(a2)
4600; CHECK-NEXT:    ret
4601entry:
4602  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv16i8_2t(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) undef, ptr %base, i32 %vl, i32 5)
4603  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} %0, 0
4604  %2 = call <vscale x 4 x float> @llvm.riscv.tuple.extract.nxv4f32.triscv.vector.tuple_nxv16i8_2t(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) %1, i32 1)
4605  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} %0, 1
4606  store i32 %3, ptr %outvl
4607  ret <vscale x 4 x float> %2
4608}
4609
4610define <vscale x 4 x float> @test_vlseg2ff_mask_nxv4f32_triscv.vector.tuple_nxv16i8_2t(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) %val, ptr %base, i32 %vl, <vscale x 4 x i1> %mask, ptr %outvl) {
4611; CHECK-LABEL: test_vlseg2ff_mask_nxv4f32_triscv.vector.tuple_nxv16i8_2t:
4612; CHECK:       # %bb.0: # %entry
4613; CHECK-NEXT:    vsetvli zero, a1, e32, m2, ta, mu
4614; CHECK-NEXT:    vmv2r.v v6, v8
4615; CHECK-NEXT:    vmv2r.v v8, v10
4616; CHECK-NEXT:    vlseg2e32ff.v v6, (a0), v0.t
4617; CHECK-NEXT:    csrr a0, vl
4618; CHECK-NEXT:    sw a0, 0(a2)
4619; CHECK-NEXT:    ret
4620entry:
4621  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv16i8_2t.nxv4i1(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) %val, ptr %base, <vscale x 4 x i1> %mask, i32 %vl, i32 1, i32 5)
4622  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} %0, 0
4623  %2 = call <vscale x 4 x float> @llvm.riscv.tuple.extract.nxv4f32.triscv.vector.tuple_nxv16i8_2t(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) %1, i32 1)
4624  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} %0, 1
4625  store i32 %3, ptr %outvl
4626  ret <vscale x 4 x float> %2
4627}
4628
4629
4630define <vscale x 8 x float> @test_vlseg2ff_nxv8f32_triscv.vector.tuple_nxv32i8_2t(ptr %base, i32 %vl, ptr %outvl) {
4631; CHECK-LABEL: test_vlseg2ff_nxv8f32_triscv.vector.tuple_nxv32i8_2t:
4632; CHECK:       # %bb.0: # %entry
4633; CHECK-NEXT:    vsetvli zero, a1, e32, m4, ta, ma
4634; CHECK-NEXT:    vlseg2e32ff.v v4, (a0)
4635; CHECK-NEXT:    csrr a0, vl
4636; CHECK-NEXT:    sw a0, 0(a2)
4637; CHECK-NEXT:    ret
4638entry:
4639  %0 = tail call {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv32i8_2t(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) undef, ptr %base, i32 %vl, i32 5)
4640  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} %0, 0
4641  %2 = call <vscale x 8 x float> @llvm.riscv.tuple.extract.nxv8f32.triscv.vector.tuple_nxv32i8_2t(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) %1, i32 1)
4642  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} %0, 1
4643  store i32 %3, ptr %outvl
4644  ret <vscale x 8 x float> %2
4645}
4646
4647define <vscale x 8 x float> @test_vlseg2ff_mask_nxv8f32_triscv.vector.tuple_nxv32i8_2t(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) %val, ptr %base, i32 %vl, <vscale x 8 x i1> %mask, ptr %outvl) {
4648; CHECK-LABEL: test_vlseg2ff_mask_nxv8f32_triscv.vector.tuple_nxv32i8_2t:
4649; CHECK:       # %bb.0: # %entry
4650; CHECK-NEXT:    vsetvli zero, a1, e32, m4, ta, mu
4651; CHECK-NEXT:    vmv4r.v v4, v8
4652; CHECK-NEXT:    vmv4r.v v8, v12
4653; CHECK-NEXT:    vlseg2e32ff.v v4, (a0), v0.t
4654; CHECK-NEXT:    csrr a0, vl
4655; CHECK-NEXT:    sw a0, 0(a2)
4656; CHECK-NEXT:    ret
4657entry:
4658  %0 = tail call {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv32i8_2t.nxv8i1(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) %val, ptr %base, <vscale x 8 x i1> %mask, i32 %vl, i32 1, i32 5)
4659  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} %0, 0
4660  %2 = call <vscale x 8 x float> @llvm.riscv.tuple.extract.nxv8f32.triscv.vector.tuple_nxv32i8_2t(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) %1, i32 1)
4661  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} %0, 1
4662  store i32 %3, ptr %outvl
4663  ret <vscale x 8 x float> %2
4664}
4665
4666
4667define <vscale x 1 x float> @test_vlseg3ff_nxv1f32_triscv.vector.tuple_nxv4i8_3t(ptr %base, i32 %vl, ptr %outvl) {
4668; CHECK-LABEL: test_vlseg3ff_nxv1f32_triscv.vector.tuple_nxv4i8_3t:
4669; CHECK:       # %bb.0: # %entry
4670; CHECK-NEXT:    vsetvli zero, a1, e32, mf2, ta, ma
4671; CHECK-NEXT:    vlseg3e32ff.v v7, (a0)
4672; CHECK-NEXT:    csrr a0, vl
4673; CHECK-NEXT:    sw a0, 0(a2)
4674; CHECK-NEXT:    ret
4675entry:
4676  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} @llvm.riscv.vlseg3ff.triscv.vector.tuple_nxv4i8_3t(target("riscv.vector.tuple", <vscale x 4 x i8>, 3) undef, ptr %base, i32 %vl, i32 5)
4677  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} %0, 0
4678  %2 = call <vscale x 1 x float> @llvm.riscv.tuple.extract.nxv1f32.triscv.vector.tuple_nxv4i8_3t(target("riscv.vector.tuple", <vscale x 4 x i8>, 3) %1, i32 1)
4679  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} %0, 1
4680  store i32 %3, ptr %outvl
4681  ret <vscale x 1 x float> %2
4682}
4683
4684define <vscale x 1 x float> @test_vlseg3ff_mask_nxv1f32_triscv.vector.tuple_nxv4i8_3t(target("riscv.vector.tuple", <vscale x 4 x i8>, 3) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
4685; CHECK-LABEL: test_vlseg3ff_mask_nxv1f32_triscv.vector.tuple_nxv4i8_3t:
4686; CHECK:       # %bb.0: # %entry
4687; CHECK-NEXT:    vsetvli zero, a1, e32, mf2, ta, mu
4688; CHECK-NEXT:    vmv1r.v v7, v8
4689; CHECK-NEXT:    vmv1r.v v8, v9
4690; CHECK-NEXT:    vmv1r.v v9, v10
4691; CHECK-NEXT:    vlseg3e32ff.v v7, (a0), v0.t
4692; CHECK-NEXT:    csrr a0, vl
4693; CHECK-NEXT:    sw a0, 0(a2)
4694; CHECK-NEXT:    ret
4695entry:
4696  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv4i8_3t.nxv1i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 3) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 5)
4697  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} %0, 0
4698  %2 = call <vscale x 1 x float> @llvm.riscv.tuple.extract.nxv1f32.triscv.vector.tuple_nxv4i8_3t(target("riscv.vector.tuple", <vscale x 4 x i8>, 3) %1, i32 1)
4699  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} %0, 1
4700  store i32 %3, ptr %outvl
4701  ret <vscale x 1 x float> %2
4702}
4703
4704
4705define <vscale x 2 x float> @test_vlseg3ff_nxv2f32_triscv.vector.tuple_nxv8i8_3t(ptr %base, i32 %vl, ptr %outvl) {
4706; CHECK-LABEL: test_vlseg3ff_nxv2f32_triscv.vector.tuple_nxv8i8_3t:
4707; CHECK:       # %bb.0: # %entry
4708; CHECK-NEXT:    vsetvli zero, a1, e32, m1, ta, ma
4709; CHECK-NEXT:    vlseg3e32ff.v v7, (a0)
4710; CHECK-NEXT:    csrr a0, vl
4711; CHECK-NEXT:    sw a0, 0(a2)
4712; CHECK-NEXT:    ret
4713entry:
4714  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} @llvm.riscv.vlseg3ff.triscv.vector.tuple_nxv8i8_3t(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) undef, ptr %base, i32 %vl, i32 5)
4715  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} %0, 0
4716  %2 = call <vscale x 2 x float> @llvm.riscv.tuple.extract.nxv2f32.triscv.vector.tuple_nxv8i8_3t(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) %1, i32 1)
4717  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} %0, 1
4718  store i32 %3, ptr %outvl
4719  ret <vscale x 2 x float> %2
4720}
4721
4722define <vscale x 2 x float> @test_vlseg3ff_mask_nxv2f32_triscv.vector.tuple_nxv8i8_3t(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
4723; CHECK-LABEL: test_vlseg3ff_mask_nxv2f32_triscv.vector.tuple_nxv8i8_3t:
4724; CHECK:       # %bb.0: # %entry
4725; CHECK-NEXT:    vsetvli zero, a1, e32, m1, ta, mu
4726; CHECK-NEXT:    vmv1r.v v7, v8
4727; CHECK-NEXT:    vmv1r.v v8, v9
4728; CHECK-NEXT:    vmv1r.v v9, v10
4729; CHECK-NEXT:    vlseg3e32ff.v v7, (a0), v0.t
4730; CHECK-NEXT:    csrr a0, vl
4731; CHECK-NEXT:    sw a0, 0(a2)
4732; CHECK-NEXT:    ret
4733entry:
4734  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv8i8_3t.nxv2i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 5)
4735  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} %0, 0
4736  %2 = call <vscale x 2 x float> @llvm.riscv.tuple.extract.nxv2f32.triscv.vector.tuple_nxv8i8_3t(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) %1, i32 1)
4737  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} %0, 1
4738  store i32 %3, ptr %outvl
4739  ret <vscale x 2 x float> %2
4740}
4741
4742
4743define <vscale x 4 x float> @test_vlseg3ff_nxv4f32_triscv.vector.tuple_nxv16i8_3t(ptr %base, i32 %vl, ptr %outvl) {
4744; CHECK-LABEL: test_vlseg3ff_nxv4f32_triscv.vector.tuple_nxv16i8_3t:
4745; CHECK:       # %bb.0: # %entry
4746; CHECK-NEXT:    vsetvli zero, a1, e32, m2, ta, ma
4747; CHECK-NEXT:    vlseg3e32ff.v v6, (a0)
4748; CHECK-NEXT:    csrr a0, vl
4749; CHECK-NEXT:    sw a0, 0(a2)
4750; CHECK-NEXT:    ret
4751entry:
4752  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} @llvm.riscv.vlseg3ff.triscv.vector.tuple_nxv16i8_3t(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) undef, ptr %base, i32 %vl, i32 5)
4753  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} %0, 0
4754  %2 = call <vscale x 4 x float> @llvm.riscv.tuple.extract.nxv4f32.triscv.vector.tuple_nxv16i8_3t(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) %1, i32 1)
4755  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} %0, 1
4756  store i32 %3, ptr %outvl
4757  ret <vscale x 4 x float> %2
4758}
4759
4760define <vscale x 4 x float> @test_vlseg3ff_mask_nxv4f32_triscv.vector.tuple_nxv16i8_3t(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) %val, ptr %base, i32 %vl, <vscale x 4 x i1> %mask, ptr %outvl) {
4761; CHECK-LABEL: test_vlseg3ff_mask_nxv4f32_triscv.vector.tuple_nxv16i8_3t:
4762; CHECK:       # %bb.0: # %entry
4763; CHECK-NEXT:    vsetvli zero, a1, e32, m2, ta, mu
4764; CHECK-NEXT:    vmv2r.v v6, v8
4765; CHECK-NEXT:    vmv2r.v v8, v10
4766; CHECK-NEXT:    vmv2r.v v10, v12
4767; CHECK-NEXT:    vlseg3e32ff.v v6, (a0), v0.t
4768; CHECK-NEXT:    csrr a0, vl
4769; CHECK-NEXT:    sw a0, 0(a2)
4770; CHECK-NEXT:    ret
4771entry:
4772  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv16i8_3t.nxv4i1(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) %val, ptr %base, <vscale x 4 x i1> %mask, i32 %vl, i32 1, i32 5)
4773  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} %0, 0
4774  %2 = call <vscale x 4 x float> @llvm.riscv.tuple.extract.nxv4f32.triscv.vector.tuple_nxv16i8_3t(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) %1, i32 1)
4775  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} %0, 1
4776  store i32 %3, ptr %outvl
4777  ret <vscale x 4 x float> %2
4778}
4779
4780
4781define <vscale x 1 x float> @test_vlseg4ff_nxv1f32_triscv.vector.tuple_nxv4i8_4t(ptr %base, i32 %vl, ptr %outvl) {
4782; CHECK-LABEL: test_vlseg4ff_nxv1f32_triscv.vector.tuple_nxv4i8_4t:
4783; CHECK:       # %bb.0: # %entry
4784; CHECK-NEXT:    vsetvli zero, a1, e32, mf2, ta, ma
4785; CHECK-NEXT:    vlseg4e32ff.v v7, (a0)
4786; CHECK-NEXT:    csrr a0, vl
4787; CHECK-NEXT:    sw a0, 0(a2)
4788; CHECK-NEXT:    ret
4789entry:
4790  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} @llvm.riscv.vlseg4ff.triscv.vector.tuple_nxv4i8_4t(target("riscv.vector.tuple", <vscale x 4 x i8>, 4) undef, ptr %base, i32 %vl, i32 5)
4791  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} %0, 0
4792  %2 = call <vscale x 1 x float> @llvm.riscv.tuple.extract.nxv1f32.triscv.vector.tuple_nxv4i8_4t(target("riscv.vector.tuple", <vscale x 4 x i8>, 4) %1, i32 1)
4793  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} %0, 1
4794  store i32 %3, ptr %outvl
4795  ret <vscale x 1 x float> %2
4796}
4797
4798define <vscale x 1 x float> @test_vlseg4ff_mask_nxv1f32_triscv.vector.tuple_nxv4i8_4t(target("riscv.vector.tuple", <vscale x 4 x i8>, 4) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
4799; CHECK-LABEL: test_vlseg4ff_mask_nxv1f32_triscv.vector.tuple_nxv4i8_4t:
4800; CHECK:       # %bb.0: # %entry
4801; CHECK-NEXT:    vsetvli zero, a1, e32, mf2, ta, mu
4802; CHECK-NEXT:    vmv1r.v v7, v8
4803; CHECK-NEXT:    vmv1r.v v8, v9
4804; CHECK-NEXT:    vmv1r.v v9, v10
4805; CHECK-NEXT:    vmv1r.v v10, v11
4806; CHECK-NEXT:    vlseg4e32ff.v v7, (a0), v0.t
4807; CHECK-NEXT:    csrr a0, vl
4808; CHECK-NEXT:    sw a0, 0(a2)
4809; CHECK-NEXT:    ret
4810entry:
4811  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv4i8_4t.nxv1i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 4) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 5)
4812  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} %0, 0
4813  %2 = call <vscale x 1 x float> @llvm.riscv.tuple.extract.nxv1f32.triscv.vector.tuple_nxv4i8_4t(target("riscv.vector.tuple", <vscale x 4 x i8>, 4) %1, i32 1)
4814  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} %0, 1
4815  store i32 %3, ptr %outvl
4816  ret <vscale x 1 x float> %2
4817}
4818
4819
4820define <vscale x 2 x float> @test_vlseg4ff_nxv2f32_triscv.vector.tuple_nxv8i8_4t(ptr %base, i32 %vl, ptr %outvl) {
4821; CHECK-LABEL: test_vlseg4ff_nxv2f32_triscv.vector.tuple_nxv8i8_4t:
4822; CHECK:       # %bb.0: # %entry
4823; CHECK-NEXT:    vsetvli zero, a1, e32, m1, ta, ma
4824; CHECK-NEXT:    vlseg4e32ff.v v7, (a0)
4825; CHECK-NEXT:    csrr a0, vl
4826; CHECK-NEXT:    sw a0, 0(a2)
4827; CHECK-NEXT:    ret
4828entry:
4829  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} @llvm.riscv.vlseg4ff.triscv.vector.tuple_nxv8i8_4t(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) undef, ptr %base, i32 %vl, i32 5)
4830  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} %0, 0
4831  %2 = call <vscale x 2 x float> @llvm.riscv.tuple.extract.nxv2f32.triscv.vector.tuple_nxv8i8_4t(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) %1, i32 1)
4832  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} %0, 1
4833  store i32 %3, ptr %outvl
4834  ret <vscale x 2 x float> %2
4835}
4836
4837define <vscale x 2 x float> @test_vlseg4ff_mask_nxv2f32_triscv.vector.tuple_nxv8i8_4t(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
4838; CHECK-LABEL: test_vlseg4ff_mask_nxv2f32_triscv.vector.tuple_nxv8i8_4t:
4839; CHECK:       # %bb.0: # %entry
4840; CHECK-NEXT:    vsetvli zero, a1, e32, m1, ta, mu
4841; CHECK-NEXT:    vmv1r.v v7, v8
4842; CHECK-NEXT:    vmv1r.v v8, v9
4843; CHECK-NEXT:    vmv1r.v v9, v10
4844; CHECK-NEXT:    vmv1r.v v10, v11
4845; CHECK-NEXT:    vlseg4e32ff.v v7, (a0), v0.t
4846; CHECK-NEXT:    csrr a0, vl
4847; CHECK-NEXT:    sw a0, 0(a2)
4848; CHECK-NEXT:    ret
4849entry:
4850  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv8i8_4t.nxv2i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 5)
4851  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} %0, 0
4852  %2 = call <vscale x 2 x float> @llvm.riscv.tuple.extract.nxv2f32.triscv.vector.tuple_nxv8i8_4t(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) %1, i32 1)
4853  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} %0, 1
4854  store i32 %3, ptr %outvl
4855  ret <vscale x 2 x float> %2
4856}
4857
4858
4859define <vscale x 4 x float> @test_vlseg4ff_nxv4f32_triscv.vector.tuple_nxv16i8_4t(ptr %base, i32 %vl, ptr %outvl) {
4860; CHECK-LABEL: test_vlseg4ff_nxv4f32_triscv.vector.tuple_nxv16i8_4t:
4861; CHECK:       # %bb.0: # %entry
4862; CHECK-NEXT:    vsetvli zero, a1, e32, m2, ta, ma
4863; CHECK-NEXT:    vlseg4e32ff.v v6, (a0)
4864; CHECK-NEXT:    csrr a0, vl
4865; CHECK-NEXT:    sw a0, 0(a2)
4866; CHECK-NEXT:    ret
4867entry:
4868  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} @llvm.riscv.vlseg4ff.triscv.vector.tuple_nxv16i8_4t(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) undef, ptr %base, i32 %vl, i32 5)
4869  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} %0, 0
4870  %2 = call <vscale x 4 x float> @llvm.riscv.tuple.extract.nxv4f32.triscv.vector.tuple_nxv16i8_4t(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) %1, i32 1)
4871  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} %0, 1
4872  store i32 %3, ptr %outvl
4873  ret <vscale x 4 x float> %2
4874}
4875
4876define <vscale x 4 x float> @test_vlseg4ff_mask_nxv4f32_triscv.vector.tuple_nxv16i8_4t(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) %val, ptr %base, i32 %vl, <vscale x 4 x i1> %mask, ptr %outvl) {
4877; CHECK-LABEL: test_vlseg4ff_mask_nxv4f32_triscv.vector.tuple_nxv16i8_4t:
4878; CHECK:       # %bb.0: # %entry
4879; CHECK-NEXT:    vsetvli zero, a1, e32, m2, ta, mu
4880; CHECK-NEXT:    vmv2r.v v6, v8
4881; CHECK-NEXT:    vmv2r.v v8, v10
4882; CHECK-NEXT:    vmv2r.v v10, v12
4883; CHECK-NEXT:    vmv2r.v v12, v14
4884; CHECK-NEXT:    vlseg4e32ff.v v6, (a0), v0.t
4885; CHECK-NEXT:    csrr a0, vl
4886; CHECK-NEXT:    sw a0, 0(a2)
4887; CHECK-NEXT:    ret
4888entry:
4889  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv16i8_4t.nxv4i1(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) %val, ptr %base, <vscale x 4 x i1> %mask, i32 %vl, i32 1, i32 5)
4890  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} %0, 0
4891  %2 = call <vscale x 4 x float> @llvm.riscv.tuple.extract.nxv4f32.triscv.vector.tuple_nxv16i8_4t(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) %1, i32 1)
4892  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} %0, 1
4893  store i32 %3, ptr %outvl
4894  ret <vscale x 4 x float> %2
4895}
4896
4897
4898define <vscale x 1 x float> @test_vlseg5ff_nxv1f32_triscv.vector.tuple_nxv4i8_5t(ptr %base, i32 %vl, ptr %outvl) {
4899; CHECK-LABEL: test_vlseg5ff_nxv1f32_triscv.vector.tuple_nxv4i8_5t:
4900; CHECK:       # %bb.0: # %entry
4901; CHECK-NEXT:    vsetvli zero, a1, e32, mf2, ta, ma
4902; CHECK-NEXT:    vlseg5e32ff.v v7, (a0)
4903; CHECK-NEXT:    csrr a0, vl
4904; CHECK-NEXT:    sw a0, 0(a2)
4905; CHECK-NEXT:    ret
4906entry:
4907  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} @llvm.riscv.vlseg5ff.triscv.vector.tuple_nxv4i8_5t(target("riscv.vector.tuple", <vscale x 4 x i8>, 5) undef, ptr %base, i32 %vl, i32 5)
4908  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} %0, 0
4909  %2 = call <vscale x 1 x float> @llvm.riscv.tuple.extract.nxv1f32.triscv.vector.tuple_nxv4i8_5t(target("riscv.vector.tuple", <vscale x 4 x i8>, 5) %1, i32 1)
4910  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} %0, 1
4911  store i32 %3, ptr %outvl
4912  ret <vscale x 1 x float> %2
4913}
4914
4915define <vscale x 1 x float> @test_vlseg5ff_mask_nxv1f32_triscv.vector.tuple_nxv4i8_5t(target("riscv.vector.tuple", <vscale x 4 x i8>, 5) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
4916; CHECK-LABEL: test_vlseg5ff_mask_nxv1f32_triscv.vector.tuple_nxv4i8_5t:
4917; CHECK:       # %bb.0: # %entry
4918; CHECK-NEXT:    vsetvli zero, a1, e32, mf2, ta, mu
4919; CHECK-NEXT:    vmv1r.v v7, v8
4920; CHECK-NEXT:    vmv1r.v v8, v9
4921; CHECK-NEXT:    vmv1r.v v9, v10
4922; CHECK-NEXT:    vmv1r.v v10, v11
4923; CHECK-NEXT:    vmv1r.v v11, v12
4924; CHECK-NEXT:    vlseg5e32ff.v v7, (a0), v0.t
4925; CHECK-NEXT:    csrr a0, vl
4926; CHECK-NEXT:    sw a0, 0(a2)
4927; CHECK-NEXT:    ret
4928entry:
4929  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} @llvm.riscv.vlseg5ff.mask.triscv.vector.tuple_nxv4i8_5t.nxv1i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 5) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 5)
4930  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} %0, 0
4931  %2 = call <vscale x 1 x float> @llvm.riscv.tuple.extract.nxv1f32.triscv.vector.tuple_nxv4i8_5t(target("riscv.vector.tuple", <vscale x 4 x i8>, 5) %1, i32 1)
4932  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} %0, 1
4933  store i32 %3, ptr %outvl
4934  ret <vscale x 1 x float> %2
4935}
4936
4937
4938define <vscale x 2 x float> @test_vlseg5ff_nxv2f32_triscv.vector.tuple_nxv8i8_5t(ptr %base, i32 %vl, ptr %outvl) {
4939; CHECK-LABEL: test_vlseg5ff_nxv2f32_triscv.vector.tuple_nxv8i8_5t:
4940; CHECK:       # %bb.0: # %entry
4941; CHECK-NEXT:    vsetvli zero, a1, e32, m1, ta, ma
4942; CHECK-NEXT:    vlseg5e32ff.v v7, (a0)
4943; CHECK-NEXT:    csrr a0, vl
4944; CHECK-NEXT:    sw a0, 0(a2)
4945; CHECK-NEXT:    ret
4946entry:
4947  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} @llvm.riscv.vlseg5ff.triscv.vector.tuple_nxv8i8_5t(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) undef, ptr %base, i32 %vl, i32 5)
4948  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} %0, 0
4949  %2 = call <vscale x 2 x float> @llvm.riscv.tuple.extract.nxv2f32.triscv.vector.tuple_nxv8i8_5t(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) %1, i32 1)
4950  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} %0, 1
4951  store i32 %3, ptr %outvl
4952  ret <vscale x 2 x float> %2
4953}
4954
4955define <vscale x 2 x float> @test_vlseg5ff_mask_nxv2f32_triscv.vector.tuple_nxv8i8_5t(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
4956; CHECK-LABEL: test_vlseg5ff_mask_nxv2f32_triscv.vector.tuple_nxv8i8_5t:
4957; CHECK:       # %bb.0: # %entry
4958; CHECK-NEXT:    vsetvli zero, a1, e32, m1, ta, mu
4959; CHECK-NEXT:    vmv1r.v v7, v8
4960; CHECK-NEXT:    vmv1r.v v8, v9
4961; CHECK-NEXT:    vmv1r.v v9, v10
4962; CHECK-NEXT:    vmv1r.v v10, v11
4963; CHECK-NEXT:    vmv1r.v v11, v12
4964; CHECK-NEXT:    vlseg5e32ff.v v7, (a0), v0.t
4965; CHECK-NEXT:    csrr a0, vl
4966; CHECK-NEXT:    sw a0, 0(a2)
4967; CHECK-NEXT:    ret
4968entry:
4969  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} @llvm.riscv.vlseg5ff.mask.triscv.vector.tuple_nxv8i8_5t.nxv2i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 5)
4970  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} %0, 0
4971  %2 = call <vscale x 2 x float> @llvm.riscv.tuple.extract.nxv2f32.triscv.vector.tuple_nxv8i8_5t(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) %1, i32 1)
4972  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} %0, 1
4973  store i32 %3, ptr %outvl
4974  ret <vscale x 2 x float> %2
4975}
4976
4977
4978define <vscale x 1 x float> @test_vlseg6ff_nxv1f32_triscv.vector.tuple_nxv4i8_6t(ptr %base, i32 %vl, ptr %outvl) {
4979; CHECK-LABEL: test_vlseg6ff_nxv1f32_triscv.vector.tuple_nxv4i8_6t:
4980; CHECK:       # %bb.0: # %entry
4981; CHECK-NEXT:    vsetvli zero, a1, e32, mf2, ta, ma
4982; CHECK-NEXT:    vlseg6e32ff.v v7, (a0)
4983; CHECK-NEXT:    csrr a0, vl
4984; CHECK-NEXT:    sw a0, 0(a2)
4985; CHECK-NEXT:    ret
4986entry:
4987  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} @llvm.riscv.vlseg6ff.triscv.vector.tuple_nxv4i8_6t(target("riscv.vector.tuple", <vscale x 4 x i8>, 6) undef, ptr %base, i32 %vl, i32 5)
4988  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} %0, 0
4989  %2 = call <vscale x 1 x float> @llvm.riscv.tuple.extract.nxv1f32.triscv.vector.tuple_nxv4i8_6t(target("riscv.vector.tuple", <vscale x 4 x i8>, 6) %1, i32 1)
4990  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} %0, 1
4991  store i32 %3, ptr %outvl
4992  ret <vscale x 1 x float> %2
4993}
4994
4995define <vscale x 1 x float> @test_vlseg6ff_mask_nxv1f32_triscv.vector.tuple_nxv4i8_6t(target("riscv.vector.tuple", <vscale x 4 x i8>, 6) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
4996; CHECK-LABEL: test_vlseg6ff_mask_nxv1f32_triscv.vector.tuple_nxv4i8_6t:
4997; CHECK:       # %bb.0: # %entry
4998; CHECK-NEXT:    vsetvli zero, a1, e32, mf2, ta, mu
4999; CHECK-NEXT:    vmv1r.v v7, v8
5000; CHECK-NEXT:    vmv1r.v v8, v9
5001; CHECK-NEXT:    vmv1r.v v9, v10
5002; CHECK-NEXT:    vmv1r.v v10, v11
5003; CHECK-NEXT:    vmv1r.v v11, v12
5004; CHECK-NEXT:    vmv1r.v v12, v13
5005; CHECK-NEXT:    vlseg6e32ff.v v7, (a0), v0.t
5006; CHECK-NEXT:    csrr a0, vl
5007; CHECK-NEXT:    sw a0, 0(a2)
5008; CHECK-NEXT:    ret
5009entry:
5010  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} @llvm.riscv.vlseg6ff.mask.triscv.vector.tuple_nxv4i8_6t.nxv1i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 6) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 5)
5011  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} %0, 0
5012  %2 = call <vscale x 1 x float> @llvm.riscv.tuple.extract.nxv1f32.triscv.vector.tuple_nxv4i8_6t(target("riscv.vector.tuple", <vscale x 4 x i8>, 6) %1, i32 1)
5013  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} %0, 1
5014  store i32 %3, ptr %outvl
5015  ret <vscale x 1 x float> %2
5016}
5017
5018
5019define <vscale x 2 x float> @test_vlseg6ff_nxv2f32_triscv.vector.tuple_nxv8i8_6t(ptr %base, i32 %vl, ptr %outvl) {
5020; CHECK-LABEL: test_vlseg6ff_nxv2f32_triscv.vector.tuple_nxv8i8_6t:
5021; CHECK:       # %bb.0: # %entry
5022; CHECK-NEXT:    vsetvli zero, a1, e32, m1, ta, ma
5023; CHECK-NEXT:    vlseg6e32ff.v v7, (a0)
5024; CHECK-NEXT:    csrr a0, vl
5025; CHECK-NEXT:    sw a0, 0(a2)
5026; CHECK-NEXT:    ret
5027entry:
5028  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} @llvm.riscv.vlseg6ff.triscv.vector.tuple_nxv8i8_6t(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) undef, ptr %base, i32 %vl, i32 5)
5029  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} %0, 0
5030  %2 = call <vscale x 2 x float> @llvm.riscv.tuple.extract.nxv2f32.triscv.vector.tuple_nxv8i8_6t(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) %1, i32 1)
5031  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} %0, 1
5032  store i32 %3, ptr %outvl
5033  ret <vscale x 2 x float> %2
5034}
5035
5036define <vscale x 2 x float> @test_vlseg6ff_mask_nxv2f32_triscv.vector.tuple_nxv8i8_6t(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
5037; CHECK-LABEL: test_vlseg6ff_mask_nxv2f32_triscv.vector.tuple_nxv8i8_6t:
5038; CHECK:       # %bb.0: # %entry
5039; CHECK-NEXT:    vsetvli zero, a1, e32, m1, ta, mu
5040; CHECK-NEXT:    vmv1r.v v7, v8
5041; CHECK-NEXT:    vmv1r.v v8, v9
5042; CHECK-NEXT:    vmv1r.v v9, v10
5043; CHECK-NEXT:    vmv1r.v v10, v11
5044; CHECK-NEXT:    vmv1r.v v11, v12
5045; CHECK-NEXT:    vmv1r.v v12, v13
5046; CHECK-NEXT:    vlseg6e32ff.v v7, (a0), v0.t
5047; CHECK-NEXT:    csrr a0, vl
5048; CHECK-NEXT:    sw a0, 0(a2)
5049; CHECK-NEXT:    ret
5050entry:
5051  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} @llvm.riscv.vlseg6ff.mask.triscv.vector.tuple_nxv8i8_6t.nxv2i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 5)
5052  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} %0, 0
5053  %2 = call <vscale x 2 x float> @llvm.riscv.tuple.extract.nxv2f32.triscv.vector.tuple_nxv8i8_6t(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) %1, i32 1)
5054  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} %0, 1
5055  store i32 %3, ptr %outvl
5056  ret <vscale x 2 x float> %2
5057}
5058
5059
5060define <vscale x 1 x float> @test_vlseg7ff_nxv1f32_triscv.vector.tuple_nxv4i8_7t(ptr %base, i32 %vl, ptr %outvl) {
5061; CHECK-LABEL: test_vlseg7ff_nxv1f32_triscv.vector.tuple_nxv4i8_7t:
5062; CHECK:       # %bb.0: # %entry
5063; CHECK-NEXT:    vsetvli zero, a1, e32, mf2, ta, ma
5064; CHECK-NEXT:    vlseg7e32ff.v v7, (a0)
5065; CHECK-NEXT:    csrr a0, vl
5066; CHECK-NEXT:    sw a0, 0(a2)
5067; CHECK-NEXT:    ret
5068entry:
5069  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} @llvm.riscv.vlseg7ff.triscv.vector.tuple_nxv4i8_7t(target("riscv.vector.tuple", <vscale x 4 x i8>, 7) undef, ptr %base, i32 %vl, i32 5)
5070  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} %0, 0
5071  %2 = call <vscale x 1 x float> @llvm.riscv.tuple.extract.nxv1f32.triscv.vector.tuple_nxv4i8_7t(target("riscv.vector.tuple", <vscale x 4 x i8>, 7) %1, i32 1)
5072  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} %0, 1
5073  store i32 %3, ptr %outvl
5074  ret <vscale x 1 x float> %2
5075}
5076
5077define <vscale x 1 x float> @test_vlseg7ff_mask_nxv1f32_triscv.vector.tuple_nxv4i8_7t(target("riscv.vector.tuple", <vscale x 4 x i8>, 7) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
5078; CHECK-LABEL: test_vlseg7ff_mask_nxv1f32_triscv.vector.tuple_nxv4i8_7t:
5079; CHECK:       # %bb.0: # %entry
5080; CHECK-NEXT:    vsetvli zero, a1, e32, mf2, ta, mu
5081; CHECK-NEXT:    vmv1r.v v7, v8
5082; CHECK-NEXT:    vmv1r.v v8, v9
5083; CHECK-NEXT:    vmv1r.v v9, v10
5084; CHECK-NEXT:    vmv1r.v v10, v11
5085; CHECK-NEXT:    vmv1r.v v11, v12
5086; CHECK-NEXT:    vmv1r.v v12, v13
5087; CHECK-NEXT:    vmv1r.v v13, v14
5088; CHECK-NEXT:    vlseg7e32ff.v v7, (a0), v0.t
5089; CHECK-NEXT:    csrr a0, vl
5090; CHECK-NEXT:    sw a0, 0(a2)
5091; CHECK-NEXT:    ret
5092entry:
5093  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} @llvm.riscv.vlseg7ff.mask.triscv.vector.tuple_nxv4i8_7t.nxv1i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 7) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 5)
5094  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} %0, 0
5095  %2 = call <vscale x 1 x float> @llvm.riscv.tuple.extract.nxv1f32.triscv.vector.tuple_nxv4i8_7t(target("riscv.vector.tuple", <vscale x 4 x i8>, 7) %1, i32 1)
5096  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} %0, 1
5097  store i32 %3, ptr %outvl
5098  ret <vscale x 1 x float> %2
5099}
5100
5101
5102define <vscale x 2 x float> @test_vlseg7ff_nxv2f32_triscv.vector.tuple_nxv8i8_7t(ptr %base, i32 %vl, ptr %outvl) {
5103; CHECK-LABEL: test_vlseg7ff_nxv2f32_triscv.vector.tuple_nxv8i8_7t:
5104; CHECK:       # %bb.0: # %entry
5105; CHECK-NEXT:    vsetvli zero, a1, e32, m1, ta, ma
5106; CHECK-NEXT:    vlseg7e32ff.v v7, (a0)
5107; CHECK-NEXT:    csrr a0, vl
5108; CHECK-NEXT:    sw a0, 0(a2)
5109; CHECK-NEXT:    ret
5110entry:
5111  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} @llvm.riscv.vlseg7ff.triscv.vector.tuple_nxv8i8_7t(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) undef, ptr %base, i32 %vl, i32 5)
5112  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} %0, 0
5113  %2 = call <vscale x 2 x float> @llvm.riscv.tuple.extract.nxv2f32.triscv.vector.tuple_nxv8i8_7t(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) %1, i32 1)
5114  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} %0, 1
5115  store i32 %3, ptr %outvl
5116  ret <vscale x 2 x float> %2
5117}
5118
5119define <vscale x 2 x float> @test_vlseg7ff_mask_nxv2f32_triscv.vector.tuple_nxv8i8_7t(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
5120; CHECK-LABEL: test_vlseg7ff_mask_nxv2f32_triscv.vector.tuple_nxv8i8_7t:
5121; CHECK:       # %bb.0: # %entry
5122; CHECK-NEXT:    vsetvli zero, a1, e32, m1, ta, mu
5123; CHECK-NEXT:    vmv1r.v v7, v8
5124; CHECK-NEXT:    vmv1r.v v8, v9
5125; CHECK-NEXT:    vmv1r.v v9, v10
5126; CHECK-NEXT:    vmv1r.v v10, v11
5127; CHECK-NEXT:    vmv1r.v v11, v12
5128; CHECK-NEXT:    vmv1r.v v12, v13
5129; CHECK-NEXT:    vmv1r.v v13, v14
5130; CHECK-NEXT:    vlseg7e32ff.v v7, (a0), v0.t
5131; CHECK-NEXT:    csrr a0, vl
5132; CHECK-NEXT:    sw a0, 0(a2)
5133; CHECK-NEXT:    ret
5134entry:
5135  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} @llvm.riscv.vlseg7ff.mask.triscv.vector.tuple_nxv8i8_7t.nxv2i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 5)
5136  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} %0, 0
5137  %2 = call <vscale x 2 x float> @llvm.riscv.tuple.extract.nxv2f32.triscv.vector.tuple_nxv8i8_7t(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) %1, i32 1)
5138  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} %0, 1
5139  store i32 %3, ptr %outvl
5140  ret <vscale x 2 x float> %2
5141}
5142
5143
5144define <vscale x 1 x float> @test_vlseg8ff_nxv1f32_triscv.vector.tuple_nxv4i8_8t(ptr %base, i32 %vl, ptr %outvl) {
5145; CHECK-LABEL: test_vlseg8ff_nxv1f32_triscv.vector.tuple_nxv4i8_8t:
5146; CHECK:       # %bb.0: # %entry
5147; CHECK-NEXT:    vsetvli zero, a1, e32, mf2, ta, ma
5148; CHECK-NEXT:    vlseg8e32ff.v v7, (a0)
5149; CHECK-NEXT:    csrr a0, vl
5150; CHECK-NEXT:    sw a0, 0(a2)
5151; CHECK-NEXT:    ret
5152entry:
5153  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} @llvm.riscv.vlseg8ff.triscv.vector.tuple_nxv4i8_8t(target("riscv.vector.tuple", <vscale x 4 x i8>, 8) undef, ptr %base, i32 %vl, i32 5)
5154  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} %0, 0
5155  %2 = call <vscale x 1 x float> @llvm.riscv.tuple.extract.nxv1f32.triscv.vector.tuple_nxv4i8_8t(target("riscv.vector.tuple", <vscale x 4 x i8>, 8) %1, i32 1)
5156  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} %0, 1
5157  store i32 %3, ptr %outvl
5158  ret <vscale x 1 x float> %2
5159}
5160
5161define <vscale x 1 x float> @test_vlseg8ff_mask_nxv1f32_triscv.vector.tuple_nxv4i8_8t(target("riscv.vector.tuple", <vscale x 4 x i8>, 8) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
5162; CHECK-LABEL: test_vlseg8ff_mask_nxv1f32_triscv.vector.tuple_nxv4i8_8t:
5163; CHECK:       # %bb.0: # %entry
5164; CHECK-NEXT:    vsetvli zero, a1, e32, mf2, ta, mu
5165; CHECK-NEXT:    vmv1r.v v7, v8
5166; CHECK-NEXT:    vmv1r.v v8, v9
5167; CHECK-NEXT:    vmv1r.v v9, v10
5168; CHECK-NEXT:    vmv1r.v v10, v11
5169; CHECK-NEXT:    vmv1r.v v11, v12
5170; CHECK-NEXT:    vmv1r.v v12, v13
5171; CHECK-NEXT:    vmv1r.v v13, v14
5172; CHECK-NEXT:    vmv1r.v v14, v15
5173; CHECK-NEXT:    vlseg8e32ff.v v7, (a0), v0.t
5174; CHECK-NEXT:    csrr a0, vl
5175; CHECK-NEXT:    sw a0, 0(a2)
5176; CHECK-NEXT:    ret
5177entry:
5178  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} @llvm.riscv.vlseg8ff.mask.triscv.vector.tuple_nxv4i8_8t.nxv1i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 8) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 5)
5179  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} %0, 0
5180  %2 = call <vscale x 1 x float> @llvm.riscv.tuple.extract.nxv1f32.triscv.vector.tuple_nxv4i8_8t(target("riscv.vector.tuple", <vscale x 4 x i8>, 8) %1, i32 1)
5181  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} %0, 1
5182  store i32 %3, ptr %outvl
5183  ret <vscale x 1 x float> %2
5184}
5185
5186
5187define <vscale x 2 x float> @test_vlseg8ff_nxv2f32_triscv.vector.tuple_nxv8i8_8t(ptr %base, i32 %vl, ptr %outvl) {
5188; CHECK-LABEL: test_vlseg8ff_nxv2f32_triscv.vector.tuple_nxv8i8_8t:
5189; CHECK:       # %bb.0: # %entry
5190; CHECK-NEXT:    vsetvli zero, a1, e32, m1, ta, ma
5191; CHECK-NEXT:    vlseg8e32ff.v v7, (a0)
5192; CHECK-NEXT:    csrr a0, vl
5193; CHECK-NEXT:    sw a0, 0(a2)
5194; CHECK-NEXT:    ret
5195entry:
5196  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} @llvm.riscv.vlseg8ff.triscv.vector.tuple_nxv8i8_8t(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) undef, ptr %base, i32 %vl, i32 5)
5197  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} %0, 0
5198  %2 = call <vscale x 2 x float> @llvm.riscv.tuple.extract.nxv2f32.triscv.vector.tuple_nxv8i8_8t(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) %1, i32 1)
5199  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} %0, 1
5200  store i32 %3, ptr %outvl
5201  ret <vscale x 2 x float> %2
5202}
5203
5204define <vscale x 2 x float> @test_vlseg8ff_mask_nxv2f32_triscv.vector.tuple_nxv8i8_8t(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
5205; CHECK-LABEL: test_vlseg8ff_mask_nxv2f32_triscv.vector.tuple_nxv8i8_8t:
5206; CHECK:       # %bb.0: # %entry
5207; CHECK-NEXT:    vsetvli zero, a1, e32, m1, ta, mu
5208; CHECK-NEXT:    vmv1r.v v7, v8
5209; CHECK-NEXT:    vmv1r.v v8, v9
5210; CHECK-NEXT:    vmv1r.v v9, v10
5211; CHECK-NEXT:    vmv1r.v v10, v11
5212; CHECK-NEXT:    vmv1r.v v11, v12
5213; CHECK-NEXT:    vmv1r.v v12, v13
5214; CHECK-NEXT:    vmv1r.v v13, v14
5215; CHECK-NEXT:    vmv1r.v v14, v15
5216; CHECK-NEXT:    vlseg8e32ff.v v7, (a0), v0.t
5217; CHECK-NEXT:    csrr a0, vl
5218; CHECK-NEXT:    sw a0, 0(a2)
5219; CHECK-NEXT:    ret
5220entry:
5221  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} @llvm.riscv.vlseg8ff.mask.triscv.vector.tuple_nxv8i8_8t.nxv2i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 5)
5222  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} %0, 0
5223  %2 = call <vscale x 2 x float> @llvm.riscv.tuple.extract.nxv2f32.triscv.vector.tuple_nxv8i8_8t(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) %1, i32 1)
5224  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} %0, 1
5225  store i32 %3, ptr %outvl
5226  ret <vscale x 2 x float> %2
5227}
5228
5229
5230define <vscale x 1 x double> @test_vlseg2ff_nxv1f64_triscv.vector.tuple_nxv8i8_2t(ptr %base, i32 %vl, ptr %outvl) {
5231; CHECK-LABEL: test_vlseg2ff_nxv1f64_triscv.vector.tuple_nxv8i8_2t:
5232; CHECK:       # %bb.0: # %entry
5233; CHECK-NEXT:    vsetvli zero, a1, e64, m1, ta, ma
5234; CHECK-NEXT:    vlseg2e64ff.v v7, (a0)
5235; CHECK-NEXT:    csrr a0, vl
5236; CHECK-NEXT:    sw a0, 0(a2)
5237; CHECK-NEXT:    ret
5238entry:
5239  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv8i8_2t(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) undef, ptr %base, i32 %vl, i32 6)
5240  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} %0, 0
5241  %2 = call <vscale x 1 x double> @llvm.riscv.tuple.extract.nxv1f64.triscv.vector.tuple_nxv8i8_2t(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) %1, i32 1)
5242  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} %0, 1
5243  store i32 %3, ptr %outvl
5244  ret <vscale x 1 x double> %2
5245}
5246
5247define <vscale x 1 x double> @test_vlseg2ff_mask_nxv1f64_triscv.vector.tuple_nxv8i8_2t(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
5248; CHECK-LABEL: test_vlseg2ff_mask_nxv1f64_triscv.vector.tuple_nxv8i8_2t:
5249; CHECK:       # %bb.0: # %entry
5250; CHECK-NEXT:    vsetvli zero, a1, e64, m1, ta, mu
5251; CHECK-NEXT:    vmv1r.v v7, v8
5252; CHECK-NEXT:    vmv1r.v v8, v9
5253; CHECK-NEXT:    vlseg2e64ff.v v7, (a0), v0.t
5254; CHECK-NEXT:    csrr a0, vl
5255; CHECK-NEXT:    sw a0, 0(a2)
5256; CHECK-NEXT:    ret
5257entry:
5258  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv8i8_2t.nxv1i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 6)
5259  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} %0, 0
5260  %2 = call <vscale x 1 x double> @llvm.riscv.tuple.extract.nxv1f64.triscv.vector.tuple_nxv8i8_2t(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) %1, i32 1)
5261  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} %0, 1
5262  store i32 %3, ptr %outvl
5263  ret <vscale x 1 x double> %2
5264}
5265
5266
5267define <vscale x 2 x double> @test_vlseg2ff_nxv2f64_triscv.vector.tuple_nxv16i8_2t(ptr %base, i32 %vl, ptr %outvl) {
5268; CHECK-LABEL: test_vlseg2ff_nxv2f64_triscv.vector.tuple_nxv16i8_2t:
5269; CHECK:       # %bb.0: # %entry
5270; CHECK-NEXT:    vsetvli zero, a1, e64, m2, ta, ma
5271; CHECK-NEXT:    vlseg2e64ff.v v6, (a0)
5272; CHECK-NEXT:    csrr a0, vl
5273; CHECK-NEXT:    sw a0, 0(a2)
5274; CHECK-NEXT:    ret
5275entry:
5276  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv16i8_2t(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) undef, ptr %base, i32 %vl, i32 6)
5277  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} %0, 0
5278  %2 = call <vscale x 2 x double> @llvm.riscv.tuple.extract.nxv2f64.triscv.vector.tuple_nxv16i8_2t(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) %1, i32 1)
5279  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} %0, 1
5280  store i32 %3, ptr %outvl
5281  ret <vscale x 2 x double> %2
5282}
5283
5284define <vscale x 2 x double> @test_vlseg2ff_mask_nxv2f64_triscv.vector.tuple_nxv16i8_2t(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
5285; CHECK-LABEL: test_vlseg2ff_mask_nxv2f64_triscv.vector.tuple_nxv16i8_2t:
5286; CHECK:       # %bb.0: # %entry
5287; CHECK-NEXT:    vsetvli zero, a1, e64, m2, ta, mu
5288; CHECK-NEXT:    vmv2r.v v6, v8
5289; CHECK-NEXT:    vmv2r.v v8, v10
5290; CHECK-NEXT:    vlseg2e64ff.v v6, (a0), v0.t
5291; CHECK-NEXT:    csrr a0, vl
5292; CHECK-NEXT:    sw a0, 0(a2)
5293; CHECK-NEXT:    ret
5294entry:
5295  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv16i8_2t.nxv2i1(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 6)
5296  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} %0, 0
5297  %2 = call <vscale x 2 x double> @llvm.riscv.tuple.extract.nxv2f64.triscv.vector.tuple_nxv16i8_2t(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) %1, i32 1)
5298  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} %0, 1
5299  store i32 %3, ptr %outvl
5300  ret <vscale x 2 x double> %2
5301}
5302
5303
5304define <vscale x 4 x double> @test_vlseg2ff_nxv4f64_triscv.vector.tuple_nxv32i8_2t(ptr %base, i32 %vl, ptr %outvl) {
5305; CHECK-LABEL: test_vlseg2ff_nxv4f64_triscv.vector.tuple_nxv32i8_2t:
5306; CHECK:       # %bb.0: # %entry
5307; CHECK-NEXT:    vsetvli zero, a1, e64, m4, ta, ma
5308; CHECK-NEXT:    vlseg2e64ff.v v4, (a0)
5309; CHECK-NEXT:    csrr a0, vl
5310; CHECK-NEXT:    sw a0, 0(a2)
5311; CHECK-NEXT:    ret
5312entry:
5313  %0 = tail call {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv32i8_2t(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) undef, ptr %base, i32 %vl, i32 6)
5314  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} %0, 0
5315  %2 = call <vscale x 4 x double> @llvm.riscv.tuple.extract.nxv4f64.triscv.vector.tuple_nxv32i8_2t(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) %1, i32 1)
5316  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} %0, 1
5317  store i32 %3, ptr %outvl
5318  ret <vscale x 4 x double> %2
5319}
5320
5321define <vscale x 4 x double> @test_vlseg2ff_mask_nxv4f64_triscv.vector.tuple_nxv32i8_2t(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) %val, ptr %base, i32 %vl, <vscale x 4 x i1> %mask, ptr %outvl) {
5322; CHECK-LABEL: test_vlseg2ff_mask_nxv4f64_triscv.vector.tuple_nxv32i8_2t:
5323; CHECK:       # %bb.0: # %entry
5324; CHECK-NEXT:    vsetvli zero, a1, e64, m4, ta, mu
5325; CHECK-NEXT:    vmv4r.v v4, v8
5326; CHECK-NEXT:    vmv4r.v v8, v12
5327; CHECK-NEXT:    vlseg2e64ff.v v4, (a0), v0.t
5328; CHECK-NEXT:    csrr a0, vl
5329; CHECK-NEXT:    sw a0, 0(a2)
5330; CHECK-NEXT:    ret
5331entry:
5332  %0 = tail call {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv32i8_2t.nxv4i1(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) %val, ptr %base, <vscale x 4 x i1> %mask, i32 %vl, i32 1, i32 6)
5333  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} %0, 0
5334  %2 = call <vscale x 4 x double> @llvm.riscv.tuple.extract.nxv4f64.triscv.vector.tuple_nxv32i8_2t(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) %1, i32 1)
5335  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} %0, 1
5336  store i32 %3, ptr %outvl
5337  ret <vscale x 4 x double> %2
5338}
5339
5340
5341define <vscale x 1 x double> @test_vlseg3ff_nxv1f64_triscv.vector.tuple_nxv8i8_3t(ptr %base, i32 %vl, ptr %outvl) {
5342; CHECK-LABEL: test_vlseg3ff_nxv1f64_triscv.vector.tuple_nxv8i8_3t:
5343; CHECK:       # %bb.0: # %entry
5344; CHECK-NEXT:    vsetvli zero, a1, e64, m1, ta, ma
5345; CHECK-NEXT:    vlseg3e64ff.v v7, (a0)
5346; CHECK-NEXT:    csrr a0, vl
5347; CHECK-NEXT:    sw a0, 0(a2)
5348; CHECK-NEXT:    ret
5349entry:
5350  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} @llvm.riscv.vlseg3ff.triscv.vector.tuple_nxv8i8_3t(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) undef, ptr %base, i32 %vl, i32 6)
5351  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} %0, 0
5352  %2 = call <vscale x 1 x double> @llvm.riscv.tuple.extract.nxv1f64.triscv.vector.tuple_nxv8i8_3t(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) %1, i32 1)
5353  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} %0, 1
5354  store i32 %3, ptr %outvl
5355  ret <vscale x 1 x double> %2
5356}
5357
5358define <vscale x 1 x double> @test_vlseg3ff_mask_nxv1f64_triscv.vector.tuple_nxv8i8_3t(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
5359; CHECK-LABEL: test_vlseg3ff_mask_nxv1f64_triscv.vector.tuple_nxv8i8_3t:
5360; CHECK:       # %bb.0: # %entry
5361; CHECK-NEXT:    vsetvli zero, a1, e64, m1, ta, mu
5362; CHECK-NEXT:    vmv1r.v v7, v8
5363; CHECK-NEXT:    vmv1r.v v8, v9
5364; CHECK-NEXT:    vmv1r.v v9, v10
5365; CHECK-NEXT:    vlseg3e64ff.v v7, (a0), v0.t
5366; CHECK-NEXT:    csrr a0, vl
5367; CHECK-NEXT:    sw a0, 0(a2)
5368; CHECK-NEXT:    ret
5369entry:
5370  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv8i8_3t.nxv1i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 6)
5371  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} %0, 0
5372  %2 = call <vscale x 1 x double> @llvm.riscv.tuple.extract.nxv1f64.triscv.vector.tuple_nxv8i8_3t(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) %1, i32 1)
5373  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} %0, 1
5374  store i32 %3, ptr %outvl
5375  ret <vscale x 1 x double> %2
5376}
5377
5378
5379define <vscale x 2 x double> @test_vlseg3ff_nxv2f64_triscv.vector.tuple_nxv16i8_3t(ptr %base, i32 %vl, ptr %outvl) {
5380; CHECK-LABEL: test_vlseg3ff_nxv2f64_triscv.vector.tuple_nxv16i8_3t:
5381; CHECK:       # %bb.0: # %entry
5382; CHECK-NEXT:    vsetvli zero, a1, e64, m2, ta, ma
5383; CHECK-NEXT:    vlseg3e64ff.v v6, (a0)
5384; CHECK-NEXT:    csrr a0, vl
5385; CHECK-NEXT:    sw a0, 0(a2)
5386; CHECK-NEXT:    ret
5387entry:
5388  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} @llvm.riscv.vlseg3ff.triscv.vector.tuple_nxv16i8_3t(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) undef, ptr %base, i32 %vl, i32 6)
5389  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} %0, 0
5390  %2 = call <vscale x 2 x double> @llvm.riscv.tuple.extract.nxv2f64.triscv.vector.tuple_nxv16i8_3t(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) %1, i32 1)
5391  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} %0, 1
5392  store i32 %3, ptr %outvl
5393  ret <vscale x 2 x double> %2
5394}
5395
5396define <vscale x 2 x double> @test_vlseg3ff_mask_nxv2f64_triscv.vector.tuple_nxv16i8_3t(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
5397; CHECK-LABEL: test_vlseg3ff_mask_nxv2f64_triscv.vector.tuple_nxv16i8_3t:
5398; CHECK:       # %bb.0: # %entry
5399; CHECK-NEXT:    vsetvli zero, a1, e64, m2, ta, mu
5400; CHECK-NEXT:    vmv2r.v v6, v8
5401; CHECK-NEXT:    vmv2r.v v8, v10
5402; CHECK-NEXT:    vmv2r.v v10, v12
5403; CHECK-NEXT:    vlseg3e64ff.v v6, (a0), v0.t
5404; CHECK-NEXT:    csrr a0, vl
5405; CHECK-NEXT:    sw a0, 0(a2)
5406; CHECK-NEXT:    ret
5407entry:
5408  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv16i8_3t.nxv2i1(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 6)
5409  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} %0, 0
5410  %2 = call <vscale x 2 x double> @llvm.riscv.tuple.extract.nxv2f64.triscv.vector.tuple_nxv16i8_3t(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) %1, i32 1)
5411  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} %0, 1
5412  store i32 %3, ptr %outvl
5413  ret <vscale x 2 x double> %2
5414}
5415
5416
5417define <vscale x 1 x double> @test_vlseg4ff_nxv1f64_triscv.vector.tuple_nxv8i8_4t(ptr %base, i32 %vl, ptr %outvl) {
5418; CHECK-LABEL: test_vlseg4ff_nxv1f64_triscv.vector.tuple_nxv8i8_4t:
5419; CHECK:       # %bb.0: # %entry
5420; CHECK-NEXT:    vsetvli zero, a1, e64, m1, ta, ma
5421; CHECK-NEXT:    vlseg4e64ff.v v7, (a0)
5422; CHECK-NEXT:    csrr a0, vl
5423; CHECK-NEXT:    sw a0, 0(a2)
5424; CHECK-NEXT:    ret
5425entry:
5426  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} @llvm.riscv.vlseg4ff.triscv.vector.tuple_nxv8i8_4t(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) undef, ptr %base, i32 %vl, i32 6)
5427  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} %0, 0
5428  %2 = call <vscale x 1 x double> @llvm.riscv.tuple.extract.nxv1f64.triscv.vector.tuple_nxv8i8_4t(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) %1, i32 1)
5429  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} %0, 1
5430  store i32 %3, ptr %outvl
5431  ret <vscale x 1 x double> %2
5432}
5433
5434define <vscale x 1 x double> @test_vlseg4ff_mask_nxv1f64_triscv.vector.tuple_nxv8i8_4t(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
5435; CHECK-LABEL: test_vlseg4ff_mask_nxv1f64_triscv.vector.tuple_nxv8i8_4t:
5436; CHECK:       # %bb.0: # %entry
5437; CHECK-NEXT:    vsetvli zero, a1, e64, m1, ta, mu
5438; CHECK-NEXT:    vmv1r.v v7, v8
5439; CHECK-NEXT:    vmv1r.v v8, v9
5440; CHECK-NEXT:    vmv1r.v v9, v10
5441; CHECK-NEXT:    vmv1r.v v10, v11
5442; CHECK-NEXT:    vlseg4e64ff.v v7, (a0), v0.t
5443; CHECK-NEXT:    csrr a0, vl
5444; CHECK-NEXT:    sw a0, 0(a2)
5445; CHECK-NEXT:    ret
5446entry:
5447  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv8i8_4t.nxv1i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 6)
5448  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} %0, 0
5449  %2 = call <vscale x 1 x double> @llvm.riscv.tuple.extract.nxv1f64.triscv.vector.tuple_nxv8i8_4t(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) %1, i32 1)
5450  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} %0, 1
5451  store i32 %3, ptr %outvl
5452  ret <vscale x 1 x double> %2
5453}
5454
5455
5456define <vscale x 2 x double> @test_vlseg4ff_nxv2f64_triscv.vector.tuple_nxv16i8_4t(ptr %base, i32 %vl, ptr %outvl) {
5457; CHECK-LABEL: test_vlseg4ff_nxv2f64_triscv.vector.tuple_nxv16i8_4t:
5458; CHECK:       # %bb.0: # %entry
5459; CHECK-NEXT:    vsetvli zero, a1, e64, m2, ta, ma
5460; CHECK-NEXT:    vlseg4e64ff.v v6, (a0)
5461; CHECK-NEXT:    csrr a0, vl
5462; CHECK-NEXT:    sw a0, 0(a2)
5463; CHECK-NEXT:    ret
5464entry:
5465  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} @llvm.riscv.vlseg4ff.triscv.vector.tuple_nxv16i8_4t(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) undef, ptr %base, i32 %vl, i32 6)
5466  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} %0, 0
5467  %2 = call <vscale x 2 x double> @llvm.riscv.tuple.extract.nxv2f64.triscv.vector.tuple_nxv16i8_4t(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) %1, i32 1)
5468  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} %0, 1
5469  store i32 %3, ptr %outvl
5470  ret <vscale x 2 x double> %2
5471}
5472
5473define <vscale x 2 x double> @test_vlseg4ff_mask_nxv2f64_triscv.vector.tuple_nxv16i8_4t(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
5474; CHECK-LABEL: test_vlseg4ff_mask_nxv2f64_triscv.vector.tuple_nxv16i8_4t:
5475; CHECK:       # %bb.0: # %entry
5476; CHECK-NEXT:    vsetvli zero, a1, e64, m2, ta, mu
5477; CHECK-NEXT:    vmv2r.v v6, v8
5478; CHECK-NEXT:    vmv2r.v v8, v10
5479; CHECK-NEXT:    vmv2r.v v10, v12
5480; CHECK-NEXT:    vmv2r.v v12, v14
5481; CHECK-NEXT:    vlseg4e64ff.v v6, (a0), v0.t
5482; CHECK-NEXT:    csrr a0, vl
5483; CHECK-NEXT:    sw a0, 0(a2)
5484; CHECK-NEXT:    ret
5485entry:
5486  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv16i8_4t.nxv2i1(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 6)
5487  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} %0, 0
5488  %2 = call <vscale x 2 x double> @llvm.riscv.tuple.extract.nxv2f64.triscv.vector.tuple_nxv16i8_4t(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) %1, i32 1)
5489  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} %0, 1
5490  store i32 %3, ptr %outvl
5491  ret <vscale x 2 x double> %2
5492}
5493
5494
5495define <vscale x 1 x double> @test_vlseg5ff_nxv1f64_triscv.vector.tuple_nxv8i8_5t(ptr %base, i32 %vl, ptr %outvl) {
5496; CHECK-LABEL: test_vlseg5ff_nxv1f64_triscv.vector.tuple_nxv8i8_5t:
5497; CHECK:       # %bb.0: # %entry
5498; CHECK-NEXT:    vsetvli zero, a1, e64, m1, ta, ma
5499; CHECK-NEXT:    vlseg5e64ff.v v7, (a0)
5500; CHECK-NEXT:    csrr a0, vl
5501; CHECK-NEXT:    sw a0, 0(a2)
5502; CHECK-NEXT:    ret
5503entry:
5504  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} @llvm.riscv.vlseg5ff.triscv.vector.tuple_nxv8i8_5t(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) undef, ptr %base, i32 %vl, i32 6)
5505  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} %0, 0
5506  %2 = call <vscale x 1 x double> @llvm.riscv.tuple.extract.nxv1f64.triscv.vector.tuple_nxv8i8_5t(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) %1, i32 1)
5507  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} %0, 1
5508  store i32 %3, ptr %outvl
5509  ret <vscale x 1 x double> %2
5510}
5511
5512define <vscale x 1 x double> @test_vlseg5ff_mask_nxv1f64_triscv.vector.tuple_nxv8i8_5t(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
5513; CHECK-LABEL: test_vlseg5ff_mask_nxv1f64_triscv.vector.tuple_nxv8i8_5t:
5514; CHECK:       # %bb.0: # %entry
5515; CHECK-NEXT:    vsetvli zero, a1, e64, m1, ta, mu
5516; CHECK-NEXT:    vmv1r.v v7, v8
5517; CHECK-NEXT:    vmv1r.v v8, v9
5518; CHECK-NEXT:    vmv1r.v v9, v10
5519; CHECK-NEXT:    vmv1r.v v10, v11
5520; CHECK-NEXT:    vmv1r.v v11, v12
5521; CHECK-NEXT:    vlseg5e64ff.v v7, (a0), v0.t
5522; CHECK-NEXT:    csrr a0, vl
5523; CHECK-NEXT:    sw a0, 0(a2)
5524; CHECK-NEXT:    ret
5525entry:
5526  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} @llvm.riscv.vlseg5ff.mask.triscv.vector.tuple_nxv8i8_5t.nxv1i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 6)
5527  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} %0, 0
5528  %2 = call <vscale x 1 x double> @llvm.riscv.tuple.extract.nxv1f64.triscv.vector.tuple_nxv8i8_5t(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) %1, i32 1)
5529  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} %0, 1
5530  store i32 %3, ptr %outvl
5531  ret <vscale x 1 x double> %2
5532}
5533
5534
5535define <vscale x 1 x double> @test_vlseg6ff_nxv1f64_triscv.vector.tuple_nxv8i8_6t(ptr %base, i32 %vl, ptr %outvl) {
5536; CHECK-LABEL: test_vlseg6ff_nxv1f64_triscv.vector.tuple_nxv8i8_6t:
5537; CHECK:       # %bb.0: # %entry
5538; CHECK-NEXT:    vsetvli zero, a1, e64, m1, ta, ma
5539; CHECK-NEXT:    vlseg6e64ff.v v7, (a0)
5540; CHECK-NEXT:    csrr a0, vl
5541; CHECK-NEXT:    sw a0, 0(a2)
5542; CHECK-NEXT:    ret
5543entry:
5544  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} @llvm.riscv.vlseg6ff.triscv.vector.tuple_nxv8i8_6t(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) undef, ptr %base, i32 %vl, i32 6)
5545  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} %0, 0
5546  %2 = call <vscale x 1 x double> @llvm.riscv.tuple.extract.nxv1f64.triscv.vector.tuple_nxv8i8_6t(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) %1, i32 1)
5547  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} %0, 1
5548  store i32 %3, ptr %outvl
5549  ret <vscale x 1 x double> %2
5550}
5551
5552define <vscale x 1 x double> @test_vlseg6ff_mask_nxv1f64_triscv.vector.tuple_nxv8i8_6t(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
5553; CHECK-LABEL: test_vlseg6ff_mask_nxv1f64_triscv.vector.tuple_nxv8i8_6t:
5554; CHECK:       # %bb.0: # %entry
5555; CHECK-NEXT:    vsetvli zero, a1, e64, m1, ta, mu
5556; CHECK-NEXT:    vmv1r.v v7, v8
5557; CHECK-NEXT:    vmv1r.v v8, v9
5558; CHECK-NEXT:    vmv1r.v v9, v10
5559; CHECK-NEXT:    vmv1r.v v10, v11
5560; CHECK-NEXT:    vmv1r.v v11, v12
5561; CHECK-NEXT:    vmv1r.v v12, v13
5562; CHECK-NEXT:    vlseg6e64ff.v v7, (a0), v0.t
5563; CHECK-NEXT:    csrr a0, vl
5564; CHECK-NEXT:    sw a0, 0(a2)
5565; CHECK-NEXT:    ret
5566entry:
5567  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} @llvm.riscv.vlseg6ff.mask.triscv.vector.tuple_nxv8i8_6t.nxv1i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 6)
5568  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} %0, 0
5569  %2 = call <vscale x 1 x double> @llvm.riscv.tuple.extract.nxv1f64.triscv.vector.tuple_nxv8i8_6t(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) %1, i32 1)
5570  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} %0, 1
5571  store i32 %3, ptr %outvl
5572  ret <vscale x 1 x double> %2
5573}
5574
5575
5576define <vscale x 1 x double> @test_vlseg7ff_nxv1f64_triscv.vector.tuple_nxv8i8_7t(ptr %base, i32 %vl, ptr %outvl) {
5577; CHECK-LABEL: test_vlseg7ff_nxv1f64_triscv.vector.tuple_nxv8i8_7t:
5578; CHECK:       # %bb.0: # %entry
5579; CHECK-NEXT:    vsetvli zero, a1, e64, m1, ta, ma
5580; CHECK-NEXT:    vlseg7e64ff.v v7, (a0)
5581; CHECK-NEXT:    csrr a0, vl
5582; CHECK-NEXT:    sw a0, 0(a2)
5583; CHECK-NEXT:    ret
5584entry:
5585  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} @llvm.riscv.vlseg7ff.triscv.vector.tuple_nxv8i8_7t(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) undef, ptr %base, i32 %vl, i32 6)
5586  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} %0, 0
5587  %2 = call <vscale x 1 x double> @llvm.riscv.tuple.extract.nxv1f64.triscv.vector.tuple_nxv8i8_7t(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) %1, i32 1)
5588  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} %0, 1
5589  store i32 %3, ptr %outvl
5590  ret <vscale x 1 x double> %2
5591}
5592
5593define <vscale x 1 x double> @test_vlseg7ff_mask_nxv1f64_triscv.vector.tuple_nxv8i8_7t(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
5594; CHECK-LABEL: test_vlseg7ff_mask_nxv1f64_triscv.vector.tuple_nxv8i8_7t:
5595; CHECK:       # %bb.0: # %entry
5596; CHECK-NEXT:    vsetvli zero, a1, e64, m1, ta, mu
5597; CHECK-NEXT:    vmv1r.v v7, v8
5598; CHECK-NEXT:    vmv1r.v v8, v9
5599; CHECK-NEXT:    vmv1r.v v9, v10
5600; CHECK-NEXT:    vmv1r.v v10, v11
5601; CHECK-NEXT:    vmv1r.v v11, v12
5602; CHECK-NEXT:    vmv1r.v v12, v13
5603; CHECK-NEXT:    vmv1r.v v13, v14
5604; CHECK-NEXT:    vlseg7e64ff.v v7, (a0), v0.t
5605; CHECK-NEXT:    csrr a0, vl
5606; CHECK-NEXT:    sw a0, 0(a2)
5607; CHECK-NEXT:    ret
5608entry:
5609  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} @llvm.riscv.vlseg7ff.mask.triscv.vector.tuple_nxv8i8_7t.nxv1i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 6)
5610  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} %0, 0
5611  %2 = call <vscale x 1 x double> @llvm.riscv.tuple.extract.nxv1f64.triscv.vector.tuple_nxv8i8_7t(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) %1, i32 1)
5612  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} %0, 1
5613  store i32 %3, ptr %outvl
5614  ret <vscale x 1 x double> %2
5615}
5616
5617
5618define <vscale x 1 x double> @test_vlseg8ff_nxv1f64_triscv.vector.tuple_nxv8i8_8t(ptr %base, i32 %vl, ptr %outvl) {
5619; CHECK-LABEL: test_vlseg8ff_nxv1f64_triscv.vector.tuple_nxv8i8_8t:
5620; CHECK:       # %bb.0: # %entry
5621; CHECK-NEXT:    vsetvli zero, a1, e64, m1, ta, ma
5622; CHECK-NEXT:    vlseg8e64ff.v v7, (a0)
5623; CHECK-NEXT:    csrr a0, vl
5624; CHECK-NEXT:    sw a0, 0(a2)
5625; CHECK-NEXT:    ret
5626entry:
5627  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} @llvm.riscv.vlseg8ff.triscv.vector.tuple_nxv8i8_8t(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) undef, ptr %base, i32 %vl, i32 6)
5628  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} %0, 0
5629  %2 = call <vscale x 1 x double> @llvm.riscv.tuple.extract.nxv1f64.triscv.vector.tuple_nxv8i8_8t(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) %1, i32 1)
5630  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} %0, 1
5631  store i32 %3, ptr %outvl
5632  ret <vscale x 1 x double> %2
5633}
5634
5635define <vscale x 1 x double> @test_vlseg8ff_mask_nxv1f64_triscv.vector.tuple_nxv8i8_8t(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
5636; CHECK-LABEL: test_vlseg8ff_mask_nxv1f64_triscv.vector.tuple_nxv8i8_8t:
5637; CHECK:       # %bb.0: # %entry
5638; CHECK-NEXT:    vsetvli zero, a1, e64, m1, ta, mu
5639; CHECK-NEXT:    vmv1r.v v7, v8
5640; CHECK-NEXT:    vmv1r.v v8, v9
5641; CHECK-NEXT:    vmv1r.v v9, v10
5642; CHECK-NEXT:    vmv1r.v v10, v11
5643; CHECK-NEXT:    vmv1r.v v11, v12
5644; CHECK-NEXT:    vmv1r.v v12, v13
5645; CHECK-NEXT:    vmv1r.v v13, v14
5646; CHECK-NEXT:    vmv1r.v v14, v15
5647; CHECK-NEXT:    vlseg8e64ff.v v7, (a0), v0.t
5648; CHECK-NEXT:    csrr a0, vl
5649; CHECK-NEXT:    sw a0, 0(a2)
5650; CHECK-NEXT:    ret
5651entry:
5652  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} @llvm.riscv.vlseg8ff.mask.triscv.vector.tuple_nxv8i8_8t.nxv1i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 6)
5653  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} %0, 0
5654  %2 = call <vscale x 1 x double> @llvm.riscv.tuple.extract.nxv1f64.triscv.vector.tuple_nxv8i8_8t(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) %1, i32 1)
5655  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} %0, 1
5656  store i32 %3, ptr %outvl
5657  ret <vscale x 1 x double> %2
5658}
5659
5660
5661define <vscale x 1 x bfloat> @test_vlseg2ff_nxv1bf16_triscv.vector.tuple_nxv2i8_2t(ptr %base, i32 %vl, ptr %outvl) {
5662; CHECK-LABEL: test_vlseg2ff_nxv1bf16_triscv.vector.tuple_nxv2i8_2t:
5663; CHECK:       # %bb.0: # %entry
5664; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, ma
5665; CHECK-NEXT:    vlseg2e16ff.v v7, (a0)
5666; CHECK-NEXT:    csrr a0, vl
5667; CHECK-NEXT:    sw a0, 0(a2)
5668; CHECK-NEXT:    ret
5669entry:
5670  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv2i8_2t(target("riscv.vector.tuple", <vscale x 2 x i8>, 2) undef, ptr %base, i32 %vl, i32 4)
5671  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 2), i32} %0, 0
5672  %2 = call <vscale x 1 x bfloat> @llvm.riscv.tuple.extract.nxv1bf16.triscv.vector.tuple_nxv2i8_2t(target("riscv.vector.tuple", <vscale x 2 x i8>, 2) %1, i32 1)
5673  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 2), i32} %0, 1
5674  store i32 %3, ptr %outvl
5675  ret <vscale x 1 x bfloat> %2
5676}
5677
5678define <vscale x 1 x bfloat> @test_vlseg2ff_mask_nxv1bf16_triscv.vector.tuple_nxv2i8_2t(target("riscv.vector.tuple", <vscale x 2 x i8>, 2) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
5679; CHECK-LABEL: test_vlseg2ff_mask_nxv1bf16_triscv.vector.tuple_nxv2i8_2t:
5680; CHECK:       # %bb.0: # %entry
5681; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, mu
5682; CHECK-NEXT:    vmv1r.v v7, v8
5683; CHECK-NEXT:    vmv1r.v v8, v9
5684; CHECK-NEXT:    vlseg2e16ff.v v7, (a0), v0.t
5685; CHECK-NEXT:    csrr a0, vl
5686; CHECK-NEXT:    sw a0, 0(a2)
5687; CHECK-NEXT:    ret
5688entry:
5689  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv2i8_2t.nxv1i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 2) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 4)
5690  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 2), i32} %0, 0
5691  %2 = call <vscale x 1 x bfloat> @llvm.riscv.tuple.extract.nxv1bf16.triscv.vector.tuple_nxv2i8_2t(target("riscv.vector.tuple", <vscale x 2 x i8>, 2) %1, i32 1)
5692  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 2), i32} %0, 1
5693  store i32 %3, ptr %outvl
5694  ret <vscale x 1 x bfloat> %2
5695}
5696
5697
5698define <vscale x 2 x bfloat> @test_vlseg2ff_nxv2bf16_triscv.vector.tuple_nxv4i8_2t(ptr %base, i32 %vl, ptr %outvl) {
5699; CHECK-LABEL: test_vlseg2ff_nxv2bf16_triscv.vector.tuple_nxv4i8_2t:
5700; CHECK:       # %bb.0: # %entry
5701; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, ma
5702; CHECK-NEXT:    vlseg2e16ff.v v7, (a0)
5703; CHECK-NEXT:    csrr a0, vl
5704; CHECK-NEXT:    sw a0, 0(a2)
5705; CHECK-NEXT:    ret
5706entry:
5707  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv4i8_2t(target("riscv.vector.tuple", <vscale x 4 x i8>, 2) undef, ptr %base, i32 %vl, i32 4)
5708  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} %0, 0
5709  %2 = call <vscale x 2 x bfloat> @llvm.riscv.tuple.extract.nxv2bf16.triscv.vector.tuple_nxv4i8_2t(target("riscv.vector.tuple", <vscale x 4 x i8>, 2) %1, i32 1)
5710  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} %0, 1
5711  store i32 %3, ptr %outvl
5712  ret <vscale x 2 x bfloat> %2
5713}
5714
5715define <vscale x 2 x bfloat> @test_vlseg2ff_mask_nxv2bf16_triscv.vector.tuple_nxv4i8_2t(target("riscv.vector.tuple", <vscale x 4 x i8>, 2) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
5716; CHECK-LABEL: test_vlseg2ff_mask_nxv2bf16_triscv.vector.tuple_nxv4i8_2t:
5717; CHECK:       # %bb.0: # %entry
5718; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, mu
5719; CHECK-NEXT:    vmv1r.v v7, v8
5720; CHECK-NEXT:    vmv1r.v v8, v9
5721; CHECK-NEXT:    vlseg2e16ff.v v7, (a0), v0.t
5722; CHECK-NEXT:    csrr a0, vl
5723; CHECK-NEXT:    sw a0, 0(a2)
5724; CHECK-NEXT:    ret
5725entry:
5726  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv4i8_2t.nxv2i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 2) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 4)
5727  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} %0, 0
5728  %2 = call <vscale x 2 x bfloat> @llvm.riscv.tuple.extract.nxv2bf16.triscv.vector.tuple_nxv4i8_2t(target("riscv.vector.tuple", <vscale x 4 x i8>, 2) %1, i32 1)
5729  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 2), i32} %0, 1
5730  store i32 %3, ptr %outvl
5731  ret <vscale x 2 x bfloat> %2
5732}
5733
5734
5735define <vscale x 4 x bfloat> @test_vlseg2ff_nxv4bf16_triscv.vector.tuple_nxv8i8_2t(ptr %base, i32 %vl, ptr %outvl) {
5736; CHECK-LABEL: test_vlseg2ff_nxv4bf16_triscv.vector.tuple_nxv8i8_2t:
5737; CHECK:       # %bb.0: # %entry
5738; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, ma
5739; CHECK-NEXT:    vlseg2e16ff.v v7, (a0)
5740; CHECK-NEXT:    csrr a0, vl
5741; CHECK-NEXT:    sw a0, 0(a2)
5742; CHECK-NEXT:    ret
5743entry:
5744  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv8i8_2t(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) undef, ptr %base, i32 %vl, i32 4)
5745  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} %0, 0
5746  %2 = call <vscale x 4 x bfloat> @llvm.riscv.tuple.extract.nxv4bf16.triscv.vector.tuple_nxv8i8_2t(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) %1, i32 1)
5747  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} %0, 1
5748  store i32 %3, ptr %outvl
5749  ret <vscale x 4 x bfloat> %2
5750}
5751
5752define <vscale x 4 x bfloat> @test_vlseg2ff_mask_nxv4bf16_triscv.vector.tuple_nxv8i8_2t(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) %val, ptr %base, i32 %vl, <vscale x 4 x i1> %mask, ptr %outvl) {
5753; CHECK-LABEL: test_vlseg2ff_mask_nxv4bf16_triscv.vector.tuple_nxv8i8_2t:
5754; CHECK:       # %bb.0: # %entry
5755; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, mu
5756; CHECK-NEXT:    vmv1r.v v7, v8
5757; CHECK-NEXT:    vmv1r.v v8, v9
5758; CHECK-NEXT:    vlseg2e16ff.v v7, (a0), v0.t
5759; CHECK-NEXT:    csrr a0, vl
5760; CHECK-NEXT:    sw a0, 0(a2)
5761; CHECK-NEXT:    ret
5762entry:
5763  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv8i8_2t.nxv4i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) %val, ptr %base, <vscale x 4 x i1> %mask, i32 %vl, i32 1, i32 4)
5764  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} %0, 0
5765  %2 = call <vscale x 4 x bfloat> @llvm.riscv.tuple.extract.nxv4bf16.triscv.vector.tuple_nxv8i8_2t(target("riscv.vector.tuple", <vscale x 8 x i8>, 2) %1, i32 1)
5766  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 2), i32} %0, 1
5767  store i32 %3, ptr %outvl
5768  ret <vscale x 4 x bfloat> %2
5769}
5770
5771
5772define <vscale x 8 x bfloat> @test_vlseg2ff_nxv8bf16_triscv.vector.tuple_nxv16i8_2t(ptr %base, i32 %vl, ptr %outvl) {
5773; CHECK-LABEL: test_vlseg2ff_nxv8bf16_triscv.vector.tuple_nxv16i8_2t:
5774; CHECK:       # %bb.0: # %entry
5775; CHECK-NEXT:    vsetvli zero, a1, e16, m2, ta, ma
5776; CHECK-NEXT:    vlseg2e16ff.v v6, (a0)
5777; CHECK-NEXT:    csrr a0, vl
5778; CHECK-NEXT:    sw a0, 0(a2)
5779; CHECK-NEXT:    ret
5780entry:
5781  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv16i8_2t(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) undef, ptr %base, i32 %vl, i32 4)
5782  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} %0, 0
5783  %2 = call <vscale x 8 x bfloat> @llvm.riscv.tuple.extract.nxv8bf16.triscv.vector.tuple_nxv16i8_2t(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) %1, i32 1)
5784  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} %0, 1
5785  store i32 %3, ptr %outvl
5786  ret <vscale x 8 x bfloat> %2
5787}
5788
5789define <vscale x 8 x bfloat> @test_vlseg2ff_mask_nxv8bf16_triscv.vector.tuple_nxv16i8_2t(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) %val, ptr %base, i32 %vl, <vscale x 8 x i1> %mask, ptr %outvl) {
5790; CHECK-LABEL: test_vlseg2ff_mask_nxv8bf16_triscv.vector.tuple_nxv16i8_2t:
5791; CHECK:       # %bb.0: # %entry
5792; CHECK-NEXT:    vsetvli zero, a1, e16, m2, ta, mu
5793; CHECK-NEXT:    vmv2r.v v6, v8
5794; CHECK-NEXT:    vmv2r.v v8, v10
5795; CHECK-NEXT:    vlseg2e16ff.v v6, (a0), v0.t
5796; CHECK-NEXT:    csrr a0, vl
5797; CHECK-NEXT:    sw a0, 0(a2)
5798; CHECK-NEXT:    ret
5799entry:
5800  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv16i8_2t.nxv8i1(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) %val, ptr %base, <vscale x 8 x i1> %mask, i32 %vl, i32 1, i32 4)
5801  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} %0, 0
5802  %2 = call <vscale x 8 x bfloat> @llvm.riscv.tuple.extract.nxv8bf16.triscv.vector.tuple_nxv16i8_2t(target("riscv.vector.tuple", <vscale x 16 x i8>, 2) %1, i32 1)
5803  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 2), i32} %0, 1
5804  store i32 %3, ptr %outvl
5805  ret <vscale x 8 x bfloat> %2
5806}
5807
5808
5809define <vscale x 16 x bfloat> @test_vlseg2ff_nxv16bf16_triscv.vector.tuple_nxv32i8_2t(ptr %base, i32 %vl, ptr %outvl) {
5810; CHECK-LABEL: test_vlseg2ff_nxv16bf16_triscv.vector.tuple_nxv32i8_2t:
5811; CHECK:       # %bb.0: # %entry
5812; CHECK-NEXT:    vsetvli zero, a1, e16, m4, ta, ma
5813; CHECK-NEXT:    vlseg2e16ff.v v4, (a0)
5814; CHECK-NEXT:    csrr a0, vl
5815; CHECK-NEXT:    sw a0, 0(a2)
5816; CHECK-NEXT:    ret
5817entry:
5818  %0 = tail call {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} @llvm.riscv.vlseg2ff.triscv.vector.tuple_nxv32i8_2t(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) undef, ptr %base, i32 %vl, i32 4)
5819  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} %0, 0
5820  %2 = call <vscale x 16 x bfloat> @llvm.riscv.tuple.extract.nxv16bf16.triscv.vector.tuple_nxv32i8_2t(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) %1, i32 1)
5821  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} %0, 1
5822  store i32 %3, ptr %outvl
5823  ret <vscale x 16 x bfloat> %2
5824}
5825
5826define <vscale x 16 x bfloat> @test_vlseg2ff_mask_nxv16bf16_triscv.vector.tuple_nxv32i8_2t(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) %val, ptr %base, i32 %vl, <vscale x 16 x i1> %mask, ptr %outvl) {
5827; CHECK-LABEL: test_vlseg2ff_mask_nxv16bf16_triscv.vector.tuple_nxv32i8_2t:
5828; CHECK:       # %bb.0: # %entry
5829; CHECK-NEXT:    vsetvli zero, a1, e16, m4, ta, mu
5830; CHECK-NEXT:    vmv4r.v v4, v8
5831; CHECK-NEXT:    vmv4r.v v8, v12
5832; CHECK-NEXT:    vlseg2e16ff.v v4, (a0), v0.t
5833; CHECK-NEXT:    csrr a0, vl
5834; CHECK-NEXT:    sw a0, 0(a2)
5835; CHECK-NEXT:    ret
5836entry:
5837  %0 = tail call {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} @llvm.riscv.vlseg2ff.mask.triscv.vector.tuple_nxv32i8_2t.nxv16i1(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) %val, ptr %base, <vscale x 16 x i1> %mask, i32 %vl, i32 1, i32 4)
5838  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} %0, 0
5839  %2 = call <vscale x 16 x bfloat> @llvm.riscv.tuple.extract.nxv16bf16.triscv.vector.tuple_nxv32i8_2t(target("riscv.vector.tuple", <vscale x 32 x i8>, 2) %1, i32 1)
5840  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 32 x i8>, 2), i32} %0, 1
5841  store i32 %3, ptr %outvl
5842  ret <vscale x 16 x bfloat> %2
5843}
5844
5845
5846define <vscale x 1 x bfloat> @test_vlseg3ff_nxv1bf16_triscv.vector.tuple_nxv2i8_3t(ptr %base, i32 %vl, ptr %outvl) {
5847; CHECK-LABEL: test_vlseg3ff_nxv1bf16_triscv.vector.tuple_nxv2i8_3t:
5848; CHECK:       # %bb.0: # %entry
5849; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, ma
5850; CHECK-NEXT:    vlseg3e16ff.v v7, (a0)
5851; CHECK-NEXT:    csrr a0, vl
5852; CHECK-NEXT:    sw a0, 0(a2)
5853; CHECK-NEXT:    ret
5854entry:
5855  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 3), i32} @llvm.riscv.vlseg3ff.triscv.vector.tuple_nxv2i8_3t(target("riscv.vector.tuple", <vscale x 2 x i8>, 3) undef, ptr %base, i32 %vl, i32 4)
5856  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 3), i32} %0, 0
5857  %2 = call <vscale x 1 x bfloat> @llvm.riscv.tuple.extract.nxv1bf16.triscv.vector.tuple_nxv2i8_3t(target("riscv.vector.tuple", <vscale x 2 x i8>, 3) %1, i32 1)
5858  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 3), i32} %0, 1
5859  store i32 %3, ptr %outvl
5860  ret <vscale x 1 x bfloat> %2
5861}
5862
5863define <vscale x 1 x bfloat> @test_vlseg3ff_mask_nxv1bf16_triscv.vector.tuple_nxv2i8_3t(target("riscv.vector.tuple", <vscale x 2 x i8>, 3) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
5864; CHECK-LABEL: test_vlseg3ff_mask_nxv1bf16_triscv.vector.tuple_nxv2i8_3t:
5865; CHECK:       # %bb.0: # %entry
5866; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, mu
5867; CHECK-NEXT:    vmv1r.v v7, v8
5868; CHECK-NEXT:    vmv1r.v v8, v9
5869; CHECK-NEXT:    vmv1r.v v9, v10
5870; CHECK-NEXT:    vlseg3e16ff.v v7, (a0), v0.t
5871; CHECK-NEXT:    csrr a0, vl
5872; CHECK-NEXT:    sw a0, 0(a2)
5873; CHECK-NEXT:    ret
5874entry:
5875  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv2i8_3t.nxv1i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 3) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 4)
5876  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 3), i32} %0, 0
5877  %2 = call <vscale x 1 x bfloat> @llvm.riscv.tuple.extract.nxv1bf16.triscv.vector.tuple_nxv2i8_3t(target("riscv.vector.tuple", <vscale x 2 x i8>, 3) %1, i32 1)
5878  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 3), i32} %0, 1
5879  store i32 %3, ptr %outvl
5880  ret <vscale x 1 x bfloat> %2
5881}
5882
5883
5884define <vscale x 2 x bfloat> @test_vlseg3ff_nxv2bf16_triscv.vector.tuple_nxv4i8_3t(ptr %base, i32 %vl, ptr %outvl) {
5885; CHECK-LABEL: test_vlseg3ff_nxv2bf16_triscv.vector.tuple_nxv4i8_3t:
5886; CHECK:       # %bb.0: # %entry
5887; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, ma
5888; CHECK-NEXT:    vlseg3e16ff.v v7, (a0)
5889; CHECK-NEXT:    csrr a0, vl
5890; CHECK-NEXT:    sw a0, 0(a2)
5891; CHECK-NEXT:    ret
5892entry:
5893  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} @llvm.riscv.vlseg3ff.triscv.vector.tuple_nxv4i8_3t(target("riscv.vector.tuple", <vscale x 4 x i8>, 3) undef, ptr %base, i32 %vl, i32 4)
5894  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} %0, 0
5895  %2 = call <vscale x 2 x bfloat> @llvm.riscv.tuple.extract.nxv2bf16.triscv.vector.tuple_nxv4i8_3t(target("riscv.vector.tuple", <vscale x 4 x i8>, 3) %1, i32 1)
5896  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} %0, 1
5897  store i32 %3, ptr %outvl
5898  ret <vscale x 2 x bfloat> %2
5899}
5900
5901define <vscale x 2 x bfloat> @test_vlseg3ff_mask_nxv2bf16_triscv.vector.tuple_nxv4i8_3t(target("riscv.vector.tuple", <vscale x 4 x i8>, 3) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
5902; CHECK-LABEL: test_vlseg3ff_mask_nxv2bf16_triscv.vector.tuple_nxv4i8_3t:
5903; CHECK:       # %bb.0: # %entry
5904; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, mu
5905; CHECK-NEXT:    vmv1r.v v7, v8
5906; CHECK-NEXT:    vmv1r.v v8, v9
5907; CHECK-NEXT:    vmv1r.v v9, v10
5908; CHECK-NEXT:    vlseg3e16ff.v v7, (a0), v0.t
5909; CHECK-NEXT:    csrr a0, vl
5910; CHECK-NEXT:    sw a0, 0(a2)
5911; CHECK-NEXT:    ret
5912entry:
5913  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv4i8_3t.nxv2i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 3) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 4)
5914  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} %0, 0
5915  %2 = call <vscale x 2 x bfloat> @llvm.riscv.tuple.extract.nxv2bf16.triscv.vector.tuple_nxv4i8_3t(target("riscv.vector.tuple", <vscale x 4 x i8>, 3) %1, i32 1)
5916  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 3), i32} %0, 1
5917  store i32 %3, ptr %outvl
5918  ret <vscale x 2 x bfloat> %2
5919}
5920
5921
5922define <vscale x 4 x bfloat> @test_vlseg3ff_nxv4bf16_triscv.vector.tuple_nxv8i8_3t(ptr %base, i32 %vl, ptr %outvl) {
5923; CHECK-LABEL: test_vlseg3ff_nxv4bf16_triscv.vector.tuple_nxv8i8_3t:
5924; CHECK:       # %bb.0: # %entry
5925; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, ma
5926; CHECK-NEXT:    vlseg3e16ff.v v7, (a0)
5927; CHECK-NEXT:    csrr a0, vl
5928; CHECK-NEXT:    sw a0, 0(a2)
5929; CHECK-NEXT:    ret
5930entry:
5931  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} @llvm.riscv.vlseg3ff.triscv.vector.tuple_nxv8i8_3t(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) undef, ptr %base, i32 %vl, i32 4)
5932  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} %0, 0
5933  %2 = call <vscale x 4 x bfloat> @llvm.riscv.tuple.extract.nxv4bf16.triscv.vector.tuple_nxv8i8_3t(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) %1, i32 1)
5934  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} %0, 1
5935  store i32 %3, ptr %outvl
5936  ret <vscale x 4 x bfloat> %2
5937}
5938
5939define <vscale x 4 x bfloat> @test_vlseg3ff_mask_nxv4bf16_triscv.vector.tuple_nxv8i8_3t(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) %val, ptr %base, i32 %vl, <vscale x 4 x i1> %mask, ptr %outvl) {
5940; CHECK-LABEL: test_vlseg3ff_mask_nxv4bf16_triscv.vector.tuple_nxv8i8_3t:
5941; CHECK:       # %bb.0: # %entry
5942; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, mu
5943; CHECK-NEXT:    vmv1r.v v7, v8
5944; CHECK-NEXT:    vmv1r.v v8, v9
5945; CHECK-NEXT:    vmv1r.v v9, v10
5946; CHECK-NEXT:    vlseg3e16ff.v v7, (a0), v0.t
5947; CHECK-NEXT:    csrr a0, vl
5948; CHECK-NEXT:    sw a0, 0(a2)
5949; CHECK-NEXT:    ret
5950entry:
5951  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv8i8_3t.nxv4i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) %val, ptr %base, <vscale x 4 x i1> %mask, i32 %vl, i32 1, i32 4)
5952  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} %0, 0
5953  %2 = call <vscale x 4 x bfloat> @llvm.riscv.tuple.extract.nxv4bf16.triscv.vector.tuple_nxv8i8_3t(target("riscv.vector.tuple", <vscale x 8 x i8>, 3) %1, i32 1)
5954  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 3), i32} %0, 1
5955  store i32 %3, ptr %outvl
5956  ret <vscale x 4 x bfloat> %2
5957}
5958
5959
5960define <vscale x 8 x bfloat> @test_vlseg3ff_nxv8bf16_triscv.vector.tuple_nxv16i8_3t(ptr %base, i32 %vl, ptr %outvl) {
5961; CHECK-LABEL: test_vlseg3ff_nxv8bf16_triscv.vector.tuple_nxv16i8_3t:
5962; CHECK:       # %bb.0: # %entry
5963; CHECK-NEXT:    vsetvli zero, a1, e16, m2, ta, ma
5964; CHECK-NEXT:    vlseg3e16ff.v v6, (a0)
5965; CHECK-NEXT:    csrr a0, vl
5966; CHECK-NEXT:    sw a0, 0(a2)
5967; CHECK-NEXT:    ret
5968entry:
5969  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} @llvm.riscv.vlseg3ff.triscv.vector.tuple_nxv16i8_3t(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) undef, ptr %base, i32 %vl, i32 4)
5970  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} %0, 0
5971  %2 = call <vscale x 8 x bfloat> @llvm.riscv.tuple.extract.nxv8bf16.triscv.vector.tuple_nxv16i8_3t(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) %1, i32 1)
5972  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} %0, 1
5973  store i32 %3, ptr %outvl
5974  ret <vscale x 8 x bfloat> %2
5975}
5976
5977define <vscale x 8 x bfloat> @test_vlseg3ff_mask_nxv8bf16_triscv.vector.tuple_nxv16i8_3t(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) %val, ptr %base, i32 %vl, <vscale x 8 x i1> %mask, ptr %outvl) {
5978; CHECK-LABEL: test_vlseg3ff_mask_nxv8bf16_triscv.vector.tuple_nxv16i8_3t:
5979; CHECK:       # %bb.0: # %entry
5980; CHECK-NEXT:    vsetvli zero, a1, e16, m2, ta, mu
5981; CHECK-NEXT:    vmv2r.v v6, v8
5982; CHECK-NEXT:    vmv2r.v v8, v10
5983; CHECK-NEXT:    vmv2r.v v10, v12
5984; CHECK-NEXT:    vlseg3e16ff.v v6, (a0), v0.t
5985; CHECK-NEXT:    csrr a0, vl
5986; CHECK-NEXT:    sw a0, 0(a2)
5987; CHECK-NEXT:    ret
5988entry:
5989  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} @llvm.riscv.vlseg3ff.mask.triscv.vector.tuple_nxv16i8_3t.nxv8i1(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) %val, ptr %base, <vscale x 8 x i1> %mask, i32 %vl, i32 1, i32 4)
5990  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} %0, 0
5991  %2 = call <vscale x 8 x bfloat> @llvm.riscv.tuple.extract.nxv8bf16.triscv.vector.tuple_nxv16i8_3t(target("riscv.vector.tuple", <vscale x 16 x i8>, 3) %1, i32 1)
5992  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 3), i32} %0, 1
5993  store i32 %3, ptr %outvl
5994  ret <vscale x 8 x bfloat> %2
5995}
5996
5997
5998define <vscale x 1 x bfloat> @test_vlseg4ff_nxv1bf16_triscv.vector.tuple_nxv2i8_4t(ptr %base, i32 %vl, ptr %outvl) {
5999; CHECK-LABEL: test_vlseg4ff_nxv1bf16_triscv.vector.tuple_nxv2i8_4t:
6000; CHECK:       # %bb.0: # %entry
6001; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, ma
6002; CHECK-NEXT:    vlseg4e16ff.v v7, (a0)
6003; CHECK-NEXT:    csrr a0, vl
6004; CHECK-NEXT:    sw a0, 0(a2)
6005; CHECK-NEXT:    ret
6006entry:
6007  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 4), i32} @llvm.riscv.vlseg4ff.triscv.vector.tuple_nxv2i8_4t(target("riscv.vector.tuple", <vscale x 2 x i8>, 4) undef, ptr %base, i32 %vl, i32 4)
6008  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 4), i32} %0, 0
6009  %2 = call <vscale x 1 x bfloat> @llvm.riscv.tuple.extract.nxv1bf16.triscv.vector.tuple_nxv2i8_4t(target("riscv.vector.tuple", <vscale x 2 x i8>, 4) %1, i32 1)
6010  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 4), i32} %0, 1
6011  store i32 %3, ptr %outvl
6012  ret <vscale x 1 x bfloat> %2
6013}
6014
6015define <vscale x 1 x bfloat> @test_vlseg4ff_mask_nxv1bf16_triscv.vector.tuple_nxv2i8_4t(target("riscv.vector.tuple", <vscale x 2 x i8>, 4) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
6016; CHECK-LABEL: test_vlseg4ff_mask_nxv1bf16_triscv.vector.tuple_nxv2i8_4t:
6017; CHECK:       # %bb.0: # %entry
6018; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, mu
6019; CHECK-NEXT:    vmv1r.v v7, v8
6020; CHECK-NEXT:    vmv1r.v v8, v9
6021; CHECK-NEXT:    vmv1r.v v9, v10
6022; CHECK-NEXT:    vmv1r.v v10, v11
6023; CHECK-NEXT:    vlseg4e16ff.v v7, (a0), v0.t
6024; CHECK-NEXT:    csrr a0, vl
6025; CHECK-NEXT:    sw a0, 0(a2)
6026; CHECK-NEXT:    ret
6027entry:
6028  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv2i8_4t.nxv1i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 4) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 4)
6029  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 4), i32} %0, 0
6030  %2 = call <vscale x 1 x bfloat> @llvm.riscv.tuple.extract.nxv1bf16.triscv.vector.tuple_nxv2i8_4t(target("riscv.vector.tuple", <vscale x 2 x i8>, 4) %1, i32 1)
6031  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 4), i32} %0, 1
6032  store i32 %3, ptr %outvl
6033  ret <vscale x 1 x bfloat> %2
6034}
6035
6036
6037define <vscale x 2 x bfloat> @test_vlseg4ff_nxv2bf16_triscv.vector.tuple_nxv4i8_4t(ptr %base, i32 %vl, ptr %outvl) {
6038; CHECK-LABEL: test_vlseg4ff_nxv2bf16_triscv.vector.tuple_nxv4i8_4t:
6039; CHECK:       # %bb.0: # %entry
6040; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, ma
6041; CHECK-NEXT:    vlseg4e16ff.v v7, (a0)
6042; CHECK-NEXT:    csrr a0, vl
6043; CHECK-NEXT:    sw a0, 0(a2)
6044; CHECK-NEXT:    ret
6045entry:
6046  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} @llvm.riscv.vlseg4ff.triscv.vector.tuple_nxv4i8_4t(target("riscv.vector.tuple", <vscale x 4 x i8>, 4) undef, ptr %base, i32 %vl, i32 4)
6047  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} %0, 0
6048  %2 = call <vscale x 2 x bfloat> @llvm.riscv.tuple.extract.nxv2bf16.triscv.vector.tuple_nxv4i8_4t(target("riscv.vector.tuple", <vscale x 4 x i8>, 4) %1, i32 1)
6049  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} %0, 1
6050  store i32 %3, ptr %outvl
6051  ret <vscale x 2 x bfloat> %2
6052}
6053
6054define <vscale x 2 x bfloat> @test_vlseg4ff_mask_nxv2bf16_triscv.vector.tuple_nxv4i8_4t(target("riscv.vector.tuple", <vscale x 4 x i8>, 4) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
6055; CHECK-LABEL: test_vlseg4ff_mask_nxv2bf16_triscv.vector.tuple_nxv4i8_4t:
6056; CHECK:       # %bb.0: # %entry
6057; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, mu
6058; CHECK-NEXT:    vmv1r.v v7, v8
6059; CHECK-NEXT:    vmv1r.v v8, v9
6060; CHECK-NEXT:    vmv1r.v v9, v10
6061; CHECK-NEXT:    vmv1r.v v10, v11
6062; CHECK-NEXT:    vlseg4e16ff.v v7, (a0), v0.t
6063; CHECK-NEXT:    csrr a0, vl
6064; CHECK-NEXT:    sw a0, 0(a2)
6065; CHECK-NEXT:    ret
6066entry:
6067  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv4i8_4t.nxv2i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 4) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 4)
6068  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} %0, 0
6069  %2 = call <vscale x 2 x bfloat> @llvm.riscv.tuple.extract.nxv2bf16.triscv.vector.tuple_nxv4i8_4t(target("riscv.vector.tuple", <vscale x 4 x i8>, 4) %1, i32 1)
6070  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 4), i32} %0, 1
6071  store i32 %3, ptr %outvl
6072  ret <vscale x 2 x bfloat> %2
6073}
6074
6075
6076define <vscale x 4 x bfloat> @test_vlseg4ff_nxv4bf16_triscv.vector.tuple_nxv8i8_4t(ptr %base, i32 %vl, ptr %outvl) {
6077; CHECK-LABEL: test_vlseg4ff_nxv4bf16_triscv.vector.tuple_nxv8i8_4t:
6078; CHECK:       # %bb.0: # %entry
6079; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, ma
6080; CHECK-NEXT:    vlseg4e16ff.v v7, (a0)
6081; CHECK-NEXT:    csrr a0, vl
6082; CHECK-NEXT:    sw a0, 0(a2)
6083; CHECK-NEXT:    ret
6084entry:
6085  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} @llvm.riscv.vlseg4ff.triscv.vector.tuple_nxv8i8_4t(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) undef, ptr %base, i32 %vl, i32 4)
6086  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} %0, 0
6087  %2 = call <vscale x 4 x bfloat> @llvm.riscv.tuple.extract.nxv4bf16.triscv.vector.tuple_nxv8i8_4t(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) %1, i32 1)
6088  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} %0, 1
6089  store i32 %3, ptr %outvl
6090  ret <vscale x 4 x bfloat> %2
6091}
6092
6093define <vscale x 4 x bfloat> @test_vlseg4ff_mask_nxv4bf16_triscv.vector.tuple_nxv8i8_4t(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) %val, ptr %base, i32 %vl, <vscale x 4 x i1> %mask, ptr %outvl) {
6094; CHECK-LABEL: test_vlseg4ff_mask_nxv4bf16_triscv.vector.tuple_nxv8i8_4t:
6095; CHECK:       # %bb.0: # %entry
6096; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, mu
6097; CHECK-NEXT:    vmv1r.v v7, v8
6098; CHECK-NEXT:    vmv1r.v v8, v9
6099; CHECK-NEXT:    vmv1r.v v9, v10
6100; CHECK-NEXT:    vmv1r.v v10, v11
6101; CHECK-NEXT:    vlseg4e16ff.v v7, (a0), v0.t
6102; CHECK-NEXT:    csrr a0, vl
6103; CHECK-NEXT:    sw a0, 0(a2)
6104; CHECK-NEXT:    ret
6105entry:
6106  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv8i8_4t.nxv4i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) %val, ptr %base, <vscale x 4 x i1> %mask, i32 %vl, i32 1, i32 4)
6107  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} %0, 0
6108  %2 = call <vscale x 4 x bfloat> @llvm.riscv.tuple.extract.nxv4bf16.triscv.vector.tuple_nxv8i8_4t(target("riscv.vector.tuple", <vscale x 8 x i8>, 4) %1, i32 1)
6109  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 4), i32} %0, 1
6110  store i32 %3, ptr %outvl
6111  ret <vscale x 4 x bfloat> %2
6112}
6113
6114
6115define <vscale x 8 x bfloat> @test_vlseg4ff_nxv8bf16_triscv.vector.tuple_nxv16i8_4t(ptr %base, i32 %vl, ptr %outvl) {
6116; CHECK-LABEL: test_vlseg4ff_nxv8bf16_triscv.vector.tuple_nxv16i8_4t:
6117; CHECK:       # %bb.0: # %entry
6118; CHECK-NEXT:    vsetvli zero, a1, e16, m2, ta, ma
6119; CHECK-NEXT:    vlseg4e16ff.v v6, (a0)
6120; CHECK-NEXT:    csrr a0, vl
6121; CHECK-NEXT:    sw a0, 0(a2)
6122; CHECK-NEXT:    ret
6123entry:
6124  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} @llvm.riscv.vlseg4ff.triscv.vector.tuple_nxv16i8_4t(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) undef, ptr %base, i32 %vl, i32 4)
6125  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} %0, 0
6126  %2 = call <vscale x 8 x bfloat> @llvm.riscv.tuple.extract.nxv8bf16.triscv.vector.tuple_nxv16i8_4t(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) %1, i32 1)
6127  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} %0, 1
6128  store i32 %3, ptr %outvl
6129  ret <vscale x 8 x bfloat> %2
6130}
6131
6132define <vscale x 8 x bfloat> @test_vlseg4ff_mask_nxv8bf16_triscv.vector.tuple_nxv16i8_4t(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) %val, ptr %base, i32 %vl, <vscale x 8 x i1> %mask, ptr %outvl) {
6133; CHECK-LABEL: test_vlseg4ff_mask_nxv8bf16_triscv.vector.tuple_nxv16i8_4t:
6134; CHECK:       # %bb.0: # %entry
6135; CHECK-NEXT:    vsetvli zero, a1, e16, m2, ta, mu
6136; CHECK-NEXT:    vmv2r.v v6, v8
6137; CHECK-NEXT:    vmv2r.v v8, v10
6138; CHECK-NEXT:    vmv2r.v v10, v12
6139; CHECK-NEXT:    vmv2r.v v12, v14
6140; CHECK-NEXT:    vlseg4e16ff.v v6, (a0), v0.t
6141; CHECK-NEXT:    csrr a0, vl
6142; CHECK-NEXT:    sw a0, 0(a2)
6143; CHECK-NEXT:    ret
6144entry:
6145  %0 = tail call {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} @llvm.riscv.vlseg4ff.mask.triscv.vector.tuple_nxv16i8_4t.nxv8i1(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) %val, ptr %base, <vscale x 8 x i1> %mask, i32 %vl, i32 1, i32 4)
6146  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} %0, 0
6147  %2 = call <vscale x 8 x bfloat> @llvm.riscv.tuple.extract.nxv8bf16.triscv.vector.tuple_nxv16i8_4t(target("riscv.vector.tuple", <vscale x 16 x i8>, 4) %1, i32 1)
6148  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 16 x i8>, 4), i32} %0, 1
6149  store i32 %3, ptr %outvl
6150  ret <vscale x 8 x bfloat> %2
6151}
6152
6153
6154define <vscale x 1 x bfloat> @test_vlseg5ff_nxv1bf16_triscv.vector.tuple_nxv2i8_5t(ptr %base, i32 %vl, ptr %outvl) {
6155; CHECK-LABEL: test_vlseg5ff_nxv1bf16_triscv.vector.tuple_nxv2i8_5t:
6156; CHECK:       # %bb.0: # %entry
6157; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, ma
6158; CHECK-NEXT:    vlseg5e16ff.v v7, (a0)
6159; CHECK-NEXT:    csrr a0, vl
6160; CHECK-NEXT:    sw a0, 0(a2)
6161; CHECK-NEXT:    ret
6162entry:
6163  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 5), i32} @llvm.riscv.vlseg5ff.triscv.vector.tuple_nxv2i8_5t(target("riscv.vector.tuple", <vscale x 2 x i8>, 5) undef, ptr %base, i32 %vl, i32 4)
6164  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 5), i32} %0, 0
6165  %2 = call <vscale x 1 x bfloat> @llvm.riscv.tuple.extract.nxv1bf16.triscv.vector.tuple_nxv2i8_5t(target("riscv.vector.tuple", <vscale x 2 x i8>, 5) %1, i32 1)
6166  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 5), i32} %0, 1
6167  store i32 %3, ptr %outvl
6168  ret <vscale x 1 x bfloat> %2
6169}
6170
6171define <vscale x 1 x bfloat> @test_vlseg5ff_mask_nxv1bf16_triscv.vector.tuple_nxv2i8_5t(target("riscv.vector.tuple", <vscale x 2 x i8>, 5) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
6172; CHECK-LABEL: test_vlseg5ff_mask_nxv1bf16_triscv.vector.tuple_nxv2i8_5t:
6173; CHECK:       # %bb.0: # %entry
6174; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, mu
6175; CHECK-NEXT:    vmv1r.v v7, v8
6176; CHECK-NEXT:    vmv1r.v v8, v9
6177; CHECK-NEXT:    vmv1r.v v9, v10
6178; CHECK-NEXT:    vmv1r.v v10, v11
6179; CHECK-NEXT:    vmv1r.v v11, v12
6180; CHECK-NEXT:    vlseg5e16ff.v v7, (a0), v0.t
6181; CHECK-NEXT:    csrr a0, vl
6182; CHECK-NEXT:    sw a0, 0(a2)
6183; CHECK-NEXT:    ret
6184entry:
6185  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 5), i32} @llvm.riscv.vlseg5ff.mask.triscv.vector.tuple_nxv2i8_5t.nxv1i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 5) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 4)
6186  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 5), i32} %0, 0
6187  %2 = call <vscale x 1 x bfloat> @llvm.riscv.tuple.extract.nxv1bf16.triscv.vector.tuple_nxv2i8_5t(target("riscv.vector.tuple", <vscale x 2 x i8>, 5) %1, i32 1)
6188  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 5), i32} %0, 1
6189  store i32 %3, ptr %outvl
6190  ret <vscale x 1 x bfloat> %2
6191}
6192
6193
6194define <vscale x 2 x bfloat> @test_vlseg5ff_nxv2bf16_triscv.vector.tuple_nxv4i8_5t(ptr %base, i32 %vl, ptr %outvl) {
6195; CHECK-LABEL: test_vlseg5ff_nxv2bf16_triscv.vector.tuple_nxv4i8_5t:
6196; CHECK:       # %bb.0: # %entry
6197; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, ma
6198; CHECK-NEXT:    vlseg5e16ff.v v7, (a0)
6199; CHECK-NEXT:    csrr a0, vl
6200; CHECK-NEXT:    sw a0, 0(a2)
6201; CHECK-NEXT:    ret
6202entry:
6203  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} @llvm.riscv.vlseg5ff.triscv.vector.tuple_nxv4i8_5t(target("riscv.vector.tuple", <vscale x 4 x i8>, 5) undef, ptr %base, i32 %vl, i32 4)
6204  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} %0, 0
6205  %2 = call <vscale x 2 x bfloat> @llvm.riscv.tuple.extract.nxv2bf16.triscv.vector.tuple_nxv4i8_5t(target("riscv.vector.tuple", <vscale x 4 x i8>, 5) %1, i32 1)
6206  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} %0, 1
6207  store i32 %3, ptr %outvl
6208  ret <vscale x 2 x bfloat> %2
6209}
6210
6211define <vscale x 2 x bfloat> @test_vlseg5ff_mask_nxv2bf16_triscv.vector.tuple_nxv4i8_5t(target("riscv.vector.tuple", <vscale x 4 x i8>, 5) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
6212; CHECK-LABEL: test_vlseg5ff_mask_nxv2bf16_triscv.vector.tuple_nxv4i8_5t:
6213; CHECK:       # %bb.0: # %entry
6214; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, mu
6215; CHECK-NEXT:    vmv1r.v v7, v8
6216; CHECK-NEXT:    vmv1r.v v8, v9
6217; CHECK-NEXT:    vmv1r.v v9, v10
6218; CHECK-NEXT:    vmv1r.v v10, v11
6219; CHECK-NEXT:    vmv1r.v v11, v12
6220; CHECK-NEXT:    vlseg5e16ff.v v7, (a0), v0.t
6221; CHECK-NEXT:    csrr a0, vl
6222; CHECK-NEXT:    sw a0, 0(a2)
6223; CHECK-NEXT:    ret
6224entry:
6225  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} @llvm.riscv.vlseg5ff.mask.triscv.vector.tuple_nxv4i8_5t.nxv2i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 5) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 4)
6226  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} %0, 0
6227  %2 = call <vscale x 2 x bfloat> @llvm.riscv.tuple.extract.nxv2bf16.triscv.vector.tuple_nxv4i8_5t(target("riscv.vector.tuple", <vscale x 4 x i8>, 5) %1, i32 1)
6228  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 5), i32} %0, 1
6229  store i32 %3, ptr %outvl
6230  ret <vscale x 2 x bfloat> %2
6231}
6232
6233
6234define <vscale x 4 x bfloat> @test_vlseg5ff_nxv4bf16_triscv.vector.tuple_nxv8i8_5t(ptr %base, i32 %vl, ptr %outvl) {
6235; CHECK-LABEL: test_vlseg5ff_nxv4bf16_triscv.vector.tuple_nxv8i8_5t:
6236; CHECK:       # %bb.0: # %entry
6237; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, ma
6238; CHECK-NEXT:    vlseg5e16ff.v v7, (a0)
6239; CHECK-NEXT:    csrr a0, vl
6240; CHECK-NEXT:    sw a0, 0(a2)
6241; CHECK-NEXT:    ret
6242entry:
6243  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} @llvm.riscv.vlseg5ff.triscv.vector.tuple_nxv8i8_5t(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) undef, ptr %base, i32 %vl, i32 4)
6244  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} %0, 0
6245  %2 = call <vscale x 4 x bfloat> @llvm.riscv.tuple.extract.nxv4bf16.triscv.vector.tuple_nxv8i8_5t(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) %1, i32 1)
6246  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} %0, 1
6247  store i32 %3, ptr %outvl
6248  ret <vscale x 4 x bfloat> %2
6249}
6250
6251define <vscale x 4 x bfloat> @test_vlseg5ff_mask_nxv4bf16_triscv.vector.tuple_nxv8i8_5t(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) %val, ptr %base, i32 %vl, <vscale x 4 x i1> %mask, ptr %outvl) {
6252; CHECK-LABEL: test_vlseg5ff_mask_nxv4bf16_triscv.vector.tuple_nxv8i8_5t:
6253; CHECK:       # %bb.0: # %entry
6254; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, mu
6255; CHECK-NEXT:    vmv1r.v v7, v8
6256; CHECK-NEXT:    vmv1r.v v8, v9
6257; CHECK-NEXT:    vmv1r.v v9, v10
6258; CHECK-NEXT:    vmv1r.v v10, v11
6259; CHECK-NEXT:    vmv1r.v v11, v12
6260; CHECK-NEXT:    vlseg5e16ff.v v7, (a0), v0.t
6261; CHECK-NEXT:    csrr a0, vl
6262; CHECK-NEXT:    sw a0, 0(a2)
6263; CHECK-NEXT:    ret
6264entry:
6265  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} @llvm.riscv.vlseg5ff.mask.triscv.vector.tuple_nxv8i8_5t.nxv4i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) %val, ptr %base, <vscale x 4 x i1> %mask, i32 %vl, i32 1, i32 4)
6266  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} %0, 0
6267  %2 = call <vscale x 4 x bfloat> @llvm.riscv.tuple.extract.nxv4bf16.triscv.vector.tuple_nxv8i8_5t(target("riscv.vector.tuple", <vscale x 8 x i8>, 5) %1, i32 1)
6268  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 5), i32} %0, 1
6269  store i32 %3, ptr %outvl
6270  ret <vscale x 4 x bfloat> %2
6271}
6272
6273
6274define <vscale x 1 x bfloat> @test_vlseg6ff_nxv1bf16_triscv.vector.tuple_nxv2i8_6t(ptr %base, i32 %vl, ptr %outvl) {
6275; CHECK-LABEL: test_vlseg6ff_nxv1bf16_triscv.vector.tuple_nxv2i8_6t:
6276; CHECK:       # %bb.0: # %entry
6277; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, ma
6278; CHECK-NEXT:    vlseg6e16ff.v v7, (a0)
6279; CHECK-NEXT:    csrr a0, vl
6280; CHECK-NEXT:    sw a0, 0(a2)
6281; CHECK-NEXT:    ret
6282entry:
6283  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 6), i32} @llvm.riscv.vlseg6ff.triscv.vector.tuple_nxv2i8_6t(target("riscv.vector.tuple", <vscale x 2 x i8>, 6) undef, ptr %base, i32 %vl, i32 4)
6284  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 6), i32} %0, 0
6285  %2 = call <vscale x 1 x bfloat> @llvm.riscv.tuple.extract.nxv1bf16.triscv.vector.tuple_nxv2i8_6t(target("riscv.vector.tuple", <vscale x 2 x i8>, 6) %1, i32 1)
6286  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 6), i32} %0, 1
6287  store i32 %3, ptr %outvl
6288  ret <vscale x 1 x bfloat> %2
6289}
6290
6291define <vscale x 1 x bfloat> @test_vlseg6ff_mask_nxv1bf16_triscv.vector.tuple_nxv2i8_6t(target("riscv.vector.tuple", <vscale x 2 x i8>, 6) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
6292; CHECK-LABEL: test_vlseg6ff_mask_nxv1bf16_triscv.vector.tuple_nxv2i8_6t:
6293; CHECK:       # %bb.0: # %entry
6294; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, mu
6295; CHECK-NEXT:    vmv1r.v v7, v8
6296; CHECK-NEXT:    vmv1r.v v8, v9
6297; CHECK-NEXT:    vmv1r.v v9, v10
6298; CHECK-NEXT:    vmv1r.v v10, v11
6299; CHECK-NEXT:    vmv1r.v v11, v12
6300; CHECK-NEXT:    vmv1r.v v12, v13
6301; CHECK-NEXT:    vlseg6e16ff.v v7, (a0), v0.t
6302; CHECK-NEXT:    csrr a0, vl
6303; CHECK-NEXT:    sw a0, 0(a2)
6304; CHECK-NEXT:    ret
6305entry:
6306  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 6), i32} @llvm.riscv.vlseg6ff.mask.triscv.vector.tuple_nxv2i8_6t.nxv1i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 6) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 4)
6307  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 6), i32} %0, 0
6308  %2 = call <vscale x 1 x bfloat> @llvm.riscv.tuple.extract.nxv1bf16.triscv.vector.tuple_nxv2i8_6t(target("riscv.vector.tuple", <vscale x 2 x i8>, 6) %1, i32 1)
6309  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 6), i32} %0, 1
6310  store i32 %3, ptr %outvl
6311  ret <vscale x 1 x bfloat> %2
6312}
6313
6314
6315define <vscale x 2 x bfloat> @test_vlseg6ff_nxv2bf16_triscv.vector.tuple_nxv4i8_6t(ptr %base, i32 %vl, ptr %outvl) {
6316; CHECK-LABEL: test_vlseg6ff_nxv2bf16_triscv.vector.tuple_nxv4i8_6t:
6317; CHECK:       # %bb.0: # %entry
6318; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, ma
6319; CHECK-NEXT:    vlseg6e16ff.v v7, (a0)
6320; CHECK-NEXT:    csrr a0, vl
6321; CHECK-NEXT:    sw a0, 0(a2)
6322; CHECK-NEXT:    ret
6323entry:
6324  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} @llvm.riscv.vlseg6ff.triscv.vector.tuple_nxv4i8_6t(target("riscv.vector.tuple", <vscale x 4 x i8>, 6) undef, ptr %base, i32 %vl, i32 4)
6325  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} %0, 0
6326  %2 = call <vscale x 2 x bfloat> @llvm.riscv.tuple.extract.nxv2bf16.triscv.vector.tuple_nxv4i8_6t(target("riscv.vector.tuple", <vscale x 4 x i8>, 6) %1, i32 1)
6327  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} %0, 1
6328  store i32 %3, ptr %outvl
6329  ret <vscale x 2 x bfloat> %2
6330}
6331
6332define <vscale x 2 x bfloat> @test_vlseg6ff_mask_nxv2bf16_triscv.vector.tuple_nxv4i8_6t(target("riscv.vector.tuple", <vscale x 4 x i8>, 6) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
6333; CHECK-LABEL: test_vlseg6ff_mask_nxv2bf16_triscv.vector.tuple_nxv4i8_6t:
6334; CHECK:       # %bb.0: # %entry
6335; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, mu
6336; CHECK-NEXT:    vmv1r.v v7, v8
6337; CHECK-NEXT:    vmv1r.v v8, v9
6338; CHECK-NEXT:    vmv1r.v v9, v10
6339; CHECK-NEXT:    vmv1r.v v10, v11
6340; CHECK-NEXT:    vmv1r.v v11, v12
6341; CHECK-NEXT:    vmv1r.v v12, v13
6342; CHECK-NEXT:    vlseg6e16ff.v v7, (a0), v0.t
6343; CHECK-NEXT:    csrr a0, vl
6344; CHECK-NEXT:    sw a0, 0(a2)
6345; CHECK-NEXT:    ret
6346entry:
6347  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} @llvm.riscv.vlseg6ff.mask.triscv.vector.tuple_nxv4i8_6t.nxv2i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 6) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 4)
6348  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} %0, 0
6349  %2 = call <vscale x 2 x bfloat> @llvm.riscv.tuple.extract.nxv2bf16.triscv.vector.tuple_nxv4i8_6t(target("riscv.vector.tuple", <vscale x 4 x i8>, 6) %1, i32 1)
6350  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 6), i32} %0, 1
6351  store i32 %3, ptr %outvl
6352  ret <vscale x 2 x bfloat> %2
6353}
6354
6355
6356define <vscale x 4 x bfloat> @test_vlseg6ff_nxv4bf16_triscv.vector.tuple_nxv8i8_6t(ptr %base, i32 %vl, ptr %outvl) {
6357; CHECK-LABEL: test_vlseg6ff_nxv4bf16_triscv.vector.tuple_nxv8i8_6t:
6358; CHECK:       # %bb.0: # %entry
6359; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, ma
6360; CHECK-NEXT:    vlseg6e16ff.v v7, (a0)
6361; CHECK-NEXT:    csrr a0, vl
6362; CHECK-NEXT:    sw a0, 0(a2)
6363; CHECK-NEXT:    ret
6364entry:
6365  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} @llvm.riscv.vlseg6ff.triscv.vector.tuple_nxv8i8_6t(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) undef, ptr %base, i32 %vl, i32 4)
6366  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} %0, 0
6367  %2 = call <vscale x 4 x bfloat> @llvm.riscv.tuple.extract.nxv4bf16.triscv.vector.tuple_nxv8i8_6t(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) %1, i32 1)
6368  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} %0, 1
6369  store i32 %3, ptr %outvl
6370  ret <vscale x 4 x bfloat> %2
6371}
6372
6373define <vscale x 4 x bfloat> @test_vlseg6ff_mask_nxv4bf16_triscv.vector.tuple_nxv8i8_6t(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) %val, ptr %base, i32 %vl, <vscale x 4 x i1> %mask, ptr %outvl) {
6374; CHECK-LABEL: test_vlseg6ff_mask_nxv4bf16_triscv.vector.tuple_nxv8i8_6t:
6375; CHECK:       # %bb.0: # %entry
6376; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, mu
6377; CHECK-NEXT:    vmv1r.v v7, v8
6378; CHECK-NEXT:    vmv1r.v v8, v9
6379; CHECK-NEXT:    vmv1r.v v9, v10
6380; CHECK-NEXT:    vmv1r.v v10, v11
6381; CHECK-NEXT:    vmv1r.v v11, v12
6382; CHECK-NEXT:    vmv1r.v v12, v13
6383; CHECK-NEXT:    vlseg6e16ff.v v7, (a0), v0.t
6384; CHECK-NEXT:    csrr a0, vl
6385; CHECK-NEXT:    sw a0, 0(a2)
6386; CHECK-NEXT:    ret
6387entry:
6388  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} @llvm.riscv.vlseg6ff.mask.triscv.vector.tuple_nxv8i8_6t.nxv4i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) %val, ptr %base, <vscale x 4 x i1> %mask, i32 %vl, i32 1, i32 4)
6389  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} %0, 0
6390  %2 = call <vscale x 4 x bfloat> @llvm.riscv.tuple.extract.nxv4bf16.triscv.vector.tuple_nxv8i8_6t(target("riscv.vector.tuple", <vscale x 8 x i8>, 6) %1, i32 1)
6391  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 6), i32} %0, 1
6392  store i32 %3, ptr %outvl
6393  ret <vscale x 4 x bfloat> %2
6394}
6395
6396
6397define <vscale x 1 x bfloat> @test_vlseg7ff_nxv1bf16_triscv.vector.tuple_nxv2i8_7t(ptr %base, i32 %vl, ptr %outvl) {
6398; CHECK-LABEL: test_vlseg7ff_nxv1bf16_triscv.vector.tuple_nxv2i8_7t:
6399; CHECK:       # %bb.0: # %entry
6400; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, ma
6401; CHECK-NEXT:    vlseg7e16ff.v v7, (a0)
6402; CHECK-NEXT:    csrr a0, vl
6403; CHECK-NEXT:    sw a0, 0(a2)
6404; CHECK-NEXT:    ret
6405entry:
6406  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 7), i32} @llvm.riscv.vlseg7ff.triscv.vector.tuple_nxv2i8_7t(target("riscv.vector.tuple", <vscale x 2 x i8>, 7) undef, ptr %base, i32 %vl, i32 4)
6407  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 7), i32} %0, 0
6408  %2 = call <vscale x 1 x bfloat> @llvm.riscv.tuple.extract.nxv1bf16.triscv.vector.tuple_nxv2i8_7t(target("riscv.vector.tuple", <vscale x 2 x i8>, 7) %1, i32 1)
6409  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 7), i32} %0, 1
6410  store i32 %3, ptr %outvl
6411  ret <vscale x 1 x bfloat> %2
6412}
6413
6414define <vscale x 1 x bfloat> @test_vlseg7ff_mask_nxv1bf16_triscv.vector.tuple_nxv2i8_7t(target("riscv.vector.tuple", <vscale x 2 x i8>, 7) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
6415; CHECK-LABEL: test_vlseg7ff_mask_nxv1bf16_triscv.vector.tuple_nxv2i8_7t:
6416; CHECK:       # %bb.0: # %entry
6417; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, mu
6418; CHECK-NEXT:    vmv1r.v v7, v8
6419; CHECK-NEXT:    vmv1r.v v8, v9
6420; CHECK-NEXT:    vmv1r.v v9, v10
6421; CHECK-NEXT:    vmv1r.v v10, v11
6422; CHECK-NEXT:    vmv1r.v v11, v12
6423; CHECK-NEXT:    vmv1r.v v12, v13
6424; CHECK-NEXT:    vmv1r.v v13, v14
6425; CHECK-NEXT:    vlseg7e16ff.v v7, (a0), v0.t
6426; CHECK-NEXT:    csrr a0, vl
6427; CHECK-NEXT:    sw a0, 0(a2)
6428; CHECK-NEXT:    ret
6429entry:
6430  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 7), i32} @llvm.riscv.vlseg7ff.mask.triscv.vector.tuple_nxv2i8_7t.nxv1i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 7) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 4)
6431  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 7), i32} %0, 0
6432  %2 = call <vscale x 1 x bfloat> @llvm.riscv.tuple.extract.nxv1bf16.triscv.vector.tuple_nxv2i8_7t(target("riscv.vector.tuple", <vscale x 2 x i8>, 7) %1, i32 1)
6433  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 7), i32} %0, 1
6434  store i32 %3, ptr %outvl
6435  ret <vscale x 1 x bfloat> %2
6436}
6437
6438
6439define <vscale x 2 x bfloat> @test_vlseg7ff_nxv2bf16_triscv.vector.tuple_nxv4i8_7t(ptr %base, i32 %vl, ptr %outvl) {
6440; CHECK-LABEL: test_vlseg7ff_nxv2bf16_triscv.vector.tuple_nxv4i8_7t:
6441; CHECK:       # %bb.0: # %entry
6442; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, ma
6443; CHECK-NEXT:    vlseg7e16ff.v v7, (a0)
6444; CHECK-NEXT:    csrr a0, vl
6445; CHECK-NEXT:    sw a0, 0(a2)
6446; CHECK-NEXT:    ret
6447entry:
6448  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} @llvm.riscv.vlseg7ff.triscv.vector.tuple_nxv4i8_7t(target("riscv.vector.tuple", <vscale x 4 x i8>, 7) undef, ptr %base, i32 %vl, i32 4)
6449  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} %0, 0
6450  %2 = call <vscale x 2 x bfloat> @llvm.riscv.tuple.extract.nxv2bf16.triscv.vector.tuple_nxv4i8_7t(target("riscv.vector.tuple", <vscale x 4 x i8>, 7) %1, i32 1)
6451  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} %0, 1
6452  store i32 %3, ptr %outvl
6453  ret <vscale x 2 x bfloat> %2
6454}
6455
6456define <vscale x 2 x bfloat> @test_vlseg7ff_mask_nxv2bf16_triscv.vector.tuple_nxv4i8_7t(target("riscv.vector.tuple", <vscale x 4 x i8>, 7) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
6457; CHECK-LABEL: test_vlseg7ff_mask_nxv2bf16_triscv.vector.tuple_nxv4i8_7t:
6458; CHECK:       # %bb.0: # %entry
6459; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, mu
6460; CHECK-NEXT:    vmv1r.v v7, v8
6461; CHECK-NEXT:    vmv1r.v v8, v9
6462; CHECK-NEXT:    vmv1r.v v9, v10
6463; CHECK-NEXT:    vmv1r.v v10, v11
6464; CHECK-NEXT:    vmv1r.v v11, v12
6465; CHECK-NEXT:    vmv1r.v v12, v13
6466; CHECK-NEXT:    vmv1r.v v13, v14
6467; CHECK-NEXT:    vlseg7e16ff.v v7, (a0), v0.t
6468; CHECK-NEXT:    csrr a0, vl
6469; CHECK-NEXT:    sw a0, 0(a2)
6470; CHECK-NEXT:    ret
6471entry:
6472  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} @llvm.riscv.vlseg7ff.mask.triscv.vector.tuple_nxv4i8_7t.nxv2i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 7) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 4)
6473  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} %0, 0
6474  %2 = call <vscale x 2 x bfloat> @llvm.riscv.tuple.extract.nxv2bf16.triscv.vector.tuple_nxv4i8_7t(target("riscv.vector.tuple", <vscale x 4 x i8>, 7) %1, i32 1)
6475  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 7), i32} %0, 1
6476  store i32 %3, ptr %outvl
6477  ret <vscale x 2 x bfloat> %2
6478}
6479
6480
6481define <vscale x 4 x bfloat> @test_vlseg7ff_nxv4bf16_triscv.vector.tuple_nxv8i8_7t(ptr %base, i32 %vl, ptr %outvl) {
6482; CHECK-LABEL: test_vlseg7ff_nxv4bf16_triscv.vector.tuple_nxv8i8_7t:
6483; CHECK:       # %bb.0: # %entry
6484; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, ma
6485; CHECK-NEXT:    vlseg7e16ff.v v7, (a0)
6486; CHECK-NEXT:    csrr a0, vl
6487; CHECK-NEXT:    sw a0, 0(a2)
6488; CHECK-NEXT:    ret
6489entry:
6490  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} @llvm.riscv.vlseg7ff.triscv.vector.tuple_nxv8i8_7t(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) undef, ptr %base, i32 %vl, i32 4)
6491  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} %0, 0
6492  %2 = call <vscale x 4 x bfloat> @llvm.riscv.tuple.extract.nxv4bf16.triscv.vector.tuple_nxv8i8_7t(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) %1, i32 1)
6493  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} %0, 1
6494  store i32 %3, ptr %outvl
6495  ret <vscale x 4 x bfloat> %2
6496}
6497
6498define <vscale x 4 x bfloat> @test_vlseg7ff_mask_nxv4bf16_triscv.vector.tuple_nxv8i8_7t(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) %val, ptr %base, i32 %vl, <vscale x 4 x i1> %mask, ptr %outvl) {
6499; CHECK-LABEL: test_vlseg7ff_mask_nxv4bf16_triscv.vector.tuple_nxv8i8_7t:
6500; CHECK:       # %bb.0: # %entry
6501; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, mu
6502; CHECK-NEXT:    vmv1r.v v7, v8
6503; CHECK-NEXT:    vmv1r.v v8, v9
6504; CHECK-NEXT:    vmv1r.v v9, v10
6505; CHECK-NEXT:    vmv1r.v v10, v11
6506; CHECK-NEXT:    vmv1r.v v11, v12
6507; CHECK-NEXT:    vmv1r.v v12, v13
6508; CHECK-NEXT:    vmv1r.v v13, v14
6509; CHECK-NEXT:    vlseg7e16ff.v v7, (a0), v0.t
6510; CHECK-NEXT:    csrr a0, vl
6511; CHECK-NEXT:    sw a0, 0(a2)
6512; CHECK-NEXT:    ret
6513entry:
6514  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} @llvm.riscv.vlseg7ff.mask.triscv.vector.tuple_nxv8i8_7t.nxv4i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) %val, ptr %base, <vscale x 4 x i1> %mask, i32 %vl, i32 1, i32 4)
6515  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} %0, 0
6516  %2 = call <vscale x 4 x bfloat> @llvm.riscv.tuple.extract.nxv4bf16.triscv.vector.tuple_nxv8i8_7t(target("riscv.vector.tuple", <vscale x 8 x i8>, 7) %1, i32 1)
6517  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 7), i32} %0, 1
6518  store i32 %3, ptr %outvl
6519  ret <vscale x 4 x bfloat> %2
6520}
6521
6522
6523define <vscale x 1 x bfloat> @test_vlseg8ff_nxv1bf16_triscv.vector.tuple_nxv2i8_8t(ptr %base, i32 %vl, ptr %outvl) {
6524; CHECK-LABEL: test_vlseg8ff_nxv1bf16_triscv.vector.tuple_nxv2i8_8t:
6525; CHECK:       # %bb.0: # %entry
6526; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, ma
6527; CHECK-NEXT:    vlseg8e16ff.v v7, (a0)
6528; CHECK-NEXT:    csrr a0, vl
6529; CHECK-NEXT:    sw a0, 0(a2)
6530; CHECK-NEXT:    ret
6531entry:
6532  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 8), i32} @llvm.riscv.vlseg8ff.triscv.vector.tuple_nxv2i8_8t(target("riscv.vector.tuple", <vscale x 2 x i8>, 8) undef, ptr %base, i32 %vl, i32 4)
6533  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 8), i32} %0, 0
6534  %2 = call <vscale x 1 x bfloat> @llvm.riscv.tuple.extract.nxv1bf16.triscv.vector.tuple_nxv2i8_8t(target("riscv.vector.tuple", <vscale x 2 x i8>, 8) %1, i32 1)
6535  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 8), i32} %0, 1
6536  store i32 %3, ptr %outvl
6537  ret <vscale x 1 x bfloat> %2
6538}
6539
6540define <vscale x 1 x bfloat> @test_vlseg8ff_mask_nxv1bf16_triscv.vector.tuple_nxv2i8_8t(target("riscv.vector.tuple", <vscale x 2 x i8>, 8) %val, ptr %base, i32 %vl, <vscale x 1 x i1> %mask, ptr %outvl) {
6541; CHECK-LABEL: test_vlseg8ff_mask_nxv1bf16_triscv.vector.tuple_nxv2i8_8t:
6542; CHECK:       # %bb.0: # %entry
6543; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, mu
6544; CHECK-NEXT:    vmv1r.v v7, v8
6545; CHECK-NEXT:    vmv1r.v v8, v9
6546; CHECK-NEXT:    vmv1r.v v9, v10
6547; CHECK-NEXT:    vmv1r.v v10, v11
6548; CHECK-NEXT:    vmv1r.v v11, v12
6549; CHECK-NEXT:    vmv1r.v v12, v13
6550; CHECK-NEXT:    vmv1r.v v13, v14
6551; CHECK-NEXT:    vmv1r.v v14, v15
6552; CHECK-NEXT:    vlseg8e16ff.v v7, (a0), v0.t
6553; CHECK-NEXT:    csrr a0, vl
6554; CHECK-NEXT:    sw a0, 0(a2)
6555; CHECK-NEXT:    ret
6556entry:
6557  %0 = tail call {target("riscv.vector.tuple", <vscale x 2 x i8>, 8), i32} @llvm.riscv.vlseg8ff.mask.triscv.vector.tuple_nxv2i8_8t.nxv1i1(target("riscv.vector.tuple", <vscale x 2 x i8>, 8) %val, ptr %base, <vscale x 1 x i1> %mask, i32 %vl, i32 1, i32 4)
6558  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 8), i32} %0, 0
6559  %2 = call <vscale x 1 x bfloat> @llvm.riscv.tuple.extract.nxv1bf16.triscv.vector.tuple_nxv2i8_8t(target("riscv.vector.tuple", <vscale x 2 x i8>, 8) %1, i32 1)
6560  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 2 x i8>, 8), i32} %0, 1
6561  store i32 %3, ptr %outvl
6562  ret <vscale x 1 x bfloat> %2
6563}
6564
6565
6566define <vscale x 2 x bfloat> @test_vlseg8ff_nxv2bf16_triscv.vector.tuple_nxv4i8_8t(ptr %base, i32 %vl, ptr %outvl) {
6567; CHECK-LABEL: test_vlseg8ff_nxv2bf16_triscv.vector.tuple_nxv4i8_8t:
6568; CHECK:       # %bb.0: # %entry
6569; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, ma
6570; CHECK-NEXT:    vlseg8e16ff.v v7, (a0)
6571; CHECK-NEXT:    csrr a0, vl
6572; CHECK-NEXT:    sw a0, 0(a2)
6573; CHECK-NEXT:    ret
6574entry:
6575  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} @llvm.riscv.vlseg8ff.triscv.vector.tuple_nxv4i8_8t(target("riscv.vector.tuple", <vscale x 4 x i8>, 8) undef, ptr %base, i32 %vl, i32 4)
6576  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} %0, 0
6577  %2 = call <vscale x 2 x bfloat> @llvm.riscv.tuple.extract.nxv2bf16.triscv.vector.tuple_nxv4i8_8t(target("riscv.vector.tuple", <vscale x 4 x i8>, 8) %1, i32 1)
6578  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} %0, 1
6579  store i32 %3, ptr %outvl
6580  ret <vscale x 2 x bfloat> %2
6581}
6582
6583define <vscale x 2 x bfloat> @test_vlseg8ff_mask_nxv2bf16_triscv.vector.tuple_nxv4i8_8t(target("riscv.vector.tuple", <vscale x 4 x i8>, 8) %val, ptr %base, i32 %vl, <vscale x 2 x i1> %mask, ptr %outvl) {
6584; CHECK-LABEL: test_vlseg8ff_mask_nxv2bf16_triscv.vector.tuple_nxv4i8_8t:
6585; CHECK:       # %bb.0: # %entry
6586; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, mu
6587; CHECK-NEXT:    vmv1r.v v7, v8
6588; CHECK-NEXT:    vmv1r.v v8, v9
6589; CHECK-NEXT:    vmv1r.v v9, v10
6590; CHECK-NEXT:    vmv1r.v v10, v11
6591; CHECK-NEXT:    vmv1r.v v11, v12
6592; CHECK-NEXT:    vmv1r.v v12, v13
6593; CHECK-NEXT:    vmv1r.v v13, v14
6594; CHECK-NEXT:    vmv1r.v v14, v15
6595; CHECK-NEXT:    vlseg8e16ff.v v7, (a0), v0.t
6596; CHECK-NEXT:    csrr a0, vl
6597; CHECK-NEXT:    sw a0, 0(a2)
6598; CHECK-NEXT:    ret
6599entry:
6600  %0 = tail call {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} @llvm.riscv.vlseg8ff.mask.triscv.vector.tuple_nxv4i8_8t.nxv2i1(target("riscv.vector.tuple", <vscale x 4 x i8>, 8) %val, ptr %base, <vscale x 2 x i1> %mask, i32 %vl, i32 1, i32 4)
6601  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} %0, 0
6602  %2 = call <vscale x 2 x bfloat> @llvm.riscv.tuple.extract.nxv2bf16.triscv.vector.tuple_nxv4i8_8t(target("riscv.vector.tuple", <vscale x 4 x i8>, 8) %1, i32 1)
6603  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 4 x i8>, 8), i32} %0, 1
6604  store i32 %3, ptr %outvl
6605  ret <vscale x 2 x bfloat> %2
6606}
6607
6608
6609define <vscale x 4 x bfloat> @test_vlseg8ff_nxv4bf16_triscv.vector.tuple_nxv8i8_8t(ptr %base, i32 %vl, ptr %outvl) {
6610; CHECK-LABEL: test_vlseg8ff_nxv4bf16_triscv.vector.tuple_nxv8i8_8t:
6611; CHECK:       # %bb.0: # %entry
6612; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, ma
6613; CHECK-NEXT:    vlseg8e16ff.v v7, (a0)
6614; CHECK-NEXT:    csrr a0, vl
6615; CHECK-NEXT:    sw a0, 0(a2)
6616; CHECK-NEXT:    ret
6617entry:
6618  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} @llvm.riscv.vlseg8ff.triscv.vector.tuple_nxv8i8_8t(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) undef, ptr %base, i32 %vl, i32 4)
6619  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} %0, 0
6620  %2 = call <vscale x 4 x bfloat> @llvm.riscv.tuple.extract.nxv4bf16.triscv.vector.tuple_nxv8i8_8t(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) %1, i32 1)
6621  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} %0, 1
6622  store i32 %3, ptr %outvl
6623  ret <vscale x 4 x bfloat> %2
6624}
6625
6626define <vscale x 4 x bfloat> @test_vlseg8ff_mask_nxv4bf16_triscv.vector.tuple_nxv8i8_8t(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) %val, ptr %base, i32 %vl, <vscale x 4 x i1> %mask, ptr %outvl) {
6627; CHECK-LABEL: test_vlseg8ff_mask_nxv4bf16_triscv.vector.tuple_nxv8i8_8t:
6628; CHECK:       # %bb.0: # %entry
6629; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, mu
6630; CHECK-NEXT:    vmv1r.v v7, v8
6631; CHECK-NEXT:    vmv1r.v v8, v9
6632; CHECK-NEXT:    vmv1r.v v9, v10
6633; CHECK-NEXT:    vmv1r.v v10, v11
6634; CHECK-NEXT:    vmv1r.v v11, v12
6635; CHECK-NEXT:    vmv1r.v v12, v13
6636; CHECK-NEXT:    vmv1r.v v13, v14
6637; CHECK-NEXT:    vmv1r.v v14, v15
6638; CHECK-NEXT:    vlseg8e16ff.v v7, (a0), v0.t
6639; CHECK-NEXT:    csrr a0, vl
6640; CHECK-NEXT:    sw a0, 0(a2)
6641; CHECK-NEXT:    ret
6642entry:
6643  %0 = tail call {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} @llvm.riscv.vlseg8ff.mask.triscv.vector.tuple_nxv8i8_8t.nxv4i1(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) %val, ptr %base, <vscale x 4 x i1> %mask, i32 %vl, i32 1, i32 4)
6644  %1 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} %0, 0
6645  %2 = call <vscale x 4 x bfloat> @llvm.riscv.tuple.extract.nxv4bf16.triscv.vector.tuple_nxv8i8_8t(target("riscv.vector.tuple", <vscale x 8 x i8>, 8) %1, i32 1)
6646  %3 = extractvalue {target("riscv.vector.tuple", <vscale x 8 x i8>, 8), i32} %0, 1
6647  store i32 %3, ptr %outvl
6648  ret <vscale x 4 x bfloat> %2
6649}
6650
6651