[JITLink][PowerPC] Add basic TLS support for ppc64

[lkail]

Summary

Add basic TLS support for ppc64. Only global-dynamic model is supported.

[lkail]

I'll post another patch to enable ELFNixPlatform support for ppc64. This TLS patch will base on that patch.

[lhames]

LGTM. Thanks @lkail!

[lkail]

Rebased.

compiler-rt/lib/orc/CMakeLists.txt

set(ALL_ORC_SOURCES
   )
 
 # Implementation files for all ORC architectures.
 set(ALL_ORC_ASM_SOURCES
   macho_tlv.x86-64.S
   macho_tlv.arm64.S
   elfnix_tls.x86-64.S
   elfnix_tls.aarch64.S
+  elfnix_tls.ppc64.S
   )
 
 # Common implementation headers will go here.
 set(ORC_COMMON_IMPL_HEADERS
   adt.h
   common.h
   compiler.h
   endianness.h
else()
     set(ORC_SOURCES
       ${ORC_COMMON_SOURCES}
       elfnix_platform.cpp
       )
 
     set(ORC_ASM_SOURCES
       elfnix_tls.x86-64.S
       elfnix_tls.aarch64.S
+      elfnix_tls.ppc64.S
       )
   endif()
 
   foreach(arch ${ORC_SUPPORTED_ARCH})
     if(NOT CAN_TARGET_${arch})
       continue()
     endif()
 

compiler-rt/lib/orc/elfnix_tls.ppc64.S

+//===-- orc_rt_elfnix_tls.ppc64.s -------------------------------*- ASM -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of the ORC runtime support library.
+//
+//===----------------------------------------------------------------------===//
+
+// The content of this file is PowerPC64 only.
+#if defined(__powerpc64__)
+
+  .text
+  // TODO: add fast-path for repeat access.
+  // See https://github.com/llvm/llvm-project/issues/51162.
+  .global ___orc_rt_elfnix_tls_get_addr
+___orc_rt_elfnix_tls_get_addr:
+  addis 2, 12, .TOC.-___orc_rt_elfnix_tls_get_addr@ha
+  addi 2, 2, .TOC.-___orc_rt_elfnix_tls_get_addr@l
+  mflr 0
+  std 0, 16(1)
+  stdu 1, -32(1)
+  bl __orc_rt_elfnix_tls_get_addr_impl
+  nop
+  addi 1, 1, 32
+  ld 0, 16(1)
+  mtlr 0
+  blr
+
+#endif

compiler-rt/test/orc/TestCases/Linux/ppc64/trivial-tls.S

-// XFAIL: target={{powerpc64.*}}
 // RUN: %clang -c -o %t %s
 // RUN: %llvm_jitlink %t
 //
 // Test that basic ELF TLS work by adding together TLSs with values
 // 0, 1, and -1, and returning the result (0 for success). This setup
 // tests both zero-initialized (.tbss) and non-zero-initialized
 // (.tdata) sections.
 

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

enum EdgeKind_ppc64 : Edge::Kind {
   TOCDelta16LODS,
   CallBranchDelta,
   // Need to restore r2 after the bl, suggesting the bl is followed by a nop.
   CallBranchDeltaRestoreTOC,
   // Request calling function with TOC.
   RequestCall,
   // Request calling function without TOC.
   RequestCallNoTOC,
+  RequestTLSDescInGOTAndTransformToTOCDelta16HA,
+  RequestTLSDescInGOTAndTransformToTOCDelta16LO,
 };
 
 enum PLTCallStubKind {
   // Setup function entry(r12) and long branch to target using TOC.
   LongBranch,
   // Save TOC pointer, setup function entry and long branch to target using TOC.
   LongBranchSaveR2,
   // Setup function entry(r12) and long branch to target without using TOC.

llvm/lib/ExecutionEngine/JITLink/ELF_ppc64.cpp

 namespace {
 
 using namespace llvm;
 using namespace llvm::jitlink;
 
 constexpr StringRef ELFTOCSymbolName = ".TOC.";
 constexpr StringRef TOCSymbolAliasIdent = "__TOC__";
 constexpr uint64_t ELFTOCBaseOffset = 0x8000;
+constexpr StringRef ELFTLSInfoSectionName = "$__TLSINFO";
+
+template <support::endianness Endianness>
+class TLSInfoTableManager_ELF_ppc64
+    : public TableManager<TLSInfoTableManager_ELF_ppc64<Endianness>> {
+public:
+  static const uint8_t TLSInfoEntryContent[16];
+
+  static StringRef getSectionName() { return ELFTLSInfoSectionName; }
+
+  bool visitEdge(LinkGraph &G, Block *B, Edge &E) {
+    Edge::Kind K = E.getKind();
+    if (K == ppc64::RequestTLSDescInGOTAndTransformToTOCDelta16HA) {
+      E.setKind(ppc64::TOCDelta16HA);
+      E.setTarget(this->getEntryForTarget(G, E.getTarget()));
+      return true;
+    }
+    if (K == ppc64::RequestTLSDescInGOTAndTransformToTOCDelta16LO) {
+      E.setKind(ppc64::TOCDelta16LO);
+      E.setTarget(this->getEntryForTarget(G, E.getTarget()));
+      return true;
+    }
+    return false;
+  }
+
+  Symbol &createEntry(LinkGraph &G, Symbol &Target) {
+    // The TLS Info entry's key value will be written by
+    // `fixTLVSectionsAndEdges`, so create mutable content.
+    auto &TLSInfoEntry = G.createMutableContentBlock(
+        getTLSInfoSection(G), G.allocateContent(getTLSInfoEntryContent()),
+        orc::ExecutorAddr(), 8, 0);
+    TLSInfoEntry.addEdge(ppc64::Pointer64, 8, Target, 0);
+    return G.addAnonymousSymbol(TLSInfoEntry, 0, 16, false, false);
+  }
+
+private:
+  Section &getTLSInfoSection(LinkGraph &G) {
+    if (!TLSInfoTable)
+      TLSInfoTable =
+          &G.createSection(ELFTLSInfoSectionName, orc::MemProt::Read);
+    return *TLSInfoTable;
+  }
+
+  ArrayRef<char> getTLSInfoEntryContent() const {
+    return {reinterpret_cast<const char *>(TLSInfoEntryContent),
+            sizeof(TLSInfoEntryContent)};
+  }
+
+  Section *TLSInfoTable = nullptr;
+};
+
+template <>
+const uint8_t TLSInfoTableManager_ELF_ppc64<
+    support::endianness::little>::TLSInfoEntryContent[16] = {
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /*pthread key */
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  /*data address*/
+};
+
+template <>
+const uint8_t TLSInfoTableManager_ELF_ppc64<
+    support::endianness::big>::TLSInfoEntryContent[16] = {
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /*pthread key */
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  /*data address*/
+};
 
 template <support::endianness Endianness>
 Symbol &createELFGOTHeader(LinkGraph &G,
                            ppc64::TOCTableManager<Endianness> &TOC) {
   Symbol *TOCSymbol = nullptr;
 
   for (Symbol *Sym : G.defined_symbols())
     if (LLVM_UNLIKELY(Sym->getName() == ELFTOCSymbolName)) {
Error buildTables_ELF_ppc64(LinkGraph &G) {
   //  first TOC base when multiple TOCs are present), followed by an array of
   //  8-byte addresses.
   createELFGOTHeader(G, TOC);
 
   // There might be compiler-generated GOT entries in ELF relocatable file.
   registerExistingGOTEntries(G, TOC);
 
   ppc64::PLTTableManager<Endianness> PLT(TOC);
-  visitExistingEdges(G, TOC, PLT);
-  // TODO: Add TLS support.
+  TLSInfoTableManager_ELF_ppc64<Endianness> TLSInfo;
+  visitExistingEdges(G, TOC, PLT, TLSInfo);
 
   // After visiting edges in LinkGraph, we have GOT entries built in the
   // synthesized section.
   // Merge sections included in TOC into synthesized TOC section,
   // thus TOC is compact and reducing chances of relocation
   // overflow.
   if (Section *TOCSection = G.findSectionByName(TOC.getSectionName())) {
     // .got and .plt are not normally present in a relocatable object file
Error addSingleRelocation(const typename ELFT::Rela &Rel,
                             Block &BlockToFix) {
     using Base = ELFLinkGraphBuilder<ELFT>;
     auto ELFReloc = Rel.getType(false);
 
     // R_PPC64_NONE is a no-op.
     if (LLVM_UNLIKELY(ELFReloc == ELF::R_PPC64_NONE))
       return Error::success();
 
+    // TLS model markers. We only support global-dynamic model now.
+    if (ELFReloc == ELF::R_PPC64_TLSGD)
+      return Error::success();
+    if (ELFReloc == ELF::R_PPC64_TLSLD)
+      return make_error<StringError>("Local-dynamic TLS model is not supported",
+                                     inconvertibleErrorCode());
+
     auto ObjSymbol = Base::Obj.getRelocationSymbol(Rel, Base::SymTabSec);
     if (!ObjSymbol)
       return ObjSymbol.takeError();
 
     uint32_t SymbolIndex = Rel.getSymbol(false);
     Symbol *GraphSymbol = Base::getGraphSymbol(SymbolIndex);
     if (!GraphSymbol)
       return make_error<StringError>(
case ELF::R_PPC64_REL24:
       Addend = ELF::decodePPC64LocalEntryOffset((*ObjSymbol)->st_other);
       break;
     case ELF::R_PPC64_REL64:
       Kind = ppc64::Delta64;
       break;
     case ELF::R_PPC64_PCREL34:
       Kind = ppc64::Delta34;
       break;
+    case ELF::R_PPC64_GOT_TLSGD16_HA:
+      Kind = ppc64::RequestTLSDescInGOTAndTransformToTOCDelta16HA;
+      break;
+    case ELF::R_PPC64_GOT_TLSGD16_LO:
+      Kind = ppc64::RequestTLSDescInGOTAndTransformToTOCDelta16LO;
+      break;
     }
 
     Edge GE(Kind, Offset, *GraphSymbol, Addend);
     BlockToFix.addEdge(std::move(GE));
     return Error::success();
   }
 
 public:

llvm/lib/ExecutionEngine/JITLink/ppc64.cpp

const char *getEdgeKindName(Edge::Kind K) {
   case CallBranchDelta:
     return "CallBranchDelta";
   case CallBranchDeltaRestoreTOC:
     return "CallBranchDeltaRestoreTOC";
   case RequestCall:
     return "RequestCall";
   case RequestCallNoTOC:
     return "RequestCallNoTOC";
+  case RequestTLSDescInGOTAndTransformToTOCDelta16HA:
+    return "RequestTLSDescInGOTAndTransformToTOCDelta16HA";
+  case RequestTLSDescInGOTAndTransformToTOCDelta16LO:
+    return "RequestTLSDescInGOTAndTransformToTOCDelta16LO";
   default:
     return getGenericEdgeKindName(static_cast<Edge::Kind>(K));
   }
 }
 
 } // end namespace llvm::jitlink::ppc64