This is an archive of the discontinued LLVM Phabricator instance.

Differential D144840

[ConstraintElimination] Add tests to check for type bounds optimisation from zext instructions
Needs ReviewPublic

Authored by zjaffal on Feb 26 2023, 10:59 PM.

Details

Reviewers
fhahn
nikic
spatel
Summary

Currently we don't utilize the information that if we have a zext operation we can put an upperbound limit to the value if we know that the zext operand is not used in any sign-extended operation

Diff Detail

Event Timeline

zjaffal created this revision.Feb 26 2023, 10:59 PM
Herald added a project: Restricted Project. · View Herald TranscriptFeb 26 2023, 10:59 PM
Herald added a subscriber: StephenFan. · View Herald Transcript
zjaffal requested review of this revision.Feb 26 2023, 10:59 PM
Herald added a project: Restricted Project. · View Herald TranscriptFeb 26 2023, 10:59 PM
Herald added a subscriber: llvm-commits. · View Herald Transcript
Harbormaster completed remote builds in B216143: Diff 500668.Feb 27 2023, 12:21 AM
zjaffal added a child revision: D144842: [ConstraintElimination] Add upper bound info based on maximum type bounds for zext instructions.Feb 27 2023, 1:52 AM
zjaffal removed a child revision: D144842: [ConstraintElimination] Add upper bound info based on maximum type bounds for zext instructions.
zjaffal added a child revision: D144841: [ConstraintElimination] Replace isKnownNegative entry with upper and lower bound info for each decomposed variable..
zjaffal updated this revision to Diff 500795.Feb 27 2023, 8:01 AM

Add additional tests where we don't have the inital condition for the function argument. The entry check is
unecessary because the typebounds can be optimised if the constraint system already contained the function
arguemnts.

Harbormaster completed remote builds in B216226: Diff 500795.Feb 27 2023, 9:11 AM
zjaffal added a comment.Apr 14 2023, 4:49 AM

ping

fhahn added inline comments.Apr 21 2023, 1:45 AM
llvm/test/Transforms/ConstraintElimination/type-bounds.ll
61

it's simpler to just return an i1 instead, this also makes verification easier.

183

nit: newline above.

326

could you also add a variant where we compare to a constant less than 255? And larger than 255?

zjaffal updated this revision to Diff 516806.Apr 25 2023, 7:57 AM

Remove redundant tests and simplify tests

Harbormaster completed remote builds in B228031: Diff 516806.Apr 25 2023, 8:28 AM

Revision Contents

PathSize
llvm/
test/
Transforms/
ConstraintElimination/
212 lines

Diff 516806

llvm/test/Transforms/ConstraintElimination/type-bounds.ll

  • This file was added.
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -passes=constraint-elimination -S %s | FileCheck %s
declare void @llvm.assume(i1)
define i1 @zext_cmp_i1_to_i32(i1 %a, i32 %b) {
; CHECK-LABEL: @zext_cmp_i1_to_i32(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A_EXT:%.*]] = zext i1 [[A:%.*]] to i32
; CHECK-NEXT: [[CMP_1:%.*]] = icmp ugt i32 [[B:%.*]], 1
; CHECK-NEXT: call void @llvm.assume(i1 [[CMP_1]])
; CHECK-NEXT: [[CMP_2:%.*]] = icmp ult i32 [[A_EXT]], [[B]]
; CHECK-NEXT: ret i1 [[CMP_2]]
;
entry:
%a.ext = zext i1 %a to i32
%cmp.1 = icmp ugt i32 %b, 1
call void @llvm.assume(i1 %cmp.1)
%cmp.2 = icmp ult i32 %a.ext, %b
ret i1 %cmp.2
}
define i1 @zext_cmp_i1_to_i32_2(i1 %a, i32 %b) {
; CHECK-LABEL: @zext_cmp_i1_to_i32_2(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A_EXT:%.*]] = zext i1 [[A:%.*]] to i32
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i32 [[A_EXT]], [[B:%.*]]
; CHECK-NEXT: ret i1 [[CMP]]
;
entry:
%a.ext = zext i1 %a to i32
%cmp = icmp ult i32 %a.ext, %b
ret i1 %cmp
}
define i1 @zext_cmp_i1_to_i32_signed(i1 %a, i32 %b) {
; CHECK-LABEL: @zext_cmp_i1_to_i32_signed(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A_EXT:%.*]] = zext i1 [[A:%.*]] to i32
; CHECK-NEXT: [[CMP_1:%.*]] = icmp ugt i32 [[B:%.*]], 1
; CHECK-NEXT: call void @llvm.assume(i1 [[CMP_1]])
; CHECK-NEXT: [[CMP_2:%.*]] = icmp slt i32 [[A_EXT]], [[B]]
; CHECK-NEXT: ret i1 [[CMP_2]]
;
entry:
%a.ext = zext i1 %a to i32
%cmp.1 = icmp ugt i32 %b, 1
call void @llvm.assume(i1 %cmp.1)
%cmp.2 = icmp slt i32 %a.ext, %b
ret i1 %cmp.2
}
define i1 @zext_cmp_vector_bounds(<2 x i8> %a, <2 x i32> %b) {
; CHECK-LABEL: @zext_cmp_vector_bounds(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A_EXT:%.*]] = zext <2 x i8> [[A:%.*]] to <2 x i32>
; CHECK-NEXT: [[CMP_1:%.*]] = icmp ugt <2 x i32> [[B:%.*]], <i32 255, i32 255>
; CHECK-NEXT: [[CONT_1:%.*]] = extractelement <2 x i1> [[CMP_1]], i32 0
; CHECK-NEXT: [[CONT_2:%.*]] = extractelement <2 x i1> [[CMP_1]], i32 1
; CHECK-NEXT: [[AND:%.*]] = and i1 [[CONT_1]], [[CONT_2]]
; CHECK-NEXT: call void @llvm.assume(i1 [[AND]])
fhahnUnsubmitted
Not Done
ReplyInline Actions

it's simpler to just return an i1 instead, this also makes verification easier.

fhahn: it's simpler to just return an `i1` instead, this also makes verification easier.
; CHECK-NEXT: [[CMP_2:%.*]] = icmp ult <2 x i32> [[A_EXT]], [[B]]
; CHECK-NEXT: [[CONT_3:%.*]] = extractelement <2 x i1> [[CMP_1]], i32 0
; CHECK-NEXT: [[CONT_4:%.*]] = extractelement <2 x i1> [[CMP_1]], i32 1
; CHECK-NEXT: [[AND_2:%.*]] = and i1 [[CONT_3]], [[CONT_4]]
; CHECK-NEXT: ret i1 [[AND_2]]
;
entry:
%a.ext = zext <2 x i8> %a to <2 x i32>
%cmp.1 = icmp ugt <2 x i32> %b, <i32 255, i32 255>
%cont.1 = extractelement <2 x i1> %cmp.1, i32 0
%cont.2 = extractelement <2 x i1> %cmp.1, i32 1
%and = and i1 %cont.1, %cont.2
call void @llvm.assume(i1 %and)
%cmp.2 = icmp ult <2 x i32> %a.ext, %b
%cont.3 = extractelement <2 x i1> %cmp.1, i32 0
%cont.4 = extractelement <2 x i1> %cmp.1, i32 1
%and.2 = and i1 %cont.3, %cont.4
ret i1 %and.2
}
define i1 @zext_cmp_i8_to_i32(i8 %a, i32 %b) {
; CHECK-LABEL: @zext_cmp_i8_to_i32(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A_EXT:%.*]] = zext i8 [[A:%.*]] to i32
; CHECK-NEXT: [[CMP_1:%.*]] = icmp ugt i32 [[B:%.*]], 255
; CHECK-NEXT: call void @llvm.assume(i1 [[CMP_1]])
; CHECK-NEXT: [[CMP_2:%.*]] = icmp ult i32 [[A_EXT]], [[B]]
; CHECK-NEXT: ret i1 [[CMP_2]]
;
entry:
%a.ext = zext i8 %a to i32
%cmp.1 = icmp ugt i32 %b, 255
call void @llvm.assume(i1 %cmp.1)
%cmp.2 = icmp ult i32 %a.ext, %b
ret i1 %cmp.2
}
define i1 @zext_cmp_i8_to_i32_less_than_255(i8 %a, i32 %b) {
; CHECK-LABEL: @zext_cmp_i8_to_i32_less_than_255(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A_EXT:%.*]] = zext i8 [[A:%.*]] to i32
; CHECK-NEXT: [[CMP_1:%.*]] = icmp ugt i32 [[B:%.*]], 240
; CHECK-NEXT: call void @llvm.assume(i1 [[CMP_1]])
; CHECK-NEXT: [[CMP_2:%.*]] = icmp ult i32 [[A_EXT]], [[B]]
; CHECK-NEXT: ret i1 [[CMP_2]]
;
entry:
%a.ext = zext i8 %a to i32
%cmp.1 = icmp ugt i32 %b, 240
call void @llvm.assume(i1 %cmp.1)
%cmp.2 = icmp ult i32 %a.ext, %b
ret i1 %cmp.2
}
define i1 @zext_cmp_i8_to_i32_greater_than_255(i8 %a, i32 %b) {
; CHECK-LABEL: @zext_cmp_i8_to_i32_greater_than_255(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A_EXT:%.*]] = zext i8 [[A:%.*]] to i32
; CHECK-NEXT: [[CMP_1:%.*]] = icmp ugt i32 [[B:%.*]], 260
; CHECK-NEXT: call void @llvm.assume(i1 [[CMP_1]])
; CHECK-NEXT: [[CMP_2:%.*]] = icmp ult i32 [[A_EXT]], [[B]]
; CHECK-NEXT: ret i1 [[CMP_2]]
;
entry:
%a.ext = zext i8 %a to i32
%cmp.1 = icmp ugt i32 %b, 260
call void @llvm.assume(i1 %cmp.1)
%cmp.2 = icmp ult i32 %a.ext, %b
ret i1 %cmp.2
}
define i1 @zext_cmp_i8_to_i32_add(i8 %a, i8 %b, i32 %c) {
; CHECK-LABEL: @zext_cmp_i8_to_i32_add(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[ADD:%.*]] = add nuw nsw i8 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[ADD_EXT:%.*]] = zext i8 [[ADD]] to i32
; CHECK-NEXT: [[CMP_1:%.*]] = icmp ugt i32 [[C:%.*]], 255
; CHECK-NEXT: call void @llvm.assume(i1 [[CMP_1]])
; CHECK-NEXT: [[CMP_2:%.*]] = icmp ult i32 [[ADD_EXT]], [[C]]
; CHECK-NEXT: ret i1 [[CMP_2]]
;
entry:
%add = add nuw nsw i8 %a, %b
%add.ext = zext i8 %add to i32
%cmp.1 = icmp ugt i32 %c, 255
call void @llvm.assume(i1 %cmp.1)
%cmp.2 = icmp ult i32 %add.ext, %c
ret i1 %cmp.2
}
define i1 @zext_multiple_uses(i8 %a, i32 %b, i32 %b2) {
; CHECK-LABEL: @zext_multiple_uses(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A_EXT:%.*]] = zext i8 [[A:%.*]] to i32
; CHECK-NEXT: [[A2_EXT:%.*]] = zext i8 [[A]] to i32
; CHECK-NEXT: [[CMP_1:%.*]] = icmp ugt i32 [[B:%.*]], 255
; CHECK-NEXT: [[CMP_2:%.*]] = icmp ugt i32 [[B2:%.*]], 255
; CHECK-NEXT: [[PRE_CMP:%.*]] = and i1 [[CMP_1]], [[CMP_2]]
; CHECK-NEXT: br i1 [[PRE_CMP]], label [[COND:%.*]], label [[EXIT:%.*]]
; CHECK: cond:
; CHECK-NEXT: [[CMP_3:%.*]] = icmp ult i32 [[A_EXT]], [[B]]
; CHECK-NEXT: [[CMP_4:%.*]] = icmp ult i32 [[A2_EXT]], [[B2]]
; CHECK-NEXT: [[AND:%.*]] = and i1 [[CMP_3]], [[CMP_4]]
; CHECK-NEXT: ret i1 [[AND]]
; CHECK: exit:
; CHECK-NEXT: ret i1 false
;
entry:
%a.ext = zext i8 %a to i32
%a2.ext = zext i8 %a to i32
%cmp.1 = icmp ugt i32 %b, 255
%cmp.2 = icmp ugt i32 %b2, 255
%pre.cmp = and i1 %cmp.1, %cmp.2
br i1 %pre.cmp, label %cond, label %exit
cond:
%cmp.3 = icmp ult i32 %a.ext, %b
%cmp.4 = icmp ult i32 %a2.ext, %b2
%and = and i1 %cmp.3, %cmp.4
ret i1 %and
exit:
fhahnUnsubmitted
Not Done
ReplyInline Actions

nit: newline above.

fhahn: nit: newline above.
ret i1 false
}
define i1 @zext_operand_used_in_sext(i8 %a, i32 %b, i32 %b2) {
; CHECK-LABEL: @zext_operand_used_in_sext(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A_EXT:%.*]] = zext i8 [[A:%.*]] to i32
; CHECK-NEXT: [[A2_EXT:%.*]] = sext i8 [[A]] to i32
; CHECK-NEXT: [[CMP_1:%.*]] = icmp ugt i32 [[B:%.*]], 255
; CHECK-NEXT: [[CMP_2:%.*]] = icmp ugt i32 [[B2:%.*]], 255
; CHECK-NEXT: [[PRE_CMP:%.*]] = and i1 [[CMP_1]], [[CMP_2]]
; CHECK-NEXT: call void @llvm.assume(i1 [[PRE_CMP]])
; CHECK-NEXT: [[CMP_3:%.*]] = icmp ult i32 [[A_EXT]], [[B]]
; CHECK-NEXT: [[CMP_4:%.*]] = icmp ult i32 [[A2_EXT]], [[B2]]
; CHECK-NEXT: [[AND:%.*]] = and i1 [[CMP_3]], [[CMP_4]]
; CHECK-NEXT: ret i1 [[AND]]
;
entry:
%a.ext = zext i8 %a to i32
%a2.ext = sext i8 %a to i32
%cmp.1 = icmp ugt i32 %b, 255
%cmp.2 = icmp ugt i32 %b2, 255
%pre.cmp = and i1 %cmp.1, %cmp.2
call void @llvm.assume(i1 %pre.cmp)
%cmp.3 = icmp ult i32 %a.ext, %b
%cmp.4 = icmp ult i32 %a2.ext, %b2
%and = and i1 %cmp.3, %cmp.4
ret i1 %and
}
fhahnUnsubmitted
Not Done
ReplyInline Actions

could you also add a variant where we compare to a constant less than 255? And larger than 255?

fhahn: could you also add a variant where we compare to a constant less than 255? And larger than 255?