[ELF] - R_X86_64_SIZE64/R_X86_64_SIZE32 relocations implemented.

[grimar]

Summary

R_X86_64_SIZE64/R_X86_64_SIZE32 relocations were introduced in 0.98v of "System V Application Binary Interface x86-64" (http://www.x86-64.org/documentation/abi.pdf).

Calculation for them is Z + A, where:
Z - Represents the size of the symbol whose index resides in the relocation entry.
A - Represents the addend used to compute the value of the relocatable field.

Currently afaik gold does not support these, but bfd does.

[grimar]

ELF/Target.cpp

645 ↗

(On Diff #42180)

// This check could be moved at upper level, but that
// would require adding Target->isSizeReloc() method.
// SIZE32/64 relocations exist only for x64 now,
// so it does not need such generic handling and that is why it is here.

[ruiu]

ELF/Target.cpp

645 ↗

(On Diff #42180)

I don't understand why you had to do this. Is this described in the spec?

[grimar]

• Addressed review comments.
• Added Target::isSizeDynReloc()
• Updated test.

ELF/Target.cpp

645 ↗

(On Diff #42180)

Point was to skip unnecessary calculations below since anyways dynamic relocation should be created for that case.
But I did a mistake in logic. Not Config->Shared have to be checked but canBePreempted(). If this relocation is against something that CBP then dynamic relocation is created and there is no need to perform any calculations.
Updated the test to cover that case.

Unfortunately I was need to add isSizeDynReloc() to target that wanted to avoid. Another way I see - to add CBP or Body argument for relocateOne and perform check inside like in first version of patch.

[ruiu]

ELF/Target.cpp

510–511 ↗

(On Diff #42271)

Is this correct? If my understanding is correct, if a symbol can be preempted, SIZE relocations for the symbol are ignored in this implementation. Is this what you expected?

[grimar]

ELF/Target.cpp

510–511 ↗

(On Diff #42271)

Keyword here "Dyn", this method checks if size relocation requires dynamic reloc.

If symbol can be preempted then it requires dynamic size relocation R_X86_64_SIZE64/R_X86_64_SIZE32 which is placed to .rela.dyn, and relocation calculation therefore ignored. For not CBP symbols I dont create dynamic relocation and resolve it during static link.
That how it works I believe, and covered in tests (relocation-size-shared.s both resolves some size relocs statically and also creates few dynamic ones).

[ruiu]

LGTM

lld/trunk/ELF/InputSection.cpp

for (const auto &RI : Rels) {
     if (Offset == (uintX_t)-1)
       return nullptr;
     return Buf + Offset;
   }
   return nullptr;
 }
 
 template <class ELFT>
+static typename llvm::object::ELFFile<ELFT>::uintX_t
+getSymSize(SymbolBody &Body) {
+  if (auto *SS = dyn_cast<Defined<ELFT>>(&Body))
+    return SS->Sym.st_size;
+  return 0;
+}
+
+template <class ELFT>
 template <bool isRela>
 void InputSectionBase<ELFT>::relocate(uint8_t *Buf, uint8_t *BufEnd,
                                       RelIteratorRange<isRela> Rels) {
   typedef Elf_Rel_Impl<ELFT, isRela> RelType;
   size_t Num = Rels.end() - Rels.begin();
   for (size_t I = 0; I < Num; ++I) {
     const RelType &RI = *(Rels.begin() + I);
     uint32_t SymIndex = RI.getSymbol(Config->Mips64EL);
if (Target->isTlsLocalDynamicReloc(Type) &&
       continue;
     }
 
     // Handle relocations for local symbols -- they never get
     // resolved so we don't allocate a SymbolBody.
     const Elf_Shdr *SymTab = File->getSymbolTable();
     if (SymIndex < SymTab->sh_info) {
       uintX_t SymVA = getLocalRelTarget(*File, RI);
-      Target->relocateOne(BufLoc, BufEnd, Type, AddrLoc, SymVA,
+      Target->relocateOne(BufLoc, BufEnd, Type, AddrLoc, SymVA, 0,
                           findMipsPairedReloc(Buf, Type, NextRelocs));
       continue;
     }
 
     SymbolBody &Body = *File->getSymbolBody(SymIndex)->repl();
 
     if (Target->isTlsGlobalDynamicReloc(Type) &&
         !Target->isTlsOptimized(Type, &Body)) {
if (Target->relocNeedsPlt(Type, Body)) {
       Type = Target->getPltRefReloc(Type);
     } else if (Target->relocNeedsGot(Type, Body)) {
       SymVA = Out<ELFT>::Got->getEntryAddr(Body);
       if (Body.isTLS())
         Type = Target->getTlsGotReloc();
     } else if (!Target->relocNeedsCopy(Type, Body) &&
                isa<SharedSymbol<ELFT>>(Body)) {
       continue;
-    } else if (Target->isTlsDynReloc(Type)) {
+    } else if (Target->isTlsDynReloc(Type) ||
+               Target->isSizeDynReloc(Type, Body)) {
       continue;
     }
-    Target->relocateOne(BufLoc, BufEnd, Type, AddrLoc,
-                        SymVA + getAddend<ELFT>(RI),
+    uintX_t A = getAddend<ELFT>(RI);
+    uintX_t Size = getSymSize<ELFT>(Body);
+    Target->relocateOne(BufLoc, BufEnd, Type, AddrLoc, SymVA + A, Size + A,
                         findMipsPairedReloc(Buf, Type, NextRelocs));
   }
 }
 
 template <class ELFT> void InputSection<ELFT>::writeTo(uint8_t *Buf) {
   if (this->Header->sh_type == SHT_NOBITS)
     return;
   // Copy section contents from source object file to output file.

lld/trunk/ELF/Target.h

public:
   virtual void writeGotPltHeaderEntries(uint8_t *Buf) const;
   virtual void writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const = 0;
   virtual void writePltZeroEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                                  uint64_t PltEntryAddr) const = 0;
   virtual void writePltEntry(uint8_t *Buf, uint64_t GotAddr,
                              uint64_t GotEntryAddr, uint64_t PltEntryAddr,
                              int32_t Index, unsigned RelOff) const = 0;
   virtual bool isRelRelative(uint32_t Type) const;
+  virtual bool isSizeDynReloc(uint32_t Type, const SymbolBody &S) const;
   virtual bool relocNeedsCopy(uint32_t Type, const SymbolBody &S) const;
   virtual bool relocNeedsGot(uint32_t Type, const SymbolBody &S) const = 0;
   virtual bool relocNeedsPlt(uint32_t Type, const SymbolBody &S) const = 0;
   virtual void relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
-                           uint64_t P, uint64_t SA,
+                           uint64_t P, uint64_t SA, uint64_t ZA = 0,
                            uint8_t *PairedLoc = nullptr) const = 0;
   virtual bool isTlsOptimized(unsigned Type, const SymbolBody *S) const;
   virtual unsigned relocateTlsOptimize(uint8_t *Loc, uint8_t *BufEnd,
                                        uint32_t Type, uint64_t P, uint64_t SA,
                                        const SymbolBody &S) const;
   virtual ~TargetInfo();
 
 protected:

lld/trunk/ELF/Target.cpp

void writePltZeroEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                          uint64_t PltEntryAddr) const override;
   void writePltEntry(uint8_t *Buf, uint64_t GotAddr, uint64_t GotEntryAddr,
                      uint64_t PltEntryAddr, int32_t Index,
                      unsigned RelOff) const override;
   bool relocNeedsCopy(uint32_t Type, const SymbolBody &S) const override;
   bool relocNeedsGot(uint32_t Type, const SymbolBody &S) const override;
   bool relocNeedsPlt(uint32_t Type, const SymbolBody &S) const override;
   void relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type, uint64_t P,
-                   uint64_t SA, uint8_t *PairedLoc = nullptr) const override;
+                   uint64_t SA, uint64_t ZA = 0,
+                   uint8_t *PairedLoc = nullptr) const override;
   bool isTlsOptimized(unsigned Type, const SymbolBody *S) const override;
   unsigned relocateTlsOptimize(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
                                uint64_t P, uint64_t SA,
                                const SymbolBody &S) const override;
 
 private:
   void relocateTlsLdToLe(uint8_t *Loc, uint8_t *BufEnd, uint64_t P,
                          uint64_t SA) const;
void writePltZeroEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                          uint64_t PltEntryAddr) const override;
   void writePltEntry(uint8_t *Buf, uint64_t GotAddr, uint64_t GotEntryAddr,
                      uint64_t PltEntryAddr, int32_t Index,
                      unsigned RelOff) const override;
   bool relocNeedsCopy(uint32_t Type, const SymbolBody &S) const override;
   bool relocNeedsGot(uint32_t Type, const SymbolBody &S) const override;
   bool relocNeedsPlt(uint32_t Type, const SymbolBody &S) const override;
   void relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type, uint64_t P,
-                   uint64_t SA, uint8_t *PairedLoc = nullptr) const override;
+                   uint64_t SA, uint64_t ZA = 0,
+                   uint8_t *PairedLoc = nullptr) const override;
   bool isRelRelative(uint32_t Type) const override;
   bool isTlsOptimized(unsigned Type, const SymbolBody *S) const override;
+  bool isSizeDynReloc(uint32_t Type, const SymbolBody &S) const override;
   unsigned relocateTlsOptimize(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
                                uint64_t P, uint64_t SA,
                                const SymbolBody &S) const override;
 
 private:
   void relocateTlsLdToLe(uint8_t *Loc, uint8_t *BufEnd, uint64_t P,
                          uint64_t SA) const;
   void relocateTlsGdToLe(uint8_t *Loc, uint8_t *BufEnd, uint64_t P,
public:
   void writePltZeroEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                          uint64_t PltEntryAddr) const override;
   void writePltEntry(uint8_t *Buf, uint64_t GotAddr, uint64_t GotEntryAddr,
                      uint64_t PltEntryAddr, int32_t Index,
                      unsigned RelOff) const override;
   bool relocNeedsGot(uint32_t Type, const SymbolBody &S) const override;
   bool relocNeedsPlt(uint32_t Type, const SymbolBody &S) const override;
   void relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type, uint64_t P,
-                   uint64_t SA, uint8_t *PairedLoc = nullptr) const override;
+                   uint64_t SA, uint64_t ZA = 0,
+                   uint8_t *PairedLoc = nullptr) const override;
   bool isRelRelative(uint32_t Type) const override;
 };
 
 class AArch64TargetInfo final : public TargetInfo {
 public:
   AArch64TargetInfo();
   unsigned getDynReloc(unsigned Type) const override;
   unsigned getPltRefReloc(unsigned Type) const override;
   void writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const override;
   void writePltZeroEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                          uint64_t PltEntryAddr) const override;
   void writePltEntry(uint8_t *Buf, uint64_t GotAddr, uint64_t GotEntryAddr,
                      uint64_t PltEntryAddr, int32_t Index,
                      unsigned RelOff) const override;
   bool relocNeedsCopy(uint32_t Type, const SymbolBody &S) const override;
   bool relocNeedsGot(uint32_t Type, const SymbolBody &S) const override;
   bool relocNeedsPlt(uint32_t Type, const SymbolBody &S) const override;
   void relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type, uint64_t P,
-                   uint64_t SA, uint8_t *PairedLoc = nullptr) const override;
+                   uint64_t SA, uint64_t ZA = 0,
+                   uint8_t *PairedLoc = nullptr) const override;
 };
 
 template <class ELFT> class MipsTargetInfo final : public TargetInfo {
 public:
   MipsTargetInfo();
   void writeGotHeaderEntries(uint8_t *Buf) const override;
   void writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const override;
   void writePltZeroEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                          uint64_t PltEntryAddr) const override;
   void writePltEntry(uint8_t *Buf, uint64_t GotAddr, uint64_t GotEntryAddr,
                      uint64_t PltEntryAddr, int32_t Index,
                      unsigned RelOff) const override;
   bool relocNeedsGot(uint32_t Type, const SymbolBody &S) const override;
   bool relocNeedsPlt(uint32_t Type, const SymbolBody &S) const override;
   void relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type, uint64_t P,
-                   uint64_t SA, uint8_t *PairedLoc = nullptr) const override;
+                   uint64_t SA, uint64_t ZA = 0,
+                   uint8_t *PairedLoc = nullptr) const override;
 };
 } // anonymous namespace
 
 TargetInfo *createTarget() {
   switch (Config->EMachine) {
   case EM_386:
     return new X86TargetInfo();
   case EM_AARCH64:

 bool TargetInfo::relocNeedsCopy(uint32_t Type, const SymbolBody &S) const {
   return false;
 }
 
 unsigned TargetInfo::getPltRefReloc(unsigned Type) const { return PCRelReloc; }
 
 bool TargetInfo::isRelRelative(uint32_t Type) const { return true; }
 
+bool TargetInfo::isSizeDynReloc(uint32_t Type, const SymbolBody &S) const {
+  return false;
+}
+
 unsigned TargetInfo::relocateTlsOptimize(uint8_t *Loc, uint8_t *BufEnd,
                                          uint32_t Type, uint64_t P, uint64_t SA,
                                          const SymbolBody &S) const {
   return 0;
 }
 
 void TargetInfo::writeGotHeaderEntries(uint8_t *Buf) const {}
 

 }
 
 bool X86TargetInfo::relocNeedsPlt(uint32_t Type, const SymbolBody &S) const {
   return (Type == R_386_PLT32 && canBePreempted(&S, true)) ||
          (Type == R_386_PC32 && S.isShared());
 }
 
 void X86TargetInfo::relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
-                                uint64_t P, uint64_t SA,
+                                uint64_t P, uint64_t SA, uint64_t ZA,
                                 uint8_t *PairedLoc) const {
   switch (Type) {
   case R_386_32:
     add32le(Loc, SA);
     break;
   case R_386_GOT32:
     add32le(Loc, SA - Out<ELF32LE>::Got->getVA());
     break;
default:
     return false;
   case R_X86_64_DTPOFF32:
   case R_X86_64_DTPOFF64:
   case R_X86_64_PC8:
   case R_X86_64_PC16:
   case R_X86_64_PC32:
   case R_X86_64_PC64:
   case R_X86_64_PLT32:
+  case R_X86_64_SIZE32:
+  case R_X86_64_SIZE64:
     return true;
   }
 }
 
+bool X86_64TargetInfo::isSizeDynReloc(uint32_t Type,
+                                      const SymbolBody &S) const {
+  return (Type == R_X86_64_SIZE32 || Type == R_X86_64_SIZE64) &&
+         canBePreempted(&S, false);
+}
+
 bool X86_64TargetInfo::isTlsOptimized(unsigned Type,
                                       const SymbolBody *S) const {
   if (Config->Shared || (S && !S->isTLS()))
     return false;
   return Type == R_X86_64_TLSGD || Type == R_X86_64_TLSLD ||
          Type == R_X86_64_DTPOFF32 ||
          (Type == R_X86_64_GOTTPOFF && !canBePreempted(S, true));
 }
case R_X86_64_TLSLD:
     relocateTlsLdToLe(Loc, BufEnd, P, SA);
     // The next relocation should be against __tls_get_addr, so skip it
     return 1;
   }
   llvm_unreachable("Unknown TLS optimization");
 }
 
 void X86_64TargetInfo::relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
-                                   uint64_t P, uint64_t SA,
+                                   uint64_t P, uint64_t SA, uint64_t ZA,
                                    uint8_t *PairedLoc) const {
   switch (Type) {
   case R_X86_64_32:
     checkUInt<32>(SA, Type);
     write32le(Loc, SA);
     break;
   case R_X86_64_32S:
     checkInt<32>(SA, Type);
case R_X86_64_DTPOFF64:
     break;
   case R_X86_64_GOTPCREL:
   case R_X86_64_PC32:
   case R_X86_64_PLT32:
   case R_X86_64_TLSGD:
   case R_X86_64_TLSLD:
     write32le(Loc, SA - P);
     break;
+  case R_X86_64_SIZE32:
+    write32le(Loc, ZA);
+    break;
+  case R_X86_64_SIZE64:
+    write64le(Loc, ZA);
+    break;
   case R_X86_64_TPOFF32: {
     uint64_t Val = SA - Out<ELF64LE>::TlsPhdr->p_memsz;
     checkInt<32>(Val, Type);
     write32le(Loc, Val);
     break;
   }
   case R_X86_64_TPOFF64:
     write32le(Loc, SA - P);
default:
     return true;
   case R_PPC64_ADDR64:
   case R_PPC64_TOC:
     return false;
   }
 }
 
 void PPC64TargetInfo::relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
-                                  uint64_t P, uint64_t SA,
+                                  uint64_t P, uint64_t SA, uint64_t ZA,
                                   uint8_t *PairedLoc) const {
   uint64_t TB = getPPC64TocBase();
 
   // For a TOC-relative relocation, adjust the addend and proceed in terms of
   // the corresponding ADDR16 relocation type.
   switch (Type) {
   case R_PPC64_TOC16:       Type = R_PPC64_ADDR16;       SA -= TB; break;
   case R_PPC64_TOC16_DS:    Type = R_PPC64_ADDR16_DS;    SA -= TB; break;

 // as (Expr & ~0xFFF). (This applies even if the machine page size
 // supported by the platform has a different value.)
 static uint64_t getAArch64Page(uint64_t Expr) {
   return Expr & (~static_cast<uint64_t>(0xFFF));
 }
 
 void AArch64TargetInfo::relocateOne(uint8_t *Loc, uint8_t *BufEnd,
                                     uint32_t Type, uint64_t P, uint64_t SA,
-                                    uint8_t *PairedLoc) const {
+                                    uint64_t ZA, uint8_t *PairedLoc) const {
   switch (Type) {
   case R_AARCH64_ABS16:
     checkIntUInt<16>(SA, Type);
     write16le(Loc, SA);
     break;
   case R_AARCH64_ABS32:
     checkIntUInt<32>(SA, Type);
     write32le(Loc, SA);

 bool MipsTargetInfo<ELFT>::relocNeedsPlt(uint32_t Type,
                                          const SymbolBody &S) const {
   return false;
 }
 
 template <class ELFT>
 void MipsTargetInfo<ELFT>::relocateOne(uint8_t *Loc, uint8_t *BufEnd,
                                        uint32_t Type, uint64_t P, uint64_t SA,
-                                       uint8_t *PairedLoc) const {
+                                       uint64_t ZA, uint8_t *PairedLoc) const {
   const endianness E = ELFT::TargetEndianness;
   switch (Type) {
   case R_MIPS_32:
     add32<E>(Loc, SA);
     break;
   case R_MIPS_CALL16:
   case R_MIPS_GOT16: {
     int64_t V = SA - getMipsGpAddr<ELFT>();

lld/trunk/test/ELF/Inputs/relocation-size-shared.s

+.data
+.global fooshared
+.type fooshared,%object
+.size fooshared,26
+fooshared:
+.zero 26

lld/trunk/test/ELF/relocation-size-shared.s

+// RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
+// RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/relocation-size-shared.s -o %tso.o
+// RUN: ld.lld -shared %tso.o -o %tso
+// RUN: ld.lld %t.o %tso -o %t1
+// RUN: llvm-readobj -r %t1 | FileCheck --check-prefix=RELOCSHARED %s
+// RUN: llvm-objdump -d %t1 | FileCheck --check-prefix=DISASM %s
+
+// RELOCSHARED:       Relocations [
+// RELOCSHARED-NEXT:  Section ({{.*}}) .rela.dyn {
+// RELOCSHARED-NEXT:    0x11018 R_X86_64_SIZE64 fooshared 0xFFFFFFFFFFFFFFFF
+// RELOCSHARED-NEXT:    0x11020 R_X86_64_SIZE64 fooshared 0x0
+// RELOCSHARED-NEXT:    0x11028 R_X86_64_SIZE64 fooshared 0x1
+// RELOCSHARED-NEXT:    0x11048 R_X86_64_SIZE32 fooshared 0xFFFFFFFFFFFFFFFF
+// RELOCSHARED-NEXT:    0x1104F R_X86_64_SIZE32 fooshared 0x0
+// RELOCSHARED-NEXT:    0x11056 R_X86_64_SIZE32 fooshared 0x1
+// RELOCSHARED-NEXT:  }
+// RELOCSHARED-NEXT:]
+
+// DISASM:      Disassembly of section .text:
+// DISASM:      _data:
+// DISASM-NEXT: 11000: 19 00
+// DISASM-NEXT: 11002: 00 00
+// DISASM-NEXT: 11004: 00 00
+// DISASM-NEXT: 11006: 00 00
+// DISASM-NEXT: 11008: 1a 00
+// DISASM-NEXT: 1100a: 00 00
+// DISASM-NEXT: 1100c: 00 00
+// DISASM-NEXT: 1100e: 00 00
+// DISASM-NEXT: 11010: 1b 00
+// DISASM-NEXT: 11012: 00 00
+// DISASM-NEXT: 11014: 00 00
+// DISASM-NEXT: 11016: 00 00
+// DISASM-NEXT: 11018: 00 00
+// DISASM-NEXT: 1101a: 00 00
+// DISASM-NEXT: 1101c: 00 00
+// DISASM-NEXT: 1101e: 00 00
+// DISASM-NEXT: 11020: 00 00
+// DISASM-NEXT: 11022: 00 00
+// DISASM-NEXT: 11024: 00 00
+// DISASM-NEXT: 11026: 00 00
+// DISASM-NEXT: 11028: 00 00
+// DISASM-NEXT: 1102a: 00 00
+// DISASM-NEXT: 1102c: 00 00
+// DISASM-NEXT: 1102e: 00 00
+// DISASM:      _start:
+// DISASM-NEXT: 11030: 8b 04 25 19 00 00 00 movl 25, %eax
+// DISASM-NEXT: 11037: 8b 04 25 1a 00 00 00 movl 26, %eax
+// DISASM-NEXT: 1103e: 8b 04 25 1b 00 00 00 movl 27, %eax
+// DISASM-NEXT: 11045: 8b 04 25 00 00 00 00 movl 0, %eax
+// DISASM-NEXT: 1104c: 8b 04 25 00 00 00 00 movl 0, %eax
+// DISASM-NEXT: 11053: 8b 04 25 00 00 00 00 movl 0, %eax
+
+.data
+.global foo
+.type foo,%object
+.size foo,26
+foo:
+.zero 26
+
+.text
+_data:
+  // R_X86_64_SIZE64:
+  .quad foo@SIZE-1
+  .quad foo@SIZE
+  .quad foo@SIZE+1
+  .quad fooshared@SIZE-1
+  .quad fooshared@SIZE
+  .quad fooshared@SIZE+1
+
+.globl _start
+_start:
+  // R_X86_64_SIZE32:
+  movl foo@SIZE-1,%eax
+  movl foo@SIZE,%eax
+  movl foo@SIZE+1,%eax
+  movl fooshared@SIZE-1,%eax
+  movl fooshared@SIZE,%eax
+  movl fooshared@SIZE+1,%eax

lld/trunk/test/ELF/relocation-size.s

+// RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
+// RUN: ld.lld %t.o -o %t1
+// RUN: llvm-readobj -r %t1 | FileCheck --check-prefix=NORELOC %s
+// RUN: llvm-objdump -d %t1 | FileCheck --check-prefix=DISASM %s
+// RUN: ld.lld -shared %t.o -o %t1
+// RUN: llvm-readobj -r %t1 | FileCheck --check-prefix=RELOCSHARED %s
+// RUN: llvm-objdump -d %t1 | FileCheck --check-prefix=DISASMSHARED %s
+
+// NORELOC:      Relocations [
+// NORELOC-NEXT: ]
+
+// DISASM:      Disassembly of section .text:
+// DISASM-NEXT: _data:
+// DISASM-NEXT: 11000: 19 00
+// DISASM-NEXT: 11002: 00 00
+// DISASM-NEXT: 11004: 00 00
+// DISASM-NEXT: 11006: 00 00
+// DISASM-NEXT: 11008: 1a 00
+// DISASM-NEXT: 1100a: 00 00
+// DISASM-NEXT: 1100c: 00 00
+// DISASM-NEXT: 1100e: 00 00
+// DISASM-NEXT: 11010: 1b 00
+// DISASM-NEXT: 11012: 00 00
+// DISASM-NEXT: 11014: 00 00
+// DISASM-NEXT: 11016: 00 00
+// DISASM-NEXT: 11018: 19 00
+// DISASM-NEXT: 1101a: 00 00
+// DISASM-NEXT: 1101c: 00 00
+// DISASM-NEXT: 1101e: 00 00
+// DISASM-NEXT: 11020: 1a 00
+// DISASM-NEXT: 11022: 00 00
+// DISASM-NEXT: 11024: 00 00
+// DISASM-NEXT: 11026: 00 00
+// DISASM-NEXT: 11028: 1b 00
+// DISASM-NEXT: 1102a: 00 00
+// DISASM-NEXT: 1102c: 00 00
+// DISASM-NEXT: 1102e: 00 00
+// DISASM:      _start:
+// DISASM-NEXT: 11030: 8b 04 25 19 00 00 00 movl 25, %eax
+// DISASM-NEXT: 11037: 8b 04 25 1a 00 00 00 movl 26, %eax
+// DISASM-NEXT: 1103e: 8b 04 25 1b 00 00 00 movl 27, %eax
+// DISASM-NEXT: 11045: 8b 04 25 19 00 00 00 movl 25, %eax
+// DISASM-NEXT: 1104c: 8b 04 25 1a 00 00 00 movl 26, %eax
+// DISASM-NEXT: 11053: 8b 04 25 1b 00 00 00 movl 27, %eax
+
+// RELOCSHARED:      Relocations [
+// RELOCSHARED-NEXT: Section ({{.*}}) .rela.dyn {
+// RELOCSHARED-NEXT:    0x1000 R_X86_64_SIZE64 foo 0xFFFFFFFFFFFFFFFF
+// RELOCSHARED-NEXT:    0x1008 R_X86_64_SIZE64 foo 0x0
+// RELOCSHARED-NEXT:    0x1010 R_X86_64_SIZE64 foo 0x1
+// RELOCSHARED-NEXT:    0x1033 R_X86_64_SIZE32 foo 0xFFFFFFFFFFFFFFFF
+// RELOCSHARED-NEXT:    0x103A R_X86_64_SIZE32 foo 0x0
+// RELOCSHARED-NEXT:    0x1041 R_X86_64_SIZE32 foo 0x1
+// RELOCSHARED-NEXT:  }
+// RELOCSHARED-NEXT: ]
+
+// DISASMSHARED:      Disassembly of section .text:
+// DISASMSHARED-NEXT: _data:
+// DISASMSHARED-NEXT: 1000: 00 00
+// DISASMSHARED-NEXT: 1002: 00 00
+// DISASMSHARED-NEXT: 1004: 00 00
+// DISASMSHARED-NEXT: 1006: 00 00
+// DISASMSHARED-NEXT: 1008: 00 00
+// DISASMSHARED-NEXT: 100a: 00 00
+// DISASMSHARED-NEXT: 100c: 00 00
+// DISASMSHARED-NEXT: 100e: 00 00
+// DISASMSHARED-NEXT: 1010: 00 00
+// DISASMSHARED-NEXT: 1012: 00 00
+// DISASMSHARED-NEXT: 1014: 00 00
+// DISASMSHARED-NEXT: 1016: 00 00
+// DISASMSHARED-NEXT: 1018: 19 00
+// DISASMSHARED-NEXT: 101a: 00 00
+// DISASMSHARED-NEXT: 101c: 00 00
+// DISASMSHARED-NEXT: 101e: 00 00
+// DISASMSHARED-NEXT: 1020: 1a 00
+// DISASMSHARED-NEXT: 1022: 00 00
+// DISASMSHARED-NEXT: 1024: 00 00
+// DISASMSHARED-NEXT: 1026: 00 00
+// DISASMSHARED-NEXT: 1028: 1b 00
+// DISASMSHARED-NEXT: 102a: 00 00
+// DISASMSHARED-NEXT: 102c: 00 00
+// DISASMSHARED-NEXT: 102e: 00 00
+// DISASMSHARED:      _start:
+// DISASMSHARED-NEXT: 1030: 8b 04 25 00 00 00 00 movl 0, %eax
+// DISASMSHARED-NEXT: 1037: 8b 04 25 00 00 00 00 movl 0, %eax
+// DISASMSHARED-NEXT: 103e: 8b 04 25 00 00 00 00 movl 0, %eax
+// DISASMSHARED-NEXT: 1045: 8b 04 25 19 00 00 00 movl 25, %eax
+// DISASMSHARED-NEXT: 104c: 8b 04 25 1a 00 00 00 movl 26, %eax
+// DISASMSHARED-NEXT: 1053: 8b 04 25 1b 00 00 00 movl 27, %eax
+
+.data
+.global foo
+.type foo,%object
+.size foo,26
+foo:
+.zero 26
+
+.data
+.global foohidden
+.hidden foohidden
+.type foohidden,%object
+.size foohidden,26
+foohidden:
+.zero 26
+
+.text
+_data:
+  // R_X86_64_SIZE64:
+  .quad foo@SIZE-1
+  .quad foo@SIZE
+  .quad foo@SIZE+1
+  .quad foohidden@SIZE-1
+  .quad foohidden@SIZE
+  .quad foohidden@SIZE+1
+.globl _start
+_start:
+  // R_X86_64_SIZE32:
+  movl foo@SIZE-1,%eax
+  movl foo@SIZE,%eax
+  movl foo@SIZE+1,%eax
+  movl foohidden@SIZE-1,%eax
+  movl foohidden@SIZE,%eax
+  movl foohidden@SIZE+1,%eax