Add helpers to determine required bit-width for intervals

Include support for if the bits are interpreted as signed and unsigned values.

PiperOrigin-RevId: 645435596

Author: allight

xls/ir/interval_ops.cc

@@ -964,4 +964,38 @@ IntervalSet OneHot(const IntervalSet& val, LsbOrMsb lsb_or_msb,
   return FromTernary(res, max_interval_bits);
 }
 
+int64_t MinimumBitCount(const IntervalSet& a) {
+  if (a.IsEmpty()) {
+    return 0;
+  }
+  return a.BitCount() - a.UpperBound()->CountLeadingZeros();
+}
+
+int64_t MinimumSignedBitCount(const IntervalSet& a) {
+  // Handle the extreme cases manually. No values or only the zero value are a
+  // 0-bit integer.
+  if (a.IsEmpty() || (a.GetPreciseValue() && a.GetPreciseValue()->IsZero())) {
+    return 0;
+  }
+  if (a.Covers(Bits::MinSigned(a.BitCount())) ||
+      a.Covers(Bits::MaxSigned(a.BitCount()))) {
+    return a.BitCount();
+  }
+  IntervalSet positive = IntervalSet::Intersect(
+      a, IntervalSet::Of({Interval::Closed(SBits(0, a.BitCount()),
+                                           Bits::MaxSigned(a.BitCount()))}));
+  // NB Intervals are unsigned and sbits are represented 2s complement so -1 is
+  // the highest value possible in this bit-width. MinSigned is the next value
+  // after MaxSigned in 2s complement representation.
+  IntervalSet negative = IntervalSet::Intersect(
+      a, IntervalSet::Of({Interval::Closed(Bits::MinSigned(a.BitCount()),
+                                           SBits(-1, a.BitCount()))}));
+  return std::max(positive.IsEmpty() ? 0 : MinimumBitCount(positive),
+                  negative.IsEmpty()
+                      ? 0
+                      : (negative.BitCount() -
+                         negative.LowerBound()->CountLeadingOnes())) +
+         1;
+}
+
 }  // namespace xls::interval_ops

xls/ir/interval_ops.h

@@ -79,6 +79,12 @@ KnownBits ExtractKnownBits(const IntervalSet& intervals,
 // much distance is between 2 intervals might provide better results.
 IntervalSet MinimizeIntervals(IntervalSet interval_set, int64_t size);
 
+// How many bits are needed to cover all values in the interval.
+int64_t MinimumBitCount(const IntervalSet& a);
+
+// How many bits are needed to cover all *signed* integer values in the range.
+int64_t MinimumSignedBitCount(const IntervalSet& a);
+
 // Arithmetic
 IntervalSet Add(const IntervalSet& a, const IntervalSet& b);
 IntervalSet Sub(const IntervalSet& a, const IntervalSet& b);

xls/ir/interval_ops_test.cc

@@ -106,6 +106,15 @@ TEST(IntervalOpsTest, MiddleOutTernary) {
   EXPECT_EQ(known, expected);
 }
 
+IntervalSet FromSignedRanges(
+    absl::Span<std::pair<int64_t, int64_t> const> ranges, int64_t bits) {
+  IntervalSet res(bits);
+  for (const auto& [l, h] : ranges) {
+    res.AddInterval(Interval::Closed(SBits(l, bits), SBits(h, bits)));
+  }
+  res.Normalize();
+  return res;
+}
 IntervalSet FromRanges(absl::Span<std::pair<int64_t, int64_t> const> ranges,
                        int64_t bits) {
   IntervalSet res(bits);
@@ -741,6 +750,24 @@ void UGtZ3Fuzz(absl::Span<std::pair<int64_t, int64_t> const> lhs,
 FUZZ_TEST(IntervalOpsTest, UGtZ3Fuzz)
     .WithDomains(IntervalDomain(8), IntervalDomain(8));
 
+TEST(IntervalOpsTest, MinimumBitCount) {
+  EXPECT_EQ(MinimumBitCount(IntervalSet(32)), 0);
+  EXPECT_EQ(MinimumBitCount(IntervalSet::Precise(UBits(0, 32))), 0);
+  EXPECT_EQ(MinimumBitCount(IntervalSet::Precise(UBits(32, 32))), 6);
+  EXPECT_EQ(MinimumBitCount(FromRanges({{0, 3}, {4, 5}, {30, 33}}, 32)), 6);
+}
+
+TEST(IntervalOpsTest, MinimumSignedBitCount) {
+  EXPECT_EQ(MinimumSignedBitCount(IntervalSet(32)), 0);
+  EXPECT_EQ(MinimumSignedBitCount(IntervalSet::Precise(UBits(0, 32))), 0);
+  EXPECT_EQ(MinimumSignedBitCount(IntervalSet::Precise(UBits(32, 32))), 7);
+  EXPECT_EQ(MinimumSignedBitCount(IntervalSet::Precise(SBits(-33, 32))), 7);
+  EXPECT_EQ(MinimumSignedBitCount(FromSignedRanges({{-1, 0}}, 32)), 1);
+  EXPECT_EQ(MinimumSignedBitCount(
+                FromSignedRanges({{0, 3}, {4, 5}, {30, 33}, {-34, -2}}, 32)),
+            7);
+}
+
 TEST(MinimizeIntervalsTest, PrefersEarlyIntervals) {
   // All 32 6-bit [0, 63] even numbers.
   IntervalSet even_numbers =