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