4962 lines · c
1// REQUIRES: systemz-registered-target2// 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 %s5// 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-ASM8 9#include <vecintrin.h>10 11volatile vector signed char vsc;12volatile vector signed short vss;13volatile vector signed int vsi;14volatile vector signed long long vsl;15volatile vector signed __int128 vslll;16volatile vector unsigned char vuc;17volatile vector unsigned short vus;18volatile vector unsigned int vui;19volatile vector unsigned long long vul;20volatile vector unsigned __int128 vulll;21volatile vector bool char vbc;22volatile vector bool short vbs;23volatile vector bool int vbi;24volatile vector bool long long vbl;25volatile vector bool __int128 vblll;26volatile vector double vd;27 28volatile signed char sc;29volatile signed short ss;30volatile signed int si;31volatile signed long long sl;32volatile signed __int128 slll;33volatile unsigned char uc;34volatile unsigned short us;35volatile unsigned int ui;36volatile unsigned long long ul;37volatile unsigned __int128 ulll;38volatile double d;39 40const void * volatile cptr;41const signed char * volatile cptrsc;42const signed short * volatile cptrss;43const signed int * volatile cptrsi;44const signed long long * volatile cptrsl;45const signed __int128 * volatile cptrslll;46const unsigned char * volatile cptruc;47const unsigned short * volatile cptrus;48const unsigned int * volatile cptrui;49const unsigned long long * volatile cptrul;50const unsigned __int128 * volatile cptrulll;51const float * volatile cptrf;52const double * volatile cptrd;53 54void * volatile ptr;55signed char * volatile ptrsc;56signed short * volatile ptrss;57signed int * volatile ptrsi;58signed long long * volatile ptrsl;59signed __int128 * volatile ptrslll;60unsigned char * volatile ptruc;61unsigned short * volatile ptrus;62unsigned int * volatile ptrui;63unsigned long long * volatile ptrul;64unsigned __int128 * volatile ptrulll;65float * volatile ptrf;66double * volatile ptrd;67 68volatile unsigned int len;69volatile int idx;70int cc;71 72void test_core(void) {73 // CHECK-ASM-LABEL: test_core74 75 len = __lcbb(cptr, 64);76 // CHECK: call i32 @llvm.s390.lcbb(ptr %{{.*}}, i32 0)77 // CHECK-ASM: lcbb78 len = __lcbb(cptr, 128);79 // CHECK: call i32 @llvm.s390.lcbb(ptr %{{.*}}, i32 1)80 // CHECK-ASM: lcbb81 len = __lcbb(cptr, 256);82 // CHECK: call i32 @llvm.s390.lcbb(ptr %{{.*}}, i32 2)83 // CHECK-ASM: lcbb84 len = __lcbb(cptr, 512);85 // CHECK: call i32 @llvm.s390.lcbb(ptr %{{.*}}, i32 3)86 // CHECK-ASM: lcbb87 len = __lcbb(cptr, 1024);88 // CHECK: call i32 @llvm.s390.lcbb(ptr %{{.*}}, i32 4)89 // CHECK-ASM: lcbb90 len = __lcbb(cptr, 2048);91 // CHECK: call i32 @llvm.s390.lcbb(ptr %{{.*}}, i32 5)92 // CHECK-ASM: lcbb93 len = __lcbb(cptr, 4096);94 // CHECK: call i32 @llvm.s390.lcbb(ptr %{{.*}}, i32 6)95 // CHECK-ASM: lcbb96 97 sc = vec_extract(vsc, idx);98 // CHECK: extractelement <16 x i8> %{{.*}}, i32 %{{.*}}99 // CHECK-ASM: vlgvb100 uc = vec_extract(vuc, idx);101 // CHECK: extractelement <16 x i8> %{{.*}}, i32 %{{.*}}102 // CHECK-ASM: vlgvb103 uc = vec_extract(vbc, idx);104 // CHECK: extractelement <16 x i8> %{{.*}}, i32 %{{.*}}105 // CHECK-ASM: vlgvb106 ss = vec_extract(vss, idx);107 // CHECK: extractelement <8 x i16> %{{.*}}, i32 %{{.*}}108 // CHECK-ASM: vlgvh109 us = vec_extract(vus, idx);110 // CHECK: extractelement <8 x i16> %{{.*}}, i32 %{{.*}}111 // CHECK-ASM: vlgvh112 us = vec_extract(vbs, idx);113 // CHECK: extractelement <8 x i16> %{{.*}}, i32 %{{.*}}114 // CHECK-ASM: vlgvh115 si = vec_extract(vsi, idx);116 // CHECK: extractelement <4 x i32> %{{.*}}, i32 %{{.*}}117 // CHECK-ASM: vlgvf118 ui = vec_extract(vui, idx);119 // CHECK: extractelement <4 x i32> %{{.*}}, i32 %{{.*}}120 // CHECK-ASM: vlgvf121 ui = vec_extract(vbi, idx);122 // CHECK: extractelement <4 x i32> %{{.*}}, i32 %{{.*}}123 // CHECK-ASM: vlgvf124 sl = vec_extract(vsl, idx);125 // CHECK: extractelement <2 x i64> %{{.*}}, i32 %{{.*}}126 // CHECK-ASM: vlgvg127 ul = vec_extract(vul, idx);128 // CHECK: extractelement <2 x i64> %{{.*}}, i32 %{{.*}}129 // CHECK-ASM: vlgvg130 ul = vec_extract(vbl, idx);131 // CHECK: extractelement <2 x i64> %{{.*}}, i32 %{{.*}}132 // CHECK-ASM: vlgvg133 d = vec_extract(vd, idx);134 // CHECK: extractelement <2 x double> %{{.*}}, i32 %{{.*}}135 // CHECK-ASM: vlgvg136 137 vsc = vec_insert(sc, vsc, idx);138 // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 %{{.*}}139 // CHECK-ASM: vlvgb140 vuc = vec_insert(uc, vuc, idx);141 // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 %{{.*}}142 // CHECK-ASM: vlvgb143 vuc = vec_insert(uc, vbc, idx);144 // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 %{{.*}}145 // CHECK-ASM: vlvgb146 vss = vec_insert(ss, vss, idx);147 // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 %{{.*}}148 // CHECK-ASM: vlvgh149 vus = vec_insert(us, vus, idx);150 // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 %{{.*}}151 // CHECK-ASM: vlvgh152 vus = vec_insert(us, vbs, idx);153 // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 %{{.*}}154 // CHECK-ASM: vlvgh155 vsi = vec_insert(si, vsi, idx);156 // CHECK: insertelement <4 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}157 // CHECK-ASM: vlvgf158 vui = vec_insert(ui, vui, idx);159 // CHECK: insertelement <4 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}160 // CHECK-ASM: vlvgf161 vui = vec_insert(ui, vbi, idx);162 // CHECK: insertelement <4 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}163 // CHECK-ASM: vlvgf164 vsl = vec_insert(sl, vsl, idx);165 // CHECK: insertelement <2 x i64> %{{.*}}, i64 %{{.*}}, i32 %{{.*}}166 // CHECK-ASM: vlvgg167 vul = vec_insert(ul, vul, idx);168 // CHECK: insertelement <2 x i64> %{{.*}}, i64 %{{.*}}, i32 %{{.*}}169 // CHECK-ASM: vlvgg170 vul = vec_insert(ul, vbl, idx);171 // CHECK: insertelement <2 x i64> %{{.*}}, i64 %{{.*}}, i32 %{{.*}}172 // CHECK-ASM: vlvgg173 vd = vec_insert(d, vd, idx);174 // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 %{{.*}}175 // CHECK-ASM: vlvgg176 177 vsc = vec_promote(sc, idx);178 // CHECK: insertelement <16 x i8> poison, i8 %{{.*}}, i32 %{{.*}}179 // CHECK-ASM: vlvgb180 vuc = vec_promote(uc, idx);181 // CHECK: insertelement <16 x i8> poison, i8 %{{.*}}, i32 %{{.*}}182 // CHECK-ASM: vlvgb183 vss = vec_promote(ss, idx);184 // CHECK: insertelement <8 x i16> poison, i16 %{{.*}}, i32 %{{.*}}185 // CHECK-ASM: vlvgh186 vus = vec_promote(us, idx);187 // CHECK: insertelement <8 x i16> poison, i16 %{{.*}}, i32 %{{.*}}188 // CHECK-ASM: vlvgh189 vsi = vec_promote(si, idx);190 // CHECK: insertelement <4 x i32> poison, i32 %{{.*}}, i32 %{{.*}}191 // CHECK-ASM: vlvgf192 vui = vec_promote(ui, idx);193 // CHECK: insertelement <4 x i32> poison, i32 %{{.*}}, i32 %{{.*}}194 // CHECK-ASM: vlvgf195 vsl = vec_promote(sl, idx);196 // CHECK: insertelement <2 x i64> poison, i64 %{{.*}}, i32 %{{.*}}197 // CHECK-ASM: vlvgg198 vul = vec_promote(ul, idx);199 // CHECK: insertelement <2 x i64> poison, i64 %{{.*}}, i32 %{{.*}}200 // CHECK-ASM: vlvgg201 vd = vec_promote(d, idx);202 // CHECK: insertelement <2 x double> poison, double %{{.*}}, i32 %{{.*}}203 // CHECK-ASM: vlvgg204 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 7207 // CHECK-ASM: vllezb208 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 7210 // CHECK-ASM: vllezb211 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 3213 // CHECK-ASM: vllezh214 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 3216 // CHECK-ASM: vllezh217 vsi = vec_insert_and_zero(cptrsi);218 // CHECK: insertelement <4 x i32> <i32 0, i32 poison, i32 0, i32 0>, i32 %{{.*}}, i64 1219 // CHECK-ASM: vllezf220 vui = vec_insert_and_zero(cptrui);221 // CHECK: insertelement <4 x i32> <i32 0, i32 poison, i32 0, i32 0>, i32 %{{.*}}, i64 1222 // CHECK-ASM: vllezf223 vsl = vec_insert_and_zero(cptrsl);224 // CHECK: insertelement <2 x i64> <i64 poison, i64 0>, i64 %{{.*}}, i64 0225 // CHECK-ASM: vllezg226 vul = vec_insert_and_zero(cptrul);227 // CHECK: insertelement <2 x i64> <i64 poison, i64 0>, i64 %{{.*}}, i64 0228 // CHECK-ASM: vllezg229 vd = vec_insert_and_zero(cptrd);230 // CHECK: insertelement <2 x double> <double poison, double 0.000000e+00>, double %{{.*}}, i64 0231 // CHECK-ASM: vllezg232 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: vperm236 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: vperm239 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: vperm242 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: vperm245 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: vperm248 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: vperm251 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: vperm254 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: vperm257 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: vperm260 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: vperm263 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: vperm266 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: vperm269 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: vperm272 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: vperm275 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: vperm278 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: vperm281 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: vpdi285 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: vpdi288 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: vpdi291 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: vpdi294 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: vpdi297 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: vpdi300 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: vpdi303 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: vpdi306 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: vpdi309 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: vpdi312 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: vpdi315 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: vpdi318 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: vpdi321 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: vpdi324 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: vpdi327 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: vpdi330 331 vss = vec_revb(vss);332 // CHECK-ASM: vperm333 vus = vec_revb(vus);334 // CHECK-ASM: vperm335 vsi = vec_revb(vsi);336 // CHECK-ASM: vperm337 vui = vec_revb(vui);338 // CHECK-ASM: vperm339 vsl = vec_revb(vsl);340 // CHECK-ASM: vperm341 vul = vec_revb(vul);342 // CHECK-ASM: vperm343 vslll = vec_revb(vslll);344 // CHECK-ASM: vperm345 vulll = vec_revb(vulll);346 // CHECK-ASM: vperm347 vd = vec_revb(vd);348 // CHECK-ASM: vperm349 350 vsc = vec_reve(vsc);351 // CHECK-ASM: vperm352 vuc = vec_reve(vuc);353 // CHECK-ASM: vperm354 vbc = vec_reve(vbc);355 // CHECK-ASM: vperm356 vss = vec_reve(vss);357 // CHECK-ASM: vperm358 vus = vec_reve(vus);359 // CHECK-ASM: vperm360 vbs = vec_reve(vbs);361 // CHECK-ASM: vperm362 vsi = vec_reve(vsi);363 // CHECK-ASM: vperm364 vui = vec_reve(vui);365 // CHECK-ASM: vperm366 vbi = vec_reve(vbi);367 // CHECK-ASM: vperm368 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: vsel379 vsc = vec_sel(vsc, vsc, vbc);380 // CHECK-ASM: vsel381 vuc = vec_sel(vuc, vuc, vuc);382 // CHECK-ASM: vsel383 vuc = vec_sel(vuc, vuc, vbc);384 // CHECK-ASM: vsel385 vbc = vec_sel(vbc, vbc, vuc);386 // CHECK-ASM: vsel387 vbc = vec_sel(vbc, vbc, vbc);388 // CHECK-ASM: vsel389 vss = vec_sel(vss, vss, vus);390 // CHECK-ASM: vsel391 vss = vec_sel(vss, vss, vbs);392 // CHECK-ASM: vsel393 vus = vec_sel(vus, vus, vus);394 // CHECK-ASM: vsel395 vus = vec_sel(vus, vus, vbs);396 // CHECK-ASM: vsel397 vbs = vec_sel(vbs, vbs, vus);398 // CHECK-ASM: vsel399 vbs = vec_sel(vbs, vbs, vbs);400 // CHECK-ASM: vsel401 vsi = vec_sel(vsi, vsi, vui);402 // CHECK-ASM: vsel403 vsi = vec_sel(vsi, vsi, vbi);404 // CHECK-ASM: vsel405 vui = vec_sel(vui, vui, vui);406 // CHECK-ASM: vsel407 vui = vec_sel(vui, vui, vbi);408 // CHECK-ASM: vsel409 vbi = vec_sel(vbi, vbi, vui);410 // CHECK-ASM: vsel411 vbi = vec_sel(vbi, vbi, vbi);412 // CHECK-ASM: vsel413 vsl = vec_sel(vsl, vsl, vul);414 // CHECK-ASM: vsel415 vsl = vec_sel(vsl, vsl, vbl);416 // CHECK-ASM: vsel417 vul = vec_sel(vul, vul, vul);418 // CHECK-ASM: vsel419 vul = vec_sel(vul, vul, vbl);420 // CHECK-ASM: vsel421 vbl = vec_sel(vbl, vbl, vul);422 // CHECK-ASM: vsel423 vbl = vec_sel(vbl, vbl, vbl);424 // CHECK-ASM: vsel425 vslll = vec_sel(vslll, vslll, vulll);426 // CHECK-ASM: vsel427 vslll = vec_sel(vslll, vslll, vblll);428 // CHECK-ASM: vsel429 vulll = vec_sel(vulll, vulll, vulll);430 // CHECK-ASM: vsel431 vulll = vec_sel(vulll, vulll, vblll);432 // CHECK-ASM: vsel433 vblll = vec_sel(vblll, vblll, vulll);434 // CHECK-ASM: vsel435 vblll = vec_sel(vblll, vblll, vblll);436 // CHECK-ASM: vsel437 vd = vec_sel(vd, vd, vul);438 // CHECK-ASM: vsel439 vd = vec_sel(vd, vd, vbl);440 // CHECK-ASM: vsel441 442 vsi = vec_gather_element(vsi, vui, cptrsi, 0);443 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 0444 vsi = vec_gather_element(vsi, vui, cptrsi, 1);445 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 1446 vsi = vec_gather_element(vsi, vui, cptrsi, 2);447 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 2448 vsi = vec_gather_element(vsi, vui, cptrsi, 3);449 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 3450 vui = vec_gather_element(vui, vui, cptrui, 0);451 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 0452 vui = vec_gather_element(vui, vui, cptrui, 1);453 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 1454 vui = vec_gather_element(vui, vui, cptrui, 2);455 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 2456 vui = vec_gather_element(vui, vui, cptrui, 3);457 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 3458 vbi = vec_gather_element(vbi, vui, cptrui, 0);459 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 0460 vbi = vec_gather_element(vbi, vui, cptrui, 1);461 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 1462 vbi = vec_gather_element(vbi, vui, cptrui, 2);463 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 2464 vbi = vec_gather_element(vbi, vui, cptrui, 3);465 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 3466 vsl = vec_gather_element(vsl, vul, cptrsl, 0);467 // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 0468 vsl = vec_gather_element(vsl, vul, cptrsl, 1);469 // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 1470 vul = vec_gather_element(vul, vul, cptrul, 0);471 // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 0472 vul = vec_gather_element(vul, vul, cptrul, 1);473 // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 1474 vbl = vec_gather_element(vbl, vul, cptrul, 0);475 // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 0476 vbl = vec_gather_element(vbl, vul, cptrul, 1);477 // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 1478 vd = vec_gather_element(vd, vul, cptrd, 0);479 // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 0480 vd = vec_gather_element(vd, vul, cptrd, 1);481 // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 1482 483 vec_scatter_element(vsi, vui, ptrsi, 0);484 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 0485 vec_scatter_element(vsi, vui, ptrsi, 1);486 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 1487 vec_scatter_element(vsi, vui, ptrsi, 2);488 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 2489 vec_scatter_element(vsi, vui, ptrsi, 3);490 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 3491 vec_scatter_element(vui, vui, ptrui, 0);492 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 0493 vec_scatter_element(vui, vui, ptrui, 1);494 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 1495 vec_scatter_element(vui, vui, ptrui, 2);496 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 2497 vec_scatter_element(vui, vui, ptrui, 3);498 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 3499 vec_scatter_element(vbi, vui, ptrui, 0);500 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 0501 vec_scatter_element(vbi, vui, ptrui, 1);502 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 1503 vec_scatter_element(vbi, vui, ptrui, 2);504 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 2505 vec_scatter_element(vbi, vui, ptrui, 3);506 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 3507 vec_scatter_element(vsl, vul, ptrsl, 0);508 // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 0509 vec_scatter_element(vsl, vul, ptrsl, 1);510 // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 1511 vec_scatter_element(vul, vul, ptrul, 0);512 // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 0513 vec_scatter_element(vul, vul, ptrul, 1);514 // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 1515 vec_scatter_element(vbl, vul, ptrul, 0);516 // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 0517 vec_scatter_element(vbl, vul, ptrul, 1);518 // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 1519 vec_scatter_element(vd, vul, ptrd, 0);520 // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 0521 vec_scatter_element(vd, vul, ptrd, 1);522 // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 1523 524 vsc = vec_xl(idx, cptrsc);525 // CHECK-ASM: vl526 vuc = vec_xl(idx, cptruc);527 // CHECK-ASM: vl528 vss = vec_xl(idx, cptrss);529 // CHECK-ASM: vl530 vus = vec_xl(idx, cptrus);531 // CHECK-ASM: vl532 vsi = vec_xl(idx, cptrsi);533 // CHECK-ASM: vl534 vui = vec_xl(idx, cptrui);535 // CHECK-ASM: vl536 vsl = vec_xl(idx, cptrsl);537 // CHECK-ASM: vl538 vul = vec_xl(idx, cptrul);539 // CHECK-ASM: vl540 vslll = vec_xl(idx, cptrslll);541 // CHECK-ASM: vl542 vulll = vec_xl(idx, cptrulll);543 // CHECK-ASM: vl544 vd = vec_xl(idx, cptrd);545 // CHECK-ASM: vl546 547 vsc = vec_xld2(idx, cptrsc);548 // CHECK-ASM: vl549 vuc = vec_xld2(idx, cptruc);550 // CHECK-ASM: vl551 vss = vec_xld2(idx, cptrss);552 // CHECK-ASM: vl553 vus = vec_xld2(idx, cptrus);554 // CHECK-ASM: vl555 vsi = vec_xld2(idx, cptrsi);556 // CHECK-ASM: vl557 vui = vec_xld2(idx, cptrui);558 // CHECK-ASM: vl559 vsl = vec_xld2(idx, cptrsl);560 // CHECK-ASM: vl561 vul = vec_xld2(idx, cptrul);562 // CHECK-ASM: vl563 vd = vec_xld2(idx, cptrd);564 // CHECK-ASM: vl565 566 vsc = vec_xlw4(idx, cptrsc);567 // CHECK-ASM: vl568 vuc = vec_xlw4(idx, cptruc);569 // CHECK-ASM: vl570 vss = vec_xlw4(idx, cptrss);571 // CHECK-ASM: vl572 vus = vec_xlw4(idx, cptrus);573 // CHECK-ASM: vl574 vsi = vec_xlw4(idx, cptrsi);575 // CHECK-ASM: vl576 vui = vec_xlw4(idx, cptrui);577 // CHECK-ASM: vl578 579 vec_xst(vsc, idx, ptrsc);580 // CHECK-ASM: vst581 vec_xst(vuc, idx, ptruc);582 // CHECK-ASM: vst583 vec_xst(vss, idx, ptrss);584 // CHECK-ASM: vst585 vec_xst(vus, idx, ptrus);586 // CHECK-ASM: vst587 vec_xst(vsi, idx, ptrsi);588 // CHECK-ASM: vst589 vec_xst(vui, idx, ptrui);590 // CHECK-ASM: vst591 vec_xst(vsl, idx, ptrsl);592 // CHECK-ASM: vst593 vec_xst(vul, idx, ptrul);594 // CHECK-ASM: vst595 vec_xst(vslll, idx, ptrslll);596 // CHECK-ASM: vst597 vec_xst(vulll, idx, ptrulll);598 // CHECK-ASM: vst599 vec_xst(vd, idx, ptrd);600 // CHECK-ASM: vst601 602 vec_xstd2(vsc, idx, ptrsc);603 // CHECK-ASM: vst604 vec_xstd2(vuc, idx, ptruc);605 // CHECK-ASM: vst606 vec_xstd2(vss, idx, ptrss);607 // CHECK-ASM: vst608 vec_xstd2(vus, idx, ptrus);609 // CHECK-ASM: vst610 vec_xstd2(vsi, idx, ptrsi);611 // CHECK-ASM: vst612 vec_xstd2(vui, idx, ptrui);613 // CHECK-ASM: vst614 vec_xstd2(vsl, idx, ptrsl);615 // CHECK-ASM: vst616 vec_xstd2(vul, idx, ptrul);617 // CHECK-ASM: vst618 vec_xstd2(vd, idx, ptrd);619 // CHECK-ASM: vst620 621 vec_xstw4(vsc, idx, ptrsc);622 // CHECK-ASM: vst623 vec_xstw4(vuc, idx, ptruc);624 // CHECK-ASM: vst625 vec_xstw4(vss, idx, ptrss);626 // CHECK-ASM: vst627 vec_xstw4(vus, idx, ptrus);628 // CHECK-ASM: vst629 vec_xstw4(vsi, idx, ptrsi);630 // CHECK-ASM: vst631 vec_xstw4(vui, idx, ptrui);632 // CHECK-ASM: vst633 634 vsc = vec_load_bndry(cptrsc, 64);635 // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 0)636 // CHECK-ASM: vlbb637 vuc = vec_load_bndry(cptruc, 64);638 // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 0)639 // CHECK-ASM: vlbb640 vss = vec_load_bndry(cptrss, 64);641 // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 0)642 // CHECK-ASM: vlbb643 vus = vec_load_bndry(cptrus, 64);644 // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 0)645 // CHECK-ASM: vlbb646 vsi = vec_load_bndry(cptrsi, 64);647 // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 0)648 // CHECK-ASM: vlbb649 vui = vec_load_bndry(cptrui, 64);650 // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 0)651 // CHECK-ASM: vlbb652 vsl = vec_load_bndry(cptrsl, 64);653 // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 0)654 // CHECK-ASM: vlbb655 vul = vec_load_bndry(cptrul, 64);656 // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 0)657 // CHECK-ASM: vlbb658 vslll = vec_load_bndry(cptrslll, 64);659 // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 0)660 // CHECK-ASM: vlbb661 vulll = vec_load_bndry(cptrulll, 64);662 // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 0)663 // CHECK-ASM: vlbb664 vd = vec_load_bndry(cptrd, 64);665 // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 0)666 // CHECK-ASM: vlbb667 vsc = vec_load_bndry(cptrsc, 128);668 // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 1)669 // CHECK-ASM: vlbb670 vsc = vec_load_bndry(cptrsc, 256);671 // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 2)672 // CHECK-ASM: vlbb673 vsc = vec_load_bndry(cptrsc, 512);674 // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 3)675 // CHECK-ASM: vlbb676 vsc = vec_load_bndry(cptrsc, 1024);677 // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 4)678 // CHECK-ASM: vlbb679 vsc = vec_load_bndry(cptrsc, 2048);680 // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 5)681 // CHECK-ASM: vlbb682 vsc = vec_load_bndry(cptrsc, 4096);683 // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 6)684 // CHECK-ASM: vlbb685 686 vsc = vec_load_len(cptrsc, idx);687 // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, ptr %{{.*}})688 // CHECK-ASM: vll689 vuc = vec_load_len(cptruc, idx);690 // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, ptr %{{.*}})691 // CHECK-ASM: vll692 vss = vec_load_len(cptrss, idx);693 // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, ptr %{{.*}})694 // CHECK-ASM: vll695 vus = vec_load_len(cptrus, idx);696 // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, ptr %{{.*}})697 // CHECK-ASM: vll698 vsi = vec_load_len(cptrsi, idx);699 // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, ptr %{{.*}})700 // CHECK-ASM: vll701 vui = vec_load_len(cptrui, idx);702 // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, ptr %{{.*}})703 // CHECK-ASM: vll704 vsl = vec_load_len(cptrsl, idx);705 // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, ptr %{{.*}})706 // CHECK-ASM: vll707 vul = vec_load_len(cptrul, idx);708 // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, ptr %{{.*}})709 // CHECK-ASM: vll710 vd = vec_load_len(cptrd, idx);711 // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, ptr %{{.*}})712 // CHECK-ASM: vll713 714 vec_store_len(vsc, ptrsc, idx);715 // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, ptr %{{.*}})716 // CHECK-ASM: vstl717 vec_store_len(vuc, ptruc, idx);718 // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, ptr %{{.*}})719 // CHECK-ASM: vstl720 vec_store_len(vss, ptrss, idx);721 // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, ptr %{{.*}})722 // CHECK-ASM: vstl723 vec_store_len(vus, ptrus, idx);724 // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, ptr %{{.*}})725 // CHECK-ASM: vstl726 vec_store_len(vsi, ptrsi, idx);727 // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, ptr %{{.*}})728 // CHECK-ASM: vstl729 vec_store_len(vui, ptrui, idx);730 // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, ptr %{{.*}})731 // CHECK-ASM: vstl732 vec_store_len(vsl, ptrsl, idx);733 // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, ptr %{{.*}})734 // CHECK-ASM: vstl735 vec_store_len(vul, ptrul, idx);736 // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, ptr %{{.*}})737 // CHECK-ASM: vstl738 vec_store_len(vd, ptrd, idx);739 // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, ptr %{{.*}})740 // CHECK-ASM: vstl741 742 vsl = vec_load_pair(sl + 1, sl - 1);743 // CHECK-ASM: vlvgp744 vul = vec_load_pair(ul + 1, ul - 1);745 // CHECK-ASM: vlvgp746 747 vuc = vec_genmask(0);748 // CHECK: <16 x i8> zeroinitializer749 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> zeroinitializer781 // CHECK-ASM: vrepb782 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: vrepb785 vuc = vec_splat(vuc, 0);786 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> poison, <16 x i32> zeroinitializer787 // CHECK-ASM: vrepb788 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: vrepb791 vbc = vec_splat(vbc, 0);792 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> poison, <16 x i32> zeroinitializer793 // CHECK-ASM: vrepb794 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: vrepb797 vss = vec_splat(vss, 0);798 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> poison, <8 x i32> zeroinitializer799 // CHECK-ASM: vreph800 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: vreph803 vus = vec_splat(vus, 0);804 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> poison, <8 x i32> zeroinitializer805 // CHECK-ASM: vreph806 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: vreph809 vbs = vec_splat(vbs, 0);810 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> poison, <8 x i32> zeroinitializer811 // CHECK-ASM: vreph812 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: vreph815 vsi = vec_splat(vsi, 0);816 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> poison, <4 x i32> zeroinitializer817 // CHECK-ASM: vrepf818 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: vrepf821 vui = vec_splat(vui, 0);822 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> poison, <4 x i32> zeroinitializer823 // CHECK-ASM: vrepf824 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: vrepf827 vbi = vec_splat(vbi, 0);828 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> poison, <4 x i32> zeroinitializer829 // CHECK-ASM: vrepf830 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: vrepf833 vsl = vec_splat(vsl, 0);834 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> poison, <2 x i32> zeroinitializer835 // CHECK-ASM: vrepg836 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: vrepg839 vul = vec_splat(vul, 0);840 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> poison, <2 x i32> zeroinitializer841 // CHECK-ASM: vrepg842 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: vrepg845 vbl = vec_splat(vbl, 0);846 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> poison, <2 x i32> zeroinitializer847 // CHECK-ASM: vrepg848 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: vrepg851 vd = vec_splat(vd, 0);852 // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> poison, <2 x i32> zeroinitializer853 // CHECK-ASM: vrepg854 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: vrepg857 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> zeroinitializer893 // CHECK-ASM: vlrepb894 vuc = vec_splats(uc);895 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> poison, <16 x i32> zeroinitializer896 // CHECK-ASM: vlrepb897 vss = vec_splats(ss);898 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> poison, <8 x i32> zeroinitializer899 // CHECK-ASM: vlreph900 vus = vec_splats(us);901 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> poison, <8 x i32> zeroinitializer902 // CHECK-ASM: vlreph903 vsi = vec_splats(si);904 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> poison, <4 x i32> zeroinitializer905 // CHECK-ASM: vlrepf906 vui = vec_splats(ui);907 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> poison, <4 x i32> zeroinitializer908 // CHECK-ASM: vlrepf909 vsl = vec_splats(sl);910 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> poison, <2 x i32> zeroinitializer911 // CHECK-ASM: vlrepg912 vul = vec_splats(ul);913 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> poison, <2 x i32> zeroinitializer914 // CHECK-ASM: vlrepg915 vd = vec_splats(d);916 // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> poison, <2 x i32> zeroinitializer917 // CHECK-ASM: vlrepg918 vslll = vec_splats(slll);919 // CHECK: insertelement <1 x i128> poison, i128 %{{.*}}, i64 0920 vulll = vec_splats(ulll);921 // CHECK: insertelement <1 x i128> poison, i128 %{{.*}}, i64 0922 923 vsl = vec_extend_s64(vsc);924 // CHECK-ASM: vsegb925 vsl = vec_extend_s64(vss);926 // CHECK-ASM: vsegh927 vsl = vec_extend_s64(vsi);928 // CHECK-ASM: vsegf929 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: vmrhb933 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: vmrhb936 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: vmrhb939 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: vmrhh942 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: vmrhh945 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: vmrhh948 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: vmrhf951 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: vmrhf954 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: vmrhf957 vsl = vec_mergeh(vsl, vsl);958 // shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i32> <i32 0, i32 2>959 // CHECK-ASM: vmrhg960 vul = vec_mergeh(vul, vul);961 // shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i32> <i32 0, i32 2>962 // CHECK-ASM: vmrhg963 vbl = vec_mergeh(vbl, vbl);964 // shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i32> <i32 0, i32 2>965 // CHECK-ASM: vmrhg966 vd = vec_mergeh(vd, vd);967 // shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> <i32 0, i32 2>968 // CHECK-ASM: vmrhg969 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: vmrlb973 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: vmrlb976 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: vmrlb979 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: vmrlh982 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: vmrlh985 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: vmrlh988 vsi = vec_mergel(vsi, vsi);989 // shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <i32 2, i32 6, i32 3, i32 7>990 // CHECK-ASM: vmrlf991 vui = vec_mergel(vui, vui);992 // shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <i32 2, i32 6, i32 3, i32 7>993 // CHECK-ASM: vmrlf994 vbi = vec_mergel(vbi, vbi);995 // shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <i32 2, i32 6, i32 3, i32 7>996 // CHECK-ASM: vmrlf997 vsl = vec_mergel(vsl, vsl);998 // shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <i32 1, i32 3>999 // CHECK-ASM: vmrlg1000 vul = vec_mergel(vul, vul);1001 // shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <i32 1, i32 3>1002 // CHECK-ASM: vmrlg1003 vbl = vec_mergel(vbl, vbl);1004 // shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <i32 1, i32 3>1005 // CHECK-ASM: vmrlg1006 vd = vec_mergel(vd, vd);1007 // shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <i32 1, i32 3>1008 // CHECK-ASM: vmrlg1009 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: vpkh1013 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: vpkh1016 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: vpkh1019 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: vpkf1022 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: vpkf1025 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: vpkf1028 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: vpkg1031 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: vpkg1034 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: vpkg1037 vsl = vec_pack(vslll, vslll);1038 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i32> <i32 1, i32 3>1039 // CHECK-ASM: vmrlg1040 vul = vec_pack(vulll, vulll);1041 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i32> <i32 1, i32 3>1042 // CHECK-ASM: vmrlg1043 vbl = vec_pack(vblll, vblll);1044 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i32> <i32 1, i32 3>1045 // CHECK-ASM: vmrlg1046 1047 vsc = vec_packs(vss, vss);1048 // CHECK: call <16 x i8> @llvm.s390.vpksh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})1049 // CHECK-ASM: vpksh1050 vuc = vec_packs(vus, vus);1051 // CHECK: call <16 x i8> @llvm.s390.vpklsh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})1052 // CHECK-ASM: vpklsh1053 vss = vec_packs(vsi, vsi);1054 // CHECK: call <8 x i16> @llvm.s390.vpksf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})1055 // CHECK-ASM: vpksf1056 vus = vec_packs(vui, vui);1057 // CHECK: call <8 x i16> @llvm.s390.vpklsf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})1058 // CHECK-ASM: vpklsf1059 vsi = vec_packs(vsl, vsl);1060 // CHECK: call <4 x i32> @llvm.s390.vpksg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})1061 // CHECK-ASM: vpksg1062 vui = vec_packs(vul, vul);1063 // CHECK: call <4 x i32> @llvm.s390.vpklsg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})1064 // CHECK-ASM: vpklsg1065 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: vpkshs1069 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: vpklshs1072 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: vpksfs1075 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: vpklsfs1078 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: vpksgs1081 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: vpklsgs1084 1085 vuc = vec_packsu(vss, vss);1086 // CHECK: call <16 x i8> @llvm.s390.vpklsh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})1087 // CHECK-ASM: vpklsh1088 vuc = vec_packsu(vus, vus);1089 // CHECK: call <16 x i8> @llvm.s390.vpklsh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})1090 // CHECK-ASM: vpklsh1091 vus = vec_packsu(vsi, vsi);1092 // CHECK: call <8 x i16> @llvm.s390.vpklsf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})1093 // CHECK-ASM: vpklsf1094 vus = vec_packsu(vui, vui);1095 // CHECK: call <8 x i16> @llvm.s390.vpklsf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})1096 // CHECK-ASM: vpklsf1097 vui = vec_packsu(vsl, vsl);1098 // CHECK: call <4 x i32> @llvm.s390.vpklsg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})1099 // CHECK-ASM: vpklsg1100 vui = vec_packsu(vul, vul);1101 // CHECK: call <4 x i32> @llvm.s390.vpklsg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})1102 // CHECK-ASM: vpklsg1103 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: vpklshs1107 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: vpklsfs1110 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: vpklsgs1113 1114 vss = vec_unpackh(vsc);1115 // CHECK: call <8 x i16> @llvm.s390.vuphb(<16 x i8> %{{.*}})1116 // CHECK-ASM: vuphb1117 vus = vec_unpackh(vuc);1118 // CHECK: call <8 x i16> @llvm.s390.vuplhb(<16 x i8> %{{.*}})1119 // CHECK-ASM: vuplhb1120 vbs = vec_unpackh(vbc);1121 // CHECK: call <8 x i16> @llvm.s390.vuphb(<16 x i8> %{{.*}})1122 // CHECK-ASM: vuphb1123 vsi = vec_unpackh(vss);1124 // CHECK: call <4 x i32> @llvm.s390.vuphh(<8 x i16> %{{.*}})1125 // CHECK-ASM: vuphh1126 vui = vec_unpackh(vus);1127 // CHECK: call <4 x i32> @llvm.s390.vuplhh(<8 x i16> %{{.*}})1128 // CHECK-ASM: vuplhh1129 vbi = vec_unpackh(vbs);1130 // CHECK: call <4 x i32> @llvm.s390.vuphh(<8 x i16> %{{.*}})1131 // CHECK-ASM: vuphh1132 vsl = vec_unpackh(vsi);1133 // CHECK: call <2 x i64> @llvm.s390.vuphf(<4 x i32> %{{.*}})1134 // CHECK-ASM: vuphf1135 vul = vec_unpackh(vui);1136 // CHECK: call <2 x i64> @llvm.s390.vuplhf(<4 x i32> %{{.*}})1137 // CHECK-ASM: vuplhf1138 vbl = vec_unpackh(vbi);1139 // CHECK: call <2 x i64> @llvm.s390.vuphf(<4 x i32> %{{.*}})1140 // CHECK-ASM: vuphf1141 1142 vss = vec_unpackl(vsc);1143 // CHECK: call <8 x i16> @llvm.s390.vuplb(<16 x i8> %{{.*}})1144 // CHECK-ASM: vuplb1145 vus = vec_unpackl(vuc);1146 // CHECK: call <8 x i16> @llvm.s390.vupllb(<16 x i8> %{{.*}})1147 // CHECK-ASM: vupllb1148 vbs = vec_unpackl(vbc);1149 // CHECK: call <8 x i16> @llvm.s390.vuplb(<16 x i8> %{{.*}})1150 // CHECK-ASM: vuplb1151 vsi = vec_unpackl(vss);1152 // CHECK: call <4 x i32> @llvm.s390.vuplhw(<8 x i16> %{{.*}})1153 // CHECK-ASM: vuplhw1154 vui = vec_unpackl(vus);1155 // CHECK: call <4 x i32> @llvm.s390.vupllh(<8 x i16> %{{.*}})1156 // CHECK-ASM: vupllh1157 vbi = vec_unpackl(vbs);1158 // CHECK: call <4 x i32> @llvm.s390.vuplhw(<8 x i16> %{{.*}})1159 // CHECK-ASM: vuplhw1160 vsl = vec_unpackl(vsi);1161 // CHECK: call <2 x i64> @llvm.s390.vuplf(<4 x i32> %{{.*}})1162 // CHECK-ASM: vuplf1163 vul = vec_unpackl(vui);1164 // CHECK: call <2 x i64> @llvm.s390.vupllf(<4 x i32> %{{.*}})1165 // CHECK-ASM: vupllf1166 vbl = vec_unpackl(vbi);1167 // CHECK: call <2 x i64> @llvm.s390.vuplf(<4 x i32> %{{.*}})1168 // CHECK-ASM: vuplf1169}1170 1171void test_compare(void) {1172 // CHECK-ASM-LABEL: test_compare1173 1174 vbc = vec_cmpeq(vsc, vsc);1175 // CHECK: icmp eq <16 x i8> %{{.*}}, %{{.*}}1176 // CHECK-ASM: vceqb1177 vbc = vec_cmpeq(vuc, vuc);1178 // CHECK: icmp eq <16 x i8> %{{.*}}, %{{.*}}1179 // CHECK-ASM: vceqb1180 vbc = vec_cmpeq(vbc, vbc);1181 // CHECK: icmp eq <16 x i8> %{{.*}}, %{{.*}}1182 // CHECK-ASM: vceqb1183 vbs = vec_cmpeq(vss, vss);1184 // CHECK: icmp eq <8 x i16> %{{.*}}, %{{.*}}1185 // CHECK-ASM: vceqh1186 vbs = vec_cmpeq(vus, vus);1187 // CHECK: icmp eq <8 x i16> %{{.*}}, %{{.*}}1188 // CHECK-ASM: vceqh1189 vbs = vec_cmpeq(vbs, vbs);1190 // CHECK: icmp eq <8 x i16> %{{.*}}, %{{.*}}1191 // CHECK-ASM: vceqh1192 vbi = vec_cmpeq(vsi, vsi);1193 // CHECK: icmp eq <4 x i32> %{{.*}}, %{{.*}}1194 // CHECK-ASM: vceqf1195 vbi = vec_cmpeq(vui, vui);1196 // CHECK: icmp eq <4 x i32> %{{.*}}, %{{.*}}1197 // CHECK-ASM: vceqf1198 vbi = vec_cmpeq(vbi, vbi);1199 // CHECK: icmp eq <4 x i32> %{{.*}}, %{{.*}}1200 // CHECK-ASM: vceqf1201 vbl = vec_cmpeq(vsl, vsl);1202 // CHECK: icmp eq <2 x i64> %{{.*}}, %{{.*}}1203 // CHECK-ASM: vceqg1204 vbl = vec_cmpeq(vul, vul);1205 // CHECK: icmp eq <2 x i64> %{{.*}}, %{{.*}}1206 // CHECK-ASM: vceqg1207 vbl = vec_cmpeq(vbl, vbl);1208 // CHECK: icmp eq <2 x i64> %{{.*}}, %{{.*}}1209 // CHECK-ASM: vceqg1210 vbl = vec_cmpeq(vd, vd);1211 // CHECK: fcmp oeq <2 x double> %{{.*}}, %{{.*}}1212 // CHECK-ASM: vfcedb1213 1214 vbc = vec_cmpge(vsc, vsc);1215 // CHECK: icmp sge <16 x i8> %{{.*}}, %{{.*}}1216 // CHECK-ASM: vchb1217 vbc = vec_cmpge(vuc, vuc);1218 // CHECK: icmp uge <16 x i8> %{{.*}}, %{{.*}}1219 // CHECK-ASM: vchlb1220 vbs = vec_cmpge(vss, vss);1221 // CHECK: icmp sge <8 x i16> %{{.*}}, %{{.*}}1222 // CHECK-ASM: vchh1223 vbs = vec_cmpge(vus, vus);1224 // CHECK: icmp uge <8 x i16> %{{.*}}, %{{.*}}1225 // CHECK-ASM: vchlh1226 vbi = vec_cmpge(vsi, vsi);1227 // CHECK: icmp sge <4 x i32> %{{.*}}, %{{.*}}1228 // CHECK-ASM: vchf1229 vbi = vec_cmpge(vui, vui);1230 // CHECK: icmp uge <4 x i32> %{{.*}}, %{{.*}}1231 // CHECK-ASM: vchlf1232 vbl = vec_cmpge(vsl, vsl);1233 // CHECK: icmp sge <2 x i64> %{{.*}}, %{{.*}}1234 // CHECK-ASM: vchg1235 vbl = vec_cmpge(vul, vul);1236 // CHECK: icmp uge <2 x i64> %{{.*}}, %{{.*}}1237 // CHECK-ASM: vchlg1238 vbl = vec_cmpge(vd, vd);1239 // CHECK: fcmp oge <2 x double> %{{.*}}, %{{.*}}1240 // CHECK-ASM: vfchedb1241 1242 vbc = vec_cmpgt(vsc, vsc);1243 // CHECK: icmp sgt <16 x i8> %{{.*}}, %{{.*}}1244 // CHECK-ASM: vchb1245 vbc = vec_cmpgt(vuc, vuc);1246 // CHECK: icmp ugt <16 x i8> %{{.*}}, %{{.*}}1247 // CHECK-ASM: vchlb1248 vbs = vec_cmpgt(vss, vss);1249 // CHECK: icmp sgt <8 x i16> %{{.*}}, %{{.*}}1250 // CHECK-ASM: vchh1251 vbs = vec_cmpgt(vus, vus);1252 // CHECK: icmp ugt <8 x i16> %{{.*}}, %{{.*}}1253 // CHECK-ASM: vchlh1254 vbi = vec_cmpgt(vsi, vsi);1255 // CHECK: icmp sgt <4 x i32> %{{.*}}, %{{.*}}1256 // CHECK-ASM: vchf1257 vbi = vec_cmpgt(vui, vui);1258 // CHECK: icmp ugt <4 x i32> %{{.*}}, %{{.*}}1259 // CHECK-ASM: vchlf1260 vbl = vec_cmpgt(vsl, vsl);1261 // CHECK: icmp sgt <2 x i64> %{{.*}}, %{{.*}}1262 // CHECK-ASM: vchg1263 vbl = vec_cmpgt(vul, vul);1264 // CHECK: icmp ugt <2 x i64> %{{.*}}, %{{.*}}1265 // CHECK-ASM: vchlg1266 vbl = vec_cmpgt(vd, vd);1267 // CHECK: fcmp ogt <2 x double> %{{.*}}, %{{.*}}1268 // CHECK-ASM: vfchdb1269 1270 vbc = vec_cmple(vsc, vsc);1271 // CHECK: icmp sle <16 x i8> %{{.*}}, %{{.*}}1272 // CHECK-ASM: vchb1273 vbc = vec_cmple(vuc, vuc);1274 // CHECK: icmp ule <16 x i8> %{{.*}}, %{{.*}}1275 // CHECK-ASM: vchlb1276 vbs = vec_cmple(vss, vss);1277 // CHECK: icmp sle <8 x i16> %{{.*}}, %{{.*}}1278 // CHECK-ASM: vchh1279 vbs = vec_cmple(vus, vus);1280 // CHECK: icmp ule <8 x i16> %{{.*}}, %{{.*}}1281 // CHECK-ASM: vchlh1282 vbi = vec_cmple(vsi, vsi);1283 // CHECK: icmp sle <4 x i32> %{{.*}}, %{{.*}}1284 // CHECK-ASM: vchf1285 vbi = vec_cmple(vui, vui);1286 // CHECK: icmp ule <4 x i32> %{{.*}}, %{{.*}}1287 // CHECK-ASM: vchlf1288 vbl = vec_cmple(vsl, vsl);1289 // CHECK: icmp sle <2 x i64> %{{.*}}, %{{.*}}1290 // CHECK-ASM: vchg1291 vbl = vec_cmple(vul, vul);1292 // CHECK: icmp ule <2 x i64> %{{.*}}, %{{.*}}1293 // CHECK-ASM: vchlg1294 vbl = vec_cmple(vd, vd);1295 // CHECK: fcmp ole <2 x double> %{{.*}}, %{{.*}}1296 // CHECK-ASM: vfchedb1297 1298 vbc = vec_cmplt(vsc, vsc);1299 // CHECK: icmp slt <16 x i8> %{{.*}}, %{{.*}}1300 // CHECK-ASM: vchb1301 vbc = vec_cmplt(vuc, vuc);1302 // CHECK: icmp ult <16 x i8> %{{.*}}, %{{.*}}1303 // CHECK-ASM: vchlb1304 vbs = vec_cmplt(vss, vss);1305 // CHECK: icmp slt <8 x i16> %{{.*}}, %{{.*}}1306 // CHECK-ASM: vchh1307 vbs = vec_cmplt(vus, vus);1308 // CHECK: icmp ult <8 x i16> %{{.*}}, %{{.*}}1309 // CHECK-ASM: vchlh1310 vbi = vec_cmplt(vsi, vsi);1311 // CHECK: icmp slt <4 x i32> %{{.*}}, %{{.*}}1312 // CHECK-ASM: vchf1313 vbi = vec_cmplt(vui, vui);1314 // CHECK: icmp ult <4 x i32> %{{.*}}, %{{.*}}1315 // CHECK-ASM: vchlf1316 vbl = vec_cmplt(vsl, vsl);1317 // CHECK: icmp slt <2 x i64> %{{.*}}, %{{.*}}1318 // CHECK-ASM: vchg1319 vbl = vec_cmplt(vul, vul);1320 // CHECK: icmp ult <2 x i64> %{{.*}}, %{{.*}}1321 // CHECK-ASM: vchlg1322 vbl = vec_cmplt(vd, vd);1323 // CHECK: fcmp olt <2 x double> %{{.*}}, %{{.*}}1324 // CHECK-ASM: vfchdb1325 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: vceqbs1329 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: vceqbs1332 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: vceqbs1335 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: vceqbs1338 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: vceqbs1341 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: vceqbs1344 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: vceqbs1347 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: vceqhs1350 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: vceqhs1353 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: vceqhs1356 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: vceqhs1359 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: vceqhs1362 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: vceqhs1365 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: vceqhs1368 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: vceqfs1371 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: vceqfs1374 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: vceqfs1377 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: vceqfs1380 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: vceqfs1383 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: vceqfs1386 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: vceqfs1389 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: vceqgs1392 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: vceqgs1395 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: vceqgs1398 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: vceqgs1401 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: vceqgs1404 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: vceqgs1407 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: vceqgs1410 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: vfcedbs1413 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: vceqbs1417 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: vceqbs1420 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: vceqbs1423 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: vceqbs1426 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: vceqbs1429 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: vceqbs1432 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: vceqbs1435 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: vceqhs1438 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: vceqhs1441 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: vceqhs1444 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: vceqhs1447 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: vceqhs1450 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: vceqhs1453 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: vceqhs1456 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: vceqfs1459 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: vceqfs1462 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: vceqfs1465 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: vceqfs1468 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: vceqfs1471 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: vceqfs1474 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: vceqfs1477 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: vceqgs1480 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: vceqgs1483 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: vceqgs1486 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: vceqgs1489 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: vceqgs1492 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: vceqgs1495 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: vceqgs1498 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: vfcedbs1501 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: vchbs1505 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: vchbs1508 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: vchbs1511 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: vchlbs1514 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: vchlbs1517 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: vchlbs1520 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: vchlbs1523 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: vchhs1526 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: vchhs1529 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: vchhs1532 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: vchlhs1535 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: vchlhs1538 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: vchlhs1541 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: vchlhs1544 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: vchfs1547 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: vchfs1550 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: vchfs1553 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: vchlfs1556 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: vchlfs1559 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: vchlfs1562 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: vchlfs1565 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: vchgs1568 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: vchgs1571 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: vchgs1574 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: vchlgs1577 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: vchlgs1580 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: vchlgs1583 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: vchlgs1586 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: vfchedbs1589 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: vchbs1593 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: vchbs1596 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: vchbs1599 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: vchlbs1602 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: vchlbs1605 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: vchlbs1608 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: vchlbs1611 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: vchhs1614 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: vchhs1617 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: vchhs1620 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: vchlhs1623 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: vchlhs1626 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: vchlhs1629 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: vchlhs1632 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: vchfs1635 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: vchfs1638 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: vchfs1641 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: vchlfs1644 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: vchlfs1647 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: vchlfs1650 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: vchlfs1653 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: vchgs1656 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: vchgs1659 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: vchgs1662 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: vchlgs1665 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: vchlgs1668 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: vchlgs1671 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: vchlgs1674 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: vfchdbs1677 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: vchbs1681 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: vchbs1684 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: vchbs1687 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: vchlbs1690 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: vchlbs1693 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: vchlbs1696 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: vchlbs1699 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: vchhs1702 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: vchhs1705 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: vchhs1708 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: vchlhs1711 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: vchlhs1714 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: vchlhs1717 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: vchlhs1720 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: vchfs1723 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: vchfs1726 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: vchfs1729 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: vchlfs1732 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: vchlfs1735 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: vchlfs1738 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: vchlfs1741 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: vchgs1744 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: vchgs1747 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: vchgs1750 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: vchlgs1753 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: vchlgs1756 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: vchlgs1759 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: vchlgs1762 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: vfchedbs1765 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: vchbs1769 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: vchbs1772 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: vchbs1775 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: vchlbs1778 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: vchlbs1781 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: vchlbs1784 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: vchlbs1787 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: vchhs1790 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: vchhs1793 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: vchhs1796 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: vchlhs1799 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: vchlhs1802 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: vchlhs1805 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: vchlhs1808 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: vchfs1811 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: vchfs1814 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: vchfs1817 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: vchlfs1820 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: vchlfs1823 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: vchlfs1826 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: vchlfs1829 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: vchgs1832 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: vchgs1835 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: vchgs1838 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: vchlgs1841 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: vchlgs1844 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: vchlgs1847 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: vchlgs1850 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: vfchdbs1853 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: vfchedbs1857 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: vfchdbs1860 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: vfchedbs1863 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: vfchdbs1866 1867 idx = vec_all_nan(vd);1868 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)1869 // CHECK-ASM: vftcidb1870 idx = vec_all_numeric(vd);1871 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)1872 // CHECK-ASM: vftcidb1873 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: vceqbs1877 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: vceqbs1880 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: vceqbs1883 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: vceqbs1886 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: vceqbs1889 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: vceqbs1892 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: vceqbs1895 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: vceqhs1898 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: vceqhs1901 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: vceqhs1904 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: vceqhs1907 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: vceqhs1910 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: vceqhs1913 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: vceqhs1916 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: vceqfs1919 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: vceqfs1922 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: vceqfs1925 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: vceqfs1928 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: vceqfs1931 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: vceqfs1934 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: vceqfs1937 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: vceqgs1940 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: vceqgs1943 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: vceqgs1946 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: vceqgs1949 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: vceqgs1952 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: vceqgs1955 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: vceqgs1958 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: vfcedbs1961 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: vceqbs1965 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: vceqbs1968 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: vceqbs1971 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: vceqbs1974 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: vceqbs1977 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: vceqbs1980 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: vceqbs1983 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: vceqhs1986 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: vceqhs1989 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: vceqhs1992 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: vceqhs1995 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: vceqhs1998 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: vceqhs2001 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: vceqhs2004 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: vceqfs2007 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: vceqfs2010 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: vceqfs2013 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: vceqfs2016 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: vceqfs2019 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: vceqfs2022 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: vceqfs2025 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: vceqgs2028 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: vceqgs2031 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: vceqgs2034 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: vceqgs2037 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: vceqgs2040 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: vceqgs2043 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: vceqgs2046 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: vfcedbs2049 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: vchbs2053 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: vchbs2056 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: vchbs2059 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: vchlbs2062 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: vchlbs2065 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: vchlbs2068 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: vchlbs2071 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: vchhs2074 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: vchhs2077 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: vchhs2080 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: vchlhs2083 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: vchlhs2086 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: vchlhs2089 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: vchlhs2092 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: vchfs2095 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: vchfs2098 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: vchfs2101 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: vchlfs2104 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: vchlfs2107 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: vchlfs2110 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: vchlfs2113 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: vchgs2116 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: vchgs2119 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: vchgs2122 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: vchlgs2125 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: vchlgs2128 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: vchlgs2131 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: vchlgs2134 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: vfchedbs2137 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: vchbs2141 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: vchbs2144 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: vchbs2147 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: vchlbs2150 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: vchlbs2153 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: vchlbs2156 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: vchlbs2159 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: vchhs2162 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: vchhs2165 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: vchhs2168 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: vchlhs2171 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: vchlhs2174 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: vchlhs2177 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: vchlhs2180 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: vchfs2183 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: vchfs2186 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: vchfs2189 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: vchlfs2192 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: vchlfs2195 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: vchlfs2198 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: vchlfs2201 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: vchgs2204 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: vchgs2207 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: vchgs2210 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: vchlgs2213 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: vchlgs2216 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: vchlgs2219 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: vchlgs2222 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: vfchdbs2225 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: vchbs2229 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: vchbs2232 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: vchbs2235 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: vchlbs2238 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: vchlbs2241 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: vchlbs2244 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: vchlbs2247 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: vchhs2250 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: vchhs2253 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: vchhs2256 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: vchlhs2259 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: vchlhs2262 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: vchlhs2265 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: vchlhs2268 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: vchfs2271 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: vchfs2274 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: vchfs2277 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: vchlfs2280 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: vchlfs2283 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: vchlfs2286 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: vchlfs2289 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: vchgs2292 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: vchgs2295 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: vchgs2298 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: vchlgs2301 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: vchlgs2304 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: vchlgs2307 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: vchlgs2310 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: vfchedbs2313 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: vchbs2317 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: vchbs2320 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: vchbs2323 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: vchlbs2326 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: vchlbs2329 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: vchlbs2332 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: vchlbs2335 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: vchhs2338 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: vchhs2341 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: vchhs2344 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: vchlhs2347 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: vchlhs2350 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: vchlhs2353 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: vchlhs2356 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: vchfs2359 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: vchfs2362 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: vchfs2365 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: vchlfs2368 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: vchlfs2371 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: vchlfs2374 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: vchlfs2377 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: vchgs2380 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: vchgs2383 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: vchgs2386 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: vchlgs2389 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: vchlgs2392 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: vchlgs2395 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: vchlgs2398 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: vfchdbs2401 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: vfchedbs2405 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: vfchdbs2408 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: vfchedbs2411 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: vfchdbs2414 2415 idx = vec_any_nan(vd);2416 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)2417 // CHECK-ASM: vftcidb2418 idx = vec_any_numeric(vd);2419 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15)2420 // CHECK-ASM: vftcidb2421}2422 2423void test_integer(void) {2424 // CHECK-ASM-LABEL: test_integer2425 2426 vsc = vec_and(vsc, vsc);2427 // CHECK-ASM: vn2428 vuc = vec_and(vuc, vuc);2429 // CHECK-ASM: vn2430 vbc = vec_and(vbc, vbc);2431 // CHECK-ASM: vn2432 vss = vec_and(vss, vss);2433 // CHECK-ASM: vn2434 vus = vec_and(vus, vus);2435 // CHECK-ASM: vn2436 vbs = vec_and(vbs, vbs);2437 // CHECK-ASM: vn2438 vsi = vec_and(vsi, vsi);2439 // CHECK-ASM: vn2440 vui = vec_and(vui, vui);2441 // CHECK-ASM: vn2442 vbi = vec_and(vbi, vbi);2443 // CHECK-ASM: vn2444 vsl = vec_and(vsl, vsl);2445 // CHECK-ASM: vn2446 vul = vec_and(vul, vul);2447 // CHECK-ASM: vn2448 vbl = vec_and(vbl, vbl);2449 // CHECK-ASM: vn2450 vslll = vec_and(vslll, vslll);2451 // CHECK-ASM: vn2452 vulll = vec_and(vulll, vulll);2453 // CHECK-ASM: vn2454 vblll = vec_and(vblll, vblll);2455 // CHECK-ASM: vn2456 vd = vec_and(vd, vd);2457 // CHECK-ASM: vn2458 2459 vsc = vec_or(vsc, vsc);2460 // CHECK-ASM: vo2461 vuc = vec_or(vuc, vuc);2462 // CHECK-ASM: vo2463 vbc = vec_or(vbc, vbc);2464 // CHECK-ASM: vo2465 vss = vec_or(vss, vss);2466 // CHECK-ASM: vo2467 vus = vec_or(vus, vus);2468 // CHECK-ASM: vo2469 vbs = vec_or(vbs, vbs);2470 // CHECK-ASM: vo2471 vsi = vec_or(vsi, vsi);2472 // CHECK-ASM: vo2473 vui = vec_or(vui, vui);2474 // CHECK-ASM: vo2475 vbi = vec_or(vbi, vbi);2476 // CHECK-ASM: vo2477 vsl = vec_or(vsl, vsl);2478 // CHECK-ASM: vo2479 vul = vec_or(vul, vul);2480 // CHECK-ASM: vo2481 vbl = vec_or(vbl, vbl);2482 // CHECK-ASM: vo2483 vslll = vec_or(vslll, vslll);2484 // CHECK-ASM: vo2485 vulll = vec_or(vulll, vulll);2486 // CHECK-ASM: vo2487 vblll = vec_or(vblll, vblll);2488 // CHECK-ASM: vo2489 vd = vec_or(vd, vd);2490 // CHECK-ASM: vo2491 2492 vsc = vec_xor(vsc, vsc);2493 // CHECK-ASM: vx2494 vuc = vec_xor(vuc, vuc);2495 // CHECK-ASM: vx2496 vbc = vec_xor(vbc, vbc);2497 // CHECK-ASM: vx2498 vss = vec_xor(vss, vss);2499 // CHECK-ASM: vx2500 vus = vec_xor(vus, vus);2501 // CHECK-ASM: vx2502 vbs = vec_xor(vbs, vbs);2503 // CHECK-ASM: vx2504 vsi = vec_xor(vsi, vsi);2505 // CHECK-ASM: vx2506 vui = vec_xor(vui, vui);2507 // CHECK-ASM: vx2508 vbi = vec_xor(vbi, vbi);2509 // CHECK-ASM: vx2510 vsl = vec_xor(vsl, vsl);2511 // CHECK-ASM: vx2512 vul = vec_xor(vul, vul);2513 // CHECK-ASM: vx2514 vbl = vec_xor(vbl, vbl);2515 // CHECK-ASM: vx2516 vslll = vec_xor(vslll, vslll);2517 // CHECK-ASM: vx2518 vulll = vec_xor(vulll, vulll);2519 // CHECK-ASM: vx2520 vblll = vec_xor(vblll, vblll);2521 // CHECK-ASM: vx2522 vd = vec_xor(vd, vd);2523 // CHECK-ASM: vx2524 2525 vsc = vec_andc(vsc, vsc);2526 // CHECK-ASM: vnc2527 vsc = vec_andc(vsc, vbc);2528 // CHECK-ASM: vnc2529 vsc = vec_andc(vbc, vsc);2530 // CHECK-ASM: vnc2531 vuc = vec_andc(vuc, vuc);2532 // CHECK-ASM: vnc2533 vuc = vec_andc(vuc, vbc);2534 // CHECK-ASM: vnc2535 vuc = vec_andc(vbc, vuc);2536 // CHECK-ASM: vnc2537 vbc = vec_andc(vbc, vbc);2538 // CHECK-ASM: vnc2539 vss = vec_andc(vss, vss);2540 // CHECK-ASM: vnc2541 vss = vec_andc(vss, vbs);2542 // CHECK-ASM: vnc2543 vss = vec_andc(vbs, vss);2544 // CHECK-ASM: vnc2545 vus = vec_andc(vus, vus);2546 // CHECK-ASM: vnc2547 vus = vec_andc(vus, vbs);2548 // CHECK-ASM: vnc2549 vus = vec_andc(vbs, vus);2550 // CHECK-ASM: vnc2551 vbs = vec_andc(vbs, vbs);2552 // CHECK-ASM: vnc2553 vsi = vec_andc(vsi, vsi);2554 // CHECK-ASM: vnc2555 vsi = vec_andc(vsi, vbi);2556 // CHECK-ASM: vnc2557 vsi = vec_andc(vbi, vsi);2558 // CHECK-ASM: vnc2559 vui = vec_andc(vui, vui);2560 // CHECK-ASM: vnc2561 vui = vec_andc(vui, vbi);2562 // CHECK-ASM: vnc2563 vui = vec_andc(vbi, vui);2564 // CHECK-ASM: vnc2565 vbi = vec_andc(vbi, vbi);2566 // CHECK-ASM: vnc2567 vsl = vec_andc(vsl, vsl);2568 // CHECK-ASM: vnc2569 vsl = vec_andc(vsl, vbl);2570 // CHECK-ASM: vnc2571 vsl = vec_andc(vbl, vsl);2572 // CHECK-ASM: vnc2573 vul = vec_andc(vul, vul);2574 // CHECK-ASM: vnc2575 vul = vec_andc(vul, vbl);2576 // CHECK-ASM: vnc2577 vul = vec_andc(vbl, vul);2578 // CHECK-ASM: vnc2579 vbl = vec_andc(vbl, vbl);2580 // CHECK-ASM: vnc2581 vslll = vec_andc(vslll, vslll);2582 // CHECK-ASM: vnc2583 vulll = vec_andc(vulll, vulll);2584 // CHECK-ASM: vnc2585 vblll = vec_andc(vblll, vblll);2586 // CHECK-ASM: vnc2587 vd = vec_andc(vd, vd);2588 // CHECK-ASM: vnc2589 vd = vec_andc(vd, vbl);2590 // CHECK-ASM: vnc2591 vd = vec_andc(vbl, vd);2592 // CHECK-ASM: vnc2593 2594 vsc = vec_nor(vsc, vsc);2595 // CHECK-ASM: vno2596 vsc = vec_nor(vsc, vbc);2597 // CHECK-ASM: vno2598 vsc = vec_nor(vbc, vsc);2599 // CHECK-ASM: vno2600 vuc = vec_nor(vuc, vuc);2601 // CHECK-ASM: vno2602 vuc = vec_nor(vuc, vbc);2603 // CHECK-ASM: vno2604 vuc = vec_nor(vbc, vuc);2605 // CHECK-ASM: vno2606 vbc = vec_nor(vbc, vbc);2607 // CHECK-ASM: vno2608 vss = vec_nor(vss, vss);2609 // CHECK-ASM: vno2610 vss = vec_nor(vss, vbs);2611 // CHECK-ASM: vno2612 vss = vec_nor(vbs, vss);2613 // CHECK-ASM: vno2614 vus = vec_nor(vus, vus);2615 // CHECK-ASM: vno2616 vus = vec_nor(vus, vbs);2617 // CHECK-ASM: vno2618 vus = vec_nor(vbs, vus);2619 // CHECK-ASM: vno2620 vbs = vec_nor(vbs, vbs);2621 // CHECK-ASM: vno2622 vsi = vec_nor(vsi, vsi);2623 // CHECK-ASM: vno2624 vsi = vec_nor(vsi, vbi);2625 // CHECK-ASM: vno2626 vsi = vec_nor(vbi, vsi);2627 // CHECK-ASM: vno2628 vui = vec_nor(vui, vui);2629 // CHECK-ASM: vno2630 vui = vec_nor(vui, vbi);2631 // CHECK-ASM: vno2632 vui = vec_nor(vbi, vui);2633 // CHECK-ASM: vno2634 vbi = vec_nor(vbi, vbi);2635 // CHECK-ASM: vno2636 vsl = vec_nor(vsl, vsl);2637 // CHECK-ASM: vno2638 vsl = vec_nor(vsl, vbl);2639 // CHECK-ASM: vno2640 vsl = vec_nor(vbl, vsl);2641 // CHECK-ASM: vno2642 vul = vec_nor(vul, vul);2643 // CHECK-ASM: vno2644 vul = vec_nor(vul, vbl);2645 // CHECK-ASM: vno2646 vul = vec_nor(vbl, vul);2647 // CHECK-ASM: vno2648 vbl = vec_nor(vbl, vbl);2649 // CHECK-ASM: vno2650 vslll = vec_nor(vslll, vslll);2651 // CHECK-ASM: vno2652 vulll = vec_nor(vulll, vulll);2653 // CHECK-ASM: vno2654 vblll = vec_nor(vblll, vblll);2655 // CHECK-ASM: vno2656 vd = vec_nor(vd, vd);2657 // CHECK-ASM: vno2658 vd = vec_nor(vd, vbl);2659 // CHECK-ASM: vno2660 vd = vec_nor(vbl, vd);2661 // CHECK-ASM: vno2662 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: vclzb2666 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: vclzb2669 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: vclzh2672 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: vclzh2675 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: vclzf2678 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: vclzf2681 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: vclzg2684 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: vclzg2687 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: vctzb2691 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: vctzb2694 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: vctzh2697 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: vctzh2700 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: vctzf2703 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: vctzf2706 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: vctzg2709 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: vctzg2712 2713 vuc = vec_popcnt(vsc);2714 // CHECK: call range(i8 0, 9) <16 x i8> @llvm.ctpop.v16i8(<16 x i8> %{{.*}})2715 // CHECK-ASM: vpopct2716 vuc = vec_popcnt(vuc);2717 // CHECK: call range(i8 0, 9) <16 x i8> @llvm.ctpop.v16i8(<16 x i8> %{{.*}})2718 // CHECK-ASM: vpopct2719 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: verllvb2741 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: verllvb2744 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: verllvh2747 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: verllvh2750 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: verllvf2753 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: verllvf2756 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: verllvg2759 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: verllvg2762 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: verllb2766 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: verllb2769 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: verllh2772 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: verllh2775 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: verllf2778 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: verllf2781 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: verllg2784 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: verllg2787 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: verimb2791 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: verimb2794 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: verimb2797 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: verimb2800 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: verimh2803 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: verimh2806 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: verimh2809 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: verimh2812 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: verimf2815 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: verimf2818 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: verimf2821 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: verimf2824 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: verimg2827 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: verimg2830 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: verimg2833 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: verimg2836 2837 vsc = vec_sll(vsc, vuc);2838 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2839 // CHECK-ASM: vsl2840 vsc = vec_sll(vsc, vus);2841 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2842 // CHECK-ASM: vsl2843 vsc = vec_sll(vsc, vui);2844 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2845 // CHECK-ASM: vsl2846 vuc = vec_sll(vuc, vuc);2847 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2848 // CHECK-ASM: vsl2849 vuc = vec_sll(vuc, vus);2850 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2851 // CHECK-ASM: vsl2852 vuc = vec_sll(vuc, vui);2853 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2854 // CHECK-ASM: vsl2855 vbc = vec_sll(vbc, vuc);2856 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2857 // CHECK-ASM: vsl2858 vbc = vec_sll(vbc, vus);2859 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2860 // CHECK-ASM: vsl2861 vbc = vec_sll(vbc, vui);2862 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2863 // CHECK-ASM: vsl2864 vss = vec_sll(vss, vuc);2865 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2866 // CHECK-ASM: vsl2867 vss = vec_sll(vss, vus);2868 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2869 // CHECK-ASM: vsl2870 vss = vec_sll(vss, vui);2871 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2872 // CHECK-ASM: vsl2873 vus = vec_sll(vus, vuc);2874 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2875 // CHECK-ASM: vsl2876 vus = vec_sll(vus, vus);2877 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2878 // CHECK-ASM: vsl2879 vus = vec_sll(vus, vui);2880 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2881 // CHECK-ASM: vsl2882 vbs = vec_sll(vbs, vuc);2883 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2884 // CHECK-ASM: vsl2885 vbs = vec_sll(vbs, vus);2886 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2887 // CHECK-ASM: vsl2888 vbs = vec_sll(vbs, vui);2889 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2890 // CHECK-ASM: vsl2891 vsi = vec_sll(vsi, vuc);2892 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2893 // CHECK-ASM: vsl2894 vsi = vec_sll(vsi, vus);2895 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2896 // CHECK-ASM: vsl2897 vsi = vec_sll(vsi, vui);2898 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2899 // CHECK-ASM: vsl2900 vui = vec_sll(vui, vuc);2901 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2902 // CHECK-ASM: vsl2903 vui = vec_sll(vui, vus);2904 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2905 // CHECK-ASM: vsl2906 vui = vec_sll(vui, vui);2907 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2908 // CHECK-ASM: vsl2909 vbi = vec_sll(vbi, vuc);2910 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2911 // CHECK-ASM: vsl2912 vbi = vec_sll(vbi, vus);2913 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2914 // CHECK-ASM: vsl2915 vbi = vec_sll(vbi, vui);2916 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2917 // CHECK-ASM: vsl2918 vsl = vec_sll(vsl, vuc);2919 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2920 // CHECK-ASM: vsl2921 vsl = vec_sll(vsl, vus);2922 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2923 // CHECK-ASM: vsl2924 vsl = vec_sll(vsl, vui);2925 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2926 // CHECK-ASM: vsl2927 vul = vec_sll(vul, vuc);2928 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2929 // CHECK-ASM: vsl2930 vul = vec_sll(vul, vus);2931 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2932 // CHECK-ASM: vsl2933 vul = vec_sll(vul, vui);2934 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2935 // CHECK-ASM: vsl2936 vbl = vec_sll(vbl, vuc);2937 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2938 // CHECK-ASM: vsl2939 vbl = vec_sll(vbl, vus);2940 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2941 // CHECK-ASM: vsl2942 vbl = vec_sll(vbl, vui);2943 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2944 // CHECK-ASM: vsl2945 vslll = vec_sll(vslll, vuc);2946 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2947 // CHECK-ASM: vsl2948 vulll = vec_sll(vulll, vuc);2949 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2950 // CHECK-ASM: vsl2951 2952 vsc = vec_slb(vsc, vsc);2953 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2954 // CHECK-ASM: vslb2955 vsc = vec_slb(vsc, vuc);2956 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2957 // CHECK-ASM: vslb2958 vuc = vec_slb(vuc, vsc);2959 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2960 // CHECK-ASM: vslb2961 vuc = vec_slb(vuc, vuc);2962 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2963 // CHECK-ASM: vslb2964 vss = vec_slb(vss, vss);2965 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2966 // CHECK-ASM: vslb2967 vss = vec_slb(vss, vus);2968 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2969 // CHECK-ASM: vslb2970 vss = vec_slb(vss, vuc);2971 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2972 // CHECK-ASM: vslb2973 vus = vec_slb(vus, vss);2974 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2975 // CHECK-ASM: vslb2976 vus = vec_slb(vus, vus);2977 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2978 // CHECK-ASM: vslb2979 vus = vec_slb(vus, vuc);2980 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2981 // CHECK-ASM: vslb2982 vsi = vec_slb(vsi, vsi);2983 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2984 // CHECK-ASM: vslb2985 vsi = vec_slb(vsi, vui);2986 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2987 // CHECK-ASM: vslb2988 vsi = vec_slb(vsi, vuc);2989 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2990 // CHECK-ASM: vslb2991 vui = vec_slb(vui, vsi);2992 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2993 // CHECK-ASM: vslb2994 vui = vec_slb(vui, vui);2995 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2996 // CHECK-ASM: vslb2997 vui = vec_slb(vui, vuc);2998 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})2999 // CHECK-ASM: vslb3000 vsl = vec_slb(vsl, vsl);3001 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3002 // CHECK-ASM: vslb3003 vsl = vec_slb(vsl, vul);3004 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3005 // CHECK-ASM: vslb3006 vsl = vec_slb(vsl, vuc);3007 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3008 // CHECK-ASM: vslb3009 vul = vec_slb(vul, vsl);3010 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3011 // CHECK-ASM: vslb3012 vul = vec_slb(vul, vul);3013 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3014 // CHECK-ASM: vslb3015 vul = vec_slb(vul, vuc);3016 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3017 // CHECK-ASM: vslb3018 vslll = vec_slb(vslll, vuc);3019 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3020 // CHECK-ASM: vslb3021 vulll = vec_slb(vulll, vuc);3022 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3023 // CHECK-ASM: vslb3024 vd = vec_slb(vd, vsl);3025 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3026 // CHECK-ASM: vslb3027 vd = vec_slb(vd, vul);3028 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3029 // CHECK-ASM: vslb3030 vd = vec_slb(vd, vuc);3031 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3032 // CHECK-ASM: vslb3033 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: vsldb3037 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: vsldb3040 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: vsldb3043 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: vsldb3046 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: vsldb3049 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: vsldb3052 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: vsldb3055 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: vsldb3058 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: vsldb3061 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: vsldb3064 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: vsldb3067 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: vsldb3070 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: vsldb3073 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: vsldb3076 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: vsldb3079 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: vsldb3082 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: vsldb3085 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: vsldb3088 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: vsldb3091 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: vsldb3094 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: vsldb3097 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: vsldb3100 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: vsldb3103 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: vsldb3106 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: vsldb3109 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: vsldb3112 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: vsldb3115 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: vsldb3118 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: vsldb3121 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: vsldb3124 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: vsldb3128 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: vsldb3131 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: vsldb3134 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: vsldb3137 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: vsldb3140 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: vsldb3143 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: vsldb3146 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: vsldb3149 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: vsldb3152 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: vsldb3155 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: vsldb3158 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: vsldb3161 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: vsldb3164 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: vsldb3167 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: vsldb3170 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: vsldb3173 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: vsldb3176 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: vsldb3179 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: vsldb3182 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: vsldb3185 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: vsldb3188 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: vsldb3191 3192 vsc = vec_sral(vsc, vuc);3193 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3194 // CHECK-ASM: vsra3195 vsc = vec_sral(vsc, vus);3196 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3197 // CHECK-ASM: vsra3198 vsc = vec_sral(vsc, vui);3199 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3200 // CHECK-ASM: vsra3201 vuc = vec_sral(vuc, vuc);3202 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3203 // CHECK-ASM: vsra3204 vuc = vec_sral(vuc, vus);3205 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3206 // CHECK-ASM: vsra3207 vuc = vec_sral(vuc, vui);3208 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3209 // CHECK-ASM: vsra3210 vbc = vec_sral(vbc, vuc);3211 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3212 // CHECK-ASM: vsra3213 vbc = vec_sral(vbc, vus);3214 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3215 // CHECK-ASM: vsra3216 vbc = vec_sral(vbc, vui);3217 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3218 // CHECK-ASM: vsra3219 vss = vec_sral(vss, vuc);3220 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3221 // CHECK-ASM: vsra3222 vss = vec_sral(vss, vus);3223 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3224 // CHECK-ASM: vsra3225 vss = vec_sral(vss, vui);3226 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3227 // CHECK-ASM: vsra3228 vus = vec_sral(vus, vuc);3229 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3230 // CHECK-ASM: vsra3231 vus = vec_sral(vus, vus);3232 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3233 // CHECK-ASM: vsra3234 vus = vec_sral(vus, vui);3235 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3236 // CHECK-ASM: vsra3237 vbs = vec_sral(vbs, vuc);3238 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3239 // CHECK-ASM: vsra3240 vbs = vec_sral(vbs, vus);3241 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3242 // CHECK-ASM: vsra3243 vbs = vec_sral(vbs, vui);3244 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3245 // CHECK-ASM: vsra3246 vsi = vec_sral(vsi, vuc);3247 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3248 // CHECK-ASM: vsra3249 vsi = vec_sral(vsi, vus);3250 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3251 // CHECK-ASM: vsra3252 vsi = vec_sral(vsi, vui);3253 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3254 // CHECK-ASM: vsra3255 vui = vec_sral(vui, vuc);3256 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3257 // CHECK-ASM: vsra3258 vui = vec_sral(vui, vus);3259 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3260 // CHECK-ASM: vsra3261 vui = vec_sral(vui, vui);3262 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3263 // CHECK-ASM: vsra3264 vbi = vec_sral(vbi, vuc);3265 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3266 // CHECK-ASM: vsra3267 vbi = vec_sral(vbi, vus);3268 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3269 // CHECK-ASM: vsra3270 vbi = vec_sral(vbi, vui);3271 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3272 // CHECK-ASM: vsra3273 vsl = vec_sral(vsl, vuc);3274 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3275 // CHECK-ASM: vsra3276 vsl = vec_sral(vsl, vus);3277 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3278 // CHECK-ASM: vsra3279 vsl = vec_sral(vsl, vui);3280 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3281 // CHECK-ASM: vsra3282 vul = vec_sral(vul, vuc);3283 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3284 // CHECK-ASM: vsra3285 vul = vec_sral(vul, vus);3286 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3287 // CHECK-ASM: vsra3288 vul = vec_sral(vul, vui);3289 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3290 // CHECK-ASM: vsra3291 vbl = vec_sral(vbl, vuc);3292 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3293 // CHECK-ASM: vsra3294 vbl = vec_sral(vbl, vus);3295 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3296 // CHECK-ASM: vsra3297 vbl = vec_sral(vbl, vui);3298 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3299 // CHECK-ASM: vsra3300 vslll = vec_sral(vslll, vuc);3301 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3302 // CHECK-ASM: vsra3303 vulll = vec_sral(vulll, vuc);3304 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3305 // CHECK-ASM: vsra3306 3307 vsc = vec_srab(vsc, vsc);3308 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3309 // CHECK-ASM: vsrab3310 vsc = vec_srab(vsc, vuc);3311 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3312 // CHECK-ASM: vsrab3313 vuc = vec_srab(vuc, vsc);3314 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3315 // CHECK-ASM: vsrab3316 vuc = vec_srab(vuc, vuc);3317 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3318 // CHECK-ASM: vsrab3319 vss = vec_srab(vss, vss);3320 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3321 // CHECK-ASM: vsrab3322 vss = vec_srab(vss, vus);3323 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3324 // CHECK-ASM: vsrab3325 vss = vec_srab(vss, vuc);3326 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3327 // CHECK-ASM: vsrab3328 vus = vec_srab(vus, vss);3329 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3330 // CHECK-ASM: vsrab3331 vus = vec_srab(vus, vus);3332 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3333 // CHECK-ASM: vsrab3334 vus = vec_srab(vus, vuc);3335 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3336 // CHECK-ASM: vsrab3337 vsi = vec_srab(vsi, vsi);3338 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3339 // CHECK-ASM: vsrab3340 vsi = vec_srab(vsi, vui);3341 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3342 // CHECK-ASM: vsrab3343 vsi = vec_srab(vsi, vuc);3344 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3345 // CHECK-ASM: vsrab3346 vui = vec_srab(vui, vsi);3347 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3348 // CHECK-ASM: vsrab3349 vui = vec_srab(vui, vui);3350 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3351 // CHECK-ASM: vsrab3352 vui = vec_srab(vui, vuc);3353 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3354 // CHECK-ASM: vsrab3355 vsl = vec_srab(vsl, vsl);3356 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3357 // CHECK-ASM: vsrab3358 vsl = vec_srab(vsl, vul);3359 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3360 // CHECK-ASM: vsrab3361 vsl = vec_srab(vsl, vuc);3362 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3363 // CHECK-ASM: vsrab3364 vul = vec_srab(vul, vsl);3365 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3366 // CHECK-ASM: vsrab3367 vul = vec_srab(vul, vul);3368 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3369 // CHECK-ASM: vsrab3370 vul = vec_srab(vul, vuc);3371 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3372 // CHECK-ASM: vsrab3373 vslll = vec_srab(vslll, vuc);3374 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3375 // CHECK-ASM: vsrab3376 vulll = vec_srab(vulll, vuc);3377 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3378 // CHECK-ASM: vsrab3379 vd = vec_srab(vd, vsl);3380 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3381 // CHECK-ASM: vsrab3382 vd = vec_srab(vd, vul);3383 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3384 // CHECK-ASM: vsrab3385 vd = vec_srab(vd, vuc);3386 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3387 // CHECK-ASM: vsrab3388 3389 vsc = vec_srl(vsc, vuc);3390 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3391 // CHECK-ASM: vsrl3392 vsc = vec_srl(vsc, vus);3393 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3394 // CHECK-ASM: vsrl3395 vsc = vec_srl(vsc, vui);3396 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3397 // CHECK-ASM: vsrl3398 vuc = vec_srl(vuc, vuc);3399 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3400 // CHECK-ASM: vsrl3401 vuc = vec_srl(vuc, vus);3402 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3403 // CHECK-ASM: vsrl3404 vuc = vec_srl(vuc, vui);3405 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3406 // CHECK-ASM: vsrl3407 vbc = vec_srl(vbc, vuc);3408 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3409 // CHECK-ASM: vsrl3410 vbc = vec_srl(vbc, vus);3411 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3412 // CHECK-ASM: vsrl3413 vbc = vec_srl(vbc, vui);3414 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3415 // CHECK-ASM: vsrl3416 vss = vec_srl(vss, vuc);3417 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3418 // CHECK-ASM: vsrl3419 vss = vec_srl(vss, vus);3420 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3421 // CHECK-ASM: vsrl3422 vss = vec_srl(vss, vui);3423 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3424 // CHECK-ASM: vsrl3425 vus = vec_srl(vus, vuc);3426 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3427 // CHECK-ASM: vsrl3428 vus = vec_srl(vus, vus);3429 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3430 // CHECK-ASM: vsrl3431 vus = vec_srl(vus, vui);3432 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3433 // CHECK-ASM: vsrl3434 vbs = vec_srl(vbs, vuc);3435 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3436 // CHECK-ASM: vsrl3437 vbs = vec_srl(vbs, vus);3438 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3439 // CHECK-ASM: vsrl3440 vbs = vec_srl(vbs, vui);3441 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3442 // CHECK-ASM: vsrl3443 vsi = vec_srl(vsi, vuc);3444 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3445 // CHECK-ASM: vsrl3446 vsi = vec_srl(vsi, vus);3447 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3448 // CHECK-ASM: vsrl3449 vsi = vec_srl(vsi, vui);3450 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3451 // CHECK-ASM: vsrl3452 vui = vec_srl(vui, vuc);3453 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3454 // CHECK-ASM: vsrl3455 vui = vec_srl(vui, vus);3456 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3457 // CHECK-ASM: vsrl3458 vui = vec_srl(vui, vui);3459 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3460 // CHECK-ASM: vsrl3461 vbi = vec_srl(vbi, vuc);3462 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3463 // CHECK-ASM: vsrl3464 vbi = vec_srl(vbi, vus);3465 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3466 // CHECK-ASM: vsrl3467 vbi = vec_srl(vbi, vui);3468 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3469 // CHECK-ASM: vsrl3470 vsl = vec_srl(vsl, vuc);3471 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3472 // CHECK-ASM: vsrl3473 vsl = vec_srl(vsl, vus);3474 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3475 // CHECK-ASM: vsrl3476 vsl = vec_srl(vsl, vui);3477 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3478 // CHECK-ASM: vsrl3479 vul = vec_srl(vul, vuc);3480 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3481 // CHECK-ASM: vsrl3482 vul = vec_srl(vul, vus);3483 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3484 // CHECK-ASM: vsrl3485 vul = vec_srl(vul, vui);3486 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3487 // CHECK-ASM: vsrl3488 vbl = vec_srl(vbl, vuc);3489 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3490 // CHECK-ASM: vsrl3491 vbl = vec_srl(vbl, vus);3492 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3493 // CHECK-ASM: vsrl3494 vbl = vec_srl(vbl, vui);3495 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3496 // CHECK-ASM: vsrl3497 vslll = vec_srl(vslll, vuc);3498 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3499 // CHECK-ASM: vsrl3500 vulll = vec_srl(vulll, vuc);3501 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3502 // CHECK-ASM: vsrl3503 3504 vsc = vec_srb(vsc, vsc);3505 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3506 // CHECK-ASM: vsrlb3507 vsc = vec_srb(vsc, vuc);3508 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3509 // CHECK-ASM: vsrlb3510 vuc = vec_srb(vuc, vsc);3511 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3512 // CHECK-ASM: vsrlb3513 vuc = vec_srb(vuc, vuc);3514 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3515 // CHECK-ASM: vsrlb3516 vss = vec_srb(vss, vss);3517 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3518 // CHECK-ASM: vsrlb3519 vss = vec_srb(vss, vus);3520 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3521 // CHECK-ASM: vsrlb3522 vss = vec_srb(vss, vuc);3523 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3524 // CHECK-ASM: vsrlb3525 vus = vec_srb(vus, vss);3526 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3527 // CHECK-ASM: vsrlb3528 vus = vec_srb(vus, vus);3529 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3530 // CHECK-ASM: vsrlb3531 vus = vec_srb(vus, vuc);3532 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3533 // CHECK-ASM: vsrlb3534 vsi = vec_srb(vsi, vsi);3535 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3536 // CHECK-ASM: vsrlb3537 vsi = vec_srb(vsi, vui);3538 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3539 // CHECK-ASM: vsrlb3540 vsi = vec_srb(vsi, vuc);3541 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3542 // CHECK-ASM: vsrlb3543 vui = vec_srb(vui, vsi);3544 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3545 // CHECK-ASM: vsrlb3546 vui = vec_srb(vui, vui);3547 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3548 // CHECK-ASM: vsrlb3549 vui = vec_srb(vui, vuc);3550 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3551 // CHECK-ASM: vsrlb3552 vsl = vec_srb(vsl, vsl);3553 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3554 // CHECK-ASM: vsrlb3555 vsl = vec_srb(vsl, vul);3556 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3557 // CHECK-ASM: vsrlb3558 vsl = vec_srb(vsl, vuc);3559 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3560 // CHECK-ASM: vsrlb3561 vul = vec_srb(vul, vsl);3562 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3563 // CHECK-ASM: vsrlb3564 vul = vec_srb(vul, vul);3565 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3566 // CHECK-ASM: vsrlb3567 vul = vec_srb(vul, vuc);3568 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3569 // CHECK-ASM: vsrlb3570 vslll = vec_srb(vslll, vuc);3571 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3572 // CHECK-ASM: vsrlb3573 vulll = vec_srb(vulll, vuc);3574 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3575 // CHECK-ASM: vsrlb3576 vd = vec_srb(vd, vsl);3577 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3578 // CHECK-ASM: vsrlb3579 vd = vec_srb(vd, vul);3580 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3581 // CHECK-ASM: vsrlb3582 vd = vec_srb(vd, vuc);3583 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3584 // CHECK-ASM: vsrlb3585 3586 vsc = vec_abs(vsc);3587 // CHECK-ASM: vlpb3588 vss = vec_abs(vss);3589 // CHECK-ASM: vlph3590 vsi = vec_abs(vsi);3591 // CHECK-ASM: vlpf3592 vsl = vec_abs(vsl);3593 // CHECK-ASM: vlpg3594 3595 vsc = vec_max(vsc, vsc);3596 // CHECK-ASM: vmxb3597 vsc = vec_max(vsc, vbc);3598 // CHECK-ASM: vmxb3599 vsc = vec_max(vbc, vsc);3600 // CHECK-ASM: vmxb3601 vuc = vec_max(vuc, vuc);3602 // CHECK-ASM: vmxlb3603 vuc = vec_max(vuc, vbc);3604 // CHECK-ASM: vmxlb3605 vuc = vec_max(vbc, vuc);3606 // CHECK-ASM: vmxlb3607 vss = vec_max(vss, vss);3608 // CHECK-ASM: vmxh3609 vss = vec_max(vss, vbs);3610 // CHECK-ASM: vmxh3611 vss = vec_max(vbs, vss);3612 // CHECK-ASM: vmxh3613 vus = vec_max(vus, vus);3614 // CHECK-ASM: vmxlh3615 vus = vec_max(vus, vbs);3616 // CHECK-ASM: vmxlh3617 vus = vec_max(vbs, vus);3618 // CHECK-ASM: vmxlh3619 vsi = vec_max(vsi, vsi);3620 // CHECK-ASM: vmxf3621 vsi = vec_max(vsi, vbi);3622 // CHECK-ASM: vmxf3623 vsi = vec_max(vbi, vsi);3624 // CHECK-ASM: vmxf3625 vui = vec_max(vui, vui);3626 // CHECK-ASM: vmxlf3627 vui = vec_max(vui, vbi);3628 // CHECK-ASM: vmxlf3629 vui = vec_max(vbi, vui);3630 // CHECK-ASM: vmxlf3631 vsl = vec_max(vsl, vsl);3632 // CHECK-ASM: vmxg3633 vsl = vec_max(vsl, vbl);3634 // CHECK-ASM: vmxg3635 vsl = vec_max(vbl, vsl);3636 // CHECK-ASM: vmxg3637 vul = vec_max(vul, vul);3638 // CHECK-ASM: vmxlg3639 vul = vec_max(vul, vbl);3640 // CHECK-ASM: vmxlg3641 vul = vec_max(vbl, vul);3642 // CHECK-ASM: vmxlg3643 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: vmnb3652 vsc = vec_min(vsc, vbc);3653 // CHECK-ASM: vmnb3654 vsc = vec_min(vbc, vsc);3655 // CHECK-ASM: vmnb3656 vuc = vec_min(vuc, vuc);3657 // CHECK-ASM: vmnlb3658 vuc = vec_min(vuc, vbc);3659 // CHECK-ASM: vmnlb3660 vuc = vec_min(vbc, vuc);3661 // CHECK-ASM: vmnlb3662 vss = vec_min(vss, vss);3663 // CHECK-ASM: vmnh3664 vss = vec_min(vss, vbs);3665 // CHECK-ASM: vmnh3666 vss = vec_min(vbs, vss);3667 // CHECK-ASM: vmnh3668 vus = vec_min(vus, vus);3669 // CHECK-ASM: vmnlh3670 vus = vec_min(vus, vbs);3671 // CHECK-ASM: vmnlh3672 vus = vec_min(vbs, vus);3673 // CHECK-ASM: vmnlh3674 vsi = vec_min(vsi, vsi);3675 // CHECK-ASM: vmnf3676 vsi = vec_min(vsi, vbi);3677 // CHECK-ASM: vmnf3678 vsi = vec_min(vbi, vsi);3679 // CHECK-ASM: vmnf3680 vui = vec_min(vui, vui);3681 // CHECK-ASM: vmnlf3682 vui = vec_min(vui, vbi);3683 // CHECK-ASM: vmnlf3684 vui = vec_min(vbi, vui);3685 // CHECK-ASM: vmnlf3686 vsl = vec_min(vsl, vsl);3687 // CHECK-ASM: vmng3688 vsl = vec_min(vsl, vbl);3689 // CHECK-ASM: vmng3690 vsl = vec_min(vbl, vsl);3691 // CHECK-ASM: vmng3692 vul = vec_min(vul, vul);3693 // CHECK-ASM: vmnlg3694 vul = vec_min(vul, vbl);3695 // CHECK-ASM: vmnlg3696 vul = vec_min(vbl, vul);3697 // CHECK-ASM: vmnlg3698 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: vaccb3708 vus = vec_addc(vus, vus);3709 // CHECK: call <8 x i16> @llvm.s390.vacch(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})3710 // CHECK-ASM: vacch3711 vui = vec_addc(vui, vui);3712 // CHECK: call <4 x i32> @llvm.s390.vaccf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})3713 // CHECK-ASM: vaccf3714 vul = vec_addc(vul, vul);3715 // CHECK: call <2 x i64> @llvm.s390.vaccg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})3716 // CHECK-ASM: vaccg3717 vulll = vec_addc(vulll, vulll);3718 // CHECK: call i128 @llvm.s390.vaccq(i128 %{{.*}}, i128 %{{.*}})3719 // CHECK-ASM: vaccq3720 3721 vulll = vec_adde(vulll, vulll, vulll);3722 // CHECK: call i128 @llvm.s390.vacq(i128 %{{.*}}, i128 %{{.*}}, i128 %{{.*}})3723 // CHECK-ASM: vacq3724 vulll = vec_addec(vulll, vulll, vulll);3725 // CHECK: call i128 @llvm.s390.vacccq(i128 %{{.*}}, i128 %{{.*}}, i128 %{{.*}})3726 // CHECK-ASM: vacccq3727 3728 vuc = vec_add_u128(vuc, vuc);3729 // CHECK-ASM: vaq3730 vuc = vec_addc_u128(vuc, vuc);3731 // CHECK: call i128 @llvm.s390.vaccq(i128 %{{.*}}, i128 %{{.*}})3732 // CHECK-ASM: vaccq3733 vuc = vec_adde_u128(vuc, vuc, vuc);3734 // CHECK: call i128 @llvm.s390.vacq(i128 %{{.*}}, i128 %{{.*}}, i128 %{{.*}})3735 // CHECK-ASM: vacq3736 vuc = vec_addec_u128(vuc, vuc, vuc);3737 // CHECK: call i128 @llvm.s390.vacccq(i128 %{{.*}}, i128 %{{.*}}, i128 %{{.*}})3738 // CHECK-ASM: vacccq3739 3740 vsc = vec_avg(vsc, vsc);3741 // CHECK: call <16 x i8> @llvm.s390.vavgb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3742 // CHECK-ASM: vavgb3743 vuc = vec_avg(vuc, vuc);3744 // CHECK: call <16 x i8> @llvm.s390.vavglb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3745 // CHECK-ASM: vavglb3746 vss = vec_avg(vss, vss);3747 // CHECK: call <8 x i16> @llvm.s390.vavgh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})3748 // CHECK-ASM: vavgh3749 vus = vec_avg(vus, vus);3750 // CHECK: call <8 x i16> @llvm.s390.vavglh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})3751 // CHECK-ASM: vavglh3752 vsi = vec_avg(vsi, vsi);3753 // CHECK: call <4 x i32> @llvm.s390.vavgf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})3754 // CHECK-ASM: vavgf3755 vui = vec_avg(vui, vui);3756 // CHECK: call <4 x i32> @llvm.s390.vavglf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})3757 // CHECK-ASM: vavglf3758 vsl = vec_avg(vsl, vsl);3759 // CHECK: call <2 x i64> @llvm.s390.vavgg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})3760 // CHECK-ASM: vavgg3761 vul = vec_avg(vul, vul);3762 // CHECK: call <2 x i64> @llvm.s390.vavglg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})3763 // CHECK-ASM: vavglg3764 3765 vui = vec_checksum(vui, vui);3766 // CHECK: call <4 x i32> @llvm.s390.vcksm(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})3767 // CHECK-ASM: vcksm3768 3769 vus = vec_gfmsum(vuc, vuc);3770 // CHECK: call <8 x i16> @llvm.s390.vgfmb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3771 // CHECK-ASM: vgfmb3772 vui = vec_gfmsum(vus, vus);3773 // CHECK: call <4 x i32> @llvm.s390.vgfmh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})3774 // CHECK-ASM: vgfmh3775 vul = vec_gfmsum(vui, vui);3776 // CHECK: call <2 x i64> @llvm.s390.vgfmf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})3777 // CHECK-ASM: vgfmf3778 vulll = vec_gfmsum(vul, vul);3779 // CHECK: call i128 @llvm.s390.vgfmg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})3780 // CHECK-ASM: vgfmg3781 vuc = vec_gfmsum_128(vul, vul);3782 // CHECK: call i128 @llvm.s390.vgfmg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})3783 // CHECK-ASM: vgfmg3784 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: vgfmab3788 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: vgfmah3791 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: vgfmaf3794 vulll = vec_gfmsum_accum(vul, vul, vulll);3795 // CHECK: call i128 @llvm.s390.vgfmag(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i128 %{{.*}})3796 // CHECK-ASM: vgfmag3797 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: vgfmag3800 3801 vsc = vec_mladd(vsc, vsc, vsc);3802 // CHECK-ASM: vmalb3803 vsc = vec_mladd(vuc, vsc, vsc);3804 // CHECK-ASM: vmalb3805 vsc = vec_mladd(vsc, vuc, vuc);3806 // CHECK-ASM: vmalb3807 vuc = vec_mladd(vuc, vuc, vuc);3808 // CHECK-ASM: vmalb3809 vss = vec_mladd(vss, vss, vss);3810 // CHECK-ASM: vmalhw3811 vss = vec_mladd(vus, vss, vss);3812 // CHECK-ASM: vmalhw3813 vss = vec_mladd(vss, vus, vus);3814 // CHECK-ASM: vmalhw3815 vus = vec_mladd(vus, vus, vus);3816 // CHECK-ASM: vmalhw3817 vsi = vec_mladd(vsi, vsi, vsi);3818 // CHECK-ASM: vmalf3819 vsi = vec_mladd(vui, vsi, vsi);3820 // CHECK-ASM: vmalf3821 vsi = vec_mladd(vsi, vui, vui);3822 // CHECK-ASM: vmalf3823 vui = vec_mladd(vui, vui, vui);3824 // CHECK-ASM: vmalf3825 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: vmahb3829 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: vmalhb3832 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: vmahh3835 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: vmalhh3838 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: vmahf3841 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: vmalhf3844 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: vmaeb3848 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: vmaleb3851 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: vmaeh3854 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: vmaleh3857 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: vmaef3860 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: vmalef3863 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: vmaob3867 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: vmalob3870 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: vmaoh3873 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: vmaloh3876 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: vmaof3879 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: vmalof3882 3883 vsc = vec_mulh(vsc, vsc);3884 // CHECK: call <16 x i8> @llvm.s390.vmhb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3885 // CHECK-ASM: vmhb3886 vuc = vec_mulh(vuc, vuc);3887 // CHECK: call <16 x i8> @llvm.s390.vmlhb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3888 // CHECK-ASM: vmlhb3889 vss = vec_mulh(vss, vss);3890 // CHECK: call <8 x i16> @llvm.s390.vmhh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})3891 // CHECK-ASM: vmhh3892 vus = vec_mulh(vus, vus);3893 // CHECK: call <8 x i16> @llvm.s390.vmlhh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})3894 // CHECK-ASM: vmlhh3895 vsi = vec_mulh(vsi, vsi);3896 // CHECK: call <4 x i32> @llvm.s390.vmhf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})3897 // CHECK-ASM: vmhf3898 vui = vec_mulh(vui, vui);3899 // CHECK: call <4 x i32> @llvm.s390.vmlhf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})3900 // CHECK-ASM: vmlhf3901 3902 vss = vec_mule(vsc, vsc);3903 // CHECK: call <8 x i16> @llvm.s390.vmeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3904 // CHECK-ASM: vmeb3905 vus = vec_mule(vuc, vuc);3906 // CHECK: call <8 x i16> @llvm.s390.vmleb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3907 // CHECK-ASM: vmleb3908 vsi = vec_mule(vss, vss);3909 // CHECK: call <4 x i32> @llvm.s390.vmeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})3910 // CHECK-ASM: vmeh3911 vui = vec_mule(vus, vus);3912 // CHECK: call <4 x i32> @llvm.s390.vmleh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})3913 // CHECK-ASM: vmleh3914 vsl = vec_mule(vsi, vsi);3915 // CHECK: call <2 x i64> @llvm.s390.vmef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})3916 // CHECK-ASM: vmef3917 vul = vec_mule(vui, vui);3918 // CHECK: call <2 x i64> @llvm.s390.vmlef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})3919 // CHECK-ASM: vmlef3920 3921 vss = vec_mulo(vsc, vsc);3922 // CHECK: call <8 x i16> @llvm.s390.vmob(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3923 // CHECK-ASM: vmob3924 vus = vec_mulo(vuc, vuc);3925 // CHECK: call <8 x i16> @llvm.s390.vmlob(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3926 // CHECK-ASM: vmlob3927 vsi = vec_mulo(vss, vss);3928 // CHECK: call <4 x i32> @llvm.s390.vmoh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})3929 // CHECK-ASM: vmoh3930 vui = vec_mulo(vus, vus);3931 // CHECK: call <4 x i32> @llvm.s390.vmloh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})3932 // CHECK-ASM: vmloh3933 vsl = vec_mulo(vsi, vsi);3934 // CHECK: call <2 x i64> @llvm.s390.vmof(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})3935 // CHECK-ASM: vmof3936 vul = vec_mulo(vui, vui);3937 // CHECK: call <2 x i64> @llvm.s390.vmlof(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})3938 // CHECK-ASM: vmlof3939 3940 vuc = vec_subc(vuc, vuc);3941 // CHECK: call <16 x i8> @llvm.s390.vscbib(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3942 // CHECK-ASM: vscbib3943 vus = vec_subc(vus, vus);3944 // CHECK: call <8 x i16> @llvm.s390.vscbih(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})3945 // CHECK-ASM: vscbih3946 vui = vec_subc(vui, vui);3947 // CHECK: call <4 x i32> @llvm.s390.vscbif(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})3948 // CHECK-ASM: vscbif3949 vul = vec_subc(vul, vul);3950 // CHECK: call <2 x i64> @llvm.s390.vscbig(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})3951 // CHECK-ASM: vscbig3952 vulll = vec_subc(vulll, vulll);3953 // CHECK: call i128 @llvm.s390.vscbiq(i128 %{{.*}}, i128 %{{.*}})3954 // CHECK-ASM: vscbiq3955 3956 vulll = vec_sube(vulll, vulll, vulll);3957 // CHECK: call i128 @llvm.s390.vsbiq(i128 %{{.*}}, i128 %{{.*}}, i128 %{{.*}})3958 // CHECK-ASM: vsbiq3959 vulll = vec_subec(vulll, vulll, vulll);3960 // CHECK: call i128 @llvm.s390.vsbcbiq(i128 %{{.*}}, i128 %{{.*}}, i128 %{{.*}})3961 // CHECK-ASM: vsbcbiq3962 3963 vuc = vec_sub_u128(vuc, vuc);3964 // CHECK-ASM: vsq3965 vuc = vec_subc_u128(vuc, vuc);3966 // CHECK: call i128 @llvm.s390.vscbiq(i128 %{{.*}}, i128 %{{.*}})3967 // CHECK-ASM: vscbiq3968 vuc = vec_sube_u128(vuc, vuc, vuc);3969 // CHECK: call i128 @llvm.s390.vsbiq(i128 %{{.*}}, i128 %{{.*}}, i128 %{{.*}})3970 // CHECK-ASM: vsbiq3971 vuc = vec_subec_u128(vuc, vuc, vuc);3972 // CHECK: call i128 @llvm.s390.vsbcbiq(i128 %{{.*}}, i128 %{{.*}}, i128 %{{.*}})3973 // CHECK-ASM: vsbcbiq3974 3975 vui = vec_sum4(vuc, vuc);3976 // CHECK: call <4 x i32> @llvm.s390.vsumb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})3977 // CHECK-ASM: vsumb3978 vui = vec_sum4(vus, vus);3979 // CHECK: call <4 x i32> @llvm.s390.vsumh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})3980 // CHECK-ASM: vsumh3981 vul = vec_sum2(vus, vus);3982 // CHECK: call <2 x i64> @llvm.s390.vsumgh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})3983 // CHECK-ASM: vsumgh3984 vul = vec_sum2(vui, vui);3985 // CHECK: call <2 x i64> @llvm.s390.vsumgf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})3986 // CHECK-ASM: vsumgf3987 vulll = vec_sum(vui, vui);3988 // CHECK: call i128 @llvm.s390.vsumqf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})3989 // CHECK-ASM: vsumqf3990 vulll = vec_sum(vul, vul);3991 // CHECK: call i128 @llvm.s390.vsumqg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})3992 // CHECK-ASM: vsumqg3993 vuc = vec_sum_u128(vui, vui);3994 // CHECK: call i128 @llvm.s390.vsumqf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})3995 // CHECK-ASM: vsumqf3996 vuc = vec_sum_u128(vul, vul);3997 // CHECK: call i128 @llvm.s390.vsumqg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})3998 // CHECK-ASM: vsumqg3999 4000 idx = vec_test_mask(vsc, vuc);4001 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})4002 // CHECK-ASM: vtm4003 idx = vec_test_mask(vuc, vuc);4004 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})4005 // CHECK-ASM: vtm4006 idx = vec_test_mask(vss, vus);4007 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})4008 // CHECK-ASM: vtm4009 idx = vec_test_mask(vus, vus);4010 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})4011 // CHECK-ASM: vtm4012 idx = vec_test_mask(vsi, vui);4013 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})4014 // CHECK-ASM: vtm4015 idx = vec_test_mask(vui, vui);4016 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})4017 // CHECK-ASM: vtm4018 idx = vec_test_mask(vsl, vul);4019 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})4020 // CHECK-ASM: vtm4021 idx = vec_test_mask(vul, vul);4022 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})4023 // CHECK-ASM: vtm4024 idx = vec_test_mask(vslll, vulll);4025 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})4026 // CHECK-ASM: vtm4027 idx = vec_test_mask(vulll, vulll);4028 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})4029 // CHECK-ASM: vtm4030 idx = vec_test_mask(vd, vul);4031 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})4032 // CHECK-ASM: vtm4033}4034 4035void test_string(void) {4036 // CHECK-ASM-LABEL: test_string4037 4038 vsc = vec_cp_until_zero(vsc);4039 // CHECK: call <16 x i8> @llvm.s390.vistrb(<16 x i8> %{{.*}})4040 // CHECK-ASM: vistrb4041 vuc = vec_cp_until_zero(vuc);4042 // CHECK: call <16 x i8> @llvm.s390.vistrb(<16 x i8> %{{.*}})4043 // CHECK-ASM: vistrb4044 vbc = vec_cp_until_zero(vbc);4045 // CHECK: call <16 x i8> @llvm.s390.vistrb(<16 x i8> %{{.*}})4046 // CHECK-ASM: vistrb4047 vss = vec_cp_until_zero(vss);4048 // CHECK: call <8 x i16> @llvm.s390.vistrh(<8 x i16> %{{.*}})4049 // CHECK-ASM: vistrh4050 vus = vec_cp_until_zero(vus);4051 // CHECK: call <8 x i16> @llvm.s390.vistrh(<8 x i16> %{{.*}})4052 // CHECK-ASM: vistrh4053 vbs = vec_cp_until_zero(vbs);4054 // CHECK: call <8 x i16> @llvm.s390.vistrh(<8 x i16> %{{.*}})4055 // CHECK-ASM: vistrh4056 vsi = vec_cp_until_zero(vsi);4057 // CHECK: call <4 x i32> @llvm.s390.vistrf(<4 x i32> %{{.*}})4058 // CHECK-ASM: vistrf4059 vui = vec_cp_until_zero(vui);4060 // CHECK: call <4 x i32> @llvm.s390.vistrf(<4 x i32> %{{.*}})4061 // CHECK-ASM: vistrf4062 vbi = vec_cp_until_zero(vbi);4063 // CHECK: call <4 x i32> @llvm.s390.vistrf(<4 x i32> %{{.*}})4064 // CHECK-ASM: vistrf4065 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: vistrbs4069 vuc = vec_cp_until_zero_cc(vuc, &cc);4070 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vistrbs(<16 x i8> %{{.*}})4071 // CHECK-ASM: vistrbs4072 vbc = vec_cp_until_zero_cc(vbc, &cc);4073 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vistrbs(<16 x i8> %{{.*}})4074 // CHECK-ASM: vistrbs4075 vss = vec_cp_until_zero_cc(vss, &cc);4076 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vistrhs(<8 x i16> %{{.*}})4077 // CHECK-ASM: vistrhs4078 vus = vec_cp_until_zero_cc(vus, &cc);4079 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vistrhs(<8 x i16> %{{.*}})4080 // CHECK-ASM: vistrhs4081 vbs = vec_cp_until_zero_cc(vbs, &cc);4082 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vistrhs(<8 x i16> %{{.*}})4083 // CHECK-ASM: vistrhs4084 vsi = vec_cp_until_zero_cc(vsi, &cc);4085 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vistrfs(<4 x i32> %{{.*}})4086 // CHECK-ASM: vistrfs4087 vui = vec_cp_until_zero_cc(vui, &cc);4088 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vistrfs(<4 x i32> %{{.*}})4089 // CHECK-ASM: vistrfs4090 vbi = vec_cp_until_zero_cc(vbi, &cc);4091 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vistrfs(<4 x i32> %{{.*}})4092 // CHECK-ASM: vistrfs4093 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: vfeeb4097 vuc = vec_cmpeq_idx(vuc, vuc);4098 // CHECK: call <16 x i8> @llvm.s390.vfeeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})4099 // CHECK-ASM: vfeeb4100 vuc = vec_cmpeq_idx(vbc, vbc);4101 // CHECK: call <16 x i8> @llvm.s390.vfeeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})4102 // CHECK-ASM: vfeeb4103 vss = vec_cmpeq_idx(vss, vss);4104 // CHECK: call <8 x i16> @llvm.s390.vfeeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})4105 // CHECK-ASM: vfeeh4106 vus = vec_cmpeq_idx(vus, vus);4107 // CHECK: call <8 x i16> @llvm.s390.vfeeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})4108 // CHECK-ASM: vfeeh4109 vus = vec_cmpeq_idx(vbs, vbs);4110 // CHECK: call <8 x i16> @llvm.s390.vfeeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})4111 // CHECK-ASM: vfeeh4112 vsi = vec_cmpeq_idx(vsi, vsi);4113 // CHECK: call <4 x i32> @llvm.s390.vfeef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})4114 // CHECK-ASM: vfeef4115 vui = vec_cmpeq_idx(vui, vui);4116 // CHECK: call <4 x i32> @llvm.s390.vfeef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})4117 // CHECK-ASM: vfeef4118 vui = vec_cmpeq_idx(vbi, vbi);4119 // CHECK: call <4 x i32> @llvm.s390.vfeef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})4120 // CHECK-ASM: vfeef4121 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: vfeebs4125 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: vfeebs4128 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: vfeebs4131 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: vfeehs4134 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: vfeehs4137 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: vfeehs4140 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: vfeefs4143 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: vfeefs4146 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: vfeefs4149 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: vfeezb4153 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: vfeezb4156 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: vfeezb4159 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: vfeezh4162 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: vfeezh4165 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: vfeezh4168 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: vfeezf4171 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: vfeezf4174 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: vfeezf4177 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: vfeezbs4181 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: vfeezbs4184 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: vfeezbs4187 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: vfeezhs4190 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: vfeezhs4193 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: vfeezhs4196 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: vfeezfs4199 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: vfeezfs4202 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: vfeezfs4205 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: vfeneb4209 vuc = vec_cmpne_idx(vuc, vuc);4210 // CHECK: call <16 x i8> @llvm.s390.vfeneb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})4211 // CHECK-ASM: vfeneb4212 vuc = vec_cmpne_idx(vbc, vbc);4213 // CHECK: call <16 x i8> @llvm.s390.vfeneb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})4214 // CHECK-ASM: vfeneb4215 vss = vec_cmpne_idx(vss, vss);4216 // CHECK: call <8 x i16> @llvm.s390.vfeneh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})4217 // CHECK-ASM: vfeneh4218 vus = vec_cmpne_idx(vus, vus);4219 // CHECK: call <8 x i16> @llvm.s390.vfeneh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})4220 // CHECK-ASM: vfeneh4221 vus = vec_cmpne_idx(vbs, vbs);4222 // CHECK: call <8 x i16> @llvm.s390.vfeneh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})4223 // CHECK-ASM: vfeneh4224 vsi = vec_cmpne_idx(vsi, vsi);4225 // CHECK: call <4 x i32> @llvm.s390.vfenef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})4226 // CHECK-ASM: vfenef4227 vui = vec_cmpne_idx(vui, vui);4228 // CHECK: call <4 x i32> @llvm.s390.vfenef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})4229 // CHECK-ASM: vfenef4230 vui = vec_cmpne_idx(vbi, vbi);4231 // CHECK: call <4 x i32> @llvm.s390.vfenef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})4232 // CHECK-ASM: vfenef4233 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: vfenebs4237 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: vfenebs4240 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: vfenebs4243 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: vfenehs4246 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: vfenehs4249 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: vfenehs4252 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: vfenefs4255 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: vfenefs4258 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: vfenefs4261 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: vfenezb4265 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: vfenezb4268 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: vfenezb4271 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: vfenezh4274 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: vfenezh4277 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: vfenezh4280 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: vfenezf4283 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: vfenezf4286 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: vfenezf4289 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: vfenezbs4293 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: vfenezbs4296 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: vfenezbs4299 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: vfenezhs4302 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: vfenezhs4305 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: vfenezhs4308 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: vfenezfs4311 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: vfenezfs4314 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: vfenezfs4317 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: vstrcb4321 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: vstrch4324 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: vstrcf4327 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: vstrcbs4331 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: vstrchs4334 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: vstrcfs4337 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: vstrcb4341 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: vstrch4344 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: vstrcf4347 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: vstrcbs4351 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: vstrchs4354 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: vstrcfs4357 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: vstrczb4361 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: vstrczh4364 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: vstrczf4367 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: vstrczbs4371 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: vstrczhs4374 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: vstrczfs4377 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: vstrcb4381 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: vstrch4384 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: vstrcf4387 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: vstrcbs4391 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: vstrchs4394 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: vstrcfs4397 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: vstrcb4401 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: vstrch4404 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: vstrcf4407 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: vstrcbs4411 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: vstrchs4414 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: vstrcfs4417 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: vstrczb4421 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: vstrczh4424 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: vstrczf4427 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: vstrczbs4431 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: vstrczhs4434 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: vstrczfs4437 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: vfaeb4441 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: vfaeb4444 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: vfaeb4447 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: vfaeh4450 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: vfaeh4453 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: vfaeh4456 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: vfaef4459 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: vfaef4462 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: vfaef4465 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: vfaebs4469 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: vfaebs4472 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: vfaebs4475 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: vfaehs4478 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: vfaehs4481 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: vfaehs4484 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: vfaefs4487 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: vfaefs4490 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: vfaefs4493 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: vfaeb4497 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: vfaeb4500 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: vfaeb4503 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: vfaeh4506 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: vfaeh4509 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: vfaeh4512 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: vfaef4515 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: vfaef4518 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: vfaef4521 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: vfaebs4525 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: vfaebs4528 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: vfaebs4531 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: vfaehs4534 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: vfaehs4537 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: vfaehs4540 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: vfaefs4543 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: vfaefs4546 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: vfaefs4549 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: vfaezb4553 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: vfaezb4556 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: vfaezb4559 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: vfaezh4562 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: vfaezh4565 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: vfaezh4568 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: vfaezf4571 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: vfaezf4574 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: vfaezf4577 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: vfaezbs4581 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: vfaezbs4584 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: vfaezbs4587 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: vfaezhs4590 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: vfaezhs4593 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: vfaezhs4596 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: vfaezfs4599 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: vfaezfs4602 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: vfaezfs4605 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: vfaeb4609 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: vfaeb4612 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: vfaeb4615 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: vfaeh4618 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: vfaeh4621 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: vfaeh4624 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: vfaef4627 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: vfaef4630 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: vfaef4633 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: vfaebs4637 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: vfaebs4640 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: vfaebs4643 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: vfaehs4646 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: vfaehs4649 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: vfaehs4652 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: vfaefs4655 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: vfaefs4658 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: vfaefs4661 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: vfaeb4665 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: vfaeb4668 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: vfaeb4671 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: vfaeh4674 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: vfaeh4677 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: vfaeh4680 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: vfaef4683 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: vfaef4686 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: vfaef4689 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: vfaebs4693 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: vfaebs4696 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: vfaebs4699 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: vfaehs4702 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: vfaehs4705 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: vfaehs4708 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: vfaefs4711 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: vfaefs4714 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: vfaefs4717 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: vfaezb4721 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: vfaezb4724 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: vfaezb4727 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: vfaezh4730 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: vfaezh4733 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: vfaezh4736 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: vfaezf4739 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: vfaezf4742 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: vfaezf4745 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: vfaezbs4749 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: vfaezbs4752 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: vfaezbs4755 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: vfaezhs4758 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: vfaezhs4761 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: vfaezhs4764 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: vfaezfs4767 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: vfaezfs4770 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: vfaezfs4773}4774 4775void test_float(void) {4776 // CHECK-ASM-LABEL: test_float4777 4778 vd = vec_abs(vd);4779 // CHECK: call <2 x double> @llvm.fabs.v2f64(<2 x double> %{{.*}})4780 // CHECK-ASM: vflpdb4781 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: vflndb4786 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: vfmadb4790 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: vfmsdb4794 vd = vec_sqrt(vd);4795 // CHECK: call <2 x double> @llvm.sqrt.v2f64(<2 x double> %{{.*}})4796 // CHECK-ASM: vfsqdb4797 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: vcdgb4856 vd = vec_double(vul);4857 // CHECK: uitofp <2 x i64> %{{.*}} to <2 x double>4858 // CHECK-ASM: vcdlgb4859 4860 vsl = vec_signed(vd);4861 // CHECK: fptosi <2 x double> %{{.*}} to <2 x i64>4862 // CHECK-ASM: vcgdb4863 vul = vec_unsigned(vd);4864 // CHECK: fptoui <2 x double> %{{.*}} to <2 x i64>4865 // CHECK-ASM: vclgdb4866 4867 vd = vec_roundp(vd);4868 // CHECK: call <2 x double> @llvm.ceil.v2f64(<2 x double> %{{.*}})4869 // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 64870 vd = vec_ceil(vd);4871 // CHECK: call <2 x double> @llvm.ceil.v2f64(<2 x double> %{{.*}})4872 // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 64873 vd = vec_roundm(vd);4874 // CHECK: call <2 x double> @llvm.floor.v2f64(<2 x double> %{{.*}})4875 // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 74876 vd = vec_floor(vd);4877 // CHECK: call <2 x double> @llvm.floor.v2f64(<2 x double> %{{.*}})4878 // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 74879 vd = vec_roundz(vd);4880 // CHECK: call <2 x double> @llvm.trunc.v2f64(<2 x double> %{{.*}})4881 // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 54882 vd = vec_trunc(vd);4883 // CHECK: call <2 x double> @llvm.trunc.v2f64(<2 x double> %{{.*}})4884 // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 54885 vd = vec_roundc(vd);4886 // CHECK: call <2 x double> @llvm.nearbyint.v2f64(<2 x double> %{{.*}})4887 // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 04888 vd = vec_rint(vd);4889 // CHECK: call <2 x double> @llvm.rint.v2f64(<2 x double> %{{.*}})4890 // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 0, 04891 vd = vec_round(vd);4892 // CHECK: call <2 x double> @llvm.roundeven.v2f64(<2 x double> %{{.*}})4893 // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 44894 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: vftcidb4898 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: vftcidb4901 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: vftcidb4904 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: vftcidb4907 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: vftcidb4910 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: vftcidb4913 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: vftcidb4916 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: vftcidb4919 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: vftcidb4922 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: vftcidb4925 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: vftcidb4928 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: vftcidb4931 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: vftcidb4934 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: vftcidb4937 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: vftcidb4940 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: vftcidb4943 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: vftcidb4946 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: vftcidb4949 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: vftcidb4952 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: vftcidb4955 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: vftcidb4958 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: vftcidb4961}4962