Remove manual byte counting from internal Stream methods.

[teemperor]

Summary

This patch removes the manual byte counting in all internal Stream methods.
This is now done by the automatic byte counting provided by calling GetWrittenBytes()
before and after writing the data (which is automatically done for us by the ByteDelta
utility class).

[labath]

What would you say to moving this class to the header, so that it can be used in all the other byte-counting patches too?

[teemperor]

• Made ByteDelta public.
• Minor fixes.

@labath It sounds reasonable to make ByteDelta public. It certainly improves the byte-counting code outside of Stream, even though it hopefully doesn't encourage anyone to do even more byte-counting in LLDB. (Also thanks for reviewing!)

[JDevlieghere]

Neat, LGTM!

include/lldb/Utility/Stream.h

protected:
   //------------------------------------------------------------------
   Flags m_flags;        ///< Dump flags.
   uint32_t m_addr_size; ///< Size of an address in bytes.
   lldb::ByteOrder
       m_byte_order;   ///< Byte order to use when encoding scalar types.
   int m_indent_level; ///< Indention level.
   std::size_t m_bytes_written = 0; ///< Number of bytes written so far.
 
-  size_t _PutHex8(uint8_t uvalue, bool add_prefix);
+  void _PutHex8(uint8_t uvalue, bool add_prefix);
 
   //------------------------------------------------------------------
   /// Output character bytes to the stream.
   ///
   /// Appends \a src_len characters from the buffer \a src to the stream.
   ///
   /// @param[in] src
   ///     A buffer containing at least \a src_len bytes of data.

source/Utility/Stream.cpp

 #include <string>
 
 #include <inttypes.h>
 #include <stddef.h>
 
 using namespace lldb;
 using namespace lldb_private;
 
+namespace {
+/// Utility class for counting the bytes that were written to a stream in a
+/// certain time span.
+/// @example
+///   ByteDelta delta(*this);
+///   WriteDataToStream("foo");
+///   return *delta;
+/// @endcode
+class ByteDelta {
+  Stream *m_stream;
+  /// Bytes we have written so far when ByteDelta was created.
+  size_t m_start;
+
+public:
+  ByteDelta(Stream &s) : m_stream(&s), m_start(s.GetWrittenBytes()) {}
+
+  size_t operator*() const { return m_stream->GetWrittenBytes() - m_start; }
+}
+} // namespace
+
 Stream::Stream(uint32_t flags, uint32_t addr_size, ByteOrder byte_order)
     : m_flags(flags), m_addr_size(addr_size), m_byte_order(byte_order),
       m_indent_level(0), m_forwarder(*this) {}
 
 Stream::Stream()
     : m_flags(0), m_addr_size(4), m_byte_order(endian::InlHostByteOrder()),
       m_indent_level(0), m_forwarder(*this) {}
 

 
 size_t Stream::PrintfAsRawHex8(const char *format, ...) {
   va_list args;
   va_start(args, format);
 
   llvm::SmallString<1024> buf;
   VASprintf(buf, format, args);
 
-  size_t length = 0;
+  ByteDelta delta(*this);
   for (char C : buf)
-    length += _PutHex8(C, false);
+    _PutHex8(C, false);
 
   va_end(args);
 
-  return length;
+  return *delta;
 }
 
 size_t Stream::PutNHex8(size_t n, uint8_t uvalue) {
-  size_t bytes_written = 0;
+  ByteDelta delta(*this);
   for (size_t i = 0; i < n; ++i)
-    bytes_written += _PutHex8(uvalue, false);
-  return bytes_written;
+    _PutHex8(uvalue, false);
+  return *delta;
 }
 
-size_t Stream::_PutHex8(uint8_t uvalue, bool add_prefix) {
-  size_t bytes_written = 0;
+void Stream::_PutHex8(uint8_t uvalue, bool add_prefix) {
   if (m_flags.Test(eBinary)) {
-    bytes_written = Write(&uvalue, 1);
+    Write(&uvalue, 1);
   } else {
     if (add_prefix)
       PutCString("0x");
 
     static char g_hex_to_ascii_hex_char[16] = {'0', '1', '2', '3', '4', '5',
                                                '6', '7', '8', '9', 'a', 'b',
                                                'c', 'd', 'e', 'f'};
     char nibble_chars[2];
     nibble_chars[0] = g_hex_to_ascii_hex_char[(uvalue >> 4) & 0xf];
     nibble_chars[1] = g_hex_to_ascii_hex_char[(uvalue >> 0) & 0xf];
-    bytes_written = Write(nibble_chars, sizeof(nibble_chars));
+    Write(nibble_chars, sizeof(nibble_chars));
   }
-  return bytes_written;
 }
 
 size_t Stream::PutHex8(uint8_t uvalue) { return _PutHex8(uvalue, false); }
 
 size_t Stream::PutHex16(uint16_t uvalue, ByteOrder byte_order) {
+  ByteDelta delta(*this);
+
   if (byte_order == eByteOrderInvalid)
     byte_order = m_byte_order;
 
-  size_t bytes_written = 0;
   if (byte_order == eByteOrderLittle) {
     for (size_t byte = 0; byte < sizeof(uvalue); ++byte)
-      bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
+      _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
   } else {
     for (size_t byte = sizeof(uvalue) - 1; byte < sizeof(uvalue); --byte)
-      bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
+      _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
   }
-  return bytes_written;
+  return *delta;
 }
 
 size_t Stream::PutHex32(uint32_t uvalue, ByteOrder byte_order) {
+  ByteDelta delta(*this);
+
   if (byte_order == eByteOrderInvalid)
     byte_order = m_byte_order;
 
-  size_t bytes_written = 0;
   if (byte_order == eByteOrderLittle) {
     for (size_t byte = 0; byte < sizeof(uvalue); ++byte)
-      bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
+      _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
   } else {
     for (size_t byte = sizeof(uvalue) - 1; byte < sizeof(uvalue); --byte)
-      bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
+      _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
   }
-  return bytes_written;
+  return *delta;
 }
 
 size_t Stream::PutHex64(uint64_t uvalue, ByteOrder byte_order) {
+  ByteDelta delta(*this);
+
   if (byte_order == eByteOrderInvalid)
     byte_order = m_byte_order;
 
-  size_t bytes_written = 0;
   if (byte_order == eByteOrderLittle) {
     for (size_t byte = 0; byte < sizeof(uvalue); ++byte)
-      bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
+      _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
   } else {
     for (size_t byte = sizeof(uvalue) - 1; byte < sizeof(uvalue); --byte)
-      bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
+      _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
   }
-  return bytes_written;
+  return *delta;
 }
 
 size_t Stream::PutMaxHex64(uint64_t uvalue, size_t byte_size,
                            lldb::ByteOrder byte_order) {
   switch (byte_size) {
   case 1:
     return PutHex8((uint8_t)uvalue);
   case 2:
size_t Stream::PutLongDouble(long double ld, ByteOrder byte_order) {
   if (byte_order == eByteOrderInvalid)
     byte_order = m_byte_order;
 
   return PutRawBytes(&ld, sizeof(ld), endian::InlHostByteOrder(), byte_order);
 }
 
 size_t Stream::PutRawBytes(const void *s, size_t src_len,
                            ByteOrder src_byte_order, ByteOrder dst_byte_order) {
+  ByteDelta delta(*this);
+
   if (src_byte_order == eByteOrderInvalid)
     src_byte_order = m_byte_order;
 
   if (dst_byte_order == eByteOrderInvalid)
     dst_byte_order = m_byte_order;
 
-  size_t bytes_written = 0;
   const uint8_t *src = (const uint8_t *)s;
   bool binary_was_set = m_flags.Test(eBinary);
   if (!binary_was_set)
     m_flags.Set(eBinary);
   if (src_byte_order == dst_byte_order) {
     for (size_t i = 0; i < src_len; ++i)
-      bytes_written += _PutHex8(src[i], false);
+      _PutHex8(src[i], false);
   } else {
     for (size_t i = src_len - 1; i < src_len; --i)
-      bytes_written += _PutHex8(src[i], false);
+      _PutHex8(src[i], false);
   }
   if (!binary_was_set)
     m_flags.Clear(eBinary);
 
-  return bytes_written;
+  return *delta;
 }
 
 size_t Stream::PutBytesAsRawHex8(const void *s, size_t src_len,
                                  ByteOrder src_byte_order,
                                  ByteOrder dst_byte_order) {
+  ByteDelta delta(*this);
   if (src_byte_order == eByteOrderInvalid)
     src_byte_order = m_byte_order;
 
   if (dst_byte_order == eByteOrderInvalid)
     dst_byte_order = m_byte_order;
 
-  size_t bytes_written = 0;
   const uint8_t *src = (const uint8_t *)s;
   bool binary_is_set = m_flags.Test(eBinary);
   m_flags.Clear(eBinary);
   if (src_byte_order == dst_byte_order) {
     for (size_t i = 0; i < src_len; ++i)
-      bytes_written += _PutHex8(src[i], false);
+      _PutHex8(src[i], false);
   } else {
     for (size_t i = src_len - 1; i < src_len; --i)
-      bytes_written += _PutHex8(src[i], false);
+      _PutHex8(src[i], false);
   }
   if (binary_is_set)
     m_flags.Set(eBinary);
 
-  return bytes_written;
+  return *delta;
 }
 
 size_t Stream::PutCStringAsRawHex8(const char *s) {
-  size_t bytes_written = 0;
+  ByteDelta delta(*this);
   bool binary_is_set = m_flags.Test(eBinary);
   m_flags.Clear(eBinary);
   while(*s) {
-    bytes_written += _PutHex8(*s, false);
+    _PutHex8(*s, false);
     ++s;
   }
   if (binary_is_set)
     m_flags.Set(eBinary);
-  return bytes_written;
+  return *delta;
 }