b972164f38
When building on i386, both clang and gcc define a builtin 'i386' macro (see discussion in https://github.com/llvm/llvm-project/pull/137063). This causes build errors in the JITLink/i386 backend when attempting to build LLVM on i386. This commit renames the 'i386' backend (namespaces, APIs and files) to 'x86' to avoid this issue.
291 lines
9.7 KiB
C++
291 lines
9.7 KiB
C++
//===--------- ELF_x86.cpp - JIT linker implementation for ELF/x86 --------===//
|
|
//
|
|
// 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/x86 jit-link implementation.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/ExecutionEngine/JITLink/ELF_x86.h"
|
|
#include "DefineExternalSectionStartAndEndSymbols.h"
|
|
#include "ELFLinkGraphBuilder.h"
|
|
#include "JITLinkGeneric.h"
|
|
#include "llvm/BinaryFormat/ELF.h"
|
|
#include "llvm/ExecutionEngine/JITLink/x86.h"
|
|
#include "llvm/Object/ELFObjectFile.h"
|
|
|
|
#define DEBUG_TYPE "jitlink"
|
|
|
|
using namespace llvm;
|
|
using namespace llvm::jitlink;
|
|
|
|
namespace {
|
|
constexpr StringRef ELFGOTSymbolName = "_GLOBAL_OFFSET_TABLE_";
|
|
|
|
Error buildTables_ELF_x86(LinkGraph &G) {
|
|
LLVM_DEBUG(dbgs() << "Visiting edges in graph:\n");
|
|
|
|
x86::GOTTableManager GOT;
|
|
x86::PLTTableManager PLT(GOT);
|
|
visitExistingEdges(G, GOT, PLT);
|
|
return Error::success();
|
|
}
|
|
} // namespace
|
|
|
|
namespace llvm::jitlink {
|
|
|
|
class ELFJITLinker_x86 : public JITLinker<ELFJITLinker_x86> {
|
|
friend class JITLinker<ELFJITLinker_x86>;
|
|
|
|
public:
|
|
ELFJITLinker_x86(std::unique_ptr<JITLinkContext> Ctx,
|
|
std::unique_ptr<LinkGraph> G, PassConfiguration PassConfig)
|
|
: JITLinker(std::move(Ctx), std::move(G), std::move(PassConfig)) {
|
|
getPassConfig().PostAllocationPasses.push_back(
|
|
[this](LinkGraph &G) { return getOrCreateGOTSymbol(G); });
|
|
}
|
|
|
|
private:
|
|
Symbol *GOTSymbol = nullptr;
|
|
|
|
Error getOrCreateGOTSymbol(LinkGraph &G) {
|
|
auto DefineExternalGOTSymbolIfPresent =
|
|
createDefineExternalSectionStartAndEndSymbolsPass(
|
|
[&](LinkGraph &LG, Symbol &Sym) -> SectionRangeSymbolDesc {
|
|
if (Sym.getName() != nullptr &&
|
|
*Sym.getName() == ELFGOTSymbolName)
|
|
if (auto *GOTSection = G.findSectionByName(
|
|
x86::GOTTableManager::getSectionName())) {
|
|
GOTSymbol = &Sym;
|
|
return {*GOTSection, true};
|
|
}
|
|
return {};
|
|
});
|
|
|
|
// Try to attach _GLOBAL_OFFSET_TABLE_ to the GOT if it's defined as an
|
|
// external.
|
|
if (auto Err = DefineExternalGOTSymbolIfPresent(G))
|
|
return Err;
|
|
|
|
// If we succeeded then we're done.
|
|
if (GOTSymbol)
|
|
return Error::success();
|
|
|
|
// Otherwise look for a GOT section: If it already has a start symbol we'll
|
|
// record it, otherwise we'll create our own.
|
|
// If there's a GOT section but we didn't find an external GOT symbol...
|
|
if (auto *GOTSection =
|
|
G.findSectionByName(x86::GOTTableManager::getSectionName())) {
|
|
|
|
// Check for an existing defined symbol.
|
|
for (auto *Sym : GOTSection->symbols())
|
|
if (Sym->getName() != nullptr && *Sym->getName() == ELFGOTSymbolName) {
|
|
GOTSymbol = Sym;
|
|
return Error::success();
|
|
}
|
|
|
|
// If there's no defined symbol then create one.
|
|
SectionRange SR(*GOTSection);
|
|
|
|
if (SR.empty()) {
|
|
GOTSymbol =
|
|
&G.addAbsoluteSymbol(ELFGOTSymbolName, orc::ExecutorAddr(), 0,
|
|
Linkage::Strong, Scope::Local, true);
|
|
} else {
|
|
GOTSymbol =
|
|
&G.addDefinedSymbol(*SR.getFirstBlock(), 0, ELFGOTSymbolName, 0,
|
|
Linkage::Strong, Scope::Local, false, true);
|
|
}
|
|
}
|
|
|
|
return Error::success();
|
|
}
|
|
|
|
Error applyFixup(LinkGraph &G, Block &B, const Edge &E) const {
|
|
return x86::applyFixup(G, B, E, GOTSymbol);
|
|
}
|
|
};
|
|
|
|
class ELFLinkGraphBuilder_x86 : public ELFLinkGraphBuilder<object::ELF32LE> {
|
|
private:
|
|
using ELFT = object::ELF32LE;
|
|
|
|
Expected<x86::EdgeKind_x86> getRelocationKind(const uint32_t Type) {
|
|
switch (Type) {
|
|
case ELF::R_386_32:
|
|
return x86::Pointer32;
|
|
case ELF::R_386_PC32:
|
|
return x86::PCRel32;
|
|
case ELF::R_386_16:
|
|
return x86::Pointer16;
|
|
case ELF::R_386_PC16:
|
|
return x86::PCRel16;
|
|
case ELF::R_386_GOT32:
|
|
return x86::RequestGOTAndTransformToDelta32FromGOT;
|
|
case ELF::R_386_GOT32X:
|
|
// TODO: Add a relaxable edge kind and update relaxation optimization.
|
|
return x86::RequestGOTAndTransformToDelta32FromGOT;
|
|
case ELF::R_386_GOTPC:
|
|
return x86::Delta32;
|
|
case ELF::R_386_GOTOFF:
|
|
return x86::Delta32FromGOT;
|
|
case ELF::R_386_PLT32:
|
|
return x86::BranchPCRel32;
|
|
}
|
|
|
|
return make_error<JITLinkError>(
|
|
"In " + G->getName() + ": Unsupported x86 relocation type " +
|
|
object::getELFRelocationTypeName(ELF::EM_386, Type));
|
|
}
|
|
|
|
Error addRelocations() override {
|
|
LLVM_DEBUG(dbgs() << "Adding relocations\n");
|
|
using Base = ELFLinkGraphBuilder<ELFT>;
|
|
using Self = ELFLinkGraphBuilder_x86;
|
|
|
|
for (const auto &RelSect : Base::Sections) {
|
|
// Validate the section to read relocation entries from.
|
|
if (RelSect.sh_type == ELF::SHT_RELA)
|
|
return make_error<StringError>(
|
|
"No SHT_RELA in valid x86 ELF object files",
|
|
inconvertibleErrorCode());
|
|
|
|
if (Error Err = Base::forEachRelRelocation(RelSect, this,
|
|
&Self::addSingleRelocation))
|
|
return Err;
|
|
}
|
|
|
|
return Error::success();
|
|
}
|
|
|
|
Error addSingleRelocation(const typename ELFT::Rel &Rel,
|
|
const typename ELFT::Shdr &FixupSection,
|
|
Block &BlockToFix) {
|
|
using Base = ELFLinkGraphBuilder<ELFT>;
|
|
|
|
auto ELFReloc = Rel.getType(false);
|
|
|
|
// R_386_NONE is a no-op.
|
|
if (LLVM_UNLIKELY(ELFReloc == ELF::R_386_NONE))
|
|
return Error::success();
|
|
|
|
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());
|
|
|
|
Expected<x86::EdgeKind_x86> Kind = getRelocationKind(ELFReloc);
|
|
if (!Kind)
|
|
return Kind.takeError();
|
|
|
|
auto FixupAddress = orc::ExecutorAddr(FixupSection.sh_addr) + Rel.r_offset;
|
|
int64_t Addend = 0;
|
|
|
|
switch (*Kind) {
|
|
case x86::Pointer32:
|
|
case x86::PCRel32:
|
|
case x86::RequestGOTAndTransformToDelta32FromGOT:
|
|
case x86::Delta32:
|
|
case x86::Delta32FromGOT:
|
|
case x86::BranchPCRel32:
|
|
case x86::BranchPCRel32ToPtrJumpStub:
|
|
case x86::BranchPCRel32ToPtrJumpStubBypassable: {
|
|
const char *FixupContent = BlockToFix.getContent().data() +
|
|
(FixupAddress - BlockToFix.getAddress());
|
|
Addend = *(const support::little32_t *)FixupContent;
|
|
break;
|
|
}
|
|
case x86::Pointer16:
|
|
case x86::PCRel16: {
|
|
const char *FixupContent = BlockToFix.getContent().data() +
|
|
(FixupAddress - BlockToFix.getAddress());
|
|
Addend = *(const support::little16_t *)FixupContent;
|
|
break;
|
|
}
|
|
}
|
|
|
|
Edge::OffsetT Offset = FixupAddress - BlockToFix.getAddress();
|
|
Edge GE(*Kind, Offset, *GraphSymbol, Addend);
|
|
LLVM_DEBUG({
|
|
dbgs() << " ";
|
|
printEdge(dbgs(), BlockToFix, GE, x86::getEdgeKindName(*Kind));
|
|
dbgs() << "\n";
|
|
});
|
|
|
|
BlockToFix.addEdge(std::move(GE));
|
|
return Error::success();
|
|
}
|
|
|
|
public:
|
|
ELFLinkGraphBuilder_x86(StringRef FileName, const object::ELFFile<ELFT> &Obj,
|
|
std::shared_ptr<orc::SymbolStringPool> SSP, Triple TT,
|
|
SubtargetFeatures Features)
|
|
: ELFLinkGraphBuilder<ELFT>(Obj, std::move(SSP), std::move(TT),
|
|
std::move(Features), FileName,
|
|
x86::getEdgeKindName) {}
|
|
};
|
|
|
|
Expected<std::unique_ptr<LinkGraph>>
|
|
createLinkGraphFromELFObject_x86(MemoryBufferRef ObjectBuffer,
|
|
std::shared_ptr<orc::SymbolStringPool> SSP) {
|
|
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();
|
|
|
|
assert((*ELFObj)->getArch() == Triple::x86 &&
|
|
"Only x86 (little endian) is supported for now");
|
|
|
|
auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF32LE>>(**ELFObj);
|
|
|
|
return ELFLinkGraphBuilder_x86((*ELFObj)->getFileName(),
|
|
ELFObjFile.getELFFile(), std::move(SSP),
|
|
(*ELFObj)->makeTriple(), std::move(*Features))
|
|
.buildGraph();
|
|
}
|
|
|
|
void link_ELF_x86(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);
|
|
|
|
// Add an in-place GOT and PLT build pass.
|
|
Config.PostPrunePasses.push_back(buildTables_ELF_x86);
|
|
|
|
// Add GOT/Stubs optimizer pass.
|
|
Config.PreFixupPasses.push_back(x86::optimizeGOTAndStubAccesses);
|
|
}
|
|
if (auto Err = Ctx->modifyPassConfig(*G, Config))
|
|
return Ctx->notifyFailed(std::move(Err));
|
|
|
|
ELFJITLinker_x86::link(std::move(Ctx), std::move(G), std::move(Config));
|
|
}
|
|
|
|
} // namespace llvm::jitlink
|