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