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