Teach llvm::format_hex() to support formatting without a prefix '0x'

[zturner]

Summary

Simple change, hope someone can take a look.

When you're dumping single bytes, having '0x' on the front of every byte is difficult to read and doubles the size of the output.

[majnemer]

Why not just use llvm::utohexstr?

[zturner]

In D7151#112909, @majnemer wrote:

Why not just use llvm::utohexstr?

Isn't that less efficient than just writing directly to the stream? Results in one heap allocation for every byte.

[rnk]

include/llvm/Support/Format.h

278–279 ↗

(On Diff #18687)

I'd rather have a special purpose helper than a second default value bool. format_hex_noprefix? format_noprefix_hex? format_hex_bytes?

[zturner]

include/llvm/Support/Format.h

278–279 ↗

(On Diff #18687)

I agree in principle that default values suck, but on the other hand I don't think HexPrefix is any more or less special than Upper, aside from having been implemented later. So it's inconsistent that one of the options is specified via a default argument, while another option is specified by using a different function even though there's nothing fundamentally different about the two options. Something like this would be a good time for a flags enum, but that would require updating thousands of lines of code.

Another thing is that it makes the pre-function comment showing sample inputs and outputs a little redundant now. I guess I would just copy over all 4 samples but remove the 0x from each of them?

Either way, I don't feel too strongly, so I don't mind changing it.

[zturner]

Moved the no-prefix option to a separate function. Also added a test.

llvm/trunk/include/llvm/Support/Format.h

 
 /// This is a helper class used for format_hex() and format_decimal().
 class FormattedNumber {
   uint64_t HexValue;
   int64_t DecValue;
   unsigned Width;
   bool Hex;
   bool Upper;
+  bool HexPrefix;
   friend class raw_ostream;
 public:
-    FormattedNumber(uint64_t HV, int64_t DV, unsigned W, bool H, bool U)
-      : HexValue(HV), DecValue(DV), Width(W), Hex(H), Upper(U) { }
+  FormattedNumber(uint64_t HV, int64_t DV, unsigned W, bool H, bool U,
+                  bool Prefix)
+      : HexValue(HV), DecValue(DV), Width(W), Hex(H), Upper(U),
+        HexPrefix(Prefix) {}
 };
 
 /// format_hex - Output \p N as a fixed width hexadecimal. If number will not
 /// fit in width, full number is still printed.  Examples:
-///   OS << format_hex(255, 4)        => 0xff
-///   OS << format_hex(255, 4, true)  => 0xFF
-///   OS << format_hex(255, 6)        => 0x00ff
-///   OS << format_hex(255, 2)        => 0xff
-inline FormattedNumber format_hex(uint64_t N, unsigned Width, bool Upper=false) {
+///   OS << format_hex(255, 4)              => 0xff
+///   OS << format_hex(255, 4, true)        => 0xFF
+///   OS << format_hex(255, 6)              => 0x00ff
+///   OS << format_hex(255, 2)              => 0xff
+inline FormattedNumber format_hex(uint64_t N, unsigned Width,
+                                  bool Upper = false) {
   assert(Width <= 18 && "hex width must be <= 18");
-  return FormattedNumber(N, 0, Width, true, Upper);
+  return FormattedNumber(N, 0, Width, true, Upper, true);
+}
+
+/// format_hex_no_prefix - Output \p N as a fixed width hexadecimal. Does not
+/// prepend '0x' to the outputted string.  If number will not fit in width,
+/// full number is still printed.  Examples:
+///   OS << format_hex_no_prefix(255, 4)              => ff
+///   OS << format_hex_no_prefix(255, 4, true)        => FF
+///   OS << format_hex_no_prefix(255, 6)              => 00ff
+///   OS << format_hex_no_prefix(255, 2)              => ff
+inline FormattedNumber format_hex_no_prefix(uint64_t N, unsigned Width,
+                                            bool Upper = false) {
+  assert(Width <= 18 && "hex width must be <= 18");
+  return FormattedNumber(N, 0, Width, true, Upper, false);
 }
 
 /// format_decimal - Output \p N as a right justified, fixed-width decimal. If 
 /// number will not fit in width, full number is still printed.  Examples:
 ///   OS << format_decimal(0, 5)     => "    0"
 ///   OS << format_decimal(255, 5)   => "  255"
 ///   OS << format_decimal(-1, 3)    => " -1"
 ///   OS << format_decimal(12345, 3) => "12345"
 inline FormattedNumber format_decimal(int64_t N, unsigned Width) {
-  return FormattedNumber(0, N, Width, false, false);
+  return FormattedNumber(0, N, Width, false, false, false);
 }
 
 
 } // end namespace llvm
 
 #endif

llvm/trunk/lib/Support/raw_ostream.cpp

raw_ostream &raw_ostream::operator<<(const FormattedString &FS) {
   if (!FS.RightJustify && (PadAmount > 0))
     this->indent(PadAmount);
   return *this;
 }
 
 raw_ostream &raw_ostream::operator<<(const FormattedNumber &FN) {
   if (FN.Hex) {
     unsigned Nibbles = (64 - countLeadingZeros(FN.HexValue)+3)/4;
-    unsigned Width = (FN.Width > Nibbles+2) ? FN.Width : Nibbles+2;
-        
+    unsigned PrefixChars = FN.HexPrefix ? 2 : 0;
+    unsigned Width = std::max(FN.Width, Nibbles + PrefixChars);
     char NumberBuffer[20] = "0x0000000000000000";
+    if (!FN.HexPrefix)
+      NumberBuffer[1] = '0';
     char *EndPtr = NumberBuffer+Width;
     char *CurPtr = EndPtr;
     const char A = FN.Upper ? 'A' : 'a';
     unsigned long long N = FN.HexValue;
     while (N) {
       uintptr_t x = N % 16;
       *--CurPtr = (x < 10 ? '0' + x : A + x - 10);
       N /= 16;

llvm/trunk/unittests/Support/raw_ostream_test.cpp

TEST(raw_ostreamTest, FormatHex) {
   EXPECT_EQ("0x001234",   printToString(format_hex(0x1234, 8), 8));
   EXPECT_EQ("0x00001234", printToString(format_hex(0x1234, 10), 10));
   EXPECT_EQ("0x1234",     printToString(format_hex(0x1234, 4), 6));
   EXPECT_EQ("0xff",       printToString(format_hex(255, 4), 4));
   EXPECT_EQ("0xFF",       printToString(format_hex(255, 4, true), 4));
   EXPECT_EQ("0x1",        printToString(format_hex(1, 3), 3));
   EXPECT_EQ("0x12",       printToString(format_hex(0x12, 3), 4));
   EXPECT_EQ("0x123",      printToString(format_hex(0x123, 3), 5));
+  EXPECT_EQ("FF",         printToString(format_hex_no_prefix(0xFF, 2, true), 4));
+  EXPECT_EQ("ABCD",       printToString(format_hex_no_prefix(0xABCD, 2, true), 4));
   EXPECT_EQ("0xffffffffffffffff",     
                           printToString(format_hex(UINT64_MAX, 18), 18));
   EXPECT_EQ("0x8000000000000000",     
                           printToString(format_hex((INT64_MIN), 18), 18));
 }
 
 TEST(raw_ostreamTest, FormatDecimal) {  
   EXPECT_EQ("   0",        printToString(format_decimal(0, 4), 4));