new api class: SBFile

[lawrence_danna]

Summary

SBFile is a scripting API wrapper for lldb_private::File

This is the first step in a project to enable arbitrary python
io.IOBase file objects -- including those that override the read()
and write() methods -- to be used as the main debugger IOStreams.

Currently this is impossible because python file objects must first
be converted into FILE* streams by SWIG in order to be passed into
the debugger.

full prototype: https://github.com/smoofra/llvm-project/tree/files

[labath]

This is an interesting undertaking. There's a lot of confusion about FILE* in lldb, and it would be great to clean some of that stuff up.

The api seems reasonably straight-forward. The one thing that struck me is that you're using unique_ptrs for the pimpled objects. That would mean the SBFile objects are non-copyable, which is generally not a good thing, as python really likes to copy things. Looking ahead at your patchset, it looks like I am onto something, as you're then trying to implement shared semantics inside lldb_private::File. That doesn't sound like the most fortunate solution to me, as most of the lldb_private::File users don't need that functionality. I am wondering if it wouldn't be better to use a shared_ptr in SBFile, and implement any extra sharing semantics you need at the SB level. Also, this needs a bunch of tests.

From a higher level perspective, it would be good to have a couple of paragraphs saying what exactly is the end goal here (what new apis will you introduce, how will they work, etc.). I can sort of guess some of that from looking at the patchset, but it would be nice to have that written down, so that we know we're on the same page. This looks like it is a sufficiently big of a change that it would deserve a quick RFC email to lldb-dev.

lldb/source/API/SBFile.cpp

20–26 ↗

(On Diff #220943)

I think it would be better if these were constructors instead of member functions. That way you might be able to get rid of the all the if (!m_opaque_up) { checks as the File member will always be initialized.

21 ↗

(On Diff #220943)

It looks like you need to reformat this file.

[lawrence_danna]

In D67793#1676592, @labath wrote:

The api seems reasonably straight-forward. The one thing that struck me is that you're using unique_ptrs for the pimpled objects. That would mean the SBFile objects are non-copyable, which is generally not a good thing, as python really likes to copy things. Looking ahead at your patchset, it looks like I am onto something, as you're then trying to implement shared semantics inside lldb_private::File. That doesn't sound like the most fortunate solution to me, as most of the lldb_private::File users don't need that functionality. I am wondering if it wouldn't be better to use a shared_ptr in SBFile, and implement any extra sharing semantics you need at the SB level. Also, this needs a bunch of tests.

That was my initial thought as well, to use a shared_ptr here, and not have any sharing at the lldb_private::File level. However, I found I couldn't do it that way. lldb_private::File doesn't really have the semantics of a file object, it has the semantics of a variable, which can point to a file object. Users of lldb_private::File expect to be able to Close() a file and re-open it as something else. They expect to be able to embed File immediately in other objects. They expect to be able to make an empty File and check it with IsValid(). I thought it would be best to let them keep using File in that way, so later in the queue I make File copyable and add FileOps class to manage the sharing between copied files. The other way to do it would be to track down every use of lldb_private::File that isn't through a pointer and convert it to shared_ptr<File> instead. Then SBFile could just be another shared_ptr<File>. Should I do it that way?

As far as python copying things goes, that's not a problem. SWIG will always allocate a SBFile on the heap and copy the pointers to it, it doesn't need an actual C++ copy constructor.

[lawrence_danna]

added some tests, rebased

[lawrence_danna]

@labath So what do you think?
Update all the lldb_private::File clients to use shared_ptr<File> instead?
Or do it this way, with sharing handled inside of File?

[lawrence_danna]

@labath

I wrote a patch for the shared_ptr approach. It's simple, but it touches a lot of lines.

https://reviews.llvm.org/D67891

Now that I've gone and done it, I kind of like it better that way. If you approve the other patch, I'll update this one accordingly.

[labath]

In D67793#1678259, @lawrence_danna wrote:

@labath

I wrote a patch for the shared_ptr approach. It's simple, but it touches a lot of lines.

https://reviews.llvm.org/D67891

Now that I've gone and done it, I kind of like it better that way. If you approve the other patch, I'll update this one accordingly.

Thanks for the quick turnaround. /I think/ the approach in the other patch looks better (I am super happy about the removal of the SetXXX methods), but I'd still like to understand whether we need to introduce that many shared_ptrs, so I'll need to think about this some more (I just got back from vacation and I am still working through my backlog).

[lawrence_danna]

changed unique_ptr to shared_ptr

[lawrence_danna]

lldb/source/API/SBFile.cpp

20–26 ↗

(On Diff #220943)

Unfortunately, SWIG does not allow return types that don't have default constructors.

https://github.com/swig/swig/issues/1062

[labath]

lldb/source/API/SBFile.cpp

20–26 ↗

(On Diff #220943)

Hmm.. that is unfortunate. I guess that means we still need the validity checks, but you should still be able to replace these with constructors, right? (you've guessed by now that I am not a fan of Set methods :) ).

[lawrence_danna]

rebased, and converted Set* methods into constructors.

[lawrence_danna]

@labath, OK sets are now constructors.

[lawrence_danna]

rebased, removed duplicate test

[labath]

Thanks. This looks good to me, but given that this is going to become a stable api that well need to maintain for a looong time, I'd like to get signoff from someone else as well. @jingham maybe ?

lldb/include/lldb/API/SBDefines.h

95 ↗

(On Diff #222264)

Sort this list ?

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

27 ↗

(On Diff #222264)

Please add a comment to explain why is this needed (I guess that has something to do with needing more control over the command output stream), because superficially it looks like you're reimplementing TestBase.runCmd here.

37–38 ↗

(On Diff #222264)

Maybe instead of raise_on_fail this should be called check (in analogy to runCmd function), and instead of raising an exception you could assert that ret.Succeeded() is true?

52 ↗

(On Diff #222264)

I believe all of these will end up writing to the source tree. Could you try replacing that with self.getBuildArtifact("output") ?

127–132 ↗

(On Diff #222264)

delete

lldb/scripts/interface/SBFile.i

36 ↗

(On Diff #222264)

add operator bool here. I'm not sure if swig handles operator!, but if it does, then we should add that too.

lldb/source/API/SBFile.cpp

1 ↗

(On Diff #222264)

I think you'll need to add the reproducer boilerplate to this file. I think it should be possible to do that automatically via lldb-instr, but I've never done that. @JDevlieghere should be able to help here.

lldb/source/Host/common/File.cpp

72–74 ↗

(On Diff #222264)

I know you're just copying, but could you remove the .str() call the `.empty() check, as neither of them are really needed here.

[jingham]

This looks fine to me, it doesn't look like you are leaving out anything useful.

Note, I think just to enforce the "default constructor" discipline, there's a test in the test suite (python_api/default-constructor/TestDefaultConstructorForAPIObjects.py) that has a file per class that just makes a default constructed object and calls all of its methods to make sure they don't crash. According to that pattern your test_sbfile_invalid test should actually go there.

[lawrence_danna]

fixed according to reviewer comments

[lawrence_danna]

addressed comments

[lawrence_danna]

flush fix for python2

[lawrence_danna]

add reproducer instrumentation.

[lawrence_danna]

lldb/scripts/Python/python-typemaps.swig

464 ↗

(On Diff #222528)

swig/LICENSE says the following, so it should be fine to copy and paste these.

The SWIG library and examples, under the Lib and Examples top level 
directories, are distributed under the following terms:

  You may copy, modify, distribute, and make derivative works based on
  this software, in source code or object code form, without
  restriction. If you distribute the software to others, you may do
  so according to the terms of your choice. This software is offered as
  is, without warranty of any kind.

[lawrence_danna]

no inlines in the API

[lawrence_danna]

@labath any more comments on this one?

[labath]

Nah, this looks fine to me now.

[labath]

BTW, I've had to add (or rather, extend) a fairly ugly hack in r373573 in order to get the new tests running on non-darwin platforms. The reason for that is that the FILE* out typemap needs to get the "mode" of the object in order to construct the python wrapper.

My hope is that we can be improved once you're finished your work here. For instance by reimplementing GetOutputFileHandle on top of GetOutputFile in swig, as the latter will (hopefully) be able to get the mode of a file correctly. Does that sound reasonable, or am I totally off-track here?

[lawrence_danna]

In D67793#1692544, @labath wrote:

BTW, I've had to add (or rather, extend) a fairly ugly hack in r373573 in order to get the new tests running on non-darwin platforms. The reason for that is that the FILE* out typemap needs to get the "mode" of the object in order to construct the python wrapper.

My hope is that we can be improved once you're finished your work here. For instance by reimplementing GetOutputFileHandle on top of GetOutputFile in swig, as the latter will (hopefully) be able to get the mode of a file correctly. Does that sound reasonable, or am I totally off-track here?

oops, sorry I missed this. Are you happy with how it all turned out?

[labath]

In D67793#1713981, @lawrence_danna wrote:

In D67793#1692544, @labath wrote:

BTW, I've had to add (or rather, extend) a fairly ugly hack in r373573 in order to get the new tests running on non-darwin platforms. The reason for that is that the FILE* out typemap needs to get the "mode" of the object in order to construct the python wrapper.

My hope is that we can be improved once you're finished your work here. For instance by reimplementing GetOutputFileHandle on top of GetOutputFile in swig, as the latter will (hopefully) be able to get the mode of a file correctly. Does that sound reasonable, or am I totally off-track here?

oops, sorry I missed this. Are you happy with how it all turned out?

Yes, very much. Thank you for cleaning that up.

[mgorny]

While looking at the other bug, I noticed something suspicious here.

lldb/trunk/source/Host/common/File.cpp

74

Shouldn't this also include File::eOpenOptionCanCreate | File::eOpenOptionTruncate?

[labath]

lldb/trunk/source/Host/common/File.cpp

74

Yeah, I guess it should, though it probably does not matter in practice right now as we're only using this on already opened FILE* objects.

[vadimcn]

lldb/trunk/scripts/Python/python-typemaps.swig

481

Sorry for being late to the party, but I just stumbled upon this code...

It seems to return a pointer from a view that had just been released. Isn't this kind of risky? While most of the time buffer views point into object's internal memory, buffer protocol does not prohibit allocating memory just to fulfill the buffer request. In which case PyBuffer_Release would be expected to release that memory, leaving the caller with a dangling pointer.

[labath]

lldb/trunk/scripts/Python/python-typemaps.swig

481

Yes, that does seem worrying, though the swig typemap also does the same thing (but it could have the same bug too). @lawrence_danna, do you know anything about this? Should the buffer be released after the function returns (in the "out" typemap, I guess)?

[lawrence_danna]

lldb/trunk/scripts/Python/python-typemaps.swig

481

@vadimcn is correct. If GetBuffer allocates to fulfill the request, rather than returning a pre-existing buffer, then this will access a dangling pointer.

@labath "in" and "out" type-maps aren't paired up like that.

I believe there is a way you can instruct SWIG to create a C++ helper variable for a typemap. The solution in this case is to use such a temporary to carry the PyBuffer reference in RAII-style.

lldb/trunk/include/lldb/API/LLDB.h

 //===-- LLDB.h --------------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_LLDB_h_
 #define LLDB_LLDB_h_
 
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBAttachInfo.h"
 #include "lldb/API/SBBlock.h"
 #include "lldb/API/SBBreakpoint.h"
-#include "lldb/API/SBBreakpointName.h"
 #include "lldb/API/SBBreakpointLocation.h"
+#include "lldb/API/SBBreakpointName.h"
 #include "lldb/API/SBBroadcaster.h"
 #include "lldb/API/SBCommandInterpreter.h"
 #include "lldb/API/SBCommandReturnObject.h"
 #include "lldb/API/SBCommunication.h"
 #include "lldb/API/SBCompileUnit.h"
 #include "lldb/API/SBData.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBDeclaration.h"
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBExecutionContext.h"
 #include "lldb/API/SBExpressionOptions.h"
+#include "lldb/API/SBFile.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBFileSpecList.h"
 #include "lldb/API/SBFrame.h"
 #include "lldb/API/SBFunction.h"
 #include "lldb/API/SBHostOS.h"
 #include "lldb/API/SBInstruction.h"
 #include "lldb/API/SBInstructionList.h"
 #include "lldb/API/SBLanguageRuntime.h"

lldb/trunk/include/lldb/API/SBDefines.h

 class LLDB_API SBData;
 class LLDB_API SBDebugger;
 class LLDB_API SBDeclaration;
 class LLDB_API SBError;
 class LLDB_API SBEvent;
 class LLDB_API SBEventList;
 class LLDB_API SBExecutionContext;
 class LLDB_API SBExpressionOptions;
+class LLDB_API SBFile;
 class LLDB_API SBFileSpec;
 class LLDB_API SBFileSpecList;
 class LLDB_API SBFrame;
 class LLDB_API SBFunction;
 class LLDB_API SBHostOS;
 class LLDB_API SBInstruction;
 class LLDB_API SBInstructionList;
 class LLDB_API SBLanguageRuntime;

lldb/trunk/include/lldb/API/SBError.h

protected:
   friend class SBProcess;
   friend class SBReproducer;
   friend class SBStructuredData;
   friend class SBTarget;
   friend class SBThread;
   friend class SBTrace;
   friend class SBValue;
   friend class SBWatchpoint;
+  friend class SBFile;
 
   lldb_private::Status *get();
 
   lldb_private::Status *operator->();
 
   const lldb_private::Status &operator*() const;
 
   lldb_private::Status &ref();

lldb/trunk/include/lldb/API/SBFile.h

+//===-- SBFile.h --------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_SBFile_h_
+#define LLDB_SBFile_h_
+
+#include "lldb/API/SBDefines.h"
+
+namespace lldb {
+
+class LLDB_API SBFile {
+public:
+  SBFile();
+  SBFile(FILE *file, bool transfer_ownership);
+  SBFile(int fd, const char *mode, bool transfer_ownership);
+  ~SBFile();
+
+  SBError Read(uint8_t *buf, size_t num_bytes, size_t *bytes_read);
+  SBError Write(const uint8_t *buf, size_t num_bytes, size_t *bytes_written);
+  SBError Flush();
+  bool IsValid() const;
+  SBError Close();
+
+  operator bool() const;
+  bool operator!() const;
+
+private:
+  FileSP m_opaque_sp;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBFile_h_

lldb/trunk/include/lldb/Host/File.h

public:
   ///
   /// \return
   ///     The underlying FILE* stream from this File, if one exists and can be extracted,
   ///     nullptr otherwise.
   FILE *TakeStreamAndClear();
 
   int GetDescriptor() const;
 
+  static uint32_t GetOptionsFromMode(llvm::StringRef mode);
+
   WaitableHandle GetWaitableHandle() override;
 
   FILE *GetStream();
 
   /// 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-

lldb/trunk/packages/Python/lldbsuite/test/python_api/default-constructor/TestDefaultConstructorForAPIObjects.py

def test_SBFunction(self):
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_function
         sb_function.fuzz_obj(obj)
 
     @add_test_categories(['pyapi'])
     @no_debug_info_test
+    def test_SBFile(self):
+        sbf = lldb.SBFile()
+        self.assertFalse(sbf.IsValid())
+        self.assertFalse(bool(sbf))
+        e, n = sbf.Write(b'foo')
+        self.assertTrue(e.Fail())
+        self.assertEqual(n, 0)
+        buffer = bytearray(100)
+        e, n = sbf.Read(buffer)
+        self.assertEqual(n, 0)
+        self.assertTrue(e.Fail())
+
+    @add_test_categories(['pyapi'])
+    @no_debug_info_test
     def test_SBInstruction(self):
         obj = lldb.SBInstruction()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_instruction
         sb_instruction.fuzz_obj(obj)

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

+"""
+Test lldb Python API for file handles.
+"""
+
+from __future__ import print_function
+
+import os
+import io
+import re
+import sys
+from contextlib import contextmanager
+
+import lldb
+from lldbsuite.test import  lldbtest
+from lldbsuite.test.decorators import add_test_categories, no_debug_info_test
+
+
+def readStrippedLines(f):
+    def i():
+        for line in f:
+            line = line.strip()
+            if line:
+                yield line
+    return list(i())
+
+
+class FileHandleTestCase(lldbtest.TestBase):
+
+    mydir = lldbtest.Base.compute_mydir(__file__)
+
+    # The way this class interacts with the debugger is different
+    # than normal.   Most of these test cases will mess with the
+    # debugger I/O streams, so we want a fresh debugger for each
+    # test so those mutations don't interfere with each other.
+    #
+    # Also, the way normal tests evaluate debugger commands is
+    # by using a SBCommandInterpreter directly, which captures
+    # the output in a result object.   For many of tests tests
+    # we want the debugger to write the  output directly to
+    # its I/O streams like it would have done interactively.
+    #
+    # For this reason we also define handleCmd() here, even though
+    # it is similar to runCmd().
+
+    def setUp(self):
+        super(FileHandleTestCase, self).setUp()
+        self.debugger = lldb.SBDebugger.Create()
+        self.out_filename = self.getBuildArtifact('output')
+        self.in_filename = self.getBuildArtifact('input')
+
+    def tearDown(self):
+        lldb.SBDebugger.Destroy(self.debugger)
+        super(FileHandleTestCase, self).tearDown()
+        for name in (self.out_filename, self.in_filename):
+            if os.path.exists(name):
+                os.unlink(name)
+
+    # Similar to runCmd(), but this uses the per-test debugger, and it
+    # supports, letting the debugger just print the results instead
+    # of collecting them.
+    def handleCmd(self, cmd, check=True, collect_result=True):
+        assert not check or collect_result
+        ret = lldb.SBCommandReturnObject()
+        if collect_result:
+            interpreter = self.debugger.GetCommandInterpreter()
+            interpreter.HandleCommand(cmd, ret)
+        else:
+            self.debugger.HandleCommand(cmd)
+        if collect_result and check:
+            self.assertTrue(ret.Succeeded())
+        return ret.GetOutput()
+
+
+    @add_test_categories(['pyapi'])
+    @no_debug_info_test
+    def test_legacy_file_out_script(self):
+        with open(self.out_filename, 'w') as f:
+            self.debugger.SetOutputFileHandle(f, False)
+            # scripts print to output even if you capture the results
+            # I'm not sure I love that behavior, but that's the way
+            # it's been for a long time.  That's why this test works
+            # even with collect_result=True.
+            self.handleCmd('script 1+1')
+            self.debugger.GetOutputFileHandle().write('FOO\n')
+        lldb.SBDebugger.Destroy(self.debugger)
+        with open(self.out_filename, 'r') as f:
+            self.assertEqual(readStrippedLines(f), ['2', 'FOO'])
+
+
+    @add_test_categories(['pyapi'])
+    @no_debug_info_test
+    def test_legacy_file_out(self):
+        with open(self.out_filename, 'w') as f:
+            self.debugger.SetOutputFileHandle(f, False)
+            self.handleCmd('p/x 3735928559', collect_result=False, check=False)
+        lldb.SBDebugger.Destroy(self.debugger)
+        with open(self.out_filename, 'r') as f:
+            self.assertIn('deadbeef', f.read())
+
+
+    @add_test_categories(['pyapi'])
+    @no_debug_info_test
+    def test_legacy_file_err(self):
+        with open(self.out_filename, 'w') as f:
+            self.debugger.SetErrorFileHandle(f, False)
+            self.handleCmd('lol', check=False, collect_result=False)
+        lldb.SBDebugger.Destroy(self.debugger)
+        with open(self.out_filename, 'r') as f:
+            self.assertIn("is not a valid command", f.read())
+
+
+    @add_test_categories(['pyapi'])
+    @no_debug_info_test
+    def test_sbfile_type_errors(self):
+        sbf = lldb.SBFile()
+        self.assertRaises(TypeError, sbf.Write, None)
+        self.assertRaises(TypeError, sbf.Read, None)
+        self.assertRaises(TypeError, sbf.Read, b'this bytes is not mutable')
+        self.assertRaises(TypeError, sbf.Write, u"ham sandwich")
+        self.assertRaises(TypeError, sbf.Read, u"ham sandwich")
+
+
+    @add_test_categories(['pyapi'])
+    @no_debug_info_test
+    def test_sbfile_write(self):
+        with open(self.out_filename, 'w') as f:
+            sbf = lldb.SBFile(f.fileno(), "w", False)
+            self.assertTrue(sbf.IsValid())
+            e, n = sbf.Write(b'FOO\nBAR')
+            self.assertTrue(e.Success())
+            self.assertEqual(n, 7)
+            sbf.Close()
+            self.assertFalse(sbf.IsValid())
+        with open(self.out_filename, 'r') as f:
+            self.assertEqual(readStrippedLines(f), ['FOO', 'BAR'])
+
+
+    @add_test_categories(['pyapi'])
+    @no_debug_info_test
+    def test_sbfile_read(self):
+        with open(self.out_filename, 'w') as f:
+            f.write('FOO')
+        with open(self.out_filename, 'r') as f:
+            sbf = lldb.SBFile(f.fileno(), "r", False)
+            self.assertTrue(sbf.IsValid())
+            buffer = bytearray(100)
+            e, n = sbf.Read(buffer)
+            self.assertTrue(e.Success())
+            self.assertEqual(buffer[:n], b'FOO')
+

lldb/trunk/scripts/Python/python-typemaps.swig

%typemap(argout) (void *buf, size_t size) {
    }
    free($1);
 }
 
 %{
 namespace {
 template <class T>
 T PyLongAsT(PyObject *obj) {
-  static_assert(true, "unsupported type"); 
+  static_assert(true, "unsupported type");
 }
 
 template <> uint64_t PyLongAsT<uint64_t>(PyObject *obj) {
   return static_cast<uint64_t>(PyLong_AsUnsignedLongLong(obj));
 }
 
 template <> uint32_t PyLongAsT<uint32_t>(PyObject *obj) {
   return static_cast<uint32_t>(PyLong_AsUnsignedLong(obj));
else if (PythonString::Check($input))
         py_str.release();
     }
     else
     {
         PyErr_SetString(PyExc_TypeError,"not a string-like object");
         return NULL;
     }
 }
+
+// These two pybuffer macros are copied out of swig/Lib/python/pybuffer.i,
+// and fixed so they will not crash if PyObject_GetBuffer fails.
+// https://github.com/swig/swig/issues/1640
+
+%define %pybuffer_mutable_binary(TYPEMAP, SIZE)
+%typemap(in) (TYPEMAP, SIZE) {
+  int res; Py_ssize_t size = 0; void *buf = 0;
+  Py_buffer view;
+  res = PyObject_GetBuffer($input, &view, PyBUF_WRITABLE);
+  if (res < 0) {
+    PyErr_Clear();
+    %argument_fail(res, "(TYPEMAP, SIZE)", $symname, $argnum);
+  }
+  size = view.len;
+  buf = view.buf;
+  PyBuffer_Release(&view);
+  $1 = ($1_ltype) buf;
+  $2 = ($2_ltype) (size/sizeof($*1_type));
+}
+%enddef
+
+%define %pybuffer_binary(TYPEMAP, SIZE)
+%typemap(in) (TYPEMAP, SIZE) {
+  int res; Py_ssize_t size = 0; const void *buf = 0;
+  Py_buffer view;
+  res = PyObject_GetBuffer($input, &view, PyBUF_CONTIG_RO);
+  if (res < 0) {
+    PyErr_Clear();
+    %argument_fail(res, "(TYPEMAP, SIZE)", $symname, $argnum);
+  }
+  size = view.len;
+  buf = view.buf;
+  PyBuffer_Release(&view);
+  $1 = ($1_ltype) buf;
+  $2 = ($2_ltype) (size / sizeof($*1_type));
+}
+%enddef
+
+%pybuffer_binary(const uint8_t *buf, size_t num_bytes);
+%pybuffer_mutable_binary(uint8_t *buf, size_t num_bytes);

lldb/trunk/scripts/interface/SBFile.i

+//===-- SWIG Interface for SBFile -----------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+namespace lldb {
+
+%feature("docstring",
+"Represents a file."
+) SBFile;
+
+class SBFile
+{
+public:
+    SBFile();
+    SBFile(int fd, const char *mode, bool transfer_ownership);
+
+    ~SBFile ();
+
+    %feature("autodoc", "Read(buffer) -> SBError, bytes_read") Read;
+    SBError Read(uint8_t *buf, size_t num_bytes, size_t *OUTPUT);
+
+    %feature("autodoc", "Write(buffer) -> SBError, written_read") Write;
+    SBError Write(const uint8_t *buf, size_t num_bytes, size_t *OUTPUT);
+
+    void Flush();
+
+    bool IsValid() const;
+
+    operator bool() const;
+
+    SBError Close();
+};
+
+} // namespace lldb

lldb/trunk/scripts/lldb.swig

 #include "lldb/API/SBData.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBDeclaration.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBExecutionContext.h"
 #include "lldb/API/SBExpressionOptions.h"
 #include "lldb/API/SBFileSpec.h"
+#include "lldb/API/SBFile.h"
 #include "lldb/API/SBFileSpecList.h"
 #include "lldb/API/SBFrame.h"
 #include "lldb/API/SBFunction.h"
 #include "lldb/API/SBHostOS.h"
 #include "lldb/API/SBInstruction.h"
 #include "lldb/API/SBInstructionList.h"
 #include "lldb/API/SBLanguageRuntime.h"
 #include "lldb/API/SBLaunchInfo.h"

 %include "./interface/SBData.i"
 %include "./interface/SBDebugger.i"
 %include "./interface/SBDeclaration.i"
 %include "./interface/SBError.i"
 %include "./interface/SBEvent.i"
 %include "./interface/SBExecutionContext.i"
 %include "./interface/SBExpressionOptions.i"
 %include "./interface/SBFileSpec.i"
+%include "./interface/SBFile.i"
 %include "./interface/SBFileSpecList.i"
 %include "./interface/SBFrame.i"
 %include "./interface/SBFunction.i"
 %include "./interface/SBHostOS.i"
 %include "./interface/SBInstruction.i"
 %include "./interface/SBInstructionList.i"
 %include "./interface/SBLanguageRuntime.i"
 %include "./interface/SBLaunchInfo.i"

lldb/trunk/source/API/CMakeLists.txt

add_lldb_library(liblldb SHARED
   SBData.cpp
   SBDebugger.cpp
   SBDeclaration.cpp
   SBError.cpp
   SBEvent.cpp
   SBExecutionContext.cpp
   SBExpressionOptions.cpp
   SBFileSpec.cpp
+  SBFile.cpp
   SBFileSpecList.cpp
   SBFrame.cpp
   SBFunction.cpp
   SBHostOS.cpp
   SBInstruction.cpp
   SBInstructionList.cpp
   SBLanguageRuntime.cpp
   SBLaunchInfo.cpp

lldb/trunk/source/API/SBFile.cpp

+//===-- SBFile.cpp ------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/API/SBFile.h"
+#include "SBReproducerPrivate.h"
+#include "lldb/API/SBError.h"
+#include "lldb/Host/File.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+SBFile::~SBFile() {}
+
+SBFile::SBFile() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFile); }
+
+SBFile::SBFile(FILE *file, bool transfer_ownership) {
+  m_opaque_sp = std::make_shared<File>(file, transfer_ownership);
+}
+
+SBFile::SBFile(int fd, const char *mode, bool transfer_owndership) {
+  LLDB_RECORD_CONSTRUCTOR(SBFile, (int, const char *, bool), fd, mode,
+                          transfer_owndership);
+  auto options = File::GetOptionsFromMode(mode);
+  m_opaque_sp = std::make_shared<File>(fd, options, transfer_owndership);
+}
+
+SBError SBFile::Read(uint8_t *buf, size_t num_bytes, size_t *bytes_read) {
+  LLDB_RECORD_DUMMY(lldb::SBError, SBFile, Read, (uint8_t *, size_t, size_t *),
+                    buf, num_bytes, bytes_read);
+  SBError error;
+  if (!m_opaque_sp) {
+    error.SetErrorString("invalid SBFile");
+    *bytes_read = 0;
+  } else {
+    Status status = m_opaque_sp->Read(buf, num_bytes);
+    error.SetError(status);
+    *bytes_read = num_bytes;
+  }
+  return LLDB_RECORD_RESULT(error);
+}
+
+SBError SBFile::Write(const uint8_t *buf, size_t num_bytes,
+                      size_t *bytes_written) {
+  LLDB_RECORD_DUMMY(lldb::SBError, SBFile, Write,
+                    (const uint8_t *, size_t, size_t *), buf, num_bytes,
+                    bytes_written);
+  SBError error;
+  if (!m_opaque_sp) {
+    error.SetErrorString("invalid SBFile");
+    *bytes_written = 0;
+  } else {
+    Status status = m_opaque_sp->Write(buf, num_bytes);
+    error.SetError(status);
+    *bytes_written = num_bytes;
+  }
+  return LLDB_RECORD_RESULT(error);
+}
+
+SBError SBFile::Flush() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBFile, Flush);
+  SBError error;
+  if (!m_opaque_sp) {
+    error.SetErrorString("invalid SBFile");
+  } else {
+    Status status = m_opaque_sp->Flush();
+    error.SetError(status);
+  }
+  return LLDB_RECORD_RESULT(error);
+}
+
+bool SBFile::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFile, IsValid);
+  return m_opaque_sp && m_opaque_sp->IsValid();
+}
+
+SBError SBFile::Close() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBFile, Close);
+  SBError error;
+  if (m_opaque_sp) {
+    Status status = m_opaque_sp->Close();
+    error.SetError(status);
+  }
+  return LLDB_RECORD_RESULT(error);
+}
+
+SBFile::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFile, operator bool);
+  return LLDB_RECORD_RESULT(IsValid());
+}
+
+bool SBFile::operator!() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFile, operator!);
+  return LLDB_RECORD_RESULT(!IsValid());
+}
+
+namespace lldb_private {
+namespace repro {
+template <> void RegisterMethods<SBFile>(Registry &R) {
+  LLDB_REGISTER_CONSTRUCTOR(SBFile, ());
+  LLDB_REGISTER_CONSTRUCTOR(SBFile, (int, const char *, bool));
+  LLDB_REGISTER_METHOD(lldb::SBError, SBFile, Flush, ());
+  LLDB_REGISTER_METHOD_CONST(bool, SBFile, IsValid, ());
+  LLDB_REGISTER_METHOD_CONST(bool, SBFile, operator bool,());
+  LLDB_REGISTER_METHOD_CONST(bool, SBFile, operator!,());
+  LLDB_REGISTER_METHOD(lldb::SBError, SBFile, Close, ());
+}
+} // namespace repro
+} // namespace lldb_private

lldb/trunk/source/API/SBReproducer.cpp

SBRegistry::SBRegistry() {
   RegisterMethods<SBData>(R);
   RegisterMethods<SBInputReader>(R);
   RegisterMethods<SBDebugger>(R);
   RegisterMethods<SBDeclaration>(R);
   RegisterMethods<SBError>(R);
   RegisterMethods<SBEvent>(R);
   RegisterMethods<SBExecutionContext>(R);
   RegisterMethods<SBExpressionOptions>(R);
+  RegisterMethods<SBFile>(R);
   RegisterMethods<SBFileSpec>(R);
   RegisterMethods<SBFileSpecList>(R);
   RegisterMethods<SBFrame>(R);
   RegisterMethods<SBFunction>(R);
   RegisterMethods<SBHostOS>(R);
   RegisterMethods<SBInstruction>(R);
   RegisterMethods<SBInstructionList>(R);
   RegisterMethods<SBLanguageRuntime>(R);

lldb/trunk/source/Host/common/File.cpp

static const char *GetStreamOpenModeFromOptions(uint32_t options) {
   } else if (options & File::eOpenOptionRead) {
     return "r";
   } else if (options & File::eOpenOptionWrite) {
     return "w";
   }
   return nullptr;
 }
 
+uint32_t File::GetOptionsFromMode(llvm::StringRef mode) {
+  return llvm::StringSwitch<uint32_t>(mode)
+      .Case("r", File::eOpenOptionRead)
+      .Case("w", File::eOpenOptionWrite)
+      .Case("a", File::eOpenOptionWrite | File::eOpenOptionAppend |
+                     File::eOpenOptionCanCreate)
+      .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);
+}
+
 int File::kInvalidDescriptor = -1;
 FILE *File::kInvalidStream = nullptr;
 
 File::~File() { Close(); }
 
 int File::GetDescriptor() const {
   if (DescriptorIsValid())
     return m_descriptor;
uint32_t File::GetPermissions(Status &error) const {
   } else {
     error.SetErrorString("invalid file descriptor");
   }
   return 0;
 }
 
 Status File::Close() {
   Status error;
-  if (StreamIsValid() && m_own_stream) {
+  if (StreamIsValid()) {
+    if (m_own_stream) {
       if (::fclose(m_stream) == EOF)
         error.SetErrorToErrno();
+    } else {
+      if (::fflush(m_stream) == EOF)
+        error.SetErrorToErrno();
+    }
   }
 
   if (DescriptorIsValid() && m_own_descriptor) {
     if (::close(m_descriptor) != 0)
       error.SetErrorToErrno();
   }
   m_descriptor = kInvalidDescriptor;
   m_stream = kInvalidStream;

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

public:
 
   static bool Check(PyObject *py_obj);
 
   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);
-
   lldb::FileUP GetUnderlyingFile() const;
 };
 
 } // namespace lldb_private
 
 #endif
 
 #endif // LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_PYTHONDATAOBJECTS_H

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

operator()(std::initializer_list<PythonObject> args) {
   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(PyRefType type, PyObject *o) { Reset(type, o); }
 
 PythonFile::~PythonFile() {}
 
 bool PythonFile::Check(PyObject *py_obj) {
 #if PY_MAJOR_VERSION < 3
   return PyFile_Check(py_obj);
 #else

 #else
   // Read through the Python source, doesn't seem to modify these strings
   Reset(PyRefType::Owned,
         PyFile_FromFile(file.GetStream(), const_cast<char *>(""), cmode,
                         nullptr));
 #endif
 }
 
-uint32_t PythonFile::GetOptionsFromMode(llvm::StringRef mode) {
-  if (mode.empty())
-    return 0;
-
-  return llvm::StringSwitch<uint32_t>(mode.str())
-      .Case("r", File::eOpenOptionRead)
-      .Case("w", File::eOpenOptionWrite)
-      .Case("a", File::eOpenOptionWrite | File::eOpenOptionAppend |
-                     File::eOpenOptionCanCreate)
-      .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);
-}
 
 FileUP PythonFile::GetUnderlyingFile() const {
   if (!IsValid())
     return nullptr;
 
   // 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());
+  auto options = File::GetOptionsFromMode(py_mode.GetString());
   auto file = std::make_unique<File>(PyObject_AsFileDescriptor(m_py_obj),
                                      options, false);
   if (!file->IsValid())
     return nullptr;
   return file;
 }
 
 #endif