SBFile support in SBCommandReturnObject

[lawrence_danna]

Summary

This patch add SBFile interfaces to SBCommandReturnObject, and
removes the internal callers of its FILE* interfaces.

[lawrence_danna]

cleanup

[lawrence_danna]

deserializer hijinks

[lawrence_danna]

lldb/source/Utility/ReproducerInstrumentation.cpp

38

@JDevlieghere advice please.

[lawrence_danna]

:-/

[labath]

lldb/include/lldb/Utility/ReproducerInstrumentation.h

19

This is definitely not right. Utility should never include other lldb libraries. I think this stuff should be defined in the API folder. Either in the SBFile.cpp directly, or some additional cpp file.

lldb/source/Utility/ReproducerInstrumentation.cpp

38

This is not totally surprising as SBDebugger::SetInputFile ignores the input SBFile when it's in replay mode. However, it still doesn't seem like the right fix. I am guessing that something special needs to happen in the record/replay logic of the SBFile constructor, but off-hand, it's not fully clear to me what would that be.

I think ideally, we'd have the reproducer shadowing that's currently done in SBDebugger::SetInputFileHandle kick in earlier (in the SBFile constructor) so that it covers all SBFiles, and not just those that later become the debugger input handles, but I don't think it should be on you to make all of that work. Maybe the appropriate fix would be to just make sure the SBFile constructor creates empty objects and acknowledge that reproducers won't work for all SBFiles until someone actually implements the appropriate support for them.

[JDevlieghere]

lldb/source/Utility/ReproducerInstrumentation.cpp

38

Thanks for the great explanation Pavel, I share your thoughts on this. So to make this work you'll want to remove the LLDB_REGISTER_CONSTRUCTOR for SBFile that take a file descriptor or a FILE* (which looks like it's currently missing?) and have custom doit implementation (similar to what I did in SBDebugger) that just returns and empty SBFile.

[lawrence_danna]

a different deserializer fix for SBFile

[lawrence_danna]

lldb/source/Utility/ReproducerInstrumentation.cpp

38

custom doits for the constructor aren't enough. That won't stop the serializer from using reinterpret_cast on SBFiles that are passed by value to other recorder-instrumented functions. I've updated the patch with a somewhat more reasonable solution that doesn't mess up the library dependencies.

[labath]

lldb/source/Utility/ReproducerInstrumentation.cpp

38

That won't stop the serializer from using reinterpret_cast on SBFiles that are passed by value to other recorder-instrumented functions.

I find that surprising. At this level, what makes SBFile different from any other SB class that is passed around by value? I'd expect that the reproducer should be able to copy the (empty) SBFile object just like every other class (once we actually get it to construct an empty SBFile from a FileSP)

[lawrence_danna]

rebased

[labath]

lldb/include/lldb/Utility/ReproducerInstrumentation.h

254–256

This still doesn't seem right to me. Though you have removed the direct #include, you only managed to do that since you've forward-declared the class manually -- which I'd consider "cheating". If this is indeed the right solution (which I am not convinced of yet), then this specialization should be somewhere in the API folder (SBFile.cpp, most likely)

lldb/source/API/SBFile.cpp

115 ↗

(On Diff #223391)

I don't think these are right because there nothing here to connect the dummy implementation (used for replay) with the invocation of the actual constructor (happening when recording). (The strings are only used for debugging purposes).

This should be something like: R.Register<SBFile *()>(&construct<SBFile()>::doit, &dummy, ...). Note that the first argument is the same blurb as the thing used in the LLDB_REGISTER_CONSTRUCTOR macro in the constructor, and it's how the reproducer connects the two methods. Maybe after fixing these (you'll need the register FileSP version of the constructor too), you won't need the other changes?

That said, I am surprised you were able to get even this far with this code. Jonas, shouldn't there be some kind of an assertion if you call an unregistered method/constructor during recording?

[lawrence_danna]

use is_trivially_copyable

[JDevlieghere]

lldb/source/API/SBCommandReturnObject.cpp

296

I'd drop the return.

302

Same here

[lawrence_danna]

lldb/include/lldb/Utility/ReproducerInstrumentation.h

254–256

I figured out how to do it without referring to SBFile at all. What we really want is std::is_trivially_copyable

Objects of trivially-copyable types are the only C++ objects that may be safely copied with std::memcpy or serialized to/from binary files with std::ofstream::write()/std::ifstream::read().

That's exactly what we're doing here.

[lawrence_danna]

get rid of dummy registrations in SBFile.cpp

lldb/source/API/SBFile.cpp

115 ↗

(On Diff #223391)

Yea, and furthermore I don't need these dummy registrations at all. None of the SBFile constructors can be replayed in any meaningful way.
I can just get rid of these and record them as LLDB_RECORD_DUMMY

[lawrence_danna]

rebased

[labath]

Some nits inline, otherwise it looks fine to me.

lldb/include/lldb/Utility/ReproducerInstrumentation.h

244

clang-format this

lldb/source/API/SBCommandReturnObject.cpp

100–125

Have these methods delegate to one another (I'm not sure which should be the "base" one TBH).

115

Why not just file_sp->Write(GetOutput(), GetOutputSize()) ? It invoking formatting function for this seems overkill (and ideally I would like to remove formatted output capabilities from the file class completely).

260–270

Here the need isn't as pressing, but I'd probably have these delegate too.

lldb/include/lldb/API/SBCommandReturnObject.h

public:
   explicit operator bool() const;
 
   bool IsValid() const;
 
   const char *GetOutput();
 
   const char *GetError();
 
-  size_t PutOutput(FILE *fh);
+  size_t PutOutput(FILE *fh); // DEPRECATED
+
+  size_t PutOutput(SBFile file);
+
+  size_t PutOutput(FileSP file);
 
   size_t GetOutputSize();
 
   size_t GetErrorSize();
 
-  size_t PutError(FILE *fh);
+  size_t PutError(FILE *fh); // DEPRECATED
+
+  size_t PutError(SBFile file);
+
+  size_t PutError(FileSP file);
 
   void Clear();
 
   lldb::ReturnStatus GetStatus();
 
   void SetStatus(lldb::ReturnStatus status);
 
   bool Succeeded();
 
   bool HasResult();
 
   void AppendMessage(const char *message);
 
   void AppendWarning(const char *message);
 
   bool GetDescription(lldb::SBStream &description);
 
-  // deprecated, these two functions do not take ownership of file handle
-  void SetImmediateOutputFile(FILE *fh);
+  void SetImmediateOutputFile(FILE *fh); // DEPRECATED
+
+  void SetImmediateErrorFile(FILE *fh); // DEPRECATED
+
+  void SetImmediateOutputFile(FILE *fh, bool transfer_ownership); // DEPRECATED
+
+  void SetImmediateErrorFile(FILE *fh, bool transfer_ownership); // DEPRECATED
+
+  void SetImmediateOutputFile(SBFile file);
 
-  void SetImmediateErrorFile(FILE *fh);
+  void SetImmediateErrorFile(SBFile file);
 
-  void SetImmediateOutputFile(FILE *fh, bool transfer_ownership);
+  void SetImmediateOutputFile(FileSP file);
 
-  void SetImmediateErrorFile(FILE *fh, bool transfer_ownership);
+  void SetImmediateErrorFile(FileSP file);
 
   void PutCString(const char *string, int len = -1);
 
   size_t Printf(const char *format, ...) __attribute__((format(printf, 2, 3)));
 
   const char *GetOutput(bool only_if_no_immediate);
 
   const char *GetError(bool only_if_no_immediate);

lldb/include/lldb/API/SBFile.h

 #define LLDB_SBFile_h_
 
 #include "lldb/API/SBDefines.h"
 
 namespace lldb {
 
 class LLDB_API SBFile {
   friend class SBDebugger;
+  friend class SBCommandReturnObject;
 
 public:
   SBFile();
   SBFile(FileSP file_sp);
   SBFile(FILE *file, bool transfer_ownership);
   SBFile(int fd, const char *mode, bool transfer_ownership);
   ~SBFile();
 

lldb/include/lldb/Interpreter/CommandReturnObject.h

Stream &GetErrorStream() {
     lldb::StreamSP stream_sp(m_err_stream.GetStreamAtIndex(eStreamStringIndex));
     if (!stream_sp) {
       stream_sp.reset(new StreamString());
       m_err_stream.SetStreamAtIndex(eStreamStringIndex, stream_sp);
     }
     return m_err_stream;
   }
 
-  void SetImmediateOutputFile(FILE *fh, bool transfer_fh_ownership = false) {
-    lldb::StreamSP stream_sp(new StreamFile(fh, transfer_fh_ownership));
+  void SetImmediateOutputFile(lldb::FileSP file_sp) {
+    lldb::StreamSP stream_sp(new StreamFile(file_sp));
     m_out_stream.SetStreamAtIndex(eImmediateStreamIndex, stream_sp);
   }
 
-  void SetImmediateErrorFile(FILE *fh, bool transfer_fh_ownership = false) {
-    lldb::StreamSP stream_sp(new StreamFile(fh, transfer_fh_ownership));
+  void SetImmediateErrorFile(lldb::FileSP file_sp) {
+    lldb::StreamSP stream_sp(new StreamFile(file_sp));
     m_err_stream.SetStreamAtIndex(eImmediateStreamIndex, stream_sp);
   }
 
   void SetImmediateOutputStream(const lldb::StreamSP &stream_sp) {
     m_out_stream.SetStreamAtIndex(eImmediateStreamIndex, stream_sp);
   }
 
   void SetImmediateErrorStream(const lldb::StreamSP &stream_sp) {

lldb/include/lldb/Utility/ReproducerInstrumentation.h

 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Logging.h"
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/ErrorHandling.h"
 
+#include "lldb/API/SBFile.h"
+
 #include <iostream>
 #include <map>
 #include <type_traits>
 
 template <typename T,
           typename std::enable_if<std::is_fundamental<T>::value, int>::type = 0>
 inline void stringify_append(llvm::raw_string_ostream &ss, const T &t) {
   ss << t;

 struct PointerTag {};
 struct ReferenceTag {};
 struct ValueTag {};
 struct FundamentalPointerTag {};
 struct FundamentalReferenceTag {};
 
 /// Return the deserialization tag for the given type T.
 template <class T> struct serializer_tag { typedef ValueTag type; };
 template <class T> struct serializer_tag<T *> {
   typedef
       typename std::conditional<std::is_fundamental<T>::value,
                                 FundamentalPointerTag, PointerTag>::type type;
 };
 template <class T> struct serializer_tag<T &> {
   typedef typename std::conditional<std::is_fundamental<T>::value,
                                     FundamentalReferenceTag, ReferenceTag>::type
       type;
 };
 
 /// Deserializes data from a buffer. It is used to deserialize function indices
 /// to replay, their arguments and return values.
 ///
 /// Fundamental types and strings are read by value. Objects are read by their
 /// index, which get translated by the IndexToObject mapping maintained in
 /// this class.
 ///
 /// Additional bookkeeping with regards to the IndexToObject is required to
 /// deserialize objects. When a constructor is run or an object is returned by
 /// value, we need to capture the object and add it to the index together with
private:
   /// Buffer containing the serialized data.
   llvm::StringRef m_buffer;
 };
 
 /// Partial specialization for C-style strings. We read the string value
 /// instead of treating it as pointer.
 template <> const char *Deserializer::Deserialize<const char *>();
 template <> char *Deserializer::Deserialize<char *>();
+template <> lldb::SBFile Deserializer::Deserialize<lldb::SBFile>();
+
 
 /// Helpers to auto-synthesize function replay code. It deserializes the replay
 /// function's arguments one by one and finally calls the corresponding
 /// function.
 template <typename... Remaining> struct DeserializationHelper;
 
 template <typename Head, typename... Tail>
 struct DeserializationHelper<Head, Tail...> {

lldb/packages/Python/lldbsuite/test/python_api/file_handle/TestFileHandle.py

def test_immediate(self):
         ret = None # call destructor and flush streams
         with open(self.out_filename, 'r') as f:
             output = f.read()
             self.assertTrue(re.search(r'Show a list of all debugger commands', output))
             self.assertTrue(re.search(r'QUUX', output))
 
 
     @add_test_categories(['pyapi'])
-    @skipIf(True) # FIXME need SBFile interfaces on SBCommandReturnObject
+    @skipIf(py_version=['<', (3,)])
     def test_immediate_string(self):
         f = io.StringIO()
         ret = lldb.SBCommandReturnObject()
         ret.SetImmediateOutputFile(f)
         interpreter = self.debugger.GetCommandInterpreter()
         interpreter.HandleCommand("help help", ret)
         # make sure the file wasn't closed early.
         f.write("\nQUUX\n")
         ret = None # call destructor and flush streams
         output = f.getvalue()
         self.assertTrue(re.search(r'Show a list of all debugger commands', output))
         self.assertTrue(re.search(r'QUUX', output))
 
 
     @add_test_categories(['pyapi'])
-    @skipIf(True) # FIXME need SBFile interfaces on SBCommandReturnObject
+    @skipIf(py_version=['<', (3,)])
     def test_immediate_sbfile_string(self):
         f = io.StringIO()
         ret = lldb.SBCommandReturnObject()
         ret.SetImmediateOutputFile(lldb.SBFile(f))
         interpreter = self.debugger.GetCommandInterpreter()
         interpreter.HandleCommand("help help", ret)
         output = f.getvalue()
         ret = None # call destructor and flush streams

lldb/scripts/interface/SBCommandReturnObject.i

public:
 
     const char *
     GetOutput (bool only_if_no_immediate);
 
     const char *
     GetError (bool if_no_immediate);
 
     size_t
-    PutOutput (FILE *fh);
+    PutOutput (lldb::SBFile file);
 
     size_t
-    PutError (FILE *fh);
+    PutError (lldb::SBFile file);
+
+    size_t
+    PutOutput (lldb::FileSP BORROWED);
+
+    size_t
+    PutError (lldb::FileSP BORROWED);
 
     void
     Clear();
 
     void
     SetStatus (lldb::ReturnStatus status);
 
     void
public:
     AppendMessage (const char *message);
 
     void
     AppendWarning (const char *message);
 
     bool
     GetDescription (lldb::SBStream &description);
 
+    void SetImmediateOutputFile(lldb::SBFile file);
+    void SetImmediateErrorFile(lldb::SBFile file);
+    void SetImmediateOutputFile(lldb::FileSP BORROWED);
+    void SetImmediateErrorFile(lldb::FileSP BORROWED);
 
-    // wrapping here so that lldb takes ownership of the
-    // new FILE* created inside of the swig interface
     %extend {
-        void SetImmediateOutputFile(FILE *fh) {
-            self->SetImmediateOutputFile(fh, true);
+        // transfer_ownership does nothing, and is here for compatibility with
+        // old scripts.  Ownership is tracked by reference count in the ordinary way.
+
+        void SetImmediateOutputFile(lldb::FileSP BORROWED, bool transfer_ownership) {
+            self->SetImmediateOutputFile(BORROWED);
         }
-        void SetImmediateErrorFile(FILE *fh) {
-            self->SetImmediateErrorFile(fh, true);
+        void SetImmediateErrorFile(lldb::FileSP BORROWED, bool transfer_ownership) {
+            self->SetImmediateErrorFile(BORROWED);
         }
     }
 
   void
   PutCString(const char* string, int len);
 
     // wrapping the variadic Printf() with a plain Print()
     // because it is hard to support varargs in SWIG bridgings

lldb/source/API/SBCommandReturnObject.cpp

 //===-- SBCommandReturnObject.cpp -------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBCommandReturnObject.h"
 #include "SBReproducerPrivate.h"
 #include "Utils.h"
 #include "lldb/API/SBError.h"
+#include "lldb/API/SBFile.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Status.h"
 
 using namespace lldb;
 using namespace lldb_private;
 

 }
 
 size_t SBCommandReturnObject::GetErrorSize() {
   LLDB_RECORD_METHOD_NO_ARGS(size_t, SBCommandReturnObject, GetErrorSize);
 
   return m_opaque_up->GetErrorData().size();
 }
 
 size_t SBCommandReturnObject::PutOutput(FILE *fh) {
   LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutOutput, (FILE *), fh);
-
   if (fh) {
     size_t num_bytes = GetOutputSize();
     if (num_bytes)
       return ::fprintf(fh, "%s", GetOutput());
   }
   return 0;
 }
 
+size_t SBCommandReturnObject::PutOutput(FileSP file_sp) {
+  LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutOutput, (FileSP),
+                     file_sp);
+  if (!file_sp)
+    return 0;
+  return file_sp->Printf("%s", GetOutput());
+}
+
+size_t SBCommandReturnObject::PutOutput(SBFile file) {
+  LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutOutput, (SBFile), file);
+  if (!file.m_opaque_sp)
+    return 0;
+  return file.m_opaque_sp->Printf("%s", GetOutput());
+}
+
 size_t SBCommandReturnObject::PutError(FILE *fh) {
   LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutError, (FILE *), fh);
 
   if (fh) {
     size_t num_bytes = GetErrorSize();
     if (num_bytes)
       return ::fprintf(fh, "%s", GetError());
   }
   return 0;
 }
 
+size_t SBCommandReturnObject::PutError(FileSP file_sp) {
+  LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutError, (FileSP),
+                     file_sp);
+  if (!file_sp)
+    return 0;
+  return file_sp->Printf("%s", GetError());
+}
+
+size_t SBCommandReturnObject::PutError(SBFile file) {
+  LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutError, (SBFile), file);
+  if (!file.m_opaque_sp)
+    return 0;
+  return file.m_opaque_sp->Printf("%s", GetError());
+}
+
 void SBCommandReturnObject::Clear() {
   LLDB_RECORD_METHOD_NO_ARGS(void, SBCommandReturnObject, Clear);
 
   m_opaque_up->Clear();
 }
 
 lldb::ReturnStatus SBCommandReturnObject::GetStatus() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::ReturnStatus, SBCommandReturnObject,
void SBCommandReturnObject::SetImmediateErrorFile(FILE *fh) {
   SetImmediateErrorFile(fh, false);
 }
 
 void SBCommandReturnObject::SetImmediateOutputFile(FILE *fh,
                                                    bool transfer_ownership) {
   LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
                      (FILE *, bool), fh, transfer_ownership);
 
-  m_opaque_up->SetImmediateOutputFile(fh, transfer_ownership);
+  if (m_opaque_up) {
+    FileSP file = std::make_shared<NativeFile>(fh, transfer_ownership);
+    m_opaque_up->SetImmediateOutputFile(file);
+  }
 }
 
 void SBCommandReturnObject::SetImmediateErrorFile(FILE *fh,
                                                   bool transfer_ownership) {
   LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
                      (FILE *, bool), fh, transfer_ownership);
 
-  m_opaque_up->SetImmediateErrorFile(fh, transfer_ownership);
+  if (m_opaque_up) {
+    FileSP file = std::make_shared<NativeFile>(fh, transfer_ownership);
+    m_opaque_up->SetImmediateErrorFile(file);
+  }
+}
+
+void SBCommandReturnObject::SetImmediateOutputFile(SBFile file) {
+  LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
+                     (SBFile), file);
+  if (m_opaque_up) {
+    m_opaque_up->SetImmediateOutputFile(file.m_opaque_sp);
+  }
+}
+
+void SBCommandReturnObject::SetImmediateErrorFile(SBFile file) {
+  LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
+                     (SBFile), file);
+  if (m_opaque_up) {
+    m_opaque_up->SetImmediateErrorFile(file.m_opaque_sp);
+  }
+}
+
+void SBCommandReturnObject::SetImmediateOutputFile(FileSP file_sp) {
+  LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
+                     (FileSP), file_sp);
+  return SetImmediateOutputFile(SBFile(file_sp));
+}
+
+void SBCommandReturnObject::SetImmediateErrorFile(FileSP file_sp) {
+  LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
+                     (FileSP), file_sp);
+  return SetImmediateErrorFile(SBFile(file_sp));
 }
 
 void SBCommandReturnObject::PutCString(const char *string, int len) {
   LLDB_RECORD_METHOD(void, SBCommandReturnObject, PutCString,
                      (const char *, int), string, len);
 
   if (len == 0 || string == nullptr || *string == 0) {
     return;
void RegisterMethods<SBCommandReturnObject>(Registry &R) {
   LLDB_REGISTER_METHOD_CONST(bool, SBCommandReturnObject, IsValid, ());
   LLDB_REGISTER_METHOD_CONST(bool, SBCommandReturnObject, operator bool, ());
   LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetOutput, ());
   LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetError, ());
   LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, GetOutputSize, ());
   LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, GetErrorSize, ());
   LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, PutOutput, (FILE *));
   LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, PutError, (FILE *));
+  LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, PutOutput, (SBFile));
+  LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, PutError, (SBFile));
+  LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, PutOutput, (FileSP));
+  LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, PutError, (FileSP));
   LLDB_REGISTER_METHOD(void, SBCommandReturnObject, Clear, ());
   LLDB_REGISTER_METHOD(lldb::ReturnStatus, SBCommandReturnObject, GetStatus,
                        ());
   LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetStatus,
                        (lldb::ReturnStatus));
   LLDB_REGISTER_METHOD(bool, SBCommandReturnObject, Succeeded, ());
   LLDB_REGISTER_METHOD(bool, SBCommandReturnObject, HasResult, ());
   LLDB_REGISTER_METHOD(void, SBCommandReturnObject, AppendMessage,
                        (const char *));
   LLDB_REGISTER_METHOD(void, SBCommandReturnObject, AppendWarning,
                        (const char *));
   LLDB_REGISTER_METHOD(bool, SBCommandReturnObject, GetDescription,
                        (lldb::SBStream &));
   LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
                        (FILE *));
   LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
                        (FILE *));
   LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
+                       (SBFile));
+  LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
+                       (SBFile));
+  LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
+                       (FileSP));
+  LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
+                       (FileSP));
+  LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
                        (FILE *, bool));
   LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
                        (FILE *, bool));
   LLDB_REGISTER_METHOD(void, SBCommandReturnObject, PutCString,
                        (const char *, int));
   LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetOutput,
                        (bool));
   LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetError, (bool));
   LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetError,
                        (lldb::SBError &, const char *));
   LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetError, (const char *));
 }
 
 }
 }

lldb/source/API/SBDebugger.cpp

if (target_sp)
       lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
 
     SBCommandInterpreter sb_interpreter(GetCommandInterpreter());
     SBCommandReturnObject result;
 
     sb_interpreter.HandleCommand(command, result, false);
 
     if (GetErrorFileHandle() != nullptr)
-      result.PutError(GetErrorFileHandle());
+      result.PutError(GetErrorFile());
     if (GetOutputFileHandle() != nullptr)
-      result.PutOutput(GetOutputFileHandle());
+      result.PutOutput(GetOutputFile());
 
     if (!m_opaque_sp->GetAsyncExecution()) {
       SBProcess process(GetCommandInterpreter().GetProcess());
       ProcessSP process_sp(process.GetSP());
       if (process_sp) {
         EventSP event_sp;
         ListenerSP lldb_listener_sp = m_opaque_sp->GetListener();
         while (lldb_listener_sp->GetEventForBroadcaster(

lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

#endif
             FILE *outfile_handle =
                 fdopen(pipe.ReleaseWriteFileDescriptor(), "w");
             output_file_sp = std::make_shared<StreamFile>(outfile_handle, true);
             error_file_sp = output_file_sp;
             if (outfile_handle)
               ::setbuf(outfile_handle, nullptr);
 
             result->SetImmediateOutputFile(
-                debugger.GetOutputFile().GetStream());
-            result->SetImmediateErrorFile(debugger.GetErrorFile().GetStream());
+                debugger.GetOutputStream().GetFileSP());
+            result->SetImmediateErrorFile(
+                debugger.GetErrorStream().GetFileSP());
           }
         }
       }
       if (!input_file_sp || !output_file_sp || !error_file_sp)
         debugger.AdoptTopIOHandlerFilesIfInvalid(input_file_sp, output_file_sp,
                                                  error_file_sp);
     } else {
       auto nullin = FileSystem::Instance().Open(

lldb/source/Utility/ReproducerInstrumentation.cpp

 //===-- ReproducerInstrumentation.cpp ---------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "lldb/API/SBFile.h"
 #include "lldb/Utility/ReproducerInstrumentation.h"
 #include "lldb/Utility/Reproducer.h"
 
 using namespace lldb_private;
 using namespace lldb_private::repro;
 
 void *IndexToObject::GetObjectForIndexImpl(unsigned idx) {
   return m_mapping.lookup(idx);
template <> const char *Deserializer::Deserialize<const char *>() {
   auto pos = m_buffer.find('\0');
   if (pos == llvm::StringRef::npos)
     return nullptr;
   const char *str = m_buffer.data();
   m_buffer = m_buffer.drop_front(pos + 1);
   return str;
 }
 
+template <> lldb::SBFile Deserializer::Deserialize<lldb::SBFile>() {
+    //@JDevlieghere I'm pretty sure this is not the right thing to
+    //do, but I don't know what is!   Without this the reproducer
+    //tests read bytes out of the file, treats them as a SBFile --
+    //which is just a shared_ptr -- and start calling copy
+    //constructors on it.  Hilarity ensues.   Surprisingly
+    //just returning an invalid SBFile here seems to work.
+    m_buffer = m_buffer.drop_front(sizeof(lldb::SBFile));
+    return lldb::SBFile();
+}
+
 bool Registry::Replay(const FileSpec &file) {
   auto error_or_file = llvm::MemoryBuffer::getFile(file.GetPath());
   if (auto err = error_or_file.getError())
     return false;
 
   return Replay((*error_or_file)->getBuffer());
 }
 

lldb/tools/driver/Driver.cpp

 //===-- Driver.cpp ----------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Driver.h"
 
 #include "lldb/API/SBCommandInterpreter.h"
 #include "lldb/API/SBCommandReturnObject.h"
 #include "lldb/API/SBDebugger.h"
+#include "lldb/API/SBFile.h"
 #include "lldb/API/SBHostOS.h"
 #include "lldb/API/SBLanguageRuntime.h"
 #include "lldb/API/SBReproducer.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBStringList.h"
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/ConvertUTF.h"
#endif
 
   SBCommandInterpreter sb_interpreter = m_debugger.GetCommandInterpreter();
 
   // Before we handle any options from the command line, we parse the
   // .lldbinit file in the user's home directory.
   SBCommandReturnObject result;
   sb_interpreter.SourceInitFileInHomeDirectory(result);
   if (m_option_data.m_debug_mode) {
-    result.PutError(m_debugger.GetErrorFileHandle());
-    result.PutOutput(m_debugger.GetOutputFileHandle());
+    result.PutError(m_debugger.GetErrorFile());
+    result.PutOutput(m_debugger.GetOutputFile());
   }
 
   // Source the local .lldbinit file if it exists and we're allowed to source.
   // Here we want to always print the return object because it contains the
   // warning and instructions to load local lldbinit files.
   sb_interpreter.SourceInitFileInCurrentWorkingDirectory(result);
-  result.PutError(m_debugger.GetErrorFileHandle());
-  result.PutOutput(m_debugger.GetOutputFileHandle());
+  result.PutError(m_debugger.GetErrorFile());
+  result.PutOutput(m_debugger.GetOutputFile());
 
   // We allow the user to specify an exit code when calling quit which we will
   // return when exiting.
   m_debugger.GetCommandInterpreter().AllowExitCodeOnQuit(true);
 
   // Now we handle options we got from the command line
   SBStream commands_stream;
 
if (!m_option_data.m_repl) {
     WriteCommandsForSourcing(eCommandPlacementAfterFile, commands_stream);
   } else if (!m_option_data.m_after_file_commands.empty()) {
     // We're in repl mode and after-file-load commands were specified.
     WithColor::warning() << "commands specified to run after file load (via -o "
                             "or -s) are ignored in REPL mode.\n";
   }
 
   if (m_option_data.m_debug_mode) {
-    result.PutError(m_debugger.GetErrorFileHandle());
-    result.PutOutput(m_debugger.GetOutputFileHandle());
+    result.PutError(m_debugger.GetErrorFile());
+    result.PutOutput(m_debugger.GetOutputFile());
   }
 
   const bool handle_events = true;
   const bool spawn_thread = false;
 
   // Check if we have any data in the commands stream, and if so, save it to a
   // temp file
   // so we can then run the command interpreter using the file contents.

lldb/unittests/Utility/ReproducerInstrumentationTest.cpp

TEST(RecordReplayTest, InstrumentedBarPtr) {
 
   ClearObjects();
 
   TestingRegistry registry;
   registry.Replay(os.str());
 
   ValidateObjects(1, 1);
 }
+
+lldb::SBFile::SBFile() { }