[Orc] Add JITLink debug support plugin for ELF x86-64

[sgraenitz]

Summary

This patch adds a new ObjectLinkingLayer plugin DebugObjectManagerPlugin and infrastructure to handle creation of DebugObjects and their registration in OrcTargetProcess. The current implementation only covers ELF on x86-64, but the infrastructure is not limited to that.

The journey starts with a new LinkGraph / JITLinkContext pair being created for a MaterializationResponsibility in ORC's ObjectLinkingLayer. It sends a notifyMaterializing() notification, which is forwarded to all registered plugins. The DebugObjectManagerPlugin aims to create a DebugObject form the provided target triple and object buffer. (Future implementations might create DebugObjects from a LinkGraph in other ways.) On success it will track it as the pending DebugObject for the MaterializationResponsibility.

This patch only implements the ELFDebugObject for x86-64 targets. It follows the RuntimeDyld approach for debug object setup: it captures a copy of the input object, parses all section headers and prepares to patch their load-address fields with their final addresses in target memory. It instructs the plugin to report the section load-addresses once they are available. The plugin overrides modifyPassConfig() and installs a JITLink post-allocation pass to capture them.

Once JITLink emitted the finalized executable, the plugin emits and registers the DebugObject. For emission it requests a new JITLinkMemoryManager::Allocation with a single read-only segment, copies the object with patched section load-addresses over to working memory and triggers finalization to target memory. For registration, it notifies the DebugObjectRegistrar provided in the constructor and stores the previously pending`DebugObject` as registered for the corresponding MaterializationResponsibility.

The DebugObjectRegistrar registers the DebugObject with the target process. llvm-jitlink uses the TPCDebugObjectRegistrar, which calls llvm_orc_registerJITLoaderGDBWrapper() in the target process via TargetProcessControl to emit a jit_code_entry compatible with the GDB JIT interface [1]. So far the implementation only supports registration and no removal. It appears to me that it wouldn't raise any new design questions, so I left this as an addition for the near future.

[1] https://sourceware.org/gdb/current/onlinedocs/gdb/JIT-Interface.html

[sgraenitz]

llvm/lib/ExecutionEngine/JITLink/DebugSupport.cpp

60

Is it possible to set an allocation's working memory to an existing buffer? Is it worth adding?

llvm/lib/ExecutionEngine/Orc/DebugObjectManagerPlugin.cpp

34

This still holds. Can we have more than one resource per MR?

llvm/lib/ExecutionEngine/Orc/TargetProcess/JITLoaderGDB.cpp

64

This replicates the code for the GDB JIT interface definition fom ExecutionEngine and causes the duplication in D97339 eventually. Is there a way to shared it without creating a dedicated library? If there's a better way, I am eager to learn about it.

Otherwise, maybe one more reason to look at this https://reviews.llvm.org/D95747#2532432 ?

[lhames]

This looks excellent.

I still think that we want to approach this using debug object construction in the long run, but this is too useful to hold up on that point. One thing that I would like to see (and that I think is doable with this scheme as-is) is to move the changes out of JITLink and entirely into Orc / ObjectLinkingLayer. Keeping them out of the deeper levels of the stack (i.e. JITLink) should make them easier to re-do later when we switch to the "right" long term solution.

So, I would be inclined to move DebugObject into ORC, and void notifyMaterializing(jitlink::LinkGraph &G) and Expected<std::unique_ptr<DebugObject>> createDebugObject(LinkGraph &G) from JITLinkContext to ObjectLinkingLayerJITLinkContext (the decl for which may need to be hoisted into the ObjectLinkingLayer.h header for now). The new methods should carry comments saying that they're deprecated -- we can leave them in for the purposes of DebugObjectManagerPlugin for now, but we don't want other people to start using them.

llvm/lib/ExecutionEngine/JITLink/DebugSupport.cpp

60

Good question. I ran across another limitation of the existing memory management API today: If you want to mutate a block in a way that changes its size (e.g. prepending or appending) then you need to allocate memory for that in the graph and copy the content into that, only to have to copy all of that back out into working memory later. What you really wanted was a way to say
"reserve me X bytes of additional memory for this block and *I'll* copy the content".

Let's stick to a copy for now, but I think we want to revisit the memory manager API in the not-too-distant-future.

llvm/lib/ExecutionEngine/Orc/DebugObjectManagerPlugin.cpp

34

In this context a "resource" is some abstract thing that you manage. You can certainly manage more than one kind of resource on behalf of an MR (e.g. for an ObjC++ object you have allocated memory tracked by ObjectLinkingLayer, eh-frames tracked by the EHFrameRegistrationPlugin, and runtime data tracked by the platform plugin).

The usual idiom is to hold a DenseMap<ResourceKey, std::vector<ResourceT>>, where ResourceT is whatever resource type(s) the plugin is managing, which I think is what you're doing.

// We should never have more than one pending debug object.

Is this true? JITLink supports running multiple concurrent instances -- If the plugin is to support concurrency it should be possible to have more than one debug object in-flight at a time.

[sgraenitz]

Make DebugObject an implementation detail of the plugin

[sgraenitz]

Thanks for the feedback.

In D97335#2588617, @lhames wrote:

So, I would be inclined to move DebugObject into ORC, and void notifyMaterializing(jitlink::LinkGraph &G) and Expected<std::unique_ptr<DebugObject>> createDebugObject(LinkGraph &G) from JITLinkContext to ObjectLinkingLayerJITLinkContext

At first I followed the approach from EH frame registration and thought I could reuse some JITLink code for handling ELF headers, but yes there is no real need to have the debug object classes there. And yes moving them over to ORC also avoids extra API. It was a bit more reorganization than I expected initially, but I think the result is better than the first version.

The new methods should carry comments saying that they're deprecated -- we can leave them in for the purposes of DebugObjectManagerPlugin for now, but we don't want other people to start using them.

I need to double-check my previous comments and will add the note then.

(the decl for which may need to be hoisted into the ObjectLinkingLayer.h header for now).

Instead of creating a new interface, I just added a MemoryBufferRef parameter to Plugin::notifyMaterializing() for now. Is that acceptable? Otherwise, can you give a rough description of the API you had in mind?

What I realized during my ExtensibleRTTI hack is, that I could also capture the incoming object file with an extra ObjectLayer above the linking layer. At first sight it doesn't look impossible. I'd also have to add some support code first and I don't know if plugin-layer-coop is a design question you already considered or rejected. What do you think?

[sgraenitz]

Allow more than one pending debug object per MaterializationUnit

[sgraenitz]

llvm/lib/ExecutionEngine/Orc/DebugObjectManagerPlugin.cpp

34

If the plugin is to support concurrency it should be possible to have more than one debug object in-flight at a time.

Yes, but wouldn't they all have their own MaterializationResponsibilities?

My first thought was: yes, I can let modifyPassConfig() and notifyLoaded() simply act on all pending debug objects registered for the MR. I submitted the change and just realized now, that it is incorrect. Please see my other inline comment.

396

This obviously won't work because it adds a pass for each pending object. But what would be the right way? Sending each section range to all the pending objects? That can't seem to be correct. What am I missing?

[sgraenitz]

Notify the debugger on notifyEmitted(), not notifyLoded(). This caused a funny behavior for pending breakpoints in LLDB: they were resolved and implemented correctly but never hit, because the JIT had overwritten the instruction in the meantime!

[lhames]

In D97335#2591511, @sgraenitz wrote:

Instead of creating a new interface, I just added a MemoryBufferRef parameter to Plugin::notifyMaterializing() for now. Is that acceptable? Otherwise, can you give a rough description of the API you had in mind?

I think that sounds good for now. Could you just add a note saying that it's deprecated? As soon as JITLink reaches the point where we can represent debug info in the graph we'll switch to using that to construct a new object,

llvm/lib/ExecutionEngine/Orc/DebugObjectManagerPlugin.cpp

34

Oh -- You're right. Each in-flight object will have a distinct MaterializationResponsibility, so you can assume one debug object per MR.

Sorry for the confusion!

[sgraenitz]

Revert support for multiple pending debug objects per MR. Update documentation in comments and polish.

[sgraenitz]

LIT tests landed with https://reviews.llvm.org/rGae51fde369dffa34e948c44f002457d27a2b22dd

[thakis]

I see you've now disabled this on Windows. I think it works on Windows with

diff --git a/llvm/tools/llvm-jitlink/CMakeLists.txt b/llvm/tools/llvm-jitlink/CMakeLists.txt
index 8d511b17fca2..34e892f30ed6 100644
--- a/llvm/tools/llvm-jitlink/CMakeLists.txt
+++ b/llvm/tools/llvm-jitlink/CMakeLists.txt
@@ -24,4 +24,16 @@ add_llvm_tool(llvm-jitlink
   llvm-jitlink-macho.cpp
   )
 
+# export_executable_symbols() is a no-op on Windows if neither
+# LLVM_EXPORTED_SYMBOL_FILE nor LLVM_EXPORT_SYMBOLS_FOR_PLUGINS are set, but
+# the jitlink tests need llvm_orc_registerJITLoaderGDBWrapper to be exported
+# from the executable to work.
+# FIXME: Find a better workaround. Maybe this should use LLVM_EXPORTED_SYMBOL_FILE
+# and an .exports file now that the binary has a required export.
+if (WIN32)
+  target_link_options(llvm-jitlink PRIVATE
+    "/export:llvm_orc_registerJITLoaderGDBWrapper"
+    )
+endif()
+
 export_executable_symbols(llvm-jitlink)

but as the comment says, setting LLVM_EXPORTED_SYMBOL_FILE seems like it'd probably be a nicer fix.

(But I don't have a problem with this being disabled on Windows.)

[thakis]

Since your win

[thakis]

fix attempt in http://reviews.llvm.org/rGbbdb4c8c9bcef0e8db751630accc04ad874f54e7 didn't help, i landed that in 900f07611330. please see if you want to follow up on the fixme therein.

[ASDenysPetrov]

My build fails after hack to this patch https://reviews.llvm.org/rG900f076113302e26e1939541b546b0075e3e9721. Could you revise your solution?
I'm using Win10, GCC+ninja
Here is my build output:

[32/92] Linking CXX executable bin\llvm-jitlink.exe
FAILED: bin/llvm-jitlink.exe
cmd.exe /C "cd . && D:\WORK\Utilities\MSYS2\mingw64\bin\c++.exe -Wa,-mbig-obj -Werror=date-time -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wno-missing-field-initializers -pedantic -Wno-long-long -Wimplicit-fallthrough -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-noexcept-type -Wdelete-non-virtual-dtor -Wsuggest-override -Wno-comment  -O2 -Wl,--stack,16777216    /export:llvm_orc_registerJITLoaderGDBWrapper tools/llvm-jitlink/CMakeFiles/llvm-jitlink.dir/llvm-jitlink.cpp.obj tools/llvm-jitlink/CMakeFiles/llvm-jitlink.dir/llvm-jitlink-elf.cpp.obj tools/llvm-jitlink/CMakeFiles/llvm-jitlink.dir/llvm-jitlink-macho.cpp.obj -o bin\llvm-jitlink.exe -Wl,--out-implib,lib\libllvm-jitlink.dll.a -Wl,--major-image-version,0,--minor-image-version,0  lib/libLLVMX86Desc.a  lib/libLLVMX86Disassembler.a  lib/libLLVMX86Info.a  lib/libLLVMBinaryFormat.a  lib/libLLVMExecutionEngine.a  lib/libLLVMJITLink.a  lib/libLLVMMC.a  lib/libLLVMObject.a  lib/libLLVMOrcJIT.a  lib/libLLVMOrcShared.a  lib/libLLVMOrcTargetProcess.a  lib/libLLVMRuntimeDyld.a  lib/libLLVMSupport.a  lib/libLLVMMCDisassembler.a  lib/libLLVMExecutionEngine.a  lib/libLLVMJITLink.a  lib/libLLVMOrcTargetProcess.a  lib/libLLVMOrcShared.a  lib/libLLVMRuntimeDyld.a  lib/libLLVMPasses.a  lib/libLLVMTarget.a  lib/libLLVMCoroutines.a  lib/libLLVMipo.a  lib/libLLVMBitWriter.a  lib/libLLVMFrontendOpenMP.a  lib/libLLVMIRReader.a  lib/libLLVMAsmParser.a  lib/libLLVMLinker.a  lib/libLLVMObjCARCOpts.a  lib/libLLVMScalarOpts.a  lib/libLLVMAggressiveInstCombine.a  lib/libLLVMInstCombine.a  lib/libLLVMVectorize.a  lib/libLLVMInstrumentation.a  lib/libLLVMTransformUtils.a  lib/libLLVMAnalysis.a  lib/libLLVMObject.a  lib/libLLVMBitReader.a  lib/libLLVMMCParser.a  lib/libLLVMMC.a  lib/libLLVMDebugInfoCodeView.a  lib/libLLVMDebugInfoMSF.a  lib/libLLVMTextAPI.a  lib/libLLVMProfileData.a  lib/libLLVMCore.a  lib/libLLVMBinaryFormat.a  lib/libLLVMRemarks.a  lib/libLLVMBitstreamReader.a  lib/libLLVMSupport.a  -lpsapi  -lshell32  -lole32  -luuid  -ladvapi32  D:/WORK/Utilities/MSYS2/mingw64/lib/libz.dll.a  lib/libLLVMDemangle.a  -lkernel32 -luser32 -lgdi32 -lwinspool -lshell32 -lole32 -loleaut32 -luuid -lcomdlg32 -ladvapi32 && cd ."
c++.exe: error: /export:llvm_orc_registerJITLoaderGDBWrapper: No such file or directory
[47/92] Linking CXX executable bin\clang-check.exe
ninja: build stopped: subcommand failed.

Here is my setup output if you're wondering cmake -GNinja ../llvm -DLLVM_LIT_ARGS=-sv -DLLVM_ENABLE_PROJECTS=clang -DLLVM_TARGETS_TO_BUILD=X86 -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=../../install -DLLVM_ENABLE_ASSERTIONS=ON:

ninja_setup_output.txt13 KBDownload

[sgraenitz]

In D97335#2603542, @ASDenysPetrov wrote:

My build fails after hack to this patch https://reviews.llvm.org/rG900f076113302e26e1939541b546b0075e3e9721. Could you revise your solution?

Hello Denys, I reverted the temporary hack and fixed the issue that Nico described with e984c2b06f0c59265ba2172bbdb2811c72123701
Does it fix the issue for you too?

[ASDenysPetrov]

In D97335#2611171, @sgraenitz wrote:

Does it fix the issue for you too?

Hi, Stefan. Thanks. I've checked. Yes, this fix (rGe984c2b06f0c59265ba2172bbdb2811c72123701) works for me.

[sgraenitz]

Attempting to close the review after it was re-opened.

[sgraenitz]

@ASDenysPetrov I guess you set the Needs Revision status accidentally?

[ASDenysPetrov]

In D97335#2614508, @sgraenitz wrote:

@ASDenysPetrov I guess you set the Needs Revision status accidentally?

Right. Probably the action was choosed previously in the drop-down list and I missed it. Sorry.

[sgraenitz]

In D97335#2614807, @ASDenysPetrov wrote:

Right. Probably the action was choosed previously in the drop-down list and I missed it. Sorry.

Can you withdraw that, i.e. accept the patch? Otherwise, I cannot close the review.

llvm/include/llvm/ExecutionEngine/JITLink/DebugSupport.h

+//===------------ DebugSupport.h - JITLink debug utils ----------*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Create companion objects for consumption by a debugger.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_JITLINK_DEBUGSUPPORT_H
+#define LLVM_EXECUTIONENGINE_JITLINK_DEBUGSUPPORT_H
+
+#include "llvm/ADT/Triple.h"
+#include "llvm/ExecutionEngine/JITLink/JITLink.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/Memory.h"
+#include "llvm/Support/MemoryBuffer.h"
+
+#include <functional>
+#include <memory>
+
+namespace llvm {
+namespace jitlink {
+
+/// Abstract interface for debug objects in the DebugObjectManagerPlugin.
+///
+/// The plugin requests a debug object from JITLinkContext when JITLink starts
+/// processing the corresponding LinkGraph. It provides access to the pass
+/// configuration of the LinkGraph and calls the finalization function, once
+/// the resulting link artifact was emitted.
+///
+class DebugObject {
+public:
+  using FinalizeContinuation = std::function<void(Expected<sys::MemoryBlock>)>;
+
+  virtual void modifyPassConfig(const Triple &TT,
+                                PassConfiguration &PassConfig) = 0;
+  virtual void finalizeAsync(FinalizeContinuation OnFinalize) = 0;
+  virtual ~DebugObject() {}
+};
+
+/// Creates a debug object based on the input object file from
+/// ObjectLinkingLayerJITLinkContext.
+///
+/// It replicates the approach used in RuntimeDyld: Patching executable and data
+/// section headers in the given object buffer with load-addresses of their
+/// corresponding LinkGraph segments in target memory.
+///
+Expected<std::unique_ptr<DebugObject>>
+createDebugObjectFromBuffer(const Triple &TT, JITLinkContext &Ctx,
+                            std::unique_ptr<WritableMemoryBuffer> Buffer);
+
+} // namespace jitlink
+} // namespace llvm
+
+#endif // LLVM_EXECUTIONENGINE_JITLINK_DEBUGSUPPORT_H

llvm/include/llvm/ExecutionEngine/JITLink/JITLink.h

createLookupContinuation(Continuation Cont) {
 
   private:
     Continuation C;
   };
 
   return std::make_unique<Impl>(std::move(Cont));
 }
 
+class DebugObject;
+
 /// Holds context for a single jitLink invocation.
 class JITLinkContext {
 public:
   using LookupMap = DenseMap<StringRef, SymbolLookupFlags>;
 
   /// Create a JITLinkContext.
   JITLinkContext(const JITLinkDylib *JD) : JD(JD) {}
 
   /// Destroy a JITLinkContext.
   virtual ~JITLinkContext();
 
   /// Return the JITLinkDylib that this link is targeting, if any.
   const JITLinkDylib *getJITLinkDylib() const { return JD; }
 
   /// Return the MemoryManager to be used for this link.
   virtual JITLinkMemoryManager &getMemoryManager() = 0;
 
+  /// Notify this context that linking is about to start.
+  virtual void notifyMaterializing(jitlink::LinkGraph &G) = 0;
+
   /// Notify this context that linking failed.
   /// Called by JITLink if linking cannot be completed.
   virtual void notifyFailed(Error Err) = 0;
 
   /// Called by JITLink to resolve external symbols. This method is passed a
   /// lookup continutation which it must call with a result to continue the
   /// linking process.
   virtual void lookup(const LookupMap &Symbols,
public:
   /// otherwise the JITContext is responsible for adding a mark-live pass in
   /// modifyPassConfig.
   virtual LinkGraphPassFunction getMarkLivePass(const Triple &TT) const;
 
   /// Called by JITLink to modify the pass pipeline prior to linking.
   /// The default version performs no modification.
   virtual Error modifyPassConfig(const Triple &TT, PassConfiguration &Config);
 
+  /// Returns a debug object for the given link graph or nullptr if it's not
+  /// supported.
+  virtual Expected<std::unique_ptr<DebugObject>>
+  createDebugObject(LinkGraph &G);
+
 private:
   const JITLinkDylib *JD = nullptr;
 };
 
 /// Marks all symbols in a graph live. This can be used as a default,
 /// conservative mark-live implementation.
 Error markAllSymbolsLive(LinkGraph &G);
 

llvm/include/llvm/ExecutionEngine/Orc/DebugObjectManagerPlugin.h

+//===---- DebugObjectManagerPlugin.h - JITLink debug objects ---*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// ObjectLinkingLayer plugin for emitting debug objects.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_ORC_DEBUGOBJECTMANAGERPLUGIN_H
+#define LLVM_EXECUTIONENGINE_ORC_DEBUGOBJECTMANAGERPLUGIN_H
+
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/Triple.h"
+#include "llvm/ExecutionEngine/JITLink/DebugSupport.h"
+#include "llvm/ExecutionEngine/JITLink/JITLink.h"
+#include "llvm/ExecutionEngine/Orc/Core.h"
+#include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"
+#include "llvm/ExecutionEngine/Orc/TPCDebugObjectRegistrar.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/Memory.h"
+
+#include <functional>
+#include <memory>
+#include <mutex>
+
+namespace llvm {
+namespace orc {
+
+/// Requests and manages DebugObjects for JITLink artifacts.
+///
+/// For each processed MaterializationResponsibility a DebugObject is requested
+/// from JITLinkContext. DebugObjects are pending as long as their corresponding
+/// MaterializationResponsibility did not finish loading.
+///
+/// There can only be one pending DebugObject per MaterializationResponsibility.
+/// Pending DebugObjects for failed MaterializationResponsibility are discarded.
+///
+/// Once loading finished, DebugObjects are finalized and their target memory
+/// is reported to the provided DebugObjectRegistrar. Ownership of DebugObjects
+/// remains with the plugin.
+///
+class DebugObjectManagerPlugin : public ObjectLinkingLayer::Plugin {
+public:
+  DebugObjectManagerPlugin(ExecutionSession &ES,
+                           std::unique_ptr<DebugObjectRegistrar> Target)
+      : ES(ES), Target(std::move(Target)) {}
+
+  void notifyMaterializing(MaterializationResponsibility &MR,
+                           jitlink::LinkGraph &G,
+                           jitlink::JITLinkContext &Ctx) override;
+
+  void notifyLoaded(MaterializationResponsibility &MR) override;
+  Error notifyFailed(MaterializationResponsibility &MR) override;
+  Error notifyRemovingResources(ResourceKey K) override;
+
+  void notifyTransferringResources(ResourceKey DstKey,
+                                   ResourceKey SrcKey) override;
+
+  void modifyPassConfig(MaterializationResponsibility &MR, const Triple &TT,
+                        jitlink::PassConfiguration &PassConfig) override;
+
+private:
+  ExecutionSession &ES;
+
+  using DebugObjectPtr = std::unique_ptr<jitlink::DebugObject>;
+  DenseMap<ResourceKey, std::vector<DebugObjectPtr>> RegisteredObjs;
+  DenseMap<ResourceKey, DebugObjectPtr> PendingObjs;
+
+  std::mutex RegisteredObjsLock;
+  std::mutex PendingObjsLock;
+
+  std::unique_ptr<DebugObjectRegistrar> Target;
+};
+
+} // namespace orc
+} // namespace llvm
+
+#endif // LLVM_EXECUTIONENGINE_ORC_DEBUGOBJECTMANAGERPLUGIN_H

llvm/include/llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h

public:
     using JITLinkSymbolVector = std::vector<const jitlink::Symbol *>;
     using LocalDependenciesMap = DenseMap<SymbolStringPtr, JITLinkSymbolVector>;
 
     virtual ~Plugin();
     virtual void modifyPassConfig(MaterializationResponsibility &MR,
                                   const Triple &TT,
                                   jitlink::PassConfiguration &Config) {}
 
+    virtual void notifyMaterializing(MaterializationResponsibility &MR,
+                                     jitlink::LinkGraph &G,
+                                     jitlink::JITLinkContext &Ctx) {}
+
     virtual void notifyLoaded(MaterializationResponsibility &MR) {}
     virtual Error notifyEmitted(MaterializationResponsibility &MR) {
       return Error::success();
     }
     virtual Error notifyFailed(MaterializationResponsibility &MR) = 0;
     virtual Error notifyRemovingResources(ResourceKey K) = 0;
     virtual void notifyTransferringResources(ResourceKey DstKey,
                                              ResourceKey SrcKey) = 0;

llvm/include/llvm/ExecutionEngine/Orc/TPCDebugObjectRegistrar.h

+//===- TPCDebugObjectRegistrar.h - TPC-based debug registration -*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// TargetProcessControl based registration of debug objects.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_ORC_TPCDEBUGOBJECTREGISTRAR_H
+#define LLVM_EXECUTIONENGINE_ORC_TPCDEBUGOBJECTREGISTRAR_H
+
+#include "llvm/ExecutionEngine/JITSymbol.h"
+#include "llvm/ExecutionEngine/Orc/TargetProcessControl.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/Memory.h"
+
+#include <cstdint>
+#include <memory>
+#include <vector>
+
+namespace llvm {
+namespace orc {
+
+/// Abstract interface used with the DebugObjectManagerPlugin for registering
+/// debug objects in the target process.
+class DebugObjectRegistrar {
+public:
+  virtual Error registerDebugObject(sys::MemoryBlock) = 0;
+  virtual ~DebugObjectRegistrar() {}
+};
+
+/// Register debug objects via TargetProcessControl.
+class TPCDebugObjectRegistrar : public DebugObjectRegistrar {
+public:
+  using SerializeBlockInfoFn =
+      std::vector<uint8_t> (*)(sys::MemoryBlock TargetMemBlock);
+
+  TPCDebugObjectRegistrar(TargetProcessControl &TPC,
+                          JITTargetAddress RegisterFn,
+                          SerializeBlockInfoFn SerializeBlockInfo)
+      : TPC(TPC), RegisterFn(RegisterFn),
+        SerializeBlockInfo(SerializeBlockInfo) {}
+
+  Error registerDebugObject(sys::MemoryBlock TargetMem) override {
+    return TPC.runWrapper(RegisterFn, SerializeBlockInfo(TargetMem))
+        .takeError();
+  }
+
+private:
+  TargetProcessControl &TPC;
+  JITTargetAddress RegisterFn;
+  SerializeBlockInfoFn SerializeBlockInfo;
+};
+
+/// Creates a TargetProcessControl-based DebugObjectRegistrar that emits debug
+/// objects to the GDB JIT interface.
+Expected<std::unique_ptr<TPCDebugObjectRegistrar>>
+createJITLoaderGDBRegistrar(TargetProcessControl &TPC);
+
+} // end namespace orc
+} // end namespace llvm
+
+#endif // LLVM_EXECUTIONENGINE_ORC_TDEBUGOBJECTREGISTRAR_H

llvm/include/llvm/ExecutionEngine/Orc/TargetProcess/JITLoaderGDB.h

+//===- JITLoaderGDB.h - Register objects via GDB JIT interface -*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Register objects for access by debuggers via the GDB JIT interface.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_ORC_TARGETPROCESS_JITLOADERGDB_H
+#define LLVM_EXECUTIONENGINE_ORC_TARGETPROCESS_JITLOADERGDB_H
+
+#include "llvm/ExecutionEngine/Orc/Shared/TargetProcessControlTypes.h"
+#include <cstdint>
+
+extern "C" llvm::orc::tpctypes::CWrapperFunctionResult
+llvm_orc_registerJITLoaderGDBWrapper(uint8_t *Data, uint64_t Size);
+
+#endif // LLVM_EXECUTIONENGINE_ORC_TARGETPROCESS_JITLOADERGDB_H

llvm/lib/ExecutionEngine/JITLink/CMakeLists.txt

 add_llvm_component_library(LLVMJITLink
   JITLink.cpp
   JITLinkGeneric.cpp
   JITLinkMemoryManager.cpp
+  DebugSupport.cpp
   EHFrameSupport.cpp
   #macho
   MachO.cpp
   MachO_arm64.cpp
   MachO_x86_64.cpp
   MachOLinkGraphBuilder.cpp
   #elf
   ELF.cpp

llvm/lib/ExecutionEngine/JITLink/DebugSupport.cpp

+//===----------- DebugSupport.cpp - JITLink debug utils ---------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ExecutionEngine/JITLink/DebugSupport.h"
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/BinaryFormat/ELF.h"
+#include "llvm/ExecutionEngine/JITLink/JITLinkDylib.h"
+#include "llvm/ExecutionEngine/JITLink/JITLinkMemoryManager.h"
+#include "llvm/ExecutionEngine/JITSymbol.h"
+#include "llvm/Object/ELFObjectFile.h"
+#include "llvm/Object/ObjectFile.h"
+#include "llvm/Support/Process.h"
+#include "llvm/Support/raw_ostream.h"
+
+#include <set>
+
+#define DEBUG_TYPE "jitlink"
+
+using namespace llvm::object;
+
+namespace llvm {
+namespace jitlink {
+
+static constexpr sys::Memory::ProtectionFlags ReadOnlyFlag =
+    static_cast<sys::Memory::ProtectionFlags>(sys::Memory::MF_READ);
+
+static const std::set<StringRef> DwarfSectionNames = {
+#define HANDLE_DWARF_SECTION(ENUM_NAME, ELF_NAME, CMDLINE_NAME, OPTION)        \
+  ELF_NAME,
+#include "llvm/BinaryFormat/Dwarf.def"
+#undef HANDLE_DWARF_SECTION
+};
+
+static bool isDwarfSection(StringRef SectionName) {
+  return DwarfSectionNames.count(SectionName) == 1;
+}
+
+class ReadOnlySegment {
+  using Allocation = JITLinkMemoryManager::Allocation;
+
+public:
+  ReadOnlySegment(JITLinkMemoryManager &MemMgr, const JITLinkDylib *JD)
+      : MemMgr(MemMgr), JD(JD), Alloc(nullptr) {}
+
+  Error initialize(std::unique_ptr<WritableMemoryBuffer> DebugObj) {
+    // TODO: This works, but what actual alignment requirements do we have?
+    unsigned Alignment = sys::Process::getPageSizeEstimate();
+    size_t Size = DebugObj->getBufferSize();
+
+    // Allocate working memory for debug object in read-only segment.
+    // TODO: Could we use the given buffer as working memory directly
+    // and avoid the unnecessary copy below?
+    Expected<std::unique_ptr<Allocation>> AllocOrErr =
+        MemMgr.allocate(JD, {{ReadOnlyFlag, {Alignment, Size, 0}}});
+    if (!AllocOrErr)
+      return AllocOrErr.takeError();
+    Alloc = std::move(*AllocOrErr);
+
+    // Initialize working memory with a copy of the debug object.
+    MutableArrayRef<char> DebugObjMem = Alloc->getWorkingMemory(ReadOnlyFlag);
+    memcpy(DebugObjMem.data(), DebugObj->getBufferStart(), Size);
+
+    return Error::success();
+  }
+
+  void finalizeAsync(Allocation::FinalizeContinuation OnFinalize) {
+    Alloc->finalizeAsync(std::move(OnFinalize));
+  }
+
+  sys::MemoryBlock getTargetMemBlock() const {
+    return sys::MemoryBlock(
+        jitTargetAddressToPointer<void *>(Alloc->getTargetMemory(ReadOnlyFlag)),
+        Alloc->getWorkingMemory(ReadOnlyFlag).size());
+  }
+
+private:
+  JITLinkMemoryManager &MemMgr;
+  const JITLinkDylib *JD;
+  std::unique_ptr<Allocation> Alloc;
+};
+
+class DebugObjectSection {
+public:
+  virtual void setTargetMemoryRange(SectionRange Range) = 0;
+  virtual void dump(raw_ostream &OS, StringRef Name) {}
+  virtual ~DebugObjectSection() {}
+};
+
+template <typename ELFT>
+class ELFDebugObjectSection : public DebugObjectSection {
+public:
+  // BinaryFormat ELF is not meant as a mutable format. We can only make changes
+  // that don't invalidate the file structure.
+  ELFDebugObjectSection(const typename ELFT::Shdr *Header)
+      : Header(const_cast<typename ELFT::Shdr *>(Header)) {}
+
+  void setTargetMemoryRange(SectionRange Range) override {
+    // Only patch load-addresses for executable and data sections.
+    if (isTextOrDataSection()) {
+      Header->sh_addr = static_cast<typename ELFT::uint>(Range.getStart());
+    }
+  }
+
+  void dump(raw_ostream &OS, StringRef Name) override {
+    if (auto Addr = static_cast<JITTargetAddress>(Header->sh_addr)) {
+      OS << formatv("  {0:x16} {1}\n", Addr, Name);
+    } else {
+      OS << formatv("                     {0}\n", Name);
+    }
+  }
+
+private:
+  typename ELFT::Shdr *Header;
+
+  bool isTextOrDataSection() const {
+    switch (Header->sh_type) {
+    case ELF::SHT_PROGBITS:
+    case ELF::SHT_X86_64_UNWIND:
+      return Header->sh_flags & (ELF::SHF_EXECINSTR | ELF::SHF_ALLOC);
+    }
+    return false;
+  }
+};
+
+template <typename ELFT> class ELFDebugObject : public DebugObject {
+  using SectionHeader = typename ELFT::Shdr;
+
+  ELFDebugObject(std::unique_ptr<llvm::WritableMemoryBuffer> Buffer,
+                 ReadOnlySegment TargetSegment)
+      : Buffer(std::move(Buffer)), Segment(std::move(TargetSegment)) {}
+
+public:
+  static Expected<std::unique_ptr<ELFDebugObject<ELFT>>>
+
+  Create(std::unique_ptr<llvm::WritableMemoryBuffer> Buffer,
+         ReadOnlySegment TargetSegment) {
+
+    MutableArrayRef<char> B = Buffer->getBuffer();
+    Expected<ELFFile<ELFT>> ObjRef =
+        ELFFile<ELFT>::create(StringRef(B.data(), B.size()));
+    if (!ObjRef)
+      return ObjRef.takeError();
+
+    Expected<ArrayRef<SectionHeader>> Sections = ObjRef->sections();
+    if (!Sections)
+      return Sections.takeError();
+
+    std::unique_ptr<ELFDebugObject<ELFT>> DebugObj(
+        new ELFDebugObject<ELFT>(std::move(Buffer), std::move(TargetSegment)));
+
+    bool HasDwarfSection = false;
+    for (const SectionHeader &Header : *Sections) {
+      Expected<StringRef> Name = ObjRef->getSectionName(Header);
+      if (!Name)
+        return Name.takeError();
+      if (Name->empty())
+        continue;
+      HasDwarfSection |= isDwarfSection(*Name);
+      if (Error Err = DebugObj->recordSection(*Name, Header))
+        return std::move(Err);
+    }
+
+    if (!HasDwarfSection) {
+      LLVM_DEBUG(dbgs() << "Aborting debug registration for LinkGraph \""
+                        << Buffer->getBufferIdentifier() + "\": "
+                        << "input object contains no debug info\n");
+      return nullptr;
+    }
+
+    return std::move(DebugObj);
+  }
+
+  Error recordSection(StringRef Name, const SectionHeader &Header) {
+    auto WrappedHeader = std::make_unique<ELFDebugObjectSection<ELFT>>(&Header);
+    auto ItInserted = Sections.try_emplace(Name, std::move(WrappedHeader));
+    if (!ItInserted.second)
+      return make_error<StringError>("Duplicate section",
+                                     inconvertibleErrorCode());
+    return Error::success();
+  }
+
+  DebugObjectSection *getSection(StringRef Name) {
+    auto It = Sections.find(Name);
+    return It == Sections.end() ? nullptr : It->second.get();
+  }
+
+  void modifyPassConfig(const Triple &TT,
+                        PassConfiguration &PassConfig) override {
+    PassConfig.PostAllocationPasses.push_back(
+        [this](LinkGraph &Graph) -> Error {
+          // Once target memory is allocated, report the final load-addresses
+          // for all sections to the debug object.
+          for (const Section &GraphSection : Graph.sections())
+            if (auto *DebugObjSection = getSection(GraphSection.getName()))
+              DebugObjSection->setTargetMemoryRange(GraphSection);
+
+          return Error::success();
+        });
+  }
+
+  void finalizeAsync(FinalizeContinuation OnFinalize) override {
+    LLVM_DEBUG({
+      dbgs() << "Section load-addresses in debug object for \""
+             << Buffer->getBufferIdentifier() << "\":\n";
+      for (const auto &KV : Sections)
+        KV.second->dump(dbgs(), KV.first());
+    });
+
+    // Allocate target memory for the debug object, start copying over our
+    // buffer and pass on the result once we're done.
+    if (Error Err = Segment.initialize(std::move(Buffer))) {
+      OnFinalize(std::move(Err));
+      return;
+    }
+
+    Segment.finalizeAsync([this, OnFinalize](Error Err) {
+      if (Err)
+        OnFinalize(std::move(Err));
+      else
+        OnFinalize(Segment.getTargetMemBlock());
+    });
+  }
+
+private:
+  StringMap<std::unique_ptr<DebugObjectSection>> Sections;
+  std::unique_ptr<llvm::WritableMemoryBuffer> Buffer;
+  ReadOnlySegment Segment;
+};
+
+static Expected<std::unique_ptr<DebugObject>>
+createDebugObjectELF(std::unique_ptr<llvm::WritableMemoryBuffer> Buf,
+                     JITLinkContext &Ctx) {
+  unsigned char Class, Endian;
+  MutableArrayRef<char> B = Buf->getBuffer();
+  std::tie(Class, Endian) = getElfArchType(StringRef(B.data(), B.size()));
+  ReadOnlySegment Seg(Ctx.getMemoryManager(), Ctx.getJITLinkDylib());
+
+  if (Class == ELF::ELFCLASS32) {
+    if (Endian == ELF::ELFDATA2LSB)
+      return ELFDebugObject<ELF32LE>::Create(std::move(Buf), std::move(Seg));
+    if (Endian == ELF::ELFDATA2MSB)
+      return ELFDebugObject<ELF32BE>::Create(std::move(Buf), std::move(Seg));
+    return nullptr;
+  }
+  if (Class == ELF::ELFCLASS64) {
+    if (Endian == ELF::ELFDATA2LSB)
+      return ELFDebugObject<ELF64LE>::Create(std::move(Buf), std::move(Seg));
+    if (Endian == ELF::ELFDATA2MSB)
+      return ELFDebugObject<ELF64BE>::Create(std::move(Buf), std::move(Seg));
+    return nullptr;
+  }
+  return nullptr;
+}
+
+Expected<std::unique_ptr<DebugObject>>
+createDebugObjectFromBuffer(const Triple &TT, JITLinkContext &Ctx,
+                            std::unique_ptr<llvm::WritableMemoryBuffer> Buf) {
+  switch (TT.getObjectFormat()) {
+  case Triple::ELF:
+    return createDebugObjectELF(std::move(Buf), Ctx);
+
+  default:
+    // TODO: When adding support for other formats, make a new file for each.
+    return nullptr;
+  }
+}
+
+} // namespace jitlink
+} // namespace llvm

llvm/lib/ExecutionEngine/JITLink/JITLink.cpp

 //===------------- JITLink.cpp - Core Run-time JIT linker APIs ------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ExecutionEngine/JITLink/JITLink.h"
 
 #include "llvm/BinaryFormat/Magic.h"
+#include "llvm/ExecutionEngine/JITLink/DebugSupport.h"
 #include "llvm/ExecutionEngine/JITLink/ELF.h"
 #include "llvm/ExecutionEngine/JITLink/MachO.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
LinkGraphPassFunction JITLinkContext::getMarkLivePass(const Triple &TT) const {
   return LinkGraphPassFunction();
 }
 
 Error JITLinkContext::modifyPassConfig(const Triple &TT,
                                        PassConfiguration &Config) {
   return Error::success();
 }
 
+Expected<std::unique_ptr<DebugObject>>
+JITLinkContext::createDebugObject(LinkGraph &G) {
+  return nullptr;
+}
+
 Error markAllSymbolsLive(LinkGraph &G) {
   for (auto *Sym : G.defined_symbols())
     Sym->setLive(true);
   return Error::success();
 }
 
 Expected<std::unique_ptr<LinkGraph>>
 createLinkGraphFromObject(MemoryBufferRef ObjectBuffer) {

llvm/lib/ExecutionEngine/Orc/CMakeLists.txt

 add_llvm_component_library(LLVMOrcJIT
   CompileOnDemandLayer.cpp
   CompileUtils.cpp
   Core.cpp
+  DebugObjectManagerPlugin.cpp
   DebugUtils.cpp
   ExecutionUtils.cpp
   IndirectionUtils.cpp
   IRCompileLayer.cpp
   IRTransformLayer.cpp
   JITTargetMachineBuilder.cpp
   LazyReexports.cpp
   Layer.cpp
   LLJIT.cpp
   MachOPlatform.cpp
   Mangling.cpp
   ObjectLinkingLayer.cpp
   ObjectTransformLayer.cpp
   OrcABISupport.cpp
   OrcV2CBindings.cpp
   RTDyldObjectLinkingLayer.cpp
   Speculation.cpp
   SpeculateAnalyses.cpp
   TargetProcessControl.cpp
   ThreadSafeModule.cpp
+  TPCDebugObjectRegistrar.cpp
   TPCDynamicLibrarySearchGenerator.cpp
   TPCEHFrameRegistrar.cpp
   TPCIndirectionUtils.cpp
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/ExecutionEngine/Orc
 
   DEPENDS
   intrinsics_gen

llvm/lib/ExecutionEngine/Orc/DebugObjectManagerPlugin.cpp

+//===---- DebugObjectManagerPlugin.h - JITLink debug objects ---*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ExecutionEngine/Orc/DebugObjectManagerPlugin.h"
+
+#include "llvm/Support/Memory.h"
+
+#define DEBUG_TYPE "orc"
+
+using namespace llvm::jitlink;
+
+namespace llvm {
+namespace orc {
+
+static ResourceKey getResourceKey(MaterializationResponsibility &MR) {
+  ResourceKey Key;
+  if (auto Err = MR.withResourceKeyDo([&](ResourceKey K) { Key = K; })) {
+    MR.getExecutionSession().reportError(std::move(Err));
+    return ResourceKey{};
+  }
+  assert(Key && "Invalid key");
+  return Key;
+}
+
+void DebugObjectManagerPlugin::notifyMaterializing(
+    MaterializationResponsibility &MR, LinkGraph &G, JITLinkContext &Ctx) {
+  std::lock_guard<std::mutex> Lock(PendingObjsLock);
+
+  // We should never have more than one pending debug object.
+  ResourceKey Key = getResourceKey(MR);
+  auto It = PendingObjs.find(Key);
+  if (It != PendingObjs.end()) {
+    ES.reportError(make_error<StringError>(
+        formatv("Materializing new LinkGraph '{0}' for pending resource: {1}",
+                G.getName(), Key),
+        inconvertibleErrorCode()));
+    return;
+  }
+
+  Expected<std::unique_ptr<DebugObject>> DebugObj = Ctx.createDebugObject(G);
+  if (!DebugObj) {
+    ES.reportError(DebugObj.takeError());
+    return;
+  }
+
+  // Not all link artifacts allow debugging.
+  if (*DebugObj)
+    PendingObjs[Key] = std::move(*DebugObj);
+}
+
+void DebugObjectManagerPlugin::modifyPassConfig(
+    MaterializationResponsibility &MR, const Triple &TT,
+    PassConfiguration &PassConfig) {
+  // Not all link artifacts have associated debug objects.
+  DebugObject *DebugObj = nullptr;
+  {
+    std::lock_guard<std::mutex> Lock(PendingObjsLock);
+    auto It = PendingObjs.find(getResourceKey(MR));
+    if (It == PendingObjs.end())
+      return;
+    DebugObj = It->second.get();
+  }
+  DebugObj->modifyPassConfig(TT, PassConfig);
+}
+
+void DebugObjectManagerPlugin::notifyLoaded(MaterializationResponsibility &MR) {
+  ResourceKey Key = getResourceKey(MR);
+  DebugObject *UnownedDebugObj = nullptr;
+  {
+    std::lock_guard<std::mutex> Lock(PendingObjsLock);
+    auto It = PendingObjs.find(Key);
+    if (It != PendingObjs.end()) {
+      UnownedDebugObj = It->second.release();
+      PendingObjs.erase(It);
+    }
+  }
+
+  // We released ownership of DebugObj, so we can easily capture the raw pointer
+  // in the continuation function, which re-owns it immediately.
+  if (UnownedDebugObj)
+    UnownedDebugObj->finalizeAsync(
+        [this, Key, UnownedDebugObj](Expected<sys::MemoryBlock> TargetMem) {
+          std::unique_ptr<DebugObject> ReownedDebugObj(UnownedDebugObj);
+          if (!TargetMem) {
+            ES.reportError(TargetMem.takeError());
+            return;
+          }
+          if (Error Err = Target->registerDebugObject(*TargetMem)) {
+            ES.reportError(std::move(Err));
+            return;
+          }
+
+          std::lock_guard<std::mutex> Lock(RegisteredObjsLock);
+          RegisteredObjs[Key].push_back(std::move(ReownedDebugObj));
+        });
+}
+
+Error DebugObjectManagerPlugin::notifyFailed(
+    MaterializationResponsibility &MR) {
+  std::lock_guard<std::mutex> Lock(PendingObjsLock);
+  PendingObjs.erase(getResourceKey(MR));
+  return Error::success();
+}
+
+void DebugObjectManagerPlugin::notifyTransferringResources(ResourceKey DstKey,
+                                                           ResourceKey SrcKey) {
+  {
+    std::lock_guard<std::mutex> Lock(RegisteredObjsLock);
+    auto SrcIt = RegisteredObjs.find(SrcKey);
+    if (SrcIt != RegisteredObjs.end()) {
+      for (std::unique_ptr<DebugObject> &Alloc : SrcIt->second)
+        RegisteredObjs[DstKey].push_back(std::move(Alloc));
+      RegisteredObjs.erase(SrcIt);
+    }
+  }
+  {
+    std::lock_guard<std::mutex> Lock(PendingObjsLock);
+    auto SrcIt = PendingObjs.find(SrcKey);
+    if (SrcIt != PendingObjs.end()) {
+      if (PendingObjs.count(DstKey)) {
+        ES.reportError(make_error<StringError>(
+            formatv(
+                "Destination '{0}' for transferring pending debug object has "
+                "a pending resource already: {1}",
+                DstKey, SrcKey),
+            inconvertibleErrorCode()));
+      } else {
+        PendingObjs[DstKey] = std::move(SrcIt->second);
+        PendingObjs.erase(SrcIt);
+      }
+    }
+  }
+}
+
+Error DebugObjectManagerPlugin::notifyRemovingResources(ResourceKey K) {
+  {
+    std::lock_guard<std::mutex> Lock(RegisteredObjsLock);
+    RegisteredObjs.erase(K);
+    // TODO: Implement unregister notifications.
+  }
+  std::lock_guard<std::mutex> Lock(PendingObjsLock);
+  PendingObjs.erase(K);
+
+  return Error::success();
+}
+
+} // namespace orc
+} // namespace llvm

llvm/lib/ExecutionEngine/Orc/ObjectLinkingLayer.cpp

 //===------- ObjectLinkingLayer.cpp - JITLink backed ORC ObjectLayer ------===//
 //
 // 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 "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"
 
 #include "llvm/ADT/Optional.h"
+#include "llvm/ExecutionEngine/JITLink/DebugSupport.h"
 #include "llvm/ExecutionEngine/JITLink/EHFrameSupport.h"
+#include "llvm/Support/Errc.h"
+#include "llvm/Support/MemoryBuffer.h"
 
 #include <vector>
 
 #define DEBUG_TYPE "orc"
 
 using namespace llvm;
 using namespace llvm::jitlink;
 using namespace llvm::orc;
~ObjectLinkingLayerJITLinkContext() {
     // If there is an object buffer return function then use it to
     // return ownership of the buffer.
     if (Layer.ReturnObjectBuffer && ObjBuffer)
       Layer.ReturnObjectBuffer(std::move(ObjBuffer));
   }
 
   JITLinkMemoryManager &getMemoryManager() override { return Layer.MemMgr; }
 
+  void notifyMaterializing(LinkGraph &G) override {
+    for (auto &P : Layer.Plugins)
+      P->notifyMaterializing(*MR, G, *this);
+  }
+
   void notifyFailed(Error Err) override {
     for (auto &P : Layer.Plugins)
       Err = joinErrors(std::move(Err), P->notifyFailed(*MR));
     Layer.getExecutionSession().reportError(std::move(Err));
     MR->failMaterialization();
   }
 
   void lookup(const LookupMap &Symbols,
for (auto &NamedDepsEntry : ExternalNamedSymbolDeps) {
         if (DepsForJD.empty())
           SymbolDeps.erase(&SourceJD);
       }
 
       MR->addDependencies(Name, SymbolDeps);
     }
   }
 
+  Expected<std::unique_ptr<DebugObject>>
+  createDebugObject(LinkGraph &G) override {
+    StringRef Obj = ObjBuffer->getBuffer();
+
+    std::unique_ptr<llvm::WritableMemoryBuffer> DebugObj =
+        WritableMemoryBuffer::getNewUninitMemBuffer(Obj.size(), G.getName());
+    if (DebugObj == nullptr)
+      return errorCodeToError(make_error_code(errc::not_enough_memory));
+
+    memcpy(DebugObj->getBufferStart(), Obj.data(), Obj.size());
+    return jitlink::createDebugObjectFromBuffer(G.getTargetTriple(), *this,
+                                                std::move(DebugObj));
+  }
+
   ObjectLinkingLayer &Layer;
   std::unique_ptr<MaterializationResponsibility> MR;
   std::unique_ptr<MemoryBuffer> ObjBuffer;
   DenseMap<SymbolStringPtr, SymbolNameSet> ExternalNamedSymbolDeps;
   DenseMap<SymbolStringPtr, SymbolNameSet> InternalNamedSymbolDeps;
 };
 
 ObjectLinkingLayer::Plugin::~Plugin() {}

 ObjectLinkingLayer::~ObjectLinkingLayer() {
   assert(Allocs.empty() && "Layer destroyed with resources still attached");
   getExecutionSession().deregisterResourceManager(*this);
 }
 
 void ObjectLinkingLayer::emit(std::unique_ptr<MaterializationResponsibility> R,
                               std::unique_ptr<MemoryBuffer> O) {
   assert(O && "Object must not be null");
-  auto ObjBuffer = O->getMemBufferRef();
+  MemoryBufferRef ObjBuffer = O->getMemBufferRef();
+
   auto Ctx = std::make_unique<ObjectLinkingLayerJITLinkContext>(
       *this, std::move(R), std::move(O));
-  if (auto G = createLinkGraphFromObject(std::move(ObjBuffer)))
+  if (auto G = createLinkGraphFromObject(ObjBuffer)) {
+    Ctx->notifyMaterializing(**G);
     link(std::move(*G), std::move(Ctx));
-  else
+  } else {
     Ctx->notifyFailed(G.takeError());
   }
+}
 
 void ObjectLinkingLayer::emit(std::unique_ptr<MaterializationResponsibility> R,
                               std::unique_ptr<LinkGraph> G) {
-  link(std::move(G), std::make_unique<ObjectLinkingLayerJITLinkContext>(
-                         *this, std::move(R), nullptr));
+  auto Ctx = std::make_unique<ObjectLinkingLayerJITLinkContext>(
+      *this, std::move(R), nullptr);
+  Ctx->notifyMaterializing(*G);
+  link(std::move(G), std::move(Ctx));
 }
 
 void ObjectLinkingLayer::modifyPassConfig(MaterializationResponsibility &MR,
                                           const Triple &TT,
                                           PassConfiguration &PassConfig) {
   for (auto &P : Plugins)
     P->modifyPassConfig(MR, TT, PassConfig);
 }

llvm/lib/ExecutionEngine/Orc/TPCDebugObjectRegistrar.cpp

+//===----- TPCDebugObjectRegistrar.cpp - TPC-based debug registration -----===//
+//
+// 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 "llvm/ExecutionEngine/Orc/TPCDebugObjectRegistrar.h"
+
+#include "llvm/ExecutionEngine/Orc/Core.h"
+#include "llvm/ExecutionEngine/Orc/TargetProcess/JITLoaderGDB.h"
+#include "llvm/Support/BinaryStreamWriter.h"
+
+namespace llvm {
+namespace orc {
+
+// Counterpart of readDebugObjectInfo() function in TargetProcess/JITLoaderGDB.h
+static std::vector<uint8_t>
+writeDebugObjectInfo(sys::MemoryBlock TargetMemBlock) {
+  auto DebugObjAddr = pointerToJITTargetAddress(TargetMemBlock.base());
+  uint64_t DebugObjSize = TargetMemBlock.allocatedSize();
+
+  std::vector<uint8_t> ArgBuffer;
+  ArgBuffer.resize(sizeof(decltype(DebugObjAddr)) +
+                   sizeof(decltype(DebugObjSize)));
+
+  BinaryStreamWriter ArgWriter(ArgBuffer, support::endianness::big);
+  cantFail(ArgWriter.writeInteger(DebugObjAddr));
+  cantFail(ArgWriter.writeInteger(DebugObjSize));
+
+  return ArgBuffer;
+}
+
+Expected<std::unique_ptr<TPCDebugObjectRegistrar>>
+createJITLoaderGDBRegistrar(TargetProcessControl &TPC) {
+  auto ProcessHandle = TPC.loadDylib(nullptr);
+  if (!ProcessHandle)
+    return ProcessHandle.takeError();
+
+  SymbolStringPtr RegisterFn =
+      TPC.getTargetTriple().isOSBinFormatMachO()
+          ? TPC.intern("_llvm_orc_registerJITLoaderGDBWrapper")
+          : TPC.intern("llvm_orc_registerJITLoaderGDBWrapper");
+
+  SymbolLookupSet RegistrationSymbols;
+  RegistrationSymbols.add(RegisterFn);
+
+  auto Result = TPC.lookupSymbols({{*ProcessHandle, RegistrationSymbols}});
+  if (!Result)
+    return Result.takeError();
+
+  assert(Result->size() == 1 && "Unexpected number of dylibs in result");
+  assert((*Result)[0].size() == 1 &&
+         "Unexpected number of addresses in result");
+
+  return std::make_unique<TPCDebugObjectRegistrar>(TPC, (*Result)[0][0],
+                                                   &writeDebugObjectInfo);
+}
+
+} // namespace orc
+} // namespace llvm

llvm/lib/ExecutionEngine/Orc/TargetProcess/CMakeLists.txt

 add_llvm_component_library(LLVMOrcTargetProcess
+  JITLoaderGDB.cpp
   RegisterEHFrames.cpp
   TargetExecutionUtils.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/ExecutionEngine/Orc
 
   LINK_COMPONENTS
   OrcShared
   Support
   )

llvm/lib/ExecutionEngine/Orc/TargetProcess/JITLoaderGDB.cpp

+//===- JITLoaderGDB.h - Register objects via GDB JIT interface -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ExecutionEngine/Orc/TargetProcess/JITLoaderGDB.h"
+
+#include "llvm/ExecutionEngine/JITSymbol.h"
+#include "llvm/Support/BinaryStreamReader.h"
+#include "llvm/Support/ManagedStatic.h"
+
+#include <cstdint>
+#include <mutex>
+#include <utility>
+
+#define DEBUG_TYPE "orc"
+
+// First version as landed in August 2009
+static constexpr uint32_t JitDescriptorVersion = 1;
+
+// Keep in sync with gdb/gdb/jit.h
+extern "C" {
+
+typedef enum {
+  JIT_NOACTION = 0,
+  JIT_REGISTER_FN,
+  JIT_UNREGISTER_FN
+} jit_actions_t;
+
+struct jit_code_entry {
+  struct jit_code_entry *next_entry;
+  struct jit_code_entry *prev_entry;
+  const char *symfile_addr;
+  uint64_t symfile_size;
+};
+
+struct jit_descriptor {
+  uint32_t version;
+  // This should be jit_actions_t, but we want to be specific about the
+  // bit-width.
+  uint32_t action_flag;
+  struct jit_code_entry *relevant_entry;
+  struct jit_code_entry *first_entry;
+};
+
+// We put information about the JITed function in this global, which the
+// debugger reads.  Make sure to specify the version statically, because the
+// debugger checks the version before we can set it during runtime.
+struct jit_descriptor __jit_debug_descriptor = {JitDescriptorVersion, 0,
+                                                nullptr, nullptr};
+
+// Debuggers that implement the GDB JIT interface put a special breakpoint in
+// this function.
+LLVM_ATTRIBUTE_NOINLINE void __jit_debug_register_code() {
+  // The noinline and the asm prevent calls to this function from being
+  // optimized out.
+#if !defined(_MSC_VER)
+  asm volatile("" ::: "memory");
+#endif
+}
+}
+
+using namespace llvm;
+using namespace llvm::orc;
+using namespace llvm::orc::tpctypes;
+
+// Serialize rendezvous with the debugger as well as access to shared data.
+ManagedStatic<std::mutex> JITDebugLock;
+
+static std::pair<const char *, uint64_t> readDebugObjectInfo(uint8_t *ArgData,
+                                                             uint64_t ArgSize) {
+  BinaryStreamReader ArgReader(ArrayRef<uint8_t>(ArgData, ArgSize),
+                               support::endianness::big);
+  uint64_t Addr, Size;
+  cantFail(ArgReader.readInteger(Addr));
+  cantFail(ArgReader.readInteger(Size));
+
+  return std::make_pair(jitTargetAddressToPointer<const char *>(Addr), Size);
+}
+
+extern "C" CWrapperFunctionResult
+llvm_orc_registerJITLoaderGDBWrapper(uint8_t *Data, uint64_t Size) {
+  if (Size != sizeof(uint64_t) + sizeof(uint64_t))
+    return WrapperFunctionResult::from(
+               "Invalid arguments to llvm_orc_registerJITLoaderGDBWrapper")
+        .release();
+
+  jit_code_entry *E = new jit_code_entry;
+  std::tie(E->symfile_addr, E->symfile_size) = readDebugObjectInfo(Data, Size);
+  E->prev_entry = nullptr;
+
+  std::lock_guard<std::mutex> Lock(*JITDebugLock);
+
+  // Insert this entry at the head of the list.
+  jit_code_entry *NextEntry = __jit_debug_descriptor.first_entry;
+  E->next_entry = NextEntry;
+  if (NextEntry) {
+    NextEntry->prev_entry = E;
+  }
+
+  __jit_debug_descriptor.first_entry = E;
+  __jit_debug_descriptor.relevant_entry = E;
+
+  // Run into the rendezvous breakpoint.
+  __jit_debug_descriptor.action_flag = JIT_REGISTER_FN;
+  __jit_debug_register_code();
+
+  return WrapperFunctionResult().release();
+}

llvm/tools/llvm-jitlink/llvm-jitlink-executor/llvm-jitlink-executor.cpp

 //===- llvm-jitlink-executor.cpp - Out-of-proc executor for llvm-jitlink -===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Simple out-of-process executor for llvm-jitlink.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ExecutionEngine/Orc/Shared/FDRawByteChannel.h"
+#include "llvm/ExecutionEngine/Orc/TargetProcess/JITLoaderGDB.h"
 #include "llvm/ExecutionEngine/Orc/TargetProcess/OrcRPCTPCServer.h"
 #include "llvm/ExecutionEngine/Orc/TargetProcess/RegisterEHFrames.h"
 #include "llvm/Support/DynamicLibrary.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/raw_ostream.h"
 #include <sstream>
 
 #ifdef LLVM_ON_UNIX
 
 #include <netinet/in.h>
 #include <sys/socket.h>
 
 #endif
 
 using namespace llvm;
 using namespace llvm::orc;
 
 ExitOnError ExitOnErr;
 
 LLVM_ATTRIBUTE_USED void linkComponents() {
   errs() << (void *)&llvm_orc_registerEHFrameSectionWrapper
-         << (void *)&llvm_orc_deregisterEHFrameSectionWrapper;
+         << (void *)&llvm_orc_deregisterEHFrameSectionWrapper
+         << (void *)&llvm_orc_registerJITLoaderGDBWrapper;
 }
 
 void printErrorAndExit(Twine ErrMsg) {
   errs() << "error: " << ErrMsg.str() << "\n\n"
          << "Usage:\n"
          << "  llvm-jitlink-executor filedescs=<infd>,<outfd> [args...]\n"
          << "  llvm-jitlink-executor listen=<host>:<port> [args...]\n";
   exit(1);

llvm/tools/llvm-jitlink/llvm-jitlink.cpp

 // library, which makes relocatable object files executable in memory. Its
 // primary function is as a testing utility for the jitlink library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm-jitlink.h"
 
 #include "llvm/BinaryFormat/Magic.h"
+#include "llvm/ExecutionEngine/Orc/DebugObjectManagerPlugin.h"
 #include "llvm/ExecutionEngine/Orc/ExecutionUtils.h"
+#include "llvm/ExecutionEngine/Orc/TPCDebugObjectRegistrar.h"
 #include "llvm/ExecutionEngine/Orc/TPCDynamicLibrarySearchGenerator.h"
 #include "llvm/ExecutionEngine/Orc/TPCEHFrameRegistrar.h"
+#include "llvm/ExecutionEngine/Orc/TargetProcess/JITLoaderGDB.h"
+#include "llvm/ExecutionEngine/Orc/TargetProcess/RegisterEHFrames.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDisassembler/MCDisassembler.h"
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCTargetOptions.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Object/MachO.h"
 #include "llvm/Object/ObjectFile.h"
+#include "llvm/Support/BinaryStreamWriter.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/Timer.h"
static cl::opt<std::string> OutOfProcessExecutor(
     cl::ValueOptional);
 
 static cl::opt<std::string> OutOfProcessExecutorConnect(
     "oop-executor-connect",
     cl::desc("Connect to an out-of-process executor via TCP"));
 
 ExitOnError ExitOnErr;
 
+LLVM_ATTRIBUTE_USED void linkComponents() {
+  errs() << (void *)&llvm_orc_registerEHFrameSectionWrapper
+         << (void *)&llvm_orc_deregisterEHFrameSectionWrapper
+         << (void *)&llvm_orc_registerJITLoaderGDBWrapper;
+}
+
 namespace llvm {
 
 static raw_ostream &
 operator<<(raw_ostream &OS, const Session::MemoryRegionInfo &MRI) {
   return OS << "target addr = "
             << format("0x%016" PRIx64, MRI.getTargetAddress())
             << ", content: " << (const void *)MRI.getContent().data() << " -- "
             << (const void *)(MRI.getContent().data() + MRI.getContent().size())
else {
     Err = MainJDOrErr.takeError();
     return;
   }
 
   if (!NoExec && !this->TPC->getTargetTriple().isOSWindows())
     ObjLayer.addPlugin(std::make_unique<EHFrameRegistrationPlugin>(
         ES, ExitOnErr(TPCEHFrameRegistrar::Create(*this->TPC))));
 
+  ObjLayer.addPlugin(std::make_unique<DebugObjectManagerPlugin>(
+      ES, ExitOnErr(createJITLoaderGDBRegistrar(*this->TPC))));
+
   ObjLayer.addPlugin(std::make_unique<JITLinkSessionPlugin>(*this));
 
   // Process any harness files.
   for (auto &HarnessFile : TestHarnesses) {
     HarnessFiles.insert(HarnessFile);
 
     auto ObjBuffer =
         ExitOnErr(errorOrToExpected(MemoryBuffer::getFile(HarnessFile)));