[APInt] Make insertBits and concat work with zero width APInts.

[lattner]

Summary

These should both clearly work with our current model for zero width
integers, but don't until now!

[lattner]

Improve unit test a bit.

[foad]

LGTM!

llvm/lib/Support/APInt.cpp

348

Just a pet peeve, I would much prefer that methods like zext and trunc allow the degenerate cases where you're extending or truncating to the same width. I think having separate "OrSelf" versions just adds clutter for no real benefit.

[lattner]

Thanks for the review Jay!

llvm/lib/Support/APInt.cpp

348

I agree completely, would you like to allow this and deprecate the "OrSelf" versions?

[foad]

extractBits also needs some work. Currently it asserts that numBits > 0.

[foad]

llvm/lib/Support/APInt.cpp

348

I have four patches for this:

1. Allow zext/sext/trunc to the same width
2. Change all users of xxxOrSelf to use the standard functions. (This isn't completely trivial because some users rely on the strange undocumented behaviour of the OrSelf functions, where they allow extending to a smaller width or truncating to a larger width, and treat it as a no-op.)
3. Deprecate the OrSelf functions
4. Remove the OrSelf functions

Is splitting it into four excessive?

[lattner]

I think your four steps is a great approach!

llvm/lib/Support/APInt.cpp

 }
 
 /// Concatenate the bits from "NewLSB" onto the bottom of *this.  This is
 /// equivalent to:
 ///   (this->zext(NewWidth) << NewLSB.getBitWidth()) | NewLSB.zext(NewWidth)
 /// In the slow case, we know the result is large.
 APInt APInt::concatSlowCase(const APInt &NewLSB) const {
   unsigned NewWidth = getBitWidth() + NewLSB.getBitWidth();
-  APInt Result = NewLSB.zext(NewWidth);
+  APInt Result = NewLSB.zextOrSelf(NewWidth);
   Result.insertBits(*this, NewLSB.getBitWidth());
   return Result;
 }
 
 /// Toggle a given bit to its opposite value whose position is given
 /// as "bitPosition".
 /// Toggles a given bit to its opposite value.
 void APInt::flipBit(unsigned bitPosition) {
   assert(bitPosition < BitWidth && "Out of the bit-width range!");
   setBitVal(bitPosition, !(*this)[bitPosition]);
 }
 
 void APInt::insertBits(const APInt &subBits, unsigned bitPosition) {
   unsigned subBitWidth = subBits.getBitWidth();
-  assert(0 < subBitWidth && (subBitWidth + bitPosition) <= BitWidth &&
+  assert(subBitWidth >= 0 && (subBitWidth + bitPosition) <= BitWidth &&
          "Illegal bit insertion");
 
+  // inserting no bits is a noop.
+  if (subBitWidth == 0)
+    return;
+
   // Insertion is a direct copy.
   if (subBitWidth == BitWidth) {
     *this = subBits;
     return;
   }
 
   // Single word result can be done as a direct bitmask.
   if (isSingleWord()) {

llvm/unittests/ADT/APIntTest.cpp

TEST(APIntTest, insertBits) {
   // General insertion.
   APInt i260(260, UINT64_MAX, true);
   i260.insertBits(APInt(129, 1ull << 48), 15);
   EXPECT_EQ(i260.extractBits(64, 0).getZExtValue(), 0x8000000000007FFFull);
   EXPECT_EQ(i260.extractBits(64, 64).getZExtValue(), 0x0000000000000000ull);
   EXPECT_EQ(i260.extractBits(64, 128).getZExtValue(), 0xFFFFFFFFFFFF0000ull);
   EXPECT_EQ(i260.extractBits(64, 192).getZExtValue(), 0xFFFFFFFFFFFFFFFFull);
   EXPECT_EQ(i260.extractBits(4, 256).getZExtValue(), 0x000000000000000Full);
+
+  // Zero width insert is a noop.
+  i31.insertBits(APInt::getZeroWidth(), 1);
 }
 
 TEST(APIntTest, insertBitsUInt64) {
   // Tests cloned from insertBits but adapted to the numBits <= 64 constraint
   uint64_t iSrc = 0x00123456;
 
   // Direct copy.
   APInt i31(31, 0x76543210ull);

 
 TEST(APIntTest, truncOrSelf) {
   APInt val(32, 0xFFFFFFFF);
   EXPECT_EQ(0xFFFF, val.truncOrSelf(16));
   EXPECT_EQ(0xFFFFFFFF, val.truncOrSelf(32));
   EXPECT_EQ(0xFFFFFFFF, val.truncOrSelf(64));
 }
 
-TEST(APIntTest, concatMSB) {
+TEST(APIntTest, concat) {
   APInt Int1(4, 0x1ULL);
   APInt Int3(4, 0x3ULL);
 
   EXPECT_EQ(0x31, Int3.concat(Int1));
   EXPECT_EQ(APInt(12, 0x313), Int3.concat(Int1).concat(Int3));
   EXPECT_EQ(APInt(16, 0x3313), Int3.concat(Int3).concat(Int1).concat(Int3));
 
   APInt I64(64, 0x3ULL);
   EXPECT_EQ(I64, I64.concat(I64).lshr(64).trunc(64));
+
+  APInt I65(65, 0x3ULL);
+  APInt I0 = APInt::getZeroWidth();
+  EXPECT_EQ(I65, I65.concat(I0));
+  EXPECT_EQ(I65, I0.concat(I65));
 }
 
 TEST(APIntTest, multiply) {
   APInt i64(64, 1234);
 
   EXPECT_EQ(7006652, i64 * 5678);
   EXPECT_EQ(7006652, 5678 * i64);