SBDebugger::SetInputFile, SetOutputFile, etc.

[lawrence_danna]

Summary

Add new methods to SBDebugger to set IO files as SBFiles instead of
as FILE* streams.

In future commits, the FILE* methods will be deprecated and these
will become the primary way to set the debugger I/O streams.

[lawrence_danna]

clang-format fix

[labath]

Looks mostly fine to me. Just a couple of questions inline...

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

243–244

self.assertTrue(status.Success())

lldb/source/API/SBDebugger.cpp

296–342

Any chance we could make this method simply delegate to the SBFile version ?

lldb/source/Core/Debugger.cpp

828–834

Could we make it so that the validity of the file_sp argument is checked at the SB level? That way you wouldn't need the Status result here. Same goes for stdout and stderr methods.

[lawrence_danna]

propagated updates from parent

[lawrence_danna]

pushed validity checks out to the SB layer

[lawrence_danna]

assertions instead of exceptions

[labath]

LGTM. thanks.

lldb/include/lldb/API/SBFile.h

31–37

All (including private) SB methods should be defined out of line. Otherwise, their implementation becomes a part of the ABI.

[lawrence_danna]

no inlines in the API

lldb/include/lldb/API/SBDebugger.h

public:
   void SetErrorFileHandle(FILE *f, bool transfer_ownership);
 
   FILE *GetInputFileHandle();
 
   FILE *GetOutputFileHandle();
 
   FILE *GetErrorFileHandle();
 
+  SBError SetInputFile(SBFile file);
+
+  SBError SetOutputFile(SBFile file);
+
+  SBError SetErrorFile(SBFile file);
+
+  SBFile GetInputFile();
+
+  SBFile GetOutputFile();
+
+  SBFile GetErrorFile();
+
   void SaveInputTerminalState();
 
   void RestoreInputTerminalState();
 
   lldb::SBCommandInterpreter GetCommandInterpreter();
 
   void HandleCommand(const char *command);
 

lldb/include/lldb/API/SBFile.h

 //===-- SBFile.h --------------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SBFile_h_
 #define LLDB_SBFile_h_
 
 #include "lldb/API/SBDefines.h"
 
 namespace lldb {
 
 class LLDB_API SBFile {
+  friend class SBDebugger;
+
 public:
   SBFile();
   SBFile(FILE *file, bool transfer_ownership);
   SBFile(int fd, const char *mode, bool transfer_ownership);
   ~SBFile();
 
   SBError Read(uint8_t *buf, size_t num_bytes, size_t *bytes_read);
   SBError Write(const uint8_t *buf, size_t num_bytes, size_t *bytes_written);
   SBError Flush();
   bool IsValid() const;
   SBError Close();
 
   operator bool() const { return IsValid(); }
   bool operator!() const { return !IsValid(); }
 
 private:
   FileSP m_opaque_sp;
+  SBFile(FileSP file_sp) : m_opaque_sp(file_sp) {}
 };
 
 } // namespace lldb
 
 #endif // LLDB_SBFile_h_

lldb/include/lldb/Core/Debugger.h

public:
   File &GetErrorFile() { return m_error_stream_sp->GetFile(); }
 
   StreamFile &GetOutputStream() { return *m_output_stream_sp; }
 
   StreamFile &GetErrorStream() { return *m_error_stream_sp; }
 
   repro::DataRecorder *GetInputRecorder();
 
-  void SetInputFileHandle(FILE *fh, bool tranfer_ownership,
-                          repro::DataRecorder *recorder = nullptr);
+  Status SetInputFile(lldb::FileSP file,
 
-  void SetOutputFileHandle(FILE *fh, bool tranfer_ownership);
+  Status SetOutputFile(lldb::FileSP file);
 
-  void SetErrorFileHandle(FILE *fh, bool tranfer_ownership);
+  Status SetErrorFile(lldb::FileSP file);
 
   void SaveInputTerminalState();
 
   void RestoreInputTerminalState();
 
   lldb::StreamSP GetAsyncOutputStream();
 
   lldb::StreamSP GetAsyncErrorStream();

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

 import sys
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
[e-mail]
+def replace_stdout(new):
+    old = sys.stdout
+    sys.stdout = new
+    try:
+        yield
+    finally:
+        sys.stdout = old
+
 def readStrippedLines(f):
     def i():
         for line in f:
             line = line.strip()
             if line:
                 yield line
     return list(i())
 
 def handle_command(debugger, cmd, raise_on_fail=True, collect_result=True):
 
     ret = lldb.SBCommandReturnObject()
 
     if collect_result:
         interpreter = debugger.GetCommandInterpreter()
         interpreter.HandleCommand(cmd, ret)
     else:
         debugger.HandleCommand(cmd)
 
+    debugger.GetOutputFile().Flush()
+    debugger.GetErrorFile().Flush()
+
     if collect_result and raise_on_fail and not ret.Succeeded():
         raise Exception
 
     return ret.GetOutput()
 
 
 class FileHandleTestCase(TestBase):
 
def test_legacy_file_err(self):
                 self.assertTrue(re.search("is not a valid command", f.read()))
         finally:
             self.RemoveTempFile('output')
             lldb.SBDebugger.Destroy(debugger)
 
 
     @add_test_categories(['pyapi'])
     @no_debug_info_test
+    def test_legacy_file_err_with_get(self):
+
+        debugger = lldb.SBDebugger.Create()
+        try:
+            with open('output', 'w') as f:
+                debugger.SetErrorFileHandle(f, False)
+                handle_command(debugger, 'lolwut', raise_on_fail=False, collect_result=False)
+                debugger.GetErrorFileHandle().write('FOOBAR\n')
+
+            with open('output', 'r') as f:
+                errors = f.read()
+                self.assertTrue(re.search(r'error:.*lolwut', errors))
+                self.assertTrue(re.search(r'FOOBAR', errors))
+
+        finally:
+            self.RemoveTempFile('output')
+            lldb.SBDebugger.Destroy(debugger)
+
+
+    @add_test_categories(['pyapi'])
+    @no_debug_info_test
     def test_sbfile_invalid(self):
         sbf = lldb.SBFile()
         self.assertFalse(sbf.IsValid())
         e, n = sbf.Write(b'foo')
         self.assertTrue(e.Fail())
         self.assertEqual(n, 0)
         buffer = bytearray(100)
         e, n = sbf.Read(buffer)
def test_sbfile_read(self):
                 buffer = bytearray(100)
                 e, n = sbf.Read(buffer)
                 self.assertTrue(e.Success())
                 self.assertEqual(buffer[:n], b'FOO')
         finally:
             self.RemoveTempFile('output')
 
 
+    @add_test_categories(['pyapi'])
+    @no_debug_info_test
+    def test_fileno_out(self):
 
+        debugger = lldb.SBDebugger.Create()
+        try:
+            with open('output', 'w') as f:
+                sbf = lldb.SBFile(f.fileno(), "w", False)
+                status = debugger.SetOutputFile(sbf)
+                if status.Fail():
+                    raise Exception(status)
+                handle_command(debugger, 'script 1+2')
+                debugger.GetOutputFile().Write(b'quux')
 
+            with open('output', 'r') as f:
+                self.assertEqual(readStrippedLines(f), ['3', 'quux'])
 
+        finally:
+            self.RemoveTempFile('output')
+            lldb.SBDebugger.Destroy(debugger)
+
+    @add_test_categories(['pyapi'])
+    @no_debug_info_test
+    def test_fileno_help(self):
+
+        debugger = lldb.SBDebugger.Create()
+        try:
+            with open('output', 'w') as f:
+                sbf = lldb.SBFile(f.fileno(), "w", False)
+                status = debugger.SetOutputFile(sbf)
+                if status.Fail():
+                    raise Exception(status)
+                handle_command(debugger, "help help", collect_result=False)
+
+            with open('output', 'r') as f:
+                self.assertTrue(re.search(r'Show a list of all debugger commands', f.read()))
+
+        finally:
+            self.RemoveTempFile('output')
+            lldb.SBDebugger.Destroy(debugger)
+
+
+    @add_test_categories(['pyapi'])
+    @no_debug_info_test
+    def test_immediate(self):
+
+        debugger = lldb.SBDebugger.Create()
+        try:
+            with open('output', 'w') as f:
+                ret = lldb.SBCommandReturnObject()
+                ret.SetImmediateOutputFile(f)
+                interpreter = 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
+
+            with open('output', '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))
+
+        finally:
+            self.RemoveTempFile('output')
+            lldb.SBDebugger.Destroy(debugger)
+
+
+    @add_test_categories(['pyapi'])
+    @no_debug_info_test
+    def test_fileno_inout(self):
+
+        debugger = lldb.SBDebugger.Create()
+        try:
+            with open('input', 'w') as f:
+                f.write("help help\n")
+
+            with open('output', 'w') as outf, open('input', 'r') as inf:
+
+                outsbf = lldb.SBFile(outf.fileno(), "w", False)
+                status = debugger.SetOutputFile(outsbf)
+                if status.Fail():
+                    raise Exception(status)
+
+                insbf = lldb.SBFile(inf.fileno(), "r", False)
+                status = debugger.SetInputFile(insbf)
+                if status.Fail():
+                    raise Exception(status)
+
+                opts = lldb.SBCommandInterpreterRunOptions()
+                debugger.RunCommandInterpreter(True, False, opts, 0, False, False)
+                debugger.GetOutputFile().Flush()
+
+            with open('output', 'r') as f:
+                self.assertTrue(re.search(r'Show a list of all debugger commands', f.read()))
+
+        finally:
+            self.RemoveTempFile('output')
+            self.RemoveTempFile('input')
+            lldb.SBDebugger.Destroy(debugger)
+
+
+    @add_test_categories(['pyapi'])
+    @no_debug_info_test
+    def test_fileno_error(self):
+
+        debugger = lldb.SBDebugger.Create()
+        try:
+            with open('output', 'w') as f:
+
+                sbf = lldb.SBFile(f.fileno(), 'w', False)
+                status = debugger.SetErrorFile(sbf)
+                if status.Fail():
+                    raise Exception(status)
+
+                handle_command(debugger, 'lolwut', raise_on_fail=False, collect_result=False)
+
+                debugger.GetErrorFile().Write(b'\nzork\n')
+
+            with open('output', 'r') as f:
+                errors = f.read()
+                self.assertTrue(re.search(r'error:.*lolwut', errors))
+                self.assertTrue(re.search(r'zork', errors))
+
+        finally:
+            self.RemoveTempFile('output')
+            lldb.SBDebugger.Destroy(debugger)
+
+
+
+    @add_test_categories(['pyapi'])
+    @no_debug_info_test
+    def test_replace_stdout(self):
+        f = io.StringIO()
+        debugger = lldb.SBDebugger.Create()
+        try:
+            with replace_stdout(f):
+                self.assertEqual(sys.stdout, f)
+                handle_command(debugger, 'script sys.stdout.write("lol")',
+                    collect_result=False)
+                self.assertEqual(sys.stdout, f)
+        finally:
+            lldb.SBDebugger.Destroy(debugger)
 

lldb/scripts/interface/SBDebugger.i

public:
     GetInputFileHandle ();
 
     FILE *
     GetOutputFileHandle ();
 
     FILE *
     GetErrorFileHandle ();
 
+    SBError
+    SetInputFile (SBFile file);
+
+    SBError
+    SetOutputFile (SBFile file);
+
+    SBError
+    SetErrorFile (SBFile file);
+
+    SBFile
+    GetInputFile ();
+
+    SBFile
+    GetOutputFile ();
+
+    SBFile
+    GetErrorFile ();
+
     lldb::SBCommandInterpreter
     GetCommandInterpreter ();
 
     void
     HandleCommand (const char *command);
 
     lldb::SBListener
     GetListener ();

lldb/source/API/SBDebugger.cpp

 
 #include "lldb/lldb-private.h"
 
 #include "lldb/API/SBBroadcaster.h"
 #include "lldb/API/SBCommandInterpreter.h"
 #include "lldb/API/SBCommandReturnObject.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBEvent.h"
+#include "lldb/API/SBFile.h"
 #include "lldb/API/SBFrame.h"
 #include "lldb/API/SBListener.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBSourceManager.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBStringList.h"
 #include "lldb/API/SBStructuredData.h"
 #include "lldb/API/SBTarget.h"

 
 // Shouldn't really be settable after initialization as this could cause lots
 // of problems; don't want users trying to switch modes in the middle of a
 // debugging session.
 void SBDebugger::SetInputFileHandle(FILE *fh, bool transfer_ownership) {
   LLDB_RECORD_METHOD(void, SBDebugger, SetInputFileHandle, (FILE *, bool), fh,
                      transfer_ownership);
 
   if (!m_opaque_sp)
     return;
 
   repro::DataRecorder *recorder = nullptr;
   if (repro::Generator *g = repro::Reproducer::Instance().GetGenerator())
     recorder = g->GetOrCreate<repro::CommandProvider>().GetNewDataRecorder();
 
   static std::unique_ptr<repro::CommandLoader> loader =
       repro::CommandLoader::Create(repro::Reproducer::Instance().GetLoader());
   if (loader) {
     llvm::Optional<std::string> file = loader->GetNextFile();
     fh = file ? FileSystem::Instance().Fopen(file->c_str(), "r") : nullptr;
+    transfer_ownership = true;
   }
 
-  m_opaque_sp->SetInputFileHandle(fh, transfer_ownership, recorder);
+  m_opaque_sp->SetInputFile(std::make_shared<File>(fh, transfer_ownership), recorder);
+}
+
+SBError SBDebugger::SetInputFile(SBFile file) {
+  LLDB_RECORD_METHOD(SBError, SBDebugger, SetInputFile, (SBFile), file);
+
+  SBError error;
+  if (!m_opaque_sp) {
+    error.ref().SetErrorString("invalid debugger");
+    return error;
+  }
+
+  repro::DataRecorder *recorder = nullptr;
+  if (repro::Generator *g = repro::Reproducer::Instance().GetGenerator())
+    recorder = g->GetOrCreate<repro::CommandProvider>().GetNewDataRecorder();
+
+  FileSP file_sp = file.m_opaque_sp;
+
+  static std::unique_ptr<repro::CommandLoader> loader =
+      repro::CommandLoader::Create(repro::Reproducer::Instance().GetLoader());
+  if (loader) {
+    llvm::Optional<std::string> nextfile = loader->GetNextFile();
+    FILE *fh = nextfile ? FileSystem::Instance().Fopen(nextfile->c_str(), "r")
+                        : nullptr;
+    if (fh) {
+      file_sp = std::make_shared<File>(fh, true);
+    }
+  }
+
+  error.SetError(m_opaque_sp->SetInputFile(file_sp, recorder));
+  return error;
 }
 
 void SBDebugger::SetOutputFileHandle(FILE *fh, bool transfer_ownership) {
   LLDB_RECORD_METHOD(void, SBDebugger, SetOutputFileHandle, (FILE *, bool), fh,
                      transfer_ownership);
 
-  if (m_opaque_sp)
-    m_opaque_sp->SetOutputFileHandle(fh, transfer_ownership);
+  if (m_opaque_sp) {
+    m_opaque_sp->SetOutputFile(std::make_shared<File>(fh, transfer_ownership));
+  }
+}
+
+SBError SBDebugger::SetOutputFile(SBFile file) {
+  LLDB_RECORD_METHOD(SBError, SBDebugger, SetOutputFile, (SBFile file), file);
+  SBError error;
+  if (!m_opaque_sp) {
+    error.ref().SetErrorString("invalid debugger");
+    return error;
+  }
+  if (!file) {
+    error.ref().SetErrorString("invalid file");
+    return error;
+  }
+  error.SetError(m_opaque_sp->SetOutputFile(file.m_opaque_sp));
+  return error;
 }
 
 void SBDebugger::SetErrorFileHandle(FILE *fh, bool transfer_ownership) {
   LLDB_RECORD_METHOD(void, SBDebugger, SetErrorFileHandle, (FILE *, bool), fh,
                      transfer_ownership);
+  if (m_opaque_sp) {
+    m_opaque_sp->SetErrorFile(std::make_shared<File>(fh, transfer_ownership));
+  }
+}
 
-  if (m_opaque_sp)
-    m_opaque_sp->SetErrorFileHandle(fh, transfer_ownership);
+SBError SBDebugger::SetErrorFile(SBFile file) {
+  LLDB_RECORD_METHOD(SBError, SBDebugger, SetErrorFile, (SBFile file), file);
+  SBError error;
+  if (!m_opaque_sp) {
+    error.ref().SetErrorString("invalid debugger");
+    return error;
+  }
+  if (!file) {
+    error.ref().SetErrorString("invalid file");
+    return error;
+  }
+  error.SetError(m_opaque_sp->SetErrorFile(file.m_opaque_sp));
+  return error;
 }
 
 FILE *SBDebugger::GetInputFileHandle() {
   LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetInputFileHandle);
-
   if (m_opaque_sp) {
     File &file_sp = m_opaque_sp->GetInputFile();
     return LLDB_RECORD_RESULT(file_sp.GetStream());
   }
   return nullptr;
 }
 
+SBFile SBDebugger::GetInputFile() {
+  LLDB_RECORD_METHOD_NO_ARGS(SBFile, SBDebugger, GetInputFile);
+  if (m_opaque_sp) {
+    return LLDB_RECORD_RESULT(SBFile(m_opaque_sp->GetInputFileSP()));
+  }
+  return LLDB_RECORD_RESULT(SBFile());
+}
+
 FILE *SBDebugger::GetOutputFileHandle() {
   LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetOutputFileHandle);
-
   if (m_opaque_sp) {
     StreamFile &stream_file = m_opaque_sp->GetOutputStream();
     return LLDB_RECORD_RESULT(stream_file.GetFile().GetStream());
   }
   return nullptr;
 }
 
+SBFile SBDebugger::GetOutputFile() {
+  LLDB_RECORD_METHOD_NO_ARGS(SBFile, SBDebugger, GetOutputFile);
+  if (m_opaque_sp) {
+    SBFile file(m_opaque_sp->GetOutputStream().GetFileSP());
+    return LLDB_RECORD_RESULT(file);
+  }
+  return LLDB_RECORD_RESULT(SBFile());
+}
+
 FILE *SBDebugger::GetErrorFileHandle() {
   LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetErrorFileHandle);
 
   if (m_opaque_sp) {
     StreamFile &stream_file = m_opaque_sp->GetErrorStream();
     return LLDB_RECORD_RESULT(stream_file.GetFile().GetStream());
   }
   return nullptr;
 }
 
+SBFile SBDebugger::GetErrorFile() {
+  LLDB_RECORD_METHOD_NO_ARGS(SBFile, SBDebugger, GetErrorFile);
+  SBFile file;
+  if (m_opaque_sp) {
+    SBFile file(m_opaque_sp->GetErrorStream().GetFileSP());
+    return LLDB_RECORD_RESULT(file);
+  }
+  return LLDB_RECORD_RESULT(SBFile());
+}
+
 void SBDebugger::SaveInputTerminalState() {
   LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, SaveInputTerminalState);
 
   if (m_opaque_sp)
     m_opaque_sp->SaveInputTerminalState();
 }
 
 void SBDebugger::RestoreInputTerminalState() {
template <> void RegisterMethods<SBInputReader>(Registry &R) {
   LLDB_REGISTER_METHOD(void, SBInputReader, SetIsDone, (bool));
   LLDB_REGISTER_METHOD_CONST(bool, SBInputReader, IsActive, ());
 }
 
 static void SetFileHandleRedirect(SBDebugger *, FILE *, bool) {
   // Do nothing.
 }
 
+static SBError SetFileRedirect(SBDebugger *, SBFile file) { return SBError(); }
+
 static bool GetDefaultArchitectureRedirect(char *arch_name,
                                            size_t arch_name_len) {
   // The function is writing to its argument. Without the redirect it would
   // write into the replay buffer.
   char buffer[1024];
   return SBDebugger::GetDefaultArchitecture(buffer, arch_name_len);
 }
 
 template <> void RegisterMethods<SBDebugger>(Registry &R) {
   // Custom implementation.
   R.Register(&invoke<void (SBDebugger::*)(
                  FILE *, bool)>::method<&SBDebugger::SetErrorFileHandle>::doit,
              &SetFileHandleRedirect);
   R.Register(&invoke<void (SBDebugger::*)(
                  FILE *, bool)>::method<&SBDebugger::SetOutputFileHandle>::doit,
              &SetFileHandleRedirect);
   R.Register<bool(char *, size_t)>(static_cast<bool (*)(char *, size_t)>(
                                        &SBDebugger::GetDefaultArchitecture),
                                    &GetDefaultArchitectureRedirect);
 
+  R.Register(&invoke<SBError (SBDebugger::*)(
+                 SBFile)>::method<&SBDebugger::SetInputFile>::doit,
+             &SetFileRedirect);
+  R.Register(&invoke<SBError (SBDebugger::*)(
+                 SBFile)>::method<&SBDebugger::SetOutputFile>::doit,
+             &SetFileRedirect);
+  R.Register(&invoke<SBError (SBDebugger::*)(
+                 SBFile)>::method<&SBDebugger::SetErrorFile>::doit,
+             &SetFileRedirect);
+
   LLDB_REGISTER_CONSTRUCTOR(SBDebugger, ());
   LLDB_REGISTER_CONSTRUCTOR(SBDebugger, (const lldb::DebuggerSP &));
   LLDB_REGISTER_CONSTRUCTOR(SBDebugger, (const lldb::SBDebugger &));
   LLDB_REGISTER_METHOD(lldb::SBDebugger &,
                        SBDebugger, operator=,(const lldb::SBDebugger &));
   LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Initialize, ());
   LLDB_REGISTER_STATIC_METHOD(lldb::SBError, SBDebugger,
                               InitializeWithErrorHandling, ());
   LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Terminate, ());
   LLDB_REGISTER_METHOD(void, SBDebugger, Clear, ());
   LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, ());
   LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, (bool));
   LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Destroy, (lldb::SBDebugger &));
   LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, MemoryPressureDetected, ());
   LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, IsValid, ());
   LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, operator bool,());
   LLDB_REGISTER_METHOD(void, SBDebugger, SetAsync, (bool));
   LLDB_REGISTER_METHOD(bool, SBDebugger, GetAsync, ());
   LLDB_REGISTER_METHOD(void, SBDebugger, SkipLLDBInitFiles, (bool));
   LLDB_REGISTER_METHOD(void, SBDebugger, SkipAppInitFiles, (bool));
   LLDB_REGISTER_METHOD(void, SBDebugger, SetInputFileHandle, (FILE *, bool));
   LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetInputFileHandle, ());
   LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetOutputFileHandle, ());
   LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetErrorFileHandle, ());
+  LLDB_REGISTER_METHOD(SBFile, SBDebugger, GetInputFile, ());
+  LLDB_REGISTER_METHOD(SBFile, SBDebugger, GetOutputFile, ());
+  LLDB_REGISTER_METHOD(SBFile, SBDebugger, GetErrorFile, ());
   LLDB_REGISTER_METHOD(void, SBDebugger, SaveInputTerminalState, ());
   LLDB_REGISTER_METHOD(void, SBDebugger, RestoreInputTerminalState, ());
   LLDB_REGISTER_METHOD(lldb::SBCommandInterpreter, SBDebugger,
                        GetCommandInterpreter, ());
   LLDB_REGISTER_METHOD(void, SBDebugger, HandleCommand, (const char *));
   LLDB_REGISTER_METHOD(lldb::SBListener, SBDebugger, GetListener, ());
   LLDB_REGISTER_METHOD(
       void, SBDebugger, HandleProcessEvent,

lldb/source/Core/Debugger.cpp

 }
 
 void Debugger::SetAsyncExecution(bool async_execution) {
   m_command_interpreter_up->SetSynchronous(!async_execution);
 }
 
 repro::DataRecorder *Debugger::GetInputRecorder() { return m_input_recorder; }
 
-void Debugger::SetInputFileHandle(FILE *fh, bool tranfer_ownership,
-                                  repro::DataRecorder *recorder) {
+Status Debugger::SetInputFile(FileSP file_sp, repro::DataRecorder *recorder) {
+  Status error;
   m_input_recorder = recorder;
 
-  m_input_file_sp = std::make_shared<File>(fh, tranfer_ownership);
-  if (!m_input_file_sp->IsValid())
+  if (!file_sp || !file_sp->IsValid()) {
     m_input_file_sp = std::make_shared<File>(stdin, false);
+    error.SetErrorString("invalid file");
+  } else {
+    m_input_file_sp = file_sp;
+  }
 
   // Save away the terminal state if that is relevant, so that we can restore
   // it in RestoreInputState.
   SaveInputTerminalState();
+
+  return error;
 }
 
-void Debugger::SetOutputFileHandle(FILE *fh, bool tranfer_ownership) {
-  FileSP file_sp = std::make_shared<File>(fh, tranfer_ownership);
-  if (!file_sp->IsValid())
+Status Debugger::SetOutputFile(FileSP file_sp) {
+  Status error;
+  if (!file_sp || !file_sp->IsValid()) {
     file_sp = std::make_shared<File>(stdout, false);
+    error.SetErrorString("invalid file");
+  }
   m_output_stream_sp = std::make_shared<StreamFile>(file_sp);
-
+  return error;
 }
 
-void Debugger::SetErrorFileHandle(FILE *fh, bool tranfer_ownership) {
-  FileSP file_sp = std::make_shared<File>(fh, tranfer_ownership);
-  if (!file_sp->IsValid())
+Status Debugger::SetErrorFile(FileSP file_sp) {
+  Status error;
+  if (!file_sp || !file_sp->IsValid()) {
     file_sp = std::make_shared<File>(stderr, false);
+    error.SetErrorString("invalid file");
+  }
   m_error_stream_sp = std::make_shared<StreamFile>(file_sp);
+  return error;
 }
 
 void Debugger::SaveInputTerminalState() {
   int fd = GetInputFile().GetDescriptor();
   if (fd != File::kInvalidDescriptor)
     m_terminal_state.Save(fd, true);
 }