Try to make ScopedPrinter use the new binary blob formatter

[zturner]

Summary

ScopedPrinter was already using its own algorithm to format binary blob data. With the new method added by clayborg, I wanted to get down to a single implementation.

In the process of doing this, I needed to update the code a little bit to support some things that ScopedPrinter needed to do. Here are the material changes from the previous implementation:

1. Changed name from format_hex_bytes to format_binary. I felt format_hex_bytes was too similar to format_hex.
2. Added the ability to offset each line of the binary blob by an initial offset.
3. Fixed a bug in the implementation where we were calling the equivalent of isprint((char)Byte), which can cause the argument to isprint() to be negative, which is undefined behavior.
4. Got a little smarter about how wide to print the offset field. Previously we were just using a full 8 bytes for the offset field, but with this patch I calculate the maximum offset value we will need to print, determine how many nibbles are needed to print that value, and then align all offset values to that width.
5. Remove the 0x prefix from the offset. I could have added an option to choose whether we want the prefix, and if anyone really needs that I can add it back. I removed it because already have a lot of tests that will fail if the offset is there, and keeping the API simple seems desirable if nobody really needs that functionality.
6. Made a few things more idiomatic / LLVMish. For example, None instead of a default constructed Optional<uint64_t>(), remove null checking from unit test helper functions (pointless since we control all entry points into the function), changing function signatures to accept ArrayRef instead of const void * and length.

[clayborg]

See inlined comments. Mostly renaming, layout and argument order stuff.

include/llvm/Support/Format.h

206 ↗

(On Diff #77400)

Binary sounds like a 0x12 hex byte would be displayed as 0b00010010. How about FormattedBytes?

209 ↗

(On Diff #77400)

This will align better if you move it after FirstByteOffset.

220 ↗

(On Diff #77400)

FormattedBytes?

230 ↗

(On Diff #77400)

format_bytes?

231 ↗

(On Diff #77400)

I would vote to move this argument after the FirstByteOffset and possibly past NumPerLine and ByteGroupSize? I would think indent level isn't going to be changed to non-zero many by that many clients.

241 ↗

(On Diff #77400)

format_bytes_with_ascii?

include/llvm/Support/raw_ostream.h

26 ↗

(On Diff #77400)

FormatedBytes?

227 ↗

(On Diff #77400)

FormatedBytes

unittests/Support/raw_ostream_test.cpp

184 ↗

(On Diff #77400)

format_bytes_str?

195 ↗

(On Diff #77400)

format_bytes_with_ascii?

[zturner]

Updated with Clayborg's suggestions

[clayborg]

Looks good.

lib/Support/raw_ostream.cpp

355 ↗

(On Diff #77508)

One thing that I was wondering is can we add an operator to the FormattedBytes class:

class FormattedBytes {
public:
    raw_ostream &operator<<(raw_ostream &s);
};

And avoid this code being in raw_ostream.cpp? Seems wrong to put the implementation for dumping FormattedBytes into raw_ostream.cpp. Doesn't need to be done with this patch, but I found this not to be very C++.

[zturner]

lib/Support/raw_ostream.cpp

355 ↗

(On Diff #77508)

You might be interested in D25587. My long term goal is to move away from all these overloaded operators entirely and be able to use printf-style formatting for everything. You can imagine writing OS << formatv("Bytes (Length={0}): ({1})", Data.size(), fmt_bytes(Data)), for example.

When that happens, we'll be able to isolate the formatting code to more appropriate places.

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

 ///   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, false);
 }
 
-class FormattedHexBytes {
-  llvm::ArrayRef<uint8_t> Bytes;
-  // Display offsets for each line if FirstByteOffset has a value.
-  llvm::Optional<uint64_t> FirstByteOffset;
+class FormattedBytes {
+  ArrayRef<uint8_t> Bytes;
+
+  // If not None, display offsets for each line relative to starting value.
+  Optional<uint64_t> FirstByteOffset;
+  uint32_t IndentLevel;  // Number of characters to indent each line.
   uint32_t NumPerLine;   // Number of bytes to show per line.
   uint8_t ByteGroupSize; // How many hex bytes are grouped without spaces
   bool Upper;            // Show offset and hex bytes as upper case.
   bool ASCII;            // Show the ASCII bytes for the hex bytes to the right.
   friend class raw_ostream;
 
 public:
-  FormattedHexBytes(llvm::ArrayRef<uint8_t> B, llvm::Optional<uint64_t> O,
-                    uint32_t NPL, uint8_t BGS, bool U, bool A)
-      : Bytes(B), FirstByteOffset(O), NumPerLine(NPL), ByteGroupSize(BGS),
-        Upper(U), ASCII(A) {}
+  FormattedBytes(ArrayRef<uint8_t> B, uint32_t IL, Optional<uint64_t> O,
+      : Bytes(B), IndentLevel(IL), FirstByteOffset(O), NumPerLine(NPL),
+        ByteGroupSize(BGS), Upper(U), ASCII(A) {
+
+    if (ByteGroupSize > NumPerLine)
+      ByteGroupSize = NumPerLine;
+  }
 };
 
-inline FormattedHexBytes format_hex_bytes(
-    llvm::ArrayRef<uint8_t> Bytes,
-    llvm::Optional<uint64_t> FirstByteOffset = llvm::Optional<uint64_t>(),
-    uint32_t NumPerLine = 16, uint8_t ByteGroupSize = 4) {
-  return FormattedHexBytes(Bytes, FirstByteOffset, NumPerLine, ByteGroupSize,
-                           false /*Upper*/, false /*ASCII*/);
-}
-
-inline FormattedHexBytes format_hex_bytes_with_ascii(
-    llvm::ArrayRef<uint8_t> Bytes,
-    llvm::Optional<uint64_t> FirstByteOffset = llvm::Optional<uint64_t>(),
-    uint32_t NumPerLine = 16, uint8_t ByteGroupSize = 4) {
-  return FormattedHexBytes(Bytes, FirstByteOffset, NumPerLine, ByteGroupSize,
-                           false /*Upper*/, true /*ASCII*/);
+inline FormattedBytes
+format_bytes(ArrayRef<uint8_t> Bytes, Optional<uint64_t> FirstByteOffset = None,
+             uint32_t NumPerLine = 16, uint8_t ByteGroupSize = 4,
+             uint32_t IndentLevel = 0, bool Upper = false) {
+  return FormattedBytes(Bytes, IndentLevel, FirstByteOffset, NumPerLine,
+                        ByteGroupSize, Upper, false);
+}
+
+inline FormattedBytes
+format_bytes_with_ascii(ArrayRef<uint8_t> Bytes,
+                        Optional<uint64_t> FirstByteOffset = None,
+                        uint32_t NumPerLine = 16, uint8_t ByteGroupSize = 4,
+                        uint32_t IndentLevel = 0, bool Upper = false) {
+  return FormattedBytes(Bytes, IndentLevel, FirstByteOffset, NumPerLine,
+                        ByteGroupSize, Upper, true);
 }
 
 } // end namespace llvm
 
 #endif

llvm/trunk/include/llvm/Support/raw_ostream.h

 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/DataTypes.h"
 #include <system_error>
 
 namespace llvm {
 class format_object_base;
 class FormattedString;
 class FormattedNumber;
-class FormattedHexBytes;
+class FormattedBytes;
 template <typename T> class SmallVectorImpl;
 
 namespace sys {
 namespace fs {
 enum OpenFlags : unsigned;
 }
 }
 
public:
   raw_ostream &operator<<(const format_object_base &Fmt);
 
   // Formatted output, see the leftJustify() function in Support/Format.h.
   raw_ostream &operator<<(const FormattedString &);
 
   // Formatted output, see the formatHex() function in Support/Format.h.
   raw_ostream &operator<<(const FormattedNumber &);
 
-  // Formatted output, see the formatHex() function in Support/Format.h.
-  raw_ostream &operator<<(const FormattedHexBytes &);
+  // Formatted output, see the format_bytes() function in Support/Format.h.
+  raw_ostream &operator<<(const FormattedBytes &);
 
   /// indent - Insert 'NumSpaces' spaces.
   raw_ostream &indent(unsigned NumSpaces);
 
   /// Changes the foreground color of text that will be output from this point
   /// forward.
   /// @param Color ANSI color to use, the special SAVEDCOLOR can be used to
   /// change only the bold attribute, and keep colors untouched

llvm/trunk/lib/Support/ScopedPrinter.cpp

 
 void ScopedPrinter::printBinaryImpl(StringRef Label, StringRef Str,
                                     ArrayRef<uint8_t> Data, bool Block) {
   if (Data.size() > 16)
     Block = true;
 
   if (Block) {
     startLine() << Label;
-    if (Str.size() > 0)
+    if (!Str.empty())
       OS << ": " << Str;
     OS << " (\n";
-    for (size_t addr = 0, end = Data.size(); addr < end; addr += 16) {
-      startLine() << format("  %04" PRIX64 ": ", uint64_t(addr));
-      // Dump line of hex.
-      for (size_t i = 0; i < 16; ++i) {
-        if (i != 0 && i % 4 == 0)
-          OS << ' ';
-        if (addr + i < end)
-          OS << hexdigit((Data[addr + i] >> 4) & 0xF, false)
-             << hexdigit(Data[addr + i] & 0xF, false);
-        else
-          OS << "  ";
-      }
-      // Print ascii.
-      OS << "  |";
-      for (std::size_t i = 0; i < 16 && addr + i < end; ++i) {
-        if (std::isprint(Data[addr + i] & 0xFF))
-          OS << Data[addr + i];
-        else
-          OS << ".";
-      }
-      OS << "|\n";
-    }
-
+    if (!Data.empty())
+      OS << format_bytes_with_ascii(Data, 0, 16, 4, (IndentLevel + 1) * 2, true)
+         << "\n";
     startLine() << ")\n";
   } else {
     startLine() << Label << ":";
-    if (Str.size() > 0)
+    if (!Str.empty())
       OS << " " << Str;
-    OS << " (";
-    for (size_t i = 0; i < Data.size(); ++i) {
-      if (i > 0)
-        OS << " ";
-
-      OS << format("%02X", static_cast<int>(Data[i]));
-    }
-    OS << ")\n";
+    OS << " (" << format_bytes(Data, None, Data.size(), 1, 0, true) << ")\n";
   }
 }
 
 } // namespace llvm

llvm/trunk/lib/Support/raw_ostream.cpp

if (FN.Hex) {
     llvm::write_integer(Stream, FN.DecValue, IntegerStyle::Integer);
     if (Buffer.size() < FN.Width)
       indent(FN.Width - Buffer.size());
     (*this) << Buffer;
   }
   return *this;
 }
 
-raw_ostream &raw_ostream::operator<<(const FormattedHexBytes &FB) {
+raw_ostream &raw_ostream::operator<<(const FormattedBytes &FB) {
+  if (FB.Bytes.empty())
+    return *this;
+
   size_t LineIndex = 0;
-  const size_t Size = FB.Bytes.size();
-  HexPrintStyle OffsetStyle =
-      FB.Upper ? HexPrintStyle::PrefixUpper : HexPrintStyle::PrefixLower;
-  HexPrintStyle ByteStyle =
-      FB.Upper ? HexPrintStyle::Upper : HexPrintStyle::Lower;
-  while (LineIndex < Size) {
+  auto Bytes = FB.Bytes;
+  const size_t Size = Bytes.size();
+  HexPrintStyle HPS = FB.Upper ? HexPrintStyle::Upper : HexPrintStyle::Lower;
+  uint64_t OffsetWidth = 0;
+  if (FB.FirstByteOffset.hasValue()) {
+    // Figure out how many nibbles are needed to print the largest offset
+    // represented by this data set, so that we can align the offset field
+    // to the right width.
+    size_t Lines = Size / FB.NumPerLine;
+    uint64_t MaxOffset = *FB.FirstByteOffset + Lines * FB.NumPerLine;
+    unsigned Power = 0;
+    if (MaxOffset > 0)
+      Power = llvm::Log2_64_Ceil(MaxOffset);
+    OffsetWidth = std::max(4ULL, llvm::alignTo(Power, 4) / 4);
+  }
+
+  // The width of a block of data including all spaces for group separators.
+  unsigned NumByteGroups =
+      alignTo(FB.NumPerLine, FB.ByteGroupSize) / FB.ByteGroupSize;
+  unsigned BlockCharWidth = FB.NumPerLine * 2 + NumByteGroups - 1;
+
+  while (!Bytes.empty()) {
+    indent(FB.IndentLevel);
+
     if (FB.FirstByteOffset.hasValue()) {
       uint64_t Offset = FB.FirstByteOffset.getValue();
-      llvm::write_hex(*this, Offset + LineIndex, OffsetStyle,
-                      sizeof(Offset) * 2 + 2);
+      llvm::write_hex(*this, Offset + LineIndex, HPS, OffsetWidth);
       *this << ": ";
     }
-    // Print the hex bytes for this line
-    uint32_t I = 0;
-    for (I = 0; I < FB.NumPerLine; ++I) {
-      size_t Index = LineIndex + I;
-      if (Index >= Size)
-        break;
-      if (I && (I % FB.ByteGroupSize) == 0)
+
+    auto Line = Bytes.take_front(FB.NumPerLine);
+
+    size_t CharsPrinted = 0;
+    // Print the hex bytes for this line in groups
+    for (size_t I = 0; I < Line.size(); ++I, CharsPrinted += 2) {
+      if (I && (I % FB.ByteGroupSize) == 0) {
+        ++CharsPrinted;
         *this << " ";
-      llvm::write_hex(*this, FB.Bytes[Index], ByteStyle, 2);
       }
-    uint32_t BytesDisplayed = I;
+      llvm::write_hex(*this, Line[I], HPS, 2);
+    }
+
     if (FB.ASCII) {
       // Print any spaces needed for any bytes that we didn't print on this
       // line so that the ASCII bytes are correctly aligned.
-      for (; I < FB.NumPerLine; ++I) {
-        if (I && (I % FB.ByteGroupSize) == 0)
-          indent(3);
-        else
-          indent(2);
-      }
-      *this << "  |";
+      assert(BlockCharWidth >= CharsPrinted);
+      indent(BlockCharWidth - CharsPrinted + 2);
+      *this << "|";
+
       // Print the ASCII char values for each byte on this line
-      for (I = 0; I < FB.NumPerLine; ++I) {
-        size_t Index = LineIndex + I;
-        if (Index >= Size)
-          break;
-        char ch = (char)FB.Bytes[Index];
-        if (isprint(ch))
-          *this << ch;
+      for (uint8_t Byte : Line) {
+        if (isprint(Byte))
+          *this << static_cast<char>(Byte);
         else
           *this << '.';
       }
       *this << '|';
     }
-    LineIndex += BytesDisplayed;
+
+    Bytes = Bytes.drop_front(Line.size());
+    LineIndex += Line.size();
     if (LineIndex < Size)
       *this << '\n';
   }
   return *this;
 }
 
 /// indent - Insert 'NumSpaces' spaces.
 raw_ostream &raw_ostream::indent(unsigned NumSpaces) {

llvm/trunk/unittests/Support/raw_ostream_test.cpp

TEST(raw_ostreamTest, FormatDecimal) {
   EXPECT_EQ("    -1",      printToString(format_decimal(-1, 6), 6));
   EXPECT_EQ("1234567890",  printToString(format_decimal(1234567890, 10), 10));
   EXPECT_EQ("  9223372036854775807", 
                           printToString(format_decimal(INT64_MAX, 21), 21));
   EXPECT_EQ(" -9223372036854775808", 
                           printToString(format_decimal(INT64_MIN, 21), 21));
 }
 
-std::string
-format_hex_bytes(const void *P, size_t N,
-                 llvm::Optional<uint64_t> Offset = llvm::Optional<uint64_t>(),
-                 uint32_t NumPerLine = 16, uint8_t ByteGroupSize = 4) {
+static std::string formatted_bytes_str(ArrayRef<uint8_t> Bytes,
+                                       llvm::Optional<uint64_t> Offset = None,
+                                       uint32_t NumPerLine = 16,
+                                       uint8_t ByteGroupSize = 4) {
   std::string S;
-  if (P && N) {
-    llvm::raw_string_ostream Str(S);
-    Str << llvm::format_hex_bytes(
-        llvm::ArrayRef<uint8_t>(static_cast<const uint8_t *>(P), N), Offset,
-        NumPerLine, ByteGroupSize);
-    Str.flush();
-  }
+  raw_string_ostream Str(S);
+  Str << format_bytes(Bytes, Offset, NumPerLine, ByteGroupSize);
   return S;
 }
 
-std::string format_hex_bytes_with_ascii(
-    const void *P, size_t N,
-    llvm::Optional<uint64_t> Offset = llvm::Optional<uint64_t>(),
-    uint32_t NumPerLine = 16, uint8_t ByteGroupSize = 4) {
+static std::string format_bytes_with_ascii_str(ArrayRef<uint8_t> Bytes,
+                                               Optional<uint64_t> Offset = None,
+                                               uint32_t NumPerLine = 16,
+                                               uint8_t ByteGroupSize = 4) {
   std::string S;
-  if (P && N) {
-    llvm::raw_string_ostream Str(S);
-    Str << llvm::format_hex_bytes_with_ascii(
-        llvm::ArrayRef<uint8_t>(static_cast<const uint8_t *>(P), N), Offset,
-        NumPerLine, ByteGroupSize);
-    Str.flush();
-  }
+  raw_string_ostream Str(S);
+  Str << format_bytes_with_ascii(Bytes, Offset, NumPerLine, ByteGroupSize);
   return S;
 }
 
 TEST(raw_ostreamTest, FormattedHexBytes) {
-  char b[] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
-              'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x',
-              'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};
-  // Test raw bytes
-  const llvm::Optional<uint64_t> InvalidOffset;
+  std::vector<uint8_t> Buf = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
+                              'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
+                              's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0',
+                              '1', '2', '3', '4', '5', '6', '7', '8', '9'};
+  ArrayRef<uint8_t> B(Buf);
+
   // Test invalid input.
-  EXPECT_EQ("", format_hex_bytes(nullptr, 0));
-  EXPECT_EQ("", format_hex_bytes(b, 0));
-  EXPECT_EQ("", format_hex_bytes(nullptr, 16));
+  EXPECT_EQ("", formatted_bytes_str(ArrayRef<uint8_t>()));
+  EXPECT_EQ("", format_bytes_with_ascii_str(ArrayRef<uint8_t>()));
   //----------------------------------------------------------------------
   // Test hex byte output with the default 4 byte groups
   //----------------------------------------------------------------------
-  EXPECT_EQ("61", format_hex_bytes(b, 1));
-  EXPECT_EQ("61626364 65", format_hex_bytes(b, 5));
+  EXPECT_EQ("61", formatted_bytes_str(B.take_front()));
+  EXPECT_EQ("61626364 65", formatted_bytes_str(B.take_front(5)));
   // Test that 16 bytes get written to a line correctly.
-  EXPECT_EQ("61626364 65666768 696a6b6c 6d6e6f70", format_hex_bytes(b, 16));
+  EXPECT_EQ("61626364 65666768 696a6b6c 6d6e6f70",
+            formatted_bytes_str(B.take_front(16)));
   // Test raw bytes with default 16 bytes per line wrapping.
-  EXPECT_EQ("61626364 65666768 696a6b6c 6d6e6f70\n71", format_hex_bytes(b, 17));
+  EXPECT_EQ("61626364 65666768 696a6b6c 6d6e6f70\n71",
+            formatted_bytes_str(B.take_front(17)));
   // Test raw bytes with 1 bytes per line wrapping.
-  EXPECT_EQ("61\n62\n63\n64\n65\n66", format_hex_bytes(b, 6, InvalidOffset, 1));
+  EXPECT_EQ("61\n62\n63\n64\n65\n66",
+            formatted_bytes_str(B.take_front(6), None, 1));
   // Test raw bytes with 7 bytes per line wrapping.
   EXPECT_EQ("61626364 656667\n68696a6b 6c6d6e\n6f7071",
-            format_hex_bytes(b, 17, InvalidOffset, 7));
+            formatted_bytes_str(B.take_front(17), None, 7));
   // Test raw bytes with 8 bytes per line wrapping.
   EXPECT_EQ("61626364 65666768\n696a6b6c 6d6e6f70\n71",
-            format_hex_bytes(b, 17, InvalidOffset, 8));
+            formatted_bytes_str(B.take_front(17), None, 8));
   //----------------------------------------------------------------------
   // Test hex byte output with the 1 byte groups
   //----------------------------------------------------------------------
-  EXPECT_EQ("61 62 63 64 65", format_hex_bytes(b, 5, InvalidOffset, 16, 1));
+  EXPECT_EQ("61 62 63 64 65",
+            formatted_bytes_str(B.take_front(5), None, 16, 1));
   // Test that 16 bytes get written to a line correctly.
   EXPECT_EQ("61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f 70",
-            format_hex_bytes(b, 16, InvalidOffset, 16, 1));
+            formatted_bytes_str(B.take_front(16), None, 16, 1));
   // Test raw bytes with default 16 bytes per line wrapping.
   EXPECT_EQ("61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f 70\n71",
-            format_hex_bytes(b, 17, InvalidOffset, 16, 1));
+            formatted_bytes_str(B.take_front(17), None, 16, 1));
   // Test raw bytes with 7 bytes per line wrapping.
   EXPECT_EQ("61 62 63 64 65 66 67\n68 69 6a 6b 6c 6d 6e\n6f 70 71",
-            format_hex_bytes(b, 17, InvalidOffset, 7, 1));
+            formatted_bytes_str(B.take_front(17), None, 7, 1));
   // Test raw bytes with 8 bytes per line wrapping.
   EXPECT_EQ("61 62 63 64 65 66 67 68\n69 6a 6b 6c 6d 6e 6f 70\n71",
-            format_hex_bytes(b, 17, InvalidOffset, 8, 1));
+            formatted_bytes_str(B.take_front(17), None, 8, 1));
 
   //----------------------------------------------------------------------
   // Test hex byte output with the 2 byte groups
   //----------------------------------------------------------------------
-  EXPECT_EQ("6162 6364 65", format_hex_bytes(b, 5, InvalidOffset, 16, 2));
+  EXPECT_EQ("6162 6364 65", formatted_bytes_str(B.take_front(5), None, 16, 2));
   // Test that 16 bytes get written to a line correctly.
   EXPECT_EQ("6162 6364 6566 6768 696a 6b6c 6d6e 6f70",
-            format_hex_bytes(b, 16, InvalidOffset, 16, 2));
+            formatted_bytes_str(B.take_front(16), None, 16, 2));
   // Test raw bytes with default 16 bytes per line wrapping.
   EXPECT_EQ("6162 6364 6566 6768 696a 6b6c 6d6e 6f70\n71",
-            format_hex_bytes(b, 17, InvalidOffset, 16, 2));
+            formatted_bytes_str(B.take_front(17), None, 16, 2));
   // Test raw bytes with 7 bytes per line wrapping.
   EXPECT_EQ("6162 6364 6566 67\n6869 6a6b 6c6d 6e\n6f70 71",
-            format_hex_bytes(b, 17, InvalidOffset, 7, 2));
+            formatted_bytes_str(B.take_front(17), None, 7, 2));
   // Test raw bytes with 8 bytes per line wrapping.
   EXPECT_EQ("6162 6364 6566 6768\n696a 6b6c 6d6e 6f70\n71",
-            format_hex_bytes(b, 17, InvalidOffset, 8, 2));
+            formatted_bytes_str(B.take_front(17), None, 8, 2));
 
   //----------------------------------------------------------------------
   // Test hex bytes with offset with the default 4 byte groups.
   //----------------------------------------------------------------------
-  EXPECT_EQ("0x0000000000000000: 61", format_hex_bytes(b, 1, 0x0));
-  EXPECT_EQ("0x0000000000001000: 61", format_hex_bytes(b, 1, 0x1000));
-  EXPECT_EQ("0x0000000000001000: 61\n0x0000000000001001: 62",
-            format_hex_bytes(b, 2, 0x1000, 1));
+  EXPECT_EQ("0000: 61", formatted_bytes_str(B.take_front(), 0x0));
+  EXPECT_EQ("1000: 61", formatted_bytes_str(B.take_front(), 0x1000));
+  EXPECT_EQ("1000: 61\n1001: 62",
+            formatted_bytes_str(B.take_front(2), 0x1000, 1));
   //----------------------------------------------------------------------
   // Test hex bytes with ASCII with the default 4 byte groups.
   //----------------------------------------------------------------------
   EXPECT_EQ("61626364 65666768 696a6b6c 6d6e6f70  |abcdefghijklmnop|",
-            format_hex_bytes_with_ascii(b, 16));
+            format_bytes_with_ascii_str(B.take_front(16)));
   EXPECT_EQ("61626364 65666768  |abcdefgh|\n"
             "696a6b6c 6d6e6f70  |ijklmnop|",
-            format_hex_bytes_with_ascii(b, 16, InvalidOffset, 8));
+            format_bytes_with_ascii_str(B.take_front(16), None, 8));
   EXPECT_EQ("61626364 65666768  |abcdefgh|\n696a6b6c           |ijkl|",
-            format_hex_bytes_with_ascii(b, 12, InvalidOffset, 8));
-  char unprintable[] = {'a', '\x1e', 'b', '\x1f'};
+            format_bytes_with_ascii_str(B.take_front(12), None, 8));
+  std::vector<uint8_t> Unprintable = {'a', '\x1e', 'b', '\x1f'};
   // Make sure the ASCII is still lined up correctly when fewer bytes than 16
   // bytes per line are available. The ASCII should still be aligned as if 16
   // bytes of hex might be displayed.
   EXPECT_EQ("611e621f                             |a.b.|",
-            format_hex_bytes_with_ascii(unprintable, 4));
+            format_bytes_with_ascii_str(Unprintable));
   //----------------------------------------------------------------------
   // Test hex bytes with ASCII with offsets with the default 4 byte groups.
   //----------------------------------------------------------------------
-  EXPECT_EQ("0x0000000000000000: 61626364 65666768 "
+  EXPECT_EQ("0000: 61626364 65666768 "
             "696a6b6c 6d6e6f70  |abcdefghijklmnop|",
-            format_hex_bytes_with_ascii(b, 16, 0));
-  EXPECT_EQ("0x0000000000000000: 61626364 65666768  |abcdefgh|\n"
-            "0x0000000000000008: 696a6b6c 6d6e6f70  |ijklmnop|",
-            format_hex_bytes_with_ascii(b, 16, 0, 8));
-  EXPECT_EQ("0x0000000000000000: 61626364 656667  |abcdefg|\n"
-            "0x0000000000000007: 68696a6b 6c      |hijkl|",
-            format_hex_bytes_with_ascii(b, 12, 0, 7));
+            format_bytes_with_ascii_str(B.take_front(16), 0));
+  EXPECT_EQ("0000: 61626364 65666768  |abcdefgh|\n"
+            "0008: 696a6b6c 6d6e6f70  |ijklmnop|",
+            format_bytes_with_ascii_str(B.take_front(16), 0, 8));
+  EXPECT_EQ("0000: 61626364 656667  |abcdefg|\n"
+            "0007: 68696a6b 6c      |hijkl|",
+            format_bytes_with_ascii_str(B.take_front(12), 0, 7));
 
   //----------------------------------------------------------------------
   // Test hex bytes with ASCII with offsets with the default 2 byte groups.
   //----------------------------------------------------------------------
-  EXPECT_EQ("0x0000000000000000: 6162 6364 6566 6768 "
+  EXPECT_EQ("0000: 6162 6364 6566 6768 "
             "696a 6b6c 6d6e 6f70  |abcdefghijklmnop|",
-            format_hex_bytes_with_ascii(b, 16, 0, 16, 2));
-  EXPECT_EQ("0x0000000000000000: 6162 6364 6566 6768  |abcdefgh|\n"
-            "0x0000000000000008: 696a 6b6c 6d6e 6f70  |ijklmnop|",
-            format_hex_bytes_with_ascii(b, 16, 0, 8, 2));
-  EXPECT_EQ("0x0000000000000000: 6162 6364 6566 67  |abcdefg|\n"
-            "0x0000000000000007: 6869 6a6b 6c       |hijkl|",
-            format_hex_bytes_with_ascii(b, 12, 0, 7, 2));
+            format_bytes_with_ascii_str(B.take_front(16), 0, 16, 2));
+  EXPECT_EQ("0000: 6162 6364 6566 6768  |abcdefgh|\n"
+            "0008: 696a 6b6c 6d6e 6f70  |ijklmnop|",
+            format_bytes_with_ascii_str(B.take_front(16), 0, 8, 2));
+  EXPECT_EQ("0000: 6162 6364 6566 67  |abcdefg|\n"
+            "0007: 6869 6a6b 6c       |hijkl|",
+            format_bytes_with_ascii_str(B.take_front(12), 0, 7, 2));
 
   //----------------------------------------------------------------------
   // Test hex bytes with ASCII with offsets with the default 1 byte groups.
   //----------------------------------------------------------------------
-  EXPECT_EQ("0x0000000000000000: 61 62 63 64 65 66 67 68 "
+  EXPECT_EQ("0000: 61 62 63 64 65 66 67 68 "
             "69 6a 6b 6c 6d 6e 6f 70  |abcdefghijklmnop|",
-            format_hex_bytes_with_ascii(b, 16, 0, 16, 1));
-  EXPECT_EQ("0x0000000000000000: 61 62 63 64 65 66 67 68  |abcdefgh|\n"
-            "0x0000000000000008: 69 6a 6b 6c 6d 6e 6f 70  |ijklmnop|",
-            format_hex_bytes_with_ascii(b, 16, 0, 8, 1));
-  EXPECT_EQ("0x0000000000000000: 61 62 63 64 65 66 67  |abcdefg|\n"
-            "0x0000000000000007: 68 69 6a 6b 6c        |hijkl|",
-            format_hex_bytes_with_ascii(b, 12, 0, 7, 1));
+            format_bytes_with_ascii_str(B.take_front(16), 0, 16, 1));
+  EXPECT_EQ("0000: 61 62 63 64 65 66 67 68  |abcdefgh|\n"
+            "0008: 69 6a 6b 6c 6d 6e 6f 70  |ijklmnop|",
+            format_bytes_with_ascii_str(B.take_front(16), 0, 8, 1));
+  EXPECT_EQ("0000: 61 62 63 64 65 66 67  |abcdefg|\n"
+            "0007: 68 69 6a 6b 6c        |hijkl|",
+            format_bytes_with_ascii_str(B.take_front(12), 0, 7, 1));
 }
 }