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