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 ↗

(On Diff #223143)

@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 ↗

(On Diff #223143)

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 ↗

(On Diff #223143)

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 ↗

(On Diff #223143)

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 ↗

(On Diff #223143)

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

255–257

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

111

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

312

I'd drop the return.

318

Same here

[lawrence_danna]

lldb/include/lldb/Utility/ReproducerInstrumentation.h

255–257

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

111

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

243

clang-format this

lldb/source/API/SBCommandReturnObject.cpp

118–142

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

133

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).

275–284

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 <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;
 }

 /// We need to differentiate between pointers to fundamental and
 /// non-fundamental types. See the corresponding Deserializer::Read method
 /// for the reason why.
 struct PointerTag {};
 struct ReferenceTag {};
 struct ValueTag {};
 struct FundamentalPointerTag {};
 struct FundamentalReferenceTag {};
+struct NotImplementedTag {};
 
 /// Return the deserialization tag for the given type T.
-template <class T> struct serializer_tag { typedef ValueTag type; };
+template <class T> struct serializer_tag {
+  typedef typename std::conditional<std::is_trivially_copyable<T>::value, ValueTag, NotImplementedTag>::type 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
#endif
   /// The latter requires special handling.
   void HandleReplayResultVoid() {
     unsigned result = Deserialize<unsigned>();
     assert(result == 0);
     (void)result;
   }
 
 private:
+  template <typename T> T Read(NotImplementedTag) {
+    m_buffer = m_buffer.drop_front(sizeof(T));
+    return T();
+  }
+
   template <typename T> T Read(ValueTag) {
     assert(HasData(sizeof(T)));
     T t;
     std::memcpy(reinterpret_cast<char *>(&t), m_buffer.data(), sizeof(T));
     m_buffer = m_buffer.drop_front(sizeof(T));
     return t;
   }
 

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'])
-    @expectedFailure # 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'])
-    @expectedFailure # 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 ref().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);
 
   ref().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);
-
-  ref().SetImmediateOutputFile(fh, transfer_ownership);
+  FileSP file = std::make_shared<NativeFile>(fh, transfer_ownership);
+  ref().SetImmediateOutputFile(file);
 }
 
 void SBCommandReturnObject::SetImmediateErrorFile(FILE *fh,
                                                   bool transfer_ownership) {
   LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
                      (FILE *, bool), fh, transfer_ownership);
+  FileSP file = std::make_shared<NativeFile>(fh, transfer_ownership);
+  ref().SetImmediateErrorFile(file);
+}
 
-  ref().SetImmediateErrorFile(fh, transfer_ownership);
+void SBCommandReturnObject::SetImmediateOutputFile(SBFile file) {
+  LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
+                     (SBFile), file);
+  ref().SetImmediateOutputFile(file.m_opaque_sp);
+}
+
+void SBCommandReturnObject::SetImmediateErrorFile(SBFile file) {
+  LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
+                     (SBFile), file);
+  ref().SetImmediateErrorFile(file.m_opaque_sp);
+}
+
+void SBCommandReturnObject::SetImmediateOutputFile(FileSP file_sp) {
+  LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
+                     (FileSP), file_sp);
+  SetImmediateOutputFile(SBFile(file_sp));
+}
+
+void SBCommandReturnObject::SetImmediateErrorFile(FileSP file_sp) {
+  LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
+                     (FileSP), file_sp);
+  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;
   } else if (len > 0) {
     std::string buffer(string, len);
     ref().AppendMessage(buffer.c_str());
   } else
     ref().AppendMessage(string);
 }
 
 const char *SBCommandReturnObject::GetOutput(bool only_if_no_immediate) {
   LLDB_RECORD_METHOD(const char *, SBCommandReturnObject, GetOutput, (bool),
                      only_if_no_immediate);
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/API/SBFile.cpp

 
 SBFile::SBFile(FileSP file_sp) : m_opaque_sp(file_sp) {
   LLDB_RECORD_DUMMY(void, SBfile, SBFile, (FileSP), file_sp);
 }
 
 SBFile::SBFile() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFile); }
 
 SBFile::SBFile(FILE *file, bool transfer_ownership) {
+  LLDB_RECORD_DUMMY(void, SBFile, (FILE *, bool), file, transfer_ownership);
   m_opaque_sp = std::make_shared<NativeFile>(file, transfer_ownership);
 }
 
 SBFile::SBFile(int fd, const char *mode, bool transfer_owndership) {
-  LLDB_RECORD_CONSTRUCTOR(SBFile, (int, const char *, bool), fd, mode,
-                          transfer_owndership);
+  LLDB_RECORD_DUMMY(void, SBFile, (int, const char *, bool), fd, mode,
   auto options = File::GetOptionsFromMode(mode);
   m_opaque_sp = std::make_shared<NativeFile>(fd, options, transfer_owndership);
 }
 
 SBError SBFile::Read(uint8_t *buf, size_t num_bytes, size_t *bytes_read) {
   LLDB_RECORD_DUMMY(lldb::SBError, SBFile, Read, (uint8_t *, size_t, size_t *),
                     buf, num_bytes, bytes_read);
   SBError error;

 
 bool SBFile::operator!() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFile, operator!);
   return LLDB_RECORD_RESULT(!IsValid());
 }
 
 namespace lldb_private {
 namespace repro {
+
 template <> void RegisterMethods<SBFile>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBFile, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBFile, (int, const char *, bool));
+
   LLDB_REGISTER_METHOD(lldb::SBError, SBFile, Flush, ());
   LLDB_REGISTER_METHOD_CONST(bool, SBFile, IsValid, ());
   LLDB_REGISTER_METHOD_CONST(bool, SBFile, operator bool,());
   LLDB_REGISTER_METHOD_CONST(bool, SBFile, operator!,());
   LLDB_REGISTER_METHOD(lldb::SBError, SBFile, Close, ());
 }
 } // namespace repro
 } // namespace lldb_private

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/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.