1 // REQUIRES: systemz-registered-target 2 // RUN: %clang_cc1 -target-cpu z14 -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 z14 -triple s390x-linux-gnu \ 6 // RUN: -O2 -fzvector -flax-vector-conversions=none \ 7 // RUN: -Wall -Wno-unused -Werror -S %s -o - | FileCheck %s --check-prefix=CHECK-ASM 8 9 #include <vecintrin.h> 10 11 volatile vector signed char vsc; 12 volatile vector signed short vss; 13 volatile vector signed int vsi; 14 volatile vector signed long long vsl; 15 volatile vector signed __int128 vslll; 16 volatile vector unsigned char vuc; 17 volatile vector unsigned short vus; 18 volatile vector unsigned int vui; 19 volatile vector unsigned long long vul; 20 volatile vector unsigned __int128 vulll; 21 volatile vector bool char vbc; 22 volatile vector bool short vbs; 23 volatile vector bool int vbi; 24 volatile vector bool long long vbl; 25 volatile vector bool __int128 vblll; 26 volatile vector float vf; 27 volatile vector double vd; 28 29 volatile signed char sc; 30 volatile signed short ss; 31 volatile signed int si; 32 volatile signed long long sl; 33 volatile unsigned char uc; 34 volatile unsigned short us; 35 volatile unsigned int ui; 36 volatile unsigned long long ul; 37 volatile float f; 38 volatile double d; 39 40 const void * volatile cptr; 41 const signed char * volatile cptrsc; 42 const signed short * volatile cptrss; 43 const signed int * volatile cptrsi; 44 const signed long long * volatile cptrsl; 45 const 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 float * volatile cptrf; 50 const double * volatile cptrd; 51 52 void * volatile ptr; 53 signed char * volatile ptrsc; 54 signed short * volatile ptrss; 55 signed int * volatile ptrsi; 56 signed long long * volatile ptrsl; 57 unsigned char * volatile ptruc; 58 unsigned short * volatile ptrus; 59 unsigned int * volatile ptrui; 60 unsigned long long * volatile ptrul; 61 float * volatile ptrf; 62 double * volatile ptrd; 63 64 volatile unsigned int len; 65 volatile int idx; 66 int cc; 67 68 void test_core(void) { 69 // CHECK-ASM-LABEL: test_core 70 vector float vf2; 71 vector double vd2; 72 73 f = vec_extract(vf, 0); 74 // CHECK: extractelement <4 x float> %{{.*}}, i64 0 75 // CHECK-ASM: vstef 76 f = vec_extract(vf, idx); 77 // CHECK: extractelement <4 x float> %{{.*}}, i32 %{{.*}} 78 // CHECK-ASM: vlgvf 79 d = vec_extract(vd, 0); 80 // CHECK: extractelement <2 x double> %{{.*}}, i64 0 81 // CHECK-ASM: vsteg 82 d = vec_extract(vd, idx); 83 // CHECK: extractelement <2 x double> %{{.*}}, i32 %{{.*}} 84 // CHECK-ASM: vlgvg 85 86 vf2 = vf; 87 vf = vec_insert(f, vf2, 0); 88 // CHECK: insertelement <4 x float> %{{.*}}, float %{{.*}}, i64 0 89 // CHECK-ASM: vlef 90 vf = vec_insert(0.0f, vf, 1); 91 // CHECK: insertelement <4 x float> %{{.*}}, float 0.000000e+00, i64 1 92 // CHECK-ASM: vleif %{{.*}}, 0, 1 93 vf = vec_insert(f, vf, idx); 94 // CHECK: insertelement <4 x float> %{{.*}}, float %{{.*}}, i32 %{{.*}} 95 // CHECK-ASM: vlvgf 96 vd2 = vd; 97 vd = vec_insert(d, vd2, 0); 98 // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i64 0 99 // CHECK-ASM: vleg 100 vd = vec_insert(0.0, vd, 1); 101 // CHECK: insertelement <2 x double> %{{.*}}, double 0.000000e+00, i64 1 102 // CHECK-ASM: vleig %{{.*}}, 0, 1 103 vd = vec_insert(d, vd, idx); 104 // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 %{{.*}} 105 // CHECK-ASM: vlvgg 106 107 vf = vec_promote(f, idx); 108 // CHECK: insertelement <4 x float> poison, float %{{.*}}, i32 %{{.*}} 109 // CHECK-ASM: vlvgf 110 vd = vec_promote(d, idx); 111 // CHECK: insertelement <2 x double> poison, double %{{.*}}, i32 %{{.*}} 112 // CHECK-ASM: vlvgg 113 114 vf = vec_insert_and_zero(cptrf); 115 // CHECK: insertelement <4 x float> <float 0.000000e+00, float poison, float 0.000000e+00, float 0.000000e+00>, float %{{.*}}, i64 1 116 // CHECK-ASM: vllezf 117 vd = vec_insert_and_zero(cptrd); 118 // CHECK: insertelement <2 x double> <double poison, double 0.000000e+00>, double %{{.*}}, i64 0 119 // CHECK-ASM: vllezg 120 121 vf = vec_perm(vf, vf, vuc); 122 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 123 // CHECK-ASM: vperm 124 vd = vec_perm(vd, vd, vuc); 125 // CHECK: call <16 x i8> @llvm.s390.vperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 126 // CHECK-ASM: vperm 127 128 vul = vec_bperm(vulll, vuc); 129 // CHECK: call <2 x i64> @llvm.s390.vbperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 130 // CHECK-ASM: vbperm 131 132 vul = vec_bperm_u128(vuc, vuc); 133 // CHECK: call <2 x i64> @llvm.s390.vbperm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 134 // CHECK-ASM: vbperm 135 136 vf = vec_revb(vf); 137 // CHECK-ASM: vperm 138 vd = vec_revb(vd); 139 // CHECK-ASM: vperm 140 141 vf = vec_reve(vf); 142 // CHECK-ASM: vperm 143 vd = vec_reve(vd); 144 // CHECK-ASM: {{vperm|vpdi}} 145 146 vf = vec_sel(vf, vf, vui); 147 // CHECK-ASM: vsel 148 vf = vec_sel(vf, vf, vbi); 149 // CHECK-ASM: vsel 150 vd = vec_sel(vd, vd, vul); 151 // CHECK-ASM: vsel 152 vd = vec_sel(vd, vd, vbl); 153 // CHECK-ASM: vsel 154 155 vf = vec_gather_element(vf, vui, cptrf, 0); 156 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 0 157 vf = vec_gather_element(vf, vui, cptrf, 1); 158 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 1 159 vf = vec_gather_element(vf, vui, cptrf, 2); 160 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 2 161 vf = vec_gather_element(vf, vui, cptrf, 3); 162 // CHECK-ASM: vgef %{{.*}}, 0(%{{.*}},%{{.*}}), 3 163 vd = vec_gather_element(vd, vul, cptrd, 0); 164 // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 0 165 vd = vec_gather_element(vd, vul, cptrd, 1); 166 // CHECK-ASM: vgeg %{{.*}}, 0(%{{.*}},%{{.*}}), 1 167 168 vec_scatter_element(vf, vui, ptrf, 0); 169 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 0 170 vec_scatter_element(vf, vui, ptrf, 1); 171 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 1 172 vec_scatter_element(vf, vui, ptrf, 2); 173 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 2 174 vec_scatter_element(vf, vui, ptrf, 3); 175 // CHECK-ASM: vscef %{{.*}}, 0(%{{.*}},%{{.*}}), 3 176 vec_scatter_element(vd, vul, ptrd, 0); 177 // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 0 178 vec_scatter_element(vd, vul, ptrd, 1); 179 // CHECK-ASM: vsceg %{{.*}}, 0(%{{.*}},%{{.*}}), 1 180 181 vf = vec_xl(idx, cptrf); 182 // CHECK-ASM: vl 183 vd = vec_xl(idx, cptrd); 184 // CHECK-ASM: vl 185 186 vec_xst(vf, idx, ptrf); 187 // CHECK-ASM: vst 188 vec_xst(vd, idx, ptrd); 189 // CHECK-ASM: vst 190 191 vd = vec_load_bndry(cptrd, 64); 192 // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 0) 193 // CHECK-ASM: vlbb 194 vf = vec_load_bndry(cptrf, 64); 195 // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 0) 196 // CHECK-ASM: vlbb 197 vf = vec_load_bndry(cptrf, 128); 198 // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 1) 199 // CHECK-ASM: vlbb 200 vf = vec_load_bndry(cptrf, 256); 201 // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 2) 202 // CHECK-ASM: vlbb 203 vf = vec_load_bndry(cptrf, 512); 204 // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 3) 205 // CHECK-ASM: vlbb 206 vf = vec_load_bndry(cptrf, 1024); 207 // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 4) 208 // CHECK-ASM: vlbb 209 vf = vec_load_bndry(cptrf, 2048); 210 // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 5) 211 // CHECK-ASM: vlbb 212 vf = vec_load_bndry(cptrf, 4096); 213 // CHECK: call <16 x i8> @llvm.s390.vlbb(ptr %{{.*}}, i32 6) 214 // CHECK-ASM: vlbb 215 216 vf = vec_load_len(cptrf, idx); 217 // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, ptr %{{.*}}) 218 // CHECK-ASM: vll 219 vd = vec_load_len(cptrd, idx); 220 // CHECK: call <16 x i8> @llvm.s390.vll(i32 %{{.*}}, ptr %{{.*}}) 221 // CHECK-ASM: vll 222 223 vec_store_len(vf, ptrf, idx); 224 // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, ptr %{{.*}}) 225 // CHECK-ASM: vstl 226 vec_store_len(vd, ptrd, idx); 227 // CHECK: call void @llvm.s390.vstl(<16 x i8> %{{.*}}, i32 %{{.*}}, ptr %{{.*}}) 228 // CHECK-ASM: vstl 229 230 vsc = vec_load_len_r(cptrsc, 0); 231 // CHECK: call <16 x i8> @llvm.s390.vlrl(i32 0, ptr %{{.*}}) 232 // CHECK-ASM: vlrl %{{.*}}, 0(%{{.*}}), 0 233 vsc = vec_load_len_r(cptrsc, idx); 234 // CHECK: call <16 x i8> @llvm.s390.vlrl(i32 %{{.*}}, ptr %{{.*}}) 235 // CHECK-ASM: vlrlr 236 vuc = vec_load_len_r(cptruc, 0); 237 // CHECK: call <16 x i8> @llvm.s390.vlrl(i32 0, ptr %{{.*}}) 238 // CHECK-ASM: vlrl %{{.*}}, 0(%{{.*}}), 0 239 vuc = vec_load_len_r(cptruc, idx); 240 // CHECK: call <16 x i8> @llvm.s390.vlrl(i32 %{{.*}}, ptr %{{.*}}) 241 // CHECK-ASM: vlrlr 242 243 vec_store_len_r(vsc, ptrsc, 0); 244 // CHECK: call void @llvm.s390.vstrl(<16 x i8> %{{.*}}, i32 0, ptr %{{.*}}) 245 // CHECK-ASM: vstrl %{{.*}}, 0(%{{.*}}), 0 246 vec_store_len_r(vsc, ptrsc, idx); 247 // CHECK: call void @llvm.s390.vstrl(<16 x i8> %{{.*}}, i32 %{{.*}}, ptr %{{.*}}) 248 // CHECK-ASM: vstrlr 249 vec_store_len_r(vuc, ptruc, 0); 250 // CHECK: call void @llvm.s390.vstrl(<16 x i8> %{{.*}}, i32 0, ptr %{{.*}}) 251 // CHECK-ASM: vstrl %{{.*}}, 0(%{{.*}}), 0 252 vec_store_len_r(vuc, ptruc, idx); 253 // CHECK: call void @llvm.s390.vstrl(<16 x i8> %{{.*}}, i32 %{{.*}}, ptr %{{.*}}) 254 // CHECK-ASM: vstrlr 255 256 vf = vec_splat(vf, 0); 257 // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> poison, <4 x i32> zeroinitializer 258 // CHECK-ASM: vrepf 259 vf = vec_splat(vf, 1); 260 // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> poison, <4 x i32> <i32 1, i32 1, i32 1, i32 1> 261 // CHECK-ASM: vrepf 262 vd = vec_splat(vd, 0); 263 // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> poison, <2 x i32> zeroinitializer 264 // CHECK-ASM: vrepg 265 vd = vec_splat(vd, 1); 266 // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> poison, <2 x i32> <i32 1, i32 1> 267 // CHECK-ASM: vrepg 268 269 vf = vec_splats(f); 270 // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> poison, <4 x i32> zeroinitializer 271 // CHECK-ASM: vlrepf 272 vd = vec_splats(d); 273 // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> poison, <2 x i32> zeroinitializer 274 // CHECK-ASM: vlrepg 275 276 vf = vec_mergeh(vf, vf); 277 // shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 1, i32 5> 278 // CHECK-ASM: vmrhf 279 vd = vec_mergeh(vd, vd); 280 // shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> <i32 0, i32 2> 281 // CHECK-ASM: vmrhg 282 283 vf = vec_mergel(vf, vf); 284 // shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <i32 2, i32 6, i32 3, i32 7> 285 // CHECK-ASM: vmrlf 286 vd = vec_mergel(vd, vd); 287 // shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <i32 1, i32 3> 288 // CHECK-ASM: vmrlg 289 } 290 291 void test_compare(void) { 292 // CHECK-ASM-LABEL: test_compare 293 294 vbi = vec_cmpeq(vf, vf); 295 // CHECK: fcmp oeq <4 x float> %{{.*}}, %{{.*}} 296 // CHECK-ASM: vfcesb 297 vbl = vec_cmpeq(vd, vd); 298 // CHECK: fcmp oeq <2 x double> %{{.*}}, %{{.*}} 299 // CHECK-ASM: vfcedb 300 301 vbi = vec_cmpge(vf, vf); 302 // CHECK: fcmp oge <4 x float> %{{.*}}, %{{.*}} 303 // CHECK-ASM: vfchesb 304 vbl = vec_cmpge(vd, vd); 305 // CHECK: fcmp oge <2 x double> %{{.*}}, %{{.*}} 306 // CHECK-ASM: vfchedb 307 308 vbi = vec_cmpgt(vf, vf); 309 // CHECK: fcmp ogt <4 x float> %{{.*}}, %{{.*}} 310 // CHECK-ASM: vfchsb 311 vbl = vec_cmpgt(vd, vd); 312 // CHECK: fcmp ogt <2 x double> %{{.*}}, %{{.*}} 313 // CHECK-ASM: vfchdb 314 315 vbi = vec_cmple(vf, vf); 316 // CHECK: fcmp ole <4 x float> %{{.*}}, %{{.*}} 317 // CHECK-ASM: vfchesb 318 vbl = vec_cmple(vd, vd); 319 // CHECK: fcmp ole <2 x double> %{{.*}}, %{{.*}} 320 // CHECK-ASM: vfchedb 321 322 vbi = vec_cmplt(vf, vf); 323 // CHECK: fcmp olt <4 x float> %{{.*}}, %{{.*}} 324 // CHECK-ASM: vfchsb 325 vbl = vec_cmplt(vd, vd); 326 // CHECK: fcmp olt <2 x double> %{{.*}}, %{{.*}} 327 // CHECK-ASM: vfchdb 328 329 idx = vec_all_eq(vf, vf); 330 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfcesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}}) 331 // CHECK-ASM: vfcesbs 332 idx = vec_all_eq(vd, vd); 333 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 334 // CHECK-ASM: vfcedbs 335 336 idx = vec_all_ne(vf, vf); 337 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfcesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}}) 338 // CHECK-ASM: vfcesbs 339 idx = vec_all_ne(vd, vd); 340 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 341 // CHECK-ASM: vfcedbs 342 343 idx = vec_all_ge(vf, vf); 344 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}}) 345 // CHECK-ASM: vfchesbs 346 idx = vec_all_ge(vd, vd); 347 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 348 // CHECK-ASM: vfchedbs 349 350 idx = vec_all_gt(vf, vf); 351 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}}) 352 // CHECK-ASM: vfchsbs 353 idx = vec_all_gt(vd, vd); 354 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 355 // CHECK-ASM: vfchdbs 356 357 idx = vec_all_le(vf, vf); 358 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}}) 359 // CHECK-ASM: vfchesbs 360 idx = vec_all_le(vd, vd); 361 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 362 // CHECK-ASM: vfchedbs 363 364 idx = vec_all_lt(vf, vf); 365 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}}) 366 // CHECK-ASM: vfchsbs 367 idx = vec_all_lt(vd, vd); 368 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 369 // CHECK-ASM: vfchdbs 370 371 idx = vec_all_nge(vf, vf); 372 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}}) 373 // CHECK-ASM: vfchesbs 374 idx = vec_all_nge(vd, vd); 375 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 376 // CHECK-ASM: vfchedbs 377 378 idx = vec_all_ngt(vf, vf); 379 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}}) 380 // CHECK-ASM: vfchsbs 381 idx = vec_all_ngt(vd, vd); 382 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 383 // CHECK-ASM: vfchdbs 384 385 idx = vec_all_nle(vf, vf); 386 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}}) 387 // CHECK-ASM: vfchesbs 388 idx = vec_all_nle(vd, vd); 389 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 390 // CHECK-ASM: vfchedbs 391 392 idx = vec_all_nlt(vf, vf); 393 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}}) 394 // CHECK-ASM: vfchsbs 395 idx = vec_all_nlt(vd, vd); 396 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 397 // CHECK-ASM: vfchdbs 398 399 idx = vec_all_nan(vf); 400 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 15) 401 // CHECK-ASM: vftcisb 402 idx = vec_all_nan(vd); 403 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15) 404 // CHECK-ASM: vftcidb 405 406 idx = vec_all_numeric(vf); 407 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 15) 408 // CHECK-ASM: vftcisb 409 idx = vec_all_numeric(vd); 410 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15) 411 // CHECK-ASM: vftcidb 412 413 idx = vec_any_eq(vf, vf); 414 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfcesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}}) 415 // CHECK-ASM: vfcesbs 416 idx = vec_any_eq(vd, vd); 417 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 418 // CHECK-ASM: vfcedbs 419 420 idx = vec_any_ne(vf, vf); 421 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfcesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}}) 422 // CHECK-ASM: vfcesbs 423 idx = vec_any_ne(vd, vd); 424 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfcedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 425 // CHECK-ASM: vfcedbs 426 427 idx = vec_any_ge(vf, vf); 428 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}}) 429 // CHECK-ASM: vfchesbs 430 idx = vec_any_ge(vd, vd); 431 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 432 // CHECK-ASM: vfchedbs 433 434 idx = vec_any_gt(vf, vf); 435 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}}) 436 // CHECK-ASM: vfchsbs 437 idx = vec_any_gt(vd, vd); 438 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 439 // CHECK-ASM: vfchdbs 440 441 idx = vec_any_le(vf, vf); 442 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}}) 443 // CHECK-ASM: vfchesbs 444 idx = vec_any_le(vd, vd); 445 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 446 // CHECK-ASM: vfchedbs 447 448 idx = vec_any_lt(vf, vf); 449 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}}) 450 // CHECK-ASM: vfchsbs 451 idx = vec_any_lt(vd, vd); 452 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 453 // CHECK-ASM: vfchdbs 454 455 idx = vec_any_nge(vf, vf); 456 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}}) 457 // CHECK-ASM: vfchesbs 458 idx = vec_any_nge(vd, vd); 459 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 460 // CHECK-ASM: vfchedbs 461 462 idx = vec_any_ngt(vf, vf); 463 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}}) 464 // CHECK-ASM: vfchsbs 465 idx = vec_any_ngt(vd, vd); 466 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 467 // CHECK-ASM: vfchdbs 468 469 idx = vec_any_nle(vf, vf); 470 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchesbs(<4 x float> %{{.*}}, <4 x float> %{{.*}}) 471 // CHECK-ASM: vfchesbs 472 idx = vec_any_nle(vd, vd); 473 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchedbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 474 // CHECK-ASM: vfchedbs 475 476 idx = vec_any_nlt(vf, vf); 477 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vfchsbs(<4 x float> %{{.*}}, <4 x float> %{{.*}}) 478 // CHECK-ASM: vfchsbs 479 idx = vec_any_nlt(vd, vd); 480 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vfchdbs(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 481 // CHECK-ASM: vfchdbs 482 483 idx = vec_any_nan(vf); 484 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 15) 485 // CHECK-ASM: vftcisb 486 idx = vec_any_nan(vd); 487 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15) 488 // CHECK-ASM: vftcidb 489 490 idx = vec_any_numeric(vf); 491 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 15) 492 // CHECK-ASM: vftcisb 493 idx = vec_any_numeric(vd); 494 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 15) 495 // CHECK-ASM: vftcidb 496 } 497 498 void test_integer(void) { 499 // CHECK-ASM-LABEL: test_integer 500 501 vf = vec_and(vf, vf); 502 // CHECK-ASM: vn 503 vd = vec_and(vd, vd); 504 // CHECK-ASM: vn 505 506 vf = vec_or(vf, vf); 507 // CHECK-ASM: vo 508 vd = vec_or(vd, vd); 509 // CHECK-ASM: vo 510 511 vf = vec_xor(vf, vf); 512 // CHECK-ASM: vx 513 vd = vec_xor(vd, vd); 514 // CHECK-ASM: vx 515 516 vf = vec_andc(vf, vf); 517 // CHECK-ASM: vnc 518 vd = vec_andc(vd, vd); 519 // CHECK-ASM: vnc 520 521 vf = vec_nor(vf, vf); 522 // CHECK-ASM: vno 523 vd = vec_nor(vd, vd); 524 // CHECK-ASM: vno 525 526 vsc = vec_nand(vsc, vsc); 527 // CHECK-ASM: vnn 528 vuc = vec_nand(vuc, vuc); 529 // CHECK-ASM: vnn 530 vbc = vec_nand(vbc, vbc); 531 // CHECK-ASM: vnn 532 vss = vec_nand(vss, vss); 533 // CHECK-ASM: vnn 534 vus = vec_nand(vus, vus); 535 // CHECK-ASM: vnn 536 vbs = vec_nand(vbs, vbs); 537 // CHECK-ASM: vnn 538 vsi = vec_nand(vsi, vsi); 539 // CHECK-ASM: vnn 540 vui = vec_nand(vui, vui); 541 // CHECK-ASM: vnn 542 vbi = vec_nand(vbi, vbi); 543 // CHECK-ASM: vnn 544 vsl = vec_nand(vsl, vsl); 545 // CHECK-ASM: vnn 546 vul = vec_nand(vul, vul); 547 // CHECK-ASM: vnn 548 vbl = vec_nand(vbl, vbl); 549 // CHECK-ASM: vnn 550 vslll = vec_nand(vslll, vslll); 551 // CHECK-ASM: vnn 552 vulll = vec_nand(vulll, vulll); 553 // CHECK-ASM: vnn 554 vblll = vec_nand(vblll, vblll); 555 // CHECK-ASM: vnn 556 vf = vec_nand(vf, vf); 557 // CHECK-ASM: vnn 558 vd = vec_nand(vd, vd); 559 // CHECK-ASM: vnn 560 561 vsc = vec_orc(vsc, vsc); 562 // CHECK-ASM: voc 563 vuc = vec_orc(vuc, vuc); 564 // CHECK-ASM: voc 565 vbc = vec_orc(vbc, vbc); 566 // CHECK-ASM: voc 567 vss = vec_orc(vss, vss); 568 // CHECK-ASM: voc 569 vus = vec_orc(vus, vus); 570 // CHECK-ASM: voc 571 vbs = vec_orc(vbs, vbs); 572 // CHECK-ASM: voc 573 vsi = vec_orc(vsi, vsi); 574 // CHECK-ASM: voc 575 vui = vec_orc(vui, vui); 576 // CHECK-ASM: voc 577 vbi = vec_orc(vbi, vbi); 578 // CHECK-ASM: voc 579 vsl = vec_orc(vsl, vsl); 580 // CHECK-ASM: voc 581 vul = vec_orc(vul, vul); 582 // CHECK-ASM: voc 583 vbl = vec_orc(vbl, vbl); 584 // CHECK-ASM: voc 585 vslll = vec_orc(vslll, vslll); 586 // CHECK-ASM: voc 587 vulll = vec_orc(vulll, vulll); 588 // CHECK-ASM: voc 589 vblll = vec_orc(vblll, vblll); 590 // CHECK-ASM: voc 591 vf = vec_orc(vf, vf); 592 // CHECK-ASM: voc 593 vd = vec_orc(vd, vd); 594 // CHECK-ASM: voc 595 596 vsc = vec_eqv(vsc, vsc); 597 // CHECK-ASM: vnx 598 vuc = vec_eqv(vuc, vuc); 599 // CHECK-ASM: vnx 600 vbc = vec_eqv(vbc, vbc); 601 // CHECK-ASM: vnx 602 vss = vec_eqv(vss, vss); 603 // CHECK-ASM: vnx 604 vus = vec_eqv(vus, vus); 605 // CHECK-ASM: vnx 606 vbs = vec_eqv(vbs, vbs); 607 // CHECK-ASM: vnx 608 vsi = vec_eqv(vsi, vsi); 609 // CHECK-ASM: vnx 610 vui = vec_eqv(vui, vui); 611 // CHECK-ASM: vnx 612 vbi = vec_eqv(vbi, vbi); 613 // CHECK-ASM: vnx 614 vsl = vec_eqv(vsl, vsl); 615 // CHECK-ASM: vnx 616 vul = vec_eqv(vul, vul); 617 // CHECK-ASM: vnx 618 vbl = vec_eqv(vbl, vbl); 619 // CHECK-ASM: vnx 620 vslll = vec_eqv(vslll, vslll); 621 // CHECK-ASM: vnx 622 vulll = vec_eqv(vulll, vulll); 623 // CHECK-ASM: vnx 624 vblll = vec_eqv(vblll, vblll); 625 // CHECK-ASM: vnx 626 vf = vec_eqv(vf, vf); 627 // CHECK-ASM: vnx 628 vd = vec_eqv(vd, vd); 629 // CHECK-ASM: vnx 630 631 vuc = vec_popcnt(vsc); 632 // CHECK: call range(i8 0, 9) <16 x i8> @llvm.ctpop.v16i8(<16 x i8> %{{.*}}) 633 // CHECK-ASM: vpopctb 634 vuc = vec_popcnt(vuc); 635 // CHECK: call range(i8 0, 9) <16 x i8> @llvm.ctpop.v16i8(<16 x i8> %{{.*}}) 636 // CHECK-ASM: vpopctb 637 vus = vec_popcnt(vss); 638 // CHECK: call range(i16 0, 17) <8 x i16> @llvm.ctpop.v8i16(<8 x i16> %{{.*}}) 639 // CHECK-ASM: vpopcth 640 vus = vec_popcnt(vus); 641 // CHECK: call range(i16 0, 17) <8 x i16> @llvm.ctpop.v8i16(<8 x i16> %{{.*}}) 642 // CHECK-ASM: vpopcth 643 vui = vec_popcnt(vsi); 644 // CHECK: call range(i32 0, 33) <4 x i32> @llvm.ctpop.v4i32(<4 x i32> %{{.*}}) 645 // CHECK-ASM: vpopctf 646 vui = vec_popcnt(vui); 647 // CHECK: call range(i32 0, 33) <4 x i32> @llvm.ctpop.v4i32(<4 x i32> %{{.*}}) 648 // CHECK-ASM: vpopctf 649 vul = vec_popcnt(vsl); 650 // CHECK: call range(i64 0, 65) <2 x i64> @llvm.ctpop.v2i64(<2 x i64> %{{.*}}) 651 // CHECK-ASM: vpopctg 652 vul = vec_popcnt(vul); 653 // CHECK: call range(i64 0, 65) <2 x i64> @llvm.ctpop.v2i64(<2 x i64> %{{.*}}) 654 // CHECK-ASM: vpopctg 655 656 vf = vec_slb(vf, vsi); 657 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 658 // CHECK-ASM: vslb 659 vf = vec_slb(vf, vui); 660 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 661 // CHECK-ASM: vslb 662 vf = vec_slb(vf, vuc); 663 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 664 // CHECK-ASM: vslb 665 vd = vec_slb(vd, vsl); 666 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 667 // CHECK-ASM: vslb 668 vd = vec_slb(vd, vul); 669 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 670 // CHECK-ASM: vslb 671 vd = vec_slb(vd, vuc); 672 // CHECK: call <16 x i8> @llvm.s390.vslb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 673 // CHECK-ASM: vslb 674 675 vf = vec_sld(vf, vf, 0); 676 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 677 // CHECK-ASM: vsldb 678 vf = vec_sld(vf, vf, 15); 679 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15) 680 // CHECK-ASM: vsldb 681 vd = vec_sld(vd, vd, 0); 682 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 0) 683 // CHECK-ASM: vsldb 684 vd = vec_sld(vd, vd, 15); 685 // CHECK: call <16 x i8> @llvm.s390.vsldb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i32 15) 686 // CHECK-ASM: vsldb 687 688 vf = vec_srab(vf, vsi); 689 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 690 // CHECK-ASM: vsrab 691 vf = vec_srab(vf, vui); 692 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 693 // CHECK-ASM: vsrab 694 vf = vec_srab(vf, vuc); 695 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 696 // CHECK-ASM: vsrab 697 vd = vec_srab(vd, vsl); 698 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 699 // CHECK-ASM: vsrab 700 vd = vec_srab(vd, vul); 701 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 702 // CHECK-ASM: vsrab 703 vd = vec_srab(vd, vuc); 704 // CHECK: call <16 x i8> @llvm.s390.vsrab(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 705 // CHECK-ASM: vsrab 706 707 vf = vec_srb(vf, vsi); 708 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 709 // CHECK-ASM: vsrlb 710 vf = vec_srb(vf, vui); 711 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 712 // CHECK-ASM: vsrlb 713 vf = vec_srb(vf, vuc); 714 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 715 // CHECK-ASM: vsrlb 716 vd = vec_srb(vd, vsl); 717 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 718 // CHECK-ASM: vsrlb 719 vd = vec_srb(vd, vul); 720 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 721 // CHECK-ASM: vsrlb 722 vd = vec_srb(vd, vuc); 723 // CHECK: call <16 x i8> @llvm.s390.vsrlb(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 724 // CHECK-ASM: vsrlb 725 726 idx = vec_test_mask(vf, vui); 727 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 728 // CHECK-ASM: vtm 729 idx = vec_test_mask(vd, vul); 730 // CHECK: call i32 @llvm.s390.vtm(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) 731 // CHECK-ASM: vtm 732 733 vulll = vec_msum(vul, vul, vulll, 0); 734 // CHECK: call i128 @llvm.s390.vmslg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i128 %{{.*}}, i32 0) 735 // CHECK-ASM: vmslg 736 vulll = vec_msum(vul, vul, vulll, 4); 737 // CHECK: call i128 @llvm.s390.vmslg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i128 %{{.*}}, i32 4) 738 // CHECK-ASM: vmslg 739 vulll = vec_msum(vul, vul, vulll, 8); 740 // CHECK: call i128 @llvm.s390.vmslg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i128 %{{.*}}, i32 8) 741 // CHECK-ASM: vmslg 742 vulll = vec_msum(vul, vul, vulll, 12); 743 // CHECK: call i128 @llvm.s390.vmslg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i128 %{{.*}}, i32 12) 744 // CHECK-ASM: vmslg 745 746 vuc = vec_msum_u128(vul, vul, vuc, 0); 747 // CHECK: call i128 @llvm.s390.vmslg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i128 %{{.*}}, i32 0) 748 // CHECK-ASM: vmslg 749 vuc = vec_msum_u128(vul, vul, vuc, 4); 750 // CHECK: call i128 @llvm.s390.vmslg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i128 %{{.*}}, i32 4) 751 // CHECK-ASM: vmslg 752 vuc = vec_msum_u128(vul, vul, vuc, 8); 753 // CHECK: call i128 @llvm.s390.vmslg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i128 %{{.*}}, i32 8) 754 // CHECK-ASM: vmslg 755 vuc = vec_msum_u128(vul, vul, vuc, 12); 756 // CHECK: call i128 @llvm.s390.vmslg(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i128 %{{.*}}, i32 12) 757 // CHECK-ASM: vmslg 758 } 759 760 void test_float(void) { 761 // CHECK-ASM-LABEL: test_float 762 763 vf = vec_abs(vf); 764 // CHECK: call <4 x float> @llvm.fabs.v4f32(<4 x float> %{{.*}}) 765 // CHECK-ASM: vflpsb 766 vd = vec_abs(vd); 767 // CHECK: call <2 x double> @llvm.fabs.v2f64(<2 x double> %{{.*}}) 768 // CHECK-ASM: vflpdb 769 770 vf = vec_nabs(vf); 771 // CHECK: [[ABS:%[^ ]+]] = tail call <4 x float> @llvm.fabs.v4f32(<4 x float> %{{.*}}) 772 // CHECK-NEXT: fneg <4 x float> [[ABS]] 773 // CHECK-ASM: vflnsb 774 vd = vec_nabs(vd); 775 // CHECK: [[ABS:%[^ ]+]] = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %{{.*}}) 776 // CHECK-NEXT: fneg <2 x double> [[ABS]] 777 // CHECK-ASM: vflndb 778 779 vf = vec_max(vf, vf); 780 // CHECK: call <4 x float> @llvm.s390.vfmaxsb(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 0) 781 // CHECK-ASM: vfmaxsb 782 vd = vec_max(vd, vd); 783 // CHECK: call <2 x double> @llvm.s390.vfmaxdb(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 0) 784 // CHECK-ASM: vfmaxdb 785 786 vf = vec_min(vf, vf); 787 // CHECK: call <4 x float> @llvm.s390.vfminsb(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 0) 788 // CHECK-ASM: vfminsb 789 vd = vec_min(vd, vd); 790 // CHECK: call <2 x double> @llvm.s390.vfmindb(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 0) 791 // CHECK-ASM: vfmindb 792 793 vf = vec_madd(vf, vf, vf); 794 // CHECK: call <4 x float> @llvm.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}) 795 // CHECK-ASM: vfmasb 796 vd = vec_madd(vd, vd, vd); 797 // CHECK: call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}) 798 // CHECK-ASM: vfmadb 799 800 vf = vec_msub(vf, vf, vf); 801 // CHECK: [[NEG:%[^ ]+]] = fneg <4 x float> %{{.*}} 802 // CHECK: call <4 x float> @llvm.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> [[NEG]]) 803 // CHECK-ASM: vfmssb 804 vd = vec_msub(vd, vd, vd); 805 // CHECK: [[NEG:%[^ ]+]] = fneg <2 x double> %{{.*}} 806 // CHECK: call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> [[NEG]]) 807 // CHECK-ASM: vfmsdb 808 809 vf = vec_nmadd(vf, vf, vf); 810 // CHECK: [[RES:%[^ ]+]] = tail call <4 x float> @llvm.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}) 811 // CHECK: fneg <4 x float> [[RES]] 812 // CHECK-ASM: vfnmasb 813 vd = vec_nmadd(vd, vd, vd); 814 // CHECK: [[RES:%[^ ]+]] = tail call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}) 815 // CHECK: fneg <2 x double> [[RES]] 816 // CHECK-ASM: vfnmadb 817 818 vf = vec_nmsub(vf, vf, vf); 819 // CHECK: [[NEG:%[^ ]+]] = fneg <4 x float> %{{.*}} 820 // CHECK: [[RES:%[^ ]+]] = tail call <4 x float> @llvm.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> [[NEG]]) 821 // CHECK: fneg <4 x float> [[RES]] 822 // CHECK-ASM: vfnmssb 823 vd = vec_nmsub(vd, vd, vd); 824 // CHECK: [[NEG:%[^ ]+]] = fneg <2 x double> %{{.*}} 825 // CHECK: [[RES:%[^ ]+]] = tail call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> [[NEG]]) 826 // CHECK: fneg <2 x double> [[RES]] 827 // CHECK-ASM: vfnmsdb 828 829 vf = vec_sqrt(vf); 830 // CHECK: call <4 x float> @llvm.sqrt.v4f32(<4 x float> %{{.*}}) 831 // CHECK-ASM: vfsqsb 832 vd = vec_sqrt(vd); 833 // CHECK: call <2 x double> @llvm.sqrt.v2f64(<2 x double> %{{.*}}) 834 // CHECK-ASM: vfsqdb 835 836 vd = vec_doublee(vf); 837 // CHECK: fpext <2 x float> %{{.*}} to <2 x double> 838 // CHECK-ASM: vldeb 839 vf = vec_floate(vd); 840 // CHECK: fptrunc <2 x double> %{{.*}} to <2 x float> 841 // CHECK-ASM: vledb 842 843 vd = vec_double(vsl); 844 // CHECK: sitofp <2 x i64> %{{.*}} to <2 x double> 845 // CHECK-ASM: vcdgb 846 vd = vec_double(vul); 847 // CHECK: uitofp <2 x i64> %{{.*}} to <2 x double> 848 // CHECK-ASM: vcdlgb 849 850 vsl = vec_signed(vd); 851 // CHECK: fptosi <2 x double> %{{.*}} to <2 x i64> 852 // CHECK-ASM: vcgdb 853 vul = vec_unsigned(vd); 854 // CHECK: fptoui <2 x double> %{{.*}} to <2 x i64> 855 // CHECK-ASM: vclgdb 856 857 vf = vec_roundp(vf); 858 // CHECK: call <4 x float> @llvm.ceil.v4f32(<4 x float> %{{.*}}) 859 // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 6 860 vf = vec_ceil(vf); 861 // CHECK: call <4 x float> @llvm.ceil.v4f32(<4 x float> %{{.*}}) 862 // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 6 863 vd = vec_roundp(vd); 864 // CHECK: call <2 x double> @llvm.ceil.v2f64(<2 x double> %{{.*}}) 865 // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 6 866 vd = vec_ceil(vd); 867 // CHECK: call <2 x double> @llvm.ceil.v2f64(<2 x double> %{{.*}}) 868 // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 6 869 870 vf = vec_roundm(vf); 871 // CHECK: call <4 x float> @llvm.floor.v4f32(<4 x float> %{{.*}}) 872 // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 7 873 vf = vec_floor(vf); 874 // CHECK: call <4 x float> @llvm.floor.v4f32(<4 x float> %{{.*}}) 875 // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 7 876 vd = vec_roundm(vd); 877 // CHECK: call <2 x double> @llvm.floor.v2f64(<2 x double> %{{.*}}) 878 // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 7 879 vd = vec_floor(vd); 880 // CHECK: call <2 x double> @llvm.floor.v2f64(<2 x double> %{{.*}}) 881 // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 7 882 883 vf = vec_roundz(vf); 884 // CHECK: call <4 x float> @llvm.trunc.v4f32(<4 x float> %{{.*}}) 885 // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 5 886 vf = vec_trunc(vf); 887 // CHECK: call <4 x float> @llvm.trunc.v4f32(<4 x float> %{{.*}}) 888 // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 5 889 vd = vec_roundz(vd); 890 // CHECK: call <2 x double> @llvm.trunc.v2f64(<2 x double> %{{.*}}) 891 // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 5 892 vd = vec_trunc(vd); 893 // CHECK: call <2 x double> @llvm.trunc.v2f64(<2 x double> %{{.*}}) 894 // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 5 895 896 vf = vec_roundc(vf); 897 // CHECK: call <4 x float> @llvm.nearbyint.v4f32(<4 x float> %{{.*}}) 898 // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 0 899 vd = vec_roundc(vd); 900 // CHECK: call <2 x double> @llvm.nearbyint.v2f64(<2 x double> %{{.*}}) 901 // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 0 902 903 vf = vec_rint(vf); 904 // CHECK: call <4 x float> @llvm.rint.v4f32(<4 x float> %{{.*}}) 905 // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 0, 0 906 vd = vec_rint(vd); 907 // CHECK: call <2 x double> @llvm.rint.v2f64(<2 x double> %{{.*}}) 908 // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 0, 0 909 910 vf = vec_round(vf); 911 // CHECK: call <4 x float> @llvm.s390.vfisb(<4 x float> %{{.*}}, i32 4, i32 4) 912 // CHECK-ASM: vfisb %{{.*}}, %{{.*}}, 4, 4 913 vd = vec_round(vd); 914 // CHECK: call <2 x double> @llvm.s390.vfidb(<2 x double> %{{.*}}, i32 4, i32 4) 915 // CHECK-ASM: vfidb %{{.*}}, %{{.*}}, 4, 4 916 917 vbi = vec_fp_test_data_class(vf, 0, &cc); 918 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 0) 919 // CHECK-ASM: vftcisb 920 vbi = vec_fp_test_data_class(vf, 4095, &cc); 921 // CHECK: call { <4 x i32>, i32 } @llvm.s390.vftcisb(<4 x float> %{{.*}}, i32 4095) 922 // CHECK-ASM: vftcisb 923 vbl = vec_fp_test_data_class(vd, 0, &cc); 924 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 0) 925 // CHECK-ASM: vftcidb 926 vbl = vec_fp_test_data_class(vd, 4095, &cc); 927 // CHECK: call { <2 x i64>, i32 } @llvm.s390.vftcidb(<2 x double> %{{.*}}, i32 4095) 928 // CHECK-ASM: vftcidb 929 } 930