llvm/lib/ExecutionEngine/JITLink/ELF_i386.cpp

   1 //===----- ELF_i386.cpp - JIT linker implementation for ELF/i386 ----===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // ELF/i386 jit-link implementation.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "llvm/ExecutionEngine/JITLink/ELF_i386.h"
  14 #include "DefineExternalSectionStartAndEndSymbols.h"
  15 #include "ELFLinkGraphBuilder.h"
  16 #include "JITLinkGeneric.h"
  17 #include "llvm/BinaryFormat/ELF.h"
  18 #include "llvm/ExecutionEngine/JITLink/i386.h"
  19 #include "llvm/Object/ELFObjectFile.h"
  20
  21 #define DEBUG_TYPE "jitlink"
  22
  23 using namespace llvm;
  24 using namespace llvm::jitlink;
  25
  26 namespace {
  27 constexpr StringRef ELFGOTSymbolName = "_GLOBAL_OFFSET_TABLE_";
  28
  29 Error buildTables_ELF_i386(LinkGraph &G) {
  30   LLVM_DEBUG(dbgs() << "Visiting edges in graph:\n");
  31
  32   i386::GOTTableManager GOT;
  33   i386::PLTTableManager PLT(GOT);
  34   visitExistingEdges(G, GOT, PLT);
  35   return Error::success();
  36 }
  37 } // namespace
  38
  39 namespace llvm::jitlink {
  40
  41 class ELFJITLinker_i386 : public JITLinker<ELFJITLinker_i386> {
  42   friend class JITLinker<ELFJITLinker_i386>;
  43
  44 public:
  45   ELFJITLinker_i386(std::unique_ptr<JITLinkContext> Ctx,
  46                     std::unique_ptr<LinkGraph> G, PassConfiguration PassConfig)
  47       : JITLinker(std::move(Ctx), std::move(G), std::move(PassConfig)) {
  48     getPassConfig().PostAllocationPasses.push_back(
  49         [this](LinkGraph &G) { return getOrCreateGOTSymbol(G); });
  50   }
  51
  52 private:
  53   Symbol *GOTSymbol = nullptr;
  54
  55   Error getOrCreateGOTSymbol(LinkGraph &G) {
  56     auto DefineExternalGOTSymbolIfPresent =
  57         createDefineExternalSectionStartAndEndSymbolsPass(
  58             [&](LinkGraph &LG, Symbol &Sym) -> SectionRangeSymbolDesc {
  59               if (Sym.getName() == ELFGOTSymbolName)
  60                 if (auto *GOTSection = G.findSectionByName(
  61                         i386::GOTTableManager::getSectionName())) {
  62                   GOTSymbol = &Sym;
  63                   return {*GOTSection, true};
  64                 }
  65               return {};
  66             });
  67
  68     // Try to attach _GLOBAL_OFFSET_TABLE_ to the GOT if it's defined as an
  69     // external.
  70     if (auto Err = DefineExternalGOTSymbolIfPresent(G))
  71       return Err;
  72
  73     // If we succeeded then we're done.
  74     if (GOTSymbol)
  75       return Error::success();
  76
  77     // Otherwise look for a GOT section: If it already has a start symbol we'll
  78     // record it, otherwise we'll create our own.
  79     // If there's a GOT section but we didn't find an external GOT symbol...
  80     if (auto *GOTSection =
  81             G.findSectionByName(i386::GOTTableManager::getSectionName())) {
  82
  83       // Check for an existing defined symbol.
  84       for (auto *Sym : GOTSection->symbols())
  85         if (Sym->getName() == ELFGOTSymbolName) {
  86           GOTSymbol = Sym;
  87           return Error::success();
  88         }
  89
  90       // If there's no defined symbol then create one.
  91       SectionRange SR(*GOTSection);
  92
  93       if (SR.empty()) {
  94         GOTSymbol =
  95             &G.addAbsoluteSymbol(ELFGOTSymbolName, orc::ExecutorAddr(), 0,
  96                                  Linkage::Strong, Scope::Local, true);
  97       } else {
  98         GOTSymbol =
  99             &G.addDefinedSymbol(*SR.getFirstBlock(), 0, ELFGOTSymbolName, 0,
 100                                 Linkage::Strong, Scope::Local, false, true);
 101       }
 102     }
 103
 104     return Error::success();
 105   }
 106
 107   Error applyFixup(LinkGraph &G, Block &B, const Edge &E) const {
 108     return i386::applyFixup(G, B, E, GOTSymbol);
 109   }
 110 };
 111
 112 template <typename ELFT>
 113 class ELFLinkGraphBuilder_i386 : public ELFLinkGraphBuilder<ELFT> {
 114 private:
 115   static Expected<i386::EdgeKind_i386> getRelocationKind(const uint32_t Type) {
 116     using namespace i386;
 117     switch (Type) {
 118     case ELF::R_386_NONE:
 119       return EdgeKind_i386::None;
 120     case ELF::R_386_32:
 121       return EdgeKind_i386::Pointer32;
 122     case ELF::R_386_PC32:
 123       return EdgeKind_i386::PCRel32;
 124     case ELF::R_386_16:
 125       return EdgeKind_i386::Pointer16;
 126     case ELF::R_386_PC16:
 127       return EdgeKind_i386::PCRel16;
 128     case ELF::R_386_GOT32:
 129       return EdgeKind_i386::RequestGOTAndTransformToDelta32FromGOT;
 130     case ELF::R_386_GOTPC:
 131       return EdgeKind_i386::Delta32;
 132     case ELF::R_386_GOTOFF:
 133       return EdgeKind_i386::Delta32FromGOT;
 134     case ELF::R_386_PLT32:
 135       return EdgeKind_i386::BranchPCRel32;
 136     }
 137
 138     return make_error<JITLinkError>("Unsupported i386 relocation:" +
 139                                     formatv("{0:d}", Type));
 140   }
 141
 142   Error addRelocations() override {
 143     LLVM_DEBUG(dbgs() << "Adding relocations\n");
 144     using Base = ELFLinkGraphBuilder<ELFT>;
 145     using Self = ELFLinkGraphBuilder_i386;
 146
 147     for (const auto &RelSect : Base::Sections) {
 148       // Validate the section to read relocation entries from.
 149       if (RelSect.sh_type == ELF::SHT_RELA)
 150         return make_error<StringError>(
 151             "No SHT_RELA in valid i386 ELF object files",
 152             inconvertibleErrorCode());
 153
 154       if (Error Err = Base::forEachRelRelocation(RelSect, this,
 155                                                  &Self::addSingleRelocation))
 156         return Err;
 157     }
 158
 159     return Error::success();
 160   }
 161
 162   Error addSingleRelocation(const typename ELFT::Rel &Rel,
 163                             const typename ELFT::Shdr &FixupSection,
 164                             Block &BlockToFix) {
 165     using Base = ELFLinkGraphBuilder<ELFT>;
 166
 167     uint32_t SymbolIndex = Rel.getSymbol(false);
 168     auto ObjSymbol = Base::Obj.getRelocationSymbol(Rel, Base::SymTabSec);
 169     if (!ObjSymbol)
 170       return ObjSymbol.takeError();
 171
 172     Symbol *GraphSymbol = Base::getGraphSymbol(SymbolIndex);
 173     if (!GraphSymbol)
 174       return make_error<StringError>(
 175           formatv("Could not find symbol at given index, did you add it to "
 176                   "JITSymbolTable? index: {0}, shndx: {1} Size of table: {2}",
 177                   SymbolIndex, (*ObjSymbol)->st_shndx,
 178                   Base::GraphSymbols.size()),
 179           inconvertibleErrorCode());
 180
 181     Expected<i386::EdgeKind_i386> Kind = getRelocationKind(Rel.getType(false));
 182     if (!Kind)
 183       return Kind.takeError();
 184
 185     auto FixupAddress = orc::ExecutorAddr(FixupSection.sh_addr) + Rel.r_offset;
 186     int64_t Addend = 0;
 187
 188     switch (*Kind) {
 189     case i386::EdgeKind_i386::Delta32: {
 190       const char *FixupContent = BlockToFix.getContent().data() +
 191                                  (FixupAddress - BlockToFix.getAddress());
 192       Addend = *(const support::ulittle32_t *)FixupContent;
 193       break;
 194     }
 195     default:
 196       break;
 197     }
 198
 199     Edge::OffsetT Offset = FixupAddress - BlockToFix.getAddress();
 200     Edge GE(*Kind, Offset, *GraphSymbol, Addend);
 201     LLVM_DEBUG({
 202       dbgs() << "    ";
 203       printEdge(dbgs(), BlockToFix, GE, i386::getEdgeKindName(*Kind));
 204       dbgs() << "\n";
 205     });
 206
 207     BlockToFix.addEdge(std::move(GE));
 208     return Error::success();
 209   }
 210
 211 public:
 212   ELFLinkGraphBuilder_i386(StringRef FileName, const object::ELFFile<ELFT> &Obj,
 213                            Triple TT, SubtargetFeatures Features)
 214       : ELFLinkGraphBuilder<ELFT>(Obj, std::move(TT), std::move(Features),
 215                                   FileName, i386::getEdgeKindName) {}
 216 };
 217
 218 Expected<std::unique_ptr<LinkGraph>>
 219 createLinkGraphFromELFObject_i386(MemoryBufferRef ObjectBuffer) {
 220   LLVM_DEBUG({
 221     dbgs() << "Building jitlink graph for new input "
 222            << ObjectBuffer.getBufferIdentifier() << "...\n";
 223   });
 224
 225   auto ELFObj = object::ObjectFile::createELFObjectFile(ObjectBuffer);
 226   if (!ELFObj)
 227     return ELFObj.takeError();
 228
 229   auto Features = (*ELFObj)->getFeatures();
 230   if (!Features)
 231     return Features.takeError();
 232
 233   assert((*ELFObj)->getArch() == Triple::x86 &&
 234          "Only i386 (little endian) is supported for now");
 235
 236   auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF32LE>>(**ELFObj);
 237   return ELFLinkGraphBuilder_i386<object::ELF32LE>(
 238              (*ELFObj)->getFileName(), ELFObjFile.getELFFile(),
 239              (*ELFObj)->makeTriple(), std::move(*Features))
 240       .buildGraph();
 241 }
 242
 243 void link_ELF_i386(std::unique_ptr<LinkGraph> G,
 244                    std::unique_ptr<JITLinkContext> Ctx) {
 245   PassConfiguration Config;
 246   const Triple &TT = G->getTargetTriple();
 247   if (Ctx->shouldAddDefaultTargetPasses(TT)) {
 248     if (auto MarkLive = Ctx->getMarkLivePass(TT))
 249       Config.PrePrunePasses.push_back(std::move(MarkLive));
 250     else
 251       Config.PrePrunePasses.push_back(markAllSymbolsLive);
 252
 253     // Add an in-place GOT and PLT build pass.
 254     Config.PostPrunePasses.push_back(buildTables_ELF_i386);
 255
 256     // Add GOT/Stubs optimizer pass.
 257     Config.PreFixupPasses.push_back(i386::optimizeGOTAndStubAccesses);
 258   }
 259   if (auto Err = Ctx->modifyPassConfig(*G, Config))
 260     return Ctx->notifyFailed(std::move(Err));
 261
 262   ELFJITLinker_i386::link(std::move(Ctx), std::move(G), std::move(Config));
 263 }
 264
 265 } // namespace llvm::jitlink