1 // REQUIRES: systemz-registered-target 2 // RUN: %clang_cc1 -target-cpu z15 -triple s390x-linux-gnu \ 3 // RUN: -O2 -fzvector -flax-vector-conversions=none \ 4 // RUN: -Wall -Wno-unused -Werror -emit-llvm %s -o - | FileCheck %s 5 // RUN: %clang_cc1 -target-cpu z15 -triple s390x-linux-gnu \ 6 // RUN: -O2 -fzvector -flax-vector-conversions=none \ 7 // RUN: -Wall -Wno-unused -Werror -S %s -o - | FileCheck %s --check-prefix=CHECK-ASM 8 9 #include <vecintrin.h> 10 11 volatile vector signed char vsc; 12 volatile vector signed short vss; 13 volatile vector signed int vsi; 14 volatile vector signed long long vsl; 15 volatile vector signed __int128 vslll; 16 volatile vector unsigned char vuc; 17 volatile vector unsigned short vus; 18 volatile vector unsigned int vui; 19 volatile vector unsigned long long vul; 20 volatile vector unsigned __int128 vulll; 21 volatile vector bool char vbc; 22 volatile vector bool short vbs; 23 volatile vector bool int vbi; 24 volatile vector bool long long vbl; 25 volatile vector float vf; 26 volatile vector double vd; 27 28 volatile signed char sc; 29 volatile signed short ss; 30 volatile signed int si; 31 volatile signed long long sl; 32 volatile unsigned char uc; 33 volatile unsigned short us; 34 volatile unsigned int ui; 35 volatile unsigned long long ul; 36 volatile float f; 37 volatile double d; 38 39 const void * volatile cptr; 40 const signed char * volatile cptrsc; 41 const signed short * volatile cptrss; 42 const signed int * volatile cptrsi; 43 const signed long long * volatile cptrsl; 44 const signed __int128 * volatile cptrslll; 45 const unsigned char * volatile cptruc; 46 const unsigned short * volatile cptrus; 47 const unsigned int * volatile cptrui; 48 const unsigned long long * volatile cptrul; 49 const unsigned __int128 * volatile cptrulll; 50 const float * volatile cptrf; 51 const double * volatile cptrd; 52 53 void * volatile ptr; 54 signed char * volatile ptrsc; 55 signed short * volatile ptrss; 56 signed int * volatile ptrsi; 57 signed long long * volatile ptrsl; 58 signed __int128 * volatile ptrslll; 59 unsigned char * volatile ptruc; 60 unsigned short * volatile ptrus; 61 unsigned int * volatile ptrui; 62 unsigned long long * volatile ptrul; 63 unsigned __int128 * volatile ptrulll; 64 float * volatile ptrf; 65 double * volatile ptrd; 66 67 volatile unsigned int len; 68 volatile int idx; 69 int cc; 70 71 void test_core(void) { 72 // CHECK-ASM-LABEL: test_core 73 vector signed short vss2; 74 vector signed int vsi2; 75 vector signed long long vsl2; 76 vector unsigned short vus2; 77 vector unsigned int vui2; 78 vector unsigned long long vul2; 79 vector float vf2; 80 vector double vd2; 81 82 vss += vec_revb(vec_xl(idx, cptrss)); 83 // CHECK-ASM: vlbrh 84 vus += vec_revb(vec_xl(idx, cptrus)); 85 // CHECK-ASM: vlbrh 86 vsi += vec_revb(vec_xl(idx, cptrsi)); 87 // CHECK-ASM: vlbrf 88 vui += vec_revb(vec_xl(idx, cptrui)); 89 // CHECK-ASM: vlbrf 90 vsl += vec_revb(vec_xl(idx, cptrsl)); 91 // CHECK-ASM: vlbrg 92 vul += vec_revb(vec_xl(idx, cptrul)); 93 // CHECK-ASM: vlbrg 94 vslll += vec_revb(vec_xl(idx, cptrslll)); 95 // CHECK-ASM: vlbrq 96 vulll += vec_revb(vec_xl(idx, cptrulll)); 97 // CHECK-ASM: vlbrq 98 vf += vec_revb(vec_xl(idx, cptrf)); 99 // CHECK-ASM: vlbrf 100 vd += vec_revb(vec_xl(idx, cptrd)); 101 // CHECK-ASM: vlbrg 102 103 vec_xst(vec_revb(vss), idx, ptrss); 104 // CHECK-ASM: vstbrh 105 vec_xst(vec_revb(vus), idx, ptrus); 106 // CHECK-ASM: vstbrh 107 vec_xst(vec_revb(vsi), idx, ptrsi); 108 // CHECK-ASM: vstbrf 109 vec_xst(vec_revb(vui), idx, ptrui); 110 // CHECK-ASM: vstbrf 111 vec_xst(vec_revb(vsl), idx, ptrsl); 112 // CHECK-ASM: vstbrg 113 vec_xst(vec_revb(vul), idx, ptrul); 114 // CHECK-ASM: vstbrg 115 vec_xst(vec_revb(vslll), idx, ptrslll); 116 // CHECK-ASM: vstbrq 117 vec_xst(vec_revb(vulll), idx, ptrulll); 118 // CHECK-ASM: vstbrq 119 vec_xst(vec_revb(vf), idx, ptrf); 120 // CHECK-ASM: vstbrf 121 vec_xst(vec_revb(vd), idx, ptrd); 122 // CHECK-ASM: vstbrg 123 124 vss += vec_revb(vec_insert_and_zero(cptrss)); 125 // CHECK-ASM: vllebrzh 126 vus += vec_revb(vec_insert_and_zero(cptrus)); 127 // CHECK-ASM: vllebrzh 128 vsi += vec_revb(vec_insert_and_zero(cptrsi)); 129 // CHECK-ASM: vllebrzf 130 vui += vec_revb(vec_insert_and_zero(cptrui)); 131 // CHECK-ASM: vllebrzf 132 vsl += vec_revb(vec_insert_and_zero(cptrsl)); 133 // CHECK-ASM: vllebrzg 134 vul += vec_revb(vec_insert_and_zero(cptrul)); 135 // CHECK-ASM: vllebrzg 136 vf += vec_revb(vec_insert_and_zero(cptrf)); 137 // CHECK-ASM: vllebrzf 138 vd += vec_revb(vec_insert_and_zero(cptrd)); 139 // CHECK-ASM: vllebrzg 140 141 vss += vec_revb(vec_splats(ss)); 142 // CHECK-ASM: vlbrreph 143 vus += vec_revb(vec_splats(us)); 144 // CHECK-ASM: vlbrreph 145 vsi += vec_revb(vec_splats(si)); 146 // CHECK-ASM: vlbrrepf 147 vui += vec_revb(vec_splats(ui)); 148 // CHECK-ASM: vlbrrepf 149 vsl += vec_revb(vec_splats(sl)); 150 // CHECK-ASM: vlbrrepg 151 vul += vec_revb(vec_splats(ul)); 152 // CHECK-ASM: vlbrrepg 153 vf += vec_revb(vec_splats(f)); 154 // CHECK-ASM: vlbrrepf 155 vd += vec_revb(vec_splats(d)); 156 // CHECK-ASM: vlbrrepg 157 158 vus = vec_splats(__builtin_bswap16(us)); 159 // CHECK-ASM: vlbrreph 160 vui = vec_splats(__builtin_bswap32(ui)); 161 // CHECK-ASM: vlbrrepf 162 vul = vec_splats((unsigned long long)__builtin_bswap64(ul)); 163 // CHECK-ASM: vlbrrepg 164 165 vss2 = vss; 166 vss += vec_revb(vec_insert(ss, vec_revb(vss2), 0)); 167 // CHECK-ASM: vlebrh 168 vus2 = vus; 169 vus += vec_revb(vec_insert(us, vec_revb(vus2), 0)); 170 // CHECK-ASM: vlebrh 171 vsi2 = vsi; 172 vsi += vec_revb(vec_insert(si, vec_revb(vsi2), 0)); 173 // CHECK-ASM: vlebrf 174 vui2 = vui; 175 vui += vec_revb(vec_insert(ui, vec_revb(vui2), 0)); 176 // CHECK-ASM: vlebrf 177 vsl2 = vsl; 178 vsl += vec_revb(vec_insert(sl, vec_revb(vsl2), 0)); 179 // CHECK-ASM: vlebrg 180 vul2 = vul; 181 vul += vec_revb(vec_insert(ul, vec_revb(vul2), 0)); 182 // CHECK-ASM: vlebrg 183 vf2 = vf; 184 vf += vec_revb(vec_insert(f, vec_revb(vf2), 0)); 185 // CHECK-ASM: vlebrf 186 vd2 = vd; 187 vd += vec_revb(vec_insert(d, vec_revb(vd2), 0)); 188 // CHECK-ASM: vlebrg 189 190 vus2 = vus; 191 vus = vec_insert(__builtin_bswap16(us), vus2, 0); 192 // CHECK-ASM: vlebrh 193 vui2 = vui; 194 vui = vec_insert(__builtin_bswap32(ui), vui2, 0); 195 // CHECK-ASM: vlebrf 196 vul2 = vul; 197 vul = vec_insert(__builtin_bswap64(ul), vul2, 0); 198 // CHECK-ASM: vlebrg 199 200 ss = vec_extract(vec_revb(vss), 0); 201 // CHECK-ASM: vstebrh 202 us = vec_extract(vec_revb(vus), 0); 203 // CHECK-ASM: vstebrh 204 si = vec_extract(vec_revb(vsi), 0); 205 // CHECK-ASM: vstebrf 206 ui = vec_extract(vec_revb(vui), 0); 207 // CHECK-ASM: vstebrf 208 sl = vec_extract(vec_revb(vsl), 0); 209 // CHECK-ASM: vstebrg 210 ul = vec_extract(vec_revb(vul), 0); 211 // CHECK-ASM: vstebrg 212 f = vec_extract(vec_revb(vf), 0); 213 // CHECK-ASM: vstebrf 214 d = vec_extract(vec_revb(vd), 0); 215 // CHECK-ASM: vstebrg 216 217 us = __builtin_bswap16(vec_extract(vus, 0)); 218 // CHECK-ASM: vstebrh 219 ui = __builtin_bswap32(vec_extract(vui, 0)); 220 // CHECK-ASM: vstebrf 221 ul = __builtin_bswap64(vec_extract(vul, 0)); 222 // CHECK-ASM: vstebrg 223 224 vsc += vec_reve(vec_xl(idx, cptrsc)); 225 // CHECK-ASM: vlbrq 226 vuc += vec_reve(vec_xl(idx, cptruc)); 227 // CHECK-ASM: vlbrq 228 vss += vec_reve(vec_xl(idx, cptrss)); 229 // CHECK-ASM: vlerh 230 vus += vec_reve(vec_xl(idx, cptrus)); 231 // CHECK-ASM: vlerh 232 vsi += vec_reve(vec_xl(idx, cptrsi)); 233 // CHECK-ASM: vlerf 234 vui += vec_reve(vec_xl(idx, cptrui)); 235 // CHECK-ASM: vlerf 236 vsl += vec_reve(vec_xl(idx, cptrsl)); 237 // CHECK-ASM: vlerg 238 vul += vec_reve(vec_xl(idx, cptrul)); 239 // CHECK-ASM: vlerg 240 vf += vec_reve(vec_xl(idx, cptrf)); 241 // CHECK-ASM: vlerf 242 vd += vec_reve(vec_xl(idx, cptrd)); 243 // CHECK-ASM: vlerg 244 245 vec_xst(vec_reve(vsc), idx, ptrsc); 246 // CHECK-ASM: vstbrq 247 vec_xst(vec_reve(vuc), idx, ptruc); 248 // CHECK-ASM: vstbrq 249 vec_xst(vec_reve(vss), idx, ptrss); 250 // CHECK-ASM: vsterh 251 vec_xst(vec_reve(vus), idx, ptrus); 252 // CHECK-ASM: vsterh 253 vec_xst(vec_reve(vsi), idx, ptrsi); 254 // CHECK-ASM: vsterf 255 vec_xst(vec_reve(vui), idx, ptrui); 256 // CHECK-ASM: vsterf 257 vec_xst(vec_reve(vsl), idx, ptrsl); 258 // CHECK-ASM: vsterg 259 vec_xst(vec_reve(vul), idx, ptrul); 260 // CHECK-ASM: vsterg 261 vec_xst(vec_reve(vf), idx, ptrf); 262 // CHECK-ASM: vsterf 263 vec_xst(vec_reve(vd), idx, ptrd); 264 // CHECK-ASM: vsterg 265 } 266 267 void test_integer(void) { 268 // CHECK-ASM-LABEL: test_integer 269 270 vsc = vec_sldb(vsc, vsc, 0); 271 // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 272 // CHECK-ASM: vsld 273 vsc = vec_sldb(vsc, vsc, 7); 274 // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7) 275 // CHECK-ASM: vsld 276 vuc = vec_sldb(vuc, vuc, 0); 277 // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 278 // CHECK-ASM: vsld 279 vuc = vec_sldb(vuc, vuc, 7); 280 // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7) 281 // CHECK-ASM: vsld 282 vss = vec_sldb(vss, vss, 0); 283 // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 284 // CHECK-ASM: vsld 285 vss = vec_sldb(vss, vss, 7); 286 // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7) 287 // CHECK-ASM: vsld 288 vus = vec_sldb(vus, vus, 0); 289 // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 290 // CHECK-ASM: vsld 291 vus = vec_sldb(vus, vus, 7); 292 // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7) 293 // CHECK-ASM: vsld 294 vsi = vec_sldb(vsi, vsi, 0); 295 // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 296 // CHECK-ASM: vsld 297 vsi = vec_sldb(vsi, vsi, 7); 298 // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7) 299 // CHECK-ASM: vsld 300 vui = vec_sldb(vui, vui, 0); 301 // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 302 // CHECK-ASM: vsld 303 vui = vec_sldb(vui, vui, 7); 304 // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7) 305 // CHECK-ASM: vsld 306 vsl = vec_sldb(vsl, vsl, 0); 307 // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 308 // CHECK-ASM: vsld 309 vsl = vec_sldb(vsl, vsl, 7); 310 // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7) 311 // CHECK-ASM: vsld 312 vul = vec_sldb(vul, vul, 0); 313 // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 314 // CHECK-ASM: vsld 315 vul = vec_sldb(vul, vul, 7); 316 // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7) 317 // CHECK-ASM: vsld 318 vslll = vec_sldb(vslll, vslll, 0); 319 // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 320 // CHECK-ASM: vsld 321 vslll = vec_sldb(vslll, vslll, 7); 322 // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7) 323 // CHECK-ASM: vsld 324 vulll = vec_sldb(vulll, vulll, 0); 325 // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 326 // CHECK-ASM: vsld 327 vulll = vec_sldb(vulll, vulll, 7); 328 // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7) 329 // CHECK-ASM: vsld 330 vf = vec_sldb(vf, vf, 0); 331 // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 332 // CHECK-ASM: vsld 333 vf = vec_sldb(vf, vf, 7); 334 // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7) 335 // CHECK-ASM: vsld 336 vd = vec_sldb(vd, vd, 0); 337 // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 338 // CHECK-ASM: vsld 339 vd = vec_sldb(vd, vd, 7); 340 // CHECK: call <16 x i8> @llvm.s390.vsld(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7) 341 // CHECK-ASM: vsld 342 343 vsc = vec_srdb(vsc, vsc, 0); 344 // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 345 // CHECK-ASM: vsrd 346 vsc = vec_srdb(vsc, vsc, 7); 347 // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7) 348 // CHECK-ASM: vsrd 349 vuc = vec_srdb(vuc, vuc, 0); 350 // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 351 // CHECK-ASM: vsrd 352 vuc = vec_srdb(vuc, vuc, 7); 353 // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7) 354 // CHECK-ASM: vsrd 355 vss = vec_srdb(vss, vss, 0); 356 // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 357 // CHECK-ASM: vsrd 358 vss = vec_srdb(vss, vss, 7); 359 // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7) 360 // CHECK-ASM: vsrd 361 vus = vec_srdb(vus, vus, 0); 362 // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 363 // CHECK-ASM: vsrd 364 vus = vec_srdb(vus, vus, 7); 365 // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7) 366 // CHECK-ASM: vsrd 367 vsi = vec_srdb(vsi, vsi, 0); 368 // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 369 // CHECK-ASM: vsrd 370 vsi = vec_srdb(vsi, vsi, 7); 371 // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7) 372 // CHECK-ASM: vsrd 373 vui = vec_srdb(vui, vui, 0); 374 // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 375 // CHECK-ASM: vsrd 376 vui = vec_srdb(vui, vui, 7); 377 // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7) 378 // CHECK-ASM: vsrd 379 vsl = vec_srdb(vsl, vsl, 0); 380 // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 381 // CHECK-ASM: vsrd 382 vsl = vec_srdb(vsl, vsl, 7); 383 // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7) 384 // CHECK-ASM: vsrd 385 vul = vec_srdb(vul, vul, 0); 386 // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 387 // CHECK-ASM: vsrd 388 vul = vec_srdb(vul, vul, 7); 389 // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7) 390 // CHECK-ASM: vsrd 391 vslll = vec_srdb(vslll, vslll, 0); 392 // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 393 // CHECK-ASM: vsrd 394 vslll = vec_srdb(vslll, vslll, 7); 395 // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7) 396 // CHECK-ASM: vsrd 397 vulll = vec_srdb(vulll, vulll, 0); 398 // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 399 // CHECK-ASM: vsrd 400 vulll = vec_srdb(vulll, vulll, 7); 401 // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7) 402 // CHECK-ASM: vsrd 403 vf = vec_srdb(vf, vf, 0); 404 // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 405 // CHECK-ASM: vsrd 406 vf = vec_srdb(vf, vf, 7); 407 // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7) 408 // CHECK-ASM: vsrd 409 vd = vec_srdb(vd, vd, 0); 410 // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 411 // CHECK-ASM: vsrd 412 vd = vec_srdb(vd, vd, 7); 413 // CHECK: call <16 x i8> @llvm.s390.vsrd(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 7) 414 // CHECK-ASM: vsrd 415 } 416 417 void test_string(void) { 418 // CHECK-ASM-LABEL: test_string 419 420 vuc = vec_search_string_cc(vsc, vsc, vuc, &cc); 421 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrsb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 422 // CHECK-ASM: vstrsb %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, 0 423 vuc = vec_search_string_cc(vbc, vbc, vuc, &cc); 424 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrsb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 425 // CHECK-ASM: vstrsb %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, 0 426 vuc = vec_search_string_cc(vuc, vuc, vuc, &cc); 427 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrsb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 428 // CHECK-ASM: vstrsb %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, 0 429 vuc = vec_search_string_cc(vss, vss, vuc, &cc); 430 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrsh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <16 x i8> %{{.*}}) 431 // CHECK-ASM: vstrsh %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, 0 432 vuc = vec_search_string_cc(vbs, vbs, vuc, &cc); 433 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrsh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <16 x i8> %{{.*}}) 434 // CHECK-ASM: vstrsh %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, 0 435 vuc = vec_search_string_cc(vus, vus, vuc, &cc); 436 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrsh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <16 x i8> %{{.*}}) 437 // CHECK-ASM: vstrsh %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, 0 438 vuc = vec_search_string_cc(vsi, vsi, vuc, &cc); 439 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrsf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <16 x i8> %{{.*}}) 440 // CHECK-ASM: vstrsf %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, 0 441 vuc = vec_search_string_cc(vbi, vbi, vuc, &cc); 442 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrsf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <16 x i8> %{{.*}}) 443 // CHECK-ASM: vstrsf %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, 0 444 vuc = vec_search_string_cc(vui, vui, vuc, &cc); 445 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrsf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <16 x i8> %{{.*}}) 446 // CHECK-ASM: vstrsf %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, 0 447 448 vuc = vec_search_string_until_zero_cc(vsc, vsc, vuc, &cc); 449 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrszb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 450 // CHECK-ASM: vstrszb %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}} 451 vuc = vec_search_string_until_zero_cc(vbc, vbc, vuc, &cc); 452 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrszb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 453 // CHECK-ASM: vstrszb %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}} 454 vuc = vec_search_string_until_zero_cc(vuc, vuc, vuc, &cc); 455 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrszb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 456 // CHECK-ASM: vstrszb %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}} 457 vuc = vec_search_string_until_zero_cc(vss, vss, vuc, &cc); 458 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrszh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <16 x i8> %{{.*}}) 459 // CHECK-ASM: vstrszh %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}} 460 vuc = vec_search_string_until_zero_cc(vbs, vbs, vuc, &cc); 461 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrszh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <16 x i8> %{{.*}}) 462 // CHECK-ASM: vstrszh %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}} 463 vuc = vec_search_string_until_zero_cc(vus, vus, vuc, &cc); 464 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrszh(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <16 x i8> %{{.*}}) 465 // CHECK-ASM: vstrszh %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}} 466 vuc = vec_search_string_until_zero_cc(vsi, vsi, vuc, &cc); 467 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrszf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <16 x i8> %{{.*}}) 468 // CHECK-ASM: vstrszf %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}} 469 vuc = vec_search_string_until_zero_cc(vbi, vbi, vuc, &cc); 470 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrszf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <16 x i8> %{{.*}}) 471 // CHECK-ASM: vstrszf %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}} 472 vuc = vec_search_string_until_zero_cc(vui, vui, vuc, &cc); 473 // CHECK: call { <16 x i8>, i32 } @llvm.s390.vstrszf(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <16 x i8> %{{.*}}) 474 // CHECK-ASM: vstrszf %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}} 475 } 476 477 void test_float(void) { 478 // CHECK-ASM-LABEL: test_float 479 480 vd = vec_double(vsl); 481 // CHECK: sitofp <2 x i64> %{{.*}} to <2 x double> 482 // CHECK-ASM: vcdgb 483 vd = vec_double(vul); 484 // CHECK: uitofp <2 x i64> %{{.*}} to <2 x double> 485 // CHECK-ASM: vcdlgb 486 vf = vec_float(vsi); 487 // CHECK: sitofp <4 x i32> %{{.*}} to <4 x float> 488 // CHECK-ASM: vcefb 489 vf = vec_float(vui); 490 // CHECK: uitofp <4 x i32> %{{.*}} to <4 x float> 491 // CHECK-ASM: vcelfb 492 493 vsl = vec_signed(vd); 494 // CHECK: fptosi <2 x double> %{{.*}} to <2 x i64> 495 // CHECK-ASM: vcgdb 496 vsi = vec_signed(vf); 497 // CHECK: fptosi <4 x float> %{{.*}} to <4 x i32> 498 // CHECK-ASM: vcfeb 499 vul = vec_unsigned(vd); 500 // CHECK: fptoui <2 x double> %{{.*}} to <2 x i64> 501 // CHECK-ASM: vclgdb 502 vui = vec_unsigned(vf); 503 // CHECK: fptoui <4 x float> %{{.*}} to <4 x i32> 504 // CHECK-ASM: vclfeb 505 } 506 507