[Mlir-commits] [mlir] [mlir][Interfaces] Track and infer no-overflow flags in integer ranges (PR #191777)
Hocky Yudhiono
llvmlistbot at llvm.org
Mon Apr 13 03:17:17 PDT 2026
https://github.com/hockyy updated https://github.com/llvm/llvm-project/pull/191777
>From bc8d2d58e079aa9619bc51874f1c60498eca5cb6 Mon Sep 17 00:00:00 2001
From: Hocky Yudhiono <hocky.yudhiono at gmail.com>
Date: Mon, 13 Apr 2026 17:08:01 +0800
Subject: [PATCH 1/2] [mlir][Interfaces] Track and infer no-overflow flags in
integer ranges
---
.../mlir/Interfaces/InferIntRangeInterface.h | 25 +++-
.../Interfaces/Utils/InferIntRangeCommon.h | 8 +-
.../Arith/IR/InferIntRangeInterfaceImpls.cpp | 132 +++++++++++++++++-
.../lib/Interfaces/InferIntRangeInterface.cpp | 31 +++-
.../Interfaces/InferIntRangeInterfaceTest.cpp | 59 ++++++++
5 files changed, 236 insertions(+), 19 deletions(-)
diff --git a/mlir/include/mlir/Interfaces/InferIntRangeInterface.h b/mlir/include/mlir/Interfaces/InferIntRangeInterface.h
index a6de3d1885eec..9870cf1cbb6fa 100644
--- a/mlir/include/mlir/Interfaces/InferIntRangeInterface.h
+++ b/mlir/include/mlir/Interfaces/InferIntRangeInterface.h
@@ -15,9 +15,18 @@
#define MLIR_INTERFACES_INFERINTRANGEINTERFACE_H
#include "mlir/IR/OpDefinition.h"
+#include "llvm/ADT/BitmaskEnum.h"
#include <optional>
namespace mlir {
+enum class OverflowFlags : uint32_t {
+ None = 0,
+ Nsw = 1,
+ Nuw = 2,
+ LLVM_MARK_AS_BITMASK_ENUM(Nuw)
+};
+LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
+
/// A set of arbitrary-precision integers representing bounds on a given integer
/// value. These bounds are inclusive on both ends, so
/// bounds of [4, 5] mean 4 <= x <= 5. Separate bounds are tracked for
@@ -29,8 +38,10 @@ class ConstantIntRanges {
/// Bound umin <= (unsigned)x <= umax and smin <= signed(x) <= smax.
/// Non-integer values should be bounded by APInts of bitwidth 0.
ConstantIntRanges(const APInt &umin, const APInt &umax, const APInt &smin,
- const APInt &smax)
- : uminVal(umin), umaxVal(umax), sminVal(smin), smaxVal(smax) {
+ const APInt &smax,
+ OverflowFlags overflowFlags = OverflowFlags::None)
+ : uminVal(umin), umaxVal(umax), sminVal(smin), smaxVal(smax),
+ overflowFlags(overflowFlags) {
assert(uminVal.getBitWidth() == umaxVal.getBitWidth() &&
umaxVal.getBitWidth() == sminVal.getBitWidth() &&
sminVal.getBitWidth() == smaxVal.getBitWidth() &&
@@ -96,11 +107,21 @@ class ConstantIntRanges {
/// value.
std::optional<APInt> getConstantValue() const;
+ /// Return overflow properties proven for the operation computing the bounded
+ /// value.
+ OverflowFlags getOverflowFlags() const { return overflowFlags; }
+
+ /// Return this range with updated overflow properties.
+ ConstantIntRanges withOverflowFlags(OverflowFlags flags) const {
+ return {uminVal, umaxVal, sminVal, smaxVal, flags};
+ }
+
friend raw_ostream &operator<<(raw_ostream &os,
const ConstantIntRanges &range);
private:
APInt uminVal, umaxVal, sminVal, smaxVal;
+ OverflowFlags overflowFlags = OverflowFlags::None;
};
raw_ostream &operator<<(raw_ostream &, const ConstantIntRanges &);
diff --git a/mlir/include/mlir/Interfaces/Utils/InferIntRangeCommon.h b/mlir/include/mlir/Interfaces/Utils/InferIntRangeCommon.h
index e369c80a26ea9..8c0784a4513bb 100644
--- a/mlir/include/mlir/Interfaces/Utils/InferIntRangeCommon.h
+++ b/mlir/include/mlir/Interfaces/Utils/InferIntRangeCommon.h
@@ -16,7 +16,6 @@
#include "mlir/Interfaces/InferIntRangeInterface.h"
#include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/BitmaskEnum.h"
#include <optional>
namespace mlir {
@@ -39,12 +38,7 @@ static constexpr unsigned indexMaxWidth = 64;
enum class CmpMode : uint32_t { Both, Signed, Unsigned };
-enum class OverflowFlags : uint32_t {
- None = 0,
- Nsw = 1,
- Nuw = 2,
- LLVM_MARK_AS_BITMASK_ENUM(Nuw)
-};
+using OverflowFlags = mlir::OverflowFlags;
/// Function that performs inference on an array of `ConstantIntRanges` while
/// taking special overflow behavior into account.
diff --git a/mlir/lib/Dialect/Arith/IR/InferIntRangeInterfaceImpls.cpp b/mlir/lib/Dialect/Arith/IR/InferIntRangeInterfaceImpls.cpp
index 49f89e1bd17f3..2624448b5f7b4 100644
--- a/mlir/lib/Dialect/Arith/IR/InferIntRangeInterfaceImpls.cpp
+++ b/mlir/lib/Dialect/Arith/IR/InferIntRangeInterfaceImpls.cpp
@@ -11,6 +11,7 @@
#include "mlir/Interfaces/Utils/InferIntRangeCommon.h"
#include <optional>
+#include <utility>
#define DEBUG_TYPE "int-range-analysis"
@@ -28,6 +29,116 @@ convertArithOverflowFlags(arith::IntegerOverflowFlags flags) {
return retFlags;
}
+template <typename Op>
+static bool proveNoOverflow(const APInt &lhs, const APInt &rhs, Op op) {
+ bool overflow = false;
+ (void)op(lhs, rhs, overflow);
+ return !overflow;
+}
+
+template <typename Op>
+static bool
+proveNoOverflowForPairs(ArrayRef<std::pair<const APInt *, const APInt *>> pairs,
+ Op op) {
+ for (const auto &[lhs, rhs] : pairs) {
+ if (!proveNoOverflow(*lhs, *rhs, op))
+ return false;
+ }
+ return true;
+}
+
+static OverflowFlags proveNoOverflowFlags(
+ ArrayRef<ConstantIntRanges> args,
+ function_ref<bool(ArrayRef<ConstantIntRanges>)> proveSigned,
+ function_ref<bool(ArrayRef<ConstantIntRanges>)> proveUnsigned) {
+ OverflowFlags flags = OverflowFlags::None;
+ if (proveSigned(args))
+ flags |= OverflowFlags::Nsw;
+ if (proveUnsigned(args))
+ flags |= OverflowFlags::Nuw;
+ return flags;
+}
+
+static bool proveNoSignedAddOverflow(ArrayRef<ConstantIntRanges> argRanges) {
+ const APInt &lhsMin = argRanges[0].smin();
+ const APInt &lhsMax = argRanges[0].smax();
+ const APInt &rhsMin = argRanges[1].smin();
+ const APInt &rhsMax = argRanges[1].smax();
+ // Signed add is monotone in both operands, so it is enough to check
+ // the interval endpoints to prove no signed wrap for the whole range.
+ return proveNoOverflowForPairs(
+ {{&lhsMin, &rhsMin}, {&lhsMax, &rhsMax}},
+ [](const APInt &lhs, const APInt &rhs, bool &overflow) {
+ return lhs.sadd_ov(rhs, overflow);
+ });
+}
+
+static bool proveNoUnsignedAddOverflow(ArrayRef<ConstantIntRanges> argRanges) {
+ return proveNoOverflow(
+ argRanges[0].umax(), argRanges[1].umax(),
+ [](const APInt &lhs, const APInt &rhs, bool &overflow) {
+ return lhs.uadd_ov(rhs, overflow);
+ });
+}
+
+static bool proveNoSignedSubOverflow(ArrayRef<ConstantIntRanges> argRanges) {
+ const APInt &lhsMin = argRanges[0].smin();
+ const APInt &lhsMax = argRanges[0].smax();
+ const APInt &rhsMin = argRanges[1].smin();
+ const APInt &rhsMax = argRanges[1].smax();
+ // For lhs - rhs, the extrema occur at (lhsMin - rhsMax) and
+ // (lhsMax - rhsMin). If both are no-wrap, the full interval is no-wrap.
+ return proveNoOverflowForPairs(
+ {{&lhsMin, &rhsMax}, {&lhsMax, &rhsMin}},
+ [](const APInt &lhs, const APInt &rhs, bool &overflow) {
+ return lhs.ssub_ov(rhs, overflow);
+ });
+}
+
+static bool proveNoUnsignedSubOverflow(ArrayRef<ConstantIntRanges> argRanges) {
+ return argRanges[0].umin().uge(argRanges[1].umax());
+}
+
+static bool proveNoSignedMulOverflow(ArrayRef<ConstantIntRanges> argRanges) {
+ const APInt &lhsMin = argRanges[0].smin();
+ const APInt &lhsMax = argRanges[0].smax();
+ const APInt &rhsMin = argRanges[1].smin();
+ const APInt &rhsMax = argRanges[1].smax();
+ // Signed multiply is not monotone across sign changes, so conservatively
+ // require all four corner products to be no-wrap.
+ return proveNoOverflowForPairs(
+ {{&lhsMin, &rhsMin},
+ {&lhsMin, &rhsMax},
+ {&lhsMax, &rhsMin},
+ {&lhsMax, &rhsMax}},
+ [](const APInt &lhs, const APInt &rhs, bool &overflow) {
+ return lhs.smul_ov(rhs, overflow);
+ });
+}
+
+static bool proveNoUnsignedMulOverflow(ArrayRef<ConstantIntRanges> argRanges) {
+ return proveNoOverflow(
+ argRanges[0].umax(), argRanges[1].umax(),
+ [](const APInt &lhs, const APInt &rhs, bool &overflow) {
+ return lhs.umul_ov(rhs, overflow);
+ });
+}
+
+static OverflowFlags proveNoOverflowForAdd(ArrayRef<ConstantIntRanges> args) {
+ return proveNoOverflowFlags(args, proveNoSignedAddOverflow,
+ proveNoUnsignedAddOverflow);
+}
+
+static OverflowFlags proveNoOverflowForSub(ArrayRef<ConstantIntRanges> args) {
+ return proveNoOverflowFlags(args, proveNoSignedSubOverflow,
+ proveNoUnsignedSubOverflow);
+}
+
+static OverflowFlags proveNoOverflowForMul(ArrayRef<ConstantIntRanges> args) {
+ return proveNoOverflowFlags(args, proveNoSignedMulOverflow,
+ proveNoUnsignedMulOverflow);
+}
+
//===----------------------------------------------------------------------===//
// ConstantOp
//===----------------------------------------------------------------------===//
@@ -65,8 +176,11 @@ void arith::ConstantOp::inferResultRanges(ArrayRef<ConstantIntRanges> argRanges,
void arith::AddIOp::inferResultRanges(ArrayRef<ConstantIntRanges> argRanges,
SetIntRangeFn setResultRange) {
- setResultRange(getResult(), inferAdd(argRanges, convertArithOverflowFlags(
- getOverflowFlags())));
+ OverflowFlags declaredFlags = convertArithOverflowFlags(getOverflowFlags());
+ ConstantIntRanges range = inferAdd(argRanges, declaredFlags);
+ OverflowFlags overflowFlags =
+ proveNoOverflowForAdd(argRanges) | declaredFlags;
+ setResultRange(getResult(), range.withOverflowFlags(overflowFlags));
}
//===----------------------------------------------------------------------===//
@@ -75,8 +189,11 @@ void arith::AddIOp::inferResultRanges(ArrayRef<ConstantIntRanges> argRanges,
void arith::SubIOp::inferResultRanges(ArrayRef<ConstantIntRanges> argRanges,
SetIntRangeFn setResultRange) {
- setResultRange(getResult(), inferSub(argRanges, convertArithOverflowFlags(
- getOverflowFlags())));
+ OverflowFlags declaredFlags = convertArithOverflowFlags(getOverflowFlags());
+ ConstantIntRanges range = inferSub(argRanges, declaredFlags);
+ OverflowFlags overflowFlags =
+ proveNoOverflowForSub(argRanges) | declaredFlags;
+ setResultRange(getResult(), range.withOverflowFlags(overflowFlags));
}
//===----------------------------------------------------------------------===//
@@ -85,8 +202,11 @@ void arith::SubIOp::inferResultRanges(ArrayRef<ConstantIntRanges> argRanges,
void arith::MulIOp::inferResultRanges(ArrayRef<ConstantIntRanges> argRanges,
SetIntRangeFn setResultRange) {
- setResultRange(getResult(), inferMul(argRanges, convertArithOverflowFlags(
- getOverflowFlags())));
+ OverflowFlags declaredFlags = convertArithOverflowFlags(getOverflowFlags());
+ ConstantIntRanges range = inferMul(argRanges, declaredFlags);
+ OverflowFlags overflowFlags =
+ proveNoOverflowForMul(argRanges) | declaredFlags;
+ setResultRange(getResult(), range.withOverflowFlags(overflowFlags));
}
//===----------------------------------------------------------------------===//
diff --git a/mlir/lib/Interfaces/InferIntRangeInterface.cpp b/mlir/lib/Interfaces/InferIntRangeInterface.cpp
index 9d8e5f50a725b..0d3e06dc4d995 100644
--- a/mlir/lib/Interfaces/InferIntRangeInterface.cpp
+++ b/mlir/lib/Interfaces/InferIntRangeInterface.cpp
@@ -17,7 +17,8 @@ using namespace mlir;
bool ConstantIntRanges::operator==(const ConstantIntRanges &other) const {
return umin().getBitWidth() == other.umin().getBitWidth() &&
umin() == other.umin() && umax() == other.umax() &&
- smin() == other.smin() && smax() == other.smax();
+ smin() == other.smin() && smax() == other.smax() &&
+ getOverflowFlags() == other.getOverflowFlags();
}
const APInt &ConstantIntRanges::umin() const { return uminVal; }
@@ -94,8 +95,10 @@ ConstantIntRanges::rangeUnion(const ConstantIntRanges &other) const {
const APInt &umaxUnion = umax().ugt(other.umax()) ? umax() : other.umax();
const APInt &sminUnion = smin().slt(other.smin()) ? smin() : other.smin();
const APInt &smaxUnion = smax().sgt(other.smax()) ? smax() : other.smax();
+ // For a union, keep only guarantees proven on both inputs.
+ OverflowFlags overflowUnion = getOverflowFlags() & other.getOverflowFlags();
- return {uminUnion, umaxUnion, sminUnion, smaxUnion};
+ return {uminUnion, umaxUnion, sminUnion, smaxUnion, overflowUnion};
}
ConstantIntRanges
@@ -111,8 +114,12 @@ ConstantIntRanges::intersection(const ConstantIntRanges &other) const {
const APInt &umaxIntersect = umax().ult(other.umax()) ? umax() : other.umax();
const APInt &sminIntersect = smin().sgt(other.smin()) ? smin() : other.smin();
const APInt &smaxIntersect = smax().slt(other.smax()) ? smax() : other.smax();
+ // For an intersection, guarantees from either input remain valid.
+ OverflowFlags overflowIntersect =
+ getOverflowFlags() | other.getOverflowFlags();
- return {uminIntersect, umaxIntersect, sminIntersect, smaxIntersect};
+ return {uminIntersect, umaxIntersect, sminIntersect, smaxIntersect,
+ overflowIntersect};
}
std::optional<APInt> ConstantIntRanges::getConstantValue() const {
@@ -129,7 +136,23 @@ raw_ostream &mlir::operator<<(raw_ostream &os, const ConstantIntRanges &range) {
range.umin().print(os, /*isSigned*/ false);
os << ", ";
range.umax().print(os, /*isSigned*/ false);
- return os << "] signed : [" << range.smin() << ", " << range.smax() << "]";
+ os << "] signed : [" << range.smin() << ", " << range.smax() << "]";
+ OverflowFlags overflowFlags = range.getOverflowFlags();
+ if (overflowFlags == OverflowFlags::None)
+ return os;
+
+ os << " overflow<";
+ bool emitted = false;
+ if ((overflowFlags & OverflowFlags::Nsw) != OverflowFlags::None) {
+ os << "nsw";
+ emitted = true;
+ }
+ if ((overflowFlags & OverflowFlags::Nuw) != OverflowFlags::None) {
+ if (emitted)
+ os << ", ";
+ os << "nuw";
+ }
+ return os << ">";
}
IntegerValueRange IntegerValueRange::getMaxRange(Value value) {
diff --git a/mlir/unittests/Interfaces/InferIntRangeInterfaceTest.cpp b/mlir/unittests/Interfaces/InferIntRangeInterfaceTest.cpp
index 97c75b3680567..1b88a3f7a74aa 100644
--- a/mlir/unittests/Interfaces/InferIntRangeInterfaceTest.cpp
+++ b/mlir/unittests/Interfaces/InferIntRangeInterfaceTest.cpp
@@ -8,6 +8,7 @@
#include "mlir/Interfaces/InferIntRangeInterface.h"
#include "llvm/ADT/APInt.h"
+#include "llvm/Support/raw_ostream.h"
#include <limits>
#include <gtest/gtest.h>
@@ -97,3 +98,61 @@ TEST(IntRangeAttrs, Join) {
ConstantIntRanges zeroOneSignedOnly(zero, uintMax, zero, one);
EXPECT_EQ(zeroOneUnsignedOnly.rangeUnion(zeroOneSignedOnly), maximal);
}
+
+TEST(IntRangeAttrs, OverflowFlags) {
+ APInt zero = APInt::getZero(64);
+ APInt one = zero + 1;
+ APInt two = zero + 2;
+
+ ConstantIntRanges nswOnly(zero, one, zero, one, OverflowFlags::Nsw);
+ ConstantIntRanges nuwOnly(one, two, one, two, OverflowFlags::Nuw);
+
+ EXPECT_NE(nswOnly.getOverflowFlags() & OverflowFlags::Nsw,
+ OverflowFlags::None);
+ EXPECT_EQ(nswOnly.getOverflowFlags() & OverflowFlags::Nuw,
+ OverflowFlags::None);
+
+ ConstantIntRanges both =
+ nswOnly.withOverflowFlags(OverflowFlags::Nsw | OverflowFlags::Nuw);
+ EXPECT_NE(both.getOverflowFlags() & OverflowFlags::Nsw, OverflowFlags::None);
+ EXPECT_NE(both.getOverflowFlags() & OverflowFlags::Nuw, OverflowFlags::None);
+
+ // rangeUnion conservatively preserves only proofs present in both inputs.
+ EXPECT_EQ(nswOnly.rangeUnion(nuwOnly).getOverflowFlags(),
+ OverflowFlags::None);
+ EXPECT_EQ(both.rangeUnion(nswOnly).getOverflowFlags(), OverflowFlags::Nsw);
+
+ // intersection preserves proofs from either input.
+ EXPECT_EQ(nswOnly.intersection(nuwOnly).getOverflowFlags(),
+ OverflowFlags::Nsw | OverflowFlags::Nuw);
+ EXPECT_EQ(both.intersection(nswOnly).getOverflowFlags(),
+ OverflowFlags::Nsw | OverflowFlags::Nuw);
+ ConstantIntRanges none(zero, two, zero, two, OverflowFlags::None);
+ EXPECT_EQ(nswOnly.intersection(none).getOverflowFlags(), OverflowFlags::Nsw);
+}
+
+TEST(IntRangeAttrs, OverflowFlagsPrinting) {
+ APInt zero = APInt::getZero(64);
+ APInt one = zero + 1;
+
+ auto toString = [](const ConstantIntRanges &r) {
+ std::string buf;
+ llvm::raw_string_ostream os(buf);
+ os << r;
+ return buf;
+ };
+
+ ConstantIntRanges noFlags(zero, one, zero, one);
+ EXPECT_EQ(toString(noFlags), "unsigned : [0, 1] signed : [0, 1]");
+
+ ConstantIntRanges nsw(zero, one, zero, one, OverflowFlags::Nsw);
+ EXPECT_EQ(toString(nsw), "unsigned : [0, 1] signed : [0, 1] overflow<nsw>");
+
+ ConstantIntRanges nuw(zero, one, zero, one, OverflowFlags::Nuw);
+ EXPECT_EQ(toString(nuw), "unsigned : [0, 1] signed : [0, 1] overflow<nuw>");
+
+ ConstantIntRanges both(zero, one, zero, one,
+ OverflowFlags::Nsw | OverflowFlags::Nuw);
+ EXPECT_EQ(toString(both),
+ "unsigned : [0, 1] signed : [0, 1] overflow<nsw, nuw>");
+}
>From ec713c606a81132c1547c5153047c3fdc7804e79 Mon Sep 17 00:00:00 2001
From: Hocky Yudhiono <hocky.yudhiono at gmail.com>
Date: Mon, 13 Apr 2026 17:58:56 +0800
Subject: [PATCH 2/2] [mlir][interfaces] Add testcases
---
.../mlir/Interfaces/InferIntRangeInterface.h | 4 +
.../DataFlow/StridedMetadataRangeAnalysis.cpp | 8 +-
.../lib/Interfaces/InferIntRangeInterface.cpp | 7 +-
.../Interfaces/Utils/InferIntRangeCommon.cpp | 4 +-
.../Interfaces/InferIntRangeInterfaceTest.cpp | 181 ++++++++++++++++++
5 files changed, 197 insertions(+), 7 deletions(-)
diff --git a/mlir/include/mlir/Interfaces/InferIntRangeInterface.h b/mlir/include/mlir/Interfaces/InferIntRangeInterface.h
index 9870cf1cbb6fa..58682967df9b1 100644
--- a/mlir/include/mlir/Interfaces/InferIntRangeInterface.h
+++ b/mlir/include/mlir/Interfaces/InferIntRangeInterface.h
@@ -50,6 +50,10 @@ class ConstantIntRanges {
bool operator==(const ConstantIntRanges &other) const;
+ /// Returns true if all signed and unsigned bounds match, ignoring
+ /// overflow flags.
+ bool hasSameBounds(const ConstantIntRanges &other) const;
+
/// The minimum value of an integer when it is interpreted as unsigned.
const APInt &umin() const;
diff --git a/mlir/lib/Analysis/DataFlow/StridedMetadataRangeAnalysis.cpp b/mlir/lib/Analysis/DataFlow/StridedMetadataRangeAnalysis.cpp
index 01c9dafaddf10..cb7305195de7a 100644
--- a/mlir/lib/Analysis/DataFlow/StridedMetadataRangeAnalysis.cpp
+++ b/mlir/lib/Analysis/DataFlow/StridedMetadataRangeAnalysis.cpp
@@ -104,10 +104,10 @@ LogicalResult StridedMetadataRangeAnalysis::visitOperation(
};
// Convert the arguments lattices to a vector.
- SmallVector<StridedMetadataRange> argRanges = llvm::map_to_vector(
- operands, [](const StridedMetadataRangeLattice *lattice) {
- return lattice->getValue();
- });
+ SmallVector<StridedMetadataRange, 2> argRanges;
+ argRanges.reserve(operands.size());
+ for (const StridedMetadataRangeLattice *lattice : operands)
+ argRanges.push_back(lattice->getValue());
// Callback to set metadata on a result.
auto joinCallback = [&](Value v, const StridedMetadataRange &md) {
diff --git a/mlir/lib/Interfaces/InferIntRangeInterface.cpp b/mlir/lib/Interfaces/InferIntRangeInterface.cpp
index 0d3e06dc4d995..090c13cea4599 100644
--- a/mlir/lib/Interfaces/InferIntRangeInterface.cpp
+++ b/mlir/lib/Interfaces/InferIntRangeInterface.cpp
@@ -15,10 +15,13 @@
using namespace mlir;
bool ConstantIntRanges::operator==(const ConstantIntRanges &other) const {
+ return hasSameBounds(other) && getOverflowFlags() == other.getOverflowFlags();
+}
+
+bool ConstantIntRanges::hasSameBounds(const ConstantIntRanges &other) const {
return umin().getBitWidth() == other.umin().getBitWidth() &&
umin() == other.umin() && umax() == other.umax() &&
- smin() == other.smin() && smax() == other.smax() &&
- getOverflowFlags() == other.getOverflowFlags();
+ smin() == other.smin() && smax() == other.smax();
}
const APInt &ConstantIntRanges::umin() const { return uminVal; }
diff --git a/mlir/lib/Interfaces/Utils/InferIntRangeCommon.cpp b/mlir/lib/Interfaces/Utils/InferIntRangeCommon.cpp
index c9f49fda726e7..ffb407a650599 100644
--- a/mlir/lib/Interfaces/Utils/InferIntRangeCommon.cpp
+++ b/mlir/lib/Interfaces/Utils/InferIntRangeCommon.cpp
@@ -100,7 +100,9 @@ mlir::intrange::inferIndexOp(const InferRangeFn &inferFn,
bool truncEqual = false;
switch (mode) {
case intrange::CmpMode::Both:
- truncEqual = (thirtyTwo == sixtyFourAsThirtyTwo);
+ // Overflow flags are auxiliary guarantees and should not decide whether
+ // the 64-bit result is a truncation-compatible match.
+ truncEqual = thirtyTwo.hasSameBounds(sixtyFourAsThirtyTwo);
break;
case intrange::CmpMode::Signed:
truncEqual = (thirtyTwo.smin() == sixtyFourAsThirtyTwo.smin() &&
diff --git a/mlir/unittests/Interfaces/InferIntRangeInterfaceTest.cpp b/mlir/unittests/Interfaces/InferIntRangeInterfaceTest.cpp
index 1b88a3f7a74aa..9affdeac1fb6f 100644
--- a/mlir/unittests/Interfaces/InferIntRangeInterfaceTest.cpp
+++ b/mlir/unittests/Interfaces/InferIntRangeInterfaceTest.cpp
@@ -7,6 +7,9 @@
//===----------------------------------------------------------------------===//
#include "mlir/Interfaces/InferIntRangeInterface.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
+#include "mlir/IR/BuiltinOps.h"
+#include "mlir/Interfaces/Utils/InferIntRangeCommon.h"
#include "llvm/ADT/APInt.h"
#include "llvm/Support/raw_ostream.h"
#include <limits>
@@ -15,6 +18,22 @@
using namespace mlir;
+namespace {
+
+template <typename OpTy>
+ConstantIntRanges inferBinaryOpResult(OpTy op,
+ ArrayRef<ConstantIntRanges> argRanges) {
+ std::optional<ConstantIntRanges> inferred;
+ op.inferResultRanges(argRanges, [&](Value v, const ConstantIntRanges &range) {
+ if (v == op.getResult())
+ inferred = range;
+ });
+ assert(inferred.has_value() && "binary op did not produce a result range");
+ return *inferred;
+}
+
+} // namespace
+
TEST(IntRangeAttrs, BasicConstructors) {
APInt zero = APInt::getZero(64);
APInt two(64, 2);
@@ -129,6 +148,12 @@ TEST(IntRangeAttrs, OverflowFlags) {
OverflowFlags::Nsw | OverflowFlags::Nuw);
ConstantIntRanges none(zero, two, zero, two, OverflowFlags::None);
EXPECT_EQ(nswOnly.intersection(none).getOverflowFlags(), OverflowFlags::Nsw);
+
+ // Full equality tracks both bounds and overflow proofs.
+ EXPECT_FALSE(nswOnly == nswOnly.withOverflowFlags(OverflowFlags::None));
+ // Bounds-only equality intentionally ignores overflow proofs.
+ EXPECT_TRUE(nswOnly.hasSameBounds(
+ nswOnly.withOverflowFlags(OverflowFlags::Nsw | OverflowFlags::Nuw)));
}
TEST(IntRangeAttrs, OverflowFlagsPrinting) {
@@ -156,3 +181,159 @@ TEST(IntRangeAttrs, OverflowFlagsPrinting) {
EXPECT_EQ(toString(both),
"unsigned : [0, 1] signed : [0, 1] overflow<nsw, nuw>");
}
+
+TEST(IntRangeAttrs, InferIndexOpCmpBothIgnoresOverflowFlags) {
+ intrange::InferRangeFn inferFn = [](ArrayRef<ConstantIntRanges> args) {
+ unsigned width = args.front().umin().getBitWidth();
+ APInt zero = APInt::getZero(width);
+ APInt one(width, 1);
+ return ConstantIntRanges(zero, one, zero, one, OverflowFlags::Nsw);
+ };
+
+ APInt zero64 = APInt::getZero(64);
+ APInt one64(64, 1);
+ ConstantIntRanges arg(zero64, one64, zero64, one64);
+ ConstantIntRanges result =
+ intrange::inferIndexOp(inferFn, {arg}, intrange::CmpMode::Both);
+
+ EXPECT_EQ(result.umin(), zero64);
+ EXPECT_EQ(result.umax(), one64);
+ EXPECT_EQ(result.smin(), zero64);
+ EXPECT_EQ(result.smax(), one64);
+ EXPECT_EQ(result.getOverflowFlags(), OverflowFlags::Nsw);
+}
+
+TEST(IntRangeAttrs, ArithAddIOpInfersOverflowFlags) {
+ MLIRContext context;
+ context.loadDialect<arith::ArithDialect>();
+
+ OpBuilder builder(&context);
+ Location loc = builder.getUnknownLoc();
+ ModuleOp module = ModuleOp::create(loc);
+ builder.setInsertionPointToStart(module.getBody());
+
+ Value zero = arith::ConstantIntOp::create(builder, loc, 0, 8);
+ Value one = arith::ConstantIntOp::create(builder, loc, 1, 8);
+
+ arith::AddIOp add = arith::AddIOp::create(builder, loc, zero, one);
+ arith::AddIOp addWithDeclaredNsw = arith::AddIOp::create(
+ builder, loc, zero, one, arith::IntegerOverflowFlags::nsw);
+
+ APInt c0(8, 0), c1(8, 1), c2(8, 2), c10(8, 10), c20(8, 20), c120(8, 120),
+ c127(8, 127), c255(8, 255);
+
+ // Both signed and unsigned proofs succeed.
+ ConstantIntRanges addLhs(c0, c10, c0, c10);
+ ConstantIntRanges addRhs(c0, c20, c0, c20);
+ ConstantIntRanges addResult = inferBinaryOpResult(add, {addLhs, addRhs});
+ EXPECT_EQ(addResult.getOverflowFlags(),
+ OverflowFlags::Nsw | OverflowFlags::Nuw);
+
+ // Signed may overflow, but unsigned remains provably no-wrap.
+ ConstantIntRanges mayOverflowLhs(c120, c127, c120, c127);
+ ConstantIntRanges mayOverflowRhs(c1, c2, c1, c2);
+ ConstantIntRanges addMayOverflowResult =
+ inferBinaryOpResult(add, {mayOverflowLhs, mayOverflowRhs});
+ EXPECT_EQ(addMayOverflowResult.getOverflowFlags(), OverflowFlags::Nuw);
+
+ // Declared op flags are preserved and merged with inferred ones.
+ ConstantIntRanges addDeclaredNswResult =
+ inferBinaryOpResult(addWithDeclaredNsw, {mayOverflowLhs, mayOverflowRhs});
+ EXPECT_EQ(addDeclaredNswResult.getOverflowFlags(),
+ OverflowFlags::Nsw | OverflowFlags::Nuw);
+
+ // Both signed and unsigned proofs fail.
+ ConstantIntRanges fullUnsigned = ConstantIntRanges::fromUnsigned(c0, c255);
+ ConstantIntRanges addFullyOverflowingResult =
+ inferBinaryOpResult(add, {fullUnsigned, fullUnsigned});
+ EXPECT_EQ(addFullyOverflowingResult.getOverflowFlags(), OverflowFlags::None);
+}
+
+TEST(IntRangeAttrs, ArithSubIOpInfersOverflowFlags) {
+ MLIRContext context;
+ context.loadDialect<arith::ArithDialect>();
+
+ OpBuilder builder(&context);
+ Location loc = builder.getUnknownLoc();
+ ModuleOp module = ModuleOp::create(loc);
+ builder.setInsertionPointToStart(module.getBody());
+
+ Value zero = arith::ConstantIntOp::create(builder, loc, 0, 8);
+ Value one = arith::ConstantIntOp::create(builder, loc, 1, 8);
+
+ arith::SubIOp sub = arith::SubIOp::create(builder, loc, zero, one);
+ arith::SubIOp subWithDeclaredNuw = arith::SubIOp::create(
+ builder, loc, zero, one, arith::IntegerOverflowFlags::nuw);
+
+ APInt c0(8, 0), c5(8, 5), c10(8, 10), c20(8, 20);
+ APInt sMin = APInt::getSignedMinValue(8);
+ APInt sNeg120(8, -120, true);
+
+ // Both signed and unsigned proofs succeed.
+ ConstantIntRanges subLhs(c10, c20, c10, c20);
+ ConstantIntRanges subRhs(c0, c5, c0, c5);
+ ConstantIntRanges subResult = inferBinaryOpResult(sub, {subLhs, subRhs});
+ EXPECT_EQ(subResult.getOverflowFlags(),
+ OverflowFlags::Nsw | OverflowFlags::Nuw);
+
+ // Signed may overflow, but unsigned remains provably no-wrap.
+ ConstantIntRanges subMayOverflowLhs =
+ ConstantIntRanges::fromSigned(sMin, sNeg120);
+ ConstantIntRanges subMayOverflowRhs(c10, c20, c10, c20);
+ ConstantIntRanges subMayOverflowResult =
+ inferBinaryOpResult(sub, {subMayOverflowLhs, subMayOverflowRhs});
+ EXPECT_EQ(subMayOverflowResult.getOverflowFlags(), OverflowFlags::Nuw);
+
+ // Declared op flags are preserved.
+ ConstantIntRanges subDeclaredNuwResult = inferBinaryOpResult(
+ subWithDeclaredNuw, {subMayOverflowLhs, subMayOverflowRhs});
+ EXPECT_EQ(subDeclaredNuwResult.getOverflowFlags(), OverflowFlags::Nuw);
+}
+
+TEST(IntRangeAttrs, ArithMulIOpInfersOverflowFlags) {
+ MLIRContext context;
+ context.loadDialect<arith::ArithDialect>();
+
+ OpBuilder builder(&context);
+ Location loc = builder.getUnknownLoc();
+ ModuleOp module = ModuleOp::create(loc);
+ builder.setInsertionPointToStart(module.getBody());
+
+ Value zero = arith::ConstantIntOp::create(builder, loc, 0, 8);
+ Value one = arith::ConstantIntOp::create(builder, loc, 1, 8);
+
+ arith::MulIOp mul = arith::MulIOp::create(builder, loc, zero, one);
+ arith::MulIOp mulWithDeclaredFlags = arith::MulIOp::create(
+ builder, loc, zero, one,
+ arith::IntegerOverflowFlags::nsw | arith::IntegerOverflowFlags::nuw);
+
+ APInt c2(8, 2), c3(8, 3), c4(8, 4), c5(8, 5), c8(8, 8), c16(8, 16),
+ c20(8, 20);
+
+ // Both signed and unsigned proofs succeed.
+ ConstantIntRanges mulLhs(c2, c3, c2, c3);
+ ConstantIntRanges mulRhs(c4, c5, c4, c5);
+ ConstantIntRanges mulResult = inferBinaryOpResult(mul, {mulLhs, mulRhs});
+ EXPECT_EQ(mulResult.getOverflowFlags(),
+ OverflowFlags::Nsw | OverflowFlags::Nuw);
+
+ // Unsigned proof succeeds, but signed proof fails (16 * 8 = 128 in i8).
+ ConstantIntRanges mulNuwOnlyLhs(c16, c16, c16, c16);
+ ConstantIntRanges mulNuwOnlyRhs(c8, c8, c8, c8);
+ ConstantIntRanges mulNuwOnlyResult =
+ inferBinaryOpResult(mul, {mulNuwOnlyLhs, mulNuwOnlyRhs});
+ EXPECT_EQ(mulNuwOnlyResult.getOverflowFlags(), OverflowFlags::Nuw);
+
+ // Both signed and unsigned proofs fail.
+ ConstantIntRanges mulMayOverflowLhs(c16, c20, c16, c20);
+ ConstantIntRanges mulMayOverflowRhs(c16, c20, c16, c20);
+ ConstantIntRanges mulMayOverflowResult =
+ inferBinaryOpResult(mul, {mulMayOverflowLhs, mulMayOverflowRhs});
+ EXPECT_EQ(mulMayOverflowResult.getOverflowFlags(), OverflowFlags::None);
+
+ // Declared op flags are preserved.
+ ConstantIntRanges mulDeclaredResult = inferBinaryOpResult(
+ mulWithDeclaredFlags, {mulMayOverflowLhs, mulMayOverflowRhs});
+ EXPECT_EQ(mulDeclaredResult.getOverflowFlags(),
+ OverflowFlags::Nsw | OverflowFlags::Nuw);
+}
More information about the Mlir-commits
mailing list