[llvm] [JITLink][XCOFF] Setup initial build support for XCOFF (PR #127266)
via llvm-commits
llvm-commits at lists.llvm.org
Mon Feb 24 21:01:36 PST 2025
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-llvm-binary-utilities
Author: Henry Jiang (mustartt)
<details>
<summary>Changes</summary>
This patch starts the initial implementation of JITLink for XCOFF (Object format for AIX).
---
Patch is 34.86 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/127266.diff
12 Files Affected:
- (added) llvm/include/llvm/ExecutionEngine/JITLink/XCOFF.h (+37)
- (added) llvm/include/llvm/ExecutionEngine/JITLink/XCOFF_ppc64.h (+37)
- (modified) llvm/lib/ExecutionEngine/JITLink/CMakeLists.txt (+5)
- (modified) llvm/lib/ExecutionEngine/JITLink/JITLink.cpp (+5)
- (added) llvm/lib/ExecutionEngine/JITLink/XCOFF.cpp (+43)
- (added) llvm/lib/ExecutionEngine/JITLink/XCOFFLinkGraphBuilder.cpp (+420)
- (added) llvm/lib/ExecutionEngine/JITLink/XCOFFLinkGraphBuilder.h (+63)
- (added) llvm/lib/ExecutionEngine/JITLink/XCOFF_ppc64.cpp (+121)
- (modified) llvm/lib/ExecutionEngine/Orc/LoadLinkableFile.cpp (+16)
- (modified) llvm/lib/ExecutionEngine/Orc/ObjectFileInterface.cpp (+45)
- (modified) llvm/lib/Object/XCOFFObjectFile.cpp (+7-3)
- (added) llvm/test/ExecutionEngine/JITLink/ppc64/XCOFF_ppc64.ll (+24)
``````````diff
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..0a76dcc77536b
--- /dev/null
+++ b/llvm/lib/ExecutionEngine/JITLink/XCOFFLinkGraphBuilder.cpp
@@ -0,0 +1,420 @@
+// 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 Hidden = *Flags & object::SymbolRef::SF_Hidden;
+ 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::Default};
+ if (Hidden)
+ S = Scope::Hidden;
+ // TODO: Got this from llvm-objdump.cpp:2938 not sure if its correct
+ if (!Weak) {
+ if (Global)
+ S = Scope::Default;
+ else
+ S = Scope::Local;
+ }
+
+ // TODO: figure out all symbols that should have Scope::SideEffectsOnly
+ 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())...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/127266
More information about the llvm-commits
mailing list