clang/test/CodeGen/VE/ve-velintrin.c

   1 // REQUIRES: ve-registered-target
   2
   3 // RUN: %clang_cc1 -S -emit-llvm -triple ve-unknown-linux-gnu \
   4 // RUN:   -ffreestanding %s -o - | FileCheck %s
   5
   6 #include <velintrin.h>
   7
   8 long v1, v2, v3;
   9 double vd1;
  10 float vf1;
  11 __vr vr1, vr2, vr3, vr4;
  12 __vm256 vm1, vm2, vm3;
  13 __vm512 vm1_512, vm2_512, vm3_512;
  14
  15 void __attribute__((noinline))
  16 test_vld_vssl(char* p, long idx) {
  17   // CHECK-LABEL: @test_vld_vssl
  18   // CHECK: call <256 x double> @llvm.ve.vl.vld.vssl(i64 %{{.*}}, ptr %{{.*}}, i32 256)
  19   vr1 = _vel_vld_vssl(idx, p, 256);
  20 }
  21
  22 void __attribute__((noinline))
  23 test_vld_vssvl(char* p, long idx) {
  24   // CHECK-LABEL: @test_vld_vssvl
  25   // CHECK: call <256 x double> @llvm.ve.vl.vld.vssvl(i64 %{{.*}}, ptr %{{.*}}, <256 x double> %{{.*}}, i32 256)
  26   vr1 = _vel_vld_vssvl(idx, p, vr1, 256);
  27 }
  28
  29 void __attribute__((noinline))
  30 test_vldnc_vssl(char* p, long idx) {
  31   // CHECK-LABEL: @test_vldnc_vssl
  32   // CHECK: call <256 x double> @llvm.ve.vl.vldnc.vssl(i64 %{{.*}}, ptr %{{.*}}, i32 256)
  33   vr1 = _vel_vldnc_vssl(idx, p, 256);
  34 }
  35
  36 void __attribute__((noinline))
  37 test_vldnc_vssvl(char* p, long idx) {
  38   // CHECK-LABEL: @test_vldnc_vssvl
  39   // CHECK: call <256 x double> @llvm.ve.vl.vldnc.vssvl(i64 %{{.*}}, ptr %{{.*}}, <256 x double> %{{.*}}, i32 256)
  40   vr1 = _vel_vldnc_vssvl(idx, p, vr1, 256);
  41 }
  42
  43 void __attribute__((noinline))
  44 test_vldu_vssl(char* p, long idx) {
  45   // CHECK-LABEL: @test_vldu_vssl
  46   // CHECK: call <256 x double> @llvm.ve.vl.vldu.vssl(i64 %{{.*}}, ptr %{{.*}}, i32 256)
  47   vr1 = _vel_vldu_vssl(idx, p, 256);
  48 }
  49
  50 void __attribute__((noinline))
  51 test_vldu_vssvl(char* p, long idx) {
  52   // CHECK-LABEL: @test_vldu_vssvl
  53   // CHECK: call <256 x double> @llvm.ve.vl.vldu.vssvl(i64 %{{.*}}, ptr %{{.*}}, <256 x double> %{{.*}}, i32 256)
  54   vr1 = _vel_vldu_vssvl(idx, p, vr1, 256);
  55 }
  56
  57 void __attribute__((noinline))
  58 test_vldunc_vssl(char* p, long idx) {
  59   // CHECK-LABEL: @test_vldunc_vssl
  60   // CHECK: call <256 x double> @llvm.ve.vl.vldunc.vssl(i64 %{{.*}}, ptr %{{.*}}, i32 256)
  61   vr1 = _vel_vldunc_vssl(idx, p, 256);
  62 }
  63
  64 void __attribute__((noinline))
  65 test_vldunc_vssvl(char* p, long idx) {
  66   // CHECK-LABEL: @test_vldunc_vssvl
  67   // CHECK: call <256 x double> @llvm.ve.vl.vldunc.vssvl(i64 %{{.*}}, ptr %{{.*}}, <256 x double> %{{.*}}, i32 256)
  68   vr1 = _vel_vldunc_vssvl(idx, p, vr1, 256);
  69 }
  70
  71 void __attribute__((noinline))
  72 test_vldlsx_vssl(char* p, long idx) {
  73   // CHECK-LABEL: @test_vldlsx_vssl
  74   // CHECK: call <256 x double> @llvm.ve.vl.vldlsx.vssl(i64 %{{.*}}, ptr %{{.*}}, i32 256)
  75   vr1 = _vel_vldlsx_vssl(idx, p, 256);
  76 }
  77
  78 void __attribute__((noinline))
  79 test_vldlsx_vssvl(char* p, long idx) {
  80   // CHECK-LABEL: @test_vldlsx_vssvl
  81   // CHECK: call <256 x double> @llvm.ve.vl.vldlsx.vssvl(i64 %{{.*}}, ptr %{{.*}}, <256 x double> %{{.*}}, i32 256)
  82   vr1 = _vel_vldlsx_vssvl(idx, p, vr1, 256);
  83 }
  84
  85 void __attribute__((noinline))
  86 test_vldlsxnc_vssl(char* p, long idx) {
  87   // CHECK-LABEL: @test_vldlsxnc_vssl
  88   // CHECK: call <256 x double> @llvm.ve.vl.vldlsxnc.vssl(i64 %{{.*}}, ptr %{{.*}}, i32 256)
  89   vr1 = _vel_vldlsxnc_vssl(idx, p, 256);
  90 }
  91
  92 void __attribute__((noinline))
  93 test_vldlsxnc_vssvl(char* p, long idx) {
  94   // CHECK-LABEL: @test_vldlsxnc_vssvl
  95   // CHECK: call <256 x double> @llvm.ve.vl.vldlsxnc.vssvl(i64 %{{.*}}, ptr %{{.*}}, <256 x double> %{{.*}}, i32 256)
  96   vr1 = _vel_vldlsxnc_vssvl(idx, p, vr1, 256);
  97 }
  98
  99 void __attribute__((noinline))
 100 test_vldlzx_vssl(char* p, long idx) {
 101   // CHECK-LABEL: @test_vldlzx_vssl
 102   // CHECK: call <256 x double> @llvm.ve.vl.vldlzx.vssl(i64 %{{.*}}, ptr %{{.*}}, i32 256)
 103   vr1 = _vel_vldlzx_vssl(idx, p, 256);
 104 }
 105
 106 void __attribute__((noinline))
 107 test_vldlzx_vssvl(char* p, long idx) {
 108   // CHECK-LABEL: @test_vldlzx_vssvl
 109   // CHECK: call <256 x double> @llvm.ve.vl.vldlzx.vssvl(i64 %{{.*}}, ptr %{{.*}}, <256 x double> %{{.*}}, i32 256)
 110   vr1 = _vel_vldlzx_vssvl(idx, p, vr1, 256);
 111 }
 112
 113 void __attribute__((noinline))
 114 test_vldlzxnc_vssl(char* p, long idx) {
 115   // CHECK-LABEL: @test_vldlzxnc_vssl
 116   // CHECK: call <256 x double> @llvm.ve.vl.vldlzxnc.vssl(i64 %{{.*}}, ptr %{{.*}}, i32 256)
 117   vr1 = _vel_vldlzxnc_vssl(idx, p, 256);
 118 }
 119
 120 void __attribute__((noinline))
 121 test_vldlzxnc_vssvl(char* p, long idx) {
 122   // CHECK-LABEL: @test_vldlzxnc_vssvl
 123   // CHECK: call <256 x double> @llvm.ve.vl.vldlzxnc.vssvl(i64 %{{.*}}, ptr %{{.*}}, <256 x double> %{{.*}}, i32 256)
 124   vr1 = _vel_vldlzxnc_vssvl(idx, p, vr1, 256);
 125 }
 126
 127 void __attribute__((noinline))
 128 test_vld2d_vssl(char* p, long idx) {
 129   // CHECK-LABEL: @test_vld2d_vssl
 130   // CHECK: call <256 x double> @llvm.ve.vl.vld2d.vssl(i64 %{{.*}}, ptr %{{.*}}, i32 256)
 131   vr1 = _vel_vld2d_vssl(idx, p, 256);
 132 }
 133
 134 void __attribute__((noinline))
 135 test_vld2d_vssvl(char* p, long idx) {
 136   // CHECK-LABEL: @test_vld2d_vssvl
 137   // CHECK: call <256 x double> @llvm.ve.vl.vld2d.vssvl(i64 %{{.*}}, ptr %{{.*}}, <256 x double> %{{.*}}, i32 256)
 138   vr1 = _vel_vld2d_vssvl(idx, p, vr1, 256);
 139 }
 140
 141 void __attribute__((noinline))
 142 test_vld2dnc_vssl(char* p, long idx) {
 143   // CHECK-LABEL: @test_vld2dnc_vssl
 144   // CHECK: call <256 x double> @llvm.ve.vl.vld2dnc.vssl(i64 %{{.*}}, ptr %{{.*}}, i32 256)
 145   vr1 = _vel_vld2dnc_vssl(idx, p, 256);
 146 }
 147
 148 void __attribute__((noinline))
 149 test_vld2dnc_vssvl(char* p, long idx) {
 150   // CHECK-LABEL: @test_vld2dnc_vssvl
 151   // CHECK: call <256 x double> @llvm.ve.vl.vld2dnc.vssvl(i64 %{{.*}}, ptr %{{.*}}, <256 x double> %{{.*}}, i32 256)
 152   vr1 = _vel_vld2dnc_vssvl(idx, p, vr1, 256);
 153 }
 154
 155 void __attribute__((noinline))
 156 test_vldu2d_vssl(char* p, long idx) {
 157   // CHECK-LABEL: @test_vldu2d_vssl
 158   // CHECK: call <256 x double> @llvm.ve.vl.vldu2d.vssl(i64 %{{.*}}, ptr %{{.*}}, i32 256)
 159   vr1 = _vel_vldu2d_vssl(idx, p, 256);
 160 }
 161
 162 void __attribute__((noinline))
 163 test_vldu2d_vssvl(char* p, long idx) {
 164   // CHECK-LABEL: @test_vldu2d_vssvl
 165   // CHECK: call <256 x double> @llvm.ve.vl.vldu2d.vssvl(i64 %{{.*}}, ptr %{{.*}}, <256 x double> %{{.*}}, i32 256)
 166   vr1 = _vel_vldu2d_vssvl(idx, p, vr1, 256);
 167 }
 168
 169 void __attribute__((noinline))
 170 test_vldu2dnc_vssl(char* p, long idx) {
 171   // CHECK-LABEL: @test_vldu2dnc_vssl
 172   // CHECK: call <256 x double> @llvm.ve.vl.vldu2dnc.vssl(i64 %{{.*}}, ptr %{{.*}}, i32 256)
 173   vr1 = _vel_vldu2dnc_vssl(idx, p, 256);
 174 }
 175
 176 void __attribute__((noinline))
 177 test_vldu2dnc_vssvl(char* p, long idx) {
 178   // CHECK-LABEL: @test_vldu2dnc_vssvl
 179   // CHECK: call <256 x double> @llvm.ve.vl.vldu2dnc.vssvl(i64 %{{.*}}, ptr %{{.*}}, <256 x double> %{{.*}}, i32 256)
 180   vr1 = _vel_vldu2dnc_vssvl(idx, p, vr1, 256);
 181 }
 182
 183 void __attribute__((noinline))
 184 test_vldl2dsx_vssl(char* p, long idx) {
 185   // CHECK-LABEL: @test_vldl2dsx_vssl
 186   // CHECK: call <256 x double> @llvm.ve.vl.vldl2dsx.vssl(i64 %{{.*}}, ptr %{{.*}}, i32 256)
 187   vr1 = _vel_vldl2dsx_vssl(idx, p, 256);
 188 }
 189
 190 void __attribute__((noinline))
 191 test_vldl2dsx_vssvl(char* p, long idx) {
 192   // CHECK-LABEL: @test_vldl2dsx_vssvl
 193   // CHECK: call <256 x double> @llvm.ve.vl.vldl2dsx.vssvl(i64 %{{.*}}, ptr %{{.*}}, <256 x double> %{{.*}}, i32 256)
 194   vr1 = _vel_vldl2dsx_vssvl(idx, p, vr1, 256);
 195 }
 196
 197 void __attribute__((noinline))
 198 test_vldl2dsxnc_vssl(char* p, long idx) {
 199   // CHECK-LABEL: @test_vldl2dsxnc_vssl
 200   // CHECK: call <256 x double> @llvm.ve.vl.vldl2dsxnc.vssl(i64 %{{.*}}, ptr %{{.*}}, i32 256)
 201   vr1 = _vel_vldl2dsxnc_vssl(idx, p, 256);
 202 }
 203
 204 void __attribute__((noinline))
 205 test_vldl2dsxnc_vssvl(char* p, long idx) {
 206   // CHECK-LABEL: @test_vldl2dsxnc_vssvl
 207   // CHECK: call <256 x double> @llvm.ve.vl.vldl2dsxnc.vssvl(i64 %{{.*}}, ptr %{{.*}}, <256 x double> %{{.*}}, i32 256)
 208   vr1 = _vel_vldl2dsxnc_vssvl(idx, p, vr1, 256);
 209 }
 210
 211 void __attribute__((noinline))
 212 test_vldl2dzx_vssl(char* p, long idx) {
 213   // CHECK-LABEL: @test_vldl2dzx_vssl
 214   // CHECK: call <256 x double> @llvm.ve.vl.vldl2dzx.vssl(i64 %{{.*}}, ptr %{{.*}}, i32 256)
 215   vr1 = _vel_vldl2dzx_vssl(idx, p, 256);
 216 }
 217
 218 void __attribute__((noinline))
 219 test_vldl2dzx_vssvl(char* p, long idx) {
 220   // CHECK-LABEL: @test_vldl2dzx_vssvl
 221   // CHECK: call <256 x double> @llvm.ve.vl.vldl2dzx.vssvl(i64 %{{.*}}, ptr %{{.*}}, <256 x double> %{{.*}}, i32 256)
 222   vr1 = _vel_vldl2dzx_vssvl(idx, p, vr1, 256);
 223 }
 224
 225 void __attribute__((noinline))
 226 test_vldl2dzxnc_vssl(char* p, long idx) {
 227   // CHECK-LABEL: @test_vldl2dzxnc_vssl
 228   // CHECK: call <256 x double> @llvm.ve.vl.vldl2dzxnc.vssl(i64 %{{.*}}, ptr %{{.*}}, i32 256)
 229   vr1 = _vel_vldl2dzxnc_vssl(idx, p, 256);
 230 }
 231
 232 void __attribute__((noinline))
 233 test_vldl2dzxnc_vssvl(char* p, long idx) {
 234   // CHECK-LABEL: @test_vldl2dzxnc_vssvl
 235   // CHECK: call <256 x double> @llvm.ve.vl.vldl2dzxnc.vssvl(i64 %{{.*}}, ptr %{{.*}}, <256 x double> %{{.*}}, i32 256)
 236   vr1 = _vel_vldl2dzxnc_vssvl(idx, p, vr1, 256);
 237 }
 238
 239 void __attribute__((noinline))
 240 test_vst_vssl(char* p, long idx) {
 241   // CHECK-LABEL: @test_vst_vssl
 242   // CHECK: call void @llvm.ve.vl.vst.vssl(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, i32 256)
 243   _vel_vst_vssl(vr1, idx, p, 256);
 244 }
 245
 246 void __attribute__((noinline))
 247 test_vst_vssml(char* p, long idx) {
 248   // CHECK-LABEL: @test_vst_vssml
 249   // CHECK: call void @llvm.ve.vl.vst.vssml(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, <256 x i1> %{{.*}}, i32 256)
 250   _vel_vst_vssml(vr1, idx, p, vm1, 256);
 251 }
 252
 253 void __attribute__((noinline))
 254 test_vstnc_vssl(char* p, long idx) {
 255   // CHECK-LABEL: @test_vstnc_vssl
 256   // CHECK: call void @llvm.ve.vl.vstnc.vssl(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, i32 256)
 257   _vel_vstnc_vssl(vr1, idx, p, 256);
 258 }
 259
 260 void __attribute__((noinline))
 261 test_vstnc_vssml(char* p, long idx) {
 262   // CHECK-LABEL: @test_vstnc_vssml
 263   // CHECK: call void @llvm.ve.vl.vstnc.vssml(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, <256 x i1> %{{.*}}, i32 256)
 264   _vel_vstnc_vssml(vr1, idx, p, vm1, 256);
 265 }
 266
 267 void __attribute__((noinline))
 268 test_vstot_vssl(char* p, long idx) {
 269   // CHECK-LABEL: @test_vstot_vssl
 270   // CHECK: call void @llvm.ve.vl.vstot.vssl(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, i32 256)
 271   _vel_vstot_vssl(vr1, idx, p, 256);
 272 }
 273
 274 void __attribute__((noinline))
 275 test_vstot_vssml(char* p, long idx) {
 276   // CHECK-LABEL: @test_vstot_vssml
 277   // CHECK: call void @llvm.ve.vl.vstot.vssml(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, <256 x i1> %{{.*}}, i32 256)
 278   _vel_vstot_vssml(vr1, idx, p, vm1, 256);
 279 }
 280
 281 void __attribute__((noinline))
 282 test_vstncot_vssl(char* p, long idx) {
 283   // CHECK-LABEL: @test_vstncot_vssl
 284   // CHECK: call void @llvm.ve.vl.vstncot.vssl(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, i32 256)
 285   _vel_vstncot_vssl(vr1, idx, p, 256);
 286 }
 287
 288 void __attribute__((noinline))
 289 test_vstncot_vssml(char* p, long idx) {
 290   // CHECK-LABEL: @test_vstncot_vssml
 291   // CHECK: call void @llvm.ve.vl.vstncot.vssml(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, <256 x i1> %{{.*}}, i32 256)
 292   _vel_vstncot_vssml(vr1, idx, p, vm1, 256);
 293 }
 294
 295 void __attribute__((noinline))
 296 test_vstu_vssl(char* p, long idx) {
 297   // CHECK-LABEL: @test_vstu_vssl
 298   // CHECK: call void @llvm.ve.vl.vstu.vssl(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, i32 256)
 299   _vel_vstu_vssl(vr1, idx, p, 256);
 300 }
 301
 302 void __attribute__((noinline))
 303 test_vstu_vssml(char* p, long idx) {
 304   // CHECK-LABEL: @test_vstu_vssml
 305   // CHECK: call void @llvm.ve.vl.vstu.vssml(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, <256 x i1> %{{.*}}, i32 256)
 306   _vel_vstu_vssml(vr1, idx, p, vm1, 256);
 307 }
 308
 309 void __attribute__((noinline))
 310 test_vstunc_vssl(char* p, long idx) {
 311   // CHECK-LABEL: @test_vstunc_vssl
 312   // CHECK: call void @llvm.ve.vl.vstunc.vssl(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, i32 256)
 313   _vel_vstunc_vssl(vr1, idx, p, 256);
 314 }
 315
 316 void __attribute__((noinline))
 317 test_vstunc_vssml(char* p, long idx) {
 318   // CHECK-LABEL: @test_vstunc_vssml
 319   // CHECK: call void @llvm.ve.vl.vstunc.vssml(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, <256 x i1> %{{.*}}, i32 256)
 320   _vel_vstunc_vssml(vr1, idx, p, vm1, 256);
 321 }
 322
 323 void __attribute__((noinline))
 324 test_vstuot_vssl(char* p, long idx) {
 325   // CHECK-LABEL: @test_vstuot_vssl
 326   // CHECK: call void @llvm.ve.vl.vstuot.vssl(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, i32 256)
 327   _vel_vstuot_vssl(vr1, idx, p, 256);
 328 }
 329
 330 void __attribute__((noinline))
 331 test_vstuot_vssml(char* p, long idx) {
 332   // CHECK-LABEL: @test_vstuot_vssml
 333   // CHECK: call void @llvm.ve.vl.vstuot.vssml(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, <256 x i1> %{{.*}}, i32 256)
 334   _vel_vstuot_vssml(vr1, idx, p, vm1, 256);
 335 }
 336
 337 void __attribute__((noinline))
 338 test_vstuncot_vssl(char* p, long idx) {
 339   // CHECK-LABEL: @test_vstuncot_vssl
 340   // CHECK: call void @llvm.ve.vl.vstuncot.vssl(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, i32 256)
 341   _vel_vstuncot_vssl(vr1, idx, p, 256);
 342 }
 343
 344 void __attribute__((noinline))
 345 test_vstuncot_vssml(char* p, long idx) {
 346   // CHECK-LABEL: @test_vstuncot_vssml
 347   // CHECK: call void @llvm.ve.vl.vstuncot.vssml(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, <256 x i1> %{{.*}}, i32 256)
 348   _vel_vstuncot_vssml(vr1, idx, p, vm1, 256);
 349 }
 350
 351 void __attribute__((noinline))
 352 test_vstl_vssl(char* p, long idx) {
 353   // CHECK-LABEL: @test_vstl_vssl
 354   // CHECK: call void @llvm.ve.vl.vstl.vssl(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, i32 256)
 355   _vel_vstl_vssl(vr1, idx, p, 256);
 356 }
 357
 358 void __attribute__((noinline))
 359 test_vstl_vssml(char* p, long idx) {
 360   // CHECK-LABEL: @test_vstl_vssml
 361   // CHECK: call void @llvm.ve.vl.vstl.vssml(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, <256 x i1> %{{.*}}, i32 256)
 362   _vel_vstl_vssml(vr1, idx, p, vm1, 256);
 363 }
 364
 365 void __attribute__((noinline))
 366 test_vstlnc_vssl(char* p, long idx) {
 367   // CHECK-LABEL: @test_vstlnc_vssl
 368   // CHECK: call void @llvm.ve.vl.vstlnc.vssl(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, i32 256)
 369   _vel_vstlnc_vssl(vr1, idx, p, 256);
 370 }
 371
 372 void __attribute__((noinline))
 373 test_vstlnc_vssml(char* p, long idx) {
 374   // CHECK-LABEL: @test_vstlnc_vssml
 375   // CHECK: call void @llvm.ve.vl.vstlnc.vssml(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, <256 x i1> %{{.*}}, i32 256)
 376   _vel_vstlnc_vssml(vr1, idx, p, vm1, 256);
 377 }
 378
 379 void __attribute__((noinline))
 380 test_vstlot_vssl(char* p, long idx) {
 381   // CHECK-LABEL: @test_vstlot_vssl
 382   // CHECK: call void @llvm.ve.vl.vstlot.vssl(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, i32 256)
 383   _vel_vstlot_vssl(vr1, idx, p, 256);
 384 }
 385
 386 void __attribute__((noinline))
 387 test_vstlot_vssml(char* p, long idx) {
 388   // CHECK-LABEL: @test_vstlot_vssml
 389   // CHECK: call void @llvm.ve.vl.vstlot.vssml(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, <256 x i1> %{{.*}}, i32 256)
 390   _vel_vstlot_vssml(vr1, idx, p, vm1, 256);
 391 }
 392
 393 void __attribute__((noinline))
 394 test_vstlncot_vssl(char* p, long idx) {
 395   // CHECK-LABEL: @test_vstlncot_vssl
 396   // CHECK: call void @llvm.ve.vl.vstlncot.vssl(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, i32 256)
 397   _vel_vstlncot_vssl(vr1, idx, p, 256);
 398 }
 399
 400 void __attribute__((noinline))
 401 test_vstlncot_vssml(char* p, long idx) {
 402   // CHECK-LABEL: @test_vstlncot_vssml
 403   // CHECK: call void @llvm.ve.vl.vstlncot.vssml(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, <256 x i1> %{{.*}}, i32 256)
 404   _vel_vstlncot_vssml(vr1, idx, p, vm1, 256);
 405 }
 406
 407 void __attribute__((noinline))
 408 test_vst2d_vssl(char* p, long idx) {
 409   // CHECK-LABEL: @test_vst2d_vssl
 410   // CHECK: call void @llvm.ve.vl.vst2d.vssl(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, i32 256)
 411   _vel_vst2d_vssl(vr1, idx, p, 256);
 412 }
 413
 414 void __attribute__((noinline))
 415 test_vst2d_vssml(char* p, long idx) {
 416   // CHECK-LABEL: @test_vst2d_vssml
 417   // CHECK: call void @llvm.ve.vl.vst2d.vssml(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, <256 x i1> %{{.*}}, i32 256)
 418   _vel_vst2d_vssml(vr1, idx, p, vm1, 256);
 419 }
 420
 421 void __attribute__((noinline))
 422 test_vst2dnc_vssl(char* p, long idx) {
 423   // CHECK-LABEL: @test_vst2dnc_vssl
 424   // CHECK: call void @llvm.ve.vl.vst2dnc.vssl(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, i32 256)
 425   _vel_vst2dnc_vssl(vr1, idx, p, 256);
 426 }
 427
 428 void __attribute__((noinline))
 429 test_vst2dnc_vssml(char* p, long idx) {
 430   // CHECK-LABEL: @test_vst2dnc_vssml
 431   // CHECK: call void @llvm.ve.vl.vst2dnc.vssml(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, <256 x i1> %{{.*}}, i32 256)
 432   _vel_vst2dnc_vssml(vr1, idx, p, vm1, 256);
 433 }
 434
 435 void __attribute__((noinline))
 436 test_vst2dot_vssl(char* p, long idx) {
 437   // CHECK-LABEL: @test_vst2dot_vssl
 438   // CHECK: call void @llvm.ve.vl.vst2dot.vssl(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, i32 256)
 439   _vel_vst2dot_vssl(vr1, idx, p, 256);
 440 }
 441
 442 void __attribute__((noinline))
 443 test_vst2dot_vssml(char* p, long idx) {
 444   // CHECK-LABEL: @test_vst2dot_vssml
 445   // CHECK: call void @llvm.ve.vl.vst2dot.vssml(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, <256 x i1> %{{.*}}, i32 256)
 446   _vel_vst2dot_vssml(vr1, idx, p, vm1, 256);
 447 }
 448
 449 void __attribute__((noinline))
 450 test_vst2dncot_vssl(char* p, long idx) {
 451   // CHECK-LABEL: @test_vst2dncot_vssl
 452   // CHECK: call void @llvm.ve.vl.vst2dncot.vssl(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, i32 256)
 453   _vel_vst2dncot_vssl(vr1, idx, p, 256);
 454 }
 455
 456 void __attribute__((noinline))
 457 test_vst2dncot_vssml(char* p, long idx) {
 458   // CHECK-LABEL: @test_vst2dncot_vssml
 459   // CHECK: call void @llvm.ve.vl.vst2dncot.vssml(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, <256 x i1> %{{.*}}, i32 256)
 460   _vel_vst2dncot_vssml(vr1, idx, p, vm1, 256);
 461 }
 462
 463 void __attribute__((noinline))
 464 test_vstu2d_vssl(char* p, long idx) {
 465   // CHECK-LABEL: @test_vstu2d_vssl
 466   // CHECK: call void @llvm.ve.vl.vstu2d.vssl(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, i32 256)
 467   _vel_vstu2d_vssl(vr1, idx, p, 256);
 468 }
 469
 470 void __attribute__((noinline))
 471 test_vstu2d_vssml(char* p, long idx) {
 472   // CHECK-LABEL: @test_vstu2d_vssml
 473   // CHECK: call void @llvm.ve.vl.vstu2d.vssml(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, <256 x i1> %{{.*}}, i32 256)
 474   _vel_vstu2d_vssml(vr1, idx, p, vm1, 256);
 475 }
 476
 477 void __attribute__((noinline))
 478 test_vstu2dnc_vssl(char* p, long idx) {
 479   // CHECK-LABEL: @test_vstu2dnc_vssl
 480   // CHECK: call void @llvm.ve.vl.vstu2dnc.vssl(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, i32 256)
 481   _vel_vstu2dnc_vssl(vr1, idx, p, 256);
 482 }
 483
 484 void __attribute__((noinline))
 485 test_vstu2dnc_vssml(char* p, long idx) {
 486   // CHECK-LABEL: @test_vstu2dnc_vssml
 487   // CHECK: call void @llvm.ve.vl.vstu2dnc.vssml(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, <256 x i1> %{{.*}}, i32 256)
 488   _vel_vstu2dnc_vssml(vr1, idx, p, vm1, 256);
 489 }
 490
 491 void __attribute__((noinline))
 492 test_vstu2dot_vssl(char* p, long idx) {
 493   // CHECK-LABEL: @test_vstu2dot_vssl
 494   // CHECK: call void @llvm.ve.vl.vstu2dot.vssl(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, i32 256)
 495   _vel_vstu2dot_vssl(vr1, idx, p, 256);
 496 }
 497
 498 void __attribute__((noinline))
 499 test_vstu2dot_vssml(char* p, long idx) {
 500   // CHECK-LABEL: @test_vstu2dot_vssml
 501   // CHECK: call void @llvm.ve.vl.vstu2dot.vssml(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, <256 x i1> %{{.*}}, i32 256)
 502   _vel_vstu2dot_vssml(vr1, idx, p, vm1, 256);
 503 }
 504
 505 void __attribute__((noinline))
 506 test_vstu2dncot_vssl(char* p, long idx) {
 507   // CHECK-LABEL: @test_vstu2dncot_vssl
 508   // CHECK: call void @llvm.ve.vl.vstu2dncot.vssl(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, i32 256)
 509   _vel_vstu2dncot_vssl(vr1, idx, p, 256);
 510 }
 511
 512 void __attribute__((noinline))
 513 test_vstu2dncot_vssml(char* p, long idx) {
 514   // CHECK-LABEL: @test_vstu2dncot_vssml
 515   // CHECK: call void @llvm.ve.vl.vstu2dncot.vssml(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, <256 x i1> %{{.*}}, i32 256)
 516   _vel_vstu2dncot_vssml(vr1, idx, p, vm1, 256);
 517 }
 518
 519 void __attribute__((noinline))
 520 test_vstl2d_vssl(char* p, long idx) {
 521   // CHECK-LABEL: @test_vstl2d_vssl
 522   // CHECK: call void @llvm.ve.vl.vstl2d.vssl(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, i32 256)
 523   _vel_vstl2d_vssl(vr1, idx, p, 256);
 524 }
 525
 526 void __attribute__((noinline))
 527 test_vstl2d_vssml(char* p, long idx) {
 528   // CHECK-LABEL: @test_vstl2d_vssml
 529   // CHECK: call void @llvm.ve.vl.vstl2d.vssml(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, <256 x i1> %{{.*}}, i32 256)
 530   _vel_vstl2d_vssml(vr1, idx, p, vm1, 256);
 531 }
 532
 533 void __attribute__((noinline))
 534 test_vstl2dnc_vssl(char* p, long idx) {
 535   // CHECK-LABEL: @test_vstl2dnc_vssl
 536   // CHECK: call void @llvm.ve.vl.vstl2dnc.vssl(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, i32 256)
 537   _vel_vstl2dnc_vssl(vr1, idx, p, 256);
 538 }
 539
 540 void __attribute__((noinline))
 541 test_vstl2dnc_vssml(char* p, long idx) {
 542   // CHECK-LABEL: @test_vstl2dnc_vssml
 543   // CHECK: call void @llvm.ve.vl.vstl2dnc.vssml(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, <256 x i1> %{{.*}}, i32 256)
 544   _vel_vstl2dnc_vssml(vr1, idx, p, vm1, 256);
 545 }
 546
 547 void __attribute__((noinline))
 548 test_vstl2dot_vssl(char* p, long idx) {
 549   // CHECK-LABEL: @test_vstl2dot_vssl
 550   // CHECK: call void @llvm.ve.vl.vstl2dot.vssl(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, i32 256)
 551   _vel_vstl2dot_vssl(vr1, idx, p, 256);
 552 }
 553
 554 void __attribute__((noinline))
 555 test_vstl2dot_vssml(char* p, long idx) {
 556   // CHECK-LABEL: @test_vstl2dot_vssml
 557   // CHECK: call void @llvm.ve.vl.vstl2dot.vssml(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, <256 x i1> %{{.*}}, i32 256)
 558   _vel_vstl2dot_vssml(vr1, idx, p, vm1, 256);
 559 }
 560
 561 void __attribute__((noinline))
 562 test_vstl2dncot_vssl(char* p, long idx) {
 563   // CHECK-LABEL: @test_vstl2dncot_vssl
 564   // CHECK: call void @llvm.ve.vl.vstl2dncot.vssl(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, i32 256)
 565   _vel_vstl2dncot_vssl(vr1, idx, p, 256);
 566 }
 567
 568 void __attribute__((noinline))
 569 test_vstl2dncot_vssml(char* p, long idx) {
 570   // CHECK-LABEL: @test_vstl2dncot_vssml
 571   // CHECK: call void @llvm.ve.vl.vstl2dncot.vssml(<256 x double> %{{.*}}, i64 %{{.*}}, ptr %{{.*}}, <256 x i1> %{{.*}}, i32 256)
 572   _vel_vstl2dncot_vssml(vr1, idx, p, vm1, 256);
 573 }
 574
 575 void __attribute__((noinline))
 576 test_pfchv_ssl(char* p, long idx) {
 577   // CHECK-LABEL: @test_pfchv_ssl
 578   // CHECK: call void @llvm.ve.vl.pfchv.ssl(i64 %{{.*}}, ptr %{{.*}}, i32 256)
 579   _vel_pfchv_ssl(idx, p, 256);
 580 }
 581
 582 void __attribute__((noinline))
 583 test_pfchvnc_ssl(char* p, long idx) {
 584   // CHECK-LABEL: @test_pfchvnc_ssl
 585   // CHECK: call void @llvm.ve.vl.pfchvnc.ssl(i64 %{{.*}}, ptr %{{.*}}, i32 256)
 586   _vel_pfchvnc_ssl(idx, p, 256);
 587 }
 588
 589 void __attribute__((noinline))
 590 test_lsv_vvss(int idx) {
 591   // CHECK-LABEL: @test_lsv_vvss
 592   // CHECK: call <256 x double> @llvm.ve.vl.lsv.vvss(<256 x double> %{{.*}}, i32 %{{.*}}, i64 %{{.*}})
 593   vr1 = _vel_lsv_vvss(vr1, idx, v1);
 594 }
 595
 596 void __attribute__((noinline))
 597 test_lvsl_svs(int idx) {
 598   // CHECK-LABEL: @test_lvsl_svs
 599   // CHECK: call i64 @llvm.ve.vl.lvsl.svs(<256 x double> %{{.*}}, i32 %{{.*}})
 600   v1 = _vel_lvsl_svs(vr1, idx);
 601 }
 602
 603 void __attribute__((noinline))
 604 test_lvsd_svs(int idx) {
 605   // CHECK-LABEL: @test_lvsd_svs
 606   // CHECK: call double @llvm.ve.vl.lvsd.svs(<256 x double> %{{.*}}, i32 %{{.*}})
 607   vd1 = _vel_lvsd_svs(vr1, idx);
 608 }
 609
 610 void __attribute__((noinline))
 611 test_lvss_svs(int idx) {
 612   // CHECK-LABEL: @test_lvss_svs
 613   // CHECK: call float @llvm.ve.vl.lvss.svs(<256 x double> %{{.*}}, i32 %{{.*}})
 614   vf1 = _vel_lvss_svs(vr1, idx);
 615 }
 616
 617 void __attribute__((noinline))
 618 test_lvm_mmss(unsigned long sy, unsigned long sz) {
 619   // CHECK-LABEL: @test_lvm_mmss
 620   // CHECK: call <256 x i1> @llvm.ve.vl.lvm.mmss(<256 x i1> %{{.*}}, i64 %{{.*}}, i64 %{{.*}})
 621   vm1 = _vel_lvm_mmss(vm2, sy, sz);
 622 }
 623
 624 void __attribute__((noinline))
 625 test_lvm_MMss(unsigned long sy, unsigned long sz) {
 626   // CHECK-LABEL: @test_lvm_MMss
 627   // CHECK: call <512 x i1> @llvm.ve.vl.lvm.MMss(<512 x i1> %{{.*}}, i64 %{{.*}}, i64 %{{.*}})
 628   vm1_512 = _vel_lvm_MMss(vm2_512, sy, sz);
 629 }
 630
 631 void __attribute__((noinline))
 632 test_svm_sms(unsigned long sy) {
 633   // CHECK-LABEL: @test_svm_sms
 634   // CHECK: call i64 @llvm.ve.vl.svm.sms(<256 x i1> %{{.*}}, i64 %{{.*}})
 635   v1 = _vel_svm_sms(vm2, sy);
 636 }
 637
 638 void __attribute__((noinline))
 639 test_svm_sMs(unsigned long sy) {
 640   // CHECK-LABEL: @test_svm_sMs
 641   // CHECK: call i64 @llvm.ve.vl.svm.sMs(<512 x i1> %{{.*}}, i64 %{{.*}})
 642   v1 = _vel_svm_sMs(vm2_512, sy);
 643 }
 644
 645 void __attribute__((noinline))
 646 test_vbrdd_vsl() {
 647   // CHECK-LABEL: @test_vbrdd_vsl
 648   // CHECK: call <256 x double> @llvm.ve.vl.vbrdd.vsl(double %{{.*}}, i32 256)
 649   vr1 = _vel_vbrdd_vsl(vd1, 256);
 650 }
 651
 652 void __attribute__((noinline))
 653 test_vbrdd_vsvl() {
 654   // CHECK-LABEL: @test_vbrdd_vsvl
 655   // CHECK: call <256 x double> @llvm.ve.vl.vbrdd.vsvl(double %{{.*}}, <256 x double> %{{.*}}, i32 256)
 656   vr1 = _vel_vbrdd_vsvl(vd1, vr1, 256);
 657 }
 658
 659 void __attribute__((noinline))
 660 test_vbrdd_vsmvl() {
 661   // CHECK-LABEL: @test_vbrdd_vsmvl
 662   // CHECK: call <256 x double> @llvm.ve.vl.vbrdd.vsmvl(double %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
 663   vr1 = _vel_vbrdd_vsmvl(vd1, vm1, vr1, 256);
 664 }
 665
 666 void __attribute__((noinline))
 667 test_vbrdl_vsl() {
 668   // CHECK-LABEL: @test_vbrdl_vsl
 669   // CHECK: call <256 x double> @llvm.ve.vl.vbrdl.vsl(i64 %{{.*}}, i32 256)
 670   vr1 = _vel_vbrdl_vsl(v1, 256);
 671 }
 672
 673 void __attribute__((noinline))
 674 test_vbrdl_vsvl() {
 675   // CHECK-LABEL: @test_vbrdl_vsvl
 676   // CHECK: call <256 x double> @llvm.ve.vl.vbrdl.vsvl(i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
 677   vr1 = _vel_vbrdl_vsvl(v1, vr1, 256);
 678 }
 679
 680 void __attribute__((noinline))
 681 test_vbrdl_vsmvl() {
 682   // CHECK-LABEL: @test_vbrdl_vsmvl
 683   // CHECK: call <256 x double> @llvm.ve.vl.vbrdl.vsmvl(i64 %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
 684   vr1 = _vel_vbrdl_vsmvl(v1, vm1, vr1, 256);
 685 }
 686
 687 void __attribute__((noinline))
 688 test_vbrds_vsl() {
 689   // CHECK-LABEL: @test_vbrds_vsl
 690   // CHECK: call <256 x double> @llvm.ve.vl.vbrds.vsl(float %{{.*}}, i32 256)
 691   vr1 = _vel_vbrds_vsl(vf1, 256);
 692 }
 693
 694 void __attribute__((noinline))
 695 test_vbrds_vsvl() {
 696   // CHECK-LABEL: @test_vbrds_vsvl
 697   // CHECK: call <256 x double> @llvm.ve.vl.vbrds.vsvl(float %{{.*}}, <256 x double> %{{.*}}, i32 256)
 698   vr1 = _vel_vbrds_vsvl(vf1, vr1, 256);
 699 }
 700
 701 void __attribute__((noinline))
 702 test_vbrds_vsmvl() {
 703   // CHECK-LABEL: @test_vbrds_vsmvl
 704   // CHECK: call <256 x double> @llvm.ve.vl.vbrds.vsmvl(float %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
 705   vr1 = _vel_vbrds_vsmvl(vf1, vm1, vr1, 256);
 706 }
 707
 708 void __attribute__((noinline))
 709 test_vbrdw_vsl() {
 710   // CHECK-LABEL: @test_vbrdw_vsl
 711   // CHECK: call <256 x double> @llvm.ve.vl.vbrdw.vsl(i32 %{{.*}}, i32 256)
 712   vr1 = _vel_vbrdw_vsl(v1, 256);
 713 }
 714
 715 void __attribute__((noinline))
 716 test_vbrdw_vsvl() {
 717   // CHECK-LABEL: @test_vbrdw_vsvl
 718   // CHECK: call <256 x double> @llvm.ve.vl.vbrdw.vsvl(i32 %{{.*}}, <256 x double> %{{.*}}, i32 256)
 719   vr1 = _vel_vbrdw_vsvl(v1, vr1, 256);
 720 }
 721
 722 void __attribute__((noinline))
 723 test_vbrdw_vsmvl() {
 724   // CHECK-LABEL: @test_vbrdw_vsmvl
 725   // CHECK: call <256 x double> @llvm.ve.vl.vbrdw.vsmvl(i32 %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
 726   vr1 = _vel_vbrdw_vsmvl(v1, vm1, vr1, 256);
 727 }
 728
 729 void __attribute__((noinline))
 730 test_pvbrd_vsl() {
 731   // CHECK-LABEL: @test_pvbrd_vsl
 732   // CHECK: call <256 x double> @llvm.ve.vl.pvbrd.vsl(i64 %{{.*}}, i32 256)
 733   vr1 = _vel_pvbrd_vsl(v1, 256);
 734 }
 735
 736 void __attribute__((noinline))
 737 test_pvbrd_vsvl() {
 738   // CHECK-LABEL: @test_pvbrd_vsvl
 739   // CHECK: call <256 x double> @llvm.ve.vl.pvbrd.vsvl(i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
 740   vr1 = _vel_pvbrd_vsvl(v1, vr1, 256);
 741 }
 742
 743 void __attribute__((noinline))
 744 test_pvbrd_vsmvl() {
 745   // CHECK-LABEL: @test_pvbrd_vsmvl
 746   // CHECK: call <256 x double> @llvm.ve.vl.pvbrd.vsMvl(i64 %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
 747   vr1 = _vel_pvbrd_vsMvl(v1, vm1_512, vr1, 256);
 748 }
 749
 750 void __attribute__((noinline))
 751 test_vmv_vsvl() {
 752   // CHECK-LABEL: @test_vmv_vsvl
 753   // CHECK: call <256 x double> @llvm.ve.vl.vmv.vsvl(i32 %{{.*}}, <256 x double> %{{.*}}, i32 256)
 754   vr1 = _vel_vmv_vsvl(v1, vr1, 256);
 755 }
 756
 757 void __attribute__((noinline))
 758 test_vmv_vsvvl() {
 759   // CHECK-LABEL: @test_vmv_vsvvl
 760   // CHECK: call <256 x double> @llvm.ve.vl.vmv.vsvvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
 761   vr1 = _vel_vmv_vsvvl(v1, vr1, vr2, 256);
 762 }
 763
 764 void __attribute__((noinline))
 765 test_vmv_vsvmvl() {
 766   // CHECK-LABEL: @test_vmv_vsvmvl
 767   // CHECK: call <256 x double> @llvm.ve.vl.vmv.vsvmvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
 768   vr1 = _vel_vmv_vsvmvl(v1, vr1, vm1, vr2, 256);
 769 }
 770
 771 void __attribute__((noinline))
 772 test_vaddul_vvvl() {
 773   // CHECK-LABEL: @test_vaddul_vvvl
 774   // CHECK: call <256 x double> @llvm.ve.vl.vaddul.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
 775   vr3 = _vel_vaddul_vvvl(vr1, vr2, 256);
 776 }
 777
 778 void __attribute__((noinline))
 779 test_vaddul_vvvvl() {
 780   // CHECK-LABEL: @test_vaddul_vvvvl
 781   // CHECK: call <256 x double> @llvm.ve.vl.vaddul.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
 782   vr3 = _vel_vaddul_vvvvl(vr1, vr2, vr3, 256);
 783 }
 784
 785 void __attribute__((noinline))
 786 test_vaddul_vsvl() {
 787   // CHECK-LABEL: @test_vaddul_vsvl
 788   // CHECK: call <256 x double> @llvm.ve.vl.vaddul.vsvl(i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
 789   vr3 = _vel_vaddul_vsvl(v1, vr2, 256);
 790 }
 791
 792 void __attribute__((noinline))
 793 test_vaddul_vsvvl() {
 794   // CHECK-LABEL: @test_vaddul_vsvvl
 795   // CHECK: call <256 x double> @llvm.ve.vl.vaddul.vsvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
 796   vr3 = _vel_vaddul_vsvvl(v1, vr2, vr3, 256);
 797 }
 798
 799 void __attribute__((noinline))
 800 test_vaddul_vvvmvl() {
 801   // CHECK-LABEL: @test_vaddul_vvvmvl
 802   // CHECK: call <256 x double> @llvm.ve.vl.vaddul.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
 803   vr3 = _vel_vaddul_vvvmvl(vr1, vr2, vm1, vr3, 256);
 804 }
 805
 806 void __attribute__((noinline))
 807 test_vaddul_vsvmvl() {
 808   // CHECK-LABEL: @test_vaddul_vsvmvl
 809   // CHECK: call <256 x double> @llvm.ve.vl.vaddul.vsvmvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
 810   vr3 = _vel_vaddul_vsvmvl(v1, vr2, vm1, vr3, 256);
 811 }
 812
 813 void __attribute__((noinline))
 814 test_vadduw_vvvl() {
 815   // CHECK-LABEL: @test_vadduw_vvvl
 816   // CHECK: call <256 x double> @llvm.ve.vl.vadduw.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
 817   vr3 = _vel_vadduw_vvvl(vr1, vr2, 256);
 818 }
 819
 820 void __attribute__((noinline))
 821 test_vadduw_vvvvl() {
 822   // CHECK-LABEL: @test_vadduw_vvvvl
 823   // CHECK: call <256 x double> @llvm.ve.vl.vadduw.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
 824   vr3 = _vel_vadduw_vvvvl(vr1, vr2, vr3, 256);
 825 }
 826
 827 void __attribute__((noinline))
 828 test_vadduw_vsvl() {
 829   // CHECK-LABEL: @test_vadduw_vsvl
 830   // CHECK: call <256 x double> @llvm.ve.vl.vadduw.vsvl(i32 %{{.*}}, <256 x double> %{{.*}}, i32 256)
 831   vr3 = _vel_vadduw_vsvl(v1, vr2, 256);
 832 }
 833
 834 void __attribute__((noinline))
 835 test_vadduw_vsvvl() {
 836   // CHECK-LABEL: @test_vadduw_vsvvl
 837   // CHECK: call <256 x double> @llvm.ve.vl.vadduw.vsvvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
 838   vr3 = _vel_vadduw_vsvvl(v1, vr2, vr3, 256);
 839 }
 840
 841 void __attribute__((noinline))
 842 test_vadduw_vvvmvl() {
 843   // CHECK-LABEL: @test_vadduw_vvvmvl
 844   // CHECK: call <256 x double> @llvm.ve.vl.vadduw.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
 845   vr3 = _vel_vadduw_vvvmvl(vr1, vr2, vm1, vr3, 256);
 846 }
 847
 848 void __attribute__((noinline))
 849 test_vadduw_vsvmvl() {
 850   // CHECK-LABEL: @test_vadduw_vsvmvl
 851   // CHECK: call <256 x double> @llvm.ve.vl.vadduw.vsvmvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
 852   vr3 = _vel_vadduw_vsvmvl(v1, vr2, vm1, vr3, 256);
 853 }
 854
 855 void __attribute__((noinline))
 856 test_pvaddu_vvvl() {
 857   // CHECK-LABEL: @test_pvaddu_vvvl
 858   // CHECK: call <256 x double> @llvm.ve.vl.pvaddu.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
 859   vr3 = _vel_pvaddu_vvvl(vr1, vr2, 256);
 860 }
 861
 862 void __attribute__((noinline))
 863 test_pvaddu_vvvvl() {
 864   // CHECK-LABEL: @test_pvaddu_vvvvl
 865   // CHECK: call <256 x double> @llvm.ve.vl.pvaddu.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
 866   vr3 = _vel_pvaddu_vvvvl(vr1, vr2, vr3, 256);
 867 }
 868
 869 void __attribute__((noinline))
 870 test_pvaddu_vsvl() {
 871   // CHECK-LABEL: @test_pvaddu_vsvl
 872   // CHECK: call <256 x double> @llvm.ve.vl.pvaddu.vsvl(i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
 873   vr3 = _vel_pvaddu_vsvl(v1, vr2, 256);
 874 }
 875
 876 void __attribute__((noinline))
 877 test_pvaddu_vsvvl() {
 878   // CHECK-LABEL: @test_pvaddu_vsvvl
 879   // CHECK: call <256 x double> @llvm.ve.vl.pvaddu.vsvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
 880   vr3 = _vel_pvaddu_vsvvl(v1, vr2, vr3, 256);
 881 }
 882
 883 void __attribute__((noinline))
 884 test_pvaddu_vvvMvl() {
 885   // CHECK-LABEL: @test_pvaddu_vvvMvl
 886   // CHECK: call <256 x double> @llvm.ve.vl.pvaddu.vvvMvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
 887   vr3 = _vel_pvaddu_vvvMvl(vr1, vr2, vm1_512, vr3, 256);
 888 }
 889
 890 void __attribute__((noinline))
 891 test_pvaddu_vsvMvl() {
 892   // CHECK-LABEL: @test_pvaddu_vsvMvl
 893   // CHECK: call <256 x double> @llvm.ve.vl.pvaddu.vsvMvl(i64 %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
 894   vr3 = _vel_pvaddu_vsvMvl(v1, vr2, vm1_512, vr3, 256);
 895 }
 896
 897 void __attribute__((noinline))
 898 test_vaddswsx_vvvl() {
 899   // CHECK-LABEL: @test_vaddswsx_vvvl
 900   // CHECK: call <256 x double> @llvm.ve.vl.vaddswsx.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
 901   vr3 = _vel_vaddswsx_vvvl(vr1, vr2, 256);
 902 }
 903
 904 void __attribute__((noinline))
 905 test_vaddswsx_vvvvl() {
 906   // CHECK-LABEL: @test_vaddswsx_vvvvl
 907   // CHECK: call <256 x double> @llvm.ve.vl.vaddswsx.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
 908   vr3 = _vel_vaddswsx_vvvvl(vr1, vr2, vr3, 256);
 909 }
 910
 911 void __attribute__((noinline))
 912 test_vaddswsx_vsvl() {
 913   // CHECK-LABEL: @test_vaddswsx_vsvl
 914   // CHECK: call <256 x double> @llvm.ve.vl.vaddswsx.vsvl(i32 %{{.*}}, <256 x double> %{{.*}}, i32 256)
 915   vr3 = _vel_vaddswsx_vsvl(v1, vr2, 256);
 916 }
 917
 918 void __attribute__((noinline))
 919 test_vaddswsx_vsvvl() {
 920   // CHECK-LABEL: @test_vaddswsx_vsvvl
 921   // CHECK: call <256 x double> @llvm.ve.vl.vaddswsx.vsvvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
 922   vr3 = _vel_vaddswsx_vsvvl(v1, vr2, vr3, 256);
 923 }
 924
 925 void __attribute__((noinline))
 926 test_vaddswsx_vvvmvl() {
 927   // CHECK-LABEL: @test_vaddswsx_vvvmvl
 928   // CHECK: call <256 x double> @llvm.ve.vl.vaddswsx.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
 929   vr3 = _vel_vaddswsx_vvvmvl(vr1, vr2, vm1, vr3, 256);
 930 }
 931
 932 void __attribute__((noinline))
 933 test_vaddswsx_vsvmvl() {
 934   // CHECK-LABEL: @test_vaddswsx_vsvmvl
 935   // CHECK: call <256 x double> @llvm.ve.vl.vaddswsx.vsvmvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
 936   vr3 = _vel_vaddswsx_vsvmvl(v1, vr2, vm1, vr3, 256);
 937 }
 938
 939 void __attribute__((noinline))
 940 test_vaddswzx_vvvl() {
 941   // CHECK-LABEL: @test_vaddswzx_vvvl
 942   // CHECK: call <256 x double> @llvm.ve.vl.vaddswzx.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
 943   vr3 = _vel_vaddswzx_vvvl(vr1, vr2, 256);
 944 }
 945
 946 void __attribute__((noinline))
 947 test_vaddswzx_vvvvl() {
 948   // CHECK-LABEL: @test_vaddswzx_vvvvl
 949   // CHECK: call <256 x double> @llvm.ve.vl.vaddswzx.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
 950   vr3 = _vel_vaddswzx_vvvvl(vr1, vr2, vr3, 256);
 951 }
 952
 953 void __attribute__((noinline))
 954 test_vaddswzx_vsvl() {
 955   // CHECK-LABEL: @test_vaddswzx_vsvl
 956   // CHECK: call <256 x double> @llvm.ve.vl.vaddswzx.vsvl(i32 %{{.*}}, <256 x double> %{{.*}}, i32 256)
 957   vr3 = _vel_vaddswzx_vsvl(v1, vr2, 256);
 958 }
 959
 960 void __attribute__((noinline))
 961 test_vaddswzx_vsvvl() {
 962   // CHECK-LABEL: @test_vaddswzx_vsvvl
 963   // CHECK: call <256 x double> @llvm.ve.vl.vaddswzx.vsvvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
 964   vr3 = _vel_vaddswzx_vsvvl(v1, vr2, vr3, 256);
 965 }
 966
 967 void __attribute__((noinline))
 968 test_vaddswzx_vvvmvl() {
 969   // CHECK-LABEL: @test_vaddswzx_vvvmvl
 970   // CHECK: call <256 x double> @llvm.ve.vl.vaddswzx.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
 971   vr3 = _vel_vaddswzx_vvvmvl(vr1, vr2, vm1, vr3, 256);
 972 }
 973
 974 void __attribute__((noinline))
 975 test_vaddswzx_vsvmvl() {
 976   // CHECK-LABEL: @test_vaddswzx_vsvmvl
 977   // CHECK: call <256 x double> @llvm.ve.vl.vaddswzx.vsvmvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
 978   vr3 = _vel_vaddswzx_vsvmvl(v1, vr2, vm1, vr3, 256);
 979 }
 980
 981 void __attribute__((noinline))
 982 test_pvadds_vvvl() {
 983   // CHECK-LABEL: @test_pvadds_vvvl
 984   // CHECK: call <256 x double> @llvm.ve.vl.pvadds.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
 985   vr3 = _vel_pvadds_vvvl(vr1, vr2, 256);
 986 }
 987
 988 void __attribute__((noinline))
 989 test_pvadds_vvvvl() {
 990   // CHECK-LABEL: @test_pvadds_vvvvl
 991   // CHECK: call <256 x double> @llvm.ve.vl.pvadds.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
 992   vr3 = _vel_pvadds_vvvvl(vr1, vr2, vr3, 256);
 993 }
 994
 995 void __attribute__((noinline))
 996 test_pvadds_vsvl() {
 997   // CHECK-LABEL: @test_pvadds_vsvl
 998   // CHECK: call <256 x double> @llvm.ve.vl.pvadds.vsvl(i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
 999   vr3 = _vel_pvadds_vsvl(v1, vr2, 256);
1000 }
1001
1002 void __attribute__((noinline))
1003 test_pvadds_vsvvl() {
1004   // CHECK-LABEL: @test_pvadds_vsvvl
1005   // CHECK: call <256 x double> @llvm.ve.vl.pvadds.vsvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1006   vr3 = _vel_pvadds_vsvvl(v1, vr2, vr3, 256);
1007 }
1008
1009 void __attribute__((noinline))
1010 test_pvadds_vvvMvl() {
1011   // CHECK-LABEL: @test_pvadds_vvvMvl
1012   // CHECK: call <256 x double> @llvm.ve.vl.pvadds.vvvMvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1013   vr3 = _vel_pvadds_vvvMvl(vr1, vr2, vm1_512, vr3, 256);
1014 }
1015
1016 void __attribute__((noinline))
1017 test_pvadds_vsvMvl() {
1018   // CHECK-LABEL: @test_pvadds_vsvMvl
1019   // CHECK: call <256 x double> @llvm.ve.vl.pvadds.vsvMvl(i64 %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1020   vr3 = _vel_pvadds_vsvMvl(v1, vr2, vm1_512, vr3, 256);
1021 }
1022
1023 void __attribute__((noinline))
1024 test_vaddsl_vvvl() {
1025   // CHECK-LABEL: @test_vaddsl_vvvl
1026   // CHECK: call <256 x double> @llvm.ve.vl.vaddsl.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1027   vr3 = _vel_vaddsl_vvvl(vr1, vr2, 256);
1028 }
1029
1030 void __attribute__((noinline))
1031 test_vaddsl_vvvvl() {
1032   // CHECK-LABEL: @test_vaddsl_vvvvl
1033   // CHECK: call <256 x double> @llvm.ve.vl.vaddsl.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1034   vr3 = _vel_vaddsl_vvvvl(vr1, vr2, vr3, 256);
1035 }
1036
1037 void __attribute__((noinline))
1038 test_vaddsl_vsvl() {
1039   // CHECK-LABEL: @test_vaddsl_vsvl
1040   // CHECK: call <256 x double> @llvm.ve.vl.vaddsl.vsvl(i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
1041   vr3 = _vel_vaddsl_vsvl(v1, vr2, 256);
1042 }
1043
1044 void __attribute__((noinline))
1045 test_vaddsl_vsvvl() {
1046   // CHECK-LABEL: @test_vaddsl_vsvvl
1047   // CHECK: call <256 x double> @llvm.ve.vl.vaddsl.vsvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1048   vr3 = _vel_vaddsl_vsvvl(v1, vr2, vr3, 256);
1049 }
1050
1051 void __attribute__((noinline))
1052 test_vaddsl_vvvmvl() {
1053   // CHECK-LABEL: @test_vaddsl_vvvmvl
1054   // CHECK: call <256 x double> @llvm.ve.vl.vaddsl.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1055   vr3 = _vel_vaddsl_vvvmvl(vr1, vr2, vm1, vr3, 256);
1056 }
1057
1058 void __attribute__((noinline))
1059 test_vaddsl_vsvmvl() {
1060   // CHECK-LABEL: @test_vaddsl_vsvmvl
1061   // CHECK: call <256 x double> @llvm.ve.vl.vaddsl.vsvmvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1062   vr3 = _vel_vaddsl_vsvmvl(v1, vr2, vm1, vr3, 256);
1063 }
1064
1065 void __attribute__((noinline))
1066 test_vsubul_vvvl() {
1067   // CHECK-LABEL: @test_vsubul_vvvl
1068   // CHECK: call <256 x double> @llvm.ve.vl.vsubul.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1069   vr3 = _vel_vsubul_vvvl(vr1, vr2, 256);
1070 }
1071
1072 void __attribute__((noinline))
1073 test_vsubul_vvvvl() {
1074   // CHECK-LABEL: @test_vsubul_vvvvl
1075   // CHECK: call <256 x double> @llvm.ve.vl.vsubul.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1076   vr3 = _vel_vsubul_vvvvl(vr1, vr2, vr3, 256);
1077 }
1078
1079 void __attribute__((noinline))
1080 test_vsubul_vsvl() {
1081   // CHECK-LABEL: @test_vsubul_vsvl
1082   // CHECK: call <256 x double> @llvm.ve.vl.vsubul.vsvl(i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
1083   vr3 = _vel_vsubul_vsvl(v1, vr2, 256);
1084 }
1085
1086 void __attribute__((noinline))
1087 test_vsubul_vsvvl() {
1088   // CHECK-LABEL: @test_vsubul_vsvvl
1089   // CHECK: call <256 x double> @llvm.ve.vl.vsubul.vsvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1090   vr3 = _vel_vsubul_vsvvl(v1, vr2, vr3, 256);
1091 }
1092
1093 void __attribute__((noinline))
1094 test_vsubul_vvvmvl() {
1095   // CHECK-LABEL: @test_vsubul_vvvmvl
1096   // CHECK: call <256 x double> @llvm.ve.vl.vsubul.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1097   vr3 = _vel_vsubul_vvvmvl(vr1, vr2, vm1, vr3, 256);
1098 }
1099
1100 void __attribute__((noinline))
1101 test_vsubul_vsvmvl() {
1102   // CHECK-LABEL: @test_vsubul_vsvmvl
1103   // CHECK: call <256 x double> @llvm.ve.vl.vsubul.vsvmvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1104   vr3 = _vel_vsubul_vsvmvl(v1, vr2, vm1, vr3, 256);
1105 }
1106
1107 void __attribute__((noinline))
1108 test_vsubuw_vvvl() {
1109   // CHECK-LABEL: @test_vsubuw_vvvl
1110   // CHECK: call <256 x double> @llvm.ve.vl.vsubuw.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1111   vr3 = _vel_vsubuw_vvvl(vr1, vr2, 256);
1112 }
1113
1114 void __attribute__((noinline))
1115 test_vsubuw_vvvvl() {
1116   // CHECK-LABEL: @test_vsubuw_vvvvl
1117   // CHECK: call <256 x double> @llvm.ve.vl.vsubuw.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1118   vr3 = _vel_vsubuw_vvvvl(vr1, vr2, vr3, 256);
1119 }
1120
1121 void __attribute__((noinline))
1122 test_vsubuw_vsvl() {
1123   // CHECK-LABEL: @test_vsubuw_vsvl
1124   // CHECK: call <256 x double> @llvm.ve.vl.vsubuw.vsvl(i32 %{{.*}}, <256 x double> %{{.*}}, i32 256)
1125   vr3 = _vel_vsubuw_vsvl(v1, vr2, 256);
1126 }
1127
1128 void __attribute__((noinline))
1129 test_vsubuw_vsvvl() {
1130   // CHECK-LABEL: @test_vsubuw_vsvvl
1131   // CHECK: call <256 x double> @llvm.ve.vl.vsubuw.vsvvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1132   vr3 = _vel_vsubuw_vsvvl(v1, vr2, vr3, 256);
1133 }
1134
1135 void __attribute__((noinline))
1136 test_vsubuw_vvvmvl() {
1137   // CHECK-LABEL: @test_vsubuw_vvvmvl
1138   // CHECK: call <256 x double> @llvm.ve.vl.vsubuw.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1139   vr3 = _vel_vsubuw_vvvmvl(vr1, vr2, vm1, vr3, 256);
1140 }
1141
1142 void __attribute__((noinline))
1143 test_vsubuw_vsvmvl() {
1144   // CHECK-LABEL: @test_vsubuw_vsvmvl
1145   // CHECK: call <256 x double> @llvm.ve.vl.vsubuw.vsvmvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1146   vr3 = _vel_vsubuw_vsvmvl(v1, vr2, vm1, vr3, 256);
1147 }
1148
1149 void __attribute__((noinline))
1150 test_pvsubu_vvvl() {
1151   // CHECK-LABEL: @test_pvsubu_vvvl
1152   // CHECK: call <256 x double> @llvm.ve.vl.pvsubu.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1153   vr3 = _vel_pvsubu_vvvl(vr1, vr2, 256);
1154 }
1155
1156 void __attribute__((noinline))
1157 test_pvsubu_vvvvl() {
1158   // CHECK-LABEL: @test_pvsubu_vvvvl
1159   // CHECK: call <256 x double> @llvm.ve.vl.pvsubu.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1160   vr3 = _vel_pvsubu_vvvvl(vr1, vr2, vr3, 256);
1161 }
1162
1163 void __attribute__((noinline))
1164 test_pvsubu_vsvl() {
1165   // CHECK-LABEL: @test_pvsubu_vsvl
1166   // CHECK: call <256 x double> @llvm.ve.vl.pvsubu.vsvl(i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
1167   vr3 = _vel_pvsubu_vsvl(v1, vr2, 256);
1168 }
1169
1170 void __attribute__((noinline))
1171 test_pvsubu_vsvvl() {
1172   // CHECK-LABEL: @test_pvsubu_vsvvl
1173   // CHECK: call <256 x double> @llvm.ve.vl.pvsubu.vsvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1174   vr3 = _vel_pvsubu_vsvvl(v1, vr2, vr3, 256);
1175 }
1176
1177 void __attribute__((noinline))
1178 test_pvsubu_vvvMvl() {
1179   // CHECK-LABEL: @test_pvsubu_vvvMvl
1180   // CHECK: call <256 x double> @llvm.ve.vl.pvsubu.vvvMvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1181   vr3 = _vel_pvsubu_vvvMvl(vr1, vr2, vm1_512, vr3, 256);
1182 }
1183
1184 void __attribute__((noinline))
1185 test_pvsubu_vsvMvl() {
1186   // CHECK-LABEL: @test_pvsubu_vsvMvl
1187   // CHECK: call <256 x double> @llvm.ve.vl.pvsubu.vsvMvl(i64 %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1188   vr3 = _vel_pvsubu_vsvMvl(v1, vr2, vm1_512, vr3, 256);
1189 }
1190
1191 void __attribute__((noinline))
1192 test_vsubswsx_vvvl() {
1193   // CHECK-LABEL: @test_vsubswsx_vvvl
1194   // CHECK: call <256 x double> @llvm.ve.vl.vsubswsx.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1195   vr3 = _vel_vsubswsx_vvvl(vr1, vr2, 256);
1196 }
1197
1198 void __attribute__((noinline))
1199 test_vsubswsx_vvvvl() {
1200   // CHECK-LABEL: @test_vsubswsx_vvvvl
1201   // CHECK: call <256 x double> @llvm.ve.vl.vsubswsx.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1202   vr3 = _vel_vsubswsx_vvvvl(vr1, vr2, vr3, 256);
1203 }
1204
1205 void __attribute__((noinline))
1206 test_vsubswsx_vsvl() {
1207   // CHECK-LABEL: @test_vsubswsx_vsvl
1208   // CHECK: call <256 x double> @llvm.ve.vl.vsubswsx.vsvl(i32 %{{.*}}, <256 x double> %{{.*}}, i32 256)
1209   vr3 = _vel_vsubswsx_vsvl(v1, vr2, 256);
1210 }
1211
1212 void __attribute__((noinline))
1213 test_vsubswsx_vsvvl() {
1214   // CHECK-LABEL: @test_vsubswsx_vsvvl
1215   // CHECK: call <256 x double> @llvm.ve.vl.vsubswsx.vsvvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1216   vr3 = _vel_vsubswsx_vsvvl(v1, vr2, vr3, 256);
1217 }
1218
1219 void __attribute__((noinline))
1220 test_vsubswsx_vvvmvl() {
1221   // CHECK-LABEL: @test_vsubswsx_vvvmvl
1222   // CHECK: call <256 x double> @llvm.ve.vl.vsubswsx.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1223   vr3 = _vel_vsubswsx_vvvmvl(vr1, vr2, vm1, vr3, 256);
1224 }
1225
1226 void __attribute__((noinline))
1227 test_vsubswsx_vsvmvl() {
1228   // CHECK-LABEL: @test_vsubswsx_vsvmvl
1229   // CHECK: call <256 x double> @llvm.ve.vl.vsubswsx.vsvmvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1230   vr3 = _vel_vsubswsx_vsvmvl(v1, vr2, vm1, vr3, 256);
1231 }
1232
1233 void __attribute__((noinline))
1234 test_vsubswzx_vvvl() {
1235   // CHECK-LABEL: @test_vsubswzx_vvvl
1236   // CHECK: call <256 x double> @llvm.ve.vl.vsubswzx.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1237   vr3 = _vel_vsubswzx_vvvl(vr1, vr2, 256);
1238 }
1239
1240 void __attribute__((noinline))
1241 test_vsubswzx_vvvvl() {
1242   // CHECK-LABEL: @test_vsubswzx_vvvvl
1243   // CHECK: call <256 x double> @llvm.ve.vl.vsubswzx.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1244   vr3 = _vel_vsubswzx_vvvvl(vr1, vr2, vr3, 256);
1245 }
1246
1247 void __attribute__((noinline))
1248 test_vsubswzx_vsvl() {
1249   // CHECK-LABEL: @test_vsubswzx_vsvl
1250   // CHECK: call <256 x double> @llvm.ve.vl.vsubswzx.vsvl(i32 %{{.*}}, <256 x double> %{{.*}}, i32 256)
1251   vr3 = _vel_vsubswzx_vsvl(v1, vr2, 256);
1252 }
1253
1254 void __attribute__((noinline))
1255 test_vsubswzx_vsvvl() {
1256   // CHECK-LABEL: @test_vsubswzx_vsvvl
1257   // CHECK: call <256 x double> @llvm.ve.vl.vsubswzx.vsvvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1258   vr3 = _vel_vsubswzx_vsvvl(v1, vr2, vr3, 256);
1259 }
1260
1261 void __attribute__((noinline))
1262 test_vsubswzx_vvvmvl() {
1263   // CHECK-LABEL: @test_vsubswzx_vvvmvl
1264   // CHECK: call <256 x double> @llvm.ve.vl.vsubswzx.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1265   vr3 = _vel_vsubswzx_vvvmvl(vr1, vr2, vm1, vr3, 256);
1266 }
1267
1268 void __attribute__((noinline))
1269 test_vsubswzx_vsvmvl() {
1270   // CHECK-LABEL: @test_vsubswzx_vsvmvl
1271   // CHECK: call <256 x double> @llvm.ve.vl.vsubswzx.vsvmvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1272   vr3 = _vel_vsubswzx_vsvmvl(v1, vr2, vm1, vr3, 256);
1273 }
1274
1275 void __attribute__((noinline))
1276 test_pvsubs_vvvl() {
1277   // CHECK-LABEL: @test_pvsubs_vvvl
1278   // CHECK: call <256 x double> @llvm.ve.vl.pvsubs.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1279   vr3 = _vel_pvsubs_vvvl(vr1, vr2, 256);
1280 }
1281
1282 void __attribute__((noinline))
1283 test_pvsubs_vvvvl() {
1284   // CHECK-LABEL: @test_pvsubs_vvvvl
1285   // CHECK: call <256 x double> @llvm.ve.vl.pvsubs.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1286   vr3 = _vel_pvsubs_vvvvl(vr1, vr2, vr3, 256);
1287 }
1288
1289 void __attribute__((noinline))
1290 test_pvsubs_vsvl() {
1291   // CHECK-LABEL: @test_pvsubs_vsvl
1292   // CHECK: call <256 x double> @llvm.ve.vl.pvsubs.vsvl(i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
1293   vr3 = _vel_pvsubs_vsvl(v1, vr2, 256);
1294 }
1295
1296 void __attribute__((noinline))
1297 test_pvsubs_vsvvl() {
1298   // CHECK-LABEL: @test_pvsubs_vsvvl
1299   // CHECK: call <256 x double> @llvm.ve.vl.pvsubs.vsvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1300   vr3 = _vel_pvsubs_vsvvl(v1, vr2, vr3, 256);
1301 }
1302
1303 void __attribute__((noinline))
1304 test_pvsubs_vvvMvl() {
1305   // CHECK-LABEL: @test_pvsubs_vvvMvl
1306   // CHECK: call <256 x double> @llvm.ve.vl.pvsubs.vvvMvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1307   vr3 = _vel_pvsubs_vvvMvl(vr1, vr2, vm1_512, vr3, 256);
1308 }
1309
1310 void __attribute__((noinline))
1311 test_pvsubs_vsvMvl() {
1312   // CHECK-LABEL: @test_pvsubs_vsvMvl
1313   // CHECK: call <256 x double> @llvm.ve.vl.pvsubs.vsvMvl(i64 %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1314   vr3 = _vel_pvsubs_vsvMvl(v1, vr2, vm1_512, vr3, 256);
1315 }
1316
1317 void __attribute__((noinline))
1318 test_vsubsl_vvvl() {
1319   // CHECK-LABEL: @test_vsubsl_vvvl
1320   // CHECK: call <256 x double> @llvm.ve.vl.vsubsl.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1321   vr3 = _vel_vsubsl_vvvl(vr1, vr2, 256);
1322 }
1323
1324 void __attribute__((noinline))
1325 test_vsubsl_vvvvl() {
1326   // CHECK-LABEL: @test_vsubsl_vvvvl
1327   // CHECK: call <256 x double> @llvm.ve.vl.vsubsl.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1328   vr3 = _vel_vsubsl_vvvvl(vr1, vr2, vr3, 256);
1329 }
1330
1331 void __attribute__((noinline))
1332 test_vsubsl_vsvl() {
1333   // CHECK-LABEL: @test_vsubsl_vsvl
1334   // CHECK: call <256 x double> @llvm.ve.vl.vsubsl.vsvl(i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
1335   vr3 = _vel_vsubsl_vsvl(v1, vr2, 256);
1336 }
1337
1338 void __attribute__((noinline))
1339 test_vsubsl_vsvvl() {
1340   // CHECK-LABEL: @test_vsubsl_vsvvl
1341   // CHECK: call <256 x double> @llvm.ve.vl.vsubsl.vsvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1342   vr3 = _vel_vsubsl_vsvvl(v1, vr2, vr3, 256);
1343 }
1344
1345 void __attribute__((noinline))
1346 test_vsubsl_vvvmvl() {
1347   // CHECK-LABEL: @test_vsubsl_vvvmvl
1348   // CHECK: call <256 x double> @llvm.ve.vl.vsubsl.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1349   vr3 = _vel_vsubsl_vvvmvl(vr1, vr2, vm1, vr3, 256);
1350 }
1351
1352 void __attribute__((noinline))
1353 test_vsubsl_vsvmvl() {
1354   // CHECK-LABEL: @test_vsubsl_vsvmvl
1355   // CHECK: call <256 x double> @llvm.ve.vl.vsubsl.vsvmvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1356   vr3 = _vel_vsubsl_vsvmvl(v1, vr2, vm1, vr3, 256);
1357 }
1358
1359 void __attribute__((noinline))
1360 test_vmulul_vvvl() {
1361   // CHECK-LABEL: @test_vmulul_vvvl
1362   // CHECK: call <256 x double> @llvm.ve.vl.vmulul.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1363   vr3 = _vel_vmulul_vvvl(vr1, vr2, 256);
1364 }
1365
1366 void __attribute__((noinline))
1367 test_vmulul_vvvvl() {
1368   // CHECK-LABEL: @test_vmulul_vvvvl
1369   // CHECK: call <256 x double> @llvm.ve.vl.vmulul.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1370   vr3 = _vel_vmulul_vvvvl(vr1, vr2, vr3, 256);
1371 }
1372
1373 void __attribute__((noinline))
1374 test_vmulul_vsvl() {
1375   // CHECK-LABEL: @test_vmulul_vsvl
1376   // CHECK: call <256 x double> @llvm.ve.vl.vmulul.vsvl(i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
1377   vr3 = _vel_vmulul_vsvl(v1, vr2, 256);
1378 }
1379
1380 void __attribute__((noinline))
1381 test_vmulul_vsvvl() {
1382   // CHECK-LABEL: @test_vmulul_vsvvl
1383   // CHECK: call <256 x double> @llvm.ve.vl.vmulul.vsvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1384   vr3 = _vel_vmulul_vsvvl(v1, vr2, vr3, 256);
1385 }
1386
1387 void __attribute__((noinline))
1388 test_vmulul_vvvmvl() {
1389   // CHECK-LABEL: @test_vmulul_vvvmvl
1390   // CHECK: call <256 x double> @llvm.ve.vl.vmulul.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1391   vr3 = _vel_vmulul_vvvmvl(vr1, vr2, vm1, vr3, 256);
1392 }
1393
1394 void __attribute__((noinline))
1395 test_vmulul_vsvmvl() {
1396   // CHECK-LABEL: @test_vmulul_vsvmvl
1397   // CHECK: call <256 x double> @llvm.ve.vl.vmulul.vsvmvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1398   vr3 = _vel_vmulul_vsvmvl(v1, vr2, vm1, vr3, 256);
1399 }
1400
1401 void __attribute__((noinline))
1402 test_vmuluw_vvvl() {
1403   // CHECK-LABEL: @test_vmuluw_vvvl
1404   // CHECK: call <256 x double> @llvm.ve.vl.vmuluw.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1405   vr3 = _vel_vmuluw_vvvl(vr1, vr2, 256);
1406 }
1407
1408 void __attribute__((noinline))
1409 test_vmuluw_vvvvl() {
1410   // CHECK-LABEL: @test_vmuluw_vvvvl
1411   // CHECK: call <256 x double> @llvm.ve.vl.vmuluw.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1412   vr3 = _vel_vmuluw_vvvvl(vr1, vr2, vr3, 256);
1413 }
1414
1415 void __attribute__((noinline))
1416 test_vmuluw_vsvl() {
1417   // CHECK-LABEL: @test_vmuluw_vsvl
1418   // CHECK: call <256 x double> @llvm.ve.vl.vmuluw.vsvl(i32 %{{.*}}, <256 x double> %{{.*}}, i32 256)
1419   vr3 = _vel_vmuluw_vsvl(v1, vr2, 256);
1420 }
1421
1422 void __attribute__((noinline))
1423 test_vmuluw_vsvvl() {
1424   // CHECK-LABEL: @test_vmuluw_vsvvl
1425   // CHECK: call <256 x double> @llvm.ve.vl.vmuluw.vsvvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1426   vr3 = _vel_vmuluw_vsvvl(v1, vr2, vr3, 256);
1427 }
1428
1429 void __attribute__((noinline))
1430 test_vmuluw_vvvmvl() {
1431   // CHECK-LABEL: @test_vmuluw_vvvmvl
1432   // CHECK: call <256 x double> @llvm.ve.vl.vmuluw.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1433   vr3 = _vel_vmuluw_vvvmvl(vr1, vr2, vm1, vr3, 256);
1434 }
1435
1436 void __attribute__((noinline))
1437 test_vmuluw_vsvmvl() {
1438   // CHECK-LABEL: @test_vmuluw_vsvmvl
1439   // CHECK: call <256 x double> @llvm.ve.vl.vmuluw.vsvmvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1440   vr3 = _vel_vmuluw_vsvmvl(v1, vr2, vm1, vr3, 256);
1441 }
1442
1443 void __attribute__((noinline))
1444 test_vmulswsx_vvvl() {
1445   // CHECK-LABEL: @test_vmulswsx_vvvl
1446   // CHECK: call <256 x double> @llvm.ve.vl.vmulswsx.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1447   vr3 = _vel_vmulswsx_vvvl(vr1, vr2, 256);
1448 }
1449
1450 void __attribute__((noinline))
1451 test_vmulswsx_vvvvl() {
1452   // CHECK-LABEL: @test_vmulswsx_vvvvl
1453   // CHECK: call <256 x double> @llvm.ve.vl.vmulswsx.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1454   vr3 = _vel_vmulswsx_vvvvl(vr1, vr2, vr3, 256);
1455 }
1456
1457 void __attribute__((noinline))
1458 test_vmulswsx_vsvl() {
1459   // CHECK-LABEL: @test_vmulswsx_vsvl
1460   // CHECK: call <256 x double> @llvm.ve.vl.vmulswsx.vsvl(i32 %{{.*}}, <256 x double> %{{.*}}, i32 256)
1461   vr3 = _vel_vmulswsx_vsvl(v1, vr2, 256);
1462 }
1463
1464 void __attribute__((noinline))
1465 test_vmulswsx_vsvvl() {
1466   // CHECK-LABEL: @test_vmulswsx_vsvvl
1467   // CHECK: call <256 x double> @llvm.ve.vl.vmulswsx.vsvvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1468   vr3 = _vel_vmulswsx_vsvvl(v1, vr2, vr3, 256);
1469 }
1470
1471 void __attribute__((noinline))
1472 test_vmulswsx_vvvmvl() {
1473   // CHECK-LABEL: @test_vmulswsx_vvvmvl
1474   // CHECK: call <256 x double> @llvm.ve.vl.vmulswsx.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1475   vr3 = _vel_vmulswsx_vvvmvl(vr1, vr2, vm1, vr3, 256);
1476 }
1477
1478 void __attribute__((noinline))
1479 test_vmulswsx_vsvmvl() {
1480   // CHECK-LABEL: @test_vmulswsx_vsvmvl
1481   // CHECK: call <256 x double> @llvm.ve.vl.vmulswsx.vsvmvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1482   vr3 = _vel_vmulswsx_vsvmvl(v1, vr2, vm1, vr3, 256);
1483 }
1484
1485 void __attribute__((noinline))
1486 test_vmulswzx_vvvl() {
1487   // CHECK-LABEL: @test_vmulswzx_vvvl
1488   // CHECK: call <256 x double> @llvm.ve.vl.vmulswzx.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1489   vr3 = _vel_vmulswzx_vvvl(vr1, vr2, 256);
1490 }
1491
1492 void __attribute__((noinline))
1493 test_vmulswzx_vvvvl() {
1494   // CHECK-LABEL: @test_vmulswzx_vvvvl
1495   // CHECK: call <256 x double> @llvm.ve.vl.vmulswzx.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1496   vr3 = _vel_vmulswzx_vvvvl(vr1, vr2, vr3, 256);
1497 }
1498
1499 void __attribute__((noinline))
1500 test_vmulswzx_vsvl() {
1501   // CHECK-LABEL: @test_vmulswzx_vsvl
1502   // CHECK: call <256 x double> @llvm.ve.vl.vmulswzx.vsvl(i32 %{{.*}}, <256 x double> %{{.*}}, i32 256)
1503   vr3 = _vel_vmulswzx_vsvl(v1, vr2, 256);
1504 }
1505
1506 void __attribute__((noinline))
1507 test_vmulswzx_vsvvl() {
1508   // CHECK-LABEL: @test_vmulswzx_vsvvl
1509   // CHECK: call <256 x double> @llvm.ve.vl.vmulswzx.vsvvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1510   vr3 = _vel_vmulswzx_vsvvl(v1, vr2, vr3, 256);
1511 }
1512
1513 void __attribute__((noinline))
1514 test_vmulswzx_vvvmvl() {
1515   // CHECK-LABEL: @test_vmulswzx_vvvmvl
1516   // CHECK: call <256 x double> @llvm.ve.vl.vmulswzx.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1517   vr3 = _vel_vmulswzx_vvvmvl(vr1, vr2, vm1, vr3, 256);
1518 }
1519
1520 void __attribute__((noinline))
1521 test_vmulswzx_vsvmvl() {
1522   // CHECK-LABEL: @test_vmulswzx_vsvmvl
1523   // CHECK: call <256 x double> @llvm.ve.vl.vmulswzx.vsvmvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1524   vr3 = _vel_vmulswzx_vsvmvl(v1, vr2, vm1, vr3, 256);
1525 }
1526
1527 void __attribute__((noinline))
1528 test_vmulsl_vvvl() {
1529   // CHECK-LABEL: @test_vmulsl_vvvl
1530   // CHECK: call <256 x double> @llvm.ve.vl.vmulsl.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1531   vr3 = _vel_vmulsl_vvvl(vr1, vr2, 256);
1532 }
1533
1534 void __attribute__((noinline))
1535 test_vmulsl_vvvvl() {
1536   // CHECK-LABEL: @test_vmulsl_vvvvl
1537   // CHECK: call <256 x double> @llvm.ve.vl.vmulsl.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1538   vr3 = _vel_vmulsl_vvvvl(vr1, vr2, vr3, 256);
1539 }
1540
1541 void __attribute__((noinline))
1542 test_vmulsl_vsvl() {
1543   // CHECK-LABEL: @test_vmulsl_vsvl
1544   // CHECK: call <256 x double> @llvm.ve.vl.vmulsl.vsvl(i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
1545   vr3 = _vel_vmulsl_vsvl(v1, vr2, 256);
1546 }
1547
1548 void __attribute__((noinline))
1549 test_vmulsl_vsvvl() {
1550   // CHECK-LABEL: @test_vmulsl_vsvvl
1551   // CHECK: call <256 x double> @llvm.ve.vl.vmulsl.vsvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1552   vr3 = _vel_vmulsl_vsvvl(v1, vr2, vr3, 256);
1553 }
1554
1555 void __attribute__((noinline))
1556 test_vmulsl_vvvmvl() {
1557   // CHECK-LABEL: @test_vmulsl_vvvmvl
1558   // CHECK: call <256 x double> @llvm.ve.vl.vmulsl.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1559   vr3 = _vel_vmulsl_vvvmvl(vr1, vr2, vm1, vr3, 256);
1560 }
1561
1562 void __attribute__((noinline))
1563 test_vmulsl_vsvmvl() {
1564   // CHECK-LABEL: @test_vmulsl_vsvmvl
1565   // CHECK: call <256 x double> @llvm.ve.vl.vmulsl.vsvmvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1566   vr3 = _vel_vmulsl_vsvmvl(v1, vr2, vm1, vr3, 256);
1567 }
1568
1569 void __attribute__((noinline))
1570 test_vmulslw_vvvl() {
1571   // CHECK-LABEL: @test_vmulslw_vvvl
1572   // CHECK: call <256 x double> @llvm.ve.vl.vmulslw.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1573   vr3 = _vel_vmulslw_vvvl(vr1, vr2, 256);
1574 }
1575
1576 void __attribute__((noinline))
1577 test_vmulslw_vvvvl() {
1578   // CHECK-LABEL: @test_vmulslw_vvvvl
1579   // CHECK: call <256 x double> @llvm.ve.vl.vmulslw.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1580   vr3 = _vel_vmulslw_vvvvl(vr1, vr2, vr3, 256);
1581 }
1582
1583 void __attribute__((noinline))
1584 test_vmulslw_vsvl() {
1585   // CHECK-LABEL: @test_vmulslw_vsvl
1586   // CHECK: call <256 x double> @llvm.ve.vl.vmulslw.vsvl(i32 %{{.*}}, <256 x double> %{{.*}}, i32 256)
1587   vr3 = _vel_vmulslw_vsvl(v1, vr2, 256);
1588 }
1589
1590 void __attribute__((noinline))
1591 test_vmulslw_vsvvl() {
1592   // CHECK-LABEL: @test_vmulslw_vsvvl
1593   // CHECK: call <256 x double> @llvm.ve.vl.vmulslw.vsvvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1594   vr3 = _vel_vmulslw_vsvvl(v1, vr2, vr3, 256);
1595 }
1596
1597 void __attribute__((noinline))
1598 test_vdivul_vvvl() {
1599   // CHECK-LABEL: @test_vdivul_vvvl
1600   // CHECK: call <256 x double> @llvm.ve.vl.vdivul.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1601   vr3 = _vel_vdivul_vvvl(vr1, vr2, 256);
1602 }
1603
1604 void __attribute__((noinline))
1605 test_vdivul_vvvvl() {
1606   // CHECK-LABEL: @test_vdivul_vvvvl
1607   // CHECK: call <256 x double> @llvm.ve.vl.vdivul.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1608   vr3 = _vel_vdivul_vvvvl(vr1, vr2, vr3, 256);
1609 }
1610
1611 void __attribute__((noinline))
1612 test_vdivul_vsvl() {
1613   // CHECK-LABEL: @test_vdivul_vsvl
1614   // CHECK: call <256 x double> @llvm.ve.vl.vdivul.vsvl(i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
1615   vr3 = _vel_vdivul_vsvl(v1, vr2, 256);
1616 }
1617
1618 void __attribute__((noinline))
1619 test_vdivul_vsvvl() {
1620   // CHECK-LABEL: @test_vdivul_vsvvl
1621   // CHECK: call <256 x double> @llvm.ve.vl.vdivul.vsvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1622   vr3 = _vel_vdivul_vsvvl(v1, vr2, vr3, 256);
1623 }
1624
1625 void __attribute__((noinline))
1626 test_vdivul_vvvmvl() {
1627   // CHECK-LABEL: @test_vdivul_vvvmvl
1628   // CHECK: call <256 x double> @llvm.ve.vl.vdivul.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1629   vr3 = _vel_vdivul_vvvmvl(vr1, vr2, vm1, vr3, 256);
1630 }
1631
1632 void __attribute__((noinline))
1633 test_vdivul_vsvmvl() {
1634   // CHECK-LABEL: @test_vdivul_vsvmvl
1635   // CHECK: call <256 x double> @llvm.ve.vl.vdivul.vsvmvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1636   vr3 = _vel_vdivul_vsvmvl(v1, vr2, vm1, vr3, 256);
1637 }
1638
1639 void __attribute__((noinline))
1640 test_vdivuw_vvvl() {
1641   // CHECK-LABEL: @test_vdivuw_vvvl
1642   // CHECK: call <256 x double> @llvm.ve.vl.vdivuw.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1643   vr3 = _vel_vdivuw_vvvl(vr1, vr2, 256);
1644 }
1645
1646 void __attribute__((noinline))
1647 test_vdivuw_vvvvl() {
1648   // CHECK-LABEL: @test_vdivuw_vvvvl
1649   // CHECK: call <256 x double> @llvm.ve.vl.vdivuw.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1650   vr3 = _vel_vdivuw_vvvvl(vr1, vr2, vr3, 256);
1651 }
1652
1653 void __attribute__((noinline))
1654 test_vdivuw_vsvl() {
1655   // CHECK-LABEL: @test_vdivuw_vsvl
1656   // CHECK: call <256 x double> @llvm.ve.vl.vdivuw.vsvl(i32 %{{.*}}, <256 x double> %{{.*}}, i32 256)
1657   vr3 = _vel_vdivuw_vsvl(v1, vr2, 256);
1658 }
1659
1660 void __attribute__((noinline))
1661 test_vdivuw_vsvvl() {
1662   // CHECK-LABEL: @test_vdivuw_vsvvl
1663   // CHECK: call <256 x double> @llvm.ve.vl.vdivuw.vsvvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1664   vr3 = _vel_vdivuw_vsvvl(v1, vr2, vr3, 256);
1665 }
1666
1667 void __attribute__((noinline))
1668 test_vdivuw_vvvmvl() {
1669   // CHECK-LABEL: @test_vdivuw_vvvmvl
1670   // CHECK: call <256 x double> @llvm.ve.vl.vdivuw.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1671   vr3 = _vel_vdivuw_vvvmvl(vr1, vr2, vm1, vr3, 256);
1672 }
1673
1674 void __attribute__((noinline))
1675 test_vdivuw_vsvmvl() {
1676   // CHECK-LABEL: @test_vdivuw_vsvmvl
1677   // CHECK: call <256 x double> @llvm.ve.vl.vdivuw.vsvmvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1678   vr3 = _vel_vdivuw_vsvmvl(v1, vr2, vm1, vr3, 256);
1679 }
1680
1681 void __attribute__((noinline))
1682 test_vdivul_vvsl() {
1683   // CHECK-LABEL: @test_vdivul_vvsl
1684   // CHECK: call <256 x double> @llvm.ve.vl.vdivul.vvsl(<256 x double> %{{.*}}, i64 %{{.*}}, i32 256)
1685   vr3 = _vel_vdivul_vvsl(vr1, v2, 256);
1686 }
1687
1688 void __attribute__((noinline))
1689 test_vdivul_vvsvl() {
1690   // CHECK-LABEL: @test_vdivul_vvsvl
1691   // CHECK: call <256 x double> @llvm.ve.vl.vdivul.vvsvl(<256 x double> %{{.*}}, i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
1692   vr3 = _vel_vdivul_vvsvl(vr1, v2, vr3, 256);
1693 }
1694
1695 void __attribute__((noinline))
1696 test_vdivul_vvsmvl() {
1697   // CHECK-LABEL: @test_vdivul_vvsmvl
1698   // CHECK: call <256 x double> @llvm.ve.vl.vdivul.vvsmvl(<256 x double> %{{.*}}, i64 %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1699   vr3 = _vel_vdivul_vvsmvl(vr1, v2, vm1, vr3, 256);
1700 }
1701
1702 void __attribute__((noinline))
1703 test_vdivuw_vvsl() {
1704   // CHECK-LABEL: @test_vdivuw_vvsl
1705   // CHECK: call <256 x double> @llvm.ve.vl.vdivuw.vvsl(<256 x double> %{{.*}}, i32 %{{.*}}, i32 256)
1706   vr3 = _vel_vdivuw_vvsl(vr1, v2, 256);
1707 }
1708
1709 void __attribute__((noinline))
1710 test_vdivuw_vvsvl() {
1711   // CHECK-LABEL: @test_vdivuw_vvsvl
1712   // CHECK: call <256 x double> @llvm.ve.vl.vdivuw.vvsvl(<256 x double> %{{.*}}, i32 %{{.*}}, <256 x double> %{{.*}}, i32 256)
1713   vr3 = _vel_vdivuw_vvsvl(vr1, v2, vr3, 256);
1714 }
1715
1716 void __attribute__((noinline))
1717 test_vdivuw_vvsmvl() {
1718   // CHECK-LABEL: @test_vdivuw_vvsmvl
1719   // CHECK: call <256 x double> @llvm.ve.vl.vdivuw.vvsmvl(<256 x double> %{{.*}}, i32 %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1720   vr3 = _vel_vdivuw_vvsmvl(vr1, v2, vm1, vr3, 256);
1721 }
1722
1723 void __attribute__((noinline))
1724 test_vdivswsx_vvvl() {
1725   // CHECK-LABEL: @test_vdivswsx_vvvl
1726   // CHECK: call <256 x double> @llvm.ve.vl.vdivswsx.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1727   vr3 = _vel_vdivswsx_vvvl(vr1, vr2, 256);
1728 }
1729
1730 void __attribute__((noinline))
1731 test_vdivswsx_vvvvl() {
1732   // CHECK-LABEL: @test_vdivswsx_vvvvl
1733   // CHECK: call <256 x double> @llvm.ve.vl.vdivswsx.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1734   vr3 = _vel_vdivswsx_vvvvl(vr1, vr2, vr3, 256);
1735 }
1736
1737 void __attribute__((noinline))
1738 test_vdivswsx_vsvl() {
1739   // CHECK-LABEL: @test_vdivswsx_vsvl
1740   // CHECK: call <256 x double> @llvm.ve.vl.vdivswsx.vsvl(i32 %{{.*}}, <256 x double> %{{.*}}, i32 256)
1741   vr3 = _vel_vdivswsx_vsvl(v1, vr2, 256);
1742 }
1743
1744 void __attribute__((noinline))
1745 test_vdivswsx_vsvvl() {
1746   // CHECK-LABEL: @test_vdivswsx_vsvvl
1747   // CHECK: call <256 x double> @llvm.ve.vl.vdivswsx.vsvvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1748   vr3 = _vel_vdivswsx_vsvvl(v1, vr2, vr3, 256);
1749 }
1750
1751 void __attribute__((noinline))
1752 test_vdivswsx_vvvmvl() {
1753   // CHECK-LABEL: @test_vdivswsx_vvvmvl
1754   // CHECK: call <256 x double> @llvm.ve.vl.vdivswsx.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1755   vr3 = _vel_vdivswsx_vvvmvl(vr1, vr2, vm1, vr3, 256);
1756 }
1757
1758 void __attribute__((noinline))
1759 test_vdivswsx_vsvmvl() {
1760   // CHECK-LABEL: @test_vdivswsx_vsvmvl
1761   // CHECK: call <256 x double> @llvm.ve.vl.vdivswsx.vsvmvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1762   vr3 = _vel_vdivswsx_vsvmvl(v1, vr2, vm1, vr3, 256);
1763 }
1764
1765 void __attribute__((noinline))
1766 test_vdivswzx_vvvl() {
1767   // CHECK-LABEL: @test_vdivswzx_vvvl
1768   // CHECK: call <256 x double> @llvm.ve.vl.vdivswzx.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1769   vr3 = _vel_vdivswzx_vvvl(vr1, vr2, 256);
1770 }
1771
1772 void __attribute__((noinline))
1773 test_vdivswzx_vvvvl() {
1774   // CHECK-LABEL: @test_vdivswzx_vvvvl
1775   // CHECK: call <256 x double> @llvm.ve.vl.vdivswzx.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1776   vr3 = _vel_vdivswzx_vvvvl(vr1, vr2, vr3, 256);
1777 }
1778
1779 void __attribute__((noinline))
1780 test_vdivswzx_vsvl() {
1781   // CHECK-LABEL: @test_vdivswzx_vsvl
1782   // CHECK: call <256 x double> @llvm.ve.vl.vdivswzx.vsvl(i32 %{{.*}}, <256 x double> %{{.*}}, i32 256)
1783   vr3 = _vel_vdivswzx_vsvl(v1, vr2, 256);
1784 }
1785
1786 void __attribute__((noinline))
1787 test_vdivswzx_vsvvl() {
1788   // CHECK-LABEL: @test_vdivswzx_vsvvl
1789   // CHECK: call <256 x double> @llvm.ve.vl.vdivswzx.vsvvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1790   vr3 = _vel_vdivswzx_vsvvl(v1, vr2, vr3, 256);
1791 }
1792
1793 void __attribute__((noinline))
1794 test_vdivswzx_vvvmvl() {
1795   // CHECK-LABEL: @test_vdivswzx_vvvmvl
1796   // CHECK: call <256 x double> @llvm.ve.vl.vdivswzx.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1797   vr3 = _vel_vdivswzx_vvvmvl(vr1, vr2, vm1, vr3, 256);
1798 }
1799
1800 void __attribute__((noinline))
1801 test_vdivswzx_vsvmvl() {
1802   // CHECK-LABEL: @test_vdivswzx_vsvmvl
1803   // CHECK: call <256 x double> @llvm.ve.vl.vdivswzx.vsvmvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1804   vr3 = _vel_vdivswzx_vsvmvl(v1, vr2, vm1, vr3, 256);
1805 }
1806
1807 void __attribute__((noinline))
1808 test_vdivswsx_vvsl() {
1809   // CHECK-LABEL: @test_vdivswsx_vvsl
1810   // CHECK: call <256 x double> @llvm.ve.vl.vdivswsx.vvsl(<256 x double> %{{.*}}, i32 %{{.*}}, i32 256)
1811   vr3 = _vel_vdivswsx_vvsl(vr1, v2, 256);
1812 }
1813
1814 void __attribute__((noinline))
1815 test_vdivswsx_vvsvl() {
1816   // CHECK-LABEL: @test_vdivswsx_vvsvl
1817   // CHECK: call <256 x double> @llvm.ve.vl.vdivswsx.vvsvl(<256 x double> %{{.*}}, i32 %{{.*}}, <256 x double> %{{.*}}, i32 256)
1818   vr3 = _vel_vdivswsx_vvsvl(vr1, v2, vr3, 256);
1819 }
1820
1821 void __attribute__((noinline))
1822 test_vdivswsx_vvsmvl() {
1823   // CHECK-LABEL: @test_vdivswsx_vvsmvl
1824   // CHECK: call <256 x double> @llvm.ve.vl.vdivswsx.vvsmvl(<256 x double> %{{.*}}, i32 %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1825   vr3 = _vel_vdivswsx_vvsmvl(vr1, v2, vm1, vr3, 256);
1826 }
1827
1828 void __attribute__((noinline))
1829 test_vdivswzx_vvsl() {
1830   // CHECK-LABEL: @test_vdivswzx_vvsl
1831   // CHECK: call <256 x double> @llvm.ve.vl.vdivswzx.vvsl(<256 x double> %{{.*}}, i32 %{{.*}}, i32 256)
1832   vr3 = _vel_vdivswzx_vvsl(vr1, v2, 256);
1833 }
1834
1835 void __attribute__((noinline))
1836 test_vdivswzx_vvsvl() {
1837   // CHECK-LABEL: @test_vdivswzx_vvsvl
1838   // CHECK: call <256 x double> @llvm.ve.vl.vdivswzx.vvsvl(<256 x double> %{{.*}}, i32 %{{.*}}, <256 x double> %{{.*}}, i32 256)
1839   vr3 = _vel_vdivswzx_vvsvl(vr1, v2, vr3, 256);
1840 }
1841
1842 void __attribute__((noinline))
1843 test_vdivswzx_vvsmvl() {
1844   // CHECK-LABEL: @test_vdivswzx_vvsmvl
1845   // CHECK: call <256 x double> @llvm.ve.vl.vdivswzx.vvsmvl(<256 x double> %{{.*}}, i32 %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1846   vr3 = _vel_vdivswzx_vvsmvl(vr1, v2, vm1, vr3, 256);
1847 }
1848
1849 void __attribute__((noinline))
1850 test_vdivsl_vvvl() {
1851   // CHECK-LABEL: @test_vdivsl_vvvl
1852   // CHECK: call <256 x double> @llvm.ve.vl.vdivsl.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1853   vr3 = _vel_vdivsl_vvvl(vr1, vr2, 256);
1854 }
1855
1856 void __attribute__((noinline))
1857 test_vdivsl_vvvvl() {
1858   // CHECK-LABEL: @test_vdivsl_vvvvl
1859   // CHECK: call <256 x double> @llvm.ve.vl.vdivsl.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1860   vr3 = _vel_vdivsl_vvvvl(vr1, vr2, vr3, 256);
1861 }
1862
1863 void __attribute__((noinline))
1864 test_vdivsl_vsvl() {
1865   // CHECK-LABEL: @test_vdivsl_vsvl
1866   // CHECK: call <256 x double> @llvm.ve.vl.vdivsl.vsvl(i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
1867   vr3 = _vel_vdivsl_vsvl(v1, vr2, 256);
1868 }
1869
1870 void __attribute__((noinline))
1871 test_vdivsl_vsvvl() {
1872   // CHECK-LABEL: @test_vdivsl_vsvvl
1873   // CHECK: call <256 x double> @llvm.ve.vl.vdivsl.vsvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1874   vr3 = _vel_vdivsl_vsvvl(v1, vr2, vr3, 256);
1875 }
1876
1877 void __attribute__((noinline))
1878 test_vdivsl_vvvmvl() {
1879   // CHECK-LABEL: @test_vdivsl_vvvmvl
1880   // CHECK: call <256 x double> @llvm.ve.vl.vdivsl.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1881   vr3 = _vel_vdivsl_vvvmvl(vr1, vr2, vm1, vr3, 256);
1882 }
1883
1884 void __attribute__((noinline))
1885 test_vdivsl_vsvmvl() {
1886   // CHECK-LABEL: @test_vdivsl_vsvmvl
1887   // CHECK: call <256 x double> @llvm.ve.vl.vdivsl.vsvmvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1888   vr3 = _vel_vdivsl_vsvmvl(v1, vr2, vm1, vr3, 256);
1889 }
1890
1891 void __attribute__((noinline))
1892 test_vdivsl_vvsl() {
1893   // CHECK-LABEL: @test_vdivsl_vvsl
1894   // CHECK: call <256 x double> @llvm.ve.vl.vdivsl.vvsl(<256 x double> %{{.*}}, i64 %{{.*}}, i32 256)
1895   vr3 = _vel_vdivsl_vvsl(vr1, v2, 256);
1896 }
1897
1898 void __attribute__((noinline))
1899 test_vdivsl_vvsvl() {
1900   // CHECK-LABEL: @test_vdivsl_vvsvl
1901   // CHECK: call <256 x double> @llvm.ve.vl.vdivsl.vvsvl(<256 x double> %{{.*}}, i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
1902   vr3 = _vel_vdivsl_vvsvl(vr1, v2, vr3, 256);
1903 }
1904
1905 void __attribute__((noinline))
1906 test_vdivsl_vvsmvl() {
1907   // CHECK-LABEL: @test_vdivsl_vvsmvl
1908   // CHECK: call <256 x double> @llvm.ve.vl.vdivsl.vvsmvl(<256 x double> %{{.*}}, i64 %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1909   vr3 = _vel_vdivsl_vvsmvl(vr1, v2, vm1, vr3, 256);
1910 }
1911
1912 void __attribute__((noinline))
1913 test_vcmpul_vvvl() {
1914   // CHECK-LABEL: @test_vcmpul_vvvl
1915   // CHECK: call <256 x double> @llvm.ve.vl.vcmpul.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1916   vr3 = _vel_vcmpul_vvvl(vr1, vr2, 256);
1917 }
1918
1919 void __attribute__((noinline))
1920 test_vcmpul_vvvvl() {
1921   // CHECK-LABEL: @test_vcmpul_vvvvl
1922   // CHECK: call <256 x double> @llvm.ve.vl.vcmpul.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1923   vr3 = _vel_vcmpul_vvvvl(vr1, vr2, vr3, 256);
1924 }
1925
1926 void __attribute__((noinline))
1927 test_vcmpul_vsvl() {
1928   // CHECK-LABEL: @test_vcmpul_vsvl
1929   // CHECK: call <256 x double> @llvm.ve.vl.vcmpul.vsvl(i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
1930   vr3 = _vel_vcmpul_vsvl(v1, vr2, 256);
1931 }
1932
1933 void __attribute__((noinline))
1934 test_vcmpul_vsvvl() {
1935   // CHECK-LABEL: @test_vcmpul_vsvvl
1936   // CHECK: call <256 x double> @llvm.ve.vl.vcmpul.vsvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1937   vr3 = _vel_vcmpul_vsvvl(v1, vr2, vr3, 256);
1938 }
1939
1940 void __attribute__((noinline))
1941 test_vcmpul_vvvmvl() {
1942   // CHECK-LABEL: @test_vcmpul_vvvmvl
1943   // CHECK: call <256 x double> @llvm.ve.vl.vcmpul.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1944   vr3 = _vel_vcmpul_vvvmvl(vr1, vr2, vm1, vr3, 256);
1945 }
1946
1947 void __attribute__((noinline))
1948 test_vcmpul_vsvmvl() {
1949   // CHECK-LABEL: @test_vcmpul_vsvmvl
1950   // CHECK: call <256 x double> @llvm.ve.vl.vcmpul.vsvmvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1951   vr3 = _vel_vcmpul_vsvmvl(v1, vr2, vm1, vr3, 256);
1952 }
1953
1954 void __attribute__((noinline))
1955 test_vcmpuw_vvvl() {
1956   // CHECK-LABEL: @test_vcmpuw_vvvl
1957   // CHECK: call <256 x double> @llvm.ve.vl.vcmpuw.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1958   vr3 = _vel_vcmpuw_vvvl(vr1, vr2, 256);
1959 }
1960
1961 void __attribute__((noinline))
1962 test_vcmpuw_vvvvl() {
1963   // CHECK-LABEL: @test_vcmpuw_vvvvl
1964   // CHECK: call <256 x double> @llvm.ve.vl.vcmpuw.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1965   vr3 = _vel_vcmpuw_vvvvl(vr1, vr2, vr3, 256);
1966 }
1967
1968 void __attribute__((noinline))
1969 test_vcmpuw_vsvl() {
1970   // CHECK-LABEL: @test_vcmpuw_vsvl
1971   // CHECK: call <256 x double> @llvm.ve.vl.vcmpuw.vsvl(i32 %{{.*}}, <256 x double> %{{.*}}, i32 256)
1972   vr3 = _vel_vcmpuw_vsvl(v1, vr2, 256);
1973 }
1974
1975 void __attribute__((noinline))
1976 test_vcmpuw_vsvvl() {
1977   // CHECK-LABEL: @test_vcmpuw_vsvvl
1978   // CHECK: call <256 x double> @llvm.ve.vl.vcmpuw.vsvvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1979   vr3 = _vel_vcmpuw_vsvvl(v1, vr2, vr3, 256);
1980 }
1981
1982 void __attribute__((noinline))
1983 test_vcmpuw_vvvmvl() {
1984   // CHECK-LABEL: @test_vcmpuw_vvvmvl
1985   // CHECK: call <256 x double> @llvm.ve.vl.vcmpuw.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1986   vr3 = _vel_vcmpuw_vvvmvl(vr1, vr2, vm1, vr3, 256);
1987 }
1988
1989 void __attribute__((noinline))
1990 test_vcmpuw_vsvmvl() {
1991   // CHECK-LABEL: @test_vcmpuw_vsvmvl
1992   // CHECK: call <256 x double> @llvm.ve.vl.vcmpuw.vsvmvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
1993   vr3 = _vel_vcmpuw_vsvmvl(v1, vr2, vm1, vr3, 256);
1994 }
1995
1996 void __attribute__((noinline))
1997 test_pvcmpu_vvvl() {
1998   // CHECK-LABEL: @test_pvcmpu_vvvl
1999   // CHECK: call <256 x double> @llvm.ve.vl.pvcmpu.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2000   vr3 = _vel_pvcmpu_vvvl(vr1, vr2, 256);
2001 }
2002
2003 void __attribute__((noinline))
2004 test_pvcmpu_vvvvl() {
2005   // CHECK-LABEL: @test_pvcmpu_vvvvl
2006   // CHECK: call <256 x double> @llvm.ve.vl.pvcmpu.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2007   vr3 = _vel_pvcmpu_vvvvl(vr1, vr2, vr3, 256);
2008 }
2009
2010 void __attribute__((noinline))
2011 test_pvcmpu_vsvl() {
2012   // CHECK-LABEL: @test_pvcmpu_vsvl
2013   // CHECK: call <256 x double> @llvm.ve.vl.pvcmpu.vsvl(i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
2014   vr3 = _vel_pvcmpu_vsvl(v1, vr2, 256);
2015 }
2016
2017 void __attribute__((noinline))
2018 test_pvcmpu_vsvvl() {
2019   // CHECK-LABEL: @test_pvcmpu_vsvvl
2020   // CHECK: call <256 x double> @llvm.ve.vl.pvcmpu.vsvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2021   vr3 = _vel_pvcmpu_vsvvl(v1, vr2, vr3, 256);
2022 }
2023
2024 void __attribute__((noinline))
2025 test_pvcmpu_vvvMvl() {
2026   // CHECK-LABEL: @test_pvcmpu_vvvMvl
2027   // CHECK: call <256 x double> @llvm.ve.vl.pvcmpu.vvvMvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2028   vr3 = _vel_pvcmpu_vvvMvl(vr1, vr2, vm1_512, vr3, 256);
2029 }
2030
2031 void __attribute__((noinline))
2032 test_pvcmpu_vsvMvl() {
2033   // CHECK-LABEL: @test_pvcmpu_vsvMvl
2034   // CHECK: call <256 x double> @llvm.ve.vl.pvcmpu.vsvMvl(i64 %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2035   vr3 = _vel_pvcmpu_vsvMvl(v1, vr2, vm1_512, vr3, 256);
2036 }
2037
2038 void __attribute__((noinline))
2039 test_vcmpswsx_vvvl() {
2040   // CHECK-LABEL: @test_vcmpswsx_vvvl
2041   // CHECK: call <256 x double> @llvm.ve.vl.vcmpswsx.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2042   vr3 = _vel_vcmpswsx_vvvl(vr1, vr2, 256);
2043 }
2044
2045 void __attribute__((noinline))
2046 test_vcmpswsx_vvvvl() {
2047   // CHECK-LABEL: @test_vcmpswsx_vvvvl
2048   // CHECK: call <256 x double> @llvm.ve.vl.vcmpswsx.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2049   vr3 = _vel_vcmpswsx_vvvvl(vr1, vr2, vr3, 256);
2050 }
2051
2052 void __attribute__((noinline))
2053 test_vcmpswsx_vsvl() {
2054   // CHECK-LABEL: @test_vcmpswsx_vsvl
2055   // CHECK: call <256 x double> @llvm.ve.vl.vcmpswsx.vsvl(i32 %{{.*}}, <256 x double> %{{.*}}, i32 256)
2056   vr3 = _vel_vcmpswsx_vsvl(v1, vr2, 256);
2057 }
2058
2059 void __attribute__((noinline))
2060 test_vcmpswsx_vsvvl() {
2061   // CHECK-LABEL: @test_vcmpswsx_vsvvl
2062   // CHECK: call <256 x double> @llvm.ve.vl.vcmpswsx.vsvvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2063   vr3 = _vel_vcmpswsx_vsvvl(v1, vr2, vr3, 256);
2064 }
2065
2066 void __attribute__((noinline))
2067 test_vcmpswsx_vvvmvl() {
2068   // CHECK-LABEL: @test_vcmpswsx_vvvmvl
2069   // CHECK: call <256 x double> @llvm.ve.vl.vcmpswsx.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2070   vr3 = _vel_vcmpswsx_vvvmvl(vr1, vr2, vm1, vr3, 256);
2071 }
2072
2073 void __attribute__((noinline))
2074 test_vcmpswsx_vsvmvl() {
2075   // CHECK-LABEL: @test_vcmpswsx_vsvmvl
2076   // CHECK: call <256 x double> @llvm.ve.vl.vcmpswsx.vsvmvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2077   vr3 = _vel_vcmpswsx_vsvmvl(v1, vr2, vm1, vr3, 256);
2078 }
2079
2080 void __attribute__((noinline))
2081 test_vcmpswzx_vvvl() {
2082   // CHECK-LABEL: @test_vcmpswzx_vvvl
2083   // CHECK: call <256 x double> @llvm.ve.vl.vcmpswzx.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2084   vr3 = _vel_vcmpswzx_vvvl(vr1, vr2, 256);
2085 }
2086
2087 void __attribute__((noinline))
2088 test_vcmpswzx_vvvvl() {
2089   // CHECK-LABEL: @test_vcmpswzx_vvvvl
2090   // CHECK: call <256 x double> @llvm.ve.vl.vcmpswzx.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2091   vr3 = _vel_vcmpswzx_vvvvl(vr1, vr2, vr3, 256);
2092 }
2093
2094 void __attribute__((noinline))
2095 test_vcmpswzx_vsvl() {
2096   // CHECK-LABEL: @test_vcmpswzx_vsvl
2097   // CHECK: call <256 x double> @llvm.ve.vl.vcmpswzx.vsvl(i32 %{{.*}}, <256 x double> %{{.*}}, i32 256)
2098   vr3 = _vel_vcmpswzx_vsvl(v1, vr2, 256);
2099 }
2100
2101 void __attribute__((noinline))
2102 test_vcmpswzx_vsvvl() {
2103   // CHECK-LABEL: @test_vcmpswzx_vsvvl
2104   // CHECK: call <256 x double> @llvm.ve.vl.vcmpswzx.vsvvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2105   vr3 = _vel_vcmpswzx_vsvvl(v1, vr2, vr3, 256);
2106 }
2107
2108 void __attribute__((noinline))
2109 test_vcmpswzx_vvvmvl() {
2110   // CHECK-LABEL: @test_vcmpswzx_vvvmvl
2111   // CHECK: call <256 x double> @llvm.ve.vl.vcmpswzx.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2112   vr3 = _vel_vcmpswzx_vvvmvl(vr1, vr2, vm1, vr3, 256);
2113 }
2114
2115 void __attribute__((noinline))
2116 test_vcmpswzx_vsvmvl() {
2117   // CHECK-LABEL: @test_vcmpswzx_vsvmvl
2118   // CHECK: call <256 x double> @llvm.ve.vl.vcmpswzx.vsvmvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2119   vr3 = _vel_vcmpswzx_vsvmvl(v1, vr2, vm1, vr3, 256);
2120 }
2121
2122 void __attribute__((noinline))
2123 test_pvcmps_vvvl() {
2124   // CHECK-LABEL: @test_pvcmps_vvvl
2125   // CHECK: call <256 x double> @llvm.ve.vl.pvcmps.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2126   vr3 = _vel_pvcmps_vvvl(vr1, vr2, 256);
2127 }
2128
2129 void __attribute__((noinline))
2130 test_pvcmps_vvvvl() {
2131   // CHECK-LABEL: @test_pvcmps_vvvvl
2132   // CHECK: call <256 x double> @llvm.ve.vl.pvcmps.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2133   vr3 = _vel_pvcmps_vvvvl(vr1, vr2, vr3, 256);
2134 }
2135
2136 void __attribute__((noinline))
2137 test_pvcmps_vsvl() {
2138   // CHECK-LABEL: @test_pvcmps_vsvl
2139   // CHECK: call <256 x double> @llvm.ve.vl.pvcmps.vsvl(i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
2140   vr3 = _vel_pvcmps_vsvl(v1, vr2, 256);
2141 }
2142
2143 void __attribute__((noinline))
2144 test_pvcmps_vsvvl() {
2145   // CHECK-LABEL: @test_pvcmps_vsvvl
2146   // CHECK: call <256 x double> @llvm.ve.vl.pvcmps.vsvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2147   vr3 = _vel_pvcmps_vsvvl(v1, vr2, vr3, 256);
2148 }
2149
2150 void __attribute__((noinline))
2151 test_pvcmps_vvvMvl() {
2152   // CHECK-LABEL: @test_pvcmps_vvvMvl
2153   // CHECK: call <256 x double> @llvm.ve.vl.pvcmps.vvvMvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2154   vr3 = _vel_pvcmps_vvvMvl(vr1, vr2, vm1_512, vr3, 256);
2155 }
2156
2157 void __attribute__((noinline))
2158 test_pvcmps_vsvMvl() {
2159   // CHECK-LABEL: @test_pvcmps_vsvMvl
2160   // CHECK: call <256 x double> @llvm.ve.vl.pvcmps.vsvMvl(i64 %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2161   vr3 = _vel_pvcmps_vsvMvl(v1, vr2, vm1_512, vr3, 256);
2162 }
2163
2164 void __attribute__((noinline))
2165 test_vcmpsl_vvvl() {
2166   // CHECK-LABEL: @test_vcmpsl_vvvl
2167   // CHECK: call <256 x double> @llvm.ve.vl.vcmpsl.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2168   vr3 = _vel_vcmpsl_vvvl(vr1, vr2, 256);
2169 }
2170
2171 void __attribute__((noinline))
2172 test_vcmpsl_vvvvl() {
2173   // CHECK-LABEL: @test_vcmpsl_vvvvl
2174   // CHECK: call <256 x double> @llvm.ve.vl.vcmpsl.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2175   vr3 = _vel_vcmpsl_vvvvl(vr1, vr2, vr3, 256);
2176 }
2177
2178 void __attribute__((noinline))
2179 test_vcmpsl_vsvl() {
2180   // CHECK-LABEL: @test_vcmpsl_vsvl
2181   // CHECK: call <256 x double> @llvm.ve.vl.vcmpsl.vsvl(i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
2182   vr3 = _vel_vcmpsl_vsvl(v1, vr2, 256);
2183 }
2184
2185 void __attribute__((noinline))
2186 test_vcmpsl_vsvvl() {
2187   // CHECK-LABEL: @test_vcmpsl_vsvvl
2188   // CHECK: call <256 x double> @llvm.ve.vl.vcmpsl.vsvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2189   vr3 = _vel_vcmpsl_vsvvl(v1, vr2, vr3, 256);
2190 }
2191
2192 void __attribute__((noinline))
2193 test_vcmpsl_vvvmvl() {
2194   // CHECK-LABEL: @test_vcmpsl_vvvmvl
2195   // CHECK: call <256 x double> @llvm.ve.vl.vcmpsl.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2196   vr3 = _vel_vcmpsl_vvvmvl(vr1, vr2, vm1, vr3, 256);
2197 }
2198
2199 void __attribute__((noinline))
2200 test_vcmpsl_vsvmvl() {
2201   // CHECK-LABEL: @test_vcmpsl_vsvmvl
2202   // CHECK: call <256 x double> @llvm.ve.vl.vcmpsl.vsvmvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2203   vr3 = _vel_vcmpsl_vsvmvl(v1, vr2, vm1, vr3, 256);
2204 }
2205
2206 void __attribute__((noinline))
2207 test_vmaxswsx_vvvl() {
2208   // CHECK-LABEL: @test_vmaxswsx_vvvl
2209   // CHECK: call <256 x double> @llvm.ve.vl.vmaxswsx.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2210   vr3 = _vel_vmaxswsx_vvvl(vr1, vr2, 256);
2211 }
2212
2213 void __attribute__((noinline))
2214 test_vmaxswsx_vvvvl() {
2215   // CHECK-LABEL: @test_vmaxswsx_vvvvl
2216   // CHECK: call <256 x double> @llvm.ve.vl.vmaxswsx.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2217   vr3 = _vel_vmaxswsx_vvvvl(vr1, vr2, vr3, 256);
2218 }
2219
2220 void __attribute__((noinline))
2221 test_vmaxswsx_vsvl() {
2222   // CHECK-LABEL: @test_vmaxswsx_vsvl
2223   // CHECK: call <256 x double> @llvm.ve.vl.vmaxswsx.vsvl(i32 %{{.*}}, <256 x double> %{{.*}}, i32 256)
2224   vr3 = _vel_vmaxswsx_vsvl(v1, vr2, 256);
2225 }
2226
2227 void __attribute__((noinline))
2228 test_vmaxswsx_vsvvl() {
2229   // CHECK-LABEL: @test_vmaxswsx_vsvvl
2230   // CHECK: call <256 x double> @llvm.ve.vl.vmaxswsx.vsvvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2231   vr3 = _vel_vmaxswsx_vsvvl(v1, vr2, vr3, 256);
2232 }
2233
2234 void __attribute__((noinline))
2235 test_vmaxswsx_vvvmvl() {
2236   // CHECK-LABEL: @test_vmaxswsx_vvvmvl
2237   // CHECK: call <256 x double> @llvm.ve.vl.vmaxswsx.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2238   vr3 = _vel_vmaxswsx_vvvmvl(vr1, vr2, vm1, vr3, 256);
2239 }
2240
2241 void __attribute__((noinline))
2242 test_vmaxswsx_vsvmvl() {
2243   // CHECK-LABEL: @test_vmaxswsx_vsvmvl
2244   // CHECK: call <256 x double> @llvm.ve.vl.vmaxswsx.vsvmvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2245   vr3 = _vel_vmaxswsx_vsvmvl(v1, vr2, vm1, vr3, 256);
2246 }
2247
2248 void __attribute__((noinline))
2249 test_vmaxswzx_vvvl() {
2250   // CHECK-LABEL: @test_vmaxswzx_vvvl
2251   // CHECK: call <256 x double> @llvm.ve.vl.vmaxswzx.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2252   vr3 = _vel_vmaxswzx_vvvl(vr1, vr2, 256);
2253 }
2254
2255 void __attribute__((noinline))
2256 test_vmaxswzx_vvvvl() {
2257   // CHECK-LABEL: @test_vmaxswzx_vvvvl
2258   // CHECK: call <256 x double> @llvm.ve.vl.vmaxswzx.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2259   vr3 = _vel_vmaxswzx_vvvvl(vr1, vr2, vr3, 256);
2260 }
2261
2262 void __attribute__((noinline))
2263 test_vmaxswzx_vsvl() {
2264   // CHECK-LABEL: @test_vmaxswzx_vsvl
2265   // CHECK: call <256 x double> @llvm.ve.vl.vmaxswzx.vsvl(i32 %{{.*}}, <256 x double> %{{.*}}, i32 256)
2266   vr3 = _vel_vmaxswzx_vsvl(v1, vr2, 256);
2267 }
2268
2269 void __attribute__((noinline))
2270 test_vmaxswzx_vsvvl() {
2271   // CHECK-LABEL: @test_vmaxswzx_vsvvl
2272   // CHECK: call <256 x double> @llvm.ve.vl.vmaxswzx.vsvvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2273   vr3 = _vel_vmaxswzx_vsvvl(v1, vr2, vr3, 256);
2274 }
2275
2276 void __attribute__((noinline))
2277 test_vmaxswzx_vvvmvl() {
2278   // CHECK-LABEL: @test_vmaxswzx_vvvmvl
2279   // CHECK: call <256 x double> @llvm.ve.vl.vmaxswzx.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2280   vr3 = _vel_vmaxswzx_vvvmvl(vr1, vr2, vm1, vr3, 256);
2281 }
2282
2283 void __attribute__((noinline))
2284 test_vmaxswzx_vsvmvl() {
2285   // CHECK-LABEL: @test_vmaxswzx_vsvmvl
2286   // CHECK: call <256 x double> @llvm.ve.vl.vmaxswzx.vsvmvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2287   vr3 = _vel_vmaxswzx_vsvmvl(v1, vr2, vm1, vr3, 256);
2288 }
2289
2290 void __attribute__((noinline))
2291 test_pvmaxs_vvvl() {
2292   // CHECK-LABEL: @test_pvmaxs_vvvl
2293   // CHECK: call <256 x double> @llvm.ve.vl.pvmaxs.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2294   vr3 = _vel_pvmaxs_vvvl(vr1, vr2, 256);
2295 }
2296
2297 void __attribute__((noinline))
2298 test_pvmaxs_vvvvl() {
2299   // CHECK-LABEL: @test_pvmaxs_vvvvl
2300   // CHECK: call <256 x double> @llvm.ve.vl.pvmaxs.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2301   vr3 = _vel_pvmaxs_vvvvl(vr1, vr2, vr3, 256);
2302 }
2303
2304 void __attribute__((noinline))
2305 test_pvmaxs_vsvl() {
2306   // CHECK-LABEL: @test_pvmaxs_vsvl
2307   // CHECK: call <256 x double> @llvm.ve.vl.pvmaxs.vsvl(i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
2308   vr3 = _vel_pvmaxs_vsvl(v1, vr2, 256);
2309 }
2310
2311 void __attribute__((noinline))
2312 test_pvmaxs_vsvvl() {
2313   // CHECK-LABEL: @test_pvmaxs_vsvvl
2314   // CHECK: call <256 x double> @llvm.ve.vl.pvmaxs.vsvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2315   vr3 = _vel_pvmaxs_vsvvl(v1, vr2, vr3, 256);
2316 }
2317
2318 void __attribute__((noinline))
2319 test_pvmaxs_vvvMvl() {
2320   // CHECK-LABEL: @test_pvmaxs_vvvMvl
2321   // CHECK: call <256 x double> @llvm.ve.vl.pvmaxs.vvvMvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2322   vr3 = _vel_pvmaxs_vvvMvl(vr1, vr2, vm1_512, vr3, 256);
2323 }
2324
2325 void __attribute__((noinline))
2326 test_pvmaxs_vsvMvl() {
2327   // CHECK-LABEL: @test_pvmaxs_vsvMvl
2328   // CHECK: call <256 x double> @llvm.ve.vl.pvmaxs.vsvMvl(i64 %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2329   vr3 = _vel_pvmaxs_vsvMvl(v1, vr2, vm1_512, vr3, 256);
2330 }
2331
2332 void __attribute__((noinline))
2333 test_vminswsx_vvvl() {
2334   // CHECK-LABEL: @test_vminswsx_vvvl
2335   // CHECK: call <256 x double> @llvm.ve.vl.vminswsx.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2336   vr3 = _vel_vminswsx_vvvl(vr1, vr2, 256);
2337 }
2338
2339 void __attribute__((noinline))
2340 test_vminswsx_vvvvl() {
2341   // CHECK-LABEL: @test_vminswsx_vvvvl
2342   // CHECK: call <256 x double> @llvm.ve.vl.vminswsx.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2343   vr3 = _vel_vminswsx_vvvvl(vr1, vr2, vr3, 256);
2344 }
2345
2346 void __attribute__((noinline))
2347 test_vminswsx_vsvl() {
2348   // CHECK-LABEL: @test_vminswsx_vsvl
2349   // CHECK: call <256 x double> @llvm.ve.vl.vminswsx.vsvl(i32 %{{.*}}, <256 x double> %{{.*}}, i32 256)
2350   vr3 = _vel_vminswsx_vsvl(v1, vr2, 256);
2351 }
2352
2353 void __attribute__((noinline))
2354 test_vminswsx_vsvvl() {
2355   // CHECK-LABEL: @test_vminswsx_vsvvl
2356   // CHECK: call <256 x double> @llvm.ve.vl.vminswsx.vsvvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2357   vr3 = _vel_vminswsx_vsvvl(v1, vr2, vr3, 256);
2358 }
2359
2360 void __attribute__((noinline))
2361 test_vminswsx_vvvmvl() {
2362   // CHECK-LABEL: @test_vminswsx_vvvmvl
2363   // CHECK: call <256 x double> @llvm.ve.vl.vminswsx.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2364   vr3 = _vel_vminswsx_vvvmvl(vr1, vr2, vm1, vr3, 256);
2365 }
2366
2367 void __attribute__((noinline))
2368 test_vminswsx_vsvmvl() {
2369   // CHECK-LABEL: @test_vminswsx_vsvmvl
2370   // CHECK: call <256 x double> @llvm.ve.vl.vminswsx.vsvmvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2371   vr3 = _vel_vminswsx_vsvmvl(v1, vr2, vm1, vr3, 256);
2372 }
2373
2374 void __attribute__((noinline))
2375 test_vminswzx_vvvl() {
2376   // CHECK-LABEL: @test_vminswzx_vvvl
2377   // CHECK: call <256 x double> @llvm.ve.vl.vminswzx.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2378   vr3 = _vel_vminswzx_vvvl(vr1, vr2, 256);
2379 }
2380
2381 void __attribute__((noinline))
2382 test_vminswzx_vvvvl() {
2383   // CHECK-LABEL: @test_vminswzx_vvvvl
2384   // CHECK: call <256 x double> @llvm.ve.vl.vminswzx.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2385   vr3 = _vel_vminswzx_vvvvl(vr1, vr2, vr3, 256);
2386 }
2387
2388 void __attribute__((noinline))
2389 test_vminswzx_vsvl() {
2390   // CHECK-LABEL: @test_vminswzx_vsvl
2391   // CHECK: call <256 x double> @llvm.ve.vl.vminswzx.vsvl(i32 %{{.*}}, <256 x double> %{{.*}}, i32 256)
2392   vr3 = _vel_vminswzx_vsvl(v1, vr2, 256);
2393 }
2394
2395 void __attribute__((noinline))
2396 test_vminswzx_vsvvl() {
2397   // CHECK-LABEL: @test_vminswzx_vsvvl
2398   // CHECK: call <256 x double> @llvm.ve.vl.vminswzx.vsvvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2399   vr3 = _vel_vminswzx_vsvvl(v1, vr2, vr3, 256);
2400 }
2401
2402 void __attribute__((noinline))
2403 test_vminswzx_vvvmvl() {
2404   // CHECK-LABEL: @test_vminswzx_vvvmvl
2405   // CHECK: call <256 x double> @llvm.ve.vl.vminswzx.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2406   vr3 = _vel_vminswzx_vvvmvl(vr1, vr2, vm1, vr3, 256);
2407 }
2408
2409 void __attribute__((noinline))
2410 test_vminswzx_vsvmvl() {
2411   // CHECK-LABEL: @test_vminswzx_vsvmvl
2412   // CHECK: call <256 x double> @llvm.ve.vl.vminswzx.vsvmvl(i32 %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2413   vr3 = _vel_vminswzx_vsvmvl(v1, vr2, vm1, vr3, 256);
2414 }
2415
2416 void __attribute__((noinline))
2417 test_pvmins_vvvl() {
2418   // CHECK-LABEL: @test_pvmins_vvvl
2419   // CHECK: call <256 x double> @llvm.ve.vl.pvmins.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2420   vr3 = _vel_pvmins_vvvl(vr1, vr2, 256);
2421 }
2422
2423 void __attribute__((noinline))
2424 test_pvmins_vvvvl() {
2425   // CHECK-LABEL: @test_pvmins_vvvvl
2426   // CHECK: call <256 x double> @llvm.ve.vl.pvmins.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2427   vr3 = _vel_pvmins_vvvvl(vr1, vr2, vr3, 256);
2428 }
2429
2430 void __attribute__((noinline))
2431 test_pvmins_vsvl() {
2432   // CHECK-LABEL: @test_pvmins_vsvl
2433   // CHECK: call <256 x double> @llvm.ve.vl.pvmins.vsvl(i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
2434   vr3 = _vel_pvmins_vsvl(v1, vr2, 256);
2435 }
2436
2437 void __attribute__((noinline))
2438 test_pvmins_vsvvl() {
2439   // CHECK-LABEL: @test_pvmins_vsvvl
2440   // CHECK: call <256 x double> @llvm.ve.vl.pvmins.vsvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2441   vr3 = _vel_pvmins_vsvvl(v1, vr2, vr3, 256);
2442 }
2443
2444 void __attribute__((noinline))
2445 test_pvmins_vvvMvl() {
2446   // CHECK-LABEL: @test_pvmins_vvvMvl
2447   // CHECK: call <256 x double> @llvm.ve.vl.pvmins.vvvMvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2448   vr3 = _vel_pvmins_vvvMvl(vr1, vr2, vm1_512, vr3, 256);
2449 }
2450
2451 void __attribute__((noinline))
2452 test_pvmins_vsvMvl() {
2453   // CHECK-LABEL: @test_pvmins_vsvMvl
2454   // CHECK: call <256 x double> @llvm.ve.vl.pvmins.vsvMvl(i64 %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2455   vr3 = _vel_pvmins_vsvMvl(v1, vr2, vm1_512, vr3, 256);
2456 }
2457
2458 void __attribute__((noinline))
2459 test_vmaxsl_vvvl() {
2460   // CHECK-LABEL: @test_vmaxsl_vvvl
2461   // CHECK: call <256 x double> @llvm.ve.vl.vmaxsl.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2462   vr3 = _vel_vmaxsl_vvvl(vr1, vr2, 256);
2463 }
2464
2465 void __attribute__((noinline))
2466 test_vmaxsl_vvvvl() {
2467   // CHECK-LABEL: @test_vmaxsl_vvvvl
2468   // CHECK: call <256 x double> @llvm.ve.vl.vmaxsl.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2469   vr3 = _vel_vmaxsl_vvvvl(vr1, vr2, vr3, 256);
2470 }
2471
2472 void __attribute__((noinline))
2473 test_vmaxsl_vsvl() {
2474   // CHECK-LABEL: @test_vmaxsl_vsvl
2475   // CHECK: call <256 x double> @llvm.ve.vl.vmaxsl.vsvl(i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
2476   vr3 = _vel_vmaxsl_vsvl(v1, vr2, 256);
2477 }
2478
2479 void __attribute__((noinline))
2480 test_vmaxsl_vsvvl() {
2481   // CHECK-LABEL: @test_vmaxsl_vsvvl
2482   // CHECK: call <256 x double> @llvm.ve.vl.vmaxsl.vsvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2483   vr3 = _vel_vmaxsl_vsvvl(v1, vr2, vr3, 256);
2484 }
2485
2486 void __attribute__((noinline))
2487 test_vmaxsl_vvvmvl() {
2488   // CHECK-LABEL: @test_vmaxsl_vvvmvl
2489   // CHECK: call <256 x double> @llvm.ve.vl.vmaxsl.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2490   vr3 = _vel_vmaxsl_vvvmvl(vr1, vr2, vm1, vr3, 256);
2491 }
2492
2493 void __attribute__((noinline))
2494 test_vmaxsl_vsvmvl() {
2495   // CHECK-LABEL: @test_vmaxsl_vsvmvl
2496   // CHECK: call <256 x double> @llvm.ve.vl.vmaxsl.vsvmvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2497   vr3 = _vel_vmaxsl_vsvmvl(v1, vr2, vm1, vr3, 256);
2498 }
2499
2500 void __attribute__((noinline))
2501 test_vminsl_vvvl() {
2502   // CHECK-LABEL: @test_vminsl_vvvl
2503   // CHECK: call <256 x double> @llvm.ve.vl.vminsl.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2504   vr3 = _vel_vminsl_vvvl(vr1, vr2, 256);
2505 }
2506
2507 void __attribute__((noinline))
2508 test_vminsl_vvvvl() {
2509   // CHECK-LABEL: @test_vminsl_vvvvl
2510   // CHECK: call <256 x double> @llvm.ve.vl.vminsl.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2511   vr3 = _vel_vminsl_vvvvl(vr1, vr2, vr3, 256);
2512 }
2513
2514 void __attribute__((noinline))
2515 test_vminsl_vsvl() {
2516   // CHECK-LABEL: @test_vminsl_vsvl
2517   // CHECK: call <256 x double> @llvm.ve.vl.vminsl.vsvl(i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
2518   vr3 = _vel_vminsl_vsvl(v1, vr2, 256);
2519 }
2520
2521 void __attribute__((noinline))
2522 test_vminsl_vsvvl() {
2523   // CHECK-LABEL: @test_vminsl_vsvvl
2524   // CHECK: call <256 x double> @llvm.ve.vl.vminsl.vsvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2525   vr3 = _vel_vminsl_vsvvl(v1, vr2, vr3, 256);
2526 }
2527
2528 void __attribute__((noinline))
2529 test_vminsl_vvvmvl() {
2530   // CHECK-LABEL: @test_vminsl_vvvmvl
2531   // CHECK: call <256 x double> @llvm.ve.vl.vminsl.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2532   vr3 = _vel_vminsl_vvvmvl(vr1, vr2, vm1, vr3, 256);
2533 }
2534
2535 void __attribute__((noinline))
2536 test_vminsl_vsvmvl() {
2537   // CHECK-LABEL: @test_vminsl_vsvmvl
2538   // CHECK: call <256 x double> @llvm.ve.vl.vminsl.vsvmvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2539   vr3 = _vel_vminsl_vsvmvl(v1, vr2, vm1, vr3, 256);
2540 }
2541
2542 void __attribute__((noinline))
2543 test_vand_vvvl() {
2544   // CHECK-LABEL: @test_vand_vvvl
2545   // CHECK: call <256 x double> @llvm.ve.vl.vand.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2546   vr3 = _vel_vand_vvvl(vr1, vr2, 256);
2547 }
2548
2549 void __attribute__((noinline))
2550 test_vand_vvvvl() {
2551   // CHECK-LABEL: @test_vand_vvvvl
2552   // CHECK: call <256 x double> @llvm.ve.vl.vand.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2553   vr3 = _vel_vand_vvvvl(vr1, vr2, vr3, 256);
2554 }
2555
2556 void __attribute__((noinline))
2557 test_vand_vsvl() {
2558   // CHECK-LABEL: @test_vand_vsvl
2559   // CHECK: call <256 x double> @llvm.ve.vl.vand.vsvl(i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
2560   vr3 = _vel_vand_vsvl(v1, vr2, 256);
2561 }
2562
2563 void __attribute__((noinline))
2564 test_vand_vsvvl() {
2565   // CHECK-LABEL: @test_vand_vsvvl
2566   // CHECK: call <256 x double> @llvm.ve.vl.vand.vsvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2567   vr3 = _vel_vand_vsvvl(v1, vr2, vr3, 256);
2568 }
2569
2570 void __attribute__((noinline))
2571 test_vand_vvvmvl() {
2572   // CHECK-LABEL: @test_vand_vvvmvl
2573   // CHECK: call <256 x double> @llvm.ve.vl.vand.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2574   vr3 = _vel_vand_vvvmvl(vr1, vr2, vm1, vr3, 256);
2575 }
2576
2577 void __attribute__((noinline))
2578 test_vand_vsvmvl() {
2579   // CHECK-LABEL: @test_vand_vsvmvl
2580   // CHECK: call <256 x double> @llvm.ve.vl.vand.vsvmvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2581   vr3 = _vel_vand_vsvmvl(v1, vr2, vm1, vr3, 256);
2582 }
2583
2584 void __attribute__((noinline))
2585 test_pvand_vvvl() {
2586   // CHECK-LABEL: @test_pvand_vvvl
2587   // CHECK: call <256 x double> @llvm.ve.vl.pvand.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2588   vr3 = _vel_pvand_vvvl(vr1, vr2, 256);
2589 }
2590
2591 void __attribute__((noinline))
2592 test_pvand_vvvvl() {
2593   // CHECK-LABEL: @test_pvand_vvvvl
2594   // CHECK: call <256 x double> @llvm.ve.vl.pvand.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2595   vr3 = _vel_pvand_vvvvl(vr1, vr2, vr3, 256);
2596 }
2597
2598 void __attribute__((noinline))
2599 test_pvand_vsvl() {
2600   // CHECK-LABEL: @test_pvand_vsvl
2601   // CHECK: call <256 x double> @llvm.ve.vl.pvand.vsvl(i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
2602   vr3 = _vel_pvand_vsvl(v1, vr2, 256);
2603 }
2604
2605 void __attribute__((noinline))
2606 test_pvand_vsvvl() {
2607   // CHECK-LABEL: @test_pvand_vsvvl
2608   // CHECK: call <256 x double> @llvm.ve.vl.pvand.vsvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2609   vr3 = _vel_pvand_vsvvl(v1, vr2, vr3, 256);
2610 }
2611
2612 void __attribute__((noinline))
2613 test_pvand_vvvMvl() {
2614   // CHECK-LABEL: @test_pvand_vvvMvl
2615   // CHECK: call <256 x double> @llvm.ve.vl.pvand.vvvMvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2616   vr3 = _vel_pvand_vvvMvl(vr1, vr2, vm1_512, vr3, 256);
2617 }
2618
2619 void __attribute__((noinline))
2620 test_pvand_vsvMvl() {
2621   // CHECK-LABEL: @test_pvand_vsvMvl
2622   // CHECK: call <256 x double> @llvm.ve.vl.pvand.vsvMvl(i64 %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2623   vr3 = _vel_pvand_vsvMvl(v1, vr2, vm1_512, vr3, 256);
2624 }
2625
2626 void __attribute__((noinline))
2627 test_vor_vvvl() {
2628   // CHECK-LABEL: @test_vor_vvvl
2629   // CHECK: call <256 x double> @llvm.ve.vl.vor.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2630   vr3 = _vel_vor_vvvl(vr1, vr2, 256);
2631 }
2632
2633 void __attribute__((noinline))
2634 test_vor_vvvvl() {
2635   // CHECK-LABEL: @test_vor_vvvvl
2636   // CHECK: call <256 x double> @llvm.ve.vl.vor.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2637   vr3 = _vel_vor_vvvvl(vr1, vr2, vr3, 256);
2638 }
2639
2640 void __attribute__((noinline))
2641 test_vor_vsvl() {
2642   // CHECK-LABEL: @test_vor_vsvl
2643   // CHECK: call <256 x double> @llvm.ve.vl.vor.vsvl(i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
2644   vr3 = _vel_vor_vsvl(v1, vr2, 256);
2645 }
2646
2647 void __attribute__((noinline))
2648 test_vor_vsvvl() {
2649   // CHECK-LABEL: @test_vor_vsvvl
2650   // CHECK: call <256 x double> @llvm.ve.vl.vor.vsvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2651   vr3 = _vel_vor_vsvvl(v1, vr2, vr3, 256);
2652 }
2653
2654 void __attribute__((noinline))
2655 test_vor_vvvmvl() {
2656   // CHECK-LABEL: @test_vor_vvvmvl
2657   // CHECK: call <256 x double> @llvm.ve.vl.vor.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2658   vr3 = _vel_vor_vvvmvl(vr1, vr2, vm1, vr3, 256);
2659 }
2660
2661 void __attribute__((noinline))
2662 test_vor_vsvmvl() {
2663   // CHECK-LABEL: @test_vor_vsvmvl
2664   // CHECK: call <256 x double> @llvm.ve.vl.vor.vsvmvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2665   vr3 = _vel_vor_vsvmvl(v1, vr2, vm1, vr3, 256);
2666 }
2667
2668 void __attribute__((noinline))
2669 test_pvor_vvvl() {
2670   // CHECK-LABEL: @test_pvor_vvvl
2671   // CHECK: call <256 x double> @llvm.ve.vl.pvor.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2672   vr3 = _vel_pvor_vvvl(vr1, vr2, 256);
2673 }
2674
2675 void __attribute__((noinline))
2676 test_pvor_vvvvl() {
2677   // CHECK-LABEL: @test_pvor_vvvvl
2678   // CHECK: call <256 x double> @llvm.ve.vl.pvor.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2679   vr3 = _vel_pvor_vvvvl(vr1, vr2, vr3, 256);
2680 }
2681
2682 void __attribute__((noinline))
2683 test_pvor_vsvl() {
2684   // CHECK-LABEL: @test_pvor_vsvl
2685   // CHECK: call <256 x double> @llvm.ve.vl.pvor.vsvl(i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
2686   vr3 = _vel_pvor_vsvl(v1, vr2, 256);
2687 }
2688
2689 void __attribute__((noinline))
2690 test_pvor_vsvvl() {
2691   // CHECK-LABEL: @test_pvor_vsvvl
2692   // CHECK: call <256 x double> @llvm.ve.vl.pvor.vsvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2693   vr3 = _vel_pvor_vsvvl(v1, vr2, vr3, 256);
2694 }
2695
2696 void __attribute__((noinline))
2697 test_pvor_vvvMvl() {
2698   // CHECK-LABEL: @test_pvor_vvvMvl
2699   // CHECK: call <256 x double> @llvm.ve.vl.pvor.vvvMvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2700   vr3 = _vel_pvor_vvvMvl(vr1, vr2, vm1_512, vr3, 256);
2701 }
2702
2703 void __attribute__((noinline))
2704 test_pvor_vsvMvl() {
2705   // CHECK-LABEL: @test_pvor_vsvMvl
2706   // CHECK: call <256 x double> @llvm.ve.vl.pvor.vsvMvl(i64 %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2707   vr3 = _vel_pvor_vsvMvl(v1, vr2, vm1_512, vr3, 256);
2708 }
2709
2710 void __attribute__((noinline))
2711 test_vxor_vvvl() {
2712   // CHECK-LABEL: @test_vxor_vvvl
2713   // CHECK: call <256 x double> @llvm.ve.vl.vxor.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2714   vr3 = _vel_vxor_vvvl(vr1, vr2, 256);
2715 }
2716
2717 void __attribute__((noinline))
2718 test_vxor_vvvvl() {
2719   // CHECK-LABEL: @test_vxor_vvvvl
2720   // CHECK: call <256 x double> @llvm.ve.vl.vxor.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2721   vr3 = _vel_vxor_vvvvl(vr1, vr2, vr3, 256);
2722 }
2723
2724 void __attribute__((noinline))
2725 test_vxor_vsvl() {
2726   // CHECK-LABEL: @test_vxor_vsvl
2727   // CHECK: call <256 x double> @llvm.ve.vl.vxor.vsvl(i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
2728   vr3 = _vel_vxor_vsvl(v1, vr2, 256);
2729 }
2730
2731 void __attribute__((noinline))
2732 test_vxor_vsvvl() {
2733   // CHECK-LABEL: @test_vxor_vsvvl
2734   // CHECK: call <256 x double> @llvm.ve.vl.vxor.vsvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2735   vr3 = _vel_vxor_vsvvl(v1, vr2, vr3, 256);
2736 }
2737
2738 void __attribute__((noinline))
2739 test_vxor_vvvmvl() {
2740   // CHECK-LABEL: @test_vxor_vvvmvl
2741   // CHECK: call <256 x double> @llvm.ve.vl.vxor.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2742   vr3 = _vel_vxor_vvvmvl(vr1, vr2, vm1, vr3, 256);
2743 }
2744
2745 void __attribute__((noinline))
2746 test_vxor_vsvmvl() {
2747   // CHECK-LABEL: @test_vxor_vsvmvl
2748   // CHECK: call <256 x double> @llvm.ve.vl.vxor.vsvmvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2749   vr3 = _vel_vxor_vsvmvl(v1, vr2, vm1, vr3, 256);
2750 }
2751
2752 void __attribute__((noinline))
2753 test_pvxor_vvvl() {
2754   // CHECK-LABEL: @test_pvxor_vvvl
2755   // CHECK: call <256 x double> @llvm.ve.vl.pvxor.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2756   vr3 = _vel_pvxor_vvvl(vr1, vr2, 256);
2757 }
2758
2759 void __attribute__((noinline))
2760 test_pvxor_vvvvl() {
2761   // CHECK-LABEL: @test_pvxor_vvvvl
2762   // CHECK: call <256 x double> @llvm.ve.vl.pvxor.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2763   vr3 = _vel_pvxor_vvvvl(vr1, vr2, vr3, 256);
2764 }
2765
2766 void __attribute__((noinline))
2767 test_pvxor_vsvl() {
2768   // CHECK-LABEL: @test_pvxor_vsvl
2769   // CHECK: call <256 x double> @llvm.ve.vl.pvxor.vsvl(i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
2770   vr3 = _vel_pvxor_vsvl(v1, vr2, 256);
2771 }
2772
2773 void __attribute__((noinline))
2774 test_pvxor_vsvvl() {
2775   // CHECK-LABEL: @test_pvxor_vsvvl
2776   // CHECK: call <256 x double> @llvm.ve.vl.pvxor.vsvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2777   vr3 = _vel_pvxor_vsvvl(v1, vr2, vr3, 256);
2778 }
2779
2780 void __attribute__((noinline))
2781 test_pvxor_vvvMvl() {
2782   // CHECK-LABEL: @test_pvxor_vvvMvl
2783   // CHECK: call <256 x double> @llvm.ve.vl.pvxor.vvvMvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2784   vr3 = _vel_pvxor_vvvMvl(vr1, vr2, vm1_512, vr3, 256);
2785 }
2786
2787 void __attribute__((noinline))
2788 test_pvxor_vsvMvl() {
2789   // CHECK-LABEL: @test_pvxor_vsvMvl
2790   // CHECK: call <256 x double> @llvm.ve.vl.pvxor.vsvMvl(i64 %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2791   vr3 = _vel_pvxor_vsvMvl(v1, vr2, vm1_512, vr3, 256);
2792 }
2793
2794 void __attribute__((noinline))
2795 test_veqv_vvvl() {
2796   // CHECK-LABEL: @test_veqv_vvvl
2797   // CHECK: call <256 x double> @llvm.ve.vl.veqv.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2798   vr3 = _vel_veqv_vvvl(vr1, vr2, 256);
2799 }
2800
2801 void __attribute__((noinline))
2802 test_veqv_vvvvl() {
2803   // CHECK-LABEL: @test_veqv_vvvvl
2804   // CHECK: call <256 x double> @llvm.ve.vl.veqv.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2805   vr3 = _vel_veqv_vvvvl(vr1, vr2, vr3, 256);
2806 }
2807
2808 void __attribute__((noinline))
2809 test_veqv_vsvl() {
2810   // CHECK-LABEL: @test_veqv_vsvl
2811   // CHECK: call <256 x double> @llvm.ve.vl.veqv.vsvl(i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
2812   vr3 = _vel_veqv_vsvl(v1, vr2, 256);
2813 }
2814
2815 void __attribute__((noinline))
2816 test_veqv_vsvvl() {
2817   // CHECK-LABEL: @test_veqv_vsvvl
2818   // CHECK: call <256 x double> @llvm.ve.vl.veqv.vsvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2819   vr3 = _vel_veqv_vsvvl(v1, vr2, vr3, 256);
2820 }
2821
2822 void __attribute__((noinline))
2823 test_veqv_vvvmvl() {
2824   // CHECK-LABEL: @test_veqv_vvvmvl
2825   // CHECK: call <256 x double> @llvm.ve.vl.veqv.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2826   vr3 = _vel_veqv_vvvmvl(vr1, vr2, vm1, vr3, 256);
2827 }
2828
2829 void __attribute__((noinline))
2830 test_veqv_vsvmvl() {
2831   // CHECK-LABEL: @test_veqv_vsvmvl
2832   // CHECK: call <256 x double> @llvm.ve.vl.veqv.vsvmvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2833   vr3 = _vel_veqv_vsvmvl(v1, vr2, vm1, vr3, 256);
2834 }
2835
2836 void __attribute__((noinline))
2837 test_pveqv_vvvl() {
2838   // CHECK-LABEL: @test_pveqv_vvvl
2839   // CHECK: call <256 x double> @llvm.ve.vl.pveqv.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2840   vr3 = _vel_pveqv_vvvl(vr1, vr2, 256);
2841 }
2842
2843 void __attribute__((noinline))
2844 test_pveqv_vvvvl() {
2845   // CHECK-LABEL: @test_pveqv_vvvvl
2846   // CHECK: call <256 x double> @llvm.ve.vl.pveqv.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2847   vr3 = _vel_pveqv_vvvvl(vr1, vr2, vr3, 256);
2848 }
2849
2850 void __attribute__((noinline))
2851 test_pveqv_vsvl() {
2852   // CHECK-LABEL: @test_pveqv_vsvl
2853   // CHECK: call <256 x double> @llvm.ve.vl.pveqv.vsvl(i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
2854   vr3 = _vel_pveqv_vsvl(v1, vr2, 256);
2855 }
2856
2857 void __attribute__((noinline))
2858 test_pveqv_vsvvl() {
2859   // CHECK-LABEL: @test_pveqv_vsvvl
2860   // CHECK: call <256 x double> @llvm.ve.vl.pveqv.vsvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2861   vr3 = _vel_pveqv_vsvvl(v1, vr2, vr3, 256);
2862 }
2863
2864 void __attribute__((noinline))
2865 test_pveqv_vvvMvl() {
2866   // CHECK-LABEL: @test_pveqv_vvvMvl
2867   // CHECK: call <256 x double> @llvm.ve.vl.pveqv.vvvMvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2868   vr3 = _vel_pveqv_vvvMvl(vr1, vr2, vm1_512, vr3, 256);
2869 }
2870
2871 void __attribute__((noinline))
2872 test_pveqv_vsvMvl() {
2873   // CHECK-LABEL: @test_pveqv_vsvMvl
2874   // CHECK: call <256 x double> @llvm.ve.vl.pveqv.vsvMvl(i64 %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2875   vr3 = _vel_pveqv_vsvMvl(v1, vr2, vm1_512, vr3, 256);
2876 }
2877
2878 void __attribute__((noinline))
2879 test_vldz_vvl() {
2880   // CHECK-LABEL: @test_vldz_vvl
2881   // CHECK: call <256 x double> @llvm.ve.vl.vldz.vvl(<256 x double> %{{.*}}, i32 256)
2882   vr3 = _vel_vldz_vvl(vr1, 256);
2883 }
2884
2885 void __attribute__((noinline))
2886 test_vldz_vvvl() {
2887   // CHECK-LABEL: @test_vldz_vvvl
2888   // CHECK: call <256 x double> @llvm.ve.vl.vldz.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2889   vr3 = _vel_vldz_vvvl(vr1, vr2, 256);
2890 }
2891
2892 void __attribute__((noinline))
2893 test_vldz_vvmvl() {
2894   // CHECK-LABEL: @test_vldz_vvmvl
2895   // CHECK: call <256 x double> @llvm.ve.vl.vldz.vvmvl(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2896   vr3 = _vel_vldz_vvmvl(vr1, vm1, vr2, 256);
2897 }
2898
2899 void __attribute__((noinline))
2900 test_pvldzlo_vvl() {
2901   // CHECK-LABEL: @test_pvldzlo_vvl
2902   // CHECK: call <256 x double> @llvm.ve.vl.pvldzlo.vvl(<256 x double> %{{.*}}, i32 256)
2903   vr3 = _vel_pvldzlo_vvl(vr1, 256);
2904 }
2905
2906 void __attribute__((noinline))
2907 test_pvldzlo_vvvl() {
2908   // CHECK-LABEL: @test_pvldzlo_vvvl
2909   // CHECK: call <256 x double> @llvm.ve.vl.pvldzlo.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2910   vr3 = _vel_pvldzlo_vvvl(vr1, vr2, 256);
2911 }
2912
2913 void __attribute__((noinline))
2914 test_pvldzlo_vvmvl() {
2915   // CHECK-LABEL: @test_pvldzlo_vvmvl
2916   // CHECK: call <256 x double> @llvm.ve.vl.pvldzlo.vvmvl(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2917   vr3 = _vel_pvldzlo_vvmvl(vr1, vm1, vr2, 256);
2918 }
2919
2920 void __attribute__((noinline))
2921 test_pvldzup_vvl() {
2922   // CHECK-LABEL: @test_pvldzup_vvl
2923   // CHECK: call <256 x double> @llvm.ve.vl.pvldzup.vvl(<256 x double> %{{.*}}, i32 256)
2924   vr3 = _vel_pvldzup_vvl(vr1, 256);
2925 }
2926
2927 void __attribute__((noinline))
2928 test_pvldzup_vvvl() {
2929   // CHECK-LABEL: @test_pvldzup_vvvl
2930   // CHECK: call <256 x double> @llvm.ve.vl.pvldzup.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2931   vr3 = _vel_pvldzup_vvvl(vr1, vr2, 256);
2932 }
2933
2934 void __attribute__((noinline))
2935 test_pvldzup_vvmvl() {
2936   // CHECK-LABEL: @test_pvldzup_vvmvl
2937   // CHECK: call <256 x double> @llvm.ve.vl.pvldzup.vvmvl(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2938   vr3 = _vel_pvldzup_vvmvl(vr1, vm1, vr2, 256);
2939 }
2940
2941 void __attribute__((noinline))
2942 test_pvldz_vvl() {
2943   // CHECK-LABEL: @test_pvldz_vvl
2944   // CHECK: call <256 x double> @llvm.ve.vl.pvldz.vvl(<256 x double> %{{.*}}, i32 256)
2945   vr3 = _vel_pvldz_vvl(vr1, 256);
2946 }
2947
2948 void __attribute__((noinline))
2949 test_pvldz_vvvl() {
2950   // CHECK-LABEL: @test_pvldz_vvvl
2951   // CHECK: call <256 x double> @llvm.ve.vl.pvldz.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2952   vr3 = _vel_pvldz_vvvl(vr1, vr2, 256);
2953 }
2954
2955 void __attribute__((noinline))
2956 test_pvldz_vvMvl() {
2957   // CHECK-LABEL: @test_pvldz_vvMvl
2958   // CHECK: call <256 x double> @llvm.ve.vl.pvldz.vvMvl(<256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2959   vr3 = _vel_pvldz_vvMvl(vr1, vm1_512, vr2, 256);
2960 }
2961
2962 void __attribute__((noinline))
2963 test_vpcnt_vvl() {
2964   // CHECK-LABEL: @test_vpcnt_vvl
2965   // CHECK: call <256 x double> @llvm.ve.vl.vpcnt.vvl(<256 x double> %{{.*}}, i32 256)
2966   vr3 = _vel_vpcnt_vvl(vr1, 256);
2967 }
2968
2969 void __attribute__((noinline))
2970 test_vpcnt_vvvl() {
2971   // CHECK-LABEL: @test_vpcnt_vvvl
2972   // CHECK: call <256 x double> @llvm.ve.vl.vpcnt.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2973   vr3 = _vel_vpcnt_vvvl(vr1, vr2, 256);
2974 }
2975
2976 void __attribute__((noinline))
2977 test_vpcnt_vvmvl() {
2978   // CHECK-LABEL: @test_vpcnt_vvmvl
2979   // CHECK: call <256 x double> @llvm.ve.vl.vpcnt.vvmvl(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2980   vr3 = _vel_vpcnt_vvmvl(vr1, vm1, vr2, 256);
2981 }
2982
2983 void __attribute__((noinline))
2984 test_pvpcntlo_vvl() {
2985   // CHECK-LABEL: @test_pvpcntlo_vvl
2986   // CHECK: call <256 x double> @llvm.ve.vl.pvpcntlo.vvl(<256 x double> %{{.*}}, i32 256)
2987   vr3 = _vel_pvpcntlo_vvl(vr1, 256);
2988 }
2989
2990 void __attribute__((noinline))
2991 test_pvpcntlo_vvvl() {
2992   // CHECK-LABEL: @test_pvpcntlo_vvvl
2993   // CHECK: call <256 x double> @llvm.ve.vl.pvpcntlo.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
2994   vr3 = _vel_pvpcntlo_vvvl(vr1, vr2, 256);
2995 }
2996
2997 void __attribute__((noinline))
2998 test_pvpcntlo_vvmvl() {
2999   // CHECK-LABEL: @test_pvpcntlo_vvmvl
3000   // CHECK: call <256 x double> @llvm.ve.vl.pvpcntlo.vvmvl(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3001   vr3 = _vel_pvpcntlo_vvmvl(vr1, vm1, vr2, 256);
3002 }
3003
3004 void __attribute__((noinline))
3005 test_pvpcntup_vvl() {
3006   // CHECK-LABEL: @test_pvpcntup_vvl
3007   // CHECK: call <256 x double> @llvm.ve.vl.pvpcntup.vvl(<256 x double> %{{.*}}, i32 256)
3008   vr3 = _vel_pvpcntup_vvl(vr1, 256);
3009 }
3010
3011 void __attribute__((noinline))
3012 test_pvpcntup_vvvl() {
3013   // CHECK-LABEL: @test_pvpcntup_vvvl
3014   // CHECK: call <256 x double> @llvm.ve.vl.pvpcntup.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3015   vr3 = _vel_pvpcntup_vvvl(vr1, vr2, 256);
3016 }
3017
3018 void __attribute__((noinline))
3019 test_pvpcntup_vvmvl() {
3020   // CHECK-LABEL: @test_pvpcntup_vvmvl
3021   // CHECK: call <256 x double> @llvm.ve.vl.pvpcntup.vvmvl(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3022   vr3 = _vel_pvpcntup_vvmvl(vr1, vm1, vr2, 256);
3023 }
3024
3025 void __attribute__((noinline))
3026 test_pvpcnt_vvl() {
3027   // CHECK-LABEL: @test_pvpcnt_vvl
3028   // CHECK: call <256 x double> @llvm.ve.vl.pvpcnt.vvl(<256 x double> %{{.*}}, i32 256)
3029   vr3 = _vel_pvpcnt_vvl(vr1, 256);
3030 }
3031
3032 void __attribute__((noinline))
3033 test_pvpcnt_vvvl() {
3034   // CHECK-LABEL: @test_pvpcnt_vvvl
3035   // CHECK: call <256 x double> @llvm.ve.vl.pvpcnt.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3036   vr3 = _vel_pvpcnt_vvvl(vr1, vr2, 256);
3037 }
3038
3039 void __attribute__((noinline))
3040 test_pvpcnt_vvMvl() {
3041   // CHECK-LABEL: @test_pvpcnt_vvMvl
3042   // CHECK: call <256 x double> @llvm.ve.vl.pvpcnt.vvMvl(<256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3043   vr3 = _vel_pvpcnt_vvMvl(vr1, vm1_512, vr2, 256);
3044 }
3045
3046 void __attribute__((noinline))
3047 test_vbrv_vvl() {
3048   // CHECK-LABEL: @test_vbrv_vvl
3049   // CHECK: call <256 x double> @llvm.ve.vl.vbrv.vvl(<256 x double> %{{.*}}, i32 256)
3050   vr3 = _vel_vbrv_vvl(vr1, 256);
3051 }
3052
3053 void __attribute__((noinline))
3054 test_vbrv_vvvl() {
3055   // CHECK-LABEL: @test_vbrv_vvvl
3056   // CHECK: call <256 x double> @llvm.ve.vl.vbrv.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3057   vr3 = _vel_vbrv_vvvl(vr1, vr2, 256);
3058 }
3059
3060 void __attribute__((noinline))
3061 test_vbrv_vvmvl() {
3062   // CHECK-LABEL: @test_vbrv_vvmvl
3063   // CHECK: call <256 x double> @llvm.ve.vl.vbrv.vvmvl(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3064   vr3 = _vel_vbrv_vvmvl(vr1, vm1, vr2, 256);
3065 }
3066
3067 void __attribute__((noinline))
3068 test_pvbrvlo_vvl() {
3069   // CHECK-LABEL: @test_pvbrvlo_vvl
3070   // CHECK: call <256 x double> @llvm.ve.vl.pvbrvlo.vvl(<256 x double> %{{.*}}, i32 256)
3071   vr3 = _vel_pvbrvlo_vvl(vr1, 256);
3072 }
3073
3074 void __attribute__((noinline))
3075 test_pvbrvlo_vvvl() {
3076   // CHECK-LABEL: @test_pvbrvlo_vvvl
3077   // CHECK: call <256 x double> @llvm.ve.vl.pvbrvlo.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3078   vr3 = _vel_pvbrvlo_vvvl(vr1, vr2, 256);
3079 }
3080
3081 void __attribute__((noinline))
3082 test_pvbrvlo_vvmvl() {
3083   // CHECK-LABEL: @test_pvbrvlo_vvmvl
3084   // CHECK: call <256 x double> @llvm.ve.vl.pvbrvlo.vvmvl(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3085   vr3 = _vel_pvbrvlo_vvmvl(vr1, vm1, vr2, 256);
3086 }
3087
3088 void __attribute__((noinline))
3089 test_pvbrvup_vvl() {
3090   // CHECK-LABEL: @test_pvbrvup_vvl
3091   // CHECK: call <256 x double> @llvm.ve.vl.pvbrvup.vvl(<256 x double> %{{.*}}, i32 256)
3092   vr3 = _vel_pvbrvup_vvl(vr1, 256);
3093 }
3094
3095 void __attribute__((noinline))
3096 test_pvbrvup_vvvl() {
3097   // CHECK-LABEL: @test_pvbrvup_vvvl
3098   // CHECK: call <256 x double> @llvm.ve.vl.pvbrvup.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3099   vr3 = _vel_pvbrvup_vvvl(vr1, vr2, 256);
3100 }
3101
3102 void __attribute__((noinline))
3103 test_pvbrvup_vvmvl() {
3104   // CHECK-LABEL: @test_pvbrvup_vvmvl
3105   // CHECK: call <256 x double> @llvm.ve.vl.pvbrvup.vvmvl(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3106   vr3 = _vel_pvbrvup_vvmvl(vr1, vm1, vr2, 256);
3107 }
3108
3109 void __attribute__((noinline))
3110 test_pvbrv_vvl() {
3111   // CHECK-LABEL: @test_pvbrv_vvl
3112   // CHECK: call <256 x double> @llvm.ve.vl.pvbrv.vvl(<256 x double> %{{.*}}, i32 256)
3113   vr3 = _vel_pvbrv_vvl(vr1, 256);
3114 }
3115
3116 void __attribute__((noinline))
3117 test_pvbrv_vvvl() {
3118   // CHECK-LABEL: @test_pvbrv_vvvl
3119   // CHECK: call <256 x double> @llvm.ve.vl.pvbrv.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3120   vr3 = _vel_pvbrv_vvvl(vr1, vr2, 256);
3121 }
3122
3123 void __attribute__((noinline))
3124 test_pvbrv_vvMvl() {
3125   // CHECK-LABEL: @test_pvbrv_vvMvl
3126   // CHECK: call <256 x double> @llvm.ve.vl.pvbrv.vvMvl(<256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3127   vr3 = _vel_pvbrv_vvMvl(vr1, vm1_512, vr2, 256);
3128 }
3129
3130 void __attribute__((noinline))
3131 test_vseq_vl() {
3132   // CHECK-LABEL: @test_vseq_vl
3133   // CHECK: call <256 x double> @llvm.ve.vl.vseq.vl(i32 256)
3134   vr1 = _vel_vseq_vl(256);
3135 }
3136
3137 void __attribute__((noinline))
3138 test_vseq_vvl() {
3139   // CHECK-LABEL: @test_vseq_vvl
3140   // CHECK: call <256 x double> @llvm.ve.vl.vseq.vvl(<256 x double> %{{.*}}, i32 256)
3141   vr1 = _vel_vseq_vvl(vr1, 256);
3142 }
3143
3144 void __attribute__((noinline))
3145 test_pvseqlo_vl() {
3146   // CHECK-LABEL: @test_pvseqlo_vl
3147   // CHECK: call <256 x double> @llvm.ve.vl.pvseqlo.vl(i32 256)
3148   vr1 = _vel_pvseqlo_vl(256);
3149 }
3150
3151 void __attribute__((noinline))
3152 test_pvseqlo_vvl() {
3153   // CHECK-LABEL: @test_pvseqlo_vvl
3154   // CHECK: call <256 x double> @llvm.ve.vl.pvseqlo.vvl(<256 x double> %{{.*}}, i32 256)
3155   vr1 = _vel_pvseqlo_vvl(vr1, 256);
3156 }
3157
3158 void __attribute__((noinline))
3159 test_pvsequp_vl() {
3160   // CHECK-LABEL: @test_pvsequp_vl
3161   // CHECK: call <256 x double> @llvm.ve.vl.pvsequp.vl(i32 256)
3162   vr1 = _vel_pvsequp_vl(256);
3163 }
3164
3165 void __attribute__((noinline))
3166 test_pvsequp_vvl() {
3167   // CHECK-LABEL: @test_pvsequp_vvl
3168   // CHECK: call <256 x double> @llvm.ve.vl.pvsequp.vvl(<256 x double> %{{.*}}, i32 256)
3169   vr1 = _vel_pvsequp_vvl(vr1, 256);
3170 }
3171
3172 void __attribute__((noinline))
3173 test_pvseq_vl() {
3174   // CHECK-LABEL: @test_pvseq_vl
3175   // CHECK: call <256 x double> @llvm.ve.vl.pvseq.vl(i32 256)
3176   vr1 = _vel_pvseq_vl(256);
3177 }
3178
3179 void __attribute__((noinline))
3180 test_pvseq_vvl() {
3181   // CHECK-LABEL: @test_pvseq_vvl
3182   // CHECK: call <256 x double> @llvm.ve.vl.pvseq.vvl(<256 x double> %{{.*}}, i32 256)
3183   vr1 = _vel_pvseq_vvl(vr1, 256);
3184 }
3185
3186 void __attribute__((noinline))
3187 test_vsll_vvvl() {
3188   // CHECK-LABEL: @test_vsll_vvvl
3189   // CHECK: call <256 x double> @llvm.ve.vl.vsll.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3190   vr3 = _vel_vsll_vvvl(vr1, vr2, 256);
3191 }
3192
3193 void __attribute__((noinline))
3194 test_vsll_vvvvl() {
3195   // CHECK-LABEL: @test_vsll_vvvvl
3196   // CHECK: call <256 x double> @llvm.ve.vl.vsll.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3197   vr3 = _vel_vsll_vvvvl(vr1, vr2, vr3, 256);
3198 }
3199
3200 void __attribute__((noinline))
3201 test_vsll_vvsl() {
3202   // CHECK-LABEL: @test_vsll_vvsl
3203   // CHECK: call <256 x double> @llvm.ve.vl.vsll.vvsl(<256 x double> %{{.*}}, i64 %{{.*}}, i32 256)
3204   vr3 = _vel_vsll_vvsl(vr1, v2, 256);
3205 }
3206
3207 void __attribute__((noinline))
3208 test_vsll_vvsvl() {
3209   // CHECK-LABEL: @test_vsll_vvsvl
3210   // CHECK: call <256 x double> @llvm.ve.vl.vsll.vvsvl(<256 x double> %{{.*}}, i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
3211   vr3 = _vel_vsll_vvsvl(vr1, v2, vr3, 256);
3212 }
3213
3214 void __attribute__((noinline))
3215 test_vsll_vvvmvl() {
3216   // CHECK-LABEL: @test_vsll_vvvmvl
3217   // CHECK: call <256 x double> @llvm.ve.vl.vsll.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3218   vr3 = _vel_vsll_vvvmvl(vr1, vr2, vm1, vr3, 256);
3219 }
3220
3221 void __attribute__((noinline))
3222 test_vsll_vvsmvl() {
3223   // CHECK-LABEL: @test_vsll_vvsmvl
3224   // CHECK: call <256 x double> @llvm.ve.vl.vsll.vvsmvl(<256 x double> %{{.*}}, i64 %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3225   vr3 = _vel_vsll_vvsmvl(vr1, v2, vm1, vr3, 256);
3226 }
3227
3228 void __attribute__((noinline))
3229 test_pvsll_vvvl() {
3230   // CHECK-LABEL: @test_pvsll_vvvl
3231   // CHECK: call <256 x double> @llvm.ve.vl.pvsll.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3232   vr3 = _vel_pvsll_vvvl(vr1, vr2, 256);
3233 }
3234
3235 void __attribute__((noinline))
3236 test_pvsll_vvvvl() {
3237   // CHECK-LABEL: @test_pvsll_vvvvl
3238   // CHECK: call <256 x double> @llvm.ve.vl.pvsll.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3239   vr3 = _vel_pvsll_vvvvl(vr1, vr2, vr3, 256);
3240 }
3241
3242 void __attribute__((noinline))
3243 test_pvsll_vvsl() {
3244   // CHECK-LABEL: @test_pvsll_vvsl
3245   // CHECK: call <256 x double> @llvm.ve.vl.pvsll.vvsl(<256 x double> %{{.*}}, i64 %{{.*}}, i32 256)
3246   vr3 = _vel_pvsll_vvsl(vr1, v2, 256);
3247 }
3248
3249 void __attribute__((noinline))
3250 test_pvsll_vvsvl() {
3251   // CHECK-LABEL: @test_pvsll_vvsvl
3252   // CHECK: call <256 x double> @llvm.ve.vl.pvsll.vvsvl(<256 x double> %{{.*}}, i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
3253   vr3 = _vel_pvsll_vvsvl(vr1, v2, vr3, 256);
3254 }
3255
3256 void __attribute__((noinline))
3257 test_pvsll_vvvMvl() {
3258   // CHECK-LABEL: @test_pvsll_vvvMvl
3259   // CHECK: call <256 x double> @llvm.ve.vl.pvsll.vvvMvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3260   vr3 = _vel_pvsll_vvvMvl(vr1, vr2, vm1_512, vr3, 256);
3261 }
3262
3263 void __attribute__((noinline))
3264 test_pvsll_vvsMvl() {
3265   // CHECK-LABEL: @test_pvsll_vvsMvl
3266   // CHECK: call <256 x double> @llvm.ve.vl.pvsll.vvsMvl(<256 x double> %{{.*}}, i64 %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3267   vr3 = _vel_pvsll_vvsMvl(vr1, v2, vm1_512, vr3, 256);
3268 }
3269
3270 void __attribute__((noinline))
3271 test_vsrl_vvvl() {
3272   // CHECK-LABEL: @test_vsrl_vvvl
3273   // CHECK: call <256 x double> @llvm.ve.vl.vsrl.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3274   vr3 = _vel_vsrl_vvvl(vr1, vr2, 256);
3275 }
3276
3277 void __attribute__((noinline))
3278 test_vsrl_vvvvl() {
3279   // CHECK-LABEL: @test_vsrl_vvvvl
3280   // CHECK: call <256 x double> @llvm.ve.vl.vsrl.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3281   vr3 = _vel_vsrl_vvvvl(vr1, vr2, vr3, 256);
3282 }
3283
3284 void __attribute__((noinline))
3285 test_vsrl_vvsl() {
3286   // CHECK-LABEL: @test_vsrl_vvsl
3287   // CHECK: call <256 x double> @llvm.ve.vl.vsrl.vvsl(<256 x double> %{{.*}}, i64 %{{.*}}, i32 256)
3288   vr3 = _vel_vsrl_vvsl(vr1, v2, 256);
3289 }
3290
3291 void __attribute__((noinline))
3292 test_vsrl_vvsvl() {
3293   // CHECK-LABEL: @test_vsrl_vvsvl
3294   // CHECK: call <256 x double> @llvm.ve.vl.vsrl.vvsvl(<256 x double> %{{.*}}, i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
3295   vr3 = _vel_vsrl_vvsvl(vr1, v2, vr3, 256);
3296 }
3297
3298 void __attribute__((noinline))
3299 test_vsrl_vvvmvl() {
3300   // CHECK-LABEL: @test_vsrl_vvvmvl
3301   // CHECK: call <256 x double> @llvm.ve.vl.vsrl.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3302   vr3 = _vel_vsrl_vvvmvl(vr1, vr2, vm1, vr3, 256);
3303 }
3304
3305 void __attribute__((noinline))
3306 test_vsrl_vvsmvl() {
3307   // CHECK-LABEL: @test_vsrl_vvsmvl
3308   // CHECK: call <256 x double> @llvm.ve.vl.vsrl.vvsmvl(<256 x double> %{{.*}}, i64 %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3309   vr3 = _vel_vsrl_vvsmvl(vr1, v2, vm1, vr3, 256);
3310 }
3311
3312 void __attribute__((noinline))
3313 test_pvsrl_vvvl() {
3314   // CHECK-LABEL: @test_pvsrl_vvvl
3315   // CHECK: call <256 x double> @llvm.ve.vl.pvsrl.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3316   vr3 = _vel_pvsrl_vvvl(vr1, vr2, 256);
3317 }
3318
3319 void __attribute__((noinline))
3320 test_pvsrl_vvvvl() {
3321   // CHECK-LABEL: @test_pvsrl_vvvvl
3322   // CHECK: call <256 x double> @llvm.ve.vl.pvsrl.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3323   vr3 = _vel_pvsrl_vvvvl(vr1, vr2, vr3, 256);
3324 }
3325
3326 void __attribute__((noinline))
3327 test_pvsrl_vvsl() {
3328   // CHECK-LABEL: @test_pvsrl_vvsl
3329   // CHECK: call <256 x double> @llvm.ve.vl.pvsrl.vvsl(<256 x double> %{{.*}}, i64 %{{.*}}, i32 256)
3330   vr3 = _vel_pvsrl_vvsl(vr1, v2, 256);
3331 }
3332
3333 void __attribute__((noinline))
3334 test_pvsrl_vvsvl() {
3335   // CHECK-LABEL: @test_pvsrl_vvsvl
3336   // CHECK: call <256 x double> @llvm.ve.vl.pvsrl.vvsvl(<256 x double> %{{.*}}, i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
3337   vr3 = _vel_pvsrl_vvsvl(vr1, v2, vr3, 256);
3338 }
3339
3340 void __attribute__((noinline))
3341 test_pvsrl_vvvMvl() {
3342   // CHECK-LABEL: @test_pvsrl_vvvMvl
3343   // CHECK: call <256 x double> @llvm.ve.vl.pvsrl.vvvMvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3344   vr3 = _vel_pvsrl_vvvMvl(vr1, vr2, vm1_512, vr3, 256);
3345 }
3346
3347 void __attribute__((noinline))
3348 test_pvsrl_vvsMvl() {
3349   // CHECK-LABEL: @test_pvsrl_vvsMvl
3350   // CHECK: call <256 x double> @llvm.ve.vl.pvsrl.vvsMvl(<256 x double> %{{.*}}, i64 %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3351   vr3 = _vel_pvsrl_vvsMvl(vr1, v2, vm1_512, vr3, 256);
3352 }
3353
3354 void __attribute__((noinline))
3355 test_vslawsx_vvvl() {
3356   // CHECK-LABEL: @test_vslawsx_vvvl
3357   // CHECK: call <256 x double> @llvm.ve.vl.vslawsx.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3358   vr3 = _vel_vslawsx_vvvl(vr1, vr2, 256);
3359 }
3360
3361 void __attribute__((noinline))
3362 test_vslawsx_vvvvl() {
3363   // CHECK-LABEL: @test_vslawsx_vvvvl
3364   // CHECK: call <256 x double> @llvm.ve.vl.vslawsx.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3365   vr3 = _vel_vslawsx_vvvvl(vr1, vr2, vr3, 256);
3366 }
3367
3368 void __attribute__((noinline))
3369 test_vslawsx_vvsl() {
3370   // CHECK-LABEL: @test_vslawsx_vvsl
3371   // CHECK: call <256 x double> @llvm.ve.vl.vslawsx.vvsl(<256 x double> %{{.*}}, i32 %{{.*}}, i32 256)
3372   vr3 = _vel_vslawsx_vvsl(vr1, v2, 256);
3373 }
3374
3375 void __attribute__((noinline))
3376 test_vslawsx_vvsvl() {
3377   // CHECK-LABEL: @test_vslawsx_vvsvl
3378   // CHECK: call <256 x double> @llvm.ve.vl.vslawsx.vvsvl(<256 x double> %{{.*}}, i32 %{{.*}}, <256 x double> %{{.*}}, i32 256)
3379   vr3 = _vel_vslawsx_vvsvl(vr1, v2, vr3, 256);
3380 }
3381
3382 void __attribute__((noinline))
3383 test_vslawsx_vvvmvl() {
3384   // CHECK-LABEL: @test_vslawsx_vvvmvl
3385   // CHECK: call <256 x double> @llvm.ve.vl.vslawsx.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3386   vr3 = _vel_vslawsx_vvvmvl(vr1, vr2, vm1, vr3, 256);
3387 }
3388
3389 void __attribute__((noinline))
3390 test_vslawsx_vvsmvl() {
3391   // CHECK-LABEL: @test_vslawsx_vvsmvl
3392   // CHECK: call <256 x double> @llvm.ve.vl.vslawsx.vvsmvl(<256 x double> %{{.*}}, i32 %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3393   vr3 = _vel_vslawsx_vvsmvl(vr1, v2, vm1, vr3, 256);
3394 }
3395
3396 void __attribute__((noinline))
3397 test_vslawzx_vvvl() {
3398   // CHECK-LABEL: @test_vslawzx_vvvl
3399   // CHECK: call <256 x double> @llvm.ve.vl.vslawzx.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3400   vr3 = _vel_vslawzx_vvvl(vr1, vr2, 256);
3401 }
3402
3403 void __attribute__((noinline))
3404 test_vslawzx_vvvvl() {
3405   // CHECK-LABEL: @test_vslawzx_vvvvl
3406   // CHECK: call <256 x double> @llvm.ve.vl.vslawzx.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3407   vr3 = _vel_vslawzx_vvvvl(vr1, vr2, vr3, 256);
3408 }
3409
3410 void __attribute__((noinline))
3411 test_vslawzx_vvsl() {
3412   // CHECK-LABEL: @test_vslawzx_vvsl
3413   // CHECK: call <256 x double> @llvm.ve.vl.vslawzx.vvsl(<256 x double> %{{.*}}, i32 %{{.*}}, i32 256)
3414   vr3 = _vel_vslawzx_vvsl(vr1, v2, 256);
3415 }
3416
3417 void __attribute__((noinline))
3418 test_vslawzx_vvsvl() {
3419   // CHECK-LABEL: @test_vslawzx_vvsvl
3420   // CHECK: call <256 x double> @llvm.ve.vl.vslawzx.vvsvl(<256 x double> %{{.*}}, i32 %{{.*}}, <256 x double> %{{.*}}, i32 256)
3421   vr3 = _vel_vslawzx_vvsvl(vr1, v2, vr3, 256);
3422 }
3423
3424 void __attribute__((noinline))
3425 test_vslawzx_vvvmvl() {
3426   // CHECK-LABEL: @test_vslawzx_vvvmvl
3427   // CHECK: call <256 x double> @llvm.ve.vl.vslawzx.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3428   vr3 = _vel_vslawzx_vvvmvl(vr1, vr2, vm1, vr3, 256);
3429 }
3430
3431 void __attribute__((noinline))
3432 test_vslawzx_vvsmvl() {
3433   // CHECK-LABEL: @test_vslawzx_vvsmvl
3434   // CHECK: call <256 x double> @llvm.ve.vl.vslawzx.vvsmvl(<256 x double> %{{.*}}, i32 %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3435   vr3 = _vel_vslawzx_vvsmvl(vr1, v2, vm1, vr3, 256);
3436 }
3437
3438 void __attribute__((noinline))
3439 test_pvsla_vvvl() {
3440   // CHECK-LABEL: @test_pvsla_vvvl
3441   // CHECK: call <256 x double> @llvm.ve.vl.pvsla.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3442   vr3 = _vel_pvsla_vvvl(vr1, vr2, 256);
3443 }
3444
3445 void __attribute__((noinline))
3446 test_pvsla_vvvvl() {
3447   // CHECK-LABEL: @test_pvsla_vvvvl
3448   // CHECK: call <256 x double> @llvm.ve.vl.pvsla.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3449   vr3 = _vel_pvsla_vvvvl(vr1, vr2, vr3, 256);
3450 }
3451
3452 void __attribute__((noinline))
3453 test_pvsla_vvsl() {
3454   // CHECK-LABEL: @test_pvsla_vvsl
3455   // CHECK: call <256 x double> @llvm.ve.vl.pvsla.vvsl(<256 x double> %{{.*}}, i64 %{{.*}}, i32 256)
3456   vr3 = _vel_pvsla_vvsl(vr1, v2, 256);
3457 }
3458
3459 void __attribute__((noinline))
3460 test_pvsla_vvsvl() {
3461   // CHECK-LABEL: @test_pvsla_vvsvl
3462   // CHECK: call <256 x double> @llvm.ve.vl.pvsla.vvsvl(<256 x double> %{{.*}}, i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
3463   vr3 = _vel_pvsla_vvsvl(vr1, v2, vr3, 256);
3464 }
3465
3466 void __attribute__((noinline))
3467 test_pvsla_vvvMvl() {
3468   // CHECK-LABEL: @test_pvsla_vvvMvl
3469   // CHECK: call <256 x double> @llvm.ve.vl.pvsla.vvvMvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3470   vr3 = _vel_pvsla_vvvMvl(vr1, vr2, vm1_512, vr3, 256);
3471 }
3472
3473 void __attribute__((noinline))
3474 test_pvsla_vvsMvl() {
3475   // CHECK-LABEL: @test_pvsla_vvsMvl
3476   // CHECK: call <256 x double> @llvm.ve.vl.pvsla.vvsMvl(<256 x double> %{{.*}}, i64 %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3477   vr3 = _vel_pvsla_vvsMvl(vr1, v2, vm1_512, vr3, 256);
3478 }
3479
3480 void __attribute__((noinline))
3481 test_vslal_vvvl() {
3482   // CHECK-LABEL: @test_vslal_vvvl
3483   // CHECK: call <256 x double> @llvm.ve.vl.vslal.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3484   vr3 = _vel_vslal_vvvl(vr1, vr2, 256);
3485 }
3486
3487 void __attribute__((noinline))
3488 test_vslal_vvvvl() {
3489   // CHECK-LABEL: @test_vslal_vvvvl
3490   // CHECK: call <256 x double> @llvm.ve.vl.vslal.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3491   vr3 = _vel_vslal_vvvvl(vr1, vr2, vr3, 256);
3492 }
3493
3494 void __attribute__((noinline))
3495 test_vslal_vvsl() {
3496   // CHECK-LABEL: @test_vslal_vvsl
3497   // CHECK: call <256 x double> @llvm.ve.vl.vslal.vvsl(<256 x double> %{{.*}}, i64 %{{.*}}, i32 256)
3498   vr3 = _vel_vslal_vvsl(vr1, v2, 256);
3499 }
3500
3501 void __attribute__((noinline))
3502 test_vslal_vvsvl() {
3503   // CHECK-LABEL: @test_vslal_vvsvl
3504   // CHECK: call <256 x double> @llvm.ve.vl.vslal.vvsvl(<256 x double> %{{.*}}, i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
3505   vr3 = _vel_vslal_vvsvl(vr1, v2, vr3, 256);
3506 }
3507
3508 void __attribute__((noinline))
3509 test_vslal_vvvmvl() {
3510   // CHECK-LABEL: @test_vslal_vvvmvl
3511   // CHECK: call <256 x double> @llvm.ve.vl.vslal.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3512   vr3 = _vel_vslal_vvvmvl(vr1, vr2, vm1, vr3, 256);
3513 }
3514
3515 void __attribute__((noinline))
3516 test_vslal_vvsmvl() {
3517   // CHECK-LABEL: @test_vslal_vvsmvl
3518   // CHECK: call <256 x double> @llvm.ve.vl.vslal.vvsmvl(<256 x double> %{{.*}}, i64 %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3519   vr3 = _vel_vslal_vvsmvl(vr1, v2, vm1, vr3, 256);
3520 }
3521
3522 void __attribute__((noinline))
3523 test_vsrawsx_vvvl() {
3524   // CHECK-LABEL: @test_vsrawsx_vvvl
3525   // CHECK: call <256 x double> @llvm.ve.vl.vsrawsx.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3526   vr3 = _vel_vsrawsx_vvvl(vr1, vr2, 256);
3527 }
3528
3529 void __attribute__((noinline))
3530 test_vsrawsx_vvvvl() {
3531   // CHECK-LABEL: @test_vsrawsx_vvvvl
3532   // CHECK: call <256 x double> @llvm.ve.vl.vsrawsx.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3533   vr3 = _vel_vsrawsx_vvvvl(vr1, vr2, vr3, 256);
3534 }
3535
3536 void __attribute__((noinline))
3537 test_vsrawsx_vvsl() {
3538   // CHECK-LABEL: @test_vsrawsx_vvsl
3539   // CHECK: call <256 x double> @llvm.ve.vl.vsrawsx.vvsl(<256 x double> %{{.*}}, i32 %{{.*}}, i32 256)
3540   vr3 = _vel_vsrawsx_vvsl(vr1, v2, 256);
3541 }
3542
3543 void __attribute__((noinline))
3544 test_vsrawsx_vvsvl() {
3545   // CHECK-LABEL: @test_vsrawsx_vvsvl
3546   // CHECK: call <256 x double> @llvm.ve.vl.vsrawsx.vvsvl(<256 x double> %{{.*}}, i32 %{{.*}}, <256 x double> %{{.*}}, i32 256)
3547   vr3 = _vel_vsrawsx_vvsvl(vr1, v2, vr3, 256);
3548 }
3549
3550 void __attribute__((noinline))
3551 test_vsrawsx_vvvmvl() {
3552   // CHECK-LABEL: @test_vsrawsx_vvvmvl
3553   // CHECK: call <256 x double> @llvm.ve.vl.vsrawsx.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3554   vr3 = _vel_vsrawsx_vvvmvl(vr1, vr2, vm1, vr3, 256);
3555 }
3556
3557 void __attribute__((noinline))
3558 test_vsrawsx_vvsmvl() {
3559   // CHECK-LABEL: @test_vsrawsx_vvsmvl
3560   // CHECK: call <256 x double> @llvm.ve.vl.vsrawsx.vvsmvl(<256 x double> %{{.*}}, i32 %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3561   vr3 = _vel_vsrawsx_vvsmvl(vr1, v2, vm1, vr3, 256);
3562 }
3563
3564 void __attribute__((noinline))
3565 test_vsrawzx_vvvl() {
3566   // CHECK-LABEL: @test_vsrawzx_vvvl
3567   // CHECK: call <256 x double> @llvm.ve.vl.vsrawzx.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3568   vr3 = _vel_vsrawzx_vvvl(vr1, vr2, 256);
3569 }
3570
3571 void __attribute__((noinline))
3572 test_vsrawzx_vvvvl() {
3573   // CHECK-LABEL: @test_vsrawzx_vvvvl
3574   // CHECK: call <256 x double> @llvm.ve.vl.vsrawzx.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3575   vr3 = _vel_vsrawzx_vvvvl(vr1, vr2, vr3, 256);
3576 }
3577
3578 void __attribute__((noinline))
3579 test_vsrawzx_vvsl() {
3580   // CHECK-LABEL: @test_vsrawzx_vvsl
3581   // CHECK: call <256 x double> @llvm.ve.vl.vsrawzx.vvsl(<256 x double> %{{.*}}, i32 %{{.*}}, i32 256)
3582   vr3 = _vel_vsrawzx_vvsl(vr1, v2, 256);
3583 }
3584
3585 void __attribute__((noinline))
3586 test_vsrawzx_vvsvl() {
3587   // CHECK-LABEL: @test_vsrawzx_vvsvl
3588   // CHECK: call <256 x double> @llvm.ve.vl.vsrawzx.vvsvl(<256 x double> %{{.*}}, i32 %{{.*}}, <256 x double> %{{.*}}, i32 256)
3589   vr3 = _vel_vsrawzx_vvsvl(vr1, v2, vr3, 256);
3590 }
3591
3592 void __attribute__((noinline))
3593 test_vsrawzx_vvvmvl() {
3594   // CHECK-LABEL: @test_vsrawzx_vvvmvl
3595   // CHECK: call <256 x double> @llvm.ve.vl.vsrawzx.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3596   vr3 = _vel_vsrawzx_vvvmvl(vr1, vr2, vm1, vr3, 256);
3597 }
3598
3599 void __attribute__((noinline))
3600 test_vsrawzx_vvsmvl() {
3601   // CHECK-LABEL: @test_vsrawzx_vvsmvl
3602   // CHECK: call <256 x double> @llvm.ve.vl.vsrawzx.vvsmvl(<256 x double> %{{.*}}, i32 %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3603   vr3 = _vel_vsrawzx_vvsmvl(vr1, v2, vm1, vr3, 256);
3604 }
3605
3606 void __attribute__((noinline))
3607 test_pvsra_vvvl() {
3608   // CHECK-LABEL: @test_pvsra_vvvl
3609   // CHECK: call <256 x double> @llvm.ve.vl.pvsra.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3610   vr3 = _vel_pvsra_vvvl(vr1, vr2, 256);
3611 }
3612
3613 void __attribute__((noinline))
3614 test_pvsra_vvvvl() {
3615   // CHECK-LABEL: @test_pvsra_vvvvl
3616   // CHECK: call <256 x double> @llvm.ve.vl.pvsra.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3617   vr3 = _vel_pvsra_vvvvl(vr1, vr2, vr3, 256);
3618 }
3619
3620 void __attribute__((noinline))
3621 test_pvsra_vvsl() {
3622   // CHECK-LABEL: @test_pvsra_vvsl
3623   // CHECK: call <256 x double> @llvm.ve.vl.pvsra.vvsl(<256 x double> %{{.*}}, i64 %{{.*}}, i32 256)
3624   vr3 = _vel_pvsra_vvsl(vr1, v2, 256);
3625 }
3626
3627 void __attribute__((noinline))
3628 test_pvsra_vvsvl() {
3629   // CHECK-LABEL: @test_pvsra_vvsvl
3630   // CHECK: call <256 x double> @llvm.ve.vl.pvsra.vvsvl(<256 x double> %{{.*}}, i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
3631   vr3 = _vel_pvsra_vvsvl(vr1, v2, vr3, 256);
3632 }
3633
3634 void __attribute__((noinline))
3635 test_pvsra_vvvMvl() {
3636   // CHECK-LABEL: @test_pvsra_vvvMvl
3637   // CHECK: call <256 x double> @llvm.ve.vl.pvsra.vvvMvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3638   vr3 = _vel_pvsra_vvvMvl(vr1, vr2, vm1_512, vr3, 256);
3639 }
3640
3641 void __attribute__((noinline))
3642 test_pvsra_vvsMvl() {
3643   // CHECK-LABEL: @test_pvsra_vvsMvl
3644   // CHECK: call <256 x double> @llvm.ve.vl.pvsra.vvsMvl(<256 x double> %{{.*}}, i64 %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3645   vr3 = _vel_pvsra_vvsMvl(vr1, v2, vm1_512, vr3, 256);
3646 }
3647
3648 void __attribute__((noinline))
3649 test_vsral_vvvl() {
3650   // CHECK-LABEL: @test_vsral_vvvl
3651   // CHECK: call <256 x double> @llvm.ve.vl.vsral.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3652   vr3 = _vel_vsral_vvvl(vr1, vr2, 256);
3653 }
3654
3655 void __attribute__((noinline))
3656 test_vsral_vvvvl() {
3657   // CHECK-LABEL: @test_vsral_vvvvl
3658   // CHECK: call <256 x double> @llvm.ve.vl.vsral.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3659   vr3 = _vel_vsral_vvvvl(vr1, vr2, vr3, 256);
3660 }
3661
3662 void __attribute__((noinline))
3663 test_vsral_vvsl() {
3664   // CHECK-LABEL: @test_vsral_vvsl
3665   // CHECK: call <256 x double> @llvm.ve.vl.vsral.vvsl(<256 x double> %{{.*}}, i64 %{{.*}}, i32 256)
3666   vr3 = _vel_vsral_vvsl(vr1, v2, 256);
3667 }
3668
3669 void __attribute__((noinline))
3670 test_vsral_vvsvl() {
3671   // CHECK-LABEL: @test_vsral_vvsvl
3672   // CHECK: call <256 x double> @llvm.ve.vl.vsral.vvsvl(<256 x double> %{{.*}}, i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
3673   vr3 = _vel_vsral_vvsvl(vr1, v2, vr3, 256);
3674 }
3675
3676 void __attribute__((noinline))
3677 test_vsral_vvvmvl() {
3678   // CHECK-LABEL: @test_vsral_vvvmvl
3679   // CHECK: call <256 x double> @llvm.ve.vl.vsral.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3680   vr3 = _vel_vsral_vvvmvl(vr1, vr2, vm1, vr3, 256);
3681 }
3682
3683 void __attribute__((noinline))
3684 test_vsral_vvsmvl() {
3685   // CHECK-LABEL: @test_vsral_vvsmvl
3686   // CHECK: call <256 x double> @llvm.ve.vl.vsral.vvsmvl(<256 x double> %{{.*}}, i64 %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3687   vr3 = _vel_vsral_vvsmvl(vr1, v2, vm1, vr3, 256);
3688 }
3689
3690 void __attribute__((noinline))
3691 test_vsfa_vvssl() {
3692   // CHECK-LABEL: @test_vsfa_vvssl
3693   // CHECK: call <256 x double> @llvm.ve.vl.vsfa.vvssl(<256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, i32 256)
3694   vr3 = _vel_vsfa_vvssl(vr1, v1, v2, 256);
3695 }
3696
3697 void __attribute__((noinline))
3698 test_vsfa_vvssvl() {
3699   // CHECK-LABEL: @test_vsfa_vvssvl
3700   // CHECK: call <256 x double> @llvm.ve.vl.vsfa.vvssvl(<256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
3701   vr3 = _vel_vsfa_vvssvl(vr1, v1, v2, vr3, 256);
3702 }
3703
3704 void __attribute__((noinline))
3705 test_vsfa_vvssmvl() {
3706   // CHECK-LABEL: @test_vsfa_vvssmvl
3707   // CHECK: call <256 x double> @llvm.ve.vl.vsfa.vvssmvl(<256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3708   vr3 = _vel_vsfa_vvssmvl(vr1, v1, v2, vm1, vr3, 256);
3709 }
3710
3711 void __attribute__((noinline))
3712 test_vfaddd_vvvl() {
3713   // CHECK-LABEL: @test_vfaddd_vvvl
3714   // CHECK: call <256 x double> @llvm.ve.vl.vfaddd.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3715   vr3 = _vel_vfaddd_vvvl(vr1, vr2, 256);
3716 }
3717
3718 void __attribute__((noinline))
3719 test_vfaddd_vvvvl() {
3720   // CHECK-LABEL: @test_vfaddd_vvvvl
3721   // CHECK: call <256 x double> @llvm.ve.vl.vfaddd.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3722   vr3 = _vel_vfaddd_vvvvl(vr1, vr2, vr3, 256);
3723 }
3724
3725 void __attribute__((noinline))
3726 test_vfaddd_vsvl() {
3727   // CHECK-LABEL: @test_vfaddd_vsvl
3728   // CHECK: call <256 x double> @llvm.ve.vl.vfaddd.vsvl(double %{{.*}}, <256 x double> %{{.*}}, i32 256)
3729   vr3 = _vel_vfaddd_vsvl(vd1, vr2, 256);
3730 }
3731
3732 void __attribute__((noinline))
3733 test_vfaddd_vsvvl() {
3734   // CHECK-LABEL: @test_vfaddd_vsvvl
3735   // CHECK: call <256 x double> @llvm.ve.vl.vfaddd.vsvvl(double %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3736   vr3 = _vel_vfaddd_vsvvl(vd1, vr2, vr3, 256);
3737 }
3738
3739 void __attribute__((noinline))
3740 test_vfaddd_vvvmvl() {
3741   // CHECK-LABEL: @test_vfaddd_vvvmvl
3742   // CHECK: call <256 x double> @llvm.ve.vl.vfaddd.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3743   vr3 = _vel_vfaddd_vvvmvl(vr1, vr2, vm1, vr3, 256);
3744 }
3745
3746 void __attribute__((noinline))
3747 test_vfaddd_vsvmvl() {
3748   // CHECK-LABEL: @test_vfaddd_vsvmvl
3749   // CHECK: call <256 x double> @llvm.ve.vl.vfaddd.vsvmvl(double %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3750   vr3 = _vel_vfaddd_vsvmvl(vd1, vr2, vm1, vr3, 256);
3751 }
3752
3753 void __attribute__((noinline))
3754 test_vfadds_vvvl() {
3755   // CHECK-LABEL: @test_vfadds_vvvl
3756   // CHECK: call <256 x double> @llvm.ve.vl.vfadds.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3757   vr3 = _vel_vfadds_vvvl(vr1, vr2, 256);
3758 }
3759
3760 void __attribute__((noinline))
3761 test_vfadds_vvvvl() {
3762   // CHECK-LABEL: @test_vfadds_vvvvl
3763   // CHECK: call <256 x double> @llvm.ve.vl.vfadds.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3764   vr3 = _vel_vfadds_vvvvl(vr1, vr2, vr3, 256);
3765 }
3766
3767 void __attribute__((noinline))
3768 test_vfadds_vsvl() {
3769   // CHECK-LABEL: @test_vfadds_vsvl
3770   // CHECK: call <256 x double> @llvm.ve.vl.vfadds.vsvl(float %{{.*}}, <256 x double> %{{.*}}, i32 256)
3771   vr3 = _vel_vfadds_vsvl(vf1, vr2, 256);
3772 }
3773
3774 void __attribute__((noinline))
3775 test_vfadds_vsvvl() {
3776   // CHECK-LABEL: @test_vfadds_vsvvl
3777   // CHECK: call <256 x double> @llvm.ve.vl.vfadds.vsvvl(float %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3778   vr3 = _vel_vfadds_vsvvl(vf1, vr2, vr3, 256);
3779 }
3780
3781 void __attribute__((noinline))
3782 test_vfadds_vvvmvl() {
3783   // CHECK-LABEL: @test_vfadds_vvvmvl
3784   // CHECK: call <256 x double> @llvm.ve.vl.vfadds.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3785   vr3 = _vel_vfadds_vvvmvl(vr1, vr2, vm1, vr3, 256);
3786 }
3787
3788 void __attribute__((noinline))
3789 test_vfadds_vsvmvl() {
3790   // CHECK-LABEL: @test_vfadds_vsvmvl
3791   // CHECK: call <256 x double> @llvm.ve.vl.vfadds.vsvmvl(float %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3792   vr3 = _vel_vfadds_vsvmvl(vf1, vr2, vm1, vr3, 256);
3793 }
3794
3795 void __attribute__((noinline))
3796 test_pvfadd_vvvl() {
3797   // CHECK-LABEL: @test_pvfadd_vvvl
3798   // CHECK: call <256 x double> @llvm.ve.vl.pvfadd.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3799   vr3 = _vel_pvfadd_vvvl(vr1, vr2, 256);
3800 }
3801
3802 void __attribute__((noinline))
3803 test_pvfadd_vvvvl() {
3804   // CHECK-LABEL: @test_pvfadd_vvvvl
3805   // CHECK: call <256 x double> @llvm.ve.vl.pvfadd.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3806   vr3 = _vel_pvfadd_vvvvl(vr1, vr2, vr3, 256);
3807 }
3808
3809 void __attribute__((noinline))
3810 test_pvfadd_vsvl() {
3811   // CHECK-LABEL: @test_pvfadd_vsvl
3812   // CHECK: call <256 x double> @llvm.ve.vl.pvfadd.vsvl(i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
3813   vr3 = _vel_pvfadd_vsvl(v1, vr2, 256);
3814 }
3815
3816 void __attribute__((noinline))
3817 test_pvfadd_vsvvl() {
3818   // CHECK-LABEL: @test_pvfadd_vsvvl
3819   // CHECK: call <256 x double> @llvm.ve.vl.pvfadd.vsvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3820   vr3 = _vel_pvfadd_vsvvl(v1, vr2, vr3, 256);
3821 }
3822
3823 void __attribute__((noinline))
3824 test_pvfadd_vvvMvl() {
3825   // CHECK-LABEL: @test_pvfadd_vvvMvl
3826   // CHECK: call <256 x double> @llvm.ve.vl.pvfadd.vvvMvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3827   vr3 = _vel_pvfadd_vvvMvl(vr1, vr2, vm1_512, vr3, 256);
3828 }
3829
3830 void __attribute__((noinline))
3831 test_pvfadd_vsvMvl() {
3832   // CHECK-LABEL: @test_pvfadd_vsvMvl
3833   // CHECK: call <256 x double> @llvm.ve.vl.pvfadd.vsvMvl(i64 %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3834   vr3 = _vel_pvfadd_vsvMvl(v1, vr2, vm1_512, vr3, 256);
3835 }
3836
3837 void __attribute__((noinline))
3838 test_vfsubd_vvvl() {
3839   // CHECK-LABEL: @test_vfsubd_vvvl
3840   // CHECK: call <256 x double> @llvm.ve.vl.vfsubd.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3841   vr3 = _vel_vfsubd_vvvl(vr1, vr2, 256);
3842 }
3843
3844 void __attribute__((noinline))
3845 test_vfsubd_vvvvl() {
3846   // CHECK-LABEL: @test_vfsubd_vvvvl
3847   // CHECK: call <256 x double> @llvm.ve.vl.vfsubd.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3848   vr3 = _vel_vfsubd_vvvvl(vr1, vr2, vr3, 256);
3849 }
3850
3851 void __attribute__((noinline))
3852 test_vfsubd_vsvl() {
3853   // CHECK-LABEL: @test_vfsubd_vsvl
3854   // CHECK: call <256 x double> @llvm.ve.vl.vfsubd.vsvl(double %{{.*}}, <256 x double> %{{.*}}, i32 256)
3855   vr3 = _vel_vfsubd_vsvl(vd1, vr2, 256);
3856 }
3857
3858 void __attribute__((noinline))
3859 test_vfsubd_vsvvl() {
3860   // CHECK-LABEL: @test_vfsubd_vsvvl
3861   // CHECK: call <256 x double> @llvm.ve.vl.vfsubd.vsvvl(double %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3862   vr3 = _vel_vfsubd_vsvvl(vd1, vr2, vr3, 256);
3863 }
3864
3865 void __attribute__((noinline))
3866 test_vfsubd_vvvmvl() {
3867   // CHECK-LABEL: @test_vfsubd_vvvmvl
3868   // CHECK: call <256 x double> @llvm.ve.vl.vfsubd.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3869   vr3 = _vel_vfsubd_vvvmvl(vr1, vr2, vm1, vr3, 256);
3870 }
3871
3872 void __attribute__((noinline))
3873 test_vfsubd_vsvmvl() {
3874   // CHECK-LABEL: @test_vfsubd_vsvmvl
3875   // CHECK: call <256 x double> @llvm.ve.vl.vfsubd.vsvmvl(double %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3876   vr3 = _vel_vfsubd_vsvmvl(vd1, vr2, vm1, vr3, 256);
3877 }
3878
3879 void __attribute__((noinline))
3880 test_vfsubs_vvvl() {
3881   // CHECK-LABEL: @test_vfsubs_vvvl
3882   // CHECK: call <256 x double> @llvm.ve.vl.vfsubs.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3883   vr3 = _vel_vfsubs_vvvl(vr1, vr2, 256);
3884 }
3885
3886 void __attribute__((noinline))
3887 test_vfsubs_vvvvl() {
3888   // CHECK-LABEL: @test_vfsubs_vvvvl
3889   // CHECK: call <256 x double> @llvm.ve.vl.vfsubs.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3890   vr3 = _vel_vfsubs_vvvvl(vr1, vr2, vr3, 256);
3891 }
3892
3893 void __attribute__((noinline))
3894 test_vfsubs_vsvl() {
3895   // CHECK-LABEL: @test_vfsubs_vsvl
3896   // CHECK: call <256 x double> @llvm.ve.vl.vfsubs.vsvl(float %{{.*}}, <256 x double> %{{.*}}, i32 256)
3897   vr3 = _vel_vfsubs_vsvl(vf1, vr2, 256);
3898 }
3899
3900 void __attribute__((noinline))
3901 test_vfsubs_vsvvl() {
3902   // CHECK-LABEL: @test_vfsubs_vsvvl
3903   // CHECK: call <256 x double> @llvm.ve.vl.vfsubs.vsvvl(float %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3904   vr3 = _vel_vfsubs_vsvvl(vf1, vr2, vr3, 256);
3905 }
3906
3907 void __attribute__((noinline))
3908 test_vfsubs_vvvmvl() {
3909   // CHECK-LABEL: @test_vfsubs_vvvmvl
3910   // CHECK: call <256 x double> @llvm.ve.vl.vfsubs.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3911   vr3 = _vel_vfsubs_vvvmvl(vr1, vr2, vm1, vr3, 256);
3912 }
3913
3914 void __attribute__((noinline))
3915 test_vfsubs_vsvmvl() {
3916   // CHECK-LABEL: @test_vfsubs_vsvmvl
3917   // CHECK: call <256 x double> @llvm.ve.vl.vfsubs.vsvmvl(float %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3918   vr3 = _vel_vfsubs_vsvmvl(vf1, vr2, vm1, vr3, 256);
3919 }
3920
3921 void __attribute__((noinline))
3922 test_pvfsub_vvvl() {
3923   // CHECK-LABEL: @test_pvfsub_vvvl
3924   // CHECK: call <256 x double> @llvm.ve.vl.pvfsub.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3925   vr3 = _vel_pvfsub_vvvl(vr1, vr2, 256);
3926 }
3927
3928 void __attribute__((noinline))
3929 test_pvfsub_vvvvl() {
3930   // CHECK-LABEL: @test_pvfsub_vvvvl
3931   // CHECK: call <256 x double> @llvm.ve.vl.pvfsub.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3932   vr3 = _vel_pvfsub_vvvvl(vr1, vr2, vr3, 256);
3933 }
3934
3935 void __attribute__((noinline))
3936 test_pvfsub_vsvl() {
3937   // CHECK-LABEL: @test_pvfsub_vsvl
3938   // CHECK: call <256 x double> @llvm.ve.vl.pvfsub.vsvl(i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
3939   vr3 = _vel_pvfsub_vsvl(v1, vr2, 256);
3940 }
3941
3942 void __attribute__((noinline))
3943 test_pvfsub_vsvvl() {
3944   // CHECK-LABEL: @test_pvfsub_vsvvl
3945   // CHECK: call <256 x double> @llvm.ve.vl.pvfsub.vsvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3946   vr3 = _vel_pvfsub_vsvvl(v1, vr2, vr3, 256);
3947 }
3948
3949 void __attribute__((noinline))
3950 test_pvfsub_vvvMvl() {
3951   // CHECK-LABEL: @test_pvfsub_vvvMvl
3952   // CHECK: call <256 x double> @llvm.ve.vl.pvfsub.vvvMvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3953   vr3 = _vel_pvfsub_vvvMvl(vr1, vr2, vm1_512, vr3, 256);
3954 }
3955
3956 void __attribute__((noinline))
3957 test_pvfsub_vsvMvl() {
3958   // CHECK-LABEL: @test_pvfsub_vsvMvl
3959   // CHECK: call <256 x double> @llvm.ve.vl.pvfsub.vsvMvl(i64 %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3960   vr3 = _vel_pvfsub_vsvMvl(v1, vr2, vm1_512, vr3, 256);
3961 }
3962
3963 void __attribute__((noinline))
3964 test_vfmuld_vvvl() {
3965   // CHECK-LABEL: @test_vfmuld_vvvl
3966   // CHECK: call <256 x double> @llvm.ve.vl.vfmuld.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3967   vr3 = _vel_vfmuld_vvvl(vr1, vr2, 256);
3968 }
3969
3970 void __attribute__((noinline))
3971 test_vfmuld_vvvvl() {
3972   // CHECK-LABEL: @test_vfmuld_vvvvl
3973   // CHECK: call <256 x double> @llvm.ve.vl.vfmuld.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3974   vr3 = _vel_vfmuld_vvvvl(vr1, vr2, vr3, 256);
3975 }
3976
3977 void __attribute__((noinline))
3978 test_vfmuld_vsvl() {
3979   // CHECK-LABEL: @test_vfmuld_vsvl
3980   // CHECK: call <256 x double> @llvm.ve.vl.vfmuld.vsvl(double %{{.*}}, <256 x double> %{{.*}}, i32 256)
3981   vr3 = _vel_vfmuld_vsvl(vd1, vr2, 256);
3982 }
3983
3984 void __attribute__((noinline))
3985 test_vfmuld_vsvvl() {
3986   // CHECK-LABEL: @test_vfmuld_vsvvl
3987   // CHECK: call <256 x double> @llvm.ve.vl.vfmuld.vsvvl(double %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3988   vr3 = _vel_vfmuld_vsvvl(vd1, vr2, vr3, 256);
3989 }
3990
3991 void __attribute__((noinline))
3992 test_vfmuld_vvvmvl() {
3993   // CHECK-LABEL: @test_vfmuld_vvvmvl
3994   // CHECK: call <256 x double> @llvm.ve.vl.vfmuld.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
3995   vr3 = _vel_vfmuld_vvvmvl(vr1, vr2, vm1, vr3, 256);
3996 }
3997
3998 void __attribute__((noinline))
3999 test_vfmuld_vsvmvl() {
4000   // CHECK-LABEL: @test_vfmuld_vsvmvl
4001   // CHECK: call <256 x double> @llvm.ve.vl.vfmuld.vsvmvl(double %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4002   vr3 = _vel_vfmuld_vsvmvl(vd1, vr2, vm1, vr3, 256);
4003 }
4004
4005 void __attribute__((noinline))
4006 test_vfmuls_vvvl() {
4007   // CHECK-LABEL: @test_vfmuls_vvvl
4008   // CHECK: call <256 x double> @llvm.ve.vl.vfmuls.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4009   vr3 = _vel_vfmuls_vvvl(vr1, vr2, 256);
4010 }
4011
4012 void __attribute__((noinline))
4013 test_vfmuls_vvvvl() {
4014   // CHECK-LABEL: @test_vfmuls_vvvvl
4015   // CHECK: call <256 x double> @llvm.ve.vl.vfmuls.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4016   vr3 = _vel_vfmuls_vvvvl(vr1, vr2, vr3, 256);
4017 }
4018
4019 void __attribute__((noinline))
4020 test_vfmuls_vsvl() {
4021   // CHECK-LABEL: @test_vfmuls_vsvl
4022   // CHECK: call <256 x double> @llvm.ve.vl.vfmuls.vsvl(float %{{.*}}, <256 x double> %{{.*}}, i32 256)
4023   vr3 = _vel_vfmuls_vsvl(vf1, vr2, 256);
4024 }
4025
4026 void __attribute__((noinline))
4027 test_vfmuls_vsvvl() {
4028   // CHECK-LABEL: @test_vfmuls_vsvvl
4029   // CHECK: call <256 x double> @llvm.ve.vl.vfmuls.vsvvl(float %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4030   vr3 = _vel_vfmuls_vsvvl(vf1, vr2, vr3, 256);
4031 }
4032
4033 void __attribute__((noinline))
4034 test_vfmuls_vvvmvl() {
4035   // CHECK-LABEL: @test_vfmuls_vvvmvl
4036   // CHECK: call <256 x double> @llvm.ve.vl.vfmuls.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4037   vr3 = _vel_vfmuls_vvvmvl(vr1, vr2, vm1, vr3, 256);
4038 }
4039
4040 void __attribute__((noinline))
4041 test_vfmuls_vsvmvl() {
4042   // CHECK-LABEL: @test_vfmuls_vsvmvl
4043   // CHECK: call <256 x double> @llvm.ve.vl.vfmuls.vsvmvl(float %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4044   vr3 = _vel_vfmuls_vsvmvl(vf1, vr2, vm1, vr3, 256);
4045 }
4046
4047 void __attribute__((noinline))
4048 test_pvfmul_vvvl() {
4049   // CHECK-LABEL: @test_pvfmul_vvvl
4050   // CHECK: call <256 x double> @llvm.ve.vl.pvfmul.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4051   vr3 = _vel_pvfmul_vvvl(vr1, vr2, 256);
4052 }
4053
4054 void __attribute__((noinline))
4055 test_pvfmul_vvvvl() {
4056   // CHECK-LABEL: @test_pvfmul_vvvvl
4057   // CHECK: call <256 x double> @llvm.ve.vl.pvfmul.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4058   vr3 = _vel_pvfmul_vvvvl(vr1, vr2, vr3, 256);
4059 }
4060
4061 void __attribute__((noinline))
4062 test_pvfmul_vsvl() {
4063   // CHECK-LABEL: @test_pvfmul_vsvl
4064   // CHECK: call <256 x double> @llvm.ve.vl.pvfmul.vsvl(i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
4065   vr3 = _vel_pvfmul_vsvl(v1, vr2, 256);
4066 }
4067
4068 void __attribute__((noinline))
4069 test_pvfmul_vsvvl() {
4070   // CHECK-LABEL: @test_pvfmul_vsvvl
4071   // CHECK: call <256 x double> @llvm.ve.vl.pvfmul.vsvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4072   vr3 = _vel_pvfmul_vsvvl(v1, vr2, vr3, 256);
4073 }
4074
4075 void __attribute__((noinline))
4076 test_pvfmul_vvvMvl() {
4077   // CHECK-LABEL: @test_pvfmul_vvvMvl
4078   // CHECK: call <256 x double> @llvm.ve.vl.pvfmul.vvvMvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4079   vr3 = _vel_pvfmul_vvvMvl(vr1, vr2, vm1_512, vr3, 256);
4080 }
4081
4082 void __attribute__((noinline))
4083 test_pvfmul_vsvMvl() {
4084   // CHECK-LABEL: @test_pvfmul_vsvMvl
4085   // CHECK: call <256 x double> @llvm.ve.vl.pvfmul.vsvMvl(i64 %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4086   vr3 = _vel_pvfmul_vsvMvl(v1, vr2, vm1_512, vr3, 256);
4087 }
4088
4089 void __attribute__((noinline))
4090 test_vfdivd_vvvl() {
4091   // CHECK-LABEL: @test_vfdivd_vvvl
4092   // CHECK: call <256 x double> @llvm.ve.vl.vfdivd.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4093   vr3 = _vel_vfdivd_vvvl(vr1, vr2, 256);
4094 }
4095
4096 void __attribute__((noinline))
4097 test_vfdivd_vvvvl() {
4098   // CHECK-LABEL: @test_vfdivd_vvvvl
4099   // CHECK: call <256 x double> @llvm.ve.vl.vfdivd.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4100   vr3 = _vel_vfdivd_vvvvl(vr1, vr2, vr3, 256);
4101 }
4102
4103 void __attribute__((noinline))
4104 test_vfdivd_vsvl() {
4105   // CHECK-LABEL: @test_vfdivd_vsvl
4106   // CHECK: call <256 x double> @llvm.ve.vl.vfdivd.vsvl(double %{{.*}}, <256 x double> %{{.*}}, i32 256)
4107   vr3 = _vel_vfdivd_vsvl(vd1, vr2, 256);
4108 }
4109
4110 void __attribute__((noinline))
4111 test_vfdivd_vsvvl() {
4112   // CHECK-LABEL: @test_vfdivd_vsvvl
4113   // CHECK: call <256 x double> @llvm.ve.vl.vfdivd.vsvvl(double %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4114   vr3 = _vel_vfdivd_vsvvl(vd1, vr2, vr3, 256);
4115 }
4116
4117 void __attribute__((noinline))
4118 test_vfdivd_vvvmvl() {
4119   // CHECK-LABEL: @test_vfdivd_vvvmvl
4120   // CHECK: call <256 x double> @llvm.ve.vl.vfdivd.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4121   vr3 = _vel_vfdivd_vvvmvl(vr1, vr2, vm1, vr3, 256);
4122 }
4123
4124 void __attribute__((noinline))
4125 test_vfdivd_vsvmvl() {
4126   // CHECK-LABEL: @test_vfdivd_vsvmvl
4127   // CHECK: call <256 x double> @llvm.ve.vl.vfdivd.vsvmvl(double %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4128   vr3 = _vel_vfdivd_vsvmvl(vd1, vr2, vm1, vr3, 256);
4129 }
4130
4131 void __attribute__((noinline))
4132 test_vfdivs_vvvl() {
4133   // CHECK-LABEL: @test_vfdivs_vvvl
4134   // CHECK: call <256 x double> @llvm.ve.vl.vfdivs.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4135   vr3 = _vel_vfdivs_vvvl(vr1, vr2, 256);
4136 }
4137
4138 void __attribute__((noinline))
4139 test_vfdivs_vvvvl() {
4140   // CHECK-LABEL: @test_vfdivs_vvvvl
4141   // CHECK: call <256 x double> @llvm.ve.vl.vfdivs.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4142   vr3 = _vel_vfdivs_vvvvl(vr1, vr2, vr3, 256);
4143 }
4144
4145 void __attribute__((noinline))
4146 test_vfdivs_vsvl() {
4147   // CHECK-LABEL: @test_vfdivs_vsvl
4148   // CHECK: call <256 x double> @llvm.ve.vl.vfdivs.vsvl(float %{{.*}}, <256 x double> %{{.*}}, i32 256)
4149   vr3 = _vel_vfdivs_vsvl(vf1, vr2, 256);
4150 }
4151
4152 void __attribute__((noinline))
4153 test_vfdivs_vsvvl() {
4154   // CHECK-LABEL: @test_vfdivs_vsvvl
4155   // CHECK: call <256 x double> @llvm.ve.vl.vfdivs.vsvvl(float %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4156   vr3 = _vel_vfdivs_vsvvl(vf1, vr2, vr3, 256);
4157 }
4158
4159 void __attribute__((noinline))
4160 test_vfdivs_vvvmvl() {
4161   // CHECK-LABEL: @test_vfdivs_vvvmvl
4162   // CHECK: call <256 x double> @llvm.ve.vl.vfdivs.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4163   vr3 = _vel_vfdivs_vvvmvl(vr1, vr2, vm1, vr3, 256);
4164 }
4165
4166 void __attribute__((noinline))
4167 test_vfdivs_vsvmvl() {
4168   // CHECK-LABEL: @test_vfdivs_vsvmvl
4169   // CHECK: call <256 x double> @llvm.ve.vl.vfdivs.vsvmvl(float %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4170   vr3 = _vel_vfdivs_vsvmvl(vf1, vr2, vm1, vr3, 256);
4171 }
4172
4173 void __attribute__((noinline))
4174 test_vfsqrtd_vvl() {
4175   // CHECK-LABEL: @test_vfsqrtd_vvl
4176   // CHECK: call <256 x double> @llvm.ve.vl.vfsqrtd.vvl(<256 x double> %{{.*}}, i32 256)
4177   vr2 = _vel_vfsqrtd_vvl(vr1, 256);
4178 }
4179
4180 void __attribute__((noinline))
4181 test_vfsqrtd_vvvl() {
4182   // CHECK-LABEL: @test_vfsqrtd_vvvl
4183   // CHECK: call <256 x double> @llvm.ve.vl.vfsqrtd.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4184   vr3 = _vel_vfsqrtd_vvvl(vr1, vr2, 256);
4185 }
4186
4187
4188 void __attribute__((noinline))
4189 test_vfsqrts_vvl() {
4190   // CHECK-LABEL: @test_vfsqrts_vvl
4191   // CHECK: call <256 x double> @llvm.ve.vl.vfsqrts.vvl(<256 x double> %{{.*}}, i32 256)
4192   vr2 = _vel_vfsqrts_vvl(vr1, 256);
4193 }
4194
4195 void __attribute__((noinline))
4196 test_vfsqrts_vvvl() {
4197   // CHECK-LABEL: @test_vfsqrts_vvvl
4198   // CHECK: call <256 x double> @llvm.ve.vl.vfsqrts.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4199   vr3 = _vel_vfsqrts_vvvl(vr1, vr2, 256);
4200 }
4201
4202 void __attribute__((noinline))
4203 test_vfcmpd_vvvl() {
4204   // CHECK-LABEL: @test_vfcmpd_vvvl
4205   // CHECK: call <256 x double> @llvm.ve.vl.vfcmpd.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4206   vr3 = _vel_vfcmpd_vvvl(vr1, vr2, 256);
4207 }
4208
4209 void __attribute__((noinline))
4210 test_vfcmpd_vvvvl() {
4211   // CHECK-LABEL: @test_vfcmpd_vvvvl
4212   // CHECK: call <256 x double> @llvm.ve.vl.vfcmpd.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4213   vr3 = _vel_vfcmpd_vvvvl(vr1, vr2, vr3, 256);
4214 }
4215
4216 void __attribute__((noinline))
4217 test_vfcmpd_vsvl() {
4218   // CHECK-LABEL: @test_vfcmpd_vsvl
4219   // CHECK: call <256 x double> @llvm.ve.vl.vfcmpd.vsvl(double %{{.*}}, <256 x double> %{{.*}}, i32 256)
4220   vr3 = _vel_vfcmpd_vsvl(vd1, vr2, 256);
4221 }
4222
4223 void __attribute__((noinline))
4224 test_vfcmpd_vsvvl() {
4225   // CHECK-LABEL: @test_vfcmpd_vsvvl
4226   // CHECK: call <256 x double> @llvm.ve.vl.vfcmpd.vsvvl(double %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4227   vr3 = _vel_vfcmpd_vsvvl(vd1, vr2, vr3, 256);
4228 }
4229
4230 void __attribute__((noinline))
4231 test_vfcmpd_vvvmvl() {
4232   // CHECK-LABEL: @test_vfcmpd_vvvmvl
4233   // CHECK: call <256 x double> @llvm.ve.vl.vfcmpd.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4234   vr3 = _vel_vfcmpd_vvvmvl(vr1, vr2, vm1, vr3, 256);
4235 }
4236
4237 void __attribute__((noinline))
4238 test_vfcmpd_vsvmvl() {
4239   // CHECK-LABEL: @test_vfcmpd_vsvmvl
4240   // CHECK: call <256 x double> @llvm.ve.vl.vfcmpd.vsvmvl(double %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4241   vr3 = _vel_vfcmpd_vsvmvl(vd1, vr2, vm1, vr3, 256);
4242 }
4243
4244 void __attribute__((noinline))
4245 test_vfcmps_vvvl() {
4246   // CHECK-LABEL: @test_vfcmps_vvvl
4247   // CHECK: call <256 x double> @llvm.ve.vl.vfcmps.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4248   vr3 = _vel_vfcmps_vvvl(vr1, vr2, 256);
4249 }
4250
4251 void __attribute__((noinline))
4252 test_vfcmps_vvvvl() {
4253   // CHECK-LABEL: @test_vfcmps_vvvvl
4254   // CHECK: call <256 x double> @llvm.ve.vl.vfcmps.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4255   vr3 = _vel_vfcmps_vvvvl(vr1, vr2, vr3, 256);
4256 }
4257
4258 void __attribute__((noinline))
4259 test_vfcmps_vsvl() {
4260   // CHECK-LABEL: @test_vfcmps_vsvl
4261   // CHECK: call <256 x double> @llvm.ve.vl.vfcmps.vsvl(float %{{.*}}, <256 x double> %{{.*}}, i32 256)
4262   vr3 = _vel_vfcmps_vsvl(vf1, vr2, 256);
4263 }
4264
4265 void __attribute__((noinline))
4266 test_vfcmps_vsvvl() {
4267   // CHECK-LABEL: @test_vfcmps_vsvvl
4268   // CHECK: call <256 x double> @llvm.ve.vl.vfcmps.vsvvl(float %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4269   vr3 = _vel_vfcmps_vsvvl(vf1, vr2, vr3, 256);
4270 }
4271
4272 void __attribute__((noinline))
4273 test_vfcmps_vvvmvl() {
4274   // CHECK-LABEL: @test_vfcmps_vvvmvl
4275   // CHECK: call <256 x double> @llvm.ve.vl.vfcmps.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4276   vr3 = _vel_vfcmps_vvvmvl(vr1, vr2, vm1, vr3, 256);
4277 }
4278
4279 void __attribute__((noinline))
4280 test_vfcmps_vsvmvl() {
4281   // CHECK-LABEL: @test_vfcmps_vsvmvl
4282   // CHECK: call <256 x double> @llvm.ve.vl.vfcmps.vsvmvl(float %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4283   vr3 = _vel_vfcmps_vsvmvl(vf1, vr2, vm1, vr3, 256);
4284 }
4285
4286 void __attribute__((noinline))
4287 test_pvfcmp_vvvl() {
4288   // CHECK-LABEL: @test_pvfcmp_vvvl
4289   // CHECK: call <256 x double> @llvm.ve.vl.pvfcmp.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4290   vr3 = _vel_pvfcmp_vvvl(vr1, vr2, 256);
4291 }
4292
4293 void __attribute__((noinline))
4294 test_pvfcmp_vvvvl() {
4295   // CHECK-LABEL: @test_pvfcmp_vvvvl
4296   // CHECK: call <256 x double> @llvm.ve.vl.pvfcmp.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4297   vr3 = _vel_pvfcmp_vvvvl(vr1, vr2, vr3, 256);
4298 }
4299
4300 void __attribute__((noinline))
4301 test_pvfcmp_vsvl() {
4302   // CHECK-LABEL: @test_pvfcmp_vsvl
4303   // CHECK: call <256 x double> @llvm.ve.vl.pvfcmp.vsvl(i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
4304   vr3 = _vel_pvfcmp_vsvl(v1, vr2, 256);
4305 }
4306
4307 void __attribute__((noinline))
4308 test_pvfcmp_vsvvl() {
4309   // CHECK-LABEL: @test_pvfcmp_vsvvl
4310   // CHECK: call <256 x double> @llvm.ve.vl.pvfcmp.vsvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4311   vr3 = _vel_pvfcmp_vsvvl(v1, vr2, vr3, 256);
4312 }
4313
4314 void __attribute__((noinline))
4315 test_pvfcmp_vvvMvl() {
4316   // CHECK-LABEL: @test_pvfcmp_vvvMvl
4317   // CHECK: call <256 x double> @llvm.ve.vl.pvfcmp.vvvMvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4318   vr3 = _vel_pvfcmp_vvvMvl(vr1, vr2, vm1_512, vr3, 256);
4319 }
4320
4321 void __attribute__((noinline))
4322 test_pvfcmp_vsvMvl() {
4323   // CHECK-LABEL: @test_pvfcmp_vsvMvl
4324   // CHECK: call <256 x double> @llvm.ve.vl.pvfcmp.vsvMvl(i64 %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4325   vr3 = _vel_pvfcmp_vsvMvl(v1, vr2, vm1_512, vr3, 256);
4326 }
4327
4328 void __attribute__((noinline))
4329 test_vfmaxd_vvvl() {
4330   // CHECK-LABEL: @test_vfmaxd_vvvl
4331   // CHECK: call <256 x double> @llvm.ve.vl.vfmaxd.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4332   vr3 = _vel_vfmaxd_vvvl(vr1, vr2, 256);
4333 }
4334
4335 void __attribute__((noinline))
4336 test_vfmaxd_vvvvl() {
4337   // CHECK-LABEL: @test_vfmaxd_vvvvl
4338   // CHECK: call <256 x double> @llvm.ve.vl.vfmaxd.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4339   vr3 = _vel_vfmaxd_vvvvl(vr1, vr2, vr3, 256);
4340 }
4341
4342 void __attribute__((noinline))
4343 test_vfmaxd_vsvl() {
4344   // CHECK-LABEL: @test_vfmaxd_vsvl
4345   // CHECK: call <256 x double> @llvm.ve.vl.vfmaxd.vsvl(double %{{.*}}, <256 x double> %{{.*}}, i32 256)
4346   vr3 = _vel_vfmaxd_vsvl(vd1, vr2, 256);
4347 }
4348
4349 void __attribute__((noinline))
4350 test_vfmaxd_vsvvl() {
4351   // CHECK-LABEL: @test_vfmaxd_vsvvl
4352   // CHECK: call <256 x double> @llvm.ve.vl.vfmaxd.vsvvl(double %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4353   vr3 = _vel_vfmaxd_vsvvl(vd1, vr2, vr3, 256);
4354 }
4355
4356 void __attribute__((noinline))
4357 test_vfmaxd_vvvmvl() {
4358   // CHECK-LABEL: @test_vfmaxd_vvvmvl
4359   // CHECK: call <256 x double> @llvm.ve.vl.vfmaxd.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4360   vr3 = _vel_vfmaxd_vvvmvl(vr1, vr2, vm1, vr3, 256);
4361 }
4362
4363 void __attribute__((noinline))
4364 test_vfmaxd_vsvmvl() {
4365   // CHECK-LABEL: @test_vfmaxd_vsvmvl
4366   // CHECK: call <256 x double> @llvm.ve.vl.vfmaxd.vsvmvl(double %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4367   vr3 = _vel_vfmaxd_vsvmvl(vd1, vr2, vm1, vr3, 256);
4368 }
4369
4370 void __attribute__((noinline))
4371 test_vfmaxs_vvvl() {
4372   // CHECK-LABEL: @test_vfmaxs_vvvl
4373   // CHECK: call <256 x double> @llvm.ve.vl.vfmaxs.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4374   vr3 = _vel_vfmaxs_vvvl(vr1, vr2, 256);
4375 }
4376
4377 void __attribute__((noinline))
4378 test_vfmaxs_vvvvl() {
4379   // CHECK-LABEL: @test_vfmaxs_vvvvl
4380   // CHECK: call <256 x double> @llvm.ve.vl.vfmaxs.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4381   vr3 = _vel_vfmaxs_vvvvl(vr1, vr2, vr3, 256);
4382 }
4383
4384 void __attribute__((noinline))
4385 test_vfmaxs_vsvl() {
4386   // CHECK-LABEL: @test_vfmaxs_vsvl
4387   // CHECK: call <256 x double> @llvm.ve.vl.vfmaxs.vsvl(float %{{.*}}, <256 x double> %{{.*}}, i32 256)
4388   vr3 = _vel_vfmaxs_vsvl(vf1, vr2, 256);
4389 }
4390
4391 void __attribute__((noinline))
4392 test_vfmaxs_vsvvl() {
4393   // CHECK-LABEL: @test_vfmaxs_vsvvl
4394   // CHECK: call <256 x double> @llvm.ve.vl.vfmaxs.vsvvl(float %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4395   vr3 = _vel_vfmaxs_vsvvl(vf1, vr2, vr3, 256);
4396 }
4397
4398 void __attribute__((noinline))
4399 test_vfmaxs_vvvmvl() {
4400   // CHECK-LABEL: @test_vfmaxs_vvvmvl
4401   // CHECK: call <256 x double> @llvm.ve.vl.vfmaxs.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4402   vr3 = _vel_vfmaxs_vvvmvl(vr1, vr2, vm1, vr3, 256);
4403 }
4404
4405 void __attribute__((noinline))
4406 test_vfmaxs_vsvmvl() {
4407   // CHECK-LABEL: @test_vfmaxs_vsvmvl
4408   // CHECK: call <256 x double> @llvm.ve.vl.vfmaxs.vsvmvl(float %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4409   vr3 = _vel_vfmaxs_vsvmvl(vf1, vr2, vm1, vr3, 256);
4410 }
4411
4412 void __attribute__((noinline))
4413 test_pvfmax_vvvl() {
4414   // CHECK-LABEL: @test_pvfmax_vvvl
4415   // CHECK: call <256 x double> @llvm.ve.vl.pvfmax.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4416   vr3 = _vel_pvfmax_vvvl(vr1, vr2, 256);
4417 }
4418
4419 void __attribute__((noinline))
4420 test_pvfmax_vvvvl() {
4421   // CHECK-LABEL: @test_pvfmax_vvvvl
4422   // CHECK: call <256 x double> @llvm.ve.vl.pvfmax.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4423   vr3 = _vel_pvfmax_vvvvl(vr1, vr2, vr3, 256);
4424 }
4425
4426 void __attribute__((noinline))
4427 test_pvfmax_vsvl() {
4428   // CHECK-LABEL: @test_pvfmax_vsvl
4429   // CHECK: call <256 x double> @llvm.ve.vl.pvfmax.vsvl(i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
4430   vr3 = _vel_pvfmax_vsvl(v1, vr2, 256);
4431 }
4432
4433 void __attribute__((noinline))
4434 test_pvfmax_vsvvl() {
4435   // CHECK-LABEL: @test_pvfmax_vsvvl
4436   // CHECK: call <256 x double> @llvm.ve.vl.pvfmax.vsvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4437   vr3 = _vel_pvfmax_vsvvl(v1, vr2, vr3, 256);
4438 }
4439
4440 void __attribute__((noinline))
4441 test_pvfmax_vvvMvl() {
4442   // CHECK-LABEL: @test_pvfmax_vvvMvl
4443   // CHECK: call <256 x double> @llvm.ve.vl.pvfmax.vvvMvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4444   vr3 = _vel_pvfmax_vvvMvl(vr1, vr2, vm1_512, vr3, 256);
4445 }
4446
4447 void __attribute__((noinline))
4448 test_pvfmax_vsvMvl() {
4449   // CHECK-LABEL: @test_pvfmax_vsvMvl
4450   // CHECK: call <256 x double> @llvm.ve.vl.pvfmax.vsvMvl(i64 %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4451   vr3 = _vel_pvfmax_vsvMvl(v1, vr2, vm1_512, vr3, 256);
4452 }
4453
4454 void __attribute__((noinline))
4455 test_vfmind_vvvl() {
4456   // CHECK-LABEL: @test_vfmind_vvvl
4457   // CHECK: call <256 x double> @llvm.ve.vl.vfmind.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4458   vr3 = _vel_vfmind_vvvl(vr1, vr2, 256);
4459 }
4460
4461 void __attribute__((noinline))
4462 test_vfmind_vvvvl() {
4463   // CHECK-LABEL: @test_vfmind_vvvvl
4464   // CHECK: call <256 x double> @llvm.ve.vl.vfmind.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4465   vr3 = _vel_vfmind_vvvvl(vr1, vr2, vr3, 256);
4466 }
4467
4468 void __attribute__((noinline))
4469 test_vfmind_vsvl() {
4470   // CHECK-LABEL: @test_vfmind_vsvl
4471   // CHECK: call <256 x double> @llvm.ve.vl.vfmind.vsvl(double %{{.*}}, <256 x double> %{{.*}}, i32 256)
4472   vr3 = _vel_vfmind_vsvl(vd1, vr2, 256);
4473 }
4474
4475 void __attribute__((noinline))
4476 test_vfmind_vsvvl() {
4477   // CHECK-LABEL: @test_vfmind_vsvvl
4478   // CHECK: call <256 x double> @llvm.ve.vl.vfmind.vsvvl(double %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4479   vr3 = _vel_vfmind_vsvvl(vd1, vr2, vr3, 256);
4480 }
4481
4482 void __attribute__((noinline))
4483 test_vfmind_vvvmvl() {
4484   // CHECK-LABEL: @test_vfmind_vvvmvl
4485   // CHECK: call <256 x double> @llvm.ve.vl.vfmind.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4486   vr3 = _vel_vfmind_vvvmvl(vr1, vr2, vm1, vr3, 256);
4487 }
4488
4489 void __attribute__((noinline))
4490 test_vfmind_vsvmvl() {
4491   // CHECK-LABEL: @test_vfmind_vsvmvl
4492   // CHECK: call <256 x double> @llvm.ve.vl.vfmind.vsvmvl(double %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4493   vr3 = _vel_vfmind_vsvmvl(vd1, vr2, vm1, vr3, 256);
4494 }
4495
4496 void __attribute__((noinline))
4497 test_vfmins_vvvl() {
4498   // CHECK-LABEL: @test_vfmins_vvvl
4499   // CHECK: call <256 x double> @llvm.ve.vl.vfmins.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4500   vr3 = _vel_vfmins_vvvl(vr1, vr2, 256);
4501 }
4502
4503 void __attribute__((noinline))
4504 test_vfmins_vvvvl() {
4505   // CHECK-LABEL: @test_vfmins_vvvvl
4506   // CHECK: call <256 x double> @llvm.ve.vl.vfmins.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4507   vr3 = _vel_vfmins_vvvvl(vr1, vr2, vr3, 256);
4508 }
4509
4510 void __attribute__((noinline))
4511 test_vfmins_vsvl() {
4512   // CHECK-LABEL: @test_vfmins_vsvl
4513   // CHECK: call <256 x double> @llvm.ve.vl.vfmins.vsvl(float %{{.*}}, <256 x double> %{{.*}}, i32 256)
4514   vr3 = _vel_vfmins_vsvl(vf1, vr2, 256);
4515 }
4516
4517 void __attribute__((noinline))
4518 test_vfmins_vsvvl() {
4519   // CHECK-LABEL: @test_vfmins_vsvvl
4520   // CHECK: call <256 x double> @llvm.ve.vl.vfmins.vsvvl(float %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4521   vr3 = _vel_vfmins_vsvvl(vf1, vr2, vr3, 256);
4522 }
4523
4524 void __attribute__((noinline))
4525 test_vfmins_vvvmvl() {
4526   // CHECK-LABEL: @test_vfmins_vvvmvl
4527   // CHECK: call <256 x double> @llvm.ve.vl.vfmins.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4528   vr3 = _vel_vfmins_vvvmvl(vr1, vr2, vm1, vr3, 256);
4529 }
4530
4531 void __attribute__((noinline))
4532 test_vfmins_vsvmvl() {
4533   // CHECK-LABEL: @test_vfmins_vsvmvl
4534   // CHECK: call <256 x double> @llvm.ve.vl.vfmins.vsvmvl(float %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4535   vr3 = _vel_vfmins_vsvmvl(vf1, vr2, vm1, vr3, 256);
4536 }
4537
4538 void __attribute__((noinline))
4539 test_pvfmin_vvvl() {
4540   // CHECK-LABEL: @test_pvfmin_vvvl
4541   // CHECK: call <256 x double> @llvm.ve.vl.pvfmin.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4542   vr3 = _vel_pvfmin_vvvl(vr1, vr2, 256);
4543 }
4544
4545 void __attribute__((noinline))
4546 test_pvfmin_vvvvl() {
4547   // CHECK-LABEL: @test_pvfmin_vvvvl
4548   // CHECK: call <256 x double> @llvm.ve.vl.pvfmin.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4549   vr3 = _vel_pvfmin_vvvvl(vr1, vr2, vr3, 256);
4550 }
4551
4552 void __attribute__((noinline))
4553 test_pvfmin_vsvl() {
4554   // CHECK-LABEL: @test_pvfmin_vsvl
4555   // CHECK: call <256 x double> @llvm.ve.vl.pvfmin.vsvl(i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
4556   vr3 = _vel_pvfmin_vsvl(v1, vr2, 256);
4557 }
4558
4559 void __attribute__((noinline))
4560 test_pvfmin_vsvvl() {
4561   // CHECK-LABEL: @test_pvfmin_vsvvl
4562   // CHECK: call <256 x double> @llvm.ve.vl.pvfmin.vsvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4563   vr3 = _vel_pvfmin_vsvvl(v1, vr2, vr3, 256);
4564 }
4565
4566 void __attribute__((noinline))
4567 test_pvfmin_vvvMvl() {
4568   // CHECK-LABEL: @test_pvfmin_vvvMvl
4569   // CHECK: call <256 x double> @llvm.ve.vl.pvfmin.vvvMvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4570   vr3 = _vel_pvfmin_vvvMvl(vr1, vr2, vm1_512, vr3, 256);
4571 }
4572
4573 void __attribute__((noinline))
4574 test_pvfmin_vsvMvl() {
4575   // CHECK-LABEL: @test_pvfmin_vsvMvl
4576   // CHECK: call <256 x double> @llvm.ve.vl.pvfmin.vsvMvl(i64 %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4577   vr3 = _vel_pvfmin_vsvMvl(v1, vr2, vm1_512, vr3, 256);
4578 }
4579
4580 void __attribute__((noinline))
4581 test_vfmadd_vvvvl() {
4582   // CHECK-LABEL: @test_vfmadd_vvvvl
4583   // CHECK: call <256 x double> @llvm.ve.vl.vfmadd.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4584   vr4 = _vel_vfmadd_vvvvl(vr1, vr2, vr3, 256);
4585 }
4586
4587 void __attribute__((noinline))
4588 test_vfmadd_vvvvvl() {
4589   // CHECK-LABEL: @test_vfmadd_vvvvvl
4590   // CHECK: call <256 x double> @llvm.ve.vl.vfmadd.vvvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4591   vr4 = _vel_vfmadd_vvvvvl(vr1, vr2, vr3, vr4, 256);
4592 }
4593
4594 void __attribute__((noinline))
4595 test_vfmadd_vsvvl() {
4596   // CHECK-LABEL: @test_vfmadd_vsvvl
4597   // CHECK: call <256 x double> @llvm.ve.vl.vfmadd.vsvvl(double %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4598   vr4 = _vel_vfmadd_vsvvl(vd1, vr2, vr3, 256);
4599 }
4600
4601 void __attribute__((noinline))
4602 test_vfmadd_vsvvvl() {
4603   // CHECK-LABEL: @test_vfmadd_vsvvvl
4604   // CHECK: call <256 x double> @llvm.ve.vl.vfmadd.vsvvvl(double %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4605   vr4 = _vel_vfmadd_vsvvvl(vd1, vr2, vr3, vr4, 256);
4606 }
4607
4608 void __attribute__((noinline))
4609 test_vfmadd_vvsvl() {
4610   // CHECK-LABEL: @test_vfmadd_vvsvl
4611   // CHECK: call <256 x double> @llvm.ve.vl.vfmadd.vvsvl(<256 x double> %{{.*}}, double %{{.*}}, <256 x double> %{{.*}}, i32 256)
4612   vr4 = _vel_vfmadd_vvsvl(vr1, vd1, vr3, 256);
4613 }
4614
4615 void __attribute__((noinline))
4616 test_vfmadd_vvsvvl() {
4617   // CHECK-LABEL: @test_vfmadd_vvsvvl
4618   // CHECK: call <256 x double> @llvm.ve.vl.vfmadd.vvsvvl(<256 x double> %{{.*}}, double %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4619   vr4 = _vel_vfmadd_vvsvvl(vr1, vd1, vr3, vr4, 256);
4620 }
4621
4622 void __attribute__((noinline))
4623 test_vfmadd_vvvvmvl() {
4624   // CHECK-LABEL: @test_vfmadd_vvvvmvl
4625   // CHECK: call <256 x double> @llvm.ve.vl.vfmadd.vvvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4626   vr4 = _vel_vfmadd_vvvvmvl(vr1, vr2, vr3, vm1, vr4, 256);
4627 }
4628
4629 void __attribute__((noinline))
4630 test_vfmadd_vsvvmvl() {
4631   // CHECK-LABEL: @test_vfmadd_vsvvmvl
4632   // CHECK: call <256 x double> @llvm.ve.vl.vfmadd.vsvvmvl(double %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4633   vr4 = _vel_vfmadd_vsvvmvl(vd1, vr2, vr3, vm1, vr4, 256);
4634 }
4635
4636 void __attribute__((noinline))
4637 test_vfmadd_vvsvmvl() {
4638   // CHECK-LABEL: @test_vfmadd_vvsvmvl
4639   // CHECK: call <256 x double> @llvm.ve.vl.vfmadd.vvsvmvl(<256 x double> %{{.*}}, double %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4640   vr4 = _vel_vfmadd_vvsvmvl(vr1, vd1, vr3, vm1, vr4, 256);
4641 }
4642
4643 void __attribute__((noinline))
4644 test_vfmads_vvvvl() {
4645   // CHECK-LABEL: @test_vfmads_vvvvl
4646   // CHECK: call <256 x double> @llvm.ve.vl.vfmads.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4647   vr4 = _vel_vfmads_vvvvl(vr1, vr2, vr3, 256);
4648 }
4649
4650 void __attribute__((noinline))
4651 test_vfmads_vvvvvl() {
4652   // CHECK-LABEL: @test_vfmads_vvvvvl
4653   // CHECK: call <256 x double> @llvm.ve.vl.vfmads.vvvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4654   vr4 = _vel_vfmads_vvvvvl(vr1, vr2, vr3, vr4, 256);
4655 }
4656
4657 void __attribute__((noinline))
4658 test_vfmads_vsvvl() {
4659   // CHECK-LABEL: @test_vfmads_vsvvl
4660   // CHECK: call <256 x double> @llvm.ve.vl.vfmads.vsvvl(float %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4661   vr4 = _vel_vfmads_vsvvl(vf1, vr2, vr3, 256);
4662 }
4663
4664 void __attribute__((noinline))
4665 test_vfmads_vsvvvl() {
4666   // CHECK-LABEL: @test_vfmads_vsvvvl
4667   // CHECK: call <256 x double> @llvm.ve.vl.vfmads.vsvvvl(float %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4668   vr4 = _vel_vfmads_vsvvvl(vf1, vr2, vr3, vr4, 256);
4669 }
4670
4671 void __attribute__((noinline))
4672 test_vfmads_vvsvl() {
4673   // CHECK-LABEL: @test_vfmads_vvsvl
4674   // CHECK: call <256 x double> @llvm.ve.vl.vfmads.vvsvl(<256 x double> %{{.*}}, float %{{.*}}, <256 x double> %{{.*}}, i32 256)
4675   vr4 = _vel_vfmads_vvsvl(vr1, vf1, vr3, 256);
4676 }
4677
4678 void __attribute__((noinline))
4679 test_vfmads_vvsvvl() {
4680   // CHECK-LABEL: @test_vfmads_vvsvvl
4681   // CHECK: call <256 x double> @llvm.ve.vl.vfmads.vvsvvl(<256 x double> %{{.*}}, float %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4682   vr4 = _vel_vfmads_vvsvvl(vr1, vf1, vr3, vr4, 256);
4683 }
4684
4685 void __attribute__((noinline))
4686 test_vfmads_vvvvmvl() {
4687   // CHECK-LABEL: @test_vfmads_vvvvmvl
4688   // CHECK: call <256 x double> @llvm.ve.vl.vfmads.vvvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4689   vr4 = _vel_vfmads_vvvvmvl(vr1, vr2, vr3, vm1, vr4, 256);
4690 }
4691
4692 void __attribute__((noinline))
4693 test_vfmads_vsvvmvl() {
4694   // CHECK-LABEL: @test_vfmads_vsvvmvl
4695   // CHECK: call <256 x double> @llvm.ve.vl.vfmads.vsvvmvl(float %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4696   vr4 = _vel_vfmads_vsvvmvl(vf1, vr2, vr3, vm1, vr4, 256);
4697 }
4698
4699 void __attribute__((noinline))
4700 test_vfmads_vvsvmvl() {
4701   // CHECK-LABEL: @test_vfmads_vvsvmvl
4702   // CHECK: call <256 x double> @llvm.ve.vl.vfmads.vvsvmvl(<256 x double> %{{.*}}, float %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4703   vr4 = _vel_vfmads_vvsvmvl(vr1, vf1, vr3, vm1, vr4, 256);
4704 }
4705
4706 void __attribute__((noinline))
4707 test_pvfmad_vvvvl() {
4708   // CHECK-LABEL: @test_pvfmad_vvvvl
4709   // CHECK: call <256 x double> @llvm.ve.vl.pvfmad.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4710   vr4 = _vel_pvfmad_vvvvl(vr1, vr2, vr3, 256);
4711 }
4712
4713 void __attribute__((noinline))
4714 test_pvfmad_vvvvvl() {
4715   // CHECK-LABEL: @test_pvfmad_vvvvvl
4716   // CHECK: call <256 x double> @llvm.ve.vl.pvfmad.vvvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4717   vr4 = _vel_pvfmad_vvvvvl(vr1, vr2, vr3, vr4, 256);
4718 }
4719
4720 void __attribute__((noinline))
4721 test_pvfmad_vsvvl() {
4722   // CHECK-LABEL: @test_pvfmad_vsvvl
4723   // CHECK: call <256 x double> @llvm.ve.vl.pvfmad.vsvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4724   vr4 = _vel_pvfmad_vsvvl(v1, vr2, vr3, 256);
4725 }
4726
4727 void __attribute__((noinline))
4728 test_pvfmad_vsvvvl() {
4729   // CHECK-LABEL: @test_pvfmad_vsvvvl
4730   // CHECK: call <256 x double> @llvm.ve.vl.pvfmad.vsvvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4731   vr4 = _vel_pvfmad_vsvvvl(v1, vr2, vr3, vr4, 256);
4732 }
4733
4734 void __attribute__((noinline))
4735 test_pvfmad_vvsvl() {
4736   // CHECK-LABEL: @test_pvfmad_vvsvl
4737   // CHECK: call <256 x double> @llvm.ve.vl.pvfmad.vvsvl(<256 x double> %{{.*}}, i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
4738   vr4 = _vel_pvfmad_vvsvl(vr1, v1, vr3, 256);
4739 }
4740
4741 void __attribute__((noinline))
4742 test_pvfmad_vvsvvl() {
4743   // CHECK-LABEL: @test_pvfmad_vvsvvl
4744   // CHECK: call <256 x double> @llvm.ve.vl.pvfmad.vvsvvl(<256 x double> %{{.*}}, i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4745   vr4 = _vel_pvfmad_vvsvvl(vr1, v1, vr3, vr4, 256);
4746 }
4747
4748 void __attribute__((noinline))
4749 test_pvfmad_vvvvMvl() {
4750   // CHECK-LABEL: @test_pvfmad_vvvvMvl
4751   // CHECK: call <256 x double> @llvm.ve.vl.pvfmad.vvvvMvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4752   vr4 = _vel_pvfmad_vvvvMvl(vr1, vr2, vr3, vm1_512, vr4, 256);
4753 }
4754
4755 void __attribute__((noinline))
4756 test_pvfmad_vsvvMvl() {
4757   // CHECK-LABEL: @test_pvfmad_vsvvMvl
4758   // CHECK: call <256 x double> @llvm.ve.vl.pvfmad.vsvvMvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4759   vr4 = _vel_pvfmad_vsvvMvl(v1, vr2, vr3, vm1_512, vr4, 256);
4760 }
4761
4762 void __attribute__((noinline))
4763 test_pvfmad_vvsvMvl() {
4764   // CHECK-LABEL: @test_pvfmad_vvsvMvl
4765   // CHECK: call <256 x double> @llvm.ve.vl.pvfmad.vvsvMvl(<256 x double> %{{.*}}, i64 %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4766   vr4 = _vel_pvfmad_vvsvMvl(vr1, v1, vr3, vm1_512, vr4, 256);
4767 }
4768
4769 void __attribute__((noinline))
4770 test_vfmsbd_vvvvl() {
4771   // CHECK-LABEL: @test_vfmsbd_vvvvl
4772   // CHECK: call <256 x double> @llvm.ve.vl.vfmsbd.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4773   vr4 = _vel_vfmsbd_vvvvl(vr1, vr2, vr3, 256);
4774 }
4775
4776 void __attribute__((noinline))
4777 test_vfmsbd_vvvvvl() {
4778   // CHECK-LABEL: @test_vfmsbd_vvvvvl
4779   // CHECK: call <256 x double> @llvm.ve.vl.vfmsbd.vvvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4780   vr4 = _vel_vfmsbd_vvvvvl(vr1, vr2, vr3, vr4, 256);
4781 }
4782
4783 void __attribute__((noinline))
4784 test_vfmsbd_vsvvl() {
4785   // CHECK-LABEL: @test_vfmsbd_vsvvl
4786   // CHECK: call <256 x double> @llvm.ve.vl.vfmsbd.vsvvl(double %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4787   vr4 = _vel_vfmsbd_vsvvl(vd1, vr2, vr3, 256);
4788 }
4789
4790 void __attribute__((noinline))
4791 test_vfmsbd_vsvvvl() {
4792   // CHECK-LABEL: @test_vfmsbd_vsvvvl
4793   // CHECK: call <256 x double> @llvm.ve.vl.vfmsbd.vsvvvl(double %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4794   vr4 = _vel_vfmsbd_vsvvvl(vd1, vr2, vr3, vr4, 256);
4795 }
4796
4797 void __attribute__((noinline))
4798 test_vfmsbd_vvsvl() {
4799   // CHECK-LABEL: @test_vfmsbd_vvsvl
4800   // CHECK: call <256 x double> @llvm.ve.vl.vfmsbd.vvsvl(<256 x double> %{{.*}}, double %{{.*}}, <256 x double> %{{.*}}, i32 256)
4801   vr4 = _vel_vfmsbd_vvsvl(vr1, vd1, vr3, 256);
4802 }
4803
4804 void __attribute__((noinline))
4805 test_vfmsbd_vvsvvl() {
4806   // CHECK-LABEL: @test_vfmsbd_vvsvvl
4807   // CHECK: call <256 x double> @llvm.ve.vl.vfmsbd.vvsvvl(<256 x double> %{{.*}}, double %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4808   vr4 = _vel_vfmsbd_vvsvvl(vr1, vd1, vr3, vr4, 256);
4809 }
4810
4811 void __attribute__((noinline))
4812 test_vfmsbd_vvvvmvl() {
4813   // CHECK-LABEL: @test_vfmsbd_vvvvmvl
4814   // CHECK: call <256 x double> @llvm.ve.vl.vfmsbd.vvvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4815   vr4 = _vel_vfmsbd_vvvvmvl(vr1, vr2, vr3, vm1, vr4, 256);
4816 }
4817
4818 void __attribute__((noinline))
4819 test_vfmsbd_vsvvmvl() {
4820   // CHECK-LABEL: @test_vfmsbd_vsvvmvl
4821   // CHECK: call <256 x double> @llvm.ve.vl.vfmsbd.vsvvmvl(double %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4822   vr4 = _vel_vfmsbd_vsvvmvl(vd1, vr2, vr3, vm1, vr4, 256);
4823 }
4824
4825 void __attribute__((noinline))
4826 test_vfmsbd_vvsvmvl() {
4827   // CHECK-LABEL: @test_vfmsbd_vvsvmvl
4828   // CHECK: call <256 x double> @llvm.ve.vl.vfmsbd.vvsvmvl(<256 x double> %{{.*}}, double %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4829   vr4 = _vel_vfmsbd_vvsvmvl(vr1, vd1, vr3, vm1, vr4, 256);
4830 }
4831
4832 void __attribute__((noinline))
4833 test_vfmsbs_vvvvl() {
4834   // CHECK-LABEL: @test_vfmsbs_vvvvl
4835   // CHECK: call <256 x double> @llvm.ve.vl.vfmsbs.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4836   vr4 = _vel_vfmsbs_vvvvl(vr1, vr2, vr3, 256);
4837 }
4838
4839 void __attribute__((noinline))
4840 test_vfmsbs_vvvvvl() {
4841   // CHECK-LABEL: @test_vfmsbs_vvvvvl
4842   // CHECK: call <256 x double> @llvm.ve.vl.vfmsbs.vvvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4843   vr4 = _vel_vfmsbs_vvvvvl(vr1, vr2, vr3, vr4, 256);
4844 }
4845
4846 void __attribute__((noinline))
4847 test_vfmsbs_vsvvl() {
4848   // CHECK-LABEL: @test_vfmsbs_vsvvl
4849   // CHECK: call <256 x double> @llvm.ve.vl.vfmsbs.vsvvl(float %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4850   vr4 = _vel_vfmsbs_vsvvl(vf1, vr2, vr3, 256);
4851 }
4852
4853 void __attribute__((noinline))
4854 test_vfmsbs_vsvvvl() {
4855   // CHECK-LABEL: @test_vfmsbs_vsvvvl
4856   // CHECK: call <256 x double> @llvm.ve.vl.vfmsbs.vsvvvl(float %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4857   vr4 = _vel_vfmsbs_vsvvvl(vf1, vr2, vr3, vr4, 256);
4858 }
4859
4860 void __attribute__((noinline))
4861 test_vfmsbs_vvsvl() {
4862   // CHECK-LABEL: @test_vfmsbs_vvsvl
4863   // CHECK: call <256 x double> @llvm.ve.vl.vfmsbs.vvsvl(<256 x double> %{{.*}}, float %{{.*}}, <256 x double> %{{.*}}, i32 256)
4864   vr4 = _vel_vfmsbs_vvsvl(vr1, vf1, vr3, 256);
4865 }
4866
4867 void __attribute__((noinline))
4868 test_vfmsbs_vvsvvl() {
4869   // CHECK-LABEL: @test_vfmsbs_vvsvvl
4870   // CHECK: call <256 x double> @llvm.ve.vl.vfmsbs.vvsvvl(<256 x double> %{{.*}}, float %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4871   vr4 = _vel_vfmsbs_vvsvvl(vr1, vf1, vr3, vr4, 256);
4872 }
4873
4874 void __attribute__((noinline))
4875 test_vfmsbs_vvvvmvl() {
4876   // CHECK-LABEL: @test_vfmsbs_vvvvmvl
4877   // CHECK: call <256 x double> @llvm.ve.vl.vfmsbs.vvvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4878   vr4 = _vel_vfmsbs_vvvvmvl(vr1, vr2, vr3, vm1, vr4, 256);
4879 }
4880
4881 void __attribute__((noinline))
4882 test_vfmsbs_vsvvmvl() {
4883   // CHECK-LABEL: @test_vfmsbs_vsvvmvl
4884   // CHECK: call <256 x double> @llvm.ve.vl.vfmsbs.vsvvmvl(float %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4885   vr4 = _vel_vfmsbs_vsvvmvl(vf1, vr2, vr3, vm1, vr4, 256);
4886 }
4887
4888 void __attribute__((noinline))
4889 test_vfmsbs_vvsvmvl() {
4890   // CHECK-LABEL: @test_vfmsbs_vvsvmvl
4891   // CHECK: call <256 x double> @llvm.ve.vl.vfmsbs.vvsvmvl(<256 x double> %{{.*}}, float %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4892   vr4 = _vel_vfmsbs_vvsvmvl(vr1, vf1, vr3, vm1, vr4, 256);
4893 }
4894
4895 void __attribute__((noinline))
4896 test_pvfmsb_vvvvl() {
4897   // CHECK-LABEL: @test_pvfmsb_vvvvl
4898   // CHECK: call <256 x double> @llvm.ve.vl.pvfmsb.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4899   vr4 = _vel_pvfmsb_vvvvl(vr1, vr2, vr3, 256);
4900 }
4901
4902 void __attribute__((noinline))
4903 test_pvfmsb_vvvvvl() {
4904   // CHECK-LABEL: @test_pvfmsb_vvvvvl
4905   // CHECK: call <256 x double> @llvm.ve.vl.pvfmsb.vvvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4906   vr4 = _vel_pvfmsb_vvvvvl(vr1, vr2, vr3, vr4, 256);
4907 }
4908
4909 void __attribute__((noinline))
4910 test_pvfmsb_vsvvl() {
4911   // CHECK-LABEL: @test_pvfmsb_vsvvl
4912   // CHECK: call <256 x double> @llvm.ve.vl.pvfmsb.vsvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4913   vr4 = _vel_pvfmsb_vsvvl(v1, vr2, vr3, 256);
4914 }
4915
4916 void __attribute__((noinline))
4917 test_pvfmsb_vsvvvl() {
4918   // CHECK-LABEL: @test_pvfmsb_vsvvvl
4919   // CHECK: call <256 x double> @llvm.ve.vl.pvfmsb.vsvvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4920   vr4 = _vel_pvfmsb_vsvvvl(v1, vr2, vr3, vr4, 256);
4921 }
4922
4923 void __attribute__((noinline))
4924 test_pvfmsb_vvsvl() {
4925   // CHECK-LABEL: @test_pvfmsb_vvsvl
4926   // CHECK: call <256 x double> @llvm.ve.vl.pvfmsb.vvsvl(<256 x double> %{{.*}}, i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
4927   vr4 = _vel_pvfmsb_vvsvl(vr1, v1, vr3, 256);
4928 }
4929
4930 void __attribute__((noinline))
4931 test_pvfmsb_vvsvvl() {
4932   // CHECK-LABEL: @test_pvfmsb_vvsvvl
4933   // CHECK: call <256 x double> @llvm.ve.vl.pvfmsb.vvsvvl(<256 x double> %{{.*}}, i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4934   vr4 = _vel_pvfmsb_vvsvvl(vr1, v1, vr3, vr4, 256);
4935 }
4936
4937 void __attribute__((noinline))
4938 test_pvfmsb_vvvvMvl() {
4939   // CHECK-LABEL: @test_pvfmsb_vvvvMvl
4940   // CHECK: call <256 x double> @llvm.ve.vl.pvfmsb.vvvvMvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4941   vr4 = _vel_pvfmsb_vvvvMvl(vr1, vr2, vr3, vm1_512, vr4, 256);
4942 }
4943
4944 void __attribute__((noinline))
4945 test_pvfmsb_vsvvMvl() {
4946   // CHECK-LABEL: @test_pvfmsb_vsvvMvl
4947   // CHECK: call <256 x double> @llvm.ve.vl.pvfmsb.vsvvMvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4948   vr4 = _vel_pvfmsb_vsvvMvl(v1, vr2, vr3, vm1_512, vr4, 256);
4949 }
4950
4951 void __attribute__((noinline))
4952 test_pvfmsb_vvsvMvl() {
4953   // CHECK-LABEL: @test_pvfmsb_vvsvMvl
4954   // CHECK: call <256 x double> @llvm.ve.vl.pvfmsb.vvsvMvl(<256 x double> %{{.*}}, i64 %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4955   vr4 = _vel_pvfmsb_vvsvMvl(vr1, v1, vr3, vm1_512, vr4, 256);
4956 }
4957
4958 void __attribute__((noinline))
4959 test_vfnmadd_vvvvl() {
4960   // CHECK-LABEL: @test_vfnmadd_vvvvl
4961   // CHECK: call <256 x double> @llvm.ve.vl.vfnmadd.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4962   vr4 = _vel_vfnmadd_vvvvl(vr1, vr2, vr3, 256);
4963 }
4964
4965 void __attribute__((noinline))
4966 test_vfnmadd_vvvvvl() {
4967   // CHECK-LABEL: @test_vfnmadd_vvvvvl
4968   // CHECK: call <256 x double> @llvm.ve.vl.vfnmadd.vvvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4969   vr4 = _vel_vfnmadd_vvvvvl(vr1, vr2, vr3, vr4, 256);
4970 }
4971
4972 void __attribute__((noinline))
4973 test_vfnmadd_vsvvl() {
4974   // CHECK-LABEL: @test_vfnmadd_vsvvl
4975   // CHECK: call <256 x double> @llvm.ve.vl.vfnmadd.vsvvl(double %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4976   vr4 = _vel_vfnmadd_vsvvl(vd1, vr2, vr3, 256);
4977 }
4978
4979 void __attribute__((noinline))
4980 test_vfnmadd_vsvvvl() {
4981   // CHECK-LABEL: @test_vfnmadd_vsvvvl
4982   // CHECK: call <256 x double> @llvm.ve.vl.vfnmadd.vsvvvl(double %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4983   vr4 = _vel_vfnmadd_vsvvvl(vd1, vr2, vr3, vr4, 256);
4984 }
4985
4986 void __attribute__((noinline))
4987 test_vfnmadd_vvsvl() {
4988   // CHECK-LABEL: @test_vfnmadd_vvsvl
4989   // CHECK: call <256 x double> @llvm.ve.vl.vfnmadd.vvsvl(<256 x double> %{{.*}}, double %{{.*}}, <256 x double> %{{.*}}, i32 256)
4990   vr4 = _vel_vfnmadd_vvsvl(vr1, vd1, vr3, 256);
4991 }
4992
4993 void __attribute__((noinline))
4994 test_vfnmadd_vvsvvl() {
4995   // CHECK-LABEL: @test_vfnmadd_vvsvvl
4996   // CHECK: call <256 x double> @llvm.ve.vl.vfnmadd.vvsvvl(<256 x double> %{{.*}}, double %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
4997   vr4 = _vel_vfnmadd_vvsvvl(vr1, vd1, vr3, vr4, 256);
4998 }
4999
5000 void __attribute__((noinline))
5001 test_vfnmadd_vvvvmvl() {
5002   // CHECK-LABEL: @test_vfnmadd_vvvvmvl
5003   // CHECK: call <256 x double> @llvm.ve.vl.vfnmadd.vvvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5004   vr4 = _vel_vfnmadd_vvvvmvl(vr1, vr2, vr3, vm1, vr4, 256);
5005 }
5006
5007 void __attribute__((noinline))
5008 test_vfnmadd_vsvvmvl() {
5009   // CHECK-LABEL: @test_vfnmadd_vsvvmvl
5010   // CHECK: call <256 x double> @llvm.ve.vl.vfnmadd.vsvvmvl(double %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5011   vr4 = _vel_vfnmadd_vsvvmvl(vd1, vr2, vr3, vm1, vr4, 256);
5012 }
5013
5014 void __attribute__((noinline))
5015 test_vfnmadd_vvsvmvl() {
5016   // CHECK-LABEL: @test_vfnmadd_vvsvmvl
5017   // CHECK: call <256 x double> @llvm.ve.vl.vfnmadd.vvsvmvl(<256 x double> %{{.*}}, double %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5018   vr4 = _vel_vfnmadd_vvsvmvl(vr1, vd1, vr3, vm1, vr4, 256);
5019 }
5020
5021 void __attribute__((noinline))
5022 test_vfnmads_vvvvl() {
5023   // CHECK-LABEL: @test_vfnmads_vvvvl
5024   // CHECK: call <256 x double> @llvm.ve.vl.vfnmads.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5025   vr4 = _vel_vfnmads_vvvvl(vr1, vr2, vr3, 256);
5026 }
5027
5028 void __attribute__((noinline))
5029 test_vfnmads_vvvvvl() {
5030   // CHECK-LABEL: @test_vfnmads_vvvvvl
5031   // CHECK: call <256 x double> @llvm.ve.vl.vfnmads.vvvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5032   vr4 = _vel_vfnmads_vvvvvl(vr1, vr2, vr3, vr4, 256);
5033 }
5034
5035 void __attribute__((noinline))
5036 test_vfnmads_vsvvl() {
5037   // CHECK-LABEL: @test_vfnmads_vsvvl
5038   // CHECK: call <256 x double> @llvm.ve.vl.vfnmads.vsvvl(float %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5039   vr4 = _vel_vfnmads_vsvvl(vf1, vr2, vr3, 256);
5040 }
5041
5042 void __attribute__((noinline))
5043 test_vfnmads_vsvvvl() {
5044   // CHECK-LABEL: @test_vfnmads_vsvvvl
5045   // CHECK: call <256 x double> @llvm.ve.vl.vfnmads.vsvvvl(float %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5046   vr4 = _vel_vfnmads_vsvvvl(vf1, vr2, vr3, vr4, 256);
5047 }
5048
5049 void __attribute__((noinline))
5050 test_vfnmads_vvsvl() {
5051   // CHECK-LABEL: @test_vfnmads_vvsvl
5052   // CHECK: call <256 x double> @llvm.ve.vl.vfnmads.vvsvl(<256 x double> %{{.*}}, float %{{.*}}, <256 x double> %{{.*}}, i32 256)
5053   vr4 = _vel_vfnmads_vvsvl(vr1, vf1, vr3, 256);
5054 }
5055
5056 void __attribute__((noinline))
5057 test_vfnmads_vvsvvl() {
5058   // CHECK-LABEL: @test_vfnmads_vvsvvl
5059   // CHECK: call <256 x double> @llvm.ve.vl.vfnmads.vvsvvl(<256 x double> %{{.*}}, float %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5060   vr4 = _vel_vfnmads_vvsvvl(vr1, vf1, vr3, vr4, 256);
5061 }
5062
5063 void __attribute__((noinline))
5064 test_vfnmads_vvvvmvl() {
5065   // CHECK-LABEL: @test_vfnmads_vvvvmvl
5066   // CHECK: call <256 x double> @llvm.ve.vl.vfnmads.vvvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5067   vr4 = _vel_vfnmads_vvvvmvl(vr1, vr2, vr3, vm1, vr4, 256);
5068 }
5069
5070 void __attribute__((noinline))
5071 test_vfnmads_vsvvmvl() {
5072   // CHECK-LABEL: @test_vfnmads_vsvvmvl
5073   // CHECK: call <256 x double> @llvm.ve.vl.vfnmads.vsvvmvl(float %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5074   vr4 = _vel_vfnmads_vsvvmvl(vf1, vr2, vr3, vm1, vr4, 256);
5075 }
5076
5077 void __attribute__((noinline))
5078 test_vfnmads_vvsvmvl() {
5079   // CHECK-LABEL: @test_vfnmads_vvsvmvl
5080   // CHECK: call <256 x double> @llvm.ve.vl.vfnmads.vvsvmvl(<256 x double> %{{.*}}, float %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5081   vr4 = _vel_vfnmads_vvsvmvl(vr1, vf1, vr3, vm1, vr4, 256);
5082 }
5083
5084 void __attribute__((noinline))
5085 test_pvfnmad_vvvvl() {
5086   // CHECK-LABEL: @test_pvfnmad_vvvvl
5087   // CHECK: call <256 x double> @llvm.ve.vl.pvfnmad.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5088   vr4 = _vel_pvfnmad_vvvvl(vr1, vr2, vr3, 256);
5089 }
5090
5091 void __attribute__((noinline))
5092 test_pvfnmad_vvvvvl() {
5093   // CHECK-LABEL: @test_pvfnmad_vvvvvl
5094   // CHECK: call <256 x double> @llvm.ve.vl.pvfnmad.vvvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5095   vr4 = _vel_pvfnmad_vvvvvl(vr1, vr2, vr3, vr4, 256);
5096 }
5097
5098 void __attribute__((noinline))
5099 test_pvfnmad_vsvvl() {
5100   // CHECK-LABEL: @test_pvfnmad_vsvvl
5101   // CHECK: call <256 x double> @llvm.ve.vl.pvfnmad.vsvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5102   vr4 = _vel_pvfnmad_vsvvl(v1, vr2, vr3, 256);
5103 }
5104
5105 void __attribute__((noinline))
5106 test_pvfnmad_vsvvvl() {
5107   // CHECK-LABEL: @test_pvfnmad_vsvvvl
5108   // CHECK: call <256 x double> @llvm.ve.vl.pvfnmad.vsvvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5109   vr4 = _vel_pvfnmad_vsvvvl(v1, vr2, vr3, vr4, 256);
5110 }
5111
5112 void __attribute__((noinline))
5113 test_pvfnmad_vvsvl() {
5114   // CHECK-LABEL: @test_pvfnmad_vvsvl
5115   // CHECK: call <256 x double> @llvm.ve.vl.pvfnmad.vvsvl(<256 x double> %{{.*}}, i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
5116   vr4 = _vel_pvfnmad_vvsvl(vr1, v1, vr3, 256);
5117 }
5118
5119 void __attribute__((noinline))
5120 test_pvfnmad_vvsvvl() {
5121   // CHECK-LABEL: @test_pvfnmad_vvsvvl
5122   // CHECK: call <256 x double> @llvm.ve.vl.pvfnmad.vvsvvl(<256 x double> %{{.*}}, i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5123   vr4 = _vel_pvfnmad_vvsvvl(vr1, v1, vr3, vr4, 256);
5124 }
5125
5126 void __attribute__((noinline))
5127 test_pvfnmad_vvvvMvl() {
5128   // CHECK-LABEL: @test_pvfnmad_vvvvMvl
5129   // CHECK: call <256 x double> @llvm.ve.vl.pvfnmad.vvvvMvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5130   vr4 = _vel_pvfnmad_vvvvMvl(vr1, vr2, vr3, vm1_512, vr4, 256);
5131 }
5132
5133 void __attribute__((noinline))
5134 test_pvfnmad_vsvvMvl() {
5135   // CHECK-LABEL: @test_pvfnmad_vsvvMvl
5136   // CHECK: call <256 x double> @llvm.ve.vl.pvfnmad.vsvvMvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5137   vr4 = _vel_pvfnmad_vsvvMvl(v1, vr2, vr3, vm1_512, vr4, 256);
5138 }
5139
5140 void __attribute__((noinline))
5141 test_pvfnmad_vvsvMvl() {
5142   // CHECK-LABEL: @test_pvfnmad_vvsvMvl
5143   // CHECK: call <256 x double> @llvm.ve.vl.pvfnmad.vvsvMvl(<256 x double> %{{.*}}, i64 %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5144   vr4 = _vel_pvfnmad_vvsvMvl(vr1, v1, vr3, vm1_512, vr4, 256);
5145 }
5146
5147 void __attribute__((noinline))
5148 test_vfnmsbd_vvvvl() {
5149   // CHECK-LABEL: @test_vfnmsbd_vvvvl
5150   // CHECK: call <256 x double> @llvm.ve.vl.vfnmsbd.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5151   vr4 = _vel_vfnmsbd_vvvvl(vr1, vr2, vr3, 256);
5152 }
5153
5154 void __attribute__((noinline))
5155 test_vfnmsbd_vvvvvl() {
5156   // CHECK-LABEL: @test_vfnmsbd_vvvvvl
5157   // CHECK: call <256 x double> @llvm.ve.vl.vfnmsbd.vvvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5158   vr4 = _vel_vfnmsbd_vvvvvl(vr1, vr2, vr3, vr4, 256);
5159 }
5160
5161 void __attribute__((noinline))
5162 test_vfnmsbd_vsvvl() {
5163   // CHECK-LABEL: @test_vfnmsbd_vsvvl
5164   // CHECK: call <256 x double> @llvm.ve.vl.vfnmsbd.vsvvl(double %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5165   vr4 = _vel_vfnmsbd_vsvvl(vd1, vr2, vr3, 256);
5166 }
5167
5168 void __attribute__((noinline))
5169 test_vfnmsbd_vsvvvl() {
5170   // CHECK-LABEL: @test_vfnmsbd_vsvvvl
5171   // CHECK: call <256 x double> @llvm.ve.vl.vfnmsbd.vsvvvl(double %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5172   vr4 = _vel_vfnmsbd_vsvvvl(vd1, vr2, vr3, vr4, 256);
5173 }
5174
5175 void __attribute__((noinline))
5176 test_vfnmsbd_vvsvl() {
5177   // CHECK-LABEL: @test_vfnmsbd_vvsvl
5178   // CHECK: call <256 x double> @llvm.ve.vl.vfnmsbd.vvsvl(<256 x double> %{{.*}}, double %{{.*}}, <256 x double> %{{.*}}, i32 256)
5179   vr4 = _vel_vfnmsbd_vvsvl(vr1, vd1, vr3, 256);
5180 }
5181
5182 void __attribute__((noinline))
5183 test_vfnmsbd_vvsvvl() {
5184   // CHECK-LABEL: @test_vfnmsbd_vvsvvl
5185   // CHECK: call <256 x double> @llvm.ve.vl.vfnmsbd.vvsvvl(<256 x double> %{{.*}}, double %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5186   vr4 = _vel_vfnmsbd_vvsvvl(vr1, vd1, vr3, vr4, 256);
5187 }
5188
5189 void __attribute__((noinline))
5190 test_vfnmsbd_vvvvmvl() {
5191   // CHECK-LABEL: @test_vfnmsbd_vvvvmvl
5192   // CHECK: call <256 x double> @llvm.ve.vl.vfnmsbd.vvvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5193   vr4 = _vel_vfnmsbd_vvvvmvl(vr1, vr2, vr3, vm1, vr4, 256);
5194 }
5195
5196 void __attribute__((noinline))
5197 test_vfnmsbd_vsvvmvl() {
5198   // CHECK-LABEL: @test_vfnmsbd_vsvvmvl
5199   // CHECK: call <256 x double> @llvm.ve.vl.vfnmsbd.vsvvmvl(double %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5200   vr4 = _vel_vfnmsbd_vsvvmvl(vd1, vr2, vr3, vm1, vr4, 256);
5201 }
5202
5203 void __attribute__((noinline))
5204 test_vfnmsbd_vvsvmvl() {
5205   // CHECK-LABEL: @test_vfnmsbd_vvsvmvl
5206   // CHECK: call <256 x double> @llvm.ve.vl.vfnmsbd.vvsvmvl(<256 x double> %{{.*}}, double %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5207   vr4 = _vel_vfnmsbd_vvsvmvl(vr1, vd1, vr3, vm1, vr4, 256);
5208 }
5209
5210 void __attribute__((noinline))
5211 test_vfnmsbs_vvvvl() {
5212   // CHECK-LABEL: @test_vfnmsbs_vvvvl
5213   // CHECK: call <256 x double> @llvm.ve.vl.vfnmsbs.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5214   vr4 = _vel_vfnmsbs_vvvvl(vr1, vr2, vr3, 256);
5215 }
5216
5217 void __attribute__((noinline))
5218 test_vfnmsbs_vvvvvl() {
5219   // CHECK-LABEL: @test_vfnmsbs_vvvvvl
5220   // CHECK: call <256 x double> @llvm.ve.vl.vfnmsbs.vvvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5221   vr4 = _vel_vfnmsbs_vvvvvl(vr1, vr2, vr3, vr4, 256);
5222 }
5223
5224 void __attribute__((noinline))
5225 test_vfnmsbs_vsvvl() {
5226   // CHECK-LABEL: @test_vfnmsbs_vsvvl
5227   // CHECK: call <256 x double> @llvm.ve.vl.vfnmsbs.vsvvl(float %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5228   vr4 = _vel_vfnmsbs_vsvvl(vf1, vr2, vr3, 256);
5229 }
5230
5231 void __attribute__((noinline))
5232 test_vfnmsbs_vsvvvl() {
5233   // CHECK-LABEL: @test_vfnmsbs_vsvvvl
5234   // CHECK: call <256 x double> @llvm.ve.vl.vfnmsbs.vsvvvl(float %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5235   vr4 = _vel_vfnmsbs_vsvvvl(vf1, vr2, vr3, vr4, 256);
5236 }
5237
5238 void __attribute__((noinline))
5239 test_vfnmsbs_vvsvl() {
5240   // CHECK-LABEL: @test_vfnmsbs_vvsvl
5241   // CHECK: call <256 x double> @llvm.ve.vl.vfnmsbs.vvsvl(<256 x double> %{{.*}}, float %{{.*}}, <256 x double> %{{.*}}, i32 256)
5242   vr4 = _vel_vfnmsbs_vvsvl(vr1, vf1, vr3, 256);
5243 }
5244
5245 void __attribute__((noinline))
5246 test_vfnmsbs_vvsvvl() {
5247   // CHECK-LABEL: @test_vfnmsbs_vvsvvl
5248   // CHECK: call <256 x double> @llvm.ve.vl.vfnmsbs.vvsvvl(<256 x double> %{{.*}}, float %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5249   vr4 = _vel_vfnmsbs_vvsvvl(vr1, vf1, vr3, vr4, 256);
5250 }
5251
5252 void __attribute__((noinline))
5253 test_vfnmsbs_vvvvmvl() {
5254   // CHECK-LABEL: @test_vfnmsbs_vvvvmvl
5255   // CHECK: call <256 x double> @llvm.ve.vl.vfnmsbs.vvvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5256   vr4 = _vel_vfnmsbs_vvvvmvl(vr1, vr2, vr3, vm1, vr4, 256);
5257 }
5258
5259 void __attribute__((noinline))
5260 test_vfnmsbs_vsvvmvl() {
5261   // CHECK-LABEL: @test_vfnmsbs_vsvvmvl
5262   // CHECK: call <256 x double> @llvm.ve.vl.vfnmsbs.vsvvmvl(float %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5263   vr4 = _vel_vfnmsbs_vsvvmvl(vf1, vr2, vr3, vm1, vr4, 256);
5264 }
5265
5266 void __attribute__((noinline))
5267 test_vfnmsbs_vvsvmvl() {
5268   // CHECK-LABEL: @test_vfnmsbs_vvsvmvl
5269   // CHECK: call <256 x double> @llvm.ve.vl.vfnmsbs.vvsvmvl(<256 x double> %{{.*}}, float %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5270   vr4 = _vel_vfnmsbs_vvsvmvl(vr1, vf1, vr3, vm1, vr4, 256);
5271 }
5272
5273 void __attribute__((noinline))
5274 test_pvfnmsb_vvvvl() {
5275   // CHECK-LABEL: @test_pvfnmsb_vvvvl
5276   // CHECK: call <256 x double> @llvm.ve.vl.pvfnmsb.vvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5277   vr4 = _vel_pvfnmsb_vvvvl(vr1, vr2, vr3, 256);
5278 }
5279
5280 void __attribute__((noinline))
5281 test_pvfnmsb_vvvvvl() {
5282   // CHECK-LABEL: @test_pvfnmsb_vvvvvl
5283   // CHECK: call <256 x double> @llvm.ve.vl.pvfnmsb.vvvvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5284   vr4 = _vel_pvfnmsb_vvvvvl(vr1, vr2, vr3, vr4, 256);
5285 }
5286
5287 void __attribute__((noinline))
5288 test_pvfnmsb_vsvvl() {
5289   // CHECK-LABEL: @test_pvfnmsb_vsvvl
5290   // CHECK: call <256 x double> @llvm.ve.vl.pvfnmsb.vsvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5291   vr4 = _vel_pvfnmsb_vsvvl(v1, vr2, vr3, 256);
5292 }
5293
5294 void __attribute__((noinline))
5295 test_pvfnmsb_vsvvvl() {
5296   // CHECK-LABEL: @test_pvfnmsb_vsvvvl
5297   // CHECK: call <256 x double> @llvm.ve.vl.pvfnmsb.vsvvvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5298   vr4 = _vel_pvfnmsb_vsvvvl(v1, vr2, vr3, vr4, 256);
5299 }
5300
5301 void __attribute__((noinline))
5302 test_pvfnmsb_vvsvl() {
5303   // CHECK-LABEL: @test_pvfnmsb_vvsvl
5304   // CHECK: call <256 x double> @llvm.ve.vl.pvfnmsb.vvsvl(<256 x double> %{{.*}}, i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
5305   vr4 = _vel_pvfnmsb_vvsvl(vr1, v1, vr3, 256);
5306 }
5307
5308 void __attribute__((noinline))
5309 test_pvfnmsb_vvsvvl() {
5310   // CHECK-LABEL: @test_pvfnmsb_vvsvvl
5311   // CHECK: call <256 x double> @llvm.ve.vl.pvfnmsb.vvsvvl(<256 x double> %{{.*}}, i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5312   vr4 = _vel_pvfnmsb_vvsvvl(vr1, v1, vr3, vr4, 256);
5313 }
5314
5315 void __attribute__((noinline))
5316 test_pvfnmsb_vvvvMvl() {
5317   // CHECK-LABEL: @test_pvfnmsb_vvvvMvl
5318   // CHECK: call <256 x double> @llvm.ve.vl.pvfnmsb.vvvvMvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5319   vr4 = _vel_pvfnmsb_vvvvMvl(vr1, vr2, vr3, vm1_512, vr4, 256);
5320 }
5321
5322 void __attribute__((noinline))
5323 test_pvfnmsb_vsvvMvl() {
5324   // CHECK-LABEL: @test_pvfnmsb_vsvvMvl
5325   // CHECK: call <256 x double> @llvm.ve.vl.pvfnmsb.vsvvMvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5326   vr4 = _vel_pvfnmsb_vsvvMvl(v1, vr2, vr3, vm1_512, vr4, 256);
5327 }
5328
5329 void __attribute__((noinline))
5330 test_pvfnmsb_vvsvMvl() {
5331   // CHECK-LABEL: @test_pvfnmsb_vvsvMvl
5332   // CHECK: call <256 x double> @llvm.ve.vl.pvfnmsb.vvsvMvl(<256 x double> %{{.*}}, i64 %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5333   vr4 = _vel_pvfnmsb_vvsvMvl(vr1, v1, vr3, vm1_512, vr4, 256);
5334 }
5335
5336 void __attribute__((noinline))
5337 test_vrcpd_vvl() {
5338   // CHECK-LABEL: @test_vrcpd_vvl
5339   // CHECK: call <256 x double> @llvm.ve.vl.vrcpd.vvl(<256 x double> %{{.*}}, i32 256)
5340   vr2 = _vel_vrcpd_vvl(vr1, 256);
5341 }
5342
5343 void __attribute__((noinline))
5344 test_vrcpd_vvvl() {
5345   // CHECK-LABEL: @test_vrcpd_vvvl
5346   // CHECK: call <256 x double> @llvm.ve.vl.vrcpd.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5347   vr3 = _vel_vrcpd_vvvl(vr1, vr2, 256);
5348 }
5349
5350 void __attribute__((noinline))
5351 test_vrcps_vvl() {
5352   // CHECK-LABEL: @test_vrcps_vvl
5353   // CHECK: call <256 x double> @llvm.ve.vl.vrcps.vvl(<256 x double> %{{.*}}, i32 256)
5354   vr2 = _vel_vrcps_vvl(vr1, 256);
5355 }
5356
5357 void __attribute__((noinline))
5358 test_vrcps_vvvl() {
5359   // CHECK-LABEL: @test_vrcps_vvvl
5360   // CHECK: call <256 x double> @llvm.ve.vl.vrcps.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5361   vr3 = _vel_vrcps_vvvl(vr1, vr2, 256);
5362 }
5363
5364 void __attribute__((noinline))
5365 test_pvrcp_vvl() {
5366   // CHECK-LABEL: @test_pvrcp_vvl
5367   // CHECK: call <256 x double> @llvm.ve.vl.pvrcp.vvl(<256 x double> %{{.*}}, i32 256)
5368   vr2 = _vel_pvrcp_vvl(vr1, 256);
5369 }
5370
5371 void __attribute__((noinline))
5372 test_pvrcp_vvvl() {
5373   // CHECK-LABEL: @test_pvrcp_vvvl
5374   // CHECK: call <256 x double> @llvm.ve.vl.pvrcp.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5375   vr3 = _vel_pvrcp_vvvl(vr1, vr2, 256);
5376 }
5377
5378 void __attribute__((noinline))
5379 test_vrsqrtd_vvl() {
5380   // CHECK-LABEL: @test_vrsqrtd_vvl
5381   // CHECK: call <256 x double> @llvm.ve.vl.vrsqrtd.vvl(<256 x double> %{{.*}}, i32 256)
5382   vr2 = _vel_vrsqrtd_vvl(vr1, 256);
5383 }
5384
5385 void __attribute__((noinline))
5386 test_vrsqrtd_vvvl() {
5387   // CHECK-LABEL: @test_vrsqrtd_vvvl
5388   // CHECK: call <256 x double> @llvm.ve.vl.vrsqrtd.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5389   vr3 = _vel_vrsqrtd_vvvl(vr1, vr2, 256);
5390 }
5391
5392 void __attribute__((noinline))
5393 test_vrsqrts_vvl() {
5394   // CHECK-LABEL: @test_vrsqrts_vvl
5395   // CHECK: call <256 x double> @llvm.ve.vl.vrsqrts.vvl(<256 x double> %{{.*}}, i32 256)
5396   vr2 = _vel_vrsqrts_vvl(vr1, 256);
5397 }
5398
5399 void __attribute__((noinline))
5400 test_vrsqrts_vvvl() {
5401   // CHECK-LABEL: @test_vrsqrts_vvvl
5402   // CHECK: call <256 x double> @llvm.ve.vl.vrsqrts.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5403   vr3 = _vel_vrsqrts_vvvl(vr1, vr2, 256);
5404 }
5405
5406 void __attribute__((noinline))
5407 test_pvrsqrt_vvl() {
5408   // CHECK-LABEL: @test_pvrsqrt_vvl
5409   // CHECK: call <256 x double> @llvm.ve.vl.pvrsqrt.vvl(<256 x double> %{{.*}}, i32 256)
5410   vr2 = _vel_pvrsqrt_vvl(vr1, 256);
5411 }
5412
5413 void __attribute__((noinline))
5414 test_pvrsqrt_vvvl() {
5415   // CHECK-LABEL: @test_pvrsqrt_vvvl
5416   // CHECK: call <256 x double> @llvm.ve.vl.pvrsqrt.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5417   vr3 = _vel_pvrsqrt_vvvl(vr1, vr2, 256);
5418 }
5419
5420 void __attribute__((noinline))
5421 test_vrsqrtdnex_vvl() {
5422   // CHECK-LABEL: @test_vrsqrtdnex_vvl
5423   // CHECK: call <256 x double> @llvm.ve.vl.vrsqrtdnex.vvl(<256 x double> %{{.*}}, i32 256)
5424   vr2 = _vel_vrsqrtdnex_vvl(vr1, 256);
5425 }
5426
5427 void __attribute__((noinline))
5428 test_vrsqrtdnex_vvvl() {
5429   // CHECK-LABEL: @test_vrsqrtdnex_vvvl
5430   // CHECK: call <256 x double> @llvm.ve.vl.vrsqrtdnex.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5431   vr3 = _vel_vrsqrtdnex_vvvl(vr1, vr2, 256);
5432 }
5433
5434 void __attribute__((noinline))
5435 test_vrsqrtsnex_vvl() {
5436   // CHECK-LABEL: @test_vrsqrtsnex_vvl
5437   // CHECK: call <256 x double> @llvm.ve.vl.vrsqrtsnex.vvl(<256 x double> %{{.*}}, i32 256)
5438   vr2 = _vel_vrsqrtsnex_vvl(vr1, 256);
5439 }
5440
5441 void __attribute__((noinline))
5442 test_vrsqrtsnex_vvvl() {
5443   // CHECK-LABEL: @test_vrsqrtsnex_vvvl
5444   // CHECK: call <256 x double> @llvm.ve.vl.vrsqrtsnex.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5445   vr3 = _vel_vrsqrtsnex_vvvl(vr1, vr2, 256);
5446 }
5447
5448 void __attribute__((noinline))
5449 test_pvrsqrtnex_vvl() {
5450   // CHECK-LABEL: @test_pvrsqrtnex_vvl
5451   // CHECK: call <256 x double> @llvm.ve.vl.pvrsqrtnex.vvl(<256 x double> %{{.*}}, i32 256)
5452   vr2 = _vel_pvrsqrtnex_vvl(vr1, 256);
5453 }
5454
5455 void __attribute__((noinline))
5456 test_pvrsqrtnex_vvvl() {
5457   // CHECK-LABEL: @test_pvrsqrtnex_vvvl
5458   // CHECK: call <256 x double> @llvm.ve.vl.pvrsqrtnex.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5459   vr3 = _vel_pvrsqrtnex_vvvl(vr1, vr2, 256);
5460 }
5461
5462 void __attribute__((noinline))
5463 test_vcvtwdsx_vvl() {
5464   // CHECK-LABEL: @test_vcvtwdsx_vvl
5465   // CHECK: call <256 x double> @llvm.ve.vl.vcvtwdsx.vvl(<256 x double> %{{.*}}, i32 256)
5466   vr2 = _vel_vcvtwdsx_vvl(vr1, 256);
5467 }
5468
5469 void __attribute__((noinline))
5470 test_vcvtwdsx_vvvl() {
5471   // CHECK-LABEL: @test_vcvtwdsx_vvvl
5472   // CHECK: call <256 x double> @llvm.ve.vl.vcvtwdsx.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5473   vr3 = _vel_vcvtwdsx_vvvl(vr1, vr2, 256);
5474 }
5475
5476 void __attribute__((noinline))
5477 test_vcvtwdsx_vvmvl() {
5478   // CHECK-LABEL: @test_vcvtwdsx_vvmvl
5479   // CHECK: call <256 x double> @llvm.ve.vl.vcvtwdsx.vvmvl(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5480   vr3 = _vel_vcvtwdsx_vvmvl(vr1, vm1, vr2, 256);
5481 }
5482
5483 void __attribute__((noinline))
5484 test_vcvtwdsxrz_vvl() {
5485   // CHECK-LABEL: @test_vcvtwdsxrz_vvl
5486   // CHECK: call <256 x double> @llvm.ve.vl.vcvtwdsxrz.vvl(<256 x double> %{{.*}}, i32 256)
5487   vr2 = _vel_vcvtwdsxrz_vvl(vr1, 256);
5488 }
5489
5490 void __attribute__((noinline))
5491 test_vcvtwdsxrz_vvvl() {
5492   // CHECK-LABEL: @test_vcvtwdsxrz_vvvl
5493   // CHECK: call <256 x double> @llvm.ve.vl.vcvtwdsxrz.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5494   vr3 = _vel_vcvtwdsxrz_vvvl(vr1, vr2, 256);
5495 }
5496
5497 void __attribute__((noinline))
5498 test_vcvtwdsxrz_vvmvl() {
5499   // CHECK-LABEL: @test_vcvtwdsxrz_vvmvl
5500   // CHECK: call <256 x double> @llvm.ve.vl.vcvtwdsxrz.vvmvl(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5501   vr3 = _vel_vcvtwdsxrz_vvmvl(vr1, vm1, vr2, 256);
5502 }
5503
5504 void __attribute__((noinline))
5505 test_vcvtwdzx_vvl() {
5506   // CHECK-LABEL: @test_vcvtwdzx_vvl
5507   // CHECK: call <256 x double> @llvm.ve.vl.vcvtwdzx.vvl(<256 x double> %{{.*}}, i32 256)
5508   vr2 = _vel_vcvtwdzx_vvl(vr1, 256);
5509 }
5510
5511 void __attribute__((noinline))
5512 test_vcvtwdzx_vvvl() {
5513   // CHECK-LABEL: @test_vcvtwdzx_vvvl
5514   // CHECK: call <256 x double> @llvm.ve.vl.vcvtwdzx.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5515   vr3 = _vel_vcvtwdzx_vvvl(vr1, vr2, 256);
5516 }
5517
5518 void __attribute__((noinline))
5519 test_vcvtwdzx_vvmvl() {
5520   // CHECK-LABEL: @test_vcvtwdzx_vvmvl
5521   // CHECK: call <256 x double> @llvm.ve.vl.vcvtwdzx.vvmvl(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5522   vr3 = _vel_vcvtwdzx_vvmvl(vr1, vm1, vr2, 256);
5523 }
5524
5525 void __attribute__((noinline))
5526 test_vcvtwdzxrz_vvl() {
5527   // CHECK-LABEL: @test_vcvtwdzxrz_vvl
5528   // CHECK: call <256 x double> @llvm.ve.vl.vcvtwdzxrz.vvl(<256 x double> %{{.*}}, i32 256)
5529   vr2 = _vel_vcvtwdzxrz_vvl(vr1, 256);
5530 }
5531
5532 void __attribute__((noinline))
5533 test_vcvtwdzxrz_vvvl() {
5534   // CHECK-LABEL: @test_vcvtwdzxrz_vvvl
5535   // CHECK: call <256 x double> @llvm.ve.vl.vcvtwdzxrz.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5536   vr3 = _vel_vcvtwdzxrz_vvvl(vr1, vr2, 256);
5537 }
5538
5539 void __attribute__((noinline))
5540 test_vcvtwdzxrz_vvmvl() {
5541   // CHECK-LABEL: @test_vcvtwdzxrz_vvmvl
5542   // CHECK: call <256 x double> @llvm.ve.vl.vcvtwdzxrz.vvmvl(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5543   vr3 = _vel_vcvtwdzxrz_vvmvl(vr1, vm1, vr2, 256);
5544 }
5545
5546 void __attribute__((noinline))
5547 test_vcvtwssx_vvl() {
5548   // CHECK-LABEL: @test_vcvtwssx_vvl
5549   // CHECK: call <256 x double> @llvm.ve.vl.vcvtwssx.vvl(<256 x double> %{{.*}}, i32 256)
5550   vr2 = _vel_vcvtwssx_vvl(vr1, 256);
5551 }
5552
5553 void __attribute__((noinline))
5554 test_vcvtwssx_vvvl() {
5555   // CHECK-LABEL: @test_vcvtwssx_vvvl
5556   // CHECK: call <256 x double> @llvm.ve.vl.vcvtwssx.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5557   vr3 = _vel_vcvtwssx_vvvl(vr1, vr2, 256);
5558 }
5559
5560 void __attribute__((noinline))
5561 test_vcvtwssx_vvmvl() {
5562   // CHECK-LABEL: @test_vcvtwssx_vvmvl
5563   // CHECK: call <256 x double> @llvm.ve.vl.vcvtwssx.vvmvl(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5564   vr3 = _vel_vcvtwssx_vvmvl(vr1, vm1, vr2, 256);
5565 }
5566
5567 void __attribute__((noinline))
5568 test_vcvtwssxrz_vvl() {
5569   // CHECK-LABEL: @test_vcvtwssxrz_vvl
5570   // CHECK: call <256 x double> @llvm.ve.vl.vcvtwssxrz.vvl(<256 x double> %{{.*}}, i32 256)
5571   vr2 = _vel_vcvtwssxrz_vvl(vr1, 256);
5572 }
5573
5574 void __attribute__((noinline))
5575 test_vcvtwssxrz_vvvl() {
5576   // CHECK-LABEL: @test_vcvtwssxrz_vvvl
5577   // CHECK: call <256 x double> @llvm.ve.vl.vcvtwssxrz.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5578   vr3 = _vel_vcvtwssxrz_vvvl(vr1, vr2, 256);
5579 }
5580
5581 void __attribute__((noinline))
5582 test_vcvtwssxrz_vvmvl() {
5583   // CHECK-LABEL: @test_vcvtwssxrz_vvmvl
5584   // CHECK: call <256 x double> @llvm.ve.vl.vcvtwssxrz.vvmvl(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5585   vr3 = _vel_vcvtwssxrz_vvmvl(vr1, vm1, vr2, 256);
5586 }
5587
5588 void __attribute__((noinline))
5589 test_vcvtwszx_vvl() {
5590   // CHECK-LABEL: @test_vcvtwszx_vvl
5591   // CHECK: call <256 x double> @llvm.ve.vl.vcvtwszx.vvl(<256 x double> %{{.*}}, i32 256)
5592   vr2 = _vel_vcvtwszx_vvl(vr1, 256);
5593 }
5594
5595 void __attribute__((noinline))
5596 test_vcvtwszx_vvvl() {
5597   // CHECK-LABEL: @test_vcvtwszx_vvvl
5598   // CHECK: call <256 x double> @llvm.ve.vl.vcvtwszx.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5599   vr3 = _vel_vcvtwszx_vvvl(vr1, vr2, 256);
5600 }
5601
5602 void __attribute__((noinline))
5603 test_vcvtwszx_vvmvl() {
5604   // CHECK-LABEL: @test_vcvtwszx_vvmvl
5605   // CHECK: call <256 x double> @llvm.ve.vl.vcvtwszx.vvmvl(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5606   vr3 = _vel_vcvtwszx_vvmvl(vr1, vm1, vr2, 256);
5607 }
5608
5609 void __attribute__((noinline))
5610 test_vcvtwszxrz_vvl() {
5611   // CHECK-LABEL: @test_vcvtwszxrz_vvl
5612   // CHECK: call <256 x double> @llvm.ve.vl.vcvtwszxrz.vvl(<256 x double> %{{.*}}, i32 256)
5613   vr2 = _vel_vcvtwszxrz_vvl(vr1, 256);
5614 }
5615
5616 void __attribute__((noinline))
5617 test_vcvtwszxrz_vvvl() {
5618   // CHECK-LABEL: @test_vcvtwszxrz_vvvl
5619   // CHECK: call <256 x double> @llvm.ve.vl.vcvtwszxrz.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5620   vr3 = _vel_vcvtwszxrz_vvvl(vr1, vr2, 256);
5621 }
5622
5623 void __attribute__((noinline))
5624 test_vcvtwszxrz_vvmvl() {
5625   // CHECK-LABEL: @test_vcvtwszxrz_vvmvl
5626   // CHECK: call <256 x double> @llvm.ve.vl.vcvtwszxrz.vvmvl(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5627   vr3 = _vel_vcvtwszxrz_vvmvl(vr1, vm1, vr2, 256);
5628 }
5629
5630 void __attribute__((noinline))
5631 test_pvcvtws_vvl() {
5632   // CHECK-LABEL: @test_pvcvtws_vvl
5633   // CHECK: call <256 x double> @llvm.ve.vl.pvcvtws.vvl(<256 x double> %{{.*}}, i32 256)
5634   vr2 = _vel_pvcvtws_vvl(vr1, 256);
5635 }
5636
5637 void __attribute__((noinline))
5638 test_pvcvtws_vvvl() {
5639   // CHECK-LABEL: @test_pvcvtws_vvvl
5640   // CHECK: call <256 x double> @llvm.ve.vl.pvcvtws.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5641   vr3 = _vel_pvcvtws_vvvl(vr1, vr2, 256);
5642 }
5643
5644 void __attribute__((noinline))
5645 test_pvcvtws_vvMvl() {
5646   // CHECK-LABEL: @test_pvcvtws_vvMvl
5647   // CHECK: call <256 x double> @llvm.ve.vl.pvcvtws.vvMvl(<256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5648   vr3 = _vel_pvcvtws_vvMvl(vr1, vm1_512, vr2, 256);
5649 }
5650
5651 void __attribute__((noinline))
5652 test_pvcvtwsrz_vvl() {
5653   // CHECK-LABEL: @test_pvcvtwsrz_vvl
5654   // CHECK: call <256 x double> @llvm.ve.vl.pvcvtwsrz.vvl(<256 x double> %{{.*}}, i32 256)
5655   vr2 = _vel_pvcvtwsrz_vvl(vr1, 256);
5656 }
5657
5658 void __attribute__((noinline))
5659 test_pvcvtwsrz_vvvl() {
5660   // CHECK-LABEL: @test_pvcvtwsrz_vvvl
5661   // CHECK: call <256 x double> @llvm.ve.vl.pvcvtwsrz.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5662   vr3 = _vel_pvcvtwsrz_vvvl(vr1, vr2, 256);
5663 }
5664
5665 void __attribute__((noinline))
5666 test_pvcvtwsrz_vvMvl() {
5667   // CHECK-LABEL: @test_pvcvtwsrz_vvMvl
5668   // CHECK: call <256 x double> @llvm.ve.vl.pvcvtwsrz.vvMvl(<256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5669   vr3 = _vel_pvcvtwsrz_vvMvl(vr1, vm1_512, vr2, 256);
5670 }
5671
5672 void __attribute__((noinline))
5673 test_vcvtld_vvl() {
5674   // CHECK-LABEL: @test_vcvtld_vvl
5675   // CHECK: call <256 x double> @llvm.ve.vl.vcvtld.vvl(<256 x double> %{{.*}}, i32 256)
5676   vr2 = _vel_vcvtld_vvl(vr1, 256);
5677 }
5678
5679 void __attribute__((noinline))
5680 test_vcvtld_vvvl() {
5681   // CHECK-LABEL: @test_vcvtld_vvvl
5682   // CHECK: call <256 x double> @llvm.ve.vl.vcvtld.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5683   vr3 = _vel_vcvtld_vvvl(vr1, vr2, 256);
5684 }
5685
5686 void __attribute__((noinline))
5687 test_vcvtld_vvmvl() {
5688   // CHECK-LABEL: @test_vcvtld_vvmvl
5689   // CHECK: call <256 x double> @llvm.ve.vl.vcvtld.vvmvl(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5690   vr3 = _vel_vcvtld_vvmvl(vr1, vm1, vr2, 256);
5691 }
5692
5693 void __attribute__((noinline))
5694 test_vcvtldrz_vvl() {
5695   // CHECK-LABEL: @test_vcvtldrz_vvl
5696   // CHECK: call <256 x double> @llvm.ve.vl.vcvtldrz.vvl(<256 x double> %{{.*}}, i32 256)
5697   vr2 = _vel_vcvtldrz_vvl(vr1, 256);
5698 }
5699
5700 void __attribute__((noinline))
5701 test_vcvtldrz_vvvl() {
5702   // CHECK-LABEL: @test_vcvtldrz_vvvl
5703   // CHECK: call <256 x double> @llvm.ve.vl.vcvtldrz.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5704   vr3 = _vel_vcvtldrz_vvvl(vr1, vr2, 256);
5705 }
5706
5707 void __attribute__((noinline))
5708 test_vcvtldrz_vvmvl() {
5709   // CHECK-LABEL: @test_vcvtldrz_vvmvl
5710   // CHECK: call <256 x double> @llvm.ve.vl.vcvtldrz.vvmvl(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5711   vr3 = _vel_vcvtldrz_vvmvl(vr1, vm1, vr2, 256);
5712 }
5713
5714 void __attribute__((noinline))
5715 test_vcvtdw_vvl() {
5716   // CHECK-LABEL: @test_vcvtdw_vvl
5717   // CHECK: call <256 x double> @llvm.ve.vl.vcvtdw.vvl(<256 x double> %{{.*}}, i32 256)
5718   vr2 = _vel_vcvtdw_vvl(vr1, 256);
5719 }
5720
5721 void __attribute__((noinline))
5722 test_vcvtdw_vvvl() {
5723   // CHECK-LABEL: @test_vcvtdw_vvvl
5724   // CHECK: call <256 x double> @llvm.ve.vl.vcvtdw.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5725   vr3 = _vel_vcvtdw_vvvl(vr1, vr2, 256);
5726 }
5727
5728 void __attribute__((noinline))
5729 test_vcvtsw_vvl() {
5730   // CHECK-LABEL: @test_vcvtsw_vvl
5731   // CHECK: call <256 x double> @llvm.ve.vl.vcvtsw.vvl(<256 x double> %{{.*}}, i32 256)
5732   vr2 = _vel_vcvtsw_vvl(vr1, 256);
5733 }
5734
5735 void __attribute__((noinline))
5736 test_vcvtsw_vvvl() {
5737   // CHECK-LABEL: @test_vcvtsw_vvvl
5738   // CHECK: call <256 x double> @llvm.ve.vl.vcvtsw.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5739   vr3 = _vel_vcvtsw_vvvl(vr1, vr2, 256);
5740 }
5741
5742 void __attribute__((noinline))
5743 test_pvcvtsw_vvl() {
5744   // CHECK-LABEL: @test_pvcvtsw_vvl
5745   // CHECK: call <256 x double> @llvm.ve.vl.pvcvtsw.vvl(<256 x double> %{{.*}}, i32 256)
5746   vr2 = _vel_pvcvtsw_vvl(vr1, 256);
5747 }
5748
5749 void __attribute__((noinline))
5750 test_pvcvtsw_vvvl() {
5751   // CHECK-LABEL: @test_pvcvtsw_vvvl
5752   // CHECK: call <256 x double> @llvm.ve.vl.pvcvtsw.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5753   vr3 = _vel_pvcvtsw_vvvl(vr1, vr2, 256);
5754 }
5755
5756 void __attribute__((noinline))
5757 test_vcvtdl_vvl() {
5758   // CHECK-LABEL: @test_vcvtdl_vvl
5759   // CHECK: call <256 x double> @llvm.ve.vl.vcvtdl.vvl(<256 x double> %{{.*}}, i32 256)
5760   vr2 = _vel_vcvtdl_vvl(vr1, 256);
5761 }
5762
5763 void __attribute__((noinline))
5764 test_vcvtdl_vvvl() {
5765   // CHECK-LABEL: @test_vcvtdl_vvvl
5766   // CHECK: call <256 x double> @llvm.ve.vl.vcvtdl.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5767   vr3 = _vel_vcvtdl_vvvl(vr1, vr2, 256);
5768 }
5769
5770 void __attribute__((noinline))
5771 test_vcvtds_vvl() {
5772   // CHECK-LABEL: @test_vcvtds_vvl
5773   // CHECK: call <256 x double> @llvm.ve.vl.vcvtds.vvl(<256 x double> %{{.*}}, i32 256)
5774   vr2 = _vel_vcvtds_vvl(vr1, 256);
5775 }
5776
5777 void __attribute__((noinline))
5778 test_vcvtds_vvvl() {
5779   // CHECK-LABEL: @test_vcvtds_vvvl
5780   // CHECK: call <256 x double> @llvm.ve.vl.vcvtds.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5781   vr3 = _vel_vcvtds_vvvl(vr1, vr2, 256);
5782 }
5783
5784 void __attribute__((noinline))
5785 test_vcvtsd_vvl() {
5786   // CHECK-LABEL: @test_vcvtsd_vvl
5787   // CHECK: call <256 x double> @llvm.ve.vl.vcvtsd.vvl(<256 x double> %{{.*}}, i32 256)
5788   vr2 = _vel_vcvtsd_vvl(vr1, 256);
5789 }
5790
5791 void __attribute__((noinline))
5792 test_vcvtsd_vvvl() {
5793   // CHECK-LABEL: @test_vcvtsd_vvvl
5794   // CHECK: call <256 x double> @llvm.ve.vl.vcvtsd.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5795   vr3 = _vel_vcvtsd_vvvl(vr1, vr2, 256);
5796 }
5797
5798 void __attribute__((noinline))
5799 test_vmrg_vvvml() {
5800   // CHECK-LABEL: @test_vmrg_vvvml
5801   // CHECK: call <256 x double> @llvm.ve.vl.vmrg.vvvml(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 256)
5802   vr3 = _vel_vmrg_vvvml(vr1, vr2, vm1, 256);
5803 }
5804
5805 void __attribute__((noinline))
5806 test_vmrg_vvvmvl() {
5807   // CHECK-LABEL: @test_vmrg_vvvmvl
5808   // CHECK: call <256 x double> @llvm.ve.vl.vmrg.vvvmvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5809   vr3 = _vel_vmrg_vvvmvl(vr1, vr2, vm1, vr3, 256);
5810 }
5811
5812 void __attribute__((noinline))
5813 test_vmrg_vsvml() {
5814   // CHECK-LABEL: @test_vmrg_vsvml
5815   // CHECK: call <256 x double> @llvm.ve.vl.vmrg.vsvml(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 256)
5816   vr3 = _vel_vmrg_vsvml(v1, vr2, vm1, 256);
5817 }
5818
5819 void __attribute__((noinline))
5820 test_vmrg_vsvmvl() {
5821   // CHECK-LABEL: @test_vmrg_vsvmvl
5822   // CHECK: call <256 x double> @llvm.ve.vl.vmrg.vsvmvl(i64 %{{.*}}, <256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5823   vr3 = _vel_vmrg_vsvmvl(v1, vr2, vm1, vr3, 256);
5824 }
5825
5826 void __attribute__((noinline))
5827 test_vmrgw_vvvMl() {
5828   // CHECK-LABEL: @test_vmrgw_vvvMl
5829   // CHECK: call <256 x double> @llvm.ve.vl.vmrgw.vvvMl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, i32 256)
5830   vr3 = _vel_vmrgw_vvvMl(vr1, vr2, vm1_512, 256);
5831 }
5832
5833 void __attribute__((noinline))
5834 test_vmrgw_vvvMvl() {
5835   // CHECK-LABEL: @test_vmrgw_vvvMvl
5836   // CHECK: call <256 x double> @llvm.ve.vl.vmrgw.vvvMvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5837   vr3 = _vel_vmrgw_vvvMvl(vr1, vr2, vm1_512, vr3, 256);
5838 }
5839
5840 void __attribute__((noinline))
5841 test_vmrgw_vsvMl() {
5842   // CHECK-LABEL: @test_vmrgw_vsvMl
5843   // CHECK: call <256 x double> @llvm.ve.vl.vmrgw.vsvMl(i32 %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, i32 256)
5844   vr3 = _vel_vmrgw_vsvMl(v1, vr2, vm1_512, 256);
5845 }
5846
5847 void __attribute__((noinline))
5848 test_vmrgw_vsvMvl() {
5849   // CHECK-LABEL: @test_vmrgw_vsvMvl
5850   // CHECK: call <256 x double> @llvm.ve.vl.vmrgw.vsvMvl(i32 %{{.*}}, <256 x double> %{{.*}}, <512 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5851   vr3 = _vel_vmrgw_vsvMvl(v1, vr2, vm1_512, vr3, 256);
5852 }
5853
5854 void __attribute__((noinline))
5855 test_vshf_vvvsl() {
5856   // CHECK-LABEL: @test_vshf_vvvsl
5857   // CHECK: call <256 x double> @llvm.ve.vl.vshf.vvvsl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i64 %{{.*}}, i32 256)
5858   vr3 = _vel_vshf_vvvsl(vr1, vr2, v1, 256);
5859 }
5860
5861 void __attribute__((noinline))
5862 test_vshf_vvvsvl() {
5863   // CHECK-LABEL: @test_vshf_vvvsvl
5864   // CHECK: call <256 x double> @llvm.ve.vl.vshf.vvvsvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
5865   vr3 = _vel_vshf_vvvsvl(vr1, vr2, v1, vr3, 256);
5866 }
5867
5868 void __attribute__((noinline))
5869 test_vcp_vvmvl() {
5870   // CHECK-LABEL: @test_vcp_vvmvl
5871   // CHECK: call <256 x double> @llvm.ve.vl.vcp.vvmvl(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5872   vr3 = _vel_vcp_vvmvl(vr1, vm1, vr2, 256);
5873 }
5874
5875 void __attribute__((noinline))
5876 test_vex_vvmvl() {
5877   // CHECK-LABEL: @test_vex_vvmvl
5878   // CHECK: call <256 x double> @llvm.ve.vl.vex.vvmvl(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
5879   vr3 = _vel_vex_vvmvl(vr1, vm1, vr2, 256);
5880 }
5881
5882 void __attribute__((noinline))
5883 test_vfmklat_ml(int vl) {
5884   // CHECK-LABEL: @test_vfmklat_ml
5885   // CHECK: call <256 x i1> @llvm.ve.vl.vfmklat.ml(i32 %{{.*}})
5886   vm1 = _vel_vfmklat_ml(vl);
5887 }
5888
5889 void __attribute__((noinline))
5890 test_vfmklaf_ml(int vl) {
5891   // CHECK-LABEL: @test_vfmklaf_ml
5892   // CHECK: call <256 x i1> @llvm.ve.vl.vfmklaf.ml(i32 %{{.*}})
5893   vm1 = _vel_vfmklaf_ml(vl);
5894 }
5895
5896 void __attribute__((noinline))
5897 test_pvfmkat_Ml(int vl) {
5898   // CHECK-LABEL: @test_pvfmkat_Ml
5899   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmkat.Ml(i32 %{{.*}})
5900   vm1_512 = _vel_pvfmkat_Ml(vl);
5901 }
5902
5903 void __attribute__((noinline))
5904 test_pvfmkaf_Ml(int vl) {
5905   // CHECK-LABEL: @test_pvfmkaf_Ml
5906   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmkaf.Ml(i32 %{{.*}})
5907   vm1_512 = _vel_pvfmkaf_Ml(vl);
5908 }
5909
5910 void __attribute__((noinline))
5911 test_vfmklgt_mvl(int vl) {
5912   // CHECK-LABEL: @test_vfmklgt_mvl
5913   // CHECK: call <256 x i1> @llvm.ve.vl.vfmklgt.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
5914   vm1 = _vel_vfmklgt_mvl(vr1, vl);
5915 }
5916
5917 void __attribute__((noinline))
5918 test_vfmklgt_mvml(int vl) {
5919   // CHECK-LABEL: @test_vfmklgt_mvml
5920   // CHECK: call <256 x i1> @llvm.ve.vl.vfmklgt.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
5921   vm1 = _vel_vfmklgt_mvml(vr1, vm2, vl);
5922 }
5923
5924 void __attribute__((noinline))
5925 test_vfmkllt_mvl(int vl) {
5926   // CHECK-LABEL: @test_vfmkllt_mvl
5927   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkllt.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
5928   vm1 = _vel_vfmkllt_mvl(vr1, vl);
5929 }
5930
5931 void __attribute__((noinline))
5932 test_vfmkllt_mvml(int vl) {
5933   // CHECK-LABEL: @test_vfmkllt_mvml
5934   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkllt.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
5935   vm1 = _vel_vfmkllt_mvml(vr1, vm2, vl);
5936 }
5937
5938 void __attribute__((noinline))
5939 test_vfmklne_mvl(int vl) {
5940   // CHECK-LABEL: @test_vfmklne_mvl
5941   // CHECK: call <256 x i1> @llvm.ve.vl.vfmklne.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
5942   vm1 = _vel_vfmklne_mvl(vr1, vl);
5943 }
5944
5945 void __attribute__((noinline))
5946 test_vfmklne_mvml(int vl) {
5947   // CHECK-LABEL: @test_vfmklne_mvml
5948   // CHECK: call <256 x i1> @llvm.ve.vl.vfmklne.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
5949   vm1 = _vel_vfmklne_mvml(vr1, vm2, vl);
5950 }
5951
5952 void __attribute__((noinline))
5953 test_vfmkleq_mvl(int vl) {
5954   // CHECK-LABEL: @test_vfmkleq_mvl
5955   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkleq.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
5956   vm1 = _vel_vfmkleq_mvl(vr1, vl);
5957 }
5958
5959 void __attribute__((noinline))
5960 test_vfmkleq_mvml(int vl) {
5961   // CHECK-LABEL: @test_vfmkleq_mvml
5962   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkleq.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
5963   vm1 = _vel_vfmkleq_mvml(vr1, vm2, vl);
5964 }
5965
5966 void __attribute__((noinline))
5967 test_vfmklge_mvl(int vl) {
5968   // CHECK-LABEL: @test_vfmklge_mvl
5969   // CHECK: call <256 x i1> @llvm.ve.vl.vfmklge.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
5970   vm1 = _vel_vfmklge_mvl(vr1, vl);
5971 }
5972
5973 void __attribute__((noinline))
5974 test_vfmklge_mvml(int vl) {
5975   // CHECK-LABEL: @test_vfmklge_mvml
5976   // CHECK: call <256 x i1> @llvm.ve.vl.vfmklge.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
5977   vm1 = _vel_vfmklge_mvml(vr1, vm2, vl);
5978 }
5979
5980 void __attribute__((noinline))
5981 test_vfmklle_mvl(int vl) {
5982   // CHECK-LABEL: @test_vfmklle_mvl
5983   // CHECK: call <256 x i1> @llvm.ve.vl.vfmklle.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
5984   vm1 = _vel_vfmklle_mvl(vr1, vl);
5985 }
5986
5987 void __attribute__((noinline))
5988 test_vfmklle_mvml(int vl) {
5989   // CHECK-LABEL: @test_vfmklle_mvml
5990   // CHECK: call <256 x i1> @llvm.ve.vl.vfmklle.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
5991   vm1 = _vel_vfmklle_mvml(vr1, vm2, vl);
5992 }
5993
5994 void __attribute__((noinline))
5995 test_vfmklnum_mvl(int vl) {
5996   // CHECK-LABEL: @test_vfmklnum_mvl
5997   // CHECK: call <256 x i1> @llvm.ve.vl.vfmklnum.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
5998   vm1 = _vel_vfmklnum_mvl(vr1, vl);
5999 }
6000
6001 void __attribute__((noinline))
6002 test_vfmklnum_mvml(int vl) {
6003   // CHECK-LABEL: @test_vfmklnum_mvml
6004   // CHECK: call <256 x i1> @llvm.ve.vl.vfmklnum.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6005   vm1 = _vel_vfmklnum_mvml(vr1, vm2, vl);
6006 }
6007
6008 void __attribute__((noinline))
6009 test_vfmklnan_mvl(int vl) {
6010   // CHECK-LABEL: @test_vfmklnan_mvl
6011   // CHECK: call <256 x i1> @llvm.ve.vl.vfmklnan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6012   vm1 = _vel_vfmklnan_mvl(vr1, vl);
6013 }
6014
6015 void __attribute__((noinline))
6016 test_vfmklnan_mvml(int vl) {
6017   // CHECK-LABEL: @test_vfmklnan_mvml
6018   // CHECK: call <256 x i1> @llvm.ve.vl.vfmklnan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6019   vm1 = _vel_vfmklnan_mvml(vr1, vm2, vl);
6020 }
6021
6022 void __attribute__((noinline))
6023 test_vfmklgtnan_mvl(int vl) {
6024   // CHECK-LABEL: @test_vfmklgtnan_mvl
6025   // CHECK: call <256 x i1> @llvm.ve.vl.vfmklgtnan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6026   vm1 = _vel_vfmklgtnan_mvl(vr1, vl);
6027 }
6028
6029 void __attribute__((noinline))
6030 test_vfmklgtnan_mvml(int vl) {
6031   // CHECK-LABEL: @test_vfmklgtnan_mvml
6032   // CHECK: call <256 x i1> @llvm.ve.vl.vfmklgtnan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6033   vm1 = _vel_vfmklgtnan_mvml(vr1, vm2, vl);
6034 }
6035
6036 void __attribute__((noinline))
6037 test_vfmklltnan_mvl(int vl) {
6038   // CHECK-LABEL: @test_vfmklltnan_mvl
6039   // CHECK: call <256 x i1> @llvm.ve.vl.vfmklltnan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6040   vm1 = _vel_vfmklltnan_mvl(vr1, vl);
6041 }
6042
6043 void __attribute__((noinline))
6044 test_vfmklltnan_mvml(int vl) {
6045   // CHECK-LABEL: @test_vfmklltnan_mvml
6046   // CHECK: call <256 x i1> @llvm.ve.vl.vfmklltnan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6047   vm1 = _vel_vfmklltnan_mvml(vr1, vm2, vl);
6048 }
6049
6050 void __attribute__((noinline))
6051 test_vfmklnenan_mvl(int vl) {
6052   // CHECK-LABEL: @test_vfmklnenan_mvl
6053   // CHECK: call <256 x i1> @llvm.ve.vl.vfmklnenan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6054   vm1 = _vel_vfmklnenan_mvl(vr1, vl);
6055 }
6056
6057 void __attribute__((noinline))
6058 test_vfmklnenan_mvml(int vl) {
6059   // CHECK-LABEL: @test_vfmklnenan_mvml
6060   // CHECK: call <256 x i1> @llvm.ve.vl.vfmklnenan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6061   vm1 = _vel_vfmklnenan_mvml(vr1, vm2, vl);
6062 }
6063
6064 void __attribute__((noinline))
6065 test_vfmkleqnan_mvl(int vl) {
6066   // CHECK-LABEL: @test_vfmkleqnan_mvl
6067   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkleqnan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6068   vm1 = _vel_vfmkleqnan_mvl(vr1, vl);
6069 }
6070
6071 void __attribute__((noinline))
6072 test_vfmkleqnan_mvml(int vl) {
6073   // CHECK-LABEL: @test_vfmkleqnan_mvml
6074   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkleqnan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6075   vm1 = _vel_vfmkleqnan_mvml(vr1, vm2, vl);
6076 }
6077
6078 void __attribute__((noinline))
6079 test_vfmklgenan_mvl(int vl) {
6080   // CHECK-LABEL: @test_vfmklgenan_mvl
6081   // CHECK: call <256 x i1> @llvm.ve.vl.vfmklgenan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6082   vm1 = _vel_vfmklgenan_mvl(vr1, vl);
6083 }
6084
6085 void __attribute__((noinline))
6086 test_vfmklgenan_mvml(int vl) {
6087   // CHECK-LABEL: @test_vfmklgenan_mvml
6088   // CHECK: call <256 x i1> @llvm.ve.vl.vfmklgenan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6089   vm1 = _vel_vfmklgenan_mvml(vr1, vm2, vl);
6090 }
6091
6092 void __attribute__((noinline))
6093 test_vfmkllenan_mvl(int vl) {
6094   // CHECK-LABEL: @test_vfmkllenan_mvl
6095   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkllenan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6096   vm1 = _vel_vfmkllenan_mvl(vr1, vl);
6097 }
6098
6099 void __attribute__((noinline))
6100 test_vfmkllenan_mvml(int vl) {
6101   // CHECK-LABEL: @test_vfmkllenan_mvml
6102   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkllenan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6103   vm1 = _vel_vfmkllenan_mvml(vr1, vm2, vl);
6104 }
6105
6106 void __attribute__((noinline))
6107 test_vfmkwgt_mvl(int vl) {
6108   // CHECK-LABEL: @test_vfmkwgt_mvl
6109   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkwgt.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6110   vm1 = _vel_vfmkwgt_mvl(vr1, vl);
6111 }
6112
6113 void __attribute__((noinline))
6114 test_vfmkwgt_mvml(int vl) {
6115   // CHECK-LABEL: @test_vfmkwgt_mvml
6116   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkwgt.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6117   vm1 = _vel_vfmkwgt_mvml(vr1, vm2, vl);
6118 }
6119
6120 void __attribute__((noinline))
6121 test_vfmkwlt_mvl(int vl) {
6122   // CHECK-LABEL: @test_vfmkwlt_mvl
6123   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkwlt.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6124   vm1 = _vel_vfmkwlt_mvl(vr1, vl);
6125 }
6126
6127 void __attribute__((noinline))
6128 test_vfmkwlt_mvml(int vl) {
6129   // CHECK-LABEL: @test_vfmkwlt_mvml
6130   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkwlt.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6131   vm1 = _vel_vfmkwlt_mvml(vr1, vm2, vl);
6132 }
6133
6134 void __attribute__((noinline))
6135 test_vfmkwne_mvl(int vl) {
6136   // CHECK-LABEL: @test_vfmkwne_mvl
6137   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkwne.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6138   vm1 = _vel_vfmkwne_mvl(vr1, vl);
6139 }
6140
6141 void __attribute__((noinline))
6142 test_vfmkwne_mvml(int vl) {
6143   // CHECK-LABEL: @test_vfmkwne_mvml
6144   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkwne.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6145   vm1 = _vel_vfmkwne_mvml(vr1, vm2, vl);
6146 }
6147
6148 void __attribute__((noinline))
6149 test_vfmkweq_mvl(int vl) {
6150   // CHECK-LABEL: @test_vfmkweq_mvl
6151   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkweq.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6152   vm1 = _vel_vfmkweq_mvl(vr1, vl);
6153 }
6154
6155 void __attribute__((noinline))
6156 test_vfmkweq_mvml(int vl) {
6157   // CHECK-LABEL: @test_vfmkweq_mvml
6158   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkweq.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6159   vm1 = _vel_vfmkweq_mvml(vr1, vm2, vl);
6160 }
6161
6162 void __attribute__((noinline))
6163 test_vfmkwge_mvl(int vl) {
6164   // CHECK-LABEL: @test_vfmkwge_mvl
6165   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkwge.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6166   vm1 = _vel_vfmkwge_mvl(vr1, vl);
6167 }
6168
6169 void __attribute__((noinline))
6170 test_vfmkwge_mvml(int vl) {
6171   // CHECK-LABEL: @test_vfmkwge_mvml
6172   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkwge.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6173   vm1 = _vel_vfmkwge_mvml(vr1, vm2, vl);
6174 }
6175
6176 void __attribute__((noinline))
6177 test_vfmkwle_mvl(int vl) {
6178   // CHECK-LABEL: @test_vfmkwle_mvl
6179   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkwle.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6180   vm1 = _vel_vfmkwle_mvl(vr1, vl);
6181 }
6182
6183 void __attribute__((noinline))
6184 test_vfmkwle_mvml(int vl) {
6185   // CHECK-LABEL: @test_vfmkwle_mvml
6186   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkwle.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6187   vm1 = _vel_vfmkwle_mvml(vr1, vm2, vl);
6188 }
6189
6190 void __attribute__((noinline))
6191 test_vfmkwnum_mvl(int vl) {
6192   // CHECK-LABEL: @test_vfmkwnum_mvl
6193   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkwnum.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6194   vm1 = _vel_vfmkwnum_mvl(vr1, vl);
6195 }
6196
6197 void __attribute__((noinline))
6198 test_vfmkwnum_mvml(int vl) {
6199   // CHECK-LABEL: @test_vfmkwnum_mvml
6200   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkwnum.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6201   vm1 = _vel_vfmkwnum_mvml(vr1, vm2, vl);
6202 }
6203
6204 void __attribute__((noinline))
6205 test_vfmkwnan_mvl(int vl) {
6206   // CHECK-LABEL: @test_vfmkwnan_mvl
6207   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkwnan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6208   vm1 = _vel_vfmkwnan_mvl(vr1, vl);
6209 }
6210
6211 void __attribute__((noinline))
6212 test_vfmkwnan_mvml(int vl) {
6213   // CHECK-LABEL: @test_vfmkwnan_mvml
6214   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkwnan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6215   vm1 = _vel_vfmkwnan_mvml(vr1, vm2, vl);
6216 }
6217
6218 void __attribute__((noinline))
6219 test_vfmkwgtnan_mvl(int vl) {
6220   // CHECK-LABEL: @test_vfmkwgtnan_mvl
6221   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkwgtnan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6222   vm1 = _vel_vfmkwgtnan_mvl(vr1, vl);
6223 }
6224
6225 void __attribute__((noinline))
6226 test_vfmkwgtnan_mvml(int vl) {
6227   // CHECK-LABEL: @test_vfmkwgtnan_mvml
6228   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkwgtnan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6229   vm1 = _vel_vfmkwgtnan_mvml(vr1, vm2, vl);
6230 }
6231
6232 void __attribute__((noinline))
6233 test_vfmkwltnan_mvl(int vl) {
6234   // CHECK-LABEL: @test_vfmkwltnan_mvl
6235   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkwltnan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6236   vm1 = _vel_vfmkwltnan_mvl(vr1, vl);
6237 }
6238
6239 void __attribute__((noinline))
6240 test_vfmkwltnan_mvml(int vl) {
6241   // CHECK-LABEL: @test_vfmkwltnan_mvml
6242   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkwltnan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6243   vm1 = _vel_vfmkwltnan_mvml(vr1, vm2, vl);
6244 }
6245
6246 void __attribute__((noinline))
6247 test_vfmkwnenan_mvl(int vl) {
6248   // CHECK-LABEL: @test_vfmkwnenan_mvl
6249   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkwnenan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6250   vm1 = _vel_vfmkwnenan_mvl(vr1, vl);
6251 }
6252
6253 void __attribute__((noinline))
6254 test_vfmkwnenan_mvml(int vl) {
6255   // CHECK-LABEL: @test_vfmkwnenan_mvml
6256   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkwnenan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6257   vm1 = _vel_vfmkwnenan_mvml(vr1, vm2, vl);
6258 }
6259
6260 void __attribute__((noinline))
6261 test_vfmkweqnan_mvl(int vl) {
6262   // CHECK-LABEL: @test_vfmkweqnan_mvl
6263   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkweqnan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6264   vm1 = _vel_vfmkweqnan_mvl(vr1, vl);
6265 }
6266
6267 void __attribute__((noinline))
6268 test_vfmkweqnan_mvml(int vl) {
6269   // CHECK-LABEL: @test_vfmkweqnan_mvml
6270   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkweqnan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6271   vm1 = _vel_vfmkweqnan_mvml(vr1, vm2, vl);
6272 }
6273
6274 void __attribute__((noinline))
6275 test_vfmkwgenan_mvl(int vl) {
6276   // CHECK-LABEL: @test_vfmkwgenan_mvl
6277   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkwgenan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6278   vm1 = _vel_vfmkwgenan_mvl(vr1, vl);
6279 }
6280
6281 void __attribute__((noinline))
6282 test_vfmkwgenan_mvml(int vl) {
6283   // CHECK-LABEL: @test_vfmkwgenan_mvml
6284   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkwgenan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6285   vm1 = _vel_vfmkwgenan_mvml(vr1, vm2, vl);
6286 }
6287
6288 void __attribute__((noinline))
6289 test_vfmkwlenan_mvl(int vl) {
6290   // CHECK-LABEL: @test_vfmkwlenan_mvl
6291   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkwlenan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6292   vm1 = _vel_vfmkwlenan_mvl(vr1, vl);
6293 }
6294
6295 void __attribute__((noinline))
6296 test_vfmkwlenan_mvml(int vl) {
6297   // CHECK-LABEL: @test_vfmkwlenan_mvml
6298   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkwlenan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6299   vm1 = _vel_vfmkwlenan_mvml(vr1, vm2, vl);
6300 }
6301
6302 void __attribute__((noinline))
6303 test_pvfmkwlogt_mvl(int vl) {
6304   // CHECK-LABEL: @test_pvfmkwlogt_mvl
6305   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwlogt.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6306   vm1 = _vel_pvfmkwlogt_mvl(vr1, vl);
6307 }
6308
6309 void __attribute__((noinline))
6310 test_pvfmkwupgt_mvl(int vl) {
6311   // CHECK-LABEL: @test_pvfmkwupgt_mvl
6312   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwupgt.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6313   vm1 = _vel_pvfmkwupgt_mvl(vr1, vl);
6314 }
6315
6316 void __attribute__((noinline))
6317 test_pvfmkwlogt_mvml(int vl) {
6318   // CHECK-LABEL: @test_pvfmkwlogt_mvml
6319   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwlogt.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6320   vm1 = _vel_pvfmkwlogt_mvml(vr1, vm2, vl);
6321 }
6322
6323 void __attribute__((noinline))
6324 test_pvfmkwupgt_mvml(int vl) {
6325   // CHECK-LABEL: @test_pvfmkwupgt_mvml
6326   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwupgt.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6327   vm1 = _vel_pvfmkwupgt_mvml(vr1, vm2, vl);
6328 }
6329
6330 void __attribute__((noinline))
6331 test_pvfmkwlolt_mvl(int vl) {
6332   // CHECK-LABEL: @test_pvfmkwlolt_mvl
6333   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwlolt.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6334   vm1 = _vel_pvfmkwlolt_mvl(vr1, vl);
6335 }
6336
6337 void __attribute__((noinline))
6338 test_pvfmkwuplt_mvl(int vl) {
6339   // CHECK-LABEL: @test_pvfmkwuplt_mvl
6340   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwuplt.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6341   vm1 = _vel_pvfmkwuplt_mvl(vr1, vl);
6342 }
6343
6344 void __attribute__((noinline))
6345 test_pvfmkwlolt_mvml(int vl) {
6346   // CHECK-LABEL: @test_pvfmkwlolt_mvml
6347   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwlolt.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6348   vm1 = _vel_pvfmkwlolt_mvml(vr1, vm2, vl);
6349 }
6350
6351 void __attribute__((noinline))
6352 test_pvfmkwuplt_mvml(int vl) {
6353   // CHECK-LABEL: @test_pvfmkwuplt_mvml
6354   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwuplt.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6355   vm1 = _vel_pvfmkwuplt_mvml(vr1, vm2, vl);
6356 }
6357
6358 void __attribute__((noinline))
6359 test_pvfmkwlone_mvl(int vl) {
6360   // CHECK-LABEL: @test_pvfmkwlone_mvl
6361   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwlone.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6362   vm1 = _vel_pvfmkwlone_mvl(vr1, vl);
6363 }
6364
6365 void __attribute__((noinline))
6366 test_pvfmkwupne_mvl(int vl) {
6367   // CHECK-LABEL: @test_pvfmkwupne_mvl
6368   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwupne.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6369   vm1 = _vel_pvfmkwupne_mvl(vr1, vl);
6370 }
6371
6372 void __attribute__((noinline))
6373 test_pvfmkwlone_mvml(int vl) {
6374   // CHECK-LABEL: @test_pvfmkwlone_mvml
6375   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwlone.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6376   vm1 = _vel_pvfmkwlone_mvml(vr1, vm2, vl);
6377 }
6378
6379 void __attribute__((noinline))
6380 test_pvfmkwupne_mvml(int vl) {
6381   // CHECK-LABEL: @test_pvfmkwupne_mvml
6382   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwupne.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6383   vm1 = _vel_pvfmkwupne_mvml(vr1, vm2, vl);
6384 }
6385
6386 void __attribute__((noinline))
6387 test_pvfmkwloeq_mvl(int vl) {
6388   // CHECK-LABEL: @test_pvfmkwloeq_mvl
6389   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwloeq.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6390   vm1 = _vel_pvfmkwloeq_mvl(vr1, vl);
6391 }
6392
6393 void __attribute__((noinline))
6394 test_pvfmkwupeq_mvl(int vl) {
6395   // CHECK-LABEL: @test_pvfmkwupeq_mvl
6396   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwupeq.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6397   vm1 = _vel_pvfmkwupeq_mvl(vr1, vl);
6398 }
6399
6400 void __attribute__((noinline))
6401 test_pvfmkwloeq_mvml(int vl) {
6402   // CHECK-LABEL: @test_pvfmkwloeq_mvml
6403   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwloeq.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6404   vm1 = _vel_pvfmkwloeq_mvml(vr1, vm2, vl);
6405 }
6406
6407 void __attribute__((noinline))
6408 test_pvfmkwupeq_mvml(int vl) {
6409   // CHECK-LABEL: @test_pvfmkwupeq_mvml
6410   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwupeq.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6411   vm1 = _vel_pvfmkwupeq_mvml(vr1, vm2, vl);
6412 }
6413
6414 void __attribute__((noinline))
6415 test_pvfmkwloge_mvl(int vl) {
6416   // CHECK-LABEL: @test_pvfmkwloge_mvl
6417   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwloge.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6418   vm1 = _vel_pvfmkwloge_mvl(vr1, vl);
6419 }
6420
6421 void __attribute__((noinline))
6422 test_pvfmkwupge_mvl(int vl) {
6423   // CHECK-LABEL: @test_pvfmkwupge_mvl
6424   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwupge.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6425   vm1 = _vel_pvfmkwupge_mvl(vr1, vl);
6426 }
6427
6428 void __attribute__((noinline))
6429 test_pvfmkwloge_mvml(int vl) {
6430   // CHECK-LABEL: @test_pvfmkwloge_mvml
6431   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwloge.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6432   vm1 = _vel_pvfmkwloge_mvml(vr1, vm2, vl);
6433 }
6434
6435 void __attribute__((noinline))
6436 test_pvfmkwupge_mvml(int vl) {
6437   // CHECK-LABEL: @test_pvfmkwupge_mvml
6438   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwupge.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6439   vm1 = _vel_pvfmkwupge_mvml(vr1, vm2, vl);
6440 }
6441
6442 void __attribute__((noinline))
6443 test_pvfmkwlole_mvl(int vl) {
6444   // CHECK-LABEL: @test_pvfmkwlole_mvl
6445   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwlole.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6446   vm1 = _vel_pvfmkwlole_mvl(vr1, vl);
6447 }
6448
6449 void __attribute__((noinline))
6450 test_pvfmkwuple_mvl(int vl) {
6451   // CHECK-LABEL: @test_pvfmkwuple_mvl
6452   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwuple.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6453   vm1 = _vel_pvfmkwuple_mvl(vr1, vl);
6454 }
6455
6456 void __attribute__((noinline))
6457 test_pvfmkwlole_mvml(int vl) {
6458   // CHECK-LABEL: @test_pvfmkwlole_mvml
6459   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwlole.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6460   vm1 = _vel_pvfmkwlole_mvml(vr1, vm2, vl);
6461 }
6462
6463 void __attribute__((noinline))
6464 test_pvfmkwuple_mvml(int vl) {
6465   // CHECK-LABEL: @test_pvfmkwuple_mvml
6466   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwuple.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6467   vm1 = _vel_pvfmkwuple_mvml(vr1, vm2, vl);
6468 }
6469
6470 void __attribute__((noinline))
6471 test_pvfmkwlonum_mvl(int vl) {
6472   // CHECK-LABEL: @test_pvfmkwlonum_mvl
6473   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwlonum.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6474   vm1 = _vel_pvfmkwlonum_mvl(vr1, vl);
6475 }
6476
6477 void __attribute__((noinline))
6478 test_pvfmkwupnum_mvl(int vl) {
6479   // CHECK-LABEL: @test_pvfmkwupnum_mvl
6480   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwupnum.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6481   vm1 = _vel_pvfmkwupnum_mvl(vr1, vl);
6482 }
6483
6484 void __attribute__((noinline))
6485 test_pvfmkwlonum_mvml(int vl) {
6486   // CHECK-LABEL: @test_pvfmkwlonum_mvml
6487   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwlonum.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6488   vm1 = _vel_pvfmkwlonum_mvml(vr1, vm2, vl);
6489 }
6490
6491 void __attribute__((noinline))
6492 test_pvfmkwupnum_mvml(int vl) {
6493   // CHECK-LABEL: @test_pvfmkwupnum_mvml
6494   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwupnum.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6495   vm1 = _vel_pvfmkwupnum_mvml(vr1, vm2, vl);
6496 }
6497
6498 void __attribute__((noinline))
6499 test_pvfmkwlonan_mvl(int vl) {
6500   // CHECK-LABEL: @test_pvfmkwlonan_mvl
6501   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwlonan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6502   vm1 = _vel_pvfmkwlonan_mvl(vr1, vl);
6503 }
6504
6505 void __attribute__((noinline))
6506 test_pvfmkwupnan_mvl(int vl) {
6507   // CHECK-LABEL: @test_pvfmkwupnan_mvl
6508   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwupnan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6509   vm1 = _vel_pvfmkwupnan_mvl(vr1, vl);
6510 }
6511
6512 void __attribute__((noinline))
6513 test_pvfmkwlonan_mvml(int vl) {
6514   // CHECK-LABEL: @test_pvfmkwlonan_mvml
6515   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwlonan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6516   vm1 = _vel_pvfmkwlonan_mvml(vr1, vm2, vl);
6517 }
6518
6519 void __attribute__((noinline))
6520 test_pvfmkwupnan_mvml(int vl) {
6521   // CHECK-LABEL: @test_pvfmkwupnan_mvml
6522   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwupnan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6523   vm1 = _vel_pvfmkwupnan_mvml(vr1, vm2, vl);
6524 }
6525
6526 void __attribute__((noinline))
6527 test_pvfmkwlogtnan_mvl(int vl) {
6528   // CHECK-LABEL: @test_pvfmkwlogtnan_mvl
6529   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwlogtnan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6530   vm1 = _vel_pvfmkwlogtnan_mvl(vr1, vl);
6531 }
6532
6533 void __attribute__((noinline))
6534 test_pvfmkwupgtnan_mvl(int vl) {
6535   // CHECK-LABEL: @test_pvfmkwupgtnan_mvl
6536   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwupgtnan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6537   vm1 = _vel_pvfmkwupgtnan_mvl(vr1, vl);
6538 }
6539
6540 void __attribute__((noinline))
6541 test_pvfmkwlogtnan_mvml(int vl) {
6542   // CHECK-LABEL: @test_pvfmkwlogtnan_mvml
6543   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwlogtnan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6544   vm1 = _vel_pvfmkwlogtnan_mvml(vr1, vm2, vl);
6545 }
6546
6547 void __attribute__((noinline))
6548 test_pvfmkwupgtnan_mvml(int vl) {
6549   // CHECK-LABEL: @test_pvfmkwupgtnan_mvml
6550   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwupgtnan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6551   vm1 = _vel_pvfmkwupgtnan_mvml(vr1, vm2, vl);
6552 }
6553
6554 void __attribute__((noinline))
6555 test_pvfmkwloltnan_mvl(int vl) {
6556   // CHECK-LABEL: @test_pvfmkwloltnan_mvl
6557   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwloltnan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6558   vm1 = _vel_pvfmkwloltnan_mvl(vr1, vl);
6559 }
6560
6561 void __attribute__((noinline))
6562 test_pvfmkwupltnan_mvl(int vl) {
6563   // CHECK-LABEL: @test_pvfmkwupltnan_mvl
6564   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwupltnan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6565   vm1 = _vel_pvfmkwupltnan_mvl(vr1, vl);
6566 }
6567
6568 void __attribute__((noinline))
6569 test_pvfmkwloltnan_mvml(int vl) {
6570   // CHECK-LABEL: @test_pvfmkwloltnan_mvml
6571   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwloltnan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6572   vm1 = _vel_pvfmkwloltnan_mvml(vr1, vm2, vl);
6573 }
6574
6575 void __attribute__((noinline))
6576 test_pvfmkwupltnan_mvml(int vl) {
6577   // CHECK-LABEL: @test_pvfmkwupltnan_mvml
6578   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwupltnan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6579   vm1 = _vel_pvfmkwupltnan_mvml(vr1, vm2, vl);
6580 }
6581
6582 void __attribute__((noinline))
6583 test_pvfmkwlonenan_mvl(int vl) {
6584   // CHECK-LABEL: @test_pvfmkwlonenan_mvl
6585   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwlonenan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6586   vm1 = _vel_pvfmkwlonenan_mvl(vr1, vl);
6587 }
6588
6589 void __attribute__((noinline))
6590 test_pvfmkwupnenan_mvl(int vl) {
6591   // CHECK-LABEL: @test_pvfmkwupnenan_mvl
6592   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwupnenan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6593   vm1 = _vel_pvfmkwupnenan_mvl(vr1, vl);
6594 }
6595
6596 void __attribute__((noinline))
6597 test_pvfmkwlonenan_mvml(int vl) {
6598   // CHECK-LABEL: @test_pvfmkwlonenan_mvml
6599   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwlonenan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6600   vm1 = _vel_pvfmkwlonenan_mvml(vr1, vm2, vl);
6601 }
6602
6603 void __attribute__((noinline))
6604 test_pvfmkwupnenan_mvml(int vl) {
6605   // CHECK-LABEL: @test_pvfmkwupnenan_mvml
6606   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwupnenan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6607   vm1 = _vel_pvfmkwupnenan_mvml(vr1, vm2, vl);
6608 }
6609
6610 void __attribute__((noinline))
6611 test_pvfmkwloeqnan_mvl(int vl) {
6612   // CHECK-LABEL: @test_pvfmkwloeqnan_mvl
6613   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwloeqnan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6614   vm1 = _vel_pvfmkwloeqnan_mvl(vr1, vl);
6615 }
6616
6617 void __attribute__((noinline))
6618 test_pvfmkwupeqnan_mvl(int vl) {
6619   // CHECK-LABEL: @test_pvfmkwupeqnan_mvl
6620   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwupeqnan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6621   vm1 = _vel_pvfmkwupeqnan_mvl(vr1, vl);
6622 }
6623
6624 void __attribute__((noinline))
6625 test_pvfmkwloeqnan_mvml(int vl) {
6626   // CHECK-LABEL: @test_pvfmkwloeqnan_mvml
6627   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwloeqnan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6628   vm1 = _vel_pvfmkwloeqnan_mvml(vr1, vm2, vl);
6629 }
6630
6631 void __attribute__((noinline))
6632 test_pvfmkwupeqnan_mvml(int vl) {
6633   // CHECK-LABEL: @test_pvfmkwupeqnan_mvml
6634   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwupeqnan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6635   vm1 = _vel_pvfmkwupeqnan_mvml(vr1, vm2, vl);
6636 }
6637
6638 void __attribute__((noinline))
6639 test_pvfmkwlogenan_mvl(int vl) {
6640   // CHECK-LABEL: @test_pvfmkwlogenan_mvl
6641   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwlogenan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6642   vm1 = _vel_pvfmkwlogenan_mvl(vr1, vl);
6643 }
6644
6645 void __attribute__((noinline))
6646 test_pvfmkwupgenan_mvl(int vl) {
6647   // CHECK-LABEL: @test_pvfmkwupgenan_mvl
6648   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwupgenan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6649   vm1 = _vel_pvfmkwupgenan_mvl(vr1, vl);
6650 }
6651
6652 void __attribute__((noinline))
6653 test_pvfmkwlogenan_mvml(int vl) {
6654   // CHECK-LABEL: @test_pvfmkwlogenan_mvml
6655   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwlogenan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6656   vm1 = _vel_pvfmkwlogenan_mvml(vr1, vm2, vl);
6657 }
6658
6659 void __attribute__((noinline))
6660 test_pvfmkwupgenan_mvml(int vl) {
6661   // CHECK-LABEL: @test_pvfmkwupgenan_mvml
6662   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwupgenan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6663   vm1 = _vel_pvfmkwupgenan_mvml(vr1, vm2, vl);
6664 }
6665
6666 void __attribute__((noinline))
6667 test_pvfmkwlolenan_mvl(int vl) {
6668   // CHECK-LABEL: @test_pvfmkwlolenan_mvl
6669   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwlolenan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6670   vm1 = _vel_pvfmkwlolenan_mvl(vr1, vl);
6671 }
6672
6673 void __attribute__((noinline))
6674 test_pvfmkwuplenan_mvl(int vl) {
6675   // CHECK-LABEL: @test_pvfmkwuplenan_mvl
6676   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwuplenan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6677   vm1 = _vel_pvfmkwuplenan_mvl(vr1, vl);
6678 }
6679
6680 void __attribute__((noinline))
6681 test_pvfmkwlolenan_mvml(int vl) {
6682   // CHECK-LABEL: @test_pvfmkwlolenan_mvml
6683   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwlolenan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6684   vm1 = _vel_pvfmkwlolenan_mvml(vr1, vm2, vl);
6685 }
6686
6687 void __attribute__((noinline))
6688 test_pvfmkwuplenan_mvml(int vl) {
6689   // CHECK-LABEL: @test_pvfmkwuplenan_mvml
6690   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkwuplenan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6691   vm1 = _vel_pvfmkwuplenan_mvml(vr1, vm2, vl);
6692 }
6693
6694 void __attribute__((noinline))
6695 test_pvfmkwgt_Mvl(int vl) {
6696   // CHECK-LABEL: @test_pvfmkwgt_Mvl
6697   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmkwgt.Mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6698   vm1_512 = _vel_pvfmkwgt_Mvl(vr1, vl);
6699 }
6700
6701 void __attribute__((noinline))
6702 test_pvfmkwgt_MvMl(int vl) {
6703   // CHECK-LABEL: @test_pvfmkwgt_MvMl
6704   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmkwgt.MvMl(<256 x double> %{{.*}}, <512 x i1> %{{.*}}, i32 %{{.*}})
6705   vm1_512 = _vel_pvfmkwgt_MvMl(vr1, vm2_512, vl);
6706 }
6707
6708 void __attribute__((noinline))
6709 test_pvfmkwlt_Mvl(int vl) {
6710   // CHECK-LABEL: @test_pvfmkwlt_Mvl
6711   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmkwlt.Mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6712   vm1_512 = _vel_pvfmkwlt_Mvl(vr1, vl);
6713 }
6714
6715 void __attribute__((noinline))
6716 test_pvfmkwlt_MvMl(int vl) {
6717   // CHECK-LABEL: @test_pvfmkwlt_MvMl
6718   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmkwlt.MvMl(<256 x double> %{{.*}}, <512 x i1> %{{.*}}, i32 %{{.*}})
6719   vm1_512 = _vel_pvfmkwlt_MvMl(vr1, vm2_512, vl);
6720 }
6721
6722 void __attribute__((noinline))
6723 test_pvfmkwne_Mvl(int vl) {
6724   // CHECK-LABEL: @test_pvfmkwne_Mvl
6725   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmkwne.Mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6726   vm1_512 = _vel_pvfmkwne_Mvl(vr1, vl);
6727 }
6728
6729 void __attribute__((noinline))
6730 test_pvfmkwne_MvMl(int vl) {
6731   // CHECK-LABEL: @test_pvfmkwne_MvMl
6732   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmkwne.MvMl(<256 x double> %{{.*}}, <512 x i1> %{{.*}}, i32 %{{.*}})
6733   vm1_512 = _vel_pvfmkwne_MvMl(vr1, vm2_512, vl);
6734 }
6735
6736 void __attribute__((noinline))
6737 test_pvfmkweq_Mvl(int vl) {
6738   // CHECK-LABEL: @test_pvfmkweq_Mvl
6739   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmkweq.Mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6740   vm1_512 = _vel_pvfmkweq_Mvl(vr1, vl);
6741 }
6742
6743 void __attribute__((noinline))
6744 test_pvfmkweq_MvMl(int vl) {
6745   // CHECK-LABEL: @test_pvfmkweq_MvMl
6746   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmkweq.MvMl(<256 x double> %{{.*}}, <512 x i1> %{{.*}}, i32 %{{.*}})
6747   vm1_512 = _vel_pvfmkweq_MvMl(vr1, vm2_512, vl);
6748 }
6749
6750 void __attribute__((noinline))
6751 test_pvfmkwge_Mvl(int vl) {
6752   // CHECK-LABEL: @test_pvfmkwge_Mvl
6753   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmkwge.Mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6754   vm1_512 = _vel_pvfmkwge_Mvl(vr1, vl);
6755 }
6756
6757 void __attribute__((noinline))
6758 test_pvfmkwge_MvMl(int vl) {
6759   // CHECK-LABEL: @test_pvfmkwge_MvMl
6760   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmkwge.MvMl(<256 x double> %{{.*}}, <512 x i1> %{{.*}}, i32 %{{.*}})
6761   vm1_512 = _vel_pvfmkwge_MvMl(vr1, vm2_512, vl);
6762 }
6763
6764 void __attribute__((noinline))
6765 test_pvfmkwle_Mvl(int vl) {
6766   // CHECK-LABEL: @test_pvfmkwle_Mvl
6767   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmkwle.Mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6768   vm1_512 = _vel_pvfmkwle_Mvl(vr1, vl);
6769 }
6770
6771 void __attribute__((noinline))
6772 test_pvfmkwle_MvMl(int vl) {
6773   // CHECK-LABEL: @test_pvfmkwle_MvMl
6774   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmkwle.MvMl(<256 x double> %{{.*}}, <512 x i1> %{{.*}}, i32 %{{.*}})
6775   vm1_512 = _vel_pvfmkwle_MvMl(vr1, vm2_512, vl);
6776 }
6777
6778 void __attribute__((noinline))
6779 test_pvfmkwnum_Mvl(int vl) {
6780   // CHECK-LABEL: @test_pvfmkwnum_Mvl
6781   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmkwnum.Mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6782   vm1_512 = _vel_pvfmkwnum_Mvl(vr1, vl);
6783 }
6784
6785 void __attribute__((noinline))
6786 test_pvfmkwnum_MvMl(int vl) {
6787   // CHECK-LABEL: @test_pvfmkwnum_MvMl
6788   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmkwnum.MvMl(<256 x double> %{{.*}}, <512 x i1> %{{.*}}, i32 %{{.*}})
6789   vm1_512 = _vel_pvfmkwnum_MvMl(vr1, vm2_512, vl);
6790 }
6791
6792 void __attribute__((noinline))
6793 test_pvfmkwnan_Mvl(int vl) {
6794   // CHECK-LABEL: @test_pvfmkwnan_Mvl
6795   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmkwnan.Mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6796   vm1_512 = _vel_pvfmkwnan_Mvl(vr1, vl);
6797 }
6798
6799 void __attribute__((noinline))
6800 test_pvfmkwnan_MvMl(int vl) {
6801   // CHECK-LABEL: @test_pvfmkwnan_MvMl
6802   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmkwnan.MvMl(<256 x double> %{{.*}}, <512 x i1> %{{.*}}, i32 %{{.*}})
6803   vm1_512 = _vel_pvfmkwnan_MvMl(vr1, vm2_512, vl);
6804 }
6805
6806 void __attribute__((noinline))
6807 test_pvfmkwgtnan_Mvl(int vl) {
6808   // CHECK-LABEL: @test_pvfmkwgtnan_Mvl
6809   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmkwgtnan.Mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6810   vm1_512 = _vel_pvfmkwgtnan_Mvl(vr1, vl);
6811 }
6812
6813 void __attribute__((noinline))
6814 test_pvfmkwgtnan_MvMl(int vl) {
6815   // CHECK-LABEL: @test_pvfmkwgtnan_MvMl
6816   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmkwgtnan.MvMl(<256 x double> %{{.*}}, <512 x i1> %{{.*}}, i32 %{{.*}})
6817   vm1_512 = _vel_pvfmkwgtnan_MvMl(vr1, vm2_512, vl);
6818 }
6819
6820 void __attribute__((noinline))
6821 test_pvfmkwltnan_Mvl(int vl) {
6822   // CHECK-LABEL: @test_pvfmkwltnan_Mvl
6823   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmkwltnan.Mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6824   vm1_512 = _vel_pvfmkwltnan_Mvl(vr1, vl);
6825 }
6826
6827 void __attribute__((noinline))
6828 test_pvfmkwltnan_MvMl(int vl) {
6829   // CHECK-LABEL: @test_pvfmkwltnan_MvMl
6830   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmkwltnan.MvMl(<256 x double> %{{.*}}, <512 x i1> %{{.*}}, i32 %{{.*}})
6831   vm1_512 = _vel_pvfmkwltnan_MvMl(vr1, vm2_512, vl);
6832 }
6833
6834 void __attribute__((noinline))
6835 test_pvfmkwnenan_Mvl(int vl) {
6836   // CHECK-LABEL: @test_pvfmkwnenan_Mvl
6837   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmkwnenan.Mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6838   vm1_512 = _vel_pvfmkwnenan_Mvl(vr1, vl);
6839 }
6840
6841 void __attribute__((noinline))
6842 test_pvfmkwnenan_MvMl(int vl) {
6843   // CHECK-LABEL: @test_pvfmkwnenan_MvMl
6844   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmkwnenan.MvMl(<256 x double> %{{.*}}, <512 x i1> %{{.*}}, i32 %{{.*}})
6845   vm1_512 = _vel_pvfmkwnenan_MvMl(vr1, vm2_512, vl);
6846 }
6847
6848 void __attribute__((noinline))
6849 test_pvfmkweqnan_Mvl(int vl) {
6850   // CHECK-LABEL: @test_pvfmkweqnan_Mvl
6851   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmkweqnan.Mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6852   vm1_512 = _vel_pvfmkweqnan_Mvl(vr1, vl);
6853 }
6854
6855 void __attribute__((noinline))
6856 test_pvfmkweqnan_MvMl(int vl) {
6857   // CHECK-LABEL: @test_pvfmkweqnan_MvMl
6858   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmkweqnan.MvMl(<256 x double> %{{.*}}, <512 x i1> %{{.*}}, i32 %{{.*}})
6859   vm1_512 = _vel_pvfmkweqnan_MvMl(vr1, vm2_512, vl);
6860 }
6861
6862 void __attribute__((noinline))
6863 test_pvfmkwgenan_Mvl(int vl) {
6864   // CHECK-LABEL: @test_pvfmkwgenan_Mvl
6865   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmkwgenan.Mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6866   vm1_512 = _vel_pvfmkwgenan_Mvl(vr1, vl);
6867 }
6868
6869 void __attribute__((noinline))
6870 test_pvfmkwgenan_MvMl(int vl) {
6871   // CHECK-LABEL: @test_pvfmkwgenan_MvMl
6872   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmkwgenan.MvMl(<256 x double> %{{.*}}, <512 x i1> %{{.*}}, i32 %{{.*}})
6873   vm1_512 = _vel_pvfmkwgenan_MvMl(vr1, vm2_512, vl);
6874 }
6875
6876 void __attribute__((noinline))
6877 test_pvfmkwlenan_Mvl(int vl) {
6878   // CHECK-LABEL: @test_pvfmkwlenan_Mvl
6879   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmkwlenan.Mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6880   vm1_512 = _vel_pvfmkwlenan_Mvl(vr1, vl);
6881 }
6882
6883 void __attribute__((noinline))
6884 test_pvfmkwlenan_MvMl(int vl) {
6885   // CHECK-LABEL: @test_pvfmkwlenan_MvMl
6886   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmkwlenan.MvMl(<256 x double> %{{.*}}, <512 x i1> %{{.*}}, i32 %{{.*}})
6887   vm1_512 = _vel_pvfmkwlenan_MvMl(vr1, vm2_512, vl);
6888 }
6889
6890 void __attribute__((noinline))
6891 test_vfmkdgt_mvl(int vl) {
6892   // CHECK-LABEL: @test_vfmkdgt_mvl
6893   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkdgt.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6894   vm1 = _vel_vfmkdgt_mvl(vr1, vl);
6895 }
6896
6897 void __attribute__((noinline))
6898 test_vfmkdgt_mvml(int vl) {
6899   // CHECK-LABEL: @test_vfmkdgt_mvml
6900   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkdgt.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6901   vm1 = _vel_vfmkdgt_mvml(vr1, vm2, vl);
6902 }
6903
6904 void __attribute__((noinline))
6905 test_vfmkdlt_mvl(int vl) {
6906   // CHECK-LABEL: @test_vfmkdlt_mvl
6907   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkdlt.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6908   vm1 = _vel_vfmkdlt_mvl(vr1, vl);
6909 }
6910
6911 void __attribute__((noinline))
6912 test_vfmkdlt_mvml(int vl) {
6913   // CHECK-LABEL: @test_vfmkdlt_mvml
6914   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkdlt.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6915   vm1 = _vel_vfmkdlt_mvml(vr1, vm2, vl);
6916 }
6917
6918 void __attribute__((noinline))
6919 test_vfmkdne_mvl(int vl) {
6920   // CHECK-LABEL: @test_vfmkdne_mvl
6921   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkdne.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6922   vm1 = _vel_vfmkdne_mvl(vr1, vl);
6923 }
6924
6925 void __attribute__((noinline))
6926 test_vfmkdne_mvml(int vl) {
6927   // CHECK-LABEL: @test_vfmkdne_mvml
6928   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkdne.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6929   vm1 = _vel_vfmkdne_mvml(vr1, vm2, vl);
6930 }
6931
6932 void __attribute__((noinline))
6933 test_vfmkdeq_mvl(int vl) {
6934   // CHECK-LABEL: @test_vfmkdeq_mvl
6935   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkdeq.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6936   vm1 = _vel_vfmkdeq_mvl(vr1, vl);
6937 }
6938
6939 void __attribute__((noinline))
6940 test_vfmkdeq_mvml(int vl) {
6941   // CHECK-LABEL: @test_vfmkdeq_mvml
6942   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkdeq.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6943   vm1 = _vel_vfmkdeq_mvml(vr1, vm2, vl);
6944 }
6945
6946 void __attribute__((noinline))
6947 test_vfmkdge_mvl(int vl) {
6948   // CHECK-LABEL: @test_vfmkdge_mvl
6949   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkdge.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6950   vm1 = _vel_vfmkdge_mvl(vr1, vl);
6951 }
6952
6953 void __attribute__((noinline))
6954 test_vfmkdge_mvml(int vl) {
6955   // CHECK-LABEL: @test_vfmkdge_mvml
6956   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkdge.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6957   vm1 = _vel_vfmkdge_mvml(vr1, vm2, vl);
6958 }
6959
6960 void __attribute__((noinline))
6961 test_vfmkdle_mvl(int vl) {
6962   // CHECK-LABEL: @test_vfmkdle_mvl
6963   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkdle.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6964   vm1 = _vel_vfmkdle_mvl(vr1, vl);
6965 }
6966
6967 void __attribute__((noinline))
6968 test_vfmkdle_mvml(int vl) {
6969   // CHECK-LABEL: @test_vfmkdle_mvml
6970   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkdle.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6971   vm1 = _vel_vfmkdle_mvml(vr1, vm2, vl);
6972 }
6973
6974 void __attribute__((noinline))
6975 test_vfmkdnum_mvl(int vl) {
6976   // CHECK-LABEL: @test_vfmkdnum_mvl
6977   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkdnum.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6978   vm1 = _vel_vfmkdnum_mvl(vr1, vl);
6979 }
6980
6981 void __attribute__((noinline))
6982 test_vfmkdnum_mvml(int vl) {
6983   // CHECK-LABEL: @test_vfmkdnum_mvml
6984   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkdnum.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6985   vm1 = _vel_vfmkdnum_mvml(vr1, vm2, vl);
6986 }
6987
6988 void __attribute__((noinline))
6989 test_vfmkdnan_mvl(int vl) {
6990   // CHECK-LABEL: @test_vfmkdnan_mvl
6991   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkdnan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
6992   vm1 = _vel_vfmkdnan_mvl(vr1, vl);
6993 }
6994
6995 void __attribute__((noinline))
6996 test_vfmkdnan_mvml(int vl) {
6997   // CHECK-LABEL: @test_vfmkdnan_mvml
6998   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkdnan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
6999   vm1 = _vel_vfmkdnan_mvml(vr1, vm2, vl);
7000 }
7001
7002 void __attribute__((noinline))
7003 test_vfmkdgtnan_mvl(int vl) {
7004   // CHECK-LABEL: @test_vfmkdgtnan_mvl
7005   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkdgtnan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7006   vm1 = _vel_vfmkdgtnan_mvl(vr1, vl);
7007 }
7008
7009 void __attribute__((noinline))
7010 test_vfmkdgtnan_mvml(int vl) {
7011   // CHECK-LABEL: @test_vfmkdgtnan_mvml
7012   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkdgtnan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7013   vm1 = _vel_vfmkdgtnan_mvml(vr1, vm2, vl);
7014 }
7015
7016 void __attribute__((noinline))
7017 test_vfmkdltnan_mvl(int vl) {
7018   // CHECK-LABEL: @test_vfmkdltnan_mvl
7019   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkdltnan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7020   vm1 = _vel_vfmkdltnan_mvl(vr1, vl);
7021 }
7022
7023 void __attribute__((noinline))
7024 test_vfmkdltnan_mvml(int vl) {
7025   // CHECK-LABEL: @test_vfmkdltnan_mvml
7026   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkdltnan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7027   vm1 = _vel_vfmkdltnan_mvml(vr1, vm2, vl);
7028 }
7029
7030 void __attribute__((noinline))
7031 test_vfmkdnenan_mvl(int vl) {
7032   // CHECK-LABEL: @test_vfmkdnenan_mvl
7033   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkdnenan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7034   vm1 = _vel_vfmkdnenan_mvl(vr1, vl);
7035 }
7036
7037 void __attribute__((noinline))
7038 test_vfmkdnenan_mvml(int vl) {
7039   // CHECK-LABEL: @test_vfmkdnenan_mvml
7040   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkdnenan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7041   vm1 = _vel_vfmkdnenan_mvml(vr1, vm2, vl);
7042 }
7043
7044 void __attribute__((noinline))
7045 test_vfmkdeqnan_mvl(int vl) {
7046   // CHECK-LABEL: @test_vfmkdeqnan_mvl
7047   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkdeqnan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7048   vm1 = _vel_vfmkdeqnan_mvl(vr1, vl);
7049 }
7050
7051 void __attribute__((noinline))
7052 test_vfmkdeqnan_mvml(int vl) {
7053   // CHECK-LABEL: @test_vfmkdeqnan_mvml
7054   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkdeqnan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7055   vm1 = _vel_vfmkdeqnan_mvml(vr1, vm2, vl);
7056 }
7057
7058 void __attribute__((noinline))
7059 test_vfmkdgenan_mvl(int vl) {
7060   // CHECK-LABEL: @test_vfmkdgenan_mvl
7061   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkdgenan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7062   vm1 = _vel_vfmkdgenan_mvl(vr1, vl);
7063 }
7064
7065 void __attribute__((noinline))
7066 test_vfmkdgenan_mvml(int vl) {
7067   // CHECK-LABEL: @test_vfmkdgenan_mvml
7068   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkdgenan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7069   vm1 = _vel_vfmkdgenan_mvml(vr1, vm2, vl);
7070 }
7071
7072 void __attribute__((noinline))
7073 test_vfmkdlenan_mvl(int vl) {
7074   // CHECK-LABEL: @test_vfmkdlenan_mvl
7075   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkdlenan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7076   vm1 = _vel_vfmkdlenan_mvl(vr1, vl);
7077 }
7078
7079 void __attribute__((noinline))
7080 test_vfmkdlenan_mvml(int vl) {
7081   // CHECK-LABEL: @test_vfmkdlenan_mvml
7082   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkdlenan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7083   vm1 = _vel_vfmkdlenan_mvml(vr1, vm2, vl);
7084 }
7085
7086 void __attribute__((noinline))
7087 test_vfmksgt_mvl(int vl) {
7088   // CHECK-LABEL: @test_vfmksgt_mvl
7089   // CHECK: call <256 x i1> @llvm.ve.vl.vfmksgt.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7090   vm1 = _vel_vfmksgt_mvl(vr1, vl);
7091 }
7092
7093 void __attribute__((noinline))
7094 test_vfmksgt_mvml(int vl) {
7095   // CHECK-LABEL: @test_vfmksgt_mvml
7096   // CHECK: call <256 x i1> @llvm.ve.vl.vfmksgt.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7097   vm1 = _vel_vfmksgt_mvml(vr1, vm2, vl);
7098 }
7099
7100 void __attribute__((noinline))
7101 test_vfmkslt_mvl(int vl) {
7102   // CHECK-LABEL: @test_vfmkslt_mvl
7103   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkslt.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7104   vm1 = _vel_vfmkslt_mvl(vr1, vl);
7105 }
7106
7107 void __attribute__((noinline))
7108 test_vfmkslt_mvml(int vl) {
7109   // CHECK-LABEL: @test_vfmkslt_mvml
7110   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkslt.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7111   vm1 = _vel_vfmkslt_mvml(vr1, vm2, vl);
7112 }
7113
7114 void __attribute__((noinline))
7115 test_vfmksne_mvl(int vl) {
7116   // CHECK-LABEL: @test_vfmksne_mvl
7117   // CHECK: call <256 x i1> @llvm.ve.vl.vfmksne.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7118   vm1 = _vel_vfmksne_mvl(vr1, vl);
7119 }
7120
7121 void __attribute__((noinline))
7122 test_vfmksne_mvml(int vl) {
7123   // CHECK-LABEL: @test_vfmksne_mvml
7124   // CHECK: call <256 x i1> @llvm.ve.vl.vfmksne.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7125   vm1 = _vel_vfmksne_mvml(vr1, vm2, vl);
7126 }
7127
7128 void __attribute__((noinline))
7129 test_vfmkseq_mvl(int vl) {
7130   // CHECK-LABEL: @test_vfmkseq_mvl
7131   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkseq.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7132   vm1 = _vel_vfmkseq_mvl(vr1, vl);
7133 }
7134
7135 void __attribute__((noinline))
7136 test_vfmkseq_mvml(int vl) {
7137   // CHECK-LABEL: @test_vfmkseq_mvml
7138   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkseq.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7139   vm1 = _vel_vfmkseq_mvml(vr1, vm2, vl);
7140 }
7141
7142 void __attribute__((noinline))
7143 test_vfmksge_mvl(int vl) {
7144   // CHECK-LABEL: @test_vfmksge_mvl
7145   // CHECK: call <256 x i1> @llvm.ve.vl.vfmksge.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7146   vm1 = _vel_vfmksge_mvl(vr1, vl);
7147 }
7148
7149 void __attribute__((noinline))
7150 test_vfmksge_mvml(int vl) {
7151   // CHECK-LABEL: @test_vfmksge_mvml
7152   // CHECK: call <256 x i1> @llvm.ve.vl.vfmksge.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7153   vm1 = _vel_vfmksge_mvml(vr1, vm2, vl);
7154 }
7155
7156 void __attribute__((noinline))
7157 test_vfmksle_mvl(int vl) {
7158   // CHECK-LABEL: @test_vfmksle_mvl
7159   // CHECK: call <256 x i1> @llvm.ve.vl.vfmksle.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7160   vm1 = _vel_vfmksle_mvl(vr1, vl);
7161 }
7162
7163 void __attribute__((noinline))
7164 test_vfmksle_mvml(int vl) {
7165   // CHECK-LABEL: @test_vfmksle_mvml
7166   // CHECK: call <256 x i1> @llvm.ve.vl.vfmksle.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7167   vm1 = _vel_vfmksle_mvml(vr1, vm2, vl);
7168 }
7169
7170 void __attribute__((noinline))
7171 test_vfmksnum_mvl(int vl) {
7172   // CHECK-LABEL: @test_vfmksnum_mvl
7173   // CHECK: call <256 x i1> @llvm.ve.vl.vfmksnum.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7174   vm1 = _vel_vfmksnum_mvl(vr1, vl);
7175 }
7176
7177 void __attribute__((noinline))
7178 test_vfmksnum_mvml(int vl) {
7179   // CHECK-LABEL: @test_vfmksnum_mvml
7180   // CHECK: call <256 x i1> @llvm.ve.vl.vfmksnum.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7181   vm1 = _vel_vfmksnum_mvml(vr1, vm2, vl);
7182 }
7183
7184 void __attribute__((noinline))
7185 test_vfmksnan_mvl(int vl) {
7186   // CHECK-LABEL: @test_vfmksnan_mvl
7187   // CHECK: call <256 x i1> @llvm.ve.vl.vfmksnan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7188   vm1 = _vel_vfmksnan_mvl(vr1, vl);
7189 }
7190
7191 void __attribute__((noinline))
7192 test_vfmksnan_mvml(int vl) {
7193   // CHECK-LABEL: @test_vfmksnan_mvml
7194   // CHECK: call <256 x i1> @llvm.ve.vl.vfmksnan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7195   vm1 = _vel_vfmksnan_mvml(vr1, vm2, vl);
7196 }
7197
7198 void __attribute__((noinline))
7199 test_vfmksgtnan_mvl(int vl) {
7200   // CHECK-LABEL: @test_vfmksgtnan_mvl
7201   // CHECK: call <256 x i1> @llvm.ve.vl.vfmksgtnan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7202   vm1 = _vel_vfmksgtnan_mvl(vr1, vl);
7203 }
7204
7205 void __attribute__((noinline))
7206 test_vfmksgtnan_mvml(int vl) {
7207   // CHECK-LABEL: @test_vfmksgtnan_mvml
7208   // CHECK: call <256 x i1> @llvm.ve.vl.vfmksgtnan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7209   vm1 = _vel_vfmksgtnan_mvml(vr1, vm2, vl);
7210 }
7211
7212 void __attribute__((noinline))
7213 test_vfmksltnan_mvl(int vl) {
7214   // CHECK-LABEL: @test_vfmksltnan_mvl
7215   // CHECK: call <256 x i1> @llvm.ve.vl.vfmksltnan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7216   vm1 = _vel_vfmksltnan_mvl(vr1, vl);
7217 }
7218
7219 void __attribute__((noinline))
7220 test_vfmksltnan_mvml(int vl) {
7221   // CHECK-LABEL: @test_vfmksltnan_mvml
7222   // CHECK: call <256 x i1> @llvm.ve.vl.vfmksltnan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7223   vm1 = _vel_vfmksltnan_mvml(vr1, vm2, vl);
7224 }
7225
7226 void __attribute__((noinline))
7227 test_vfmksnenan_mvl(int vl) {
7228   // CHECK-LABEL: @test_vfmksnenan_mvl
7229   // CHECK: call <256 x i1> @llvm.ve.vl.vfmksnenan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7230   vm1 = _vel_vfmksnenan_mvl(vr1, vl);
7231 }
7232
7233 void __attribute__((noinline))
7234 test_vfmksnenan_mvml(int vl) {
7235   // CHECK-LABEL: @test_vfmksnenan_mvml
7236   // CHECK: call <256 x i1> @llvm.ve.vl.vfmksnenan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7237   vm1 = _vel_vfmksnenan_mvml(vr1, vm2, vl);
7238 }
7239
7240 void __attribute__((noinline))
7241 test_vfmkseqnan_mvl(int vl) {
7242   // CHECK-LABEL: @test_vfmkseqnan_mvl
7243   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkseqnan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7244   vm1 = _vel_vfmkseqnan_mvl(vr1, vl);
7245 }
7246
7247 void __attribute__((noinline))
7248 test_vfmkseqnan_mvml(int vl) {
7249   // CHECK-LABEL: @test_vfmkseqnan_mvml
7250   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkseqnan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7251   vm1 = _vel_vfmkseqnan_mvml(vr1, vm2, vl);
7252 }
7253
7254 void __attribute__((noinline))
7255 test_vfmksgenan_mvl(int vl) {
7256   // CHECK-LABEL: @test_vfmksgenan_mvl
7257   // CHECK: call <256 x i1> @llvm.ve.vl.vfmksgenan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7258   vm1 = _vel_vfmksgenan_mvl(vr1, vl);
7259 }
7260
7261 void __attribute__((noinline))
7262 test_vfmksgenan_mvml(int vl) {
7263   // CHECK-LABEL: @test_vfmksgenan_mvml
7264   // CHECK: call <256 x i1> @llvm.ve.vl.vfmksgenan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7265   vm1 = _vel_vfmksgenan_mvml(vr1, vm2, vl);
7266 }
7267
7268 void __attribute__((noinline))
7269 test_vfmkslenan_mvl(int vl) {
7270   // CHECK-LABEL: @test_vfmkslenan_mvl
7271   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkslenan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7272   vm1 = _vel_vfmkslenan_mvl(vr1, vl);
7273 }
7274
7275 void __attribute__((noinline))
7276 test_vfmkslenan_mvml(int vl) {
7277   // CHECK-LABEL: @test_vfmkslenan_mvml
7278   // CHECK: call <256 x i1> @llvm.ve.vl.vfmkslenan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7279   vm1 = _vel_vfmkslenan_mvml(vr1, vm2, vl);
7280 }
7281
7282 void __attribute__((noinline))
7283 test_pvfmkslogt_mvl(int vl) {
7284   // CHECK-LABEL: @test_pvfmkslogt_mvl
7285   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkslogt.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7286   vm1 = _vel_pvfmkslogt_mvl(vr1, vl);
7287 }
7288
7289 void __attribute__((noinline))
7290 test_pvfmksupgt_mvl(int vl) {
7291   // CHECK-LABEL: @test_pvfmksupgt_mvl
7292   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmksupgt.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7293   vm1 = _vel_pvfmksupgt_mvl(vr1, vl);
7294 }
7295
7296 void __attribute__((noinline))
7297 test_pvfmkslogt_mvml(int vl) {
7298   // CHECK-LABEL: @test_pvfmkslogt_mvml
7299   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkslogt.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7300   vm1 = _vel_pvfmkslogt_mvml(vr1, vm2, vl);
7301 }
7302
7303 void __attribute__((noinline))
7304 test_pvfmksupgt_mvml(int vl) {
7305   // CHECK-LABEL: @test_pvfmksupgt_mvml
7306   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmksupgt.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7307   vm1 = _vel_pvfmksupgt_mvml(vr1, vm2, vl);
7308 }
7309
7310 void __attribute__((noinline))
7311 test_pvfmkslolt_mvl(int vl) {
7312   // CHECK-LABEL: @test_pvfmkslolt_mvl
7313   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkslolt.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7314   vm1 = _vel_pvfmkslolt_mvl(vr1, vl);
7315 }
7316
7317 void __attribute__((noinline))
7318 test_pvfmksuplt_mvl(int vl) {
7319   // CHECK-LABEL: @test_pvfmksuplt_mvl
7320   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmksuplt.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7321   vm1 = _vel_pvfmksuplt_mvl(vr1, vl);
7322 }
7323
7324 void __attribute__((noinline))
7325 test_pvfmkslolt_mvml(int vl) {
7326   // CHECK-LABEL: @test_pvfmkslolt_mvml
7327   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkslolt.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7328   vm1 = _vel_pvfmkslolt_mvml(vr1, vm2, vl);
7329 }
7330
7331 void __attribute__((noinline))
7332 test_pvfmksuplt_mvml(int vl) {
7333   // CHECK-LABEL: @test_pvfmksuplt_mvml
7334   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmksuplt.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7335   vm1 = _vel_pvfmksuplt_mvml(vr1, vm2, vl);
7336 }
7337
7338 void __attribute__((noinline))
7339 test_pvfmkslone_mvl(int vl) {
7340   // CHECK-LABEL: @test_pvfmkslone_mvl
7341   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkslone.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7342   vm1 = _vel_pvfmkslone_mvl(vr1, vl);
7343 }
7344
7345 void __attribute__((noinline))
7346 test_pvfmksupne_mvl(int vl) {
7347   // CHECK-LABEL: @test_pvfmksupne_mvl
7348   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmksupne.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7349   vm1 = _vel_pvfmksupne_mvl(vr1, vl);
7350 }
7351
7352 void __attribute__((noinline))
7353 test_pvfmkslone_mvml(int vl) {
7354   // CHECK-LABEL: @test_pvfmkslone_mvml
7355   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkslone.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7356   vm1 = _vel_pvfmkslone_mvml(vr1, vm2, vl);
7357 }
7358
7359 void __attribute__((noinline))
7360 test_pvfmksupne_mvml(int vl) {
7361   // CHECK-LABEL: @test_pvfmksupne_mvml
7362   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmksupne.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7363   vm1 = _vel_pvfmksupne_mvml(vr1, vm2, vl);
7364 }
7365
7366 void __attribute__((noinline))
7367 test_pvfmksloeq_mvl(int vl) {
7368   // CHECK-LABEL: @test_pvfmksloeq_mvl
7369   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmksloeq.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7370   vm1 = _vel_pvfmksloeq_mvl(vr1, vl);
7371 }
7372
7373 void __attribute__((noinline))
7374 test_pvfmksupeq_mvl(int vl) {
7375   // CHECK-LABEL: @test_pvfmksupeq_mvl
7376   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmksupeq.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7377   vm1 = _vel_pvfmksupeq_mvl(vr1, vl);
7378 }
7379
7380 void __attribute__((noinline))
7381 test_pvfmksloeq_mvml(int vl) {
7382   // CHECK-LABEL: @test_pvfmksloeq_mvml
7383   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmksloeq.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7384   vm1 = _vel_pvfmksloeq_mvml(vr1, vm2, vl);
7385 }
7386
7387 void __attribute__((noinline))
7388 test_pvfmksupeq_mvml(int vl) {
7389   // CHECK-LABEL: @test_pvfmksupeq_mvml
7390   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmksupeq.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7391   vm1 = _vel_pvfmksupeq_mvml(vr1, vm2, vl);
7392 }
7393
7394 void __attribute__((noinline))
7395 test_pvfmksloge_mvl(int vl) {
7396   // CHECK-LABEL: @test_pvfmksloge_mvl
7397   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmksloge.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7398   vm1 = _vel_pvfmksloge_mvl(vr1, vl);
7399 }
7400
7401 void __attribute__((noinline))
7402 test_pvfmksupge_mvl(int vl) {
7403   // CHECK-LABEL: @test_pvfmksupge_mvl
7404   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmksupge.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7405   vm1 = _vel_pvfmksupge_mvl(vr1, vl);
7406 }
7407
7408 void __attribute__((noinline))
7409 test_pvfmksloge_mvml(int vl) {
7410   // CHECK-LABEL: @test_pvfmksloge_mvml
7411   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmksloge.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7412   vm1 = _vel_pvfmksloge_mvml(vr1, vm2, vl);
7413 }
7414
7415 void __attribute__((noinline))
7416 test_pvfmksupge_mvml(int vl) {
7417   // CHECK-LABEL: @test_pvfmksupge_mvml
7418   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmksupge.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7419   vm1 = _vel_pvfmksupge_mvml(vr1, vm2, vl);
7420 }
7421
7422 void __attribute__((noinline))
7423 test_pvfmkslole_mvl(int vl) {
7424   // CHECK-LABEL: @test_pvfmkslole_mvl
7425   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkslole.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7426   vm1 = _vel_pvfmkslole_mvl(vr1, vl);
7427 }
7428
7429 void __attribute__((noinline))
7430 test_pvfmksuple_mvl(int vl) {
7431   // CHECK-LABEL: @test_pvfmksuple_mvl
7432   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmksuple.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7433   vm1 = _vel_pvfmksuple_mvl(vr1, vl);
7434 }
7435
7436 void __attribute__((noinline))
7437 test_pvfmkslole_mvml(int vl) {
7438   // CHECK-LABEL: @test_pvfmkslole_mvml
7439   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkslole.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7440   vm1 = _vel_pvfmkslole_mvml(vr1, vm2, vl);
7441 }
7442
7443 void __attribute__((noinline))
7444 test_pvfmksuple_mvml(int vl) {
7445   // CHECK-LABEL: @test_pvfmksuple_mvml
7446   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmksuple.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7447   vm1 = _vel_pvfmksuple_mvml(vr1, vm2, vl);
7448 }
7449
7450 void __attribute__((noinline))
7451 test_pvfmkslonum_mvl(int vl) {
7452   // CHECK-LABEL: @test_pvfmkslonum_mvl
7453   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkslonum.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7454   vm1 = _vel_pvfmkslonum_mvl(vr1, vl);
7455 }
7456
7457 void __attribute__((noinline))
7458 test_pvfmksupnum_mvl(int vl) {
7459   // CHECK-LABEL: @test_pvfmksupnum_mvl
7460   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmksupnum.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7461   vm1 = _vel_pvfmksupnum_mvl(vr1, vl);
7462 }
7463
7464 void __attribute__((noinline))
7465 test_pvfmkslonum_mvml(int vl) {
7466   // CHECK-LABEL: @test_pvfmkslonum_mvml
7467   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkslonum.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7468   vm1 = _vel_pvfmkslonum_mvml(vr1, vm2, vl);
7469 }
7470
7471 void __attribute__((noinline))
7472 test_pvfmksupnum_mvml(int vl) {
7473   // CHECK-LABEL: @test_pvfmksupnum_mvml
7474   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmksupnum.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7475   vm1 = _vel_pvfmksupnum_mvml(vr1, vm2, vl);
7476 }
7477
7478 void __attribute__((noinline))
7479 test_pvfmkslonan_mvl(int vl) {
7480   // CHECK-LABEL: @test_pvfmkslonan_mvl
7481   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkslonan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7482   vm1 = _vel_pvfmkslonan_mvl(vr1, vl);
7483 }
7484
7485 void __attribute__((noinline))
7486 test_pvfmksupnan_mvl(int vl) {
7487   // CHECK-LABEL: @test_pvfmksupnan_mvl
7488   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmksupnan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7489   vm1 = _vel_pvfmksupnan_mvl(vr1, vl);
7490 }
7491
7492 void __attribute__((noinline))
7493 test_pvfmkslonan_mvml(int vl) {
7494   // CHECK-LABEL: @test_pvfmkslonan_mvml
7495   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkslonan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7496   vm1 = _vel_pvfmkslonan_mvml(vr1, vm2, vl);
7497 }
7498
7499 void __attribute__((noinline))
7500 test_pvfmksupnan_mvml(int vl) {
7501   // CHECK-LABEL: @test_pvfmksupnan_mvml
7502   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmksupnan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7503   vm1 = _vel_pvfmksupnan_mvml(vr1, vm2, vl);
7504 }
7505
7506 void __attribute__((noinline))
7507 test_pvfmkslogtnan_mvl(int vl) {
7508   // CHECK-LABEL: @test_pvfmkslogtnan_mvl
7509   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkslogtnan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7510   vm1 = _vel_pvfmkslogtnan_mvl(vr1, vl);
7511 }
7512
7513 void __attribute__((noinline))
7514 test_pvfmksupgtnan_mvl(int vl) {
7515   // CHECK-LABEL: @test_pvfmksupgtnan_mvl
7516   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmksupgtnan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7517   vm1 = _vel_pvfmksupgtnan_mvl(vr1, vl);
7518 }
7519
7520 void __attribute__((noinline))
7521 test_pvfmkslogtnan_mvml(int vl) {
7522   // CHECK-LABEL: @test_pvfmkslogtnan_mvml
7523   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkslogtnan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7524   vm1 = _vel_pvfmkslogtnan_mvml(vr1, vm2, vl);
7525 }
7526
7527 void __attribute__((noinline))
7528 test_pvfmksupgtnan_mvml(int vl) {
7529   // CHECK-LABEL: @test_pvfmksupgtnan_mvml
7530   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmksupgtnan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7531   vm1 = _vel_pvfmksupgtnan_mvml(vr1, vm2, vl);
7532 }
7533
7534 void __attribute__((noinline))
7535 test_pvfmksloltnan_mvl(int vl) {
7536   // CHECK-LABEL: @test_pvfmksloltnan_mvl
7537   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmksloltnan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7538   vm1 = _vel_pvfmksloltnan_mvl(vr1, vl);
7539 }
7540
7541 void __attribute__((noinline))
7542 test_pvfmksupltnan_mvl(int vl) {
7543   // CHECK-LABEL: @test_pvfmksupltnan_mvl
7544   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmksupltnan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7545   vm1 = _vel_pvfmksupltnan_mvl(vr1, vl);
7546 }
7547
7548 void __attribute__((noinline))
7549 test_pvfmksloltnan_mvml(int vl) {
7550   // CHECK-LABEL: @test_pvfmksloltnan_mvml
7551   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmksloltnan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7552   vm1 = _vel_pvfmksloltnan_mvml(vr1, vm2, vl);
7553 }
7554
7555 void __attribute__((noinline))
7556 test_pvfmksupltnan_mvml(int vl) {
7557   // CHECK-LABEL: @test_pvfmksupltnan_mvml
7558   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmksupltnan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7559   vm1 = _vel_pvfmksupltnan_mvml(vr1, vm2, vl);
7560 }
7561
7562 void __attribute__((noinline))
7563 test_pvfmkslonenan_mvl(int vl) {
7564   // CHECK-LABEL: @test_pvfmkslonenan_mvl
7565   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkslonenan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7566   vm1 = _vel_pvfmkslonenan_mvl(vr1, vl);
7567 }
7568
7569 void __attribute__((noinline))
7570 test_pvfmksupnenan_mvl(int vl) {
7571   // CHECK-LABEL: @test_pvfmksupnenan_mvl
7572   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmksupnenan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7573   vm1 = _vel_pvfmksupnenan_mvl(vr1, vl);
7574 }
7575
7576 void __attribute__((noinline))
7577 test_pvfmkslonenan_mvml(int vl) {
7578   // CHECK-LABEL: @test_pvfmkslonenan_mvml
7579   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkslonenan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7580   vm1 = _vel_pvfmkslonenan_mvml(vr1, vm2, vl);
7581 }
7582
7583 void __attribute__((noinline))
7584 test_pvfmksupnenan_mvml(int vl) {
7585   // CHECK-LABEL: @test_pvfmksupnenan_mvml
7586   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmksupnenan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7587   vm1 = _vel_pvfmksupnenan_mvml(vr1, vm2, vl);
7588 }
7589
7590 void __attribute__((noinline))
7591 test_pvfmksloeqnan_mvl(int vl) {
7592   // CHECK-LABEL: @test_pvfmksloeqnan_mvl
7593   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmksloeqnan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7594   vm1 = _vel_pvfmksloeqnan_mvl(vr1, vl);
7595 }
7596
7597 void __attribute__((noinline))
7598 test_pvfmksupeqnan_mvl(int vl) {
7599   // CHECK-LABEL: @test_pvfmksupeqnan_mvl
7600   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmksupeqnan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7601   vm1 = _vel_pvfmksupeqnan_mvl(vr1, vl);
7602 }
7603
7604 void __attribute__((noinline))
7605 test_pvfmksloeqnan_mvml(int vl) {
7606   // CHECK-LABEL: @test_pvfmksloeqnan_mvml
7607   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmksloeqnan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7608   vm1 = _vel_pvfmksloeqnan_mvml(vr1, vm2, vl);
7609 }
7610
7611 void __attribute__((noinline))
7612 test_pvfmksupeqnan_mvml(int vl) {
7613   // CHECK-LABEL: @test_pvfmksupeqnan_mvml
7614   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmksupeqnan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7615   vm1 = _vel_pvfmksupeqnan_mvml(vr1, vm2, vl);
7616 }
7617
7618 void __attribute__((noinline))
7619 test_pvfmkslogenan_mvl(int vl) {
7620   // CHECK-LABEL: @test_pvfmkslogenan_mvl
7621   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkslogenan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7622   vm1 = _vel_pvfmkslogenan_mvl(vr1, vl);
7623 }
7624
7625 void __attribute__((noinline))
7626 test_pvfmksupgenan_mvl(int vl) {
7627   // CHECK-LABEL: @test_pvfmksupgenan_mvl
7628   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmksupgenan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7629   vm1 = _vel_pvfmksupgenan_mvl(vr1, vl);
7630 }
7631
7632 void __attribute__((noinline))
7633 test_pvfmkslogenan_mvml(int vl) {
7634   // CHECK-LABEL: @test_pvfmkslogenan_mvml
7635   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkslogenan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7636   vm1 = _vel_pvfmkslogenan_mvml(vr1, vm2, vl);
7637 }
7638
7639 void __attribute__((noinline))
7640 test_pvfmksupgenan_mvml(int vl) {
7641   // CHECK-LABEL: @test_pvfmksupgenan_mvml
7642   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmksupgenan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7643   vm1 = _vel_pvfmksupgenan_mvml(vr1, vm2, vl);
7644 }
7645
7646 void __attribute__((noinline))
7647 test_pvfmkslolenan_mvl(int vl) {
7648   // CHECK-LABEL: @test_pvfmkslolenan_mvl
7649   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkslolenan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7650   vm1 = _vel_pvfmkslolenan_mvl(vr1, vl);
7651 }
7652
7653 void __attribute__((noinline))
7654 test_pvfmksuplenan_mvl(int vl) {
7655   // CHECK-LABEL: @test_pvfmksuplenan_mvl
7656   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmksuplenan.mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7657   vm1 = _vel_pvfmksuplenan_mvl(vr1, vl);
7658 }
7659
7660 void __attribute__((noinline))
7661 test_pvfmkslolenan_mvml(int vl) {
7662   // CHECK-LABEL: @test_pvfmkslolenan_mvml
7663   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmkslolenan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7664   vm1 = _vel_pvfmkslolenan_mvml(vr1, vm2, vl);
7665 }
7666
7667 void __attribute__((noinline))
7668 test_pvfmksuplenan_mvml(int vl) {
7669   // CHECK-LABEL: @test_pvfmksuplenan_mvml
7670   // CHECK: call <256 x i1> @llvm.ve.vl.pvfmksuplenan.mvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 %{{.*}})
7671   vm1 = _vel_pvfmksuplenan_mvml(vr1, vm2, vl);
7672 }
7673
7674 void __attribute__((noinline))
7675 test_pvfmksgt_Mvl(int vl) {
7676   // CHECK-LABEL: @test_pvfmksgt_Mvl
7677   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmksgt.Mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7678   vm1_512 = _vel_pvfmksgt_Mvl(vr1, vl);
7679 }
7680
7681 void __attribute__((noinline))
7682 test_pvfmksgt_MvMl(int vl) {
7683   // CHECK-LABEL: @test_pvfmksgt_MvMl
7684   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmksgt.MvMl(<256 x double> %{{.*}}, <512 x i1> %{{.*}}, i32 %{{.*}})
7685   vm1_512 = _vel_pvfmksgt_MvMl(vr1, vm2_512, vl);
7686 }
7687
7688 void __attribute__((noinline))
7689 test_pvfmkslt_Mvl(int vl) {
7690   // CHECK-LABEL: @test_pvfmkslt_Mvl
7691   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmkslt.Mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7692   vm1_512 = _vel_pvfmkslt_Mvl(vr1, vl);
7693 }
7694
7695 void __attribute__((noinline))
7696 test_pvfmkslt_MvMl(int vl) {
7697   // CHECK-LABEL: @test_pvfmkslt_MvMl
7698   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmkslt.MvMl(<256 x double> %{{.*}}, <512 x i1> %{{.*}}, i32 %{{.*}})
7699   vm1_512 = _vel_pvfmkslt_MvMl(vr1, vm2_512, vl);
7700 }
7701
7702 void __attribute__((noinline))
7703 test_pvfmksne_Mvl(int vl) {
7704   // CHECK-LABEL: @test_pvfmksne_Mvl
7705   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmksne.Mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7706   vm1_512 = _vel_pvfmksne_Mvl(vr1, vl);
7707 }
7708
7709 void __attribute__((noinline))
7710 test_pvfmksne_MvMl(int vl) {
7711   // CHECK-LABEL: @test_pvfmksne_MvMl
7712   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmksne.MvMl(<256 x double> %{{.*}}, <512 x i1> %{{.*}}, i32 %{{.*}})
7713   vm1_512 = _vel_pvfmksne_MvMl(vr1, vm2_512, vl);
7714 }
7715
7716 void __attribute__((noinline))
7717 test_pvfmkseq_Mvl(int vl) {
7718   // CHECK-LABEL: @test_pvfmkseq_Mvl
7719   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmkseq.Mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7720   vm1_512 = _vel_pvfmkseq_Mvl(vr1, vl);
7721 }
7722
7723 void __attribute__((noinline))
7724 test_pvfmkseq_MvMl(int vl) {
7725   // CHECK-LABEL: @test_pvfmkseq_MvMl
7726   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmkseq.MvMl(<256 x double> %{{.*}}, <512 x i1> %{{.*}}, i32 %{{.*}})
7727   vm1_512 = _vel_pvfmkseq_MvMl(vr1, vm2_512, vl);
7728 }
7729
7730 void __attribute__((noinline))
7731 test_pvfmksge_Mvl(int vl) {
7732   // CHECK-LABEL: @test_pvfmksge_Mvl
7733   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmksge.Mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7734   vm1_512 = _vel_pvfmksge_Mvl(vr1, vl);
7735 }
7736
7737 void __attribute__((noinline))
7738 test_pvfmksge_MvMl(int vl) {
7739   // CHECK-LABEL: @test_pvfmksge_MvMl
7740   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmksge.MvMl(<256 x double> %{{.*}}, <512 x i1> %{{.*}}, i32 %{{.*}})
7741   vm1_512 = _vel_pvfmksge_MvMl(vr1, vm2_512, vl);
7742 }
7743
7744 void __attribute__((noinline))
7745 test_pvfmksle_Mvl(int vl) {
7746   // CHECK-LABEL: @test_pvfmksle_Mvl
7747   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmksle.Mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7748   vm1_512 = _vel_pvfmksle_Mvl(vr1, vl);
7749 }
7750
7751 void __attribute__((noinline))
7752 test_pvfmksle_MvMl(int vl) {
7753   // CHECK-LABEL: @test_pvfmksle_MvMl
7754   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmksle.MvMl(<256 x double> %{{.*}}, <512 x i1> %{{.*}}, i32 %{{.*}})
7755   vm1_512 = _vel_pvfmksle_MvMl(vr1, vm2_512, vl);
7756 }
7757
7758 void __attribute__((noinline))
7759 test_pvfmksnum_Mvl(int vl) {
7760   // CHECK-LABEL: @test_pvfmksnum_Mvl
7761   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmksnum.Mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7762   vm1_512 = _vel_pvfmksnum_Mvl(vr1, vl);
7763 }
7764
7765 void __attribute__((noinline))
7766 test_pvfmksnum_MvMl(int vl) {
7767   // CHECK-LABEL: @test_pvfmksnum_MvMl
7768   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmksnum.MvMl(<256 x double> %{{.*}}, <512 x i1> %{{.*}}, i32 %{{.*}})
7769   vm1_512 = _vel_pvfmksnum_MvMl(vr1, vm2_512, vl);
7770 }
7771
7772 void __attribute__((noinline))
7773 test_pvfmksnan_Mvl(int vl) {
7774   // CHECK-LABEL: @test_pvfmksnan_Mvl
7775   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmksnan.Mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7776   vm1_512 = _vel_pvfmksnan_Mvl(vr1, vl);
7777 }
7778
7779 void __attribute__((noinline))
7780 test_pvfmksnan_MvMl(int vl) {
7781   // CHECK-LABEL: @test_pvfmksnan_MvMl
7782   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmksnan.MvMl(<256 x double> %{{.*}}, <512 x i1> %{{.*}}, i32 %{{.*}})
7783   vm1_512 = _vel_pvfmksnan_MvMl(vr1, vm2_512, vl);
7784 }
7785
7786 void __attribute__((noinline))
7787 test_pvfmksgtnan_Mvl(int vl) {
7788   // CHECK-LABEL: @test_pvfmksgtnan_Mvl
7789   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmksgtnan.Mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7790   vm1_512 = _vel_pvfmksgtnan_Mvl(vr1, vl);
7791 }
7792
7793 void __attribute__((noinline))
7794 test_pvfmksgtnan_MvMl(int vl) {
7795   // CHECK-LABEL: @test_pvfmksgtnan_MvMl
7796   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmksgtnan.MvMl(<256 x double> %{{.*}}, <512 x i1> %{{.*}}, i32 %{{.*}})
7797   vm1_512 = _vel_pvfmksgtnan_MvMl(vr1, vm2_512, vl);
7798 }
7799
7800 void __attribute__((noinline))
7801 test_pvfmksltnan_Mvl(int vl) {
7802   // CHECK-LABEL: @test_pvfmksltnan_Mvl
7803   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmksltnan.Mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7804   vm1_512 = _vel_pvfmksltnan_Mvl(vr1, vl);
7805 }
7806
7807 void __attribute__((noinline))
7808 test_pvfmksltnan_MvMl(int vl) {
7809   // CHECK-LABEL: @test_pvfmksltnan_MvMl
7810   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmksltnan.MvMl(<256 x double> %{{.*}}, <512 x i1> %{{.*}}, i32 %{{.*}})
7811   vm1_512 = _vel_pvfmksltnan_MvMl(vr1, vm2_512, vl);
7812 }
7813
7814 void __attribute__((noinline))
7815 test_pvfmksnenan_Mvl(int vl) {
7816   // CHECK-LABEL: @test_pvfmksnenan_Mvl
7817   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmksnenan.Mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7818   vm1_512 = _vel_pvfmksnenan_Mvl(vr1, vl);
7819 }
7820
7821 void __attribute__((noinline))
7822 test_pvfmksnenan_MvMl(int vl) {
7823   // CHECK-LABEL: @test_pvfmksnenan_MvMl
7824   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmksnenan.MvMl(<256 x double> %{{.*}}, <512 x i1> %{{.*}}, i32 %{{.*}})
7825   vm1_512 = _vel_pvfmksnenan_MvMl(vr1, vm2_512, vl);
7826 }
7827
7828 void __attribute__((noinline))
7829 test_pvfmkseqnan_Mvl(int vl) {
7830   // CHECK-LABEL: @test_pvfmkseqnan_Mvl
7831   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmkseqnan.Mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7832   vm1_512 = _vel_pvfmkseqnan_Mvl(vr1, vl);
7833 }
7834
7835 void __attribute__((noinline))
7836 test_pvfmkseqnan_MvMl(int vl) {
7837   // CHECK-LABEL: @test_pvfmkseqnan_MvMl
7838   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmkseqnan.MvMl(<256 x double> %{{.*}}, <512 x i1> %{{.*}}, i32 %{{.*}})
7839   vm1_512 = _vel_pvfmkseqnan_MvMl(vr1, vm2_512, vl);
7840 }
7841
7842 void __attribute__((noinline))
7843 test_pvfmksgenan_Mvl(int vl) {
7844   // CHECK-LABEL: @test_pvfmksgenan_Mvl
7845   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmksgenan.Mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7846   vm1_512 = _vel_pvfmksgenan_Mvl(vr1, vl);
7847 }
7848
7849 void __attribute__((noinline))
7850 test_pvfmksgenan_MvMl(int vl) {
7851   // CHECK-LABEL: @test_pvfmksgenan_MvMl
7852   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmksgenan.MvMl(<256 x double> %{{.*}}, <512 x i1> %{{.*}}, i32 %{{.*}})
7853   vm1_512 = _vel_pvfmksgenan_MvMl(vr1, vm2_512, vl);
7854 }
7855
7856 void __attribute__((noinline))
7857 test_pvfmkslenan_Mvl(int vl) {
7858   // CHECK-LABEL: @test_pvfmkslenan_Mvl
7859   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmkslenan.Mvl(<256 x double> %{{.*}}, i32 %{{.*}})
7860   vm1_512 = _vel_pvfmkslenan_Mvl(vr1, vl);
7861 }
7862
7863 void __attribute__((noinline))
7864 test_pvfmkslenan_MvMl(int vl) {
7865   // CHECK-LABEL: @test_pvfmkslenan_MvMl
7866   // CHECK: call <512 x i1> @llvm.ve.vl.pvfmkslenan.MvMl(<256 x double> %{{.*}}, <512 x i1> %{{.*}}, i32 %{{.*}})
7867   vm1_512 = _vel_pvfmkslenan_MvMl(vr1, vm2_512, vl);
7868 }
7869
7870 void __attribute__((noinline))
7871 test_vsumwsx_vvl() {
7872   // CHECK-LABEL: @test_vsumwsx_vvl
7873   // CHECK: call <256 x double> @llvm.ve.vl.vsumwsx.vvl(<256 x double> %{{.*}}, i32 256)
7874   vr2 = _vel_vsumwsx_vvl(vr1, 256);
7875 }
7876
7877 void __attribute__((noinline))
7878 test_vsumwsx_vvml() {
7879   // CHECK-LABEL: @test_vsumwsx_vvml
7880   // CHECK: call <256 x double> @llvm.ve.vl.vsumwsx.vvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 256)
7881   vr2 = _vel_vsumwsx_vvml(vr1, vm1, 256);
7882 }
7883
7884 void __attribute__((noinline))
7885 test_vsumwzx_vvl() {
7886   // CHECK-LABEL: @test_vsumwzx_vvl
7887   // CHECK: call <256 x double> @llvm.ve.vl.vsumwzx.vvl(<256 x double> %{{.*}}, i32 256)
7888   vr2 = _vel_vsumwzx_vvl(vr1, 256);
7889 }
7890
7891 void __attribute__((noinline))
7892 test_vsumwzx_vvml() {
7893   // CHECK-LABEL: @test_vsumwzx_vvml
7894   // CHECK: call <256 x double> @llvm.ve.vl.vsumwzx.vvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 256)
7895   vr2 = _vel_vsumwzx_vvml(vr1, vm1, 256);
7896 }
7897
7898 void __attribute__((noinline))
7899 test_vsuml_vvl() {
7900   // CHECK-LABEL: @test_vsuml_vvl
7901   // CHECK: call <256 x double> @llvm.ve.vl.vsuml.vvl(<256 x double> %{{.*}}, i32 256)
7902   vr2 = _vel_vsuml_vvl(vr1, 256);
7903 }
7904
7905 void __attribute__((noinline))
7906 test_vsuml_vvml() {
7907   // CHECK-LABEL: @test_vsuml_vvml
7908   // CHECK: call <256 x double> @llvm.ve.vl.vsuml.vvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 256)
7909   vr2 = _vel_vsuml_vvml(vr1, vm1, 256);
7910 }
7911
7912 void __attribute__((noinline))
7913 test_vfsumd_vvl() {
7914   // CHECK-LABEL: @test_vfsumd_vvl
7915   // CHECK: call <256 x double> @llvm.ve.vl.vfsumd.vvl(<256 x double> %{{.*}}, i32 256)
7916   vr2 = _vel_vfsumd_vvl(vr1, 256);
7917 }
7918
7919 void __attribute__((noinline))
7920 test_vfsumd_vvml() {
7921   // CHECK-LABEL: @test_vfsumd_vvml
7922   // CHECK: call <256 x double> @llvm.ve.vl.vfsumd.vvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 256)
7923   vr2 = _vel_vfsumd_vvml(vr1, vm1, 256);
7924 }
7925
7926 void __attribute__((noinline))
7927 test_vfsums_vvl() {
7928   // CHECK-LABEL: @test_vfsums_vvl
7929   // CHECK: call <256 x double> @llvm.ve.vl.vfsums.vvl(<256 x double> %{{.*}}, i32 256)
7930   vr2 = _vel_vfsums_vvl(vr1, 256);
7931 }
7932
7933 void __attribute__((noinline))
7934 test_vfsums_vvml() {
7935   // CHECK-LABEL: @test_vfsums_vvml
7936   // CHECK: call <256 x double> @llvm.ve.vl.vfsums.vvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 256)
7937   vr2 = _vel_vfsums_vvml(vr1, vm1, 256);
7938 }
7939
7940 void __attribute__((noinline))
7941 test_vrmaxswfstsx_vvl() {
7942   // CHECK-LABEL: @test_vrmaxswfstsx_vvl
7943   // CHECK: call <256 x double> @llvm.ve.vl.vrmaxswfstsx.vvl(<256 x double> %{{.*}}, i32 256)
7944   vr3 = _vel_vrmaxswfstsx_vvl(vr1, 256);
7945 }
7946
7947 void __attribute__((noinline))
7948 test_vrmaxswfstsx_vvvl() {
7949   // CHECK-LABEL: @test_vrmaxswfstsx_vvvl
7950   // CHECK: call <256 x double> @llvm.ve.vl.vrmaxswfstsx.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
7951   vr3 = _vel_vrmaxswfstsx_vvvl(vr1, vr2, 256);
7952 }
7953
7954 void __attribute__((noinline))
7955 test_vrmaxswlstsx_vvl() {
7956   // CHECK-LABEL: @test_vrmaxswlstsx_vvl
7957   // CHECK: call <256 x double> @llvm.ve.vl.vrmaxswlstsx.vvl(<256 x double> %{{.*}}, i32 256)
7958   vr3 = _vel_vrmaxswlstsx_vvl(vr1, 256);
7959 }
7960
7961 void __attribute__((noinline))
7962 test_vrmaxswlstsx_vvvl() {
7963   // CHECK-LABEL: @test_vrmaxswlstsx_vvvl
7964   // CHECK: call <256 x double> @llvm.ve.vl.vrmaxswlstsx.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
7965   vr3 = _vel_vrmaxswlstsx_vvvl(vr1, vr2, 256);
7966 }
7967
7968 void __attribute__((noinline))
7969 test_vrmaxswfstzx_vvl() {
7970   // CHECK-LABEL: @test_vrmaxswfstzx_vvl
7971   // CHECK: call <256 x double> @llvm.ve.vl.vrmaxswfstzx.vvl(<256 x double> %{{.*}}, i32 256)
7972   vr3 = _vel_vrmaxswfstzx_vvl(vr1, 256);
7973 }
7974
7975 void __attribute__((noinline))
7976 test_vrmaxswfstzx_vvvl() {
7977   // CHECK-LABEL: @test_vrmaxswfstzx_vvvl
7978   // CHECK: call <256 x double> @llvm.ve.vl.vrmaxswfstzx.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
7979   vr3 = _vel_vrmaxswfstzx_vvvl(vr1, vr2, 256);
7980 }
7981
7982 void __attribute__((noinline))
7983 test_vrmaxswlstzx_vvl() {
7984   // CHECK-LABEL: @test_vrmaxswlstzx_vvl
7985   // CHECK: call <256 x double> @llvm.ve.vl.vrmaxswlstzx.vvl(<256 x double> %{{.*}}, i32 256)
7986   vr3 = _vel_vrmaxswlstzx_vvl(vr1, 256);
7987 }
7988
7989 void __attribute__((noinline))
7990 test_vrmaxswlstzx_vvvl() {
7991   // CHECK-LABEL: @test_vrmaxswlstzx_vvvl
7992   // CHECK: call <256 x double> @llvm.ve.vl.vrmaxswlstzx.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
7993   vr3 = _vel_vrmaxswlstzx_vvvl(vr1, vr2, 256);
7994 }
7995
7996 void __attribute__((noinline))
7997 test_vrminswfstsx_vvl() {
7998   // CHECK-LABEL: @test_vrminswfstsx_vvl
7999   // CHECK: call <256 x double> @llvm.ve.vl.vrminswfstsx.vvl(<256 x double> %{{.*}}, i32 256)
8000   vr3 = _vel_vrminswfstsx_vvl(vr1, 256);
8001 }
8002
8003 void __attribute__((noinline))
8004 test_vrminswfstsx_vvvl() {
8005   // CHECK-LABEL: @test_vrminswfstsx_vvvl
8006   // CHECK: call <256 x double> @llvm.ve.vl.vrminswfstsx.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
8007   vr3 = _vel_vrminswfstsx_vvvl(vr1, vr2, 256);
8008 }
8009
8010 void __attribute__((noinline))
8011 test_vrminswlstsx_vvl() {
8012   // CHECK-LABEL: @test_vrminswlstsx_vvl
8013   // CHECK: call <256 x double> @llvm.ve.vl.vrminswlstsx.vvl(<256 x double> %{{.*}}, i32 256)
8014   vr3 = _vel_vrminswlstsx_vvl(vr1, 256);
8015 }
8016
8017 void __attribute__((noinline))
8018 test_vrminswlstsx_vvvl() {
8019   // CHECK-LABEL: @test_vrminswlstsx_vvvl
8020   // CHECK: call <256 x double> @llvm.ve.vl.vrminswlstsx.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
8021   vr3 = _vel_vrminswlstsx_vvvl(vr1, vr2, 256);
8022 }
8023
8024 void __attribute__((noinline))
8025 test_vrminswfstzx_vvl() {
8026   // CHECK-LABEL: @test_vrminswfstzx_vvl
8027   // CHECK: call <256 x double> @llvm.ve.vl.vrminswfstzx.vvl(<256 x double> %{{.*}}, i32 256)
8028   vr3 = _vel_vrminswfstzx_vvl(vr1, 256);
8029 }
8030
8031 void __attribute__((noinline))
8032 test_vrminswfstzx_vvvl() {
8033   // CHECK-LABEL: @test_vrminswfstzx_vvvl
8034   // CHECK: call <256 x double> @llvm.ve.vl.vrminswfstzx.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
8035   vr3 = _vel_vrminswfstzx_vvvl(vr1, vr2, 256);
8036 }
8037
8038 void __attribute__((noinline))
8039 test_vrminswlstzx_vvl() {
8040   // CHECK-LABEL: @test_vrminswlstzx_vvl
8041   // CHECK: call <256 x double> @llvm.ve.vl.vrminswlstzx.vvl(<256 x double> %{{.*}}, i32 256)
8042   vr3 = _vel_vrminswlstzx_vvl(vr1, 256);
8043 }
8044
8045 void __attribute__((noinline))
8046 test_vrminswlstzx_vvvl() {
8047   // CHECK-LABEL: @test_vrminswlstzx_vvvl
8048   // CHECK: call <256 x double> @llvm.ve.vl.vrminswlstzx.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
8049   vr3 = _vel_vrminswlstzx_vvvl(vr1, vr2, 256);
8050 }
8051
8052 void __attribute__((noinline))
8053 test_vrmaxslfst_vvl() {
8054   // CHECK-LABEL: @test_vrmaxslfst_vvl
8055   // CHECK: call <256 x double> @llvm.ve.vl.vrmaxslfst.vvl(<256 x double> %{{.*}}, i32 256)
8056   vr3 = _vel_vrmaxslfst_vvl(vr1, 256);
8057 }
8058
8059 void __attribute__((noinline))
8060 test_vrmaxslfst_vvvl() {
8061   // CHECK-LABEL: @test_vrmaxslfst_vvvl
8062   // CHECK: call <256 x double> @llvm.ve.vl.vrmaxslfst.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
8063   vr3 = _vel_vrmaxslfst_vvvl(vr1, vr2, 256);
8064 }
8065
8066 void __attribute__((noinline))
8067 test_vrmaxsllst_vvl() {
8068   // CHECK-LABEL: @test_vrmaxsllst_vvl
8069   // CHECK: call <256 x double> @llvm.ve.vl.vrmaxsllst.vvl(<256 x double> %{{.*}}, i32 256)
8070   vr3 = _vel_vrmaxsllst_vvl(vr1, 256);
8071 }
8072
8073 void __attribute__((noinline))
8074 test_vrmaxsllst_vvvl() {
8075   // CHECK-LABEL: @test_vrmaxsllst_vvvl
8076   // CHECK: call <256 x double> @llvm.ve.vl.vrmaxsllst.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
8077   vr3 = _vel_vrmaxsllst_vvvl(vr1, vr2, 256);
8078 }
8079
8080 void __attribute__((noinline))
8081 test_vrminslfst_vvl() {
8082   // CHECK-LABEL: @test_vrminslfst_vvl
8083   // CHECK: call <256 x double> @llvm.ve.vl.vrminslfst.vvl(<256 x double> %{{.*}}, i32 256)
8084   vr3 = _vel_vrminslfst_vvl(vr1, 256);
8085 }
8086
8087 void __attribute__((noinline))
8088 test_vrminslfst_vvvl() {
8089   // CHECK-LABEL: @test_vrminslfst_vvvl
8090   // CHECK: call <256 x double> @llvm.ve.vl.vrminslfst.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
8091   vr3 = _vel_vrminslfst_vvvl(vr1, vr2, 256);
8092 }
8093
8094 void __attribute__((noinline))
8095 test_vrminsllst_vvl() {
8096   // CHECK-LABEL: @test_vrminsllst_vvl
8097   // CHECK: call <256 x double> @llvm.ve.vl.vrminsllst.vvl(<256 x double> %{{.*}}, i32 256)
8098   vr3 = _vel_vrminsllst_vvl(vr1, 256);
8099 }
8100
8101 void __attribute__((noinline))
8102 test_vrminsllst_vvvl() {
8103   // CHECK-LABEL: @test_vrminsllst_vvvl
8104   // CHECK: call <256 x double> @llvm.ve.vl.vrminsllst.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
8105   vr3 = _vel_vrminsllst_vvvl(vr1, vr2, 256);
8106 }
8107
8108 void __attribute__((noinline))
8109 test_vfrmaxdfst_vvl() {
8110   // CHECK-LABEL: @test_vfrmaxdfst_vvl
8111   // CHECK: call <256 x double> @llvm.ve.vl.vfrmaxdfst.vvl(<256 x double> %{{.*}}, i32 256)
8112   vr3 = _vel_vfrmaxdfst_vvl(vr1, 256);
8113 }
8114
8115 void __attribute__((noinline))
8116 test_vfrmaxdfst_vvvl() {
8117   // CHECK-LABEL: @test_vfrmaxdfst_vvvl
8118   // CHECK: call <256 x double> @llvm.ve.vl.vfrmaxdfst.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
8119   vr3 = _vel_vfrmaxdfst_vvvl(vr1, vr2, 256);
8120 }
8121
8122 void __attribute__((noinline))
8123 test_vfrmaxdlst_vvl() {
8124   // CHECK-LABEL: @test_vfrmaxdlst_vvl
8125   // CHECK: call <256 x double> @llvm.ve.vl.vfrmaxdlst.vvl(<256 x double> %{{.*}}, i32 256)
8126   vr3 = _vel_vfrmaxdlst_vvl(vr1, 256);
8127 }
8128
8129 void __attribute__((noinline))
8130 test_vfrmaxdlst_vvvl() {
8131   // CHECK-LABEL: @test_vfrmaxdlst_vvvl
8132   // CHECK: call <256 x double> @llvm.ve.vl.vfrmaxdlst.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
8133   vr3 = _vel_vfrmaxdlst_vvvl(vr1, vr2, 256);
8134 }
8135
8136 void __attribute__((noinline))
8137 test_vfrmaxsfst_vvl() {
8138   // CHECK-LABEL: @test_vfrmaxsfst_vvl
8139   // CHECK: call <256 x double> @llvm.ve.vl.vfrmaxsfst.vvl(<256 x double> %{{.*}}, i32 256)
8140   vr3 = _vel_vfrmaxsfst_vvl(vr1, 256);
8141 }
8142
8143 void __attribute__((noinline))
8144 test_vfrmaxsfst_vvvl() {
8145   // CHECK-LABEL: @test_vfrmaxsfst_vvvl
8146   // CHECK: call <256 x double> @llvm.ve.vl.vfrmaxsfst.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
8147   vr3 = _vel_vfrmaxsfst_vvvl(vr1, vr2, 256);
8148 }
8149
8150 void __attribute__((noinline))
8151 test_vfrmaxslst_vvl() {
8152   // CHECK-LABEL: @test_vfrmaxslst_vvl
8153   // CHECK: call <256 x double> @llvm.ve.vl.vfrmaxslst.vvl(<256 x double> %{{.*}}, i32 256)
8154   vr3 = _vel_vfrmaxslst_vvl(vr1, 256);
8155 }
8156
8157 void __attribute__((noinline))
8158 test_vfrmaxslst_vvvl() {
8159   // CHECK-LABEL: @test_vfrmaxslst_vvvl
8160   // CHECK: call <256 x double> @llvm.ve.vl.vfrmaxslst.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
8161   vr3 = _vel_vfrmaxslst_vvvl(vr1, vr2, 256);
8162 }
8163
8164 void __attribute__((noinline))
8165 test_vfrmindfst_vvl() {
8166   // CHECK-LABEL: @test_vfrmindfst_vvl
8167   // CHECK: call <256 x double> @llvm.ve.vl.vfrmindfst.vvl(<256 x double> %{{.*}}, i32 256)
8168   vr3 = _vel_vfrmindfst_vvl(vr1, 256);
8169 }
8170
8171 void __attribute__((noinline))
8172 test_vfrmindfst_vvvl() {
8173   // CHECK-LABEL: @test_vfrmindfst_vvvl
8174   // CHECK: call <256 x double> @llvm.ve.vl.vfrmindfst.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
8175   vr3 = _vel_vfrmindfst_vvvl(vr1, vr2, 256);
8176 }
8177
8178 void __attribute__((noinline))
8179 test_vfrmindlst_vvl() {
8180   // CHECK-LABEL: @test_vfrmindlst_vvl
8181   // CHECK: call <256 x double> @llvm.ve.vl.vfrmindlst.vvl(<256 x double> %{{.*}}, i32 256)
8182   vr3 = _vel_vfrmindlst_vvl(vr1, 256);
8183 }
8184
8185 void __attribute__((noinline))
8186 test_vfrmindlst_vvvl() {
8187   // CHECK-LABEL: @test_vfrmindlst_vvvl
8188   // CHECK: call <256 x double> @llvm.ve.vl.vfrmindlst.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
8189   vr3 = _vel_vfrmindlst_vvvl(vr1, vr2, 256);
8190 }
8191
8192 void __attribute__((noinline))
8193 test_vfrminsfst_vvl() {
8194   // CHECK-LABEL: @test_vfrminsfst_vvl
8195   // CHECK: call <256 x double> @llvm.ve.vl.vfrminsfst.vvl(<256 x double> %{{.*}}, i32 256)
8196   vr3 = _vel_vfrminsfst_vvl(vr1, 256);
8197 }
8198
8199 void __attribute__((noinline))
8200 test_vfrminsfst_vvvl() {
8201   // CHECK-LABEL: @test_vfrminsfst_vvvl
8202   // CHECK: call <256 x double> @llvm.ve.vl.vfrminsfst.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
8203   vr3 = _vel_vfrminsfst_vvvl(vr1, vr2, 256);
8204 }
8205
8206 void __attribute__((noinline))
8207 test_vfrminslst_vvl() {
8208   // CHECK-LABEL: @test_vfrminslst_vvl
8209   // CHECK: call <256 x double> @llvm.ve.vl.vfrminslst.vvl(<256 x double> %{{.*}}, i32 256)
8210   vr3 = _vel_vfrminslst_vvl(vr1, 256);
8211 }
8212
8213 void __attribute__((noinline))
8214 test_vfrminslst_vvvl() {
8215   // CHECK-LABEL: @test_vfrminslst_vvvl
8216   // CHECK: call <256 x double> @llvm.ve.vl.vfrminslst.vvvl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i32 256)
8217   vr3 = _vel_vfrminslst_vvvl(vr1, vr2, 256);
8218 }
8219
8220 void __attribute__((noinline))
8221 test_vrand_vvl() {
8222   // CHECK-LABEL: @test_vrand_vvl
8223   // CHECK: call <256 x double> @llvm.ve.vl.vrand.vvl(<256 x double> %{{.*}}, i32 256)
8224   vr3 = _vel_vrand_vvl(vr1, 256);
8225 }
8226
8227 void __attribute__((noinline))
8228 test_vrand_vvml() {
8229   // CHECK-LABEL: @test_vrand_vvml
8230   // CHECK: call <256 x double> @llvm.ve.vl.vrand.vvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 256)
8231   vr3 = _vel_vrand_vvml(vr1, vm1, 256);
8232 }
8233
8234 void __attribute__((noinline))
8235 test_vror_vvl() {
8236   // CHECK-LABEL: @test_vror_vvl
8237   // CHECK: call <256 x double> @llvm.ve.vl.vror.vvl(<256 x double> %{{.*}}, i32 256)
8238   vr3 = _vel_vror_vvl(vr1, 256);
8239 }
8240
8241 void __attribute__((noinline))
8242 test_vror_vvml() {
8243   // CHECK-LABEL: @test_vror_vvml
8244   // CHECK: call <256 x double> @llvm.ve.vl.vror.vvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 256)
8245   vr3 = _vel_vror_vvml(vr1, vm1, 256);
8246 }
8247
8248 void __attribute__((noinline))
8249 test_vrxor_vvl() {
8250   // CHECK-LABEL: @test_vrxor_vvl
8251   // CHECK: call <256 x double> @llvm.ve.vl.vrxor.vvl(<256 x double> %{{.*}}, i32 256)
8252   vr3 = _vel_vrxor_vvl(vr1, 256);
8253 }
8254
8255 void __attribute__((noinline))
8256 test_vrxor_vvml() {
8257   // CHECK-LABEL: @test_vrxor_vvml
8258   // CHECK: call <256 x double> @llvm.ve.vl.vrxor.vvml(<256 x double> %{{.*}}, <256 x i1> %{{.*}}, i32 256)
8259   vr3 = _vel_vrxor_vvml(vr1, vm1, 256);
8260 }
8261
8262 void __attribute__((noinline))
8263 test_vgt_vvssl() {
8264   // CHECK-LABEL: @test_vgt_vvssl
8265   // CHECK: call <256 x double> @llvm.ve.vl.vgt.vvssl(<256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, i32 256)
8266   vr3 = _vel_vgt_vvssl(vr1, v1, v2, 256);
8267 }
8268
8269 void __attribute__((noinline))
8270 test_vgt_vvssvl() {
8271   // CHECK-LABEL: @test_vgt_vvssvl
8272   // CHECK: call <256 x double> @llvm.ve.vl.vgt.vvssvl(<256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
8273   vr3 = _vel_vgt_vvssvl(vr1, v1, v2, vr3, 256);
8274 }
8275
8276 void __attribute__((noinline))
8277 test_vgt_vvssml() {
8278   // CHECK-LABEL: @test_vgt_vvssml
8279   // CHECK: call <256 x double> @llvm.ve.vl.vgt.vvssml(<256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, <256 x i1> %{{.*}}, i32 256)
8280   vr3 = _vel_vgt_vvssml(vr1, v1, v2, vm1, 256);
8281 }
8282
8283 void __attribute__((noinline))
8284 test_vgt_vvssmvl() {
8285   // CHECK-LABEL: @test_vgt_vvssmvl
8286   // CHECK: call <256 x double> @llvm.ve.vl.vgt.vvssmvl(<256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
8287   vr3 = _vel_vgt_vvssmvl(vr1, v1, v2, vm1, vr3, 256);
8288 }
8289
8290 void __attribute__((noinline))
8291 test_vgtnc_vvssl() {
8292   // CHECK-LABEL: @test_vgtnc_vvssl
8293   // CHECK: call <256 x double> @llvm.ve.vl.vgtnc.vvssl(<256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, i32 256)
8294   vr3 = _vel_vgtnc_vvssl(vr1, v1, v2, 256);
8295 }
8296
8297 void __attribute__((noinline))
8298 test_vgtnc_vvssvl() {
8299   // CHECK-LABEL: @test_vgtnc_vvssvl
8300   // CHECK: call <256 x double> @llvm.ve.vl.vgtnc.vvssvl(<256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
8301   vr3 = _vel_vgtnc_vvssvl(vr1, v1, v2, vr3, 256);
8302 }
8303
8304 void __attribute__((noinline))
8305 test_vgtnc_vvssml() {
8306   // CHECK-LABEL: @test_vgtnc_vvssml
8307   // CHECK: call <256 x double> @llvm.ve.vl.vgtnc.vvssml(<256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, <256 x i1> %{{.*}}, i32 256)
8308   vr3 = _vel_vgtnc_vvssml(vr1, v1, v2, vm1, 256);
8309 }
8310
8311 void __attribute__((noinline))
8312 test_vgtnc_vvssmvl() {
8313   // CHECK-LABEL: @test_vgtnc_vvssmvl
8314   // CHECK: call <256 x double> @llvm.ve.vl.vgtnc.vvssmvl(<256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
8315   vr3 = _vel_vgtnc_vvssmvl(vr1, v1, v2, vm1, vr3, 256);
8316 }
8317
8318 void __attribute__((noinline))
8319 test_vgtu_vvssl() {
8320   // CHECK-LABEL: @test_vgtu_vvssl
8321   // CHECK: call <256 x double> @llvm.ve.vl.vgtu.vvssl(<256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, i32 256)
8322   vr3 = _vel_vgtu_vvssl(vr1, v1, v2, 256);
8323 }
8324
8325 void __attribute__((noinline))
8326 test_vgtu_vvssvl() {
8327   // CHECK-LABEL: @test_vgtu_vvssvl
8328   // CHECK: call <256 x double> @llvm.ve.vl.vgtu.vvssvl(<256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
8329   vr3 = _vel_vgtu_vvssvl(vr1, v1, v2, vr3, 256);
8330 }
8331
8332 void __attribute__((noinline))
8333 test_vgtu_vvssml() {
8334   // CHECK-LABEL: @test_vgtu_vvssml
8335   // CHECK: call <256 x double> @llvm.ve.vl.vgtu.vvssml(<256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, <256 x i1> %{{.*}}, i32 256)
8336   vr3 = _vel_vgtu_vvssml(vr1, v1, v2, vm1, 256);
8337 }
8338
8339 void __attribute__((noinline))
8340 test_vgtu_vvssmvl() {
8341   // CHECK-LABEL: @test_vgtu_vvssmvl
8342   // CHECK: call <256 x double> @llvm.ve.vl.vgtu.vvssmvl(<256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
8343   vr3 = _vel_vgtu_vvssmvl(vr1, v1, v2, vm1, vr3, 256);
8344 }
8345
8346 void __attribute__((noinline))
8347 test_vgtunc_vvssl() {
8348   // CHECK-LABEL: @test_vgtunc_vvssl
8349   // CHECK: call <256 x double> @llvm.ve.vl.vgtunc.vvssl(<256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, i32 256)
8350   vr3 = _vel_vgtunc_vvssl(vr1, v1, v2, 256);
8351 }
8352
8353 void __attribute__((noinline))
8354 test_vgtunc_vvssvl() {
8355   // CHECK-LABEL: @test_vgtunc_vvssvl
8356   // CHECK: call <256 x double> @llvm.ve.vl.vgtunc.vvssvl(<256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
8357   vr3 = _vel_vgtunc_vvssvl(vr1, v1, v2, vr3, 256);
8358 }
8359
8360 void __attribute__((noinline))
8361 test_vgtunc_vvssml() {
8362   // CHECK-LABEL: @test_vgtunc_vvssml
8363   // CHECK: call <256 x double> @llvm.ve.vl.vgtunc.vvssml(<256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, <256 x i1> %{{.*}}, i32 256)
8364   vr3 = _vel_vgtunc_vvssml(vr1, v1, v2, vm1, 256);
8365 }
8366
8367 void __attribute__((noinline))
8368 test_vgtunc_vvssmvl() {
8369   // CHECK-LABEL: @test_vgtunc_vvssmvl
8370   // CHECK: call <256 x double> @llvm.ve.vl.vgtunc.vvssmvl(<256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
8371   vr3 = _vel_vgtunc_vvssmvl(vr1, v1, v2, vm1, vr3, 256);
8372 }
8373
8374 void __attribute__((noinline))
8375 test_vgtlsx_vvssl() {
8376   // CHECK-LABEL: @test_vgtlsx_vvssl
8377   // CHECK: call <256 x double> @llvm.ve.vl.vgtlsx.vvssl(<256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, i32 256)
8378   vr3 = _vel_vgtlsx_vvssl(vr1, v1, v2, 256);
8379 }
8380
8381 void __attribute__((noinline))
8382 test_vgtlsx_vvssvl() {
8383   // CHECK-LABEL: @test_vgtlsx_vvssvl
8384   // CHECK: call <256 x double> @llvm.ve.vl.vgtlsx.vvssvl(<256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
8385   vr3 = _vel_vgtlsx_vvssvl(vr1, v1, v2, vr3, 256);
8386 }
8387
8388 void __attribute__((noinline))
8389 test_vgtlsx_vvssml() {
8390   // CHECK-LABEL: @test_vgtlsx_vvssml
8391   // CHECK: call <256 x double> @llvm.ve.vl.vgtlsx.vvssml(<256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, <256 x i1> %{{.*}}, i32 256)
8392   vr3 = _vel_vgtlsx_vvssml(vr1, v1, v2, vm1, 256);
8393 }
8394
8395 void __attribute__((noinline))
8396 test_vgtlsx_vvssmvl() {
8397   // CHECK-LABEL: @test_vgtlsx_vvssmvl
8398   // CHECK: call <256 x double> @llvm.ve.vl.vgtlsx.vvssmvl(<256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
8399   vr3 = _vel_vgtlsx_vvssmvl(vr1, v1, v2, vm1, vr3, 256);
8400 }
8401
8402 void __attribute__((noinline))
8403 test_vgtlsxnc_vvssl() {
8404   // CHECK-LABEL: @test_vgtlsxnc_vvssl
8405   // CHECK: call <256 x double> @llvm.ve.vl.vgtlsxnc.vvssl(<256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, i32 256)
8406   vr3 = _vel_vgtlsxnc_vvssl(vr1, v1, v2, 256);
8407 }
8408
8409 void __attribute__((noinline))
8410 test_vgtlsxnc_vvssvl() {
8411   // CHECK-LABEL: @test_vgtlsxnc_vvssvl
8412   // CHECK: call <256 x double> @llvm.ve.vl.vgtlsxnc.vvssvl(<256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
8413   vr3 = _vel_vgtlsxnc_vvssvl(vr1, v1, v2, vr3, 256);
8414 }
8415
8416 void __attribute__((noinline))
8417 test_vgtlsxnc_vvssml() {
8418   // CHECK-LABEL: @test_vgtlsxnc_vvssml
8419   // CHECK: call <256 x double> @llvm.ve.vl.vgtlsxnc.vvssml(<256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, <256 x i1> %{{.*}}, i32 256)
8420   vr3 = _vel_vgtlsxnc_vvssml(vr1, v1, v2, vm1, 256);
8421 }
8422
8423 void __attribute__((noinline))
8424 test_vgtlsxnc_vvssmvl() {
8425   // CHECK-LABEL: @test_vgtlsxnc_vvssmvl
8426   // CHECK: call <256 x double> @llvm.ve.vl.vgtlsxnc.vvssmvl(<256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
8427   vr3 = _vel_vgtlsxnc_vvssmvl(vr1, v1, v2, vm1, vr3, 256);
8428 }
8429
8430 void __attribute__((noinline))
8431 test_vgtlzx_vvssl() {
8432   // CHECK-LABEL: @test_vgtlzx_vvssl
8433   // CHECK: call <256 x double> @llvm.ve.vl.vgtlzx.vvssl(<256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, i32 256)
8434   vr3 = _vel_vgtlzx_vvssl(vr1, v1, v2, 256);
8435 }
8436
8437 void __attribute__((noinline))
8438 test_vgtlzx_vvssvl() {
8439   // CHECK-LABEL: @test_vgtlzx_vvssvl
8440   // CHECK: call <256 x double> @llvm.ve.vl.vgtlzx.vvssvl(<256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
8441   vr3 = _vel_vgtlzx_vvssvl(vr1, v1, v2, vr3, 256);
8442 }
8443
8444 void __attribute__((noinline))
8445 test_vgtlzx_vvssml() {
8446   // CHECK-LABEL: @test_vgtlzx_vvssml
8447   // CHECK: call <256 x double> @llvm.ve.vl.vgtlzx.vvssml(<256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, <256 x i1> %{{.*}}, i32 256)
8448   vr3 = _vel_vgtlzx_vvssml(vr1, v1, v2, vm1, 256);
8449 }
8450
8451 void __attribute__((noinline))
8452 test_vgtlzx_vvssmvl() {
8453   // CHECK-LABEL: @test_vgtlzx_vvssmvl
8454   // CHECK: call <256 x double> @llvm.ve.vl.vgtlzx.vvssmvl(<256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
8455   vr3 = _vel_vgtlzx_vvssmvl(vr1, v1, v2, vm1, vr3, 256);
8456 }
8457
8458 void __attribute__((noinline))
8459 test_vgtlzxnc_vvssl() {
8460   // CHECK-LABEL: @test_vgtlzxnc_vvssl
8461   // CHECK: call <256 x double> @llvm.ve.vl.vgtlzxnc.vvssl(<256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, i32 256)
8462   vr3 = _vel_vgtlzxnc_vvssl(vr1, v1, v2, 256);
8463 }
8464
8465 void __attribute__((noinline))
8466 test_vgtlzxnc_vvssvl() {
8467   // CHECK-LABEL: @test_vgtlzxnc_vvssvl
8468   // CHECK: call <256 x double> @llvm.ve.vl.vgtlzxnc.vvssvl(<256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, <256 x double> %{{.*}}, i32 256)
8469   vr3 = _vel_vgtlzxnc_vvssvl(vr1, v1, v2, vr3, 256);
8470 }
8471
8472 void __attribute__((noinline))
8473 test_vgtlzxnc_vvssml() {
8474   // CHECK-LABEL: @test_vgtlzxnc_vvssml
8475   // CHECK: call <256 x double> @llvm.ve.vl.vgtlzxnc.vvssml(<256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, <256 x i1> %{{.*}}, i32 256)
8476   vr3 = _vel_vgtlzxnc_vvssml(vr1, v1, v2, vm1, 256);
8477 }
8478
8479 void __attribute__((noinline))
8480 test_vgtlzxnc_vvssmvl() {
8481   // CHECK-LABEL: @test_vgtlzxnc_vvssmvl
8482   // CHECK: call <256 x double> @llvm.ve.vl.vgtlzxnc.vvssmvl(<256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, <256 x i1> %{{.*}}, <256 x double> %{{.*}}, i32 256)
8483   vr3 = _vel_vgtlzxnc_vvssmvl(vr1, v1, v2, vm1, vr3, 256);
8484 }
8485
8486 void __attribute__((noinline))
8487 test_vsc_vvssl() {
8488   // CHECK-LABEL: @test_vsc_vvssl
8489   // CHECK: call void @llvm.ve.vl.vsc.vvssl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, i32 256)
8490   _vel_vsc_vvssl(vr1, vr2, v1, v2, 256);
8491 }
8492
8493 void __attribute__((noinline))
8494 test_vsc_vvssml() {
8495   // CHECK-LABEL: @test_vsc_vvssml
8496   // CHECK: call void @llvm.ve.vl.vsc.vvssml(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, <256 x i1> %{{.*}}, i32 256)
8497   _vel_vsc_vvssml(vr1, vr2, v1, v2, vm1, 256);
8498 }
8499
8500 void __attribute__((noinline))
8501 test_vscnc_vvssl() {
8502   // CHECK-LABEL: @test_vscnc_vvssl
8503   // CHECK: call void @llvm.ve.vl.vscnc.vvssl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, i32 256)
8504   _vel_vscnc_vvssl(vr1, vr2, v1, v2, 256);
8505 }
8506
8507 void __attribute__((noinline))
8508 test_vscnc_vvssml() {
8509   // CHECK-LABEL: @test_vscnc_vvssml
8510   // CHECK: call void @llvm.ve.vl.vscnc.vvssml(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, <256 x i1> %{{.*}}, i32 256)
8511   _vel_vscnc_vvssml(vr1, vr2, v1, v2, vm1, 256);
8512 }
8513
8514 void __attribute__((noinline))
8515 test_vscot_vvssl() {
8516   // CHECK-LABEL: @test_vscot_vvssl
8517   // CHECK: call void @llvm.ve.vl.vscot.vvssl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, i32 256)
8518   _vel_vscot_vvssl(vr1, vr2, v1, v2, 256);
8519 }
8520
8521 void __attribute__((noinline))
8522 test_vscot_vvssml() {
8523   // CHECK-LABEL: @test_vscot_vvssml
8524   // CHECK: call void @llvm.ve.vl.vscot.vvssml(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, <256 x i1> %{{.*}}, i32 256)
8525   _vel_vscot_vvssml(vr1, vr2, v1, v2, vm1, 256);
8526 }
8527
8528 void __attribute__((noinline))
8529 test_vscncot_vvssl() {
8530   // CHECK-LABEL: @test_vscncot_vvssl
8531   // CHECK: call void @llvm.ve.vl.vscncot.vvssl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, i32 256)
8532   _vel_vscncot_vvssl(vr1, vr2, v1, v2, 256);
8533 }
8534
8535 void __attribute__((noinline))
8536 test_vscncot_vvssml() {
8537   // CHECK-LABEL: @test_vscncot_vvssml
8538   // CHECK: call void @llvm.ve.vl.vscncot.vvssml(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, <256 x i1> %{{.*}}, i32 256)
8539   _vel_vscncot_vvssml(vr1, vr2, v1, v2, vm1, 256);
8540 }
8541
8542 void __attribute__((noinline))
8543 test_vscu_vvssl() {
8544   // CHECK-LABEL: @test_vscu_vvssl
8545   // CHECK: call void @llvm.ve.vl.vscu.vvssl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, i32 256)
8546   _vel_vscu_vvssl(vr1, vr2, v1, v2, 256);
8547 }
8548
8549 void __attribute__((noinline))
8550 test_vscu_vvssml() {
8551   // CHECK-LABEL: @test_vscu_vvssml
8552   // CHECK: call void @llvm.ve.vl.vscu.vvssml(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, <256 x i1> %{{.*}}, i32 256)
8553   _vel_vscu_vvssml(vr1, vr2, v1, v2, vm1, 256);
8554 }
8555
8556 void __attribute__((noinline))
8557 test_vscunc_vvssl() {
8558   // CHECK-LABEL: @test_vscunc_vvssl
8559   // CHECK: call void @llvm.ve.vl.vscunc.vvssl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, i32 256)
8560   _vel_vscunc_vvssl(vr1, vr2, v1, v2, 256);
8561 }
8562
8563 void __attribute__((noinline))
8564 test_vscunc_vvssml() {
8565   // CHECK-LABEL: @test_vscunc_vvssml
8566   // CHECK: call void @llvm.ve.vl.vscunc.vvssml(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, <256 x i1> %{{.*}}, i32 256)
8567   _vel_vscunc_vvssml(vr1, vr2, v1, v2, vm1, 256);
8568 }
8569
8570 void __attribute__((noinline))
8571 test_vscuot_vvssl() {
8572   // CHECK-LABEL: @test_vscuot_vvssl
8573   // CHECK: call void @llvm.ve.vl.vscuot.vvssl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, i32 256)
8574   _vel_vscuot_vvssl(vr1, vr2, v1, v2, 256);
8575 }
8576
8577 void __attribute__((noinline))
8578 test_vscuot_vvssml() {
8579   // CHECK-LABEL: @test_vscuot_vvssml
8580   // CHECK: call void @llvm.ve.vl.vscuot.vvssml(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, <256 x i1> %{{.*}}, i32 256)
8581   _vel_vscuot_vvssml(vr1, vr2, v1, v2, vm1, 256);
8582 }
8583
8584 void __attribute__((noinline))
8585 test_vscuncot_vvssl() {
8586   // CHECK-LABEL: @test_vscuncot_vvssl
8587   // CHECK: call void @llvm.ve.vl.vscuncot.vvssl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, i32 256)
8588   _vel_vscuncot_vvssl(vr1, vr2, v1, v2, 256);
8589 }
8590
8591 void __attribute__((noinline))
8592 test_vscuncot_vvssml() {
8593   // CHECK-LABEL: @test_vscuncot_vvssml
8594   // CHECK: call void @llvm.ve.vl.vscuncot.vvssml(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, <256 x i1> %{{.*}}, i32 256)
8595   _vel_vscuncot_vvssml(vr1, vr2, v1, v2, vm1, 256);
8596 }
8597
8598 void __attribute__((noinline))
8599 test_vscl_vvssl() {
8600   // CHECK-LABEL: @test_vscl_vvssl
8601   // CHECK: call void @llvm.ve.vl.vscl.vvssl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, i32 256)
8602   _vel_vscl_vvssl(vr1, vr2, v1, v2, 256);
8603 }
8604
8605 void __attribute__((noinline))
8606 test_vscl_vvssml() {
8607   // CHECK-LABEL: @test_vscl_vvssml
8608   // CHECK: call void @llvm.ve.vl.vscl.vvssml(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, <256 x i1> %{{.*}}, i32 256)
8609   _vel_vscl_vvssml(vr1, vr2, v1, v2, vm1, 256);
8610 }
8611
8612 void __attribute__((noinline))
8613 test_vsclnc_vvssl() {
8614   // CHECK-LABEL: @test_vsclnc_vvssl
8615   // CHECK: call void @llvm.ve.vl.vsclnc.vvssl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, i32 256)
8616   _vel_vsclnc_vvssl(vr1, vr2, v1, v2, 256);
8617 }
8618
8619 void __attribute__((noinline))
8620 test_vsclnc_vvssml() {
8621   // CHECK-LABEL: @test_vsclnc_vvssml
8622   // CHECK: call void @llvm.ve.vl.vsclnc.vvssml(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, <256 x i1> %{{.*}}, i32 256)
8623   _vel_vsclnc_vvssml(vr1, vr2, v1, v2, vm1, 256);
8624 }
8625
8626 void __attribute__((noinline))
8627 test_vsclot_vvssl() {
8628   // CHECK-LABEL: @test_vsclot_vvssl
8629   // CHECK: call void @llvm.ve.vl.vsclot.vvssl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, i32 256)
8630   _vel_vsclot_vvssl(vr1, vr2, v1, v2, 256);
8631 }
8632
8633 void __attribute__((noinline))
8634 test_vsclot_vvssml() {
8635   // CHECK-LABEL: @test_vsclot_vvssml
8636   // CHECK: call void @llvm.ve.vl.vsclot.vvssml(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, <256 x i1> %{{.*}}, i32 256)
8637   _vel_vsclot_vvssml(vr1, vr2, v1, v2, vm1, 256);
8638 }
8639
8640 void __attribute__((noinline))
8641 test_vsclncot_vvssl() {
8642   // CHECK-LABEL: @test_vsclncot_vvssl
8643   // CHECK: call void @llvm.ve.vl.vsclncot.vvssl(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, i32 256)
8644   _vel_vsclncot_vvssl(vr1, vr2, v1, v2, 256);
8645 }
8646
8647 void __attribute__((noinline))
8648 test_vsclncot_vvssml() {
8649   // CHECK-LABEL: @test_vsclncot_vvssml
8650   // CHECK: call void @llvm.ve.vl.vsclncot.vvssml(<256 x double> %{{.*}}, <256 x double> %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, <256 x i1> %{{.*}}, i32 256)
8651   _vel_vsclncot_vvssml(vr1, vr2, v1, v2, vm1, 256);
8652 }
8653
8654 void __attribute__((noinline))
8655 test_andm_mmm() {
8656   // CHECK-LABEL: @test_andm_mmm
8657   // CHECK: call <256 x i1> @llvm.ve.vl.andm.mmm(<256 x i1> %{{.*}}, <256 x i1> %{{.*}})
8658   vm3 = _vel_andm_mmm(vm1, vm2);
8659 }
8660
8661 void __attribute__((noinline))
8662 test_andm_MMM() {
8663   // CHECK-LABEL: @test_andm_MMM
8664   // CHECK: call <512 x i1> @llvm.ve.vl.andm.MMM(<512 x i1> %{{.*}}, <512 x i1> %{{.*}})
8665   vm3_512 = _vel_andm_MMM(vm1_512, vm2_512);
8666 }
8667
8668 void __attribute__((noinline))
8669 test_orm_mmm() {
8670   // CHECK-LABEL: @test_orm_mmm
8671   // CHECK: call <256 x i1> @llvm.ve.vl.orm.mmm(<256 x i1> %{{.*}}, <256 x i1> %{{.*}})
8672   vm3 = _vel_orm_mmm(vm1, vm2);
8673 }
8674
8675 void __attribute__((noinline))
8676 test_orm_MMM() {
8677   // CHECK-LABEL: @test_orm_MMM
8678   // CHECK: call <512 x i1> @llvm.ve.vl.orm.MMM(<512 x i1> %{{.*}}, <512 x i1> %{{.*}})
8679   vm3_512 = _vel_orm_MMM(vm1_512, vm2_512);
8680 }
8681
8682 void __attribute__((noinline))
8683 test_xorm_mmm() {
8684   // CHECK-LABEL: @test_xorm_mmm
8685   // CHECK: call <256 x i1> @llvm.ve.vl.xorm.mmm(<256 x i1> %{{.*}}, <256 x i1> %{{.*}})
8686   vm3 = _vel_xorm_mmm(vm1, vm2);
8687 }
8688
8689 void __attribute__((noinline))
8690 test_xorm_MMM() {
8691   // CHECK-LABEL: @test_xorm_MMM
8692   // CHECK: call <512 x i1> @llvm.ve.vl.xorm.MMM(<512 x i1> %{{.*}}, <512 x i1> %{{.*}})
8693   vm3_512 = _vel_xorm_MMM(vm1_512, vm2_512);
8694 }
8695
8696 void __attribute__((noinline))
8697 test_eqvm_mmm() {
8698   // CHECK-LABEL: @test_eqvm_mmm
8699   // CHECK: call <256 x i1> @llvm.ve.vl.eqvm.mmm(<256 x i1> %{{.*}}, <256 x i1> %{{.*}})
8700   vm3 = _vel_eqvm_mmm(vm1, vm2);
8701 }
8702
8703 void __attribute__((noinline))
8704 test_eqvm_MMM() {
8705   // CHECK-LABEL: @test_eqvm_MMM
8706   // CHECK: call <512 x i1> @llvm.ve.vl.eqvm.MMM(<512 x i1> %{{.*}}, <512 x i1> %{{.*}})
8707   vm3_512 = _vel_eqvm_MMM(vm1_512, vm2_512);
8708 }
8709
8710 void __attribute__((noinline))
8711 test_nndm_mmm() {
8712   // CHECK-LABEL: @test_nndm_mmm
8713   // CHECK: call <256 x i1> @llvm.ve.vl.nndm.mmm(<256 x i1> %{{.*}}, <256 x i1> %{{.*}})
8714   vm3 = _vel_nndm_mmm(vm1, vm2);
8715 }
8716
8717 void __attribute__((noinline))
8718 test_nndm_MMM() {
8719   // CHECK-LABEL: @test_nndm_MMM
8720   // CHECK: call <512 x i1> @llvm.ve.vl.nndm.MMM(<512 x i1> %{{.*}}, <512 x i1> %{{.*}})
8721   vm3_512 = _vel_nndm_MMM(vm1_512, vm2_512);
8722 }
8723
8724 void __attribute__((noinline))
8725 test_negm_mm() {
8726   // CHECK-LABEL: @test_negm_mm
8727   // CHECK: call <256 x i1> @llvm.ve.vl.negm.mm(<256 x i1> %{{.*}})
8728   vm2 = _vel_negm_mm(vm1);
8729 }
8730
8731 void __attribute__((noinline))
8732 test_negm_MM() {
8733   // CHECK-LABEL: @test_negm_MM
8734   // CHECK: call <512 x i1> @llvm.ve.vl.negm.MM(<512 x i1> %{{.*}})
8735   vm2_512 = _vel_negm_MM(vm1_512);
8736 }
8737
8738 void __attribute__((noinline))
8739 test_pcvm_sml() {
8740   // CHECK-LABEL: @test_pcvm_sml
8741   // CHECK: call i64 @llvm.ve.vl.pcvm.sml(<256 x i1> %{{.*}}, i32 256)
8742   v1 = _vel_pcvm_sml(vm1, 256);
8743 }
8744
8745 void __attribute__((noinline))
8746 test_lzvm_sml() {
8747   // CHECK-LABEL: @test_lzvm_sml
8748   // CHECK: call i64 @llvm.ve.vl.lzvm.sml(<256 x i1> %{{.*}}, i32 256)
8749   v1 = _vel_lzvm_sml(vm1, 256);
8750 }
8751
8752 void __attribute__((noinline))
8753 test_tovm_sml() {
8754   // CHECK-LABEL: @test_tovm_sml
8755   // CHECK: call i64 @llvm.ve.vl.tovm.sml(<256 x i1> %{{.*}}, i32 256)
8756   v1 = _vel_tovm_sml(vm1, 256);
8757 }
8758
8759 void __attribute__((noinline))
8760 test_lcr_sss() {
8761   // CHECK-LABEL: @test_lcr_sss
8762   // CHECK: call i64 @llvm.ve.vl.lcr.sss(i64 %{{.*}}, i64 %{{.*}})
8763   v3 = _vel_lcr_sss(v1, v2);
8764 }
8765
8766 void __attribute__((noinline))
8767 test_scr_sss() {
8768   // CHECK-LABEL: @test_scr_sss
8769   // CHECK: call void @llvm.ve.vl.scr.sss(i64 %{{.*}}, i64 %{{.*}}, i64 %{{.*}})
8770   _vel_scr_sss(v1, v2, v3);
8771 }
8772
8773 void __attribute__((noinline))
8774 test_tscr_ssss() {
8775   // CHECK-LABEL: @test_tscr_ssss
8776   // CHECK: call i64 @llvm.ve.vl.tscr.ssss(i64 %{{.*}}, i64 %{{.*}}, i64 %{{.*}})
8777   v3 = _vel_tscr_ssss(v1, v2, v3);
8778 }
8779
8780 void __attribute__((noinline))
8781 test_fidcr_sss() {
8782   // CHECK-LABEL: @test_fidcr_sss
8783   // CHECK: call i64 @llvm.ve.vl.fidcr.sss(i64 %{{.*}}, i32 0)
8784   v2 = _vel_fidcr_sss(v1, 0);
8785 }
8786
8787 void __attribute__((noinline))
8788 test_fencei() {
8789   // CHECK-LABEL: @test_fencei
8790   // CHECK: call void @llvm.ve.vl.fencei()
8791   _vel_fencei();
8792 }
8793
8794 void __attribute__((noinline))
8795 test_fencem_s() {
8796   // CHECK-LABEL: @test_fencem_s
8797   // CHECK: call void @llvm.ve.vl.fencem.s(i32 0)
8798   _vel_fencem_s(0);
8799 }
8800
8801 void __attribute__((noinline))
8802 test_fencec_s() {
8803   // CHECK-LABEL: @test_fencec_s
8804   // CHECK: call void @llvm.ve.vl.fencec.s(i32 0)
8805   _vel_fencec_s(0);
8806 }
8807
8808 void __attribute__((noinline))
8809 test_svob() {
8810   // CHECK-LABEL: @test_svob
8811   // CHECK: call void @llvm.ve.vl.svob()
8812   _vel_svob();
8813 }
8814
8815 void __attribute__((noinline))
8816 test_pack_f32p(float* p1, float* p2) {
8817   // CHECK-LABEL: @test_pack_f32p
8818   // CHECK: call i64 @llvm.ve.vl.pack.f32p(ptr %{{.*}}, ptr %{{.*}})
8819   v1 = _vel_pack_f32p(p1, p2);
8820 }
8821
8822 void __attribute__((noinline))
8823 test_pack_f32a(float* p) {
8824   // CHECK-LABEL: @test_pack_f32a
8825   // CHECK: call i64 @llvm.ve.vl.pack.f32a(ptr %{{.*}})
8826   v1 = _vel_pack_f32a(p);
8827 }
8828
8829 void __attribute__((noinline))
8830 test_extract_vm512u() {
8831   // CHECK-LABEL: @test_extract_vm512u
8832   // CHECK: call <256 x i1> @llvm.ve.vl.extract.vm512u(<512 x i1> %{{.*}})
8833   vm1 = _vel_extract_vm512u(vm1_512);
8834 }
8835
8836 void __attribute__((noinline))
8837 test_extract_vm512l() {
8838   // CHECK-LABEL: @test_extract_vm512l
8839   // CHECK: call <256 x i1> @llvm.ve.vl.extract.vm512l(<512 x i1> %{{.*}})
8840   vm1 = _vel_extract_vm512l(vm1_512);
8841 }
8842
8843 void __attribute__((noinline))
8844 test_insert_vm512u() {
8845   // CHECK-LABEL: @test_insert_vm512u
8846   // CHECK: call <512 x i1> @llvm.ve.vl.insert.vm512u(<512 x i1> %{{.*}}, <256 x i1> %{{.*}})
8847   vm1_512 = _vel_insert_vm512u(vm1_512, vm1);
8848 }
8849
8850 void __attribute__((noinline))
8851 test_insert_vm512l() {
8852   // CHECK-LABEL: @test_insert_vm512l
8853   // CHECK: call <512 x i1> @llvm.ve.vl.insert.vm512l(<512 x i1> %{{.*}}, <256 x i1> %{{.*}})
8854   vm1_512 = _vel_insert_vm512l(vm1_512, vm1);
8855 }