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

[JDevlieghere]

Summary

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 loaded through FileSystem::CreateDataBuffer which returns a DataBufferLLVM. The latter is backed by a llvm::WritableMemoryBuffer because every DataBuffer is considered to be writable. In order to use a read-only llvm::MemoryBuffer I had to split DataBuffer into DataBuffer (read-only) and WritableDataBuffer (read-write).

rdar://74890607

[labath]

Yeah, I tried doing this (well, i used const DataBuffer to represent read-only data) last time this topic came up, and ran into the same problem. Since there was no pressing need for it, I put the patch away.

I think the best way to fix this is to allow the object file classes to control the way the object file is mapped into memory (during creation). Then the ObjectFileELF could map the the file read-write, and the rest would do it read-only (though I think it's possible we need to relocate COFF files as well, only no one ran into the issue yet). If we wanted to be very fancy, we could check whether the object file needs relocations (basically, does it have any .rel(a).debug_*** sections) and *then* map the file read-write, but I don't think that's really necessary.

That doesn't directly help with the code in ObjectFileELF::ApplyRelocations, since it would still get an object whose static type prohibits writes. However, if we can ensure that the dynamic type of the object is alright, then we can put an appropriate cast there, and put a comment pointing to the place where the object is created.

In llvm the relocations are being applied on-the-fly as the data is being read. That would be another possibility, but it would be a much more intrusive change (and tbh, I can't say I like the llvm model that much). OTOH, it would go a long way towards unifying llvm and lldb object&dwarf readers....

[JDevlieghere]

• Implement Pavel's suggestion of mapping ELF files as writable and casting to a WritableMemoryBuffer.

[shafik]

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

236

nitpick reinterpret_cast instead of C-style cast.

[labath]

lldb/include/lldb/Utility/DataBuffer.h

53–58

Replace with using DataBuffer::GetBytes ?

58

Are you sure this should be public?

60–124

ditto

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

363

I guess this should be done unconditionally now.

393

I am assuming this will always point to a writable kind of a data buffer. Could we change the prototype to reflect that?

2635

add // ObjectFileELF creates a WritableDataBuffer in CreateInstance

[JDevlieghere]

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

363

No, I tried doing that actually and it broke a bunch of unit tests. I can take a look at it later this week if you think this is important.

393

Are you okay with making that a separate patch?

[JDevlieghere]

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

393

https://reviews.llvm.org/D123073

[labath]

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

363

Right, I think I know what's going on. The unit tests use a (relatively new) object file feature where you can construct an ObjectFile instance without a backing file by providing all of its data upfront.

I think it is important to have a story for all entry points into the ELF code, since that is what makes the cast in ApplyRelocations sound. There are several ways to handle this. In my order of preference, they would be:

• In the file backed case, the initial 512-byte buffer will be heap-based (hence, effectively writable). If it is acceptable (and statically type-safe) to make the the buffer for the buffer-backed case writable, then we could change the CreateInstance prototype to take a WritableDataBuffer. Only the full mappings done by individual subclasses would be read-only. The only (non-test) use case for this feature is for some mach-o shenanigans so you'd be best qualified to determine if this would work.
• If we can be sure that the buffer-backed buffer is always writable, but we cannot enforce that in the type system, then we could add a comment documenting that the buffers dynamic type must be writable in one does not provide a backing file.
• Failing all that, we could have ObjectFileELF make a heap copy of the incoming data buffer in the buffer-backed case. Since there's no production use case for buffer-backed ELF files I think that should be fine. We could also have the ELF class refuse to open such files, but that would mean changing the unit tests back to using temporary files, which would make me sad.

[JDevlieghere]

I don't really like the idea of making the argument to createInstance writable. That seems like an implementation detail. Instead I added a virtual method IsWritable() to the DataBuffer and an assert to ObjectFileELF that ensures we always have a writable buffer.

@labath: does that cover your concerns?

[JDevlieghere]

• Copy the buffer if ObjectFileELF didn't map it
• Use LLVM style RTTI

[labath]

Looks good. Thanks for your patience.

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

2636–2638

use llvm::cast instead.

lldb/include/lldb/Core/ValueObject.h

public:
 
   lldb::ValueObjectSP Persist();
 
   /// Returns true if this is a char* or a char[] if it is a char* and
   /// check_pointer is true, it also checks that the pointer is valid.
   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);
 
   virtual size_t GetPointeeData(DataExtractor &data, uint32_t item_idx = 0,
                                 uint32_t item_count = 1);
 
   virtual uint64_t GetData(DataExtractor &data, Status &error);
 

lldb/include/lldb/Host/FileSystem.h

public:
   //// Create memory buffer from path.
   /// \{
   std::shared_ptr<DataBuffer> CreateDataBuffer(const llvm::Twine &path,
                                                uint64_t size = 0,
                                                uint64_t offset = 0);
   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.
   bool ResolveExecutableLocation(FileSpec &file_spec);
 
   /// Get the user home directory.
   bool GetHomeDirectory(llvm::SmallVectorImpl<char> &path) const;
   bool GetHomeDirectory(FileSpec &file_spec) const;

lldb/include/lldb/Symbol/CompactUnwindInfo.h

bool CreateUnwindPlan_arm64(Target &target, FunctionInfo &function_info,
                               Address pc_or_function_start);
 
   bool CreateUnwindPlan_armv7(Target &target, FunctionInfo &function_info,
                               UnwindPlan &unwind_plan,
                               Address pc_or_function_start);
 
   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
   // out of live memory and cache them here
   std::mutex m_mutex;
   std::vector<UnwindIndex> m_indexes;
 
   LazyBool m_indexes_computed; // eLazyBoolYes once we've tried to parse the
                                // unwind info
   // eLazyBoolNo means we cannot parse the unwind info & should not retry
   // eLazyBoolCalculate means we haven't tried to parse it yet

lldb/include/lldb/Symbol/ObjectFile.h

protected:
   /// \param[in] new_arch
   ///     The architecture this module will be set to.
   ///
   /// \return
   ///     Returns \b true if the architecture was changed, \b
   ///     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);
 
 private:
   ObjectFile(const ObjectFile &) = delete;
   const ObjectFile &operator=(const ObjectFile &) = delete;
 };
 

lldb/include/lldb/Target/ProcessStructReader.h

for (size_t idx = 0; idx < struct_type.GetNumFields(); idx++) {
       ConstString const_name = ConstString(name.c_str());
       size_t byte_index = static_cast<size_t>(bit_offset / 8);
       m_fields[const_name] =
           FieldImpl{field_type, byte_index, static_cast<size_t>(*size)};
     }
     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);
     if (error.Fail())
       return;
     m_data = DataExtractor(buffer_sp, m_byte_order, m_addr_byte_size);
   }
 

lldb/include/lldb/Target/RegisterCheckpoint.h

enum class Reason {
     // read into m_data_sp, or the save/restore checkpoint should fail.
     eDataBackup
   };
 
   RegisterCheckpoint(Reason reason) : UserID(0), m_reason(reason) {}
 
   ~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.
   RegisterCheckpoint(const RegisterCheckpoint &) = delete;
   const RegisterCheckpoint &operator=(const RegisterCheckpoint &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_REGISTERCHECKPOINT_H

lldb/include/lldb/Target/RegisterContext.h

public:
   virtual lldb::ByteOrder GetByteOrder();
 
   virtual bool ReadRegister(const RegisterInfo *reg_info,
                             RegisterValue &reg_value) = 0;
 
   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;
   }
 
   virtual bool WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) {
     return false;
   }
 
   // These two functions are used to implement "push" and "pop" of register

lldb/include/lldb/Target/RegisterContextUnwind.h

public:
   const lldb_private::RegisterSet *GetRegisterSet(size_t reg_set) override;
 
   bool ReadRegister(const lldb_private::RegisterInfo *reg_info,
                     lldb_private::RegisterValue &value) override;
 
   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;
 
   uint32_t ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind,
                                                uint32_t num) override;
 
   bool IsValid() const;
 

lldb/include/lldb/Utility/DataBuffer.h

 
 #include "lldb/lldb-types.h"
 
 #include "llvm/ADT/ArrayRef.h"
 
 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.
 ///
 /// Subclasses can implement as many different constructors or member
 /// functions that allow data to be stored in the object's buffer prior to
 /// handing the shared data to clients that use these buffers.
 ///
 /// All subclasses must override all of the pure virtual functions as they are
 /// used by clients to access the data. Having a common interface allows
 /// different ways of storing data, yet using it in one common way.
 ///
 /// This class currently expects all data to be available without any extra
 /// calls being made, but we can modify it to optionally get data on demand
 /// 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;
 };
 
 } // namespace lldb_private
 
 #endif /// #if defined(__cplusplus)
 #endif // LLDB_UTILITY_DATABUFFER_H

lldb/include/lldb/Utility/DataBufferHeap.h

 /// A subclass of DataBuffer that stores a data buffer on the heap.
 ///
 /// This class keeps its data in a heap based buffer that is owned by the
 /// object. This class is best used to store chunks of data that are created
 /// or read from sources that can't intelligently and lazily fault new data
 /// 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
   ///
   /// Initializes the heap based buffer with no bytes.
   DataBufferHeap();
 
   /// Construct with size \a n and fill with \a ch.
   ///
public:
   ///
   /// \param[in] src
   ///     A pointer to the data to copy.
   ///
   /// \param[in] src_len
   ///     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;
 
   /// Set the number of bytes in the data buffer.
   ///
   /// Sets the number of bytes that this object should be able to contain.
   /// This can be used prior to copying data into the buffer. Note that this
public:
   ///     The number of bytes in \a src to copy.
   void CopyData(const void *src, lldb::offset_t src_len);
   void CopyData(llvm::StringRef src) { CopyData(src.data(), src.size()); }
 
   void AppendData(const void *src, uint64_t src_len);
 
   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.
   typedef std::vector<uint8_t> buffer_t; ///< Buffer type
   buffer_t m_data; ///< The heap based buffer where data is stored
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_UTILITY_DATABUFFERHEAP_H

lldb/include/lldb/Utility/DataBufferLLVM.h

 #include "lldb/Utility/DataBuffer.h"
 #include "lldb/lldb-types.h"
 
 #include <cstdint>
 #include <memory>
 
 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
 
 #endif

lldb/include/lldb/lldb-forward.h

 class Connection;
 class ConnectionFileDescriptor;
 class ConstString;
 class ConstStringTable;
 class DWARFCallFrameInfo;
 class DWARFDataExtractor;
 class DWARFExpression;
 class DataBuffer;
+class WritableDataBuffer;
 class DataBufferHeap;
 class DataEncoder;
 class DataExtractor;
 class DataFileCache;
 class Debugger;
 class Declaration;
 class DiagnosticManager;
 class Disassembler;

 typedef std::shared_ptr<lldb_private::Broadcaster> BroadcasterSP;
 typedef std::shared_ptr<lldb_private::BroadcasterManager> BroadcasterManagerSP;
 typedef std::weak_ptr<lldb_private::BroadcasterManager> BroadcasterManagerWP;
 typedef std::shared_ptr<lldb_private::UserExpression> UserExpressionSP;
 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;
 typedef std::shared_ptr<lldb_private::Disassembler> DisassemblerSP;
 typedef std::unique_ptr<lldb_private::DynamicCheckerFunctions>
     DynamicCheckerFunctionsUP;
 typedef std::unique_ptr<lldb_private::DynamicLoader> DynamicLoaderUP;
 typedef std::shared_ptr<lldb_private::Event> EventSP;

lldb/source/Commands/CommandObjectMemory.cpp

if (total_byte_size > max_unforced_size && !m_memory_options.m_force) {
           max_unforced_size);
       result.AppendErrorWithFormat(
           "Please use --force to override this restriction just once.\n");
       result.AppendErrorWithFormat("or set target.max-memory-read-size if you "
                                    "will often need a larger limit.\n");
       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
       // memory read
       if (!m_format_options.GetFormatValue().OptionWasSet())
         m_format_options.GetFormatValue().SetCurrentValue(eFormatDefault);
 
       llvm::Optional<uint64_t> size = compiler_type.GetByteSize(nullptr);

lldb/source/Core/SourceManager.cpp

if (line == UINT32_MAX) {
     // Already done?
     if (!m_offsets.empty() && m_offsets[0] == UINT32_MAX)
       return true;
 
     if (m_offsets.empty()) {
       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();
 
         // Calculate all line offsets from scratch
 
         // Push a 1 at index zero to indicate the file has been completely
         // indexed.
         m_offsets.push_back(UINT32_MAX);
bool SourceManager::File::GetLine(uint32_t line_no, std::string &buffer) {
   if (!LineIsValid(line_no))
     return false;
 
   size_t start_offset = GetLineOffset(line_no);
   size_t end_offset = GetLineOffset(line_no + 1);
   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;
 }
 
 void SourceManager::SourceFileCache::AddSourceFile(const FileSP &file_sp) {
   FileSpec file_spec = file_sp->GetFileSpec();
   FileCache::iterator pos = m_file_cache.find(file_spec);

lldb/source/Core/ValueObject.cpp

bool ValueObject::SetData(DataExtractor &data, Status &error) {
 
   // If we have reached this point, then we have successfully changed the
   // value.
   SetNeedsUpdate();
   return true;
 }
 
 static bool CopyStringDataToBufferSP(const StreamString &source,
-                                     lldb::DataBufferSP &destination) {
+                                     lldb::WritableDataBufferSP &destination) {
   llvm::StringRef src = source.GetString();
   src = src.rtrim('\0');
   destination = std::make_shared<DataBufferHeap>(src.size(), 0);
   memcpy(destination->GetBytes(), src.data(), src.size());
   return true;
 }
 
 std::pair<size_t, bool>
-ValueObject::ReadPointedString(lldb::DataBufferSP &buffer_sp, Status &error,
-                               uint32_t max_length, bool honor_array,
-                               Format item_format) {
+ValueObject::ReadPointedString(lldb::WritableDataBufferSP &buffer_sp,
+                               Status &error, uint32_t max_length,
+                               bool honor_array, Format item_format) {
   bool was_capped = false;
   StreamString s;
   ExecutionContext exe_ctx(GetExecutionContextRef());
   Target *target = exe_ctx.GetTargetPtr();
 
   if (!target) {
     s << "<no target to read from>";
     error.SetErrorString("no target to read from");
if (flags.AnySet(eTypeIsArray | eTypeIsPointer) &&
 
       if (IsCStringContainer(true) &&
           (custom_format == eFormatCString ||
            custom_format == eFormatCharArray || custom_format == eFormatChar ||
            custom_format ==
                eFormatVectorOfChar)) // print char[] & char* directly
       {
         Status error;
-        lldb::DataBufferSP buffer_sp;
+        lldb::WritableDataBufferSP buffer_sp;
         std::pair<size_t, bool> read_string = ReadPointedString(
             buffer_sp, error, 0, (custom_format == eFormatVectorOfChar) ||
                                      (custom_format == eFormatCharArray));
         lldb_private::formatters::StringPrinter::
             ReadBufferAndDumpToStreamOptions options(*this);
         options.SetData(DataExtractor(
             buffer_sp, lldb::eByteOrderInvalid,
             8)); // none of this matters for a string - pass some defaults

lldb/source/DataFormatters/StringPrinter.cpp

if (zero_is_terminator) {
           break;
         }
         data_ptr++;
       }
 
       data_ptr = (const SourceDataType *)data.GetDataStart();
     }
 
-    lldb::DataBufferSP utf8_data_buffer_sp;
+    lldb::WritableDataBufferSP utf8_data_buffer_sp;
     llvm::UTF8 *utf8_data_ptr = nullptr;
     llvm::UTF8 *utf8_data_end_ptr = nullptr;
 
     if (ConvertFunction) {
       utf8_data_buffer_sp =
           std::make_shared<DataBufferHeap>(4 * bufferSPSize, 0);
       utf8_data_ptr = (llvm::UTF8 *)utf8_data_buffer_sp->GetBytes();
       utf8_data_end_ptr = utf8_data_ptr + utf8_data_buffer_sp->GetByteSize();
if (!options.GetIgnoreMaxLength()) {
       }
     }
   } else {
     sourceSize = max_size;
     needs_zero_terminator = true;
   }
 
   const int bufferSPSize = sourceSize * type_width;
-  lldb::DataBufferSP buffer_sp(new DataBufferHeap(bufferSPSize, 0));
+  lldb::WritableDataBufferSP buffer_sp(new DataBufferHeap(bufferSPSize, 0));
 
   // Check if we got bytes. We never get any bytes if we have an empty
   // string, but we still continue so that we end up actually printing
   // an empty string ("").
   if (sourceSize != 0 && !buffer_sp->GetBytes())
     return false;
 
   Status error;

lldb/source/DataFormatters/TypeFormat.cpp

if (context_type == Value::ContextType::RegisterInfo) {
           if (type_flags.Test(eTypeIsPointer) &&
               !type_flags.Test(eTypeIsObjC)) {
             // if we are dumping a pointer as a c-string, get the pointee data
             // as a string
             TargetSP target_sp(valobj->GetTargetSP());
             if (target_sp) {
               size_t max_len = target_sp->GetMaximumSizeOfStringSummary();
               Status error;
-              DataBufferSP buffer_sp(new DataBufferHeap(max_len + 1, 0));
+              WritableDataBufferSP buffer_sp(
+                  new DataBufferHeap(max_len + 1, 0));
               Address address(valobj->GetPointerValue());
               if (target_sp->ReadCStringFromMemory(
                       address, (char *)buffer_sp->GetBytes(), max_len, error) &&
                   error.Success())
                 data.SetData(buffer_sp);
             }
           }
         } else {

lldb/source/Expression/IRExecutionUnit.cpp

Status IRExecutionUnit::DisassembleFunction(Stream &stream,
 
   Target *target = exe_ctx.GetTargetPtr();
   if (!target) {
     ret.SetErrorToGenericError();
     ret.SetErrorString("Couldn't find the target");
     return ret;
   }
 
-  lldb::DataBufferSP buffer_sp(new DataBufferHeap(func_range.second, 0));
+  lldb::WritableDataBufferSP buffer_sp(
+      new DataBufferHeap(func_range.second, 0));
 
   Process *process = exe_ctx.GetProcessPtr();
   Status err;
   process->ReadMemory(func_remote_addr, buffer_sp->GetBytes(),
                       buffer_sp->GetByteSize(), err);
 
   if (!err.Success()) {
     ret.SetErrorToGenericError();

lldb/source/Host/common/FileSystem.cpp

void FileSystem::Resolve(FileSpec &file_spec) {
   // Update the FileSpec with the resolved path.
   if (file_spec.GetFilename().IsEmpty())
     file_spec.GetDirectory().SetString(path);
   else
     file_spec.SetPath(path);
   file_spec.SetIsResolved(true);
 }
 
-std::shared_ptr<DataBuffer>
-FileSystem::CreateDataBuffer(const llvm::Twine &path, uint64_t size,
-                             uint64_t offset) {
-  const bool is_volatile = !IsLocal(path);
-  std::unique_ptr<llvm::WritableMemoryBuffer> buffer;
+template <typename T>
+static std::unique_ptr<T> GetMemoryBuffer(const llvm::Twine &path,
+                                          uint64_t size, uint64_t offset,
+                                          bool is_volatile) {
+  std::unique_ptr<T> buffer;
   if (size == 0) {
-    auto buffer_or_error =
-        llvm::WritableMemoryBuffer::getFile(path, is_volatile);
+    auto buffer_or_error = T::getFile(path, is_volatile);
     if (!buffer_or_error)
       return nullptr;
     buffer = std::move(*buffer_or_error);
   } else {
-    auto buffer_or_error = llvm::WritableMemoryBuffer::getFileSlice(
-        path, size, offset, is_volatile);
+    auto buffer_or_error = T::getFileSlice(path, size, offset, is_volatile);
     if (!buffer_or_error)
       return nullptr;
     buffer = std::move(*buffer_or_error);
   }
+  return buffer;
+}
+
+std::shared_ptr<WritableDataBuffer>
+FileSystem::CreateWritableDataBuffer(const llvm::Twine &path, uint64_t size,
+                                     uint64_t offset) {
+  const bool is_volatile = !IsLocal(path);
+  auto buffer = GetMemoryBuffer<llvm::WritableMemoryBuffer>(path, size, offset,
+                                                            is_volatile);
+  if (!buffer)
+    return {};
+  return std::shared_ptr<WritableDataBufferLLVM>(
+      new WritableDataBufferLLVM(std::move(buffer)));
+}
+
+std::shared_ptr<DataBuffer>
+FileSystem::CreateDataBuffer(const llvm::Twine &path, uint64_t size,
+                             uint64_t offset) {
+  const bool is_volatile = !IsLocal(path);
+  auto buffer =
+      GetMemoryBuffer<llvm::MemoryBuffer>(path, size, offset, is_volatile);
+  if (!buffer)
+    return {};
   return std::shared_ptr<DataBufferLLVM>(new DataBufferLLVM(std::move(buffer)));
 }
 
+std::shared_ptr<WritableDataBuffer>
+FileSystem::CreateWritableDataBuffer(const FileSpec &file_spec, uint64_t size,
+                                     uint64_t offset) {
+  return CreateWritableDataBuffer(file_spec.GetPath(), size, offset);
+}
+
 std::shared_ptr<DataBuffer>
 FileSystem::CreateDataBuffer(const FileSpec &file_spec, uint64_t size,
                              uint64_t offset) {
   return CreateDataBuffer(file_spec.GetPath(), size, offset);
 }
 
 bool FileSystem::ResolveExecutableLocation(FileSpec &file_spec) {
   // If the directory is set there's nothing to do.

lldb/source/Host/common/Host.cpp

if (!shell_info_sp->process_reaped.WaitForValueEqualTo(true, timeout)) {
         command_output_ptr->clear();
         uint64_t file_size =
             FileSystem::Instance().GetByteSize(output_file_spec);
         if (file_size > 0) {
           if (file_size > command_output_ptr->max_size()) {
             error.SetErrorStringWithFormat(
                 "shell command output is too large to fit into a std::string");
           } else {
-            auto Buffer =
-                FileSystem::Instance().CreateDataBuffer(output_file_spec);
+            WritableDataBufferSP Buffer =
+                FileSystem::Instance().CreateWritableDataBuffer(
+                    output_file_spec);
             if (error.Success())
               command_output_ptr->assign(
                   reinterpret_cast<char *>(Buffer->GetBytes()),
                   Buffer->GetByteSize());
           }
         }
       }
     }

lldb/source/Plugins/ABI/ARM/ABISysV_arm.cpp

if (compiler_type.IsIntegerOrEnumerationType(is_signed)) {
     // not handled yet
     return return_valobj_sp;
   }
 
   if (is_vfp_candidate) {
     ProcessSP process_sp(thread.GetProcess());
     ByteOrder byte_order = process_sp->GetByteOrder();
 
-    DataBufferSP data_sp(new DataBufferHeap(*byte_size, 0));
+    WritableDataBufferSP data_sp(new DataBufferHeap(*byte_size, 0));
     uint32_t data_offset = 0;
 
     for (uint32_t reg_index = 0; reg_index < vfp_count; reg_index++) {
       uint32_t regnum = 0;
 
       if (vfp_byte_size == 4)
         regnum = dwarf_s0 + reg_index;
       else if (vfp_byte_size == 8)

lldb/source/Plugins/ABI/Mips/ABISysV_mips.cpp

else {
           return return_valobj_sp;
         case 64: {
           static_assert(sizeof(double) == sizeof(uint64_t), "");
           const RegisterInfo *f1_info = reg_ctx->GetRegisterInfoByName("f1", 0);
           RegisterValue f1_value;
           DataExtractor f1_data;
           reg_ctx->ReadRegister(f1_info, f1_value);
           DataExtractor *copy_from_extractor = nullptr;
-          DataBufferSP data_sp(new DataBufferHeap(8, 0));
+          WritableDataBufferSP data_sp(new DataBufferHeap(8, 0));
           DataExtractor return_ext(
               data_sp, target_byte_order,
               target->GetArchitecture().GetAddressByteSize());
 
           if (target_byte_order == eByteOrderLittle) {
             copy_from_extractor = &f0_data;
             copy_from_extractor->CopyByteOrderedData(
                 offset, 4, data_sp->GetBytes(), 4, target_byte_order);

lldb/source/Plugins/ABI/Mips/ABISysV_mips64.cpp

if (type_flags & eTypeIsInteger || type_flags & eTypeIsPointer) {
             success = true;
           } else if (*byte_size == sizeof(long double)) {
             const RegisterInfo *f2_info =
                 reg_ctx->GetRegisterInfoByName("f2", 0);
             RegisterValue f2_value;
             DataExtractor f2_data;
             reg_ctx->ReadRegister(f2_info, f2_value);
             DataExtractor *copy_from_extractor = nullptr;
-            DataBufferSP data_sp(new DataBufferHeap(16, 0));
+            WritableDataBufferSP data_sp(new DataBufferHeap(16, 0));
             DataExtractor return_ext(
                 data_sp, target_byte_order,
                 target->GetArchitecture().GetAddressByteSize());
 
             if (target_byte_order == eByteOrderLittle) {
               copy_from_extractor = &f0_data;
               copy_from_extractor->CopyByteOrderedData(
                   0, 8, data_sp->GetBytes(), *byte_size - 8, target_byte_order);
if (type_flags & eTypeIsScalar || type_flags & eTypeIsPointer) {
 
     if (success)
       return_valobj_sp = ValueObjectConstResult::Create(
           thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
   } else if (type_flags & eTypeIsStructUnion || type_flags & eTypeIsClass ||
              type_flags & eTypeIsVector) {
     // Any structure of up to 16 bytes in size is returned in the registers.
     if (*byte_size <= 16) {
-      DataBufferSP data_sp(new DataBufferHeap(16, 0));
+      WritableDataBufferSP data_sp(new DataBufferHeap(16, 0));
       DataExtractor return_ext(data_sp, target_byte_order,
                                target->GetArchitecture().GetAddressByteSize());
 
       RegisterValue r2_value, r3_value, f0_value, f1_value, f2_value;
       // Tracks how much bytes of r2 and r3 registers we've consumed so far
       uint32_t integer_bytes = 0;
 
       // True if return values are in FP return registers.

lldb/source/Plugins/ABI/PowerPC/ABISysV_ppc.cpp

ValueObjectSP ABISysV_ppc::GetReturnValueObjectImpl(
   llvm::Optional<uint64_t> bit_width = return_compiler_type.GetBitSize(&thread);
   if (!bit_width)
     return return_valobj_sp;
   if (return_compiler_type.IsAggregateType()) {
     Target *target = exe_ctx.GetTargetPtr();
     bool is_memory = true;
     if (*bit_width <= 128) {
       ByteOrder target_byte_order = target->GetArchitecture().GetByteOrder();
-      DataBufferSP data_sp(new DataBufferHeap(16, 0));
+      WritableDataBufferSP data_sp(new DataBufferHeap(16, 0));
       DataExtractor return_ext(data_sp, target_byte_order,
                                target->GetArchitecture().GetAddressByteSize());
 
       const RegisterInfo *r3_info = reg_ctx_sp->GetRegisterInfoByName("r3", 0);
       const RegisterInfo *rdx_info =
           reg_ctx_sp->GetRegisterInfoByName("rdx", 0);
 
       RegisterValue r3_value, rdx_value;

lldb/source/Plugins/ABI/X86/ABISysV_x86_64.cpp

if (return_compiler_type.IsAggregateType()) {
     std::vector<CompilerType> aggregate_compiler_types;
     if (return_compiler_type.GetTypeSystem()->CanPassInRegisters(
           return_compiler_type) &&
       *bit_width <= 128 &&
       FlattenAggregateType(thread, exe_ctx, return_compiler_type,
                           0, aggregate_field_offsets,
                           aggregate_compiler_types)) {
       ByteOrder byte_order = target->GetArchitecture().GetByteOrder();
-      DataBufferSP data_sp(new DataBufferHeap(16, 0));
+      WritableDataBufferSP data_sp(new DataBufferHeap(16, 0));
       DataExtractor return_ext(data_sp, byte_order,
                                target->GetArchitecture().GetAddressByteSize());
 
       const RegisterInfo *rax_info =
           reg_ctx_sp->GetRegisterInfoByName("rax", 0);
       const RegisterInfo *rdx_info =
           reg_ctx_sp->GetRegisterInfoByName("rdx", 0);
       const RegisterInfo *xmm0_info =

lldb/source/Plugins/ABI/X86/ABIWindows_x86_64.cpp

bool is_memory = *bit_width > max_register_value_bit_width ||
                    *bit_width & (*bit_width - 1);
   std::vector<uint32_t> aggregate_field_offsets;
   std::vector<CompilerType> aggregate_compiler_types;
   if (!is_memory &&
       FlattenAggregateType(thread, exe_ctx, return_compiler_type,
                            0, aggregate_field_offsets,
                            aggregate_compiler_types)) {
     ByteOrder byte_order = target->GetArchitecture().GetByteOrder();
-    DataBufferSP data_sp(
+    WritableDataBufferSP data_sp(
         new DataBufferHeap(max_register_value_bit_width / 8, 0));
     DataExtractor return_ext(data_sp, byte_order,
         target->GetArchitecture().GetAddressByteSize());
 
     // The only register used to return struct/class by value
     const RegisterInfo *rax_info =
         reg_ctx_sp->GetRegisterInfoByName("rax", 0);
     RegisterValue rax_value;

lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp

if (bytes_read == sizeof(llvm::MachO::mach_header)) {
     // Read the rest of dyld's mach header
     if (data.GetU32(&offset, &header->cputype,
                     (sizeof(llvm::MachO::mach_header) / sizeof(uint32_t)) -
                         1)) {
       if (load_command_data == nullptr)
         return true; // We were able to read the mach_header and weren't asked
                      // to read the load command bytes
 
-      DataBufferSP load_cmd_data_sp(new DataBufferHeap(header->sizeofcmds, 0));
+      WritableDataBufferSP load_cmd_data_sp(
+          new DataBufferHeap(header->sizeofcmds, 0));
 
       size_t load_cmd_bytes_read =
           m_process->ReadMemory(load_cmd_addr, load_cmd_data_sp->GetBytes(),
                                 load_cmd_data_sp->GetByteSize(), error);
 
       if (load_cmd_bytes_read == header->sizeofcmds) {
         // Set the load command data and also set the correct endian swap
         // settings and the correct address size

lldb/source/Plugins/Language/CPlusPlus/LibCxx.cpp

if (m_pair_ptr) {
               ast_ctx->GetBasicType(lldb::eBasicTypeVoid).GetPointerType()},
              {"ptr2",
               ast_ctx->GetBasicType(lldb::eBasicTypeVoid).GetPointerType()},
              {"cw", ast_ctx->GetBasicType(lldb::eBasicTypeBool)},
              {"payload", pair_type}});
         llvm::Optional<uint64_t> size = tree_node_type.GetByteSize(nullptr);
         if (!size)
           return false;
-        DataBufferSP buffer_sp(new DataBufferHeap(*size, 0));
+        WritableDataBufferSP buffer_sp(new DataBufferHeap(*size, 0));
         ProcessSP process_sp(target_sp->GetProcessSP());
         Status error;
         process_sp->ReadMemory(addr, buffer_sp->GetBytes(),
                                buffer_sp->GetByteSize(), error);
         if (error.Fail())
           return false;
         DataExtractor extractor(buffer_sp, process_sp->GetByteOrder(),
                                 process_sp->GetAddressByteSize());

lldb/source/Plugins/Language/CPlusPlus/LibCxxVector.cpp

lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::GetChildAtIndex(
   size_t bytes_read = process_sp->ReadMemory(byte_location, &byte, 1, err);
   if (err.Fail() || bytes_read == 0)
     return {};
   mask = 1 << bit_index;
   bool bit_set = ((byte & mask) != 0);
   llvm::Optional<uint64_t> size = m_bool_type.GetByteSize(nullptr);
   if (!size)
     return {};
-  DataBufferSP buffer_sp(new DataBufferHeap(*size, 0));
+  WritableDataBufferSP buffer_sp(new DataBufferHeap(*size, 0));
   if (bit_set && buffer_sp && buffer_sp->GetBytes()) {
     // regardless of endianness, anything non-zero is true
     *(buffer_sp->GetBytes()) = 1;
   }
   StreamString name;
   name.Printf("[%" PRIu64 "]", (uint64_t)idx);
   ValueObjectSP retval_sp(CreateValueObjectFromData(
       name.GetString(),

lldb/source/Plugins/Language/ObjC/CF.cpp

bool lldb_private::formatters::CFBitVectorSummaryProvider(
   uint64_t num_bytes = count / 8 + ((count & 7) ? 1 : 0);
   addr_t data_ptr = process_sp->ReadPointerFromMemory(
       valobj_addr + 2 * ptr_size + 2 * ptr_size, error);
   if (error.Fail())
     return false;
   // make sure we do not try to read huge amounts of data
   if (num_bytes > 1024)
     num_bytes = 1024;
-  DataBufferSP buffer_sp(new DataBufferHeap(num_bytes, 0));
+  WritableDataBufferSP buffer_sp(new DataBufferHeap(num_bytes, 0));
   num_bytes =
       process_sp->ReadMemory(data_ptr, buffer_sp->GetBytes(), num_bytes, error);
   if (error.Fail() || num_bytes == 0)
     return false;
   uint8_t *bytes = buffer_sp->GetBytes();
   for (uint64_t byte_idx = 0; byte_idx < num_bytes - 1; byte_idx++) {
     uint8_t byte = bytes[byte_idx];
     bool bit0 = (byte & 1) == 1;

lldb/source/Plugins/Language/ObjC/NSDictionary.cpp

if (!m_pair_type.IsValid()) {
       TargetSP target_sp(m_backend.GetTargetSP());
       if (!target_sp)
         return ValueObjectSP();
       m_pair_type = GetLLDBNSPairType(target_sp);
     }
     if (!m_pair_type.IsValid())
       return ValueObjectSP();
 
-    DataBufferSP buffer_sp(new DataBufferHeap(2 * m_ptr_size, 0));
+    WritableDataBufferSP buffer_sp(new DataBufferHeap(2 * m_ptr_size, 0));
 
     if (m_ptr_size == 8) {
       uint64_t *data_ptr = (uint64_t *)buffer_sp->GetBytes();
       *data_ptr = dict_item.key_ptr;
       *(data_ptr + 1) = dict_item.val_ptr;
     } else {
       uint32_t *data_ptr = (uint32_t *)buffer_sp->GetBytes();
       *data_ptr = dict_item.key_ptr;
if (!m_pair_type.IsValid()) {
       TargetSP target_sp(m_backend.GetTargetSP());
       if (!target_sp)
         return ValueObjectSP();
       m_pair_type = GetLLDBNSPairType(target_sp);
     }
     if (!m_pair_type.IsValid())
       return ValueObjectSP();
 
-    DataBufferSP buffer_sp(new DataBufferHeap(2 * m_ptr_size, 0));
+    WritableDataBufferSP buffer_sp(new DataBufferHeap(2 * m_ptr_size, 0));
 
     switch (m_ptr_size) {
     case 0: // architecture has no clue - fail
       return lldb::ValueObjectSP();
     case 4: {
       uint32_t *data_ptr = reinterpret_cast<uint32_t *>(buffer_sp->GetBytes());
       *data_ptr = dict_item.key_ptr;
       *(data_ptr + 1) = dict_item.val_ptr;
if (!m_pair_type.IsValid()) {
       TargetSP target_sp(m_backend.GetTargetSP());
       if (!target_sp)
         return ValueObjectSP();
       m_pair_type = GetLLDBNSPairType(target_sp);
     }
     if (!m_pair_type.IsValid())
       return ValueObjectSP();
 
-    DataBufferSP buffer_sp(new DataBufferHeap(2 * m_ptr_size, 0));
+    WritableDataBufferSP buffer_sp(new DataBufferHeap(2 * m_ptr_size, 0));
 
     if (m_ptr_size == 8) {
       uint64_t *data_ptr = (uint64_t *)buffer_sp->GetBytes();
       *data_ptr = dict_item.key_ptr;
       *(data_ptr + 1) = dict_item.val_ptr;
     } else {
       uint32_t *data_ptr = (uint32_t *)buffer_sp->GetBytes();
       *data_ptr = dict_item.key_ptr;
if (error.Fail())
     return nullptr;
   lldb::addr_t key_at_idx = process_sp->ReadPointerFromMemory(value_ptr, error);
   if (error.Fail())
     return nullptr;
 
   auto pair_type =
       GetLLDBNSPairType(process_sp->GetTarget().shared_from_this());
 
-  DataBufferSP buffer_sp(new DataBufferHeap(2 * ptr_size, 0));
+  WritableDataBufferSP buffer_sp(new DataBufferHeap(2 * ptr_size, 0));
 
   if (ptr_size == 8) {
     uint64_t *data_ptr = (uint64_t *)buffer_sp->GetBytes();
     *data_ptr = key_at_idx;
     *(data_ptr + 1) = value_at_idx;
   } else {
     uint32_t *data_ptr = (uint32_t *)buffer_sp->GetBytes();
     *data_ptr = key_at_idx;
if (!m_pair_type.IsValid()) {
       TargetSP target_sp(m_backend.GetTargetSP());
       if (!target_sp)
         return ValueObjectSP();
       m_pair_type = GetLLDBNSPairType(target_sp);
     }
     if (!m_pair_type.IsValid())
       return ValueObjectSP();
 
-    DataBufferSP buffer_sp(new DataBufferHeap(2 * m_ptr_size, 0));
+    WritableDataBufferSP buffer_sp(new DataBufferHeap(2 * m_ptr_size, 0));
 
     if (m_ptr_size == 8) {
       uint64_t *data_ptr = (uint64_t *)buffer_sp->GetBytes();
       *data_ptr = dict_item.key_ptr;
       *(data_ptr + 1) = dict_item.val_ptr;
     } else {
       uint32_t *data_ptr = (uint32_t *)buffer_sp->GetBytes();
       *data_ptr = dict_item.key_ptr;
if (!m_pair_type.IsValid()) {
       TargetSP target_sp(m_backend.GetTargetSP());
       if (!target_sp)
         return ValueObjectSP();
       m_pair_type = GetLLDBNSPairType(target_sp);
     }
     if (!m_pair_type.IsValid())
       return ValueObjectSP();
 
-    DataBufferSP buffer_sp(new DataBufferHeap(2 * m_ptr_size, 0));
+    WritableDataBufferSP buffer_sp(new DataBufferHeap(2 * m_ptr_size, 0));
 
     if (m_ptr_size == 8) {
       uint64_t *data_ptr = (uint64_t *)buffer_sp->GetBytes();
       *data_ptr = dict_item.key_ptr;
       *(data_ptr + 1) = dict_item.val_ptr;
     } else {
       uint32_t *data_ptr = (uint32_t *)buffer_sp->GetBytes();
       *data_ptr = dict_item.key_ptr;

lldb/source/Plugins/Language/ObjC/NSSet.cpp

lldb_private::formatters::NSCFSetSyntheticFrontEnd::GetChildAtIndex(
   }
 
   if (idx >= m_children.size()) // should never happen
     return lldb::ValueObjectSP();
 
   SetItemDescriptor &set_item = m_children[idx];
   if (!set_item.valobj_sp) {
 
-    DataBufferSP buffer_sp(new DataBufferHeap(m_ptr_size, 0));
+    WritableDataBufferSP buffer_sp(new DataBufferHeap(m_ptr_size, 0));
 
     switch (m_ptr_size) {
     case 0: // architecture has no clue - fail
       return lldb::ValueObjectSP();
     case 4:
       *reinterpret_cast<uint32_t *>(buffer_sp->GetBytes()) =
           static_cast<uint32_t>(set_item.item_ptr);
       break;

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

void AppleObjCRuntimeV1::ClassDescriptorV1::Initialize(
   lldb::addr_t name_ptr =
       process_sp->ReadPointerFromMemory(m_isa + 2 * ptr_size, error);
 
   if (error.Fail()) {
     m_valid = false;
     return;
   }
 
-  lldb::DataBufferSP buffer_sp(new DataBufferHeap(1024, 0));
+  lldb::WritableDataBufferSP buffer_sp(new DataBufferHeap(1024, 0));
 
   size_t count = process_sp->ReadCStringFromMemory(
       name_ptr, (char *)buffer_sp->GetBytes(), 1024, error);
 
   if (error.Fail()) {
     m_valid = false;
     return;
   }
 
   if (count)
-    m_name = ConstString((char *)buffer_sp->GetBytes());
+    m_name = ConstString(reinterpret_cast<const char *>(buffer_sp->GetBytes()));
   else
     m_name = ConstString();
 
   m_instance_size = process_sp->ReadUnsignedIntegerFromMemory(
       m_isa + 5 * ptr_size, ptr_size, 0, error);
 
   if (error.Fail()) {
     m_valid = false;

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

void AppleObjCTrampolineHandler::AppleObjCVTables::VTableRegion::SetUpRegion() {
   // the offset of the vtable code from the beginning of the
   // descriptor record.  Below, we'll convert that into an absolute
   // code address, since I don't want to have to compute it over and
   // over.
 
   // Ingest the whole descriptor array:
   const lldb::addr_t desc_ptr = m_header_addr + header_size;
   const size_t desc_array_size = num_descriptors * descriptor_size;
-  DataBufferSP data_sp(new DataBufferHeap(desc_array_size, '\0'));
+  WritableDataBufferSP data_sp(new DataBufferHeap(desc_array_size, '\0'));
   uint8_t *dst = (uint8_t *)data_sp->GetBytes();
 
   DataExtractor desc_extractor(dst, desc_array_size, process_sp->GetByteOrder(),
                                process_sp->GetAddressByteSize());
   bytes_read = process_sp->ReadMemory(desc_ptr, dst, desc_array_size, error);
   if (bytes_read != desc_array_size) {
     m_valid = false;
     return;

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

if (!FileSystem::Instance().Readable(file)) {
     strm.EOL();
     return false;
   }
 
   // Read file into data buffer
   auto data_sp = FileSystem::Instance().CreateDataBuffer(file.GetPath());
 
   // Cast start of buffer to FileHeader and use pointer to read metadata
-  void *file_buf = data_sp->GetBytes();
+  const void *file_buf = data_sp->GetBytes();
   if (file_buf == nullptr ||
       data_sp->GetByteSize() < (sizeof(AllocationDetails::FileHeader) +
                                 sizeof(AllocationDetails::ElementHeader))) {
     strm.Printf("Error: File %s does not contain enough data for header", path);
     strm.EOL();
     return false;
   }
   const AllocationDetails::FileHeader *file_header =
-      static_cast<AllocationDetails::FileHeader *>(file_buf);
+      static_cast<const AllocationDetails::FileHeader *>(file_buf);
 
   // Check file starts with ascii characters "RSAD"
   if (memcmp(file_header->ident, "RSAD", 4)) {
     strm.Printf("Error: File doesn't contain identifier for an RS allocation "
                 "dump. Are you sure this is the correct file?");
     strm.EOL();
     return false;
   }
 
   // Look at the type of the root element in the header
   AllocationDetails::ElementHeader root_el_hdr;
-  memcpy(&root_el_hdr, static_cast<uint8_t *>(file_buf) +
-                           sizeof(AllocationDetails::FileHeader),
+  memcpy(&root_el_hdr,
+         static_cast<const uint8_t *>(file_buf) +
          sizeof(AllocationDetails::ElementHeader));
 
   LLDB_LOGF(log, "%s - header type %" PRIu32 ", element size %" PRIu32,
             __FUNCTION__, root_el_hdr.type, root_el_hdr.element_size);
 
   // Check if the target allocation and file both have the same number of bytes
   // for an Element
   if (*alloc->element.datum_size.get() != root_el_hdr.element_size) {
if (file_type > Element::RS_TYPE_FONT) {
 
     strm.Printf(
         "Warning: Mismatched Types - file '%s' type, allocation '%s' type",
         head_type_name, target_type_name);
     strm.EOL();
   }
 
   // Advance buffer past header
-  file_buf = static_cast<uint8_t *>(file_buf) + file_header->hdr_size;
+  file_buf = static_cast<const uint8_t *>(file_buf) + file_header->hdr_size;
 
   // Calculate size of allocation data in file
   size_t size = data_sp->GetByteSize() - file_header->hdr_size;
 
   // Check if the target allocation and file both have the same total data
   // size.
   const uint32_t alloc_size = *alloc->size.get();
   if (alloc_size != size) {

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.h

public:
 
   void RelocateSection(lldb_private::Section *section) override;
 
 protected:
 
   std::vector<LoadableData>
   GetLoadableData(lldb_private::Target &target) override;
 
+  static lldb::WritableDataBufferSP
+  MapFileDataWritable(const lldb_private::FileSpec &file, uint64_t Size,
+                      uint64_t Offset);
+
 private:
   ObjectFileELF(const lldb::ModuleSP &module_sp, lldb::DataBufferSP &data_sp,
                 lldb::offset_t data_offset, const lldb_private::FileSpec *file,
                 lldb::offset_t offset, lldb::offset_t length);
 
   ObjectFileELF(const lldb::ModuleSP &module_sp,
                 lldb::DataBufferSP &header_data_sp,
                 const lldb::ProcessSP &process_sp, lldb::addr_t header_addr);

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

 }
 
 ObjectFile *ObjectFileELF::CreateInstance(const lldb::ModuleSP &module_sp,
                                           DataBufferSP data_sp,
                                           lldb::offset_t data_offset,
                                           const lldb_private::FileSpec *file,
                                           lldb::offset_t file_offset,
                                           lldb::offset_t length) {
+  bool mapped_writable = false;
   if (!data_sp) {
-    data_sp = MapFileData(*file, length, file_offset);
+    data_sp = MapFileDataWritable(*file, length, file_offset);
     if (!data_sp)
       return nullptr;
     data_offset = 0;
+    mapped_writable = true;
   }
 
   assert(data_sp);
 
   if (data_sp->GetByteSize() <= (llvm::ELF::EI_NIDENT + data_offset))
     return nullptr;
 
   const uint8_t *magic = data_sp->GetBytes() + data_offset;
   if (!ELFHeader::MagicBytesMatch(magic))
     return nullptr;
 
   // Update the data to contain the entire file if it doesn't already
   if (data_sp->GetByteSize() < length) {
-    data_sp = MapFileData(*file, length, file_offset);
+    data_sp = MapFileDataWritable(*file, length, file_offset);
     if (!data_sp)
       return nullptr;
     data_offset = 0;
+    mapped_writable = true;
+    magic = data_sp->GetBytes();
+  }
+
+  // If we didn't map the data as writable take ownership of the buffer.
+  if (!mapped_writable) {
+    data_sp = std::make_shared<DataBufferHeap>(data_sp->GetBytes(),
+                                               data_sp->GetByteSize());
+    data_offset = 0;
     magic = data_sp->GetBytes();
   }
 
   unsigned address_size = ELFHeader::AddressSizeInBytes(magic);
   if (address_size == 4 || address_size == 8) {
     std::unique_ptr<ObjectFileELF> objfile_up(new ObjectFileELF(
         module_sp, data_sp, data_offset, file, file_offset, length));
     ArchSpec spec = objfile_up->GetArchitecture();
     if (spec && objfile_up->SetModulesArchitecture(spec))
       return objfile_up.release();
   }
 
   return nullptr;
 }
 
 ObjectFile *ObjectFileELF::CreateMemoryInstance(
     const lldb::ModuleSP &module_sp, DataBufferSP data_sp,
     const lldb::ProcessSP &process_sp, lldb::addr_t header_addr) {
   if (data_sp && data_sp->GetByteSize() > (llvm::ELF::EI_NIDENT)) {
     const uint8_t *magic = data_sp->GetBytes();
     if (ELFHeader::MagicBytesMatch(magic)) {
       unsigned address_size = ELFHeader::AddressSizeInBytes(magic);
       if (address_size == 4 || address_size == 8) {
         std::unique_ptr<ObjectFileELF> objfile_up(
             new ObjectFileELF(module_sp, data_sp, process_sp, header_addr));
for (unsigned i = 0; i < num_relocations; ++i) {
     } else {
       switch (reloc_type(rel)) {
       case R_AARCH64_ABS64:
       case R_X86_64_64: {
         symbol = symtab->FindSymbolByID(reloc_symbol(rel));
         if (symbol) {
           addr_t value = symbol->GetAddressRef().GetFileAddress();
           DataBufferSP &data_buffer_sp = debug_data.GetSharedDataBuffer();
+          // ObjectFileELF creates a WritableDataBuffer in CreateInstance.
+          WritableDataBuffer *data_buffer =
+              llvm::cast<WritableDataBuffer>(data_buffer_sp.get());
           uint64_t *dst = reinterpret_cast<uint64_t *>(
-              data_buffer_sp->GetBytes() + rel_section->GetFileOffset() +
+              data_buffer->GetBytes() + rel_section->GetFileOffset() +
               ELFRelocation::RelocOffset64(rel));
           uint64_t val_offset = value + ELFRelocation::RelocAddend64(rel);
           memcpy(dst, &val_offset, sizeof(uint64_t));
         }
         break;
       }
       case R_X86_64_32:
       case R_X86_64_32S:
       case R_AARCH64_ABS32: {
         symbol = symtab->FindSymbolByID(reloc_symbol(rel));
         if (symbol) {
           addr_t value = symbol->GetAddressRef().GetFileAddress();
           value += ELFRelocation::RelocAddend32(rel);
           if ((reloc_type(rel) == R_X86_64_32 && (value > UINT32_MAX)) ||
               (reloc_type(rel) == R_X86_64_32S &&
                ((int64_t)value > INT32_MAX && (int64_t)value < INT32_MIN)) ||
               (reloc_type(rel) == R_AARCH64_ABS32 &&
                ((int64_t)value > INT32_MAX && (int64_t)value < INT32_MIN))) {
             Log *log = GetLog(LLDBLog::Modules);
             LLDB_LOGF(log, "Failed to apply debug info relocations");
             break;
           }
           uint32_t truncated_addr = (value & 0xFFFFFFFF);
           DataBufferSP &data_buffer_sp = debug_data.GetSharedDataBuffer();
+          // ObjectFileELF creates a WritableDataBuffer in CreateInstance.
+          WritableDataBuffer *data_buffer =
+              llvm::cast<WritableDataBuffer>(data_buffer_sp.get());
           uint32_t *dst = reinterpret_cast<uint32_t *>(
-              data_buffer_sp->GetBytes() + rel_section->GetFileOffset() +
+              data_buffer->GetBytes() + rel_section->GetFileOffset() +
               ELFRelocation::RelocOffset32(rel));
           memcpy(dst, &truncated_addr, sizeof(uint32_t));
         }
         break;
       }
       case R_X86_64_PC32:
       default:
         assert(false && "unexpected relocation type");
if (H.p_filesz == 0)
       continue;
     auto segment_data = GetSegmentData(H);
     loadable.Contents = llvm::ArrayRef<uint8_t>(segment_data.GetDataStart(),
                                                 segment_data.GetByteSize());
     loadables.push_back(loadable);
   }
   return loadables;
 }
+
+lldb::WritableDataBufferSP
+ObjectFileELF::MapFileDataWritable(const FileSpec &file, uint64_t Size,
+                                   uint64_t Offset) {
+  return FileSystem::Instance().CreateWritableDataBuffer(file.GetPath(), Size,
+                                                         Offset);
+}

lldb/source/Plugins/ObjectFile/wasm/ObjectFileWasm.cpp

 static bool ValidateModuleHeader(const DataBufferSP &data_sp) {
   if (!data_sp || data_sp->GetByteSize() < kWasmHeaderSize)
     return false;
 
   if (llvm::identify_magic(toStringRef(data_sp->GetData())) !=
       llvm::file_magic::wasm_object)
     return false;
 
-  uint8_t *Ptr = data_sp->GetBytes() + sizeof(llvm::wasm::WasmMagic);
+  const uint8_t *Ptr = data_sp->GetBytes() + sizeof(llvm::wasm::WasmMagic);
 
   uint32_t version = llvm::support::endian::read32le(Ptr);
   return version == llvm::wasm::WasmVersion;
 }
 
 static llvm::Optional<ConstString>
 GetWasmString(llvm::DataExtractor &data, llvm::DataExtractor::Cursor &c) {
   // A Wasm string is encoded as a vector of UTF-8 codes.

lldb/source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

user_id_t fd_dst = FileCache::GetInstance().OpenFile(
         permissions, error);
 
     if (fd_dst == UINT64_MAX) {
       if (error.Success())
         error.SetErrorString("unable to open destination file");
     }
 
     if (error.Success()) {
-      lldb::DataBufferSP buffer_sp(new DataBufferHeap(1024, 0));
+      lldb::WritableDataBufferSP buffer_sp(new DataBufferHeap(1024, 0));
       uint64_t offset = 0;
       error.Clear();
       while (error.Success()) {
         const uint64_t n_read = ReadFile(fd_src, offset, buffer_sp->GetBytes(),
                                          buffer_sp->GetByteSize(), error);
         if (error.Fail())
           break;
         if (n_read == 0)

lldb/source/Plugins/Process/Utility/RegisterContextDarwin_arm.h

public:
   const lldb_private::RegisterSet *GetRegisterSet(size_t set) override;
 
   bool ReadRegister(const lldb_private::RegisterInfo *reg_info,
                     lldb_private::RegisterValue &reg_value) override;
 
   bool WriteRegister(const lldb_private::RegisterInfo *reg_info,
                      const lldb_private::RegisterValue &reg_value) override;
 
-  bool ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
+  bool ReadAllRegisterValues(lldb::WritableDataBufferSP &data_sp) override;
 
   bool WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
 
   uint32_t ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind,
                                                uint32_t num) override;
 
   uint32_t NumSupportedHardwareBreakpoints() override;
 

lldb/source/Plugins/Process/Utility/RegisterContextDarwin_arm.cpp

bool RegisterContextDarwin_arm::WriteRegister(const RegisterInfo *reg_info,
 
   default:
     return false;
   }
   return WriteRegisterSet(set) == KERN_SUCCESS;
 }
 
 bool RegisterContextDarwin_arm::ReadAllRegisterValues(
-    lldb::DataBufferSP &data_sp) {
+    lldb::WritableDataBufferSP &data_sp) {
   data_sp = std::make_shared<DataBufferHeap>(REG_CONTEXT_SIZE, 0);
   if (data_sp && ReadGPR(false) == KERN_SUCCESS &&
       ReadFPU(false) == KERN_SUCCESS && ReadEXC(false) == KERN_SUCCESS) {
     uint8_t *dst = data_sp->GetBytes();
     ::memcpy(dst, &gpr, sizeof(gpr));
     dst += sizeof(gpr);
 
     ::memcpy(dst, &fpu, sizeof(fpu));

lldb/source/Plugins/Process/Utility/RegisterContextDarwin_arm64.h

public:
   const lldb_private::RegisterSet *GetRegisterSet(size_t set) override;
 
   bool ReadRegister(const lldb_private::RegisterInfo *reg_info,
                     lldb_private::RegisterValue &reg_value) override;
 
   bool WriteRegister(const lldb_private::RegisterInfo *reg_info,
                      const lldb_private::RegisterValue &reg_value) override;
 
-  bool ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
+  bool ReadAllRegisterValues(lldb::WritableDataBufferSP &data_sp) override;
 
   bool WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
 
   uint32_t ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind,
                                                uint32_t num) override;
 
   uint32_t NumSupportedHardwareWatchpoints() override;
 

lldb/source/Plugins/Process/Utility/RegisterContextDarwin_arm64.cpp

bool RegisterContextDarwin_arm64::WriteRegister(const RegisterInfo *reg_info,
 
   default:
     return false;
   }
   return WriteRegisterSet(set) == KERN_SUCCESS;
 }
 
 bool RegisterContextDarwin_arm64::ReadAllRegisterValues(
-    lldb::DataBufferSP &data_sp) {
+    lldb::WritableDataBufferSP &data_sp) {
   data_sp = std::make_shared<DataBufferHeap>(REG_CONTEXT_SIZE, 0);
   if (ReadGPR(false) == KERN_SUCCESS && ReadFPU(false) == KERN_SUCCESS &&
       ReadEXC(false) == KERN_SUCCESS) {
     uint8_t *dst = data_sp->GetBytes();
     ::memcpy(dst, &gpr, sizeof(gpr));
     dst += sizeof(gpr);
 
     ::memcpy(dst, &fpu, sizeof(fpu));

lldb/source/Plugins/Process/Utility/RegisterContextDarwin_i386.h

public:
   const lldb_private::RegisterSet *GetRegisterSet(size_t set) override;
 
   bool ReadRegister(const lldb_private::RegisterInfo *reg_info,
                     lldb_private::RegisterValue &value) override;
 
   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;
 
   uint32_t ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind,
                                                uint32_t num) override;
 
   bool HardwareSingleStep(bool enable) override;
 

lldb/source/Plugins/Process/Utility/RegisterContextDarwin_i386.cpp

bool RegisterContextDarwin_i386::WriteRegister(const RegisterInfo *reg_info,
 
   default:
     return false;
   }
   return WriteRegisterSet(set) == 0;
 }
 
 bool RegisterContextDarwin_i386::ReadAllRegisterValues(
-    lldb::DataBufferSP &data_sp) {
+    lldb::WritableDataBufferSP &data_sp) {
   data_sp = std::make_shared<DataBufferHeap>(REG_CONTEXT_SIZE, 0);
   if (ReadGPR(false) == 0 && ReadFPU(false) == 0 && ReadEXC(false) == 0) {
     uint8_t *dst = data_sp->GetBytes();
     ::memcpy(dst, &gpr, sizeof(gpr));
     dst += sizeof(gpr);
 
     ::memcpy(dst, &fpu, sizeof(fpu));
     dst += sizeof(gpr);

lldb/source/Plugins/Process/Utility/RegisterContextDarwin_x86_64.h

public:
   const lldb_private::RegisterSet *GetRegisterSet(size_t set) override;
 
   bool ReadRegister(const lldb_private::RegisterInfo *reg_info,
                     lldb_private::RegisterValue &value) override;
 
   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;
 
   uint32_t ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind,
                                                uint32_t num) override;
 
   bool HardwareSingleStep(bool enable) override;
 

lldb/source/Plugins/Process/Utility/RegisterContextDarwin_x86_64.cpp

bool RegisterContextDarwin_x86_64::WriteRegister(const RegisterInfo *reg_info,
 
   default:
     return false;
   }
   return WriteRegisterSet(set) == 0;
 }
 
 bool RegisterContextDarwin_x86_64::ReadAllRegisterValues(
-    lldb::DataBufferSP &data_sp) {
+    lldb::WritableDataBufferSP &data_sp) {
   data_sp = std::make_shared<DataBufferHeap>(REG_CONTEXT_SIZE, 0);
   if (ReadGPR(false) == 0 && ReadFPU(false) == 0 && ReadEXC(false) == 0) {
     uint8_t *dst = data_sp->GetBytes();
     ::memcpy(dst, &gpr, sizeof(gpr));
     dst += sizeof(gpr);
 
     ::memcpy(dst, &fpu, sizeof(fpu));
     dst += sizeof(gpr);

lldb/source/Plugins/Process/Utility/RegisterContextDummy.h

public:
   const lldb_private::RegisterSet *GetRegisterSet(size_t reg_set) override;
 
   bool ReadRegister(const lldb_private::RegisterInfo *reg_info,
                     lldb_private::RegisterValue &value) override;
 
   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;
 
   uint32_t ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind,
                                                uint32_t num) override;
 
 private:
   // For RegisterContextLLDB only

lldb/source/Plugins/Process/Utility/RegisterContextDummy.cpp

 }
 
 bool RegisterContextDummy::WriteRegister(
     const lldb_private::RegisterInfo *reg_info,
     const lldb_private::RegisterValue &value) {
   return false;
 }
 
-bool RegisterContextDummy::ReadAllRegisterValues(lldb::DataBufferSP &data_sp) {
+bool RegisterContextDummy::ReadAllRegisterValues(
+    lldb::WritableDataBufferSP &data_sp) {
   return false;
 }
 
 bool RegisterContextDummy::WriteAllRegisterValues(
     const lldb::DataBufferSP &data_sp) {
   return false;
 }
 
 uint32_t RegisterContextDummy::ConvertRegisterKindToRegisterNumber(
     lldb::RegisterKind kind, uint32_t num) {
   if (kind == eRegisterKindGeneric && num == LLDB_REGNUM_GENERIC_PC)
     return 0;
   return LLDB_INVALID_REGNUM;
 }

lldb/source/Plugins/Process/Utility/RegisterContextHistory.h

public:
   const lldb_private::RegisterSet *GetRegisterSet(size_t reg_set) override;
 
   bool ReadRegister(const lldb_private::RegisterInfo *reg_info,
                     lldb_private::RegisterValue &value) override;
 
   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;
 
   uint32_t ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind,
                                                uint32_t num) override;
 
 private:
   // For RegisterContextLLDB only

lldb/source/Plugins/Process/Utility/RegisterContextHistory.cpp

 
 bool RegisterContextHistory::WriteRegister(
     const lldb_private::RegisterInfo *reg_info,
     const lldb_private::RegisterValue &value) {
   return false;
 }
 
 bool RegisterContextHistory::ReadAllRegisterValues(
-    lldb::DataBufferSP &data_sp) {
+    lldb::WritableDataBufferSP &data_sp) {
   return false;
 }
 
 bool RegisterContextHistory::WriteAllRegisterValues(
     const lldb::DataBufferSP &data_sp) {
   return false;
 }
 
 uint32_t RegisterContextHistory::ConvertRegisterKindToRegisterNumber(
     lldb::RegisterKind kind, uint32_t num) {
   if (kind == eRegisterKindGeneric && num == LLDB_REGNUM_GENERIC_PC)
     return 0;
   return LLDB_INVALID_REGNUM;
 }

lldb/source/Plugins/Process/Utility/RegisterContextMemory.h

public:
   // class and modify the read/write functions as needed.
 
   bool ReadRegister(const lldb_private::RegisterInfo *reg_info,
                     lldb_private::RegisterValue &reg_value) override;
 
   bool WriteRegister(const lldb_private::RegisterInfo *reg_info,
                      const lldb_private::RegisterValue &reg_value) override;
 
-  bool ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
+  bool ReadAllRegisterValues(lldb::WritableDataBufferSP &data_sp) override;
 
   bool WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
 
   void SetAllRegisterData(const lldb::DataBufferSP &data_sp);
 
 protected:
   void SetAllRegisterValid(bool b);
 
   lldb_private::DynamicRegisterInfo &m_reg_infos;
   std::vector<bool> m_reg_valid;
+  lldb::WritableDataBufferSP m_data;
   lldb_private::DataExtractor m_reg_data;
   lldb::addr_t m_reg_data_addr; // If this is valid, then we have a register
                                 // context that is stored in memmory
 
 private:
   RegisterContextMemory(const RegisterContextMemory &) = delete;
   const RegisterContextMemory &
   operator=(const RegisterContextMemory &) = delete;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_REGISTERCONTEXTMEMORY_H

lldb/source/Plugins/Process/Utility/RegisterContextMemory.cpp

RegisterContextMemory::RegisterContextMemory(Thread &thread,
   // Resize our vector of bools to contain one bool for every register. We will
   // use these boolean values to know when a register value is valid in
   // m_reg_data.
   const size_t num_regs = reg_infos.GetNumRegisters();
   assert(num_regs > 0);
   m_reg_valid.resize(num_regs);
 
   // Make a heap based buffer that is big enough to store all registers
-  DataBufferSP reg_data_sp(
-      new DataBufferHeap(reg_infos.GetRegisterDataByteSize(), 0));
-  m_reg_data.SetData(reg_data_sp);
+  m_data =
+      std::make_shared<DataBufferHeap>(reg_infos.GetRegisterDataByteSize(), 0);
+  m_reg_data.SetData(m_data);
 }
 
 // Destructor
 RegisterContextMemory::~RegisterContextMemory() = default;
 
 void RegisterContextMemory::InvalidateAllRegisters() {
   if (m_reg_data_addr != LLDB_INVALID_ADDRESS)
     SetAllRegisterValid(false);
uint32_t RegisterContextMemory::ConvertRegisterKindToRegisterNumber(
     lldb::RegisterKind kind, uint32_t num) {
   return m_reg_infos.ConvertRegisterKindToRegisterNumber(kind, num);
 }
 
 bool RegisterContextMemory::ReadRegister(const RegisterInfo *reg_info,
                                          RegisterValue &reg_value) {
   const uint32_t reg_num = reg_info->kinds[eRegisterKindLLDB];
   if (!m_reg_valid[reg_num]) {
-    if (!ReadAllRegisterValues(m_reg_data.GetSharedDataBuffer()))
+    if (!ReadAllRegisterValues(m_data))
       return false;
   }
   const bool partial_data_ok = false;
   return reg_value
       .SetValueFromData(reg_info, m_reg_data, reg_info->byte_offset,
                         partial_data_ok)
       .Success();
 }
 
 bool RegisterContextMemory::WriteRegister(const RegisterInfo *reg_info,
                                           const RegisterValue &reg_value) {
   if (m_reg_data_addr != LLDB_INVALID_ADDRESS) {
     const uint32_t reg_num = reg_info->kinds[eRegisterKindLLDB];
     addr_t reg_addr = m_reg_data_addr + reg_info->byte_offset;
     Status error(WriteRegisterValueToMemory(reg_info, reg_addr,
                                             reg_info->byte_size, reg_value));
     m_reg_valid[reg_num] = false;
     return error.Success();
   }
   return false;
 }
 
-bool RegisterContextMemory::ReadAllRegisterValues(DataBufferSP &data_sp) {
+bool RegisterContextMemory::ReadAllRegisterValues(
+    WritableDataBufferSP &data_sp) {
   if (m_reg_data_addr != LLDB_INVALID_ADDRESS) {
     ProcessSP process_sp(CalculateProcess());
     if (process_sp) {
       Status error;
       if (process_sp->ReadMemory(m_reg_data_addr, data_sp->GetBytes(),
                                  data_sp->GetByteSize(),
                                  error) == data_sp->GetByteSize()) {
         SetAllRegisterValid(true);

lldb/source/Plugins/Process/Utility/RegisterContextThreadMemory.h

public:
   // restoring the original state by passing the data_sp we got from
   // ReadAllRegisters to WriteAllRegisterValues.
   // ReadAllRegisters will do what is necessary to return a coherent set of
   // register values for this thread, which
   // may mean e.g. interrupting a thread that is sitting in a kernel trap.  That
   // is a somewhat disruptive operation,
   // so these API's should only be used when this behavior is needed.
 
-  bool ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
+  bool ReadAllRegisterValues(lldb::WritableDataBufferSP &data_sp) override;
 
   bool WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
 
   bool CopyFromRegisterContext(lldb::RegisterContextSP context);
 
   uint32_t ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind,
                                                uint32_t num) override;
 

lldb/source/Plugins/Process/Utility/RegisterContextThreadMemory.cpp

bool RegisterContextThreadMemory::WriteRegister(
     const RegisterInfo *reg_info, const RegisterValue &reg_value) {
   UpdateRegisterContext();
   if (m_reg_ctx_sp)
     return m_reg_ctx_sp->WriteRegister(reg_info, reg_value);
   return false;
 }
 
 bool RegisterContextThreadMemory::ReadAllRegisterValues(
-    lldb::DataBufferSP &data_sp) {
+    lldb::WritableDataBufferSP &data_sp) {
   UpdateRegisterContext();
   if (m_reg_ctx_sp)
     return m_reg_ctx_sp->ReadAllRegisterValues(data_sp);
   return false;
 }
 
 bool RegisterContextThreadMemory::WriteAllRegisterValues(
     const lldb::DataBufferSP &data_sp) {

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_arm.h

public:
   ~RegisterContextCorePOSIX_arm() override;
 
   bool ReadRegister(const lldb_private::RegisterInfo *reg_info,
                     lldb_private::RegisterValue &value) override;
 
   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;
 
   bool HardwareSingleStep(bool enable) override;
 
 protected:
   bool ReadGPR() override;
 

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_arm.cpp

if (offset == reg_info->byte_offset + reg_info->byte_size) {
       value = v;
       return true;
     }
   }
   return false;
 }
 
 bool RegisterContextCorePOSIX_arm::ReadAllRegisterValues(
-    lldb::DataBufferSP &data_sp) {
+    lldb::WritableDataBufferSP &data_sp) {
   return false;
 }
 
 bool RegisterContextCorePOSIX_arm::WriteRegister(const RegisterInfo *reg_info,
                                                  const RegisterValue &value) {
   return false;
 }
 
 bool RegisterContextCorePOSIX_arm::WriteAllRegisterValues(
     const lldb::DataBufferSP &data_sp) {
   return false;
 }
 
 bool RegisterContextCorePOSIX_arm::HardwareSingleStep(bool enable) {
   return false;
 }

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_arm64.h

public:
   ~RegisterContextCorePOSIX_arm64() override;
 
   bool ReadRegister(const lldb_private::RegisterInfo *reg_info,
                     lldb_private::RegisterValue &value) override;
 
   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;
 
   bool HardwareSingleStep(bool enable) override;
 
 protected:
   RegisterContextCorePOSIX_arm64(
       lldb_private::Thread &thread,

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_arm64.cpp

value.SetFromMemoryData(reg_info, m_pac_data.GetDataStart() + offset,
                             reg_info->byte_size, lldb::eByteOrderLittle, error);
   } else
     return false;
 
   return error.Success();
 }
 
 bool RegisterContextCorePOSIX_arm64::ReadAllRegisterValues(
-    lldb::DataBufferSP &data_sp) {
+    lldb::WritableDataBufferSP &data_sp) {
   return false;
 }
 
 bool RegisterContextCorePOSIX_arm64::WriteRegister(const RegisterInfo *reg_info,
                                                    const RegisterValue &value) {
   return false;
 }
 
 bool RegisterContextCorePOSIX_arm64::WriteAllRegisterValues(
     const lldb::DataBufferSP &data_sp) {
   return false;
 }
 
 bool RegisterContextCorePOSIX_arm64::HardwareSingleStep(bool enable) {
   return false;
 }

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_mips64.h

public:
   ~RegisterContextCorePOSIX_mips64() override;
 
   bool ReadRegister(const lldb_private::RegisterInfo *reg_info,
                     lldb_private::RegisterValue &value) override;
 
   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;
 
   bool HardwareSingleStep(bool enable) override;
 
 protected:
   bool ReadGPR() override;
 

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_mips64.cpp

if (IsGPR(reg_info->kinds[lldb::eRegisterKindLLDB])) {
     v =m_fpr.GetMaxU64(&offset, reg_info->byte_size);
     value = v;
     return true;
     }
   return false;
 }
 
 bool RegisterContextCorePOSIX_mips64::ReadAllRegisterValues(
-    lldb::DataBufferSP &data_sp) {
+    lldb::WritableDataBufferSP &data_sp) {
   return false;
 }
 
 bool RegisterContextCorePOSIX_mips64::WriteRegister(
     const RegisterInfo *reg_info, const RegisterValue &value) {
   return false;
 }
 
 bool RegisterContextCorePOSIX_mips64::WriteAllRegisterValues(
     const lldb::DataBufferSP &data_sp) {
   return false;
 }
 
 bool RegisterContextCorePOSIX_mips64::HardwareSingleStep(bool enable) {
   return false;
 }

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_powerpc.h

public:
   ~RegisterContextCorePOSIX_powerpc() override;
 
   bool ReadRegister(const lldb_private::RegisterInfo *reg_info,
                     lldb_private::RegisterValue &value) override;
 
   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;
 
   bool HardwareSingleStep(bool enable) override;
 
 protected:
   bool ReadGPR() override;
 

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_powerpc.cpp

if (offset == reg_info->byte_offset + reg_info->byte_size) {
         value = v;
       return true;
     }
   }
   return false;
 }
 
 bool RegisterContextCorePOSIX_powerpc::ReadAllRegisterValues(
-    lldb::DataBufferSP &data_sp) {
+    lldb::WritableDataBufferSP &data_sp) {
   return false;
 }
 
 bool RegisterContextCorePOSIX_powerpc::WriteRegister(
     const RegisterInfo *reg_info, const RegisterValue &value) {
   return false;
 }
 
 bool RegisterContextCorePOSIX_powerpc::WriteAllRegisterValues(
     const lldb::DataBufferSP &data_sp) {
   return false;
 }
 
 bool RegisterContextCorePOSIX_powerpc::HardwareSingleStep(bool enable) {
   return false;
 }

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_s390x.h

public:
   ~RegisterContextCorePOSIX_s390x() override;
 
   bool ReadRegister(const lldb_private::RegisterInfo *reg_info,
                     lldb_private::RegisterValue &value) override;
 
   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;
 
   bool HardwareSingleStep(bool enable) override;
 
 protected:
   bool ReadGPR() override;
 

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_s390x.cpp

if (offset == reg_info->byte_offset + reg_info->byte_size) {
       return true;
     }
   }
 
   return false;
 }
 
 bool RegisterContextCorePOSIX_s390x::ReadAllRegisterValues(
-    lldb::DataBufferSP &data_sp) {
+    lldb::WritableDataBufferSP &data_sp) {
   return false;
 }
 
 bool RegisterContextCorePOSIX_s390x::WriteRegister(const RegisterInfo *reg_info,
                                                    const RegisterValue &value) {
   return false;
 }
 
 bool RegisterContextCorePOSIX_s390x::WriteAllRegisterValues(
     const lldb::DataBufferSP &data_sp) {
   return false;
 }
 
 bool RegisterContextCorePOSIX_s390x::HardwareSingleStep(bool enable) {
   return false;
 }

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_x86_64.h

RegisterContextCorePOSIX_x86_64(
       llvm::ArrayRef<lldb_private::CoreNote> notes);
 
   bool ReadRegister(const lldb_private::RegisterInfo *reg_info,
                     lldb_private::RegisterValue &value) override;
 
   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;
 
   bool HardwareSingleStep(bool enable) override;
 
 protected:
   bool ReadGPR() override;
 

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_x86_64.cpp

bool RegisterContextCorePOSIX_x86_64::ReadRegister(const RegisterInfo *reg_info,
   Status error;
   value.SetFromMemoryData(reg_info, src + offset, reg_info->byte_size,
                           lldb::eByteOrderLittle, error);
 
   return error.Success();
 }
 
 bool RegisterContextCorePOSIX_x86_64::ReadAllRegisterValues(
-    lldb::DataBufferSP &data_sp) {
+    lldb::WritableDataBufferSP &data_sp) {
   return false;
 }
 
 bool RegisterContextCorePOSIX_x86_64::WriteRegister(
     const RegisterInfo *reg_info, const RegisterValue &value) {
   return false;
 }
 
 bool RegisterContextCorePOSIX_x86_64::WriteAllRegisterValues(
     const lldb::DataBufferSP &data_sp) {
   return false;
 }
 
 bool RegisterContextCorePOSIX_x86_64::HardwareSingleStep(bool enable) {
   return false;
 }

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

if (response.GetChar() != 'm') {
     LLDB_LOGF(log,
               "GDBRemoteCommunicationClient::%s: qMemTags response did not "
               "begin with \"m\"",
               __FUNCTION__);
     return nullptr;
   }
 
   size_t expected_bytes = response.GetBytesLeft() / 2;
-  DataBufferSP buffer_sp(new DataBufferHeap(expected_bytes, 0));
+  WritableDataBufferSP buffer_sp(new DataBufferHeap(expected_bytes, 0));
   size_t got_bytes = response.GetHexBytesAvail(buffer_sp->GetData());
   // Check both because in some situations chars are consumed even
   // if the decoding fails.
   if (response.GetBytesLeft() || (expected_bytes != got_bytes)) {
     LLDB_LOGF(
         log,
         "GDBRemoteCommunicationClient::%s: Invalid data in qMemTags response",
         __FUNCTION__);
DataBufferSP GDBRemoteCommunicationClient::ReadRegister(lldb::tid_t tid,
   StreamString payload;
   payload.Printf("p%x", reg);
   StringExtractorGDBRemote response;
   if (SendThreadSpecificPacketAndWaitForResponse(
           tid, std::move(payload), response) != PacketResult::Success ||
       !response.IsNormalResponse())
     return nullptr;
 
-  DataBufferSP buffer_sp(
+  WritableDataBufferSP buffer_sp(
       new DataBufferHeap(response.GetStringRef().size() / 2, 0));
   response.GetHexBytes(buffer_sp->GetData(), '\xcc');
   return buffer_sp;
 }
 
 DataBufferSP GDBRemoteCommunicationClient::ReadAllRegisters(lldb::tid_t tid) {
   StreamString payload;
   payload.PutChar('g');
   StringExtractorGDBRemote response;
   if (SendThreadSpecificPacketAndWaitForResponse(
           tid, std::move(payload), response) != PacketResult::Success ||
       !response.IsNormalResponse())
     return nullptr;
 
-  DataBufferSP buffer_sp(
+  WritableDataBufferSP buffer_sp(
       new DataBufferHeap(response.GetStringRef().size() / 2, 0));
   response.GetHexBytes(buffer_sp->GetData(), '\xcc');
   return buffer_sp;
 }
 
 bool GDBRemoteCommunicationClient::WriteRegister(lldb::tid_t tid,
                                                  uint32_t reg_num,
                                                  llvm::ArrayRef<uint8_t> data) {

lldb/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.h

public:
   const RegisterSet *GetRegisterSet(size_t reg_set) override;
 
   bool ReadRegister(const RegisterInfo *reg_info,
                     RegisterValue &value) override;
 
   bool WriteRegister(const RegisterInfo *reg_info,
                      const 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;
 
   bool ReadAllRegisterValues(RegisterCheckpoint &reg_checkpoint) override;
 
   bool
   WriteAllRegisterValues(const RegisterCheckpoint &reg_checkpoint) override;
 

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

if (save_id != 0) {
 
     return gdb_comm.RestoreRegisterState(m_thread.GetProtocolID(), save_id);
   } else {
     return WriteAllRegisterValues(reg_checkpoint.GetData());
   }
 }
 
 bool GDBRemoteRegisterContext::ReadAllRegisterValues(
-    lldb::DataBufferSP &data_sp) {
+    lldb::WritableDataBufferSP &data_sp) {
   ExecutionContext exe_ctx(CalculateThread());
 
   Process *process = exe_ctx.GetProcessPtr();
   Thread *thread = exe_ctx.GetThreadPtr();
   if (process == nullptr || thread == nullptr)
     return false;
 
   GDBRemoteCommunicationClient &gdb_comm(
       ((ProcessGDBRemote *)process)->GetGDBRemote());
 
   const bool use_g_packet =
       !gdb_comm.AvoidGPackets((ProcessGDBRemote *)process);
 
   GDBRemoteClientBase::Lock lock(gdb_comm);
   if (lock) {
     if (gdb_comm.SyncThreadState(m_thread.GetProtocolID()))
       InvalidateAllRegisters();
 
-    if (use_g_packet &&
-        (data_sp = gdb_comm.ReadAllRegisters(m_thread.GetProtocolID())))
+    if (use_g_packet) {
+      if (DataBufferSP data_buffer =
+              gdb_comm.ReadAllRegisters(m_thread.GetProtocolID())) {
+        data_sp = std::make_shared<DataBufferHeap>(*data_buffer);
         return true;
+      }
+    }
 
     // We're going to read each register
     // individually and store them as binary data in a buffer.
     const RegisterInfo *reg_info;
 
     for (uint32_t i = 0; (reg_info = GetRegisterInfoAtIndex(i)) != nullptr;
          i++) {
       if (reg_info

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

if (thread_sp) {
 
       auto iter = std::find(m_thread_ids.begin(), m_thread_ids.end(), tid);
       if (iter != m_thread_ids.end()) {
         SetThreadPc(thread_sp, iter - m_thread_ids.begin());
       }
 
       for (const auto &pair : expedited_register_map) {
         StringExtractor reg_value_extractor(pair.second);
-        DataBufferSP buffer_sp(new DataBufferHeap(
+        WritableDataBufferSP buffer_sp(new DataBufferHeap(
             reg_value_extractor.GetStringRef().size() / 2, 0));
         reg_value_extractor.GetHexBytes(buffer_sp->GetData(), '\xcc');
         uint32_t lldb_regnum =
             gdb_reg_ctx_sp->ConvertRegisterKindToRegisterNumber(
                 eRegisterKindProcessPlugin, pair.first);
         gdb_thread->PrivateSetRegisterValue(lldb_regnum, buffer_sp->GetData());
       }
 
if (key == g_key_tid) {
                     "address", mem_cache_addr)) {
               if (mem_cache_addr != LLDB_INVALID_ADDRESS) {
                 llvm::StringRef str;
                 if (mem_cache_dict->GetValueForKeyAsString("bytes", str)) {
                   StringExtractor bytes(str);
                   bytes.SetFilePos(0);
 
                   const size_t byte_size = bytes.GetStringRef().size() / 2;
-                  DataBufferSP data_buffer_sp(new DataBufferHeap(byte_size, 0));
+                  WritableDataBufferSP data_buffer_sp(
+                      new DataBufferHeap(byte_size, 0));
                   const size_t bytes_copied =
                       bytes.GetHexBytes(data_buffer_sp->GetData(), 0);
                   if (bytes_copied == byte_size)
                     m_memory_cache.AddL1CacheData(mem_cache_addr,
                                                   data_buffer_sp);
                 }
               }
             }
while (stop_packet.GetNameColonValue(key, value)) {
         // values
         llvm::StringRef addr_str, bytes_str;
         std::tie(addr_str, bytes_str) = value.split('=');
         if (!addr_str.empty() && !bytes_str.empty()) {
           lldb::addr_t mem_cache_addr = LLDB_INVALID_ADDRESS;
           if (!addr_str.getAsInteger(0, mem_cache_addr)) {
             StringExtractor bytes(bytes_str);
             const size_t byte_size = bytes.GetBytesLeft() / 2;
-            DataBufferSP data_buffer_sp(new DataBufferHeap(byte_size, 0));
+            WritableDataBufferSP data_buffer_sp(
+                new DataBufferHeap(byte_size, 0));
             const size_t bytes_copied =
                 bytes.GetHexBytes(data_buffer_sp->GetData(), 0);
             if (bytes_copied == byte_size)
               m_memory_cache.AddL1CacheData(mem_cache_addr, data_buffer_sp);
           }
         }
       } else if (key.compare("watch") == 0 || key.compare("rwatch") == 0 ||
                  key.compare("awatch") == 0) {

lldb/source/Plugins/Process/minidump/RegisterContextMinidump_x86_32.cpp

 }
 
 lldb::DataBufferSP lldb_private::minidump::ConvertMinidumpContext_x86_32(
     llvm::ArrayRef<uint8_t> source_data,
     RegisterInfoInterface *target_reg_interface) {
 
   const RegisterInfo *reg_info = target_reg_interface->GetRegisterInfo();
 
-  lldb::DataBufferSP result_context_buf(
+  lldb::WritableDataBufferSP result_context_buf(
       new DataBufferHeap(target_reg_interface->GetGPRSize(), 0));
   uint8_t *result_base = result_context_buf->GetBytes();
 
   if (source_data.size() < sizeof(MinidumpContext_x86_32))
     return nullptr;
 
   const MinidumpContext_x86_32 *context;
   consumeObject(source_data, context);

lldb/source/Plugins/Process/minidump/RegisterContextMinidump_x86_64.cpp

 }
 
 lldb::DataBufferSP lldb_private::minidump::ConvertMinidumpContext_x86_64(
     llvm::ArrayRef<uint8_t> source_data,
     RegisterInfoInterface *target_reg_interface) {
 
   const RegisterInfo *reg_info = target_reg_interface->GetRegisterInfo();
 
-  lldb::DataBufferSP result_context_buf(
+  lldb::WritableDataBufferSP result_context_buf(
       new DataBufferHeap(target_reg_interface->GetGPRSize(), 0));
   uint8_t *result_base = result_context_buf->GetBytes();
 
   if (source_data.size() < sizeof(MinidumpContext_x86_64))
     return nullptr;
 
   const MinidumpContext_x86_64 *context;
   consumeObject(source_data, context);

lldb/source/Symbol/ObjectFile.cpp

 #include "lldb/lldb-private.h"
 
 #include "llvm/Support/DJB.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 char ObjectFile::ID;
+size_t ObjectFile::g_initial_bytes_to_read = 512;
 
 static ObjectFileSP
 CreateObjectFromContainer(const lldb::ModuleSP &module_sp, const FileSpec *file,
                           lldb::offset_t file_offset, lldb::offset_t file_size,
                           DataBufferSP &data_sp, lldb::offset_t &data_offset) {
   ObjectContainerCreateInstance callback;
   for (uint32_t idx = 0;
        (callback = PluginManager::GetObjectContainerCreateCallbackAtIndex(
if (file_exists && module_sp->GetObjectName()) {
       if (object_file_sp)
         return object_file_sp;
     }
     // Ok, we didn't find any containers that have a named object, now lets
     // read the first 512 bytes from the file so the object file and object
     // container plug-ins can use these bytes to see if they can parse this
     // file.
     if (file_size > 0) {
-      data_sp = FileSystem::Instance().CreateDataBuffer(file->GetPath(), 512,
-                                                        file_offset);
+      data_sp = FileSystem::Instance().CreateDataBuffer(
+          file->GetPath(), g_initial_bytes_to_read, file_offset);
       data_offset = 0;
     }
   }
 
   if (!data_sp || data_sp->GetByteSize() == 0) {
     // Check for archive file with format "/path/to/archive.a(object.o)"
     llvm::SmallString<256> path_with_object;
     module_sp->GetFileSpec().GetPath(path_with_object);
if (ObjectFile::SplitArchivePathWithObject(path_with_object, archive_file,
         // file).
         ObjectFileSP object_file_sp = CreateObjectFromContainer(
             module_sp, file, file_offset, file_size, data_sp, data_offset);
         if (object_file_sp)
           return object_file_sp;
         // We failed to find any cached object files in the container plug-
         // ins, so lets read the first 512 bytes and try again below...
         data_sp = FileSystem::Instance().CreateDataBuffer(
-            archive_file.GetPath(), 512, file_offset);
+            archive_file.GetPath(), g_initial_bytes_to_read, file_offset);
       }
     }
   }
 
   if (data_sp && data_sp->GetByteSize() > 0) {
     // Check if this is a normal object file by iterating through all
     // object file plugin instances.
     ObjectFileCreateInstance callback;

 }
 
 size_t ObjectFile::GetModuleSpecifications(const FileSpec &file,
                                            lldb::offset_t file_offset,
                                            lldb::offset_t file_size,
                                            ModuleSpecList &specs,
                                            DataBufferSP data_sp) {
   if (!data_sp)
-    data_sp = FileSystem::Instance().CreateDataBuffer(file.GetPath(), 512,
-                                                      file_offset);
+    data_sp = FileSystem::Instance().CreateDataBuffer(
+        file.GetPath(), g_initial_bytes_to_read, file_offset);
   if (data_sp) {
     if (file_size == 0) {
       const lldb::offset_t actual_file_size =
           FileSystem::Instance().GetByteSize(file);
       if (actual_file_size > file_offset)
         file_size = actual_file_size - file_offset;
     }
     return ObjectFile::GetModuleSpecifications(file,        // file spec

lldb/source/Target/Platform.cpp

lldb::user_id_t dest_file = OpenFile(
                        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));
+  lldb::WritableDataBufferSP buffer_sp(new DataBufferHeap(1024 * 16, 0));
   uint64_t offset = 0;
   for (;;) {
     size_t bytes_read = buffer_sp->GetByteSize();
     error = source_file.get()->Read(buffer_sp->GetBytes(), bytes_read);
     if (error.Fail() || bytes_read == 0)
       break;
 
     const uint64_t bytes_written =

lldb/source/Target/RegisterContextUnwind.cpp

bool RegisterContextUnwind::WriteRegister(const RegisterInfo *reg_info,
   if (!m_parent_unwind.SearchForSavedLocationForRegister(
           lldb_regnum, regloc, m_frame_number - 1, false))
     return false;
 
   return WriteRegisterValueToRegisterLocation(regloc, reg_info, value);
 }
 
 // Don't need to implement this one
-bool RegisterContextUnwind::ReadAllRegisterValues(lldb::DataBufferSP &data_sp) {
+bool RegisterContextUnwind::ReadAllRegisterValues(
+    lldb::WritableDataBufferSP &data_sp) {
   return false;
 }
 
 // Don't need to implement this one
 bool RegisterContextUnwind::WriteAllRegisterValues(
     const lldb::DataBufferSP &data_sp) {
   return false;
 }

lldb/source/Utility/DataBufferHeap.cpp

 }
 
 // Initialize this class with a copy of the "n" bytes from the "bytes" buffer.
 DataBufferHeap::DataBufferHeap(const void *src, lldb::offset_t src_len)
     : m_data() {
   CopyData(src, src_len);
 }
 
+DataBufferHeap::DataBufferHeap(const DataBuffer &data_buffer) : m_data() {
+  CopyData(data_buffer.GetBytes(), data_buffer.GetByteSize());
+}
+
 // Virtual destructor since this class inherits from a pure virtual base class.
 DataBufferHeap::~DataBufferHeap() = default;
 
-// Return a pointer to the bytes owned by this object, or nullptr if the object
-// contains no bytes.
-uint8_t *DataBufferHeap::GetBytes() {
-  return (m_data.empty() ? nullptr : m_data.data());
-}
-
 // Return a const pointer to the bytes owned by this object, or nullptr if the
 // object contains no bytes.
-const uint8_t *DataBufferHeap::GetBytes() const {
+const uint8_t *DataBufferHeap::GetBytesImpl() const {
   return (m_data.empty() ? nullptr : m_data.data());
 }
 
 // Return the number of bytes this object currently contains.
 uint64_t DataBufferHeap::GetByteSize() const { return m_data.size(); }
 
 // Sets the number of bytes that this object should be able to contain. This
 // can be used prior to copying data into the buffer.
void DataBufferHeap::AppendData(const void *src, uint64_t src_len) {
   m_data.insert(m_data.end(), static_cast<const uint8_t *>(src),
                 static_cast<const uint8_t *>(src) + src_len);
 }
 
 void DataBufferHeap::Clear() {
   buffer_t empty;
   m_data.swap(empty);
 }
+
+char DataBuffer::ID;
+char WritableDataBuffer::ID;
+char DataBufferUnowned::ID;
+char DataBufferHeap::ID;

lldb/source/Utility/DataBufferLLVM.cpp

 //===-- DataBufferLLVM.cpp ------------------------------------------------===//
 //
 // 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/Utility/DataBufferLLVM.h"
 
 #include "llvm/Support/MemoryBuffer.h"
 
 #include <cassert>
 
 using namespace lldb_private;
 
-DataBufferLLVM::DataBufferLLVM(
-    std::unique_ptr<llvm::WritableMemoryBuffer> MemBuffer)
+DataBufferLLVM::DataBufferLLVM(std::unique_ptr<llvm::MemoryBuffer> MemBuffer)
     : Buffer(std::move(MemBuffer)) {
   assert(Buffer != nullptr &&
          "Cannot construct a DataBufferLLVM with a null buffer");
 }
 
 DataBufferLLVM::~DataBufferLLVM() = default;
 
-uint8_t *DataBufferLLVM::GetBytes() {
-  return reinterpret_cast<uint8_t *>(Buffer->getBufferStart());
+const uint8_t *DataBufferLLVM::GetBytesImpl() const {
+  return reinterpret_cast<const uint8_t *>(Buffer->getBufferStart());
+}
+
+lldb::offset_t DataBufferLLVM::GetByteSize() const {
+  return Buffer->getBufferSize();
+}
+
+WritableDataBufferLLVM::WritableDataBufferLLVM(
+    std::unique_ptr<llvm::WritableMemoryBuffer> MemBuffer)
+    : Buffer(std::move(MemBuffer)) {
+  assert(Buffer != nullptr &&
+         "Cannot construct a WritableDataBufferLLVM with a null buffer");
 }
 
-const uint8_t *DataBufferLLVM::GetBytes() const {
+WritableDataBufferLLVM::~WritableDataBufferLLVM() = default;
+
+const uint8_t *WritableDataBufferLLVM::GetBytesImpl() const {
   return reinterpret_cast<const uint8_t *>(Buffer->getBufferStart());
 }
 
-lldb::offset_t DataBufferLLVM::GetByteSize() const {
+lldb::offset_t WritableDataBufferLLVM::GetByteSize() const {
   return Buffer->getBufferSize();
 }
+
+char DataBufferLLVM::ID;
+char WritableDataBufferLLVM::ID;

lldb/unittests/Utility/CMakeLists.txt

 add_lldb_unittest(UtilityTests
   AnsiTerminalTest.cpp
   ArgsTest.cpp
   OptionsWithRawTest.cpp
   ArchSpecTest.cpp
   BroadcasterTest.cpp
   ConstStringTest.cpp
   CompletionRequestTest.cpp
+  DataBufferTest.cpp
   DataEncoderTest.cpp
   DataExtractorTest.cpp
   EnvironmentTest.cpp
   EventTest.cpp
   FileSpecTest.cpp
   FlagsTest.cpp
   ListenerTest.cpp
   LogTest.cpp

lldb/unittests/Utility/DataBufferTest.cpp

+//===-- DataBufferTest.cpp ------------------------------------------------===//
+//
+// 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 "gtest/gtest.h"
+
+#include "lldb/Utility/DataBuffer.h"
+#include "lldb/Utility/DataBufferHeap.h"
+#include "lldb/Utility/DataBufferLLVM.h"
+
+#include "llvm/Support/Casting.h"
+#include "llvm/Support/MemoryBuffer.h"
+
+using namespace lldb_private;
+using namespace lldb;
+
+TEST(DataBufferTest, RTTI) {
+  {
+    DataBufferSP data_buffer_sp = std::make_shared<DataBufferHeap>();
+    DataBuffer *data_buffer = data_buffer_sp.get();
+
+    EXPECT_TRUE(llvm::isa<DataBuffer>(data_buffer));
+    EXPECT_TRUE(llvm::isa<WritableDataBuffer>(data_buffer));
+    EXPECT_TRUE(llvm::isa<DataBufferHeap>(data_buffer));
+    EXPECT_FALSE(llvm::isa<DataBufferLLVM>(data_buffer));
+  }
+
+  {
+    llvm::StringRef data;
+    DataBufferSP data_buffer_sp = std::make_shared<DataBufferLLVM>(
+        llvm::MemoryBuffer::getMemBufferCopy(data));
+    DataBuffer *data_buffer = data_buffer_sp.get();
+
+    EXPECT_TRUE(llvm::isa<DataBuffer>(data_buffer));
+    EXPECT_TRUE(llvm::isa<DataBufferLLVM>(data_buffer));
+    EXPECT_FALSE(llvm::isa<WritableDataBuffer>(data_buffer));
+    EXPECT_FALSE(llvm::isa<WritableDataBufferLLVM>(data_buffer));
+    EXPECT_FALSE(llvm::isa<DataBufferHeap>(data_buffer));
+  }
+
+  {
+    DataBufferSP data_buffer_sp = std::make_shared<WritableDataBufferLLVM>(
+        llvm::WritableMemoryBuffer::getNewMemBuffer(1));
+    DataBuffer *data_buffer = data_buffer_sp.get();
+
+    EXPECT_TRUE(llvm::isa<DataBuffer>(data_buffer));
+    EXPECT_TRUE(llvm::isa<WritableDataBuffer>(data_buffer));
+    EXPECT_TRUE(llvm::isa<WritableDataBufferLLVM>(data_buffer));
+    EXPECT_FALSE(llvm::isa<DataBufferLLVM>(data_buffer));
+    EXPECT_FALSE(llvm::isa<DataBufferHeap>(data_buffer));
+  }
+}