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