Getting R_X86_64_PC32 working as our first relocation

[jaredwy]

Summary

The first attempt at getting a relocation type added.
So far nothing special but should set the architecture going forward for the rest of the relocations

[lhames]

This looks great!

Style issues: There are a number of single line statements with braces around them -- those braces should be moved to match the style guide. You should also clang-format the patch if you haven't already. Otherwise this is good to land.

llvm/lib/ExecutionEngine/JITLink/ELF_x86_64.cpp

195–199

No braces for single-line statements. :)

Side note regarding the TODO: Long term I think it would make sense to do some sort of up-front validation of the input file, but for now this is the right place to check this.

236

For what error condition? Empty sections? Does your parser ever produce them?

[jaredwy]

Clang-format was run but doesn't seem to catch this case, ill clean it up later this afternoon.

llvm/lib/ExecutionEngine/JITLink/ELF_x86_64.cpp

236

No. If a JITSection is found, it would be next to impossible not to have a block. So if i push the error check on jitSection that should ensure a block is present

[lhames]

Oh, wait: this still needs a test case before it lands. The llvm/test/ExecutionEngine/JITLink/X86/ELF_x86-64_relocations.s test should be updated to include a check for the new relocation.

[jaredwy]

This should fix up the review comments, and the clang-tidy issue
Will add the tests later tonight

[lhames]

a6deaeec370ec5e34f9e5aa3fad3bc73770d4895 adds basic support for llvm-jitlink -check tests for ELF. That should allow you to test this.

[jaredwy]

Adding the relocation test file (thanks lang!)

[lhames]

LGTM!

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

 #define LLVM_EXECUTIONENGINE_JITLINK_ELF_X86_64_H
 
 #include "llvm/ExecutionEngine/JITLink/JITLink.h"
 
 namespace llvm {
 namespace jitlink {
 
 namespace ELF_x86_64_Edges {
-
 enum ELFX86RelocationKind : Edge::Kind {
-  R_AMD64_NONE = Edge::FirstRelocation,
-  R_AMD64_64,
-  R_AMD64_PC32,
-  R_AMD64_GOT32,
-  R_AMD64_PLT32,
-  R_AMD64_COPY,
-  R_AMD64_GLOB_DAT,
-  R_AMD64_JUMP_SLOT,
-  R_AMD64_RELATIVE,
-  R_AMD64_GOTPCREL,
-  R_AMD64_32,
-  R_AMD64_32S,
-  R_AMD64_16,
-  R_AMD64_PC16,
-  R_AMD64_8,
-  R_AMD64_PC8,
-  R_AMD64_PC64,
-  R_AMD64_GOTOFF64,
-  R_AMD64_GOTPC32,
-  R_AMD64_SIZE32,
-  R_AMD64_SIZE64
+  Branch32 = Edge::FirstRelocation,
+  Branch32ToStub,
+  Pointer32,
+  Pointer64,
+  Pointer64Anon,
+  PCRel32,
+  PCRel32Minus1,
+  PCRel32Minus2,
+  PCRel32Minus4,
+  PCRel32Anon,
+  PCRel32Minus1Anon,
+  PCRel32Minus2Anon,
+  PCRel32Minus4Anon,
+  PCRel32GOTLoad,
+  PCRel32GOT,
+  PCRel32TLV,
+  Delta32,
+  Delta64,
+  NegDelta32,
+  NegDelta64,
 };
 
 } // end namespace ELF_x86_64_Edges
 
 /// jit-link the given object buffer, which must be a ELF x86-64 object file.
 void jitLink_ELF_x86_64(std::unique_ptr<JITLinkContext> Ctx);
-StringRef getELFX86RelocationKindName(Edge::Kind R);
 } // end namespace jitlink
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_JITLINK_ELF_X86_64_H

llvm/lib/ExecutionEngine/JITLink/ELF_x86_64.cpp

 
 using namespace llvm;
 using namespace llvm::jitlink;
 
 static const char *CommonSectionName = "__common";
 
 namespace llvm {
 namespace jitlink {
+
 // This should become a template as the ELFFile is so a lot of this could become
 // generic
 class ELFLinkGraphBuilder_x86_64 {
 
 private:
   Section *CommonSection = nullptr;
+  // TODO hack to get this working
+  // Find a better way
+  using SymbolTable = object::ELFFile<object::ELF64LE>::Elf_Shdr;
+  // For now we just assume
+  std::map<int32_t, Symbol *> JITSymbolTable;
+
   Section &getCommonSection() {
     if (!CommonSection) {
       auto Prot = static_cast<sys::Memory::ProtectionFlags>(
           sys::Memory::MF_READ | sys::Memory::MF_WRITE);
       CommonSection = &G->createSection(CommonSectionName, Prot);
     }
     return *CommonSection;
   }
 
+  static Expected<ELF_x86_64_Edges::ELFX86RelocationKind>
+  getRelocationKind(const uint32_t Type) {
+    switch (Type) {
+    case ELF::R_X86_64_PC32:
+      return ELF_x86_64_Edges::ELFX86RelocationKind::PCRel32;
+    }
+    return make_error<JITLinkError>("Unsupported x86-64 relocation:" +
+                                    formatv("{0:d}", Type));
+  }
+
   std::unique_ptr<LinkGraph> G;
   // This could be a template
   const object::ELFFile<object::ELF64LE> &Obj;
   object::ELFFile<object::ELF64LE>::Elf_Shdr_Range sections;
+  SymbolTable SymTab;
 
   bool isRelocatable() { return Obj.getHeader()->e_type == llvm::ELF::ET_REL; }
 
   support::endianness
   getEndianness(const object::ELFFile<object::ELF64LE> &Obj) {
     return Obj.isLE() ? support::little : support::big;
   }
 
for (auto SecRef : sections) {
 
       for (auto SymRef : *Symbols) {
         Optional<StringRef> Name;
         uint64_t Size = 0;
 
         // FIXME: Read size.
         (void)Size;
 
-        if (auto NameOrErr = SymRef.getName(*StringTable)) {
+        if (auto NameOrErr = SymRef.getName(*StringTable))
           Name = *NameOrErr;
-        } else {
+        else
           return NameOrErr.takeError();
-        }
+
         LLVM_DEBUG({
           dbgs() << "  ";
           if (!Name)
             dbgs() << "<anonymous symbol>";
           else
             dbgs() << *Name;
           dbgs() << ": value = " << formatv("{0:x16}", SymRef.getValue())
                  << ", type = " << formatv("{0:x2}", SymRef.getType())
for (auto &SecRef : sections) {
 
         Data = contents->data();
         // TODO protection flags.
         // for now everything is
         auto &section = G->createSection(*Name, Prot);
         // Do this here because we have it, but move it into graphify later
         G->createContentBlock(section, StringRef(Data, Size), Address,
                               Alignment, 0);
+        if (SecRef.sh_type == ELF::SHT_SYMTAB)
+          // TODO: Dynamic?
+          SymTab = SecRef;
       }
     }
 
     return Error::success();
   }
 
+  Error addRelocations() {
+    LLVM_DEBUG(dbgs() << "Adding relocations\n");
+    // TODO a partern is forming of iterate some sections but only give me
+    // ones I am interested, i should abstract that concept some where
+    for (auto &SecRef : sections) {
+      if (SecRef.sh_type != ELF::SHT_RELA && SecRef.sh_type != ELF::SHT_REL)
+        continue;
+      // TODO can the elf obj file do this for me?
+      if (SecRef.sh_type == ELF::SHT_REL)
+        return make_error<llvm::StringError>("Shouldn't have REL in x64",
+                                             llvm::inconvertibleErrorCode());
+
+      auto RelSectName = Obj.getSectionName(&SecRef);
+      if (!RelSectName)
+        return RelSectName.takeError();
+      // Deal with .eh_frame later
+      if (*RelSectName == StringRef(".rela.eh_frame"))
+        continue;
+
+      auto UpdateSection = Obj.getSection(SecRef.sh_info);
+      if (!UpdateSection)
+        return UpdateSection.takeError();
+
+      auto UpdateSectionName = Obj.getSectionName(*UpdateSection);
+      if (!UpdateSectionName)
+        return UpdateSectionName.takeError();
+
+      auto JITSection = G->findSectionByName(*UpdateSectionName);
+      if (!JITSection)
+        return make_error<llvm::StringError>(
+            "Refencing a a section that wasn't added to graph" +
+                *UpdateSectionName,
+            llvm::inconvertibleErrorCode());
+
+      auto Relocations = Obj.relas(&SecRef);
+      if (!Relocations)
+        return Relocations.takeError();
+
+      for (const auto &Rela : *Relocations) {
+        auto Type = Rela.getType(false);
+
+        LLVM_DEBUG({
+          dbgs() << "Relocation Type: " << Type << "\n"
+                 << "Name: " << Obj.getRelocationTypeName(Type) << "\n";
+        });
+
+        auto Symbol = Obj.getRelocationSymbol(&Rela, &SymTab);
+        if (!Symbol)
+          return Symbol.takeError();
+
+        auto BlockToFix = *(JITSection->blocks().begin());
+        auto TargetSymbol = JITSymbolTable[(*Symbol)->st_shndx];
+        uint64_t Addend = Rela.r_addend;
+        JITTargetAddress FixupAddress =
+            (*UpdateSection)->sh_addr + Rela.r_offset;
+
+        LLVM_DEBUG({
+          dbgs() << "Processing relocation at "
+                 << format("0x%016" PRIx64, FixupAddress) << "\n";
+        });
+        auto Kind = getRelocationKind(Type);
+        if (!Kind)
+          return Kind.takeError();
+
+        LLVM_DEBUG({
+          Edge GE(*Kind, FixupAddress - BlockToFix->getAddress(), *TargetSymbol,
+                  Addend);
+          // TODO a mapping of KIND => type then call getRelocationTypeName4
+          printEdge(dbgs(), *BlockToFix, GE, StringRef(""));
+          dbgs() << "\n";
+        });
+        BlockToFix->addEdge(*Kind, FixupAddress - BlockToFix->getAddress(),
+                            *TargetSymbol, Addend);
+      }
+    }
+    return Error::success();
+  }
+
   Error graphifyRegularSymbols() {
 
     // TODO: ELF supports beyond SHN_LORESERVE,
     // need to perf test how a vector vs map handles those cases
 
     std::vector<std::vector<object::ELFFile<object::ELF64LE>::Elf_Shdr_Range *>>
         SecIndexToSymbols;
 
for (auto SecRef : sections) {
         //     continue;
         //   }
         std::pair<Linkage, Scope> bindings;
         auto Name = SymRef.getName(*StringTable);
         // I am not sure on If this is going to hold as an invariant. Revisit.
         if (!Name)
           return Name.takeError();
         // TODO: weak and hidden
-        if (SymRef.isExternal()) {
+        if (SymRef.isExternal())
           bindings = {Linkage::Strong, Scope::Default};
-        } else {
+        else
           bindings = {Linkage::Strong, Scope::Local};
-        }
 
         if (SymRef.isDefined() &&
             (Type == ELF::STT_FUNC || Type == ELF::STT_OBJECT)) {
 
           auto DefinedSection = Obj.getSection(SymRef.st_shndx);
           if (!DefinedSection)
             return DefinedSection.takeError();
           auto sectName = Obj.getSectionName(*DefinedSection);
           if (!sectName)
             return Name.takeError();
 
           auto JitSection = G->findSectionByName(*sectName);
           if (!JitSection)
             return make_error<llvm::StringError>(
                 "Could not find a section", llvm::inconvertibleErrorCode());
           auto bs = JitSection->blocks();
           if (bs.empty())
             return make_error<llvm::StringError>(
                 "Section has no block", llvm::inconvertibleErrorCode());
 
           auto B = *bs.begin();
           LLVM_DEBUG({ dbgs() << "  " << *Name << ": "; });
 
-          G->addDefinedSymbol(*B, SymRef.getValue(), *Name, SymRef.st_size,
-                              bindings.first, bindings.second,
-                              SymRef.getType() == ELF::STT_FUNC, false);
+          auto &S = G->addDefinedSymbol(
+              *B, SymRef.getValue(), *Name, SymRef.st_size, bindings.first,
+              bindings.second, SymRef.getType() == ELF::STT_FUNC, false);
+          JITSymbolTable[SymRef.st_shndx] = &S;
         }
         //TODO: The following has to be implmented.
         // leaving commented out to save time for future patchs
         /*
           G->addAbsoluteSymbol(*Name, SymRef.getValue(), SymRef.st_size,
           Linkage::Strong, Scope::Default, false);
 
           if(SymRef.isCommon()) {
if (auto Err = createNormalizedSections())
       return std::move(Err);
 
     if (auto Err = createNormalizedSymbols())
       return std::move(Err);
 
     if (auto Err = graphifyRegularSymbols())
       return std::move(Err);
 
+    if (auto Err = addRelocations())
+      return std::move(Err);
+
     return std::move(G);
   }
 };
 
 class ELFJITLinker_x86_64 : public JITLinker<ELFJITLinker_x86_64> {
   friend class JITLinker<ELFJITLinker_x86_64>;
 
 public:
   ELFJITLinker_x86_64(std::unique_ptr<JITLinkContext> Ctx,
                       PassConfiguration PassConfig)
       : JITLinker(std::move(Ctx), std::move(PassConfig)) {}
 
 private:
-  StringRef getEdgeKindName(Edge::Kind R) const override {
-    return getELFX86RelocationKindName(R);
-  }
+  StringRef getEdgeKindName(Edge::Kind R) const override { return StringRef(); }
 
   Expected<std::unique_ptr<LinkGraph>>
   buildGraph(MemoryBufferRef ObjBuffer) override {
     auto ELFObj = object::ObjectFile::createELFObjectFile(ObjBuffer);
     if (!ELFObj)
       return ELFObj.takeError();
 
     auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF64LE>>(**ELFObj);
     std::string fileName(ELFObj->get()->getFileName());
     return ELFLinkGraphBuilder_x86_64(std::move(fileName),
                                       *ELFObjFile.getELFFile())
         .buildGraph();
   }
 
   Error applyFixup(Block &B, const Edge &E, char *BlockWorkingMem) const {
-    //TODO: add relocation handling
+    using namespace ELF_x86_64_Edges;
+    char *FixupPtr = BlockWorkingMem + E.getOffset();
+    JITTargetAddress FixupAddress = B.getAddress() + E.getOffset();
+    switch (E.getKind()) {
+
+    case ELFX86RelocationKind::PCRel32:
+      int64_t Value = E.getTarget().getAddress() + E.getAddend() - FixupAddress;
+      // verify
+      *(support::little32_t *)FixupPtr = Value;
+      break;
+    }
     return Error::success();
   }
 };
 
 void jitLink_ELF_x86_64(std::unique_ptr<JITLinkContext> Ctx) {
   PassConfiguration Config;
   Triple TT("x86_64-linux");
   // Construct a JITLinker and run the link function.
   // Add a mark-live pass.
   if (auto MarkLive = Ctx->getMarkLivePass(TT))
     Config.PrePrunePasses.push_back(std::move(MarkLive));
   else
     Config.PrePrunePasses.push_back(markAllSymbolsLive);
 
   ELFJITLinker_x86_64::link(std::move(Ctx), std::move(Config));
 }
-
-StringRef getELFX86RelocationKindName(Edge::Kind R) {
-  // case R_AMD64_NONE:
-  //   return "None";
-  // case R_AMD64_PC32:
-  // case R_AMD64_GOT32:
-  // case R_AMD64_PLT32,
-  // R_AMD64_COPY,
-  // R_AMD64_GLOB_DAT,
-  // R_AMD64_JUMP_SLOT,
-  // R_AMD64_RELATIVE,
-  // R_AMD64_GOTPCREL,
-  // R_AMD64_32,
-  // R_AMD64_32S,
-  // R_AMD64_16,
-  // R_AMD64_PC16,
-  // R_AMD64_8,
-  // R_AMD64_PC8,
-  // R_AMD64_PC64,
-  // R_AMD64_GOTOFF64,
-  // R_AMD64_GOTPC32,
-  // R_AMD64_SIZE32,
-  // R_AMD64_SIZE64
-  return getGenericEdgeKindName(static_cast<Edge::Kind>(R));
-}
 } // end namespace jitlink
 } // end namespace llvm