[clang] [analyzer] Fix truncation of ranges wider than 64 bits (PR #239147)
via cfe-commits
cfe-commits at lists.llvm.org
Thu Nov 5 22:27:34 PST 2026
https://github.com/relaxcn updated https://github.com/llvm/llvm-project/pull/239147
>From 0708432c43ab1b5e30cb87b42eaf1170c8a99ad2 Mon Sep 17 00:00:00 2001
From: relaxcn <irelaxcn at outlook.com>
Date: Wed, 28 Oct 2026 18:13:21 +0800
Subject: [PATCH] [analyzer] Fix truncation of ranges wider than 64 bits
`RangeSet::Factory::truncateTo()` compared the source span and the target cardinality minus one through `getZExtValue()`.
Both can need more than 64 bits:
1. A 128-bit interval such as `[0, 2^64]` already has a 65-bit span.
2. A target wider than 64 bits has a threshold that does not fit in `uint64_t` at all.
With assertions enabled this aborts in `APInt::getZExtValue()`;
without assertions the comparison silently uses the low 64 bits and can produce a range that is much smaller than the truncated source interval.
So this patch keeps both quantities as `APInt` at the source width.
The threshold is `getLowBitsSet(W, N)`, i.e. `2^N - 1` in `W` bits, the span is the existing `W`-bit subtraction, and `uge()` makes the distance comparison unsigned.
The endpoint conversion and the split after a wrap are unchanged.
FIXME: The only current caller of `castTo()`, `SymbolicRangeInferrer::VisitBinaryOperator<BO_NE>`, always casts to the wider of the two operand types and never truncates so this bug would never occur.
We found this problem in our new feature implementing of downstream.
---
.../Core/RangeConstraintManager.cpp | 26 +++++-----
.../unittests/StaticAnalyzer/RangeSetTest.cpp | 49 +++++++++++++++++++
2 files changed, 62 insertions(+), 13 deletions(-)
diff --git a/clang/lib/StaticAnalyzer/Core/RangeConstraintManager.cpp b/clang/lib/StaticAnalyzer/Core/RangeConstraintManager.cpp
index 888f3ae9e159a6..cdeb65ea7d548e 100644
--- a/clang/lib/StaticAnalyzer/Core/RangeConstraintManager.cpp
+++ b/clang/lib/StaticAnalyzer/Core/RangeConstraintManager.cpp
@@ -715,25 +715,25 @@ RangeSet::ContainerType RangeSet::Factory::truncateTo(RangeSet What,
using llvm::APSInt;
ContainerType Result;
ContainerType Dummy;
- // CastRangeSize is an amount of all possible values of cast type.
- // Example: `char` has 256 values; `short` has 65536 values.
- // But in fact we use `amount of values` - 1, because
- // we can't keep `amount of values of UINT64` inside uint64_t.
- // E.g. 256 is an amount of all possible values of `char` and we can't keep
- // it inside `char`.
- // And it's OK, it's enough to do correct calculations.
- uint64_t CastRangeSize = APInt::getMaxValue(Ty.getBitWidth()).getZExtValue();
+
+ // Difference of largest and smallest possible value in `Ty`.
+ const APInt CastRangeLength =
+ APInt::getLowBitsSet(What.getBitWidth(), Ty.getBitWidth());
for (const Range &R : What) {
// Get bounds of the given range.
APSInt FromInt = R.From();
APSInt ToInt = R.To();
- // CurrentRangeSize is an amount of all possible values of the current
- // range minus one.
- uint64_t CurrentRangeSize = (ToInt - FromInt).getZExtValue();
- // This is an optimization for a specific case when this Range covers
+
+ // This is a `W`-bit subtraction.
+ // For a valid range, the unsigned value of the result is the mathematical
+ // distance between the endpoints even when they are signed.
+ // Assigning to `APInt` drops the sign so that `uge()` below does not
+ // interpret an all-ones span as -1.
+ const APInt CurrentRangeLength = ToInt - FromInt;
+ // This is an optimization for a specific case when this `Range` covers
// the whole range of the target type.
Dummy.clear();
- if (CurrentRangeSize >= CastRangeSize) {
+ if (CurrentRangeLength.uge(CastRangeLength)) {
Dummy.emplace_back(ValueFactory.getMinValue(Ty),
ValueFactory.getMaxValue(Ty));
Result = std::move(Dummy);
diff --git a/clang/unittests/StaticAnalyzer/RangeSetTest.cpp b/clang/unittests/StaticAnalyzer/RangeSetTest.cpp
index a8c7626dec6f29..59879202da9288 100644
--- a/clang/unittests/StaticAnalyzer/RangeSetTest.cpp
+++ b/clang/unittests/StaticAnalyzer/RangeSetTest.cpp
@@ -281,6 +281,55 @@ using IntTypes = ::testing::Types<int8_t, uint8_t, int16_t, uint16_t, int32_t,
uint32_t, int64_t, uint64_t>;
TYPED_TEST_SUITE(RangeSetTest, IntTypes, );
+using RangeSetWideCastTest = RangeSetTest<uint64_t>;
+
+TEST_F(RangeSetWideCastTest, TruncateWideIntervals) {
+ using llvm::APInt;
+ using llvm::APSInt;
+ // Build endpoints explicitly: the fixture's `uint64_t` parameter must not
+ // limit the source width.
+ auto Interval = [&](APInt From, APInt To, bool Unsigned = true) {
+ return F.add(F.getEmptySet(), Range(BVF.getValue(APSInt(From, Unsigned)),
+ BVF.getValue(APSInt(To, Unsigned))));
+ };
+ const APSIntType U64(64, true), S64(64, false), U128(128, true);
+ const APInt Zero128(128, 0);
+ const APInt Two64 = APInt::getOneBitSet(128, 64);
+ const APInt Max64 = APInt::getMaxValue(64);
+ const RangeSet Full64 = Interval(APInt(64, 0), Max64);
+
+ // A span wider than 64 bits covers the entire target range.
+ checkCastToImpl(Interval(Zero128, Two64), U64, Full64);
+ checkCastToImpl(Interval(APInt::getSignedMinValue(128),
+ APInt::getSignedMaxValue(128), false),
+ U64, Full64);
+ checkCastToImpl(Interval(-APInt(128, 1), Two64 - 1, false), U64, Full64);
+
+ // Check the boundary at exactly 2^64 consecutive values.
+ checkCastToImpl(Interval(Zero128, Two64 - 1), U64, Full64);
+ checkCastToImpl(Interval(Zero128, Two64 - 2), U64,
+ Interval(APInt(64, 0), Max64 - 1));
+
+ // Wide endpoints alone do not imply a full target range.
+ const APInt High = APInt::getOneBitSet(128, 96);
+ checkCastToImpl(Interval(High + 3, High + 5), U64,
+ Interval(APInt(64, 3), APInt(64, 5)));
+ checkCastToImpl(Interval(Two64 - 2, Two64 + 1), U64,
+ F.unite(Interval(APInt(64, 0), APInt(64, 1)),
+ Interval(Max64 - 1, Max64)));
+
+ const APInt Two63 = APInt::getOneBitSet(128, 63);
+ const APInt MinSigned = APInt::getSignedMinValue(64);
+ const APInt MaxSigned = APInt::getSignedMaxValue(64);
+ checkCastToImpl(Interval(Two63 - 2, Two63 + 1), S64,
+ F.unite(Interval(MinSigned, MinSigned + 1, false),
+ Interval(MaxSigned - 1, MaxSigned, false)));
+
+ // The destination can also be wider than 64 bits.
+ checkCastToImpl(Interval(APInt(256, 0), APInt::getOneBitSet(256, 128)), U128,
+ Interval(Zero128, APInt::getMaxValue(128)));
+}
+
TYPED_TEST(RangeSetTest, RangeSetNegateTest) {
using TV = TestValues<TypeParam>;
constexpr auto MIN = TV::MIN;
More information about the cfe-commits
mailing list