[lldb] Refactor DataBuffer so we can map files as read-only

Currently, all data buffers are assumed to be writable. This is a
problem on macOS where it's not allowed to load unsigned binaries in
memory as writable. To be more precise, MAP_RESILIENT_CODESIGN and
MAP_RESILIENT_MEDIA need to be set for mapped (unsigned) binaries on our
platform.

Binaries are mapped through FileSystem::CreateDataBuffer which returns a
DataBufferLLVM. The latter is backed by a llvm::WritableMemoryBuffer
because every DataBuffer in LLDB is considered to be writable. In order
to use a read-only llvm::MemoryBuffer I had to split our abstraction
around it.

This patch distinguishes between a DataBuffer (read-only) and
WritableDataBuffer (read-write) and updates LLDB to use the appropriate
one.

rdar://74890607

Differential revision: https://reviews.llvm.org/D122856

Author: JDevlieghere

lldb/include/lldb/Core/ValueObject.h

@@ -679,7 +679,7 @@ class ValueObject {
   bool IsCStringContainer(bool check_pointer = false);
 
   std::pair<size_t, bool>
-  ReadPointedString(lldb::DataBufferSP &buffer_sp, Status &error,
+  ReadPointedString(lldb::WritableDataBufferSP &buffer_sp, Status &error,
                     uint32_t max_length = 0, bool honor_array = true,
                     lldb::Format item_format = lldb::eFormatCharArray);
 

lldb/include/lldb/Host/FileSystem.h

@@ -148,6 +148,12 @@ class FileSystem {
   std::shared_ptr<DataBuffer> CreateDataBuffer(const FileSpec &file_spec,
                                                uint64_t size = 0,
                                                uint64_t offset = 0);
+  std::shared_ptr<WritableDataBuffer>
+  CreateWritableDataBuffer(const llvm::Twine &path, uint64_t size = 0,
+                           uint64_t offset = 0);
+  std::shared_ptr<WritableDataBuffer>
+  CreateWritableDataBuffer(const FileSpec &file_spec, uint64_t size = 0,
+                           uint64_t offset = 0);
   /// \}
 
   /// Call into the Host to see if it can help find the file.

lldb/include/lldb/Symbol/CompactUnwindInfo.h

@@ -138,9 +138,10 @@ class CompactUnwindInfo {
 
   ObjectFile &m_objfile;
   lldb::SectionSP m_section_sp;
-  lldb::DataBufferSP m_section_contents_if_encrypted; // if the binary is
-                                                      // encrypted, read the
-                                                      // sect contents
+  lldb::WritableDataBufferSP
+      m_section_contents_if_encrypted; // if the binary is
+                                       // encrypted, read the
+                                       // sect contents
   // out of live memory and cache them here
   std::mutex m_mutex;
   std::vector<UnwindIndex> m_indexes;

lldb/include/lldb/Symbol/ObjectFile.h

@@ -759,6 +759,9 @@ class ObjectFile : public std::enable_shared_from_this<ObjectFile>,
   ///     false otherwise.
   bool SetModulesArchitecture(const ArchSpec &new_arch);
 
+  /// The number of bytes to read when going through the plugins.
+  static size_t g_initial_bytes_to_read;
+
   static lldb::DataBufferSP MapFileData(const FileSpec &file, uint64_t Size,
                                         uint64_t Offset);
 

lldb/include/lldb/Target/ProcessStructReader.h

@@ -69,7 +69,7 @@ class ProcessStructReader {
     auto total_size = struct_type.GetByteSize(nullptr);
     if (!total_size)
       return;
-    lldb::DataBufferSP buffer_sp(new DataBufferHeap(*total_size, 0));
+    lldb::WritableDataBufferSP buffer_sp(new DataBufferHeap(*total_size, 0));
     Status error;
     process->ReadMemoryFromInferior(base_addr, buffer_sp->GetBytes(),
                                     *total_size, error);

lldb/include/lldb/Target/RegisterCheckpoint.h

@@ -35,12 +35,12 @@ class RegisterCheckpoint : public UserID {
 
   ~RegisterCheckpoint() = default;
 
-  lldb::DataBufferSP &GetData() { return m_data_sp; }
+  lldb::WritableDataBufferSP &GetData() { return m_data_sp; }
 
-  const lldb::DataBufferSP &GetData() const { return m_data_sp; }
+  const lldb::WritableDataBufferSP &GetData() const { return m_data_sp; }
 
 protected:
-  lldb::DataBufferSP m_data_sp;
+  lldb::WritableDataBufferSP m_data_sp;
   Reason m_reason;
 
   // Make RegisterCheckpointSP if you wish to share the data in this class.

lldb/include/lldb/Target/RegisterContext.h

@@ -43,7 +43,7 @@ class RegisterContext : public std::enable_shared_from_this<RegisterContext>,
   virtual bool WriteRegister(const RegisterInfo *reg_info,
                              const RegisterValue &reg_value) = 0;
 
-  virtual bool ReadAllRegisterValues(lldb::DataBufferSP &data_sp) {
+  virtual bool ReadAllRegisterValues(lldb::WritableDataBufferSP &data_sp) {
     return false;
   }
 

lldb/include/lldb/Target/RegisterContextUnwind.h

@@ -50,7 +50,7 @@ class RegisterContextUnwind : public lldb_private::RegisterContext {
   bool WriteRegister(const lldb_private::RegisterInfo *reg_info,
                      const lldb_private::RegisterValue &value) override;
 
-  bool ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
+  bool ReadAllRegisterValues(lldb::WritableDataBufferSP &data_sp) override;
 
   bool WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
 

lldb/include/lldb/Utility/DataBuffer.h

@@ -20,12 +20,12 @@
 namespace lldb_private {
 
 /// \class DataBuffer DataBuffer.h "lldb/Core/DataBuffer.h"
-/// A pure virtual protocol class for abstracted data buffers.
+/// A pure virtual protocol class for abstracted read only data buffers.
 ///
-/// DataBuffer is an abstract class that gets packaged into a shared pointer
-/// that can use to implement various ways to store data (on the heap, memory
-/// mapped, cached inferior memory). It gets used by DataExtractor so many
-/// DataExtractor objects can share the same data and sub-ranges of that
+/// DataBuffer is an abstract class that gets packaged into a shared
+/// pointer that can use to implement various ways to store data (on the heap,
+/// memory mapped, cached inferior memory). It gets used by DataExtractor so
+/// many DataExtractor objects can share the same data and sub-ranges of that
 /// shared data, and the last object that contains a reference to the shared
 /// data will free it.
 ///
@@ -42,52 +42,106 @@ namespace lldb_private {
 /// with some extra function calls to load the data before it gets accessed.
 class DataBuffer {
 public:
-  /// Destructor
-  ///
-  /// The destructor is virtual as other classes will inherit from this class
-  /// and be downcast to the DataBuffer pure virtual interface. The virtual
-  /// destructor ensures that destructing the base class will destruct the
-  /// class that inherited from it correctly.
   virtual ~DataBuffer() = default;
 
-  /// Get a pointer to the data.
+  /// Get the number of bytes in the data buffer.
   ///
   /// \return
-  ///     A pointer to the bytes owned by this object, or NULL if the
-  ///     object contains no bytes.
-  virtual uint8_t *GetBytes() = 0;
+  ///     The number of bytes this object currently contains.
+  virtual lldb::offset_t GetByteSize() const = 0;
 
   /// Get a const pointer to the data.
   ///
   /// \return
   ///     A const pointer to the bytes owned by this object, or NULL
   ///     if the object contains no bytes.
-  virtual const uint8_t *GetBytes() const = 0;
-
-  /// Get the number of bytes in the data buffer.
-  ///
-  /// \return
-  ///     The number of bytes this object currently contains.
-  virtual lldb::offset_t GetByteSize() const = 0;
+  const uint8_t *GetBytes() const { return GetBytesImpl(); }
 
   llvm::ArrayRef<uint8_t> GetData() const {
     return llvm::ArrayRef<uint8_t>(GetBytes(), GetByteSize());
   }
 
+  /// LLVM RTTI support.
+  /// {
+  static char ID;
+  virtual bool isA(const void *ClassID) const { return ClassID == &ID; }
+  static bool classof(const DataBuffer *data_buffer) {
+    return data_buffer->isA(&ID);
+  }
+  /// }
+
+protected:
+  /// Get a const pointer to the data.
+  ///
+  /// \return
+  ///     A const pointer to the bytes owned by this object, or NULL
+  ///     if the object contains no bytes.
+  virtual const uint8_t *GetBytesImpl() const = 0;
+};
+
+/// \class DataBuffer DataBuffer.h "lldb/Core/DataBuffer.h"
+/// A pure virtual protocol class for abstracted writable data buffers.
+///
+/// DataBuffer is an abstract class that gets packaged into a shared pointer
+/// that can use to implement various ways to store data (on the heap, memory
+/// mapped, cached inferior memory). It gets used by DataExtractor so many
+/// DataExtractor objects can share the same data and sub-ranges of that
+/// shared data, and the last object that contains a reference to the shared
+/// data will free it.
+class WritableDataBuffer : public DataBuffer {
+public:
+  /// Destructor
+  ///
+  /// The destructor is virtual as other classes will inherit from this class
+  /// and be downcast to the DataBuffer pure virtual interface. The virtual
+  /// destructor ensures that destructing the base class will destruct the
+  /// class that inherited from it correctly.
+  virtual ~WritableDataBuffer() = default;
+
+  using DataBuffer::GetBytes;
+  using DataBuffer::GetData;
+
+  /// Get a pointer to the data.
+  ///
+  /// \return
+  ///     A pointer to the bytes owned by this object, or NULL if the
+  ///     object contains no bytes.
+  uint8_t *GetBytes() { return const_cast<uint8_t *>(GetBytesImpl()); }
+
   llvm::MutableArrayRef<uint8_t> GetData() {
     return llvm::MutableArrayRef<uint8_t>(GetBytes(), GetByteSize());
   }
+
+  /// LLVM RTTI support.
+  /// {
+  static char ID;
+  bool isA(const void *ClassID) const override {
+    return ClassID == &ID || DataBuffer::isA(ClassID);
+  }
+  static bool classof(const DataBuffer *data_buffer) {
+    return data_buffer->isA(&ID);
+  }
+  /// }
 };
 
-class DataBufferUnowned : public DataBuffer {
+class DataBufferUnowned : public WritableDataBuffer {
 public:
   DataBufferUnowned(uint8_t *bytes, lldb::offset_t size)
       : m_bytes(bytes), m_size(size) {}
 
-  uint8_t *GetBytes() override { return m_bytes; }
-  const uint8_t *GetBytes() const override { return m_bytes; }
+  const uint8_t *GetBytesImpl() const override { return m_bytes; }
   lldb::offset_t GetByteSize() const override { return m_size; }
 
+  /// LLVM RTTI support.
+  /// {
+  static char ID;
+  bool isA(const void *ClassID) const override {
+    return ClassID == &ID || WritableDataBuffer::isA(ClassID);
+  }
+  static bool classof(const DataBuffer *data_buffer) {
+    return data_buffer->isA(&ID);
+  }
+  /// }
 private:
   uint8_t *m_bytes;
   lldb::offset_t m_size;

lldb/include/lldb/Utility/DataBufferHeap.h

@@ -27,7 +27,7 @@ namespace lldb_private {
 /// pages in. Large amounts of data that comes from files should probably use
 /// DataBufferLLVM, which can intelligently determine when memory mapping is
 /// optimal.
-class DataBufferHeap : public DataBuffer {
+class DataBufferHeap : public WritableDataBuffer {
 public:
   /// Default constructor
   ///
@@ -54,17 +54,20 @@ class DataBufferHeap : public DataBuffer {
   ///     The number of bytes in \a src to copy.
   DataBufferHeap(const void *src, lldb::offset_t src_len);
 
+  /// Construct by making a copy of a DataBuffer.
+  ///
+  /// \param[in] data_buffer
+  ///     A read only data buffer to copy.
+  DataBufferHeap(const DataBuffer &data_buffer);
+
   /// Destructor.
   ///
   /// Virtual destructor since this class inherits from a pure virtual base
   /// class #DataBuffer.
   ~DataBufferHeap() override;
 
-  /// \copydoc DataBuffer::GetBytes()
-  uint8_t *GetBytes() override;
-
   /// \copydoc DataBuffer::GetBytes() const
-  const uint8_t *GetBytes() const override;
+  const uint8_t *GetBytesImpl() const override;
 
   /// \copydoc DataBuffer::GetByteSize() const
   lldb::offset_t GetByteSize() const override;
@@ -100,6 +103,17 @@ class DataBufferHeap : public DataBuffer {
 
   void Clear();
 
+  /// LLVM RTTI support.
+  /// {
+  static char ID;
+  bool isA(const void *ClassID) const override {
+    return ClassID == &ID || WritableDataBuffer::isA(ClassID);
+  }
+  static bool classof(const DataBuffer *data_buffer) {
+    return data_buffer->isA(&ID);
+  }
+  /// }
+
 private:
   // This object uses a std::vector<uint8_t> to store its data. This takes care
   // of free the data when the object is deleted.

lldb/include/lldb/Utility/DataBufferLLVM.h

@@ -17,26 +17,63 @@
 
 namespace llvm {
 class WritableMemoryBuffer;
+class MemoryBuffer;
 class Twine;
 } // namespace llvm
 
 namespace lldb_private {
-
 class FileSystem;
+
 class DataBufferLLVM : public DataBuffer {
 public:
   ~DataBufferLLVM() override;
 
-  uint8_t *GetBytes() override;
-  const uint8_t *GetBytes() const override;
+  const uint8_t *GetBytesImpl() const override;
   lldb::offset_t GetByteSize() const override;
 
-private:
-  friend FileSystem;
+  /// LLVM RTTI support.
+  /// {
+  static char ID;
+  bool isA(const void *ClassID) const override {
+    return ClassID == &ID || DataBuffer::isA(ClassID);
+  }
+  static bool classof(const DataBuffer *data_buffer) {
+    return data_buffer->isA(&ID);
+  }
+  /// }
+
+  /// Construct a DataBufferLLVM from \p Buffer.  \p Buffer must be a valid
+  /// pointer.
+  explicit DataBufferLLVM(std::unique_ptr<llvm::MemoryBuffer> Buffer);
+
+protected:
+  std::unique_ptr<llvm::MemoryBuffer> Buffer;
+};
+
+class WritableDataBufferLLVM : public WritableDataBuffer {
+public:
+  ~WritableDataBufferLLVM() override;
+
+  const uint8_t *GetBytesImpl() const override;
+  lldb::offset_t GetByteSize() const override;
+
+  /// LLVM RTTI support.
+  /// {
+  static char ID;
+  bool isA(const void *ClassID) const override {
+    return ClassID == &ID || WritableDataBuffer::isA(ClassID);
+  }
+  static bool classof(const DataBuffer *data_buffer) {
+    return data_buffer->isA(&ID);
+  }
+  /// }
+
   /// Construct a DataBufferLLVM from \p Buffer.  \p Buffer must be a valid
   /// pointer.
-  explicit DataBufferLLVM(std::unique_ptr<llvm::WritableMemoryBuffer> Buffer);
+  explicit WritableDataBufferLLVM(
+      std::unique_ptr<llvm::WritableMemoryBuffer> Buffer);
 
+protected:
   std::unique_ptr<llvm::WritableMemoryBuffer> Buffer;
 };
 } // namespace lldb_private

lldb/include/lldb/lldb-forward.h

@@ -67,6 +67,7 @@ class DWARFCallFrameInfo;
 class DWARFDataExtractor;
 class DWARFExpression;
 class DataBuffer;
+class WritableDataBuffer;
 class DataBufferHeap;
 class DataEncoder;
 class DataExtractor;
@@ -309,6 +310,7 @@ typedef std::shared_ptr<lldb_private::CommandObject> CommandObjectSP;
 typedef std::shared_ptr<lldb_private::Connection> ConnectionSP;
 typedef std::shared_ptr<lldb_private::CompileUnit> CompUnitSP;
 typedef std::shared_ptr<lldb_private::DataBuffer> DataBufferSP;
+typedef std::shared_ptr<lldb_private::WritableDataBuffer> WritableDataBufferSP;
 typedef std::shared_ptr<lldb_private::DataExtractor> DataExtractorSP;
 typedef std::shared_ptr<lldb_private::Debugger> DebuggerSP;
 typedef std::weak_ptr<lldb_private::Debugger> DebuggerWP;

lldb/source/Commands/CommandObjectMemory.cpp

@@ -639,7 +639,7 @@ class CommandObjectMemoryRead : public CommandObjectParsed {
       return false;
     }
 
-    DataBufferSP data_sp;
+    WritableDataBufferSP data_sp;
     size_t bytes_read = 0;
     if (compiler_type.GetOpaqueQualType()) {
       // Make sure we don't display our type as ASCII bytes like the default

lldb/source/Core/SourceManager.cpp

@@ -644,7 +644,7 @@ bool SourceManager::File::CalculateLineOffsets(uint32_t line) {
       if (m_data_sp.get() == nullptr)
         return false;
 
-      const char *start = (char *)m_data_sp->GetBytes();
+      const char *start = (const char *)m_data_sp->GetBytes();
       if (start) {
         const char *end = start + m_data_sp->GetByteSize();
 
@@ -694,7 +694,7 @@ bool SourceManager::File::GetLine(uint32_t line_no, std::string &buffer) {
   if (end_offset == UINT32_MAX) {
     end_offset = m_data_sp->GetByteSize();
   }
-  buffer.assign((char *)m_data_sp->GetBytes() + start_offset,
+  buffer.assign((const char *)m_data_sp->GetBytes() + start_offset,
                 end_offset - start_offset);
 
   return true;