• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // RUN: %clang_cc1 -triple s390x-linux-gnu -target-cpu z13 -fzvector \
2 // RUN:  -O -emit-llvm -o - -W -Wall -Werror %s | FileCheck %s
3 
4 volatile vector signed char sc, sc2;
5 volatile vector unsigned char uc, uc2;
6 volatile vector bool char bc, bc2;
7 
8 volatile vector signed short ss, ss2;
9 volatile vector unsigned short us, us2;
10 volatile vector bool short bs, bs2;
11 
12 volatile vector signed int si, si2;
13 volatile vector unsigned int ui, ui2;
14 volatile vector bool int bi, bi2;
15 
16 volatile vector signed long long sl, sl2;
17 volatile vector unsigned long long ul, ul2;
18 volatile vector bool long long bl, bl2;
19 
20 volatile vector double fd, fd2;
21 
22 volatile int cnt;
23 
test_assign(void)24 void test_assign (void)
25 {
26 // CHECK-LABEL: test_assign
27 
28 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
29 // CHECK: store volatile <16 x i8> [[VAL]], <16 x i8>* @sc
30   sc = sc2;
31 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
32 // CHECK: store volatile <16 x i8> [[VAL]], <16 x i8>* @uc
33   uc = uc2;
34 
35 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
36 // CHECK: store volatile <8 x i16> [[VAL]], <8 x i16>* @ss
37   ss = ss2;
38 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
39 // CHECK: store volatile <8 x i16> [[VAL]], <8 x i16>* @us
40   us = us2;
41 
42 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
43 // CHECK: store volatile <4 x i32> [[VAL]], <4 x i32>* @si
44   si = si2;
45 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
46 // CHECK: store volatile <4 x i32> [[VAL]], <4 x i32>* @ui
47   ui = ui2;
48 
49 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
50 // CHECK: store volatile <2 x i64> [[VAL]], <2 x i64>* @sl
51   sl = sl2;
52 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
53 // CHECK: store volatile <2 x i64> [[VAL]], <2 x i64>* @ul
54   ul = ul2;
55 
56 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x double>, <2 x double>* @fd2
57 // CHECK: store volatile <2 x double> [[VAL]], <2 x double>* @fd
58   fd = fd2;
59 }
60 
test_pos(void)61 void test_pos (void)
62 {
63 // CHECK-LABEL: test_pos
64 
65 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
66 // CHECK: store volatile <16 x i8> [[VAL]], <16 x i8>* @sc
67   sc = +sc2;
68 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
69 // CHECK: store volatile <16 x i8> [[VAL]], <16 x i8>* @uc
70   uc = +uc2;
71 
72 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
73 // CHECK: store volatile <8 x i16> [[VAL]], <8 x i16>* @ss
74   ss = +ss2;
75 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
76 // CHECK: store volatile <8 x i16> [[VAL]], <8 x i16>* @us
77   us = +us2;
78 
79 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
80 // CHECK: store volatile <4 x i32> [[VAL]], <4 x i32>* @si
81   si = +si2;
82 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
83 // CHECK: store volatile <4 x i32> [[VAL]], <4 x i32>* @ui
84   ui = +ui2;
85 
86 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
87 // CHECK: store volatile <2 x i64> [[VAL]], <2 x i64>* @sl
88   sl = +sl2;
89 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
90 // CHECK: store volatile <2 x i64> [[VAL]], <2 x i64>* @ul
91   ul = +ul2;
92 
93 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x double>, <2 x double>* @fd2
94 // CHECK: store volatile <2 x double> [[VAL]], <2 x double>* @fd
95   fd = +fd2;
96 }
97 
test_neg(void)98 void test_neg (void)
99 {
100 // CHECK-LABEL: test_neg
101 
102 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
103 // CHECK: %{{.*}} = sub <16 x i8> zeroinitializer, [[VAL]]
104   sc = -sc2;
105 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
106 // CHECK: %{{.*}} = sub <8 x i16> zeroinitializer, [[VAL]]
107   ss = -ss2;
108 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
109 // CHECK: %{{.*}} = sub <4 x i32> zeroinitializer, [[VAL]]
110   si = -si2;
111 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
112 // CHECK: %{{.*}} = sub <2 x i64> zeroinitializer, [[VAL]]
113   sl = -sl2;
114 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x double>, <2 x double>* @fd2
115 // CHECK: %{{.*}} = fsub <2 x double> <double -0.000000e+00, double -0.000000e+00>, [[VAL]]
116   fd = -fd2;
117 }
118 
test_preinc(void)119 void test_preinc (void)
120 {
121 // CHECK-LABEL: test_preinc
122 
123 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
124 // CHECK: %{{.*}} = add <16 x i8> [[VAL]], <i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1>
125   ++sc2;
126 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
127 // CHECK: %{{.*}} = add <16 x i8> [[VAL]], <i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1>
128   ++uc2;
129 
130 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
131 // CHECK: %{{.*}} = add <8 x i16> [[VAL]], <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
132   ++ss2;
133 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
134 // CHECK: %{{.*}} = add <8 x i16> [[VAL]], <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
135   ++us2;
136 
137 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
138 // CHECK: %{{.*}} = add <4 x i32> [[VAL]], <i32 1, i32 1, i32 1, i32 1>
139   ++si2;
140 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
141 // CHECK: %{{.*}} = add <4 x i32> [[VAL]], <i32 1, i32 1, i32 1, i32 1>
142   ++ui2;
143 
144 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
145 // CHECK: %{{.*}} = add <2 x i64> [[VAL]], <i64 1, i64 1>
146   ++sl2;
147 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
148 // CHECK: %{{.*}} = add <2 x i64> [[VAL]], <i64 1, i64 1>
149   ++ul2;
150 
151 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x double>, <2 x double>* @fd2
152 // CHECK: %{{.*}} = fadd <2 x double> [[VAL]], <double 1.000000e+00, double 1.000000e+00>
153   ++fd2;
154 }
155 
test_postinc(void)156 void test_postinc (void)
157 {
158 // CHECK-LABEL: test_postinc
159 
160 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
161 // CHECK: %{{.*}} = add <16 x i8> [[VAL]], <i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1>
162   sc2++;
163 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
164 // CHECK: %{{.*}} = add <16 x i8> [[VAL]], <i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1>
165   uc2++;
166 
167 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
168 // CHECK: %{{.*}} = add <8 x i16> [[VAL]], <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
169   ss2++;
170 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
171 // CHECK: %{{.*}} = add <8 x i16> [[VAL]], <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
172   us2++;
173 
174 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
175 // CHECK: %{{.*}} = add <4 x i32> [[VAL]], <i32 1, i32 1, i32 1, i32 1>
176   si2++;
177 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
178 // CHECK: %{{.*}} = add <4 x i32> [[VAL]], <i32 1, i32 1, i32 1, i32 1>
179   ui2++;
180 
181 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
182 // CHECK: %{{.*}} = add <2 x i64> [[VAL]], <i64 1, i64 1>
183   sl2++;
184 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
185 // CHECK: %{{.*}} = add <2 x i64> [[VAL]], <i64 1, i64 1>
186   ul2++;
187 
188 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x double>, <2 x double>* @fd2
189 // CHECK: %{{.*}} = fadd <2 x double> [[VAL]], <double 1.000000e+00, double 1.000000e+00>
190   fd2++;
191 }
192 
test_predec(void)193 void test_predec (void)
194 {
195 // CHECK-LABEL: test_predec
196 
197 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
198 // CHECK: %{{.*}} = add <16 x i8> [[VAL]], <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
199   --sc2;
200 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
201 // CHECK: %{{.*}} = add <16 x i8> [[VAL]], <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
202   --uc2;
203 
204 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
205 // CHECK: %{{.*}} = add <8 x i16> [[VAL]], <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
206   --ss2;
207 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
208 // CHECK: %{{.*}} = add <8 x i16> [[VAL]], <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
209   --us2;
210 
211 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
212 // CHECK: %{{.*}} = add <4 x i32> [[VAL]], <i32 -1, i32 -1, i32 -1, i32 -1>
213   --si2;
214 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
215 // CHECK: %{{.*}} = add <4 x i32> [[VAL]], <i32 -1, i32 -1, i32 -1, i32 -1>
216   --ui2;
217 
218 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
219 // CHECK: %{{.*}} = add <2 x i64> [[VAL]], <i64 -1, i64 -1>
220   --sl2;
221 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
222 // CHECK: %{{.*}} = add <2 x i64> [[VAL]], <i64 -1, i64 -1>
223   --ul2;
224 
225 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x double>, <2 x double>* @fd2
226 // CHECK: %{{.*}} = fadd <2 x double> [[VAL]], <double -1.000000e+00, double -1.000000e+00>
227   --fd2;
228 }
229 
test_postdec(void)230 void test_postdec (void)
231 {
232 // CHECK-LABEL: test_postdec
233 
234 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
235 // CHECK: %{{.*}} = add <16 x i8> [[VAL]], <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
236   sc2--;
237 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
238 // CHECK: %{{.*}} = add <16 x i8> [[VAL]], <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
239   uc2--;
240 
241 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
242 // CHECK: %{{.*}} = add <8 x i16> [[VAL]], <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
243   ss2--;
244 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
245 // CHECK: %{{.*}} = add <8 x i16> [[VAL]], <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
246   us2--;
247 
248 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
249 // CHECK: %{{.*}} = add <4 x i32> [[VAL]], <i32 -1, i32 -1, i32 -1, i32 -1>
250   si2--;
251 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
252 // CHECK: %{{.*}} = add <4 x i32> [[VAL]], <i32 -1, i32 -1, i32 -1, i32 -1>
253   ui2--;
254 
255 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
256 // CHECK: %{{.*}} = add <2 x i64> [[VAL]], <i64 -1, i64 -1>
257   sl2--;
258 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
259 // CHECK: %{{.*}} = add <2 x i64> [[VAL]], <i64 -1, i64 -1>
260   ul2--;
261 
262 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x double>, <2 x double>* @fd2
263 // CHECK: %{{.*}} = fadd <2 x double> [[VAL]], <double -1.000000e+00, double -1.000000e+00>
264   fd2--;
265 }
266 
test_add(void)267 void test_add (void)
268 {
269 // CHECK-LABEL: test_add
270 
271 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
272 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
273 // CHECK: %{{.*}} = add <16 x i8> [[VAL2]], [[VAL1]]
274   sc = sc + sc2;
275 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
276 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc2
277 // CHECK: %{{.*}} = add <16 x i8> [[VAL2]], [[VAL1]]
278   sc = sc + bc2;
279 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc
280 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
281 // CHECK: %{{.*}} = add <16 x i8> [[VAL2]], [[VAL1]]
282   sc = bc + sc2;
283 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
284 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
285 // CHECK: %{{.*}} = add <16 x i8> [[VAL2]], [[VAL1]]
286   uc = uc + uc2;
287 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
288 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc2
289 // CHECK: %{{.*}} = add <16 x i8> [[VAL2]], [[VAL1]]
290   uc = uc + bc2;
291 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc
292 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
293 // CHECK: %{{.*}} = add <16 x i8> [[VAL2]], [[VAL1]]
294   uc = bc + uc2;
295 
296 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
297 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
298 // CHECK: %{{.*}} = add <8 x i16> [[VAL2]], [[VAL1]]
299   ss = ss + ss2;
300 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
301 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs2
302 // CHECK: %{{.*}} = add <8 x i16> [[VAL2]], [[VAL1]]
303   ss = ss + bs2;
304 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs
305 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
306 // CHECK: %{{.*}} = add <8 x i16> [[VAL2]], [[VAL1]]
307   ss = bs + ss2;
308 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
309 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
310 // CHECK: %{{.*}} = add <8 x i16> [[VAL2]], [[VAL1]]
311   us = us + us2;
312 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
313 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs2
314 // CHECK: %{{.*}} = add <8 x i16> [[VAL2]], [[VAL1]]
315   us = us + bs2;
316 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs
317 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
318 // CHECK: %{{.*}} = add <8 x i16> [[VAL2]], [[VAL1]]
319   us = bs + us2;
320 
321 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
322 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
323 // CHECK: %{{.*}} = add <4 x i32> [[VAL2]], [[VAL1]]
324   si = si + si2;
325 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
326 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi2
327 // CHECK: %{{.*}} = add <4 x i32> [[VAL2]], [[VAL1]]
328   si = si + bi2;
329 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi
330 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
331 // CHECK: %{{.*}} = add <4 x i32> [[VAL2]], [[VAL1]]
332   si = bi + si2;
333 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
334 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
335 // CHECK: %{{.*}} = add <4 x i32> [[VAL2]], [[VAL1]]
336   ui = ui + ui2;
337 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
338 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi2
339 // CHECK: %{{.*}} = add <4 x i32> [[VAL2]], [[VAL1]]
340   ui = ui + bi2;
341 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi
342 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
343 // CHECK: %{{.*}} = add <4 x i32> [[VAL2]], [[VAL1]]
344   ui = bi + ui2;
345 
346 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
347 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
348 // CHECK: %{{.*}} = add <2 x i64> [[VAL2]], [[VAL1]]
349   sl = sl + sl2;
350 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
351 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl2
352 // CHECK: %{{.*}} = add <2 x i64> [[VAL2]], [[VAL1]]
353   sl = sl + bl2;
354 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl
355 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
356 // CHECK: %{{.*}} = add <2 x i64> [[VAL2]], [[VAL1]]
357   sl = bl + sl2;
358 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
359 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
360 // CHECK: %{{.*}} = add <2 x i64> [[VAL2]], [[VAL1]]
361   ul = ul + ul2;
362 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
363 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl2
364 // CHECK: %{{.*}} = add <2 x i64> [[VAL2]], [[VAL1]]
365   ul = ul + bl2;
366 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl
367 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
368 // CHECK: %{{.*}} = add <2 x i64> [[VAL2]], [[VAL1]]
369   ul = bl + ul2;
370 
371 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x double>, <2 x double>* @fd
372 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x double>, <2 x double>* @fd2
373 // CHECK: %{{.*}} = fadd <2 x double> [[VAL1]], [[VAL2]]
374   fd = fd + fd2;
375 }
376 
test_add_assign(void)377 void test_add_assign (void)
378 {
379 // CHECK-LABEL: test_add_assign
380 
381 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
382 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
383 // CHECK: %{{.*}} = add <16 x i8> [[VAL1]], [[VAL2]]
384   sc += sc2;
385 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc2
386 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
387 // CHECK: %{{.*}} = add <16 x i8> [[VAL1]], [[VAL2]]
388   sc += bc2;
389 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
390 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
391 // CHECK: %{{.*}} = add <16 x i8> [[VAL1]], [[VAL2]]
392   uc += uc2;
393 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc2
394 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
395 // CHECK: %{{.*}} = add <16 x i8> [[VAL1]], [[VAL2]]
396   uc += bc2;
397 
398 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
399 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
400 // CHECK: %{{.*}} = add <8 x i16> [[VAL1]], [[VAL2]]
401   ss += ss2;
402 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs2
403 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
404 // CHECK: %{{.*}} = add <8 x i16> [[VAL1]], [[VAL2]]
405   ss += bs2;
406 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
407 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
408 // CHECK: %{{.*}} = add <8 x i16> [[VAL1]], [[VAL2]]
409   us += us2;
410 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs2
411 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
412 // CHECK: %{{.*}} = add <8 x i16> [[VAL1]], [[VAL2]]
413   us += bs2;
414 
415 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
416 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
417 // CHECK: %{{.*}} = add <4 x i32> [[VAL1]], [[VAL2]]
418   si += si2;
419 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi2
420 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
421 // CHECK: %{{.*}} = add <4 x i32> [[VAL1]], [[VAL2]]
422   si += bi2;
423 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
424 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
425 // CHECK: %{{.*}} = add <4 x i32> [[VAL1]], [[VAL2]]
426   ui += ui2;
427 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi2
428 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
429 // CHECK: %{{.*}} = add <4 x i32> [[VAL1]], [[VAL2]]
430   ui += bi2;
431 
432 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
433 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
434 // CHECK: %{{.*}} = add <2 x i64> [[VAL1]], [[VAL2]]
435   sl += sl2;
436 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl2
437 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
438 // CHECK: %{{.*}} = add <2 x i64> [[VAL1]], [[VAL2]]
439   sl += bl2;
440 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
441 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
442 // CHECK: %{{.*}} = add <2 x i64> [[VAL1]], [[VAL2]]
443   ul += ul2;
444 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl2
445 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
446 // CHECK: %{{.*}} = add <2 x i64> [[VAL1]], [[VAL2]]
447   ul += bl2;
448 
449 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x double>, <2 x double>* @fd2
450 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x double>, <2 x double>* @fd
451 // CHECK: %{{.*}} = fadd <2 x double> [[VAL2]], [[VAL1]]
452   fd += fd2;
453 }
454 
test_sub(void)455 void test_sub (void)
456 {
457 // CHECK-LABEL: test_sub
458 
459 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
460 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
461 // CHECK: %{{.*}} = sub <16 x i8> [[VAL1]], [[VAL2]]
462   sc = sc - sc2;
463 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
464 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc2
465 // CHECK: %{{.*}} = sub <16 x i8> [[VAL1]], [[VAL2]]
466   sc = sc - bc2;
467 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc
468 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
469 // CHECK: %{{.*}} = sub <16 x i8> [[VAL1]], [[VAL2]]
470   sc = bc - sc2;
471 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
472 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
473 // CHECK: %{{.*}} = sub <16 x i8> [[VAL1]], [[VAL2]]
474   uc = uc - uc2;
475 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
476 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc2
477 // CHECK: %{{.*}} = sub <16 x i8> [[VAL1]], [[VAL2]]
478   uc = uc - bc2;
479 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc
480 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
481 // CHECK: %{{.*}} = sub <16 x i8> [[VAL1]], [[VAL2]]
482   uc = bc - uc2;
483 
484 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
485 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
486 // CHECK: %{{.*}} = sub <8 x i16> [[VAL1]], [[VAL2]]
487   ss = ss - ss2;
488 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
489 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs2
490 // CHECK: %{{.*}} = sub <8 x i16> [[VAL1]], [[VAL2]]
491   ss = ss - bs2;
492 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs
493 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
494 // CHECK: %{{.*}} = sub <8 x i16> [[VAL1]], [[VAL2]]
495   ss = bs - ss2;
496 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
497 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
498 // CHECK: %{{.*}} = sub <8 x i16> [[VAL1]], [[VAL2]]
499   us = us - us2;
500 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
501 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs2
502 // CHECK: %{{.*}} = sub <8 x i16> [[VAL1]], [[VAL2]]
503   us = us - bs2;
504 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs
505 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
506 // CHECK: %{{.*}} = sub <8 x i16> [[VAL1]], [[VAL2]]
507   us = bs - us2;
508 
509 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
510 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
511 // CHECK: %{{.*}} = sub <4 x i32> [[VAL1]], [[VAL2]]
512   si = si - si2;
513 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
514 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi2
515 // CHECK: %{{.*}} = sub <4 x i32> [[VAL1]], [[VAL2]]
516   si = si - bi2;
517 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi
518 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
519 // CHECK: %{{.*}} = sub <4 x i32> [[VAL1]], [[VAL2]]
520   si = bi - si2;
521 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
522 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
523 // CHECK: %{{.*}} = sub <4 x i32> [[VAL1]], [[VAL2]]
524   ui = ui - ui2;
525 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
526 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi2
527 // CHECK: %{{.*}} = sub <4 x i32> [[VAL1]], [[VAL2]]
528   ui = ui - bi2;
529 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi
530 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
531 // CHECK: %{{.*}} = sub <4 x i32> [[VAL1]], [[VAL2]]
532   ui = bi - ui2;
533 
534 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
535 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
536 // CHECK: %{{.*}} = sub <2 x i64> [[VAL1]], [[VAL2]]
537   sl = sl - sl2;
538 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
539 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl2
540 // CHECK: %{{.*}} = sub <2 x i64> [[VAL1]], [[VAL2]]
541   sl = sl - bl2;
542 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl
543 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
544 // CHECK: %{{.*}} = sub <2 x i64> [[VAL1]], [[VAL2]]
545   sl = bl - sl2;
546 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
547 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
548 // CHECK: %{{.*}} = sub <2 x i64> [[VAL1]], [[VAL2]]
549   ul = ul - ul2;
550 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
551 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl2
552 // CHECK: %{{.*}} = sub <2 x i64> [[VAL1]], [[VAL2]]
553   ul = ul - bl2;
554 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl
555 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
556 // CHECK: %{{.*}} = sub <2 x i64> [[VAL1]], [[VAL2]]
557   ul = bl - ul2;
558 
559 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x double>, <2 x double>* @fd
560 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x double>, <2 x double>* @fd2
561 // CHECK: %{{.*}} = fsub <2 x double> [[VAL1]], [[VAL2]]
562   fd = fd - fd2;
563 }
564 
test_sub_assign(void)565 void test_sub_assign (void)
566 {
567 // CHECK-LABEL: test_sub_assign
568 
569 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
570 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
571 // CHECK: %{{.*}} = sub <16 x i8> [[VAL1]], [[VAL2]]
572   sc -= sc2;
573 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc2
574 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
575 // CHECK: %{{.*}} = sub <16 x i8> [[VAL1]], [[VAL2]]
576   sc -= bc2;
577 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
578 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
579 // CHECK: %{{.*}} = sub <16 x i8> [[VAL1]], [[VAL2]]
580   uc -= uc2;
581 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc2
582 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
583 // CHECK: %{{.*}} = sub <16 x i8> [[VAL1]], [[VAL2]]
584   uc -= bc2;
585 
586 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
587 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
588 // CHECK: %{{.*}} = sub <8 x i16> [[VAL1]], [[VAL2]]
589   ss -= ss2;
590 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs2
591 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
592 // CHECK: %{{.*}} = sub <8 x i16> [[VAL1]], [[VAL2]]
593   ss -= bs2;
594 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
595 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
596 // CHECK: %{{.*}} = sub <8 x i16> [[VAL1]], [[VAL2]]
597   us -= us2;
598 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs2
599 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
600 // CHECK: %{{.*}} = sub <8 x i16> [[VAL1]], [[VAL2]]
601   us -= bs2;
602 
603 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
604 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
605 // CHECK: %{{.*}} = sub <4 x i32> [[VAL1]], [[VAL2]]
606   si -= si2;
607 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi2
608 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
609 // CHECK: %{{.*}} = sub <4 x i32> [[VAL1]], [[VAL2]]
610   si -= bi2;
611 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
612 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
613 // CHECK: %{{.*}} = sub <4 x i32> [[VAL1]], [[VAL2]]
614   ui -= ui2;
615 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi2
616 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
617 // CHECK: %{{.*}} = sub <4 x i32> [[VAL1]], [[VAL2]]
618   ui -= bi2;
619 
620 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
621 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
622 // CHECK: %{{.*}} = sub <2 x i64> [[VAL1]], [[VAL2]]
623   sl -= sl2;
624 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl2
625 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
626 // CHECK: %{{.*}} = sub <2 x i64> [[VAL1]], [[VAL2]]
627   sl -= bl2;
628 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
629 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
630 // CHECK: %{{.*}} = sub <2 x i64> [[VAL1]], [[VAL2]]
631   ul -= ul2;
632 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl2
633 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
634 // CHECK: %{{.*}} = sub <2 x i64> [[VAL1]], [[VAL2]]
635   ul -= bl2;
636 
637 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x double>, <2 x double>* @fd2
638 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x double>, <2 x double>* @fd
639 // CHECK: %{{.*}} = fsub <2 x double> [[VAL1]], [[VAL2]]
640   fd -= fd2;
641 }
642 
test_mul(void)643 void test_mul (void)
644 {
645 // CHECK-LABEL: test_mul
646 
647 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
648 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
649 // CHECK: %{{.*}} = mul <16 x i8> [[VAL2]], [[VAL1]]
650   sc = sc * sc2;
651 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
652 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
653 // CHECK: %{{.*}} = mul <16 x i8> [[VAL2]], [[VAL1]]
654   uc = uc * uc2;
655 
656 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
657 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
658 // CHECK: %{{.*}} = mul <8 x i16> [[VAL2]], [[VAL1]]
659   ss = ss * ss2;
660 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
661 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
662 // CHECK: %{{.*}} = mul <8 x i16> [[VAL2]], [[VAL1]]
663   us = us * us2;
664 
665 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
666 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
667 // CHECK: %{{.*}} = mul <4 x i32> [[VAL2]], [[VAL1]]
668   si = si * si2;
669 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
670 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
671 // CHECK: %{{.*}} = mul <4 x i32> [[VAL2]], [[VAL1]]
672   ui = ui * ui2;
673 
674 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
675 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
676 // CHECK: %{{.*}} = mul <2 x i64> [[VAL2]], [[VAL1]]
677   sl = sl * sl2;
678 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
679 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
680 // CHECK: %{{.*}} = mul <2 x i64> [[VAL2]], [[VAL1]]
681   ul = ul * ul2;
682 
683 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x double>, <2 x double>* @fd
684 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x double>, <2 x double>* @fd2
685 // CHECK: %{{.*}} = fmul <2 x double> [[VAL1]], [[VAL2]]
686   fd = fd * fd2;
687 }
688 
test_mul_assign(void)689 void test_mul_assign (void)
690 {
691 // CHECK-LABEL: test_mul_assign
692 
693 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
694 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
695 // CHECK: %{{.*}} = mul <16 x i8> [[VAL1]], [[VAL2]]
696   sc *= sc2;
697 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
698 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
699 // CHECK: %{{.*}} = mul <16 x i8> [[VAL1]], [[VAL2]]
700   uc *= uc2;
701 
702 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
703 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
704 // CHECK: %{{.*}} = mul <8 x i16> [[VAL1]], [[VAL2]]
705   ss *= ss2;
706 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
707 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
708 // CHECK: %{{.*}} = mul <8 x i16> [[VAL1]], [[VAL2]]
709   us *= us2;
710 
711 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
712 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
713 // CHECK: %{{.*}} = mul <4 x i32> [[VAL1]], [[VAL2]]
714   si *= si2;
715 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
716 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
717 // CHECK: %{{.*}} = mul <4 x i32> [[VAL1]], [[VAL2]]
718   ui *= ui2;
719 
720 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
721 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
722 // CHECK: %{{.*}} = mul <2 x i64> [[VAL1]], [[VAL2]]
723   sl *= sl2;
724 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
725 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
726 // CHECK: %{{.*}} = mul <2 x i64> [[VAL1]], [[VAL2]]
727   ul *= ul2;
728 
729 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x double>, <2 x double>* @fd2
730 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x double>, <2 x double>* @fd
731 // CHECK: %{{.*}} = fmul <2 x double> [[VAL2]], [[VAL1]]
732   fd *= fd2;
733 }
734 
test_div(void)735 void test_div (void)
736 {
737 // CHECK-LABEL: test_div
738 
739 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
740 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
741 // CHECK: %{{.*}} = sdiv <16 x i8> [[VAL1]], [[VAL2]]
742   sc = sc / sc2;
743 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
744 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
745 // CHECK: %{{.*}} = udiv <16 x i8> [[VAL1]], [[VAL2]]
746   uc = uc / uc2;
747 
748 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
749 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
750 // CHECK: %{{.*}} = sdiv <8 x i16> [[VAL1]], [[VAL2]]
751   ss = ss / ss2;
752 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
753 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
754 // CHECK: %{{.*}} = udiv <8 x i16> [[VAL1]], [[VAL2]]
755   us = us / us2;
756 
757 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
758 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
759 // CHECK: %{{.*}} = sdiv <4 x i32> [[VAL1]], [[VAL2]]
760   si = si / si2;
761 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
762 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
763 // CHECK: %{{.*}} = udiv <4 x i32> [[VAL1]], [[VAL2]]
764   ui = ui / ui2;
765 
766 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
767 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
768 // CHECK: %{{.*}} = sdiv <2 x i64> [[VAL1]], [[VAL2]]
769   sl = sl / sl2;
770 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
771 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
772 // CHECK: %{{.*}} = udiv <2 x i64> [[VAL1]], [[VAL2]]
773   ul = ul / ul2;
774 
775 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x double>, <2 x double>* @fd
776 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x double>, <2 x double>* @fd2
777 // CHECK: %{{.*}} = fdiv <2 x double> [[VAL1]], [[VAL2]]
778   fd = fd / fd2;
779 }
780 
test_div_assign(void)781 void test_div_assign (void)
782 {
783 // CHECK-LABEL: test_div_assign
784 
785 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
786 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
787 // CHECK: %{{.*}} = sdiv <16 x i8> [[VAL1]], [[VAL2]]
788   sc /= sc2;
789 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
790 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
791 // CHECK: %{{.*}} = udiv <16 x i8> [[VAL1]], [[VAL2]]
792   uc /= uc2;
793 
794 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
795 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
796 // CHECK: %{{.*}} = sdiv <8 x i16> [[VAL1]], [[VAL2]]
797   ss /= ss2;
798 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
799 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
800 // CHECK: %{{.*}} = udiv <8 x i16> [[VAL1]], [[VAL2]]
801   us /= us2;
802 
803 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
804 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
805 // CHECK: %{{.*}} = sdiv <4 x i32> [[VAL1]], [[VAL2]]
806   si /= si2;
807 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
808 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
809 // CHECK: %{{.*}} = udiv <4 x i32> [[VAL1]], [[VAL2]]
810   ui /= ui2;
811 
812 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
813 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
814 // CHECK: %{{.*}} = sdiv <2 x i64> [[VAL1]], [[VAL2]]
815   sl /= sl2;
816 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
817 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
818 // CHECK: %{{.*}} = udiv <2 x i64> [[VAL1]], [[VAL2]]
819   ul /= ul2;
820 
821 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x double>, <2 x double>* @fd2
822 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x double>, <2 x double>* @fd
823 // CHECK: %{{.*}} = fdiv <2 x double> [[VAL1]], [[VAL2]]
824   fd /= fd2;
825 }
826 
test_rem(void)827 void test_rem (void)
828 {
829 // CHECK-LABEL: test_rem
830 
831 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
832 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
833 // CHECK: %{{.*}} = srem <16 x i8> [[VAL1]], [[VAL2]]
834   sc = sc % sc2;
835 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
836 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
837 // CHECK: %{{.*}} = urem <16 x i8> [[VAL1]], [[VAL2]]
838   uc = uc % uc2;
839 
840 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
841 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
842 // CHECK: %{{.*}} = srem <8 x i16> [[VAL1]], [[VAL2]]
843   ss = ss % ss2;
844 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
845 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
846 // CHECK: %{{.*}} = urem <8 x i16> [[VAL1]], [[VAL2]]
847   us = us % us2;
848 
849 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
850 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
851 // CHECK: %{{.*}} = srem <4 x i32> [[VAL1]], [[VAL2]]
852   si = si % si2;
853 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
854 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
855 // CHECK: %{{.*}} = urem <4 x i32> [[VAL1]], [[VAL2]]
856   ui = ui % ui2;
857 
858 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
859 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
860 // CHECK: %{{.*}} = srem <2 x i64> [[VAL1]], [[VAL2]]
861   sl = sl % sl2;
862 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
863 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
864 // CHECK: %{{.*}} = urem <2 x i64> [[VAL1]], [[VAL2]]
865   ul = ul % ul2;
866 }
867 
test_rem_assign(void)868 void test_rem_assign (void)
869 {
870 // CHECK-LABEL: test_rem_assign
871 
872 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
873 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
874 // CHECK: %{{.*}} = srem <16 x i8> [[VAL1]], [[VAL2]]
875   sc %= sc2;
876 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
877 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
878 // CHECK: %{{.*}} = urem <16 x i8> [[VAL1]], [[VAL2]]
879   uc %= uc2;
880 
881 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
882 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
883 // CHECK: %{{.*}} = srem <8 x i16> [[VAL1]], [[VAL2]]
884   ss %= ss2;
885 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
886 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
887 // CHECK: %{{.*}} = urem <8 x i16> [[VAL1]], [[VAL2]]
888   us %= us2;
889 
890 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
891 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
892 // CHECK: %{{.*}} = srem <4 x i32> [[VAL1]], [[VAL2]]
893   si %= si2;
894 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
895 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
896 // CHECK: %{{.*}} = urem <4 x i32> [[VAL1]], [[VAL2]]
897   ui %= ui2;
898 
899 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
900 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
901 // CHECK: %{{.*}} = srem <2 x i64> [[VAL1]], [[VAL2]]
902   sl %= sl2;
903 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
904 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
905 // CHECK: %{{.*}} = urem <2 x i64> [[VAL1]], [[VAL2]]
906   ul %= ul2;
907 }
908 
test_not(void)909 void test_not (void)
910 {
911 // CHECK-LABEL: test_not
912 
913 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
914 // CHECK: %{{.*}} = xor <16 x i8> [[VAL]], <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
915   sc = ~sc2;
916 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
917 // CHECK: %{{.*}} = xor <16 x i8> [[VAL]], <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
918   uc = ~uc2;
919 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc2
920 // CHECK: %{{.*}} = xor <16 x i8> [[VAL]], <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
921   bc = ~bc2;
922 
923 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
924 // CHECK: %{{.*}} = xor <8 x i16> [[VAL]], <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
925   ss = ~ss2;
926 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
927 // CHECK: %{{.*}} = xor <8 x i16> [[VAL]], <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
928   us = ~us2;
929 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs2
930 // CHECK: %{{.*}} = xor <8 x i16> [[VAL]], <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
931   bs = ~bs2;
932 
933 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
934 // CHECK: %{{.*}} = xor <4 x i32> [[VAL]], <i32 -1, i32 -1, i32 -1, i32 -1>
935   si = ~si2;
936 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
937 // CHECK: %{{.*}} = xor <4 x i32> [[VAL]], <i32 -1, i32 -1, i32 -1, i32 -1>
938   ui = ~ui2;
939 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi2
940 // CHECK: %{{.*}} = xor <4 x i32> [[VAL]], <i32 -1, i32 -1, i32 -1, i32 -1>
941   bi = ~bi2;
942 
943 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
944 // CHECK: %{{.*}} = xor <2 x i64> [[VAL]], <i64 -1, i64 -1>
945   sl = ~sl2;
946 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
947 // CHECK: %{{.*}} = xor <2 x i64> [[VAL]], <i64 -1, i64 -1>
948   ul = ~ul2;
949 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl2
950 // CHECK: %{{.*}} = xor <2 x i64> [[VAL]], <i64 -1, i64 -1>
951   bl = ~bl2;
952 }
953 
test_and(void)954 void test_and (void)
955 {
956 // CHECK-LABEL: test_and
957 
958 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
959 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
960 // CHECK: %{{.*}} = and <16 x i8> [[VAL2]], [[VAL1]]
961   sc = sc & sc2;
962 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
963 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc2
964 // CHECK: %{{.*}} = and <16 x i8> [[VAL2]], [[VAL1]]
965   sc = sc & bc2;
966 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc
967 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
968 // CHECK: %{{.*}} = and <16 x i8> [[VAL2]], [[VAL1]]
969   sc = bc & sc2;
970 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
971 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
972 // CHECK: %{{.*}} = and <16 x i8> [[VAL2]], [[VAL1]]
973   uc = uc & uc2;
974 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
975 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc2
976 // CHECK: %{{.*}} = and <16 x i8> [[VAL2]], [[VAL1]]
977   uc = uc & bc2;
978 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc
979 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
980 // CHECK: %{{.*}} = and <16 x i8> [[VAL2]], [[VAL1]]
981   uc = bc & uc2;
982 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc
983 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc2
984 // CHECK: %{{.*}} = and <16 x i8> [[VAL2]], [[VAL1]]
985   bc = bc & bc2;
986 
987 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
988 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
989 // CHECK: %{{.*}} = and <8 x i16> [[VAL2]], [[VAL1]]
990   ss = ss & ss2;
991 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
992 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs2
993 // CHECK: %{{.*}} = and <8 x i16> [[VAL2]], [[VAL1]]
994   ss = ss & bs2;
995 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs
996 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
997 // CHECK: %{{.*}} = and <8 x i16> [[VAL2]], [[VAL1]]
998   ss = bs & ss2;
999 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
1000 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
1001 // CHECK: %{{.*}} = and <8 x i16> [[VAL2]], [[VAL1]]
1002   us = us & us2;
1003 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
1004 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs2
1005 // CHECK: %{{.*}} = and <8 x i16> [[VAL2]], [[VAL1]]
1006   us = us & bs2;
1007 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs
1008 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
1009 // CHECK: %{{.*}} = and <8 x i16> [[VAL2]], [[VAL1]]
1010   us = bs & us2;
1011 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs
1012 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs2
1013 // CHECK: %{{.*}} = and <8 x i16> [[VAL2]], [[VAL1]]
1014   bs = bs & bs2;
1015 
1016 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
1017 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
1018 // CHECK: %{{.*}} = and <4 x i32> [[VAL2]], [[VAL1]]
1019   si = si & si2;
1020 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
1021 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi2
1022 // CHECK: %{{.*}} = and <4 x i32> [[VAL2]], [[VAL1]]
1023   si = si & bi2;
1024 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi
1025 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
1026 // CHECK: %{{.*}} = and <4 x i32> [[VAL2]], [[VAL1]]
1027   si = bi & si2;
1028 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
1029 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
1030 // CHECK: %{{.*}} = and <4 x i32> [[VAL2]], [[VAL1]]
1031   ui = ui & ui2;
1032 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
1033 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi2
1034 // CHECK: %{{.*}} = and <4 x i32> [[VAL2]], [[VAL1]]
1035   ui = ui & bi2;
1036 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi
1037 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
1038 // CHECK: %{{.*}} = and <4 x i32> [[VAL2]], [[VAL1]]
1039   ui = bi & ui2;
1040 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi
1041 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi2
1042 // CHECK: %{{.*}} = and <4 x i32> [[VAL2]], [[VAL1]]
1043   bi = bi & bi2;
1044 
1045 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
1046 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
1047 // CHECK: %{{.*}} = and <2 x i64> [[VAL2]], [[VAL1]]
1048   sl = sl & sl2;
1049 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
1050 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl2
1051 // CHECK: %{{.*}} = and <2 x i64> [[VAL2]], [[VAL1]]
1052   sl = sl & bl2;
1053 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl
1054 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
1055 // CHECK: %{{.*}} = and <2 x i64> [[VAL2]], [[VAL1]]
1056   sl = bl & sl2;
1057 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
1058 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
1059 // CHECK: %{{.*}} = and <2 x i64> [[VAL2]], [[VAL1]]
1060   ul = ul & ul2;
1061 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
1062 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl2
1063 // CHECK: %{{.*}} = and <2 x i64> [[VAL2]], [[VAL1]]
1064   ul = ul & bl2;
1065 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl
1066 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
1067 // CHECK: %{{.*}} = and <2 x i64> [[VAL2]], [[VAL1]]
1068   ul = bl & ul2;
1069 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl
1070 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl2
1071 // CHECK: %{{.*}} = and <2 x i64> [[VAL2]], [[VAL1]]
1072   bl = bl & bl2;
1073 }
1074 
test_and_assign(void)1075 void test_and_assign (void)
1076 {
1077 // CHECK-LABEL: test_and_assign
1078 
1079 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
1080 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
1081 // CHECK: %{{.*}} = and <16 x i8> [[VAL1]], [[VAL2]]
1082   sc &= sc2;
1083 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc2
1084 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
1085 // CHECK: %{{.*}} = and <16 x i8> [[VAL1]], [[VAL2]]
1086   sc &= bc2;
1087 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
1088 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
1089 // CHECK: %{{.*}} = and <16 x i8> [[VAL1]], [[VAL2]]
1090   uc &= uc2;
1091 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc2
1092 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
1093 // CHECK: %{{.*}} = and <16 x i8> [[VAL1]], [[VAL2]]
1094   uc &= bc2;
1095 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc2
1096 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc
1097 // CHECK: %{{.*}} = and <16 x i8> [[VAL1]], [[VAL2]]
1098   bc &= bc2;
1099 
1100 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
1101 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
1102 // CHECK: %{{.*}} = and <8 x i16> [[VAL1]], [[VAL2]]
1103   ss &= ss2;
1104 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs2
1105 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
1106 // CHECK: %{{.*}} = and <8 x i16> [[VAL1]], [[VAL2]]
1107   ss &= bs2;
1108 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
1109 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
1110 // CHECK: %{{.*}} = and <8 x i16> [[VAL1]], [[VAL2]]
1111   us &= us2;
1112 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs2
1113 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
1114 // CHECK: %{{.*}} = and <8 x i16> [[VAL1]], [[VAL2]]
1115   us &= bs2;
1116 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs2
1117 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs
1118 // CHECK: %{{.*}} = and <8 x i16> [[VAL1]], [[VAL2]]
1119   bs &= bs2;
1120 
1121 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
1122 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
1123 // CHECK: %{{.*}} = and <4 x i32> [[VAL1]], [[VAL2]]
1124   si &= si2;
1125 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi2
1126 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
1127 // CHECK: %{{.*}} = and <4 x i32> [[VAL1]], [[VAL2]]
1128   si &= bi2;
1129 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
1130 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
1131 // CHECK: %{{.*}} = and <4 x i32> [[VAL1]], [[VAL2]]
1132   ui &= ui2;
1133 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi2
1134 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
1135 // CHECK: %{{.*}} = and <4 x i32> [[VAL1]], [[VAL2]]
1136   ui &= bi2;
1137 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi2
1138 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi
1139 // CHECK: %{{.*}} = and <4 x i32> [[VAL1]], [[VAL2]]
1140   bi &= bi2;
1141 
1142 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
1143 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
1144 // CHECK: %{{.*}} = and <2 x i64> [[VAL1]], [[VAL2]]
1145   sl &= sl2;
1146 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl2
1147 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
1148 // CHECK: %{{.*}} = and <2 x i64> [[VAL1]], [[VAL2]]
1149   sl &= bl2;
1150 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
1151 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
1152 // CHECK: %{{.*}} = and <2 x i64> [[VAL1]], [[VAL2]]
1153   ul &= ul2;
1154 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl2
1155 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
1156 // CHECK: %{{.*}} = and <2 x i64> [[VAL1]], [[VAL2]]
1157   ul &= bl2;
1158 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl2
1159 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl
1160 // CHECK: %{{.*}} = and <2 x i64> [[VAL1]], [[VAL2]]
1161   bl &= bl2;
1162 }
1163 
test_or(void)1164 void test_or (void)
1165 {
1166 // CHECK-LABEL: test_or
1167 
1168 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
1169 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
1170 // CHECK: %{{.*}} = or <16 x i8> [[VAL2]], [[VAL1]]
1171   sc = sc | sc2;
1172 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
1173 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc2
1174 // CHECK: %{{.*}} = or <16 x i8> [[VAL2]], [[VAL1]]
1175   sc = sc | bc2;
1176 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc
1177 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
1178 // CHECK: %{{.*}} = or <16 x i8> [[VAL2]], [[VAL1]]
1179   sc = bc | sc2;
1180 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
1181 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
1182 // CHECK: %{{.*}} = or <16 x i8> [[VAL2]], [[VAL1]]
1183   uc = uc | uc2;
1184 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
1185 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc2
1186 // CHECK: %{{.*}} = or <16 x i8> [[VAL2]], [[VAL1]]
1187   uc = uc | bc2;
1188 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc
1189 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
1190 // CHECK: %{{.*}} = or <16 x i8> [[VAL2]], [[VAL1]]
1191   uc = bc | uc2;
1192 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc
1193 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc2
1194 // CHECK: %{{.*}} = or <16 x i8> [[VAL2]], [[VAL1]]
1195   bc = bc | bc2;
1196 
1197 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
1198 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
1199 // CHECK: %{{.*}} = or <8 x i16> [[VAL2]], [[VAL1]]
1200   ss = ss | ss2;
1201 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
1202 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs2
1203 // CHECK: %{{.*}} = or <8 x i16> [[VAL2]], [[VAL1]]
1204   ss = ss | bs2;
1205 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs
1206 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
1207 // CHECK: %{{.*}} = or <8 x i16> [[VAL2]], [[VAL1]]
1208   ss = bs | ss2;
1209 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
1210 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
1211 // CHECK: %{{.*}} = or <8 x i16> [[VAL2]], [[VAL1]]
1212   us = us | us2;
1213 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
1214 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs2
1215 // CHECK: %{{.*}} = or <8 x i16> [[VAL2]], [[VAL1]]
1216   us = us | bs2;
1217 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs
1218 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
1219 // CHECK: %{{.*}} = or <8 x i16> [[VAL2]], [[VAL1]]
1220   us = bs | us2;
1221 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs
1222 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs2
1223 // CHECK: %{{.*}} = or <8 x i16> [[VAL2]], [[VAL1]]
1224   bs = bs | bs2;
1225 
1226 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
1227 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
1228 // CHECK: %{{.*}} = or <4 x i32> [[VAL2]], [[VAL1]]
1229   si = si | si2;
1230 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
1231 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi2
1232 // CHECK: %{{.*}} = or <4 x i32> [[VAL2]], [[VAL1]]
1233   si = si | bi2;
1234 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi
1235 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
1236 // CHECK: %{{.*}} = or <4 x i32> [[VAL2]], [[VAL1]]
1237   si = bi | si2;
1238 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
1239 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
1240 // CHECK: %{{.*}} = or <4 x i32> [[VAL2]], [[VAL1]]
1241   ui = ui | ui2;
1242 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
1243 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi2
1244 // CHECK: %{{.*}} = or <4 x i32> [[VAL2]], [[VAL1]]
1245   ui = ui | bi2;
1246 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi
1247 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
1248 // CHECK: %{{.*}} = or <4 x i32> [[VAL2]], [[VAL1]]
1249   ui = bi | ui2;
1250 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi
1251 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi2
1252 // CHECK: %{{.*}} = or <4 x i32> [[VAL2]], [[VAL1]]
1253   bi = bi | bi2;
1254 
1255 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
1256 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
1257 // CHECK: %{{.*}} = or <2 x i64> [[VAL2]], [[VAL1]]
1258   sl = sl | sl2;
1259 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
1260 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl2
1261 // CHECK: %{{.*}} = or <2 x i64> [[VAL2]], [[VAL1]]
1262   sl = sl | bl2;
1263 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl
1264 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
1265 // CHECK: %{{.*}} = or <2 x i64> [[VAL2]], [[VAL1]]
1266   sl = bl | sl2;
1267 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
1268 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
1269 // CHECK: %{{.*}} = or <2 x i64> [[VAL2]], [[VAL1]]
1270   ul = ul | ul2;
1271 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
1272 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl2
1273 // CHECK: %{{.*}} = or <2 x i64> [[VAL2]], [[VAL1]]
1274   ul = ul | bl2;
1275 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl
1276 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
1277 // CHECK: %{{.*}} = or <2 x i64> [[VAL2]], [[VAL1]]
1278   ul = bl | ul2;
1279 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl
1280 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl2
1281 // CHECK: %{{.*}} = or <2 x i64> [[VAL2]], [[VAL1]]
1282   bl = bl | bl2;
1283 }
1284 
test_or_assign(void)1285 void test_or_assign (void)
1286 {
1287 // CHECK-LABEL: test_or_assign
1288 
1289 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
1290 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
1291 // CHECK: %{{.*}} = or <16 x i8> [[VAL1]], [[VAL2]]
1292   sc |= sc2;
1293 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc2
1294 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
1295 // CHECK: %{{.*}} = or <16 x i8> [[VAL1]], [[VAL2]]
1296   sc |= bc2;
1297 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
1298 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
1299 // CHECK: %{{.*}} = or <16 x i8> [[VAL1]], [[VAL2]]
1300   uc |= uc2;
1301 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc2
1302 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
1303 // CHECK: %{{.*}} = or <16 x i8> [[VAL1]], [[VAL2]]
1304   uc |= bc2;
1305 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc2
1306 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc
1307 // CHECK: %{{.*}} = or <16 x i8> [[VAL1]], [[VAL2]]
1308   bc |= bc2;
1309 
1310 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
1311 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
1312 // CHECK: %{{.*}} = or <8 x i16> [[VAL1]], [[VAL2]]
1313   ss |= ss2;
1314 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs2
1315 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
1316 // CHECK: %{{.*}} = or <8 x i16> [[VAL1]], [[VAL2]]
1317   ss |= bs2;
1318 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
1319 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
1320 // CHECK: %{{.*}} = or <8 x i16> [[VAL1]], [[VAL2]]
1321   us |= us2;
1322 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs2
1323 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
1324 // CHECK: %{{.*}} = or <8 x i16> [[VAL1]], [[VAL2]]
1325   us |= bs2;
1326 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs2
1327 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs
1328 // CHECK: %{{.*}} = or <8 x i16> [[VAL1]], [[VAL2]]
1329   bs |= bs2;
1330 
1331 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
1332 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
1333 // CHECK: %{{.*}} = or <4 x i32> [[VAL1]], [[VAL2]]
1334   si |= si2;
1335 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi2
1336 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
1337 // CHECK: %{{.*}} = or <4 x i32> [[VAL1]], [[VAL2]]
1338   si |= bi2;
1339 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
1340 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
1341 // CHECK: %{{.*}} = or <4 x i32> [[VAL1]], [[VAL2]]
1342   ui |= ui2;
1343 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi2
1344 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
1345 // CHECK: %{{.*}} = or <4 x i32> [[VAL1]], [[VAL2]]
1346   ui |= bi2;
1347 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi2
1348 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi
1349 // CHECK: %{{.*}} = or <4 x i32> [[VAL1]], [[VAL2]]
1350   bi |= bi2;
1351 
1352 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
1353 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
1354 // CHECK: %{{.*}} = or <2 x i64> [[VAL1]], [[VAL2]]
1355   sl |= sl2;
1356 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl2
1357 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
1358 // CHECK: %{{.*}} = or <2 x i64> [[VAL1]], [[VAL2]]
1359   sl |= bl2;
1360 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
1361 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
1362 // CHECK: %{{.*}} = or <2 x i64> [[VAL1]], [[VAL2]]
1363   ul |= ul2;
1364 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl2
1365 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
1366 // CHECK: %{{.*}} = or <2 x i64> [[VAL1]], [[VAL2]]
1367   ul |= bl2;
1368 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl2
1369 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl
1370 // CHECK: %{{.*}} = or <2 x i64> [[VAL1]], [[VAL2]]
1371   bl |= bl2;
1372 }
1373 
test_xor(void)1374 void test_xor (void)
1375 {
1376 // CHECK-LABEL: test_xor
1377 
1378 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
1379 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
1380 // CHECK: %{{.*}} = xor <16 x i8> [[VAL1]], [[VAL2]]
1381   sc = sc ^ sc2;
1382 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
1383 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc2
1384 // CHECK: %{{.*}} = xor <16 x i8> [[VAL1]], [[VAL2]]
1385   sc = sc ^ bc2;
1386 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc
1387 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
1388 // CHECK: %{{.*}} = xor <16 x i8> [[VAL1]], [[VAL2]]
1389   sc = bc ^ sc2;
1390 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
1391 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
1392 // CHECK: %{{.*}} = xor <16 x i8> [[VAL1]], [[VAL2]]
1393   uc = uc ^ uc2;
1394 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
1395 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc2
1396 // CHECK: %{{.*}} = xor <16 x i8> [[VAL1]], [[VAL2]]
1397   uc = uc ^ bc2;
1398 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc
1399 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
1400 // CHECK: %{{.*}} = xor <16 x i8> [[VAL1]], [[VAL2]]
1401   uc = bc ^ uc2;
1402 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc
1403 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc2
1404 // CHECK: %{{.*}} = xor <16 x i8> [[VAL1]], [[VAL2]]
1405   bc = bc ^ bc2;
1406 
1407 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
1408 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
1409 // CHECK: %{{.*}} = xor <8 x i16> [[VAL1]], [[VAL2]]
1410   ss = ss ^ ss2;
1411 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
1412 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs2
1413 // CHECK: %{{.*}} = xor <8 x i16> [[VAL1]], [[VAL2]]
1414   ss = ss ^ bs2;
1415 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs
1416 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
1417 // CHECK: %{{.*}} = xor <8 x i16> [[VAL1]], [[VAL2]]
1418   ss = bs ^ ss2;
1419 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
1420 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
1421 // CHECK: %{{.*}} = xor <8 x i16> [[VAL1]], [[VAL2]]
1422   us = us ^ us2;
1423 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
1424 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs2
1425 // CHECK: %{{.*}} = xor <8 x i16> [[VAL1]], [[VAL2]]
1426   us = us ^ bs2;
1427 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs
1428 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
1429 // CHECK: %{{.*}} = xor <8 x i16> [[VAL1]], [[VAL2]]
1430   us = bs ^ us2;
1431 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs
1432 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs2
1433 // CHECK: %{{.*}} = xor <8 x i16> [[VAL1]], [[VAL2]]
1434   bs = bs ^ bs2;
1435 
1436 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
1437 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
1438 // CHECK: %{{.*}} = xor <4 x i32> [[VAL1]], [[VAL2]]
1439   si = si ^ si2;
1440 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
1441 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi2
1442 // CHECK: %{{.*}} = xor <4 x i32> [[VAL1]], [[VAL2]]
1443   si = si ^ bi2;
1444 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi
1445 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
1446 // CHECK: %{{.*}} = xor <4 x i32> [[VAL1]], [[VAL2]]
1447   si = bi ^ si2;
1448 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
1449 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
1450 // CHECK: %{{.*}} = xor <4 x i32> [[VAL1]], [[VAL2]]
1451   ui = ui ^ ui2;
1452 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
1453 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi2
1454 // CHECK: %{{.*}} = xor <4 x i32> [[VAL1]], [[VAL2]]
1455   ui = ui ^ bi2;
1456 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi
1457 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
1458 // CHECK: %{{.*}} = xor <4 x i32> [[VAL1]], [[VAL2]]
1459   ui = bi ^ ui2;
1460 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi
1461 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi2
1462 // CHECK: %{{.*}} = xor <4 x i32> [[VAL1]], [[VAL2]]
1463   bi = bi ^ bi2;
1464 
1465 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
1466 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
1467 // CHECK: %{{.*}} = xor <2 x i64> [[VAL1]], [[VAL2]]
1468   sl = sl ^ sl2;
1469 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
1470 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl2
1471 // CHECK: %{{.*}} = xor <2 x i64> [[VAL1]], [[VAL2]]
1472   sl = sl ^ bl2;
1473 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl
1474 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
1475 // CHECK: %{{.*}} = xor <2 x i64> [[VAL1]], [[VAL2]]
1476   sl = bl ^ sl2;
1477 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
1478 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
1479 // CHECK: %{{.*}} = xor <2 x i64> [[VAL1]], [[VAL2]]
1480   ul = ul ^ ul2;
1481 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
1482 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl2
1483 // CHECK: %{{.*}} = xor <2 x i64> [[VAL1]], [[VAL2]]
1484   ul = ul ^ bl2;
1485 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl
1486 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
1487 // CHECK: %{{.*}} = xor <2 x i64> [[VAL1]], [[VAL2]]
1488   ul = bl ^ ul2;
1489 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl
1490 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl2
1491 // CHECK: %{{.*}} = xor <2 x i64> [[VAL1]], [[VAL2]]
1492   bl = bl ^ bl2;
1493 }
1494 
test_xor_assign(void)1495 void test_xor_assign (void)
1496 {
1497 // CHECK-LABEL: test_xor_assign
1498 
1499 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
1500 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
1501 // CHECK: %{{.*}} = xor <16 x i8> [[VAL2]], [[VAL1]]
1502   sc ^= sc2;
1503 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc2
1504 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
1505 // CHECK: %{{.*}} = xor <16 x i8> [[VAL2]], [[VAL1]]
1506   sc ^= bc2;
1507 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
1508 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
1509 // CHECK: %{{.*}} = xor <16 x i8> [[VAL2]], [[VAL1]]
1510   uc ^= uc2;
1511 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc2
1512 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
1513 // CHECK: %{{.*}} = xor <16 x i8> [[VAL2]], [[VAL1]]
1514   uc ^= bc2;
1515 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc2
1516 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc
1517 // CHECK: %{{.*}} = xor <16 x i8> [[VAL2]], [[VAL1]]
1518   bc ^= bc2;
1519 
1520 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
1521 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
1522 // CHECK: %{{.*}} = xor <8 x i16> [[VAL2]], [[VAL1]]
1523   ss ^= ss2;
1524 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs2
1525 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
1526 // CHECK: %{{.*}} = xor <8 x i16> [[VAL2]], [[VAL1]]
1527   ss ^= bs2;
1528 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
1529 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
1530 // CHECK: %{{.*}} = xor <8 x i16> [[VAL2]], [[VAL1]]
1531   us ^= us2;
1532 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs2
1533 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
1534 // CHECK: %{{.*}} = xor <8 x i16> [[VAL2]], [[VAL1]]
1535   us ^= bs2;
1536 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs2
1537 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs
1538 // CHECK: %{{.*}} = xor <8 x i16> [[VAL2]], [[VAL1]]
1539   bs ^= bs2;
1540 
1541 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
1542 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
1543 // CHECK: %{{.*}} = xor <4 x i32> [[VAL2]], [[VAL1]]
1544   si ^= si2;
1545 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi2
1546 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
1547 // CHECK: %{{.*}} = xor <4 x i32> [[VAL2]], [[VAL1]]
1548   si ^= bi2;
1549 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
1550 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
1551 // CHECK: %{{.*}} = xor <4 x i32> [[VAL2]], [[VAL1]]
1552   ui ^= ui2;
1553 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi2
1554 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
1555 // CHECK: %{{.*}} = xor <4 x i32> [[VAL2]], [[VAL1]]
1556   ui ^= bi2;
1557 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi2
1558 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi
1559 // CHECK: %{{.*}} = xor <4 x i32> [[VAL2]], [[VAL1]]
1560   bi ^= bi2;
1561 
1562 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
1563 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
1564 // CHECK: %{{.*}} = xor <2 x i64> [[VAL2]], [[VAL1]]
1565   sl ^= sl2;
1566 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl2
1567 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
1568 // CHECK: %{{.*}} = xor <2 x i64> [[VAL2]], [[VAL1]]
1569   sl ^= bl2;
1570 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
1571 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
1572 // CHECK: %{{.*}} = xor <2 x i64> [[VAL2]], [[VAL1]]
1573   ul ^= ul2;
1574 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl2
1575 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
1576 // CHECK: %{{.*}} = xor <2 x i64> [[VAL2]], [[VAL1]]
1577   ul ^= bl2;
1578 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl2
1579 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl
1580 // CHECK: %{{.*}} = xor <2 x i64> [[VAL2]], [[VAL1]]
1581   bl ^= bl2;
1582 }
1583 
test_sl(void)1584 void test_sl (void)
1585 {
1586 // CHECK-LABEL: test_sl
1587 
1588 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
1589 // CHECK: [[CNT:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
1590 // CHECK: %{{.*}} = shl <16 x i8> [[VAL]], [[CNT]]
1591   sc = sc << sc2;
1592 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
1593 // CHECK: [[CNT:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
1594 // CHECK: %{{.*}} = shl <16 x i8> [[VAL]], [[CNT]]
1595   sc = sc << uc2;
1596 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
1597 // CHECK: [[T1:%[^ ]+]] = load volatile i32, i32* @cnt
1598 // CHECK: [[T2:%[^ ]+]] = insertelement <16 x i32> undef, i32 [[T1]], i32 0
1599 // CHECK: [[T3:%[^ ]+]] = shufflevector <16 x i32> [[T2]], <16 x i32> undef, <16 x i32> zeroinitializer
1600 // CHECK: [[CNT:%[^ ]+]] = trunc <16 x i32> [[T3]] to <16 x i8>
1601 // CHECK: %{{.*}} = shl <16 x i8> [[VAL]], [[CNT]]
1602   sc = sc << cnt;
1603 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
1604 // CHECK: %{{.*}} = shl <16 x i8> [[VAL]], <i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5>
1605   sc = sc << 5;
1606 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
1607 // CHECK: [[CNT:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
1608 // CHECK: %{{.*}} = shl <16 x i8> [[VAL]], [[CNT]]
1609   uc = uc << sc2;
1610 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
1611 // CHECK: [[CNT:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
1612 // CHECK: %{{.*}} = shl <16 x i8> [[VAL]], [[CNT]]
1613   uc = uc << uc2;
1614 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
1615 // CHECK: [[T1:%[^ ]+]] = load volatile i32, i32* @cnt
1616 // CHECK: [[T2:%[^ ]+]] = insertelement <16 x i32> undef, i32 [[T1]], i32 0
1617 // CHECK: [[T3:%[^ ]+]] = shufflevector <16 x i32> [[T2]], <16 x i32> undef, <16 x i32> zeroinitializer
1618 // CHECK: [[CNT:%[^ ]+]] = trunc <16 x i32> [[T3]] to <16 x i8>
1619 // CHECK: %{{.*}} = shl <16 x i8> [[VAL]], [[CNT]]
1620   uc = uc << cnt;
1621 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
1622 // CHECK: %{{.*}} = shl <16 x i8> [[VAL]], <i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5>
1623   uc = uc << 5;
1624 
1625 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
1626 // CHECK: [[CNT:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
1627 // CHECK: %{{.*}} = shl <8 x i16> [[VAL]], [[CNT]]
1628   ss = ss << ss2;
1629 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
1630 // CHECK: [[CNT:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
1631 // CHECK: %{{.*}} = shl <8 x i16> [[VAL]], [[CNT]]
1632   ss = ss << us2;
1633 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
1634 // CHECK: [[T1:%[^ ]+]] = load volatile i32, i32* @cnt
1635 // CHECK: [[T2:%[^ ]+]] = insertelement <8 x i32> undef, i32 [[T1]], i32 0
1636 // CHECK: [[T3:%[^ ]+]] = shufflevector <8 x i32> [[T2]], <8 x i32> undef, <8 x i32> zeroinitializer
1637 // CHECK: [[CNT:%[^ ]+]] = trunc <8 x i32> [[T3]] to <8 x i16>
1638 // CHECK: %{{.*}} = shl <8 x i16> [[VAL]], [[CNT]]
1639   ss = ss << cnt;
1640 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
1641 // CHECK: %{{.*}} = shl <8 x i16> [[VAL]], <i16 5, i16 5, i16 5, i16 5, i16 5, i16 5, i16 5, i16 5>
1642   ss = ss << 5;
1643 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
1644 // CHECK: [[CNT:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
1645 // CHECK: %{{.*}} = shl <8 x i16> [[VAL]], [[CNT]]
1646   us = us << ss2;
1647 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
1648 // CHECK: [[CNT:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
1649 // CHECK: %{{.*}} = shl <8 x i16> [[VAL]], [[CNT]]
1650   us = us << us2;
1651 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
1652 // CHECK: [[T1:%[^ ]+]] = load volatile i32, i32* @cnt
1653 // CHECK: [[T2:%[^ ]+]] = insertelement <8 x i32> undef, i32 [[T1]], i32 0
1654 // CHECK: [[T3:%[^ ]+]] = shufflevector <8 x i32> [[T2]], <8 x i32> undef, <8 x i32> zeroinitializer
1655 // CHECK: [[CNT:%[^ ]+]] = trunc <8 x i32> [[T3]] to <8 x i16>
1656 // CHECK: %{{.*}} = shl <8 x i16> [[VAL]], [[CNT]]
1657   us = us << cnt;
1658 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
1659 // CHECK: %{{.*}} = shl <8 x i16> [[VAL]], <i16 5, i16 5, i16 5, i16 5, i16 5, i16 5, i16 5, i16 5>
1660   us = us << 5;
1661 
1662 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
1663 // CHECK: [[CNT:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
1664 // CHECK: %{{.*}} = shl <4 x i32> [[VAL]], [[CNT]]
1665   si = si << si2;
1666 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
1667 // CHECK: [[CNT:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
1668 // CHECK: %{{.*}} = shl <4 x i32> [[VAL]], [[CNT]]
1669   si = si << ui2;
1670 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
1671 // CHECK: [[T1:%[^ ]+]] = load volatile i32, i32* @cnt
1672 // CHECK: [[T3:%[^ ]+]] = insertelement <4 x i32> undef, i32 [[T1]], i32 0
1673 // CHECK: [[CNT:%[^ ]+]] = shufflevector <4 x i32> [[T3]], <4 x i32> undef, <4 x i32> zeroinitializer
1674 // CHECK: %{{.*}} = shl <4 x i32> [[VAL]], [[CNT]]
1675   si = si << cnt;
1676 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
1677 // CHECK: %{{.*}} = shl <4 x i32> [[VAL]], <i32 5, i32 5, i32 5, i32 5>
1678   si = si << 5;
1679 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
1680 // CHECK: [[CNT:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
1681 // CHECK: %{{.*}} = shl <4 x i32> [[VAL]], [[CNT]]
1682   ui = ui << si2;
1683 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
1684 // CHECK: [[CNT:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
1685 // CHECK: %{{.*}} = shl <4 x i32> [[VAL]], [[CNT]]
1686   ui = ui << ui2;
1687 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
1688 // CHECK: [[T1:%[^ ]+]] = load volatile i32, i32* @cnt
1689 // CHECK: [[T3:%[^ ]+]] = insertelement <4 x i32> undef, i32 [[T1]], i32 0
1690 // CHECK: [[CNT:%[^ ]+]] = shufflevector <4 x i32> [[T3]], <4 x i32> undef, <4 x i32> zeroinitializer
1691 // CHECK: %{{.*}} = shl <4 x i32> [[VAL]], [[CNT]]
1692   ui = ui << cnt;
1693 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
1694 // CHECK: %{{.*}} = shl <4 x i32> [[VAL]], <i32 5, i32 5, i32 5, i32 5>
1695   ui = ui << 5;
1696 
1697 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
1698 // CHECK: [[CNT:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
1699 // CHECK: %{{.*}} = shl <2 x i64> [[VAL]], [[CNT]]
1700   sl = sl << sl2;
1701 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
1702 // CHECK: [[CNT:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
1703 // CHECK: %{{.*}} = shl <2 x i64> [[VAL]], [[CNT]]
1704   sl = sl << ul2;
1705 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
1706 // CHECK: [[T1:%[^ ]+]] = load volatile i32, i32* @cnt
1707 // CHECK: [[T2:%[^ ]+]] = insertelement <2 x i32> undef, i32 [[T1]], i32 0
1708 // CHECK: [[T3:%[^ ]+]] = shufflevector <2 x i32> [[T2]], <2 x i32> undef, <2 x i32> zeroinitializer
1709 // CHECK: [[CNT:%[^ ]+]] = zext <2 x i32> [[T3]] to <2 x i64>
1710 // CHECK: %{{.*}} = shl <2 x i64> [[VAL]], [[CNT]]
1711   sl = sl << cnt;
1712 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
1713 // CHECK: %{{.*}} = shl <2 x i64> [[VAL]], <i64 5, i64 5>
1714   sl = sl << 5;
1715 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
1716 // CHECK: [[CNT:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
1717 // CHECK: %{{.*}} = shl <2 x i64> [[VAL]], [[CNT]]
1718   ul = ul << sl2;
1719 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
1720 // CHECK: [[CNT:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
1721 // CHECK: %{{.*}} = shl <2 x i64> [[VAL]], [[CNT]]
1722   ul = ul << ul2;
1723 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
1724 // CHECK: [[T1:%[^ ]+]] = load volatile i32, i32* @cnt
1725 // CHECK: [[T2:%[^ ]+]] = insertelement <2 x i32> undef, i32 [[T1]], i32 0
1726 // CHECK: [[T3:%[^ ]+]] = shufflevector <2 x i32> [[T2]], <2 x i32> undef, <2 x i32> zeroinitializer
1727 // CHECK: [[CNT:%[^ ]+]] = zext <2 x i32> [[T3]] to <2 x i64>
1728 // CHECK: %{{.*}} = shl <2 x i64> [[VAL]], [[CNT]]
1729   ul = ul << cnt;
1730 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
1731 // CHECK: %{{.*}} = shl <2 x i64> [[VAL]], <i64 5, i64 5>
1732   ul = ul << 5;
1733 }
1734 
test_sl_assign(void)1735 void test_sl_assign (void)
1736 {
1737 // CHECK-LABEL: test_sl_assign
1738 
1739 // CHECK: [[CNT:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
1740 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
1741 // CHECK: %{{.*}} = shl <16 x i8> [[VAL]], [[CNT]]
1742   sc <<= sc2;
1743 // CHECK: [[CNT:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
1744 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
1745 // CHECK: %{{.*}} = shl <16 x i8> [[VAL]], [[CNT]]
1746   sc <<= uc2;
1747 // CHECK: [[T1:%[^ ]+]] = load volatile i32, i32* @cnt
1748 // CHECK: [[T2:%[^ ]+]] = insertelement <16 x i32> undef, i32 [[T1]], i32 0
1749 // CHECK: [[T3:%[^ ]+]] = shufflevector <16 x i32> [[T2]], <16 x i32> undef, <16 x i32> zeroinitializer
1750 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
1751 // CHECK: [[CNT:%[^ ]+]] = trunc <16 x i32> [[T3]] to <16 x i8>
1752 // CHECK: %{{.*}} = shl <16 x i8> [[VAL]], [[CNT]]
1753   sc <<= cnt;
1754 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
1755 // CHECK: %{{.*}} = shl <16 x i8> [[VAL]], <i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5>
1756   sc <<= 5;
1757 // CHECK: [[CNT:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
1758 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
1759 // CHECK: %{{.*}} = shl <16 x i8> [[VAL]], [[CNT]]
1760   uc <<= sc2;
1761 // CHECK: [[CNT:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
1762 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
1763 // CHECK: %{{.*}} = shl <16 x i8> [[VAL]], [[CNT]]
1764   uc <<= uc2;
1765 // CHECK: [[T1:%[^ ]+]] = load volatile i32, i32* @cnt
1766 // CHECK: [[T2:%[^ ]+]] = insertelement <16 x i32> undef, i32 [[T1]], i32 0
1767 // CHECK: [[T3:%[^ ]+]] = shufflevector <16 x i32> [[T2]], <16 x i32> undef, <16 x i32> zeroinitializer
1768 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
1769 // CHECK: [[CNT:%[^ ]+]] = trunc <16 x i32> [[T3]] to <16 x i8>
1770 // CHECK: %{{.*}} = shl <16 x i8> [[VAL]], [[CNT]]
1771   uc <<= cnt;
1772 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
1773 // CHECK: %{{.*}} = shl <16 x i8> [[VAL]], <i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5>
1774   uc <<= 5;
1775 
1776 // CHECK: [[CNT:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
1777 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
1778 // CHECK: %{{.*}} = shl <8 x i16> [[VAL]], [[CNT]]
1779   ss <<= ss2;
1780 // CHECK: [[CNT:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
1781 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
1782 // CHECK: %{{.*}} = shl <8 x i16> [[VAL]], [[CNT]]
1783   ss <<= us2;
1784 // CHECK: [[T1:%[^ ]+]] = load volatile i32, i32* @cnt
1785 // CHECK: [[T2:%[^ ]+]] = insertelement <8 x i32> undef, i32 [[T1]], i32 0
1786 // CHECK: [[T3:%[^ ]+]] = shufflevector <8 x i32> [[T2]], <8 x i32> undef, <8 x i32> zeroinitializer
1787 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
1788 // CHECK: [[CNT:%[^ ]+]] = trunc <8 x i32> [[T3]] to <8 x i16>
1789 // CHECK: %{{.*}} = shl <8 x i16> [[VAL]], [[CNT]]
1790   ss <<= cnt;
1791 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
1792 // CHECK: %{{.*}} = shl <8 x i16> [[VAL]], <i16 5, i16 5, i16 5, i16 5, i16 5, i16 5, i16 5, i16 5>
1793   ss <<= 5;
1794 // CHECK: [[CNT:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
1795 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
1796 // CHECK: %{{.*}} = shl <8 x i16> [[VAL]], [[CNT]]
1797   us <<= ss2;
1798 // CHECK: [[CNT:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
1799 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
1800 // CHECK: %{{.*}} = shl <8 x i16> [[VAL]], [[CNT]]
1801   us <<= us2;
1802 // CHECK: [[T1:%[^ ]+]] = load volatile i32, i32* @cnt
1803 // CHECK: [[T2:%[^ ]+]] = insertelement <8 x i32> undef, i32 [[T1]], i32 0
1804 // CHECK: [[T3:%[^ ]+]] = shufflevector <8 x i32> [[T2]], <8 x i32> undef, <8 x i32> zeroinitializer
1805 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
1806 // CHECK: [[CNT:%[^ ]+]] = trunc <8 x i32> [[T3]] to <8 x i16>
1807 // CHECK: %{{.*}} = shl <8 x i16> [[VAL]], [[CNT]]
1808   us <<= cnt;
1809 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
1810 // CHECK: %{{.*}} = shl <8 x i16> [[VAL]], <i16 5, i16 5, i16 5, i16 5, i16 5, i16 5, i16 5, i16 5>
1811   us <<= 5;
1812 
1813 // CHECK: [[CNT:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
1814 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
1815 // CHECK: %{{.*}} = shl <4 x i32> [[VAL]], [[CNT]]
1816   si <<= si2;
1817 // CHECK: [[CNT:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
1818 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
1819 // CHECK: %{{.*}} = shl <4 x i32> [[VAL]], [[CNT]]
1820   si <<= ui2;
1821 // CHECK: [[T1:%[^ ]+]] = load volatile i32, i32* @cnt
1822 // CHECK: [[T3:%[^ ]+]] = insertelement <4 x i32> undef, i32 [[T1]], i32 0
1823 // CHECK: [[CNT:%[^ ]+]] = shufflevector <4 x i32> [[T3]], <4 x i32> undef, <4 x i32> zeroinitializer
1824 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
1825 // CHECK: %{{.*}} = shl <4 x i32> [[VAL]], [[CNT]]
1826   si <<= cnt;
1827 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
1828 // CHECK: %{{.*}} = shl <4 x i32> [[VAL]], <i32 5, i32 5, i32 5, i32 5>
1829   si <<= 5;
1830 // CHECK: [[CNT:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
1831 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
1832 // CHECK: %{{.*}} = shl <4 x i32> [[VAL]], [[CNT]]
1833   ui <<= si2;
1834 // CHECK: [[CNT:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
1835 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
1836 // CHECK: %{{.*}} = shl <4 x i32> [[VAL]], [[CNT]]
1837   ui <<= ui2;
1838 // CHECK: [[T1:%[^ ]+]] = load volatile i32, i32* @cnt
1839 // CHECK: [[T3:%[^ ]+]] = insertelement <4 x i32> undef, i32 [[T1]], i32 0
1840 // CHECK: [[CNT:%[^ ]+]] = shufflevector <4 x i32> [[T3]], <4 x i32> undef, <4 x i32> zeroinitializer
1841 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
1842 // CHECK: %{{.*}} = shl <4 x i32> [[VAL]], [[CNT]]
1843   ui <<= cnt;
1844 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
1845 // CHECK: %{{.*}} = shl <4 x i32> [[VAL]], <i32 5, i32 5, i32 5, i32 5>
1846   ui <<= 5;
1847 
1848 // CHECK: [[CNT:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
1849 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
1850 // CHECK: %{{.*}} = shl <2 x i64> [[VAL]], [[CNT]]
1851   sl <<= sl2;
1852 // CHECK: [[CNT:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
1853 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
1854 // CHECK: %{{.*}} = shl <2 x i64> [[VAL]], [[CNT]]
1855   sl <<= ul2;
1856 // CHECK: [[T1:%[^ ]+]] = load volatile i32, i32* @cnt
1857 // CHECK: [[T2:%[^ ]+]] = insertelement <2 x i32> undef, i32 [[T1]], i32 0
1858 // CHECK: [[T3:%[^ ]+]] = shufflevector <2 x i32> [[T2]], <2 x i32> undef, <2 x i32> zeroinitializer
1859 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
1860 // CHECK: [[CNT:%[^ ]+]] = zext <2 x i32> [[T3]] to <2 x i64>
1861 // CHECK: %{{.*}} = shl <2 x i64> [[VAL]], [[CNT]]
1862   sl <<= cnt;
1863 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
1864 // CHECK: %{{.*}} = shl <2 x i64> [[VAL]], <i64 5, i64 5>
1865   sl <<= 5;
1866 // CHECK: [[CNT:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
1867 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
1868 // CHECK: %{{.*}} = shl <2 x i64> [[VAL]], [[CNT]]
1869   ul <<= sl2;
1870 // CHECK: [[CNT:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
1871 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
1872 // CHECK: %{{.*}} = shl <2 x i64> [[VAL]], [[CNT]]
1873   ul <<= ul2;
1874 // CHECK: [[T1:%[^ ]+]] = load volatile i32, i32* @cnt
1875 // CHECK: [[T2:%[^ ]+]] = insertelement <2 x i32> undef, i32 [[T1]], i32 0
1876 // CHECK: [[T3:%[^ ]+]] = shufflevector <2 x i32> [[T2]], <2 x i32> undef, <2 x i32> zeroinitializer
1877 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
1878 // CHECK: [[CNT:%[^ ]+]] = zext <2 x i32> [[T3]] to <2 x i64>
1879 // CHECK: %{{.*}} = shl <2 x i64> [[VAL]], [[CNT]]
1880   ul <<= cnt;
1881 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
1882 // CHECK: %{{.*}} = shl <2 x i64> [[VAL]], <i64 5, i64 5>
1883   ul <<= 5;
1884 }
1885 
test_sr(void)1886 void test_sr (void)
1887 {
1888 // CHECK-LABEL: test_sr
1889 
1890 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
1891 // CHECK: [[CNT:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
1892 // CHECK: %{{.*}} = ashr <16 x i8> [[VAL]], [[CNT]]
1893   sc = sc >> sc2;
1894 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
1895 // CHECK: [[CNT:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
1896 // CHECK: %{{.*}} = ashr <16 x i8> [[VAL]], [[CNT]]
1897   sc = sc >> uc2;
1898 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
1899 // CHECK: [[T1:%[^ ]+]] = load volatile i32, i32* @cnt
1900 // CHECK: [[T2:%[^ ]+]] = insertelement <16 x i32> undef, i32 [[T1]], i32 0
1901 // CHECK: [[T3:%[^ ]+]] = shufflevector <16 x i32> [[T2]], <16 x i32> undef, <16 x i32> zeroinitializer
1902 // CHECK: [[CNT:%[^ ]+]] = trunc <16 x i32> [[T3]] to <16 x i8>
1903 // CHECK: %{{.*}} = ashr <16 x i8> [[VAL]], [[CNT]]
1904   sc = sc >> cnt;
1905 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
1906 // CHECK: %{{.*}} = ashr <16 x i8> [[VAL]], <i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5>
1907   sc = sc >> 5;
1908 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
1909 // CHECK: [[CNT:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
1910 // CHECK: %{{.*}} = lshr <16 x i8> [[VAL]], [[CNT]]
1911   uc = uc >> sc2;
1912 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
1913 // CHECK: [[CNT:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
1914 // CHECK: %{{.*}} = lshr <16 x i8> [[VAL]], [[CNT]]
1915   uc = uc >> uc2;
1916 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
1917 // CHECK: [[T1:%[^ ]+]] = load volatile i32, i32* @cnt
1918 // CHECK: [[T2:%[^ ]+]] = insertelement <16 x i32> undef, i32 [[T1]], i32 0
1919 // CHECK: [[T3:%[^ ]+]] = shufflevector <16 x i32> [[T2]], <16 x i32> undef, <16 x i32> zeroinitializer
1920 // CHECK: [[CNT:%[^ ]+]] = trunc <16 x i32> [[T3]] to <16 x i8>
1921 // CHECK: %{{.*}} = lshr <16 x i8> [[VAL]], [[CNT]]
1922   uc = uc >> cnt;
1923 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
1924 // CHECK: %{{.*}} = lshr <16 x i8> [[VAL]], <i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5>
1925   uc = uc >> 5;
1926 
1927 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
1928 // CHECK: [[CNT:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
1929 // CHECK: %{{.*}} = ashr <8 x i16> [[VAL]], [[CNT]]
1930   ss = ss >> ss2;
1931 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
1932 // CHECK: [[CNT:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
1933 // CHECK: %{{.*}} = ashr <8 x i16> [[VAL]], [[CNT]]
1934   ss = ss >> us2;
1935 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
1936 // CHECK: [[T1:%[^ ]+]] = load volatile i32, i32* @cnt
1937 // CHECK: [[T2:%[^ ]+]] = insertelement <8 x i32> undef, i32 [[T1]], i32 0
1938 // CHECK: [[T3:%[^ ]+]] = shufflevector <8 x i32> [[T2]], <8 x i32> undef, <8 x i32> zeroinitializer
1939 // CHECK: [[CNT:%[^ ]+]] = trunc <8 x i32> [[T3]] to <8 x i16>
1940 // CHECK: %{{.*}} = ashr <8 x i16> [[VAL]], [[CNT]]
1941   ss = ss >> cnt;
1942 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
1943 // CHECK: %{{.*}} = ashr <8 x i16> [[VAL]], <i16 5, i16 5, i16 5, i16 5, i16 5, i16 5, i16 5, i16 5>
1944   ss = ss >> 5;
1945 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
1946 // CHECK: [[CNT:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
1947 // CHECK: %{{.*}} = lshr <8 x i16> [[VAL]], [[CNT]]
1948   us = us >> ss2;
1949 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
1950 // CHECK: [[CNT:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
1951 // CHECK: %{{.*}} = lshr <8 x i16> [[VAL]], [[CNT]]
1952   us = us >> us2;
1953 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
1954 // CHECK: [[T1:%[^ ]+]] = load volatile i32, i32* @cnt
1955 // CHECK: [[T2:%[^ ]+]] = insertelement <8 x i32> undef, i32 [[T1]], i32 0
1956 // CHECK: [[T3:%[^ ]+]] = shufflevector <8 x i32> [[T2]], <8 x i32> undef, <8 x i32> zeroinitializer
1957 // CHECK: [[CNT:%[^ ]+]] = trunc <8 x i32> [[T3]] to <8 x i16>
1958 // CHECK: %{{.*}} = lshr <8 x i16> [[VAL]], [[CNT]]
1959   us = us >> cnt;
1960 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
1961 // CHECK: %{{.*}} = lshr <8 x i16> [[VAL]], <i16 5, i16 5, i16 5, i16 5, i16 5, i16 5, i16 5, i16 5>
1962   us = us >> 5;
1963 
1964 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
1965 // CHECK: [[CNT:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
1966 // CHECK: %{{.*}} = ashr <4 x i32> [[VAL]], [[CNT]]
1967   si = si >> si2;
1968 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
1969 // CHECK: [[CNT:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
1970 // CHECK: %{{.*}} = ashr <4 x i32> [[VAL]], [[CNT]]
1971   si = si >> ui2;
1972 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
1973 // CHECK: [[T1:%[^ ]+]] = load volatile i32, i32* @cnt
1974 // CHECK: [[T3:%[^ ]+]] = insertelement <4 x i32> undef, i32 [[T1]], i32 0
1975 // CHECK: [[CNT:%[^ ]+]] = shufflevector <4 x i32> [[T3]], <4 x i32> undef, <4 x i32> zeroinitializer
1976 // CHECK: %{{.*}} = ashr <4 x i32> [[VAL]], [[CNT]]
1977   si = si >> cnt;
1978 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
1979 // CHECK: %{{.*}} = ashr <4 x i32> [[VAL]], <i32 5, i32 5, i32 5, i32 5>
1980   si = si >> 5;
1981 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
1982 // CHECK: [[CNT:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
1983 // CHECK: %{{.*}} = lshr <4 x i32> [[VAL]], [[CNT]]
1984   ui = ui >> si2;
1985 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
1986 // CHECK: [[CNT:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
1987 // CHECK: %{{.*}} = lshr <4 x i32> [[VAL]], [[CNT]]
1988   ui = ui >> ui2;
1989 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
1990 // CHECK: [[T1:%[^ ]+]] = load volatile i32, i32* @cnt
1991 // CHECK: [[T3:%[^ ]+]] = insertelement <4 x i32> undef, i32 [[T1]], i32 0
1992 // CHECK: [[CNT:%[^ ]+]] = shufflevector <4 x i32> [[T3]], <4 x i32> undef, <4 x i32> zeroinitializer
1993 // CHECK: %{{.*}} = lshr <4 x i32> [[VAL]], [[CNT]]
1994   ui = ui >> cnt;
1995 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
1996 // CHECK: %{{.*}} = lshr <4 x i32> [[VAL]], <i32 5, i32 5, i32 5, i32 5>
1997   ui = ui >> 5;
1998 
1999 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
2000 // CHECK: [[CNT:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
2001 // CHECK: %{{.*}} = ashr <2 x i64> [[VAL]], [[CNT]]
2002   sl = sl >> sl2;
2003 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
2004 // CHECK: [[CNT:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
2005 // CHECK: %{{.*}} = ashr <2 x i64> [[VAL]], [[CNT]]
2006   sl = sl >> ul2;
2007 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
2008 // CHECK: [[T1:%[^ ]+]] = load volatile i32, i32* @cnt
2009 // CHECK: [[T2:%[^ ]+]] = insertelement <2 x i32> undef, i32 [[T1]], i32 0
2010 // CHECK: [[T3:%[^ ]+]] = shufflevector <2 x i32> [[T2]], <2 x i32> undef, <2 x i32> zeroinitializer
2011 // CHECK: [[CNT:%[^ ]+]] = zext <2 x i32> [[T3]] to <2 x i64>
2012 // CHECK: %{{.*}} = ashr <2 x i64> [[VAL]], [[CNT]]
2013   sl = sl >> cnt;
2014 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
2015 // CHECK: %{{.*}} = ashr <2 x i64> [[VAL]], <i64 5, i64 5>
2016   sl = sl >> 5;
2017 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
2018 // CHECK: [[CNT:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
2019 // CHECK: %{{.*}} = lshr <2 x i64> [[VAL]], [[CNT]]
2020   ul = ul >> sl2;
2021 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
2022 // CHECK: [[CNT:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
2023 // CHECK: %{{.*}} = lshr <2 x i64> [[VAL]], [[CNT]]
2024   ul = ul >> ul2;
2025 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
2026 // CHECK: [[T1:%[^ ]+]] = load volatile i32, i32* @cnt
2027 // CHECK: [[T2:%[^ ]+]] = insertelement <2 x i32> undef, i32 [[T1]], i32 0
2028 // CHECK: [[T3:%[^ ]+]] = shufflevector <2 x i32> [[T2]], <2 x i32> undef, <2 x i32> zeroinitializer
2029 // CHECK: [[CNT:%[^ ]+]] = zext <2 x i32> [[T3]] to <2 x i64>
2030 // CHECK: %{{.*}} = lshr <2 x i64> [[VAL]], [[CNT]]
2031   ul = ul >> cnt;
2032 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
2033 // CHECK: %{{.*}} = lshr <2 x i64> [[VAL]], <i64 5, i64 5>
2034   ul = ul >> 5;
2035 }
2036 
test_sr_assign(void)2037 void test_sr_assign (void)
2038 {
2039 // CHECK-LABEL: test_sr_assign
2040 
2041 // CHECK: [[CNT:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
2042 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
2043 // CHECK: %{{.*}} = ashr <16 x i8> [[VAL]], [[CNT]]
2044   sc >>= sc2;
2045 // CHECK: [[CNT:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
2046 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
2047 // CHECK: %{{.*}} = ashr <16 x i8> [[VAL]], [[CNT]]
2048   sc >>= uc2;
2049 // CHECK: [[T1:%[^ ]+]] = load volatile i32, i32* @cnt
2050 // CHECK: [[T2:%[^ ]+]] = insertelement <16 x i32> undef, i32 [[T1]], i32 0
2051 // CHECK: [[T3:%[^ ]+]] = shufflevector <16 x i32> [[T2]], <16 x i32> undef, <16 x i32> zeroinitializer
2052 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
2053 // CHECK: [[CNT:%[^ ]+]] = trunc <16 x i32> [[T3]] to <16 x i8>
2054 // CHECK: %{{.*}} = ashr <16 x i8> [[VAL]], [[CNT]]
2055   sc >>= cnt;
2056 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
2057 // CHECK: %{{.*}} = ashr <16 x i8> [[VAL]], <i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5>
2058   sc >>= 5;
2059 // CHECK: [[CNT:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
2060 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
2061 // CHECK: %{{.*}} = lshr <16 x i8> [[VAL]], [[CNT]]
2062   uc >>= sc2;
2063 // CHECK: [[CNT:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
2064 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
2065 // CHECK: %{{.*}} = lshr <16 x i8> [[VAL]], [[CNT]]
2066   uc >>= uc2;
2067 // CHECK: [[T1:%[^ ]+]] = load volatile i32, i32* @cnt
2068 // CHECK: [[T2:%[^ ]+]] = insertelement <16 x i32> undef, i32 [[T1]], i32 0
2069 // CHECK: [[T3:%[^ ]+]] = shufflevector <16 x i32> [[T2]], <16 x i32> undef, <16 x i32> zeroinitializer
2070 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
2071 // CHECK: [[CNT:%[^ ]+]] = trunc <16 x i32> [[T3]] to <16 x i8>
2072 // CHECK: %{{.*}} = lshr <16 x i8> [[VAL]], [[CNT]]
2073   uc >>= cnt;
2074 // CHECK: [[VAL:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
2075 // CHECK: %{{.*}} = lshr <16 x i8> [[VAL]], <i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5>
2076   uc >>= 5;
2077 
2078 // CHECK: [[CNT:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
2079 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
2080 // CHECK: %{{.*}} = ashr <8 x i16> [[VAL]], [[CNT]]
2081   ss >>= ss2;
2082 // CHECK: [[CNT:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
2083 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
2084 // CHECK: %{{.*}} = ashr <8 x i16> [[VAL]], [[CNT]]
2085   ss >>= us2;
2086 // CHECK: [[T1:%[^ ]+]] = load volatile i32, i32* @cnt
2087 // CHECK: [[T2:%[^ ]+]] = insertelement <8 x i32> undef, i32 [[T1]], i32 0
2088 // CHECK: [[T3:%[^ ]+]] = shufflevector <8 x i32> [[T2]], <8 x i32> undef, <8 x i32> zeroinitializer
2089 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
2090 // CHECK: [[CNT:%[^ ]+]] = trunc <8 x i32> [[T3]] to <8 x i16>
2091 // CHECK: %{{.*}} = ashr <8 x i16> [[VAL]], [[CNT]]
2092   ss >>= cnt;
2093 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
2094 // CHECK: %{{.*}} = ashr <8 x i16> [[VAL]], <i16 5, i16 5, i16 5, i16 5, i16 5, i16 5, i16 5, i16 5>
2095   ss >>= 5;
2096 // CHECK: [[CNT:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
2097 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
2098 // CHECK: %{{.*}} = lshr <8 x i16> [[VAL]], [[CNT]]
2099   us >>= ss2;
2100 // CHECK: [[CNT:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
2101 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
2102 // CHECK: %{{.*}} = lshr <8 x i16> [[VAL]], [[CNT]]
2103   us >>= us2;
2104 // CHECK: [[T1:%[^ ]+]] = load volatile i32, i32* @cnt
2105 // CHECK: [[T2:%[^ ]+]] = insertelement <8 x i32> undef, i32 [[T1]], i32 0
2106 // CHECK: [[T3:%[^ ]+]] = shufflevector <8 x i32> [[T2]], <8 x i32> undef, <8 x i32> zeroinitializer
2107 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
2108 // CHECK: [[CNT:%[^ ]+]] = trunc <8 x i32> [[T3]] to <8 x i16>
2109 // CHECK: %{{.*}} = lshr <8 x i16> [[VAL]], [[CNT]]
2110   us >>= cnt;
2111 // CHECK: [[VAL:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
2112 // CHECK: %{{.*}} = lshr <8 x i16> [[VAL]], <i16 5, i16 5, i16 5, i16 5, i16 5, i16 5, i16 5, i16 5>
2113   us >>= 5;
2114 
2115 // CHECK: [[CNT:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
2116 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
2117 // CHECK: %{{.*}} = ashr <4 x i32> [[VAL]], [[CNT]]
2118   si >>= si2;
2119 // CHECK: [[CNT:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
2120 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
2121 // CHECK: %{{.*}} = ashr <4 x i32> [[VAL]], [[CNT]]
2122   si >>= ui2;
2123 // CHECK: [[T1:%[^ ]+]] = load volatile i32, i32* @cnt
2124 // CHECK: [[T3:%[^ ]+]] = insertelement <4 x i32> undef, i32 [[T1]], i32 0
2125 // CHECK: [[CNT:%[^ ]+]] = shufflevector <4 x i32> [[T3]], <4 x i32> undef, <4 x i32> zeroinitializer
2126 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
2127 // CHECK: %{{.*}} = ashr <4 x i32> [[VAL]], [[CNT]]
2128   si >>= cnt;
2129 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
2130 // CHECK: %{{.*}} = ashr <4 x i32> [[VAL]], <i32 5, i32 5, i32 5, i32 5>
2131   si >>= 5;
2132 // CHECK: [[CNT:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
2133 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
2134 // CHECK: %{{.*}} = lshr <4 x i32> [[VAL]], [[CNT]]
2135   ui >>= si2;
2136 // CHECK: [[CNT:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
2137 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
2138 // CHECK: %{{.*}} = lshr <4 x i32> [[VAL]], [[CNT]]
2139   ui >>= ui2;
2140 // CHECK: [[T1:%[^ ]+]] = load volatile i32, i32* @cnt
2141 // CHECK: [[T3:%[^ ]+]] = insertelement <4 x i32> undef, i32 [[T1]], i32 0
2142 // CHECK: [[CNT:%[^ ]+]] = shufflevector <4 x i32> [[T3]], <4 x i32> undef, <4 x i32> zeroinitializer
2143 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
2144 // CHECK: %{{.*}} = lshr <4 x i32> [[VAL]], [[CNT]]
2145   ui >>= cnt;
2146 // CHECK: [[VAL:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
2147 // CHECK: %{{.*}} = lshr <4 x i32> [[VAL]], <i32 5, i32 5, i32 5, i32 5>
2148   ui >>= 5;
2149 
2150 // CHECK: [[CNT:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
2151 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
2152 // CHECK: %{{.*}} = ashr <2 x i64> [[VAL]], [[CNT]]
2153   sl >>= sl2;
2154 // CHECK: [[CNT:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
2155 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
2156 // CHECK: %{{.*}} = ashr <2 x i64> [[VAL]], [[CNT]]
2157   sl >>= ul2;
2158 // CHECK: [[T1:%[^ ]+]] = load volatile i32, i32* @cnt
2159 // CHECK: [[T2:%[^ ]+]] = insertelement <2 x i32> undef, i32 [[T1]], i32 0
2160 // CHECK: [[T3:%[^ ]+]] = shufflevector <2 x i32> [[T2]], <2 x i32> undef, <2 x i32> zeroinitializer
2161 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
2162 // CHECK: [[CNT:%[^ ]+]] = zext <2 x i32> [[T3]] to <2 x i64>
2163 // CHECK: %{{.*}} = ashr <2 x i64> [[VAL]], [[CNT]]
2164   sl >>= cnt;
2165 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
2166 // CHECK: %{{.*}} = ashr <2 x i64> [[VAL]], <i64 5, i64 5>
2167   sl >>= 5;
2168 // CHECK: [[CNT:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
2169 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
2170 // CHECK: %{{.*}} = lshr <2 x i64> [[VAL]], [[CNT]]
2171   ul >>= sl2;
2172 // CHECK: [[CNT:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
2173 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
2174 // CHECK: %{{.*}} = lshr <2 x i64> [[VAL]], [[CNT]]
2175   ul >>= ul2;
2176 // CHECK: [[T1:%[^ ]+]] = load volatile i32, i32* @cnt
2177 // CHECK: [[T2:%[^ ]+]] = insertelement <2 x i32> undef, i32 [[T1]], i32 0
2178 // CHECK: [[T3:%[^ ]+]] = shufflevector <2 x i32> [[T2]], <2 x i32> undef, <2 x i32> zeroinitializer
2179 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
2180 // CHECK: [[CNT:%[^ ]+]] = zext <2 x i32> [[T3]] to <2 x i64>
2181 // CHECK: %{{.*}} = lshr <2 x i64> [[VAL]], [[CNT]]
2182   ul >>= cnt;
2183 // CHECK: [[VAL:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
2184 // CHECK: %{{.*}} = lshr <2 x i64> [[VAL]], <i64 5, i64 5>
2185   ul >>= 5;
2186 }
2187 
2188 
test_cmpeq(void)2189 void test_cmpeq (void)
2190 {
2191 // CHECK-LABEL: test_cmpeq
2192 
2193 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
2194 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
2195 // CHECK: [[CMP:%[^ ]+]] = icmp eq <16 x i8> [[VAL1]], [[VAL2]]
2196 // CHECK: %{{.*}} = sext <16 x i1> [[CMP]] to <16 x i8>
2197   bc = sc == sc2;
2198 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
2199 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc2
2200 // CHECK: [[CMP:%[^ ]+]] = icmp eq <16 x i8> [[VAL1]], [[VAL2]]
2201 // CHECK: %{{.*}} = sext <16 x i1> [[CMP]] to <16 x i8>
2202   bc = sc == bc2;
2203 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc
2204 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
2205 // CHECK: [[CMP:%[^ ]+]] = icmp eq <16 x i8> [[VAL1]], [[VAL2]]
2206 // CHECK: %{{.*}} = sext <16 x i1> [[CMP]] to <16 x i8>
2207   bc = bc == sc2;
2208 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
2209 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
2210 // CHECK: [[CMP:%[^ ]+]] = icmp eq <16 x i8> [[VAL1]], [[VAL2]]
2211 // CHECK: %{{.*}} = sext <16 x i1> [[CMP]] to <16 x i8>
2212   bc = uc == uc2;
2213 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
2214 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc2
2215 // CHECK: [[CMP:%[^ ]+]] = icmp eq <16 x i8> [[VAL1]], [[VAL2]]
2216 // CHECK: %{{.*}} = sext <16 x i1> [[CMP]] to <16 x i8>
2217   bc = uc == bc2;
2218 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc
2219 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
2220 // CHECK: [[CMP:%[^ ]+]] = icmp eq <16 x i8> [[VAL1]], [[VAL2]]
2221 // CHECK: %{{.*}} = sext <16 x i1> [[CMP]] to <16 x i8>
2222   bc = bc == uc2;
2223 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc
2224 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc2
2225 // CHECK: [[CMP:%[^ ]+]] = icmp eq <16 x i8> [[VAL1]], [[VAL2]]
2226 // CHECK: %{{.*}} = sext <16 x i1> [[CMP]] to <16 x i8>
2227   bc = bc == bc2;
2228 
2229 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
2230 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
2231 // CHECK: [[CMP:%[^ ]+]] = icmp eq <8 x i16> [[VAL1]], [[VAL2]]
2232 // CHECK: %{{.*}} = sext <8 x i1> [[CMP]] to <8 x i16>
2233   bs = ss == ss2;
2234 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
2235 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs2
2236 // CHECK: [[CMP:%[^ ]+]] = icmp eq <8 x i16> [[VAL1]], [[VAL2]]
2237 // CHECK: %{{.*}} = sext <8 x i1> [[CMP]] to <8 x i16>
2238   bs = ss == bs2;
2239 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs
2240 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
2241 // CHECK: [[CMP:%[^ ]+]] = icmp eq <8 x i16> [[VAL1]], [[VAL2]]
2242 // CHECK: %{{.*}} = sext <8 x i1> [[CMP]] to <8 x i16>
2243   bs = bs == ss2;
2244 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
2245 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
2246 // CHECK: [[CMP:%[^ ]+]] = icmp eq <8 x i16> [[VAL1]], [[VAL2]]
2247 // CHECK: %{{.*}} = sext <8 x i1> [[CMP]] to <8 x i16>
2248   bs = us == us2;
2249 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
2250 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs2
2251 // CHECK: [[CMP:%[^ ]+]] = icmp eq <8 x i16> [[VAL1]], [[VAL2]]
2252 // CHECK: %{{.*}} = sext <8 x i1> [[CMP]] to <8 x i16>
2253   bs = us == bs2;
2254 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs
2255 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
2256 // CHECK: [[CMP:%[^ ]+]] = icmp eq <8 x i16> [[VAL1]], [[VAL2]]
2257 // CHECK: %{{.*}} = sext <8 x i1> [[CMP]] to <8 x i16>
2258   bs = bs == us2;
2259 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs
2260 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs2
2261 // CHECK: [[CMP:%[^ ]+]] = icmp eq <8 x i16> [[VAL1]], [[VAL2]]
2262 // CHECK: %{{.*}} = sext <8 x i1> [[CMP]] to <8 x i16>
2263   bs = bs == bs2;
2264 
2265 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
2266 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
2267 // CHECK: [[CMP:%[^ ]+]] = icmp eq <4 x i32> [[VAL1]], [[VAL2]]
2268 // CHECK: %{{.*}} = sext <4 x i1> [[CMP]] to <4 x i32>
2269   bi = si == si2;
2270 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
2271 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi2
2272 // CHECK: [[CMP:%[^ ]+]] = icmp eq <4 x i32> [[VAL1]], [[VAL2]]
2273 // CHECK: %{{.*}} = sext <4 x i1> [[CMP]] to <4 x i32>
2274   bi = si == bi2;
2275 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi
2276 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
2277 // CHECK: [[CMP:%[^ ]+]] = icmp eq <4 x i32> [[VAL1]], [[VAL2]]
2278 // CHECK: %{{.*}} = sext <4 x i1> [[CMP]] to <4 x i32>
2279   bi = bi == si2;
2280 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
2281 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
2282 // CHECK: [[CMP:%[^ ]+]] = icmp eq <4 x i32> [[VAL1]], [[VAL2]]
2283 // CHECK: %{{.*}} = sext <4 x i1> [[CMP]] to <4 x i32>
2284   bi = ui == ui2;
2285 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
2286 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi2
2287 // CHECK: [[CMP:%[^ ]+]] = icmp eq <4 x i32> [[VAL1]], [[VAL2]]
2288 // CHECK: %{{.*}} = sext <4 x i1> [[CMP]] to <4 x i32>
2289   bi = ui == bi2;
2290 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi
2291 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
2292 // CHECK: [[CMP:%[^ ]+]] = icmp eq <4 x i32> [[VAL1]], [[VAL2]]
2293 // CHECK: %{{.*}} = sext <4 x i1> [[CMP]] to <4 x i32>
2294   bi = bi == ui2;
2295 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi
2296 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi2
2297 // CHECK: [[CMP:%[^ ]+]] = icmp eq <4 x i32> [[VAL1]], [[VAL2]]
2298 // CHECK: %{{.*}} = sext <4 x i1> [[CMP]] to <4 x i32>
2299   bi = bi == bi2;
2300 
2301 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
2302 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
2303 // CHECK: [[CMP:%[^ ]+]] = icmp eq <2 x i64> [[VAL1]], [[VAL2]]
2304 // CHECK: %{{.*}} = sext <2 x i1> [[CMP]] to <2 x i64>
2305   bl = sl == sl2;
2306 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
2307 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl2
2308 // CHECK: [[CMP:%[^ ]+]] = icmp eq <2 x i64> [[VAL1]], [[VAL2]]
2309 // CHECK: %{{.*}} = sext <2 x i1> [[CMP]] to <2 x i64>
2310   bl = sl == bl2;
2311 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl
2312 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
2313 // CHECK: [[CMP:%[^ ]+]] = icmp eq <2 x i64> [[VAL1]], [[VAL2]]
2314 // CHECK: %{{.*}} = sext <2 x i1> [[CMP]] to <2 x i64>
2315   bl = bl == sl2;
2316 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
2317 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
2318 // CHECK: [[CMP:%[^ ]+]] = icmp eq <2 x i64> [[VAL1]], [[VAL2]]
2319 // CHECK: %{{.*}} = sext <2 x i1> [[CMP]] to <2 x i64>
2320   bl = ul == ul2;
2321 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
2322 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl2
2323 // CHECK: [[CMP:%[^ ]+]] = icmp eq <2 x i64> [[VAL1]], [[VAL2]]
2324 // CHECK: %{{.*}} = sext <2 x i1> [[CMP]] to <2 x i64>
2325   bl = ul == bl2;
2326 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl
2327 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
2328 // CHECK: [[CMP:%[^ ]+]] = icmp eq <2 x i64> [[VAL1]], [[VAL2]]
2329 // CHECK: %{{.*}} = sext <2 x i1> [[CMP]] to <2 x i64>
2330   bl = bl == ul2;
2331 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl
2332 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl2
2333 // CHECK: [[CMP:%[^ ]+]] = icmp eq <2 x i64> [[VAL1]], [[VAL2]]
2334 // CHECK: %{{.*}} = sext <2 x i1> [[CMP]] to <2 x i64>
2335   bl = bl == bl2;
2336 
2337 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x double>, <2 x double>* @fd
2338 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x double>, <2 x double>* @fd2
2339 // CHECK: [[CMP:%[^ ]+]] = fcmp oeq <2 x double> [[VAL1]], [[VAL2]]
2340 // CHECK: %{{.*}} = sext <2 x i1> [[CMP]] to <2 x i64>
2341   bl = fd == fd2;
2342 }
2343 
test_cmpne(void)2344 void test_cmpne (void)
2345 {
2346 // CHECK-LABEL: test_cmpne
2347 
2348 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
2349 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
2350 // CHECK: [[CMP:%[^ ]+]] = icmp ne <16 x i8> [[VAL1]], [[VAL2]]
2351 // CHECK: %{{.*}} = sext <16 x i1> [[CMP]] to <16 x i8>
2352   bc = sc != sc2;
2353 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
2354 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc2
2355 // CHECK: [[CMP:%[^ ]+]] = icmp ne <16 x i8> [[VAL1]], [[VAL2]]
2356 // CHECK: %{{.*}} = sext <16 x i1> [[CMP]] to <16 x i8>
2357   bc = sc != bc2;
2358 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc
2359 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
2360 // CHECK: [[CMP:%[^ ]+]] = icmp ne <16 x i8> [[VAL1]], [[VAL2]]
2361 // CHECK: %{{.*}} = sext <16 x i1> [[CMP]] to <16 x i8>
2362   bc = bc != sc2;
2363 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
2364 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
2365 // CHECK: [[CMP:%[^ ]+]] = icmp ne <16 x i8> [[VAL1]], [[VAL2]]
2366 // CHECK: %{{.*}} = sext <16 x i1> [[CMP]] to <16 x i8>
2367   bc = uc != uc2;
2368 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
2369 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc2
2370 // CHECK: [[CMP:%[^ ]+]] = icmp ne <16 x i8> [[VAL1]], [[VAL2]]
2371 // CHECK: %{{.*}} = sext <16 x i1> [[CMP]] to <16 x i8>
2372   bc = uc != bc2;
2373 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc
2374 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
2375 // CHECK: [[CMP:%[^ ]+]] = icmp ne <16 x i8> [[VAL1]], [[VAL2]]
2376 // CHECK: %{{.*}} = sext <16 x i1> [[CMP]] to <16 x i8>
2377   bc = bc != uc2;
2378 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc
2379 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc2
2380 // CHECK: [[CMP:%[^ ]+]] = icmp ne <16 x i8> [[VAL1]], [[VAL2]]
2381 // CHECK: %{{.*}} = sext <16 x i1> [[CMP]] to <16 x i8>
2382   bc = bc != bc2;
2383 
2384 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
2385 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
2386 // CHECK: [[CMP:%[^ ]+]] = icmp ne <8 x i16> [[VAL1]], [[VAL2]]
2387 // CHECK: %{{.*}} = sext <8 x i1> [[CMP]] to <8 x i16>
2388   bs = ss != ss2;
2389 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
2390 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs2
2391 // CHECK: [[CMP:%[^ ]+]] = icmp ne <8 x i16> [[VAL1]], [[VAL2]]
2392 // CHECK: %{{.*}} = sext <8 x i1> [[CMP]] to <8 x i16>
2393   bs = ss != bs2;
2394 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs
2395 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
2396 // CHECK: [[CMP:%[^ ]+]] = icmp ne <8 x i16> [[VAL1]], [[VAL2]]
2397 // CHECK: %{{.*}} = sext <8 x i1> [[CMP]] to <8 x i16>
2398   bs = bs != ss2;
2399 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
2400 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
2401 // CHECK: [[CMP:%[^ ]+]] = icmp ne <8 x i16> [[VAL1]], [[VAL2]]
2402 // CHECK: %{{.*}} = sext <8 x i1> [[CMP]] to <8 x i16>
2403   bs = us != us2;
2404 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
2405 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs2
2406 // CHECK: [[CMP:%[^ ]+]] = icmp ne <8 x i16> [[VAL1]], [[VAL2]]
2407 // CHECK: %{{.*}} = sext <8 x i1> [[CMP]] to <8 x i16>
2408   bs = us != bs2;
2409 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs
2410 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
2411 // CHECK: [[CMP:%[^ ]+]] = icmp ne <8 x i16> [[VAL1]], [[VAL2]]
2412 // CHECK: %{{.*}} = sext <8 x i1> [[CMP]] to <8 x i16>
2413   bs = bs != us2;
2414 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs
2415 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs2
2416 // CHECK: [[CMP:%[^ ]+]] = icmp ne <8 x i16> [[VAL1]], [[VAL2]]
2417 // CHECK: %{{.*}} = sext <8 x i1> [[CMP]] to <8 x i16>
2418   bs = bs != bs2;
2419 
2420 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
2421 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
2422 // CHECK: [[CMP:%[^ ]+]] = icmp ne <4 x i32> [[VAL1]], [[VAL2]]
2423 // CHECK: %{{.*}} = sext <4 x i1> [[CMP]] to <4 x i32>
2424   bi = si != si2;
2425 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
2426 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi2
2427 // CHECK: [[CMP:%[^ ]+]] = icmp ne <4 x i32> [[VAL1]], [[VAL2]]
2428 // CHECK: %{{.*}} = sext <4 x i1> [[CMP]] to <4 x i32>
2429   bi = si != bi2;
2430 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi
2431 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
2432 // CHECK: [[CMP:%[^ ]+]] = icmp ne <4 x i32> [[VAL1]], [[VAL2]]
2433 // CHECK: %{{.*}} = sext <4 x i1> [[CMP]] to <4 x i32>
2434   bi = bi != si2;
2435 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
2436 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
2437 // CHECK: [[CMP:%[^ ]+]] = icmp ne <4 x i32> [[VAL1]], [[VAL2]]
2438 // CHECK: %{{.*}} = sext <4 x i1> [[CMP]] to <4 x i32>
2439   bi = ui != ui2;
2440 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
2441 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi2
2442 // CHECK: [[CMP:%[^ ]+]] = icmp ne <4 x i32> [[VAL1]], [[VAL2]]
2443 // CHECK: %{{.*}} = sext <4 x i1> [[CMP]] to <4 x i32>
2444   bi = ui != bi2;
2445 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi
2446 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
2447 // CHECK: [[CMP:%[^ ]+]] = icmp ne <4 x i32> [[VAL1]], [[VAL2]]
2448 // CHECK: %{{.*}} = sext <4 x i1> [[CMP]] to <4 x i32>
2449   bi = bi != ui2;
2450 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi
2451 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi2
2452 // CHECK: [[CMP:%[^ ]+]] = icmp ne <4 x i32> [[VAL1]], [[VAL2]]
2453 // CHECK: %{{.*}} = sext <4 x i1> [[CMP]] to <4 x i32>
2454   bi = bi != bi2;
2455 
2456 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
2457 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
2458 // CHECK: [[CMP:%[^ ]+]] = icmp ne <2 x i64> [[VAL1]], [[VAL2]]
2459 // CHECK: %{{.*}} = sext <2 x i1> [[CMP]] to <2 x i64>
2460   bl = sl != sl2;
2461 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
2462 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl2
2463 // CHECK: [[CMP:%[^ ]+]] = icmp ne <2 x i64> [[VAL1]], [[VAL2]]
2464 // CHECK: %{{.*}} = sext <2 x i1> [[CMP]] to <2 x i64>
2465   bl = sl != bl2;
2466 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl
2467 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
2468 // CHECK: [[CMP:%[^ ]+]] = icmp ne <2 x i64> [[VAL1]], [[VAL2]]
2469 // CHECK: %{{.*}} = sext <2 x i1> [[CMP]] to <2 x i64>
2470   bl = bl != sl2;
2471 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
2472 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
2473 // CHECK: [[CMP:%[^ ]+]] = icmp ne <2 x i64> [[VAL1]], [[VAL2]]
2474 // CHECK: %{{.*}} = sext <2 x i1> [[CMP]] to <2 x i64>
2475   bl = ul != ul2;
2476 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
2477 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl2
2478 // CHECK: [[CMP:%[^ ]+]] = icmp ne <2 x i64> [[VAL1]], [[VAL2]]
2479 // CHECK: %{{.*}} = sext <2 x i1> [[CMP]] to <2 x i64>
2480   bl = ul != bl2;
2481 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl
2482 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
2483 // CHECK: [[CMP:%[^ ]+]] = icmp ne <2 x i64> [[VAL1]], [[VAL2]]
2484 // CHECK: %{{.*}} = sext <2 x i1> [[CMP]] to <2 x i64>
2485   bl = bl != ul2;
2486 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl
2487 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl2
2488 // CHECK: [[CMP:%[^ ]+]] = icmp ne <2 x i64> [[VAL1]], [[VAL2]]
2489 // CHECK: %{{.*}} = sext <2 x i1> [[CMP]] to <2 x i64>
2490   bl = bl != bl2;
2491 
2492 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x double>, <2 x double>* @fd
2493 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x double>, <2 x double>* @fd2
2494 // CHECK: [[CMP:%[^ ]+]] = fcmp une <2 x double> [[VAL1]], [[VAL2]]
2495 // CHECK: %{{.*}} = sext <2 x i1> [[CMP]] to <2 x i64>
2496   bl = fd != fd2;
2497 }
2498 
test_cmpge(void)2499 void test_cmpge (void)
2500 {
2501 // CHECK-LABEL: test_cmpge
2502 
2503 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
2504 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
2505 // CHECK: [[CMP:%[^ ]+]] = icmp sge <16 x i8> [[VAL1]], [[VAL2]]
2506 // CHECK: %{{.*}} = sext <16 x i1> [[CMP]] to <16 x i8>
2507   bc = sc >= sc2;
2508 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
2509 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
2510 // CHECK: [[CMP:%[^ ]+]] = icmp uge <16 x i8> [[VAL1]], [[VAL2]]
2511 // CHECK: %{{.*}} = sext <16 x i1> [[CMP]] to <16 x i8>
2512   bc = uc >= uc2;
2513 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc
2514 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc2
2515 // CHECK: [[CMP:%[^ ]+]] = icmp uge <16 x i8> [[VAL1]], [[VAL2]]
2516 // CHECK: %{{.*}} = sext <16 x i1> [[CMP]] to <16 x i8>
2517   bc = bc >= bc2;
2518 
2519 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
2520 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
2521 // CHECK: [[CMP:%[^ ]+]] = icmp sge <8 x i16> [[VAL1]], [[VAL2]]
2522 // CHECK: %{{.*}} = sext <8 x i1> [[CMP]] to <8 x i16>
2523   bs = ss >= ss2;
2524 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
2525 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
2526 // CHECK: [[CMP:%[^ ]+]] = icmp uge <8 x i16> [[VAL1]], [[VAL2]]
2527 // CHECK: %{{.*}} = sext <8 x i1> [[CMP]] to <8 x i16>
2528   bs = us >= us2;
2529 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs
2530 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs2
2531 // CHECK: [[CMP:%[^ ]+]] = icmp uge <8 x i16> [[VAL1]], [[VAL2]]
2532 // CHECK: %{{.*}} = sext <8 x i1> [[CMP]] to <8 x i16>
2533   bs = bs >= bs2;
2534 
2535 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
2536 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
2537 // CHECK: [[CMP:%[^ ]+]] = icmp sge <4 x i32> [[VAL1]], [[VAL2]]
2538 // CHECK: %{{.*}} = sext <4 x i1> [[CMP]] to <4 x i32>
2539   bi = si >= si2;
2540 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
2541 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
2542 // CHECK: [[CMP:%[^ ]+]] = icmp uge <4 x i32> [[VAL1]], [[VAL2]]
2543 // CHECK: %{{.*}} = sext <4 x i1> [[CMP]] to <4 x i32>
2544   bi = ui >= ui2;
2545 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi
2546 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi2
2547 // CHECK: [[CMP:%[^ ]+]] = icmp uge <4 x i32> [[VAL1]], [[VAL2]]
2548 // CHECK: %{{.*}} = sext <4 x i1> [[CMP]] to <4 x i32>
2549   bi = bi >= bi2;
2550 
2551 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
2552 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
2553 // CHECK: [[CMP:%[^ ]+]] = icmp sge <2 x i64> [[VAL1]], [[VAL2]]
2554 // CHECK: %{{.*}} = sext <2 x i1> [[CMP]] to <2 x i64>
2555   bl = sl >= sl2;
2556 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
2557 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
2558 // CHECK: [[CMP:%[^ ]+]] = icmp uge <2 x i64> [[VAL1]], [[VAL2]]
2559 // CHECK: %{{.*}} = sext <2 x i1> [[CMP]] to <2 x i64>
2560   bl = ul >= ul2;
2561 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl
2562 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl2
2563 // CHECK: [[CMP:%[^ ]+]] = icmp uge <2 x i64> [[VAL1]], [[VAL2]]
2564 // CHECK: %{{.*}} = sext <2 x i1> [[CMP]] to <2 x i64>
2565   bl = bl >= bl2;
2566 
2567 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x double>, <2 x double>* @fd
2568 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x double>, <2 x double>* @fd2
2569 // CHECK: [[CMP:%[^ ]+]] = fcmp oge <2 x double> [[VAL1]], [[VAL2]]
2570 // CHECK: %{{.*}} = sext <2 x i1> [[CMP]] to <2 x i64>
2571   bl = fd >= fd2;
2572 }
2573 
test_cmpgt(void)2574 void test_cmpgt (void)
2575 {
2576 // CHECK-LABEL: test_cmpgt
2577 
2578 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
2579 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
2580 // CHECK: [[CMP:%[^ ]+]] = icmp sgt <16 x i8> [[VAL1]], [[VAL2]]
2581 // CHECK: %{{.*}} = sext <16 x i1> [[CMP]] to <16 x i8>
2582   bc = sc > sc2;
2583 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
2584 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
2585 // CHECK: [[CMP:%[^ ]+]] = icmp ugt <16 x i8> [[VAL1]], [[VAL2]]
2586 // CHECK: %{{.*}} = sext <16 x i1> [[CMP]] to <16 x i8>
2587   bc = uc > uc2;
2588 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc
2589 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc2
2590 // CHECK: [[CMP:%[^ ]+]] = icmp ugt <16 x i8> [[VAL1]], [[VAL2]]
2591 // CHECK: %{{.*}} = sext <16 x i1> [[CMP]] to <16 x i8>
2592   bc = bc > bc2;
2593 
2594 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
2595 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
2596 // CHECK: [[CMP:%[^ ]+]] = icmp sgt <8 x i16> [[VAL1]], [[VAL2]]
2597 // CHECK: %{{.*}} = sext <8 x i1> [[CMP]] to <8 x i16>
2598   bs = ss > ss2;
2599 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
2600 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
2601 // CHECK: [[CMP:%[^ ]+]] = icmp ugt <8 x i16> [[VAL1]], [[VAL2]]
2602 // CHECK: %{{.*}} = sext <8 x i1> [[CMP]] to <8 x i16>
2603   bs = us > us2;
2604 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs
2605 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs2
2606 // CHECK: [[CMP:%[^ ]+]] = icmp ugt <8 x i16> [[VAL1]], [[VAL2]]
2607 // CHECK: %{{.*}} = sext <8 x i1> [[CMP]] to <8 x i16>
2608   bs = bs > bs2;
2609 
2610 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
2611 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
2612 // CHECK: [[CMP:%[^ ]+]] = icmp sgt <4 x i32> [[VAL1]], [[VAL2]]
2613 // CHECK: %{{.*}} = sext <4 x i1> [[CMP]] to <4 x i32>
2614   bi = si > si2;
2615 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
2616 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
2617 // CHECK: [[CMP:%[^ ]+]] = icmp ugt <4 x i32> [[VAL1]], [[VAL2]]
2618 // CHECK: %{{.*}} = sext <4 x i1> [[CMP]] to <4 x i32>
2619   bi = ui > ui2;
2620 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi
2621 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi2
2622 // CHECK: [[CMP:%[^ ]+]] = icmp ugt <4 x i32> [[VAL1]], [[VAL2]]
2623 // CHECK: %{{.*}} = sext <4 x i1> [[CMP]] to <4 x i32>
2624   bi = bi > bi2;
2625 
2626 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
2627 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
2628 // CHECK: [[CMP:%[^ ]+]] = icmp sgt <2 x i64> [[VAL1]], [[VAL2]]
2629 // CHECK: %{{.*}} = sext <2 x i1> [[CMP]] to <2 x i64>
2630   bl = sl > sl2;
2631 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
2632 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
2633 // CHECK: [[CMP:%[^ ]+]] = icmp ugt <2 x i64> [[VAL1]], [[VAL2]]
2634 // CHECK: %{{.*}} = sext <2 x i1> [[CMP]] to <2 x i64>
2635   bl = ul > ul2;
2636 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl
2637 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl2
2638 // CHECK: [[CMP:%[^ ]+]] = icmp ugt <2 x i64> [[VAL1]], [[VAL2]]
2639 // CHECK: %{{.*}} = sext <2 x i1> [[CMP]] to <2 x i64>
2640   bl = bl > bl2;
2641 
2642 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x double>, <2 x double>* @fd
2643 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x double>, <2 x double>* @fd2
2644 // CHECK: [[CMP:%[^ ]+]] = fcmp ogt <2 x double> [[VAL1]], [[VAL2]]
2645 // CHECK: %{{.*}} = sext <2 x i1> [[CMP]] to <2 x i64>
2646   bl = fd > fd2;
2647 }
2648 
test_cmple(void)2649 void test_cmple (void)
2650 {
2651 // CHECK-LABEL: test_cmple
2652 
2653 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
2654 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
2655 // CHECK: [[CMP:%[^ ]+]] = icmp sle <16 x i8> [[VAL1]], [[VAL2]]
2656 // CHECK: %{{.*}} = sext <16 x i1> [[CMP]] to <16 x i8>
2657   bc = sc <= sc2;
2658 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
2659 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
2660 // CHECK: [[CMP:%[^ ]+]] = icmp ule <16 x i8> [[VAL1]], [[VAL2]]
2661 // CHECK: %{{.*}} = sext <16 x i1> [[CMP]] to <16 x i8>
2662   bc = uc <= uc2;
2663 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc
2664 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc2
2665 // CHECK: [[CMP:%[^ ]+]] = icmp ule <16 x i8> [[VAL1]], [[VAL2]]
2666 // CHECK: %{{.*}} = sext <16 x i1> [[CMP]] to <16 x i8>
2667   bc = bc <= bc2;
2668 
2669 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
2670 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
2671 // CHECK: [[CMP:%[^ ]+]] = icmp sle <8 x i16> [[VAL1]], [[VAL2]]
2672 // CHECK: %{{.*}} = sext <8 x i1> [[CMP]] to <8 x i16>
2673   bs = ss <= ss2;
2674 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
2675 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
2676 // CHECK: [[CMP:%[^ ]+]] = icmp ule <8 x i16> [[VAL1]], [[VAL2]]
2677 // CHECK: %{{.*}} = sext <8 x i1> [[CMP]] to <8 x i16>
2678   bs = us <= us2;
2679 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs
2680 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs2
2681 // CHECK: [[CMP:%[^ ]+]] = icmp ule <8 x i16> [[VAL1]], [[VAL2]]
2682 // CHECK: %{{.*}} = sext <8 x i1> [[CMP]] to <8 x i16>
2683   bs = bs <= bs2;
2684 
2685 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
2686 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
2687 // CHECK: [[CMP:%[^ ]+]] = icmp sle <4 x i32> [[VAL1]], [[VAL2]]
2688 // CHECK: %{{.*}} = sext <4 x i1> [[CMP]] to <4 x i32>
2689   bi = si <= si2;
2690 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
2691 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
2692 // CHECK: [[CMP:%[^ ]+]] = icmp ule <4 x i32> [[VAL1]], [[VAL2]]
2693 // CHECK: %{{.*}} = sext <4 x i1> [[CMP]] to <4 x i32>
2694   bi = ui <= ui2;
2695 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi
2696 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi2
2697 // CHECK: [[CMP:%[^ ]+]] = icmp ule <4 x i32> [[VAL1]], [[VAL2]]
2698 // CHECK: %{{.*}} = sext <4 x i1> [[CMP]] to <4 x i32>
2699   bi = bi <= bi2;
2700 
2701 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
2702 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
2703 // CHECK: [[CMP:%[^ ]+]] = icmp sle <2 x i64> [[VAL1]], [[VAL2]]
2704 // CHECK: %{{.*}} = sext <2 x i1> [[CMP]] to <2 x i64>
2705   bl = sl <= sl2;
2706 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
2707 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
2708 // CHECK: [[CMP:%[^ ]+]] = icmp ule <2 x i64> [[VAL1]], [[VAL2]]
2709 // CHECK: %{{.*}} = sext <2 x i1> [[CMP]] to <2 x i64>
2710   bl = ul <= ul2;
2711 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl
2712 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl2
2713 // CHECK: [[CMP:%[^ ]+]] = icmp ule <2 x i64> [[VAL1]], [[VAL2]]
2714 // CHECK: %{{.*}} = sext <2 x i1> [[CMP]] to <2 x i64>
2715   bl = bl <= bl2;
2716 
2717 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x double>, <2 x double>* @fd
2718 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x double>, <2 x double>* @fd2
2719 // CHECK: [[CMP:%[^ ]+]] = fcmp ole <2 x double> [[VAL1]], [[VAL2]]
2720 // CHECK: %{{.*}} = sext <2 x i1> [[CMP]] to <2 x i64>
2721   bl = fd <= fd2;
2722 }
2723 
test_cmplt(void)2724 void test_cmplt (void)
2725 {
2726 // CHECK-LABEL: test_cmplt
2727 
2728 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc
2729 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @sc2
2730 // CHECK: [[CMP:%[^ ]+]] = icmp slt <16 x i8> [[VAL1]], [[VAL2]]
2731 // CHECK: %{{.*}} = sext <16 x i1> [[CMP]] to <16 x i8>
2732   bc = sc < sc2;
2733 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc
2734 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @uc2
2735 // CHECK: [[CMP:%[^ ]+]] = icmp ult <16 x i8> [[VAL1]], [[VAL2]]
2736 // CHECK: %{{.*}} = sext <16 x i1> [[CMP]] to <16 x i8>
2737   bc = uc < uc2;
2738 // CHECK: [[VAL1:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc
2739 // CHECK: [[VAL2:%[^ ]+]] = load volatile <16 x i8>, <16 x i8>* @bc2
2740 // CHECK: [[CMP:%[^ ]+]] = icmp ult <16 x i8> [[VAL1]], [[VAL2]]
2741 // CHECK: %{{.*}} = sext <16 x i1> [[CMP]] to <16 x i8>
2742   bc = bc < bc2;
2743 
2744 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss
2745 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @ss2
2746 // CHECK: [[CMP:%[^ ]+]] = icmp slt <8 x i16> [[VAL1]], [[VAL2]]
2747 // CHECK: %{{.*}} = sext <8 x i1> [[CMP]] to <8 x i16>
2748   bs = ss < ss2;
2749 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us
2750 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @us2
2751 // CHECK: [[CMP:%[^ ]+]] = icmp ult <8 x i16> [[VAL1]], [[VAL2]]
2752 // CHECK: %{{.*}} = sext <8 x i1> [[CMP]] to <8 x i16>
2753   bs = us < us2;
2754 // CHECK: [[VAL1:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs
2755 // CHECK: [[VAL2:%[^ ]+]] = load volatile <8 x i16>, <8 x i16>* @bs2
2756 // CHECK: [[CMP:%[^ ]+]] = icmp ult <8 x i16> [[VAL1]], [[VAL2]]
2757 // CHECK: %{{.*}} = sext <8 x i1> [[CMP]] to <8 x i16>
2758   bs = bs < bs2;
2759 
2760 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si
2761 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @si2
2762 // CHECK: [[CMP:%[^ ]+]] = icmp slt <4 x i32> [[VAL1]], [[VAL2]]
2763 // CHECK: %{{.*}} = sext <4 x i1> [[CMP]] to <4 x i32>
2764   bi = si < si2;
2765 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui
2766 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @ui2
2767 // CHECK: [[CMP:%[^ ]+]] = icmp ult <4 x i32> [[VAL1]], [[VAL2]]
2768 // CHECK: %{{.*}} = sext <4 x i1> [[CMP]] to <4 x i32>
2769   bi = ui < ui2;
2770 // CHECK: [[VAL1:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi
2771 // CHECK: [[VAL2:%[^ ]+]] = load volatile <4 x i32>, <4 x i32>* @bi2
2772 // CHECK: [[CMP:%[^ ]+]] = icmp ult <4 x i32> [[VAL1]], [[VAL2]]
2773 // CHECK: %{{.*}} = sext <4 x i1> [[CMP]] to <4 x i32>
2774   bi = bi < bi2;
2775 
2776 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl
2777 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @sl2
2778 // CHECK: [[CMP:%[^ ]+]] = icmp slt <2 x i64> [[VAL1]], [[VAL2]]
2779 // CHECK: %{{.*}} = sext <2 x i1> [[CMP]] to <2 x i64>
2780   bl = sl < sl2;
2781 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul
2782 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @ul2
2783 // CHECK: [[CMP:%[^ ]+]] = icmp ult <2 x i64> [[VAL1]], [[VAL2]]
2784 // CHECK: %{{.*}} = sext <2 x i1> [[CMP]] to <2 x i64>
2785   bl = ul < ul2;
2786 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl
2787 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x i64>, <2 x i64>* @bl2
2788 // CHECK: [[CMP:%[^ ]+]] = icmp ult <2 x i64> [[VAL1]], [[VAL2]]
2789 // CHECK: %{{.*}} = sext <2 x i1> [[CMP]] to <2 x i64>
2790   bl = bl < bl2;
2791 
2792 // CHECK: [[VAL1:%[^ ]+]] = load volatile <2 x double>, <2 x double>* @fd
2793 // CHECK: [[VAL2:%[^ ]+]] = load volatile <2 x double>, <2 x double>* @fd2
2794 // CHECK: [[CMP:%[^ ]+]] = fcmp olt <2 x double> [[VAL1]], [[VAL2]]
2795 // CHECK: %{{.*}} = sext <2 x i1> [[CMP]] to <2 x i64>
2796   bl = fd < fd2;
2797 }
2798 
2799