llvm/test/CodeGen/RISCV/rvv/vpload.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
   2 ; RUN: llc -mtriple=riscv32 -mattr=+d,+zfh,+zvfh,+v \
   3 ; RUN:     -verify-machineinstrs < %s | FileCheck %s
   4 ; RUN: llc -mtriple=riscv64 -mattr=+d,+zfh,+zvfh,+v \
   5 ; RUN:     -verify-machineinstrs < %s | FileCheck %s
   6
   7 declare <vscale x 1 x i8> @llvm.vp.load.nxv1i8.p0(<vscale x 1 x i8>*, <vscale x 1 x i1>, i32)
   8
   9 define <vscale x 1 x i8> @vpload_nxv1i8(<vscale x 1 x i8>* %ptr, <vscale x 1 x i1> %m, i32 zeroext %evl) {
  10 ; CHECK-LABEL: vpload_nxv1i8:
  11 ; CHECK:       # %bb.0:
  12 ; CHECK-NEXT:    vsetvli zero, a1, e8, mf8, ta, ma
  13 ; CHECK-NEXT:    vle8.v v8, (a0), v0.t
  14 ; CHECK-NEXT:    ret
  15   %load = call <vscale x 1 x i8> @llvm.vp.load.nxv1i8.p0(<vscale x 1 x i8>* %ptr, <vscale x 1 x i1> %m, i32 %evl)
  16   ret <vscale x 1 x i8> %load
  17 }
  18
  19 define <vscale x 1 x i8> @vpload_nxv1i8_allones_mask(<vscale x 1 x i8>* %ptr, i32 zeroext %evl) {
  20 ; CHECK-LABEL: vpload_nxv1i8_allones_mask:
  21 ; CHECK:       # %bb.0:
  22 ; CHECK-NEXT:    vsetvli zero, a1, e8, mf8, ta, ma
  23 ; CHECK-NEXT:    vle8.v v8, (a0)
  24 ; CHECK-NEXT:    ret
  25   %a = insertelement <vscale x 1 x i1> poison, i1 true, i32 0
  26   %b = shufflevector <vscale x 1 x i1> %a, <vscale x 1 x i1> poison, <vscale x 1 x i32> zeroinitializer
  27   %load = call <vscale x 1 x i8> @llvm.vp.load.nxv1i8.p0(<vscale x 1 x i8>* %ptr, <vscale x 1 x i1> %b, i32 %evl)
  28   ret <vscale x 1 x i8> %load
  29 }
  30
  31 declare <vscale x 2 x i8> @llvm.vp.load.nxv2i8.p0(<vscale x 2 x i8>*, <vscale x 2 x i1>, i32)
  32
  33 define <vscale x 2 x i8> @vpload_nxv2i8(<vscale x 2 x i8>* %ptr, <vscale x 2 x i1> %m, i32 zeroext %evl) {
  34 ; CHECK-LABEL: vpload_nxv2i8:
  35 ; CHECK:       # %bb.0:
  36 ; CHECK-NEXT:    vsetvli zero, a1, e8, mf4, ta, ma
  37 ; CHECK-NEXT:    vle8.v v8, (a0), v0.t
  38 ; CHECK-NEXT:    ret
  39   %load = call <vscale x 2 x i8> @llvm.vp.load.nxv2i8.p0(<vscale x 2 x i8>* %ptr, <vscale x 2 x i1> %m, i32 %evl)
  40   ret <vscale x 2 x i8> %load
  41 }
  42
  43 declare <vscale x 3 x i8> @llvm.vp.load.nxv3i8.p0(<vscale x 3 x i8>*, <vscale x 3 x i1>, i32)
  44
  45 define <vscale x 3 x i8> @vpload_nxv3i8(<vscale x 3 x i8>* %ptr, <vscale x 3 x i1> %m, i32 zeroext %evl) {
  46 ; CHECK-LABEL: vpload_nxv3i8:
  47 ; CHECK:       # %bb.0:
  48 ; CHECK-NEXT:    vsetvli zero, a1, e8, mf2, ta, ma
  49 ; CHECK-NEXT:    vle8.v v8, (a0), v0.t
  50 ; CHECK-NEXT:    ret
  51   %load = call <vscale x 3 x i8> @llvm.vp.load.nxv3i8.p0(<vscale x 3 x i8>* %ptr, <vscale x 3 x i1> %m, i32 %evl)
  52   ret <vscale x 3 x i8> %load
  53 }
  54
  55 declare <vscale x 4 x i8> @llvm.vp.load.nxv4i8.p0(<vscale x 4 x i8>*, <vscale x 4 x i1>, i32)
  56
  57 define <vscale x 4 x i8> @vpload_nxv4i8(<vscale x 4 x i8>* %ptr, <vscale x 4 x i1> %m, i32 zeroext %evl) {
  58 ; CHECK-LABEL: vpload_nxv4i8:
  59 ; CHECK:       # %bb.0:
  60 ; CHECK-NEXT:    vsetvli zero, a1, e8, mf2, ta, ma
  61 ; CHECK-NEXT:    vle8.v v8, (a0), v0.t
  62 ; CHECK-NEXT:    ret
  63   %load = call <vscale x 4 x i8> @llvm.vp.load.nxv4i8.p0(<vscale x 4 x i8>* %ptr, <vscale x 4 x i1> %m, i32 %evl)
  64   ret <vscale x 4 x i8> %load
  65 }
  66
  67 declare <vscale x 8 x i8> @llvm.vp.load.nxv8i8.p0(<vscale x 8 x i8>*, <vscale x 8 x i1>, i32)
  68
  69 define <vscale x 8 x i8> @vpload_nxv8i8(<vscale x 8 x i8>* %ptr, <vscale x 8 x i1> %m, i32 zeroext %evl) {
  70 ; CHECK-LABEL: vpload_nxv8i8:
  71 ; CHECK:       # %bb.0:
  72 ; CHECK-NEXT:    vsetvli zero, a1, e8, m1, ta, ma
  73 ; CHECK-NEXT:    vle8.v v8, (a0), v0.t
  74 ; CHECK-NEXT:    ret
  75   %load = call <vscale x 8 x i8> @llvm.vp.load.nxv8i8.p0(<vscale x 8 x i8>* %ptr, <vscale x 8 x i1> %m, i32 %evl)
  76   ret <vscale x 8 x i8> %load
  77 }
  78
  79 define <vscale x 8 x i8> @vpload_nxv8i8_allones_mask(<vscale x 8 x i8>* %ptr, i32 zeroext %evl) {
  80 ; CHECK-LABEL: vpload_nxv8i8_allones_mask:
  81 ; CHECK:       # %bb.0:
  82 ; CHECK-NEXT:    vsetvli zero, a1, e8, m1, ta, ma
  83 ; CHECK-NEXT:    vle8.v v8, (a0)
  84 ; CHECK-NEXT:    ret
  85   %a = insertelement <vscale x 8 x i1> poison, i1 true, i32 0
  86   %b = shufflevector <vscale x 8 x i1> %a, <vscale x 8 x i1> poison, <vscale x 8 x i32> zeroinitializer
  87   %load = call <vscale x 8 x i8> @llvm.vp.load.nxv8i8.p0(<vscale x 8 x i8>* %ptr, <vscale x 8 x i1> %b, i32 %evl)
  88   ret <vscale x 8 x i8> %load
  89 }
  90
  91 declare <vscale x 1 x i16> @llvm.vp.load.nxv1i16.p0(<vscale x 1 x i16>*, <vscale x 1 x i1>, i32)
  92
  93 define <vscale x 1 x i16> @vpload_nxv1i16(<vscale x 1 x i16>* %ptr, <vscale x 1 x i1> %m, i32 zeroext %evl) {
  94 ; CHECK-LABEL: vpload_nxv1i16:
  95 ; CHECK:       # %bb.0:
  96 ; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, ma
  97 ; CHECK-NEXT:    vle16.v v8, (a0), v0.t
  98 ; CHECK-NEXT:    ret
  99   %load = call <vscale x 1 x i16> @llvm.vp.load.nxv1i16.p0(<vscale x 1 x i16>* %ptr, <vscale x 1 x i1> %m, i32 %evl)
 100   ret <vscale x 1 x i16> %load
 101 }
 102
 103 declare <vscale x 2 x i16> @llvm.vp.load.nxv2i16.p0(<vscale x 2 x i16>*, <vscale x 2 x i1>, i32)
 104
 105 define <vscale x 2 x i16> @vpload_nxv2i16(<vscale x 2 x i16>* %ptr, <vscale x 2 x i1> %m, i32 zeroext %evl) {
 106 ; CHECK-LABEL: vpload_nxv2i16:
 107 ; CHECK:       # %bb.0:
 108 ; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, ma
 109 ; CHECK-NEXT:    vle16.v v8, (a0), v0.t
 110 ; CHECK-NEXT:    ret
 111   %load = call <vscale x 2 x i16> @llvm.vp.load.nxv2i16.p0(<vscale x 2 x i16>* %ptr, <vscale x 2 x i1> %m, i32 %evl)
 112   ret <vscale x 2 x i16> %load
 113 }
 114
 115 define <vscale x 2 x i16> @vpload_nxv2i16_allones_mask(<vscale x 2 x i16>* %ptr, i32 zeroext %evl) {
 116 ; CHECK-LABEL: vpload_nxv2i16_allones_mask:
 117 ; CHECK:       # %bb.0:
 118 ; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, ma
 119 ; CHECK-NEXT:    vle16.v v8, (a0)
 120 ; CHECK-NEXT:    ret
 121   %a = insertelement <vscale x 2 x i1> poison, i1 true, i32 0
 122   %b = shufflevector <vscale x 2 x i1> %a, <vscale x 2 x i1> poison, <vscale x 2 x i32> zeroinitializer
 123   %load = call <vscale x 2 x i16> @llvm.vp.load.nxv2i16.p0(<vscale x 2 x i16>* %ptr, <vscale x 2 x i1> %b, i32 %evl)
 124   ret <vscale x 2 x i16> %load
 125 }
 126
 127 declare <vscale x 4 x i16> @llvm.vp.load.nxv4i16.p0(<vscale x 4 x i16>*, <vscale x 4 x i1>, i32)
 128
 129 define <vscale x 4 x i16> @vpload_nxv4i16(<vscale x 4 x i16>* %ptr, <vscale x 4 x i1> %m, i32 zeroext %evl) {
 130 ; CHECK-LABEL: vpload_nxv4i16:
 131 ; CHECK:       # %bb.0:
 132 ; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, ma
 133 ; CHECK-NEXT:    vle16.v v8, (a0), v0.t
 134 ; CHECK-NEXT:    ret
 135   %load = call <vscale x 4 x i16> @llvm.vp.load.nxv4i16.p0(<vscale x 4 x i16>* %ptr, <vscale x 4 x i1> %m, i32 %evl)
 136   ret <vscale x 4 x i16> %load
 137 }
 138
 139 declare <vscale x 8 x i16> @llvm.vp.load.nxv8i16.p0(<vscale x 8 x i16>*, <vscale x 8 x i1>, i32)
 140
 141 define <vscale x 8 x i16> @vpload_nxv8i16(<vscale x 8 x i16>* %ptr, <vscale x 8 x i1> %m, i32 zeroext %evl) {
 142 ; CHECK-LABEL: vpload_nxv8i16:
 143 ; CHECK:       # %bb.0:
 144 ; CHECK-NEXT:    vsetvli zero, a1, e16, m2, ta, ma
 145 ; CHECK-NEXT:    vle16.v v8, (a0), v0.t
 146 ; CHECK-NEXT:    ret
 147   %load = call <vscale x 8 x i16> @llvm.vp.load.nxv8i16.p0(<vscale x 8 x i16>* %ptr, <vscale x 8 x i1> %m, i32 %evl)
 148   ret <vscale x 8 x i16> %load
 149 }
 150
 151 declare <vscale x 1 x i32> @llvm.vp.load.nxv1i32.p0(<vscale x 1 x i32>*, <vscale x 1 x i1>, i32)
 152
 153 define <vscale x 1 x i32> @vpload_nxv1i32(<vscale x 1 x i32>* %ptr, <vscale x 1 x i1> %m, i32 zeroext %evl) {
 154 ; CHECK-LABEL: vpload_nxv1i32:
 155 ; CHECK:       # %bb.0:
 156 ; CHECK-NEXT:    vsetvli zero, a1, e32, mf2, ta, ma
 157 ; CHECK-NEXT:    vle32.v v8, (a0), v0.t
 158 ; CHECK-NEXT:    ret
 159   %load = call <vscale x 1 x i32> @llvm.vp.load.nxv1i32.p0(<vscale x 1 x i32>* %ptr, <vscale x 1 x i1> %m, i32 %evl)
 160   ret <vscale x 1 x i32> %load
 161 }
 162
 163 declare <vscale x 2 x i32> @llvm.vp.load.nxv2i32.p0(<vscale x 2 x i32>*, <vscale x 2 x i1>, i32)
 164
 165 define <vscale x 2 x i32> @vpload_nxv2i32(<vscale x 2 x i32>* %ptr, <vscale x 2 x i1> %m, i32 zeroext %evl) {
 166 ; CHECK-LABEL: vpload_nxv2i32:
 167 ; CHECK:       # %bb.0:
 168 ; CHECK-NEXT:    vsetvli zero, a1, e32, m1, ta, ma
 169 ; CHECK-NEXT:    vle32.v v8, (a0), v0.t
 170 ; CHECK-NEXT:    ret
 171   %load = call <vscale x 2 x i32> @llvm.vp.load.nxv2i32.p0(<vscale x 2 x i32>* %ptr, <vscale x 2 x i1> %m, i32 %evl)
 172   ret <vscale x 2 x i32> %load
 173 }
 174
 175 declare <vscale x 4 x i32> @llvm.vp.load.nxv4i32.p0(<vscale x 4 x i32>*, <vscale x 4 x i1>, i32)
 176
 177 define <vscale x 4 x i32> @vpload_nxv4i32(<vscale x 4 x i32>* %ptr, <vscale x 4 x i1> %m, i32 zeroext %evl) {
 178 ; CHECK-LABEL: vpload_nxv4i32:
 179 ; CHECK:       # %bb.0:
 180 ; CHECK-NEXT:    vsetvli zero, a1, e32, m2, ta, ma
 181 ; CHECK-NEXT:    vle32.v v8, (a0), v0.t
 182 ; CHECK-NEXT:    ret
 183   %load = call <vscale x 4 x i32> @llvm.vp.load.nxv4i32.p0(<vscale x 4 x i32>* %ptr, <vscale x 4 x i1> %m, i32 %evl)
 184   ret <vscale x 4 x i32> %load
 185 }
 186
 187 define <vscale x 4 x i32> @vpload_nxv4i32_allones_mask(<vscale x 4 x i32>* %ptr, i32 zeroext %evl) {
 188 ; CHECK-LABEL: vpload_nxv4i32_allones_mask:
 189 ; CHECK:       # %bb.0:
 190 ; CHECK-NEXT:    vsetvli zero, a1, e32, m2, ta, ma
 191 ; CHECK-NEXT:    vle32.v v8, (a0)
 192 ; CHECK-NEXT:    ret
 193   %a = insertelement <vscale x 4 x i1> poison, i1 true, i32 0
 194   %b = shufflevector <vscale x 4 x i1> %a, <vscale x 4 x i1> poison, <vscale x 4 x i32> zeroinitializer
 195   %load = call <vscale x 4 x i32> @llvm.vp.load.nxv4i32.p0(<vscale x 4 x i32>* %ptr, <vscale x 4 x i1> %b, i32 %evl)
 196   ret <vscale x 4 x i32> %load
 197 }
 198
 199 declare <vscale x 8 x i32> @llvm.vp.load.nxv8i32.p0(<vscale x 8 x i32>*, <vscale x 8 x i1>, i32)
 200
 201 define <vscale x 8 x i32> @vpload_nxv8i32(<vscale x 8 x i32>* %ptr, <vscale x 8 x i1> %m, i32 zeroext %evl) {
 202 ; CHECK-LABEL: vpload_nxv8i32:
 203 ; CHECK:       # %bb.0:
 204 ; CHECK-NEXT:    vsetvli zero, a1, e32, m4, ta, ma
 205 ; CHECK-NEXT:    vle32.v v8, (a0), v0.t
 206 ; CHECK-NEXT:    ret
 207   %load = call <vscale x 8 x i32> @llvm.vp.load.nxv8i32.p0(<vscale x 8 x i32>* %ptr, <vscale x 8 x i1> %m, i32 %evl)
 208   ret <vscale x 8 x i32> %load
 209 }
 210
 211 declare <vscale x 1 x i64> @llvm.vp.load.nxv1i64.p0(<vscale x 1 x i64>*, <vscale x 1 x i1>, i32)
 212
 213 define <vscale x 1 x i64> @vpload_nxv1i64(<vscale x 1 x i64>* %ptr, <vscale x 1 x i1> %m, i32 zeroext %evl) {
 214 ; CHECK-LABEL: vpload_nxv1i64:
 215 ; CHECK:       # %bb.0:
 216 ; CHECK-NEXT:    vsetvli zero, a1, e64, m1, ta, ma
 217 ; CHECK-NEXT:    vle64.v v8, (a0), v0.t
 218 ; CHECK-NEXT:    ret
 219   %load = call <vscale x 1 x i64> @llvm.vp.load.nxv1i64.p0(<vscale x 1 x i64>* %ptr, <vscale x 1 x i1> %m, i32 %evl)
 220   ret <vscale x 1 x i64> %load
 221 }
 222
 223 define <vscale x 1 x i64> @vpload_nxv1i64_allones_mask(<vscale x 1 x i64>* %ptr, i32 zeroext %evl) {
 224 ; CHECK-LABEL: vpload_nxv1i64_allones_mask:
 225 ; CHECK:       # %bb.0:
 226 ; CHECK-NEXT:    vsetvli zero, a1, e64, m1, ta, ma
 227 ; CHECK-NEXT:    vle64.v v8, (a0)
 228 ; CHECK-NEXT:    ret
 229   %a = insertelement <vscale x 1 x i1> poison, i1 true, i32 0
 230   %b = shufflevector <vscale x 1 x i1> %a, <vscale x 1 x i1> poison, <vscale x 1 x i32> zeroinitializer
 231   %load = call <vscale x 1 x i64> @llvm.vp.load.nxv1i64.p0(<vscale x 1 x i64>* %ptr, <vscale x 1 x i1> %b, i32 %evl)
 232   ret <vscale x 1 x i64> %load
 233 }
 234
 235 declare <vscale x 2 x i64> @llvm.vp.load.nxv2i64.p0(<vscale x 2 x i64>*, <vscale x 2 x i1>, i32)
 236
 237 define <vscale x 2 x i64> @vpload_nxv2i64(<vscale x 2 x i64>* %ptr, <vscale x 2 x i1> %m, i32 zeroext %evl) {
 238 ; CHECK-LABEL: vpload_nxv2i64:
 239 ; CHECK:       # %bb.0:
 240 ; CHECK-NEXT:    vsetvli zero, a1, e64, m2, ta, ma
 241 ; CHECK-NEXT:    vle64.v v8, (a0), v0.t
 242 ; CHECK-NEXT:    ret
 243   %load = call <vscale x 2 x i64> @llvm.vp.load.nxv2i64.p0(<vscale x 2 x i64>* %ptr, <vscale x 2 x i1> %m, i32 %evl)
 244   ret <vscale x 2 x i64> %load
 245 }
 246
 247 declare <vscale x 4 x i64> @llvm.vp.load.nxv4i64.p0(<vscale x 4 x i64>*, <vscale x 4 x i1>, i32)
 248
 249 define <vscale x 4 x i64> @vpload_nxv4i64(<vscale x 4 x i64>* %ptr, <vscale x 4 x i1> %m, i32 zeroext %evl) {
 250 ; CHECK-LABEL: vpload_nxv4i64:
 251 ; CHECK:       # %bb.0:
 252 ; CHECK-NEXT:    vsetvli zero, a1, e64, m4, ta, ma
 253 ; CHECK-NEXT:    vle64.v v8, (a0), v0.t
 254 ; CHECK-NEXT:    ret
 255   %load = call <vscale x 4 x i64> @llvm.vp.load.nxv4i64.p0(<vscale x 4 x i64>* %ptr, <vscale x 4 x i1> %m, i32 %evl)
 256   ret <vscale x 4 x i64> %load
 257 }
 258
 259 declare <vscale x 8 x i64> @llvm.vp.load.nxv8i64.p0(<vscale x 8 x i64>*, <vscale x 8 x i1>, i32)
 260
 261 define <vscale x 8 x i64> @vpload_nxv8i64(<vscale x 8 x i64>* %ptr, <vscale x 8 x i1> %m, i32 zeroext %evl) {
 262 ; CHECK-LABEL: vpload_nxv8i64:
 263 ; CHECK:       # %bb.0:
 264 ; CHECK-NEXT:    vsetvli zero, a1, e64, m8, ta, ma
 265 ; CHECK-NEXT:    vle64.v v8, (a0), v0.t
 266 ; CHECK-NEXT:    ret
 267   %load = call <vscale x 8 x i64> @llvm.vp.load.nxv8i64.p0(<vscale x 8 x i64>* %ptr, <vscale x 8 x i1> %m, i32 %evl)
 268   ret <vscale x 8 x i64> %load
 269 }
 270
 271 declare <vscale x 1 x half> @llvm.vp.load.nxv1f16.p0(<vscale x 1 x half>*, <vscale x 1 x i1>, i32)
 272
 273 define <vscale x 1 x half> @vpload_nxv1f16(<vscale x 1 x half>* %ptr, <vscale x 1 x i1> %m, i32 zeroext %evl) {
 274 ; CHECK-LABEL: vpload_nxv1f16:
 275 ; CHECK:       # %bb.0:
 276 ; CHECK-NEXT:    vsetvli zero, a1, e16, mf4, ta, ma
 277 ; CHECK-NEXT:    vle16.v v8, (a0), v0.t
 278 ; CHECK-NEXT:    ret
 279   %load = call <vscale x 1 x half> @llvm.vp.load.nxv1f16.p0(<vscale x 1 x half>* %ptr, <vscale x 1 x i1> %m, i32 %evl)
 280   ret <vscale x 1 x half> %load
 281 }
 282
 283 declare <vscale x 2 x half> @llvm.vp.load.nxv2f16.p0(<vscale x 2 x half>*, <vscale x 2 x i1>, i32)
 284
 285 define <vscale x 2 x half> @vpload_nxv2f16(<vscale x 2 x half>* %ptr, <vscale x 2 x i1> %m, i32 zeroext %evl) {
 286 ; CHECK-LABEL: vpload_nxv2f16:
 287 ; CHECK:       # %bb.0:
 288 ; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, ma
 289 ; CHECK-NEXT:    vle16.v v8, (a0), v0.t
 290 ; CHECK-NEXT:    ret
 291   %load = call <vscale x 2 x half> @llvm.vp.load.nxv2f16.p0(<vscale x 2 x half>* %ptr, <vscale x 2 x i1> %m, i32 %evl)
 292   ret <vscale x 2 x half> %load
 293 }
 294
 295 define <vscale x 2 x half> @vpload_nxv2f16_allones_mask(<vscale x 2 x half>* %ptr, i32 zeroext %evl) {
 296 ; CHECK-LABEL: vpload_nxv2f16_allones_mask:
 297 ; CHECK:       # %bb.0:
 298 ; CHECK-NEXT:    vsetvli zero, a1, e16, mf2, ta, ma
 299 ; CHECK-NEXT:    vle16.v v8, (a0)
 300 ; CHECK-NEXT:    ret
 301   %a = insertelement <vscale x 2 x i1> poison, i1 true, i32 0
 302   %b = shufflevector <vscale x 2 x i1> %a, <vscale x 2 x i1> poison, <vscale x 2 x i32> zeroinitializer
 303   %load = call <vscale x 2 x half> @llvm.vp.load.nxv2f16.p0(<vscale x 2 x half>* %ptr, <vscale x 2 x i1> %b, i32 %evl)
 304   ret <vscale x 2 x half> %load
 305 }
 306
 307 declare <vscale x 4 x half> @llvm.vp.load.nxv4f16.p0(<vscale x 4 x half>*, <vscale x 4 x i1>, i32)
 308
 309 define <vscale x 4 x half> @vpload_nxv4f16(<vscale x 4 x half>* %ptr, <vscale x 4 x i1> %m, i32 zeroext %evl) {
 310 ; CHECK-LABEL: vpload_nxv4f16:
 311 ; CHECK:       # %bb.0:
 312 ; CHECK-NEXT:    vsetvli zero, a1, e16, m1, ta, ma
 313 ; CHECK-NEXT:    vle16.v v8, (a0), v0.t
 314 ; CHECK-NEXT:    ret
 315   %load = call <vscale x 4 x half> @llvm.vp.load.nxv4f16.p0(<vscale x 4 x half>* %ptr, <vscale x 4 x i1> %m, i32 %evl)
 316   ret <vscale x 4 x half> %load
 317 }
 318
 319 declare <vscale x 8 x half> @llvm.vp.load.nxv8f16.p0(<vscale x 8 x half>*, <vscale x 8 x i1>, i32)
 320
 321 define <vscale x 8 x half> @vpload_nxv8f16(<vscale x 8 x half>* %ptr, <vscale x 8 x i1> %m, i32 zeroext %evl) {
 322 ; CHECK-LABEL: vpload_nxv8f16:
 323 ; CHECK:       # %bb.0:
 324 ; CHECK-NEXT:    vsetvli zero, a1, e16, m2, ta, ma
 325 ; CHECK-NEXT:    vle16.v v8, (a0), v0.t
 326 ; CHECK-NEXT:    ret
 327   %load = call <vscale x 8 x half> @llvm.vp.load.nxv8f16.p0(<vscale x 8 x half>* %ptr, <vscale x 8 x i1> %m, i32 %evl)
 328   ret <vscale x 8 x half> %load
 329 }
 330
 331 declare <vscale x 1 x float> @llvm.vp.load.nxv1f32.p0(<vscale x 1 x float>*, <vscale x 1 x i1>, i32)
 332
 333 define <vscale x 1 x float> @vpload_nxv1f32(<vscale x 1 x float>* %ptr, <vscale x 1 x i1> %m, i32 zeroext %evl) {
 334 ; CHECK-LABEL: vpload_nxv1f32:
 335 ; CHECK:       # %bb.0:
 336 ; CHECK-NEXT:    vsetvli zero, a1, e32, mf2, ta, ma
 337 ; CHECK-NEXT:    vle32.v v8, (a0), v0.t
 338 ; CHECK-NEXT:    ret
 339   %load = call <vscale x 1 x float> @llvm.vp.load.nxv1f32.p0(<vscale x 1 x float>* %ptr, <vscale x 1 x i1> %m, i32 %evl)
 340   ret <vscale x 1 x float> %load
 341 }
 342
 343 declare <vscale x 2 x float> @llvm.vp.load.nxv2f32.p0(<vscale x 2 x float>*, <vscale x 2 x i1>, i32)
 344
 345 define <vscale x 2 x float> @vpload_nxv2f32(<vscale x 2 x float>* %ptr, <vscale x 2 x i1> %m, i32 zeroext %evl) {
 346 ; CHECK-LABEL: vpload_nxv2f32:
 347 ; CHECK:       # %bb.0:
 348 ; CHECK-NEXT:    vsetvli zero, a1, e32, m1, ta, ma
 349 ; CHECK-NEXT:    vle32.v v8, (a0), v0.t
 350 ; CHECK-NEXT:    ret
 351   %load = call <vscale x 2 x float> @llvm.vp.load.nxv2f32.p0(<vscale x 2 x float>* %ptr, <vscale x 2 x i1> %m, i32 %evl)
 352   ret <vscale x 2 x float> %load
 353 }
 354
 355 declare <vscale x 4 x float> @llvm.vp.load.nxv4f32.p0(<vscale x 4 x float>*, <vscale x 4 x i1>, i32)
 356
 357 define <vscale x 4 x float> @vpload_nxv4f32(<vscale x 4 x float>* %ptr, <vscale x 4 x i1> %m, i32 zeroext %evl) {
 358 ; CHECK-LABEL: vpload_nxv4f32:
 359 ; CHECK:       # %bb.0:
 360 ; CHECK-NEXT:    vsetvli zero, a1, e32, m2, ta, ma
 361 ; CHECK-NEXT:    vle32.v v8, (a0), v0.t
 362 ; CHECK-NEXT:    ret
 363   %load = call <vscale x 4 x float> @llvm.vp.load.nxv4f32.p0(<vscale x 4 x float>* %ptr, <vscale x 4 x i1> %m, i32 %evl)
 364   ret <vscale x 4 x float> %load
 365 }
 366
 367 declare <vscale x 8 x float> @llvm.vp.load.nxv8f32.p0(<vscale x 8 x float>*, <vscale x 8 x i1>, i32)
 368
 369 define <vscale x 8 x float> @vpload_nxv8f32(<vscale x 8 x float>* %ptr, <vscale x 8 x i1> %m, i32 zeroext %evl) {
 370 ; CHECK-LABEL: vpload_nxv8f32:
 371 ; CHECK:       # %bb.0:
 372 ; CHECK-NEXT:    vsetvli zero, a1, e32, m4, ta, ma
 373 ; CHECK-NEXT:    vle32.v v8, (a0), v0.t
 374 ; CHECK-NEXT:    ret
 375   %load = call <vscale x 8 x float> @llvm.vp.load.nxv8f32.p0(<vscale x 8 x float>* %ptr, <vscale x 8 x i1> %m, i32 %evl)
 376   ret <vscale x 8 x float> %load
 377 }
 378
 379 define <vscale x 8 x float> @vpload_nxv8f32_allones_mask(<vscale x 8 x float>* %ptr, i32 zeroext %evl) {
 380 ; CHECK-LABEL: vpload_nxv8f32_allones_mask:
 381 ; CHECK:       # %bb.0:
 382 ; CHECK-NEXT:    vsetvli zero, a1, e32, m4, ta, ma
 383 ; CHECK-NEXT:    vle32.v v8, (a0)
 384 ; CHECK-NEXT:    ret
 385   %a = insertelement <vscale x 8 x i1> poison, i1 true, i32 0
 386   %b = shufflevector <vscale x 8 x i1> %a, <vscale x 8 x i1> poison, <vscale x 8 x i32> zeroinitializer
 387   %load = call <vscale x 8 x float> @llvm.vp.load.nxv8f32.p0(<vscale x 8 x float>* %ptr, <vscale x 8 x i1> %b, i32 %evl)
 388   ret <vscale x 8 x float> %load
 389 }
 390
 391 declare <vscale x 1 x double> @llvm.vp.load.nxv1f64.p0(<vscale x 1 x double>*, <vscale x 1 x i1>, i32)
 392
 393 define <vscale x 1 x double> @vpload_nxv1f64(<vscale x 1 x double>* %ptr, <vscale x 1 x i1> %m, i32 zeroext %evl) {
 394 ; CHECK-LABEL: vpload_nxv1f64:
 395 ; CHECK:       # %bb.0:
 396 ; CHECK-NEXT:    vsetvli zero, a1, e64, m1, ta, ma
 397 ; CHECK-NEXT:    vle64.v v8, (a0), v0.t
 398 ; CHECK-NEXT:    ret
 399   %load = call <vscale x 1 x double> @llvm.vp.load.nxv1f64.p0(<vscale x 1 x double>* %ptr, <vscale x 1 x i1> %m, i32 %evl)
 400   ret <vscale x 1 x double> %load
 401 }
 402
 403 declare <vscale x 2 x double> @llvm.vp.load.nxv2f64.p0(<vscale x 2 x double>*, <vscale x 2 x i1>, i32)
 404
 405 define <vscale x 2 x double> @vpload_nxv2f64(<vscale x 2 x double>* %ptr, <vscale x 2 x i1> %m, i32 zeroext %evl) {
 406 ; CHECK-LABEL: vpload_nxv2f64:
 407 ; CHECK:       # %bb.0:
 408 ; CHECK-NEXT:    vsetvli zero, a1, e64, m2, ta, ma
 409 ; CHECK-NEXT:    vle64.v v8, (a0), v0.t
 410 ; CHECK-NEXT:    ret
 411   %load = call <vscale x 2 x double> @llvm.vp.load.nxv2f64.p0(<vscale x 2 x double>* %ptr, <vscale x 2 x i1> %m, i32 %evl)
 412   ret <vscale x 2 x double> %load
 413 }
 414
 415 declare <vscale x 4 x double> @llvm.vp.load.nxv4f64.p0(<vscale x 4 x double>*, <vscale x 4 x i1>, i32)
 416
 417 define <vscale x 4 x double> @vpload_nxv4f64(<vscale x 4 x double>* %ptr, <vscale x 4 x i1> %m, i32 zeroext %evl) {
 418 ; CHECK-LABEL: vpload_nxv4f64:
 419 ; CHECK:       # %bb.0:
 420 ; CHECK-NEXT:    vsetvli zero, a1, e64, m4, ta, ma
 421 ; CHECK-NEXT:    vle64.v v8, (a0), v0.t
 422 ; CHECK-NEXT:    ret
 423   %load = call <vscale x 4 x double> @llvm.vp.load.nxv4f64.p0(<vscale x 4 x double>* %ptr, <vscale x 4 x i1> %m, i32 %evl)
 424   ret <vscale x 4 x double> %load
 425 }
 426
 427 define <vscale x 4 x double> @vpload_nxv4f64_allones_mask(<vscale x 4 x double>* %ptr, i32 zeroext %evl) {
 428 ; CHECK-LABEL: vpload_nxv4f64_allones_mask:
 429 ; CHECK:       # %bb.0:
 430 ; CHECK-NEXT:    vsetvli zero, a1, e64, m4, ta, ma
 431 ; CHECK-NEXT:    vle64.v v8, (a0)
 432 ; CHECK-NEXT:    ret
 433   %a = insertelement <vscale x 4 x i1> poison, i1 true, i32 0
 434   %b = shufflevector <vscale x 4 x i1> %a, <vscale x 4 x i1> poison, <vscale x 4 x i32> zeroinitializer
 435   %load = call <vscale x 4 x double> @llvm.vp.load.nxv4f64.p0(<vscale x 4 x double>* %ptr, <vscale x 4 x i1> %b, i32 %evl)
 436   ret <vscale x 4 x double> %load
 437 }
 438
 439 declare <vscale x 8 x double> @llvm.vp.load.nxv8f64.p0(<vscale x 8 x double>*, <vscale x 8 x i1>, i32)
 440
 441 define <vscale x 8 x double> @vpload_nxv8f64(<vscale x 8 x double>* %ptr, <vscale x 8 x i1> %m, i32 zeroext %evl) {
 442 ; CHECK-LABEL: vpload_nxv8f64:
 443 ; CHECK:       # %bb.0:
 444 ; CHECK-NEXT:    vsetvli zero, a1, e64, m8, ta, ma
 445 ; CHECK-NEXT:    vle64.v v8, (a0), v0.t
 446 ; CHECK-NEXT:    ret
 447   %load = call <vscale x 8 x double> @llvm.vp.load.nxv8f64.p0(<vscale x 8 x double>* %ptr, <vscale x 8 x i1> %m, i32 %evl)
 448   ret <vscale x 8 x double> %load
 449 }
 450
 451 declare <vscale x 16 x double> @llvm.vp.load.nxv16f64.p0(<vscale x 16 x double>*, <vscale x 16 x i1>, i32)
 452
 453 define <vscale x 16 x double> @vpload_nxv16f64(<vscale x 16 x double>* %ptr, <vscale x 16 x i1> %m, i32 zeroext %evl) {
 454 ; CHECK-LABEL: vpload_nxv16f64:
 455 ; CHECK:       # %bb.0:
 456 ; CHECK-NEXT:    vmv1r.v v8, v0
 457 ; CHECK-NEXT:    csrr a2, vlenb
 458 ; CHECK-NEXT:    sub a3, a1, a2
 459 ; CHECK-NEXT:    sltu a4, a1, a3
 460 ; CHECK-NEXT:    addi a4, a4, -1
 461 ; CHECK-NEXT:    and a3, a4, a3
 462 ; CHECK-NEXT:    slli a4, a2, 3
 463 ; CHECK-NEXT:    add a4, a0, a4
 464 ; CHECK-NEXT:    srli a5, a2, 3
 465 ; CHECK-NEXT:    vsetvli a6, zero, e8, mf4, ta, ma
 466 ; CHECK-NEXT:    vslidedown.vx v0, v0, a5
 467 ; CHECK-NEXT:    vsetvli zero, a3, e64, m8, ta, ma
 468 ; CHECK-NEXT:    vle64.v v16, (a4), v0.t
 469 ; CHECK-NEXT:    bltu a1, a2, .LBB37_2
 470 ; CHECK-NEXT:  # %bb.1:
 471 ; CHECK-NEXT:    mv a1, a2
 472 ; CHECK-NEXT:  .LBB37_2:
 473 ; CHECK-NEXT:    vsetvli zero, a1, e64, m8, ta, ma
 474 ; CHECK-NEXT:    vmv1r.v v0, v8
 475 ; CHECK-NEXT:    vle64.v v8, (a0), v0.t
 476 ; CHECK-NEXT:    ret
 477   %load = call <vscale x 16 x double> @llvm.vp.load.nxv16f64.p0(<vscale x 16 x double>* %ptr, <vscale x 16 x i1> %m, i32 %evl)
 478   ret <vscale x 16 x double> %load
 479 }
 480
 481 declare <vscale x 17 x double> @llvm.vp.load.nxv17f64.p0(<vscale x 17 x double>*, <vscale x 17 x i1>, i32)
 482
 483 declare <vscale x 1 x double> @llvm.vector.extract.nxv1f64(<vscale x 17 x double> %vec, i64 %idx)
 484 declare <vscale x 16 x double> @llvm.vector.extract.nxv16f64(<vscale x 17 x double> %vec, i64 %idx)
 485
 486 ; Note: We can't return <vscale x 17 x double> as that introduces a vector
 487 ; store can't yet be legalized through widening. In order to test purely the
 488 ; vp.load legalization, manually split it.
 489
 490 ; Widen to nxv32f64 then split into 4 x nxv8f64, of which 1 is empty.
 491
 492 define <vscale x 16 x double> @vpload_nxv17f64(<vscale x 17 x double>* %ptr, <vscale x 1 x double>* %out, <vscale x 17 x i1> %m, i32 zeroext %evl) {
 493 ; CHECK-LABEL: vpload_nxv17f64:
 494 ; CHECK:       # %bb.0:
 495 ; CHECK-NEXT:    csrr a3, vlenb
 496 ; CHECK-NEXT:    slli a5, a3, 1
 497 ; CHECK-NEXT:    vmv1r.v v8, v0
 498 ; CHECK-NEXT:    mv a4, a2
 499 ; CHECK-NEXT:    bltu a2, a5, .LBB38_2
 500 ; CHECK-NEXT:  # %bb.1:
 501 ; CHECK-NEXT:    mv a4, a5
 502 ; CHECK-NEXT:  .LBB38_2:
 503 ; CHECK-NEXT:    sub a6, a4, a3
 504 ; CHECK-NEXT:    sltu a7, a4, a6
 505 ; CHECK-NEXT:    addi a7, a7, -1
 506 ; CHECK-NEXT:    and a6, a7, a6
 507 ; CHECK-NEXT:    slli a7, a3, 3
 508 ; CHECK-NEXT:    add a7, a0, a7
 509 ; CHECK-NEXT:    srli t0, a3, 3
 510 ; CHECK-NEXT:    vsetvli t1, zero, e8, mf4, ta, ma
 511 ; CHECK-NEXT:    vslidedown.vx v0, v8, t0
 512 ; CHECK-NEXT:    vsetvli zero, a6, e64, m8, ta, ma
 513 ; CHECK-NEXT:    vle64.v v16, (a7), v0.t
 514 ; CHECK-NEXT:    sub a5, a2, a5
 515 ; CHECK-NEXT:    sltu a2, a2, a5
 516 ; CHECK-NEXT:    addi a2, a2, -1
 517 ; CHECK-NEXT:    and a2, a2, a5
 518 ; CHECK-NEXT:    bltu a2, a3, .LBB38_4
 519 ; CHECK-NEXT:  # %bb.3:
 520 ; CHECK-NEXT:    mv a2, a3
 521 ; CHECK-NEXT:  .LBB38_4:
 522 ; CHECK-NEXT:    slli a5, a3, 4
 523 ; CHECK-NEXT:    add a5, a0, a5
 524 ; CHECK-NEXT:    srli a6, a3, 2
 525 ; CHECK-NEXT:    vsetvli a7, zero, e8, mf2, ta, ma
 526 ; CHECK-NEXT:    vslidedown.vx v0, v8, a6
 527 ; CHECK-NEXT:    vsetvli zero, a2, e64, m8, ta, ma
 528 ; CHECK-NEXT:    vle64.v v24, (a5), v0.t
 529 ; CHECK-NEXT:    bltu a4, a3, .LBB38_6
 530 ; CHECK-NEXT:  # %bb.5:
 531 ; CHECK-NEXT:    mv a4, a3
 532 ; CHECK-NEXT:  .LBB38_6:
 533 ; CHECK-NEXT:    vsetvli zero, a4, e64, m8, ta, ma
 534 ; CHECK-NEXT:    vmv1r.v v0, v8
 535 ; CHECK-NEXT:    vle64.v v8, (a0), v0.t
 536 ; CHECK-NEXT:    vs1r.v v24, (a1)
 537 ; CHECK-NEXT:    ret
 538   %load = call <vscale x 17 x double> @llvm.vp.load.nxv17f64.p0(<vscale x 17 x double>* %ptr, <vscale x 17 x i1> %m, i32 %evl)
 539   %lo = call <vscale x 16 x double> @llvm.vector.extract.nxv16f64(<vscale x 17 x double> %load, i64 0)
 540   %hi = call <vscale x 1 x double> @llvm.vector.extract.nxv1f64(<vscale x 17 x double> %load, i64 16)
 541   store <vscale x 1 x double> %hi, <vscale x 1 x double>* %out
 542   ret <vscale x 16 x double> %lo
 543 }