This is an archive of the discontinued LLVM Phabricator instance.

Differential D154938

[InstCombine] Test cases for D154937
ClosedPublic

Authored by 0xdc03 on Jul 11 2023, 3:08 AM.

Details

Reviewers
nikic
Commits
rGb336f9deeba2: [InstCombine] Test cases for D154937
Summary

Create test cases for the following two folds:

(icmp eq X, C) | (icmp ult Other, (X - C)) -> (icmp ule Other, (X - (C + 1)))
(icmp ne X, C) & (icmp uge Other, (X - C)) -> (icmp ugt Other, (X - (C + 1)))

Diff Detail

Event Timeline

0xdc03 created this revision.Jul 11 2023, 3:08 AM
Herald added a project: Restricted Project. · View Herald TranscriptJul 11 2023, 3:08 AM
Herald added a subscriber: StephenFan. · View Herald Transcript
0xdc03 requested review of this revision.Jul 11 2023, 3:08 AM
Herald added a project: Restricted Project. · View Herald TranscriptJul 11 2023, 3:08 AM
Herald added a subscriber: llvm-commits. · View Herald Transcript
0xdc03 added a child revision: D154937: [InstCombine] Generalize foldAndOrOfICmpEqZeroAndICmp.Jul 11 2023, 3:08 AM
0xdc03 mentioned this in D154937: [InstCombine] Generalize foldAndOrOfICmpEqZeroAndICmp.Jul 11 2023, 3:11 AM
0xdc03 updated this revision to Diff 539013.Jul 11 2023, 4:05 AM
  • Remove unnecessary tests
  • Fix typo: 'vetor' -> 'vector'
  • Fix commuted test cases
Harbormaster completed remote builds in B244412: Diff 539013.Jul 11 2023, 6:14 AM
nikic accepted this revision.Jul 11 2023, 6:38 AM

LGTM

llvm/test/Transforms/InstCombine/and-or-icmp-const-icmp.ll
504

I'd personally save a lot of these tests -- generally we want to see one test of each "kind", but not every possible combination. So a test for eq, ne, vectors and mismatched constants each, rather than all 8 combinations of eq/ne, scalar/vector and matching/mismatching for example.

This revision is now accepted and ready to land.Jul 11 2023, 6:38 AM
0xdc03 updated this revision to Diff 539083.Jul 11 2023, 7:12 AM
  • Reduce test count to half
0xdc03 marked an inline comment as done.Jul 11 2023, 7:13 AM
0xdc03 added inline comments.
llvm/test/Transforms/InstCombine/and-or-icmp-const-icmp.ll
504

That's a great idea, I have halved the test count by interpolating the eq and ne tests :)

0xdc03 marked an inline comment as done.Jul 11 2023, 7:14 AM
0xdc03 updated this revision to Diff 539098.Jul 11 2023, 7:45 AM
  • Add an undef splat vector test
Harbormaster completed remote builds in B244472: Diff 539098.Jul 11 2023, 10:36 AM
Closed by commit rGb336f9deeba2: [InstCombine] Test cases for D154937 (authored by 0xdc03). · Explain WhyJul 11 2023, 10:44 PM
This revision was automatically updated to reflect the committed changes.
0xdc03 added a commit: rGb336f9deeba2: [InstCombine] Test cases for D154937.

Revision Contents

PathSize
llvm/
test/
Transforms/
InstCombine/
294 lines

Diff 539386

llvm/test/Transforms/InstCombine/and-or-icmp-const-icmp.ll

  • This file was added.
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 3
; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Tests for foldAndOrOfICmpEqConstantAndICmp
; https://github.com/llvm/llvm-project/issues/63749
; ==============================================================================
; (icmp eq X, C) | (icmp ult Other, (X - C)) -> (icmp ule Other, (X - (C + 1)))
; (icmp ne X, C) & (icmp uge Other, (X - C)) -> (icmp ugt Other, (X - (C + 1)))
; ==============================================================================
; ==============================================================================
; Basic tests
; ==============================================================================
define i1 @eq_basic(i8 %x, i8 %y) {
; CHECK-LABEL: define i1 @eq_basic
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]]) {
; CHECK-NEXT: [[TMP1:%.*]] = add i8 [[X]], -1
; CHECK-NEXT: [[OR:%.*]] = icmp uge i8 [[TMP1]], [[Y]]
; CHECK-NEXT: ret i1 [[OR]]
;
%c1 = icmp eq i8 %x, 0
%c2 = icmp ugt i8 %x, %y
%or = or i1 %c1, %c2
ret i1 %or
}
define i1 @ne_basic_equal_5(i8 %x, i8 %y) {
; CHECK-LABEL: define i1 @ne_basic_equal_5
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]]) {
; CHECK-NEXT: [[SUB:%.*]] = add i8 [[X]], -5
; CHECK-NEXT: [[C1:%.*]] = icmp ne i8 [[X]], 5
; CHECK-NEXT: [[C2:%.*]] = icmp ule i8 [[SUB]], [[Y]]
; CHECK-NEXT: [[AND:%.*]] = and i1 [[C1]], [[C2]]
; CHECK-NEXT: ret i1 [[AND]]
;
%sub = add i8 %x, -5
%c1 = icmp ne i8 %x, 5
%c2 = icmp ule i8 %sub, %y
%and = and i1 %c1, %c2
ret i1 %and
}
define i1 @eq_basic_equal_minus_1(i8 %x, i8 %y) {
; CHECK-LABEL: define i1 @eq_basic_equal_minus_1
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]]) {
; CHECK-NEXT: [[ADD:%.*]] = add i8 [[X]], 1
; CHECK-NEXT: [[C1:%.*]] = icmp eq i8 [[X]], -1
; CHECK-NEXT: [[C2:%.*]] = icmp ugt i8 [[ADD]], [[Y]]
; CHECK-NEXT: [[OR:%.*]] = or i1 [[C1]], [[C2]]
; CHECK-NEXT: ret i1 [[OR]]
;
%add = add i8 %x, 1
%c1 = icmp eq i8 %x, -1
%c2 = icmp ugt i8 %add, %y
%or = or i1 %c1, %c2
ret i1 %or
}
define i1 @ne_basic_equal_minus_7(i8 %x, i8 %y) {
; CHECK-LABEL: define i1 @ne_basic_equal_minus_7
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]]) {
; CHECK-NEXT: [[ADD:%.*]] = add i8 [[X]], 7
; CHECK-NEXT: [[C1:%.*]] = icmp ne i8 [[X]], -7
; CHECK-NEXT: [[C2:%.*]] = icmp ule i8 [[ADD]], [[Y]]
; CHECK-NEXT: [[AND:%.*]] = and i1 [[C1]], [[C2]]
; CHECK-NEXT: ret i1 [[AND]]
;
%add = add i8 %x, 7
%c1 = icmp ne i8 %x, -7
%c2 = icmp ule i8 %add, %y
%and = and i1 %c1, %c2
ret i1 %and
}
define i1 @eq_basic_unequal(i8 %x, i8 %y) {
; CHECK-LABEL: define i1 @eq_basic_unequal
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]]) {
; CHECK-NEXT: [[SUB:%.*]] = add i8 [[X]], -5
; CHECK-NEXT: [[C1:%.*]] = icmp eq i8 [[X]], 6
; CHECK-NEXT: [[C2:%.*]] = icmp ugt i8 [[SUB]], [[Y]]
; CHECK-NEXT: [[OR:%.*]] = or i1 [[C1]], [[C2]]
; CHECK-NEXT: ret i1 [[OR]]
;
%sub = add i8 %x, -5
%c1 = icmp eq i8 %x, 6
%c2 = icmp ugt i8 %sub, %y
%or = or i1 %c1, %c2
ret i1 %or
}
define i1 @ne_basic_unequal(i8 %x, i8 %y) {
; CHECK-LABEL: define i1 @ne_basic_unequal
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]]) {
; CHECK-NEXT: [[ADD:%.*]] = add i8 [[X]], 7
; CHECK-NEXT: [[C1:%.*]] = icmp ne i8 [[X]], -4
; CHECK-NEXT: [[C2:%.*]] = icmp ule i8 [[ADD]], [[Y]]
; CHECK-NEXT: [[AND:%.*]] = and i1 [[C1]], [[C2]]
; CHECK-NEXT: ret i1 [[AND]]
;
%add = add i8 %x, 7
%c1 = icmp ne i8 %x, -4
%c2 = icmp ule i8 %add, %y
%and = and i1 %c1, %c2
ret i1 %and
}
; ==============================================================================
; Tests with multiple uses
; ==============================================================================
define i1 @eq_multi_c1(i8 %x, i8 %y) {
; CHECK-LABEL: define i1 @eq_multi_c1
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]]) {
; CHECK-NEXT: [[C1:%.*]] = icmp eq i8 [[X]], 0
; CHECK-NEXT: [[TMP1:%.*]] = add i8 [[X]], -1
; CHECK-NEXT: [[OR:%.*]] = icmp uge i8 [[TMP1]], [[Y]]
; CHECK-NEXT: call void @use(i1 [[C1]])
; CHECK-NEXT: ret i1 [[OR]]
;
%c1 = icmp eq i8 %x, 0
%c2 = icmp ugt i8 %x, %y
%or = or i1 %c1, %c2
call void @use(i1 %c1)
ret i1 %or
}
define i1 @ne_multi_c2(i8 %x, i8 %y) {
; CHECK-LABEL: define i1 @ne_multi_c2
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]]) {
; CHECK-NEXT: [[C2:%.*]] = icmp ule i8 [[X]], [[Y]]
; CHECK-NEXT: [[TMP1:%.*]] = add i8 [[X]], -1
; CHECK-NEXT: [[AND:%.*]] = icmp ult i8 [[TMP1]], [[Y]]
; CHECK-NEXT: call void @use(i1 [[C2]])
; CHECK-NEXT: ret i1 [[AND]]
;
%c1 = icmp ne i8 %x, 0
%c2 = icmp ule i8 %x, %y
%and = and i1 %c1, %c2
call void @use(i1 %c2)
ret i1 %and
}
; ==============================================================================
; Tests with vector types
; ==============================================================================
define <2 x i1> @eq_vector(<2 x i8> %x, <2 x i8> %y) {
; CHECK-LABEL: define <2 x i1> @eq_vector
; CHECK-SAME: (<2 x i8> [[X:%.*]], <2 x i8> [[Y:%.*]]) {
; CHECK-NEXT: [[TMP1:%.*]] = add <2 x i8> [[X]], <i8 -1, i8 -1>
; CHECK-NEXT: [[OR:%.*]] = icmp uge <2 x i8> [[TMP1]], [[Y]]
; CHECK-NEXT: ret <2 x i1> [[OR]]
;
%c1 = icmp eq <2 x i8> %x, <i8 0, i8 0>
%c2 = icmp ugt <2 x i8> %x, %y
%or = or <2 x i1> %c1, %c2
ret <2 x i1> %or
}
define <2 x i1> @ne_vector_equal_5(<2 x i8> %x, <2 x i8> %y) {
; CHECK-LABEL: define <2 x i1> @ne_vector_equal_5
; CHECK-SAME: (<2 x i8> [[X:%.*]], <2 x i8> [[Y:%.*]]) {
; CHECK-NEXT: [[SUB:%.*]] = add <2 x i8> [[X]], <i8 -5, i8 -5>
; CHECK-NEXT: [[C1:%.*]] = icmp ne <2 x i8> [[X]], <i8 5, i8 5>
; CHECK-NEXT: [[C2:%.*]] = icmp ule <2 x i8> [[SUB]], [[Y]]
; CHECK-NEXT: [[AND:%.*]] = and <2 x i1> [[C1]], [[C2]]
; CHECK-NEXT: ret <2 x i1> [[AND]]
;
%sub = add <2 x i8> %x, <i8 -5, i8 -5>
%c1 = icmp ne <2 x i8> %x, <i8 5, i8 5>
%c2 = icmp ule <2 x i8> %sub, %y
%and = and <2 x i1> %c1, %c2
ret <2 x i1> %and
}
define <2 x i1> @eq_vector_equal_minus_1(<2 x i8> %x, <2 x i8> %y) {
; CHECK-LABEL: define <2 x i1> @eq_vector_equal_minus_1
; CHECK-SAME: (<2 x i8> [[X:%.*]], <2 x i8> [[Y:%.*]]) {
; CHECK-NEXT: [[ADD:%.*]] = add <2 x i8> [[X]], <i8 1, i8 1>
; CHECK-NEXT: [[C1:%.*]] = icmp eq <2 x i8> [[X]], <i8 -1, i8 -1>
; CHECK-NEXT: [[C2:%.*]] = icmp ugt <2 x i8> [[ADD]], [[Y]]
; CHECK-NEXT: [[OR:%.*]] = or <2 x i1> [[C1]], [[C2]]
; CHECK-NEXT: ret <2 x i1> [[OR]]
;
%add = add <2 x i8> %x, <i8 1, i8 1>
%c1 = icmp eq <2 x i8> %x, <i8 -1, i8 -1>
%c2 = icmp ugt <2 x i8> %add, %y
%or = or <2 x i1> %c1, %c2
ret <2 x i1> %or
}
define <2 x i1> @ne_vector_equal_minus_7(<2 x i8> %x, <2 x i8> %y) {
; CHECK-LABEL: define <2 x i1> @ne_vector_equal_minus_7
; CHECK-SAME: (<2 x i8> [[X:%.*]], <2 x i8> [[Y:%.*]]) {
; CHECK-NEXT: [[ADD:%.*]] = add <2 x i8> [[X]], <i8 7, i8 7>
; CHECK-NEXT: [[C1:%.*]] = icmp ne <2 x i8> [[X]], <i8 -7, i8 -7>
; CHECK-NEXT: [[C2:%.*]] = icmp ule <2 x i8> [[ADD]], [[Y]]
; CHECK-NEXT: [[AND:%.*]] = and <2 x i1> [[C1]], [[C2]]
; CHECK-NEXT: ret <2 x i1> [[AND]]
;
%add = add <2 x i8> %x, <i8 7, i8 7>
%c1 = icmp ne <2 x i8> %x, <i8 -7, i8 -7>
%c2 = icmp ule <2 x i8> %add, %y
%and = and <2 x i1> %c1, %c2
ret <2 x i1> %and
}
define <2 x i1> @eq_vector_unequal1(<2 x i8> %x, <2 x i8> %y) {
; CHECK-LABEL: define <2 x i1> @eq_vector_unequal1
; CHECK-SAME: (<2 x i8> [[X:%.*]], <2 x i8> [[Y:%.*]]) {
; CHECK-NEXT: [[SUB:%.*]] = add <2 x i8> [[X]], <i8 -5, i8 -5>
; CHECK-NEXT: [[C1:%.*]] = icmp eq <2 x i8> [[X]], <i8 2, i8 2>
; CHECK-NEXT: [[C2:%.*]] = icmp ugt <2 x i8> [[SUB]], [[Y]]
; CHECK-NEXT: [[OR:%.*]] = or <2 x i1> [[C1]], [[C2]]
; CHECK-NEXT: ret <2 x i1> [[OR]]
;
%sub = add <2 x i8> %x, <i8 -5, i8 -5>
%c1 = icmp eq <2 x i8> %x, <i8 2, i8 2>
%c2 = icmp ugt <2 x i8> %sub, %y
%or = or <2 x i1> %c1, %c2
ret <2 x i1> %or
}
define <2 x i1> @ne_vector_unequal2(<2 x i8> %x, <2 x i8> %y) {
; CHECK-LABEL: define <2 x i1> @ne_vector_unequal2
; CHECK-SAME: (<2 x i8> [[X:%.*]], <2 x i8> [[Y:%.*]]) {
; CHECK-NEXT: [[ADD:%.*]] = add <2 x i8> [[X]], <i8 7, i8 7>
; CHECK-NEXT: [[C1:%.*]] = icmp ne <2 x i8> [[X]], <i8 -3, i8 -3>
; CHECK-NEXT: [[C2:%.*]] = icmp ule <2 x i8> [[ADD]], [[Y]]
; CHECK-NEXT: [[AND:%.*]] = and <2 x i1> [[C1]], [[C2]]
; CHECK-NEXT: ret <2 x i1> [[AND]]
;
%add = add <2 x i8> %x, <i8 7, i8 7>
%c1 = icmp ne <2 x i8> %x, <i8 -3, i8 -3>
%c2 = icmp ule <2 x i8> %add, %y
%and = and <2 x i1> %c1, %c2
ret <2 x i1> %and
}
; ==============================================================================
; Tests with undef
; ==============================================================================
define <2 x i1> @eq_vector_undef(<2 x i8> %x, <2 x i8> %y) {
; CHECK-LABEL: define <2 x i1> @eq_vector_undef
; CHECK-SAME: (<2 x i8> [[X:%.*]], <2 x i8> [[Y:%.*]]) {
; CHECK-NEXT: [[SUB:%.*]] = add <2 x i8> [[X]], <i8 -5, i8 -5>
; CHECK-NEXT: [[C1:%.*]] = icmp eq <2 x i8> [[X]], <i8 5, i8 undef>
; CHECK-NEXT: [[C2:%.*]] = icmp ugt <2 x i8> [[SUB]], [[Y]]
; CHECK-NEXT: [[OR:%.*]] = or <2 x i1> [[C1]], [[C2]]
; CHECK-NEXT: ret <2 x i1> [[OR]]
;
%sub = add <2 x i8> %x, <i8 -5, i8 -5>
%c1 = icmp eq <2 x i8> %x, <i8 5, i8 undef>
%c2 = icmp ugt <2 x i8> %sub, %y
%or = or <2 x i1> %c1, %c2
ret <2 x i1> %or
}
; ==============================================================================
; Tests with values commuted
; ==============================================================================
define i1 @eq_commuted(i8 %x, i8 %py) {
; CHECK-LABEL: define i1 @eq_commuted
; CHECK-SAME: (i8 [[X:%.*]], i8 [[PY:%.*]]) {
; CHECK-NEXT: [[Y:%.*]] = sdiv i8 43, [[PY]]
; CHECK-NEXT: [[TMP1:%.*]] = add i8 [[X]], -1
; CHECK-NEXT: [[OR:%.*]] = icmp uge i8 [[TMP1]], [[Y]]
; CHECK-NEXT: ret i1 [[OR]]
;
%y = sdiv i8 43, %py ; thwart complexity-based canonicalization
%c1 = icmp eq i8 %x, 0
%c2 = icmp ult i8 %y, %x
%or = or i1 %c1, %c2
ret i1 %or
}
define i1 @ne_commuted_equal_minus_1(i8 %x, i8 %py) {
; CHECK-LABEL: define i1 @ne_commuted_equal_minus_1
; CHECK-SAME: (i8 [[X:%.*]], i8 [[PY:%.*]]) {
; CHECK-NEXT: [[Y:%.*]] = sdiv i8 42, [[PY]]
; CHECK-NEXT: [[ADD:%.*]] = add i8 [[X]], 1
; CHECK-NEXT: [[C1:%.*]] = icmp ne i8 [[X]], -1
; CHECK-NEXT: [[C2:%.*]] = icmp uge i8 [[Y]], [[ADD]]
; CHECK-NEXT: [[AND:%.*]] = and i1 [[C1]], [[C2]]
; CHECK-NEXT: ret i1 [[AND]]
;
%y = sdiv i8 42, %py ; thwart complexity-based canonicalization
%add = add i8 %x, 1
%c1 = icmp ne i8 %x, -1
%c2 = icmp uge i8 %y, %add
%and = and i1 %c1, %c2
ret i1 %and
}
declare void @use(i1)
nikicUnsubmitted
Done
ReplyInline Actions

I'd personally save a lot of these tests -- generally we want to see one test of each "kind", but not every possible combination. So a test for eq, ne, vectors and mismatched constants each, rather than all 8 combinations of eq/ne, scalar/vector and matching/mismatching for example.

nikic: I'd personally save a lot of these tests -- generally we want to see one test of each "kind"…
0xdc03AuthorUnsubmitted
Done
ReplyInline Actions

That's a great idea, I have halved the test count by interpolating the eq and ne tests :)

0xdc03: That's a great idea, I have halved the test count by interpolating the eq and ne tests :)