remove File::SetStream(), make new files instead.

[lawrence_danna]

Summary

This patch removes File::SetStream() and File::SetDescriptor(),
and replaces most direct uses of File with pointers to File.
Instead of calling SetStream() on a file, we make a new file and
replace it.

My ultimate goal here is to introduce a new API class SBFile, which
has full support for python io.IOStream file objects. These can
redirect read() and write() to python code, so lldb::Files will
need a way to dispatch those methods. Additionally it will need some
form of sharing and assigning files, as a SBFile will be passed in and
assigned to the main IO streams of the debugger.

In my prototype patch queue, I make File itself copyable and add a
secondary class FileOps to manage the sharing and dispatch. In that
case SBFile was a unique_ptr<File>.
(here: https://github.com/smoofra/llvm-project/tree/files)

However in review, Pavel Labath suggested that it be shared_ptr instead.
(here: https://reviews.llvm.org/D67793)

In order for SBFile to use shared_ptr<File>, everything else should
as well.

If this patch is accepted, I will make SBFile use a shared_ptr
I will remove FileOps from future patches and use subclasses of File
instead.

[lawrence_danna]

updated description

[labath]

While I am fully in favour of removing the SetXXX methods, and it does seem like some amount of shared_ptrs will be needed at the (though I don't fully understand your vission yet), I don't really like this proliferation of shared_ptrs everywhere (there's way too many of shared_ptrs in lldb already). I'd like it to be possible to use these APIs in the simplest cases without any shared_ptrs involved. For instance, instead of Status FileSystem::Open(FileSP &, FileSpec, uint32_t, uint32_t, bool), we could have Expected<File> FileSystem::Open(FileSpec, uint32_t, uint32_t, bool) or Expected<std::unique_ptr<File>> FileSystem::Open(FileSpec, uint32_t, uint32_t, bool). The first option would require making the File class movable (so you could write file = File(...) instead of file.SetXXX(...), while the second option would enable fully immutable File objects. Given that we already have File::Close (and ergo, a natural representation for the moved-from state), I'd try to go for the first option.

Could we make changes like that first, and later decide how much shared_ptring needs to be done? One can always convert a non-shared pointer into a shared one, but the other direction is more tricky. In the mean time, I'll respond to the lldb-dev thread you started (thanks for doing that!) to get a better idea of what you're trying to do here.

lldb/include/lldb/Core/Debugger.h

123–131

The lldb_private qualification is superfluous here.

[lawrence_danna]

In D67891#1678933, @labath wrote:

....The first option would require making the File class movable....

I don't think making File movable will work. I'll be wanting a PythonFile subclass, which overrides virtual methods in File. It won't be possible to move one of those into a File variable. I do think the second option, with unique_ptr does make sense.

[lawrence_danna]

converted many uses of shared_ptr<File> into unique_ptr

[lawrence_danna]

@labath How's it look now? I made FileSystem::Open return a unique_ptr, and only convert that over to a shared_ptr where necessary.

[labath]

Yeah, after writing the previous comment, I realized that you'll probably want to subclass File to implement the python stuff (which I agree is a good idea). So, going for unique_ptr<File> is probably the best way forward here. Nonetheless, I still believe the return type of the FileSystem method should be Expected<unique_ptr<File>>, as that is the direction both llvm and lldb is trying to move in (with llvm being much more successful at that, but lldb is making progress too). If it turns out that a lot of the callers are unable to do anything useful with the returned error (with llvm::Expected, you are forced to handle it somehow), we can make a special overload like OpenIngoringErrors which avoids the boilerplate needed to explicitly ignore an error (but I hope that won't be needed).

The other thing is that the interface changes in the Debugger class are causing a lot of churn, which makes it hard to figure out what exactly is changing. Would it be possible to split these out into a separate patch, so that the functional changes are more obvious here?

lldb/source/Host/common/FileSystem.cpp

439–440

once this returns Expected<unique_ptr<File>>, you can do a return llvm::errorCodeToError(std::error_code(errno, std::generic_category())) here.

444–445

I don't think this is really needed as the else branch is guaranteed to return a valid File object, right? (i.e., you could just do return std::make_unique(...) there...)

lldb/source/Interpreter/CommandInterpreter.cpp

2319–2320

the lldb convention would be to name these xxx_up

[lawrence_danna]

converted to Expected<FileUP>, and split into two separate patches

[labath]

Thanks for splitting these up. It makes it much more obvious what is going on.

I see now that you're making use of this SetFile method which I wanted to remove in the previous patch. I kind of like that, because it pushes the Set one level up (so it now happens on the Stream instead of the File), but I do wonder if we shouldn't remove it completely. It seems like we could have Debugger::SetXXXFileHandle just create a fresh stream instead of twiddling with the existing one. This has the potential to change behavior as this change will not propagate to anybody who has fetched the stream_sp previously. However, I'm not sure if this is a change we care about because if anybody was writing to a stream while we were in the process of changing it, then he would likely trigger a race condition anyway. This way, we risk some code not immediately noticing the stream change, but at least we're thread safe. @jingham, what do you think about that?

Other than that, I am pretty happy with how this looks, and I think you've convinced me that the shared pointer inside the StreamFile object is really needed.

[lawrence_danna]

rebased

[lawrence_danna]

@labath how's this one looking? need any changes?

[labath]

looks good to me

lldb/source/Commands/CommandObjectGUI.cpp

32–33

This looks like it would fit on one line. Did you run clang-format?

[lawrence_danna]

clang-format

[lawrence_danna]

style fixes.

[lawrence_danna]

fixed style issues

[lawrence_danna]

updated commit message

lldb/include/lldb/Core/Debugger.h

 #include <stdint.h>
 
 #include <memory>
 #include <vector>
 
 #include "lldb/Core/FormatEntity.h"
 #include "lldb/Core/IOHandler.h"
 #include "lldb/Core/SourceManager.h"
+#include "lldb/Core/StreamFile.h"
 #include "lldb/Core/UserSettingsController.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Host/Terminal.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/TargetList.h"
 #include "lldb/Utility/Broadcaster.h"
 #include "lldb/Utility/ConstString.h"
static bool FormatDisassemblerAddress(const FormatEntity::Entry *format,
                                         const Address *addr, Stream &s);
 
   void Clear();
 
   bool GetAsyncExecution();
 
   void SetAsyncExecution(bool async);
 
-  lldb::StreamFileSP GetInputFile() { return m_input_file_sp; }
+  lldb::FileSP GetInputFileSP() { return m_input_file_sp; }
 
-  lldb::StreamFileSP GetOutputFile() { return m_output_file_sp; }
+  lldb::StreamFileSP GetOutputStreamSP() { return m_output_stream_sp; }
 
-  lldb::StreamFileSP GetErrorFile() { return m_error_file_sp; }
+  lldb::StreamFileSP GetErrorStreamSP() { return m_error_stream_sp; }
+
+  lldb_private::File &GetInputFile() { return *m_input_file_sp; }
+
+  lldb_private::File &GetOutputFile() { return m_output_stream_sp->GetFile(); }
+
+  lldb_private::File &GetErrorFile() { return m_error_stream_sp->GetFile(); }
+
+  lldb_private::StreamFile &GetOutputStream() { return *m_output_stream_sp; }
+
+  lldb_private::StreamFile &GetErrorStream() { return *m_error_stream_sp; }
 
   repro::DataRecorder *GetInputRecorder();
 
   void SetInputFileHandle(FILE *fh, bool tranfer_ownership,
                           repro::DataRecorder *recorder = nullptr);
 
   void SetOutputFileHandle(FILE *fh, bool tranfer_ownership);
 
public:
   PlatformList &GetPlatformList() { return m_platform_list; }
 
   void DispatchInputInterrupt();
 
   void DispatchInputEndOfFile();
 
   // If any of the streams are not set, set them to the in/out/err stream of
   // the top most input reader to ensure they at least have something
-  void AdoptTopIOHandlerFilesIfInvalid(lldb::StreamFileSP &in,
+  void AdoptTopIOHandlerFilesIfInvalid(lldb::FileSP &in,
                                        lldb::StreamFileSP &out,
                                        lldb::StreamFileSP &err);
 
   void PushIOHandler(const lldb::IOHandlerSP &reader_sp,
                      bool cancel_top_handler = true);
 
   bool PopIOHandler(const lldb::IOHandlerSP &reader_sp);
 
void FlushProcessOutput(Process &process, bool flush_stdout,
                           bool flush_stderr);
 
   SourceManager::SourceFileCache &GetSourceFileCache() {
     return m_source_file_cache;
   }
 
   void InstanceInitialize();
 
-  lldb::StreamFileSP m_input_file_sp;
-  lldb::StreamFileSP m_output_file_sp;
-  lldb::StreamFileSP m_error_file_sp;
+  // these should never be NULL
+  lldb::FileSP m_input_file_sp;
+  lldb::StreamFileSP m_output_stream_sp;
+  lldb::StreamFileSP m_error_stream_sp;
 
   /// Used for shadowing the input file when capturing a reproducer.
   repro::DataRecorder *m_input_recorder;
 
   lldb::BroadcasterManagerSP m_broadcaster_manager_sp; // The debugger acts as a
                                                        // broadcaster manager of
                                                        // last resort.
   // It needs to get constructed before the target_list or any other member

lldb/include/lldb/Core/IOHandler.h

enum class Type {
     PythonInterpreter,
     PythonCode,
     Other
   };
 
   IOHandler(Debugger &debugger, IOHandler::Type type);
 
   IOHandler(Debugger &debugger, IOHandler::Type type,
-            const lldb::StreamFileSP &input_sp,
-            const lldb::StreamFileSP &output_sp,
+            const lldb::FileSP &input_sp, const lldb::StreamFileSP &output_sp,
             const lldb::StreamFileSP &error_sp, uint32_t flags,
             repro::DataRecorder *data_recorder);
 
   virtual ~IOHandler();
 
   // Each IOHandler gets to run until it is done. It should read data from the
   // "in" and place output into "out" and "err and return when done.
   virtual void Run() = 0;
public:
   int GetErrorFD();
 
   FILE *GetInputFILE();
 
   FILE *GetOutputFILE();
 
   FILE *GetErrorFILE();
 
-  lldb::StreamFileSP &GetInputStreamFile();
+  lldb::FileSP &GetInputFileSP();
 
-  lldb::StreamFileSP &GetOutputStreamFile();
+  lldb::StreamFileSP &GetOutputStreamFileSP();
 
-  lldb::StreamFileSP &GetErrorStreamFile();
+  lldb::StreamFileSP &GetErrorStreamFileSP();
 
   Debugger &GetDebugger() { return m_debugger; }
 
   void *GetUserData() { return m_user_data; }
 
   void SetUserData(void *user_data) { m_user_data = user_data; }
 
   Flags &GetFlags() { return m_flags; }
public:
 
   virtual void PrintAsync(Stream *stream, const char *s, size_t len) {
     stream->Write(s, len);
     stream->Flush();
   }
 
 protected:
   Debugger &m_debugger;
-  lldb::StreamFileSP m_input_sp;
+  lldb::FileSP m_input_sp;
   lldb::StreamFileSP m_output_sp;
   lldb::StreamFileSP m_error_sp;
   repro::DataRecorder *m_data_recorder;
   Predicate<bool> m_popped;
   Flags m_flags;
   Type m_type;
   void *m_user_data;
   bool m_done;
IOHandlerEditline(Debugger &debugger, IOHandler::Type type,
                     bool multi_line, bool color_prompts,
                     uint32_t line_number_start, // If non-zero show line numbers
                                                 // starting at
                                                 // 'line_number_start'
                     IOHandlerDelegate &delegate,
                     repro::DataRecorder *data_recorder);
 
   IOHandlerEditline(Debugger &debugger, IOHandler::Type type,
-                    const lldb::StreamFileSP &input_sp,
+                    const lldb::FileSP &input_sp,
                     const lldb::StreamFileSP &output_sp,
                     const lldb::StreamFileSP &error_sp, uint32_t flags,
                     const char *editline_name, // Used for saving history files
                     llvm::StringRef prompt, llvm::StringRef continuation_prompt,
                     bool multi_line, bool color_prompts,
                     uint32_t line_number_start, // If non-zero show line numbers
                                                 // starting at
                                                 // 'line_number_start'
                     IOHandlerDelegate &delegate,
                     repro::DataRecorder *data_recorder);
 
   IOHandlerEditline(Debugger &, IOHandler::Type, const char *, const char *,
                     const char *, bool, bool, uint32_t,
                     IOHandlerDelegate &) = delete;
 
-  IOHandlerEditline(Debugger &, IOHandler::Type, const lldb::StreamFileSP &,
+  IOHandlerEditline(Debugger &, IOHandler::Type, const lldb::FileSP &,
                     const lldb::StreamFileSP &, const lldb::StreamFileSP &,
                     uint32_t, const char *, const char *, const char *, bool,
                     bool, uint32_t, IOHandlerDelegate &) = delete;
 
   ~IOHandlerEditline() override;
 
   void Run() override;
 

lldb/include/lldb/Core/StreamFile.h

public:
 
   StreamFile(const char *path);
 
   StreamFile(const char *path, uint32_t options,
              uint32_t permissions = lldb::eFilePermissionsFileDefault);
 
   StreamFile(FILE *fh, bool transfer_ownership);
 
+  StreamFile(std::shared_ptr<File> file) : StreamFile() { SetFile(file); }
+
   ~StreamFile() override;
 
-  File &GetFile() { return m_file; }
+  File &GetFile() { return *m_file_sp; }
+
+  const File &GetFile() const { return *m_file_sp; }
+
+  std::shared_ptr<File> GetFileSP() { return m_file_sp; }
 
-  const File &GetFile() const { return m_file; }
+  void SetFile(std::shared_ptr<File> file) {
+    if (file)
+      m_file_sp = file;
+    else
+      m_file_sp = std::make_shared<File>();
+  }
 
   void Flush() override;
 
 
 protected:
   // Classes that inherit from StreamFile can see and modify these
-  File m_file;
+  std::shared_ptr<File> m_file_sp; // never NULL
   size_t WriteImpl(const void *s, size_t length) override;
 
 private:
   DISALLOW_COPY_AND_ASSIGN(StreamFile);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_StreamFile_h_

lldb/include/lldb/Host/File.h

public:
   Status Close() override;
 
   void Clear();
 
   int GetDescriptor() const;
 
   WaitableHandle GetWaitableHandle() override;
 
-  void SetDescriptor(int fd, uint32_t options, bool transfer_ownership);
-
   FILE *GetStream();
 
-  void SetStream(FILE *fh, bool transfer_ownership);
-
   /// Read bytes from a file from the current file position.
   ///
   /// NOTE: This function is NOT thread safe. Use the read function
   /// that takes an "off_t &offset" to ensure correct operation in multi-
   /// threaded environments.
   ///
   /// \param[in] buf
   ///     A buffer where to put the bytes that are read.

lldb/include/lldb/Host/FileSystem.h

public:
   Status ResolveSymbolicLink(const FileSpec &src, FileSpec &dst);
 
   /// Wraps ::fopen in a platform-independent way.
   FILE *Fopen(const char *path, const char *mode);
 
   /// Wraps ::open in a platform-independent way.
   int Open(const char *path, int flags, int mode);
 
-  Status Open(File &File, const FileSpec &file_spec, uint32_t options,
+  // file will be set to null if there's an error.
+  Status Open(std::shared_ptr<File> &file, const FileSpec &file_spec,
+              uint32_t options,
               uint32_t permissions = lldb::eFilePermissionsFileDefault,
               bool should_close_fd = true);
 
   /// Get a directory iterator.
   /// \{
   llvm::vfs::directory_iterator DirBegin(const FileSpec &file_spec,
                                          std::error_code &ec);
   llvm::vfs::directory_iterator DirBegin(const llvm::Twine &dir,

lldb/scripts/Python/python-typemaps.swig

else if (!lldb_private::PythonFile::Check($input)) {
       } else {
          PyErr_SetString(PyExc_TypeError,"not a file-like object");
          return nullptr;
       }
    }
    else
    {
       PythonFile py_file(PyRefType::Borrowed, $input);
-      File file;
+      lldb::FileSP file;
       if (!py_file.GetUnderlyingFile(file))
          return nullptr;
 
-      $1 = file.GetStream();
+      $1 = file->GetStream();
       if ($1)
-         file.Clear();
+         file->Clear();
     }
 }
 
 %typemap(out) FILE * {
    char mode[4] = {0};
 %#ifdef __APPLE__
    int i = 0;
    if ($1)

lldb/source/API/SBDebugger.cpp

void SBDebugger::SetErrorFileHandle(FILE *fh, bool transfer_ownership) {
   if (m_opaque_sp)
     m_opaque_sp->SetErrorFileHandle(fh, transfer_ownership);
 }
 
 FILE *SBDebugger::GetInputFileHandle() {
   LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetInputFileHandle);
 
   if (m_opaque_sp) {
-    StreamFileSP stream_file_sp(m_opaque_sp->GetInputFile());
-    if (stream_file_sp)
-      return LLDB_RECORD_RESULT(stream_file_sp->GetFile().GetStream());
+    File &file_sp = m_opaque_sp->GetInputFile();
+    return LLDB_RECORD_RESULT(file_sp.GetStream());
   }
   return nullptr;
 }
 
 FILE *SBDebugger::GetOutputFileHandle() {
   LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetOutputFileHandle);
 
   if (m_opaque_sp) {
-    StreamFileSP stream_file_sp(m_opaque_sp->GetOutputFile());
-    if (stream_file_sp)
-      return LLDB_RECORD_RESULT(stream_file_sp->GetFile().GetStream());
+    StreamFile &stream_file = m_opaque_sp->GetOutputStream();
+    return LLDB_RECORD_RESULT(stream_file.GetFile().GetStream());
   }
   return nullptr;
 }
 
 FILE *SBDebugger::GetErrorFileHandle() {
   LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetErrorFileHandle);
 
   if (m_opaque_sp) {
-    StreamFileSP stream_file_sp(m_opaque_sp->GetErrorFile());
-    if (stream_file_sp)
-      return LLDB_RECORD_RESULT(stream_file_sp->GetFile().GetStream());
+    StreamFile &stream_file = m_opaque_sp->GetErrorStream();
+    return LLDB_RECORD_RESULT(stream_file.GetFile().GetStream());
   }
   return nullptr;
 }
 
 void SBDebugger::SaveInputTerminalState() {
   LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, SaveInputTerminalState);
 
   if (m_opaque_sp)

lldb/source/API/SBStream.cpp

void SBStream::RedirectToFile(const char *path, bool append) {
   }
   StreamFile *stream_file = new StreamFile;
   uint32_t open_options = File::eOpenOptionWrite | File::eOpenOptionCanCreate;
   if (append)
     open_options |= File::eOpenOptionAppend;
   else
     open_options |= File::eOpenOptionTruncate;
 
-  FileSystem::Instance().Open(stream_file->GetFile(), FileSpec(path),
-                              open_options);
+  FileSP file;
+  FileSystem::Instance().Open(file, FileSpec(path), open_options);
+  stream_file->SetFile(file);
   m_opaque_up.reset(stream_file);
 
   if (m_opaque_up) {
     m_is_file = true;
 
     // If we had any data locally in our StreamString, then pass that along to
     // the to new file we are redirecting to.
     if (!local_data.empty())

lldb/source/Commands/CommandObjectBreakpointCommand.cpp

are no syntax errors may indicate that a function was declared but never called.");
     m_arguments.push_back(arg);
   }
 
   ~CommandObjectBreakpointCommandAdd() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
   void IOHandlerActivated(IOHandler &io_handler, bool interactive) override {
-    StreamFileSP output_sp(io_handler.GetOutputStreamFile());
+    StreamFileSP output_sp(io_handler.GetOutputStreamFileSP());
     if (output_sp && interactive) {
       output_sp->PutCString(g_reader_instructions);
       output_sp->Flush();
     }
   }
 
   void IOHandlerInputComplete(IOHandler &io_handler,
                               std::string &line) override {

lldb/source/Commands/CommandObjectCommands.cpp

a number follows 'f':"
 
     (lldb) command regex f s/^$/finish/ 's/([0-9]+)/frame select %1/')");
   }
 
   ~CommandObjectCommandsAddRegex() override = default;
 
 protected:
   void IOHandlerActivated(IOHandler &io_handler, bool interactive) override {
-    StreamFileSP output_sp(io_handler.GetOutputStreamFile());
+    StreamFileSP output_sp(io_handler.GetOutputStreamFileSP());
     if (output_sp && interactive) {
       output_sp->PutCString("Enter one or more sed substitution commands in "
                             "the form: 's/<regex>/<subst>/'.\nTerminate the "
                             "substitution list with an empty line.\n");
       output_sp->Flush();
     }
   }
 
public:
 
     std::string m_class_name;
     std::string m_funct_name;
     std::string m_short_help;
     ScriptedCommandSynchronicity m_synchronicity;
   };
 
   void IOHandlerActivated(IOHandler &io_handler, bool interactive) override {
-    StreamFileSP output_sp(io_handler.GetOutputStreamFile());
+    StreamFileSP output_sp(io_handler.GetOutputStreamFileSP());
     if (output_sp && interactive) {
       output_sp->PutCString(g_python_command_instructions);
       output_sp->Flush();
     }
   }
 
   void IOHandlerInputComplete(IOHandler &io_handler,
                               std::string &data) override {
-    StreamFileSP error_sp = io_handler.GetErrorStreamFile();
+    StreamFileSP error_sp = io_handler.GetErrorStreamFileSP();
 
     ScriptInterpreter *interpreter = GetDebugger().GetScriptInterpreter();
     if (interpreter) {
 
       StringList lines;
       lines.SplitIntoLines(data);
       if (lines.GetSize() > 0) {
         std::string funct_name_str;

lldb/source/Commands/CommandObjectExpression.cpp

 }
 
 void CommandObjectExpression::IOHandlerInputComplete(IOHandler &io_handler,
                                                      std::string &line) {
   io_handler.SetIsDone(true);
   //    StreamSP output_stream =
   //    io_handler.GetDebugger().GetAsyncOutputStream();
   //    StreamSP error_stream = io_handler.GetDebugger().GetAsyncErrorStream();
-  StreamFileSP output_sp(io_handler.GetOutputStreamFile());
-  StreamFileSP error_sp(io_handler.GetErrorStreamFile());
+  StreamFileSP output_sp = io_handler.GetOutputStreamFileSP();
+  StreamFileSP error_sp = io_handler.GetErrorStreamFileSP();
 
   EvaluateExpression(line.c_str(), output_sp.get(), error_sp.get());
   if (output_sp)
     output_sp->Flush();
   if (error_sp)
     error_sp->Flush();
 }
 
IOHandlerSP io_handler_sp(
       new IOHandlerEditline(debugger, IOHandler::Type::Expression,
                             "lldb-expr", // Name of input reader for history
                             llvm::StringRef(), // No prompt
                             llvm::StringRef(), // Continuation prompt
                             multiple_lines, color_prompt,
                             1, // Show line numbers starting at 1
                             *this, nullptr));
 
-  StreamFileSP output_sp(io_handler_sp->GetOutputStreamFile());
+  StreamFileSP output_sp = io_handler_sp->GetOutputStreamFileSP();
   if (output_sp) {
     output_sp->PutCString(
         "Enter expressions, then terminate with an empty line to evaluate:\n");
     output_sp->Flush();
   }
   debugger.PushIOHandler(io_handler_sp);
 }
 

lldb/source/Commands/CommandObjectGUI.cpp

 
 CommandObjectGUI::~CommandObjectGUI() {}
 
 bool CommandObjectGUI::DoExecute(Args &args, CommandReturnObject &result) {
 #ifndef LLDB_DISABLE_CURSES
   if (args.GetArgumentCount() == 0) {
     Debugger &debugger = GetDebugger();
 
-    lldb::StreamFileSP input_sp = debugger.GetInputFile();
-    if (input_sp && input_sp->GetFile().GetIsRealTerminal() &&
-        input_sp->GetFile().GetIsInteractive()) {
+    File &input = debugger.GetInputFile();
+    if (input.GetIsRealTerminal() &&
+        input.GetIsInteractive()) {
       IOHandlerSP io_handler_sp(new IOHandlerCursesGUI(debugger));
       if (io_handler_sp)
         debugger.PushIOHandler(io_handler_sp);
       result.SetStatus(eReturnStatusSuccessFinishResult);
     } else {
       result.AppendError("the gui command requires an interactive terminal.");
       result.SetStatus(eReturnStatusFailed);
     }

lldb/source/Commands/CommandObjectMemory.cpp

#undef ALL_KEYWORDS
     if (outfile_spec) {
 
       uint32_t open_options =
           File::eOpenOptionWrite | File::eOpenOptionCanCreate;
       const bool append = m_outfile_options.GetAppend().GetCurrentValue();
       if (append)
         open_options |= File::eOpenOptionAppend;
 
-      Status error = FileSystem::Instance().Open(outfile_stream.GetFile(),
-                                                 outfile_spec, open_options);
+      FileSP file;
+      Status error =
+          FileSystem::Instance().Open(file, outfile_spec, open_options);
+      outfile_stream.SetFile(file);
+
       if (error.Success()) {
         if (m_memory_options.m_output_as_binary) {
           const size_t bytes_written =
               outfile_stream.Write(data_sp->GetBytes(), bytes_read);
           if (bytes_written > 0) {
             result.GetOutputStream().Printf(
                 "%zi bytes %s to '%s'\n", bytes_written,
                 append ? "appended" : "written", path.c_str());

lldb/source/Commands/CommandObjectTarget.cpp

CommandObjectTargetStopHookAdd(CommandInterpreter &interpreter)
         m_options() {}
 
   ~CommandObjectTargetStopHookAdd() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
 protected:
   void IOHandlerActivated(IOHandler &io_handler, bool interactive) override {
-    StreamFileSP output_sp(io_handler.GetOutputStreamFile());
+    StreamFileSP output_sp(io_handler.GetOutputStreamFileSP());
     if (output_sp && interactive) {
       output_sp->PutCString(
           "Enter your stop hook command(s).  Type 'DONE' to end.\n");
       output_sp->Flush();
     }
   }
 
   void IOHandlerInputComplete(IOHandler &io_handler,
                               std::string &line) override {
     if (m_stop_hook_sp) {
       if (line.empty()) {
-        StreamFileSP error_sp(io_handler.GetErrorStreamFile());
+        StreamFileSP error_sp(io_handler.GetErrorStreamFileSP());
         if (error_sp) {
           error_sp->Printf("error: stop hook #%" PRIu64
                            " aborted, no commands.\n",
                            m_stop_hook_sp->GetID());
           error_sp->Flush();
         }
         Target *target = GetDebugger().GetSelectedTarget().get();
         if (target)
           target->RemoveStopHookByID(m_stop_hook_sp->GetID());
       } else {
         m_stop_hook_sp->GetCommandPointer()->SplitIntoLines(line);
-        StreamFileSP output_sp(io_handler.GetOutputStreamFile());
+        StreamFileSP output_sp(io_handler.GetOutputStreamFileSP());
         if (output_sp) {
           output_sp->Printf("Stop hook #%" PRIu64 " added.\n",
                             m_stop_hook_sp->GetID());
           output_sp->Flush();
         }
       }
       m_stop_hook_sp.reset();
     }

lldb/source/Commands/CommandObjectType.cpp

public:
   void IOHandlerActivated(IOHandler &io_handler, bool interactive) override {
     static const char *g_summary_addreader_instructions =
         "Enter your Python command(s). Type 'DONE' to end.\n"
         "def function (valobj,internal_dict):\n"
         "     \"\"\"valobj: an SBValue which you want to provide a summary "
         "for\n"
         "        internal_dict: an LLDB support object not to be used\"\"\"\n";
 
-    StreamFileSP output_sp(io_handler.GetOutputStreamFile());
+    StreamFileSP output_sp(io_handler.GetOutputStreamFileSP());
     if (output_sp && interactive) {
       output_sp->PutCString(g_summary_addreader_instructions);
       output_sp->Flush();
     }
   }
 
   void IOHandlerInputComplete(IOHandler &io_handler,
                               std::string &data) override {
-    StreamFileSP error_sp = io_handler.GetErrorStreamFile();
+    StreamFileSP error_sp = io_handler.GetErrorStreamFileSP();
 
 #ifndef LLDB_DISABLE_PYTHON
     ScriptInterpreter *interpreter = GetDebugger().GetScriptInterpreter();
     if (interpreter) {
       StringList lines;
       lines.SplitIntoLines(data);
       if (lines.GetSize() > 0) {
         ScriptAddOptions *options_ptr =
else {
                          "name, or use -P and type a Python class "
                          "line-by-line");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
   }
 
   void IOHandlerActivated(IOHandler &io_handler, bool interactive) override {
-    StreamFileSP output_sp(io_handler.GetOutputStreamFile());
+    StreamFileSP output_sp(io_handler.GetOutputStreamFileSP());
     if (output_sp && interactive) {
       output_sp->PutCString(g_synth_addreader_instructions);
       output_sp->Flush();
     }
   }
 
   void IOHandlerInputComplete(IOHandler &io_handler,
                               std::string &data) override {
-    StreamFileSP error_sp = io_handler.GetErrorStreamFile();
+    StreamFileSP error_sp = io_handler.GetErrorStreamFileSP();
 
 #ifndef LLDB_DISABLE_PYTHON
     ScriptInterpreter *interpreter = GetDebugger().GetScriptInterpreter();
     if (interpreter) {
       StringList lines;
       lines.SplitIntoLines(data);
       if (lines.GetSize() > 0) {
         SynthAddOptions *options_ptr =

lldb/source/Commands/CommandObjectWatchpointCommand.cpp

are no syntax errors may indicate that a function was declared but never called.");
     m_arguments.push_back(arg);
   }
 
   ~CommandObjectWatchpointCommandAdd() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
   void IOHandlerActivated(IOHandler &io_handler, bool interactive) override {
-    StreamFileSP output_sp(io_handler.GetOutputStreamFile());
+    StreamFileSP output_sp(io_handler.GetOutputStreamFileSP());
     if (output_sp && interactive) {
       output_sp->PutCString(
           "Enter your debugger command(s).  Type 'DONE' to end.\n");
       output_sp->Flush();
     }
   }
 
   void IOHandlerInputComplete(IOHandler &io_handler,

lldb/source/Core/Debugger.cpp

if (property_path == g_debugger_properties[ePropertyPrompt].name) {
       SetPrompt(GetPrompt());
     } else if (is_load_script && target_sp &&
                load_script_old_value == eLoadScriptFromSymFileWarn) {
       if (target_sp->TargetProperties::GetLoadScriptFromSymbolFile() ==
           eLoadScriptFromSymFileTrue) {
         std::list<Status> errors;
         StreamString feedback_stream;
         if (!target_sp->LoadScriptingResources(errors, &feedback_stream)) {
-          StreamFileSP stream_sp(GetErrorFile());
-          if (stream_sp) {
-            for (auto error : errors) {
-              stream_sp->Printf("%s\n", error.AsCString());
-            }
-            if (feedback_stream.GetSize())
-              stream_sp->PutCString(feedback_stream.GetString());
-          }
+          Stream &s = GetErrorStream();
+            s.Printf("%s\n", error.AsCString());
+            s.PutCString(feedback_stream.GetString());
         }
       }
     }
   }
   return error;
 }
 
 bool Debugger::GetAutoConfirm() const {
if (g_debugger_list_ptr && g_debugger_list_mutex_ptr) {
     }
   }
   return target_sp;
 }
 
 Debugger::Debugger(lldb::LogOutputCallback log_callback, void *baton)
     : UserID(g_unique_id++),
       Properties(std::make_shared<OptionValueProperties>()),
-      m_input_file_sp(std::make_shared<StreamFile>(stdin, false)),
-      m_output_file_sp(std::make_shared<StreamFile>(stdout, false)),
-      m_error_file_sp(std::make_shared<StreamFile>(stderr, false)),
+      m_input_file_sp(std::make_shared<File>(stdin, false)),
+      m_output_stream_sp(std::make_shared<StreamFile>(stdout, false)),
+      m_error_stream_sp(std::make_shared<StreamFile>(stderr, false)),
       m_input_recorder(nullptr),
       m_broadcaster_manager_sp(BroadcasterManager::MakeBroadcasterManager()),
       m_terminal_state(), m_target_list(*this), m_platform_list(),
       m_listener_sp(Listener::MakeListener("lldb.Debugger")),
       m_source_manager_up(), m_source_file_cache(),
       m_command_interpreter_up(
           std::make_unique<CommandInterpreter>(*this, false)),
       m_script_interpreter_sp(), m_input_reader_stack(), m_instance_name(),
Debugger::Debugger(lldb::LogOutputCallback log_callback, void *baton)
   term_width->SetMinimumValue(10);
   term_width->SetMaximumValue(1024);
 
   // Turn off use-color if this is a dumb terminal.
   const char *term = getenv("TERM");
   if (term && !strcmp(term, "dumb"))
     SetUseColor(false);
   // Turn off use-color if we don't write to a terminal with color support.
-  if (!m_output_file_sp->GetFile().GetIsTerminalWithColors())
+  if (!GetOutputFile().GetIsTerminalWithColors())
     SetUseColor(false);
 
 #if defined(_WIN32) && defined(ENABLE_VIRTUAL_TERMINAL_PROCESSING)
   // Enabling use of ANSI color codes because LLDB is using them to highlight
   // text.
   llvm::sys::Process::UseANSIEscapeCodes(true);
 #endif
 }
for (int i = 0; i < num_targets; i++) {
         target_sp->Destroy();
       }
     }
     m_broadcaster_manager_sp->Clear();
 
     // Close the input file _before_ we close the input read communications
     // class as it does NOT own the input file, our m_input_file does.
     m_terminal_state.Clear();
-    if (m_input_file_sp)
-      m_input_file_sp->GetFile().Close();
+    GetInputFile().Close();
 
     m_command_interpreter_up->Clear();
   });
 }
 
 bool Debugger::GetCloseInputOnEOF() const {
   //    return m_input_comm.GetCloseOnEOF();
   return false;
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) {
   m_input_recorder = recorder;
-  if (m_input_file_sp)
-    m_input_file_sp->GetFile().SetStream(fh, tranfer_ownership);
-  else
-    m_input_file_sp = std::make_shared<StreamFile>(fh, tranfer_ownership);
 
-  File &in_file = m_input_file_sp->GetFile();
-  if (!in_file.IsValid())
-    in_file.SetStream(stdin, true);
+  m_input_file_sp = std::make_shared<File>(fh, tranfer_ownership);
+  if (!m_input_file_sp->IsValid())
+    m_input_file_sp = std::make_shared<File>(stdin, false);
 
   // Save away the terminal state if that is relevant, so that we can restore
   // it in RestoreInputState.
   SaveInputTerminalState();
 }
 
 void Debugger::SetOutputFileHandle(FILE *fh, bool tranfer_ownership) {
-  if (m_output_file_sp)
-    m_output_file_sp->GetFile().SetStream(fh, tranfer_ownership);
-  else
-    m_output_file_sp = std::make_shared<StreamFile>(fh, tranfer_ownership);
 
-  File &out_file = m_output_file_sp->GetFile();
-  if (!out_file.IsValid())
-    out_file.SetStream(stdout, false);
+  GetOutputStream().SetFile(std::make_shared<File>(fh, tranfer_ownership));
+  if (!GetOutputFile())
+    GetOutputStream().SetFile(std::make_shared<File>(stdout, false));
 
   // Do not create the ScriptInterpreter just for setting the output file
   // handle as the constructor will know how to do the right thing on its own.
   if (ScriptInterpreter *script_interpreter =
           GetScriptInterpreter(/*can_create=*/false))
     script_interpreter->ResetOutputFileHandle(fh);
 }
 
 void Debugger::SetErrorFileHandle(FILE *fh, bool tranfer_ownership) {
-  if (m_error_file_sp)
-    m_error_file_sp->GetFile().SetStream(fh, tranfer_ownership);
-  else
-    m_error_file_sp = std::make_shared<StreamFile>(fh, tranfer_ownership);
-
-  File &err_file = m_error_file_sp->GetFile();
-  if (!err_file.IsValid())
-    err_file.SetStream(stderr, false);
+  GetErrorStream().SetFile(std::make_shared<File>(fh, tranfer_ownership));
+  if (!GetErrorFile())
+    GetErrorStream().SetFile(std::make_shared<File>(stderr, false));
 }
 
 void Debugger::SaveInputTerminalState() {
-  if (m_input_file_sp) {
-    File &in_file = m_input_file_sp->GetFile();
-    if (in_file.GetDescriptor() != File::kInvalidDescriptor)
-      m_terminal_state.Save(in_file.GetDescriptor(), true);
-  }
+  int fd = GetInputFile().GetDescriptor();
+  if (fd != File::kInvalidDescriptor)
+    m_terminal_state.Save(fd, true);
 }
 
 void Debugger::RestoreInputTerminalState() { m_terminal_state.Restore(); }
 
 ExecutionContext Debugger::GetSelectedExecutionContext() {
   ExecutionContext exe_ctx;
   TargetSP target_sp(GetSelectedTarget());
   exe_ctx.SetTargetSP(target_sp);

 }
 
 bool Debugger::CheckTopIOHandlerTypes(IOHandler::Type top_type,
                                       IOHandler::Type second_top_type) {
   return m_input_reader_stack.CheckTopIOHandlerTypes(top_type, second_top_type);
 }
 
 void Debugger::PrintAsync(const char *s, size_t len, bool is_stdout) {
-  lldb::StreamFileSP stream = is_stdout ? GetOutputFile() : GetErrorFile();
-  m_input_reader_stack.PrintAsync(stream.get(), s, len);
+  lldb_private::StreamFile &stream =
+      is_stdout ? GetOutputStream() : GetErrorStream();
+  m_input_reader_stack.PrintAsync(&stream, s, len);
 }
 
 ConstString Debugger::GetTopIOHandlerControlSequence(char ch) {
   return m_input_reader_stack.GetTopIOHandlerControlSequence(ch);
 }
 
 const char *Debugger::GetIOHandlerCommandPrefix() {
   return m_input_reader_stack.GetTopIOHandlerCommandPrefix();
while (true) {
       if (top_reader_sp && top_reader_sp->GetIsDone())
         PopIOHandler(top_reader_sp);
       else
         break;
     }
   }
 }
 
-void Debugger::AdoptTopIOHandlerFilesIfInvalid(StreamFileSP &in,
-                                               StreamFileSP &out,
+void Debugger::AdoptTopIOHandlerFilesIfInvalid(FileSP &in, StreamFileSP &out,
                                                StreamFileSP &err) {
   // Before an IOHandler runs, it must have in/out/err streams. This function
   // is called when one ore more of the streams are nullptr. We use the top
   // input reader's in/out/err streams, or fall back to the debugger file
   // handles, or we fall back onto stdin/stdout/stderr as a last resort.
 
   std::lock_guard<std::recursive_mutex> guard(m_input_reader_stack.GetMutex());
   IOHandlerSP top_reader_sp(m_input_reader_stack.Top());
   // If no STDIN has been set, then set it appropriately
   if (!in) {
     if (top_reader_sp)
-      in = top_reader_sp->GetInputStreamFile();
+      in = top_reader_sp->GetInputFileSP();
     else
-      in = GetInputFile();
+      in = GetInputFileSP();
 
     // If there is nothing, use stdin
     if (!in)
-      in = std::make_shared<StreamFile>(stdin, false);
+      in = std::make_shared<File>(stdin, false);
   }
   // If no STDOUT has been set, then set it appropriately
   if (!out) {
     if (top_reader_sp)
-      out = top_reader_sp->GetOutputStreamFile();
+      out = top_reader_sp->GetOutputStreamFileSP();
     else
-      out = GetOutputFile();
+      out = GetOutputStreamSP();
 
     // If there is nothing, use stdout
     if (!out)
       out = std::make_shared<StreamFile>(stdout, false);
   }
   // If no STDERR has been set, then set it appropriately
   if (!err) {
     if (top_reader_sp)
-      err = top_reader_sp->GetErrorStreamFile();
+      err = top_reader_sp->GetErrorStreamFileSP();
     else
-      err = GetErrorFile();
+      err = GetErrorStreamSP();
 
     // If there is nothing, use stderr
     if (!err)
-      err = std::make_shared<StreamFile>(stdout, false);
+      err = std::make_shared<StreamFile>(stderr, false);
   }
 }
 
 void Debugger::PushIOHandler(const IOHandlerSP &reader_sp,
                              bool cancel_top_handler) {
   if (!reader_sp)
     return;
 
bool Debugger::EnableLog(llvm::StringRef channel,
   std::shared_ptr<llvm::raw_ostream> log_stream_sp;
   if (m_log_callback_stream_sp) {
     log_stream_sp = m_log_callback_stream_sp;
     // For now when using the callback mode you always get thread & timestamp.
     log_options |=
         LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME;
   } else if (log_file.empty()) {
     log_stream_sp = std::make_shared<llvm::raw_fd_ostream>(
-        GetOutputFile()->GetFile().GetDescriptor(), !should_close, unbuffered);
+        GetOutputFile().GetDescriptor(), !should_close, unbuffered);
   } else {
     auto pos = m_log_streams.find(log_file);
     if (pos != m_log_streams.end())
       log_stream_sp = pos->second.lock();
     if (!log_stream_sp) {
       llvm::sys::fs::OpenFlags flags = llvm::sys::fs::OF_Text;
       if (log_options & LLDB_LOG_OPTION_APPEND)
         flags |= llvm::sys::fs::OF_Append;
if (io_handler_thread) {
                llvm::toString(io_handler_thread.takeError()));
     }
   }
   return m_io_handler_thread.IsJoinable();
 }
 
 void Debugger::StopIOHandlerThread() {
   if (m_io_handler_thread.IsJoinable()) {
-    if (m_input_file_sp)
-      m_input_file_sp->GetFile().Close();
+    GetInputFile().Close();
     m_io_handler_thread.Join(nullptr);
   }
 }
 
 void Debugger::JoinIOHandlerThread() {
   if (HasIOHandlerThread()) {
     thread_result_t result;
     m_io_handler_thread.Join(&result);

lldb/source/Core/IOHandler.cpp

 #include <string.h>
 #include <type_traits>
 
 using namespace lldb;
 using namespace lldb_private;
 
 IOHandler::IOHandler(Debugger &debugger, IOHandler::Type type)
     : IOHandler(debugger, type,
-                StreamFileSP(), // Adopt STDIN from top input reader
+                FileSP(),       // Adopt STDIN from top input reader
                 StreamFileSP(), // Adopt STDOUT from top input reader
                 StreamFileSP(), // Adopt STDERR from top input reader
                 0,              // Flags
                 nullptr         // Shadow file recorder
       ) {}
 
 IOHandler::IOHandler(Debugger &debugger, IOHandler::Type type,
-                     const lldb::StreamFileSP &input_sp,
+                     const lldb::FileSP &input_sp,
                      const lldb::StreamFileSP &output_sp,
                      const lldb::StreamFileSP &error_sp, uint32_t flags,
                      repro::DataRecorder *data_recorder)
     : m_debugger(debugger), m_input_sp(input_sp), m_output_sp(output_sp),
       m_error_sp(error_sp), m_data_recorder(data_recorder), m_popped(false),
       m_flags(flags), m_type(type), m_user_data(nullptr), m_done(false),
       m_active(false) {
   // If any files are not specified, then adopt them from the top input reader.
   if (!m_input_sp || !m_output_sp || !m_error_sp)
     debugger.AdoptTopIOHandlerFilesIfInvalid(m_input_sp, m_output_sp,
                                              m_error_sp);
 }
 
 IOHandler::~IOHandler() = default;
 
 int IOHandler::GetInputFD() {
-  return (m_input_sp ? m_input_sp->GetFile().GetDescriptor() : -1);
+  return (m_input_sp ? m_input_sp->GetDescriptor() : -1);
 }
 
 int IOHandler::GetOutputFD() {
   return (m_output_sp ? m_output_sp->GetFile().GetDescriptor() : -1);
 }
 
 int IOHandler::GetErrorFD() {
   return (m_error_sp ? m_error_sp->GetFile().GetDescriptor() : -1);
 }
 
 FILE *IOHandler::GetInputFILE() {
-  return (m_input_sp ? m_input_sp->GetFile().GetStream() : nullptr);
+  return (m_input_sp ? m_input_sp->GetStream() : nullptr);
 }
 
 FILE *IOHandler::GetOutputFILE() {
   return (m_output_sp ? m_output_sp->GetFile().GetStream() : nullptr);
 }
 
 FILE *IOHandler::GetErrorFILE() {
   return (m_error_sp ? m_error_sp->GetFile().GetStream() : nullptr);
 }
 
-StreamFileSP &IOHandler::GetInputStreamFile() { return m_input_sp; }
+FileSP &IOHandler::GetInputFileSP() { return m_input_sp; }
 
-StreamFileSP &IOHandler::GetOutputStreamFile() { return m_output_sp; }
+StreamFileSP &IOHandler::GetOutputStreamFileSP() { return m_output_sp; }
 
-StreamFileSP &IOHandler::GetErrorStreamFile() { return m_error_sp; }
+StreamFileSP &IOHandler::GetErrorStreamFileSP() { return m_error_sp; }
 
 bool IOHandler::GetIsInteractive() {
-  return GetInputStreamFile()->GetFile().GetIsInteractive();
+  return GetInputFileSP() ? GetInputFileSP()->GetIsInteractive() : false;
 }
 
 bool IOHandler::GetIsRealTerminal() {
-  return GetInputStreamFile()->GetFile().GetIsRealTerminal();
+  return GetInputFileSP() ? GetInputFileSP()->GetIsRealTerminal() : false;
 }
 
 void IOHandler::SetPopped(bool b) { m_popped.SetValue(b, eBroadcastOnChange); }
 
 void IOHandler::WaitForPop() { m_popped.WaitForValueEqualTo(true); }
 
 void IOHandlerStack::PrintAsync(Stream *stream, const char *s, size_t len) {
   if (stream) {

 
 IOHandlerEditline::IOHandlerEditline(
     Debugger &debugger, IOHandler::Type type,
     const char *editline_name, // Used for saving history files
     llvm::StringRef prompt, llvm::StringRef continuation_prompt,
     bool multi_line, bool color_prompts, uint32_t line_number_start,
     IOHandlerDelegate &delegate, repro::DataRecorder *data_recorder)
     : IOHandlerEditline(debugger, type,
-                        StreamFileSP(), // Inherit input from top input reader
+                        FileSP(),       // Inherit input from top input reader
                         StreamFileSP(), // Inherit output from top input reader
                         StreamFileSP(), // Inherit error from top input reader
                         0,              // Flags
                         editline_name,  // Used for saving history files
                         prompt, continuation_prompt, multi_line, color_prompts,
                         line_number_start, delegate, data_recorder) {}
 
 IOHandlerEditline::IOHandlerEditline(
-    Debugger &debugger, IOHandler::Type type,
-    const lldb::StreamFileSP &input_sp, const lldb::StreamFileSP &output_sp,
-    const lldb::StreamFileSP &error_sp, uint32_t flags,
+    Debugger &debugger, IOHandler::Type type, const lldb::FileSP &input_sp,
+    const lldb::StreamFileSP &output_sp, const lldb::StreamFileSP &error_sp,
+    uint32_t flags,
     const char *editline_name, // Used for saving history files
     llvm::StringRef prompt, llvm::StringRef continuation_prompt,
     bool multi_line, bool color_prompts, uint32_t line_number_start,
     IOHandlerDelegate &delegate, repro::DataRecorder *data_recorder)
     : IOHandler(debugger, type, input_sp, output_sp, error_sp, flags,
                 data_recorder),
 #ifndef LLDB_DISABLE_LIBEDIT
       m_editline_up(),
 #endif
       m_delegate(delegate), m_prompt(), m_continuation_prompt(),
       m_current_lines_ptr(nullptr), m_base_line_number(line_number_start),
       m_curr_line_idx(UINT32_MAX), m_multi_line(multi_line),
       m_color_prompts(color_prompts), m_interrupt_exits(true),
       m_editing(false) {
   SetPrompt(prompt);
 
 #ifndef LLDB_DISABLE_LIBEDIT
   bool use_editline = false;
 
-  use_editline = m_input_sp->GetFile().GetIsRealTerminal();
+  use_editline = m_input_sp && m_input_sp->GetIsRealTerminal();
 
   if (use_editline) {
     m_editline_up.reset(new Editline(editline_name, GetInputFILE(),
                                      GetOutputFILE(), GetErrorFILE(),
                                      m_color_prompts));
     m_editline_up->SetIsInputCompleteCallback(IsInputCompleteCallback, this);
     m_editline_up->SetAutoCompleteCallback(AutoCompleteCallback, this);
     // See if the delegate supports fixing indentation
if (prompt) {
       if (coord.X < 0)
         coord.X = 0;
       SetConsoleCursorPosition(console_handle, coord);
     }
 #endif
     IOHandler::PrintAsync(stream, s, len);
 #ifdef _MSC_VER
     if (prompt)
-      IOHandler::PrintAsync(GetOutputStreamFile().get(), prompt,
+      IOHandler::PrintAsync(GetOutputStreamFileSP().get(), prompt,
                             strlen(prompt));
 #endif
   }
 }
 
 // we may want curses to be disabled for some builds for instance, windows
 #ifndef LLDB_DISABLE_CURSES
 

lldb/source/Core/StreamFile.cpp

 #include "lldb/Host/FileSystem.h"
 
 #include <stdio.h>
 
 using namespace lldb;
 using namespace lldb_private;
 
 // StreamFile constructor
-StreamFile::StreamFile() : Stream(), m_file() {}
+StreamFile::StreamFile() : Stream() { m_file_sp = std::make_shared<File>(); }
 
 StreamFile::StreamFile(uint32_t flags, uint32_t addr_size, ByteOrder byte_order)
-    : Stream(flags, addr_size, byte_order), m_file() {}
+    : Stream(flags, addr_size, byte_order) {
+  m_file_sp = std::make_shared<File>();
+}
 
-StreamFile::StreamFile(int fd, bool transfer_ownership)
-    : Stream(), m_file(fd, File::eOpenOptionWrite, transfer_ownership) {}
+StreamFile::StreamFile(int fd, bool transfer_ownership) : Stream() {
+  m_file_sp =
+      std::make_shared<File>(fd, File::eOpenOptionWrite, transfer_ownership);
+}
 
-StreamFile::StreamFile(FILE *fh, bool transfer_ownership)
-    : Stream(), m_file(fh, transfer_ownership) {}
+StreamFile::StreamFile(FILE *fh, bool transfer_ownership) : Stream() {
+  m_file_sp = std::make_shared<File>(fh, transfer_ownership);
+}
 
-StreamFile::StreamFile(const char *path) : Stream(), m_file() {
-  FileSystem::Instance().Open(m_file, FileSpec(path),
+StreamFile::StreamFile(const char *path) : Stream() {
+  FileSystem::Instance().Open(m_file_sp, FileSpec(path),
                               File::eOpenOptionWrite |
                                   File::eOpenOptionCanCreate |
                                   File::eOpenOptionCloseOnExec);
+  if (!m_file_sp)
+    m_file_sp = std::make_shared<File>();
 }
 
 StreamFile::StreamFile(const char *path, uint32_t options, uint32_t permissions)
-    : Stream(), m_file() {
-
-  FileSystem::Instance().Open(m_file, FileSpec(path), options, permissions);
+    : Stream() {
+  FileSystem::Instance().Open(m_file_sp, FileSpec(path), options, permissions);
+  if (!m_file_sp)
+    m_file_sp = std::make_shared<File>();
 }
 
 StreamFile::~StreamFile() {}
 
-void StreamFile::Flush() { m_file.Flush(); }
+void StreamFile::Flush() { m_file_sp->Flush(); }
 
 size_t StreamFile::WriteImpl(const void *s, size_t length) {
-  m_file.Write(s, length);
+  m_file_sp->Write(s, length);
   return length;
 }

lldb/source/Expression/REPL.cpp

lldb::IOHandlerSP REPL::GetIOHandler() {
   }
   return m_io_handler_sp;
 }
 
 void REPL::IOHandlerActivated(IOHandler &io_handler, bool interactive) {
   lldb::ProcessSP process_sp = m_target.GetProcessSP();
   if (process_sp && process_sp->IsAlive())
     return;
-  lldb::StreamFileSP error_sp(io_handler.GetErrorStreamFile());
+  lldb::StreamFileSP error_sp(io_handler.GetErrorStreamFileSP());
   error_sp->Printf("REPL requires a running target process.\n");
   io_handler.SetIsDone(true);
 }
 
 bool REPL::IOHandlerInterrupt(IOHandler &io_handler) { return false; }
 
 void REPL::IOHandlerInputInterrupted(IOHandler &io_handler, std::string &line) {
 }
int REPL::IOHandlerFixIndentation(IOHandler &io_handler,
 
   if (desired_indent == LLDB_INVALID_OFFSET)
     return 0;
 
   return (int)desired_indent - actual_indent;
 }
 
 void REPL::IOHandlerInputComplete(IOHandler &io_handler, std::string &code) {
-  lldb::StreamFileSP output_sp(io_handler.GetOutputStreamFile());
-  lldb::StreamFileSP error_sp(io_handler.GetErrorStreamFile());
+  lldb::StreamFileSP output_sp(io_handler.GetOutputStreamFileSP());
+  lldb::StreamFileSP error_sp(io_handler.GetErrorStreamFileSP());
   bool extra_line = false;
   bool did_quit = false;
 
   if (code.empty()) {
     m_code.AppendString("");
     static_cast<IOHandlerEditline &>(io_handler)
         .SetBaseLineNumber(m_code.GetSize() + 1);
   } else {
if (code[0] == ':') {
 
         if (add_to_code) {
           const uint32_t new_default_line = m_code.GetSize() + 1;
 
           m_code.SplitIntoLines(code);
 
           // Update our code on disk
           if (!m_repl_source_path.empty()) {
-            lldb_private::File file;
+            std::shared_ptr<lldb_private::File> file;
             FileSystem::Instance().Open(file, FileSpec(m_repl_source_path),
                                         File::eOpenOptionWrite |
                                             File::eOpenOptionTruncate |
                                             File::eOpenOptionCanCreate,
                                         lldb::eFilePermissionsFileDefault);
+            if (file) {
               std::string code(m_code.CopyList());
               code.append(1, '\n');
               size_t bytes_written = code.size();
-            file.Write(code.c_str(), bytes_written);
-            file.Close();
+              file->Write(code.c_str(), bytes_written);
+              file->Close();
+            }
 
             // Now set the default file and line to the REPL source file
             m_target.GetSourceManager().SetDefaultFileAndLine(
                 FileSpec(m_repl_source_path), new_default_line);
           }
           static_cast<IOHandlerEditline &>(io_handler)
               .SetBaseLineNumber(m_code.GetSize() + 1);
         }

lldb/source/Host/common/File.cpp

#endif
   }
 
   // Invalid descriptor and invalid stream, return invalid descriptor.
   return kInvalidDescriptor;
 }
 
 IOObject::WaitableHandle File::GetWaitableHandle() { return GetDescriptor(); }
 
-void File::SetDescriptor(int fd, uint32_t options, bool transfer_ownership) {
-  if (IsValid())
-    Close();
-  m_descriptor = fd;
-  m_should_close_fd = transfer_ownership;
-  m_options = options;
-}
-
 FILE *File::GetStream() {
   if (!StreamIsValid()) {
     if (DescriptorIsValid()) {
       const char *mode = GetStreamOpenModeFromOptions(m_options);
       if (mode) {
         if (!m_should_close_fd) {
 // We must duplicate the file descriptor if we don't own it because when you
 // call fdopen, the stream will own the fd
#endif
           m_should_close_fd = false;
         }
       }
     }
   }
   return m_stream;
 }
 
-void File::SetStream(FILE *fh, bool transfer_ownership) {
-  if (IsValid())
-    Close();
-  m_stream = fh;
-  m_own_stream = transfer_ownership;
-}
-
 uint32_t File::GetPermissions(Status &error) const {
   int fd = GetDescriptor();
   if (fd != kInvalidDescriptor) {
     struct stat file_stats;
     if (::fstat(fd, &file_stats) == -1)
       error.SetErrorToErrno();
     else {
       error.Clear();

lldb/source/Host/common/FileCache.cpp

 }
 
 lldb::user_id_t FileCache::OpenFile(const FileSpec &file_spec, uint32_t flags,
                                     uint32_t mode, Status &error) {
   if (!file_spec) {
     error.SetErrorString("empty path");
     return UINT64_MAX;
   }
-  FileSP file_sp(new File());
-  error = FileSystem::Instance().Open(*file_sp, file_spec, flags, mode);
-  if (!file_sp->IsValid())
+  FileSP file_sp;
+  error = FileSystem::Instance().Open(file_sp, file_spec, flags, mode);
+  if (!file_sp)
     return UINT64_MAX;
   lldb::user_id_t fd = file_sp->GetDescriptor();
   m_cache[fd] = file_sp;
   return fd;
 }
 
 bool FileCache::CloseFile(lldb::user_id_t fd, Status &error) {
   if (fd == UINT64_MAX) {

lldb/source/Host/common/FileSystem.cpp

if (permissions & lldb::eFilePermissionsWorldRead)
     mode |= S_IROTH;
   if (permissions & lldb::eFilePermissionsWorldWrite)
     mode |= S_IWOTH;
   if (permissions & lldb::eFilePermissionsWorldExecute)
     mode |= S_IXOTH;
   return mode;
 }
 
-Status FileSystem::Open(File &File, const FileSpec &file_spec, uint32_t options,
-                        uint32_t permissions, bool should_close_fd) {
+Status FileSystem::Open(FileSP &filesp, const FileSpec &file_spec,
+                        uint32_t options, uint32_t permissions,
+                        bool should_close_fd) {
   if (m_collector)
     m_collector->addFile(file_spec.GetPath());
 
-  if (File.IsValid())
-    File.Close();
+  filesp.reset();
 
   const int open_flags = GetOpenFlags(options);
   const mode_t open_mode =
       (open_flags & O_CREAT) ? GetOpenMode(permissions) : 0;
 
   auto path = GetExternalPath(file_spec);
   if (!path)
     return Status(path.getError());
 
   int descriptor = llvm::sys::RetryAfterSignal(
       -1, OpenWithFS, *this, path->c_str(), open_flags, open_mode);
 
   Status error;
   if (!File::DescriptorIsValid(descriptor)) {
-    File.SetDescriptor(-1, options, false);
+    errno = EINVAL;
     error.SetErrorToErrno();
   } else {
-    File.SetDescriptor(descriptor, options, should_close_fd);
+    filesp = std::make_shared<File>(descriptor, options, should_close_fd);
   }
+  if (filesp && !filesp->IsValid())
+    filesp.reset();
   return error;
 }
 
 ErrorOr<std::string> FileSystem::GetExternalPath(const llvm::Twine &path) {
   if (!m_mapped)
     return path.str();
 
   // If VFS mapped we know the underlying FS is a RedirectingFileSystem.

lldb/source/Host/windows/Host.cpp

 
 using namespace lldb;
 using namespace lldb_private;
 
 namespace {
 bool GetTripleForProcess(const FileSpec &executable, llvm::Triple &triple) {
   // Open the PE File as a binary file, and parse just enough information to
   // determine the machine type.
-  File imageBinary;
-  FileSystem::Instance().Open(imageBinary, executable, File::eOpenOptionRead,
+  FileSP imageBinarySP;
+  FileSystem::Instance().Open(imageBinarySP, executable, File::eOpenOptionRead,
                               lldb::eFilePermissionsUserRead);
+  if (!imageBinarySP)
+    return false;
+  File &imageBinary = *imageBinarySP;
   imageBinary.SeekFromStart(0x3c);
   int32_t peOffset = 0;
   uint32_t peHead = 0;
   uint16_t machineType = 0;
   size_t readSize = sizeof(peOffset);
   imageBinary.Read(&peOffset, readSize);
   imageBinary.SeekFromStart(peOffset);
   imageBinary.Read(&peHead, readSize);

lldb/source/Interpreter/CommandInterpreter.cpp

void CommandInterpreter::HandleCommandsFromFile(
   if (!FileSystem::Instance().Exists(cmd_file)) {
     result.AppendErrorWithFormat(
         "Error reading commands from file %s - file not found.\n",
         cmd_file.GetFilename().AsCString("<Unknown>"));
     result.SetStatus(eReturnStatusFailed);
     return;
   }
 
-  StreamFileSP input_file_sp(new StreamFile());
   std::string cmd_file_path = cmd_file.GetPath();
-  Status error = FileSystem::Instance().Open(input_file_sp->GetFile(), cmd_file,
+  FileSP input_file_sp;
+  Status error = FileSystem::Instance().Open(input_file_sp, cmd_file,
                                              File::eOpenOptionRead);
-
-  if (error.Fail()) {
+  if (!input_file_sp || error.Fail()) {
     result.AppendErrorWithFormat(
         "error: an error occurred read file '%s': %s\n", cmd_file_path.c_str(),
         error.AsCString());
     result.SetStatus(eReturnStatusFailed);
     return;
   }
 
   Debugger &debugger = GetDebugger();
if (options.m_print_errors == eLazyBoolCalculate) {
     } else if (m_command_source_flags.back() & eHandleCommandFlagPrintErrors) {
       flags |= eHandleCommandFlagPrintErrors;
     }
   } else if (options.m_print_errors == eLazyBoolYes) {
     flags |= eHandleCommandFlagPrintErrors;
   }
 
   if (flags & eHandleCommandFlagPrintResult) {
-    debugger.GetOutputFile()->Printf("Executing commands in '%s'.\n",
-                                     cmd_file_path.c_str());
+    debugger.GetOutputFile().Printf("Executing commands in '%s'.\n",
   }
 
   // Used for inheriting the right settings when "command source" might
   // have nested "command source" commands
   lldb::StreamFileSP empty_stream_sp;
   m_command_source_flags.push_back(flags);
   IOHandlerSP io_handler_sp(new IOHandlerEditline(
       debugger, IOHandler::Type::CommandInterpreter, input_file_sp,
if (!is_interactive) {
     // alias, get an error and stop parsing the commands file).
     if (line.empty())
       return;
 
     // When using a non-interactive file handle (like when sourcing commands
     // from a file) we need to echo the command out so we don't just see the
     // command output and no command...
     if (EchoCommandNonInteractive(line, io_handler.GetFlags()))
-      io_handler.GetOutputStreamFile()->Printf("%s%s\n", io_handler.GetPrompt(),
-                                               line.c_str());
+      io_handler.GetOutputStreamFileSP()->Printf(
+          "%s%s\n", io_handler.GetPrompt(), line.c_str());
   }
 
   StartHandlingCommand();
 
   lldb_private::CommandReturnObject result;
   HandleCommand(line.c_str(), eLazyBoolCalculate, result);
 
   // Now emit the command output text from the command we just executed
   if ((result.Succeeded() &&
        io_handler.GetFlags().Test(eHandleCommandFlagPrintResult)) ||
       io_handler.GetFlags().Test(eHandleCommandFlagPrintErrors)) {
     // Display any STDOUT/STDERR _prior_ to emitting the command result text
     GetProcessOutput();
 
     if (!result.GetImmediateOutputStream()) {
       llvm::StringRef output = result.GetOutputData();
-      PrintCommandOutput(*io_handler.GetOutputStreamFile(), output);
+      PrintCommandOutput(*io_handler.GetOutputStreamFileSP(), output);
     }
 
     // Now emit the command error text from the command we just executed
     if (!result.GetImmediateErrorStream()) {
       llvm::StringRef error = result.GetErrorData();
-      PrintCommandOutput(*io_handler.GetErrorStreamFile(), error);
+      PrintCommandOutput(*io_handler.GetErrorStreamFileSP(), error);
     }
   }
 
   FinishHandlingCommand();
 
   switch (result.GetStatus()) {
   case eReturnStatusInvalid:
   case eReturnStatusSuccessFinishNoResult:
if (options) {
         flags |= eHandleCommandFlagPrintErrors;
     } else {
       flags = eHandleCommandFlagEchoCommand | eHandleCommandFlagPrintResult |
               eHandleCommandFlagPrintErrors;
     }
 
     m_command_io_handler_sp = std::make_shared<IOHandlerEditline>(
         m_debugger, IOHandler::Type::CommandInterpreter,
-        m_debugger.GetInputFile(), m_debugger.GetOutputFile(),
-        m_debugger.GetErrorFile(), flags, "lldb", m_debugger.GetPrompt(),
+        m_debugger.GetInputFileSP(), m_debugger.GetOutputStreamSP(),
+        m_debugger.GetErrorStreamSP(), flags, "lldb", m_debugger.GetPrompt(),
         llvm::StringRef(), // Continuation prompt
         false, // Don't enable multiple line input, just single line commands
         m_debugger.GetUseColor(),
         0,     // Don't show line numbers
         *this, // IOHandlerDelegate
         GetDebugger().GetInputRecorder());
   }
   return m_command_io_handler_sp;

lldb/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp

if (ReadMemoryModule(process) == false) {
                 "Unable to read '%s' from memory at address 0x%" PRIx64
                 " to get the segment load addresses.",
                 m_name.c_str(), m_load_address);
       return false;
     }
   }
 
   if (IsKernel() && m_uuid.IsValid()) {
-    Stream *s = target.GetDebugger().GetOutputFile().get();
-    if (s) {
-      s->Printf("Kernel UUID: %s\n",
-                m_uuid.GetAsString().c_str());
-      s->Printf("Load Address: 0x%" PRIx64 "\n", m_load_address);
-    }
+    Stream &s = target.GetDebugger().GetOutputStream();
+    s.Printf("Kernel UUID: %s\n", m_uuid.GetAsString().c_str());
+    s.Printf("Load Address: 0x%" PRIx64 "\n", m_load_address);
   }
 
   if (!m_module_sp) {
     // See if the kext has already been loaded into the target, probably by the
     // user doing target modules add.
     const ModuleList &target_images = target.GetImages();
     m_module_sp = target_images.FindModule(m_uuid);
 
FileSpecList search_paths = target.GetExecutableSearchPaths();
       // standard search paths on the system, and on a Mac it will try calling
       // the DebugSymbols framework with the UUID to find the binary via its
       // search methods.
       if (!m_module_sp) {
         m_module_sp = target.GetOrCreateModule(module_spec, true /* notify */);
       }
 
       if (IsKernel() && !m_module_sp) {
-        Stream *s = target.GetDebugger().GetOutputFile().get();
-        if (s) {
-          s->Printf("WARNING: Unable to locate kernel binary on the debugger "
-                    "system.\n");
-        }
-      }
-    }
+        Stream &s = target.GetDebugger().GetOutputStream();
+        s.Printf("WARNING: Unable to locate kernel binary on the debugger "
 
     // If we managed to find a module, append it to the target's list of
     // images. If we also have a memory module, require that they have matching
     // UUIDs
     if (m_module_sp) {
       if (m_uuid.IsValid() && m_module_sp->GetUUID() == m_uuid) {
         target.GetImages().AppendIfNeeded(m_module_sp);
         if (IsKernel() &&
if (m_module_sp->GetUUID() == m_memory_module_sp->GetUUID()) {
         m_module_sp.reset(); // One or both object files missing
     } else
       m_module_sp.reset(); // UUID mismatch
   }
 
   bool is_loaded = IsLoaded();
 
   if (is_loaded && m_module_sp && IsKernel()) {
-    Stream *s = target.GetDebugger().GetOutputFile().get();
-    if (s) {
-      ObjectFile *kernel_object_file = m_module_sp->GetObjectFile();
-      if (kernel_object_file) {
-        addr_t file_address =
-            kernel_object_file->GetBaseAddress().GetFileAddress();
-        if (m_load_address != LLDB_INVALID_ADDRESS &&
-            file_address != LLDB_INVALID_ADDRESS) {
-          s->Printf("Kernel slid 0x%" PRIx64 " in memory.\n",
-                    m_load_address - file_address);
-        }
-      }
-      {
-        s->Printf("Loaded kernel file %s\n",
-                  m_module_sp->GetFileSpec().GetPath().c_str());
-      }
-      s->Flush();
-    }
+    Stream &s = target.GetDebugger().GetOutputStream();
+        s.Printf("Kernel slid 0x%" PRIx64 " in memory.\n",
+      s.Printf("Loaded kernel file %s\n",
+    s.Flush();
   }
+
   return is_loaded;
 }
 
 uint32_t DynamicLoaderDarwinKernel::KextImageInfo::GetAddressByteSize() {
   if (m_memory_module_sp)
     return m_memory_module_sp->GetArchitecture().GetAddressByteSize();
   if (m_module_sp)
     return m_module_sp->GetArchitecture().GetAddressByteSize();
if (m_process->GetTarget().ReadPointerFromMemory(
       if (m_kext_summary_header_addr.IsValid() &&
           m_kext_summary_header_addr.GetFileAddress() != 0) {
         const size_t bytes_read = m_process->GetTarget().ReadMemory(
             m_kext_summary_header_addr, prefer_file_cache, buf, count, error);
         if (bytes_read == count) {
           lldb::offset_t offset = 0;
           m_kext_summary_header.version = data.GetU32(&offset);
           if (m_kext_summary_header.version > 128) {
-            Stream *s =
-                m_process->GetTarget().GetDebugger().GetOutputFile().get();
-            s->Printf("WARNING: Unable to read kext summary header, got "
-                      "improbable version number %u\n",
-                      m_kext_summary_header.version);
+            Stream &s = m_process->GetTarget().GetDebugger().GetOutputStream();
+            s.Printf("WARNING: Unable to read kext summary header, got "
             // If we get an improbably large version number, we're probably
             // getting bad memory.
             m_kext_summary_header_addr.Clear();
             return false;
           }
           if (m_kext_summary_header.version >= 2) {
             m_kext_summary_header.entry_size = data.GetU32(&offset);
             if (m_kext_summary_header.entry_size > 4096) {
               // If we get an improbably large entry_size, we're probably
               // getting bad memory.
-              Stream *s =
-                  m_process->GetTarget().GetDebugger().GetOutputFile().get();
-              s->Printf("WARNING: Unable to read kext summary header, got "
-                        "improbable entry_size %u\n",
-                        m_kext_summary_header.entry_size);
+              Stream &s =
+                  m_process->GetTarget().GetDebugger().GetOutputStream();
+              s.Printf("WARNING: Unable to read kext summary header, got "
               m_kext_summary_header_addr.Clear();
               return false;
             }
           } else {
             // Versions less than 2 didn't have an entry size, it was hard
             // coded
             m_kext_summary_header.entry_size =
                 KERNEL_MODULE_ENTRY_SIZE_VERSION_1;
           }
           m_kext_summary_header.entry_count = data.GetU32(&offset);
           if (m_kext_summary_header.entry_count > 10000) {
             // If we get an improbably large number of kexts, we're probably
             // getting bad memory.
-            Stream *s =
-                m_process->GetTarget().GetDebugger().GetOutputFile().get();
-            s->Printf("WARNING: Unable to read kext summary header, got "
-                      "improbable number of kexts %u\n",
-                      m_kext_summary_header.entry_count);
+            Stream &s = m_process->GetTarget().GetDebugger().GetOutputStream();
+            s.Printf("WARNING: Unable to read kext summary header, got "
             m_kext_summary_header_addr.Clear();
             return false;
           }
           return true;
         }
       }
     }
   }
if (add_this_one) {
       number_of_new_kexts_being_added++;
     }
   }
 
   if (number_of_new_kexts_being_added == 0 &&
       number_of_old_kexts_being_removed == 0)
     return true;
 
-  Stream *s = m_process->GetTarget().GetDebugger().GetOutputFile().get();
-  if (s && load_kexts) {
+  Stream &s = m_process->GetTarget().GetDebugger().GetOutputStream();
+  if (load_kexts) {
     if (number_of_new_kexts_being_added > 0 &&
         number_of_old_kexts_being_removed > 0) {
-      s->Printf("Loading %d kext modules and unloading %d kext modules ",
-                number_of_new_kexts_being_added,
-                number_of_old_kexts_being_removed);
+      s.Printf("Loading %d kext modules and unloading %d kext modules ",
     } else if (number_of_new_kexts_being_added > 0) {
-      s->Printf("Loading %d kext modules ", number_of_new_kexts_being_added);
+      s.Printf("Loading %d kext modules ", number_of_new_kexts_being_added);
     } else if (number_of_old_kexts_being_removed > 0) {
-      s->Printf("Unloading %d kext modules ",
-                number_of_old_kexts_being_removed);
+      s.Printf("Unloading %d kext modules ", number_of_old_kexts_being_removed);
     }
   }
 
   if (log) {
     if (load_kexts) {
       LLDB_LOGF(log,
                 "DynamicLoaderDarwinKernel::ParseKextSummaries: %d kexts "
                 "added, %d kexts removed",
for (uint32_t new_kext = 0; new_kext < num_of_new_kexts; new_kext++) {
         }
 
         m_known_kexts.push_back(image_info);
 
         if (image_info.GetModule() &&
             m_process->GetStopID() == image_info.GetProcessStopId())
           loaded_module_list.AppendIfNeeded(image_info.GetModule());
 
-        if (s && load_kexts) {
+        if (load_kexts) {
           if (kext_successfully_added)
-            s->Printf(".");
+            s.Printf(".");
           else
-            s->Printf("-");
+            s.Printf("-");
         }
 
         if (log)
           kext_summaries[new_kext].PutToLog(log);
       }
     }
     m_process->GetTarget().ModulesDidLoad(loaded_module_list);
   }
 
   if (number_of_old_kexts_being_removed > 0) {
     ModuleList loaded_module_list;
     const uint32_t num_of_old_kexts = m_known_kexts.size();
     for (uint32_t old_kext = 0; old_kext < num_of_old_kexts; old_kext++) {
       ModuleList unloaded_module_list;
       if (to_be_removed[old_kext]) {
         KextImageInfo &image_info = m_known_kexts[old_kext];
         // You can't unload the kernel.
         if (!image_info.IsKernel()) {
           if (image_info.GetModule()) {
             unloaded_module_list.AppendIfNeeded(image_info.GetModule());
           }
-          if (s)
-            s->Printf(".");
+          s.Printf(".");
           image_info.Clear();
           // should pull it out of the KextImageInfos vector but that would
           // mutate the list and invalidate the to_be_removed bool vector;
           // leaving it in place once Cleared() is relatively harmless.
         }
       }
       m_process->GetTarget().ModulesDidUnload(unloaded_module_list, false);
     }
   }
 
-  if (s && load_kexts) {
-    s->Printf(" done.\n");
+  if (load_kexts) {
+    s.Printf(" done.\n");
     if (kexts_failed_to_load.size() > 0 && number_of_new_kexts_being_added > 0) {
-      s->Printf("Failed to load %d of %d kexts:\n",
-                (int)kexts_failed_to_load.size(),
-                number_of_new_kexts_being_added);
+      s.Printf("Failed to load %d of %d kexts:\n",
       // print a sorted list of <kext-name, uuid> kexts which failed to load
       unsigned longest_name = 0;
       std::sort(kexts_failed_to_load.begin(), kexts_failed_to_load.end());
       for (const auto &ku : kexts_failed_to_load) {
         if (ku.first.size() > longest_name)
           longest_name = ku.first.size();
       }
       for (const auto &ku : kexts_failed_to_load) {
         std::string uuid;
         if (ku.second.IsValid())
           uuid = ku.second.GetAsString();
-        s->Printf (" %-*s %s\n", longest_name, ku.first.c_str(), uuid.c_str());
+        s.Printf(" %-*s %s\n", longest_name, ku.first.c_str(), uuid.c_str());
       }
     }
-    s->Flush();
+    s.Flush();
   }
 
   return true;
 }
 
 uint32_t DynamicLoaderDarwinKernel::ReadKextSummaries(
     const Address &kext_summary_addr, uint32_t image_infos_count,
     KextImageInfo::collection &image_infos) {

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp

execution_unit_sp = std::make_shared<IRExecutionUnit>(
       m_compiler->getTargetOpts().Features);
 
   ClangExpressionHelper *type_system_helper =
       dyn_cast<ClangExpressionHelper>(m_expr.GetTypeSystemHelper());
   ClangExpressionDeclMap *decl_map =
       type_system_helper->DeclMap(); // result can be NULL
 
   if (decl_map) {
-    Stream *error_stream = nullptr;
     Target *target = exe_ctx.GetTargetPtr();
-    error_stream = target->GetDebugger().GetErrorFile().get();
-
+    auto &error_stream = target->GetDebugger().GetErrorStream();
     IRForTarget ir_for_target(decl_map, m_expr.NeedsVariableResolution(),
-                              *execution_unit_sp, *error_stream,
+                              *execution_unit_sp, error_stream,
                               function_name.AsCString());
 
     bool ir_can_run =
         ir_for_target.runOnModule(*execution_unit_sp->GetModule());
 
     if (!ir_can_run) {
       err.SetErrorString(
           "The expression could not be prepared to run in the target");

lldb/source/Plugins/InstrumentationRuntime/ASan/ASanRuntime.cpp

bool AddressSanitizerRuntime::NotifyBreakpointHit(
   if (process_sp && process_sp == context->exe_ctx_ref.GetProcessSP()) {
     ThreadSP thread_sp = context->exe_ctx_ref.GetThreadSP();
     if (thread_sp)
       thread_sp->SetStopInfo(InstrumentationRuntimeStopInfo::
                                  CreateStopReasonWithInstrumentationData(
                                      *thread_sp, description, report));
 
     StreamFileSP stream_sp(
-        process_sp->GetTarget().GetDebugger().GetOutputFile());
+        process_sp->GetTarget().GetDebugger().GetOutputStreamSP());
     if (stream_sp) {
       stream_sp->Printf("AddressSanitizer report breakpoint hit. Use 'thread "
                         "info -s' to get extended information about the "
                         "report.\n");
     }
     return true; // Return true to stop the target
   } else
     return false; // Let target run

lldb/source/Plugins/InstrumentationRuntime/TSan/TSanRuntime.cpp

bool ThreadSanitizerRuntime::NotifyBreakpointHit(
   if (process_sp && process_sp == context->exe_ctx_ref.GetProcessSP()) {
     ThreadSP thread_sp = context->exe_ctx_ref.GetThreadSP();
     if (thread_sp)
       thread_sp->SetStopInfo(
           InstrumentationRuntimeStopInfo::
               CreateStopReasonWithInstrumentationData(
                   *thread_sp, stop_reason_description, report));
 
-    StreamFileSP stream_sp(
-        process_sp->GetTarget().GetDebugger().GetOutputFile());
-    if (stream_sp) {
-      stream_sp->Printf("ThreadSanitizer report breakpoint hit. Use 'thread "
-                        "info -s' to get extended information about the "
-                        "report.\n");
-    }
+    StreamFile &s = process_sp->GetTarget().GetDebugger().GetOutputStream();
+    s.Printf("ThreadSanitizer report breakpoint hit. Use 'thread "
+
     return true; // Return true to stop the target
   } else
     return false; // Let target run
 }
 
 const RegularExpression &ThreadSanitizerRuntime::GetPatternForRuntimeLibrary() {
   static RegularExpression regex(llvm::StringRef("libclang_rt.tsan_"));
   return regex;

lldb/source/Plugins/InstrumentationRuntime/UBSan/UBSanRuntime.cpp

StructuredData::ObjectSP UndefinedBehaviorSanitizerRuntime::RetrieveReportData(
   ThreadSP thread_sp = exe_ctx_ref.GetThreadSP();
   StackFrameSP frame_sp = thread_sp->GetSelectedFrame();
   ModuleSP runtime_module_sp = GetRuntimeModuleSP();
   Target &target = process_sp->GetTarget();
 
   if (!frame_sp)
     return StructuredData::ObjectSP();
 
-  StreamFileSP Stream(target.GetDebugger().GetOutputFile());
+  StreamFileSP Stream = target.GetDebugger().GetOutputStreamSP();
 
   EvaluateExpressionOptions options;
   options.SetUnwindOnError(true);
   options.SetTryAllThreads(true);
   options.SetStopOthers(true);
   options.SetIgnoreBreakpoints(true);
   options.SetTimeout(process_sp->GetUtilityExpressionTimeout());
   options.SetPrefix(ub_sanitizer_retrieve_report_data_prefix);

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.cpp

AppleObjCTrampolineHandler::AppleObjCTrampolineHandler(
 
   // FIXME: Do some kind of logging here.
   if (m_impl_fn_addr == LLDB_INVALID_ADDRESS) {
     // If we can't even find the ordinary get method implementation function,
     // then we aren't going to be able to
     // step through any method dispatches.  Warn to that effect and get out of
     // here.
     if (process_sp->CanJIT()) {
-      process_sp->GetTarget().GetDebugger().GetErrorFile()->Printf(
+      process_sp->GetTarget().GetDebugger().GetErrorStream().Printf(
           "Could not find implementation lookup function \"%s\""
           " step in through ObjC method dispatch will not work.\n",
           get_impl_name.AsCString());
     }
     return;
   } else if (m_impl_stret_fn_addr == LLDB_INVALID_ADDRESS) {
     // It there is no stret return lookup function, assume that it is the same
     // as the straight lookup:

lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

assert(alloc->data_ptr.isValid() && alloc->element.type.isValid() &&
          alloc->element.type_vec_size.isValid() &&
          alloc->element.datum_size.get() &&
          alloc->element.type_kind.isValid() && alloc->dimension.isValid() &&
          "Allocation information not available");
 
   // Check we can create writable file
   FileSpec file_spec(path);
   FileSystem::Instance().Resolve(file_spec);
-  File file;
+  FileSP file;
   FileSystem::Instance().Open(file, file_spec,
                               File::eOpenOptionWrite |
                                   File::eOpenOptionCanCreate |
                                   File::eOpenOptionTruncate);
 
   if (!file) {
     strm.Printf("Error: Failed to open '%s' for writing", path);
     strm.EOL();
bool RenderScriptRuntime::SaveAllocation(Stream &strm, const uint32_t alloc_id,
   head.hdr_size = static_cast<uint16_t>(sizeof(AllocationDetails::FileHeader) +
                                         element_header_size);
 
   // Write the file header
   size_t num_bytes = sizeof(AllocationDetails::FileHeader);
   LLDB_LOGF(log, "%s - writing File Header, 0x%" PRIx64 " bytes", __FUNCTION__,
             (uint64_t)num_bytes);
 
-  Status err = file.Write(&head, num_bytes);
+  Status err = file->Write(&head, num_bytes);
   if (!err.Success()) {
     strm.Printf("Error: '%s' when writing to file '%s'", err.AsCString(), path);
     strm.EOL();
     return false;
   }
 
   // Create the headers describing the element type of the allocation.
   std::shared_ptr<uint8_t> element_header_buffer(
       new uint8_t[element_header_size]);
   if (element_header_buffer == nullptr) {
     strm.Printf("Internal Error: Couldn't allocate %" PRIu64
                 " bytes on the heap",
                 (uint64_t)element_header_size);
     strm.EOL();
     return false;
   }
 
   PopulateElementHeaders(element_header_buffer, 0, alloc->element);
 
   // Write headers for allocation element type to file
   num_bytes = element_header_size;
   LLDB_LOGF(log, "%s - writing element headers, 0x%" PRIx64 " bytes.",
             __FUNCTION__, (uint64_t)num_bytes);
 
-  err = file.Write(element_header_buffer.get(), num_bytes);
+  err = file->Write(element_header_buffer.get(), num_bytes);
   if (!err.Success()) {
     strm.Printf("Error: '%s' when writing to file '%s'", err.AsCString(), path);
     strm.EOL();
     return false;
   }
 
   // Write allocation data to file
   num_bytes = static_cast<size_t>(*alloc->size.get());
   LLDB_LOGF(log, "%s - writing 0x%" PRIx64 " bytes", __FUNCTION__,
             (uint64_t)num_bytes);
 
-  err = file.Write(buffer.get(), num_bytes);
+  err = file->Write(buffer.get(), num_bytes);
   if (!err.Success()) {
     strm.Printf("Error: '%s' when writing to file '%s'", err.AsCString(), path);
     strm.EOL();
     return false;
   }
 
   strm.Printf("Allocation written to file '%s'", path);
   strm.EOL();
bool DoExecute(Args &command, CommandReturnObject &result) override {
 
     Stream *output_strm = nullptr;
     StreamFile outfile_stream;
     const FileSpec &outfile_spec =
         m_options.m_outfile; // Dump allocation to file instead
     if (outfile_spec) {
       // Open output file
       std::string path = outfile_spec.GetPath();
-      auto error = FileSystem::Instance().Open(
-          outfile_stream.GetFile(), outfile_spec,
-          File::eOpenOptionWrite | File::eOpenOptionCanCreate);
+      FileSP file;
+      auto error = FileSystem::Instance().Open(file, outfile_spec,
+                                               File::eOpenOptionWrite |
+                                                   File::eOpenOptionCanCreate);
+      outfile_stream.SetFile(file);
       if (error.Success()) {
         output_strm = &outfile_stream;
         result.GetOutputStream().Printf("Results written to '%s'",
                                         path.c_str());
         result.GetOutputStream().EOL();
       } else {
         result.AppendErrorWithFormat("Couldn't open file '%s'", path.c_str());
         result.SetStatus(eReturnStatusFailed);

lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

if (target_triple.getVendor() == llvm::Triple::Apple &&
               buffer.PutHex32(static_cast<uint32_t>(segment.filesize));
             }
             buffer.PutHex32(segment.maxprot);
             buffer.PutHex32(segment.initprot);
             buffer.PutHex32(segment.nsects);
             buffer.PutHex32(segment.flags);
           }
 
-          File core_file;
+          FileSP core_file;
           std::string core_file_path(outfile.GetPath());
           error = FileSystem::Instance().Open(core_file, outfile,
                                               File::eOpenOptionWrite |
                                                   File::eOpenOptionTruncate |
                                                   File::eOpenOptionCanCreate);
-          if (error.Success()) {
+          if (error.Success() && core_file) {
             // Read 1 page at a time
             uint8_t bytes[0x1000];
             // Write the mach header and load commands out to the core file
             size_t bytes_written = buffer.GetString().size();
-            error = core_file.Write(buffer.GetString().data(), bytes_written);
+            error = core_file->Write(buffer.GetString().data(), bytes_written);
             if (error.Success()) {
               // Now write the file data for all memory segments in the process
               for (const auto &segment : segment_load_commands) {
-                if (core_file.SeekFromStart(segment.fileoff) == -1) {
+                if (core_file->SeekFromStart(segment.fileoff) == -1) {
                   error.SetErrorStringWithFormat(
                       "unable to seek to offset 0x%" PRIx64 " in '%s'",
                       segment.fileoff, core_file_path.c_str());
                   break;
                 }
 
                 printf("Saving %" PRId64
                        " bytes of data for memory region at 0x%" PRIx64 "\n",
                        segment.vmsize, segment.vmaddr);
                 addr_t bytes_left = segment.vmsize;
                 addr_t addr = segment.vmaddr;
                 Status memory_read_error;
                 while (bytes_left > 0 && error.Success()) {
                   const size_t bytes_to_read =
                       bytes_left > sizeof(bytes) ? sizeof(bytes) : bytes_left;
 
                   // In a savecore setting, we don't really care about caching,
                   // as the data is dumped and very likely never read again,
                   // so we call ReadMemoryFromInferior to bypass it.
                   const size_t bytes_read = process_sp->ReadMemoryFromInferior(
                       addr, bytes, bytes_to_read, memory_read_error);
 
                   if (bytes_read == bytes_to_read) {
                     size_t bytes_written = bytes_read;
-                    error = core_file.Write(bytes, bytes_written);
+                    error = core_file->Write(bytes, bytes_written);
                     bytes_left -= bytes_read;
                     addr += bytes_read;
                   } else {
                     // Some pages within regions are not readable, those should
                     // be zero filled
                     memset(bytes, 0, bytes_to_read);
                     size_t bytes_written = bytes_to_read;
-                    error = core_file.Write(bytes, bytes_written);
+                    error = core_file->Write(bytes, bytes_written);
                     bytes_left -= bytes_to_read;
                     addr += bytes_to_read;
                   }
                 }
               }
             }
           }
         } else {

lldb/source/Plugins/Platform/MacOSX/objcxx/PlatformiOSSimulatorCoreSimulatorSupport.mm

bool CoreSimulatorSupport::Device::Shutdown(Status &err) {
   } else {
     err.SetErrorString([[nserror description] UTF8String]);
     return false;
   }
 }
 
 static Status HandleFileAction(ProcessLaunchInfo &launch_info,
                                NSMutableDictionary *options, NSString *key,
-                               const int fd, File &file) {
+                               const int fd, lldb::FileSP &file) {
   Status error;
   const FileAction *file_action = launch_info.GetFileActionForFD(fd);
   if (file_action) {
     switch (file_action->GetAction()) {
     case FileAction::eFileActionNone:
       break;
 
     case FileAction::eFileActionClose:
case FileAction::eFileActionOpen: {
         int created_fd =
             open(file_spec.GetPath().c_str(), oflag, S_IRUSR | S_IWUSR);
         if (created_fd >= 0) {
           uint32_t file_options = 0;
           if ((oflag & O_RDWR) || (oflag & O_RDONLY))
             file_options |= File::eOpenOptionRead;
           if ((oflag & O_RDWR) || (oflag & O_RDONLY))
             file_options |= File::eOpenOptionWrite;
-          file.SetDescriptor(created_fd, file_options, true);
+          file = std::make_shared<File>(created_fd, file_options, true);
           [options setValue:[NSNumber numberWithInteger:created_fd] forKey:key];
           return error; // Success
         } else {
           posix_error.SetErrorToErrno();
           error.SetErrorStringWithFormat("unable to open file '%s': %s",
                                          file_spec.GetPath().c_str(),
                                          posix_error.AsCString());
         }
for (const auto &KV : launch_info.GetEnvironment()) {
     NSString *value_ns = [NSString stringWithUTF8String:KV.second.c_str()];
 
     [env_dict setValue:value_ns forKey:key_ns];
   }
 
   [options setObject:env_dict forKey:kSimDeviceSpawnEnvironment];
 
   Status error;
-  File stdin_file;
-  File stdout_file;
-  File stderr_file;
+  lldb::FileSP stdin_file;
+  lldb::FileSP stdout_file;
+  lldb::FileSP stderr_file;
   error = HandleFileAction(launch_info, options, kSimDeviceSpawnStdin,
                            STDIN_FILENO, stdin_file);
 
   if (error.Fail())
     return CoreSimulatorSupport::Process(error);
 
   error = HandleFileAction(launch_info, options, kSimDeviceSpawnStdout,
                            STDOUT_FILENO, stdout_file);

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.cpp

GDBRemoteCommunicationServerCommon::Handle_vFile_Open(
   packet.GetHexByteStringTerminatedBy(path, ',');
   if (!path.empty()) {
     if (packet.GetChar() == ',') {
       uint32_t flags = packet.GetHexMaxU32(false, 0);
       if (packet.GetChar() == ',') {
         mode_t mode = packet.GetHexMaxU32(false, 0600);
         FileSpec path_spec(path);
         FileSystem::Instance().Resolve(path_spec);
-        File file;
+        FileSP file;
         // Do not close fd.
         Status error =
             FileSystem::Instance().Open(file, path_spec, flags, mode, false);
         const int save_errno = error.GetError();
         StreamString response;
         response.PutChar('F');
-        response.Printf("%i", file.GetDescriptor());
+        response.Printf("%i", file ? file->GetDescriptor()
+                                   : File::kInvalidDescriptor);
         if (save_errno)
           response.Printf(",%i", save_errno);
         return SendPacketNoLock(response.GetString());
       }
     }
   }
   return SendErrorResponse(18);
 }

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

 namespace lldb {
 // Provide a function that can easily dump the packet history if we know a
 // ProcessGDBRemote * value (which we can get from logs or from debugging). We
 // need the function in the lldb namespace so it makes it into the final
 // executable since the LLDB shared library only exports stuff in the lldb
 // namespace. This allows you to attach with a debugger and call this function
 // and get the packet history dumped to a file.
 void DumpProcessGDBRemotePacketHistory(void *p, const char *path) {
-  StreamFile strm;
-  Status error = FileSystem::Instance().Open(strm.GetFile(), FileSpec(path),
+  FileSP file;
+  Status error = FileSystem::Instance().Open(file, FileSpec(path),
                                              File::eOpenOptionWrite |
                                                  File::eOpenOptionCanCreate);
-  if (error.Success())
-    ((ProcessGDBRemote *)p)->GetGDBRemote().DumpHistory(strm);
+  if (file) {
+    StreamFile stream(file);
+    ((ProcessGDBRemote *)p)->GetGDBRemote().DumpHistory(stream);
+  }
 }
 } // namespace lldb
 
 namespace {
 
 #define LLDB_PROPERTIES_processgdbremote
 #include "ProcessGDBRemoteProperties.inc"
 

lldb/source/Plugins/ScriptInterpreter/None/ScriptInterpreterNone.cpp

 ScriptInterpreterNone::ScriptInterpreterNone(Debugger &debugger)
     : ScriptInterpreter(debugger, eScriptLanguageNone) {}
 
 ScriptInterpreterNone::~ScriptInterpreterNone() {}
 
 bool ScriptInterpreterNone::ExecuteOneLine(llvm::StringRef command,
                                            CommandReturnObject *,
                                            const ExecuteScriptOptions &) {
-  m_debugger.GetErrorFile()->PutCString(
+  m_debugger.GetErrorStream().PutCString(
       "error: there is no embedded script interpreter in this mode.\n");
   return false;
 }
 
 void ScriptInterpreterNone::ExecuteInterpreterLoop() {
-  m_debugger.GetErrorFile()->PutCString(
+  m_debugger.GetErrorStream().PutCString(
       "error: there is no embedded script interpreter in this mode.\n");
 }
 
 void ScriptInterpreterNone::Initialize() {
   static llvm::once_flag g_once_flag;
 
   llvm::call_once(g_once_flag, []() {
     PluginManager::RegisterPlugin(GetPluginNameStatic(),

lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.h

public:
 
   using PythonObject::Reset;
 
   void Reset(PyRefType type, PyObject *py_obj) override;
   void Reset(File &file, const char *mode);
 
   static uint32_t GetOptionsFromMode(llvm::StringRef mode);
 
-  bool GetUnderlyingFile(File &file) const;
+  bool GetUnderlyingFile(lldb::FileSP &file) const;
 };
 
 } // namespace lldb_private
 
 #endif
 
 #endif // LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_PYTHONDATAOBJECTS_H

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

return PythonObject(PyRefType::Owned,
                       PyObject_CallObject(m_py_obj, arg_tuple.get()));
 }
 
 PythonFile::PythonFile() : PythonObject() {}
 
 PythonFile::PythonFile(File &file, const char *mode) { Reset(file, mode); }
 
 PythonFile::PythonFile(const char *path, const char *mode) {
-  lldb_private::File file;
+  lldb::FileSP file;
   FileSystem::Instance().Open(file, FileSpec(path), GetOptionsFromMode(mode));
-  Reset(file, mode);
+  if (file)
+    Reset(*file, mode);
+  else
+    Reset();
 }
 
 PythonFile::PythonFile(PyRefType type, PyObject *o) { Reset(type, o); }
 
 PythonFile::~PythonFile() {}
 
 bool PythonFile::Check(PyObject *py_obj) {
 #if PY_MAJOR_VERSION < 3
return llvm::StringSwitch<uint32_t>(mode.str())
       .Case("r+", File::eOpenOptionRead | File::eOpenOptionWrite)
       .Case("w+", File::eOpenOptionRead | File::eOpenOptionWrite |
                       File::eOpenOptionCanCreate | File::eOpenOptionTruncate)
       .Case("a+", File::eOpenOptionRead | File::eOpenOptionWrite |
                       File::eOpenOptionAppend | File::eOpenOptionCanCreate)
       .Default(0);
 }
 
-bool PythonFile::GetUnderlyingFile(File &file) const {
+bool PythonFile::GetUnderlyingFile(FileSP &file) const {
   if (!IsValid())
     return false;
 
-  file.Close();
+  if (file)
+    file->Close();
+
   // We don't own the file descriptor returned by this function, make sure the
   // File object knows about that.
   PythonString py_mode = GetAttributeValue("mode").AsType<PythonString>();
   auto options = PythonFile::GetOptionsFromMode(py_mode.GetString());
-  file.SetDescriptor(PyObject_AsFileDescriptor(m_py_obj), options, false);
-  return file.IsValid();
+  file = std::make_shared<File>(PyObject_AsFileDescriptor(m_py_obj), options,
+                                false);
+  return file->IsValid();
 }
 
 #endif

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

 )";
     break;
   case eIOHandlerWatchpoint:
     instructions = "Enter your Python command(s). Type 'DONE' to end.\n";
     break;
   }
 
   if (instructions) {
-    StreamFileSP output_sp(io_handler.GetOutputStreamFile());
+    StreamFileSP output_sp(io_handler.GetOutputStreamFileSP());
     if (output_sp && interactive) {
       output_sp->PutCString(instructions);
       output_sp->Flush();
     }
   }
 }
 
 void ScriptInterpreterPythonImpl::IOHandlerInputComplete(IOHandler &io_handler,
for (auto bp_options : *bp_options_vec) {
       if (GenerateBreakpointCommandCallbackData(data_up->user_source,
                                                 data_up->script_source)
               .Success()) {
         auto baton_sp = std::make_shared<BreakpointOptions::CommandBaton>(
             std::move(data_up));
         bp_options->SetCallback(
             ScriptInterpreterPythonImpl::BreakpointCallbackFunction, baton_sp);
       } else if (!batch_mode) {
-        StreamFileSP error_sp = io_handler.GetErrorStreamFile();
+        StreamFileSP error_sp = io_handler.GetErrorStreamFileSP();
         if (error_sp) {
           error_sp->Printf("Warning: No command attached to breakpoint.\n");
           error_sp->Flush();
         }
       }
     }
     m_active_io_handler = eIOHandlerNone;
   } break;
   case eIOHandlerWatchpoint: {
     WatchpointOptions *wp_options =
         (WatchpointOptions *)io_handler.GetUserData();
     auto data_up = std::make_unique<WatchpointOptions::CommandData>();
     data_up->user_source.SplitIntoLines(data);
 
     if (GenerateWatchpointCommandCallbackData(data_up->user_source,
                                               data_up->script_source)) {
       auto baton_sp =
           std::make_shared<WatchpointOptions::CommandBaton>(std::move(data_up));
       wp_options->SetCallback(
           ScriptInterpreterPythonImpl::WatchpointCallbackFunction, baton_sp);
     } else if (!batch_mode) {
-      StreamFileSP error_sp = io_handler.GetErrorStreamFile();
+      StreamFileSP error_sp = io_handler.GetErrorStreamFileSP();
       if (error_sp) {
         error_sp->Printf("Warning: No command attached to breakpoint.\n");
         error_sp->Flush();
       }
     }
     m_active_io_handler = eIOHandlerNone;
   } break;
   }
bool ScriptInterpreterPythonImpl::EnterSession(uint16_t on_entry_flags,
   run_string.Clear();
 
   PythonDictionary &sys_module_dict = GetSysModuleDictionary();
   if (sys_module_dict.IsValid()) {
     File in_file(in, false);
     File out_file(out, false);
     File err_file(err, false);
 
-    lldb::StreamFileSP in_sp;
+    lldb::FileSP in_sp;
     lldb::StreamFileSP out_sp;
     lldb::StreamFileSP err_sp;
     if (!in_file.IsValid() || !out_file.IsValid() || !err_file.IsValid())
       m_debugger.AdoptTopIOHandlerFilesIfInvalid(in_sp, out_sp, err_sp);
 
     if (on_entry_flags & Locker::NoSTDIN) {
       m_saved_stdin.Reset();
     } else {
       if (!SetStdHandle(in_file, "stdin", m_saved_stdin, "r")) {
         if (in_sp)
-          SetStdHandle(in_sp->GetFile(), "stdin", m_saved_stdin, "r");
+          SetStdHandle(*in_sp, "stdin", m_saved_stdin, "r");
       }
     }
 
     if (!SetStdHandle(out_file, "stdout", m_saved_stdout, "w")) {
       if (out_sp)
         SetStdHandle(out_sp->GetFile(), "stdout", m_saved_stdout, "w");
     }
 
if (!command.empty()) {
     // We want to call run_one_line, passing in the dictionary and the command
     // string.  We cannot do this through PyRun_SimpleString here because the
     // command string may contain escaped characters, and putting it inside
     // another string to pass to PyRun_SimpleString messes up the escaping.  So
     // we use the following more complicated method to pass the command string
     // directly down to Python.
     Debugger &debugger = m_debugger;
 
-    StreamFileSP input_file_sp;
+    FileSP input_file_sp;
     StreamFileSP output_file_sp;
     StreamFileSP error_file_sp;
     Communication output_comm(
         "lldb.ScriptInterpreterPythonImpl.ExecuteOneLine.comm");
     bool join_read_thread = false;
     if (options.GetEnableIO()) {
       if (result) {
-        input_file_sp = debugger.GetInputFile();
+        input_file_sp = debugger.GetInputFileSP();
         // Set output to a temporary file so we can forward the results on to
         // the result object
 
         Pipe pipe;
         Status pipe_result = pipe.CreateNew(false);
         if (pipe_result.Success()) {
 #if defined(_WIN32)
           lldb::file_t read_file = pipe.GetReadNativeHandle();
#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()->GetFile().GetStream());
-            result->SetImmediateErrorFile(
-                debugger.GetErrorFile()->GetFile().GetStream());
+                debugger.GetOutputFile().GetStream());
+            result->SetImmediateErrorFile(debugger.GetErrorFile().GetStream());
           }
         }
       }
       if (!input_file_sp || !output_file_sp || !error_file_sp)
         debugger.AdoptTopIOHandlerFilesIfInvalid(input_file_sp, output_file_sp,
                                                  error_file_sp);
     } else {
-      input_file_sp = std::make_shared<StreamFile>();
-      FileSystem::Instance().Open(input_file_sp->GetFile(),
-                                  FileSpec(FileSystem::DEV_NULL),
+
+      FileSystem::Instance().Open(input_file_sp, FileSpec(FileSystem::DEV_NULL),
                                   File::eOpenOptionRead);
 
-      output_file_sp = std::make_shared<StreamFile>();
-      FileSystem::Instance().Open(output_file_sp->GetFile(),
-                                  FileSpec(FileSystem::DEV_NULL),
+      FileSP f;
+      FileSystem::Instance().Open(f, FileSpec(FileSystem::DEV_NULL),
                                   File::eOpenOptionWrite);
-
-      error_file_sp = output_file_sp;
+      error_file_sp = output_file_sp = std::make_shared<StreamFile>(f);
     }
 
-    FILE *in_file = input_file_sp->GetFile().GetStream();
+    FILE *in_file = input_file_sp->GetStream();
     FILE *out_file = output_file_sp->GetFile().GetStream();
     FILE *err_file = error_file_sp->GetFile().GetStream();
     bool success = false;
     {
       // WARNING!  It's imperative that this RAII scope be as tight as
       // possible. In particular, the scope must end *before* we try to join
       // the read thread.  The reason for this is that a pre-requisite for
       // joining the read thread is that we close the write handle (to break
void ScriptInterpreterPythonImpl::ExecuteInterpreterLoop() {
   Debugger &debugger = m_debugger;
 
   // At the moment, the only time the debugger does not have an input file
   // handle is when this is called directly from Python, in which case it is
   // both dangerous and unnecessary (not to mention confusing) to try to embed
   // a running interpreter loop inside the already running Python interpreter
   // loop, so we won't do it.
 
-  if (!debugger.GetInputFile()->GetFile().IsValid())
+  if (!debugger.GetInputFile().IsValid())
     return;
 
   IOHandlerSP io_handler_sp(new IOHandlerPythonInterpreter(debugger, this));
   if (io_handler_sp) {
     debugger.PushIOHandler(io_handler_sp);
   }
 }
 

lldb/source/Target/ModuleCache.cpp

if ((result[i] >= 1 && result[i] <= 31) ||
         strchr(kFSIllegalChars, result[i]) != nullptr)
       result[i] = '_';
   }
   return result;
 }
 
 class ModuleLock {
 private:
-  File m_file;
+  FileSP m_file_sp;
   std::unique_ptr<lldb_private::LockFile> m_lock;
   FileSpec m_file_spec;
 
 public:
   ModuleLock(const FileSpec &root_dir_spec, const UUID &uuid, Status &error);
   void Delete();
 };
 

 ModuleLock::ModuleLock(const FileSpec &root_dir_spec, const UUID &uuid,
                        Status &error) {
   const auto lock_dir_spec = JoinPath(root_dir_spec, kLockDirName);
   error = MakeDirectory(lock_dir_spec);
   if (error.Fail())
     return;
 
   m_file_spec = JoinPath(lock_dir_spec, uuid.GetAsString().c_str());
-  FileSystem::Instance().Open(m_file, m_file_spec,
+  FileSystem::Instance().Open(m_file_sp, m_file_spec,
                               File::eOpenOptionWrite |
                                   File::eOpenOptionCanCreate |
                                   File::eOpenOptionCloseOnExec);
-  if (!m_file) {
+  if (!m_file_sp) {
     error.SetErrorToErrno();
     return;
   }
 
-  m_lock.reset(new lldb_private::LockFile(m_file.GetDescriptor()));
+  m_lock.reset(new lldb_private::LockFile(m_file_sp->GetDescriptor()));
   error = m_lock->WriteLock(0, 1);
   if (error.Fail())
     error.SetErrorStringWithFormat("Failed to lock file: %s",
                                    error.AsCString());
 }
 
 void ModuleLock::Delete() {
-  if (!m_file)
+  if (!m_file_sp)
     return;
 
-  m_file.Close();
+  m_file_sp->Close();
+  m_file_sp.reset();
   llvm::sys::fs::remove(m_file_spec.GetPath());
 }
 
 /////////////////////////////////////////////////////////////////////////
 
 Status ModuleCache::Put(const FileSpec &root_dir_spec, const char *hostname,
                         const ModuleSpec &module_spec, const FileSpec &tmp_file,
                         const FileSpec &target_file) {

lldb/source/Target/Platform.cpp

Status Platform::PutFile(const FileSpec &source, const FileSpec &destination,
   LLDB_LOGF(log, "[PutFile] Using block by block transfer....\n");
 
   uint32_t source_open_options =
       File::eOpenOptionRead | File::eOpenOptionCloseOnExec;
   namespace fs = llvm::sys::fs;
   if (fs::is_symlink_file(source.GetPath()))
     source_open_options |= File::eOpenOptionDontFollowSymlinks;
 
-  File source_file;
+  FileSP source_file;
   Status error = FileSystem::Instance().Open(
       source_file, source, source_open_options, lldb::eFilePermissionsUserRW);
-  uint32_t permissions = source_file.GetPermissions(error);
+  if (!source_file || !source_file->IsValid())
+    return Status("PutFile: unable to open source file");
+  uint32_t permissions = source_file->GetPermissions(error);
   if (permissions == 0)
     permissions = lldb::eFilePermissionsFileDefault;
 
-  if (!source_file.IsValid())
-    return Status("PutFile: unable to open source file");
   lldb::user_id_t dest_file = OpenFile(
       destination, File::eOpenOptionCanCreate | File::eOpenOptionWrite |
                        File::eOpenOptionTruncate | File::eOpenOptionCloseOnExec,
       permissions, error);
   LLDB_LOGF(log, "dest_file = %" PRIu64 "\n", dest_file);
 
   if (error.Fail())
     return error;
   if (dest_file == UINT64_MAX)
     return Status("unable to open target file");
   lldb::DataBufferSP buffer_sp(new DataBufferHeap(1024 * 16, 0));
   uint64_t offset = 0;
   for (;;) {
     size_t bytes_read = buffer_sp->GetByteSize();
-    error = source_file.Read(buffer_sp->GetBytes(), bytes_read);
+    error = source_file->Read(buffer_sp->GetBytes(), bytes_read);
     if (error.Fail() || bytes_read == 0)
       break;
 
     const uint64_t bytes_written =
         WriteFile(dest_file, offset, buffer_sp->GetBytes(), bytes_read, error);
     if (error.Fail())
       break;
 
     offset += bytes_written;
     if (bytes_written != bytes_read) {
       // We didn't write the correct number of bytes, so adjust the file
       // position in the source file we are reading from...
-      source_file.SeekFromStart(offset);
+      source_file->SeekFromStart(offset);
     }
   }
   CloseFile(dest_file, error);
 
   if (uid == UINT32_MAX && gid == UINT32_MAX)
     return error;
 
   // TODO: ChownFile?
lldb::ProcessSP Platform::ConnectProcess(llvm::StringRef connect_url,
 
   debugger.GetTargetList().SetSelectedTarget(target);
 
   lldb::ProcessSP process_sp =
       target->CreateProcess(debugger.GetListener(), plugin_name, nullptr);
   if (!process_sp)
     return nullptr;
 
-  error =
-      process_sp->ConnectRemote(debugger.GetOutputFile().get(), connect_url);
+  error = process_sp->ConnectRemote(&debugger.GetOutputStream(), connect_url);
   if (error.Fail())
     return nullptr;
 
   return process_sp;
 }
 
 size_t Platform::ConnectToWaitingProcesses(lldb_private::Debugger &debugger,
                                            lldb_private::Status &error) {

lldb/source/Target/Process.cpp

Process::CreateBreakpointSite(const BreakpointLocationSP &owner,
 
   if (owner->ShouldResolveIndirectFunctions()) {
     Symbol *symbol = owner->GetAddress().CalculateSymbolContextSymbol();
     if (symbol && symbol->IsIndirect()) {
       Status error;
       Address symbol_address = symbol->GetAddress();
       load_addr = ResolveIndirectFunction(&symbol_address, error);
       if (!error.Success() && show_error) {
-        GetTarget().GetDebugger().GetErrorFile()->Printf(
+        GetTarget().GetDebugger().GetErrorStream().Printf(
             "warning: failed to resolve indirect function at 0x%" PRIx64
             " for breakpoint %i.%i: %s\n",
             symbol->GetLoadAddress(&GetTarget()),
             owner->GetBreakpoint().GetID(), owner->GetID(),
             error.AsCString() ? error.AsCString() : "unknown error");
         return LLDB_INVALID_BREAK_ID;
       }
       Address resolved_address(load_addr);
if (bp_site_sp) {
       if (bp_site_sp) {
         Status error = EnableBreakpointSite(bp_site_sp.get());
         if (error.Success()) {
           owner->SetBreakpointSite(bp_site_sp);
           return m_breakpoint_site_list.Add(bp_site_sp);
         } else {
           if (show_error || use_hardware) {
             // Report error for setting breakpoint...
-            GetTarget().GetDebugger().GetErrorFile()->Printf(
+            GetTarget().GetDebugger().GetErrorStream().Printf(
                 "warning: failed to set breakpoint site at 0x%" PRIx64
                 " for breakpoint %i.%i: %s\n",
                 load_addr, owner->GetBreakpoint().GetID(), owner->GetID(),
                 error.AsCString() ? error.AsCString() : "unknown error");
           }
         }
       }
     }

 }
 
 class IOHandlerProcessSTDIO : public IOHandler {
 public:
   IOHandlerProcessSTDIO(Process *process, int write_fd)
       : IOHandler(process->GetTarget().GetDebugger(),
                   IOHandler::Type::ProcessIO),
         m_process(process),
+        m_read_file(GetInputFD(), File::eOpenOptionRead, false),
         m_write_file(write_fd, File::eOpenOptionWrite, false) {
     m_pipe.CreateNew(false);
-    m_read_file.SetDescriptor(GetInputFD(), File::eOpenOptionRead, false);
   }
 
   ~IOHandlerProcessSTDIO() override = default;
 
   // Each IOHandler gets to run until it is done. It should read data from the
   // "in" and place output into "out" and "err and return when done.
   void Run() override {
     if (!m_read_file.IsValid() || !m_write_file.IsValid() ||

lldb/source/Target/Target.cpp

 
 static void LoadScriptingResourceForModule(const ModuleSP &module_sp,
                                            Target *target) {
   Status error;
   StreamString feedback_stream;
   if (module_sp && !module_sp->LoadScriptingResourceInTarget(
                        target, error, &feedback_stream)) {
     if (error.AsCString())
-      target->GetDebugger().GetErrorFile()->Printf(
+      target->GetDebugger().GetErrorStream().Printf(
           "unable to load scripting data for module %s - error reported was "
           "%s\n",
           module_sp->GetFileSpec().GetFileNameStrippingExtension().GetCString(),
           error.AsCString());
   }
   if (feedback_stream.GetSize())
-    target->GetDebugger().GetErrorFile()->Printf("%s\n",
+    target->GetDebugger().GetErrorStream().Printf("%s\n",
                                                   feedback_stream.GetData());
 }
 
 void Target::ClearModules(bool delete_locations) {
   ModulesDidUnload(m_images, delete_locations);
   m_section_load_history.Clear();
   m_images.Clear();
   m_scratch_type_system_map.Clear();
   m_ast_importer_sp.reset();

lldb/source/Target/ThreadPlanTracer.cpp

ThreadPlanTracer::ThreadPlanTracer(Thread &thread)
     : m_thread(thread), m_single_step(true), m_enabled(false), m_stream_sp() {}
 
 Stream *ThreadPlanTracer::GetLogStream() {
   if (m_stream_sp)
     return m_stream_sp.get();
   else {
     TargetSP target_sp(m_thread.CalculateTarget());
     if (target_sp)
-      return target_sp->GetDebugger().GetOutputFile().get();
+      return &(target_sp->GetDebugger().GetOutputStream());
   }
   return nullptr;
 }
 
 void ThreadPlanTracer::Log() {
   SymbolContext sc;
   bool show_frame_index = false;
   bool show_fullpaths = false;

lldb/unittests/ScriptInterpreter/Python/PythonDataObjectsTests.cpp

TEST_F(PythonDataObjectsTest, TestPythonCallableInvoke) {
   auto list_result = result.AsType<PythonList>();
   EXPECT_EQ(3U, list_result.GetSize());
   EXPECT_EQ(one.get(), list_result.GetItemAtIndex(0).get());
   EXPECT_EQ(two.get(), list_result.GetItemAtIndex(1).get());
   EXPECT_EQ(three.get(), list_result.GetItemAtIndex(2).get());
 }
 
 TEST_F(PythonDataObjectsTest, TestPythonFile) {
-  File file;
+  lldb::FileSP file;
   FileSystem::Instance().Open(file, FileSpec(FileSystem::DEV_NULL),
                               File::eOpenOptionRead);
-  PythonFile py_file(file, "r");
+  EXPECT_TRUE(file);
+  if (file) {
+    PythonFile py_file(*file, "r");
     EXPECT_TRUE(PythonFile::Check(py_file.get()));
   }
+}
 
 TEST_F(PythonDataObjectsTest, TestObjectAttributes) {
   PythonInteger py_int(42);
   EXPECT_TRUE(py_int.HasAttribute("numerator"));
   EXPECT_FALSE(py_int.HasAttribute("this_should_not_exist"));
 
   PythonInteger numerator_attr =
       py_int.GetAttributeValue("numerator").AsType<PythonInteger>();