[JITLink][COFF][x86_64] Reimplement ADDR32NB/REL32.

[sunho]

Summary

Reimplements ADDR32NB/REL32 relocations properly, out-of-reach targets will be dealt in the separate patch that will generate the stub for dllimport symbols.

[tschuett]

You said for both relocations that the value should not exceed 32bit. Is there a place for asserts to check/prove the fact?

I prefer enum class for new code.

[sunho]

@tschuett It's checked in this patch using isInt<32> and also checked another time in x86_64.h when generic relocation edge is used. I also prefer to enum class but all existing code has been using enum. I also don't see an easy way to "extend" enum class. Is there a clever way? (for more context, if we were to swtich to enum class, we must have a way to extend enum as x86_64 edge kind was extended from generic jitlink edge kind in the first place)

[tschuett]

Thanks

[sgraenitz]

That's a really creative solution for a tricky issue and it looks pretty good already! Kudos! Here's first set of questions and remarks.

llvm/lib/ExecutionEngine/JITLink/COFF_x86_64.cpp

214

Detail: We shouldn't use std::move here explicitly. Might prevent copy-elision.

221

Detail: I think we have to std::move(Err) here into the implicit ctor of Expected<JITTargetAddress>

227

This function appears to be the trickiest part of the patch. It's breaking out back into ORC to query the image base address. That's wild! And it might actually work!

The only thing that seems odd is that all COFF tests (and in general every user of the backend?) will need to define the absolute __ImageBase symbol now -- even though it's only used in two cases. Instead of calling it upfront here in the optimize function, could we call it on-demand in the specific cases?

I guess you could turn the variable here into a lambda, which would call getImageBaseAddress() only once and capture a stack variable to cache the result.. Does that make sense?

234

What else could it be?

248

Detail: I am a fan of writing out non-obvious types, but if not let's at least add the * please

[sunho]

llvm/lib/ExecutionEngine/JITLink/COFF_x86_64.cpp

234

I'm very uncertain about this part too. The tricky part is that makeTirple doesn't set COFF object format type for some reason. I tried chaning maketriple to set coff forat but it breaks several tests outside Orc. We can't just check with !isObjectFormatTypeELF() too as ELF is the default object format -- even for coff object format they are unchagned. I have to look into why maketriple doesn't set COFF object format.

[sunho]

Address comments

[sunho]

target

[sunho]

llvm/lib/ExecutionEngine/JITLink/COFF_x86_64.cpp

234

Made it better by setting format inside coffgraphbuilder.

[sunho]

add neg addend

[sgraenitz]

Nice, thanks for the updates. Are you planning to replace the COFF_external_func test or is it fully covered by the new COFF_addr32nb_reloc tests?

llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.cpp

24

Yes, I think it's a lot better to have it explicit like this. Can we still add a short note that summarizes our knowledge about missing COFF object format settings? Thanks!

327

How does your patch affect symbol sets so that they might be empty now?

llvm/test/ExecutionEngine/JITLink/X86/COFF_addr32nb_reloc_neg_addend.test

10

Can we name a good example here that involves negative addend?

[sunho]

I'm planning to submit the patch that deals with dllimport stubs that cleanly solve the out of reach issue, since I think we agreed on requiring clients to manually set dllimport attribute for external (external to jitdylib) functions.

llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.cpp

327

It's actually the side effect of the last patch (not dead stripping asso

[sunho]

llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.cpp

327

The truncated comment I submitted is wrong comment. It's because of the change in this patch (ignoring IsDiscardable) This was needed to prevent a crash that happens in a hello world obj file. If you want me to, I can separate out that change as an another patch with a testcase.

[sgraenitz]

Alright! Thanks, I didn't see that.

Form my side this looks all really good. I am sure you know best whether it's ready to land or if you want Lang to review as well.

llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.cpp

140

And then maybe:

// FIXME: Revisit crash when dropping IMAGE_SCN_MEM_DISCARDABLE sections

327

No worries, you don't need to split that out. However, keeping empty symbol sets around might be surprising for the reader (and in fact that might be solved at some point?). Do we always expect them to be IMAGE_SCN_MEM_DISCARDABLE? Then why not:

assert((cantFail(Obj.getSection(SecIndex))->Characteristics & 
        COFF::IMAGE_SCN_MEM_DISCARDABLE) != 0 && "Revisit after fixing crash")

[sunho]

Address comments & refactor

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

enum EdgeKind_x86_64 : Edge::Kind {
   ///   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 relocation.
+  ///
+  /// Represents a data/control flow instruction using PC-relative addressing
+  /// to a target.
+  ///
+  /// The fixup expression for this kind includes an implicit offset to account
+  /// for the PC (unlike the Delta edges) so that a PCRel32 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.
+  ///
+  PCRel32,
+
   /// 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)
   ///   ; ...
enum EdgeKind_x86_64 : Edge::Kind {
   ///
   /// 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.
   ///
-  RequestTLVPAndTransformToPCRel32TLVPLoadREXRelaxable
+  RequestTLVPAndTransformToPCRel32TLVPLoadREXRelaxable,
+  // First platform specific relocation.
+  FirstPlatformRelocation
 };
 
 /// Returns a string name for the given x86-64 edge. For debugging purposes
 /// only.
 const char *getEdgeKindName(Edge::Kind K);
 
 /// Returns true if the given uint64_t value is in range for a uint32_t.
 inline bool isInRangeForImmU32(uint64_t Value) {
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 PCRel32:
   case BranchPCRel32:
   case BranchPCRel32ToPtrJumpStub:
   case BranchPCRel32ToPtrJumpStubBypassable:
   case PCRel32GOTLoadRelaxable:
   case PCRel32GOTLoadREXRelaxable:
   case PCRel32TLVPLoadREXRelaxable: {
     int64_t Value =
         E.getTarget().getAddress() - (FixupAddress + 4) + E.getAddend();

llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.cpp

 
 #define DEBUG_TYPE "jitlink"
 
 static const char *CommonSectionName = "__common";
 
 namespace llvm {
 namespace jitlink {
 
+static Triple createTripleWithCOFFFormat(Triple T) {
+  T.setObjectFormat(Triple::COFF);
+  return T;
+}
+
 COFFLinkGraphBuilder::COFFLinkGraphBuilder(
     const object::COFFObjectFile &Obj, Triple TT,
     LinkGraph::GetEdgeKindNameFunction GetEdgeKindName)
     : Obj(Obj),
-      G(std::make_unique<LinkGraph>(
-          Obj.getFileName().str(), Triple(std::move(TT)), getPointerSize(Obj),
-          getEndianness(Obj), std::move(GetEdgeKindName))) {
+      G(std::make_unique<LinkGraph>(Obj.getFileName().str(),
+                                    createTripleWithCOFFFormat(TT),
+                                    getPointerSize(Obj), getEndianness(Obj),
+                                    std::move(GetEdgeKindName))) {
   LLVM_DEBUG({
     dbgs() << "Created COFFLinkGraphBuilder for \"" << Obj.getFileName()
            << "\"\n";
   });
 }
 
 COFFLinkGraphBuilder::~COFFLinkGraphBuilder() = default;
 
for (COFFSectionIndex SecIndex = 1;
     Expected<const object::coff_section *> Sec = Obj.getSection(SecIndex);
     if (!Sec)
       return Sec.takeError();
 
     StringRef SectionName;
     if (Expected<StringRef> SecNameOrErr = Obj.getSectionName(*Sec))
       SectionName = *SecNameOrErr;
 
-    bool IsDiscardable =
-        (*Sec)->Characteristics &
-        (COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_LNK_INFO);
-    if (IsDiscardable) {
-      LLVM_DEBUG(dbgs() << "    " << SecIndex << ": \"" << SectionName
-                        << "\" is discardable: "
-                           "No graph section will be created.\n");
-      continue;
-    }
-
     // FIXME: Skip debug info sections
 
     LLVM_DEBUG({
       dbgs() << "    "
              << "Creating section for \"" << SectionName << "\"\n";
     });
 
+    // FIXME: Revisit crash when dropping IMAGE_SCN_MEM_DISCARDABLE sections
+
     // Get the section's memory protection flags.
     MemProt Prot = MemProt::None;
     if ((*Sec)->Characteristics & COFF::IMAGE_SCN_MEM_EXECUTE)
       Prot |= MemProt::Exec;
     if ((*Sec)->Characteristics & COFF::IMAGE_SCN_MEM_READ)
       Prot |= MemProt::Read;
     if ((*Sec)->Characteristics & COFF::IMAGE_SCN_MEM_WRITE)
       Prot |= MemProt::Write;

 // logarithmic time complexity of sorted symbol insertion. Symbol is inserted to
 // the set once it's processed in graphifySymbols. In this function, we iterate
 // each collected symbol in sorted order and calculate the implicit size.
 Error COFFLinkGraphBuilder::calculateImplicitSizeOfSymbols() {
   for (COFFSectionIndex SecIndex = 1;
        SecIndex <= static_cast<COFFSectionIndex>(Obj.getNumberOfSections());
        SecIndex++) {
     auto &SymbolSet = SymbolSets[SecIndex];
+    if (SymbolSet.empty())
+      continue;
     jitlink::Block *B = getGraphBlock(SecIndex);
     orc::ExecutorAddrDiff LastOffset = B->getSize();
     orc::ExecutorAddrDiff LastDifferentOffset = B->getSize();
     orc::ExecutorAddrDiff LastSize = 0;
     for (auto It = SymbolSet.rbegin(); It != SymbolSet.rend(); It++) {
       orc::ExecutorAddrDiff Offset = It->first;
       jitlink::Symbol *Symbol = It->second;
       orc::ExecutorAddrDiff CandSize;
return &G->addAbsoluteSymbol(SymbolName,
                                  Linkage::Strong, Scope::Local, false);
 
   if (llvm::COFF::isReservedSectionNumber(Symbol.getSectionNumber()))
     return make_error<JITLinkError>(
         "Reserved section number used in regular symbol " +
         formatv("{0:d}", SymIndex));
 
   Block *B = getGraphBlock(Symbol.getSectionNumber());
+  if (!B) {
+    LLVM_DEBUG({
+      dbgs() << "    " << SymIndex
+             << ": Skipping graph symbol since section was not created for "
+                "COFF symbol \""
+             << SymbolName << "\" in section " << Symbol.getSectionNumber()
+             << "\n";
+    });
+    return nullptr;
+  }
+
   if (Symbol.isExternal()) {
     // This is not a comdat sequence, export the symbol as it is
     if (!isComdatSection(Section)) {
 
       return &G->addDefinedSymbol(
           *B, Symbol.getValue(), SymbolName, 0, Linkage::Strong, Scope::Default,
           Symbol.getComplexType() == COFF::IMAGE_SYM_DTYPE_FUNCTION, false);
     } else {

llvm/lib/ExecutionEngine/JITLink/COFF_x86_64.cpp

 
 #define DEBUG_TYPE "jitlink"
 
 using namespace llvm;
 using namespace llvm::jitlink;
 
 namespace {
 
+enum EdgeKind_coff_x86_64 : Edge::Kind {
+  PCRel32 = x86_64::FirstPlatformRelocation,
+  Pointer32NB,
+};
+
 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,
                        PassConfiguration PassConfig)
       : JITLinker(std::move(Ctx), std::move(G), std::move(PassConfig)) {}
 
 private:
   Error applyFixup(LinkGraph &G, Block &B, const Edge &E) const {
     return x86_64::applyFixup(G, B, E, nullptr);
   }
 };
 
 class COFFLinkGraphBuilder_x86_64 : public COFFLinkGraphBuilder {
 private:
-  uint64_t ImageBase = 0;
-  enum COFFX86RelocationKind {
-    COFFAddr32NB,
-    COFFRel32,
-  };
-
-  static Expected<COFFX86RelocationKind>
-  getRelocationKind(const uint32_t Type) {
-    switch (Type) {
-    case COFF::RelocationTypeAMD64::IMAGE_REL_AMD64_ADDR32NB:
-      return COFFAddr32NB;
-    case COFF::RelocationTypeAMD64::IMAGE_REL_AMD64_REL32:
-      return COFFRel32;
-    }
-
-    return make_error<JITLinkError>("Unsupported x86_64 relocation:" +
-                                    formatv("{0:d}", Type));
-  }
-
   Error addRelocations() override {
-
     LLVM_DEBUG(dbgs() << "Processing relocations:\n");
 
     for (const auto &RelSect : sections())
       if (Error Err = COFFLinkGraphBuilder::forEachRelocation(
               RelSect, this, &COFFLinkGraphBuilder_x86_64::addSingleRelocation))
         return Err;
 
     return Error::success();
   }
 
-  uint64_t getImageBase() {
-    if (!ImageBase) {
-      ImageBase = std::numeric_limits<uint64_t>::max();
-      for (const auto &Block : getGraph().blocks()) {
-        if (Block->getAddress().getValue())
-          ImageBase = std::min(ImageBase, Block->getAddress().getValue());
-      }
-    }
-    return ImageBase;
-  }
-
   Error addSingleRelocation(const object::RelocationRef &Rel,
                             const object::SectionRef &FixupSect,
                             Block &BlockToFix) {
-
     const object::coff_relocation *COFFRel = getObject().getCOFFRelocation(Rel);
     auto SymbolIt = Rel.getSymbol();
     if (SymbolIt == getObject().symbol_end()) {
       return make_error<StringError>(
           formatv("Invalid symbol index in relocation entry. "
                   "index: {0}, section: {1}",
                   COFFRel->SymbolTableIndex, FixupSect.getIndex()),
           inconvertibleErrorCode());
     }
 
     object::COFFSymbolRef COFFSymbol = getObject().getCOFFSymbol(*SymbolIt);
     COFFSymbolIndex SymIndex = getObject().getSymbolIndex(COFFSymbol);
 
     Symbol *GraphSymbol = getGraphSymbol(SymIndex);
     if (!GraphSymbol)
       return make_error<StringError>(
           formatv("Could not find symbol at given index, did you add it to "
                   "JITSymbolTable? index: {0}, section: {1}",
                   SymIndex, FixupSect.getIndex()),
           inconvertibleErrorCode());
 
-    Expected<COFFX86RelocationKind> RelocKind =
-        getRelocationKind(Rel.getType());
-    if (!RelocKind)
-      return RelocKind.takeError();
-
     int64_t Addend = 0;
     orc::ExecutorAddr FixupAddress =
         orc::ExecutorAddr(FixupSect.getAddress()) + Rel.getOffset();
     Edge::OffsetT Offset = FixupAddress - BlockToFix.getAddress();
 
     Edge::Kind Kind = Edge::Invalid;
+    const char *FixupPtr = BlockToFix.getContent().data() + Offset;
 
-    switch (*RelocKind) {
-    case COFFAddr32NB: {
-      Kind = x86_64::Pointer32;
-      Offset -= getImageBase();
+    switch (Rel.getType()) {
+    case COFF::RelocationTypeAMD64::IMAGE_REL_AMD64_ADDR32NB: {
+      Kind = EdgeKind_coff_x86_64::Pointer32NB;
+      Addend = *reinterpret_cast<const support::little32_t *>(FixupPtr);
+      break;
+    }
+    case COFF::RelocationTypeAMD64::IMAGE_REL_AMD64_REL32: {
+      Kind = EdgeKind_coff_x86_64::PCRel32;
+      Addend = *reinterpret_cast<const support::little32_t *>(FixupPtr);
       break;
     }
-    case COFFRel32: {
-      Kind = x86_64::BranchPCRel32;
+    case COFF::RelocationTypeAMD64::IMAGE_REL_AMD64_REL32_1: {
+      Kind = EdgeKind_coff_x86_64::PCRel32;
+      Addend = *reinterpret_cast<const support::little32_t *>(FixupPtr);
+      Addend -= 1;
       break;
     }
+    default: {
+      return make_error<JITLinkError>("Unsupported x86_64 relocation:" +
+                                      formatv("{0:d}", Rel.getType()));
+    }
     };
 
     Edge GE(Kind, Offset, *GraphSymbol, Addend);
     LLVM_DEBUG({
       dbgs() << "    ";
-      printEdge(dbgs(), BlockToFix, GE, x86_64::getEdgeKindName(Kind));
+      printEdge(dbgs(), BlockToFix, GE, getCOFFX86RelocationKindName(Kind));
       dbgs() << "\n";
     });
 
     BlockToFix.addEdge(std::move(GE));
+
     return Error::success();
   }
 
-  /// Return the string name of the given COFF x86_64 edge kind.
-  const char *getCOFFX86RelocationKindName(COFFX86RelocationKind R) {
-    switch (R) {
-    case COFFAddr32NB:
-      return "COFFAddr32NB";
-    case COFFRel32:
-      return "COFFRel32";
+public:
+  COFFLinkGraphBuilder_x86_64(const object::COFFObjectFile &Obj, const Triple T)
+      : COFFLinkGraphBuilder(Obj, std::move(T), getCOFFX86RelocationKindName) {}
+};
+
+class COFFLinkGraphLowering_x86_64 {
+public:
+  // Lowers COFF x86_64 specific edges to generic x86_64 edges.
+  Error lowerCOFFRelocationEdges(LinkGraph &G, JITLinkContext &Ctx) {
+    for (auto *B : G.blocks()) {
+      for (auto &E : B->edges()) {
+        switch (E.getKind()) {
+        case EdgeKind_coff_x86_64::Pointer32NB: {
+          auto ImageBase = getImageBaseAddress(G, Ctx);
+          if (!ImageBase)
+            return ImageBase.takeError();
+          E.setAddend(E.getAddend() - *ImageBase);
+          E.setKind(x86_64::Pointer32);
+          break;
         }
+        case EdgeKind_coff_x86_64::PCRel32: {
+          E.setKind(x86_64::PCRel32);
+          break;
+        }
+        default:
+          break;
+        }
+      }
+    }
+    return Error::success();
   }
 
-public:
-  COFFLinkGraphBuilder_x86_64(const object::COFFObjectFile &Obj, const Triple T)
-      : COFFLinkGraphBuilder(Obj, std::move(T), x86_64::getEdgeKindName) {}
+private:
+  static StringRef getImageBaseSymbolName() { return "__ImageBase"; }
+  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;
+      }
+
+    JITLinkContext::LookupMap Symbols;
+    Symbols[getImageBaseSymbolName()] = SymbolLookupFlags::RequiredSymbol;
+    JITTargetAddress ImageBase;
+    Error Err = Error::success();
+    Ctx.lookup(Symbols,
+               createLookupContinuation([&](Expected<AsyncLookupResult> LR) {
+                 ErrorAsOutParameter EAO(&Err);
+                 if (!LR) {
+                   Err = LR.takeError();
+                   return;
+                 }
+                 auto &ImageBaseSymbol = LR->begin()->second;
+                 ImageBase = ImageBaseSymbol.getAddress();
+               }));
+    if (Err)
+      return std::move(Err);
+    this->ImageBase = ImageBase;
+    return ImageBase;
+  }
+  JITTargetAddress ImageBase = 0;
 };
 
-Error buildTables_COFF_x86_64(LinkGraph &G) {
-  LLVM_DEBUG(dbgs() << "Visiting edges in graph:\n");
+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))
+    return Err;
 
-  x86_64::GOTTableManager GOT;
-  x86_64::PLTTableManager PLT(GOT);
-  visitExistingEdges(G, GOT, PLT);
   return Error::success();
 }
 } // namespace
 
 namespace llvm {
 namespace jitlink {
 
+/// Return the string name of the given COFF x86_64 edge kind.
+const char *getCOFFX86RelocationKindName(Edge::Kind R) {
+  switch (R) {
+  case PCRel32:
+    return "PCRel32";
+  case Pointer32NB:
+    return "Pointer32NB";
+  default:
+    return x86_64::getEdgeKindName(R);
+  }
+}
+
 Expected<std::unique_ptr<LinkGraph>>
 createLinkGraphFromCOFFObject_x86_64(MemoryBufferRef ObjectBuffer) {
   LLVM_DEBUG({
     dbgs() << "Building jitlink graph for new input "
            << ObjectBuffer.getBufferIdentifier() << "...\n";
   });
 
   auto COFFObj = object::ObjectFile::createCOFFObjectFile(ObjectBuffer);
   if (!COFFObj)
     return COFFObj.takeError();
 
   return COFFLinkGraphBuilder_x86_64(**COFFObj, (*COFFObj)->makeTriple())
       .buildGraph();
 }
 
 void link_COFF_x86_64(std::unique_ptr<LinkGraph> G,
                       std::unique_ptr<JITLinkContext> Ctx) {
   PassConfiguration Config;
   const Triple &TT = G->getTargetTriple();
   if (Ctx->shouldAddDefaultTargetPasses(TT)) {
     // Add a mark-live pass.
     if (auto MarkLive = Ctx->getMarkLivePass(TT))
       Config.PrePrunePasses.push_back(std::move(MarkLive));
     else
       Config.PrePrunePasses.push_back(markAllSymbolsLive);
 
-    // Add an in-place GOT/Stubs/TLSInfoEntry build pass.
-    Config.PostPrunePasses.push_back(buildTables_COFF_x86_64);
-
-    // Add GOT/Stubs optimizer pass.
-    Config.PreFixupPasses.push_back(x86_64::optimizeGOTAndStubAccesses);
+    // Add COFF edge lowering passes.
+    JITLinkContext *CtxPtr = Ctx.get();
+    Config.PreFixupPasses.push_back(
+        [CtxPtr](LinkGraph &G) { return lowerEdges_COFF_x86_64(G, CtxPtr); });
   }
 
   if (auto Err = Ctx->modifyPassConfig(*G, Config))
     return Ctx->notifyFailed(std::move(Err));
 
   COFFJITLinker_x86_64::link(std::move(Ctx), std::move(G), std::move(Config));
 }
 
 } // namespace jitlink
 } // namespace llvm

llvm/lib/ExecutionEngine/JITLink/x86_64.cpp

const char *getEdgeKindName(Edge::Kind K) {
   case Delta32:
     return "Delta32";
   case NegDelta64:
     return "NegDelta64";
   case NegDelta32:
     return "NegDelta32";
   case Delta64FromGOT:
     return "Delta64FromGOT";
+  case PCRel32:
+    return "PCRel32";
   case BranchPCRel32:
     return "BranchPCRel32";
   case BranchPCRel32ToPtrJumpStub:
     return "BranchPCRel32ToPtrJumpStub";
   case BranchPCRel32ToPtrJumpStubBypassable:
     return "BranchPCRel32ToPtrJumpStubBypassable";
   case RequestGOTAndTransformToDelta32:
     return "RequestGOTAndTransformToDelta32";

llvm/test/ExecutionEngine/JITLink/X86/COFF_addr32nb_reloc.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_ADDR32NB relocation properly sets the delta of target 
+# from imagebase.
+#
+# jitlink-check: *{4}(pdata) = func - __ImageBase
+--- !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:            .pdata
+    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_ADDR32NB
+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:           0
+    SectionNumber:   2
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_FUNCTION
+    StorageClass:    IMAGE_SYM_CLASS_EXTERNAL
+  - Name:            pdata
+    Value:           0
+    SectionNumber:   3
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_FUNCTION
+    StorageClass:    IMAGE_SYM_CLASS_EXTERNAL

llvm/test/ExecutionEngine/JITLink/X86/COFF_addr32nb_reloc_neg_addend.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_ADDR32NB relocation properly sets the delta of target 
+# from imagebase with a negative addend.
+#
+# jitlink-check: *{4}(pdata) = func - __ImageBase - 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:     '000000000000000B'
+  - Name:            .func
+    Characteristics: [ IMAGE_SCN_CNT_CODE, IMAGE_SCN_MEM_EXECUTE, IMAGE_SCN_MEM_READ ]
+    Alignment:       16
+    SectionData:     '000000000000000A'
+  - Name:            .pdata
+    Characteristics: [ IMAGE_SCN_CNT_CODE, IMAGE_SCN_MEM_EXECUTE, IMAGE_SCN_MEM_READ ]
+    Alignment:       4
+    SectionData:     'FCFFFFFF00000000'
+    Relocations:
+      - VirtualAddress:  0
+        SymbolTableIndex: 7
+        Type:            IMAGE_REL_AMD64_ADDR32NB
+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:           0
+    SectionNumber:   2
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_FUNCTION
+    StorageClass:    IMAGE_SYM_CLASS_EXTERNAL
+  - Name:            pdata
+    Value:           0
+    SectionNumber:   3
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_FUNCTION
+    StorageClass:    IMAGE_SYM_CLASS_EXTERNAL

llvm/test/ExecutionEngine/JITLink/X86/COFF_basic.s

-# RUN: llvm-mc -filetype=obj -triple=x86_64-windows-msvc %s -o %t
-# RUN: llvm-jitlink -noexec %t
-# 
-# Check a basic COFF object file loads successfully.
-
-  .text
-  .def  @feat.00;
-  .scl  3;
-  .type 0;
-  .endef
-  .globl  @feat.00
-.set @feat.00, 0
-  .file "main.c"
-  .def  main;
-  .scl  2;
-  .type 32;
-  .endef
-  .globl  main
-  .p2align  4, 0x90
-main:
-    .seh_proc main
-  pushq %rax
-  .seh_stackalloc 8
-  .seh_endprologue
-  movl  $0, 4(%rsp)
-  xorl  %eax, %eax
-  popq  %rcx
-  retq
-  .seh_endproc

llvm/test/ExecutionEngine/JITLink/X86/COFF_comdat_weak_duplicate.s

 # RUN: rm -rf %t && mkdir -p %t
 # RUN: yaml2obj %S/Inputs/COFF_comdat_weak_def.yaml -o %t/COFF_weak_1.o
 # RUN: yaml2obj %S/Inputs/COFF_comdat_weak_def.yaml -o %t/COFF_weak_2.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-windows-msvc %s -o %t/COFF_main.o
 # RUN: 
 # RUN: llvm-jitlink -noexec %t/COFF_main.o %t/COFF_weak_1.o %t/COFF_weak_2.o \
 # RUN: -slab-allocate 100Kb -slab-address 0xfff00000 -slab-page-size 4096 \
 # RUN: -show-graph -noexec 2>&1 | FileCheck %s
 #
 # Check that duplicate comdat any definitions don't generate duplicate definition error.
 #
 # CHECK: section weakfunc:
 # CHECK-EMPTY:
-# CHECK-NEXT:  block 0xfff02000 size = 0x00000001, align = 16, alignment-offset = 0
+# CHECK-NEXT:  block 0xfff01000 size = 0x00000001, align = 16, alignment-offset = 0
 # CHECK-NEXT:    symbols:
-# CHECK-NEXT:      0xfff02000 (block + 0x00000000): size: 0x00000001, linkage: weak, scope: default, live  -   func
+# CHECK-NEXT:      0xfff01000 (block + 0x00000000): size: 0x00000001, linkage: weak, scope: default, live  -   func
 # CHECK-NEXT:    no edges
 
   .text
 
   .def  main;
   .scl  2;
   .type 32;
   .endef
   .globl  main
   .p2align  4, 0x90
 main:
     callq func
   retq
 No newline at end of file

llvm/test/ExecutionEngine/JITLink/X86/COFF_external_func.s

-# REQUIRES: asserts
-# RUN: llvm-mc -filetype=obj -triple=x86_64-windows-msvc %s -o %t
-# RUN: llvm-jitlink -abs func=0xcafef00d --debug-only=jitlink -noexec %t 2>&1 | FileCheck %s
-#
-# Check an external symbol to a functon is created.
-#
-# CHECK: Creating graph symbols...
-# CHECK:   7: Creating external graph symbol for COFF symbol "func" in (external) (index: 0)
-
-  .text
-
-  .def  main;
-  .scl  2;
-  .type 32;
-  .endef
-  .globl  main
-  .p2align  4, 0x90
-main:
-  callq func
-  retq

llvm/test/ExecutionEngine/JITLink/X86/COFF_external_var.s

-# REQUIRES: asserts
 # RUN: llvm-mc -filetype=obj -triple=x86_64-windows-msvc %s -o %t
-# RUN: llvm-jitlink -abs var=0xcafef00d --debug-only=jitlink -noexec %t 2>&1 | FileCheck %s
+# RUN: not llvm-jitlink -slab-allocate 100Kb -slab-address 0xfff00000 -slab-page-size 4096 \
+# RUN: -abs var=0x7fff00000000 -noexec %t
 #
-# Check an external symbol to a variable is created.
+# Check data access to a external variable out of reach causes an error.
 #
-# CHECK: Creating graph symbols...
-# CHECK:   7: Creating external graph symbol for COFF symbol "var" in (external) (index: 0)
 
   .text
 
   .def  main;
   .scl  2;
   .type 32;
   .endef
   .globl  main 
   .p2align  4, 0x90
 main:
   movl  var(%rip), %eax
   retq

llvm/test/ExecutionEngine/JITLink/X86/COFF_file_debug.s

 # REQUIRES: asserts
 # RUN: llvm-mc -filetype=obj -triple=x86_64-windows-msvc %s -o %t
 # RUN: llvm-jitlink -abs func=0xcafef00d --debug-only=jitlink -noexec %t 2>&1 | FileCheck %s
 #
 # Check a file debug symbol is skipped.
 #
 # CHECK: Creating graph symbols...
-# CHECK:   8: Skipping FileRecord symbol ".file" in (debug) (index: -2)
+# CHECK:   7: Skipping FileRecord symbol ".file" in (debug) (index: -2)
 
   .text
 
   .file "skip_this_file_symbol"
 
   .def  main;
   .scl  2;
   .type 32;
   .endef
   .globl  main
   .p2align  4, 0x90
 main:
-  callq func
   retq

llvm/test/ExecutionEngine/JITLink/X86/COFF_x86-64_small_pic_relocations.s

# jitlink-check: decode_operand(test_rel32_data, 4) = named_data - next_pc(test_rel32_data)
   .scl 2;
   .type 32;
   .endef
   .globl test_rel32_data
   .p2align 4, 0x90
 test_rel32_data:
     leaq named_data(%rip), %rax
 
-# Check that calls to external functions out-of-range from the callsite trigger 
-# the generation of stubs and GOT entries. This produces a BranchPCRel32 edge, 
-# but STUB table manager will create a STUB sequence because external function 
-# is out-of-range from the callsite.
-#
-# jitlink-check: decode_operand(test_call_extern_out_of_range32, 0) = \
-# jitlink-check:     stub_addr(coff_sm_reloc.o, extern_out_of_range32) - \
-# jitlink-check:        next_pc(test_call_extern_out_of_range32)
-# jitlink-check: *{8}(got_addr(coff_sm_reloc.o, extern_out_of_range32)) = \
-# jitlink-check:     extern_out_of_range32
-  .def test_call_extern_out_of_range32;
-  .scl 2;
-  .type 32;
-  .endef
-  .globl main
-  .p2align 4, 0x90
-test_call_extern_out_of_range32:
-  callq extern_out_of_range32
-  retq
-
 # Local named data/func that is used in conjunction with other test cases
   .text
   .def named_func;
   .scl 2;
   .type 32;
   .endef
   .globl named_func
   .p2align 4, 0x90
 named_func:
   retq
 
   .data
   .p2align 3
 named_data:
   .quad 53