[StringRef] Make getAsInteger a tad more robust.

[zturner]

Summary

Previously if the auto sense radix was specified as part of
the string and you *also* explicitly specified the radix value
to the function, we would fail.

This patch allows the radix prefix to be properly consumed even
in non-auto-sense mode.

In doing so, I learned that there was zero test coverage for
getAsInteger with an explicitly specified radix, so this patch
also rectifies that since I needed to add tests to make sure
this patch works.

[amccarth]

llvm/lib/Support/StringRef.cpp

442

You could avoid the duplication of the prefix logic by always calling GetAutoSenseRadix:

const auto SensedRadix = GetAutoSenseRadix(Str);
if (Radix == 0)
  Radix = SensedRadix ;
assert(Radix == SensedRadix);

[zturner]

llvm/lib/Support/StringRef.cpp

442

int N;
StringRef("012345").getAsInteger(10, N);

should work, but auto-sense will detect this as base 8.

llvm/lib/Support/StringRef.cpp

 static unsigned GetAutoSenseRadix(StringRef &Str) {
   if (Str.empty())
     return 10;
 
   if (Str.startswith("0x") || Str.startswith("0X")) {
     Str = Str.substr(2);
     return 16;
   }
-  
   if (Str.startswith("0b") || Str.startswith("0B")) {
     Str = Str.substr(2);
     return 2;
   }
 
   if (Str.startswith("0o")) {
     Str = Str.substr(2);
     return 8;
   }
 
   if (Str[0] == '0' && Str.size() > 1 && ascii_isdigit(Str[1])) {
     Str = Str.substr(1);
     return 8;
   }
 
   return 10;
 }
 
 bool llvm::consumeUnsignedInteger(StringRef &Str, unsigned Radix,
                                   unsigned long long &Result) {
   // Autosense radix if not specified.
   if (Radix == 0)
     Radix = GetAutoSenseRadix(Str);
-
+  else {
+    // Even if the radix is specified, there might still be a radix prefix.
+    if (Radix == 2 && Str.startswith_lower("0b"))
+      Str = Str.drop_front(2);
+    else if (Radix == 8) {
+      if (Str.startswith("0o"))
+        Str = Str.drop_front(2);
+      else if (Str[0] == '0' && Str.size() > 1 && ascii_isdigit(Str[1]))
+        Str = Str.drop_front();
+    } else if (Radix == 16 && Str.startswith_lower("0x"))
+      Str = Str.drop_front(2);
+  }
   // Empty strings (after the radix autosense) are invalid.
   if (Str.empty()) return true;
 
   // Parse all the bytes of the string given this radix.  Watch for overflow.
   StringRef Str2 = Str;
   Result = 0;
   while (!Str2.empty()) {
     unsigned CharVal;

llvm/unittests/ADT/StringRefTest.cpp

EXPECT_EQ(hash_value(std::string("hello world ")),
             hash_value(StringRef("hello world ")));
   EXPECT_EQ(H, hash_value(StringRef("hello world\0")));
   EXPECT_NE(hash_value(std::string("ello worl")),
             hash_value(StringRef("hello world").slice(1, -1)));
 }
 
 struct UnsignedPair {
   const char *Str;
+  unsigned Radix;
   uint64_t Expected;
-} Unsigned[] =
-  { {"0", 0}
-  , {"255", 255}
-  , {"256", 256}
-  , {"65535", 65535}
-  , {"65536", 65536}
-  , {"4294967295", 4294967295ULL}
-  , {"4294967296", 4294967296ULL}
-  , {"18446744073709551615", 18446744073709551615ULL}
-  , {"042", 34}
-  , {"0x42", 66}
-  , {"0b101010", 42}
-  };
+} Unsigned[] = {{"0", 10, 0},
+                {"255", 10, 255},
+                {"256", 10, 256},
+                {"65535", 10, 65535},
+                {"65536", 10, 65536},
+                {"4294967295", 10, 4294967295ULL},
+                {"4294967296", 10, 4294967296ULL},
+                {"18446744073709551615", 10, 18446744073709551615ULL},
+                {"042", 8, 34},
+                {"0x42", 16, 66},
+                {"0b101010", 2, 42}};
 
 struct SignedPair {
   const char *Str;
+  unsigned Radix;
   int64_t Expected;
-} Signed[] =
-  { {"0", 0}
-  , {"-0", 0}
-  , {"127", 127}
-  , {"128", 128}
-  , {"-128", -128}
-  , {"-129", -129}
-  , {"32767", 32767}
-  , {"32768", 32768}
-  , {"-32768", -32768}
-  , {"-32769", -32769}
-  , {"2147483647", 2147483647LL}
-  , {"2147483648", 2147483648LL}
-  , {"-2147483648", -2147483648LL}
-  , {"-2147483649", -2147483649LL}
-  , {"-9223372036854775808", -(9223372036854775807LL) - 1}
-  , {"042", 34}
-  , {"0x42", 66}
-  , {"0b101010", 42}
-  , {"-042", -34}
-  , {"-0x42", -66}
-  , {"-0b101010", -42}
-  };
+} Signed[] = {{"0", 10, 0},
+              {"-0", 10, 0},
+              {"127", 10, 127},
+              {"128", 10, 128},
+              {"-128", 10, -128},
+              {"-129", 10, -129},
+              {"32767", 10, 32767},
+              {"32768", 10, 32768},
+              {"-32768", 10, -32768},
+              {"-32769", 10, -32769},
+              {"2147483647", 10, 2147483647LL},
+              {"2147483648", 10, 2147483648LL},
+              {"-2147483648", 10, -2147483648LL},
+              {"-2147483649", 10, -2147483649LL},
+              {"-9223372036854775808", 10, -(9223372036854775807LL) - 1},
+              {"042", 8, 34},
+              {"0x42", 16, 66},
+              {"0b101010", 2, 42},
+              {"-042", 8, -34},
+              {"-0x42", 16, -66},
+              {"-0b101010", 2, -42}};
 
 TEST(StringRefTest, getAsInteger) {
   uint8_t U8;
   uint16_t U16;
   uint32_t U32;
   uint64_t U64;
 
   for (size_t i = 0; i < array_lengthof(Unsigned); ++i) {
-    bool U8Success = StringRef(Unsigned[i].Str).getAsInteger(0, U8);
+    for (unsigned Radix : {0u, Unsigned[i].Radix}) {
+      bool U8Success = StringRef(Unsigned[i].Str).getAsInteger(Radix, U8);
       if (static_cast<uint8_t>(Unsigned[i].Expected) == Unsigned[i].Expected) {
         ASSERT_FALSE(U8Success);
         EXPECT_EQ(U8, Unsigned[i].Expected);
       } else {
         ASSERT_TRUE(U8Success);
       }
-    bool U16Success = StringRef(Unsigned[i].Str).getAsInteger(0, U16);
+      bool U16Success = StringRef(Unsigned[i].Str).getAsInteger(Radix, U16);
       if (static_cast<uint16_t>(Unsigned[i].Expected) == Unsigned[i].Expected) {
         ASSERT_FALSE(U16Success);
         EXPECT_EQ(U16, Unsigned[i].Expected);
       } else {
         ASSERT_TRUE(U16Success);
       }
-    bool U32Success = StringRef(Unsigned[i].Str).getAsInteger(0, U32);
+      bool U32Success = StringRef(Unsigned[i].Str).getAsInteger(Radix, U32);
       if (static_cast<uint32_t>(Unsigned[i].Expected) == Unsigned[i].Expected) {
         ASSERT_FALSE(U32Success);
         EXPECT_EQ(U32, Unsigned[i].Expected);
       } else {
         ASSERT_TRUE(U32Success);
       }
-    bool U64Success = StringRef(Unsigned[i].Str).getAsInteger(0, U64);
+      bool U64Success = StringRef(Unsigned[i].Str).getAsInteger(Radix, U64);
       if (static_cast<uint64_t>(Unsigned[i].Expected) == Unsigned[i].Expected) {
         ASSERT_FALSE(U64Success);
         EXPECT_EQ(U64, Unsigned[i].Expected);
       } else {
         ASSERT_TRUE(U64Success);
       }
     }
+  }
 
   int8_t S8;
   int16_t S16;
   int32_t S32;
   int64_t S64;
 
   for (size_t i = 0; i < array_lengthof(Signed); ++i) {
-    bool S8Success = StringRef(Signed[i].Str).getAsInteger(0, S8);
+    for (unsigned Radix : {0u, Signed[i].Radix}) {
+      bool S8Success = StringRef(Signed[i].Str).getAsInteger(Radix, S8);
       if (static_cast<int8_t>(Signed[i].Expected) == Signed[i].Expected) {
         ASSERT_FALSE(S8Success);
         EXPECT_EQ(S8, Signed[i].Expected);
       } else {
         ASSERT_TRUE(S8Success);
       }
-    bool S16Success = StringRef(Signed[i].Str).getAsInteger(0, S16);
+      bool S16Success = StringRef(Signed[i].Str).getAsInteger(Radix, S16);
       if (static_cast<int16_t>(Signed[i].Expected) == Signed[i].Expected) {
         ASSERT_FALSE(S16Success);
         EXPECT_EQ(S16, Signed[i].Expected);
       } else {
         ASSERT_TRUE(S16Success);
       }
-    bool S32Success = StringRef(Signed[i].Str).getAsInteger(0, S32);
+      bool S32Success = StringRef(Signed[i].Str).getAsInteger(Radix, S32);
       if (static_cast<int32_t>(Signed[i].Expected) == Signed[i].Expected) {
         ASSERT_FALSE(S32Success);
         EXPECT_EQ(S32, Signed[i].Expected);
       } else {
         ASSERT_TRUE(S32Success);
       }
-    bool S64Success = StringRef(Signed[i].Str).getAsInteger(0, S64);
+      bool S64Success = StringRef(Signed[i].Str).getAsInteger(Radix, S64);
       if (static_cast<int64_t>(Signed[i].Expected) == Signed[i].Expected) {
         ASSERT_FALSE(S64Success);
         EXPECT_EQ(S64, Signed[i].Expected);
       } else {
         ASSERT_TRUE(S64Success);
       }
     }
   }
-
+}
 
 static const char* BadStrings[] = {
     ""                      // empty string
   , "18446744073709551617"  // value just over max
   , "123456789012345678901" // value way too large
   , "4t23v"                 // illegal decimal characters
   , "0x123W56"              // illegal hex characters
   , "0b2"                   // illegal bin characters