llvm/lib/ExecutionEngine/JITLink/ELF_ppc64.cpp

   1 //===------- ELF_ppc64.cpp -JIT linker implementation for ELF/ppc64 -------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // ELF/ppc64 jit-link implementation.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "llvm/ExecutionEngine/JITLink/ELF_ppc64.h"
  14 #include "llvm/ExecutionEngine/JITLink/DWARFRecordSectionSplitter.h"
  15 #include "llvm/ExecutionEngine/JITLink/TableManager.h"
  16 #include "llvm/ExecutionEngine/JITLink/ppc64.h"
  17 #include "llvm/Object/ELFObjectFile.h"
  18
  19 #include "EHFrameSupportImpl.h"
  20 #include "ELFLinkGraphBuilder.h"
  21 #include "JITLinkGeneric.h"
  22
  23 #define DEBUG_TYPE "jitlink"
  24
  25 namespace {
  26
  27 using namespace llvm;
  28 using namespace llvm::jitlink;
  29
  30 constexpr StringRef ELFTOCSymbolName = ".TOC.";
  31 constexpr StringRef TOCSymbolAliasIdent = "__TOC__";
  32 constexpr uint64_t ELFTOCBaseOffset = 0x8000;
  33 constexpr StringRef ELFTLSInfoSectionName = "$__TLSINFO";
  34
  35 template <llvm::endianness Endianness>
  36 class TLSInfoTableManager_ELF_ppc64
  37     : public TableManager<TLSInfoTableManager_ELF_ppc64<Endianness>> {
  38 public:
  39   static const uint8_t TLSInfoEntryContent[16];
  40
  41   static StringRef getSectionName() { return ELFTLSInfoSectionName; }
  42
  43   bool visitEdge(LinkGraph &G, Block *B, Edge &E) {
  44     Edge::Kind K = E.getKind();
  45     switch (K) {
  46     case ppc64::RequestTLSDescInGOTAndTransformToTOCDelta16HA:
  47       E.setKind(ppc64::TOCDelta16HA);
  48       E.setTarget(this->getEntryForTarget(G, E.getTarget()));
  49       return true;
  50     case ppc64::RequestTLSDescInGOTAndTransformToTOCDelta16LO:
  51       E.setKind(ppc64::TOCDelta16LO);
  52       E.setTarget(this->getEntryForTarget(G, E.getTarget()));
  53       return true;
  54     case ppc64::RequestTLSDescInGOTAndTransformToDelta34:
  55       E.setKind(ppc64::Delta34);
  56       E.setTarget(this->getEntryForTarget(G, E.getTarget()));
  57       return true;
  58     default:
  59       return false;
  60     }
  61   }
  62
  63   Symbol &createEntry(LinkGraph &G, Symbol &Target) {
  64     // The TLS Info entry's key value will be written by
  65     // `fixTLVSectionsAndEdges`, so create mutable content.
  66     auto &TLSInfoEntry = G.createMutableContentBlock(
  67         getTLSInfoSection(G), G.allocateContent(getTLSInfoEntryContent()),
  68         orc::ExecutorAddr(), 8, 0);
  69     TLSInfoEntry.addEdge(ppc64::Pointer64, 8, Target, 0);
  70     return G.addAnonymousSymbol(TLSInfoEntry, 0, 16, false, false);
  71   }
  72
  73 private:
  74   Section &getTLSInfoSection(LinkGraph &G) {
  75     if (!TLSInfoTable)
  76       TLSInfoTable =
  77           &G.createSection(ELFTLSInfoSectionName, orc::MemProt::Read);
  78     return *TLSInfoTable;
  79   }
  80
  81   ArrayRef<char> getTLSInfoEntryContent() const {
  82     return {reinterpret_cast<const char *>(TLSInfoEntryContent),
  83             sizeof(TLSInfoEntryContent)};
  84   }
  85
  86   Section *TLSInfoTable = nullptr;
  87 };
  88
  89 template <>
  90 const uint8_t TLSInfoTableManager_ELF_ppc64<
  91     llvm::endianness::little>::TLSInfoEntryContent[16] = {
  92     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /*pthread key */
  93     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  /*data address*/
  94 };
  95
  96 template <>
  97 const uint8_t TLSInfoTableManager_ELF_ppc64<
  98     llvm::endianness::big>::TLSInfoEntryContent[16] = {
  99     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /*pthread key */
 100     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  /*data address*/
 101 };
 102
 103 template <llvm::endianness Endianness>
 104 Symbol &createELFGOTHeader(LinkGraph &G,
 105                            ppc64::TOCTableManager<Endianness> &TOC) {
 106   Symbol *TOCSymbol = nullptr;
 107
 108   for (Symbol *Sym : G.defined_symbols())
 109     if (LLVM_UNLIKELY(Sym->getName() == ELFTOCSymbolName)) {
 110       TOCSymbol = Sym;
 111       break;
 112     }
 113
 114   if (LLVM_LIKELY(TOCSymbol == nullptr)) {
 115     for (Symbol *Sym : G.external_symbols())
 116       if (Sym->getName() == ELFTOCSymbolName) {
 117         TOCSymbol = Sym;
 118         break;
 119       }
 120   }
 121
 122   if (!TOCSymbol)
 123     TOCSymbol = &G.addExternalSymbol(ELFTOCSymbolName, 0, false);
 124
 125   return TOC.getEntryForTarget(G, *TOCSymbol);
 126 }
 127
 128 // Register preexisting GOT entries with TOC table manager.
 129 template <llvm::endianness Endianness>
 130 inline void
 131 registerExistingGOTEntries(LinkGraph &G,
 132                            ppc64::TOCTableManager<Endianness> &TOC) {
 133   auto isGOTEntry = [](const Edge &E) {
 134     return E.getKind() == ppc64::Pointer64 && E.getTarget().isExternal();
 135   };
 136   if (Section *dotTOCSection = G.findSectionByName(".toc")) {
 137     for (Block *B : dotTOCSection->blocks())
 138       for (Edge &E : B->edges())
 139         if (isGOTEntry(E))
 140           TOC.registerPreExistingEntry(E.getTarget(),
 141                                        G.addAnonymousSymbol(*B, E.getOffset(),
 142                                                             G.getPointerSize(),
 143                                                             false, false));
 144   }
 145 }
 146
 147 template <llvm::endianness Endianness>
 148 Error buildTables_ELF_ppc64(LinkGraph &G) {
 149   LLVM_DEBUG(dbgs() << "Visiting edges in graph:\n");
 150   ppc64::TOCTableManager<Endianness> TOC;
 151   // Before visiting edges, we create a header containing the address of TOC
 152   // base as ELFABIv2 suggests:
 153   //  > The GOT consists of an 8-byte header that contains the TOC base (the
 154   //  first TOC base when multiple TOCs are present), followed by an array of
 155   //  8-byte addresses.
 156   createELFGOTHeader(G, TOC);
 157
 158   // There might be compiler-generated GOT entries in ELF relocatable file.
 159   registerExistingGOTEntries(G, TOC);
 160
 161   ppc64::PLTTableManager<Endianness> PLT(TOC);
 162   TLSInfoTableManager_ELF_ppc64<Endianness> TLSInfo;
 163   visitExistingEdges(G, TOC, PLT, TLSInfo);
 164
 165   // After visiting edges in LinkGraph, we have GOT entries built in the
 166   // synthesized section.
 167   // Merge sections included in TOC into synthesized TOC section,
 168   // thus TOC is compact and reducing chances of relocation
 169   // overflow.
 170   if (Section *TOCSection = G.findSectionByName(TOC.getSectionName())) {
 171     // .got and .plt are not normally present in a relocatable object file
 172     // because they are linker generated.
 173     if (Section *gotSection = G.findSectionByName(".got"))
 174       G.mergeSections(*TOCSection, *gotSection);
 175     if (Section *tocSection = G.findSectionByName(".toc"))
 176       G.mergeSections(*TOCSection, *tocSection);
 177     if (Section *sdataSection = G.findSectionByName(".sdata"))
 178       G.mergeSections(*TOCSection, *sdataSection);
 179     if (Section *sbssSection = G.findSectionByName(".sbss"))
 180       G.mergeSections(*TOCSection, *sbssSection);
 181     // .tocbss no longer appears in ELFABIv2. Leave it here to be compatible
 182     // with rtdyld.
 183     if (Section *tocbssSection = G.findSectionByName(".tocbss"))
 184       G.mergeSections(*TOCSection, *tocbssSection);
 185     if (Section *pltSection = G.findSectionByName(".plt"))
 186       G.mergeSections(*TOCSection, *pltSection);
 187   }
 188
 189   return Error::success();
 190 }
 191
 192 } // namespace
 193
 194 namespace llvm::jitlink {
 195
 196 template <llvm::endianness Endianness>
 197 class ELFLinkGraphBuilder_ppc64
 198     : public ELFLinkGraphBuilder<object::ELFType<Endianness, true>> {
 199 private:
 200   using ELFT = object::ELFType<Endianness, true>;
 201   using Base = ELFLinkGraphBuilder<ELFT>;
 202
 203   using Base::G; // Use LinkGraph pointer from base class.
 204
 205   Error addRelocations() override {
 206     LLVM_DEBUG(dbgs() << "Processing relocations:\n");
 207
 208     using Self = ELFLinkGraphBuilder_ppc64<Endianness>;
 209     for (const auto &RelSect : Base::Sections) {
 210       // Validate the section to read relocation entries from.
 211       if (RelSect.sh_type == ELF::SHT_REL)
 212         return make_error<StringError>("No SHT_REL in valid " +
 213                                            G->getTargetTriple().getArchName() +
 214                                            " ELF object files",
 215                                        inconvertibleErrorCode());
 216
 217       if (Error Err = Base::forEachRelaRelocation(RelSect, this,
 218                                                   &Self::addSingleRelocation))
 219         return Err;
 220     }
 221
 222     return Error::success();
 223   }
 224
 225   Error addSingleRelocation(const typename ELFT::Rela &Rel,
 226                             const typename ELFT::Shdr &FixupSection,
 227                             Block &BlockToFix) {
 228     using Base = ELFLinkGraphBuilder<ELFT>;
 229     auto ELFReloc = Rel.getType(false);
 230
 231     // R_PPC64_NONE is a no-op.
 232     if (LLVM_UNLIKELY(ELFReloc == ELF::R_PPC64_NONE))
 233       return Error::success();
 234
 235     // TLS model markers. We only support global-dynamic model now.
 236     if (ELFReloc == ELF::R_PPC64_TLSGD)
 237       return Error::success();
 238     if (ELFReloc == ELF::R_PPC64_TLSLD)
 239       return make_error<StringError>("Local-dynamic TLS model is not supported",
 240                                      inconvertibleErrorCode());
 241
 242     if (ELFReloc == ELF::R_PPC64_PCREL_OPT)
 243       // TODO: Support PCREL optimization, now ignore it.
 244       return Error::success();
 245
 246     if (ELFReloc == ELF::R_PPC64_TPREL34)
 247       return make_error<StringError>("Local-exec TLS model is not supported",
 248                                      inconvertibleErrorCode());
 249
 250     auto ObjSymbol = Base::Obj.getRelocationSymbol(Rel, Base::SymTabSec);
 251     if (!ObjSymbol)
 252       return ObjSymbol.takeError();
 253
 254     uint32_t SymbolIndex = Rel.getSymbol(false);
 255     Symbol *GraphSymbol = Base::getGraphSymbol(SymbolIndex);
 256     if (!GraphSymbol)
 257       return make_error<StringError>(
 258           formatv("Could not find symbol at given index, did you add it to "
 259                   "JITSymbolTable? index: {0}, shndx: {1} Size of table: {2}",
 260                   SymbolIndex, (*ObjSymbol)->st_shndx,
 261                   Base::GraphSymbols.size()),
 262           inconvertibleErrorCode());
 263
 264     int64_t Addend = Rel.r_addend;
 265     orc::ExecutorAddr FixupAddress =
 266         orc::ExecutorAddr(FixupSection.sh_addr) + Rel.r_offset;
 267     Edge::OffsetT Offset = FixupAddress - BlockToFix.getAddress();
 268     Edge::Kind Kind = Edge::Invalid;
 269
 270     switch (ELFReloc) {
 271     default:
 272       return make_error<JITLinkError>(
 273           "In " + G->getName() + ": Unsupported ppc64 relocation type " +
 274           object::getELFRelocationTypeName(ELF::EM_PPC64, ELFReloc));
 275     case ELF::R_PPC64_ADDR64:
 276       Kind = ppc64::Pointer64;
 277       break;
 278     case ELF::R_PPC64_ADDR32:
 279       Kind = ppc64::Pointer32;
 280       break;
 281     case ELF::R_PPC64_ADDR16:
 282       Kind = ppc64::Pointer16;
 283       break;
 284     case ELF::R_PPC64_ADDR16_DS:
 285       Kind = ppc64::Pointer16DS;
 286       break;
 287     case ELF::R_PPC64_ADDR16_HA:
 288       Kind = ppc64::Pointer16HA;
 289       break;
 290     case ELF::R_PPC64_ADDR16_HI:
 291       Kind = ppc64::Pointer16HI;
 292       break;
 293     case ELF::R_PPC64_ADDR16_HIGH:
 294       Kind = ppc64::Pointer16HIGH;
 295       break;
 296     case ELF::R_PPC64_ADDR16_HIGHA:
 297       Kind = ppc64::Pointer16HIGHA;
 298       break;
 299     case ELF::R_PPC64_ADDR16_HIGHER:
 300       Kind = ppc64::Pointer16HIGHER;
 301       break;
 302     case ELF::R_PPC64_ADDR16_HIGHERA:
 303       Kind = ppc64::Pointer16HIGHERA;
 304       break;
 305     case ELF::R_PPC64_ADDR16_HIGHEST:
 306       Kind = ppc64::Pointer16HIGHEST;
 307       break;
 308     case ELF::R_PPC64_ADDR16_HIGHESTA:
 309       Kind = ppc64::Pointer16HIGHESTA;
 310       break;
 311     case ELF::R_PPC64_ADDR16_LO:
 312       Kind = ppc64::Pointer16LO;
 313       break;
 314     case ELF::R_PPC64_ADDR16_LO_DS:
 315       Kind = ppc64::Pointer16LODS;
 316       break;
 317     case ELF::R_PPC64_ADDR14:
 318       Kind = ppc64::Pointer14;
 319       break;
 320     case ELF::R_PPC64_TOC:
 321       Kind = ppc64::TOC;
 322       break;
 323     case ELF::R_PPC64_TOC16:
 324       Kind = ppc64::TOCDelta16;
 325       break;
 326     case ELF::R_PPC64_TOC16_HA:
 327       Kind = ppc64::TOCDelta16HA;
 328       break;
 329     case ELF::R_PPC64_TOC16_HI:
 330       Kind = ppc64::TOCDelta16HI;
 331       break;
 332     case ELF::R_PPC64_TOC16_DS:
 333       Kind = ppc64::TOCDelta16DS;
 334       break;
 335     case ELF::R_PPC64_TOC16_LO:
 336       Kind = ppc64::TOCDelta16LO;
 337       break;
 338     case ELF::R_PPC64_TOC16_LO_DS:
 339       Kind = ppc64::TOCDelta16LODS;
 340       break;
 341     case ELF::R_PPC64_REL16:
 342       Kind = ppc64::Delta16;
 343       break;
 344     case ELF::R_PPC64_REL16_HA:
 345       Kind = ppc64::Delta16HA;
 346       break;
 347     case ELF::R_PPC64_REL16_HI:
 348       Kind = ppc64::Delta16HI;
 349       break;
 350     case ELF::R_PPC64_REL16_LO:
 351       Kind = ppc64::Delta16LO;
 352       break;
 353     case ELF::R_PPC64_REL32:
 354       Kind = ppc64::Delta32;
 355       break;
 356     case ELF::R_PPC64_REL24_NOTOC:
 357       Kind = ppc64::RequestCallNoTOC;
 358       break;
 359     case ELF::R_PPC64_REL24:
 360       Kind = ppc64::RequestCall;
 361       // Determining a target is external or not is deferred in PostPrunePass.
 362       // We assume branching to local entry by default, since in PostPrunePass,
 363       // we don't have any context to determine LocalEntryOffset. If it finally
 364       // turns out to be an external call, we'll have a stub for the external
 365       // target, the target of this edge will be the stub and its addend will be
 366       // set 0.
 367       Addend += ELF::decodePPC64LocalEntryOffset((*ObjSymbol)->st_other);
 368       break;
 369     case ELF::R_PPC64_REL64:
 370       Kind = ppc64::Delta64;
 371       break;
 372     case ELF::R_PPC64_PCREL34:
 373       Kind = ppc64::Delta34;
 374       break;
 375     case ELF::R_PPC64_GOT_PCREL34:
 376       Kind = ppc64::RequestGOTAndTransformToDelta34;
 377       break;
 378     case ELF::R_PPC64_GOT_TLSGD16_HA:
 379       Kind = ppc64::RequestTLSDescInGOTAndTransformToTOCDelta16HA;
 380       break;
 381     case ELF::R_PPC64_GOT_TLSGD16_LO:
 382       Kind = ppc64::RequestTLSDescInGOTAndTransformToTOCDelta16LO;
 383       break;
 384     case ELF::R_PPC64_GOT_TLSGD_PCREL34:
 385       Kind = ppc64::RequestTLSDescInGOTAndTransformToDelta34;
 386       break;
 387     }
 388
 389     Edge GE(Kind, Offset, *GraphSymbol, Addend);
 390     BlockToFix.addEdge(std::move(GE));
 391     return Error::success();
 392   }
 393
 394 public:
 395   ELFLinkGraphBuilder_ppc64(StringRef FileName,
 396                             const object::ELFFile<ELFT> &Obj, Triple TT,
 397                             SubtargetFeatures Features)
 398       : ELFLinkGraphBuilder<ELFT>(Obj, std::move(TT), std::move(Features),
 399                                   FileName, ppc64::getEdgeKindName) {}
 400 };
 401
 402 template <llvm::endianness Endianness>
 403 class ELFJITLinker_ppc64 : public JITLinker<ELFJITLinker_ppc64<Endianness>> {
 404   using JITLinkerBase = JITLinker<ELFJITLinker_ppc64<Endianness>>;
 405   friend JITLinkerBase;
 406
 407 public:
 408   ELFJITLinker_ppc64(std::unique_ptr<JITLinkContext> Ctx,
 409                      std::unique_ptr<LinkGraph> G, PassConfiguration PassConfig)
 410       : JITLinkerBase(std::move(Ctx), std::move(G), std::move(PassConfig)) {
 411     JITLinkerBase::getPassConfig().PostAllocationPasses.push_back(
 412         [this](LinkGraph &G) { return defineTOCBase(G); });
 413   }
 414
 415 private:
 416   Symbol *TOCSymbol = nullptr;
 417
 418   Error defineTOCBase(LinkGraph &G) {
 419     for (Symbol *Sym : G.defined_symbols()) {
 420       if (LLVM_UNLIKELY(Sym->getName() == ELFTOCSymbolName)) {
 421         TOCSymbol = Sym;
 422         return Error::success();
 423       }
 424     }
 425
 426     assert(TOCSymbol == nullptr &&
 427            "TOCSymbol should not be defined at this point");
 428
 429     for (Symbol *Sym : G.external_symbols()) {
 430       if (Sym->getName() == ELFTOCSymbolName) {
 431         TOCSymbol = Sym;
 432         break;
 433       }
 434     }
 435
 436     if (Section *TOCSection = G.findSectionByName(
 437             ppc64::TOCTableManager<Endianness>::getSectionName())) {
 438       assert(!TOCSection->empty() && "TOC section should have reserved an "
 439                                      "entry for containing the TOC base");
 440
 441       SectionRange SR(*TOCSection);
 442       orc::ExecutorAddr TOCBaseAddr(SR.getFirstBlock()->getAddress() +
 443                                     ELFTOCBaseOffset);
 444       assert(TOCSymbol && TOCSymbol->isExternal() &&
 445              ".TOC. should be a external symbol at this point");
 446       G.makeAbsolute(*TOCSymbol, TOCBaseAddr);
 447       // Create an alias of .TOC. so that rtdyld checker can recognize.
 448       G.addAbsoluteSymbol(TOCSymbolAliasIdent, TOCSymbol->getAddress(),
 449                           TOCSymbol->getSize(), TOCSymbol->getLinkage(),
 450                           TOCSymbol->getScope(), TOCSymbol->isLive());
 451       return Error::success();
 452     }
 453
 454     // If TOC section doesn't exist, which means no TOC relocation is found, we
 455     // don't need a TOCSymbol.
 456     return Error::success();
 457   }
 458
 459   Error applyFixup(LinkGraph &G, Block &B, const Edge &E) const {
 460     return ppc64::applyFixup<Endianness>(G, B, E, TOCSymbol);
 461   }
 462 };
 463
 464 template <llvm::endianness Endianness>
 465 Expected<std::unique_ptr<LinkGraph>>
 466 createLinkGraphFromELFObject_ppc64(MemoryBufferRef ObjectBuffer) {
 467   LLVM_DEBUG({
 468     dbgs() << "Building jitlink graph for new input "
 469            << ObjectBuffer.getBufferIdentifier() << "...\n";
 470   });
 471
 472   auto ELFObj = object::ObjectFile::createELFObjectFile(ObjectBuffer);
 473   if (!ELFObj)
 474     return ELFObj.takeError();
 475
 476   auto Features = (*ELFObj)->getFeatures();
 477   if (!Features)
 478     return Features.takeError();
 479
 480   using ELFT = object::ELFType<Endianness, true>;
 481   auto &ELFObjFile = cast<object::ELFObjectFile<ELFT>>(**ELFObj);
 482   return ELFLinkGraphBuilder_ppc64<Endianness>(
 483              (*ELFObj)->getFileName(), ELFObjFile.getELFFile(),
 484              (*ELFObj)->makeTriple(), std::move(*Features))
 485       .buildGraph();
 486 }
 487
 488 template <llvm::endianness Endianness>
 489 void link_ELF_ppc64(std::unique_ptr<LinkGraph> G,
 490                     std::unique_ptr<JITLinkContext> Ctx) {
 491   PassConfiguration Config;
 492
 493   if (Ctx->shouldAddDefaultTargetPasses(G->getTargetTriple())) {
 494     // Construct a JITLinker and run the link function.
 495
 496     // Add eh-frame passes.
 497     Config.PrePrunePasses.push_back(DWARFRecordSectionSplitter(".eh_frame"));
 498     Config.PrePrunePasses.push_back(EHFrameEdgeFixer(
 499         ".eh_frame", G->getPointerSize(), ppc64::Pointer32, ppc64::Pointer64,
 500         ppc64::Delta32, ppc64::Delta64, ppc64::NegDelta32));
 501     Config.PrePrunePasses.push_back(EHFrameNullTerminator(".eh_frame"));
 502
 503     // Add a mark-live pass.
 504     if (auto MarkLive = Ctx->getMarkLivePass(G->getTargetTriple()))
 505       Config.PrePrunePasses.push_back(std::move(MarkLive));
 506     else
 507       Config.PrePrunePasses.push_back(markAllSymbolsLive);
 508   }
 509
 510   Config.PostPrunePasses.push_back(buildTables_ELF_ppc64<Endianness>);
 511
 512   if (auto Err = Ctx->modifyPassConfig(*G, Config))
 513     return Ctx->notifyFailed(std::move(Err));
 514
 515   ELFJITLinker_ppc64<Endianness>::link(std::move(Ctx), std::move(G),
 516                                        std::move(Config));
 517 }
 518
 519 Expected<std::unique_ptr<LinkGraph>>
 520 createLinkGraphFromELFObject_ppc64(MemoryBufferRef ObjectBuffer) {
 521   return createLinkGraphFromELFObject_ppc64<llvm::endianness::big>(
 522       std::move(ObjectBuffer));
 523 }
 524
 525 Expected<std::unique_ptr<LinkGraph>>
 526 createLinkGraphFromELFObject_ppc64le(MemoryBufferRef ObjectBuffer) {
 527   return createLinkGraphFromELFObject_ppc64<llvm::endianness::little>(
 528       std::move(ObjectBuffer));
 529 }
 530
 531 /// jit-link the given object buffer, which must be a ELF ppc64 object file.
 532 void link_ELF_ppc64(std::unique_ptr<LinkGraph> G,
 533                     std::unique_ptr<JITLinkContext> Ctx) {
 534   return link_ELF_ppc64<llvm::endianness::big>(std::move(G), std::move(Ctx));
 535 }
 536
 537 /// jit-link the given object buffer, which must be a ELF ppc64le object file.
 538 void link_ELF_ppc64le(std::unique_ptr<LinkGraph> G,
 539                       std::unique_ptr<JITLinkContext> Ctx) {
 540   return link_ELF_ppc64<llvm::endianness::little>(std::move(G), std::move(Ctx));
 541 }
 542
 543 } // end namespace llvm::jitlink