1 // REQUIRES: powerpc-registered-target 2 // RUN: %clang_cc1 -faltivec -target-feature +power8-vector -triple powerpc64-unknown-unknown -emit-llvm %s -o - | FileCheck %s 3 // RUN: %clang_cc1 -faltivec -target-feature +power8-vector -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-LE 4 // RUN: not %clang_cc1 -faltivec -target-feature +vsx -triple powerpc64-unknown-unknown -emit-llvm %s -o - 2>&1 | FileCheck %s -check-prefix=CHECK-PPC 5 // Added -target-feature +vsx above to avoid errors about "vector double" and to 6 // generate the correct errors for functions that are only overloaded with VSX 7 // (vec_cmpge, vec_cmple). Without this option, there is only one overload so 8 // it is selected. 9 #include <altivec.h> 10 11 void dummy() { } 12 signed int si; 13 signed long long sll; 14 unsigned long long ull; 15 signed __int128 sx; 16 unsigned __int128 ux; 17 double d; 18 vector signed char vsc = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5 }; 19 vector unsigned char vuc = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5 }; 20 vector bool char vbc = { 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1 }; 21 22 vector signed short vss = { 0, 1, 2, 3, 4, 5, 6, 7 }; 23 vector unsigned short vus = { 0, 1, 2, 3, 4, 5, 6, 7 }; 24 vector bool short vbs = { 1, 1, 0, 0, 0, 0, 1, 1 }; 25 26 vector signed int vsi = { -1, 2, -3, 4 }; 27 vector unsigned int vui = { 1, 2, 3, 4 }; 28 vector bool int vbi = {0, -1, -1, 0}; 29 30 vector signed long long vsll = { 1, 2 }; 31 vector unsigned long long vull = { 1, 2 }; 32 vector bool long long vbll = { 1, 0 }; 33 34 vector signed __int128 vsx = { 1 }; 35 vector unsigned __int128 vux = { 1 }; 36 37 vector float vfa = { 1.e-4f, -132.23f, -22.1, 32.00f }; 38 vector double vda = { 1.e-11, -132.23e10 }; 39 40 int res_i; 41 double res_d; 42 signed long long res_sll; 43 unsigned long long res_ull; 44 45 vector signed char res_vsc; 46 vector unsigned char res_vuc; 47 vector bool char res_vbc; 48 49 vector signed short res_vss; 50 vector unsigned short res_vus; 51 vector bool short res_vbs; 52 53 vector signed int res_vsi; 54 vector unsigned int res_vui; 55 vector bool int res_vbi; 56 57 vector signed long long res_vsll; 58 vector unsigned long long res_vull; 59 vector bool long long res_vbll; 60 61 vector signed __int128 res_vsx; 62 vector unsigned __int128 res_vux; 63 64 vector float res_vf; 65 vector double res_vd; 66 67 // CHECK-LABEL: define void @test1 68 void test1() { 69 70 /* vec_abs */ 71 res_vsll = vec_abs(vsll); 72 // CHECK: call <2 x i64> @llvm.ppc.altivec.vmaxsd(<2 x i64> %{{[0-9]*}}, <2 x i64> 73 // CHECK-LE: call <2 x i64> @llvm.ppc.altivec.vmaxsd(<2 x i64> %{{[0-9]*}}, <2 x i64> 74 // CHECK-PPC: error: call to 'vec_abs' is ambiguous 75 76 res_vd = vec_abs(vda); 77 // CHECK: call <2 x double> @llvm.fabs.v2f64(<2 x double> %{{.*}}) 78 // CHECK: store <2 x double> %{{.*}}, <2 x double>* @res_vd 79 // CHECK-LE: call <2 x double> @llvm.fabs.v2f64(<2 x double> %{{.*}}) 80 // CHECK-LE: store <2 x double> %{{.*}}, <2 x double>* @res_vd 81 // CHECK-PPC: error: call to 'vec_abs' is ambiguous 82 83 /* vec_add */ 84 res_vsll = vec_add(vsll, vsll); 85 // CHECK: add <2 x i64> 86 // CHECK-LE: add <2 x i64> 87 // CHECK-PPC: error: call to 'vec_add' is ambiguous 88 89 res_vull = vec_add(vull, vull); 90 // CHECK: add <2 x i64> 91 // CHECK-LE: add <2 x i64> 92 // CHECK-PPC: error: call to 'vec_add' is ambiguous 93 94 /* vec_addc */ 95 res_vsi = vec_addc(vsi, vsi); 96 // CHECK: @llvm.ppc.altivec.vaddcuw 97 // CHECK-LE: @llvm.ppc.altivec.vaddcuw 98 99 res_vui = vec_addc(vui, vui); 100 // CHECK: @llvm.ppc.altivec.vaddcuw 101 // CHECK-LE: @llvm.ppc.altivec.vaddcuw 102 103 res_vsx = vec_addc(vsx, vsx); 104 // CHECK: @llvm.ppc.altivec.vaddcuq 105 // CHECK-LE: @llvm.ppc.altivec.vaddcuq 106 107 res_vux = vec_addc(vux, vux); 108 // CHECK: @llvm.ppc.altivec.vaddcuq 109 // CHECK-LE: @llvm.ppc.altivec.vaddcuq 110 111 /* vec_adde */ 112 res_vsx = vec_adde(vsx, vsx, vsx); 113 // CHECK: @llvm.ppc.altivec.vaddeuqm 114 // CHECK-LE: @llvm.ppc.altivec.vaddeuqm 115 116 res_vux = vec_adde(vux, vux, vux); 117 // CHECK: @llvm.ppc.altivec.vaddeuqm 118 // CHECK-LE: @llvm.ppc.altivec.vaddeuqm 119 120 /* vec_addec */ 121 res_vsx = vec_addec(vsx, vsx, vsx); 122 // CHECK: @llvm.ppc.altivec.vaddecuq 123 // CHECK-LE: @llvm.ppc.altivec.vaddecuq 124 125 /* vec_mergee */ 126 res_vbi = vec_mergee(vbi, vbi); 127 // CHECK: @llvm.ppc.altivec.vperm 128 // CHECK-LE: @llvm.ppc.altivec.vperm 129 130 res_vsi = vec_mergee(vsi, vsi); 131 // CHECK: @llvm.ppc.altivec.vperm 132 // CHECK-LE: @llvm.ppc.altivec.vperm 133 134 res_vui = vec_mergee(vui, vui); 135 // CHECK: @llvm.ppc.altivec.vperm 136 // CHECK-LE: @llvm.ppc.altivec.vperm 137 // CHECK-PPC: warning: implicit declaration of function 'vec_mergee' 138 139 /* vec_mergeo */ 140 res_vbi = vec_mergeo(vbi, vbi); 141 // CHECK: @llvm.ppc.altivec.vperm 142 // CHECK-LE: @llvm.ppc.altivec.vperm 143 144 res_vsi = vec_mergeo(vsi, vsi); 145 // CHECK: @llvm.ppc.altivec.vperm 146 // CHECK-LE: @llvm.ppc.altivec.vperm 147 148 res_vui = vec_mergeo(vui, vui); 149 // CHECK: @llvm.ppc.altivec.vperm 150 // CHECK-LE: @llvm.ppc.altivec.vperm 151 // CHECK-PPC: warning: implicit declaration of function 'vec_mergeo' 152 153 /* vec_cmpeq */ 154 res_vbll = vec_cmpeq(vsll, vsll); 155 // CHECK: @llvm.ppc.altivec.vcmpequd 156 // CHECK-LE: @llvm.ppc.altivec.vcmpequd 157 // CHECK-PPC: error: call to 'vec_cmpeq' is ambiguous 158 159 res_vbll = vec_cmpeq(vull, vull); 160 // CHECK: @llvm.ppc.altivec.vcmpequd 161 // CHECK-LE: @llvm.ppc.altivec.vcmpequd 162 // CHECK-PPC: error: call to 'vec_cmpeq' is ambiguous 163 164 /* vec_cmpge */ 165 res_vbll = vec_cmpge(vsll, vsll); 166 // CHECK: @llvm.ppc.altivec.vcmpgtsd 167 // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd 168 // CHECK-PPC: error: call to 'vec_cmpge' is ambiguous 169 170 res_vbll = vec_cmpge(vull, vull); 171 // CHECK: @llvm.ppc.altivec.vcmpgtud 172 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud 173 // CHECK-PPC: error: call to 'vec_cmpge' is ambiguous 174 175 /* vec_cmple */ 176 res_vbll = vec_cmple(vsll, vsll); 177 // CHECK: @llvm.ppc.altivec.vcmpgtsd 178 // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd 179 // CHECK-PPC: error: call to 'vec_cmple' is ambiguous 180 181 res_vbll = vec_cmple(vull, vull); 182 // CHECK: @llvm.ppc.altivec.vcmpgtud 183 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud 184 // CHECK-PPC: error: call to 'vec_cmple' is ambiguous 185 186 /* vec_cmpgt */ 187 res_vbll = vec_cmpgt(vsll, vsll); 188 // CHECK: @llvm.ppc.altivec.vcmpgtsd 189 // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd 190 // CHECK-PPC: error: call to 'vec_cmpgt' is ambiguous 191 192 res_vbll = vec_cmpgt(vull, vull); 193 // CHECK: @llvm.ppc.altivec.vcmpgtud 194 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud 195 // CHECK-PPC: error: call to 'vec_cmpgt' is ambiguous 196 197 /* vec_cmplt */ 198 res_vbll = vec_cmplt(vsll, vsll); 199 // CHECK: call <2 x i64> @llvm.ppc.altivec.vcmpgtsd(<2 x i64> %{{[0-9]*}}, <2 x i64> %{{[0-9]*}}) 200 // CHECK-LE: call <2 x i64> @llvm.ppc.altivec.vcmpgtsd(<2 x i64> %{{[0-9]*}}, <2 x i64> %{{[0-9]*}}) 201 // CHECK-PPC: error: call to 'vec_cmplt' is ambiguous 202 203 res_vbll = vec_cmplt(vull, vull); 204 // CHECK: call <2 x i64> @llvm.ppc.altivec.vcmpgtud(<2 x i64> %{{[0-9]*}}, <2 x i64> %{{[0-9]*}}) 205 // CHECK-LE: call <2 x i64> @llvm.ppc.altivec.vcmpgtud(<2 x i64> %{{[0-9]*}}, <2 x i64> %{{[0-9]*}}) 206 // CHECK-PPC: error: call to 'vec_cmplt' is ambiguous 207 208 /* vec_double */ 209 res_vd = vec_double(vsll); 210 // CHECK: sitofp i64 {{.+}} to double 211 // CHECK-BE: sitofp i64 {{.+}} to double 212 213 res_vd = vec_double(vull); 214 // CHECK: uitofp i64 {{.+}} to double 215 // CHECK-BE: uitofp i64 {{.+}} to double 216 217 /* vec_eqv */ 218 res_vsc = vec_eqv(vsc, vsc); 219 // CHECK: [[T1:%.+]] = bitcast <16 x i8> {{.+}} to <4 x i32> 220 // CHECK: [[T2:%.+]] = bitcast <16 x i8> {{.+}} to <4 x i32> 221 // CHECK: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]]) 222 // CHECK: bitcast <4 x i32> [[T3]] to <16 x i8> 223 // CHECK-LE: [[T1:%.+]] = bitcast <16 x i8> {{.+}} to <4 x i32> 224 // CHECK-LE: [[T2:%.+]] = bitcast <16 x i8> {{.+}} to <4 x i32> 225 // CHECK-LE: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]]) 226 // CHECK-LE: bitcast <4 x i32> [[T3]] to <16 x i8> 227 // CHECK-PPC: error: assigning to 228 229 res_vsc = vec_eqv(vbc, vbc); 230 // CHECK: [[T1:%.+]] = bitcast <16 x i8> {{.+}} to <4 x i32> 231 // CHECK: [[T2:%.+]] = bitcast <16 x i8> {{.+}} to <4 x i32> 232 // CHECK: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]]) 233 // CHECK: bitcast <4 x i32> [[T3]] to <16 x i8> 234 // CHECK-LE: [[T1:%.+]] = bitcast <16 x i8> {{.+}} to <4 x i32> 235 // CHECK-LE: [[T2:%.+]] = bitcast <16 x i8> {{.+}} to <4 x i32> 236 // CHECK-LE: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]]) 237 // CHECK-LE: bitcast <4 x i32> [[T3]] to <16 x i8> 238 // CHECK-PPC: error: assigning to 239 240 res_vuc = vec_eqv(vuc, vuc); 241 // CHECK: [[T1:%.+]] = bitcast <16 x i8> {{.+}} to <4 x i32> 242 // CHECK: [[T2:%.+]] = bitcast <16 x i8> {{.+}} to <4 x i32> 243 // CHECK: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]]) 244 // CHECK: bitcast <4 x i32> [[T3]] to <16 x i8> 245 // CHECK-LE: [[T1:%.+]] = bitcast <16 x i8> {{.+}} to <4 x i32> 246 // CHECK-LE: [[T2:%.+]] = bitcast <16 x i8> {{.+}} to <4 x i32> 247 // CHECK-LE: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]]) 248 // CHECK-LE: bitcast <4 x i32> [[T3]] to <16 x i8> 249 // CHECK-PPC: error: assigning to 250 251 res_vss = vec_eqv(vss, vss); 252 // CHECK: [[T1:%.+]] = bitcast <8 x i16> {{.+}} to <4 x i32> 253 // CHECK: [[T2:%.+]] = bitcast <8 x i16> {{.+}} to <4 x i32> 254 // CHECK: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]]) 255 // CHECK: bitcast <4 x i32> [[T3]] to <8 x i16> 256 // CHECK-LE: [[T1:%.+]] = bitcast <8 x i16> {{.+}} to <4 x i32> 257 // CHECK-LE: [[T2:%.+]] = bitcast <8 x i16> {{.+}} to <4 x i32> 258 // CHECK-LE: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]]) 259 // CHECK-LE: bitcast <4 x i32> [[T3]] to <8 x i16> 260 // CHECK-PPC: error: assigning to 261 262 res_vss = vec_eqv(vbs, vbs); 263 // CHECK: [[T1:%.+]] = bitcast <8 x i16> {{.+}} to <4 x i32> 264 // CHECK: [[T2:%.+]] = bitcast <8 x i16> {{.+}} to <4 x i32> 265 // CHECK: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]]) 266 // CHECK: bitcast <4 x i32> [[T3]] to <8 x i16> 267 // CHECK-LE: [[T1:%.+]] = bitcast <8 x i16> {{.+}} to <4 x i32> 268 // CHECK-LE: [[T2:%.+]] = bitcast <8 x i16> {{.+}} to <4 x i32> 269 // CHECK-LE: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]]) 270 // CHECK-LE: bitcast <4 x i32> [[T3]] to <8 x i16> 271 // CHECK-PPC: error: assigning to 272 273 res_vus = vec_eqv(vus, vus); 274 // CHECK: [[T1:%.+]] = bitcast <8 x i16> {{.+}} to <4 x i32> 275 // CHECK: [[T2:%.+]] = bitcast <8 x i16> {{.+}} to <4 x i32> 276 // CHECK: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]]) 277 // CHECK: bitcast <4 x i32> [[T3]] to <8 x i16> 278 // CHECK-LE: [[T1:%.+]] = bitcast <8 x i16> {{.+}} to <4 x i32> 279 // CHECK-LE: [[T2:%.+]] = bitcast <8 x i16> {{.+}} to <4 x i32> 280 // CHECK-LE: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]]) 281 // CHECK-LE: bitcast <4 x i32> [[T3]] to <8 x i16> 282 // CHECK-PPC: error: assigning to 283 284 res_vsi = vec_eqv(vsi, vsi); 285 // CHECK: call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> {{.*}}, <4 x i32> {{.+}}) 286 // CHECK-LE: call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> {{.*}}, <4 x i32> {{.+}}) 287 // CHECK-PPC: error: assigning to 288 289 res_vsi = vec_eqv(vbi, vbi); 290 // CHECK: call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> {{.*}}, <4 x i32> {{.+}}) 291 // CHECK-LE: call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> {{.*}}, <4 x i32> {{.+}}) 292 // CHECK-PPC: error: assigning to 293 294 res_vui = vec_eqv(vui, vui); 295 // CHECK: call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> {{.*}}, <4 x i32> {{.+}}) 296 // CHECK-LE: call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> {{.*}}, <4 x i32> {{.+}}) 297 // CHECK-PPC: error: assigning to 298 299 res_vsll = vec_eqv(vsll, vsll); 300 // CHECK: [[T1:%.+]] = bitcast <2 x i64> {{.+}} to <4 x i32> 301 // CHECK: [[T2:%.+]] = bitcast <2 x i64> {{.+}} to <4 x i32> 302 // CHECK: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]]) 303 // CHECK: bitcast <4 x i32> [[T3]] to <2 x i64> 304 // CHECK-LE: [[T1:%.+]] = bitcast <2 x i64> {{.+}} to <4 x i32> 305 // CHECK-LE: [[T2:%.+]] = bitcast <2 x i64> {{.+}} to <4 x i32> 306 // CHECK-LE: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]]) 307 // CHECK-LE: bitcast <4 x i32> [[T3]] to <2 x i64> 308 // CHECK-PPC: error: assigning to 309 310 res_vsll = vec_eqv(vbll, vbll); 311 // CHECK: [[T1:%.+]] = bitcast <2 x i64> {{.+}} to <4 x i32> 312 // CHECK: [[T2:%.+]] = bitcast <2 x i64> {{.+}} to <4 x i32> 313 // CHECK: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]]) 314 // CHECK: bitcast <4 x i32> [[T3]] to <2 x i64> 315 // CHECK-LE: [[T1:%.+]] = bitcast <2 x i64> {{.+}} to <4 x i32> 316 // CHECK-LE: [[T2:%.+]] = bitcast <2 x i64> {{.+}} to <4 x i32> 317 // CHECK-LE: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]]) 318 // CHECK-LE: bitcast <4 x i32> [[T3]] to <2 x i64> 319 // CHECK-PPC: error: assigning to 320 321 res_vull = vec_eqv(vull, vull); 322 // CHECK: [[T1:%.+]] = bitcast <2 x i64> {{.+}} to <4 x i32> 323 // CHECK: [[T2:%.+]] = bitcast <2 x i64> {{.+}} to <4 x i32> 324 // CHECK: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]]) 325 // CHECK: bitcast <4 x i32> [[T3]] to <2 x i64> 326 // CHECK-LE: [[T1:%.+]] = bitcast <2 x i64> {{.+}} to <4 x i32> 327 // CHECK-LE: [[T2:%.+]] = bitcast <2 x i64> {{.+}} to <4 x i32> 328 // CHECK-LE: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]]) 329 // CHECK-LE: bitcast <4 x i32> [[T3]] to <2 x i64> 330 // CHECK-PPC: error: assigning to 331 332 res_vf = vec_eqv(vfa, vfa); 333 // CHECK: [[T1:%.+]] = bitcast <4 x float> {{.+}} to <4 x i32> 334 // CHECK: [[T2:%.+]] = bitcast <4 x float> {{.+}} to <4 x i32> 335 // CHECK: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]]) 336 // CHECK: bitcast <4 x i32> [[T3]] to <4 x float> 337 // CHECK-LE: [[T1:%.+]] = bitcast <4 x float> {{.+}} to <4 x i32> 338 // CHECK-LE: [[T2:%.+]] = bitcast <4 x float> {{.+}} to <4 x i32> 339 // CHECK-LE: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]]) 340 // CHECK-LE: bitcast <4 x i32> [[T3]] to <4 x float> 341 // CHECK-PPC: error: assigning to 342 343 res_vd = vec_eqv(vda, vda); 344 // CHECK: [[T1:%.+]] = bitcast <2 x double> {{.+}} to <4 x i32> 345 // CHECK: [[T2:%.+]] = bitcast <2 x double> {{.+}} to <4 x i32> 346 // CHECK: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]]) 347 // CHECK: bitcast <4 x i32> [[T3]] to <2 x double> 348 // CHECK-LE: [[T1:%.+]] = bitcast <2 x double> {{.+}} to <4 x i32> 349 // CHECK-LE: [[T2:%.+]] = bitcast <2 x double> {{.+}} to <4 x i32> 350 // CHECK-LE: [[T3:%.+]] = call <4 x i32> @llvm.ppc.vsx.xxleqv(<4 x i32> [[T1]], <4 x i32> [[T2]]) 351 // CHECK-LE: bitcast <4 x i32> [[T3]] to <2 x double> 352 // CHECK-PPC: error: assigning to 353 354 /* vec_extract */ 355 res_sll = vec_extract(vsll, si); 356 // CHECK: extractelement <2 x i64> 357 // CHECK-LE: extractelement <2 x i64> 358 359 res_ull = vec_extract(vull, si); 360 // CHECK: extractelement <2 x i64> 361 // CHECK-LE: extractelement <2 x i64> 362 363 res_ull = vec_extract(vbll, si); 364 // CHECK: extractelement <2 x i64> 365 // CHECK-LE: extractelement <2 x i64> 366 367 res_d = vec_extract(vda, si); 368 // CHECK: extractelement <2 x double> 369 // CHECK-LE: extractelement <2 x double> 370 371 /* vec_insert */ 372 res_vsll = vec_insert(sll, vsll, si); 373 // CHECK: insertelement <2 x i64> 374 // CHECK-LE: insertelement <2 x i64> 375 376 res_vbll = vec_insert(ull, vbll, si); 377 // CHECK: insertelement <2 x i64> 378 // CHECK-LE: insertelement <2 x i64> 379 380 res_vull = vec_insert(ull, vull, si); 381 // CHECK: insertelement <2 x i64> 382 // CHECK-LE: insertelement <2 x i64> 383 384 res_vd = vec_insert(d, vda, si); 385 // CHECK: insertelement <2 x double> 386 // CHECK-LE: insertelement <2 x double> 387 388 /* vec_cntlz */ 389 res_vsc = vec_cntlz(vsc); 390 // CHECK: call <16 x i8> @llvm.ctlz.v16i8(<16 x i8> %{{.+}}, i1 false) 391 // CHECK-LE: call <16 x i8> @llvm.ctlz.v16i8(<16 x i8> %{{.+}}, i1 false) 392 // CHECK-PPC: warning: implicit declaration of function 'vec_cntlz' is invalid in C99 393 394 res_vuc = vec_cntlz(vuc); 395 // CHECK: call <16 x i8> @llvm.ctlz.v16i8(<16 x i8> %{{.+}}, i1 false) 396 // CHECK-LE: call <16 x i8> @llvm.ctlz.v16i8(<16 x i8> %{{.+}}, i1 false) 397 398 res_vss = vec_cntlz(vss); 399 // CHECK: call <8 x i16> @llvm.ctlz.v8i16(<8 x i16> %{{.+}}, i1 false) 400 // CHECK-LE: call <8 x i16> @llvm.ctlz.v8i16(<8 x i16> %{{.+}}, i1 false) 401 402 res_vus = vec_cntlz(vus); 403 // CHECK: call <8 x i16> @llvm.ctlz.v8i16(<8 x i16> %{{.+}}, i1 false) 404 // CHECK-LE: call <8 x i16> @llvm.ctlz.v8i16(<8 x i16> %{{.+}}, i1 false) 405 406 res_vsi = vec_cntlz(vsi); 407 // CHECK: call <4 x i32> @llvm.ctlz.v4i32(<4 x i32> %{{.+}}, i1 false) 408 // CHECK-LE: call <4 x i32> @llvm.ctlz.v4i32(<4 x i32> %{{.+}}, i1 false) 409 410 res_vui = vec_cntlz(vui); 411 // CHECK: call <4 x i32> @llvm.ctlz.v4i32(<4 x i32> %{{.+}}, i1 false) 412 // CHECK-LE: call <4 x i32> @llvm.ctlz.v4i32(<4 x i32> %{{.+}}, i1 false) 413 414 res_vsll = vec_cntlz(vsll); 415 // CHECK: call <2 x i64> @llvm.ctlz.v2i64(<2 x i64> %{{.+}}, i1 false) 416 // CHECK-LE: call <2 x i64> @llvm.ctlz.v2i64(<2 x i64> %{{.+}}, i1 false) 417 418 res_vull = vec_cntlz(vull); 419 // CHECK: call <2 x i64> @llvm.ctlz.v2i64(<2 x i64> %{{.+}}, i1 false) 420 // CHECK-LE: call <2 x i64> @llvm.ctlz.v2i64(<2 x i64> %{{.+}}, i1 false) 421 422 /* ----------------------- predicates --------------------------- */ 423 /* vec_all_eq */ 424 res_i = vec_all_eq(vsll, vsll); 425 // CHECK: @llvm.ppc.altivec.vcmpequd.p 426 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p 427 // CHECK-PPC: error: call to 'vec_all_eq' is ambiguous 428 429 res_i = vec_all_eq(vsll, vbll); 430 // CHECK: @llvm.ppc.altivec.vcmpequd.p 431 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p 432 // CHECK-PPC: error: call to 'vec_all_eq' is ambiguous 433 434 res_i = vec_all_eq(vull, vull); 435 // CHECK: @llvm.ppc.altivec.vcmpequd.p 436 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p 437 // CHECK-PPC: error: call to 'vec_all_eq' is ambiguous 438 439 res_i = vec_all_eq(vull, vbll); 440 // CHECK: @llvm.ppc.altivec.vcmpequd.p 441 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p 442 // CHECK-PPC: error: call to 'vec_all_eq' is ambiguous 443 444 res_i = vec_all_eq(vbll, vsll); 445 // CHECK: @llvm.ppc.altivec.vcmpequd.p 446 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p 447 // CHECK-PPC: error: call to 'vec_all_eq' is ambiguous 448 449 res_i = vec_all_eq(vbll, vull); 450 // CHECK: @llvm.ppc.altivec.vcmpequd.p 451 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p 452 // CHECK-PPC: error: call to 'vec_all_eq' is ambiguous 453 454 res_i = vec_all_eq(vbll, vbll); 455 // CHECK: @llvm.ppc.altivec.vcmpequd.p 456 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p 457 // CHECK-PPC: error: call to 'vec_all_eq' is ambiguous 458 459 res_i = vec_all_eq(vda, vda); 460 // CHECK: @llvm.ppc.vsx.xvcmpeqdp.p 461 // CHECK-LE: @llvm.ppc.vsx.xvcmpeqdp.p 462 463 /* vec_all_ne */ 464 res_i = vec_all_ne(vsll, vsll); 465 // CHECK: @llvm.ppc.altivec.vcmpequd.p 466 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p 467 // CHECK-PPC: error: call to 'vec_all_ne' is ambiguous 468 469 res_i = vec_all_ne(vsll, vbll); 470 // CHECK: @llvm.ppc.altivec.vcmpequd.p 471 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p 472 // CHECK-PPC: error: call to 'vec_all_ne' is ambiguous 473 474 res_i = vec_all_ne(vull, vull); 475 // CHECK: @llvm.ppc.altivec.vcmpequd.p 476 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p 477 // CHECK-PPC: error: call to 'vec_all_ne' is ambiguous 478 479 res_i = vec_all_ne(vull, vbll); 480 // CHECK: @llvm.ppc.altivec.vcmpequd.p 481 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p 482 // CHECK-PPC: error: call to 'vec_all_ne' is ambiguous 483 484 res_i = vec_all_ne(vbll, vsll); 485 // CHECK: @llvm.ppc.altivec.vcmpequd.p 486 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p 487 // CHECK-PPC: error: call to 'vec_all_ne' is ambiguous 488 489 res_i = vec_all_ne(vbll, vull); 490 // CHECK: @llvm.ppc.altivec.vcmpequd.p 491 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p 492 // CHECK-PPC: error: call to 'vec_all_ne' is ambiguous 493 494 res_i = vec_all_ne(vbll, vbll); 495 // CHECK: @llvm.ppc.altivec.vcmpequd.p 496 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p 497 // CHECK-PPC: error: call to 'vec_all_ne' is ambiguous 498 499 dummy(); 500 // CHECK: @dummy 501 502 res_i = vec_all_ne(vda, vda); 503 // CHECK: @llvm.ppc.vsx.xvcmpeqdp.p 504 // CHECK-LE: @llvm.ppc.vsx.xvcmpeqdp.p 505 506 dummy(); 507 // CHECK: @dummy 508 509 res_i = vec_all_nge(vda, vda); 510 // CHECK: @llvm.ppc.vsx.xvcmpgedp.p 511 // CHECK-LE: @llvm.ppc.vsx.xvcmpgedp.p 512 513 res_i = vec_all_ngt(vda, vda); 514 // CHECK: @llvm.ppc.vsx.xvcmpgtdp.p 515 // CHECK-LE: @llvm.ppc.vsx.xvcmpgtdp.p 516 517 /* vec_any_eq */ 518 res_i = vec_any_eq(vsll, vsll); 519 // CHECK: @llvm.ppc.altivec.vcmpequd.p 520 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p 521 // CHECK-PPC: error: call to 'vec_any_eq' is ambiguous 522 523 res_i = vec_any_eq(vsll, vbll); 524 // CHECK: @llvm.ppc.altivec.vcmpequd.p 525 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p 526 // CHECK-PPC: error: call to 'vec_any_eq' is ambiguous 527 528 res_i = vec_any_eq(vull, vull); 529 // CHECK: @llvm.ppc.altivec.vcmpequd.p 530 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p 531 // CHECK-PPC: error: call to 'vec_any_eq' is ambiguous 532 533 res_i = vec_any_eq(vull, vbll); 534 // CHECK: @llvm.ppc.altivec.vcmpequd.p 535 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p 536 // CHECK-PPC: error: call to 'vec_any_eq' is ambiguous 537 538 res_i = vec_any_eq(vbll, vsll); 539 // CHECK: @llvm.ppc.altivec.vcmpequd.p 540 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p 541 // CHECK-PPC: error: call to 'vec_any_eq' is ambiguous 542 543 res_i = vec_any_eq(vbll, vull); 544 // CHECK: @llvm.ppc.altivec.vcmpequd.p 545 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p 546 // CHECK-PPC: error: call to 'vec_any_eq' is ambiguous 547 548 res_i = vec_any_eq(vbll, vbll); 549 // CHECK: @llvm.ppc.altivec.vcmpequd.p 550 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p 551 // CHECK-PPC: error: call to 'vec_any_eq' is ambiguous 552 553 res_i = vec_any_eq(vda, vda); 554 // CHECK: @llvm.ppc.vsx.xvcmpeqdp.p 555 // CHECK-LE: @llvm.ppc.vsx.xvcmpeqdp.p 556 557 /* vec_any_ne */ 558 res_i = vec_any_ne(vsll, vsll); 559 // CHECK: @llvm.ppc.altivec.vcmpequd.p 560 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p 561 // CHECK-PPC: error: call to 'vec_any_ne' is ambiguous 562 563 res_i = vec_any_ne(vsll, vbll); 564 // CHECK: @llvm.ppc.altivec.vcmpequd.p 565 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p 566 // CHECK-PPC: error: call to 'vec_any_ne' is ambiguous 567 568 res_i = vec_any_ne(vull, vull); 569 // CHECK: @llvm.ppc.altivec.vcmpequd.p 570 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p 571 // CHECK-PPC: error: call to 'vec_any_ne' is ambiguous 572 573 res_i = vec_any_ne(vull, vbll); 574 // CHECK: @llvm.ppc.altivec.vcmpequd.p 575 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p 576 // CHECK-PPC: error: call to 'vec_any_ne' is ambiguous 577 578 res_i = vec_any_ne(vbll, vsll); 579 // CHECK: @llvm.ppc.altivec.vcmpequd.p 580 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p 581 // CHECK-PPC: error: call to 'vec_any_ne' is ambiguous 582 583 res_i = vec_any_ne(vbll, vull); 584 // CHECK: @llvm.ppc.altivec.vcmpequd.p 585 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p 586 // CHECK-PPC: error: call to 'vec_any_ne' is ambiguous 587 588 res_i = vec_any_ne(vbll, vbll); 589 // CHECK: @llvm.ppc.altivec.vcmpequd.p 590 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p 591 // CHECK-PPC: error: call to 'vec_any_ne' is ambiguous 592 593 res_i = vec_any_ne(vda, vda); 594 // CHECK: @llvm.ppc.vsx.xvcmpeqdp.p 595 // CHECK-LE: @llvm.ppc.vsx.xvcmpeqdp.p 596 597 /* vec_all_ge */ 598 res_i = vec_all_ge(vsll, vsll); 599 // CHECK: @llvm.ppc.altivec.vcmpgtsd.p 600 // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p 601 // CHECK-PPC: error: call to 'vec_all_ge' is ambiguous 602 603 res_i = vec_all_ge(vsll, vbll); 604 // CHECK: @llvm.ppc.altivec.vcmpgtsd.p 605 // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p 606 // CHECK-PPC: error: call to 'vec_all_ge' is ambiguous 607 608 res_i = vec_all_ge(vull, vull); 609 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 610 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 611 // CHECK-PPC: error: call to 'vec_all_ge' is ambiguous 612 613 res_i = vec_all_ge(vull, vbll); 614 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 615 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 616 // CHECK-PPC: error: call to 'vec_all_ge' is ambiguous 617 618 res_i = vec_all_ge(vbll, vsll); 619 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 620 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 621 // CHECK-PPC: error: call to 'vec_all_ge' is ambiguous 622 623 res_i = vec_all_ge(vbll, vull); 624 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 625 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 626 // CHECK-PPC: error: call to 'vec_all_ge' is ambiguous 627 628 res_i = vec_all_ge(vbll, vbll); 629 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 630 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 631 // CHECK-PPC: error: call to 'vec_all_ge' is ambiguous 632 633 res_i = vec_all_ge(vda, vda); 634 // CHECK: @llvm.ppc.vsx.xvcmpgedp.p 635 // CHECK-LE: @llvm.ppc.vsx.xvcmpgedp.p 636 637 /* vec_all_gt */ 638 res_i = vec_all_gt(vsll, vsll); 639 // CHECK: @llvm.ppc.altivec.vcmpgtsd.p 640 // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p 641 // CHECK-PPC: error: call to 'vec_all_gt' is ambiguous 642 643 res_i = vec_all_gt(vsll, vbll); 644 // CHECK: @llvm.ppc.altivec.vcmpgtsd.p 645 // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p 646 // CHECK-PPC: error: call to 'vec_all_gt' is ambiguous 647 648 res_i = vec_all_gt(vull, vull); 649 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 650 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 651 // CHECK-PPC: error: call to 'vec_all_gt' is ambiguous 652 653 res_i = vec_all_gt(vull, vbll); 654 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 655 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 656 // CHECK-PPC: error: call to 'vec_all_gt' is ambiguous 657 658 res_i = vec_all_gt(vbll, vsll); 659 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 660 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 661 // CHECK-PPC: error: call to 'vec_all_gt' is ambiguous 662 663 res_i = vec_all_gt(vbll, vull); 664 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 665 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 666 // CHECK-PPC: error: call to 'vec_all_gt' is ambiguous 667 668 res_i = vec_all_gt(vbll, vbll); 669 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 670 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 671 // CHECK-PPC: error: call to 'vec_all_gt' is ambiguous 672 673 res_i = vec_all_gt(vda, vda); 674 // CHECK: @llvm.ppc.vsx.xvcmpgtdp.p 675 // CHECK-LE: @llvm.ppc.vsx.xvcmpgtdp.p 676 677 /* vec_all_le */ 678 res_i = vec_all_le(vsll, vsll); 679 // CHECK: @llvm.ppc.altivec.vcmpgtsd.p 680 // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p 681 // CHECK-PPC: error: call to 'vec_all_le' is ambiguous 682 683 res_i = vec_all_le(vsll, vbll); 684 // CHECK: @llvm.ppc.altivec.vcmpgtsd.p 685 // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p 686 // CHECK-PPC: error: call to 'vec_all_le' is ambiguous 687 688 res_i = vec_all_le(vull, vull); 689 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 690 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 691 // CHECK-PPC: error: call to 'vec_all_le' is ambiguous 692 693 res_i = vec_all_le(vull, vbll); 694 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 695 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 696 // CHECK-PPC: error: call to 'vec_all_le' is ambiguous 697 698 res_i = vec_all_le(vbll, vsll); 699 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 700 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 701 // CHECK-PPC: error: call to 'vec_all_le' is ambiguous 702 703 res_i = vec_all_le(vbll, vull); 704 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 705 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 706 // CHECK-PPC: error: call to 'vec_all_le' is ambiguous 707 708 res_i = vec_all_le(vbll, vbll); 709 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 710 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 711 // CHECK-PPC: error: call to 'vec_all_le' is ambiguous 712 713 res_i = vec_all_le(vda, vda); 714 // CHECK: @llvm.ppc.vsx.xvcmpgedp.p 715 // CHECK-LE: @llvm.ppc.vsx.xvcmpgedp.p 716 717 /* vec_all_lt */ 718 res_i = vec_all_lt(vsll, vsll); 719 // CHECK: @llvm.ppc.altivec.vcmpgtsd.p 720 // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p 721 // CHECK-PPC: error: call to 'vec_all_lt' is ambiguous 722 723 res_i = vec_all_lt(vsll, vbll); 724 // CHECK: @llvm.ppc.altivec.vcmpgtsd.p 725 // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p 726 // CHECK-PPC: error: call to 'vec_all_lt' is ambiguous 727 728 res_i = vec_all_lt(vull, vull); 729 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 730 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 731 // CHECK-PPC: error: call to 'vec_all_lt' is ambiguous 732 733 res_i = vec_all_lt(vull, vbll); 734 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 735 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 736 // CHECK-PPC: error: call to 'vec_all_lt' is ambiguous 737 738 res_i = vec_all_lt(vbll, vsll); 739 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 740 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 741 // CHECK-PPC: error: call to 'vec_all_lt' is ambiguous 742 743 res_i = vec_all_lt(vbll, vull); 744 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 745 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 746 // CHECK-PPC: error: call to 'vec_all_lt' is ambiguous 747 748 res_i = vec_all_lt(vbll, vbll); 749 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 750 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 751 // CHECK-PPC: error: call to 'vec_all_lt' is ambiguous 752 753 res_i = vec_all_lt(vda, vda); 754 // CHECK: @llvm.ppc.vsx.xvcmpgtdp.p 755 // CHECK-LE: @llvm.ppc.vsx.xvcmpgtdp.p 756 757 res_i = vec_all_nan(vda); 758 // CHECK: @llvm.ppc.vsx.xvcmpeqdp.p 759 // CHECK-LE: @llvm.ppc.vsx.xvcmpeqdp.p 760 761 /* vec_any_ge */ 762 res_i = vec_any_ge(vsll, vsll); 763 // CHECK: @llvm.ppc.altivec.vcmpgtsd.p 764 // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p 765 // CHECK-PPC: error: call to 'vec_any_ge' is ambiguous 766 767 res_i = vec_any_ge(vsll, vbll); 768 // CHECK: @llvm.ppc.altivec.vcmpgtsd.p 769 // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p 770 // CHECK-PPC: error: call to 'vec_any_ge' is ambiguous 771 772 res_i = vec_any_ge(vull, vull); 773 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 774 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 775 // CHECK-PPC: error: call to 'vec_any_ge' is ambiguous 776 777 res_i = vec_any_ge(vull, vbll); 778 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 779 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 780 // CHECK-PPC: error: call to 'vec_any_ge' is ambiguous 781 782 res_i = vec_any_ge(vbll, vsll); 783 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 784 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 785 // CHECK-PPC: error: call to 'vec_any_ge' is ambiguous 786 787 res_i = vec_any_ge(vbll, vull); 788 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 789 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 790 // CHECK-PPC: error: call to 'vec_any_ge' is ambiguous 791 792 res_i = vec_any_ge(vbll, vbll); 793 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 794 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 795 // CHECK-PPC: error: call to 'vec_any_ge' is ambiguous 796 797 res_i = vec_any_ge(vda, vda); 798 // CHECK: @llvm.ppc.vsx.xvcmpgedp.p 799 // CHECK-LE: @llvm.ppc.vsx.xvcmpgedp.p 800 801 /* vec_any_gt */ 802 res_i = vec_any_gt(vsll, vsll); 803 // CHECK: @llvm.ppc.altivec.vcmpgtsd.p 804 // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p 805 // CHECK-PPC: error: call to 'vec_any_gt' is ambiguous 806 807 res_i = vec_any_gt(vsll, vbll); 808 // CHECK: @llvm.ppc.altivec.vcmpgtsd.p 809 // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p 810 // CHECK-PPC: error: call to 'vec_any_gt' is ambiguous 811 812 res_i = vec_any_gt(vull, vull); 813 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 814 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 815 // CHECK-PPC: error: call to 'vec_any_gt' is ambiguous 816 817 res_i = vec_any_gt(vull, vbll); 818 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 819 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 820 // CHECK-PPC: error: call to 'vec_any_gt' is ambiguous 821 822 res_i = vec_any_gt(vbll, vsll); 823 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 824 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 825 // CHECK-PPC: error: call to 'vec_any_gt' is ambiguous 826 827 res_i = vec_any_gt(vbll, vull); 828 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 829 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 830 // CHECK-PPC: error: call to 'vec_any_gt' is ambiguous 831 832 res_i = vec_any_gt(vbll, vbll); 833 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 834 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 835 // CHECK-PPC: error: call to 'vec_any_gt' is ambiguous 836 837 res_i = vec_any_gt(vda, vda); 838 // CHECK: @llvm.ppc.vsx.xvcmpgtdp.p 839 // CHECK-LE: @llvm.ppc.vsx.xvcmpgtdp.p 840 841 /* vec_any_le */ 842 res_i = vec_any_le(vsll, vsll); 843 // CHECK: @llvm.ppc.altivec.vcmpgtsd.p 844 // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p 845 // CHECK-PPC: error: call to 'vec_any_le' is ambiguous 846 847 res_i = vec_any_le(vsll, vbll); 848 // CHECK: @llvm.ppc.altivec.vcmpgtsd.p 849 // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p 850 // CHECK-PPC: error: call to 'vec_any_le' is ambiguous 851 852 res_i = vec_any_le(vull, vull); 853 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 854 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 855 // CHECK-PPC: error: call to 'vec_any_le' is ambiguous 856 857 res_i = vec_any_le(vull, vbll); 858 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 859 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 860 // CHECK-PPC: error: call to 'vec_any_le' is ambiguous 861 862 res_i = vec_any_le(vbll, vsll); 863 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 864 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 865 // CHECK-PPC: error: call to 'vec_any_le' is ambiguous 866 867 res_i = vec_any_le(vbll, vull); 868 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 869 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 870 // CHECK-PPC: error: call to 'vec_any_le' is ambiguous 871 872 res_i = vec_any_le(vbll, vbll); 873 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 874 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 875 // CHECK-PPC: error: call to 'vec_any_le' is ambiguous 876 877 res_i = vec_any_le(vda, vda); 878 // CHECK: @llvm.ppc.vsx.xvcmpgedp.p 879 // CHECK-LE: @llvm.ppc.vsx.xvcmpgedp.p 880 881 /* vec_any_lt */ 882 res_i = vec_any_lt(vsll, vsll); 883 // CHECK: @llvm.ppc.altivec.vcmpgtsd.p 884 // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p 885 // CHECK-PPC: error: call to 'vec_any_lt' is ambiguous 886 887 res_i = vec_any_lt(vsll, vbll); 888 // CHECK: @llvm.ppc.altivec.vcmpgtsd.p 889 // CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p 890 // CHECK-PPC: error: call to 'vec_any_lt' is ambiguous 891 892 res_i = vec_any_lt(vull, vull); 893 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 894 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 895 // CHECK-PPC: error: call to 'vec_any_lt' is ambiguous 896 897 res_i = vec_any_lt(vull, vbll); 898 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 899 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 900 // CHECK-PPC: error: call to 'vec_any_lt' is ambiguous 901 902 res_i = vec_any_lt(vbll, vsll); 903 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 904 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 905 // CHECK-PPC: error: call to 'vec_any_lt' is ambiguous 906 907 res_i = vec_any_lt(vbll, vull); 908 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 909 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 910 // CHECK-PPC: error: call to 'vec_any_lt' is ambiguous 911 912 res_i = vec_any_lt(vbll, vbll); 913 // CHECK: @llvm.ppc.altivec.vcmpgtud.p 914 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p 915 // CHECK-PPC: error: call to 'vec_any_lt' is ambiguous 916 917 res_i = vec_any_lt(vda, vda); 918 // CHECK: @llvm.ppc.vsx.xvcmpgtdp.p 919 // CHECK-LE: @llvm.ppc.vsx.xvcmpgtdp.p 920 921 /* vec_max */ 922 res_vsll = vec_max(vsll, vsll); 923 // CHECK: @llvm.ppc.altivec.vmaxsd 924 // CHECK-LE: @llvm.ppc.altivec.vmaxsd 925 // CHECK-PPC: error: call to 'vec_max' is ambiguous 926 927 res_vsll = vec_max(vbll, vsll); 928 // CHECK: @llvm.ppc.altivec.vmaxsd 929 // CHECK-LE: @llvm.ppc.altivec.vmaxsd 930 // CHECK-PPC: error: call to 'vec_max' is ambiguous 931 932 res_vsll = vec_max(vsll, vbll); 933 // CHECK: @llvm.ppc.altivec.vmaxsd 934 // CHECK-LE: @llvm.ppc.altivec.vmaxsd 935 // CHECK-PPC: error: call to 'vec_max' is ambiguous 936 937 res_vull = vec_max(vull, vull); 938 // CHECK: @llvm.ppc.altivec.vmaxud 939 // CHECK-LE: @llvm.ppc.altivec.vmaxud 940 // CHECK-PPC: error: call to 'vec_max' is ambiguous 941 942 res_vull = vec_max(vbll, vull); 943 // CHECK: @llvm.ppc.altivec.vmaxud 944 // CHECK-LE: @llvm.ppc.altivec.vmaxud 945 // CHECK-PPC: error: call to 'vec_max' is ambiguous 946 947 res_vull = vec_max(vull, vbll); 948 // CHECK: @llvm.ppc.altivec.vmaxud 949 // CHECK-LE: @llvm.ppc.altivec.vmaxud 950 // CHECK-PPC: error: call to 'vec_max' is ambiguous 951 952 /* vec_mergeh */ 953 res_vbll = vec_mergeh(vbll, vbll); 954 // CHECK: @llvm.ppc.altivec.vperm 955 // CHECK-LE: @llvm.ppc.altivec.vperm 956 957 res_vbll = vec_mergel(vbll, vbll); 958 // CHECK: @llvm.ppc.altivec.vperm 959 // CHECK-LE: @llvm.ppc.altivec.vperm 960 961 /* vec_min */ 962 res_vsll = vec_min(vsll, vsll); 963 // CHECK: @llvm.ppc.altivec.vminsd 964 // CHECK-LE: @llvm.ppc.altivec.vminsd 965 // CHECK-PPC: error: call to 'vec_min' is ambiguous 966 967 res_vsll = vec_min(vbll, vsll); 968 // CHECK: @llvm.ppc.altivec.vminsd 969 // CHECK-LE: @llvm.ppc.altivec.vminsd 970 // CHECK-PPC: error: call to 'vec_min' is ambiguous 971 972 res_vsll = vec_min(vsll, vbll); 973 // CHECK: @llvm.ppc.altivec.vminsd 974 // CHECK-LE: @llvm.ppc.altivec.vminsd 975 // CHECK-PPC: error: call to 'vec_min' is ambiguous 976 977 res_vull = vec_min(vull, vull); 978 // CHECK: @llvm.ppc.altivec.vminud 979 // CHECK-LE: @llvm.ppc.altivec.vminud 980 // CHECK-PPC: error: call to 'vec_min' is ambiguous 981 982 res_vull = vec_min(vbll, vull); 983 // CHECK: @llvm.ppc.altivec.vminud 984 // CHECK-LE: @llvm.ppc.altivec.vminud 985 // CHECK-PPC: error: call to 'vec_min' is ambiguous 986 987 res_vull = vec_min(vull, vbll); 988 // CHECK: @llvm.ppc.altivec.vminud 989 // CHECK-LE: @llvm.ppc.altivec.vminud 990 // CHECK-PPC: error: call to 'vec_min' is ambiguous 991 992 /* vec_mule */ 993 res_vsll = vec_mule(vsi, vsi); 994 // CHECK: @llvm.ppc.altivec.vmulesw 995 // CHECK-LE: @llvm.ppc.altivec.vmulosw 996 // CHECK-PPC: error: call to 'vec_mule' is ambiguous 997 998 res_vull = vec_mule(vui , vui); 999 // CHECK: @llvm.ppc.altivec.vmuleuw 1000 // CHECK-LE: @llvm.ppc.altivec.vmulouw 1001 // CHECK-PPC: error: call to 'vec_mule' is ambiguous 1002 1003 /* vec_mulo */ 1004 res_vsll = vec_mulo(vsi, vsi); 1005 // CHECK: @llvm.ppc.altivec.vmulosw 1006 // CHECK-LE: @llvm.ppc.altivec.vmulesw 1007 // CHECK-PPC: error: call to 'vec_mulo' is ambiguous 1008 1009 res_vull = vec_mulo(vui, vui); 1010 // CHECK: @llvm.ppc.altivec.vmulouw 1011 // CHECK-LE: @llvm.ppc.altivec.vmuleuw 1012 // CHECK-PPC: error: call to 'vec_mulo' is ambiguous 1013 1014 /* vec_packs */ 1015 res_vsi = vec_packs(vsll, vsll); 1016 // CHECK: @llvm.ppc.altivec.vpksdss 1017 // CHECK-LE: @llvm.ppc.altivec.vpksdss 1018 // CHECK-PPC: error: call to 'vec_packs' is ambiguous 1019 1020 res_vui = vec_packs(vull, vull); 1021 // CHECK: @llvm.ppc.altivec.vpkudus 1022 // CHECK-LE: @llvm.ppc.altivec.vpkudus 1023 // CHECK-PPC: error: call to 'vec_packs' is ambiguous 1024 1025 /* vec_packsu */ 1026 res_vui = vec_packsu(vsll, vsll); 1027 // CHECK: @llvm.ppc.altivec.vpksdus 1028 // CHECK-LE: @llvm.ppc.altivec.vpksdus 1029 // CHECK-PPC: error: call to 'vec_packsu' is ambiguous 1030 1031 res_vui = vec_packsu(vull, vull); 1032 // CHECK: @llvm.ppc.altivec.vpkudus 1033 // CHECK-LE: @llvm.ppc.altivec.vpkudus 1034 // CHECK-PPC: error: call to 'vec_packsu' is ambiguous 1035 1036 /* vec_rl */ 1037 res_vsll = vec_rl(vsll, vull); 1038 // CHECK: @llvm.ppc.altivec.vrld 1039 // CHECK-LE: @llvm.ppc.altivec.vrld 1040 // CHECK-PPC: error: call to 'vec_rl' is ambiguous 1041 1042 res_vull = vec_rl(vull, vull); 1043 // CHECK: @llvm.ppc.altivec.vrld 1044 // CHECK-LE: @llvm.ppc.altivec.vrld 1045 // CHECK-PPC: error: call to 'vec_rl' is ambiguous 1046 1047 /* vec_sl */ 1048 res_vsll = vec_sl(vsll, vull); 1049 // CHECK: shl <2 x i64> 1050 // CHECK-LE: shl <2 x i64> 1051 // CHECK-PPC: error: call to 'vec_sl' is ambiguous 1052 1053 res_vull = vec_sl(vull, vull); 1054 // CHECK: shl <2 x i64> 1055 // CHECK-LE: shl <2 x i64> 1056 // CHECK-PPC: error: call to 'vec_sl' is ambiguous 1057 1058 /* vec_sr */ 1059 res_vsll = vec_sr(vsll, vull); 1060 // CHECK: lshr <2 x i64> 1061 // CHECK-LE: lshr <2 x i64> 1062 // CHECK-PPC: error: call to 'vec_sr' is ambiguous 1063 1064 res_vull = vec_sr(vull, vull); 1065 // CHECK: lshr <2 x i64> 1066 // CHECK-LE: lshr <2 x i64> 1067 // CHECK-PPC: error: call to 'vec_sr' is ambiguous 1068 1069 /* vec_sra */ 1070 res_vsll = vec_sra(vsll, vull); 1071 // CHECK: ashr <2 x i64> 1072 // CHECK-LE: ashr <2 x i64> 1073 // CHECK-PPC: error: call to 'vec_sra' is ambiguous 1074 1075 res_vull = vec_sra(vull, vull); 1076 // CHECK: ashr <2 x i64> 1077 // CHECK-LE: ashr <2 x i64> 1078 // CHECK-PPC: error: call to 'vec_sra' is ambiguous 1079 1080 /* vec_splats */ 1081 res_vsll = vec_splats(sll); 1082 // CHECK: insertelement <2 x i64> 1083 // CHECK-LE: insertelement <2 x i64> 1084 1085 res_vull = vec_splats(ull); 1086 // CHECK: insertelement <2 x i64> 1087 // CHECK-LE: insertelement <2 x i64> 1088 1089 res_vsx = vec_splats(sx); 1090 // CHECK: insertelement <1 x i128> 1091 // CHECK-LE: insertelement <1 x i128> 1092 1093 res_vux = vec_splats(ux); 1094 // CHECK: insertelement <1 x i128> 1095 // CHECK-LE: insertelement <1 x i128> 1096 1097 res_vd = vec_splats(d); 1098 // CHECK: insertelement <2 x double> 1099 // CHECK-LE: insertelement <2 x double> 1100 1101 1102 /* vec_unpackh */ 1103 res_vsll = vec_unpackh(vsi); 1104 // CHECK: llvm.ppc.altivec.vupkhsw 1105 // CHECK-LE: llvm.ppc.altivec.vupklsw 1106 // CHECK-PPC: error: call to 'vec_unpackh' is ambiguous 1107 1108 res_vbll = vec_unpackh(vbi); 1109 // CHECK: llvm.ppc.altivec.vupkhsw 1110 // CHECK-LE: llvm.ppc.altivec.vupklsw 1111 // CHECK-PPC: error: call to 'vec_unpackh' is ambiguous 1112 1113 /* vec_unpackl */ 1114 res_vsll = vec_unpackl(vsi); 1115 // CHECK: llvm.ppc.altivec.vupklsw 1116 // CHECK-LE: llvm.ppc.altivec.vupkhsw 1117 // CHECK-PPC: error: call to 'vec_unpackl' is ambiguous 1118 1119 res_vbll = vec_unpackl(vbi); 1120 // CHECK: llvm.ppc.altivec.vupklsw 1121 // CHECK-LE: llvm.ppc.altivec.vupkhsw 1122 // CHECK-PPC: error: call to 'vec_unpackl' is ambiguous 1123 1124 /* vec_vpksdss */ 1125 res_vsi = vec_vpksdss(vsll, vsll); 1126 // CHECK: llvm.ppc.altivec.vpksdss 1127 // CHECK-LE: llvm.ppc.altivec.vpksdss 1128 // CHECK-PPC: warning: implicit declaration of function 'vec_vpksdss' 1129 1130 /* vec_vpksdus */ 1131 res_vui = vec_vpksdus(vsll, vsll); 1132 // CHECK: llvm.ppc.altivec.vpksdus 1133 // CHECK-LE: llvm.ppc.altivec.vpksdus 1134 // CHECK-PPC: warning: implicit declaration of function 'vec_vpksdus' 1135 1136 /* vec_vpkudum */ 1137 res_vsi = vec_vpkudum(vsll, vsll); 1138 // CHECK: vperm 1139 // CHECK-LE: vperm 1140 // CHECK-PPC: warning: implicit declaration of function 'vec_vpkudum' 1141 1142 res_vui = vec_vpkudum(vull, vull); 1143 // CHECK: vperm 1144 // CHECK-LE: vperm 1145 1146 res_vui = vec_vpkudus(vull, vull); 1147 // CHECK: llvm.ppc.altivec.vpkudus 1148 // CHECK-LE: llvm.ppc.altivec.vpkudus 1149 // CHECK-PPC: warning: implicit declaration of function 'vec_vpkudus' 1150 1151 /* vec_vupkhsw */ 1152 res_vsll = vec_vupkhsw(vsi); 1153 // CHECK: llvm.ppc.altivec.vupkhsw 1154 // CHECK-LE: llvm.ppc.altivec.vupklsw 1155 // CHECK-PPC: warning: implicit declaration of function 'vec_vupkhsw' 1156 1157 res_vbll = vec_vupkhsw(vbi); 1158 // CHECK: llvm.ppc.altivec.vupkhsw 1159 // CHECK-LE: llvm.ppc.altivec.vupklsw 1160 1161 /* vec_vupklsw */ 1162 res_vsll = vec_vupklsw(vsi); 1163 // CHECK: llvm.ppc.altivec.vupklsw 1164 // CHECK-LE: llvm.ppc.altivec.vupkhsw 1165 // CHECK-PPC: warning: implicit declaration of function 'vec_vupklsw' 1166 1167 res_vbll = vec_vupklsw(vbi); 1168 // CHECK: llvm.ppc.altivec.vupklsw 1169 // CHECK-LE: llvm.ppc.altivec.vupkhsw 1170 1171 /* vec_max */ 1172 res_vsll = vec_max(vsll, vsll); 1173 // CHECK: @llvm.ppc.altivec.vmaxsd 1174 // CHECK-LE: @llvm.ppc.altivec.vmaxsd 1175 1176 res_vsll = vec_max(vbll, vsll); 1177 // CHECK: @llvm.ppc.altivec.vmaxsd 1178 // CHECK-LE: @llvm.ppc.altivec.vmaxsd 1179 1180 res_vsll = vec_max(vsll, vbll); 1181 // CHECK: @llvm.ppc.altivec.vmaxsd 1182 // CHECK-LE: @llvm.ppc.altivec.vmaxsd 1183 1184 res_vull = vec_max(vull, vull); 1185 // CHECK: @llvm.ppc.altivec.vmaxud 1186 // CHECK-LE: @llvm.ppc.altivec.vmaxud 1187 1188 res_vull = vec_max(vbll, vull); 1189 // CHECK: @llvm.ppc.altivec.vmaxud 1190 // CHECK-LE: @llvm.ppc.altivec.vmaxud 1191 1192 /* vec_min */ 1193 res_vsll = vec_min(vsll, vsll); 1194 // CHECK: @llvm.ppc.altivec.vminsd 1195 // CHECK-LE: @llvm.ppc.altivec.vminsd 1196 1197 res_vsll = vec_min(vbll, vsll); 1198 // CHECK: @llvm.ppc.altivec.vminsd 1199 // CHECK-LE: @llvm.ppc.altivec.vminsd 1200 1201 res_vsll = vec_min(vsll, vbll); 1202 // CHECK: @llvm.ppc.altivec.vminsd 1203 // CHECK-LE: @llvm.ppc.altivec.vminsd 1204 1205 res_vull = vec_min(vull, vull); 1206 // CHECK: @llvm.ppc.altivec.vminud 1207 // CHECK-LE: @llvm.ppc.altivec.vminud 1208 1209 res_vull = vec_min(vbll, vull); 1210 // CHECK: @llvm.ppc.altivec.vminud 1211 // CHECK-LE: @llvm.ppc.altivec.vminud 1212 1213 /* vec_nand */ 1214 res_vsc = vec_nand(vsc, vsc); 1215 // CHECK: [[T1:%.+]] = and <16 x i8> 1216 // CHECK: xor <16 x i8> [[T1]], <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> 1217 // CHECK-LE: [[T1:%.+]] = and <16 x i8> 1218 // CHECK-LE: xor <16 x i8> [[T1]], <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> 1219 // CHECK-PPC: warning: implicit declaration of function 'vec_nand' is invalid in C99 1220 1221 res_vsc = vec_nand(vbc, vbc); 1222 // CHECK: [[T1:%.+]] = and <16 x i8> 1223 // CHECK: xor <16 x i8> [[T1]], <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> 1224 // CHECK-LE: [[T1:%.+]] = and <16 x i8> 1225 // CHECK-LE: xor <16 x i8> [[T1]], <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> 1226 1227 res_vuc = vec_nand(vuc, vuc); 1228 // CHECK: [[T1:%.+]] = and <16 x i8> 1229 // CHECK: xor <16 x i8> [[T1]], <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> 1230 // CHECK-LE: [[T1:%.+]] = and <16 x i8> 1231 // CHECK-LE: xor <16 x i8> [[T1]], <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> 1232 1233 res_vss = vec_nand(vss, vss); 1234 // CHECK: [[T1:%.+]] = and <8 x i16> 1235 // CHECK: xor <8 x i16> [[T1]], <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1> 1236 // CHECK-LE: [[T1:%.+]] = and <8 x i16> 1237 // CHECK-LE: xor <8 x i16> [[T1]], <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1> 1238 1239 res_vss = vec_nand(vbs, vbs); 1240 // CHECK: [[T1:%.+]] = and <8 x i16> 1241 // CHECK: xor <8 x i16> [[T1]], <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1> 1242 // CHECK-LE: [[T1:%.+]] = and <8 x i16> 1243 // CHECK-LE: xor <8 x i16> [[T1]], <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1> 1244 1245 res_vus = vec_nand(vus, vus); 1246 // CHECK: [[T1:%.+]] = and <8 x i16> 1247 // CHECK: xor <8 x i16> [[T1]], <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1> 1248 // CHECK-LE: [[T1:%.+]] = and <8 x i16> 1249 // CHECK-LE: xor <8 x i16> [[T1]], <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1> 1250 1251 res_vsi = vec_nand(vsi, vsi); 1252 // CHECK: [[T1:%.+]] = and <4 x i32> 1253 // CHECK: xor <4 x i32> [[T1]], <i32 -1, i32 -1, i32 -1, i32 -1> 1254 // CHECK-LE: [[T1:%.+]] = and <4 x i32> 1255 // CHECK-LE: xor <4 x i32> [[T1]], <i32 -1, i32 -1, i32 -1, i32 -1> 1256 1257 res_vsi = vec_nand(vbi, vbi); 1258 // CHECK: [[T1:%.+]] = and <4 x i32> 1259 // CHECK: xor <4 x i32> [[T1]], <i32 -1, i32 -1, i32 -1, i32 -1> 1260 // CHECK-LE: [[T1:%.+]] = and <4 x i32> 1261 // CHECK-LE: xor <4 x i32> [[T1]], <i32 -1, i32 -1, i32 -1, i32 -1> 1262 1263 res_vui = vec_nand(vui, vui); 1264 // CHECK: [[T1:%.+]] = and <4 x i32> 1265 // CHECK: xor <4 x i32> [[T1]], <i32 -1, i32 -1, i32 -1, i32 -1> 1266 // CHECK-LE: [[T1:%.+]] = and <4 x i32> 1267 // CHECK-LE: xor <4 x i32> [[T1]], <i32 -1, i32 -1, i32 -1, i32 -1> 1268 1269 res_vsll = vec_nand(vsll, vsll); 1270 // CHECK: [[T1:%.+]] = and <2 x i64> 1271 // CHECK: xor <2 x i64> [[T1]], <i64 -1, i64 -1> 1272 // CHECK-LE: [[T1:%.+]] = and <2 x i64> 1273 // CHECK-LE: xor <2 x i64> [[T1]], <i64 -1, i64 -1> 1274 1275 res_vsll = vec_nand(vbll, vbll); 1276 // CHECK: [[T1:%.+]] = and <2 x i64> 1277 // CHECK: xor <2 x i64> [[T1]], <i64 -1, i64 -1> 1278 // CHECK-LE: [[T1:%.+]] = and <2 x i64> 1279 // CHECK-LE: xor <2 x i64> [[T1]], <i64 -1, i64 -1> 1280 1281 res_vull = vec_nand(vull, vull); 1282 // CHECK: [[T1:%.+]] = and <2 x i64> 1283 // CHECK: xor <2 x i64> [[T1]], <i64 -1, i64 -1> 1284 // CHECK-LE: [[T1:%.+]] = and <2 x i64> 1285 // CHECK-LE: xor <2 x i64> [[T1]], <i64 -1, i64 -1> 1286 1287 /* vec_orc */ 1288 res_vsc = vec_orc(vsc, vsc); 1289 // CHECK: [[T1:%.+]] = xor <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> 1290 // CHECK: or <16 x i8> {{%.+}}, [[T1]] 1291 // CHECK-LE: [[T1:%.+]] = xor <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> 1292 // CHECK-LE: or <16 x i8> {{%.+}}, [[T1]] 1293 // CHECK-PPC: warning: implicit declaration of function 'vec_orc' is invalid in C99 1294 1295 res_vsc = vec_orc(vsc, vbc); 1296 // CHECK: [[T1:%.+]] = xor <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> 1297 // CHECK: or <16 x i8> {{%.+}}, [[T1]] 1298 // CHECK-LE: [[T1:%.+]] = xor <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> 1299 // CHECK-LE: or <16 x i8> {{%.+}}, [[T1]] 1300 1301 res_vsc = vec_orc(vbc, vsc); 1302 // CHECK: [[T1:%.+]] = xor <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> 1303 // CHECK: or <16 x i8> {{%.+}}, [[T1]] 1304 // CHECK-LE: [[T1:%.+]] = xor <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> 1305 // CHECK-LE: or <16 x i8> {{%.+}}, [[T1]] 1306 1307 res_vuc = vec_orc(vuc, vuc); 1308 // CHECK: [[T1:%.+]] = xor <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> 1309 // CHECK: or <16 x i8> {{%.+}}, [[T1]] 1310 // CHECK-LE: [[T1:%.+]] = xor <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> 1311 // CHECK-LE: or <16 x i8> {{%.+}}, [[T1]] 1312 1313 res_vuc = vec_orc(vuc, vbc); 1314 // CHECK: [[T1:%.+]] = xor <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> 1315 // CHECK: or <16 x i8> {{%.+}}, [[T1]] 1316 // CHECK-LE: [[T1:%.+]] = xor <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> 1317 // CHECK-LE: or <16 x i8> {{%.+}}, [[T1]] 1318 1319 res_vuc = vec_orc(vbc, vuc); 1320 // CHECK: [[T1:%.+]] = xor <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> 1321 // CHECK: or <16 x i8> {{%.+}}, [[T1]] 1322 // CHECK-LE: [[T1:%.+]] = xor <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> 1323 // CHECK-LE: or <16 x i8> {{%.+}}, [[T1]] 1324 1325 res_vbc = vec_orc(vbc, vbc); 1326 // CHECK: [[T1:%.+]] = xor <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> 1327 // CHECK: or <16 x i8> {{%.+}}, [[T1]] 1328 // CHECK-LE: [[T1:%.+]] = xor <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> 1329 // CHECK-LE: or <16 x i8> {{%.+}}, [[T1]] 1330 1331 res_vss = vec_orc(vss, vss); 1332 // CHECK: [[T1:%.+]] = xor <8 x i16> {{%.+}}, <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1> 1333 // CHECK: or <8 x i16> {{%.+}}, [[T1]] 1334 // CHECK-LE: [[T1:%.+]] = xor <8 x i16> {{%.+}}, <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1> 1335 // CHECK-LE: or <8 x i16> {{%.+}}, [[T1]] 1336 1337 res_vss = vec_orc(vss, vbs); 1338 // CHECK: [[T1:%.+]] = xor <8 x i16> {{%.+}}, <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1> 1339 // CHECK: or <8 x i16> {{%.+}}, [[T1]] 1340 // CHECK-LE: [[T1:%.+]] = xor <8 x i16> {{%.+}}, <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1> 1341 // CHECK-LE: or <8 x i16> {{%.+}}, [[T1]] 1342 1343 res_vss = vec_orc(vbs, vss); 1344 // CHECK: [[T1:%.+]] = xor <8 x i16> {{%.+}}, <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1> 1345 // CHECK: or <8 x i16> {{%.+}}, [[T1]] 1346 // CHECK-LE: [[T1:%.+]] = xor <8 x i16> {{%.+}}, <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1> 1347 // CHECK-LE: or <8 x i16> {{%.+}}, [[T1]] 1348 1349 res_vus = vec_orc(vus, vus); 1350 // CHECK: [[T1:%.+]] = xor <8 x i16> {{%.+}}, <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1> 1351 // CHECK: or <8 x i16> {{%.+}}, [[T1]] 1352 // CHECK-LE: [[T1:%.+]] = xor <8 x i16> {{%.+}}, <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1> 1353 // CHECK-LE: or <8 x i16> {{%.+}}, [[T1]] 1354 1355 res_vus = vec_orc(vus, vbs); 1356 // CHECK: [[T1:%.+]] = xor <8 x i16> {{%.+}}, <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1> 1357 // CHECK: or <8 x i16> {{%.+}}, [[T1]] 1358 // CHECK-LE: [[T1:%.+]] = xor <8 x i16> {{%.+}}, <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1> 1359 // CHECK-LE: or <8 x i16> {{%.+}}, [[T1]] 1360 1361 res_vus = vec_orc(vbs, vus); 1362 // CHECK: [[T1:%.+]] = xor <8 x i16> {{%.+}}, <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1> 1363 // CHECK: or <8 x i16> {{%.+}}, [[T1]] 1364 // CHECK-LE: [[T1:%.+]] = xor <8 x i16> {{%.+}}, <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1> 1365 // CHECK-LE: or <8 x i16> {{%.+}}, [[T1]] 1366 1367 res_vbs = vec_orc(vbs, vbs); 1368 // CHECK: [[T1:%.+]] = xor <8 x i16> {{%.+}}, <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1> 1369 // CHECK: or <8 x i16> {{%.+}}, [[T1]] 1370 // CHECK-LE: [[T1:%.+]] = xor <8 x i16> {{%.+}}, <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1> 1371 // CHECK-LE: or <8 x i16> {{%.+}}, [[T1]] 1372 1373 res_vsi = vec_orc(vsi, vsi); 1374 // CHECK: [[T1:%.+]] = xor <4 x i32> {{%.+}}, <i32 -1, i32 -1, i32 -1, i32 -1> 1375 // CHECK: or <4 x i32> {{%.+}}, [[T1]] 1376 // CHECK-LE: [[T1:%.+]] = xor <4 x i32> {{%.+}}, <i32 -1, i32 -1, i32 -1, i32 -1> 1377 // CHECK-LE: or <4 x i32> {{%.+}}, [[T1]] 1378 1379 res_vsi = vec_orc(vsi, vbi); 1380 // CHECK: [[T1:%.+]] = xor <4 x i32> {{%.+}}, <i32 -1, i32 -1, i32 -1, i32 -1> 1381 // CHECK: or <4 x i32> {{%.+}}, [[T1]] 1382 // CHECK-LE: [[T1:%.+]] = xor <4 x i32> {{%.+}}, <i32 -1, i32 -1, i32 -1, i32 -1> 1383 // CHECK-LE: or <4 x i32> {{%.+}}, [[T1]] 1384 1385 res_vsi = vec_orc(vbi, vsi); 1386 // CHECK: [[T1:%.+]] = xor <4 x i32> {{%.+}}, <i32 -1, i32 -1, i32 -1, i32 -1> 1387 // CHECK: or <4 x i32> {{%.+}}, [[T1]] 1388 // CHECK-LE: [[T1:%.+]] = xor <4 x i32> {{%.+}}, <i32 -1, i32 -1, i32 -1, i32 -1> 1389 // CHECK-LE: or <4 x i32> {{%.+}}, [[T1]] 1390 1391 res_vui = vec_orc(vui, vui); 1392 // CHECK: [[T1:%.+]] = xor <4 x i32> {{%.+}}, <i32 -1, i32 -1, i32 -1, i32 -1> 1393 // CHECK: or <4 x i32> {{%.+}}, [[T1]] 1394 // CHECK-LE: [[T1:%.+]] = xor <4 x i32> {{%.+}}, <i32 -1, i32 -1, i32 -1, i32 -1> 1395 // CHECK-LE: or <4 x i32> {{%.+}}, [[T1]] 1396 1397 res_vui = vec_orc(vui, vbi); 1398 // CHECK: [[T1:%.+]] = xor <4 x i32> {{%.+}}, <i32 -1, i32 -1, i32 -1, i32 -1> 1399 // CHECK: or <4 x i32> {{%.+}}, [[T1]] 1400 // CHECK-LE: [[T1:%.+]] = xor <4 x i32> {{%.+}}, <i32 -1, i32 -1, i32 -1, i32 -1> 1401 // CHECK-LE: or <4 x i32> {{%.+}}, [[T1]] 1402 1403 res_vui = vec_orc(vbi, vui); 1404 // CHECK: [[T1:%.+]] = xor <4 x i32> {{%.+}}, <i32 -1, i32 -1, i32 -1, i32 -1> 1405 // CHECK: or <4 x i32> {{%.+}}, [[T1]] 1406 // CHECK-LE: [[T1:%.+]] = xor <4 x i32> {{%.+}}, <i32 -1, i32 -1, i32 -1, i32 -1> 1407 // CHECK-LE: or <4 x i32> {{%.+}}, [[T1]] 1408 1409 res_vbi = vec_orc(vbi, vbi); 1410 // CHECK: [[T1:%.+]] = xor <4 x i32> {{%.+}}, <i32 -1, i32 -1, i32 -1, i32 -1> 1411 // CHECK: or <4 x i32> {{%.+}}, [[T1]] 1412 // CHECK-LE: [[T1:%.+]] = xor <4 x i32> {{%.+}}, <i32 -1, i32 -1, i32 -1, i32 -1> 1413 // CHECK-LE: or <4 x i32> {{%.+}}, [[T1]] 1414 1415 res_vsll = vec_orc(vsll, vsll); 1416 // CHECK: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1> 1417 // CHECK: or <2 x i64> {{%.+}}, [[T1]] 1418 // CHECK-LE: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1> 1419 // CHECK-LE: or <2 x i64> {{%.+}}, [[T1]] 1420 1421 res_vsll = vec_orc(vsll, vbll); 1422 // CHECK: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1> 1423 // CHECK: or <2 x i64> {{%.+}}, [[T1]] 1424 // CHECK-LE: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1> 1425 // CHECK-LE: or <2 x i64> {{%.+}}, [[T1]] 1426 1427 res_vsll = vec_orc(vbll, vsll); 1428 // CHECK: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1> 1429 // CHECK: or <2 x i64> {{%.+}}, [[T1]] 1430 // CHECK-LE: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1> 1431 // CHECK-LE: or <2 x i64> {{%.+}}, [[T1]] 1432 1433 res_vull = vec_orc(vull, vull); 1434 // CHECK: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1> 1435 // CHECK: or <2 x i64> {{%.+}}, [[T1]] 1436 // CHECK-LE: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1> 1437 // CHECK-LE: or <2 x i64> {{%.+}}, [[T1]] 1438 1439 res_vull = vec_orc(vull, vbll); 1440 // CHECK: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1> 1441 // CHECK: or <2 x i64> {{%.+}}, [[T1]] 1442 // CHECK-LE: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1> 1443 // CHECK-LE: or <2 x i64> {{%.+}}, [[T1]] 1444 1445 res_vull = vec_orc(vbll, vull); 1446 // CHECK: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1> 1447 // CHECK: or <2 x i64> {{%.+}}, [[T1]] 1448 // CHECK-LE: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1> 1449 // CHECK-LE: or <2 x i64> {{%.+}}, [[T1]] 1450 1451 res_vbll = vec_orc(vbll, vbll); 1452 // CHECK: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1> 1453 // CHECK: or <2 x i64> {{%.+}}, [[T1]] 1454 // CHECK-LE: [[T1:%.+]] = xor <2 x i64> {{%.+}}, <i64 -1, i64 -1> 1455 // CHECK-LE: or <2 x i64> {{%.+}}, [[T1]] 1456 1457 /* vec_sub */ 1458 res_vsll = vec_sub(vsll, vsll); 1459 // CHECK: sub <2 x i64> 1460 // CHECK-LE: sub <2 x i64> 1461 1462 res_vull = vec_sub(vull, vull); 1463 // CHECK: sub <2 x i64> 1464 // CHECK-LE: sub <2 x i64> 1465 1466 res_vd = vec_sub(vda, vda); 1467 // CHECK: fsub <2 x double> 1468 // CHECK-LE: fsub <2 x double> 1469 1470 res_vsx = vec_sub(vsx, vsx); 1471 // CHECK: sub <1 x i128> 1472 // CHECK-LE: sub <1 x i128> 1473 1474 res_vux = vec_sub(vux, vux); 1475 // CHECK: sub <1 x i128> 1476 // CHECK-LE: sub <1 x i128> 1477 1478 /* vec_vbpermq */ 1479 res_vsll = vec_vbpermq(vsc, vsc); 1480 // CHECK: llvm.ppc.altivec.vbpermq 1481 // CHECK-LE: llvm.ppc.altivec.vbpermq 1482 1483 res_vull = vec_vbpermq(vuc, vuc); 1484 // CHECK: llvm.ppc.altivec.vbpermq 1485 // CHECK-LE: llvm.ppc.altivec.vbpermq 1486 // CHECK-PPC: warning: implicit declaration of function 'vec_vbpermq' 1487 1488 /* vec_vgbbd */ 1489 res_vsc = vec_vgbbd(vsc); 1490 // CHECK: llvm.ppc.altivec.vgbbd 1491 // CHECK-LE: llvm.ppc.altivec.vgbbd 1492 1493 res_vuc = vec_vgbbd(vuc); 1494 // CHECK: llvm.ppc.altivec.vgbbd 1495 // CHECK-LE: llvm.ppc.altivec.vgbbd 1496 // CHECK-PPC: warning: implicit declaration of function 'vec_vgbbd' 1497 1498 res_vuc = vec_gb(vuc); 1499 // CHECK: llvm.ppc.altivec.vgbbd 1500 // CHECK-LE: llvm.ppc.altivec.vgbbd 1501 // CHECK-PPC: warning: implicit declaration of function 'vec_gb' 1502 1503 res_vull = vec_bperm(vux, vux); 1504 // CHECK: llvm.ppc.altivec.vbpermq 1505 // CHECK-LE: llvm.ppc.altivec.vbpermq 1506 // CHECK-PPC: warning: implicit declaration of function 'vec_bperm' 1507 } 1508
