Add raw_ostream wrapper to the Stream class

[teemperor]

Summary

This wrapper will allow us in the future to reuse LLVM methods from within the
Stream class.

Currently no test as this is intended to be an internal class that shouldn't have any
NFC. The test for this change will be the follow up patch that migrates LLDB's
LEB128 implementation to the one from LLVM.

This change also adds custom move/assignment methods to Stream, as LLVM
raw_ostream doesn't support these. As our internal stream has anyway no state,
we can just keep the same stream object around.

[labath]

Wouldn't it be even better to actually expose the llvm class via some accessor or something? This way we could slowly migrate existing code by changing it to write to stream.accessor() instead of stream ? (I am not saying to do that now, but it opens up possibilities for the future.)

I also found it hard to deduce who is forwarding to whom from the member names. Maybe rename m_forward_to to m_target or something like that?

[teemperor]

• Renamed m_forward_to to m_target.
• Added a getter to allow external code to use the raw_ostream API.
• Renamed m_forward to m_forwarder.

@labath Thanks, fixed the problems you pointed out. I already made the API public in this patch, it's probably good for encouraging people to use LLVM's raw_ostream classes.

[labath]

looks good to me. Thanks.

Btw, have you looked at how hard would it be to actually fix the places that are copying these streams?

[teemperor]

StreamTee is copying it, which is expected to be copyable when we copy CommandObjectResult around. And then I just added the copy-constructor as CommandObjectResult refactoring sound time-expensive.

[labath]

In D50161#1187972, @teemperor wrote:

StreamTee is copying it, which is expected to be copyable when we copy CommandObjectResult around. And then I just added the copy-constructor as CommandObjectResult refactoring sound time-expensive.

Sure, that's fine. I was just wondering what the obstacles are. Thanks.

lldb/trunk/include/lldb/Utility/Stream.h

 #ifndef liblldb_Stream_h_
 #define liblldb_Stream_h_
 
 #include "lldb/Utility/Flags.h"
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-enumerations.h" // for ByteOrder::eByteOrderInvalid
 #include "llvm/ADT/StringRef.h"     // for StringRef
 #include "llvm/Support/FormatVariadic.h"
+#include "llvm/Support/raw_ostream.h"
 
 #include <stdarg.h>
 #include <stddef.h>    // for size_t
 #include <stdint.h>    // for uint32_t, uint64_t, uint8_t
 #include <type_traits> // for forward
 
 namespace lldb_private {
 
public:
 
   //------------------------------------------------------------------
   /// Construct a default Stream, not binary, host byte order and host addr
   /// size.
   ///
   //------------------------------------------------------------------
   Stream();
 
+  // FIXME: Streams should not be copyable.
+  Stream(const Stream &other) : m_forwarder(*this) { (*this) = other; }
+
+  Stream &operator=(const Stream &rhs) {
+    m_flags = rhs.m_flags;
+    m_addr_size = rhs.m_addr_size;
+    m_byte_order = rhs.m_byte_order;
+    m_indent_level = rhs.m_indent_level;
+    return *this;
+  }
+
   //------------------------------------------------------------------
   /// Destructor
   //------------------------------------------------------------------
   virtual ~Stream();
 
   //------------------------------------------------------------------
   // Subclasses must override these methods
   //------------------------------------------------------------------
public:
   /// Put an ULEB128 \a uval out to the stream using the printf format in \a
   /// format.
   ///
   /// @param[in] uval
   ///     A uint64_t value that was extracted as a ULEB128 value.
   //------------------------------------------------------------------
   size_t PutULEB128(uint64_t uval);
 
+  //------------------------------------------------------------------
+  /// Returns a raw_ostream that forwards the data to this Stream object.
+  //------------------------------------------------------------------
+  llvm::raw_ostream &AsRawOstream() {
+    return m_forwarder;
+  }
+
 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.
protected:
   ///
   /// @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;
+
+  //----------------------------------------------------------------------
+  /// @class RawOstreamForward Stream.h "lldb/Utility/Stream.h"
+  /// This is a wrapper class that exposes a raw_ostream interface that just
+  /// forwards to an LLDB stream, allowing to reuse LLVM algorithms that take
+  /// a raw_ostream within the LLDB code base.
+  //----------------------------------------------------------------------
+  class RawOstreamForward : public llvm::raw_ostream {
+    // Note: This stream must *not* maintain its own buffer, but instead
+    // directly write everything to the internal Stream class. Without this,
+    // we would run into the problem that the Stream written byte count would
+    // differ from the actually written bytes by the size of the internal
+    // raw_ostream buffer.
+
+    Stream &m_target;
+    void write_impl(const char *Ptr, size_t Size) override {
+      m_target.Write(Ptr, Size);
+    }
+
+    uint64_t current_pos() const override {
+      return m_target.GetWrittenBytes();
+    }
+
+  public:
+    RawOstreamForward(Stream &target)
+        : llvm::raw_ostream(/*unbuffered*/ true), m_target(target) {}
+  };
+  RawOstreamForward m_forwarder;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_Stream_h_

lldb/trunk/source/Utility/Stream.cpp

 #include <inttypes.h>
 #include <stddef.h>
 
 using namespace lldb;
 using namespace lldb_private;
 
 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_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_indent_level(0), m_forwarder(*this) {}
 
 //------------------------------------------------------------------
 // Destructor
 //------------------------------------------------------------------
 Stream::~Stream() {}
 
 ByteOrder Stream::SetByteOrder(ByteOrder byte_order) {
   ByteOrder old_byte_order = m_byte_order;