[APInt] Enable APInt to support zero bit integers.

[lattner]

Summary

Motivation: APInt not supporting zero bit values leads to
a lot of special cases in various bits of code, particularly
when using APInt as a bit vector (where you want to start with
zero bits and then concat on more. This is particularly
challenging in the CIRCT project, where the absence of zero-bit
ConstantOp forces duplication of ops and makes instcombine-like
logic far more complicated.

Approach: zero bit integers are weird. There are two reasonable
approaches: either make it illegal to do general arithmetic on
them (e.g. sign extends), or treat them as as implicitly having
a zero value. This patch takes the conservative approach, which
enables their use in bitvector applications.

[lattner]

Craig or Andrew's, would you be willing to review this?

[lattner]

One random example of where zero bit values would be better: https://github.com/llvm/circt/blob/main/lib/Dialect/Comb/CombFolds.cpp#L1909

The bigger problem is that things like firrtl.constant cannot represent zero bit values, which causes no end of problem, e.g. here:
https://github.com/llvm/circt/blob/main/lib/Dialect/FIRRTL/FIRRTLFolds.cpp

[craig.topper]

llvm/include/llvm/ADT/APInt.h

575–576

This comment is wrong. We aren't checking bitwidth, we're checking that both bitwidths are <=64, but not that they are the same.

580

Why don't we need to clearUnusedBits here?

llvm/lib/Support/APInt.cpp

262

I assume you droped this because it's checked in operator*?

1098

BitWidth?

[lattner]

Fix an incorrect comment, and tweak some logic that Craig noticed.

[lattner]

llvm/include/llvm/ADT/APInt.h

575–576

agreed, good catch.

580

I can split this out to a different patch if you prefer. It just isn't needed. RHS is already a well formed APInt, so it already has the right zero bits at the top.

llvm/lib/Support/APInt.cpp

262

Right. I trimmed some redundant checks.

1098

great catch

[craig.topper]

llvm/include/llvm/ADT/APInt.h

580

Couldn't RHS have more bits than this which would require the bits to be removed?

[lattner]

llvm/include/llvm/ADT/APInt.h

580

Nope. This is a copy ctor, we're taking both the new value and the new bitwidth, so the new value is already guaranteed to be normalized under the new bitwidth by the instance we're copying from.

[lattner]

Fix case issue in unit test to make clang-tidy happier.

[youngar]

llvm/include/llvm/ADT/APInt.h

1441–1446

In the initial comment block you mention that zext is defined, should this assert be removed?

[youngar]

llvm/include/llvm/ADT/APInt.h

1441–1446

Oh, this should be moved to getSExtValue()

[lattner]

llvm/include/llvm/ADT/APInt.h

1441–1446

What I meant is the zext() method which zero extends an APInt (by adding new zeros and not caring about what is already there). I chose to make this undefined on zero bit values because it is accessing the (non-existent) value.

We could change this (in this, or in a future patch), and make getZExtValue() also work. That would definitely enable a bunch of stuff to "just work" with zero bit APInts, I just started out conservative with this patch.

[craig.topper]

llvm/include/llvm/ADT/APInt.h

580

Derp. That makes sense.

[lattner]

Thanks. @youngar are you satisfied with this as a logical step forward? Anyone willing to provide an LGTM?

[lattner]

incidentally, I fixed the clang-tidy warnings in new code, but I don't plan to "clang tidy clean" this code pervasively. it would distract from the core of what this patch is about.

[youngar]

Yeah, I'm happy with this step forward. LGTM.

[craig.topper]

LGTM

[lattner]

Thanks both!

[xbolva00]

In D109555#2993501, @lattner wrote:

Thanks both!

Seems more expensive than expected.

http://llvm-compile-time-tracker.com/compare.php?from=7f793b102c9a11eddcf247da8043a3556581e7c1&to=704a39569346401e96a6a3978ddc490dfa828ccc&stat=instructions

[xbolva00]

llvm/include/llvm/ADT/APInt.h

351

LLVM_UNLIKELY?

1494

detto

1844

.

llvm/lib/Support/APInt.cpp

1067

.

1085

also here and below..

[lattner]

Thanks for the head's up @xbolva00. Will add those in a follow-up

[foad]

llvm/include/llvm/ADT/APInt.h

352

Should be true, surely?

[lattner]

llvm/include/llvm/ADT/APInt.h

352

Welcome to the weirdness of zero bit integers :)

[foad]

llvm/include/llvm/ADT/APInt.h

352

I'm not joking. I assert that isAllOnes(getZeroWidth()) should return true, for the same reason that std::all_of() returns true on an empty range.

To put it another way, all of the bits in a zero-width integer are 1, and I challenge you to show me one that isn't!

To put it another way, isAllOnes(X) should be the same as X == (1 << X.getBitWidth()) - 1.

[lattner]

You're right - I think there are two logically consistent paths we could take (and this patch isn't either of them):

1. We could take your approach.
2. We could abort and die on isAllOnes() saying it is not defined.

The patch is already treating zero bit integers as "zero" (no bits set means the value is zero) in the isZero() and isOne() predicates, so I think that going with #1 is defensible. We could also define sext(zerobit) as filling with zeros as well. WDYT?

I'm happy to switch this if we can settle on a design.

[foad]

My starting point is that a zero-width unsigned integer makes sense and always has the value 0, but a zero-width signed integer makes no sense at all (I think you could "logically" argue that it is always 0, or that is is always -1). With that in mind...

You're right - I think there are two logically consistent paths we could take (and this patch isn't either of them):

1. We could take your approach.
2. We could abort and die on isAllOnes() saying it is not defined.

I'd prefer (1) and I think it's logically consistent.

The patch is already treating zero bit integers as "zero" (no bits set means the value is zero) in the isZero() and isOne() predicates, so I think that going with #1 is defensible. We could also define sext(zerobit) as filling with zeros as well. WDYT?

I think isZero and isOne and zext should all work on zero-width integers, but sext should assert that the width is non-zero.

[lattner]

My starting point is that a zero-width unsigned integer makes sense and always has the value 0, but a zero-width signed integer makes no sense at all (I think you could "logically" argue that it is always 0, or that is is always -1). With that in mind...
I think isZero and isOne and zext should all work on zero-width integers, but sext should assert that the width is non-zero.

I don't understand how sext is different. APInt doesn't hold a signed value, and sext doesn't extend from a signed value. sext is a function defined based on the high bit of the existing value. It doesn't make sense for a zero-width APInt to return true for isZero() but not produce a n-bit zero value for sext(n).

[foad]

It doesn't make sense for a zero-width APInt to return true for isZero() but not produce a n-bit zero value for sext(n).

You could just as well say: it doesn't make sense for a zero-width APInt to return true for isAllOnes() but not produce a n-bit all-ones value for sext(n).

Zero-width ints satisfy both isZero() and (I assert) isAllOnes(), so something has to give. I think the solution is to say that sext is not defined on zero-width ints because...

sext is a function defined based on the high bit of the existing value.

... a zero-width int doesn't have a high bit.

[lattner]

Hi Jay,

I'm getting caught back up on old patches and I'm not sure if I closed this off with you. isAllOnes() seems defined on zero bit values now, so I think you're happy. Am I missing anything more?

-Chris

[foad]

In D109555#3043950, @lattner wrote:

I'm getting caught back up on old patches and I'm not sure if I closed this off with you. isAllOnes() seems defined on zero bit values now, so I think you're happy. Am I missing anything more?

isAllOnes returns false on zero bit values. I still maintain it should return true. Then I'd be happy :)

[lattner]

Ok, I'll take the scary risk of making you incrementally happier: https://reviews.llvm.org/D111241 :-)

Thanks Jay!

llvm/include/llvm/ADT/APInt.h

 ///   * The value is stored canonically as an unsigned value. For operations
 ///     where it makes a difference, there are both signed and unsigned variants
 ///     of the operation. For example, sdiv and udiv. However, because the bit
 ///     widths must be the same, operations such as Mul and Add produce the same
 ///     results regardless of whether the values are interpreted as signed or
 ///     not.
 ///   * In general, the class tries to follow the style of computation that LLVM
 ///     uses in its IR. This simplifies its use for LLVM.
+///   * APInt supports zero-bit-width values, but operations that require bits
+///     are not defined on it (e.g. you cannot ask for the sign of a zero-bit
+///     integer).  This means that operations like zero extension and logical
+///     shifts are defined, but sign extension and ashr is not.  Zero bit values
+///     compare and hash equal to themselves, and countLeadingZeros returns 0.
 ///
 class LLVM_NODISCARD APInt {
 public:
   typedef uint64_t WordType;
 
   /// This enum is used to hold the constants we needed for APInt.
   enum : unsigned {
     /// Byte size of a word.
public:
   /// will be done. Otherwise, no sign extension occurs (high order bits beyond
   /// the range of val are zero filled).
   ///
   /// \param numBits the bit width of the constructed APInt
   /// \param val the initial value of the APInt
   /// \param isSigned how to treat signedness of val
   APInt(unsigned numBits, uint64_t val, bool isSigned = false)
       : BitWidth(numBits) {
-    assert(BitWidth && "bitwidth too small");
     if (isSingleWord()) {
       U.VAL = val;
       clearUnusedBits();
     } else {
       initSlowCase(val, isSigned);
     }
   }
 
public:
   /// are 2, 8, 10, 16, and 36. It is an error for the value implied by the
   /// string to require more bits than numBits.
   ///
   /// \param numBits the bit width of the constructed APInt
   /// \param str the string to be interpreted
   /// \param radix the radix to use for the conversion
   APInt(unsigned numBits, StringRef str, uint8_t radix);
 
-  /// Default constructor that creates an uninteresting APInt
-  /// representing a 1-bit zero value.
-  ///
-  /// This is useful for object deserialization (pair this with the static
-  ///  method Read).
+  /// Default constructor that creates an APInt with a 1-bit zero value.
   explicit APInt() : BitWidth(1) { U.VAL = 0; }
 
   /// Copy Constructor.
   APInt(const APInt &that) : BitWidth(that.BitWidth) {
     if (isSingleWord())
       U.VAL = that.U.VAL;
     else
       initSlowCase(that);
public:
   /// @{
 
   /// Get the '0' value for the specified bit-width.
   static APInt getZero(unsigned numBits) { return APInt(numBits, 0); }
 
   /// NOTE: This is soft-deprecated.  Please use `getZero()` instead.
   static APInt getNullValue(unsigned numBits) { return getZero(numBits); }
 
+  /// Return an APInt zero bits wide.
+  static APInt getZeroWidth() { return getZero(0); }
+
   /// Gets maximum unsigned value of APInt for specific bit width.
   static APInt getMaxValue(unsigned numBits) {
     return getAllOnesValue(numBits);
   }
 
   /// Gets maximum signed value of APInt for a specific bit width.
   static APInt getSignedMaxValue(unsigned numBits) {
     APInt API = getAllOnesValue(numBits);
public:
   /// \p hiBit.
   ///
   /// \param numBits the intended bit width of the result
   /// \param loBit the index of the lowest bit set.
   /// \param hiBit the index of the highest bit set.
   ///
   /// \returns An APInt value with the requested bits set.
   static APInt getBitsSet(unsigned numBits, unsigned loBit, unsigned hiBit) {
-    assert(loBit <= hiBit && "loBit greater than hiBit");
     APInt Res(numBits, 0);
     Res.setBits(loBit, hiBit);
     return Res;
   }
 
   /// Wrap version of getBitsSet.
   /// If \p hiBit is bigger than \p loBit, this is same with getBitsSet.
   /// If \p hiBit is not bigger than \p loBit, the set bits "wrap". For example,
   /// with parameters (32, 28, 4), you would get 0xF000000F.
   /// If \p hiBit is equal to \p loBit, you would get a result with all bits
   /// set.
   static APInt getBitsSetWithWrap(unsigned numBits, unsigned loBit,
                                   unsigned hiBit) {
     APInt Res(numBits, 0);
     Res.setBitsWithWrap(loBit, hiBit);
     return Res;
   }
 
-  /// Get a value with upper bits starting at loBit set.
-  ///
   /// Constructs an APInt value that has a contiguous range of bits set. The
   /// bits from loBit (inclusive) to numBits (exclusive) will be set. All other
   /// bits will be zero. For example, with parameters(32, 12) you would get
   /// 0xFFFFF000.
   ///
   /// \param numBits the intended bit width of the result
   /// \param loBit the index of the lowest bit to set.
   ///
   /// \returns An APInt value with the requested bits set.
   static APInt getBitsSetFrom(unsigned numBits, unsigned loBit) {
     APInt Res(numBits, 0);
     Res.setBitsFrom(loBit);
     return Res;
   }
 
-  /// Get a value with high bits set
-  ///
   /// Constructs an APInt value that has the top hiBitsSet bits set.
   ///
   /// \param numBits the bitwidth of the result
   /// \param hiBitsSet the number of high-order bits set in the result.
   static APInt getHighBitsSet(unsigned numBits, unsigned hiBitsSet) {
     APInt Res(numBits, 0);
     Res.setHighBits(hiBitsSet);
     return Res;
   }
 
-  /// Get a value with low bits set
-  ///
   /// Constructs an APInt value that has the bottom loBitsSet bits set.
   ///
   /// \param numBits the bitwidth of the result
   /// \param loBitsSet the number of low-order bits set in the result.
   static APInt getLowBitsSet(unsigned numBits, unsigned loBitsSet) {
     APInt Res(numBits, 0);
     Res.setLowBits(loBitsSet);
     return Res;
public:
 
   /// Determine if this APInt Value is non-positive (<= 0).
   ///
   /// \returns true if this APInt is non-positive.
   bool isNonPositive() const { return !isStrictlyPositive(); }
 
   /// Determine if all bits are set.
   bool isAllOnes() const {
-    if (isSingleWord())
+    if (isSingleWord()) {
+      if (BitWidth == 0)
+        return false;
       return U.VAL == WORDTYPE_MAX >> (APINT_BITS_PER_WORD - BitWidth);
+    }
     return countTrailingOnesSlowCase() == BitWidth;
   }
 
   /// NOTE: This is soft-deprecated.  Please use `isAllOnes()` instead.
   bool isAllOnesValue() const { return isAllOnes(); }
 
   /// Determine if this value is zero, i.e. all bits are clear.
-  bool isZero() const { return !*this; }
+  bool isZero() const {
+    if (isSingleWord())
+      return U.VAL == 0;
+    return countLeadingZerosSlowCase() == BitWidth;
+  }
 
   /// NOTE: This is soft-deprecated.  Please use `isZero()` instead.
   bool isNullValue() const { return isZero(); }
 
   /// Determine if this is a value of 1.
   ///
   /// This checks to see if the value of this APInt is one.
   bool isOne() const {
public:
   /// value for the APInt's bit width.
   bool isMaxValue() const { return isAllOnes(); }
 
   /// Determine if this is the largest signed value.
   ///
   /// This checks to see if the value of this APInt is the maximum signed
   /// value for the APInt's bit width.
   bool isMaxSignedValue() const {
-    if (isSingleWord())
+    if (isSingleWord()) {
+      assert(BitWidth && "zero width values not allowed");
       return U.VAL == ((WordType(1) << (BitWidth - 1)) - 1);
+    }
     return !isNegative() && countTrailingOnesSlowCase() == BitWidth - 1;
   }
 
   /// Determine if this is the smallest unsigned value.
   ///
   /// This checks to see if the value of this APInt is the minimum unsigned
   /// value for the APInt's bit width.
   bool isMinValue() const { return isZero(); }
 
   /// Determine if this is the smallest signed value.
   ///
   /// This checks to see if the value of this APInt is the minimum signed
   /// value for the APInt's bit width.
   bool isMinSignedValue() const {
-    if (isSingleWord())
+    if (isSingleWord()) {
+      assert(BitWidth && "zero width values not allowed");
       return U.VAL == (WordType(1) << (BitWidth - 1));
+    }
     return isNegative() && countTrailingZerosSlowCase() == BitWidth - 1;
   }
 
   /// Check if this APInt has an N-bits unsigned integer value.
-  bool isIntN(unsigned N) const {
-    assert(N && "0 bit APInt not supported");
-    return getActiveBits() <= N;
-  }
+  bool isIntN(unsigned N) const { return getActiveBits() <= N; }
 
   /// Check if this APInt has an N-bits signed integer value.
-  bool isSignedIntN(unsigned N) const {
-    assert(N && "0 bit APInt not supported");
-    return getMinSignedBits() <= N;
-  }
+  bool isSignedIntN(unsigned N) const { return getMinSignedBits() <= N; }
 
   /// Check if this APInt's value is a power of two greater than zero.
   ///
   /// \returns true if the argument APInt value is a power of two > 0.
   bool isPowerOf2() const {
-    if (isSingleWord())
+    if (isSingleWord()) {
+      assert(BitWidth && "zero width values not allowed");
       return isPowerOf2_64(U.VAL);
+    }
     return countPopulationSlowCase() == 1;
   }
 
   /// Check if the APInt's value is returned by getSignMask.
   ///
   /// \returns true if this is the value returned by getSignMask.
   bool isSignMask() const { return isMinSignedValue(); }
 
   /// Convert APInt to a boolean value.
   ///
   /// This converts the APInt to a boolean value as a test against zero.
-  bool getBoolValue() const { return !!*this; }
+  bool getBoolValue() const { return !isZero(); }
 
   /// If this value is smaller than the specified limit, return it, otherwise
   /// return the limit value.  This causes the value to saturate to the limit.
   uint64_t getLimitedValue(uint64_t Limit = UINT64_MAX) const {
     return ugt(Limit) ? Limit : getZExtValue();
   }
 
   /// Check if the APInt consists of a repeated bit pattern.
if (isSingleWord())
       return isShiftedMask_64(U.VAL);
     unsigned Ones = countPopulationSlowCase();
     unsigned LeadZ = countLeadingZerosSlowCase();
     return (Ones + LeadZ + countTrailingZeros()) == BitWidth;
   }
 
   /// Compute an APInt containing numBits highbits from this APInt.
   ///
-  /// Get an APInt with the same BitWidth as this APInt, just zero mask
-  /// the low bits and right shift to the least significant bit.
+  /// Get an APInt with the same BitWidth as this APInt, just zero mask the low
+  /// bits and right shift to the least significant bit.
   ///
   /// \returns the high "numBits" bits of this APInt.
   APInt getHiBits(unsigned numBits) const;
 
   /// Compute an APInt containing numBits lowbits from this APInt.
   ///
-  /// Get an APInt with the same BitWidth as this APInt, just zero mask
-  /// the high bits.
+  /// Get an APInt with the same BitWidth as this APInt, just zero mask the high
+  /// bits.
   ///
   /// \returns the low "numBits" bits of this APInt.
   APInt getLoBits(unsigned numBits) const;
 
   /// Determine if two APInts have the same value, after zero-extending
   /// one of them (if needed!) to ensure that the bit-widths match.
   static bool isSameValue(const APInt &I1, const APInt &I2) {
     if (I1.getBitWidth() == I2.getBitWidth())
if (isSingleWord())
       return &U.VAL;
     return &U.pVal[0];
   }
 
   /// @}
   /// \name Unary Operators
   /// @{
 
-  /// Postfix increment operator.
-  ///
-  /// Increments *this by 1.
+  /// Postfix increment operator.  Increment *this by 1.
   ///
   /// \returns a new APInt value representing the original value of *this.
   APInt operator++(int) {
     APInt API(*this);
     ++(*this);
     return API;
   }
 
   /// Prefix increment operator.
   ///
   /// \returns *this incremented by one
   APInt &operator++();
 
-  /// Postfix decrement operator.
-  ///
-  /// Decrements *this by 1.
+  /// Postfix decrement operator. Decrement *this by 1.
   ///
   /// \returns a new APInt value representing the original value of *this.
   APInt operator--(int) {
     APInt API(*this);
     --(*this);
     return API;
   }
 
   /// Prefix decrement operator.
   ///
   /// \returns *this decremented by one.
   APInt &operator--();
 
-  /// Logical negation operator.
-  ///
-  /// Performs logical negation operation on this APInt.
-  ///
-  /// \returns true if *this is zero, false otherwise.
-  bool operator!() const {
-    if (isSingleWord())
-      return U.VAL == 0;
-    return countLeadingZerosSlowCase() == BitWidth;
-  }
+  /// Logical negation operation on this APInt returns true if zero, like normal
+  /// integers.
+  bool operator!() const { return isZero(); }
 
   /// @}
   /// \name Assignment Operators
   /// @{
 
   /// Copy assignment operator.
   ///
   /// \returns *this after assignment of RHS.
   APInt &operator=(const APInt &RHS) {
-    // If the bitwidths are the same, we can avoid mucking with memory
+    // The common case (both source or dest being inline) doesn't require
+    // allocation or deallocation.
     if (isSingleWord() && RHS.isSingleWord()) {
       U.VAL = RHS.U.VAL;
       BitWidth = RHS.BitWidth;
-      return clearUnusedBits();
+      return *this;
     }
 
     AssignSlowCase(RHS);
     return *this;
   }
 
   /// Move assignment operator.
   APInt &operator=(APInt &&that) {
 #ifdef EXPENSIVE_CHECKS
     // Some std::shuffle implementations still do self-assignment.
     if (this == &that)
       return *this;
 #endif
     assert(this != &that && "Self-move not supported");
     if (!isSingleWord())
       delete[] U.pVal;
 
     // Use memcpy so that type based alias analysis sees both VAL and pVal
     // as modified.
     memcpy(&U, &that.U, sizeof(U));
 
     BitWidth = that.BitWidth;
     that.BitWidth = 0;
-
     return *this;
   }
 
   /// Assignment operator.
   ///
   /// The RHS value is assigned to *this. If the significant bits in RHS exceed
   /// the bit width, the excess bits are truncated. If the bit width is larger
   /// than 64, the value is zero filled in the unspecified high order bits.
if (isSingleWord())
       U.VAL = WORDTYPE_MAX;
     else
       // Set all the bits in all the words.
       memset(U.pVal, -1, getNumWords() * APINT_WORD_SIZE);
     // Clear the unused ones
     clearUnusedBits();
   }
 
-  /// Set a given bit to 1.
-  ///
   /// Set the given bit to 1 whose position is given as "bitPosition".
   void setBit(unsigned BitPosition) {
     assert(BitPosition < BitWidth && "BitPosition out of range");
     WordType Mask = maskBit(BitPosition);
     if (isSingleWord())
       U.VAL |= Mask;
     else
       U.pVal[whichWord(BitPosition)] |= Mask;
#endif
   /// for -1, this function will always return 1.
   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())
+    if (isSingleWord()) {
+      assert(BitWidth && "zero width values not allowed");
       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
   /// int64_t. Otherwise an assertion will result.
#endif
   ///
   /// This function is an APInt version of the countLeadingOnes
   /// functions in MathExtras.h. It counts the number of ones from the most
   /// significant bit to the first zero bit.
   ///
   /// \returns 0 if the high order bit is not set, otherwise returns the number
   /// of 1 bits from the most significant to the least
   unsigned countLeadingOnes() const {
-    if (isSingleWord())
+    if (isSingleWord()) {
+      if (BitWidth == 0)
+        return 0;
       return llvm::countLeadingOnes(U.VAL << (APINT_BITS_PER_WORD - BitWidth));
+    }
     return countLeadingOnesSlowCase();
   }
 
   /// Computes the number of leading bits of this APInt that are equal to its
   /// sign bit.
   unsigned getNumSignBits() const {
     return isNegative() ? countLeadingOnes() : countLeadingZeros();
   }
private:
   } U;
 
   unsigned BitWidth; ///< The number of bits in this APInt.
 
   friend struct DenseMapInfo<APInt>;
 
   friend class APSInt;
 
-  /// Fast internal constructor
-  ///
   /// This constructor is used only internally for speed of construction of
-  /// temporaries. It is unsafe for general use so it is not public.
+  /// temporaries. It is unsafe since it takes ownership of the pointer, so it
+  /// is not public.
   APInt(uint64_t *val, unsigned bits) : BitWidth(bits) { U.pVal = val; }
 
   /// Determine which word a bit is in.
   ///
   /// \returns the word position for the specified bit position.
   static unsigned whichWord(unsigned bitPosition) {
     return bitPosition / APINT_BITS_PER_WORD;
   }
 
-  /// Determine which bit in a word a bit is in.
-  ///
-  /// \returns the bit position in a word for the specified bit position
-  /// in the APInt.
+  /// Determine which bit in a word the specified bit position is in.
   static unsigned whichBit(unsigned bitPosition) {
     return bitPosition % APINT_BITS_PER_WORD;
   }
 
   /// Get a single bit mask.
   ///
   /// \returns a uint64_t with only bit at "whichBit(bitPosition)" set
   /// This method generates and returns a uint64_t (word) mask for a single
   /// bit at a specific bit position. This is used to mask the bit in the
   /// corresponding word.
   static uint64_t maskBit(unsigned bitPosition) {
     return 1ULL << whichBit(bitPosition);
   }
 
   /// Clear unused high order bits
   ///
   /// This method is used internally to clear the top "N" bits in the high order
   /// word that are not used by the APInt. This is needed after the most
   /// significant word is assigned a value to ensure that those bits are
   /// zero'd out.
   APInt &clearUnusedBits() {
-    // Compute how many bits are used in the final word
+    // Compute how many bits are used in the final word.
     unsigned WordBits = ((BitWidth - 1) % APINT_BITS_PER_WORD) + 1;
 
     // Mask out the high bits.
     uint64_t mask = WORDTYPE_MAX >> (APINT_BITS_PER_WORD - WordBits);
+    if (BitWidth == 0)
+      mask = 0;
+
     if (isSingleWord())
       U.VAL &= mask;
     else
       U.pVal[getNumWords() - 1] &= mask;
     return *this;
   }
 
   /// Get the word corresponding to a bit position

llvm/lib/Support/APInt.cpp

 }
 
 void APInt::initSlowCase(const APInt& that) {
   U.pVal = getMemory(getNumWords());
   memcpy(U.pVal, that.U.pVal, getNumWords() * APINT_WORD_SIZE);
 }
 
 void APInt::initFromArray(ArrayRef<uint64_t> bigVal) {
-  assert(BitWidth && "Bitwidth too small");
   assert(bigVal.data() && "Null pointer detected!");
   if (isSingleWord())
     U.VAL = bigVal[0];
   else {
     // Get memory, cleared to 0
     U.pVal = getClearedMemory(getNumWords());
     // Calculate the number of words to copy
     unsigned words = std::min<unsigned>(bigVal.size(), getNumWords());
     // Copy the words from bigVal to pVal
     memcpy(U.pVal, bigVal.data(), words * APINT_WORD_SIZE);
   }
   // Make sure unused high bits are cleared
   clearUnusedBits();
 }
 
-APInt::APInt(unsigned numBits, ArrayRef<uint64_t> bigVal)
-  : BitWidth(numBits) {
+APInt::APInt(unsigned numBits, ArrayRef<uint64_t> bigVal) : BitWidth(numBits) {
   initFromArray(bigVal);
 }
 
 APInt::APInt(unsigned numBits, unsigned numWords, const uint64_t bigVal[])
     : BitWidth(numBits) {
   initFromArray(makeArrayRef(bigVal, numWords));
 }
 
 APInt::APInt(unsigned numbits, StringRef Str, uint8_t radix)
     : BitWidth(numbits) {
-  assert(BitWidth && "Bitwidth too small");
   fromString(numbits, Str, radix);
 }
 
 void APInt::reallocate(unsigned NewBitWidth) {
   // If the number of words is the same we can just change the width and stop.
   if (getNumWords() == getNumWords(NewBitWidth)) {
     BitWidth = NewBitWidth;
     return;

 }
 
 APInt APInt::operator*(const APInt& RHS) const {
   assert(BitWidth == RHS.BitWidth && "Bit widths must be the same");
   if (isSingleWord())
     return APInt(BitWidth, U.VAL * RHS.U.VAL);
 
   APInt Result(getMemory(getNumWords()), getBitWidth());
-
   tcMultiply(Result.U.pVal, U.pVal, RHS.U.pVal, getNumWords());
-
   Result.clearUnusedBits();
   return Result;
 }
 
 void APInt::AndAssignSlowCase(const APInt &RHS) {
   WordType *dst = U.pVal, *rhs = RHS.U.pVal;
   for (size_t i = 0, e = getNumWords(); i != e; ++i)
     dst[i] &= rhs[i];
 }
 
 void APInt::OrAssignSlowCase(const APInt &RHS) {
   WordType *dst = U.pVal, *rhs = RHS.U.pVal;
   for (size_t i = 0, e = getNumWords(); i != e; ++i)
     dst[i] |= rhs[i];
 }
 
 void APInt::XorAssignSlowCase(const APInt &RHS) {
   WordType *dst = U.pVal, *rhs = RHS.U.pVal;
   for (size_t i = 0, e = getNumWords(); i != e; ++i)
     dst[i] ^= rhs[i];
 }
 
-APInt& APInt::operator*=(const APInt& RHS) {
-  assert(BitWidth == RHS.BitWidth && "Bit widths must be the same");
+APInt &APInt::operator*=(const APInt &RHS) {
   *this = *this * RHS;
   return *this;
 }
 
 APInt& APInt::operator*=(uint64_t RHS) {
   if (isSingleWord()) {
     U.VAL *= RHS;
   } else {
APInt APInt::reverseBits() const {
   case 64:
     return APInt(BitWidth, llvm::reverseBits<uint64_t>(U.VAL));
   case 32:
     return APInt(BitWidth, llvm::reverseBits<uint32_t>(U.VAL));
   case 16:
     return APInt(BitWidth, llvm::reverseBits<uint16_t>(U.VAL));
   case 8:
     return APInt(BitWidth, llvm::reverseBits<uint8_t>(U.VAL));
+  case 0:
+    return *this;
   default:
     break;
   }
 
   APInt Val(*this);
   APInt Reversed(BitWidth, 0);
   unsigned S = BitWidth;
 
double APInt::roundToDouble(bool isSigned) const {
   uint64_t sign = isNeg ? (1ULL << (APINT_BITS_PER_WORD - 1)) : 0;
   uint64_t I = sign | (exp << 52) | mantissa;
   return bit_cast<double>(I);
 }
 
 // Truncate to new width.
 APInt APInt::trunc(unsigned width) const {
   assert(width < BitWidth && "Invalid APInt Truncate request");
-  assert(width && "Can't truncate to 0 bits");
 
   if (width <= APINT_BITS_PER_WORD)
     return APInt(width, getRawData()[0]);
 
   APInt Result(getMemory(getNumWords(width)), width);
 
   // Copy full words.
   unsigned i;
   for (i = 0; i != width / APINT_BITS_PER_WORD; i++)
     Result.U.pVal[i] = U.pVal[i];
 
   // Truncate and copy any partial word.
   unsigned bits = (0 - width) % APINT_BITS_PER_WORD;
   if (bits != 0)
     Result.U.pVal[i] = U.pVal[i] << bits >> bits;
 
   return Result;
 }
 
 // Truncate to new width with unsigned saturation.
 APInt APInt::truncUSat(unsigned width) const {
   assert(width < BitWidth && "Invalid APInt Truncate request");
-  assert(width && "Can't truncate to 0 bits");
 
   // Can we just losslessly truncate it?
   if (isIntN(width))
     return trunc(width);
   // If not, then just return the new limit.
   return APInt::getMaxValue(width);
 }
 
 // Truncate to new width with signed saturation.
 APInt APInt::truncSSat(unsigned width) const {
   assert(width < BitWidth && "Invalid APInt Truncate request");
-  assert(width && "Can't truncate to 0 bits");
 
   // Can we just losslessly truncate it?
   if (isSignedIntN(width))
     return trunc(width);
   // If not, then just return the new limits.
   return isNegative() ? APInt::getSignedMinValue(width)
                       : APInt::getSignedMaxValue(width);
 }

 
 void APInt::shlSlowCase(unsigned ShiftAmt) {
   tcShiftLeft(U.pVal, getNumWords(), ShiftAmt);
   clearUnusedBits();
 }
 
 // Calculate the rotate amount modulo the bit width.
 static unsigned rotateModulo(unsigned BitWidth, const APInt &rotateAmt) {
+  if (BitWidth == 0)
+    return 0;
   unsigned rotBitWidth = rotateAmt.getBitWidth();
   APInt rot = rotateAmt;
   if (rotBitWidth < BitWidth) {
     // Extend the rotate APInt, so that the urem doesn't divide by 0.
     // e.g. APInt(1, 32) would give APInt(1, 0).
     rot = rotateAmt.zext(BitWidth);
   }
   rot = rot.urem(APInt(rot.getBitWidth(), BitWidth));
   return rot.getLimitedValue(BitWidth);
 }
 
 APInt APInt::rotl(const APInt &rotateAmt) const {
   return rotl(rotateModulo(BitWidth, rotateAmt));
 }
 
 APInt APInt::rotl(unsigned rotateAmt) const {
+  if (BitWidth == 0)
+    return *this;
   rotateAmt %= BitWidth;
   if (rotateAmt == 0)
     return *this;
   return shl(rotateAmt) | lshr(BitWidth - rotateAmt);
 }
 
 APInt APInt::rotr(const APInt &rotateAmt) const {
   return rotr(rotateModulo(BitWidth, rotateAmt));
 }
 
 APInt APInt::rotr(unsigned rotateAmt) const {
+  if (BitWidth == 0)
+    return *this;
   rotateAmt %= BitWidth;
   if (rotateAmt == 0)
     return *this;
   return lshr(rotateAmt) | shl(BitWidth - rotateAmt);
 }
 
 /// \returns the nearest log base 2 of this APInt. Ties round up.
 ///
switch (Radix) {
         Prefix = "0x";
         break;
       default:
         llvm_unreachable("Invalid radix!");
     }
   }
 
   // First, check for a zero value and just short circuit the logic below.
-  if (*this == 0) {
+  if (isZero()) {
     while (*Prefix) {
       Str.push_back(*Prefix);
       ++Prefix;
     };
     Str.push_back('0');
     return;
   }
 
APInt llvm::APIntOps::RoundingUDiv(const APInt &A, const APInt &B,
   // Currently udivrem always rounds down.
   switch (RM) {
   case APInt::Rounding::DOWN:
   case APInt::Rounding::TOWARD_ZERO:
     return A.udiv(B);
   case APInt::Rounding::UP: {
     APInt Quo, Rem;
     APInt::udivrem(A, B, Quo, Rem);
-    if (Rem == 0)
+    if (Rem.isZero())
       return Quo;
     return Quo + 1;
   }
   }
   llvm_unreachable("Unknown APInt::Rounding enum");
 }
 
 APInt llvm::APIntOps::RoundingSDiv(const APInt &A, const APInt &B,
                                    APInt::Rounding RM) {
   switch (RM) {
   case APInt::Rounding::DOWN:
   case APInt::Rounding::UP: {
     APInt Quo, Rem;
     APInt::sdivrem(A, B, Quo, Rem);
-    if (Rem == 0)
+    if (Rem.isZero())
       return Quo;
     // This algorithm deals with arbitrary rounding mode used by sdivrem.
     // We want to check whether the non-integer part of the mathematical value
     // is negative or not. If the non-integer part is negative, we need to round
     // down from Quo; otherwise, if it's positive or 0, we return Quo, as it's
     // already rounded down.
     if (RM == APInt::Rounding::DOWN) {
       if (Rem.isNegative() != B.isNegative())

llvm/unittests/ADT/APIntTest.cpp

TEST(APIntTest, Log2) {
   EXPECT_EQ(APInt(15, 9).logBase2(), 3U);
   EXPECT_EQ(APInt(15, 9).ceilLogBase2(), 4U);
   EXPECT_EQ(APInt(15, 9).exactLogBase2(), -1);
 }
 
 #ifdef GTEST_HAS_DEATH_TEST
 #ifndef NDEBUG
 TEST(APIntTest, StringDeath) {
-  EXPECT_DEATH((void)APInt(0, "", 0), "Bitwidth too small");
   EXPECT_DEATH((void)APInt(32, "", 0), "Invalid string length");
   EXPECT_DEATH((void)APInt(32, "0", 0), "Radix should be 2, 8, 10, 16, or 36!");
   EXPECT_DEATH((void)APInt(32, "", 10), "Invalid string length");
   EXPECT_DEATH((void)APInt(32, "-", 10), "String is only a sign, needs a value.");
   EXPECT_DEATH((void)APInt(1, "1234", 10), "Insufficient bit width");
   EXPECT_DEATH((void)APInt(32, "\0", 10), "Invalid string length");
   EXPECT_DEATH((void)APInt(32, StringRef("1\02", 3), 10), "Invalid character in digit string");
   EXPECT_DEATH((void)APInt(32, "1L", 10), "Invalid character in digit string");
TEST(APIntTest, SignbitZeroChecks) {
   EXPECT_TRUE(APInt(8, 0).isNonPositive());
 
   EXPECT_FALSE(APInt(8, 1).isNegative());
   EXPECT_TRUE(APInt(8, 1).isNonNegative());
   EXPECT_TRUE(APInt(8, 1).isStrictlyPositive());
   EXPECT_FALSE(APInt(8, 1).isNonPositive());
 }
 
+TEST(APIntTest, ZeroWidth) {
+  // Zero width Constructors.
+  auto ZW = APInt::getZeroWidth();
+  EXPECT_EQ(0U, ZW.getBitWidth());
+  EXPECT_EQ(0U, APInt(0, ArrayRef<uint64_t>({0, 1, 2})).getBitWidth());
+  EXPECT_EQ(0U, APInt(0, "0", 10).getBitWidth());
+
+  // Default constructor is single bit wide.
+  EXPECT_EQ(1U, APInt().getBitWidth());
+
+  // Copy ctor (move is down below).
+  APInt ZW2(ZW);
+  EXPECT_EQ(0U, ZW2.getBitWidth());
+  // Assignment
+  ZW = ZW2;
+  EXPECT_EQ(0U, ZW.getBitWidth());
+
+  // Methods like getLowBitsSet work with zero bits.
+  EXPECT_EQ(0U, APInt::getLowBitsSet(0, 0).getBitWidth());
+  EXPECT_EQ(0U, APInt::getSplat(0, ZW).getBitWidth());
+
+  // Logical operators.
+  ZW |= ZW2;
+  ZW &= ZW2;
+  ZW ^= ZW2;
+  ZW |= 42; // These ignore high bits of the literal.
+  ZW &= 42;
+  ZW ^= 42;
+  EXPECT_EQ(1, ZW.isIntN(0));
+
+  // Modulo Arithmetic.  Divide/Rem aren't defined on division by zero, so they
+  // aren't supported.
+  ZW += ZW2;
+  ZW -= ZW2;
+  ZW *= ZW2;
+
+  // Logical Shifts and rotates, the amount must be <= bitwidth.
+  ZW <<= 0;
+  ZW.lshrInPlace(0);
+  (void)ZW.rotl(0);
+  (void)ZW.rotr(0);
+
+  // Comparisons.
+  EXPECT_EQ(1, ZW == ZW);
+  EXPECT_EQ(0, ZW != ZW);
+  EXPECT_EQ(0, ZW.ult(ZW));
+
+  // Mutations.
+  ZW.setBitsWithWrap(0, 0);
+  ZW.setBits(0, 0);
+  ZW.clearAllBits();
+  ZW.flipAllBits();
+
+  // Leading, trailing, ctpop, etc
+  EXPECT_EQ(0U, ZW.countLeadingZeros());
+  EXPECT_EQ(0U, ZW.countLeadingOnes());
+  EXPECT_EQ(0U, ZW.countPopulation());
+  EXPECT_EQ(0U, ZW.reverseBits().getBitWidth());
+  EXPECT_EQ(0U, ZW.getHiBits(0).getBitWidth());
+  EXPECT_EQ(0U, ZW.getLoBits(0).getBitWidth());
+  EXPECT_EQ(0, ZW.zext(4));
+  EXPECT_EQ(0U, APInt(4, 3).trunc(0).getBitWidth());
+
+  SmallString<42> STR;
+  ZW.toStringUnsigned(STR);
+  EXPECT_EQ("0", STR);
+
+  // Move ctor (keep at the end of the method since moves are destructive).
+  APInt MZW1(std::move(ZW));
+  EXPECT_EQ(0U, MZW1.getBitWidth());
+  // Move Assignment
+  MZW1 = std::move(ZW2);
+  EXPECT_EQ(0U, MZW1.getBitWidth());
+}
+
 } // end anonymous namespace