llvm/test/CodeGen/RISCV/rvv/vminu-vp.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
   2 ; RUN: llc -mtriple=riscv32 -mattr=+v -verify-machineinstrs < %s \
   3 ; RUN:   | FileCheck %s --check-prefixes=CHECK,RV32
   4 ; RUN: llc -mtriple=riscv64 -mattr=+v -verify-machineinstrs < %s \
   5 ; RUN:   | FileCheck %s --check-prefixes=CHECK,RV64
   6
   7 declare <vscale x 8 x i7> @llvm.vp.umin.nxv8i7(<vscale x 8 x i7>, <vscale x 8 x i7>, <vscale x 8 x i1>, i32)
   8
   9 define <vscale x 8 x i7> @vminu_vx_nxv8i7(<vscale x 8 x i7> %a, i7 signext %b, <vscale x 8 x i1> %mask, i32 zeroext %evl) {
  10 ; CHECK-LABEL: vminu_vx_nxv8i7:
  11 ; CHECK:       # %bb.0:
  12 ; CHECK-NEXT:    li a2, 127
  13 ; CHECK-NEXT:    vsetvli zero, a1, e8, m1, ta, ma
  14 ; CHECK-NEXT:    vand.vx v8, v8, a2, v0.t
  15 ; CHECK-NEXT:    vsetvli a3, zero, e8, m1, ta, ma
  16 ; CHECK-NEXT:    vmv.v.x v9, a0
  17 ; CHECK-NEXT:    vsetvli zero, a1, e8, m1, ta, ma
  18 ; CHECK-NEXT:    vand.vx v9, v9, a2, v0.t
  19 ; CHECK-NEXT:    vminu.vv v8, v8, v9, v0.t
  20 ; CHECK-NEXT:    ret
  21   %elt.head = insertelement <vscale x 8 x i7> poison, i7 %b, i32 0
  22   %vb = shufflevector <vscale x 8 x i7> %elt.head, <vscale x 8 x i7> poison, <vscale x 8 x i32> zeroinitializer
  23   %v = call <vscale x 8 x i7> @llvm.vp.umin.nxv8i7(<vscale x 8 x i7> %a, <vscale x 8 x i7> %vb, <vscale x 8 x i1> %mask, i32 %evl)
  24   ret <vscale x 8 x i7> %v
  25 }
  26
  27 declare <vscale x 1 x i8> @llvm.vp.umin.nxv1i8(<vscale x 1 x i8>, <vscale x 1 x i8>, <vscale x 1 x i1>, i32)
  28
  29 define <vscale x 1 x i8> @vminu_vv_nxv1i8(<vscale x 1 x i8> %va, <vscale x 1 x i8> %b, <vscale x 1 x i1> %m, i32 zeroext %evl) {
  30 ; CHECK-LABEL: vminu_vv_nxv1i8:
  31 ; CHECK:       # %bb.0:
  32 ; CHECK-NEXT:    vsetvli zero, a0, e8, mf8, ta, ma
  33 ; CHECK-NEXT:    vminu.vv v8, v8, v9, v0.t
  34 ; CHECK-NEXT:    ret
  35   %v = call <vscale x 1 x i8> @llvm.vp.umin.nxv1i8(<vscale x 1 x i8> %va, <vscale x 1 x i8> %b, <vscale x 1 x i1> %m, i32 %evl)
  36   ret <vscale x 1 x i8> %v
  37 }
  38
  39 define <vscale x 1 x i8> @vminu_vv_nxv1i8_unmasked(<vscale x 1 x i8> %va, <vscale x 1 x i8> %b, i32 zeroext %evl) {
  40 ; CHECK-LABEL: vminu_vv_nxv1i8_unmasked:
  41 ; CHECK:       # %bb.0:
  42 ; CHECK-NEXT:    vsetvli zero, a0, e8, mf8, ta, ma
  43 ; CHECK-NEXT:    vminu.vv v8, v8, v9
  44 ; CHECK-NEXT:    ret
  45   %v = call <vscale x 1 x i8> @llvm.vp.umin.nxv1i8(<vscale x 1 x i8> %va, <vscale x 1 x i8> %b, <vscale x 1 x i1> splat (i1 true), i32 %evl)
  46   ret <vscale x 1 x i8> %v
  47 }
  48
  49 define <vscale x 1 x i8> @vminu_vx_nxv1i8(<vscale x 1 x i8> %va, i8 %b, <vscale x 1 x i1> %m, i32 zeroext %evl) {
  50 ; CHECK-LABEL: vminu_vx_nxv1i8:
  51 ; CHECK:       # %bb.0:
  52 ; CHECK-NEXT:    vsetvli zero, a1, e8, mf8, ta, ma
  53 ; CHECK-NEXT:    vminu.vx v8, v8, a0, v0.t
  54 ; CHECK-NEXT:    ret
  55   %elt.head = insertelement <vscale x 1 x i8> poison, i8 %b, i32 0
  56   %vb = shufflevector <vscale x 1 x i8> %elt.head, <vscale x 1 x i8> poison, <vscale x 1 x i32> zeroinitializer
  57   %v = call <vscale x 1 x i8> @llvm.vp.umin.nxv1i8(<vscale x 1 x i8> %va, <vscale x 1 x i8> %vb, <vscale x 1 x i1> %m, i32 %evl)
  58   ret <vscale x 1 x i8> %v
  59 }
  60
  61 define <vscale x 1 x i8> @vminu_vx_nxv1i8_commute(<vscale x 1 x i8> %va, i8 %b, <vscale x 1 x i1> %m, i32 zeroext %evl) {
  62 ; CHECK-LABEL: vminu_vx_nxv1i8_commute:
  63 ; CHECK:       # %bb.0:
  64 ; CHECK-NEXT:    vsetvli zero, a1, e8, mf8, ta, ma
  65 ; CHECK-NEXT:    vminu.vx v8, v8, a0, v0.t
  66 ; CHECK-NEXT:    ret
  67   %elt.head = insertelement <vscale x 1 x i8> poison, i8 %b, i32 0
  68   %vb = shufflevector <vscale x 1 x i8> %elt.head, <vscale x 1 x i8> poison, <vscale x 1 x i32> zeroinitializer
  69   %v = call <vscale x 1 x i8> @llvm.vp.umin.nxv1i8(<vscale x 1 x i8> %vb, <vscale x 1 x i8> %va, <vscale x 1 x i1> %m, i32 %evl)
  70   ret <vscale x 1 x i8> %v
  71 }
  72
  73 define <vscale x 1 x i8> @vminu_vx_nxv1i8_unmasked(<vscale x 1 x i8> %va, i8 %b, i32 zeroext %evl) {
  74 ; CHECK-LABEL: vminu_vx_nxv1i8_unmasked:
  75 ; CHECK:       # %bb.0:
  76 ; CHECK-NEXT:    vsetvli zero, a1, e8, mf8, ta, ma
  77 ; CHECK-NEXT:    vminu.vx v8, v8, a0
  78 ; CHECK-NEXT:    ret
  79   %elt.head = insertelement <vscale x 1 x i8> poison, i8 %b, i32 0
  80   %vb = shufflevector <vscale x 1 x i8> %elt.head, <vscale x 1 x i8> poison, <vscale x 1 x i32> zeroinitializer
  81   %v = call <vscale x 1 x i8> @llvm.vp.umin.nxv1i8(<vscale x 1 x i8> %va, <vscale x 1 x i8> %vb, <vscale x 1 x i1> splat (i1 true), i32 %evl)
  82   ret <vscale x 1 x i8> %v
  83 }
  84
  85 declare <vscale x 2 x i8> @llvm.vp.umin.nxv2i8(<vscale x 2 x i8>, <vscale x 2 x i8>, <vscale x 2 x i1>, i32)
  86
  87 define <vscale x 2 x i8> @vminu_vv_nxv2i8(<vscale x 2 x i8> %va, <vscale x 2 x i8> %b, <vscale x 2 x i1> %m, i32 zeroext %evl) {
  88 ; CHECK-LABEL: vminu_vv_nxv2i8:
  89 ; CHECK:       # %bb.0:
  90 ; CHECK-NEXT:    vsetvli zero, a0, e8, mf4, ta, ma
  91 ; CHECK-NEXT:    vminu.vv v8, v8, v9, v0.t
  92 ; CHECK-NEXT:    ret
  93   %v = call <vscale x 2 x i8> @llvm.vp.umin.nxv2i8(<vscale x 2 x i8> %va, <vscale x 2 x i8> %b, <vscale x 2 x i1> %m, i32 %evl)
  94   ret <vscale x 2 x i8> %v
  95 }
  96
  97 define <vscale x 2 x i8> @vminu_vv_nxv2i8_unmasked(<vscale x 2 x i8> %va, <vscale x 2 x i8> %b, i32 zeroext %evl) {
  98 ; CHECK-LABEL: vminu_vv_nxv2i8_unmasked:
  99 ; CHECK:       # %bb.0:
 100 ; CHECK-NEXT:    vsetvli zero, a0, e8, mf4, ta, ma
 101 ; CHECK-NEXT:    vminu.vv v8, v8, v9
 102 ; CHECK-NEXT:    ret
 103   %v = call <vscale x 2 x i8> @llvm.vp.umin.nxv2i8(<vscale x 2 x i8> %va, <vscale x 2 x i8> %b, <vscale x 2 x i1> splat (i1 true), i32 %evl)
 104   ret <vscale x 2 x i8> %v
 105 }
 106
 107 define <vscale x 2 x i8> @vminu_vx_nxv2i8(<vscale x 2 x i8> %va, i8 %b, <vscale x 2 x i1> %m, i32 zeroext %evl) {
 108 ; CHECK-LABEL: vminu_vx_nxv2i8:
 109 ; CHECK:       # %bb.0:
 110 ; CHECK-NEXT:    vsetvli zero, a1, e8, mf4, ta, ma
 111 ; CHECK-NEXT:    vminu.vx v8, v8, a0, v0.t
 112 ; CHECK-NEXT:    ret
 113   %elt.head = insertelement <vscale x 2 x i8> poison, i8 %b, i32 0
 114   %vb = shufflevector <vscale x 2 x i8> %elt.head, <vscale x 2 x i8> poison, <vscale x 2 x i32> zeroinitializer
 115   %v = call <vscale x 2 x i8> @llvm.vp.umin.nxv2i8(<vscale x 2 x i8> %va, <vscale x 2 x i8> %vb, <vscale x 2 x i1> %m, i32 %evl)
 116   ret <vscale x 2 x i8> %v
 117 }
 118
 119 define <vscale x 2 x i8> @vminu_vx_nxv2i8_unmasked(<vscale x 2 x i8> %va, i8 %b, i32 zeroext %evl) {
 120 ; CHECK-LABEL: vminu_vx_nxv2i8_unmasked:
 121 ; CHECK:       # %bb.0:
 122 ; CHECK-NEXT:    vsetvli zero, a1, e8, mf4, ta, ma
 123 ; CHECK-NEXT:    vminu.vx v8, v8, a0
 124 ; CHECK-NEXT:    ret
 125   %elt.head = insertelement <vscale x 2 x i8> poison, i8 %b, i32 0
 126   %vb = shufflevector <vscale x 2 x i8> %elt.head, <vscale x 2 x i8> poison, <vscale x 2 x i32> zeroinitializer
 127   %v = call <vscale x 2 x i8> @llvm.vp.umin.nxv2i8(<vscale x 2 x i8> %va, <vscale x 2 x i8> %vb, <vscale x 2 x i1> splat (i1 true), i32 %evl)
 128   ret <vscale x 2 x i8> %v
 129 }
 130
 131 declare <vscale x 3 x i8> @llvm.vp.umin.nxv3i8(<vscale x 3 x i8>, <vscale x 3 x i8>, <vscale x 3 x i1>, i32)
 132
 133 define <vscale x 3 x i8> @vminu_vv_nxv3i8(<vscale x 3 x i8> %va, <vscale x 3 x i8> %b, <vscale x 3 x i1> %m, i32 zeroext %evl) {
 134 ; CHECK-LABEL: vminu_vv_nxv3i8:
 135 ; CHECK:       # %bb.0:
 136 ; CHECK-NEXT:    vsetvli zero, a0, e8, mf2, ta, ma
 137 ; CHECK-NEXT:    vminu.vv v8, v8, v9, v0.t
 138 ; CHECK-NEXT:    ret
 139   %v = call <vscale x 3 x i8> @llvm.vp.umin.nxv3i8(<vscale x 3 x i8> %va, <vscale x 3 x i8> %b, <vscale x 3 x i1> %m, i32 %evl)
 140   ret <vscale x 3 x i8> %v
 141 }
 142
 143 define <vscale x 3 x i8> @vminu_vv_nxv3i8_unmasked(<vscale x 3 x i8> %va, <vscale x 3 x i8> %b, i32 zeroext %evl) {
 144 ; CHECK-LABEL: vminu_vv_nxv3i8_unmasked:
 145 ; CHECK:       # %bb.0:
 146 ; CHECK-NEXT:    vsetvli zero, a0, e8, mf2, ta, ma
 147 ; CHECK-NEXT:    vminu.vv v8, v8, v9
 148 ; CHECK-NEXT:    ret
 149   %v = call <vscale x 3 x i8> @llvm.vp.umin.nxv3i8(<vscale x 3 x i8> %va, <vscale x 3 x i8> %b, <vscale x 3 x i1> splat (i1 true), i32 %evl)
 150   ret <vscale x 3 x i8> %v
 151 }
 152
 153 define <vscale x 3 x i8> @vminu_vx_nxv3i8(<vscale x 3 x i8> %va, i8 %b, <vscale x 3 x i1> %m, i32 zeroext %evl) {
 154 ; CHECK-LABEL: vminu_vx_nxv3i8:
 155 ; CHECK:       # %bb.0:
 156 ; CHECK-NEXT:    vsetvli zero, a1, e8, mf2, ta, ma
 157 ; CHECK-NEXT:    vminu.vx v8, v8, a0, v0.t
 158 ; CHECK-NEXT:    ret
 159   %elt.head = insertelement <vscale x 3 x i8> poison, i8 %b, i32 0
 160   %vb = shufflevector <vscale x 3 x i8> %elt.head, <vscale x 3 x i8> poison, <vscale x 3 x i32> zeroinitializer
 161   %v = call <vscale x 3 x i8> @llvm.vp.umin.nxv3i8(<vscale x 3 x i8> %va, <vscale x 3 x i8> %vb, <vscale x 3 x i1> %m, i32 %evl)
 162   ret <vscale x 3 x i8> %v
 163 }
 164
 165 define <vscale x 3 x i8> @vminu_vx_nxv3i8_unmasked(<vscale x 3 x i8> %va, i8 %b, i32 zeroext %evl) {
 166 ; CHECK-LABEL: vminu_vx_nxv3i8_unmasked:
 167 ; CHECK:       # %bb.0:
 168 ; CHECK-NEXT:    vsetvli zero, a1, e8, mf2, ta, ma
 169 ; CHECK-NEXT:    vminu.vx v8, v8, a0
 170 ; CHECK-NEXT:    ret
 171   %elt.head = insertelement <vscale x 3 x i8> poison, i8 %b, i32 0
 172   %vb = shufflevector <vscale x 3 x i8> %elt.head, <vscale x 3 x i8> poison, <vscale x 3 x i32> zeroinitializer
 173   %v = call <vscale x 3 x i8> @llvm.vp.umin.nxv3i8(<vscale x 3 x i8> %va, <vscale x 3 x i8> %vb, <vscale x 3 x i1> splat (i1 true), i32 %evl)
 174   ret <vscale x 3 x i8> %v
 175 }
 176
 177 declare <vscale x 4 x i8> @llvm.vp.umin.nxv4i8(<vscale x 4 x i8>, <vscale x 4 x i8>, <vscale x 4 x i1>, i32)
 178
 179 define <vscale x 4 x i8> @vminu_vv_nxv4i8(<vscale x 4 x i8> %va, <vscale x 4 x i8> %b, <vscale x 4 x i1> %m, i32 zeroext %evl) {
 180 ; CHECK-LABEL: vminu_vv_nxv4i8:
 181 ; CHECK:       # %bb.0:
 182 ; CHECK-NEXT:    vsetvli zero, a0, e8, mf2, ta, ma
 183 ; CHECK-NEXT:    vminu.vv v8, v8, v9, v0.t
 184 ; CHECK-NEXT:    ret
 185   %v = call <vscale x 4 x i8> @llvm.vp.umin.nxv4i8(<vscale x 4 x i8> %va, <vscale x 4 x i8> %b, <vscale x 4 x i1> %m, i32 %evl)
 186   ret <vscale x 4 x i8> %v
 187 }
 188
 189 define <vscale x 4 x i8> @vminu_vv_nxv4i8_unmasked(<vscale x 4 x i8> %va, <vscale x 4 x i8> %b, i32 zeroext %evl) {
 190 ; CHECK-LABEL: vminu_vv_nxv4i8_unmasked:
 191 ; CHECK:       # %bb.0:
 192 ; CHECK-NEXT:    vsetvli zero, a0, e8, mf2, ta, ma
 193 ; CHECK-NEXT:    vminu.vv v8, v8, v9
 194 ; CHECK-NEXT:    ret
 195   %v = call <vscale x 4 x i8> @llvm.vp.umin.nxv4i8(<vscale x 4 x i8> %va, <vscale x 4 x i8> %b, <vscale x 4 x i1> splat (i1 true), i32 %evl)
 196   ret <vscale x 4 x i8> %v
 197 }
 198
 199 define <vscale x 4 x i8> @vminu_vx_nxv4i8(<vscale x 4 x i8> %va, i8 %b, <vscale x 4 x i1> %m, i32 zeroext %evl) {
 200 ; CHECK-LABEL: vminu_vx_nxv4i8:
 201 ; CHECK:       # %bb.0:
 202 ; CHECK-NEXT:    vsetvli zero, a1, e8, mf2, ta, ma
 203 ; CHECK-NEXT:    vminu.vx v8, v8, a0, v0.t
 204 ; CHECK-NEXT:    ret
 205   %elt.head = insertelement <vscale x 4 x i8> poison, i8 %b, i32 0
 206   %vb = shufflevector <vscale x 4 x i8> %elt.head, <vscale x 4 x i8> poison, <vscale x 4 x i32> zeroinitializer
 207   %v = call <vscale x 4 x i8> @llvm.vp.umin.nxv4i8(<vscale x 4 x i8> %va, <vscale x 4 x i8> %vb, <vscale x 4 x i1> %m, i32 %evl)
 208   ret <vscale x 4 x i8> %v
 209 }
 210
 211 define <vscale x 4 x i8> @vminu_vx_nxv4i8_unmasked(<vscale x 4 x i8> %va, i8 %b, i32 zeroext %evl) {
 212 ; CHECK-LABEL: vminu_vx_nxv4i8_unmasked:
 213 ; CHECK:       # %bb.0:
 214 ; CHECK-NEXT:    vsetvli zero, a1, e8, mf2, ta, ma
 215 ; CHECK-NEXT:    vminu.vx v8, v8, a0
 216 ; CHECK-NEXT:    ret
 217   %elt.head = insertelement <vscale x 4 x i8> poison, i8 %b, i32 0
 218   %vb = shufflevector <vscale x 4 x i8> %elt.head, <vscale x 4 x i8> poison, <vscale x 4 x i32> zeroinitializer
 219   %v = call <vscale x 4 x i8> @llvm.vp.umin.nxv4i8(<vscale x 4 x i8> %va, <vscale x 4 x i8> %vb, <vscale x 4 x i1> splat (i1 true), i32 %evl)
 220   ret <vscale x 4 x i8> %v
 221 }
 222
 223 declare <vscale x 8 x i8> @llvm.vp.umin.nxv8i8(<vscale x 8 x i8>, <vscale x 8 x i8>, <vscale x 8 x i1>, i32)
 224
 225 define <vscale x 8 x i8> @vminu_vv_nxv8i8(<vscale x 8 x i8> %va, <vscale x 8 x i8> %b, <vscale x 8 x i1> %m, i32 zeroext %evl) {
 226 ; CHECK-LABEL: vminu_vv_nxv8i8:
 227 ; CHECK:       # %bb.0:
 228 ; CHECK-NEXT:    vsetvli zero, a0, e8, m1, ta, ma
 229 ; CHECK-NEXT:    vminu.vv v8, v8, v9, v0.t
 230 ; CHECK-NEXT:    ret
 231   %v = call <vscale x 8 x i8> @llvm.vp.umin.nxv8i8(<vscale x 8 x i8> %va, <vscale x 8 x i8> %b, <vscale x 8 x i1> %m, i32 %evl)
 232   ret <vscale x 8 x i8> %v
 233 }
 234
 235 define <vscale x 8 x i8> @vminu_vv_nxv8i8_unmasked(<vscale x 8 x i8> %va, <vscale x 8 x i8> %b, i32 zeroext %evl) {
 236 ; CHECK-LABEL: vminu_vv_nxv8i8_unmasked:
 237 ; CHECK:       # %bb.0:
 238 ; CHECK-NEXT:    vsetvli zero, a0, e8, m1, ta, ma
 239 ; CHECK-NEXT:    vminu.vv v8, v8, v9
 240 ; CHECK-NEXT:    ret
 241   %v = call <vscale x 8 x i8> @llvm.vp.umin.nxv8i8(<vscale x 8 x i8> %va, <vscale x 8 x i8> %b, <vscale x 8 x i1> splat (i1 true), i32 %evl)
 242   ret <vscale x 8 x i8> %v
 243 }
 244
 245 define <vscale x 8 x i8> @vminu_vx_nxv8i8(<vscale x 8 x i8> %va, i8 %b, <vscale x 8 x i1> %m, i32 zeroext %evl) {
 246 ; CHECK-LABEL: vminu_vx_nxv8i8:
 247 ; CHECK:       # %bb.0:
 248 ; CHECK-NEXT:    vsetvli zero, a1, e8, m1, ta, ma
 249 ; CHECK-NEXT:    vminu.vx v8, v8, a0, v0.t
 250 ; CHECK-NEXT:    ret
 251   %elt.head = insertelement <vscale x 8 x i8> poison, i8 %b, i32 0
 252   %vb = shufflevector <vscale x 8 x i8> %elt.head, <vscale x 8 x i8> poison, <vscale x 8 x i32> zeroinitializer
 253   %v = call <vscale x 8 x i8> @llvm.vp.umin.nxv8i8(<vscale x 8 x i8> %va, <vscale x 8 x i8> %vb, <vscale x 8 x i1> %m, i32 %evl)
 254   ret <vscale x 8 x i8> %v
 255 }
 256
 257 define <vscale x 8 x i8> @vminu_vx_nxv8i8_unmasked(<vscale x 8 x i8> %va, i8 %b, i32 zeroext %evl) {
 258 ; CHECK-LABEL: vminu_vx_nxv8i8_unmasked:
 259 ; CHECK:       # %bb.0:
 260 ; CHECK-NEXT:    vsetvli zero, a1, e8, m1, ta, ma
 261 ; CHECK-NEXT:    vminu.vx v8, v8, a0
 262 ; CHECK-NEXT:    ret
 263   %elt.head = insertelement <vscale x 8 x i8> poison, i8 %b, i32 0
 264   %vb = shufflevector <vscale x 8 x i8> %elt.head, <vscale x 8 x i8> poison, <vscale x 8 x i32> zeroinitializer
 265   %v = call <vscale x 8 x i8> @llvm.vp.umin.nxv8i8(<vscale x 8 x i8> %va, <vscale x 8 x i8> %vb, <vscale x 8 x i1> splat (i1 true), i32 %evl)
 266   ret <vscale x 8 x i8> %v
 267 }
 268
 269 declare <vscale x 16 x i8> @llvm.vp.umin.nxv16i8(<vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i1>, i32)
 270
 271 define <vscale x 16 x i8> @vminu_vv_nxv16i8(<vscale x 16 x i8> %va, <vscale x 16 x i8> %b, <vscale x 16 x i1> %m, i32 zeroext %evl) {
 272 ; CHECK-LABEL: vminu_vv_nxv16i8:
 273 ; CHECK:       # %bb.0:
 274 ; CHECK-NEXT:    vsetvli zero, a0, e8, m2, ta, ma
 275 ; CHECK-NEXT:    vminu.vv v8, v8, v10, v0.t
 276 ; CHECK-NEXT:    ret
 277   %v = call <vscale x 16 x i8> @llvm.vp.umin.nxv16i8(<vscale x 16 x i8> %va, <vscale x 16 x i8> %b, <vscale x 16 x i1> %m, i32 %evl)
 278   ret <vscale x 16 x i8> %v
 279 }
 280
 281 define <vscale x 16 x i8> @vminu_vv_nxv16i8_unmasked(<vscale x 16 x i8> %va, <vscale x 16 x i8> %b, i32 zeroext %evl) {
 282 ; CHECK-LABEL: vminu_vv_nxv16i8_unmasked:
 283 ; CHECK:       # %bb.0:
 284 ; CHECK-NEXT:    vsetvli zero, a0, e8, m2, ta, ma
 285 ; CHECK-NEXT:    vminu.vv v8, v8, v10
 286 ; CHECK-NEXT:    ret
 287   %v = call <vscale x 16 x i8> @llvm.vp.umin.nxv16i8(<vscale x 16 x i8> %va, <vscale x 16 x i8> %b, <vscale x 16 x i1> splat (i1 true), i32 %evl)
 288   ret <vscale x 16 x i8> %v
 289 }
 290
 291 define <vscale x 16 x i8> @vminu_vx_nxv16i8(<vscale x 16 x i8> %va, i8 %b, <vscale x 16 x i1> %m, i32 zeroext %evl) {
 292 ; CHECK-LABEL: vminu_vx_nxv16i8:
 293 ; CHECK:       # %bb.0:
 294 ; CHECK-NEXT:    vsetvli zero, a1, e8, m2, ta, ma
 295 ; CHECK-NEXT:    vminu.vx v8, v8, a0, v0.t
 296 ; CHECK-NEXT:    ret
 297   %elt.head = insertelement <vscale x 16 x i8> poison, i8 %b, i32 0
 298   %vb = shufflevector <vscale x 16 x i8> %elt.head, <vscale x 16 x i8> poison, <vscale x 16 x i32> zeroinitializer
 299   %v = call <vscale x 16 x i8> @llvm.vp.umin.nxv16i8(<vscale x 16 x i8> %va, <vscale x 16 x i8> %vb, <vscale x 16 x i1> %m, i32 %evl)
 300   ret <vscale x 16 x i8> %v
 301 }
 302
 303 define <vscale x 16 x i8> @vminu_vx_nxv16i8_unmasked(<vscale x 16 x i8> %va, i8 %b, i32 zeroext %evl) {
 304 ; CHECK-LABEL: vminu_vx_nxv16i8_unmasked:
 305 ; CHECK:       # %bb.0:
 306 ; CHECK-NEXT:    vsetvli zero, a1, e8, m2, ta, ma
 307 ; CHECK-NEXT:    vminu.vx v8, v8, a0
 308 ; CHECK-NEXT:    ret
 309   %elt.head = insertelement <vscale x 16 x i8> poison, i8 %b, i32 0
 310   %vb = shufflevector <vscale x 16 x i8> %elt.head, <vscale x 16 x i8> poison, <vscale x 16 x i32> zeroinitializer
 311   %v = call <vscale x 16 x i8> @llvm.vp.umin.nxv16i8(<vscale x 16 x i8> %va, <vscale x 16 x i8> %vb, <vscale x 16 x i1> splat (i1 true), i32 %evl)
 312   ret <vscale x 16 x i8> %v
 313 }
 314
 315 declare <vscale x 32 x i8> @llvm.vp.umin.nxv32i8(<vscale x 32 x i8>, <vscale x 32 x i8>, <vscale x 32 x i1>, i32)
 316
 317 define <vscale x 32 x i8> @vminu_vv_nxv32i8(<vscale x 32 x i8> %va, <vscale x 32 x i8> %b, <vscale x 32 x i1> %m, i32 zeroext %evl) {
 318 ; CHECK-LABEL: vminu_vv_nxv32i8:
 319 ; CHECK:       # %bb.0:
 320 ; CHECK-NEXT:    vsetvli zero, a0, e8, m4, ta, ma
 321 ; CHECK-NEXT:    vminu.vv v8, v8, v12, v0.t
 322 ; CHECK-NEXT:    ret
 323   %v = call <vscale x 32 x i8> @llvm.vp.umin.nxv32i8(<vscale x 32 x i8> %va, <vscale x 32 x i8> %b, <vscale x 32 x i1> %m, i32 %evl)
 324   ret <vscale x 32 x i8> %v
 325 }
 326
 327 define <vscale x 32 x i8> @vminu_vv_nxv32i8_unmasked(<vscale x 32 x i8> %va, <vscale x 32 x i8> %b, i32 zeroext %evl) {
 328 ; CHECK-LABEL: vminu_vv_nxv32i8_unmasked:
 329 ; CHECK:       # %bb.0:
 330 ; CHECK-NEXT:    vsetvli zero, a0, e8, m4, ta, ma
 331 ; CHECK-NEXT:    vminu.vv v8, v8, v12
 332 ; CHECK-NEXT:    ret
 333   %v = call <vscale x 32 x i8> @llvm.vp.umin.nxv32i8(<vscale x 32 x i8> %va, <vscale x 32 x i8> %b, <vscale x 32 x i1> splat (i1 true), i32 %evl)
 334   ret <vscale x 32 x i8> %v
 335 }
 336
 337 define <vscale x 32 x i8> @vminu_vx_nxv32i8(<vscale x 32 x i8> %va, i8 %b, <vscale x 32 x i1> %m, i32 zeroext %evl) {
 338 ; CHECK-LABEL: vminu_vx_nxv32i8:
 339 ; CHECK:       # %bb.0:
 340 ; CHECK-NEXT:    vsetvli zero, a1, e8, m4, ta, ma
 341 ; CHECK-NEXT:    vminu.vx v8, v8, a0, v0.t
 342 ; CHECK-NEXT:    ret
 343   %elt.head = insertelement <vscale x 32 x i8> poison, i8 %b, i32 0
 344   %vb = shufflevector <vscale x 32 x i8> %elt.head, <vscale x 32 x i8> poison, <vscale x 32 x i32> zeroinitializer
 345   %v = call <vscale x 32 x i8> @llvm.vp.umin.nxv32i8(<vscale x 32 x i8> %va, <vscale x 32 x i8> %vb, <vscale x 32 x i1> %m, i32 %evl)
 346   ret <vscale x 32 x i8> %v
 347 }
 348
 349 define <vscale x 32 x i8> @vminu_vx_nxv32i8_unmasked(<vscale x 32 x i8> %va, i8 %b, i32 zeroext %evl) {
 350 ; CHECK-LABEL: vminu_vx_nxv32i8_unmasked:
 351 ; CHECK:       # %bb.0:
 352 ; CHECK-NEXT:    vsetvli zero, a1, e8, m4, ta, ma
 353 ; CHECK-NEXT:    vminu.vx v8, v8, a0
 354 ; CHECK-NEXT:    ret
 355   %elt.head = insertelement <vscale x 32 x i8> poison, i8 %b, i32 0
 356   %vb = shufflevector <vscale x 32 x i8> %elt.head, <vscale x 32 x i8> poison, <vscale x 32 x i32> zeroinitializer
 357   %v = call <vscale x 32 x i8> @llvm.vp.umin.nxv32i8(<vscale x 32 x i8> %va, <vscale x 32 x i8> %vb, <vscale x 32 x i1> splat (i1 true), i32 %evl)
 358   ret <vscale x 32 x i8> %v
 359 }
 360
 361 declare <vscale x 64 x i8> @llvm.vp.umin.nxv64i8(<vscale x 64 x i8>, <vscale x 64 x i8>, <vscale x 64 x i1>, i32)
 362
 363 define <vscale x 64 x i8> @vminu_vv_nxv64i8(<vscale x 64 x i8> %va, <vscale x 64 x i8> %b, <vscale x 64 x i1> %m, i32 zeroext %evl) {
 364 ; CHECK-LABEL: vminu_vv_nxv64i8:
 365 ; CHECK:       # %bb.0:
 366 ; CHECK-NEXT:    vsetvli zero, a0, e8, m8, ta, ma
 367 ; CHECK-NEXT:    vminu.vv v8, v8, v16, v0.t
 368 ; CHECK-NEXT:    ret
 369   %v = call <vscale x 64 x i8> @llvm.vp.umin.nxv64i8(<vscale x 64 x i8> %va, <vscale x 64 x i8> %b, <vscale x 64 x i1> %m, i32 %evl)
 370   ret <vscale x 64 x i8> %v
 371 }
 372
 373 define <vscale x 64 x i8> @vminu_vv_nxv64i8_unmasked(<vscale x 64 x i8> %va, <vscale x 64 x i8> %b, i32 zeroext %evl) {
 374 ; CHECK-LABEL: vminu_vv_nxv64i8_unmasked:
 375 ; CHECK:       # %bb.0:
 376 ; CHECK-NEXT:    vsetvli zero, a0, e8, m8, ta, ma
 377 ; CHECK-NEXT:    vminu.vv v8, v8, v16
 378 ; CHECK-NEXT:    ret
 379   %v = call <vscale x 64 x i8> @llvm.vp.umin.nxv64i8(<vscale x 64 x i8> %va, <vscale x 64 x i8> %b, <vscale x 64 x i1> splat (i1 true), i32 %evl)
 380   ret <vscale x 64 x i8> %v
 381 }
 382
 383 define <vscale x 64 x i8> @vminu_vx_nxv64i8(<vscale x 64 x i8> %va, i8 %b, <vscale x 64 x i1> %m, i32 zeroext %evl) {
 384 ; CHECK-LABEL: vminu_vx_nxv64i8:
 385 ; CHECK:       # %bb.0:
 386 ; CHECK-NEXT:    vsetvli zero, a1, e8, m8, ta, ma
 387 ; CHECK-NEXT:    vminu.vx v8, v8, a0, v0.t
 388 ; CHECK-NEXT:    ret
 389   %elt.head = insertelement <vscale x 64 x i8> poison, i8 %b, i32 0
 390   %vb = shufflevector <vscale x 64 x i8> %elt.head, <vscale x 64 x i8> poison, <vscale x 64 x i32> zeroinitializer
 391   %v = call <vscale x 64 x i8> @llvm.vp.umin.nxv64i8(<vscale x 64 x i8> %va, <vscale x 64 x i8> %vb, <vscale x 64 x i1> %m, i32 %evl)
 392   ret <vscale x 64 x i8> %v
 393 }
 394
 395 define <vscale x 64 x i8> @vminu_vx_nxv64i8_unmasked(<vscale x 64 x i8> %va, i8 %b, i32 zeroext %evl) {
 396 ; CHECK-LABEL: vminu_vx_nxv64i8_unmasked:
 397 ; CHECK:       # %bb.0:
 398 ; CHECK-NEXT:    vsetvli zero, a1, e8, m8, ta, ma
 399 ; CHECK-NEXT:    vminu.vx v8, v8, a0
 400 ; CHECK-NEXT:    ret
 401   %elt.head = insertelement <vscale x 64 x i8> poison, i8 %b, i32 0
 402   %vb = shufflevector <vscale x 64 x i8> %elt.head, <vscale x 64 x i8> poison, <vscale x 64 x i32> zeroinitializer
 403   %v = call <vscale x 64 x i8> @llvm.vp.umin.nxv64i8(<vscale x 64 x i8> %va, <vscale x 64 x i8> %vb, <vscale x 64 x i1> splat (i1 true), i32 %evl)
 404   ret <vscale x 64 x i8> %v
 405 }
 406
 407 ; Test that split-legalization works when the mask itself needs splitting.
 408
 409 declare <vscale x 128 x i8> @llvm.vp.umin.nxv128i8(<vscale x 128 x i8>, <vscale x 128 x i8>, <vscale x 128 x i1>, i32)
 410
 411 define <vscale x 128 x i8> @vminu_vx_nxv128i8(<vscale x 128 x i8> %va, i8 %b, <vscale x 128 x i1> %m, i32 zeroext %evl) {
 412 ; CHECK-LABEL: vminu_vx_nxv128i8:
 413 ; CHECK:       # %bb.0:
 414 ; CHECK-NEXT:    vmv1r.v v24, v0
 415 ; CHECK-NEXT:    vsetvli a3, zero, e8, m8, ta, ma
 416 ; CHECK-NEXT:    vlm.v v0, (a1)
 417 ; CHECK-NEXT:    csrr a1, vlenb
 418 ; CHECK-NEXT:    slli a1, a1, 3
 419 ; CHECK-NEXT:    sub a3, a2, a1
 420 ; CHECK-NEXT:    sltu a4, a2, a3
 421 ; CHECK-NEXT:    addi a4, a4, -1
 422 ; CHECK-NEXT:    and a3, a4, a3
 423 ; CHECK-NEXT:    vsetvli zero, a3, e8, m8, ta, ma
 424 ; CHECK-NEXT:    vminu.vx v16, v16, a0, v0.t
 425 ; CHECK-NEXT:    bltu a2, a1, .LBB34_2
 426 ; CHECK-NEXT:  # %bb.1:
 427 ; CHECK-NEXT:    mv a2, a1
 428 ; CHECK-NEXT:  .LBB34_2:
 429 ; CHECK-NEXT:    vmv1r.v v0, v24
 430 ; CHECK-NEXT:    vsetvli zero, a2, e8, m8, ta, ma
 431 ; CHECK-NEXT:    vminu.vx v8, v8, a0, v0.t
 432 ; CHECK-NEXT:    ret
 433   %elt.head = insertelement <vscale x 128 x i8> poison, i8 %b, i32 0
 434   %vb = shufflevector <vscale x 128 x i8> %elt.head, <vscale x 128 x i8> poison, <vscale x 128 x i32> zeroinitializer
 435   %v = call <vscale x 128 x i8> @llvm.vp.umin.nxv128i8(<vscale x 128 x i8> %va, <vscale x 128 x i8> %vb, <vscale x 128 x i1> %m, i32 %evl)
 436   ret <vscale x 128 x i8> %v
 437 }
 438
 439 define <vscale x 128 x i8> @vminu_vx_nxv128i8_unmasked(<vscale x 128 x i8> %va, i8 %b, i32 zeroext %evl) {
 440 ; CHECK-LABEL: vminu_vx_nxv128i8_unmasked:
 441 ; CHECK:       # %bb.0:
 442 ; CHECK-NEXT:    csrr a2, vlenb
 443 ; CHECK-NEXT:    slli a2, a2, 3
 444 ; CHECK-NEXT:    sub a3, a1, a2
 445 ; CHECK-NEXT:    sltu a4, a1, a3
 446 ; CHECK-NEXT:    addi a4, a4, -1
 447 ; CHECK-NEXT:    and a3, a4, a3
 448 ; CHECK-NEXT:    vsetvli zero, a3, e8, m8, ta, ma
 449 ; CHECK-NEXT:    vminu.vx v16, v16, a0
 450 ; CHECK-NEXT:    bltu a1, a2, .LBB35_2
 451 ; CHECK-NEXT:  # %bb.1:
 452 ; CHECK-NEXT:    mv a1, a2
 453 ; CHECK-NEXT:  .LBB35_2:
 454 ; CHECK-NEXT:    vsetvli zero, a1, e8, m8, ta, ma
 455 ; CHECK-NEXT:    vminu.vx v8, v8, a0
 456 ; CHECK-NEXT:    ret
 457   %elt.head = insertelement <vscale x 128 x i8> poison, i8 %b, i32 0
 458   %vb = shufflevector <vscale x 128 x i8> %elt.head, <vscale x 128 x i8> poison, <vscale x 128 x i32> zeroinitializer
 459   %v = call <vscale x 128 x i8> @llvm.vp.umin.nxv128i8(<vscale x 128 x i8> %va, <vscale x 128 x i8> %vb, <vscale x 128 x i1> splat (i1 true), i32 %evl)
 460   ret <vscale x 128 x i8> %v
 461 }
 462
 463 declare <vscale x 1 x i16> @llvm.vp.umin.nxv1i16(<vscale x 1 x i16>, <vscale x 1 x i16>, <vscale x 1 x i1>, i32)
 464
 465 define <vscale x 1 x i16> @vminu_vv_nxv1i16(<vscale x 1 x i16> %va, <vscale x 1 x i16> %b, <vscale x 1 x i1> %m, i32 zeroext %evl) {
 466 ; CHECK-LABEL: vminu_vv_nxv1i16:
 467 ; CHECK:       # %bb.0:
 468 ; CHECK-NEXT:    vsetvli zero, a0, e16, mf4, ta, ma
 469 ; CHECK-NEXT:    vminu.vv v8, v8, v9, v0.t
 470 ; CHECK-NEXT:    ret
 471   %v = call <vscale x 1 x i16> @llvm.vp.umin.nxv1i16(<vscale x 1 x i16> %va, <vscale x 1 x i16> %b, <vscale x 1 x i1> %m, i32 %evl)
 472   ret <vscale x 1 x i16> %v
 473 }
 474
 475 define <vscale x 1 x i16> @vminu_vv_nxv1i16_unmasked(<vscale x 1 x i16> %va, <vscale x 1 x i16> %b, i32 zeroext %evl) {
 476 ; CHECK-LABEL: vminu_vv_nxv1i16_unmasked:
 477 ; CHECK:       # %bb.0:
 478 ; CHECK-NEXT:    vsetvli zero, a0, e16, mf4, ta, ma
 479 ; CHECK-NEXT:    vminu.vv v8, v8, v9
 480 ; CHECK-NEXT:    ret
 481   %v = call <vscale x 1 x i16> @llvm.vp.umin.nxv1i16(<vscale x 1 x i16> %va, <vscale x 1 x i16> %b, <vscale x 1 x i1> splat (i1 true), i32 %evl)
 482   ret <vscale x 1 x i16> %v
 483 }
 484
 485 define <vscale x 1 x i16> @vminu_vx_nxv1i16(<vscale x 1 x i16> %va, i16 %b, <vscale x 1 x i1> %m, i32 zeroext %evl) {
 486 ; CHECK-LABEL: vminu_vx_nxv1i16:
 487 ; CHECK:       # %bb.0:
 488 ; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, ma
 489 ; CHECK-NEXT:    vminu.vx v8, v8, a0, v0.t
 490 ; CHECK-NEXT:    ret
 491   %elt.head = insertelement <vscale x 1 x i16> poison, i16 %b, i32 0
 492   %vb = shufflevector <vscale x 1 x i16> %elt.head, <vscale x 1 x i16> poison, <vscale x 1 x i32> zeroinitializer
 493   %v = call <vscale x 1 x i16> @llvm.vp.umin.nxv1i16(<vscale x 1 x i16> %va, <vscale x 1 x i16> %vb, <vscale x 1 x i1> %m, i32 %evl)
 494   ret <vscale x 1 x i16> %v
 495 }
 496
 497 define <vscale x 1 x i16> @vminu_vx_nxv1i16_unmasked(<vscale x 1 x i16> %va, i16 %b, i32 zeroext %evl) {
 498 ; CHECK-LABEL: vminu_vx_nxv1i16_unmasked:
 499 ; CHECK:       # %bb.0:
 500 ; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, ma
 501 ; CHECK-NEXT:    vminu.vx v8, v8, a0
 502 ; CHECK-NEXT:    ret
 503   %elt.head = insertelement <vscale x 1 x i16> poison, i16 %b, i32 0
 504   %vb = shufflevector <vscale x 1 x i16> %elt.head, <vscale x 1 x i16> poison, <vscale x 1 x i32> zeroinitializer
 505   %v = call <vscale x 1 x i16> @llvm.vp.umin.nxv1i16(<vscale x 1 x i16> %va, <vscale x 1 x i16> %vb, <vscale x 1 x i1> splat (i1 true), i32 %evl)
 506   ret <vscale x 1 x i16> %v
 507 }
 508
 509 declare <vscale x 2 x i16> @llvm.vp.umin.nxv2i16(<vscale x 2 x i16>, <vscale x 2 x i16>, <vscale x 2 x i1>, i32)
 510
 511 define <vscale x 2 x i16> @vminu_vv_nxv2i16(<vscale x 2 x i16> %va, <vscale x 2 x i16> %b, <vscale x 2 x i1> %m, i32 zeroext %evl) {
 512 ; CHECK-LABEL: vminu_vv_nxv2i16:
 513 ; CHECK:       # %bb.0:
 514 ; CHECK-NEXT:    vsetvli zero, a0, e16, mf2, ta, ma
 515 ; CHECK-NEXT:    vminu.vv v8, v8, v9, v0.t
 516 ; CHECK-NEXT:    ret
 517   %v = call <vscale x 2 x i16> @llvm.vp.umin.nxv2i16(<vscale x 2 x i16> %va, <vscale x 2 x i16> %b, <vscale x 2 x i1> %m, i32 %evl)
 518   ret <vscale x 2 x i16> %v
 519 }
 520
 521 define <vscale x 2 x i16> @vminu_vv_nxv2i16_unmasked(<vscale x 2 x i16> %va, <vscale x 2 x i16> %b, i32 zeroext %evl) {
 522 ; CHECK-LABEL: vminu_vv_nxv2i16_unmasked:
 523 ; CHECK:       # %bb.0:
 524 ; CHECK-NEXT:    vsetvli zero, a0, e16, mf2, ta, ma
 525 ; CHECK-NEXT:    vminu.vv v8, v8, v9
 526 ; CHECK-NEXT:    ret
 527   %v = call <vscale x 2 x i16> @llvm.vp.umin.nxv2i16(<vscale x 2 x i16> %va, <vscale x 2 x i16> %b, <vscale x 2 x i1> splat (i1 true), i32 %evl)
 528   ret <vscale x 2 x i16> %v
 529 }
 530
 531 define <vscale x 2 x i16> @vminu_vx_nxv2i16(<vscale x 2 x i16> %va, i16 %b, <vscale x 2 x i1> %m, i32 zeroext %evl) {
 532 ; CHECK-LABEL: vminu_vx_nxv2i16:
 533 ; CHECK:       # %bb.0:
 534 ; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, ma
 535 ; CHECK-NEXT:    vminu.vx v8, v8, a0, v0.t
 536 ; CHECK-NEXT:    ret
 537   %elt.head = insertelement <vscale x 2 x i16> poison, i16 %b, i32 0
 538   %vb = shufflevector <vscale x 2 x i16> %elt.head, <vscale x 2 x i16> poison, <vscale x 2 x i32> zeroinitializer
 539   %v = call <vscale x 2 x i16> @llvm.vp.umin.nxv2i16(<vscale x 2 x i16> %va, <vscale x 2 x i16> %vb, <vscale x 2 x i1> %m, i32 %evl)
 540   ret <vscale x 2 x i16> %v
 541 }
 542
 543 define <vscale x 2 x i16> @vminu_vx_nxv2i16_unmasked(<vscale x 2 x i16> %va, i16 %b, i32 zeroext %evl) {
 544 ; CHECK-LABEL: vminu_vx_nxv2i16_unmasked:
 545 ; CHECK:       # %bb.0:
 546 ; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, ma
 547 ; CHECK-NEXT:    vminu.vx v8, v8, a0
 548 ; CHECK-NEXT:    ret
 549   %elt.head = insertelement <vscale x 2 x i16> poison, i16 %b, i32 0
 550   %vb = shufflevector <vscale x 2 x i16> %elt.head, <vscale x 2 x i16> poison, <vscale x 2 x i32> zeroinitializer
 551   %v = call <vscale x 2 x i16> @llvm.vp.umin.nxv2i16(<vscale x 2 x i16> %va, <vscale x 2 x i16> %vb, <vscale x 2 x i1> splat (i1 true), i32 %evl)
 552   ret <vscale x 2 x i16> %v
 553 }
 554
 555 declare <vscale x 4 x i16> @llvm.vp.umin.nxv4i16(<vscale x 4 x i16>, <vscale x 4 x i16>, <vscale x 4 x i1>, i32)
 556
 557 define <vscale x 4 x i16> @vminu_vv_nxv4i16(<vscale x 4 x i16> %va, <vscale x 4 x i16> %b, <vscale x 4 x i1> %m, i32 zeroext %evl) {
 558 ; CHECK-LABEL: vminu_vv_nxv4i16:
 559 ; CHECK:       # %bb.0:
 560 ; CHECK-NEXT:    vsetvli zero, a0, e16, m1, ta, ma
 561 ; CHECK-NEXT:    vminu.vv v8, v8, v9, v0.t
 562 ; CHECK-NEXT:    ret
 563   %v = call <vscale x 4 x i16> @llvm.vp.umin.nxv4i16(<vscale x 4 x i16> %va, <vscale x 4 x i16> %b, <vscale x 4 x i1> %m, i32 %evl)
 564   ret <vscale x 4 x i16> %v
 565 }
 566
 567 define <vscale x 4 x i16> @vminu_vv_nxv4i16_unmasked(<vscale x 4 x i16> %va, <vscale x 4 x i16> %b, i32 zeroext %evl) {
 568 ; CHECK-LABEL: vminu_vv_nxv4i16_unmasked:
 569 ; CHECK:       # %bb.0:
 570 ; CHECK-NEXT:    vsetvli zero, a0, e16, m1, ta, ma
 571 ; CHECK-NEXT:    vminu.vv v8, v8, v9
 572 ; CHECK-NEXT:    ret
 573   %v = call <vscale x 4 x i16> @llvm.vp.umin.nxv4i16(<vscale x 4 x i16> %va, <vscale x 4 x i16> %b, <vscale x 4 x i1> splat (i1 true), i32 %evl)
 574   ret <vscale x 4 x i16> %v
 575 }
 576
 577 define <vscale x 4 x i16> @vminu_vx_nxv4i16(<vscale x 4 x i16> %va, i16 %b, <vscale x 4 x i1> %m, i32 zeroext %evl) {
 578 ; CHECK-LABEL: vminu_vx_nxv4i16:
 579 ; CHECK:       # %bb.0:
 580 ; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, ma
 581 ; CHECK-NEXT:    vminu.vx v8, v8, a0, v0.t
 582 ; CHECK-NEXT:    ret
 583   %elt.head = insertelement <vscale x 4 x i16> poison, i16 %b, i32 0
 584   %vb = shufflevector <vscale x 4 x i16> %elt.head, <vscale x 4 x i16> poison, <vscale x 4 x i32> zeroinitializer
 585   %v = call <vscale x 4 x i16> @llvm.vp.umin.nxv4i16(<vscale x 4 x i16> %va, <vscale x 4 x i16> %vb, <vscale x 4 x i1> %m, i32 %evl)
 586   ret <vscale x 4 x i16> %v
 587 }
 588
 589 define <vscale x 4 x i16> @vminu_vx_nxv4i16_unmasked(<vscale x 4 x i16> %va, i16 %b, i32 zeroext %evl) {
 590 ; CHECK-LABEL: vminu_vx_nxv4i16_unmasked:
 591 ; CHECK:       # %bb.0:
 592 ; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, ma
 593 ; CHECK-NEXT:    vminu.vx v8, v8, a0
 594 ; CHECK-NEXT:    ret
 595   %elt.head = insertelement <vscale x 4 x i16> poison, i16 %b, i32 0
 596   %vb = shufflevector <vscale x 4 x i16> %elt.head, <vscale x 4 x i16> poison, <vscale x 4 x i32> zeroinitializer
 597   %v = call <vscale x 4 x i16> @llvm.vp.umin.nxv4i16(<vscale x 4 x i16> %va, <vscale x 4 x i16> %vb, <vscale x 4 x i1> splat (i1 true), i32 %evl)
 598   ret <vscale x 4 x i16> %v
 599 }
 600
 601 declare <vscale x 8 x i16> @llvm.vp.umin.nxv8i16(<vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i1>, i32)
 602
 603 define <vscale x 8 x i16> @vminu_vv_nxv8i16(<vscale x 8 x i16> %va, <vscale x 8 x i16> %b, <vscale x 8 x i1> %m, i32 zeroext %evl) {
 604 ; CHECK-LABEL: vminu_vv_nxv8i16:
 605 ; CHECK:       # %bb.0:
 606 ; CHECK-NEXT:    vsetvli zero, a0, e16, m2, ta, ma
 607 ; CHECK-NEXT:    vminu.vv v8, v8, v10, v0.t
 608 ; CHECK-NEXT:    ret
 609   %v = call <vscale x 8 x i16> @llvm.vp.umin.nxv8i16(<vscale x 8 x i16> %va, <vscale x 8 x i16> %b, <vscale x 8 x i1> %m, i32 %evl)
 610   ret <vscale x 8 x i16> %v
 611 }
 612
 613 define <vscale x 8 x i16> @vminu_vv_nxv8i16_unmasked(<vscale x 8 x i16> %va, <vscale x 8 x i16> %b, i32 zeroext %evl) {
 614 ; CHECK-LABEL: vminu_vv_nxv8i16_unmasked:
 615 ; CHECK:       # %bb.0:
 616 ; CHECK-NEXT:    vsetvli zero, a0, e16, m2, ta, ma
 617 ; CHECK-NEXT:    vminu.vv v8, v8, v10
 618 ; CHECK-NEXT:    ret
 619   %v = call <vscale x 8 x i16> @llvm.vp.umin.nxv8i16(<vscale x 8 x i16> %va, <vscale x 8 x i16> %b, <vscale x 8 x i1> splat (i1 true), i32 %evl)
 620   ret <vscale x 8 x i16> %v
 621 }
 622
 623 define <vscale x 8 x i16> @vminu_vx_nxv8i16(<vscale x 8 x i16> %va, i16 %b, <vscale x 8 x i1> %m, i32 zeroext %evl) {
 624 ; CHECK-LABEL: vminu_vx_nxv8i16:
 625 ; CHECK:       # %bb.0:
 626 ; CHECK-NEXT:    vsetvli zero, a1, e16, m2, ta, ma
 627 ; CHECK-NEXT:    vminu.vx v8, v8, a0, v0.t
 628 ; CHECK-NEXT:    ret
 629   %elt.head = insertelement <vscale x 8 x i16> poison, i16 %b, i32 0
 630   %vb = shufflevector <vscale x 8 x i16> %elt.head, <vscale x 8 x i16> poison, <vscale x 8 x i32> zeroinitializer
 631   %v = call <vscale x 8 x i16> @llvm.vp.umin.nxv8i16(<vscale x 8 x i16> %va, <vscale x 8 x i16> %vb, <vscale x 8 x i1> %m, i32 %evl)
 632   ret <vscale x 8 x i16> %v
 633 }
 634
 635 define <vscale x 8 x i16> @vminu_vx_nxv8i16_unmasked(<vscale x 8 x i16> %va, i16 %b, i32 zeroext %evl) {
 636 ; CHECK-LABEL: vminu_vx_nxv8i16_unmasked:
 637 ; CHECK:       # %bb.0:
 638 ; CHECK-NEXT:    vsetvli zero, a1, e16, m2, ta, ma
 639 ; CHECK-NEXT:    vminu.vx v8, v8, a0
 640 ; CHECK-NEXT:    ret
 641   %elt.head = insertelement <vscale x 8 x i16> poison, i16 %b, i32 0
 642   %vb = shufflevector <vscale x 8 x i16> %elt.head, <vscale x 8 x i16> poison, <vscale x 8 x i32> zeroinitializer
 643   %v = call <vscale x 8 x i16> @llvm.vp.umin.nxv8i16(<vscale x 8 x i16> %va, <vscale x 8 x i16> %vb, <vscale x 8 x i1> splat (i1 true), i32 %evl)
 644   ret <vscale x 8 x i16> %v
 645 }
 646
 647 declare <vscale x 16 x i16> @llvm.vp.umin.nxv16i16(<vscale x 16 x i16>, <vscale x 16 x i16>, <vscale x 16 x i1>, i32)
 648
 649 define <vscale x 16 x i16> @vminu_vv_nxv16i16(<vscale x 16 x i16> %va, <vscale x 16 x i16> %b, <vscale x 16 x i1> %m, i32 zeroext %evl) {
 650 ; CHECK-LABEL: vminu_vv_nxv16i16:
 651 ; CHECK:       # %bb.0:
 652 ; CHECK-NEXT:    vsetvli zero, a0, e16, m4, ta, ma
 653 ; CHECK-NEXT:    vminu.vv v8, v8, v12, v0.t
 654 ; CHECK-NEXT:    ret
 655   %v = call <vscale x 16 x i16> @llvm.vp.umin.nxv16i16(<vscale x 16 x i16> %va, <vscale x 16 x i16> %b, <vscale x 16 x i1> %m, i32 %evl)
 656   ret <vscale x 16 x i16> %v
 657 }
 658
 659 define <vscale x 16 x i16> @vminu_vv_nxv16i16_unmasked(<vscale x 16 x i16> %va, <vscale x 16 x i16> %b, i32 zeroext %evl) {
 660 ; CHECK-LABEL: vminu_vv_nxv16i16_unmasked:
 661 ; CHECK:       # %bb.0:
 662 ; CHECK-NEXT:    vsetvli zero, a0, e16, m4, ta, ma
 663 ; CHECK-NEXT:    vminu.vv v8, v8, v12
 664 ; CHECK-NEXT:    ret
 665   %v = call <vscale x 16 x i16> @llvm.vp.umin.nxv16i16(<vscale x 16 x i16> %va, <vscale x 16 x i16> %b, <vscale x 16 x i1> splat (i1 true), i32 %evl)
 666   ret <vscale x 16 x i16> %v
 667 }
 668
 669 define <vscale x 16 x i16> @vminu_vx_nxv16i16(<vscale x 16 x i16> %va, i16 %b, <vscale x 16 x i1> %m, i32 zeroext %evl) {
 670 ; CHECK-LABEL: vminu_vx_nxv16i16:
 671 ; CHECK:       # %bb.0:
 672 ; CHECK-NEXT:    vsetvli zero, a1, e16, m4, ta, ma
 673 ; CHECK-NEXT:    vminu.vx v8, v8, a0, v0.t
 674 ; CHECK-NEXT:    ret
 675   %elt.head = insertelement <vscale x 16 x i16> poison, i16 %b, i32 0
 676   %vb = shufflevector <vscale x 16 x i16> %elt.head, <vscale x 16 x i16> poison, <vscale x 16 x i32> zeroinitializer
 677   %v = call <vscale x 16 x i16> @llvm.vp.umin.nxv16i16(<vscale x 16 x i16> %va, <vscale x 16 x i16> %vb, <vscale x 16 x i1> %m, i32 %evl)
 678   ret <vscale x 16 x i16> %v
 679 }
 680
 681 define <vscale x 16 x i16> @vminu_vx_nxv16i16_unmasked(<vscale x 16 x i16> %va, i16 %b, i32 zeroext %evl) {
 682 ; CHECK-LABEL: vminu_vx_nxv16i16_unmasked:
 683 ; CHECK:       # %bb.0:
 684 ; CHECK-NEXT:    vsetvli zero, a1, e16, m4, ta, ma
 685 ; CHECK-NEXT:    vminu.vx v8, v8, a0
 686 ; CHECK-NEXT:    ret
 687   %elt.head = insertelement <vscale x 16 x i16> poison, i16 %b, i32 0
 688   %vb = shufflevector <vscale x 16 x i16> %elt.head, <vscale x 16 x i16> poison, <vscale x 16 x i32> zeroinitializer
 689   %v = call <vscale x 16 x i16> @llvm.vp.umin.nxv16i16(<vscale x 16 x i16> %va, <vscale x 16 x i16> %vb, <vscale x 16 x i1> splat (i1 true), i32 %evl)
 690   ret <vscale x 16 x i16> %v
 691 }
 692
 693 declare <vscale x 32 x i16> @llvm.vp.umin.nxv32i16(<vscale x 32 x i16>, <vscale x 32 x i16>, <vscale x 32 x i1>, i32)
 694
 695 define <vscale x 32 x i16> @vminu_vv_nxv32i16(<vscale x 32 x i16> %va, <vscale x 32 x i16> %b, <vscale x 32 x i1> %m, i32 zeroext %evl) {
 696 ; CHECK-LABEL: vminu_vv_nxv32i16:
 697 ; CHECK:       # %bb.0:
 698 ; CHECK-NEXT:    vsetvli zero, a0, e16, m8, ta, ma
 699 ; CHECK-NEXT:    vminu.vv v8, v8, v16, v0.t
 700 ; CHECK-NEXT:    ret
 701   %v = call <vscale x 32 x i16> @llvm.vp.umin.nxv32i16(<vscale x 32 x i16> %va, <vscale x 32 x i16> %b, <vscale x 32 x i1> %m, i32 %evl)
 702   ret <vscale x 32 x i16> %v
 703 }
 704
 705 define <vscale x 32 x i16> @vminu_vv_nxv32i16_unmasked(<vscale x 32 x i16> %va, <vscale x 32 x i16> %b, i32 zeroext %evl) {
 706 ; CHECK-LABEL: vminu_vv_nxv32i16_unmasked:
 707 ; CHECK:       # %bb.0:
 708 ; CHECK-NEXT:    vsetvli zero, a0, e16, m8, ta, ma
 709 ; CHECK-NEXT:    vminu.vv v8, v8, v16
 710 ; CHECK-NEXT:    ret
 711   %v = call <vscale x 32 x i16> @llvm.vp.umin.nxv32i16(<vscale x 32 x i16> %va, <vscale x 32 x i16> %b, <vscale x 32 x i1> splat (i1 true), i32 %evl)
 712   ret <vscale x 32 x i16> %v
 713 }
 714
 715 define <vscale x 32 x i16> @vminu_vx_nxv32i16(<vscale x 32 x i16> %va, i16 %b, <vscale x 32 x i1> %m, i32 zeroext %evl) {
 716 ; CHECK-LABEL: vminu_vx_nxv32i16:
 717 ; CHECK:       # %bb.0:
 718 ; CHECK-NEXT:    vsetvli zero, a1, e16, m8, ta, ma
 719 ; CHECK-NEXT:    vminu.vx v8, v8, a0, v0.t
 720 ; CHECK-NEXT:    ret
 721   %elt.head = insertelement <vscale x 32 x i16> poison, i16 %b, i32 0
 722   %vb = shufflevector <vscale x 32 x i16> %elt.head, <vscale x 32 x i16> poison, <vscale x 32 x i32> zeroinitializer
 723   %v = call <vscale x 32 x i16> @llvm.vp.umin.nxv32i16(<vscale x 32 x i16> %va, <vscale x 32 x i16> %vb, <vscale x 32 x i1> %m, i32 %evl)
 724   ret <vscale x 32 x i16> %v
 725 }
 726
 727 define <vscale x 32 x i16> @vminu_vx_nxv32i16_unmasked(<vscale x 32 x i16> %va, i16 %b, i32 zeroext %evl) {
 728 ; CHECK-LABEL: vminu_vx_nxv32i16_unmasked:
 729 ; CHECK:       # %bb.0:
 730 ; CHECK-NEXT:    vsetvli zero, a1, e16, m8, ta, ma
 731 ; CHECK-NEXT:    vminu.vx v8, v8, a0
 732 ; CHECK-NEXT:    ret
 733   %elt.head = insertelement <vscale x 32 x i16> poison, i16 %b, i32 0
 734   %vb = shufflevector <vscale x 32 x i16> %elt.head, <vscale x 32 x i16> poison, <vscale x 32 x i32> zeroinitializer
 735   %v = call <vscale x 32 x i16> @llvm.vp.umin.nxv32i16(<vscale x 32 x i16> %va, <vscale x 32 x i16> %vb, <vscale x 32 x i1> splat (i1 true), i32 %evl)
 736   ret <vscale x 32 x i16> %v
 737 }
 738
 739 declare <vscale x 1 x i32> @llvm.vp.umin.nxv1i32(<vscale x 1 x i32>, <vscale x 1 x i32>, <vscale x 1 x i1>, i32)
 740
 741 define <vscale x 1 x i32> @vminu_vv_nxv1i32(<vscale x 1 x i32> %va, <vscale x 1 x i32> %b, <vscale x 1 x i1> %m, i32 zeroext %evl) {
 742 ; CHECK-LABEL: vminu_vv_nxv1i32:
 743 ; CHECK:       # %bb.0:
 744 ; CHECK-NEXT:    vsetvli zero, a0, e32, mf2, ta, ma
 745 ; CHECK-NEXT:    vminu.vv v8, v8, v9, v0.t
 746 ; CHECK-NEXT:    ret
 747   %v = call <vscale x 1 x i32> @llvm.vp.umin.nxv1i32(<vscale x 1 x i32> %va, <vscale x 1 x i32> %b, <vscale x 1 x i1> %m, i32 %evl)
 748   ret <vscale x 1 x i32> %v
 749 }
 750
 751 define <vscale x 1 x i32> @vminu_vv_nxv1i32_unmasked(<vscale x 1 x i32> %va, <vscale x 1 x i32> %b, i32 zeroext %evl) {
 752 ; CHECK-LABEL: vminu_vv_nxv1i32_unmasked:
 753 ; CHECK:       # %bb.0:
 754 ; CHECK-NEXT:    vsetvli zero, a0, e32, mf2, ta, ma
 755 ; CHECK-NEXT:    vminu.vv v8, v8, v9
 756 ; CHECK-NEXT:    ret
 757   %v = call <vscale x 1 x i32> @llvm.vp.umin.nxv1i32(<vscale x 1 x i32> %va, <vscale x 1 x i32> %b, <vscale x 1 x i1> splat (i1 true), i32 %evl)
 758   ret <vscale x 1 x i32> %v
 759 }
 760
 761 define <vscale x 1 x i32> @vminu_vx_nxv1i32(<vscale x 1 x i32> %va, i32 %b, <vscale x 1 x i1> %m, i32 zeroext %evl) {
 762 ; CHECK-LABEL: vminu_vx_nxv1i32:
 763 ; CHECK:       # %bb.0:
 764 ; CHECK-NEXT:    vsetvli zero, a1, e32, mf2, ta, ma
 765 ; CHECK-NEXT:    vminu.vx v8, v8, a0, v0.t
 766 ; CHECK-NEXT:    ret
 767   %elt.head = insertelement <vscale x 1 x i32> poison, i32 %b, i32 0
 768   %vb = shufflevector <vscale x 1 x i32> %elt.head, <vscale x 1 x i32> poison, <vscale x 1 x i32> zeroinitializer
 769   %v = call <vscale x 1 x i32> @llvm.vp.umin.nxv1i32(<vscale x 1 x i32> %va, <vscale x 1 x i32> %vb, <vscale x 1 x i1> %m, i32 %evl)
 770   ret <vscale x 1 x i32> %v
 771 }
 772
 773 define <vscale x 1 x i32> @vminu_vx_nxv1i32_unmasked(<vscale x 1 x i32> %va, i32 %b, i32 zeroext %evl) {
 774 ; CHECK-LABEL: vminu_vx_nxv1i32_unmasked:
 775 ; CHECK:       # %bb.0:
 776 ; CHECK-NEXT:    vsetvli zero, a1, e32, mf2, ta, ma
 777 ; CHECK-NEXT:    vminu.vx v8, v8, a0
 778 ; CHECK-NEXT:    ret
 779   %elt.head = insertelement <vscale x 1 x i32> poison, i32 %b, i32 0
 780   %vb = shufflevector <vscale x 1 x i32> %elt.head, <vscale x 1 x i32> poison, <vscale x 1 x i32> zeroinitializer
 781   %v = call <vscale x 1 x i32> @llvm.vp.umin.nxv1i32(<vscale x 1 x i32> %va, <vscale x 1 x i32> %vb, <vscale x 1 x i1> splat (i1 true), i32 %evl)
 782   ret <vscale x 1 x i32> %v
 783 }
 784
 785 declare <vscale x 2 x i32> @llvm.vp.umin.nxv2i32(<vscale x 2 x i32>, <vscale x 2 x i32>, <vscale x 2 x i1>, i32)
 786
 787 define <vscale x 2 x i32> @vminu_vv_nxv2i32(<vscale x 2 x i32> %va, <vscale x 2 x i32> %b, <vscale x 2 x i1> %m, i32 zeroext %evl) {
 788 ; CHECK-LABEL: vminu_vv_nxv2i32:
 789 ; CHECK:       # %bb.0:
 790 ; CHECK-NEXT:    vsetvli zero, a0, e32, m1, ta, ma
 791 ; CHECK-NEXT:    vminu.vv v8, v8, v9, v0.t
 792 ; CHECK-NEXT:    ret
 793   %v = call <vscale x 2 x i32> @llvm.vp.umin.nxv2i32(<vscale x 2 x i32> %va, <vscale x 2 x i32> %b, <vscale x 2 x i1> %m, i32 %evl)
 794   ret <vscale x 2 x i32> %v
 795 }
 796
 797 define <vscale x 2 x i32> @vminu_vv_nxv2i32_unmasked(<vscale x 2 x i32> %va, <vscale x 2 x i32> %b, i32 zeroext %evl) {
 798 ; CHECK-LABEL: vminu_vv_nxv2i32_unmasked:
 799 ; CHECK:       # %bb.0:
 800 ; CHECK-NEXT:    vsetvli zero, a0, e32, m1, ta, ma
 801 ; CHECK-NEXT:    vminu.vv v8, v8, v9
 802 ; CHECK-NEXT:    ret
 803   %v = call <vscale x 2 x i32> @llvm.vp.umin.nxv2i32(<vscale x 2 x i32> %va, <vscale x 2 x i32> %b, <vscale x 2 x i1> splat (i1 true), i32 %evl)
 804   ret <vscale x 2 x i32> %v
 805 }
 806
 807 define <vscale x 2 x i32> @vminu_vx_nxv2i32(<vscale x 2 x i32> %va, i32 %b, <vscale x 2 x i1> %m, i32 zeroext %evl) {
 808 ; CHECK-LABEL: vminu_vx_nxv2i32:
 809 ; CHECK:       # %bb.0:
 810 ; CHECK-NEXT:    vsetvli zero, a1, e32, m1, ta, ma
 811 ; CHECK-NEXT:    vminu.vx v8, v8, a0, v0.t
 812 ; CHECK-NEXT:    ret
 813   %elt.head = insertelement <vscale x 2 x i32> poison, i32 %b, i32 0
 814   %vb = shufflevector <vscale x 2 x i32> %elt.head, <vscale x 2 x i32> poison, <vscale x 2 x i32> zeroinitializer
 815   %v = call <vscale x 2 x i32> @llvm.vp.umin.nxv2i32(<vscale x 2 x i32> %va, <vscale x 2 x i32> %vb, <vscale x 2 x i1> %m, i32 %evl)
 816   ret <vscale x 2 x i32> %v
 817 }
 818
 819 define <vscale x 2 x i32> @vminu_vx_nxv2i32_unmasked(<vscale x 2 x i32> %va, i32 %b, i32 zeroext %evl) {
 820 ; CHECK-LABEL: vminu_vx_nxv2i32_unmasked:
 821 ; CHECK:       # %bb.0:
 822 ; CHECK-NEXT:    vsetvli zero, a1, e32, m1, ta, ma
 823 ; CHECK-NEXT:    vminu.vx v8, v8, a0
 824 ; CHECK-NEXT:    ret
 825   %elt.head = insertelement <vscale x 2 x i32> poison, i32 %b, i32 0
 826   %vb = shufflevector <vscale x 2 x i32> %elt.head, <vscale x 2 x i32> poison, <vscale x 2 x i32> zeroinitializer
 827   %v = call <vscale x 2 x i32> @llvm.vp.umin.nxv2i32(<vscale x 2 x i32> %va, <vscale x 2 x i32> %vb, <vscale x 2 x i1> splat (i1 true), i32 %evl)
 828   ret <vscale x 2 x i32> %v
 829 }
 830
 831 declare <vscale x 4 x i32> @llvm.vp.umin.nxv4i32(<vscale x 4 x i32>, <vscale x 4 x i32>, <vscale x 4 x i1>, i32)
 832
 833 define <vscale x 4 x i32> @vminu_vv_nxv4i32(<vscale x 4 x i32> %va, <vscale x 4 x i32> %b, <vscale x 4 x i1> %m, i32 zeroext %evl) {
 834 ; CHECK-LABEL: vminu_vv_nxv4i32:
 835 ; CHECK:       # %bb.0:
 836 ; CHECK-NEXT:    vsetvli zero, a0, e32, m2, ta, ma
 837 ; CHECK-NEXT:    vminu.vv v8, v8, v10, v0.t
 838 ; CHECK-NEXT:    ret
 839   %v = call <vscale x 4 x i32> @llvm.vp.umin.nxv4i32(<vscale x 4 x i32> %va, <vscale x 4 x i32> %b, <vscale x 4 x i1> %m, i32 %evl)
 840   ret <vscale x 4 x i32> %v
 841 }
 842
 843 define <vscale x 4 x i32> @vminu_vv_nxv4i32_unmasked(<vscale x 4 x i32> %va, <vscale x 4 x i32> %b, i32 zeroext %evl) {
 844 ; CHECK-LABEL: vminu_vv_nxv4i32_unmasked:
 845 ; CHECK:       # %bb.0:
 846 ; CHECK-NEXT:    vsetvli zero, a0, e32, m2, ta, ma
 847 ; CHECK-NEXT:    vminu.vv v8, v8, v10
 848 ; CHECK-NEXT:    ret
 849   %v = call <vscale x 4 x i32> @llvm.vp.umin.nxv4i32(<vscale x 4 x i32> %va, <vscale x 4 x i32> %b, <vscale x 4 x i1> splat (i1 true), i32 %evl)
 850   ret <vscale x 4 x i32> %v
 851 }
 852
 853 define <vscale x 4 x i32> @vminu_vx_nxv4i32(<vscale x 4 x i32> %va, i32 %b, <vscale x 4 x i1> %m, i32 zeroext %evl) {
 854 ; CHECK-LABEL: vminu_vx_nxv4i32:
 855 ; CHECK:       # %bb.0:
 856 ; CHECK-NEXT:    vsetvli zero, a1, e32, m2, ta, ma
 857 ; CHECK-NEXT:    vminu.vx v8, v8, a0, v0.t
 858 ; CHECK-NEXT:    ret
 859   %elt.head = insertelement <vscale x 4 x i32> poison, i32 %b, i32 0
 860   %vb = shufflevector <vscale x 4 x i32> %elt.head, <vscale x 4 x i32> poison, <vscale x 4 x i32> zeroinitializer
 861   %v = call <vscale x 4 x i32> @llvm.vp.umin.nxv4i32(<vscale x 4 x i32> %va, <vscale x 4 x i32> %vb, <vscale x 4 x i1> %m, i32 %evl)
 862   ret <vscale x 4 x i32> %v
 863 }
 864
 865 define <vscale x 4 x i32> @vminu_vx_nxv4i32_unmasked(<vscale x 4 x i32> %va, i32 %b, i32 zeroext %evl) {
 866 ; CHECK-LABEL: vminu_vx_nxv4i32_unmasked:
 867 ; CHECK:       # %bb.0:
 868 ; CHECK-NEXT:    vsetvli zero, a1, e32, m2, ta, ma
 869 ; CHECK-NEXT:    vminu.vx v8, v8, a0
 870 ; CHECK-NEXT:    ret
 871   %elt.head = insertelement <vscale x 4 x i32> poison, i32 %b, i32 0
 872   %vb = shufflevector <vscale x 4 x i32> %elt.head, <vscale x 4 x i32> poison, <vscale x 4 x i32> zeroinitializer
 873   %v = call <vscale x 4 x i32> @llvm.vp.umin.nxv4i32(<vscale x 4 x i32> %va, <vscale x 4 x i32> %vb, <vscale x 4 x i1> splat (i1 true), i32 %evl)
 874   ret <vscale x 4 x i32> %v
 875 }
 876
 877 declare <vscale x 8 x i32> @llvm.vp.umin.nxv8i32(<vscale x 8 x i32>, <vscale x 8 x i32>, <vscale x 8 x i1>, i32)
 878
 879 define <vscale x 8 x i32> @vminu_vv_nxv8i32(<vscale x 8 x i32> %va, <vscale x 8 x i32> %b, <vscale x 8 x i1> %m, i32 zeroext %evl) {
 880 ; CHECK-LABEL: vminu_vv_nxv8i32:
 881 ; CHECK:       # %bb.0:
 882 ; CHECK-NEXT:    vsetvli zero, a0, e32, m4, ta, ma
 883 ; CHECK-NEXT:    vminu.vv v8, v8, v12, v0.t
 884 ; CHECK-NEXT:    ret
 885   %v = call <vscale x 8 x i32> @llvm.vp.umin.nxv8i32(<vscale x 8 x i32> %va, <vscale x 8 x i32> %b, <vscale x 8 x i1> %m, i32 %evl)
 886   ret <vscale x 8 x i32> %v
 887 }
 888
 889 define <vscale x 8 x i32> @vminu_vv_nxv8i32_unmasked(<vscale x 8 x i32> %va, <vscale x 8 x i32> %b, i32 zeroext %evl) {
 890 ; CHECK-LABEL: vminu_vv_nxv8i32_unmasked:
 891 ; CHECK:       # %bb.0:
 892 ; CHECK-NEXT:    vsetvli zero, a0, e32, m4, ta, ma
 893 ; CHECK-NEXT:    vminu.vv v8, v8, v12
 894 ; CHECK-NEXT:    ret
 895   %v = call <vscale x 8 x i32> @llvm.vp.umin.nxv8i32(<vscale x 8 x i32> %va, <vscale x 8 x i32> %b, <vscale x 8 x i1> splat (i1 true), i32 %evl)
 896   ret <vscale x 8 x i32> %v
 897 }
 898
 899 define <vscale x 8 x i32> @vminu_vx_nxv8i32(<vscale x 8 x i32> %va, i32 %b, <vscale x 8 x i1> %m, i32 zeroext %evl) {
 900 ; CHECK-LABEL: vminu_vx_nxv8i32:
 901 ; CHECK:       # %bb.0:
 902 ; CHECK-NEXT:    vsetvli zero, a1, e32, m4, ta, ma
 903 ; CHECK-NEXT:    vminu.vx v8, v8, a0, v0.t
 904 ; CHECK-NEXT:    ret
 905   %elt.head = insertelement <vscale x 8 x i32> poison, i32 %b, i32 0
 906   %vb = shufflevector <vscale x 8 x i32> %elt.head, <vscale x 8 x i32> poison, <vscale x 8 x i32> zeroinitializer
 907   %v = call <vscale x 8 x i32> @llvm.vp.umin.nxv8i32(<vscale x 8 x i32> %va, <vscale x 8 x i32> %vb, <vscale x 8 x i1> %m, i32 %evl)
 908   ret <vscale x 8 x i32> %v
 909 }
 910
 911 define <vscale x 8 x i32> @vminu_vx_nxv8i32_unmasked(<vscale x 8 x i32> %va, i32 %b, i32 zeroext %evl) {
 912 ; CHECK-LABEL: vminu_vx_nxv8i32_unmasked:
 913 ; CHECK:       # %bb.0:
 914 ; CHECK-NEXT:    vsetvli zero, a1, e32, m4, ta, ma
 915 ; CHECK-NEXT:    vminu.vx v8, v8, a0
 916 ; CHECK-NEXT:    ret
 917   %elt.head = insertelement <vscale x 8 x i32> poison, i32 %b, i32 0
 918   %vb = shufflevector <vscale x 8 x i32> %elt.head, <vscale x 8 x i32> poison, <vscale x 8 x i32> zeroinitializer
 919   %v = call <vscale x 8 x i32> @llvm.vp.umin.nxv8i32(<vscale x 8 x i32> %va, <vscale x 8 x i32> %vb, <vscale x 8 x i1> splat (i1 true), i32 %evl)
 920   ret <vscale x 8 x i32> %v
 921 }
 922
 923 declare <vscale x 16 x i32> @llvm.vp.umin.nxv16i32(<vscale x 16 x i32>, <vscale x 16 x i32>, <vscale x 16 x i1>, i32)
 924
 925 define <vscale x 16 x i32> @vminu_vv_nxv16i32(<vscale x 16 x i32> %va, <vscale x 16 x i32> %b, <vscale x 16 x i1> %m, i32 zeroext %evl) {
 926 ; CHECK-LABEL: vminu_vv_nxv16i32:
 927 ; CHECK:       # %bb.0:
 928 ; CHECK-NEXT:    vsetvli zero, a0, e32, m8, ta, ma
 929 ; CHECK-NEXT:    vminu.vv v8, v8, v16, v0.t
 930 ; CHECK-NEXT:    ret
 931   %v = call <vscale x 16 x i32> @llvm.vp.umin.nxv16i32(<vscale x 16 x i32> %va, <vscale x 16 x i32> %b, <vscale x 16 x i1> %m, i32 %evl)
 932   ret <vscale x 16 x i32> %v
 933 }
 934
 935 define <vscale x 16 x i32> @vminu_vv_nxv16i32_unmasked(<vscale x 16 x i32> %va, <vscale x 16 x i32> %b, i32 zeroext %evl) {
 936 ; CHECK-LABEL: vminu_vv_nxv16i32_unmasked:
 937 ; CHECK:       # %bb.0:
 938 ; CHECK-NEXT:    vsetvli zero, a0, e32, m8, ta, ma
 939 ; CHECK-NEXT:    vminu.vv v8, v8, v16
 940 ; CHECK-NEXT:    ret
 941   %v = call <vscale x 16 x i32> @llvm.vp.umin.nxv16i32(<vscale x 16 x i32> %va, <vscale x 16 x i32> %b, <vscale x 16 x i1> splat (i1 true), i32 %evl)
 942   ret <vscale x 16 x i32> %v
 943 }
 944
 945 define <vscale x 16 x i32> @vminu_vx_nxv16i32(<vscale x 16 x i32> %va, i32 %b, <vscale x 16 x i1> %m, i32 zeroext %evl) {
 946 ; CHECK-LABEL: vminu_vx_nxv16i32:
 947 ; CHECK:       # %bb.0:
 948 ; CHECK-NEXT:    vsetvli zero, a1, e32, m8, ta, ma
 949 ; CHECK-NEXT:    vminu.vx v8, v8, a0, v0.t
 950 ; CHECK-NEXT:    ret
 951   %elt.head = insertelement <vscale x 16 x i32> poison, i32 %b, i32 0
 952   %vb = shufflevector <vscale x 16 x i32> %elt.head, <vscale x 16 x i32> poison, <vscale x 16 x i32> zeroinitializer
 953   %v = call <vscale x 16 x i32> @llvm.vp.umin.nxv16i32(<vscale x 16 x i32> %va, <vscale x 16 x i32> %vb, <vscale x 16 x i1> %m, i32 %evl)
 954   ret <vscale x 16 x i32> %v
 955 }
 956
 957 define <vscale x 16 x i32> @vminu_vx_nxv16i32_unmasked(<vscale x 16 x i32> %va, i32 %b, i32 zeroext %evl) {
 958 ; CHECK-LABEL: vminu_vx_nxv16i32_unmasked:
 959 ; CHECK:       # %bb.0:
 960 ; CHECK-NEXT:    vsetvli zero, a1, e32, m8, ta, ma
 961 ; CHECK-NEXT:    vminu.vx v8, v8, a0
 962 ; CHECK-NEXT:    ret
 963   %elt.head = insertelement <vscale x 16 x i32> poison, i32 %b, i32 0
 964   %vb = shufflevector <vscale x 16 x i32> %elt.head, <vscale x 16 x i32> poison, <vscale x 16 x i32> zeroinitializer
 965   %v = call <vscale x 16 x i32> @llvm.vp.umin.nxv16i32(<vscale x 16 x i32> %va, <vscale x 16 x i32> %vb, <vscale x 16 x i1> splat (i1 true), i32 %evl)
 966   ret <vscale x 16 x i32> %v
 967 }
 968
 969 ; Test that split-legalization works then the mask needs manual splitting.
 970
 971 declare <vscale x 32 x i32> @llvm.vp.umin.nxv32i32(<vscale x 32 x i32>, <vscale x 32 x i32>, <vscale x 32 x i1>, i32)
 972
 973 define <vscale x 32 x i32> @vminu_vx_nxv32i32(<vscale x 32 x i32> %va, i32 %b, <vscale x 32 x i1> %m, i32 zeroext %evl) {
 974 ; CHECK-LABEL: vminu_vx_nxv32i32:
 975 ; CHECK:       # %bb.0:
 976 ; CHECK-NEXT:    vmv1r.v v24, v0
 977 ; CHECK-NEXT:    csrr a2, vlenb
 978 ; CHECK-NEXT:    srli a3, a2, 2
 979 ; CHECK-NEXT:    vsetvli a4, zero, e8, mf2, ta, ma
 980 ; CHECK-NEXT:    vslidedown.vx v0, v0, a3
 981 ; CHECK-NEXT:    slli a2, a2, 1
 982 ; CHECK-NEXT:    sub a3, a1, a2
 983 ; CHECK-NEXT:    sltu a4, a1, a3
 984 ; CHECK-NEXT:    addi a4, a4, -1
 985 ; CHECK-NEXT:    and a3, a4, a3
 986 ; CHECK-NEXT:    vsetvli zero, a3, e32, m8, ta, ma
 987 ; CHECK-NEXT:    vminu.vx v16, v16, a0, v0.t
 988 ; CHECK-NEXT:    bltu a1, a2, .LBB80_2
 989 ; CHECK-NEXT:  # %bb.1:
 990 ; CHECK-NEXT:    mv a1, a2
 991 ; CHECK-NEXT:  .LBB80_2:
 992 ; CHECK-NEXT:    vmv1r.v v0, v24
 993 ; CHECK-NEXT:    vsetvli zero, a1, e32, m8, ta, ma
 994 ; CHECK-NEXT:    vminu.vx v8, v8, a0, v0.t
 995 ; CHECK-NEXT:    ret
 996   %elt.head = insertelement <vscale x 32 x i32> poison, i32 %b, i32 0
 997   %vb = shufflevector <vscale x 32 x i32> %elt.head, <vscale x 32 x i32> poison, <vscale x 32 x i32> zeroinitializer
 998   %v = call <vscale x 32 x i32> @llvm.vp.umin.nxv32i32(<vscale x 32 x i32> %va, <vscale x 32 x i32> %vb, <vscale x 32 x i1> %m, i32 %evl)
 999   ret <vscale x 32 x i32> %v
1000 }
1001
1002 define <vscale x 32 x i32> @vminu_vx_nxv32i32_unmasked(<vscale x 32 x i32> %va, i32 %b, i32 zeroext %evl) {
1003 ; CHECK-LABEL: vminu_vx_nxv32i32_unmasked:
1004 ; CHECK:       # %bb.0:
1005 ; CHECK-NEXT:    csrr a2, vlenb
1006 ; CHECK-NEXT:    slli a2, a2, 1
1007 ; CHECK-NEXT:    sub a3, a1, a2
1008 ; CHECK-NEXT:    sltu a4, a1, a3
1009 ; CHECK-NEXT:    addi a4, a4, -1
1010 ; CHECK-NEXT:    and a3, a4, a3
1011 ; CHECK-NEXT:    vsetvli zero, a3, e32, m8, ta, ma
1012 ; CHECK-NEXT:    vminu.vx v16, v16, a0
1013 ; CHECK-NEXT:    bltu a1, a2, .LBB81_2
1014 ; CHECK-NEXT:  # %bb.1:
1015 ; CHECK-NEXT:    mv a1, a2
1016 ; CHECK-NEXT:  .LBB81_2:
1017 ; CHECK-NEXT:    vsetvli zero, a1, e32, m8, ta, ma
1018 ; CHECK-NEXT:    vminu.vx v8, v8, a0
1019 ; CHECK-NEXT:    ret
1020   %elt.head = insertelement <vscale x 32 x i32> poison, i32 %b, i32 0
1021   %vb = shufflevector <vscale x 32 x i32> %elt.head, <vscale x 32 x i32> poison, <vscale x 32 x i32> zeroinitializer
1022   %v = call <vscale x 32 x i32> @llvm.vp.umin.nxv32i32(<vscale x 32 x i32> %va, <vscale x 32 x i32> %vb, <vscale x 32 x i1> splat (i1 true), i32 %evl)
1023   ret <vscale x 32 x i32> %v
1024 }
1025
1026 ; Test splitting when the %evl is a constant (albeit an unknown one).
1027
1028 declare i32 @llvm.vscale.i32()
1029
1030 ; FIXME: The upper half of the operation is doing nothing.
1031 ; FIXME: The branches comparing vscale vs. vscale should be constant-foldable.
1032
1033 define <vscale x 32 x i32> @vminu_vx_nxv32i32_evl_nx8(<vscale x 32 x i32> %va, i32 %b, <vscale x 32 x i1> %m) {
1034 ; CHECK-LABEL: vminu_vx_nxv32i32_evl_nx8:
1035 ; CHECK:       # %bb.0:
1036 ; CHECK-NEXT:    vmv1r.v v24, v0
1037 ; CHECK-NEXT:    csrr a1, vlenb
1038 ; CHECK-NEXT:    srli a2, a1, 2
1039 ; CHECK-NEXT:    vsetvli a3, zero, e8, mf2, ta, ma
1040 ; CHECK-NEXT:    vslidedown.vx v0, v0, a2
1041 ; CHECK-NEXT:    slli a2, a1, 1
1042 ; CHECK-NEXT:    sub a3, a1, a2
1043 ; CHECK-NEXT:    sltu a4, a1, a3
1044 ; CHECK-NEXT:    addi a4, a4, -1
1045 ; CHECK-NEXT:    and a3, a4, a3
1046 ; CHECK-NEXT:    vsetvli zero, a3, e32, m8, ta, ma
1047 ; CHECK-NEXT:    vminu.vx v16, v16, a0, v0.t
1048 ; CHECK-NEXT:    bltu a1, a2, .LBB82_2
1049 ; CHECK-NEXT:  # %bb.1:
1050 ; CHECK-NEXT:    mv a1, a2
1051 ; CHECK-NEXT:  .LBB82_2:
1052 ; CHECK-NEXT:    vmv1r.v v0, v24
1053 ; CHECK-NEXT:    vsetvli zero, a1, e32, m8, ta, ma
1054 ; CHECK-NEXT:    vminu.vx v8, v8, a0, v0.t
1055 ; CHECK-NEXT:    ret
1056   %elt.head = insertelement <vscale x 32 x i32> poison, i32 %b, i32 0
1057   %vb = shufflevector <vscale x 32 x i32> %elt.head, <vscale x 32 x i32> poison, <vscale x 32 x i32> zeroinitializer
1058   %evl = call i32 @llvm.vscale.i32()
1059   %evl0 = mul i32 %evl, 8
1060   %v = call <vscale x 32 x i32> @llvm.vp.umin.nxv32i32(<vscale x 32 x i32> %va, <vscale x 32 x i32> %vb, <vscale x 32 x i1> %m, i32 %evl0)
1061   ret <vscale x 32 x i32> %v
1062 }
1063
1064 ; FIXME: The first vminu.vx should be able to infer that its AVL is equivalent to VLMAX.
1065 ; FIXME: The upper half of the operation is doing nothing but we don't catch
1066 ; that on RV64; we issue a usubsat(and (vscale x 16), 0xffffffff, vscale x 16)
1067 ; (the "original" %evl is the "and", due to known-bits issues with legalizing
1068 ; the i32 %evl to i64) and this isn't detected as 0.
1069 ; This could be resolved in the future with more detailed KnownBits analysis
1070 ; for ISD::VSCALE.
1071
1072 define <vscale x 32 x i32> @vminu_vx_nxv32i32_evl_nx16(<vscale x 32 x i32> %va, i32 %b, <vscale x 32 x i1> %m) {
1073 ; RV32-LABEL: vminu_vx_nxv32i32_evl_nx16:
1074 ; RV32:       # %bb.0:
1075 ; RV32-NEXT:    vsetvli a1, zero, e32, m8, ta, ma
1076 ; RV32-NEXT:    vminu.vx v8, v8, a0, v0.t
1077 ; RV32-NEXT:    ret
1078 ;
1079 ; RV64-LABEL: vminu_vx_nxv32i32_evl_nx16:
1080 ; RV64:       # %bb.0:
1081 ; RV64-NEXT:    csrr a1, vlenb
1082 ; RV64-NEXT:    srli a1, a1, 2
1083 ; RV64-NEXT:    vsetvli a2, zero, e8, mf2, ta, ma
1084 ; RV64-NEXT:    vslidedown.vx v24, v0, a1
1085 ; RV64-NEXT:    vsetvli a1, zero, e32, m8, ta, ma
1086 ; RV64-NEXT:    vminu.vx v8, v8, a0, v0.t
1087 ; RV64-NEXT:    vmv1r.v v0, v24
1088 ; RV64-NEXT:    vsetivli zero, 0, e32, m8, ta, ma
1089 ; RV64-NEXT:    vminu.vx v16, v16, a0, v0.t
1090 ; RV64-NEXT:    ret
1091   %elt.head = insertelement <vscale x 32 x i32> poison, i32 %b, i32 0
1092   %vb = shufflevector <vscale x 32 x i32> %elt.head, <vscale x 32 x i32> poison, <vscale x 32 x i32> zeroinitializer
1093   %evl = call i32 @llvm.vscale.i32()
1094   %evl0 = mul i32 %evl, 16
1095   %v = call <vscale x 32 x i32> @llvm.vp.umin.nxv32i32(<vscale x 32 x i32> %va, <vscale x 32 x i32> %vb, <vscale x 32 x i1> %m, i32 %evl0)
1096   ret <vscale x 32 x i32> %v
1097 }
1098
1099 declare <vscale x 1 x i64> @llvm.vp.umin.nxv1i64(<vscale x 1 x i64>, <vscale x 1 x i64>, <vscale x 1 x i1>, i32)
1100
1101 define <vscale x 1 x i64> @vminu_vv_nxv1i64(<vscale x 1 x i64> %va, <vscale x 1 x i64> %b, <vscale x 1 x i1> %m, i32 zeroext %evl) {
1102 ; CHECK-LABEL: vminu_vv_nxv1i64:
1103 ; CHECK:       # %bb.0:
1104 ; CHECK-NEXT:    vsetvli zero, a0, e64, m1, ta, ma
1105 ; CHECK-NEXT:    vminu.vv v8, v8, v9, v0.t
1106 ; CHECK-NEXT:    ret
1107   %v = call <vscale x 1 x i64> @llvm.vp.umin.nxv1i64(<vscale x 1 x i64> %va, <vscale x 1 x i64> %b, <vscale x 1 x i1> %m, i32 %evl)
1108   ret <vscale x 1 x i64> %v
1109 }
1110
1111 define <vscale x 1 x i64> @vminu_vv_nxv1i64_unmasked(<vscale x 1 x i64> %va, <vscale x 1 x i64> %b, i32 zeroext %evl) {
1112 ; CHECK-LABEL: vminu_vv_nxv1i64_unmasked:
1113 ; CHECK:       # %bb.0:
1114 ; CHECK-NEXT:    vsetvli zero, a0, e64, m1, ta, ma
1115 ; CHECK-NEXT:    vminu.vv v8, v8, v9
1116 ; CHECK-NEXT:    ret
1117   %v = call <vscale x 1 x i64> @llvm.vp.umin.nxv1i64(<vscale x 1 x i64> %va, <vscale x 1 x i64> %b, <vscale x 1 x i1> splat (i1 true), i32 %evl)
1118   ret <vscale x 1 x i64> %v
1119 }
1120
1121 define <vscale x 1 x i64> @vminu_vx_nxv1i64(<vscale x 1 x i64> %va, i64 %b, <vscale x 1 x i1> %m, i32 zeroext %evl) {
1122 ; RV32-LABEL: vminu_vx_nxv1i64:
1123 ; RV32:       # %bb.0:
1124 ; RV32-NEXT:    addi sp, sp, -16
1125 ; RV32-NEXT:    .cfi_def_cfa_offset 16
1126 ; RV32-NEXT:    sw a1, 12(sp)
1127 ; RV32-NEXT:    sw a0, 8(sp)
1128 ; RV32-NEXT:    addi a0, sp, 8
1129 ; RV32-NEXT:    vsetvli a1, zero, e64, m1, ta, ma
1130 ; RV32-NEXT:    vlse64.v v9, (a0), zero
1131 ; RV32-NEXT:    vsetvli zero, a2, e64, m1, ta, ma
1132 ; RV32-NEXT:    vminu.vv v8, v8, v9, v0.t
1133 ; RV32-NEXT:    addi sp, sp, 16
1134 ; RV32-NEXT:    ret
1135 ;
1136 ; RV64-LABEL: vminu_vx_nxv1i64:
1137 ; RV64:       # %bb.0:
1138 ; RV64-NEXT:    vsetvli zero, a1, e64, m1, ta, ma
1139 ; RV64-NEXT:    vminu.vx v8, v8, a0, v0.t
1140 ; RV64-NEXT:    ret
1141   %elt.head = insertelement <vscale x 1 x i64> poison, i64 %b, i32 0
1142   %vb = shufflevector <vscale x 1 x i64> %elt.head, <vscale x 1 x i64> poison, <vscale x 1 x i32> zeroinitializer
1143   %v = call <vscale x 1 x i64> @llvm.vp.umin.nxv1i64(<vscale x 1 x i64> %va, <vscale x 1 x i64> %vb, <vscale x 1 x i1> %m, i32 %evl)
1144   ret <vscale x 1 x i64> %v
1145 }
1146
1147 define <vscale x 1 x i64> @vminu_vx_nxv1i64_unmasked(<vscale x 1 x i64> %va, i64 %b, i32 zeroext %evl) {
1148 ; RV32-LABEL: vminu_vx_nxv1i64_unmasked:
1149 ; RV32:       # %bb.0:
1150 ; RV32-NEXT:    addi sp, sp, -16
1151 ; RV32-NEXT:    .cfi_def_cfa_offset 16
1152 ; RV32-NEXT:    sw a1, 12(sp)
1153 ; RV32-NEXT:    sw a0, 8(sp)
1154 ; RV32-NEXT:    addi a0, sp, 8
1155 ; RV32-NEXT:    vsetvli a1, zero, e64, m1, ta, ma
1156 ; RV32-NEXT:    vlse64.v v9, (a0), zero
1157 ; RV32-NEXT:    vsetvli zero, a2, e64, m1, ta, ma
1158 ; RV32-NEXT:    vminu.vv v8, v8, v9
1159 ; RV32-NEXT:    addi sp, sp, 16
1160 ; RV32-NEXT:    ret
1161 ;
1162 ; RV64-LABEL: vminu_vx_nxv1i64_unmasked:
1163 ; RV64:       # %bb.0:
1164 ; RV64-NEXT:    vsetvli zero, a1, e64, m1, ta, ma
1165 ; RV64-NEXT:    vminu.vx v8, v8, a0
1166 ; RV64-NEXT:    ret
1167   %elt.head = insertelement <vscale x 1 x i64> poison, i64 %b, i32 0
1168   %vb = shufflevector <vscale x 1 x i64> %elt.head, <vscale x 1 x i64> poison, <vscale x 1 x i32> zeroinitializer
1169   %v = call <vscale x 1 x i64> @llvm.vp.umin.nxv1i64(<vscale x 1 x i64> %va, <vscale x 1 x i64> %vb, <vscale x 1 x i1> splat (i1 true), i32 %evl)
1170   ret <vscale x 1 x i64> %v
1171 }
1172
1173 declare <vscale x 2 x i64> @llvm.vp.umin.nxv2i64(<vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i1>, i32)
1174
1175 define <vscale x 2 x i64> @vminu_vv_nxv2i64(<vscale x 2 x i64> %va, <vscale x 2 x i64> %b, <vscale x 2 x i1> %m, i32 zeroext %evl) {
1176 ; CHECK-LABEL: vminu_vv_nxv2i64:
1177 ; CHECK:       # %bb.0:
1178 ; CHECK-NEXT:    vsetvli zero, a0, e64, m2, ta, ma
1179 ; CHECK-NEXT:    vminu.vv v8, v8, v10, v0.t
1180 ; CHECK-NEXT:    ret
1181   %v = call <vscale x 2 x i64> @llvm.vp.umin.nxv2i64(<vscale x 2 x i64> %va, <vscale x 2 x i64> %b, <vscale x 2 x i1> %m, i32 %evl)
1182   ret <vscale x 2 x i64> %v
1183 }
1184
1185 define <vscale x 2 x i64> @vminu_vv_nxv2i64_unmasked(<vscale x 2 x i64> %va, <vscale x 2 x i64> %b, i32 zeroext %evl) {
1186 ; CHECK-LABEL: vminu_vv_nxv2i64_unmasked:
1187 ; CHECK:       # %bb.0:
1188 ; CHECK-NEXT:    vsetvli zero, a0, e64, m2, ta, ma
1189 ; CHECK-NEXT:    vminu.vv v8, v8, v10
1190 ; CHECK-NEXT:    ret
1191   %v = call <vscale x 2 x i64> @llvm.vp.umin.nxv2i64(<vscale x 2 x i64> %va, <vscale x 2 x i64> %b, <vscale x 2 x i1> splat (i1 true), i32 %evl)
1192   ret <vscale x 2 x i64> %v
1193 }
1194
1195 define <vscale x 2 x i64> @vminu_vx_nxv2i64(<vscale x 2 x i64> %va, i64 %b, <vscale x 2 x i1> %m, i32 zeroext %evl) {
1196 ; RV32-LABEL: vminu_vx_nxv2i64:
1197 ; RV32:       # %bb.0:
1198 ; RV32-NEXT:    addi sp, sp, -16
1199 ; RV32-NEXT:    .cfi_def_cfa_offset 16
1200 ; RV32-NEXT:    sw a1, 12(sp)
1201 ; RV32-NEXT:    sw a0, 8(sp)
1202 ; RV32-NEXT:    addi a0, sp, 8
1203 ; RV32-NEXT:    vsetvli a1, zero, e64, m2, ta, ma
1204 ; RV32-NEXT:    vlse64.v v10, (a0), zero
1205 ; RV32-NEXT:    vsetvli zero, a2, e64, m2, ta, ma
1206 ; RV32-NEXT:    vminu.vv v8, v8, v10, v0.t
1207 ; RV32-NEXT:    addi sp, sp, 16
1208 ; RV32-NEXT:    ret
1209 ;
1210 ; RV64-LABEL: vminu_vx_nxv2i64:
1211 ; RV64:       # %bb.0:
1212 ; RV64-NEXT:    vsetvli zero, a1, e64, m2, ta, ma
1213 ; RV64-NEXT:    vminu.vx v8, v8, a0, v0.t
1214 ; RV64-NEXT:    ret
1215   %elt.head = insertelement <vscale x 2 x i64> poison, i64 %b, i32 0
1216   %vb = shufflevector <vscale x 2 x i64> %elt.head, <vscale x 2 x i64> poison, <vscale x 2 x i32> zeroinitializer
1217   %v = call <vscale x 2 x i64> @llvm.vp.umin.nxv2i64(<vscale x 2 x i64> %va, <vscale x 2 x i64> %vb, <vscale x 2 x i1> %m, i32 %evl)
1218   ret <vscale x 2 x i64> %v
1219 }
1220
1221 define <vscale x 2 x i64> @vminu_vx_nxv2i64_unmasked(<vscale x 2 x i64> %va, i64 %b, i32 zeroext %evl) {
1222 ; RV32-LABEL: vminu_vx_nxv2i64_unmasked:
1223 ; RV32:       # %bb.0:
1224 ; RV32-NEXT:    addi sp, sp, -16
1225 ; RV32-NEXT:    .cfi_def_cfa_offset 16
1226 ; RV32-NEXT:    sw a1, 12(sp)
1227 ; RV32-NEXT:    sw a0, 8(sp)
1228 ; RV32-NEXT:    addi a0, sp, 8
1229 ; RV32-NEXT:    vsetvli a1, zero, e64, m2, ta, ma
1230 ; RV32-NEXT:    vlse64.v v10, (a0), zero
1231 ; RV32-NEXT:    vsetvli zero, a2, e64, m2, ta, ma
1232 ; RV32-NEXT:    vminu.vv v8, v8, v10
1233 ; RV32-NEXT:    addi sp, sp, 16
1234 ; RV32-NEXT:    ret
1235 ;
1236 ; RV64-LABEL: vminu_vx_nxv2i64_unmasked:
1237 ; RV64:       # %bb.0:
1238 ; RV64-NEXT:    vsetvli zero, a1, e64, m2, ta, ma
1239 ; RV64-NEXT:    vminu.vx v8, v8, a0
1240 ; RV64-NEXT:    ret
1241   %elt.head = insertelement <vscale x 2 x i64> poison, i64 %b, i32 0
1242   %vb = shufflevector <vscale x 2 x i64> %elt.head, <vscale x 2 x i64> poison, <vscale x 2 x i32> zeroinitializer
1243   %v = call <vscale x 2 x i64> @llvm.vp.umin.nxv2i64(<vscale x 2 x i64> %va, <vscale x 2 x i64> %vb, <vscale x 2 x i1> splat (i1 true), i32 %evl)
1244   ret <vscale x 2 x i64> %v
1245 }
1246
1247 declare <vscale x 4 x i64> @llvm.vp.umin.nxv4i64(<vscale x 4 x i64>, <vscale x 4 x i64>, <vscale x 4 x i1>, i32)
1248
1249 define <vscale x 4 x i64> @vminu_vv_nxv4i64(<vscale x 4 x i64> %va, <vscale x 4 x i64> %b, <vscale x 4 x i1> %m, i32 zeroext %evl) {
1250 ; CHECK-LABEL: vminu_vv_nxv4i64:
1251 ; CHECK:       # %bb.0:
1252 ; CHECK-NEXT:    vsetvli zero, a0, e64, m4, ta, ma
1253 ; CHECK-NEXT:    vminu.vv v8, v8, v12, v0.t
1254 ; CHECK-NEXT:    ret
1255   %v = call <vscale x 4 x i64> @llvm.vp.umin.nxv4i64(<vscale x 4 x i64> %va, <vscale x 4 x i64> %b, <vscale x 4 x i1> %m, i32 %evl)
1256   ret <vscale x 4 x i64> %v
1257 }
1258
1259 define <vscale x 4 x i64> @vminu_vv_nxv4i64_unmasked(<vscale x 4 x i64> %va, <vscale x 4 x i64> %b, i32 zeroext %evl) {
1260 ; CHECK-LABEL: vminu_vv_nxv4i64_unmasked:
1261 ; CHECK:       # %bb.0:
1262 ; CHECK-NEXT:    vsetvli zero, a0, e64, m4, ta, ma
1263 ; CHECK-NEXT:    vminu.vv v8, v8, v12
1264 ; CHECK-NEXT:    ret
1265   %v = call <vscale x 4 x i64> @llvm.vp.umin.nxv4i64(<vscale x 4 x i64> %va, <vscale x 4 x i64> %b, <vscale x 4 x i1> splat (i1 true), i32 %evl)
1266   ret <vscale x 4 x i64> %v
1267 }
1268
1269 define <vscale x 4 x i64> @vminu_vx_nxv4i64(<vscale x 4 x i64> %va, i64 %b, <vscale x 4 x i1> %m, i32 zeroext %evl) {
1270 ; RV32-LABEL: vminu_vx_nxv4i64:
1271 ; RV32:       # %bb.0:
1272 ; RV32-NEXT:    addi sp, sp, -16
1273 ; RV32-NEXT:    .cfi_def_cfa_offset 16
1274 ; RV32-NEXT:    sw a1, 12(sp)
1275 ; RV32-NEXT:    sw a0, 8(sp)
1276 ; RV32-NEXT:    addi a0, sp, 8
1277 ; RV32-NEXT:    vsetvli a1, zero, e64, m4, ta, ma
1278 ; RV32-NEXT:    vlse64.v v12, (a0), zero
1279 ; RV32-NEXT:    vsetvli zero, a2, e64, m4, ta, ma
1280 ; RV32-NEXT:    vminu.vv v8, v8, v12, v0.t
1281 ; RV32-NEXT:    addi sp, sp, 16
1282 ; RV32-NEXT:    ret
1283 ;
1284 ; RV64-LABEL: vminu_vx_nxv4i64:
1285 ; RV64:       # %bb.0:
1286 ; RV64-NEXT:    vsetvli zero, a1, e64, m4, ta, ma
1287 ; RV64-NEXT:    vminu.vx v8, v8, a0, v0.t
1288 ; RV64-NEXT:    ret
1289   %elt.head = insertelement <vscale x 4 x i64> poison, i64 %b, i32 0
1290   %vb = shufflevector <vscale x 4 x i64> %elt.head, <vscale x 4 x i64> poison, <vscale x 4 x i32> zeroinitializer
1291   %v = call <vscale x 4 x i64> @llvm.vp.umin.nxv4i64(<vscale x 4 x i64> %va, <vscale x 4 x i64> %vb, <vscale x 4 x i1> %m, i32 %evl)
1292   ret <vscale x 4 x i64> %v
1293 }
1294
1295 define <vscale x 4 x i64> @vminu_vx_nxv4i64_unmasked(<vscale x 4 x i64> %va, i64 %b, i32 zeroext %evl) {
1296 ; RV32-LABEL: vminu_vx_nxv4i64_unmasked:
1297 ; RV32:       # %bb.0:
1298 ; RV32-NEXT:    addi sp, sp, -16
1299 ; RV32-NEXT:    .cfi_def_cfa_offset 16
1300 ; RV32-NEXT:    sw a1, 12(sp)
1301 ; RV32-NEXT:    sw a0, 8(sp)
1302 ; RV32-NEXT:    addi a0, sp, 8
1303 ; RV32-NEXT:    vsetvli a1, zero, e64, m4, ta, ma
1304 ; RV32-NEXT:    vlse64.v v12, (a0), zero
1305 ; RV32-NEXT:    vsetvli zero, a2, e64, m4, ta, ma
1306 ; RV32-NEXT:    vminu.vv v8, v8, v12
1307 ; RV32-NEXT:    addi sp, sp, 16
1308 ; RV32-NEXT:    ret
1309 ;
1310 ; RV64-LABEL: vminu_vx_nxv4i64_unmasked:
1311 ; RV64:       # %bb.0:
1312 ; RV64-NEXT:    vsetvli zero, a1, e64, m4, ta, ma
1313 ; RV64-NEXT:    vminu.vx v8, v8, a0
1314 ; RV64-NEXT:    ret
1315   %elt.head = insertelement <vscale x 4 x i64> poison, i64 %b, i32 0
1316   %vb = shufflevector <vscale x 4 x i64> %elt.head, <vscale x 4 x i64> poison, <vscale x 4 x i32> zeroinitializer
1317   %v = call <vscale x 4 x i64> @llvm.vp.umin.nxv4i64(<vscale x 4 x i64> %va, <vscale x 4 x i64> %vb, <vscale x 4 x i1> splat (i1 true), i32 %evl)
1318   ret <vscale x 4 x i64> %v
1319 }
1320
1321 declare <vscale x 8 x i64> @llvm.vp.umin.nxv8i64(<vscale x 8 x i64>, <vscale x 8 x i64>, <vscale x 8 x i1>, i32)
1322
1323 define <vscale x 8 x i64> @vminu_vv_nxv8i64(<vscale x 8 x i64> %va, <vscale x 8 x i64> %b, <vscale x 8 x i1> %m, i32 zeroext %evl) {
1324 ; CHECK-LABEL: vminu_vv_nxv8i64:
1325 ; CHECK:       # %bb.0:
1326 ; CHECK-NEXT:    vsetvli zero, a0, e64, m8, ta, ma
1327 ; CHECK-NEXT:    vminu.vv v8, v8, v16, v0.t
1328 ; CHECK-NEXT:    ret
1329   %v = call <vscale x 8 x i64> @llvm.vp.umin.nxv8i64(<vscale x 8 x i64> %va, <vscale x 8 x i64> %b, <vscale x 8 x i1> %m, i32 %evl)
1330   ret <vscale x 8 x i64> %v
1331 }
1332
1333 define <vscale x 8 x i64> @vminu_vv_nxv8i64_unmasked(<vscale x 8 x i64> %va, <vscale x 8 x i64> %b, i32 zeroext %evl) {
1334 ; CHECK-LABEL: vminu_vv_nxv8i64_unmasked:
1335 ; CHECK:       # %bb.0:
1336 ; CHECK-NEXT:    vsetvli zero, a0, e64, m8, ta, ma
1337 ; CHECK-NEXT:    vminu.vv v8, v8, v16
1338 ; CHECK-NEXT:    ret
1339   %v = call <vscale x 8 x i64> @llvm.vp.umin.nxv8i64(<vscale x 8 x i64> %va, <vscale x 8 x i64> %b, <vscale x 8 x i1> splat (i1 true), i32 %evl)
1340   ret <vscale x 8 x i64> %v
1341 }
1342
1343 define <vscale x 8 x i64> @vminu_vx_nxv8i64(<vscale x 8 x i64> %va, i64 %b, <vscale x 8 x i1> %m, i32 zeroext %evl) {
1344 ; RV32-LABEL: vminu_vx_nxv8i64:
1345 ; RV32:       # %bb.0:
1346 ; RV32-NEXT:    addi sp, sp, -16
1347 ; RV32-NEXT:    .cfi_def_cfa_offset 16
1348 ; RV32-NEXT:    sw a1, 12(sp)
1349 ; RV32-NEXT:    sw a0, 8(sp)
1350 ; RV32-NEXT:    addi a0, sp, 8
1351 ; RV32-NEXT:    vsetvli a1, zero, e64, m8, ta, ma
1352 ; RV32-NEXT:    vlse64.v v16, (a0), zero
1353 ; RV32-NEXT:    vsetvli zero, a2, e64, m8, ta, ma
1354 ; RV32-NEXT:    vminu.vv v8, v8, v16, v0.t
1355 ; RV32-NEXT:    addi sp, sp, 16
1356 ; RV32-NEXT:    ret
1357 ;
1358 ; RV64-LABEL: vminu_vx_nxv8i64:
1359 ; RV64:       # %bb.0:
1360 ; RV64-NEXT:    vsetvli zero, a1, e64, m8, ta, ma
1361 ; RV64-NEXT:    vminu.vx v8, v8, a0, v0.t
1362 ; RV64-NEXT:    ret
1363   %elt.head = insertelement <vscale x 8 x i64> poison, i64 %b, i32 0
1364   %vb = shufflevector <vscale x 8 x i64> %elt.head, <vscale x 8 x i64> poison, <vscale x 8 x i32> zeroinitializer
1365   %v = call <vscale x 8 x i64> @llvm.vp.umin.nxv8i64(<vscale x 8 x i64> %va, <vscale x 8 x i64> %vb, <vscale x 8 x i1> %m, i32 %evl)
1366   ret <vscale x 8 x i64> %v
1367 }
1368
1369 define <vscale x 8 x i64> @vminu_vx_nxv8i64_unmasked(<vscale x 8 x i64> %va, i64 %b, i32 zeroext %evl) {
1370 ; RV32-LABEL: vminu_vx_nxv8i64_unmasked:
1371 ; RV32:       # %bb.0:
1372 ; RV32-NEXT:    addi sp, sp, -16
1373 ; RV32-NEXT:    .cfi_def_cfa_offset 16
1374 ; RV32-NEXT:    sw a1, 12(sp)
1375 ; RV32-NEXT:    sw a0, 8(sp)
1376 ; RV32-NEXT:    addi a0, sp, 8
1377 ; RV32-NEXT:    vsetvli a1, zero, e64, m8, ta, ma
1378 ; RV32-NEXT:    vlse64.v v16, (a0), zero
1379 ; RV32-NEXT:    vsetvli zero, a2, e64, m8, ta, ma
1380 ; RV32-NEXT:    vminu.vv v8, v8, v16
1381 ; RV32-NEXT:    addi sp, sp, 16
1382 ; RV32-NEXT:    ret
1383 ;
1384 ; RV64-LABEL: vminu_vx_nxv8i64_unmasked:
1385 ; RV64:       # %bb.0:
1386 ; RV64-NEXT:    vsetvli zero, a1, e64, m8, ta, ma
1387 ; RV64-NEXT:    vminu.vx v8, v8, a0
1388 ; RV64-NEXT:    ret
1389   %elt.head = insertelement <vscale x 8 x i64> poison, i64 %b, i32 0
1390   %vb = shufflevector <vscale x 8 x i64> %elt.head, <vscale x 8 x i64> poison, <vscale x 8 x i32> zeroinitializer
1391   %v = call <vscale x 8 x i64> @llvm.vp.umin.nxv8i64(<vscale x 8 x i64> %va, <vscale x 8 x i64> %vb, <vscale x 8 x i1> splat (i1 true), i32 %evl)
1392   ret <vscale x 8 x i64> %v
1393 }