338 lines · cpp
1//===----- ELF_aarch32.cpp - JIT linker implementation for arm/thumb ------===//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-exception6//7//===----------------------------------------------------------------------===//8//9// ELF/aarch32 jit-link implementation.10//11//===----------------------------------------------------------------------===//12 13#include "llvm/ExecutionEngine/JITLink/ELF_aarch32.h"14 15#include "llvm/BinaryFormat/ELF.h"16#include "llvm/ExecutionEngine/JITLink/JITLink.h"17#include "llvm/ExecutionEngine/JITLink/aarch32.h"18#include "llvm/Object/ELF.h"19#include "llvm/Object/ELFObjectFile.h"20#include "llvm/Support/Compiler.h"21#include "llvm/Support/ErrorHandling.h"22#include "llvm/TargetParser/ARMTargetParser.h"23 24#include "ELFLinkGraphBuilder.h"25#include "JITLinkGeneric.h"26 27#define DEBUG_TYPE "jitlink"28 29using namespace llvm::object;30 31namespace llvm {32namespace jitlink {33 34/// Translate from ELF relocation type to JITLink-internal edge kind.35LLVM_ABI Expected<aarch32::EdgeKind_aarch32>36getJITLinkEdgeKind(uint32_t ELFType, const aarch32::ArmConfig &ArmCfg) {37 switch (ELFType) {38 case ELF::R_ARM_ABS32:39 return aarch32::Data_Pointer32;40 case ELF::R_ARM_GOT_PREL:41 return aarch32::Data_RequestGOTAndTransformToDelta32;42 case ELF::R_ARM_REL32:43 return aarch32::Data_Delta32;44 case ELF::R_ARM_CALL:45 return aarch32::Arm_Call;46 case ELF::R_ARM_JUMP24:47 return aarch32::Arm_Jump24;48 case ELF::R_ARM_MOVW_ABS_NC:49 return aarch32::Arm_MovwAbsNC;50 case ELF::R_ARM_MOVT_ABS:51 return aarch32::Arm_MovtAbs;52 case ELF::R_ARM_NONE:53 return aarch32::None;54 case ELF::R_ARM_PREL31:55 return aarch32::Data_PRel31;56 case ELF::R_ARM_TARGET1:57 return (ArmCfg.Target1Rel) ? aarch32::Data_Delta3258 : aarch32::Data_Pointer32;59 case ELF::R_ARM_THM_CALL:60 return aarch32::Thumb_Call;61 case ELF::R_ARM_THM_JUMP24:62 return aarch32::Thumb_Jump24;63 case ELF::R_ARM_THM_MOVW_ABS_NC:64 return aarch32::Thumb_MovwAbsNC;65 case ELF::R_ARM_THM_MOVT_ABS:66 return aarch32::Thumb_MovtAbs;67 case ELF::R_ARM_THM_MOVW_PREL_NC:68 return aarch32::Thumb_MovwPrelNC;69 case ELF::R_ARM_THM_MOVT_PREL:70 return aarch32::Thumb_MovtPrel;71 }72 73 return make_error<JITLinkError>(74 "Unsupported aarch32 relocation " + formatv("{0:d}: ", ELFType) +75 object::getELFRelocationTypeName(ELF::EM_ARM, ELFType));76}77 78/// Translate from JITLink-internal edge kind back to ELF relocation type.79LLVM_ABI Expected<uint32_t> getELFRelocationType(Edge::Kind Kind) {80 switch (static_cast<aarch32::EdgeKind_aarch32>(Kind)) {81 case aarch32::Data_Delta32:82 return ELF::R_ARM_REL32;83 case aarch32::Data_Pointer32:84 return ELF::R_ARM_ABS32;85 case aarch32::Data_PRel31:86 return ELF::R_ARM_PREL31;87 case aarch32::Data_RequestGOTAndTransformToDelta32:88 return ELF::R_ARM_GOT_PREL;89 case aarch32::Arm_Call:90 return ELF::R_ARM_CALL;91 case aarch32::Arm_Jump24:92 return ELF::R_ARM_JUMP24;93 case aarch32::Arm_MovwAbsNC:94 return ELF::R_ARM_MOVW_ABS_NC;95 case aarch32::Arm_MovtAbs:96 return ELF::R_ARM_MOVT_ABS;97 case aarch32::Thumb_Call:98 return ELF::R_ARM_THM_CALL;99 case aarch32::Thumb_Jump24:100 return ELF::R_ARM_THM_JUMP24;101 case aarch32::Thumb_MovwAbsNC:102 return ELF::R_ARM_THM_MOVW_ABS_NC;103 case aarch32::Thumb_MovtAbs:104 return ELF::R_ARM_THM_MOVT_ABS;105 case aarch32::Thumb_MovwPrelNC:106 return ELF::R_ARM_THM_MOVW_PREL_NC;107 case aarch32::Thumb_MovtPrel:108 return ELF::R_ARM_THM_MOVT_PREL;109 case aarch32::None:110 return ELF::R_ARM_NONE;111 }112 113 return make_error<JITLinkError>(formatv("Invalid aarch32 edge {0:d}: ",114 Kind));115}116 117/// Get a human-readable name for the given ELF AArch32 edge kind.118const char *getELFAArch32EdgeKindName(Edge::Kind R) {119 // No ELF-specific edge kinds yet120 return aarch32::getEdgeKindName(R);121}122 123class ELFJITLinker_aarch32 : public JITLinker<ELFJITLinker_aarch32> {124 friend class JITLinker<ELFJITLinker_aarch32>;125 126public:127 ELFJITLinker_aarch32(std::unique_ptr<JITLinkContext> Ctx,128 std::unique_ptr<LinkGraph> G, PassConfiguration PassCfg,129 aarch32::ArmConfig ArmCfg)130 : JITLinker(std::move(Ctx), std::move(G), std::move(PassCfg)),131 ArmCfg(std::move(ArmCfg)) {}132 133private:134 aarch32::ArmConfig ArmCfg;135 136 Error applyFixup(LinkGraph &G, Block &B, const Edge &E) const {137 return aarch32::applyFixup(G, B, E, ArmCfg);138 }139};140 141template <llvm::endianness DataEndianness>142class ELFLinkGraphBuilder_aarch32143 : public ELFLinkGraphBuilder<ELFType<DataEndianness, false>> {144private:145 using ELFT = ELFType<DataEndianness, false>;146 using Base = ELFLinkGraphBuilder<ELFT>;147 148 Error addRelocations() override {149 LLVM_DEBUG(dbgs() << "Processing relocations:\n");150 using Self = ELFLinkGraphBuilder_aarch32<DataEndianness>;151 for (const auto &RelSect : Base::Sections) {152 if (Error Err = Base::forEachRelRelocation(RelSect, this,153 &Self::addSingleRelRelocation))154 return Err;155 }156 return Error::success();157 }158 159 Error addSingleRelRelocation(const typename ELFT::Rel &Rel,160 const typename ELFT::Shdr &FixupSect,161 Block &BlockToFix) {162 uint32_t SymbolIndex = Rel.getSymbol(false);163 auto ObjSymbol = Base::Obj.getRelocationSymbol(Rel, Base::SymTabSec);164 if (!ObjSymbol)165 return ObjSymbol.takeError();166 167 Symbol *GraphSymbol = Base::getGraphSymbol(SymbolIndex);168 if (!GraphSymbol)169 return make_error<StringError>(170 formatv("Could not find symbol at given index, did you add it to "171 "JITSymbolTable? index: {0}, shndx: {1} Size of table: {2}",172 SymbolIndex, (*ObjSymbol)->st_shndx,173 Base::GraphSymbols.size()),174 inconvertibleErrorCode());175 176 uint32_t Type = Rel.getType(false);177 Expected<aarch32::EdgeKind_aarch32> Kind = getJITLinkEdgeKind(Type, ArmCfg);178 if (!Kind)179 return Kind.takeError();180 181 auto FixupAddress = orc::ExecutorAddr(FixupSect.sh_addr) + Rel.r_offset;182 Edge::OffsetT Offset = FixupAddress - BlockToFix.getAddress();183 184 Expected<int64_t> Addend =185 aarch32::readAddend(*Base::G, BlockToFix, Offset, *Kind, ArmCfg);186 if (!Addend)187 return Addend.takeError();188 189 Edge E(*Kind, Offset, *GraphSymbol, *Addend);190 LLVM_DEBUG({191 dbgs() << " ";192 printEdge(dbgs(), BlockToFix, E, getELFAArch32EdgeKindName(*Kind));193 dbgs() << "\n";194 });195 196 BlockToFix.addEdge(std::move(E));197 return Error::success();198 }199 200 aarch32::ArmConfig ArmCfg;201 202protected:203 TargetFlagsType makeTargetFlags(const typename ELFT::Sym &Sym) override {204 // Only emit target flag for callable symbols205 if (Sym.getType() != ELF::STT_FUNC)206 return TargetFlagsType{};207 if (Sym.getValue() & 0x01)208 return aarch32::ThumbSymbol;209 return TargetFlagsType{};210 }211 212 orc::ExecutorAddrDiff getRawOffset(const typename ELFT::Sym &Sym,213 TargetFlagsType Flags) override {214 assert((makeTargetFlags(Sym) & Flags) == Flags);215 static constexpr uint64_t ThumbBit = 0x01;216 if (Sym.getType() == ELF::STT_FUNC)217 return Sym.getValue() & ~ThumbBit;218 return Sym.getValue();219 }220 221public:222 ELFLinkGraphBuilder_aarch32(StringRef FileName,223 const llvm::object::ELFFile<ELFT> &Obj,224 std::shared_ptr<orc::SymbolStringPool> SSP,225 Triple TT, SubtargetFeatures Features,226 aarch32::ArmConfig ArmCfg)227 : ELFLinkGraphBuilder<ELFT>(Obj, std::move(SSP), std::move(TT),228 std::move(Features), FileName,229 getELFAArch32EdgeKindName),230 ArmCfg(std::move(ArmCfg)) {}231};232 233template <typename StubsManagerType>234Error buildTables_ELF_aarch32(LinkGraph &G) {235 LLVM_DEBUG(dbgs() << "Visiting edges in graph:\n");236 237 StubsManagerType StubsManager;238 visitExistingEdges(G, StubsManager);239 aarch32::GOTBuilder GOT;240 visitExistingEdges(G, GOT);241 242 return Error::success();243}244 245Expected<std::unique_ptr<LinkGraph>> createLinkGraphFromELFObject_aarch32(246 MemoryBufferRef ObjectBuffer, std::shared_ptr<orc::SymbolStringPool> SSP) {247 LLVM_DEBUG({248 dbgs() << "Building jitlink graph for new input "249 << ObjectBuffer.getBufferIdentifier() << "...\n";250 });251 252 auto ELFObj = ObjectFile::createELFObjectFile(ObjectBuffer);253 if (!ELFObj)254 return ELFObj.takeError();255 256 auto Features = (*ELFObj)->getFeatures();257 if (!Features)258 return Features.takeError();259 260 // Find out what exact AArch32 instruction set and features we target.261 auto TT = (*ELFObj)->makeTriple();262 ARM::ArchKind AK = ARM::parseArch(TT.getArchName());263 if (AK == ARM::ArchKind::INVALID)264 return make_error<JITLinkError>(265 "Failed to build ELF link graph: Invalid ARM ArchKind");266 267 // Resolve our internal configuration for the target. If at some point the268 // CPUArch alone becomes too unprecise, we can find more details in the269 // Tag_CPU_arch_profile.270 auto Arch = static_cast<ARMBuildAttrs::CPUArch>(ARM::getArchAttr(AK));271 aarch32::ArmConfig ArmCfg = aarch32::getArmConfigForCPUArch(Arch);272 273 // Populate the link-graph.274 switch (TT.getArch()) {275 case Triple::arm:276 case Triple::thumb: {277 auto &ELFFile = cast<ELFObjectFile<ELF32LE>>(**ELFObj).getELFFile();278 return ELFLinkGraphBuilder_aarch32<llvm::endianness::little>(279 (*ELFObj)->getFileName(), ELFFile, std::move(SSP), TT,280 std::move(*Features), ArmCfg)281 .buildGraph();282 }283 case Triple::armeb:284 case Triple::thumbeb: {285 auto &ELFFile = cast<ELFObjectFile<ELF32BE>>(**ELFObj).getELFFile();286 return ELFLinkGraphBuilder_aarch32<llvm::endianness::big>(287 (*ELFObj)->getFileName(), ELFFile, std::move(SSP), TT,288 std::move(*Features), ArmCfg)289 .buildGraph();290 }291 default:292 return make_error<JITLinkError>(293 "Failed to build ELF/aarch32 link graph: Invalid target triple " +294 TT.getTriple());295 }296}297 298void link_ELF_aarch32(std::unique_ptr<LinkGraph> G,299 std::unique_ptr<JITLinkContext> Ctx) {300 const Triple &TT = G->getTargetTriple();301 302 using namespace ARMBuildAttrs;303 ARM::ArchKind AK = ARM::parseArch(TT.getArchName());304 auto CPU = static_cast<CPUArch>(ARM::getArchAttr(AK));305 aarch32::ArmConfig ArmCfg = aarch32::getArmConfigForCPUArch(CPU);306 307 PassConfiguration PassCfg;308 if (Ctx->shouldAddDefaultTargetPasses(TT)) {309 // Add a mark-live pass.310 if (auto MarkLive = Ctx->getMarkLivePass(TT))311 PassCfg.PrePrunePasses.push_back(std::move(MarkLive));312 else313 PassCfg.PrePrunePasses.push_back(markAllSymbolsLive);314 315 switch (ArmCfg.Stubs) {316 case aarch32::StubsFlavor::pre_v7:317 PassCfg.PostPrunePasses.push_back(318 buildTables_ELF_aarch32<aarch32::StubsManager_prev7>);319 break;320 case aarch32::StubsFlavor::v7:321 PassCfg.PostPrunePasses.push_back(322 buildTables_ELF_aarch32<aarch32::StubsManager_v7>);323 break;324 case aarch32::StubsFlavor::Undefined:325 llvm_unreachable("Check before building graph");326 }327 }328 329 if (auto Err = Ctx->modifyPassConfig(*G, PassCfg))330 return Ctx->notifyFailed(std::move(Err));331 332 ELFJITLinker_aarch32::link(std::move(Ctx), std::move(G), std::move(PassCfg),333 std::move(ArmCfg));334}335 336} // namespace jitlink337} // namespace llvm338