[lldb/Reproducers] Instrument SBFile

[JDevlieghere]

Summary

Currently SBFile isn't really instrumented, which was causing trouble when capturing and replaying the Python test suite. The class is particularly tricky because one of its constructors takes a FileSP which isn't instrumented. Until we have proper shadowing in place, we'll simply always record a nullptr.

lldb/include/lldb/API/SBFile.h

class LLDB_API SBFile {
   friend class SBInstructionList;
   friend class SBDebugger;
   friend class SBCommandReturnObject;
   friend class SBProcess;
 
 public:
   SBFile();
   SBFile(FileSP file_sp);
+  SBFile(const SBFile &rhs);
   SBFile(FILE *file, bool transfer_ownership);
   SBFile(int fd, const char *mode, bool transfer_ownership);
   ~SBFile();
 
+  SBFile &operator=(const SBFile &rhs);
+
   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;

lldb/source/API/SBFile.cpp

 #include "lldb/Host/File.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBFile::~SBFile() {}
 
 SBFile::SBFile(FileSP file_sp) : m_opaque_sp(file_sp) {
-  LLDB_RECORD_DUMMY(void, SBfile, SBFile, (FileSP), file_sp);
+  // We have no way to capture the incoming FileSP as the class isn't
+  // instrumented, so pretend that it's always null.
+  LLDB_RECORD_CONSTRUCTOR(SBFile, (lldb::FileSP), nullptr);
+}
+
+SBFile::SBFile(const SBFile &rhs) : m_opaque_sp(rhs.m_opaque_sp) {
+  LLDB_RECORD_CONSTRUCTOR(SBFile, (const lldb::SBFile&), rhs);
+}
+
+SBFile &SBFile ::operator=(const SBFile &rhs) {
+  LLDB_RECORD_METHOD(lldb::SBFile &,
+                     SBFile, operator=,(const lldb::SBFile &), rhs);
+
+  if (this != &rhs)
+    m_opaque_sp = rhs.m_opaque_sp;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 SBFile::SBFile() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFile); }
 
 SBFile::SBFile(FILE *file, bool transfer_ownership) {
-  LLDB_RECORD_DUMMY(void, SBFile, (FILE *, bool), file, transfer_ownership);
+  LLDB_RECORD_CONSTRUCTOR(SBFile, (FILE *, bool), file, transfer_ownership);
+
   m_opaque_sp = std::make_shared<NativeFile>(file, transfer_ownership);
 }
 
 SBFile::SBFile(int fd, const char *mode, bool transfer_owndership) {
-  LLDB_RECORD_DUMMY(void, SBFile, (int, const char *, bool), fd, mode,
+  LLDB_RECORD_CONSTRUCTOR(SBFile, (int, const char *, bool), fd, mode,
                           transfer_owndership);
+
   auto options = File::GetOptionsFromMode(mode);
   if (!options) {
     llvm::consumeError(options.takeError());
     return;
   }
   m_opaque_sp =
       std::make_shared<NativeFile>(fd, options.get(), 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 *),
+  LLDB_RECORD_METHOD(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,
+  LLDB_RECORD_METHOD(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);

 }
 
 namespace lldb_private {
 namespace repro {
 
 template <> void RegisterMethods<SBFile>(Registry &R) {
   LLDB_REGISTER_CONSTRUCTOR(SBFile, ());
   LLDB_REGISTER_CONSTRUCTOR(SBFile, (FileSP));
+  LLDB_REGISTER_CONSTRUCTOR(SBFile, (const SBFile&));
   LLDB_REGISTER_CONSTRUCTOR(SBFile, (FILE *, bool));
   LLDB_REGISTER_CONSTRUCTOR(SBFile, (int, const char *, bool));
+  LLDB_REGISTER_METHOD(SBFile&, SBFile, operator=,(const SBFile&));
   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_CONST(FileSP, SBFile, GetFile, ());
   LLDB_REGISTER_METHOD(lldb::SBError, SBFile, Close, ());
 }
 } // namespace repro
 } // namespace lldb_private