[lldb] Remove lldbExpression's dependency on ObjectFileJIT

[bulbazord]

Summary

The high level goal is the title. The way this is accomplished is by adding a
new callback ObjectFileCreateInstanceWithDelegate where the intention is
to be able to create ObjectFile instances that are backed by a delegate
(like the way ObjectFileJIT works now with IRExecutionUnit as its
delegate).

[bulbazord]

Minor fix to ObjectFileWasm

[mib]

lldb/include/lldb/Symbol/ObjectFile.h

28

nit: What about nesting this in the ObjectFile class and rename it to Delegate. I would be better in term of namespacing IMO

lldb/source/Expression/CMakeLists.txt

1

Nice!

[labath]

I already regret getting involved in this, but here it goes...

Do you actually expect we will have multiple ObjectFile subclasses implementing the ObjectFileCreateInstanceWithDelegate interface? Because if not, then I think this is just a very roundabout way of being able to satisfy the syntactic requirements for calling ObjectFileJIT a plugin.

However, semantically, I don't think ObjectFileJIT is really a plugin, because a fundamental property of a plugin is that one can plug it out (and still have the core functionality working). If I compiled LLDB without ObjectFileELF, then it would work just fine (sans the capability to open ELF files). If I plug ObjectFileJIT out, then all expression evaluation (a core functionality) becomes broken, regardless of which target I'm debugging (or anything else).

I think that LLDB (falsely) equates the concept of a "plugin" with that of a "subclass". ObjectFile is clearly a class that was meant to be pluginized by subclassing. However, that doesn't mean that every subclass of ObjectFile needs to be a plugin.

I find it very unlikely that someone is going to implement a different ObjectFile plugin that would take an ObjectFileDelegate and expose it as an ObjectFile instance. The idea just doesn't make sense. I wasn't around when this got created, but I'm pretty sure that's not what the author had in mind.

I think that the situation here is reversed. ObjectFileJIT is not the plugin. ObjectFileDelegate is. And ObjectFileJIT is just an interface adaptor to present the delegate as an object file. To me, this puts it into the same category as e.g. ProcessTrace, which is a non-plugin subclass of a pluggable base, which implements a generic tracing capability on top of a trace plugin.

Now, with all of this in mind, I'd like to propose a simpler solution to the plugin dependency problem: just drop the plugin pretense and make ObjectFileJIT a core class. We can move it to a core folder (next to the ObjectFile class -- like ProcessTrace), to satisfy the formal requirements. And, we probably don't need to do anything else...

[bulbazord]

In D147009#4227163, @labath wrote:

I already regret getting involved in this, but here it goes...

Your effort and participation is greatly appreciated. I'm sorry if this is frustrating.

Do you actually expect we will have multiple ObjectFile subclasses implementing the ObjectFileCreateInstanceWithDelegate interface? Because if not, then I think this is just a very roundabout way of being able to satisfy the syntactic requirements for calling ObjectFileJIT a plugin.

That's exactly what this is. If we had "ScriptedObjectFiles" or something similar to this (like with what @mib is doing with ScriptedProcess) then this abstraction might make more sense but I'm not sure if that will be a thing.

However, semantically, I don't think ObjectFileJIT is really a plugin, because a fundamental property of a plugin is that one can plug it out (and still have the core functionality working). If I compiled LLDB without ObjectFileELF, then it would work just fine (sans the capability to open ELF files). If I plug ObjectFileJIT out, then all expression evaluation (a core functionality) becomes broken, regardless of which target I'm debugging (or anything else).

I think that LLDB (falsely) equates the concept of a "plugin" with that of a "subclass". ObjectFile is clearly a class that was meant to be pluginized by subclassing. However, that doesn't mean that every subclass of ObjectFile needs to be a plugin.

I find it very unlikely that someone is going to implement a different ObjectFile plugin that would take an ObjectFileDelegate and expose it as an ObjectFile instance. The idea just doesn't make sense. I wasn't around when this got created, but I'm pretty sure that's not what the author had in mind.

I think that the situation here is reversed. ObjectFileJIT is not the plugin. ObjectFileDelegate is. And ObjectFileJIT is just an interface adaptor to present the delegate as an object file. To me, this puts it into the same category as e.g. ProcessTrace, which is a non-plugin subclass of a pluggable base, which implements a generic tracing capability on top of a trace plugin.

Now, with all of this in mind, I'd like to propose a simpler solution to the plugin dependency problem: just drop the plugin pretense and make ObjectFileJIT a core class. We can move it to a core folder (next to the ObjectFile class -- like ProcessTrace), to satisfy the formal requirements. And, we probably don't need to do anything else...

I'm alright with this solution. We also don't need to rename "ObjectFileJITDelegate" to just "ObjectFileDelegate" so it'll be very clear what it is. I'm honestly not entirely sure why ObjectFileJIT is a plugin to begin with, but the argument you've laid out is very compelling for why it shouldn't be.

[bulbazord]

I'm abandoning this approach in favor of what Pavel suggested: https://reviews.llvm.org/D147084

lldb/include/lldb/Core/Module.h

public:
   ///
   /// \return
   ///     The object file loaded from memory or nullptr, if the operation
   ///     failed (see the `error` for more information in that case).
   ObjectFile *GetMemoryObjectFile(const lldb::ProcessSP &process_sp,
                                   lldb::addr_t header_addr, Status &error,
                                   size_t size_to_read = 512);
 
+  /// Load an object file backed by an ObjectFileDelegate
+  ///
+  /// If the object file has not been created yet, this function
+  /// will find the best ObjectFile plugin with the given delegate.
+  ///
+  /// \return
+  ///     The object file backed by the delegate or nullptr if the operation
+  ///     failed.
+  ObjectFile *
+  GetObjectFileWithDelegate(const lldb::ObjectFileDelegateSP &delegate_sp);
+
   /// Get the module's symbol file
   ///
   /// If the symbol file has already been loaded, this function returns it. All
   /// arguments are ignored. If the symbol file has not been located yet, and
   /// the can_create argument is false, the function returns nullptr. If
   /// can_create is true, this function will find the best SymbolFile plug-in
   /// that can use the current object file. feedback_strm, if not null, is used
   /// to report the details of the search process.

lldb/include/lldb/Core/PluginManager.h

static bool RegisterPlugin(llvm::StringRef name, llvm::StringRef description,
                              SystemRuntimeCreateInstance create_callback);
 
   static bool UnregisterPlugin(SystemRuntimeCreateInstance create_callback);
 
   static SystemRuntimeCreateInstance
   GetSystemRuntimeCreateCallbackAtIndex(uint32_t idx);
 
   // ObjectFile
-  static bool
-  RegisterPlugin(llvm::StringRef name, llvm::StringRef description,
-                 ObjectFileCreateInstance create_callback,
-                 ObjectFileCreateMemoryInstance create_memory_callback,
-                 ObjectFileGetModuleSpecifications get_module_specifications,
-                 ObjectFileSaveCore save_core = nullptr,
-                 DebuggerInitializeCallback debugger_init_callback = nullptr);
+  static bool RegisterPlugin(
+      llvm::StringRef name, llvm::StringRef description,
+      ObjectFileCreateInstanceWithDelegate create_with_delegate_callback,
 
   static bool UnregisterPlugin(ObjectFileCreateInstance create_callback);
 
   static ObjectFileCreateInstance
   GetObjectFileCreateCallbackAtIndex(uint32_t idx);
 
   static ObjectFileCreateMemoryInstance
   GetObjectFileCreateMemoryCallbackAtIndex(uint32_t idx);
 
   static ObjectFileGetModuleSpecifications
   GetObjectFileGetModuleSpecificationsCallbackAtIndex(uint32_t idx);
 
   static ObjectFileCreateMemoryInstance
   GetObjectFileCreateMemoryCallbackForPluginName(llvm::StringRef name);
 
+  static ObjectFileCreateInstanceWithDelegate
+  GetObjectFileCreateWithDelegateCallbackAtIndex(uint32_t idx);
+
   static Status SaveCore(const lldb::ProcessSP &process_sp,
                          const FileSpec &outfile,
                          lldb::SaveCoreStyle &core_style,
                          llvm::StringRef plugin_name);
 
   // ObjectContainer
   static bool RegisterPlugin(
       llvm::StringRef name, llvm::StringRef description,

lldb/include/lldb/Expression/IRExecutionUnit.h

 
 #include "llvm/ExecutionEngine/SectionMemoryManager.h"
 #include "llvm/IR/Module.h"
 
 #include "lldb/Expression/IRMemoryMap.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Utility/DataBufferHeap.h"
+#include "lldb/Utility/FileSpec.h"
 #include "lldb/lldb-forward.h"
 #include "lldb/lldb-private.h"
 
 namespace llvm {
 
 class Module;
 class ExecutionEngine;
 class ObjectCache;

 /// can be passed to a thread plan to run in the target.
 ///
 /// This class creates a subclass of LLVM's SectionMemoryManager, because that
 /// is how the JIT emits code.  Because LLDB needs to move JIT-compiled code
 /// into the target process, the IRExecutionUnit knows how to copy the emitted
 /// code into the target process.
 class IRExecutionUnit : public std::enable_shared_from_this<IRExecutionUnit>,
                         public IRMemoryMap,
-                        public ObjectFileJITDelegate {
+                        public ObjectFileDelegate {
 public:
   /// Constructor
   IRExecutionUnit(std::unique_ptr<llvm::LLVMContext> &context_up,
                   std::unique_ptr<llvm::Module> &module_up, ConstString &name,
                   const lldb::TargetSP &target_sp, const SymbolContext &sym_ctx,
                   std::vector<std::string> &cpu_features);
 
   /// Destructor
public:
   /// Accessors for IRForTarget and other clients that may want binary data
   /// placed on their behalf.  The binary data is owned by the IRExecutionUnit
   /// unless the client explicitly chooses to free it.
 
   lldb::addr_t WriteNow(const uint8_t *bytes, size_t size, Status &error);
 
   void FreeNow(lldb::addr_t allocation);
 
-  /// ObjectFileJITDelegate overrides
+  /// ObjectFileDelegate overrides
   lldb::ByteOrder GetByteOrder() const override;
 
   uint32_t GetAddressByteSize() const override;
 
   void PopulateSymtab(lldb_private::ObjectFile *obj_file,
                       lldb_private::Symtab &symtab) override;
 
   void PopulateSectionList(lldb_private::ObjectFile *obj_file,
                            lldb_private::SectionList &section_list) override;
 
   ArchSpec GetArchitecture() override;
 
-  lldb::ModuleSP GetJITModule();
+  lldb::ModuleSP CreateJITModule(const FileSpec &file_spec);
 
   lldb::addr_t FindSymbol(ConstString name, bool &missing_weak);
 
   void GetStaticInitializers(std::vector<lldb::addr_t> &static_initializers);
 
   /// \class JittedFunction IRExecutionUnit.h
   /// "lldb/Expression/IRExecutionUnit.h"
   /// Encapsulates a single function that has been generated by the JIT.

lldb/include/lldb/Symbol/ObjectFile.h

 #include "lldb/Utility/UUID.h"
 #include "lldb/lldb-private.h"
 #include "llvm/Support/Threading.h"
 #include "llvm/Support/VersionTuple.h"
 #include <optional>
 
 namespace lldb_private {
 
-class ObjectFileJITDelegate {
+class ObjectFileDelegate {
 public:
-  ObjectFileJITDelegate() = default;
+  ObjectFileDelegate() = default;
 
-  virtual ~ObjectFileJITDelegate() = default;
+  virtual ~ObjectFileDelegate() = default;
 
   virtual lldb::ByteOrder GetByteOrder() const = 0;
 
   virtual uint32_t GetAddressByteSize() const = 0;
 
   virtual void PopulateSymtab(lldb_private::ObjectFile *obj_file,
                               lldb_private::Symtab &symtab) = 0;
 
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::WritableDataBufferSP file_data_sp);
 
+  /// Find an ObjectFile plugin that can be backed by a delegate.
+  ///
+  /// Scans all loaded plugin interfaces that implement versions of the
+  /// ObjectFile plugin interface and returns the first instance that can be
+  /// backed by the given delegate.
+  ///
+  /// \param[in] module_sp
+  ///     The parent module that owns this object file.
+  ///
+  /// \param[in] delegate_sp
+  ///     The delegate that will back the object file.
+  static lldb::ObjectFileSP
+  FindPlugin(const lldb::ModuleSP &module_sp,
+             const lldb::ObjectFileDelegateSP &delegate_sp);
+
   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/include/lldb/lldb-forward.h

 class MemoryRegionInfo;
 class MemoryRegionInfos;
 class Module;
 class ModuleList;
 class ModuleSpec;
 class ModuleSpecList;
 class ObjectContainer;
 class ObjectFile;
-class ObjectFileJITDelegate;
+class ObjectFileDelegate;
 class OperatingSystem;
 class OptionGroup;
 class OptionGroupOptions;
 class OptionGroupPlatform;
 class OptionValue;
 class OptionValueArch;
 class OptionValueArgs;
 class OptionValueArray;

 typedef std::weak_ptr<lldb_private::Listener> ListenerWP;
 typedef std::shared_ptr<lldb_private::MemoryHistory> MemoryHistorySP;
 typedef std::unique_ptr<lldb_private::MemoryRegionInfo> MemoryRegionInfoUP;
 typedef std::shared_ptr<lldb_private::MemoryRegionInfo> MemoryRegionInfoSP;
 typedef std::shared_ptr<lldb_private::Module> ModuleSP;
 typedef std::weak_ptr<lldb_private::Module> ModuleWP;
 typedef std::shared_ptr<lldb_private::ObjectFile> ObjectFileSP;
 typedef std::shared_ptr<lldb_private::ObjectContainer> ObjectContainerSP;
-typedef std::shared_ptr<lldb_private::ObjectFileJITDelegate>
-    ObjectFileJITDelegateSP;
-typedef std::weak_ptr<lldb_private::ObjectFileJITDelegate>
-    ObjectFileJITDelegateWP;
+typedef std::shared_ptr<lldb_private::ObjectFileDelegate>
+    ObjectFileDelegateSP;
+typedef std::weak_ptr<lldb_private::ObjectFileDelegate>
+    ObjectFileDelegateWP;
 typedef std::unique_ptr<lldb_private::OperatingSystem> OperatingSystemUP;
 typedef std::shared_ptr<lldb_private::OptionValue> OptionValueSP;
 typedef std::weak_ptr<lldb_private::OptionValue> OptionValueWP;
 typedef std::shared_ptr<lldb_private::OptionValueProperties>
     OptionValuePropertiesSP;
 typedef std::shared_ptr<lldb_private::Platform> PlatformSP;
 typedef std::shared_ptr<lldb_private::Process> ProcessSP;
 typedef std::shared_ptr<lldb_private::ProcessAttachInfo> ProcessAttachInfoSP;

lldb/include/lldb/lldb-private-interfaces.h

typedef ObjectFile *(*ObjectFileCreateInstance)(const lldb::ModuleSP &module_sp,
                                                 lldb::DataBufferSP data_sp,
                                                 lldb::offset_t data_offset,
                                                 const FileSpec *file,
                                                 lldb::offset_t file_offset,
                                                 lldb::offset_t length);
 typedef ObjectFile *(*ObjectFileCreateMemoryInstance)(
     const lldb::ModuleSP &module_sp, lldb::WritableDataBufferSP data_sp,
     const lldb::ProcessSP &process_sp, lldb::addr_t offset);
+typedef ObjectFile *(*ObjectFileCreateInstanceWithDelegate)(
+    const lldb::ModuleSP &module_sp,
+    const lldb::ObjectFileDelegateSP &delegate_sp);
 typedef bool (*ObjectFileSaveCore)(const lldb::ProcessSP &process_sp,
                                    const FileSpec &outfile,
                                    lldb::SaveCoreStyle &core_style,
                                    Status &error);
 typedef EmulateInstruction *(*EmulateInstructionCreateInstance)(
     const ArchSpec &arch, InstructionType inst_type);
 typedef OperatingSystem *(*OperatingSystemCreateInstance)(Process *process,
                                                           bool force);

lldb/source/Core/Module.cpp

if (process_sp) {
       }
     } else {
       error.SetErrorString("invalid process");
     }
   }
   return m_objfile_sp.get();
 }
 
+ObjectFile *Module::GetObjectFileWithDelegate(
+    const lldb::ObjectFileDelegateSP &delegate_sp) {
+  if (m_objfile_sp)
+    return m_objfile_sp.get();
+
+  {
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
+    m_did_load_objfile.store(true, std::memory_order_relaxed);
+    m_objfile_sp = ObjectFile::FindPlugin(shared_from_this(), delegate_sp);
+    if (m_objfile_sp)
+      m_arch = m_objfile_sp->GetArchitecture();
+  }
+  return m_objfile_sp.get();
+}
+
 const lldb_private::UUID &Module::GetUUID() {
   if (!m_did_set_uuid.load()) {
     std::lock_guard<std::recursive_mutex> guard(m_mutex);
     if (!m_did_set_uuid.load()) {
       ObjectFile *obj_file = GetObjectFile();
 
       if (obj_file != nullptr) {
         m_uuid = obj_file->GetUUID();

lldb/source/Core/PluginManager.cpp

 
 #pragma mark ObjectFile
 
 struct ObjectFileInstance : public PluginInstance<ObjectFileCreateInstance> {
   ObjectFileInstance(
       llvm::StringRef name, llvm::StringRef description,
       CallbackType create_callback,
       ObjectFileCreateMemoryInstance create_memory_callback,
+      ObjectFileCreateInstanceWithDelegate create_delegate_callback,
       ObjectFileGetModuleSpecifications get_module_specifications,
       ObjectFileSaveCore save_core,
       DebuggerInitializeCallback debugger_init_callback)
       : PluginInstance<ObjectFileCreateInstance>(
             name, description, create_callback, debugger_init_callback),
         create_memory_callback(create_memory_callback),
+        create_delegate_callback(create_delegate_callback),
         get_module_specifications(get_module_specifications),
         save_core(save_core) {}
 
   ObjectFileCreateMemoryInstance create_memory_callback;
+  ObjectFileCreateInstanceWithDelegate create_delegate_callback;
   ObjectFileGetModuleSpecifications get_module_specifications;
   ObjectFileSaveCore save_core;
 };
 typedef PluginInstances<ObjectFileInstance> ObjectFileInstances;
 
 static ObjectFileInstances &GetObjectFileInstances() {
   static ObjectFileInstances g_instances;
   return g_instances;
 }
 
 bool PluginManager::RegisterPlugin(
     llvm::StringRef name, llvm::StringRef description,
     ObjectFileCreateInstance create_callback,
     ObjectFileCreateMemoryInstance create_memory_callback,
+    ObjectFileCreateInstanceWithDelegate create_delegate_callback,
     ObjectFileGetModuleSpecifications get_module_specifications,
     ObjectFileSaveCore save_core,
     DebuggerInitializeCallback debugger_init_callback) {
   return GetObjectFileInstances().RegisterPlugin(
       name, description, create_callback, create_memory_callback,
-      get_module_specifications, save_core, debugger_init_callback);
+      create_delegate_callback, get_module_specifications, save_core,
+      debugger_init_callback);
 }
 
 bool PluginManager::UnregisterPlugin(ObjectFileCreateInstance create_callback) {
   return GetObjectFileInstances().UnregisterPlugin(create_callback);
 }
 
 ObjectFileCreateInstance
 PluginManager::GetObjectFileCreateCallbackAtIndex(uint32_t idx) {
PluginManager::GetObjectFileCreateMemoryCallbackForPluginName(
   const auto &instances = GetObjectFileInstances().GetInstances();
   for (auto &instance : instances) {
     if (instance.name == name)
       return instance.create_memory_callback;
   }
   return nullptr;
 }
 
+ObjectFileCreateInstanceWithDelegate
+PluginManager::GetObjectFileCreateWithDelegateCallbackAtIndex(uint32_t idx) {
+  const auto &instances = GetObjectFileInstances().GetInstances();
+  if (idx < instances.size())
+    return instances[idx].create_delegate_callback;
+  return nullptr;
+}
+
 Status PluginManager::SaveCore(const lldb::ProcessSP &process_sp,
                                const FileSpec &outfile,
                                lldb::SaveCoreStyle &core_style,
                                llvm::StringRef plugin_name) {
   if (plugin_name.empty()) {
     // Try saving core directly from the process plugin first.
     llvm::Expected<bool> ret = process_sp->SaveCore(outfile.GetPath());
     if (!ret)

lldb/source/Expression/CMakeLists.txt

-# TODO: Add property `NO_PLUGIN_DEPENDENCIES` to lldbExpression
-add_lldb_library(lldbExpression
+add_lldb_library(lldbExpression NO_PLUGIN_DEPENDENCIES
   DiagnosticManager.cpp
   DWARFExpression.cpp
   DWARFExpressionList.cpp
   Expression.cpp
   ExpressionVariable.cpp
   FunctionCaller.cpp
   IRExecutionUnit.cpp
   IRInterpreter.cpp
add_lldb_library(lldbExpression NO_PLUGIN_DEPENDENCIES
 
   LINK_LIBS
     lldbCore
     lldbHost
     lldbInterpreter
     lldbSymbol
     lldbTarget
     lldbUtility
-    lldbPluginObjectFileJIT
 
   LINK_COMPONENTS
     Core
     ExecutionEngine
     Support
   )

lldb/source/Expression/FunctionCaller.cpp

bool FunctionCaller::WriteFunctionWrapper(
   if (!jit_error.Success()) {
     diagnostic_manager.Printf(eDiagnosticSeverityError,
                               "Error in PrepareForExecution: %s.",
                               jit_error.AsCString());
     return false;
   }
 
   if (m_parser->GetGenerateDebugInfo()) {
-    lldb::ModuleSP jit_module_sp(m_execution_unit_sp->GetJITModule());
-
-    if (jit_module_sp) {
-      ConstString const_func_name(FunctionName());
-      FileSpec jit_file;
-      jit_file.SetFilename(const_func_name);
-      jit_module_sp->SetFileSpecAndObjectName(jit_file, ConstString());
+    if (auto jit_module_sp = m_execution_unit_sp->CreateJITModule(jit_file)) {
       m_jit_module_wp = jit_module_sp;
-      process->GetTarget().GetImages().Append(jit_module_sp,
-                                              true /* notify */);
+      process->GetTarget().GetImages().Append(jit_module_sp);
     }
   }
   if (process && m_jit_start_addr)
     m_jit_process_wp = process->shared_from_this();
 
   m_JITted = true;
 
   return true;

lldb/source/Expression/IRExecutionUnit.cpp

 #include "lldb/Target/LanguageRuntime.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/Log.h"
 
-#include "lldb/../../source/Plugins/ObjectFile/JIT/ObjectFileJIT.h"
 #include <optional>
 
 using namespace lldb_private;
 
 IRExecutionUnit::IRExecutionUnit(std::unique_ptr<llvm::LLVMContext> &context_up,
                                  std::unique_ptr<llvm::Module> &module_up,
                                  ConstString &name,
                                  const lldb::TargetSP &target_sp,

 
 ArchSpec IRExecutionUnit::GetArchitecture() {
   ExecutionContext exe_ctx(GetBestExecutionContextScope());
   if(Target *target = exe_ctx.GetTargetPtr())
     return target->GetArchitecture();
   return ArchSpec();
 }
 
-lldb::ModuleSP IRExecutionUnit::GetJITModule() {
+lldb::ModuleSP IRExecutionUnit::CreateJITModule(const FileSpec &file_spec) {
   ExecutionContext exe_ctx(GetBestExecutionContextScope());
   Target *target = exe_ctx.GetTargetPtr();
   if (!target)
-    return nullptr;
-
-  auto Delegate = std::static_pointer_cast<lldb_private::ObjectFileJITDelegate>(
-      shared_from_this());
+    return lldb::ModuleSP();
 
-  lldb::ModuleSP jit_module_sp =
-      lldb_private::Module::CreateModuleFromObjectFile<ObjectFileJIT>(Delegate);
-  if (!jit_module_sp)
-    return nullptr;
+  // If we are unable to get the architecture, we consider the creation a
+  // failure.
+  auto arch = GetArchitecture();
+  if (!arch)
+    return lldb::ModuleSP();
+
+  auto module_sp = std::make_shared<Module>(file_spec, arch);
+  if (!module_sp)
+    return lldb::ModuleSP();
+
+  auto objfile = module_sp->GetObjectFileWithDelegate(shared_from_this());
+  if (!objfile)
+    return lldb::ModuleSP();
 
   bool changed = false;
-  jit_module_sp->SetLoadAddress(*target, 0, true, changed);
-  return jit_module_sp;
+  module_sp->SetLoadAddress(*target, /*value = */ 0,
+                            /*value_is_offset = */ true, changed);
+  return module_sp;
 }

lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp

if (register_execution_unit) {
       if (auto *persistent_state =
               exe_ctx.GetTargetPtr()->GetPersistentExpressionStateForLanguage(
                   m_language))
         persistent_state->RegisterExecutionUnit(m_execution_unit_sp);
     }
   }
 
   if (generate_debug_info) {
-    lldb::ModuleSP jit_module_sp(m_execution_unit_sp->GetJITModule());
-
-    if (jit_module_sp) {
-      ConstString const_func_name(FunctionName());
-      FileSpec jit_file;
-      jit_file.SetFilename(const_func_name);
-      jit_module_sp->SetFileSpecAndObjectName(jit_file, ConstString());
+
+    if (auto jit_module_sp = m_execution_unit_sp->CreateJITModule(jit_file)) {
       m_jit_module_wp = jit_module_sp;
       target->GetImages().Append(jit_module_sp);
     }
   }
 
   if (process && m_jit_start_addr != LLDB_INVALID_ADDRESS)
     m_jit_process_wp = lldb::ProcessWP(process->shared_from_this());
   return true;

lldb/source/Plugins/ExpressionParser/Clang/ClangUtilityFunction.cpp

bool ClangUtilityFunction::Install(DiagnosticManager &diagnostic_manager,
 
   Status jit_error = parser.PrepareForExecution(
       m_jit_start_addr, m_jit_end_addr, m_execution_unit_sp, exe_ctx,
       can_interpret, eExecutionPolicyAlways);
 
   if (m_jit_start_addr != LLDB_INVALID_ADDRESS) {
     m_jit_process_wp = process->shared_from_this();
     if (parser.GetGenerateDebugInfo()) {
-      lldb::ModuleSP jit_module_sp(m_execution_unit_sp->GetJITModule());
-
-      if (jit_module_sp) {
-        ConstString const_func_name(FunctionName());
-        FileSpec jit_file;
-        jit_file.SetFilename(const_func_name);
-        jit_module_sp->SetFileSpecAndObjectName(jit_file, ConstString());
+      if (auto jit_module_sp = m_execution_unit_sp->CreateJITModule(jit_file)) {
         m_jit_module_wp = jit_module_sp;
         target->GetImages().Append(jit_module_sp);
       }
     }
   }
 
   DeclMap()->DidParse();
 

lldb/source/Plugins/ObjectFile/Breakpad/ObjectFileBreakpad.h

CreateInstance(const lldb::ModuleSP &module_sp, lldb::DataBufferSP data_sp,
                  lldb::offset_t data_offset, const FileSpec *file,
                  lldb::offset_t file_offset, lldb::offset_t length);
 
   static ObjectFile *CreateMemoryInstance(const lldb::ModuleSP &module_sp,
                                           lldb::WritableDataBufferSP data_sp,
                                           const lldb::ProcessSP &process_sp,
                                           lldb::addr_t header_addr);
 
+  static ObjectFile *
+  CreateInstanceWithDelegate(const lldb::ModuleSP &module_sp,
+                             const lldb::ObjectFileDelegateSP &delegate_sp);
+
   static size_t GetModuleSpecifications(const FileSpec &file,
                                         lldb::DataBufferSP &data_sp,
                                         lldb::offset_t data_offset,
                                         lldb::offset_t file_offset,
                                         lldb::offset_t length,
                                         ModuleSpecList &specs);
 
   // PluginInterface protocol

lldb/source/Plugins/ObjectFile/Breakpad/ObjectFileBreakpad.cpp

std::optional<Header> Header::parse(llvm::StringRef text) {
   auto Info = InfoRecord::parse(line);
   UUID uuid = Info && Info->ID ? Info->ID : Module->ID;
   return Header{ArchSpec(triple), std::move(uuid)};
 }
 
 char ObjectFileBreakpad::ID;
 
 void ObjectFileBreakpad::Initialize() {
-  PluginManager::RegisterPlugin(GetPluginNameStatic(),
-                                GetPluginDescriptionStatic(), CreateInstance,
-                                CreateMemoryInstance, GetModuleSpecifications);
+  PluginManager::RegisterPlugin(
+      GetPluginNameStatic(), GetPluginDescriptionStatic(), CreateInstance,
+      CreateMemoryInstance, CreateInstanceWithDelegate,
+      GetModuleSpecifications);
 }
 
 void ObjectFileBreakpad::Terminate() {
   PluginManager::UnregisterPlugin(CreateInstance);
 }
 
 ObjectFile *ObjectFileBreakpad::CreateInstance(
     const ModuleSP &module_sp, DataBufferSP data_sp, offset_t data_offset,

 }
 
 ObjectFile *ObjectFileBreakpad::CreateMemoryInstance(
     const ModuleSP &module_sp, WritableDataBufferSP data_sp,
     const ProcessSP &process_sp, addr_t header_addr) {
   return nullptr;
 }
 
+ObjectFile *ObjectFileBreakpad::CreateInstanceWithDelegate(
+    const lldb::ModuleSP &module_sp,
+    const lldb::ObjectFileDelegateSP &delegate_sp) {
+  return nullptr;
+}
+
 size_t ObjectFileBreakpad::GetModuleSpecifications(
     const FileSpec &file, DataBufferSP &data_sp, offset_t data_offset,
     offset_t file_offset, offset_t length, ModuleSpecList &specs) {
   auto text = toStringRef(data_sp->GetData());
   std::optional<Header> header = Header::parse(text);
   if (!header)
     return 0;
   ModuleSpec spec(file, std::move(header->arch));

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

public:
   CreateInstance(const lldb::ModuleSP &module_sp, lldb::DataBufferSP data_sp,
                  lldb::offset_t data_offset, const lldb_private::FileSpec *file,
                  lldb::offset_t file_offset, lldb::offset_t length);
 
   static lldb_private::ObjectFile *CreateMemoryInstance(
       const lldb::ModuleSP &module_sp, lldb::WritableDataBufferSP data_sp,
       const lldb::ProcessSP &process_sp, lldb::addr_t header_addr);
 
+  static lldb_private::ObjectFile *
+  CreateInstanceWithDelegate(const lldb::ModuleSP &module_sp,
+                             const lldb::ObjectFileDelegateSP &delegate_sp);
+
   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 length,
                                         lldb_private::ModuleSpecList &specs);
 
   static bool MagicBytesMatch(lldb::DataBufferSP &data_sp, lldb::addr_t offset,

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

 
 char ObjectFileELF::ID;
 
 // Arbitrary constant used as UUID prefix for core files.
 const uint32_t ObjectFileELF::g_core_uuid_magic(0xE210C);
 
 // Static methods.
 void ObjectFileELF::Initialize() {
-  PluginManager::RegisterPlugin(GetPluginNameStatic(),
-                                GetPluginDescriptionStatic(), CreateInstance,
-                                CreateMemoryInstance, GetModuleSpecifications);
+  PluginManager::RegisterPlugin(
+      GetPluginNameStatic(), GetPluginDescriptionStatic(), CreateInstance,
+      CreateMemoryInstance, CreateInstanceWithDelegate,
+      GetModuleSpecifications);
 }
 
 void ObjectFileELF::Terminate() {
   PluginManager::UnregisterPlugin(CreateInstance);
 }
 
 ObjectFile *ObjectFileELF::CreateInstance(const lldb::ModuleSP &module_sp,
                                           DataBufferSP data_sp,
if (ELFHeader::MagicBytesMatch(magic)) {
         if (spec && objfile_up->SetModulesArchitecture(spec))
           return objfile_up.release();
       }
     }
   }
   return nullptr;
 }
 
+ObjectFile *ObjectFileELF::CreateInstanceWithDelegate(
+    const lldb::ModuleSP &module_sp,
+    const lldb::ObjectFileDelegateSP &delegate_sp) {
+  return nullptr;
+}
+
 bool ObjectFileELF::MagicBytesMatch(DataBufferSP &data_sp,
                                     lldb::addr_t data_offset,
                                     lldb::addr_t data_length) {
   if (data_sp &&
       data_sp->GetByteSize() > (llvm::ELF::EI_NIDENT + data_offset)) {
     const uint8_t *magic = data_sp->GetBytes() + data_offset;
     return ELFHeader::MagicBytesMatch(magic);
   }

lldb/source/Plugins/ObjectFile/JIT/ObjectFileJIT.h

 #include "lldb/Core/Address.h"
 #include "lldb/Symbol/ObjectFile.h"
 
 // This class needs to be hidden as eventually belongs in a plugin that
 // will export the ObjectFile protocol
 class ObjectFileJIT : public lldb_private::ObjectFile {
 public:
   ObjectFileJIT(const lldb::ModuleSP &module_sp,
-                const lldb::ObjectFileJITDelegateSP &delegate_sp);
+                const lldb::ObjectFileDelegateSP &delegate_sp);
 
   ~ObjectFileJIT() override;
 
   // Static Functions
   static void Initialize();
 
   static void Terminate();
 
   static llvm::StringRef GetPluginNameStatic() { return "jit"; }
 
   static llvm::StringRef GetPluginDescriptionStatic() {
     return "JIT code object file";
   }
 
   static lldb_private::ObjectFile *
   CreateInstance(const lldb::ModuleSP &module_sp, lldb::DataBufferSP data_sp,
                  lldb::offset_t data_offset, const lldb_private::FileSpec *file,
                  lldb::offset_t file_offset, lldb::offset_t length);
 
   static lldb_private::ObjectFile *CreateMemoryInstance(
       const lldb::ModuleSP &module_sp, lldb::WritableDataBufferSP data_sp,
       const lldb::ProcessSP &process_sp, lldb::addr_t header_addr);
 
+  static lldb_private::ObjectFile *
+  CreateInstanceWithDelegate(const lldb::ModuleSP &module_sp,
+                             const lldb::ObjectFileDelegateSP &delegate_sp);
+
   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 length,
                                         lldb_private::ModuleSpecList &specs);
 
   // LLVM RTTI support
public:
   ObjectFile::Type CalculateType() override;
 
   ObjectFile::Strata CalculateStrata() override;
 
   // PluginInterface protocol
   llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }
 
 protected:
-  lldb::ObjectFileJITDelegateWP m_delegate_wp;
+  lldb::ObjectFileDelegateWP m_delegate_wp;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_OBJECTFILE_JIT_OBJECTFILEJIT_H

lldb/source/Plugins/ObjectFile/JIT/ObjectFileJIT.cpp

 using namespace lldb;
 using namespace lldb_private;
 
 LLDB_PLUGIN_DEFINE(ObjectFileJIT)
 
 char ObjectFileJIT::ID;
 
 void ObjectFileJIT::Initialize() {
-  PluginManager::RegisterPlugin(GetPluginNameStatic(),
-                                GetPluginDescriptionStatic(), CreateInstance,
-                                CreateMemoryInstance, GetModuleSpecifications);
+  PluginManager::RegisterPlugin(
+      GetPluginNameStatic(), GetPluginDescriptionStatic(), CreateInstance,
+      CreateMemoryInstance, CreateInstanceWithDelegate,
+      GetModuleSpecifications);
 }
 
 void ObjectFileJIT::Terminate() {
   PluginManager::UnregisterPlugin(CreateInstance);
 }
 
 ObjectFile *ObjectFileJIT::CreateInstance(const lldb::ModuleSP &module_sp,
                                           DataBufferSP data_sp,
                                           lldb::offset_t data_offset,
                                           const FileSpec *file,
                                           lldb::offset_t file_offset,
                                           lldb::offset_t length) {
-  // JIT'ed object file is backed by the ObjectFileJITDelegate, never read from
+  // JIT'ed object file is backed by the ObjectFileDelegate, never read from
   // a file
   return nullptr;
 }
 
 ObjectFile *ObjectFileJIT::CreateMemoryInstance(const lldb::ModuleSP &module_sp,
                                                 WritableDataBufferSP data_sp,
                                                 const ProcessSP &process_sp,
                                                 lldb::addr_t header_addr) {
-  // JIT'ed object file is backed by the ObjectFileJITDelegate, never read from
+  // JIT'ed object file is backed by the ObjectFileDelegate, never read from
   // memory
   return nullptr;
 }
 
+ObjectFile *ObjectFileJIT::CreateInstanceWithDelegate(
+    const lldb::ModuleSP &module_sp,
+    const lldb::ObjectFileDelegateSP &delegate_sp) {
+  if (!module_sp || !delegate_sp)
+    return nullptr;
+
+  auto objfile_jit_up = std::make_unique<ObjectFileJIT>(module_sp, delegate_sp);
+  if (!objfile_jit_up)
+    return nullptr;
+
+  return objfile_jit_up.release();
+}
+
 size_t ObjectFileJIT::GetModuleSpecifications(
     const lldb_private::FileSpec &file, lldb::DataBufferSP &data_sp,
     lldb::offset_t data_offset, lldb::offset_t file_offset,
     lldb::offset_t length, lldb_private::ModuleSpecList &specs) {
   // JIT'ed object file can't be read from a file on disk
   return 0;
 }
 
 ObjectFileJIT::ObjectFileJIT(const lldb::ModuleSP &module_sp,
-                             const ObjectFileJITDelegateSP &delegate_sp)
+                             const ObjectFileDelegateSP &delegate_sp)
     : ObjectFile(module_sp, nullptr, 0, 0, DataBufferSP(), 0), m_delegate_wp() {
   if (delegate_sp) {
     m_delegate_wp = delegate_sp;
     m_data.SetByteOrder(delegate_sp->GetByteOrder());
     m_data.SetAddressByteSize(delegate_sp->GetAddressByteSize());
   }
 }
 
 ObjectFileJIT::~ObjectFileJIT() = default;
 
 bool ObjectFileJIT::ParseHeader() {
   // JIT code is never in a file, nor is it required to have any header
   return false;
 }
 
 ByteOrder ObjectFileJIT::GetByteOrder() const { return m_data.GetByteOrder(); }
 
 bool ObjectFileJIT::IsExecutable() const { return false; }
 
 uint32_t ObjectFileJIT::GetAddressByteSize() const {
   return m_data.GetAddressByteSize();
 }
 
 void ObjectFileJIT::ParseSymtab(Symtab &symtab) {
-  ObjectFileJITDelegateSP delegate_sp(m_delegate_wp.lock());
+  ObjectFileDelegateSP delegate_sp(m_delegate_wp.lock());
   if (delegate_sp)
     delegate_sp->PopulateSymtab(this, symtab);
 }
 
 bool ObjectFileJIT::IsStripped() {
   return false; // JIT code that is in a module is never stripped
 }
 
 void ObjectFileJIT::CreateSections(SectionList &unified_section_list) {
   if (!m_sections_up) {
     m_sections_up = std::make_unique<SectionList>();
-    ObjectFileJITDelegateSP delegate_sp(m_delegate_wp.lock());
+    ObjectFileDelegateSP delegate_sp(m_delegate_wp.lock());
     if (delegate_sp) {
       delegate_sp->PopulateSectionList(this, *m_sections_up);
       unified_section_list = *m_sections_up;
     }
   }
 }
 
 void ObjectFileJIT::Dump(Stream *s) {

 
 lldb_private::Address ObjectFileJIT::GetBaseAddress() { return Address(); }
 
 ObjectFile::Type ObjectFileJIT::CalculateType() { return eTypeJIT; }
 
 ObjectFile::Strata ObjectFileJIT::CalculateStrata() { return eStrataJIT; }
 
 ArchSpec ObjectFileJIT::GetArchitecture() {
-  if (ObjectFileJITDelegateSP delegate_sp = m_delegate_wp.lock())
+  if (ObjectFileDelegateSP delegate_sp = m_delegate_wp.lock())
     return delegate_sp->GetArchitecture();
   return ArchSpec();
 }
 
 bool ObjectFileJIT::SetLoadAddress(Target &target, lldb::addr_t value,
                                    bool value_is_offset) {
   size_t num_loaded_sections = 0;
   SectionList *section_list = GetSectionList();

lldb/source/Plugins/ObjectFile/JSON/ObjectFileJSON.h

CreateInstance(const lldb::ModuleSP &module_sp, lldb::DataBufferSP data_sp,
                  lldb::offset_t data_offset, const FileSpec *file,
                  lldb::offset_t file_offset, lldb::offset_t length);
 
   static ObjectFile *CreateMemoryInstance(const lldb::ModuleSP &module_sp,
                                           lldb::WritableDataBufferSP data_sp,
                                           const lldb::ProcessSP &process_sp,
                                           lldb::addr_t header_addr);
 
+  static ObjectFile *
+  CreateInstanceWithDelegate(const lldb::ModuleSP &module_sp,
+                             const lldb::ObjectFileDelegateSP &delegate_sp);
+
   static size_t GetModuleSpecifications(const FileSpec &file,
                                         lldb::DataBufferSP &data_sp,
                                         lldb::offset_t data_offset,
                                         lldb::offset_t file_offset,
                                         lldb::offset_t length,
                                         ModuleSpecList &specs);
 
   llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }

lldb/source/Plugins/ObjectFile/JSON/ObjectFileJSON.cpp

 using namespace lldb;
 using namespace lldb_private;
 
 LLDB_PLUGIN_DEFINE(ObjectFileJSON)
 
 char ObjectFileJSON::ID;
 
 void ObjectFileJSON::Initialize() {
-  PluginManager::RegisterPlugin(GetPluginNameStatic(),
-                                GetPluginDescriptionStatic(), CreateInstance,
-                                CreateMemoryInstance, GetModuleSpecifications);
+  PluginManager::RegisterPlugin(
+      GetPluginNameStatic(), GetPluginDescriptionStatic(), CreateInstance,
+      CreateMemoryInstance, CreateInstanceWithDelegate,
+      GetModuleSpecifications);
 }
 
 void ObjectFileJSON::Terminate() {
   PluginManager::UnregisterPlugin(CreateInstance);
 }
 
 ObjectFile *
 ObjectFileJSON::CreateInstance(const ModuleSP &module_sp, DataBufferSP data_sp,

 
 ObjectFile *ObjectFileJSON::CreateMemoryInstance(const ModuleSP &module_sp,
                                                  WritableDataBufferSP data_sp,
                                                  const ProcessSP &process_sp,
                                                  addr_t header_addr) {
   return nullptr;
 }
 
+ObjectFile *ObjectFileJSON::CreateInstanceWithDelegate(
+    const lldb::ModuleSP &module_sp,
+    const lldb::ObjectFileDelegateSP &delegate_sp) {
+  return nullptr;
+}
+
 size_t ObjectFileJSON::GetModuleSpecifications(
     const FileSpec &file, DataBufferSP &data_sp, offset_t data_offset,
     offset_t file_offset, offset_t length, ModuleSpecList &specs) {
 
   if (!MagicBytesMatch(data_sp, data_offset, data_sp->GetByteSize()))
     return 0;
 
   auto text =

lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.h

public:
   CreateInstance(const lldb::ModuleSP &module_sp, lldb::DataBufferSP data_sp,
                  lldb::offset_t data_offset, const lldb_private::FileSpec *file,
                  lldb::offset_t file_offset, lldb::offset_t length);
 
   static lldb_private::ObjectFile *CreateMemoryInstance(
       const lldb::ModuleSP &module_sp, lldb::WritableDataBufferSP data_sp,
       const lldb::ProcessSP &process_sp, lldb::addr_t header_addr);
 
+  static lldb_private::ObjectFile *
+  CreateInstanceWithDelegate(const lldb::ModuleSP &module_sp,
+                             const lldb::ObjectFileDelegateSP &delegate_sp);
+
   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 length,
                                         lldb_private::ModuleSpecList &specs);
 
   static bool SaveCore(const lldb::ProcessSP &process_sp,

lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

 
 #define MACHO_NLIST_ARM_SYMBOL_IS_THUMB 0x0008
 
 char ObjectFileMachO::ID;
 
 void ObjectFileMachO::Initialize() {
   PluginManager::RegisterPlugin(
       GetPluginNameStatic(), GetPluginDescriptionStatic(), CreateInstance,
-      CreateMemoryInstance, GetModuleSpecifications, SaveCore);
+      CreateMemoryInstance, CreateInstanceWithDelegate, GetModuleSpecifications,
+      SaveCore);
 }
 
 void ObjectFileMachO::Terminate() {
   PluginManager::UnregisterPlugin(CreateInstance);
 }
 
 ObjectFile *ObjectFileMachO::CreateInstance(const lldb::ModuleSP &module_sp,
                                             DataBufferSP data_sp,
if (ObjectFileMachO::MagicBytesMatch(data_sp, 0, data_sp->GetByteSize())) {
     std::unique_ptr<ObjectFile> objfile_up(
         new ObjectFileMachO(module_sp, data_sp, process_sp, header_addr));
     if (objfile_up.get() && objfile_up->ParseHeader())
       return objfile_up.release();
   }
   return nullptr;
 }
 
+ObjectFile *ObjectFileMachO::CreateInstanceWithDelegate(
+    const lldb::ModuleSP &module_sp,
+    const lldb::ObjectFileDelegateSP &delegate_sp) {
+  return nullptr;
+}
+
 size_t ObjectFileMachO::GetModuleSpecifications(
     const lldb_private::FileSpec &file, lldb::DataBufferSP &data_sp,
     lldb::offset_t data_offset, lldb::offset_t file_offset,
     lldb::offset_t length, lldb_private::ModuleSpecList &specs) {
   const size_t initial_count = specs.GetSize();
 
   if (ObjectFileMachO::MagicBytesMatch(data_sp, 0, data_sp->GetByteSize())) {
     DataExtractor data;

lldb/source/Plugins/ObjectFile/Minidump/ObjectFileMinidump.h

public:
   CreateInstance(const lldb::ModuleSP &module_sp, lldb::DataBufferSP data_sp,
                  lldb::offset_t data_offset, const lldb_private::FileSpec *file,
                  lldb::offset_t offset, lldb::offset_t length);
 
   static lldb_private::ObjectFile *CreateMemoryInstance(
       const lldb::ModuleSP &module_sp, lldb::WritableDataBufferSP data_sp,
       const lldb::ProcessSP &process_sp, lldb::addr_t header_addr);
 
+  static lldb_private::ObjectFile *
+  CreateInstanceWithDelegate(const lldb::ModuleSP &module_sp,
+                             const lldb::ObjectFileDelegateSP &delegate_sp);
+
   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 length,
                                         lldb_private::ModuleSpecList &specs);
 
   // Saves dump in Minidump file format

lldb/source/Plugins/ObjectFile/Minidump/ObjectFileMinidump.cpp

 using namespace lldb;
 using namespace lldb_private;
 
 LLDB_PLUGIN_DEFINE(ObjectFileMinidump)
 
 void ObjectFileMinidump::Initialize() {
   PluginManager::RegisterPlugin(
       GetPluginNameStatic(), GetPluginDescriptionStatic(), CreateInstance,
-      CreateMemoryInstance, GetModuleSpecifications, SaveCore);
+      CreateMemoryInstance, CreateInstanceWithDelegate, GetModuleSpecifications,
+      SaveCore);
 }
 
 void ObjectFileMinidump::Terminate() {
   PluginManager::UnregisterPlugin(CreateInstance);
 }
 
 ObjectFile *ObjectFileMinidump::CreateInstance(
     const lldb::ModuleSP &module_sp, lldb::DataBufferSP data_sp,
     lldb::offset_t data_offset, const lldb_private::FileSpec *file,
     lldb::offset_t offset, lldb::offset_t length) {
   return nullptr;
 }
 
 ObjectFile *ObjectFileMinidump::CreateMemoryInstance(
     const lldb::ModuleSP &module_sp, WritableDataBufferSP data_sp,
     const ProcessSP &process_sp, lldb::addr_t header_addr) {
   return nullptr;
 }
 
+ObjectFile *ObjectFileMinidump::CreateInstanceWithDelegate(
+    const lldb::ModuleSP &module_sp,
+    const lldb::ObjectFileDelegateSP &delegate_sp) {
+  return nullptr;
+}
+
 size_t ObjectFileMinidump::GetModuleSpecifications(
     const lldb_private::FileSpec &file, lldb::DataBufferSP &data_sp,
     lldb::offset_t data_offset, lldb::offset_t file_offset,
     lldb::offset_t length, lldb_private::ModuleSpecList &specs) {
   specs.Clear();
   return 0;
 }
 

lldb/source/Plugins/ObjectFile/PDB/ObjectFilePDB.h

CreateInstance(const lldb::ModuleSP &module_sp, lldb::DataBufferSP data_sp,
                  lldb::offset_t data_offset, const FileSpec *file,
                  lldb::offset_t file_offset, lldb::offset_t length);
 
   static ObjectFile *CreateMemoryInstance(const lldb::ModuleSP &module_sp,
                                           lldb::WritableDataBufferSP data_sp,
                                           const lldb::ProcessSP &process_sp,
                                           lldb::addr_t header_addr);
 
+  static ObjectFile *
+  CreateInstanceWithDelegate(const lldb::ModuleSP &module_sp,
+                             const lldb::ObjectFileDelegateSP &delegate_sp);
+
   static size_t GetModuleSpecifications(const FileSpec &file,
                                         lldb::DataBufferSP &data_sp,
                                         lldb::offset_t data_offset,
                                         lldb::offset_t file_offset,
                                         lldb::offset_t length,
                                         ModuleSpecList &specs);
 
   // PluginInterface protocol

lldb/source/Plugins/ObjectFile/PDB/ObjectFilePDB.cpp

static UUID GetPDBUUID(InfoStream &IS) {
   memcpy(&debug_info.Uuid, IS.getGuid().Guid, sizeof(debug_info.Uuid));
   debug_info.Age = IS.getAge();
   return UUID(debug_info);
 }
 
 char ObjectFilePDB::ID;
 
 void ObjectFilePDB::Initialize() {
-  PluginManager::RegisterPlugin(GetPluginNameStatic(),
-                                GetPluginDescriptionStatic(), CreateInstance,
-                                CreateMemoryInstance, GetModuleSpecifications);
+  PluginManager::RegisterPlugin(
+      GetPluginNameStatic(), GetPluginDescriptionStatic(), CreateInstance,
+      CreateMemoryInstance, CreateInstanceWithDelegate,
+      GetModuleSpecifications);
 }
 
 void ObjectFilePDB::Terminate() {
   PluginManager::UnregisterPlugin(CreateInstance);
 }
 
 ArchSpec ObjectFilePDB::GetArchitecture() {
   auto dbi_stream = m_file_up->getPDBDbiStream();

 
 ObjectFile *ObjectFilePDB::CreateMemoryInstance(const ModuleSP &module_sp,
                                                 WritableDataBufferSP data_sp,
                                                 const ProcessSP &process_sp,
                                                 addr_t header_addr) {
   return nullptr;
 }
 
+ObjectFile *ObjectFilePDB::CreateInstanceWithDelegate(
+    const ModuleSP &module_sp, const ObjectFileDelegateSP &delegate_sp) {
+  return nullptr;
+}
+
 size_t ObjectFilePDB::GetModuleSpecifications(
     const FileSpec &file, DataBufferSP &data_sp, offset_t data_offset,
     offset_t file_offset, offset_t length, ModuleSpecList &specs) {
   const size_t initial_count = specs.GetSize();
   ModuleSpec module_spec(file);
   llvm::BumpPtrAllocator allocator;
   std::unique_ptr<PDBFile> pdb_file = loadPDBFile(file.GetPath(), allocator);
   if (!pdb_file)

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

public:
   CreateInstance(const lldb::ModuleSP &module_sp, lldb::DataBufferSP data_sp,
                  lldb::offset_t data_offset, const lldb_private::FileSpec *file,
                  lldb::offset_t offset, lldb::offset_t length);
 
   static lldb_private::ObjectFile *CreateMemoryInstance(
       const lldb::ModuleSP &module_sp, lldb::WritableDataBufferSP data_sp,
       const lldb::ProcessSP &process_sp, lldb::addr_t header_addr);
 
+  static lldb_private::ObjectFile *
+  CreateInstanceWithDelegate(const lldb::ModuleSP &module_sp,
+                             const lldb::ObjectFileDelegateSP &delegate_sp);
+
   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 length,
                                         lldb_private::ModuleSpecList &specs);
 
   static bool SaveCore(const lldb::ProcessSP &process_sp,

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

static UUID GetCoffUUID(llvm::object::COFFObjectFile &coff_obj) {
   // Use 4 bytes of crc from the .gnu_debuglink section.
   llvm::support::ulittle32_t data(gnu_debuglink_crc);
   return UUID(&data, sizeof(data));
 }
 
 char ObjectFilePECOFF::ID;
 
 void ObjectFilePECOFF::Initialize() {
-  PluginManager::RegisterPlugin(GetPluginNameStatic(),
-                                GetPluginDescriptionStatic(), CreateInstance,
-                                CreateMemoryInstance, GetModuleSpecifications,
-                                SaveCore, DebuggerInitialize);
+  PluginManager::RegisterPlugin(
+      GetPluginNameStatic(), GetPluginDescriptionStatic(), CreateInstance,
+      CreateMemoryInstance, CreateInstanceWithDelegate, GetModuleSpecifications,
 }
 
 void ObjectFilePECOFF::DebuggerInitialize(Debugger &debugger) {
   if (!PluginManager::GetSettingForObjectFilePlugin(
           debugger, PluginProperties::GetSettingName())) {
     const bool is_global_setting = true;
     PluginManager::CreateSettingForObjectFilePlugin(
         debugger, GetGlobalPluginProperties().GetValueProperties(),
ObjectFile *ObjectFilePECOFF::CreateMemoryInstance(
   auto objfile_up = std::make_unique<ObjectFilePECOFF>(
       module_sp, data_sp, process_sp, header_addr);
   if (objfile_up.get() && objfile_up->ParseHeader()) {
     return objfile_up.release();
   }
   return nullptr;
 }
 
+ObjectFile *ObjectFilePECOFF::CreateInstanceWithDelegate(
+    const lldb::ModuleSP &module_sp,
+    const lldb::ObjectFileDelegateSP &delegate_sp) {
+  return nullptr;
+}
+
 size_t ObjectFilePECOFF::GetModuleSpecifications(
     const lldb_private::FileSpec &file, lldb::DataBufferSP &data_sp,
     lldb::offset_t data_offset, lldb::offset_t file_offset,
     lldb::offset_t length, lldb_private::ModuleSpecList &specs) {
   const size_t initial_count = specs.GetSize();
   if (!data_sp || !ObjectFilePECOFF::MagicBytesMatch(data_sp))
     return initial_count;
 

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

CreateInstance(const lldb::ModuleSP &module_sp, lldb::DataBufferSP data_sp,
                  lldb::offset_t data_offset, const FileSpec *file,
                  lldb::offset_t file_offset, lldb::offset_t length);
 
   static ObjectFile *CreateMemoryInstance(const lldb::ModuleSP &module_sp,
                                           lldb::WritableDataBufferSP data_sp,
                                           const lldb::ProcessSP &process_sp,
                                           lldb::addr_t header_addr);
 
+  static ObjectFile *
+  CreateInstanceWithDelegate(const lldb::ModuleSP &module_sp,
+                             const lldb::ObjectFileDelegateSP &delegate_sp);
+
   static size_t GetModuleSpecifications(const FileSpec &file,
                                         lldb::DataBufferSP &data_sp,
                                         lldb::offset_t data_offset,
                                         lldb::offset_t file_offset,
                                         lldb::offset_t length,
                                         ModuleSpecList &specs);
 
   /// PluginInterface protocol.

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

GetWasmString(llvm::DataExtractor &data, llvm::DataExtractor::Cursor &c) {
 
   llvm::StringRef str = toStringRef(llvm::ArrayRef(str_storage));
   return ConstString(str);
 }
 
 char ObjectFileWasm::ID;
 
 void ObjectFileWasm::Initialize() {
-  PluginManager::RegisterPlugin(GetPluginNameStatic(),
-                                GetPluginDescriptionStatic(), CreateInstance,
-                                CreateMemoryInstance, GetModuleSpecifications);
+  PluginManager::RegisterPlugin(
+      GetPluginNameStatic(), GetPluginDescriptionStatic(), CreateInstance,
+      CreateMemoryInstance, CreateInstanceWithDelegate,
+      GetModuleSpecifications);
 }
 
 void ObjectFileWasm::Terminate() {
   PluginManager::UnregisterPlugin(CreateInstance);
 }
 
 ObjectFile *
 ObjectFileWasm::CreateInstance(const ModuleSP &module_sp, DataBufferSP data_sp,
ObjectFile *ObjectFileWasm::CreateMemoryInstance(const ModuleSP &module_sp,
   std::unique_ptr<ObjectFileWasm> objfile_up(
       new ObjectFileWasm(module_sp, data_sp, process_sp, header_addr));
   ArchSpec spec = objfile_up->GetArchitecture();
   if (spec && objfile_up->SetModulesArchitecture(spec))
     return objfile_up.release();
   return nullptr;
 }
 
+ObjectFile *ObjectFileWasm::CreateInstanceWithDelegate(
+    const ModuleSP &module_sp, const ObjectFileDelegateSP &delegate_sp) {
+  return nullptr;
+}
+
 bool ObjectFileWasm::DecodeNextSection(lldb::offset_t *offset_ptr) {
   // Buffer sufficient to read a section header and find the pointer to the next
   // section.
   const uint32_t kBufferSize = 1024;
   DataExtractor section_header_data = ReadImageData(*offset_ptr, kBufferSize);
 
   llvm::DataExtractor data = section_header_data.GetAsLLVM();
   llvm::DataExtractor::Cursor c(0);

lldb/source/Symbol/ObjectFile.cpp

ObjectFileSP ObjectFile::FindPlugin(const lldb::ModuleSP &module_sp,
   }
 
   // We didn't find it, so clear our shared pointer in case it contains
   // anything and return an empty shared pointer
   object_file_sp.reset();
   return object_file_sp;
 }
 
+ObjectFileSP
+ObjectFile::FindPlugin(const lldb::ModuleSP &module_sp,
+                       const lldb::ObjectFileDelegateSP &delegate_sp) {
+  if (!module_sp)
+    return ObjectFileSP();
+
+  ObjectFileSP object_file_sp;
+  ObjectFileCreateInstanceWithDelegate create_callback;
+  for (uint32_t idx = 0;
+       (create_callback =
+            PluginManager::GetObjectFileCreateWithDelegateCallbackAtIndex(
+                idx)) != nullptr;
+       idx++) {
+    object_file_sp.reset(create_callback(module_sp, delegate_sp));
+    if (object_file_sp)
+      return object_file_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) {
   if (!data_sp)
     data_sp = FileSystem::Instance().CreateDataBuffer(
         file.GetPath(), g_initial_bytes_to_read, file_offset);