1 //===----- ELF_aarch64.cpp - JIT linker implementation for ELF/aarch64 ----===// 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/aarch64 jit-link implementation. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "llvm/ExecutionEngine/JITLink/ELF_aarch64.h" 14 #include "ELFLinkGraphBuilder.h" 15 #include "JITLinkGeneric.h" 16 #include "llvm/BinaryFormat/ELF.h" 17 #include "llvm/ExecutionEngine/JITLink/aarch64.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 { 26 namespace jitlink { 27 28 class ELFJITLinker_aarch64 : public JITLinker<ELFJITLinker_aarch64> { 29 friend class JITLinker<ELFJITLinker_aarch64>; 30 31 public: 32 ELFJITLinker_aarch64(std::unique_ptr<JITLinkContext> Ctx, 33 std::unique_ptr<LinkGraph> G, 34 PassConfiguration PassConfig) 35 : JITLinker(std::move(Ctx), std::move(G), std::move(PassConfig)) {} 36 37 private: 38 Error applyFixup(LinkGraph &G, Block &B, const Edge &E) const { 39 using namespace aarch64; 40 using namespace llvm::support; 41 42 char *BlockWorkingMem = B.getAlreadyMutableContent().data(); 43 char *FixupPtr = BlockWorkingMem + E.getOffset(); 44 JITTargetAddress FixupAddress = B.getAddress() + E.getOffset(); 45 switch (E.getKind()) { 46 case aarch64::R_AARCH64_CALL26: { 47 assert((FixupAddress & 0x3) == 0 && "Call-inst is not 32-bit aligned"); 48 int64_t Value = E.getTarget().getAddress() - FixupAddress + E.getAddend(); 49 50 if (static_cast<uint64_t>(Value) & 0x3) 51 return make_error<JITLinkError>("Call target is not 32-bit aligned"); 52 53 if (!fitsRangeSignedInt<27>(Value)) 54 return makeTargetOutOfRangeError(G, B, E); 55 56 uint32_t RawInstr = *(little32_t *)FixupPtr; 57 assert((RawInstr & 0x7fffffff) == 0x14000000 && 58 "RawInstr isn't a B or BR immediate instruction"); 59 uint32_t Imm = (static_cast<uint32_t>(Value) & ((1 << 28) - 1)) >> 2; 60 uint32_t FixedInstr = RawInstr | Imm; 61 *(little32_t *)FixupPtr = FixedInstr; 62 break; 63 } 64 } 65 return Error::success(); 66 } 67 68 template <uint8_t Bits> static bool fitsRangeSignedInt(int64_t Value) { 69 return Value >= -(1ll << Bits) && Value < (1ll << Bits); 70 } 71 }; 72 73 template <typename ELFT> 74 class ELFLinkGraphBuilder_aarch64 : public ELFLinkGraphBuilder<ELFT> { 75 private: 76 static Expected<aarch64::EdgeKind_aarch64> 77 getRelocationKind(const uint32_t Type) { 78 using namespace aarch64; 79 switch (Type) { 80 case ELF::R_AARCH64_CALL26: 81 return EdgeKind_aarch64::R_AARCH64_CALL26; 82 } 83 84 return make_error<JITLinkError>("Unsupported aarch64 relocation:" + 85 formatv("{0:d}", Type)); 86 } 87 88 Error addRelocations() override { 89 LLVM_DEBUG(dbgs() << "Processing relocations:\n"); 90 91 using Base = ELFLinkGraphBuilder<ELFT>; 92 using Self = ELFLinkGraphBuilder_aarch64<ELFT>; 93 for (const auto &RelSect : Base::Sections) 94 if (Error Err = Base::forEachRelocation(RelSect, this, 95 &Self::addSingleRelocation)) 96 return Err; 97 98 return Error::success(); 99 } 100 101 Error addSingleRelocation(const typename ELFT::Rela &Rel, 102 const typename ELFT::Shdr &FixupSect, 103 Section &GraphSection) { 104 using Base = ELFLinkGraphBuilder<ELFT>; 105 106 uint32_t SymbolIndex = Rel.getSymbol(false); 107 auto ObjSymbol = Base::Obj.getRelocationSymbol(Rel, Base::SymTabSec); 108 if (!ObjSymbol) 109 return ObjSymbol.takeError(); 110 111 Symbol *GraphSymbol = Base::getGraphSymbol(SymbolIndex); 112 if (!GraphSymbol) 113 return make_error<StringError>( 114 formatv("Could not find symbol at given index, did you add it to " 115 "JITSymbolTable? index: {0}, shndx: {1} Size of table: {2}", 116 SymbolIndex, (*ObjSymbol)->st_shndx, 117 Base::GraphSymbols.size()), 118 inconvertibleErrorCode()); 119 120 uint32_t Type = Rel.getType(false); 121 Expected<aarch64::EdgeKind_aarch64> Kind = getRelocationKind(Type); 122 if (!Kind) 123 return Kind.takeError(); 124 125 int64_t Addend = Rel.r_addend; 126 Block *BlockToFix = *(GraphSection.blocks().begin()); 127 JITTargetAddress FixupAddress = FixupSect.sh_addr + Rel.r_offset; 128 Edge::OffsetT Offset = FixupAddress - BlockToFix->getAddress(); 129 Edge GE(*Kind, Offset, *GraphSymbol, Addend); 130 LLVM_DEBUG({ 131 dbgs() << " "; 132 printEdge(dbgs(), *BlockToFix, GE, aarch64::getEdgeKindName(*Kind)); 133 dbgs() << "\n"; 134 }); 135 136 BlockToFix->addEdge(std::move(GE)); 137 return Error::success(); 138 } 139 140 public: 141 ELFLinkGraphBuilder_aarch64(StringRef FileName, 142 const object::ELFFile<ELFT> &Obj, const Triple T) 143 : ELFLinkGraphBuilder<ELFT>(Obj, std::move(T), FileName, 144 aarch64::getEdgeKindName) {} 145 }; 146 147 Expected<std::unique_ptr<LinkGraph>> 148 createLinkGraphFromELFObject_aarch64(MemoryBufferRef ObjectBuffer) { 149 LLVM_DEBUG({ 150 dbgs() << "Building jitlink graph for new input " 151 << ObjectBuffer.getBufferIdentifier() << "...\n"; 152 }); 153 154 auto ELFObj = object::ObjectFile::createELFObjectFile(ObjectBuffer); 155 if (!ELFObj) 156 return ELFObj.takeError(); 157 158 assert((*ELFObj)->getArch() == Triple::aarch64 && 159 "Only AArch64 (little endian) is supported for now"); 160 161 auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF64LE>>(**ELFObj); 162 return ELFLinkGraphBuilder_aarch64<object::ELF64LE>((*ELFObj)->getFileName(), 163 ELFObjFile.getELFFile(), 164 (*ELFObj)->makeTriple()) 165 .buildGraph(); 166 } 167 168 void link_ELF_aarch64(std::unique_ptr<LinkGraph> G, 169 std::unique_ptr<JITLinkContext> Ctx) { 170 PassConfiguration Config; 171 const Triple &TT = G->getTargetTriple(); 172 if (Ctx->shouldAddDefaultTargetPasses(TT)) { 173 if (auto MarkLive = Ctx->getMarkLivePass(TT)) 174 Config.PrePrunePasses.push_back(std::move(MarkLive)); 175 else 176 Config.PrePrunePasses.push_back(markAllSymbolsLive); 177 } 178 if (auto Err = Ctx->modifyPassConfig(*G, Config)) 179 return Ctx->notifyFailed(std::move(Err)); 180 181 ELFJITLinker_aarch64::link(std::move(Ctx), std::move(G), std::move(Config)); 182 } 183 184 } // namespace jitlink 185 } // namespace llvm 186