| blob | 4e3832f31e5a4c626ed7d38ccb813bfa6453845e |
1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
2 ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
4 ; There are 12 basic patterns (or 6 with DeMorganized equivalent) with
5 ; 2 (commute logic op) *
6 ; 2 (swap compare operands) *
7 ; 2 (signed/unsigned) *
8 ; 2 (not of input operand)
9 ; variations for a total of 192 tests.
11 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
12 ;
13 ; (X == MAX) && (X < Y) --> false
14 ;
15 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
17 define i1 @slt_and_max(i8 %x, i8 %y) {
18 ; CHECK-LABEL: @slt_and_max(
19 ; CHECK-NEXT: ret i1 false
20 ;
21 %cmp = icmp slt i8 %x, %y
22 %cmpeq = icmp eq i8 %x, 127
23 %r = and i1 %cmp, %cmpeq
24 ret i1 %r
25 }
27 define <2 x i1> @slt_and_max_commute(<2 x i8> %x, <2 x i8> %y) {
28 ; CHECK-LABEL: @slt_and_max_commute(
29 ; CHECK-NEXT: ret <2 x i1> zeroinitializer
30 ;
31 %cmp = icmp slt <2 x i8> %x, %y
32 %cmpeq = icmp eq <2 x i8> %x, <i8 127, i8 127>
33 %r = and <2 x i1> %cmpeq, %cmp
34 ret <2 x i1> %r
35 }
37 define i1 @slt_swap_and_max(i8 %x, i8 %y) {
38 ; CHECK-LABEL: @slt_swap_and_max(
39 ; CHECK-NEXT: ret i1 false
40 ;
41 %cmp = icmp sgt i8 %y, %x
42 %cmpeq = icmp eq i8 %x, 127
43 %r = and i1 %cmp, %cmpeq
44 ret i1 %r
45 }
47 define i1 @slt_swap_and_max_commute(i8 %x, i8 %y) {
48 ; CHECK-LABEL: @slt_swap_and_max_commute(
49 ; CHECK-NEXT: ret i1 false
50 ;
51 %cmp = icmp sgt i8 %y, %x
52 %cmpeq = icmp eq i8 %x, 127
53 %r = and i1 %cmpeq, %cmp
54 ret i1 %r
55 }
57 define i1 @ult_and_max(i8 %x, i8 %y) {
58 ; CHECK-LABEL: @ult_and_max(
59 ; CHECK-NEXT: ret i1 false
60 ;
61 %cmp = icmp ult i8 %x, %y
62 %cmpeq = icmp eq i8 %x, 255
63 %r = and i1 %cmp, %cmpeq
64 ret i1 %r
65 }
67 define i1 @ult_and_max_commute(i8 %x, i8 %y) {
68 ; CHECK-LABEL: @ult_and_max_commute(
69 ; CHECK-NEXT: ret i1 false
70 ;
71 %cmp = icmp ult i8 %x, %y
72 %cmpeq = icmp eq i8 %x, 255
73 %r = and i1 %cmpeq, %cmp
74 ret i1 %r
75 }
77 define i1 @ult_swap_and_max(i8 %x, i8 %y) {
78 ; CHECK-LABEL: @ult_swap_and_max(
79 ; CHECK-NEXT: ret i1 false
80 ;
81 %cmp = icmp ugt i8 %y, %x
82 %cmpeq = icmp eq i8 %x, 255
83 %r = and i1 %cmp, %cmpeq
84 ret i1 %r
85 }
87 define i1 @ult_swap_and_max_commute(i8 %x, i8 %y) {
88 ; CHECK-LABEL: @ult_swap_and_max_commute(
89 ; CHECK-NEXT: ret i1 false
90 ;
91 %cmp = icmp ugt i8 %y, %x
92 %cmpeq = icmp eq i8 %x, 255
93 %r = and i1 %cmpeq, %cmp
94 ret i1 %r
95 }
97 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
98 ;
99 ; (X == MIN) && (X > Y) --> false
100 ;
101 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
103 define i1 @sgt_and_min(i9 %x, i9 %y) {
104 ; CHECK-LABEL: @sgt_and_min(
105 ; CHECK-NEXT: ret i1 false
106 ;
107 %cmp = icmp sgt i9 %x, %y
108 %cmpeq = icmp eq i9 %x, 256
109 %r = and i1 %cmp, %cmpeq
110 ret i1 %r
111 }
113 define i1 @sgt_and_min_commute(i8 %x, i8 %y) {
114 ; CHECK-LABEL: @sgt_and_min_commute(
115 ; CHECK-NEXT: ret i1 false
116 ;
117 %cmp = icmp sgt i8 %x, %y
118 %cmpeq = icmp eq i8 %x, 128
119 %r = and i1 %cmpeq, %cmp
120 ret i1 %r
121 }
123 define i1 @sgt_swap_and_min(i8 %x, i8 %y) {
124 ; CHECK-LABEL: @sgt_swap_and_min(
125 ; CHECK-NEXT: ret i1 false
126 ;
127 %cmp = icmp slt i8 %y, %x
128 %cmpeq = icmp eq i8 %x, 128
129 %r = and i1 %cmp, %cmpeq
130 ret i1 %r
131 }
133 define i1 @sgt_swap_and_min_commute(i8 %x, i8 %y) {
134 ; CHECK-LABEL: @sgt_swap_and_min_commute(
135 ; CHECK-NEXT: ret i1 false
136 ;
137 %cmp = icmp slt i8 %y, %x
138 %cmpeq = icmp eq i8 %x, 128
139 %r = and i1 %cmpeq, %cmp
140 ret i1 %r
141 }
143 define i1 @ugt_and_min(i8 %x, i8 %y) {
144 ; CHECK-LABEL: @ugt_and_min(
145 ; CHECK-NEXT: ret i1 false
146 ;
147 %cmp = icmp ugt i8 %x, %y
148 %cmpeq = icmp eq i8 %x, 0
149 %r = and i1 %cmp, %cmpeq
150 ret i1 %r
151 }
153 define i1 @ugt_and_min_commute(i8 %x, i8 %y) {
154 ; CHECK-LABEL: @ugt_and_min_commute(
155 ; CHECK-NEXT: ret i1 false
156 ;
157 %cmp = icmp ugt i8 %x, %y
158 %cmpeq = icmp eq i8 %x, 0
159 %r = and i1 %cmpeq, %cmp
160 ret i1 %r
161 }
163 define i1 @ugt_swap_and_min(i8 %x, i8 %y) {
164 ; CHECK-LABEL: @ugt_swap_and_min(
165 ; CHECK-NEXT: ret i1 false
166 ;
167 %cmp = icmp ult i8 %y, %x
168 %cmpeq = icmp eq i8 %x, 0
169 %r = and i1 %cmp, %cmpeq
170 ret i1 %r
171 }
173 define i1 @ugt_swap_and_min_commute(i8 %x, i8 %y) {
174 ; CHECK-LABEL: @ugt_swap_and_min_commute(
175 ; CHECK-NEXT: ret i1 false
176 ;
177 %cmp = icmp ult i8 %y, %x
178 %cmpeq = icmp eq i8 %x, 0
179 %r = and i1 %cmpeq, %cmp
180 ret i1 %r
181 }
183 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
184 ;
185 ; (X != MAX) || (X >= Y) --> true
186 ;
187 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
189 define i1 @sge_or_not_max(i8 %x, i8 %y) {
190 ; CHECK-LABEL: @sge_or_not_max(
191 ; CHECK-NEXT: ret i1 true
192 ;
193 %cmp = icmp sge i8 %x, %y
194 %cmpeq = icmp ne i8 %x, 127
195 %r = or i1 %cmp, %cmpeq
196 ret i1 %r
197 }
199 define i1 @sge_or_not_max_commute(i8 %x, i8 %y) {
200 ; CHECK-LABEL: @sge_or_not_max_commute(
201 ; CHECK-NEXT: ret i1 true
202 ;
203 %cmp = icmp sge i8 %x, %y
204 %cmpeq = icmp ne i8 %x, 127
205 %r = or i1 %cmpeq, %cmp
206 ret i1 %r
207 }
209 define i1 @sge_swap_or_not_max(i8 %x, i8 %y) {
210 ; CHECK-LABEL: @sge_swap_or_not_max(
211 ; CHECK-NEXT: ret i1 true
212 ;
213 %cmp = icmp sle i8 %y, %x
214 %cmpeq = icmp ne i8 %x, 127
215 %r = or i1 %cmp, %cmpeq
216 ret i1 %r
217 }
219 define i1 @sge_swap_or_not_max_commute(i8 %x, i8 %y) {
220 ; CHECK-LABEL: @sge_swap_or_not_max_commute(
221 ; CHECK-NEXT: ret i1 true
222 ;
223 %cmp = icmp sle i8 %y, %x
224 %cmpeq = icmp ne i8 %x, 127
225 %r = or i1 %cmpeq, %cmp
226 ret i1 %r
227 }
229 define i1 @uge_or_not_max(i8 %x, i8 %y) {
230 ; CHECK-LABEL: @uge_or_not_max(
231 ; CHECK-NEXT: ret i1 true
232 ;
233 %cmp = icmp uge i8 %x, %y
234 %cmpeq = icmp ne i8 %x, 255
235 %r = or i1 %cmp, %cmpeq
236 ret i1 %r
237 }
239 define i1 @uge_or_not_max_commute(i8 %x, i8 %y) {
240 ; CHECK-LABEL: @uge_or_not_max_commute(
241 ; CHECK-NEXT: ret i1 true
242 ;
243 %cmp = icmp uge i8 %x, %y
244 %cmpeq = icmp ne i8 %x, 255
245 %r = or i1 %cmpeq, %cmp
246 ret i1 %r
247 }
249 define i1 @uge_swap_or_not_max(i8 %x, i8 %y) {
250 ; CHECK-LABEL: @uge_swap_or_not_max(
251 ; CHECK-NEXT: ret i1 true
252 ;
253 %cmp = icmp ule i8 %y, %x
254 %cmpeq = icmp ne i8 %x, 255
255 %r = or i1 %cmp, %cmpeq
256 ret i1 %r
257 }
259 define i1 @uge_swap_or_not_max_commute(i8 %x, i8 %y) {
260 ; CHECK-LABEL: @uge_swap_or_not_max_commute(
261 ; CHECK-NEXT: ret i1 true
262 ;
263 %cmp = icmp ule i8 %y, %x
264 %cmpeq = icmp ne i8 %x, 255
265 %r = or i1 %cmpeq, %cmp
266 ret i1 %r
267 }
269 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
270 ;
271 ; (X != MIN) || (X <= Y) --> true
272 ;
273 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
275 define i1 @sle_or_not_min(i8 %x, i8 %y) {
276 ; CHECK-LABEL: @sle_or_not_min(
277 ; CHECK-NEXT: ret i1 true
278 ;
279 %cmp = icmp sle i8 %x, %y
280 %cmpeq = icmp ne i8 %x, 128
281 %r = or i1 %cmp, %cmpeq
282 ret i1 %r
283 }
285 define i1 @sle_or_not_min_commute(i8 %x, i8 %y) {
286 ; CHECK-LABEL: @sle_or_not_min_commute(
287 ; CHECK-NEXT: ret i1 true
288 ;
289 %cmp = icmp sle i8 %x, %y
290 %cmpeq = icmp ne i8 %x, 128
291 %r = or i1 %cmpeq, %cmp
292 ret i1 %r
293 }
295 define i1 @sle_swap_or_not_min(i8 %x, i8 %y) {
296 ; CHECK-LABEL: @sle_swap_or_not_min(
297 ; CHECK-NEXT: ret i1 true
298 ;
299 %cmp = icmp sge i8 %y, %x
300 %cmpeq = icmp ne i8 %x, 128
301 %r = or i1 %cmp, %cmpeq
302 ret i1 %r
303 }
305 define i1 @sle_swap_or_not_min_commute(i8 %x, i8 %y) {
306 ; CHECK-LABEL: @sle_swap_or_not_min_commute(
307 ; CHECK-NEXT: ret i1 true
308 ;
309 %cmp = icmp sge i8 %y, %x
310 %cmpeq = icmp ne i8 %x, 128
311 %r = or i1 %cmpeq, %cmp
312 ret i1 %r
313 }
315 define i1 @ule_or_not_min(i427 %x, i427 %y) {
316 ; CHECK-LABEL: @ule_or_not_min(
317 ; CHECK-NEXT: ret i1 true
318 ;
319 %cmp = icmp ule i427 %x, %y
320 %cmpeq = icmp ne i427 %x, 0
321 %r = or i1 %cmp, %cmpeq
322 ret i1 %r
323 }
325 define i1 @ule_or_not_min_commute(i8 %x, i8 %y) {
326 ; CHECK-LABEL: @ule_or_not_min_commute(
327 ; CHECK-NEXT: ret i1 true
328 ;
329 %cmp = icmp ule i8 %x, %y
330 %cmpeq = icmp ne i8 %x, 0
331 %r = or i1 %cmpeq, %cmp
332 ret i1 %r
333 }
335 define i1 @ule_swap_or_not_min(i8 %x, i8 %y) {
336 ; CHECK-LABEL: @ule_swap_or_not_min(
337 ; CHECK-NEXT: ret i1 true
338 ;
339 %cmp = icmp uge i8 %y, %x
340 %cmpeq = icmp ne i8 %x, 0
341 %r = or i1 %cmp, %cmpeq
342 ret i1 %r
343 }
345 define i1 @ule_swap_or_not_min_commute(i8 %x, i8 %y) {
346 ; CHECK-LABEL: @ule_swap_or_not_min_commute(
347 ; CHECK-NEXT: ret i1 true
348 ;
349 %cmp = icmp uge i8 %y, %x
350 %cmpeq = icmp ne i8 %x, 0
351 %r = or i1 %cmpeq, %cmp
352 ret i1 %r
353 }
355 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
356 ;
357 ; (X == MAX) && (X >= Y) --> X == MAX
358 ;
359 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
361 define i1 @sge_and_max(i8 %x, i8 %y) {
362 ; CHECK-LABEL: @sge_and_max(
363 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], 127
364 ; CHECK-NEXT: ret i1 [[CMPEQ]]
365 ;
366 %cmp = icmp sge i8 %x, %y
367 %cmpeq = icmp eq i8 %x, 127
368 %r = and i1 %cmp, %cmpeq
369 ret i1 %r
370 }
372 define i1 @sge_and_max_commute(i8 %x, i8 %y) {
373 ; CHECK-LABEL: @sge_and_max_commute(
374 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], 127
375 ; CHECK-NEXT: ret i1 [[CMPEQ]]
376 ;
377 %cmp = icmp sge i8 %x, %y
378 %cmpeq = icmp eq i8 %x, 127
379 %r = and i1 %cmpeq, %cmp
380 ret i1 %r
381 }
383 define i1 @sge_swap_and_max(i8 %x, i8 %y) {
384 ; CHECK-LABEL: @sge_swap_and_max(
385 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], 127
386 ; CHECK-NEXT: ret i1 [[CMPEQ]]
387 ;
388 %cmp = icmp sle i8 %y, %x
389 %cmpeq = icmp eq i8 %x, 127
390 %r = and i1 %cmp, %cmpeq
391 ret i1 %r
392 }
394 define i1 @sge_swap_and_max_commute(i8 %x, i8 %y) {
395 ; CHECK-LABEL: @sge_swap_and_max_commute(
396 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], 127
397 ; CHECK-NEXT: ret i1 [[CMPEQ]]
398 ;
399 %cmp = icmp sle i8 %y, %x
400 %cmpeq = icmp eq i8 %x, 127
401 %r = and i1 %cmpeq, %cmp
402 ret i1 %r
403 }
405 define i1 @uge_and_max(i8 %x, i8 %y) {
406 ; CHECK-LABEL: @uge_and_max(
407 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], -1
408 ; CHECK-NEXT: ret i1 [[CMPEQ]]
409 ;
410 %cmp = icmp uge i8 %x, %y
411 %cmpeq = icmp eq i8 %x, 255
412 %r = and i1 %cmp, %cmpeq
413 ret i1 %r
414 }
416 define i1 @uge_and_max_commute(i8 %x, i8 %y) {
417 ; CHECK-LABEL: @uge_and_max_commute(
418 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], -1
419 ; CHECK-NEXT: ret i1 [[CMPEQ]]
420 ;
421 %cmp = icmp uge i8 %x, %y
422 %cmpeq = icmp eq i8 %x, 255
423 %r = and i1 %cmpeq, %cmp
424 ret i1 %r
425 }
427 define i1 @uge_swap_and_max(i8 %x, i8 %y) {
428 ; CHECK-LABEL: @uge_swap_and_max(
429 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], -1
430 ; CHECK-NEXT: ret i1 [[CMPEQ]]
431 ;
432 %cmp = icmp ule i8 %y, %x
433 %cmpeq = icmp eq i8 %x, 255
434 %r = and i1 %cmp, %cmpeq
435 ret i1 %r
436 }
438 define i1 @uge_swap_and_max_commute(i8 %x, i8 %y) {
439 ; CHECK-LABEL: @uge_swap_and_max_commute(
440 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], -1
441 ; CHECK-NEXT: ret i1 [[CMPEQ]]
442 ;
443 %cmp = icmp ule i8 %y, %x
444 %cmpeq = icmp eq i8 %x, 255
445 %r = and i1 %cmpeq, %cmp
446 ret i1 %r
447 }
449 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
450 ;
451 ; (X == MIN) && (X <= Y) --> X == MIN
452 ;
453 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
455 define i1 @sle_and_min(i8 %x, i8 %y) {
456 ; CHECK-LABEL: @sle_and_min(
457 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], -128
458 ; CHECK-NEXT: ret i1 [[CMPEQ]]
459 ;
460 %cmp = icmp sle i8 %x, %y
461 %cmpeq = icmp eq i8 %x, 128
462 %r = and i1 %cmp, %cmpeq
463 ret i1 %r
464 }
466 define i1 @sle_and_min_commute(i8 %x, i8 %y) {
467 ; CHECK-LABEL: @sle_and_min_commute(
468 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], -128
469 ; CHECK-NEXT: ret i1 [[CMPEQ]]
470 ;
471 %cmp = icmp sle i8 %x, %y
472 %cmpeq = icmp eq i8 %x, 128
473 %r = and i1 %cmpeq, %cmp
474 ret i1 %r
475 }
477 define i1 @sle_swap_and_min(i8 %x, i8 %y) {
478 ; CHECK-LABEL: @sle_swap_and_min(
479 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], -128
480 ; CHECK-NEXT: ret i1 [[CMPEQ]]
481 ;
482 %cmp = icmp sge i8 %y, %x
483 %cmpeq = icmp eq i8 %x, 128
484 %r = and i1 %cmp, %cmpeq
485 ret i1 %r
486 }
488 define i1 @sle_swap_and_min_commute(i8 %x, i8 %y) {
489 ; CHECK-LABEL: @sle_swap_and_min_commute(
490 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], -128
491 ; CHECK-NEXT: ret i1 [[CMPEQ]]
492 ;
493 %cmp = icmp sge i8 %y, %x
494 %cmpeq = icmp eq i8 %x, 128
495 %r = and i1 %cmpeq, %cmp
496 ret i1 %r
497 }
499 define i1 @ule_and_min(i8 %x, i8 %y) {
500 ; CHECK-LABEL: @ule_and_min(
501 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], 0
502 ; CHECK-NEXT: ret i1 [[CMPEQ]]
503 ;
504 %cmp = icmp ule i8 %x, %y
505 %cmpeq = icmp eq i8 %x, 0
506 %r = and i1 %cmp, %cmpeq
507 ret i1 %r
508 }
510 define i1 @ule_and_min_commute(i8 %x, i8 %y) {
511 ; CHECK-LABEL: @ule_and_min_commute(
512 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], 0
513 ; CHECK-NEXT: ret i1 [[CMPEQ]]
514 ;
515 %cmp = icmp ule i8 %x, %y
516 %cmpeq = icmp eq i8 %x, 0
517 %r = and i1 %cmpeq, %cmp
518 ret i1 %r
519 }
521 define i1 @ule_swap_and_min(i8 %x, i8 %y) {
522 ; CHECK-LABEL: @ule_swap_and_min(
523 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], 0
524 ; CHECK-NEXT: ret i1 [[CMPEQ]]
525 ;
526 %cmp = icmp uge i8 %y, %x
527 %cmpeq = icmp eq i8 %x, 0
528 %r = and i1 %cmp, %cmpeq
529 ret i1 %r
530 }
532 define i1 @ule_swap_and_min_commute(i8 %x, i8 %y) {
533 ; CHECK-LABEL: @ule_swap_and_min_commute(
534 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], 0
535 ; CHECK-NEXT: ret i1 [[CMPEQ]]
536 ;
537 %cmp = icmp uge i8 %y, %x
538 %cmpeq = icmp eq i8 %x, 0
539 %r = and i1 %cmpeq, %cmp
540 ret i1 %r
541 }
543 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
544 ;
545 ; (X == MAX) || (X >= Y) --> X >= Y
546 ;
547 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
549 define i1 @sge_or_max(i8 %x, i8 %y) {
550 ; CHECK-LABEL: @sge_or_max(
551 ; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[X:%.*]], [[Y:%.*]]
552 ; CHECK-NEXT: ret i1 [[CMP]]
553 ;
554 %cmp = icmp sge i8 %x, %y
555 %cmpeq = icmp eq i8 %x, 127
556 %r = or i1 %cmp, %cmpeq
557 ret i1 %r
558 }
560 define i1 @sge_or_max_commute(i8 %x, i8 %y) {
561 ; CHECK-LABEL: @sge_or_max_commute(
562 ; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[X:%.*]], [[Y:%.*]]
563 ; CHECK-NEXT: ret i1 [[CMP]]
564 ;
565 %cmp = icmp sge i8 %x, %y
566 %cmpeq = icmp eq i8 %x, 127
567 %r = or i1 %cmpeq, %cmp
568 ret i1 %r
569 }
571 define i1 @sge_swap_or_max(i8 %x, i8 %y) {
572 ; CHECK-LABEL: @sge_swap_or_max(
573 ; CHECK-NEXT: [[CMP:%.*]] = icmp sle i8 [[Y:%.*]], [[X:%.*]]
574 ; CHECK-NEXT: ret i1 [[CMP]]
575 ;
576 %cmp = icmp sle i8 %y, %x
577 %cmpeq = icmp eq i8 %x, 127
578 %r = or i1 %cmp, %cmpeq
579 ret i1 %r
580 }
582 define i1 @sge_swap_or_max_commute(i8 %x, i8 %y) {
583 ; CHECK-LABEL: @sge_swap_or_max_commute(
584 ; CHECK-NEXT: [[CMP:%.*]] = icmp sle i8 [[Y:%.*]], [[X:%.*]]
585 ; CHECK-NEXT: ret i1 [[CMP]]
586 ;
587 %cmp = icmp sle i8 %y, %x
588 %cmpeq = icmp eq i8 %x, 127
589 %r = or i1 %cmpeq, %cmp
590 ret i1 %r
591 }
593 define i1 @uge_or_max(i8 %x, i8 %y) {
594 ; CHECK-LABEL: @uge_or_max(
595 ; CHECK-NEXT: [[CMP:%.*]] = icmp uge i8 [[X:%.*]], [[Y:%.*]]
596 ; CHECK-NEXT: ret i1 [[CMP]]
597 ;
598 %cmp = icmp uge i8 %x, %y
599 %cmpeq = icmp eq i8 %x, 255
600 %r = or i1 %cmp, %cmpeq
601 ret i1 %r
602 }
604 define i1 @uge_or_max_commute(i8 %x, i8 %y) {
605 ; CHECK-LABEL: @uge_or_max_commute(
606 ; CHECK-NEXT: [[CMP:%.*]] = icmp uge i8 [[X:%.*]], [[Y:%.*]]
607 ; CHECK-NEXT: ret i1 [[CMP]]
608 ;
609 %cmp = icmp uge i8 %x, %y
610 %cmpeq = icmp eq i8 %x, 255
611 %r = or i1 %cmpeq, %cmp
612 ret i1 %r
613 }
615 define i1 @uge_swap_or_max(i8 %x, i8 %y) {
616 ; CHECK-LABEL: @uge_swap_or_max(
617 ; CHECK-NEXT: [[CMP:%.*]] = icmp ule i8 [[Y:%.*]], [[X:%.*]]
618 ; CHECK-NEXT: ret i1 [[CMP]]
619 ;
620 %cmp = icmp ule i8 %y, %x
621 %cmpeq = icmp eq i8 %x, 255
622 %r = or i1 %cmp, %cmpeq
623 ret i1 %r
624 }
626 define i1 @uge_swap_or_max_commute(i8 %x, i8 %y) {
627 ; CHECK-LABEL: @uge_swap_or_max_commute(
628 ; CHECK-NEXT: [[CMP:%.*]] = icmp ule i8 [[Y:%.*]], [[X:%.*]]
629 ; CHECK-NEXT: ret i1 [[CMP]]
630 ;
631 %cmp = icmp ule i8 %y, %x
632 %cmpeq = icmp eq i8 %x, 255
633 %r = or i1 %cmpeq, %cmp
634 ret i1 %r
635 }
637 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
638 ;
639 ; (X == MIN) || (X <= Y) --> X <= Y
640 ;
641 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
643 define i1 @sle_or_min(i8 %x, i8 %y) {
644 ; CHECK-LABEL: @sle_or_min(
645 ; CHECK-NEXT: [[CMP:%.*]] = icmp sle i8 [[X:%.*]], [[Y:%.*]]
646 ; CHECK-NEXT: ret i1 [[CMP]]
647 ;
648 %cmp = icmp sle i8 %x, %y
649 %cmpeq = icmp eq i8 %x, 128
650 %r = or i1 %cmp, %cmpeq
651 ret i1 %r
652 }
654 define i1 @sle_or_min_commute(i8 %x, i8 %y) {
655 ; CHECK-LABEL: @sle_or_min_commute(
656 ; CHECK-NEXT: [[CMP:%.*]] = icmp sle i8 [[X:%.*]], [[Y:%.*]]
657 ; CHECK-NEXT: ret i1 [[CMP]]
658 ;
659 %cmp = icmp sle i8 %x, %y
660 %cmpeq = icmp eq i8 %x, 128
661 %r = or i1 %cmpeq, %cmp
662 ret i1 %r
663 }
665 define i1 @sle_swap_or_min(i8 %x, i8 %y) {
666 ; CHECK-LABEL: @sle_swap_or_min(
667 ; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[Y:%.*]], [[X:%.*]]
668 ; CHECK-NEXT: ret i1 [[CMP]]
669 ;
670 %cmp = icmp sge i8 %y, %x
671 %cmpeq = icmp eq i8 %x, 128
672 %r = or i1 %cmp, %cmpeq
673 ret i1 %r
674 }
676 define i1 @sle_swap_or_min_commute(i8 %x, i8 %y) {
677 ; CHECK-LABEL: @sle_swap_or_min_commute(
678 ; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[Y:%.*]], [[X:%.*]]
679 ; CHECK-NEXT: ret i1 [[CMP]]
680 ;
681 %cmp = icmp sge i8 %y, %x
682 %cmpeq = icmp eq i8 %x, 128
683 %r = or i1 %cmpeq, %cmp
684 ret i1 %r
685 }
687 define i1 @ule_or_min(i8 %x, i8 %y) {
688 ; CHECK-LABEL: @ule_or_min(
689 ; CHECK-NEXT: [[CMP:%.*]] = icmp ule i8 [[X:%.*]], [[Y:%.*]]
690 ; CHECK-NEXT: ret i1 [[CMP]]
691 ;
692 %cmp = icmp ule i8 %x, %y
693 %cmpeq = icmp eq i8 %x, 0
694 %r = or i1 %cmp, %cmpeq
695 ret i1 %r
696 }
698 define i1 @ule_or_min_commute(i8 %x, i8 %y) {
699 ; CHECK-LABEL: @ule_or_min_commute(
700 ; CHECK-NEXT: [[CMP:%.*]] = icmp ule i8 [[X:%.*]], [[Y:%.*]]
701 ; CHECK-NEXT: ret i1 [[CMP]]
702 ;
703 %cmp = icmp ule i8 %x, %y
704 %cmpeq = icmp eq i8 %x, 0
705 %r = or i1 %cmpeq, %cmp
706 ret i1 %r
707 }
709 define i1 @ule_swap_or_min(i8 %x, i8 %y) {
710 ; CHECK-LABEL: @ule_swap_or_min(
711 ; CHECK-NEXT: [[CMP:%.*]] = icmp uge i8 [[Y:%.*]], [[X:%.*]]
712 ; CHECK-NEXT: ret i1 [[CMP]]
713 ;
714 %cmp = icmp uge i8 %y, %x
715 %cmpeq = icmp eq i8 %x, 0
716 %r = or i1 %cmp, %cmpeq
717 ret i1 %r
718 }
720 define i1 @ule_swap_or_min_commute(i8 %x, i8 %y) {
721 ; CHECK-LABEL: @ule_swap_or_min_commute(
722 ; CHECK-NEXT: [[CMP:%.*]] = icmp uge i8 [[Y:%.*]], [[X:%.*]]
723 ; CHECK-NEXT: ret i1 [[CMP]]
724 ;
725 %cmp = icmp uge i8 %y, %x
726 %cmpeq = icmp eq i8 %x, 0
727 %r = or i1 %cmpeq, %cmp
728 ret i1 %r
729 }
731 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
732 ;
733 ; (X != MAX) && (X < Y) --> X < Y
734 ;
735 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
737 define i1 @slt_and_not_max(i8 %x, i8 %y) {
738 ; CHECK-LABEL: @slt_and_not_max(
739 ; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[X:%.*]], [[Y:%.*]]
740 ; CHECK-NEXT: ret i1 [[CMP]]
741 ;
742 %cmp = icmp slt i8 %x, %y
743 %cmpeq = icmp ne i8 %x, 127
744 %r = and i1 %cmp, %cmpeq
745 ret i1 %r
746 }
748 define i1 @slt_and_not_max_commute(i8 %x, i8 %y) {
749 ; CHECK-LABEL: @slt_and_not_max_commute(
750 ; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[X:%.*]], [[Y:%.*]]
751 ; CHECK-NEXT: ret i1 [[CMP]]
752 ;
753 %cmp = icmp slt i8 %x, %y
754 %cmpeq = icmp ne i8 %x, 127
755 %r = and i1 %cmpeq, %cmp
756 ret i1 %r
757 }
759 define i1 @slt_swap_and_not_max(i8 %x, i8 %y) {
760 ; CHECK-LABEL: @slt_swap_and_not_max(
761 ; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[Y:%.*]], [[X:%.*]]
762 ; CHECK-NEXT: ret i1 [[CMP]]
763 ;
764 %cmp = icmp sgt i8 %y, %x
765 %cmpeq = icmp ne i8 %x, 127
766 %r = and i1 %cmp, %cmpeq
767 ret i1 %r
768 }
770 define i1 @slt_swap_and_not_max_commute(i8 %x, i8 %y) {
771 ; CHECK-LABEL: @slt_swap_and_not_max_commute(
772 ; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[Y:%.*]], [[X:%.*]]
773 ; CHECK-NEXT: ret i1 [[CMP]]
774 ;
775 %cmp = icmp sgt i8 %y, %x
776 %cmpeq = icmp ne i8 %x, 127
777 %r = and i1 %cmpeq, %cmp
778 ret i1 %r
779 }
781 define i1 @ult_and_not_max(i8 %x, i8 %y) {
782 ; CHECK-LABEL: @ult_and_not_max(
783 ; CHECK-NEXT: [[CMP:%.*]] = icmp ult i8 [[X:%.*]], [[Y:%.*]]
784 ; CHECK-NEXT: ret i1 [[CMP]]
785 ;
786 %cmp = icmp ult i8 %x, %y
787 %cmpeq = icmp ne i8 %x, 255
788 %r = and i1 %cmp, %cmpeq
789 ret i1 %r
790 }
792 define i1 @ult_and_not_max_commute(i8 %x, i8 %y) {
793 ; CHECK-LABEL: @ult_and_not_max_commute(
794 ; CHECK-NEXT: [[CMP:%.*]] = icmp ult i8 [[X:%.*]], [[Y:%.*]]
795 ; CHECK-NEXT: ret i1 [[CMP]]
796 ;
797 %cmp = icmp ult i8 %x, %y
798 %cmpeq = icmp ne i8 %x, 255
799 %r = and i1 %cmpeq, %cmp
800 ret i1 %r
801 }
803 define i1 @ult_swap_and_not_max(i8 %x, i8 %y) {
804 ; CHECK-LABEL: @ult_swap_and_not_max(
805 ; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i8 [[Y:%.*]], [[X:%.*]]
806 ; CHECK-NEXT: ret i1 [[CMP]]
807 ;
808 %cmp = icmp ugt i8 %y, %x
809 %cmpeq = icmp ne i8 %x, 255
810 %r = and i1 %cmp, %cmpeq
811 ret i1 %r
812 }
814 define i1 @ult_swap_and_not_max_commute(i8 %x, i8 %y) {
815 ; CHECK-LABEL: @ult_swap_and_not_max_commute(
816 ; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i8 [[Y:%.*]], [[X:%.*]]
817 ; CHECK-NEXT: ret i1 [[CMP]]
818 ;
819 %cmp = icmp ugt i8 %y, %x
820 %cmpeq = icmp ne i8 %x, 255
821 %r = and i1 %cmpeq, %cmp
822 ret i1 %r
823 }
825 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
826 ;
827 ; (X != MIN) && (X > Y) --> X > Y
828 ;
829 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
831 define i1 @sgt_and_not_min(i8 %x, i8 %y) {
832 ; CHECK-LABEL: @sgt_and_not_min(
833 ; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[X:%.*]], [[Y:%.*]]
834 ; CHECK-NEXT: ret i1 [[CMP]]
835 ;
836 %cmp = icmp sgt i8 %x, %y
837 %cmpeq = icmp ne i8 %x, 128
838 %r = and i1 %cmp, %cmpeq
839 ret i1 %r
840 }
842 define i1 @sgt_and_not_min_commute(i8 %x, i8 %y) {
843 ; CHECK-LABEL: @sgt_and_not_min_commute(
844 ; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[X:%.*]], [[Y:%.*]]
845 ; CHECK-NEXT: ret i1 [[CMP]]
846 ;
847 %cmp = icmp sgt i8 %x, %y
848 %cmpeq = icmp ne i8 %x, 128
849 %r = and i1 %cmpeq, %cmp
850 ret i1 %r
851 }
853 define i1 @sgt_swap_and_not_min(i8 %x, i8 %y) {
854 ; CHECK-LABEL: @sgt_swap_and_not_min(
855 ; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[Y:%.*]], [[X:%.*]]
856 ; CHECK-NEXT: ret i1 [[CMP]]
857 ;
858 %cmp = icmp slt i8 %y, %x
859 %cmpeq = icmp ne i8 %x, 128
860 %r = and i1 %cmp, %cmpeq
861 ret i1 %r
862 }
864 define i1 @sgt_swap_and_not_min_commute(i8 %x, i8 %y) {
865 ; CHECK-LABEL: @sgt_swap_and_not_min_commute(
866 ; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[Y:%.*]], [[X:%.*]]
867 ; CHECK-NEXT: ret i1 [[CMP]]
868 ;
869 %cmp = icmp slt i8 %y, %x
870 %cmpeq = icmp ne i8 %x, 128
871 %r = and i1 %cmpeq, %cmp
872 ret i1 %r
873 }
875 define i1 @ugt_and_not_min(i8 %x, i8 %y) {
876 ; CHECK-LABEL: @ugt_and_not_min(
877 ; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i8 [[X:%.*]], [[Y:%.*]]
878 ; CHECK-NEXT: ret i1 [[CMP]]
879 ;
880 %cmp = icmp ugt i8 %x, %y
881 %cmpeq = icmp ne i8 %x, 0
882 %r = and i1 %cmp, %cmpeq
883 ret i1 %r
884 }
886 define i1 @ugt_and_not_min_commute(i8 %x, i8 %y) {
887 ; CHECK-LABEL: @ugt_and_not_min_commute(
888 ; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i8 [[X:%.*]], [[Y:%.*]]
889 ; CHECK-NEXT: ret i1 [[CMP]]
890 ;
891 %cmp = icmp ugt i8 %x, %y
892 %cmpeq = icmp ne i8 %x, 0
893 %r = and i1 %cmpeq, %cmp
894 ret i1 %r
895 }
897 define i1 @ugt_swap_and_not_min(i8 %x, i8 %y) {
898 ; CHECK-LABEL: @ugt_swap_and_not_min(
899 ; CHECK-NEXT: [[CMP:%.*]] = icmp ult i8 [[Y:%.*]], [[X:%.*]]
900 ; CHECK-NEXT: ret i1 [[CMP]]
901 ;
902 %cmp = icmp ult i8 %y, %x
903 %cmpeq = icmp ne i8 %x, 0
904 %r = and i1 %cmp, %cmpeq
905 ret i1 %r
906 }
908 define i1 @ugt_swap_and_not_min_commute(i8 %x, i8 %y) {
909 ; CHECK-LABEL: @ugt_swap_and_not_min_commute(
910 ; CHECK-NEXT: [[CMP:%.*]] = icmp ult i8 [[Y:%.*]], [[X:%.*]]
911 ; CHECK-NEXT: ret i1 [[CMP]]
912 ;
913 %cmp = icmp ult i8 %y, %x
914 %cmpeq = icmp ne i8 %x, 0
915 %r = and i1 %cmpeq, %cmp
916 ret i1 %r
917 }
919 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
920 ;
921 ; (X != MAX) || (X < Y) --> X != MAX
922 ;
923 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
925 define i1 @slt_or_not_max(i8 %x, i8 %y) {
926 ; CHECK-LABEL: @slt_or_not_max(
927 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], 127
928 ; CHECK-NEXT: ret i1 [[CMPEQ]]
929 ;
930 %cmp = icmp slt i8 %x, %y
931 %cmpeq = icmp ne i8 %x, 127
932 %r = or i1 %cmp, %cmpeq
933 ret i1 %r
934 }
936 define i1 @slt_or_not_max_commute(i8 %x, i8 %y) {
937 ; CHECK-LABEL: @slt_or_not_max_commute(
938 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], 127
939 ; CHECK-NEXT: ret i1 [[CMPEQ]]
940 ;
941 %cmp = icmp slt i8 %x, %y
942 %cmpeq = icmp ne i8 %x, 127
943 %r = or i1 %cmpeq, %cmp
944 ret i1 %r
945 }
947 define i1 @slt_swap_or_not_max(i8 %x, i8 %y) {
948 ; CHECK-LABEL: @slt_swap_or_not_max(
949 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], 127
950 ; CHECK-NEXT: ret i1 [[CMPEQ]]
951 ;
952 %cmp = icmp sgt i8 %y, %x
953 %cmpeq = icmp ne i8 %x, 127
954 %r = or i1 %cmp, %cmpeq
955 ret i1 %r
956 }
958 define i1 @slt_swap_or_not_max_commute(i8 %x, i8 %y) {
959 ; CHECK-LABEL: @slt_swap_or_not_max_commute(
960 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], 127
961 ; CHECK-NEXT: ret i1 [[CMPEQ]]
962 ;
963 %cmp = icmp sgt i8 %y, %x
964 %cmpeq = icmp ne i8 %x, 127
965 %r = or i1 %cmpeq, %cmp
966 ret i1 %r
967 }
969 define i1 @ult_or_not_max(i8 %x, i8 %y) {
970 ; CHECK-LABEL: @ult_or_not_max(
971 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], -1
972 ; CHECK-NEXT: ret i1 [[CMPEQ]]
973 ;
974 %cmp = icmp ult i8 %x, %y
975 %cmpeq = icmp ne i8 %x, 255
976 %r = or i1 %cmp, %cmpeq
977 ret i1 %r
978 }
980 define i1 @ult_or_not_max_commute(i8 %x, i8 %y) {
981 ; CHECK-LABEL: @ult_or_not_max_commute(
982 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], -1
983 ; CHECK-NEXT: ret i1 [[CMPEQ]]
984 ;
985 %cmp = icmp ult i8 %x, %y
986 %cmpeq = icmp ne i8 %x, 255
987 %r = or i1 %cmpeq, %cmp
988 ret i1 %r
989 }
991 define i1 @ult_swap_or_not_max(i8 %x, i8 %y) {
992 ; CHECK-LABEL: @ult_swap_or_not_max(
993 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], -1
994 ; CHECK-NEXT: ret i1 [[CMPEQ]]
995 ;
996 %cmp = icmp ugt i8 %y, %x
997 %cmpeq = icmp ne i8 %x, 255
998 %r = or i1 %cmp, %cmpeq
999 ret i1 %r
1000 }
1002 define i1 @ult_swap_or_not_max_commute(i8 %x, i8 %y) {
1003 ; CHECK-LABEL: @ult_swap_or_not_max_commute(
1004 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], -1
1005 ; CHECK-NEXT: ret i1 [[CMPEQ]]
1006 ;
1007 %cmp = icmp ugt i8 %y, %x
1008 %cmpeq = icmp ne i8 %x, 255
1009 %r = or i1 %cmpeq, %cmp
1010 ret i1 %r
1011 }
1013 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1014 ;
1015 ; (X != MIN) || (X > Y) --> X != MIN
1016 ;
1017 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1019 define i1 @sgt_or_not_min(i8 %x, i8 %y) {
1020 ; CHECK-LABEL: @sgt_or_not_min(
1021 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], -128
1022 ; CHECK-NEXT: ret i1 [[CMPEQ]]
1023 ;
1024 %cmp = icmp sgt i8 %x, %y
1025 %cmpeq = icmp ne i8 %x, 128
1026 %r = or i1 %cmp, %cmpeq
1027 ret i1 %r
1028 }
1030 define i1 @sgt_or_not_min_commute(i8 %x, i8 %y) {
1031 ; CHECK-LABEL: @sgt_or_not_min_commute(
1032 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], -128
1033 ; CHECK-NEXT: ret i1 [[CMPEQ]]
1034 ;
1035 %cmp = icmp sgt i8 %x, %y
1036 %cmpeq = icmp ne i8 %x, 128
1037 %r = or i1 %cmpeq, %cmp
1038 ret i1 %r
1039 }
1041 define i1 @sgt_swap_or_not_min(i8 %x, i8 %y) {
1042 ; CHECK-LABEL: @sgt_swap_or_not_min(
1043 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], -128
1044 ; CHECK-NEXT: ret i1 [[CMPEQ]]
1045 ;
1046 %cmp = icmp slt i8 %y, %x
1047 %cmpeq = icmp ne i8 %x, 128
1048 %r = or i1 %cmp, %cmpeq
1049 ret i1 %r
1050 }
1052 define i1 @sgt_swap_or_not_min_commute(i8 %x, i8 %y) {
1053 ; CHECK-LABEL: @sgt_swap_or_not_min_commute(
1054 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], -128
1055 ; CHECK-NEXT: ret i1 [[CMPEQ]]
1056 ;
1057 %cmp = icmp slt i8 %y, %x
1058 %cmpeq = icmp ne i8 %x, 128
1059 %r = or i1 %cmpeq, %cmp
1060 ret i1 %r
1061 }
1063 define i1 @ugt_or_not_min(i8 %x, i8 %y) {
1064 ; CHECK-LABEL: @ugt_or_not_min(
1065 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], 0
1066 ; CHECK-NEXT: ret i1 [[CMPEQ]]
1067 ;
1068 %cmp = icmp ugt i8 %x, %y
1069 %cmpeq = icmp ne i8 %x, 0
1070 %r = or i1 %cmp, %cmpeq
1071 ret i1 %r
1072 }
1074 define i1 @ugt_or_not_min_commute(i8 %x, i8 %y) {
1075 ; CHECK-LABEL: @ugt_or_not_min_commute(
1076 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], 0
1077 ; CHECK-NEXT: ret i1 [[CMPEQ]]
1078 ;
1079 %cmp = icmp ugt i8 %x, %y
1080 %cmpeq = icmp ne i8 %x, 0
1081 %r = or i1 %cmpeq, %cmp
1082 ret i1 %r
1083 }
1085 define i1 @ugt_swap_or_not_min(i8 %x, i8 %y) {
1086 ; CHECK-LABEL: @ugt_swap_or_not_min(
1087 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], 0
1088 ; CHECK-NEXT: ret i1 [[CMPEQ]]
1089 ;
1090 %cmp = icmp ult i8 %y, %x
1091 %cmpeq = icmp ne i8 %x, 0
1092 %r = or i1 %cmp, %cmpeq
1093 ret i1 %r
1094 }
1096 define i1 @ugt_swap_or_not_min_commute(i823 %x, i823 %y) {
1097 ; CHECK-LABEL: @ugt_swap_or_not_min_commute(
1098 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i823 [[X:%.*]], 0
1099 ; CHECK-NEXT: ret i1 [[CMPEQ]]
1100 ;
1101 %cmp = icmp ult i823 %y, %x
1102 %cmpeq = icmp ne i823 %x, 0
1103 %r = or i1 %cmpeq, %cmp
1104 ret i1 %r
1105 }
1107 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1108 ;
1109 ; (X == MIN) && (!X < Y) --> false
1110 ;
1111 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1113 define i1 @slt_and_max_not_op(i8 %x, i8 %y) {
1114 ; CHECK-LABEL: @slt_and_max_not_op(
1115 ; CHECK-NEXT: ret i1 false
1116 ;
1117 %notx = xor i8 %x, -1
1118 %cmp = icmp slt i8 %notx, %y
1119 %cmpeq = icmp eq i8 %x, 128
1120 %r = and i1 %cmp, %cmpeq
1121 ret i1 %r
1122 }
1124 define <2 x i1> @slt_and_max_commute_not_op(<2 x i8> %x, <2 x i8> %y) {
1125 ; CHECK-LABEL: @slt_and_max_commute_not_op(
1126 ; CHECK-NEXT: ret <2 x i1> zeroinitializer
1127 ;
1128 %notx = xor <2 x i8> %x, <i8 -1, i8 -1>
1129 %cmp = icmp slt <2 x i8> %notx, %y
1130 %cmpeq = icmp eq <2 x i8> %x, <i8 128, i8 128>
1131 %r = and <2 x i1> %cmpeq, %cmp
1132 ret <2 x i1> %r
1133 }
1135 define i1 @slt_swap_and_max_not_op(i8 %x, i8 %y) {
1136 ; CHECK-LABEL: @slt_swap_and_max_not_op(
1137 ; CHECK-NEXT: ret i1 false
1138 ;
1139 %notx = xor i8 %x, -1
1140 %cmp = icmp sgt i8 %y, %notx
1141 %cmpeq = icmp eq i8 %x, 128
1142 %r = and i1 %cmp, %cmpeq
1143 ret i1 %r
1144 }
1146 define i1 @slt_swap_and_max_commute_not_op(i8 %x, i8 %y) {
1147 ; CHECK-LABEL: @slt_swap_and_max_commute_not_op(
1148 ; CHECK-NEXT: ret i1 false
1149 ;
1150 %notx = xor i8 %x, -1
1151 %cmp = icmp sgt i8 %y, %notx
1152 %cmpeq = icmp eq i8 %x, 128
1153 %r = and i1 %cmpeq, %cmp
1154 ret i1 %r
1155 }
1157 define i1 @ult_and_max_not_op(i8 %x, i8 %y) {
1158 ; CHECK-LABEL: @ult_and_max_not_op(
1159 ; CHECK-NEXT: ret i1 false
1160 ;
1161 %notx = xor i8 %x, -1
1162 %cmp = icmp ult i8 %notx, %y
1163 %cmpeq = icmp eq i8 %x, 0
1164 %r = and i1 %cmp, %cmpeq
1165 ret i1 %r
1166 }
1168 define i1 @ult_and_max_commute_not_op(i8 %x, i8 %y) {
1169 ; CHECK-LABEL: @ult_and_max_commute_not_op(
1170 ; CHECK-NEXT: ret i1 false
1171 ;
1172 %notx = xor i8 %x, -1
1173 %cmp = icmp ult i8 %notx, %y
1174 %cmpeq = icmp eq i8 %x, 0
1175 %r = and i1 %cmpeq, %cmp
1176 ret i1 %r
1177 }
1179 define i1 @ult_swap_and_max_not_op(i8 %x, i8 %y) {
1180 ; CHECK-LABEL: @ult_swap_and_max_not_op(
1181 ; CHECK-NEXT: ret i1 false
1182 ;
1183 %notx = xor i8 %x, -1
1184 %cmp = icmp ugt i8 %y, %notx
1185 %cmpeq = icmp eq i8 %x, 0
1186 %r = and i1 %cmp, %cmpeq
1187 ret i1 %r
1188 }
1190 define i1 @ult_swap_and_max_commute_not_op(i8 %x, i8 %y) {
1191 ; CHECK-LABEL: @ult_swap_and_max_commute_not_op(
1192 ; CHECK-NEXT: ret i1 false
1193 ;
1194 %notx = xor i8 %x, -1
1195 %cmp = icmp ugt i8 %y, %notx
1196 %cmpeq = icmp eq i8 %x, 0
1197 %r = and i1 %cmpeq, %cmp
1198 ret i1 %r
1199 }
1201 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1202 ;
1203 ; (X == MAX) && (!X > Y) --> false
1204 ;
1205 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1207 define i1 @sgt_and_min_not_op(i9 %x, i9 %y) {
1208 ; CHECK-LABEL: @sgt_and_min_not_op(
1209 ; CHECK-NEXT: ret i1 false
1210 ;
1211 %notx = xor i9 %x, -1
1212 %cmp = icmp sgt i9 %notx, %y
1213 %cmpeq = icmp eq i9 %x, 255
1214 %r = and i1 %cmp, %cmpeq
1215 ret i1 %r
1216 }
1218 define i1 @sgt_and_min_commute_not_op(i8 %x, i8 %y) {
1219 ; CHECK-LABEL: @sgt_and_min_commute_not_op(
1220 ; CHECK-NEXT: ret i1 false
1221 ;
1222 %notx = xor i8 %x, -1
1223 %cmp = icmp sgt i8 %notx, %y
1224 %cmpeq = icmp eq i8 %x, 127
1225 %r = and i1 %cmpeq, %cmp
1226 ret i1 %r
1227 }
1229 define i1 @sgt_swap_and_min_not_op(i8 %x, i8 %y) {
1230 ; CHECK-LABEL: @sgt_swap_and_min_not_op(
1231 ; CHECK-NEXT: ret i1 false
1232 ;
1233 %notx = xor i8 %x, -1
1234 %cmp = icmp slt i8 %y, %notx
1235 %cmpeq = icmp eq i8 %x, 127
1236 %r = and i1 %cmp, %cmpeq
1237 ret i1 %r
1238 }
1240 define i1 @sgt_swap_and_min_commute_not_op(i8 %x, i8 %y) {
1241 ; CHECK-LABEL: @sgt_swap_and_min_commute_not_op(
1242 ; CHECK-NEXT: ret i1 false
1243 ;
1244 %notx = xor i8 %x, -1
1245 %cmp = icmp slt i8 %y, %notx
1246 %cmpeq = icmp eq i8 %x, 127
1247 %r = and i1 %cmpeq, %cmp
1248 ret i1 %r
1249 }
1251 define i1 @ugt_and_min_not_op(i8 %x, i8 %y) {
1252 ; CHECK-LABEL: @ugt_and_min_not_op(
1253 ; CHECK-NEXT: ret i1 false
1254 ;
1255 %notx = xor i8 %x, -1
1256 %cmp = icmp ugt i8 %notx, %y
1257 %cmpeq = icmp eq i8 %x, 255
1258 %r = and i1 %cmp, %cmpeq
1259 ret i1 %r
1260 }
1262 define i1 @ugt_and_min_commute_not_op(i8 %x, i8 %y) {
1263 ; CHECK-LABEL: @ugt_and_min_commute_not_op(
1264 ; CHECK-NEXT: ret i1 false
1265 ;
1266 %notx = xor i8 %x, -1
1267 %cmp = icmp ugt i8 %notx, %y
1268 %cmpeq = icmp eq i8 %x, 255
1269 %r = and i1 %cmpeq, %cmp
1270 ret i1 %r
1271 }
1273 define i1 @ugt_swap_and_min_not_op(i8 %x, i8 %y) {
1274 ; CHECK-LABEL: @ugt_swap_and_min_not_op(
1275 ; CHECK-NEXT: ret i1 false
1276 ;
1277 %notx = xor i8 %x, -1
1278 %cmp = icmp ult i8 %y, %notx
1279 %cmpeq = icmp eq i8 %x, 255
1280 %r = and i1 %cmp, %cmpeq
1281 ret i1 %r
1282 }
1284 define i1 @ugt_swap_and_min_commute_not_op(i8 %x, i8 %y) {
1285 ; CHECK-LABEL: @ugt_swap_and_min_commute_not_op(
1286 ; CHECK-NEXT: ret i1 false
1287 ;
1288 %notx = xor i8 %x, -1
1289 %cmp = icmp ult i8 %y, %notx
1290 %cmpeq = icmp eq i8 %x, 255
1291 %r = and i1 %cmpeq, %cmp
1292 ret i1 %r
1293 }
1295 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1296 ;
1297 ; (X != MIN) || (!X >= Y) --> true
1298 ;
1299 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1301 define i1 @sge_or_not_max_not_op(i8 %x, i8 %y) {
1302 ; CHECK-LABEL: @sge_or_not_max_not_op(
1303 ; CHECK-NEXT: ret i1 true
1304 ;
1305 %notx = xor i8 %x, -1
1306 %cmp = icmp sge i8 %notx, %y
1307 %cmpeq = icmp ne i8 %x, 128
1308 %r = or i1 %cmp, %cmpeq
1309 ret i1 %r
1310 }
1312 define i1 @sge_or_not_max_commute_not_op(i8 %x, i8 %y) {
1313 ; CHECK-LABEL: @sge_or_not_max_commute_not_op(
1314 ; CHECK-NEXT: ret i1 true
1315 ;
1316 %notx = xor i8 %x, -1
1317 %cmp = icmp sge i8 %notx, %y
1318 %cmpeq = icmp ne i8 %x, 128
1319 %r = or i1 %cmpeq, %cmp
1320 ret i1 %r
1321 }
1323 define i1 @sge_swap_or_not_max_not_op(i8 %x, i8 %y) {
1324 ; CHECK-LABEL: @sge_swap_or_not_max_not_op(
1325 ; CHECK-NEXT: ret i1 true
1326 ;
1327 %notx = xor i8 %x, -1
1328 %cmp = icmp sle i8 %y, %notx
1329 %cmpeq = icmp ne i8 %x, 128
1330 %r = or i1 %cmp, %cmpeq
1331 ret i1 %r
1332 }
1334 define i1 @sge_swap_or_not_max_commute_not_op(i8 %x, i8 %y) {
1335 ; CHECK-LABEL: @sge_swap_or_not_max_commute_not_op(
1336 ; CHECK-NEXT: ret i1 true
1337 ;
1338 %notx = xor i8 %x, -1
1339 %cmp = icmp sle i8 %y, %notx
1340 %cmpeq = icmp ne i8 %x, 128
1341 %r = or i1 %cmpeq, %cmp
1342 ret i1 %r
1343 }
1345 define i1 @uge_or_not_max_not_op(i8 %x, i8 %y) {
1346 ; CHECK-LABEL: @uge_or_not_max_not_op(
1347 ; CHECK-NEXT: ret i1 true
1348 ;
1349 %notx = xor i8 %x, -1
1350 %cmp = icmp uge i8 %notx, %y
1351 %cmpeq = icmp ne i8 %x, 0
1352 %r = or i1 %cmp, %cmpeq
1353 ret i1 %r
1354 }
1356 define i1 @uge_or_not_max_commute_not_op(i8 %x, i8 %y) {
1357 ; CHECK-LABEL: @uge_or_not_max_commute_not_op(
1358 ; CHECK-NEXT: ret i1 true
1359 ;
1360 %notx = xor i8 %x, -1
1361 %cmp = icmp uge i8 %notx, %y
1362 %cmpeq = icmp ne i8 %x, 0
1363 %r = or i1 %cmpeq, %cmp
1364 ret i1 %r
1365 }
1367 define i1 @uge_swap_or_not_max_not_op(i8 %x, i8 %y) {
1368 ; CHECK-LABEL: @uge_swap_or_not_max_not_op(
1369 ; CHECK-NEXT: ret i1 true
1370 ;
1371 %notx = xor i8 %x, -1
1372 %cmp = icmp ule i8 %y, %notx
1373 %cmpeq = icmp ne i8 %x, 0
1374 %r = or i1 %cmp, %cmpeq
1375 ret i1 %r
1376 }
1378 define i1 @uge_swap_or_not_max_commute_not_op(i8 %x, i8 %y) {
1379 ; CHECK-LABEL: @uge_swap_or_not_max_commute_not_op(
1380 ; CHECK-NEXT: ret i1 true
1381 ;
1382 %notx = xor i8 %x, -1
1383 %cmp = icmp ule i8 %y, %notx
1384 %cmpeq = icmp ne i8 %x, 0
1385 %r = or i1 %cmpeq, %cmp
1386 ret i1 %r
1387 }
1389 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1390 ;
1391 ; (X != MAX) || (!X <= Y) --> true
1392 ;
1393 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1395 define i1 @sle_or_not_min_not_op(i8 %x, i8 %y) {
1396 ; CHECK-LABEL: @sle_or_not_min_not_op(
1397 ; CHECK-NEXT: ret i1 true
1398 ;
1399 %notx = xor i8 %x, -1
1400 %cmp = icmp sle i8 %notx, %y
1401 %cmpeq = icmp ne i8 %x, 127
1402 %r = or i1 %cmp, %cmpeq
1403 ret i1 %r
1404 }
1406 define i1 @sle_or_not_min_commute_not_op(i8 %x, i8 %y) {
1407 ; CHECK-LABEL: @sle_or_not_min_commute_not_op(
1408 ; CHECK-NEXT: ret i1 true
1409 ;
1410 %notx = xor i8 %x, -1
1411 %cmp = icmp sle i8 %notx, %y
1412 %cmpeq = icmp ne i8 %x, 127
1413 %r = or i1 %cmpeq, %cmp
1414 ret i1 %r
1415 }
1417 define i1 @sle_swap_or_not_min_not_op(i8 %x, i8 %y) {
1418 ; CHECK-LABEL: @sle_swap_or_not_min_not_op(
1419 ; CHECK-NEXT: ret i1 true
1420 ;
1421 %notx = xor i8 %x, -1
1422 %cmp = icmp sge i8 %y, %notx
1423 %cmpeq = icmp ne i8 %x, 127
1424 %r = or i1 %cmp, %cmpeq
1425 ret i1 %r
1426 }
1428 define i1 @sle_swap_or_not_min_commute_not_op(i8 %x, i8 %y) {
1429 ; CHECK-LABEL: @sle_swap_or_not_min_commute_not_op(
1430 ; CHECK-NEXT: ret i1 true
1431 ;
1432 %notx = xor i8 %x, -1
1433 %cmp = icmp sge i8 %y, %notx
1434 %cmpeq = icmp ne i8 %x, 127
1435 %r = or i1 %cmpeq, %cmp
1436 ret i1 %r
1437 }
1439 define i1 @ule_or_not_min_not_op(i427 %x, i427 %y) {
1440 ; CHECK-LABEL: @ule_or_not_min_not_op(
1441 ; CHECK-NEXT: ret i1 true
1442 ;
1443 %notx = xor i427 %x, -1
1444 %cmp = icmp ule i427 %notx, %y
1445 %cmpeq = icmp ne i427 %x, -1
1446 %r = or i1 %cmp, %cmpeq
1447 ret i1 %r
1448 }
1450 define i1 @ule_or_not_min_commute_not_op(i8 %x, i8 %y) {
1451 ; CHECK-LABEL: @ule_or_not_min_commute_not_op(
1452 ; CHECK-NEXT: ret i1 true
1453 ;
1454 %notx = xor i8 %x, -1
1455 %cmp = icmp ule i8 %notx, %y
1456 %cmpeq = icmp ne i8 %x, 255
1457 %r = or i1 %cmpeq, %cmp
1458 ret i1 %r
1459 }
1461 define i1 @ule_swap_or_not_min_not_op(i8 %x, i8 %y) {
1462 ; CHECK-LABEL: @ule_swap_or_not_min_not_op(
1463 ; CHECK-NEXT: ret i1 true
1464 ;
1465 %notx = xor i8 %x, -1
1466 %cmp = icmp uge i8 %y, %notx
1467 %cmpeq = icmp ne i8 %x, 255
1468 %r = or i1 %cmp, %cmpeq
1469 ret i1 %r
1470 }
1472 define i1 @ule_swap_or_not_min_commute_not_op(i8 %x, i8 %y) {
1473 ; CHECK-LABEL: @ule_swap_or_not_min_commute_not_op(
1474 ; CHECK-NEXT: ret i1 true
1475 ;
1476 %notx = xor i8 %x, -1
1477 %cmp = icmp uge i8 %y, %notx
1478 %cmpeq = icmp ne i8 %x, 255
1479 %r = or i1 %cmpeq, %cmp
1480 ret i1 %r
1481 }
1483 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1484 ;
1485 ; (X == MIN) && (!X >= Y) --> X == MIN
1486 ;
1487 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1489 define i1 @sge_and_max_not_op(i8 %x, i8 %y) {
1490 ; CHECK-LABEL: @sge_and_max_not_op(
1491 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], -128
1492 ; CHECK-NEXT: ret i1 [[CMPEQ]]
1493 ;
1494 %notx = xor i8 %x, -1
1495 %cmp = icmp sge i8 %notx, %y
1496 %cmpeq = icmp eq i8 %x, 128
1497 %r = and i1 %cmp, %cmpeq
1498 ret i1 %r
1499 }
1501 define i1 @sge_and_max_commute_not_op(i8 %x, i8 %y) {
1502 ; CHECK-LABEL: @sge_and_max_commute_not_op(
1503 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], -128
1504 ; CHECK-NEXT: ret i1 [[CMPEQ]]
1505 ;
1506 %notx = xor i8 %x, -1
1507 %cmp = icmp sge i8 %notx, %y
1508 %cmpeq = icmp eq i8 %x, 128
1509 %r = and i1 %cmpeq, %cmp
1510 ret i1 %r
1511 }
1513 define i1 @sge_swap_and_max_not_op(i8 %x, i8 %y) {
1514 ; CHECK-LABEL: @sge_swap_and_max_not_op(
1515 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], -128
1516 ; CHECK-NEXT: ret i1 [[CMPEQ]]
1517 ;
1518 %notx = xor i8 %x, -1
1519 %cmp = icmp sle i8 %y, %notx
1520 %cmpeq = icmp eq i8 %x, 128
1521 %r = and i1 %cmp, %cmpeq
1522 ret i1 %r
1523 }
1525 define i1 @sge_swap_and_max_commute_not_op(i8 %x, i8 %y) {
1526 ; CHECK-LABEL: @sge_swap_and_max_commute_not_op(
1527 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], -128
1528 ; CHECK-NEXT: ret i1 [[CMPEQ]]
1529 ;
1530 %notx = xor i8 %x, -1
1531 %cmp = icmp sle i8 %y, %notx
1532 %cmpeq = icmp eq i8 %x, 128
1533 %r = and i1 %cmpeq, %cmp
1534 ret i1 %r
1535 }
1537 define i1 @uge_and_max_not_op(i8 %x, i8 %y) {
1538 ; CHECK-LABEL: @uge_and_max_not_op(
1539 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], 0
1540 ; CHECK-NEXT: ret i1 [[CMPEQ]]
1541 ;
1542 %notx = xor i8 %x, -1
1543 %cmp = icmp uge i8 %notx, %y
1544 %cmpeq = icmp eq i8 %x, 0
1545 %r = and i1 %cmp, %cmpeq
1546 ret i1 %r
1547 }
1549 define i1 @uge_and_max_commute_not_op(i8 %x, i8 %y) {
1550 ; CHECK-LABEL: @uge_and_max_commute_not_op(
1551 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], 0
1552 ; CHECK-NEXT: ret i1 [[CMPEQ]]
1553 ;
1554 %notx = xor i8 %x, -1
1555 %cmp = icmp uge i8 %notx, %y
1556 %cmpeq = icmp eq i8 %x, 0
1557 %r = and i1 %cmpeq, %cmp
1558 ret i1 %r
1559 }
1561 define i1 @uge_swap_and_max_not_op(i8 %x, i8 %y) {
1562 ; CHECK-LABEL: @uge_swap_and_max_not_op(
1563 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], 0
1564 ; CHECK-NEXT: ret i1 [[CMPEQ]]
1565 ;
1566 %notx = xor i8 %x, -1
1567 %cmp = icmp ule i8 %y, %notx
1568 %cmpeq = icmp eq i8 %x, 0
1569 %r = and i1 %cmp, %cmpeq
1570 ret i1 %r
1571 }
1573 define i1 @uge_swap_and_max_commute_not_op(i8 %x, i8 %y) {
1574 ; CHECK-LABEL: @uge_swap_and_max_commute_not_op(
1575 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], 0
1576 ; CHECK-NEXT: ret i1 [[CMPEQ]]
1577 ;
1578 %notx = xor i8 %x, -1
1579 %cmp = icmp ule i8 %y, %notx
1580 %cmpeq = icmp eq i8 %x, 0
1581 %r = and i1 %cmpeq, %cmp
1582 ret i1 %r
1583 }
1585 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1586 ;
1587 ; (X == MIN) && (!X <= Y) --> X == MIN
1588 ;
1589 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1591 define i1 @sle_and_min_not_op(i8 %x, i8 %y) {
1592 ; CHECK-LABEL: @sle_and_min_not_op(
1593 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
1594 ; CHECK-NEXT: [[CMP:%.*]] = icmp sle i8 [[NOTX]], [[Y:%.*]]
1595 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -128
1596 ; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
1597 ; CHECK-NEXT: ret i1 [[R]]
1598 ;
1599 %notx = xor i8 %x, -1
1600 %cmp = icmp sle i8 %notx, %y
1601 %cmpeq = icmp eq i8 %x, 128
1602 %r = and i1 %cmp, %cmpeq
1603 ret i1 %r
1604 }
1606 define i1 @sle_and_min_commute_not_op(i8 %x, i8 %y) {
1607 ; CHECK-LABEL: @sle_and_min_commute_not_op(
1608 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
1609 ; CHECK-NEXT: [[CMP:%.*]] = icmp sle i8 [[NOTX]], [[Y:%.*]]
1610 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -128
1611 ; CHECK-NEXT: [[R:%.*]] = and i1 [[CMPEQ]], [[CMP]]
1612 ; CHECK-NEXT: ret i1 [[R]]
1613 ;
1614 %notx = xor i8 %x, -1
1615 %cmp = icmp sle i8 %notx, %y
1616 %cmpeq = icmp eq i8 %x, 128
1617 %r = and i1 %cmpeq, %cmp
1618 ret i1 %r
1619 }
1621 define i1 @sle_swap_and_min_not_op(i8 %x, i8 %y) {
1622 ; CHECK-LABEL: @sle_swap_and_min_not_op(
1623 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
1624 ; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[Y:%.*]], [[NOTX]]
1625 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -128
1626 ; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
1627 ; CHECK-NEXT: ret i1 [[R]]
1628 ;
1629 %notx = xor i8 %x, -1
1630 %cmp = icmp sge i8 %y, %notx
1631 %cmpeq = icmp eq i8 %x, 128
1632 %r = and i1 %cmp, %cmpeq
1633 ret i1 %r
1634 }
1636 define i1 @sle_swap_and_min_commute_not_op(i8 %x, i8 %y) {
1637 ; CHECK-LABEL: @sle_swap_and_min_commute_not_op(
1638 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
1639 ; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[Y:%.*]], [[NOTX]]
1640 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -128
1641 ; CHECK-NEXT: [[R:%.*]] = and i1 [[CMPEQ]], [[CMP]]
1642 ; CHECK-NEXT: ret i1 [[R]]
1643 ;
1644 %notx = xor i8 %x, -1
1645 %cmp = icmp sge i8 %y, %notx
1646 %cmpeq = icmp eq i8 %x, 128
1647 %r = and i1 %cmpeq, %cmp
1648 ret i1 %r
1649 }
1651 define i1 @ule_and_min_not_op(i8 %x, i8 %y) {
1652 ; CHECK-LABEL: @ule_and_min_not_op(
1653 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
1654 ; CHECK-NEXT: [[CMP:%.*]] = icmp ule i8 [[NOTX]], [[Y:%.*]]
1655 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], 0
1656 ; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
1657 ; CHECK-NEXT: ret i1 [[R]]
1658 ;
1659 %notx = xor i8 %x, -1
1660 %cmp = icmp ule i8 %notx, %y
1661 %cmpeq = icmp eq i8 %x, 0
1662 %r = and i1 %cmp, %cmpeq
1663 ret i1 %r
1664 }
1666 define i1 @ule_and_min_commute_not_op(i8 %x, i8 %y) {
1667 ; CHECK-LABEL: @ule_and_min_commute_not_op(
1668 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
1669 ; CHECK-NEXT: [[CMP:%.*]] = icmp ule i8 [[NOTX]], [[Y:%.*]]
1670 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], 0
1671 ; CHECK-NEXT: [[R:%.*]] = and i1 [[CMPEQ]], [[CMP]]
1672 ; CHECK-NEXT: ret i1 [[R]]
1673 ;
1674 %notx = xor i8 %x, -1
1675 %cmp = icmp ule i8 %notx, %y
1676 %cmpeq = icmp eq i8 %x, 0
1677 %r = and i1 %cmpeq, %cmp
1678 ret i1 %r
1679 }
1681 define i1 @ule_swap_and_min_not_op(i8 %x, i8 %y) {
1682 ; CHECK-LABEL: @ule_swap_and_min_not_op(
1683 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
1684 ; CHECK-NEXT: [[CMP:%.*]] = icmp uge i8 [[Y:%.*]], [[NOTX]]
1685 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], 0
1686 ; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
1687 ; CHECK-NEXT: ret i1 [[R]]
1688 ;
1689 %notx = xor i8 %x, -1
1690 %cmp = icmp uge i8 %y, %notx
1691 %cmpeq = icmp eq i8 %x, 0
1692 %r = and i1 %cmp, %cmpeq
1693 ret i1 %r
1694 }
1696 define i1 @ule_swap_and_min_commute_not_op(i8 %x, i8 %y) {
1697 ; CHECK-LABEL: @ule_swap_and_min_commute_not_op(
1698 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
1699 ; CHECK-NEXT: [[CMP:%.*]] = icmp uge i8 [[Y:%.*]], [[NOTX]]
1700 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], 0
1701 ; CHECK-NEXT: [[R:%.*]] = and i1 [[CMPEQ]], [[CMP]]
1702 ; CHECK-NEXT: ret i1 [[R]]
1703 ;
1704 %notx = xor i8 %x, -1
1705 %cmp = icmp uge i8 %y, %notx
1706 %cmpeq = icmp eq i8 %x, 0
1707 %r = and i1 %cmpeq, %cmp
1708 ret i1 %r
1709 }
1711 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1712 ;
1713 ; (X == MIN) || (!X >= Y) --> !X >= Y
1714 ;
1715 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1717 define i1 @sge_or_max_not_op(i8 %x, i8 %y) {
1718 ; CHECK-LABEL: @sge_or_max_not_op(
1719 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
1720 ; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[NOTX]], [[Y:%.*]]
1721 ; CHECK-NEXT: ret i1 [[CMP]]
1722 ;
1723 %notx = xor i8 %x, -1
1724 %cmp = icmp sge i8 %notx, %y
1725 %cmpeq = icmp eq i8 %x, 128
1726 %r = or i1 %cmp, %cmpeq
1727 ret i1 %r
1728 }
1730 define i1 @sge_or_max_commute_not_op(i8 %x, i8 %y) {
1731 ; CHECK-LABEL: @sge_or_max_commute_not_op(
1732 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
1733 ; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[NOTX]], [[Y:%.*]]
1734 ; CHECK-NEXT: ret i1 [[CMP]]
1735 ;
1736 %notx = xor i8 %x, -1
1737 %cmp = icmp sge i8 %notx, %y
1738 %cmpeq = icmp eq i8 %x, 128
1739 %r = or i1 %cmpeq, %cmp
1740 ret i1 %r
1741 }
1743 define i1 @sge_swap_or_max_not_op(i8 %x, i8 %y) {
1744 ; CHECK-LABEL: @sge_swap_or_max_not_op(
1745 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
1746 ; CHECK-NEXT: [[CMP:%.*]] = icmp sle i8 [[Y:%.*]], [[NOTX]]
1747 ; CHECK-NEXT: ret i1 [[CMP]]
1748 ;
1749 %notx = xor i8 %x, -1
1750 %cmp = icmp sle i8 %y, %notx
1751 %cmpeq = icmp eq i8 %x, 128
1752 %r = or i1 %cmp, %cmpeq
1753 ret i1 %r
1754 }
1756 define i1 @sge_swap_or_max_commute_not_op(i8 %x, i8 %y) {
1757 ; CHECK-LABEL: @sge_swap_or_max_commute_not_op(
1758 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
1759 ; CHECK-NEXT: [[CMP:%.*]] = icmp sle i8 [[Y:%.*]], [[NOTX]]
1760 ; CHECK-NEXT: ret i1 [[CMP]]
1761 ;
1762 %notx = xor i8 %x, -1
1763 %cmp = icmp sle i8 %y, %notx
1764 %cmpeq = icmp eq i8 %x, 128
1765 %r = or i1 %cmpeq, %cmp
1766 ret i1 %r
1767 }
1769 define i1 @uge_or_max_not_op(i8 %x, i8 %y) {
1770 ; CHECK-LABEL: @uge_or_max_not_op(
1771 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
1772 ; CHECK-NEXT: [[CMP:%.*]] = icmp uge i8 [[NOTX]], [[Y:%.*]]
1773 ; CHECK-NEXT: ret i1 [[CMP]]
1774 ;
1775 %notx = xor i8 %x, -1
1776 %cmp = icmp uge i8 %notx, %y
1777 %cmpeq = icmp eq i8 %x, 0
1778 %r = or i1 %cmp, %cmpeq
1779 ret i1 %r
1780 }
1782 define i1 @uge_or_max_commute_not_op(i8 %x, i8 %y) {
1783 ; CHECK-LABEL: @uge_or_max_commute_not_op(
1784 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
1785 ; CHECK-NEXT: [[CMP:%.*]] = icmp uge i8 [[NOTX]], [[Y:%.*]]
1786 ; CHECK-NEXT: ret i1 [[CMP]]
1787 ;
1788 %notx = xor i8 %x, -1
1789 %cmp = icmp uge i8 %notx, %y
1790 %cmpeq = icmp eq i8 %x, 0
1791 %r = or i1 %cmpeq, %cmp
1792 ret i1 %r
1793 }
1795 define i1 @uge_swap_or_max_not_op(i8 %x, i8 %y) {
1796 ; CHECK-LABEL: @uge_swap_or_max_not_op(
1797 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
1798 ; CHECK-NEXT: [[CMP:%.*]] = icmp ule i8 [[Y:%.*]], [[NOTX]]
1799 ; CHECK-NEXT: ret i1 [[CMP]]
1800 ;
1801 %notx = xor i8 %x, -1
1802 %cmp = icmp ule i8 %y, %notx
1803 %cmpeq = icmp eq i8 %x, 0
1804 %r = or i1 %cmp, %cmpeq
1805 ret i1 %r
1806 }
1808 define i1 @uge_swap_or_max_commute_not_op(i8 %x, i8 %y) {
1809 ; CHECK-LABEL: @uge_swap_or_max_commute_not_op(
1810 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
1811 ; CHECK-NEXT: [[CMP:%.*]] = icmp ule i8 [[Y:%.*]], [[NOTX]]
1812 ; CHECK-NEXT: ret i1 [[CMP]]
1813 ;
1814 %notx = xor i8 %x, -1
1815 %cmp = icmp ule i8 %y, %notx
1816 %cmpeq = icmp eq i8 %x, 0
1817 %r = or i1 %cmpeq, %cmp
1818 ret i1 %r
1819 }
1821 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1822 ;
1823 ; (X == MAX) || (!X <= Y) --> !X <= Y
1824 ;
1825 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1827 define i1 @sle_or_min_not_op(i8 %x, i8 %y) {
1828 ; CHECK-LABEL: @sle_or_min_not_op(
1829 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
1830 ; CHECK-NEXT: [[CMP:%.*]] = icmp sle i8 [[NOTX]], [[Y:%.*]]
1831 ; CHECK-NEXT: ret i1 [[CMP]]
1832 ;
1833 %notx = xor i8 %x, -1
1834 %cmp = icmp sle i8 %notx, %y
1835 %cmpeq = icmp eq i8 %x, 127
1836 %r = or i1 %cmp, %cmpeq
1837 ret i1 %r
1838 }
1840 define i1 @sle_or_min_commute_not_op(i8 %x, i8 %y) {
1841 ; CHECK-LABEL: @sle_or_min_commute_not_op(
1842 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
1843 ; CHECK-NEXT: [[CMP:%.*]] = icmp sle i8 [[NOTX]], [[Y:%.*]]
1844 ; CHECK-NEXT: ret i1 [[CMP]]
1845 ;
1846 %notx = xor i8 %x, -1
1847 %cmp = icmp sle i8 %notx, %y
1848 %cmpeq = icmp eq i8 %x, 127
1849 %r = or i1 %cmpeq, %cmp
1850 ret i1 %r
1851 }
1853 define i1 @sle_swap_or_min_not_op(i8 %x, i8 %y) {
1854 ; CHECK-LABEL: @sle_swap_or_min_not_op(
1855 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
1856 ; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[Y:%.*]], [[NOTX]]
1857 ; CHECK-NEXT: ret i1 [[CMP]]
1858 ;
1859 %notx = xor i8 %x, -1
1860 %cmp = icmp sge i8 %y, %notx
1861 %cmpeq = icmp eq i8 %x, 127
1862 %r = or i1 %cmp, %cmpeq
1863 ret i1 %r
1864 }
1866 define i1 @sle_swap_or_min_commute_not_op(i8 %x, i8 %y) {
1867 ; CHECK-LABEL: @sle_swap_or_min_commute_not_op(
1868 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
1869 ; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[Y:%.*]], [[NOTX]]
1870 ; CHECK-NEXT: ret i1 [[CMP]]
1871 ;
1872 %notx = xor i8 %x, -1
1873 %cmp = icmp sge i8 %y, %notx
1874 %cmpeq = icmp eq i8 %x, 127
1875 %r = or i1 %cmpeq, %cmp
1876 ret i1 %r
1877 }
1879 define i1 @ule_or_min_not_op(i8 %x, i8 %y) {
1880 ; CHECK-LABEL: @ule_or_min_not_op(
1881 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
1882 ; CHECK-NEXT: [[CMP:%.*]] = icmp ule i8 [[NOTX]], [[Y:%.*]]
1883 ; CHECK-NEXT: ret i1 [[CMP]]
1884 ;
1885 %notx = xor i8 %x, -1
1886 %cmp = icmp ule i8 %notx, %y
1887 %cmpeq = icmp eq i8 %x, 255
1888 %r = or i1 %cmp, %cmpeq
1889 ret i1 %r
1890 }
1892 define i1 @ule_or_min_commute_not_op(i8 %x, i8 %y) {
1893 ; CHECK-LABEL: @ule_or_min_commute_not_op(
1894 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
1895 ; CHECK-NEXT: [[CMP:%.*]] = icmp ule i8 [[NOTX]], [[Y:%.*]]
1896 ; CHECK-NEXT: ret i1 [[CMP]]
1897 ;
1898 %notx = xor i8 %x, -1
1899 %cmp = icmp ule i8 %notx, %y
1900 %cmpeq = icmp eq i8 %x, 255
1901 %r = or i1 %cmpeq, %cmp
1902 ret i1 %r
1903 }
1905 define i1 @ule_swap_or_min_not_op(i8 %x, i8 %y) {
1906 ; CHECK-LABEL: @ule_swap_or_min_not_op(
1907 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
1908 ; CHECK-NEXT: [[CMP:%.*]] = icmp uge i8 [[Y:%.*]], [[NOTX]]
1909 ; CHECK-NEXT: ret i1 [[CMP]]
1910 ;
1911 %notx = xor i8 %x, -1
1912 %cmp = icmp uge i8 %y, %notx
1913 %cmpeq = icmp eq i8 %x, 255
1914 %r = or i1 %cmp, %cmpeq
1915 ret i1 %r
1916 }
1918 define i1 @ule_swap_or_min_commute_not_op(i8 %x, i8 %y) {
1919 ; CHECK-LABEL: @ule_swap_or_min_commute_not_op(
1920 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
1921 ; CHECK-NEXT: [[CMP:%.*]] = icmp uge i8 [[Y:%.*]], [[NOTX]]
1922 ; CHECK-NEXT: ret i1 [[CMP]]
1923 ;
1924 %notx = xor i8 %x, -1
1925 %cmp = icmp uge i8 %y, %notx
1926 %cmpeq = icmp eq i8 %x, 255
1927 %r = or i1 %cmpeq, %cmp
1928 ret i1 %r
1929 }
1931 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1932 ;
1933 ; (X != MIN) && (!X < Y) --> !X < Y
1934 ;
1935 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1937 define i1 @slt_and_not_max_not_op(i8 %x, i8 %y) {
1938 ; CHECK-LABEL: @slt_and_not_max_not_op(
1939 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
1940 ; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[NOTX]], [[Y:%.*]]
1941 ; CHECK-NEXT: ret i1 [[CMP]]
1942 ;
1943 %notx = xor i8 %x, -1
1944 %cmp = icmp slt i8 %notx, %y
1945 %cmpeq = icmp ne i8 %x, 128
1946 %r = and i1 %cmp, %cmpeq
1947 ret i1 %r
1948 }
1950 define i1 @slt_and_not_max_commute_not_op(i8 %x, i8 %y) {
1951 ; CHECK-LABEL: @slt_and_not_max_commute_not_op(
1952 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
1953 ; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[NOTX]], [[Y:%.*]]
1954 ; CHECK-NEXT: ret i1 [[CMP]]
1955 ;
1956 %notx = xor i8 %x, -1
1957 %cmp = icmp slt i8 %notx, %y
1958 %cmpeq = icmp ne i8 %x, 128
1959 %r = and i1 %cmpeq, %cmp
1960 ret i1 %r
1961 }
1963 define i1 @slt_swap_and_not_max_not_op(i8 %x, i8 %y) {
1964 ; CHECK-LABEL: @slt_swap_and_not_max_not_op(
1965 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
1966 ; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[Y:%.*]], [[NOTX]]
1967 ; CHECK-NEXT: ret i1 [[CMP]]
1968 ;
1969 %notx = xor i8 %x, -1
1970 %cmp = icmp sgt i8 %y, %notx
1971 %cmpeq = icmp ne i8 %x, 128
1972 %r = and i1 %cmp, %cmpeq
1973 ret i1 %r
1974 }
1976 define i1 @slt_swap_and_not_max_commute_not_op(i8 %x, i8 %y) {
1977 ; CHECK-LABEL: @slt_swap_and_not_max_commute_not_op(
1978 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
1979 ; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[Y:%.*]], [[NOTX]]
1980 ; CHECK-NEXT: ret i1 [[CMP]]
1981 ;
1982 %notx = xor i8 %x, -1
1983 %cmp = icmp sgt i8 %y, %notx
1984 %cmpeq = icmp ne i8 %x, 128
1985 %r = and i1 %cmpeq, %cmp
1986 ret i1 %r
1987 }
1989 define i1 @ult_and_not_max_not_op(i8 %x, i8 %y) {
1990 ; CHECK-LABEL: @ult_and_not_max_not_op(
1991 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
1992 ; CHECK-NEXT: [[CMP:%.*]] = icmp ult i8 [[NOTX]], [[Y:%.*]]
1993 ; CHECK-NEXT: ret i1 [[CMP]]
1994 ;
1995 %notx = xor i8 %x, -1
1996 %cmp = icmp ult i8 %notx, %y
1997 %cmpeq = icmp ne i8 %x, 0
1998 %r = and i1 %cmp, %cmpeq
1999 ret i1 %r
2000 }
2002 define i1 @ult_and_not_max_commute_not_op(i8 %x, i8 %y) {
2003 ; CHECK-LABEL: @ult_and_not_max_commute_not_op(
2004 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
2005 ; CHECK-NEXT: [[CMP:%.*]] = icmp ult i8 [[NOTX]], [[Y:%.*]]
2006 ; CHECK-NEXT: ret i1 [[CMP]]
2007 ;
2008 %notx = xor i8 %x, -1
2009 %cmp = icmp ult i8 %notx, %y
2010 %cmpeq = icmp ne i8 %x, 0
2011 %r = and i1 %cmpeq, %cmp
2012 ret i1 %r
2013 }
2015 define i1 @ult_swap_and_not_max_not_op(i8 %x, i8 %y) {
2016 ; CHECK-LABEL: @ult_swap_and_not_max_not_op(
2017 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
2018 ; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i8 [[Y:%.*]], [[NOTX]]
2019 ; CHECK-NEXT: ret i1 [[CMP]]
2020 ;
2021 %notx = xor i8 %x, -1
2022 %cmp = icmp ugt i8 %y, %notx
2023 %cmpeq = icmp ne i8 %x, 0
2024 %r = and i1 %cmp, %cmpeq
2025 ret i1 %r
2026 }
2028 define i1 @ult_swap_and_not_max_commute_not_op(i8 %x, i8 %y) {
2029 ; CHECK-LABEL: @ult_swap_and_not_max_commute_not_op(
2030 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
2031 ; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i8 [[Y:%.*]], [[NOTX]]
2032 ; CHECK-NEXT: ret i1 [[CMP]]
2033 ;
2034 %notx = xor i8 %x, -1
2035 %cmp = icmp ugt i8 %y, %notx
2036 %cmpeq = icmp ne i8 %x, 0
2037 %r = and i1 %cmpeq, %cmp
2038 ret i1 %r
2039 }
2041 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2042 ;
2043 ; (X != MAX) && (!X > Y) --> !X > Y
2044 ;
2045 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2047 define i1 @sgt_and_not_min_not_op(i8 %x, i8 %y) {
2048 ; CHECK-LABEL: @sgt_and_not_min_not_op(
2049 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
2050 ; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[NOTX]], [[Y:%.*]]
2051 ; CHECK-NEXT: ret i1 [[CMP]]
2052 ;
2053 %notx = xor i8 %x, -1
2054 %cmp = icmp sgt i8 %notx, %y
2055 %cmpeq = icmp ne i8 %x, 127
2056 %r = and i1 %cmp, %cmpeq
2057 ret i1 %r
2058 }
2060 define i1 @sgt_and_not_min_commute_not_op(i8 %x, i8 %y) {
2061 ; CHECK-LABEL: @sgt_and_not_min_commute_not_op(
2062 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
2063 ; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[NOTX]], [[Y:%.*]]
2064 ; CHECK-NEXT: ret i1 [[CMP]]
2065 ;
2066 %notx = xor i8 %x, -1
2067 %cmp = icmp sgt i8 %notx, %y
2068 %cmpeq = icmp ne i8 %x, 127
2069 %r = and i1 %cmpeq, %cmp
2070 ret i1 %r
2071 }
2073 define i1 @sgt_swap_and_not_min_not_op(i8 %x, i8 %y) {
2074 ; CHECK-LABEL: @sgt_swap_and_not_min_not_op(
2075 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
2076 ; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[Y:%.*]], [[NOTX]]
2077 ; CHECK-NEXT: ret i1 [[CMP]]
2078 ;
2079 %notx = xor i8 %x, -1
2080 %cmp = icmp slt i8 %y, %notx
2081 %cmpeq = icmp ne i8 %x, 127
2082 %r = and i1 %cmp, %cmpeq
2083 ret i1 %r
2084 }
2086 define i1 @sgt_swap_and_not_min_commute_not_op(i8 %x, i8 %y) {
2087 ; CHECK-LABEL: @sgt_swap_and_not_min_commute_not_op(
2088 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
2089 ; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[Y:%.*]], [[NOTX]]
2090 ; CHECK-NEXT: ret i1 [[CMP]]
2091 ;
2092 %notx = xor i8 %x, -1
2093 %cmp = icmp slt i8 %y, %notx
2094 %cmpeq = icmp ne i8 %x, 127
2095 %r = and i1 %cmpeq, %cmp
2096 ret i1 %r
2097 }
2099 define i1 @ugt_and_not_min_not_op(i8 %x, i8 %y) {
2100 ; CHECK-LABEL: @ugt_and_not_min_not_op(
2101 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
2102 ; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i8 [[NOTX]], [[Y:%.*]]
2103 ; CHECK-NEXT: ret i1 [[CMP]]
2104 ;
2105 %notx = xor i8 %x, -1
2106 %cmp = icmp ugt i8 %notx, %y
2107 %cmpeq = icmp ne i8 %x, 255
2108 %r = and i1 %cmp, %cmpeq
2109 ret i1 %r
2110 }
2112 define i1 @ugt_and_not_min_commute_not_op(i8 %x, i8 %y) {
2113 ; CHECK-LABEL: @ugt_and_not_min_commute_not_op(
2114 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
2115 ; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i8 [[NOTX]], [[Y:%.*]]
2116 ; CHECK-NEXT: ret i1 [[CMP]]
2117 ;
2118 %notx = xor i8 %x, -1
2119 %cmp = icmp ugt i8 %notx, %y
2120 %cmpeq = icmp ne i8 %x, 255
2121 %r = and i1 %cmpeq, %cmp
2122 ret i1 %r
2123 }
2125 define i1 @ugt_swap_and_not_min_not_op(i8 %x, i8 %y) {
2126 ; CHECK-LABEL: @ugt_swap_and_not_min_not_op(
2127 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
2128 ; CHECK-NEXT: [[CMP:%.*]] = icmp ult i8 [[Y:%.*]], [[NOTX]]
2129 ; CHECK-NEXT: ret i1 [[CMP]]
2130 ;
2131 %notx = xor i8 %x, -1
2132 %cmp = icmp ult i8 %y, %notx
2133 %cmpeq = icmp ne i8 %x, 255
2134 %r = and i1 %cmp, %cmpeq
2135 ret i1 %r
2136 }
2138 define i1 @ugt_swap_and_not_min_commute_not_op(i8 %x, i8 %y) {
2139 ; CHECK-LABEL: @ugt_swap_and_not_min_commute_not_op(
2140 ; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
2141 ; CHECK-NEXT: [[CMP:%.*]] = icmp ult i8 [[Y:%.*]], [[NOTX]]
2142 ; CHECK-NEXT: ret i1 [[CMP]]
2143 ;
2144 %notx = xor i8 %x, -1
2145 %cmp = icmp ult i8 %y, %notx
2146 %cmpeq = icmp ne i8 %x, 255
2147 %r = and i1 %cmpeq, %cmp
2148 ret i1 %r
2149 }
2151 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2152 ;
2153 ; (X != MIN) || (!X < Y) --> X != MIN
2154 ;
2155 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2157 define i1 @slt_or_not_max_not_op(i8 %x, i8 %y) {
2158 ; CHECK-LABEL: @slt_or_not_max_not_op(
2159 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], -128
2160 ; CHECK-NEXT: ret i1 [[CMPEQ]]
2161 ;
2162 %notx = xor i8 %x, -1
2163 %cmp = icmp slt i8 %notx, %y
2164 %cmpeq = icmp ne i8 %x, 128
2165 %r = or i1 %cmp, %cmpeq
2166 ret i1 %r
2167 }
2169 define i1 @slt_or_not_max_commute_not_op(i8 %x, i8 %y) {
2170 ; CHECK-LABEL: @slt_or_not_max_commute_not_op(
2171 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], -128
2172 ; CHECK-NEXT: ret i1 [[CMPEQ]]
2173 ;
2174 %notx = xor i8 %x, -1
2175 %cmp = icmp slt i8 %notx, %y
2176 %cmpeq = icmp ne i8 %x, 128
2177 %r = or i1 %cmpeq, %cmp
2178 ret i1 %r
2179 }
2181 define i1 @slt_swap_or_not_max_not_op(i8 %x, i8 %y) {
2182 ; CHECK-LABEL: @slt_swap_or_not_max_not_op(
2183 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], -128
2184 ; CHECK-NEXT: ret i1 [[CMPEQ]]
2185 ;
2186 %notx = xor i8 %x, -1
2187 %cmp = icmp sgt i8 %y, %notx
2188 %cmpeq = icmp ne i8 %x, 128
2189 %r = or i1 %cmp, %cmpeq
2190 ret i1 %r
2191 }
2193 define i1 @slt_swap_or_not_max_commute_not_op(i8 %x, i8 %y) {
2194 ; CHECK-LABEL: @slt_swap_or_not_max_commute_not_op(
2195 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], -128
2196 ; CHECK-NEXT: ret i1 [[CMPEQ]]
2197 ;
2198 %notx = xor i8 %x, -1
2199 %cmp = icmp sgt i8 %y, %notx
2200 %cmpeq = icmp ne i8 %x, 128
2201 %r = or i1 %cmpeq, %cmp
2202 ret i1 %r
2203 }
2205 define i1 @ult_or_not_max_not_op(i8 %x, i8 %y) {
2206 ; CHECK-LABEL: @ult_or_not_max_not_op(
2207 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], 0
2208 ; CHECK-NEXT: ret i1 [[CMPEQ]]
2209 ;
2210 %notx = xor i8 %x, -1
2211 %cmp = icmp ult i8 %notx, %y
2212 %cmpeq = icmp ne i8 %x, 0
2213 %r = or i1 %cmp, %cmpeq
2214 ret i1 %r
2215 }
2217 define i1 @ult_or_not_max_commute_not_op(i8 %x, i8 %y) {
2218 ; CHECK-LABEL: @ult_or_not_max_commute_not_op(
2219 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], 0
2220 ; CHECK-NEXT: ret i1 [[CMPEQ]]
2221 ;
2222 %notx = xor i8 %x, -1
2223 %cmp = icmp ult i8 %notx, %y
2224 %cmpeq = icmp ne i8 %x, 0
2225 %r = or i1 %cmpeq, %cmp
2226 ret i1 %r
2227 }
2229 define i1 @ult_swap_or_not_max_not_op(i8 %x, i8 %y) {
2230 ; CHECK-LABEL: @ult_swap_or_not_max_not_op(
2231 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], 0
2232 ; CHECK-NEXT: ret i1 [[CMPEQ]]
2233 ;
2234 %notx = xor i8 %x, -1
2235 %cmp = icmp ugt i8 %y, %notx
2236 %cmpeq = icmp ne i8 %x, 0
2237 %r = or i1 %cmp, %cmpeq
2238 ret i1 %r
2239 }
2241 define i1 @ult_swap_or_not_max_commute_not_op(i8 %x, i8 %y) {
2242 ; CHECK-LABEL: @ult_swap_or_not_max_commute_not_op(
2243 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], 0
2244 ; CHECK-NEXT: ret i1 [[CMPEQ]]
2245 ;
2246 %notx = xor i8 %x, -1
2247 %cmp = icmp ugt i8 %y, %notx
2248 %cmpeq = icmp ne i8 %x, 0
2249 %r = or i1 %cmpeq, %cmp
2250 ret i1 %r
2251 }
2253 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2254 ;
2255 ; (X != MAX) || (!X > Y) --> X != MAX
2256 ;
2257 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2259 define i1 @sgt_or_not_min_not_op(i8 %x, i8 %y) {
2260 ; CHECK-LABEL: @sgt_or_not_min_not_op(
2261 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], 127
2262 ; CHECK-NEXT: ret i1 [[CMPEQ]]
2263 ;
2264 %notx = xor i8 %x, -1
2265 %cmp = icmp sgt i8 %notx, %y
2266 %cmpeq = icmp ne i8 %x, 127
2267 %r = or i1 %cmp, %cmpeq
2268 ret i1 %r
2269 }
2271 define i1 @sgt_or_not_min_commute_not_op(i8 %x, i8 %y) {
2272 ; CHECK-LABEL: @sgt_or_not_min_commute_not_op(
2273 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], 127
2274 ; CHECK-NEXT: ret i1 [[CMPEQ]]
2275 ;
2276 %notx = xor i8 %x, -1
2277 %cmp = icmp sgt i8 %notx, %y
2278 %cmpeq = icmp ne i8 %x, 127
2279 %r = or i1 %cmpeq, %cmp
2280 ret i1 %r
2281 }
2283 define i1 @sgt_swap_or_not_min_not_op(i8 %x, i8 %y) {
2284 ; CHECK-LABEL: @sgt_swap_or_not_min_not_op(
2285 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], 127
2286 ; CHECK-NEXT: ret i1 [[CMPEQ]]
2287 ;
2288 %notx = xor i8 %x, -1
2289 %cmp = icmp slt i8 %y, %notx
2290 %cmpeq = icmp ne i8 %x, 127
2291 %r = or i1 %cmp, %cmpeq
2292 ret i1 %r
2293 }
2295 define i1 @sgt_swap_or_not_min_commute_not_op(i8 %x, i8 %y) {
2296 ; CHECK-LABEL: @sgt_swap_or_not_min_commute_not_op(
2297 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], 127
2298 ; CHECK-NEXT: ret i1 [[CMPEQ]]
2299 ;
2300 %notx = xor i8 %x, -1
2301 %cmp = icmp slt i8 %y, %notx
2302 %cmpeq = icmp ne i8 %x, 127
2303 %r = or i1 %cmpeq, %cmp
2304 ret i1 %r
2305 }
2307 define i1 @ugt_or_not_min_not_op(i8 %x, i8 %y) {
2308 ; CHECK-LABEL: @ugt_or_not_min_not_op(
2309 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], -1
2310 ; CHECK-NEXT: ret i1 [[CMPEQ]]
2311 ;
2312 %notx = xor i8 %x, -1
2313 %cmp = icmp ugt i8 %notx, %y
2314 %cmpeq = icmp ne i8 %x, 255
2315 %r = or i1 %cmp, %cmpeq
2316 ret i1 %r
2317 }
2319 define i1 @ugt_or_not_min_commute_not_op(i8 %x, i8 %y) {
2320 ; CHECK-LABEL: @ugt_or_not_min_commute_not_op(
2321 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], -1
2322 ; CHECK-NEXT: ret i1 [[CMPEQ]]
2323 ;
2324 %notx = xor i8 %x, -1
2325 %cmp = icmp ugt i8 %notx, %y
2326 %cmpeq = icmp ne i8 %x, 255
2327 %r = or i1 %cmpeq, %cmp
2328 ret i1 %r
2329 }
2331 define i1 @ugt_swap_or_not_min_not_op(i8 %x, i8 %y) {
2332 ; CHECK-LABEL: @ugt_swap_or_not_min_not_op(
2333 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], -1
2334 ; CHECK-NEXT: ret i1 [[CMPEQ]]
2335 ;
2336 %notx = xor i8 %x, -1
2337 %cmp = icmp ult i8 %y, %notx
2338 %cmpeq = icmp ne i8 %x, 255
2339 %r = or i1 %cmp, %cmpeq
2340 ret i1 %r
2341 }
2343 define i1 @ugt_swap_or_not_min_commute_not_op(i823 %x, i823 %y) {
2344 ; CHECK-LABEL: @ugt_swap_or_not_min_commute_not_op(
2345 ; CHECK-NEXT: [[NOTX:%.*]] = xor i823 [[X:%.*]], -1
2346 ; CHECK-NEXT: [[CMP:%.*]] = icmp ult i823 [[Y:%.*]], [[NOTX]]
2347 ; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i823 [[X]], 255
2348 ; CHECK-NEXT: [[R:%.*]] = or i1 [[CMPEQ]], [[CMP]]
2349 ; CHECK-NEXT: ret i1 [[R]]
2350 ;
2351 %notx = xor i823 %x, -1
2352 %cmp = icmp ult i823 %y, %notx
2353 %cmpeq = icmp ne i823 %x, 255
2354 %r = or i1 %cmpeq, %cmp
2355 ret i1 %r
2356 }