Extract construction of DataBufferLLVM into FileSystem

[JDevlieghere]

Summary

This moves construction of data buffers into the FileSystem class. Like some of the previous refactorings we don't translate the path yet because the functionality hasn't been landed in LLVM yet.

[labath]

Looks fine to me, I'd just ask you to consider shortening the method names a bit.

include/lldb/Host/FileSystem.h

119–122

Can we streamline these names? I don't think the FromPath part brings anything here when the method is on the filesystem class, as it's completely natural and expected for those methods to take paths. Maybe just CreateDataBuffer or ToDataBuffer

include/lldb/Host/FileSystem.h

 //===-- FileSystem.h --------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_Host_FileSystem_h
 #define liblldb_Host_FileSystem_h
 
 #include "lldb/Host/File.h"
+#include "lldb/Utility/DataBufferLLVM.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Status.h"
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/Chrono.h"
 #include "llvm/Support/VirtualFileSystem.h"
 
 #include "lldb/lldb-types.h"
public:
   /// @}
 
   /// Returns whether the given path is a directory.
   /// @{
   bool IsDirectory(const FileSpec &file_spec) const;
   bool IsDirectory(const llvm::Twine &path) const;
   /// @}
 
+  /// Returns whether the given path is local to the file system.
+  /// @{
+  bool IsLocal(const FileSpec &file_spec) const;
+  bool IsLocal(const llvm::Twine &path) const;
+  /// @}
+
   /// Make the given file path absolute.
   /// @{
   std::error_code MakeAbsolute(llvm::SmallVectorImpl<char> &path) const;
   std::error_code MakeAbsolute(FileSpec &file_spec) const;
   /// @}
 
   /// Resolve path to make it canonical.
   /// @{
   void Resolve(llvm::SmallVectorImpl<char> &path);
   void Resolve(FileSpec &file_spec);
   /// @}
 
+  //// Create memory buffer from path.
+  /// @{
+  std::shared_ptr<DataBufferLLVM>
+  CreateDataBufferFromPath(const llvm::Twine &path, uint64_t size = 0,
+                           uint64_t offset = 0);
+  std::shared_ptr<DataBufferLLVM>
+  CreateDataBufferFromPath(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.

include/lldb/Utility/DataBufferLLVM.h

 
 namespace llvm {
 class WritableMemoryBuffer;
 class Twine;
 }
 
 namespace lldb_private {
 
+class FileSystem;
 class DataBufferLLVM : public DataBuffer {
 public:
   ~DataBufferLLVM();
 
-  static std::shared_ptr<DataBufferLLVM>
-  CreateSliceFromPath(const llvm::Twine &Path, uint64_t Size, uint64_t Offset);
-
-  static std::shared_ptr<DataBufferLLVM>
-  CreateFromPath(const llvm::Twine &Path);
-
   uint8_t *GetBytes() override;
   const uint8_t *GetBytes() const override;
   lldb::offset_t GetByteSize() const override;
 
   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);
 
   std::unique_ptr<llvm::WritableMemoryBuffer> Buffer;
 };
 }
 
 #endif

source/API/SBSection.cpp

 //===-- SBSection.cpp -------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBSection.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBTarget.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/DataBuffer.h"
-#include "lldb/Utility/DataBufferLLVM.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBSection::SBSection() : m_opaque_wp() {}
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 = DataBufferLLVM::CreateSliceFromPath(
+          auto data_buffer_sp = FileSystem::Instance().CreateDataBufferFromPath(
               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);
           }

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 = DataBufferLLVM::CreateSliceFromPath(
+      auto data_sp = FileSystem::Instance().CreateDataBufferFromPath(
           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);

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 = DataBufferLLVM::CreateFromPath(m_file_spec.GetPath());
+    m_data_sp = FileSystem::Instance().CreateDataBufferFromPath(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 = DataBufferLLVM::CreateFromPath(m_file_spec.GetPath());
+    m_data_sp = FileSystem::Instance().CreateDataBufferFromPath(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,

source/Host/common/FileSystem.cpp

if (!status)
     return false;
   return status->isDirectory();
 }
 
 bool FileSystem::IsDirectory(const FileSpec &file_spec) const {
   return IsDirectory(file_spec.GetPath());
 }
 
+bool FileSystem::IsLocal(const Twine &path) const {
+  bool b;
+  m_fs->isLocal(path, b);
+  return b;
+}
+
+bool FileSystem::IsLocal(const FileSpec &file_spec) const {
+  return IsLocal(file_spec.GetPath());
+}
+
 void FileSystem::EnumerateDirectory(Twine path, bool find_directories,
                                     bool find_files, bool find_other,
                                     EnumerateDirectoryCallbackType callback,
                                     void *callback_baton) {
   std::error_code EC;
   vfs::recursive_directory_iterator Iter(*m_fs, path, EC);
   vfs::recursive_directory_iterator End;
   for (; Iter != End && !EC; Iter.increment(EC)) {
void FileSystem::Resolve(FileSpec &file_spec) {
   // Resolve the path.
   Resolve(path);
 
   // Update the FileSpec with the resolved path.
   file_spec.SetPath(path);
   file_spec.SetIsResolved(true);
 }
 
+std::shared_ptr<DataBufferLLVM>
+FileSystem::CreateDataBufferFromPath(const llvm::Twine &path, uint64_t size,
+                                     uint64_t offset) {
+  const bool is_volatile = !IsLocal(path);
+
+  std::unique_ptr<llvm::WritableMemoryBuffer> buffer;
+  if (size == 0) {
+    auto buffer_or_error =
+        llvm::WritableMemoryBuffer::getFile(path, -1, 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);
+    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::CreateDataBufferFromPath(const FileSpec &file_spec, uint64_t size,
+                                     uint64_t offset) {
+  return CreateDataBufferFromPath(file_spec.GetPath(), size, offset);
+}
+
 bool FileSystem::ResolveExecutableLocation(FileSpec &file_spec) {
   // If the directory is set there's nothing to do.
   const ConstString &directory = file_spec.GetDirectory();
   if (directory)
     return false;
 
   // We cannot look for a file if there's no file name.
   const ConstString &filename = file_spec.GetFilename();

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 =
-                DataBufferLLVM::CreateFromPath(output_file_spec.GetPath());
+            auto Buffer = FileSystem::Instance().CreateDataBufferFromPath(
+                output_file_spec);
             if (error.Success())
               command_output_ptr->assign(Buffer->GetChars(),
                                          Buffer->GetByteSize());
           }
         }
       }
     }
   }

source/Host/linux/Host.cpp

 // Project includes
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Status.h"
 
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/linux/Support.h"
-#include "lldb/Utility/DataBufferLLVM.h"
 #include "lldb/Utility/DataExtractor.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 namespace {
 enum class ProcessState {
   Unknown,
if (!isdigit(*dname))
       return false;
   }
   return true;
 }
 
 static ArchSpec GetELFProcessCPUType(llvm::StringRef exe_path) {
   Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
 
-  auto buffer_sp = DataBufferLLVM::CreateSliceFromPath(exe_path, 0x20, 0);
+  auto buffer_sp =
+      FileSystem::Instance().CreateDataBufferFromPath(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;
 

source/Interpreter/OptionValueFileSpec.cpp

 //===-- OptionValueFileSpec.cpp ---------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Interpreter/OptionValueFileSpec.h"
 
 #include "lldb/DataFormatters/FormatManager.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Interpreter/CommandCompletions.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Utility/Args.h"
-#include "lldb/Utility/DataBufferLLVM.h"
 #include "lldb/Utility/State.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 OptionValueFileSpec::OptionValueFileSpec(bool resolve)
     : OptionValue(), m_current_value(), m_default_value(), m_data_sp(),
       m_data_mod_time(),
size_t OptionValueFileSpec::AutoComplete(CommandInterpreter &interpreter,
   return request.GetNumberOfMatches();
 }
 
 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;
-    m_data_sp = DataBufferLLVM::CreateFromPath(m_current_value.GetPath());
+    m_data_sp = FileSystem::Instance().CreateDataBufferFromPath(
+        m_current_value.GetPath());
     m_data_mod_time = file_mod_time;
   }
   return m_data_sp;
 }

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

 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/ConstString.h"
-#include "lldb/Utility/DataBufferLLVM.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/Status.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_renderscript;
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 = DataBufferLLVM::CreateFromPath(file.GetPath());
+  auto data_sp =
+      FileSystem::Instance().CreateDataBufferFromPath(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 = DataBufferLLVM::CreateSliceFromPath(fs.GetPath(), size, addr);
+  auto buffer =
+      FileSystem::Instance().CreateDataBufferFromPath(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');

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

 #endif
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/ArchSpec.h"
-#include "lldb/Utility/DataBufferLLVM.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/Timer.h"
 
 #include "llvm/Support/MemoryBuffer.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
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 =
-          DataBufferLLVM::CreateSliceFromPath(file->GetPath(), length, file_offset);
+          FileSystem::Instance().CreateDataBufferFromPath(*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(),
           file_offset));
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 =
-        DataBufferLLVM::CreateSliceFromPath(file.GetPath(), file_size, file_offset);
+    data_sp = FileSystem::Instance().CreateDataBufferFromPath(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);
     }
   }
 
   if (archive_sp) {

source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

 #include "lldb/Host/XML.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
-#include "lldb/Utility/DataBufferLLVM.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Timer.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Threading.h"
 #include "llvm/Support/VersionTuple.h"
 
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 =
-          DataBufferLLVM::CreateFromPath(temp_file_spec.GetPath());
+      auto dir_buffer = FileSystem::Instance().CreateDataBufferFromPath(
+          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());
         developer_dir_path[path_ref.size()] = '\0';

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

 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/UnixSignals.h"
 #include "lldb/Utility/DataBufferHeap.h"
-#include "lldb/Utility/DataBufferLLVM.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/State.h"
 
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/Support/Threading.h"
 
 #include "Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.h"
 #include "Plugins/ObjectFile/ELF/ObjectFileELF.h"
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 = DataBufferLLVM::CreateSliceFromPath(crash_file->GetPath(),
-                                                       header_size, 0);
+    auto data_sp = FileSystem::Instance().CreateDataBufferFromPath(
+        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)
           process_sp.reset(

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

 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBuffer.h"
-#include "lldb/Utility/DataBufferLLVM.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/State.h"
 
 // Project includes
 #include "ProcessMachCore.h"
 #include "Plugins/Process/Utility/StopInfoMachException.h"
 #include "ThreadMachCore.h"
 

 }
 
 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 =
-        DataBufferLLVM::CreateSliceFromPath(crash_file->GetPath(), header_size, 0);
+    auto data_sp = FileSystem::Instance().CreateDataBufferFromPath(
+        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)
           process_sp.reset(

source/Plugins/Process/minidump/ProcessMinidump.cpp

 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Target/JITLoaderList.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/UnixSignals.h"
-#include "lldb/Utility/DataBufferLLVM.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/State.h"
 
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Threading.h"
 
 #include "Plugins/Process/Utility/StopInfoMachException.h"
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(MinidumpHeader);
-  auto DataPtr =
-      DataBufferLLVM::CreateSliceFromPath(crash_file->GetPath(), header_size, 0);
+  auto DataPtr = FileSystem::Instance().CreateDataBufferFromPath(
+      crash_file->GetPath(), header_size, 0);
   if (!DataPtr)
     return nullptr;
 
   lldbassert(DataPtr->GetByteSize() == header_size);
 
   // first, only try to parse the header, beacuse we need to be fast
   llvm::ArrayRef<uint8_t> HeaderBytes = DataPtr->GetData();
   const MinidumpHeader *header = MinidumpHeader::Parse(HeaderBytes);
   if (header == nullptr)
     return nullptr;
 
-  auto AllData = DataBufferLLVM::CreateSliceFromPath(crash_file->GetPath(), -1, 0);
+  auto AllData = FileSystem::Instance().CreateDataBufferFromPath(
+      crash_file->GetPath(), -1, 0);
   if (!AllData)
     return nullptr;
 
   auto minidump_parser = MinidumpParser::Create(AllData);
   // check if the parser object is valid
   if (!minidump_parser)
     return nullptr;
 

source/Symbol/ObjectFile.cpp

 #include "lldb/Core/Section.h"
 #include "lldb/Symbol/ObjectContainer.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBuffer.h"
 #include "lldb/Utility/DataBufferHeap.h"
-#include "lldb/Utility/DataBufferLLVM.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/Timer.h"
 #include "lldb/lldb-private.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
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 =
-              DataBufferLLVM::CreateSliceFromPath(file->GetPath(), 512, file_offset);
+          data_sp = FileSystem::Instance().CreateDataBufferFromPath(
+              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)"
         char path_with_object[PATH_MAX * 2];
         module_sp->GetFileSpec().GetPath(path_with_object,
if (file) {
               if (object_container_ap.get())
                 object_file_sp = object_container_ap->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 = DataBufferLLVM::CreateSliceFromPath(archive_file.GetPath(),
-                                                     512, file_offset);
+            data_sp = FileSystem::Instance().CreateDataBufferFromPath(
+                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.
         ObjectFileCreateInstance create_object_file_callback;
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 = DataBufferLLVM::CreateSliceFromPath(file.GetPath(), 512, file_offset);
+  DataBufferSP data_sp = FileSystem::Instance().CreateDataBufferFromPath(
+      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;
     }
     return ObjectFile::GetModuleSpecifications(file,        // file spec

 }
 
 void ObjectFile::RelocateSection(lldb_private::Section *section)
 {
 }
 
 DataBufferSP ObjectFile::MapFileData(const FileSpec &file, uint64_t Size,
                                      uint64_t Offset) {
-  return DataBufferLLVM::CreateSliceFromPath(file.GetPath(), Size, Offset);
+  return FileSystem::Instance().CreateDataBufferFromPath(file.GetPath(), Size,
+                                                         Offset);
 }

source/Utility/DataBufferLLVM.cpp

DataBufferLLVM::DataBufferLLVM(
     std::unique_ptr<llvm::WritableMemoryBuffer> MemBuffer)
     : Buffer(std::move(MemBuffer)) {
   assert(Buffer != nullptr &&
          "Cannot construct a DataBufferLLVM with a null buffer");
 }
 
 DataBufferLLVM::~DataBufferLLVM() {}
 
-std::shared_ptr<DataBufferLLVM>
-DataBufferLLVM::CreateSliceFromPath(const llvm::Twine &Path, uint64_t Size,
-                                    uint64_t Offset) {
-  // If the file resides non-locally, pass the volatile flag so that we don't
-  // mmap it.
-  bool IsVolatile = !llvm::sys::fs::is_local(Path);
-
-  auto Buffer =
-      llvm::WritableMemoryBuffer::getFileSlice(Path, Size, Offset, IsVolatile);
-  if (!Buffer)
-    return nullptr;
-  return std::shared_ptr<DataBufferLLVM>(
-      new DataBufferLLVM(std::move(*Buffer)));
-}
-
-std::shared_ptr<DataBufferLLVM>
-DataBufferLLVM::CreateFromPath(const llvm::Twine &Path) {
-  // If the file resides non-locally, pass the volatile flag so that we don't
-  // mmap it.
-  bool IsVolatile = !llvm::sys::fs::is_local(Path);
-
-  auto Buffer = llvm::WritableMemoryBuffer::getFile(Path, -1, IsVolatile);
-  if (!Buffer)
-    return nullptr;
-  return std::shared_ptr<DataBufferLLVM>(
-      new DataBufferLLVM(std::move(*Buffer)));
-}
-
 uint8_t *DataBufferLLVM::GetBytes() {
   return reinterpret_cast<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();
 }

unittests/Process/minidump/MinidumpParserTest.cpp

 #include "Plugins/Process/minidump/MinidumpParser.h"
 #include "Plugins/Process/minidump/MinidumpTypes.h"
 #include "Plugins/Process/minidump/RegisterContextMinidump_x86_32.h"
 #include "Plugins/Process/minidump/RegisterContextMinidump_x86_64.h"
 
 #include "TestingSupport/TestUtilities.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Utility/ArchSpec.h"
-#include "lldb/Utility/DataBufferLLVM.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/FileSpec.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "gtest/gtest.h"
 
 // C includes
 
 // C++ includes
 #include <memory>
 
 using namespace lldb_private;
 using namespace minidump;
 
 class MinidumpParserTest : public testing::Test {
 public:
   void SetUpData(const char *minidump_filename) {
     std::string filename = GetInputFilePath(minidump_filename);
-    auto BufferPtr = DataBufferLLVM::CreateSliceFromPath(filename, -1, 0);
+    auto BufferPtr =
+        FileSystem::Instance().CreateDataBufferFromPath(filename, -1, 0);
     ASSERT_NE(BufferPtr, nullptr);
     llvm::Optional<MinidumpParser> optional_parser =
         MinidumpParser::Create(BufferPtr);
     ASSERT_TRUE(optional_parser.hasValue());
     parser.reset(new MinidumpParser(optional_parser.getValue()));
     ASSERT_GT(parser->GetData().size(), 0UL);
     auto result = parser->Initialize();
     ASSERT_TRUE(result.Success()) << result.AsCString();
   }
 
   void InvalidMinidump(const char *minidump_filename, uint64_t load_size) {
     std::string filename = GetInputFilePath(minidump_filename);
     auto BufferPtr =
-        DataBufferLLVM::CreateSliceFromPath(filename, load_size, 0);
+        FileSystem::Instance().CreateDataBufferFromPath(filename, load_size, 0);
     ASSERT_NE(BufferPtr, nullptr);
 
     llvm::Optional<MinidumpParser> optional_parser =
         MinidumpParser::Create(BufferPtr);
     ASSERT_TRUE(optional_parser.hasValue());
     parser.reset(new MinidumpParser(optional_parser.getValue()));
     ASSERT_GT(parser->GetData().size(), 0UL);
     auto result = parser->Initialize();