Skip to content

Commit f844e3d

Browse files
AZero13AZero13
committed
[InstCombine] Canonicalize signed saturated additions with positive numbers only
https://alive2.llvm.org/ce/z/YGT5SN This is tricky because with positive numbers, we only go up, so we can in fact always hit the signed_max boundary. This is important because the intrinsic we use has the behavior of going the OTHER way, aka clamp to INT_MIN if it goes in that direction. And the range checking we do only works for positive numbers. Because of this issue, we can only do this for constants as well.
1 parent a043af5 commit f844e3d

File tree

3 files changed

+109
-21
lines changed

3 files changed

+109
-21
lines changed

‎llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

Lines changed: 104 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -1012,10 +1012,9 @@ static Value *canonicalizeSaturatedSubtract(const ICmpInst *ICI,
10121012
return Result;
10131013
}
10141014

1015-
static Value *canonicalizeSaturatedAdd(ICmpInst *Cmp, Value *TVal, Value *FVal,
1016-
InstCombiner::BuilderTy &Builder) {
1017-
if (!Cmp->hasOneUse())
1018-
return nullptr;
1015+
static Value *
1016+
canonicalizeSaturatedAddUnsigned(ICmpInst *Cmp, Value *TVal, Value *FVal,
1017+
InstCombiner::BuilderTy &Builder) {
10191018

10201019
// Match unsigned saturated add with constant.
10211020
Value *Cmp0 = Cmp->getOperand(0);
@@ -1037,8 +1036,7 @@ static Value *canonicalizeSaturatedAdd(ICmpInst *Cmp, Value *TVal, Value *FVal,
10371036
// uge -1 is canonicalized to eq -1 and requires special handling
10381037
// (a == -1) ? -1 : a + 1 -> uadd.sat(a, 1)
10391038
if (Pred == ICmpInst::ICMP_EQ) {
1040-
if (match(FVal, m_Add(m_Specific(Cmp0), m_One())) &&
1041-
match(Cmp1, m_AllOnes())) {
1039+
if (match(FVal, m_Add(m_Specific(Cmp0), m_One())) && Cmp1 == TVal) {
10421040
return Builder.CreateBinaryIntrinsic(
10431041
Intrinsic::uadd_sat, Cmp0, ConstantInt::get(Cmp0->getType(), 1));
10441042
}
@@ -1115,6 +1113,106 @@ static Value *canonicalizeSaturatedAdd(ICmpInst *Cmp, Value *TVal, Value *FVal,
11151113
return nullptr;
11161114
}
11171115

1116+
static Value *canonicalizeSaturatedAddSigned(ICmpInst *Cmp, Value *TVal,
1117+
Value *FVal,
1118+
InstCombiner::BuilderTy &Builder) {
1119+
// Match saturated add with constant.
1120+
Value *Cmp0 = Cmp->getOperand(0);
1121+
Value *Cmp1 = Cmp->getOperand(1);
1122+
ICmpInst::Predicate Pred = Cmp->getPredicate();
1123+
Value *X, *Y;
1124+
const APInt *C;
1125+
1126+
// Canonicalize INT_MAX to true value of the select.
1127+
if (match(FVal, m_MaxSignedValue())) {
1128+
std::swap(TVal, FVal);
1129+
Pred = CmpInst::getInversePredicate(Pred);
1130+
}
1131+
if (!match(TVal, m_MaxSignedValue()))
1132+
return nullptr;
1133+
1134+
// sge maximum signed value is canonicalized to eq minimum signed value and
1135+
// requires special handling (a == INT_MAX) ? INT_MAX : a + 1 -> sadd.sat(a,
1136+
// 1)
1137+
if (Pred == ICmpInst::ICMP_EQ) {
1138+
if (match(FVal, m_Add(m_Specific(Cmp0), m_One())) && Cmp1 == TVal) {
1139+
return Builder.CreateBinaryIntrinsic(
1140+
Intrinsic::sadd_sat, Cmp0, ConstantInt::get(Cmp0->getType(), 1));
1141+
}
1142+
return nullptr;
1143+
}
1144+
1145+
if ((Pred == ICmpInst::ICMP_SGE || Pred == ICmpInst::ICMP_SGT) &&
1146+
match(FVal, m_Add(m_Specific(Cmp0), m_APIntAllowPoison(C))) &&
1147+
match(Cmp1, m_SpecificIntAllowPoison(
1148+
APInt::getSignedMaxValue(
1149+
Cmp1->getType()->getScalarSizeInBits()) -
1150+
*C))) {
1151+
// (X > INT_MAX - C) ? INT_MAX : (X + C) --> sadd.sat(X, C)
1152+
// (X >= INT_MAX - C) ? INT_MAX : (X + C) --> sadd.sat(X, C)
1153+
return Builder.CreateBinaryIntrinsic(Intrinsic::sadd_sat, Cmp0,
1154+
ConstantInt::get(Cmp0->getType(), *C));
1155+
}
1156+
1157+
if (Pred == ICmpInst::ICMP_SGT &&
1158+
match(FVal, m_Add(m_Specific(Cmp0), m_APIntAllowPoison(C))) &&
1159+
match(Cmp1, m_SpecificIntAllowPoison(
1160+
APInt::getSignedMaxValue(
1161+
Cmp1->getType()->getScalarSizeInBits()) -
1162+
*C - 1)) &&
1163+
!C->isSignedMinValue()) {
1164+
// (X > INT_MAX - C - 1) ? INT_MAX : (X + C) --> sadd.sat(X, C)
1165+
return Builder.CreateBinaryIntrinsic(Intrinsic::sadd_sat, Cmp0,
1166+
ConstantInt::get(Cmp0->getType(), *C));
1167+
}
1168+
1169+
if (Pred == ICmpInst::ICMP_SGE &&
1170+
match(FVal, m_Add(m_Specific(Cmp0), m_APIntAllowPoison(C))) &&
1171+
match(Cmp1, m_SpecificIntAllowPoison(
1172+
APInt::getSignedMinValue(
1173+
Cmp1->getType()->getScalarSizeInBits()) -
1174+
*C + 1)) &&
1175+
!C->isZero()) {
1176+
// (X >= INT_MAX - C + 1) ? INT_MAX : (X + C) --> sadd.sat(X, C)
1177+
return Builder.CreateBinaryIntrinsic(Intrinsic::sadd_sat, Cmp0,
1178+
ConstantInt::get(Cmp0->getType(), *C));
1179+
}
1180+
1181+
// Canonicalize predicate to less-than or less-or-equal-than.
1182+
if (Pred == ICmpInst::ICMP_SGT || Pred == ICmpInst::ICMP_SGE) {
1183+
std::swap(Cmp0, Cmp1);
1184+
Pred = CmpInst::getSwappedPredicate(Pred);
1185+
}
1186+
1187+
if (Pred != ICmpInst::ICMP_SLT && Pred != ICmpInst::ICMP_SLE)
1188+
return nullptr;
1189+
1190+
if (match(Cmp0, m_NSWSub(m_MaxSignedValue(), m_Value(X))) &&
1191+
match(FVal, m_c_Add(m_Specific(X), m_Value(Y))) && Y == Cmp1) {
1192+
// (INT_MAX - X s< Y) ? INT_MAX : (X + Y) --> sadd.sat(X, Y)
1193+
// (INT_MAX - X s< Y) ? INT_MAX : (Y + X) --> sadd.sat(X, Y)
1194+
return Builder.CreateBinaryIntrinsic(Intrinsic::sadd_sat, X, Y);
1195+
}
1196+
1197+
// TODO: More cases?
1198+
1199+
return nullptr;
1200+
}
1201+
1202+
static Value *canonicalizeSaturatedAdd(ICmpInst *Cmp, Value *TVal, Value *FVal,
1203+
InstCombiner::BuilderTy &Builder) {
1204+
if (!Cmp->hasOneUse())
1205+
return nullptr;
1206+
1207+
if (Value *V = canonicalizeSaturatedAddUnsigned(Cmp, TVal, FVal, Builder))
1208+
return V;
1209+
1210+
if (Value *V = canonicalizeSaturatedAddSigned(Cmp, TVal, FVal, Builder))
1211+
return V;
1212+
1213+
return nullptr;
1214+
}
1215+
11181216
/// Try to match patterns with select and subtract as absolute difference.
11191217
static Value *foldAbsDiff(ICmpInst *Cmp, Value *TVal, Value *FVal,
11201218
InstCombiner::BuilderTy &Builder) {

‎llvm/test/Transforms/InstCombine/canonicalize-const-to-bop.ll

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -123,8 +123,7 @@ define i8 @udiv_slt_exact(i8 %x) {
123123
define i8 @canonicalize_icmp_operands(i8 %x) {
124124
; CHECK-LABEL: define i8 @canonicalize_icmp_operands(
125125
; CHECK-SAME: i8 [[X:%.*]]) {
126-
; CHECK-NEXT: [[TMP1:%.*]] = call i8 @llvm.smin.i8(i8 [[X]], i8 119)
127-
; CHECK-NEXT: [[S:%.*]] = add nsw i8 [[TMP1]], 8
126+
; CHECK-NEXT: [[S:%.*]] = call i8 @llvm.sadd.sat.i8(i8 [[X]], i8 8)
128127
; CHECK-NEXT: ret i8 [[S]]
129128
;
130129
%add = add nsw i8 %x, 8

‎llvm/test/Transforms/InstCombine/saturating-add-sub.ll

Lines changed: 4 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -2378,9 +2378,7 @@ define i8 @sadd_sat_ugt_int_max(i8 %x, i8 %y) {
23782378

23792379
define i8 @sadd_sat_eq_int_max(i8 %x) {
23802380
; CHECK-LABEL: @sadd_sat_eq_int_max(
2381-
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i8 [[X:%.*]], 127
2382-
; CHECK-NEXT: [[ADD:%.*]] = add i8 [[X]], 1
2383-
; CHECK-NEXT: [[R:%.*]] = select i1 [[CMP]], i8 127, i8 [[ADD]]
2381+
; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.sadd.sat.i8(i8 [[X:%.*]], i8 1)
23842382
; CHECK-NEXT: ret i8 [[R]]
23852383
;
23862384
%cmp = icmp eq i8 %x, 127
@@ -2391,8 +2389,7 @@ define i8 @sadd_sat_eq_int_max(i8 %x) {
23912389

23922390
define i8 @sadd_sat_constant(i8 %x) {
23932391
; CHECK-LABEL: @sadd_sat_constant(
2394-
; CHECK-NEXT: [[TMP1:%.*]] = call i8 @llvm.smin.i8(i8 [[X:%.*]], i8 117)
2395-
; CHECK-NEXT: [[R:%.*]] = add nsw i8 [[TMP1]], 10
2392+
; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.sadd.sat.i8(i8 [[X:%.*]], i8 10)
23962393
; CHECK-NEXT: ret i8 [[R]]
23972394
;
23982395
%cmp = icmp sge i8 %x, 118
@@ -2611,10 +2608,7 @@ define i8 @sadd_sat_commuted_both(i8 %x, i8 %y) {
26112608

26122609
define i8 @sadd_sat_int_max_minus_x_nsw_slt(i8 %x, i8 %y) {
26132610
; CHECK-LABEL: @sadd_sat_int_max_minus_x_nsw_slt(
2614-
; CHECK-NEXT: [[SUB:%.*]] = sub nsw i8 127, [[X:%.*]]
2615-
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[SUB]], [[Y:%.*]]
2616-
; CHECK-NEXT: [[ADD:%.*]] = add i8 [[X]], [[Y]]
2617-
; CHECK-NEXT: [[R:%.*]] = select i1 [[CMP]], i8 127, i8 [[ADD]]
2611+
; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.sadd.sat.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
26182612
; CHECK-NEXT: ret i8 [[R]]
26192613
;
26202614
%sub = sub nsw i8 127, %x
@@ -2626,10 +2620,7 @@ define i8 @sadd_sat_int_max_minus_x_nsw_slt(i8 %x, i8 %y) {
26262620

26272621
define i8 @sadd_sat_int_max_minus_x_nsw_sge_commuted(i8 %x, i8 %y) {
26282622
; CHECK-LABEL: @sadd_sat_int_max_minus_x_nsw_sge_commuted(
2629-
; CHECK-NEXT: [[SUB:%.*]] = sub nsw i8 127, [[X:%.*]]
2630-
; CHECK-NEXT: [[CMP_NOT:%.*]] = icmp slt i8 [[Y:%.*]], [[SUB]]
2631-
; CHECK-NEXT: [[ADD:%.*]] = add i8 [[X]], [[Y]]
2632-
; CHECK-NEXT: [[R:%.*]] = select i1 [[CMP_NOT]], i8 [[ADD]], i8 127
2623+
; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.sadd.sat.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
26332624
; CHECK-NEXT: ret i8 [[R]]
26342625
;
26352626
%sub = sub nsw i8 127, %x

0 commit comments

Comments
 (0)