[llvm] JITLink: Add initial SystemZ Support. (PR #144528)
Ulrich Weigand via llvm-commits
llvm-commits at lists.llvm.org
Thu Oct 30 04:33:13 PDT 2025
================
@@ -0,0 +1,440 @@
+//===----- ELF_systemz.cpp - JIT linker implementation for ELF/systemz ----===//
+//
+// 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/systemz jit-link implementation.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ExecutionEngine/JITLink/DWARFRecordSectionSplitter.h"
+#include "llvm/ExecutionEngine/JITLink/systemz.h"
+#include "llvm/Object/ELFObjectFile.h"
+
+#include "DefineExternalSectionStartAndEndSymbols.h"
+#include "EHFrameSupportImpl.h"
+#include "ELFLinkGraphBuilder.h"
+#include "JITLinkGeneric.h"
+
+#define DEBUG_TYPE "jitlink"
+
+using namespace llvm;
+using namespace llvm::jitlink;
+
+namespace {
+
+constexpr StringRef ELFGOTSymbolName = "_GLOBAL_OFFSET_TABLE_";
+
+Error buildTables_ELF_systemz(LinkGraph &G) {
+ LLVM_DEBUG(dbgs() << "Visiting edges in graph:\n");
+ systemz::GOTTableManager GOT;
+ systemz::PLTTableManager PLT(GOT);
+ visitExistingEdges(G, GOT, PLT);
+ return Error::success();
+}
+
+} // namespace
+
+namespace llvm {
+namespace jitlink {
+class ELFJITLinker_systemz : public JITLinker<ELFJITLinker_systemz> {
+ friend class JITLinker<ELFJITLinker_systemz>;
+
+public:
+ ELFJITLinker_systemz(std::unique_ptr<JITLinkContext> Ctx,
+ std::unique_ptr<LinkGraph> G,
+ PassConfiguration PassConfig)
+ : JITLinker(std::move(Ctx), std::move(G), std::move(PassConfig)) {
+ if (shouldAddDefaultTargetPasses(getGraph().getTargetTriple()))
+ getPassConfig().PostAllocationPasses.push_back(
+ [this](LinkGraph &G) { return getOrCreateGOTSymbol(G); });
+ }
+
+private:
+ Symbol *GOTSymbol = nullptr;
+
+ Error applyFixup(LinkGraph &G, Block &B, const Edge &E) const {
+ return systemz::applyFixup(G, B, E, GOTSymbol);
+ }
+
+ Error getOrCreateGOTSymbol(LinkGraph &G) {
+ auto DefineExternalGOTSymbolIfPresent =
+ createDefineExternalSectionStartAndEndSymbolsPass(
+ [&](LinkGraph &LG, Symbol &Sym) -> SectionRangeSymbolDesc {
+ if (Sym.getName() != nullptr &&
+ *Sym.getName() == ELFGOTSymbolName)
+ if (auto *GOTSection = G.findSectionByName(
+ systemz::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(systemz::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);
+ }
+
+ // If we still haven't found a GOT symbol then double check the externals.
+ // We may have a GOT-relative reference but no GOT section, in which case
+ // we just need to point the GOT symbol at some address in this graph.
+ if (!GOTSymbol) {
+ for (auto *Sym : G.external_symbols()) {
+ if (Sym->getName() != nullptr && *Sym->getName() == ELFGOTSymbolName) {
+ auto Blocks = G.blocks();
+ if (!Blocks.empty()) {
+ G.makeAbsolute(*Sym, (*Blocks.begin())->getAddress());
+ GOTSymbol = Sym;
+ break;
+ }
+ }
+ }
+ }
+
+ return Error::success();
+ }
+};
+
+class ELFLinkGraphBuilder_systemz
+ : public ELFLinkGraphBuilder<object::ELF64BE> {
+private:
+ using ELFT = object::ELF64BE;
+ using Base = ELFLinkGraphBuilder<ELFT>;
+ using Base::G; // Use LinkGraph pointer from base class.
+
+ Error addRelocations() override {
+ LLVM_DEBUG(dbgs() << "Processing relocations:\n");
+
+ using Base = ELFLinkGraphBuilder<ELFT>;
+ using Self = ELFLinkGraphBuilder_systemz;
+ for (const auto &RelSect : Base::Sections) {
+ if (RelSect.sh_type == ELF::SHT_REL)
+ // Validate the section to read relocation entries from.
+ 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 &FixupSect,
+ Block &BlockToFix) {
+ using support::big32_t;
+ using Base = ELFLinkGraphBuilder<ELFT>;
+ auto ELFReloc = Rel.getType(false);
+
+ // No reloc.
+ if (LLVM_UNLIKELY(ELFReloc == ELF::R_390_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());
+
+ // Validate the relocation kind.
+ int64_t Addend = Rel.r_addend;
+ Edge::Kind Kind = Edge::Invalid;
+
+ switch (ELFReloc) {
+ case ELF::R_390_PC64: {
+ Kind = systemz::Delta64;
+ break;
+ }
+ case ELF::R_390_PC32: {
+ Kind = systemz::Delta32;
+ break;
+ }
+ case ELF::R_390_PC16: {
+ Kind = systemz::Delta16;
+ break;
+ }
+ case ELF::R_390_PC32DBL: {
+ Kind = systemz::Delta32dbl;
+ break;
+ }
+ case ELF::R_390_PC24DBL: {
+ Kind = systemz::Delta24dbl;
+ break;
+ }
+ case ELF::R_390_PC16DBL: {
+ Kind = systemz::Delta16dbl;
+ break;
+ }
+ case ELF::R_390_PC12DBL: {
+ Kind = systemz::Delta12dbl;
+ break;
+ }
+ case ELF::R_390_64: {
+ Kind = systemz::Pointer64;
+ break;
+ }
+ case ELF::R_390_32: {
+ Kind = systemz::Pointer32;
+ break;
+ }
+ case ELF::R_390_20: {
+ Kind = systemz::Pointer20;
+ break;
+ }
+ case ELF::R_390_16: {
+ Kind = systemz::Pointer16;
+ break;
+ }
+ case ELF::R_390_12: {
+ Kind = systemz::Pointer12;
+ break;
+ }
+ case ELF::R_390_8: {
+ Kind = systemz::Pointer8;
+ break;
+ }
+ // Relocations targeting the PLT associated with the symbol.
+ case ELF::R_390_PLT64: {
+ Kind = systemz::BranchPCRelPLT64;
----------------
uweigand wrote:
The whole `BranchPCRel...` naming convention is x86-specific, and there it makes sense because they actually do treat branch relocations differently (with that extra 4 byte offset). We don't have that at all - this is just a regular PC-relative relocation, which we elsewhere just call `Delta...`. So I think this kind should simply be named `DeltaPLT64`. Likewise for the other `BranchPCRelPLT` kinds.
https://github.com/llvm/llvm-project/pull/144528
More information about the llvm-commits
mailing list