1 // REQUIRES: powerpc-registered-target 2 // RUN: %clang_cc1 -no-opaque-pointers -target-feature +altivec -target-feature +power9-vector \ 3 // RUN: -triple powerpc64-unknown-unknown -emit-llvm %s \ 4 // RUN: -flax-vector-conversions=integer \ 5 // RUN: -o - | FileCheck %s -check-prefix=CHECK-BE 6 7 // RUN: %clang_cc1 -no-opaque-pointers -target-feature +altivec -target-feature +power9-vector \ 8 // RUN: -triple powerpc64le-unknown-unknown -emit-llvm %s \ 9 // RUN: -flax-vector-conversions=integer \ 10 // RUN: -o - | FileCheck %s 11 12 // FIXME: This last test is intended to fail if the default is changed to 13 // -flax-vector-conversions=none and <altivec.h> isn't fixed first. 14 // RUN: %clang_cc1 -no-opaque-pointers -target-feature +altivec -target-feature +power9-vector \ 15 // RUN: -triple powerpc64-unknown-unknown -emit-llvm %s \ 16 // RUN: -o - | FileCheck %s -check-prefix=CHECK-BE 17 18 #include <altivec.h> 19 20 vector signed char vsca, vscb; 21 vector unsigned char vuca, vucb; 22 vector bool char vbca, vbcb; 23 vector signed short vssa, vssb; 24 vector unsigned short vusa, vusb; 25 vector bool short vbsa, vbsb; 26 vector signed int vsia, vsib; 27 vector unsigned int vuia, vuib; 28 vector bool int vbia, vbib; 29 vector signed long long vsla, vslb; 30 vector unsigned long long vula, vulb; 31 vector bool long long vbla, vblb; 32 vector float vfa, vfb; 33 vector double vda, vdb; 34 vector unsigned __int128 vui128a, vui128b; 35 vector signed __int128 vsi128a, vsi128b; 36 37 float f[4] = { 23.4f, 56.7f, 89.0f, 12.3f }; 38 double d[2] = { 23.4, 56.7 }; 39 signed char sc[16] = { -8, 9, -10, 11, -12, 13, -14, 15, 40 -0, 1, -2, 3, -4, 5, -6, 7 }; 41 unsigned char uc[16] = { 8, 9, 10, 11, 12, 13, 14, 15, 42 0, 1, 2, 3, 4, 5, 6, 7 }; 43 signed short ss[8] = { -1, 2, -3, 4, -5, 6, -7, 8 }; 44 unsigned short us[8] = { 0, 1, 2, 3, 4, 5, 6, 7 }; 45 signed int si[4] = { -1, 2, -3, 4 }; 46 unsigned int ui[4] = { 0, 1, 2, 3 }; 47 signed long sl[2] = { -1L, 2L }; 48 unsigned long ul[2] = { 1L, 2L }; 49 signed long long sll[2] = { 1LL, 1LL }; 50 unsigned long long ull[2] = { -1LL, 1LL }; 51 signed __int128 sint128[1] = { -1 }; 52 unsigned __int128 uint128[1] = { 1 }; 53 54 unsigned test1(void) { 55 // CHECK-BE: @llvm.ppc.altivec.vcmpequb(<16 x i8> 56 // CHECK-BE: @llvm.ctlz.v2i64(<2 x i64> 57 // CHECK-BE: extractelement <2 x i64> 58 // CHECK-BE: icmp eq i64 {{.*}}, 64 59 // CHECK-BE: extractelement <2 x i64> 60 // CHECK-BE: add i64 {{.*}}, 64 61 // CHECK-BE: lshr i64 {{.*}}, 3 62 // CHECK: @llvm.ppc.altivec.vcmpequb(<16 x i8> 63 // CHECK: @llvm.cttz.v2i64(<2 x i64> 64 // CHECK: extractelement <2 x i64> 65 // CHECK: icmp eq i64 {{.*}}, 64 66 // CHECK: extractelement <2 x i64> 67 // CHECK: add i64 {{.*}}, 64 68 // CHECK: lshr i64 {{.*}}, 3 69 return vec_first_match_index (vsca, vscb); 70 } 71 unsigned test2(void) { 72 // CHECK-BE: @llvm.ppc.altivec.vcmpequb(<16 x i8> 73 // CHECK-BE: @llvm.ctlz.v2i64(<2 x i64> 74 // CHECK-BE: extractelement <2 x i64> 75 // CHECK-BE: icmp eq i64 {{.*}}, 64 76 // CHECK-BE: extractelement <2 x i64> 77 // CHECK-BE: add i64 {{.*}}, 64 78 // CHECK-BE: lshr i64 {{.*}}, 3 79 // CHECK: @llvm.ppc.altivec.vcmpequb(<16 x i8> 80 // CHECK: @llvm.cttz.v2i64(<2 x i64> 81 // CHECK: extractelement <2 x i64> 82 // CHECK: icmp eq i64 {{.*}}, 64 83 // CHECK: extractelement <2 x i64> 84 // CHECK: add i64 {{.*}}, 64 85 // CHECK: lshr i64 {{.*}}, 3 86 return vec_first_match_index (vuca, vucb); 87 } 88 unsigned test3(void) { 89 // CHECK-BE: @llvm.ppc.altivec.vcmpequw(<4 x i32> 90 // CHECK-BE: @llvm.ctlz.v2i64(<2 x i64> 91 // CHECK-BE: extractelement <2 x i64> 92 // CHECK-BE: icmp eq i64 {{.*}}, 64 93 // CHECK-BE: extractelement <2 x i64> 94 // CHECK-BE: add i64 {{.*}}, 64 95 // CHECK-BE: lshr i64 {{.*}}, 5 96 // CHECK: @llvm.ppc.altivec.vcmpequw(<4 x i32> 97 // CHECK: @llvm.cttz.v2i64(<2 x i64> 98 // CHECK: extractelement <2 x i64> 99 // CHECK: icmp eq i64 {{.*}}, 64 100 // CHECK: extractelement <2 x i64> 101 // CHECK: add i64 {{.*}}, 64 102 // CHECK: lshr i64 {{.*}}, 5 103 return vec_first_match_index (vsia, vsib); 104 } 105 unsigned test4(void) { 106 // CHECK-BE: @llvm.ppc.altivec.vcmpequw(<4 x i32> 107 // CHECK-BE: @llvm.ctlz.v2i64(<2 x i64> 108 // CHECK-BE: extractelement <2 x i64> 109 // CHECK-BE: icmp eq i64 {{.*}}, 64 110 // CHECK-BE: extractelement <2 x i64> 111 // CHECK-BE: add i64 {{.*}}, 64 112 // CHECK-BE: lshr i64 {{.*}}, 5 113 // CHECK: @llvm.ppc.altivec.vcmpequw(<4 x i32> 114 // CHECK: @llvm.cttz.v2i64(<2 x i64> 115 // CHECK: extractelement <2 x i64> 116 // CHECK: icmp eq i64 {{.*}}, 64 117 // CHECK: extractelement <2 x i64> 118 // CHECK: add i64 {{.*}}, 64 119 // CHECK: lshr i64 {{.*}}, 5 120 return vec_first_match_index (vuia, vuib); 121 } 122 unsigned test5(void) { 123 // CHECK-BE: @llvm.ppc.altivec.vcmpequh(<8 x i16> 124 // CHECK-BE: @llvm.ctlz.v2i64(<2 x i64> 125 // CHECK-BE: extractelement <2 x i64> 126 // CHECK-BE: icmp eq i64 {{.*}}, 64 127 // CHECK-BE: extractelement <2 x i64> 128 // CHECK-BE: add i64 {{.*}}, 64 129 // CHECK-BE: lshr i64 {{.*}}, 4 130 // CHECK: @llvm.ppc.altivec.vcmpequh(<8 x i16> 131 // CHECK: @llvm.cttz.v2i64(<2 x i64> 132 // CHECK: extractelement <2 x i64> 133 // CHECK: icmp eq i64 {{.*}}, 64 134 // CHECK: extractelement <2 x i64> 135 // CHECK: add i64 {{.*}}, 64 136 // CHECK: lshr i64 {{.*}}, 4 137 return vec_first_match_index (vssa, vssb); 138 } 139 unsigned test6(void) { 140 // CHECK-BE: @llvm.ppc.altivec.vcmpequh(<8 x i16> 141 // CHECK-BE: @llvm.ctlz.v2i64(<2 x i64> 142 // CHECK-BE: extractelement <2 x i64> 143 // CHECK-BE: icmp eq i64 {{.*}}, 64 144 // CHECK-BE: extractelement <2 x i64> 145 // CHECK-BE: add i64 {{.*}}, 64 146 // CHECK-BE: lshr i64 {{.*}}, 4 147 // CHECK: @llvm.ppc.altivec.vcmpequh(<8 x i16> 148 // CHECK: @llvm.cttz.v2i64(<2 x i64> 149 // CHECK: extractelement <2 x i64> 150 // CHECK: icmp eq i64 {{.*}}, 64 151 // CHECK: extractelement <2 x i64> 152 // CHECK: add i64 {{.*}}, 64 153 // CHECK: lshr i64 {{.*}}, 4 154 return vec_first_match_index (vusa, vusb); 155 } 156 unsigned test7(void) { 157 // CHECK-BE: @llvm.ppc.altivec.vcmpequb(<16 x i8> 158 // CHECK-BE: @llvm.ppc.altivec.vcmpequb(<16 x i8> 159 // CHECK-BE: or <16 x i8> 160 // CHECK-BE: @llvm.ppc.altivec.vcmpequb(<16 x i8> 161 // CHECK-BE: or <16 x i8> 162 // CHECK-BE: @llvm.ctlz.v2i64(<2 x i64> 163 // CHECK-BE: extractelement <2 x i64> 164 // CHECK-BE: icmp eq i64 {{.*}}, 64 165 // CHECK-BE: extractelement <2 x i64> 166 // CHECK-BE: add i64 {{.*}}, 64 167 // CHECK-BE: lshr i64 {{.*}}, 3 168 // CHECK: @llvm.ppc.altivec.vcmpequb(<16 x i8> 169 // CHECK: @llvm.ppc.altivec.vcmpequb(<16 x i8> 170 // CHECK: or <16 x i8> 171 // CHECK: @llvm.ppc.altivec.vcmpequb(<16 x i8> 172 // CHECK: or <16 x i8> 173 // CHECK: @llvm.cttz.v2i64(<2 x i64> 174 // CHECK: extractelement <2 x i64> 175 // CHECK: icmp eq i64 {{.*}}, 64 176 // CHECK: extractelement <2 x i64> 177 // CHECK: add i64 {{.*}}, 64 178 // CHECK: lshr i64 {{.*}}, 3 179 return vec_first_match_or_eos_index (vsca, vscb); 180 } 181 unsigned test8(void) { 182 // CHECK-BE: @llvm.ppc.altivec.vcmpequb(<16 x i8> 183 // CHECK-BE: @llvm.ppc.altivec.vcmpequb(<16 x i8> 184 // CHECK-BE: or <16 x i8> 185 // CHECK-BE: @llvm.ppc.altivec.vcmpequb(<16 x i8> 186 // CHECK-BE: or <16 x i8> 187 // CHECK-BE: @llvm.ctlz.v2i64(<2 x i64> 188 // CHECK-BE: extractelement <2 x i64> 189 // CHECK-BE: icmp eq i64 {{.*}}, 64 190 // CHECK-BE: extractelement <2 x i64> 191 // CHECK-BE: add i64 {{.*}}, 64 192 // CHECK-BE: lshr i64 {{.*}}, 3 193 // CHECK: @llvm.ppc.altivec.vcmpequb(<16 x i8> 194 // CHECK: @llvm.ppc.altivec.vcmpequb(<16 x i8> 195 // CHECK: or <16 x i8> 196 // CHECK: @llvm.ppc.altivec.vcmpequb(<16 x i8> 197 // CHECK: or <16 x i8> 198 // CHECK: @llvm.cttz.v2i64(<2 x i64> 199 // CHECK: extractelement <2 x i64> 200 // CHECK: icmp eq i64 {{.*}}, 64 201 // CHECK: extractelement <2 x i64> 202 // CHECK: add i64 {{.*}}, 64 203 // CHECK: lshr i64 {{.*}}, 3 204 return vec_first_match_or_eos_index (vuca, vucb); 205 } 206 unsigned test9(void) { 207 // CHECK-BE: @llvm.ppc.altivec.vcmpequw(<4 x i32> 208 // CHECK-BE: @llvm.ppc.altivec.vcmpequw(<4 x i32> 209 // CHECK-BE: or <4 x i32> 210 // CHECK-BE: @llvm.ppc.altivec.vcmpequw(<4 x i32> 211 // CHECK-BE: or <4 x i32> 212 // CHECK-BE: @llvm.ctlz.v2i64(<2 x i64> 213 // CHECK-BE: extractelement <2 x i64> 214 // CHECK-BE: icmp eq i64 {{.*}}, 64 215 // CHECK-BE: extractelement <2 x i64> 216 // CHECK-BE: add i64 {{.*}}, 64 217 // CHECK-BE: lshr i64 {{.*}}, 5 218 // CHECK: @llvm.ppc.altivec.vcmpequw(<4 x i32> 219 // CHECK: @llvm.ppc.altivec.vcmpequw(<4 x i32> 220 // CHECK: or <4 x i32> 221 // CHECK: @llvm.ppc.altivec.vcmpequw(<4 x i32> 222 // CHECK: or <4 x i32> 223 // CHECK: @llvm.cttz.v2i64(<2 x i64> 224 // CHECK: extractelement <2 x i64> 225 // CHECK: icmp eq i64 {{.*}}, 64 226 // CHECK: extractelement <2 x i64> 227 // CHECK: add i64 {{.*}}, 64 228 // CHECK: lshr i64 {{.*}}, 5 229 return vec_first_match_or_eos_index (vsia, vsib); 230 } 231 unsigned test10(void) { 232 // CHECK-BE: @llvm.ppc.altivec.vcmpequw(<4 x i32> 233 // CHECK-BE: @llvm.ppc.altivec.vcmpequw(<4 x i32> 234 // CHECK-BE: or <4 x i32> 235 // CHECK-BE: @llvm.ppc.altivec.vcmpequw(<4 x i32> 236 // CHECK-BE: or <4 x i32> 237 // CHECK-BE: @llvm.ctlz.v2i64(<2 x i64> 238 // CHECK-BE: extractelement <2 x i64> 239 // CHECK-BE: icmp eq i64 {{.*}}, 64 240 // CHECK-BE: extractelement <2 x i64> 241 // CHECK-BE: add i64 {{.*}}, 64 242 // CHECK-BE: lshr i64 {{.*}}, 5 243 // CHECK: @llvm.ppc.altivec.vcmpequw(<4 x i32> 244 // CHECK: @llvm.ppc.altivec.vcmpequw(<4 x i32> 245 // CHECK: or <4 x i32> 246 // CHECK: @llvm.ppc.altivec.vcmpequw(<4 x i32> 247 // CHECK: or <4 x i32> 248 // CHECK: @llvm.cttz.v2i64(<2 x i64> 249 // CHECK: extractelement <2 x i64> 250 // CHECK: icmp eq i64 {{.*}}, 64 251 // CHECK: extractelement <2 x i64> 252 // CHECK: add i64 {{.*}}, 64 253 // CHECK: lshr i64 {{.*}}, 5 254 return vec_first_match_or_eos_index (vuia, vuib); 255 } 256 unsigned test11(void) { 257 // CHECK-BE: @llvm.ppc.altivec.vcmpequh(<8 x i16> 258 // CHECK-BE: @llvm.ppc.altivec.vcmpequh(<8 x i16> 259 // CHECK-BE: or <8 x i16> 260 // CHECK-BE: @llvm.ppc.altivec.vcmpequh(<8 x i16> 261 // CHECK-BE: or <8 x i16> 262 // CHECK-BE: @llvm.ctlz.v2i64(<2 x i64> 263 // CHECK-BE: extractelement <2 x i64> 264 // CHECK-BE: icmp eq i64 {{.*}}, 64 265 // CHECK-BE: extractelement <2 x i64> 266 // CHECK-BE: add i64 {{.*}}, 64 267 // CHECK-BE: lshr i64 {{.*}}, 4 268 // CHECK: @llvm.ppc.altivec.vcmpequh(<8 x i16> 269 // CHECK: @llvm.ppc.altivec.vcmpequh(<8 x i16> 270 // CHECK: or <8 x i16> 271 // CHECK: @llvm.ppc.altivec.vcmpequh(<8 x i16> 272 // CHECK: or <8 x i16> 273 // CHECK: @llvm.cttz.v2i64(<2 x i64> 274 // CHECK: extractelement <2 x i64> 275 // CHECK: icmp eq i64 {{.*}}, 64 276 // CHECK: extractelement <2 x i64> 277 // CHECK: add i64 {{.*}}, 64 278 // CHECK: lshr i64 {{.*}}, 4 279 return vec_first_match_or_eos_index (vssa, vssb); 280 } 281 unsigned test12(void) { 282 // CHECK-BE: @llvm.ppc.altivec.vcmpequh(<8 x i16> 283 // CHECK-BE: @llvm.ppc.altivec.vcmpequh(<8 x i16> 284 // CHECK-BE: or <8 x i16> 285 // CHECK-BE: @llvm.ppc.altivec.vcmpequh(<8 x i16> 286 // CHECK-BE: or <8 x i16> 287 // CHECK-BE: @llvm.ctlz.v2i64(<2 x i64> 288 // CHECK-BE: extractelement <2 x i64> 289 // CHECK-BE: icmp eq i64 {{.*}}, 64 290 // CHECK-BE: extractelement <2 x i64> 291 // CHECK-BE: add i64 {{.*}}, 64 292 // CHECK-BE: lshr i64 {{.*}}, 4 293 // CHECK: @llvm.ppc.altivec.vcmpequh(<8 x i16> 294 // CHECK: @llvm.ppc.altivec.vcmpequh(<8 x i16> 295 // CHECK: or <8 x i16> 296 // CHECK: @llvm.ppc.altivec.vcmpequh(<8 x i16> 297 // CHECK: or <8 x i16> 298 // CHECK: @llvm.cttz.v2i64(<2 x i64> 299 // CHECK: extractelement <2 x i64> 300 // CHECK: icmp eq i64 {{.*}}, 64 301 // CHECK: extractelement <2 x i64> 302 // CHECK: add i64 {{.*}}, 64 303 // CHECK: lshr i64 {{.*}}, 4 304 return vec_first_match_or_eos_index (vusa, vusb); 305 } 306 unsigned test13(void) { 307 // CHECK-BE: @llvm.ppc.altivec.vcmpneb(<16 x i8> 308 // CHECK-BE: @llvm.ctlz.v2i64(<2 x i64> 309 // CHECK-BE: extractelement <2 x i64> 310 // CHECK-BE: icmp eq i64 {{.*}}, 64 311 // CHECK-BE: extractelement <2 x i64> 312 // CHECK-BE: add i64 {{.*}}, 64 313 // CHECK-BE: lshr i64 {{.*}}, 3 314 // CHECK: @llvm.ppc.altivec.vcmpneb(<16 x i8> 315 // CHECK: @llvm.cttz.v2i64(<2 x i64> 316 // CHECK: extractelement <2 x i64> 317 // CHECK: icmp eq i64 {{.*}}, 64 318 // CHECK: extractelement <2 x i64> 319 // CHECK: add i64 {{.*}}, 64 320 // CHECK: lshr i64 {{.*}}, 3 321 return vec_first_mismatch_index (vsca, vscb); 322 } 323 unsigned test14(void) { 324 // CHECK-BE: @llvm.ppc.altivec.vcmpneb(<16 x i8> 325 // CHECK-BE: @llvm.ctlz.v2i64(<2 x i64> 326 // CHECK-BE: extractelement <2 x i64> 327 // CHECK-BE: icmp eq i64 {{.*}}, 64 328 // CHECK-BE: extractelement <2 x i64> 329 // CHECK-BE: add i64 {{.*}}, 64 330 // CHECK-BE: lshr i64 {{.*}}, 3 331 // CHECK: @llvm.ppc.altivec.vcmpneb(<16 x i8> 332 // CHECK: @llvm.cttz.v2i64(<2 x i64> 333 // CHECK: extractelement <2 x i64> 334 // CHECK: icmp eq i64 {{.*}}, 64 335 // CHECK: extractelement <2 x i64> 336 // CHECK: add i64 {{.*}}, 64 337 // CHECK: lshr i64 {{.*}}, 3 338 return vec_first_mismatch_index (vuca, vucb); 339 } 340 unsigned test15(void) { 341 // CHECK-BE: @llvm.ppc.altivec.vcmpnew(<4 x i32> 342 // CHECK-BE: @llvm.ctlz.v2i64(<2 x i64> 343 // CHECK-BE: extractelement <2 x i64> 344 // CHECK-BE: icmp eq i64 {{.*}}, 64 345 // CHECK-BE: extractelement <2 x i64> 346 // CHECK-BE: add i64 {{.*}}, 64 347 // CHECK-BE: lshr i64 {{.*}}, 5 348 // CHECK: @llvm.ppc.altivec.vcmpnew(<4 x i32> 349 // CHECK: @llvm.cttz.v2i64(<2 x i64> 350 // CHECK: extractelement <2 x i64> 351 // CHECK: icmp eq i64 {{.*}}, 64 352 // CHECK: extractelement <2 x i64> 353 // CHECK: add i64 {{.*}}, 64 354 // CHECK: lshr i64 {{.*}}, 5 355 return vec_first_mismatch_index (vsia, vsib); 356 } 357 unsigned test16(void) { 358 // CHECK-BE: @llvm.ppc.altivec.vcmpnew(<4 x i32> 359 // CHECK-BE: @llvm.ctlz.v2i64(<2 x i64> 360 // CHECK-BE: extractelement <2 x i64> 361 // CHECK-BE: icmp eq i64 {{.*}}, 64 362 // CHECK-BE: extractelement <2 x i64> 363 // CHECK-BE: add i64 {{.*}}, 64 364 // CHECK-BE: lshr i64 {{.*}}, 5 365 // CHECK: @llvm.ppc.altivec.vcmpnew(<4 x i32> 366 // CHECK: @llvm.cttz.v2i64(<2 x i64> 367 // CHECK: extractelement <2 x i64> 368 // CHECK: icmp eq i64 {{.*}}, 64 369 // CHECK: extractelement <2 x i64> 370 // CHECK: add i64 {{.*}}, 64 371 // CHECK: lshr i64 {{.*}}, 5 372 return vec_first_mismatch_index (vuia, vuib); 373 } 374 unsigned test17(void) { 375 // CHECK-BE: @llvm.ppc.altivec.vcmpneh(<8 x i16> 376 // CHECK-BE: @llvm.ctlz.v2i64(<2 x i64> 377 // CHECK-BE: extractelement <2 x i64> 378 // CHECK-BE: icmp eq i64 {{.*}}, 64 379 // CHECK-BE: extractelement <2 x i64> 380 // CHECK-BE: add i64 {{.*}}, 64 381 // CHECK-BE: lshr i64 {{.*}}, 4 382 // CHECK: @llvm.ppc.altivec.vcmpneh(<8 x i16> 383 // CHECK: @llvm.cttz.v2i64(<2 x i64> 384 // CHECK: extractelement <2 x i64> 385 // CHECK: icmp eq i64 {{.*}}, 64 386 // CHECK: extractelement <2 x i64> 387 // CHECK: add i64 {{.*}}, 64 388 // CHECK: lshr i64 {{.*}}, 4 389 return vec_first_mismatch_index (vssa, vssb); 390 } 391 unsigned test18(void) { 392 // CHECK-BE: @llvm.ppc.altivec.vcmpneh(<8 x i16> 393 // CHECK-BE: @llvm.ctlz.v2i64(<2 x i64> 394 // CHECK-BE: extractelement <2 x i64> 395 // CHECK-BE: icmp eq i64 {{.*}}, 64 396 // CHECK-BE: extractelement <2 x i64> 397 // CHECK-BE: add i64 {{.*}}, 64 398 // CHECK-BE: lshr i64 {{.*}}, 4 399 // CHECK: @llvm.ppc.altivec.vcmpneh(<8 x i16> 400 // CHECK: @llvm.cttz.v2i64(<2 x i64> 401 // CHECK: extractelement <2 x i64> 402 // CHECK: icmp eq i64 {{.*}}, 64 403 // CHECK: extractelement <2 x i64> 404 // CHECK: add i64 {{.*}}, 64 405 // CHECK: lshr i64 {{.*}}, 4 406 return vec_first_mismatch_index (vusa, vusb); 407 } 408 unsigned test19(void) { 409 // CHECK-BE: @llvm.ppc.altivec.vcmpnezb(<16 x i8> 410 // CHECK-BE: @llvm.ctlz.v2i64(<2 x i64> 411 // CHECK-BE: extractelement <2 x i64> 412 // CHECK-BE: icmp eq i64 {{.*}}, 64 413 // CHECK-BE: extractelement <2 x i64> 414 // CHECK-BE: add i64 {{.*}}, 64 415 // CHECK-BE: lshr i64 {{.*}}, 3 416 // CHECK: @llvm.ppc.altivec.vcmpnezb(<16 x i8> 417 // CHECK: @llvm.cttz.v2i64(<2 x i64> 418 // CHECK: extractelement <2 x i64> 419 // CHECK: icmp eq i64 {{.*}}, 64 420 // CHECK: extractelement <2 x i64> 421 // CHECK: add i64 {{.*}}, 64 422 // CHECK: lshr i64 {{.*}}, 3 423 return vec_first_mismatch_or_eos_index (vsca, vscb); 424 } 425 unsigned test20(void) { 426 // CHECK-BE: @llvm.ppc.altivec.vcmpnezb(<16 x i8> 427 // CHECK-BE: @llvm.ctlz.v2i64(<2 x i64> 428 // CHECK-BE: extractelement <2 x i64> 429 // CHECK-BE: icmp eq i64 {{.*}}, 64 430 // CHECK-BE: extractelement <2 x i64> 431 // CHECK-BE: add i64 {{.*}}, 64 432 // CHECK-BE: lshr i64 {{.*}}, 3 433 // CHECK: @llvm.ppc.altivec.vcmpnezb(<16 x i8> 434 // CHECK: @llvm.cttz.v2i64(<2 x i64> 435 // CHECK: extractelement <2 x i64> 436 // CHECK: icmp eq i64 {{.*}}, 64 437 // CHECK: extractelement <2 x i64> 438 // CHECK: add i64 {{.*}}, 64 439 // CHECK: lshr i64 {{.*}}, 3 440 return vec_first_mismatch_or_eos_index (vuca, vucb); 441 } 442 unsigned test21(void) { 443 // CHECK-BE: @llvm.ppc.altivec.vcmpnezw(<4 x i32> 444 // CHECK-BE: @llvm.ctlz.v2i64(<2 x i64> 445 // CHECK-BE: extractelement <2 x i64> 446 // CHECK-BE: icmp eq i64 {{.*}}, 64 447 // CHECK-BE: extractelement <2 x i64> 448 // CHECK-BE: add i64 {{.*}}, 64 449 // CHECK-BE: lshr i64 {{.*}}, 5 450 // CHECK: @llvm.ppc.altivec.vcmpnezw(<4 x i32> 451 // CHECK: @llvm.cttz.v2i64(<2 x i64> 452 // CHECK: extractelement <2 x i64> 453 // CHECK: icmp eq i64 {{.*}}, 64 454 // CHECK: extractelement <2 x i64> 455 // CHECK: add i64 {{.*}}, 64 456 // CHECK: lshr i64 {{.*}}, 5 457 return vec_first_mismatch_or_eos_index (vsia, vsib); 458 } 459 unsigned test22(void) { 460 // CHECK-BE: @llvm.ppc.altivec.vcmpnezw(<4 x i32> 461 // CHECK-BE: @llvm.ctlz.v2i64(<2 x i64> 462 // CHECK-BE: extractelement <2 x i64> 463 // CHECK-BE: icmp eq i64 {{.*}}, 64 464 // CHECK-BE: extractelement <2 x i64> 465 // CHECK-BE: add i64 {{.*}}, 64 466 // CHECK-BE: lshr i64 {{.*}}, 5 467 // CHECK: @llvm.ppc.altivec.vcmpnezw(<4 x i32> 468 // CHECK: @llvm.cttz.v2i64(<2 x i64> 469 // CHECK: extractelement <2 x i64> 470 // CHECK: icmp eq i64 {{.*}}, 64 471 // CHECK: extractelement <2 x i64> 472 // CHECK: add i64 {{.*}}, 64 473 // CHECK: lshr i64 {{.*}}, 5 474 return vec_first_mismatch_or_eos_index (vuia, vuib); 475 } 476 unsigned test23(void) { 477 // CHECK-BE: @llvm.ppc.altivec.vcmpnezh(<8 x i16> 478 // CHECK-BE: @llvm.ctlz.v2i64(<2 x i64> 479 // CHECK-BE: extractelement <2 x i64> 480 // CHECK-BE: icmp eq i64 {{.*}}, 64 481 // CHECK-BE: extractelement <2 x i64> 482 // CHECK-BE: add i64 {{.*}}, 64 483 // CHECK-BE: lshr i64 {{.*}}, 4 484 // CHECK: @llvm.ppc.altivec.vcmpnezh(<8 x i16> 485 // CHECK: @llvm.cttz.v2i64(<2 x i64> 486 // CHECK: extractelement <2 x i64> 487 // CHECK: icmp eq i64 {{.*}}, 64 488 // CHECK: extractelement <2 x i64> 489 // CHECK: add i64 {{.*}}, 64 490 // CHECK: lshr i64 {{.*}}, 4 491 return vec_first_mismatch_or_eos_index (vssa, vssb); 492 } 493 unsigned test24(void) { 494 // CHECK-BE: @llvm.ppc.altivec.vcmpnezh(<8 x i16> 495 // CHECK-BE: @llvm.ctlz.v2i64(<2 x i64> 496 // CHECK-BE: extractelement <2 x i64> 497 // CHECK-BE: icmp eq i64 {{.*}}, 64 498 // CHECK-BE: extractelement <2 x i64> 499 // CHECK-BE: add i64 {{.*}}, 64 500 // CHECK-BE: lshr i64 {{.*}}, 4 501 // CHECK: @llvm.ppc.altivec.vcmpnezh(<8 x i16> 502 // CHECK: @llvm.cttz.v2i64(<2 x i64> 503 // CHECK: extractelement <2 x i64> 504 // CHECK: icmp eq i64 {{.*}}, 64 505 // CHECK: extractelement <2 x i64> 506 // CHECK: add i64 {{.*}}, 64 507 // CHECK: lshr i64 {{.*}}, 4 508 return vec_first_mismatch_or_eos_index (vusa, vusb); 509 } 510 vector bool char test25(void) { 511 // CHECK-BE: @llvm.ppc.altivec.vcmpneb(<16 x i8> 512 // CHECK-BE-NEXT: ret <16 x i8> 513 // CHECK: @llvm.ppc.altivec.vcmpneb(<16 x i8> 514 // CHECK-NEXT: ret <16 x i8> 515 return vec_cmpne (vbca, vbcb); 516 } 517 vector bool char test26(void) { 518 // CHECK-BE: @llvm.ppc.altivec.vcmpneb(<16 x i8> 519 // CHECK-BE-NEXT: ret <16 x i8> 520 // CHECK: @llvm.ppc.altivec.vcmpneb(<16 x i8> 521 // CHECK-NEXT: ret <16 x i8> 522 return vec_cmpne (vsca, vscb); 523 } 524 vector bool char test27(void) { 525 // CHECK-BE: @llvm.ppc.altivec.vcmpneb(<16 x i8> 526 // CHECK-BE-NEXT: ret <16 x i8> 527 // CHECK: @llvm.ppc.altivec.vcmpneb(<16 x i8> 528 // CHECK-NEXT: ret <16 x i8> 529 return vec_cmpne (vuca, vucb); 530 } 531 vector bool int test28(void) { 532 // CHECK-BE: @llvm.ppc.altivec.vcmpnew(<4 x i32> 533 // CHECK-BE-NEXT: ret <4 x i32> 534 // CHECK: @llvm.ppc.altivec.vcmpnew(<4 x i32> 535 // CHECK-NEXT: ret <4 x i32> 536 return vec_cmpne (vbia, vbib); 537 } 538 vector bool int test29(void) { 539 // CHECK-BE: @llvm.ppc.altivec.vcmpnew(<4 x i32> 540 // CHECK-BE-NEXT: ret <4 x i32> 541 // CHECK: @llvm.ppc.altivec.vcmpnew(<4 x i32> 542 // CHECK-NEXT: ret <4 x i32> 543 return vec_cmpne (vsia, vsib); 544 } 545 vector bool int test30(void) { 546 // CHECK-BE: @llvm.ppc.altivec.vcmpnew(<4 x i32> 547 // CHECK-BE-NEXT: ret <4 x i32> 548 // CHECK: @llvm.ppc.altivec.vcmpnew(<4 x i32> 549 // CHECK-NEXT: ret <4 x i32> 550 return vec_cmpne (vuia, vuib); 551 } 552 vector bool long long test31(void) { 553 // CHECK-BE: @llvm.ppc.altivec.vcmpequd(<2 x i64> 554 // CHECK-BE: xor <2 x i64> 555 // CHECK-BE-NEXT: ret <2 x i64> 556 // CHECK: @llvm.ppc.altivec.vcmpequd(<2 x i64> 557 // CHECK: xor <2 x i64> 558 // CHECK-NEXT: ret <2 x i64> 559 return vec_cmpne (vbla, vblb); 560 } 561 vector bool long long test32(void) { 562 // CHECK-BE: @llvm.ppc.altivec.vcmpequd(<2 x i64> 563 // CHECK-BE: xor <2 x i64> 564 // CHECK-BE-NEXT: ret <2 x i64> 565 // CHECK: @llvm.ppc.altivec.vcmpequd(<2 x i64> 566 // CHECK: xor <2 x i64> 567 // CHECK-NEXT: ret <2 x i64> 568 return vec_cmpne (vsla, vslb); 569 } 570 vector bool long long test33(void) { 571 // CHECK-BE: @llvm.ppc.altivec.vcmpequd(<2 x i64> 572 // CHECK-BE: xor <2 x i64> 573 // CHECK-BE-NEXT: ret <2 x i64> 574 // CHECK: @llvm.ppc.altivec.vcmpequd(<2 x i64> 575 // CHECK: xor <2 x i64> 576 // CHECK-NEXT: ret <2 x i64> 577 return vec_cmpne (vula, vulb); 578 } 579 vector bool short test34(void) { 580 // CHECK-BE: @llvm.ppc.altivec.vcmpneh(<8 x i16> 581 // CHECK-BE-NEXT: ret <8 x i16> 582 // CHECK: @llvm.ppc.altivec.vcmpneh(<8 x i16> 583 // CHECK-NEXT: ret <8 x i16> 584 return vec_cmpne (vbsa, vbsb); 585 } 586 vector bool short test35(void) { 587 // CHECK-BE: @llvm.ppc.altivec.vcmpneh(<8 x i16> 588 // CHECK-BE-NEXT: ret <8 x i16> 589 // CHECK: @llvm.ppc.altivec.vcmpneh(<8 x i16> 590 // CHECK-NEXT: ret <8 x i16> 591 return vec_cmpne (vssa, vssb); 592 } 593 vector bool short test36(void) { 594 // CHECK-BE: @llvm.ppc.altivec.vcmpneh(<8 x i16> 595 // CHECK-BE-NEXT: ret <8 x i16> 596 // CHECK: @llvm.ppc.altivec.vcmpneh(<8 x i16> 597 // CHECK-NEXT: ret <8 x i16> 598 return vec_cmpne (vusa, vusb); 599 } 600 vector bool long long test37(void) { 601 // CHECK-BE: @llvm.ppc.altivec.vcmpequd(<2 x i64> 602 // CHECK-BE: xor <2 x i64> 603 // CHECK-BE-NEXT: ret <2 x i64> 604 // CHECK: @llvm.ppc.altivec.vcmpequd(<2 x i64> 605 // CHECK: xor <2 x i64> 606 // CHECK-NEXT: ret <2 x i64> 607 return vec_cmpne (vda, vdb); 608 } 609 vector bool int test38(void) { 610 // CHECK-BE: @llvm.ppc.altivec.vcmpnew(<4 x i32> 611 // CHECK-BE-NEXT: ret <4 x i32> 612 // CHECK: @llvm.ppc.altivec.vcmpnew(<4 x i32> 613 // CHECK-NEXT: ret <4 x i32> 614 return vec_cmpne (vfa, vfb); 615 } 616 vector signed char test39(void) { 617 // CHECK-BE: @llvm.cttz.v16i8(<16 x i8> 618 // CHECK-BE-NEXT: ret <16 x i8> 619 // CHECK: @llvm.cttz.v16i8(<16 x i8> 620 // CHECK-NEXT: ret <16 x i8> 621 return vec_cnttz (vsca); 622 } 623 vector unsigned char test40(void) { 624 // CHECK-BE: @llvm.cttz.v16i8(<16 x i8> 625 // CHECK-BE-NEXT: ret <16 x i8> 626 // CHECK: @llvm.cttz.v16i8(<16 x i8> 627 // CHECK-NEXT: ret <16 x i8> 628 return vec_cnttz (vuca); 629 } 630 vector signed int test41(void) { 631 // CHECK-BE: @llvm.cttz.v4i32(<4 x i32> 632 // CHECK-BE-NEXT: ret <4 x i32> 633 // CHECK: @llvm.cttz.v4i32(<4 x i32> 634 // CHECK-NEXT: ret <4 x i32> 635 return vec_cnttz (vsia); 636 } 637 vector unsigned int test42(void) { 638 // CHECK-BE: @llvm.cttz.v4i32(<4 x i32> 639 // CHECK-BE-NEXT: ret <4 x i32> 640 // CHECK: @llvm.cttz.v4i32(<4 x i32> 641 // CHECK-NEXT: ret <4 x i32> 642 return vec_cnttz (vuia); 643 } 644 vector signed long long test43(void) { 645 // CHECK-BE: @llvm.cttz.v2i64(<2 x i64> 646 // CHECK-BE-NEXT: ret <2 x i64> 647 // CHECK: @llvm.cttz.v2i64(<2 x i64> 648 // CHECK-NEXT: ret <2 x i64> 649 return vec_cnttz (vsla); 650 } 651 vector unsigned long long test44(void) { 652 // CHECK-BE: @llvm.cttz.v2i64(<2 x i64> 653 // CHECK-BE-NEXT: ret <2 x i64> 654 // CHECK: @llvm.cttz.v2i64(<2 x i64> 655 // CHECK-NEXT: ret <2 x i64> 656 return vec_cnttz (vula); 657 } 658 vector signed short test45(void) { 659 // CHECK-BE: @llvm.cttz.v8i16(<8 x i16> 660 // CHECK-BE-NEXT: ret <8 x i16> 661 // CHECK: @llvm.cttz.v8i16(<8 x i16> 662 // CHECK-NEXT: ret <8 x i16> 663 return vec_cnttz (vssa); 664 } 665 vector unsigned short test46(void) { 666 // CHECK-BE: @llvm.cttz.v8i16(<8 x i16> 667 // CHECK-BE-NEXT: ret <8 x i16> 668 // CHECK: @llvm.cttz.v8i16(<8 x i16> 669 // CHECK-NEXT: ret <8 x i16> 670 return vec_cnttz (vusa); 671 } 672 vector unsigned char test47(void) { 673 // CHECK-BE: @llvm.ctpop.v16i8(<16 x i8> 674 // CHECK-BE-NEXT: ret <16 x i8> 675 // CHECK: @llvm.ctpop.v16i8(<16 x i8> 676 // CHECK-NEXT: ret <16 x i8> 677 return vec_popcnt (vsca); 678 } 679 vector unsigned char test48(void) { 680 // CHECK-BE: @llvm.ctpop.v16i8(<16 x i8> 681 // CHECK-BE-NEXT: ret <16 x i8> 682 // CHECK: @llvm.ctpop.v16i8(<16 x i8> 683 // CHECK-NEXT: ret <16 x i8> 684 return vec_popcnt (vuca); 685 } 686 vector unsigned int test49(void) { 687 // CHECK-BE: @llvm.ctpop.v4i32(<4 x i32> 688 // CHECK-BE-NEXT: ret <4 x i32> 689 // CHECK: @llvm.ctpop.v4i32(<4 x i32> 690 // CHECK-NEXT: ret <4 x i32> 691 return vec_popcnt (vsia); 692 } 693 vector unsigned int test50(void) { 694 // CHECK-BE: @llvm.ctpop.v4i32(<4 x i32> 695 // CHECK-BE-NEXT: ret <4 x i32> 696 // CHECK: @llvm.ctpop.v4i32(<4 x i32> 697 // CHECK-NEXT: ret <4 x i32> 698 return vec_popcnt (vuia); 699 } 700 vector unsigned long long test51(void) { 701 // CHECK-BE: @llvm.ctpop.v2i64(<2 x i64> 702 // CHECK-BE-NEXT: ret <2 x i64> 703 // CHECK: @llvm.ctpop.v2i64(<2 x i64> 704 // CHECK-NEXT: ret <2 x i64> 705 return vec_popcnt (vsla); 706 } 707 vector unsigned long long test52(void) { 708 // CHECK-BE: @llvm.ctpop.v2i64(<2 x i64> 709 // CHECK-BE-NEXT: ret <2 x i64> 710 // CHECK: @llvm.ctpop.v2i64(<2 x i64> 711 // CHECK-NEXT: ret <2 x i64> 712 return vec_popcnt (vula); 713 } 714 vector unsigned short test53(void) { 715 // CHECK-BE: @llvm.ctpop.v8i16(<8 x i16> 716 // CHECK-BE-NEXT: ret <8 x i16> 717 // CHECK: @llvm.ctpop.v8i16(<8 x i16> 718 // CHECK-NEXT: ret <8 x i16> 719 return vec_popcnt (vssa); 720 } 721 vector unsigned short test54(void) { 722 // CHECK-BE: @llvm.ctpop.v8i16(<8 x i16> 723 // CHECK-BE-NEXT: ret <8 x i16> 724 // CHECK: @llvm.ctpop.v8i16(<8 x i16> 725 // CHECK-NEXT: ret <8 x i16> 726 return vec_popcnt (vusa); 727 } 728 vector double test55(void) { 729 // CHECK-BE: @llvm.ppc.vsx.xviexpdp(<2 x i64> %{{.+}}, <2 x i64> 730 // CHECK-BE-NEXT: ret <2 x double> 731 // CHECK: @llvm.ppc.vsx.xviexpdp(<2 x i64> %{{.+}}, <2 x i64> 732 // CHECK-NEXT: ret <2 x double> 733 return vec_insert_exp (vda,vulb); 734 } 735 vector double test56(void) { 736 // CHECK-BE: @llvm.ppc.vsx.xviexpdp(<2 x i64> %{{.+}}, <2 x i64> 737 // CHECK-BE-NEXT: ret <2 x double> 738 // CHECK: @llvm.ppc.vsx.xviexpdp(<2 x i64> %{{.+}}, <2 x i64> 739 // CHECK-NEXT: ret <2 x double> 740 return vec_insert_exp (vula, vulb); 741 } 742 vector float test57(void) { 743 // CHECK-BE: @llvm.ppc.vsx.xviexpsp(<4 x i32> %{{.+}}, <4 x i32> 744 // CHECK-BE-NEXT: ret <4 x float> 745 // CHECK: @llvm.ppc.vsx.xviexpsp(<4 x i32> %{{.+}}, <4 x i32> 746 // CHECK-NEXT: ret <4 x float> 747 return vec_insert_exp (vfa,vuib); 748 } 749 vector float test58(void) { 750 // CHECK-BE: @llvm.ppc.vsx.xviexpsp(<4 x i32> %{{.+}}, <4 x i32> 751 // CHECK-BE-NEXT: ret <4 x float> 752 // CHECK: @llvm.ppc.vsx.xviexpsp(<4 x i32> %{{.+}}, <4 x i32> 753 // CHECK-NEXT: ret <4 x float> 754 return vec_insert_exp (vuia,vuib); 755 } 756 signed int test59(void) { 757 // CHECK-BE: @llvm.ppc.altivec.vclzlsbb(<16 x i8> 758 // CHECK-BE-NEXT: ret i32 759 // CHECK-LE: @llvm.ppc.altivec.vctzlsbb(<16 x i8> 760 // CHECK-LE-NEXT: ret i32 761 return vec_cntlz_lsbb (vuca); 762 } 763 signed int test60(void) { 764 // CHECK-BE: @llvm.ppc.altivec.vclzlsbb(<16 x i8> 765 // CHECK-BE-NEXT: ret i32 766 // CHECK-LE: @llvm.ppc.altivec.vctzlsbb(<16 x i8> 767 // CHECK-LE-NEXT: ret i32 768 return vec_cntlz_lsbb (vsca); 769 } 770 signed int test61(void) { 771 // CHECK-BE: @llvm.ppc.altivec.vctzlsbb(<16 x i8> 772 // CHECK-BE-NEXT: ret i32 773 // CHECK-LE: @llvm.ppc.altivec.vclzlsbb(<16 x i8> 774 // CHECK-LE-NEXT: ret i32 775 return vec_cnttz_lsbb (vsca); 776 } 777 signed int test62(void) { 778 // CHECK-BE: @llvm.ppc.altivec.vctzlsbb(<16 x i8> 779 // CHECK-BE-NEXT: ret i32 780 // CHECK-LE: @llvm.ppc.altivec.vclzlsbb(<16 x i8> 781 // CHECK-LE-NEXT: ret i32 782 return vec_cnttz_lsbb (vuca); 783 } 784 vector unsigned int test63(void) { 785 // CHECK-BE: @llvm.ppc.altivec.vprtybw(<4 x i32> 786 // CHECK-BE-NEXT: ret <4 x i32> 787 // CHECK: @llvm.ppc.altivec.vprtybw(<4 x i32> 788 // CHECK-NEXT: ret <4 x i32> 789 return vec_parity_lsbb (vuia); 790 } 791 vector unsigned int test64(void) { 792 // CHECK-BE: @llvm.ppc.altivec.vprtybw(<4 x i32> 793 // CHECK-BE-NEXT: ret <4 x i32> 794 // CHECK: @llvm.ppc.altivec.vprtybw(<4 x i32> 795 // CHECK-NEXT: ret <4 x i32> 796 return vec_parity_lsbb (vsia); 797 } 798 vector unsigned long long test65(void) { 799 // CHECK-BE: @llvm.ppc.altivec.vprtybd(<2 x i64> 800 // CHECK-BE-NEXT: ret <2 x i64> 801 // CHECK: @llvm.ppc.altivec.vprtybd(<2 x i64> 802 // CHECK-NEXT: ret <2 x i64> 803 return vec_parity_lsbb (vula); 804 } 805 vector unsigned long long test66(void) { 806 // CHECK-BE: @llvm.ppc.altivec.vprtybd(<2 x i64> 807 // CHECK-BE-NEXT: ret <2 x i64> 808 // CHECK: @llvm.ppc.altivec.vprtybd(<2 x i64> 809 // CHECK-NEXT: ret <2 x i64> 810 return vec_parity_lsbb (vsla); 811 } 812 vector unsigned __int128 test67(void) { 813 // CHECK-BE: @llvm.ppc.altivec.vprtybq(<1 x i128> 814 // CHECK-BE-NEXT: ret <1 x i128> 815 // CHECK: @llvm.ppc.altivec.vprtybq(<1 x i128> 816 // CHECK-NEXT: ret <1 x i128> 817 return vec_parity_lsbb (vui128a); 818 } 819 vector unsigned __int128 test68(void) { 820 // CHECK-BE: @llvm.ppc.altivec.vprtybq(<1 x i128> 821 // CHECK-BE-NEXT: ret <1 x i128> 822 // CHECK: @llvm.ppc.altivec.vprtybq(<1 x i128> 823 // CHECK-NEXT: ret <1 x i128> 824 return vec_parity_lsbb (vsi128a); 825 } 826 vector unsigned char test69(void) { 827 // CHECK-BE: call <16 x i8> @llvm.ppc.altivec.vabsdub(<16 x i8> {{.+}}, <16 x i8> {{.+}}) 828 // CHECK: call <16 x i8> @llvm.ppc.altivec.vabsdub(<16 x i8> {{.+}}, <16 x i8> {{.+}}) 829 return vec_absd(vuca, vucb); 830 } 831 vector unsigned short test70(void) { 832 // CHECK-BE: call <8 x i16> @llvm.ppc.altivec.vabsduh(<8 x i16> {{.+}}, <8 x i16> {{.+}}) 833 // CHECK: call <8 x i16> @llvm.ppc.altivec.vabsduh(<8 x i16> {{.+}}, <8 x i16> {{.+}}) 834 return vec_absd(vusa, vusb); 835 } 836 vector unsigned int test71(void) { 837 // CHECK-BE: call <4 x i32> @llvm.ppc.altivec.vabsduw(<4 x i32> {{.+}}, <4 x i32> {{.+}}) 838 // CHECK: call <4 x i32> @llvm.ppc.altivec.vabsduw(<4 x i32> {{.+}}, <4 x i32> {{.+}}) 839 return vec_absd(vuia, vuib); 840 } 841 vector unsigned char test72(void) { 842 // CHECK-BE: @llvm.ppc.altivec.vslv(<16 x i8> 843 // CHECK-BE-NEXT: ret <16 x i8> 844 // CHECK: @llvm.ppc.altivec.vslv(<16 x i8> 845 // CHECK-NEXT: ret <16 x i8> 846 return vec_slv (vuca, vucb); 847 } 848 vector unsigned char test73(void) { 849 // CHECK-BE: @llvm.ppc.altivec.vsrv(<16 x i8> 850 // CHECK-BE-NEXT: ret <16 x i8> 851 // CHECK: @llvm.ppc.altivec.vsrv(<16 x i8> 852 // CHECK-NEXT: ret <16 x i8> 853 return vec_srv (vuca, vucb); 854 } 855 vector unsigned short test74(void) { 856 // CHECK-BE: @llvm.ppc.vsx.xvcvsphp(<4 x float> 857 // CHECK-BE: @llvm.ppc.vsx.xvcvsphp(<4 x float> 858 // CHECK-BE: @llvm.ppc.altivec.vperm 859 // CHECK: @llvm.ppc.vsx.xvcvsphp(<4 x float> 860 // CHECK: @llvm.ppc.vsx.xvcvsphp(<4 x float> 861 // CHECK: @llvm.ppc.altivec.vperm 862 return vec_pack_to_short_fp32(vfa, vfb); 863 } 864 vector unsigned int test75(void) { 865 // CHECK-BE: @llvm.ppc.altivec.vrlwmi(<4 x i32 866 // CHECK-BE-NEXT: ret <4 x i32> 867 // CHECK: @llvm.ppc.altivec.vrlwmi(<4 x i32 868 // CHECK-NEXT: ret <4 x i32> 869 return vec_rlmi(vuia, vuia, vuia); 870 } 871 vector unsigned long long test76(void) { 872 // CHECK-BE: @llvm.ppc.altivec.vrldmi(<2 x i64 873 // CHECK-BE-NEXT: ret <2 x i64> 874 // CHECK: @llvm.ppc.altivec.vrldmi(<2 x i64 875 // CHECK-NEXT: ret <2 x i64> 876 return vec_rlmi(vula, vula, vula); 877 } 878 vector unsigned int test77(void) { 879 // CHECK-BE: %[[RES1:.+]] = shl <4 x i32 880 // CHECK-BE: %[[RES2:.+]] = or <4 x i32> %[[RES1]] 881 // CHECK-BE: @llvm.ppc.altivec.vrlwnm(<4 x i32 882 // CHECK-BE: ret <4 x i32> 883 // CHECK: %[[RES1:.+]] = shl <4 x i32 884 // CHECK: %[[RES2:.+]] = or <4 x i32> %[[RES1]] 885 // CHECK: @llvm.ppc.altivec.vrlwnm(<4 x i32 886 // CHECK: ret <4 x i32> 887 return vec_rlnm(vuia, vuia, vuia); 888 } 889 vector unsigned long long test78(void) { 890 // CHECK-BE: %[[RES1:.+]] = shl <2 x i64 891 // CHECK-BE: %[[RES2:.+]] = or <2 x i64> %[[RES1]] 892 // CHECK-BE: @llvm.ppc.altivec.vrldnm(<2 x i64 893 // CHECK-BE-NEXT: ret <2 x i64> 894 // CHECK: %[[RES1:.+]] = shl <2 x i64 895 // CHECK: %[[RES2:.+]] = or <2 x i64> %[[RES1]] 896 // CHECK: @llvm.ppc.altivec.vrldnm(<2 x i64 897 // CHECK-NEXT: ret <2 x i64> 898 return vec_rlnm(vula, vula, vula); 899 } 900 vector double test79(void) { 901 // CHECK-BE: extractelement <4 x float> 902 // CHECK-BE: fpext float 903 // CHECK-BE: insertelement <2 x double> 904 // CHECK-BE: extractelement <4 x float> 905 // CHECK-BE: fpext float 906 // CHECK-BE: insertelement <2 x double> 907 // CHECK: extractelement <4 x float> 908 // CHECK: fpext float 909 // CHECK: insertelement <2 x double> 910 // CHECK: extractelement <4 x float> 911 // CHECK: fpext float 912 // CHECK: insertelement <2 x double> 913 return vec_unpackh(vfa); 914 } 915 vector double test80(void) { 916 // CHECK-BE: extractelement <4 x float> 917 // CHECK-BE: fpext float 918 // CHECK-BE: insertelement <2 x double> 919 // CHECK-BE: extractelement <4 x float> 920 // CHECK-BE: fpext float 921 // CHECK-BE: insertelement <2 x double> 922 // CHECK: extractelement <4 x float> 923 // CHECK: fpext float 924 // CHECK: insertelement <2 x double> 925 // CHECK: extractelement <4 x float> 926 // CHECK: fpext float 927 // CHECK: insertelement <2 x double> 928 return vec_unpackl(vfa); 929 } 930 vector float test81(void) { 931 // CHECK: extractelement <2 x double> 932 // CHECK: fptrunc double 933 // CHECK: insertelement <4 x float> 934 // CHECK: extractelement <2 x double> 935 // CHECK: fptrunc double 936 // CHECK: insertelement <4 x float> 937 // CHECK: extractelement <2 x double> 938 // CHECK: fptrunc double 939 // CHECK: insertelement <4 x float> 940 // CHECK: extractelement <2 x double> 941 // CHECK: fptrunc double 942 // CHECK: insertelement <4 x float> 943 // CHECK-LE: extractelement <2 x double> 944 // CHECK-LE: fptrunc double 945 // CHECK-LE: insertelement <4 x float> 946 // CHECK-LE: extractelement <2 x double> 947 // CHECK-LE: fptrunc double 948 // CHECK-LE: insertelement <4 x float> 949 // CHECK-LE: extractelement <2 x double> 950 // CHECK-LE: fptrunc double 951 // CHECK-LE: insertelement <4 x float> 952 // CHECK-LE: extractelement <2 x double> 953 // CHECK-LE: fptrunc double 954 // CHECK-LE: insertelement <4 x float> 955 return vec_pack(vda, vdb); 956 } 957 vector unsigned int test82(void) { 958 // CHECK-BE: @llvm.ppc.vsx.xvxexpsp(<4 x float> {{.+}}) 959 // CHECK-BE-NEXT: ret <4 x i32> 960 // CHECK: @llvm.ppc.vsx.xvxexpsp(<4 x float> {{.+}}) 961 // CHECK-NEXT: ret <4 x i32> 962 return vec_extract_exp(vfa); 963 } 964 vector unsigned long long test83(void) { 965 // CHECK-BE: @llvm.ppc.vsx.xvxexpdp(<2 x double> {{.+}}) 966 // CHECK-BE-NEXT: ret <2 x i64> 967 // CHECK: @llvm.ppc.vsx.xvxexpdp(<2 x double> {{.+}}) 968 // CHECK-NEXT: ret <2 x i64> 969 return vec_extract_exp(vda); 970 } 971 vector unsigned int test84(void) { 972 // CHECK-BE: @llvm.ppc.vsx.xvxsigsp(<4 x float> {{.+}}) 973 // CHECK-BE-NEXT: ret <4 x i32> 974 // CHECK: @llvm.ppc.vsx.xvxsigsp(<4 x float> {{.+}}) 975 // CHECK-NEXT: ret <4 x i32> 976 return vec_extract_sig(vfa); 977 } 978 vector unsigned long long test85(void) { 979 // CHECK-BE: @llvm.ppc.vsx.xvxsigdp(<2 x double> {{.+}}) 980 // CHECK-BE-NEXT: ret <2 x i64> 981 // CHECK: @llvm.ppc.vsx.xvxsigdp(<2 x double> {{.+}}) 982 // CHECK-NEXT: ret <2 x i64> 983 return vec_extract_sig(vda); 984 } 985 vector bool int test86(void) { 986 // CHECK-BE: @llvm.ppc.vsx.xvtstdcsp(<4 x float> {{.+}}, i32 127) 987 // CHECK-BE-NEXT: ret <4 x i32> 988 // CHECK: @llvm.ppc.vsx.xvtstdcsp(<4 x float> {{.+}}, i32 127) 989 // CHECK-NEXT: ret <4 x i32> 990 return vec_test_data_class(vfa, __VEC_CLASS_FP_NOT_NORMAL); 991 } 992 vector bool long long test87(void) { 993 // CHECK-BE: @llvm.ppc.vsx.xvtstdcdp(<2 x double> {{.+}}, i32 127) 994 // CHECK-BE-NEXT: ret <2 x i64> 995 // CHECK: @llvm.ppc.vsx.xvtstdcdp(<2 x double> {{.+}}, i32 127) 996 // CHECK-NEXT: ret <2 x i64> 997 return vec_test_data_class(vda, __VEC_CLASS_FP_NOT_NORMAL); 998 } 999 vector unsigned char test88(void) { 1000 // CHECK-BE: @llvm.ppc.vsx.lxvl(i8* %{{.+}}, i64 1001 // CHECK-BE-NEXT-NEXT: ret <16 x i8> 1002 // CHECK: @llvm.ppc.vsx.lxvl(i8* %{{.+}}, i64 1003 // CHECK-NEXT-NEXT: ret <16 x i8> 1004 return vec_xl_len(uc,0); 1005 } 1006 vector signed char test89(void) { 1007 // CHECK-BE: @llvm.ppc.vsx.lxvl(i8* %{{.+}}, i64 1008 // CHECK-BE-NEXT-NEXT: ret <16 x i8> 1009 // CHECK: @llvm.ppc.vsx.lxvl(i8* %{{.+}}, i64 1010 // CHECK-NEXT-NEXT: ret <16 x i8> 1011 return vec_xl_len(sc,0); 1012 } 1013 vector unsigned short test90(void) { 1014 // CHECK-BE: @llvm.ppc.vsx.lxvl(i8* %{{.+}}, i64 1015 // CHECK-BE-NEXT-NEXT: ret <8 x i16> 1016 // CHECK: @llvm.ppc.vsx.lxvl(i8* %{{.+}}, i64 1017 // CHECK-NEXT-NEXT: ret <8 x i16> 1018 return vec_xl_len(us,0); 1019 } 1020 vector signed short test91(void) { 1021 // CHECK-BE: @llvm.ppc.vsx.lxvl(i8* %{{.+}}, i64 1022 // CHECK-BE-NEXT-NEXT: ret <8 x i16> 1023 // CHECK: @llvm.ppc.vsx.lxvl(i8* %{{.+}}, i64 1024 // CHECK-NEXT-NEXT: ret <8 x i16> 1025 return vec_xl_len(ss,0); 1026 } 1027 vector unsigned int test92(void) { 1028 // CHECK-BE: @llvm.ppc.vsx.lxvl(i8* %{{.+}}, i64 1029 // CHECK-BE-NEXT: ret <4 x i32> 1030 // CHECK: @llvm.ppc.vsx.lxvl(i8* %{{.+}}, i64 1031 // CHECK-NEXT: ret <4 x i32> 1032 return vec_xl_len(ui,0); 1033 } 1034 1035 vector signed int test93(void) { 1036 // CHECK-BE: @llvm.ppc.vsx.lxvl(i8* %{{.+}}, i64 1037 // CHECK-BE-NEXT: ret <4 x i32> 1038 // CHECK: @llvm.ppc.vsx.lxvl(i8* %{{.+}}, i64 1039 // CHECK-NEXT: ret <4 x i32> 1040 return vec_xl_len(si,0); 1041 } 1042 1043 vector float test94(void) { 1044 // CHECK-BE: @llvm.ppc.vsx.lxvl(i8* %{{.+}}, i64 1045 // CHECK-BE-NEXT-NEXT: ret <4 x i32> 1046 // CHECK: @llvm.ppc.vsx.lxvl(i8* %{{.+}}, i64 1047 // CHECK-NEXT-NEXT: ret <4 x i32> 1048 return vec_xl_len(f,0); 1049 } 1050 1051 vector unsigned long long test95(void) { 1052 // CHECK-BE: @llvm.ppc.vsx.lxvl(i8* %{{.+}}, i64 1053 // CHECK-BE-NEXT-NEXT: ret <2 x i64> 1054 // CHECK: @llvm.ppc.vsx.lxvl(i8* %{{.+}}, i64 1055 // CHECK-NEXT-NEXT: ret <2 x i64> 1056 return vec_xl_len(ull,0); 1057 } 1058 1059 vector signed long long test96(void) { 1060 // CHECK-BE: @llvm.ppc.vsx.lxvl(i8* %{{.+}}, i64 1061 // CHECK-BE-NEXT-NEXT: ret <2 x i64> 1062 // CHECK: @llvm.ppc.vsx.lxvl(i8* %{{.+}}, i64 1063 // CHECK-NEXT-NEXT: ret <2 x i64> 1064 return vec_xl_len(sll,0); 1065 } 1066 1067 vector double test97(void) { 1068 // CHECK-BE: @llvm.ppc.vsx.lxvl(i8* %{{.+}}, i64 1069 // CHECK-BE-NEXT-NEXT: ret <2 x i64> 1070 // CHECK: @llvm.ppc.vsx.lxvl(i8* %{{.+}}, i64 1071 // CHECK-NEXT-NEXT: ret <2 x i64> 1072 return vec_xl_len(d,0); 1073 } 1074 1075 vector unsigned __int128 test98(void) { 1076 // CHECK-BE: @llvm.ppc.vsx.lxvl(i8* %{{.+}}, i64 1077 // CHECK-BE-NEXT-NEXT: ret <1 x i128> 1078 // CHECK: @llvm.ppc.vsx.lxvl(i8* %{{.+}}, i64 1079 // CHECK-NEXT-NEXT: ret <1 x i128> 1080 return vec_xl_len(uint128,0); 1081 } 1082 1083 vector signed __int128 test99(void) { 1084 // CHECK-BE: @llvm.ppc.vsx.lxvl(i8* %{{.+}}, i64 1085 // CHECK-BE-NEXT-NEXT: ret <1 x i128> 1086 // CHECK: @llvm.ppc.vsx.lxvl(i8* %{{.+}}, i64 1087 // CHECK-NEXT-NEXT: ret <1 x i128> 1088 return vec_xl_len(sint128,0); 1089 } 1090 1091 void test100(void) { 1092 // CHECK-BE: @llvm.ppc.vsx.stxvl(<4 x i32> %{{.+}}, i8* %{{.+}}, i64 1093 // CHECK: @llvm.ppc.vsx.stxvl(<4 x i32> %{{.+}}, i8* %{{.+}}, i64 1094 return vec_xst_len(vuca,uc,0); 1095 } 1096 1097 void test101(void) { 1098 // CHECK-BE: @llvm.ppc.vsx.stxvl(<4 x i32> %{{.+}}, i8* %{{.+}}, i64 1099 // CHECK: @llvm.ppc.vsx.stxvl(<4 x i32> %{{.+}}, i8* %{{.+}}, i64 1100 return vec_xst_len(vsca,sc,0); 1101 } 1102 1103 void test102(void) { 1104 // CHECK-BE: @llvm.ppc.vsx.stxvl(<4 x i32> %{{.+}}, i8* %{{.+}}, i64 1105 // CHECK: @llvm.ppc.vsx.stxvl(<4 x i32> %{{.+}}, i8* %{{.+}}, i64 1106 return vec_xst_len(vusa,us,0); 1107 } 1108 1109 void test103(void) { 1110 // CHECK-BE: @llvm.ppc.vsx.stxvl(<4 x i32> %{{.+}}, i8* %{{.+}}, i64 1111 // CHECK: @llvm.ppc.vsx.stxvl(<4 x i32> %{{.+}}, i8* %{{.+}}, i64 1112 return vec_xst_len(vssa,ss,0); 1113 } 1114 1115 void test104(void) { 1116 // CHECK-BE: @llvm.ppc.vsx.stxvl(<4 x i32> %{{.+}}, i8* %{{.+}}, i64 1117 // CHECK: @llvm.ppc.vsx.stxvl(<4 x i32> %{{.+}}, i8* %{{.+}}, i64 1118 return vec_xst_len(vuia,ui,0); 1119 } 1120 1121 void test105(void) { 1122 // CHECK-BE: @llvm.ppc.vsx.stxvl(<4 x i32> %{{.+}}, i8* %{{.+}}, i64 1123 // CHECK: @llvm.ppc.vsx.stxvl(<4 x i32> %{{.+}}, i8* %{{.+}}, i64 1124 return vec_xst_len(vsia,si,0); 1125 } 1126 1127 void test106(void) { 1128 // CHECK-BE: @llvm.ppc.vsx.stxvl(<4 x i32> %{{.+}}, i8* %{{.+}}, i64 1129 // CHECK: @llvm.ppc.vsx.stxvl(<4 x i32> %{{.+}}, i8* %{{.+}}, i64 1130 return vec_xst_len(vfa,f,0); 1131 } 1132 1133 void test107(void) { 1134 // CHECK-BE: @llvm.ppc.vsx.stxvl(<4 x i32> %{{.+}}, i8* %{{.+}}, i64 1135 // CHECK: @llvm.ppc.vsx.stxvl(<4 x i32> %{{.+}}, i8* %{{.+}}, i64 1136 return vec_xst_len(vula,ull,0); 1137 } 1138 1139 void test108(void) { 1140 // CHECK-BE: @llvm.ppc.vsx.stxvl(<4 x i32> %{{.+}}, i8* %{{.+}}, i64 1141 // CHECK: @llvm.ppc.vsx.stxvl(<4 x i32> %{{.+}}, i8* %{{.+}}, i64 1142 return vec_xst_len(vsla,sll,0); 1143 } 1144 1145 void test109(void) { 1146 // CHECK-BE: @llvm.ppc.vsx.stxvl(<4 x i32> %{{.+}}, i8* %{{.+}}, i64 1147 // CHECK: @llvm.ppc.vsx.stxvl(<4 x i32> %{{.+}}, i8* %{{.+}}, i64 1148 return vec_xst_len(vda,d,0); 1149 } 1150 1151 void test110(void) { 1152 // CHECK-BE: @llvm.ppc.vsx.stxvl(<4 x i32> %{{.+}}, i8* %{{.+}}, i64 1153 // CHECK: @llvm.ppc.vsx.stxvl(<4 x i32> %{{.+}}, i8* %{{.+}}, i64 1154 return vec_xst_len(vui128a,uint128,0); 1155 } 1156 1157 void test111(void) { 1158 // CHECK-BE: @llvm.ppc.vsx.stxvl(<4 x i32> %{{.+}}, i8* %{{.+}}, i64 1159 // CHECK: @llvm.ppc.vsx.stxvl(<4 x i32> %{{.+}}, i8* %{{.+}}, i64 1160 return vec_xst_len(vsi128a,sint128,0); 1161 } 1162 1163 vector unsigned char test112(void) { 1164 // CHECK-BE: @llvm.ppc.vsx.lxvll(i8* %{{.+}}, i64 1165 // CHECK-BE: @llvm.ppc.altivec.lvsr(i8* %{{.+}} 1166 // CHECK-BE: @llvm.ppc.altivec.vperm 1167 // CHECK: @llvm.ppc.vsx.lxvll(i8* %{{.+}}, i64 1168 // CHECK: @llvm.ppc.altivec.lvsr(i8* %{{.+}} 1169 // CHECK: @llvm.ppc.altivec.vperm 1170 return vec_xl_len_r(uc,0); 1171 } 1172 void test113(void) { 1173 // CHECK-BE: @llvm.ppc.altivec.lvsl(i8* %{{.+}} 1174 // CHECK-BE: @llvm.ppc.altivec.vperm 1175 // CHECK-BE: @llvm.ppc.vsx.stxvll(<4 x i32> %{{.+}}, i8* %{{.+}}, i64 1176 // CHECK: @llvm.ppc.altivec.lvsl(i8* %{{.+}} 1177 // CHECK: @llvm.ppc.altivec.vperm 1178 // CHECK: @llvm.ppc.vsx.stxvll(<4 x i32> %{{.+}}, i8* %{{.+}}, i64 1179 return vec_xst_len_r(vuca,uc,0); 1180 } 1181 vector float test114(void) { 1182 // CHECK-BE: shufflevector <8 x i16> {{.+}}, <8 x i16> {{.+}}, <8 x i32> <i32 undef, i32 0, i32 undef, i32 1, i32 undef, i32 2, i32 undef, i32 3> 1183 // CHECK-BE: @llvm.ppc.vsx.xvcvhpsp(<8 x i16> {{.+}}) 1184 // CHECK-BE-NEXT: ret <4 x float> 1185 // CHECK: shufflevector <8 x i16> {{.+}}, <8 x i16> {{.+}}, <8 x i32> <i32 0, i32 undef, i32 1, i32 undef, i32 2, i32 undef, i32 3, i32 undef> 1186 // CHECK: @llvm.ppc.vsx.xvcvhpsp(<8 x i16> {{.+}}) 1187 // CHECK-NEXT: ret <4 x float> 1188 return vec_extract_fp32_from_shorth(vusa); 1189 } 1190 vector float test115(void) { 1191 // CHECK-BE: shufflevector <8 x i16> {{.+}}, <8 x i16> {{.+}}, <8 x i32> <i32 undef, i32 4, i32 undef, i32 5, i32 undef, i32 6, i32 undef, i32 7> 1192 // CHECK-BE: @llvm.ppc.vsx.xvcvhpsp(<8 x i16> {{.+}}) 1193 // CHECK-BE-NEXT: ret <4 x float> 1194 // CHECK: shufflevector <8 x i16> {{.+}}, <8 x i16> {{.+}}, <8 x i32> <i32 4, i32 undef, i32 5, i32 undef, i32 6, i32 undef, i32 7, i32 undef> 1195 // CHECK: @llvm.ppc.vsx.xvcvhpsp(<8 x i16> {{.+}}) 1196 // CHECK-NEXT: ret <4 x float> 1197 return vec_extract_fp32_from_shortl(vusa); 1198 } 1199 vector unsigned char test116(void) { 1200 // CHECK-BE: [[T1:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxinsertw(<4 x i32> {{.+}}, <2 x i64> {{.+}}, i32 7) 1201 // CHECK-BE-NEXT: bitcast <4 x i32> [[T1]] to <16 x i8> 1202 // CHECK: [[T1:%.+]] = shufflevector <2 x i64> {{.+}}, <2 x i64> {{.+}}, <2 x i32> <i32 1, i32 0> 1203 // CHECK-NEXT: [[T2:%.+]] = bitcast <2 x i64> [[T1]] to <4 x i32> 1204 // CHECK-NEXT: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxinsertw(<4 x i32> [[T2]], <2 x i64> {{.+}}, i32 5) 1205 // CHECK-NEXT: bitcast <4 x i32> [[T3]] to <16 x i8> 1206 return vec_insert4b(vuia, vuca, 7); 1207 } 1208 vector unsigned char test117(void) { 1209 // CHECK-BE: [[T1:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxinsertw(<4 x i32> {{.+}}, <2 x i64> {{.+}}, i32 12) 1210 // CHECK-BE-NEXT: bitcast <4 x i32> [[T1]] to <16 x i8> 1211 // CHECK: [[T1:%.+]] = shufflevector <2 x i64> {{.+}}, <2 x i64> {{.+}}, <2 x i32> <i32 1, i32 0> 1212 // CHECK-NEXT: [[T2:%.+]] = bitcast <2 x i64> [[T1]] to <4 x i32> 1213 // CHECK-NEXT: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxinsertw(<4 x i32> [[T2]], <2 x i64> {{.+}}, i32 0) 1214 // CHECK-NEXT: bitcast <4 x i32> [[T3]] to <16 x i8> 1215 return vec_insert4b(vuia, vuca, 13); 1216 } 1217 vector unsigned long long test118(void) { 1218 // CHECK-BE: call <2 x i64> @llvm.ppc.vsx.xxextractuw(<2 x i64> {{.+}}, i32 11) 1219 // CHECK-BE-NEXT: ret <2 x i64> 1220 // CHECK: [[T1:%.+]] = call <2 x i64> @llvm.ppc.vsx.xxextractuw(<2 x i64> {{.+}}, i32 1) 1221 // CHECK-NEXT: shufflevector <2 x i64> [[T1]], <2 x i64> [[T1]], <2 x i32> <i32 1, i32 0> 1222 // CHECK-NEXT: ret <2 x i64> 1223 return vec_extract4b(vuca, 11); 1224 } 1225 vector unsigned long long test119(void) { 1226 // CHECK-BE: call <2 x i64> @llvm.ppc.vsx.xxextractuw(<2 x i64> {{.+}}, i32 0) 1227 // CHECK-BE-NEXT: ret <2 x i64> 1228 // CHECK: [[T1:%.+]] = call <2 x i64> @llvm.ppc.vsx.xxextractuw(<2 x i64> {{.+}}, i32 12) 1229 // CHECK-NEXT: shufflevector <2 x i64> [[T1]], <2 x i64> [[T1]], <2 x i32> <i32 1, i32 0> 1230 // CHECK-NEXT: ret <2 x i64> 1231 return vec_extract4b(vuca, -5); 1232 } 1233 1234 vector signed int test_vec_signexti_si_sc(void) { 1235 // CHECK: @llvm.ppc.altivec.vextsb2w(<16 x i8> 1236 // CHECK-NEXT: ret <4 x i32> 1237 return vec_signexti(vsca); 1238 } 1239 1240 vector signed int test_vec_signexti_si_ss(void) { 1241 // CHECK: @llvm.ppc.altivec.vextsh2w(<8 x i16> 1242 // CHECK-NEXT: ret <4 x i32> 1243 return vec_signexti(vssa); 1244 } 1245 1246 vector signed long long test_vec_signextll_sll_sc(void) { 1247 // CHECK: @llvm.ppc.altivec.vextsb2d(<16 x i8> 1248 // CHECK-NEXT: ret <2 x i64> 1249 return vec_signextll(vsca); 1250 } 1251 1252 vector signed long long test_vec_signextll_sll_ss(void) { 1253 // CHECK: @llvm.ppc.altivec.vextsh2d(<8 x i16> 1254 // CHECK-NEXT: ret <2 x i64> 1255 return vec_signextll(vssa); 1256 } 1257 1258 vector signed long long test_vec_signextll_sll_si(void) { 1259 // CHECK: @llvm.ppc.altivec.vextsw2d(<4 x i32> 1260 // CHECK-NEXT: ret <2 x i64> 1261 return vec_signextll(vsia); 1262 } 1263 1264 vector unsigned long long test_vbpermd(void) { 1265 // CHECK: @llvm.ppc.altivec.vbpermd(<2 x i64> 1266 // CHECK-BE: @llvm.ppc.altivec.vbpermd(<2 x i64> 1267 return vec_bperm(vula, vuca); 1268 } 1269