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