[libc] fix shifting exact multiples of 64 in uint

[michaelrj]

Summary

The internal uint class had a bug introduced recently when optimizing
the shift routines. When calculating the value of a block, it would
shift an adjacent block by 64 - the shift amount. If the shift amount
was 0, this would be a shift of 64, which is undefined for a 64 bit
integer. This patch fixes this by adding a conditional to catch this
case.

[lntue]

libc/src/__support/UInt.h

378

Can you change it similar to the fix for shift right in https://reviews.llvm.org/D139566? I.e., move the check for shift == 0 or shift > 0 outside of the loop?

434

This is not needed as shift is guaranteed to be positive in line 426. This was actually fixed in https://reviews.llvm.org/D139566

[michaelrj]

move check for shift of 0 outside of loop for shift_left
remove redundant check in shift right

libc/src/__support/UInt.h

if constexpr (Bits == 128) {
         return;
       }
       __uint128_t tmp = __uint128_t(val[0]) + (__uint128_t(val[1]) << 64);
       tmp <<= s;
       val[0] = uint64_t(tmp);
       val[1] = uint64_t(tmp >> 64);
       return;
     }
-#endif                           // __SIZEOF_INT128__
+#endif // __SIZEOF_INT128__
     if (unlikely(s == 0))
       return;
 
     const size_t drop = s / 64;  // Number of words to drop
     const size_t shift = s % 64; // Bits to shift in the remaining words.
     size_t i = WordCount;
 
     if (drop < WordCount) {
       i = WordCount - 1;
-      size_t j = WordCount - 1 - drop;
-      for (; j > 0; --i, --j) {
+      if (shift > 0) {
+        for (size_t j = WordCount - 1 - drop; j > 0; --i, --j) {
           val[i] = (val[j] << shift) | (val[j - 1] >> (64 - shift));
         }
         val[i] = val[0] << shift;
+      } else {
+        for (size_t j = WordCount - 1 - drop; j > 0; --i, --j) {
+          val[i] = val[j];
+        }
+        val[i] = val[0];
+      }
     }
 
     for (size_t j = 0; j < i; ++j) {
       val[j] = 0;
     }
   }
 
   constexpr UInt<Bits> operator<<(size_t s) const {
#endif // __SIZEOF_INT128__
     const size_t shift = s % 64; // Bit shift in the remaining words.
 
     size_t i = 0;
 
     if (drop < WordCount) {
       if (shift > 0) {
         for (size_t j = drop; j < WordCount - 1; ++i, ++j) {
           val[i] = (val[j] >> shift) | (val[j + 1] << (64 - shift));
         }
         val[i] = val[WordCount - 1] >> shift;
         ++i;
       } else {
         for (size_t j = drop; j < WordCount; ++i, ++j) {
           val[i] = val[j];
         }
       }
     }

libc/test/src/__support/uint_test.cpp

TEST(LlvmLibcUIntClassTest, ShiftLeftTests) {
   EXPECT_EQ((val2 << 96), result4);
 
   LL_UInt128 result5({0, 0x2468ace000000000});
   EXPECT_EQ((val2 << 100), result5);
 
   LL_UInt128 result6({0, 0});
   EXPECT_EQ((val2 << 128), result6);
   EXPECT_EQ((val2 << 256), result6);
+
+  LL_UInt192 val3({1, 0, 0});
+  LL_UInt192 result7({0, 1, 0});
+  EXPECT_EQ((val3 << 64), result7);
 }
 
 TEST(LlvmLibcUIntClassTest, ShiftRightTests) {
   LL_UInt128 val1(0x0123456789abcdef);
   LL_UInt128 result1(0x00123456789abcde);
   EXPECT_EQ((val1 >> 4), result1);
 
   LL_UInt128 val2({0x13579bdf02468ace, 0x123456789abcdef0});
TEST(LlvmLibcUIntClassTest, ShiftRightTests) {
   EXPECT_EQ((v1 >> 64), r1);
 
   LL_UInt192 v2({0x1111222233334444, 0x5555666677778888, 0xaaaabbbbccccdddd});
   LL_UInt192 r2({0x5555666677778888, 0xaaaabbbbccccdddd, 0});
   LL_UInt192 r3({0xaaaabbbbccccdddd, 0, 0});
   EXPECT_EQ((v2 >> 64), r2);
   EXPECT_EQ((v2 >> 128), r3);
   EXPECT_EQ((r2 >> 64), r3);
+
+  LL_UInt192 val3({0, 0, 1});
+  LL_UInt192 result7({0, 1, 0});
+  EXPECT_EQ((val3 >> 64), result7);
 }
 
 TEST(LlvmLibcUIntClassTest, AndTests) {
   LL_UInt128 base({0xffff00000000ffff, 0xffffffff00000000});
   LL_UInt128 val128({0xf0f0f0f00f0f0f0f, 0xff00ff0000ff00ff});
   uint64_t val64 = 0xf0f0f0f00f0f0f0f;
   int val32 = 0x0f0f0f0f;
   LL_UInt128 result128({0xf0f0000000000f0f, 0xff00ff0000000000});