544 lines
19 KiB
C++
544 lines
19 KiB
C++
|
//===------- ELF_ppc64.cpp -JIT linker implementation for ELF/ppc64 -------===//
|
||
|
|
//
|
||
|
|
// 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/ppc64 jit-link implementation.
|
||
|
|
//
|
||
|
|
//===----------------------------------------------------------------------===//
|
||
|
|
|
||
|
|
#include "llvm/ExecutionEngine/JITLink/ELF_ppc64.h"
|
||
|
|
#include "llvm/ExecutionEngine/JITLink/DWARFRecordSectionSplitter.h"
|
||
|
|
#include "llvm/ExecutionEngine/JITLink/TableManager.h"
|
||
|
|
#include "llvm/ExecutionEngine/JITLink/ppc64.h"
|
||
|
|
#include "llvm/Object/ELFObjectFile.h"
|
||
|
|
|
||
|
|
#include "EHFrameSupportImpl.h"
|
||
|
|
#include "ELFLinkGraphBuilder.h"
|
||
|
|
#include "JITLinkGeneric.h"
|
||
|
|
|
||
|
|
#define DEBUG_TYPE "jitlink"
|
||
|
|
|
||
|
|
namespace {
|
||
|
|
|
||
|
|
using namespace llvm;
|
||
|
|
using namespace llvm::jitlink;
|
||
|
|
|
||
|
|
constexpr StringRef ELFTOCSymbolName = ".TOC.";
|
||
|
|
constexpr StringRef TOCSymbolAliasIdent = "__TOC__";
|
||
|
|
constexpr uint64_t ELFTOCBaseOffset = 0x8000;
|
||
|
|
constexpr StringRef ELFTLSInfoSectionName = "$__TLSINFO";
|
||
|
|
|
||
|
|
template <llvm::endianness Endianness>
|
||
|
|
class TLSInfoTableManager_ELF_ppc64
|
||
|
|
: public TableManager<TLSInfoTableManager_ELF_ppc64<Endianness>> {
|
||
|
|
public:
|
||
|
|
static const uint8_t TLSInfoEntryContent[16];
|
||
|
|
|
||
|
|
static StringRef getSectionName() { return ELFTLSInfoSectionName; }
|
||
|
|
|
||
|
|
bool visitEdge(LinkGraph &G, Block *B, Edge &E) {
|
||
|
|
Edge::Kind K = E.getKind();
|
||
|
|
switch (K) {
|
||
|
|
case ppc64::RequestTLSDescInGOTAndTransformToTOCDelta16HA:
|
||
|
|
E.setKind(ppc64::TOCDelta16HA);
|
||
|
|
E.setTarget(this->getEntryForTarget(G, E.getTarget()));
|
||
|
|
return true;
|
||
|
|
case ppc64::RequestTLSDescInGOTAndTransformToTOCDelta16LO:
|
||
|
|
E.setKind(ppc64::TOCDelta16LO);
|
||
|
|
E.setTarget(this->getEntryForTarget(G, E.getTarget()));
|
||
|
|
return true;
|
||
|
|
case ppc64::RequestTLSDescInGOTAndTransformToDelta34:
|
||
|
|
E.setKind(ppc64::Delta34);
|
||
|
|
E.setTarget(this->getEntryForTarget(G, E.getTarget()));
|
||
|
|
return true;
|
||
|
|
default:
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
Symbol &createEntry(LinkGraph &G, Symbol &Target) {
|
||
|
|
// The TLS Info entry's key value will be written by
|
||
|
|
// `fixTLVSectionsAndEdges`, so create mutable content.
|
||
|
|
auto &TLSInfoEntry = G.createMutableContentBlock(
|
||
|
|
getTLSInfoSection(G), G.allocateContent(getTLSInfoEntryContent()),
|
||
|
|
orc::ExecutorAddr(), 8, 0);
|
||
|
|
TLSInfoEntry.addEdge(ppc64::Pointer64, 8, Target, 0);
|
||
|
|
return G.addAnonymousSymbol(TLSInfoEntry, 0, 16, false, false);
|
||
|
|
}
|
||
|
|
|
||
|
|
private:
|
||
|
|
Section &getTLSInfoSection(LinkGraph &G) {
|
||
|
|
if (!TLSInfoTable)
|
||
|
|
TLSInfoTable =
|
||
|
|
&G.createSection(ELFTLSInfoSectionName, orc::MemProt::Read);
|
||
|
|
return *TLSInfoTable;
|
||
|
|
}
|
||
|
|
|
||
|
|
ArrayRef<char> getTLSInfoEntryContent() const {
|
||
|
|
return {reinterpret_cast<const char *>(TLSInfoEntryContent),
|
||
|
|
sizeof(TLSInfoEntryContent)};
|
||
|
|
}
|
||
|
|
|
||
|
|
Section *TLSInfoTable = nullptr;
|
||
|
|
};
|
||
|
|
|
||
|
|
template <>
|
||
|
|
const uint8_t TLSInfoTableManager_ELF_ppc64<
|
||
|
|
llvm::endianness::little>::TLSInfoEntryContent[16] = {
|
||
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /*pthread key */
|
||
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 /*data address*/
|
||
|
|
};
|
||
|
|
|
||
|
|
template <>
|
||
|
|
const uint8_t TLSInfoTableManager_ELF_ppc64<
|
||
|
|
llvm::endianness::big>::TLSInfoEntryContent[16] = {
|
||
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /*pthread key */
|
||
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 /*data address*/
|
||
|
|
};
|
||
|
|
|
||
|
|
template <llvm::endianness Endianness>
|
||
|
|
Symbol &createELFGOTHeader(LinkGraph &G,
|
||
|
|
ppc64::TOCTableManager<Endianness> &TOC) {
|
||
|
|
Symbol *TOCSymbol = nullptr;
|
||
|
|
|
||
|
|
for (Symbol *Sym : G.defined_symbols())
|
||
|
|
if (LLVM_UNLIKELY(Sym->getName() == ELFTOCSymbolName)) {
|
||
|
|
TOCSymbol = Sym;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (LLVM_LIKELY(TOCSymbol == nullptr)) {
|
||
|
|
for (Symbol *Sym : G.external_symbols())
|
||
|
|
if (Sym->getName() == ELFTOCSymbolName) {
|
||
|
|
TOCSymbol = Sym;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!TOCSymbol)
|
||
|
|
TOCSymbol = &G.addExternalSymbol(ELFTOCSymbolName, 0, false);
|
||
|
|
|
||
|
|
return TOC.getEntryForTarget(G, *TOCSymbol);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Register preexisting GOT entries with TOC table manager.
|
||
|
|
template <llvm::endianness Endianness>
|
||
|
|
inline void
|
||
|
|
registerExistingGOTEntries(LinkGraph &G,
|
||
|
|
ppc64::TOCTableManager<Endianness> &TOC) {
|
||
|
|
auto isGOTEntry = [](const Edge &E) {
|
||
|
|
return E.getKind() == ppc64::Pointer64 && E.getTarget().isExternal();
|
||
|
|
};
|
||
|
|
if (Section *dotTOCSection = G.findSectionByName(".toc")) {
|
||
|
|
for (Block *B : dotTOCSection->blocks())
|
||
|
|
for (Edge &E : B->edges())
|
||
|
|
if (isGOTEntry(E))
|
||
|
|
TOC.registerPreExistingEntry(E.getTarget(),
|
||
|
|
G.addAnonymousSymbol(*B, E.getOffset(),
|
||
|
|
G.getPointerSize(),
|
||
|
|
false, false));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
template <llvm::endianness Endianness>
|
||
|
|
Error buildTables_ELF_ppc64(LinkGraph &G) {
|
||
|
|
LLVM_DEBUG(dbgs() << "Visiting edges in graph:\n");
|
||
|
|
ppc64::TOCTableManager<Endianness> TOC;
|
||
|
|
// Before visiting edges, we create a header containing the address of TOC
|
||
|
|
// base as ELFABIv2 suggests:
|
||
|
|
// > The GOT consists of an 8-byte header that contains the TOC base (the
|
||
|
|
// first TOC base when multiple TOCs are present), followed by an array of
|
||
|
|
// 8-byte addresses.
|
||
|
|
createELFGOTHeader(G, TOC);
|
||
|
|
|
||
|
|
// There might be compiler-generated GOT entries in ELF relocatable file.
|
||
|
|
registerExistingGOTEntries(G, TOC);
|
||
|
|
|
||
|
|
ppc64::PLTTableManager<Endianness> PLT(TOC);
|
||
|
|
TLSInfoTableManager_ELF_ppc64<Endianness> TLSInfo;
|
||
|
|
visitExistingEdges(G, TOC, PLT, TLSInfo);
|
||
|
|
|
||
|
|
// After visiting edges in LinkGraph, we have GOT entries built in the
|
||
|
|
// synthesized section.
|
||
|
|
// Merge sections included in TOC into synthesized TOC section,
|
||
|
|
// thus TOC is compact and reducing chances of relocation
|
||
|
|
// overflow.
|
||
|
|
if (Section *TOCSection = G.findSectionByName(TOC.getSectionName())) {
|
||
|
|
// .got and .plt are not normally present in a relocatable object file
|
||
|
|
// because they are linker generated.
|
||
|
|
if (Section *gotSection = G.findSectionByName(".got"))
|
||
|
|
G.mergeSections(*TOCSection, *gotSection);
|
||
|
|
if (Section *tocSection = G.findSectionByName(".toc"))
|
||
|
|
G.mergeSections(*TOCSection, *tocSection);
|
||
|
|
if (Section *sdataSection = G.findSectionByName(".sdata"))
|
||
|
|
G.mergeSections(*TOCSection, *sdataSection);
|
||
|
|
if (Section *sbssSection = G.findSectionByName(".sbss"))
|
||
|
|
G.mergeSections(*TOCSection, *sbssSection);
|
||
|
|
// .tocbss no longer appears in ELFABIv2. Leave it here to be compatible
|
||
|
|
// with rtdyld.
|
||
|
|
if (Section *tocbssSection = G.findSectionByName(".tocbss"))
|
||
|
|
G.mergeSections(*TOCSection, *tocbssSection);
|
||
|
|
if (Section *pltSection = G.findSectionByName(".plt"))
|
||
|
|
G.mergeSections(*TOCSection, *pltSection);
|
||
|
|
}
|
||
|
|
|
||
|
|
return Error::success();
|
||
|
|
}
|
||
|
|
|
||
|
|
} // namespace
|
||
|
|
|
||
|
|
namespace llvm::jitlink {
|
||
|
|
|
||
|
|
template <llvm::endianness Endianness>
|
||
|
|
class ELFLinkGraphBuilder_ppc64
|
||
|
|
: public ELFLinkGraphBuilder<object::ELFType<Endianness, true>> {
|
||
|
|
private:
|
||
|
|
using ELFT = object::ELFType<Endianness, true>;
|
||
|
|
using Base = ELFLinkGraphBuilder<ELFT>;
|
||
|
|
|
||
|
|
using Base::G; // Use LinkGraph pointer from base class.
|
||
|
|
|
||
|
|
Error addRelocations() override {
|
||
|
|
LLVM_DEBUG(dbgs() << "Processing relocations:\n");
|
||
|
|
|
||
|
|
using Self = ELFLinkGraphBuilder_ppc64<Endianness>;
|
||
|
|
for (const auto &RelSect : Base::Sections) {
|
||
|
|
// Validate the section to read relocation entries from.
|
||
|
|
if (RelSect.sh_type == ELF::SHT_REL)
|
||
|
|
return make_error<StringError>("No SHT_REL in valid " +
|
||
|
|
G->getTargetTriple().getArchName() +
|
||
|
|
" ELF object files",
|
||
|
|
inconvertibleErrorCode());
|
||
|
|
|
||
|
|
if (Error Err = Base::forEachRelaRelocation(RelSect, this,
|
||
|
|
&Self::addSingleRelocation))
|
||
|
|
return Err;
|
||
|
|
}
|
||
|
|
|
||
|
|
return Error::success();
|
||
|
|
}
|
||
|
|
|
||
|
|
Error addSingleRelocation(const typename ELFT::Rela &Rel,
|
||
|
|
const typename ELFT::Shdr &FixupSection,
|
||
|
|
Block &BlockToFix) {
|
||
|
|
using Base = ELFLinkGraphBuilder<ELFT>;
|
||
|
|
auto ELFReloc = Rel.getType(false);
|
||
|
|
|
||
|
|
// R_PPC64_NONE is a no-op.
|
||
|
|
if (LLVM_UNLIKELY(ELFReloc == ELF::R_PPC64_NONE))
|
||
|
|
return Error::success();
|
||
|
|
|
||
|
|
// TLS model markers. We only support global-dynamic model now.
|
||
|
|
if (ELFReloc == ELF::R_PPC64_TLSGD)
|
||
|
|
return Error::success();
|
||
|
|
if (ELFReloc == ELF::R_PPC64_TLSLD)
|
||
|
|
return make_error<StringError>("Local-dynamic TLS model is not supported",
|
||
|
|
inconvertibleErrorCode());
|
||
|
|
|
||
|
|
if (ELFReloc == ELF::R_PPC64_PCREL_OPT)
|
||
|
|
// TODO: Support PCREL optimization, now ignore it.
|
||
|
|
return Error::success();
|
||
|
|
|
||
|
|
if (ELFReloc == ELF::R_PPC64_TPREL34)
|
||
|
|
return make_error<StringError>("Local-exec TLS model is not supported",
|
||
|
|
inconvertibleErrorCode());
|
||
|
|
|
||
|
|
auto ObjSymbol = Base::Obj.getRelocationSymbol(Rel, Base::SymTabSec);
|
||
|
|
if (!ObjSymbol)
|
||
|
|
return ObjSymbol.takeError();
|
||
|
|
|
||
|
|
uint32_t SymbolIndex = Rel.getSymbol(false);
|
||
|
|
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());
|
||
|
|
|
||
|
|
int64_t Addend = Rel.r_addend;
|
||
|
|
orc::ExecutorAddr FixupAddress =
|
||
|
|
orc::ExecutorAddr(FixupSection.sh_addr) + Rel.r_offset;
|
||
|
|
Edge::OffsetT Offset = FixupAddress - BlockToFix.getAddress();
|
||
|
|
Edge::Kind Kind = Edge::Invalid;
|
||
|
|
|
||
|
|
switch (ELFReloc) {
|
||
|
|
default:
|
||
|
|
return make_error<JITLinkError>(
|
||
|
|
"In " + G->getName() + ": Unsupported ppc64 relocation type " +
|
||
|
|
object::getELFRelocationTypeName(ELF::EM_PPC64, ELFReloc));
|
||
|
|
case ELF::R_PPC64_ADDR64:
|
||
|
|
Kind = ppc64::Pointer64;
|
||
|
|
break;
|
||
|
|
case ELF::R_PPC64_ADDR32:
|
||
|
|
Kind = ppc64::Pointer32;
|
||
|
|
break;
|
||
|
|
case ELF::R_PPC64_ADDR16:
|
||
|
|
Kind = ppc64::Pointer16;
|
||
|
|
break;
|
||
|
|
case ELF::R_PPC64_ADDR16_DS:
|
||
|
|
Kind = ppc64::Pointer16DS;
|
||
|
|
break;
|
||
|
|
case ELF::R_PPC64_ADDR16_HA:
|
||
|
|
Kind = ppc64::Pointer16HA;
|
||
|
|
break;
|
||
|
|
case ELF::R_PPC64_ADDR16_HI:
|
||
|
|
Kind = ppc64::Pointer16HI;
|
||
|
|
break;
|
||
|
|
case ELF::R_PPC64_ADDR16_HIGH:
|
||
|
|
Kind = ppc64::Pointer16HIGH;
|
||
|
|
break;
|
||
|
|
case ELF::R_PPC64_ADDR16_HIGHA:
|
||
|
|
Kind = ppc64::Pointer16HIGHA;
|
||
|
|
break;
|
||
|
|
case ELF::R_PPC64_ADDR16_HIGHER:
|
||
|
|
Kind = ppc64::Pointer16HIGHER;
|
||
|
|
break;
|
||
|
|
case ELF::R_PPC64_ADDR16_HIGHERA:
|
||
|
|
Kind = ppc64::Pointer16HIGHERA;
|
||
|
|
break;
|
||
|
|
case ELF::R_PPC64_ADDR16_HIGHEST:
|
||
|
|
Kind = ppc64::Pointer16HIGHEST;
|
||
|
|
break;
|
||
|
|
case ELF::R_PPC64_ADDR16_HIGHESTA:
|
||
|
|
Kind = ppc64::Pointer16HIGHESTA;
|
||
|
|
break;
|
||
|
|
case ELF::R_PPC64_ADDR16_LO:
|
||
|
|
Kind = ppc64::Pointer16LO;
|
||
|
|
break;
|
||
|
|
case ELF::R_PPC64_ADDR16_LO_DS:
|
||
|
|
Kind = ppc64::Pointer16LODS;
|
||
|
|
break;
|
||
|
|
case ELF::R_PPC64_ADDR14:
|
||
|
|
Kind = ppc64::Pointer14;
|
||
|
|
break;
|
||
|
|
case ELF::R_PPC64_TOC:
|
||
|
|
Kind = ppc64::TOC;
|
||
|
|
break;
|
||
|
|
case ELF::R_PPC64_TOC16:
|
||
|
|
Kind = ppc64::TOCDelta16;
|
||
|
|
break;
|
||
|
|
case ELF::R_PPC64_TOC16_HA:
|
||
|
|
Kind = ppc64::TOCDelta16HA;
|
||
|
|
break;
|
||
|
|
case ELF::R_PPC64_TOC16_HI:
|
||
|
|
Kind = ppc64::TOCDelta16HI;
|
||
|
|
break;
|
||
|
|
case ELF::R_PPC64_TOC16_DS:
|
||
|
|
Kind = ppc64::TOCDelta16DS;
|
||
|
|
break;
|
||
|
|
case ELF::R_PPC64_TOC16_LO:
|
||
|
|
Kind = ppc64::TOCDelta16LO;
|
||
|
|
break;
|
||
|
|
case ELF::R_PPC64_TOC16_LO_DS:
|
||
|
|
Kind = ppc64::TOCDelta16LODS;
|
||
|
|
break;
|
||
|
|
case ELF::R_PPC64_REL16:
|
||
|
|
Kind = ppc64::Delta16;
|
||
|
|
break;
|
||
|
|
case ELF::R_PPC64_REL16_HA:
|
||
|
|
Kind = ppc64::Delta16HA;
|
||
|
|
break;
|
||
|
|
case ELF::R_PPC64_REL16_HI:
|
||
|
|
Kind = ppc64::Delta16HI;
|
||
|
|
break;
|
||
|
|
case ELF::R_PPC64_REL16_LO:
|
||
|
|
Kind = ppc64::Delta16LO;
|
||
|
|
break;
|
||
|
|
case ELF::R_PPC64_REL32:
|
||
|
|
Kind = ppc64::Delta32;
|
||
|
|
break;
|
||
|
|
case ELF::R_PPC64_REL24_NOTOC:
|
||
|
|
Kind = ppc64::RequestCallNoTOC;
|
||
|
|
break;
|
||
|
|
case ELF::R_PPC64_REL24:
|
||
|
|
Kind = ppc64::RequestCall;
|
||
|
|
// Determining a target is external or not is deferred in PostPrunePass.
|
||
|
|
// We assume branching to local entry by default, since in PostPrunePass,
|
||
|
|
// we don't have any context to determine LocalEntryOffset. If it finally
|
||
|
|
// turns out to be an external call, we'll have a stub for the external
|
||
|
|
// target, the target of this edge will be the stub and its addend will be
|
||
|
|
// set 0.
|
||
|
|
Addend += ELF::decodePPC64LocalEntryOffset((*ObjSymbol)->st_other);
|
||
|
|
break;
|
||
|
|
case ELF::R_PPC64_REL64:
|
||
|
|
Kind = ppc64::Delta64;
|
||
|
|
break;
|
||
|
|
case ELF::R_PPC64_PCREL34:
|
||
|
|
Kind = ppc64::Delta34;
|
||
|
|
break;
|
||
|
|
case ELF::R_PPC64_GOT_PCREL34:
|
||
|
|
Kind = ppc64::RequestGOTAndTransformToDelta34;
|
||
|
|
break;
|
||
|
|
case ELF::R_PPC64_GOT_TLSGD16_HA:
|
||
|
|
Kind = ppc64::RequestTLSDescInGOTAndTransformToTOCDelta16HA;
|
||
|
|
break;
|
||
|
|
case ELF::R_PPC64_GOT_TLSGD16_LO:
|
||
|
|
Kind = ppc64::RequestTLSDescInGOTAndTransformToTOCDelta16LO;
|
||
|
|
break;
|
||
|
|
case ELF::R_PPC64_GOT_TLSGD_PCREL34:
|
||
|
|
Kind = ppc64::RequestTLSDescInGOTAndTransformToDelta34;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
Edge GE(Kind, Offset, *GraphSymbol, Addend);
|
||
|
|
BlockToFix.addEdge(std::move(GE));
|
||
|
|
return Error::success();
|
||
|
|
}
|
||
|
|
|
||
|
|
public:
|
||
|
|
ELFLinkGraphBuilder_ppc64(StringRef FileName,
|
||
|
|
const object::ELFFile<ELFT> &Obj, Triple TT,
|
||
|
|
SubtargetFeatures Features)
|
||
|
|
: ELFLinkGraphBuilder<ELFT>(Obj, std::move(TT), std::move(Features),
|
||
|
|
FileName, ppc64::getEdgeKindName) {}
|
||
|
|
};
|
||
|
|
|
||
|
|
template <llvm::endianness Endianness>
|
||
|
|
class ELFJITLinker_ppc64 : public JITLinker<ELFJITLinker_ppc64<Endianness>> {
|
||
|
|
using JITLinkerBase = JITLinker<ELFJITLinker_ppc64<Endianness>>;
|
||
|
|
friend JITLinkerBase;
|
||
|
|
|
||
|
|
public:
|
||
|
|
ELFJITLinker_ppc64(std::unique_ptr<JITLinkContext> Ctx,
|
||
|
|
std::unique_ptr<LinkGraph> G, PassConfiguration PassConfig)
|
||
|
|
: JITLinkerBase(std::move(Ctx), std::move(G), std::move(PassConfig)) {
|
||
|
|
JITLinkerBase::getPassConfig().PostAllocationPasses.push_back(
|
||
|
|
[this](LinkGraph &G) { return defineTOCBase(G); });
|
||
|
|
}
|
||
|
|
|
||
|
|
private:
|
||
|
|
Symbol *TOCSymbol = nullptr;
|
||
|
|
|
||
|
|
Error defineTOCBase(LinkGraph &G) {
|
||
|
|
for (Symbol *Sym : G.defined_symbols()) {
|
||
|
|
if (LLVM_UNLIKELY(Sym->getName() == ELFTOCSymbolName)) {
|
||
|
|
TOCSymbol = Sym;
|
||
|
|
return Error::success();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
assert(TOCSymbol == nullptr &&
|
||
|
|
"TOCSymbol should not be defined at this point");
|
||
|
|
|
||
|
|
for (Symbol *Sym : G.external_symbols()) {
|
||
|
|
if (Sym->getName() == ELFTOCSymbolName) {
|
||
|
|
TOCSymbol = Sym;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (Section *TOCSection = G.findSectionByName(
|
||
|
|
ppc64::TOCTableManager<Endianness>::getSectionName())) {
|
||
|
|
assert(!TOCSection->empty() && "TOC section should have reserved an "
|
||
|
|
"entry for containing the TOC base");
|
||
|
|
|
||
|
|
SectionRange SR(*TOCSection);
|
||
|
|
orc::ExecutorAddr TOCBaseAddr(SR.getFirstBlock()->getAddress() +
|
||
|
|
ELFTOCBaseOffset);
|
||
|
|
assert(TOCSymbol && TOCSymbol->isExternal() &&
|
||
|
|
".TOC. should be a external symbol at this point");
|
||
|
|
G.makeAbsolute(*TOCSymbol, TOCBaseAddr);
|
||
|
|
// Create an alias of .TOC. so that rtdyld checker can recognize.
|
||
|
|
G.addAbsoluteSymbol(TOCSymbolAliasIdent, TOCSymbol->getAddress(),
|
||
|
|
TOCSymbol->getSize(), TOCSymbol->getLinkage(),
|
||
|
|
TOCSymbol->getScope(), TOCSymbol->isLive());
|
||
|
|
return Error::success();
|
||
|
|
}
|
||
|
|
|
||
|
|
// If TOC section doesn't exist, which means no TOC relocation is found, we
|
||
|
|
// don't need a TOCSymbol.
|
||
|
|
return Error::success();
|
||
|
|
}
|
||
|
|
|
||
|
|
Error applyFixup(LinkGraph &G, Block &B, const Edge &E) const {
|
||
|
|
return ppc64::applyFixup<Endianness>(G, B, E, TOCSymbol);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
template <llvm::endianness Endianness>
|
||
|
|
Expected<std::unique_ptr<LinkGraph>>
|
||
|
|
createLinkGraphFromELFObject_ppc64(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();
|
||
|
|
|
||
|
|
auto Features = (*ELFObj)->getFeatures();
|
||
|
|
if (!Features)
|
||
|
|
return Features.takeError();
|
||
|
|
|
||
|
|
using ELFT = object::ELFType<Endianness, true>;
|
||
|
|
auto &ELFObjFile = cast<object::ELFObjectFile<ELFT>>(**ELFObj);
|
||
|
|
return ELFLinkGraphBuilder_ppc64<Endianness>(
|
||
|
|
(*ELFObj)->getFileName(), ELFObjFile.getELFFile(),
|
||
|
|
(*ELFObj)->makeTriple(), std::move(*Features))
|
||
|
|
.buildGraph();
|
||
|
|
}
|
||
|
|
|
||
|
|
template <llvm::endianness Endianness>
|
||
|
|
void link_ELF_ppc64(std::unique_ptr<LinkGraph> G,
|
||
|
|
std::unique_ptr<JITLinkContext> Ctx) {
|
||
|
|
PassConfiguration Config;
|
||
|
|
|
||
|
|
if (Ctx->shouldAddDefaultTargetPasses(G->getTargetTriple())) {
|
||
|
|
// Construct a JITLinker and run the link function.
|
||
|
|
|
||
|
|
// Add eh-frame passes.
|
||
|
|
Config.PrePrunePasses.push_back(DWARFRecordSectionSplitter(".eh_frame"));
|
||
|
|
Config.PrePrunePasses.push_back(EHFrameEdgeFixer(
|
||
|
|
".eh_frame", G->getPointerSize(), ppc64::Pointer32, ppc64::Pointer64,
|
||
|
|
ppc64::Delta32, ppc64::Delta64, ppc64::NegDelta32));
|
||
|
|
Config.PrePrunePasses.push_back(EHFrameNullTerminator(".eh_frame"));
|
||
|
|
|
||
|
|
// Add a mark-live pass.
|
||
|
|
if (auto MarkLive = Ctx->getMarkLivePass(G->getTargetTriple()))
|
||
|
|
Config.PrePrunePasses.push_back(std::move(MarkLive));
|
||
|
|
else
|
||
|
|
Config.PrePrunePasses.push_back(markAllSymbolsLive);
|
||
|
|
}
|
||
|
|
|
||
|
|
Config.PostPrunePasses.push_back(buildTables_ELF_ppc64<Endianness>);
|
||
|
|
|
||
|
|
if (auto Err = Ctx->modifyPassConfig(*G, Config))
|
||
|
|
return Ctx->notifyFailed(std::move(Err));
|
||
|
|
|
||
|
|
ELFJITLinker_ppc64<Endianness>::link(std::move(Ctx), std::move(G),
|
||
|
|
std::move(Config));
|
||
|
|
}
|
||
|
|
|
||
|
|
Expected<std::unique_ptr<LinkGraph>>
|
||
|
|
createLinkGraphFromELFObject_ppc64(MemoryBufferRef ObjectBuffer) {
|
||
|
|
return createLinkGraphFromELFObject_ppc64<llvm::endianness::big>(
|
||
|
|
std::move(ObjectBuffer));
|
||
|
|
}
|
||
|
|
|
||
|
|
Expected<std::unique_ptr<LinkGraph>>
|
||
|
|
createLinkGraphFromELFObject_ppc64le(MemoryBufferRef ObjectBuffer) {
|
||
|
|
return createLinkGraphFromELFObject_ppc64<llvm::endianness::little>(
|
||
|
|
std::move(ObjectBuffer));
|
||
|
|
}
|
||
|
|
|
||
|
|
/// jit-link the given object buffer, which must be a ELF ppc64 object file.
|
||
|
|
void link_ELF_ppc64(std::unique_ptr<LinkGraph> G,
|
||
|
|
std::unique_ptr<JITLinkContext> Ctx) {
|
||
|
|
return link_ELF_ppc64<llvm::endianness::big>(std::move(G), std::move(Ctx));
|
||
|
|
}
|
||
|
|
|
||
|
|
/// jit-link the given object buffer, which must be a ELF ppc64le object file.
|
||
|
|
void link_ELF_ppc64le(std::unique_ptr<LinkGraph> G,
|
||
|
|
std::unique_ptr<JITLinkContext> Ctx) {
|
||
|
|
return link_ELF_ppc64<llvm::endianness::little>(std::move(G), std::move(Ctx));
|
||
|
|
}
|
||
|
|
|
||
|
|
} // end namespace llvm::jitlink
|