[APInt] Keep the original bit width in quotient and remainder

[kparzysz]

Summary

Some trivial cases in udivrem were handled by directly assigning 0 or 1 to APInt objects. This would set the bit width to 1, instead of the bit width of the inputs. A potentially undesirable side effect of that is that with the bit width of 1, 1 equals -1.

[craig.topper]

LGTM

lib/Support/APInt.cpp

void APInt::udivrem(const APInt &LHS, const APInt &RHS,
   // Get some size facts about the dividend and divisor
   unsigned lhsWords = getNumWords(LHS.getActiveBits());
   unsigned rhsBits  = RHS.getActiveBits();
   unsigned rhsWords = getNumWords(rhsBits);
   assert(rhsWords && "Performing divrem operation by zero ???");
 
   // Check the degenerate cases
   if (lhsWords == 0) {
-    Quotient = 0;                // 0 / Y ===> 0
-    Remainder = 0;               // 0 % Y ===> 0
+    Quotient = APInt(BitWidth, 0);    // 0 / Y ===> 0
+    Remainder = APInt(BitWidth, 0);   // 0 % Y ===> 0
     return;
   }
 
   if (rhsBits == 1) {
-    Quotient = LHS;             // X / 1 ===> X
-    Remainder = 0;              // X % 1 ===> 0
+    Quotient = LHS;                   // X / 1 ===> X
+    Remainder = APInt(BitWidth, 0);   // X % 1 ===> 0
   }
 
   if (lhsWords < rhsWords || LHS.ult(RHS)) {
-    Remainder = LHS;            // X % Y ===> X, iff X < Y
-    Quotient = 0;               // X / Y ===> 0, iff X < Y
+    Remainder = LHS;                  // X % Y ===> X, iff X < Y
+    Quotient = APInt(BitWidth, 0);    // X / Y ===> 0, iff X < Y
     return;
   }
 
   if (LHS == RHS) {
-    Quotient  = 1;              // X / X ===> 1
-    Remainder = 0;              // X % X ===> 0;
+    Quotient  = APInt(BitWidth, 1);   // X / X ===> 1
+    Remainder = APInt(BitWidth, 0);   // X % X ===> 0;
     return;
   }
 
   // Make sure there is enough space to hold the results.
   // NOTE: This assumes that reallocate won't affect any bits if it doesn't
   // change the size. This is necessary if Quotient or Remainder is aliased
   // with LHS or RHS.
   Quotient.reallocate(BitWidth);
if (LHS.isSingleWord()) {
     return;
   }
 
   // Get some size facts about the dividend and divisor
   unsigned lhsWords = getNumWords(LHS.getActiveBits());
 
   // Check the degenerate cases
   if (lhsWords == 0) {
-    Quotient = 0;                // 0 / Y ===> 0
-    Remainder = 0;               // 0 % Y ===> 0
+    Quotient = APInt(BitWidth, 0);    // 0 / Y ===> 0
+    Remainder = 0;                    // 0 % Y ===> 0
     return;
   }
 
   if (RHS == 1) {
-    Quotient = LHS;             // X / 1 ===> X
-    Remainder = 0;              // X % 1 ===> 0
+    Quotient = LHS;                   // X / 1 ===> X
+    Remainder = 0;                    // X % 1 ===> 0
+    return;
   }
 
   if (LHS.ult(RHS)) {
-    Remainder = LHS.getZExtValue(); // X % Y ===> X, iff X < Y
-    Quotient = 0;                   // X / Y ===> 0, iff X < Y
+    Remainder = LHS.getZExtValue();   // X % Y ===> X, iff X < Y
+    Quotient = APInt(BitWidth, 0);    // X / Y ===> 0, iff X < Y
     return;
   }
 
   if (LHS == RHS) {
-    Quotient  = 1;              // X / X ===> 1
-    Remainder = 0;              // X % X ===> 0;
+    Quotient  = APInt(BitWidth, 1);   // X / X ===> 1
+    Remainder = 0;                    // X % X ===> 0;
     return;
   }
 
   // Make sure there is enough space to hold the results.
   // NOTE: This assumes that reallocate won't affect any bits if it doesn't
   // change the size. This is necessary if Quotient is aliased with LHS.
   Quotient.reallocate(BitWidth);
 

unittests/ADT/APIntTest.cpp

testDiv(-APInt{256, 9},
           -APInt{256, 1});
 
   // Multiword dividend
   testDiv(APInt{1024, 19}.shl(811),
           4356013, // one word
           APInt{1024, 1});
 }
 
+TEST(APIntTest, divrem_simple) {
+  // Test simple cases.
+  APInt A(65, 2), B(65, 2);
+  APInt Q, R;
+
+  // X / X
+  APInt::sdivrem(A, B, Q, R);
+  EXPECT_EQ(Q, APInt(65, 1));
+  EXPECT_EQ(R, APInt(65, 0));
+  APInt::udivrem(A, B, Q, R);
+  EXPECT_EQ(Q, APInt(65, 1));
+  EXPECT_EQ(R, APInt(65, 0));
+
+  // 0 / X
+  APInt O(65, 0);
+  APInt::sdivrem(O, B, Q, R);
+  EXPECT_EQ(Q, APInt(65, 0));
+  EXPECT_EQ(R, APInt(65, 0));
+  APInt::udivrem(O, B, Q, R);
+  EXPECT_EQ(Q, APInt(65, 0));
+  EXPECT_EQ(R, APInt(65, 0));
+
+  // X / 1
+  APInt I(65, 1);
+  APInt::sdivrem(A, I, Q, R);
+  EXPECT_EQ(Q, A);
+  EXPECT_EQ(R, APInt(65, 0));
+  APInt::udivrem(A, I, Q, R);
+  EXPECT_EQ(Q, A);
+  EXPECT_EQ(R, APInt(65, 0));
+}
+
 TEST(APIntTest, fromString) {
   EXPECT_EQ(APInt(32, 0), APInt(32,   "0", 2));
   EXPECT_EQ(APInt(32, 1), APInt(32,   "1", 2));
   EXPECT_EQ(APInt(32, 2), APInt(32,  "10", 2));
   EXPECT_EQ(APInt(32, 3), APInt(32,  "11", 2));
   EXPECT_EQ(APInt(32, 4), APInt(32, "100", 2));
 
   EXPECT_EQ(APInt(32, 0), APInt(32,   "+0", 2));