[llvm-branch-commits] [llvm] [ConstraintElim] A signed sum of operands with opposite signs cannot wrap (PR #235159)
Jon Roelofs via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Mon Nov 9 11:54:42 PST 2026
https://github.com/jroelofs updated https://github.com/llvm/llvm-project/pull/235159
>From 3294c71414f6dac5c31b70fffde33ba00d5af711 Mon Sep 17 00:00:00 2001
From: Jon Roelofs <jonathan_roelofs at apple.com>
Date: Thu, 5 Nov 2026 13:39:08 -0800
Subject: [PATCH 1/2] [ConstraintElim] A signed sum of operands with opposite
signs cannot wrap
If one operand is known non-negative and the other non-positive, the signed
sum is between them, so it cannot overflow.
https://alive2.llvm.org/ce/z/ZF5Yqr
---
.../Scalar/ConstraintElimination.cpp | 19 ++++++
.../ConstraintElimination/add-nsw.ll | 9 +--
.../sadd-with-overflow.ll | 62 +++++++++++++++++++
3 files changed, 84 insertions(+), 6 deletions(-)
diff --git a/llvm/lib/Transforms/Scalar/ConstraintElimination.cpp b/llvm/lib/Transforms/Scalar/ConstraintElimination.cpp
index dfb16aaed655b7..bbf0c828a0dbc2 100644
--- a/llvm/lib/Transforms/Scalar/ConstraintElimination.cpp
+++ b/llvm/lib/Transforms/Scalar/ConstraintElimination.cpp
@@ -419,6 +419,10 @@ class ConstraintInfo {
/// system implies it or because ValueTracking can prove it.
bool isKnownPositive(Value *V);
+ /// Returns true if \p V is known to be non-positive, either because the
+ /// signed system implies it or because ValueTracking can prove it.
+ bool isKnownNonPositive(Value *V);
+
/// Returns true if \p V is known to be negative, false if \p V is known to be
/// nonnegative, or std::nullopt if neither the signed system nor
/// ValueTracking can prove it.
@@ -628,6 +632,14 @@ static bool isKnownNoWrap(Instruction::BinaryOps Opcode, Value *Op0, Value *Op1,
return true;
}
+ // A signed sum of operands with opposite signs cannot wrap.
+ if (Signed && Opcode == Instruction::Add) {
+ if (Info.isKnownNonNegative(Op0) && Info.isKnownNonPositive(Op1))
+ return true;
+ if (Info.isKnownNonPositive(Op0) && Info.isKnownNonNegative(Op1))
+ return true;
+ }
+
if (!Signed && (NoWrapFlags & OBO::NoSignedWrap) &&
(Opcode == Instruction::Shl || Info.isKnownNonNegative(Op1)) &&
Info.isKnownNonNegative(Op0))
@@ -1165,6 +1177,13 @@ bool ConstraintInfo::isKnownPositive(Value *V) {
doesHold(CmpInst::ICMP_SGT, V, ConstantInt::get(V->getType(), 0));
}
+bool ConstraintInfo::isKnownNonPositive(Value *V) {
+ if (auto *CI = dyn_cast<ConstantInt>(V))
+ return CI->getValue().isNonPositive();
+ return ::isKnownNegative(V, DL) ||
+ doesHold(CmpInst::ICMP_SLE, V, ConstantInt::get(V->getType(), 0));
+}
+
std::optional<bool> ConstraintInfo::getKnownSign(Value *V) {
KnownBits Known = computeKnownBits(V, DL);
if (Known.isNonNegative())
diff --git a/llvm/test/Transforms/ConstraintElimination/add-nsw.ll b/llvm/test/Transforms/ConstraintElimination/add-nsw.ll
index 07ad9a51f1912d..757ed12e167308 100644
--- a/llvm/test/Transforms/ConstraintElimination/add-nsw.ll
+++ b/llvm/test/Transforms/ConstraintElimination/add-nsw.ll
@@ -978,8 +978,7 @@ define i1 @add_non_positive_slt(i64 %x, i64 %y, i64 %b) {
; CHECK-NEXT: [[C:%.*]] = icmp slt i64 [[X]], [[B:%.*]]
; CHECK-NEXT: call void @llvm.assume(i1 [[C]])
; CHECK-NEXT: [[SUB:%.*]] = add i64 [[X]], [[Y]]
-; CHECK-NEXT: [[T:%.*]] = icmp slt i64 [[SUB]], [[B]]
-; CHECK-NEXT: ret i1 [[T]]
+; CHECK-NEXT: ret i1 true
;
%x.non.neg = icmp sge i64 %x, 0
call void @llvm.assume(i1 %x.non.neg)
@@ -1001,8 +1000,7 @@ define i1 @add_non_positive_slt_commuted(i64 %x, i64 %y, i64 %b) {
; CHECK-NEXT: [[C:%.*]] = icmp slt i64 [[X]], [[B:%.*]]
; CHECK-NEXT: call void @llvm.assume(i1 [[C]])
; CHECK-NEXT: [[SUB:%.*]] = add i64 [[Y]], [[X]]
-; CHECK-NEXT: [[T:%.*]] = icmp slt i64 [[SUB]], [[B]]
-; CHECK-NEXT: ret i1 [[T]]
+; CHECK-NEXT: ret i1 true
;
%x.non.neg = icmp sge i64 %x, 0
call void @llvm.assume(i1 %x.non.neg)
@@ -1026,8 +1024,7 @@ define i1 @add_non_positive_slt_hoisted(i64 %x, i64 %y, i64 %b) {
; CHECK-NEXT: [[SUB:%.*]] = add i64 [[X]], [[Y]]
; CHECK-NEXT: br i1 [[AND_2]], label [[IF_END:%.*]], label [[EXIT:%.*]]
; CHECK: if.end:
-; CHECK-NEXT: [[T:%.*]] = icmp slt i64 [[SUB]], [[B]]
-; CHECK-NEXT: ret i1 [[T]]
+; CHECK-NEXT: ret i1 true
; CHECK: exit:
; CHECK-NEXT: ret i1 false
;
diff --git a/llvm/test/Transforms/ConstraintElimination/sadd-with-overflow.ll b/llvm/test/Transforms/ConstraintElimination/sadd-with-overflow.ll
index 4194797fa5ea05..df7d867003d68c 100644
--- a/llvm/test/Transforms/ConstraintElimination/sadd-with-overflow.ll
+++ b/llvm/test/Transforms/ConstraintElimination/sadd-with-overflow.ll
@@ -318,3 +318,65 @@ then:
else:
ret i8 0
}
+
+define void @sadd_opposite_signs(i64 %v, i64 %s) {
+; CHECK-LABEL: define void @sadd_opposite_signs(
+; CHECK-SAME: i64 [[V:%.*]], i64 [[S:%.*]]) {
+; CHECK-NEXT: [[ENTRY:.*:]]
+; CHECK-NEXT: [[A:%.*]] = lshr i64 [[V]], 1
+; CHECK-NEXT: [[C:%.*]] = icmp sge i64 [[S]], 0
+; CHECK-NEXT: call void @llvm.assume(i1 [[C]])
+; CHECK-NEXT: [[N:%.*]] = xor i64 [[S]], -1
+; CHECK-NEXT: call void @use(i1 false)
+; CHECK-NEXT: ret void
+;
+entry:
+ %a = lshr i64 %v, 1
+ %c = icmp sge i64 %s, 0
+ call void @llvm.assume(i1 %c)
+ %n = xor i64 %s, -1
+ %r = call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %a, i64 %n)
+ %ov = extractvalue { i64, i1 } %r, 1
+ call void @use(i1 %ov)
+ ret void
+}
+
+define void @sadd_same_signs(i64 %v, i64 %s) {
+; CHECK-LABEL: define void @sadd_same_signs(
+; CHECK-SAME: i64 [[V:%.*]], i64 [[S:%.*]]) {
+; CHECK-NEXT: [[ENTRY:.*:]]
+; CHECK-NEXT: [[A:%.*]] = lshr i64 [[V]], 1
+; CHECK-NEXT: [[C:%.*]] = icmp sge i64 [[S]], 0
+; CHECK-NEXT: call void @llvm.assume(i1 [[C]])
+; CHECK-NEXT: [[R:%.*]] = call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 [[A]], i64 [[S]])
+; CHECK-NEXT: [[OV:%.*]] = extractvalue { i64, i1 } [[R]], 1
+; CHECK-NEXT: call void @use(i1 [[OV]])
+; CHECK-NEXT: ret void
+;
+entry:
+ %a = lshr i64 %v, 1
+ %c = icmp sge i64 %s, 0
+ call void @llvm.assume(i1 %c)
+ %r = call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %a, i64 %s)
+ %ov = extractvalue { i64, i1 } %r, 1
+ call void @use(i1 %ov)
+ ret void
+}
+
+define void @sadd_opposite_signs_known_negative(i8 %v, i8 %w) {
+; CHECK-LABEL: define void @sadd_opposite_signs_known_negative(
+; CHECK-SAME: i8 [[V:%.*]], i8 [[W:%.*]]) {
+; CHECK-NEXT: [[ENTRY:.*:]]
+; CHECK-NEXT: [[A:%.*]] = lshr i8 [[V]], 1
+; CHECK-NEXT: [[B:%.*]] = or i8 [[W]], -128
+; CHECK-NEXT: call void @use(i1 false)
+; CHECK-NEXT: ret void
+;
+entry:
+ %a = lshr i8 %v, 1
+ %b = or i8 %w, -128
+ %r = call { i8, i1 } @llvm.sadd.with.overflow.i8(i8 %a, i8 %b)
+ %ov = extractvalue { i8, i1 } %r, 1
+ call void @use(i1 %ov)
+ ret void
+}
>From 53fccf605baa227d289dcb3f1e7411b160552088 Mon Sep 17 00:00:00 2001
From: Jon Roelofs <jonathan_roelofs at apple.com>
Date: Mon, 9 Nov 2026 11:06:56 -0800
Subject: [PATCH 2/2] cache known bits for opposite signs check
---
.../Scalar/ConstraintElimination.cpp | 23 +++++++++++--------
1 file changed, 13 insertions(+), 10 deletions(-)
diff --git a/llvm/lib/Transforms/Scalar/ConstraintElimination.cpp b/llvm/lib/Transforms/Scalar/ConstraintElimination.cpp
index bbf0c828a0dbc2..482a86cecce488 100644
--- a/llvm/lib/Transforms/Scalar/ConstraintElimination.cpp
+++ b/llvm/lib/Transforms/Scalar/ConstraintElimination.cpp
@@ -413,7 +413,7 @@ class ConstraintInfo {
/// Returns true if \p V is known to be non-negative, either because the
/// signed system implies it or because ValueTracking can prove it.
- bool isKnownNonNegative(Value *V);
+ bool isKnownNonNegative(const WithCache<const Value *> &V);
/// Returns true if \p V is known to be positive, either because the signed
/// system implies it or because ValueTracking can prove it.
@@ -421,7 +421,7 @@ class ConstraintInfo {
/// Returns true if \p V is known to be non-positive, either because the
/// signed system implies it or because ValueTracking can prove it.
- bool isKnownNonPositive(Value *V);
+ bool isKnownNonPositive(const WithCache<const Value *> &V);
/// Returns true if \p V is known to be negative, false if \p V is known to be
/// nonnegative, or std::nullopt if neither the signed system nor
@@ -634,9 +634,10 @@ static bool isKnownNoWrap(Instruction::BinaryOps Opcode, Value *Op0, Value *Op1,
// A signed sum of operands with opposite signs cannot wrap.
if (Signed && Opcode == Instruction::Add) {
- if (Info.isKnownNonNegative(Op0) && Info.isKnownNonPositive(Op1))
+ WithCache<const Value *> KnownOp0{Op0}, KnownOp1{Op1};
+ if (Info.isKnownNonNegative(KnownOp0) && Info.isKnownNonPositive(KnownOp1))
return true;
- if (Info.isKnownNonPositive(Op0) && Info.isKnownNonNegative(Op1))
+ if (Info.isKnownNonPositive(KnownOp0) && Info.isKnownNonNegative(KnownOp1))
return true;
}
@@ -1163,11 +1164,12 @@ bool ConstraintInfo::doesHold(CmpInst::Predicate Pred, Value *A, Value *B) {
.value_or(false);
}
-bool ConstraintInfo::isKnownNonNegative(Value *V) {
- if (auto *CI = dyn_cast<ConstantInt>(V))
+bool ConstraintInfo::isKnownNonNegative(const WithCache<const Value *> &V) {
+ if (auto *CI = dyn_cast<ConstantInt>(V.getValue()))
return !CI->isNegative();
return ::isKnownNonNegative(V, DL) ||
- doesHold(CmpInst::ICMP_SGE, V, ConstantInt::get(V->getType(), 0));
+ doesHold(CmpInst::ICMP_SGE, const_cast<Value *>(V.getValue()),
+ ConstantInt::get(V->getType(), 0));
}
bool ConstraintInfo::isKnownPositive(Value *V) {
@@ -1177,11 +1179,12 @@ bool ConstraintInfo::isKnownPositive(Value *V) {
doesHold(CmpInst::ICMP_SGT, V, ConstantInt::get(V->getType(), 0));
}
-bool ConstraintInfo::isKnownNonPositive(Value *V) {
- if (auto *CI = dyn_cast<ConstantInt>(V))
+bool ConstraintInfo::isKnownNonPositive(const WithCache<const Value *> &V) {
+ if (auto *CI = dyn_cast<ConstantInt>(V.getValue()))
return CI->getValue().isNonPositive();
return ::isKnownNegative(V, DL) ||
- doesHold(CmpInst::ICMP_SLE, V, ConstantInt::get(V->getType(), 0));
+ doesHold(CmpInst::ICMP_SLE, const_cast<Value *>(V.getValue()),
+ ConstantInt::get(V->getType(), 0));
}
std::optional<bool> ConstraintInfo::getKnownSign(Value *V) {
More information about the llvm-branch-commits
mailing list