Add byte counting mechanism to LLDB's Stream class.

[teemperor]

Summary

This patch allows LLDB's Stream class to count the bytes it has written to so far.

There are two major motivations for this patch:

The first one is that this will allow us to get rid of all the handwritten byte counting code
we have in LLDB so far. Examples for this are pretty much all functions in LLDB that
take a Stream to write to and return a size_t, which usually represents the bytes written.

By moving to this centralized byte counting mechanism, we hopefully can avoid some
tricky errors that happen when some code forgets to count the written bytes while
writing something to a stream.

The second motivation is that this is needed for the migration away from LLDB's Stream
and towards LLVM's raw_ostream. My current plan is to start offering a fake raw_ostream
class that just forwards to a LLDB Stream.

However, for this raw_ostream wrapper we need to fulfill the raw_ostream interface with
LLDB's Stream, which currently lacks the ability to count the bytes written so far (which
raw_ostream exposes by it's tell() method). By adding this functionality it is trivial to start
rolling out our raw_ostream wrapper (and then eventually completely move to raw_ostream).

Also, once this fake raw_ostream is available, we can start replacing our own code writing
to LLDB's Stream by LLVM code writing to raw_ostream. The best example for this is the
LEB128 encoding we currently ship, which can be replaced with by LLVM's version which
accepts an raw_ostream.

From the point of view of the pure source changes this test does, we essentially just renamed
the Write implementation in Stream to WriteImpl while the Write method everyone is using
to write its raw bytes is now just forwarding and counting the written bytes.

[teemperor]

• Added some more documentation.

[labath]

I think there's a small difference in semantics between this and the tell function on llvm streams. This tells the number of bytes written, while the other one an absolute position within the stream. The two probably only differ if you open a StreamFile in append mode. However, even then, I doubt anyone will care about the distinction, so it shouldn't impede the migration. So, I'm happy to sign off on this. Thanks for doing it.

[JDevlieghere]

include/lldb/Utility/Stream.h

542

I believe you need the < for Doxygen to associate the comment with the var, like the line(s) above.

[teemperor]

• Fixing some of the merge conflicts.
• Fixed doxygen comment.

Thanks for the reviews!

include/lldb/Core/StreamAsynchronousIO.h

 class StreamAsynchronousIO : public Stream {
 public:
   StreamAsynchronousIO(Debugger &debugger, bool for_stdout);
 
   ~StreamAsynchronousIO() override;
 
   void Flush() override;
 
-  size_t Write(const void *src, size_t src_len) override;
+protected:
+  size_t WriteImpl(const void *src, size_t src_len) override;
 
 private:
   Debugger &m_debugger;
   std::string m_data;
   bool m_for_stdout;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_StreamAsynchronousIO_h

include/lldb/Core/StreamBuffer.h

StreamBuffer(uint32_t flags, uint32_t addr_size, lldb::ByteOrder byte_order)
       : Stream(flags, addr_size, byte_order), m_packet() {}
 
   virtual ~StreamBuffer() {}
 
   virtual void Flush() {
     // Nothing to do when flushing a buffer based stream...
   }
 
-  virtual size_t Write(const void *s, size_t length) {
-    if (s && length)
-      m_packet.append((const char *)s, ((const char *)s) + length);
-    return length;
-  }
-
   void Clear() { m_packet.clear(); }
 
   // Beware, this might not be NULL terminated as you can expect from
   // StringString as there may be random bits in the llvm::SmallVector. If you
   // are using this class to create a C string, be sure the call PutChar ('\0')
   // after you have created your string, or use StreamString.
   const char *GetData() const { return m_packet.data(); }
 
   size_t GetSize() const { return m_packet.size(); }
 
 protected:
   llvm::SmallVector<char, N> m_packet;
+
+  virtual size_t WriteImpl(const void *s, size_t length) {
+    if (s && length)
+      m_packet.append((const char *)s, ((const char *)s) + length);
+    return length;
+  }
 };
 
 } // namespace lldb_private
 
 #endif // #ifndef liblldb_StreamBuffer_h_

include/lldb/Core/StreamFile.h

public:
   ~StreamFile() override;
 
   File &GetFile() { return m_file; }
 
   const File &GetFile() const { return m_file; }
 
   void Flush() override;
 
-  size_t Write(const void *s, size_t length) override;
 
 protected:
   //------------------------------------------------------------------
   // Classes that inherit from StreamFile can see and modify these
   //------------------------------------------------------------------
   File m_file;
+  size_t WriteImpl(const void *s, size_t length) override;
 
 private:
   DISALLOW_COPY_AND_ASSIGN(StreamFile);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_StreamFile_h_

include/lldb/Utility/Stream.h

public:
   ///     A buffer containing at least \a src_len bytes of data.
   ///
   /// @param[in] src_len
   ///     A number of bytes to append to the stream.
   ///
   /// @return
   ///     The number of bytes that were appended to the stream.
   //------------------------------------------------------------------
-  virtual size_t Write(const void *src, size_t src_len) = 0;
+  size_t Write(const void *src, size_t src_len) {
+    size_t appended_byte_count = WriteImpl(src, src_len);
+    m_bytes_written += appended_byte_count;
+    return appended_byte_count;
+  }
+
+  size_t GetWrittenBytes() const { return m_bytes_written; }
 
   //------------------------------------------------------------------
   // Member functions
   //------------------------------------------------------------------
   size_t PutChar(char ch);
 
   //------------------------------------------------------------------
   /// Set the byte_order value.
protected:
   //------------------------------------------------------------------
   // Member variables
   //------------------------------------------------------------------
   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;
 
   size_t _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.
+  ///
+  /// @param[in] src_len
+  ///     A number of bytes to append to the stream.
+  ///
+  /// @return
+  ///     The number of bytes that were appended to the stream.
+  //------------------------------------------------------------------
+  virtual size_t WriteImpl(const void *src, size_t src_len) = 0;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_Stream_h_

include/lldb/Utility/StreamString.h

public:
   StreamString();
 
   StreamString(uint32_t flags, uint32_t addr_size, lldb::ByteOrder byte_order);
 
   ~StreamString() override;
 
   void Flush() override;
 
-  size_t Write(const void *s, size_t length) override;
-
   void Clear();
 
   bool Empty() const;
 
   size_t GetSize() const;
 
   size_t GetSizeOfLastLine() const;
 
   llvm::StringRef GetString() const;
 
   const char *GetData() const { return m_packet.c_str(); }
 
   void FillLastLineToColumn(uint32_t column, char fill_char);
 
 protected:
   std::string m_packet;
+  size_t WriteImpl(const void *s, size_t length) override;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_StreamString_h_

include/lldb/Utility/StreamTee.h

for (pos = m_streams.begin(), end = m_streams.end(); pos != end; ++pos) {
       // StreamTee to be used with hard coded indexes for clients that might
       // want N total streams with only a few that are set to valid values.
       Stream *strm = pos->get();
       if (strm)
         strm->Flush();
     }
   }
 
-  size_t Write(const void *s, size_t length) override {
-    std::lock_guard<std::recursive_mutex> guard(m_streams_mutex);
-    if (m_streams.empty())
-      return 0;
-
-    size_t min_bytes_written = SIZE_MAX;
-    collection::iterator pos, end;
-    for (pos = m_streams.begin(), end = m_streams.end(); pos != end; ++pos) {
-      // Allow for our collection to contain NULL streams. This allows the
-      // StreamTee to be used with hard coded indexes for clients that might
-      // want N total streams with only a few that are set to valid values.
-      Stream *strm = pos->get();
-      if (strm) {
-        const size_t bytes_written = strm->Write(s, length);
-        if (min_bytes_written > bytes_written)
-          min_bytes_written = bytes_written;
-      }
-    }
-    if (min_bytes_written == SIZE_MAX)
-      return 0;
-    return min_bytes_written;
-  }
-
   size_t AppendStream(const lldb::StreamSP &stream_sp) {
     size_t new_idx = m_streams.size();
     std::lock_guard<std::recursive_mutex> guard(m_streams_mutex);
     m_streams.push_back(stream_sp);
     return new_idx;
   }
 
   size_t GetNumStreams() const {
if (idx >= m_streams.size())
       m_streams.resize(idx + 1);
     m_streams[idx] = stream_sp;
   }
 
 protected:
   typedef std::vector<lldb::StreamSP> collection;
   mutable std::recursive_mutex m_streams_mutex;
   collection m_streams;
+
+  size_t WriteImpl(const void *s, size_t length) override {
+    std::lock_guard<std::recursive_mutex> guard(m_streams_mutex);
+    if (m_streams.empty())
+      return 0;
+
+    size_t min_bytes_written = SIZE_MAX;
+    collection::iterator pos, end;
+    for (pos = m_streams.begin(), end = m_streams.end(); pos != end; ++pos) {
+      // Allow for our collection to contain NULL streams. This allows the
+      // StreamTee to be used with hard coded indexes for clients that might
+      // want N total streams with only a few that are set to valid values.
+      Stream *strm = pos->get();
+      if (strm) {
+        const size_t bytes_written = strm->Write(s, length);
+        if (min_bytes_written > bytes_written)
+          min_bytes_written = bytes_written;
+      }
+    }
+    if (min_bytes_written == SIZE_MAX)
+      return 0;
+    return min_bytes_written;
+  }
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_StreamTee_h_

source/Core/StreamAsynchronousIO.cpp

 
 void StreamAsynchronousIO::Flush() {
   if (!m_data.empty()) {
     m_debugger.PrintAsync(m_data.data(), m_data.size(), m_for_stdout);
     m_data = std::string();
   }
 }
 
-size_t StreamAsynchronousIO::Write(const void *s, size_t length) {
+size_t StreamAsynchronousIO::WriteImpl(const void *s, size_t length) {
   m_data.append((const char *)s, length);
   return length;
 }

source/Core/StreamFile.cpp

 
 StreamFile::StreamFile(const char *path, uint32_t options, uint32_t permissions)
     : Stream(), m_file(path, options, permissions) {}
 
 StreamFile::~StreamFile() {}
 
 void StreamFile::Flush() { m_file.Flush(); }
 
-size_t StreamFile::Write(const void *s, size_t length) {
+size_t StreamFile::WriteImpl(const void *s, size_t length) {
   m_file.Write(s, length);
   return length;
 }

source/Utility/StreamString.cpp

StreamString::StreamString(uint32_t flags, uint32_t addr_size,
     : Stream(flags, addr_size, byte_order), m_packet() {}
 
 StreamString::~StreamString() {}
 
 void StreamString::Flush() {
   // Nothing to do when flushing a buffer based stream...
 }
 
-size_t StreamString::Write(const void *s, size_t length) {
+size_t StreamString::WriteImpl(const void *s, size_t length) {
   m_packet.append(reinterpret_cast<const char *>(s), length);
   return length;
 }
 
-void StreamString::Clear() { m_packet.clear(); }
+void StreamString::Clear() {
+  m_packet.clear();
+  m_bytes_written = 0;
+}
 
 bool StreamString::Empty() const { return GetSize() == 0; }
 
 size_t StreamString::GetSize() const { return m_packet.size(); }
 
 size_t StreamString::GetSizeOfLastLine() const {
   const size_t length = m_packet.size();
   size_t last_line_begin_pos = m_packet.find_last_of("\r\n");

unittests/Utility/StreamTeeTest.cpp

 }
 
 namespace {
   struct FlushTestStream : public Stream {
     unsigned m_flush_count = false;
     void Flush() override {
       ++m_flush_count;
     }
-    size_t Write(const void *src, size_t src_len) override { return src_len; }
+    size_t WriteImpl(const void *src, size_t src_len) override {
+      return src_len;
+    }
   };
 }
 
 TEST(StreamTeeTest, Flush) {
   // Check that Flush is distributed to all streams.
   auto fs1 = new FlushTestStream();
   auto fs2 = new FlushTestStream();
   lldb::StreamSP s1(fs1);

unittests/Utility/StreamTest.cpp

 
 TEST_F(StreamTest, ChangingByteOrder) {
   s.SetByteOrder(lldb::eByteOrderPDP);
   EXPECT_EQ(lldb::eByteOrderPDP, s.GetByteOrder());
 }
 
 TEST_F(StreamTest, PutChar) {
   s.PutChar('a');
+  EXPECT_EQ(1U, s.GetWrittenBytes());
   EXPECT_EQ("a", TakeValue());
 
   s.PutChar('1');
+  EXPECT_EQ(1U, s.GetWrittenBytes());
   EXPECT_EQ("1", TakeValue());
 }
 
 TEST_F(StreamTest, PutCharWhitespace) {
   s.PutChar(' ');
+  EXPECT_EQ(1U, s.GetWrittenBytes());
   EXPECT_EQ(" ", TakeValue());
 
   s.PutChar('\n');
+  EXPECT_EQ(1U, s.GetWrittenBytes());
   EXPECT_EQ("\n", TakeValue());
 
   s.PutChar('\r');
+  EXPECT_EQ(1U, s.GetWrittenBytes());
   EXPECT_EQ("\r", TakeValue());
 
   s.PutChar('\t');
+  EXPECT_EQ(1U, s.GetWrittenBytes());
   EXPECT_EQ("\t", TakeValue());
 }
 
 TEST_F(StreamTest, PutCString) {
   s.PutCString("");
+  EXPECT_EQ(0U, s.GetWrittenBytes());
   EXPECT_EQ("", TakeValue());
 
   s.PutCString("foobar");
+  EXPECT_EQ(6U, s.GetWrittenBytes());
   EXPECT_EQ("foobar", TakeValue());
 
   s.PutCString(" ");
+  EXPECT_EQ(1U, s.GetWrittenBytes());
   EXPECT_EQ(" ", TakeValue());
 }
 
 TEST_F(StreamTest, PutCStringWithStringRef) {
   s.PutCString(llvm::StringRef(""));
+  EXPECT_EQ(0U, s.GetWrittenBytes());
   EXPECT_EQ("", TakeValue());
 
   s.PutCString(llvm::StringRef("foobar"));
+  EXPECT_EQ(6U, s.GetWrittenBytes());
   EXPECT_EQ("foobar", TakeValue());
 
   s.PutCString(llvm::StringRef(" "));
+  EXPECT_EQ(1U, s.GetWrittenBytes());
   EXPECT_EQ(" ", TakeValue());
 }
 
 TEST_F(StreamTest, QuotedCString) {
   s.QuotedCString("foo");
+  EXPECT_EQ(5U, s.GetWrittenBytes());
   EXPECT_EQ(R"("foo")", TakeValue());
 
   s.QuotedCString("ba r");
+  EXPECT_EQ(6U, s.GetWrittenBytes());
   EXPECT_EQ(R"("ba r")", TakeValue());
 
   s.QuotedCString(" ");
+  EXPECT_EQ(3U, s.GetWrittenBytes());
   EXPECT_EQ(R"(" ")", TakeValue());
 }
 
 TEST_F(StreamTest, PutCharNull) {
   s.PutChar('\0');
+  EXPECT_EQ(1U, s.GetWrittenBytes());
   EXPECT_EQ(std::string("\0", 1), TakeValue());
 
   s.PutChar('a');
+  EXPECT_EQ(1U, s.GetWrittenBytes());
   EXPECT_EQ(std::string("a", 1), TakeValue());
 }
 
 TEST_F(StreamTest, PutCStringAsRawHex8) {
   s.PutCStringAsRawHex8("foobar");
+  EXPECT_EQ(12U, s.GetWrittenBytes());
   EXPECT_EQ("666f6f626172", TakeValue());
 
   s.PutCStringAsRawHex8(" ");
+  EXPECT_EQ(2U, s.GetWrittenBytes());
   EXPECT_EQ("20", TakeValue());
 }
 
 TEST_F(StreamTest, PutHex8) {
   s.PutHex8((uint8_t)55);
+  EXPECT_EQ(2U, s.GetWrittenBytes());
   EXPECT_EQ("37", TakeValue());
   s.PutHex8(std::numeric_limits<uint8_t>::max());
+  EXPECT_EQ(2U, s.GetWrittenBytes());
   EXPECT_EQ("ff", TakeValue());
   s.PutHex8((uint8_t)0);
+  EXPECT_EQ(2U, s.GetWrittenBytes());
   EXPECT_EQ("00", TakeValue());
 }
 
 TEST_F(StreamTest, PutNHex8) {
   s.PutNHex8(0, (uint8_t)55);
+  EXPECT_EQ(0U, s.GetWrittenBytes());
   EXPECT_EQ("", TakeValue());
+
   s.PutNHex8(1, (uint8_t)55);
+  EXPECT_EQ(2U, s.GetWrittenBytes());
   EXPECT_EQ("37", TakeValue());
+
   s.PutNHex8(2, (uint8_t)55);
+  EXPECT_EQ(4U, s.GetWrittenBytes());
   EXPECT_EQ("3737", TakeValue());
+
   s.PutNHex8(1, (uint8_t)56);
+  EXPECT_EQ(2U, s.GetWrittenBytes());
   EXPECT_EQ("38", TakeValue());
 }
 
 TEST_F(StreamTest, PutHex16ByteOrderLittle) {
   s.PutHex16(0x1234U, lldb::eByteOrderLittle);
+  EXPECT_EQ(4U, s.GetWrittenBytes());
   EXPECT_EQ("3412", TakeValue());
+
   s.PutHex16(std::numeric_limits<uint16_t>::max(), lldb::eByteOrderLittle);
+  EXPECT_EQ(4U, s.GetWrittenBytes());
   EXPECT_EQ("ffff", TakeValue());
+
   s.PutHex16(0U, lldb::eByteOrderLittle);
+  EXPECT_EQ(4U, s.GetWrittenBytes());
   EXPECT_EQ("0000", TakeValue());
 }
 
 TEST_F(StreamTest, PutHex16ByteOrderBig) {
   s.PutHex16(0x1234U, lldb::eByteOrderBig);
+  EXPECT_EQ(4U, s.GetWrittenBytes());
   EXPECT_EQ("1234", TakeValue());
+
   s.PutHex16(std::numeric_limits<uint16_t>::max(), lldb::eByteOrderBig);
+  EXPECT_EQ(4U, s.GetWrittenBytes());
   EXPECT_EQ("ffff", TakeValue());
+
   s.PutHex16(0U, lldb::eByteOrderBig);
+  EXPECT_EQ(4U, s.GetWrittenBytes());
   EXPECT_EQ("0000", TakeValue());
 }
 
 TEST_F(StreamTest, PutHex32ByteOrderLittle) {
   s.PutHex32(0x12345678U, lldb::eByteOrderLittle);
+  EXPECT_EQ(8U, s.GetWrittenBytes());
   EXPECT_EQ("78563412", TakeValue());
+
   s.PutHex32(std::numeric_limits<uint32_t>::max(), lldb::eByteOrderLittle);
+  EXPECT_EQ(8U, s.GetWrittenBytes());
   EXPECT_EQ("ffffffff", TakeValue());
+
   s.PutHex32(0U, lldb::eByteOrderLittle);
+  EXPECT_EQ(8U, s.GetWrittenBytes());
   EXPECT_EQ("00000000", TakeValue());
 }
 
 TEST_F(StreamTest, PutHex32ByteOrderBig) {
   s.PutHex32(0x12345678U, lldb::eByteOrderBig);
+  EXPECT_EQ(8U, s.GetWrittenBytes());
   EXPECT_EQ("12345678", TakeValue());
+
   s.PutHex32(std::numeric_limits<uint32_t>::max(), lldb::eByteOrderBig);
+  EXPECT_EQ(8U, s.GetWrittenBytes());
   EXPECT_EQ("ffffffff", TakeValue());
+
   s.PutHex32(0U, lldb::eByteOrderBig);
+  EXPECT_EQ(8U, s.GetWrittenBytes());
   EXPECT_EQ("00000000", TakeValue());
 }
 
 TEST_F(StreamTest, PutHex64ByteOrderLittle) {
   s.PutHex64(0x1234567890ABCDEFU, lldb::eByteOrderLittle);
+  EXPECT_EQ(16U, s.GetWrittenBytes());
   EXPECT_EQ("efcdab9078563412", TakeValue());
+
   s.PutHex64(std::numeric_limits<uint64_t>::max(), lldb::eByteOrderLittle);
+  EXPECT_EQ(16U, s.GetWrittenBytes());
   EXPECT_EQ("ffffffffffffffff", TakeValue());
+
   s.PutHex64(0U, lldb::eByteOrderLittle);
+  EXPECT_EQ(16U, s.GetWrittenBytes());
   EXPECT_EQ("0000000000000000", TakeValue());
 }
 
 TEST_F(StreamTest, PutHex64ByteOrderBig) {
   s.PutHex64(0x1234567890ABCDEFU, lldb::eByteOrderBig);
+  EXPECT_EQ(16U, s.GetWrittenBytes());
   EXPECT_EQ("1234567890abcdef", TakeValue());
+
   s.PutHex64(std::numeric_limits<uint64_t>::max(), lldb::eByteOrderBig);
+  EXPECT_EQ(16U, s.GetWrittenBytes());
   EXPECT_EQ("ffffffffffffffff", TakeValue());
+
   s.PutHex64(0U, lldb::eByteOrderBig);
+  EXPECT_EQ(16U, s.GetWrittenBytes());
   EXPECT_EQ("0000000000000000", TakeValue());
 }
 
 TEST_F(StreamTest, PutMaxHex64ByteOrderBig) {
   std::size_t bytes;
   bytes = s.PutMaxHex64(0x12U, 1, lldb::eByteOrderBig);
+  EXPECT_EQ(2U, s.GetWrittenBytes());
   EXPECT_EQ(2U, bytes);
   bytes = s.PutMaxHex64(0x1234U, 2, lldb::eByteOrderBig);
+  EXPECT_EQ(6U, s.GetWrittenBytes());
   EXPECT_EQ(4U, bytes);
   bytes = s.PutMaxHex64(0x12345678U, 4, lldb::eByteOrderBig);
+  EXPECT_EQ(14U, s.GetWrittenBytes());
   EXPECT_EQ(8U, bytes);
   bytes = s.PutMaxHex64(0x1234567890ABCDEFU, 8, lldb::eByteOrderBig);
+  EXPECT_EQ(30U, s.GetWrittenBytes());
   EXPECT_EQ(16U, bytes);
   EXPECT_EQ("121234123456781234567890abcdef", TakeValue());
 }
 
 TEST_F(StreamTest, PutMaxHex64ByteOrderLittle) {
   std::size_t bytes;
   bytes = s.PutMaxHex64(0x12U, 1, lldb::eByteOrderLittle);
+  EXPECT_EQ(2U, s.GetWrittenBytes());
   EXPECT_EQ(2U, bytes);
   bytes = s.PutMaxHex64(0x1234U, 2, lldb::eByteOrderLittle);
+  EXPECT_EQ(6U, s.GetWrittenBytes());
   EXPECT_EQ(4U, bytes);
   bytes = s.PutMaxHex64(0x12345678U, 4, lldb::eByteOrderLittle);
+  EXPECT_EQ(14U, s.GetWrittenBytes());
   EXPECT_EQ(8U, bytes);
   bytes = s.PutMaxHex64(0x1234567890ABCDEFU, 8, lldb::eByteOrderLittle);
+  EXPECT_EQ(30U, s.GetWrittenBytes());
   EXPECT_EQ(16U, bytes);
   EXPECT_EQ("12341278563412efcdab9078563412", TakeValue());
 }
 
 //------------------------------------------------------------------------------
 // Shift operator tests.
 //------------------------------------------------------------------------------
 
 TEST_F(StreamTest, ShiftOperatorChars) {
   s << 'a' << 'b';
+  EXPECT_EQ(2U, s.GetWrittenBytes());
   EXPECT_EQ("ab", TakeValue());
 }
 
 TEST_F(StreamTest, ShiftOperatorStrings) {
   s << "cstring\n";
+  EXPECT_EQ(8U, s.GetWrittenBytes());
   s << llvm::StringRef("llvm::StringRef\n");
+  EXPECT_EQ(24U, s.GetWrittenBytes());
   EXPECT_EQ("cstring\nllvm::StringRef\n", TakeValue());
 }
 
 TEST_F(StreamTest, ShiftOperatorInts) {
   s << std::numeric_limits<int8_t>::max() << " ";
   s << std::numeric_limits<int16_t>::max() << " ";
   s << std::numeric_limits<int32_t>::max() << " ";
   s << std::numeric_limits<int64_t>::max();
+  EXPECT_EQ(40U, s.GetWrittenBytes());
   EXPECT_EQ("127 32767 2147483647 9223372036854775807", TakeValue());
 }
 
 TEST_F(StreamTest, ShiftOperatorUInts) {
   s << std::numeric_limits<uint8_t>::max() << " ";
   s << std::numeric_limits<uint16_t>::max() << " ";
   s << std::numeric_limits<uint32_t>::max() << " ";
   s << std::numeric_limits<uint64_t>::max();
+  EXPECT_EQ(33U, s.GetWrittenBytes());
   EXPECT_EQ("ff ffff ffffffff ffffffffffffffff", TakeValue());
 }
 
 TEST_F(StreamTest, ShiftOperatorPtr) {
   // This test is a bit tricky because pretty much everything related to
   // pointer printing seems to lead to UB or IB. So let's make the most basic
   // test that just checks that we print *something*. This way we at least know
   // that pointer printing doesn't do really bad things (e.g. crashing, reading
   // OOB/uninitialized memory which the sanitizers would spot).
 
   // Shift our own pointer to the output.
   int i = 3;
   int *ptr = &i;
   s << ptr;
 
+  EXPECT_NE(0U, s.GetWrittenBytes());
   EXPECT_TRUE(!TakeValue().empty());
 }
 
 TEST_F(StreamTest, PutPtr) {
   // See the ShiftOperatorPtr test for the rationale.
   int i = 3;
   int *ptr = &i;
   s.PutPointer(ptr);
 
+  EXPECT_NE(0U, s.GetWrittenBytes());
   EXPECT_TRUE(!TakeValue().empty());
 }
 
 // Alias to make it more clear that 'invalid' means for the Stream interface
 // that it should use the host byte order.
 const static auto hostByteOrder = lldb::eByteOrderInvalid;
 
 //------------------------------------------------------------------------------
 // PutRawBytes/PutBytesAsRawHex tests.
 //------------------------------------------------------------------------------
 
 TEST_F(StreamTest, PutBytesAsRawHex8ToBigEndian) {
   uint32_t value = 0x12345678;
   s.PutBytesAsRawHex8(static_cast<void*>(&value), sizeof(value),
                       hostByteOrder, lldb::eByteOrderBig);
+  EXPECT_EQ(8U, s.GetWrittenBytes());
   EXPECT_EQ("78563412", TakeValue());
 }
 
 TEST_F(StreamTest, PutRawBytesToBigEndian) {
   uint32_t value = 0x12345678;
   s.PutRawBytes(static_cast<void*>(&value), sizeof(value),
                       hostByteOrder, lldb::eByteOrderBig);
+  EXPECT_EQ(4U, s.GetWrittenBytes());
   EXPECT_EQ("\x78\x56\x34\x12", TakeValue());
 }
 
 TEST_F(StreamTest, PutBytesAsRawHex8ToLittleEndian) {
   uint32_t value = 0x12345678;
   s.PutBytesAsRawHex8(static_cast<void*>(&value), sizeof(value),
                       hostByteOrder, lldb::eByteOrderLittle);
+  EXPECT_EQ(8U, s.GetWrittenBytes());
   EXPECT_EQ("12345678", TakeValue());
 }
 
 TEST_F(StreamTest, PutRawBytesToLittleEndian) {
   uint32_t value = 0x12345678;
   s.PutRawBytes(static_cast<void*>(&value), sizeof(value),
                       hostByteOrder, lldb::eByteOrderLittle);
+  EXPECT_EQ(4U, s.GetWrittenBytes());
   EXPECT_EQ("\x12\x34\x56\x78", TakeValue());
 }
 
 TEST_F(StreamTest, PutBytesAsRawHex8ToMixedEndian) {
   uint32_t value = 0x12345678;
   s.PutBytesAsRawHex8(static_cast<void*>(&value), sizeof(value),
                       hostByteOrder, lldb::eByteOrderPDP);
 

 }
 
 //------------------------------------------------------------------------------
 // ULEB128 support for binary streams.
 //------------------------------------------------------------------------------
 
 TEST_F(BinaryStreamTest, PutULEB128OneByte) {
   auto bytes = s.PutULEB128(0x74ULL);
+  EXPECT_EQ(1U, s.GetWrittenBytes());
   EXPECT_EQ("\x74", TakeValue());
   EXPECT_EQ(1U, bytes);
 }
 
 TEST_F(BinaryStreamTest, PutULEB128TwoBytes) {
   auto bytes = s.PutULEB128(0x1985ULL);
+  EXPECT_EQ(2U, s.GetWrittenBytes());
   EXPECT_EQ("\x85\x33", TakeValue());
   EXPECT_EQ(2U, bytes);
 }
 
 TEST_F(BinaryStreamTest, PutULEB128ThreeBytes) {
   auto bytes = s.PutULEB128(0x5023ULL);
+  EXPECT_EQ(3U, s.GetWrittenBytes());
   EXPECT_EQ("\xA3\xA0\x1", TakeValue());
   EXPECT_EQ(3U, bytes);
 }
 
 TEST_F(BinaryStreamTest, PutULEB128FourBytes) {
   auto bytes = s.PutULEB128(0xA48032ULL);
+  EXPECT_EQ(4U, s.GetWrittenBytes());
   EXPECT_EQ("\xB2\x80\x92\x5", TakeValue());
   EXPECT_EQ(4U, bytes);
 }
 
 TEST_F(BinaryStreamTest, PutULEB128FiveBytes) {
   auto bytes = s.PutULEB128(0x12345678ULL);
+  EXPECT_EQ(5U, s.GetWrittenBytes());
   EXPECT_EQ("\xF8\xAC\xD1\x91\x1", TakeValue());
   EXPECT_EQ(5U, bytes);
 }
 
 TEST_F(BinaryStreamTest, PutULEB128SixBytes) {
   auto bytes = s.PutULEB128(0xABFE3FAFDFULL);
+  EXPECT_EQ(6U, s.GetWrittenBytes());
   EXPECT_EQ("\xDF\xDF\xFE\xF1\xBF\x15", TakeValue());
   EXPECT_EQ(6U, bytes);
 }
 
 TEST_F(BinaryStreamTest, PutULEB128SevenBytes) {
   auto bytes = s.PutULEB128(0xDABFE3FAFDFULL);
+  EXPECT_EQ(7U, s.GetWrittenBytes());
   EXPECT_EQ("\xDF\xDF\xFE\xF1\xBF\xB5\x3", TakeValue());
   EXPECT_EQ(7U, bytes);
 }
 
 TEST_F(BinaryStreamTest, PutULEB128EightBytes) {
   auto bytes = s.PutULEB128(0x7CDABFE3FAFDFULL);
+  EXPECT_EQ(8U, s.GetWrittenBytes());
   EXPECT_EQ("\xDF\xDF\xFE\xF1\xBF\xB5\xF3\x3", TakeValue());
   EXPECT_EQ(8U, bytes);
 }
 
 TEST_F(BinaryStreamTest, PutULEB128NineBytes) {
   auto bytes = s.PutULEB128(0x327CDABFE3FAFDFULL);
+  EXPECT_EQ(9U, s.GetWrittenBytes());
   EXPECT_EQ("\xDF\xDF\xFE\xF1\xBF\xB5\xF3\x93\x3", TakeValue());
   EXPECT_EQ(9U, bytes);
 }
 
 TEST_F(BinaryStreamTest, PutULEB128MaxValue) {
   auto bytes = s.PutULEB128(std::numeric_limits<uint64_t>::max());
+  EXPECT_EQ(10U, s.GetWrittenBytes());
   EXPECT_EQ("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x1", TakeValue());
   EXPECT_EQ(10U, bytes);
 }
 
 TEST_F(BinaryStreamTest, PutULEB128Zero) {
   auto bytes = s.PutULEB128(0x0U);
+  EXPECT_EQ(1U, s.GetWrittenBytes());
   EXPECT_EQ(std::string("\0", 1), TakeValue());
   EXPECT_EQ(1U, bytes);
 }
 
 TEST_F(BinaryStreamTest, PutULEB128One) {
   auto bytes = s.PutULEB128(0x1U);
+  EXPECT_EQ(1U, s.GetWrittenBytes());
   EXPECT_EQ("\x1", TakeValue());
   EXPECT_EQ(1U, bytes);
 }
 
 //------------------------------------------------------------------------------
 // SLEB128 support for binary streams.
 //------------------------------------------------------------------------------
 
 TEST_F(BinaryStreamTest, PutSLEB128OneByte) {
   auto bytes = s.PutSLEB128(0x74LL);
+  EXPECT_EQ(2U, s.GetWrittenBytes());
   EXPECT_EQ(std::string("\xF4\0", 2), TakeValue());
   EXPECT_EQ(2U, bytes);
 }
 
 TEST_F(BinaryStreamTest, PutSLEB128TwoBytes) {
   auto bytes = s.PutSLEB128(0x1985LL);
+  EXPECT_EQ(2U, s.GetWrittenBytes());
   EXPECT_EQ("\x85\x33", TakeValue());
   EXPECT_EQ(2U, bytes);
 }
 
 TEST_F(BinaryStreamTest, PutSLEB128ThreeBytes) {
   auto bytes = s.PutSLEB128(0x5023LL);
+  EXPECT_EQ(3U, s.GetWrittenBytes());
   EXPECT_EQ("\xA3\xA0\x1", TakeValue());
   EXPECT_EQ(3U, bytes);
 }
 
 TEST_F(BinaryStreamTest, PutSLEB128FourBytes) {
   auto bytes = s.PutSLEB128(0xA48032LL);
+  EXPECT_EQ(4U, s.GetWrittenBytes());
   EXPECT_EQ("\xB2\x80\x92\x5", TakeValue());
   EXPECT_EQ(4U, bytes);
 }
 
 TEST_F(BinaryStreamTest, PutSLEB128FiveBytes) {
   auto bytes = s.PutSLEB128(0x12345678LL);
+  EXPECT_EQ(5U, s.GetWrittenBytes());
   EXPECT_EQ("\xF8\xAC\xD1\x91\x1", TakeValue());
   EXPECT_EQ(5U, bytes);
 }
 
 TEST_F(BinaryStreamTest, PutSLEB128SixBytes) {
   auto bytes = s.PutSLEB128(0xABFE3FAFDFLL);
+  EXPECT_EQ(6U, s.GetWrittenBytes());
   EXPECT_EQ("\xDF\xDF\xFE\xF1\xBF\x15", TakeValue());
   EXPECT_EQ(6U, bytes);
 }
 
 TEST_F(BinaryStreamTest, PutSLEB128SevenBytes) {
   auto bytes = s.PutSLEB128(0xDABFE3FAFDFLL);
+  EXPECT_EQ(7U, s.GetWrittenBytes());
   EXPECT_EQ("\xDF\xDF\xFE\xF1\xBF\xB5\x3", TakeValue());
   EXPECT_EQ(7U, bytes);
 }
 
 TEST_F(BinaryStreamTest, PutSLEB128EightBytes) {
   auto bytes = s.PutSLEB128(0x7CDABFE3FAFDFLL);
+  EXPECT_EQ(8U, s.GetWrittenBytes());
   EXPECT_EQ("\xDF\xDF\xFE\xF1\xBF\xB5\xF3\x3", TakeValue());
   EXPECT_EQ(8U, bytes);
 }
 
 TEST_F(BinaryStreamTest, PutSLEB128NineBytes) {
   auto bytes = s.PutSLEB128(0x327CDABFE3FAFDFLL);
+  EXPECT_EQ(9U, s.GetWrittenBytes());
   EXPECT_EQ("\xDF\xDF\xFE\xF1\xBF\xB5\xF3\x93\x3", TakeValue());
   EXPECT_EQ(9U, bytes);
 }
 
 TEST_F(BinaryStreamTest, PutSLEB128MaxValue) {
   auto bytes = s.PutSLEB128(std::numeric_limits<int64_t>::max());
+  EXPECT_EQ(10U, s.GetWrittenBytes());
   EXPECT_EQ(std::string("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0", 10), TakeValue());
   EXPECT_EQ(10U, bytes);
 }
 
 TEST_F(BinaryStreamTest, PutSLEB128Zero) {
   auto bytes = s.PutSLEB128(0x0);
+  EXPECT_EQ(1U, s.GetWrittenBytes());
   EXPECT_EQ(std::string("\0", 1), TakeValue());
   EXPECT_EQ(1U, bytes);
 }
 
 TEST_F(BinaryStreamTest, PutSLEB128One) {
   auto bytes = s.PutSLEB128(0x1);
+  EXPECT_EQ(1U, s.GetWrittenBytes());
   EXPECT_EQ(std::string("\x1", 1), TakeValue());
   EXPECT_EQ(1U, bytes);
 }
 
 //------------------------------------------------------------------------------
 // SLEB128/ULEB128 support for non-binary streams.
 //------------------------------------------------------------------------------
 
 // The logic for this is very simple, so it should be enough to test some basic
 // use cases.
 
 TEST_F(StreamTest, PutULEB128) {
   auto bytes = s.PutULEB128(0x74ULL);
+  EXPECT_EQ(4U, s.GetWrittenBytes());
   EXPECT_EQ("0x74", TakeValue());
   EXPECT_EQ(4U, bytes);
 }
 
 TEST_F(StreamTest, PutSLEB128) {
   auto bytes = s.PutSLEB128(0x1985LL);
+  EXPECT_EQ(6U, s.GetWrittenBytes());
   EXPECT_EQ("0x6533", TakeValue());
   EXPECT_EQ(6U, bytes);
 }