ldd: Add GotEntrySize/GotPltEntrySize to ELF target

[hjl.tools]

Summary

For x86-64 psABI, the entry size of .got and .got.plt sections is 8
bytes for both LP64 and ILP32. Add GotEntrySize and GotPltEntrySize
to ELF target instead of using size of ELFT::uint. Now we can generate
a simple working x32 executable:

[hjl@gnu-skl-1 pr28507]$ gcc -mx32 -B./ -o foo foo.o -Wl,-v
collect2 version 6.1.1 20160621 (Red Hat 6.1.1-3)
./ld -plugin /usr/libexec/gcc/x86_64-redhat-linux/6.1.1/liblto_plugin.so -plugin-opt=/usr/libexec/gcc/x86_64-redhat-linux/6.1.1/lto-wrapper -plugin-opt=-fresolution=/tmp/ccSNGyqu.res -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s --build-id --no-add-needed --eh-frame-hdr --hash-style=gnu -m elf32_x86_64 -dynamic-linker /libx32/ld-linux-x32.so.2 -o foo /usr/lib/gcc/x86_64-redhat-linux/6.1.1/../../../../libx32/crt1.o /usr/lib/gcc/x86_64-redhat-linux/6.1.1/../../../../libx32/crti.o /usr/lib/gcc/x86_64-redhat-linux/6.1.1/x32/crtbegin.o -L/usr/lib/gcc/x86_64-redhat-linux/6.1.1/x32 -L/usr/lib/gcc/x86_64-redhat-linux/6.1.1/../../../../libx32 -L/lib/../libx32 -L/usr/lib/../libx32 -L. -L/usr/lib/gcc/x86_64-redhat-linux/6.1.1 -L/usr/lib/gcc/x86_64-redhat-linux/6.1.1/../../.. foo.o -v -lgcc --as-needed -lgcc_s --no-as-needed -lc -lgcc --as-needed -lgcc_s --no-as-needed /usr/lib/gcc/x86_64-redhat-linux/6.1.1/x32/crtend.o /usr/lib/gcc/x86_64-redhat-linux/6.1.1/../../../../libx32/crtn.o
LLD 3.9 (ssh://[e-mail]/export/server/git/llvm/lld 96b35f25c4f2253e9be5b814913106ec072a84d9)
[hjl@gnu-skl-1 pr28507]$ ./foo
hello
[hjl@gnu-skl-1 pr28507]$

[ruiu]

LGTM with nits.

ELF/Target.cpp

314–317

Please reorder so that the order matches the member definitions in the base class.

ELF/Target.h

84–87

Sort

86–87

Sort.

[hjl.tools]

ELF/Target.h

86–87

What is the sorting order? Like this

unsigned GotEntrySize;
unsigned GotPltEntrySize;
unsigned PltEntrySize;
unsigned PltHeaderSize;

[ruiu]

LGTM with nits.

ELF/Target.h

86–87

Yeah. Since we are mixing uint32_t and unsigned, there's no single sort order, but at least for all members of the same type, I'd like to sort them alphabetically. So is it.

ELF/OutputSections.cpp

 template <class ELFT>
 void OutputSectionBase<ELFT>::writeHeaderTo(Elf_Shdr *Shdr) {
   *Shdr = Header;
 }
 
 template <class ELFT>
 GotPltSection<ELFT>::GotPltSection()
     : OutputSectionBase<ELFT>(".got.plt", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE) {
-  this->Header.sh_addralign = sizeof(uintX_t);
+  this->Header.sh_addralign = Target->GotPltEntrySize;
 }
 
 template <class ELFT> void GotPltSection<ELFT>::addEntry(SymbolBody &Sym) {
   Sym.GotPltIndex = Target->GotPltHeaderEntriesNum + Entries.size();
   Entries.push_back(&Sym);
 }
 
 template <class ELFT> bool GotPltSection<ELFT>::empty() const {
   return Entries.empty();
 }
 
 template <class ELFT> void GotPltSection<ELFT>::finalize() {
   this->Header.sh_size =
-      (Target->GotPltHeaderEntriesNum + Entries.size()) * sizeof(uintX_t);
+      (Target->GotPltHeaderEntriesNum + Entries.size()) *
+       Target->GotPltEntrySize;
 }
 
 template <class ELFT> void GotPltSection<ELFT>::writeTo(uint8_t *Buf) {
   Target->writeGotPltHeader(Buf);
-  Buf += Target->GotPltHeaderEntriesNum * sizeof(uintX_t);
+  Buf += Target->GotPltHeaderEntriesNum * Target->GotPltEntrySize;
   for (const SymbolBody *B : Entries) {
     Target->writeGotPlt(Buf, *B);
     Buf += sizeof(uintX_t);
   }
 }
 
 template <class ELFT>
 GotSection<ELFT>::GotSection()
     : OutputSectionBase<ELFT>(".got", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE) {
   if (Config->EMachine == EM_MIPS)
     this->Header.sh_flags |= SHF_MIPS_GPREL;
-  this->Header.sh_addralign = sizeof(uintX_t);
+  this->Header.sh_addralign = Target->GotEntrySize;
 }
 
 template <class ELFT>
 void GotSection<ELFT>::addEntry(SymbolBody &Sym) {
   Sym.GotIndex = Entries.size();
   Entries.push_back(&Sym);
 }
 

ELF/Symbols.cpp

typename ELFT::uint SymbolBody::getVA(typename ELFT::uint Addend) const {
   return OutVA + Addend;
 }
 
 template <class ELFT> typename ELFT::uint SymbolBody::getGotVA() const {
   return Out<ELFT>::Got->getVA() + getGotOffset<ELFT>();
 }
 
 template <class ELFT> typename ELFT::uint SymbolBody::getGotOffset() const {
-  return GotIndex * sizeof(typename ELFT::uint);
+  return GotIndex * Target->GotEntrySize;
 }
 
 template <class ELFT> typename ELFT::uint SymbolBody::getGotPltVA() const {
   return Out<ELFT>::GotPlt->getVA() + getGotPltOffset<ELFT>();
 }
 
 template <class ELFT> typename ELFT::uint SymbolBody::getGotPltOffset() const {
-  return GotPltIndex * sizeof(typename ELFT::uint);
+  return GotPltIndex * Target->GotPltEntrySize;
 }
 
 template <class ELFT> typename ELFT::uint SymbolBody::getPltVA() const {
   return Out<ELFT>::Plt->getVA() + Target->PltHeaderSize +
          PltIndex * Target->PltEntrySize;
 }
 
 template <class ELFT> typename ELFT::uint SymbolBody::getThunkVA() const {

ELF/Target.h

public:
   uint32_t GotRel;
   uint32_t PltRel;
   uint32_t RelativeRel;
   uint32_t IRelativeRel;
   uint32_t TlsDescRel;
   uint32_t TlsGotRel;
   uint32_t TlsModuleIndexRel;
   uint32_t TlsOffsetRel;
   unsigned PltEntrySize;
   unsigned PltHeaderSize;
+  unsigned GotEntrySize;
+  unsigned GotPltEntrySize;
 
   // At least on x86_64 positions 1 and 2 are used by the first plt entry
   // to support lazy loading.
   unsigned GotPltHeaderEntriesNum = 3;
 
   // Set to 0 for variant 2
   unsigned TcbSize = 0;
 

ELF/Target.cpp

X86TargetInfo::X86TargetInfo() {
   CopyRel = R_386_COPY;
   GotRel = R_386_GLOB_DAT;
   PltRel = R_386_JUMP_SLOT;
   IRelativeRel = R_386_IRELATIVE;
   RelativeRel = R_386_RELATIVE;
   TlsGotRel = R_386_TLS_TPOFF;
   TlsModuleIndexRel = R_386_TLS_DTPMOD32;
   TlsOffsetRel = R_386_TLS_DTPOFF32;
   PltEntrySize = 16;
   PltHeaderSize = 16;
+  GotEntrySize = 4;
+  GotPltEntrySize = 4;
   TlsGdRelaxSkip = 2;
 }
 
 RelExpr X86TargetInfo::getRelExpr(uint32_t Type, const SymbolBody &S) const {
   switch (Type) {
   default:
     return R_ABS;
   case R_386_TLS_GD:
template <class ELFT> X86_64TargetInfo<ELFT>::X86_64TargetInfo() {
   PltRel = R_X86_64_JUMP_SLOT;
   RelativeRel = R_X86_64_RELATIVE;
   IRelativeRel = R_X86_64_IRELATIVE;
   TlsGotRel = R_X86_64_TPOFF64;
   TlsModuleIndexRel = R_X86_64_DTPMOD64;
   TlsOffsetRel = R_X86_64_DTPOFF64;
   PltEntrySize = 16;
   PltHeaderSize = 16;
+  GotEntrySize = 8;
+  GotPltEntrySize = 8;
   TlsGdRelaxSkip = 2;
 }
 
 template <class ELFT>
 RelExpr X86_64TargetInfo<ELFT>::getRelExpr(uint32_t Type,
                                            const SymbolBody &S) const {
   switch (Type) {
   default:
RelExpr PPCTargetInfo::getRelExpr(uint32_t Type, const SymbolBody &S) const {
   return R_ABS;
 }
 
 PPC64TargetInfo::PPC64TargetInfo() {
   PltRel = GotRel = R_PPC64_GLOB_DAT;
   RelativeRel = R_PPC64_RELATIVE;
   PltEntrySize = 32;
   PltHeaderSize = 0;
+  GotEntrySize = 8;
+  GotPltEntrySize = 8;
 
   // We need 64K pages (at least under glibc/Linux, the loader won't
   // set different permissions on a finer granularity than that).
   PageSize = 65536;
 
   // The PPC64 ELF ABI v1 spec, says:
   //
   //   It is normally desirable to put segments with different characteristics
AArch64TargetInfo::AArch64TargetInfo() {
   RelativeRel = R_AARCH64_RELATIVE;
   IRelativeRel = R_AARCH64_IRELATIVE;
   GotRel = R_AARCH64_GLOB_DAT;
   PltRel = R_AARCH64_JUMP_SLOT;
   TlsDescRel = R_AARCH64_TLSDESC;
   TlsGotRel = R_AARCH64_TLS_TPREL64;
   PltEntrySize = 16;
   PltHeaderSize = 32;
+  GotEntrySize = 8;
+  GotPltEntrySize = 8;
 
   // It doesn't seem to be documented anywhere, but tls on aarch64 uses variant
   // 1 of the tls structures and the tcb size is 16.
   TcbSize = 16;
 }
 
 RelExpr AArch64TargetInfo::getRelExpr(uint32_t Type,
                                       const SymbolBody &S) const {
ARMTargetInfo::ARMTargetInfo() {
   IRelativeRel = R_ARM_IRELATIVE;
   GotRel = R_ARM_GLOB_DAT;
   PltRel = R_ARM_JUMP_SLOT;
   TlsGotRel = R_ARM_TLS_TPOFF32;
   TlsModuleIndexRel = R_ARM_TLS_DTPMOD32;
   TlsOffsetRel = R_ARM_TLS_DTPOFF32;
   PltEntrySize = 16;
   PltHeaderSize = 20;
+  GotEntrySize = 4;
+  GotPltEntrySize = 4;
 }
 
 RelExpr ARMTargetInfo::getRelExpr(uint32_t Type, const SymbolBody &S) const {
   switch (Type) {
   default:
     return R_ABS;
   case R_ARM_THM_JUMP11:
     return R_PC;
uint64_t ARMTargetInfo::getImplicitAddend(const uint8_t *Buf,
   }
 }
 
 template <class ELFT> MipsTargetInfo<ELFT>::MipsTargetInfo() {
   GotPltHeaderEntriesNum = 2;
   PageSize = 65536;
   PltEntrySize = 16;
   PltHeaderSize = 32;
+  GotEntrySize = sizeof(typename ELFT::uint);
+  GotPltEntrySize = sizeof(typename ELFT::uint);
   CopyRel = R_MIPS_COPY;
   PltRel = R_MIPS_JUMP_SLOT;
   if (ELFT::Is64Bits) {
     RelativeRel = (R_MIPS_64 << 8) | R_MIPS_REL32;
     TlsGotRel = R_MIPS_TLS_TPREL64;
     TlsModuleIndexRel = R_MIPS_TLS_DTPMOD64;
     TlsOffsetRel = R_MIPS_TLS_DTPREL64;
   } else {