1 // REQUIRES: systemz-registered-target 2 // RUN: %clang_cc1 -target-cpu z13 -triple s390x-linux-gnu \ 3 // RUN: -O2 -fzvector -flax-vector-conversions=none \ 4 // RUN: -Wall -Wno-unused -Werror -emit-llvm %s -o - | FileCheck %s 5 // RUN: %clang_cc1 -target-cpu z13 -triple s390x-linux-gnu \ 6 // RUN: -O2 -fzvector -flax-vector-conversions=none \ 7 // RUN: -Wall -Wno-unused -Werror -S %s -o - | FileCheck %s --check-prefix=CHECK-ASM 8 9 #include <vecintrin.h> 10 11 volatile vector signed char vsc; 12 volatile vector signed short vss; 13 volatile vector signed int vsi; 14 volatile vector signed long long vsl; 15 volatile vector unsigned char vuc; 16 volatile vector unsigned short vus; 17 volatile vector unsigned int vui; 18 volatile vector unsigned long long vul; 19 volatile vector bool char vbc; 20 volatile vector bool short vbs; 21 volatile vector bool int vbi; 22 volatile vector bool long long vbl; 23 volatile vector double vd; 24 25 volatile signed char sc; 26 volatile signed short ss; 27 volatile signed int si; 28 volatile signed long long sl; 29 volatile unsigned char uc; 30 volatile unsigned short us; 31 volatile unsigned int ui; 32 volatile unsigned long long ul; 33 volatile double d; 34 35 const void * volatile cptr; 36 const signed char * volatile cptrsc; 37 const signed short * volatile cptrss; 38 const signed int * volatile cptrsi; 39 const signed long long * volatile cptrsl; 40 const unsigned char * volatile cptruc; 41 const unsigned short * volatile cptrus; 42 const unsigned int * volatile cptrui; 43 const unsigned long long * volatile cptrul; 44 const float * volatile cptrf; 45 const double * volatile cptrd; 46 47 void * volatile ptr; 48 signed char * volatile ptrsc; 49 signed short * volatile ptrss; 50 signed int * volatile ptrsi; 51 signed long long * volatile ptrsl; 52 unsigned char * volatile ptruc; 53 unsigned short * volatile ptrus; 54 unsigned int * volatile ptrui; 55 unsigned long long * volatile ptrul; 56 float * volatile ptrf; 57 double * volatile ptrd; 58 59 volatile unsigned int len; 60 volatile int idx; 61 int cc; 62 63 void test_core(void) { 64 // CHECK-ASM-LABEL: test_core 65 66 len = __lcbb(cptr, 64); 67 // CHECK: call i32 @llvm.s390.lcbb(i8* %{{.*}}, i32 0) 68 // CHECK-ASM: lcbb 69 len = __lcbb(cptr, 128); 70 // CHECK: call i32 @llvm.s390.lcbb(i8* %{{.*}}, i32 1) 71 // CHECK-ASM: lcbb 72 len = __lcbb(cptr, 256); 73 // CHECK: call i32 @llvm.s390.lcbb(i8* %{{.*}}, i32 2) 74 // CHECK-ASM: lcbb 75 len = __lcbb(cptr, 512); 76 // CHECK: call i32 @llvm.s390.lcbb(i8* %{{.*}}, i32 3) 77 // CHECK-ASM: lcbb 78 len = __lcbb(cptr, 1024); 79 // CHECK: call i32 @llvm.s390.lcbb(i8* %{{.*}}, i32 4) 80 // CHECK-ASM: lcbb 81 len = __lcbb(cptr, 2048); 82 // CHECK: call i32 @llvm.s390.lcbb(i8* %{{.*}}, i32 5) 83 // CHECK-ASM: lcbb 84 len = __lcbb(cptr, 4096); 85 // CHECK: call i32 @llvm.s390.lcbb(i8* %{{.*}}, i32 6) 86 // CHECK-ASM: lcbb 87 88 sc = vec_extract(vsc, idx); 89 // CHECK: extractelement <16 x i8> %{{.*}}, i32 %{{.*}} 90 // CHECK-ASM: vlgvb 91 uc = vec_extract(vuc, idx); 92 // CHECK: extractelement <16 x i8> %{{.*}}, i32 %{{.*}} 93 // CHECK-ASM: vlgvb 94 uc = vec_extract(vbc, idx); 95 // CHECK: extractelement <16 x i8> %{{.*}}, i32 %{{.*}} 96 // CHECK-ASM: vlgvb 97 ss = vec_extract(vss, idx); 98 // CHECK: extractelement <8 x i16> %{{.*}}, i32 %{{.*}} 99 // CHECK-ASM: vlgvh 100 us = vec_extract(vus, idx); 101 // CHECK: extractelement <8 x i16> %{{.*}}, i32 %{{.*}} 102 // CHECK-ASM: vlgvh 103 us = vec_extract(vbs, idx); 104 // CHECK: extractelement <8 x i16> %{{.*}}, i32 %{{.*}} 105 // CHECK-ASM: vlgvh 106 si = vec_extract(vsi, idx); 107 // CHECK: extractelement <4 x i32> %{{.*}}, i32 %{{.*}} 108 // CHECK-ASM: vlgvf 109 ui = vec_extract(vui, idx); 110 // CHECK: extractelement <4 x i32> %{{.*}}, i32 %{{.*}} 111 // CHECK-ASM: vlgvf 112 ui = vec_extract(vbi, idx); 113 // CHECK: extractelement <4 x i32> %{{.*}}, i32 %{{.*}} 114 // CHECK-ASM: vlgvf 115 sl = vec_extract(vsl, idx); 116 // CHECK: extractelement <2 x i64> %{{.*}}, i32 %{{.*}} 117 // CHECK-ASM: vlgvg 118 ul = vec_extract(vul, idx); 119 // CHECK: extractelement <2 x i64> %{{.*}}, i32 %{{.*}} 120 // CHECK-ASM: vlgvg 121 ul = vec_extract(vbl, idx); 122 // CHECK: extractelement <2 x i64> %{{.*}}, i32 %{{.*}} 123 // CHECK-ASM: vlgvg 124 d = vec_extract(vd, idx); 125 // CHECK: extractelement <2 x double> %{{.*}}, i32 %{{.*}} 126 // CHECK-ASM: vlgvg 127 128 vsc = vec_insert(sc, vsc, idx); 129 // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 %{{.*}} 130 // CHECK-ASM: vlvgb 131 vuc = vec_insert(uc, vuc, idx); 132 // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 %{{.*}} 133 // CHECK-ASM: vlvgb 134 vuc = vec_insert(uc, vbc, idx); 135 // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 %{{.*}} 136 // CHECK-ASM: vlvgb 137 vss = vec_insert(ss, vss, idx); 138 // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 %{{.*}} 139 // CHECK-ASM: vlvgh 140 vus = vec_insert(us, vus, idx); 141 // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 %{{.*}} 142 // CHECK-ASM: vlvgh 143 vus = vec_insert(us, vbs, idx); 144 // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 %{{.*}} 145 // CHECK-ASM: vlvgh 146 vsi = vec_insert(si, vsi, idx); 147 // CHECK: insertelement <4 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}} 148 // CHECK-ASM: vlvgf 149 vui = vec_insert(ui, vui, idx); 150 // CHECK: insertelement <4 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}} 151 // CHECK-ASM: vlvgf 152 vui = vec_insert(ui, vbi, idx); 153 // CHECK: insertelement <4 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}} 154 // CHECK-ASM: vlvgf 155 vsl = vec_insert(sl, vsl, idx); 156 // CHECK: insertelement <2 x i64> %{{.*}}, i64 %{{.*}}, i32 %{{.*}} 157 // CHECK-ASM: vlvgg 158 vul = vec_insert(ul, vul, idx); 159 // CHECK: insertelement <2 x i64> %{{.*}}, i64 %{{.*}}, i32 %{{.*}} 160 // CHECK-ASM: vlvgg 161 vul = vec_insert(ul, vbl, idx); 162 // CHECK: insertelement <2 x i64> %{{.*}}, i64 %{{.*}}, i32 %{{.*}} 163 // CHECK-ASM: vlvgg 164 vd = vec_insert(d, vd, idx); 165 // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 %{{.*}} 166 // CHECK-ASM: vlvgg 167 168 vsc = vec_promote(sc, idx); 169 // CHECK: insertelement <16 x i8> undef, i8 %{{.*}}, i32 %{{.*}} 170 // CHECK-ASM: vlvgb 171 vuc = vec_promote(uc, idx); 172 // CHECK: insertelement <16 x i8> undef, i8 %{{.*}}, i32 %{{.*}} 173 // CHECK-ASM: vlvgb 174 vss = vec_promote(ss, idx); 175 // CHECK: insertelement <8 x i16> undef, i16 %{{.*}}, i32 %{{.*}} 176 // CHECK-ASM: vlvgh 177 vus = vec_promote(us, idx); 178 // CHECK: insertelement <8 x i16> undef, i16 %{{.*}}, i32 %{{.*}} 179 // CHECK-ASM: vlvgh 180 vsi = vec_promote(si, idx); 181 // CHECK: insertelement <4 x i32> undef, i32 %{{.*}}, i32 %{{.*}} 182 // CHECK-ASM: vlvgf 183 vui = vec_promote(ui, idx); 184 // CHECK: insertelement <4 x i32> undef, i32 %{{.*}}, i32 %{{.*}} 185 // CHECK-ASM: vlvgf 186 vsl = vec_promote(sl, idx); 187 // CHECK: insertelement <2 x i64> undef, i64 %{{.*}}, i32 %{{.*}} 188 // CHECK-ASM: vlvgg 189 vul = vec_promote(ul, idx); 190 // CHECK: insertelement <2 x i64> undef, i64 %{{.*}}, i32 %{{.*}} 191 // CHECK-ASM: vlvgg 192 vd = vec_promote(d, idx); 193 // CHECK: insertelement <2 x double> undef, double %{{.*}}, i32 %{{.*}} 194 // CHECK-ASM: vlvgg 195 196 vsc = vec_insert_and_zero(cptrsc); 197 // CHECK: insertelement <16 x i8> <i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 poison, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0>, i8 %{{.*}}, i32 7 198 // CHECK-ASM: vllezb 199 vuc = vec_insert_and_zero(cptruc); 200 // CHECK: insertelement <16 x i8> <i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 poison, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0>, i8 %{{.*}}, i32 7 201 // CHECK-ASM: vllezb 202 vss = vec_insert_and_zero(cptrss); 203 // CHECK: insertelement <8 x i16> <i16 0, i16 0, i16 0, i16 poison, i16 0, i16 0, i16 0, i16 0>, i16 %{{.*}}, i32 3 204 // CHECK-ASM: vllezh 205 vus = vec_insert_and_zero(cptrus); 206 // CHECK: insertelement <8 x i16> <i16 0, i16 0, i16 0, i16 poison, i16 0, i16 0, i16 0, i16 0>, i16 %{{.*}}, i32 3 207 // CHECK-ASM: vllezh 208 vsi = vec_insert_and_zero(cptrsi); 209 // CHECK: insertelement <4 x i32> <i32 0, i32 poison, i32 0, i32 0>, i32 %{{.*}}, i32 1 210 // CHECK-ASM: vllezf 211 vui = vec_insert_and_zero(cptrui); 212 // CHECK: insertelement <4 x i32> <i32 0, i32 poison, i32 0, i32 0>, i32 %{{.*}}, i32 1 213 // CHECK-ASM: vllezf 214 vsl = vec_insert_and_zero(cptrsl); 215 // CHECK: insertelement <2 x i64> <i64 poison, i64 0>, i64 %{{.*}}, i32 0 216 // CHECK-ASM: vllezg 217 vul = vec_insert_and_zero(cptrul); 218 // CHECK: insertelement <2 x i64> <i64 poison, i64 0>, i64 %{{.*}}, i32 0 219 // CHECK-ASM: vllezg 220 vd = vec_insert_and_zero(cptrd); 221 // CHECK: insertelement <2 x double> <double poison, double 0.000000e+00>, double %{{.*}}, i32 0 222 // CHECK-ASM: vllezg 223 224 vsc = vec_perm(vsc, vsc, vuc); 225 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 226 // CHECK-ASM: vperm 227 vuc = vec_perm(vuc, vuc, vuc); 228 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 229 // CHECK-ASM: vperm 230 vbc = vec_perm(vbc, vbc, vuc); 231 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 232 // CHECK-ASM: vperm 233 vss = vec_perm(vss, vss, vuc); 234 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 235 // CHECK-ASM: vperm 236 vus = vec_perm(vus, vus, vuc); 237 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 238 // CHECK-ASM: vperm 239 vbs = vec_perm(vbs, vbs, vuc); 240 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 241 // CHECK-ASM: vperm 242 vsi = vec_perm(vsi, vsi, vuc); 243 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 244 // CHECK-ASM: vperm 245 vui = vec_perm(vui, vui, vuc); 246 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 247 // CHECK-ASM: vperm 248 vbi = vec_perm(vbi, vbi, vuc); 249 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 250 // CHECK-ASM: vperm 251 vsl = vec_perm(vsl, vsl, vuc); 252 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 253 // CHECK-ASM: vperm 254 vul = vec_perm(vul, vul, vuc); 255 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 256 // CHECK-ASM: vperm 257 vbl = vec_perm(vbl, vbl, vuc); 258 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 259 // CHECK-ASM: vperm 260 vd = vec_perm(vd, vd, vuc); 261 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 262 // CHECK-ASM: vperm 263 264 vsl = vec_permi(vsl, vsl, 0); 265 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 0) 266 // CHECK-ASM: vpdi 267 vsl = vec_permi(vsl, vsl, 1); 268 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 1) 269 // CHECK-ASM: vpdi 270 vsl = vec_permi(vsl, vsl, 2); 271 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 4) 272 // CHECK-ASM: vpdi 273 vsl = vec_permi(vsl, vsl, 3); 274 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 5) 275 // CHECK-ASM: vpdi 276 vul = vec_permi(vul, vul, 0); 277 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 0) 278 // CHECK-ASM: vpdi 279 vul = vec_permi(vul, vul, 1); 280 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 1) 281 // CHECK-ASM: vpdi 282 vul = vec_permi(vul, vul, 2); 283 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 4) 284 // CHECK-ASM: vpdi 285 vul = vec_permi(vul, vul, 3); 286 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 5) 287 // CHECK-ASM: vpdi 288 vbl = vec_permi(vbl, vbl, 0); 289 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 0) 290 // CHECK-ASM: vpdi 291 vbl = vec_permi(vbl, vbl, 1); 292 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 1) 293 // CHECK-ASM: vpdi 294 vbl = vec_permi(vbl, vbl, 2); 295 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 4) 296 // CHECK-ASM: vpdi 297 vbl = vec_permi(vbl, vbl, 3); 298 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 5) 299 // CHECK-ASM: vpdi 300 vd = vec_permi(vd, vd, 0); 301 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 0) 302 // CHECK-ASM: vpdi 303 vd = vec_permi(vd, vd, 1); 304 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 1) 305 // CHECK-ASM: vpdi 306 vd = vec_permi(vd, vd, 2); 307 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 4) 308 // CHECK-ASM: vpdi 309 vd = vec_permi(vd, vd, 3); 310 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 5) 311 // CHECK-ASM: vpdi 312 313 vss = vec_revb(vss); 314 // CHECK-ASM: vperm 315 vus = vec_revb(vus); 316 // CHECK-ASM: vperm 317 vsi = vec_revb(vsi); 318 // CHECK-ASM: vperm 319 vui = vec_revb(vui); 320 // CHECK-ASM: vperm 321 vsl = vec_revb(vsl); 322 // CHECK-ASM: vperm 323 vul = vec_revb(vul); 324 // CHECK-ASM: vperm 325 vd = vec_revb(vd); 326 // CHECK-ASM: vperm 327 328 vsc = vec_reve(vsc); 329 // CHECK-ASM: vperm 330 vuc = vec_reve(vuc); 331 // CHECK-ASM: vperm 332 vbc = vec_reve(vbc); 333 // CHECK-ASM: vperm 334 vss = vec_reve(vss); 335 // CHECK-ASM: vperm 336 vus = vec_reve(vus); 337 // CHECK-ASM: vperm 338 vbs = vec_reve(vbs); 339 // CHECK-ASM: vperm 340 vsi = vec_reve(vsi); 341 // CHECK-ASM: vperm 342 vui = vec_reve(vui); 343 // CHECK-ASM: vperm 344 vbi = vec_reve(vbi); 345 // CHECK-ASM: vperm 346 vsl = vec_reve(vsl); 347 // CHECK-ASM: {{vperm|vpdi}} 348 vul = vec_reve(vul); 349 // CHECK-ASM: {{vperm|vpdi}} 350 vbl = vec_reve(vbl); 351 // CHECK-ASM: {{vperm|vpdi}} 352 vd = vec_reve(vd); 353 // CHECK-ASM: {{vperm|vpdi}} 354 355 vsc = vec_sel(vsc, vsc, vuc); 356 // CHECK-ASM: vsel 357 vsc = vec_sel(vsc, vsc, vbc); 358 // CHECK-ASM: vsel 359 vuc = vec_sel(vuc, vuc, vuc); 360 // CHECK-ASM: vsel 361 vuc = vec_sel(vuc, vuc, vbc); 362 // CHECK-ASM: vsel 363 vbc = vec_sel(vbc, vbc, vuc); 364 // CHECK-ASM: vsel 365 vbc = vec_sel(vbc, vbc, vbc); 366 // CHECK-ASM: vsel 367 vss = vec_sel(vss, vss, vus); 368 // CHECK-ASM: vsel 369 vss = vec_sel(vss, vss, vbs); 370 // CHECK-ASM: vsel 371 vus = vec_sel(vus, vus, vus); 372 // CHECK-ASM: vsel 373 vus = vec_sel(vus, vus, vbs); 374 // CHECK-ASM: vsel 375 vbs = vec_sel(vbs, vbs, vus); 376 // CHECK-ASM: vsel 377 vbs = vec_sel(vbs, vbs, vbs); 378 // CHECK-ASM: vsel 379 vsi = vec_sel(vsi, vsi, vui); 380 // CHECK-ASM: vsel 381 vsi = vec_sel(vsi, vsi, vbi); 382 // CHECK-ASM: vsel 383 vui = vec_sel(vui, vui, vui); 384 // CHECK-ASM: vsel 385 vui = vec_sel(vui, vui, vbi); 386 // CHECK-ASM: vsel 387 vbi = vec_sel(vbi, vbi, vui); 388 // CHECK-ASM: vsel 389 vbi = vec_sel(vbi, vbi, vbi); 390 // CHECK-ASM: vsel 391 vsl = vec_sel(vsl, vsl, vul); 392 // CHECK-ASM: vsel 393 vsl = vec_sel(vsl, vsl, vbl); 394 // CHECK-ASM: vsel 395 vul = vec_sel(vul, vul, vul); 396 // CHECK-ASM: vsel 397 vul = vec_sel(vul, vul, vbl); 398 // CHECK-ASM: vsel 399 vbl = vec_sel(vbl, vbl, vul); 400 // CHECK-ASM: vsel 401 vbl = vec_sel(vbl, vbl, vbl); 402 // CHECK-ASM: vsel 403 vd = vec_sel(vd, vd, vul); 404 // CHECK-ASM: vsel 405 vd = vec_sel(vd, vd, vbl); 406 // CHECK-ASM: vsel 407 408 vsi = vec_gather_element(vsi, vui, cptrsi, 0); 409 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 0 410 vsi = vec_gather_element(vsi, vui, cptrsi, 1); 411 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 1 412 vsi = vec_gather_element(vsi, vui, cptrsi, 2); 413 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 2 414 vsi = vec_gather_element(vsi, vui, cptrsi, 3); 415 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 3 416 vui = vec_gather_element(vui, vui, cptrui, 0); 417 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 0 418 vui = vec_gather_element(vui, vui, cptrui, 1); 419 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 1 420 vui = vec_gather_element(vui, vui, cptrui, 2); 421 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 2 422 vui = vec_gather_element(vui, vui, cptrui, 3); 423 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 3 424 vbi = vec_gather_element(vbi, vui, cptrui, 0); 425 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 0 426 vbi = vec_gather_element(vbi, vui, cptrui, 1); 427 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 1 428 vbi = vec_gather_element(vbi, vui, cptrui, 2); 429 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 2 430 vbi = vec_gather_element(vbi, vui, cptrui, 3); 431 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 3 432 vsl = vec_gather_element(vsl, vul, cptrsl, 0); 433 // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 0 434 vsl = vec_gather_element(vsl, vul, cptrsl, 1); 435 // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 1 436 vul = vec_gather_element(vul, vul, cptrul, 0); 437 // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 0 438 vul = vec_gather_element(vul, vul, cptrul, 1); 439 // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 1 440 vbl = vec_gather_element(vbl, vul, cptrul, 0); 441 // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 0 442 vbl = vec_gather_element(vbl, vul, cptrul, 1); 443 // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 1 444 vd = vec_gather_element(vd, vul, cptrd, 0); 445 // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 0 446 vd = vec_gather_element(vd, vul, cptrd, 1); 447 // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 1 448 449 vec_scatter_element(vsi, vui, ptrsi, 0); 450 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 0 451 vec_scatter_element(vsi, vui, ptrsi, 1); 452 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 1 453 vec_scatter_element(vsi, vui, ptrsi, 2); 454 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 2 455 vec_scatter_element(vsi, vui, ptrsi, 3); 456 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 3 457 vec_scatter_element(vui, vui, ptrui, 0); 458 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 0 459 vec_scatter_element(vui, vui, ptrui, 1); 460 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 1 461 vec_scatter_element(vui, vui, ptrui, 2); 462 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 2 463 vec_scatter_element(vui, vui, ptrui, 3); 464 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 3 465 vec_scatter_element(vbi, vui, ptrui, 0); 466 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 0 467 vec_scatter_element(vbi, vui, ptrui, 1); 468 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 1 469 vec_scatter_element(vbi, vui, ptrui, 2); 470 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 2 471 vec_scatter_element(vbi, vui, ptrui, 3); 472 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 3 473 vec_scatter_element(vsl, vul, ptrsl, 0); 474 // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 0 475 vec_scatter_element(vsl, vul, ptrsl, 1); 476 // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 1 477 vec_scatter_element(vul, vul, ptrul, 0); 478 // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 0 479 vec_scatter_element(vul, vul, ptrul, 1); 480 // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 1 481 vec_scatter_element(vbl, vul, ptrul, 0); 482 // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 0 483 vec_scatter_element(vbl, vul, ptrul, 1); 484 // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 1 485 vec_scatter_element(vd, vul, ptrd, 0); 486 // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 0 487 vec_scatter_element(vd, vul, ptrd, 1); 488 // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 1 489 490 vsc = vec_xl(idx, cptrsc); 491 // CHECK-ASM: vl 492 vuc = vec_xl(idx, cptruc); 493 // CHECK-ASM: vl 494 vss = vec_xl(idx, cptrss); 495 // CHECK-ASM: vl 496 vus = vec_xl(idx, cptrus); 497 // CHECK-ASM: vl 498 vsi = vec_xl(idx, cptrsi); 499 // CHECK-ASM: vl 500 vui = vec_xl(idx, cptrui); 501 // CHECK-ASM: vl 502 vsl = vec_xl(idx, cptrsl); 503 // CHECK-ASM: vl 504 vul = vec_xl(idx, cptrul); 505 // CHECK-ASM: vl 506 vd = vec_xl(idx, cptrd); 507 // CHECK-ASM: vl 508 509 vsc = vec_xld2(idx, cptrsc); 510 // CHECK-ASM: vl 511 vuc = vec_xld2(idx, cptruc); 512 // CHECK-ASM: vl 513 vss = vec_xld2(idx, cptrss); 514 // CHECK-ASM: vl 515 vus = vec_xld2(idx, cptrus); 516 // CHECK-ASM: vl 517 vsi = vec_xld2(idx, cptrsi); 518 // CHECK-ASM: vl 519 vui = vec_xld2(idx, cptrui); 520 // CHECK-ASM: vl 521 vsl = vec_xld2(idx, cptrsl); 522 // CHECK-ASM: vl 523 vul = vec_xld2(idx, cptrul); 524 // CHECK-ASM: vl 525 vd = vec_xld2(idx, cptrd); 526 // CHECK-ASM: vl 527 528 vsc = vec_xlw4(idx, cptrsc); 529 // CHECK-ASM: vl 530 vuc = vec_xlw4(idx, cptruc); 531 // CHECK-ASM: vl 532 vss = vec_xlw4(idx, cptrss); 533 // CHECK-ASM: vl 534 vus = vec_xlw4(idx, cptrus); 535 // CHECK-ASM: vl 536 vsi = vec_xlw4(idx, cptrsi); 537 // CHECK-ASM: vl 538 vui = vec_xlw4(idx, cptrui); 539 // CHECK-ASM: vl 540 541 vec_xst(vsc, idx, ptrsc); 542 // CHECK-ASM: vst 543 vec_xst(vuc, idx, ptruc); 544 // CHECK-ASM: vst 545 vec_xst(vss, idx, ptrss); 546 // CHECK-ASM: vst 547 vec_xst(vus, idx, ptrus); 548 // CHECK-ASM: vst 549 vec_xst(vsi, idx, ptrsi); 550 // CHECK-ASM: vst 551 vec_xst(vui, idx, ptrui); 552 // CHECK-ASM: vst 553 vec_xst(vsl, idx, ptrsl); 554 // CHECK-ASM: vst 555 vec_xst(vul, idx, ptrul); 556 // CHECK-ASM: vst 557 vec_xst(vd, idx, ptrd); 558 // CHECK-ASM: vst 559 560 vec_xstd2(vsc, idx, ptrsc); 561 // CHECK-ASM: vst 562 vec_xstd2(vuc, idx, ptruc); 563 // CHECK-ASM: vst 564 vec_xstd2(vss, idx, ptrss); 565 // CHECK-ASM: vst 566 vec_xstd2(vus, idx, ptrus); 567 // CHECK-ASM: vst 568 vec_xstd2(vsi, idx, ptrsi); 569 // CHECK-ASM: vst 570 vec_xstd2(vui, idx, ptrui); 571 // CHECK-ASM: vst 572 vec_xstd2(vsl, idx, ptrsl); 573 // CHECK-ASM: vst 574 vec_xstd2(vul, idx, ptrul); 575 // CHECK-ASM: vst 576 vec_xstd2(vd, idx, ptrd); 577 // CHECK-ASM: vst 578 579 vec_xstw4(vsc, idx, ptrsc); 580 // CHECK-ASM: vst 581 vec_xstw4(vuc, idx, ptruc); 582 // CHECK-ASM: vst 583 vec_xstw4(vss, idx, ptrss); 584 // CHECK-ASM: vst 585 vec_xstw4(vus, idx, ptrus); 586 // CHECK-ASM: vst 587 vec_xstw4(vsi, idx, ptrsi); 588 // CHECK-ASM: vst 589 vec_xstw4(vui, idx, ptrui); 590 // CHECK-ASM: vst 591 592 vsc = vec_load_bndry(cptrsc, 64); 593 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0) 594 // CHECK-ASM: vlbb 595 vuc = vec_load_bndry(cptruc, 64); 596 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0) 597 // CHECK-ASM: vlbb 598 vss = vec_load_bndry(cptrss, 64); 599 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0) 600 // CHECK-ASM: vlbb 601 vus = vec_load_bndry(cptrus, 64); 602 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0) 603 // CHECK-ASM: vlbb 604 vsi = vec_load_bndry(cptrsi, 64); 605 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0) 606 // CHECK-ASM: vlbb 607 vui = vec_load_bndry(cptrui, 64); 608 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0) 609 // CHECK-ASM: vlbb 610 vsl = vec_load_bndry(cptrsl, 64); 611 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0) 612 // CHECK-ASM: vlbb 613 vul = vec_load_bndry(cptrul, 64); 614 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0) 615 // CHECK-ASM: vlbb 616 vd = vec_load_bndry(cptrd, 64); 617 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0) 618 // CHECK-ASM: vlbb 619 vsc = vec_load_bndry(cptrsc, 128); 620 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 1) 621 // CHECK-ASM: vlbb 622 vsc = vec_load_bndry(cptrsc, 256); 623 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 2) 624 // CHECK-ASM: vlbb 625 vsc = vec_load_bndry(cptrsc, 512); 626 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 3) 627 // CHECK-ASM: vlbb 628 vsc = vec_load_bndry(cptrsc, 1024); 629 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 4) 630 // CHECK-ASM: vlbb 631 vsc = vec_load_bndry(cptrsc, 2048); 632 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 5) 633 // CHECK-ASM: vlbb 634 vsc = vec_load_bndry(cptrsc, 4096); 635 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 6) 636 // CHECK-ASM: vlbb 637 638 vsc = vec_load_len(cptrsc, idx); 639 // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}}) 640 // CHECK-ASM: vll 641 vuc = vec_load_len(cptruc, idx); 642 // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}}) 643 // CHECK-ASM: vll 644 vss = vec_load_len(cptrss, idx); 645 // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}}) 646 // CHECK-ASM: vll 647 vus = vec_load_len(cptrus, idx); 648 // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}}) 649 // CHECK-ASM: vll 650 vsi = vec_load_len(cptrsi, idx); 651 // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}}) 652 // CHECK-ASM: vll 653 vui = vec_load_len(cptrui, idx); 654 // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}}) 655 // CHECK-ASM: vll 656 vsl = vec_load_len(cptrsl, idx); 657 // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}}) 658 // CHECK-ASM: vll 659 vul = vec_load_len(cptrul, idx); 660 // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}}) 661 // CHECK-ASM: vll 662 vd = vec_load_len(cptrd, idx); 663 // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}}) 664 // CHECK-ASM: vll 665 666 vec_store_len(vsc, ptrsc, idx); 667 // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}}) 668 // CHECK-ASM: vstl 669 vec_store_len(vuc, ptruc, idx); 670 // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}}) 671 // CHECK-ASM: vstl 672 vec_store_len(vss, ptrss, idx); 673 // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}}) 674 // CHECK-ASM: vstl 675 vec_store_len(vus, ptrus, idx); 676 // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}}) 677 // CHECK-ASM: vstl 678 vec_store_len(vsi, ptrsi, idx); 679 // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}}) 680 // CHECK-ASM: vstl 681 vec_store_len(vui, ptrui, idx); 682 // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}}) 683 // CHECK-ASM: vstl 684 vec_store_len(vsl, ptrsl, idx); 685 // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}}) 686 // CHECK-ASM: vstl 687 vec_store_len(vul, ptrul, idx); 688 // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}}) 689 // CHECK-ASM: vstl 690 vec_store_len(vd, ptrd, idx); 691 // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}}) 692 // CHECK-ASM: vstl 693 694 vsl = vec_load_pair(sl + 1, sl - 1); 695 // CHECK-ASM: vlvgp 696 vul = vec_load_pair(ul + 1, ul - 1); 697 // CHECK-ASM: vlvgp 698 699 vuc = vec_genmask(0); 700 // CHECK: <16 x i8> zeroinitializer 701 vuc = vec_genmask(0x8000); 702 // CHECK: <16 x i8> <i8 -1, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0> 703 vuc = vec_genmask(0xffff); 704 // CHECK: <16 x i8> <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1> 705 706 vuc = vec_genmasks_8(0, 7); 707 // CHECK: <16 x i8> <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1> 708 vuc = vec_genmasks_8(1, 4); 709 // CHECK: <16 x i8> <i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120> 710 vuc = vec_genmasks_8(6, 2); 711 // CHECK: <16 x i8> <i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29> 712 vus = vec_genmasks_16(0, 15); 713 // CHECK: <8 x i16> <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1> 714 vus = vec_genmasks_16(2, 11); 715 // CHECK: <8 x i16> <i16 16368, i16 16368, i16 16368, i16 16368, i16 16368, i16 16368, i16 16368, i16 16368> 716 vus = vec_genmasks_16(9, 2); 717 // CHECK: <8 x i16> <i16 -8065, i16 -8065, i16 -8065, i16 -8065, i16 -8065, i16 -8065, i16 -8065, i16 -8065> 718 vui = vec_genmasks_32(0, 31); 719 // CHECK: <4 x i32> <i32 -1, i32 -1, i32 -1, i32 -1> 720 vui = vec_genmasks_32(7, 20); 721 // CHECK: <4 x i32> <i32 33552384, i32 33552384, i32 33552384, i32 33552384> 722 vui = vec_genmasks_32(25, 4); 723 // CHECK: <4 x i32> <i32 -134217601, i32 -134217601, i32 -134217601, i32 -134217601> 724 vul = vec_genmasks_64(0, 63); 725 // CHECK: <2 x i64> <i64 -1, i64 -1> 726 vul = vec_genmasks_64(3, 40); 727 // CHECK: <2 x i64> <i64 2305843009205305344, i64 2305843009205305344> 728 vul = vec_genmasks_64(30, 11); 729 // CHECK: <2 x i64> <i64 -4503582447501313, i64 -4503582447501313> 730 731 vsc = vec_splat(vsc, 0); 732 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> poison, <16 x i32> zeroinitializer 733 // CHECK-ASM: vrepb 734 vsc = vec_splat(vsc, 15); 735 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> undef, <16 x i32> <i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15> 736 // CHECK-ASM: vrepb 737 vuc = vec_splat(vuc, 0); 738 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> poison, <16 x i32> zeroinitializer 739 // CHECK-ASM: vrepb 740 vuc = vec_splat(vuc, 15); 741 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> undef, <16 x i32> <i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15> 742 // CHECK-ASM: vrepb 743 vbc = vec_splat(vbc, 0); 744 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> poison, <16 x i32> zeroinitializer 745 // CHECK-ASM: vrepb 746 vbc = vec_splat(vbc, 15); 747 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> undef, <16 x i32> <i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15> 748 // CHECK-ASM: vrepb 749 vss = vec_splat(vss, 0); 750 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> poison, <8 x i32> zeroinitializer 751 // CHECK-ASM: vreph 752 vss = vec_splat(vss, 7); 753 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> undef, <8 x i32> <i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7> 754 // CHECK-ASM: vreph 755 vus = vec_splat(vus, 0); 756 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> poison, <8 x i32> zeroinitializer 757 // CHECK-ASM: vreph 758 vus = vec_splat(vus, 7); 759 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> undef, <8 x i32> <i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7> 760 // CHECK-ASM: vreph 761 vbs = vec_splat(vbs, 0); 762 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> poison, <8 x i32> zeroinitializer 763 // CHECK-ASM: vreph 764 vbs = vec_splat(vbs, 7); 765 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> undef, <8 x i32> <i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7> 766 // CHECK-ASM: vreph 767 vsi = vec_splat(vsi, 0); 768 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> poison, <4 x i32> zeroinitializer 769 // CHECK-ASM: vrepf 770 vsi = vec_splat(vsi, 3); 771 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3> 772 // CHECK-ASM: vrepf 773 vui = vec_splat(vui, 0); 774 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> poison, <4 x i32> zeroinitializer 775 // CHECK-ASM: vrepf 776 vui = vec_splat(vui, 3); 777 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3> 778 // CHECK-ASM: vrepf 779 vbi = vec_splat(vbi, 0); 780 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> poison, <4 x i32> zeroinitializer 781 // CHECK-ASM: vrepf 782 vbi = vec_splat(vbi, 3); 783 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3> 784 // CHECK-ASM: vrepf 785 vsl = vec_splat(vsl, 0); 786 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> poison, <2 x i32> zeroinitializer 787 // CHECK-ASM: vrepg 788 vsl = vec_splat(vsl, 1); 789 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> undef, <2 x i32> <i32 1, i32 1> 790 // CHECK-ASM: vrepg 791 vul = vec_splat(vul, 0); 792 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> poison, <2 x i32> zeroinitializer 793 // CHECK-ASM: vrepg 794 vul = vec_splat(vul, 1); 795 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> undef, <2 x i32> <i32 1, i32 1> 796 // CHECK-ASM: vrepg 797 vbl = vec_splat(vbl, 0); 798 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> poison, <2 x i32> zeroinitializer 799 // CHECK-ASM: vrepg 800 vbl = vec_splat(vbl, 1); 801 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> undef, <2 x i32> <i32 1, i32 1> 802 // CHECK-ASM: vrepg 803 vd = vec_splat(vd, 0); 804 // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> poison, <2 x i32> zeroinitializer 805 // CHECK-ASM: vrepg 806 vd = vec_splat(vd, 1); 807 // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> undef, <2 x i32> <i32 1, i32 1> 808 // CHECK-ASM: vrepg 809 810 vsc = vec_splat_s8(-128); 811 // CHECK: <16 x i8> <i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128> 812 vsc = vec_splat_s8(127); 813 // CHECK: <16 x i8> <i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127> 814 vuc = vec_splat_u8(1); 815 // CHECK: <16 x i8> <i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1> 816 vuc = vec_splat_u8(254); 817 // CHECK: <16 x i8> <i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2> 818 vss = vec_splat_s16(-32768); 819 // CHECK: <8 x i16> <i16 -32768, i16 -32768, i16 -32768, i16 -32768, i16 -32768, i16 -32768, i16 -32768, i16 -32768> 820 vss = vec_splat_s16(32767); 821 // CHECK: <8 x i16> <i16 32767, i16 32767, i16 32767, i16 32767, i16 32767, i16 32767, i16 32767, i16 32767> 822 vus = vec_splat_u16(1); 823 // CHECK: <8 x i16> <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1> 824 vus = vec_splat_u16(65534); 825 // CHECK: <8 x i16> <i16 -2, i16 -2, i16 -2, i16 -2, i16 -2, i16 -2, i16 -2, i16 -2> 826 vsi = vec_splat_s32(-32768); 827 // CHECK: <4 x i32> <i32 -32768, i32 -32768, i32 -32768, i32 -32768> 828 vsi = vec_splat_s32(32767); 829 // CHECK: <4 x i32> <i32 32767, i32 32767, i32 32767, i32 32767> 830 vui = vec_splat_u32(-32768); 831 // CHECK: <4 x i32> <i32 -32768, i32 -32768, i32 -32768, i32 -32768> 832 vui = vec_splat_u32(32767); 833 // CHECK: <4 x i32> <i32 32767, i32 32767, i32 32767, i32 32767> 834 vsl = vec_splat_s64(-32768); 835 // CHECK: <2 x i64> <i64 -32768, i64 -32768> 836 vsl = vec_splat_s64(32767); 837 // CHECK: <2 x i64> <i64 32767, i64 32767> 838 vul = vec_splat_u64(-32768); 839 // CHECK: <2 x i64> <i64 -32768, i64 -32768> 840 vul = vec_splat_u64(32767); 841 // CHECK: <2 x i64> <i64 32767, i64 32767> 842 843 vsc = vec_splats(sc); 844 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> poison, <16 x i32> zeroinitializer 845 // CHECK-ASM: vlrepb 846 vuc = vec_splats(uc); 847 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> poison, <16 x i32> zeroinitializer 848 // CHECK-ASM: vlrepb 849 vss = vec_splats(ss); 850 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> poison, <8 x i32> zeroinitializer 851 // CHECK-ASM: vlreph 852 vus = vec_splats(us); 853 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> poison, <8 x i32> zeroinitializer 854 // CHECK-ASM: vlreph 855 vsi = vec_splats(si); 856 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> poison, <4 x i32> zeroinitializer 857 // CHECK-ASM: vlrepf 858 vui = vec_splats(ui); 859 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> poison, <4 x i32> zeroinitializer 860 // CHECK-ASM: vlrepf 861 vsl = vec_splats(sl); 862 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> poison, <2 x i32> zeroinitializer 863 // CHECK-ASM: vlrepg 864 vul = vec_splats(ul); 865 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> poison, <2 x i32> zeroinitializer 866 // CHECK-ASM: vlrepg 867 vd = vec_splats(d); 868 // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> poison, <2 x i32> zeroinitializer 869 // CHECK-ASM: vlrepg 870 871 vsl = vec_extend_s64(vsc); 872 // CHECK-ASM: vsegb 873 vsl = vec_extend_s64(vss); 874 // CHECK-ASM: vsegh 875 vsl = vec_extend_s64(vsi); 876 // CHECK-ASM: vsegf 877 878 vsc = vec_mergeh(vsc, vsc); 879 // shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> <i32 0, i32 16, i32 1, i32 17, i32 2, i32 18, i32 3, i32 19, i32 4, i32 20, i32 5, i32 21, i32 6, i32 22, i32 7, i32 23> 880 // CHECK-ASM: vmrhb 881 vuc = vec_mergeh(vuc, vuc); 882 // shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> <i32 0, i32 16, i32 1, i32 17, i32 2, i32 18, i32 3, i32 19, i32 4, i32 20, i32 5, i32 21, i32 6, i32 22, i32 7, i32 23> 883 // CHECK-ASM: vmrhb 884 vbc = vec_mergeh(vbc, vbc); 885 // shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> <i32 0, i32 16, i32 1, i32 17, i32 2, i32 18, i32 3, i32 19, i32 4, i32 20, i32 5, i32 21, i32 6, i32 22, i32 7, i32 23> 886 // CHECK-ASM: vmrhb 887 vss = vec_mergeh(vss, vss); 888 // shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11> 889 // CHECK-ASM: vmrhh 890 vus = vec_mergeh(vus, vus); 891 // shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11> 892 // CHECK-ASM: vmrhh 893 vbs = vec_mergeh(vbs, vbs); 894 // shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11> 895 // CHECK-ASM: vmrhh 896 vsi = vec_mergeh(vsi, vsi); 897 // shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 1, i32 5> 898 // CHECK-ASM: vmrhf 899 vui = vec_mergeh(vui, vui); 900 // shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 1, i32 5> 901 // CHECK-ASM: vmrhf 902 vbi = vec_mergeh(vbi, vbi); 903 // shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 1, i32 5> 904 // CHECK-ASM: vmrhf 905 vsl = vec_mergeh(vsl, vsl); 906 // shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i32> <i32 0, i32 2> 907 // CHECK-ASM: vmrhg 908 vul = vec_mergeh(vul, vul); 909 // shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i32> <i32 0, i32 2> 910 // CHECK-ASM: vmrhg 911 vbl = vec_mergeh(vbl, vbl); 912 // shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i32> <i32 0, i32 2> 913 // CHECK-ASM: vmrhg 914 vd = vec_mergeh(vd, vd); 915 // shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> <i32 0, i32 2> 916 // CHECK-ASM: vmrhg 917 918 vsc = vec_mergel(vsc, vsc); 919 // shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 8, i32 24, i32 9, i32 25, i32 10, i32 26, i32 11, i32 27, i32 12, i32 28, i32 13, i32 29, i32 14, i32 30, i32 15, i32 31> 920 // CHECK-ASM: vmrlb 921 vuc = vec_mergel(vuc, vuc); 922 // shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 8, i32 24, i32 9, i32 25, i32 10, i32 26, i32 11, i32 27, i32 12, i32 28, i32 13, i32 29, i32 14, i32 30, i32 15, i32 31> 923 // CHECK-ASM: vmrlb 924 vbc = vec_mergel(vbc, vbc); 925 // shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 8, i32 24, i32 9, i32 25, i32 10, i32 26, i32 11, i32 27, i32 12, i32 28, i32 13, i32 29, i32 14, i32 30, i32 15, i32 31> 926 // CHECK-ASM: vmrlb 927 vss = vec_mergel(vss, vss); 928 // shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15> 929 // CHECK-ASM: vmrlh 930 vus = vec_mergel(vus, vus); 931 // shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15> 932 // CHECK-ASM: vmrlh 933 vbs = vec_mergel(vbs, vbs); 934 // shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15> 935 // CHECK-ASM: vmrlh 936 vsi = vec_mergel(vsi, vsi); 937 // shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <i32 2, i32 6, i32 3, i32 7> 938 // CHECK-ASM: vmrlf 939 vui = vec_mergel(vui, vui); 940 // shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <i32 2, i32 6, i32 3, i32 7> 941 // CHECK-ASM: vmrlf 942 vbi = vec_mergel(vbi, vbi); 943 // shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <i32 2, i32 6, i32 3, i32 7> 944 // CHECK-ASM: vmrlf 945 vsl = vec_mergel(vsl, vsl); 946 // shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <i32 1, i32 3> 947 // CHECK-ASM: vmrlg 948 vul = vec_mergel(vul, vul); 949 // shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <i32 1, i32 3> 950 // CHECK-ASM: vmrlg 951 vbl = vec_mergel(vbl, vbl); 952 // shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <i32 1, i32 3> 953 // CHECK-ASM: vmrlg 954 vd = vec_mergel(vd, vd); 955 // shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <i32 1, i32 3> 956 // CHECK-ASM: vmrlg 957 958 vsc = vec_pack(vss, vss); 959 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15, i32 17, i32 19, i32 21, i32 23, i32 25, i32 27, i32 29, i32 31> 960 // CHECK-ASM: vpkh 961 vuc = vec_pack(vus, vus); 962 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15, i32 17, i32 19, i32 21, i32 23, i32 25, i32 27, i32 29, i32 31> 963 // CHECK-ASM: vpkh 964 vbc = vec_pack(vbs, vbs); 965 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15, i32 17, i32 19, i32 21, i32 23, i32 25, i32 27, i32 29, i32 31> 966 // CHECK-ASM: vpkh 967 vss = vec_pack(vsi, vsi); 968 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15> 969 // CHECK-ASM: vpkf 970 vus = vec_pack(vui, vui); 971 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15> 972 // CHECK-ASM: vpkf 973 vbs = vec_pack(vbi, vbi); 974 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15> 975 // CHECK-ASM: vpkf 976 vsi = vec_pack(vsl, vsl); 977 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 1, i32 3, i32 5, i32 7> 978 // CHECK-ASM: vpkg 979 vui = vec_pack(vul, vul); 980 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 1, i32 3, i32 5, i32 7> 981 // CHECK-ASM: vpkg 982 vbi = vec_pack(vbl, vbl); 983 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 1, i32 3, i32 5, i32 7> 984 // CHECK-ASM: vpkg 985 986 vsc = vec_packs(vss, vss); 987 // CHECK: call <16 x i8> @llvm.s390.vpksh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 988 // CHECK-ASM: vpksh 989 vuc = vec_packs(vus, vus); 990 // CHECK: call <16 x i8> @llvm.s390.vpklsh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 991 // CHECK-ASM: vpklsh 992 vss = vec_packs(vsi, vsi); 993 // CHECK: call <8 x i16> @llvm.s390.vpksf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 994 // CHECK-ASM: vpksf 995 vus = vec_packs(vui, vui); 996 // CHECK: call <8 x i16> @llvm.s390.vpklsf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 997 // CHECK-ASM: vpklsf 998 vsi = vec_packs(vsl, vsl); 999 // CHECK: call <4 x i32> @llvm.s390.vpksg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1000 // CHECK-ASM: vpksg 1001 vui = vec_packs(vul, vul); 1002 // CHECK: call <4 x i32> @llvm.s390.vpklsg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1003 // CHECK-ASM: vpklsg 1004 1005 vsc = vec_packs_cc(vss, vss, &cc); 1006 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vpkshs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1007 // CHECK-ASM: vpkshs 1008 vuc = vec_packs_cc(vus, vus, &cc); 1009 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vpklshs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1010 // CHECK-ASM: vpklshs 1011 vss = vec_packs_cc(vsi, vsi, &cc); 1012 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vpksfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1013 // CHECK-ASM: vpksfs 1014 vus = vec_packs_cc(vui, vui, &cc); 1015 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vpklsfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1016 // CHECK-ASM: vpklsfs 1017 vsi = vec_packs_cc(vsl, vsl, &cc); 1018 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vpksgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1019 // CHECK-ASM: vpksgs 1020 vui = vec_packs_cc(vul, vul, &cc); 1021 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vpklsgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1022 // CHECK-ASM: vpklsgs 1023 1024 vuc = vec_packsu(vss, vss); 1025 // CHECK: call <16 x i8> @llvm.s390.vpklsh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1026 // CHECK-ASM: vpklsh 1027 vuc = vec_packsu(vus, vus); 1028 // CHECK: call <16 x i8> @llvm.s390.vpklsh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1029 // CHECK-ASM: vpklsh 1030 vus = vec_packsu(vsi, vsi); 1031 // CHECK: call <8 x i16> @llvm.s390.vpklsf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1032 // CHECK-ASM: vpklsf 1033 vus = vec_packsu(vui, vui); 1034 // CHECK: call <8 x i16> @llvm.s390.vpklsf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1035 // CHECK-ASM: vpklsf 1036 vui = vec_packsu(vsl, vsl); 1037 // CHECK: call <4 x i32> @llvm.s390.vpklsg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1038 // CHECK-ASM: vpklsg 1039 vui = vec_packsu(vul, vul); 1040 // CHECK: call <4 x i32> @llvm.s390.vpklsg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1041 // CHECK-ASM: vpklsg 1042 1043 vuc = vec_packsu_cc(vus, vus, &cc); 1044 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vpklshs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1045 // CHECK-ASM: vpklshs 1046 vus = vec_packsu_cc(vui, vui, &cc); 1047 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vpklsfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1048 // CHECK-ASM: vpklsfs 1049 vui = vec_packsu_cc(vul, vul, &cc); 1050 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vpklsgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1051 // CHECK-ASM: vpklsgs 1052 1053 vss = vec_unpackh(vsc); 1054 // CHECK: call <8 x i16> @llvm.s390.vuphb(<16 x i8> %{{.*}}) 1055 // CHECK-ASM: vuphb 1056 vus = vec_unpackh(vuc); 1057 // CHECK: call <8 x i16> @llvm.s390.vuplhb(<16 x i8> %{{.*}}) 1058 // CHECK-ASM: vuplhb 1059 vbs = vec_unpackh(vbc); 1060 // CHECK: call <8 x i16> @llvm.s390.vuphb(<16 x i8> %{{.*}}) 1061 // CHECK-ASM: vuphb 1062 vsi = vec_unpackh(vss); 1063 // CHECK: call <4 x i32> @llvm.s390.vuphh(<8 x i16> %{{.*}}) 1064 // CHECK-ASM: vuphh 1065 vui = vec_unpackh(vus); 1066 // CHECK: call <4 x i32> @llvm.s390.vuplhh(<8 x i16> %{{.*}}) 1067 // CHECK-ASM: vuplhh 1068 vbi = vec_unpackh(vbs); 1069 // CHECK: call <4 x i32> @llvm.s390.vuphh(<8 x i16> %{{.*}}) 1070 // CHECK-ASM: vuphh 1071 vsl = vec_unpackh(vsi); 1072 // CHECK: call <2 x i64> @llvm.s390.vuphf(<4 x i32> %{{.*}}) 1073 // CHECK-ASM: vuphf 1074 vul = vec_unpackh(vui); 1075 // CHECK: call <2 x i64> @llvm.s390.vuplhf(<4 x i32> %{{.*}}) 1076 // CHECK-ASM: vuplhf 1077 vbl = vec_unpackh(vbi); 1078 // CHECK: call <2 x i64> @llvm.s390.vuphf(<4 x i32> %{{.*}}) 1079 // CHECK-ASM: vuphf 1080 1081 vss = vec_unpackl(vsc); 1082 // CHECK: call <8 x i16> @llvm.s390.vuplb(<16 x i8> %{{.*}}) 1083 // CHECK-ASM: vuplb 1084 vus = vec_unpackl(vuc); 1085 // CHECK: call <8 x i16> @llvm.s390.vupllb(<16 x i8> %{{.*}}) 1086 // CHECK-ASM: vupllb 1087 vbs = vec_unpackl(vbc); 1088 // CHECK: call <8 x i16> @llvm.s390.vuplb(<16 x i8> %{{.*}}) 1089 // CHECK-ASM: vuplb 1090 vsi = vec_unpackl(vss); 1091 // CHECK: call <4 x i32> @llvm.s390.vuplhw(<8 x i16> %{{.*}}) 1092 // CHECK-ASM: vuplhw 1093 vui = vec_unpackl(vus); 1094 // CHECK: call <4 x i32> @llvm.s390.vupllh(<8 x i16> %{{.*}}) 1095 // CHECK-ASM: vupllh 1096 vbi = vec_unpackl(vbs); 1097 // CHECK: call <4 x i32> @llvm.s390.vuplhw(<8 x i16> %{{.*}}) 1098 // CHECK-ASM: vuplhw 1099 vsl = vec_unpackl(vsi); 1100 // CHECK: call <2 x i64> @llvm.s390.vuplf(<4 x i32> %{{.*}}) 1101 // CHECK-ASM: vuplf 1102 vul = vec_unpackl(vui); 1103 // CHECK: call <2 x i64> @llvm.s390.vupllf(<4 x i32> %{{.*}}) 1104 // CHECK-ASM: vupllf 1105 vbl = vec_unpackl(vbi); 1106 // CHECK: call <2 x i64> @llvm.s390.vuplf(<4 x i32> %{{.*}}) 1107 // CHECK-ASM: vuplf 1108 } 1109 1110 void test_compare(void) { 1111 // CHECK-ASM-LABEL: test_compare 1112 1113 vbc = vec_cmpeq(vsc, vsc); 1114 // CHECK: icmp eq <16 x i8> %{{.*}}, %{{.*}} 1115 // CHECK-ASM: vceqb 1116 vbc = vec_cmpeq(vuc, vuc); 1117 // CHECK: icmp eq <16 x i8> %{{.*}}, %{{.*}} 1118 // CHECK-ASM: vceqb 1119 vbc = vec_cmpeq(vbc, vbc); 1120 // CHECK: icmp eq <16 x i8> %{{.*}}, %{{.*}} 1121 // CHECK-ASM: vceqb 1122 vbs = vec_cmpeq(vss, vss); 1123 // CHECK: icmp eq <8 x i16> %{{.*}}, %{{.*}} 1124 // CHECK-ASM: vceqh 1125 vbs = vec_cmpeq(vus, vus); 1126 // CHECK: icmp eq <8 x i16> %{{.*}}, %{{.*}} 1127 // CHECK-ASM: vceqh 1128 vbs = vec_cmpeq(vbs, vbs); 1129 // CHECK: icmp eq <8 x i16> %{{.*}}, %{{.*}} 1130 // CHECK-ASM: vceqh 1131 vbi = vec_cmpeq(vsi, vsi); 1132 // CHECK: icmp eq <4 x i32> %{{.*}}, %{{.*}} 1133 // CHECK-ASM: vceqf 1134 vbi = vec_cmpeq(vui, vui); 1135 // CHECK: icmp eq <4 x i32> %{{.*}}, %{{.*}} 1136 // CHECK-ASM: vceqf 1137 vbi = vec_cmpeq(vbi, vbi); 1138 // CHECK: icmp eq <4 x i32> %{{.*}}, %{{.*}} 1139 // CHECK-ASM: vceqf 1140 vbl = vec_cmpeq(vsl, vsl); 1141 // CHECK: icmp eq <2 x i64> %{{.*}}, %{{.*}} 1142 // CHECK-ASM: vceqg 1143 vbl = vec_cmpeq(vul, vul); 1144 // CHECK: icmp eq <2 x i64> %{{.*}}, %{{.*}} 1145 // CHECK-ASM: vceqg 1146 vbl = vec_cmpeq(vbl, vbl); 1147 // CHECK: icmp eq <2 x i64> %{{.*}}, %{{.*}} 1148 // CHECK-ASM: vceqg 1149 vbl = vec_cmpeq(vd, vd); 1150 // CHECK: fcmp oeq <2 x double> %{{.*}}, %{{.*}} 1151 // CHECK-ASM: vfcedb 1152 1153 vbc = vec_cmpge(vsc, vsc); 1154 // CHECK: icmp sge <16 x i8> %{{.*}}, %{{.*}} 1155 // CHECK-ASM: vchb 1156 vbc = vec_cmpge(vuc, vuc); 1157 // CHECK: icmp uge <16 x i8> %{{.*}}, %{{.*}} 1158 // CHECK-ASM: vchlb 1159 vbs = vec_cmpge(vss, vss); 1160 // CHECK: icmp sge <8 x i16> %{{.*}}, %{{.*}} 1161 // CHECK-ASM: vchh 1162 vbs = vec_cmpge(vus, vus); 1163 // CHECK: icmp uge <8 x i16> %{{.*}}, %{{.*}} 1164 // CHECK-ASM: vchlh 1165 vbi = vec_cmpge(vsi, vsi); 1166 // CHECK: icmp sge <4 x i32> %{{.*}}, %{{.*}} 1167 // CHECK-ASM: vchf 1168 vbi = vec_cmpge(vui, vui); 1169 // CHECK: icmp uge <4 x i32> %{{.*}}, %{{.*}} 1170 // CHECK-ASM: vchlf 1171 vbl = vec_cmpge(vsl, vsl); 1172 // CHECK: icmp sge <2 x i64> %{{.*}}, %{{.*}} 1173 // CHECK-ASM: vchg 1174 vbl = vec_cmpge(vul, vul); 1175 // CHECK: icmp uge <2 x i64> %{{.*}}, %{{.*}} 1176 // CHECK-ASM: vchlg 1177 vbl = vec_cmpge(vd, vd); 1178 // CHECK: fcmp oge <2 x double> %{{.*}}, %{{.*}} 1179 // CHECK-ASM: vfchedb 1180 1181 vbc = vec_cmpgt(vsc, vsc); 1182 // CHECK: icmp sgt <16 x i8> %{{.*}}, %{{.*}} 1183 // CHECK-ASM: vchb 1184 vbc = vec_cmpgt(vuc, vuc); 1185 // CHECK: icmp ugt <16 x i8> %{{.*}}, %{{.*}} 1186 // CHECK-ASM: vchlb 1187 vbs = vec_cmpgt(vss, vss); 1188 // CHECK: icmp sgt <8 x i16> %{{.*}}, %{{.*}} 1189 // CHECK-ASM: vchh 1190 vbs = vec_cmpgt(vus, vus); 1191 // CHECK: icmp ugt <8 x i16> %{{.*}}, %{{.*}} 1192 // CHECK-ASM: vchlh 1193 vbi = vec_cmpgt(vsi, vsi); 1194 // CHECK: icmp sgt <4 x i32> %{{.*}}, %{{.*}} 1195 // CHECK-ASM: vchf 1196 vbi = vec_cmpgt(vui, vui); 1197 // CHECK: icmp ugt <4 x i32> %{{.*}}, %{{.*}} 1198 // CHECK-ASM: vchlf 1199 vbl = vec_cmpgt(vsl, vsl); 1200 // CHECK: icmp sgt <2 x i64> %{{.*}}, %{{.*}} 1201 // CHECK-ASM: vchg 1202 vbl = vec_cmpgt(vul, vul); 1203 // CHECK: icmp ugt <2 x i64> %{{.*}}, %{{.*}} 1204 // CHECK-ASM: vchlg 1205 vbl = vec_cmpgt(vd, vd); 1206 // CHECK: fcmp ogt <2 x double> %{{.*}}, %{{.*}} 1207 // CHECK-ASM: vfchdb 1208 1209 vbc = vec_cmple(vsc, vsc); 1210 // CHECK: icmp sle <16 x i8> %{{.*}}, %{{.*}} 1211 // CHECK-ASM: vchb 1212 vbc = vec_cmple(vuc, vuc); 1213 // CHECK: icmp ule <16 x i8> %{{.*}}, %{{.*}} 1214 // CHECK-ASM: vchlb 1215 vbs = vec_cmple(vss, vss); 1216 // CHECK: icmp sle <8 x i16> %{{.*}}, %{{.*}} 1217 // CHECK-ASM: vchh 1218 vbs = vec_cmple(vus, vus); 1219 // CHECK: icmp ule <8 x i16> %{{.*}}, %{{.*}} 1220 // CHECK-ASM: vchlh 1221 vbi = vec_cmple(vsi, vsi); 1222 // CHECK: icmp sle <4 x i32> %{{.*}}, %{{.*}} 1223 // CHECK-ASM: vchf 1224 vbi = vec_cmple(vui, vui); 1225 // CHECK: icmp ule <4 x i32> %{{.*}}, %{{.*}} 1226 // CHECK-ASM: vchlf 1227 vbl = vec_cmple(vsl, vsl); 1228 // CHECK: icmp sle <2 x i64> %{{.*}}, %{{.*}} 1229 // CHECK-ASM: vchg 1230 vbl = vec_cmple(vul, vul); 1231 // CHECK: icmp ule <2 x i64> %{{.*}}, %{{.*}} 1232 // CHECK-ASM: vchlg 1233 vbl = vec_cmple(vd, vd); 1234 // CHECK: fcmp ole <2 x double> %{{.*}}, %{{.*}} 1235 // CHECK-ASM: vfchedb 1236 1237 vbc = vec_cmplt(vsc, vsc); 1238 // CHECK: icmp slt <16 x i8> %{{.*}}, %{{.*}} 1239 // CHECK-ASM: vchb 1240 vbc = vec_cmplt(vuc, vuc); 1241 // CHECK: icmp ult <16 x i8> %{{.*}}, %{{.*}} 1242 // CHECK-ASM: vchlb 1243 vbs = vec_cmplt(vss, vss); 1244 // CHECK: icmp slt <8 x i16> %{{.*}}, %{{.*}} 1245 // CHECK-ASM: vchh 1246 vbs = vec_cmplt(vus, vus); 1247 // CHECK: icmp ult <8 x i16> %{{.*}}, %{{.*}} 1248 // CHECK-ASM: vchlh 1249 vbi = vec_cmplt(vsi, vsi); 1250 // CHECK: icmp slt <4 x i32> %{{.*}}, %{{.*}} 1251 // CHECK-ASM: vchf 1252 vbi = vec_cmplt(vui, vui); 1253 // CHECK: icmp ult <4 x i32> %{{.*}}, %{{.*}} 1254 // CHECK-ASM: vchlf 1255 vbl = vec_cmplt(vsl, vsl); 1256 // CHECK: icmp slt <2 x i64> %{{.*}}, %{{.*}} 1257 // CHECK-ASM: vchg 1258 vbl = vec_cmplt(vul, vul); 1259 // CHECK: icmp ult <2 x i64> %{{.*}}, %{{.*}} 1260 // CHECK-ASM: vchlg 1261 vbl = vec_cmplt(vd, vd); 1262 // CHECK: fcmp olt <2 x double> %{{.*}}, %{{.*}} 1263 // CHECK-ASM: vfchdb 1264 1265 idx = vec_all_eq(vsc, vsc); 1266 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1267 // CHECK-ASM: vceqbs 1268 idx = vec_all_eq(vsc, vbc); 1269 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1270 // CHECK-ASM: vceqbs 1271 idx = vec_all_eq(vbc, vsc); 1272 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1273 // CHECK-ASM: vceqbs 1274 idx = vec_all_eq(vuc, vuc); 1275 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1276 // CHECK-ASM: vceqbs 1277 idx = vec_all_eq(vuc, vbc); 1278 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1279 // CHECK-ASM: vceqbs 1280 idx = vec_all_eq(vbc, vuc); 1281 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1282 // CHECK-ASM: vceqbs 1283 idx = vec_all_eq(vbc, vbc); 1284 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1285 // CHECK-ASM: vceqbs 1286 idx = vec_all_eq(vss, vss); 1287 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1288 // CHECK-ASM: vceqhs 1289 idx = vec_all_eq(vss, vbs); 1290 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1291 // CHECK-ASM: vceqhs 1292 idx = vec_all_eq(vbs, vss); 1293 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1294 // CHECK-ASM: vceqhs 1295 idx = vec_all_eq(vus, vus); 1296 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1297 // CHECK-ASM: vceqhs 1298 idx = vec_all_eq(vus, vbs); 1299 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1300 // CHECK-ASM: vceqhs 1301 idx = vec_all_eq(vbs, vus); 1302 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1303 // CHECK-ASM: vceqhs 1304 idx = vec_all_eq(vbs, vbs); 1305 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1306 // CHECK-ASM: vceqhs 1307 idx = vec_all_eq(vsi, vsi); 1308 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1309 // CHECK-ASM: vceqfs 1310 idx = vec_all_eq(vsi, vbi); 1311 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1312 // CHECK-ASM: vceqfs 1313 idx = vec_all_eq(vbi, vsi); 1314 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1315 // CHECK-ASM: vceqfs 1316 idx = vec_all_eq(vui, vui); 1317 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1318 // CHECK-ASM: vceqfs 1319 idx = vec_all_eq(vui, vbi); 1320 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1321 // CHECK-ASM: vceqfs 1322 idx = vec_all_eq(vbi, vui); 1323 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1324 // CHECK-ASM: vceqfs 1325 idx = vec_all_eq(vbi, vbi); 1326 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1327 // CHECK-ASM: vceqfs 1328 idx = vec_all_eq(vsl, vsl); 1329 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1330 // CHECK-ASM: vceqgs 1331 idx = vec_all_eq(vsl, vbl); 1332 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1333 // CHECK-ASM: vceqgs 1334 idx = vec_all_eq(vbl, vsl); 1335 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1336 // CHECK-ASM: vceqgs 1337 idx = vec_all_eq(vul, vul); 1338 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1339 // CHECK-ASM: vceqgs 1340 idx = vec_all_eq(vul, vbl); 1341 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1342 // CHECK-ASM: vceqgs 1343 idx = vec_all_eq(vbl, vul); 1344 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1345 // CHECK-ASM: vceqgs 1346 idx = vec_all_eq(vbl, vbl); 1347 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1348 // CHECK-ASM: vceqgs 1349 idx = vec_all_eq(vd, vd); 1350 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 1351 // CHECK-ASM: vfcedbs 1352 1353 idx = vec_all_ne(vsc, vsc); 1354 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1355 // CHECK-ASM: vceqbs 1356 idx = vec_all_ne(vsc, vbc); 1357 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1358 // CHECK-ASM: vceqbs 1359 idx = vec_all_ne(vbc, vsc); 1360 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1361 // CHECK-ASM: vceqbs 1362 idx = vec_all_ne(vuc, vuc); 1363 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1364 // CHECK-ASM: vceqbs 1365 idx = vec_all_ne(vuc, vbc); 1366 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1367 // CHECK-ASM: vceqbs 1368 idx = vec_all_ne(vbc, vuc); 1369 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1370 // CHECK-ASM: vceqbs 1371 idx = vec_all_ne(vbc, vbc); 1372 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1373 // CHECK-ASM: vceqbs 1374 idx = vec_all_ne(vss, vss); 1375 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1376 // CHECK-ASM: vceqhs 1377 idx = vec_all_ne(vss, vbs); 1378 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1379 // CHECK-ASM: vceqhs 1380 idx = vec_all_ne(vbs, vss); 1381 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1382 // CHECK-ASM: vceqhs 1383 idx = vec_all_ne(vus, vus); 1384 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1385 // CHECK-ASM: vceqhs 1386 idx = vec_all_ne(vus, vbs); 1387 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1388 // CHECK-ASM: vceqhs 1389 idx = vec_all_ne(vbs, vus); 1390 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1391 // CHECK-ASM: vceqhs 1392 idx = vec_all_ne(vbs, vbs); 1393 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1394 // CHECK-ASM: vceqhs 1395 idx = vec_all_ne(vsi, vsi); 1396 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1397 // CHECK-ASM: vceqfs 1398 idx = vec_all_ne(vsi, vbi); 1399 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1400 // CHECK-ASM: vceqfs 1401 idx = vec_all_ne(vbi, vsi); 1402 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1403 // CHECK-ASM: vceqfs 1404 idx = vec_all_ne(vui, vui); 1405 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1406 // CHECK-ASM: vceqfs 1407 idx = vec_all_ne(vui, vbi); 1408 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1409 // CHECK-ASM: vceqfs 1410 idx = vec_all_ne(vbi, vui); 1411 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1412 // CHECK-ASM: vceqfs 1413 idx = vec_all_ne(vbi, vbi); 1414 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1415 // CHECK-ASM: vceqfs 1416 idx = vec_all_ne(vsl, vsl); 1417 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1418 // CHECK-ASM: vceqgs 1419 idx = vec_all_ne(vsl, vbl); 1420 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1421 // CHECK-ASM: vceqgs 1422 idx = vec_all_ne(vbl, vsl); 1423 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1424 // CHECK-ASM: vceqgs 1425 idx = vec_all_ne(vul, vul); 1426 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1427 // CHECK-ASM: vceqgs 1428 idx = vec_all_ne(vul, vbl); 1429 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1430 // CHECK-ASM: vceqgs 1431 idx = vec_all_ne(vbl, vul); 1432 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1433 // CHECK-ASM: vceqgs 1434 idx = vec_all_ne(vbl, vbl); 1435 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1436 // CHECK-ASM: vceqgs 1437 idx = vec_all_ne(vd, vd); 1438 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 1439 // CHECK-ASM: vfcedbs 1440 1441 idx = vec_all_ge(vsc, vsc); 1442 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1443 // CHECK-ASM: vchbs 1444 idx = vec_all_ge(vsc, vbc); 1445 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1446 // CHECK-ASM: vchbs 1447 idx = vec_all_ge(vbc, vsc); 1448 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1449 // CHECK-ASM: vchbs 1450 idx = vec_all_ge(vuc, vuc); 1451 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1452 // CHECK-ASM: vchlbs 1453 idx = vec_all_ge(vuc, vbc); 1454 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1455 // CHECK-ASM: vchlbs 1456 idx = vec_all_ge(vbc, vuc); 1457 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1458 // CHECK-ASM: vchlbs 1459 idx = vec_all_ge(vbc, vbc); 1460 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1461 // CHECK-ASM: vchlbs 1462 idx = vec_all_ge(vss, vss); 1463 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1464 // CHECK-ASM: vchhs 1465 idx = vec_all_ge(vss, vbs); 1466 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1467 // CHECK-ASM: vchhs 1468 idx = vec_all_ge(vbs, vss); 1469 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1470 // CHECK-ASM: vchhs 1471 idx = vec_all_ge(vus, vus); 1472 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1473 // CHECK-ASM: vchlhs 1474 idx = vec_all_ge(vus, vbs); 1475 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1476 // CHECK-ASM: vchlhs 1477 idx = vec_all_ge(vbs, vus); 1478 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1479 // CHECK-ASM: vchlhs 1480 idx = vec_all_ge(vbs, vbs); 1481 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1482 // CHECK-ASM: vchlhs 1483 idx = vec_all_ge(vsi, vsi); 1484 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1485 // CHECK-ASM: vchfs 1486 idx = vec_all_ge(vsi, vbi); 1487 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1488 // CHECK-ASM: vchfs 1489 idx = vec_all_ge(vbi, vsi); 1490 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1491 // CHECK-ASM: vchfs 1492 idx = vec_all_ge(vui, vui); 1493 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1494 // CHECK-ASM: vchlfs 1495 idx = vec_all_ge(vui, vbi); 1496 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1497 // CHECK-ASM: vchlfs 1498 idx = vec_all_ge(vbi, vui); 1499 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1500 // CHECK-ASM: vchlfs 1501 idx = vec_all_ge(vbi, vbi); 1502 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1503 // CHECK-ASM: vchlfs 1504 idx = vec_all_ge(vsl, vsl); 1505 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1506 // CHECK-ASM: vchgs 1507 idx = vec_all_ge(vsl, vbl); 1508 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1509 // CHECK-ASM: vchgs 1510 idx = vec_all_ge(vbl, vsl); 1511 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1512 // CHECK-ASM: vchgs 1513 idx = vec_all_ge(vul, vul); 1514 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1515 // CHECK-ASM: vchlgs 1516 idx = vec_all_ge(vul, vbl); 1517 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1518 // CHECK-ASM: vchlgs 1519 idx = vec_all_ge(vbl, vul); 1520 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1521 // CHECK-ASM: vchlgs 1522 idx = vec_all_ge(vbl, vbl); 1523 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1524 // CHECK-ASM: vchlgs 1525 idx = vec_all_ge(vd, vd); 1526 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 1527 // CHECK-ASM: vfchedbs 1528 1529 idx = vec_all_gt(vsc, vsc); 1530 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1531 // CHECK-ASM: vchbs 1532 idx = vec_all_gt(vsc, vbc); 1533 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1534 // CHECK-ASM: vchbs 1535 idx = vec_all_gt(vbc, vsc); 1536 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1537 // CHECK-ASM: vchbs 1538 idx = vec_all_gt(vuc, vuc); 1539 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1540 // CHECK-ASM: vchlbs 1541 idx = vec_all_gt(vuc, vbc); 1542 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1543 // CHECK-ASM: vchlbs 1544 idx = vec_all_gt(vbc, vuc); 1545 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1546 // CHECK-ASM: vchlbs 1547 idx = vec_all_gt(vbc, vbc); 1548 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1549 // CHECK-ASM: vchlbs 1550 idx = vec_all_gt(vss, vss); 1551 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1552 // CHECK-ASM: vchhs 1553 idx = vec_all_gt(vss, vbs); 1554 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1555 // CHECK-ASM: vchhs 1556 idx = vec_all_gt(vbs, vss); 1557 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1558 // CHECK-ASM: vchhs 1559 idx = vec_all_gt(vus, vus); 1560 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1561 // CHECK-ASM: vchlhs 1562 idx = vec_all_gt(vus, vbs); 1563 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1564 // CHECK-ASM: vchlhs 1565 idx = vec_all_gt(vbs, vus); 1566 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1567 // CHECK-ASM: vchlhs 1568 idx = vec_all_gt(vbs, vbs); 1569 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1570 // CHECK-ASM: vchlhs 1571 idx = vec_all_gt(vsi, vsi); 1572 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1573 // CHECK-ASM: vchfs 1574 idx = vec_all_gt(vsi, vbi); 1575 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1576 // CHECK-ASM: vchfs 1577 idx = vec_all_gt(vbi, vsi); 1578 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1579 // CHECK-ASM: vchfs 1580 idx = vec_all_gt(vui, vui); 1581 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1582 // CHECK-ASM: vchlfs 1583 idx = vec_all_gt(vui, vbi); 1584 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1585 // CHECK-ASM: vchlfs 1586 idx = vec_all_gt(vbi, vui); 1587 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1588 // CHECK-ASM: vchlfs 1589 idx = vec_all_gt(vbi, vbi); 1590 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1591 // CHECK-ASM: vchlfs 1592 idx = vec_all_gt(vsl, vsl); 1593 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1594 // CHECK-ASM: vchgs 1595 idx = vec_all_gt(vsl, vbl); 1596 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1597 // CHECK-ASM: vchgs 1598 idx = vec_all_gt(vbl, vsl); 1599 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1600 // CHECK-ASM: vchgs 1601 idx = vec_all_gt(vul, vul); 1602 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1603 // CHECK-ASM: vchlgs 1604 idx = vec_all_gt(vul, vbl); 1605 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1606 // CHECK-ASM: vchlgs 1607 idx = vec_all_gt(vbl, vul); 1608 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1609 // CHECK-ASM: vchlgs 1610 idx = vec_all_gt(vbl, vbl); 1611 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1612 // CHECK-ASM: vchlgs 1613 idx = vec_all_gt(vd, vd); 1614 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 1615 // CHECK-ASM: vfchdbs 1616 1617 idx = vec_all_le(vsc, vsc); 1618 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1619 // CHECK-ASM: vchbs 1620 idx = vec_all_le(vsc, vbc); 1621 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1622 // CHECK-ASM: vchbs 1623 idx = vec_all_le(vbc, vsc); 1624 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1625 // CHECK-ASM: vchbs 1626 idx = vec_all_le(vuc, vuc); 1627 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1628 // CHECK-ASM: vchlbs 1629 idx = vec_all_le(vuc, vbc); 1630 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1631 // CHECK-ASM: vchlbs 1632 idx = vec_all_le(vbc, vuc); 1633 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1634 // CHECK-ASM: vchlbs 1635 idx = vec_all_le(vbc, vbc); 1636 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1637 // CHECK-ASM: vchlbs 1638 idx = vec_all_le(vss, vss); 1639 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1640 // CHECK-ASM: vchhs 1641 idx = vec_all_le(vss, vbs); 1642 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1643 // CHECK-ASM: vchhs 1644 idx = vec_all_le(vbs, vss); 1645 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1646 // CHECK-ASM: vchhs 1647 idx = vec_all_le(vus, vus); 1648 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1649 // CHECK-ASM: vchlhs 1650 idx = vec_all_le(vus, vbs); 1651 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1652 // CHECK-ASM: vchlhs 1653 idx = vec_all_le(vbs, vus); 1654 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1655 // CHECK-ASM: vchlhs 1656 idx = vec_all_le(vbs, vbs); 1657 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1658 // CHECK-ASM: vchlhs 1659 idx = vec_all_le(vsi, vsi); 1660 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1661 // CHECK-ASM: vchfs 1662 idx = vec_all_le(vsi, vbi); 1663 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1664 // CHECK-ASM: vchfs 1665 idx = vec_all_le(vbi, vsi); 1666 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1667 // CHECK-ASM: vchfs 1668 idx = vec_all_le(vui, vui); 1669 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1670 // CHECK-ASM: vchlfs 1671 idx = vec_all_le(vui, vbi); 1672 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1673 // CHECK-ASM: vchlfs 1674 idx = vec_all_le(vbi, vui); 1675 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1676 // CHECK-ASM: vchlfs 1677 idx = vec_all_le(vbi, vbi); 1678 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1679 // CHECK-ASM: vchlfs 1680 idx = vec_all_le(vsl, vsl); 1681 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1682 // CHECK-ASM: vchgs 1683 idx = vec_all_le(vsl, vbl); 1684 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1685 // CHECK-ASM: vchgs 1686 idx = vec_all_le(vbl, vsl); 1687 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1688 // CHECK-ASM: vchgs 1689 idx = vec_all_le(vul, vul); 1690 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1691 // CHECK-ASM: vchlgs 1692 idx = vec_all_le(vul, vbl); 1693 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1694 // CHECK-ASM: vchlgs 1695 idx = vec_all_le(vbl, vul); 1696 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1697 // CHECK-ASM: vchlgs 1698 idx = vec_all_le(vbl, vbl); 1699 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1700 // CHECK-ASM: vchlgs 1701 idx = vec_all_le(vd, vd); 1702 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 1703 // CHECK-ASM: vfchedbs 1704 1705 idx = vec_all_lt(vsc, vsc); 1706 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1707 // CHECK-ASM: vchbs 1708 idx = vec_all_lt(vsc, vbc); 1709 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1710 // CHECK-ASM: vchbs 1711 idx = vec_all_lt(vbc, vsc); 1712 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1713 // CHECK-ASM: vchbs 1714 idx = vec_all_lt(vuc, vuc); 1715 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1716 // CHECK-ASM: vchlbs 1717 idx = vec_all_lt(vuc, vbc); 1718 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1719 // CHECK-ASM: vchlbs 1720 idx = vec_all_lt(vbc, vuc); 1721 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1722 // CHECK-ASM: vchlbs 1723 idx = vec_all_lt(vbc, vbc); 1724 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1725 // CHECK-ASM: vchlbs 1726 idx = vec_all_lt(vss, vss); 1727 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1728 // CHECK-ASM: vchhs 1729 idx = vec_all_lt(vss, vbs); 1730 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1731 // CHECK-ASM: vchhs 1732 idx = vec_all_lt(vbs, vss); 1733 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1734 // CHECK-ASM: vchhs 1735 idx = vec_all_lt(vus, vus); 1736 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1737 // CHECK-ASM: vchlhs 1738 idx = vec_all_lt(vus, vbs); 1739 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1740 // CHECK-ASM: vchlhs 1741 idx = vec_all_lt(vbs, vus); 1742 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1743 // CHECK-ASM: vchlhs 1744 idx = vec_all_lt(vbs, vbs); 1745 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1746 // CHECK-ASM: vchlhs 1747 idx = vec_all_lt(vsi, vsi); 1748 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1749 // CHECK-ASM: vchfs 1750 idx = vec_all_lt(vsi, vbi); 1751 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1752 // CHECK-ASM: vchfs 1753 idx = vec_all_lt(vbi, vsi); 1754 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1755 // CHECK-ASM: vchfs 1756 idx = vec_all_lt(vui, vui); 1757 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1758 // CHECK-ASM: vchlfs 1759 idx = vec_all_lt(vui, vbi); 1760 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1761 // CHECK-ASM: vchlfs 1762 idx = vec_all_lt(vbi, vui); 1763 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1764 // CHECK-ASM: vchlfs 1765 idx = vec_all_lt(vbi, vbi); 1766 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1767 // CHECK-ASM: vchlfs 1768 idx = vec_all_lt(vsl, vsl); 1769 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1770 // CHECK-ASM: vchgs 1771 idx = vec_all_lt(vsl, vbl); 1772 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1773 // CHECK-ASM: vchgs 1774 idx = vec_all_lt(vbl, vsl); 1775 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1776 // CHECK-ASM: vchgs 1777 idx = vec_all_lt(vul, vul); 1778 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1779 // CHECK-ASM: vchlgs 1780 idx = vec_all_lt(vul, vbl); 1781 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1782 // CHECK-ASM: vchlgs 1783 idx = vec_all_lt(vbl, vul); 1784 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1785 // CHECK-ASM: vchlgs 1786 idx = vec_all_lt(vbl, vbl); 1787 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1788 // CHECK-ASM: vchlgs 1789 idx = vec_all_lt(vd, vd); 1790 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 1791 // CHECK-ASM: vfchdbs 1792 1793 idx = vec_all_nge(vd, vd); 1794 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 1795 // CHECK-ASM: vfchedbs 1796 idx = vec_all_ngt(vd, vd); 1797 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 1798 // CHECK-ASM: vfchdbs 1799 idx = vec_all_nle(vd, vd); 1800 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 1801 // CHECK-ASM: vfchedbs 1802 idx = vec_all_nlt(vd, vd); 1803 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 1804 // CHECK-ASM: vfchdbs 1805 1806 idx = vec_all_nan(vd); 1807 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15) 1808 // CHECK-ASM: vftcidb 1809 idx = vec_all_numeric(vd); 1810 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15) 1811 // CHECK-ASM: vftcidb 1812 1813 idx = vec_any_eq(vsc, vsc); 1814 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1815 // CHECK-ASM: vceqbs 1816 idx = vec_any_eq(vsc, vbc); 1817 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1818 // CHECK-ASM: vceqbs 1819 idx = vec_any_eq(vbc, vsc); 1820 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1821 // CHECK-ASM: vceqbs 1822 idx = vec_any_eq(vuc, vuc); 1823 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1824 // CHECK-ASM: vceqbs 1825 idx = vec_any_eq(vuc, vbc); 1826 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1827 // CHECK-ASM: vceqbs 1828 idx = vec_any_eq(vbc, vuc); 1829 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1830 // CHECK-ASM: vceqbs 1831 idx = vec_any_eq(vbc, vbc); 1832 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1833 // CHECK-ASM: vceqbs 1834 idx = vec_any_eq(vss, vss); 1835 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1836 // CHECK-ASM: vceqhs 1837 idx = vec_any_eq(vss, vbs); 1838 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1839 // CHECK-ASM: vceqhs 1840 idx = vec_any_eq(vbs, vss); 1841 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1842 // CHECK-ASM: vceqhs 1843 idx = vec_any_eq(vus, vus); 1844 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1845 // CHECK-ASM: vceqhs 1846 idx = vec_any_eq(vus, vbs); 1847 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1848 // CHECK-ASM: vceqhs 1849 idx = vec_any_eq(vbs, vus); 1850 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1851 // CHECK-ASM: vceqhs 1852 idx = vec_any_eq(vbs, vbs); 1853 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1854 // CHECK-ASM: vceqhs 1855 idx = vec_any_eq(vsi, vsi); 1856 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1857 // CHECK-ASM: vceqfs 1858 idx = vec_any_eq(vsi, vbi); 1859 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1860 // CHECK-ASM: vceqfs 1861 idx = vec_any_eq(vbi, vsi); 1862 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1863 // CHECK-ASM: vceqfs 1864 idx = vec_any_eq(vui, vui); 1865 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1866 // CHECK-ASM: vceqfs 1867 idx = vec_any_eq(vui, vbi); 1868 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1869 // CHECK-ASM: vceqfs 1870 idx = vec_any_eq(vbi, vui); 1871 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1872 // CHECK-ASM: vceqfs 1873 idx = vec_any_eq(vbi, vbi); 1874 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1875 // CHECK-ASM: vceqfs 1876 idx = vec_any_eq(vsl, vsl); 1877 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1878 // CHECK-ASM: vceqgs 1879 idx = vec_any_eq(vsl, vbl); 1880 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1881 // CHECK-ASM: vceqgs 1882 idx = vec_any_eq(vbl, vsl); 1883 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1884 // CHECK-ASM: vceqgs 1885 idx = vec_any_eq(vul, vul); 1886 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1887 // CHECK-ASM: vceqgs 1888 idx = vec_any_eq(vul, vbl); 1889 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1890 // CHECK-ASM: vceqgs 1891 idx = vec_any_eq(vbl, vul); 1892 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1893 // CHECK-ASM: vceqgs 1894 idx = vec_any_eq(vbl, vbl); 1895 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1896 // CHECK-ASM: vceqgs 1897 idx = vec_any_eq(vd, vd); 1898 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 1899 // CHECK-ASM: vfcedbs 1900 1901 idx = vec_any_ne(vsc, vsc); 1902 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1903 // CHECK-ASM: vceqbs 1904 idx = vec_any_ne(vsc, vbc); 1905 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1906 // CHECK-ASM: vceqbs 1907 idx = vec_any_ne(vbc, vsc); 1908 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1909 // CHECK-ASM: vceqbs 1910 idx = vec_any_ne(vuc, vuc); 1911 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1912 // CHECK-ASM: vceqbs 1913 idx = vec_any_ne(vuc, vbc); 1914 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1915 // CHECK-ASM: vceqbs 1916 idx = vec_any_ne(vbc, vuc); 1917 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1918 // CHECK-ASM: vceqbs 1919 idx = vec_any_ne(vbc, vbc); 1920 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1921 // CHECK-ASM: vceqbs 1922 idx = vec_any_ne(vss, vss); 1923 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1924 // CHECK-ASM: vceqhs 1925 idx = vec_any_ne(vss, vbs); 1926 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1927 // CHECK-ASM: vceqhs 1928 idx = vec_any_ne(vbs, vss); 1929 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1930 // CHECK-ASM: vceqhs 1931 idx = vec_any_ne(vus, vus); 1932 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1933 // CHECK-ASM: vceqhs 1934 idx = vec_any_ne(vus, vbs); 1935 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1936 // CHECK-ASM: vceqhs 1937 idx = vec_any_ne(vbs, vus); 1938 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1939 // CHECK-ASM: vceqhs 1940 idx = vec_any_ne(vbs, vbs); 1941 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1942 // CHECK-ASM: vceqhs 1943 idx = vec_any_ne(vsi, vsi); 1944 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1945 // CHECK-ASM: vceqfs 1946 idx = vec_any_ne(vsi, vbi); 1947 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1948 // CHECK-ASM: vceqfs 1949 idx = vec_any_ne(vbi, vsi); 1950 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1951 // CHECK-ASM: vceqfs 1952 idx = vec_any_ne(vui, vui); 1953 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1954 // CHECK-ASM: vceqfs 1955 idx = vec_any_ne(vui, vbi); 1956 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1957 // CHECK-ASM: vceqfs 1958 idx = vec_any_ne(vbi, vui); 1959 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1960 // CHECK-ASM: vceqfs 1961 idx = vec_any_ne(vbi, vbi); 1962 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1963 // CHECK-ASM: vceqfs 1964 idx = vec_any_ne(vsl, vsl); 1965 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1966 // CHECK-ASM: vceqgs 1967 idx = vec_any_ne(vsl, vbl); 1968 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1969 // CHECK-ASM: vceqgs 1970 idx = vec_any_ne(vbl, vsl); 1971 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1972 // CHECK-ASM: vceqgs 1973 idx = vec_any_ne(vul, vul); 1974 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1975 // CHECK-ASM: vceqgs 1976 idx = vec_any_ne(vul, vbl); 1977 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1978 // CHECK-ASM: vceqgs 1979 idx = vec_any_ne(vbl, vul); 1980 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1981 // CHECK-ASM: vceqgs 1982 idx = vec_any_ne(vbl, vbl); 1983 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1984 // CHECK-ASM: vceqgs 1985 idx = vec_any_ne(vd, vd); 1986 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 1987 // CHECK-ASM: vfcedbs 1988 1989 idx = vec_any_ge(vsc, vsc); 1990 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1991 // CHECK-ASM: vchbs 1992 idx = vec_any_ge(vsc, vbc); 1993 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1994 // CHECK-ASM: vchbs 1995 idx = vec_any_ge(vbc, vsc); 1996 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1997 // CHECK-ASM: vchbs 1998 idx = vec_any_ge(vuc, vuc); 1999 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2000 // CHECK-ASM: vchlbs 2001 idx = vec_any_ge(vuc, vbc); 2002 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2003 // CHECK-ASM: vchlbs 2004 idx = vec_any_ge(vbc, vuc); 2005 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2006 // CHECK-ASM: vchlbs 2007 idx = vec_any_ge(vbc, vbc); 2008 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2009 // CHECK-ASM: vchlbs 2010 idx = vec_any_ge(vss, vss); 2011 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2012 // CHECK-ASM: vchhs 2013 idx = vec_any_ge(vss, vbs); 2014 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2015 // CHECK-ASM: vchhs 2016 idx = vec_any_ge(vbs, vss); 2017 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2018 // CHECK-ASM: vchhs 2019 idx = vec_any_ge(vus, vus); 2020 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2021 // CHECK-ASM: vchlhs 2022 idx = vec_any_ge(vus, vbs); 2023 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2024 // CHECK-ASM: vchlhs 2025 idx = vec_any_ge(vbs, vus); 2026 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2027 // CHECK-ASM: vchlhs 2028 idx = vec_any_ge(vbs, vbs); 2029 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2030 // CHECK-ASM: vchlhs 2031 idx = vec_any_ge(vsi, vsi); 2032 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2033 // CHECK-ASM: vchfs 2034 idx = vec_any_ge(vsi, vbi); 2035 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2036 // CHECK-ASM: vchfs 2037 idx = vec_any_ge(vbi, vsi); 2038 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2039 // CHECK-ASM: vchfs 2040 idx = vec_any_ge(vui, vui); 2041 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2042 // CHECK-ASM: vchlfs 2043 idx = vec_any_ge(vui, vbi); 2044 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2045 // CHECK-ASM: vchlfs 2046 idx = vec_any_ge(vbi, vui); 2047 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2048 // CHECK-ASM: vchlfs 2049 idx = vec_any_ge(vbi, vbi); 2050 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2051 // CHECK-ASM: vchlfs 2052 idx = vec_any_ge(vsl, vsl); 2053 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 2054 // CHECK-ASM: vchgs 2055 idx = vec_any_ge(vsl, vbl); 2056 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 2057 // CHECK-ASM: vchgs 2058 idx = vec_any_ge(vbl, vsl); 2059 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 2060 // CHECK-ASM: vchgs 2061 idx = vec_any_ge(vul, vul); 2062 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 2063 // CHECK-ASM: vchlgs 2064 idx = vec_any_ge(vul, vbl); 2065 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 2066 // CHECK-ASM: vchlgs 2067 idx = vec_any_ge(vbl, vul); 2068 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 2069 // CHECK-ASM: vchlgs 2070 idx = vec_any_ge(vbl, vbl); 2071 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 2072 // CHECK-ASM: vchlgs 2073 idx = vec_any_ge(vd, vd); 2074 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 2075 // CHECK-ASM: vfchedbs 2076 2077 idx = vec_any_gt(vsc, vsc); 2078 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2079 // CHECK-ASM: vchbs 2080 idx = vec_any_gt(vsc, vbc); 2081 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2082 // CHECK-ASM: vchbs 2083 idx = vec_any_gt(vbc, vsc); 2084 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2085 // CHECK-ASM: vchbs 2086 idx = vec_any_gt(vuc, vuc); 2087 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2088 // CHECK-ASM: vchlbs 2089 idx = vec_any_gt(vuc, vbc); 2090 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2091 // CHECK-ASM: vchlbs 2092 idx = vec_any_gt(vbc, vuc); 2093 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2094 // CHECK-ASM: vchlbs 2095 idx = vec_any_gt(vbc, vbc); 2096 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2097 // CHECK-ASM: vchlbs 2098 idx = vec_any_gt(vss, vss); 2099 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2100 // CHECK-ASM: vchhs 2101 idx = vec_any_gt(vss, vbs); 2102 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2103 // CHECK-ASM: vchhs 2104 idx = vec_any_gt(vbs, vss); 2105 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2106 // CHECK-ASM: vchhs 2107 idx = vec_any_gt(vus, vus); 2108 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2109 // CHECK-ASM: vchlhs 2110 idx = vec_any_gt(vus, vbs); 2111 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2112 // CHECK-ASM: vchlhs 2113 idx = vec_any_gt(vbs, vus); 2114 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2115 // CHECK-ASM: vchlhs 2116 idx = vec_any_gt(vbs, vbs); 2117 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2118 // CHECK-ASM: vchlhs 2119 idx = vec_any_gt(vsi, vsi); 2120 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2121 // CHECK-ASM: vchfs 2122 idx = vec_any_gt(vsi, vbi); 2123 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2124 // CHECK-ASM: vchfs 2125 idx = vec_any_gt(vbi, vsi); 2126 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2127 // CHECK-ASM: vchfs 2128 idx = vec_any_gt(vui, vui); 2129 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2130 // CHECK-ASM: vchlfs 2131 idx = vec_any_gt(vui, vbi); 2132 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2133 // CHECK-ASM: vchlfs 2134 idx = vec_any_gt(vbi, vui); 2135 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2136 // CHECK-ASM: vchlfs 2137 idx = vec_any_gt(vbi, vbi); 2138 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2139 // CHECK-ASM: vchlfs 2140 idx = vec_any_gt(vsl, vsl); 2141 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 2142 // CHECK-ASM: vchgs 2143 idx = vec_any_gt(vsl, vbl); 2144 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 2145 // CHECK-ASM: vchgs 2146 idx = vec_any_gt(vbl, vsl); 2147 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 2148 // CHECK-ASM: vchgs 2149 idx = vec_any_gt(vul, vul); 2150 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 2151 // CHECK-ASM: vchlgs 2152 idx = vec_any_gt(vul, vbl); 2153 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 2154 // CHECK-ASM: vchlgs 2155 idx = vec_any_gt(vbl, vul); 2156 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 2157 // CHECK-ASM: vchlgs 2158 idx = vec_any_gt(vbl, vbl); 2159 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 2160 // CHECK-ASM: vchlgs 2161 idx = vec_any_gt(vd, vd); 2162 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 2163 // CHECK-ASM: vfchdbs 2164 2165 idx = vec_any_le(vsc, vsc); 2166 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2167 // CHECK-ASM: vchbs 2168 idx = vec_any_le(vsc, vbc); 2169 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2170 // CHECK-ASM: vchbs 2171 idx = vec_any_le(vbc, vsc); 2172 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2173 // CHECK-ASM: vchbs 2174 idx = vec_any_le(vuc, vuc); 2175 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2176 // CHECK-ASM: vchlbs 2177 idx = vec_any_le(vuc, vbc); 2178 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2179 // CHECK-ASM: vchlbs 2180 idx = vec_any_le(vbc, vuc); 2181 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2182 // CHECK-ASM: vchlbs 2183 idx = vec_any_le(vbc, vbc); 2184 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2185 // CHECK-ASM: vchlbs 2186 idx = vec_any_le(vss, vss); 2187 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2188 // CHECK-ASM: vchhs 2189 idx = vec_any_le(vss, vbs); 2190 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2191 // CHECK-ASM: vchhs 2192 idx = vec_any_le(vbs, vss); 2193 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2194 // CHECK-ASM: vchhs 2195 idx = vec_any_le(vus, vus); 2196 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2197 // CHECK-ASM: vchlhs 2198 idx = vec_any_le(vus, vbs); 2199 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2200 // CHECK-ASM: vchlhs 2201 idx = vec_any_le(vbs, vus); 2202 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2203 // CHECK-ASM: vchlhs 2204 idx = vec_any_le(vbs, vbs); 2205 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2206 // CHECK-ASM: vchlhs 2207 idx = vec_any_le(vsi, vsi); 2208 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2209 // CHECK-ASM: vchfs 2210 idx = vec_any_le(vsi, vbi); 2211 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2212 // CHECK-ASM: vchfs 2213 idx = vec_any_le(vbi, vsi); 2214 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2215 // CHECK-ASM: vchfs 2216 idx = vec_any_le(vui, vui); 2217 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2218 // CHECK-ASM: vchlfs 2219 idx = vec_any_le(vui, vbi); 2220 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2221 // CHECK-ASM: vchlfs 2222 idx = vec_any_le(vbi, vui); 2223 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2224 // CHECK-ASM: vchlfs 2225 idx = vec_any_le(vbi, vbi); 2226 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2227 // CHECK-ASM: vchlfs 2228 idx = vec_any_le(vsl, vsl); 2229 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 2230 // CHECK-ASM: vchgs 2231 idx = vec_any_le(vsl, vbl); 2232 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 2233 // CHECK-ASM: vchgs 2234 idx = vec_any_le(vbl, vsl); 2235 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 2236 // CHECK-ASM: vchgs 2237 idx = vec_any_le(vul, vul); 2238 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 2239 // CHECK-ASM: vchlgs 2240 idx = vec_any_le(vul, vbl); 2241 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 2242 // CHECK-ASM: vchlgs 2243 idx = vec_any_le(vbl, vul); 2244 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 2245 // CHECK-ASM: vchlgs 2246 idx = vec_any_le(vbl, vbl); 2247 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 2248 // CHECK-ASM: vchlgs 2249 idx = vec_any_le(vd, vd); 2250 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 2251 // CHECK-ASM: vfchedbs 2252 2253 idx = vec_any_lt(vsc, vsc); 2254 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2255 // CHECK-ASM: vchbs 2256 idx = vec_any_lt(vsc, vbc); 2257 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2258 // CHECK-ASM: vchbs 2259 idx = vec_any_lt(vbc, vsc); 2260 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2261 // CHECK-ASM: vchbs 2262 idx = vec_any_lt(vuc, vuc); 2263 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2264 // CHECK-ASM: vchlbs 2265 idx = vec_any_lt(vuc, vbc); 2266 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2267 // CHECK-ASM: vchlbs 2268 idx = vec_any_lt(vbc, vuc); 2269 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2270 // CHECK-ASM: vchlbs 2271 idx = vec_any_lt(vbc, vbc); 2272 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2273 // CHECK-ASM: vchlbs 2274 idx = vec_any_lt(vss, vss); 2275 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2276 // CHECK-ASM: vchhs 2277 idx = vec_any_lt(vss, vbs); 2278 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2279 // CHECK-ASM: vchhs 2280 idx = vec_any_lt(vbs, vss); 2281 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2282 // CHECK-ASM: vchhs 2283 idx = vec_any_lt(vus, vus); 2284 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2285 // CHECK-ASM: vchlhs 2286 idx = vec_any_lt(vus, vbs); 2287 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2288 // CHECK-ASM: vchlhs 2289 idx = vec_any_lt(vbs, vus); 2290 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2291 // CHECK-ASM: vchlhs 2292 idx = vec_any_lt(vbs, vbs); 2293 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2294 // CHECK-ASM: vchlhs 2295 idx = vec_any_lt(vsi, vsi); 2296 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2297 // CHECK-ASM: vchfs 2298 idx = vec_any_lt(vsi, vbi); 2299 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2300 // CHECK-ASM: vchfs 2301 idx = vec_any_lt(vbi, vsi); 2302 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2303 // CHECK-ASM: vchfs 2304 idx = vec_any_lt(vui, vui); 2305 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2306 // CHECK-ASM: vchlfs 2307 idx = vec_any_lt(vui, vbi); 2308 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2309 // CHECK-ASM: vchlfs 2310 idx = vec_any_lt(vbi, vui); 2311 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2312 // CHECK-ASM: vchlfs 2313 idx = vec_any_lt(vbi, vbi); 2314 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2315 // CHECK-ASM: vchlfs 2316 idx = vec_any_lt(vsl, vsl); 2317 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 2318 // CHECK-ASM: vchgs 2319 idx = vec_any_lt(vsl, vbl); 2320 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 2321 // CHECK-ASM: vchgs 2322 idx = vec_any_lt(vbl, vsl); 2323 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 2324 // CHECK-ASM: vchgs 2325 idx = vec_any_lt(vul, vul); 2326 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 2327 // CHECK-ASM: vchlgs 2328 idx = vec_any_lt(vul, vbl); 2329 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 2330 // CHECK-ASM: vchlgs 2331 idx = vec_any_lt(vbl, vul); 2332 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 2333 // CHECK-ASM: vchlgs 2334 idx = vec_any_lt(vbl, vbl); 2335 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 2336 // CHECK-ASM: vchlgs 2337 idx = vec_any_lt(vd, vd); 2338 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 2339 // CHECK-ASM: vfchdbs 2340 2341 idx = vec_any_nge(vd, vd); 2342 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 2343 // CHECK-ASM: vfchedbs 2344 idx = vec_any_ngt(vd, vd); 2345 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 2346 // CHECK-ASM: vfchdbs 2347 idx = vec_any_nle(vd, vd); 2348 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 2349 // CHECK-ASM: vfchedbs 2350 idx = vec_any_nlt(vd, vd); 2351 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 2352 // CHECK-ASM: vfchdbs 2353 2354 idx = vec_any_nan(vd); 2355 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15) 2356 // CHECK-ASM: vftcidb 2357 idx = vec_any_numeric(vd); 2358 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15) 2359 // CHECK-ASM: vftcidb 2360 } 2361 2362 void test_integer(void) { 2363 // CHECK-ASM-LABEL: test_integer 2364 2365 vsc = vec_andc(vsc, vsc); 2366 // CHECK-ASM: vnc 2367 vsc = vec_andc(vsc, vbc); 2368 // CHECK-ASM: vnc 2369 vsc = vec_andc(vbc, vsc); 2370 // CHECK-ASM: vnc 2371 vuc = vec_andc(vuc, vuc); 2372 // CHECK-ASM: vnc 2373 vuc = vec_andc(vuc, vbc); 2374 // CHECK-ASM: vnc 2375 vuc = vec_andc(vbc, vuc); 2376 // CHECK-ASM: vnc 2377 vbc = vec_andc(vbc, vbc); 2378 // CHECK-ASM: vnc 2379 vss = vec_andc(vss, vss); 2380 // CHECK-ASM: vnc 2381 vss = vec_andc(vss, vbs); 2382 // CHECK-ASM: vnc 2383 vss = vec_andc(vbs, vss); 2384 // CHECK-ASM: vnc 2385 vus = vec_andc(vus, vus); 2386 // CHECK-ASM: vnc 2387 vus = vec_andc(vus, vbs); 2388 // CHECK-ASM: vnc 2389 vus = vec_andc(vbs, vus); 2390 // CHECK-ASM: vnc 2391 vbs = vec_andc(vbs, vbs); 2392 // CHECK-ASM: vnc 2393 vsi = vec_andc(vsi, vsi); 2394 // CHECK-ASM: vnc 2395 vsi = vec_andc(vsi, vbi); 2396 // CHECK-ASM: vnc 2397 vsi = vec_andc(vbi, vsi); 2398 // CHECK-ASM: vnc 2399 vui = vec_andc(vui, vui); 2400 // CHECK-ASM: vnc 2401 vui = vec_andc(vui, vbi); 2402 // CHECK-ASM: vnc 2403 vui = vec_andc(vbi, vui); 2404 // CHECK-ASM: vnc 2405 vbi = vec_andc(vbi, vbi); 2406 // CHECK-ASM: vnc 2407 vsl = vec_andc(vsl, vsl); 2408 // CHECK-ASM: vnc 2409 vsl = vec_andc(vsl, vbl); 2410 // CHECK-ASM: vnc 2411 vsl = vec_andc(vbl, vsl); 2412 // CHECK-ASM: vnc 2413 vul = vec_andc(vul, vul); 2414 // CHECK-ASM: vnc 2415 vul = vec_andc(vul, vbl); 2416 // CHECK-ASM: vnc 2417 vul = vec_andc(vbl, vul); 2418 // CHECK-ASM: vnc 2419 vbl = vec_andc(vbl, vbl); 2420 // CHECK-ASM: vnc 2421 vd = vec_andc(vd, vd); 2422 // CHECK-ASM: vnc 2423 vd = vec_andc(vd, vbl); 2424 // CHECK-ASM: vnc 2425 vd = vec_andc(vbl, vd); 2426 // CHECK-ASM: vnc 2427 2428 vsc = vec_nor(vsc, vsc); 2429 // CHECK-ASM: vno 2430 vsc = vec_nor(vsc, vbc); 2431 // CHECK-ASM: vno 2432 vsc = vec_nor(vbc, vsc); 2433 // CHECK-ASM: vno 2434 vuc = vec_nor(vuc, vuc); 2435 // CHECK-ASM: vno 2436 vuc = vec_nor(vuc, vbc); 2437 // CHECK-ASM: vno 2438 vuc = vec_nor(vbc, vuc); 2439 // CHECK-ASM: vno 2440 vbc = vec_nor(vbc, vbc); 2441 // CHECK-ASM: vno 2442 vss = vec_nor(vss, vss); 2443 // CHECK-ASM: vno 2444 vss = vec_nor(vss, vbs); 2445 // CHECK-ASM: vno 2446 vss = vec_nor(vbs, vss); 2447 // CHECK-ASM: vno 2448 vus = vec_nor(vus, vus); 2449 // CHECK-ASM: vno 2450 vus = vec_nor(vus, vbs); 2451 // CHECK-ASM: vno 2452 vus = vec_nor(vbs, vus); 2453 // CHECK-ASM: vno 2454 vbs = vec_nor(vbs, vbs); 2455 // CHECK-ASM: vno 2456 vsi = vec_nor(vsi, vsi); 2457 // CHECK-ASM: vno 2458 vsi = vec_nor(vsi, vbi); 2459 // CHECK-ASM: vno 2460 vsi = vec_nor(vbi, vsi); 2461 // CHECK-ASM: vno 2462 vui = vec_nor(vui, vui); 2463 // CHECK-ASM: vno 2464 vui = vec_nor(vui, vbi); 2465 // CHECK-ASM: vno 2466 vui = vec_nor(vbi, vui); 2467 // CHECK-ASM: vno 2468 vbi = vec_nor(vbi, vbi); 2469 // CHECK-ASM: vno 2470 vsl = vec_nor(vsl, vsl); 2471 // CHECK-ASM: vno 2472 vsl = vec_nor(vsl, vbl); 2473 // CHECK-ASM: vno 2474 vsl = vec_nor(vbl, vsl); 2475 // CHECK-ASM: vno 2476 vul = vec_nor(vul, vul); 2477 // CHECK-ASM: vno 2478 vul = vec_nor(vul, vbl); 2479 // CHECK-ASM: vno 2480 vul = vec_nor(vbl, vul); 2481 // CHECK-ASM: vno 2482 vbl = vec_nor(vbl, vbl); 2483 // CHECK-ASM: vno 2484 vd = vec_nor(vd, vd); 2485 // CHECK-ASM: vno 2486 vd = vec_nor(vd, vbl); 2487 // CHECK-ASM: vno 2488 vd = vec_nor(vbl, vd); 2489 // CHECK-ASM: vno 2490 2491 vuc = vec_cntlz(vsc); 2492 // CHECK: call <16 x i8> @llvm.ctlz.v16i8(<16 x i8> %{{.*}}, i1 false) 2493 // CHECK-ASM: vclzb 2494 vuc = vec_cntlz(vuc); 2495 // CHECK: call <16 x i8> @llvm.ctlz.v16i8(<16 x i8> %{{.*}}, i1 false) 2496 // CHECK-ASM: vclzb 2497 vus = vec_cntlz(vss); 2498 // CHECK: call <8 x i16> @llvm.ctlz.v8i16(<8 x i16> %{{.*}}, i1 false) 2499 // CHECK-ASM: vclzh 2500 vus = vec_cntlz(vus); 2501 // CHECK: call <8 x i16> @llvm.ctlz.v8i16(<8 x i16> %{{.*}}, i1 false) 2502 // CHECK-ASM: vclzh 2503 vui = vec_cntlz(vsi); 2504 // CHECK: call <4 x i32> @llvm.ctlz.v4i32(<4 x i32> %{{.*}}, i1 false) 2505 // CHECK-ASM: vclzf 2506 vui = vec_cntlz(vui); 2507 // CHECK: call <4 x i32> @llvm.ctlz.v4i32(<4 x i32> %{{.*}}, i1 false) 2508 // CHECK-ASM: vclzf 2509 vul = vec_cntlz(vsl); 2510 // CHECK: call <2 x i64> @llvm.ctlz.v2i64(<2 x i64> %{{.*}}, i1 false) 2511 // CHECK-ASM: vclzg 2512 vul = vec_cntlz(vul); 2513 // CHECK: call <2 x i64> @llvm.ctlz.v2i64(<2 x i64> %{{.*}}, i1 false) 2514 // CHECK-ASM: vclzg 2515 2516 vuc = vec_cnttz(vsc); 2517 // CHECK: call <16 x i8> @llvm.cttz.v16i8(<16 x i8> %{{.*}}, i1 false) 2518 // CHECK-ASM: vctzb 2519 vuc = vec_cnttz(vuc); 2520 // CHECK: call <16 x i8> @llvm.cttz.v16i8(<16 x i8> %{{.*}}, i1 false) 2521 // CHECK-ASM: vctzb 2522 vus = vec_cnttz(vss); 2523 // CHECK: call <8 x i16> @llvm.cttz.v8i16(<8 x i16> %{{.*}}, i1 false) 2524 // CHECK-ASM: vctzh 2525 vus = vec_cnttz(vus); 2526 // CHECK: call <8 x i16> @llvm.cttz.v8i16(<8 x i16> %{{.*}}, i1 false) 2527 // CHECK-ASM: vctzh 2528 vui = vec_cnttz(vsi); 2529 // CHECK: call <4 x i32> @llvm.cttz.v4i32(<4 x i32> %{{.*}}, i1 false) 2530 // CHECK-ASM: vctzf 2531 vui = vec_cnttz(vui); 2532 // CHECK: call <4 x i32> @llvm.cttz.v4i32(<4 x i32> %{{.*}}, i1 false) 2533 // CHECK-ASM: vctzf 2534 vul = vec_cnttz(vsl); 2535 // CHECK: call <2 x i64> @llvm.cttz.v2i64(<2 x i64> %{{.*}}, i1 false) 2536 // CHECK-ASM: vctzg 2537 vul = vec_cnttz(vul); 2538 // CHECK: call <2 x i64> @llvm.cttz.v2i64(<2 x i64> %{{.*}}, i1 false) 2539 // CHECK-ASM: vctzg 2540 2541 vuc = vec_popcnt(vsc); 2542 // CHECK: call <16 x i8> @llvm.ctpop.v16i8(<16 x i8> %{{.*}}) 2543 // CHECK-ASM: vpopct 2544 vuc = vec_popcnt(vuc); 2545 // CHECK: call <16 x i8> @llvm.ctpop.v16i8(<16 x i8> %{{.*}}) 2546 // CHECK-ASM: vpopct 2547 vus = vec_popcnt(vss); 2548 // CHECK: call <8 x i16> @llvm.ctpop.v8i16(<8 x i16> %{{.*}}) 2549 // (emulated) 2550 vus = vec_popcnt(vus); 2551 // CHECK: call <8 x i16> @llvm.ctpop.v8i16(<8 x i16> %{{.*}}) 2552 // (emulated) 2553 vui = vec_popcnt(vsi); 2554 // CHECK: call <4 x i32> @llvm.ctpop.v4i32(<4 x i32> %{{.*}}) 2555 // (emulated) 2556 vui = vec_popcnt(vui); 2557 // CHECK: call <4 x i32> @llvm.ctpop.v4i32(<4 x i32> %{{.*}}) 2558 // (emulated) 2559 vul = vec_popcnt(vsl); 2560 // CHECK: call <2 x i64> @llvm.ctpop.v2i64(<2 x i64> %{{.*}}) 2561 // (emulated) 2562 vul = vec_popcnt(vul); 2563 // CHECK: call <2 x i64> @llvm.ctpop.v2i64(<2 x i64> %{{.*}}) 2564 // (emulated) 2565 2566 vsc = vec_rl(vsc, vuc); 2567 // CHECK: call <16 x i8> @llvm.s390.verllvb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2568 // CHECK-ASM: verllvb 2569 vuc = vec_rl(vuc, vuc); 2570 // CHECK: call <16 x i8> @llvm.s390.verllvb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2571 // CHECK-ASM: verllvb 2572 vss = vec_rl(vss, vus); 2573 // CHECK: call <8 x i16> @llvm.s390.verllvh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2574 // CHECK-ASM: verllvh 2575 vus = vec_rl(vus, vus); 2576 // CHECK: call <8 x i16> @llvm.s390.verllvh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2577 // CHECK-ASM: verllvh 2578 vsi = vec_rl(vsi, vui); 2579 // CHECK: call <4 x i32> @llvm.s390.verllvf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2580 // CHECK-ASM: verllvf 2581 vui = vec_rl(vui, vui); 2582 // CHECK: call <4 x i32> @llvm.s390.verllvf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2583 // CHECK-ASM: verllvf 2584 vsl = vec_rl(vsl, vul); 2585 // CHECK: call <2 x i64> @llvm.s390.verllvg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 2586 // CHECK-ASM: verllvg 2587 vul = vec_rl(vul, vul); 2588 // CHECK: call <2 x i64> @llvm.s390.verllvg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 2589 // CHECK-ASM: verllvg 2590 2591 vsc = vec_rli(vsc, ul); 2592 // CHECK: call <16 x i8> @llvm.s390.verllb(<16 x i8> %{{.*}}, i32 %{{.*}}) 2593 // CHECK-ASM: verllb 2594 vuc = vec_rli(vuc, ul); 2595 // CHECK: call <16 x i8> @llvm.s390.verllb(<16 x i8> %{{.*}}, i32 %{{.*}}) 2596 // CHECK-ASM: verllb 2597 vss = vec_rli(vss, ul); 2598 // CHECK: call <8 x i16> @llvm.s390.verllh(<8 x i16> %{{.*}}, i32 %{{.*}}) 2599 // CHECK-ASM: verllh 2600 vus = vec_rli(vus, ul); 2601 // CHECK: call <8 x i16> @llvm.s390.verllh(<8 x i16> %{{.*}}, i32 %{{.*}}) 2602 // CHECK-ASM: verllh 2603 vsi = vec_rli(vsi, ul); 2604 // CHECK: call <4 x i32> @llvm.s390.verllf(<4 x i32> %{{.*}}, i32 %{{.*}}) 2605 // CHECK-ASM: verllf 2606 vui = vec_rli(vui, ul); 2607 // CHECK: call <4 x i32> @llvm.s390.verllf(<4 x i32> %{{.*}}, i32 %{{.*}}) 2608 // CHECK-ASM: verllf 2609 vsl = vec_rli(vsl, ul); 2610 // CHECK: call <2 x i64> @llvm.s390.verllg(<2 x i64> %{{.*}}, i32 %{{.*}}) 2611 // CHECK-ASM: verllg 2612 vul = vec_rli(vul, ul); 2613 // CHECK: call <2 x i64> @llvm.s390.verllg(<2 x i64> %{{.*}}, i32 %{{.*}}) 2614 // CHECK-ASM: verllg 2615 2616 vsc = vec_rl_mask(vsc, vuc, 0); 2617 // CHECK: call <16 x i8> @llvm.s390.verimb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2618 // CHECK-ASM: verimb 2619 vsc = vec_rl_mask(vsc, vuc, 255); 2620 // CHECK: call <16 x i8> @llvm.s390.verimb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255) 2621 // CHECK-ASM: verimb 2622 vuc = vec_rl_mask(vuc, vuc, 0); 2623 // CHECK: call <16 x i8> @llvm.s390.verimb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2624 // CHECK-ASM: verimb 2625 vuc = vec_rl_mask(vuc, vuc, 255); 2626 // CHECK: call <16 x i8> @llvm.s390.verimb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255) 2627 // CHECK-ASM: verimb 2628 vss = vec_rl_mask(vss, vus, 0); 2629 // CHECK: call <8 x i16> @llvm.s390.verimh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0) 2630 // CHECK-ASM: verimh 2631 vss = vec_rl_mask(vss, vus, 255); 2632 // CHECK: call <8 x i16> @llvm.s390.verimh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 255) 2633 // CHECK-ASM: verimh 2634 vus = vec_rl_mask(vus, vus, 0); 2635 // CHECK: call <8 x i16> @llvm.s390.verimh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0) 2636 // CHECK-ASM: verimh 2637 vus = vec_rl_mask(vus, vus, 255); 2638 // CHECK: call <8 x i16> @llvm.s390.verimh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 255) 2639 // CHECK-ASM: verimh 2640 vsi = vec_rl_mask(vsi, vui, 0); 2641 // CHECK: call <4 x i32> @llvm.s390.verimf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0) 2642 // CHECK-ASM: verimf 2643 vsi = vec_rl_mask(vsi, vui, 255); 2644 // CHECK: call <4 x i32> @llvm.s390.verimf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 255) 2645 // CHECK-ASM: verimf 2646 vui = vec_rl_mask(vui, vui, 0); 2647 // CHECK: call <4 x i32> @llvm.s390.verimf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0) 2648 // CHECK-ASM: verimf 2649 vui = vec_rl_mask(vui, vui, 255); 2650 // CHECK: call <4 x i32> @llvm.s390.verimf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 255) 2651 // CHECK-ASM: verimf 2652 vsl = vec_rl_mask(vsl, vul, 0); 2653 // CHECK: call <2 x i64> @llvm.s390.verimg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 0) 2654 // CHECK-ASM: verimg 2655 vsl = vec_rl_mask(vsl, vul, 255); 2656 // CHECK: call <2 x i64> @llvm.s390.verimg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 255) 2657 // CHECK-ASM: verimg 2658 vul = vec_rl_mask(vul, vul, 0); 2659 // CHECK: call <2 x i64> @llvm.s390.verimg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 0) 2660 // CHECK-ASM: verimg 2661 vul = vec_rl_mask(vul, vul, 255); 2662 // CHECK: call <2 x i64> @llvm.s390.verimg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 255) 2663 // CHECK-ASM: verimg 2664 2665 vsc = vec_sll(vsc, vuc); 2666 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2667 // CHECK-ASM: vsl 2668 vsc = vec_sll(vsc, vus); 2669 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2670 // CHECK-ASM: vsl 2671 vsc = vec_sll(vsc, vui); 2672 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2673 // CHECK-ASM: vsl 2674 vuc = vec_sll(vuc, vuc); 2675 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2676 // CHECK-ASM: vsl 2677 vuc = vec_sll(vuc, vus); 2678 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2679 // CHECK-ASM: vsl 2680 vuc = vec_sll(vuc, vui); 2681 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2682 // CHECK-ASM: vsl 2683 vbc = vec_sll(vbc, vuc); 2684 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2685 // CHECK-ASM: vsl 2686 vbc = vec_sll(vbc, vus); 2687 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2688 // CHECK-ASM: vsl 2689 vbc = vec_sll(vbc, vui); 2690 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2691 // CHECK-ASM: vsl 2692 vss = vec_sll(vss, vuc); 2693 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2694 // CHECK-ASM: vsl 2695 vss = vec_sll(vss, vus); 2696 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2697 // CHECK-ASM: vsl 2698 vss = vec_sll(vss, vui); 2699 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2700 // CHECK-ASM: vsl 2701 vus = vec_sll(vus, vuc); 2702 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2703 // CHECK-ASM: vsl 2704 vus = vec_sll(vus, vus); 2705 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2706 // CHECK-ASM: vsl 2707 vus = vec_sll(vus, vui); 2708 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2709 // CHECK-ASM: vsl 2710 vbs = vec_sll(vbs, vuc); 2711 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2712 // CHECK-ASM: vsl 2713 vbs = vec_sll(vbs, vus); 2714 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2715 // CHECK-ASM: vsl 2716 vbs = vec_sll(vbs, vui); 2717 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2718 // CHECK-ASM: vsl 2719 vsi = vec_sll(vsi, vuc); 2720 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2721 // CHECK-ASM: vsl 2722 vsi = vec_sll(vsi, vus); 2723 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2724 // CHECK-ASM: vsl 2725 vsi = vec_sll(vsi, vui); 2726 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2727 // CHECK-ASM: vsl 2728 vui = vec_sll(vui, vuc); 2729 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2730 // CHECK-ASM: vsl 2731 vui = vec_sll(vui, vus); 2732 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2733 // CHECK-ASM: vsl 2734 vui = vec_sll(vui, vui); 2735 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2736 // CHECK-ASM: vsl 2737 vbi = vec_sll(vbi, vuc); 2738 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2739 // CHECK-ASM: vsl 2740 vbi = vec_sll(vbi, vus); 2741 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2742 // CHECK-ASM: vsl 2743 vbi = vec_sll(vbi, vui); 2744 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2745 // CHECK-ASM: vsl 2746 vsl = vec_sll(vsl, vuc); 2747 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2748 // CHECK-ASM: vsl 2749 vsl = vec_sll(vsl, vus); 2750 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2751 // CHECK-ASM: vsl 2752 vsl = vec_sll(vsl, vui); 2753 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2754 // CHECK-ASM: vsl 2755 vul = vec_sll(vul, vuc); 2756 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2757 // CHECK-ASM: vsl 2758 vul = vec_sll(vul, vus); 2759 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2760 // CHECK-ASM: vsl 2761 vul = vec_sll(vul, vui); 2762 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2763 // CHECK-ASM: vsl 2764 vbl = vec_sll(vbl, vuc); 2765 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2766 // CHECK-ASM: vsl 2767 vbl = vec_sll(vbl, vus); 2768 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2769 // CHECK-ASM: vsl 2770 vbl = vec_sll(vbl, vui); 2771 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2772 // CHECK-ASM: vsl 2773 2774 vsc = vec_slb(vsc, vsc); 2775 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2776 // CHECK-ASM: vslb 2777 vsc = vec_slb(vsc, vuc); 2778 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2779 // CHECK-ASM: vslb 2780 vuc = vec_slb(vuc, vsc); 2781 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2782 // CHECK-ASM: vslb 2783 vuc = vec_slb(vuc, vuc); 2784 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2785 // CHECK-ASM: vslb 2786 vss = vec_slb(vss, vss); 2787 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2788 // CHECK-ASM: vslb 2789 vss = vec_slb(vss, vus); 2790 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2791 // CHECK-ASM: vslb 2792 vus = vec_slb(vus, vss); 2793 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2794 // CHECK-ASM: vslb 2795 vus = vec_slb(vus, vus); 2796 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2797 // CHECK-ASM: vslb 2798 vsi = vec_slb(vsi, vsi); 2799 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2800 // CHECK-ASM: vslb 2801 vsi = vec_slb(vsi, vui); 2802 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2803 // CHECK-ASM: vslb 2804 vui = vec_slb(vui, vsi); 2805 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2806 // CHECK-ASM: vslb 2807 vui = vec_slb(vui, vui); 2808 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2809 // CHECK-ASM: vslb 2810 vsl = vec_slb(vsl, vsl); 2811 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2812 // CHECK-ASM: vslb 2813 vsl = vec_slb(vsl, vul); 2814 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2815 // CHECK-ASM: vslb 2816 vul = vec_slb(vul, vsl); 2817 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2818 // CHECK-ASM: vslb 2819 vul = vec_slb(vul, vul); 2820 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2821 // CHECK-ASM: vslb 2822 vd = vec_slb(vd, vsl); 2823 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2824 // CHECK-ASM: vslb 2825 vd = vec_slb(vd, vul); 2826 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2827 // CHECK-ASM: vslb 2828 2829 vsc = vec_sld(vsc, vsc, 0); 2830 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2831 // CHECK-ASM: vsldb 2832 vsc = vec_sld(vsc, vsc, 15); 2833 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15) 2834 // CHECK-ASM: vsldb 2835 vuc = vec_sld(vuc, vuc, 0); 2836 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2837 // CHECK-ASM: vsldb 2838 vuc = vec_sld(vuc, vuc, 15); 2839 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15) 2840 // CHECK-ASM: vsldb 2841 vbc = vec_sld(vbc, vbc, 0); 2842 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2843 // CHECK-ASM: vsldb 2844 vbc = vec_sld(vbc, vbc, 15); 2845 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15) 2846 // CHECK-ASM: vsldb 2847 vss = vec_sld(vss, vss, 0); 2848 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2849 // CHECK-ASM: vsldb 2850 vss = vec_sld(vss, vss, 15); 2851 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15) 2852 // CHECK-ASM: vsldb 2853 vus = vec_sld(vus, vus, 0); 2854 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2855 // CHECK-ASM: vsldb 2856 vus = vec_sld(vus, vus, 15); 2857 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15) 2858 // CHECK-ASM: vsldb 2859 vbs = vec_sld(vbs, vbs, 0); 2860 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2861 // CHECK-ASM: vsldb 2862 vbs = vec_sld(vbs, vbs, 15); 2863 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15) 2864 // CHECK-ASM: vsldb 2865 vsi = vec_sld(vsi, vsi, 0); 2866 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2867 // CHECK-ASM: vsldb 2868 vsi = vec_sld(vsi, vsi, 15); 2869 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15) 2870 // CHECK-ASM: vsldb 2871 vui = vec_sld(vui, vui, 0); 2872 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2873 // CHECK-ASM: vsldb 2874 vui = vec_sld(vui, vui, 15); 2875 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15) 2876 // CHECK-ASM: vsldb 2877 vbi = vec_sld(vbi, vbi, 0); 2878 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2879 // CHECK-ASM: vsldb 2880 vbi = vec_sld(vbi, vbi, 15); 2881 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15) 2882 // CHECK-ASM: vsldb 2883 vsl = vec_sld(vsl, vsl, 0); 2884 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2885 // CHECK-ASM: vsldb 2886 vsl = vec_sld(vsl, vsl, 15); 2887 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15) 2888 // CHECK-ASM: vsldb 2889 vul = vec_sld(vul, vul, 0); 2890 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2891 // CHECK-ASM: vsldb 2892 vul = vec_sld(vul, vul, 15); 2893 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15) 2894 // CHECK-ASM: vsldb 2895 vbl = vec_sld(vbl, vbl, 0); 2896 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2897 // CHECK-ASM: vsldb 2898 vbl = vec_sld(vbl, vbl, 15); 2899 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15) 2900 // CHECK-ASM: vsldb 2901 vd = vec_sld(vd, vd, 0); 2902 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2903 // CHECK-ASM: vsldb 2904 vd = vec_sld(vd, vd, 15); 2905 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15) 2906 // CHECK-ASM: vsldb 2907 2908 vsc = vec_sldw(vsc, vsc, 0); 2909 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2910 // CHECK-ASM: vsldb 2911 vsc = vec_sldw(vsc, vsc, 3); 2912 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12) 2913 // CHECK-ASM: vsldb 2914 vuc = vec_sldw(vuc, vuc, 0); 2915 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2916 // CHECK-ASM: vsldb 2917 vuc = vec_sldw(vuc, vuc, 3); 2918 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12) 2919 // CHECK-ASM: vsldb 2920 vss = vec_sldw(vss, vss, 0); 2921 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2922 // CHECK-ASM: vsldb 2923 vss = vec_sldw(vss, vss, 3); 2924 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12) 2925 // CHECK-ASM: vsldb 2926 vus = vec_sldw(vus, vus, 0); 2927 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2928 // CHECK-ASM: vsldb 2929 vus = vec_sldw(vus, vus, 3); 2930 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12) 2931 // CHECK-ASM: vsldb 2932 vsi = vec_sldw(vsi, vsi, 0); 2933 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2934 // CHECK-ASM: vsldb 2935 vsi = vec_sldw(vsi, vsi, 3); 2936 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12) 2937 // CHECK-ASM: vsldb 2938 vui = vec_sldw(vui, vui, 0); 2939 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2940 // CHECK-ASM: vsldb 2941 vui = vec_sldw(vui, vui, 3); 2942 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12) 2943 // CHECK-ASM: vsldb 2944 vsl = vec_sldw(vsl, vsl, 0); 2945 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2946 // CHECK-ASM: vsldb 2947 vsl = vec_sldw(vsl, vsl, 3); 2948 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12) 2949 // CHECK-ASM: vsldb 2950 vul = vec_sldw(vul, vul, 0); 2951 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2952 // CHECK-ASM: vsldb 2953 vul = vec_sldw(vul, vul, 3); 2954 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12) 2955 // CHECK-ASM: vsldb 2956 vd = vec_sldw(vd, vd, 0); 2957 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2958 // CHECK-ASM: vsldb 2959 vd = vec_sldw(vd, vd, 3); 2960 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12) 2961 // CHECK-ASM: vsldb 2962 2963 vsc = vec_sral(vsc, vuc); 2964 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2965 // CHECK-ASM: vsra 2966 vsc = vec_sral(vsc, vus); 2967 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2968 // CHECK-ASM: vsra 2969 vsc = vec_sral(vsc, vui); 2970 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2971 // CHECK-ASM: vsra 2972 vuc = vec_sral(vuc, vuc); 2973 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2974 // CHECK-ASM: vsra 2975 vuc = vec_sral(vuc, vus); 2976 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2977 // CHECK-ASM: vsra 2978 vuc = vec_sral(vuc, vui); 2979 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2980 // CHECK-ASM: vsra 2981 vbc = vec_sral(vbc, vuc); 2982 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2983 // CHECK-ASM: vsra 2984 vbc = vec_sral(vbc, vus); 2985 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2986 // CHECK-ASM: vsra 2987 vbc = vec_sral(vbc, vui); 2988 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2989 // CHECK-ASM: vsra 2990 vss = vec_sral(vss, vuc); 2991 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2992 // CHECK-ASM: vsra 2993 vss = vec_sral(vss, vus); 2994 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2995 // CHECK-ASM: vsra 2996 vss = vec_sral(vss, vui); 2997 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2998 // CHECK-ASM: vsra 2999 vus = vec_sral(vus, vuc); 3000 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3001 // CHECK-ASM: vsra 3002 vus = vec_sral(vus, vus); 3003 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3004 // CHECK-ASM: vsra 3005 vus = vec_sral(vus, vui); 3006 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3007 // CHECK-ASM: vsra 3008 vbs = vec_sral(vbs, vuc); 3009 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3010 // CHECK-ASM: vsra 3011 vbs = vec_sral(vbs, vus); 3012 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3013 // CHECK-ASM: vsra 3014 vbs = vec_sral(vbs, vui); 3015 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3016 // CHECK-ASM: vsra 3017 vsi = vec_sral(vsi, vuc); 3018 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3019 // CHECK-ASM: vsra 3020 vsi = vec_sral(vsi, vus); 3021 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3022 // CHECK-ASM: vsra 3023 vsi = vec_sral(vsi, vui); 3024 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3025 // CHECK-ASM: vsra 3026 vui = vec_sral(vui, vuc); 3027 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3028 // CHECK-ASM: vsra 3029 vui = vec_sral(vui, vus); 3030 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3031 // CHECK-ASM: vsra 3032 vui = vec_sral(vui, vui); 3033 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3034 // CHECK-ASM: vsra 3035 vbi = vec_sral(vbi, vuc); 3036 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3037 // CHECK-ASM: vsra 3038 vbi = vec_sral(vbi, vus); 3039 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3040 // CHECK-ASM: vsra 3041 vbi = vec_sral(vbi, vui); 3042 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3043 // CHECK-ASM: vsra 3044 vsl = vec_sral(vsl, vuc); 3045 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3046 // CHECK-ASM: vsra 3047 vsl = vec_sral(vsl, vus); 3048 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3049 // CHECK-ASM: vsra 3050 vsl = vec_sral(vsl, vui); 3051 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3052 // CHECK-ASM: vsra 3053 vul = vec_sral(vul, vuc); 3054 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3055 // CHECK-ASM: vsra 3056 vul = vec_sral(vul, vus); 3057 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3058 // CHECK-ASM: vsra 3059 vul = vec_sral(vul, vui); 3060 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3061 // CHECK-ASM: vsra 3062 vbl = vec_sral(vbl, vuc); 3063 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3064 // CHECK-ASM: vsra 3065 vbl = vec_sral(vbl, vus); 3066 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3067 // CHECK-ASM: vsra 3068 vbl = vec_sral(vbl, vui); 3069 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3070 // CHECK-ASM: vsra 3071 3072 vsc = vec_srab(vsc, vsc); 3073 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3074 // CHECK-ASM: vsrab 3075 vsc = vec_srab(vsc, vuc); 3076 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3077 // CHECK-ASM: vsrab 3078 vuc = vec_srab(vuc, vsc); 3079 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3080 // CHECK-ASM: vsrab 3081 vuc = vec_srab(vuc, vuc); 3082 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3083 // CHECK-ASM: vsrab 3084 vss = vec_srab(vss, vss); 3085 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3086 // CHECK-ASM: vsrab 3087 vss = vec_srab(vss, vus); 3088 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3089 // CHECK-ASM: vsrab 3090 vus = vec_srab(vus, vss); 3091 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3092 // CHECK-ASM: vsrab 3093 vus = vec_srab(vus, vus); 3094 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3095 // CHECK-ASM: vsrab 3096 vsi = vec_srab(vsi, vsi); 3097 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3098 // CHECK-ASM: vsrab 3099 vsi = vec_srab(vsi, vui); 3100 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3101 // CHECK-ASM: vsrab 3102 vui = vec_srab(vui, vsi); 3103 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3104 // CHECK-ASM: vsrab 3105 vui = vec_srab(vui, vui); 3106 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3107 // CHECK-ASM: vsrab 3108 vsl = vec_srab(vsl, vsl); 3109 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3110 // CHECK-ASM: vsrab 3111 vsl = vec_srab(vsl, vul); 3112 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3113 // CHECK-ASM: vsrab 3114 vul = vec_srab(vul, vsl); 3115 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3116 // CHECK-ASM: vsrab 3117 vul = vec_srab(vul, vul); 3118 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3119 // CHECK-ASM: vsrab 3120 vd = vec_srab(vd, vsl); 3121 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3122 // CHECK-ASM: vsrab 3123 vd = vec_srab(vd, vul); 3124 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3125 // CHECK-ASM: vsrab 3126 3127 vsc = vec_srl(vsc, vuc); 3128 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3129 // CHECK-ASM: vsrl 3130 vsc = vec_srl(vsc, vus); 3131 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3132 // CHECK-ASM: vsrl 3133 vsc = vec_srl(vsc, vui); 3134 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3135 // CHECK-ASM: vsrl 3136 vuc = vec_srl(vuc, vuc); 3137 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3138 // CHECK-ASM: vsrl 3139 vuc = vec_srl(vuc, vus); 3140 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3141 // CHECK-ASM: vsrl 3142 vuc = vec_srl(vuc, vui); 3143 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3144 // CHECK-ASM: vsrl 3145 vbc = vec_srl(vbc, vuc); 3146 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3147 // CHECK-ASM: vsrl 3148 vbc = vec_srl(vbc, vus); 3149 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3150 // CHECK-ASM: vsrl 3151 vbc = vec_srl(vbc, vui); 3152 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3153 // CHECK-ASM: vsrl 3154 vss = vec_srl(vss, vuc); 3155 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3156 // CHECK-ASM: vsrl 3157 vss = vec_srl(vss, vus); 3158 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3159 // CHECK-ASM: vsrl 3160 vss = vec_srl(vss, vui); 3161 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3162 // CHECK-ASM: vsrl 3163 vus = vec_srl(vus, vuc); 3164 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3165 // CHECK-ASM: vsrl 3166 vus = vec_srl(vus, vus); 3167 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3168 // CHECK-ASM: vsrl 3169 vus = vec_srl(vus, vui); 3170 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3171 // CHECK-ASM: vsrl 3172 vbs = vec_srl(vbs, vuc); 3173 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3174 // CHECK-ASM: vsrl 3175 vbs = vec_srl(vbs, vus); 3176 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3177 // CHECK-ASM: vsrl 3178 vbs = vec_srl(vbs, vui); 3179 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3180 // CHECK-ASM: vsrl 3181 vsi = vec_srl(vsi, vuc); 3182 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3183 // CHECK-ASM: vsrl 3184 vsi = vec_srl(vsi, vus); 3185 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3186 // CHECK-ASM: vsrl 3187 vsi = vec_srl(vsi, vui); 3188 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3189 // CHECK-ASM: vsrl 3190 vui = vec_srl(vui, vuc); 3191 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3192 // CHECK-ASM: vsrl 3193 vui = vec_srl(vui, vus); 3194 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3195 // CHECK-ASM: vsrl 3196 vui = vec_srl(vui, vui); 3197 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3198 // CHECK-ASM: vsrl 3199 vbi = vec_srl(vbi, vuc); 3200 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3201 // CHECK-ASM: vsrl 3202 vbi = vec_srl(vbi, vus); 3203 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3204 // CHECK-ASM: vsrl 3205 vbi = vec_srl(vbi, vui); 3206 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3207 // CHECK-ASM: vsrl 3208 vsl = vec_srl(vsl, vuc); 3209 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3210 // CHECK-ASM: vsrl 3211 vsl = vec_srl(vsl, vus); 3212 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3213 // CHECK-ASM: vsrl 3214 vsl = vec_srl(vsl, vui); 3215 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3216 // CHECK-ASM: vsrl 3217 vul = vec_srl(vul, vuc); 3218 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3219 // CHECK-ASM: vsrl 3220 vul = vec_srl(vul, vus); 3221 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3222 // CHECK-ASM: vsrl 3223 vul = vec_srl(vul, vui); 3224 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3225 // CHECK-ASM: vsrl 3226 vbl = vec_srl(vbl, vuc); 3227 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3228 // CHECK-ASM: vsrl 3229 vbl = vec_srl(vbl, vus); 3230 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3231 // CHECK-ASM: vsrl 3232 vbl = vec_srl(vbl, vui); 3233 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3234 // CHECK-ASM: vsrl 3235 3236 vsc = vec_srb(vsc, vsc); 3237 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3238 // CHECK-ASM: vsrlb 3239 vsc = vec_srb(vsc, vuc); 3240 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3241 // CHECK-ASM: vsrlb 3242 vuc = vec_srb(vuc, vsc); 3243 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3244 // CHECK-ASM: vsrlb 3245 vuc = vec_srb(vuc, vuc); 3246 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3247 // CHECK-ASM: vsrlb 3248 vss = vec_srb(vss, vss); 3249 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3250 // CHECK-ASM: vsrlb 3251 vss = vec_srb(vss, vus); 3252 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3253 // CHECK-ASM: vsrlb 3254 vus = vec_srb(vus, vss); 3255 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3256 // CHECK-ASM: vsrlb 3257 vus = vec_srb(vus, vus); 3258 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3259 // CHECK-ASM: vsrlb 3260 vsi = vec_srb(vsi, vsi); 3261 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3262 // CHECK-ASM: vsrlb 3263 vsi = vec_srb(vsi, vui); 3264 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3265 // CHECK-ASM: vsrlb 3266 vui = vec_srb(vui, vsi); 3267 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3268 // CHECK-ASM: vsrlb 3269 vui = vec_srb(vui, vui); 3270 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3271 // CHECK-ASM: vsrlb 3272 vsl = vec_srb(vsl, vsl); 3273 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3274 // CHECK-ASM: vsrlb 3275 vsl = vec_srb(vsl, vul); 3276 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3277 // CHECK-ASM: vsrlb 3278 vul = vec_srb(vul, vsl); 3279 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3280 // CHECK-ASM: vsrlb 3281 vul = vec_srb(vul, vul); 3282 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3283 // CHECK-ASM: vsrlb 3284 vd = vec_srb(vd, vsl); 3285 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3286 // CHECK-ASM: vsrlb 3287 vd = vec_srb(vd, vul); 3288 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3289 // CHECK-ASM: vsrlb 3290 3291 vsc = vec_abs(vsc); 3292 // CHECK-ASM: vlpb 3293 vss = vec_abs(vss); 3294 // CHECK-ASM: vlph 3295 vsi = vec_abs(vsi); 3296 // CHECK-ASM: vlpf 3297 vsl = vec_abs(vsl); 3298 // CHECK-ASM: vlpg 3299 3300 vsc = vec_max(vsc, vsc); 3301 // CHECK-ASM: vmxb 3302 vsc = vec_max(vsc, vbc); 3303 // CHECK-ASM: vmxb 3304 vsc = vec_max(vbc, vsc); 3305 // CHECK-ASM: vmxb 3306 vuc = vec_max(vuc, vuc); 3307 // CHECK-ASM: vmxlb 3308 vuc = vec_max(vuc, vbc); 3309 // CHECK-ASM: vmxlb 3310 vuc = vec_max(vbc, vuc); 3311 // CHECK-ASM: vmxlb 3312 vss = vec_max(vss, vss); 3313 // CHECK-ASM: vmxh 3314 vss = vec_max(vss, vbs); 3315 // CHECK-ASM: vmxh 3316 vss = vec_max(vbs, vss); 3317 // CHECK-ASM: vmxh 3318 vus = vec_max(vus, vus); 3319 // CHECK-ASM: vmxlh 3320 vus = vec_max(vus, vbs); 3321 // CHECK-ASM: vmxlh 3322 vus = vec_max(vbs, vus); 3323 // CHECK-ASM: vmxlh 3324 vsi = vec_max(vsi, vsi); 3325 // CHECK-ASM: vmxf 3326 vsi = vec_max(vsi, vbi); 3327 // CHECK-ASM: vmxf 3328 vsi = vec_max(vbi, vsi); 3329 // CHECK-ASM: vmxf 3330 vui = vec_max(vui, vui); 3331 // CHECK-ASM: vmxlf 3332 vui = vec_max(vui, vbi); 3333 // CHECK-ASM: vmxlf 3334 vui = vec_max(vbi, vui); 3335 // CHECK-ASM: vmxlf 3336 vsl = vec_max(vsl, vsl); 3337 // CHECK-ASM: vmxg 3338 vsl = vec_max(vsl, vbl); 3339 // CHECK-ASM: vmxg 3340 vsl = vec_max(vbl, vsl); 3341 // CHECK-ASM: vmxg 3342 vul = vec_max(vul, vul); 3343 // CHECK-ASM: vmxlg 3344 vul = vec_max(vul, vbl); 3345 // CHECK-ASM: vmxlg 3346 vul = vec_max(vbl, vul); 3347 // CHECK-ASM: vmxlg 3348 vd = vec_max(vd, vd); 3349 // (emulated) 3350 3351 vsc = vec_min(vsc, vsc); 3352 // CHECK-ASM: vmnb 3353 vsc = vec_min(vsc, vbc); 3354 // CHECK-ASM: vmnb 3355 vsc = vec_min(vbc, vsc); 3356 // CHECK-ASM: vmnb 3357 vuc = vec_min(vuc, vuc); 3358 // CHECK-ASM: vmnlb 3359 vuc = vec_min(vuc, vbc); 3360 // CHECK-ASM: vmnlb 3361 vuc = vec_min(vbc, vuc); 3362 // CHECK-ASM: vmnlb 3363 vss = vec_min(vss, vss); 3364 // CHECK-ASM: vmnh 3365 vss = vec_min(vss, vbs); 3366 // CHECK-ASM: vmnh 3367 vss = vec_min(vbs, vss); 3368 // CHECK-ASM: vmnh 3369 vus = vec_min(vus, vus); 3370 // CHECK-ASM: vmnlh 3371 vus = vec_min(vus, vbs); 3372 // CHECK-ASM: vmnlh 3373 vus = vec_min(vbs, vus); 3374 // CHECK-ASM: vmnlh 3375 vsi = vec_min(vsi, vsi); 3376 // CHECK-ASM: vmnf 3377 vsi = vec_min(vsi, vbi); 3378 // CHECK-ASM: vmnf 3379 vsi = vec_min(vbi, vsi); 3380 // CHECK-ASM: vmnf 3381 vui = vec_min(vui, vui); 3382 // CHECK-ASM: vmnlf 3383 vui = vec_min(vui, vbi); 3384 // CHECK-ASM: vmnlf 3385 vui = vec_min(vbi, vui); 3386 // CHECK-ASM: vmnlf 3387 vsl = vec_min(vsl, vsl); 3388 // CHECK-ASM: vmng 3389 vsl = vec_min(vsl, vbl); 3390 // CHECK-ASM: vmng 3391 vsl = vec_min(vbl, vsl); 3392 // CHECK-ASM: vmng 3393 vul = vec_min(vul, vul); 3394 // CHECK-ASM: vmnlg 3395 vul = vec_min(vul, vbl); 3396 // CHECK-ASM: vmnlg 3397 vul = vec_min(vbl, vul); 3398 // CHECK-ASM: vmnlg 3399 vd = vec_min(vd, vd); 3400 // (emulated) 3401 3402 vuc = vec_addc(vuc, vuc); 3403 // CHECK: call <16 x i8> @llvm.s390.vaccb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3404 // CHECK-ASM: vaccb 3405 vus = vec_addc(vus, vus); 3406 // CHECK: call <8 x i16> @llvm.s390.vacch(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3407 // CHECK-ASM: vacch 3408 vui = vec_addc(vui, vui); 3409 // CHECK: call <4 x i32> @llvm.s390.vaccf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3410 // CHECK-ASM: vaccf 3411 vul = vec_addc(vul, vul); 3412 // CHECK: call <2 x i64> @llvm.s390.vaccg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 3413 // CHECK-ASM: vaccg 3414 3415 vuc = vec_add_u128(vuc, vuc); 3416 // CHECK: call <16 x i8> @llvm.s390.vaq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3417 // CHECK-ASM: vaq 3418 vuc = vec_addc_u128(vuc, vuc); 3419 // CHECK: call <16 x i8> @llvm.s390.vaccq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3420 // CHECK-ASM: vaccq 3421 vuc = vec_adde_u128(vuc, vuc, vuc); 3422 // CHECK: call <16 x i8> @llvm.s390.vacq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3423 // CHECK-ASM: vacq 3424 vuc = vec_addec_u128(vuc, vuc, vuc); 3425 // CHECK: call <16 x i8> @llvm.s390.vacccq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3426 // CHECK-ASM: vacccq 3427 3428 vsc = vec_avg(vsc, vsc); 3429 // CHECK: call <16 x i8> @llvm.s390.vavgb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3430 // CHECK-ASM: vavgb 3431 vuc = vec_avg(vuc, vuc); 3432 // CHECK: call <16 x i8> @llvm.s390.vavglb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3433 // CHECK-ASM: vavglb 3434 vss = vec_avg(vss, vss); 3435 // CHECK: call <8 x i16> @llvm.s390.vavgh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3436 // CHECK-ASM: vavgh 3437 vus = vec_avg(vus, vus); 3438 // CHECK: call <8 x i16> @llvm.s390.vavglh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3439 // CHECK-ASM: vavglh 3440 vsi = vec_avg(vsi, vsi); 3441 // CHECK: call <4 x i32> @llvm.s390.vavgf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3442 // CHECK-ASM: vavgf 3443 vui = vec_avg(vui, vui); 3444 // CHECK: call <4 x i32> @llvm.s390.vavglf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3445 // CHECK-ASM: vavglf 3446 vsl = vec_avg(vsl, vsl); 3447 // CHECK: call <2 x i64> @llvm.s390.vavgg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 3448 // CHECK-ASM: vavgg 3449 vul = vec_avg(vul, vul); 3450 // CHECK: call <2 x i64> @llvm.s390.vavglg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 3451 // CHECK-ASM: vavglg 3452 3453 vui = vec_checksum(vui, vui); 3454 // CHECK: call <4 x i32> @llvm.s390.vcksm(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3455 // CHECK-ASM: vcksm 3456 3457 vus = vec_gfmsum(vuc, vuc); 3458 // CHECK: call <8 x i16> @llvm.s390.vgfmb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3459 // CHECK-ASM: vgfmb 3460 vui = vec_gfmsum(vus, vus); 3461 // CHECK: call <4 x i32> @llvm.s390.vgfmh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3462 // CHECK-ASM: vgfmh 3463 vul = vec_gfmsum(vui, vui); 3464 // CHECK: call <2 x i64> @llvm.s390.vgfmf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3465 // CHECK-ASM: vgfmf 3466 vuc = vec_gfmsum_128(vul, vul); 3467 // CHECK: call <16 x i8> @llvm.s390.vgfmg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 3468 // CHECK-ASM: vgfmg 3469 3470 vus = vec_gfmsum_accum(vuc, vuc, vus); 3471 // CHECK: call <8 x i16> @llvm.s390.vgfmab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <8 x i16> %{{.*}}) 3472 // CHECK-ASM: vgfmab 3473 vui = vec_gfmsum_accum(vus, vus, vui); 3474 // CHECK: call <4 x i32> @llvm.s390.vgfmah(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <4 x i32> %{{.*}}) 3475 // CHECK-ASM: vgfmah 3476 vul = vec_gfmsum_accum(vui, vui, vul); 3477 // CHECK: call <2 x i64> @llvm.s390.vgfmaf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <2 x i64> %{{.*}}) 3478 // CHECK-ASM: vgfmaf 3479 vuc = vec_gfmsum_accum_128(vul, vul, vuc); 3480 // CHECK: call <16 x i8> @llvm.s390.vgfmag(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <16 x i8> %{{.*}}) 3481 // CHECK-ASM: vgfmag 3482 3483 vsc = vec_mladd(vsc, vsc, vsc); 3484 // CHECK-ASM: vmalb 3485 vsc = vec_mladd(vuc, vsc, vsc); 3486 // CHECK-ASM: vmalb 3487 vsc = vec_mladd(vsc, vuc, vuc); 3488 // CHECK-ASM: vmalb 3489 vuc = vec_mladd(vuc, vuc, vuc); 3490 // CHECK-ASM: vmalb 3491 vss = vec_mladd(vss, vss, vss); 3492 // CHECK-ASM: vmalhw 3493 vss = vec_mladd(vus, vss, vss); 3494 // CHECK-ASM: vmalhw 3495 vss = vec_mladd(vss, vus, vus); 3496 // CHECK-ASM: vmalhw 3497 vus = vec_mladd(vus, vus, vus); 3498 // CHECK-ASM: vmalhw 3499 vsi = vec_mladd(vsi, vsi, vsi); 3500 // CHECK-ASM: vmalf 3501 vsi = vec_mladd(vui, vsi, vsi); 3502 // CHECK-ASM: vmalf 3503 vsi = vec_mladd(vsi, vui, vui); 3504 // CHECK-ASM: vmalf 3505 vui = vec_mladd(vui, vui, vui); 3506 // CHECK-ASM: vmalf 3507 3508 vsc = vec_mhadd(vsc, vsc, vsc); 3509 // CHECK: call <16 x i8> @llvm.s390.vmahb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3510 // CHECK-ASM: vmahb 3511 vuc = vec_mhadd(vuc, vuc, vuc); 3512 // CHECK: call <16 x i8> @llvm.s390.vmalhb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3513 // CHECK-ASM: vmalhb 3514 vss = vec_mhadd(vss, vss, vss); 3515 // CHECK: call <8 x i16> @llvm.s390.vmahh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3516 // CHECK-ASM: vmahh 3517 vus = vec_mhadd(vus, vus, vus); 3518 // CHECK: call <8 x i16> @llvm.s390.vmalhh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3519 // CHECK-ASM: vmalhh 3520 vsi = vec_mhadd(vsi, vsi, vsi); 3521 // CHECK: call <4 x i32> @llvm.s390.vmahf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3522 // CHECK-ASM: vmahf 3523 vui = vec_mhadd(vui, vui, vui); 3524 // CHECK: call <4 x i32> @llvm.s390.vmalhf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3525 // CHECK-ASM: vmalhf 3526 3527 vss = vec_meadd(vsc, vsc, vss); 3528 // CHECK: call <8 x i16> @llvm.s390.vmaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <8 x i16> %{{.*}}) 3529 // CHECK-ASM: vmaeb 3530 vus = vec_meadd(vuc, vuc, vus); 3531 // CHECK: call <8 x i16> @llvm.s390.vmaleb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <8 x i16> %{{.*}}) 3532 // CHECK-ASM: vmaleb 3533 vsi = vec_meadd(vss, vss, vsi); 3534 // CHECK: call <4 x i32> @llvm.s390.vmaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <4 x i32> %{{.*}}) 3535 // CHECK-ASM: vmaeh 3536 vui = vec_meadd(vus, vus, vui); 3537 // CHECK: call <4 x i32> @llvm.s390.vmaleh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <4 x i32> %{{.*}}) 3538 // CHECK-ASM: vmaleh 3539 vsl = vec_meadd(vsi, vsi, vsl); 3540 // CHECK: call <2 x i64> @llvm.s390.vmaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <2 x i64> %{{.*}}) 3541 // CHECK-ASM: vmaef 3542 vul = vec_meadd(vui, vui, vul); 3543 // CHECK: call <2 x i64> @llvm.s390.vmalef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <2 x i64> %{{.*}}) 3544 // CHECK-ASM: vmalef 3545 3546 vss = vec_moadd(vsc, vsc, vss); 3547 // CHECK: call <8 x i16> @llvm.s390.vmaob(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <8 x i16> %{{.*}}) 3548 // CHECK-ASM: vmaob 3549 vus = vec_moadd(vuc, vuc, vus); 3550 // CHECK: call <8 x i16> @llvm.s390.vmalob(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <8 x i16> %{{.*}}) 3551 // CHECK-ASM: vmalob 3552 vsi = vec_moadd(vss, vss, vsi); 3553 // CHECK: call <4 x i32> @llvm.s390.vmaoh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <4 x i32> %{{.*}}) 3554 // CHECK-ASM: vmaoh 3555 vui = vec_moadd(vus, vus, vui); 3556 // CHECK: call <4 x i32> @llvm.s390.vmaloh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <4 x i32> %{{.*}}) 3557 // CHECK-ASM: vmaloh 3558 vsl = vec_moadd(vsi, vsi, vsl); 3559 // CHECK: call <2 x i64> @llvm.s390.vmaof(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <2 x i64> %{{.*}}) 3560 // CHECK-ASM: vmaof 3561 vul = vec_moadd(vui, vui, vul); 3562 // CHECK: call <2 x i64> @llvm.s390.vmalof(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <2 x i64> %{{.*}}) 3563 // CHECK-ASM: vmalof 3564 3565 vsc = vec_mulh(vsc, vsc); 3566 // CHECK: call <16 x i8> @llvm.s390.vmhb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3567 // CHECK-ASM: vmhb 3568 vuc = vec_mulh(vuc, vuc); 3569 // CHECK: call <16 x i8> @llvm.s390.vmlhb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3570 // CHECK-ASM: vmlhb 3571 vss = vec_mulh(vss, vss); 3572 // CHECK: call <8 x i16> @llvm.s390.vmhh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3573 // CHECK-ASM: vmhh 3574 vus = vec_mulh(vus, vus); 3575 // CHECK: call <8 x i16> @llvm.s390.vmlhh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3576 // CHECK-ASM: vmlhh 3577 vsi = vec_mulh(vsi, vsi); 3578 // CHECK: call <4 x i32> @llvm.s390.vmhf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3579 // CHECK-ASM: vmhf 3580 vui = vec_mulh(vui, vui); 3581 // CHECK: call <4 x i32> @llvm.s390.vmlhf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3582 // CHECK-ASM: vmlhf 3583 3584 vss = vec_mule(vsc, vsc); 3585 // CHECK: call <8 x i16> @llvm.s390.vmeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3586 // CHECK-ASM: vmeb 3587 vus = vec_mule(vuc, vuc); 3588 // CHECK: call <8 x i16> @llvm.s390.vmleb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3589 // CHECK-ASM: vmleb 3590 vsi = vec_mule(vss, vss); 3591 // CHECK: call <4 x i32> @llvm.s390.vmeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3592 // CHECK-ASM: vmeh 3593 vui = vec_mule(vus, vus); 3594 // CHECK: call <4 x i32> @llvm.s390.vmleh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3595 // CHECK-ASM: vmleh 3596 vsl = vec_mule(vsi, vsi); 3597 // CHECK: call <2 x i64> @llvm.s390.vmef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3598 // CHECK-ASM: vmef 3599 vul = vec_mule(vui, vui); 3600 // CHECK: call <2 x i64> @llvm.s390.vmlef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3601 // CHECK-ASM: vmlef 3602 3603 vss = vec_mulo(vsc, vsc); 3604 // CHECK: call <8 x i16> @llvm.s390.vmob(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3605 // CHECK-ASM: vmob 3606 vus = vec_mulo(vuc, vuc); 3607 // CHECK: call <8 x i16> @llvm.s390.vmlob(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3608 // CHECK-ASM: vmlob 3609 vsi = vec_mulo(vss, vss); 3610 // CHECK: call <4 x i32> @llvm.s390.vmoh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3611 // CHECK-ASM: vmoh 3612 vui = vec_mulo(vus, vus); 3613 // CHECK: call <4 x i32> @llvm.s390.vmloh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3614 // CHECK-ASM: vmloh 3615 vsl = vec_mulo(vsi, vsi); 3616 // CHECK: call <2 x i64> @llvm.s390.vmof(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3617 // CHECK-ASM: vmof 3618 vul = vec_mulo(vui, vui); 3619 // CHECK: call <2 x i64> @llvm.s390.vmlof(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3620 // CHECK-ASM: vmlof 3621 3622 vuc = vec_subc(vuc, vuc); 3623 // CHECK: call <16 x i8> @llvm.s390.vscbib(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3624 // CHECK-ASM: vscbib 3625 vus = vec_subc(vus, vus); 3626 // CHECK: call <8 x i16> @llvm.s390.vscbih(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3627 // CHECK-ASM: vscbih 3628 vui = vec_subc(vui, vui); 3629 // CHECK: call <4 x i32> @llvm.s390.vscbif(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3630 // CHECK-ASM: vscbif 3631 vul = vec_subc(vul, vul); 3632 // CHECK: call <2 x i64> @llvm.s390.vscbig(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 3633 // CHECK-ASM: vscbig 3634 3635 vuc = vec_sub_u128(vuc, vuc); 3636 // CHECK: call <16 x i8> @llvm.s390.vsq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3637 // CHECK-ASM: vsq 3638 vuc = vec_subc_u128(vuc, vuc); 3639 // CHECK: call <16 x i8> @llvm.s390.vscbiq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3640 // CHECK-ASM: vscbiq 3641 vuc = vec_sube_u128(vuc, vuc, vuc); 3642 // CHECK: call <16 x i8> @llvm.s390.vsbiq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3643 // CHECK-ASM: vsbiq 3644 vuc = vec_subec_u128(vuc, vuc, vuc); 3645 // CHECK: call <16 x i8> @llvm.s390.vsbcbiq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3646 // CHECK-ASM: vsbcbiq 3647 3648 vui = vec_sum4(vuc, vuc); 3649 // CHECK: call <4 x i32> @llvm.s390.vsumb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3650 // CHECK-ASM: vsumb 3651 vui = vec_sum4(vus, vus); 3652 // CHECK: call <4 x i32> @llvm.s390.vsumh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3653 // CHECK-ASM: vsumh 3654 vul = vec_sum2(vus, vus); 3655 // CHECK: call <2 x i64> @llvm.s390.vsumgh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3656 // CHECK-ASM: vsumgh 3657 vul = vec_sum2(vui, vui); 3658 // CHECK: call <2 x i64> @llvm.s390.vsumgf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3659 // CHECK-ASM: vsumgf 3660 vuc = vec_sum_u128(vui, vui); 3661 // CHECK: call <16 x i8> @llvm.s390.vsumqf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3662 // CHECK-ASM: vsumqf 3663 vuc = vec_sum_u128(vul, vul); 3664 // CHECK: call <16 x i8> @llvm.s390.vsumqg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 3665 // CHECK-ASM: vsumqg 3666 3667 idx = vec_test_mask(vsc, vuc); 3668 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3669 // CHECK-ASM: vtm 3670 idx = vec_test_mask(vuc, vuc); 3671 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3672 // CHECK-ASM: vtm 3673 idx = vec_test_mask(vss, vus); 3674 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3675 // CHECK-ASM: vtm 3676 idx = vec_test_mask(vus, vus); 3677 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3678 // CHECK-ASM: vtm 3679 idx = vec_test_mask(vsi, vui); 3680 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3681 // CHECK-ASM: vtm 3682 idx = vec_test_mask(vui, vui); 3683 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3684 // CHECK-ASM: vtm 3685 idx = vec_test_mask(vsl, vul); 3686 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3687 // CHECK-ASM: vtm 3688 idx = vec_test_mask(vul, vul); 3689 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3690 // CHECK-ASM: vtm 3691 idx = vec_test_mask(vd, vul); 3692 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3693 // CHECK-ASM: vtm 3694 } 3695 3696 void test_string(void) { 3697 // CHECK-ASM-LABEL: test_string 3698 3699 vsc = vec_cp_until_zero(vsc); 3700 // CHECK: call <16 x i8> @llvm.s390.vistrb(<16 x i8> %{{.*}}) 3701 // CHECK-ASM: vistrb 3702 vuc = vec_cp_until_zero(vuc); 3703 // CHECK: call <16 x i8> @llvm.s390.vistrb(<16 x i8> %{{.*}}) 3704 // CHECK-ASM: vistrb 3705 vbc = vec_cp_until_zero(vbc); 3706 // CHECK: call <16 x i8> @llvm.s390.vistrb(<16 x i8> %{{.*}}) 3707 // CHECK-ASM: vistrb 3708 vss = vec_cp_until_zero(vss); 3709 // CHECK: call <8 x i16> @llvm.s390.vistrh(<8 x i16> %{{.*}}) 3710 // CHECK-ASM: vistrh 3711 vus = vec_cp_until_zero(vus); 3712 // CHECK: call <8 x i16> @llvm.s390.vistrh(<8 x i16> %{{.*}}) 3713 // CHECK-ASM: vistrh 3714 vbs = vec_cp_until_zero(vbs); 3715 // CHECK: call <8 x i16> @llvm.s390.vistrh(<8 x i16> %{{.*}}) 3716 // CHECK-ASM: vistrh 3717 vsi = vec_cp_until_zero(vsi); 3718 // CHECK: call <4 x i32> @llvm.s390.vistrf(<4 x i32> %{{.*}}) 3719 // CHECK-ASM: vistrf 3720 vui = vec_cp_until_zero(vui); 3721 // CHECK: call <4 x i32> @llvm.s390.vistrf(<4 x i32> %{{.*}}) 3722 // CHECK-ASM: vistrf 3723 vbi = vec_cp_until_zero(vbi); 3724 // CHECK: call <4 x i32> @llvm.s390.vistrf(<4 x i32> %{{.*}}) 3725 // CHECK-ASM: vistrf 3726 3727 vsc = vec_cp_until_zero_cc(vsc, &cc); 3728 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vistrbs(<16 x i8> %{{.*}}) 3729 // CHECK-ASM: vistrbs 3730 vuc = vec_cp_until_zero_cc(vuc, &cc); 3731 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vistrbs(<16 x i8> %{{.*}}) 3732 // CHECK-ASM: vistrbs 3733 vbc = vec_cp_until_zero_cc(vbc, &cc); 3734 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vistrbs(<16 x i8> %{{.*}}) 3735 // CHECK-ASM: vistrbs 3736 vss = vec_cp_until_zero_cc(vss, &cc); 3737 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vistrhs(<8 x i16> %{{.*}}) 3738 // CHECK-ASM: vistrhs 3739 vus = vec_cp_until_zero_cc(vus, &cc); 3740 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vistrhs(<8 x i16> %{{.*}}) 3741 // CHECK-ASM: vistrhs 3742 vbs = vec_cp_until_zero_cc(vbs, &cc); 3743 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vistrhs(<8 x i16> %{{.*}}) 3744 // CHECK-ASM: vistrhs 3745 vsi = vec_cp_until_zero_cc(vsi, &cc); 3746 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vistrfs(<4 x i32> %{{.*}}) 3747 // CHECK-ASM: vistrfs 3748 vui = vec_cp_until_zero_cc(vui, &cc); 3749 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vistrfs(<4 x i32> %{{.*}}) 3750 // CHECK-ASM: vistrfs 3751 vbi = vec_cp_until_zero_cc(vbi, &cc); 3752 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vistrfs(<4 x i32> %{{.*}}) 3753 // CHECK-ASM: vistrfs 3754 3755 vsc = vec_cmpeq_idx(vsc, vsc); 3756 // CHECK: call <16 x i8> @llvm.s390.vfeeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3757 // CHECK-ASM: vfeeb 3758 vuc = vec_cmpeq_idx(vuc, vuc); 3759 // CHECK: call <16 x i8> @llvm.s390.vfeeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3760 // CHECK-ASM: vfeeb 3761 vuc = vec_cmpeq_idx(vbc, vbc); 3762 // CHECK: call <16 x i8> @llvm.s390.vfeeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3763 // CHECK-ASM: vfeeb 3764 vss = vec_cmpeq_idx(vss, vss); 3765 // CHECK: call <8 x i16> @llvm.s390.vfeeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3766 // CHECK-ASM: vfeeh 3767 vus = vec_cmpeq_idx(vus, vus); 3768 // CHECK: call <8 x i16> @llvm.s390.vfeeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3769 // CHECK-ASM: vfeeh 3770 vus = vec_cmpeq_idx(vbs, vbs); 3771 // CHECK: call <8 x i16> @llvm.s390.vfeeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3772 // CHECK-ASM: vfeeh 3773 vsi = vec_cmpeq_idx(vsi, vsi); 3774 // CHECK: call <4 x i32> @llvm.s390.vfeef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3775 // CHECK-ASM: vfeef 3776 vui = vec_cmpeq_idx(vui, vui); 3777 // CHECK: call <4 x i32> @llvm.s390.vfeef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3778 // CHECK-ASM: vfeef 3779 vui = vec_cmpeq_idx(vbi, vbi); 3780 // CHECK: call <4 x i32> @llvm.s390.vfeef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3781 // CHECK-ASM: vfeef 3782 3783 vsc = vec_cmpeq_idx_cc(vsc, vsc, &cc); 3784 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfeebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3785 // CHECK-ASM: vfeebs 3786 vuc = vec_cmpeq_idx_cc(vuc, vuc, &cc); 3787 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfeebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3788 // CHECK-ASM: vfeebs 3789 vuc = vec_cmpeq_idx_cc(vbc, vbc, &cc); 3790 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfeebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3791 // CHECK-ASM: vfeebs 3792 vss = vec_cmpeq_idx_cc(vss, vss, &cc); 3793 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfeehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3794 // CHECK-ASM: vfeehs 3795 vus = vec_cmpeq_idx_cc(vus, vus, &cc); 3796 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfeehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3797 // CHECK-ASM: vfeehs 3798 vus = vec_cmpeq_idx_cc(vbs, vbs, &cc); 3799 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfeehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3800 // CHECK-ASM: vfeehs 3801 vsi = vec_cmpeq_idx_cc(vsi, vsi, &cc); 3802 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfeefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3803 // CHECK-ASM: vfeefs 3804 vui = vec_cmpeq_idx_cc(vui, vui, &cc); 3805 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfeefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3806 // CHECK-ASM: vfeefs 3807 vui = vec_cmpeq_idx_cc(vbi, vbi, &cc); 3808 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfeefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3809 // CHECK-ASM: vfeefs 3810 3811 vsc = vec_cmpeq_or_0_idx(vsc, vsc); 3812 // CHECK: call <16 x i8> @llvm.s390.vfeezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3813 // CHECK-ASM: vfeezb 3814 vuc = vec_cmpeq_or_0_idx(vuc, vuc); 3815 // CHECK: call <16 x i8> @llvm.s390.vfeezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3816 // CHECK-ASM: vfeezb 3817 vuc = vec_cmpeq_or_0_idx(vbc, vbc); 3818 // CHECK: call <16 x i8> @llvm.s390.vfeezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3819 // CHECK-ASM: vfeezb 3820 vss = vec_cmpeq_or_0_idx(vss, vss); 3821 // CHECK: call <8 x i16> @llvm.s390.vfeezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3822 // CHECK-ASM: vfeezh 3823 vus = vec_cmpeq_or_0_idx(vus, vus); 3824 // CHECK: call <8 x i16> @llvm.s390.vfeezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3825 // CHECK-ASM: vfeezh 3826 vus = vec_cmpeq_or_0_idx(vbs, vbs); 3827 // CHECK: call <8 x i16> @llvm.s390.vfeezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3828 // CHECK-ASM: vfeezh 3829 vsi = vec_cmpeq_or_0_idx(vsi, vsi); 3830 // CHECK: call <4 x i32> @llvm.s390.vfeezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3831 // CHECK-ASM: vfeezf 3832 vui = vec_cmpeq_or_0_idx(vui, vui); 3833 // CHECK: call <4 x i32> @llvm.s390.vfeezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3834 // CHECK-ASM: vfeezf 3835 vui = vec_cmpeq_or_0_idx(vbi, vbi); 3836 // CHECK: call <4 x i32> @llvm.s390.vfeezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3837 // CHECK-ASM: vfeezf 3838 3839 vsc = vec_cmpeq_or_0_idx_cc(vsc, vsc, &cc); 3840 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfeezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3841 // CHECK-ASM: vfeezbs 3842 vuc = vec_cmpeq_or_0_idx_cc(vuc, vuc, &cc); 3843 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfeezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3844 // CHECK-ASM: vfeezbs 3845 vuc = vec_cmpeq_or_0_idx_cc(vbc, vbc, &cc); 3846 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfeezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3847 // CHECK-ASM: vfeezbs 3848 vss = vec_cmpeq_or_0_idx_cc(vss, vss, &cc); 3849 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfeezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3850 // CHECK-ASM: vfeezhs 3851 vus = vec_cmpeq_or_0_idx_cc(vus, vus, &cc); 3852 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfeezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3853 // CHECK-ASM: vfeezhs 3854 vus = vec_cmpeq_or_0_idx_cc(vbs, vbs, &cc); 3855 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfeezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3856 // CHECK-ASM: vfeezhs 3857 vsi = vec_cmpeq_or_0_idx_cc(vsi, vsi, &cc); 3858 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfeezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3859 // CHECK-ASM: vfeezfs 3860 vui = vec_cmpeq_or_0_idx_cc(vui, vui, &cc); 3861 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfeezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3862 // CHECK-ASM: vfeezfs 3863 vui = vec_cmpeq_or_0_idx_cc(vbi, vbi, &cc); 3864 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfeezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3865 // CHECK-ASM: vfeezfs 3866 3867 vsc = vec_cmpne_idx(vsc, vsc); 3868 // CHECK: call <16 x i8> @llvm.s390.vfeneb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3869 // CHECK-ASM: vfeneb 3870 vuc = vec_cmpne_idx(vuc, vuc); 3871 // CHECK: call <16 x i8> @llvm.s390.vfeneb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3872 // CHECK-ASM: vfeneb 3873 vuc = vec_cmpne_idx(vbc, vbc); 3874 // CHECK: call <16 x i8> @llvm.s390.vfeneb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3875 // CHECK-ASM: vfeneb 3876 vss = vec_cmpne_idx(vss, vss); 3877 // CHECK: call <8 x i16> @llvm.s390.vfeneh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3878 // CHECK-ASM: vfeneh 3879 vus = vec_cmpne_idx(vus, vus); 3880 // CHECK: call <8 x i16> @llvm.s390.vfeneh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3881 // CHECK-ASM: vfeneh 3882 vus = vec_cmpne_idx(vbs, vbs); 3883 // CHECK: call <8 x i16> @llvm.s390.vfeneh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3884 // CHECK-ASM: vfeneh 3885 vsi = vec_cmpne_idx(vsi, vsi); 3886 // CHECK: call <4 x i32> @llvm.s390.vfenef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3887 // CHECK-ASM: vfenef 3888 vui = vec_cmpne_idx(vui, vui); 3889 // CHECK: call <4 x i32> @llvm.s390.vfenef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3890 // CHECK-ASM: vfenef 3891 vui = vec_cmpne_idx(vbi, vbi); 3892 // CHECK: call <4 x i32> @llvm.s390.vfenef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3893 // CHECK-ASM: vfenef 3894 3895 vsc = vec_cmpne_idx_cc(vsc, vsc, &cc); 3896 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfenebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3897 // CHECK-ASM: vfenebs 3898 vuc = vec_cmpne_idx_cc(vuc, vuc, &cc); 3899 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfenebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3900 // CHECK-ASM: vfenebs 3901 vuc = vec_cmpne_idx_cc(vbc, vbc, &cc); 3902 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfenebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3903 // CHECK-ASM: vfenebs 3904 vss = vec_cmpne_idx_cc(vss, vss, &cc); 3905 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfenehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3906 // CHECK-ASM: vfenehs 3907 vus = vec_cmpne_idx_cc(vus, vus, &cc); 3908 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfenehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3909 // CHECK-ASM: vfenehs 3910 vus = vec_cmpne_idx_cc(vbs, vbs, &cc); 3911 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfenehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3912 // CHECK-ASM: vfenehs 3913 vsi = vec_cmpne_idx_cc(vsi, vsi, &cc); 3914 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfenefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3915 // CHECK-ASM: vfenefs 3916 vui = vec_cmpne_idx_cc(vui, vui, &cc); 3917 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfenefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3918 // CHECK-ASM: vfenefs 3919 vui = vec_cmpne_idx_cc(vbi, vbi, &cc); 3920 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfenefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3921 // CHECK-ASM: vfenefs 3922 3923 vsc = vec_cmpne_or_0_idx(vsc, vsc); 3924 // CHECK: call <16 x i8> @llvm.s390.vfenezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3925 // CHECK-ASM: vfenezb 3926 vuc = vec_cmpne_or_0_idx(vuc, vuc); 3927 // CHECK: call <16 x i8> @llvm.s390.vfenezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3928 // CHECK-ASM: vfenezb 3929 vuc = vec_cmpne_or_0_idx(vbc, vbc); 3930 // CHECK: call <16 x i8> @llvm.s390.vfenezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3931 // CHECK-ASM: vfenezb 3932 vss = vec_cmpne_or_0_idx(vss, vss); 3933 // CHECK: call <8 x i16> @llvm.s390.vfenezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3934 // CHECK-ASM: vfenezh 3935 vus = vec_cmpne_or_0_idx(vus, vus); 3936 // CHECK: call <8 x i16> @llvm.s390.vfenezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3937 // CHECK-ASM: vfenezh 3938 vus = vec_cmpne_or_0_idx(vbs, vbs); 3939 // CHECK: call <8 x i16> @llvm.s390.vfenezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3940 // CHECK-ASM: vfenezh 3941 vsi = vec_cmpne_or_0_idx(vsi, vsi); 3942 // CHECK: call <4 x i32> @llvm.s390.vfenezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3943 // CHECK-ASM: vfenezf 3944 vui = vec_cmpne_or_0_idx(vui, vui); 3945 // CHECK: call <4 x i32> @llvm.s390.vfenezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3946 // CHECK-ASM: vfenezf 3947 vui = vec_cmpne_or_0_idx(vbi, vbi); 3948 // CHECK: call <4 x i32> @llvm.s390.vfenezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3949 // CHECK-ASM: vfenezf 3950 3951 vsc = vec_cmpne_or_0_idx_cc(vsc, vsc, &cc); 3952 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfenezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3953 // CHECK-ASM: vfenezbs 3954 vuc = vec_cmpne_or_0_idx_cc(vuc, vuc, &cc); 3955 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfenezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3956 // CHECK-ASM: vfenezbs 3957 vuc = vec_cmpne_or_0_idx_cc(vbc, vbc, &cc); 3958 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfenezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 3959 // CHECK-ASM: vfenezbs 3960 vss = vec_cmpne_or_0_idx_cc(vss, vss, &cc); 3961 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfenezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3962 // CHECK-ASM: vfenezhs 3963 vus = vec_cmpne_or_0_idx_cc(vus, vus, &cc); 3964 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfenezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3965 // CHECK-ASM: vfenezhs 3966 vus = vec_cmpne_or_0_idx_cc(vbs, vbs, &cc); 3967 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfenezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 3968 // CHECK-ASM: vfenezhs 3969 vsi = vec_cmpne_or_0_idx_cc(vsi, vsi, &cc); 3970 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfenezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3971 // CHECK-ASM: vfenezfs 3972 vui = vec_cmpne_or_0_idx_cc(vui, vui, &cc); 3973 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfenezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3974 // CHECK-ASM: vfenezfs 3975 vui = vec_cmpne_or_0_idx_cc(vbi, vbi, &cc); 3976 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfenezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 3977 // CHECK-ASM: vfenezfs 3978 3979 vbc = vec_cmprg(vuc, vuc, vuc); 3980 // CHECK: call <16 x i8> @llvm.s390.vstrcb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4) 3981 // CHECK-ASM: vstrcb 3982 vbs = vec_cmprg(vus, vus, vus); 3983 // CHECK: call <8 x i16> @llvm.s390.vstrch(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4) 3984 // CHECK-ASM: vstrch 3985 vbi = vec_cmprg(vui, vui, vui); 3986 // CHECK: call <4 x i32> @llvm.s390.vstrcf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4) 3987 // CHECK-ASM: vstrcf 3988 3989 vbc = vec_cmprg_cc(vuc, vuc, vuc, &cc); 3990 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrcbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4) 3991 // CHECK-ASM: vstrcbs 3992 vbs = vec_cmprg_cc(vus, vus, vus, &cc); 3993 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vstrchs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4) 3994 // CHECK-ASM: vstrchs 3995 vbi = vec_cmprg_cc(vui, vui, vui, &cc); 3996 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vstrcfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4) 3997 // CHECK-ASM: vstrcfs 3998 3999 vuc = vec_cmprg_idx(vuc, vuc, vuc); 4000 // CHECK: call <16 x i8> @llvm.s390.vstrcb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 4001 // CHECK-ASM: vstrcb 4002 vus = vec_cmprg_idx(vus, vus, vus); 4003 // CHECK: call <8 x i16> @llvm.s390.vstrch(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0) 4004 // CHECK-ASM: vstrch 4005 vui = vec_cmprg_idx(vui, vui, vui); 4006 // CHECK: call <4 x i32> @llvm.s390.vstrcf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0) 4007 // CHECK-ASM: vstrcf 4008 4009 vuc = vec_cmprg_idx_cc(vuc, vuc, vuc, &cc); 4010 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrcbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 4011 // CHECK-ASM: vstrcbs 4012 vus = vec_cmprg_idx_cc(vus, vus, vus, &cc); 4013 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vstrchs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0) 4014 // CHECK-ASM: vstrchs 4015 vui = vec_cmprg_idx_cc(vui, vui, vui, &cc); 4016 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vstrcfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0) 4017 // CHECK-ASM: vstrcfs 4018 4019 vuc = vec_cmprg_or_0_idx(vuc, vuc, vuc); 4020 // CHECK: call <16 x i8> @llvm.s390.vstrczb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 4021 // CHECK-ASM: vstrczb 4022 vus = vec_cmprg_or_0_idx(vus, vus, vus); 4023 // CHECK: call <8 x i16> @llvm.s390.vstrczh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0) 4024 // CHECK-ASM: vstrczh 4025 vui = vec_cmprg_or_0_idx(vui, vui, vui); 4026 // CHECK: call <4 x i32> @llvm.s390.vstrczf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0) 4027 // CHECK-ASM: vstrczf 4028 4029 vuc = vec_cmprg_or_0_idx_cc(vuc, vuc, vuc, &cc); 4030 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrczbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 4031 // CHECK-ASM: vstrczbs 4032 vus = vec_cmprg_or_0_idx_cc(vus, vus, vus, &cc); 4033 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vstrczhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0) 4034 // CHECK-ASM: vstrczhs 4035 vui = vec_cmprg_or_0_idx_cc(vui, vui, vui, &cc); 4036 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vstrczfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0) 4037 // CHECK-ASM: vstrczfs 4038 4039 vbc = vec_cmpnrg(vuc, vuc, vuc); 4040 // CHECK: call <16 x i8> @llvm.s390.vstrcb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12) 4041 // CHECK-ASM: vstrcb 4042 vbs = vec_cmpnrg(vus, vus, vus); 4043 // CHECK: call <8 x i16> @llvm.s390.vstrch(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12) 4044 // CHECK-ASM: vstrch 4045 vbi = vec_cmpnrg(vui, vui, vui); 4046 // CHECK: call <4 x i32> @llvm.s390.vstrcf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12) 4047 // CHECK-ASM: vstrcf 4048 4049 vbc = vec_cmpnrg_cc(vuc, vuc, vuc, &cc); 4050 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrcbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12) 4051 // CHECK-ASM: vstrcbs 4052 vbs = vec_cmpnrg_cc(vus, vus, vus, &cc); 4053 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vstrchs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12) 4054 // CHECK-ASM: vstrchs 4055 vbi = vec_cmpnrg_cc(vui, vui, vui, &cc); 4056 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vstrcfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12) 4057 // CHECK-ASM: vstrcfs 4058 4059 vuc = vec_cmpnrg_idx(vuc, vuc, vuc); 4060 // CHECK: call <16 x i8> @llvm.s390.vstrcb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8) 4061 // CHECK-ASM: vstrcb 4062 vus = vec_cmpnrg_idx(vus, vus, vus); 4063 // CHECK: call <8 x i16> @llvm.s390.vstrch(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8) 4064 // CHECK-ASM: vstrch 4065 vui = vec_cmpnrg_idx(vui, vui, vui); 4066 // CHECK: call <4 x i32> @llvm.s390.vstrcf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8) 4067 // CHECK-ASM: vstrcf 4068 4069 vuc = vec_cmpnrg_idx_cc(vuc, vuc, vuc, &cc); 4070 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrcbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8) 4071 // CHECK-ASM: vstrcbs 4072 vus = vec_cmpnrg_idx_cc(vus, vus, vus, &cc); 4073 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vstrchs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8) 4074 // CHECK-ASM: vstrchs 4075 vui = vec_cmpnrg_idx_cc(vui, vui, vui, &cc); 4076 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vstrcfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8) 4077 // CHECK-ASM: vstrcfs 4078 4079 vuc = vec_cmpnrg_or_0_idx(vuc, vuc, vuc); 4080 // CHECK: call <16 x i8> @llvm.s390.vstrczb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8) 4081 // CHECK-ASM: vstrczb 4082 vus = vec_cmpnrg_or_0_idx(vus, vus, vus); 4083 // CHECK: call <8 x i16> @llvm.s390.vstrczh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8) 4084 // CHECK-ASM: vstrczh 4085 vui = vec_cmpnrg_or_0_idx(vui, vui, vui); 4086 // CHECK: call <4 x i32> @llvm.s390.vstrczf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8) 4087 // CHECK-ASM: vstrczf 4088 4089 vuc = vec_cmpnrg_or_0_idx_cc(vuc, vuc, vuc, &cc); 4090 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrczbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8) 4091 // CHECK-ASM: vstrczbs 4092 vus = vec_cmpnrg_or_0_idx_cc(vus, vus, vus, &cc); 4093 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vstrczhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8) 4094 // CHECK-ASM: vstrczhs 4095 vui = vec_cmpnrg_or_0_idx_cc(vui, vui, vui, &cc); 4096 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vstrczfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8) 4097 // CHECK-ASM: vstrczfs 4098 4099 vbc = vec_find_any_eq(vsc, vsc); 4100 // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4) 4101 // CHECK-ASM: vfaeb 4102 vbc = vec_find_any_eq(vuc, vuc); 4103 // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4) 4104 // CHECK-ASM: vfaeb 4105 vbc = vec_find_any_eq(vbc, vbc); 4106 // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4) 4107 // CHECK-ASM: vfaeb 4108 vbs = vec_find_any_eq(vss, vss); 4109 // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4) 4110 // CHECK-ASM: vfaeh 4111 vbs = vec_find_any_eq(vus, vus); 4112 // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4) 4113 // CHECK-ASM: vfaeh 4114 vbs = vec_find_any_eq(vbs, vbs); 4115 // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4) 4116 // CHECK-ASM: vfaeh 4117 vbi = vec_find_any_eq(vsi, vsi); 4118 // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4) 4119 // CHECK-ASM: vfaef 4120 vbi = vec_find_any_eq(vui, vui); 4121 // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4) 4122 // CHECK-ASM: vfaef 4123 vbi = vec_find_any_eq(vbi, vbi); 4124 // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4) 4125 // CHECK-ASM: vfaef 4126 4127 vbc = vec_find_any_eq_cc(vsc, vsc, &cc); 4128 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4) 4129 // CHECK-ASM: vfaebs 4130 vbc = vec_find_any_eq_cc(vuc, vuc, &cc); 4131 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4) 4132 // CHECK-ASM: vfaebs 4133 vbc = vec_find_any_eq_cc(vbc, vbc, &cc); 4134 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4) 4135 // CHECK-ASM: vfaebs 4136 vbs = vec_find_any_eq_cc(vss, vss, &cc); 4137 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4) 4138 // CHECK-ASM: vfaehs 4139 vbs = vec_find_any_eq_cc(vus, vus, &cc); 4140 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4) 4141 // CHECK-ASM: vfaehs 4142 vbs = vec_find_any_eq_cc(vbs, vbs, &cc); 4143 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4) 4144 // CHECK-ASM: vfaehs 4145 vbi = vec_find_any_eq_cc(vsi, vsi, &cc); 4146 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4) 4147 // CHECK-ASM: vfaefs 4148 vbi = vec_find_any_eq_cc(vui, vui, &cc); 4149 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4) 4150 // CHECK-ASM: vfaefs 4151 vbi = vec_find_any_eq_cc(vbi, vbi, &cc); 4152 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4) 4153 // CHECK-ASM: vfaefs 4154 4155 vsc = vec_find_any_eq_idx(vsc, vsc); 4156 // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 4157 // CHECK-ASM: vfaeb 4158 vuc = vec_find_any_eq_idx(vuc, vuc); 4159 // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 4160 // CHECK-ASM: vfaeb 4161 vuc = vec_find_any_eq_idx(vbc, vbc); 4162 // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 4163 // CHECK-ASM: vfaeb 4164 vss = vec_find_any_eq_idx(vss, vss); 4165 // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0) 4166 // CHECK-ASM: vfaeh 4167 vus = vec_find_any_eq_idx(vus, vus); 4168 // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0) 4169 // CHECK-ASM: vfaeh 4170 vus = vec_find_any_eq_idx(vbs, vbs); 4171 // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0) 4172 // CHECK-ASM: vfaeh 4173 vsi = vec_find_any_eq_idx(vsi, vsi); 4174 // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0) 4175 // CHECK-ASM: vfaef 4176 vui = vec_find_any_eq_idx(vui, vui); 4177 // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0) 4178 // CHECK-ASM: vfaef 4179 vui = vec_find_any_eq_idx(vbi, vbi); 4180 // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0) 4181 // CHECK-ASM: vfaef 4182 4183 vsc = vec_find_any_eq_idx_cc(vsc, vsc, &cc); 4184 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 4185 // CHECK-ASM: vfaebs 4186 vuc = vec_find_any_eq_idx_cc(vuc, vuc, &cc); 4187 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 4188 // CHECK-ASM: vfaebs 4189 vuc = vec_find_any_eq_idx_cc(vbc, vbc, &cc); 4190 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 4191 // CHECK-ASM: vfaebs 4192 vss = vec_find_any_eq_idx_cc(vss, vss, &cc); 4193 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0) 4194 // CHECK-ASM: vfaehs 4195 vus = vec_find_any_eq_idx_cc(vus, vus, &cc); 4196 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0) 4197 // CHECK-ASM: vfaehs 4198 vus = vec_find_any_eq_idx_cc(vbs, vbs, &cc); 4199 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0) 4200 // CHECK-ASM: vfaehs 4201 vsi = vec_find_any_eq_idx_cc(vsi, vsi, &cc); 4202 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0) 4203 // CHECK-ASM: vfaefs 4204 vui = vec_find_any_eq_idx_cc(vui, vui, &cc); 4205 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0) 4206 // CHECK-ASM: vfaefs 4207 vui = vec_find_any_eq_idx_cc(vbi, vbi, &cc); 4208 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0) 4209 // CHECK-ASM: vfaefs 4210 4211 vsc = vec_find_any_eq_or_0_idx(vsc, vsc); 4212 // CHECK: call <16 x i8> @llvm.s390.vfaezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 4213 // CHECK-ASM: vfaezb 4214 vuc = vec_find_any_eq_or_0_idx(vuc, vuc); 4215 // CHECK: call <16 x i8> @llvm.s390.vfaezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 4216 // CHECK-ASM: vfaezb 4217 vuc = vec_find_any_eq_or_0_idx(vbc, vbc); 4218 // CHECK: call <16 x i8> @llvm.s390.vfaezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 4219 // CHECK-ASM: vfaezb 4220 vss = vec_find_any_eq_or_0_idx(vss, vss); 4221 // CHECK: call <8 x i16> @llvm.s390.vfaezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0) 4222 // CHECK-ASM: vfaezh 4223 vus = vec_find_any_eq_or_0_idx(vus, vus); 4224 // CHECK: call <8 x i16> @llvm.s390.vfaezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0) 4225 // CHECK-ASM: vfaezh 4226 vus = vec_find_any_eq_or_0_idx(vbs, vbs); 4227 // CHECK: call <8 x i16> @llvm.s390.vfaezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0) 4228 // CHECK-ASM: vfaezh 4229 vsi = vec_find_any_eq_or_0_idx(vsi, vsi); 4230 // CHECK: call <4 x i32> @llvm.s390.vfaezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0) 4231 // CHECK-ASM: vfaezf 4232 vui = vec_find_any_eq_or_0_idx(vui, vui); 4233 // CHECK: call <4 x i32> @llvm.s390.vfaezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0) 4234 // CHECK-ASM: vfaezf 4235 vui = vec_find_any_eq_or_0_idx(vbi, vbi); 4236 // CHECK: call <4 x i32> @llvm.s390.vfaezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0) 4237 // CHECK-ASM: vfaezf 4238 4239 vsc = vec_find_any_eq_or_0_idx_cc(vsc, vsc, &cc); 4240 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 4241 // CHECK-ASM: vfaezbs 4242 vuc = vec_find_any_eq_or_0_idx_cc(vuc, vuc, &cc); 4243 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 4244 // CHECK-ASM: vfaezbs 4245 vuc = vec_find_any_eq_or_0_idx_cc(vbc, vbc, &cc); 4246 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 4247 // CHECK-ASM: vfaezbs 4248 vss = vec_find_any_eq_or_0_idx_cc(vss, vss, &cc); 4249 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0) 4250 // CHECK-ASM: vfaezhs 4251 vus = vec_find_any_eq_or_0_idx_cc(vus, vus, &cc); 4252 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0) 4253 // CHECK-ASM: vfaezhs 4254 vus = vec_find_any_eq_or_0_idx_cc(vbs, vbs, &cc); 4255 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0) 4256 // CHECK-ASM: vfaezhs 4257 vsi = vec_find_any_eq_or_0_idx_cc(vsi, vsi, &cc); 4258 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0) 4259 // CHECK-ASM: vfaezfs 4260 vui = vec_find_any_eq_or_0_idx_cc(vui, vui, &cc); 4261 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0) 4262 // CHECK-ASM: vfaezfs 4263 vui = vec_find_any_eq_or_0_idx_cc(vbi, vbi, &cc); 4264 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0) 4265 // CHECK-ASM: vfaezfs 4266 4267 vbc = vec_find_any_ne(vsc, vsc); 4268 // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12) 4269 // CHECK-ASM: vfaeb 4270 vbc = vec_find_any_ne(vuc, vuc); 4271 // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12) 4272 // CHECK-ASM: vfaeb 4273 vbc = vec_find_any_ne(vbc, vbc); 4274 // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12) 4275 // CHECK-ASM: vfaeb 4276 vbs = vec_find_any_ne(vss, vss); 4277 // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12) 4278 // CHECK-ASM: vfaeh 4279 vbs = vec_find_any_ne(vus, vus); 4280 // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12) 4281 // CHECK-ASM: vfaeh 4282 vbs = vec_find_any_ne(vbs, vbs); 4283 // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12) 4284 // CHECK-ASM: vfaeh 4285 vbi = vec_find_any_ne(vsi, vsi); 4286 // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12) 4287 // CHECK-ASM: vfaef 4288 vbi = vec_find_any_ne(vui, vui); 4289 // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12) 4290 // CHECK-ASM: vfaef 4291 vbi = vec_find_any_ne(vbi, vbi); 4292 // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12) 4293 // CHECK-ASM: vfaef 4294 4295 vbc = vec_find_any_ne_cc(vsc, vsc, &cc); 4296 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12) 4297 // CHECK-ASM: vfaebs 4298 vbc = vec_find_any_ne_cc(vuc, vuc, &cc); 4299 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12) 4300 // CHECK-ASM: vfaebs 4301 vbc = vec_find_any_ne_cc(vbc, vbc, &cc); 4302 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12) 4303 // CHECK-ASM: vfaebs 4304 vbs = vec_find_any_ne_cc(vss, vss, &cc); 4305 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12) 4306 // CHECK-ASM: vfaehs 4307 vbs = vec_find_any_ne_cc(vus, vus, &cc); 4308 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12) 4309 // CHECK-ASM: vfaehs 4310 vbs = vec_find_any_ne_cc(vbs, vbs, &cc); 4311 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12) 4312 // CHECK-ASM: vfaehs 4313 vbi = vec_find_any_ne_cc(vsi, vsi, &cc); 4314 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12) 4315 // CHECK-ASM: vfaefs 4316 vbi = vec_find_any_ne_cc(vui, vui, &cc); 4317 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12) 4318 // CHECK-ASM: vfaefs 4319 vbi = vec_find_any_ne_cc(vbi, vbi, &cc); 4320 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12) 4321 // CHECK-ASM: vfaefs 4322 4323 vsc = vec_find_any_ne_idx(vsc, vsc); 4324 // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8) 4325 // CHECK-ASM: vfaeb 4326 vuc = vec_find_any_ne_idx(vuc, vuc); 4327 // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8) 4328 // CHECK-ASM: vfaeb 4329 vuc = vec_find_any_ne_idx(vbc, vbc); 4330 // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8) 4331 // CHECK-ASM: vfaeb 4332 vss = vec_find_any_ne_idx(vss, vss); 4333 // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8) 4334 // CHECK-ASM: vfaeh 4335 vus = vec_find_any_ne_idx(vus, vus); 4336 // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8) 4337 // CHECK-ASM: vfaeh 4338 vus = vec_find_any_ne_idx(vbs, vbs); 4339 // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8) 4340 // CHECK-ASM: vfaeh 4341 vsi = vec_find_any_ne_idx(vsi, vsi); 4342 // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8) 4343 // CHECK-ASM: vfaef 4344 vui = vec_find_any_ne_idx(vui, vui); 4345 // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8) 4346 // CHECK-ASM: vfaef 4347 vui = vec_find_any_ne_idx(vbi, vbi); 4348 // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8) 4349 // CHECK-ASM: vfaef 4350 4351 vsc = vec_find_any_ne_idx_cc(vsc, vsc, &cc); 4352 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8) 4353 // CHECK-ASM: vfaebs 4354 vuc = vec_find_any_ne_idx_cc(vuc, vuc, &cc); 4355 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8) 4356 // CHECK-ASM: vfaebs 4357 vuc = vec_find_any_ne_idx_cc(vbc, vbc, &cc); 4358 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8) 4359 // CHECK-ASM: vfaebs 4360 vss = vec_find_any_ne_idx_cc(vss, vss, &cc); 4361 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8) 4362 // CHECK-ASM: vfaehs 4363 vus = vec_find_any_ne_idx_cc(vus, vus, &cc); 4364 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8) 4365 // CHECK-ASM: vfaehs 4366 vus = vec_find_any_ne_idx_cc(vbs, vbs, &cc); 4367 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8) 4368 // CHECK-ASM: vfaehs 4369 vsi = vec_find_any_ne_idx_cc(vsi, vsi, &cc); 4370 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8) 4371 // CHECK-ASM: vfaefs 4372 vui = vec_find_any_ne_idx_cc(vui, vui, &cc); 4373 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8) 4374 // CHECK-ASM: vfaefs 4375 vui = vec_find_any_ne_idx_cc(vbi, vbi, &cc); 4376 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8) 4377 // CHECK-ASM: vfaefs 4378 4379 vsc = vec_find_any_ne_or_0_idx(vsc, vsc); 4380 // CHECK: call <16 x i8> @llvm.s390.vfaezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8) 4381 // CHECK-ASM: vfaezb 4382 vuc = vec_find_any_ne_or_0_idx(vuc, vuc); 4383 // CHECK: call <16 x i8> @llvm.s390.vfaezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8) 4384 // CHECK-ASM: vfaezb 4385 vuc = vec_find_any_ne_or_0_idx(vbc, vbc); 4386 // CHECK: call <16 x i8> @llvm.s390.vfaezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8) 4387 // CHECK-ASM: vfaezb 4388 vss = vec_find_any_ne_or_0_idx(vss, vss); 4389 // CHECK: call <8 x i16> @llvm.s390.vfaezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8) 4390 // CHECK-ASM: vfaezh 4391 vus = vec_find_any_ne_or_0_idx(vus, vus); 4392 // CHECK: call <8 x i16> @llvm.s390.vfaezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8) 4393 // CHECK-ASM: vfaezh 4394 vus = vec_find_any_ne_or_0_idx(vbs, vbs); 4395 // CHECK: call <8 x i16> @llvm.s390.vfaezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8) 4396 // CHECK-ASM: vfaezh 4397 vsi = vec_find_any_ne_or_0_idx(vsi, vsi); 4398 // CHECK: call <4 x i32> @llvm.s390.vfaezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8) 4399 // CHECK-ASM: vfaezf 4400 vui = vec_find_any_ne_or_0_idx(vui, vui); 4401 // CHECK: call <4 x i32> @llvm.s390.vfaezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8) 4402 // CHECK-ASM: vfaezf 4403 vui = vec_find_any_ne_or_0_idx(vbi, vbi); 4404 // CHECK: call <4 x i32> @llvm.s390.vfaezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8) 4405 // CHECK-ASM: vfaezf 4406 4407 vsc = vec_find_any_ne_or_0_idx_cc(vsc, vsc, &cc); 4408 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8) 4409 // CHECK-ASM: vfaezbs 4410 vuc = vec_find_any_ne_or_0_idx_cc(vuc, vuc, &cc); 4411 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8) 4412 // CHECK-ASM: vfaezbs 4413 vuc = vec_find_any_ne_or_0_idx_cc(vbc, vbc, &cc); 4414 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8) 4415 // CHECK-ASM: vfaezbs 4416 vss = vec_find_any_ne_or_0_idx_cc(vss, vss, &cc); 4417 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8) 4418 // CHECK-ASM: vfaezhs 4419 vus = vec_find_any_ne_or_0_idx_cc(vus, vus, &cc); 4420 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8) 4421 // CHECK-ASM: vfaezhs 4422 vus = vec_find_any_ne_or_0_idx_cc(vbs, vbs, &cc); 4423 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8) 4424 // CHECK-ASM: vfaezhs 4425 vsi = vec_find_any_ne_or_0_idx_cc(vsi, vsi, &cc); 4426 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8) 4427 // CHECK-ASM: vfaezfs 4428 vui = vec_find_any_ne_or_0_idx_cc(vui, vui, &cc); 4429 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8) 4430 // CHECK-ASM: vfaezfs 4431 vui = vec_find_any_ne_or_0_idx_cc(vbi, vbi, &cc); 4432 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8) 4433 // CHECK-ASM: vfaezfs 4434 } 4435 4436 void test_float(void) { 4437 // CHECK-ASM-LABEL: test_float 4438 4439 vd = vec_abs(vd); 4440 // CHECK: call <2 x double> @llvm.fabs.v2f64(<2 x double> %{{.*}}) 4441 // CHECK-ASM: vflpdb 4442 4443 vd = vec_nabs(vd); 4444 // CHECK: [[ABS:%[^ ]+]] = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %{{.*}}) 4445 // CHECK-NEXT: fneg <2 x double> [[ABS]] 4446 // CHECK-ASM: vflndb 4447 4448 vd = vec_madd(vd, vd, vd); 4449 // CHECK: call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}) 4450 // CHECK-ASM: vfmadb 4451 vd = vec_msub(vd, vd, vd); 4452 // CHECK: [[NEG:%[^ ]+]] = fneg <2 x double> %{{.*}} 4453 // CHECK: call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> [[NEG]]) 4454 // CHECK-ASM: vfmsdb 4455 vd = vec_sqrt(vd); 4456 // CHECK: call <2 x double> @llvm.sqrt.v2f64(<2 x double> %{{.*}}) 4457 // CHECK-ASM: vfsqdb 4458 4459 vd = vec_ld2f(cptrf); 4460 // CHECK: [[VAL:%[^ ]+]] = load <2 x float>, <2 x float>* %{{.*}} 4461 // CHECK: fpext <2 x float> [[VAL]] to <2 x double> 4462 // (emulated) 4463 vec_st2f(vd, ptrf); 4464 // CHECK: [[VAL:%[^ ]+]] = fptrunc <2 x double> %{{.*}} to <2 x float> 4465 // CHECK: store <2 x float> [[VAL]], <2 x float>* %{{.*}} 4466 // (emulated) 4467 4468 vd = vec_ctd(vsl, 0); 4469 // CHECK: sitofp <2 x i64> %{{.*}} to <2 x double> 4470 // (emulated) 4471 vd = vec_ctd(vul, 0); 4472 // CHECK: uitofp <2 x i64> %{{.*}} to <2 x double> 4473 // (emulated) 4474 vd = vec_ctd(vsl, 1); 4475 // CHECK: [[VAL:%[^ ]+]] = sitofp <2 x i64> %{{.*}} to <2 x double> 4476 // CHECK: fmul <2 x double> [[VAL]], <double 5.000000e-01, double 5.000000e-01> 4477 // (emulated) 4478 vd = vec_ctd(vul, 1); 4479 // CHECK: [[VAL:%[^ ]+]] = uitofp <2 x i64> %{{.*}} to <2 x double> 4480 // CHECK: fmul <2 x double> [[VAL]], <double 5.000000e-01, double 5.000000e-01> 4481 // (emulated) 4482 vd = vec_ctd(vsl, 31); 4483 // CHECK: [[VAL:%[^ ]+]] = sitofp <2 x i64> %{{.*}} to <2 x double> 4484 // CHECK: fmul <2 x double> [[VAL]], <double 0x3E00000000000000, double 0x3E00000000000000> 4485 // (emulated) 4486 vd = vec_ctd(vul, 31); 4487 // CHECK: [[VAL:%[^ ]+]] = uitofp <2 x i64> %{{.*}} to <2 x double> 4488 // CHECK: fmul <2 x double> [[VAL]], <double 0x3E00000000000000, double 0x3E00000000000000> 4489 // (emulated) 4490 4491 vsl = vec_ctsl(vd, 0); 4492 // CHECK: fptosi <2 x double> %{{.*}} to <2 x i64> 4493 // (emulated) 4494 vul = vec_ctul(vd, 0); 4495 // CHECK: fptoui <2 x double> %{{.*}} to <2 x i64> 4496 // (emulated) 4497 vsl = vec_ctsl(vd, 1); 4498 // CHECK: [[VAL:%[^ ]+]] = fmul <2 x double> %{{.*}}, <double 2.000000e+00, double 2.000000e+00> 4499 // CHECK: fptosi <2 x double> [[VAL]] to <2 x i64> 4500 // (emulated) 4501 vul = vec_ctul(vd, 1); 4502 // CHECK: [[VAL:%[^ ]+]] = fmul <2 x double> %{{.*}}, <double 2.000000e+00, double 2.000000e+00> 4503 // CHECK: fptoui <2 x double> [[VAL]] to <2 x i64> 4504 // (emulated) 4505 vsl = vec_ctsl(vd, 31); 4506 // CHECK: [[VAL:%[^ ]+]] = fmul <2 x double> %{{.*}}, <double 0x41E0000000000000, double 0x41E0000000000000> 4507 // CHECK: fptosi <2 x double> [[VAL]] to <2 x i64> 4508 // (emulated) 4509 vul = vec_ctul(vd, 31); 4510 // CHECK: [[VAL:%[^ ]+]] = fmul <2 x double> %{{.*}}, <double 0x41E0000000000000, double 0x41E0000000000000> 4511 // CHECK: fptoui <2 x double> [[VAL]] to <2 x i64> 4512 // (emulated) 4513 4514 vd = vec_double(vsl); 4515 // CHECK: sitofp <2 x i64> %{{.*}} to <2 x double> 4516 // CHECK-ASM: vcdgb 4517 vd = vec_double(vul); 4518 // CHECK: uitofp <2 x i64> %{{.*}} to <2 x double> 4519 // CHECK-ASM: vcdlgb 4520 4521 vsl = vec_signed(vd); 4522 // CHECK: fptosi <2 x double> %{{.*}} to <2 x i64> 4523 // CHECK-ASM: vcgdb 4524 vul = vec_unsigned(vd); 4525 // CHECK: fptoui <2 x double> %{{.*}} to <2 x i64> 4526 // CHECK-ASM: vclgdb 4527 4528 vd = vec_roundp(vd); 4529 // CHECK: call <2 x double> @llvm.ceil.v2f64(<2 x double> %{{.*}}) 4530 // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 6 4531 vd = vec_ceil(vd); 4532 // CHECK: call <2 x double> @llvm.ceil.v2f64(<2 x double> %{{.*}}) 4533 // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 6 4534 vd = vec_roundm(vd); 4535 // CHECK: call <2 x double> @llvm.floor.v2f64(<2 x double> %{{.*}}) 4536 // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 7 4537 vd = vec_floor(vd); 4538 // CHECK: call <2 x double> @llvm.floor.v2f64(<2 x double> %{{.*}}) 4539 // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 7 4540 vd = vec_roundz(vd); 4541 // CHECK: call <2 x double> @llvm.trunc.v2f64(<2 x double> %{{.*}}) 4542 // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 5 4543 vd = vec_trunc(vd); 4544 // CHECK: call <2 x double> @llvm.trunc.v2f64(<2 x double> %{{.*}}) 4545 // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 5 4546 vd = vec_roundc(vd); 4547 // CHECK: call <2 x double> @llvm.nearbyint.v2f64(<2 x double> %{{.*}}) 4548 // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 0 4549 vd = vec_rint(vd); 4550 // CHECK: call <2 x double> @llvm.rint.v2f64(<2 x double> %{{.*}}) 4551 // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 0, 0 4552 vd = vec_round(vd); 4553 // CHECK: call <2 x double> @llvm.s390.vfidb(<2 x double> %{{.*}}, i32 4, i32 4) 4554 // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 4 4555 4556 vbl = vec_fp_test_data_class(vd, 0, &cc); 4557 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 0) 4558 // CHECK-ASM: vftcidb 4559 vbl = vec_fp_test_data_class(vd, 4095, &cc); 4560 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 4095) 4561 // CHECK-ASM: vftcidb 4562 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_ZERO_P, &cc); 4563 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 2048) 4564 // CHECK-ASM: vftcidb 4565 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_ZERO_N, &cc); 4566 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 1024) 4567 // CHECK-ASM: vftcidb 4568 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_ZERO, &cc); 4569 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 3072) 4570 // CHECK-ASM: vftcidb 4571 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_NORMAL_P, &cc); 4572 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 512) 4573 // CHECK-ASM: vftcidb 4574 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_NORMAL_N, &cc); 4575 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 256) 4576 // CHECK-ASM: vftcidb 4577 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_NORMAL, &cc); 4578 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 768) 4579 // CHECK-ASM: vftcidb 4580 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_SUBNORMAL_P, &cc); 4581 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 128) 4582 // CHECK-ASM: vftcidb 4583 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_SUBNORMAL_N, &cc); 4584 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 64) 4585 // CHECK-ASM: vftcidb 4586 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_SUBNORMAL, &cc); 4587 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 192) 4588 // CHECK-ASM: vftcidb 4589 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_INFINITY_P, &cc); 4590 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 32) 4591 // CHECK-ASM: vftcidb 4592 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_INFINITY_N, &cc); 4593 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 16) 4594 // CHECK-ASM: vftcidb 4595 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_INFINITY, &cc); 4596 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 48) 4597 // CHECK-ASM: vftcidb 4598 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_QNAN_P, &cc); 4599 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 8) 4600 // CHECK-ASM: vftcidb 4601 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_QNAN_N, &cc); 4602 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 4) 4603 // CHECK-ASM: vftcidb 4604 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_QNAN, &cc); 4605 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 12) 4606 // CHECK-ASM: vftcidb 4607 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_SNAN_P, &cc); 4608 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 2) 4609 // CHECK-ASM: vftcidb 4610 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_SNAN_N, &cc); 4611 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 1) 4612 // CHECK-ASM: vftcidb 4613 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_SNAN, &cc); 4614 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 3) 4615 // CHECK-ASM: vftcidb 4616 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_NAN, &cc); 4617 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15) 4618 // CHECK-ASM: vftcidb 4619 vbl = vec_fp_test_data_class(vd, __VEC_CLASS_FP_NOT_NORMAL, &cc); 4620 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 3327) 4621 // CHECK-ASM: vftcidb 4622 } 4623