[llvm] 7d3dfc8 - [JITLink][XCOFF] Setup initial build support for XCOFF (#127266)
via llvm-commits
llvm-commits at lists.llvm.org
Thu Apr 3 14:01:22 PDT 2025
Author: Henry Jiang
Date: 2025-04-03T17:01:18-04:00
New Revision: 7d3dfc862d283319d01997c0672c50b4a082aa4e
URL: https://github.com/llvm/llvm-project/commit/7d3dfc862d283319d01997c0672c50b4a082aa4e
DIFF: https://github.com/llvm/llvm-project/commit/7d3dfc862d283319d01997c0672c50b4a082aa4e.diff
LOG: [JITLink][XCOFF] Setup initial build support for XCOFF (#127266)
This patch starts the initial implementation of JITLink for XCOFF (Object format for AIX).
Added:
llvm/include/llvm/ExecutionEngine/JITLink/XCOFF.h
llvm/include/llvm/ExecutionEngine/JITLink/XCOFF_ppc64.h
llvm/lib/ExecutionEngine/JITLink/XCOFF.cpp
llvm/lib/ExecutionEngine/JITLink/XCOFFLinkGraphBuilder.cpp
llvm/lib/ExecutionEngine/JITLink/XCOFFLinkGraphBuilder.h
llvm/lib/ExecutionEngine/JITLink/XCOFF_ppc64.cpp
llvm/test/ExecutionEngine/JITLink/ppc64/XCOFF_ppc64.ll
Modified:
llvm/lib/ExecutionEngine/JITLink/CMakeLists.txt
llvm/lib/ExecutionEngine/JITLink/JITLink.cpp
llvm/lib/ExecutionEngine/Orc/LoadLinkableFile.cpp
llvm/lib/ExecutionEngine/Orc/ObjectFileInterface.cpp
llvm/lib/Object/XCOFFObjectFile.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/ExecutionEngine/JITLink/XCOFF.h b/llvm/include/llvm/ExecutionEngine/JITLink/XCOFF.h
new file mode 100644
index 0000000000000..3d181d0786eb7
--- /dev/null
+++ b/llvm/include/llvm/ExecutionEngine/JITLink/XCOFF.h
@@ -0,0 +1,37 @@
+//===------- XCOFF.h - Generic JIT link function for XCOFF ------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// jit-link functions for XCOFF.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_JITLINK_XCOFF_H
+#define LLVM_EXECUTIONENGINE_JITLINK_XCOFF_H
+
+#include "llvm/ExecutionEngine/JITLink/JITLink.h"
+
+namespace llvm {
+namespace jitlink {
+
+/// Create a LinkGraph from an XCOFF relocatable object.
+///
+/// Note: The graph does not take ownership of the underlying buffer, nor copy
+/// its contents. The caller is responsible for ensuring that the object buffer
+/// outlives the graph.
+Expected<std::unique_ptr<LinkGraph>>
+createLinkGraphFromXCOFFObject(MemoryBufferRef ObjectBuffer,
+ std::shared_ptr<orc::SymbolStringPool> SSP);
+
+/// Link the given graph.
+void link_XCOFF(std::unique_ptr<LinkGraph> G,
+ std::unique_ptr<JITLinkContext> Ctx);
+
+} // namespace jitlink
+} // namespace llvm
+
+#endif // LLVM_EXECUTIONENGINE_JITLINK_XCOFF_H
diff --git a/llvm/include/llvm/ExecutionEngine/JITLink/XCOFF_ppc64.h b/llvm/include/llvm/ExecutionEngine/JITLink/XCOFF_ppc64.h
new file mode 100644
index 0000000000000..ec5c8a37bda27
--- /dev/null
+++ b/llvm/include/llvm/ExecutionEngine/JITLink/XCOFF_ppc64.h
@@ -0,0 +1,37 @@
+//===------ XCOFF_ppc64.h - JIT link functions for XCOFF/ppc64 ------*- C++
+//-*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// jit-link functions for XCOFF/ppc64.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_JITLINK_XCOFF_PPC64_H
+#define LLVM_EXECUTIONENGINE_JITLINK_XCOFF_PPC64_H
+
+#include "llvm/ExecutionEngine/JITLink/JITLink.h"
+
+namespace llvm::jitlink {
+
+/// Create a LinkGraph from an XCOFF/ppc64 relocatable object.
+///
+/// Note: The graph does not take ownership of the underlying buffer, nor copy
+/// its contents. The caller is responsible for ensuring that the object buffer
+/// outlives the graph.
+///
+Expected<std::unique_ptr<LinkGraph>> createLinkGraphFromXCOFFObject_ppc64(
+ MemoryBufferRef ObjectBuffer, std::shared_ptr<orc::SymbolStringPool> SSP);
+
+/// jit-link the given object buffer, which must be a XCOFF ppc64 object file.
+///
+void link_XCOFF_ppc64(std::unique_ptr<LinkGraph> G,
+ std::unique_ptr<JITLinkContext> Ctx);
+
+} // end namespace llvm::jitlink
+
+#endif // LLVM_EXECUTIONENGINE_JITLINK_XCOFF_PPC64_H
diff --git a/llvm/lib/ExecutionEngine/JITLink/CMakeLists.txt b/llvm/lib/ExecutionEngine/JITLink/CMakeLists.txt
index 65dd0c7468ae1..22e4513e1374c 100644
--- a/llvm/lib/ExecutionEngine/JITLink/CMakeLists.txt
+++ b/llvm/lib/ExecutionEngine/JITLink/CMakeLists.txt
@@ -35,6 +35,11 @@ add_llvm_component_library(LLVMJITLink
COFFLinkGraphBuilder.cpp
COFF_x86_64.cpp
+ # XCOFF
+ XCOFF.cpp
+ XCOFF_ppc64.cpp
+ XCOFFLinkGraphBuilder.cpp
+
# Architectures:
aarch32.cpp
aarch64.cpp
diff --git a/llvm/lib/ExecutionEngine/JITLink/JITLink.cpp b/llvm/lib/ExecutionEngine/JITLink/JITLink.cpp
index e8ce9b2b9527d..15a8fcf312ade 100644
--- a/llvm/lib/ExecutionEngine/JITLink/JITLink.cpp
+++ b/llvm/lib/ExecutionEngine/JITLink/JITLink.cpp
@@ -13,6 +13,7 @@
#include "llvm/ExecutionEngine/JITLink/COFF.h"
#include "llvm/ExecutionEngine/JITLink/ELF.h"
#include "llvm/ExecutionEngine/JITLink/MachO.h"
+#include "llvm/ExecutionEngine/JITLink/XCOFF.h"
#include "llvm/ExecutionEngine/JITLink/aarch64.h"
#include "llvm/ExecutionEngine/JITLink/i386.h"
#include "llvm/ExecutionEngine/JITLink/loongarch.h"
@@ -501,6 +502,8 @@ createLinkGraphFromObject(MemoryBufferRef ObjectBuffer,
return createLinkGraphFromELFObject(ObjectBuffer, std::move(SSP));
case file_magic::coff_object:
return createLinkGraphFromCOFFObject(ObjectBuffer, std::move(SSP));
+ case file_magic::xcoff_object_64:
+ return createLinkGraphFromXCOFFObject(ObjectBuffer, std::move(SSP));
default:
return make_error<JITLinkError>("Unsupported file format");
};
@@ -532,6 +535,8 @@ void link(std::unique_ptr<LinkGraph> G, std::unique_ptr<JITLinkContext> Ctx) {
return link_ELF(std::move(G), std::move(Ctx));
case Triple::COFF:
return link_COFF(std::move(G), std::move(Ctx));
+ case Triple::XCOFF:
+ return link_XCOFF(std::move(G), std::move(Ctx));
default:
Ctx->notifyFailed(make_error<JITLinkError>("Unsupported object format"));
};
diff --git a/llvm/lib/ExecutionEngine/JITLink/XCOFF.cpp b/llvm/lib/ExecutionEngine/JITLink/XCOFF.cpp
new file mode 100644
index 0000000000000..cb026538632a9
--- /dev/null
+++ b/llvm/lib/ExecutionEngine/JITLink/XCOFF.cpp
@@ -0,0 +1,43 @@
+//===-------------- XCOFF.cpp - JIT linker function for XCOFF -------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// XCOFF jit-link function.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ExecutionEngine/JITLink/XCOFF.h"
+#include "llvm/ExecutionEngine/JITLink/XCOFF_ppc64.h"
+#include "llvm/Object/XCOFFObjectFile.h"
+
+using namespace llvm;
+
+#define DEBUG_TYPE "jitlink"
+
+namespace llvm {
+namespace jitlink {
+
+Expected<std::unique_ptr<LinkGraph>>
+createLinkGraphFromXCOFFObject(MemoryBufferRef ObjectBuffer,
+ std::shared_ptr<orc::SymbolStringPool> SSP) {
+ // Check magic
+ file_magic Magic = identify_magic(ObjectBuffer.getBuffer());
+ if (Magic != file_magic::xcoff_object_64)
+ return make_error<JITLinkError>("Invalid XCOFF 64 Header");
+
+ // TODO: See if we need to add more checks
+ //
+ return createLinkGraphFromXCOFFObject_ppc64(ObjectBuffer, std::move(SSP));
+}
+
+void link_XCOFF(std::unique_ptr<LinkGraph> G,
+ std::unique_ptr<JITLinkContext> Ctx) {
+ link_XCOFF_ppc64(std::move(G), std::move(Ctx));
+}
+
+} // namespace jitlink
+} // namespace llvm
diff --git a/llvm/lib/ExecutionEngine/JITLink/XCOFFLinkGraphBuilder.cpp b/llvm/lib/ExecutionEngine/JITLink/XCOFFLinkGraphBuilder.cpp
new file mode 100644
index 0000000000000..b871ecfb4f0d8
--- /dev/null
+++ b/llvm/lib/ExecutionEngine/JITLink/XCOFFLinkGraphBuilder.cpp
@@ -0,0 +1,415 @@
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Generic XCOFF LinkGraph building code.
+//
+//===----------------------------------------------------------------------===//
+
+#include "XCOFFLinkGraphBuilder.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/BinaryFormat/XCOFF.h"
+#include "llvm/ExecutionEngine/JITLink/JITLink.h"
+#include "llvm/ExecutionEngine/JITLink/ppc64.h"
+#include "llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h"
+#include "llvm/ExecutionEngine/Orc/Shared/MemoryFlags.h"
+#include "llvm/Object/ObjectFile.h"
+#include "llvm/Object/XCOFFObjectFile.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/Format.h"
+#include "llvm/Support/raw_ostream.h"
+#include <memory>
+
+using namespace llvm;
+
+#define DEBUG_TYPE "jitlink"
+
+namespace llvm {
+namespace jitlink {
+
+XCOFFLinkGraphBuilder::XCOFFLinkGraphBuilder(
+ const object::XCOFFObjectFile &Obj,
+ std::shared_ptr<orc::SymbolStringPool> SSP, Triple TT,
+ SubtargetFeatures Features,
+ LinkGraph::GetEdgeKindNameFunction GetEdgeKindName)
+ : Obj(Obj),
+ G(std::make_unique<LinkGraph>(
+ std::string(Obj.getFileName()), std::move(SSP), std::move(TT),
+ std::move(Features), std::move(GetEdgeKindName))) {}
+
+static llvm::StringRef getStorageClassString(XCOFF::StorageClass SC) {
+ switch (SC) {
+ case XCOFF::StorageClass::C_FILE:
+ return "C_FILE (File name)";
+ case XCOFF::StorageClass::C_BINCL:
+ return "C_BINCL (Beginning of include file)";
+ case XCOFF::StorageClass::C_EINCL:
+ return "C_EINCL (Ending of include file)";
+ case XCOFF::StorageClass::C_GSYM:
+ return "C_GSYM (Global variable)";
+ case XCOFF::StorageClass::C_STSYM:
+ return "C_STSYM (Statically allocated symbol)";
+ case XCOFF::StorageClass::C_BCOMM:
+ return "C_BCOMM (Beginning of common block)";
+ case XCOFF::StorageClass::C_ECOMM:
+ return "C_ECOMM (End of common block)";
+ case XCOFF::StorageClass::C_ENTRY:
+ return "C_ENTRY (Alternate entry)";
+ case XCOFF::StorageClass::C_BSTAT:
+ return "C_BSTAT (Beginning of static block)";
+ case XCOFF::StorageClass::C_ESTAT:
+ return "C_ESTAT (End of static block)";
+ case XCOFF::StorageClass::C_GTLS:
+ return "C_GTLS (Global thread-local variable)";
+ case XCOFF::StorageClass::C_STTLS:
+ return "C_STTLS (Static thread-local variable)";
+ case XCOFF::StorageClass::C_DWARF:
+ return "C_DWARF (DWARF section symbol)";
+ case XCOFF::StorageClass::C_LSYM:
+ return "C_LSYM (Automatic variable allocated on stack)";
+ case XCOFF::StorageClass::C_PSYM:
+ return "C_PSYM (Argument to subroutine allocated on stack)";
+ case XCOFF::StorageClass::C_RSYM:
+ return "C_RSYM (Register variable)";
+ case XCOFF::StorageClass::C_RPSYM:
+ return "C_RPSYM (Argument to function stored in register)";
+ case XCOFF::StorageClass::C_ECOML:
+ return "C_ECOML (Local member of common block)";
+ case XCOFF::StorageClass::C_FUN:
+ return "C_FUN (Function or procedure)";
+ case XCOFF::StorageClass::C_EXT:
+ return "C_EXT (External symbol)";
+ case XCOFF::StorageClass::C_WEAKEXT:
+ return "C_WEAKEXT (Weak external symbol)";
+ case XCOFF::StorageClass::C_NULL:
+ return "C_NULL";
+ case XCOFF::StorageClass::C_STAT:
+ return "C_STAT (Static)";
+ case XCOFF::StorageClass::C_BLOCK:
+ return "C_BLOCK (\".bb\" or \".eb\")";
+ case XCOFF::StorageClass::C_FCN:
+ return "C_FCN (\".bf\" or \".ef\")";
+ case XCOFF::StorageClass::C_HIDEXT:
+ return "C_HIDEXT (Un-named external symbol)";
+ case XCOFF::StorageClass::C_INFO:
+ return "C_INFO (Comment string in .info section)";
+ case XCOFF::StorageClass::C_DECL:
+ return "C_DECL (Declaration of object)";
+ case XCOFF::StorageClass::C_AUTO:
+ return "C_AUTO (Automatic variable)";
+ case XCOFF::StorageClass::C_REG:
+ return "C_REG (Register variable)";
+ case XCOFF::StorageClass::C_EXTDEF:
+ return "C_EXTDEF (External definition)";
+ case XCOFF::StorageClass::C_LABEL:
+ return "C_LABEL (Label)";
+ case XCOFF::StorageClass::C_ULABEL:
+ return "C_ULABEL (Undefined label)";
+ case XCOFF::StorageClass::C_MOS:
+ return "C_MOS (Member of structure)";
+ case XCOFF::StorageClass::C_ARG:
+ return "C_ARG (Function argument)";
+ case XCOFF::StorageClass::C_STRTAG:
+ return "C_STRTAG (Structure tag)";
+ case XCOFF::StorageClass::C_MOU:
+ return "C_MOU (Member of union)";
+ case XCOFF::StorageClass::C_UNTAG:
+ return "C_UNTAG (Union tag)";
+ case XCOFF::StorageClass::C_TPDEF:
+ return "C_TPDEF (Type definition)";
+ case XCOFF::StorageClass::C_USTATIC:
+ return "C_USTATIC (Undefined static)";
+ case XCOFF::StorageClass::C_ENTAG:
+ return "C_ENTAG (Enumeration tag)";
+ case XCOFF::StorageClass::C_MOE:
+ return "C_MOE (Member of enumeration)";
+ case XCOFF::StorageClass::C_REGPARM:
+ return "C_REGPARM (Register parameter)";
+ case XCOFF::StorageClass::C_FIELD:
+ return "C_FIELD (Bit field)";
+ case XCOFF::StorageClass::C_EOS:
+ return "C_EOS (End of structure)";
+ case XCOFF::StorageClass::C_LINE:
+ return "C_LINE";
+ case XCOFF::StorageClass::C_ALIAS:
+ return "C_ALIAS (Duplicate tag)";
+ case XCOFF::StorageClass::C_HIDDEN:
+ return "C_HIDDEN (Special storage class for external)";
+ case XCOFF::StorageClass::C_EFCN:
+ return "C_EFCN (Physical end of function)";
+ case XCOFF::StorageClass::C_TCSYM:
+ return "C_TCSYM (Reserved)";
+ }
+}
+
+Error XCOFFLinkGraphBuilder::processSections() {
+ LLVM_DEBUG(dbgs() << " Creating graph sections...\n");
+
+ UndefSection = &G->createSection("*UND*", orc::MemProt::None);
+
+ for (object::SectionRef Section : Obj.sections()) {
+ auto SectionName = Section.getName();
+ if (!SectionName)
+ return SectionName.takeError();
+
+ LLVM_DEBUG({
+ dbgs() << " section = " << *SectionName
+ << ", idx = " << Section.getIndex()
+ << ", size = " << format_hex_no_prefix(Section.getSize(), 8)
+ << ", vma = " << format_hex(Section.getAddress(), 16) << "\n";
+ });
+
+ // We can skip debug (including dawrf) and pad sections
+ if (Section.isDebugSection() || *SectionName == "pad")
+ continue;
+ LLVM_DEBUG(dbgs() << " creating graph section\n");
+
+ orc::MemProt Prot = orc::MemProt::Read;
+ if (Section.isText())
+ Prot |= orc::MemProt::Exec;
+ if (Section.isData() || Section.isBSS())
+ Prot |= orc::MemProt::Write;
+
+ jitlink::Section *GraphSec = &G->createSection(*SectionName, Prot);
+ // TODO: Check for no_alloc for certain sections
+
+ assert(!SectionTable.contains(Section.getIndex()) &&
+ "Section with same index already exists");
+ SectionTable[Section.getIndex()] = {GraphSec, Section};
+ }
+
+ return Error::success();
+}
+
+static std::optional<object::XCOFFSymbolRef>
+getXCOFFSymbolContainingSymbolRef(const object::XCOFFObjectFile &Obj,
+ const object::SymbolRef &Sym) {
+ const object::XCOFFSymbolRef SymRef =
+ Obj.toSymbolRef(Sym.getRawDataRefImpl());
+ if (!SymRef.isCsectSymbol())
+ return std::nullopt;
+
+ Expected<object::XCOFFCsectAuxRef> CsectAuxEntOrErr =
+ SymRef.getXCOFFCsectAuxRef();
+ if (!CsectAuxEntOrErr || !CsectAuxEntOrErr.get().isLabel())
+ return std::nullopt;
+ uint32_t Idx =
+ static_cast<uint32_t>(CsectAuxEntOrErr.get().getSectionOrLength());
+ object::DataRefImpl DRI;
+ DRI.p = Obj.getSymbolByIndex(Idx);
+ return object::XCOFFSymbolRef(DRI, &Obj);
+}
+
+static void printSymbolEntry(raw_ostream &OS,
+ const object::XCOFFObjectFile &Obj,
+ const object::XCOFFSymbolRef &Sym) {
+ OS << " " << format_hex(cantFail(Sym.getAddress()), 16);
+ OS << " " << left_justify(cantFail(Sym.getName()), 10);
+ if (Sym.isCsectSymbol()) {
+ auto CsectAuxEntry = cantFail(Sym.getXCOFFCsectAuxRef());
+ if (!CsectAuxEntry.isLabel()) {
+ std::string MCStr =
+ "[" +
+ XCOFF::getMappingClassString(CsectAuxEntry.getStorageMappingClass())
+ .str() +
+ "]";
+ OS << left_justify(MCStr, 3);
+ }
+ }
+ OS << " " << format_hex(Sym.getSize(), 8);
+ OS << " " << Sym.getSectionNumber();
+ OS << " " << getStorageClassString(Sym.getStorageClass());
+ OS << " (idx: " << Obj.getSymbolIndex(Sym.getRawDataRefImpl().p) << ")";
+ if (Sym.isCsectSymbol()) {
+ if (auto ParentSym = getXCOFFSymbolContainingSymbolRef(Obj, Sym)) {
+ OS << " (csect idx: "
+ << Obj.getSymbolIndex(ParentSym->getRawDataRefImpl().p) << ")";
+ }
+ }
+ OS << "\n";
+}
+
+Error XCOFFLinkGraphBuilder::processCsectsAndSymbols() {
+ LLVM_DEBUG(dbgs() << " Creating graph blocks and symbols...\n");
+
+ for (auto [K, V] : SectionTable) {
+ LLVM_DEBUG(dbgs() << " section entry(idx: " << K
+ << " section: " << V.Section->getName() << ")\n");
+ }
+
+ for (object::XCOFFSymbolRef Symbol : Obj.symbols()) {
+ LLVM_DEBUG({ printSymbolEntry(dbgs(), Obj, Symbol); });
+
+ auto Flags = Symbol.getFlags();
+ if (!Flags)
+ return Flags.takeError();
+
+ bool External = *Flags & object::SymbolRef::SF_Undefined;
+ bool Weak = *Flags & object::SymbolRef::SF_Weak;
+ bool Global = *Flags & object::SymbolRef::SF_Global;
+
+ auto SymbolIndex = Obj.getSymbolIndex(Symbol.getEntryAddress());
+ auto SymbolName = Symbol.getName();
+ if (!SymbolName)
+ return SymbolName.takeError();
+
+ if (External) {
+ LLVM_DEBUG(dbgs() << " created external symbol\n");
+ SymbolIndexTable[SymbolIndex] =
+ &G->addExternalSymbol(*SymbolName, Symbol.getSize(), Weak);
+ continue;
+ }
+
+ if (!Symbol.isCsectSymbol()) {
+ LLVM_DEBUG(dbgs() << " skipped: not a csect symbol\n");
+ continue;
+ }
+
+ auto ParentSym = getXCOFFSymbolContainingSymbolRef(Obj, Symbol);
+ object::XCOFFSymbolRef CsectSymbol = ParentSym ? *ParentSym : Symbol;
+
+ auto CsectSymbolIndex = Obj.getSymbolIndex(CsectSymbol.getEntryAddress());
+ auto ParentSectionNumber = CsectSymbol.getSectionNumber();
+
+ bool IsUndefinedSection = !SectionTable.contains(ParentSectionNumber);
+ Section *ParentSection = !IsUndefinedSection
+ ? SectionTable[ParentSectionNumber].Section
+ : UndefSection;
+ Block *B = nullptr;
+
+ // TODO: Clean up the logic for handling undefined symbols
+ if (!CsectTable.contains(CsectSymbolIndex) && !IsUndefinedSection) {
+ object::SectionRef &SectionRef =
+ SectionTable[ParentSectionNumber].SectionData;
+ auto Data = SectionRef.getContents();
+ if (!Data)
+ return Data.takeError();
+ auto CsectSymbolAddr = CsectSymbol.getAddress();
+ if (!CsectSymbolAddr)
+ return CsectSymbolAddr.takeError();
+
+ ArrayRef<char> SectionBuffer{Data->data(), Data->size()};
+ auto Offset = *CsectSymbolAddr - SectionRef.getAddress();
+
+ LLVM_DEBUG(dbgs() << " symbol entry: offset = " << Offset
+ << ", size = " << CsectSymbol.getSize()
+ << ", storage class = "
+ << getStorageClassString(CsectSymbol.getStorageClass())
+ << "\n");
+
+ B = &G->createContentBlock(
+ *ParentSection, SectionBuffer.slice(Offset, CsectSymbol.getSize()),
+ orc::ExecutorAddr(*CsectSymbolAddr), CsectSymbol.getAlignment(), 0);
+
+ CsectTable[CsectSymbolIndex] = B;
+ } else {
+ B = CsectTable[CsectSymbolIndex];
+ }
+
+ Scope S{Scope::Local};
+ if (Symbol.getSymbolType() & XCOFF::SYM_V_HIDDEN ||
+ Symbol.getSymbolType() & XCOFF::SYM_V_INTERNAL)
+ S = Scope::Hidden;
+ else if (Global)
+ S = Scope::Default;
+ // TODO: map all symbols for c++ static initialization to SideEffectOnly
+
+ Linkage L = Weak ? Linkage::Weak : Linkage::Strong;
+ auto SymbolAddr = Symbol.getAddress();
+ if (!SymbolAddr)
+ return SymbolAddr.takeError();
+ auto IsCallableOrErr = Symbol.isFunction();
+ if (!IsCallableOrErr)
+ return IsCallableOrErr.takeError();
+
+ auto BlockOffset = *SymbolAddr - B->getAddress().getValue();
+
+ LLVM_DEBUG(dbgs() << " creating with linkage = " << getLinkageName(L)
+ << ", scope = " << getScopeName(S) << ", B = "
+ << format_hex(B->getAddress().getValue(), 16) << "\n");
+
+ SymbolIndexTable[SymbolIndex] =
+ &G->addDefinedSymbol(*B, BlockOffset, *SymbolName, Symbol.getSize(), L,
+ S, *IsCallableOrErr, true);
+ }
+
+ return Error::success();
+}
+
+Error XCOFFLinkGraphBuilder::processRelocations() {
+ LLVM_DEBUG(dbgs() << " Creating relocations...\n");
+
+ for (object::SectionRef Section : Obj.sections()) {
+ auto SectionName = Section.getName();
+ if (!SectionName)
+ return SectionName.takeError();
+
+ LLVM_DEBUG(dbgs() << " Relocations for section " << *SectionName
+ << ":\n");
+
+ for (object::RelocationRef Relocation : Section.relocations()) {
+ SmallString<16> RelocName;
+ Relocation.getTypeName(RelocName);
+ object::SymbolRef Symbol = *Relocation.getSymbol();
+
+ auto TargetSymbol = Symbol.getName();
+ if (!TargetSymbol)
+ return TargetSymbol.takeError();
+
+ auto SymbolIndex = Obj.getSymbolIndex(Symbol.getRawDataRefImpl().p);
+
+ LLVM_DEBUG(dbgs() << " " << format_hex(Relocation.getOffset(), 16)
+ << " (idx: " << SymbolIndex << ")"
+ << " " << RelocName << " " << *TargetSymbol << "\n";);
+
+ assert(SymbolIndexTable.contains(SymbolIndex) &&
+ "Relocation needs a record in the symbol table");
+ auto *S = SymbolIndexTable[SymbolIndex];
+ auto It = find_if(G->blocks(),
+ [Target = orc::ExecutorAddr(Section.getAddress() +
+ Relocation.getOffset())](
+ const Block *B) -> bool {
+ return B->getRange().contains(Target);
+ });
+ assert(It != G->blocks().end() &&
+ "Cannot find the target relocation block");
+ Block *B = *It;
+
+ auto TargetBlockOffset = Section.getAddress() + Relocation.getOffset() -
+ B->getAddress().getValue();
+ switch (Relocation.getType()) {
+ case XCOFF::R_POS:
+ B->addEdge(ppc64::EdgeKind_ppc64::Pointer64, TargetBlockOffset, *S, 0);
+ break;
+ default:
+ SmallString<16> RelocType;
+ Relocation.getTypeName(RelocType);
+ return make_error<StringError>(
+ "Unsupported Relocation Type: " + RelocType, std::error_code());
+ }
+ }
+ }
+
+ return Error::success();
+}
+
+Expected<std::unique_ptr<LinkGraph>> XCOFFLinkGraphBuilder::buildGraph() {
+ LLVM_DEBUG(dbgs() << "Building XCOFFLinkGraph...\n");
+
+ // FIXME: Check to make sure the object is relocatable
+
+ if (auto Err = processSections())
+ return Err;
+ if (auto Err = processCsectsAndSymbols())
+ return Err;
+ if (auto Err = processRelocations())
+ return Err;
+
+ return std::move(G);
+}
+
+} // namespace jitlink
+} // namespace llvm
diff --git a/llvm/lib/ExecutionEngine/JITLink/XCOFFLinkGraphBuilder.h b/llvm/lib/ExecutionEngine/JITLink/XCOFFLinkGraphBuilder.h
new file mode 100644
index 0000000000000..c6481170637c2
--- /dev/null
+++ b/llvm/lib/ExecutionEngine/JITLink/XCOFFLinkGraphBuilder.h
@@ -0,0 +1,63 @@
+//===----- XCOFFLinkGraphBuilder.h - XCOFF LinkGraph builder ----*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Generic XCOFF LinkGraph building code.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LIB_EXECUTIONENGINE_JITLINK_XCOFFLINKGRAPHBUILDER_H
+#define LIB_EXECUTIONENGINE_JITLINK_XCOFFLINKGRAPHBUILDER_H
+
+#include "llvm/ExecutionEngine/JITLink/JITLink.h"
+#include "llvm/ExecutionEngine/Orc/SymbolStringPool.h"
+#include "llvm/Object/ObjectFile.h"
+#include "llvm/Object/XCOFFObjectFile.h"
+#include "llvm/TargetParser/SubtargetFeature.h"
+#include <memory>
+
+namespace llvm {
+namespace jitlink {
+
+class XCOFFLinkGraphBuilder {
+public:
+ virtual ~XCOFFLinkGraphBuilder() = default;
+ Expected<std::unique_ptr<LinkGraph>> buildGraph();
+
+public:
+ XCOFFLinkGraphBuilder(const object::XCOFFObjectFile &Obj,
+ std::shared_ptr<orc::SymbolStringPool> SSP, Triple TT,
+ SubtargetFeatures Features,
+ LinkGraph::GetEdgeKindNameFunction GetEdgeKindName);
+ LinkGraph &getGraph() const { return *G; }
+ const object::XCOFFObjectFile &getObject() const { return Obj; }
+
+private:
+ Error processSections();
+ Error processCsectsAndSymbols();
+ Error processRelocations();
+
+private:
+ const object::XCOFFObjectFile &Obj;
+ std::unique_ptr<LinkGraph> G;
+
+ Section *UndefSection;
+
+ struct SectionEntry {
+ jitlink::Section *Section;
+ object::SectionRef SectionData;
+ };
+
+ DenseMap<uint16_t, SectionEntry> SectionTable;
+ DenseMap<uint32_t, Block *> CsectTable;
+ DenseMap<uint32_t, Symbol *> SymbolIndexTable;
+};
+
+} // namespace jitlink
+} // namespace llvm
+
+#endif // LIB_EXECUTIONENGINE_JITLINK_XCOFFLINKGRAPHBUILDER_H
diff --git a/llvm/lib/ExecutionEngine/JITLink/XCOFF_ppc64.cpp b/llvm/lib/ExecutionEngine/JITLink/XCOFF_ppc64.cpp
new file mode 100644
index 0000000000000..fd6b5f61749b5
--- /dev/null
+++ b/llvm/lib/ExecutionEngine/JITLink/XCOFF_ppc64.cpp
@@ -0,0 +1,121 @@
+//===------- XCOFF_ppc64.cpp -JIT linker implementation for XCOFF/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
+//
+//===----------------------------------------------------------------------===//
+//
+// XCOFF/ppc64 jit-link implementation.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ExecutionEngine/JITLink/XCOFF_ppc64.h"
+#include "JITLinkGeneric.h"
+#include "XCOFFLinkGraphBuilder.h"
+#include "llvm/ADT/bit.h"
+#include "llvm/ExecutionEngine/JITLink/JITLink.h"
+#include "llvm/ExecutionEngine/JITLink/ppc64.h"
+#include "llvm/Object/ObjectFile.h"
+#include "llvm/Object/XCOFFObjectFile.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/ErrorHandling.h"
+#include <system_error>
+
+using namespace llvm;
+
+#define DEBUG_TYPE "jitlink"
+
+namespace llvm {
+namespace jitlink {
+
+Expected<std::unique_ptr<LinkGraph>> createLinkGraphFromXCOFFObject_ppc64(
+ MemoryBufferRef ObjectBuffer, std::shared_ptr<orc::SymbolStringPool> SSP) {
+ LLVM_DEBUG({
+ dbgs() << "Building jitlink graph for new input "
+ << ObjectBuffer.getBufferIdentifier() << "...\n";
+ });
+
+ auto Obj = object::ObjectFile::createObjectFile(ObjectBuffer);
+ if (!Obj)
+ return Obj.takeError();
+ assert((**Obj).isXCOFF() && "Expects and XCOFF Object");
+
+ auto Features = (*Obj)->getFeatures();
+ if (!Features)
+ return Features.takeError();
+ LLVM_DEBUG({
+ dbgs() << " Features: ";
+ (*Features).print(dbgs());
+ });
+
+ return XCOFFLinkGraphBuilder(cast<object::XCOFFObjectFile>(**Obj),
+ std::move(SSP), Triple("powerpc64-ibm-aix"),
+ std::move(*Features), ppc64::getEdgeKindName)
+ .buildGraph();
+}
+
+class XCOFFJITLinker_ppc64 : public JITLinker<XCOFFJITLinker_ppc64> {
+ using JITLinkerBase = JITLinker<XCOFFJITLinker_ppc64>;
+ friend JITLinkerBase;
+
+public:
+ XCOFFJITLinker_ppc64(std::unique_ptr<JITLinkContext> Ctx,
+ std::unique_ptr<LinkGraph> G,
+ PassConfiguration PassConfig)
+ : JITLinkerBase(std::move(Ctx), std::move(G), std::move(PassConfig)) {
+ // FIXME: Post allocation pass define TOC base, this is temporary to support
+ // building until we can build the required toc entries
+ defineTOCSymbol(getGraph());
+ }
+
+ Error applyFixup(LinkGraph &G, Block &B, const Edge &E) const {
+ LLVM_DEBUG(dbgs() << " Applying fixup for " << G.getName()
+ << ", address = " << B.getAddress()
+ << ", target = " << E.getTarget().getName() << ", kind = "
+ << ppc64::getEdgeKindName(E.getKind()) << "\n");
+ switch (E.getKind()) {
+ case ppc64::Pointer64:
+ if (auto Err = ppc64::applyFixup<endianness::big>(G, B, E, TOCSymbol))
+ return Err;
+ break;
+ default:
+ return make_error<StringError>("Unsupported relocation type",
+ std::error_code());
+ }
+ return Error::success();
+ }
+
+private:
+ void defineTOCSymbol(LinkGraph &G) {
+ for (Symbol *S : G.defined_symbols()) {
+ if (S->hasName() && *S->getName() == StringRef("TOC")) {
+ TOCSymbol = S;
+ return;
+ }
+ }
+ llvm_unreachable("LinkGraph does not contan an TOC Symbol");
+ }
+
+private:
+ Symbol *TOCSymbol = nullptr;
+};
+
+void link_XCOFF_ppc64(std::unique_ptr<LinkGraph> G,
+ std::unique_ptr<JITLinkContext> Ctx) {
+ // Ctx->notifyFailed(make_error<StringError>(
+ // "link_XCOFF_ppc64 is not implemented", std::error_code()));
+
+ PassConfiguration Config;
+
+ // Pass insertions
+
+ if (auto Err = Ctx->modifyPassConfig(*G, Config))
+ return Ctx->notifyFailed(std::move(Err));
+
+ XCOFFJITLinker_ppc64::link(std::move(Ctx), std::move(G), std::move(Config));
+}
+
+} // namespace jitlink
+} // namespace llvm
diff --git a/llvm/lib/ExecutionEngine/Orc/LoadLinkableFile.cpp b/llvm/lib/ExecutionEngine/Orc/LoadLinkableFile.cpp
index 77ae7c7ca2e0e..4f01c01da4b9f 100644
--- a/llvm/lib/ExecutionEngine/Orc/LoadLinkableFile.cpp
+++ b/llvm/lib/ExecutionEngine/Orc/LoadLinkableFile.cpp
@@ -25,6 +25,13 @@ checkCOFFRelocatableObject(std::unique_ptr<MemoryBuffer> Obj,
return std::move(Obj);
}
+static Expected<std::unique_ptr<MemoryBuffer>>
+checkXCOFFRelocatableObject(std::unique_ptr<MemoryBuffer> Obj,
+ const Triple &TT) {
+ // TODO: Actually check the architecture of the file.
+ return std::move(Obj);
+}
+
static Expected<std::unique_ptr<MemoryBuffer>>
checkELFRelocatableObject(std::unique_ptr<MemoryBuffer> Obj, const Triple &TT) {
// TODO: Actually check the architecture of the file.
@@ -105,6 +112,15 @@ loadLinkableFile(StringRef Path, const Triple &TT, LoadArchives LA,
return loadLinkableSliceFromMachOUniversalBinary(
FD, std::move(*Buf), TT, LA, Path, *IdentifierOverride);
break;
+ case file_magic::xcoff_object_64:
+ if (!RequireFormat || *RequireFormat == Triple::XCOFF) {
+ auto CheckedBuf = checkXCOFFRelocatableObject(std::move(*Buf), TT);
+ if (!CheckedBuf)
+ return CheckedBuf.takeError();
+ return std::make_pair(std::move(*CheckedBuf),
+ LinkableFileKind::RelocatableObject);
+ }
+ break;
default:
break;
}
diff --git a/llvm/lib/ExecutionEngine/Orc/ObjectFileInterface.cpp b/llvm/lib/ExecutionEngine/Orc/ObjectFileInterface.cpp
index 0b2cafb0bff13..b9cee98d45d77 100644
--- a/llvm/lib/ExecutionEngine/Orc/ObjectFileInterface.cpp
+++ b/llvm/lib/ExecutionEngine/Orc/ObjectFileInterface.cpp
@@ -7,11 +7,13 @@
//===----------------------------------------------------------------------===//
#include "llvm/ExecutionEngine/Orc/ObjectFileInterface.h"
+#include "llvm/ExecutionEngine/JITSymbol.h"
#include "llvm/ExecutionEngine/Orc/Shared/ObjectFormats.h"
#include "llvm/Object/COFF.h"
#include "llvm/Object/ELFObjectFile.h"
#include "llvm/Object/MachO.h"
#include "llvm/Object/ObjectFile.h"
+#include "llvm/Object/XCOFFObjectFile.h"
#include <optional>
#define DEBUG_TYPE "orc"
@@ -227,6 +229,52 @@ getCOFFObjectFileSymbolInfo(ExecutionSession &ES,
return I;
}
+Expected<MaterializationUnit::Interface>
+getXCOFFObjectFileSymbolInfo(ExecutionSession &ES,
+ const object::ObjectFile &Obj) {
+
+ MaterializationUnit::Interface I;
+
+ for (auto &Sym : Obj.symbols()) {
+ Expected<uint32_t> SymFlagsOrErr = Sym.getFlags();
+ if (!SymFlagsOrErr)
+ return SymFlagsOrErr.takeError();
+ uint32_t Flags = *SymFlagsOrErr;
+
+ // Skip undefined, non global and ST_File
+ if (Flags & object::SymbolRef::SF_Undefined)
+ continue;
+ if (!(Flags & object::SymbolRef::SF_Global))
+ continue;
+
+ auto SymbolType = Sym.getType();
+ if (!SymbolType)
+ return SymbolType.takeError();
+
+ if (*SymbolType == object::SymbolRef::ST_File)
+ continue;
+
+ auto Name = Sym.getName();
+ if (!Name)
+ return Name.takeError();
+ auto SymFlags = JITSymbolFlags::fromObjectSymbol(Sym);
+ if (!SymFlags)
+ return SymFlags.takeError();
+
+ // TODO: Revisit symbol visibility
+ // On AIX, symbols with C_EXT and C_WEAKEXT symbols have no specified
+ // visibility are considered to have Default scope for LinkGraph. When the
+ // object is not a DSO, symbol visibility is not specified. In the absence
+ // of an Export List, its reasonable to minimic roughly the behaviour of
+ // -bexpall or CreateExportList.
+ *SymFlags |= JITSymbolFlags::Exported;
+
+ I.SymbolFlags[ES.intern(std::move(*Name))] = std::move(*SymFlags);
+ }
+ // TODO: Find all initialization symbols for c++ static initializers
+ return I;
+}
+
Expected<MaterializationUnit::Interface>
getGenericObjectFileSymbolInfo(ExecutionSession &ES,
const object::ObjectFile &Obj) {
@@ -280,6 +328,8 @@ getObjectFileInterface(ExecutionSession &ES, MemoryBufferRef ObjBuffer) {
return getELFObjectFileSymbolInfo(ES, *ELFObj);
else if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(Obj->get()))
return getCOFFObjectFileSymbolInfo(ES, *COFFObj);
+ else if (auto *XCOFFObj = dyn_cast<object::XCOFFObjectFile>(Obj->get()))
+ return getXCOFFObjectFileSymbolInfo(ES, *XCOFFObj);
return getGenericObjectFileSymbolInfo(ES, **Obj);
}
diff --git a/llvm/lib/Object/XCOFFObjectFile.cpp b/llvm/lib/Object/XCOFFObjectFile.cpp
index df3b2a091aec2..5a246438e2c0e 100644
--- a/llvm/lib/Object/XCOFFObjectFile.cpp
+++ b/llvm/lib/Object/XCOFFObjectFile.cpp
@@ -429,9 +429,13 @@ XCOFFObjectFile::getSectionContents(DataRefImpl Sec) const {
}
uint64_t XCOFFObjectFile::getSectionAlignment(DataRefImpl Sec) const {
- uint64_t Result = 0;
- llvm_unreachable("Not yet implemented!");
- return Result;
+ // TODO: Copied from MC/XCOFFObjectWriter.cpp
+ // Sections other than DWARF section use DefaultSectionAlign as the default
+ // alignment, while DWARF sections have their own alignments. DWARF section
+ // alignment is bigger than DefaultSectionAlign.
+ if (isDebugSection(Sec))
+ return 8;
+ return 4;
}
uint64_t XCOFFObjectFile::getSectionFileOffsetToRawData(DataRefImpl Sec) const {
diff --git a/llvm/test/ExecutionEngine/JITLink/ppc64/XCOFF_ppc64.ll b/llvm/test/ExecutionEngine/JITLink/ppc64/XCOFF_ppc64.ll
new file mode 100644
index 0000000000000..659b0a8959e73
--- /dev/null
+++ b/llvm/test/ExecutionEngine/JITLink/ppc64/XCOFF_ppc64.ll
@@ -0,0 +1,24 @@
+; AIX's support for llvm-mc does not have enough support for directives like .csect
+; so we can't use the tool. llvm-jitlink -check is not available as it requries
+; implementation of registerXCOFFGraphInfo. Will revisit this testcase once support
+; is more complete.
+
+; RUN: mkdir -p %t
+; RUN: llc --filetype=obj -o %t/xcoff_ppc64.o %s
+; RUN: llvm-jitlink -noexec -num-threads=0 -triple=powerpc64-ibm-aix %t/xcoff_ppc64.o
+
+target datalayout = "E-m:a-Fi64-i64:64-i128:128-n32:64-S128-v256:256:256-v512:512:512"
+target triple = "powerpc64-ibm-aix"
+
+define i32 @main() #0 {
+entry:
+ ret i32 0
+}
+
+attributes #0 = { "target-cpu"="pwr7" }
+
+!llvm.module.flags = !{!0, !1}
+
+!0 = !{i32 1, !"wchar_size", i32 4}
+!1 = !{i32 8, !"PIC Level", i32 2}
+
More information about the llvm-commits
mailing list