1 // REQUIRES: systemz-registered-target 2 // RUN: %clang_cc1 -target-cpu z13 -triple s390x-linux-gnu \ 3 // RUN: -O -fzvector -fno-lax-vector-conversions \ 4 // RUN: -Wall -Wno-unused -Werror -emit-llvm %s -o - | FileCheck %s 5 6 #include <vecintrin.h> 7 8 volatile vector signed char vsc; 9 volatile vector signed short vss; 10 volatile vector signed int vsi; 11 volatile vector signed long long vsl; 12 volatile vector unsigned char vuc; 13 volatile vector unsigned short vus; 14 volatile vector unsigned int vui; 15 volatile vector unsigned long long vul; 16 volatile vector bool char vbc; 17 volatile vector bool short vbs; 18 volatile vector bool int vbi; 19 volatile vector bool long long vbl; 20 volatile vector double vd; 21 22 volatile signed char sc; 23 volatile signed short ss; 24 volatile signed int si; 25 volatile signed long long sl; 26 volatile unsigned char uc; 27 volatile unsigned short us; 28 volatile unsigned int ui; 29 volatile unsigned long long ul; 30 volatile double d; 31 32 const void * volatile cptr; 33 const signed char * volatile cptrsc; 34 const signed short * volatile cptrss; 35 const signed int * volatile cptrsi; 36 const signed long long * volatile cptrsl; 37 const unsigned char * volatile cptruc; 38 const unsigned short * volatile cptrus; 39 const unsigned int * volatile cptrui; 40 const unsigned long long * volatile cptrul; 41 const float * volatile cptrf; 42 const double * volatile cptrd; 43 44 void * volatile ptr; 45 signed char * volatile ptrsc; 46 signed short * volatile ptrss; 47 signed int * volatile ptrsi; 48 signed long long * volatile ptrsl; 49 unsigned char * volatile ptruc; 50 unsigned short * volatile ptrus; 51 unsigned int * volatile ptrui; 52 unsigned long long * volatile ptrul; 53 float * volatile ptrf; 54 double * volatile ptrd; 55 56 volatile unsigned int len; 57 volatile int idx; 58 int cc; 59 60 void test_core(void) { 61 len = __lcbb(cptr, 64); 62 // CHECK: call i32 @llvm.s390.lcbb(i8* %{{.*}}, i32 0) 63 len = __lcbb(cptr, 128); 64 // CHECK: call i32 @llvm.s390.lcbb(i8* %{{.*}}, i32 1) 65 len = __lcbb(cptr, 256); 66 // CHECK: call i32 @llvm.s390.lcbb(i8* %{{.*}}, i32 2) 67 len = __lcbb(cptr, 512); 68 // CHECK: call i32 @llvm.s390.lcbb(i8* %{{.*}}, i32 3) 69 len = __lcbb(cptr, 1024); 70 // CHECK: call i32 @llvm.s390.lcbb(i8* %{{.*}}, i32 4) 71 len = __lcbb(cptr, 2048); 72 // CHECK: call i32 @llvm.s390.lcbb(i8* %{{.*}}, i32 5) 73 len = __lcbb(cptr, 4096); 74 // CHECK: call i32 @llvm.s390.lcbb(i8* %{{.*}}, i32 6) 75 76 sc = vec_extract(vsc, idx); 77 // CHECK: extractelement <16 x i8> %{{.*}}, i32 %{{.*}} 78 uc = vec_extract(vuc, idx); 79 // CHECK: extractelement <16 x i8> %{{.*}}, i32 %{{.*}} 80 uc = vec_extract(vbc, idx); 81 // CHECK: extractelement <16 x i8> %{{.*}}, i32 %{{.*}} 82 ss = vec_extract(vss, idx); 83 // CHECK: extractelement <8 x i16> %{{.*}}, i32 %{{.*}} 84 us = vec_extract(vus, idx); 85 // CHECK: extractelement <8 x i16> %{{.*}}, i32 %{{.*}} 86 us = vec_extract(vbs, idx); 87 // CHECK: extractelement <8 x i16> %{{.*}}, i32 %{{.*}} 88 si = vec_extract(vsi, idx); 89 // CHECK: extractelement <4 x i32> %{{.*}}, i32 %{{.*}} 90 ui = vec_extract(vui, idx); 91 // CHECK: extractelement <4 x i32> %{{.*}}, i32 %{{.*}} 92 ui = vec_extract(vbi, idx); 93 // CHECK: extractelement <4 x i32> %{{.*}}, i32 %{{.*}} 94 sl = vec_extract(vsl, idx); 95 // CHECK: extractelement <2 x i64> %{{.*}}, i32 %{{.*}} 96 ul = vec_extract(vul, idx); 97 // CHECK: extractelement <2 x i64> %{{.*}}, i32 %{{.*}} 98 ul = vec_extract(vbl, idx); 99 // CHECK: extractelement <2 x i64> %{{.*}}, i32 %{{.*}} 100 d = vec_extract(vd, idx); 101 // CHECK: extractelement <2 x double> %{{.*}}, i32 %{{.*}} 102 103 vsc = vec_insert(sc, vsc, idx); 104 // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 %{{.*}} 105 vuc = vec_insert(uc, vuc, idx); 106 // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 %{{.*}} 107 vuc = vec_insert(uc, vbc, idx); 108 // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 %{{.*}} 109 vss = vec_insert(ss, vss, idx); 110 // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 %{{.*}} 111 vus = vec_insert(us, vus, idx); 112 // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 %{{.*}} 113 vus = vec_insert(us, vbs, idx); 114 // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 %{{.*}} 115 vsi = vec_insert(si, vsi, idx); 116 // CHECK: insertelement <4 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}} 117 vui = vec_insert(ui, vui, idx); 118 // CHECK: insertelement <4 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}} 119 vui = vec_insert(ui, vbi, idx); 120 // CHECK: insertelement <4 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}} 121 vsl = vec_insert(sl, vsl, idx); 122 // CHECK: insertelement <2 x i64> %{{.*}}, i64 %{{.*}}, i32 %{{.*}} 123 vul = vec_insert(ul, vul, idx); 124 // CHECK: insertelement <2 x i64> %{{.*}}, i64 %{{.*}}, i32 %{{.*}} 125 vul = vec_insert(ul, vbl, idx); 126 // CHECK: insertelement <2 x i64> %{{.*}}, i64 %{{.*}}, i32 %{{.*}} 127 vd = vec_insert(d, vd, idx); 128 // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 %{{.*}} 129 130 vsc = vec_promote(sc, idx); 131 // CHECK: insertelement <16 x i8> undef, i8 %{{.*}}, i32 %{{.*}} 132 vuc = vec_promote(uc, idx); 133 // CHECK: insertelement <16 x i8> undef, i8 %{{.*}}, i32 %{{.*}} 134 vss = vec_promote(ss, idx); 135 // CHECK: insertelement <8 x i16> undef, i16 %{{.*}}, i32 %{{.*}} 136 vus = vec_promote(us, idx); 137 // CHECK: insertelement <8 x i16> undef, i16 %{{.*}}, i32 %{{.*}} 138 vsi = vec_promote(si, idx); 139 // CHECK: insertelement <4 x i32> undef, i32 %{{.*}}, i32 %{{.*}} 140 vui = vec_promote(ui, idx); 141 // CHECK: insertelement <4 x i32> undef, i32 %{{.*}}, i32 %{{.*}} 142 vsl = vec_promote(sl, idx); 143 // CHECK: insertelement <2 x i64> undef, i64 %{{.*}}, i32 %{{.*}} 144 vul = vec_promote(ul, idx); 145 // CHECK: insertelement <2 x i64> undef, i64 %{{.*}}, i32 %{{.*}} 146 vd = vec_promote(d, idx); 147 // CHECK: insertelement <2 x double> undef, double %{{.*}}, i32 %{{.*}} 148 149 vsc = vec_insert_and_zero(cptrsc); 150 // CHECK: insertelement <16 x i8> <i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 undef, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0>, i8 %{{.*}}, i32 7 151 vuc = vec_insert_and_zero(cptruc); 152 // CHECK: insertelement <16 x i8> <i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 undef, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0>, i8 %{{.*}}, i32 7 153 vss = vec_insert_and_zero(cptrss); 154 // CHECK: insertelement <8 x i16> <i16 0, i16 0, i16 0, i16 undef, i16 0, i16 0, i16 0, i16 0>, i16 %{{.*}}, i32 3 155 vus = vec_insert_and_zero(cptrus); 156 // CHECK: insertelement <8 x i16> <i16 0, i16 0, i16 0, i16 undef, i16 0, i16 0, i16 0, i16 0>, i16 %{{.*}}, i32 3 157 vsi = vec_insert_and_zero(cptrsi); 158 // CHECK: insertelement <4 x i32> <i32 0, i32 undef, i32 0, i32 0>, i32 %{{.*}}, i32 1 159 vui = vec_insert_and_zero(cptrui); 160 // CHECK: insertelement <4 x i32> <i32 0, i32 undef, i32 0, i32 0>, i32 %{{.*}}, i32 1 161 vsl = vec_insert_and_zero(cptrsl); 162 // CHECK: insertelement <2 x i64> <i64 undef, i64 0>, i64 %{{.*}}, i32 0 163 vul = vec_insert_and_zero(cptrul); 164 // CHECK: insertelement <2 x i64> <i64 undef, i64 0>, i64 %{{.*}}, i32 0 165 vd = vec_insert_and_zero(cptrd); 166 // CHECK: insertelement <2 x double> <double undef, double 0.000000e+00>, double %{{.*}}, i32 0 167 168 vsc = vec_perm(vsc, vsc, vuc); 169 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 170 vuc = vec_perm(vuc, vuc, vuc); 171 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 172 vbc = vec_perm(vbc, vbc, vuc); 173 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 174 vss = vec_perm(vss, vss, vuc); 175 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 176 vus = vec_perm(vus, vus, vuc); 177 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 178 vbs = vec_perm(vbs, vbs, vuc); 179 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 180 vsi = vec_perm(vsi, vsi, vuc); 181 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 182 vui = vec_perm(vui, vui, vuc); 183 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 184 vbi = vec_perm(vbi, vbi, vuc); 185 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 186 vsl = vec_perm(vsl, vsl, vuc); 187 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 188 vul = vec_perm(vul, vul, vuc); 189 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 190 vbl = vec_perm(vbl, vbl, vuc); 191 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 192 vd = vec_perm(vd, vd, vuc); 193 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 194 195 vsl = vec_permi(vsl, vsl, 0); 196 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 0) 197 vsl = vec_permi(vsl, vsl, 1); 198 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 1) 199 vsl = vec_permi(vsl, vsl, 2); 200 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 4) 201 vsl = vec_permi(vsl, vsl, 3); 202 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 5) 203 vul = vec_permi(vul, vul, 0); 204 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 0) 205 vul = vec_permi(vul, vul, 1); 206 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 1) 207 vul = vec_permi(vul, vul, 2); 208 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 4) 209 vul = vec_permi(vul, vul, 3); 210 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 5) 211 vbl = vec_permi(vbl, vbl, 0); 212 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 0) 213 vbl = vec_permi(vbl, vbl, 1); 214 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 1) 215 vbl = vec_permi(vbl, vbl, 2); 216 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 4) 217 vbl = vec_permi(vbl, vbl, 3); 218 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 5) 219 vd = vec_permi(vd, vd, 0); 220 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 0) 221 vd = vec_permi(vd, vd, 1); 222 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 1) 223 vd = vec_permi(vd, vd, 2); 224 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 4) 225 vd = vec_permi(vd, vd, 3); 226 // CHECK: call <2 x i64> @llvm.s390.vpdi(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 5) 227 228 vsc = vec_sel(vsc, vsc, vuc); 229 vsc = vec_sel(vsc, vsc, vbc); 230 vuc = vec_sel(vuc, vuc, vuc); 231 vuc = vec_sel(vuc, vuc, vbc); 232 vbc = vec_sel(vbc, vbc, vuc); 233 vbc = vec_sel(vbc, vbc, vbc); 234 vss = vec_sel(vss, vss, vus); 235 vss = vec_sel(vss, vss, vbs); 236 vus = vec_sel(vus, vus, vus); 237 vus = vec_sel(vus, vus, vbs); 238 vbs = vec_sel(vbs, vbs, vus); 239 vbs = vec_sel(vbs, vbs, vbs); 240 vsi = vec_sel(vsi, vsi, vui); 241 vsi = vec_sel(vsi, vsi, vbi); 242 vui = vec_sel(vui, vui, vui); 243 vui = vec_sel(vui, vui, vbi); 244 vbi = vec_sel(vbi, vbi, vui); 245 vbi = vec_sel(vbi, vbi, vbi); 246 vsl = vec_sel(vsl, vsl, vul); 247 vsl = vec_sel(vsl, vsl, vbl); 248 vul = vec_sel(vul, vul, vul); 249 vul = vec_sel(vul, vul, vbl); 250 vbl = vec_sel(vbl, vbl, vul); 251 vbl = vec_sel(vbl, vbl, vbl); 252 vd = vec_sel(vd, vd, vul); 253 vd = vec_sel(vd, vd, vbl); 254 255 vsi = vec_gather_element(vsi, vui, cptrsi, 0); 256 vsi = vec_gather_element(vsi, vui, cptrsi, 1); 257 vsi = vec_gather_element(vsi, vui, cptrsi, 2); 258 vsi = vec_gather_element(vsi, vui, cptrsi, 3); 259 vui = vec_gather_element(vui, vui, cptrui, 0); 260 vui = vec_gather_element(vui, vui, cptrui, 1); 261 vui = vec_gather_element(vui, vui, cptrui, 2); 262 vui = vec_gather_element(vui, vui, cptrui, 3); 263 vbi = vec_gather_element(vbi, vui, cptrui, 0); 264 vbi = vec_gather_element(vbi, vui, cptrui, 1); 265 vbi = vec_gather_element(vbi, vui, cptrui, 2); 266 vbi = vec_gather_element(vbi, vui, cptrui, 3); 267 vsl = vec_gather_element(vsl, vul, cptrsl, 0); 268 vsl = vec_gather_element(vsl, vul, cptrsl, 1); 269 vul = vec_gather_element(vul, vul, cptrul, 0); 270 vul = vec_gather_element(vul, vul, cptrul, 1); 271 vbl = vec_gather_element(vbl, vul, cptrul, 0); 272 vbl = vec_gather_element(vbl, vul, cptrul, 1); 273 vd = vec_gather_element(vd, vul, cptrd, 0); 274 vd = vec_gather_element(vd, vul, cptrd, 1); 275 276 vec_scatter_element(vsi, vui, ptrsi, 0); 277 vec_scatter_element(vsi, vui, ptrsi, 1); 278 vec_scatter_element(vsi, vui, ptrsi, 2); 279 vec_scatter_element(vsi, vui, ptrsi, 3); 280 vec_scatter_element(vui, vui, ptrui, 0); 281 vec_scatter_element(vui, vui, ptrui, 1); 282 vec_scatter_element(vui, vui, ptrui, 2); 283 vec_scatter_element(vui, vui, ptrui, 3); 284 vec_scatter_element(vbi, vui, ptrui, 0); 285 vec_scatter_element(vbi, vui, ptrui, 1); 286 vec_scatter_element(vbi, vui, ptrui, 2); 287 vec_scatter_element(vbi, vui, ptrui, 3); 288 vec_scatter_element(vsl, vul, ptrsl, 0); 289 vec_scatter_element(vsl, vul, ptrsl, 1); 290 vec_scatter_element(vul, vul, ptrul, 0); 291 vec_scatter_element(vul, vul, ptrul, 1); 292 vec_scatter_element(vbl, vul, ptrul, 0); 293 vec_scatter_element(vbl, vul, ptrul, 1); 294 vec_scatter_element(vd, vul, ptrd, 0); 295 vec_scatter_element(vd, vul, ptrd, 1); 296 297 vsc = vec_xld2(idx, cptrsc); 298 vuc = vec_xld2(idx, cptruc); 299 vss = vec_xld2(idx, cptrss); 300 vus = vec_xld2(idx, cptrus); 301 vsi = vec_xld2(idx, cptrsi); 302 vui = vec_xld2(idx, cptrui); 303 vsl = vec_xld2(idx, cptrsl); 304 vul = vec_xld2(idx, cptrul); 305 vd = vec_xld2(idx, cptrd); 306 307 vsc = vec_xlw4(idx, cptrsc); 308 vuc = vec_xlw4(idx, cptruc); 309 vss = vec_xlw4(idx, cptrss); 310 vus = vec_xlw4(idx, cptrus); 311 vsi = vec_xlw4(idx, cptrsi); 312 vui = vec_xlw4(idx, cptrui); 313 314 vec_xstd2(vsc, idx, ptrsc); 315 vec_xstd2(vuc, idx, ptruc); 316 vec_xstd2(vss, idx, ptrss); 317 vec_xstd2(vus, idx, ptrus); 318 vec_xstd2(vsi, idx, ptrsi); 319 vec_xstd2(vui, idx, ptrui); 320 vec_xstd2(vsl, idx, ptrsl); 321 vec_xstd2(vul, idx, ptrul); 322 vec_xstd2(vd, idx, ptrd); 323 324 vec_xstw4(vsc, idx, ptrsc); 325 vec_xstw4(vuc, idx, ptruc); 326 vec_xstw4(vss, idx, ptrss); 327 vec_xstw4(vus, idx, ptrus); 328 vec_xstw4(vsi, idx, ptrsi); 329 vec_xstw4(vui, idx, ptrui); 330 331 vsc = vec_load_bndry(cptrsc, 64); 332 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0) 333 vuc = vec_load_bndry(cptruc, 64); 334 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0) 335 vss = vec_load_bndry(cptrss, 64); 336 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0) 337 vus = vec_load_bndry(cptrus, 64); 338 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0) 339 vsi = vec_load_bndry(cptrsi, 64); 340 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0) 341 vui = vec_load_bndry(cptrui, 64); 342 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0) 343 vsl = vec_load_bndry(cptrsl, 64); 344 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0) 345 vul = vec_load_bndry(cptrul, 64); 346 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0) 347 vd = vec_load_bndry(cptrd, 64); 348 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 0) 349 vsc = vec_load_bndry(cptrsc, 128); 350 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 1) 351 vsc = vec_load_bndry(cptrsc, 256); 352 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 2) 353 vsc = vec_load_bndry(cptrsc, 512); 354 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 3) 355 vsc = vec_load_bndry(cptrsc, 1024); 356 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 4) 357 vsc = vec_load_bndry(cptrsc, 2048); 358 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 5) 359 vsc = vec_load_bndry(cptrsc, 4096); 360 // CHECK: call <16 x i8> @llvm.s390.vlbb(i8* %{{.*}}, i32 6) 361 362 vsc = vec_load_len(cptrsc, idx); 363 // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}}) 364 vuc = vec_load_len(cptruc, idx); 365 // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}}) 366 vss = vec_load_len(cptrss, idx); 367 // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}}) 368 vus = vec_load_len(cptrus, idx); 369 // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}}) 370 vsi = vec_load_len(cptrsi, idx); 371 // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}}) 372 vui = vec_load_len(cptrui, idx); 373 // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}}) 374 vsl = vec_load_len(cptrsl, idx); 375 // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}}) 376 vul = vec_load_len(cptrul, idx); 377 // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}}) 378 vd = vec_load_len(cptrd, idx); 379 // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, i8* %{{.*}}) 380 381 vec_store_len(vsc, ptrsc, idx); 382 // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}}) 383 vec_store_len(vuc, ptruc, idx); 384 // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}}) 385 vec_store_len(vss, ptrss, idx); 386 // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}}) 387 vec_store_len(vus, ptrus, idx); 388 // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}}) 389 vec_store_len(vsi, ptrsi, idx); 390 // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}}) 391 vec_store_len(vui, ptrui, idx); 392 // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}}) 393 vec_store_len(vsl, ptrsl, idx); 394 // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}}) 395 vec_store_len(vul, ptrul, idx); 396 // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}}) 397 vec_store_len(vd, ptrd, idx); 398 // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, i8* %{{.*}}) 399 400 vsl = vec_load_pair(sl, sl); 401 vul = vec_load_pair(ul, ul); 402 403 vuc = vec_genmask(0); 404 // CHECK: <16 x i8> zeroinitializer 405 vuc = vec_genmask(0x8000); 406 // 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> 407 vuc = vec_genmask(0xffff); 408 // CHECK: <16 x i8> <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1> 409 410 vuc = vec_genmasks_8(0, 7); 411 // CHECK: <16 x i8> <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1> 412 vuc = vec_genmasks_8(1, 4); 413 // CHECK: <16 x i8> <i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120, i8 120> 414 vuc = vec_genmasks_8(6, 2); 415 // CHECK: <16 x i8> <i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29, i8 -29> 416 vus = vec_genmasks_16(0, 15); 417 // CHECK: <8 x i16> <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1> 418 vus = vec_genmasks_16(2, 11); 419 // CHECK: <8 x i16> <i16 16368, i16 16368, i16 16368, i16 16368, i16 16368, i16 16368, i16 16368, i16 16368> 420 vus = vec_genmasks_16(9, 2); 421 // CHECK: <8 x i16> <i16 -8065, i16 -8065, i16 -8065, i16 -8065, i16 -8065, i16 -8065, i16 -8065, i16 -8065> 422 vui = vec_genmasks_32(0, 31); 423 // CHECK: <4 x i32> <i32 -1, i32 -1, i32 -1, i32 -1> 424 vui = vec_genmasks_32(7, 20); 425 // CHECK: <4 x i32> <i32 33552384, i32 33552384, i32 33552384, i32 33552384> 426 vui = vec_genmasks_32(25, 4); 427 // CHECK: <4 x i32> <i32 -134217601, i32 -134217601, i32 -134217601, i32 -134217601> 428 vul = vec_genmasks_64(0, 63); 429 // CHECK: <2 x i64> <i64 -1, i64 -1> 430 vul = vec_genmasks_64(3, 40); 431 // CHECK: <2 x i64> <i64 2305843009205305344, i64 2305843009205305344> 432 vul = vec_genmasks_64(30, 11); 433 // CHECK: <2 x i64> <i64 -4503582447501313, i64 -4503582447501313> 434 435 vsc = vec_splat(vsc, 0); 436 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> undef, <16 x i32> zeroinitializer 437 vsc = vec_splat(vsc, 15); 438 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> undef, <16 x i32> <i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15> 439 vuc = vec_splat(vuc, 0); 440 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> undef, <16 x i32> zeroinitializer 441 vuc = vec_splat(vuc, 15); 442 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> undef, <16 x i32> <i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15> 443 vbc = vec_splat(vbc, 0); 444 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> undef, <16 x i32> zeroinitializer 445 vbc = vec_splat(vbc, 15); 446 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> undef, <16 x i32> <i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15, i32 15> 447 vss = vec_splat(vss, 0); 448 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> undef, <8 x i32> zeroinitializer 449 vss = vec_splat(vss, 7); 450 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> undef, <8 x i32> <i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7> 451 vus = vec_splat(vus, 0); 452 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> undef, <8 x i32> zeroinitializer 453 vus = vec_splat(vus, 7); 454 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> undef, <8 x i32> <i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7> 455 vbs = vec_splat(vbs, 0); 456 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> undef, <8 x i32> zeroinitializer 457 vbs = vec_splat(vbs, 7); 458 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> undef, <8 x i32> <i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7> 459 vsi = vec_splat(vsi, 0); 460 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> undef, <4 x i32> zeroinitializer 461 vsi = vec_splat(vsi, 3); 462 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3> 463 vui = vec_splat(vui, 0); 464 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> undef, <4 x i32> zeroinitializer 465 vui = vec_splat(vui, 3); 466 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3> 467 vbi = vec_splat(vbi, 0); 468 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> undef, <4 x i32> zeroinitializer 469 vbi = vec_splat(vbi, 3); 470 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3> 471 vsl = vec_splat(vsl, 0); 472 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> undef, <2 x i32> zeroinitializer 473 vsl = vec_splat(vsl, 1); 474 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> undef, <2 x i32> <i32 1, i32 1> 475 vul = vec_splat(vul, 0); 476 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> undef, <2 x i32> zeroinitializer 477 vul = vec_splat(vul, 1); 478 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> undef, <2 x i32> <i32 1, i32 1> 479 vbl = vec_splat(vbl, 0); 480 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> undef, <2 x i32> zeroinitializer 481 vbl = vec_splat(vbl, 1); 482 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> undef, <2 x i32> <i32 1, i32 1> 483 vd = vec_splat(vd, 0); 484 // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> undef, <2 x i32> zeroinitializer 485 vd = vec_splat(vd, 1); 486 // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> undef, <2 x i32> <i32 1, i32 1> 487 488 vsc = vec_splat_s8(-128); 489 // CHECK: <16 x i8> <i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128> 490 vsc = vec_splat_s8(127); 491 // CHECK: <16 x i8> <i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127> 492 vuc = vec_splat_u8(1); 493 // CHECK: <16 x i8> <i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1> 494 vuc = vec_splat_u8(254); 495 // CHECK: <16 x i8> <i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2> 496 vss = vec_splat_s16(-32768); 497 // CHECK: <8 x i16> <i16 -32768, i16 -32768, i16 -32768, i16 -32768, i16 -32768, i16 -32768, i16 -32768, i16 -32768> 498 vss = vec_splat_s16(32767); 499 // CHECK: <8 x i16> <i16 32767, i16 32767, i16 32767, i16 32767, i16 32767, i16 32767, i16 32767, i16 32767> 500 vus = vec_splat_u16(1); 501 // CHECK: <8 x i16> <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1> 502 vus = vec_splat_u16(65534); 503 // CHECK: <8 x i16> <i16 -2, i16 -2, i16 -2, i16 -2, i16 -2, i16 -2, i16 -2, i16 -2> 504 vsi = vec_splat_s32(-32768); 505 // CHECK: <4 x i32> <i32 -32768, i32 -32768, i32 -32768, i32 -32768> 506 vsi = vec_splat_s32(32767); 507 // CHECK: <4 x i32> <i32 32767, i32 32767, i32 32767, i32 32767> 508 vui = vec_splat_u32(-32768); 509 // CHECK: <4 x i32> <i32 -32768, i32 -32768, i32 -32768, i32 -32768> 510 vui = vec_splat_u32(32767); 511 // CHECK: <4 x i32> <i32 32767, i32 32767, i32 32767, i32 32767> 512 vsl = vec_splat_s64(-32768); 513 // CHECK: <2 x i64> <i64 -32768, i64 -32768> 514 vsl = vec_splat_s64(32767); 515 // CHECK: <2 x i64> <i64 32767, i64 32767> 516 vul = vec_splat_u64(-32768); 517 // CHECK: <2 x i64> <i64 -32768, i64 -32768> 518 vul = vec_splat_u64(32767); 519 // CHECK: <2 x i64> <i64 32767, i64 32767> 520 521 vsc = vec_splats(sc); 522 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> undef, <16 x i32> zeroinitializer 523 vuc = vec_splats(uc); 524 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> undef, <16 x i32> zeroinitializer 525 vss = vec_splats(ss); 526 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> undef, <8 x i32> zeroinitializer 527 vus = vec_splats(us); 528 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> undef, <8 x i32> zeroinitializer 529 vsi = vec_splats(si); 530 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> undef, <4 x i32> zeroinitializer 531 vui = vec_splats(ui); 532 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> undef, <4 x i32> zeroinitializer 533 vsl = vec_splats(sl); 534 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> undef, <2 x i32> zeroinitializer 535 vul = vec_splats(ul); 536 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> undef, <2 x i32> zeroinitializer 537 vd = vec_splats(d); 538 // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> undef, <2 x i32> zeroinitializer 539 540 vsl = vec_extend_s64(vsc); 541 vsl = vec_extend_s64(vss); 542 vsl = vec_extend_s64(vsi); 543 544 vsc = vec_mergeh(vsc, vsc); 545 // 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> 546 vuc = vec_mergeh(vuc, vuc); 547 // 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> 548 vbc = vec_mergeh(vbc, vbc); 549 // 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> 550 vss = vec_mergeh(vss, vss); 551 // 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> 552 vus = vec_mergeh(vus, vus); 553 // 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> 554 vbs = vec_mergeh(vbs, vbs); 555 // 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> 556 vsi = vec_mergeh(vsi, vsi); 557 // shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 1, i32 5> 558 vui = vec_mergeh(vui, vui); 559 // shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 1, i32 5> 560 vbi = vec_mergeh(vbi, vbi); 561 // shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 1, i32 5> 562 vsl = vec_mergeh(vsl, vsl); 563 // shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i32> <i32 0, i32 2> 564 vul = vec_mergeh(vul, vul); 565 // shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i32> <i32 0, i32 2> 566 vbl = vec_mergeh(vbl, vbl); 567 // shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i32> <i32 0, i32 2> 568 vd = vec_mergeh(vd, vd); 569 // shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> <i32 0, i32 2> 570 571 vsc = vec_mergel(vsc, vsc); 572 // 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> 573 vuc = vec_mergel(vuc, vuc); 574 // 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> 575 vbc = vec_mergel(vbc, vbc); 576 // 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> 577 vss = vec_mergel(vss, vss); 578 // 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> 579 vus = vec_mergel(vus, vus); 580 // 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> 581 vbs = vec_mergel(vbs, vbs); 582 // 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> 583 vsi = vec_mergel(vsi, vsi); 584 // shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <i32 2, i32 6, i32 3, i32 7> 585 vui = vec_mergel(vui, vui); 586 // shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <i32 2, i32 6, i32 3, i32 7> 587 vbi = vec_mergel(vbi, vbi); 588 // shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <i32 2, i32 6, i32 3, i32 7> 589 vsl = vec_mergel(vsl, vsl); 590 // shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <i32 1, i32 3> 591 vul = vec_mergel(vul, vul); 592 // shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <i32 1, i32 3> 593 vbl = vec_mergel(vbl, vbl); 594 // shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <i32 1, i32 3> 595 vd = vec_mergel(vd, vd); 596 // shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <i32 1, i32 3> 597 598 vsc = vec_pack(vss, vss); 599 // 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> 600 vuc = vec_pack(vus, vus); 601 // 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> 602 vbc = vec_pack(vbs, vbs); 603 // 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> 604 vss = vec_pack(vsi, vsi); 605 // 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> 606 vus = vec_pack(vui, vui); 607 // 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> 608 vbs = vec_pack(vbi, vbi); 609 // 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> 610 vsi = vec_pack(vsl, vsl); 611 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 1, i32 3, i32 5, i32 7> 612 vui = vec_pack(vul, vul); 613 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 1, i32 3, i32 5, i32 7> 614 vbi = vec_pack(vbl, vbl); 615 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 1, i32 3, i32 5, i32 7> 616 617 vsc = vec_packs(vss, vss); 618 // CHECK: call <16 x i8> @llvm.s390.vpksh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 619 vuc = vec_packs(vus, vus); 620 // CHECK: call <16 x i8> @llvm.s390.vpklsh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 621 vss = vec_packs(vsi, vsi); 622 // CHECK: call <8 x i16> @llvm.s390.vpksf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 623 vus = vec_packs(vui, vui); 624 // CHECK: call <8 x i16> @llvm.s390.vpklsf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 625 vsi = vec_packs(vsl, vsl); 626 // CHECK: call <4 x i32> @llvm.s390.vpksg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 627 vui = vec_packs(vul, vul); 628 // CHECK: call <4 x i32> @llvm.s390.vpklsg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 629 630 vsc = vec_packs_cc(vss, vss, &cc); 631 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vpkshs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 632 vuc = vec_packs_cc(vus, vus, &cc); 633 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vpklshs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 634 vss = vec_packs_cc(vsi, vsi, &cc); 635 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vpksfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 636 vus = vec_packs_cc(vui, vui, &cc); 637 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vpklsfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 638 vsi = vec_packs_cc(vsl, vsl, &cc); 639 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vpksgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 640 vui = vec_packs_cc(vul, vul, &cc); 641 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vpklsgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 642 643 vuc = vec_packsu(vss, vss); 644 // CHECK: call <16 x i8> @llvm.s390.vpklsh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 645 vuc = vec_packsu(vus, vus); 646 // CHECK: call <16 x i8> @llvm.s390.vpklsh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 647 vus = vec_packsu(vsi, vsi); 648 // CHECK: call <8 x i16> @llvm.s390.vpklsf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 649 vus = vec_packsu(vui, vui); 650 // CHECK: call <8 x i16> @llvm.s390.vpklsf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 651 vui = vec_packsu(vsl, vsl); 652 // CHECK: call <4 x i32> @llvm.s390.vpklsg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 653 vui = vec_packsu(vul, vul); 654 // CHECK: call <4 x i32> @llvm.s390.vpklsg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 655 656 vuc = vec_packsu_cc(vus, vus, &cc); 657 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vpklshs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 658 vus = vec_packsu_cc(vui, vui, &cc); 659 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vpklsfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 660 vui = vec_packsu_cc(vul, vul, &cc); 661 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vpklsgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 662 663 vss = vec_unpackh(vsc); 664 // CHECK: call <8 x i16> @llvm.s390.vuphb(<16 x i8> %{{.*}}) 665 vus = vec_unpackh(vuc); 666 // CHECK: call <8 x i16> @llvm.s390.vuplhb(<16 x i8> %{{.*}}) 667 vbs = vec_unpackh(vbc); 668 // CHECK: call <8 x i16> @llvm.s390.vuphb(<16 x i8> %{{.*}}) 669 vsi = vec_unpackh(vss); 670 // CHECK: call <4 x i32> @llvm.s390.vuphh(<8 x i16> %{{.*}}) 671 vui = vec_unpackh(vus); 672 // CHECK: call <4 x i32> @llvm.s390.vuplhh(<8 x i16> %{{.*}}) 673 vbi = vec_unpackh(vbs); 674 // CHECK: call <4 x i32> @llvm.s390.vuphh(<8 x i16> %{{.*}}) 675 vsl = vec_unpackh(vsi); 676 // CHECK: call <2 x i64> @llvm.s390.vuphf(<4 x i32> %{{.*}}) 677 vul = vec_unpackh(vui); 678 // CHECK: call <2 x i64> @llvm.s390.vuplhf(<4 x i32> %{{.*}}) 679 vbl = vec_unpackh(vbi); 680 // CHECK: call <2 x i64> @llvm.s390.vuphf(<4 x i32> %{{.*}}) 681 682 vss = vec_unpackl(vsc); 683 // CHECK: call <8 x i16> @llvm.s390.vuplb(<16 x i8> %{{.*}}) 684 vus = vec_unpackl(vuc); 685 // CHECK: call <8 x i16> @llvm.s390.vupllb(<16 x i8> %{{.*}}) 686 vbs = vec_unpackl(vbc); 687 // CHECK: call <8 x i16> @llvm.s390.vuplb(<16 x i8> %{{.*}}) 688 vsi = vec_unpackl(vss); 689 // CHECK: call <4 x i32> @llvm.s390.vuplhw(<8 x i16> %{{.*}}) 690 vui = vec_unpackl(vus); 691 // CHECK: call <4 x i32> @llvm.s390.vupllh(<8 x i16> %{{.*}}) 692 vbi = vec_unpackl(vbs); 693 // CHECK: call <4 x i32> @llvm.s390.vuplhw(<8 x i16> %{{.*}}) 694 vsl = vec_unpackl(vsi); 695 // CHECK: call <2 x i64> @llvm.s390.vuplf(<4 x i32> %{{.*}}) 696 vul = vec_unpackl(vui); 697 // CHECK: call <2 x i64> @llvm.s390.vupllf(<4 x i32> %{{.*}}) 698 vbl = vec_unpackl(vbi); 699 // CHECK: call <2 x i64> @llvm.s390.vuplf(<4 x i32> %{{.*}}) 700 } 701 702 void test_compare(void) { 703 vbc = vec_cmpeq(vsc, vsc); 704 // CHECK: icmp eq <16 x i8> %{{.*}}, %{{.*}} 705 vbc = vec_cmpeq(vuc, vuc); 706 // CHECK: icmp eq <16 x i8> %{{.*}}, %{{.*}} 707 vbc = vec_cmpeq(vbc, vbc); 708 // CHECK: icmp eq <16 x i8> %{{.*}}, %{{.*}} 709 vbs = vec_cmpeq(vss, vss); 710 // CHECK: icmp eq <8 x i16> %{{.*}}, %{{.*}} 711 vbs = vec_cmpeq(vus, vus); 712 // CHECK: icmp eq <8 x i16> %{{.*}}, %{{.*}} 713 vbs = vec_cmpeq(vbs, vbs); 714 // CHECK: icmp eq <8 x i16> %{{.*}}, %{{.*}} 715 vbi = vec_cmpeq(vsi, vsi); 716 // CHECK: icmp eq <4 x i32> %{{.*}}, %{{.*}} 717 vbi = vec_cmpeq(vui, vui); 718 // CHECK: icmp eq <4 x i32> %{{.*}}, %{{.*}} 719 vbi = vec_cmpeq(vbi, vbi); 720 // CHECK: icmp eq <4 x i32> %{{.*}}, %{{.*}} 721 vbl = vec_cmpeq(vsl, vsl); 722 // CHECK: icmp eq <2 x i64> %{{.*}}, %{{.*}} 723 vbl = vec_cmpeq(vul, vul); 724 // CHECK: icmp eq <2 x i64> %{{.*}}, %{{.*}} 725 vbl = vec_cmpeq(vbl, vbl); 726 // CHECK: icmp eq <2 x i64> %{{.*}}, %{{.*}} 727 vbl = vec_cmpeq(vd, vd); 728 // CHECK: fcmp oeq <2 x double> %{{.*}}, %{{.*}} 729 730 vbc = vec_cmpge(vsc, vsc); 731 // CHECK: icmp sge <16 x i8> %{{.*}}, %{{.*}} 732 vbc = vec_cmpge(vuc, vuc); 733 // CHECK: icmp uge <16 x i8> %{{.*}}, %{{.*}} 734 vbs = vec_cmpge(vss, vss); 735 // CHECK: icmp sge <8 x i16> %{{.*}}, %{{.*}} 736 vbs = vec_cmpge(vus, vus); 737 // CHECK: icmp uge <8 x i16> %{{.*}}, %{{.*}} 738 vbi = vec_cmpge(vsi, vsi); 739 // CHECK: icmp sge <4 x i32> %{{.*}}, %{{.*}} 740 vbi = vec_cmpge(vui, vui); 741 // CHECK: icmp uge <4 x i32> %{{.*}}, %{{.*}} 742 vbl = vec_cmpge(vsl, vsl); 743 // CHECK: icmp sge <2 x i64> %{{.*}}, %{{.*}} 744 vbl = vec_cmpge(vul, vul); 745 // CHECK: icmp uge <2 x i64> %{{.*}}, %{{.*}} 746 vbl = vec_cmpge(vd, vd); 747 // CHECK: fcmp oge <2 x double> %{{.*}}, %{{.*}} 748 749 vbc = vec_cmpgt(vsc, vsc); 750 // CHECK: icmp sgt <16 x i8> %{{.*}}, %{{.*}} 751 vbc = vec_cmpgt(vuc, vuc); 752 // CHECK: icmp ugt <16 x i8> %{{.*}}, %{{.*}} 753 vbs = vec_cmpgt(vss, vss); 754 // CHECK: icmp sgt <8 x i16> %{{.*}}, %{{.*}} 755 vbs = vec_cmpgt(vus, vus); 756 // CHECK: icmp ugt <8 x i16> %{{.*}}, %{{.*}} 757 vbi = vec_cmpgt(vsi, vsi); 758 // CHECK: icmp sgt <4 x i32> %{{.*}}, %{{.*}} 759 vbi = vec_cmpgt(vui, vui); 760 // CHECK: icmp ugt <4 x i32> %{{.*}}, %{{.*}} 761 vbl = vec_cmpgt(vsl, vsl); 762 // CHECK: icmp sgt <2 x i64> %{{.*}}, %{{.*}} 763 vbl = vec_cmpgt(vul, vul); 764 // CHECK: icmp ugt <2 x i64> %{{.*}}, %{{.*}} 765 vbl = vec_cmpgt(vd, vd); 766 // CHECK: fcmp ogt <2 x double> %{{.*}}, %{{.*}} 767 768 vbc = vec_cmple(vsc, vsc); 769 // CHECK: icmp sle <16 x i8> %{{.*}}, %{{.*}} 770 vbc = vec_cmple(vuc, vuc); 771 // CHECK: icmp ule <16 x i8> %{{.*}}, %{{.*}} 772 vbs = vec_cmple(vss, vss); 773 // CHECK: icmp sle <8 x i16> %{{.*}}, %{{.*}} 774 vbs = vec_cmple(vus, vus); 775 // CHECK: icmp ule <8 x i16> %{{.*}}, %{{.*}} 776 vbi = vec_cmple(vsi, vsi); 777 // CHECK: icmp sle <4 x i32> %{{.*}}, %{{.*}} 778 vbi = vec_cmple(vui, vui); 779 // CHECK: icmp ule <4 x i32> %{{.*}}, %{{.*}} 780 vbl = vec_cmple(vsl, vsl); 781 // CHECK: icmp sle <2 x i64> %{{.*}}, %{{.*}} 782 vbl = vec_cmple(vul, vul); 783 // CHECK: icmp ule <2 x i64> %{{.*}}, %{{.*}} 784 vbl = vec_cmple(vd, vd); 785 // CHECK: fcmp ole <2 x double> %{{.*}}, %{{.*}} 786 787 vbc = vec_cmplt(vsc, vsc); 788 // CHECK: icmp slt <16 x i8> %{{.*}}, %{{.*}} 789 vbc = vec_cmplt(vuc, vuc); 790 // CHECK: icmp ult <16 x i8> %{{.*}}, %{{.*}} 791 vbs = vec_cmplt(vss, vss); 792 // CHECK: icmp slt <8 x i16> %{{.*}}, %{{.*}} 793 vbs = vec_cmplt(vus, vus); 794 // CHECK: icmp ult <8 x i16> %{{.*}}, %{{.*}} 795 vbi = vec_cmplt(vsi, vsi); 796 // CHECK: icmp slt <4 x i32> %{{.*}}, %{{.*}} 797 vbi = vec_cmplt(vui, vui); 798 // CHECK: icmp ult <4 x i32> %{{.*}}, %{{.*}} 799 vbl = vec_cmplt(vsl, vsl); 800 // CHECK: icmp slt <2 x i64> %{{.*}}, %{{.*}} 801 vbl = vec_cmplt(vul, vul); 802 // CHECK: icmp ult <2 x i64> %{{.*}}, %{{.*}} 803 vbl = vec_cmplt(vd, vd); 804 // CHECK: fcmp olt <2 x double> %{{.*}}, %{{.*}} 805 806 idx = vec_all_eq(vsc, vsc); 807 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 808 idx = vec_all_eq(vsc, vbc); 809 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 810 idx = vec_all_eq(vbc, vsc); 811 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 812 idx = vec_all_eq(vuc, vuc); 813 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 814 idx = vec_all_eq(vuc, vbc); 815 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 816 idx = vec_all_eq(vbc, vuc); 817 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 818 idx = vec_all_eq(vbc, vbc); 819 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 820 idx = vec_all_eq(vss, vss); 821 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 822 idx = vec_all_eq(vss, vbs); 823 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 824 idx = vec_all_eq(vbs, vss); 825 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 826 idx = vec_all_eq(vus, vus); 827 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 828 idx = vec_all_eq(vus, vbs); 829 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 830 idx = vec_all_eq(vbs, vus); 831 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 832 idx = vec_all_eq(vbs, vbs); 833 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 834 idx = vec_all_eq(vsi, vsi); 835 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 836 idx = vec_all_eq(vsi, vbi); 837 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 838 idx = vec_all_eq(vbi, vsi); 839 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 840 idx = vec_all_eq(vui, vui); 841 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 842 idx = vec_all_eq(vui, vbi); 843 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 844 idx = vec_all_eq(vbi, vui); 845 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 846 idx = vec_all_eq(vbi, vbi); 847 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 848 idx = vec_all_eq(vsl, vsl); 849 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 850 idx = vec_all_eq(vsl, vbl); 851 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 852 idx = vec_all_eq(vbl, vsl); 853 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 854 idx = vec_all_eq(vul, vul); 855 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 856 idx = vec_all_eq(vul, vbl); 857 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 858 idx = vec_all_eq(vbl, vul); 859 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 860 idx = vec_all_eq(vbl, vbl); 861 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 862 idx = vec_all_eq(vd, vd); 863 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 864 865 idx = vec_all_ne(vsc, vsc); 866 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 867 idx = vec_all_ne(vsc, vbc); 868 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 869 idx = vec_all_ne(vbc, vsc); 870 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 871 idx = vec_all_ne(vuc, vuc); 872 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 873 idx = vec_all_ne(vuc, vbc); 874 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 875 idx = vec_all_ne(vbc, vuc); 876 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 877 idx = vec_all_ne(vbc, vbc); 878 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 879 idx = vec_all_ne(vss, vss); 880 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 881 idx = vec_all_ne(vss, vbs); 882 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 883 idx = vec_all_ne(vbs, vss); 884 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 885 idx = vec_all_ne(vus, vus); 886 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 887 idx = vec_all_ne(vus, vbs); 888 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 889 idx = vec_all_ne(vbs, vus); 890 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 891 idx = vec_all_ne(vbs, vbs); 892 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 893 idx = vec_all_ne(vsi, vsi); 894 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 895 idx = vec_all_ne(vsi, vbi); 896 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 897 idx = vec_all_ne(vbi, vsi); 898 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 899 idx = vec_all_ne(vui, vui); 900 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 901 idx = vec_all_ne(vui, vbi); 902 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 903 idx = vec_all_ne(vbi, vui); 904 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 905 idx = vec_all_ne(vbi, vbi); 906 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 907 idx = vec_all_ne(vsl, vsl); 908 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 909 idx = vec_all_ne(vsl, vbl); 910 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 911 idx = vec_all_ne(vbl, vsl); 912 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 913 idx = vec_all_ne(vul, vul); 914 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 915 idx = vec_all_ne(vul, vbl); 916 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 917 idx = vec_all_ne(vbl, vul); 918 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 919 idx = vec_all_ne(vbl, vbl); 920 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 921 idx = vec_all_ne(vd, vd); 922 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 923 924 idx = vec_all_ge(vsc, vsc); 925 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 926 idx = vec_all_ge(vsc, vbc); 927 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 928 idx = vec_all_ge(vbc, vsc); 929 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 930 idx = vec_all_ge(vuc, vuc); 931 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 932 idx = vec_all_ge(vuc, vbc); 933 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 934 idx = vec_all_ge(vbc, vuc); 935 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 936 idx = vec_all_ge(vbc, vbc); 937 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 938 idx = vec_all_ge(vss, vss); 939 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 940 idx = vec_all_ge(vss, vbs); 941 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 942 idx = vec_all_ge(vbs, vss); 943 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 944 idx = vec_all_ge(vus, vus); 945 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 946 idx = vec_all_ge(vus, vbs); 947 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 948 idx = vec_all_ge(vbs, vus); 949 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 950 idx = vec_all_ge(vbs, vbs); 951 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 952 idx = vec_all_ge(vsi, vsi); 953 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 954 idx = vec_all_ge(vsi, vbi); 955 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 956 idx = vec_all_ge(vbi, vsi); 957 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 958 idx = vec_all_ge(vui, vui); 959 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 960 idx = vec_all_ge(vui, vbi); 961 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 962 idx = vec_all_ge(vbi, vui); 963 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 964 idx = vec_all_ge(vbi, vbi); 965 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 966 idx = vec_all_ge(vsl, vsl); 967 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 968 idx = vec_all_ge(vsl, vbl); 969 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 970 idx = vec_all_ge(vbl, vsl); 971 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 972 idx = vec_all_ge(vul, vul); 973 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 974 idx = vec_all_ge(vul, vbl); 975 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 976 idx = vec_all_ge(vbl, vul); 977 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 978 idx = vec_all_ge(vbl, vbl); 979 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 980 idx = vec_all_ge(vd, vd); 981 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 982 983 idx = vec_all_gt(vsc, vsc); 984 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 985 idx = vec_all_gt(vsc, vbc); 986 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 987 idx = vec_all_gt(vbc, vsc); 988 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 989 idx = vec_all_gt(vuc, vuc); 990 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 991 idx = vec_all_gt(vuc, vbc); 992 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 993 idx = vec_all_gt(vbc, vuc); 994 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 995 idx = vec_all_gt(vbc, vbc); 996 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 997 idx = vec_all_gt(vss, vss); 998 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 999 idx = vec_all_gt(vss, vbs); 1000 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1001 idx = vec_all_gt(vbs, vss); 1002 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1003 idx = vec_all_gt(vus, vus); 1004 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1005 idx = vec_all_gt(vus, vbs); 1006 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1007 idx = vec_all_gt(vbs, vus); 1008 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1009 idx = vec_all_gt(vbs, vbs); 1010 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1011 idx = vec_all_gt(vsi, vsi); 1012 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1013 idx = vec_all_gt(vsi, vbi); 1014 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1015 idx = vec_all_gt(vbi, vsi); 1016 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1017 idx = vec_all_gt(vui, vui); 1018 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1019 idx = vec_all_gt(vui, vbi); 1020 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1021 idx = vec_all_gt(vbi, vui); 1022 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1023 idx = vec_all_gt(vbi, vbi); 1024 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1025 idx = vec_all_gt(vsl, vsl); 1026 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1027 idx = vec_all_gt(vsl, vbl); 1028 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1029 idx = vec_all_gt(vbl, vsl); 1030 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1031 idx = vec_all_gt(vul, vul); 1032 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1033 idx = vec_all_gt(vul, vbl); 1034 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1035 idx = vec_all_gt(vbl, vul); 1036 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1037 idx = vec_all_gt(vbl, vbl); 1038 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1039 idx = vec_all_gt(vd, vd); 1040 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 1041 1042 idx = vec_all_le(vsc, vsc); 1043 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1044 idx = vec_all_le(vsc, vbc); 1045 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1046 idx = vec_all_le(vbc, vsc); 1047 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1048 idx = vec_all_le(vuc, vuc); 1049 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1050 idx = vec_all_le(vuc, vbc); 1051 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1052 idx = vec_all_le(vbc, vuc); 1053 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1054 idx = vec_all_le(vbc, vbc); 1055 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1056 idx = vec_all_le(vss, vss); 1057 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1058 idx = vec_all_le(vss, vbs); 1059 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1060 idx = vec_all_le(vbs, vss); 1061 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1062 idx = vec_all_le(vus, vus); 1063 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1064 idx = vec_all_le(vus, vbs); 1065 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1066 idx = vec_all_le(vbs, vus); 1067 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1068 idx = vec_all_le(vbs, vbs); 1069 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1070 idx = vec_all_le(vsi, vsi); 1071 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1072 idx = vec_all_le(vsi, vbi); 1073 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1074 idx = vec_all_le(vbi, vsi); 1075 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1076 idx = vec_all_le(vui, vui); 1077 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1078 idx = vec_all_le(vui, vbi); 1079 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1080 idx = vec_all_le(vbi, vui); 1081 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1082 idx = vec_all_le(vbi, vbi); 1083 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1084 idx = vec_all_le(vsl, vsl); 1085 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1086 idx = vec_all_le(vsl, vbl); 1087 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1088 idx = vec_all_le(vbl, vsl); 1089 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1090 idx = vec_all_le(vul, vul); 1091 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1092 idx = vec_all_le(vul, vbl); 1093 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1094 idx = vec_all_le(vbl, vul); 1095 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1096 idx = vec_all_le(vbl, vbl); 1097 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1098 idx = vec_all_le(vd, vd); 1099 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 1100 1101 idx = vec_all_lt(vsc, vsc); 1102 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1103 idx = vec_all_lt(vsc, vbc); 1104 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1105 idx = vec_all_lt(vbc, vsc); 1106 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1107 idx = vec_all_lt(vuc, vuc); 1108 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1109 idx = vec_all_lt(vuc, vbc); 1110 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1111 idx = vec_all_lt(vbc, vuc); 1112 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1113 idx = vec_all_lt(vbc, vbc); 1114 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1115 idx = vec_all_lt(vss, vss); 1116 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1117 idx = vec_all_lt(vss, vbs); 1118 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1119 idx = vec_all_lt(vbs, vss); 1120 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1121 idx = vec_all_lt(vus, vus); 1122 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1123 idx = vec_all_lt(vus, vbs); 1124 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1125 idx = vec_all_lt(vbs, vus); 1126 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1127 idx = vec_all_lt(vbs, vbs); 1128 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1129 idx = vec_all_lt(vsi, vsi); 1130 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1131 idx = vec_all_lt(vsi, vbi); 1132 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1133 idx = vec_all_lt(vbi, vsi); 1134 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1135 idx = vec_all_lt(vui, vui); 1136 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1137 idx = vec_all_lt(vui, vbi); 1138 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1139 idx = vec_all_lt(vbi, vui); 1140 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1141 idx = vec_all_lt(vbi, vbi); 1142 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1143 idx = vec_all_lt(vsl, vsl); 1144 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1145 idx = vec_all_lt(vsl, vbl); 1146 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1147 idx = vec_all_lt(vbl, vsl); 1148 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1149 idx = vec_all_lt(vul, vul); 1150 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1151 idx = vec_all_lt(vul, vbl); 1152 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1153 idx = vec_all_lt(vbl, vul); 1154 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1155 idx = vec_all_lt(vbl, vbl); 1156 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1157 idx = vec_all_lt(vd, vd); 1158 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 1159 1160 idx = vec_all_nge(vd, vd); 1161 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 1162 idx = vec_all_ngt(vd, vd); 1163 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 1164 idx = vec_all_nle(vd, vd); 1165 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 1166 idx = vec_all_nlt(vd, vd); 1167 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 1168 1169 idx = vec_all_nan(vd); 1170 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15) 1171 idx = vec_all_numeric(vd); 1172 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15) 1173 1174 idx = vec_any_eq(vsc, vsc); 1175 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1176 idx = vec_any_eq(vsc, vbc); 1177 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1178 idx = vec_any_eq(vbc, vsc); 1179 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1180 idx = vec_any_eq(vuc, vuc); 1181 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1182 idx = vec_any_eq(vuc, vbc); 1183 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1184 idx = vec_any_eq(vbc, vuc); 1185 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1186 idx = vec_any_eq(vbc, vbc); 1187 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1188 idx = vec_any_eq(vss, vss); 1189 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1190 idx = vec_any_eq(vss, vbs); 1191 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1192 idx = vec_any_eq(vbs, vss); 1193 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1194 idx = vec_any_eq(vus, vus); 1195 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1196 idx = vec_any_eq(vus, vbs); 1197 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1198 idx = vec_any_eq(vbs, vus); 1199 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1200 idx = vec_any_eq(vbs, vbs); 1201 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1202 idx = vec_any_eq(vsi, vsi); 1203 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1204 idx = vec_any_eq(vsi, vbi); 1205 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1206 idx = vec_any_eq(vbi, vsi); 1207 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1208 idx = vec_any_eq(vui, vui); 1209 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1210 idx = vec_any_eq(vui, vbi); 1211 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1212 idx = vec_any_eq(vbi, vui); 1213 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1214 idx = vec_any_eq(vbi, vbi); 1215 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1216 idx = vec_any_eq(vsl, vsl); 1217 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1218 idx = vec_any_eq(vsl, vbl); 1219 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1220 idx = vec_any_eq(vbl, vsl); 1221 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1222 idx = vec_any_eq(vul, vul); 1223 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1224 idx = vec_any_eq(vul, vbl); 1225 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1226 idx = vec_any_eq(vbl, vul); 1227 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1228 idx = vec_any_eq(vbl, vbl); 1229 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1230 idx = vec_any_eq(vd, vd); 1231 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 1232 1233 idx = vec_any_ne(vsc, vsc); 1234 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1235 idx = vec_any_ne(vsc, vbc); 1236 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1237 idx = vec_any_ne(vbc, vsc); 1238 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1239 idx = vec_any_ne(vuc, vuc); 1240 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1241 idx = vec_any_ne(vuc, vbc); 1242 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1243 idx = vec_any_ne(vbc, vuc); 1244 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1245 idx = vec_any_ne(vbc, vbc); 1246 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vceqbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1247 idx = vec_any_ne(vss, vss); 1248 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1249 idx = vec_any_ne(vss, vbs); 1250 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1251 idx = vec_any_ne(vbs, vss); 1252 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1253 idx = vec_any_ne(vus, vus); 1254 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1255 idx = vec_any_ne(vus, vbs); 1256 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1257 idx = vec_any_ne(vbs, vus); 1258 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1259 idx = vec_any_ne(vbs, vbs); 1260 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vceqhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1261 idx = vec_any_ne(vsi, vsi); 1262 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1263 idx = vec_any_ne(vsi, vbi); 1264 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1265 idx = vec_any_ne(vbi, vsi); 1266 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1267 idx = vec_any_ne(vui, vui); 1268 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1269 idx = vec_any_ne(vui, vbi); 1270 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1271 idx = vec_any_ne(vbi, vui); 1272 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1273 idx = vec_any_ne(vbi, vbi); 1274 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vceqfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1275 idx = vec_any_ne(vsl, vsl); 1276 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1277 idx = vec_any_ne(vsl, vbl); 1278 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1279 idx = vec_any_ne(vbl, vsl); 1280 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1281 idx = vec_any_ne(vul, vul); 1282 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1283 idx = vec_any_ne(vul, vbl); 1284 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1285 idx = vec_any_ne(vbl, vul); 1286 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1287 idx = vec_any_ne(vbl, vbl); 1288 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vceqgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1289 idx = vec_any_ne(vd, vd); 1290 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 1291 1292 idx = vec_any_ge(vsc, vsc); 1293 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1294 idx = vec_any_ge(vsc, vbc); 1295 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1296 idx = vec_any_ge(vbc, vsc); 1297 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1298 idx = vec_any_ge(vuc, vuc); 1299 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1300 idx = vec_any_ge(vuc, vbc); 1301 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1302 idx = vec_any_ge(vbc, vuc); 1303 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1304 idx = vec_any_ge(vbc, vbc); 1305 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1306 idx = vec_any_ge(vss, vss); 1307 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1308 idx = vec_any_ge(vss, vbs); 1309 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1310 idx = vec_any_ge(vbs, vss); 1311 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1312 idx = vec_any_ge(vus, vus); 1313 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1314 idx = vec_any_ge(vus, vbs); 1315 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1316 idx = vec_any_ge(vbs, vus); 1317 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1318 idx = vec_any_ge(vbs, vbs); 1319 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1320 idx = vec_any_ge(vsi, vsi); 1321 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1322 idx = vec_any_ge(vsi, vbi); 1323 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1324 idx = vec_any_ge(vbi, vsi); 1325 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1326 idx = vec_any_ge(vui, vui); 1327 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1328 idx = vec_any_ge(vui, vbi); 1329 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1330 idx = vec_any_ge(vbi, vui); 1331 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1332 idx = vec_any_ge(vbi, vbi); 1333 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1334 idx = vec_any_ge(vsl, vsl); 1335 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1336 idx = vec_any_ge(vsl, vbl); 1337 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1338 idx = vec_any_ge(vbl, vsl); 1339 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1340 idx = vec_any_ge(vul, vul); 1341 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1342 idx = vec_any_ge(vul, vbl); 1343 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1344 idx = vec_any_ge(vbl, vul); 1345 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1346 idx = vec_any_ge(vbl, vbl); 1347 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1348 idx = vec_any_ge(vd, vd); 1349 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 1350 1351 idx = vec_any_gt(vsc, vsc); 1352 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1353 idx = vec_any_gt(vsc, vbc); 1354 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1355 idx = vec_any_gt(vbc, vsc); 1356 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1357 idx = vec_any_gt(vuc, vuc); 1358 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1359 idx = vec_any_gt(vuc, vbc); 1360 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1361 idx = vec_any_gt(vbc, vuc); 1362 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1363 idx = vec_any_gt(vbc, vbc); 1364 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1365 idx = vec_any_gt(vss, vss); 1366 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1367 idx = vec_any_gt(vss, vbs); 1368 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1369 idx = vec_any_gt(vbs, vss); 1370 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1371 idx = vec_any_gt(vus, vus); 1372 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1373 idx = vec_any_gt(vus, vbs); 1374 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1375 idx = vec_any_gt(vbs, vus); 1376 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1377 idx = vec_any_gt(vbs, vbs); 1378 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1379 idx = vec_any_gt(vsi, vsi); 1380 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1381 idx = vec_any_gt(vsi, vbi); 1382 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1383 idx = vec_any_gt(vbi, vsi); 1384 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1385 idx = vec_any_gt(vui, vui); 1386 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1387 idx = vec_any_gt(vui, vbi); 1388 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1389 idx = vec_any_gt(vbi, vui); 1390 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1391 idx = vec_any_gt(vbi, vbi); 1392 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1393 idx = vec_any_gt(vsl, vsl); 1394 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1395 idx = vec_any_gt(vsl, vbl); 1396 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1397 idx = vec_any_gt(vbl, vsl); 1398 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1399 idx = vec_any_gt(vul, vul); 1400 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1401 idx = vec_any_gt(vul, vbl); 1402 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1403 idx = vec_any_gt(vbl, vul); 1404 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1405 idx = vec_any_gt(vbl, vbl); 1406 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1407 idx = vec_any_gt(vd, vd); 1408 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 1409 1410 idx = vec_any_le(vsc, vsc); 1411 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1412 idx = vec_any_le(vsc, vbc); 1413 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1414 idx = vec_any_le(vbc, vsc); 1415 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1416 idx = vec_any_le(vuc, vuc); 1417 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1418 idx = vec_any_le(vuc, vbc); 1419 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1420 idx = vec_any_le(vbc, vuc); 1421 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1422 idx = vec_any_le(vbc, vbc); 1423 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1424 idx = vec_any_le(vss, vss); 1425 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1426 idx = vec_any_le(vss, vbs); 1427 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1428 idx = vec_any_le(vbs, vss); 1429 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1430 idx = vec_any_le(vus, vus); 1431 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1432 idx = vec_any_le(vus, vbs); 1433 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1434 idx = vec_any_le(vbs, vus); 1435 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1436 idx = vec_any_le(vbs, vbs); 1437 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1438 idx = vec_any_le(vsi, vsi); 1439 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1440 idx = vec_any_le(vsi, vbi); 1441 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1442 idx = vec_any_le(vbi, vsi); 1443 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1444 idx = vec_any_le(vui, vui); 1445 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1446 idx = vec_any_le(vui, vbi); 1447 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1448 idx = vec_any_le(vbi, vui); 1449 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1450 idx = vec_any_le(vbi, vbi); 1451 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1452 idx = vec_any_le(vsl, vsl); 1453 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1454 idx = vec_any_le(vsl, vbl); 1455 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1456 idx = vec_any_le(vbl, vsl); 1457 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1458 idx = vec_any_le(vul, vul); 1459 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1460 idx = vec_any_le(vul, vbl); 1461 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1462 idx = vec_any_le(vbl, vul); 1463 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1464 idx = vec_any_le(vbl, vbl); 1465 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1466 idx = vec_any_le(vd, vd); 1467 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 1468 1469 idx = vec_any_lt(vsc, vsc); 1470 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1471 idx = vec_any_lt(vsc, vbc); 1472 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1473 idx = vec_any_lt(vbc, vsc); 1474 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1475 idx = vec_any_lt(vuc, vuc); 1476 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1477 idx = vec_any_lt(vuc, vbc); 1478 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1479 idx = vec_any_lt(vbc, vuc); 1480 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1481 idx = vec_any_lt(vbc, vbc); 1482 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vchlbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1483 idx = vec_any_lt(vss, vss); 1484 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1485 idx = vec_any_lt(vss, vbs); 1486 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1487 idx = vec_any_lt(vbs, vss); 1488 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1489 idx = vec_any_lt(vus, vus); 1490 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1491 idx = vec_any_lt(vus, vbs); 1492 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1493 idx = vec_any_lt(vbs, vus); 1494 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1495 idx = vec_any_lt(vbs, vbs); 1496 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vchlhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1497 idx = vec_any_lt(vsi, vsi); 1498 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1499 idx = vec_any_lt(vsi, vbi); 1500 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1501 idx = vec_any_lt(vbi, vsi); 1502 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1503 idx = vec_any_lt(vui, vui); 1504 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1505 idx = vec_any_lt(vui, vbi); 1506 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1507 idx = vec_any_lt(vbi, vui); 1508 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1509 idx = vec_any_lt(vbi, vbi); 1510 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vchlfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1511 idx = vec_any_lt(vsl, vsl); 1512 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1513 idx = vec_any_lt(vsl, vbl); 1514 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1515 idx = vec_any_lt(vbl, vsl); 1516 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1517 idx = vec_any_lt(vul, vul); 1518 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1519 idx = vec_any_lt(vul, vbl); 1520 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1521 idx = vec_any_lt(vbl, vul); 1522 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1523 idx = vec_any_lt(vbl, vbl); 1524 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vchlgs(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1525 idx = vec_any_lt(vd, vd); 1526 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 1527 1528 idx = vec_any_nge(vd, vd); 1529 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 1530 idx = vec_any_ngt(vd, vd); 1531 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 1532 idx = vec_any_nle(vd, vd); 1533 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 1534 idx = vec_any_nlt(vd, vd); 1535 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 1536 1537 idx = vec_any_nan(vd); 1538 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15) 1539 idx = vec_any_numeric(vd); 1540 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15) 1541 } 1542 1543 void test_integer(void) { 1544 vsc = vec_andc(vsc, vsc); 1545 vsc = vec_andc(vsc, vbc); 1546 vsc = vec_andc(vbc, vsc); 1547 vuc = vec_andc(vuc, vuc); 1548 vuc = vec_andc(vuc, vbc); 1549 vuc = vec_andc(vbc, vuc); 1550 vbc = vec_andc(vbc, vbc); 1551 vss = vec_andc(vss, vss); 1552 vss = vec_andc(vss, vbs); 1553 vss = vec_andc(vbs, vss); 1554 vus = vec_andc(vus, vus); 1555 vus = vec_andc(vus, vbs); 1556 vus = vec_andc(vbs, vus); 1557 vbs = vec_andc(vbs, vbs); 1558 vsi = vec_andc(vsi, vsi); 1559 vsi = vec_andc(vsi, vbi); 1560 vsi = vec_andc(vbi, vsi); 1561 vui = vec_andc(vui, vui); 1562 vui = vec_andc(vui, vbi); 1563 vui = vec_andc(vbi, vui); 1564 vbi = vec_andc(vbi, vbi); 1565 vsl = vec_andc(vsl, vsl); 1566 vsl = vec_andc(vsl, vbl); 1567 vsl = vec_andc(vbl, vsl); 1568 vul = vec_andc(vul, vul); 1569 vul = vec_andc(vul, vbl); 1570 vul = vec_andc(vbl, vul); 1571 vbl = vec_andc(vbl, vbl); 1572 vd = vec_andc(vd, vd); 1573 vd = vec_andc(vd, vbl); 1574 vd = vec_andc(vbl, vd); 1575 1576 vsc = vec_nor(vsc, vsc); 1577 vsc = vec_nor(vsc, vbc); 1578 vsc = vec_nor(vbc, vsc); 1579 vuc = vec_nor(vuc, vuc); 1580 vuc = vec_nor(vuc, vbc); 1581 vuc = vec_nor(vbc, vuc); 1582 vbc = vec_nor(vbc, vbc); 1583 vss = vec_nor(vss, vss); 1584 vss = vec_nor(vss, vbs); 1585 vss = vec_nor(vbs, vss); 1586 vus = vec_nor(vus, vus); 1587 vus = vec_nor(vus, vbs); 1588 vus = vec_nor(vbs, vus); 1589 vbs = vec_nor(vbs, vbs); 1590 vsi = vec_nor(vsi, vsi); 1591 vsi = vec_nor(vsi, vbi); 1592 vsi = vec_nor(vbi, vsi); 1593 vui = vec_nor(vui, vui); 1594 vui = vec_nor(vui, vbi); 1595 vui = vec_nor(vbi, vui); 1596 vbi = vec_nor(vbi, vbi); 1597 vsl = vec_nor(vsl, vsl); 1598 vsl = vec_nor(vsl, vbl); 1599 vsl = vec_nor(vbl, vsl); 1600 vul = vec_nor(vul, vul); 1601 vul = vec_nor(vul, vbl); 1602 vul = vec_nor(vbl, vul); 1603 vbl = vec_nor(vbl, vbl); 1604 vd = vec_nor(vd, vd); 1605 vd = vec_nor(vd, vbl); 1606 vd = vec_nor(vbl, vd); 1607 1608 vuc = vec_cntlz(vsc); 1609 // CHECK: call <16 x i8> @llvm.ctlz.v16i8(<16 x i8> %{{.*}}, i1 false) 1610 vuc = vec_cntlz(vuc); 1611 // CHECK: call <16 x i8> @llvm.ctlz.v16i8(<16 x i8> %{{.*}}, i1 false) 1612 vus = vec_cntlz(vss); 1613 // CHECK: call <8 x i16> @llvm.ctlz.v8i16(<8 x i16> %{{.*}}, i1 false) 1614 vus = vec_cntlz(vus); 1615 // CHECK: call <8 x i16> @llvm.ctlz.v8i16(<8 x i16> %{{.*}}, i1 false) 1616 vui = vec_cntlz(vsi); 1617 // CHECK: call <4 x i32> @llvm.ctlz.v4i32(<4 x i32> %{{.*}}, i1 false) 1618 vui = vec_cntlz(vui); 1619 // CHECK: call <4 x i32> @llvm.ctlz.v4i32(<4 x i32> %{{.*}}, i1 false) 1620 vul = vec_cntlz(vsl); 1621 // CHECK: call <2 x i64> @llvm.ctlz.v2i64(<2 x i64> %{{.*}}, i1 false) 1622 vul = vec_cntlz(vul); 1623 // CHECK: call <2 x i64> @llvm.ctlz.v2i64(<2 x i64> %{{.*}}, i1 false) 1624 1625 vuc = vec_cnttz(vsc); 1626 // CHECK: call <16 x i8> @llvm.cttz.v16i8(<16 x i8> %{{.*}}, i1 false) 1627 vuc = vec_cnttz(vuc); 1628 // CHECK: call <16 x i8> @llvm.cttz.v16i8(<16 x i8> %{{.*}}, i1 false) 1629 vus = vec_cnttz(vss); 1630 // CHECK: call <8 x i16> @llvm.cttz.v8i16(<8 x i16> %{{.*}}, i1 false) 1631 vus = vec_cnttz(vus); 1632 // CHECK: call <8 x i16> @llvm.cttz.v8i16(<8 x i16> %{{.*}}, i1 false) 1633 vui = vec_cnttz(vsi); 1634 // CHECK: call <4 x i32> @llvm.cttz.v4i32(<4 x i32> %{{.*}}, i1 false) 1635 vui = vec_cnttz(vui); 1636 // CHECK: call <4 x i32> @llvm.cttz.v4i32(<4 x i32> %{{.*}}, i1 false) 1637 vul = vec_cnttz(vsl); 1638 // CHECK: call <2 x i64> @llvm.cttz.v2i64(<2 x i64> %{{.*}}, i1 false) 1639 vul = vec_cnttz(vul); 1640 // CHECK: call <2 x i64> @llvm.cttz.v2i64(<2 x i64> %{{.*}}, i1 false) 1641 1642 vuc = vec_popcnt(vsc); 1643 // CHECK: call <16 x i8> @llvm.ctpop.v16i8(<16 x i8> %{{.*}}) 1644 vuc = vec_popcnt(vuc); 1645 // CHECK: call <16 x i8> @llvm.ctpop.v16i8(<16 x i8> %{{.*}}) 1646 vus = vec_popcnt(vss); 1647 // CHECK: call <8 x i16> @llvm.ctpop.v8i16(<8 x i16> %{{.*}}) 1648 vus = vec_popcnt(vus); 1649 // CHECK: call <8 x i16> @llvm.ctpop.v8i16(<8 x i16> %{{.*}}) 1650 vui = vec_popcnt(vsi); 1651 // CHECK: call <4 x i32> @llvm.ctpop.v4i32(<4 x i32> %{{.*}}) 1652 vui = vec_popcnt(vui); 1653 // CHECK: call <4 x i32> @llvm.ctpop.v4i32(<4 x i32> %{{.*}}) 1654 vul = vec_popcnt(vsl); 1655 // CHECK: call <2 x i64> @llvm.ctpop.v2i64(<2 x i64> %{{.*}}) 1656 vul = vec_popcnt(vul); 1657 // CHECK: call <2 x i64> @llvm.ctpop.v2i64(<2 x i64> %{{.*}}) 1658 1659 vsc = vec_rl(vsc, vuc); 1660 // CHECK: call <16 x i8> @llvm.s390.verllvb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1661 vuc = vec_rl(vuc, vuc); 1662 // CHECK: call <16 x i8> @llvm.s390.verllvb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1663 vss = vec_rl(vss, vus); 1664 // CHECK: call <8 x i16> @llvm.s390.verllvh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1665 vus = vec_rl(vus, vus); 1666 // CHECK: call <8 x i16> @llvm.s390.verllvh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1667 vsi = vec_rl(vsi, vui); 1668 // CHECK: call <4 x i32> @llvm.s390.verllvf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1669 vui = vec_rl(vui, vui); 1670 // CHECK: call <4 x i32> @llvm.s390.verllvf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1671 vsl = vec_rl(vsl, vul); 1672 // CHECK: call <2 x i64> @llvm.s390.verllvg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1673 vul = vec_rl(vul, vul); 1674 // CHECK: call <2 x i64> @llvm.s390.verllvg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1675 1676 vsc = vec_rli(vsc, ul); 1677 // CHECK: call <16 x i8> @llvm.s390.verllb(<16 x i8> %{{.*}}, i32 %{{.*}}) 1678 vuc = vec_rli(vuc, ul); 1679 // CHECK: call <16 x i8> @llvm.s390.verllb(<16 x i8> %{{.*}}, i32 %{{.*}}) 1680 vss = vec_rli(vss, ul); 1681 // CHECK: call <8 x i16> @llvm.s390.verllh(<8 x i16> %{{.*}}, i32 %{{.*}}) 1682 vus = vec_rli(vus, ul); 1683 // CHECK: call <8 x i16> @llvm.s390.verllh(<8 x i16> %{{.*}}, i32 %{{.*}}) 1684 vsi = vec_rli(vsi, ul); 1685 // CHECK: call <4 x i32> @llvm.s390.verllf(<4 x i32> %{{.*}}, i32 %{{.*}}) 1686 vui = vec_rli(vui, ul); 1687 // CHECK: call <4 x i32> @llvm.s390.verllf(<4 x i32> %{{.*}}, i32 %{{.*}}) 1688 vsl = vec_rli(vsl, ul); 1689 // CHECK: call <2 x i64> @llvm.s390.verllg(<2 x i64> %{{.*}}, i32 %{{.*}}) 1690 vul = vec_rli(vul, ul); 1691 // CHECK: call <2 x i64> @llvm.s390.verllg(<2 x i64> %{{.*}}, i32 %{{.*}}) 1692 1693 vsc = vec_rl_mask(vsc, vuc, 0); 1694 // CHECK: call <16 x i8> @llvm.s390.verimb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 1695 vsc = vec_rl_mask(vsc, vuc, 255); 1696 // CHECK: call <16 x i8> @llvm.s390.verimb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255) 1697 vuc = vec_rl_mask(vuc, vuc, 0); 1698 // CHECK: call <16 x i8> @llvm.s390.verimb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 1699 vuc = vec_rl_mask(vuc, vuc, 255); 1700 // CHECK: call <16 x i8> @llvm.s390.verimb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 255) 1701 vss = vec_rl_mask(vss, vus, 0); 1702 // CHECK: call <8 x i16> @llvm.s390.verimh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0) 1703 vss = vec_rl_mask(vss, vus, 255); 1704 // CHECK: call <8 x i16> @llvm.s390.verimh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 255) 1705 vus = vec_rl_mask(vus, vus, 0); 1706 // CHECK: call <8 x i16> @llvm.s390.verimh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0) 1707 vus = vec_rl_mask(vus, vus, 255); 1708 // CHECK: call <8 x i16> @llvm.s390.verimh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 255) 1709 vsi = vec_rl_mask(vsi, vui, 0); 1710 // CHECK: call <4 x i32> @llvm.s390.verimf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0) 1711 vsi = vec_rl_mask(vsi, vui, 255); 1712 // CHECK: call <4 x i32> @llvm.s390.verimf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 255) 1713 vui = vec_rl_mask(vui, vui, 0); 1714 // CHECK: call <4 x i32> @llvm.s390.verimf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0) 1715 vui = vec_rl_mask(vui, vui, 255); 1716 // CHECK: call <4 x i32> @llvm.s390.verimf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 255) 1717 vsl = vec_rl_mask(vsl, vul, 0); 1718 // CHECK: call <2 x i64> @llvm.s390.verimg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 0) 1719 vsl = vec_rl_mask(vsl, vul, 255); 1720 // CHECK: call <2 x i64> @llvm.s390.verimg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 255) 1721 vul = vec_rl_mask(vul, vul, 0); 1722 // CHECK: call <2 x i64> @llvm.s390.verimg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 0) 1723 vul = vec_rl_mask(vul, vul, 255); 1724 // CHECK: call <2 x i64> @llvm.s390.verimg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i32 255) 1725 1726 vsc = vec_sll(vsc, vuc); 1727 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1728 vsc = vec_sll(vsc, vus); 1729 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1730 vsc = vec_sll(vsc, vui); 1731 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1732 vuc = vec_sll(vuc, vuc); 1733 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1734 vuc = vec_sll(vuc, vus); 1735 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1736 vuc = vec_sll(vuc, vui); 1737 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1738 vbc = vec_sll(vbc, vuc); 1739 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1740 vbc = vec_sll(vbc, vus); 1741 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1742 vbc = vec_sll(vbc, vui); 1743 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1744 vss = vec_sll(vss, vuc); 1745 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1746 vss = vec_sll(vss, vus); 1747 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1748 vss = vec_sll(vss, vui); 1749 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1750 vus = vec_sll(vus, vuc); 1751 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1752 vus = vec_sll(vus, vus); 1753 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1754 vus = vec_sll(vus, vui); 1755 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1756 vbs = vec_sll(vbs, vuc); 1757 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1758 vbs = vec_sll(vbs, vus); 1759 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1760 vbs = vec_sll(vbs, vui); 1761 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1762 vsi = vec_sll(vsi, vuc); 1763 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1764 vsi = vec_sll(vsi, vus); 1765 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1766 vsi = vec_sll(vsi, vui); 1767 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1768 vui = vec_sll(vui, vuc); 1769 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1770 vui = vec_sll(vui, vus); 1771 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1772 vui = vec_sll(vui, vui); 1773 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1774 vbi = vec_sll(vbi, vuc); 1775 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1776 vbi = vec_sll(vbi, vus); 1777 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1778 vbi = vec_sll(vbi, vui); 1779 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1780 vsl = vec_sll(vsl, vuc); 1781 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1782 vsl = vec_sll(vsl, vus); 1783 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1784 vsl = vec_sll(vsl, vui); 1785 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1786 vul = vec_sll(vul, vuc); 1787 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1788 vul = vec_sll(vul, vus); 1789 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1790 vul = vec_sll(vul, vui); 1791 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1792 vbl = vec_sll(vbl, vuc); 1793 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1794 vbl = vec_sll(vbl, vus); 1795 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1796 vbl = vec_sll(vbl, vui); 1797 // CHECK: call <16 x i8> @llvm.s390.vsl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1798 1799 vsc = vec_slb(vsc, vsc); 1800 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1801 vsc = vec_slb(vsc, vuc); 1802 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1803 vuc = vec_slb(vuc, vsc); 1804 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1805 vuc = vec_slb(vuc, vuc); 1806 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1807 vss = vec_slb(vss, vss); 1808 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1809 vss = vec_slb(vss, vus); 1810 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1811 vus = vec_slb(vus, vss); 1812 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1813 vus = vec_slb(vus, vus); 1814 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1815 vsi = vec_slb(vsi, vsi); 1816 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1817 vsi = vec_slb(vsi, vui); 1818 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1819 vui = vec_slb(vui, vsi); 1820 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1821 vui = vec_slb(vui, vui); 1822 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1823 vsl = vec_slb(vsl, vsl); 1824 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1825 vsl = vec_slb(vsl, vul); 1826 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1827 vul = vec_slb(vul, vsl); 1828 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1829 vul = vec_slb(vul, vul); 1830 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1831 vd = vec_slb(vd, vsl); 1832 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1833 vd = vec_slb(vd, vul); 1834 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1835 1836 vsc = vec_sld(vsc, vsc, 0); 1837 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 1838 vsc = vec_sld(vsc, vsc, 15); 1839 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15) 1840 vuc = vec_sld(vuc, vuc, 0); 1841 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 1842 vuc = vec_sld(vuc, vuc, 15); 1843 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15) 1844 vss = vec_sld(vss, vss, 0); 1845 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 1846 vss = vec_sld(vss, vss, 15); 1847 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15) 1848 vus = vec_sld(vus, vus, 0); 1849 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 1850 vus = vec_sld(vus, vus, 15); 1851 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15) 1852 vsi = vec_sld(vsi, vsi, 0); 1853 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 1854 vsi = vec_sld(vsi, vsi, 15); 1855 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15) 1856 vui = vec_sld(vui, vui, 0); 1857 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 1858 vui = vec_sld(vui, vui, 15); 1859 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15) 1860 vsl = vec_sld(vsl, vsl, 0); 1861 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 1862 vsl = vec_sld(vsl, vsl, 15); 1863 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15) 1864 vul = vec_sld(vul, vul, 0); 1865 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 1866 vul = vec_sld(vul, vul, 15); 1867 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15) 1868 vd = vec_sld(vd, vd, 0); 1869 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 1870 vd = vec_sld(vd, vd, 15); 1871 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15) 1872 1873 vsc = vec_sldw(vsc, vsc, 0); 1874 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 1875 vsc = vec_sldw(vsc, vsc, 3); 1876 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12) 1877 vuc = vec_sldw(vuc, vuc, 0); 1878 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 1879 vuc = vec_sldw(vuc, vuc, 3); 1880 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12) 1881 vss = vec_sldw(vss, vss, 0); 1882 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 1883 vss = vec_sldw(vss, vss, 3); 1884 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12) 1885 vus = vec_sldw(vus, vus, 0); 1886 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 1887 vus = vec_sldw(vus, vus, 3); 1888 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12) 1889 vsi = vec_sldw(vsi, vsi, 0); 1890 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 1891 vsi = vec_sldw(vsi, vsi, 3); 1892 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12) 1893 vui = vec_sldw(vui, vui, 0); 1894 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 1895 vui = vec_sldw(vui, vui, 3); 1896 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12) 1897 vsl = vec_sldw(vsl, vsl, 0); 1898 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 1899 vsl = vec_sldw(vsl, vsl, 3); 1900 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12) 1901 vul = vec_sldw(vul, vul, 0); 1902 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 1903 vul = vec_sldw(vul, vul, 3); 1904 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12) 1905 vd = vec_sldw(vd, vd, 0); 1906 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 1907 vd = vec_sldw(vd, vd, 3); 1908 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12) 1909 1910 vsc = vec_sral(vsc, vuc); 1911 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1912 vsc = vec_sral(vsc, vus); 1913 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1914 vsc = vec_sral(vsc, vui); 1915 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1916 vuc = vec_sral(vuc, vuc); 1917 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1918 vuc = vec_sral(vuc, vus); 1919 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1920 vuc = vec_sral(vuc, vui); 1921 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1922 vbc = vec_sral(vbc, vuc); 1923 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1924 vbc = vec_sral(vbc, vus); 1925 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1926 vbc = vec_sral(vbc, vui); 1927 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1928 vss = vec_sral(vss, vuc); 1929 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1930 vss = vec_sral(vss, vus); 1931 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1932 vss = vec_sral(vss, vui); 1933 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1934 vus = vec_sral(vus, vuc); 1935 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1936 vus = vec_sral(vus, vus); 1937 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1938 vus = vec_sral(vus, vui); 1939 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1940 vbs = vec_sral(vbs, vuc); 1941 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1942 vbs = vec_sral(vbs, vus); 1943 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1944 vbs = vec_sral(vbs, vui); 1945 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1946 vsi = vec_sral(vsi, vuc); 1947 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1948 vsi = vec_sral(vsi, vus); 1949 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1950 vsi = vec_sral(vsi, vui); 1951 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1952 vui = vec_sral(vui, vuc); 1953 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1954 vui = vec_sral(vui, vus); 1955 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1956 vui = vec_sral(vui, vui); 1957 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1958 vbi = vec_sral(vbi, vuc); 1959 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1960 vbi = vec_sral(vbi, vus); 1961 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1962 vbi = vec_sral(vbi, vui); 1963 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1964 vsl = vec_sral(vsl, vuc); 1965 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1966 vsl = vec_sral(vsl, vus); 1967 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1968 vsl = vec_sral(vsl, vui); 1969 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1970 vul = vec_sral(vul, vuc); 1971 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1972 vul = vec_sral(vul, vus); 1973 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1974 vul = vec_sral(vul, vui); 1975 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1976 vbl = vec_sral(vbl, vuc); 1977 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1978 vbl = vec_sral(vbl, vus); 1979 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1980 vbl = vec_sral(vbl, vui); 1981 // CHECK: call <16 x i8> @llvm.s390.vsra(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1982 1983 vsc = vec_srab(vsc, vsc); 1984 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1985 vsc = vec_srab(vsc, vuc); 1986 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1987 vuc = vec_srab(vuc, vsc); 1988 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1989 vuc = vec_srab(vuc, vuc); 1990 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1991 vss = vec_srab(vss, vss); 1992 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1993 vss = vec_srab(vss, vus); 1994 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1995 vus = vec_srab(vus, vss); 1996 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1997 vus = vec_srab(vus, vus); 1998 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 1999 vsi = vec_srab(vsi, vsi); 2000 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2001 vsi = vec_srab(vsi, vui); 2002 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2003 vui = vec_srab(vui, vsi); 2004 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2005 vui = vec_srab(vui, vui); 2006 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2007 vsl = vec_srab(vsl, vsl); 2008 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2009 vsl = vec_srab(vsl, vul); 2010 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2011 vul = vec_srab(vul, vsl); 2012 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2013 vul = vec_srab(vul, vul); 2014 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2015 vd = vec_srab(vd, vsl); 2016 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2017 vd = vec_srab(vd, vul); 2018 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2019 2020 vsc = vec_srl(vsc, vuc); 2021 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2022 vsc = vec_srl(vsc, vus); 2023 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2024 vsc = vec_srl(vsc, vui); 2025 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2026 vuc = vec_srl(vuc, vuc); 2027 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2028 vuc = vec_srl(vuc, vus); 2029 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2030 vuc = vec_srl(vuc, vui); 2031 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2032 vbc = vec_srl(vbc, vuc); 2033 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2034 vbc = vec_srl(vbc, vus); 2035 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2036 vbc = vec_srl(vbc, vui); 2037 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2038 vss = vec_srl(vss, vuc); 2039 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2040 vss = vec_srl(vss, vus); 2041 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2042 vss = vec_srl(vss, vui); 2043 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2044 vus = vec_srl(vus, vuc); 2045 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2046 vus = vec_srl(vus, vus); 2047 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2048 vus = vec_srl(vus, vui); 2049 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2050 vbs = vec_srl(vbs, vuc); 2051 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2052 vbs = vec_srl(vbs, vus); 2053 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2054 vbs = vec_srl(vbs, vui); 2055 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2056 vsi = vec_srl(vsi, vuc); 2057 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2058 vsi = vec_srl(vsi, vus); 2059 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2060 vsi = vec_srl(vsi, vui); 2061 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2062 vui = vec_srl(vui, vuc); 2063 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2064 vui = vec_srl(vui, vus); 2065 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2066 vui = vec_srl(vui, vui); 2067 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2068 vbi = vec_srl(vbi, vuc); 2069 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2070 vbi = vec_srl(vbi, vus); 2071 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2072 vbi = vec_srl(vbi, vui); 2073 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2074 vsl = vec_srl(vsl, vuc); 2075 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2076 vsl = vec_srl(vsl, vus); 2077 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2078 vsl = vec_srl(vsl, vui); 2079 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2080 vul = vec_srl(vul, vuc); 2081 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2082 vul = vec_srl(vul, vus); 2083 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2084 vul = vec_srl(vul, vui); 2085 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2086 vbl = vec_srl(vbl, vuc); 2087 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2088 vbl = vec_srl(vbl, vus); 2089 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2090 vbl = vec_srl(vbl, vui); 2091 // CHECK: call <16 x i8> @llvm.s390.vsrl(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2092 2093 vsc = vec_srb(vsc, vsc); 2094 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2095 vsc = vec_srb(vsc, vuc); 2096 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2097 vuc = vec_srb(vuc, vsc); 2098 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2099 vuc = vec_srb(vuc, vuc); 2100 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2101 vss = vec_srb(vss, vss); 2102 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2103 vss = vec_srb(vss, vus); 2104 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2105 vus = vec_srb(vus, vss); 2106 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2107 vus = vec_srb(vus, vus); 2108 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2109 vsi = vec_srb(vsi, vsi); 2110 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2111 vsi = vec_srb(vsi, vui); 2112 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2113 vui = vec_srb(vui, vsi); 2114 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2115 vui = vec_srb(vui, vui); 2116 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2117 vsl = vec_srb(vsl, vsl); 2118 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2119 vsl = vec_srb(vsl, vul); 2120 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2121 vul = vec_srb(vul, vsl); 2122 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2123 vul = vec_srb(vul, vul); 2124 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2125 vd = vec_srb(vd, vsl); 2126 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2127 vd = vec_srb(vd, vul); 2128 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2129 2130 vsc = vec_abs(vsc); 2131 vss = vec_abs(vss); 2132 vsi = vec_abs(vsi); 2133 vsl = vec_abs(vsl); 2134 2135 vsc = vec_max(vsc, vsc); 2136 vsc = vec_max(vsc, vbc); 2137 vsc = vec_max(vbc, vsc); 2138 vuc = vec_max(vuc, vuc); 2139 vuc = vec_max(vuc, vbc); 2140 vuc = vec_max(vbc, vuc); 2141 vss = vec_max(vss, vss); 2142 vss = vec_max(vss, vbs); 2143 vss = vec_max(vbs, vss); 2144 vus = vec_max(vus, vus); 2145 vus = vec_max(vus, vbs); 2146 vus = vec_max(vbs, vus); 2147 vsi = vec_max(vsi, vsi); 2148 vsi = vec_max(vsi, vbi); 2149 vsi = vec_max(vbi, vsi); 2150 vui = vec_max(vui, vui); 2151 vui = vec_max(vui, vbi); 2152 vui = vec_max(vbi, vui); 2153 vsl = vec_max(vsl, vsl); 2154 vsl = vec_max(vsl, vbl); 2155 vsl = vec_max(vbl, vsl); 2156 vul = vec_max(vul, vul); 2157 vul = vec_max(vul, vbl); 2158 vul = vec_max(vbl, vul); 2159 vd = vec_max(vd, vd); 2160 2161 vsc = vec_min(vsc, vsc); 2162 vsc = vec_min(vsc, vbc); 2163 vsc = vec_min(vbc, vsc); 2164 vuc = vec_min(vuc, vuc); 2165 vuc = vec_min(vuc, vbc); 2166 vuc = vec_min(vbc, vuc); 2167 vss = vec_min(vss, vss); 2168 vss = vec_min(vss, vbs); 2169 vss = vec_min(vbs, vss); 2170 vus = vec_min(vus, vus); 2171 vus = vec_min(vus, vbs); 2172 vus = vec_min(vbs, vus); 2173 vsi = vec_min(vsi, vsi); 2174 vsi = vec_min(vsi, vbi); 2175 vsi = vec_min(vbi, vsi); 2176 vui = vec_min(vui, vui); 2177 vui = vec_min(vui, vbi); 2178 vui = vec_min(vbi, vui); 2179 vsl = vec_min(vsl, vsl); 2180 vsl = vec_min(vsl, vbl); 2181 vsl = vec_min(vbl, vsl); 2182 vul = vec_min(vul, vul); 2183 vul = vec_min(vul, vbl); 2184 vul = vec_min(vbl, vul); 2185 vd = vec_min(vd, vd); 2186 2187 vuc = vec_addc(vuc, vuc); 2188 // CHECK: call <16 x i8> @llvm.s390.vaccb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2189 vus = vec_addc(vus, vus); 2190 // CHECK: call <8 x i16> @llvm.s390.vacch(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2191 vui = vec_addc(vui, vui); 2192 // CHECK: call <4 x i32> @llvm.s390.vaccf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2193 vul = vec_addc(vul, vul); 2194 // CHECK: call <2 x i64> @llvm.s390.vaccg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 2195 2196 vuc = vec_add_u128(vuc, vuc); 2197 // CHECK: call <16 x i8> @llvm.s390.vaq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2198 vuc = vec_addc_u128(vuc, vuc); 2199 // CHECK: call <16 x i8> @llvm.s390.vaccq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2200 vuc = vec_adde_u128(vuc, vuc, vuc); 2201 // CHECK: call <16 x i8> @llvm.s390.vacq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2202 vuc = vec_addec_u128(vuc, vuc, vuc); 2203 // CHECK: call <16 x i8> @llvm.s390.vacccq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2204 2205 vsc = vec_avg(vsc, vsc); 2206 // CHECK: call <16 x i8> @llvm.s390.vavgb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2207 vuc = vec_avg(vuc, vuc); 2208 // CHECK: call <16 x i8> @llvm.s390.vavglb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2209 vss = vec_avg(vss, vss); 2210 // CHECK: call <8 x i16> @llvm.s390.vavgh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2211 vus = vec_avg(vus, vus); 2212 // CHECK: call <8 x i16> @llvm.s390.vavglh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2213 vsi = vec_avg(vsi, vsi); 2214 // CHECK: call <4 x i32> @llvm.s390.vavgf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2215 vui = vec_avg(vui, vui); 2216 // CHECK: call <4 x i32> @llvm.s390.vavglf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2217 vsl = vec_avg(vsl, vsl); 2218 // CHECK: call <2 x i64> @llvm.s390.vavgg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 2219 vul = vec_avg(vul, vul); 2220 // CHECK: call <2 x i64> @llvm.s390.vavglg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 2221 2222 vui = vec_checksum(vui, vui); 2223 // CHECK: call <4 x i32> @llvm.s390.vcksm(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2224 2225 vus = vec_gfmsum(vuc, vuc); 2226 // CHECK: call <8 x i16> @llvm.s390.vgfmb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2227 vui = vec_gfmsum(vus, vus); 2228 // CHECK: call <4 x i32> @llvm.s390.vgfmh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2229 vul = vec_gfmsum(vui, vui); 2230 // CHECK: call <2 x i64> @llvm.s390.vgfmf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2231 vuc = vec_gfmsum_128(vul, vul); 2232 // CHECK: call <16 x i8> @llvm.s390.vgfmg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 2233 2234 vus = vec_gfmsum_accum(vuc, vuc, vus); 2235 // CHECK: call <8 x i16> @llvm.s390.vgfmab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <8 x i16> %{{.*}}) 2236 vui = vec_gfmsum_accum(vus, vus, vui); 2237 // CHECK: call <4 x i32> @llvm.s390.vgfmah(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <4 x i32> %{{.*}}) 2238 vul = vec_gfmsum_accum(vui, vui, vul); 2239 // CHECK: call <2 x i64> @llvm.s390.vgfmaf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <2 x i64> %{{.*}}) 2240 vuc = vec_gfmsum_accum_128(vul, vul, vuc); 2241 // CHECK: call <16 x i8> @llvm.s390.vgfmag(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <16 x i8> %{{.*}}) 2242 2243 vsc = vec_mladd(vsc, vsc, vsc); 2244 vsc = vec_mladd(vuc, vsc, vsc); 2245 vsc = vec_mladd(vsc, vuc, vuc); 2246 vuc = vec_mladd(vuc, vuc, vuc); 2247 vss = vec_mladd(vss, vss, vss); 2248 vss = vec_mladd(vus, vss, vss); 2249 vss = vec_mladd(vss, vus, vus); 2250 vus = vec_mladd(vus, vus, vus); 2251 vsi = vec_mladd(vsi, vsi, vsi); 2252 vsi = vec_mladd(vui, vsi, vsi); 2253 vsi = vec_mladd(vsi, vui, vui); 2254 vui = vec_mladd(vui, vui, vui); 2255 2256 vsc = vec_mhadd(vsc, vsc, vsc); 2257 // CHECK: call <16 x i8> @llvm.s390.vmahb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2258 vuc = vec_mhadd(vuc, vuc, vuc); 2259 // CHECK: call <16 x i8> @llvm.s390.vmalhb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2260 vss = vec_mhadd(vss, vss, vss); 2261 // CHECK: call <8 x i16> @llvm.s390.vmahh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2262 vus = vec_mhadd(vus, vus, vus); 2263 // CHECK: call <8 x i16> @llvm.s390.vmalhh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2264 vsi = vec_mhadd(vsi, vsi, vsi); 2265 // CHECK: call <4 x i32> @llvm.s390.vmahf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2266 vui = vec_mhadd(vui, vui, vui); 2267 // CHECK: call <4 x i32> @llvm.s390.vmalhf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2268 2269 vss = vec_meadd(vsc, vsc, vss); 2270 // CHECK: call <8 x i16> @llvm.s390.vmaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <8 x i16> %{{.*}}) 2271 vus = vec_meadd(vuc, vuc, vus); 2272 // CHECK: call <8 x i16> @llvm.s390.vmaleb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <8 x i16> %{{.*}}) 2273 vsi = vec_meadd(vss, vss, vsi); 2274 // CHECK: call <4 x i32> @llvm.s390.vmaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <4 x i32> %{{.*}}) 2275 vui = vec_meadd(vus, vus, vui); 2276 // CHECK: call <4 x i32> @llvm.s390.vmaleh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <4 x i32> %{{.*}}) 2277 vsl = vec_meadd(vsi, vsi, vsl); 2278 // CHECK: call <2 x i64> @llvm.s390.vmaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <2 x i64> %{{.*}}) 2279 vul = vec_meadd(vui, vui, vul); 2280 // CHECK: call <2 x i64> @llvm.s390.vmalef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <2 x i64> %{{.*}}) 2281 2282 vss = vec_moadd(vsc, vsc, vss); 2283 // CHECK: call <8 x i16> @llvm.s390.vmaob(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <8 x i16> %{{.*}}) 2284 vus = vec_moadd(vuc, vuc, vus); 2285 // CHECK: call <8 x i16> @llvm.s390.vmalob(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <8 x i16> %{{.*}}) 2286 vsi = vec_moadd(vss, vss, vsi); 2287 // CHECK: call <4 x i32> @llvm.s390.vmaoh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <4 x i32> %{{.*}}) 2288 vui = vec_moadd(vus, vus, vui); 2289 // CHECK: call <4 x i32> @llvm.s390.vmaloh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <4 x i32> %{{.*}}) 2290 vsl = vec_moadd(vsi, vsi, vsl); 2291 // CHECK: call <2 x i64> @llvm.s390.vmaof(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <2 x i64> %{{.*}}) 2292 vul = vec_moadd(vui, vui, vul); 2293 // CHECK: call <2 x i64> @llvm.s390.vmalof(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <2 x i64> %{{.*}}) 2294 2295 vsc = vec_mulh(vsc, vsc); 2296 // CHECK: call <16 x i8> @llvm.s390.vmhb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2297 vuc = vec_mulh(vuc, vuc); 2298 // CHECK: call <16 x i8> @llvm.s390.vmlhb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2299 vss = vec_mulh(vss, vss); 2300 // CHECK: call <8 x i16> @llvm.s390.vmhh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2301 vus = vec_mulh(vus, vus); 2302 // CHECK: call <8 x i16> @llvm.s390.vmlhh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2303 vsi = vec_mulh(vsi, vsi); 2304 // CHECK: call <4 x i32> @llvm.s390.vmhf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2305 vui = vec_mulh(vui, vui); 2306 // CHECK: call <4 x i32> @llvm.s390.vmlhf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2307 2308 vss = vec_mule(vsc, vsc); 2309 // CHECK: call <8 x i16> @llvm.s390.vmeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2310 vus = vec_mule(vuc, vuc); 2311 // CHECK: call <8 x i16> @llvm.s390.vmleb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2312 vsi = vec_mule(vss, vss); 2313 // CHECK: call <4 x i32> @llvm.s390.vmeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2314 vui = vec_mule(vus, vus); 2315 // CHECK: call <4 x i32> @llvm.s390.vmleh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2316 vsl = vec_mule(vsi, vsi); 2317 // CHECK: call <2 x i64> @llvm.s390.vmef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2318 vul = vec_mule(vui, vui); 2319 // CHECK: call <2 x i64> @llvm.s390.vmlef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2320 2321 vss = vec_mulo(vsc, vsc); 2322 // CHECK: call <8 x i16> @llvm.s390.vmob(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2323 vus = vec_mulo(vuc, vuc); 2324 // CHECK: call <8 x i16> @llvm.s390.vmlob(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2325 vsi = vec_mulo(vss, vss); 2326 // CHECK: call <4 x i32> @llvm.s390.vmoh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2327 vui = vec_mulo(vus, vus); 2328 // CHECK: call <4 x i32> @llvm.s390.vmloh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2329 vsl = vec_mulo(vsi, vsi); 2330 // CHECK: call <2 x i64> @llvm.s390.vmof(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2331 vul = vec_mulo(vui, vui); 2332 // CHECK: call <2 x i64> @llvm.s390.vmlof(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2333 2334 vuc = vec_subc(vuc, vuc); 2335 // CHECK: call <16 x i8> @llvm.s390.vscbib(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2336 vus = vec_subc(vus, vus); 2337 // CHECK: call <8 x i16> @llvm.s390.vscbih(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2338 vui = vec_subc(vui, vui); 2339 // CHECK: call <4 x i32> @llvm.s390.vscbif(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2340 vul = vec_subc(vul, vul); 2341 // CHECK: call <2 x i64> @llvm.s390.vscbig(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 2342 2343 vuc = vec_sub_u128(vuc, vuc); 2344 // CHECK: call <16 x i8> @llvm.s390.vsq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2345 vuc = vec_subc_u128(vuc, vuc); 2346 // CHECK: call <16 x i8> @llvm.s390.vscbiq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2347 vuc = vec_sube_u128(vuc, vuc, vuc); 2348 // CHECK: call <16 x i8> @llvm.s390.vsbiq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2349 vuc = vec_subec_u128(vuc, vuc, vuc); 2350 // CHECK: call <16 x i8> @llvm.s390.vsbcbiq(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2351 2352 vui = vec_sum4(vuc, vuc); 2353 // CHECK: call <4 x i32> @llvm.s390.vsumb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2354 vui = vec_sum4(vus, vus); 2355 // CHECK: call <4 x i32> @llvm.s390.vsumh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2356 vul = vec_sum2(vus, vus); 2357 // CHECK: call <2 x i64> @llvm.s390.vsumgh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2358 vul = vec_sum2(vui, vui); 2359 // CHECK: call <2 x i64> @llvm.s390.vsumgf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2360 vuc = vec_sum_u128(vui, vui); 2361 // CHECK: call <16 x i8> @llvm.s390.vsumqf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2362 vuc = vec_sum_u128(vul, vul); 2363 // CHECK: call <16 x i8> @llvm.s390.vsumqg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 2364 2365 idx = vec_test_mask(vsc, vuc); 2366 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2367 idx = vec_test_mask(vuc, vuc); 2368 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2369 idx = vec_test_mask(vss, vus); 2370 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2371 idx = vec_test_mask(vus, vus); 2372 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2373 idx = vec_test_mask(vsi, vui); 2374 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2375 idx = vec_test_mask(vui, vui); 2376 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2377 idx = vec_test_mask(vsl, vul); 2378 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2379 idx = vec_test_mask(vul, vul); 2380 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2381 idx = vec_test_mask(vd, vul); 2382 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2383 } 2384 2385 void test_string(void) { 2386 vsc = vec_cp_until_zero(vsc); 2387 // CHECK: call <16 x i8> @llvm.s390.vistrb(<16 x i8> %{{.*}}) 2388 vuc = vec_cp_until_zero(vuc); 2389 // CHECK: call <16 x i8> @llvm.s390.vistrb(<16 x i8> %{{.*}}) 2390 vbc = vec_cp_until_zero(vbc); 2391 // CHECK: call <16 x i8> @llvm.s390.vistrb(<16 x i8> %{{.*}}) 2392 vss = vec_cp_until_zero(vss); 2393 // CHECK: call <8 x i16> @llvm.s390.vistrh(<8 x i16> %{{.*}}) 2394 vus = vec_cp_until_zero(vus); 2395 // CHECK: call <8 x i16> @llvm.s390.vistrh(<8 x i16> %{{.*}}) 2396 vbs = vec_cp_until_zero(vbs); 2397 // CHECK: call <8 x i16> @llvm.s390.vistrh(<8 x i16> %{{.*}}) 2398 vsi = vec_cp_until_zero(vsi); 2399 // CHECK: call <4 x i32> @llvm.s390.vistrf(<4 x i32> %{{.*}}) 2400 vui = vec_cp_until_zero(vui); 2401 // CHECK: call <4 x i32> @llvm.s390.vistrf(<4 x i32> %{{.*}}) 2402 vbi = vec_cp_until_zero(vbi); 2403 // CHECK: call <4 x i32> @llvm.s390.vistrf(<4 x i32> %{{.*}}) 2404 2405 vsc = vec_cp_until_zero_cc(vsc, &cc); 2406 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vistrbs(<16 x i8> %{{.*}}) 2407 vuc = vec_cp_until_zero_cc(vuc, &cc); 2408 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vistrbs(<16 x i8> %{{.*}}) 2409 vbc = vec_cp_until_zero_cc(vbc, &cc); 2410 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vistrbs(<16 x i8> %{{.*}}) 2411 vss = vec_cp_until_zero_cc(vss, &cc); 2412 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vistrhs(<8 x i16> %{{.*}}) 2413 vus = vec_cp_until_zero_cc(vus, &cc); 2414 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vistrhs(<8 x i16> %{{.*}}) 2415 vbs = vec_cp_until_zero_cc(vbs, &cc); 2416 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vistrhs(<8 x i16> %{{.*}}) 2417 vsi = vec_cp_until_zero_cc(vsi, &cc); 2418 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vistrfs(<4 x i32> %{{.*}}) 2419 vui = vec_cp_until_zero_cc(vui, &cc); 2420 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vistrfs(<4 x i32> %{{.*}}) 2421 vbi = vec_cp_until_zero_cc(vbi, &cc); 2422 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vistrfs(<4 x i32> %{{.*}}) 2423 2424 vsc = vec_cmpeq_idx(vsc, vsc); 2425 // CHECK: call <16 x i8> @llvm.s390.vfeeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2426 vuc = vec_cmpeq_idx(vuc, vuc); 2427 // CHECK: call <16 x i8> @llvm.s390.vfeeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2428 vuc = vec_cmpeq_idx(vbc, vbc); 2429 // CHECK: call <16 x i8> @llvm.s390.vfeeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2430 vss = vec_cmpeq_idx(vss, vss); 2431 // CHECK: call <8 x i16> @llvm.s390.vfeeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2432 vus = vec_cmpeq_idx(vus, vus); 2433 // CHECK: call <8 x i16> @llvm.s390.vfeeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2434 vus = vec_cmpeq_idx(vbs, vbs); 2435 // CHECK: call <8 x i16> @llvm.s390.vfeeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2436 vsi = vec_cmpeq_idx(vsi, vsi); 2437 // CHECK: call <4 x i32> @llvm.s390.vfeef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2438 vui = vec_cmpeq_idx(vui, vui); 2439 // CHECK: call <4 x i32> @llvm.s390.vfeef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2440 vui = vec_cmpeq_idx(vbi, vbi); 2441 // CHECK: call <4 x i32> @llvm.s390.vfeef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2442 2443 vsc = vec_cmpeq_idx_cc(vsc, vsc, &cc); 2444 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfeebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2445 vuc = vec_cmpeq_idx_cc(vuc, vuc, &cc); 2446 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfeebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2447 vuc = vec_cmpeq_idx_cc(vbc, vbc, &cc); 2448 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfeebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2449 vss = vec_cmpeq_idx_cc(vss, vss, &cc); 2450 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfeehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2451 vus = vec_cmpeq_idx_cc(vus, vus, &cc); 2452 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfeehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2453 vus = vec_cmpeq_idx_cc(vbs, vbs, &cc); 2454 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfeehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2455 vsi = vec_cmpeq_idx_cc(vsi, vsi, &cc); 2456 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfeefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2457 vui = vec_cmpeq_idx_cc(vui, vui, &cc); 2458 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfeefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2459 vui = vec_cmpeq_idx_cc(vbi, vbi, &cc); 2460 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfeefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2461 2462 vsc = vec_cmpeq_or_0_idx(vsc, vsc); 2463 // CHECK: call <16 x i8> @llvm.s390.vfeezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2464 vuc = vec_cmpeq_or_0_idx(vuc, vuc); 2465 // CHECK: call <16 x i8> @llvm.s390.vfeezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2466 vuc = vec_cmpeq_or_0_idx(vbc, vbc); 2467 // CHECK: call <16 x i8> @llvm.s390.vfeezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2468 vss = vec_cmpeq_or_0_idx(vss, vss); 2469 // CHECK: call <8 x i16> @llvm.s390.vfeezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2470 vus = vec_cmpeq_or_0_idx(vus, vus); 2471 // CHECK: call <8 x i16> @llvm.s390.vfeezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2472 vus = vec_cmpeq_or_0_idx(vbs, vbs); 2473 // CHECK: call <8 x i16> @llvm.s390.vfeezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2474 vsi = vec_cmpeq_or_0_idx(vsi, vsi); 2475 // CHECK: call <4 x i32> @llvm.s390.vfeezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2476 vui = vec_cmpeq_or_0_idx(vui, vui); 2477 // CHECK: call <4 x i32> @llvm.s390.vfeezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2478 vui = vec_cmpeq_or_0_idx(vbi, vbi); 2479 // CHECK: call <4 x i32> @llvm.s390.vfeezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2480 2481 vsc = vec_cmpeq_or_0_idx_cc(vsc, vsc, &cc); 2482 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfeezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2483 vuc = vec_cmpeq_or_0_idx_cc(vuc, vuc, &cc); 2484 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfeezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2485 vuc = vec_cmpeq_or_0_idx_cc(vbc, vbc, &cc); 2486 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfeezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2487 vss = vec_cmpeq_or_0_idx_cc(vss, vss, &cc); 2488 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfeezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2489 vus = vec_cmpeq_or_0_idx_cc(vus, vus, &cc); 2490 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfeezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2491 vus = vec_cmpeq_or_0_idx_cc(vbs, vbs, &cc); 2492 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfeezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2493 vsi = vec_cmpeq_or_0_idx_cc(vsi, vsi, &cc); 2494 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfeezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2495 vui = vec_cmpeq_or_0_idx_cc(vui, vui, &cc); 2496 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfeezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2497 vui = vec_cmpeq_or_0_idx_cc(vbi, vbi, &cc); 2498 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfeezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2499 2500 vsc = vec_cmpne_idx(vsc, vsc); 2501 // CHECK: call <16 x i8> @llvm.s390.vfeneb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2502 vuc = vec_cmpne_idx(vuc, vuc); 2503 // CHECK: call <16 x i8> @llvm.s390.vfeneb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2504 vuc = vec_cmpne_idx(vbc, vbc); 2505 // CHECK: call <16 x i8> @llvm.s390.vfeneb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2506 vss = vec_cmpne_idx(vss, vss); 2507 // CHECK: call <8 x i16> @llvm.s390.vfeneh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2508 vus = vec_cmpne_idx(vus, vus); 2509 // CHECK: call <8 x i16> @llvm.s390.vfeneh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2510 vus = vec_cmpne_idx(vbs, vbs); 2511 // CHECK: call <8 x i16> @llvm.s390.vfeneh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2512 vsi = vec_cmpne_idx(vsi, vsi); 2513 // CHECK: call <4 x i32> @llvm.s390.vfenef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2514 vui = vec_cmpne_idx(vui, vui); 2515 // CHECK: call <4 x i32> @llvm.s390.vfenef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2516 vui = vec_cmpne_idx(vbi, vbi); 2517 // CHECK: call <4 x i32> @llvm.s390.vfenef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2518 2519 vsc = vec_cmpne_idx_cc(vsc, vsc, &cc); 2520 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfenebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2521 vuc = vec_cmpne_idx_cc(vuc, vuc, &cc); 2522 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfenebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2523 vuc = vec_cmpne_idx_cc(vbc, vbc, &cc); 2524 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfenebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2525 vss = vec_cmpne_idx_cc(vss, vss, &cc); 2526 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfenehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2527 vus = vec_cmpne_idx_cc(vus, vus, &cc); 2528 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfenehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2529 vus = vec_cmpne_idx_cc(vbs, vbs, &cc); 2530 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfenehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2531 vsi = vec_cmpne_idx_cc(vsi, vsi, &cc); 2532 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfenefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2533 vui = vec_cmpne_idx_cc(vui, vui, &cc); 2534 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfenefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2535 vui = vec_cmpne_idx_cc(vbi, vbi, &cc); 2536 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfenefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2537 2538 vsc = vec_cmpne_or_0_idx(vsc, vsc); 2539 // CHECK: call <16 x i8> @llvm.s390.vfenezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2540 vuc = vec_cmpne_or_0_idx(vuc, vuc); 2541 // CHECK: call <16 x i8> @llvm.s390.vfenezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2542 vuc = vec_cmpne_or_0_idx(vbc, vbc); 2543 // CHECK: call <16 x i8> @llvm.s390.vfenezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2544 vss = vec_cmpne_or_0_idx(vss, vss); 2545 // CHECK: call <8 x i16> @llvm.s390.vfenezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2546 vus = vec_cmpne_or_0_idx(vus, vus); 2547 // CHECK: call <8 x i16> @llvm.s390.vfenezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2548 vus = vec_cmpne_or_0_idx(vbs, vbs); 2549 // CHECK: call <8 x i16> @llvm.s390.vfenezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2550 vsi = vec_cmpne_or_0_idx(vsi, vsi); 2551 // CHECK: call <4 x i32> @llvm.s390.vfenezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2552 vui = vec_cmpne_or_0_idx(vui, vui); 2553 // CHECK: call <4 x i32> @llvm.s390.vfenezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2554 vui = vec_cmpne_or_0_idx(vbi, vbi); 2555 // CHECK: call <4 x i32> @llvm.s390.vfenezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2556 2557 vsc = vec_cmpne_or_0_idx_cc(vsc, vsc, &cc); 2558 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfenezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2559 vuc = vec_cmpne_or_0_idx_cc(vuc, vuc, &cc); 2560 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfenezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2561 vuc = vec_cmpne_or_0_idx_cc(vbc, vbc, &cc); 2562 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfenezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 2563 vss = vec_cmpne_or_0_idx_cc(vss, vss, &cc); 2564 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfenezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2565 vus = vec_cmpne_or_0_idx_cc(vus, vus, &cc); 2566 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfenezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2567 vus = vec_cmpne_or_0_idx_cc(vbs, vbs, &cc); 2568 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfenezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) 2569 vsi = vec_cmpne_or_0_idx_cc(vsi, vsi, &cc); 2570 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfenezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2571 vui = vec_cmpne_or_0_idx_cc(vui, vui, &cc); 2572 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfenezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2573 vui = vec_cmpne_or_0_idx_cc(vbi, vbi, &cc); 2574 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfenezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 2575 2576 vbc = vec_cmprg(vuc, vuc, vuc); 2577 // CHECK: call <16 x i8> @llvm.s390.vstrcb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4) 2578 vbs = vec_cmprg(vus, vus, vus); 2579 // CHECK: call <8 x i16> @llvm.s390.vstrch(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4) 2580 vbi = vec_cmprg(vui, vui, vui); 2581 // CHECK: call <4 x i32> @llvm.s390.vstrcf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4) 2582 2583 vbc = vec_cmprg_cc(vuc, vuc, vuc, &cc); 2584 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrcbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4) 2585 vbs = vec_cmprg_cc(vus, vus, vus, &cc); 2586 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vstrchs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4) 2587 vbi = vec_cmprg_cc(vui, vui, vui, &cc); 2588 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vstrcfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4) 2589 2590 vuc = vec_cmprg_idx(vuc, vuc, vuc); 2591 // CHECK: call <16 x i8> @llvm.s390.vstrcb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2592 vus = vec_cmprg_idx(vus, vus, vus); 2593 // CHECK: call <8 x i16> @llvm.s390.vstrch(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0) 2594 vui = vec_cmprg_idx(vui, vui, vui); 2595 // CHECK: call <4 x i32> @llvm.s390.vstrcf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0) 2596 2597 vuc = vec_cmprg_idx_cc(vuc, vuc, vuc, &cc); 2598 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrcbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2599 vus = vec_cmprg_idx_cc(vus, vus, vus, &cc); 2600 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vstrchs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0) 2601 vui = vec_cmprg_idx_cc(vui, vui, vui, &cc); 2602 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vstrcfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0) 2603 2604 vuc = vec_cmprg_or_0_idx(vuc, vuc, vuc); 2605 // CHECK: call <16 x i8> @llvm.s390.vstrczb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2606 vus = vec_cmprg_or_0_idx(vus, vus, vus); 2607 // CHECK: call <8 x i16> @llvm.s390.vstrczh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0) 2608 vui = vec_cmprg_or_0_idx(vui, vui, vui); 2609 // CHECK: call <4 x i32> @llvm.s390.vstrczf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0) 2610 2611 vuc = vec_cmprg_or_0_idx_cc(vuc, vuc, vuc, &cc); 2612 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrczbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2613 vus = vec_cmprg_or_0_idx_cc(vus, vus, vus, &cc); 2614 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vstrczhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0) 2615 vui = vec_cmprg_or_0_idx_cc(vui, vui, vui, &cc); 2616 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vstrczfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0) 2617 2618 vbc = vec_cmpnrg(vuc, vuc, vuc); 2619 // CHECK: call <16 x i8> @llvm.s390.vstrcb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12) 2620 vbs = vec_cmpnrg(vus, vus, vus); 2621 // CHECK: call <8 x i16> @llvm.s390.vstrch(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12) 2622 vbi = vec_cmpnrg(vui, vui, vui); 2623 // CHECK: call <4 x i32> @llvm.s390.vstrcf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12) 2624 2625 vbc = vec_cmpnrg_cc(vuc, vuc, vuc, &cc); 2626 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrcbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12) 2627 vbs = vec_cmpnrg_cc(vus, vus, vus, &cc); 2628 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vstrchs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12) 2629 vbi = vec_cmpnrg_cc(vui, vui, vui, &cc); 2630 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vstrcfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12) 2631 2632 vuc = vec_cmpnrg_idx(vuc, vuc, vuc); 2633 // CHECK: call <16 x i8> @llvm.s390.vstrcb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8) 2634 vus = vec_cmpnrg_idx(vus, vus, vus); 2635 // CHECK: call <8 x i16> @llvm.s390.vstrch(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8) 2636 vui = vec_cmpnrg_idx(vui, vui, vui); 2637 // CHECK: call <4 x i32> @llvm.s390.vstrcf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8) 2638 2639 vuc = vec_cmpnrg_idx_cc(vuc, vuc, vuc, &cc); 2640 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrcbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8) 2641 vus = vec_cmpnrg_idx_cc(vus, vus, vus, &cc); 2642 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vstrchs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8) 2643 vui = vec_cmpnrg_idx_cc(vui, vui, vui, &cc); 2644 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vstrcfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8) 2645 2646 vuc = vec_cmpnrg_or_0_idx(vuc, vuc, vuc); 2647 // CHECK: call <16 x i8> @llvm.s390.vstrczb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8) 2648 vus = vec_cmpnrg_or_0_idx(vus, vus, vus); 2649 // CHECK: call <8 x i16> @llvm.s390.vstrczh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8) 2650 vui = vec_cmpnrg_or_0_idx(vui, vui, vui); 2651 // CHECK: call <4 x i32> @llvm.s390.vstrczf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8) 2652 2653 vuc = vec_cmpnrg_or_0_idx_cc(vuc, vuc, vuc, &cc); 2654 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrczbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8) 2655 vus = vec_cmpnrg_or_0_idx_cc(vus, vus, vus, &cc); 2656 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vstrczhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8) 2657 vui = vec_cmpnrg_or_0_idx_cc(vui, vui, vui, &cc); 2658 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vstrczfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8) 2659 2660 vbc = vec_find_any_eq(vsc, vsc); 2661 // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4) 2662 vbc = vec_find_any_eq(vuc, vuc); 2663 // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4) 2664 vbc = vec_find_any_eq(vbc, vbc); 2665 // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4) 2666 vbs = vec_find_any_eq(vss, vss); 2667 // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4) 2668 vbs = vec_find_any_eq(vus, vus); 2669 // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4) 2670 vbs = vec_find_any_eq(vbs, vbs); 2671 // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4) 2672 vbi = vec_find_any_eq(vsi, vsi); 2673 // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4) 2674 vbi = vec_find_any_eq(vui, vui); 2675 // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4) 2676 vbi = vec_find_any_eq(vbi, vbi); 2677 // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4) 2678 2679 vbc = vec_find_any_eq_cc(vsc, vsc, &cc); 2680 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4) 2681 vbc = vec_find_any_eq_cc(vuc, vuc, &cc); 2682 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4) 2683 vbc = vec_find_any_eq_cc(vbc, vbc, &cc); 2684 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 4) 2685 vbs = vec_find_any_eq_cc(vss, vss, &cc); 2686 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4) 2687 vbs = vec_find_any_eq_cc(vus, vus, &cc); 2688 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4) 2689 vbs = vec_find_any_eq_cc(vbs, vbs, &cc); 2690 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 4) 2691 vbi = vec_find_any_eq_cc(vsi, vsi, &cc); 2692 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4) 2693 vbi = vec_find_any_eq_cc(vui, vui, &cc); 2694 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4) 2695 vbi = vec_find_any_eq_cc(vbi, vbi, &cc); 2696 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 4) 2697 2698 vsc = vec_find_any_eq_idx(vsc, vsc); 2699 // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2700 vuc = vec_find_any_eq_idx(vuc, vuc); 2701 // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2702 vuc = vec_find_any_eq_idx(vbc, vbc); 2703 // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2704 vss = vec_find_any_eq_idx(vss, vss); 2705 // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0) 2706 vus = vec_find_any_eq_idx(vus, vus); 2707 // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0) 2708 vus = vec_find_any_eq_idx(vbs, vbs); 2709 // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0) 2710 vsi = vec_find_any_eq_idx(vsi, vsi); 2711 // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0) 2712 vui = vec_find_any_eq_idx(vui, vui); 2713 // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0) 2714 vui = vec_find_any_eq_idx(vbi, vbi); 2715 // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0) 2716 2717 vsc = vec_find_any_eq_idx_cc(vsc, vsc, &cc); 2718 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2719 vuc = vec_find_any_eq_idx_cc(vuc, vuc, &cc); 2720 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2721 vuc = vec_find_any_eq_idx_cc(vbc, vbc, &cc); 2722 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2723 vss = vec_find_any_eq_idx_cc(vss, vss, &cc); 2724 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0) 2725 vus = vec_find_any_eq_idx_cc(vus, vus, &cc); 2726 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0) 2727 vus = vec_find_any_eq_idx_cc(vbs, vbs, &cc); 2728 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0) 2729 vsi = vec_find_any_eq_idx_cc(vsi, vsi, &cc); 2730 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0) 2731 vui = vec_find_any_eq_idx_cc(vui, vui, &cc); 2732 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0) 2733 vui = vec_find_any_eq_idx_cc(vbi, vbi, &cc); 2734 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0) 2735 2736 vsc = vec_find_any_eq_or_0_idx(vsc, vsc); 2737 // CHECK: call <16 x i8> @llvm.s390.vfaezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2738 vuc = vec_find_any_eq_or_0_idx(vuc, vuc); 2739 // CHECK: call <16 x i8> @llvm.s390.vfaezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2740 vuc = vec_find_any_eq_or_0_idx(vbc, vbc); 2741 // CHECK: call <16 x i8> @llvm.s390.vfaezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2742 vss = vec_find_any_eq_or_0_idx(vss, vss); 2743 // CHECK: call <8 x i16> @llvm.s390.vfaezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0) 2744 vus = vec_find_any_eq_or_0_idx(vus, vus); 2745 // CHECK: call <8 x i16> @llvm.s390.vfaezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0) 2746 vus = vec_find_any_eq_or_0_idx(vbs, vbs); 2747 // CHECK: call <8 x i16> @llvm.s390.vfaezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0) 2748 vsi = vec_find_any_eq_or_0_idx(vsi, vsi); 2749 // CHECK: call <4 x i32> @llvm.s390.vfaezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0) 2750 vui = vec_find_any_eq_or_0_idx(vui, vui); 2751 // CHECK: call <4 x i32> @llvm.s390.vfaezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0) 2752 vui = vec_find_any_eq_or_0_idx(vbi, vbi); 2753 // CHECK: call <4 x i32> @llvm.s390.vfaezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0) 2754 2755 vsc = vec_find_any_eq_or_0_idx_cc(vsc, vsc, &cc); 2756 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2757 vuc = vec_find_any_eq_or_0_idx_cc(vuc, vuc, &cc); 2758 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2759 vuc = vec_find_any_eq_or_0_idx_cc(vbc, vbc, &cc); 2760 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 2761 vss = vec_find_any_eq_or_0_idx_cc(vss, vss, &cc); 2762 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0) 2763 vus = vec_find_any_eq_or_0_idx_cc(vus, vus, &cc); 2764 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0) 2765 vus = vec_find_any_eq_or_0_idx_cc(vbs, vbs, &cc); 2766 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 0) 2767 vsi = vec_find_any_eq_or_0_idx_cc(vsi, vsi, &cc); 2768 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0) 2769 vui = vec_find_any_eq_or_0_idx_cc(vui, vui, &cc); 2770 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0) 2771 vui = vec_find_any_eq_or_0_idx_cc(vbi, vbi, &cc); 2772 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 0) 2773 2774 vbc = vec_find_any_ne(vsc, vsc); 2775 // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12) 2776 vbc = vec_find_any_ne(vuc, vuc); 2777 // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12) 2778 vbc = vec_find_any_ne(vbc, vbc); 2779 // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12) 2780 vbs = vec_find_any_ne(vss, vss); 2781 // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12) 2782 vbs = vec_find_any_ne(vus, vus); 2783 // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12) 2784 vbs = vec_find_any_ne(vbs, vbs); 2785 // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12) 2786 vbi = vec_find_any_ne(vsi, vsi); 2787 // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12) 2788 vbi = vec_find_any_ne(vui, vui); 2789 // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12) 2790 vbi = vec_find_any_ne(vbi, vbi); 2791 // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12) 2792 2793 vbc = vec_find_any_ne_cc(vsc, vsc, &cc); 2794 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12) 2795 vbc = vec_find_any_ne_cc(vuc, vuc, &cc); 2796 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12) 2797 vbc = vec_find_any_ne_cc(vbc, vbc, &cc); 2798 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 12) 2799 vbs = vec_find_any_ne_cc(vss, vss, &cc); 2800 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12) 2801 vbs = vec_find_any_ne_cc(vus, vus, &cc); 2802 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12) 2803 vbs = vec_find_any_ne_cc(vbs, vbs, &cc); 2804 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 12) 2805 vbi = vec_find_any_ne_cc(vsi, vsi, &cc); 2806 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12) 2807 vbi = vec_find_any_ne_cc(vui, vui, &cc); 2808 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12) 2809 vbi = vec_find_any_ne_cc(vbi, vbi, &cc); 2810 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 12) 2811 2812 vsc = vec_find_any_ne_idx(vsc, vsc); 2813 // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8) 2814 vuc = vec_find_any_ne_idx(vuc, vuc); 2815 // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8) 2816 vuc = vec_find_any_ne_idx(vbc, vbc); 2817 // CHECK: call <16 x i8> @llvm.s390.vfaeb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8) 2818 vss = vec_find_any_ne_idx(vss, vss); 2819 // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8) 2820 vus = vec_find_any_ne_idx(vus, vus); 2821 // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8) 2822 vus = vec_find_any_ne_idx(vbs, vbs); 2823 // CHECK: call <8 x i16> @llvm.s390.vfaeh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8) 2824 vsi = vec_find_any_ne_idx(vsi, vsi); 2825 // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8) 2826 vui = vec_find_any_ne_idx(vui, vui); 2827 // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8) 2828 vui = vec_find_any_ne_idx(vbi, vbi); 2829 // CHECK: call <4 x i32> @llvm.s390.vfaef(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8) 2830 2831 vsc = vec_find_any_ne_idx_cc(vsc, vsc, &cc); 2832 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8) 2833 vuc = vec_find_any_ne_idx_cc(vuc, vuc, &cc); 2834 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8) 2835 vuc = vec_find_any_ne_idx_cc(vbc, vbc, &cc); 2836 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaebs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8) 2837 vss = vec_find_any_ne_idx_cc(vss, vss, &cc); 2838 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8) 2839 vus = vec_find_any_ne_idx_cc(vus, vus, &cc); 2840 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8) 2841 vus = vec_find_any_ne_idx_cc(vbs, vbs, &cc); 2842 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaehs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8) 2843 vsi = vec_find_any_ne_idx_cc(vsi, vsi, &cc); 2844 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8) 2845 vui = vec_find_any_ne_idx_cc(vui, vui, &cc); 2846 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8) 2847 vui = vec_find_any_ne_idx_cc(vbi, vbi, &cc); 2848 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaefs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8) 2849 2850 vsc = vec_find_any_ne_or_0_idx(vsc, vsc); 2851 // CHECK: call <16 x i8> @llvm.s390.vfaezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8) 2852 vuc = vec_find_any_ne_or_0_idx(vuc, vuc); 2853 // CHECK: call <16 x i8> @llvm.s390.vfaezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8) 2854 vuc = vec_find_any_ne_or_0_idx(vbc, vbc); 2855 // CHECK: call <16 x i8> @llvm.s390.vfaezb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8) 2856 vss = vec_find_any_ne_or_0_idx(vss, vss); 2857 // CHECK: call <8 x i16> @llvm.s390.vfaezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8) 2858 vus = vec_find_any_ne_or_0_idx(vus, vus); 2859 // CHECK: call <8 x i16> @llvm.s390.vfaezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8) 2860 vus = vec_find_any_ne_or_0_idx(vbs, vbs); 2861 // CHECK: call <8 x i16> @llvm.s390.vfaezh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8) 2862 vsi = vec_find_any_ne_or_0_idx(vsi, vsi); 2863 // CHECK: call <4 x i32> @llvm.s390.vfaezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8) 2864 vui = vec_find_any_ne_or_0_idx(vui, vui); 2865 // CHECK: call <4 x i32> @llvm.s390.vfaezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8) 2866 vui = vec_find_any_ne_or_0_idx(vbi, vbi); 2867 // CHECK: call <4 x i32> @llvm.s390.vfaezf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8) 2868 2869 vsc = vec_find_any_ne_or_0_idx_cc(vsc, vsc, &cc); 2870 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8) 2871 vuc = vec_find_any_ne_or_0_idx_cc(vuc, vuc, &cc); 2872 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8) 2873 vuc = vec_find_any_ne_or_0_idx_cc(vbc, vbc, &cc); 2874 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vfaezbs(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 8) 2875 vss = vec_find_any_ne_or_0_idx_cc(vss, vss, &cc); 2876 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8) 2877 vus = vec_find_any_ne_or_0_idx_cc(vus, vus, &cc); 2878 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8) 2879 vus = vec_find_any_ne_or_0_idx_cc(vbs, vbs, &cc); 2880 // CHECK: call { <8 x i16>, i32 } @llvm.s390.vfaezhs(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, i32 8) 2881 vsi = vec_find_any_ne_or_0_idx_cc(vsi, vsi, &cc); 2882 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8) 2883 vui = vec_find_any_ne_or_0_idx_cc(vui, vui, &cc); 2884 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8) 2885 vui = vec_find_any_ne_or_0_idx_cc(vbi, vbi, &cc); 2886 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfaezfs(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i32 8) 2887 } 2888 2889 void test_float(void) { 2890 vd = vec_abs(vd); 2891 // CHECK: call <2 x double> @llvm.fabs.v2f64(<2 x double> %{{.*}}) 2892 2893 vd = vec_nabs(vd); 2894 // CHECK: [[ABS:%[^ ]+]] = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %{{.*}}) 2895 // CHECK-NEXT: fsub <2 x double> <double -0.000000e+00, double -0.000000e+00>, [[ABS]] 2896 2897 vd = vec_madd(vd, vd, vd); 2898 // CHECK: call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}) 2899 vd = vec_msub(vd, vd, vd); 2900 // CHECK: [[NEG:%[^ ]+]] = fsub <2 x double> <double -0.000000e+00, double -0.000000e+00>, %{{.*}} 2901 // CHECK: call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> [[NEG]]) 2902 vd = vec_sqrt(vd); 2903 // CHECK: call <2 x double> @llvm.sqrt.v2f64(<2 x double> %{{.*}}) 2904 2905 vd = vec_ld2f(cptrf); 2906 // CHECK: [[VAL:%[^ ]+]] = load <2 x float>, <2 x float>* %{{.*}} 2907 // CHECK: fpext <2 x float> [[VAL]] to <2 x double> 2908 vec_st2f(vd, ptrf); 2909 // CHECK: [[VAL:%[^ ]+]] = fptrunc <2 x double> %{{.*}} to <2 x float> 2910 // CHECK: store <2 x float> [[VAL]], <2 x float>* %{{.*}} 2911 2912 vd = vec_ctd(vsl, 0); 2913 // CHECK: sitofp <2 x i64> %{{.*}} to <2 x double> 2914 vd = vec_ctd(vul, 0); 2915 // CHECK: uitofp <2 x i64> %{{.*}} to <2 x double> 2916 vd = vec_ctd(vsl, 1); 2917 // CHECK: [[VAL:%[^ ]+]] = sitofp <2 x i64> %{{.*}} to <2 x double> 2918 // CHECK: fmul <2 x double> [[VAL]], <double 5.000000e-01, double 5.000000e-01> 2919 vd = vec_ctd(vul, 1); 2920 // CHECK: [[VAL:%[^ ]+]] = uitofp <2 x i64> %{{.*}} to <2 x double> 2921 // CHECK: fmul <2 x double> [[VAL]], <double 5.000000e-01, double 5.000000e-01> 2922 vd = vec_ctd(vsl, 31); 2923 // CHECK: [[VAL:%[^ ]+]] = sitofp <2 x i64> %{{.*}} to <2 x double> 2924 // CHECK: fmul <2 x double> [[VAL]], <double 0x3E00000000000000, double 0x3E00000000000000> 2925 vd = vec_ctd(vul, 31); 2926 // CHECK: [[VAL:%[^ ]+]] = uitofp <2 x i64> %{{.*}} to <2 x double> 2927 // CHECK: fmul <2 x double> [[VAL]], <double 0x3E00000000000000, double 0x3E00000000000000> 2928 2929 vsl = vec_ctsl(vd, 0); 2930 // CHECK: fptosi <2 x double> %{{.*}} to <2 x i64> 2931 vul = vec_ctul(vd, 0); 2932 // CHECK: fptoui <2 x double> %{{.*}} to <2 x i64> 2933 vsl = vec_ctsl(vd, 1); 2934 // CHECK: [[VAL:%[^ ]+]] = fmul <2 x double> %{{.*}}, <double 2.000000e+00, double 2.000000e+00> 2935 // CHECK: fptosi <2 x double> [[VAL]] to <2 x i64> 2936 vul = vec_ctul(vd, 1); 2937 // CHECK: [[VAL:%[^ ]+]] = fmul <2 x double> %{{.*}}, <double 2.000000e+00, double 2.000000e+00> 2938 // CHECK: fptoui <2 x double> [[VAL]] to <2 x i64> 2939 vsl = vec_ctsl(vd, 31); 2940 // CHECK: [[VAL:%[^ ]+]] = fmul <2 x double> %{{.*}}, <double 0x41E0000000000000, double 0x41E0000000000000> 2941 // CHECK: fptosi <2 x double> [[VAL]] to <2 x i64> 2942 vul = vec_ctul(vd, 31); 2943 // CHECK: [[VAL:%[^ ]+]] = fmul <2 x double> %{{.*}}, <double 0x41E0000000000000, double 0x41E0000000000000> 2944 // CHECK: fptoui <2 x double> [[VAL]] to <2 x i64> 2945 2946 vd = vec_roundp(vd); 2947 // CHECK: call <2 x double> @llvm.ceil.v2f64(<2 x double> %{{.*}}) 2948 vd = vec_ceil(vd); 2949 // CHECK: call <2 x double> @llvm.ceil.v2f64(<2 x double> %{{.*}}) 2950 vd = vec_roundm(vd); 2951 // CHECK: call <2 x double> @llvm.floor.v2f64(<2 x double> %{{.*}}) 2952 vd = vec_floor(vd); 2953 // CHECK: call <2 x double> @llvm.floor.v2f64(<2 x double> %{{.*}}) 2954 vd = vec_roundz(vd); 2955 // CHECK: call <2 x double> @llvm.trunc.v2f64(<2 x double> %{{.*}}) 2956 vd = vec_trunc(vd); 2957 // CHECK: call <2 x double> @llvm.trunc.v2f64(<2 x double> %{{.*}}) 2958 vd = vec_roundc(vd); 2959 // CHECK: call <2 x double> @llvm.nearbyint.v2f64(<2 x double> %{{.*}}) 2960 vd = vec_round(vd); 2961 // CHECK: call <2 x double> @llvm.s390.vfidb(<2 x double> %{{.*}}, i32 4, i32 4) 2962 2963 vbl = vec_fp_test_data_class(vd, 0, &cc); 2964 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 0) 2965 vbl = vec_fp_test_data_class(vd, 4095, &cc); 2966 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 4095) 2967 } 2968
