[ELF2] Add a base set of PPC64 relocations

[hfinkel]

Summary

This is mostly an adaptation of the code in LLVM's lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp, and handles a sufficient number of relocations to link a 'hello world' program on big-Endian PPC64/Linux (ELF v1 ABI) (and said program will even run when a few later patches are also applied).

This is obviously still missing test cases; I'm working on those. Other feedback, and suggestions on which tests to emulate, is certainly appreciated.

[ruiu]

ELF/Target.cpp

213

I'm not entirely sure, but the capitalization rule is usually applyPPCLo (not applyPPClo), no?

213–237

No need for inline. Compilers should take care of them.

215

Arguments must start with uppercase, so Value. But I prefer just V, so that we can write these functions one line.

219

No space before '('

249–250

I wouldn't write zeros beforehand. Instead, you can add as many "0, 0 , 0, ..." as you want at end of Insts to fill the entire space with zeros.

255

Remove this blank line.

264–278

I wouldn't construct Insts. Instead I'd do

write32be(Buf, 0xf810000u); // std %r2 ...
write32be(Buf + 4, 0x3d62000u | apply...)
write32be(Buf + 8, ...

296–300

if (Type != R_PPC64_REL24)
  return false;
return S.isShared() || (S....

304

BaseAddr -> Base

308

Rename Addend -> A, just like the ELF spec.

323

Offset -> Off

326–346

This switch statement enclosed with if-else-if looks a bit weird. Can you remove outer if and just use switch instead?

343–346

You want to move this piece of code just after "uint8_t *Loc = Buf + Offset;" to return early.

368

This style is not in line with others. Please don't put break after }

388

If you can trigger this assertion by giving broken object files, this shouldn't be an assert() but an error().

390

All variable must starts with uppercase.

423–427

Generally we have lots of very similar expressions to calculate relocation values, we want to write them down as simple as possible. So I don't want to use descriptive names for each temporary variables. Please use one-letter variables or don't use variables at all. For example, I'd write this as

int32_t V = int32(SymVA - Base + Off + A);
if (SignExtend32<32>(V) != V)
  error(...)
write32be(Loc, V);

(By the way, the above error check seems odd. It would never fail, no?)

430–432

write64be(Loc, SymVA - BaseAddr - Offset + Addend);

[hfinkel]

ELF/Target.cpp

213

Done.

213–237

Done.

215

Done.

219

Done.

249–250

Done.

255

Done.

264–278

Done.

296–300

Done.

304

BaseAddr is consistent with the names used by the other targets (we can certainly rename them all as a separate change).

308

Done.

323

Done.

326–346

It is done this way to share the addend-adjustment logic. Early-return: done.

368

Done.

388

Done.

390

Done.

423–427

Done.

You're right (I copied these checks from RuntimeDyldELF.cpp, and I should fix them up there as well).

430–432

I've changed everything to use similar short variable names to those that AArch64 uses.

[ruiu]

Can you upload the new patch? Thanks!

[hfinkel]

In D13562#264243, @ruiu wrote:

Can you upload the new patch? Thanks!

Yes; I'm working on some regression tests now.

[hfinkel]

Updated to reflect reviewer comments and add a regression test.

[ruiu]

Can you upload the new patch? Thanks!

ELF/Target.cpp

247

Add a blank line before this line.

247

This class does not use any members of the class, so let's make it a static non-member function.

247

Blank line.

257

Drop 'u' suffix.

260–261

Can this fit in one line if you use a shorter name for EntryOffset?

280

Blank line.

295

Blank line.

341–346

Write like this to remove the outer if.

case R_PPC64_TOC16: Type = R_PPC64_ADDR16; A -= getTocBase(); break;
case ...

355

(R) & ~3 -> R & ~3

357

You don't need {} here. {} is used in switch-case to create a new scope for local variables, but you didn't define any in this {}.

364

Ditto

379

Remove {}

383

Ditto

387

Ditto

388

*(L + 3) -> L[3]

393

Ditto

406

Ditto

410

Ditto

[hfinkel]

Addressed review comments.

[ruiu]

LGTM with nits. Thank you for your work for PPC64!

ELF/Target.cpp

225

You can remove &0xffff because least significant 48 bits are already 0.

228

Ditto

[hfinkel]

r250101, thanks!

ELF/Target.cpp

 //===- Target.cpp ---------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Target.h"
 #include "Error.h"
+#include "OutputSections.h"
 #include "Symbols.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Object/ELF.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/ELF.h"
 
 using namespace llvm;
case R_X86_64_32S:
     break;
   }
   default:
     error(Twine("unrecognized reloc ") + Twine(Type));
     break;
   }
 }
 
+// Relocation masks following the #lo(value), #hi(value), #ha(value),
+// #higher(value), #highera(value), #highest(value), and #highesta(value)
+// macros defined in section 4.5.1. Relocation Types of the PPC-elf64abi
+// document.
+
+static inline uint16_t applyPPClo(uint64_t value) { return value & 0xffff; }
+
+static inline uint16_t applyPPChi(uint64_t value) {
+  return (value >> 16) & 0xffff;
+}
+
+static inline uint16_t applyPPCha (uint64_t value) {
+  return ((value + 0x8000) >> 16) & 0xffff;
+}
+
+static inline uint16_t applyPPChigher(uint64_t value) {
+  return (value >> 32) & 0xffff;
+}
+
+static inline uint16_t applyPPChighera (uint64_t value) {
+  return ((value + 0x8000) >> 32) & 0xffff;
+}
+
+static inline uint16_t applyPPChighest(uint64_t value) {
+  return (value >> 48) & 0xffff;
+}
+
+static inline uint16_t applyPPChighesta (uint64_t value) {
+  return ((value + 0x8000) >> 48) & 0xffff;
+}
+
 PPC64TargetInfo::PPC64TargetInfo() {
-  // PCRelReloc = FIXME
-  // GotReloc = FIXME
+  PCRelReloc = R_PPC64_REL24;
+  GotReloc = R_PPC64_GLOB_DAT;
+  GotRefReloc = R_PPC64_REL64;
   PltEntrySize = 32;
   PageSize = 0x10000;
   VAStart = 0x10000000;
 }
 void PPC64TargetInfo::writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
-                                    uint64_t PltEntryAddr) const {}
+                                    uint64_t PltEntryAddr) const {
+  std::fill(Buf, Buf + getPltEntrySize(), 0);
+
+  // FIXME: See comments in relocateOne.
+  uint64_t GotVA = Out<ELF64BE>::Got->getVA();
+  uint64_t TocVA = GotVA;
+  uint64_t TocBaseVA = TocVA - 0x8000;
+
+  uint64_t EntryOffset = GotEntryAddr - TocBaseVA;
+
+  // FIXME: What we should do, in theory, is get the offset of the function
+  // descriptor in the .opd section, and use that as the offset from %r2 (the
+  // TOC-base pointer). Instead, we have the GOT-entry offset, and that will
+  // be a pointer to the function descriptor in the .opd section. Using
+  // this scheme is simpler, but requires an extra indirection per PLT dispatch.
+
+  const uint32_t Insts[] = {
+    0xf8410000u,                               // std %r2, 40(%r1)
+    0x3d620000u | applyPPCha(EntryOffset),     // addis %r11, %r2, X@ha
+    0xe98b0000u | applyPPClo(EntryOffset),     // ld %r12, X@l(%r11)
+    0xe96c0000u,                               // ld %r11,0(%r12)
+    0x7d6903a6u,                               // mtctr %r11
+    0xe84c0008u,                               // ld %r2,8(%r12)
+    0xe96c0010u,                               // ld %r11,16(%r12)
+    0x4e800420u                                // bctr
+  };
+
+  for (auto InstVal : Insts) {
+    write32be(Buf, InstVal);
+    Buf += 4;
+  }
+}
 bool PPC64TargetInfo::relocNeedsGot(uint32_t Type, const SymbolBody &S) const {
-  return false;
+  if (relocNeedsPlt(Type, S))
+    return true;
+
+  switch (Type) {
+  default: return false;
+  case R_PPC64_GOT16:
+  case R_PPC64_GOT16_LO:
+  case R_PPC64_GOT16_HI:
+  case R_PPC64_GOT16_HA:
+  case R_PPC64_GOT16_DS:
+  case R_PPC64_GOT16_LO_DS:
+    return true;
+  }
 }
 bool PPC64TargetInfo::relocNeedsPlt(uint32_t Type, const SymbolBody &S) const {
-  return false;
+  switch (Type) {
+  default: return false;
+  case R_PPC64_REL24:
+    // These are function calls that need to be redirected through a PLT stub.
+    return S.isShared() || (S.isUndefined() && S.isWeak());
+  }
 }
 void PPC64TargetInfo::relocateOne(uint8_t *Buf, const void *RelP, uint32_t Type,
                                   uint64_t BaseAddr, uint64_t SymVA,
                                   uint64_t GotVA) const {
   typedef ELFFile<ELF64BE>::Elf_Rela Elf_Rela;
   auto &Rel = *reinterpret_cast<const Elf_Rela *>(RelP);
+  int64_t Addend = Rel.r_addend;
+
+  // The TOC consists of sections .got, .toc, .tocbss, .plt in that
+  // order. The TOC starts where the first of these sections starts.
+
+  // FIXME: This obviously does not do the right thing when there is no .got
+  // section!
+  uint64_t TocVA = GotVA;
+
+  // Per the ppc64-elf-linux ABI, The TOC base is TOC value plus 0x8000
+  // thus permitting a full 64 Kbytes segment. Note that the glibc startup
+  // code (crt1.o) assumes that you can get from the TOC base to the
+  // start of the .toc section with only a single (signed) 16-bit relocation.
+  uint64_t TocBaseVA = TocVA - 0x8000;
 
   uint64_t Offset = Rel.r_offset;
   uint8_t *Loc = Buf + Offset;
+
+  if (Type == R_PPC64_TOC16 ||
+      Type == R_PPC64_TOC16_DS ||
+      Type == R_PPC64_TOC16_LO ||
+      Type == R_PPC64_TOC16_LO_DS ||
+      Type == R_PPC64_TOC16_HI ||
+      Type == R_PPC64_TOC16_HA) {
     switch (Type) {
-  case R_PPC64_ADDR64:
-    write64be(Loc, SymVA + Rel.r_addend);
+    case R_PPC64_TOC16:       Type = R_PPC64_ADDR16; break;
+    case R_PPC64_TOC16_DS:    Type = R_PPC64_ADDR16_DS; break;
+    case R_PPC64_TOC16_LO:    Type = R_PPC64_ADDR16_LO; break;
+    case R_PPC64_TOC16_LO_DS: Type = R_PPC64_ADDR16_LO_DS; break;
+    case R_PPC64_TOC16_HI:    Type = R_PPC64_ADDR16_HI; break;
+    case R_PPC64_TOC16_HA:    Type = R_PPC64_ADDR16_HA; break;
+    default: llvm_unreachable("Wrong relocation type.");
+    }
+
+    Addend -= TocBaseVA;
+  } else if (Type == R_PPC64_TOC) {
+    write64be(Loc, TocBaseVA);
+    return;
+  }
+
+  switch (Type) {
+  case R_PPC64_ADDR16:
+    write16be(Loc, applyPPClo(SymVA + Addend));
     break;
-  case R_PPC64_TOC:
-    // We don't create a TOC yet.
+  case R_PPC64_ADDR16_DS: {
+    uint64_t Result = SymVA + Addend;
+    if ((uint64_t) SignExtend32<16>(Result) != Result)
+      error("Relocation R_PPC64_ADDR16_DS overflow");
+
+    uint16_t Mask = ~3;
+    write16be(Loc, (read16be(Loc) & ~Mask) |
+                   (Result & Mask));
+    } break;
+  case R_PPC64_ADDR16_LO:
+    write16be(Loc, applyPPClo(SymVA + Addend));
+    break;
+  case R_PPC64_ADDR16_LO_DS: {
+    uint16_t Mask = ~3;
+    write16be(Loc, (read16be(Loc) & ~Mask) |
+                   (applyPPClo(SymVA + Addend) & Mask));
+    } break;
+  case R_PPC64_ADDR16_HI:
+    write16be(Loc, applyPPChi(SymVA + Addend));
+    break;
+  case R_PPC64_ADDR16_HA:
+    write16be(Loc, applyPPCha(SymVA + Addend));
+    break;
+  case R_PPC64_ADDR16_HIGHER:
+    write16be(Loc, applyPPChigher(SymVA + Addend));
+    break;
+  case R_PPC64_ADDR16_HIGHERA:
+    write16be(Loc, applyPPChighera(SymVA + Addend));
+    break;
+  case R_PPC64_ADDR16_HIGHEST:
+    write16be(Loc, applyPPChighest(SymVA + Addend));
+    break;
+  case R_PPC64_ADDR16_HIGHESTA:
+    write16be(Loc, applyPPChighesta(SymVA + Addend));
+    break;
+  case R_PPC64_ADDR14: {
+    assert(((SymVA + Addend) & 3) == 0);
+    // Preserve the AA/LK bits in the branch instruction
+    uint8_t aalk = *(Loc + 3);
+    write16be(Loc + 2, (aalk & 3) | ((SymVA + Addend) & 0xfffc));
+  } break;
+  case R_PPC64_REL16_LO: {
+    uint64_t FinalAddress = (BaseAddr + Offset);
+    uint64_t Delta = SymVA - FinalAddress + Addend;
+    write16be(Loc, applyPPClo(Delta));
+  } break;
+  case R_PPC64_REL16_HI: {
+    uint64_t FinalAddress = (BaseAddr + Offset);
+    uint64_t Delta = SymVA - FinalAddress + Addend;
+    write16be(Loc, applyPPChi(Delta));
+  } break;
+  case R_PPC64_REL16_HA: {
+    uint64_t FinalAddress = (BaseAddr + Offset);
+    uint64_t Delta = SymVA - FinalAddress + Addend;
+    write16be(Loc, applyPPCha(Delta));
+  } break;
+  case R_PPC64_ADDR32: {
+    int32_t Result = static_cast<int32_t>(SymVA + Addend);
+    if (SignExtend32<32>(Result) != Result)
+      error("Relocation R_PPC64_ADDR32 overflow");
+    write32be(Loc, Result);
+  } break;
+  case R_PPC64_REL24: {
+    uint64_t FinalAddress = (BaseAddr + Offset);
+    int32_t delta = static_cast<int32_t>(SymVA - FinalAddress + Addend);
+    uint32_t Mask = 0x03FFFFFC;
+    if (SignExtend32<24>(delta) != delta)
+      error("Relocation R_PPC64_REL24 overflow");
+    write32be(Loc, (read32be(Loc) & ~Mask) | (delta & Mask));
+  } break;
+  case R_PPC64_REL32: {
+    uint64_t FinalAddress = (BaseAddr + Offset);
+    int32_t delta = static_cast<int32_t>(SymVA - FinalAddress + Addend);
+    if (SignExtend32<32>(delta) != delta)
+      error("Relocation R_PPC64_REL32 overflow");
+    write32be(Loc, delta);
+  } break;
+  case R_PPC64_REL64: {
+    uint64_t FinalAddress = (BaseAddr + Offset);
+    uint64_t Delta = SymVA - FinalAddress + Addend;
+    write64be(Loc, Delta);
+  } break;
+  case R_PPC64_ADDR64:
+    write64be(Loc, SymVA + Addend);
     break;
   default:
     error(Twine("unrecognized reloc ") + Twine(Type));
     break;
   }
 }
 
 PPCTargetInfo::PPCTargetInfo() {