llvm/test/CodeGen/RISCV/rvv/vlsegff-rv32.ll

   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
   5 declare {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)
   6 declare {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
   8 define <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
  16 entry:
  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
  25 define <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
  35 entry:
  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
  44 declare {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)
  45 declare {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
  47 define <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
  55 entry:
  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
  64 define <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
  74 entry:
  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
  83 declare {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)
  84 declare {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
  86 define <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
  94 entry:
  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
 103 define <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
 113 entry:
 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
 122 declare {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)
 123 declare {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
 125 define <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
 133 entry:
 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
 142 define <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
 152 entry:
 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
 161 declare {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)
 162 declare {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
 164 define <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
 172 entry:
 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
 181 define <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
 191 entry:
 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
 200 declare {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)
 201 declare {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
 203 define <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
 211 entry:
 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
 220 define <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
 230 entry:
 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
 239 declare {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)
 240 declare {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
 242 define <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
 250 entry:
 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
 259 define <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
 270 entry:
 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
 279 declare {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)
 280 declare {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
 282 define <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
 290 entry:
 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
 299 define <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
 310 entry:
 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
 319 declare {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)
 320 declare {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
 322 define <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
 330 entry:
 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
 339 define <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
 350 entry:
 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
 359 declare {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)
 360 declare {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
 362 define <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
 370 entry:
 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
 379 define <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
 390 entry:
 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
 399 declare {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)
 400 declare {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
 402 define <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
 410 entry:
 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
 419 define <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
 430 entry:
 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
 439 declare {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)
 440 declare {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
 442 define <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
 450 entry:
 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
 459 define <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
 471 entry:
 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
 480 declare {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)
 481 declare {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
 483 define <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
 491 entry:
 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
 500 define <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
 512 entry:
 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
 521 declare {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)
 522 declare {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
 524 define <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
 532 entry:
 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
 541 define <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
 553 entry:
 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
 562 declare {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)
 563 declare {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
 565 define <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
 573 entry:
 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
 582 define <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
 594 entry:
 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
 603 declare {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)
 604 declare {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
 606 define <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
 614 entry:
 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
 623 define <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
 635 entry:
 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
 644 declare {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)
 645 declare {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
 647 define <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
 655 entry:
 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
 664 define <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
 677 entry:
 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
 686 declare {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)
 687 declare {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
 689 define <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
 697 entry:
 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
 706 define <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
 719 entry:
 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
 728 declare {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)
 729 declare {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
 731 define <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
 739 entry:
 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
 748 define <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
 761 entry:
 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
 770 declare {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)
 771 declare {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
 773 define <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
 781 entry:
 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
 790 define <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
 803 entry:
 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
 812 declare {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)
 813 declare {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
 815 define <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
 823 entry:
 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
 832 define <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
 846 entry:
 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
 855 declare {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)
 856 declare {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
 858 define <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
 866 entry:
 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
 875 define <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
 889 entry:
 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
 898 declare {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)
 899 declare {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
 901 define <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
 909 entry:
 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
 918 define <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
 932 entry:
 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
 941 declare {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)
 942 declare {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
 944 define <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
 952 entry:
 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
 961 define <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
 975 entry:
 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
 984 declare {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)
 985 declare {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
 987 define <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
 995 entry:
 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
1004 define <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
1019 entry:
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
1028 declare {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)
1029 declare {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
1031 define <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
1039 entry:
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
1048 define <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
1063 entry:
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
1072 declare {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)
1073 declare {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
1075 define <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
1083 entry:
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
1092 define <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
1107 entry:
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
1116 declare {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)
1117 declare {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
1119 define <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
1127 entry:
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
1136 define <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
1151 entry:
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
1160 declare {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)
1161 declare {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
1163 define <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
1171 entry:
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
1180 define <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
1196 entry:
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
1205 declare {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)
1206 declare {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
1208 define <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
1216 entry:
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
1225 define <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
1241 entry:
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
1250 declare {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)
1251 declare {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
1253 define <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
1261 entry:
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
1270 define <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
1286 entry:
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
1295 declare {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)
1296 declare {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
1298 define <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
1306 entry:
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
1315 define <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
1331 entry:
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
1340 declare {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
1342 define <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
1350 entry:
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
1359 define <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
1369 entry:
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
1378 declare {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
1380 define <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
1388 entry:
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
1397 define <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
1407 entry:
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
1416 declare {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
1418 define <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
1426 entry:
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
1435 define <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
1445 entry:
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
1454 declare {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
1456 define <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
1464 entry:
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
1473 define <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
1483 entry:
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
1492 declare {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
1494 define <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
1502 entry:
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
1511 define <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
1521 entry:
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
1530 declare {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
1532 define <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
1540 entry:
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
1549 define <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
1560 entry:
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
1569 declare {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
1571 define <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
1579 entry:
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
1588 define <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
1599 entry:
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
1608 declare {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
1610 define <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
1618 entry:
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
1627 define <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
1638 entry:
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
1647 declare {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
1649 define <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
1657 entry:
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
1666 define <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
1677 entry:
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
1686 declare {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
1688 define <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
1696 entry:
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
1705 define <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
1717 entry:
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
1726 declare {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
1728 define <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
1736 entry:
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
1745 define <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
1757 entry:
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
1766 declare {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
1768 define <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
1776 entry:
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
1785 define <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
1797 entry:
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
1806 declare {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
1808 define <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
1816 entry:
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
1825 define <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
1837 entry:
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
1846 declare {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
1848 define <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
1856 entry:
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
1865 define <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
1878 entry:
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
1887 declare {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
1889 define <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
1897 entry:
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
1906 define <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
1919 entry:
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
1928 declare {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
1930 define <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
1938 entry:
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
1947 define <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
1960 entry:
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
1969 declare {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
1971 define <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
1979 entry:
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
1988 define <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
2002 entry:
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
2011 declare {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
2013 define <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
2021 entry:
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
2030 define <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
2044 entry:
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
2053 declare {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
2055 define <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
2063 entry:
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
2072 define <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
2086 entry:
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
2095 declare {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
2097 define <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
2105 entry:
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
2114 define <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
2129 entry:
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
2138 declare {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
2140 define <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
2148 entry:
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
2157 define <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
2172 entry:
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
2181 declare {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
2183 define <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
2191 entry:
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
2200 define <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
2215 entry:
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
2224 declare {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
2226 define <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
2234 entry:
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
2243 define <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
2259 entry:
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
2268 declare {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
2270 define <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
2278 entry:
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
2287 define <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
2303 entry:
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
2312 declare {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
2314 define <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
2322 entry:
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
2331 define <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
2347 entry:
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
2356 declare {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
2358 define <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
2366 entry:
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
2375 define <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
2385 entry:
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
2394 declare {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
2396 define <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
2404 entry:
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
2413 define <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
2423 entry:
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
2432 declare {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
2434 define <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
2442 entry:
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
2451 define <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
2461 entry:
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
2470 declare {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
2472 define <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
2480 entry:
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
2489 define <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
2499 entry:
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
2508 declare {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
2510 define <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
2518 entry:
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
2527 define <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
2538 entry:
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
2547 declare {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
2549 define <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
2557 entry:
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
2566 define <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
2577 entry:
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
2586 declare {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
2588 define <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
2596 entry:
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
2605 define <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
2616 entry:
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
2625 declare {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
2627 define <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
2635 entry:
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
2644 define <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
2656 entry:
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
2665 declare {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
2667 define <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
2675 entry:
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
2684 define <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
2696 entry:
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
2705 declare {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
2707 define <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
2715 entry:
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
2724 define <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
2736 entry:
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
2745 declare {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
2747 define <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
2755 entry:
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
2764 define <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
2777 entry:
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
2786 declare {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
2788 define <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
2796 entry:
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
2805 define <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
2818 entry:
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
2827 declare {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
2829 define <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
2837 entry:
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
2846 define <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
2860 entry:
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
2869 declare {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
2871 define <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
2879 entry:
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
2888 define <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
2902 entry:
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
2911 declare {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
2913 define <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
2921 entry:
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
2930 define <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
2945 entry:
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
2954 declare {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
2956 define <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
2964 entry:
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
2973 define <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
2988 entry:
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
2997 declare {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
2999 define <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
3007 entry:
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
3016 define <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
3032 entry:
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
3041 declare {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
3043 define <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
3051 entry:
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
3060 define <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
3076 entry:
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
3085 declare {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
3087 define <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
3095 entry:
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
3104 define <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
3114 entry:
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
3123 declare {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
3125 define <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
3133 entry:
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
3142 define <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
3152 entry:
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
3161 declare {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
3163 define <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
3171 entry:
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
3180 define <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
3190 entry:
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
3199 declare {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
3201 define <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
3209 entry:
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
3218 define <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
3229 entry:
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
3238 declare {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
3240 define <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
3248 entry:
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
3257 define <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
3268 entry:
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
3277 declare {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
3279 define <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
3287 entry:
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
3296 define <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
3308 entry:
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
3317 declare {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
3319 define <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
3327 entry:
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
3336 define <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
3348 entry:
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
3357 declare {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
3359 define <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
3367 entry:
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
3376 define <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
3389 entry:
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
3398 declare {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
3400 define <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
3408 entry:
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
3417 define <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
3431 entry:
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
3440 declare {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
3442 define <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
3450 entry:
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
3459 define <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
3474 entry:
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
3483 declare {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
3485 define <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
3493 entry:
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
3502 define <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
3518 entry:
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
3528 define <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
3536 entry:
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
3545 define <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
3555 entry:
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
3565 define <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
3573 entry:
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
3582 define <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
3592 entry:
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
3602 define <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
3610 entry:
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
3619 define <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
3629 entry:
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
3639 define <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
3647 entry:
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
3656 define <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
3666 entry:
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
3676 define <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
3684 entry:
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
3693 define <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
3703 entry:
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
3713 define <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
3721 entry:
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
3730 define <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
3741 entry:
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
3751 define <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
3759 entry:
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
3768 define <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
3779 entry:
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
3789 define <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
3797 entry:
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
3806 define <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
3817 entry:
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
3827 define <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
3835 entry:
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
3844 define <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
3855 entry:
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
3865 define <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
3873 entry:
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
3882 define <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
3894 entry:
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
3904 define <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
3912 entry:
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
3921 define <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
3933 entry:
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
3943 define <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
3951 entry:
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
3960 define <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
3972 entry:
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
3982 define <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
3990 entry:
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
3999 define <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
4011 entry:
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
4021 define <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
4029 entry:
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
4038 define <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
4051 entry:
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
4061 define <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
4069 entry:
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
4078 define <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
4091 entry:
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
4101 define <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
4109 entry:
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
4118 define <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
4131 entry:
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
4141 define <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
4149 entry:
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
4158 define <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
4172 entry:
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
4182 define <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
4190 entry:
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
4199 define <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
4213 entry:
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
4223 define <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
4231 entry:
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
4240 define <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
4254 entry:
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
4264 define <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
4272 entry:
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
4281 define <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
4296 entry:
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
4306 define <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
4314 entry:
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
4323 define <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
4338 entry:
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
4348 define <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
4356 entry:
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
4365 define <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
4380 entry:
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
4390 define <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
4398 entry:
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
4407 define <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
4423 entry:
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
4433 define <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
4441 entry:
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
4450 define <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
4466 entry:
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
4476 define <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
4484 entry:
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
4493 define <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
4509 entry:
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
4519 define <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
4527 entry:
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
4536 define <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
4546 entry:
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
4556 define <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
4564 entry:
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
4573 define <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
4583 entry:
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
4593 define <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
4601 entry:
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
4610 define <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
4620 entry:
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
4630 define <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
4638 entry:
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
4647 define <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
4657 entry:
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
4667 define <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
4675 entry:
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
4684 define <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
4695 entry:
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
4705 define <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
4713 entry:
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
4722 define <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
4733 entry:
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
4743 define <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
4751 entry:
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
4760 define <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
4771 entry:
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
4781 define <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
4789 entry:
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
4798 define <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
4810 entry:
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
4820 define <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
4828 entry:
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
4837 define <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
4849 entry:
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
4859 define <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
4867 entry:
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
4876 define <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
4888 entry:
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
4898 define <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
4906 entry:
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
4915 define <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
4928 entry:
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
4938 define <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
4946 entry:
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
4955 define <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
4968 entry:
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
4978 define <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
4986 entry:
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
4995 define <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
5009 entry:
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
5019 define <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
5027 entry:
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
5036 define <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
5050 entry:
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
5060 define <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
5068 entry:
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
5077 define <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
5092 entry:
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
5102 define <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
5110 entry:
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
5119 define <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
5134 entry:
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
5144 define <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
5152 entry:
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
5161 define <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
5177 entry:
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
5187 define <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
5195 entry:
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
5204 define <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
5220 entry:
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
5230 define <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
5238 entry:
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
5247 define <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
5257 entry:
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
5267 define <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
5275 entry:
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
5284 define <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
5294 entry:
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
5304 define <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
5312 entry:
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
5321 define <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
5331 entry:
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
5341 define <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
5349 entry:
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
5358 define <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
5369 entry:
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
5379 define <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
5387 entry:
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
5396 define <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
5407 entry:
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
5417 define <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
5425 entry:
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
5434 define <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
5446 entry:
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
5456 define <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
5464 entry:
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
5473 define <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
5485 entry:
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
5495 define <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
5503 entry:
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
5512 define <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
5525 entry:
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
5535 define <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
5543 entry:
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
5552 define <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
5566 entry:
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
5576 define <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
5584 entry:
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
5593 define <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
5608 entry:
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
5618 define <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
5626 entry:
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
5635 define <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
5651 entry:
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
5661 define <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
5669 entry:
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
5678 define <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
5688 entry:
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
5698 define <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
5706 entry:
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
5715 define <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
5725 entry:
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
5735 define <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
5743 entry:
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
5752 define <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
5762 entry:
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
5772 define <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
5780 entry:
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
5789 define <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
5799 entry:
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
5809 define <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
5817 entry:
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
5826 define <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
5836 entry:
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
5846 define <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
5854 entry:
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
5863 define <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
5874 entry:
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
5884 define <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
5892 entry:
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
5901 define <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
5912 entry:
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
5922 define <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
5930 entry:
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
5939 define <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
5950 entry:
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
5960 define <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
5968 entry:
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
5977 define <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
5988 entry:
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
5998 define <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
6006 entry:
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
6015 define <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
6027 entry:
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
6037 define <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
6045 entry:
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
6054 define <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
6066 entry:
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
6076 define <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
6084 entry:
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
6093 define <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
6105 entry:
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
6115 define <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
6123 entry:
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
6132 define <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
6144 entry:
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
6154 define <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
6162 entry:
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
6171 define <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
6184 entry:
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
6194 define <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
6202 entry:
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
6211 define <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
6224 entry:
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
6234 define <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
6242 entry:
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
6251 define <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
6264 entry:
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
6274 define <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
6282 entry:
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
6291 define <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
6305 entry:
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
6315 define <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
6323 entry:
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
6332 define <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
6346 entry:
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
6356 define <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
6364 entry:
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
6373 define <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
6387 entry:
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
6397 define <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
6405 entry:
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
6414 define <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
6429 entry:
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
6439 define <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
6447 entry:
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
6456 define <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
6471 entry:
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
6481 define <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
6489 entry:
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
6498 define <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
6513 entry:
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
6523 define <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
6531 entry:
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
6540 define <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
6556 entry:
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
6566 define <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
6574 entry:
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
6583 define <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
6599 entry:
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
6609 define <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
6617 entry:
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
6626 define <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
6642 entry:
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