[ADT] Remove 0-width Asserts in APInt.getZExtValue

[seldridge]

Summary

Remove assertion that disallows getting a zero-extended value from a
zero-width APInt. This check is too restrictive and makes it difficult
to use APInt to model zero-width things, e.g., zero-width wires in the
CIRCT project.

Signed-off-by: Schuyler Eldridge <[e-mail]>

[seldridge]

This diff removes restrictions around zero/sign extension of zero-width APInts. Specifically, there is a restriction introduced in https://reviews.llvm.org/D109555 that disallows zero extension of zero-width APInts. Additionally, there are some old asserts inside MathExtras, added in https://reviews.llvm.org/D22442, which assert on sign extension of any zero-width number (which are used pervasively inside APInt code to implement its sign extension). This is attempting to better enable the CIRCT project to rely on APInt to represent zero-width wires without introducing lots of additional guards to work around APInt methods which assert when used. More information on what specifically this is attempting to solve for CIRCT is here: https://github.com/llvm/circt/issues/2255

[seldridge]

Run clang-format

Run clang-format to squash trailing whitespace.

[darthscsi]

LGTM.

[nikic]

Based on the discussion in D109555, the current consensus seems to be that while zext of zero-width is well-defined, sext is not.

[seldridge]

Drop SExt commit. This is somewhat controversial and, after further
examination on my end, seemingly not needed. I can revive this if it
becomes necessary for CIRCT.

[nikic]

Can you please add a test to TEST(APIntTest, ZeroWidth)?

[lattner]

This revised change to getZExtValue only LGTM, because it is the only reasonable definition of this. As @nikic points out, we need to be more deliberate about bigger changes: defining a zero width thing to always have zero value isn't obviously correct.

Please change the commit message to "Remove zero-width assertion from getZExtValue" to make it more specific, thanks!

[seldridge]

Add test of zero-width ZExt behavior.

[foad]

LGTM too, thanks!

[seldridge]

Update commit message/diff summary to reflect reduced scope.

[nikic]

LG

llvm/unittests/ADT/APIntTest.cpp

3057 ↗

(On Diff #390803)

Zero extension :)

[seldridge]

Fix comment. :)

llvm/include/llvm/ADT/APInt.h

#endif
   unsigned getMinSignedBits() const { return BitWidth - getNumSignBits() + 1; }
 
   /// Get zero extended value
   ///
   /// This method attempts to return the value of this APInt as a zero extended
   /// uint64_t. The bitwidth must be <= 64 or the value must fit within a
   /// uint64_t. Otherwise an assertion will result.
   uint64_t getZExtValue() const {
-    if (isSingleWord()) {
-      assert(BitWidth && "zero width values not allowed");
+    if (isSingleWord())
       return U.VAL;
-    }
     assert(getActiveBits() <= 64 && "Too many bits for uint64_t");
     return U.pVal[0];
   }
 
   /// Get sign extended value
   ///
   /// This method attempts to return the value of this APInt as a sign extended
   /// int64_t. The bit width must be <= 64 or the value must fit within an

llvm/include/llvm/Support/MathExtras.h

 /// \p Skew mod \p Align. \p Align must be non-zero
 inline uint64_t alignDown(uint64_t Value, uint64_t Align, uint64_t Skew = 0) {
   assert(Align != 0u && "Align can't be 0.");
   Skew %= Align;
   return (Value - Skew) / Align * Align + Skew;
 }
 
 /// Sign-extend the number in the bottom B bits of X to a 32-bit integer.
-/// Requires 0 < B <= 32.
+/// Requires 0 <= B <= 32.  Sign extension of a zero-width value returns zero.
 template <unsigned B> constexpr inline int32_t SignExtend32(uint32_t X) {
-  static_assert(B > 0, "Bit width can't be 0.");
   static_assert(B <= 32, "Bit width out of range.");
+  if (!B)
+    return 0;
   return int32_t(X << (32 - B)) >> (32 - B);
 }
 
 /// Sign-extend the number in the bottom B bits of X to a 32-bit integer.
-/// Requires 0 < B <= 32.
+/// Requires 0 <= B <= 32.  Sign extension of a zero-width value returns zero.
 inline int32_t SignExtend32(uint32_t X, unsigned B) {
-  assert(B > 0 && "Bit width can't be 0.");
   assert(B <= 32 && "Bit width out of range.");
+  if (!B)
+    return 0;
   return int32_t(X << (32 - B)) >> (32 - B);
 }
 
 /// Sign-extend the number in the bottom B bits of X to a 64-bit integer.
-/// Requires 0 < B <= 64.
+/// Requires 0 <= B <= 64.  Sign extension of a zero-width value returns zero.
 template <unsigned B> constexpr inline int64_t SignExtend64(uint64_t x) {
-  static_assert(B > 0, "Bit width can't be 0.");
   static_assert(B <= 64, "Bit width out of range.");
+  if (!B)
+    return 0;
   return int64_t(x << (64 - B)) >> (64 - B);
 }
 
 /// Sign-extend the number in the bottom B bits of X to a 64-bit integer.
-/// Requires 0 < B <= 64.
+/// Requires 0 <= B <= 64.  Sign extension of a zero-width value returns zero.
 inline int64_t SignExtend64(uint64_t X, unsigned B) {
-  assert(B > 0 && "Bit width can't be 0.");
   assert(B <= 64 && "Bit width out of range.");
+  if (!B)
+    return 0;
   return int64_t(X << (64 - B)) >> (64 - B);
 }
 
 /// Subtract two unsigned integers, X and Y, of type T and return the absolute
 /// value of the result.
 template <typename T>
 std::enable_if_t<std::is_unsigned<T>::value, T> AbsoluteDifference(T X, T Y) {
   return X > Y ? (X - Y) : (Y - X);