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 "ELFLinkGraphBuilder.h" 15 #include "JITLinkGeneric.h" 16 #include "llvm/BinaryFormat/ELF.h" 17 #include "llvm/ExecutionEngine/JITLink/i386.h" 18 #include "llvm/Object/ELFObjectFile.h" 19 20 #define DEBUG_TYPE "jitlink" 21 22 using namespace llvm; 23 using namespace llvm::jitlink; 24 25 namespace llvm::jitlink { 26 27 class ELFJITLinker_i386 : public JITLinker<ELFJITLinker_i386> { 28 friend class JITLinker<ELFJITLinker_i386>; 29 30 public: 31 ELFJITLinker_i386(std::unique_ptr<JITLinkContext> Ctx, 32 std::unique_ptr<LinkGraph> G, PassConfiguration PassConfig) 33 : JITLinker(std::move(Ctx), std::move(G), std::move(PassConfig)) {} 34 35 private: 36 Error applyFixup(LinkGraph &G, Block &B, const Edge &E) const { 37 return i386::applyFixup(G, B, E); 38 } 39 }; 40 41 template <typename ELFT> 42 class ELFLinkGraphBuilder_i386 : public ELFLinkGraphBuilder<ELFT> { 43 private: 44 static Expected<i386::EdgeKind_i386> getRelocationKind(const uint32_t Type) { 45 using namespace i386; 46 switch (Type) { 47 case ELF::R_386_NONE: 48 return EdgeKind_i386::None; 49 case ELF::R_386_32: 50 return EdgeKind_i386::Pointer32; 51 case ELF::R_386_PC32: 52 return EdgeKind_i386::PCRel32; 53 case ELF::R_386_16: 54 return EdgeKind_i386::Pointer16; 55 case ELF::R_386_PC16: 56 return EdgeKind_i386::PCRel16; 57 case ELF::R_386_GOTPC: 58 return EdgeKind_i386::Delta32FromGOT; 59 } 60 61 return make_error<JITLinkError>("Unsupported i386 relocation:" + 62 formatv("{0:d}", Type)); 63 } 64 65 Error addRelocations() override { 66 LLVM_DEBUG(dbgs() << "Adding relocations\n"); 67 using Base = ELFLinkGraphBuilder<ELFT>; 68 using Self = ELFLinkGraphBuilder_i386; 69 70 for (const auto &RelSect : Base::Sections) { 71 // Validate the section to read relocation entries from. 72 if (RelSect.sh_type == ELF::SHT_RELA) 73 return make_error<StringError>( 74 "No SHT_RELA in valid i386 ELF object files", 75 inconvertibleErrorCode()); 76 77 if (Error Err = Base::forEachRelRelocation(RelSect, this, 78 &Self::addSingleRelocation)) 79 return Err; 80 } 81 82 return Error::success(); 83 } 84 85 Error addSingleRelocation(const typename ELFT::Rel &Rel, 86 const typename ELFT::Shdr &FixupSection, 87 Block &BlockToFix) { 88 using Base = ELFLinkGraphBuilder<ELFT>; 89 90 uint32_t SymbolIndex = Rel.getSymbol(false); 91 auto ObjSymbol = Base::Obj.getRelocationSymbol(Rel, Base::SymTabSec); 92 if (!ObjSymbol) 93 return ObjSymbol.takeError(); 94 95 Symbol *GraphSymbol = Base::getGraphSymbol(SymbolIndex); 96 if (!GraphSymbol) 97 return make_error<StringError>( 98 formatv("Could not find symbol at given index, did you add it to " 99 "JITSymbolTable? index: {0}, shndx: {1} Size of table: {2}", 100 SymbolIndex, (*ObjSymbol)->st_shndx, 101 Base::GraphSymbols.size()), 102 inconvertibleErrorCode()); 103 104 Expected<i386::EdgeKind_i386> Kind = getRelocationKind(Rel.getType(false)); 105 if (!Kind) 106 return Kind.takeError(); 107 108 // TODO: To be removed when GOT relative relocations are supported. 109 if (*Kind == i386::EdgeKind_i386::Delta32FromGOT) 110 return Error::success(); 111 112 int64_t Addend = 0; 113 114 auto FixupAddress = orc::ExecutorAddr(FixupSection.sh_addr) + Rel.r_offset; 115 Edge::OffsetT Offset = FixupAddress - BlockToFix.getAddress(); 116 Edge GE(*Kind, Offset, *GraphSymbol, Addend); 117 LLVM_DEBUG({ 118 dbgs() << " "; 119 printEdge(dbgs(), BlockToFix, GE, i386::getEdgeKindName(*Kind)); 120 dbgs() << "\n"; 121 }); 122 123 BlockToFix.addEdge(std::move(GE)); 124 125 return Error::success(); 126 } 127 128 public: 129 ELFLinkGraphBuilder_i386(StringRef FileName, const object::ELFFile<ELFT> &Obj, 130 const Triple T) 131 : ELFLinkGraphBuilder<ELFT>(Obj, std::move(T), FileName, 132 i386::getEdgeKindName) {} 133 }; 134 135 Expected<std::unique_ptr<LinkGraph>> 136 createLinkGraphFromELFObject_i386(MemoryBufferRef ObjectBuffer) { 137 LLVM_DEBUG({ 138 dbgs() << "Building jitlink graph for new input " 139 << ObjectBuffer.getBufferIdentifier() << "...\n"; 140 }); 141 142 auto ELFObj = object::ObjectFile::createELFObjectFile(ObjectBuffer); 143 if (!ELFObj) 144 return ELFObj.takeError(); 145 146 assert((*ELFObj)->getArch() == Triple::x86 && 147 "Only i386 (little endian) is supported for now"); 148 149 auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF32LE>>(**ELFObj); 150 return ELFLinkGraphBuilder_i386<object::ELF32LE>((*ELFObj)->getFileName(), 151 ELFObjFile.getELFFile(), 152 (*ELFObj)->makeTriple()) 153 .buildGraph(); 154 } 155 156 void link_ELF_i386(std::unique_ptr<LinkGraph> G, 157 std::unique_ptr<JITLinkContext> Ctx) { 158 PassConfiguration Config; 159 const Triple &TT = G->getTargetTriple(); 160 if (Ctx->shouldAddDefaultTargetPasses(TT)) { 161 if (auto MarkLive = Ctx->getMarkLivePass(TT)) 162 Config.PrePrunePasses.push_back(std::move(MarkLive)); 163 else 164 Config.PrePrunePasses.push_back(markAllSymbolsLive); 165 } 166 if (auto Err = Ctx->modifyPassConfig(*G, Config)) 167 return Ctx->notifyFailed(std::move(Err)); 168 169 ELFJITLinker_i386::link(std::move(Ctx), std::move(G), std::move(Config)); 170 } 171 172 } // namespace llvm::jitlink 173