[JITLink][ELF][PPC64] Add skeleton ppc64 support and ELF/ppc64 JITLink backend.

[lhames]

Summary

This patch introduces a skeleton JITLink ppc64 support header and ELF/ppc64
backend. No relocations are supported in this initial version, but given a
program requiring no relocations (e.g. one that just returns a constant value
from main) the new backend is able to construct a LinkGraph from a ppc64 ELF
relocatable object, and the llvm-jitlink tool is able to execute it.

Being minimal, this commit should also serve as a good example of how to
introduce a JITLink backend for a new architecture.

[lhames]

Hi All,

I've added a few of the usual JIT reviewers, and some of you who I've seen make recent contributions to LLVM's PowerPC target library. If there's anyone else who you think should take a look please feel free to add them.

I'm not familiar with PowerPC nomenclature so I'd especially appreciate tips on naming. E.g. should it be "ppc64", "PPC64", "PowerPC64"?

I plan to add at least one basic relocation next. The aim is to make the ELF/ppc64 backend project accessible to the community by getting the JITLink boilerplate out of the way so that any interested committers can focus on implementing the ppc64 specifics.

The skeleton itself is sufficient to get a basic, relocation-free program running:

int main(void) {
  return 0;
}

(As tested on a POWER9 instance that has been generously provided to me by osuosl.org)

[sgraenitz]

The plan sounds very reasonable. PowerPC support is one of the last missing pieces for feature parity with RuntimeDyld. Speaking for the JITLink code, this looks excellent of course.

llvm/test/ExecutionEngine/JITLink/PPC64/ppc64le-no-relocs.s

1 ↗

(On Diff #513061)

The test fails for me when I don't build the LLVM PowerPC target. I would have expected it to be unsupported instead. I guess we need a llvm/test/ExecutionEngine/JITLink/PPC64/lit.local.cfg file like this:

if not 'PowerPC' in config.root.targets:
    config.unsupported = True

[v.g.vassilev]

This looks great!

[jain98]

Looks good! Does Phabricator only allow one reviewer to accept the revision. I can't seem to find any button that would let me accept the revision.

[lhames]

Add missing lit.cfg.py to llvm/test/ExecutionEngine/JITLink/PPC64 to prevent
ppc64 tests from running when the PowerPC target isn't enabled.

[lhames]

llvm/test/ExecutionEngine/JITLink/PPC64/ppc64le-no-relocs.s

1 ↗

(On Diff #513061)

Thanks for catching this. I've added the missing lit.local.cfg file in the latest version.

[sgraenitz]

Thanks! LGTM

[lhames]

clang-format

[lhames]

Rename test dir from PPC64 to ppc64.

I'm not sure whether this is the right direction, but it makes the naming
consistent with the rest of the patch (lowercase ppc64 everywhere except
include guards and ELF types/values).

[lhames]

Add a relocation processing loop with no supported relocations.

This will cause the skeleton ELF/ppc64 backend to error out if it encounters
any relocations, rather than silently ignoring them. Having this in the initial
commit helps future developers who may use this skeleton as a template, since
missing relocation failures will self-describe (via the error message) rather
than resulting in a crash or hang.

[nemanjai]

This all LGTM and I think the naming is consistent with other targets, so ppc64 makes sense. I have some minor comments that are more likely due to my lack of familiarity with jit-link than anything that should require action on the patch.

llvm/include/llvm/ExecutionEngine/JITLink/ELF_ppc64.h

10

Is it customary for these comments to mention LE/BE separately?
Something like
jit-link functions for ELF/ppc64{le}

22

Should this say ELF/ppc64 since it is for big endian rather than little (le)?

llvm/lib/ExecutionEngine/JITLink/ELF.cpp

61

I don't know what this does, but I imagine it is not related to PPC support. Since this patch will serve as a guide to future devs, perhaps this should just go in as a separate NFC??? commit?

llvm/lib/ExecutionEngine/JITLink/ELF_ppc64.cpp

47

Is x64 here supposed to be ppc64 or is in just an indication that it is a 64-bit ELF object regardless of architecture?

70

I am just curious what the implications of adding this triple here and whether it would be a problem on little endian PPC64 targets since the triple mentioned here is a big endian triple. Namely, do we need something like

Endianness == support::little ?
  "ppc64le-unknown-linux" :
  "ppc64-unknown-linux"

llvm/test/ExecutionEngine/lit.local.cfg

1 ↗

(On Diff #513935)

Just out of curiosity, will this enable all the tests to run on PPC even though a number of them may be failing? Do we need to try this out on PPC and mark the currently failing test cases with XFAIL?

[lhames]

Rebase on top-of-tree, address nemanjai's review comments.

[MaskRay]

llvm/include/llvm/ExecutionEngine/JITLink/ppc64.h

45

inconsistent "end namespace" marker? :)

Note: with C++17 we can do namespace llvm::jitlink::ppc64

[MaskRay]

llvm/lib/ExecutionEngine/JITLink/ELF.cpp

79

The braces are optional.

LLVM style may prefer removing the else, so that the number of lines is even smaller.

[lhames]

llvm/include/llvm/ExecutionEngine/JITLink/ELF_ppc64.h

22

Thanks for catching these!

llvm/lib/ExecutionEngine/JITLink/ELF.cpp

61

Good point -- the buffer check was just expanded so that we could assume EI_DATA was accessible below, but it's not otherwise related to this patch. I've split it out into d8472ac238d.

llvm/lib/ExecutionEngine/JITLink/ELF_ppc64.cpp

47

Just a typo left in from me copy/pasting the x86-64 backend. :)

70

Yes -- thank you for catching this!

We definitely want to get the architecture in the triple right: ObjectLinkingLayer plugins may use it to make decisions about how they inspect/modify the graph.

llvm/test/ExecutionEngine/lit.local.cfg

1 ↗

(On Diff #513935)

This will enable these tests on all platforms where the PowerPC target is built (which I believe is everywhere, except where LLVM_TARGETS_TO_BUILD is explicitly specified to exclude PowerPC).

I've tested this patch on Linux/ppc64le, Linux/x86-64, Darwin/x86-64, and Darwin/arm64 and all tests are passing on those platforms. I think we should probably land this and see what bots (if any) fail, then selectively XFAIL/UNSUPPORT them.

[lhames]

Use C++17-style for namespaces.

[lhames]

llvm/include/llvm/ExecutionEngine/JITLink/ppc64.h

45

Good point. I've updated the namespaces in the latest version.

llvm/lib/ExecutionEngine/JITLink/ELF.cpp

79

I tried this without the braces, but it scans oddly when reading (it looks like incorrectly indented cases). I think it's worth keeping them for grouping here.

[nemanjai]

Thank you so much for implementing this for PowerPC. Implementing JITLink has been on our radar for a while and this gives us a very welcome head start.

[lhames]

In D148192#4275894, @nemanjai wrote:

Thank you so much for implementing this for PowerPC. Implementing JITLink has been on our radar for a while and this gives us a very welcome head start.

You're very welcome.

As a next step to landing this I've enabled JIT tests on PowerPC in d771f54107c4. We'll see what (if anything) is failing these days. Once the JIT test suite is passing I think this is ready to land.

[lhames]

Looks like we have a handful of test failures on big-endian machines only when PowerPC tests are enabled (see https://lab.llvm.org/buildbot#builders/93/builds/14488):

Failed Tests (4):
  LLVM :: ExecutionEngine/JITLink/x86-64/MachO-duplicate-local.test
  LLVM :: ExecutionEngine/JITLink/x86-64/MachO_ehframe_bad_fde_cie-ptr_out-of-range.test
  LLVM :: ExecutionEngine/JITLink/x86-64/MachO_ehframe_bad_fde_pc-begin_out-of-range.test
  LLVM :: ExecutionEngine/RuntimeDyld/AArch64/ELF_ARM64_TSTBR14.s

There may be others if the failures are sensitive to memory layout. Still, this looks like a pretty good start.

I'm fine marking the RuntimeDyld tests unsupported on ppc64, but I'd definitely like to get the JITLink ones passing. I've requested a ppc64 big-endian instance from osuosl.org to look into this when I get back from vacation.

[Dinistro]

It seems that this revision uncovers some existing test failures related to Orc. The failures are only triggered when building the llvm examples with static libraries enabled . Do you guys know who is responsible for fixing these tests?

[lhames]

In D148192#4279643, @Dinistro wrote:

It seems that this revision uncovers some existing test failures related to Orc. The failures are only triggered when building the llvm examples with static libraries enabled . Do you guys know who is responsible for fixing these tests?

Hi @Dinistro. Do you have a link to the failing tests?

[lhames]

In D148192#4282626, @lhames wrote:

In D148192#4279643, @Dinistro wrote:

It seems that this revision uncovers some existing test failures related to Orc. The failures are only triggered when building the llvm examples with static libraries enabled . Do you guys know who is responsible for fixing these tests?

Hi @Dinistro. Do you have a link to the failing tests?

Oh -- the failures posted by buildkite! Yep -- I'll be fixing those before this lands.

[Dinistro]

In D148192#4282630, @lhames wrote:

Oh -- the failures posted by buildkite! Yep -- I'll be fixing those before this lands.

Yes, I was referring to these issues. Thank you for looking into it :)

[lhames]

Quick update on this: osuosl.org is kindly organizing a big-endian PPC64 system for me -- I'm going to use that to debug the big-endian testcase failures that we see when we enable JIT tests for PowerPC. Once those tests are passing we're clear to land this.

[lhames]

Rebase.

[NathanielMcVicar]

It looks like this change has broken MSVC builders: https://lab.llvm.org/buildbot/#/builders/13/builds/35643

llvm-project\llvm\include\llvm/ExecutionEngine/JITLink/ppc64.h(37): error C2220: the following warning is treated as an error
llvm-project\llvm\include\llvm/ExecutionEngine/JITLink/ppc64.h(37): warning C4065: switch statement contains 'default' but no 'case' labels

llvm/include/llvm/ExecutionEngine/JITLink/ELF_ppc64.h

+//===------ ELF_ppc64.h - JIT link functions for ELF/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 ELF/ppc64{le}.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_JITLINK_ELF_PPC64_H
+#define LLVM_EXECUTIONENGINE_JITLINK_ELF_PPC64_H
+
+#include "llvm/ExecutionEngine/JITLink/JITLink.h"
+
+namespace llvm::jitlink {
+
+/// Create a LinkGraph from an ELF/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.
+///
+/// WARNING: The big-endian backend has not been tested yet.
+Expected<std::unique_ptr<LinkGraph>>
+createLinkGraphFromELFObject_ppc64(MemoryBufferRef ObjectBuffer);
+
+/// Create a LinkGraph from an ELF/ppc64le 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>>
+createLinkGraphFromELFObject_ppc64le(MemoryBufferRef ObjectBuffer);
+
+/// jit-link the given object buffer, which must be a ELF ppc64le object file.
+///
+/// WARNING: The big-endian backend has not been tested yet.
+void link_ELF_ppc64(std::unique_ptr<LinkGraph> G,
+                    std::unique_ptr<JITLinkContext> 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);
+
+} // end namespace llvm::jitlink
+
+#endif // LLVM_EXECUTIONENGINE_JITLINK_ELF_PPC64_H

llvm/include/llvm/ExecutionEngine/JITLink/ppc64.h

+//===--- ppc64.h - Generic JITLink ppc64 edge kinds, utilities --*- 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 utilities for graphs representing 64-bit PowerPC objects.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_JITLINK_PPC64_H
+#define LLVM_EXECUTIONENGINE_JITLINK_PPC64_H
+
+#include "llvm/ExecutionEngine/JITLink/JITLink.h"
+
+namespace llvm::jitlink::ppc64 {
+
+/// Represents ppc64 fixups and other ppc64-specific edge kinds.
+/// TODO: Add edge kinds.
+enum EdgeKind_ppc64 : Edge::Kind {};
+
+/// Returns a string name for the given ppc64 edge. For debugging purposes
+/// only.
+const char *getEdgeKindName(Edge::Kind K);
+
+/// Apply fixup expression for edge to block content.
+/// TOOD: Add fixups as we add edges.
+inline Error applyFixup(LinkGraph &G, Block &B, const Edge &E,
+                        const Symbol *GOTSymbol) {
+  switch (E.getKind()) {
+  default:
+    return make_error<JITLinkError>(
+        "In graph " + G.getName() + ", section " + B.getSection().getName() +
+        " unsupported edge kind " + getEdgeKindName(E.getKind()));
+  }
+
+  return Error::success();
+}
+
+} // end namespace llvm::jitlink::ppc64
+
+#endif // LLVM_EXECUTIONENGINE_JITLINK_PPC64_H

llvm/lib/ExecutionEngine/JITLink/CMakeLists.txt

add_llvm_component_library(LLVMJITLink
 
   # ELF
   ELF.cpp
   ELFLinkGraphBuilder.cpp
   ELF_aarch32.cpp
   ELF_aarch64.cpp
   ELF_i386.cpp
   ELF_loongarch.cpp
+  ELF_ppc64.cpp
   ELF_riscv.cpp
   ELF_x86_64.cpp
 
   # COFF
   COFF.cpp
   COFFDirectiveParser.cpp
   COFFLinkGraphBuilder.cpp
   COFF_x86_64.cpp
 
   # Architectures:
   aarch32.cpp
   aarch64.cpp
   i386.cpp
   loongarch.cpp
+  ppc64.cpp
   riscv.cpp
   x86_64.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/ExecutionEngine/JITLink
 
   DEPENDS
   intrinsics_gen

llvm/lib/ExecutionEngine/JITLink/ELF.cpp

 
 #include "llvm/ExecutionEngine/JITLink/ELF.h"
 
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/ExecutionEngine/JITLink/ELF_aarch32.h"
 #include "llvm/ExecutionEngine/JITLink/ELF_aarch64.h"
 #include "llvm/ExecutionEngine/JITLink/ELF_i386.h"
 #include "llvm/ExecutionEngine/JITLink/ELF_loongarch.h"
+#include "llvm/ExecutionEngine/JITLink/ELF_ppc64.h"
 #include "llvm/ExecutionEngine/JITLink/ELF_riscv.h"
 #include "llvm/ExecutionEngine/JITLink/ELF_x86_64.h"
 #include "llvm/Object/ELF.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include <cstring>
 
Expected<uint16_t> readTargetMachineArch(StringRef Buffer) {
   }
 
   return ELF::EM_NONE;
 }
 
 Expected<std::unique_ptr<LinkGraph>>
 createLinkGraphFromELFObject(MemoryBufferRef ObjectBuffer) {
   StringRef Buffer = ObjectBuffer.getBuffer();
   if (Buffer.size() < ELF::EI_NIDENT)
     return make_error<JITLinkError>("Truncated ELF buffer");
 
   if (memcmp(Buffer.data(), ELF::ElfMagic, strlen(ELF::ElfMagic)) != 0)
     return make_error<JITLinkError>("ELF magic not valid");
 
+  uint8_t DataEncoding = Buffer.data()[ELF::EI_DATA];
   Expected<uint16_t> TargetMachineArch = readTargetMachineArch(Buffer);
   if (!TargetMachineArch)
     return TargetMachineArch.takeError();
 
   switch (*TargetMachineArch) {
   case ELF::EM_AARCH64:
     return createLinkGraphFromELFObject_aarch64(ObjectBuffer);
   case ELF::EM_ARM:
     return createLinkGraphFromELFObject_aarch32(ObjectBuffer);
   case ELF::EM_LOONGARCH:
     return createLinkGraphFromELFObject_loongarch(ObjectBuffer);
+  case ELF::EM_PPC64: {
+    if (DataEncoding == ELF::ELFDATA2LSB)
+      return createLinkGraphFromELFObject_ppc64le(ObjectBuffer);
+    else
+      return createLinkGraphFromELFObject_ppc64(ObjectBuffer);
+  }
   case ELF::EM_RISCV:
     return createLinkGraphFromELFObject_riscv(ObjectBuffer);
   case ELF::EM_X86_64:
     return createLinkGraphFromELFObject_x86_64(ObjectBuffer);
   case ELF::EM_386:
     return createLinkGraphFromELFObject_i386(ObjectBuffer);
   default:
     return make_error<JITLinkError>(
void link_ELF(std::unique_ptr<LinkGraph> G,
   case Triple::thumb:
   case Triple::thumbeb:
     link_ELF_aarch32(std::move(G), std::move(Ctx));
     return;
   case Triple::loongarch32:
   case Triple::loongarch64:
     link_ELF_loongarch(std::move(G), std::move(Ctx));
     return;
+  case Triple::ppc64:
+    link_ELF_ppc64(std::move(G), std::move(Ctx));
+    return;
+  case Triple::ppc64le:
+    link_ELF_ppc64le(std::move(G), std::move(Ctx));
+    return;
   case Triple::riscv32:
   case Triple::riscv64:
     link_ELF_riscv(std::move(G), std::move(Ctx));
     return;
   case Triple::x86_64:
     link_ELF_x86_64(std::move(G), std::move(Ctx));
     return;
   case Triple::x86:

llvm/lib/ExecutionEngine/JITLink/ELF_ppc64.cpp

+//===------- 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/ppc64.h"
+#include "llvm/Object/ELFObjectFile.h"
+#include "llvm/Support/Endian.h"
+
+#include "ELFLinkGraphBuilder.h"
+#include "JITLinkGeneric.h"
+
+#define DEBUG_TYPE "jitlink"
+
+namespace llvm::jitlink {
+
+template <support::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) {
+    auto ELFReloc = Rel.getType(false);
+    return make_error<JITLinkError>(
+        "In " + G->getName() + ": Unsupported ppc64 relocation type " +
+        object::getELFRelocationTypeName(ELF::EM_PPC64, ELFReloc));
+  }
+
+public:
+  ELFLinkGraphBuilder_ppc64(StringRef FileName,
+                            const object::ELFFile<ELFT> &Obj, Triple TT,
+                            LinkGraph::FeatureVector Features)
+      : ELFLinkGraphBuilder<ELFT>(Obj, std::move(TT), std::move(Features),
+                                  FileName, ppc64::getEdgeKindName) {}
+};
+
+template <support::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)) {}
+
+private:
+  Symbol *GOTSymbol = nullptr;
+
+  Error applyFixup(LinkGraph &G, Block &B, const Edge &E) const {
+    return ppc64::applyFixup(G, B, E, GOTSymbol);
+  }
+};
+
+template <support::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(), Features->getFeatures())
+      .buildGraph();
+}
+
+template <support::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 a mark-live pass.
+    if (auto MarkLive = Ctx->getMarkLivePass(G->getTargetTriple()))
+      Config.PrePrunePasses.push_back(std::move(MarkLive));
+    else
+      Config.PrePrunePasses.push_back(markAllSymbolsLive);
+  }
+
+  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<support::big>(
+      std::move(ObjectBuffer));
+}
+
+Expected<std::unique_ptr<LinkGraph>>
+createLinkGraphFromELFObject_ppc64le(MemoryBufferRef ObjectBuffer) {
+  return createLinkGraphFromELFObject_ppc64<support::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<support::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<support::little>(std::move(G), std::move(Ctx));
+}
+
+} // end namespace llvm::jitlink

llvm/lib/ExecutionEngine/JITLink/ppc64.cpp

+//===----- ppc64.cpp - Generic JITLink ppc64 edge kinds, utilities ------===//
+//
+// 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 utilities for graphs representing 64-bit PowerPC objects.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ExecutionEngine/JITLink/ppc64.h"
+
+#define DEBUG_TYPE "jitlink"
+
+namespace llvm::jitlink::ppc64 {
+
+const char *getEdgeKindName(Edge::Kind K) {
+  // TODO: Add edge names.
+  switch (K) {
+  default:
+    return getGenericEdgeKindName(static_cast<Edge::Kind>(K));
+  }
+}
+
+} // end namespace llvm::jitlink::ppc64

llvm/test/ExecutionEngine/JITLink/ppc64/lit.local.cfg

+if not 'PowerPC' in config.root.targets:
+  config.unsupported = True

llvm/test/ExecutionEngine/JITLink/ppc64/ppc64le-no-relocs.s

+# RUN: llvm-mc -triple=powerpc64le-unknown-linux-gnu -filetype=obj -o %t %s
+# RUN: llvm-jitlink -noexec %t
+#
+# Check that a program that just returns immediately from main (requiring no
+# relocations at all) loads under llvm-jitlink.
+
+  .text
+  .abiversion 2
+  .file "ppc64le-no-relocs.c"
+  .globl  main
+  .p2align  4
+  .type main,@function
+main:
+.Lfunc_begin0:
+  li 3, 0
+  blr
+  .long 0
+  .quad 0
+.Lfunc_end0:
+  .size main, .Lfunc_end0-.Lfunc_begin0