llvm/test/CodeGen/RISCV/GlobalISel/regbankselect/rvv/load.mir

   1 # NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py
   2 # RUN: llc -mtriple=riscv32 -mattr=+m,+v -run-pass=regbankselect \
   3 # RUN:   -simplify-mir -verify-machineinstrs %s \
   4 # RUN:   -o - | FileCheck -check-prefix=RV32I %s
   5 # RUN: llc -mtriple=riscv64 -mattr=+m,+v -run-pass=regbankselect \
   6 # RUN:   -simplify-mir -verify-machineinstrs %s \
   7 # RUN:   -o - | FileCheck -check-prefix=RV64I %s
   8 --- |
   9
  10   define <vscale x 1 x i8> @vload_nx1i8(ptr %pa) #0 {
  11     %va = load <vscale x 1 x i8>, ptr %pa, align 1
  12     ret <vscale x 1 x i8> %va
  13   }
  14
  15   define <vscale x 2 x i8> @vload_nx2i8(ptr %pa) #0 {
  16     %va = load <vscale x 2 x i8>, ptr %pa, align 2
  17     ret <vscale x 2 x i8> %va
  18   }
  19
  20   define <vscale x 4 x i8> @vload_nx4i8(ptr %pa) #0 {
  21     %va = load <vscale x 4 x i8>, ptr %pa, align 4
  22     ret <vscale x 4 x i8> %va
  23   }
  24
  25   define <vscale x 8 x i8> @vload_nx8i8(ptr %pa) #0 {
  26     %va = load <vscale x 8 x i8>, ptr %pa, align 8
  27     ret <vscale x 8 x i8> %va
  28   }
  29
  30   define <vscale x 16 x i8> @vload_nx16i8(ptr %pa) #0 {
  31     %va = load <vscale x 16 x i8>, ptr %pa, align 16
  32     ret <vscale x 16 x i8> %va
  33   }
  34
  35   define <vscale x 32 x i8> @vload_nx32i8(ptr %pa) #0 {
  36     %va = load <vscale x 32 x i8>, ptr %pa, align 32
  37     ret <vscale x 32 x i8> %va
  38   }
  39
  40   define <vscale x 64 x i8> @vload_nx64i8(ptr %pa) #0 {
  41     %va = load <vscale x 64 x i8>, ptr %pa, align 64
  42     ret <vscale x 64 x i8> %va
  43   }
  44
  45   define <vscale x 1 x i16> @vload_nx1i16(ptr %pa) #0 {
  46     %va = load <vscale x 1 x i16>, ptr %pa, align 2
  47     ret <vscale x 1 x i16> %va
  48   }
  49
  50   define <vscale x 2 x i16> @vload_nx2i16(ptr %pa) #0 {
  51     %va = load <vscale x 2 x i16>, ptr %pa, align 4
  52     ret <vscale x 2 x i16> %va
  53   }
  54
  55   define <vscale x 4 x i16> @vload_nx4i16(ptr %pa) #0 {
  56     %va = load <vscale x 4 x i16>, ptr %pa, align 8
  57     ret <vscale x 4 x i16> %va
  58   }
  59
  60   define <vscale x 8 x i16> @vload_nx8i16(ptr %pa) #0 {
  61     %va = load <vscale x 8 x i16>, ptr %pa, align 16
  62     ret <vscale x 8 x i16> %va
  63   }
  64
  65   define <vscale x 16 x i16> @vload_nx16i16(ptr %pa) #0 {
  66     %va = load <vscale x 16 x i16>, ptr %pa, align 32
  67     ret <vscale x 16 x i16> %va
  68   }
  69
  70   define <vscale x 32 x i16> @vload_nx32i16(ptr %pa) #0 {
  71     %va = load <vscale x 32 x i16>, ptr %pa, align 64
  72     ret <vscale x 32 x i16> %va
  73   }
  74
  75   define <vscale x 1 x i32> @vload_nx1i32(ptr %pa) #0 {
  76     %va = load <vscale x 1 x i32>, ptr %pa, align 4
  77     ret <vscale x 1 x i32> %va
  78   }
  79
  80   define <vscale x 2 x i32> @vload_nx2i32(ptr %pa) #0 {
  81     %va = load <vscale x 2 x i32>, ptr %pa, align 8
  82     ret <vscale x 2 x i32> %va
  83   }
  84
  85   define <vscale x 4 x i32> @vload_nx4i32(ptr %pa) #0 {
  86     %va = load <vscale x 4 x i32>, ptr %pa, align 16
  87     ret <vscale x 4 x i32> %va
  88   }
  89
  90   define <vscale x 8 x i32> @vload_nx8i32(ptr %pa) #0 {
  91     %va = load <vscale x 8 x i32>, ptr %pa, align 32
  92     ret <vscale x 8 x i32> %va
  93   }
  94
  95   define <vscale x 16 x i32> @vload_nx16i32(ptr %pa) #0 {
  96     %va = load <vscale x 16 x i32>, ptr %pa, align 64
  97     ret <vscale x 16 x i32> %va
  98   }
  99
 100   define <vscale x 1 x i64> @vload_nx1i64(ptr %pa) #0 {
 101     %va = load <vscale x 1 x i64>, ptr %pa, align 8
 102     ret <vscale x 1 x i64> %va
 103   }
 104
 105   define <vscale x 2 x i64> @vload_nx2i64(ptr %pa) #0 {
 106     %va = load <vscale x 2 x i64>, ptr %pa, align 16
 107     ret <vscale x 2 x i64> %va
 108   }
 109
 110   define <vscale x 4 x i64> @vload_nx4i64(ptr %pa) #0 {
 111     %va = load <vscale x 4 x i64>, ptr %pa, align 32
 112     ret <vscale x 4 x i64> %va
 113   }
 114
 115   define <vscale x 8 x i64> @vload_nx8i64(ptr %pa) #0 {
 116     %va = load <vscale x 8 x i64>, ptr %pa, align 64
 117     ret <vscale x 8 x i64> %va
 118   }
 119
 120   define <vscale x 16 x i8> @vload_nx16i8_align1(ptr %pa) #0 {
 121     %va = load <vscale x 16 x i8>, ptr %pa, align 1
 122     ret <vscale x 16 x i8> %va
 123   }
 124
 125   define <vscale x 16 x i8> @vload_nx16i8_align2(ptr %pa) #0 {
 126     %va = load <vscale x 16 x i8>, ptr %pa, align 2
 127     ret <vscale x 16 x i8> %va
 128   }
 129
 130   define <vscale x 16 x i8> @vload_nx16i8_align16(ptr %pa) #0 {
 131     %va = load <vscale x 16 x i8>, ptr %pa, align 16
 132     ret <vscale x 16 x i8> %va
 133   }
 134
 135   define <vscale x 16 x i8> @vload_nx16i8_align64(ptr %pa) #0 {
 136     %va = load <vscale x 16 x i8>, ptr %pa, align 64
 137     ret <vscale x 16 x i8> %va
 138   }
 139
 140   define <vscale x 4 x i16> @vload_nx4i16_align1(ptr %pa) #0 {
 141     %va = load <vscale x 4 x i16>, ptr %pa, align 1
 142     ret <vscale x 4 x i16> %va
 143   }
 144
 145   define <vscale x 4 x i16> @vload_nx4i16_align2(ptr %pa) #0 {
 146     %va = load <vscale x 4 x i16>, ptr %pa, align 2
 147     ret <vscale x 4 x i16> %va
 148   }
 149
 150   define <vscale x 4 x i16> @vload_nx4i16_align4(ptr %pa) #0 {
 151     %va = load <vscale x 4 x i16>, ptr %pa, align 4
 152     ret <vscale x 4 x i16> %va
 153   }
 154
 155   define <vscale x 4 x i16> @vload_nx4i16_align8(ptr %pa) #0 {
 156     %va = load <vscale x 4 x i16>, ptr %pa, align 8
 157     ret <vscale x 4 x i16> %va
 158   }
 159
 160   define <vscale x 4 x i16> @vload_nx4i16_align16(ptr %pa) #0 {
 161     %va = load <vscale x 4 x i16>, ptr %pa, align 16
 162     ret <vscale x 4 x i16> %va
 163   }
 164
 165   define <vscale x 2 x i32> @vload_nx2i32_align2(ptr %pa) #0 {
 166     %va = load <vscale x 2 x i32>, ptr %pa, align 2
 167     ret <vscale x 2 x i32> %va
 168   }
 169
 170   define <vscale x 2 x i32> @vload_nx2i32_align4(ptr %pa) #0 {
 171     %va = load <vscale x 2 x i32>, ptr %pa, align 4
 172     ret <vscale x 2 x i32> %va
 173   }
 174
 175   define <vscale x 2 x i32> @vload_nx2i32_align8(ptr %pa) #0 {
 176     %va = load <vscale x 2 x i32>, ptr %pa, align 8
 177     ret <vscale x 2 x i32> %va
 178   }
 179
 180   define <vscale x 2 x i32> @vload_nx2i32_align16(ptr %pa) #0 {
 181     %va = load <vscale x 2 x i32>, ptr %pa, align 16
 182     ret <vscale x 2 x i32> %va
 183   }
 184
 185   define <vscale x 2 x i32> @vload_nx2i32_align256(ptr %pa) #0 {
 186     %va = load <vscale x 2 x i32>, ptr %pa, align 256
 187     ret <vscale x 2 x i32> %va
 188   }
 189
 190   define <vscale x 2 x i64> @vload_nx2i64_align4(ptr %pa) #0 {
 191     %va = load <vscale x 2 x i64>, ptr %pa, align 4
 192     ret <vscale x 2 x i64> %va
 193   }
 194
 195   define <vscale x 2 x i64> @vload_nx2i64_align8(ptr %pa) #0 {
 196     %va = load <vscale x 2 x i64>, ptr %pa, align 8
 197     ret <vscale x 2 x i64> %va
 198   }
 199
 200   define <vscale x 2 x i64> @vload_nx2i64_align16(ptr %pa) #0 {
 201     %va = load <vscale x 2 x i64>, ptr %pa, align 16
 202     ret <vscale x 2 x i64> %va
 203   }
 204
 205   define <vscale x 2 x i64> @vload_nx2i64_align32(ptr %pa) #0 {
 206     %va = load <vscale x 2 x i64>, ptr %pa, align 32
 207     ret <vscale x 2 x i64> %va
 208   }
 209
 210   define <vscale x 1 x ptr> @vload_nx1ptr(ptr %pa) #0 {
 211     %va = load <vscale x 1 x ptr>, ptr %pa, align 4
 212     ret <vscale x 1 x ptr> %va
 213   }
 214
 215   define <vscale x 2 x ptr> @vload_nx2ptr(ptr %pa) #0 {
 216     %va = load <vscale x 2 x ptr>, ptr %pa, align 8
 217     ret <vscale x 2 x ptr> %va
 218   }
 219
 220   define <vscale x 8 x ptr> @vload_nx8ptr(ptr %pa) #0 {
 221     %va = load <vscale x 8 x ptr>, ptr %pa, align 32
 222     ret <vscale x 8 x ptr> %va
 223   }
 224
 225 ...
 226 ---
 227 name:            vload_nx1i8
 228 legalized:       true
 229 tracksRegLiveness: true
 230 body:             |
 231   bb.1 (%ir-block.0):
 232     liveins: $x10
 233
 234     ; RV32I-LABEL: name: vload_nx1i8
 235     ; RV32I: liveins: $x10
 236     ; RV32I-NEXT: {{  $}}
 237     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 238     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 1 x s8>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 1 x s8>) from %ir.pa)
 239     ; RV32I-NEXT: $v8 = COPY [[LOAD]](<vscale x 1 x s8>)
 240     ; RV32I-NEXT: PseudoRET implicit $v8
 241     ;
 242     ; RV64I-LABEL: name: vload_nx1i8
 243     ; RV64I: liveins: $x10
 244     ; RV64I-NEXT: {{  $}}
 245     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 246     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 1 x s8>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 1 x s8>) from %ir.pa)
 247     ; RV64I-NEXT: $v8 = COPY [[LOAD]](<vscale x 1 x s8>)
 248     ; RV64I-NEXT: PseudoRET implicit $v8
 249     %0:_(p0) = COPY $x10
 250     %1:_(<vscale x 1 x s8>) = G_LOAD %0(p0) :: (load (<vscale x 1 x s8>) from %ir.pa)
 251     $v8 = COPY %1(<vscale x 1 x s8>)
 252     PseudoRET implicit $v8
 253
 254 ...
 255 ---
 256 name:            vload_nx2i8
 257 legalized:       true
 258 tracksRegLiveness: true
 259 body:             |
 260   bb.1 (%ir-block.0):
 261     liveins: $x10
 262
 263     ; RV32I-LABEL: name: vload_nx2i8
 264     ; RV32I: liveins: $x10
 265     ; RV32I-NEXT: {{  $}}
 266     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 267     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 2 x s8>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 2 x s8>) from %ir.pa)
 268     ; RV32I-NEXT: $v8 = COPY [[LOAD]](<vscale x 2 x s8>)
 269     ; RV32I-NEXT: PseudoRET implicit $v8
 270     ;
 271     ; RV64I-LABEL: name: vload_nx2i8
 272     ; RV64I: liveins: $x10
 273     ; RV64I-NEXT: {{  $}}
 274     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 275     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 2 x s8>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 2 x s8>) from %ir.pa)
 276     ; RV64I-NEXT: $v8 = COPY [[LOAD]](<vscale x 2 x s8>)
 277     ; RV64I-NEXT: PseudoRET implicit $v8
 278     %0:_(p0) = COPY $x10
 279     %1:_(<vscale x 2 x s8>) = G_LOAD %0(p0) :: (load (<vscale x 2 x s8>) from %ir.pa)
 280     $v8 = COPY %1(<vscale x 2 x s8>)
 281     PseudoRET implicit $v8
 282
 283 ...
 284 ---
 285 name:            vload_nx4i8
 286 legalized:       true
 287 tracksRegLiveness: true
 288 body:             |
 289   bb.1 (%ir-block.0):
 290     liveins: $x10
 291
 292     ; RV32I-LABEL: name: vload_nx4i8
 293     ; RV32I: liveins: $x10
 294     ; RV32I-NEXT: {{  $}}
 295     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 296     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 4 x s8>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 4 x s8>) from %ir.pa)
 297     ; RV32I-NEXT: $v8 = COPY [[LOAD]](<vscale x 4 x s8>)
 298     ; RV32I-NEXT: PseudoRET implicit $v8
 299     ;
 300     ; RV64I-LABEL: name: vload_nx4i8
 301     ; RV64I: liveins: $x10
 302     ; RV64I-NEXT: {{  $}}
 303     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 304     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 4 x s8>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 4 x s8>) from %ir.pa)
 305     ; RV64I-NEXT: $v8 = COPY [[LOAD]](<vscale x 4 x s8>)
 306     ; RV64I-NEXT: PseudoRET implicit $v8
 307     %0:_(p0) = COPY $x10
 308     %1:_(<vscale x 4 x s8>) = G_LOAD %0(p0) :: (load (<vscale x 4 x s8>) from %ir.pa)
 309     $v8 = COPY %1(<vscale x 4 x s8>)
 310     PseudoRET implicit $v8
 311
 312 ...
 313 ---
 314 name:            vload_nx8i8
 315 legalized:       true
 316 tracksRegLiveness: true
 317 body:             |
 318   bb.1 (%ir-block.0):
 319     liveins: $x10
 320
 321     ; RV32I-LABEL: name: vload_nx8i8
 322     ; RV32I: liveins: $x10
 323     ; RV32I-NEXT: {{  $}}
 324     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 325     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 8 x s8>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 8 x s8>) from %ir.pa)
 326     ; RV32I-NEXT: $v8 = COPY [[LOAD]](<vscale x 8 x s8>)
 327     ; RV32I-NEXT: PseudoRET implicit $v8
 328     ;
 329     ; RV64I-LABEL: name: vload_nx8i8
 330     ; RV64I: liveins: $x10
 331     ; RV64I-NEXT: {{  $}}
 332     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 333     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 8 x s8>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 8 x s8>) from %ir.pa)
 334     ; RV64I-NEXT: $v8 = COPY [[LOAD]](<vscale x 8 x s8>)
 335     ; RV64I-NEXT: PseudoRET implicit $v8
 336     %0:_(p0) = COPY $x10
 337     %1:_(<vscale x 8 x s8>) = G_LOAD %0(p0) :: (load (<vscale x 8 x s8>) from %ir.pa)
 338     $v8 = COPY %1(<vscale x 8 x s8>)
 339     PseudoRET implicit $v8
 340
 341 ...
 342 ---
 343 name:            vload_nx16i8
 344 legalized:       true
 345 tracksRegLiveness: true
 346 body:             |
 347   bb.1 (%ir-block.0):
 348     liveins: $x10
 349
 350     ; RV32I-LABEL: name: vload_nx16i8
 351     ; RV32I: liveins: $x10
 352     ; RV32I-NEXT: {{  $}}
 353     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 354     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 16 x s8>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 16 x s8>) from %ir.pa)
 355     ; RV32I-NEXT: $v8m2 = COPY [[LOAD]](<vscale x 16 x s8>)
 356     ; RV32I-NEXT: PseudoRET implicit $v8m2
 357     ;
 358     ; RV64I-LABEL: name: vload_nx16i8
 359     ; RV64I: liveins: $x10
 360     ; RV64I-NEXT: {{  $}}
 361     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 362     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 16 x s8>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 16 x s8>) from %ir.pa)
 363     ; RV64I-NEXT: $v8m2 = COPY [[LOAD]](<vscale x 16 x s8>)
 364     ; RV64I-NEXT: PseudoRET implicit $v8m2
 365     %0:_(p0) = COPY $x10
 366     %1:_(<vscale x 16 x s8>) = G_LOAD %0(p0) :: (load (<vscale x 16 x s8>) from %ir.pa)
 367     $v8m2 = COPY %1(<vscale x 16 x s8>)
 368     PseudoRET implicit $v8m2
 369
 370 ...
 371 ---
 372 name:            vload_nx32i8
 373 legalized:       true
 374 tracksRegLiveness: true
 375 body:             |
 376   bb.1 (%ir-block.0):
 377     liveins: $x10
 378
 379     ; RV32I-LABEL: name: vload_nx32i8
 380     ; RV32I: liveins: $x10
 381     ; RV32I-NEXT: {{  $}}
 382     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 383     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 32 x s8>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 32 x s8>) from %ir.pa)
 384     ; RV32I-NEXT: $v8m4 = COPY [[LOAD]](<vscale x 32 x s8>)
 385     ; RV32I-NEXT: PseudoRET implicit $v8m4
 386     ;
 387     ; RV64I-LABEL: name: vload_nx32i8
 388     ; RV64I: liveins: $x10
 389     ; RV64I-NEXT: {{  $}}
 390     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 391     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 32 x s8>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 32 x s8>) from %ir.pa)
 392     ; RV64I-NEXT: $v8m4 = COPY [[LOAD]](<vscale x 32 x s8>)
 393     ; RV64I-NEXT: PseudoRET implicit $v8m4
 394     %0:_(p0) = COPY $x10
 395     %1:_(<vscale x 32 x s8>) = G_LOAD %0(p0) :: (load (<vscale x 32 x s8>) from %ir.pa)
 396     $v8m4 = COPY %1(<vscale x 32 x s8>)
 397     PseudoRET implicit $v8m4
 398
 399 ...
 400 ---
 401 name:            vload_nx64i8
 402 legalized:       true
 403 tracksRegLiveness: true
 404 body:             |
 405   bb.1 (%ir-block.0):
 406     liveins: $x10
 407
 408     ; RV32I-LABEL: name: vload_nx64i8
 409     ; RV32I: liveins: $x10
 410     ; RV32I-NEXT: {{  $}}
 411     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 412     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 64 x s8>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 64 x s8>) from %ir.pa)
 413     ; RV32I-NEXT: $v8m8 = COPY [[LOAD]](<vscale x 64 x s8>)
 414     ; RV32I-NEXT: PseudoRET implicit $v8m8
 415     ;
 416     ; RV64I-LABEL: name: vload_nx64i8
 417     ; RV64I: liveins: $x10
 418     ; RV64I-NEXT: {{  $}}
 419     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 420     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 64 x s8>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 64 x s8>) from %ir.pa)
 421     ; RV64I-NEXT: $v8m8 = COPY [[LOAD]](<vscale x 64 x s8>)
 422     ; RV64I-NEXT: PseudoRET implicit $v8m8
 423     %0:_(p0) = COPY $x10
 424     %1:_(<vscale x 64 x s8>) = G_LOAD %0(p0) :: (load (<vscale x 64 x s8>) from %ir.pa)
 425     $v8m8 = COPY %1(<vscale x 64 x s8>)
 426     PseudoRET implicit $v8m8
 427
 428 ...
 429 ---
 430 name:            vload_nx1i16
 431 legalized:       true
 432 tracksRegLiveness: true
 433 body:             |
 434   bb.1 (%ir-block.0):
 435     liveins: $x10
 436
 437     ; RV32I-LABEL: name: vload_nx1i16
 438     ; RV32I: liveins: $x10
 439     ; RV32I-NEXT: {{  $}}
 440     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 441     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 1 x s16>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 1 x s16>) from %ir.pa)
 442     ; RV32I-NEXT: $v8 = COPY [[LOAD]](<vscale x 1 x s16>)
 443     ; RV32I-NEXT: PseudoRET implicit $v8
 444     ;
 445     ; RV64I-LABEL: name: vload_nx1i16
 446     ; RV64I: liveins: $x10
 447     ; RV64I-NEXT: {{  $}}
 448     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 449     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 1 x s16>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 1 x s16>) from %ir.pa)
 450     ; RV64I-NEXT: $v8 = COPY [[LOAD]](<vscale x 1 x s16>)
 451     ; RV64I-NEXT: PseudoRET implicit $v8
 452     %0:_(p0) = COPY $x10
 453     %1:_(<vscale x 1 x s16>) = G_LOAD %0(p0) :: (load (<vscale x 1 x s16>) from %ir.pa)
 454     $v8 = COPY %1(<vscale x 1 x s16>)
 455     PseudoRET implicit $v8
 456
 457 ...
 458 ---
 459 name:            vload_nx2i16
 460 legalized:       true
 461 tracksRegLiveness: true
 462 body:             |
 463   bb.1 (%ir-block.0):
 464     liveins: $x10
 465
 466     ; RV32I-LABEL: name: vload_nx2i16
 467     ; RV32I: liveins: $x10
 468     ; RV32I-NEXT: {{  $}}
 469     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 470     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 2 x s16>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 2 x s16>) from %ir.pa)
 471     ; RV32I-NEXT: $v8 = COPY [[LOAD]](<vscale x 2 x s16>)
 472     ; RV32I-NEXT: PseudoRET implicit $v8
 473     ;
 474     ; RV64I-LABEL: name: vload_nx2i16
 475     ; RV64I: liveins: $x10
 476     ; RV64I-NEXT: {{  $}}
 477     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 478     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 2 x s16>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 2 x s16>) from %ir.pa)
 479     ; RV64I-NEXT: $v8 = COPY [[LOAD]](<vscale x 2 x s16>)
 480     ; RV64I-NEXT: PseudoRET implicit $v8
 481     %0:_(p0) = COPY $x10
 482     %1:_(<vscale x 2 x s16>) = G_LOAD %0(p0) :: (load (<vscale x 2 x s16>) from %ir.pa)
 483     $v8 = COPY %1(<vscale x 2 x s16>)
 484     PseudoRET implicit $v8
 485
 486 ...
 487 ---
 488 name:            vload_nx4i16
 489 legalized:       true
 490 tracksRegLiveness: true
 491 body:             |
 492   bb.1 (%ir-block.0):
 493     liveins: $x10
 494
 495     ; RV32I-LABEL: name: vload_nx4i16
 496     ; RV32I: liveins: $x10
 497     ; RV32I-NEXT: {{  $}}
 498     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 499     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 4 x s16>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 4 x s16>) from %ir.pa)
 500     ; RV32I-NEXT: $v8 = COPY [[LOAD]](<vscale x 4 x s16>)
 501     ; RV32I-NEXT: PseudoRET implicit $v8
 502     ;
 503     ; RV64I-LABEL: name: vload_nx4i16
 504     ; RV64I: liveins: $x10
 505     ; RV64I-NEXT: {{  $}}
 506     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 507     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 4 x s16>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 4 x s16>) from %ir.pa)
 508     ; RV64I-NEXT: $v8 = COPY [[LOAD]](<vscale x 4 x s16>)
 509     ; RV64I-NEXT: PseudoRET implicit $v8
 510     %0:_(p0) = COPY $x10
 511     %1:_(<vscale x 4 x s16>) = G_LOAD %0(p0) :: (load (<vscale x 4 x s16>) from %ir.pa)
 512     $v8 = COPY %1(<vscale x 4 x s16>)
 513     PseudoRET implicit $v8
 514
 515 ...
 516 ---
 517 name:            vload_nx8i16
 518 legalized:       true
 519 tracksRegLiveness: true
 520 body:             |
 521   bb.1 (%ir-block.0):
 522     liveins: $x10
 523
 524     ; RV32I-LABEL: name: vload_nx8i16
 525     ; RV32I: liveins: $x10
 526     ; RV32I-NEXT: {{  $}}
 527     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 528     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 8 x s16>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 8 x s16>) from %ir.pa)
 529     ; RV32I-NEXT: $v8m2 = COPY [[LOAD]](<vscale x 8 x s16>)
 530     ; RV32I-NEXT: PseudoRET implicit $v8m2
 531     ;
 532     ; RV64I-LABEL: name: vload_nx8i16
 533     ; RV64I: liveins: $x10
 534     ; RV64I-NEXT: {{  $}}
 535     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 536     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 8 x s16>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 8 x s16>) from %ir.pa)
 537     ; RV64I-NEXT: $v8m2 = COPY [[LOAD]](<vscale x 8 x s16>)
 538     ; RV64I-NEXT: PseudoRET implicit $v8m2
 539     %0:_(p0) = COPY $x10
 540     %1:_(<vscale x 8 x s16>) = G_LOAD %0(p0) :: (load (<vscale x 8 x s16>) from %ir.pa)
 541     $v8m2 = COPY %1(<vscale x 8 x s16>)
 542     PseudoRET implicit $v8m2
 543
 544 ...
 545 ---
 546 name:            vload_nx16i16
 547 legalized:       true
 548 tracksRegLiveness: true
 549 body:             |
 550   bb.1 (%ir-block.0):
 551     liveins: $x10
 552
 553     ; RV32I-LABEL: name: vload_nx16i16
 554     ; RV32I: liveins: $x10
 555     ; RV32I-NEXT: {{  $}}
 556     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 557     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 16 x s16>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 16 x s16>) from %ir.pa)
 558     ; RV32I-NEXT: $v8m4 = COPY [[LOAD]](<vscale x 16 x s16>)
 559     ; RV32I-NEXT: PseudoRET implicit $v8m4
 560     ;
 561     ; RV64I-LABEL: name: vload_nx16i16
 562     ; RV64I: liveins: $x10
 563     ; RV64I-NEXT: {{  $}}
 564     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 565     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 16 x s16>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 16 x s16>) from %ir.pa)
 566     ; RV64I-NEXT: $v8m4 = COPY [[LOAD]](<vscale x 16 x s16>)
 567     ; RV64I-NEXT: PseudoRET implicit $v8m4
 568     %0:_(p0) = COPY $x10
 569     %1:_(<vscale x 16 x s16>) = G_LOAD %0(p0) :: (load (<vscale x 16 x s16>) from %ir.pa)
 570     $v8m4 = COPY %1(<vscale x 16 x s16>)
 571     PseudoRET implicit $v8m4
 572
 573 ...
 574 ---
 575 name:            vload_nx32i16
 576 legalized:       true
 577 tracksRegLiveness: true
 578 body:             |
 579   bb.1 (%ir-block.0):
 580     liveins: $x10
 581
 582     ; RV32I-LABEL: name: vload_nx32i16
 583     ; RV32I: liveins: $x10
 584     ; RV32I-NEXT: {{  $}}
 585     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 586     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 32 x s16>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 32 x s16>) from %ir.pa)
 587     ; RV32I-NEXT: $v8m8 = COPY [[LOAD]](<vscale x 32 x s16>)
 588     ; RV32I-NEXT: PseudoRET implicit $v8m8
 589     ;
 590     ; RV64I-LABEL: name: vload_nx32i16
 591     ; RV64I: liveins: $x10
 592     ; RV64I-NEXT: {{  $}}
 593     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 594     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 32 x s16>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 32 x s16>) from %ir.pa)
 595     ; RV64I-NEXT: $v8m8 = COPY [[LOAD]](<vscale x 32 x s16>)
 596     ; RV64I-NEXT: PseudoRET implicit $v8m8
 597     %0:_(p0) = COPY $x10
 598     %1:_(<vscale x 32 x s16>) = G_LOAD %0(p0) :: (load (<vscale x 32 x s16>) from %ir.pa)
 599     $v8m8 = COPY %1(<vscale x 32 x s16>)
 600     PseudoRET implicit $v8m8
 601
 602 ...
 603 ---
 604 name:            vload_nx1i32
 605 legalized:       true
 606 tracksRegLiveness: true
 607 body:             |
 608   bb.1 (%ir-block.0):
 609     liveins: $x10
 610
 611     ; RV32I-LABEL: name: vload_nx1i32
 612     ; RV32I: liveins: $x10
 613     ; RV32I-NEXT: {{  $}}
 614     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 615     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 1 x s32>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 1 x s32>) from %ir.pa)
 616     ; RV32I-NEXT: $v8 = COPY [[LOAD]](<vscale x 1 x s32>)
 617     ; RV32I-NEXT: PseudoRET implicit $v8
 618     ;
 619     ; RV64I-LABEL: name: vload_nx1i32
 620     ; RV64I: liveins: $x10
 621     ; RV64I-NEXT: {{  $}}
 622     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 623     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 1 x s32>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 1 x s32>) from %ir.pa)
 624     ; RV64I-NEXT: $v8 = COPY [[LOAD]](<vscale x 1 x s32>)
 625     ; RV64I-NEXT: PseudoRET implicit $v8
 626     %0:_(p0) = COPY $x10
 627     %1:_(<vscale x 1 x s32>) = G_LOAD %0(p0) :: (load (<vscale x 1 x s32>) from %ir.pa)
 628     $v8 = COPY %1(<vscale x 1 x s32>)
 629     PseudoRET implicit $v8
 630
 631 ...
 632 ---
 633 name:            vload_nx2i32
 634 legalized:       true
 635 tracksRegLiveness: true
 636 body:             |
 637   bb.1 (%ir-block.0):
 638     liveins: $x10
 639
 640     ; RV32I-LABEL: name: vload_nx2i32
 641     ; RV32I: liveins: $x10
 642     ; RV32I-NEXT: {{  $}}
 643     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 644     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 2 x s32>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 2 x s32>) from %ir.pa)
 645     ; RV32I-NEXT: $v8 = COPY [[LOAD]](<vscale x 2 x s32>)
 646     ; RV32I-NEXT: PseudoRET implicit $v8
 647     ;
 648     ; RV64I-LABEL: name: vload_nx2i32
 649     ; RV64I: liveins: $x10
 650     ; RV64I-NEXT: {{  $}}
 651     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 652     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 2 x s32>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 2 x s32>) from %ir.pa)
 653     ; RV64I-NEXT: $v8 = COPY [[LOAD]](<vscale x 2 x s32>)
 654     ; RV64I-NEXT: PseudoRET implicit $v8
 655     %0:_(p0) = COPY $x10
 656     %1:_(<vscale x 2 x s32>) = G_LOAD %0(p0) :: (load (<vscale x 2 x s32>) from %ir.pa)
 657     $v8 = COPY %1(<vscale x 2 x s32>)
 658     PseudoRET implicit $v8
 659
 660 ...
 661 ---
 662 name:            vload_nx4i32
 663 legalized:       true
 664 tracksRegLiveness: true
 665 body:             |
 666   bb.1 (%ir-block.0):
 667     liveins: $x10
 668
 669     ; RV32I-LABEL: name: vload_nx4i32
 670     ; RV32I: liveins: $x10
 671     ; RV32I-NEXT: {{  $}}
 672     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 673     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 4 x s32>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 4 x s32>) from %ir.pa)
 674     ; RV32I-NEXT: $v8m2 = COPY [[LOAD]](<vscale x 4 x s32>)
 675     ; RV32I-NEXT: PseudoRET implicit $v8m2
 676     ;
 677     ; RV64I-LABEL: name: vload_nx4i32
 678     ; RV64I: liveins: $x10
 679     ; RV64I-NEXT: {{  $}}
 680     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 681     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 4 x s32>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 4 x s32>) from %ir.pa)
 682     ; RV64I-NEXT: $v8m2 = COPY [[LOAD]](<vscale x 4 x s32>)
 683     ; RV64I-NEXT: PseudoRET implicit $v8m2
 684     %0:_(p0) = COPY $x10
 685     %1:_(<vscale x 4 x s32>) = G_LOAD %0(p0) :: (load (<vscale x 4 x s32>) from %ir.pa)
 686     $v8m2 = COPY %1(<vscale x 4 x s32>)
 687     PseudoRET implicit $v8m2
 688
 689 ...
 690 ---
 691 name:            vload_nx8i32
 692 legalized:       true
 693 tracksRegLiveness: true
 694 body:             |
 695   bb.1 (%ir-block.0):
 696     liveins: $x10
 697
 698     ; RV32I-LABEL: name: vload_nx8i32
 699     ; RV32I: liveins: $x10
 700     ; RV32I-NEXT: {{  $}}
 701     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 702     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 8 x s32>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 8 x s32>) from %ir.pa)
 703     ; RV32I-NEXT: $v8m4 = COPY [[LOAD]](<vscale x 8 x s32>)
 704     ; RV32I-NEXT: PseudoRET implicit $v8m4
 705     ;
 706     ; RV64I-LABEL: name: vload_nx8i32
 707     ; RV64I: liveins: $x10
 708     ; RV64I-NEXT: {{  $}}
 709     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 710     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 8 x s32>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 8 x s32>) from %ir.pa)
 711     ; RV64I-NEXT: $v8m4 = COPY [[LOAD]](<vscale x 8 x s32>)
 712     ; RV64I-NEXT: PseudoRET implicit $v8m4
 713     %0:_(p0) = COPY $x10
 714     %1:_(<vscale x 8 x s32>) = G_LOAD %0(p0) :: (load (<vscale x 8 x s32>) from %ir.pa)
 715     $v8m4 = COPY %1(<vscale x 8 x s32>)
 716     PseudoRET implicit $v8m4
 717
 718 ...
 719 ---
 720 name:            vload_nx16i32
 721 legalized:       true
 722 tracksRegLiveness: true
 723 body:             |
 724   bb.1 (%ir-block.0):
 725     liveins: $x10
 726
 727     ; RV32I-LABEL: name: vload_nx16i32
 728     ; RV32I: liveins: $x10
 729     ; RV32I-NEXT: {{  $}}
 730     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 731     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 16 x s32>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 16 x s32>) from %ir.pa)
 732     ; RV32I-NEXT: $v8m8 = COPY [[LOAD]](<vscale x 16 x s32>)
 733     ; RV32I-NEXT: PseudoRET implicit $v8m8
 734     ;
 735     ; RV64I-LABEL: name: vload_nx16i32
 736     ; RV64I: liveins: $x10
 737     ; RV64I-NEXT: {{  $}}
 738     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 739     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 16 x s32>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 16 x s32>) from %ir.pa)
 740     ; RV64I-NEXT: $v8m8 = COPY [[LOAD]](<vscale x 16 x s32>)
 741     ; RV64I-NEXT: PseudoRET implicit $v8m8
 742     %0:_(p0) = COPY $x10
 743     %1:_(<vscale x 16 x s32>) = G_LOAD %0(p0) :: (load (<vscale x 16 x s32>) from %ir.pa)
 744     $v8m8 = COPY %1(<vscale x 16 x s32>)
 745     PseudoRET implicit $v8m8
 746
 747 ...
 748 ---
 749 name:            vload_nx1i64
 750 legalized:       true
 751 tracksRegLiveness: true
 752 body:             |
 753   bb.1 (%ir-block.0):
 754     liveins: $x10
 755
 756     ; RV32I-LABEL: name: vload_nx1i64
 757     ; RV32I: liveins: $x10
 758     ; RV32I-NEXT: {{  $}}
 759     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 760     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 1 x s64>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 1 x s64>) from %ir.pa)
 761     ; RV32I-NEXT: $v8 = COPY [[LOAD]](<vscale x 1 x s64>)
 762     ; RV32I-NEXT: PseudoRET implicit $v8
 763     ;
 764     ; RV64I-LABEL: name: vload_nx1i64
 765     ; RV64I: liveins: $x10
 766     ; RV64I-NEXT: {{  $}}
 767     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 768     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 1 x s64>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 1 x s64>) from %ir.pa)
 769     ; RV64I-NEXT: $v8 = COPY [[LOAD]](<vscale x 1 x s64>)
 770     ; RV64I-NEXT: PseudoRET implicit $v8
 771     %0:_(p0) = COPY $x10
 772     %1:_(<vscale x 1 x s64>) = G_LOAD %0(p0) :: (load (<vscale x 1 x s64>) from %ir.pa)
 773     $v8 = COPY %1(<vscale x 1 x s64>)
 774     PseudoRET implicit $v8
 775
 776 ...
 777 ---
 778 name:            vload_nx2i64
 779 legalized:       true
 780 tracksRegLiveness: true
 781 body:             |
 782   bb.1 (%ir-block.0):
 783     liveins: $x10
 784
 785     ; RV32I-LABEL: name: vload_nx2i64
 786     ; RV32I: liveins: $x10
 787     ; RV32I-NEXT: {{  $}}
 788     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 789     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 2 x s64>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 2 x s64>) from %ir.pa)
 790     ; RV32I-NEXT: $v8m2 = COPY [[LOAD]](<vscale x 2 x s64>)
 791     ; RV32I-NEXT: PseudoRET implicit $v8m2
 792     ;
 793     ; RV64I-LABEL: name: vload_nx2i64
 794     ; RV64I: liveins: $x10
 795     ; RV64I-NEXT: {{  $}}
 796     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 797     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 2 x s64>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 2 x s64>) from %ir.pa)
 798     ; RV64I-NEXT: $v8m2 = COPY [[LOAD]](<vscale x 2 x s64>)
 799     ; RV64I-NEXT: PseudoRET implicit $v8m2
 800     %0:_(p0) = COPY $x10
 801     %1:_(<vscale x 2 x s64>) = G_LOAD %0(p0) :: (load (<vscale x 2 x s64>) from %ir.pa)
 802     $v8m2 = COPY %1(<vscale x 2 x s64>)
 803     PseudoRET implicit $v8m2
 804
 805 ...
 806 ---
 807 name:            vload_nx4i64
 808 legalized:       true
 809 tracksRegLiveness: true
 810 body:             |
 811   bb.1 (%ir-block.0):
 812     liveins: $x10
 813
 814     ; RV32I-LABEL: name: vload_nx4i64
 815     ; RV32I: liveins: $x10
 816     ; RV32I-NEXT: {{  $}}
 817     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 818     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 4 x s64>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 4 x s64>) from %ir.pa)
 819     ; RV32I-NEXT: $v8m4 = COPY [[LOAD]](<vscale x 4 x s64>)
 820     ; RV32I-NEXT: PseudoRET implicit $v8m4
 821     ;
 822     ; RV64I-LABEL: name: vload_nx4i64
 823     ; RV64I: liveins: $x10
 824     ; RV64I-NEXT: {{  $}}
 825     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 826     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 4 x s64>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 4 x s64>) from %ir.pa)
 827     ; RV64I-NEXT: $v8m4 = COPY [[LOAD]](<vscale x 4 x s64>)
 828     ; RV64I-NEXT: PseudoRET implicit $v8m4
 829     %0:_(p0) = COPY $x10
 830     %1:_(<vscale x 4 x s64>) = G_LOAD %0(p0) :: (load (<vscale x 4 x s64>) from %ir.pa)
 831     $v8m4 = COPY %1(<vscale x 4 x s64>)
 832     PseudoRET implicit $v8m4
 833
 834 ...
 835 ---
 836 name:            vload_nx8i64
 837 legalized:       true
 838 tracksRegLiveness: true
 839 body:             |
 840   bb.1 (%ir-block.0):
 841     liveins: $x10
 842
 843     ; RV32I-LABEL: name: vload_nx8i64
 844     ; RV32I: liveins: $x10
 845     ; RV32I-NEXT: {{  $}}
 846     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 847     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 8 x s64>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 8 x s64>) from %ir.pa)
 848     ; RV32I-NEXT: $v8m8 = COPY [[LOAD]](<vscale x 8 x s64>)
 849     ; RV32I-NEXT: PseudoRET implicit $v8m8
 850     ;
 851     ; RV64I-LABEL: name: vload_nx8i64
 852     ; RV64I: liveins: $x10
 853     ; RV64I-NEXT: {{  $}}
 854     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 855     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 8 x s64>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 8 x s64>) from %ir.pa)
 856     ; RV64I-NEXT: $v8m8 = COPY [[LOAD]](<vscale x 8 x s64>)
 857     ; RV64I-NEXT: PseudoRET implicit $v8m8
 858     %0:_(p0) = COPY $x10
 859     %1:_(<vscale x 8 x s64>) = G_LOAD %0(p0) :: (load (<vscale x 8 x s64>) from %ir.pa)
 860     $v8m8 = COPY %1(<vscale x 8 x s64>)
 861     PseudoRET implicit $v8m8
 862
 863 ...
 864 ---
 865 name:            vload_nx16i8_align1
 866 legalized:       true
 867 tracksRegLiveness: true
 868 body:             |
 869   bb.1 (%ir-block.0):
 870     liveins: $x10
 871
 872     ; RV32I-LABEL: name: vload_nx16i8_align1
 873     ; RV32I: liveins: $x10
 874     ; RV32I-NEXT: {{  $}}
 875     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 876     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 16 x s8>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 16 x s8>) from %ir.pa, align 1)
 877     ; RV32I-NEXT: $v8m2 = COPY [[LOAD]](<vscale x 16 x s8>)
 878     ; RV32I-NEXT: PseudoRET implicit $v8m2
 879     ;
 880     ; RV64I-LABEL: name: vload_nx16i8_align1
 881     ; RV64I: liveins: $x10
 882     ; RV64I-NEXT: {{  $}}
 883     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 884     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 16 x s8>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 16 x s8>) from %ir.pa, align 1)
 885     ; RV64I-NEXT: $v8m2 = COPY [[LOAD]](<vscale x 16 x s8>)
 886     ; RV64I-NEXT: PseudoRET implicit $v8m2
 887     %0:_(p0) = COPY $x10
 888     %1:_(<vscale x 16 x s8>) = G_LOAD %0(p0) :: (load (<vscale x 16 x s8>) from %ir.pa, align 1)
 889     $v8m2 = COPY %1(<vscale x 16 x s8>)
 890     PseudoRET implicit $v8m2
 891
 892 ...
 893 ---
 894 name:            vload_nx16i8_align2
 895 legalized:       true
 896 tracksRegLiveness: true
 897 body:             |
 898   bb.1 (%ir-block.0):
 899     liveins: $x10
 900
 901     ; RV32I-LABEL: name: vload_nx16i8_align2
 902     ; RV32I: liveins: $x10
 903     ; RV32I-NEXT: {{  $}}
 904     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 905     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 16 x s8>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 16 x s8>) from %ir.pa, align 2)
 906     ; RV32I-NEXT: $v8m2 = COPY [[LOAD]](<vscale x 16 x s8>)
 907     ; RV32I-NEXT: PseudoRET implicit $v8m2
 908     ;
 909     ; RV64I-LABEL: name: vload_nx16i8_align2
 910     ; RV64I: liveins: $x10
 911     ; RV64I-NEXT: {{  $}}
 912     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 913     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 16 x s8>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 16 x s8>) from %ir.pa, align 2)
 914     ; RV64I-NEXT: $v8m2 = COPY [[LOAD]](<vscale x 16 x s8>)
 915     ; RV64I-NEXT: PseudoRET implicit $v8m2
 916     %0:_(p0) = COPY $x10
 917     %1:_(<vscale x 16 x s8>) = G_LOAD %0(p0) :: (load (<vscale x 16 x s8>) from %ir.pa, align 2)
 918     $v8m2 = COPY %1(<vscale x 16 x s8>)
 919     PseudoRET implicit $v8m2
 920
 921 ...
 922 ---
 923 name:            vload_nx16i8_align16
 924 legalized:       true
 925 tracksRegLiveness: true
 926 body:             |
 927   bb.1 (%ir-block.0):
 928     liveins: $x10
 929
 930     ; RV32I-LABEL: name: vload_nx16i8_align16
 931     ; RV32I: liveins: $x10
 932     ; RV32I-NEXT: {{  $}}
 933     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 934     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 16 x s8>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 16 x s8>) from %ir.pa)
 935     ; RV32I-NEXT: $v8m2 = COPY [[LOAD]](<vscale x 16 x s8>)
 936     ; RV32I-NEXT: PseudoRET implicit $v8m2
 937     ;
 938     ; RV64I-LABEL: name: vload_nx16i8_align16
 939     ; RV64I: liveins: $x10
 940     ; RV64I-NEXT: {{  $}}
 941     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 942     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 16 x s8>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 16 x s8>) from %ir.pa)
 943     ; RV64I-NEXT: $v8m2 = COPY [[LOAD]](<vscale x 16 x s8>)
 944     ; RV64I-NEXT: PseudoRET implicit $v8m2
 945     %0:_(p0) = COPY $x10
 946     %1:_(<vscale x 16 x s8>) = G_LOAD %0(p0) :: (load (<vscale x 16 x s8>) from %ir.pa)
 947     $v8m2 = COPY %1(<vscale x 16 x s8>)
 948     PseudoRET implicit $v8m2
 949
 950 ...
 951 ---
 952 name:            vload_nx16i8_align64
 953 legalized:       true
 954 tracksRegLiveness: true
 955 body:             |
 956   bb.1 (%ir-block.0):
 957     liveins: $x10
 958
 959     ; RV32I-LABEL: name: vload_nx16i8_align64
 960     ; RV32I: liveins: $x10
 961     ; RV32I-NEXT: {{  $}}
 962     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 963     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 16 x s8>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 16 x s8>) from %ir.pa, align 64)
 964     ; RV32I-NEXT: $v8m2 = COPY [[LOAD]](<vscale x 16 x s8>)
 965     ; RV32I-NEXT: PseudoRET implicit $v8m2
 966     ;
 967     ; RV64I-LABEL: name: vload_nx16i8_align64
 968     ; RV64I: liveins: $x10
 969     ; RV64I-NEXT: {{  $}}
 970     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 971     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 16 x s8>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 16 x s8>) from %ir.pa, align 64)
 972     ; RV64I-NEXT: $v8m2 = COPY [[LOAD]](<vscale x 16 x s8>)
 973     ; RV64I-NEXT: PseudoRET implicit $v8m2
 974     %0:_(p0) = COPY $x10
 975     %1:_(<vscale x 16 x s8>) = G_LOAD %0(p0) :: (load (<vscale x 16 x s8>) from %ir.pa, align 64)
 976     $v8m2 = COPY %1(<vscale x 16 x s8>)
 977     PseudoRET implicit $v8m2
 978
 979 ...
 980 ---
 981 name:            vload_nx4i16_align1
 982 legalized:       true
 983 tracksRegLiveness: true
 984 body:             |
 985   bb.1 (%ir-block.0):
 986     liveins: $x10
 987
 988     ; RV32I-LABEL: name: vload_nx4i16_align1
 989     ; RV32I: liveins: $x10
 990     ; RV32I-NEXT: {{  $}}
 991     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
 992     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 8 x s8>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 8 x s8>) from %ir.pa, align 1)
 993     ; RV32I-NEXT: [[BITCAST:%[0-9]+]]:vrb(<vscale x 4 x s16>) = G_BITCAST [[LOAD]](<vscale x 8 x s8>)
 994     ; RV32I-NEXT: $v8 = COPY [[BITCAST]](<vscale x 4 x s16>)
 995     ; RV32I-NEXT: PseudoRET implicit $v8
 996     ;
 997     ; RV64I-LABEL: name: vload_nx4i16_align1
 998     ; RV64I: liveins: $x10
 999     ; RV64I-NEXT: {{  $}}
1000     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
1001     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 8 x s8>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 8 x s8>) from %ir.pa, align 1)
1002     ; RV64I-NEXT: [[BITCAST:%[0-9]+]]:vrb(<vscale x 4 x s16>) = G_BITCAST [[LOAD]](<vscale x 8 x s8>)
1003     ; RV64I-NEXT: $v8 = COPY [[BITCAST]](<vscale x 4 x s16>)
1004     ; RV64I-NEXT: PseudoRET implicit $v8
1005     %0:_(p0) = COPY $x10
1006     %2:_(<vscale x 8 x s8>) = G_LOAD %0(p0) :: (load (<vscale x 8 x s8>) from %ir.pa, align 1)
1007     %1:_(<vscale x 4 x s16>) = G_BITCAST %2(<vscale x 8 x s8>)
1008     $v8 = COPY %1(<vscale x 4 x s16>)
1009     PseudoRET implicit $v8
1010
1011 ...
1012 ---
1013 name:            vload_nx4i16_align2
1014 legalized:       true
1015 tracksRegLiveness: true
1016 body:             |
1017   bb.1 (%ir-block.0):
1018     liveins: $x10
1019
1020     ; RV32I-LABEL: name: vload_nx4i16_align2
1021     ; RV32I: liveins: $x10
1022     ; RV32I-NEXT: {{  $}}
1023     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
1024     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 4 x s16>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 4 x s16>) from %ir.pa, align 2)
1025     ; RV32I-NEXT: $v8 = COPY [[LOAD]](<vscale x 4 x s16>)
1026     ; RV32I-NEXT: PseudoRET implicit $v8
1027     ;
1028     ; RV64I-LABEL: name: vload_nx4i16_align2
1029     ; RV64I: liveins: $x10
1030     ; RV64I-NEXT: {{  $}}
1031     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
1032     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 4 x s16>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 4 x s16>) from %ir.pa, align 2)
1033     ; RV64I-NEXT: $v8 = COPY [[LOAD]](<vscale x 4 x s16>)
1034     ; RV64I-NEXT: PseudoRET implicit $v8
1035     %0:_(p0) = COPY $x10
1036     %1:_(<vscale x 4 x s16>) = G_LOAD %0(p0) :: (load (<vscale x 4 x s16>) from %ir.pa, align 2)
1037     $v8 = COPY %1(<vscale x 4 x s16>)
1038     PseudoRET implicit $v8
1039
1040 ...
1041 ---
1042 name:            vload_nx4i16_align4
1043 legalized:       true
1044 tracksRegLiveness: true
1045 body:             |
1046   bb.1 (%ir-block.0):
1047     liveins: $x10
1048
1049     ; RV32I-LABEL: name: vload_nx4i16_align4
1050     ; RV32I: liveins: $x10
1051     ; RV32I-NEXT: {{  $}}
1052     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
1053     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 4 x s16>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 4 x s16>) from %ir.pa, align 4)
1054     ; RV32I-NEXT: $v8 = COPY [[LOAD]](<vscale x 4 x s16>)
1055     ; RV32I-NEXT: PseudoRET implicit $v8
1056     ;
1057     ; RV64I-LABEL: name: vload_nx4i16_align4
1058     ; RV64I: liveins: $x10
1059     ; RV64I-NEXT: {{  $}}
1060     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
1061     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 4 x s16>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 4 x s16>) from %ir.pa, align 4)
1062     ; RV64I-NEXT: $v8 = COPY [[LOAD]](<vscale x 4 x s16>)
1063     ; RV64I-NEXT: PseudoRET implicit $v8
1064     %0:_(p0) = COPY $x10
1065     %1:_(<vscale x 4 x s16>) = G_LOAD %0(p0) :: (load (<vscale x 4 x s16>) from %ir.pa, align 4)
1066     $v8 = COPY %1(<vscale x 4 x s16>)
1067     PseudoRET implicit $v8
1068
1069 ...
1070 ---
1071 name:            vload_nx4i16_align8
1072 legalized:       true
1073 tracksRegLiveness: true
1074 body:             |
1075   bb.1 (%ir-block.0):
1076     liveins: $x10
1077
1078     ; RV32I-LABEL: name: vload_nx4i16_align8
1079     ; RV32I: liveins: $x10
1080     ; RV32I-NEXT: {{  $}}
1081     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
1082     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 4 x s16>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 4 x s16>) from %ir.pa)
1083     ; RV32I-NEXT: $v8 = COPY [[LOAD]](<vscale x 4 x s16>)
1084     ; RV32I-NEXT: PseudoRET implicit $v8
1085     ;
1086     ; RV64I-LABEL: name: vload_nx4i16_align8
1087     ; RV64I: liveins: $x10
1088     ; RV64I-NEXT: {{  $}}
1089     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
1090     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 4 x s16>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 4 x s16>) from %ir.pa)
1091     ; RV64I-NEXT: $v8 = COPY [[LOAD]](<vscale x 4 x s16>)
1092     ; RV64I-NEXT: PseudoRET implicit $v8
1093     %0:_(p0) = COPY $x10
1094     %1:_(<vscale x 4 x s16>) = G_LOAD %0(p0) :: (load (<vscale x 4 x s16>) from %ir.pa)
1095     $v8 = COPY %1(<vscale x 4 x s16>)
1096     PseudoRET implicit $v8
1097
1098 ...
1099 ---
1100 name:            vload_nx4i16_align16
1101 legalized:       true
1102 tracksRegLiveness: true
1103 body:             |
1104   bb.1 (%ir-block.0):
1105     liveins: $x10
1106
1107     ; RV32I-LABEL: name: vload_nx4i16_align16
1108     ; RV32I: liveins: $x10
1109     ; RV32I-NEXT: {{  $}}
1110     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
1111     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 4 x s16>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 4 x s16>) from %ir.pa, align 16)
1112     ; RV32I-NEXT: $v8 = COPY [[LOAD]](<vscale x 4 x s16>)
1113     ; RV32I-NEXT: PseudoRET implicit $v8
1114     ;
1115     ; RV64I-LABEL: name: vload_nx4i16_align16
1116     ; RV64I: liveins: $x10
1117     ; RV64I-NEXT: {{  $}}
1118     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
1119     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 4 x s16>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 4 x s16>) from %ir.pa, align 16)
1120     ; RV64I-NEXT: $v8 = COPY [[LOAD]](<vscale x 4 x s16>)
1121     ; RV64I-NEXT: PseudoRET implicit $v8
1122     %0:_(p0) = COPY $x10
1123     %1:_(<vscale x 4 x s16>) = G_LOAD %0(p0) :: (load (<vscale x 4 x s16>) from %ir.pa, align 16)
1124     $v8 = COPY %1(<vscale x 4 x s16>)
1125     PseudoRET implicit $v8
1126
1127 ...
1128 ---
1129 name:            vload_nx2i32_align2
1130 legalized:       true
1131 tracksRegLiveness: true
1132 body:             |
1133   bb.1 (%ir-block.0):
1134     liveins: $x10
1135
1136     ; RV32I-LABEL: name: vload_nx2i32_align2
1137     ; RV32I: liveins: $x10
1138     ; RV32I-NEXT: {{  $}}
1139     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
1140     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 8 x s8>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 8 x s8>) from %ir.pa, align 2)
1141     ; RV32I-NEXT: [[BITCAST:%[0-9]+]]:vrb(<vscale x 2 x s32>) = G_BITCAST [[LOAD]](<vscale x 8 x s8>)
1142     ; RV32I-NEXT: $v8 = COPY [[BITCAST]](<vscale x 2 x s32>)
1143     ; RV32I-NEXT: PseudoRET implicit $v8
1144     ;
1145     ; RV64I-LABEL: name: vload_nx2i32_align2
1146     ; RV64I: liveins: $x10
1147     ; RV64I-NEXT: {{  $}}
1148     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
1149     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 8 x s8>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 8 x s8>) from %ir.pa, align 2)
1150     ; RV64I-NEXT: [[BITCAST:%[0-9]+]]:vrb(<vscale x 2 x s32>) = G_BITCAST [[LOAD]](<vscale x 8 x s8>)
1151     ; RV64I-NEXT: $v8 = COPY [[BITCAST]](<vscale x 2 x s32>)
1152     ; RV64I-NEXT: PseudoRET implicit $v8
1153     %0:_(p0) = COPY $x10
1154     %2:_(<vscale x 8 x s8>) = G_LOAD %0(p0) :: (load (<vscale x 8 x s8>) from %ir.pa, align 2)
1155     %1:_(<vscale x 2 x s32>) = G_BITCAST %2(<vscale x 8 x s8>)
1156     $v8 = COPY %1(<vscale x 2 x s32>)
1157     PseudoRET implicit $v8
1158
1159 ...
1160 ---
1161 name:            vload_nx2i32_align4
1162 legalized:       true
1163 tracksRegLiveness: true
1164 body:             |
1165   bb.1 (%ir-block.0):
1166     liveins: $x10
1167
1168     ; RV32I-LABEL: name: vload_nx2i32_align4
1169     ; RV32I: liveins: $x10
1170     ; RV32I-NEXT: {{  $}}
1171     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
1172     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 2 x s32>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 2 x s32>) from %ir.pa, align 4)
1173     ; RV32I-NEXT: $v8 = COPY [[LOAD]](<vscale x 2 x s32>)
1174     ; RV32I-NEXT: PseudoRET implicit $v8
1175     ;
1176     ; RV64I-LABEL: name: vload_nx2i32_align4
1177     ; RV64I: liveins: $x10
1178     ; RV64I-NEXT: {{  $}}
1179     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
1180     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 2 x s32>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 2 x s32>) from %ir.pa, align 4)
1181     ; RV64I-NEXT: $v8 = COPY [[LOAD]](<vscale x 2 x s32>)
1182     ; RV64I-NEXT: PseudoRET implicit $v8
1183     %0:_(p0) = COPY $x10
1184     %1:_(<vscale x 2 x s32>) = G_LOAD %0(p0) :: (load (<vscale x 2 x s32>) from %ir.pa, align 4)
1185     $v8 = COPY %1(<vscale x 2 x s32>)
1186     PseudoRET implicit $v8
1187
1188 ...
1189 ---
1190 name:            vload_nx2i32_align8
1191 legalized:       true
1192 tracksRegLiveness: true
1193 body:             |
1194   bb.1 (%ir-block.0):
1195     liveins: $x10
1196
1197     ; RV32I-LABEL: name: vload_nx2i32_align8
1198     ; RV32I: liveins: $x10
1199     ; RV32I-NEXT: {{  $}}
1200     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
1201     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 2 x s32>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 2 x s32>) from %ir.pa)
1202     ; RV32I-NEXT: $v8 = COPY [[LOAD]](<vscale x 2 x s32>)
1203     ; RV32I-NEXT: PseudoRET implicit $v8
1204     ;
1205     ; RV64I-LABEL: name: vload_nx2i32_align8
1206     ; RV64I: liveins: $x10
1207     ; RV64I-NEXT: {{  $}}
1208     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
1209     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 2 x s32>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 2 x s32>) from %ir.pa)
1210     ; RV64I-NEXT: $v8 = COPY [[LOAD]](<vscale x 2 x s32>)
1211     ; RV64I-NEXT: PseudoRET implicit $v8
1212     %0:_(p0) = COPY $x10
1213     %1:_(<vscale x 2 x s32>) = G_LOAD %0(p0) :: (load (<vscale x 2 x s32>) from %ir.pa)
1214     $v8 = COPY %1(<vscale x 2 x s32>)
1215     PseudoRET implicit $v8
1216
1217 ...
1218 ---
1219 name:            vload_nx2i32_align16
1220 legalized:       true
1221 tracksRegLiveness: true
1222 body:             |
1223   bb.1 (%ir-block.0):
1224     liveins: $x10
1225
1226     ; RV32I-LABEL: name: vload_nx2i32_align16
1227     ; RV32I: liveins: $x10
1228     ; RV32I-NEXT: {{  $}}
1229     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
1230     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 2 x s32>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 2 x s32>) from %ir.pa, align 16)
1231     ; RV32I-NEXT: $v8 = COPY [[LOAD]](<vscale x 2 x s32>)
1232     ; RV32I-NEXT: PseudoRET implicit $v8
1233     ;
1234     ; RV64I-LABEL: name: vload_nx2i32_align16
1235     ; RV64I: liveins: $x10
1236     ; RV64I-NEXT: {{  $}}
1237     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
1238     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 2 x s32>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 2 x s32>) from %ir.pa, align 16)
1239     ; RV64I-NEXT: $v8 = COPY [[LOAD]](<vscale x 2 x s32>)
1240     ; RV64I-NEXT: PseudoRET implicit $v8
1241     %0:_(p0) = COPY $x10
1242     %1:_(<vscale x 2 x s32>) = G_LOAD %0(p0) :: (load (<vscale x 2 x s32>) from %ir.pa, align 16)
1243     $v8 = COPY %1(<vscale x 2 x s32>)
1244     PseudoRET implicit $v8
1245
1246 ...
1247 ---
1248 name:            vload_nx2i32_align256
1249 legalized:       true
1250 tracksRegLiveness: true
1251 body:             |
1252   bb.1 (%ir-block.0):
1253     liveins: $x10
1254
1255     ; RV32I-LABEL: name: vload_nx2i32_align256
1256     ; RV32I: liveins: $x10
1257     ; RV32I-NEXT: {{  $}}
1258     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
1259     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 2 x s32>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 2 x s32>) from %ir.pa, align 256)
1260     ; RV32I-NEXT: $v8 = COPY [[LOAD]](<vscale x 2 x s32>)
1261     ; RV32I-NEXT: PseudoRET implicit $v8
1262     ;
1263     ; RV64I-LABEL: name: vload_nx2i32_align256
1264     ; RV64I: liveins: $x10
1265     ; RV64I-NEXT: {{  $}}
1266     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
1267     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 2 x s32>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 2 x s32>) from %ir.pa, align 256)
1268     ; RV64I-NEXT: $v8 = COPY [[LOAD]](<vscale x 2 x s32>)
1269     ; RV64I-NEXT: PseudoRET implicit $v8
1270     %0:_(p0) = COPY $x10
1271     %1:_(<vscale x 2 x s32>) = G_LOAD %0(p0) :: (load (<vscale x 2 x s32>) from %ir.pa, align 256)
1272     $v8 = COPY %1(<vscale x 2 x s32>)
1273     PseudoRET implicit $v8
1274
1275 ...
1276 ---
1277 name:            vload_nx2i64_align4
1278 legalized:       true
1279 tracksRegLiveness: true
1280 body:             |
1281   bb.1 (%ir-block.0):
1282     liveins: $x10
1283
1284     ; RV32I-LABEL: name: vload_nx2i64_align4
1285     ; RV32I: liveins: $x10
1286     ; RV32I-NEXT: {{  $}}
1287     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
1288     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 16 x s8>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 16 x s8>) from %ir.pa, align 4)
1289     ; RV32I-NEXT: [[BITCAST:%[0-9]+]]:vrb(<vscale x 2 x s64>) = G_BITCAST [[LOAD]](<vscale x 16 x s8>)
1290     ; RV32I-NEXT: $v8m2 = COPY [[BITCAST]](<vscale x 2 x s64>)
1291     ; RV32I-NEXT: PseudoRET implicit $v8m2
1292     ;
1293     ; RV64I-LABEL: name: vload_nx2i64_align4
1294     ; RV64I: liveins: $x10
1295     ; RV64I-NEXT: {{  $}}
1296     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
1297     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 16 x s8>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 16 x s8>) from %ir.pa, align 4)
1298     ; RV64I-NEXT: [[BITCAST:%[0-9]+]]:vrb(<vscale x 2 x s64>) = G_BITCAST [[LOAD]](<vscale x 16 x s8>)
1299     ; RV64I-NEXT: $v8m2 = COPY [[BITCAST]](<vscale x 2 x s64>)
1300     ; RV64I-NEXT: PseudoRET implicit $v8m2
1301     %0:_(p0) = COPY $x10
1302     %2:_(<vscale x 16 x s8>) = G_LOAD %0(p0) :: (load (<vscale x 16 x s8>) from %ir.pa, align 4)
1303     %1:_(<vscale x 2 x s64>) = G_BITCAST %2(<vscale x 16 x s8>)
1304     $v8m2 = COPY %1(<vscale x 2 x s64>)
1305     PseudoRET implicit $v8m2
1306
1307 ...
1308 ---
1309 name:            vload_nx2i64_align8
1310 legalized:       true
1311 tracksRegLiveness: true
1312 body:             |
1313   bb.1 (%ir-block.0):
1314     liveins: $x10
1315
1316     ; RV32I-LABEL: name: vload_nx2i64_align8
1317     ; RV32I: liveins: $x10
1318     ; RV32I-NEXT: {{  $}}
1319     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
1320     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 2 x s64>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 2 x s64>) from %ir.pa, align 8)
1321     ; RV32I-NEXT: $v8m2 = COPY [[LOAD]](<vscale x 2 x s64>)
1322     ; RV32I-NEXT: PseudoRET implicit $v8m2
1323     ;
1324     ; RV64I-LABEL: name: vload_nx2i64_align8
1325     ; RV64I: liveins: $x10
1326     ; RV64I-NEXT: {{  $}}
1327     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
1328     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 2 x s64>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 2 x s64>) from %ir.pa, align 8)
1329     ; RV64I-NEXT: $v8m2 = COPY [[LOAD]](<vscale x 2 x s64>)
1330     ; RV64I-NEXT: PseudoRET implicit $v8m2
1331     %0:_(p0) = COPY $x10
1332     %1:_(<vscale x 2 x s64>) = G_LOAD %0(p0) :: (load (<vscale x 2 x s64>) from %ir.pa, align 8)
1333     $v8m2 = COPY %1(<vscale x 2 x s64>)
1334     PseudoRET implicit $v8m2
1335
1336 ...
1337 ---
1338 name:            vload_nx2i64_align16
1339 legalized:       true
1340 tracksRegLiveness: true
1341 body:             |
1342   bb.1 (%ir-block.0):
1343     liveins: $x10
1344
1345     ; RV32I-LABEL: name: vload_nx2i64_align16
1346     ; RV32I: liveins: $x10
1347     ; RV32I-NEXT: {{  $}}
1348     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
1349     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 2 x s64>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 2 x s64>) from %ir.pa)
1350     ; RV32I-NEXT: $v8m2 = COPY [[LOAD]](<vscale x 2 x s64>)
1351     ; RV32I-NEXT: PseudoRET implicit $v8m2
1352     ;
1353     ; RV64I-LABEL: name: vload_nx2i64_align16
1354     ; RV64I: liveins: $x10
1355     ; RV64I-NEXT: {{  $}}
1356     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
1357     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 2 x s64>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 2 x s64>) from %ir.pa)
1358     ; RV64I-NEXT: $v8m2 = COPY [[LOAD]](<vscale x 2 x s64>)
1359     ; RV64I-NEXT: PseudoRET implicit $v8m2
1360     %0:_(p0) = COPY $x10
1361     %1:_(<vscale x 2 x s64>) = G_LOAD %0(p0) :: (load (<vscale x 2 x s64>) from %ir.pa)
1362     $v8m2 = COPY %1(<vscale x 2 x s64>)
1363     PseudoRET implicit $v8m2
1364
1365 ...
1366 ---
1367 name:            vload_nx2i64_align32
1368 legalized:       true
1369 tracksRegLiveness: true
1370 body:             |
1371   bb.1 (%ir-block.0):
1372     liveins: $x10
1373
1374     ; RV32I-LABEL: name: vload_nx2i64_align32
1375     ; RV32I: liveins: $x10
1376     ; RV32I-NEXT: {{  $}}
1377     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
1378     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 2 x s64>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 2 x s64>) from %ir.pa, align 32)
1379     ; RV32I-NEXT: $v8m2 = COPY [[LOAD]](<vscale x 2 x s64>)
1380     ; RV32I-NEXT: PseudoRET implicit $v8m2
1381     ;
1382     ; RV64I-LABEL: name: vload_nx2i64_align32
1383     ; RV64I: liveins: $x10
1384     ; RV64I-NEXT: {{  $}}
1385     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
1386     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 2 x s64>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 2 x s64>) from %ir.pa, align 32)
1387     ; RV64I-NEXT: $v8m2 = COPY [[LOAD]](<vscale x 2 x s64>)
1388     ; RV64I-NEXT: PseudoRET implicit $v8m2
1389     %0:_(p0) = COPY $x10
1390     %1:_(<vscale x 2 x s64>) = G_LOAD %0(p0) :: (load (<vscale x 2 x s64>) from %ir.pa, align 32)
1391     $v8m2 = COPY %1(<vscale x 2 x s64>)
1392     PseudoRET implicit $v8m2
1393
1394 ...
1395 ---
1396 name:            vload_nx1ptr
1397 legalized:       true
1398 tracksRegLiveness: true
1399 body:             |
1400   bb.1 (%ir-block.0):
1401     liveins: $x10
1402
1403     ; RV32I-LABEL: name: vload_nx1ptr
1404     ; RV32I: liveins: $x10
1405     ; RV32I-NEXT: {{  $}}
1406     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
1407     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 1 x p0>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 1 x p0>) from %ir.pa)
1408     ; RV32I-NEXT: $v8 = COPY [[LOAD]](<vscale x 1 x p0>)
1409     ; RV32I-NEXT: PseudoRET implicit $v8
1410     ;
1411     ; RV64I-LABEL: name: vload_nx1ptr
1412     ; RV64I: liveins: $x10
1413     ; RV64I-NEXT: {{  $}}
1414     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
1415     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 1 x p0>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 1 x p0>) from %ir.pa)
1416     ; RV64I-NEXT: $v8 = COPY [[LOAD]](<vscale x 1 x p0>)
1417     ; RV64I-NEXT: PseudoRET implicit $v8
1418     %0:_(p0) = COPY $x10
1419     %1:_(<vscale x 1 x p0>) = G_LOAD %0(p0) :: (load (<vscale x 1 x p0>) from %ir.pa)
1420     $v8 = COPY %1(<vscale x 1 x p0>)
1421     PseudoRET implicit $v8
1422
1423 ...
1424 ---
1425 name:            vload_nx2ptr
1426 legalized:       true
1427 tracksRegLiveness: true
1428 body:             |
1429   bb.1 (%ir-block.0):
1430     liveins: $x10
1431
1432     ; RV32I-LABEL: name: vload_nx2ptr
1433     ; RV32I: liveins: $x10
1434     ; RV32I-NEXT: {{  $}}
1435     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
1436     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 2 x p0>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 2 x p0>) from %ir.pa)
1437     ; RV32I-NEXT: $v8 = COPY [[LOAD]](<vscale x 2 x p0>)
1438     ; RV32I-NEXT: PseudoRET implicit $v8
1439     ;
1440     ; RV64I-LABEL: name: vload_nx2ptr
1441     ; RV64I: liveins: $x10
1442     ; RV64I-NEXT: {{  $}}
1443     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
1444     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 2 x p0>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 2 x p0>) from %ir.pa)
1445     ; RV64I-NEXT: $v8 = COPY [[LOAD]](<vscale x 2 x p0>)
1446     ; RV64I-NEXT: PseudoRET implicit $v8
1447     %0:_(p0) = COPY $x10
1448     %1:_(<vscale x 2 x p0>) = G_LOAD %0(p0) :: (load (<vscale x 2 x p0>) from %ir.pa)
1449     $v8 = COPY %1(<vscale x 2 x p0>)
1450     PseudoRET implicit $v8
1451
1452 ...
1453 ---
1454 name:            vload_nx8ptr
1455 legalized:       true
1456 tracksRegLiveness: true
1457 body:             |
1458   bb.1 (%ir-block.0):
1459     liveins: $x10
1460
1461     ; RV32I-LABEL: name: vload_nx8ptr
1462     ; RV32I: liveins: $x10
1463     ; RV32I-NEXT: {{  $}}
1464     ; RV32I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
1465     ; RV32I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 8 x p0>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 8 x p0>) from %ir.pa)
1466     ; RV32I-NEXT: $v8m4 = COPY [[LOAD]](<vscale x 8 x p0>)
1467     ; RV32I-NEXT: PseudoRET implicit $v8m4
1468     ;
1469     ; RV64I-LABEL: name: vload_nx8ptr
1470     ; RV64I: liveins: $x10
1471     ; RV64I-NEXT: {{  $}}
1472     ; RV64I-NEXT: [[COPY:%[0-9]+]]:gprb(p0) = COPY $x10
1473     ; RV64I-NEXT: [[LOAD:%[0-9]+]]:vrb(<vscale x 8 x p0>) = G_LOAD [[COPY]](p0) :: (load (<vscale x 8 x p0>) from %ir.pa)
1474     ; RV64I-NEXT: $v8m4 = COPY [[LOAD]](<vscale x 8 x p0>)
1475     ; RV64I-NEXT: PseudoRET implicit $v8m4
1476     %0:_(p0) = COPY $x10
1477     %1:_(<vscale x 8 x p0>) = G_LOAD %0(p0) :: (load (<vscale x 8 x p0>) from %ir.pa)
1478     $v8m4 = COPY %1(<vscale x 8 x p0>)
1479     PseudoRET implicit $v8m4
1480
1481 ...