Add StringRef::consumeInteger(APInt)

[thopre]

Summary

This will be required to allow arbitrary precision support to
FileCheck's numeric variables and expressions. Note: as per
getAsInteger(), this does not support negative value. If there is
interest for that it can be added in a separate patch.

[dblaikie]

Sounds OK to me

[thopre]

Remove <64 bit APInt consumeInteger tests

[thopre]

In D150878#4361073, @thopre wrote:

Remove <64 bit APInt consumeInteger tests

These did not make sense, the whole point of consumeInteger(APInt) is to not be limited in bitsize and thus succeed. That's why unit tests were failing: they were expecting a consumeInteger failing when the expected value is bigger than 32bit.

[dblaikie]

Do you need someone to commit this for you? (if so, what name & email address would you like to be used to attribute the work?)

[thopre]

In D150878#4362820, @dblaikie wrote:

Do you need someone to commit this for you? (if so, what name & email address would you like to be used to attribute the work?)

I have commit access, thanks! I just wanted to have CI be green first since there was problem with the previous version (expecting APInt tests to fail for values < 64 bits which did not make sense).

llvm/include/llvm/ADT/StringRef.h

#endif
     ///
     /// \returns true if the string does not solely consist of a valid
     /// non-empty number in the appropriate base.
     ///
     /// APInt::fromString is superficially similar but assumes the
     /// string is well-formed in the given radix.
     bool getAsInteger(unsigned Radix, APInt &Result) const;
 
+    /// Parse the current string as an integer of the specified \p Radix.  If
+    /// \p Radix is specified as zero, this does radix autosensing using
+    /// extended C rules: 0 is octal, 0x is hex, 0b is binary.
+    ///
+    /// If the string does not begin with a number of the specified radix,
+    /// this returns true to signify the error. The string is considered
+    /// erroneous if empty.
+    /// The portion of the string representing the discovered numeric value
+    /// is removed from the beginning of the string.
+    bool consumeInteger(unsigned Radix, APInt &Result);
+
     /// Parse the current string as an IEEE double-precision floating
     /// point value.  The string must be a well-formed double.
     ///
     /// If \p AllowInexact is false, the function will fail if the string
     /// cannot be represented exactly.  Otherwise, the function only fails
     /// in case of an overflow or underflow, or an invalid floating point
     /// representation.
     bool getAsDouble(double &Result, bool AllowInexact = true) const;

llvm/lib/Support/StringRef.cpp

bool llvm::getAsSignedInteger(StringRef Str, unsigned Radix,
   if (consumeSignedInteger(Str, Radix, Result))
     return true;
 
   // For getAsSignedInteger, we require the whole string to be consumed or else
   // we consider it a failure.
   return !Str.empty();
 }
 
-bool StringRef::getAsInteger(unsigned Radix, APInt &Result) const {
+bool StringRef::consumeInteger(unsigned Radix, APInt &Result) {
   StringRef Str = *this;
 
   // Autosense radix if not specified.
   if (Radix == 0)
     Radix = GetAutoSenseRadix(Str);
 
   assert(Radix > 1 && Radix <= 36);
 
   // Empty strings (after the radix autosense) are invalid.
   if (Str.empty()) return true;
 
   // Skip leading zeroes.  This can be a significant improvement if
   // it means we don't need > 64 bits.
   while (!Str.empty() && Str.front() == '0')
     Str = Str.substr(1);
 
   // If it was nothing but zeroes....
   if (Str.empty()) {
     Result = APInt(64, 0);
+    *this = Str;
     return false;
   }
 
   // (Over-)estimate the required number of bits.
   unsigned Log2Radix = 0;
   while ((1U << Log2Radix) < Radix) Log2Radix++;
   bool IsPowerOf2Radix = ((1U << Log2Radix) == Radix);
 
while (!Str.empty()) {
     unsigned CharVal;
     if (Str[0] >= '0' && Str[0] <= '9')
       CharVal = Str[0]-'0';
     else if (Str[0] >= 'a' && Str[0] <= 'z')
       CharVal = Str[0]-'a'+10;
     else if (Str[0] >= 'A' && Str[0] <= 'Z')
       CharVal = Str[0]-'A'+10;
     else
-      return true;
+      break;
 
     // If the parsed value is larger than the integer radix, the string is
     // invalid.
     if (CharVal >= Radix)
-      return true;
+      break;
 
     // Add in this character.
     if (IsPowerOf2Radix) {
       Result <<= Log2Radix;
       Result |= CharVal;
     } else {
       Result *= RadixAP;
       CharAP = CharVal;
       Result += CharAP;
     }
 
     Str = Str.substr(1);
   }
 
+  // We consider the operation a failure if no characters were consumed
+  // successfully.
+  if (size() == Str.size())
+    return true;
+
+  *this = Str;
   return false;
 }
 
+bool StringRef::getAsInteger(unsigned Radix, APInt &Result) const {
+  StringRef Str = *this;
+  if (Str.consumeInteger(Radix, Result))
+    return true;
+
+  // For getAsInteger, we require the whole string to be consumed or else we
+  // consider it a failure.
+  return !Str.empty();
+}
+
 bool StringRef::getAsDouble(double &Result, bool AllowInexact) const {
   APFloat F(0.0);
   auto StatusOrErr = F.convertFromString(*this, APFloat::rmNearestTiesToEven);
   if (errorToBool(StatusOrErr.takeError()))
     return true;
 
   APFloat::opStatus Status = *StatusOrErr;
   if (Status != APFloat::opOK) {

llvm/unittests/ADT/StringRefTest.cpp

const char *Leftover;
     {"-0b101010", -42, ""},
     {"-0b101010-1", -42, "-1"}};
 
 TEST(StringRefTest, consumeIntegerUnsigned) {
   uint8_t U8;
   uint16_t U16;
   uint32_t U32;
   uint64_t U64;
+  APInt U;
 
   for (size_t i = 0; i < std::size(ConsumeUnsigned); ++i) {
     StringRef Str = ConsumeUnsigned[i].Str;
     bool U8Success = Str.consumeInteger(0, U8);
     if (static_cast<uint8_t>(ConsumeUnsigned[i].Expected) ==
         ConsumeUnsigned[i].Expected) {
       ASSERT_FALSE(U8Success);
       EXPECT_EQ(U8, ConsumeUnsigned[i].Expected);
       EXPECT_EQ(Str, ConsumeUnsigned[i].Leftover);
     } else {
       ASSERT_TRUE(U8Success);
     }
 
     Str = ConsumeUnsigned[i].Str;
+    U8Success = Str.consumeInteger(0, U);
+    if (static_cast<uint8_t>(ConsumeUnsigned[i].Expected) ==
+        ConsumeUnsigned[i].Expected) {
+      ASSERT_FALSE(U8Success);
+      EXPECT_EQ(U.getZExtValue(), ConsumeUnsigned[i].Expected);
+      EXPECT_EQ(Str, ConsumeUnsigned[i].Leftover);
+    } else {
+      ASSERT_TRUE(U8Success);
+    }
+
+    Str = ConsumeUnsigned[i].Str;
     bool U16Success = Str.consumeInteger(0, U16);
     if (static_cast<uint16_t>(ConsumeUnsigned[i].Expected) ==
         ConsumeUnsigned[i].Expected) {
       ASSERT_FALSE(U16Success);
       EXPECT_EQ(U16, ConsumeUnsigned[i].Expected);
       EXPECT_EQ(Str, ConsumeUnsigned[i].Leftover);
     } else {
       ASSERT_TRUE(U16Success);
     }
 
     Str = ConsumeUnsigned[i].Str;
+    U16Success = Str.consumeInteger(0, U);
+    if (static_cast<uint16_t>(ConsumeUnsigned[i].Expected) ==
+        ConsumeUnsigned[i].Expected) {
+      ASSERT_FALSE(U16Success);
+      EXPECT_EQ(U.getZExtValue(), ConsumeUnsigned[i].Expected);
+      EXPECT_EQ(Str, ConsumeUnsigned[i].Leftover);
+    } else {
+      ASSERT_TRUE(U16Success);
+    }
+
+    Str = ConsumeUnsigned[i].Str;
     bool U32Success = Str.consumeInteger(0, U32);
     if (static_cast<uint32_t>(ConsumeUnsigned[i].Expected) ==
         ConsumeUnsigned[i].Expected) {
       ASSERT_FALSE(U32Success);
       EXPECT_EQ(U32, ConsumeUnsigned[i].Expected);
       EXPECT_EQ(Str, ConsumeUnsigned[i].Leftover);
     } else {
       ASSERT_TRUE(U32Success);
     }
 
     Str = ConsumeUnsigned[i].Str;
+    U32Success = Str.consumeInteger(0, U);
+    if (static_cast<uint32_t>(ConsumeUnsigned[i].Expected) ==
+        ConsumeUnsigned[i].Expected) {
+      ASSERT_FALSE(U32Success);
+      EXPECT_EQ(U.getZExtValue(), ConsumeUnsigned[i].Expected);
+      EXPECT_EQ(Str, ConsumeUnsigned[i].Leftover);
+    } else {
+      ASSERT_TRUE(U32Success);
+    }
+
+    Str = ConsumeUnsigned[i].Str;
     bool U64Success = Str.consumeInteger(0, U64);
     ASSERT_FALSE(U64Success);
     EXPECT_EQ(U64, ConsumeUnsigned[i].Expected);
     EXPECT_EQ(Str, ConsumeUnsigned[i].Leftover);
+
+    Str = ConsumeUnsigned[i].Str;
+    U64Success = Str.consumeInteger(0, U);
+    ASSERT_FALSE(U64Success);
+    EXPECT_EQ(U.getZExtValue(), ConsumeUnsigned[i].Expected);
+    EXPECT_EQ(Str, ConsumeUnsigned[i].Leftover);
   }
 }
 
 TEST(StringRefTest, consumeIntegerSigned) {
   int8_t S8;
   int16_t S16;
   int32_t S32;
   int64_t S64;