[lldb/Module] Allow for the creation of memory-only modules

[friss]

Summary

This patch extends the ModuleSpec class to include a
DataBufferSP which contains the module data. If this
data is provided, LLDB won't try to hit the filesystem
to create the Module, but use only the data stored in
the ModuleSpec.

[friss]

This is the generic part of https://reviews.llvm.org/D83023

I modified to existing unittests to load their binary directly from memory, one ELF, one Mach-O. I tried to modify a PECOFF test to, but ObjectFilePECoff requires the file to be on the filesystem as it reopens it to create an LLVM PECoff object. I'm not sure about the testing strategy here. Should this just be a dedicated test instead, and remove the ugly InMemory thing that this patch adds to TestFile?

[labath]

I like this.

The coff thingy is unfortunate, but it's not a hard limitation. It's just that nobody cared about making this work from memory (until now), and (re)loading the file from disk was the easiest solution. If my d372a8e8 sticks, then I think we should be able to load coff files from memory too. I would like if all tests loaded the files from memory, because it makes the code simpler, but maybe that does not need to be done here -- that can definitely be handled separately.

As for the testing strategy, I think that some dedicated tests would be nice in any case, if for nothing else, then for testing some of the edge cases (opening a corrupted data buffer, opening a buffer when a file with the given name exists on disk, etc.).

lldb/include/lldb/Core/ModuleSpec.h

40

I guess this GetByteSize call should also not fire if data is not set. In fact I'm not sure it should fire at all. I think at one point I tried to remove this and didn't get any failures on linux. If mac is the same then maybe we could delete it unconditionally.

55

You missed the copy constructor. I think both of these could be = default, or just omitted completely.

[friss]

I went ahead and updated all unittests to use only in-memory modules.
This required tweaking both ObjectFileELF and ObjectFilePECOFF a little.

[friss]

lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

543–544 ↗

(On Diff #277657)

This seems to work in the test, but I have to admit that I'm not 100% sure it's correct given the comment below about wanting to write this buffer.

565 ↗

(On Diff #277657)

I'm not sure why m_file was tested here, but this doesn't work with a pure in-memory file.

[labath]

lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

543–544 ↗

(On Diff #277657)

I think this is fine. I can't find anything wanting to write to this data. Maybe that was the case once but perhaps that code was removed now.

lldb/unittests/Core/ModuleSpecTest.cpp

27 ↗

(On Diff #277657)

this is cool

30 ↗

(On Diff #277657)

s/anythign/anything

57 ↗

(On Diff #277657)

Maybe reduce these down? I'm not sure about others, but and elf file with a single .text section and no symbols should still perfectly valid.

lldb/unittests/TestingSupport/TestUtilities.h

42–44

Since we don't need to do cleanup anymore, we can make Buffer a regular std::string and rely on the compiler-generated move and copy operations. In fact, we may not even need the TestFile class at all as the yaml functions could return a ModuleSpec directly.

60–63

you'll need to add Buffer(std::move(Buffer)) for the && to do anything.

[friss]

lldb/unittests/TestingSupport/TestUtilities.h

42–44

I kept the TestFile class for now, as it owns the file memory buffer. I could change the tests to to a DataBufferHeap which would copy the memory, but be able to live on its own. Tell me if you feel strongly about this.

lldb/include/lldb/Core/Module.h

 //===-- Module.h ------------------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_CORE_MODULE_H
 #define LLDB_CORE_MODULE_H
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContextScope.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Target/PathMappingList.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/ConstString.h"
protected:
   FileSpec m_symfile_spec;   ///< If this path is valid, then this is the file
                              ///that _will_ be used as the symbol file for this
                              ///module
   ConstString m_object_name; ///< The name an object within this module that is
                              ///selected, or empty of the module is represented
                              ///by \a m_file.
   uint64_t m_object_offset;
   llvm::sys::TimePoint<> m_object_mod_time;
+
+  /// DataBuffer containing the module image, if it was provided at
+  /// construction time. Otherwise the data will be retrieved by mapping
+  /// one of the FileSpec members above.
+  lldb::DataBufferSP m_data_sp;
+
   lldb::ObjectFileSP m_objfile_sp; ///< A shared pointer to the object file
                                    ///parser for this module as it may or may
                                    ///not be shared with the SymbolFile
   llvm::Optional<UnwindTable> m_unwind_table; ///< Table of FuncUnwinders
                                               /// objects created for this
                                               /// Module's functions
   lldb::SymbolVendorUP
       m_symfile_up; ///< A pointer to the symbol vendor for this module.

lldb/include/lldb/Core/ModuleSpec.h

 //===-- ModuleSpec.h --------------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_CORE_MODULESPEC_H
 #define LLDB_CORE_MODULESPEC_H
 
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Target/PathMappingList.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/UUID.h"
 
 #include "llvm/Support/Chrono.h"
 
 #include <mutex>
 #include <vector>
 
 namespace lldb_private {
 
 class ModuleSpec {
 public:
   ModuleSpec()
       : m_file(), m_platform_file(), m_symbol_file(), m_arch(), m_uuid(),
         m_object_name(), m_object_offset(0), m_object_size(0),
         m_source_mappings() {}
 
-  ModuleSpec(const FileSpec &file_spec, const UUID &uuid = UUID())
+  /// If the \param data argument is passed, its contents will be used
+  /// as the module contents instead of trying to read them from
+  /// \param file_spec.
+  ModuleSpec(const FileSpec &file_spec, const UUID &uuid = UUID(),
+             lldb::DataBufferSP data = lldb::DataBufferSP())
       : m_file(file_spec), m_platform_file(), m_symbol_file(), m_arch(),
         m_uuid(uuid), m_object_name(), m_object_offset(0),
         m_object_size(FileSystem::Instance().GetByteSize(file_spec)),
-        m_source_mappings() {}
+        m_source_mappings(), m_data(data) {}
 
   ModuleSpec(const FileSpec &file_spec, const ArchSpec &arch)
       : m_file(file_spec), m_platform_file(), m_symbol_file(), m_arch(arch),
         m_uuid(), m_object_name(), m_object_offset(0),
         m_object_size(FileSystem::Instance().GetByteSize(file_spec)),
         m_source_mappings() {}
 
   ModuleSpec(const ModuleSpec &rhs)
       : m_file(rhs.m_file), m_platform_file(rhs.m_platform_file),
         m_symbol_file(rhs.m_symbol_file), m_arch(rhs.m_arch),
         m_uuid(rhs.m_uuid), m_object_name(rhs.m_object_name),
         m_object_offset(rhs.m_object_offset), m_object_size(rhs.m_object_size),
         m_object_mod_time(rhs.m_object_mod_time),
         m_source_mappings(rhs.m_source_mappings) {}
 
   ModuleSpec &operator=(const ModuleSpec &rhs) {
     if (this != &rhs) {
       m_file = rhs.m_file;
       m_platform_file = rhs.m_platform_file;
       m_symbol_file = rhs.m_symbol_file;
       m_arch = rhs.m_arch;
       m_uuid = rhs.m_uuid;
       m_object_name = rhs.m_object_name;
       m_object_offset = rhs.m_object_offset;
       m_object_size = rhs.m_object_size;
       m_object_mod_time = rhs.m_object_mod_time;
       m_source_mappings = rhs.m_source_mappings;
+      m_data = rhs.m_data;
     }
     return *this;
   }
 
   FileSpec *GetFileSpecPtr() { return (m_file ? &m_file : nullptr); }
 
   const FileSpec *GetFileSpecPtr() const {
     return (m_file ? &m_file : nullptr);
public:
   }
 
   const llvm::sys::TimePoint<> &GetObjectModificationTime() const {
     return m_object_mod_time;
   }
 
   PathMappingList &GetSourceMappingList() const { return m_source_mappings; }
 
+  lldb::DataBufferSP GetData() const { return m_data; }
+
   void Clear() {
     m_file.Clear();
     m_platform_file.Clear();
     m_symbol_file.Clear();
     m_arch.Clear();
     m_uuid.Clear();
     m_object_name.Clear();
     m_object_offset = 0;
protected:
   FileSpec m_symbol_file;
   ArchSpec m_arch;
   UUID m_uuid;
   ConstString m_object_name;
   uint64_t m_object_offset;
   uint64_t m_object_size;
   llvm::sys::TimePoint<> m_object_mod_time;
   mutable PathMappingList m_source_mappings;
+  lldb::DataBufferSP m_data = {};
 };
 
 class ModuleSpecList {
 public:
   ModuleSpecList() : m_specs(), m_mutex() {}
 
   ModuleSpecList(const ModuleSpecList &rhs) : m_specs(), m_mutex() {
     std::lock_guard<std::recursive_mutex> lhs_guard(m_mutex);

lldb/include/lldb/Symbol/ObjectFile.h

 //===-- ObjectFile.h --------------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SYMBOL_OBJECTFILE_H
 #define LLDB_SYMBOL_OBJECTFILE_H
 
 #include "lldb/Core/FileSpecList.h"
 #include "lldb/Core/ModuleChild.h"
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Symbol/Symtab.h"
 #include "lldb/Symbol/UnwindTable.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/UUID.h"
public:
   ///
   /// \param[in] header_addr
   ///     The address of the header for the object file in memory.
   static lldb::ObjectFileSP FindPlugin(const lldb::ModuleSP &module_sp,
                                        const lldb::ProcessSP &process_sp,
                                        lldb::addr_t header_addr,
                                        lldb::DataBufferSP &file_data_sp);
 
-  static size_t GetModuleSpecifications(const FileSpec &file,
-                                        lldb::offset_t file_offset,
-                                        lldb::offset_t file_size,
-                                        ModuleSpecList &specs);
+  static size_t
+  GetModuleSpecifications(const FileSpec &file, lldb::offset_t file_offset,
+                          lldb::offset_t file_size, ModuleSpecList &specs,
+                          lldb::DataBufferSP data_sp = lldb::DataBufferSP());
 
   static size_t GetModuleSpecifications(const lldb_private::FileSpec &file,
                                         lldb::DataBufferSP &data_sp,
                                         lldb::offset_t data_offset,
                                         lldb::offset_t file_offset,
                                         lldb::offset_t file_size,
                                         lldb_private::ModuleSpecList &specs);
   /// Split a path into a file path with object name.

lldb/include/lldb/Utility/DataBuffer.h

 //===-- DataBuffer.h --------------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_UTILITY_DATABUFFER_H
 #define LLDB_UTILITY_DATABUFFER_H
 #if defined(__cplusplus)
 
 #include <stdint.h>
 #include <string.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.
 ///
llvm::ArrayRef<uint8_t> GetData() const {
     return llvm::ArrayRef<uint8_t>(GetBytes(), GetByteSize());
   }
 
   llvm::MutableArrayRef<uint8_t> GetData() {
     return llvm::MutableArrayRef<uint8_t>(GetBytes(), GetByteSize());
   }
 };
 
+class DataBufferUnowned : public DataBuffer {
+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; }
+  lldb::offset_t GetByteSize() const override { return m_size; }
+
+private:
+  uint8_t *m_bytes;
+  lldb::offset_t m_size;
+};
+
 } // namespace lldb_private
 
 #endif /// #if defined(__cplusplus)
 #endif // LLDB_UTILITY_DATABUFFER_H

lldb/source/Core/Module.cpp

 //===-- Module.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/Core/Module.h"
 
 #include "lldb/Core/AddressRange.h"
 #include "lldb/Core/AddressResolverFileLine.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/FileSpecList.h"
 #include "lldb/Core/Mangled.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/SearchFilter.h"
LLDB_LOGF(log, "%p Module::Module((%s) '%s%s%s%s')",
               module_spec.GetArchitecture().GetArchitectureName(),
               module_spec.GetFileSpec().GetPath().c_str(),
               module_spec.GetObjectName().IsEmpty() ? "" : "(",
               module_spec.GetObjectName().IsEmpty()
                   ? ""
                   : module_spec.GetObjectName().AsCString(""),
               module_spec.GetObjectName().IsEmpty() ? "" : ")");
 
+  auto data_sp = module_spec.GetData();
+
   // First extract all module specifications from the file using the local file
   // path. If there are no specifications, then don't fill anything in
   ModuleSpecList modules_specs;
   if (ObjectFile::GetModuleSpecifications(module_spec.GetFileSpec(), 0, 0,
-                                          modules_specs) == 0)
+                                          modules_specs, data_sp) == 0)
     return;
 
   // Now make sure that one of the module specifications matches what we just
   // extract. We might have a module specification that specifies a file
   // "/usr/lib/dyld" with UUID XXX, but we might have a local version of
   // "/usr/lib/dyld" that has
   // UUID YYY and we don't want those to match. If they don't match, just don't
   // fill any ivars in so we don't accidentally grab the wrong file later since
   // they don't match...
   ModuleSpec matching_module_spec;
   if (!modules_specs.FindMatchingModuleSpec(module_spec,
                                             matching_module_spec)) {
     if (log) {
       LLDB_LOGF(log, "Found local object file but the specs didn't match");
     }
     return;
   }
 
+  // Set m_data_sp if it was initially provided in the ModuleSpec. Note that
+  // we cannot use the data_sp variable here, because it will have been
+  // modified by GetModuleSpecifications().
+  if (auto module_spec_data_sp = module_spec.GetData()) {
+    m_data_sp = module_spec_data_sp;
+    m_mod_time = {};
+  } else {
     if (module_spec.GetFileSpec())
-    m_mod_time = FileSystem::Instance().GetModificationTime(module_spec.GetFileSpec());
-  else if (matching_module_spec.GetFileSpec())
       m_mod_time =
-        FileSystem::Instance().GetModificationTime(matching_module_spec.GetFileSpec());
+          FileSystem::Instance().GetModificationTime(module_spec.GetFileSpec());
+    else if (matching_module_spec.GetFileSpec())
+      m_mod_time = FileSystem::Instance().GetModificationTime(
+          matching_module_spec.GetFileSpec());
+  }
 
   // Copy the architecture from the actual spec if we got one back, else use
   // the one that was specified
   if (matching_module_spec.GetArchitecture().IsValid())
     m_arch = matching_module_spec.GetArchitecture();
   else if (module_spec.GetArchitecture().IsValid())
     m_arch = module_spec.GetArchitecture();
 
if (format_len > 0) {
       if (last_char != '\n' && last_char != '\r')
         strm.EOL();
     }
     Host::SystemLog(Host::eSystemLogError, "%s", strm.GetData());
   }
 }
 
 bool Module::FileHasChanged() const {
+  // We have provided the DataBuffer for this module to avoid accessing the
+  // filesystem. We never want to reload those files.
+  if (m_data_sp)
+    return false;
   if (!m_file_has_changed)
     m_file_has_changed =
         (FileSystem::Instance().GetModificationTime(m_file) != m_mod_time);
   return m_file_has_changed;
 }
 
 void Module::ReportErrorIfModifyDetected(const char *format, ...) {
   if (!m_first_file_changed_log) {

 
 ObjectFile *Module::GetObjectFile() {
   if (!m_did_load_objfile.load()) {
     std::lock_guard<std::recursive_mutex> guard(m_mutex);
     if (!m_did_load_objfile.load()) {
       static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
       Timer scoped_timer(func_cat, "Module::GetObjectFile () module = %s",
                          GetFileSpec().GetFilename().AsCString(""));
-      DataBufferSP data_sp;
       lldb::offset_t data_offset = 0;
-      const lldb::offset_t file_size =
-          FileSystem::Instance().GetByteSize(m_file);
+      lldb::offset_t file_size;
+
+      if (m_data_sp)
+        file_size = m_data_sp->GetByteSize();
+      else
+        file_size = FileSystem::Instance().GetByteSize(m_file);
+
       if (file_size > m_object_offset) {
         m_did_load_objfile = true;
+        // FindPlugin will modify its data_sp argument. Do not let it
+        // modify our m_data_sp member.
+        auto data_sp = m_data_sp;
         m_objfile_sp = ObjectFile::FindPlugin(
             shared_from_this(), &m_file, m_object_offset,
             file_size - m_object_offset, data_sp, data_offset);
         if (m_objfile_sp) {
           // Once we get the object file, update our module with the object
           // file's architecture since it might differ in vendor/os if some
           // parts were unknown.  But since the matching arch might already be
           // more specific than the generic COFF architecture, only merge in

lldb/source/Symbol/ObjectFile.cpp

 //===-- ObjectFile.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/Symbol/ObjectFile.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Symbol/CallFrameInfo.h"
 #include "lldb/Symbol/ObjectContainer.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Target/Process.h"
ObjectFileSP ObjectFile::FindPlugin(const lldb::ModuleSP &module_sp,
   // anything and return an empty shared pointer
   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);
+                                           ModuleSpecList &specs,
+                                           DataBufferSP data_sp) {
+  if (!data_sp)
+    data_sp = FileSystem::Instance().CreateDataBuffer(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

lldb/unittests/ObjectFile/ELF/TestObjectFileELF.cpp

 //===-- TestObjectFileELF.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 "Plugins/ObjectFile/ELF/ObjectFileELF.h"
 #include "Plugins/SymbolFile/Symtab/SymbolFileSymtab.h"
 #include "TestingSupport/SubsystemRAII.h"
 #include "TestingSupport/TestUtilities.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
- Name:            _start
     Binding:         STB_GLOBAL
   - Name:            X
     Type:            STT_OBJECT
     Section:         .bss
     Value:           0x0000000000601004
     Size:            0x0000000000000004
     Binding:         STB_GLOBAL
 ...
-)");
+)",
+                                         true);
   ASSERT_THAT_EXPECTED(ExpectedFile, llvm::Succeeded());
 
-  ModuleSpec spec{FileSpec(ExpectedFile->name())};
-  spec.GetSymbolFileSpec().SetFile(ExpectedFile->name(),
-                                   FileSpec::Style::native);
+  ModuleSpec spec{FileSpec("<from memory>"), UUID(),
+                  ExpectedFile->dataBuffer()};
+  //  spec.GetSymbolFileSpec() = spec;
   auto module_sp = std::make_shared<Module>(spec);
   SectionList *list = module_sp->GetSectionList();
   ASSERT_NE(nullptr, list);
 
   auto bss_sp = list->FindSectionByName(ConstString(".bss"));
   ASSERT_NE(nullptr, bss_sp);
   auto data_sp = list->FindSectionByName(ConstString(".data"));
   ASSERT_NE(nullptr, data_sp);

lldb/unittests/Symbol/TestLineEntry.cpp

 //===-- TestLineEntry.cpp -------------------------------------------------===//
 //
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "gtest/gtest.h"
 #include <iostream>
 
 #include "Plugins/ObjectFile/Mach-O/ObjectFileMachO.h"
 #include "Plugins/SymbolFile/DWARF/DWARFASTParserClang.h"
 #include "Plugins/SymbolFile/DWARF/SymbolFileDWARF.h"
 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
 #include "TestingSupport/SubsystemRAII.h"
 #include "TestingSupport/TestUtilities.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Host/FileSystem.h"

 
 protected:
   llvm::Expected<LineEntry> GetLineEntryForLine(uint32_t line);
   llvm::Optional<TestFile> m_file;
   ModuleSP m_module_sp;
 };
 
 void LineEntryTest::SetUp() {
-  auto ExpectedFile = TestFile::fromYamlFile("inlined-functions.yaml");
+  auto ExpectedFile = TestFile::fromYamlFile("inlined-functions.yaml", true);
   ASSERT_THAT_EXPECTED(ExpectedFile, llvm::Succeeded());
   m_file.emplace(std::move(*ExpectedFile));
-  m_module_sp = std::make_shared<Module>(ModuleSpec(FileSpec(m_file->name())));
+  m_module_sp = std::make_shared<Module>(
+      ModuleSpec(FileSpec("<from memory>"), UUID(), m_file->dataBuffer()));
 }
 
 llvm::Expected<LineEntry> LineEntryTest::GetLineEntryForLine(uint32_t line) {
   bool check_inlines = true;
   bool exact = true;
   SymbolContextList sc_comp_units;
   SymbolContextList sc_line_entries;
   FileSpec file_spec("inlined-functions.cpp");

lldb/unittests/TestingSupport/TestUtilities.h

 //===- TestUtilities.h ------------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_UNITTESTS_TESTINGSUPPORT_TESTUTILITIES_H
 #define LLDB_UNITTESTS_TESTINGSUPPORT_TESTUTILITIES_H
 
+#include "lldb/Utility/DataBuffer.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FileUtilities.h"
 #include <string>
 
 #define ASSERT_NO_ERROR(x)                                                     \
   if (std::error_code ASSERT_NO_ERROR_ec = x) {                                \
     llvm::SmallString<128> MessageStorage;                                     \
     llvm::raw_svector_ostream Message(MessageStorage);                         \
     Message << #x ": did not return errc::success.\n"                          \
             << "error number: " << ASSERT_NO_ERROR_ec.value() << "\n"          \
             << "error message: " << ASSERT_NO_ERROR_ec.message() << "\n";      \
     GTEST_FATAL_FAILURE_(MessageStorage.c_str());                              \
   } else {                                                                     \
   }
 
 namespace lldb_private {
 std::string GetInputFilePath(const llvm::Twine &name);
 
 class TestFile {
 public:
-  static llvm::Expected<TestFile> fromYaml(llvm::StringRef Yaml);
-  static llvm::Expected<TestFile> fromYamlFile(const llvm::Twine &Name);
+  static llvm::Expected<TestFile> fromYaml(llvm::StringRef Yaml,
+                                           bool InMemory = false);
+  static llvm::Expected<TestFile> fromYamlFile(const llvm::Twine &Name,
+                                               bool InMemory = false);
 
-  TestFile(TestFile &&RHS) : Name(std::move(RHS.Name)) {
+  TestFile(TestFile &&RHS)
+      : Name(std::move(RHS.Name)), Buffer(std::move(RHS.Buffer)) {
     RHS.Name = llvm::None;
+    RHS.Buffer = llvm::None;
   }
 
   ~TestFile();
 
   llvm::StringRef name() { return *Name; }
 
+  lldb::DataBufferSP dataBuffer() {
+    auto *buffer = reinterpret_cast<const uint8_t *>(Buffer->data());
+    return std::make_shared<DataBufferUnowned>(const_cast<uint8_t *>(buffer),
+                                               Buffer->size());
+  }
+
 private:
   TestFile(llvm::StringRef Name, llvm::FileRemover &&Remover)
       : Name(std::string(Name)) {
     Remover.releaseFile();
   }
+
+  TestFile(std::string &&Buffer) : Buffer(Buffer) {}
+
   void operator=(const TestFile &) = delete;
 
   llvm::Optional<std::string> Name;
+  llvm::Optional<std::string> Buffer;
 };
 }
 
 #endif

lldb/unittests/TestingSupport/TestUtilities.cpp

 //===-- TestUtilities.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
 //
 //===----------------------------------------------------------------------===//
 

 
 std::string lldb_private::GetInputFilePath(const llvm::Twine &name) {
   llvm::SmallString<128> result = llvm::sys::path::parent_path(TestMainArgv0);
   llvm::sys::fs::make_absolute(result);
   llvm::sys::path::append(result, "Inputs", name);
   return std::string(result.str());
 }
 
-llvm::Expected<TestFile> TestFile::fromYaml(llvm::StringRef Yaml) {
+llvm::Expected<TestFile> TestFile::fromYaml(llvm::StringRef Yaml,
+                                            bool InMemory) {
   const auto *Info = testing::UnitTest::GetInstance()->current_test_info();
   assert(Info);
+
+  if (InMemory) {
+    std::string Buffer;
+    llvm::raw_string_ostream OS(Buffer);
+    llvm::yaml::Input YIn(Yaml);
+    if (!llvm::yaml::convertYAML(YIn, OS, [](const llvm::Twine &Msg) {}))
+      return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                     "convertYAML() failed");
+    return TestFile(std::move(Buffer));
+  }
+
   llvm::SmallString<128> Name;
   int FD;
   if (std::error_code EC = llvm::sys::fs::createTemporaryFile(
           llvm::Twine(Info->test_case_name()) + "-" + Info->name(), "test", FD,
           Name))
     return llvm::errorCodeToError(EC);
   llvm::FileRemover Remover(Name);
   {
     llvm::raw_fd_ostream OS(FD, /*shouldClose*/ true);
     llvm::yaml::Input YIn(Yaml);
     if (!llvm::yaml::convertYAML(YIn, OS, [](const llvm::Twine &Msg) {}))
       return llvm::createStringError(llvm::inconvertibleErrorCode(),
                                      "convertYAML() failed");
   }
   return TestFile(Name, std::move(Remover));
 }
 
-llvm::Expected<TestFile> TestFile::fromYamlFile(const llvm::Twine &Name) {
+llvm::Expected<TestFile> TestFile::fromYamlFile(const llvm::Twine &Name,
+                                                bool InMemory) {
   auto BufferOrError =
       llvm::MemoryBuffer::getFile(GetInputFilePath(Name), /*FileSize*/ -1,
                                   /*RequiresNullTerminator*/ false);
   if (!BufferOrError)
     return llvm::errorCodeToError(BufferOrError.getError());
-  return fromYaml(BufferOrError.get()->getBuffer());
+  return fromYaml(BufferOrError.get()->getBuffer(), InMemory);
 }
 
 TestFile::~TestFile() {
   if (!Name)
     return;
   if (std::error_code EC =
           llvm::sys::fs::remove(*Name, /*IgnoreNonExisting*/ false))
     GTEST_LOG_(WARNING) << "Failed to delete `" << Name->c_str()
                         << "`: " << EC.message();
 }