Add control of hex casing in APInt::toString

[thopre]

Summary

This will be used in implementing arbitrary precision support to
FileCheck's numeric variables and expressions.

[foad]

Looks fine to me.

[RKSimon]

LGTM

[lattner]

I would suggest a silly microoptimization:

static const char BothDigits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz";
const char *Digits = BothDigits+(UpperCase ? 0 : 36);

Avoids looking up two different GOT entries.

[thopre]

In D150879#4353625, @lattner wrote:

I would suggest a silly microoptimization:

static const char BothDigits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz";
const char *Digits = BothDigits+(UpperCase ? 0 : 36);

Avoids looking up two different GOT entries.

Changed and landed.

llvm/include/llvm/ADT/APInt.h

   unsigned countPopulation() const { return popcount(); }
 
   /// @}
   /// \name Conversion Functions
   /// @{
   void print(raw_ostream &OS, bool isSigned) const;
 
   /// Converts an APInt to a string and append it to Str.  Str is commonly a
-  /// SmallString.
+  /// SmallString. If Radix > 10, UpperCase determine the case of letter
+  /// digits.
   void toString(SmallVectorImpl<char> &Str, unsigned Radix, bool Signed,
-                bool formatAsCLiteral = false) const;
+                bool formatAsCLiteral = false, bool UpperCase = true) const;
 
   /// Considers the APInt to be unsigned and converts it into a string in the
   /// radix given. The radix can be 2, 8, 10 16, or 36.
   void toStringUnsigned(SmallVectorImpl<char> &Str, unsigned Radix = 10) const {
     toString(Str, Radix, false, false);
   }
 
   /// Considers the APInt to be signed and converts it into a string in the

llvm/lib/Support/APInt.cpp

for (StringRef::iterator e = str.end(); p != e; ++p) {
     // Add in the digit we just interpreted
     *this += digit;
   }
   // If its negative, put it in two's complement form
   if (isNeg)
     this->negate();
 }
 
-void APInt::toString(SmallVectorImpl<char> &Str, unsigned Radix,
-                     bool Signed, bool formatAsCLiteral) const {
+void APInt::toString(SmallVectorImpl<char> &Str, unsigned Radix, bool Signed,
+                     bool formatAsCLiteral, bool UpperCase) const {
   assert((Radix == 10 || Radix == 8 || Radix == 16 || Radix == 2 ||
           Radix == 36) &&
          "Radix should be 2, 8, 10, 16, or 36!");
 
   const char *Prefix = "";
   if (formatAsCLiteral) {
     switch (Radix) {
       case 2:
if (isZero()) {
     while (*Prefix) {
       Str.push_back(*Prefix);
       ++Prefix;
     };
     Str.push_back('0');
     return;
   }
 
-  static const char Digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  static const char BothDigits[] = "0123456789abcdefghijklmnopqrstuvwxyz"
+                                   "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  const char *Digits = BothDigits + (UpperCase ? 36 : 0);
 
   if (isSingleWord()) {
     char Buffer[65];
     char *BufPtr = std::end(Buffer);
 
     uint64_t N;
     if (!Signed) {
       N = getZExtValue();

llvm/unittests/ADT/APIntTest.cpp

TEST(APIntTest, toString) {
   EXPECT_EQ(std::string(S), "0b11111111");
   S.clear();
   APInt(8, 255, isSigned).toString(S, 8, isSigned, true);
   EXPECT_EQ(std::string(S), "0377");
   S.clear();
   APInt(8, 255, isSigned).toString(S, 10, isSigned, true);
   EXPECT_EQ(std::string(S), "255");
   S.clear();
+  APInt(8, 255, isSigned).toString(S, 16, isSigned, true, /*UpperCase=*/false);
+  EXPECT_EQ(std::string(S), "0xff");
+  S.clear();
   APInt(8, 255, isSigned).toString(S, 16, isSigned, true);
   EXPECT_EQ(std::string(S), "0xFF");
   S.clear();
   APInt(8, 255, isSigned).toString(S, 36, isSigned, false);
   EXPECT_EQ(std::string(S), "73");
   S.clear();
 
   isSigned = true;