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