[ELF] Add basic support for PPC LE

[syzaara]

Summary

This patch adds changes to start supporting the Power 64-Bit ELF V2 ABI. This includes:

• changing the ElfSym::GlobalOffsetTable to be named .TOC. rather than _GLOBAL_OFFSET_TABLE_
• creating a GotHeader so the first entry in the .got is .TOC.
• setting the e_flags to be 1 for ELF V1 and 2 for ELF V2

[ruiu]

lld/ELF/Arch/PPC64.cpp

90

Maybe you should template PPC64 class with ELFT? We do that for MIPS, and it's working fine. By doing that, we can remove this kind of switch completely.

lld/ELF/SyntheticSections.cpp

632–634

Assigning to a value and then immediately returning the value seems odd.

641

Please use clang-format to format a patch.

lld/ELF/Writer.cpp

192–200

Don't you need _GLOBAL_OFFSET_TABLE_ for PPC? If so, why? What is .TOC. and what is a role of the symbol? They need to be explained so that a first-time reader can understand the intention of the code.

[syzaara]

lld/ELF/Arch/PPC64.cpp

90

Our plan is to remove the BE/ELFv1 support so we won't need to template the PPC64 class.

[ruiu]

lld/ELF/Arch/PPC64.cpp

90

Is Hal OK with that?

[sfertile]

lld/ELF/Arch/PPC64.cpp

90

I've pinged Hal about this in IRC but didn't get a response. Hopefully he can chime in here.

I think since we are specifically implementing abi version 2 which (as far as I am aware) is only used on little-endian chips, then it makes sense to make these limitations explicit. Since there is already some functionality for the BE V1 abi, we decided it was best to leave it enabled at the start, but once we could replace all the existing testing with the V2 abi equivalent we would disable/remove the PPC64BE target. That isn't to say that we can't add support for the V1 abi and big-endian later, just that until a conscious effort it made to support the V1 abi as well it we would be best to remove it.

[ruiu]

lld/ELF/Arch/PPC64.cpp

90

I agree with that. There's no point to use a template to make it work for both LE and BE even though we only do support LE. We should also remove BE v1 ABI if it is absolutely necessary because I believe that the current v1 LE ABI support is somewhat incomplete and not really usable for linking regular day-to-day programs.

Could you please leave a comment here saying that we are currently handling both ELF64LE and ELF64BE but eventually we'll remove BE support once v2 ABI support is complete?

I'd wait for Hal's response though.

96–98

If you do like this you could eliminate the reassignments to the local variable.

if (EFlags =
      cast<ObjFile<ELF64BE>>(ObjectFiles[0])->getObj().getHeader()->e_flags)
  return EFlags;
return 1;

[ruiu]

lld/ELF/Writer.cpp

193

It is perhaps more accurate to say that PPC uses a different symbol name for _GLOBAL_OFFSET_TABLE_ and it's called ".TOC.". But I wonder why...

199–200

I'd make it more explicit that we are doing the same thing except choosing the name:

ElfSym::GlobalOffsetTable = addOptionalRegular(
      (Config->EMachine == EM_PPC64) ? ".TOC." : "_GLOBAL_OFFSET_TABLE_",
      Out::ElfHeader, Target->GotBaseSymOff);

[hfinkel]

lld/ELF/Arch/PPC64.cpp

90

I agree. I never had time to get the BE implementation beyond the "hello world" stage (and, evidently, neither did anyone else). Let's remove it, do the LE ABIv2 implementation, and then if we want to add BE ABIv1 support later, we can figure out how to do that at that point.

[ruiu]

lld/ELF/Arch/PPC64.cpp

93

Please remove this and define inside if to narrow the scope of the local variables. There's no point to define a local variable early in C89 style.

99

I mean I'd do this:

if (uint32_t EFlags =

lld/ELF/SyntheticSections.cpp

632–633

This condition is always true on PPC64LE because GotHeaderEntriesNum is set to 1. That means you'll always have a .got even if you are creating static binaries. Is this really correct?

lld/ELF/Writer.cpp

193

Do you know why PPC64LE is using a different name? I mean if you can't find a reason, that's fine, but if that's the case, I'd leave a comment here saying that I don't know why, but .TOC. is defined by PPC64 v2 ABI spec as such, and the spec doesn't say anything about _GLOBAL_OFFSET_TABLE_.

[sfertile]

lld/ELF/Writer.cpp

193

The 32bit ppc elf abi supplement defined small data and small bss sections which held (local) data that could be accessed within a 16 bit offset of a _SDA_BASE_ pointer. In shared objects I think _SDA_BASE_ had the same value as _GLOBAL_OFFSET_TABLE_. In an executable _SDA_BASE_ would be loaded into an abi specified register and that register would hold that value for the life of the program.

The 64-bit PowerOpen ABI defined a TableOfContents (TOC) section which combined the typical elf GOT with the small data sections. The .TOC. symbol replaces both _GLOBAL_OFFSET_TABLE_ and _SDA_BASE_ from the 32bit abi.

There are a couple things related to the TOC we need to document in the PPC64 target:

1. What is the TOC and how it differs from the GOT.
2. The differences between .toc section , .TOC. symbol, Table of Contents (TOC) and TOC Base.
3. How the various code models affect addressing using the TOC.

I would prefer to do these in a subsequent patch, but I think its pretty reasonable to add #1 in this patch if you prefer.

[ruiu]

I'd really appreciate if you add these facts as comments as you add code for ppc64le rather than doing it later, as documentation is sometimes more important than actual code for this kind of low-level stuff that's built on top of a long history. We often find that everybody's doing something (e.g. using a different symbol name for something) but hard to figure out if that's an coincidence, cargo culting, undocumented ABI, or a part of a documented ABI. Writing a comment with a bit of background history will be extremely useful when we will have to revisit code we are writing today. In fact, I think we should write patches as if we were not only writing code but a book describing what the linker is.

[sfertile]

In D44483#1039369, @ruiu wrote:

I'd really appreciate if you add these facts as comments as you add code for ppc64le rather than doing it later, as documentation is sometimes more important than actual code for this kind of low-level stuff that's built on top of a long history. We often find that everybody's doing something (e.g. using a different symbol name for something) but hard to figure out if that's an coincidence, cargo culting, undocumented ABI, or a part of a documented ABI. Writing a comment with a bit of background history will be extremely useful when we will have to revisit code we are writing today. In fact, I think we should write patches as if we were not only writing code but a book describing what the linker is.

I think thats a great way to look at it. The reason we were holding off on adding some of that documentation is because we have a good understanding of the current (V2) ABI, so we know how things work today, but we really don't have any of the historical knowledge so we don't really know why the abi chooses to do these things differently. I agree with your reasoning though, we are better off to document what we know now and then we can always refine it in later patches.

[syzaara]

lld/ELF/SyntheticSections.cpp

632–633

This is incorrect, we only want to have .got if the .TOC. symbol is used which is already handled in the if statement with !(ElfSym::GlobalOffsetTable && !Target->GotBaseSymInGotPlt);

[ruiu]

LGTM

I think thats a great way to look at it. The reason we were holding off on adding some of that documentation is because we have a good understanding of the current (V2) ABI, so we know how things work today, but we really don't have any of the historical knowledge so we don't really know why the abi chooses to do these things differently. I agree with your reasoning though, we are better off to document what we know now and then we can always refine it in later patches.

Thank you for your understanding. We don't have to figure out and justify every detail of the spec because some facts have really been lost in history, but still, writing honest comments about what we know and don't know today will be extremely useful in the future. For example, instead of just saying "_GLOBAL_OFFSET_TABLE_ is not defined in ppc but we have .TOC instead", we can say (I don't think the statement is correct, but as an example) "_GLOBAL_OFFSET_TABLE_ is not defined in ppc but we have .TOC instead. These symbols serve a similar purpose, and .TOC. is defined as +0x8000 from the beginning global offset table. We don't know the exact reason why ppc defined its own symbol name instead of using _GLOBAL_OFFSET_TABLE_, but that existed from the first version of PPC ABI, so we need to define that symbol." I really like that kind of comment because it is more convincing to me that the author of the code understood what they were doing.

Anyways, thank you for the first patch! Please submit.

lld/ELF/Arch/PPC64.cpp

 //===- PPC64.cpp ----------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Symbols.h"
 #include "SyntheticSections.h"
 #include "Target.h"
 #include "lld/Common/ErrorHandler.h"
 #include "llvm/Support/Endian.h"
 
 using namespace llvm;
+using namespace llvm::object;
+using namespace llvm::support::endian;
 using namespace llvm::ELF;
 using namespace lld;
 using namespace lld::elf;
 
 static uint64_t PPC64TocOffset = 0x8000;
 
 uint64_t elf::getPPC64TocBase() {
   // The TOC consists of sections .got, .toc, .tocbss, .plt in that order. The
   // TOC starts where the first of these sections starts. We always create a
   // .got when we see a relocation that uses it, so for us the start is always
   // the .got.
   uint64_t TocVA = InX::Got->getVA();
 
   // 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.
   return TocVA + PPC64TocOffset;
 }
 
 namespace {
 class PPC64 final : public TargetInfo {
 public:
   PPC64();
+  uint32_t calcEFlags() const override;
   RelExpr getRelExpr(RelType Type, const Symbol &S,
                      const uint8_t *Loc) const override;
   void writePlt(uint8_t *Buf, uint64_t GotPltEntryAddr, uint64_t PltEntryAddr,
                 int32_t Index, unsigned RelOff) const override;
   void relocateOne(uint8_t *Loc, RelType Type, uint64_t Val) const override;
+  void writeGotHeader(uint8_t *Buf) const override;
 };
 } // namespace
 
 // 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 uint16_t applyPPCLo(uint64_t V) { return V; }
 static uint16_t applyPPCHi(uint64_t V) { return V >> 16; }
 static uint16_t applyPPCHa(uint64_t V) { return (V + 0x8000) >> 16; }
 static uint16_t applyPPCHigher(uint64_t V) { return V >> 32; }
 static uint16_t applyPPCHighera(uint64_t V) { return (V + 0x8000) >> 32; }
 static uint16_t applyPPCHighest(uint64_t V) { return V >> 48; }
 static uint16_t applyPPCHighesta(uint64_t V) { return (V + 0x8000) >> 48; }
 
 PPC64::PPC64() {
   PltRel = GotRel = R_PPC64_GLOB_DAT;
   RelativeRel = R_PPC64_RELATIVE;
   GotEntrySize = 8;
   GotPltEntrySize = 8;
   PltEntrySize = 32;
   PltHeaderSize = 0;
+  if (Config->EKind == ELF64LEKind)
+    GotHeaderEntriesNum = 1;
 
   // We need 64K pages (at least under glibc/Linux, the loader won't
   // set different permissions on a finer granularity than that).
   DefaultMaxPageSize = 65536;
 
   // The PPC64 ELF ABI v1 spec, says:
   //
   //   It is normally desirable to put segments with different characteristics
   //   in separate 256 Mbyte portions of the address space, to give the
   //   operating system full paging flexibility in the 64-bit address space.
   //
   // And because the lowest non-zero 256M boundary is 0x10000000, PPC64 linkers
   // use 0x10000000 as the starting address.
   DefaultImageBase = 0x10000000;
 }
 
+static uint32_t getEFlags(InputFile *File) {
+  // Get the e_flag from the input file and if it is unspecified, then set it to
+  // the e_flag appropriate for the ABI.
+  uint32_t EFlags = 0;
+  switch (Config->EKind) {
+  case ELF64BEKind:
+    EFlags =
+        cast<ObjFile<ELF64BE>>(ObjectFiles[0])->getObj().getHeader()->e_flags;
+    return EFlags == 0 ? 1 : EFlags;
+  case ELF64LEKind:
+    EFlags =
+        cast<ObjFile<ELF64LE>>(ObjectFiles[0])->getObj().getHeader()->e_flags;
+    return EFlags == 0 ? 2 : EFlags;
+  default:
+    llvm_unreachable("unknown Config->EKind");
+  }
+}
+
+uint32_t PPC64::calcEFlags() const {
+  assert(!ObjectFiles.empty());
+  uint32_t Ret = getEFlags(ObjectFiles[0]);
+
+  // Verify that all input files have the same e_flags.
+  for (InputFile *F : makeArrayRef(ObjectFiles).slice(1)) {
+    if (Ret == getEFlags(F))
+      continue;
+    error("incompatible e_flags: " + toString(F));
+    return 0;
+  }
+  return Ret;
+}
+
 RelExpr PPC64::getRelExpr(RelType Type, const Symbol &S,
                           const uint8_t *Loc) const {
   switch (Type) {
   case R_PPC64_TOC16:
   case R_PPC64_TOC16_DS:
   case R_PPC64_TOC16_HA:
   case R_PPC64_TOC16_HI:
   case R_PPC64_TOC16_LO:
   case R_PPC64_TOC16_LO_DS:
     return R_GOTREL;
   case R_PPC64_TOC:
     return R_PPC_TOC;
   case R_PPC64_REL24:
     return R_PPC_PLT_OPD;
   default:
     return R_ABS;
   }
 }
 
+void PPC64::writeGotHeader(uint8_t *Buf) const {
+  if (Config->EKind == ELF64LEKind)
+    write64(Buf, getPPC64TocBase());
+}
+
 void PPC64::writePlt(uint8_t *Buf, uint64_t GotPltEntryAddr,
                      uint64_t PltEntryAddr, int32_t Index,
                      unsigned RelOff) const {
   uint64_t Off = GotPltEntryAddr - getPPC64TocBase();
 
   // 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

lld/ELF/SyntheticSections.cpp

for (EhInputSection *S : Sections)
     S->relocateAlloc(Buf, nullptr);
 }
 
 GotSection::GotSection()
     : SyntheticSection(SHF_ALLOC | SHF_WRITE, SHT_PROGBITS,
                        Target->GotEntrySize, ".got") {}
 
 void GotSection::addEntry(Symbol &Sym) {
-  Sym.GotIndex = NumEntries;
+  Sym.GotIndex = Target->GotHeaderEntriesNum + NumEntries;
   ++NumEntries;
 }
 
 bool GotSection::addDynTlsEntry(Symbol &Sym) {
   if (Sym.GlobalDynIndex != -1U)
     return false;
   Sym.GlobalDynIndex = NumEntries;
   // Global Dynamic TLS entries take two GOT slots.

 uint64_t GotSection::getGlobalDynAddr(const Symbol &B) const {
   return this->getVA() + B.GlobalDynIndex * Config->Wordsize;
 }
 
 uint64_t GotSection::getGlobalDynOffset(const Symbol &B) const {
   return B.GlobalDynIndex * Config->Wordsize;
 }
 
-void GotSection::finalizeContents() { Size = NumEntries * Config->Wordsize; }
+void GotSection::finalizeContents() {
+  Size = (NumEntries + Target->GotHeaderEntriesNum) * Config->Wordsize;
+}
 
 bool GotSection::empty() const {
   // We need to emit a GOT even if it's empty if there's a relocation that is
   // relative to GOT(such as GOTOFFREL) or there's a symbol that points to a GOT
   // (i.e. _GLOBAL_OFFSET_TABLE_) that the target defines relative to the .got.
-  return NumEntries == 0 && !HasGotOffRel &&
-         !(ElfSym::GlobalOffsetTable && !Target->GotBaseSymInGotPlt);
+  return (NumEntries == 0 && !Target->GotHeaderEntriesNum) && !HasGotOffRel &&
+         !ElfSym::GlobalOffsetTable;
 }
 
 void GotSection::writeTo(uint8_t *Buf) {
   // Buf points to the start of this section's buffer,
   // whereas InputSectionBase::relocateAlloc() expects its argument
   // to point to the start of the output section.
+  Target->writeGotHeader(Buf);
+  Buf += Target->GotHeaderEntriesNum * Target->GotEntrySize;
   relocateAlloc(Buf - OutSecOff, Buf - OutSecOff + Size);
 }
 
 MipsGotSection::MipsGotSection()
     : SyntheticSection(SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL, SHT_PROGBITS, 16,
                        ".got") {}
 
 void MipsGotSection::addEntry(Symbol &Sym, int64_t Addend, RelExpr Expr) {

lld/ELF/Target.h

 class Symbol;
 
 class TargetInfo {
 public:
   virtual uint32_t calcEFlags() const { return 0; }
   virtual bool isPicRel(RelType Type) const { return true; }
   virtual RelType getDynRel(RelType Type) const { return Type; }
   virtual void writeGotPltHeader(uint8_t *Buf) const {}
+  virtual void writeGotHeader(uint8_t *Buf) const {}
   virtual void writeGotPlt(uint8_t *Buf, const Symbol &S) const {};
   virtual void writeIgotPlt(uint8_t *Buf, const Symbol &S) const;
   virtual int64_t getImplicitAddend(const uint8_t *Buf, RelType Type) const;
 
   // If lazy binding is supported, the first entry of the PLT has code
   // to call the dynamic linker to resolve PLT entries the first time
   // they are called. This function writes that code.
   virtual void writePltHeader(uint8_t *Buf) const {}
public:
   unsigned GotPltEntrySize = 0;
   unsigned PltEntrySize;
   unsigned PltHeaderSize;
 
   // At least on x86_64 positions 1 and 2 are used by the first plt entry
   // to support lazy loading.
   unsigned GotPltHeaderEntriesNum = 3;
 
+  // On PPC ELF V2 abi, the first entry in the .got is the .TOC.
+  unsigned GotHeaderEntriesNum = 0;
+
   // Set to 0 for variant 2
   unsigned TcbSize = 0;
 
   bool NeedsThunks = false;
 
   // A 4-byte field corresponding to one or more trap instructions, used to pad
   // executable OutputSections.
   uint32_t TrapInstr = 0;

lld/ELF/Writer.cpp

if (Config->EMachine == EM_MIPS) {
     // The __gnu_local_gp is a magic symbol equal to the current value of 'gp'
     // pointer. This symbol is used in the code generated by .cpload pseudo-op
     // in case of using -mno-shared option.
     // https://sourceware.org/ml/binutils/2004-12/msg00094.html
     if (Symtab->find("__gnu_local_gp"))
       ElfSym::MipsLocalGp =
           Symtab->addAbsolute("__gnu_local_gp", STV_HIDDEN, STB_GLOBAL);
   }
 
+  // PPC64 does not define any _GLOBAL_OFFSET_TABLE_ symbol. Instead it uses the
+  // symbol .TOC. which points to the .got section + GotBaseSymOff.
+  if (Config->EMachine == EM_PPC64)
+    ElfSym::GlobalOffsetTable =
+        addOptionalRegular(".TOC.", Out::ElfHeader, Target->GotBaseSymOff);
+  else
     ElfSym::GlobalOffsetTable = addOptionalRegular(
         "_GLOBAL_OFFSET_TABLE_", Out::ElfHeader, Target->GotBaseSymOff);
 
   // __ehdr_start is the location of ELF file headers. Note that we define
   // this symbol unconditionally even when using a linker script, which
   // differs from the behavior implemented by GNU linker which only define
   // this symbol if ELF headers are in the memory mapped segment.
   // __executable_start is not documented, but the expectation of at
   // least the android libc is that it points to the elf header too.
   // __dso_handle symbol is passed to cxa_finalize as a marker to identify

lld/test/ELF/basic-ppc64.s

+# # RUN: llvm-mc -filetype=obj -triple=powerpc64le-unknown-linux %s -o %t
+# RUN: ld.lld --hash-style=sysv -discard-all -shared %t -o %t2
+# RUN: llvm-readobj -file-headers -sections -section-data -program-headers %t2 | FileCheck %s
+# REQUIRES: ppc
+.abiversion 2
+# Exits with return code 55 on linux.
+.text
+  li 0,1
+  li 3,55
+  sc
+
+// CHECK: Format: ELF64-ppc64
+// CHECK-NEXT: Arch: powerpc64le
+// CHECK-NEXT: AddressSize: 64bit
+// CHECK-NEXT: LoadName:
+// CHECK-NEXT: ElfHeader {
+// CHECK-NEXT:   Ident {
+// CHECK-NEXT:     Magic: (7F 45 4C 46)
+// CHECK-NEXT:     Class: 64-bit (0x2)
+// CHECK-NEXT:     DataEncoding: LittleEndian (0x1)
+// CHECK-NEXT:     FileVersion: 1
+// CHECK-NEXT:     OS/ABI: SystemV (0x0)
+// CHECK-NEXT:     ABIVersion: 0
+// CHECK-NEXT:     Unused: (00 00 00 00 00 00 00)
+// CHECK-NEXT:   }
+// CHECK-NEXT:   Type: SharedObject (0x3)
+// CHECK-NEXT:   Machine: EM_PPC64 (0x15)
+// CHECK-NEXT:   Version: 1
+// CHECK-NEXT:   Entry: 0x10000
+// CHECK-NEXT:   ProgramHeaderOffset: 0x40
+// CHECK-NEXT:   SectionHeaderOffset: 0x200F8
+// CHECK-NEXT:   Flags [ (0x2)
+// CHECK-NEXT:     0x2
+// CHECK-NEXT:   ]
+// CHECK-NEXT:   HeaderSize: 64
+// CHECK-NEXT:   ProgramHeaderEntrySize: 56
+// CHECK-NEXT:   ProgramHeaderCount: 7
+// CHECK-NEXT:   SectionHeaderEntrySize: 64
+// CHECK-NEXT:   SectionHeaderCount: 11
+// CHECK-NEXT:   StringTableSectionIndex: 9
+// CHECK-NEXT: }
+// CHECK-NEXT: Sections [
+// CHECK-NEXT:   Section {
+// CHECK-NEXT:     Index: 0
+// CHECK-NEXT:     Name:  (0)
+// CHECK-NEXT:     Type: SHT_NULL (0x0)
+// CHECK-NEXT:     Flags [ (0x0)
+// CHECK-NEXT:     ]
+// CHECK-NEXT:     Address: 0x0
+// CHECK-NEXT:     Offset: 0x0
+// CHECK-NEXT:     Size: 0
+// CHECK-NEXT:     Link: 0
+// CHECK-NEXT:     Info: 0
+// CHECK-NEXT:     AddressAlignment: 0
+// CHECK-NEXT:     EntrySize: 0
+// CHECK-NEXT:     SectionData (
+// CHECK-NEXT:     )
+// CHECK-NEXT:   }
+// CHECK-NEXT:   Section {
+// CHECK-NEXT:     Index: 1
+// CHECK-NEXT:     Name: .dynsym (1)
+// CHECK-NEXT:     Type: SHT_DYNSYM (0xB)
+// CHECK-NEXT:     Flags [ (0x2)
+// CHECK-NEXT:       SHF_ALLOC (0x2)
+// CHECK-NEXT:     ]
+// CHECK-NEXT:     Address: 0x1C8
+// CHECK-NEXT:     Offset: 0x1C8
+// CHECK-NEXT:     Size: 24
+// CHECK-NEXT:     Link: 3
+// CHECK-NEXT:     Info: 1
+// CHECK-NEXT:     AddressAlignment: 8
+// CHECK-NEXT:     EntrySize: 24
+// CHECK-NEXT:     SectionData (
+// CHECK-NEXT:       0000: 00000000 00000000 00000000 00000000  |................|
+// CHECK-NEXT:       0010: 00000000 00000000                    |........|
+// CHECK-NEXT:     )
+// CHECK-NEXT:   }
+// CHECK-NEXT:   Section {
+// CHECK-NEXT:     Index: 2
+// CHECK-NEXT:     Name: .hash (9)
+// CHECK-NEXT:     Type: SHT_HASH (0x5)
+// CHECK-NEXT:     Flags [ (0x2)
+// CHECK-NEXT:       SHF_ALLOC (0x2)
+// CHECK-NEXT:     ]
+// CHECK-NEXT:     Address: 0x1E0
+// CHECK-NEXT:     Offset: 0x1E0
+// CHECK-NEXT:     Size: 16
+// CHECK-NEXT:     Link: 1
+// CHECK-NEXT:     Info: 0
+// CHECK-NEXT:     AddressAlignment: 4
+// CHECK-NEXT:     EntrySize: 4
+// CHECK-NEXT:     SectionData (
+// CHECK-NEXT:       0000: 01000000 01000000 00000000 00000000  |................|
+// CHECK-NEXT:     )
+// CHECK-NEXT:   }
+// CHECK-NEXT:   Section {
+// CHECK-NEXT:     Index: 3
+// CHECK-NEXT:     Name: .dynstr (15)
+// CHECK-NEXT:     Type: SHT_STRTAB (0x3)
+// CHECK-NEXT:     Flags [ (0x2)
+// CHECK-NEXT:       SHF_ALLOC (0x2)
+// CHECK-NEXT:     ]
+// CHECK-NEXT:     Address: 0x1F0
+// CHECK-NEXT:     Offset: 0x1F0
+// CHECK-NEXT:     Size: 1
+// CHECK-NEXT:     Link: 0
+// CHECK-NEXT:     Info: 0
+// CHECK-NEXT:     AddressAlignment: 1
+// CHECK-NEXT:     EntrySize: 0
+// CHECK-NEXT:     SectionData (
+// CHECK-NEXT:       0000: 00                                   |.|
+// CHECK-NEXT:     )
+// CHECK-NEXT:   }
+// CHECK-NEXT:   Section {
+// CHECK-NEXT:     Index: 4
+// CHECK-NEXT:     Name: .text (23)
+// CHECK-NEXT:     Type: SHT_PROGBITS (0x1)
+// CHECK-NEXT:     Flags [ (0x6)
+// CHECK-NEXT:       SHF_ALLOC (0x2)
+// CHECK-NEXT:       SHF_EXECINSTR (0x4)
+// CHECK-NEXT:     ]
+// CHECK-NEXT:     Address: 0x10000
+// CHECK-NEXT:     Offset: 0x10000
+// CHECK-NEXT:     Size: 12
+// CHECK-NEXT:     Link: 0
+// CHECK-NEXT:     Info: 0
+// CHECK-NEXT:     AddressAlignment: 4
+// CHECK-NEXT:     EntrySize: 0
+// CHECK-NEXT:     SectionData (
+// CHECK-NEXT:       0000: 01000038 37006038 02000044           |...87.`8...D|
+// CHECK-NEXT:     )
+// CHECK-NEXT:   }
+// CHECK-NEXT:   Section {
+// CHECK-NEXT:     Index: 5
+// CHECK-NEXT:     Name: .dynamic (29)
+// CHECK-NEXT:     Type: SHT_DYNAMIC (0x6)
+// CHECK-NEXT:     Flags [ (0x3)
+// CHECK-NEXT:       SHF_ALLOC (0x2)
+// CHECK-NEXT:       SHF_WRITE (0x1)
+// CHECK-NEXT:     ]
+// CHECK-NEXT:     Address: 0x20000
+// CHECK-NEXT:     Offset: 0x20000
+// CHECK-NEXT:     Size: 96
+// CHECK-NEXT:     Link: 3
+// CHECK-NEXT:     Info: 0
+// CHECK-NEXT:     AddressAlignment: 8
+// CHECK-NEXT:     EntrySize: 16
+// CHECK-NEXT:     SectionData (
+// CHECK-NEXT:       0000: 06000000 00000000 C8010000 00000000  |................|
+// CHECK-NEXT:       0010: 0B000000 00000000 18000000 00000000  |................|
+// CHECK-NEXT:       0020: 05000000 00000000 F0010000 00000000  |................|
+// CHECK-NEXT:       0030: 0A000000 00000000 01000000 00000000  |................|
+// CHECK-NEXT:       0040: 04000000 00000000 E0010000 00000000  |................|
+// CHECK-NEXT:       0050: 00000000 00000000 00000000 00000000  |................|
+// CHECK-NEXT:     )
+// CHECK-NEXT:   }
+// CHECK-NEXT:   Section {
+// CHECK-NEXT:     Index: 6
+// CHECK-NEXT:     Name: .got (38)
+// CHECK-NEXT:     Type: SHT_PROGBITS (0x1)
+// CHECK-NEXT:     Flags [ (0x3)
+// CHECK-NEXT:       SHF_ALLOC (0x2)
+// CHECK-NEXT:       SHF_WRITE (0x1)
+// CHECK-NEXT:     ]
+// CHECK-NEXT:     Address: 0x20060
+// CHECK-NEXT:     Offset: 0x20060
+// CHECK-NEXT:     Size: 8
+// CHECK-NEXT:     Link: 0
+// CHECK-NEXT:     Info: 0
+// CHECK-NEXT:     AddressAlignment: 8
+// CHECK-NEXT:     EntrySize: 0
+// CHECK-NEXT:     SectionData (
+// CHECK-NEXT:       0000: 60800200 00000000                    |`.......|
+// CHECK-NEXT:     )
+// CHECK-NEXT:   }
+// CHECK-NEXT:  Section {
+// CHECK-NEXT:    Index: 7
+// CHECK-NEXT:    Name: .comment (43)
+// CHECK-NEXT:    Type: SHT_PROGBITS (0x1)
+// CHECK-NEXT:    Flags [ (0x30)
+// CHECK-NEXT:      SHF_MERGE (0x10)
+// CHECK-NEXT:      SHF_STRINGS (0x20)
+// CHECK-NEXT:    ]
+// CHECK-NEXT:    Address: 0x0
+// CHECK-NEXT:    Offset: 0x20068
+// CHECK-NEXT:    Size: 8
+// CHECK-NEXT:    Link: 0
+// CHECK-NEXT:    Info: 0
+// CHECK-NEXT:    AddressAlignment: 1
+// CHECK-NEXT:    EntrySize: 1
+// CHECK-NEXT:    SectionData (
+// CHECK-NEXT:      0000: 4C4C4420 312E3000                    |LLD 1.0.|
+// CHECK-NEXT:    )
+// CHECK-NEXT:  }
+// CHECK-NEXT:   Section {
+// CHECK-NEXT:     Index: 8
+// CHECK-NEXT:     Name: .symtab (52)
+// CHECK-NEXT:     Type: SHT_SYMTAB (0x2)
+// CHECK-NEXT:     Flags [ (0x0)
+// CHECK-NEXT:     ]
+// CHECK-NEXT:     Address: 0x0
+// CHECK-NEXT:     Offset: 0x20070
+// CHECK-NEXT:     Size: 48
+// CHECK-NEXT:     Link: 10
+// CHECK-NEXT:     Info: 2
+// CHECK-NEXT:     AddressAlignment: 8
+// CHECK-NEXT:     EntrySize: 24
+// CHECK-NEXT:     SectionData (
+// CHECK-NEXT:       0000: 00000000 00000000 00000000 00000000  |................|
+// CHECK-NEXT:       0010: 00000000 00000000 01000000 00020500  |................|
+// CHECK-NEXT:       0020: 00000200 00000000 00000000 00000000  |................|
+// CHECK-NEXT:     )
+// CHECK-NEXT:   }
+// CHECK-NEXT:   Section {
+// CHECK-NEXT:     Index: 9
+// CHECK-NEXT:     Name: .shstrtab (60)
+// CHECK-NEXT:     Type: SHT_STRTAB (0x3)
+// CHECK-NEXT:     Flags [ (0x0)
+// CHECK-NEXT:     ]
+// CHECK-NEXT:     Address: 0x0
+// CHECK-NEXT:     Offset: 0x200A0
+// CHECK-NEXT:     Size: 78
+// CHECK-NEXT:     Link: 0
+// CHECK-NEXT:     Info: 0
+// CHECK-NEXT:     AddressAlignment: 1
+// CHECK-NEXT:     EntrySize: 0
+// CHECK-NEXT:     SectionData (
+// CHECK-NEXT:       0000: 002E6479 6E73796D 002E6861 7368002E  |..dynsym..hash..|
+// CHECK-NEXT:       0010: 64796E73 7472002E 74657874 002E6479  |dynstr..text..dy|
+// CHECK-NEXT:       0020: 6E616D69 63002E67 6F74002E 636F6D6D  |namic..got..comm|
+// CHECK-NEXT:       0030: 656E7400 2E73796D 74616200 2E736873  |ent..symtab..shs|
+// CHECK-NEXT:       0040: 74727461 62002E73 74727461 6200      |trtab..strtab.|
+// CHECK-NEXT:     )
+// CHECK-NEXT:   }
+// CHECK-NEXT:   Section {
+// CHECK-NEXT:     Index: 10
+// CHECK-NEXT:     Name: .strtab (70)
+// CHECK-NEXT:     Type: SHT_STRTAB (0x3)
+// CHECK-NEXT:     Flags [ (0x0)
+// CHECK-NEXT:     ]
+// CHECK-NEXT:     Address: 0x0
+// CHECK-NEXT:     Offset: 0x200EE
+// CHECK-NEXT:     Size: 10
+// CHECK-NEXT:     Link: 0
+// CHECK-NEXT:     Info: 0
+// CHECK-NEXT:     AddressAlignment: 1
+// CHECK-NEXT:     EntrySize: 0
+// CHECK-NEXT:     SectionData (
+// CHECK-NEXT:       0000: 005F4459 4E414D49 4300               |._DYNAMIC.|
+// CHECK-NEXT:     )
+// CHECK-NEXT:   }
+// CHECK-NEXT: ]
+// CHECK-NEXT: ProgramHeaders [
+// CHECK-NEXT:   ProgramHeader {
+// CHECK-NEXT:     Type: PT_PHDR (0x6)
+// CHECK-NEXT:     Offset: 0x40
+// CHECK-NEXT:     VirtualAddress: 0x40
+// CHECK-NEXT:     PhysicalAddress: 0x40
+// CHECK-NEXT:     FileSize: 392
+// CHECK-NEXT:     MemSize: 392
+// CHECK-NEXT:     Flags [ (0x4)
+// CHECK-NEXT:       PF_R (0x4)
+// CHECK-NEXT:     ]
+// CHECK-NEXT:     Alignment: 8
+// CHECK-NEXT:   }
+// CHECK-NEXT:   ProgramHeader {
+// CHECK-NEXT:     Type: PT_LOAD (0x1)
+// CHECK-NEXT:     Offset: 0x0
+// CHECK-NEXT:     VirtualAddress: 0x0
+// CHECK-NEXT:     PhysicalAddress: 0x0
+// CHECK-NEXT:     FileSize: 497
+// CHECK-NEXT:     MemSize: 497
+// CHECK-NEXT:     Flags [ (0x4)
+// CHECK-NEXT:       PF_R (0x4)
+// CHECK-NEXT:     ]
+// CHECK-NEXT:     Alignment: 65536
+// CHECK-NEXT:   }
+// CHECK-NEXT:   ProgramHeader {
+// CHECK-NEXT:     Type: PT_LOAD (0x1)
+// CHECK-NEXT:     Offset: 0x10000
+// CHECK-NEXT:     VirtualAddress: 0x10000
+// CHECK-NEXT:     PhysicalAddress: 0x10000
+// CHECK-NEXT:     FileSize: 12
+// CHECK-NEXT:     MemSize: 12
+// CHECK-NEXT:     Flags [ (0x5)
+// CHECK-NEXT:       PF_R (0x4)
+// CHECK-NEXT:       PF_X (0x1)
+// CHECK-NEXT:     ]
+// CHECK-NEXT:     Alignment: 65536
+// CHECK-NEXT:   }
+// CHECK-NEXT:   ProgramHeader {
+// CHECK-NEXT:     Type: PT_LOAD (0x1)
+// CHECK-NEXT:     Offset: 0x20000
+// CHECK-NEXT:     VirtualAddress: 0x20000
+// CHECK-NEXT:     PhysicalAddress: 0x20000
+// CHECK-NEXT:     FileSize: 104
+// CHECK-NEXT:     MemSize: 104
+// CHECK-NEXT:     Flags [ (0x6)
+// CHECK-NEXT:       PF_R (0x4)
+// CHECK-NEXT:       PF_W (0x2)
+// CHECK-NEXT:     ]
+// CHECK-NEXT:     Alignment: 65536
+// CHECK-NEXT:   }
+// CHECK-NEXT:   ProgramHeader {
+// CHECK-NEXT:     Type: PT_DYNAMIC (0x2)
+// CHECK-NEXT:     Offset: 0x20000
+// CHECK-NEXT:     VirtualAddress: 0x20000
+// CHECK-NEXT:     PhysicalAddress: 0x20000
+// CHECK-NEXT:     FileSize: 96
+// CHECK-NEXT:     MemSize: 96
+// CHECK-NEXT:     Flags [ (0x6)
+// CHECK-NEXT:       PF_R (0x4)
+// CHECK-NEXT:       PF_W (0x2)
+// CHECK-NEXT:     ]
+// CHECK-NEXT:     Alignment: 8
+// CHECK-NEXT:   }
+// CHECK-NEXT:   ProgramHeader {
+// CHECK-NEXT:     Type: PT_GNU_RELRO (0x6474E552)
+// CHECK-NEXT:     Offset: 0x20000
+// CHECK-NEXT:     VirtualAddress: 0x20000
+// CHECK-NEXT:     PhysicalAddress: 0x20000
+// CHECK-NEXT:     FileSize: 104
+// CHECK-NEXT:     MemSize: 4096
+// CHECK-NEXT:     Flags [ (0x4)
+// CHECK-NEXT:       PF_R (0x4)
+// CHECK-NEXT:     ]
+// CHECK-NEXT:     Alignment: 1
+// CHECK-NEXT:   }
+// CHECK-NEXT:   ProgramHeader {
+// CHECK-NEXT:     Type: PT_GNU_STACK (0x6474E551)
+// CHECK-NEXT:     Offset: 0x0
+// CHECK-NEXT:     VirtualAddress: 0x0
+// CHECK-NEXT:     PhysicalAddress: 0x0
+// CHECK-NEXT:     FileSize: 0
+// CHECK-NEXT:     MemSize: 0
+// CHECK-NEXT:     Flags [ (0x6)
+// CHECK-NEXT:       PF_R (0x4)
+// CHECK-NEXT:       PF_W (0x2)
+// CHECK-NEXT:     ]
+// CHECK-NEXT:     Alignment: 0
+// CHECK-NEXT:   }
+// CHECK-NEXT: ]

lld/test/ELF/basic64be.s

 # CHECK-NEXT:     Unused: (00 00 00 00 00 00 00)
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Type: Executable (0x2)
 # CHECK-NEXT:   Machine: EM_PPC64 (0x15)
 # CHECK-NEXT:   Version: 1
 # CHECK-NEXT:   Entry: 0x10020040
 # CHECK-NEXT:   ProgramHeaderOffset: 0x40
 # CHECK-NEXT:   SectionHeaderOffset: 0x30080
-# CHECK-NEXT:   Flags [ (0x0)
+# CHECK-NEXT:   Flags [ (0x1)
+# CHECK-NEXT:    0x1
 # CHECK-NEXT:   ]
 # CHECK-NEXT:   HeaderSize: 64
 # CHECK-NEXT:   ProgramHeaderEntrySize: 56
 # CHECK-NEXT:   ProgramHeaderCount: 6
 # CHECK-NEXT:   SectionHeaderEntrySize: 64
 # CHECK-NEXT:   SectionHeaderCount: 10
 # CHECK-NEXT:   StringTableSectionIndex: 8
 # CHECK-NEXT: }

lld/test/ELF/emulation.s

 # PPC64-NEXT:     Unused: (00 00 00 00 00 00 00)
 # PPC64-NEXT:   }
 # PPC64-NEXT:   Type: Executable (0x2)
 # PPC64-NEXT:   Machine: EM_PPC64 (0x15)
 # PPC64-NEXT:   Version: 1
 # PPC64-NEXT:   Entry:
 # PPC64-NEXT:   ProgramHeaderOffset: 0x40
 # PPC64-NEXT:   SectionHeaderOffset:
-# PPC64-NEXT:   Flags [ (0x0)
+# PPC64-NEXT:   Flags [ (0x1)
+# PPC64-NEXT:     0x1
 # PPC64-NEXT:   ]
 # PPC64-NEXT:   HeaderSize: 64
 # PPC64-NEXT:   ProgramHeaderEntrySize: 56
 # PPC64-NEXT:   ProgramHeaderCount:
 # PPC64-NEXT:   SectionHeaderEntrySize: 64
 # PPC64-NEXT:   SectionHeaderCount:
 # PPC64-NEXT:   StringTableSectionIndex:
 # PPC64-NEXT: }

 # PPC64LE-NEXT:     Unused: (00 00 00 00 00 00 00)
 # PPC64LE-NEXT:   }
 # PPC64LE-NEXT:   Type: Executable (0x2)
 # PPC64LE-NEXT:   Machine: EM_PPC64 (0x15)
 # PPC64LE-NEXT:   Version: 1
 # PPC64LE-NEXT:   Entry:
 # PPC64LE-NEXT:   ProgramHeaderOffset: 0x40
 # PPC64LE-NEXT:   SectionHeaderOffset:
-# PPC64LE-NEXT:   Flags [ (0x0)
+# PPC64LE-NEXT:   Flags [ (0x2)
+# PPC64LE-NEXT:     0x2
 # PPC64LE-NEXT:   ]
 # PPC64LE-NEXT:   HeaderSize: 64
 # PPC64LE-NEXT:   ProgramHeaderEntrySize: 56
 # PPC64LE-NEXT:   ProgramHeaderCount:
 # PPC64LE-NEXT:   SectionHeaderEntrySize: 64
 # PPC64LE-NEXT:   SectionHeaderCount:
 # PPC64LE-NEXT:   StringTableSectionIndex:
 # PPC64LE-NEXT: }