[JITLink] Introduce generic x86-64 support by refactoring MachO/x86-64.

[lhames]

Summary

This patch refactors the MachO/x86-64 implementation of JITLink to replace the
MachO-specific edge kinds with generic x86-64 edges and fixup expressions. The
new, generic x86-64 edge kinds should be re-usable for other formats (ELF, and
COFF if/when support for that is added) and simplify the writing of format
agnostic (but architecture specific) JITLink passes.

[sgraenitz]

Factoring out architecture specific code sounds like a reasonable approach to reduce code duplication across the JITLink backends. As far as I can see, the patch only ports the MachOJITLinker_x86_64 to use the generic functionality. The ELFJITLinker_x86_64 mostly remains unchanged. Is there a conceptual reason for it or would that be a rather straightforward next step?

What I am not sure I understand yet is how endianness is handled in this scheme. The new applyFixup() function is using hard casts to little-endian when writing fixup values into memory. Is that because addRelocations() is supposed to populate the fixup values with the correct endian already? I think the ELF implementation didn't consider it at all so far, so there is no loss of functionality. Just asking for interest.

Great documentation for the edge kinds!

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

207

Typo: from

[lhames]

In D98305#2619857, @sgraenitz wrote:

Factoring out architecture specific code sounds like a reasonable approach to reduce code duplication across the JITLink backends. As far as I can see, the patch only ports the MachOJITLinker_x86_64 to use the generic functionality. The ELFJITLinker_x86_64 mostly remains unchanged. Is there a conceptual reason for it or would that be a rather straightforward next step?

Yes -- that's a logical next step. I know @jaredwy is working on a refactor of the ELF/x86-64 backend to extract a generic ELF graph builder at the moment, so I wanted to hold off on any changes to the ELF backend in case they interfered with his work.

What I am not sure I understand yet is how endianness is handled in this scheme. The new applyFixup() function is using hard casts to little-endian when writing fixup values into memory. Is that because addRelocations() is supposed to populate the fixup values with the correct endian already? I think the ELF implementation didn't consider it at all so far, so there is no loss of functionality. Just asking for interest.

There is a hard (but poorly documented) boundary here: Linker *working memory* (block content) should always be in the executor's (target's) endianness, hence the hard casts here. That's because it comes from the object file (which is in the executor's endianness) and will be transferred byte-for-byte to the executor. All other graph values including symbol and block addresses should be in the host's endianness to avoid any unnecessary conversions during arithmetic. Conversions to/from executor endianness should be done on write/reads of working memory only.

Great documentation for the edge kinds!

Thanks!

[sgraenitz]

Thanks for elaborating. LGTM

[NathanielMcVicar]

I believe this change, or one of the subsequent ones (I can't find them on Differential, sorry), broke a test on the Windows Debug build.

Failed Tests (1):
  LLVM :: ExecutionEngine/JITLink/X86/ELF_skip_debug_sections.s

Here's the trace:

E:\llvm-project-merge\build_windows>"e:\llvm-project-merge\build_windows\bin\llvm-jitlink.exe" "-debug-only=jitlink" "-noexec" "E:\llvm-project-merge\build_windows\test\ExecutionEngine\JITLink\X86\Output\ELF_skip_debug_sections.s.tmp"
Building jitlink graph for new input E:\llvm-project-merge\build_windows\test\ExecutionEngine\JITLink\X86\Output\ELF_skip_debug_sections.s.tmp...
Creating normalized sections...
  .strtab: 0x0000000000000000 -- 0x00000000000000ab, align: 1 Flags: 0x0
  .text: 0x0000000000000000 -- 0x0000000000000016, align: 16 Flags: 0x6
.debug_str is a debug section: No graph section will be created.
.debug_abbrev is a debug section: No graph section will be created.
.debug_info is a debug section: No graph section will be created.
  .rela.debug_info: 0x0000000000000000 -- 0x0000000000000150, align: 8 Flags: 0x0
  .comment: 0x0000000000000000 -- 0x0000000000000020, align: 1 Flags: 0x30
.debug_line is a debug section: No graph section will be created.
  .rela.debug_line: 0x0000000000000000 -- 0x0000000000000018, align: 8 Flags: 0x0
  .eh_frame: 0x0000000000000000 -- 0x0000000000000040, align: 8 Flags: 0x2
  .rela.eh_frame: 0x0000000000000000 -- 0x0000000000000030, align: 8 Flags: 0x0
  .symtab: 0x0000000000000000 -- 0x00000000000000c0, align: 8 Flags: 0x0
Creating normalized symbols...
  value = 0x0000000000000000, type = 0x00, binding = 0x00, size = 0x0000000000000000, info = 0x00 :
  value = 0x0000000000000000, type = 0x04, binding = 0x00, size = 0x0000000000000000, info = 0x04 :ELF_skip_debug_sections.c
  value = 0x0000000000000000, type = 0x03, binding = 0x00, size = 0x0000000000000000, info = 0x03 :
  value = 0x0000000000000000, type = 0x03, binding = 0x00, size = 0x0000000000000000, info = 0x03 :
  value = 0x0000000000000000, type = 0x03, binding = 0x00, size = 0x0000000000000000, info = 0x03 :
  value = 0x0000000000000000, type = 0x03, binding = 0x00, size = 0x0000000000000000, info = 0x03 :
  value = 0x0000000000000000, type = 0x02, binding = 0x01, size = 0x0000000000000006, info = 0x12 :foo
  value = 0x0000000000000010, type = 0x02, binding = 0x01, size = 0x0000000000000006, info = 0x12 :main
Creating graph symbols...
Processing symbol section .symtab:
   at index 2
  foo at index 6
  main at index 7
Adding relocations
Adding relocations from section .rela.debug_info
  Target is dwarf section .debug_info. Skipping.
Adding relocations from section .rela.debug_line
  Target is dwarf section .debug_line. Skipping.
Adding relocations from section .rela.eh_frame
  For target section .eh_frame
Relocation Type: 2
Name: R_X86_64_PC32
Processing relocation at 0x0000000000000020
edge@0x0000000000000020: 0x0000000000000000 + 0x20 -- PCRel32 -> .text
Relocation Type: 2
Name: R_X86_64_PC32
Processing relocation at 0x0000000000000034
edge@0x0000000000000034: 0x0000000000000000 + 0x34 -- PCRel32 -> .text + 16
Starting link phase 1 for graph E:\llvm-project-merge\build_windows\test\ExecutionEngine\JITLink\X86\Output\ELF_skip_debug_sections.s.tmp
EHFrameSplitter: Processing .eh_frame...
  Processing block at 0x0000000000000000
    Processing CFI record at 0x0000000000000000
      Extracted 0x0000000000000000 -- 0x00000018: size = 0x00000018, content, align = 8, align-ofs = 0, section = .eh_frame
    Processing CFI record at 0x0000000000000018
      Extracted 0x0000000000000018 -- 0x0000002c: size = 0x00000014, content, align = 8, align-ofs = 0, section = .eh_frame
    Processing CFI record at 0x000000000000002c
      Extracted 0x000000000000002c -- 0x00000040: size = 0x00000014, content, align = 8, align-ofs = 4, section = .eh_frame
EHFrameEdgeFixer: Processing .eh_frame...
  Processing block at 0x0000000000000000
    Processing CFI record at 0x0000000000000000
      Record is CIE
  Processing block at 0x0000000000000018
    Processing CFI record at 0x0000000000000018
      Record is FDE
        Adding edge at 0x000000000000001c to CIE at: 0x0000000000000000
        Already has edge at 0x0000000000000020 to PC at 0x0000000000000000
        Adding keep-alive edge from target at 0x0000000000000000 to FDE at 0x0000000000000018
        Record does not have LSDA field.
  Processing block at 0x000000000000002c
    Processing CFI record at 0x000000000000002c
      Record is FDE
        Adding edge at 0x0000000000000030 to CIE at: 0x0000000000000000
        Already has edge at 0x0000000000000034 to PC at 0x0000000000000000 + 0x0000000000000010
        Adding keep-alive edge from target at 0x0000000000000000 to FDE at 0x000000000000002c
        Record does not have LSDA field.
EHFrameNullTerminator adding null terminator to .eh_frame
Link graph "E:\llvm-project-merge\build_windows\test\ExecutionEngine\JITLink\X86\Output\ELF_skip_debug_sections.s.tmp" pre-pruning:
PLEASE submit a bug report to https://bugs.llvm.org/ and include the crash backtrace.
Stack dump:
0.      Program arguments: e:\\llvm-project-merge\\build_windows\\bin\\llvm-jitlink.exe -debug-only=jitlink -noexec E:\\llvm-project-merge\\build_windows\\test\\ExecutionEngine\\JITLink\\X86\\Output\\ELF_skip_debug_sections.s.tmp
 #0 0x00007ff7a1cbb55e std::_Debug_lt_pred<<lambda_7aeefcb115b0a8ce43b4c96fdac18921> &,llvm::jitlink::Symbol * &,llvm::jitlink::Symbol * &,0> C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Tools\MSVC\14.28.29910\include\xutility:1626:0
 #1 0x00007ff7a1cbccc0 std::_Insertion_sort_unchecked<llvm::jitlink::Symbol * *,<lambda_7aeefcb115b0a8ce43b4c96fdac18921> > C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Tools\MSVC\14.28.29910\include\algorithm:7361:0
 #2 0x00007ff7a1cc0a8c std::_Sort_unchecked<llvm::jitlink::Symbol * *,<lambda_7aeefcb115b0a8ce43b4c96fdac18921> > C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Tools\MSVC\14.28.29910\include\algorithm:7486:0
 #3 0x00007ff7a1cc487e std::sort<std::_Vector_iterator<std::_Vector_val<std::_Simple_types<llvm::jitlink::Symbol *> > >,<lambda_7aeefcb115b0a8ce43b4c96fdac18921> > C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Tools\MSVC\14.28.29910\include\algorithm:7516:0
 #4 0x00007ff7a1cc47a1 llvm::sort<std::_Vector_iterator<std::_Vector_val<std::_Simple_types<llvm::jitlink::Symbol *> > >,<lambda_7aeefcb115b0a8ce43b4c96fdac18921> > E:\llvm-project-merge\llvm\include\llvm\ADT\STLExtras.h:1449:0
 #5 0x00007ff7a1cc436b llvm::sort<std::vector<llvm::jitlink::Symbol *,std::allocator<llvm::jitlink::Symbol *> > &,<lambda_7aeefcb115b0a8ce43b4c96fdac18921> > E:\llvm-project-merge\llvm\include\llvm\ADT\STLExtras.h:1454:0
 #6 0x00007ff7a1cb6822 llvm::jitlink::LinkGraph::dump(class llvm::raw_ostream &) E:\llvm-project-merge\llvm\lib\ExecutionEngine\JITLink\JITLink.cpp:252:0
 #7 0x00007ff7a1d35ca3 llvm::jitlink::JITLinkerBase::linkPhase1(class std::unique_ptr<class llvm::jitlink::JITLinkerBase, struct std::default_delete<class llvm::jitlink::JITLinkerBase>>) E:\llvm-project-merge\llvm\lib\ExecutionEngine\JITLink\JITLinkGeneric.cpp:35:0
 #8 0x00007ff7a1ce238d llvm::jitlink::JITLinker<class llvm::jitlink::ELFJITLinker_x86_64>::link<class std::unique_ptr<class llvm::jitlink::JITLinkContext, struct std::default_delete<class llvm::jitlink::JITLinkContext>>, class std::unique_ptr<class llvm::jitlink::LinkGraph, struct std::default_delete<class llvm::jitlink::LinkGraph>>, struct llvm::jitlink::PassConfiguration>(class std::unique_ptr<class llvm::jitlink::JITLinkContext, struct std::default_delete<class llvm::jitlink::JITLinkContext>> &&, class std::unique_ptr<class llvm::jitlink::LinkGraph, struct std::default_delete<class llvm::jitlink::LinkGraph>> &&, struct llvm::jitlink::PassConfiguration &&) E:\llvm-project-merge\llvm\lib\ExecutionEngine\JITLink\JITLinkGeneric.h:140:0
 #9 0x00007ff7a1cd46d6 llvm::jitlink::link_ELF_x86_64(class std::unique_ptr<class llvm::jitlink::LinkGraph, struct std::default_delete<class llvm::jitlink::LinkGraph>>, class std::unique_ptr<class llvm::jitlink::JITLinkContext, struct std::default_delete<class llvm::jitlink::JITLinkContext>>) E:\llvm-project-merge\llvm\lib\ExecutionEngine\JITLink\ELF_x86_64.cpp:931:0
#10 0x00007ff7a1cd0411 llvm::jitlink::link_ELF(class std::unique_ptr<class llvm::jitlink::LinkGraph, struct std::default_delete<class llvm::jitlink::LinkGraph>>, class std::unique_ptr<class llvm::jitlink::JITLinkContext, struct std::default_delete<class llvm::jitlink::JITLinkContext>>) E:\llvm-project-merge\llvm\lib\ExecutionEngine\JITLink\ELF.cpp:81:0
#11 0x00007ff7a1cb7ff0 llvm::jitlink::link(class std::unique_ptr<class llvm::jitlink::LinkGraph, struct std::default_delete<class llvm::jitlink::LinkGraph>>, class std::unique_ptr<class llvm::jitlink::JITLinkContext, struct std::default_delete<class llvm::jitlink::JITLinkContext>>) E:\llvm-project-merge\llvm\lib\ExecutionEngine\JITLink\JITLink.cpp:409:0
#12 0x00007ff7a219660f llvm::orc::ObjectLinkingLayer::emit(class std::unique_ptr<class llvm::orc::MaterializationResponsibility, struct std::default_delete<class llvm::orc::MaterializationResponsibility>>, class std::unique_ptr<class llvm::MemoryBuffer, struct std::default_delete<class llvm::MemoryBuffer>>) E:\llvm-project-merge\llvm\lib\ExecutionEngine\Orc\ObjectLinkingLayer.cpp:602:0
#13 0x00007ff7a218dfa8 llvm::orc::BasicObjectLayerMaterializationUnit::materialize(class std::unique_ptr<class llvm::orc::MaterializationResponsibility, struct std::default_delete<class llvm::orc::MaterializationResponsibility>>) E:\llvm-project-merge\llvm\lib\ExecutionEngine\Orc\Layer.cpp:205:0
#14 0x00007ff7a210da99 llvm::orc::MaterializationTask::run(void) E:\llvm-project-merge\llvm\lib\ExecutionEngine\Orc\Core.cpp:1760:0
#15 0x00007ff7a2185d8d llvm::orc::ExecutionSession::runOnCurrentThread(class std::unique_ptr<class llvm::orc::Task, struct std::default_delete<class llvm::orc::Task>>) E:\llvm-project-merge\llvm\include\llvm\ExecutionEngine\Orc\Core.h:1429:0
#16 0x00007ff7a211c098 llvm::detail::UniqueFunctionBase<void, class std::unique_ptr<class llvm::orc::Task, struct std::default_delete<class llvm::orc::Task>>>::CallImpl<void (__cdecl *)(class std::unique_ptr<class llvm::orc::Task, struct std::default_delete<class llvm::orc::Task>>)>(void *, class std::unique_ptr<class llvm::orc::Task, struct std::default_delete<class llvm::orc::Task>> &) E:\llvm-project-merge\llvm\include\llvm\ADT\FunctionExtras.h:206:0
#17 0x00007ff7a215c008 llvm::unique_function<(class std::unique_ptr<class llvm::orc::Task, struct std::default_delete<class llvm::orc::Task>>)>::operator()(class std::unique_ptr<class llvm::orc::Task, struct std::default_delete<class llvm::orc::Task>>) E:\llvm-project-merge\llvm\include\llvm\ADT\FunctionExtras.h:367:0
#18 0x00007ff7a217332c llvm::orc::ExecutionSession::dispatchTask(class std::unique_ptr<class llvm::orc::Task, struct std::default_delete<class llvm::orc::Task>>) E:\llvm-project-merge\llvm\include\llvm\ExecutionEngine\Orc\Core.h:1419:0
#19 0x00007ff7a210f147 llvm::orc::ExecutionSession::dispatchOutstandingMUs(void) E:\llvm-project-merge\llvm\lib\ExecutionEngine\Orc\Core.cpp:2035:0
#20 0x00007ff7a2110edf llvm::orc::ExecutionSession::OL_completeLookup(class std::unique_ptr<class llvm::orc::InProgressLookupState, struct std::default_delete<class llvm::orc::InProgressLookupState>>, class std::shared_ptr<class llvm::orc::AsynchronousSymbolQuery>, class std::function<(class llvm::DenseMap<class llvm::orc::JITDylib *, class llvm::DenseSet<class llvm::orc::SymbolStringPtr, struct llvm::DenseMapInfo<class llvm::orc::SymbolStringPtr>>, struct llvm::DenseMapInfo<class llvm::orc::JITDylib *>, struct llvm::detail::DenseMapPair<class llvm::orc::JITDylib *, class llvm::DenseSet<class llvm::orc::SymbolStringPtr, struct llvm::DenseMapInfo<class llvm::orc::SymbolStringPtr>>>> const &)>) E:\llvm-project-merge\llvm\lib\ExecutionEngine\Orc\Core.cpp:2565:0
#21 0x00007ff7a2171408 llvm::orc::InProgressFullLookupState::complete(class std::unique_ptr<class llvm::orc::InProgressLookupState, struct std::default_delete<class llvm::orc::InProgressLookupState>>) E:\llvm-project-merge\llvm\lib\ExecutionEngine\Orc\Core.cpp:550:0
#22 0x00007ff7a2110995 llvm::orc::ExecutionSession::OL_applyQueryPhase1(class std::unique_ptr<class llvm::orc::InProgressLookupState, struct std::default_delete<class llvm::orc::InProgressLookupState>>, class llvm::Error) E:\llvm-project-merge\llvm\lib\ExecutionEngine\Orc\Core.cpp:2321:0
#23 0x00007ff7a210e6c1 llvm::orc::ExecutionSession::lookup(enum llvm::orc::LookupKind, class std::vector<struct std::pair<class llvm::orc::JITDylib *, enum llvm::orc::JITDylibLookupFlags>, class std::allocator<struct std::pair<class llvm::orc::JITDylib *, enum llvm::orc::JITDylibLookupFlags>>> const &, class llvm::orc::SymbolLookupSet, enum llvm::orc::SymbolState, class llvm::unique_function<(class llvm::Expected<class llvm::DenseMap<class llvm::orc::SymbolStringPtr, class llvm::JITEvaluatedSymbol, struct llvm::DenseMapInfo<class llvm::orc::SymbolStringPtr>, struct llvm::detail::DenseMapPair<class llvm::orc::SymbolStringPtr, class llvm::JITEvaluatedSymbol>>>)>, class std::function<(class llvm::DenseMap<class llvm::orc::JITDylib *, class llvm::DenseSet<class llvm::orc::SymbolStringPtr, struct llvm::DenseMapInfo<class llvm::orc::SymbolStringPtr>>, struct llvm::DenseMapInfo<class llvm::orc::JITDylib *>, struct llvm::detail::DenseMapPair<class llvm::orc::JITDylib *, class llvm::DenseSet<class llvm::orc::SymbolStringPtr, struct llvm::DenseMapInfo<class llvm::orc::SymbolStringPtr>>>> const &)>) E:\llvm-project-merge\llvm\lib\ExecutionEngine\Orc\Core.cpp:1925:0
#24 0x00007ff7a210e8a3 llvm::orc::ExecutionSession::lookup(class std::vector<struct std::pair<class llvm::orc::JITDylib *, enum llvm::orc::JITDylibLookupFlags>, class std::allocator<struct std::pair<class llvm::orc::JITDylib *, enum llvm::orc::JITDylibLookupFlags>>> const &, class llvm::orc::SymbolLookupSet const &, enum llvm::orc::LookupKind, enum llvm::orc::SymbolState, class std::function<(class llvm::DenseMap<class llvm::orc::JITDylib *, class llvm::DenseSet<class llvm::orc::SymbolStringPtr, struct llvm::DenseMapInfo<class llvm::orc::SymbolStringPtr>>, struct llvm::DenseMapInfo<class llvm::orc::JITDylib *>, struct llvm::detail::DenseMapPair<class llvm::orc::JITDylib *, class llvm::DenseSet<class llvm::orc::SymbolStringPtr, struct llvm::DenseMapInfo<class llvm::orc::SymbolStringPtr>>>> const &)>) E:\llvm-project-merge\llvm\lib\ExecutionEngine\Orc\Core.cpp:1966:0
#25 0x00007ff7a210eb10 llvm::orc::ExecutionSession::lookup(class std::vector<struct std::pair<class llvm::orc::JITDylib *, enum llvm::orc::JITDylibLookupFlags>, class std::allocator<struct std::pair<class llvm::orc::JITDylib *, enum llvm::orc::JITDylibLookupFlags>>> const &, class llvm::orc::SymbolStringPtr, enum llvm::orc::SymbolState) E:\llvm-project-merge\llvm\lib\ExecutionEngine\Orc\Core.cpp:1987:0
#26 0x00007ff7a210ed8a llvm::orc::ExecutionSession::lookup(class llvm::ArrayRef<class llvm::orc::JITDylib *>, class llvm::orc::SymbolStringPtr, enum llvm::orc::SymbolState) E:\llvm-project-merge\llvm\lib\ExecutionEngine\Orc\Core.cpp:1999:0
#27 0x00007ff7a210ee69 llvm::orc::ExecutionSession::lookup(class llvm::ArrayRef<class llvm::orc::JITDylib *>, class llvm::StringRef, enum llvm::orc::SymbolState) E:\llvm-project-merge\llvm\lib\ExecutionEngine\Orc\Core.cpp:2005:0
#28 0x00007ff7a1b9b192 getMainEntryPoint E:\llvm-project-merge\llvm\tools\llvm-jitlink\llvm-jitlink.cpp:1320:0
#29 0x00007ff7a1b9b72e main E:\llvm-project-merge\llvm\tools\llvm-jitlink\llvm-jitlink.cpp:1369:0
#30 0x00007ff7a32f7139 invoke_main D:\a01\_work\26\s\src\vctools\crt\vcstartup\src\startup\exe_common.inl:79:0
#31 0x00007ff7a32f701e __scrt_common_main_seh D:\a01\_work\26\s\src\vctools\crt\vcstartup\src\startup\exe_common.inl:288:0
#32 0x00007ff7a32f6ede __scrt_common_main D:\a01\_work\26\s\src\vctools\crt\vcstartup\src\startup\exe_common.inl:331:0
#33 0x00007ff7a32f71ce mainCRTStartup D:\a01\_work\26\s\src\vctools\crt\vcstartup\src\startup\exe_main.cpp:17:0
#34 0x00007ffc92777034 (C:\WINDOWS\System32\KERNEL32.DLL+0x17034)
#35 0x00007ffc92cc2651 (C:\WINDOWS\SYSTEM32\ntdll.dll+0x52651)

[lhames]

In D98305#2761113, @NathanielMcVicar wrote:

I believe this change, or one of the subsequent ones (I can't find them on Differential, sorry), broke a test on the Windows Debug build.

Failed Tests (1):
  LLVM :: ExecutionEngine/JITLink/X86/ELF_skip_debug_sections.s

Hi Nathaniel,

Where are you seeing this test fail? If it's failing on a Buildbot could you please share a link to a failed build? If it's failing locally, are you building top-of-tree, and what is your build configuration?

• Lang.

[NathanielMcVicar]

Hi Lang,

Unfortunately, I don't think there's currently a working bot running the LLVM tests on Windows. I can see the failure locally on my machine and in our internal CI, top of tree with the following configuration (host triple is x86_64-pc-windows-msvc):

-G Ninja -DCMAKE_BUILD_TYPE=Debug -DLLVM_ENABLE_PROJECTS=clang;lld;lldb;mlir -DLLVM_TARGETS_TO_BUILD=host -DLLDB_INCLUDE_TESTS=OFF -DLLVM_ENABLE_ASSERTIONS=ON

[lhames]

In D98305#2761733, @NathanielMcVicar wrote:

Hi Lang,

Unfortunately, I don't think there's currently a working bot running the LLVM tests on Windows. I can see the failure locally on my machine and in our internal CI, top of tree with the following configuration (host triple is x86_64-pc-windows-msvc):

-G Ninja -DCMAKE_BUILD_TYPE=Debug -DLLVM_ENABLE_PROJECTS=clang;lld;lldb;mlir -DLLVM_TARGETS_TO_BUILD=host -DLLDB_INCLUDE_TESTS=OFF -DLLVM_ENABLE_ASSERTIONS=ON

Hi Nathaniel,

I don't have access to a Windows machine to test on, but I think Dave Blaikie has spotted the bug -- A think-o in the existing comparator meant that it did not provide a strict weak ordering. Could you let you know if d1a7630369bc fixes the issue for you?

Thanks for reporting this, and thanks Dave for spotting the issue.

• Lang.

[NathanielMcVicar]

Yes, the fix works! Thanks again.

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

 Expected<std::unique_ptr<LinkGraph>>
 createLinkGraphFromELFObject_x86_64(MemoryBufferRef ObjectBuffer);
 
 /// jit-link the given object buffer, which must be a ELF x86-64 object file.
 void link_ELF_x86_64(std::unique_ptr<LinkGraph> G,
                      std::unique_ptr<JITLinkContext> Ctx);
 
 /// Return the string name of the given ELF x86-64 edge kind.
-StringRef getELFX86RelocationKindName(Edge::Kind R);
+const char *getELFX86RelocationKindName(Edge::Kind R);
 } // end namespace jitlink
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_JITLINK_ELF_X86_64_H

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

using block_iterator = nested_collection_iterator<const_section_iterator,
                                                     Section::block_iterator,
                                                     Block *, getSectionBlocks>;
 
   using const_block_iterator =
       nested_collection_iterator<const_section_iterator,
                                  Section::const_block_iterator, const Block *,
                                  getSectionConstBlocks>;
 
+  using GetEdgeKindNameFunction = const char *(*)(Edge::Kind);
+
   LinkGraph(std::string Name, const Triple &TT, unsigned PointerSize,
-            support::endianness Endianness)
+            support::endianness Endianness,
+            GetEdgeKindNameFunction GetEdgeKindName)
       : Name(std::move(Name)), TT(TT), PointerSize(PointerSize),
-        Endianness(Endianness) {}
+        Endianness(Endianness), GetEdgeKindName(std::move(GetEdgeKindName)) {}
 
   /// Returns the name of this graph (usually the name of the original
   /// underlying MemoryBuffer).
   const std::string &getName() const { return Name; }
 
   /// Returns the target triple for this Graph.
   const Triple &getTargetTriple() const { return TT; }
 
   /// Returns the pointer size for use in this graph.
   unsigned getPointerSize() const { return PointerSize; }
 
   /// Returns the endianness of content in this graph.
   support::endianness getEndianness() const { return Endianness; }
 
+  const char *getEdgeKindName(Edge::Kind K) const { return GetEdgeKindName(K); }
+
   /// Allocate a copy of the given string using the LinkGraph's allocator.
   /// This can be useful when renaming symbols or adding new content to the
   /// graph.
   StringRef allocateString(StringRef Source) {
     auto *AllocatedBuffer = Allocator.Allocate<char>(Source.size());
     llvm::copy(Source, AllocatedBuffer);
     return StringRef(AllocatedBuffer, Source.size());
   }
assert(llvm::none_of(B.getSection().symbols(),
                            return &Sym->getBlock() == &B;
                          }) &&
            "Block still has symbols attached");
     B.getSection().removeBlock(B);
     destroyBlock(B);
   }
 
   /// Dump the graph.
-  ///
-  /// If supplied, the EdgeKindToName function will be used to name edge
-  /// kinds in the debug output. Otherwise raw edge kind numbers will be
-  /// displayed.
-  void dump(raw_ostream &OS,
-            std::function<StringRef(Edge::Kind)> EdegKindToName =
-                std::function<StringRef(Edge::Kind)>());
+  void dump(raw_ostream &OS);
 
 private:
   // Put the BumpPtrAllocator first so that we don't free any of the underlying
   // memory until the Symbol/Addressable destructors have been run.
   BumpPtrAllocator Allocator;
 
   std::string Name;
   Triple TT;
   unsigned PointerSize;
   support::endianness Endianness;
+  GetEdgeKindNameFunction GetEdgeKindName = nullptr;
   SectionList Sections;
   ExternalSymbolSet ExternalSymbols;
   ExternalSymbolSet AbsoluteSymbols;
 };
 
 /// Enables easy lookup of blocks by addresses.
 class BlockAddressMap {
 public:

 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);
 
+/// Create an out of range error for the given edge in the given block.
+Error makeTargetOutOfRangeError(const Block &B, const Edge &E,
+                                const char *(*getEdgeKindName)(Edge::Kind));
+
 /// Create a LinkGraph from the given object buffer.
 ///
 /// Note: The graph does not take ownership of the underlying buffer, nor copy
 /// its contents. The caller is responsible for ensuring that the object buffer
 /// outlives the graph.
 Expected<std::unique_ptr<LinkGraph>>
 createLinkGraphFromObject(MemoryBufferRef ObjectBuffer);
 
 /// Link the given graph.
 void link(std::unique_ptr<LinkGraph> G, std::unique_ptr<JITLinkContext> Ctx);
 
 } // end namespace jitlink
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_JITLINK_JITLINK_H

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

 ///
 /// If PostPrunePasses is empty then a default GOT-and-stubs insertion pass will
 /// be inserted. If PostPrunePasses is not empty then the caller is responsible
 /// for including a pass to insert GOT and stub edges.
 void link_MachO_arm64(std::unique_ptr<LinkGraph> G,
                       std::unique_ptr<JITLinkContext> Ctx);
 
 /// Return the string name of the given MachO arm64 edge kind.
-StringRef getMachOARM64RelocationKindName(Edge::Kind R);
+const char *getMachOARM64RelocationKindName(Edge::Kind R);
 
 } // end namespace jitlink
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_JITLINK_MACHO_ARM64_H

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

 #ifndef LLVM_EXECUTIONENGINE_JITLINK_MACHO_X86_64_H
 #define LLVM_EXECUTIONENGINE_JITLINK_MACHO_X86_64_H
 
 #include "llvm/ExecutionEngine/JITLink/JITLink.h"
 
 namespace llvm {
 namespace jitlink {
 
-namespace MachO_x86_64_Edges {
-
-enum MachOX86RelocationKind : Edge::Kind {
-  Branch32 = Edge::FirstRelocation,
-  Branch32ToStub,
-  Pointer32,
-  Pointer64,
-  Pointer64Anon,
-  PCRel32,
-  PCRel32Minus1,
-  PCRel32Minus2,
-  PCRel32Minus4,
-  PCRel32Anon,
-  PCRel32Minus1Anon,
-  PCRel32Minus2Anon,
-  PCRel32Minus4Anon,
-  PCRel32GOTLoad,
-  PCRel32GOT,
-  PCRel32TLV,
-  Delta32,
-  Delta64,
-  NegDelta32,
-  NegDelta64,
-};
-
-} // namespace MachO_x86_64_Edges
-
 /// Create a LinkGraph from a MachO/x86-64 relocatable object.
 ///
 /// Note: The graph does not take ownership of the underlying buffer, nor copy
 /// its contents. The caller is responsible for ensuring that the object buffer
 /// outlives the graph.
 Expected<std::unique_ptr<LinkGraph>>
 createLinkGraphFromMachOObject_x86_64(MemoryBufferRef ObjectBuffer);
 
 /// jit-link the given LinkGraph.
 ///
 /// If PrePrunePasses is empty then a default mark-live pass will be inserted
 /// that will mark all exported atoms live. If PrePrunePasses is not empty, the
 /// caller is responsible for including a pass to mark atoms as live.
 ///
 /// If PostPrunePasses is empty then a default GOT-and-stubs insertion pass will
 /// be inserted. If PostPrunePasses is not empty then the caller is responsible
 /// for including a pass to insert GOT and stub edges.
 void link_MachO_x86_64(std::unique_ptr<LinkGraph> G,
                        std::unique_ptr<JITLinkContext> Ctx);
 
-/// Return the string name of the given MachO x86-64 edge kind.
-StringRef getMachOX86RelocationKindName(Edge::Kind R);
-
 } // end namespace jitlink
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_JITLINK_MACHO_X86_64_H

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

+//===-- x86_64.h - Generic JITLink x86-64 edge kinds, utilities -*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Generic utilities for graphs representing x86-64 objects.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_JITLINK_X86_64_H
+#define LLVM_EXECUTIONENGINE_JITLINK_X86_64_H
+
+#include "llvm/ExecutionEngine/JITLink/JITLink.h"
+
+namespace llvm {
+namespace jitlink {
+namespace x86_64 {
+
+/// Represents x86-64 fixups and other x86-64-specific edge kinds.
+enum EdgeKind_x86_64 : Edge::Kind {
+
+  /// A plain 64-bit pointer value relocation.
+  ///
+  /// Fixup expression:
+  ///   Fixup <- Target + Addend : uint64
+  ///
+  Pointer64 = Edge::FirstRelocation,
+
+  /// A plain 32-bit pointer value relocation.
+  ///
+  /// Fixup expression:
+  ///   Fixup <- Target + Addend : uint32
+  ///
+  /// Errors:
+  ///   - The target must reside in the low 32-bits of the address space,
+  ///     otherwise an out-of-range error will be returned.
+  ///
+  Pointer32,
+
+  /// A 64-bit delta.
+  ///
+  /// Delta from the fixup to the target.
+  ///
+  /// Fixup expression:
+  ///   Fixup <- Target - Fixup + Addend : int64
+  ///
+  Delta64,
+
+  /// A 32-bit delta.
+  ///
+  /// Delta from the fixup to the target.
+  ///
+  /// Fixup expression:
+  ///   Fixup <- Target - Fixup + Addend : int64
+  ///
+  /// Errors:
+  ///   - The result of the fixup expression must fit into an int32, otherwise
+  ///     an out-of-range error will be returned.
+  ///
+  Delta32,
+
+  /// A 64-bit negative delta.
+  ///
+  /// Delta from target back to the fixup.
+  ///
+  /// Fixup expression:
+  ///   Fixup <- Fixup - Target + Addend : int64
+  ///
+  NegDelta64,
+
+  /// A 32-bit negative delta.
+  ///
+  /// Delta from the target back to the fixup.
+  ///
+  /// Fixup expression:
+  ///   Fixup <- Fixup - Target + Addend : int32
+  ///
+  /// Errors:
+  ///   - The result of the fixup expression must fit into an int32, otherwise
+  ///     an out-of-range error will be returned.
+  NegDelta32,
+
+  /// A 32-bit PC-relative branch.
+  ///
+  /// Represents a PC-relative call or branch to a target. This can be used to
+  /// identify, record, and/or patch call sites.
+  ///
+  /// The fixup expression for this kind includes an implicit offset to account
+  /// for the PC (unlike the Delta edges) so that a Branch32PCRel with a target
+  /// T and addend zero is a call/branch to the start (offset zero) of T.
+  ///
+  /// Fixup expression:
+  ///   Fixup <- Target - (Fixup + 4) + Addend : int32
+  ///
+  /// Errors:
+  ///   - The result of the fixup expression must fit into an int32, otherwise
+  ///     an out-of-range error will be returned.
+  ///
+  BranchPCRel32,
+
+  /// A 32-bit PC-relative branch to a pointer jump stub.
+  ///
+  /// The target of this relocation should be a pointer jump stub of the form:
+  ///
+  /// \code{.s}
+  ///   .text
+  ///   jmpq *tgtptr(%rip)
+  ///   ; ...
+  ///
+  ///   .data
+  ///   tgtptr:
+  ///     .quad 0
+  /// \endcode
+  ///
+  /// This edge kind has the same fixup expression as BranchPCRel32, but further
+  /// identifies the call/branch as being to a pointer jump stub. For edges of
+  /// this kind the jump stub should not be bypassed (use
+  /// BranchPCRel32ToPtrJumpStubRelaxable for that), but the pointer location
+  /// target may be recorded to allow manipulation at runtime.
+  ///
+  /// Fixup expression:
+  ///   Fixup <- Target - Fixup + Addend - 4 : int32
+  ///
+  /// Errors:
+  ///   - The result of the fixup expression must fit into an int32, otherwise
+  ///     an out-of-range error will be returned.
+  ///
+  BranchPCRel32ToPtrJumpStub,
+
+  /// A relaxable version of BranchPCRel32ToPtrJumpStub.
+  ///
+  /// The edge kind has the same fixup expression as BranchPCRel32ToPtrJumpStub,
+  /// but identifies the call/branch as being to a pointer jump stub that may be
+  /// bypassed if the ultimate target is within range of the fixup location.
+  ///
+  /// Fixup expression:
+  ///   Fixup <- Target - Fixup + Addend - 4: int32
+  ///
+  /// Errors:
+  ///   - The result of the fixup expression must fit into an int32, otherwise
+  ///     an out-of-range error will be returned.
+  ///
+  BranchPCRel32ToPtrJumpStubRelaxable,
+
+  /// A GOT entry getter/constructor, transformed to Delta32 pointing at the GOT
+  /// entry for the original target.
+  ///
+  /// Indicates that this edge should be transformed into a Delta32 targeting
+  /// the GOT entry for the edge's current target, maintaining the same addend.
+  /// A GOT entry for the target should be created if one does not already
+  /// exist.
+  ///
+  /// Edges of this kind are usually handled by a GOT builder pass inserted by
+  /// default.
+  ///
+  /// Fixup expression:
+  ///   NONE
+  ///
+  /// Errors:
+  ///   - *ASSERTION* Failure to handle edges of this kind prior to the fixup
+  ///     phase will result in an assert/unreachable during the fixup phase.
+  ///
+  RequestGOTAndTransformToDelta32,
+
+  /// A PC-relative reference to a GOT entry, relaxable if GOT entry target
+  /// is in-range of the fixup.
+  ///
+  /// If the GOT entry target is in-range of the fixup then the load from the
+  /// GOT may be replaced with a direct memory address calculation.
+  ///
+  /// Fixup expression:
+  ///   Fixup <- Target - (Fixup + 4) + Addend : int32
+  ///
+  /// Errors:
+  ///   - The result of the fixup expression must fit into an int32, otherwise
+  ///     an out-of-range error will be returned.
+  ///
+  PCRel32GOTLoadRelaxable,
+
+  /// A GOT entry getter/constructor, transformed to PCRel32ToGOTLoadRelaxable
+  /// pointing at the GOT entry for the original target.
+  ///
+  /// Indicates that this edge should be transformed into a
+  /// PC32ToGOTLoadRelaxable targeting the GOT entry for the edge's current
+  /// target, maintaining the same addend. A GOT entry for the target should be
+  /// created if one does not already exist.
+  ///
+  /// Edges of this kind are usually handled by a GOT builder pass inserted by
+  /// default.
+  ///
+  /// Fixup expression:
+  ///   NONE
+  ///
+  /// Errors:
+  ///   - *ASSERTION* Failure to handle edges of this kind prior to the fixup
+  ///     phase will result in an assert/unreachable during the fixup phase.
+  ///
+  RequestGOTAndTransformToPCRel32GOTLoadRelaxable,
+
+  /// A PC-relative reference to a Thread Local Variable Pointer (TLVP) entry,
+  /// relaxable if the TLVP entry target is in-range of the fixup.
+  ///
+  /// If the TLVP entry target is in-range of the fixup then the load frmo the
+  /// TLVP may be replaced with a direct memory address calculation.
+  ///
+  /// The target of this edge must be a thread local variable entry of the form
+  ///   .quad <tlv getter thunk>
+  ///   .quad <tlv key>
+  ///   .quad <tlv initializer>
+  ///
+  /// Fixup expression:
+  ///   Fixup <- Target - (Fixup + 4) + Addend : int32
+  ///
+  /// Errors:
+  ///   - The result of the fixup expression must fit into an int32, otherwise
+  ///     an out-of-range error will be returned.
+  ///   - The target must be either external, or a TLV entry of the required
+  ///     form, otherwise a malformed TLV entry error will be returned.
+  ///
+  PCRel32TLVPLoadRelaxable,
+
+  /// A TLVP entry getter/constructor, transformed to
+  /// Delta32ToTLVPLoadRelaxable.
+  ///
+  /// Indicates that this edge should be transformed into a
+  /// Delta32ToTLVPLoadRelaxable targeting the TLVP entry for the edge's current
+  /// target. A TLVP entry for the target should be created if one does not
+  /// already exist.
+  ///
+  /// Fixup expression:
+  ///   NONE
+  ///
+  /// Errors:
+  ///   - *ASSERTION* Failure to handle edges of this kind prior to the fixup
+  ///     phase will result in an assert/unreachable during the fixup phase.
+  ///
+  RequestTLVPAndTransformToPCRel32TLVPLoadRelaxable
+};
+
+/// Returns a string name for the given x86-64 edge. For debugging purposes
+/// only.
+const char *getEdgeKindName(Edge::Kind K);
+
+/// Apply fixup expression for edge to block content.
+inline Error applyFixup(Block &B, const Edge &E, char *BlockWorkingMem) {
+  using namespace support;
+
+  char *FixupPtr = BlockWorkingMem + E.getOffset();
+  JITTargetAddress FixupAddress = B.getAddress() + E.getOffset();
+
+  switch (E.getKind()) {
+
+  case Pointer64: {
+    uint64_t Value = E.getTarget().getAddress() + E.getAddend();
+    *(ulittle64_t *)FixupPtr = Value;
+    break;
+  }
+
+  case Pointer32: {
+    uint64_t Value = E.getTarget().getAddress() + E.getAddend();
+    if (Value > std::numeric_limits<uint32_t>::max())
+      return makeTargetOutOfRangeError(B, E, getEdgeKindName);
+    *(ulittle32_t *)FixupPtr = Value;
+    break;
+  }
+
+  case BranchPCRel32:
+  case BranchPCRel32ToPtrJumpStub:
+  case BranchPCRel32ToPtrJumpStubRelaxable:
+  case PCRel32GOTLoadRelaxable:
+  case PCRel32TLVPLoadRelaxable: {
+    int64_t Value =
+        E.getTarget().getAddress() - (FixupAddress + 4) + E.getAddend();
+    if (Value < std::numeric_limits<int32_t>::min() ||
+        Value > std::numeric_limits<int32_t>::max())
+      return makeTargetOutOfRangeError(B, E, getEdgeKindName);
+    *(little32_t *)FixupPtr = Value;
+    break;
+  }
+
+  case Delta64: {
+    int64_t Value = E.getTarget().getAddress() - FixupAddress + E.getAddend();
+    *(little64_t *)FixupPtr = Value;
+    break;
+  }
+
+  case Delta32: {
+    int64_t Value = E.getTarget().getAddress() - FixupAddress + E.getAddend();
+    if (Value < std::numeric_limits<int32_t>::min() ||
+        Value > std::numeric_limits<int32_t>::max())
+      return makeTargetOutOfRangeError(B, E, getEdgeKindName);
+    *(little32_t *)FixupPtr = Value;
+    break;
+  }
+
+  case NegDelta64: {
+    int64_t Value = FixupAddress - E.getTarget().getAddress() + E.getAddend();
+    *(little64_t *)FixupPtr = Value;
+    break;
+  }
+
+  case NegDelta32: {
+    int64_t Value = FixupAddress - E.getTarget().getAddress() + E.getAddend();
+    if (Value < std::numeric_limits<int32_t>::min() ||
+        Value > std::numeric_limits<int32_t>::max())
+      return makeTargetOutOfRangeError(B, E, getEdgeKindName);
+    *(little32_t *)FixupPtr = Value;
+    break;
+  }
+
+  default: {
+    // If you hit this you should check that *constructor and other non-fixup
+    // edges have been removed prior to applying fixups.
+    llvm_unreachable("Graph contains edge kind with no fixup expression");
+  }
+  }
+
+  return Error::success();
+}
+
+} // namespace x86_64
+} // end namespace jitlink
+} // end namespace llvm
+
+#endif // LLVM_EXECUTIONENGINE_JITLINK_X86_64_H

llvm/lib/ExecutionEngine/JITLink/BasicGOTAndStubsBuilder.h

void run() {
     // We're going to be adding new blocks, but we don't want to iterate over
     // the newly added ones, so just copy the existing blocks out.
     std::vector<Block *> Blocks(G.blocks().begin(), G.blocks().end());
 
     LLVM_DEBUG(dbgs() << "Creating GOT entries and stubs:\n");
 
     for (auto *B : Blocks)
       for (auto &E : B->edges())
-        if (impl().isGOTEdge(E)) {
+        if (impl().isGOTEdgeToFix(E)) {
           LLVM_DEBUG({
             dbgs() << "  Updating GOT edge ";
             printEdge(dbgs(), *B, E, "<target GOT>");
             dbgs() << "\n";
           });
           impl().fixGOTEdge(E, getGOTEntrySymbol(E.getTarget()));
         } else if (impl().isExternalBranchEdge(E)) {
           LLVM_DEBUG({

llvm/lib/ExecutionEngine/JITLink/CMakeLists.txt

 add_llvm_component_library(LLVMJITLink
   JITLink.cpp
   JITLinkGeneric.cpp
   JITLinkMemoryManager.cpp
   EHFrameSupport.cpp
-  #macho
+
+  # Formats:
+
+  # MachO
   MachO.cpp
   MachO_arm64.cpp
   MachO_x86_64.cpp
   MachOLinkGraphBuilder.cpp
-  #elf
+
+  # ELF
+
   ELF.cpp
   ELF_x86_64.cpp
 
+  # Architectures:
+  x86_64.cpp
+
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/ExecutionEngine/JITLink
 
   DEPENDS
   intrinsics_gen
 
   LINK_COMPONENTS
   BinaryFormat

llvm/lib/ExecutionEngine/JITLink/ELF_x86_64.cpp

class ELF_x86_64_GOTAndStubsBuilder
     : public BasicGOTAndStubsBuilder<ELF_x86_64_GOTAndStubsBuilder> {
 public:
   static const uint8_t NullGOTEntryContent[8];
   static const uint8_t StubContent[6];
 
   ELF_x86_64_GOTAndStubsBuilder(LinkGraph &G)
       : BasicGOTAndStubsBuilder<ELF_x86_64_GOTAndStubsBuilder>(G) {}
 
-  bool isGOTEdge(Edge &E) const {
+  bool isGOTEdgeToFix(Edge &E) const {
     return E.getKind() == PCRel32GOT || E.getKind() == PCRel32GOTLoad;
   }
 
   Symbol &createGOTEntry(Symbol &Target) {
     auto &GOTEntryBlock = G.createContentBlock(
         getGOTSection(), getGOTEntryBlockContent(), 0, 8, 0);
     GOTEntryBlock.addEdge(Pointer64, 0, Target, 0);
     return G.addAnonymousSymbol(GOTEntryBlock, 0, 8, false, false);
for (auto SecRef : sections) {
       }
     }
     return Error::success();
   }
 
 public:
   ELFLinkGraphBuilder_x86_64(StringRef FileName,
                              const object::ELFFile<object::ELF64LE> &Obj)
-      : G(std::make_unique<LinkGraph>(FileName.str(),
-                                      Triple("x86_64-unknown-linux"),
-                                      getPointerSize(Obj), getEndianness(Obj))),
+      : G(std::make_unique<LinkGraph>(
+            FileName.str(), Triple("x86_64-unknown-linux"), getPointerSize(Obj),
+            getEndianness(Obj), getELFX86RelocationKindName)),
         Obj(Obj) {}
 
   Expected<std::unique_ptr<LinkGraph>> buildGraph() {
     // Sanity check: we only operate on relocatable objects.
     if (!isRelocatable())
       return make_error<JITLinkError>("Object is not a relocatable ELF");
 
     auto Secs = Obj.sections();

 
 public:
   ELFJITLinker_x86_64(std::unique_ptr<JITLinkContext> Ctx,
                       std::unique_ptr<LinkGraph> G,
                       PassConfiguration PassConfig)
       : JITLinker(std::move(Ctx), std::move(G), std::move(PassConfig)) {}
 
 private:
-  StringRef getEdgeKindName(Edge::Kind R) const override {
-    return getELFX86RelocationKindName(R);
-  }
 
   static Error targetOutOfRangeError(const Block &B, const Edge &E) {
     std::string ErrMsg;
     {
       raw_string_ostream ErrStream(ErrMsg);
       ErrStream << "Relocation target out of range: ";
       printEdge(ErrStream, B, E, getELFX86RelocationKindName(E.getKind()));
       ErrStream << "\n";
if (Ctx->shouldAddDefaultTargetPasses(G->getTargetTriple())) {
     Config.PreFixupPasses.push_back(optimizeELF_x86_64_GOTAndStubs);
   }
 
   if (auto Err = Ctx->modifyPassConfig(*G, Config))
     return Ctx->notifyFailed(std::move(Err));
 
   ELFJITLinker_x86_64::link(std::move(Ctx), std::move(G), std::move(Config));
 }
-StringRef getELFX86RelocationKindName(Edge::Kind R) {
+const char *getELFX86RelocationKindName(Edge::Kind R) {
   switch (R) {
   case PCRel32:
     return "PCRel32";
   case Pointer64:
     return "Pointer64";
   case PCRel32GOTLoad:
     return "PCRel32GOTLoad";
   case Branch32:
     return "Branch32";
   case Branch32ToStub:
     return "Branch32ToStub";
   }
   return getGenericEdgeKindName(static_cast<Edge::Kind>(R));
 }
 } // end namespace jitlink
 } // end namespace llvm

llvm/lib/ExecutionEngine/JITLink/JITLink.cpp

// Handle symbol transfer/update.
     // Update offsets for all remaining symbols in B.
     for (auto *Sym : BlockSymbols)
       Sym->setOffset(Sym->getOffset() - SplitIndex);
   }
 
   return NewBlock;
 }
 
-void LinkGraph::dump(raw_ostream &OS,
-                     std::function<StringRef(Edge::Kind)> EdgeKindToName) {
-  if (!EdgeKindToName)
-    EdgeKindToName = [](Edge::Kind K) { return StringRef(); };
-
+void LinkGraph::dump(raw_ostream &OS) {
   OS << "Symbols:\n";
   for (auto *Sym : defined_symbols()) {
     OS << "  " << format("0x%016" PRIx64, Sym->getAddress()) << ": " << *Sym
        << "\n";
     if (Sym->isDefined()) {
       for (auto &E : Sym->getBlock().edges()) {
         OS << "    ";
-        StringRef EdgeName = (E.getKind() < Edge::FirstRelocation
-                                  ? getGenericEdgeKindName(E.getKind())
-                                  : EdgeKindToName(E.getKind()));
-
-        if (!EdgeName.empty())
-          printEdge(OS, Sym->getBlock(), E, EdgeName);
-        else {
-          auto EdgeNumberString = std::to_string(E.getKind());
-          printEdge(OS, Sym->getBlock(), E, EdgeNumberString);
-        }
+        printEdge(OS, Sym->getBlock(), E, getEdgeKindName(E.getKind()));
         OS << "\n";
       }
     }
   }
 
   OS << "Absolute symbols:\n";
   for (auto *Sym : absolute_symbols())
     OS << "  " << format("0x%016" PRIx64, Sym->getAddress()) << ": " << *Sym

 }
 
 Error markAllSymbolsLive(LinkGraph &G) {
   for (auto *Sym : G.defined_symbols())
     Sym->setLive(true);
   return Error::success();
 }
 
+Error makeTargetOutOfRangeError(const Block &B, const Edge &E,
+                                const char *(*getEdgeKindName)(Edge::Kind)) {
+  std::string ErrMsg;
+  {
+    raw_string_ostream ErrStream(ErrMsg);
+    ErrStream << "Relocation target out of range: ";
+    printEdge(ErrStream, B, E, getEdgeKindName(E.getKind()));
+    ErrStream << "\n";
+  }
+  return make_error<JITLinkError>(std::move(ErrMsg));
+}
+
 Expected<std::unique_ptr<LinkGraph>>
 createLinkGraphFromObject(MemoryBufferRef ObjectBuffer) {
   auto Magic = identify_magic(ObjectBuffer.getBuffer());
   switch (Magic) {
   case file_magic::macho_object:
     return createLinkGraphFromMachOObject(ObjectBuffer);
   case file_magic::elf_relocatable:
     return createLinkGraphFromELFObject(ObjectBuffer);

llvm/lib/ExecutionEngine/JITLink/JITLinkGeneric.h

protected:
   void linkPhase2(std::unique_ptr<JITLinkerBase> Self,
                   Expected<AsyncLookupResult> LookupResult,
                   SegmentLayoutMap Layout);
 
   // Phase 3:
   //   3.1: Call OnFinalized callback, handing off allocation.
   void linkPhase3(std::unique_ptr<JITLinkerBase> Self, Error Err);
 
-  // For debug dumping of the link graph.
-  virtual StringRef getEdgeKindName(Edge::Kind K) const = 0;
-
   // Align a JITTargetAddress to conform with block alignment requirements.
   static JITTargetAddress alignToBlock(JITTargetAddress Addr, Block &B) {
     uint64_t Delta = (B.getAlignmentOffset() - Addr) % B.getAlignment();
     return Addr + Delta;
   }
 
   // Align a pointer to conform with block alignment requirements.
   static char *alignToBlock(char *P, Block &B) {
private:
   SegmentLayoutMap layOutBlocks();
   Error allocateSegments(const SegmentLayoutMap &Layout);
   JITLinkContext::LookupMap getExternalSymbolNames() const;
   void applyLookupResult(AsyncLookupResult LR);
   void copyBlockContentToWorkingMemory(const SegmentLayoutMap &Layout,
                                        JITLinkMemoryManager::Allocation &Alloc);
   void deallocateAndBailOut(Error Err);
 
-  void dumpGraph(raw_ostream &OS);
-
   std::unique_ptr<JITLinkContext> Ctx;
   std::unique_ptr<LinkGraph> G;
   PassConfiguration Passes;
   std::unique_ptr<JITLinkMemoryManager::Allocation> Alloc;
 };
 
 template <typename LinkerImpl> class JITLinker : public JITLinkerBase {
 public:

llvm/lib/ExecutionEngine/JITLink/JITLinkGeneric.cpp

void JITLinkerBase::linkPhase1(std::unique_ptr<JITLinkerBase> Self) {
   });
 
   // Prune and optimize the graph.
   if (auto Err = runPasses(Passes.PrePrunePasses))
     return Ctx->notifyFailed(std::move(Err));
 
   LLVM_DEBUG({
     dbgs() << "Link graph \"" << G->getName() << "\" pre-pruning:\n";
-    dumpGraph(dbgs());
+    G->dump(dbgs());
   });
 
   prune(*G);
 
   LLVM_DEBUG({
     dbgs() << "Link graph \"" << G->getName() << "\" post-pruning:\n";
-    dumpGraph(dbgs());
+    G->dump(dbgs());
   });
 
   // Run post-pruning passes.
   if (auto Err = runPasses(Passes.PostPrunePasses))
     return Ctx->notifyFailed(std::move(Err));
 
   // Sort blocks into segments.
   auto Layout = layOutBlocks();
 
   // Allocate memory for segments.
   if (auto Err = allocateSegments(Layout))
     return Ctx->notifyFailed(std::move(Err));
 
   LLVM_DEBUG({
     dbgs() << "Link graph \"" << G->getName()
            << "\" before post-allocation passes:\n";
-    dumpGraph(dbgs());
+    G->dump(dbgs());
   });
 
   // Run post-allocation passes.
   if (auto Err = runPasses(Passes.PostAllocationPasses))
     return Ctx->notifyFailed(std::move(Err));
 
   // Notify client that the defined symbols have been assigned addresses.
   LLVM_DEBUG(
void JITLinkerBase::linkPhase2(std::unique_ptr<JITLinkerBase> Self,
   applyLookupResult(*LR);
 
   // Copy block content to working memory.
   copyBlockContentToWorkingMemory(Layout, *Alloc);
 
   LLVM_DEBUG({
     dbgs() << "Link graph \"" << G->getName()
            << "\" before pre-fixup passes:\n";
-    dumpGraph(dbgs());
+    G->dump(dbgs());
   });
 
   if (auto Err = runPasses(Passes.PreFixupPasses))
     return deallocateAndBailOut(std::move(Err));
 
   LLVM_DEBUG({
     dbgs() << "Link graph \"" << G->getName() << "\" before copy-and-fixup:\n";
-    dumpGraph(dbgs());
+    G->dump(dbgs());
   });
 
   // Fix up block content.
   if (auto Err = fixUpBlocks(*G))
     return deallocateAndBailOut(std::move(Err));
 
   LLVM_DEBUG({
     dbgs() << "Link graph \"" << G->getName() << "\" after copy-and-fixup:\n";
-    dumpGraph(dbgs());
+    G->dump(dbgs());
   });
 
   if (auto Err = runPasses(Passes.PostFixupPasses))
     return deallocateAndBailOut(std::move(Err));
 
   // FIXME: Use move capture once we have c++14.
   auto *UnownedSelf = Self.release();
   auto Phase3Continuation = [UnownedSelf](Error Err) {

 }
 
 void JITLinkerBase::deallocateAndBailOut(Error Err) {
   assert(Err && "Should not be bailing out on success value");
   assert(Alloc && "can not call deallocateAndBailOut before allocation");
   Ctx->notifyFailed(joinErrors(std::move(Err), Alloc->deallocate()));
 }
 
-void JITLinkerBase::dumpGraph(raw_ostream &OS) {
-  assert(G && "Graph is not set yet");
-  G->dump(dbgs(), [this](Edge::Kind K) { return getEdgeKindName(K); });
-}
-
 void prune(LinkGraph &G) {
   std::vector<Symbol *> Worklist;
   DenseSet<Block *> VisitedBlocks;
 
   // Build the initial worklist from all symbols initially live.
   for (auto *Sym : G.defined_symbols())
     if (Sym->isLive())
       Worklist.push_back(Sym);

llvm/lib/ExecutionEngine/JITLink/MachOLinkGraphBuilder.h

public:
     uint64_t Alignment = 0;
     uint32_t Flags = 0;
     const char *Data = nullptr;
     Section *GraphSection = nullptr;
   };
 
   using SectionParserFunction = std::function<Error(NormalizedSection &S)>;
 
-  MachOLinkGraphBuilder(const object::MachOObjectFile &Obj, Triple TT);
+  MachOLinkGraphBuilder(const object::MachOObjectFile &Obj, Triple TT,
+                        LinkGraph::GetEdgeKindNameFunction GetEdgeKindName);
 
   LinkGraph &getGraph() const { return *G; }
 
   const object::MachOObjectFile &getObject() const { return Obj; }
 
   void addCustomSectionParser(StringRef SectionName,
                               SectionParserFunction Parse);
 

llvm/lib/ExecutionEngine/JITLink/MachOLinkGraphBuilder.cpp

if (auto Err = graphifySectionsWithCustomParsers())
     return std::move(Err);
 
   if (auto Err = addRelocations())
     return std::move(Err);
 
   return std::move(G);
 }
 
-MachOLinkGraphBuilder::MachOLinkGraphBuilder(const object::MachOObjectFile &Obj,
-                                             Triple TT)
+MachOLinkGraphBuilder::MachOLinkGraphBuilder(
+    const object::MachOObjectFile &Obj, Triple TT,
+    LinkGraph::GetEdgeKindNameFunction GetEdgeKindName)
     : Obj(Obj),
-      G(std::make_unique<LinkGraph>(std::string(Obj.getFileName()),
-                                    std::move(TT), getPointerSize(Obj),
-                                    getEndianness(Obj))) {}
+      G(std::make_unique<LinkGraph>(
+          std::string(Obj.getFileName()), std::move(TT), getPointerSize(Obj),
+          getEndianness(Obj), std::move(GetEdgeKindName))) {}
 
 void MachOLinkGraphBuilder::addCustomSectionParser(
     StringRef SectionName, SectionParserFunction Parser) {
   assert(!CustomSectionParserFunctions.count(SectionName) &&
          "Custom parser for this section already exists");
   CustomSectionParserFunctions[SectionName] = std::move(Parser);
 }
 

llvm/lib/ExecutionEngine/JITLink/MachO_arm64.cpp

 using namespace llvm::jitlink;
 using namespace llvm::jitlink::MachO_arm64_Edges;
 
 namespace {
 
 class MachOLinkGraphBuilder_arm64 : public MachOLinkGraphBuilder {
 public:
   MachOLinkGraphBuilder_arm64(const object::MachOObjectFile &Obj)
-      : MachOLinkGraphBuilder(Obj, Triple("arm64-apple-darwin")),
+      : MachOLinkGraphBuilder(Obj, Triple("arm64-apple-darwin"),
+                              getMachOARM64RelocationKindName),
         NumSymbols(Obj.getSymtabLoadCommand().nsyms) {}
 
 private:
   static Expected<MachOARM64RelocationKind>
   getRelocationKind(const MachO::relocation_info &RI) {
     switch (RI.r_type) {
     case MachO::ARM64_RELOC_UNSIGNED:
       if (!RI.r_pcrel) {
for (auto &S : Obj.sections()) {
 
           Kind = getRelocationKind(RI);
           if (!Kind)
             return Kind.takeError();
 
           if (*Kind != Branch26 && *Kind != Page21 && *Kind != PageOffset12)
             return make_error<JITLinkError>(
                 "Invalid relocation pair: Addend + " +
-                getMachOARM64RelocationKindName(*Kind));
+                StringRef(getMachOARM64RelocationKindName(*Kind)));
 
           LLVM_DEBUG({
             dbgs() << "    Addend: value = " << formatv("{0:x6}", Addend)
                    << ", pair is " << getMachOARM64RelocationKindName(*Kind)
                    << "\n";
           });
 
           // Find the address of the value to fix up.

 };
 
 class MachO_arm64_GOTAndStubsBuilder
     : public BasicGOTAndStubsBuilder<MachO_arm64_GOTAndStubsBuilder> {
 public:
   MachO_arm64_GOTAndStubsBuilder(LinkGraph &G)
       : BasicGOTAndStubsBuilder<MachO_arm64_GOTAndStubsBuilder>(G) {}
 
-  bool isGOTEdge(Edge &E) const {
-    return E.getKind() == GOTPage21 || E.getKind() == GOTPageOffset12 ||
-           E.getKind() == PointerToGOT;
+  bool isGOTEdgeToFix(Edge &E) const {
+    return (E.getKind() == GOTPage21 || E.getKind() == GOTPageOffset12 ||
+            E.getKind() == PointerToGOT) &&
+           E.getTarget().isExternal();
   }
 
   Symbol &createGOTEntry(Symbol &Target) {
     auto &GOTEntryBlock = G.createContentBlock(
         getGOTSection(), getGOTEntryBlockContent(), 0, 8, 0);
     GOTEntryBlock.addEdge(Pointer64, 0, Target, 0);
     return G.addAnonymousSymbol(GOTEntryBlock, 0, 8, false, false);
   }

 
 public:
   MachOJITLinker_arm64(std::unique_ptr<JITLinkContext> Ctx,
                        std::unique_ptr<LinkGraph> G,
                        PassConfiguration PassConfig)
       : JITLinker(std::move(Ctx), std::move(G), std::move(PassConfig)) {}
 
 private:
-  StringRef getEdgeKindName(Edge::Kind R) const override {
-    return getMachOARM64RelocationKindName(R);
-  }
 
   static Error targetOutOfRangeError(const Block &B, const Edge &E) {
     std::string ErrMsg;
     {
       raw_string_ostream ErrStream(ErrMsg);
       ErrStream << "Relocation target out of range: ";
       printEdge(ErrStream, B, E, getMachOARM64RelocationKindName(E.getKind()));
       ErrStream << "\n";
void link_MachO_arm64(std::unique_ptr<LinkGraph> G,
 
   if (auto Err = Ctx->modifyPassConfig(*G, Config))
     return Ctx->notifyFailed(std::move(Err));
 
   // Construct a JITLinker and run the link function.
   MachOJITLinker_arm64::link(std::move(Ctx), std::move(G), std::move(Config));
 }
 
-StringRef getMachOARM64RelocationKindName(Edge::Kind R) {
+const char *getMachOARM64RelocationKindName(Edge::Kind R) {
   switch (R) {
   case Branch26:
     return "Branch26";
   case Pointer64:
     return "Pointer64";
   case Pointer64Anon:
     return "Pointer64Anon";
   case Page21:

llvm/lib/ExecutionEngine/JITLink/MachO_x86_64.cpp

 //===---- MachO_x86_64.cpp -JIT linker implementation for MachO/x86-64 ----===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // MachO/x86-64 jit-link implementation.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ExecutionEngine/JITLink/MachO_x86_64.h"
+#include "llvm/ExecutionEngine/JITLink/x86_64.h"
 
 #include "BasicGOTAndStubsBuilder.h"
 #include "MachOLinkGraphBuilder.h"
 
 #define DEBUG_TYPE "jitlink"
 
 using namespace llvm;
 using namespace llvm::jitlink;
-using namespace llvm::jitlink::MachO_x86_64_Edges;
 
 namespace {
 
 class MachOLinkGraphBuilder_x86_64 : public MachOLinkGraphBuilder {
 public:
   MachOLinkGraphBuilder_x86_64(const object::MachOObjectFile &Obj)
-      : MachOLinkGraphBuilder(Obj, Triple("x86_64-apple-darwin")) {}
+      : MachOLinkGraphBuilder(Obj, Triple("x86_64-apple-darwin"),
+                              x86_64::getEdgeKindName) {}
 
 private:
-  static Expected<MachOX86RelocationKind>
-  getRelocationKind(const MachO::relocation_info &RI) {
+  enum MachONormalizedRelocationType : unsigned {
+    MachOBranch32,
+    MachOPointer32,
+    MachOPointer64,
+    MachOPointer64Anon,
+    MachOPCRel32,
+    MachOPCRel32Minus1,
+    MachOPCRel32Minus2,
+    MachOPCRel32Minus4,
+    MachOPCRel32Anon,
+    MachOPCRel32Minus1Anon,
+    MachOPCRel32Minus2Anon,
+    MachOPCRel32Minus4Anon,
+    MachOPCRel32GOTLoad,
+    MachOPCRel32GOT,
+    MachOPCRel32TLV,
+    MachOSubtractor32,
+    MachOSubtractor64,
+  };
+
+  static Expected<MachONormalizedRelocationType>
+  getRelocKind(const MachO::relocation_info &RI) {
     switch (RI.r_type) {
     case MachO::X86_64_RELOC_UNSIGNED:
       if (!RI.r_pcrel) {
         if (RI.r_length == 3)
-          return RI.r_extern ? Pointer64 : Pointer64Anon;
+          return RI.r_extern ? MachOPointer64 : MachOPointer64Anon;
         else if (RI.r_extern && RI.r_length == 2)
-          return Pointer32;
+          return MachOPointer32;
       }
       break;
     case MachO::X86_64_RELOC_SIGNED:
       if (RI.r_pcrel && RI.r_length == 2)
-        return RI.r_extern ? PCRel32 : PCRel32Anon;
+        return RI.r_extern ? MachOPCRel32 : MachOPCRel32Anon;
       break;
     case MachO::X86_64_RELOC_BRANCH:
       if (RI.r_pcrel && RI.r_extern && RI.r_length == 2)
-        return Branch32;
+        return MachOBranch32;
       break;
     case MachO::X86_64_RELOC_GOT_LOAD:
       if (RI.r_pcrel && RI.r_extern && RI.r_length == 2)
-        return PCRel32GOTLoad;
+        return MachOPCRel32GOTLoad;
       break;
     case MachO::X86_64_RELOC_GOT:
       if (RI.r_pcrel && RI.r_extern && RI.r_length == 2)
-        return PCRel32GOT;
+        return MachOPCRel32GOT;
       break;
     case MachO::X86_64_RELOC_SUBTRACTOR:
-      // SUBTRACTOR must be non-pc-rel, extern, with length 2 or 3.
-      // Initially represent SUBTRACTOR relocations with 'Delta<W>'. They may
-      // be turned into NegDelta<W> by parsePairRelocation.
       if (!RI.r_pcrel && RI.r_extern) {
         if (RI.r_length == 2)
-          return Delta32;
+          return MachOSubtractor32;
         else if (RI.r_length == 3)
-          return Delta64;
+          return MachOSubtractor64;
       }
       break;
     case MachO::X86_64_RELOC_SIGNED_1:
       if (RI.r_pcrel && RI.r_length == 2)
-        return RI.r_extern ? PCRel32Minus1 : PCRel32Minus1Anon;
+        return RI.r_extern ? MachOPCRel32Minus1 : MachOPCRel32Minus1Anon;
       break;
     case MachO::X86_64_RELOC_SIGNED_2:
       if (RI.r_pcrel && RI.r_length == 2)
-        return RI.r_extern ? PCRel32Minus2 : PCRel32Minus2Anon;
+        return RI.r_extern ? MachOPCRel32Minus2 : MachOPCRel32Minus2Anon;
       break;
     case MachO::X86_64_RELOC_SIGNED_4:
       if (RI.r_pcrel && RI.r_length == 2)
-        return RI.r_extern ? PCRel32Minus4 : PCRel32Minus4Anon;
+        return RI.r_extern ? MachOPCRel32Minus4 : MachOPCRel32Minus4Anon;
       break;
     case MachO::X86_64_RELOC_TLV:
       if (RI.r_pcrel && RI.r_extern && RI.r_length == 2)
-        return PCRel32TLV;
+        return MachOPCRel32TLV;
       break;
     }
 
     return make_error<JITLinkError>(
         "Unsupported x86-64 relocation: address=" +
         formatv("{0:x8}", RI.r_address) +
         ", symbolnum=" + formatv("{0:x6}", RI.r_symbolnum) +
         ", kind=" + formatv("{0:x1}", RI.r_type) +
         ", pc_rel=" + (RI.r_pcrel ? "true" : "false") +
         ", extern=" + (RI.r_extern ? "true" : "false") +
         ", length=" + formatv("{0:d}", RI.r_length));
   }
 
-  using PairRelocInfo = std::tuple<MachOX86RelocationKind, Symbol *, uint64_t>;
+  using PairRelocInfo = std::tuple<Edge::Kind, Symbol *, uint64_t>;
 
   // Parses paired SUBTRACTOR/UNSIGNED relocations and, on success,
   // returns the edge kind and addend to be used.
-  Expected<PairRelocInfo>
-  parsePairRelocation(Block &BlockToFix, Edge::Kind SubtractorKind,
-                      const MachO::relocation_info &SubRI,
-                      JITTargetAddress FixupAddress, const char *FixupContent,
-                      object::relocation_iterator &UnsignedRelItr,
-                      object::relocation_iterator &RelEnd) {
+  Expected<PairRelocInfo> parsePairRelocation(
+      Block &BlockToFix, MachONormalizedRelocationType SubtractorKind,
+      const MachO::relocation_info &SubRI, JITTargetAddress FixupAddress,
+      const char *FixupContent, object::relocation_iterator &UnsignedRelItr,
     using namespace support;
 
-    assert(((SubtractorKind == Delta32 && SubRI.r_length == 2) ||
-            (SubtractorKind == Delta64 && SubRI.r_length == 3)) &&
+    assert(((SubtractorKind == MachOSubtractor32 && SubRI.r_length == 2) ||
+            (SubtractorKind == MachOSubtractor64 && SubRI.r_length == 3)) &&
            "Subtractor kind should match length");
     assert(SubRI.r_extern && "SUBTRACTOR reloc symbol should be extern");
     assert(!SubRI.r_pcrel && "SUBTRACTOR reloc should not be PCRel");
 
     if (UnsignedRelItr == RelEnd)
       return make_error<JITLinkError>("x86_64 SUBTRACTOR without paired "
                                       "UNSIGNED relocation");
 
if (UnsignedRI.r_extern) {
       auto ToSymbolSec = findSectionByIndex(UnsignedRI.r_symbolnum - 1);
       if (!ToSymbolSec)
         return ToSymbolSec.takeError();
       ToSymbol = getSymbolByAddress(ToSymbolSec->Address);
       assert(ToSymbol && "No symbol for section");
       FixupValue -= ToSymbol->getAddress();
     }
 
-    MachOX86RelocationKind DeltaKind;
+    Edge::Kind DeltaKind;
     Symbol *TargetSymbol;
     uint64_t Addend;
     if (&BlockToFix == &FromSymbol->getAddressable()) {
       TargetSymbol = ToSymbol;
-      DeltaKind = (SubRI.r_length == 3) ? Delta64 : Delta32;
+      DeltaKind = (SubRI.r_length == 3) ? x86_64::Delta64 : x86_64::Delta32;
       Addend = FixupValue + (FixupAddress - FromSymbol->getAddress());
       // FIXME: handle extern 'from'.
     } else if (&BlockToFix == &ToSymbol->getAddressable()) {
       TargetSymbol = FromSymbol;
-      DeltaKind = (SubRI.r_length == 3) ? NegDelta64 : NegDelta32;
+      DeltaKind =
+          (SubRI.r_length == 3) ? x86_64::NegDelta64 : x86_64::NegDelta32;
       Addend = FixupValue - (FixupAddress - ToSymbol->getAddress());
     } else {
       // BlockToFix was neither FromSymbol nor ToSymbol.
       return make_error<JITLinkError>("SUBTRACTOR relocation must fix up "
                                       "either 'A' or 'B' (or a symbol in one "
                                       "of their alt-entry chains)");
     }
 
for (auto &S : Obj.sections()) {
       }
 
       // Add relocations for section.
       for (auto RelItr = S.relocation_begin(), RelEnd = S.relocation_end();
            RelItr != RelEnd; ++RelItr) {
 
         MachO::relocation_info RI = getRelocationInfo(RelItr);
 
-        // Sanity check the relocation kind.
-        auto Kind = getRelocationKind(RI);
-        if (!Kind)
-          return Kind.takeError();
-
         // Find the address of the value to fix up.
         JITTargetAddress FixupAddress = SectionAddress + (uint32_t)RI.r_address;
 
         LLVM_DEBUG({
           auto &NSec =
               getSectionByIndex(Obj.getSectionIndex(S.getRawDataRefImpl()));
           dbgs() << "  " << NSec.SectName << " + "
                  << formatv("{0:x8}", RI.r_address) << ":\n";
for (auto &S : Obj.sections()) {
             BlockToFix->getAddress() + BlockToFix->getContent().size())
           return make_error<JITLinkError>(
               "Relocation extends past end of fixup block");
 
         // Get a pointer to the fixup content.
         const char *FixupContent = BlockToFix->getContent().data() +
                                    (FixupAddress - BlockToFix->getAddress());
 
+        size_t FixupOffset = FixupAddress - BlockToFix->getAddress();
+
         // The target symbol and addend will be populated by the switch below.
         Symbol *TargetSymbol = nullptr;
         uint64_t Addend = 0;
 
-        switch (*Kind) {
-        case Branch32:
-        case PCRel32:
-        case PCRel32GOTLoad:
-        case PCRel32GOT:
+        // Sanity check the relocation kind.
+        auto MachORelocKind = getRelocKind(RI);
+        if (!MachORelocKind)
+          return MachORelocKind.takeError();
+
+        Edge::Kind Kind = Edge::Invalid;
+
+        switch (*MachORelocKind) {
+        case MachOBranch32:
+          if (auto TargetSymbolOrErr = findSymbolByIndex(RI.r_symbolnum))
+            TargetSymbol = TargetSymbolOrErr->GraphSymbol;
+          else
+            return TargetSymbolOrErr.takeError();
+          Addend = *(const little32_t *)FixupContent;
+          Kind = x86_64::BranchPCRel32;
+          break;
+        case MachOPCRel32:
+          if (auto TargetSymbolOrErr = findSymbolByIndex(RI.r_symbolnum))
+            TargetSymbol = TargetSymbolOrErr->GraphSymbol;
+          else
+            return TargetSymbolOrErr.takeError();
+          Addend = *(const little32_t *)FixupContent - 4;
+          Kind = x86_64::Delta32;
+          break;
+        case MachOPCRel32GOTLoad:
           if (auto TargetSymbolOrErr = findSymbolByIndex(RI.r_symbolnum))
             TargetSymbol = TargetSymbolOrErr->GraphSymbol;
           else
             return TargetSymbolOrErr.takeError();
           Addend = *(const little32_t *)FixupContent;
+          Kind = x86_64::RequestGOTAndTransformToPCRel32GOTLoadRelaxable;
+          if (FixupOffset < 3)
+            return make_error<JITLinkError>("GOTLD at invalid offset " +
+                                            formatv("{0}", FixupOffset));
           break;
-        case Pointer32:
+        case MachOPCRel32GOT:
+          if (auto TargetSymbolOrErr = findSymbolByIndex(RI.r_symbolnum))
+            TargetSymbol = TargetSymbolOrErr->GraphSymbol;
+          else
+            return TargetSymbolOrErr.takeError();
+          Addend = *(const little32_t *)FixupContent - 4;
+          Kind = x86_64::RequestGOTAndTransformToDelta32;
+          break;
+        case MachOPointer32:
           if (auto TargetSymbolOrErr = findSymbolByIndex(RI.r_symbolnum))
             TargetSymbol = TargetSymbolOrErr->GraphSymbol;
           else
             return TargetSymbolOrErr.takeError();
           Addend = *(const ulittle32_t *)FixupContent;
+          Kind = x86_64::Pointer32;
           break;
-        case Pointer64:
+        case MachOPointer64:
           if (auto TargetSymbolOrErr = findSymbolByIndex(RI.r_symbolnum))
             TargetSymbol = TargetSymbolOrErr->GraphSymbol;
           else
             return TargetSymbolOrErr.takeError();
           Addend = *(const ulittle64_t *)FixupContent;
+          Kind = x86_64::Pointer64;
           break;
-        case Pointer64Anon: {
+        case MachOPointer64Anon: {
           JITTargetAddress TargetAddress = *(const ulittle64_t *)FixupContent;
           if (auto TargetSymbolOrErr = findSymbolByAddress(TargetAddress))
             TargetSymbol = &*TargetSymbolOrErr;
           else
             return TargetSymbolOrErr.takeError();
           Addend = TargetAddress - TargetSymbol->getAddress();
+          Kind = x86_64::Pointer64;
           break;
         }
-        case PCRel32Minus1:
-        case PCRel32Minus2:
-        case PCRel32Minus4:
+        case MachOPCRel32Minus1:
+        case MachOPCRel32Minus2:
+        case MachOPCRel32Minus4:
           if (auto TargetSymbolOrErr = findSymbolByIndex(RI.r_symbolnum))
             TargetSymbol = TargetSymbolOrErr->GraphSymbol;
           else
             return TargetSymbolOrErr.takeError();
-          Addend = *(const little32_t *)FixupContent +
-                   (1 << (*Kind - PCRel32Minus1));
+          Addend = *(const little32_t *)FixupContent - 4;
+          // -
+          //   (1 << (*MachORelocKind - MachOPCRel32Minus1));
+          Kind = x86_64::Delta32;
           break;
-        case PCRel32Anon: {
+        case MachOPCRel32Anon: {
           JITTargetAddress TargetAddress =
               FixupAddress + 4 + *(const little32_t *)FixupContent;
           if (auto TargetSymbolOrErr = findSymbolByAddress(TargetAddress))
             TargetSymbol = &*TargetSymbolOrErr;
           else
             return TargetSymbolOrErr.takeError();
-          Addend = TargetAddress - TargetSymbol->getAddress();
+          Addend = TargetAddress - TargetSymbol->getAddress() - 4;
+          Kind = x86_64::Delta32;
           break;
         }
-        case PCRel32Minus1Anon:
-        case PCRel32Minus2Anon:
-        case PCRel32Minus4Anon: {
+        case MachOPCRel32Minus1Anon:
+        case MachOPCRel32Minus2Anon:
+        case MachOPCRel32Minus4Anon: {
           JITTargetAddress Delta =
-              static_cast<JITTargetAddress>(1ULL << (*Kind - PCRel32Minus1Anon));
+              4 + static_cast<JITTargetAddress>(
+                      1ULL << (*MachORelocKind - MachOPCRel32Minus1Anon));
           JITTargetAddress TargetAddress =
-              FixupAddress + 4 + Delta + *(const little32_t *)FixupContent;
+              FixupAddress + Delta + *(const little32_t *)FixupContent;
           if (auto TargetSymbolOrErr = findSymbolByAddress(TargetAddress))
             TargetSymbol = &*TargetSymbolOrErr;
           else
             return TargetSymbolOrErr.takeError();
-          Addend = TargetAddress - TargetSymbol->getAddress();
+          Addend = TargetAddress - TargetSymbol->getAddress() - Delta;
+          Kind = x86_64::Delta32;
           break;
         }
-        case Delta32:
-        case Delta64: {
+        case MachOSubtractor32:
+        case MachOSubtractor64: {
           // We use Delta32/Delta64 to represent SUBTRACTOR relocations.
           // parsePairRelocation handles the paired reloc, and returns the
           // edge kind to be used (either Delta32/Delta64, or
           // NegDelta32/NegDelta64, depending on the direction of the
           // subtraction) along with the addend.
           auto PairInfo =
-              parsePairRelocation(*BlockToFix, *Kind, RI, FixupAddress,
-                                  FixupContent, ++RelItr, RelEnd);
+              parsePairRelocation(*BlockToFix, *MachORelocKind, RI,
+                                  FixupAddress, FixupContent, ++RelItr, RelEnd);
           if (!PairInfo)
             return PairInfo.takeError();
-          std::tie(*Kind, TargetSymbol, Addend) = *PairInfo;
+          std::tie(Kind, TargetSymbol, Addend) = *PairInfo;
           assert(TargetSymbol && "No target symbol from parsePairRelocation?");
           break;
         }
-        case PCRel32TLV:
+        case MachOPCRel32TLV:
           return make_error<JITLinkError>(
               "MachO TLV relocations not yet supported");
-        default:
-          llvm_unreachable("Special relocation kind should not appear in "
-                           "mach-o file");
         }
 
         LLVM_DEBUG({
           dbgs() << "    ";
-          Edge GE(*Kind, FixupAddress - BlockToFix->getAddress(), *TargetSymbol,
+          Edge GE(Kind, FixupAddress - BlockToFix->getAddress(), *TargetSymbol,
                   Addend);
-          printEdge(dbgs(), *BlockToFix, GE,
-                    getMachOX86RelocationKindName(*Kind));
+          printEdge(dbgs(), *BlockToFix, GE, x86_64::getEdgeKindName(Kind));
           dbgs() << "\n";
         });
-        BlockToFix->addEdge(*Kind, FixupAddress - BlockToFix->getAddress(),
+        BlockToFix->addEdge(Kind, FixupAddress - BlockToFix->getAddress(),
                             *TargetSymbol, Addend);
       }
     }
     return Error::success();
   }
 };
 
 class MachO_x86_64_GOTAndStubsBuilder
     : public BasicGOTAndStubsBuilder<MachO_x86_64_GOTAndStubsBuilder> {
 public:
   static const uint8_t NullGOTEntryContent[8];
   static const uint8_t StubContent[6];
 
   MachO_x86_64_GOTAndStubsBuilder(LinkGraph &G)
       : BasicGOTAndStubsBuilder<MachO_x86_64_GOTAndStubsBuilder>(G) {}
 
-  bool isGOTEdge(Edge &E) const {
-    return E.getKind() == PCRel32GOT || E.getKind() == PCRel32GOTLoad;
+  bool isGOTEdgeToFix(Edge &E) const {
+    return E.getKind() == x86_64::RequestGOTAndTransformToDelta32 ||
+           E.getKind() ==
+               x86_64::RequestGOTAndTransformToPCRel32GOTLoadRelaxable;
   }
 
   Symbol &createGOTEntry(Symbol &Target) {
     auto &GOTEntryBlock = G.createContentBlock(
         getGOTSection(), getGOTEntryBlockContent(), 0, 8, 0);
-    GOTEntryBlock.addEdge(Pointer64, 0, Target, 0);
+    GOTEntryBlock.addEdge(x86_64::Pointer64, 0, Target, 0);
     return G.addAnonymousSymbol(GOTEntryBlock, 0, 8, false, false);
   }
 
   void fixGOTEdge(Edge &E, Symbol &GOTEntry) {
-    assert((E.getKind() == PCRel32GOT || E.getKind() == PCRel32GOTLoad) &&
-           "Not a GOT edge?");
-    // If this is a PCRel32GOT then change it to an ordinary PCRel32. If it is
-    // a PCRel32GOTLoad then leave it as-is for now. We will use the kind to
-    // check for GOT optimization opportunities in the
-    // optimizeMachO_x86_64_GOTAndStubs pass below.
-    if (E.getKind() == PCRel32GOT)
-      E.setKind(PCRel32);
-
+    // Fix the edge kind.
+    switch (E.getKind()) {
+    case x86_64::RequestGOTAndTransformToDelta32:
+      E.setKind(x86_64::Delta32);
+      break;
+    case x86_64::RequestGOTAndTransformToPCRel32GOTLoadRelaxable:
+      E.setKind(x86_64::PCRel32GOTLoadRelaxable);
+      break;
+    default:
+      llvm_unreachable("Not a GOT transform edge");
+    }
+    // Fix the target, leave the addend as-is.
     E.setTarget(GOTEntry);
-    // Leave the edge addend as-is.
   }
 
   bool isExternalBranchEdge(Edge &E) {
-    return E.getKind() == Branch32 && !E.getTarget().isDefined();
+    return E.getKind() == x86_64::BranchPCRel32 && E.getTarget().isExternal();
   }
 
   Symbol &createStub(Symbol &Target) {
     auto &StubContentBlock =
         G.createContentBlock(getStubsSection(), getStubBlockContent(), 0, 1, 0);
     // Re-use GOT entries for stub targets.
     auto &GOTEntrySymbol = getGOTEntrySymbol(Target);
-    StubContentBlock.addEdge(PCRel32, 2, GOTEntrySymbol, 0);
+    StubContentBlock.addEdge(x86_64::Delta32, 2, GOTEntrySymbol, -4);
     return G.addAnonymousSymbol(StubContentBlock, 0, 6, true, false);
   }
 
   void fixExternalBranchEdge(Edge &E, Symbol &Stub) {
-    assert(E.getKind() == Branch32 && "Not a Branch32 edge?");
-    assert(E.getAddend() == 0 && "Branch32 edge has non-zero addend?");
+    assert(E.getKind() == x86_64::BranchPCRel32 && "Not a Branch32 edge?");
+    assert(E.getAddend() == 0 &&
+           "BranchPCRel32 edge has unexpected addend value");
 
-    // Set the edge kind to Branch32ToStub. We will use this to check for stub
-    // optimization opportunities in the optimizeMachO_x86_64_GOTAndStubs pass
-    // below.
-    E.setKind(Branch32ToStub);
+    // Set the edge kind to BranchPCRel32ToPtrJumpStubRelaxable. We will use
+    // this to check for stub optimization opportunities in the
+    // optimizeMachO_x86_64_GOTAndStubs pass below.
+    E.setKind(x86_64::BranchPCRel32ToPtrJumpStubRelaxable);
     E.setTarget(Stub);
   }
 
 private:
   Section &getGOTSection() {
     if (!GOTSection)
       GOTSection = &G.createSection("$__GOT", sys::Memory::MF_READ);
     return *GOTSection;
const uint8_t MachO_x86_64_GOTAndStubsBuilder::StubContent[6] = {
     0xFF, 0x25, 0x00, 0x00, 0x00, 0x00};
 } // namespace
 
 static Error optimizeMachO_x86_64_GOTAndStubs(LinkGraph &G) {
   LLVM_DEBUG(dbgs() << "Optimizing GOT entries and stubs:\n");
 
   for (auto *B : G.blocks())
     for (auto &E : B->edges())
-      if (E.getKind() == PCRel32GOTLoad) {
+      if (E.getKind() == x86_64::PCRel32GOTLoadRelaxable) {
         assert(E.getOffset() >= 3 && "GOT edge occurs too early in block");
 
-        // Switch the edge kind to PCRel32: Whether we change the edge target
-        // or not this will be the desired kind.
-        E.setKind(PCRel32);
-
         // Optimize GOT references.
         auto &GOTBlock = E.getTarget().getBlock();
         assert(GOTBlock.getSize() == G.getPointerSize() &&
                "GOT entry block should be pointer sized");
         assert(GOTBlock.edges_size() == 1 &&
                "GOT entry should only have one outgoing edge");
 
         auto &GOTTarget = GOTBlock.edges().begin()->getTarget();
         JITTargetAddress EdgeAddr = B->getAddress() + E.getOffset();
         JITTargetAddress TargetAddr = GOTTarget.getAddress();
 
         // Check that this is a recognized MOV instruction.
         // FIXME: Can we assume this?
         constexpr uint8_t MOVQRIPRel[] = {0x48, 0x8b};
         if (strncmp(B->getContent().data() + E.getOffset() - 3,
                     reinterpret_cast<const char *>(MOVQRIPRel), 2) != 0)
           continue;
 
         int64_t Displacement = TargetAddr - EdgeAddr + 4;
         if (Displacement >= std::numeric_limits<int32_t>::min() &&
             Displacement <= std::numeric_limits<int32_t>::max()) {
           E.setTarget(GOTTarget);
+          E.setKind(x86_64::Delta32);
+          E.setAddend(E.getAddend() - 4);
           auto *BlockData = reinterpret_cast<uint8_t *>(
               const_cast<char *>(B->getContent().data()));
           BlockData[E.getOffset() - 2] = 0x8d;
           LLVM_DEBUG({
             dbgs() << "  Replaced GOT load wih LEA:\n    ";
-            printEdge(dbgs(), *B, E,
-                      getMachOX86RelocationKindName(E.getKind()));
+            printEdge(dbgs(), *B, E, x86_64::getEdgeKindName(E.getKind()));
             dbgs() << "\n";
           });
         }
-      } else if (E.getKind() == Branch32ToStub) {
-
-        // Switch the edge kind to PCRel32: Whether we change the edge target
-        // or not this will be the desired kind.
-        E.setKind(Branch32);
-
+      } else if (E.getKind() == x86_64::BranchPCRel32ToPtrJumpStubRelaxable) {
         auto &StubBlock = E.getTarget().getBlock();
         assert(StubBlock.getSize() ==
                    sizeof(MachO_x86_64_GOTAndStubsBuilder::StubContent) &&
                "Stub block should be stub sized");
         assert(StubBlock.edges_size() == 1 &&
                "Stub block should only have one outgoing edge");
 
         auto &GOTBlock = StubBlock.edges().begin()->getTarget().getBlock();
         assert(GOTBlock.getSize() == G.getPointerSize() &&
                "GOT block should be pointer sized");
         assert(GOTBlock.edges_size() == 1 &&
                "GOT block should only have one outgoing edge");
 
         auto &GOTTarget = GOTBlock.edges().begin()->getTarget();
         JITTargetAddress EdgeAddr = B->getAddress() + E.getOffset();
         JITTargetAddress TargetAddr = GOTTarget.getAddress();
 
         int64_t Displacement = TargetAddr - EdgeAddr + 4;
         if (Displacement >= std::numeric_limits<int32_t>::min() &&
             Displacement <= std::numeric_limits<int32_t>::max()) {
+          E.setKind(x86_64::BranchPCRel32);
           E.setTarget(GOTTarget);
           LLVM_DEBUG({
             dbgs() << "  Replaced stub branch with direct branch:\n    ";
-            printEdge(dbgs(), *B, E,
-                      getMachOX86RelocationKindName(E.getKind()));
+            printEdge(dbgs(), *B, E, x86_64::getEdgeKindName(E.getKind()));
             dbgs() << "\n";
           });
         }
       }
 
   return Error::success();
 }
 
 namespace llvm {
 namespace jitlink {
 
 class MachOJITLinker_x86_64 : public JITLinker<MachOJITLinker_x86_64> {
   friend class JITLinker<MachOJITLinker_x86_64>;
 
 public:
   MachOJITLinker_x86_64(std::unique_ptr<JITLinkContext> Ctx,
                         std::unique_ptr<LinkGraph> G,
                         PassConfiguration PassConfig)
       : JITLinker(std::move(Ctx), std::move(G), std::move(PassConfig)) {}
 
 private:
-  StringRef getEdgeKindName(Edge::Kind R) const override {
-    return getMachOX86RelocationKindName(R);
-  }
-
-  static Error targetOutOfRangeError(const Block &B, const Edge &E) {
-    std::string ErrMsg;
-    {
-      raw_string_ostream ErrStream(ErrMsg);
-      ErrStream << "Relocation target out of range: ";
-      printEdge(ErrStream, B, E, getMachOX86RelocationKindName(E.getKind()));
-      ErrStream << "\n";
-    }
-    return make_error<JITLinkError>(std::move(ErrMsg));
-  }
 
   Error applyFixup(Block &B, const Edge &E, char *BlockWorkingMem) const {
-
-    using namespace support;
-
-    char *FixupPtr = BlockWorkingMem + E.getOffset();
-    JITTargetAddress FixupAddress = B.getAddress() + E.getOffset();
-
-    switch (E.getKind()) {
-    case Branch32:
-    case PCRel32:
-    case PCRel32Anon: {
-      int64_t Value =
-          E.getTarget().getAddress() - (FixupAddress + 4) + E.getAddend();
-      if (Value < std::numeric_limits<int32_t>::min() ||
-          Value > std::numeric_limits<int32_t>::max())
-        return targetOutOfRangeError(B, E);
-      *(little32_t *)FixupPtr = Value;
-      break;
-    }
-    case Pointer64:
-    case Pointer64Anon: {
-      uint64_t Value = E.getTarget().getAddress() + E.getAddend();
-      *(ulittle64_t *)FixupPtr = Value;
-      break;
-    }
-    case PCRel32Minus1:
-    case PCRel32Minus2:
-    case PCRel32Minus4: {
-      int Delta = 4 + (1 << (E.getKind() - PCRel32Minus1));
-      int64_t Value =
-          E.getTarget().getAddress() - (FixupAddress + Delta) + E.getAddend();
-      if (Value < std::numeric_limits<int32_t>::min() ||
-          Value > std::numeric_limits<int32_t>::max())
-        return targetOutOfRangeError(B, E);
-      *(little32_t *)FixupPtr = Value;
-      break;
-    }
-    case PCRel32Minus1Anon:
-    case PCRel32Minus2Anon:
-    case PCRel32Minus4Anon: {
-      int Delta = 4 + (1 << (E.getKind() - PCRel32Minus1Anon));
-      int64_t Value =
-          E.getTarget().getAddress() - (FixupAddress + Delta) + E.getAddend();
-      if (Value < std::numeric_limits<int32_t>::min() ||
-          Value > std::numeric_limits<int32_t>::max())
-        return targetOutOfRangeError(B, E);
-      *(little32_t *)FixupPtr = Value;
-      break;
-    }
-    case Delta32:
-    case Delta64:
-    case NegDelta32:
-    case NegDelta64: {
-      int64_t Value;
-      if (E.getKind() == Delta32 || E.getKind() == Delta64)
-        Value = E.getTarget().getAddress() - FixupAddress + E.getAddend();
-      else
-        Value = FixupAddress - E.getTarget().getAddress() + E.getAddend();
-
-      if (E.getKind() == Delta32 || E.getKind() == NegDelta32) {
-        if (Value < std::numeric_limits<int32_t>::min() ||
-            Value > std::numeric_limits<int32_t>::max())
-          return targetOutOfRangeError(B, E);
-        *(little32_t *)FixupPtr = Value;
-      } else
-        *(little64_t *)FixupPtr = Value;
-      break;
-    }
-    case Pointer32: {
-      uint64_t Value = E.getTarget().getAddress() + E.getAddend();
-      if (Value > std::numeric_limits<uint32_t>::max())
-        return targetOutOfRangeError(B, E);
-      *(ulittle32_t *)FixupPtr = Value;
-      break;
-    }
-    default:
-      llvm_unreachable("Unrecognized edge kind");
-    }
-
-    return Error::success();
+    return x86_64::applyFixup(B, E, BlockWorkingMem);
   }
-
-  uint64_t NullValue = 0;
 };
 
 Expected<std::unique_ptr<LinkGraph>>
 createLinkGraphFromMachOObject_x86_64(MemoryBufferRef ObjectBuffer) {
   auto MachOObj = object::ObjectFile::createMachOObjectFile(ObjectBuffer);
   if (!MachOObj)
     return MachOObj.takeError();
   return MachOLinkGraphBuilder_x86_64(**MachOObj).buildGraph();
 }
 
 void link_MachO_x86_64(std::unique_ptr<LinkGraph> G,
                        std::unique_ptr<JITLinkContext> Ctx) {
 
   PassConfiguration Config;
 
   if (Ctx->shouldAddDefaultTargetPasses(G->getTargetTriple())) {
     // Add eh-frame passses.
     Config.PrePrunePasses.push_back(EHFrameSplitter("__eh_frame"));
-    Config.PrePrunePasses.push_back(EHFrameEdgeFixer(
-        "__eh_frame", G->getPointerSize(), Delta64, Delta32, NegDelta32));
+    Config.PrePrunePasses.push_back(
+        EHFrameEdgeFixer("__eh_frame", G->getPointerSize(), x86_64::Delta64,
+                         x86_64::Delta32, x86_64::NegDelta32));
 
     // Add a mark-live pass.
     if (auto MarkLive = Ctx->getMarkLivePass(G->getTargetTriple()))
       Config.PrePrunePasses.push_back(std::move(MarkLive));
     else
       Config.PrePrunePasses.push_back(markAllSymbolsLive);
 
     // Add an in-place GOT/Stubs pass.
     Config.PostPrunePasses.push_back([](LinkGraph &G) -> Error {
       MachO_x86_64_GOTAndStubsBuilder(G).run();
       return Error::success();
     });
 
     // Add GOT/Stubs optimizer pass.
     Config.PreFixupPasses.push_back(optimizeMachO_x86_64_GOTAndStubs);
   }
 
   if (auto Err = Ctx->modifyPassConfig(*G, Config))
     return Ctx->notifyFailed(std::move(Err));
 
   // Construct a JITLinker and run the link function.
   MachOJITLinker_x86_64::link(std::move(Ctx), std::move(G), std::move(Config));
 }
 
-StringRef getMachOX86RelocationKindName(Edge::Kind R) {
-  switch (R) {
-  case Branch32:
-    return "Branch32";
-  case Branch32ToStub:
-    return "Branch32ToStub";
-  case Pointer32:
-    return "Pointer32";
-  case Pointer64:
-    return "Pointer64";
-  case Pointer64Anon:
-    return "Pointer64Anon";
-  case PCRel32:
-    return "PCRel32";
-  case PCRel32Minus1:
-    return "PCRel32Minus1";
-  case PCRel32Minus2:
-    return "PCRel32Minus2";
-  case PCRel32Minus4:
-    return "PCRel32Minus4";
-  case PCRel32Anon:
-    return "PCRel32Anon";
-  case PCRel32Minus1Anon:
-    return "PCRel32Minus1Anon";
-  case PCRel32Minus2Anon:
-    return "PCRel32Minus2Anon";
-  case PCRel32Minus4Anon:
-    return "PCRel32Minus4Anon";
-  case PCRel32GOTLoad:
-    return "PCRel32GOTLoad";
-  case PCRel32GOT:
-    return "PCRel32GOT";
-  case PCRel32TLV:
-    return "PCRel32TLV";
-  case Delta32:
-    return "Delta32";
-  case Delta64:
-    return "Delta64";
-  case NegDelta32:
-    return "NegDelta32";
-  case NegDelta64:
-    return "NegDelta64";
-  default:
-    return getGenericEdgeKindName(static_cast<Edge::Kind>(R));
-  }
-}
-
 } // end namespace jitlink
 } // end namespace llvm

llvm/lib/ExecutionEngine/JITLink/x86_64.cpp

+//===----- x86_64.cpp - Generic JITLink x86-64 edge kinds, utilities ------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Generic utilities for graphs representing x86-64 objects.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ExecutionEngine/JITLink/x86_64.h"
+
+#define DEBUG_TYPE "jitlink"
+
+namespace llvm {
+namespace jitlink {
+namespace x86_64 {
+
+const char *getEdgeKindName(Edge::Kind K) {
+  switch (K) {
+  case Pointer64:
+    return "Pointer64";
+  case Pointer32:
+    return "Pointer32";
+  case Delta64:
+    return "Delta64";
+  case Delta32:
+    return "Delta32";
+  case NegDelta64:
+    return "NegDelta64";
+  case NegDelta32:
+    return "NegDelta32";
+  case BranchPCRel32:
+    return "BranchPCRel32";
+  case BranchPCRel32ToPtrJumpStub:
+    return "BranchPCRel32ToPtrJumpStub";
+  case BranchPCRel32ToPtrJumpStubRelaxable:
+    return "BranchPCRel32ToPtrJumpStubRelaxable";
+  case RequestGOTAndTransformToDelta32:
+    return "RequestGOTAndTransformToDelta32";
+  case PCRel32GOTLoadRelaxable:
+    return "PCRel32GOTLoadRelaxable";
+  case RequestGOTAndTransformToPCRel32GOTLoadRelaxable:
+    return "RequestGOTAndTransformToPCRel32GOTLoadRelaxable";
+  case PCRel32TLVPLoadRelaxable:
+    return "PCRel32TLVPLoadRelaxable";
+  case RequestTLVPAndTransformToPCRel32TLVPLoadRelaxable:
+    return "RequestTLVPAndTransformToPCRel32TLVPLoadRelaxable";
+  default:
+    return getGenericEdgeKindName(static_cast<Edge::Kind>(K));
+  }
+}
+
+} // end namespace x86_64
+} // end namespace jitlink
+} // end namespace llvm

llvm/unittests/ExecutionEngine/JITLink/LinkGraphTests.cpp

 
 static const char BlockContentBytes[] = {0x10, 0x11, 0x12, 0x13, 0x14, 0x15,
                                          0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B,
                                          0x1C, 0x1D, 0x1E, 0x1F, 0x00};
 static StringRef BlockContent(BlockContentBytes);
 
 TEST(LinkGraphTest, Construction) {
   // Check that LinkGraph construction works as expected.
-  LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, support::little);
+  LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, support::little,
+              getGenericEdgeKindName);
   EXPECT_EQ(G.getName(), "foo");
   EXPECT_EQ(G.getTargetTriple().str(), "x86_64-apple-darwin");
   EXPECT_EQ(G.getPointerSize(), 8U);
   EXPECT_EQ(G.getEndianness(), support::little);
   EXPECT_TRUE(llvm::empty(G.external_symbols()));
   EXPECT_TRUE(llvm::empty(G.absolute_symbols()));
   EXPECT_TRUE(llvm::empty(G.defined_symbols()));
   EXPECT_TRUE(llvm::empty(G.blocks()));
 }
 
 TEST(LinkGraphTest, AddressAccess) {
   // Check that we can get addresses for blocks, symbols, and edges.
-  LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, support::little);
+  LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, support::little,
+              getGenericEdgeKindName);
 
   auto Sec1 = G.createSection("__data.1", RWFlags);
   auto &B1 = G.createContentBlock(Sec1, BlockContent, 0x1000, 8, 0);
   auto &S1 = G.addDefinedSymbol(B1, 4, "S1", 4, Linkage::Strong, Scope::Default,
                                 false, false);
   B1.addEdge(Edge::FirstRelocation, 8, S1, 0);
   auto &E1 = *B1.edges().begin();
 
   EXPECT_EQ(B1.getAddress(), 0x1000U) << "Incorrect block address";
   EXPECT_EQ(S1.getAddress(), 0x1004U) << "Incorrect symbol address";
   EXPECT_EQ(B1.getFixupAddress(E1), 0x1008U) << "Incorrect fixup address";
 }
 
 TEST(LinkGraphTest, BlockAndSymbolIteration) {
   // Check that we can iterate over blocks within Sections and across sections.
-  LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, support::little);
+  LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, support::little,
+              getGenericEdgeKindName);
   auto &Sec1 = G.createSection("__data.1", RWFlags);
   auto &B1 = G.createContentBlock(Sec1, BlockContent, 0x1000, 8, 0);
   auto &B2 = G.createContentBlock(Sec1, BlockContent, 0x2000, 8, 0);
   auto &S1 = G.addDefinedSymbol(B1, 0, "S1", 4, Linkage::Strong, Scope::Default,
                                 false, false);
   auto &S2 = G.addDefinedSymbol(B2, 4, "S2", 4, Linkage::Strong, Scope::Default,
                                 false, false);
 

 TEST(LinkGraphTest, SplitBlock) {
   // Check that the LinkGraph::splitBlock test works as expected.
 
   const char BlockContentBytes[] = {0x10, 0x11, 0x12, 0x13, 0x14, 0x15,
                                     0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B,
                                     0x1C, 0x1D, 0x1E, 0x1F, 0x00};
   StringRef BlockContent(BlockContentBytes);
 
-  LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, support::little);
+  LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, support::little,
+              getGenericEdgeKindName);
   auto &Sec = G.createSection("__data", RWFlags);
 
   // Create the block to split.
   auto &B1 = G.createContentBlock(Sec, BlockContent, 0x1000, 8, 0);
 
   // Add some symbols to the block.
   auto &S1 = G.addDefinedSymbol(B1, 0, "S1", 4, Linkage::Strong, Scope::Default,
                                 false, false);