WIP: [lldb/FileSystem] Add & use CreateReadonlyDataBuffer where possible

[vsk]

Summary

Add FileSystem::CreateReadonlyDataBuffer to allow lldb to open files
using mmap() (i.e. without any heap allocation).

There's no functionality change intended here. We've been getting
reports of lldb using 2GB+ of heap memory while debugging Xcode [1], and
I think this should help with that.

This is WIP because ObjectFileELF::RelocateDebugSections mutates a buffer
obtained from ObjectFile. SymbolFile/DWARF/parallel-indexing-stress.s is the
only failing test, everything else passes with the current patch (on Darwin).

rdar://53785446

[1] heap report from two different users:

Count Bytes Avg Size Symbol
11404 2143015136 187917.8 (anonymous namespace)::MemoryBufferMem<llvm::WritableMemoryBuffer> C++ LLDB
11948 2537624624 212389.1 (anonymous namespace)::MemoryBufferMem<llvm::WritableMemoryBuffer> C++ LLDB

[vsk]

+ @labath @rupprecht, my tentative plan is to fix this by having ObjectFileELF make a copy into a heap-allocated buffer when applying relocations. Please lmk if that's problematic (although, that seems like a slightly lazier version of what we do today, so hopefully it's all right).

[labath]

Before you get too carried away with this, I'd like us to clarify something. Your comment seems to imply that FileSystem::CreateDataBuffer does not use mmap. That doesn't sound right, and it's not what I see happening on linux now (and I don't see why macos would be different):

$ strace -e trace=file,desc bin/lldb bin/lldb -o "image dump sections" -b
...
openat(AT_FDCWD, "bin/lldb", O_RDONLY|O_CLOEXEC) = 4
fstat(4, {st_mode=S_IFREG|0770, st_size=414096, ...}) = 0
mmap(NULL, 414096, PROT_READ|PROT_WRITE, MAP_PRIVATE, 4, 0) = 0x7f94160d7000

What this does is create a mapping, where unmodified pages are backed by the file on disk, and memory is allocated for any modified pages in the usual copy-on-write fashion. So, if you don't modify any pages -- you get no allocations.

It is true that FileSystem::CreateDataBuffer can sometimes use a heap allocation (malloc) to fulfill the request, but this has nothing to do with the writability of that buffer. What happens is that if we detect that the file we are about to read comes from a "remote" system (NFS, etc.), then we will fall back to malloc+read, because mmaps of volatile files are somewhat precarious.

For this reason, I am somewhat doubtful that this patch will solve the memory problems with memory usage, except maybe by playing some accounting tricks, where a read-only mapping would get reported in a different bucket than a read-write COW one. So, I gotta ask: How sure are you that this patch will solve the problems reported by your users? Is it possible that these two users have some kinds of remote mounts or something similar that could be throwing us off track?

Regardless of the answers to the questions above, I think that this patch, in principle, is a good idea, but I think we should encode the mutability of the DataBuffer in the type system. If we can ensure that CreateReadonlyDataBuffer returns a const DataBuffer, then we can have the compiler check for us that noone writes to these buffers, instead of us trying to guess.

As for ObjectFileELF, relocating the data inside RelocateDebugSections would basically reimplement what the COW mmap gives us for free. So, I think a simpler solution is to just make sure ObjectFileELF always creates a read-write mapping for the object file.

[vsk]

@labath thank you for your comments. I'm not yet sure what explains the average size of the WritableMemoryBuffer's allocated on our users' machines (~ 187,918 bytes, comfortably larger than the 16K threshold in shouldUseMmap). I'll need to figure this out before going any further.

I did expect openFileAux to always malloc() when constructing a WritableMemoryBuffer, forgetting that a MAP_PRIVATE mapping would also work. Generally, on Darwin (& probably elsewhere) we want to use MAP_PRIVATE mappings as much as possible, as these do not need to get written to swap space or stashed in the VM compressor.

lldb/include/lldb/Host/FileSystem.h

public:
   std::shared_ptr<DataBufferLLVM>
   CreateWritableDataBuffer(const llvm::Twine &path, uint64_t size = 0,
                            uint64_t offset = 0);
   std::shared_ptr<DataBufferLLVM>
   CreateWritableDataBuffer(const FileSpec &file_spec, uint64_t size = 0,
                            uint64_t offset = 0);
   /// \}
 
+  //// Read a file into a (possibly mmap()'d) read-only memory buffer.
+  /// \{
+  std::shared_ptr<DataBufferLLVM>
+  CreateReadonlyDataBuffer(const llvm::Twine &path, uint64_t size = 0,
+                           uint64_t offset = 0);
+  std::shared_ptr<DataBufferLLVM>
+  CreateReadonlyDataBuffer(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);
 
   enum EnumerateDirectoryResult {
     /// Enumerate next entry in the current directory.
     eEnumerateDirectoryResultNext,
     /// Recurse into the current entry if it is a directory or symlink, or next
     /// if not.
public:
   llvm::ErrorOr<std::string> GetExternalPath(const llvm::Twine &path);
   llvm::ErrorOr<std::string> GetExternalPath(const FileSpec &file_spec);
 
   llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> GetVirtualFileSystem() {
     return m_fs;
   }
 
 private:
+  enum class BufferKind {
+    Writable,
+    Readonly
+  };
+
+  std::shared_ptr<DataBufferLLVM> CreateDataBuffer(const llvm::Twine &path,
+                                                   uint64_t size,
+                                                   uint64_t offset,
+                                                   BufferKind kind);
+
   void AddFile(const llvm::Twine &file);
   static llvm::Optional<FileSystem> &InstanceImpl();
   llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> m_fs;
   std::shared_ptr<llvm::FileCollector> m_collector;
   bool m_mapped;
 };
 } // namespace lldb_private
 
 #endif

lldb/include/lldb/Utility/DataBufferLLVM.h

 
 #include "lldb/Utility/DataBuffer.h"
 #include "lldb/lldb-types.h"
 
 #include <memory>
 #include <stdint.h>
 
 namespace llvm {
-class WritableMemoryBuffer;
+class MemoryBuffer;
 class Twine;
 }
 
 namespace lldb_private {
 
 class FileSystem;
 class DataBufferLLVM : public DataBuffer {
 public:
   ~DataBufferLLVM() override;
 
+  // WARNING: If this is backed by a read-only buffer, using the non-const
+  // GetBytes overload is dangerous. Use the const overload instead.
   uint8_t *GetBytes() override;
+
   const uint8_t *GetBytes() const override;
   lldb::offset_t GetByteSize() const override;
 
+  // WARNING: If this is backed by a read-only buffer, using the non-const
+  // GetBytes overload is dangerous. Use the const GetBytes overload instead.
   char *GetChars() { return reinterpret_cast<char *>(GetBytes()); }
 
 private:
   friend FileSystem;
   /// Construct a DataBufferLLVM from \p Buffer.  \p Buffer must be a valid
   /// pointer.
-  explicit DataBufferLLVM(std::unique_ptr<llvm::WritableMemoryBuffer> Buffer);
+  explicit DataBufferLLVM(std::unique_ptr<llvm::MemoryBuffer> Buffer);
 
-  std::unique_ptr<llvm::WritableMemoryBuffer> Buffer;
+  std::unique_ptr<llvm::MemoryBuffer> Buffer;
 };
 }
 
 #endif

lldb/source/API/SBSection.cpp

if (sect_file_size > 0) {
           uint64_t file_size = size;
           if (file_size == UINT64_MAX) {
             file_size = section_sp->GetByteSize();
             if (file_size > offset)
               file_size -= offset;
             else
               file_size = 0;
           }
-          auto data_buffer_sp = FileSystem::Instance().CreateWritableDataBuffer(
+          auto data_buffer_sp = FileSystem::Instance().CreateReadonlyDataBuffer(
               objfile->GetFileSpec().GetPath(), file_size, file_offset);
           if (data_buffer_sp && data_buffer_sp->GetByteSize() > 0) {
             DataExtractorSP data_extractor_sp(
                 new DataExtractor(data_buffer_sp, objfile->GetByteOrder(),
                                   objfile->GetAddressByteSize()));
 
             sb_data.SetOpaque(data_extractor_sp);
           }

lldb/source/Commands/CommandObjectMemory.cpp

if (addr == LLDB_INVALID_ADDRESS) {
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     if (m_memory_options.m_infile) {
       size_t length = SIZE_MAX;
       if (item_byte_size > 1)
         length = item_byte_size;
-      auto data_sp = FileSystem::Instance().CreateWritableDataBuffer(
+      auto data_sp = FileSystem::Instance().CreateReadonlyDataBuffer(
           m_memory_options.m_infile.GetPath(), length,
           m_memory_options.m_infile_offset);
       if (data_sp) {
         length = data_sp->GetByteSize();
         if (length > 0) {
           Status error;
           size_t bytes_written =
               process->WriteMemory(addr, data_sp->GetBytes(), length, error);

lldb/source/Core/SourceManager.cpp

if (target) {
           m_file_spec = new_file_spec;
           m_mod_time = FileSystem::Instance().GetModificationTime(m_file_spec);
         }
       }
     }
   }
 
   if (m_mod_time != llvm::sys::TimePoint<>())
-    m_data_sp = FileSystem::Instance().CreateWritableDataBuffer(m_file_spec);
+    m_data_sp = FileSystem::Instance().CreateReadonlyDataBuffer(m_file_spec);
 }
 
 uint32_t SourceManager::File::GetLineOffset(uint32_t line) {
   if (line == 0)
     return UINT32_MAX;
 
   if (line == 1)
     return 0;
void SourceManager::File::UpdateIfNeeded() {
   // TODO: use host API to sign up for file modifications to anything in our
   // source cache and only update when we determine a file has been updated.
   // For now we check each time we want to display info for the file.
   auto curr_mod_time = FileSystem::Instance().GetModificationTime(m_file_spec);
 
   if (curr_mod_time != llvm::sys::TimePoint<>() &&
       m_mod_time != curr_mod_time) {
     m_mod_time = curr_mod_time;
-    m_data_sp = FileSystem::Instance().CreateWritableDataBuffer(m_file_spec);
+    m_data_sp = FileSystem::Instance().CreateReadonlyDataBuffer(m_file_spec);
     m_offsets.clear();
   }
 }
 
 size_t SourceManager::File::DisplaySourceLines(uint32_t line,
                                                llvm::Optional<size_t> column,
                                                uint32_t context_before,
                                                uint32_t context_after,

lldb/source/Host/common/FileSystem.cpp

void FileSystem::Resolve(FileSpec &file_spec) {
   if (file_spec.GetFilename().IsEmpty())
     file_spec.GetDirectory().SetString(path);
   else
     file_spec.SetPath(path);
   file_spec.SetIsResolved(true);
 }
 
 std::shared_ptr<DataBufferLLVM>
-FileSystem::CreateWritableDataBuffer(const llvm::Twine &path, uint64_t size,
-                                     uint64_t offset) {
+FileSystem::CreateDataBuffer(const llvm::Twine &path, uint64_t size,
+                             uint64_t offset, BufferKind kind) {
   AddFile(path);
 
   const bool is_volatile = !IsLocal(path);
   const ErrorOr<std::string> external_path = GetExternalPath(path);
+  const bool requires_null_terminator = false;
 
   if (!external_path)
     return nullptr;
 
-  std::unique_ptr<llvm::WritableMemoryBuffer> buffer;
+  std::unique_ptr<llvm::MemoryBuffer> buffer;
+  if (kind == BufferKind::Writable) {
     if (size == 0) {
       auto buffer_or_error =
           llvm::WritableMemoryBuffer::getFile(*external_path, -1, is_volatile);
       if (!buffer_or_error)
         return nullptr;
       buffer = std::move(*buffer_or_error);
     } else {
       auto buffer_or_error = llvm::WritableMemoryBuffer::getFileSlice(
           *external_path, size, offset, is_volatile);
       if (!buffer_or_error)
         return nullptr;
       buffer = std::move(*buffer_or_error);
     }
+  }
+  if (kind == BufferKind::Readonly) {
+    if (size == 0) {
+      auto buffer_or_error = llvm::MemoryBuffer::getFile(
+          *external_path, -1, requires_null_terminator, is_volatile);
+      if (!buffer_or_error)
+        return nullptr;
+      buffer = std::move(*buffer_or_error);
+    } else {
+      auto buffer_or_error = llvm::MemoryBuffer::getFileSlice(
+          *external_path, size, offset, is_volatile);
+      if (!buffer_or_error)
+        return nullptr;
+      buffer = std::move(*buffer_or_error);
+    }
+  }
   return std::shared_ptr<DataBufferLLVM>(new DataBufferLLVM(std::move(buffer)));
 }
 
 std::shared_ptr<DataBufferLLVM>
+FileSystem::CreateWritableDataBuffer(const llvm::Twine &path, uint64_t size,
+                                     uint64_t offset) {
+  return CreateDataBuffer(path, size, offset, BufferKind::Writable);
+}
+
+std::shared_ptr<DataBufferLLVM>
 FileSystem::CreateWritableDataBuffer(const FileSpec &file_spec, uint64_t size,
                                      uint64_t offset) {
-  return CreateWritableDataBuffer(file_spec.GetPath(), size, offset);
+  return CreateDataBuffer(file_spec.GetPath(), size, offset,
+                          BufferKind::Writable);
+}
+
+std::shared_ptr<DataBufferLLVM>
+FileSystem::CreateReadonlyDataBuffer(const llvm::Twine &path, uint64_t size,
+                                     uint64_t offset) {
+  return CreateDataBuffer(path, size, offset, BufferKind::Readonly);
+}
+
+std::shared_ptr<DataBufferLLVM>
+FileSystem::CreateReadonlyDataBuffer(const FileSpec &file_spec, uint64_t size,
+                                     uint64_t offset) {
+  return CreateDataBuffer(file_spec.GetPath(), size, offset,
+                          BufferKind::Readonly);
 }
 
 bool FileSystem::ResolveExecutableLocation(FileSpec &file_spec) {
   // If the directory is set there's nothing to do.
   ConstString directory = file_spec.GetDirectory();
   if (directory)
     return false;
 

lldb/source/Host/linux/Host.cpp

static bool IsDirNumeric(const char *dname) {
   }
   return true;
 }
 
 static ArchSpec GetELFProcessCPUType(llvm::StringRef exe_path) {
   Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
 
   auto buffer_sp =
-      FileSystem::Instance().CreateWritableDataBuffer(exe_path, 0x20, 0);
+      FileSystem::Instance().CreateReadonlyDataBuffer(exe_path, 0x20, 0);
   if (!buffer_sp)
     return ArchSpec();
 
   uint8_t exe_class =
       llvm::object::getElfArchType(
           {buffer_sp->GetChars(), size_t(buffer_sp->GetByteSize())})
           .first;
 

lldb/source/Host/netbsd/Host.cpp

static bool GetNetBSDProcessArgs(const ProcessInstanceInfoMatch *match_info_ptr,
 
   return true;
 }
 
 static bool GetNetBSDProcessCPUType(ProcessInstanceInfo &process_info) {
   Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
 
   if (process_info.ProcessIDIsValid()) {
-    auto buffer_sp = FileSystem::Instance().CreateWritableDataBuffer(
+    auto buffer_sp = FileSystem::Instance().CreateReadonlyDataBuffer(
         process_info.GetExecutableFile(), 0x20, 0);
     if (buffer_sp) {
       uint8_t exe_class =
           llvm::object::getElfArchType(
               {buffer_sp->GetChars(), size_t(buffer_sp->GetByteSize())})
               .first;
 
       switch (exe_class) {

lldb/source/Interpreter/OptionValueFileSpec.cpp

CommandCompletions::InvokeCommonCompletionCallbacks(
       interpreter, m_completion_mask, request, nullptr);
 }
 
 const lldb::DataBufferSP &OptionValueFileSpec::GetFileContents() {
   if (m_current_value) {
     const auto file_mod_time = FileSystem::Instance().GetModificationTime(m_current_value);
     if (m_data_sp && m_data_mod_time == file_mod_time)
       return m_data_sp;
+    // FIXME: Does this need to be a writable buffer?
     m_data_sp = FileSystem::Instance().CreateWritableDataBuffer(
         m_current_value.GetPath());
     m_data_mod_time = file_mod_time;
   }
   return m_data_sp;
 }

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

bool RenderScriptRuntime::LoadAllocation(Stream &strm, const uint32_t alloc_id,
   if (!FileSystem::Instance().Readable(file)) {
     strm.Printf("Error: File %s does not have readable permissions", path);
     strm.EOL();
     return false;
   }
 
   // Read file into data buffer
   auto data_sp =
-      FileSystem::Instance().CreateWritableDataBuffer(file.GetPath());
+      FileSystem::Instance().CreateReadonlyDataBuffer(file.GetPath());
 
   // Cast start of buffer to FileHeader and use pointer to read metadata
   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();
bool RSModuleDescriptor::ParseRSInfo() {
   const addr_t addr = info_sym->GetAddressRef().GetFileAddress();
   if (addr == LLDB_INVALID_ADDRESS)
     return false;
 
   const addr_t size = info_sym->GetByteSize();
   const FileSpec fs = m_module->GetFileSpec();
 
   auto buffer =
-      FileSystem::Instance().CreateWritableDataBuffer(fs.GetPath(), size, addr);
+      FileSystem::Instance().CreateReadonlyDataBuffer(fs.GetPath(), size, addr);
   if (!buffer)
     return false;
 
   // split rs.info. contents into lines
   llvm::SmallVector<llvm::StringRef, 128> info_lines;
   {
     const llvm::StringRef raw_rs_info((const char *)buffer->GetBytes());
     raw_rs_info.split(info_lines, '\n');

lldb/source/Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.cpp

if (file && data_sp && ObjectContainerBSDArchive::MagicBytesMatch(data)) {
           module_sp->GetFileSpec().GetPath().c_str(),
           static_cast<const void *>(file), static_cast<uint64_t>(file_offset),
           static_cast<uint64_t>(length));
 
       // Map the entire .a file to be sure that we don't lose any data if the
       // file gets updated by a new build while this .a file is being used for
       // debugging
       DataBufferSP archive_data_sp =
-          FileSystem::Instance().CreateWritableDataBuffer(*file, length,
+          FileSystem::Instance().CreateReadonlyDataBuffer(*file, length,
                                                           file_offset);
       if (!archive_data_sp)
         return nullptr;
 
       lldb::offset_t archive_data_offset = 0;
 
       Archive::shared_ptr archive_sp(Archive::FindCachedArchive(
           *file, module_sp->GetArchitecture(), module_sp->GetModificationTime(),
size_t ObjectContainerBSDArchive::GetModuleSpecifications(
 
   const size_t initial_count = specs.GetSize();
   llvm::sys::TimePoint<> file_mod_time = FileSystem::Instance().GetModificationTime(file);
   Archive::shared_ptr archive_sp(
       Archive::FindCachedArchive(file, ArchSpec(), file_mod_time, file_offset));
   bool set_archive_arch = false;
   if (!archive_sp) {
     set_archive_arch = true;
-    data_sp = FileSystem::Instance().CreateWritableDataBuffer(file, file_size,
+    data_sp = FileSystem::Instance().CreateReadonlyDataBuffer(file, file_size,
                                                               file_offset);
     if (data_sp) {
       data.SetData(data_sp, 0, data_sp->GetByteSize());
       archive_sp = Archive::ParseAndCacheArchiveForFile(
           file, ArchSpec(), file_mod_time, file_offset, data);
     }
   }
 

lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

if (m_developer_directory.empty()) {
 
     if (!developer_dir_path_valid) {
       std::string xcode_dir_path;
       const char *xcode_select_prefix_dir = getenv("XCODE_SELECT_PREFIX_DIR");
       if (xcode_select_prefix_dir)
         xcode_dir_path.append(xcode_select_prefix_dir);
       xcode_dir_path.append("/usr/share/xcode-select/xcode_dir_path");
       temp_file_spec.SetFile(xcode_dir_path, FileSpec::Style::native);
-      auto dir_buffer = FileSystem::Instance().CreateWritableDataBuffer(
+      auto dir_buffer = FileSystem::Instance().CreateReadonlyDataBuffer(
           temp_file_spec.GetPath());
       if (dir_buffer && dir_buffer->GetByteSize() > 0) {
         llvm::StringRef path_ref(dir_buffer->GetChars());
         // Trim tailing newlines and make sure there is enough room for a null
         // terminator.
         path_ref =
             path_ref.rtrim("\r\n").take_front(sizeof(developer_dir_path) - 1);
         ::memcpy(developer_dir_path, path_ref.data(), path_ref.size());

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

lldb::ProcessSP ProcessElfCore::CreateInstance(lldb::TargetSP target_sp,
                                                const FileSpec *crash_file) {
   lldb::ProcessSP process_sp;
   if (crash_file) {
     // Read enough data for a ELF32 header or ELF64 header Note: Here we care
     // about e_type field only, so it is safe to ignore possible presence of
     // the header extension.
     const size_t header_size = sizeof(llvm::ELF::Elf64_Ehdr);
 
-    auto data_sp = FileSystem::Instance().CreateWritableDataBuffer(
+    auto data_sp = FileSystem::Instance().CreateReadonlyDataBuffer(
         crash_file->GetPath(), header_size, 0);
     if (data_sp && data_sp->GetByteSize() == header_size &&
         elf::ELFHeader::MagicBytesMatch(data_sp->GetBytes())) {
       elf::ELFHeader elf_header;
       DataExtractor data(data_sp, lldb::eByteOrderLittle, 4);
       lldb::offset_t data_offset = 0;
       if (elf_header.Parse(data, &data_offset)) {
         if (elf_header.e_type == llvm::ELF::ET_CORE)

lldb/source/Plugins/Process/mach-core/ProcessMachCore.cpp

 }
 
 lldb::ProcessSP ProcessMachCore::CreateInstance(lldb::TargetSP target_sp,
                                                 ListenerSP listener_sp,
                                                 const FileSpec *crash_file) {
   lldb::ProcessSP process_sp;
   if (crash_file) {
     const size_t header_size = sizeof(llvm::MachO::mach_header);
-    auto data_sp = FileSystem::Instance().CreateWritableDataBuffer(
+    auto data_sp = FileSystem::Instance().CreateReadonlyDataBuffer(
         crash_file->GetPath(), header_size, 0);
     if (data_sp && data_sp->GetByteSize() == header_size) {
       DataExtractor data(data_sp, lldb::eByteOrderLittle, 4);
 
       lldb::offset_t data_offset = 0;
       llvm::MachO::mach_header mach_header;
       if (ObjectFileMachO::ParseHeader(data, &data_offset, mach_header)) {
         if (mach_header.filetype == llvm::MachO::MH_CORE)

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

lldb::ProcessSP ProcessMinidump::CreateInstance(lldb::TargetSP target_sp,
                                                 lldb::ListenerSP listener_sp,
                                                 const FileSpec *crash_file) {
   if (!crash_file)
     return nullptr;
 
   lldb::ProcessSP process_sp;
   // Read enough data for the Minidump header
   constexpr size_t header_size = sizeof(Header);
-  auto DataPtr = FileSystem::Instance().CreateWritableDataBuffer(
+  auto DataPtr = FileSystem::Instance().CreateReadonlyDataBuffer(
       crash_file->GetPath(), header_size, 0);
   if (!DataPtr)
     return nullptr;
 
   lldbassert(DataPtr->GetByteSize() == header_size);
   if (identify_magic(toStringRef(DataPtr->GetData())) != llvm::file_magic::minidump)
     return nullptr;
 
-  auto AllData = FileSystem::Instance().CreateWritableDataBuffer(
+  auto AllData = FileSystem::Instance().CreateReadonlyDataBuffer(
       crash_file->GetPath(), -1, 0);
   if (!AllData)
     return nullptr;
 
   return std::make_shared<ProcessMinidump>(target_sp, listener_sp, *crash_file,
                                            std::move(AllData));
 }
 

lldb/source/Symbol/ObjectFile.cpp

if (file) {
               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().CreateWritableDataBuffer(
+          data_sp = FileSystem::Instance().CreateReadonlyDataBuffer(
               file->GetPath(), 512, 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;
if (file) {
               if (object_container_up)
                 object_file_sp = object_container_up->GetObjectFile(file);
 
               if (object_file_sp.get())
                 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().CreateWritableDataBuffer(
+            data_sp = FileSystem::Instance().CreateReadonlyDataBuffer(
                 archive_file.GetPath(), 512, 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.
ObjectFileSP ObjectFile::FindPlugin(const lldb::ModuleSP &module_sp,
   object_file_sp.reset();
   return object_file_sp;
 }
 
 size_t ObjectFile::GetModuleSpecifications(const FileSpec &file,
                                            lldb::offset_t file_offset,
                                            lldb::offset_t file_size,
                                            ModuleSpecList &specs) {
-  DataBufferSP data_sp = FileSystem::Instance().CreateWritableDataBuffer(
+  DataBufferSP data_sp = FileSystem::Instance().CreateReadonlyDataBuffer(
       file.GetPath(), 512, 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;
     }

 }
 
 void ObjectFile::RelocateSection(lldb_private::Section *section)
 {
 }
 
 DataBufferSP ObjectFile::MapFileData(const FileSpec &file, uint64_t Size,
                                      uint64_t Offset) {
-  return FileSystem::Instance().CreateWritableDataBuffer(file.GetPath(), Size,
+  return FileSystem::Instance().CreateReadonlyDataBuffer(file.GetPath(), Size,
                                                          Offset);
 }
 
 void llvm::format_provider<ObjectFile::Type>::format(
     const ObjectFile::Type &type, raw_ostream &OS, StringRef Style) {
   switch (type) {
   case ObjectFile::eTypeInvalid:
     OS << "invalid";

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 <assert.h>
 
 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() {}
 
 uint8_t *DataBufferLLVM::GetBytes() {
-  return reinterpret_cast<uint8_t *>(Buffer->getBufferStart());
+  return const_cast<uint8_t *>(
+      reinterpret_cast<const uint8_t *>(Buffer->getBufferStart()));
 }
 
 const uint8_t *DataBufferLLVM::GetBytes() const {
   return reinterpret_cast<const uint8_t *>(Buffer->getBufferStart());
 }
 
 lldb::offset_t DataBufferLLVM::GetByteSize() const {
   return Buffer->getBufferSize();
 }

lldb/unittests/Process/minidump/MinidumpParserTest.cpp

 
 class MinidumpParserTest : public testing::Test {
 public:
   SubsystemRAII<FileSystem> subsystems;
 
   void SetUpData(const char *minidump_filename) {
     std::string filename = GetInputFilePath(minidump_filename);
     auto BufferPtr =
-        FileSystem::Instance().CreateWritableDataBuffer(filename, -1, 0);
+        FileSystem::Instance().CreateReadonlyDataBuffer(filename, -1, 0);
     ASSERT_NE(BufferPtr, nullptr);
     llvm::Expected<MinidumpParser> expected_parser =
         MinidumpParser::Create(BufferPtr);
     ASSERT_THAT_EXPECTED(expected_parser, llvm::Succeeded());
     parser = std::move(*expected_parser);
     ASSERT_GT(parser->GetData().size(), 0UL);
   }