[lldb/FileSystem] Rename CreateDataBuffer -> CreateWritableDataBuffer, NFC

[vsk]

Summary

Some clients of lldb::FileSystem look like they are unintentionally
heap-allocating file contents.

This patch renames the CreateDataBuffer API to allow clients to express
intention more clearly. As a follow-up I propose adding a 'Readonly' API
that can use mmap().

rdar://53785446

[JDevlieghere]

LGTM

lldb/include/lldb/Host/FileSystem.h

public:
   /// \}
 
   /// Resolve path to make it canonical.
   /// \{
   void Resolve(llvm::SmallVectorImpl<char> &path);
   void Resolve(FileSpec &file_spec);
   /// \}
 
-  //// Create memory buffer from path.
+  //// Read a file into a heap-allocated, writable memory buffer.
   /// \{
-  std::shared_ptr<DataBufferLLVM> CreateDataBuffer(const llvm::Twine &path,
-                                                   uint64_t size = 0,
-                                                   uint64_t offset = 0);
-  std::shared_ptr<DataBufferLLVM> CreateDataBuffer(const FileSpec &file_spec,
-                                                   uint64_t size = 0,
-                                                   uint64_t offset = 0);
+  std::shared_ptr<DataBufferLLVM>
+  CreateWritableDataBuffer(const llvm::Twine &path, uint64_t size = 0,
+  std::shared_ptr<DataBufferLLVM>
+  CreateWritableDataBuffer(const FileSpec &file_spec, uint64_t size = 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,

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().CreateDataBuffer(
+          auto data_buffer_sp = FileSystem::Instance().CreateWritableDataBuffer(
               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().CreateDataBuffer(
+      auto data_sp = FileSystem::Instance().CreateWritableDataBuffer(
           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().CreateDataBuffer(m_file_spec);
+    m_data_sp = FileSystem::Instance().CreateWritableDataBuffer(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().CreateDataBuffer(m_file_spec);
+    m_data_sp = FileSystem::Instance().CreateWritableDataBuffer(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::CreateDataBuffer(const llvm::Twine &path, uint64_t size,
+FileSystem::CreateWritableDataBuffer(const llvm::Twine &path, uint64_t size,
                                      uint64_t offset) {
   AddFile(path);
 
   const bool is_volatile = !IsLocal(path);
   const ErrorOr<std::string> external_path = GetExternalPath(path);
 
   if (!external_path)
     return nullptr;
 
if (size == 0) {
     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::CreateDataBuffer(const FileSpec &file_spec, uint64_t size,
+FileSystem::CreateWritableDataBuffer(const FileSpec &file_spec, uint64_t size,
                                      uint64_t offset) {
-  return CreateDataBuffer(file_spec.GetPath(), size, offset);
+  return CreateWritableDataBuffer(file_spec.GetPath(), size, offset);
 }
 
 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/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);
+            auto Buffer = FileSystem::Instance().CreateWritableDataBuffer(
+                output_file_spec);
             if (error.Success())
               command_output_ptr->assign(Buffer->GetChars(),
                                          Buffer->GetByteSize());
           }
         }
       }
     }
   }

lldb/source/Host/linux/Host.cpp

if (!isdigit(*dname))
       return false;
   }
   return true;
 }
 
 static ArchSpec GetELFProcessCPUType(llvm::StringRef exe_path) {
   Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
 
-  auto buffer_sp = FileSystem::Instance().CreateDataBuffer(exe_path, 0x20, 0);
+  auto buffer_sp =
+      FileSystem::Instance().CreateWritableDataBuffer(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().CreateDataBuffer(
+    auto buffer_sp = FileSystem::Instance().CreateWritableDataBuffer(
         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;
-    m_data_sp =
-        FileSystem::Instance().CreateDataBuffer(m_current_value.GetPath());
+    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().CreateDataBuffer(file.GetPath());
+  auto data_sp =
+      FileSystem::Instance().CreateWritableDataBuffer(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().CreateDataBuffer(fs.GetPath(), size, addr);
+      FileSystem::Instance().CreateWritableDataBuffer(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().CreateDataBuffer(*file, length, file_offset);
+          FileSystem::Instance().CreateWritableDataBuffer(*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 =
-        FileSystem::Instance().CreateDataBuffer(file, file_size, file_offset);
+    data_sp = FileSystem::Instance().CreateWritableDataBuffer(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) {

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().CreateDataBuffer(temp_file_spec.GetPath());
+      auto dir_buffer = FileSystem::Instance().CreateWritableDataBuffer(
+          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';

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().CreateDataBuffer(
+    auto data_sp = FileSystem::Instance().CreateWritableDataBuffer(
         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().CreateDataBuffer(
+    auto data_sp = FileSystem::Instance().CreateWritableDataBuffer(
         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().CreateDataBuffer(crash_file->GetPath(),
-                                                         header_size, 0);
+  auto DataPtr = FileSystem::Instance().CreateWritableDataBuffer(
+      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().CreateDataBuffer(crash_file->GetPath(), -1, 0);
+  auto AllData = FileSystem::Instance().CreateWritableDataBuffer(
+      crash_file->GetPath(), -1, 0);
   if (!AllData)
     return nullptr;
 
   return std::make_shared<ProcessMinidump>(target_sp, listener_sp, *crash_file,
                                            std::move(AllData));
 }
 
 bool ProcessMinidump::CanDebug(lldb::TargetSP target_sp,

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().CreateDataBuffer(file->GetPath(),
-                                                            512, file_offset);
+          data_sp = FileSystem::Instance().CreateWritableDataBuffer(
+              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;
         module_sp->GetFileSpec().GetPath(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().CreateDataBuffer(
+            data_sp = FileSystem::Instance().CreateWritableDataBuffer(
                 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().CreateDataBuffer(file.GetPath(), 512, file_offset);
+  DataBufferSP data_sp = FileSystem::Instance().CreateWritableDataBuffer(
+      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 FileSystem::Instance().CreateDataBuffer(file.GetPath(), Size, Offset);
+  return FileSystem::Instance().CreateWritableDataBuffer(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";
     break;

lldb/unittests/Process/minidump/MinidumpParserTest.cpp

 using namespace minidump;
 
 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().CreateDataBuffer(filename, -1, 0);
+    auto BufferPtr =
+        FileSystem::Instance().CreateWritableDataBuffer(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);
   }