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