5ed687f505768905d96013b1c64061b1570e2e29
[oota-llvm.git] / test / CodeGen / X86 / vselect-minmax.ll
1 ; RUN: llc -march=x86-64 -mcpu=core2 < %s | FileCheck %s -check-prefix=SSE2
2 ; RUN: llc -march=x86-64 -mcpu=corei7 < %s | FileCheck %s -check-prefix=SSE4
3 ; RUN: llc -march=x86-64 -mcpu=corei7-avx < %s | FileCheck %s -check-prefix=AVX1
4 ; RUN: llc -march=x86-64 -mcpu=core-avx2 -mattr=+avx2 < %s | FileCheck %s -check-prefix=AVX2
5 ; RUN: llc -march=x86-64 -mcpu=knl < %s | FileCheck %s  -check-prefix=AVX2 -check-prefix=AVX512F
6 ; RUN: llc -march=x86-64 -mcpu=skx < %s | FileCheck %s  -check-prefix=AVX512BW -check-prefix=AVX512VL -check-prefix=AVX512F
7
8 define void @test1(i8* nocapture %a, i8* nocapture %b) nounwind {
9 vector.ph:
10   br label %vector.body
11
12 vector.body:                                      ; preds = %vector.body, %vector.ph
13   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
14   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
15   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
16   %ptr.a = bitcast i8* %gep.a to <16 x i8>*
17   %ptr.b = bitcast i8* %gep.b to <16 x i8>*
18   %load.a = load <16 x i8>, <16 x i8>* %ptr.a, align 2
19   %load.b = load <16 x i8>, <16 x i8>* %ptr.b, align 2
20   %cmp = icmp slt <16 x i8> %load.a, %load.b
21   %sel = select <16 x i1> %cmp, <16 x i8> %load.a, <16 x i8> %load.b
22   store <16 x i8> %sel, <16 x i8>* %ptr.a, align 2
23   %index.next = add i64 %index, 16
24   %loop = icmp eq i64 %index.next, 16384
25   br i1 %loop, label %for.end, label %vector.body
26
27 for.end:                                          ; preds = %vector.body
28   ret void
29
30 ; SSE4-LABEL: test1:
31 ; SSE4: pminsb
32
33 ; AVX1-LABEL: test1:
34 ; AVX1: vpminsb
35
36 ; AVX2-LABEL: test1:
37 ; AVX2: vpminsb
38
39 ; AVX512VL-LABEL: test1:
40 ; AVX512VL: vpminsb
41 }
42
43 define void @test2(i8* nocapture %a, i8* nocapture %b) nounwind {
44 vector.ph:
45   br label %vector.body
46
47 vector.body:                                      ; preds = %vector.body, %vector.ph
48   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
49   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
50   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
51   %ptr.a = bitcast i8* %gep.a to <16 x i8>*
52   %ptr.b = bitcast i8* %gep.b to <16 x i8>*
53   %load.a = load <16 x i8>, <16 x i8>* %ptr.a, align 2
54   %load.b = load <16 x i8>, <16 x i8>* %ptr.b, align 2
55   %cmp = icmp sle <16 x i8> %load.a, %load.b
56   %sel = select <16 x i1> %cmp, <16 x i8> %load.a, <16 x i8> %load.b
57   store <16 x i8> %sel, <16 x i8>* %ptr.a, align 2
58   %index.next = add i64 %index, 16
59   %loop = icmp eq i64 %index.next, 16384
60   br i1 %loop, label %for.end, label %vector.body
61
62 for.end:                                          ; preds = %vector.body
63   ret void
64
65 ; SSE4-LABEL: test2:
66 ; SSE4: pminsb
67
68 ; AVX1-LABEL: test2:
69 ; AVX1: vpminsb
70
71 ; AVX2-LABEL: test2:
72 ; AVX2: vpminsb
73
74 ; AVX512VL-LABEL: test2:
75 ; AVX512VL: vpminsb
76 }
77
78 define void @test3(i8* nocapture %a, i8* nocapture %b) nounwind {
79 vector.ph:
80   br label %vector.body
81
82 vector.body:                                      ; preds = %vector.body, %vector.ph
83   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
84   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
85   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
86   %ptr.a = bitcast i8* %gep.a to <16 x i8>*
87   %ptr.b = bitcast i8* %gep.b to <16 x i8>*
88   %load.a = load <16 x i8>, <16 x i8>* %ptr.a, align 2
89   %load.b = load <16 x i8>, <16 x i8>* %ptr.b, align 2
90   %cmp = icmp sgt <16 x i8> %load.a, %load.b
91   %sel = select <16 x i1> %cmp, <16 x i8> %load.a, <16 x i8> %load.b
92   store <16 x i8> %sel, <16 x i8>* %ptr.a, align 2
93   %index.next = add i64 %index, 16
94   %loop = icmp eq i64 %index.next, 16384
95   br i1 %loop, label %for.end, label %vector.body
96
97 for.end:                                          ; preds = %vector.body
98   ret void
99
100 ; SSE4-LABEL: test3:
101 ; SSE4: pmaxsb
102
103 ; AVX1-LABEL: test3:
104 ; AVX1: vpmaxsb
105
106 ; AVX2-LABEL: test3:
107 ; AVX2: vpmaxsb
108
109 ; AVX512VL-LABEL: test3:
110 ; AVX512VL: vpmaxsb
111 }
112
113 define void @test4(i8* nocapture %a, i8* nocapture %b) nounwind {
114 vector.ph:
115   br label %vector.body
116
117 vector.body:                                      ; preds = %vector.body, %vector.ph
118   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
119   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
120   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
121   %ptr.a = bitcast i8* %gep.a to <16 x i8>*
122   %ptr.b = bitcast i8* %gep.b to <16 x i8>*
123   %load.a = load <16 x i8>, <16 x i8>* %ptr.a, align 2
124   %load.b = load <16 x i8>, <16 x i8>* %ptr.b, align 2
125   %cmp = icmp sge <16 x i8> %load.a, %load.b
126   %sel = select <16 x i1> %cmp, <16 x i8> %load.a, <16 x i8> %load.b
127   store <16 x i8> %sel, <16 x i8>* %ptr.a, align 2
128   %index.next = add i64 %index, 16
129   %loop = icmp eq i64 %index.next, 16384
130   br i1 %loop, label %for.end, label %vector.body
131
132 for.end:                                          ; preds = %vector.body
133   ret void
134
135 ; SSE4-LABEL: test4:
136 ; SSE4: pmaxsb
137
138 ; AVX1-LABEL: test4:
139 ; AVX1: vpmaxsb
140
141 ; AVX2-LABEL: test4:
142 ; AVX2: vpmaxsb
143
144 ; AVX512VL-LABEL: test4:
145 ; AVX512VL: vpmaxsb
146 }
147
148 define void @test5(i8* nocapture %a, i8* nocapture %b) nounwind {
149 vector.ph:
150   br label %vector.body
151
152 vector.body:                                      ; preds = %vector.body, %vector.ph
153   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
154   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
155   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
156   %ptr.a = bitcast i8* %gep.a to <16 x i8>*
157   %ptr.b = bitcast i8* %gep.b to <16 x i8>*
158   %load.a = load <16 x i8>, <16 x i8>* %ptr.a, align 2
159   %load.b = load <16 x i8>, <16 x i8>* %ptr.b, align 2
160   %cmp = icmp ult <16 x i8> %load.a, %load.b
161   %sel = select <16 x i1> %cmp, <16 x i8> %load.a, <16 x i8> %load.b
162   store <16 x i8> %sel, <16 x i8>* %ptr.a, align 2
163   %index.next = add i64 %index, 16
164   %loop = icmp eq i64 %index.next, 16384
165   br i1 %loop, label %for.end, label %vector.body
166
167 for.end:                                          ; preds = %vector.body
168   ret void
169
170 ; SSE2-LABEL: test5:
171 ; SSE2: pminub
172
173 ; AVX1-LABEL: test5:
174 ; AVX1: vpminub
175
176 ; AVX2-LABEL: test5:
177 ; AVX2: vpminub
178
179 ; AVX512VL-LABEL: test5:
180 ; AVX512VL: vpminub 
181 }
182
183 define void @test6(i8* nocapture %a, i8* nocapture %b) nounwind {
184 vector.ph:
185   br label %vector.body
186
187 vector.body:                                      ; preds = %vector.body, %vector.ph
188   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
189   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
190   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
191   %ptr.a = bitcast i8* %gep.a to <16 x i8>*
192   %ptr.b = bitcast i8* %gep.b to <16 x i8>*
193   %load.a = load <16 x i8>, <16 x i8>* %ptr.a, align 2
194   %load.b = load <16 x i8>, <16 x i8>* %ptr.b, align 2
195   %cmp = icmp ule <16 x i8> %load.a, %load.b
196   %sel = select <16 x i1> %cmp, <16 x i8> %load.a, <16 x i8> %load.b
197   store <16 x i8> %sel, <16 x i8>* %ptr.a, align 2
198   %index.next = add i64 %index, 16
199   %loop = icmp eq i64 %index.next, 16384
200   br i1 %loop, label %for.end, label %vector.body
201
202 for.end:                                          ; preds = %vector.body
203   ret void
204
205 ; SSE2-LABEL: test6:
206 ; SSE2: pminub
207
208 ; AVX1-LABEL: test6:
209 ; AVX1: vpminub
210
211 ; AVX2-LABEL: test6:
212 ; AVX2: vpminub
213
214 ; AVX512VL-LABEL: test6:
215 ; AVX512VL: vpminub
216 }
217
218 define void @test7(i8* nocapture %a, i8* nocapture %b) nounwind {
219 vector.ph:
220   br label %vector.body
221
222 vector.body:                                      ; preds = %vector.body, %vector.ph
223   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
224   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
225   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
226   %ptr.a = bitcast i8* %gep.a to <16 x i8>*
227   %ptr.b = bitcast i8* %gep.b to <16 x i8>*
228   %load.a = load <16 x i8>, <16 x i8>* %ptr.a, align 2
229   %load.b = load <16 x i8>, <16 x i8>* %ptr.b, align 2
230   %cmp = icmp ugt <16 x i8> %load.a, %load.b
231   %sel = select <16 x i1> %cmp, <16 x i8> %load.a, <16 x i8> %load.b
232   store <16 x i8> %sel, <16 x i8>* %ptr.a, align 2
233   %index.next = add i64 %index, 16
234   %loop = icmp eq i64 %index.next, 16384
235   br i1 %loop, label %for.end, label %vector.body
236
237 for.end:                                          ; preds = %vector.body
238   ret void
239
240 ; SSE2-LABEL: test7:
241 ; SSE2: pmaxub
242
243 ; AVX1-LABEL: test7:
244 ; AVX1: vpmaxub
245
246 ; AVX2-LABEL: test7:
247 ; AVX2: vpmaxub
248
249 ; AVX512VL-LABEL: test7:
250 ; AVX512VL: vpmaxub
251 }
252
253 define void @test8(i8* nocapture %a, i8* nocapture %b) nounwind {
254 vector.ph:
255   br label %vector.body
256
257 vector.body:                                      ; preds = %vector.body, %vector.ph
258   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
259   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
260   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
261   %ptr.a = bitcast i8* %gep.a to <16 x i8>*
262   %ptr.b = bitcast i8* %gep.b to <16 x i8>*
263   %load.a = load <16 x i8>, <16 x i8>* %ptr.a, align 2
264   %load.b = load <16 x i8>, <16 x i8>* %ptr.b, align 2
265   %cmp = icmp uge <16 x i8> %load.a, %load.b
266   %sel = select <16 x i1> %cmp, <16 x i8> %load.a, <16 x i8> %load.b
267   store <16 x i8> %sel, <16 x i8>* %ptr.a, align 2
268   %index.next = add i64 %index, 16
269   %loop = icmp eq i64 %index.next, 16384
270   br i1 %loop, label %for.end, label %vector.body
271
272 for.end:                                          ; preds = %vector.body
273   ret void
274
275 ; SSE2-LABEL: test8:
276 ; SSE2: pmaxub
277
278 ; AVX1-LABEL: test8:
279 ; AVX1: vpmaxub
280
281 ; AVX2-LABEL: test8:
282 ; AVX2: vpmaxub
283
284 ; AVX512VL-LABEL: test8:
285 ; AVX512VL: vpmaxub
286 }
287
288 define void @test9(i16* nocapture %a, i16* nocapture %b) nounwind {
289 vector.ph:
290   br label %vector.body
291
292 vector.body:                                      ; preds = %vector.body, %vector.ph
293   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
294   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
295   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
296   %ptr.a = bitcast i16* %gep.a to <8 x i16>*
297   %ptr.b = bitcast i16* %gep.b to <8 x i16>*
298   %load.a = load <8 x i16>, <8 x i16>* %ptr.a, align 2
299   %load.b = load <8 x i16>, <8 x i16>* %ptr.b, align 2
300   %cmp = icmp slt <8 x i16> %load.a, %load.b
301   %sel = select <8 x i1> %cmp, <8 x i16> %load.a, <8 x i16> %load.b
302   store <8 x i16> %sel, <8 x i16>* %ptr.a, align 2
303   %index.next = add i64 %index, 8
304   %loop = icmp eq i64 %index.next, 16384
305   br i1 %loop, label %for.end, label %vector.body
306
307 for.end:                                          ; preds = %vector.body
308   ret void
309
310 ; SSE2-LABEL: test9:
311 ; SSE2: pminsw
312
313 ; AVX1-LABEL: test9:
314 ; AVX1: vpminsw
315
316 ; AVX2-LABEL: test9:
317 ; AVX2: vpminsw
318
319 ; AVX512VL-LABEL: test9:
320 ; AVX512VL: vpminsw 
321 }
322
323 define void @test10(i16* nocapture %a, i16* nocapture %b) nounwind {
324 vector.ph:
325   br label %vector.body
326
327 vector.body:                                      ; preds = %vector.body, %vector.ph
328   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
329   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
330   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
331   %ptr.a = bitcast i16* %gep.a to <8 x i16>*
332   %ptr.b = bitcast i16* %gep.b to <8 x i16>*
333   %load.a = load <8 x i16>, <8 x i16>* %ptr.a, align 2
334   %load.b = load <8 x i16>, <8 x i16>* %ptr.b, align 2
335   %cmp = icmp sle <8 x i16> %load.a, %load.b
336   %sel = select <8 x i1> %cmp, <8 x i16> %load.a, <8 x i16> %load.b
337   store <8 x i16> %sel, <8 x i16>* %ptr.a, align 2
338   %index.next = add i64 %index, 8
339   %loop = icmp eq i64 %index.next, 16384
340   br i1 %loop, label %for.end, label %vector.body
341
342 for.end:                                          ; preds = %vector.body
343   ret void
344
345 ; SSE2-LABEL: test10:
346 ; SSE2: pminsw
347
348 ; AVX1-LABEL: test10:
349 ; AVX1: vpminsw
350
351 ; AVX2-LABEL: test10:
352 ; AVX2: vpminsw
353
354 ; AVX512VL-LABEL: test10:
355 ; AVX512VL: vpminsw
356 }
357
358 define void @test11(i16* nocapture %a, i16* nocapture %b) nounwind {
359 vector.ph:
360   br label %vector.body
361
362 vector.body:                                      ; preds = %vector.body, %vector.ph
363   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
364   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
365   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
366   %ptr.a = bitcast i16* %gep.a to <8 x i16>*
367   %ptr.b = bitcast i16* %gep.b to <8 x i16>*
368   %load.a = load <8 x i16>, <8 x i16>* %ptr.a, align 2
369   %load.b = load <8 x i16>, <8 x i16>* %ptr.b, align 2
370   %cmp = icmp sgt <8 x i16> %load.a, %load.b
371   %sel = select <8 x i1> %cmp, <8 x i16> %load.a, <8 x i16> %load.b
372   store <8 x i16> %sel, <8 x i16>* %ptr.a, align 2
373   %index.next = add i64 %index, 8
374   %loop = icmp eq i64 %index.next, 16384
375   br i1 %loop, label %for.end, label %vector.body
376
377 for.end:                                          ; preds = %vector.body
378   ret void
379
380 ; SSE2-LABEL: test11:
381 ; SSE2: pmaxsw
382
383 ; AVX1-LABEL: test11:
384 ; AVX1: vpmaxsw
385
386 ; AVX2-LABEL: test11:
387 ; AVX2: vpmaxsw
388
389 ; AVX512VL-LABEL: test11:
390 ; AVX512VL: vpmaxsw
391 }
392
393 define void @test12(i16* nocapture %a, i16* nocapture %b) nounwind {
394 vector.ph:
395   br label %vector.body
396
397 vector.body:                                      ; preds = %vector.body, %vector.ph
398   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
399   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
400   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
401   %ptr.a = bitcast i16* %gep.a to <8 x i16>*
402   %ptr.b = bitcast i16* %gep.b to <8 x i16>*
403   %load.a = load <8 x i16>, <8 x i16>* %ptr.a, align 2
404   %load.b = load <8 x i16>, <8 x i16>* %ptr.b, align 2
405   %cmp = icmp sge <8 x i16> %load.a, %load.b
406   %sel = select <8 x i1> %cmp, <8 x i16> %load.a, <8 x i16> %load.b
407   store <8 x i16> %sel, <8 x i16>* %ptr.a, align 2
408   %index.next = add i64 %index, 8
409   %loop = icmp eq i64 %index.next, 16384
410   br i1 %loop, label %for.end, label %vector.body
411
412 for.end:                                          ; preds = %vector.body
413   ret void
414
415 ; SSE2-LABEL: test12:
416 ; SSE2: pmaxsw
417
418 ; AVX1-LABEL: test12:
419 ; AVX1: vpmaxsw
420
421 ; AVX2-LABEL: test12:
422 ; AVX2: vpmaxsw
423
424 ; AVX512VL-LABEL: test12:
425 ; AVX512VL: vpmaxsw
426 }
427
428 define void @test13(i16* nocapture %a, i16* nocapture %b) nounwind {
429 vector.ph:
430   br label %vector.body
431
432 vector.body:                                      ; preds = %vector.body, %vector.ph
433   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
434   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
435   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
436   %ptr.a = bitcast i16* %gep.a to <8 x i16>*
437   %ptr.b = bitcast i16* %gep.b to <8 x i16>*
438   %load.a = load <8 x i16>, <8 x i16>* %ptr.a, align 2
439   %load.b = load <8 x i16>, <8 x i16>* %ptr.b, align 2
440   %cmp = icmp ult <8 x i16> %load.a, %load.b
441   %sel = select <8 x i1> %cmp, <8 x i16> %load.a, <8 x i16> %load.b
442   store <8 x i16> %sel, <8 x i16>* %ptr.a, align 2
443   %index.next = add i64 %index, 8
444   %loop = icmp eq i64 %index.next, 16384
445   br i1 %loop, label %for.end, label %vector.body
446
447 for.end:                                          ; preds = %vector.body
448   ret void
449
450 ; SSE4-LABEL: test13:
451 ; SSE4: pminuw
452
453 ; AVX1-LABEL: test13:
454 ; AVX1: vpminuw
455
456 ; AVX2-LABEL: test13:
457 ; AVX2: vpminuw
458
459 ; AVX512VL-LABEL: test13:
460 ; AVX512VL: vpminuw
461 }
462
463 define void @test14(i16* nocapture %a, i16* nocapture %b) nounwind {
464 vector.ph:
465   br label %vector.body
466
467 vector.body:                                      ; preds = %vector.body, %vector.ph
468   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
469   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
470   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
471   %ptr.a = bitcast i16* %gep.a to <8 x i16>*
472   %ptr.b = bitcast i16* %gep.b to <8 x i16>*
473   %load.a = load <8 x i16>, <8 x i16>* %ptr.a, align 2
474   %load.b = load <8 x i16>, <8 x i16>* %ptr.b, align 2
475   %cmp = icmp ule <8 x i16> %load.a, %load.b
476   %sel = select <8 x i1> %cmp, <8 x i16> %load.a, <8 x i16> %load.b
477   store <8 x i16> %sel, <8 x i16>* %ptr.a, align 2
478   %index.next = add i64 %index, 8
479   %loop = icmp eq i64 %index.next, 16384
480   br i1 %loop, label %for.end, label %vector.body
481
482 for.end:                                          ; preds = %vector.body
483   ret void
484
485 ; SSE4-LABEL: test14:
486 ; SSE4: pminuw
487
488 ; AVX1-LABEL: test14:
489 ; AVX1: vpminuw
490
491 ; AVX2-LABEL: test14:
492 ; AVX2: vpminuw
493
494 ; AVX512VL-LABEL: test14:
495 ; AVX512VL: vpminuw 
496 }
497
498 define void @test15(i16* nocapture %a, i16* nocapture %b) nounwind {
499 vector.ph:
500   br label %vector.body
501
502 vector.body:                                      ; preds = %vector.body, %vector.ph
503   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
504   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
505   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
506   %ptr.a = bitcast i16* %gep.a to <8 x i16>*
507   %ptr.b = bitcast i16* %gep.b to <8 x i16>*
508   %load.a = load <8 x i16>, <8 x i16>* %ptr.a, align 2
509   %load.b = load <8 x i16>, <8 x i16>* %ptr.b, align 2
510   %cmp = icmp ugt <8 x i16> %load.a, %load.b
511   %sel = select <8 x i1> %cmp, <8 x i16> %load.a, <8 x i16> %load.b
512   store <8 x i16> %sel, <8 x i16>* %ptr.a, align 2
513   %index.next = add i64 %index, 8
514   %loop = icmp eq i64 %index.next, 16384
515   br i1 %loop, label %for.end, label %vector.body
516
517 for.end:                                          ; preds = %vector.body
518   ret void
519
520 ; SSE4-LABEL: test15:
521 ; SSE4: pmaxuw
522
523 ; AVX1-LABEL: test15:
524 ; AVX1: vpmaxuw
525
526 ; AVX2-LABEL: test15:
527 ; AVX2: vpmaxuw
528
529 ; AVX512VL-LABEL: test15:
530 ; AVX512VL: vpmaxuw
531 }
532
533 define void @test16(i16* nocapture %a, i16* nocapture %b) nounwind {
534 vector.ph:
535   br label %vector.body
536
537 vector.body:                                      ; preds = %vector.body, %vector.ph
538   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
539   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
540   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
541   %ptr.a = bitcast i16* %gep.a to <8 x i16>*
542   %ptr.b = bitcast i16* %gep.b to <8 x i16>*
543   %load.a = load <8 x i16>, <8 x i16>* %ptr.a, align 2
544   %load.b = load <8 x i16>, <8 x i16>* %ptr.b, align 2
545   %cmp = icmp uge <8 x i16> %load.a, %load.b
546   %sel = select <8 x i1> %cmp, <8 x i16> %load.a, <8 x i16> %load.b
547   store <8 x i16> %sel, <8 x i16>* %ptr.a, align 2
548   %index.next = add i64 %index, 8
549   %loop = icmp eq i64 %index.next, 16384
550   br i1 %loop, label %for.end, label %vector.body
551
552 for.end:                                          ; preds = %vector.body
553   ret void
554
555 ; SSE4-LABEL: test16:
556 ; SSE4: pmaxuw
557
558 ; AVX1-LABEL: test16:
559 ; AVX1: vpmaxuw
560
561 ; AVX2-LABEL: test16:
562 ; AVX2: vpmaxuw
563
564 ; AVX512VL-LABEL: test16:
565 ; AVX512VL: vpmaxuw
566 }
567
568 define void @test17(i32* nocapture %a, i32* nocapture %b) nounwind {
569 vector.ph:
570   br label %vector.body
571
572 vector.body:                                      ; preds = %vector.body, %vector.ph
573   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
574   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
575   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
576   %ptr.a = bitcast i32* %gep.a to <4 x i32>*
577   %ptr.b = bitcast i32* %gep.b to <4 x i32>*
578   %load.a = load <4 x i32>, <4 x i32>* %ptr.a, align 2
579   %load.b = load <4 x i32>, <4 x i32>* %ptr.b, align 2
580   %cmp = icmp slt <4 x i32> %load.a, %load.b
581   %sel = select <4 x i1> %cmp, <4 x i32> %load.a, <4 x i32> %load.b
582   store <4 x i32> %sel, <4 x i32>* %ptr.a, align 2
583   %index.next = add i64 %index, 4
584   %loop = icmp eq i64 %index.next, 16384
585   br i1 %loop, label %for.end, label %vector.body
586
587 for.end:                                          ; preds = %vector.body
588   ret void
589
590 ; SSE4-LABEL: test17:
591 ; SSE4: pminsd
592
593 ; AVX1-LABEL: test17:
594 ; AVX1: vpminsd
595
596 ; AVX2-LABEL: test17:
597 ; AVX2: vpminsd
598
599 ; AVX512VL-LABEL: test17:
600 ; AVX512VL: vpminsd
601 }
602
603 define void @test18(i32* nocapture %a, i32* nocapture %b) nounwind {
604 vector.ph:
605   br label %vector.body
606
607 vector.body:                                      ; preds = %vector.body, %vector.ph
608   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
609   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
610   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
611   %ptr.a = bitcast i32* %gep.a to <4 x i32>*
612   %ptr.b = bitcast i32* %gep.b to <4 x i32>*
613   %load.a = load <4 x i32>, <4 x i32>* %ptr.a, align 2
614   %load.b = load <4 x i32>, <4 x i32>* %ptr.b, align 2
615   %cmp = icmp sle <4 x i32> %load.a, %load.b
616   %sel = select <4 x i1> %cmp, <4 x i32> %load.a, <4 x i32> %load.b
617   store <4 x i32> %sel, <4 x i32>* %ptr.a, align 2
618   %index.next = add i64 %index, 4
619   %loop = icmp eq i64 %index.next, 16384
620   br i1 %loop, label %for.end, label %vector.body
621
622 for.end:                                          ; preds = %vector.body
623   ret void
624
625 ; SSE4-LABEL: test18:
626 ; SSE4: pminsd
627
628 ; AVX1-LABEL: test18:
629 ; AVX1: vpminsd
630
631 ; AVX2-LABEL: test18:
632 ; AVX2: vpminsd
633
634 ; AVX512VL-LABEL: test18:
635 ; AVX512VL: vpminsd
636 }
637
638 define void @test19(i32* nocapture %a, i32* nocapture %b) nounwind {
639 vector.ph:
640   br label %vector.body
641
642 vector.body:                                      ; preds = %vector.body, %vector.ph
643   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
644   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
645   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
646   %ptr.a = bitcast i32* %gep.a to <4 x i32>*
647   %ptr.b = bitcast i32* %gep.b to <4 x i32>*
648   %load.a = load <4 x i32>, <4 x i32>* %ptr.a, align 2
649   %load.b = load <4 x i32>, <4 x i32>* %ptr.b, align 2
650   %cmp = icmp sgt <4 x i32> %load.a, %load.b
651   %sel = select <4 x i1> %cmp, <4 x i32> %load.a, <4 x i32> %load.b
652   store <4 x i32> %sel, <4 x i32>* %ptr.a, align 2
653   %index.next = add i64 %index, 4
654   %loop = icmp eq i64 %index.next, 16384
655   br i1 %loop, label %for.end, label %vector.body
656
657 for.end:                                          ; preds = %vector.body
658   ret void
659
660 ; SSE4-LABEL: test19:
661 ; SSE4: pmaxsd
662
663 ; AVX1-LABEL: test19:
664 ; AVX1: vpmaxsd
665
666 ; AVX2-LABEL: test19:
667 ; AVX2: vpmaxsd
668
669 ; AVX512VL-LABEL: test19:
670 ; AVX512VL: vpmaxsd
671 }
672
673 define void @test20(i32* nocapture %a, i32* nocapture %b) nounwind {
674 vector.ph:
675   br label %vector.body
676
677 vector.body:                                      ; preds = %vector.body, %vector.ph
678   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
679   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
680   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
681   %ptr.a = bitcast i32* %gep.a to <4 x i32>*
682   %ptr.b = bitcast i32* %gep.b to <4 x i32>*
683   %load.a = load <4 x i32>, <4 x i32>* %ptr.a, align 2
684   %load.b = load <4 x i32>, <4 x i32>* %ptr.b, align 2
685   %cmp = icmp sge <4 x i32> %load.a, %load.b
686   %sel = select <4 x i1> %cmp, <4 x i32> %load.a, <4 x i32> %load.b
687   store <4 x i32> %sel, <4 x i32>* %ptr.a, align 2
688   %index.next = add i64 %index, 4
689   %loop = icmp eq i64 %index.next, 16384
690   br i1 %loop, label %for.end, label %vector.body
691
692 for.end:                                          ; preds = %vector.body
693   ret void
694
695 ; SSE4-LABEL: test20:
696 ; SSE4: pmaxsd
697
698 ; AVX1-LABEL: test20:
699 ; AVX1: vpmaxsd
700
701 ; AVX2-LABEL: test20:
702 ; AVX2: vpmaxsd
703
704 ; AVX512VL-LABEL: test20:
705 ; AVX512VL: vpmaxsd
706 }
707
708 define void @test21(i32* nocapture %a, i32* nocapture %b) nounwind {
709 vector.ph:
710   br label %vector.body
711
712 vector.body:                                      ; preds = %vector.body, %vector.ph
713   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
714   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
715   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
716   %ptr.a = bitcast i32* %gep.a to <4 x i32>*
717   %ptr.b = bitcast i32* %gep.b to <4 x i32>*
718   %load.a = load <4 x i32>, <4 x i32>* %ptr.a, align 2
719   %load.b = load <4 x i32>, <4 x i32>* %ptr.b, align 2
720   %cmp = icmp ult <4 x i32> %load.a, %load.b
721   %sel = select <4 x i1> %cmp, <4 x i32> %load.a, <4 x i32> %load.b
722   store <4 x i32> %sel, <4 x i32>* %ptr.a, align 2
723   %index.next = add i64 %index, 4
724   %loop = icmp eq i64 %index.next, 16384
725   br i1 %loop, label %for.end, label %vector.body
726
727 for.end:                                          ; preds = %vector.body
728   ret void
729
730 ; SSE4-LABEL: test21:
731 ; SSE4: pminud
732
733 ; AVX1-LABEL: test21:
734 ; AVX1: vpminud
735
736 ; AVX2-LABEL: test21:
737 ; AVX2: vpminud
738
739 ; AVX512VL-LABEL: test21:
740 ; AVX512VL: vpminud
741 }
742
743 define void @test22(i32* nocapture %a, i32* nocapture %b) nounwind {
744 vector.ph:
745   br label %vector.body
746
747 vector.body:                                      ; preds = %vector.body, %vector.ph
748   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
749   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
750   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
751   %ptr.a = bitcast i32* %gep.a to <4 x i32>*
752   %ptr.b = bitcast i32* %gep.b to <4 x i32>*
753   %load.a = load <4 x i32>, <4 x i32>* %ptr.a, align 2
754   %load.b = load <4 x i32>, <4 x i32>* %ptr.b, align 2
755   %cmp = icmp ule <4 x i32> %load.a, %load.b
756   %sel = select <4 x i1> %cmp, <4 x i32> %load.a, <4 x i32> %load.b
757   store <4 x i32> %sel, <4 x i32>* %ptr.a, align 2
758   %index.next = add i64 %index, 4
759   %loop = icmp eq i64 %index.next, 16384
760   br i1 %loop, label %for.end, label %vector.body
761
762 for.end:                                          ; preds = %vector.body
763   ret void
764
765 ; SSE4-LABEL: test22:
766 ; SSE4: pminud
767
768 ; AVX1-LABEL: test22:
769 ; AVX1: vpminud
770
771 ; AVX2-LABEL: test22:
772 ; AVX2: vpminud
773
774 ; AVX512VL-LABEL: test22:
775 ; AVX512VL: vpminud
776 }
777
778 define void @test23(i32* nocapture %a, i32* nocapture %b) nounwind {
779 vector.ph:
780   br label %vector.body
781
782 vector.body:                                      ; preds = %vector.body, %vector.ph
783   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
784   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
785   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
786   %ptr.a = bitcast i32* %gep.a to <4 x i32>*
787   %ptr.b = bitcast i32* %gep.b to <4 x i32>*
788   %load.a = load <4 x i32>, <4 x i32>* %ptr.a, align 2
789   %load.b = load <4 x i32>, <4 x i32>* %ptr.b, align 2
790   %cmp = icmp ugt <4 x i32> %load.a, %load.b
791   %sel = select <4 x i1> %cmp, <4 x i32> %load.a, <4 x i32> %load.b
792   store <4 x i32> %sel, <4 x i32>* %ptr.a, align 2
793   %index.next = add i64 %index, 4
794   %loop = icmp eq i64 %index.next, 16384
795   br i1 %loop, label %for.end, label %vector.body
796
797 for.end:                                          ; preds = %vector.body
798   ret void
799
800 ; SSE4-LABEL: test23:
801 ; SSE4: pmaxud
802
803 ; AVX1-LABEL: test23:
804 ; AVX1: vpmaxud
805
806 ; AVX2-LABEL: test23:
807 ; AVX2: vpmaxud
808
809 ; AVX512VL-LABEL: test23:
810 ; AVX512VL: vpmaxud
811 }
812
813 define void @test24(i32* nocapture %a, i32* nocapture %b) nounwind {
814 vector.ph:
815   br label %vector.body
816
817 vector.body:                                      ; preds = %vector.body, %vector.ph
818   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
819   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
820   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
821   %ptr.a = bitcast i32* %gep.a to <4 x i32>*
822   %ptr.b = bitcast i32* %gep.b to <4 x i32>*
823   %load.a = load <4 x i32>, <4 x i32>* %ptr.a, align 2
824   %load.b = load <4 x i32>, <4 x i32>* %ptr.b, align 2
825   %cmp = icmp uge <4 x i32> %load.a, %load.b
826   %sel = select <4 x i1> %cmp, <4 x i32> %load.a, <4 x i32> %load.b
827   store <4 x i32> %sel, <4 x i32>* %ptr.a, align 2
828   %index.next = add i64 %index, 4
829   %loop = icmp eq i64 %index.next, 16384
830   br i1 %loop, label %for.end, label %vector.body
831
832 for.end:                                          ; preds = %vector.body
833   ret void
834
835 ; SSE4-LABEL: test24:
836 ; SSE4: pmaxud
837
838 ; AVX1-LABEL: test24:
839 ; AVX1: vpmaxud
840
841 ; AVX2-LABEL: test24:
842 ; AVX2: vpmaxud
843
844 ; AVX512VL-LABEL: test24:
845 ; AVX512VL: vpmaxud
846 }
847
848 define void @test25(i8* nocapture %a, i8* nocapture %b) nounwind {
849 vector.ph:
850   br label %vector.body
851
852 vector.body:                                      ; preds = %vector.body, %vector.ph
853   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
854   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
855   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
856   %ptr.a = bitcast i8* %gep.a to <32 x i8>*
857   %ptr.b = bitcast i8* %gep.b to <32 x i8>*
858   %load.a = load <32 x i8>, <32 x i8>* %ptr.a, align 2
859   %load.b = load <32 x i8>, <32 x i8>* %ptr.b, align 2
860   %cmp = icmp slt <32 x i8> %load.a, %load.b
861   %sel = select <32 x i1> %cmp, <32 x i8> %load.a, <32 x i8> %load.b
862   store <32 x i8> %sel, <32 x i8>* %ptr.a, align 2
863   %index.next = add i64 %index, 32
864   %loop = icmp eq i64 %index.next, 16384
865   br i1 %loop, label %for.end, label %vector.body
866
867 for.end:                                          ; preds = %vector.body
868   ret void
869
870 ; AVX2-LABEL: test25:
871 ; AVX2: vpminsb
872
873 ; AVX512VL-LABEL: test25:
874 ; AVX512VL: vpminsb
875 }
876
877 define void @test26(i8* nocapture %a, i8* nocapture %b) nounwind {
878 vector.ph:
879   br label %vector.body
880
881 vector.body:                                      ; preds = %vector.body, %vector.ph
882   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
883   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
884   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
885   %ptr.a = bitcast i8* %gep.a to <32 x i8>*
886   %ptr.b = bitcast i8* %gep.b to <32 x i8>*
887   %load.a = load <32 x i8>, <32 x i8>* %ptr.a, align 2
888   %load.b = load <32 x i8>, <32 x i8>* %ptr.b, align 2
889   %cmp = icmp sle <32 x i8> %load.a, %load.b
890   %sel = select <32 x i1> %cmp, <32 x i8> %load.a, <32 x i8> %load.b
891   store <32 x i8> %sel, <32 x i8>* %ptr.a, align 2
892   %index.next = add i64 %index, 32
893   %loop = icmp eq i64 %index.next, 16384
894   br i1 %loop, label %for.end, label %vector.body
895
896 for.end:                                          ; preds = %vector.body
897   ret void
898
899 ; AVX2-LABEL: test26:
900 ; AVX2: vpminsb
901
902 ; AVX512VL-LABEL: test26:
903 ; AVX512VL: vpminsb
904 }
905
906 define void @test27(i8* nocapture %a, i8* nocapture %b) nounwind {
907 vector.ph:
908   br label %vector.body
909
910 vector.body:                                      ; preds = %vector.body, %vector.ph
911   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
912   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
913   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
914   %ptr.a = bitcast i8* %gep.a to <32 x i8>*
915   %ptr.b = bitcast i8* %gep.b to <32 x i8>*
916   %load.a = load <32 x i8>, <32 x i8>* %ptr.a, align 2
917   %load.b = load <32 x i8>, <32 x i8>* %ptr.b, align 2
918   %cmp = icmp sgt <32 x i8> %load.a, %load.b
919   %sel = select <32 x i1> %cmp, <32 x i8> %load.a, <32 x i8> %load.b
920   store <32 x i8> %sel, <32 x i8>* %ptr.a, align 2
921   %index.next = add i64 %index, 32
922   %loop = icmp eq i64 %index.next, 16384
923   br i1 %loop, label %for.end, label %vector.body
924
925 for.end:                                          ; preds = %vector.body
926   ret void
927
928 ; AVX2-LABEL: test27:
929 ; AVX2: vpmaxsb
930
931 ; AVX512VL-LABEL: test27:
932 ; AVX512VL: vpmaxsb
933 }
934
935 define void @test28(i8* nocapture %a, i8* nocapture %b) nounwind {
936 vector.ph:
937   br label %vector.body
938
939 vector.body:                                      ; preds = %vector.body, %vector.ph
940   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
941   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
942   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
943   %ptr.a = bitcast i8* %gep.a to <32 x i8>*
944   %ptr.b = bitcast i8* %gep.b to <32 x i8>*
945   %load.a = load <32 x i8>, <32 x i8>* %ptr.a, align 2
946   %load.b = load <32 x i8>, <32 x i8>* %ptr.b, align 2
947   %cmp = icmp sge <32 x i8> %load.a, %load.b
948   %sel = select <32 x i1> %cmp, <32 x i8> %load.a, <32 x i8> %load.b
949   store <32 x i8> %sel, <32 x i8>* %ptr.a, align 2
950   %index.next = add i64 %index, 32
951   %loop = icmp eq i64 %index.next, 16384
952   br i1 %loop, label %for.end, label %vector.body
953
954 for.end:                                          ; preds = %vector.body
955   ret void
956
957 ; AVX2-LABEL: test28:
958 ; AVX2: vpmaxsb
959
960 ; AVX512VL-LABEL: test28:
961 ; AVX512VL: vpmaxsb
962 }
963
964 define void @test29(i8* nocapture %a, i8* nocapture %b) nounwind {
965 vector.ph:
966   br label %vector.body
967
968 vector.body:                                      ; preds = %vector.body, %vector.ph
969   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
970   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
971   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
972   %ptr.a = bitcast i8* %gep.a to <32 x i8>*
973   %ptr.b = bitcast i8* %gep.b to <32 x i8>*
974   %load.a = load <32 x i8>, <32 x i8>* %ptr.a, align 2
975   %load.b = load <32 x i8>, <32 x i8>* %ptr.b, align 2
976   %cmp = icmp ult <32 x i8> %load.a, %load.b
977   %sel = select <32 x i1> %cmp, <32 x i8> %load.a, <32 x i8> %load.b
978   store <32 x i8> %sel, <32 x i8>* %ptr.a, align 2
979   %index.next = add i64 %index, 32
980   %loop = icmp eq i64 %index.next, 16384
981   br i1 %loop, label %for.end, label %vector.body
982
983 for.end:                                          ; preds = %vector.body
984   ret void
985
986 ; AVX2-LABEL: test29:
987 ; AVX2: vpminub
988
989 ; AVX512VL-LABEL: test29:
990 ; AVX512VL: vpminub
991 }
992
993 define void @test30(i8* nocapture %a, i8* nocapture %b) nounwind {
994 vector.ph:
995   br label %vector.body
996
997 vector.body:                                      ; preds = %vector.body, %vector.ph
998   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
999   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
1000   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
1001   %ptr.a = bitcast i8* %gep.a to <32 x i8>*
1002   %ptr.b = bitcast i8* %gep.b to <32 x i8>*
1003   %load.a = load <32 x i8>, <32 x i8>* %ptr.a, align 2
1004   %load.b = load <32 x i8>, <32 x i8>* %ptr.b, align 2
1005   %cmp = icmp ule <32 x i8> %load.a, %load.b
1006   %sel = select <32 x i1> %cmp, <32 x i8> %load.a, <32 x i8> %load.b
1007   store <32 x i8> %sel, <32 x i8>* %ptr.a, align 2
1008   %index.next = add i64 %index, 32
1009   %loop = icmp eq i64 %index.next, 16384
1010   br i1 %loop, label %for.end, label %vector.body
1011
1012 for.end:                                          ; preds = %vector.body
1013   ret void
1014
1015 ; AVX2-LABEL: test30:
1016 ; AVX2: vpminub
1017
1018 ; AVX512VL-LABEL: test30:
1019 ; AVX512VL: vpminub
1020 }
1021
1022 define void @test31(i8* nocapture %a, i8* nocapture %b) nounwind {
1023 vector.ph:
1024   br label %vector.body
1025
1026 vector.body:                                      ; preds = %vector.body, %vector.ph
1027   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
1028   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
1029   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
1030   %ptr.a = bitcast i8* %gep.a to <32 x i8>*
1031   %ptr.b = bitcast i8* %gep.b to <32 x i8>*
1032   %load.a = load <32 x i8>, <32 x i8>* %ptr.a, align 2
1033   %load.b = load <32 x i8>, <32 x i8>* %ptr.b, align 2
1034   %cmp = icmp ugt <32 x i8> %load.a, %load.b
1035   %sel = select <32 x i1> %cmp, <32 x i8> %load.a, <32 x i8> %load.b
1036   store <32 x i8> %sel, <32 x i8>* %ptr.a, align 2
1037   %index.next = add i64 %index, 32
1038   %loop = icmp eq i64 %index.next, 16384
1039   br i1 %loop, label %for.end, label %vector.body
1040
1041 for.end:                                          ; preds = %vector.body
1042   ret void
1043
1044 ; AVX2-LABEL: test31:
1045 ; AVX2: vpmaxub
1046
1047 ; AVX512VL-LABEL: test31:
1048 ; AVX512VL: vpmaxub
1049 }
1050
1051 define void @test32(i8* nocapture %a, i8* nocapture %b) nounwind {
1052 vector.ph:
1053   br label %vector.body
1054
1055 vector.body:                                      ; preds = %vector.body, %vector.ph
1056   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
1057   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
1058   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
1059   %ptr.a = bitcast i8* %gep.a to <32 x i8>*
1060   %ptr.b = bitcast i8* %gep.b to <32 x i8>*
1061   %load.a = load <32 x i8>, <32 x i8>* %ptr.a, align 2
1062   %load.b = load <32 x i8>, <32 x i8>* %ptr.b, align 2
1063   %cmp = icmp uge <32 x i8> %load.a, %load.b
1064   %sel = select <32 x i1> %cmp, <32 x i8> %load.a, <32 x i8> %load.b
1065   store <32 x i8> %sel, <32 x i8>* %ptr.a, align 2
1066   %index.next = add i64 %index, 32
1067   %loop = icmp eq i64 %index.next, 16384
1068   br i1 %loop, label %for.end, label %vector.body
1069
1070 for.end:                                          ; preds = %vector.body
1071   ret void
1072
1073 ; AVX2-LABEL: test32:
1074 ; AVX2: vpmaxub
1075
1076 ; AVX512VL-LABEL: test32:
1077 ; AVX512VL: vpmaxub
1078 }
1079
1080 define void @test33(i16* nocapture %a, i16* nocapture %b) nounwind {
1081 vector.ph:
1082   br label %vector.body
1083
1084 vector.body:                                      ; preds = %vector.body, %vector.ph
1085   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
1086   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
1087   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
1088   %ptr.a = bitcast i16* %gep.a to <16 x i16>*
1089   %ptr.b = bitcast i16* %gep.b to <16 x i16>*
1090   %load.a = load <16 x i16>, <16 x i16>* %ptr.a, align 2
1091   %load.b = load <16 x i16>, <16 x i16>* %ptr.b, align 2
1092   %cmp = icmp slt <16 x i16> %load.a, %load.b
1093   %sel = select <16 x i1> %cmp, <16 x i16> %load.a, <16 x i16> %load.b
1094   store <16 x i16> %sel, <16 x i16>* %ptr.a, align 2
1095   %index.next = add i64 %index, 16
1096   %loop = icmp eq i64 %index.next, 16384
1097   br i1 %loop, label %for.end, label %vector.body
1098
1099 for.end:                                          ; preds = %vector.body
1100   ret void
1101
1102 ; AVX2-LABEL: test33:
1103 ; AVX2: vpminsw
1104
1105 ; AVX512VL-LABEL: test33:
1106 ; AVX512VL: vpminsw 
1107 }
1108
1109 define void @test34(i16* nocapture %a, i16* nocapture %b) nounwind {
1110 vector.ph:
1111   br label %vector.body
1112
1113 vector.body:                                      ; preds = %vector.body, %vector.ph
1114   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
1115   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
1116   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
1117   %ptr.a = bitcast i16* %gep.a to <16 x i16>*
1118   %ptr.b = bitcast i16* %gep.b to <16 x i16>*
1119   %load.a = load <16 x i16>, <16 x i16>* %ptr.a, align 2
1120   %load.b = load <16 x i16>, <16 x i16>* %ptr.b, align 2
1121   %cmp = icmp sle <16 x i16> %load.a, %load.b
1122   %sel = select <16 x i1> %cmp, <16 x i16> %load.a, <16 x i16> %load.b
1123   store <16 x i16> %sel, <16 x i16>* %ptr.a, align 2
1124   %index.next = add i64 %index, 16
1125   %loop = icmp eq i64 %index.next, 16384
1126   br i1 %loop, label %for.end, label %vector.body
1127
1128 for.end:                                          ; preds = %vector.body
1129   ret void
1130
1131 ; AVX2-LABEL: test34:
1132 ; AVX2: vpminsw
1133
1134 ; AVX512VL-LABEL: test34:
1135 ; AVX512VL: vpminsw
1136 }
1137
1138 define void @test35(i16* nocapture %a, i16* nocapture %b) nounwind {
1139 vector.ph:
1140   br label %vector.body
1141
1142 vector.body:                                      ; preds = %vector.body, %vector.ph
1143   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
1144   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
1145   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
1146   %ptr.a = bitcast i16* %gep.a to <16 x i16>*
1147   %ptr.b = bitcast i16* %gep.b to <16 x i16>*
1148   %load.a = load <16 x i16>, <16 x i16>* %ptr.a, align 2
1149   %load.b = load <16 x i16>, <16 x i16>* %ptr.b, align 2
1150   %cmp = icmp sgt <16 x i16> %load.a, %load.b
1151   %sel = select <16 x i1> %cmp, <16 x i16> %load.a, <16 x i16> %load.b
1152   store <16 x i16> %sel, <16 x i16>* %ptr.a, align 2
1153   %index.next = add i64 %index, 16
1154   %loop = icmp eq i64 %index.next, 16384
1155   br i1 %loop, label %for.end, label %vector.body
1156
1157 for.end:                                          ; preds = %vector.body
1158   ret void
1159
1160 ; AVX2-LABEL: test35:
1161 ; AVX2: vpmaxsw
1162
1163 ; AVX512VL-LABEL: test35:
1164 ; AVX512VL: vpmaxsw
1165 }
1166
1167 define void @test36(i16* nocapture %a, i16* nocapture %b) nounwind {
1168 vector.ph:
1169   br label %vector.body
1170
1171 vector.body:                                      ; preds = %vector.body, %vector.ph
1172   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
1173   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
1174   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
1175   %ptr.a = bitcast i16* %gep.a to <16 x i16>*
1176   %ptr.b = bitcast i16* %gep.b to <16 x i16>*
1177   %load.a = load <16 x i16>, <16 x i16>* %ptr.a, align 2
1178   %load.b = load <16 x i16>, <16 x i16>* %ptr.b, align 2
1179   %cmp = icmp sge <16 x i16> %load.a, %load.b
1180   %sel = select <16 x i1> %cmp, <16 x i16> %load.a, <16 x i16> %load.b
1181   store <16 x i16> %sel, <16 x i16>* %ptr.a, align 2
1182   %index.next = add i64 %index, 16
1183   %loop = icmp eq i64 %index.next, 16384
1184   br i1 %loop, label %for.end, label %vector.body
1185
1186 for.end:                                          ; preds = %vector.body
1187   ret void
1188
1189 ; AVX2-LABEL: test36:
1190 ; AVX2: vpmaxsw
1191
1192 ; AVX512VL-LABEL: test36:
1193 ; AVX512VL: vpmaxsw
1194 }
1195
1196 define void @test37(i16* nocapture %a, i16* nocapture %b) nounwind {
1197 vector.ph:
1198   br label %vector.body
1199
1200 vector.body:                                      ; preds = %vector.body, %vector.ph
1201   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
1202   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
1203   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
1204   %ptr.a = bitcast i16* %gep.a to <16 x i16>*
1205   %ptr.b = bitcast i16* %gep.b to <16 x i16>*
1206   %load.a = load <16 x i16>, <16 x i16>* %ptr.a, align 2
1207   %load.b = load <16 x i16>, <16 x i16>* %ptr.b, align 2
1208   %cmp = icmp ult <16 x i16> %load.a, %load.b
1209   %sel = select <16 x i1> %cmp, <16 x i16> %load.a, <16 x i16> %load.b
1210   store <16 x i16> %sel, <16 x i16>* %ptr.a, align 2
1211   %index.next = add i64 %index, 16
1212   %loop = icmp eq i64 %index.next, 16384
1213   br i1 %loop, label %for.end, label %vector.body
1214
1215 for.end:                                          ; preds = %vector.body
1216   ret void
1217
1218 ; AVX2-LABEL: test37:
1219 ; AVX2: vpminuw
1220
1221 ; AVX512VL-LABEL: test37:
1222 ; AVX512VL: vpminuw
1223 }
1224
1225 define void @test38(i16* nocapture %a, i16* nocapture %b) nounwind {
1226 vector.ph:
1227   br label %vector.body
1228
1229 vector.body:                                      ; preds = %vector.body, %vector.ph
1230   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
1231   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
1232   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
1233   %ptr.a = bitcast i16* %gep.a to <16 x i16>*
1234   %ptr.b = bitcast i16* %gep.b to <16 x i16>*
1235   %load.a = load <16 x i16>, <16 x i16>* %ptr.a, align 2
1236   %load.b = load <16 x i16>, <16 x i16>* %ptr.b, align 2
1237   %cmp = icmp ule <16 x i16> %load.a, %load.b
1238   %sel = select <16 x i1> %cmp, <16 x i16> %load.a, <16 x i16> %load.b
1239   store <16 x i16> %sel, <16 x i16>* %ptr.a, align 2
1240   %index.next = add i64 %index, 16
1241   %loop = icmp eq i64 %index.next, 16384
1242   br i1 %loop, label %for.end, label %vector.body
1243
1244 for.end:                                          ; preds = %vector.body
1245   ret void
1246
1247 ; AVX2-LABEL: test38:
1248 ; AVX2: vpminuw
1249
1250 ; AVX512VL-LABEL: test38:
1251 ; AVX512VL: vpminuw
1252 }
1253
1254 define void @test39(i16* nocapture %a, i16* nocapture %b) nounwind {
1255 vector.ph:
1256   br label %vector.body
1257
1258 vector.body:                                      ; preds = %vector.body, %vector.ph
1259   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
1260   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
1261   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
1262   %ptr.a = bitcast i16* %gep.a to <16 x i16>*
1263   %ptr.b = bitcast i16* %gep.b to <16 x i16>*
1264   %load.a = load <16 x i16>, <16 x i16>* %ptr.a, align 2
1265   %load.b = load <16 x i16>, <16 x i16>* %ptr.b, align 2
1266   %cmp = icmp ugt <16 x i16> %load.a, %load.b
1267   %sel = select <16 x i1> %cmp, <16 x i16> %load.a, <16 x i16> %load.b
1268   store <16 x i16> %sel, <16 x i16>* %ptr.a, align 2
1269   %index.next = add i64 %index, 16
1270   %loop = icmp eq i64 %index.next, 16384
1271   br i1 %loop, label %for.end, label %vector.body
1272
1273 for.end:                                          ; preds = %vector.body
1274   ret void
1275
1276 ; AVX2-LABEL: test39:
1277 ; AVX2: vpmaxuw
1278
1279 ; AVX512VL-LABEL: test39:
1280 ; AVX512VL: vpmaxuw
1281 }
1282
1283 define void @test40(i16* nocapture %a, i16* nocapture %b) nounwind {
1284 vector.ph:
1285   br label %vector.body
1286
1287 vector.body:                                      ; preds = %vector.body, %vector.ph
1288   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
1289   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
1290   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
1291   %ptr.a = bitcast i16* %gep.a to <16 x i16>*
1292   %ptr.b = bitcast i16* %gep.b to <16 x i16>*
1293   %load.a = load <16 x i16>, <16 x i16>* %ptr.a, align 2
1294   %load.b = load <16 x i16>, <16 x i16>* %ptr.b, align 2
1295   %cmp = icmp uge <16 x i16> %load.a, %load.b
1296   %sel = select <16 x i1> %cmp, <16 x i16> %load.a, <16 x i16> %load.b
1297   store <16 x i16> %sel, <16 x i16>* %ptr.a, align 2
1298   %index.next = add i64 %index, 16
1299   %loop = icmp eq i64 %index.next, 16384
1300   br i1 %loop, label %for.end, label %vector.body
1301
1302 for.end:                                          ; preds = %vector.body
1303   ret void
1304
1305 ; AVX2-LABEL: test40:
1306 ; AVX2: vpmaxuw
1307
1308 ; AVX512VL-LABEL: test40:
1309 ; AVX512VL: vpmaxuw
1310 }
1311
1312 define void @test41(i32* nocapture %a, i32* nocapture %b) nounwind {
1313 vector.ph:
1314   br label %vector.body
1315
1316 vector.body:                                      ; preds = %vector.body, %vector.ph
1317   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
1318   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
1319   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
1320   %ptr.a = bitcast i32* %gep.a to <8 x i32>*
1321   %ptr.b = bitcast i32* %gep.b to <8 x i32>*
1322   %load.a = load <8 x i32>, <8 x i32>* %ptr.a, align 2
1323   %load.b = load <8 x i32>, <8 x i32>* %ptr.b, align 2
1324   %cmp = icmp slt <8 x i32> %load.a, %load.b
1325   %sel = select <8 x i1> %cmp, <8 x i32> %load.a, <8 x i32> %load.b
1326   store <8 x i32> %sel, <8 x i32>* %ptr.a, align 2
1327   %index.next = add i64 %index, 8
1328   %loop = icmp eq i64 %index.next, 16384
1329   br i1 %loop, label %for.end, label %vector.body
1330
1331 for.end:                                          ; preds = %vector.body
1332   ret void
1333
1334 ; AVX2-LABEL: test41:
1335 ; AVX2: vpminsd
1336
1337 ; AVX512VL-LABEL: test41:
1338 ; AVX512VL: vpminsd
1339 }
1340
1341 define void @test42(i32* nocapture %a, i32* nocapture %b) nounwind {
1342 vector.ph:
1343   br label %vector.body
1344
1345 vector.body:                                      ; preds = %vector.body, %vector.ph
1346   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
1347   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
1348   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
1349   %ptr.a = bitcast i32* %gep.a to <8 x i32>*
1350   %ptr.b = bitcast i32* %gep.b to <8 x i32>*
1351   %load.a = load <8 x i32>, <8 x i32>* %ptr.a, align 2
1352   %load.b = load <8 x i32>, <8 x i32>* %ptr.b, align 2
1353   %cmp = icmp sle <8 x i32> %load.a, %load.b
1354   %sel = select <8 x i1> %cmp, <8 x i32> %load.a, <8 x i32> %load.b
1355   store <8 x i32> %sel, <8 x i32>* %ptr.a, align 2
1356   %index.next = add i64 %index, 8
1357   %loop = icmp eq i64 %index.next, 16384
1358   br i1 %loop, label %for.end, label %vector.body
1359
1360 for.end:                                          ; preds = %vector.body
1361   ret void
1362
1363 ; AVX2-LABEL: test42:
1364 ; AVX2: vpminsd
1365
1366 ; AVX512VL-LABEL: test42:
1367 ; AVX512VL: vpminsd
1368 }
1369
1370 define void @test43(i32* nocapture %a, i32* nocapture %b) nounwind {
1371 vector.ph:
1372   br label %vector.body
1373
1374 vector.body:                                      ; preds = %vector.body, %vector.ph
1375   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
1376   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
1377   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
1378   %ptr.a = bitcast i32* %gep.a to <8 x i32>*
1379   %ptr.b = bitcast i32* %gep.b to <8 x i32>*
1380   %load.a = load <8 x i32>, <8 x i32>* %ptr.a, align 2
1381   %load.b = load <8 x i32>, <8 x i32>* %ptr.b, align 2
1382   %cmp = icmp sgt <8 x i32> %load.a, %load.b
1383   %sel = select <8 x i1> %cmp, <8 x i32> %load.a, <8 x i32> %load.b
1384   store <8 x i32> %sel, <8 x i32>* %ptr.a, align 2
1385   %index.next = add i64 %index, 8
1386   %loop = icmp eq i64 %index.next, 16384
1387   br i1 %loop, label %for.end, label %vector.body
1388
1389 for.end:                                          ; preds = %vector.body
1390   ret void
1391
1392 ; AVX2-LABEL: test43:
1393 ; AVX2: vpmaxsd
1394
1395 ; AVX512VL-LABEL: test43:
1396 ; AVX512VL: vpmaxsd
1397 }
1398
1399 define void @test44(i32* nocapture %a, i32* nocapture %b) nounwind {
1400 vector.ph:
1401   br label %vector.body
1402
1403 vector.body:                                      ; preds = %vector.body, %vector.ph
1404   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
1405   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
1406   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
1407   %ptr.a = bitcast i32* %gep.a to <8 x i32>*
1408   %ptr.b = bitcast i32* %gep.b to <8 x i32>*
1409   %load.a = load <8 x i32>, <8 x i32>* %ptr.a, align 2
1410   %load.b = load <8 x i32>, <8 x i32>* %ptr.b, align 2
1411   %cmp = icmp sge <8 x i32> %load.a, %load.b
1412   %sel = select <8 x i1> %cmp, <8 x i32> %load.a, <8 x i32> %load.b
1413   store <8 x i32> %sel, <8 x i32>* %ptr.a, align 2
1414   %index.next = add i64 %index, 8
1415   %loop = icmp eq i64 %index.next, 16384
1416   br i1 %loop, label %for.end, label %vector.body
1417
1418 for.end:                                          ; preds = %vector.body
1419   ret void
1420
1421 ; AVX2-LABEL: test44:
1422 ; AVX2: vpmaxsd
1423
1424 ; AVX512VL-LABEL: test44:
1425 ; AVX512VL: vpmaxsd
1426 }
1427
1428 define void @test45(i32* nocapture %a, i32* nocapture %b) nounwind {
1429 vector.ph:
1430   br label %vector.body
1431
1432 vector.body:                                      ; preds = %vector.body, %vector.ph
1433   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
1434   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
1435   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
1436   %ptr.a = bitcast i32* %gep.a to <8 x i32>*
1437   %ptr.b = bitcast i32* %gep.b to <8 x i32>*
1438   %load.a = load <8 x i32>, <8 x i32>* %ptr.a, align 2
1439   %load.b = load <8 x i32>, <8 x i32>* %ptr.b, align 2
1440   %cmp = icmp ult <8 x i32> %load.a, %load.b
1441   %sel = select <8 x i1> %cmp, <8 x i32> %load.a, <8 x i32> %load.b
1442   store <8 x i32> %sel, <8 x i32>* %ptr.a, align 2
1443   %index.next = add i64 %index, 8
1444   %loop = icmp eq i64 %index.next, 16384
1445   br i1 %loop, label %for.end, label %vector.body
1446
1447 for.end:                                          ; preds = %vector.body
1448   ret void
1449
1450 ; AVX2-LABEL: test45:
1451 ; AVX2: vpminud
1452
1453 ; AVX512VL-LABEL: test45:
1454 ; AVX512VL: vpminud
1455 }
1456
1457 define void @test46(i32* nocapture %a, i32* nocapture %b) nounwind {
1458 vector.ph:
1459   br label %vector.body
1460
1461 vector.body:                                      ; preds = %vector.body, %vector.ph
1462   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
1463   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
1464   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
1465   %ptr.a = bitcast i32* %gep.a to <8 x i32>*
1466   %ptr.b = bitcast i32* %gep.b to <8 x i32>*
1467   %load.a = load <8 x i32>, <8 x i32>* %ptr.a, align 2
1468   %load.b = load <8 x i32>, <8 x i32>* %ptr.b, align 2
1469   %cmp = icmp ule <8 x i32> %load.a, %load.b
1470   %sel = select <8 x i1> %cmp, <8 x i32> %load.a, <8 x i32> %load.b
1471   store <8 x i32> %sel, <8 x i32>* %ptr.a, align 2
1472   %index.next = add i64 %index, 8
1473   %loop = icmp eq i64 %index.next, 16384
1474   br i1 %loop, label %for.end, label %vector.body
1475
1476 for.end:                                          ; preds = %vector.body
1477   ret void
1478
1479 ; AVX2-LABEL: test46:
1480 ; AVX2: vpminud
1481
1482 ; AVX512VL-LABEL: test46:
1483 ; AVX512VL: vpminud
1484 }
1485
1486 define void @test47(i32* nocapture %a, i32* nocapture %b) nounwind {
1487 vector.ph:
1488   br label %vector.body
1489
1490 vector.body:                                      ; preds = %vector.body, %vector.ph
1491   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
1492   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
1493   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
1494   %ptr.a = bitcast i32* %gep.a to <8 x i32>*
1495   %ptr.b = bitcast i32* %gep.b to <8 x i32>*
1496   %load.a = load <8 x i32>, <8 x i32>* %ptr.a, align 2
1497   %load.b = load <8 x i32>, <8 x i32>* %ptr.b, align 2
1498   %cmp = icmp ugt <8 x i32> %load.a, %load.b
1499   %sel = select <8 x i1> %cmp, <8 x i32> %load.a, <8 x i32> %load.b
1500   store <8 x i32> %sel, <8 x i32>* %ptr.a, align 2
1501   %index.next = add i64 %index, 8
1502   %loop = icmp eq i64 %index.next, 16384
1503   br i1 %loop, label %for.end, label %vector.body
1504
1505 for.end:                                          ; preds = %vector.body
1506   ret void
1507
1508 ; AVX2-LABEL: test47:
1509 ; AVX2: vpmaxud
1510
1511 ; AVX512VL-LABEL: test47:
1512 ; AVX512VL: vpmaxud
1513 }
1514
1515 define void @test48(i32* nocapture %a, i32* nocapture %b) nounwind {
1516 vector.ph:
1517   br label %vector.body
1518
1519 vector.body:                                      ; preds = %vector.body, %vector.ph
1520   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
1521   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
1522   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
1523   %ptr.a = bitcast i32* %gep.a to <8 x i32>*
1524   %ptr.b = bitcast i32* %gep.b to <8 x i32>*
1525   %load.a = load <8 x i32>, <8 x i32>* %ptr.a, align 2
1526   %load.b = load <8 x i32>, <8 x i32>* %ptr.b, align 2
1527   %cmp = icmp uge <8 x i32> %load.a, %load.b
1528   %sel = select <8 x i1> %cmp, <8 x i32> %load.a, <8 x i32> %load.b
1529   store <8 x i32> %sel, <8 x i32>* %ptr.a, align 2
1530   %index.next = add i64 %index, 8
1531   %loop = icmp eq i64 %index.next, 16384
1532   br i1 %loop, label %for.end, label %vector.body
1533
1534 for.end:                                          ; preds = %vector.body
1535   ret void
1536
1537 ; AVX2-LABEL: test48:
1538 ; AVX2: vpmaxud
1539
1540 ; AVX512VL-LABEL: test48:
1541 ; AVX512VL: vpmaxud
1542 }
1543
1544 define void @test49(i8* nocapture %a, i8* nocapture %b) nounwind {
1545 vector.ph:
1546   br label %vector.body
1547
1548 vector.body:                                      ; preds = %vector.body, %vector.ph
1549   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
1550   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
1551   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
1552   %ptr.a = bitcast i8* %gep.a to <16 x i8>*
1553   %ptr.b = bitcast i8* %gep.b to <16 x i8>*
1554   %load.a = load <16 x i8>, <16 x i8>* %ptr.a, align 2
1555   %load.b = load <16 x i8>, <16 x i8>* %ptr.b, align 2
1556   %cmp = icmp slt <16 x i8> %load.a, %load.b
1557   %sel = select <16 x i1> %cmp, <16 x i8> %load.b, <16 x i8> %load.a
1558   store <16 x i8> %sel, <16 x i8>* %ptr.a, align 2
1559   %index.next = add i64 %index, 16
1560   %loop = icmp eq i64 %index.next, 16384
1561   br i1 %loop, label %for.end, label %vector.body
1562
1563 for.end:                                          ; preds = %vector.body
1564   ret void
1565
1566 ; SSE4-LABEL: test49:
1567 ; SSE4: pmaxsb
1568
1569 ; AVX1-LABEL: test49:
1570 ; AVX1: vpmaxsb
1571
1572 ; AVX2-LABEL: test49:
1573 ; AVX2: vpmaxsb
1574
1575 ; AVX512VL-LABEL: test49:
1576 ; AVX512VL: vpmaxsb
1577 }
1578
1579 define void @test50(i8* nocapture %a, i8* nocapture %b) nounwind {
1580 vector.ph:
1581   br label %vector.body
1582
1583 vector.body:                                      ; preds = %vector.body, %vector.ph
1584   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
1585   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
1586   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
1587   %ptr.a = bitcast i8* %gep.a to <16 x i8>*
1588   %ptr.b = bitcast i8* %gep.b to <16 x i8>*
1589   %load.a = load <16 x i8>, <16 x i8>* %ptr.a, align 2
1590   %load.b = load <16 x i8>, <16 x i8>* %ptr.b, align 2
1591   %cmp = icmp sle <16 x i8> %load.a, %load.b
1592   %sel = select <16 x i1> %cmp, <16 x i8> %load.b, <16 x i8> %load.a
1593   store <16 x i8> %sel, <16 x i8>* %ptr.a, align 2
1594   %index.next = add i64 %index, 16
1595   %loop = icmp eq i64 %index.next, 16384
1596   br i1 %loop, label %for.end, label %vector.body
1597
1598 for.end:                                          ; preds = %vector.body
1599   ret void
1600
1601 ; SSE4-LABEL: test50:
1602 ; SSE4: pmaxsb
1603
1604 ; AVX1-LABEL: test50:
1605 ; AVX1: vpmaxsb
1606
1607 ; AVX2-LABEL: test50:
1608 ; AVX2: vpmaxsb
1609
1610 ; AVX512VL-LABEL: test50:
1611 ; AVX512VL: vpmaxsb
1612 }
1613
1614 define void @test51(i8* nocapture %a, i8* nocapture %b) nounwind {
1615 vector.ph:
1616   br label %vector.body
1617
1618 vector.body:                                      ; preds = %vector.body, %vector.ph
1619   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
1620   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
1621   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
1622   %ptr.a = bitcast i8* %gep.a to <16 x i8>*
1623   %ptr.b = bitcast i8* %gep.b to <16 x i8>*
1624   %load.a = load <16 x i8>, <16 x i8>* %ptr.a, align 2
1625   %load.b = load <16 x i8>, <16 x i8>* %ptr.b, align 2
1626   %cmp = icmp sgt <16 x i8> %load.a, %load.b
1627   %sel = select <16 x i1> %cmp, <16 x i8> %load.b, <16 x i8> %load.a
1628   store <16 x i8> %sel, <16 x i8>* %ptr.a, align 2
1629   %index.next = add i64 %index, 16
1630   %loop = icmp eq i64 %index.next, 16384
1631   br i1 %loop, label %for.end, label %vector.body
1632
1633 for.end:                                          ; preds = %vector.body
1634   ret void
1635
1636 ; SSE4-LABEL: test51:
1637 ; SSE4: pminsb
1638
1639 ; AVX1-LABEL: test51:
1640 ; AVX1: vpminsb
1641
1642 ; AVX2-LABEL: test51:
1643 ; AVX2: vpminsb
1644
1645 ; AVX512VL-LABEL: test51:
1646 ; AVX512VL: vpminsb
1647 }
1648
1649 define void @test52(i8* nocapture %a, i8* nocapture %b) nounwind {
1650 vector.ph:
1651   br label %vector.body
1652
1653 vector.body:                                      ; preds = %vector.body, %vector.ph
1654   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
1655   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
1656   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
1657   %ptr.a = bitcast i8* %gep.a to <16 x i8>*
1658   %ptr.b = bitcast i8* %gep.b to <16 x i8>*
1659   %load.a = load <16 x i8>, <16 x i8>* %ptr.a, align 2
1660   %load.b = load <16 x i8>, <16 x i8>* %ptr.b, align 2
1661   %cmp = icmp sge <16 x i8> %load.a, %load.b
1662   %sel = select <16 x i1> %cmp, <16 x i8> %load.b, <16 x i8> %load.a
1663   store <16 x i8> %sel, <16 x i8>* %ptr.a, align 2
1664   %index.next = add i64 %index, 16
1665   %loop = icmp eq i64 %index.next, 16384
1666   br i1 %loop, label %for.end, label %vector.body
1667
1668 for.end:                                          ; preds = %vector.body
1669   ret void
1670
1671 ; SSE4-LABEL: test52:
1672 ; SSE4: pminsb
1673
1674 ; AVX1-LABEL: test52:
1675 ; AVX1: vpminsb
1676
1677 ; AVX2-LABEL: test52:
1678 ; AVX2: vpminsb
1679
1680 ; AVX512VL-LABEL: test52:
1681 ; AVX512VL: vpminsb
1682 }
1683
1684 define void @test53(i8* nocapture %a, i8* nocapture %b) nounwind {
1685 vector.ph:
1686   br label %vector.body
1687
1688 vector.body:                                      ; preds = %vector.body, %vector.ph
1689   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
1690   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
1691   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
1692   %ptr.a = bitcast i8* %gep.a to <16 x i8>*
1693   %ptr.b = bitcast i8* %gep.b to <16 x i8>*
1694   %load.a = load <16 x i8>, <16 x i8>* %ptr.a, align 2
1695   %load.b = load <16 x i8>, <16 x i8>* %ptr.b, align 2
1696   %cmp = icmp ult <16 x i8> %load.a, %load.b
1697   %sel = select <16 x i1> %cmp, <16 x i8> %load.b, <16 x i8> %load.a
1698   store <16 x i8> %sel, <16 x i8>* %ptr.a, align 2
1699   %index.next = add i64 %index, 16
1700   %loop = icmp eq i64 %index.next, 16384
1701   br i1 %loop, label %for.end, label %vector.body
1702
1703 for.end:                                          ; preds = %vector.body
1704   ret void
1705
1706 ; SSE2-LABEL: test53:
1707 ; SSE2: pmaxub
1708
1709 ; AVX1-LABEL: test53:
1710 ; AVX1: vpmaxub
1711
1712 ; AVX2-LABEL: test53:
1713 ; AVX2: vpmaxub
1714
1715 ; AVX512VL-LABEL: test53:
1716 ; AVX512VL: vpmaxub
1717 }
1718
1719 define void @test54(i8* nocapture %a, i8* nocapture %b) nounwind {
1720 vector.ph:
1721   br label %vector.body
1722
1723 vector.body:                                      ; preds = %vector.body, %vector.ph
1724   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
1725   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
1726   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
1727   %ptr.a = bitcast i8* %gep.a to <16 x i8>*
1728   %ptr.b = bitcast i8* %gep.b to <16 x i8>*
1729   %load.a = load <16 x i8>, <16 x i8>* %ptr.a, align 2
1730   %load.b = load <16 x i8>, <16 x i8>* %ptr.b, align 2
1731   %cmp = icmp ule <16 x i8> %load.a, %load.b
1732   %sel = select <16 x i1> %cmp, <16 x i8> %load.b, <16 x i8> %load.a
1733   store <16 x i8> %sel, <16 x i8>* %ptr.a, align 2
1734   %index.next = add i64 %index, 16
1735   %loop = icmp eq i64 %index.next, 16384
1736   br i1 %loop, label %for.end, label %vector.body
1737
1738 for.end:                                          ; preds = %vector.body
1739   ret void
1740
1741 ; SSE2-LABEL: test54:
1742 ; SSE2: pmaxub
1743
1744 ; AVX1-LABEL: test54:
1745 ; AVX1: vpmaxub
1746
1747 ; AVX2-LABEL: test54:
1748 ; AVX2: vpmaxub
1749
1750 ; AVX512VL-LABEL: test54:
1751 ; AVX512VL: vpmaxub
1752 }
1753
1754 define void @test55(i8* nocapture %a, i8* nocapture %b) nounwind {
1755 vector.ph:
1756   br label %vector.body
1757
1758 vector.body:                                      ; preds = %vector.body, %vector.ph
1759   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
1760   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
1761   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
1762   %ptr.a = bitcast i8* %gep.a to <16 x i8>*
1763   %ptr.b = bitcast i8* %gep.b to <16 x i8>*
1764   %load.a = load <16 x i8>, <16 x i8>* %ptr.a, align 2
1765   %load.b = load <16 x i8>, <16 x i8>* %ptr.b, align 2
1766   %cmp = icmp ugt <16 x i8> %load.a, %load.b
1767   %sel = select <16 x i1> %cmp, <16 x i8> %load.b, <16 x i8> %load.a
1768   store <16 x i8> %sel, <16 x i8>* %ptr.a, align 2
1769   %index.next = add i64 %index, 16
1770   %loop = icmp eq i64 %index.next, 16384
1771   br i1 %loop, label %for.end, label %vector.body
1772
1773 for.end:                                          ; preds = %vector.body
1774   ret void
1775
1776 ; SSE2-LABEL: test55:
1777 ; SSE2: pminub
1778
1779 ; AVX1-LABEL: test55:
1780 ; AVX1: vpminub
1781
1782 ; AVX2-LABEL: test55:
1783 ; AVX2: vpminub
1784
1785 ; AVX512VL-LABEL: test55:
1786 ; AVX512VL: vpminub
1787 }
1788
1789 define void @test56(i8* nocapture %a, i8* nocapture %b) nounwind {
1790 vector.ph:
1791   br label %vector.body
1792
1793 vector.body:                                      ; preds = %vector.body, %vector.ph
1794   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
1795   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
1796   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
1797   %ptr.a = bitcast i8* %gep.a to <16 x i8>*
1798   %ptr.b = bitcast i8* %gep.b to <16 x i8>*
1799   %load.a = load <16 x i8>, <16 x i8>* %ptr.a, align 2
1800   %load.b = load <16 x i8>, <16 x i8>* %ptr.b, align 2
1801   %cmp = icmp uge <16 x i8> %load.a, %load.b
1802   %sel = select <16 x i1> %cmp, <16 x i8> %load.b, <16 x i8> %load.a
1803   store <16 x i8> %sel, <16 x i8>* %ptr.a, align 2
1804   %index.next = add i64 %index, 16
1805   %loop = icmp eq i64 %index.next, 16384
1806   br i1 %loop, label %for.end, label %vector.body
1807
1808 for.end:                                          ; preds = %vector.body
1809   ret void
1810
1811 ; SSE2-LABEL: test56:
1812 ; SSE2: pminub
1813
1814 ; AVX1-LABEL: test56:
1815 ; AVX1: vpminub
1816
1817 ; AVX2-LABEL: test56:
1818 ; AVX2: vpminub
1819
1820 ; AVX512VL-LABEL: test56:
1821 ; AVX512VL: vpminub
1822 }
1823
1824 define void @test57(i16* nocapture %a, i16* nocapture %b) nounwind {
1825 vector.ph:
1826   br label %vector.body
1827
1828 vector.body:                                      ; preds = %vector.body, %vector.ph
1829   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
1830   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
1831   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
1832   %ptr.a = bitcast i16* %gep.a to <8 x i16>*
1833   %ptr.b = bitcast i16* %gep.b to <8 x i16>*
1834   %load.a = load <8 x i16>, <8 x i16>* %ptr.a, align 2
1835   %load.b = load <8 x i16>, <8 x i16>* %ptr.b, align 2
1836   %cmp = icmp slt <8 x i16> %load.a, %load.b
1837   %sel = select <8 x i1> %cmp, <8 x i16> %load.b, <8 x i16> %load.a
1838   store <8 x i16> %sel, <8 x i16>* %ptr.a, align 2
1839   %index.next = add i64 %index, 8
1840   %loop = icmp eq i64 %index.next, 16384
1841   br i1 %loop, label %for.end, label %vector.body
1842
1843 for.end:                                          ; preds = %vector.body
1844   ret void
1845
1846 ; SSE2-LABEL: test57:
1847 ; SSE2: pmaxsw
1848
1849 ; AVX1-LABEL: test57:
1850 ; AVX1: vpmaxsw
1851
1852 ; AVX2-LABEL: test57:
1853 ; AVX2: vpmaxsw
1854
1855 ; AVX512VL-LABEL: test57:
1856 ; AVX512VL: vpmaxsw
1857 }
1858
1859 define void @test58(i16* nocapture %a, i16* nocapture %b) nounwind {
1860 vector.ph:
1861   br label %vector.body
1862
1863 vector.body:                                      ; preds = %vector.body, %vector.ph
1864   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
1865   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
1866   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
1867   %ptr.a = bitcast i16* %gep.a to <8 x i16>*
1868   %ptr.b = bitcast i16* %gep.b to <8 x i16>*
1869   %load.a = load <8 x i16>, <8 x i16>* %ptr.a, align 2
1870   %load.b = load <8 x i16>, <8 x i16>* %ptr.b, align 2
1871   %cmp = icmp sle <8 x i16> %load.a, %load.b
1872   %sel = select <8 x i1> %cmp, <8 x i16> %load.b, <8 x i16> %load.a
1873   store <8 x i16> %sel, <8 x i16>* %ptr.a, align 2
1874   %index.next = add i64 %index, 8
1875   %loop = icmp eq i64 %index.next, 16384
1876   br i1 %loop, label %for.end, label %vector.body
1877
1878 for.end:                                          ; preds = %vector.body
1879   ret void
1880
1881 ; SSE2-LABEL: test58:
1882 ; SSE2: pmaxsw
1883
1884 ; AVX1-LABEL: test58:
1885 ; AVX1: vpmaxsw
1886
1887 ; AVX2-LABEL: test58:
1888 ; AVX2: vpmaxsw
1889
1890 ; AVX512VL-LABEL: test58:
1891 ; AVX512VL: vpmaxsw
1892 }
1893
1894 define void @test59(i16* nocapture %a, i16* nocapture %b) nounwind {
1895 vector.ph:
1896   br label %vector.body
1897
1898 vector.body:                                      ; preds = %vector.body, %vector.ph
1899   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
1900   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
1901   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
1902   %ptr.a = bitcast i16* %gep.a to <8 x i16>*
1903   %ptr.b = bitcast i16* %gep.b to <8 x i16>*
1904   %load.a = load <8 x i16>, <8 x i16>* %ptr.a, align 2
1905   %load.b = load <8 x i16>, <8 x i16>* %ptr.b, align 2
1906   %cmp = icmp sgt <8 x i16> %load.a, %load.b
1907   %sel = select <8 x i1> %cmp, <8 x i16> %load.b, <8 x i16> %load.a
1908   store <8 x i16> %sel, <8 x i16>* %ptr.a, align 2
1909   %index.next = add i64 %index, 8
1910   %loop = icmp eq i64 %index.next, 16384
1911   br i1 %loop, label %for.end, label %vector.body
1912
1913 for.end:                                          ; preds = %vector.body
1914   ret void
1915
1916 ; SSE2-LABEL: test59:
1917 ; SSE2: pminsw
1918
1919 ; AVX1-LABEL: test59:
1920 ; AVX1: vpminsw
1921
1922 ; AVX2-LABEL: test59:
1923 ; AVX2: vpminsw
1924
1925 ; AVX512VL-LABEL: test59:
1926 ; AVX512VL: vpminsw
1927 }
1928
1929 define void @test60(i16* nocapture %a, i16* nocapture %b) nounwind {
1930 vector.ph:
1931   br label %vector.body
1932
1933 vector.body:                                      ; preds = %vector.body, %vector.ph
1934   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
1935   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
1936   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
1937   %ptr.a = bitcast i16* %gep.a to <8 x i16>*
1938   %ptr.b = bitcast i16* %gep.b to <8 x i16>*
1939   %load.a = load <8 x i16>, <8 x i16>* %ptr.a, align 2
1940   %load.b = load <8 x i16>, <8 x i16>* %ptr.b, align 2
1941   %cmp = icmp sge <8 x i16> %load.a, %load.b
1942   %sel = select <8 x i1> %cmp, <8 x i16> %load.b, <8 x i16> %load.a
1943   store <8 x i16> %sel, <8 x i16>* %ptr.a, align 2
1944   %index.next = add i64 %index, 8
1945   %loop = icmp eq i64 %index.next, 16384
1946   br i1 %loop, label %for.end, label %vector.body
1947
1948 for.end:                                          ; preds = %vector.body
1949   ret void
1950
1951 ; SSE2-LABEL: test60:
1952 ; SSE2: pminsw
1953
1954 ; AVX1-LABEL: test60:
1955 ; AVX1: vpminsw
1956
1957 ; AVX2-LABEL: test60:
1958 ; AVX2: vpminsw
1959
1960 ; AVX512VL-LABEL: test60:
1961 ; AVX512VL: vpminsw
1962 }
1963
1964 define void @test61(i16* nocapture %a, i16* nocapture %b) nounwind {
1965 vector.ph:
1966   br label %vector.body
1967
1968 vector.body:                                      ; preds = %vector.body, %vector.ph
1969   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
1970   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
1971   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
1972   %ptr.a = bitcast i16* %gep.a to <8 x i16>*
1973   %ptr.b = bitcast i16* %gep.b to <8 x i16>*
1974   %load.a = load <8 x i16>, <8 x i16>* %ptr.a, align 2
1975   %load.b = load <8 x i16>, <8 x i16>* %ptr.b, align 2
1976   %cmp = icmp ult <8 x i16> %load.a, %load.b
1977   %sel = select <8 x i1> %cmp, <8 x i16> %load.b, <8 x i16> %load.a
1978   store <8 x i16> %sel, <8 x i16>* %ptr.a, align 2
1979   %index.next = add i64 %index, 8
1980   %loop = icmp eq i64 %index.next, 16384
1981   br i1 %loop, label %for.end, label %vector.body
1982
1983 for.end:                                          ; preds = %vector.body
1984   ret void
1985
1986 ; SSE4-LABEL: test61:
1987 ; SSE4: pmaxuw
1988
1989 ; AVX1-LABEL: test61:
1990 ; AVX1: vpmaxuw
1991
1992 ; AVX2-LABEL: test61:
1993 ; AVX2: vpmaxuw
1994
1995 ; AVX512VL-LABEL: test61:
1996 ; AVX512VL: vpmaxuw
1997 }
1998
1999 define void @test62(i16* nocapture %a, i16* nocapture %b) nounwind {
2000 vector.ph:
2001   br label %vector.body
2002
2003 vector.body:                                      ; preds = %vector.body, %vector.ph
2004   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
2005   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
2006   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
2007   %ptr.a = bitcast i16* %gep.a to <8 x i16>*
2008   %ptr.b = bitcast i16* %gep.b to <8 x i16>*
2009   %load.a = load <8 x i16>, <8 x i16>* %ptr.a, align 2
2010   %load.b = load <8 x i16>, <8 x i16>* %ptr.b, align 2
2011   %cmp = icmp ule <8 x i16> %load.a, %load.b
2012   %sel = select <8 x i1> %cmp, <8 x i16> %load.b, <8 x i16> %load.a
2013   store <8 x i16> %sel, <8 x i16>* %ptr.a, align 2
2014   %index.next = add i64 %index, 8
2015   %loop = icmp eq i64 %index.next, 16384
2016   br i1 %loop, label %for.end, label %vector.body
2017
2018 for.end:                                          ; preds = %vector.body
2019   ret void
2020
2021 ; SSE4-LABEL: test62:
2022 ; SSE4: pmaxuw
2023
2024 ; AVX1-LABEL: test62:
2025 ; AVX1: vpmaxuw
2026
2027 ; AVX2-LABEL: test62:
2028 ; AVX2: vpmaxuw
2029
2030 ; AVX512VL-LABEL: test62:
2031 ; AVX512VL: vpmaxuw
2032 }
2033
2034 define void @test63(i16* nocapture %a, i16* nocapture %b) nounwind {
2035 vector.ph:
2036   br label %vector.body
2037
2038 vector.body:                                      ; preds = %vector.body, %vector.ph
2039   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
2040   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
2041   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
2042   %ptr.a = bitcast i16* %gep.a to <8 x i16>*
2043   %ptr.b = bitcast i16* %gep.b to <8 x i16>*
2044   %load.a = load <8 x i16>, <8 x i16>* %ptr.a, align 2
2045   %load.b = load <8 x i16>, <8 x i16>* %ptr.b, align 2
2046   %cmp = icmp ugt <8 x i16> %load.a, %load.b
2047   %sel = select <8 x i1> %cmp, <8 x i16> %load.b, <8 x i16> %load.a
2048   store <8 x i16> %sel, <8 x i16>* %ptr.a, align 2
2049   %index.next = add i64 %index, 8
2050   %loop = icmp eq i64 %index.next, 16384
2051   br i1 %loop, label %for.end, label %vector.body
2052
2053 for.end:                                          ; preds = %vector.body
2054   ret void
2055
2056 ; SSE4-LABEL: test63:
2057 ; SSE4: pminuw
2058
2059 ; AVX1-LABEL: test63:
2060 ; AVX1: vpminuw
2061
2062 ; AVX2-LABEL: test63:
2063 ; AVX2: vpminuw
2064
2065 ; AVX512VL-LABEL: test63:
2066 ; AVX512VL: vpminuw
2067 }
2068
2069 define void @test64(i16* nocapture %a, i16* nocapture %b) nounwind {
2070 vector.ph:
2071   br label %vector.body
2072
2073 vector.body:                                      ; preds = %vector.body, %vector.ph
2074   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
2075   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
2076   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
2077   %ptr.a = bitcast i16* %gep.a to <8 x i16>*
2078   %ptr.b = bitcast i16* %gep.b to <8 x i16>*
2079   %load.a = load <8 x i16>, <8 x i16>* %ptr.a, align 2
2080   %load.b = load <8 x i16>, <8 x i16>* %ptr.b, align 2
2081   %cmp = icmp uge <8 x i16> %load.a, %load.b
2082   %sel = select <8 x i1> %cmp, <8 x i16> %load.b, <8 x i16> %load.a
2083   store <8 x i16> %sel, <8 x i16>* %ptr.a, align 2
2084   %index.next = add i64 %index, 8
2085   %loop = icmp eq i64 %index.next, 16384
2086   br i1 %loop, label %for.end, label %vector.body
2087
2088 for.end:                                          ; preds = %vector.body
2089   ret void
2090
2091 ; SSE4-LABEL: test64:
2092 ; SSE4: pminuw
2093
2094 ; AVX1-LABEL: test64:
2095 ; AVX1: vpminuw
2096
2097 ; AVX2-LABEL: test64:
2098 ; AVX2: vpminuw
2099
2100 ; AVX512VL-LABEL: test64:
2101 ; AVX512VL: vpminuw
2102 }
2103
2104 define void @test65(i32* nocapture %a, i32* nocapture %b) nounwind {
2105 vector.ph:
2106   br label %vector.body
2107
2108 vector.body:                                      ; preds = %vector.body, %vector.ph
2109   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
2110   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
2111   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
2112   %ptr.a = bitcast i32* %gep.a to <4 x i32>*
2113   %ptr.b = bitcast i32* %gep.b to <4 x i32>*
2114   %load.a = load <4 x i32>, <4 x i32>* %ptr.a, align 2
2115   %load.b = load <4 x i32>, <4 x i32>* %ptr.b, align 2
2116   %cmp = icmp slt <4 x i32> %load.a, %load.b
2117   %sel = select <4 x i1> %cmp, <4 x i32> %load.b, <4 x i32> %load.a
2118   store <4 x i32> %sel, <4 x i32>* %ptr.a, align 2
2119   %index.next = add i64 %index, 4
2120   %loop = icmp eq i64 %index.next, 16384
2121   br i1 %loop, label %for.end, label %vector.body
2122
2123 for.end:                                          ; preds = %vector.body
2124   ret void
2125
2126 ; SSE4-LABEL: test65:
2127 ; SSE4: pmaxsd
2128
2129 ; AVX1-LABEL: test65:
2130 ; AVX1: vpmaxsd
2131
2132 ; AVX2-LABEL: test65:
2133 ; AVX2: vpmaxsd
2134
2135 ; AVX512VL-LABEL: test65:
2136 ; AVX512VL: vpmaxsd
2137 }
2138
2139 define void @test66(i32* nocapture %a, i32* nocapture %b) nounwind {
2140 vector.ph:
2141   br label %vector.body
2142
2143 vector.body:                                      ; preds = %vector.body, %vector.ph
2144   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
2145   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
2146   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
2147   %ptr.a = bitcast i32* %gep.a to <4 x i32>*
2148   %ptr.b = bitcast i32* %gep.b to <4 x i32>*
2149   %load.a = load <4 x i32>, <4 x i32>* %ptr.a, align 2
2150   %load.b = load <4 x i32>, <4 x i32>* %ptr.b, align 2
2151   %cmp = icmp sle <4 x i32> %load.a, %load.b
2152   %sel = select <4 x i1> %cmp, <4 x i32> %load.b, <4 x i32> %load.a
2153   store <4 x i32> %sel, <4 x i32>* %ptr.a, align 2
2154   %index.next = add i64 %index, 4
2155   %loop = icmp eq i64 %index.next, 16384
2156   br i1 %loop, label %for.end, label %vector.body
2157
2158 for.end:                                          ; preds = %vector.body
2159   ret void
2160
2161 ; SSE4-LABEL: test66:
2162 ; SSE4: pmaxsd
2163
2164 ; AVX1-LABEL: test66:
2165 ; AVX1: vpmaxsd
2166
2167 ; AVX2-LABEL: test66:
2168 ; AVX2: vpmaxsd
2169
2170 ; AVX512VL-LABEL: test66:
2171 ; AVX512VL: vpmaxsd
2172 }
2173
2174 define void @test67(i32* nocapture %a, i32* nocapture %b) nounwind {
2175 vector.ph:
2176   br label %vector.body
2177
2178 vector.body:                                      ; preds = %vector.body, %vector.ph
2179   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
2180   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
2181   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
2182   %ptr.a = bitcast i32* %gep.a to <4 x i32>*
2183   %ptr.b = bitcast i32* %gep.b to <4 x i32>*
2184   %load.a = load <4 x i32>, <4 x i32>* %ptr.a, align 2
2185   %load.b = load <4 x i32>, <4 x i32>* %ptr.b, align 2
2186   %cmp = icmp sgt <4 x i32> %load.a, %load.b
2187   %sel = select <4 x i1> %cmp, <4 x i32> %load.b, <4 x i32> %load.a
2188   store <4 x i32> %sel, <4 x i32>* %ptr.a, align 2
2189   %index.next = add i64 %index, 4
2190   %loop = icmp eq i64 %index.next, 16384
2191   br i1 %loop, label %for.end, label %vector.body
2192
2193 for.end:                                          ; preds = %vector.body
2194   ret void
2195
2196 ; SSE4-LABEL: test67:
2197 ; SSE4: pminsd
2198
2199 ; AVX1-LABEL: test67:
2200 ; AVX1: vpminsd
2201
2202 ; AVX2-LABEL: test67:
2203 ; AVX2: vpminsd
2204
2205 ; AVX512VL-LABEL: test67:
2206 ; AVX512VL: vpminsd
2207 }
2208
2209 define void @test68(i32* nocapture %a, i32* nocapture %b) nounwind {
2210 vector.ph:
2211   br label %vector.body
2212
2213 vector.body:                                      ; preds = %vector.body, %vector.ph
2214   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
2215   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
2216   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
2217   %ptr.a = bitcast i32* %gep.a to <4 x i32>*
2218   %ptr.b = bitcast i32* %gep.b to <4 x i32>*
2219   %load.a = load <4 x i32>, <4 x i32>* %ptr.a, align 2
2220   %load.b = load <4 x i32>, <4 x i32>* %ptr.b, align 2
2221   %cmp = icmp sge <4 x i32> %load.a, %load.b
2222   %sel = select <4 x i1> %cmp, <4 x i32> %load.b, <4 x i32> %load.a
2223   store <4 x i32> %sel, <4 x i32>* %ptr.a, align 2
2224   %index.next = add i64 %index, 4
2225   %loop = icmp eq i64 %index.next, 16384
2226   br i1 %loop, label %for.end, label %vector.body
2227
2228 for.end:                                          ; preds = %vector.body
2229   ret void
2230
2231 ; SSE4-LABEL: test68:
2232 ; SSE4: pminsd
2233
2234 ; AVX1-LABEL: test68:
2235 ; AVX1: vpminsd
2236
2237 ; AVX2-LABEL: test68:
2238 ; AVX2: vpminsd
2239
2240 ; AVX512VL-LABEL: test68:
2241 ; AVX512VL: vpminsd
2242 }
2243
2244 define void @test69(i32* nocapture %a, i32* nocapture %b) nounwind {
2245 vector.ph:
2246   br label %vector.body
2247
2248 vector.body:                                      ; preds = %vector.body, %vector.ph
2249   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
2250   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
2251   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
2252   %ptr.a = bitcast i32* %gep.a to <4 x i32>*
2253   %ptr.b = bitcast i32* %gep.b to <4 x i32>*
2254   %load.a = load <4 x i32>, <4 x i32>* %ptr.a, align 2
2255   %load.b = load <4 x i32>, <4 x i32>* %ptr.b, align 2
2256   %cmp = icmp ult <4 x i32> %load.a, %load.b
2257   %sel = select <4 x i1> %cmp, <4 x i32> %load.b, <4 x i32> %load.a
2258   store <4 x i32> %sel, <4 x i32>* %ptr.a, align 2
2259   %index.next = add i64 %index, 4
2260   %loop = icmp eq i64 %index.next, 16384
2261   br i1 %loop, label %for.end, label %vector.body
2262
2263 for.end:                                          ; preds = %vector.body
2264   ret void
2265
2266 ; SSE4-LABEL: test69:
2267 ; SSE4: pmaxud
2268
2269 ; AVX1-LABEL: test69:
2270 ; AVX1: vpmaxud
2271
2272 ; AVX2-LABEL: test69:
2273 ; AVX2: vpmaxud
2274
2275 ; AVX512VL-LABEL: test69:
2276 ; AVX512VL: vpmaxud
2277 }
2278
2279 define void @test70(i32* nocapture %a, i32* nocapture %b) nounwind {
2280 vector.ph:
2281   br label %vector.body
2282
2283 vector.body:                                      ; preds = %vector.body, %vector.ph
2284   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
2285   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
2286   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
2287   %ptr.a = bitcast i32* %gep.a to <4 x i32>*
2288   %ptr.b = bitcast i32* %gep.b to <4 x i32>*
2289   %load.a = load <4 x i32>, <4 x i32>* %ptr.a, align 2
2290   %load.b = load <4 x i32>, <4 x i32>* %ptr.b, align 2
2291   %cmp = icmp ule <4 x i32> %load.a, %load.b
2292   %sel = select <4 x i1> %cmp, <4 x i32> %load.b, <4 x i32> %load.a
2293   store <4 x i32> %sel, <4 x i32>* %ptr.a, align 2
2294   %index.next = add i64 %index, 4
2295   %loop = icmp eq i64 %index.next, 16384
2296   br i1 %loop, label %for.end, label %vector.body
2297
2298 for.end:                                          ; preds = %vector.body
2299   ret void
2300
2301 ; SSE4-LABEL: test70:
2302 ; SSE4: pmaxud
2303
2304 ; AVX1-LABEL: test70:
2305 ; AVX1: vpmaxud
2306
2307 ; AVX2-LABEL: test70:
2308 ; AVX2: vpmaxud
2309
2310 ; AVX512VL-LABEL: test70:
2311 ; AVX512VL: vpmaxud
2312 }
2313
2314 define void @test71(i32* nocapture %a, i32* nocapture %b) nounwind {
2315 vector.ph:
2316   br label %vector.body
2317
2318 vector.body:                                      ; preds = %vector.body, %vector.ph
2319   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
2320   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
2321   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
2322   %ptr.a = bitcast i32* %gep.a to <4 x i32>*
2323   %ptr.b = bitcast i32* %gep.b to <4 x i32>*
2324   %load.a = load <4 x i32>, <4 x i32>* %ptr.a, align 2
2325   %load.b = load <4 x i32>, <4 x i32>* %ptr.b, align 2
2326   %cmp = icmp ugt <4 x i32> %load.a, %load.b
2327   %sel = select <4 x i1> %cmp, <4 x i32> %load.b, <4 x i32> %load.a
2328   store <4 x i32> %sel, <4 x i32>* %ptr.a, align 2
2329   %index.next = add i64 %index, 4
2330   %loop = icmp eq i64 %index.next, 16384
2331   br i1 %loop, label %for.end, label %vector.body
2332
2333 for.end:                                          ; preds = %vector.body
2334   ret void
2335
2336 ; SSE4-LABEL: test71:
2337 ; SSE4: pminud
2338
2339 ; AVX1-LABEL: test71:
2340 ; AVX1: vpminud
2341
2342 ; AVX2-LABEL: test71:
2343 ; AVX2: vpminud
2344
2345 ; AVX512VL-LABEL: test71:
2346 ; AVX512VL: vpminud
2347 }
2348
2349 define void @test72(i32* nocapture %a, i32* nocapture %b) nounwind {
2350 vector.ph:
2351   br label %vector.body
2352
2353 vector.body:                                      ; preds = %vector.body, %vector.ph
2354   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
2355   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
2356   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
2357   %ptr.a = bitcast i32* %gep.a to <4 x i32>*
2358   %ptr.b = bitcast i32* %gep.b to <4 x i32>*
2359   %load.a = load <4 x i32>, <4 x i32>* %ptr.a, align 2
2360   %load.b = load <4 x i32>, <4 x i32>* %ptr.b, align 2
2361   %cmp = icmp uge <4 x i32> %load.a, %load.b
2362   %sel = select <4 x i1> %cmp, <4 x i32> %load.b, <4 x i32> %load.a
2363   store <4 x i32> %sel, <4 x i32>* %ptr.a, align 2
2364   %index.next = add i64 %index, 4
2365   %loop = icmp eq i64 %index.next, 16384
2366   br i1 %loop, label %for.end, label %vector.body
2367
2368 for.end:                                          ; preds = %vector.body
2369   ret void
2370
2371 ; SSE4-LABEL: test72:
2372 ; SSE4: pminud
2373
2374 ; AVX1-LABEL: test72:
2375 ; AVX1: vpminud
2376
2377 ; AVX2-LABEL: test72:
2378 ; AVX2: vpminud
2379
2380 ; AVX512VL-LABEL: test72:
2381 ; AVX512VL: vpminud
2382 }
2383
2384 define void @test73(i8* nocapture %a, i8* nocapture %b) nounwind {
2385 vector.ph:
2386   br label %vector.body
2387
2388 vector.body:                                      ; preds = %vector.body, %vector.ph
2389   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
2390   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
2391   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
2392   %ptr.a = bitcast i8* %gep.a to <32 x i8>*
2393   %ptr.b = bitcast i8* %gep.b to <32 x i8>*
2394   %load.a = load <32 x i8>, <32 x i8>* %ptr.a, align 2
2395   %load.b = load <32 x i8>, <32 x i8>* %ptr.b, align 2
2396   %cmp = icmp slt <32 x i8> %load.a, %load.b
2397   %sel = select <32 x i1> %cmp, <32 x i8> %load.b, <32 x i8> %load.a
2398   store <32 x i8> %sel, <32 x i8>* %ptr.a, align 2
2399   %index.next = add i64 %index, 32
2400   %loop = icmp eq i64 %index.next, 16384
2401   br i1 %loop, label %for.end, label %vector.body
2402
2403 for.end:                                          ; preds = %vector.body
2404   ret void
2405
2406 ; AVX2-LABEL: test73:
2407 ; AVX2: vpmaxsb
2408
2409 ; AVX512VL-LABEL: test73:
2410 ; AVX512VL: vpmaxsb
2411 }
2412
2413 define void @test74(i8* nocapture %a, i8* nocapture %b) nounwind {
2414 vector.ph:
2415   br label %vector.body
2416
2417 vector.body:                                      ; preds = %vector.body, %vector.ph
2418   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
2419   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
2420   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
2421   %ptr.a = bitcast i8* %gep.a to <32 x i8>*
2422   %ptr.b = bitcast i8* %gep.b to <32 x i8>*
2423   %load.a = load <32 x i8>, <32 x i8>* %ptr.a, align 2
2424   %load.b = load <32 x i8>, <32 x i8>* %ptr.b, align 2
2425   %cmp = icmp sle <32 x i8> %load.a, %load.b
2426   %sel = select <32 x i1> %cmp, <32 x i8> %load.b, <32 x i8> %load.a
2427   store <32 x i8> %sel, <32 x i8>* %ptr.a, align 2
2428   %index.next = add i64 %index, 32
2429   %loop = icmp eq i64 %index.next, 16384
2430   br i1 %loop, label %for.end, label %vector.body
2431
2432 for.end:                                          ; preds = %vector.body
2433   ret void
2434
2435 ; AVX2-LABEL: test74:
2436 ; AVX2: vpmaxsb
2437
2438 ; AVX512VL-LABEL: test74:
2439 ; AVX512VL: vpmaxsb 
2440 }
2441
2442 define void @test75(i8* nocapture %a, i8* nocapture %b) nounwind {
2443 vector.ph:
2444   br label %vector.body
2445
2446 vector.body:                                      ; preds = %vector.body, %vector.ph
2447   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
2448   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
2449   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
2450   %ptr.a = bitcast i8* %gep.a to <32 x i8>*
2451   %ptr.b = bitcast i8* %gep.b to <32 x i8>*
2452   %load.a = load <32 x i8>, <32 x i8>* %ptr.a, align 2
2453   %load.b = load <32 x i8>, <32 x i8>* %ptr.b, align 2
2454   %cmp = icmp sgt <32 x i8> %load.a, %load.b
2455   %sel = select <32 x i1> %cmp, <32 x i8> %load.b, <32 x i8> %load.a
2456   store <32 x i8> %sel, <32 x i8>* %ptr.a, align 2
2457   %index.next = add i64 %index, 32
2458   %loop = icmp eq i64 %index.next, 16384
2459   br i1 %loop, label %for.end, label %vector.body
2460
2461 for.end:                                          ; preds = %vector.body
2462   ret void
2463
2464 ; AVX2-LABEL: test75:
2465 ; AVX2: vpminsb
2466
2467 ; AVX512VL-LABEL: test75:
2468 ; AVX512VL: vpminsb
2469 }
2470
2471 define void @test76(i8* nocapture %a, i8* nocapture %b) nounwind {
2472 vector.ph:
2473   br label %vector.body
2474
2475 vector.body:                                      ; preds = %vector.body, %vector.ph
2476   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
2477   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
2478   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
2479   %ptr.a = bitcast i8* %gep.a to <32 x i8>*
2480   %ptr.b = bitcast i8* %gep.b to <32 x i8>*
2481   %load.a = load <32 x i8>, <32 x i8>* %ptr.a, align 2
2482   %load.b = load <32 x i8>, <32 x i8>* %ptr.b, align 2
2483   %cmp = icmp sge <32 x i8> %load.a, %load.b
2484   %sel = select <32 x i1> %cmp, <32 x i8> %load.b, <32 x i8> %load.a
2485   store <32 x i8> %sel, <32 x i8>* %ptr.a, align 2
2486   %index.next = add i64 %index, 32
2487   %loop = icmp eq i64 %index.next, 16384
2488   br i1 %loop, label %for.end, label %vector.body
2489
2490 for.end:                                          ; preds = %vector.body
2491   ret void
2492
2493 ; AVX2-LABEL: test76:
2494 ; AVX2: vpminsb
2495
2496 ; AVX512VL-LABEL: test76:
2497 ; AVX512VL: vpminsb
2498 }
2499
2500 define void @test77(i8* nocapture %a, i8* nocapture %b) nounwind {
2501 vector.ph:
2502   br label %vector.body
2503
2504 vector.body:                                      ; preds = %vector.body, %vector.ph
2505   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
2506   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
2507   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
2508   %ptr.a = bitcast i8* %gep.a to <32 x i8>*
2509   %ptr.b = bitcast i8* %gep.b to <32 x i8>*
2510   %load.a = load <32 x i8>, <32 x i8>* %ptr.a, align 2
2511   %load.b = load <32 x i8>, <32 x i8>* %ptr.b, align 2
2512   %cmp = icmp ult <32 x i8> %load.a, %load.b
2513   %sel = select <32 x i1> %cmp, <32 x i8> %load.b, <32 x i8> %load.a
2514   store <32 x i8> %sel, <32 x i8>* %ptr.a, align 2
2515   %index.next = add i64 %index, 32
2516   %loop = icmp eq i64 %index.next, 16384
2517   br i1 %loop, label %for.end, label %vector.body
2518
2519 for.end:                                          ; preds = %vector.body
2520   ret void
2521
2522 ; AVX2-LABEL: test77:
2523 ; AVX2: vpmaxub
2524
2525 ; AVX512VL-LABEL: test77:
2526 ; AVX512VL: vpmaxub
2527 }
2528
2529 define void @test78(i8* nocapture %a, i8* nocapture %b) nounwind {
2530 vector.ph:
2531   br label %vector.body
2532
2533 vector.body:                                      ; preds = %vector.body, %vector.ph
2534   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
2535   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
2536   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
2537   %ptr.a = bitcast i8* %gep.a to <32 x i8>*
2538   %ptr.b = bitcast i8* %gep.b to <32 x i8>*
2539   %load.a = load <32 x i8>, <32 x i8>* %ptr.a, align 2
2540   %load.b = load <32 x i8>, <32 x i8>* %ptr.b, align 2
2541   %cmp = icmp ule <32 x i8> %load.a, %load.b
2542   %sel = select <32 x i1> %cmp, <32 x i8> %load.b, <32 x i8> %load.a
2543   store <32 x i8> %sel, <32 x i8>* %ptr.a, align 2
2544   %index.next = add i64 %index, 32
2545   %loop = icmp eq i64 %index.next, 16384
2546   br i1 %loop, label %for.end, label %vector.body
2547
2548 for.end:                                          ; preds = %vector.body
2549   ret void
2550
2551 ; AVX2-LABEL: test78:
2552 ; AVX2: vpmaxub
2553
2554 ; AVX512VL-LABEL: test78:
2555 ; AVX512VL: vpmaxub
2556 }
2557
2558 define void @test79(i8* nocapture %a, i8* nocapture %b) nounwind {
2559 vector.ph:
2560   br label %vector.body
2561
2562 vector.body:                                      ; preds = %vector.body, %vector.ph
2563   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
2564   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
2565   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
2566   %ptr.a = bitcast i8* %gep.a to <32 x i8>*
2567   %ptr.b = bitcast i8* %gep.b to <32 x i8>*
2568   %load.a = load <32 x i8>, <32 x i8>* %ptr.a, align 2
2569   %load.b = load <32 x i8>, <32 x i8>* %ptr.b, align 2
2570   %cmp = icmp ugt <32 x i8> %load.a, %load.b
2571   %sel = select <32 x i1> %cmp, <32 x i8> %load.b, <32 x i8> %load.a
2572   store <32 x i8> %sel, <32 x i8>* %ptr.a, align 2
2573   %index.next = add i64 %index, 32
2574   %loop = icmp eq i64 %index.next, 16384
2575   br i1 %loop, label %for.end, label %vector.body
2576
2577 for.end:                                          ; preds = %vector.body
2578   ret void
2579
2580 ; AVX2-LABEL: test79:
2581 ; AVX2: vpminub
2582
2583 ; AVX512VL-LABEL: test79:
2584 ; AVX512VL: vpminub
2585 }
2586
2587 define void @test80(i8* nocapture %a, i8* nocapture %b) nounwind {
2588 vector.ph:
2589   br label %vector.body
2590
2591 vector.body:                                      ; preds = %vector.body, %vector.ph
2592   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
2593   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
2594   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
2595   %ptr.a = bitcast i8* %gep.a to <32 x i8>*
2596   %ptr.b = bitcast i8* %gep.b to <32 x i8>*
2597   %load.a = load <32 x i8>, <32 x i8>* %ptr.a, align 2
2598   %load.b = load <32 x i8>, <32 x i8>* %ptr.b, align 2
2599   %cmp = icmp uge <32 x i8> %load.a, %load.b
2600   %sel = select <32 x i1> %cmp, <32 x i8> %load.b, <32 x i8> %load.a
2601   store <32 x i8> %sel, <32 x i8>* %ptr.a, align 2
2602   %index.next = add i64 %index, 32
2603   %loop = icmp eq i64 %index.next, 16384
2604   br i1 %loop, label %for.end, label %vector.body
2605
2606 for.end:                                          ; preds = %vector.body
2607   ret void
2608
2609 ; AVX2-LABEL: test80:
2610 ; AVX2: vpminub
2611
2612 ; AVX512VL-LABEL: test80:
2613 ; AVX512VL: vpminub
2614 }
2615
2616 define void @test81(i16* nocapture %a, i16* nocapture %b) nounwind {
2617 vector.ph:
2618   br label %vector.body
2619
2620 vector.body:                                      ; preds = %vector.body, %vector.ph
2621   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
2622   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
2623   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
2624   %ptr.a = bitcast i16* %gep.a to <16 x i16>*
2625   %ptr.b = bitcast i16* %gep.b to <16 x i16>*
2626   %load.a = load <16 x i16>, <16 x i16>* %ptr.a, align 2
2627   %load.b = load <16 x i16>, <16 x i16>* %ptr.b, align 2
2628   %cmp = icmp slt <16 x i16> %load.a, %load.b
2629   %sel = select <16 x i1> %cmp, <16 x i16> %load.b, <16 x i16> %load.a
2630   store <16 x i16> %sel, <16 x i16>* %ptr.a, align 2
2631   %index.next = add i64 %index, 16
2632   %loop = icmp eq i64 %index.next, 16384
2633   br i1 %loop, label %for.end, label %vector.body
2634
2635 for.end:                                          ; preds = %vector.body
2636   ret void
2637
2638 ; AVX2-LABEL: test81:
2639 ; AVX2: vpmaxsw
2640
2641 ; AVX512VL-LABEL: test81:
2642 ; AVX512VL: vpmaxsw
2643 }
2644
2645 define void @test82(i16* nocapture %a, i16* nocapture %b) nounwind {
2646 vector.ph:
2647   br label %vector.body
2648
2649 vector.body:                                      ; preds = %vector.body, %vector.ph
2650   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
2651   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
2652   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
2653   %ptr.a = bitcast i16* %gep.a to <16 x i16>*
2654   %ptr.b = bitcast i16* %gep.b to <16 x i16>*
2655   %load.a = load <16 x i16>, <16 x i16>* %ptr.a, align 2
2656   %load.b = load <16 x i16>, <16 x i16>* %ptr.b, align 2
2657   %cmp = icmp sle <16 x i16> %load.a, %load.b
2658   %sel = select <16 x i1> %cmp, <16 x i16> %load.b, <16 x i16> %load.a
2659   store <16 x i16> %sel, <16 x i16>* %ptr.a, align 2
2660   %index.next = add i64 %index, 16
2661   %loop = icmp eq i64 %index.next, 16384
2662   br i1 %loop, label %for.end, label %vector.body
2663
2664 for.end:                                          ; preds = %vector.body
2665   ret void
2666
2667 ; AVX2-LABEL: test82:
2668 ; AVX2: vpmaxsw
2669
2670 ; AVX512VL-LABEL: test82:
2671 ; AVX512VL: vpmaxsw
2672 }
2673
2674 define void @test83(i16* nocapture %a, i16* nocapture %b) nounwind {
2675 vector.ph:
2676   br label %vector.body
2677
2678 vector.body:                                      ; preds = %vector.body, %vector.ph
2679   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
2680   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
2681   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
2682   %ptr.a = bitcast i16* %gep.a to <16 x i16>*
2683   %ptr.b = bitcast i16* %gep.b to <16 x i16>*
2684   %load.a = load <16 x i16>, <16 x i16>* %ptr.a, align 2
2685   %load.b = load <16 x i16>, <16 x i16>* %ptr.b, align 2
2686   %cmp = icmp sgt <16 x i16> %load.a, %load.b
2687   %sel = select <16 x i1> %cmp, <16 x i16> %load.b, <16 x i16> %load.a
2688   store <16 x i16> %sel, <16 x i16>* %ptr.a, align 2
2689   %index.next = add i64 %index, 16
2690   %loop = icmp eq i64 %index.next, 16384
2691   br i1 %loop, label %for.end, label %vector.body
2692
2693 for.end:                                          ; preds = %vector.body
2694   ret void
2695
2696 ; AVX2-LABEL: test83:
2697 ; AVX2: vpminsw
2698
2699 ; AVX512VL-LABEL: test83:
2700 ; AVX512VL: vpminsw
2701 }
2702
2703 define void @test84(i16* nocapture %a, i16* nocapture %b) nounwind {
2704 vector.ph:
2705   br label %vector.body
2706
2707 vector.body:                                      ; preds = %vector.body, %vector.ph
2708   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
2709   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
2710   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
2711   %ptr.a = bitcast i16* %gep.a to <16 x i16>*
2712   %ptr.b = bitcast i16* %gep.b to <16 x i16>*
2713   %load.a = load <16 x i16>, <16 x i16>* %ptr.a, align 2
2714   %load.b = load <16 x i16>, <16 x i16>* %ptr.b, align 2
2715   %cmp = icmp sge <16 x i16> %load.a, %load.b
2716   %sel = select <16 x i1> %cmp, <16 x i16> %load.b, <16 x i16> %load.a
2717   store <16 x i16> %sel, <16 x i16>* %ptr.a, align 2
2718   %index.next = add i64 %index, 16
2719   %loop = icmp eq i64 %index.next, 16384
2720   br i1 %loop, label %for.end, label %vector.body
2721
2722 for.end:                                          ; preds = %vector.body
2723   ret void
2724
2725 ; AVX2-LABEL: test84:
2726 ; AVX2: vpminsw
2727
2728 ; AVX512VL-LABEL: test84:
2729 ; AVX512VL: vpminsw
2730 }
2731
2732 define void @test85(i16* nocapture %a, i16* nocapture %b) nounwind {
2733 vector.ph:
2734   br label %vector.body
2735
2736 vector.body:                                      ; preds = %vector.body, %vector.ph
2737   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
2738   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
2739   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
2740   %ptr.a = bitcast i16* %gep.a to <16 x i16>*
2741   %ptr.b = bitcast i16* %gep.b to <16 x i16>*
2742   %load.a = load <16 x i16>, <16 x i16>* %ptr.a, align 2
2743   %load.b = load <16 x i16>, <16 x i16>* %ptr.b, align 2
2744   %cmp = icmp ult <16 x i16> %load.a, %load.b
2745   %sel = select <16 x i1> %cmp, <16 x i16> %load.b, <16 x i16> %load.a
2746   store <16 x i16> %sel, <16 x i16>* %ptr.a, align 2
2747   %index.next = add i64 %index, 16
2748   %loop = icmp eq i64 %index.next, 16384
2749   br i1 %loop, label %for.end, label %vector.body
2750
2751 for.end:                                          ; preds = %vector.body
2752   ret void
2753
2754 ; AVX2-LABEL: test85:
2755 ; AVX2: vpmaxuw
2756
2757 ; AVX512VL-LABEL: test85:
2758 ; AVX512VL: vpmaxuw
2759 }
2760
2761 define void @test86(i16* nocapture %a, i16* nocapture %b) nounwind {
2762 vector.ph:
2763   br label %vector.body
2764
2765 vector.body:                                      ; preds = %vector.body, %vector.ph
2766   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
2767   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
2768   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
2769   %ptr.a = bitcast i16* %gep.a to <16 x i16>*
2770   %ptr.b = bitcast i16* %gep.b to <16 x i16>*
2771   %load.a = load <16 x i16>, <16 x i16>* %ptr.a, align 2
2772   %load.b = load <16 x i16>, <16 x i16>* %ptr.b, align 2
2773   %cmp = icmp ule <16 x i16> %load.a, %load.b
2774   %sel = select <16 x i1> %cmp, <16 x i16> %load.b, <16 x i16> %load.a
2775   store <16 x i16> %sel, <16 x i16>* %ptr.a, align 2
2776   %index.next = add i64 %index, 16
2777   %loop = icmp eq i64 %index.next, 16384
2778   br i1 %loop, label %for.end, label %vector.body
2779
2780 for.end:                                          ; preds = %vector.body
2781   ret void
2782
2783 ; AVX2-LABEL: test86:
2784 ; AVX2: vpmaxuw
2785
2786 ; AVX512VL-LABEL: test86:
2787 ; AVX512VL: vpmaxuw
2788 }
2789
2790 define void @test87(i16* nocapture %a, i16* nocapture %b) nounwind {
2791 vector.ph:
2792   br label %vector.body
2793
2794 vector.body:                                      ; preds = %vector.body, %vector.ph
2795   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
2796   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
2797   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
2798   %ptr.a = bitcast i16* %gep.a to <16 x i16>*
2799   %ptr.b = bitcast i16* %gep.b to <16 x i16>*
2800   %load.a = load <16 x i16>, <16 x i16>* %ptr.a, align 2
2801   %load.b = load <16 x i16>, <16 x i16>* %ptr.b, align 2
2802   %cmp = icmp ugt <16 x i16> %load.a, %load.b
2803   %sel = select <16 x i1> %cmp, <16 x i16> %load.b, <16 x i16> %load.a
2804   store <16 x i16> %sel, <16 x i16>* %ptr.a, align 2
2805   %index.next = add i64 %index, 16
2806   %loop = icmp eq i64 %index.next, 16384
2807   br i1 %loop, label %for.end, label %vector.body
2808
2809 for.end:                                          ; preds = %vector.body
2810   ret void
2811
2812 ; AVX2-LABEL: test87:
2813 ; AVX2: vpminuw
2814
2815 ; AVX512VL-LABEL: test87:
2816 ; AVX512VL: vpminuw
2817 }
2818
2819 define void @test88(i16* nocapture %a, i16* nocapture %b) nounwind {
2820 vector.ph:
2821   br label %vector.body
2822
2823 vector.body:                                      ; preds = %vector.body, %vector.ph
2824   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
2825   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
2826   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
2827   %ptr.a = bitcast i16* %gep.a to <16 x i16>*
2828   %ptr.b = bitcast i16* %gep.b to <16 x i16>*
2829   %load.a = load <16 x i16>, <16 x i16>* %ptr.a, align 2
2830   %load.b = load <16 x i16>, <16 x i16>* %ptr.b, align 2
2831   %cmp = icmp uge <16 x i16> %load.a, %load.b
2832   %sel = select <16 x i1> %cmp, <16 x i16> %load.b, <16 x i16> %load.a
2833   store <16 x i16> %sel, <16 x i16>* %ptr.a, align 2
2834   %index.next = add i64 %index, 16
2835   %loop = icmp eq i64 %index.next, 16384
2836   br i1 %loop, label %for.end, label %vector.body
2837
2838 for.end:                                          ; preds = %vector.body
2839   ret void
2840
2841 ; AVX2-LABEL: test88:
2842 ; AVX2: vpminuw
2843
2844 ; AVX512VL-LABEL: test88:
2845 ; AVX512VL: vpminuw
2846 }
2847
2848 define void @test89(i32* nocapture %a, i32* nocapture %b) nounwind {
2849 vector.ph:
2850   br label %vector.body
2851
2852 vector.body:                                      ; preds = %vector.body, %vector.ph
2853   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
2854   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
2855   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
2856   %ptr.a = bitcast i32* %gep.a to <8 x i32>*
2857   %ptr.b = bitcast i32* %gep.b to <8 x i32>*
2858   %load.a = load <8 x i32>, <8 x i32>* %ptr.a, align 2
2859   %load.b = load <8 x i32>, <8 x i32>* %ptr.b, align 2
2860   %cmp = icmp slt <8 x i32> %load.a, %load.b
2861   %sel = select <8 x i1> %cmp, <8 x i32> %load.b, <8 x i32> %load.a
2862   store <8 x i32> %sel, <8 x i32>* %ptr.a, align 2
2863   %index.next = add i64 %index, 8
2864   %loop = icmp eq i64 %index.next, 16384
2865   br i1 %loop, label %for.end, label %vector.body
2866
2867 for.end:                                          ; preds = %vector.body
2868   ret void
2869
2870 ; AVX2-LABEL: test89:
2871 ; AVX2: vpmaxsd
2872
2873 ; AVX512VL-LABEL: test89:
2874 ; AVX512VL: vpmaxsd
2875 }
2876
2877 define void @test90(i32* nocapture %a, i32* nocapture %b) nounwind {
2878 vector.ph:
2879   br label %vector.body
2880
2881 vector.body:                                      ; preds = %vector.body, %vector.ph
2882   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
2883   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
2884   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
2885   %ptr.a = bitcast i32* %gep.a to <8 x i32>*
2886   %ptr.b = bitcast i32* %gep.b to <8 x i32>*
2887   %load.a = load <8 x i32>, <8 x i32>* %ptr.a, align 2
2888   %load.b = load <8 x i32>, <8 x i32>* %ptr.b, align 2
2889   %cmp = icmp sle <8 x i32> %load.a, %load.b
2890   %sel = select <8 x i1> %cmp, <8 x i32> %load.b, <8 x i32> %load.a
2891   store <8 x i32> %sel, <8 x i32>* %ptr.a, align 2
2892   %index.next = add i64 %index, 8
2893   %loop = icmp eq i64 %index.next, 16384
2894   br i1 %loop, label %for.end, label %vector.body
2895
2896 for.end:                                          ; preds = %vector.body
2897   ret void
2898
2899 ; AVX2-LABEL: test90:
2900 ; AVX2: vpmaxsd
2901
2902 ; AVX512VL-LABEL: test90:
2903 ; AVX512VL: vpmaxsd
2904 }
2905
2906 define void @test91(i32* nocapture %a, i32* nocapture %b) nounwind {
2907 vector.ph:
2908   br label %vector.body
2909
2910 vector.body:                                      ; preds = %vector.body, %vector.ph
2911   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
2912   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
2913   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
2914   %ptr.a = bitcast i32* %gep.a to <8 x i32>*
2915   %ptr.b = bitcast i32* %gep.b to <8 x i32>*
2916   %load.a = load <8 x i32>, <8 x i32>* %ptr.a, align 2
2917   %load.b = load <8 x i32>, <8 x i32>* %ptr.b, align 2
2918   %cmp = icmp sgt <8 x i32> %load.a, %load.b
2919   %sel = select <8 x i1> %cmp, <8 x i32> %load.b, <8 x i32> %load.a
2920   store <8 x i32> %sel, <8 x i32>* %ptr.a, align 2
2921   %index.next = add i64 %index, 8
2922   %loop = icmp eq i64 %index.next, 16384
2923   br i1 %loop, label %for.end, label %vector.body
2924
2925 for.end:                                          ; preds = %vector.body
2926   ret void
2927
2928 ; AVX2-LABEL: test91:
2929 ; AVX2: vpminsd
2930
2931 ; AVX512VL-LABEL: test91:
2932 ; AVX512VL: vpminsd
2933 }
2934
2935 define void @test92(i32* nocapture %a, i32* nocapture %b) nounwind {
2936 vector.ph:
2937   br label %vector.body
2938
2939 vector.body:                                      ; preds = %vector.body, %vector.ph
2940   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
2941   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
2942   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
2943   %ptr.a = bitcast i32* %gep.a to <8 x i32>*
2944   %ptr.b = bitcast i32* %gep.b to <8 x i32>*
2945   %load.a = load <8 x i32>, <8 x i32>* %ptr.a, align 2
2946   %load.b = load <8 x i32>, <8 x i32>* %ptr.b, align 2
2947   %cmp = icmp sge <8 x i32> %load.a, %load.b
2948   %sel = select <8 x i1> %cmp, <8 x i32> %load.b, <8 x i32> %load.a
2949   store <8 x i32> %sel, <8 x i32>* %ptr.a, align 2
2950   %index.next = add i64 %index, 8
2951   %loop = icmp eq i64 %index.next, 16384
2952   br i1 %loop, label %for.end, label %vector.body
2953
2954 for.end:                                          ; preds = %vector.body
2955   ret void
2956
2957 ; AVX2-LABEL: test92:
2958 ; AVX2: vpminsd
2959
2960 ; AVX512VL-LABEL: test92:
2961 ; AVX512VL: vpminsd
2962 }
2963
2964 define void @test93(i32* nocapture %a, i32* nocapture %b) nounwind {
2965 vector.ph:
2966   br label %vector.body
2967
2968 vector.body:                                      ; preds = %vector.body, %vector.ph
2969   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
2970   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
2971   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
2972   %ptr.a = bitcast i32* %gep.a to <8 x i32>*
2973   %ptr.b = bitcast i32* %gep.b to <8 x i32>*
2974   %load.a = load <8 x i32>, <8 x i32>* %ptr.a, align 2
2975   %load.b = load <8 x i32>, <8 x i32>* %ptr.b, align 2
2976   %cmp = icmp ult <8 x i32> %load.a, %load.b
2977   %sel = select <8 x i1> %cmp, <8 x i32> %load.b, <8 x i32> %load.a
2978   store <8 x i32> %sel, <8 x i32>* %ptr.a, align 2
2979   %index.next = add i64 %index, 8
2980   %loop = icmp eq i64 %index.next, 16384
2981   br i1 %loop, label %for.end, label %vector.body
2982
2983 for.end:                                          ; preds = %vector.body
2984   ret void
2985
2986 ; AVX2-LABEL: test93:
2987 ; AVX2: vpmaxud
2988
2989 ; AVX512VL-LABEL: test93:
2990 ; AVX512VL: vpmaxud
2991 }
2992
2993 define void @test94(i32* nocapture %a, i32* nocapture %b) nounwind {
2994 vector.ph:
2995   br label %vector.body
2996
2997 vector.body:                                      ; preds = %vector.body, %vector.ph
2998   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
2999   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
3000   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
3001   %ptr.a = bitcast i32* %gep.a to <8 x i32>*
3002   %ptr.b = bitcast i32* %gep.b to <8 x i32>*
3003   %load.a = load <8 x i32>, <8 x i32>* %ptr.a, align 2
3004   %load.b = load <8 x i32>, <8 x i32>* %ptr.b, align 2
3005   %cmp = icmp ule <8 x i32> %load.a, %load.b
3006   %sel = select <8 x i1> %cmp, <8 x i32> %load.b, <8 x i32> %load.a
3007   store <8 x i32> %sel, <8 x i32>* %ptr.a, align 2
3008   %index.next = add i64 %index, 8
3009   %loop = icmp eq i64 %index.next, 16384
3010   br i1 %loop, label %for.end, label %vector.body
3011
3012 for.end:                                          ; preds = %vector.body
3013   ret void
3014
3015 ; AVX2-LABEL: test94:
3016 ; AVX2: vpmaxud
3017
3018 ; AVX512VL-LABEL: test94:
3019 ; AVX512VL: vpmaxud
3020 }
3021
3022 define void @test95(i32* nocapture %a, i32* nocapture %b) nounwind {
3023 vector.ph:
3024   br label %vector.body
3025
3026 vector.body:                                      ; preds = %vector.body, %vector.ph
3027   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
3028   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
3029   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
3030   %ptr.a = bitcast i32* %gep.a to <8 x i32>*
3031   %ptr.b = bitcast i32* %gep.b to <8 x i32>*
3032   %load.a = load <8 x i32>, <8 x i32>* %ptr.a, align 2
3033   %load.b = load <8 x i32>, <8 x i32>* %ptr.b, align 2
3034   %cmp = icmp ugt <8 x i32> %load.a, %load.b
3035   %sel = select <8 x i1> %cmp, <8 x i32> %load.b, <8 x i32> %load.a
3036   store <8 x i32> %sel, <8 x i32>* %ptr.a, align 2
3037   %index.next = add i64 %index, 8
3038   %loop = icmp eq i64 %index.next, 16384
3039   br i1 %loop, label %for.end, label %vector.body
3040
3041 for.end:                                          ; preds = %vector.body
3042   ret void
3043
3044 ; AVX2-LABEL: test95:
3045 ; AVX2: vpminud
3046
3047 ; AVX512VL-LABEL: test95:
3048 ; AVX512VL: vpminud
3049 }
3050
3051 define void @test96(i32* nocapture %a, i32* nocapture %b) nounwind {
3052 vector.ph:
3053   br label %vector.body
3054
3055 vector.body:                                      ; preds = %vector.body, %vector.ph
3056   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
3057   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
3058   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
3059   %ptr.a = bitcast i32* %gep.a to <8 x i32>*
3060   %ptr.b = bitcast i32* %gep.b to <8 x i32>*
3061   %load.a = load <8 x i32>, <8 x i32>* %ptr.a, align 2
3062   %load.b = load <8 x i32>, <8 x i32>* %ptr.b, align 2
3063   %cmp = icmp uge <8 x i32> %load.a, %load.b
3064   %sel = select <8 x i1> %cmp, <8 x i32> %load.b, <8 x i32> %load.a
3065   store <8 x i32> %sel, <8 x i32>* %ptr.a, align 2
3066   %index.next = add i64 %index, 8
3067   %loop = icmp eq i64 %index.next, 16384
3068   br i1 %loop, label %for.end, label %vector.body
3069
3070 for.end:                                          ; preds = %vector.body
3071   ret void
3072
3073 ; AVX2-LABEL: test96:
3074 ; AVX2: vpminud
3075
3076 ; AVX512VL-LABEL: test96:
3077 ; AVX512VL: vpminud
3078 }
3079
3080 ; ----------------------------
3081
3082 define void @test97(i8* nocapture %a, i8* nocapture %b) nounwind {
3083 vector.ph:
3084   br label %vector.body
3085
3086 vector.body:                                      ; preds = %vector.body, %vector.ph
3087   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
3088   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
3089   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
3090   %ptr.a = bitcast i8* %gep.a to <64 x i8>*
3091   %ptr.b = bitcast i8* %gep.b to <64 x i8>*
3092   %load.a = load <64 x i8>, <64 x i8>* %ptr.a, align 2
3093   %load.b = load <64 x i8>, <64 x i8>* %ptr.b, align 2
3094   %cmp = icmp slt <64 x i8> %load.a, %load.b
3095   %sel = select <64 x i1> %cmp, <64 x i8> %load.a, <64 x i8> %load.b
3096   store <64 x i8> %sel, <64 x i8>* %ptr.a, align 2
3097   %index.next = add i64 %index, 32
3098   %loop = icmp eq i64 %index.next, 16384
3099   br i1 %loop, label %for.end, label %vector.body
3100
3101 for.end:                                          ; preds = %vector.body
3102   ret void
3103
3104 ; AVX512BW-LABEL: test97:
3105 ; AVX512BW: vpminsb {{.*}}
3106 }
3107
3108 define void @test98(i8* nocapture %a, i8* nocapture %b) nounwind {
3109 vector.ph:
3110   br label %vector.body
3111
3112 vector.body:                                      ; preds = %vector.body, %vector.ph
3113   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
3114   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
3115   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
3116   %ptr.a = bitcast i8* %gep.a to <64 x i8>*
3117   %ptr.b = bitcast i8* %gep.b to <64 x i8>*
3118   %load.a = load <64 x i8>, <64 x i8>* %ptr.a, align 2
3119   %load.b = load <64 x i8>, <64 x i8>* %ptr.b, align 2
3120   %cmp = icmp sle <64 x i8> %load.a, %load.b
3121   %sel = select <64 x i1> %cmp, <64 x i8> %load.a, <64 x i8> %load.b
3122   store <64 x i8> %sel, <64 x i8>* %ptr.a, align 2
3123   %index.next = add i64 %index, 32
3124   %loop = icmp eq i64 %index.next, 16384
3125   br i1 %loop, label %for.end, label %vector.body
3126
3127 for.end:                                          ; preds = %vector.body
3128   ret void
3129
3130 ; AVX512BW-LABEL: test98:
3131 ; AVX512BW: vpminsb {{.*}}
3132 }
3133
3134 define void @test99(i8* nocapture %a, i8* nocapture %b) nounwind {
3135 vector.ph:
3136   br label %vector.body
3137
3138 vector.body:                                      ; preds = %vector.body, %vector.ph
3139   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
3140   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
3141   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
3142   %ptr.a = bitcast i8* %gep.a to <64 x i8>*
3143   %ptr.b = bitcast i8* %gep.b to <64 x i8>*
3144   %load.a = load <64 x i8>, <64 x i8>* %ptr.a, align 2
3145   %load.b = load <64 x i8>, <64 x i8>* %ptr.b, align 2
3146   %cmp = icmp sgt <64 x i8> %load.a, %load.b
3147   %sel = select <64 x i1> %cmp, <64 x i8> %load.a, <64 x i8> %load.b
3148   store <64 x i8> %sel, <64 x i8>* %ptr.a, align 2
3149   %index.next = add i64 %index, 32
3150   %loop = icmp eq i64 %index.next, 16384
3151   br i1 %loop, label %for.end, label %vector.body
3152
3153 for.end:                                          ; preds = %vector.body
3154   ret void
3155
3156 ; AVX512BW-LABEL: test99:
3157 ; AVX512BW: vpmaxsb {{.*}}
3158 }
3159
3160 define void @test100(i8* nocapture %a, i8* nocapture %b) nounwind {
3161 vector.ph:
3162   br label %vector.body
3163
3164 vector.body:                                      ; preds = %vector.body, %vector.ph
3165   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
3166   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
3167   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
3168   %ptr.a = bitcast i8* %gep.a to <64 x i8>*
3169   %ptr.b = bitcast i8* %gep.b to <64 x i8>*
3170   %load.a = load <64 x i8>, <64 x i8>* %ptr.a, align 2
3171   %load.b = load <64 x i8>, <64 x i8>* %ptr.b, align 2
3172   %cmp = icmp sge <64 x i8> %load.a, %load.b
3173   %sel = select <64 x i1> %cmp, <64 x i8> %load.a, <64 x i8> %load.b
3174   store <64 x i8> %sel, <64 x i8>* %ptr.a, align 2
3175   %index.next = add i64 %index, 32
3176   %loop = icmp eq i64 %index.next, 16384
3177   br i1 %loop, label %for.end, label %vector.body
3178
3179 for.end:                                          ; preds = %vector.body
3180   ret void
3181
3182 ; AVX512BW-LABEL: test100:
3183 ; AVX512BW: vpmaxsb {{.*}}
3184 }
3185
3186 define void @test101(i8* nocapture %a, i8* nocapture %b) nounwind {
3187 vector.ph:
3188   br label %vector.body
3189
3190 vector.body:                                      ; preds = %vector.body, %vector.ph
3191   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
3192   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
3193   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
3194   %ptr.a = bitcast i8* %gep.a to <64 x i8>*
3195   %ptr.b = bitcast i8* %gep.b to <64 x i8>*
3196   %load.a = load <64 x i8>, <64 x i8>* %ptr.a, align 2
3197   %load.b = load <64 x i8>, <64 x i8>* %ptr.b, align 2
3198   %cmp = icmp ult <64 x i8> %load.a, %load.b
3199   %sel = select <64 x i1> %cmp, <64 x i8> %load.a, <64 x i8> %load.b
3200   store <64 x i8> %sel, <64 x i8>* %ptr.a, align 2
3201   %index.next = add i64 %index, 32
3202   %loop = icmp eq i64 %index.next, 16384
3203   br i1 %loop, label %for.end, label %vector.body
3204
3205 for.end:                                          ; preds = %vector.body
3206   ret void
3207
3208 ; AVX512BW-LABEL: test101:
3209 ; AVX512BW: vpminub {{.*}}
3210 }
3211
3212 define void @test102(i8* nocapture %a, i8* nocapture %b) nounwind {
3213 vector.ph:
3214   br label %vector.body
3215
3216 vector.body:                                      ; preds = %vector.body, %vector.ph
3217   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
3218   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
3219   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
3220   %ptr.a = bitcast i8* %gep.a to <64 x i8>*
3221   %ptr.b = bitcast i8* %gep.b to <64 x i8>*
3222   %load.a = load <64 x i8>, <64 x i8>* %ptr.a, align 2
3223   %load.b = load <64 x i8>, <64 x i8>* %ptr.b, align 2
3224   %cmp = icmp ule <64 x i8> %load.a, %load.b
3225   %sel = select <64 x i1> %cmp, <64 x i8> %load.a, <64 x i8> %load.b
3226   store <64 x i8> %sel, <64 x i8>* %ptr.a, align 2
3227   %index.next = add i64 %index, 32
3228   %loop = icmp eq i64 %index.next, 16384
3229   br i1 %loop, label %for.end, label %vector.body
3230
3231 for.end:                                          ; preds = %vector.body
3232   ret void
3233
3234 ; AVX512BW-LABEL: test102:
3235 ; AVX512BW: vpminub {{.*}}
3236 }
3237
3238 define void @test103(i8* nocapture %a, i8* nocapture %b) nounwind {
3239 vector.ph:
3240   br label %vector.body
3241
3242 vector.body:                                      ; preds = %vector.body, %vector.ph
3243   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
3244   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
3245   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
3246   %ptr.a = bitcast i8* %gep.a to <64 x i8>*
3247   %ptr.b = bitcast i8* %gep.b to <64 x i8>*
3248   %load.a = load <64 x i8>, <64 x i8>* %ptr.a, align 2
3249   %load.b = load <64 x i8>, <64 x i8>* %ptr.b, align 2
3250   %cmp = icmp ugt <64 x i8> %load.a, %load.b
3251   %sel = select <64 x i1> %cmp, <64 x i8> %load.a, <64 x i8> %load.b
3252   store <64 x i8> %sel, <64 x i8>* %ptr.a, align 2
3253   %index.next = add i64 %index, 32
3254   %loop = icmp eq i64 %index.next, 16384
3255   br i1 %loop, label %for.end, label %vector.body
3256
3257 for.end:                                          ; preds = %vector.body
3258   ret void
3259
3260 ; AVX512BW-LABEL: test103:
3261 ; AVX512BW: vpmaxub {{.*}}
3262 }
3263
3264 define void @test104(i8* nocapture %a, i8* nocapture %b) nounwind {
3265 vector.ph:
3266   br label %vector.body
3267
3268 vector.body:                                      ; preds = %vector.body, %vector.ph
3269   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
3270   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
3271   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
3272   %ptr.a = bitcast i8* %gep.a to <64 x i8>*
3273   %ptr.b = bitcast i8* %gep.b to <64 x i8>*
3274   %load.a = load <64 x i8>, <64 x i8>* %ptr.a, align 2
3275   %load.b = load <64 x i8>, <64 x i8>* %ptr.b, align 2
3276   %cmp = icmp uge <64 x i8> %load.a, %load.b
3277   %sel = select <64 x i1> %cmp, <64 x i8> %load.a, <64 x i8> %load.b
3278   store <64 x i8> %sel, <64 x i8>* %ptr.a, align 2
3279   %index.next = add i64 %index, 32
3280   %loop = icmp eq i64 %index.next, 16384
3281   br i1 %loop, label %for.end, label %vector.body
3282
3283 for.end:                                          ; preds = %vector.body
3284   ret void
3285
3286 ; AVX512BW-LABEL: test104:
3287 ; AVX512BW: vpmaxub {{.*}}
3288 }
3289
3290 define void @test105(i16* nocapture %a, i16* nocapture %b) nounwind {
3291 vector.ph:
3292   br label %vector.body
3293
3294 vector.body:                                      ; preds = %vector.body, %vector.ph
3295   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
3296   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
3297   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
3298   %ptr.a = bitcast i16* %gep.a to <32 x i16>*
3299   %ptr.b = bitcast i16* %gep.b to <32 x i16>*
3300   %load.a = load <32 x i16>, <32 x i16>* %ptr.a, align 2
3301   %load.b = load <32 x i16>, <32 x i16>* %ptr.b, align 2
3302   %cmp = icmp slt <32 x i16> %load.a, %load.b
3303   %sel = select <32 x i1> %cmp, <32 x i16> %load.a, <32 x i16> %load.b
3304   store <32 x i16> %sel, <32 x i16>* %ptr.a, align 2
3305   %index.next = add i64 %index, 16
3306   %loop = icmp eq i64 %index.next, 16384
3307   br i1 %loop, label %for.end, label %vector.body
3308
3309 for.end:                                          ; preds = %vector.body
3310   ret void
3311
3312 ; AVX512BW-LABEL: test105:
3313 ; AVX512BW: vpminsw {{.*}}
3314 }
3315
3316 define void @test106(i16* nocapture %a, i16* nocapture %b) nounwind {
3317 vector.ph:
3318   br label %vector.body
3319
3320 vector.body:                                      ; preds = %vector.body, %vector.ph
3321   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
3322   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
3323   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
3324   %ptr.a = bitcast i16* %gep.a to <32 x i16>*
3325   %ptr.b = bitcast i16* %gep.b to <32 x i16>*
3326   %load.a = load <32 x i16>, <32 x i16>* %ptr.a, align 2
3327   %load.b = load <32 x i16>, <32 x i16>* %ptr.b, align 2
3328   %cmp = icmp sle <32 x i16> %load.a, %load.b
3329   %sel = select <32 x i1> %cmp, <32 x i16> %load.a, <32 x i16> %load.b
3330   store <32 x i16> %sel, <32 x i16>* %ptr.a, align 2
3331   %index.next = add i64 %index, 16
3332   %loop = icmp eq i64 %index.next, 16384
3333   br i1 %loop, label %for.end, label %vector.body
3334
3335 for.end:                                          ; preds = %vector.body
3336   ret void
3337
3338 ; AVX512BW-LABEL: test106:
3339 ; AVX512BW: vpminsw {{.*}}
3340 }
3341
3342 define void @test107(i16* nocapture %a, i16* nocapture %b) nounwind {
3343 vector.ph:
3344   br label %vector.body
3345
3346 vector.body:                                      ; preds = %vector.body, %vector.ph
3347   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
3348   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
3349   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
3350   %ptr.a = bitcast i16* %gep.a to <32 x i16>*
3351   %ptr.b = bitcast i16* %gep.b to <32 x i16>*
3352   %load.a = load <32 x i16>, <32 x i16>* %ptr.a, align 2
3353   %load.b = load <32 x i16>, <32 x i16>* %ptr.b, align 2
3354   %cmp = icmp sgt <32 x i16> %load.a, %load.b
3355   %sel = select <32 x i1> %cmp, <32 x i16> %load.a, <32 x i16> %load.b
3356   store <32 x i16> %sel, <32 x i16>* %ptr.a, align 2
3357   %index.next = add i64 %index, 16
3358   %loop = icmp eq i64 %index.next, 16384
3359   br i1 %loop, label %for.end, label %vector.body
3360
3361 for.end:                                          ; preds = %vector.body
3362   ret void
3363
3364 ; AVX512BW-LABEL: test107:
3365 ; AVX512BW: vpmaxsw {{.*}}
3366 }
3367
3368 define void @test108(i16* nocapture %a, i16* nocapture %b) nounwind {
3369 vector.ph:
3370   br label %vector.body
3371
3372 vector.body:                                      ; preds = %vector.body, %vector.ph
3373   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
3374   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
3375   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
3376   %ptr.a = bitcast i16* %gep.a to <32 x i16>*
3377   %ptr.b = bitcast i16* %gep.b to <32 x i16>*
3378   %load.a = load <32 x i16>, <32 x i16>* %ptr.a, align 2
3379   %load.b = load <32 x i16>, <32 x i16>* %ptr.b, align 2
3380   %cmp = icmp sge <32 x i16> %load.a, %load.b
3381   %sel = select <32 x i1> %cmp, <32 x i16> %load.a, <32 x i16> %load.b
3382   store <32 x i16> %sel, <32 x i16>* %ptr.a, align 2
3383   %index.next = add i64 %index, 16
3384   %loop = icmp eq i64 %index.next, 16384
3385   br i1 %loop, label %for.end, label %vector.body
3386
3387 for.end:                                          ; preds = %vector.body
3388   ret void
3389
3390 ; AVX512BW-LABEL: test108:
3391 ; AVX512BW: vpmaxsw {{.*}}
3392 }
3393
3394 define void @test109(i16* nocapture %a, i16* nocapture %b) nounwind {
3395 vector.ph:
3396   br label %vector.body
3397
3398 vector.body:                                      ; preds = %vector.body, %vector.ph
3399   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
3400   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
3401   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
3402   %ptr.a = bitcast i16* %gep.a to <32 x i16>*
3403   %ptr.b = bitcast i16* %gep.b to <32 x i16>*
3404   %load.a = load <32 x i16>, <32 x i16>* %ptr.a, align 2
3405   %load.b = load <32 x i16>, <32 x i16>* %ptr.b, align 2
3406   %cmp = icmp ult <32 x i16> %load.a, %load.b
3407   %sel = select <32 x i1> %cmp, <32 x i16> %load.a, <32 x i16> %load.b
3408   store <32 x i16> %sel, <32 x i16>* %ptr.a, align 2
3409   %index.next = add i64 %index, 16
3410   %loop = icmp eq i64 %index.next, 16384
3411   br i1 %loop, label %for.end, label %vector.body
3412
3413 for.end:                                          ; preds = %vector.body
3414   ret void
3415
3416 ; AVX512BW-LABEL: test109:
3417 ; AVX512BW: vpminuw {{.*}}
3418 }
3419
3420 define void @test110(i16* nocapture %a, i16* nocapture %b) nounwind {
3421 vector.ph:
3422   br label %vector.body
3423
3424 vector.body:                                      ; preds = %vector.body, %vector.ph
3425   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
3426   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
3427   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
3428   %ptr.a = bitcast i16* %gep.a to <32 x i16>*
3429   %ptr.b = bitcast i16* %gep.b to <32 x i16>*
3430   %load.a = load <32 x i16>, <32 x i16>* %ptr.a, align 2
3431   %load.b = load <32 x i16>, <32 x i16>* %ptr.b, align 2
3432   %cmp = icmp ule <32 x i16> %load.a, %load.b
3433   %sel = select <32 x i1> %cmp, <32 x i16> %load.a, <32 x i16> %load.b
3434   store <32 x i16> %sel, <32 x i16>* %ptr.a, align 2
3435   %index.next = add i64 %index, 16
3436   %loop = icmp eq i64 %index.next, 16384
3437   br i1 %loop, label %for.end, label %vector.body
3438
3439 for.end:                                          ; preds = %vector.body
3440   ret void
3441
3442 ; AVX512BW-LABEL: test110:
3443 ; AVX512BW: vpminuw {{.*}}
3444 }
3445
3446 define void @test111(i16* nocapture %a, i16* nocapture %b) nounwind {
3447 vector.ph:
3448   br label %vector.body
3449
3450 vector.body:                                      ; preds = %vector.body, %vector.ph
3451   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
3452   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
3453   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
3454   %ptr.a = bitcast i16* %gep.a to <32 x i16>*
3455   %ptr.b = bitcast i16* %gep.b to <32 x i16>*
3456   %load.a = load <32 x i16>, <32 x i16>* %ptr.a, align 2
3457   %load.b = load <32 x i16>, <32 x i16>* %ptr.b, align 2
3458   %cmp = icmp ugt <32 x i16> %load.a, %load.b
3459   %sel = select <32 x i1> %cmp, <32 x i16> %load.a, <32 x i16> %load.b
3460   store <32 x i16> %sel, <32 x i16>* %ptr.a, align 2
3461   %index.next = add i64 %index, 16
3462   %loop = icmp eq i64 %index.next, 16384
3463   br i1 %loop, label %for.end, label %vector.body
3464
3465 for.end:                                          ; preds = %vector.body
3466   ret void
3467
3468 ; AVX512BW-LABEL: test111:
3469 ; AVX512BW: vpmaxuw {{.*}}
3470 }
3471
3472 define void @test112(i16* nocapture %a, i16* nocapture %b) nounwind {
3473 vector.ph:
3474   br label %vector.body
3475
3476 vector.body:                                      ; preds = %vector.body, %vector.ph
3477   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
3478   %gep.a = getelementptr inbounds i16, i16* %a, i64 %index
3479   %gep.b = getelementptr inbounds i16, i16* %b, i64 %index
3480   %ptr.a = bitcast i16* %gep.a to <32 x i16>*
3481   %ptr.b = bitcast i16* %gep.b to <32 x i16>*
3482   %load.a = load <32 x i16>, <32 x i16>* %ptr.a, align 2
3483   %load.b = load <32 x i16>, <32 x i16>* %ptr.b, align 2
3484   %cmp = icmp uge <32 x i16> %load.a, %load.b
3485   %sel = select <32 x i1> %cmp, <32 x i16> %load.a, <32 x i16> %load.b
3486   store <32 x i16> %sel, <32 x i16>* %ptr.a, align 2
3487   %index.next = add i64 %index, 16
3488   %loop = icmp eq i64 %index.next, 16384
3489   br i1 %loop, label %for.end, label %vector.body
3490
3491 for.end:                                          ; preds = %vector.body
3492   ret void
3493
3494 ; AVX512BW-LABEL: test112:
3495 ; AVX512BW: vpmaxuw {{.*}}
3496 }
3497
3498 define void @test113(i32* nocapture %a, i32* nocapture %b) nounwind {
3499 vector.ph:
3500   br label %vector.body
3501
3502 vector.body:                                      ; preds = %vector.body, %vector.ph
3503   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
3504   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
3505   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
3506   %ptr.a = bitcast i32* %gep.a to <16 x i32>*
3507   %ptr.b = bitcast i32* %gep.b to <16 x i32>*
3508   %load.a = load <16 x i32>, <16 x i32>* %ptr.a, align 2
3509   %load.b = load <16 x i32>, <16 x i32>* %ptr.b, align 2
3510   %cmp = icmp slt <16 x i32> %load.a, %load.b
3511   %sel = select <16 x i1> %cmp, <16 x i32> %load.a, <16 x i32> %load.b
3512   store <16 x i32> %sel, <16 x i32>* %ptr.a, align 2
3513   %index.next = add i64 %index, 8
3514   %loop = icmp eq i64 %index.next, 16384
3515   br i1 %loop, label %for.end, label %vector.body
3516
3517 for.end:                                          ; preds = %vector.body
3518   ret void
3519
3520 ; AVX512F-LABEL: test113:
3521 ; AVX512F: vpminsd {{.*}}
3522 }
3523
3524 define void @test114(i32* nocapture %a, i32* nocapture %b) nounwind {
3525 vector.ph:
3526   br label %vector.body
3527
3528 vector.body:                                      ; preds = %vector.body, %vector.ph
3529   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
3530   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
3531   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
3532   %ptr.a = bitcast i32* %gep.a to <16 x i32>*
3533   %ptr.b = bitcast i32* %gep.b to <16 x i32>*
3534   %load.a = load <16 x i32>, <16 x i32>* %ptr.a, align 2
3535   %load.b = load <16 x i32>, <16 x i32>* %ptr.b, align 2
3536   %cmp = icmp sle <16 x i32> %load.a, %load.b
3537   %sel = select <16 x i1> %cmp, <16 x i32> %load.a, <16 x i32> %load.b
3538   store <16 x i32> %sel, <16 x i32>* %ptr.a, align 2
3539   %index.next = add i64 %index, 8
3540   %loop = icmp eq i64 %index.next, 16384
3541   br i1 %loop, label %for.end, label %vector.body
3542
3543 for.end:                                          ; preds = %vector.body
3544   ret void
3545
3546 ; AVX512F-LABEL: test114:
3547 ; AVX512F: vpminsd {{.*}}
3548 }
3549
3550 define void @test115(i32* nocapture %a, i32* nocapture %b) nounwind {
3551 vector.ph:
3552   br label %vector.body
3553
3554 vector.body:                                      ; preds = %vector.body, %vector.ph
3555   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
3556   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
3557   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
3558   %ptr.a = bitcast i32* %gep.a to <16 x i32>*
3559   %ptr.b = bitcast i32* %gep.b to <16 x i32>*
3560   %load.a = load <16 x i32>, <16 x i32>* %ptr.a, align 2
3561   %load.b = load <16 x i32>, <16 x i32>* %ptr.b, align 2
3562   %cmp = icmp sgt <16 x i32> %load.a, %load.b
3563   %sel = select <16 x i1> %cmp, <16 x i32> %load.a, <16 x i32> %load.b
3564   store <16 x i32> %sel, <16 x i32>* %ptr.a, align 2
3565   %index.next = add i64 %index, 8
3566   %loop = icmp eq i64 %index.next, 16384
3567   br i1 %loop, label %for.end, label %vector.body
3568
3569 for.end:                                          ; preds = %vector.body
3570   ret void
3571
3572 ; AVX512F-LABEL: test115:
3573 ; AVX512F: vpmaxsd {{.*}}
3574 }
3575
3576 define void @test116(i32* nocapture %a, i32* nocapture %b) nounwind {
3577 vector.ph:
3578   br label %vector.body
3579
3580 vector.body:                                      ; preds = %vector.body, %vector.ph
3581   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
3582   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
3583   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
3584   %ptr.a = bitcast i32* %gep.a to <16 x i32>*
3585   %ptr.b = bitcast i32* %gep.b to <16 x i32>*
3586   %load.a = load <16 x i32>, <16 x i32>* %ptr.a, align 2
3587   %load.b = load <16 x i32>, <16 x i32>* %ptr.b, align 2
3588   %cmp = icmp sge <16 x i32> %load.a, %load.b
3589   %sel = select <16 x i1> %cmp, <16 x i32> %load.a, <16 x i32> %load.b
3590   store <16 x i32> %sel, <16 x i32>* %ptr.a, align 2
3591   %index.next = add i64 %index, 8
3592   %loop = icmp eq i64 %index.next, 16384
3593   br i1 %loop, label %for.end, label %vector.body
3594
3595 for.end:                                          ; preds = %vector.body
3596   ret void
3597
3598 ; AVX512F-LABEL: test116:
3599 ; AVX512F: vpmaxsd {{.*}}
3600 }
3601
3602 define void @test117(i32* nocapture %a, i32* nocapture %b) nounwind {
3603 vector.ph:
3604   br label %vector.body
3605
3606 vector.body:                                      ; preds = %vector.body, %vector.ph
3607   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
3608   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
3609   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
3610   %ptr.a = bitcast i32* %gep.a to <16 x i32>*
3611   %ptr.b = bitcast i32* %gep.b to <16 x i32>*
3612   %load.a = load <16 x i32>, <16 x i32>* %ptr.a, align 2
3613   %load.b = load <16 x i32>, <16 x i32>* %ptr.b, align 2
3614   %cmp = icmp ult <16 x i32> %load.a, %load.b
3615   %sel = select <16 x i1> %cmp, <16 x i32> %load.a, <16 x i32> %load.b
3616   store <16 x i32> %sel, <16 x i32>* %ptr.a, align 2
3617   %index.next = add i64 %index, 8
3618   %loop = icmp eq i64 %index.next, 16384
3619   br i1 %loop, label %for.end, label %vector.body
3620
3621 for.end:                                          ; preds = %vector.body
3622   ret void
3623
3624 ; AVX512F-LABEL: test117:
3625 ; AVX512F: vpminud {{.*}}
3626 }
3627
3628 define void @test118(i32* nocapture %a, i32* nocapture %b) nounwind {
3629 vector.ph:
3630   br label %vector.body
3631
3632 vector.body:                                      ; preds = %vector.body, %vector.ph
3633   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
3634   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
3635   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
3636   %ptr.a = bitcast i32* %gep.a to <16 x i32>*
3637   %ptr.b = bitcast i32* %gep.b to <16 x i32>*
3638   %load.a = load <16 x i32>, <16 x i32>* %ptr.a, align 2
3639   %load.b = load <16 x i32>, <16 x i32>* %ptr.b, align 2
3640   %cmp = icmp ule <16 x i32> %load.a, %load.b
3641   %sel = select <16 x i1> %cmp, <16 x i32> %load.a, <16 x i32> %load.b
3642   store <16 x i32> %sel, <16 x i32>* %ptr.a, align 2
3643   %index.next = add i64 %index, 8
3644   %loop = icmp eq i64 %index.next, 16384
3645   br i1 %loop, label %for.end, label %vector.body
3646
3647 for.end:                                          ; preds = %vector.body
3648   ret void
3649
3650 ; AVX512F-LABEL: test118:
3651 ; AVX512F: vpminud {{.*}}
3652 }
3653
3654 define void @test119(i32* nocapture %a, i32* nocapture %b) nounwind {
3655 vector.ph:
3656   br label %vector.body
3657
3658 vector.body:                                      ; preds = %vector.body, %vector.ph
3659   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
3660   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
3661   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
3662   %ptr.a = bitcast i32* %gep.a to <16 x i32>*
3663   %ptr.b = bitcast i32* %gep.b to <16 x i32>*
3664   %load.a = load <16 x i32>, <16 x i32>* %ptr.a, align 2
3665   %load.b = load <16 x i32>, <16 x i32>* %ptr.b, align 2
3666   %cmp = icmp ugt <16 x i32> %load.a, %load.b
3667   %sel = select <16 x i1> %cmp, <16 x i32> %load.a, <16 x i32> %load.b
3668   store <16 x i32> %sel, <16 x i32>* %ptr.a, align 2
3669   %index.next = add i64 %index, 8
3670   %loop = icmp eq i64 %index.next, 16384
3671   br i1 %loop, label %for.end, label %vector.body
3672
3673 for.end:                                          ; preds = %vector.body
3674   ret void
3675
3676 ; AVX512F-LABEL: test119:
3677 ; AVX512F: vpmaxud {{.*}}
3678 }
3679
3680 define void @test120(i32* nocapture %a, i32* nocapture %b) nounwind {
3681 vector.ph:
3682   br label %vector.body
3683
3684 vector.body:                                      ; preds = %vector.body, %vector.ph
3685   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
3686   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
3687   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
3688   %ptr.a = bitcast i32* %gep.a to <16 x i32>*
3689   %ptr.b = bitcast i32* %gep.b to <16 x i32>*
3690   %load.a = load <16 x i32>, <16 x i32>* %ptr.a, align 2
3691   %load.b = load <16 x i32>, <16 x i32>* %ptr.b, align 2
3692   %cmp = icmp uge <16 x i32> %load.a, %load.b
3693   %sel = select <16 x i1> %cmp, <16 x i32> %load.a, <16 x i32> %load.b
3694   store <16 x i32> %sel, <16 x i32>* %ptr.a, align 2
3695   %index.next = add i64 %index, 8
3696   %loop = icmp eq i64 %index.next, 16384
3697   br i1 %loop, label %for.end, label %vector.body
3698
3699 for.end:                                          ; preds = %vector.body
3700   ret void
3701
3702 ; AVX512F-LABEL: test120:
3703 ; AVX512F: vpmaxud {{.*}}
3704 }
3705
3706 define void @test121(i32* nocapture %a, i32* nocapture %b) nounwind {
3707 vector.ph:
3708   br label %vector.body
3709
3710 vector.body:                                      ; preds = %vector.body, %vector.ph
3711   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
3712   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
3713   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
3714   %ptr.a = bitcast i32* %gep.a to <8 x i64>*
3715   %ptr.b = bitcast i32* %gep.b to <8 x i64>*
3716   %load.a = load <8 x i64>, <8 x i64>* %ptr.a, align 2
3717   %load.b = load <8 x i64>, <8 x i64>* %ptr.b, align 2
3718   %cmp = icmp slt <8 x i64> %load.a, %load.b
3719   %sel = select <8 x i1> %cmp, <8 x i64> %load.a, <8 x i64> %load.b
3720   store <8 x i64> %sel, <8 x i64>* %ptr.a, align 2
3721   %index.next = add i64 %index, 8
3722   %loop = icmp eq i64 %index.next, 16384
3723   br i1 %loop, label %for.end, label %vector.body
3724
3725 for.end:                                          ; preds = %vector.body
3726   ret void
3727
3728 ; AVX512F-LABEL: test121:
3729 ; AVX512F: vpminsq {{.*}}
3730 }
3731
3732 define void @test122(i32* nocapture %a, i32* nocapture %b) nounwind {
3733 vector.ph:
3734   br label %vector.body
3735
3736 vector.body:                                      ; preds = %vector.body, %vector.ph
3737   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
3738   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
3739   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
3740   %ptr.a = bitcast i32* %gep.a to <8 x i64>*
3741   %ptr.b = bitcast i32* %gep.b to <8 x i64>*
3742   %load.a = load <8 x i64>, <8 x i64>* %ptr.a, align 2
3743   %load.b = load <8 x i64>, <8 x i64>* %ptr.b, align 2
3744   %cmp = icmp sle <8 x i64> %load.a, %load.b
3745   %sel = select <8 x i1> %cmp, <8 x i64> %load.a, <8 x i64> %load.b
3746   store <8 x i64> %sel, <8 x i64>* %ptr.a, align 2
3747   %index.next = add i64 %index, 8
3748   %loop = icmp eq i64 %index.next, 16384
3749   br i1 %loop, label %for.end, label %vector.body
3750
3751 for.end:                                          ; preds = %vector.body
3752   ret void
3753
3754 ; AVX512F-LABEL: test122:
3755 ; AVX512F: vpminsq {{.*}}
3756 }
3757
3758 define void @test123(i32* nocapture %a, i32* nocapture %b) nounwind {
3759 vector.ph:
3760   br label %vector.body
3761
3762 vector.body:                                      ; preds = %vector.body, %vector.ph
3763   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
3764   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
3765   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
3766   %ptr.a = bitcast i32* %gep.a to <8 x i64>*
3767   %ptr.b = bitcast i32* %gep.b to <8 x i64>*
3768   %load.a = load <8 x i64>, <8 x i64>* %ptr.a, align 2
3769   %load.b = load <8 x i64>, <8 x i64>* %ptr.b, align 2
3770   %cmp = icmp sgt <8 x i64> %load.a, %load.b
3771   %sel = select <8 x i1> %cmp, <8 x i64> %load.a, <8 x i64> %load.b
3772   store <8 x i64> %sel, <8 x i64>* %ptr.a, align 2
3773   %index.next = add i64 %index, 8
3774   %loop = icmp eq i64 %index.next, 16384
3775   br i1 %loop, label %for.end, label %vector.body
3776
3777 for.end:                                          ; preds = %vector.body
3778   ret void
3779
3780 ; AVX512F-LABEL: test123:
3781 ; AVX512F: vpmaxsq {{.*}}
3782 }
3783
3784 define void @test124(i32* nocapture %a, i32* nocapture %b) nounwind {
3785 vector.ph:
3786   br label %vector.body
3787
3788 vector.body:                                      ; preds = %vector.body, %vector.ph
3789   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
3790   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
3791   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
3792   %ptr.a = bitcast i32* %gep.a to <8 x i64>*
3793   %ptr.b = bitcast i32* %gep.b to <8 x i64>*
3794   %load.a = load <8 x i64>, <8 x i64>* %ptr.a, align 2
3795   %load.b = load <8 x i64>, <8 x i64>* %ptr.b, align 2
3796   %cmp = icmp sge <8 x i64> %load.a, %load.b
3797   %sel = select <8 x i1> %cmp, <8 x i64> %load.a, <8 x i64> %load.b
3798   store <8 x i64> %sel, <8 x i64>* %ptr.a, align 2
3799   %index.next = add i64 %index, 8
3800   %loop = icmp eq i64 %index.next, 16384
3801   br i1 %loop, label %for.end, label %vector.body
3802
3803 for.end:                                          ; preds = %vector.body
3804   ret void
3805
3806 ; AVX512F-LABEL: test124:
3807 ; AVX512F: vpmaxsq {{.*}}
3808 }
3809
3810 define void @test125(i32* nocapture %a, i32* nocapture %b) nounwind {
3811 vector.ph:
3812   br label %vector.body
3813
3814 vector.body:                                      ; preds = %vector.body, %vector.ph
3815   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
3816   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
3817   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
3818   %ptr.a = bitcast i32* %gep.a to <8 x i64>*
3819   %ptr.b = bitcast i32* %gep.b to <8 x i64>*
3820   %load.a = load <8 x i64>, <8 x i64>* %ptr.a, align 2
3821   %load.b = load <8 x i64>, <8 x i64>* %ptr.b, align 2
3822   %cmp = icmp ult <8 x i64> %load.a, %load.b
3823   %sel = select <8 x i1> %cmp, <8 x i64> %load.a, <8 x i64> %load.b
3824   store <8 x i64> %sel, <8 x i64>* %ptr.a, align 2
3825   %index.next = add i64 %index, 8
3826   %loop = icmp eq i64 %index.next, 16384
3827   br i1 %loop, label %for.end, label %vector.body
3828
3829 for.end:                                          ; preds = %vector.body
3830   ret void
3831
3832 ; AVX512F-LABEL: test125:
3833 ; AVX512F: vpminuq {{.*}}
3834 }
3835
3836 define void @test126(i32* nocapture %a, i32* nocapture %b) nounwind {
3837 vector.ph:
3838   br label %vector.body
3839
3840 vector.body:                                      ; preds = %vector.body, %vector.ph
3841   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
3842   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
3843   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
3844   %ptr.a = bitcast i32* %gep.a to <8 x i64>*
3845   %ptr.b = bitcast i32* %gep.b to <8 x i64>*
3846   %load.a = load <8 x i64>, <8 x i64>* %ptr.a, align 2
3847   %load.b = load <8 x i64>, <8 x i64>* %ptr.b, align 2
3848   %cmp = icmp ule <8 x i64> %load.a, %load.b
3849   %sel = select <8 x i1> %cmp, <8 x i64> %load.a, <8 x i64> %load.b
3850   store <8 x i64> %sel, <8 x i64>* %ptr.a, align 2
3851   %index.next = add i64 %index, 8
3852   %loop = icmp eq i64 %index.next, 16384
3853   br i1 %loop, label %for.end, label %vector.body
3854
3855 for.end:                                          ; preds = %vector.body
3856   ret void
3857
3858 ; AVX512F-LABEL: test126:
3859 ; AVX512F: vpminuq {{.*}}
3860 }
3861
3862 define void @test127(i32* nocapture %a, i32* nocapture %b) nounwind {
3863 vector.ph:
3864   br label %vector.body
3865
3866 vector.body:                                      ; preds = %vector.body, %vector.ph
3867   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
3868   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
3869   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
3870   %ptr.a = bitcast i32* %gep.a to <8 x i64>*
3871   %ptr.b = bitcast i32* %gep.b to <8 x i64>*
3872   %load.a = load <8 x i64>, <8 x i64>* %ptr.a, align 2
3873   %load.b = load <8 x i64>, <8 x i64>* %ptr.b, align 2
3874   %cmp = icmp ugt <8 x i64> %load.a, %load.b
3875   %sel = select <8 x i1> %cmp, <8 x i64> %load.a, <8 x i64> %load.b
3876   store <8 x i64> %sel, <8 x i64>* %ptr.a, align 2
3877   %index.next = add i64 %index, 8
3878   %loop = icmp eq i64 %index.next, 16384
3879   br i1 %loop, label %for.end, label %vector.body
3880
3881 for.end:                                          ; preds = %vector.body
3882   ret void
3883
3884 ; AVX512F-LABEL: test127:
3885 ; AVX512F: vpmaxuq {{.*}}
3886 }
3887
3888 define void @test128(i32* nocapture %a, i32* nocapture %b) nounwind {
3889 vector.ph:
3890   br label %vector.body
3891
3892 vector.body:                                      ; preds = %vector.body, %vector.ph
3893   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
3894   %gep.a = getelementptr inbounds i32, i32* %a, i64 %index
3895   %gep.b = getelementptr inbounds i32, i32* %b, i64 %index
3896   %ptr.a = bitcast i32* %gep.a to <8 x i64>*
3897   %ptr.b = bitcast i32* %gep.b to <8 x i64>*
3898   %load.a = load <8 x i64>, <8 x i64>* %ptr.a, align 2
3899   %load.b = load <8 x i64>, <8 x i64>* %ptr.b, align 2
3900   %cmp = icmp uge <8 x i64> %load.a, %load.b
3901   %sel = select <8 x i1> %cmp, <8 x i64> %load.a, <8 x i64> %load.b
3902   store <8 x i64> %sel, <8 x i64>* %ptr.a, align 2
3903   %index.next = add i64 %index, 8
3904   %loop = icmp eq i64 %index.next, 16384
3905   br i1 %loop, label %for.end, label %vector.body
3906
3907 for.end:                                          ; preds = %vector.body
3908   ret void
3909
3910 ; AVX512F-LABEL: test128:
3911 ; AVX512F: vpmaxuq {{.*}}
3912 }
3913
3914 define void @test129(i8* nocapture %a, i8* nocapture %b) nounwind {
3915 vector.ph:
3916   br label %vector.body
3917
3918 vector.body:                                      ; preds = %vector.body, %vector.ph
3919   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
3920   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
3921   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
3922   %ptr.a = bitcast i8* %gep.a to <64 x i8>*
3923   %ptr.b = bitcast i8* %gep.b to <64 x i8>*
3924   %load.a = load <64 x i8>, <64 x i8>* %ptr.a, align 2
3925   %load.b = load <64 x i8>, <64 x i8>* %ptr.b, align 2
3926   %cmp = icmp slt <64 x i8> %load.a, %load.b
3927   %sel = select <64 x i1> %cmp, <64 x i8> %load.b, <64 x i8> %load.a
3928   store <64 x i8> %sel, <64 x i8>* %ptr.a, align 2
3929   %index.next = add i64 %index, 32
3930   %loop = icmp eq i64 %index.next, 16384
3931   br i1 %loop, label %for.end, label %vector.body
3932
3933 for.end:                                          ; preds = %vector.body
3934   ret void
3935
3936 ; AVX512BW-LABEL: test129:
3937 ; AVX512BW: vpmaxsb
3938 }
3939
3940 define void @test130(i8* nocapture %a, i8* nocapture %b) nounwind {
3941 vector.ph:
3942   br label %vector.body
3943
3944 vector.body:                                      ; preds = %vector.body, %vector.ph
3945   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
3946   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
3947   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
3948   %ptr.a = bitcast i8* %gep.a to <64 x i8>*
3949   %ptr.b = bitcast i8* %gep.b to <64 x i8>*
3950   %load.a = load <64 x i8>, <64 x i8>* %ptr.a, align 2
3951   %load.b = load <64 x i8>, <64 x i8>* %ptr.b, align 2
3952   %cmp = icmp sle <64 x i8> %load.a, %load.b
3953   %sel = select <64 x i1> %cmp, <64 x i8> %load.b, <64 x i8> %load.a
3954   store <64 x i8> %sel, <64 x i8>* %ptr.a, align 2
3955   %index.next = add i64 %index, 32
3956   %loop = icmp eq i64 %index.next, 16384
3957   br i1 %loop, label %for.end, label %vector.body
3958
3959 for.end:                                          ; preds = %vector.body
3960   ret void
3961
3962 ; AVX512BW-LABEL: test130:
3963 ; AVX512BW: vpmaxsb
3964 }
3965
3966 define void @test131(i8* nocapture %a, i8* nocapture %b) nounwind {
3967 vector.ph:
3968   br label %vector.body
3969
3970 vector.body:                                      ; preds = %vector.body, %vector.ph
3971   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
3972   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index
3973   %gep.b = getelementptr inbounds i8, i8* %b, i64 %index
3974   %ptr.a = bitcast i8* %gep.a to <64 x i8>*
3975   %ptr.b = bitcast i8* %gep.b to <64 x i8>*
3976   %load.a = load <64 x i8>, <64 x i8>* %ptr.a, align 2
3977   %load.b = load <64 x i8>, <64 x i8>* %ptr.b, align 2
3978   %cmp = icmp sgt <64 x i8> %load.a, %load.b
3979   %sel = select <64 x i1> %cmp, <64 x i8> %load.b, <64 x i8> %load.a
3980   store <64 x i8> %sel, <64 x i8>* %ptr.a, align 2
3981   %index.next = add i64 %index, 32
3982   %loop = icmp eq i64 %index.next, 16384
3983   br i1 %loop, label %for.end, label %vector.body
3984
3985 for.end:                                          ; preds = %vector.body
3986   ret void
3987
3988 ; AVX512BW-LABEL: test131:
3989 ; AVX512BW: vpminsb
3990 }
3991
3992 define void @test132(i8* nocapture %a, i8* nocapture %b) nounwind {
3993 vector.ph:
3994   br label %vector.body
3995
3996 vector.body:                                      ; preds = %vector.body, %vector.ph
3997   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
3998   %gep.a = getelementptr inbounds i8, i8* %a, i64 %index