clang/test/CodeGen/PowerPC/builtins-ppc-vsx.c

   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]*}}, <i64 -1, 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]*}}, <i64 -1, 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]*}}, <i64 -1, 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]*}}, <i64 -1, 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]*}}, <i64 -1, 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]], <i64 -1, 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]], <i64 -1, 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]+}}, <i64 -1, 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]+}}, <i64 -1, 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]+}}, <i64 -1, 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]+}}, <i64 -1, 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]+}}, <i64 -1, 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]+}}, <i64 -1, 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]+}}, <i64 -1, 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]+}}, <i64 -1, 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]+}}, <i64 -1, 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]+}}, <i64 -1, 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]+}}, <i64 -1, 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]+}}, <i64 -1, 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]+}}, <i64 -1, 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]+}}, <i64 -1, 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]+}}, <i64 -1, 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]+}}, <i64 -1, 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> {{%.*}}, <float 8.000000e+00, float 8.000000e+00, float 8.000000e+00, float 8.000000e+00>
1286   // CHECK: call <2 x i64> @llvm.ppc.vsx.xvcvspsxds(<4 x float>
1287   // CHECK-LE: fmul <4 x float> {{%.*}}, <float 8.000000e+00, float 8.000000e+00, float 8.000000e+00, 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> {{%.*}}, <double 8.000000e+00, double 8.000000e+00>
1293   // CHECK: fptosi <2 x double> {{%.*}} to <2 x i64>
1294   // CHECK-LE: fmul <2 x double> {{%.*}}, <double 8.000000e+00, 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> {{%.*}}, <float 8.000000e+00, float 8.000000e+00, float 8.000000e+00, float 8.000000e+00>
1311   // CHECK: call <2 x i64> @llvm.ppc.vsx.xvcvspuxds(<4 x float>
1312   // CHECK-LE: fmul <4 x float> {{%.*}}, <float 8.000000e+00, float 8.000000e+00, float 8.000000e+00, 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> {{%.*}}, <double 8.000000e+00, double 8.000000e+00>
1318   // CHECK: fptoui <2 x double> {{%.*}} to <2 x i64>
1319   // CHECK-LE: fmul <2 x double> {{%.*}}, <double 8.000000e+00, 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> {{.*}} <double 2.500000e-01, double 2.500000e-01>
1349 // CHECK-LE: sitofp <2 x i64> %{{.*}} to <2 x double>
1350 // CHECK-LE: fmul <2 x double> {{.*}} <double 2.500000e-01, 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> {{.*}} <double 2.500000e-01, double 2.500000e-01>
1355 // CHECK-LE: uitofp <2 x i64> %{{.*}} to <2 x double>
1356 // CHECK-LE: fmul <2 x double> {{.*}} <double 2.500000e-01, 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> {{.*}} <double 2.500000e-01, 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> {{.*}} <double 2.500000e-01, 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> {{.*}} <double 2.500000e-01, 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> {{.*}} <double 2.500000e-01, 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> <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>, 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> <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>, 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> <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>, 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> <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>, 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_vsll = vec_xlds(sll, asll);
1981 // CHECK: load i64
1982 // CHECK: insertelement <2 x i64>
1983 // CHECK: shufflevector <2 x i64>
1984 // CHECK-LE: load i64
1985 // CHECK-LE: insertelement <2 x i64>
1986 // CHECK-LE: shufflevector <2 x i64>
1987
1988 res_vull = vec_xlds(sll, aull);
1989 // CHECK: load i64
1990 // CHECK: insertelement <2 x i64>
1991 // CHECK: shufflevector <2 x i64>
1992 // CHECK-LE: load i64
1993 // CHECK-LE: insertelement <2 x i64>
1994 // CHECK-LE: shufflevector <2 x i64>
1995
1996 res_vd = vec_xlds(sll, ad);
1997 // CHECK: load double
1998 // CHECK: insertelement <2 x double>
1999 // CHECK: shufflevector <2 x double>
2000 // CHECK-LE: load double
2001 // CHECK-LE: insertelement <2 x double>
2002 // CHECK-LE: shufflevector <2 x double>
2003
2004 res_vsi = vec_load_splats(sll, asi);
2005 // CHECK: load i32
2006 // CHECK: insertelement <4 x i32>
2007 // CHECK: shufflevector <4 x i32>
2008 // CHECK-LE: load i32
2009 // CHECK-LE: insertelement <4 x i32>
2010 // CHECK-LE: shufflevector <4 x i32>
2011
2012 res_vsi = vec_load_splats(ull, asi);
2013 // CHECK: load i32
2014 // CHECK: insertelement <4 x i32>
2015 // CHECK: shufflevector <4 x i32>
2016 // CHECK-LE: load i32
2017 // CHECK-LE: insertelement <4 x i32>
2018 // CHECK-LE: shufflevector <4 x i32>
2019
2020 res_vui = vec_load_splats(sll, aui);
2021 // CHECK: load i32
2022 // CHECK: insertelement <4 x i32>
2023 // CHECK: shufflevector <4 x i32>
2024 // CHECK-LE: load i32
2025 // CHECK-LE: insertelement <4 x i32>
2026 // CHECK-LE: shufflevector <4 x i32>
2027
2028 res_vui = vec_load_splats(ull, aui);
2029 // CHECK: load i32
2030 // CHECK: insertelement <4 x i32>
2031 // CHECK: shufflevector <4 x i32>
2032 // CHECK-LE: load i32
2033 // CHECK-LE: insertelement <4 x i32>
2034 // CHECK-LE: shufflevector <4 x i32>
2035
2036 res_vf = vec_load_splats(sll, af);
2037 // CHECK: load float
2038 // CHECK: insertelement <4 x float>
2039 // CHECK: shufflevector <4 x float>
2040 // CHECK-LE: load float
2041 // CHECK-LE: insertelement <4 x float>
2042 // CHECK-LE: shufflevector <4 x float>
2043
2044 res_vf = vec_load_splats(ull, af);
2045 // CHECK: load float
2046 // CHECK: insertelement <4 x float>
2047 // CHECK: shufflevector <4 x float>
2048 // CHECK-LE: load float
2049 // CHECK-LE: insertelement <4 x float>
2050 // CHECK-LE: shufflevector <4 x float>
2051
2052 vec_xst_be(vsll, sll, asll);
2053 // CHECK: store <2 x i64> %{{[0-9]+}}, ptr %{{[0-9]+}}, align 1
2054 // CHECK-LE: call void @llvm.ppc.vsx.stxvd2x.be(<2 x double> %{{[0-9]+}}, ptr %{{[0-9]+}})
2055
2056 vec_xst_be(vull, sll, aull);
2057 // CHECK: store <2 x i64> %{{[0-9]+}}, ptr %{{[0-9]+}}, align 1
2058 // CHECK-LE: call void @llvm.ppc.vsx.stxvd2x.be(<2 x double> %{{[0-9]+}}, ptr %{{[0-9]+}})
2059
2060 vec_xst_be(vd, sll, ad);
2061 // CHECK: store <2 x double> %{{[0-9]+}}, ptr %{{[0-9]+}}, align 1
2062 // CHECK-LE: call void @llvm.ppc.vsx.stxvd2x.be(<2 x double> %{{[0-9]+}}, ptr %{{[0-9]+}})
2063
2064   res_vf = vec_neg(vf);
2065 // CHECK: fneg <4 x float> {{%[0-9]+}}
2066 // CHECK-LE: fneg <4 x float> {{%[0-9]+}}
2067
2068   res_vd = vec_neg(vd);
2069 // CHECK: fneg <2 x double> {{%[0-9]+}}
2070 // CHECK-LE: fneg <2 x double> {{%[0-9]+}}
2071
2072 res_vd = vec_xxpermdi(vd, vd, 0);
2073 // CHECK: shufflevector <2 x i64> %{{[0-9]+}}, <2 x i64> %{{[0-9]+}}, <2 x i32> <i32 0, i32 2>
2074 // CHECK-LE: shufflevector <2 x i64> %{{[0-9]+}}, <2 x i64> %{{[0-9]+}}, <2 x i32> <i32 0, i32 2>
2075
2076 res_vf = vec_xxpermdi(vf, vf, 1);
2077 // CHECK: shufflevector <2 x i64> %{{[0-9]+}}, <2 x i64> %{{[0-9]+}}, <2 x i32> <i32 0, i32 3>
2078 // CHECK-LE: shufflevector <2 x i64> %{{[0-9]+}}, <2 x i64> %{{[0-9]+}}, <2 x i32> <i32 0, i32 3>
2079
2080 res_vsll = vec_xxpermdi(vsll, vsll, 2);
2081 // CHECK: shufflevector <2 x i64> %{{[0-9]+}}, <2 x i64> %{{[0-9]+}}, <2 x i32> <i32 1, i32 2>
2082 // CHECK-LE: shufflevector <2 x i64> %{{[0-9]+}}, <2 x i64> %{{[0-9]+}}, <2 x i32> <i32 1, i32 2>
2083
2084 res_vull = vec_xxpermdi(vull, vull, 3);
2085 // CHECK: shufflevector <2 x i64> %{{[0-9]+}}, <2 x i64> %{{[0-9]+}}, <2 x i32> <i32 1, i32 3>
2086 // CHECK-LE: shufflevector <2 x i64> %{{[0-9]+}}, <2 x i64> %{{[0-9]+}}, <2 x i32> <i32 1, i32 3>
2087
2088 res_vsi = vec_xxpermdi(vsi, vsi, 0);
2089 // CHECK: shufflevector <2 x i64> %{{[0-9]+}}, <2 x i64> %{{[0-9]+}}, <2 x i32> <i32 0, i32 2>
2090 // CHECK-LE: shufflevector <2 x i64> %{{[0-9]+}}, <2 x i64> %{{[0-9]+}}, <2 x i32> <i32 0, i32 2>
2091
2092 res_vui = vec_xxpermdi(vui, vui, 1);
2093 // CHECK: shufflevector <2 x i64> %{{[0-9]+}}, <2 x i64> %{{[0-9]+}}, <2 x i32> <i32 0, i32 3>
2094 // CHECK-LE: shufflevector <2 x i64> %{{[0-9]+}}, <2 x i64> %{{[0-9]+}}, <2 x i32> <i32 0, i32 3>
2095
2096 res_vss = vec_xxpermdi(vss, vss, 2);
2097 // CHECK: shufflevector <2 x i64> %{{[0-9]+}}, <2 x i64> %{{[0-9]+}}, <2 x i32> <i32 1, i32 2>
2098 // CHECK-LE: shufflevector <2 x i64> %{{[0-9]+}}, <2 x i64> %{{[0-9]+}}, <2 x i32> <i32 1, i32 2>
2099
2100 res_vus = vec_xxpermdi(vus, vus, 3);
2101 // CHECK: shufflevector <2 x i64> %{{[0-9]+}}, <2 x i64> %{{[0-9]+}}, <2 x i32> <i32 1, i32 3>
2102 // CHECK-LE: shufflevector <2 x i64> %{{[0-9]+}}, <2 x i64> %{{[0-9]+}}, <2 x i32> <i32 1, i32 3>
2103
2104 res_vsc = vec_xxpermdi(vsc, vsc, 0);
2105 // CHECK: shufflevector <2 x i64> %{{[0-9]+}}, <2 x i64> %{{[0-9]+}}, <2 x i32> <i32 0, i32 2>
2106 // CHECK-LE: shufflevector <2 x i64> %{{[0-9]+}}, <2 x i64> %{{[0-9]+}}, <2 x i32> <i32 0, i32 2>
2107
2108 res_vuc = vec_xxpermdi(vuc, vuc, 1);
2109 // CHECK: shufflevector <2 x i64> %{{[0-9]+}}, <2 x i64> %{{[0-9]+}}, <2 x i32> <i32 0, i32 3>
2110 // CHECK-LE: shufflevector <2 x i64> %{{[0-9]+}}, <2 x i64> %{{[0-9]+}}, <2 x i32> <i32 0, i32 3>
2111
2112 res_vd = vec_permi(vd, vd, 0);
2113 // CHECK: shufflevector <2 x double> %{{[0-9]+}}, <2 x double> %{{[0-9]+}}, <2 x i32> <i32 0, i32 2>
2114 // CHECK-LE: shufflevector <2 x double> %{{[0-9]+}}, <2 x double> %{{[0-9]+}}, <2 x i32> <i32 0, i32 2>
2115
2116 res_vsll = vec_permi(vsll, vsll, 2);
2117 // CHECK: shufflevector <2 x i64> %{{[0-9]+}}, <2 x i64> %{{[0-9]+}}, <2 x i32> <i32 1, i32 2>
2118 // CHECK-LE: shufflevector <2 x i64> %{{[0-9]+}}, <2 x i64> %{{[0-9]+}}, <2 x i32> <i32 1, i32 2>
2119
2120 res_vull = vec_permi(vull, vull, 3);
2121 // CHECK: shufflevector <2 x i64> %{{[0-9]+}}, <2 x i64> %{{[0-9]+}}, <2 x i32> <i32 1, i32 3>
2122 // CHECK-LE: shufflevector <2 x i64> %{{[0-9]+}}, <2 x i64> %{{[0-9]+}}, <2 x i32> <i32 1, i32 3>
2123
2124 res_vbll = vec_permi(vbll, vbll, 3);
2125 // CHECK: shufflevector <2 x i64> %{{[0-9]+}}, <2 x i64> %{{[0-9]+}}, <2 x i32> <i32 1, i32 3>
2126 // CHECK-LE: shufflevector <2 x i64> %{{[0-9]+}}, <2 x i64> %{{[0-9]+}}, <2 x i32> <i32 1, i32 3>
2127
2128 res_vd = vec_xxsldwi(vd, vd, 0);
2129 // CHECK: shufflevector <4 x i32> %{{[0-9]+}}, <4 x i32> %{{[0-9]+}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
2130 // CHECK-LE: shufflevector <4 x i32> %{{[0-9]+}}, <4 x i32> %{{[0-9]+}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
2131
2132 res_vf = vec_xxsldwi(vf, vf, 1);
2133 // CHECK: shufflevector <4 x i32> %{{[0-9]+}}, <4 x i32> %{{[0-9]+}}, <4 x i32> <i32 1, i32 2, i32 3, i32 4>
2134 // CHECK-LE: shufflevector <4 x i32> %{{[0-9]+}}, <4 x i32> %{{[0-9]+}}, <4 x i32> <i32 7, i32 0, i32 1, i32 2>
2135
2136 res_vsll = vec_xxsldwi(vsll, vsll, 2);
2137 // CHECK: shufflevector <4 x i32> %{{[0-9]+}}, <4 x i32> %{{[0-9]+}}, <4 x i32> <i32 2, i32 3, i32 4, i32 5>
2138 // CHECK-LE: shufflevector <4 x i32> %{{[0-9]+}}, <4 x i32> %{{[0-9]+}}, <4 x i32> <i32 6, i32 7, i32 0, i32 1>
2139
2140 res_vull = vec_xxsldwi(vull, vull, 3);
2141 // CHECK: shufflevector <4 x i32> %{{[0-9]+}}, <4 x i32> %{{[0-9]+}}, <4 x i32> <i32 3, i32 4, i32 5, i32 6>
2142 // CHECK-LE: shufflevector <4 x i32> %{{[0-9]+}}, <4 x i32> %{{[0-9]+}}, <4 x i32> <i32 5, i32 6, i32 7, i32 0>
2143
2144 res_vsi = vec_xxsldwi(vsi, vsi, 0);
2145 // CHECK: shufflevector <4 x i32> %{{[0-9]+}}, <4 x i32> %{{[0-9]+}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
2146 // CHECK-LE: shufflevector <4 x i32> %{{[0-9]+}}, <4 x i32> %{{[0-9]+}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
2147
2148 res_vui = vec_xxsldwi(vui, vui, 1);
2149 // CHECK: shufflevector <4 x i32> %{{[0-9]+}}, <4 x i32> %{{[0-9]+}}, <4 x i32> <i32 1, i32 2, i32 3, i32 4>
2150 // CHECK-LE: shufflevector <4 x i32> %{{[0-9]+}}, <4 x i32> %{{[0-9]+}}, <4 x i32> <i32 7, i32 0, i32 1, i32 2>
2151
2152 res_vss = vec_xxsldwi(vss, vss, 2);
2153 // CHECK: shufflevector <4 x i32> %{{[0-9]+}}, <4 x i32> %{{[0-9]+}}, <4 x i32> <i32 2, i32 3, i32 4, i32 5>
2154 // CHECK-LE: shufflevector <4 x i32> %{{[0-9]+}}, <4 x i32> %{{[0-9]+}}, <4 x i32> <i32 6, i32 7, i32 0, i32 1>
2155
2156
2157 res_vus = vec_xxsldwi(vus, vus, 3);
2158 // CHECK: shufflevector <4 x i32> %{{[0-9]+}}, <4 x i32> %{{[0-9]+}}, <4 x i32> <i32 3, i32 4, i32 5, i32 6>
2159 // CHECK-LE: shufflevector <4 x i32> %{{[0-9]+}}, <4 x i32> %{{[0-9]+}}, <4 x i32> <i32 5, i32 6, i32 7, i32 0>
2160
2161 res_vsc = vec_xxsldwi(vsc, vsc, 0);
2162 // CHECK: shufflevector <4 x i32> %{{[0-9]+}}, <4 x i32> %{{[0-9]+}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
2163 // CHECK-LE: shufflevector <4 x i32> %{{[0-9]+}}, <4 x i32> %{{[0-9]+}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
2164
2165 res_vuc = vec_xxsldwi(vuc, vuc, 1);
2166 // CHECK: shufflevector <4 x i32> %{{[0-9]+}}, <4 x i32> %{{[0-9]+}}, <4 x i32> <i32 1, i32 2, i32 3, i32 4>
2167 // CHECK-LE: shufflevector <4 x i32> %{{[0-9]+}}, <4 x i32> %{{[0-9]+}}, <4 x i32> <i32 7, i32 0, i32 1, i32 2>
2168
2169 res_vd = vec_promote(d, 0);
2170 // CHECK: store <2 x double> zeroinitializer
2171 // CHECK: insertelement <2 x double>
2172 // CHECK-LE: store <2 x double> zeroinitializer
2173 // CHECK-LE: insertelement <2 x double>
2174
2175 res_vsll = vec_promote(sll, 0);
2176 // CHECK: store <2 x i64> zeroinitializer
2177 // CHECK: insertelement <2 x i64>
2178 // CHECK-LE: store <2 x i64> zeroinitializer
2179 // CHECK-LE: insertelement <2 x i64>
2180
2181 res_vull = vec_promote(ull, 0);
2182 // CHECK: store <2 x i64> zeroinitializer
2183 // CHECK: insertelement <2 x i64>
2184 // CHECK-LE: store <2 x i64> zeroinitializer
2185 // CHECK-LE: insertelement <2 x i64>
2186 }
2187
2188 // The return type of the call expression may be different from the return type of the shufflevector.
2189 // Wrong implementation could crash the compiler, add this test case to check that and avoid ICE.
2190 vector int xxpermdi_should_not_assert(vector int a, vector int b) {
2191   return vec_xxpermdi(a, b, 0);
2192 // CHECK-LABEL: xxpermdi_should_not_assert
2193 // CHECK:  bitcast <4 x i32> %{{[0-9]+}} to <2 x i64>
2194 // CHECK-NEXT:  bitcast <4 x i32> %{{[0-9]+}} to <2 x i64>
2195 // CHECK-NEXT:  shufflevector <2 x i64> %{{[0-9]+}}, <2 x i64> %{{[0-9]+}}, <2 x i32> <i32 0, i32 2>
2196 // CHECK-NEXT:  bitcast <2 x i64> %{{[0-9]+}} to <4 x i32>
2197
2198 // CHECK-LE:  bitcast <4 x i32> %{{[0-9]+}} to <2 x i64>
2199 // CHECK-LE-NEXT:  bitcast <4 x i32> %{{[0-9]+}} to <2 x i64>
2200 // CHECK-LE-NEXT:  shufflevector <2 x i64> %{{[0-9]+}}, <2 x i64> %{{[0-9]+}}, <2 x i32> <i32 0, i32 2>
2201 // CHECK-LE-NEXT:  bitcast <2 x i64> %{{[0-9]+}} to <4 x i32>
2202 }
2203
2204 vector double xxsldwi_should_not_assert(vector double a, vector double b) {
2205   return vec_xxsldwi(a, b, 0);
2206 // CHECK-LABEL: xxsldwi_should_not_assert
2207 // CHECK:  bitcast <2 x double> %{{[0-9]+}} to <4 x i32>
2208 // CHECK-NEXT:  bitcast <2 x double> %{{[0-9]+}} to <4 x i32>
2209 // CHECK-NEXT:  shufflevector <4 x i32> %{{[0-9]+}}, <4 x i32> %{{[0-9]+}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
2210 // CHECK-NEXT:  bitcast <4 x i32> %{{[0-9]+}} to <2 x double>
2211
2212 // CHECK-LE:  bitcast <2 x double> %{{[0-9]+}} to <4 x i32>
2213 // CHECK-NEXT-LE:  bitcast <2 x double> %{{[0-9]+}} to <4 x i32>
2214 // 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>
2215 // CHECK-NEXT-LE:  bitcast <4 x i32> %{{[0-9]+}} to <2 x double>
2216 }
2217
2218 void test_vector_cpsgn_float(vector float a, vector float b) {
2219 // CHECK-LABEL: test_vector_cpsgn_float
2220 // CHECK-NOT: SEPARATOR
2221 // CHECK-DAG: [[RA:%[0-9]+]] = load <4 x float>, ptr %__a.addr
2222 // CHECK-DAG: [[RB:%[0-9]+]] = load <4 x float>, ptr %__b.addr
2223 // CHECK-NEXT: call <4 x float> @llvm.copysign.v4f32(<4 x float> [[RB]], <4 x float> [[RA]])
2224   vec_cpsgn(a, b);
2225 }
2226
2227 void test_vector_cpsgn_double(vector double a, vector double b) {
2228 // CHECK-LABEL: test_vector_cpsgn_double
2229 // CHECK-NOT: SEPARATOR
2230 // CHECK-DAG: [[RA:%[0-9]+]] = load <2 x double>, ptr %__a.addr
2231 // CHECK-DAG: [[RB:%[0-9]+]] = load <2 x double>, ptr %__b.addr
2232 // CHECK-NEXT: call <2 x double> @llvm.copysign.v2f64(<2 x double> [[RB]], <2 x double> [[RA]])
2233   vec_cpsgn(a, b);
2234 }
2235
2236 void test_builtin_xvcpsgnsp(vector float a, vector float b) {
2237 // CHECK-LABEL: test_builtin_xvcpsgnsp
2238 // CHECK-NOT: SEPARATOR
2239 // CHECK-DAG: [[RA:%[0-9]+]] = load <4 x float>, ptr %a.addr
2240 // CHECK-DAG: [[RB:%[0-9]+]] = load <4 x float>, ptr %b.addr
2241 // CHECK-NEXT: call <4 x float> @llvm.copysign.v4f32(<4 x float> [[RA]], <4 x float> [[RB]])
2242   __builtin_vsx_xvcpsgnsp(a, b);
2243 }
2244
2245 void test_builtin_xvcpsgndp(vector double a, vector double b) {
2246 // CHECK-LABEL: test_builtin_xvcpsgndp
2247 // CHECK-NOT: SEPARATOR
2248 // CHECK-DAG: [[RA:%[0-9]+]] = load <2 x double>, ptr %a.addr
2249 // CHECK-DAG: [[RB:%[0-9]+]] = load <2 x double>, ptr %b.addr
2250 // CHECK-NEXT: call <2 x double> @llvm.copysign.v2f64(<2 x double> [[RA]], <2 x double> [[RB]])
2251   __builtin_vsx_xvcpsgndp(a, b);
2252 }
2253
2254 vector double test_recipdivd(vector double a, vector double b) {
2255   // CHECK-LABEL: test_recipdivd
2256   // CHECK: fdiv fast <2 x double>
2257   // CHECK-LE-LABEL: test_recipdivd
2258   // CHECK-LE: fdiv fast <2 x double>
2259   return vec_recipdiv(a, b);
2260 }
2261
2262 vector double test_rsqrtd(vector double a, vector double b) {
2263   // CHECK-LABEL: test_rsqrtd
2264   // CHECK: call fast <2 x double> @llvm.sqrt.v2f64
2265   // CHECK: fdiv fast <2 x double> <double 1.000000e+00, double 1.000000e+00>
2266   // CHECK-LE-LABEL: test_rsqrtd
2267   // CHECK-LE: call fast <2 x double> @llvm.sqrt.v2f64
2268   // CHECK-LE: fdiv fast <2 x double> <double 1.000000e+00, double 1.000000e+00>
2269   return vec_rsqrt(a);
2270 }
2271
2272 void test_p8overloads_backwards_compat() {
2273   // CHECK-LABEL: test_p8overloads_backwards_compat
2274   res_vsll = vec_add(vsll, vsll);
2275   // CHECK: add <4 x i32>
2276   // CHECK: call <4 x i32> @llvm.ppc.altivec.vaddcuw
2277   // 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>
2278   // CHECK: add <4 x i32>
2279   // CHECK-LE: add <2 x i64>
2280   res_vull = vec_add(vull, vull);
2281   // CHECK: add <4 x i32>
2282   // CHECK: call <4 x i32> @llvm.ppc.altivec.vaddcuw
2283   // 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>
2284   // CHECK: add <4 x i32>
2285   // CHECK-LE: add <2 x i64>
2286   dummy();
2287   // CHECK: call void @dummy()
2288   // CHECK-LE: call void @dummy()
2289
2290   res_vbll = vec_cmpeq(vsll, vsll);
2291   // CHECK: call <4 x i32> @llvm.ppc.altivec.vcmpequw
2292   // CHECK: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 1, i32 2, i32 3, i32 0>
2293   // CHECK: and <4 x i32>
2294   // CHECK: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 0, i32 0, i32 2, i32 2>
2295   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vcmpequw
2296   // CHECK-LE: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 3, i32 0, i32 1, i32 2>
2297   // CHECK-LE: and <4 x i32>
2298   // CHECK-LE: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 1, i32 1, i32 3, i32 3>
2299   res_vbll = vec_cmpeq(vull, vull);
2300   // CHECK: call <4 x i32> @llvm.ppc.altivec.vcmpequw
2301   // CHECK: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 1, i32 2, i32 3, i32 0>
2302   // CHECK: and <4 x i32>
2303   // CHECK: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 0, i32 0, i32 2, i32 2>
2304   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vcmpequw
2305   // CHECK-LE: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 3, i32 0, i32 1, i32 2>
2306   // CHECK-LE: and <4 x i32>
2307   // CHECK-LE: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 1, i32 1, i32 3, i32 3>
2308   res_vbll = vec_cmpeq(vbll, vbll);
2309   // CHECK: call <4 x i32> @llvm.ppc.altivec.vcmpequw
2310   // CHECK: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 1, i32 2, i32 3, i32 0>
2311   // CHECK: and <4 x i32>
2312   // CHECK: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 0, i32 0, i32 2, i32 2>
2313   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vcmpequw
2314   // CHECK-LE: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 3, i32 0, i32 1, i32 2>
2315   // CHECK-LE: and <4 x i32>
2316   // CHECK-LE: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 1, i32 1, i32 3, i32 3>
2317   dummy();
2318   // CHECK: call void @dummy()
2319   // CHECK-LE: call void @dummy()
2320
2321   res_vbll = vec_cmpgt(vsll, vsll);
2322   // CHECK: call <4 x i32> @llvm.ppc.altivec.vcmpgtsw
2323   // CHECK: call <4 x i32> @llvm.ppc.altivec.vcmpgtuw
2324   // CHECK: call <4 x i32> @llvm.ppc.altivec.vcmpequw
2325   // CHECK: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 1, i32 2, i32 3, i32 0>
2326   // CHECK: and <4 x i32>
2327   // CHECK: or <4 x i32>
2328   // CHECK: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 0, i32 0, i32 2, i32 2>
2329   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vcmpgtsw
2330   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vcmpgtuw
2331   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vcmpequw
2332   // CHECK-LE: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 3, i32 0, i32 1, i32 2>
2333   // CHECK-LE: and <4 x i32>
2334   // CHECK-LE: or <4 x i32>
2335   // CHECK-LE: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 1, i32 1, i32 3, i32 3>
2336   res_vbll = vec_cmpgt(vull, vull);
2337   // CHECK: call <4 x i32> @llvm.ppc.altivec.vcmpgtuw
2338   // CHECK: call <4 x i32> @llvm.ppc.altivec.vcmpequw
2339   // CHECK: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 1, i32 2, i32 3, i32 0>
2340   // CHECK: and <4 x i32>
2341   // CHECK: or <4 x i32>
2342   // CHECK: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 0, i32 0, i32 2, i32 2>
2343   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vcmpgtuw
2344   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vcmpequw
2345   // CHECK-LE: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 3, i32 0, i32 1, i32 2>
2346   // CHECK-LE: and <4 x i32>
2347   // CHECK-LE: or <4 x i32>
2348   // CHECK-LE: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 1, i32 1, i32 3, i32 3>
2349   dummy();
2350   // CHECK: call void @dummy()
2351   // CHECK-LE: call void @dummy()
2352
2353   res_vbll = vec_cmpge(vsll, vsll);
2354   // CHECK: call <4 x i32> @llvm.ppc.altivec.vcmpgtsw
2355   // CHECK: call <4 x i32> @llvm.ppc.altivec.vcmpgtuw
2356   // CHECK: call <4 x i32> @llvm.ppc.altivec.vcmpequw
2357   // CHECK: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 1, i32 2, i32 3, i32 0>
2358   // CHECK: and <4 x i32>
2359   // CHECK: or <4 x i32>
2360   // CHECK: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 0, i32 0, i32 2, i32 2>
2361   // CHECK: xor <2 x i64> {{%.*}}, <i64 -1, i64 -1>
2362   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vcmpgtsw
2363   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vcmpgtuw
2364   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vcmpequw
2365   // CHECK-LE: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 3, i32 0, i32 1, i32 2>
2366   // CHECK-LE: and <4 x i32>
2367   // CHECK-LE: or <4 x i32>
2368   // CHECK-LE: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 1, i32 1, i32 3, i32 3>
2369   // CHECK-LE: xor <2 x i64> {{%.*}}, <i64 -1, i64 -1>
2370   res_vbll = vec_cmpge(vull, vull);
2371   // CHECK: call <4 x i32> @llvm.ppc.altivec.vcmpgtuw
2372   // CHECK: call <4 x i32> @llvm.ppc.altivec.vcmpequw
2373   // CHECK: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 1, i32 2, i32 3, i32 0>
2374   // CHECK: and <4 x i32>
2375   // CHECK: or <4 x i32>
2376   // CHECK: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 0, i32 0, i32 2, i32 2>
2377   // CHECK: xor <2 x i64> {{%.*}}, <i64 -1, i64 -1>
2378   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vcmpgtuw
2379   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vcmpequw
2380   // CHECK-LE: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 3, i32 0, i32 1, i32 2>
2381   // CHECK-LE: and <4 x i32>
2382   // CHECK-LE: or <4 x i32>
2383   // CHECK-LE: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 1, i32 1, i32 3, i32 3>
2384   // CHECK-LE: xor <2 x i64> {{%.*}}, <i64 -1, i64 -1>
2385   dummy();
2386   // CHECK: call void @dummy()
2387   // CHECK-LE: call void @dummy()
2388
2389   res_vbll = vec_cmplt(vsll, vsll);
2390   // CHECK: call <4 x i32> @llvm.ppc.altivec.vcmpgtsw
2391   // CHECK: call <4 x i32> @llvm.ppc.altivec.vcmpgtuw
2392   // CHECK: call <4 x i32> @llvm.ppc.altivec.vcmpequw
2393   // CHECK: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 1, i32 2, i32 3, i32 0>
2394   // CHECK: and <4 x i32>
2395   // CHECK: or <4 x i32>
2396   // CHECK: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 0, i32 0, i32 2, i32 2>
2397   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vcmpgtsw
2398   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vcmpgtuw
2399   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vcmpequw
2400   // CHECK-LE: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 3, i32 0, i32 1, i32 2>
2401   // CHECK-LE: and <4 x i32>
2402   // CHECK-LE: or <4 x i32>
2403   // CHECK-LE: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 1, i32 1, i32 3, i32 3>
2404   res_vbll = vec_cmplt(vull, vull);
2405   // CHECK: call <4 x i32> @llvm.ppc.altivec.vcmpgtuw
2406   // CHECK: call <4 x i32> @llvm.ppc.altivec.vcmpequw
2407   // CHECK: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 1, i32 2, i32 3, i32 0>
2408   // CHECK: and <4 x i32>
2409   // CHECK: or <4 x i32>
2410   // CHECK: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 0, i32 0, i32 2, i32 2>
2411   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vcmpgtuw
2412   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vcmpequw
2413   // CHECK-LE: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 3, i32 0, i32 1, i32 2>
2414   // CHECK-LE: and <4 x i32>
2415   // CHECK-LE: or <4 x i32>
2416   // CHECK-LE: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 1, i32 1, i32 3, i32 3>
2417   dummy();
2418   // CHECK: call void @dummy()
2419   // CHECK-LE: call void @dummy()
2420
2421   res_vbll = vec_cmple(vsll, vsll);
2422   // CHECK: call <4 x i32> @llvm.ppc.altivec.vcmpgtsw
2423   // CHECK: call <4 x i32> @llvm.ppc.altivec.vcmpgtuw
2424   // CHECK: call <4 x i32> @llvm.ppc.altivec.vcmpequw
2425   // CHECK: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 1, i32 2, i32 3, i32 0>
2426   // CHECK: and <4 x i32>
2427   // CHECK: or <4 x i32>
2428   // CHECK: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 0, i32 0, i32 2, i32 2>
2429   // CHECK: xor <2 x i64> {{%.*}}, <i64 -1, i64 -1>
2430   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vcmpgtsw
2431   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vcmpgtuw
2432   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vcmpequw
2433   // CHECK-LE: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 3, i32 0, i32 1, i32 2>
2434   // CHECK-LE: and <4 x i32>
2435   // CHECK-LE: or <4 x i32>
2436   // CHECK-LE: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 1, i32 1, i32 3, i32 3>
2437   // CHECK-LE: xor <2 x i64> {{%.*}}, <i64 -1, i64 -1>
2438   res_vbll = vec_cmple(vull, vull);
2439   // CHECK: call <4 x i32> @llvm.ppc.altivec.vcmpgtuw
2440   // CHECK: call <4 x i32> @llvm.ppc.altivec.vcmpequw
2441   // CHECK: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 1, i32 2, i32 3, i32 0>
2442   // CHECK: and <4 x i32>
2443   // CHECK: or <4 x i32>
2444   // CHECK: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 0, i32 0, i32 2, i32 2>
2445   // CHECK: xor <2 x i64> {{%.*}}, <i64 -1, i64 -1>
2446   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vcmpgtuw
2447   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vcmpequw
2448   // CHECK-LE: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 3, i32 0, i32 1, i32 2>
2449   // CHECK-LE: and <4 x i32>
2450   // CHECK-LE: or <4 x i32>
2451   // CHECK-LE: shufflevector <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> <i32 1, i32 1, i32 3, i32 3>
2452   // CHECK-LE: xor <2 x i64> {{%.*}}, <i64 -1, i64 -1>
2453   dummy();
2454   // CHECK: call void @dummy()
2455   // CHECK-LE: call void @dummy()
2456
2457   res_vsll = vec_sl(vsll, vull);
2458   // CHECK: urem <2 x i64> {{%.*}}, <i64 64, i64 64>
2459   // CHECK: call <4 x i32> @llvm.ppc.altivec.vslo
2460   // CHECK: call <4 x i32> @llvm.ppc.altivec.vsl
2461   // CHECK: shufflevector <2 x i64> {{%.*}}, <2 x i64> {{%.*}}, <2 x i32> <i32 1, i32 0>
2462   // CHECK: shufflevector <2 x i64> {{%.*}}, <2 x i64> {{%.*}}, <2 x i32> <i32 1, i32 0>
2463   // CHECK: call <4 x i32> @llvm.ppc.altivec.vslo
2464   // CHECK: call <4 x i32> @llvm.ppc.altivec.vsl
2465   // CHECK: shufflevector <2 x i64> {{%.*}}, <2 x i64> {{%.*}}, <2 x i32> <i32 1, i32 3>
2466   // CHECK-LE: urem <2 x i64> {{%.*}}, <i64 64, i64 64>
2467   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vslo
2468   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vsl
2469   // CHECK-LE: shufflevector <2 x i64> {{%.*}}, <2 x i64> {{%.*}}, <2 x i32> <i32 1, i32 0>
2470   // CHECK-LE: shufflevector <2 x i64> {{%.*}}, <2 x i64> {{%.*}}, <2 x i32> <i32 1, i32 0>
2471   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vslo
2472   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vsl
2473   // CHECK-LE: shufflevector <2 x i64> {{%.*}}, <2 x i64> {{%.*}}, <2 x i32> <i32 0, i32 2>
2474   res_vull = vec_sl(vull, vull);
2475   // CHECK: urem <2 x i64> {{%.*}}, <i64 64, i64 64>
2476   // CHECK: call <4 x i32> @llvm.ppc.altivec.vslo
2477   // CHECK: call <4 x i32> @llvm.ppc.altivec.vsl
2478   // CHECK: shufflevector <2 x i64> {{%.*}}, <2 x i64> {{%.*}}, <2 x i32> <i32 1, i32 0>
2479   // CHECK: shufflevector <2 x i64> {{%.*}}, <2 x i64> {{%.*}}, <2 x i32> <i32 1, i32 0>
2480   // CHECK: call <4 x i32> @llvm.ppc.altivec.vslo
2481   // CHECK: call <4 x i32> @llvm.ppc.altivec.vsl
2482   // CHECK: shufflevector <2 x i64> {{%.*}}, <2 x i64> {{%.*}}, <2 x i32> <i32 1, i32 3>
2483   // CHECK-LE: urem <2 x i64> {{%.*}}, <i64 64, i64 64>
2484   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vslo
2485   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vsl
2486   // CHECK-LE: shufflevector <2 x i64> {{%.*}}, <2 x i64> {{%.*}}, <2 x i32> <i32 1, i32 0>
2487   // CHECK-LE: shufflevector <2 x i64> {{%.*}}, <2 x i64> {{%.*}}, <2 x i32> <i32 1, i32 0>
2488   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vslo
2489   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vsl
2490   // CHECK-LE: shufflevector <2 x i64> {{%.*}}, <2 x i64> {{%.*}}, <2 x i32> <i32 0, i32 2>
2491   dummy();
2492   // CHECK: call void @dummy()
2493   // CHECK-LE: call void @dummy()
2494
2495   res_vsll = vec_sr(vsll, vull);
2496   // CHECK: urem <2 x i64> {{%.*}}, <i64 64, i64 64>
2497   // CHECK: shufflevector <2 x i64> {{%.*}}, <2 x i64> {{%.*}}, <2 x i32> <i32 1, i32 0>
2498   // CHECK: call <4 x i32> @llvm.ppc.altivec.vsro
2499   // CHECK: call <4 x i32> @llvm.ppc.altivec.vsr
2500   // CHECK: shufflevector <2 x i64> {{%.*}}, <2 x i64> {{%.*}}, <2 x i32> <i32 1, i32 0>
2501   // CHECK: call <4 x i32> @llvm.ppc.altivec.vsro
2502   // CHECK: call <4 x i32> @llvm.ppc.altivec.vsr
2503   // CHECK: shufflevector <2 x i64> {{%.*}}, <2 x i64> {{%.*}}, <2 x i32> <i32 0, i32 2>
2504   // CHECK-LE: urem <2 x i64> {{%.*}}, <i64 64, i64 64>
2505   // CHECK-LE: shufflevector <2 x i64> {{%.*}}, <2 x i64> {{%.*}}, <2 x i32> <i32 1, i32 0>
2506   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vsro
2507   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vsr
2508   // CHECK-LE: shufflevector <2 x i64> {{%.*}}, <2 x i64> {{%.*}}, <2 x i32> <i32 1, i32 0>
2509   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vsro
2510   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vsr
2511   // CHECK-LE: shufflevector <2 x i64> {{%.*}}, <2 x i64> {{%.*}}, <2 x i32> <i32 1, i32 3>
2512   res_vull = vec_sr(vull, vull);
2513   // CHECK: urem <2 x i64> {{%.*}}, <i64 64, i64 64>
2514   // CHECK: shufflevector <2 x i64> {{%.*}}, <2 x i64> {{%.*}}, <2 x i32> <i32 1, i32 0>
2515   // CHECK: call <4 x i32> @llvm.ppc.altivec.vsro
2516   // CHECK: call <4 x i32> @llvm.ppc.altivec.vsr
2517   // CHECK: shufflevector <2 x i64> {{%.*}}, <2 x i64> {{%.*}}, <2 x i32> <i32 1, i32 0>
2518   // CHECK: call <4 x i32> @llvm.ppc.altivec.vsro
2519   // CHECK: call <4 x i32> @llvm.ppc.altivec.vsr
2520   // CHECK: shufflevector <2 x i64> {{%.*}}, <2 x i64> {{%.*}}, <2 x i32> <i32 0, i32 2>
2521   // CHECK-LE: urem <2 x i64> {{%.*}}, <i64 64, i64 64>
2522   // CHECK-LE: shufflevector <2 x i64> {{%.*}}, <2 x i64> {{%.*}}, <2 x i32> <i32 1, i32 0>
2523   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vsro
2524   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vsr
2525   // CHECK-LE: shufflevector <2 x i64> {{%.*}}, <2 x i64> {{%.*}}, <2 x i32> <i32 1, i32 0>
2526   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vsro
2527   // CHECK-LE: call <4 x i32> @llvm.ppc.altivec.vsr
2528   // CHECK-LE: shufflevector <2 x i64> {{%.*}}, <2 x i64> {{%.*}}, <2 x i32> <i32 1, i32 3>
2529   dummy();
2530   // CHECK: call void @dummy()
2531   // CHECK-LE: call void @dummy()
2532
2533   res_vsll = vec_sra(vsll, vull);
2534   // CHECK: urem <2 x i64> {{%.*}}, <i64 64, i64 64>
2535   // CHECK: ashr <2 x i64>
2536   // CHECK-LE: urem <2 x i64> {{%.*}}, <i64 64, i64 64>
2537   // CHECK-LE: ashr <2 x i64>
2538   res_vull = vec_sra(vull, vull);
2539   // CHECK: urem <2 x i64> {{%.*}}, <i64 64, i64 64>
2540   // CHECK: ashr <2 x i64>
2541   // CHECK-LE: urem <2 x i64> {{%.*}}, <i64 64, i64 64>
2542   // CHECK-LE: ashr <2 x i64>
2543
2544   /* ----------------------- predicates --------------------------- */
2545   /* vec_all_eq */
2546   res_i = vec_all_eq(vsll, vsll);
2547   // CHECK: xor <2 x i64>
2548   // CHECK: @llvm.ppc.altivec.vcmpequw.p
2549   // CHECK-LE: xor <2 x i64>
2550   // CHECK-LE: @llvm.ppc.altivec.vcmpequw.p
2551
2552   res_i = vec_all_eq(vsll, vbll);
2553   // CHECK: xor <2 x i64>
2554   // CHECK: @llvm.ppc.altivec.vcmpequw.p
2555   // CHECK-LE: xor <2 x i64>
2556   // CHECK-LE: @llvm.ppc.altivec.vcmpequw.p
2557
2558   res_i = vec_all_eq(vull, vull);
2559   // CHECK: xor <2 x i64>
2560   // CHECK: @llvm.ppc.altivec.vcmpequw.p
2561   // CHECK-LE: xor <2 x i64>
2562   // CHECK-LE: @llvm.ppc.altivec.vcmpequw.p
2563
2564   res_i = vec_all_eq(vull, vbll);
2565   // CHECK: xor <2 x i64>
2566   // CHECK: @llvm.ppc.altivec.vcmpequw.p
2567   // CHECK-LE: xor <2 x i64>
2568   // CHECK-LE: @llvm.ppc.altivec.vcmpequw.p
2569
2570   res_i = vec_all_eq(vbll, vsll);
2571   // CHECK: xor <2 x i64>
2572   // CHECK: @llvm.ppc.altivec.vcmpequw.p
2573   // CHECK-LE: xor <2 x i64>
2574   // CHECK-LE: @llvm.ppc.altivec.vcmpequw.p
2575
2576   res_i = vec_all_eq(vbll, vull);
2577   // CHECK: xor <2 x i64>
2578   // CHECK: @llvm.ppc.altivec.vcmpequw.p
2579   // CHECK-LE: xor <2 x i64>
2580   // CHECK-LE: @llvm.ppc.altivec.vcmpequw.p
2581
2582   res_i = vec_all_eq(vbll, vbll);
2583   // CHECK: xor <2 x i64>
2584   // CHECK: @llvm.ppc.altivec.vcmpequw.p
2585   // CHECK-LE: xor <2 x i64>
2586   // CHECK-LE: @llvm.ppc.altivec.vcmpequw.p
2587
2588   /* vec_all_ne */
2589   res_i = vec_all_ne(vsll, vsll);
2590   // CHECK: @llvm.ppc.altivec.vcmpequd.p
2591   // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
2592
2593   res_i = vec_all_ne(vsll, vbll);
2594   // CHECK: @llvm.ppc.altivec.vcmpequd.p
2595   // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
2596
2597   res_i = vec_all_ne(vull, vull);
2598   // CHECK: @llvm.ppc.altivec.vcmpequd.p
2599   // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
2600
2601   res_i = vec_all_ne(vull, vbll);
2602   // CHECK: @llvm.ppc.altivec.vcmpequd.p
2603   // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
2604
2605   res_i = vec_all_ne(vbll, vsll);
2606   // CHECK: @llvm.ppc.altivec.vcmpequd.p
2607   // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
2608
2609   res_i = vec_all_ne(vbll, vull);
2610   // CHECK: @llvm.ppc.altivec.vcmpequd.p
2611   // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
2612
2613   res_i = vec_all_ne(vbll, vbll);
2614   // CHECK: @llvm.ppc.altivec.vcmpequd.p
2615   // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
2616
2617   dummy();
2618   // CHECK: @dummy
2619
2620   /* vec_any_eq */
2621   res_i = vec_any_eq(vsll, vsll);
2622   // CHECK: @llvm.ppc.altivec.vcmpequd.p
2623   // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
2624
2625   res_i = vec_any_eq(vsll, vbll);
2626   // CHECK: @llvm.ppc.altivec.vcmpequd.p
2627   // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
2628
2629   res_i = vec_any_eq(vull, vull);
2630   // CHECK: @llvm.ppc.altivec.vcmpequd.p
2631   // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
2632
2633   res_i = vec_any_eq(vull, vbll);
2634   // CHECK: @llvm.ppc.altivec.vcmpequd.p
2635   // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
2636
2637   res_i = vec_any_eq(vbll, vsll);
2638   // CHECK: @llvm.ppc.altivec.vcmpequd.p
2639   // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
2640
2641   res_i = vec_any_eq(vbll, vull);
2642   // CHECK: @llvm.ppc.altivec.vcmpequd.p
2643   // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
2644
2645   res_i = vec_any_eq(vbll, vbll);
2646   // CHECK: @llvm.ppc.altivec.vcmpequd.p
2647   // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
2648
2649   /* vec_any_ne */
2650   res_i = vec_any_ne(vsll, vsll);
2651   // CHECK: xor <2 x i64>
2652   // CHECK: @llvm.ppc.altivec.vcmpequw.p
2653   // CHECK: xor i1
2654   // CHECK-LE: xor <2 x i64>
2655   // CHECK-LE: @llvm.ppc.altivec.vcmpequw.p
2656   // CHECK-LE: xor i1
2657
2658   res_i = vec_any_ne(vsll, vbll);
2659   // CHECK: xor <2 x i64>
2660   // CHECK: @llvm.ppc.altivec.vcmpequw.p
2661   // CHECK: xor i1
2662   // CHECK-LE: xor <2 x i64>
2663   // CHECK-LE: @llvm.ppc.altivec.vcmpequw.p
2664   // CHECK-LE: xor i1
2665
2666   res_i = vec_any_ne(vull, vull);
2667   // CHECK: xor <2 x i64>
2668   // CHECK: @llvm.ppc.altivec.vcmpequw.p
2669   // CHECK: xor i1
2670   // CHECK-LE: xor <2 x i64>
2671   // CHECK-LE: @llvm.ppc.altivec.vcmpequw.p
2672   // CHECK-LE: xor i1
2673
2674   res_i = vec_any_ne(vull, vbll);
2675   // CHECK: xor <2 x i64>
2676   // CHECK: @llvm.ppc.altivec.vcmpequw.p
2677   // CHECK: xor i1
2678   // CHECK-LE: xor <2 x i64>
2679   // CHECK-LE: @llvm.ppc.altivec.vcmpequw.p
2680   // CHECK-LE: xor i1
2681
2682   res_i = vec_any_ne(vbll, vsll);
2683   // CHECK: xor <2 x i64>
2684   // CHECK: @llvm.ppc.altivec.vcmpequw.p
2685   // CHECK: xor i1
2686   // CHECK-LE: xor <2 x i64>
2687   // CHECK-LE: @llvm.ppc.altivec.vcmpequw.p
2688   // CHECK-LE: xor i1
2689
2690   res_i = vec_any_ne(vbll, vull);
2691   // CHECK: xor <2 x i64>
2692   // CHECK: @llvm.ppc.altivec.vcmpequw.p
2693   // CHECK: xor i1
2694   // CHECK-LE: xor <2 x i64>
2695   // CHECK-LE: @llvm.ppc.altivec.vcmpequw.p
2696   // CHECK-LE: xor i1
2697
2698   res_i = vec_any_ne(vbll, vbll);
2699   // CHECK: xor <2 x i64>
2700   // CHECK: @llvm.ppc.altivec.vcmpequw.p
2701   // CHECK: xor i1
2702   // CHECK-LE: xor <2 x i64>
2703   // CHECK-LE: @llvm.ppc.altivec.vcmpequw.p
2704   // CHECK-LE: xor i1
2705
2706   /* vec_all_ge */
2707   res_i = vec_all_ge(vsll, vsll);
2708   // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
2709   // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
2710
2711   res_i = vec_all_ge(vsll, vbll);
2712   // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
2713   // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
2714
2715   res_i = vec_all_ge(vull, vull);
2716   // CHECK: @llvm.ppc.altivec.vcmpgtud.p
2717   // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
2718
2719   res_i = vec_all_ge(vull, vbll);
2720   // CHECK: @llvm.ppc.altivec.vcmpgtud.p
2721   // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
2722
2723   res_i = vec_all_ge(vbll, vsll);
2724   // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
2725   // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
2726
2727   res_i = vec_all_ge(vbll, vull);
2728   // CHECK: @llvm.ppc.altivec.vcmpgtud.p
2729   // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
2730
2731   res_i = vec_all_ge(vbll, vbll);
2732   // CHECK: @llvm.ppc.altivec.vcmpgtud.p
2733   // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
2734
2735   /* vec_all_gt */
2736   res_i = vec_all_gt(vsll, vsll);
2737   // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
2738   // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
2739
2740   res_i = vec_all_gt(vsll, vbll);
2741   // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
2742   // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
2743
2744   res_i = vec_all_gt(vull, vull);
2745   // CHECK: @llvm.ppc.altivec.vcmpgtud.p
2746   // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
2747
2748   res_i = vec_all_gt(vull, vbll);
2749   // CHECK: @llvm.ppc.altivec.vcmpgtud.p
2750   // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
2751
2752   res_i = vec_all_gt(vbll, vsll);
2753   // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
2754   // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
2755
2756   res_i = vec_all_gt(vbll, vull);
2757   // CHECK: @llvm.ppc.altivec.vcmpgtud.p
2758   // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
2759
2760   res_i = vec_all_gt(vbll, vbll);
2761   // CHECK: @llvm.ppc.altivec.vcmpgtud.p
2762   // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
2763
2764   /* vec_all_le */
2765   res_i = vec_all_le(vsll, vsll);
2766   // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
2767   // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
2768
2769   res_i = vec_all_le(vsll, vbll);
2770   // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
2771   // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
2772
2773   res_i = vec_all_le(vull, vull);
2774   // CHECK: @llvm.ppc.altivec.vcmpgtud.p
2775   // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
2776
2777   res_i = vec_all_le(vull, vbll);
2778   // CHECK: @llvm.ppc.altivec.vcmpgtud.p
2779   // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
2780
2781   res_i = vec_all_le(vbll, vsll);
2782   // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
2783   // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
2784
2785   res_i = vec_all_le(vbll, vull);
2786   // CHECK: @llvm.ppc.altivec.vcmpgtud.p
2787   // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
2788
2789   res_i = vec_all_le(vbll, vbll);
2790   // CHECK: @llvm.ppc.altivec.vcmpgtud.p
2791   // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
2792
2793   /* vec_all_lt */
2794   res_i = vec_all_lt(vsll, vsll);
2795   // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
2796   // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
2797
2798   res_i = vec_all_lt(vsll, vbll);
2799   // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
2800   // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
2801
2802   res_i = vec_all_lt(vull, vull);
2803   // CHECK: @llvm.ppc.altivec.vcmpgtud.p
2804   // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
2805
2806   res_i = vec_all_lt(vull, vbll);
2807   // CHECK: @llvm.ppc.altivec.vcmpgtud.p
2808   // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
2809
2810   res_i = vec_all_lt(vbll, vsll);
2811   // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
2812   // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
2813
2814   res_i = vec_all_lt(vbll, vull);
2815   // CHECK: @llvm.ppc.altivec.vcmpgtud.p
2816   // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
2817
2818   res_i = vec_all_lt(vbll, vbll);
2819   // CHECK: @llvm.ppc.altivec.vcmpgtud.p
2820   // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
2821
2822   /* vec_any_ge */
2823   res_i = vec_any_ge(vsll, vsll);
2824   // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
2825   // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
2826
2827   res_i = vec_any_ge(vsll, vbll);
2828   // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
2829   // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
2830
2831   res_i = vec_any_ge(vull, vull);
2832   // CHECK: @llvm.ppc.altivec.vcmpgtud.p
2833   // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
2834
2835   res_i = vec_any_ge(vull, vbll);
2836   // CHECK: @llvm.ppc.altivec.vcmpgtud.p
2837   // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
2838
2839   res_i = vec_any_ge(vbll, vsll);
2840   // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
2841   // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
2842
2843   res_i = vec_any_ge(vbll, vull);
2844   // CHECK: @llvm.ppc.altivec.vcmpgtud.p
2845   // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
2846
2847   res_i = vec_any_ge(vbll, vbll);
2848   // CHECK: @llvm.ppc.altivec.vcmpgtud.p
2849   // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
2850
2851   /* vec_any_gt */
2852   res_i = vec_any_gt(vsll, vsll);
2853   // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
2854   // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
2855
2856   res_i = vec_any_gt(vsll, vbll);
2857   // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
2858   // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
2859
2860   res_i = vec_any_gt(vull, vull);
2861   // CHECK: @llvm.ppc.altivec.vcmpgtud.p
2862   // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
2863
2864   res_i = vec_any_gt(vull, vbll);
2865   // CHECK: @llvm.ppc.altivec.vcmpgtud.p
2866   // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
2867
2868   res_i = vec_any_gt(vbll, vsll);
2869   // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
2870   // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
2871
2872   res_i = vec_any_gt(vbll, vull);
2873   // CHECK: @llvm.ppc.altivec.vcmpgtud.p
2874   // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
2875
2876   res_i = vec_any_gt(vbll, vbll);
2877   // CHECK: @llvm.ppc.altivec.vcmpgtud.p
2878   // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
2879
2880   /* vec_any_le */
2881   res_i = vec_any_le(vsll, vsll);
2882   // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
2883   // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
2884
2885   res_i = vec_any_le(vsll, vbll);
2886   // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
2887   // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
2888
2889   res_i = vec_any_le(vull, vull);
2890   // CHECK: @llvm.ppc.altivec.vcmpgtud.p
2891   // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
2892
2893   res_i = vec_any_le(vull, vbll);
2894   // CHECK: @llvm.ppc.altivec.vcmpgtud.p
2895   // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
2896
2897   res_i = vec_any_le(vbll, vsll);
2898   // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
2899   // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
2900
2901   res_i = vec_any_le(vbll, vull);
2902   // CHECK: @llvm.ppc.altivec.vcmpgtud.p
2903   // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
2904
2905   res_i = vec_any_le(vbll, vbll);
2906   // CHECK: @llvm.ppc.altivec.vcmpgtud.p
2907   // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
2908
2909   /* vec_any_lt */
2910   res_i = vec_any_lt(vsll, vsll);
2911   // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
2912   // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
2913
2914   res_i = vec_any_lt(vsll, vbll);
2915   // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
2916   // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
2917
2918   res_i = vec_any_lt(vull, vull);
2919   // CHECK: @llvm.ppc.altivec.vcmpgtud.p
2920   // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
2921
2922   res_i = vec_any_lt(vull, vbll);
2923   // CHECK: @llvm.ppc.altivec.vcmpgtud.p
2924   // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
2925
2926   res_i = vec_any_lt(vbll, vsll);
2927   // CHECK: @llvm.ppc.altivec.vcmpgtsd.p
2928   // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
2929
2930   res_i = vec_any_lt(vbll, vull);
2931   // CHECK: @llvm.ppc.altivec.vcmpgtud.p
2932   // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
2933
2934   res_i = vec_any_lt(vbll, vbll);
2935   // CHECK: @llvm.ppc.altivec.vcmpgtud.p
2936   // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
2937 }