diff options
Diffstat (limited to 'llvm/lib/ExecutionEngine/JITLink/ELF_aarch64.cpp')
| -rw-r--r-- | llvm/lib/ExecutionEngine/JITLink/ELF_aarch64.cpp | 185 |
1 files changed, 185 insertions, 0 deletions
diff --git a/llvm/lib/ExecutionEngine/JITLink/ELF_aarch64.cpp b/llvm/lib/ExecutionEngine/JITLink/ELF_aarch64.cpp new file mode 100644 index 000000000000..dc183dfddfae --- /dev/null +++ b/llvm/lib/ExecutionEngine/JITLink/ELF_aarch64.cpp @@ -0,0 +1,185 @@ +//===----- ELF_aarch64.cpp - JIT linker implementation for ELF/aarch64 ----===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// ELF/aarch64 jit-link implementation. +// +//===----------------------------------------------------------------------===// + +#include "llvm/ExecutionEngine/JITLink/ELF_aarch64.h" +#include "ELFLinkGraphBuilder.h" +#include "JITLinkGeneric.h" +#include "llvm/BinaryFormat/ELF.h" +#include "llvm/ExecutionEngine/JITLink/aarch64.h" +#include "llvm/Object/ELFObjectFile.h" + +#define DEBUG_TYPE "jitlink" + +using namespace llvm; +using namespace llvm::jitlink; + +namespace llvm { +namespace jitlink { + +class ELFJITLinker_aarch64 : public JITLinker<ELFJITLinker_aarch64> { + friend class JITLinker<ELFJITLinker_aarch64>; + +public: + ELFJITLinker_aarch64(std::unique_ptr<JITLinkContext> Ctx, + std::unique_ptr<LinkGraph> G, + PassConfiguration PassConfig) + : JITLinker(std::move(Ctx), std::move(G), std::move(PassConfig)) {} + +private: + Error applyFixup(LinkGraph &G, Block &B, const Edge &E) const { + using namespace aarch64; + using namespace llvm::support; + + char *BlockWorkingMem = B.getAlreadyMutableContent().data(); + char *FixupPtr = BlockWorkingMem + E.getOffset(); + JITTargetAddress FixupAddress = B.getAddress() + E.getOffset(); + switch (E.getKind()) { + case aarch64::R_AARCH64_CALL26: { + assert((FixupAddress & 0x3) == 0 && "Call-inst is not 32-bit aligned"); + int64_t Value = E.getTarget().getAddress() - FixupAddress + E.getAddend(); + + if (static_cast<uint64_t>(Value) & 0x3) + return make_error<JITLinkError>("Call target is not 32-bit aligned"); + + if (!fitsRangeSignedInt<27>(Value)) + return makeTargetOutOfRangeError(G, B, E); + + uint32_t RawInstr = *(little32_t *)FixupPtr; + assert((RawInstr & 0x7fffffff) == 0x14000000 && + "RawInstr isn't a B or BR immediate instruction"); + uint32_t Imm = (static_cast<uint32_t>(Value) & ((1 << 28) - 1)) >> 2; + uint32_t FixedInstr = RawInstr | Imm; + *(little32_t *)FixupPtr = FixedInstr; + break; + } + } + return Error::success(); + } + + template <uint8_t Bits> static bool fitsRangeSignedInt(int64_t Value) { + return Value >= -(1ll << Bits) && Value < (1ll << Bits); + } +}; + +template <typename ELFT> +class ELFLinkGraphBuilder_aarch64 : public ELFLinkGraphBuilder<ELFT> { +private: + static Expected<aarch64::EdgeKind_aarch64> + getRelocationKind(const uint32_t Type) { + using namespace aarch64; + switch (Type) { + case ELF::R_AARCH64_CALL26: + return EdgeKind_aarch64::R_AARCH64_CALL26; + } + + return make_error<JITLinkError>("Unsupported aarch64 relocation:" + + formatv("{0:d}", Type)); + } + + Error addRelocations() override { + LLVM_DEBUG(dbgs() << "Processing relocations:\n"); + + using Base = ELFLinkGraphBuilder<ELFT>; + using Self = ELFLinkGraphBuilder_aarch64<ELFT>; + for (const auto &RelSect : Base::Sections) + if (Error Err = Base::forEachRelocation(RelSect, this, + &Self::addSingleRelocation)) + return Err; + + return Error::success(); + } + + Error addSingleRelocation(const typename ELFT::Rela &Rel, + const typename ELFT::Shdr &FixupSect, + Section &GraphSection) { + using Base = ELFLinkGraphBuilder<ELFT>; + + uint32_t SymbolIndex = Rel.getSymbol(false); + auto ObjSymbol = Base::Obj.getRelocationSymbol(Rel, Base::SymTabSec); + if (!ObjSymbol) + return ObjSymbol.takeError(); + + Symbol *GraphSymbol = Base::getGraphSymbol(SymbolIndex); + if (!GraphSymbol) + return make_error<StringError>( + formatv("Could not find symbol at given index, did you add it to " + "JITSymbolTable? index: {0}, shndx: {1} Size of table: {2}", + SymbolIndex, (*ObjSymbol)->st_shndx, + Base::GraphSymbols.size()), + inconvertibleErrorCode()); + + uint32_t Type = Rel.getType(false); + Expected<aarch64::EdgeKind_aarch64> Kind = getRelocationKind(Type); + if (!Kind) + return Kind.takeError(); + + int64_t Addend = Rel.r_addend; + Block *BlockToFix = *(GraphSection.blocks().begin()); + JITTargetAddress FixupAddress = FixupSect.sh_addr + Rel.r_offset; + Edge::OffsetT Offset = FixupAddress - BlockToFix->getAddress(); + Edge GE(*Kind, Offset, *GraphSymbol, Addend); + LLVM_DEBUG({ + dbgs() << " "; + printEdge(dbgs(), *BlockToFix, GE, aarch64::getEdgeKindName(*Kind)); + dbgs() << "\n"; + }); + + BlockToFix->addEdge(std::move(GE)); + return Error::success(); + } + +public: + ELFLinkGraphBuilder_aarch64(StringRef FileName, + const object::ELFFile<ELFT> &Obj, const Triple T) + : ELFLinkGraphBuilder<ELFT>(Obj, std::move(T), FileName, + aarch64::getEdgeKindName) {} +}; + +Expected<std::unique_ptr<LinkGraph>> +createLinkGraphFromELFObject_aarch64(MemoryBufferRef ObjectBuffer) { + LLVM_DEBUG({ + dbgs() << "Building jitlink graph for new input " + << ObjectBuffer.getBufferIdentifier() << "...\n"; + }); + + auto ELFObj = object::ObjectFile::createELFObjectFile(ObjectBuffer); + if (!ELFObj) + return ELFObj.takeError(); + + assert((*ELFObj)->getArch() == Triple::aarch64 && + "Only AArch64 (little endian) is supported for now"); + + auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF64LE>>(**ELFObj); + return ELFLinkGraphBuilder_aarch64<object::ELF64LE>((*ELFObj)->getFileName(), + ELFObjFile.getELFFile(), + (*ELFObj)->makeTriple()) + .buildGraph(); +} + +void link_ELF_aarch64(std::unique_ptr<LinkGraph> G, + std::unique_ptr<JITLinkContext> Ctx) { + PassConfiguration Config; + const Triple &TT = G->getTargetTriple(); + if (Ctx->shouldAddDefaultTargetPasses(TT)) { + if (auto MarkLive = Ctx->getMarkLivePass(TT)) + Config.PrePrunePasses.push_back(std::move(MarkLive)); + else + Config.PrePrunePasses.push_back(markAllSymbolsLive); + } + if (auto Err = Ctx->modifyPassConfig(*G, Config)) + return Ctx->notifyFailed(std::move(Err)); + + ELFJITLinker_aarch64::link(std::move(Ctx), std::move(G), std::move(Config)); +} + +} // namespace jitlink +} // namespace llvm |