[APInt] Remove calls to clearUnusedBits from XorSlowCase and operator^=

[craig.topper]

Summary

There's a comment in XorSlowCase that says "0^0==1" which isn't true. 0 xored with 0 is still 0. So I don't think we need to clear any unused bits here.

Now there is no difference between XorSlowCase and AndSlowCase/OrSlowCase other than the operation being performed

[chfast]

Looks good, but adding an unit test for this case would be nice...

[craig.topper]

Add some unit tests for 1-bit and/or/xor.

[MatzeB]

LGTM. unittests may also be interesting with the neg_one value (which I had rather called all_ones`.

llvm/trunk/lib/Support/APInt.cpp

for (unsigned i = 0; i < numWords; ++i)
     pVal[i] |= RHS.pVal[i];
   return *this;
 }
 
 APInt& APInt::operator^=(const APInt& RHS) {
   assert(BitWidth == RHS.BitWidth && "Bit widths must be the same");
   if (isSingleWord()) {
     VAL ^= RHS.VAL;
-    this->clearUnusedBits();
     return *this;
   }
   unsigned numWords = getNumWords();
   for (unsigned i = 0; i < numWords; ++i)
     pVal[i] ^= RHS.pVal[i];
-  return clearUnusedBits();
+  return *this;
 }
 
 APInt APInt::AndSlowCase(const APInt& RHS) const {
   unsigned numWords = getNumWords();
   uint64_t* val = getMemory(numWords);
   for (unsigned i = 0; i < numWords; ++i)
     val[i] = pVal[i] & RHS.pVal[i];
   return APInt(val, getBitWidth());
 }
 
 APInt APInt::OrSlowCase(const APInt& RHS) const {
   unsigned numWords = getNumWords();
   uint64_t *val = getMemory(numWords);
   for (unsigned i = 0; i < numWords; ++i)
     val[i] = pVal[i] | RHS.pVal[i];
   return APInt(val, getBitWidth());
 }
 
 APInt APInt::XorSlowCase(const APInt& RHS) const {
   unsigned numWords = getNumWords();
   uint64_t *val = getMemory(numWords);
   for (unsigned i = 0; i < numWords; ++i)
     val[i] = pVal[i] ^ RHS.pVal[i];
 
-  APInt Result(val, getBitWidth());
-  // 0^0==1 so clear the high bits in case they got set.
-  Result.clearUnusedBits();
-  return Result;
+  return APInt(val, getBitWidth());
 }
 
 APInt APInt::operator*(const APInt& RHS) const {
   assert(BitWidth == RHS.BitWidth && "Bit widths must be the same");
   if (isSingleWord())
     return APInt(BitWidth, VAL * RHS.VAL);
   APInt Result(*this);
   Result *= RHS;

llvm/trunk/unittests/ADT/APIntTest.cpp

TEST(APIntTest, i1) {
   EXPECT_EQ(zero, neg_one + one);
   EXPECT_EQ(neg_two, neg_one + neg_one);
 
   // Subtractions.
   EXPECT_EQ(neg_two, neg_one - one);
   EXPECT_EQ(two, one - neg_one);
   EXPECT_EQ(zero, one - one);
 
+  // And
+  EXPECT_EQ(zero, zero & zero);
+  EXPECT_EQ(zero, one & zero);
+  EXPECT_EQ(zero, zero & one);
+  EXPECT_EQ(one, one & one);
+  EXPECT_EQ(zero, zero & zero);
+  EXPECT_EQ(zero, neg_one & zero);
+  EXPECT_EQ(zero, zero & neg_one);
+  EXPECT_EQ(neg_one, neg_one & neg_one);
+
+  // Or
+  EXPECT_EQ(zero, zero | zero);
+  EXPECT_EQ(one, one | zero);
+  EXPECT_EQ(one, zero | one);
+  EXPECT_EQ(one, one | one);
+  EXPECT_EQ(zero, zero | zero);
+  EXPECT_EQ(neg_one, neg_one | zero);
+  EXPECT_EQ(neg_one, zero | neg_one);
+  EXPECT_EQ(neg_one, neg_one | neg_one);
+
+  // Xor
+  EXPECT_EQ(zero, zero ^ zero);
+  EXPECT_EQ(one, one ^ zero);
+  EXPECT_EQ(one, zero ^ one);
+  EXPECT_EQ(zero, one ^ one);
+  EXPECT_EQ(zero, zero ^ zero);
+  EXPECT_EQ(neg_one, neg_one ^ zero);
+  EXPECT_EQ(neg_one, zero ^ neg_one);
+  EXPECT_EQ(zero, neg_one ^ neg_one);
+
   // Shifts.
   EXPECT_EQ(zero, one << one);
   EXPECT_EQ(one, one << zero);
   EXPECT_EQ(zero, one.shl(1));
   EXPECT_EQ(one, one.shl(0));
   EXPECT_EQ(zero, one.lshr(1));
   EXPECT_EQ(zero, one.ashr(1));