Add IU64 and Span classes, to compute spans over all integers (#9021)

IU64 is a single numeric representation for both signed and unsigned
integers: it can contain as many negative values as a signed number can,
but also as many unsigned as well (so it needs more than 64 bits).

The Span class is a simple representation of contiguous Spans of
numbers.

Author: kripken

src/support/iu64.h

@@ -0,0 +1,152 @@
+/*
+ * Copyright 2026 WebAssembly Community Group participants
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef wasm_support_i65_h
+#define wasm_support_i65_h
+
+#include <cstdint>
+#include <iostream>
+#include <limits>
+
+namespace wasm {
+
+// An integer capable of representing numbers in the combined range of 32 and
+// 64-bit integers, both signed and unsigned. That is, in the range
+//
+//  std::numeric_limits<int64_t>::min() .. std::numeric_limits<uint64_t>::max()
+//
+// This is basically an i64 combined with a u64 in terms of range, hence "IU64".
+struct IU64 {
+  // A 64-bit payload with an extra 65th sign bit.
+  uint64_t value = 0;
+  bool negative = false;
+
+  constexpr IU64() = default;
+
+  // Unsigned values are simple.
+  constexpr IU64(uint32_t x) : value(x) {}
+  constexpr IU64(uint64_t x) : value(x) {}
+
+  // Signed values need to be checked for being negative.
+  constexpr IU64(int32_t x) {
+    if (x >= 0) {
+      value = x;
+    } else {
+      negative = true;
+      value = -int64_t(x);
+    }
+  }
+  constexpr IU64(int64_t x) {
+    if (x >= 0) {
+      value = x;
+    } else {
+      negative = true;
+
+      // One does not simply negate MIN_INT64.
+      if (x == std::numeric_limits<int64_t>::min()) {
+        value = uint64_t(1) << 63;
+      } else {
+        value = -int64_t(x);
+      }
+    }
+  }
+
+  constexpr bool operator==(const IU64& other) const {
+    return value == other.value && negative == other.negative;
+  }
+  constexpr bool operator!=(const IU64& other) const {
+    return !(*this == other);
+  }
+
+  constexpr bool operator<(const IU64& other) const {
+    if (negative) {
+      if (other.negative) {
+        // Both negative; we are smaller if absolute value is larger.
+        return value > other.value;
+      } else {
+        // Only we are negative, so we are smaller.
+        return true;
+      }
+    } else {
+      if (other.negative) {
+        // Only the other is negative, so we are larger.
+        return false;
+      } else {
+        // Both positive; we are smaller if absolute value is smaller.
+        return value < other.value;
+      }
+    }
+  }
+  constexpr bool operator<=(const IU64& other) const {
+    return *this < other || *this == other;
+  }
+  constexpr bool operator>(const IU64& other) const {
+    return !(*this <= other);
+  }
+  constexpr bool operator>=(const IU64& other) const {
+    return !(*this < other);
+  }
+};
+
+inline std::ostream& operator<<(std::ostream& os, const IU64& x) {
+  if (x.negative) {
+    os << '-';
+  }
+  return os << x.value;
+}
+
+} // namespace wasm
+
+namespace std {
+
+template<> class numeric_limits<wasm::IU64> {
+public:
+  static constexpr bool is_specialized = true;
+  static constexpr bool is_signed = true;
+  static constexpr bool is_integer = true;
+  static constexpr bool is_exact = true;
+  static constexpr bool has_infinity = false;
+  static constexpr bool has_quiet_NaN = false;
+  static constexpr bool has_signaling_NaN = false;
+  static constexpr float_denorm_style has_denorm = denorm_absent;
+  static constexpr bool has_denorm_loss = false;
+  static constexpr float_round_style round_style = round_toward_zero;
+  static constexpr bool is_iec559 = false;
+  static constexpr bool is_bounded = true;
+  static constexpr bool is_modulo = false;
+  static constexpr int digits = 65;
+  static constexpr int digits10 = 19;
+  static constexpr int max_digits10 = 0;
+  static constexpr int radix = 2;
+  static constexpr int min_exponent = 0;
+  static constexpr int min_exponent10 = 0;
+  static constexpr int max_exponent = 0;
+  static constexpr int max_exponent10 = 0;
+  static constexpr bool traps = false;
+  static constexpr bool tinyness_before = false;
+
+  static constexpr wasm::IU64 min() noexcept {
+    return wasm::IU64(std::numeric_limits<int64_t>::min());
+  }
+  static constexpr wasm::IU64 lowest() noexcept { return min(); }
+  static constexpr wasm::IU64 max() noexcept {
+    return wasm::IU64(std::numeric_limits<uint64_t>::max());
+  }
+};
+
+} // namespace std
+
+#endif // wasm_support_i65_h

src/support/span.h

@@ -0,0 +1,100 @@
+/*
+ * Copyright 2026 WebAssembly Community Group participants
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef wasm_support_span_h
+#define wasm_support_span_h
+
+#include <algorithm>
+#include <cassert>
+#include <iostream>
+#include <limits>
+
+namespace wasm {
+
+// A span of values.
+//
+// Span{min, max} means [min, max], inclusive of both sides. To represent an
+// empty span, we use min > max.
+template<typename T> struct Span {
+  static constexpr T Min = std::numeric_limits<T>::lowest();
+  static constexpr T Max = std::numeric_limits<T>::max();
+
+  T min = Min;
+  T max = Max;
+
+  constexpr Span() = default;
+  constexpr Span(T min, T max) : min(min), max(max) {}
+
+  // Set a single value as possible.
+  void set(T value) { min = max = value; }
+
+  // To represent an empty span, we use min > max, an impossible span.
+  void setEmpty() {
+    *this = empty();
+    assert(isEmpty());
+  }
+
+  bool isEmpty() const { return min > max; }
+
+  static Span<T> empty() { return Span{Max, Min}; }
+
+  void setFull() {
+    *this = Span();
+    assert(isFull());
+  }
+
+  bool isFull() const { return min == Min && max == Max; }
+
+  static Span<T> full() { return Span{}; }
+
+  // Intersect this with another span, returning a (possibly empty) span.
+  Span<T> intersection(const Span& other) const {
+    if (isEmpty() || other.isEmpty()) {
+      return empty();
+    }
+    return Span<T>{std::max(min, other.min), std::min(max, other.max)};
+  }
+
+  // Checks whether two spans have any overlap at all.
+  bool hasOverlap(const Span& other) const {
+    return !intersection(other).isEmpty();
+  }
+
+  // Check whether we contain another span (possibly being equal).
+  bool contains(const Span& other) const {
+    return intersection(other) == other;
+  }
+
+  bool operator==(const Span& other) const {
+    if (isEmpty()) {
+      return other.isEmpty();
+    }
+    return !other.isEmpty() && min == other.min && max == other.max;
+  }
+  bool operator!=(const Span& other) const { return !(*this == other); }
+};
+
+template<typename T>
+inline std::ostream& operator<<(std::ostream& os, const Span<T>& span) {
+  if (span.isEmpty()) {
+    return os << "[empty]";
+  }
+  return os << '[' << span.min << ", " << span.max << ']';
+}
+
+} // namespace wasm
+
+#endif // wasm_support_span_h

test/gtest/CMakeLists.txt

@@ -17,6 +17,7 @@ set(unittest_SOURCES
   disjoint_sets.cpp
   graph.cpp
   int128.cpp
+  iu64.cpp
   leaves.cpp
   glbs.cpp
   inplace_vector.cpp
@@ -31,6 +32,7 @@ set(unittest_SOURCES
   printing.cpp
   public-type-validator.cpp
   scc.cpp
+  span.cpp
   stringify.cpp
   subtype-exprs.cpp
   suffix_tree.cpp