[JITLink][COFF][x86_64] Implement SECTION/SECREL relocation.

[sunho]

Summary

Implements SECTION/SECREL relocation. These are used by debug info (pdb) data.

[lhames]

What is Const16 used for?

I think we want to maintain the invariant that all edges point at symbols. We could use an absolute symbol for this if we allow for the idea that absolute symbols can be used for values other than addresses.

Alternatively, could the value be baked into the contents by the LinkGraphBuilder?

[sunho]

Use absolute symbol.

[lhames]

LGTM, other than the change to the assert condition.

Thanks @sunho!

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

1105–1110

Why has the S == Scope::Local check been removed?

It's an odd "feature" but LinkGraph does permit duplicate names for local symbols, because they can crop up in real objects produced by ld -r and other tools.

llvm/lib/ExecutionEngine/Orc/ObjectLinkingLayer.cpp

540–542

This is a nice catch. I guess we're missing absolute symbol support test coverage.

[lhames]

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

1105–1110

/facepalm.

I read the change backwards. Thanks for adding the check. :)

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

Symbol &addExternalSymbol(StringRef Name, orc::ExecutorAddrDiff Size,
     ExternalSymbols.insert(&Sym);
     return Sym;
   }
 
   /// Add an absolute symbol.
   Symbol &addAbsoluteSymbol(StringRef Name, orc::ExecutorAddr Address,
                             orc::ExecutorAddrDiff Size, Linkage L, Scope S,
                             bool IsLive) {
-    assert(llvm::count_if(AbsoluteSymbols,
+    assert(S == Scope::Local || llvm::count_if(AbsoluteSymbols,
                                                [&](const Symbol *Sym) {
                                                  return Sym->getName() == Name;
                                                }) == 0 &&
                                     "Duplicate absolute symbol");
     auto &Sym = Symbol::constructAbsolute(Allocator.Allocate<Symbol>(),
                                           createAddressable(Address), Name,
                                           Size, L, S, IsLive);
     AbsoluteSymbols.insert(&Sym);
     return Sym;
   }
 
   /// Convenience method for adding a weak zero-fill symbol.
   Symbol &addCommonSymbol(StringRef Name, Scope S, Section &Section,

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

enum EdgeKind_x86_64 : Edge::Kind {
   /// Fixup expression:
   ///   Fixup <- Target + Addend : int32
   ///
   /// Errors:
   ///   - The target must reside in the signed 32-bits([-2**31, 2**32 - 1]) of
   ///   the address space, otherwise an out-of-range error will be returned.
   Pointer32Signed,
 
+  /// A plain 16-bit pointer value relocation.
+  ///
+  /// Fixup expression:
+  ///   Fixup <- Target + Addend : uint16
+  ///
+  /// Errors:
+  ///   - The target must reside in the low 16-bits of the address space,
+  ///     otherwise an out-of-range error will be returned.
+  ///
+  Pointer16,
+
   /// A 64-bit delta.
   ///
   /// Delta from the fixup to the target.
   ///
   /// Fixup expression:
   ///   Fixup <- Target - Fixup + Addend : int64
   ///
   Delta64,
case Pointer32Signed: {
     int64_t Value = E.getTarget().getAddress().getValue() + E.getAddend();
     if (LLVM_LIKELY(isInRangeForImmS32(Value)))
       *(little32_t *)FixupPtr = Value;
     else
       return makeTargetOutOfRangeError(G, B, E);
     break;
   }
 
+  case Pointer16: {
+    uint64_t Value = E.getTarget().getAddress().getValue() + E.getAddend();
+    if (LLVM_LIKELY(isUInt<16>(Value)))
+      *(ulittle16_t *)FixupPtr = Value;
+    else
+      return makeTargetOutOfRangeError(G, B, E);
+    break;
+  }
+
   case PCRel32:
   case BranchPCRel32:
   case BranchPCRel32ToPtrJumpStub:
   case BranchPCRel32ToPtrJumpStubBypassable:
   case PCRel32GOTLoadRelaxable:
   case PCRel32GOTLoadREXRelaxable:
   case PCRel32TLVPLoadREXRelaxable: {
     int64_t Value =

llvm/lib/ExecutionEngine/JITLink/COFF_x86_64.cpp

 using namespace llvm::jitlink;
 
 namespace {
 
 enum EdgeKind_coff_x86_64 : Edge::Kind {
   PCRel32 = x86_64::FirstPlatformRelocation,
   Pointer32NB,
   Pointer64,
+  SectionIdx16,
+  SecRel32,
 };
 
 class COFFJITLinker_x86_64 : public JITLinker<COFFJITLinker_x86_64> {
   friend class JITLinker<COFFJITLinker_x86_64>;
 
 public:
   COFFJITLinker_x86_64(std::unique_ptr<JITLinkContext> Ctx,
                        std::unique_ptr<LinkGraph> G,
case COFF::RelocationTypeAMD64::IMAGE_REL_AMD64_REL32_5: {
       Addend -= 5;
       break;
     }
     case COFF::RelocationTypeAMD64::IMAGE_REL_AMD64_ADDR64: {
       Kind = EdgeKind_coff_x86_64::Pointer64;
       Addend = *reinterpret_cast<const support::little64_t *>(FixupPtr);
       break;
     }
+    case COFF::RelocationTypeAMD64::IMAGE_REL_AMD64_SECTION: {
+      Kind = EdgeKind_coff_x86_64::SectionIdx16;
+      Addend = *reinterpret_cast<const support::little16_t *>(FixupPtr);
+      uint64_t SectionIdx = 0;
+      if (COFFSymbol.isAbsolute())
+        SectionIdx = getObject().getNumberOfSections() + 1;
+      else
+        SectionIdx = COFFSymbol.getSectionNumber();
+      auto *AbsSym = &getGraph().addAbsoluteSymbol(
+          "secidx", orc::ExecutorAddr(SectionIdx), 2, Linkage::Strong,
+          Scope::Local, false);
+      GraphSymbol = AbsSym;
+      break;
+    }
+    case COFF::RelocationTypeAMD64::IMAGE_REL_AMD64_SECREL: {
+      Kind = EdgeKind_coff_x86_64::SecRel32;
+      Addend = *reinterpret_cast<const support::little32_t *>(FixupPtr);
+      break;
+    }
     default: {
       return make_error<JITLinkError>("Unsupported x86_64 relocation:" +
                                       formatv("{0:d}", Rel.getType()));
     }
     };
 
     Edge GE(Kind, Offset, *GraphSymbol, Addend);
     LLVM_DEBUG({
for (auto *B : G.blocks()) {
         case EdgeKind_coff_x86_64::PCRel32: {
           E.setKind(x86_64::PCRel32);
           break;
         }
         case EdgeKind_coff_x86_64::Pointer64: {
           E.setKind(x86_64::Pointer64);
           break;
         }
+        case EdgeKind_coff_x86_64::SectionIdx16: {
+          E.setKind(x86_64::Pointer16);
+          break;
+        }
+        case EdgeKind_coff_x86_64::SecRel32: {
+          E.setAddend(E.getAddend() -
+                      getSectionStart(E.getTarget().getBlock().getSection())
+                          .getValue());
+          E.setKind(x86_64::Pointer32);
+          break;
+        }
         default:
           break;
         }
       }
     }
     return Error::success();
   }
 
 private:
   static StringRef getImageBaseSymbolName() { return "__ImageBase"; }
+
+  orc::ExecutorAddr getSectionStart(Section &Sec) {
+    if (!SectionStartCache.count(&Sec)) {
+      SectionRange Range(Sec);
+      SectionStartCache[&Sec] = Range.getStart();
+    }
+    return SectionStartCache[&Sec];
+  }
+
   Expected<JITTargetAddress> getImageBaseAddress(LinkGraph &G,
                                                  JITLinkContext &Ctx) {
     if (this->ImageBase)
       return this->ImageBase;
     for (auto *S : G.defined_symbols())
       if (S->getName() == getImageBaseSymbolName()) {
         this->ImageBase = S->getAddress().getValue();
         return this->ImageBase;
Ctx.lookup(Symbols,
                  auto &ImageBaseSymbol = LR->begin()->second;
                  ImageBase = ImageBaseSymbol.getAddress();
                }));
     if (Err)
       return std::move(Err);
     this->ImageBase = ImageBase;
     return ImageBase;
   }
+
+  DenseMap<Section *, orc::ExecutorAddr> SectionStartCache;
   JITTargetAddress ImageBase = 0;
 };
 
 Error lowerEdges_COFF_x86_64(LinkGraph &G, JITLinkContext *Ctx) {
   LLVM_DEBUG(dbgs() << "Lowering COFF x86_64 edges:\n");
   COFFLinkGraphLowering_x86_64 GraphLowering;
 
   if (auto Err = GraphLowering.lowerCOFFRelocationEdges(G, *Ctx))

 const char *getCOFFX86RelocationKindName(Edge::Kind R) {
   switch (R) {
   case PCRel32:
     return "PCRel32";
   case Pointer32NB:
     return "Pointer32NB";
   case Pointer64:
     return "Pointer64";
+  case SectionIdx16:
+    return "SectionIdx16";
+  case SecRel32:
+    return "SecRel32";
   default:
     return x86_64::getEdgeKindName(R);
   }
 }
 
 Expected<std::unique_ptr<LinkGraph>>
 createLinkGraphFromCOFFObject_x86_64(MemoryBufferRef ObjectBuffer) {
   LLVM_DEBUG({

llvm/lib/ExecutionEngine/JITLink/x86_64.cpp

 const char *getEdgeKindName(Edge::Kind K) {
   switch (K) {
   case Pointer64:
     return "Pointer64";
   case Pointer32:
     return "Pointer32";
   case Pointer32Signed:
     return "Pointer32Signed";
+  case Pointer16:
+    return "Pointer16";
   case Delta64:
     return "Delta64";
   case Delta32:
     return "Delta32";
   case NegDelta64:
     return "NegDelta64";
   case NegDelta32:
     return "NegDelta32";

llvm/lib/ExecutionEngine/Orc/ObjectLinkingLayer.cpp

BlockDependenciesMap computeBlockNonLocalDeps(LinkGraph &G) {
     for (auto *B : G.blocks())
       (void)BlockInfos[B];
 
     // Build initial worklist, record block dependencies/dependants and
     // non-local symbol dependencies.
     for (auto *B : G.blocks()) {
       auto &BI = BlockInfos[B];
       for (auto &E : B->edges()) {
-        if (E.getTarget().getScope() == Scope::Local) {
+        if (E.getTarget().getScope() == Scope::Local &&
+            !E.getTarget().isAbsolute()) {
           auto &TgtB = E.getTarget().getBlock();
           if (&TgtB != B) {
             BI.Dependencies.insert(&TgtB);
             BlockInfos[&TgtB].Dependants.insert(B);
           }
         }
       }
 
       // If this node has both dependants and dependencies then add it to the

llvm/test/ExecutionEngine/JITLink/X86/COFF_section_relocs.test

+# RUN: yaml2obj %s -o %t
+# RUN: llvm-jitlink -noexec -abs __ImageBase=0xfff00000 \
+# RUN: -slab-allocate 100Kb -slab-address 0xfff00000 -slab-page-size 4096 \
+# RUN: -check %s %t 
+# 
+# Check IMAGE_REL_AMD64_SECTION and IMAGE_REL_AMD64_SECREL relocations
+# are working correctly.
+#
+# jitlink-check: *{2}(sect) = 2
+# jitlink-check: *{4}(sect+2) = 4
+--- !COFF
+header:
+  Machine:         IMAGE_FILE_MACHINE_AMD64
+  Characteristics: [  ]
+sections:
+  - Name:            .text
+    Characteristics: [ IMAGE_SCN_CNT_CODE, IMAGE_SCN_MEM_EXECUTE, IMAGE_SCN_MEM_READ ]
+    Alignment:       16
+    SectionData:     '0000000000000000'
+  - Name:            .func
+    Characteristics: [ IMAGE_SCN_CNT_CODE, IMAGE_SCN_MEM_EXECUTE, IMAGE_SCN_MEM_READ ]
+    Alignment:       16
+    SectionData:     '0000000000000000'
+  - Name:            .sect
+    Characteristics: [ IMAGE_SCN_CNT_CODE, IMAGE_SCN_MEM_EXECUTE, IMAGE_SCN_MEM_READ ]
+    Alignment:       4
+    SectionData:     '0000000000000000'
+    Relocations:
+      - VirtualAddress:  0
+        SymbolTableIndex: 7
+        Type:            IMAGE_REL_AMD64_SECTION
+      - VirtualAddress:  2
+        SymbolTableIndex: 7
+        Type:            IMAGE_REL_AMD64_SECREL
+symbols:
+  - Name:            .text
+    Value:           0
+    SectionNumber:   1
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_NULL
+    StorageClass:    IMAGE_SYM_CLASS_STATIC
+    SectionDefinition:
+      Length:          8
+      NumberOfRelocations: 0
+      CheckSum:            0
+      NumberOfLinenumbers: 0
+      Number:          1
+  - Name:            .func
+    Value:           0
+    SectionNumber:   2
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_NULL
+    StorageClass:    IMAGE_SYM_CLASS_STATIC
+    SectionDefinition:
+      Length:          8
+      NumberOfRelocations: 0
+      CheckSum:            0
+      NumberOfLinenumbers: 0
+      Number:          2
+  - Name:            .pdata
+    Value:           0
+    SectionNumber:   3
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_NULL
+    StorageClass:    IMAGE_SYM_CLASS_STATIC
+    SectionDefinition:
+      Length:          8
+      NumberOfRelocations: 1
+      CheckSum:            0
+      NumberOfLinenumbers: 0
+      Number:          3
+  - Name:            main
+    Value:           0
+    SectionNumber:   1
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_FUNCTION
+    StorageClass:    IMAGE_SYM_CLASS_EXTERNAL
+  - Name:            func
+    Value:           4
+    SectionNumber:   2
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_FUNCTION
+    StorageClass:    IMAGE_SYM_CLASS_EXTERNAL
+  - Name:            sect
+    Value:           0
+    SectionNumber:   3
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_FUNCTION
+    StorageClass:    IMAGE_SYM_CLASS_EXTERNAL