[ELF2] Implements -z relro: create an ELF "PT_GNU_RELRO" segment header in the object.

[grimar]

Summary

Partial (-z relro) and full (-z relro, -z now) relro cases are implemented.

Partial relro:

• The ELF sections are reordered so that the ELF internal data sections (.got, .dtors, etc.) precede the program's data sections (.data and .bss).

.got is readonly, .got.plt is still writeable.

Full relro:

• Supports all the features of partial RELRO, .got.plt is also readonly.

[davide]

ELF/Driver.cpp

192 ↗

(On Diff #38852)

You already assign ZRelro to false so the last two lines (I think) can be removed, no?

[grimar]

ELF/Driver.cpp

192 ↗

(On Diff #38852)

I am not sure about that. What will be if we specify both ones in the command line (-z relro -z norelro ... -z relro) ? I guess that processing both ones can also be helpfull here since that can be feature that is already used and works for overriding the option for somebody.

But if first argument is not fine then it is still questionable which exactly lines should be removed then.
Like notes mentioned: looks like ld has ZRelro set to true by default.
So I need to know should I do the same in this patch or not. If yes then not the last ones, but two lines before the last two are becoming redundant.

[davide]

ELF/Driver.cpp

192 ↗

(On Diff #38852)

I think -zrelro -znorelro -zlrelro is a fairly weird way of specifying options on a cmdline (probably we shouldn't really care about that at this stage of development) but just out of curiosity, can you please check what gold and ld do in this case? My experience is that the option to enable "wins" but they're not always consistent with themselves.

[grimar]

ELF/Driver.cpp

192 ↗

(On Diff #38852)

I would agree that we should not care, but not for current case when it is just 2 lines of code that are already written and keeps consistenty with both ld/gold:

gcc -fuse-ld=bfd -Wl,-z,norelro,-z,relro,-z,norelro -fPIC maintest.c -o mainro
gcc -fuse-ld=gold -Wl,-z,norelro,-z,relro,-z,norelro -fPIC maintest.c -o mainro
Both ld/gold does not generate GNU_RELRO headers in that cases above.

Adding one more -z relro makes header to appear in output:
gcc -fuse-ld=bfd -Wl,-z,norelro,-z,relro,-z,norelro,-z,relro -fPIC maintest.c -o mainro

[• rafael]

ELF/Writer.cpp

317 ↗

(On Diff #38852)

Please don't do this.

The constraint that we have is that now the RW PT_LOAD is split in two parts. The bits that become ro after relacations are applied and the ones that don't.

You can implement that directly in the comparison function.

Also, I think we may as well always sort like that.

[• rafael]

And please rebase on top of trunk :-)

[grimar]

Rebased, simplified.

ELF/Writer.cpp

317 ↗

(On Diff #38852)

Problem is I cant recognize where is "got", "got.plt" and "data" using only section attributes bits.
They all are SHT_PROGBITS and "aw". And the only way to put .data to be the last here is checking its name I think.

There was no need to check order of got and got.plt because of stable_sort here, so I removed getRelroSectionRank(), but anyways here and in assignAddresses() I was not able to get rid of compare of name with ".data".

[• rafael]

ELF/Writer.cpp

379 ↗

(On Diff #39684)

This needs a comment and should probably be more explicit. Something like

bool AIsRelRo = helperfunc(...)
bool BIsRelRo = helperfunc(...)
if (AIsRelRo != BIsRelRo)

return AIsRelRo;

744 ↗

(On Diff #39684)

You should be able to write this as

if (cur is rw and sec is relro)

Add sec to relro segment.

The "is relro" check should use the same helper function that is used in the sorting.

[ruiu]

This is probably naive but obligatory question. Is relro segments considered actually useful? How many projects are using this for what?

ELF/Driver.cpp

192 ↗

(On Diff #39684)

Why do they have norelro although they don't have nonow nor noorigin or such?

ELF/Writer.cpp

739 ↗

(On Diff #39684)

I don't really want to make this for-loop longer than that is now. This is getting hard to understand over time. Can you create another for loop and move this piece of code outside of the loop?

[grimar]

ELF/Driver.cpp

192 ↗

(On Diff #39684)

I guess because -relro is set by default in bfd. Then the question is why they have -relro. Thats I dont know.

[grimar]

In D14218#285384, @ruiu wrote:

This is probably naive but obligatory question. Is relro segments considered actually useful? How many projects are using this for what?

For me it looks like its extremely useful for security. List of projects can be found here for example:
http://tk-blog.blogspot.ru/2009/02/relro-not-so-well-known-memory.html

[grimar]

Review comments addressed.

ELF/Writer.cpp

379 ↗

(On Diff #39684)

Done.

739 ↗

(On Diff #39684)

Adding another loop would add too much of code and too much duplication. Bcos I still need to calculate VA. I moved that logic to external method instead.

744 ↗

(On Diff #39684)

Done.

[• rafael]

ELF/Writer.cpp

327 ↗

(On Diff #39821)

This has to be a whitelist.

If a .o file has a section name "foobar", we cannot assume that it is relro.

692 ↗

(On Diff #39821)

delete the empty line.

[ruiu]

ELF/Driver.cpp

192 ↗

(On Diff #39821)

We probably should enable this by default, too.

ELF/Writer.cpp

48 ↗

(On Diff #39821)

You named isRelroSection and GnuRelroPhdr, so you want to name this updateRelro (instead of updateRelRo) for consistency.

693 ↗

(On Diff #39821)

if (!Config->ZRelro || !(Cur->p_flags & PF_W) || isRelroSection(Sec))
  return;

700 ↗

(On Diff #39821)

Remove this blank line.

803 ↗

(On Diff #39821)

So you are checking if p_filesz is not zero here to determine if we need the phdr, but

839–840 ↗

(On Diff #39821)

Here you are using something different. Are they guaranteed to be the same?

[grimar]

Review comments addressed.

ELF/Writer.cpp

327 ↗

(On Diff #39821)

Done.

692 ↗

(On Diff #39821)

Done.

693 ↗

(On Diff #39821)

Done.

700 ↗

(On Diff #39821)

Done.

839–840 ↗

(On Diff #39821)

Fixed

[• rafael]

ELF/Writer.cpp

368 ↗

(On Diff #40266)

Thin can be just Sec == &GotPlt, no?

371 ↗

(On Diff #40266)

Check for &Dynamic and &Got instead of the names.

[grimar]

ELF/Writer.cpp

371 ↗

(On Diff #40266)

I tried that and the above when developed it to see and that made method to look a bit more bulky. It adds one more _if_ section and for me comparing of names looks better since we anyways unable to get rid of that at all and dont plan to rename the sections ever.
So do you think its really be better to do ?

[grimar]

• Addressed review comments
• Rebased

[• rafael]

LGTM with two small changes.

ELF/Writer.cpp

435 ↗

(On Diff #40761)

Add a comment saying that relro go before plain rw sections.

757 ↗

(On Diff #40761)

Use |=

[grimar]

In D14218#295265, @rafael wrote:

LGTM with two small changes.

Perfect. thanks for your time !

[emaste]

With this change we end up with broken binaries on FreeBSD: http://llvm.org/pr25790

[grimar]

In D14218#306223, @emaste wrote:

With this change we end up with broken binaries on FreeBSD: http://llvm.org/pr25790

http://reviews.llvm.org/D15423 should fix that.

lld/trunk/ELF/Config.h

struct Configuration {
   bool Static = false;
   bool StripAll;
   bool SysvHash = true;
   bool Verbose;
   bool ZExecStack = false;
   bool ZNodelete;
   bool ZNow;
   bool ZOrigin;
+  bool ZRelro;
   ELFKind EKind = ELFNoneKind;
   uint16_t EMachine = llvm::ELF::EM_NONE;
   uint64_t EntryAddr = -1;
   unsigned Optimize = 0;
 };
 
 extern Configuration *Config;
 
 } // namespace elf2
 } // namespace lld
 
 #endif

lld/trunk/ELF/Driver.cpp

void LinkerDriver::createFiles(opt::InputArgList &Args) {
   Config->Init = getString(Args, OPT_init, "_init");
   Config->OutputFile = getString(Args, OPT_o);
   Config->SoName = getString(Args, OPT_soname);
   Config->Sysroot = getString(Args, OPT_sysroot);
 
   Config->ZNodelete = hasZOption(Args, "nodelete");
   Config->ZNow = hasZOption(Args, "now");
   Config->ZOrigin = hasZOption(Args, "origin");
+  Config->ZRelro = !hasZOption(Args, "norelro");
 
   if (auto *Arg = Args.getLastArg(OPT_O)) {
     StringRef Val = Arg->getValue();
     if (Val.getAsInteger(10, Config->Optimize))
       error("Invalid optimization level");
   }
 
   if (auto *Arg = Args.getLastArg(OPT_hash_style)) {

lld/trunk/ELF/Writer.cpp

 private:
   void copyLocalSymbols();
   void createSections();
   template <bool isRela>
   void scanRelocs(InputSectionBase<ELFT> &C,
                   iterator_range<const Elf_Rel_Impl<ELFT, isRela> *> Rels);
   void scanRelocs(InputSection<ELFT> &C);
   void scanRelocs(InputSectionBase<ELFT> &S, const Elf_Shdr &RelSec);
+  void updateRelro(Elf_Phdr *Cur, Elf_Phdr *GnuRelroPhdr,
+                   OutputSectionBase<ELFT> *Sec, uintX_t VA);
   void assignAddresses();
   void buildSectionMap();
   void openFile(StringRef OutputPath);
   void writeHeader();
   void writeSections();
   bool isDiscarded(InputSectionBase<ELFT> *IS) const;
   StringRef getOutputSectionName(StringRef S) const;
   bool needsInterpSection() const {
private:
   std::vector<OutputSectionBase<ELFT> *> OutputSections;
   unsigned getNumSections() const { return OutputSections.size() + 1; }
 
   void addStartStopSymbols(OutputSectionBase<ELFT> *Sec);
   void setPhdr(Elf_Phdr *PH, uint32_t Type, uint32_t Flags, uintX_t FileOff,
                uintX_t VA, uintX_t Size, uintX_t Align);
   void copyPhdr(Elf_Phdr *PH, OutputSectionBase<ELFT> *From);
 
+  bool HasRelro = false;
   SymbolTable<ELFT> &Symtab;
   std::vector<Elf_Phdr> Phdrs;
 
   uintX_t FileSize;
   uintX_t SectionHeaderOff;
 
   llvm::StringMap<llvm::StringRef> InputToOutputSection;
 };
return StringSwitch<int>(SectionName)
            .Case(".tocbss", 0)
            .Case(".branch_lt", 2)
            .Case(".toc", 3)
            .Case(".toc1", 4)
            .Case(".opd", 5)
            .Default(1);
 }
 
+template <class ELFT> static bool isRelroSection(OutputSectionBase<ELFT> *Sec) {
+  OutputSectionBase<ELFT>::uintX_t Flags = Sec->getFlags();
+  if (!(Flags & SHF_ALLOC) || !(Flags & SHF_WRITE))
+    return false;
+  uint32_t Type = Sec->getType();
+  if ((Flags & SHF_TLS) || (Type == SHT_INIT_ARRAY || Type == SHT_FINI_ARRAY ||
+                            Type == SHT_PREINIT_ARRAY))
+    return true;
+  if (Sec == Out<ELFT>::GotPlt)
+    return Config->ZNow;
+  if (Sec == Out<ELFT>::Dynamic || Sec == Out<ELFT>::Got)
+    return true;
+
+  StringRef Name = Sec->getName();
+  StringRef WhiteList[] = {".data.rel.ro", ".ctors", ".dtors", ".jcr",
+                           ".eh_frame"};
+  return (std::find(std::begin(WhiteList), std::end(WhiteList), Name) !=
+          std::end(WhiteList));
+}
+
 // Output section ordering is determined by this function.
 template <class ELFT>
 static bool compareOutputSections(OutputSectionBase<ELFT> *A,
                                   OutputSectionBase<ELFT> *B) {
   typedef typename ELFFile<ELFT>::uintX_t uintX_t;
 
   uintX_t AFlags = A->getFlags();
   uintX_t BFlags = B->getFlags();
static bool compareOutputSections(OutputSectionBase<ELFT> *A,
   // them is a p_memsz that is larger than p_filesz. Seeing that it
   // zeros the end of the PT_LOAD, so that has to correspond to the
   // nobits sections.
   bool AIsNoBits = A->getType() == SHT_NOBITS;
   bool BIsNoBits = B->getType() == SHT_NOBITS;
   if (AIsNoBits != BIsNoBits)
     return BIsNoBits;
 
+  // We place RelRo section before plain r/w ones.
+  bool AIsRelRo = isRelroSection(A);
+  bool BIsRelRo = isRelroSection(B);
+  if (AIsRelRo != BIsRelRo)
+    return AIsRelRo;
+
   // Some architectures have additional ordering restrictions for sections
   // within the same PT_LOAD.
   if (Config->EMachine == EM_PPC64)
     return getPPC64SectionRank(A->getName()) <
            getPPC64SectionRank(B->getName());
 
   return false;
 }
template <class ELFT> void Writer<ELFT>::createSections() {
   if (Out<ELFT>::GotPlt && !Out<ELFT>::GotPlt->empty())
     OutputSections.push_back(Out<ELFT>::GotPlt);
   if (!Out<ELFT>::Plt->empty())
     OutputSections.push_back(Out<ELFT>::Plt);
 
   std::stable_sort(OutputSections.begin(), OutputSections.end(),
                    compareSections<ELFT>);
 
-  for (unsigned I = 0, N = OutputSections.size(); I < N; ++I)
+  for (unsigned I = 0, N = OutputSections.size(); I < N; ++I) {
     OutputSections[I]->SectionIndex = I + 1;
+    HasRelro |= (Config->ZRelro && isRelroSection(OutputSections[I]));
+  }
 
   for (OutputSectionBase<ELFT> *Sec : OutputSections)
     Out<ELFT>::ShStrTab->add(Sec->getName());
 
   // Finalizers fix each section's size.
   // .dynamic section's finalizer may add strings to .dynstr,
   // so finalize that early.
   // Likewise, .dynsym is finalized early since that may fill up .gnu.hash.
static uint32_t toPhdrFlags(uint64_t Flags) {
   uint32_t Ret = PF_R;
   if (Flags & SHF_WRITE)
     Ret |= PF_W;
   if (Flags & SHF_EXECINSTR)
     Ret |= PF_X;
   return Ret;
 }
 
+template <class ELFT>
+void Writer<ELFT>::updateRelro(Elf_Phdr *Cur, Elf_Phdr *GnuRelroPhdr,
+                               OutputSectionBase<ELFT> *Sec, uintX_t VA) {
+  if (!Config->ZRelro || !(Cur->p_flags & PF_W) || !isRelroSection(Sec))
+    return;
+  if (!GnuRelroPhdr->p_type)
+    setPhdr(GnuRelroPhdr, PT_GNU_RELRO, PF_R, Cur->p_offset, Cur->p_vaddr,
+            VA - Cur->p_vaddr, 1 /*p_align*/);
+  GnuRelroPhdr->p_filesz = VA - Cur->p_vaddr;
+  GnuRelroPhdr->p_memsz = VA - Cur->p_vaddr;
+}
+
 // Visits all sections to create PHDRs and to assign incremental,
 // non-overlapping addresses to output sections.
 template <class ELFT> void Writer<ELFT>::assignAddresses() {
   uintX_t VA = Target->getVAStart() + sizeof(Elf_Ehdr);
   uintX_t FileOff = sizeof(Elf_Ehdr);
 
   // Calculate and reserve the space for the program header first so that
   // the first section can start right after the program header.
template <class ELFT> void Writer<ELFT>::assignAddresses() {
   Elf_Phdr *Interp = nullptr;
   if (needsInterpSection())
     Interp = &Phdrs[++PhdrIdx];
 
   // Add the first PT_LOAD segment for regular output sections.
   setPhdr(&Phdrs[++PhdrIdx], PT_LOAD, PF_R, 0, Target->getVAStart(), FileOff,
           Target->getPageSize());
 
+  Elf_Phdr GnuRelroPhdr = {};
   Elf_Phdr TlsPhdr{};
   uintX_t ThreadBSSOffset = 0;
   // Create phdrs as we assign VAs and file offsets to all output sections.
   for (OutputSectionBase<ELFT> *Sec : OutputSections) {
     if (needsPhdr<ELFT>(Sec)) {
       uintX_t Flags = toPhdrFlags(Sec->getFlags());
       if (Phdrs[PhdrIdx].p_flags != Flags) {
         // Flags changed. Create a new PT_LOAD.
if (needsPhdr<ELFT>(Sec)) {
           TlsPhdr.p_filesz += Sec->getSize();
           VA += Sec->getSize();
         }
         TlsPhdr.p_align = std::max<uintX_t>(TlsPhdr.p_align, Sec->getAlign());
       } else {
         VA = RoundUpToAlignment(VA, Sec->getAlign());
         Sec->setVA(VA);
         VA += Sec->getSize();
+        updateRelro(&Phdrs[PhdrIdx], &GnuRelroPhdr, Sec, VA);
       }
     }
 
     FileOff = RoundUpToAlignment(FileOff, Sec->getAlign());
     Sec->setFileOffset(FileOff);
     if (Sec->getType() != SHT_NOBITS)
       FileOff += Sec->getSize();
     if (needsPhdr<ELFT>(Sec)) {
template <class ELFT> void Writer<ELFT>::assignAddresses() {
 
   // Add an entry for .dynamic.
   if (isOutputDynamic()) {
     Elf_Phdr *PH = &Phdrs[++PhdrIdx];
     PH->p_type = PT_DYNAMIC;
     copyPhdr(PH, Out<ELFT>::Dynamic);
   }
 
+  if (HasRelro) {
+    Elf_Phdr *PH = &Phdrs[++PhdrIdx];
+    *PH = GnuRelroPhdr;
+  }
+
   // PT_GNU_STACK is a special section to tell the loader to make the
   // pages for the stack non-executable.
   if (!Config->ZExecStack) {
     Elf_Phdr *PH = &Phdrs[++PhdrIdx];
     PH->p_type = PT_GNU_STACK;
     PH->p_flags = PF_R | PF_W;
   }
 
for (OutputSectionBase<ELFT> *Sec : OutputSections) {
     uintX_t Flags = toPhdrFlags(Sec->getFlags());
     if (Last != Flags) {
       Last = Flags;
       ++I;
     }
   }
   if (Tls)
     ++I;
+  if (HasRelro)
+    ++I;
   return I;
 }
 
 template <class ELFT> void Writer<ELFT>::writeHeader() {
   uint8_t *Buf = Buffer->getBufferStart();
   memcpy(Buf, "\177ELF", 4);
 
   // Write the ELF header.

lld/trunk/test/ELF/eh-frame-merge.s

 // CHECK-NEXT: Size:
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 8
 // CHECK-NEXT: EntrySize: 0
 // CHECK-NEXT: SectionData (
 // CHECK-NEXT:   0000: 14000000 00000000 017A5200 01781001  |
 // CHECK-NEXT:   0010: 1B0C0708 90010000 10000000 1C000000  |
-// CHECK-NEXT:   0020: 880E0000 01000000 00000000 10000000  |
-// CHECK-NEXT:   0030: 30000000 760E0000 02000000 00000000  |
-// CHECK-NEXT:   0040: 10000000 44000000 610E0000 01000000  |
+// CHECK-NEXT:   0020: 500E0000 01000000 00000000 10000000  |
+// CHECK-NEXT:   0030: 30000000 3E0E0000 02000000 00000000  |
+// CHECK-NEXT:   0040: 10000000 44000000 290E0000 01000000  |
 // CHECK-NEXT:   0050: 00000000                             |
 // CHECK-NEXT: )
 
 // CHECK:      Name: foo
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_EXECINSTR

lld/trunk/test/ELF/gnu-hash-table.s

 # PPC64:      Arch: powerpc64
 # PPC64:      AddressSize: 64bit
 # PPC64:      Sections [
 # PPC64:          Name: .gnu.hash
 # PPC64-NEXT:     Type: SHT_GNU_HASH
 # PPC64-NEXT:     Flags [
 # PPC64-NEXT:       SHF_ALLOC
 # PPC64-NEXT:     ]
-# PPC64-NEXT:     Address: 0x1B8
-# PPC64-NEXT:     Offset: 0x1B8
+# PPC64-NEXT:     Address: 0x1F0
+# PPC64-NEXT:     Offset: 0x1F0
 # PPC64-NEXT:     Size: 36
 # PPC64-NEXT:     Link: 1
 # PPC64-NEXT:     Info: 0
 # PPC64-NEXT:     AddressAlignment: 8
 # PPC64-NEXT:     EntrySize: 0
 # PPC64-NEXT:   }
 # PPC64:      ]
 # PPC64:      DynamicSymbols [

lld/trunk/test/ELF/got-aarch64.s

 // RUN: llvm-mc -filetype=obj -triple=aarch64-unknown-linux %s -o %t.o
 // RUN: ld.lld -shared %t.o -o %t.so
 // RUN: llvm-readobj -s -r %t.so | FileCheck %s
 // RUN: llvm-objdump -d %t.so | FileCheck --check-prefix=DISASM %s
 // REQUIRES: aarch64
 
 // CHECK:      Name: .got
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_WRITE
 // CHECK-NEXT: ]
-// CHECK-NEXT: Address: 0x2098
+// CHECK-NEXT: Address: 0x2090
 // CHECK-NEXT: Offset:
 // CHECK-NEXT: Size: 8
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 8
 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section ({{.*}}) .rela.dyn {
-// CHECK-NEXT:     0x2098 R_AARCH64_GLOB_DAT dat 0x0
+// CHECK-NEXT:     0x2090 R_AARCH64_GLOB_DAT dat 0x0
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
 // Page(0x2098) - Page(0x1000) = 0x1000 = 4096
 // 0x2098 & 0xff8 = 0x98 = 152
 
 // DISASM: main:
 // DISASM-NEXT:     1000: {{.*}} adrp x0, #4096
-// DISASM-NEXT:     1004: {{.*}} ldr x0, [x0, #152]
+// DISASM-NEXT:     1004: {{.*}} ldr x0, [x0, #144]
 
 .global main,foo,dat
 .text
 main:
     adrp x0, :got:dat
     ldr x0, [x0, :got_lo12:dat]
 .data
 dat:
     .word 42

lld/trunk/test/ELF/merge-shared.s

 
 
 // CHECK:      Name: foo
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_MERGE
 // CHECK-NEXT: ]
-// CHECK-NEXT: Address: 0x158
+// CHECK-NEXT: Address: 0x190
 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section ({{.*}}) .rela.dyn {
-// CHECK-NEXT:     0x{{.*}} R_X86_64_RELATIVE - 0x15A
+// CHECK-NEXT:     0x{{.*}} R_X86_64_RELATIVE - 0x192
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]

lld/trunk/test/ELF/merge-string.s

 
 // CHECK:      Name:    .rodata
 // CHECK-NEXT: Type:    SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_MERGE
 // CHECK-NEXT:   SHF_STRINGS
 // CHECK-NEXT: ]
-// CHECK-NEXT: Address:         0x158
-// CHECK-NEXT: Offset:  0x158
+// CHECK-NEXT: Address:         0x190
+// CHECK-NEXT: Offset:  0x190
 // CHECK-NEXT: Size:    4
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 1
 // CHECK-NEXT: EntrySize: 0
 // CHECK-NEXT: SectionData (
 // CHECK-NEXT:   0000: 61626300                             |abc.|
 // CHECK-NEXT: )
 
 // NOTAIL:      Name:    .rodata
 // NOTAIL-NEXT: Type:    SHT_PROGBITS
 // NOTAIL-NEXT: Flags [
 // NOTAIL-NEXT:   SHF_ALLOC
 // NOTAIL-NEXT:   SHF_MERGE
 // NOTAIL-NEXT:   SHF_STRINGS
 // NOTAIL-NEXT: ]
-// NOTAIL-NEXT: Address:         0x158
-// NOTAIL-NEXT: Offset:  0x158
+// NOTAIL-NEXT: Address:         0x190
+// NOTAIL-NEXT: Offset:  0x190
 // NOTAIL-NEXT: Size:    7
 // NOTAIL-NEXT: Link: 0
 // NOTAIL-NEXT: Info: 0
 // NOTAIL-NEXT: AddressAlignment: 1
 // NOTAIL-NEXT: EntrySize: 0
 // NOTAIL-NEXT: SectionData (
 // NOTAIL-NEXT:   0000: 61626300 626300                     |abc.bc.|
 // NOTAIL-NEXT: )
 
 // CHECK:      Name: .rodata
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_MERGE
 // CHECK-NEXT:   SHF_STRINGS
 // CHECK-NEXT: ]
-// CHECK-NEXT: Address: 0x15C
-// CHECK-NEXT: Offset: 0x15C
+// CHECK-NEXT: Address: 0x194
+// CHECK-NEXT: Offset: 0x194
 // CHECK-NEXT: Size: 4
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 2
 // CHECK-NEXT: EntrySize: 0
 // CHECK-NEXT: SectionData (
 // CHECK-NEXT:   0000: 14000000                             |....|
 // CHECK-NEXT: )
 
 
 // CHECK:      Name:    bar
-// CHECK-NEXT: Value:   0x159
+// CHECK-NEXT: Value:   0x191
 
 // CHECK:      Name:    foo
-// CHECK-NEXT: Value:   0x158
+// CHECK-NEXT: Value:   0x190
 
 // CHECK:      Name: zed
-// CHECK-NEXT: Value: 0x15C
+// CHECK-NEXT: Value: 0x194
 // CHECK-NEXT: Size: 0

lld/trunk/test/ELF/merge-sym.s

 
 
 // CHECK:      Name: .rodata
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_MERGE
 // CHECK-NEXT: ]
-// CHECK-NEXT: Address: 0x158
+// CHECK-NEXT: Address: 0x190
 
 // CHECK:      Name: foo
-// CHECK-NEXT: Value: 0x15A
+// CHECK-NEXT: Value: 0x192

lld/trunk/test/ELF/mips-dynamic.s

 # REQUIRES: mips
 
 # EXE:      Sections [
 # EXE:          Name: .dynamic
 # EXE-NEXT:     Type: SHT_DYNAMIC
 # EXE-NEXT:     Flags [
 # EXE-NEXT:       SHF_ALLOC
 # EXE-NEXT:     ]
-# EXE:          Name: .rld_map
+# EXE:          Name: .got
 # EXE-NEXT:     Type: SHT_PROGBITS
-# EXE-NEXT:     Flags [
+# EXE-NEXT:     Flags [ (0x10000003)
 # EXE-NEXT:       SHF_ALLOC
 # EXE-NEXT:       SHF_WRITE
 # EXE-NEXT:     ]
-# EXE-NEXT:     Address: [[RLDMAPADDR:0x[0-9a-f]+]]
+# EXE-NEXT:     Address: [[GOTADDR:0x[0-9a-f]+]]
 # EXE-NEXT:     Offset:
-# EXE-NEXT:     Size: 4
-# EXE:          Name: .got
+# EXE-NEXT:     Size: 8
+# EXE:          Name: .rld_map
 # EXE-NEXT:     Type: SHT_PROGBITS
-# EXE-NEXT:     Flags [ (0x10000003)
+# EXE-NEXT:     Flags [
 # EXE-NEXT:       SHF_ALLOC
 # EXE-NEXT:       SHF_WRITE
 # EXE-NEXT:     ]
-# EXE-NEXT:     Address: [[GOTADDR:0x[0-9a-f]+]]
+# EXE-NEXT:     Address: [[RLDMAPADDR:0x[0-9a-f]+]]
 # EXE-NEXT:     Offset:
-# EXE-NEXT:     Size: 8
+# EXE-NEXT:     Size: 4
 # EXE:      ]
 # EXE:      DynamicSection [
 # EXE-NEXT:   Tag        Type                 Name/Value
 # EXE-DAG:    0x00000003 PLTGOT               [[GOTADDR]]
 # EXE-DAG:    0x70000001 MIPS_RLD_VERSION     1
 # EXE-DAG:    0x70000005 MIPS_FLAGS           NOTPOT
 # EXE-DAG:    0x70000006 MIPS_BASE_ADDRESS
 # EXE-DAG:    0x7000000A MIPS_LOCAL_GOTNO     2

lld/trunk/test/ELF/mips-got-relocs.s

__start:
   .data
   .globl v1
   .type  v1,@object
   .size  v1,4
 v1:
   .word 0
 
 # EXE_SYM: Sections:
-# EXE_SYM: .got 0000000c 0000000000030004 DATA
+# EXE_SYM: .got 0000000c 0000000000030000 DATA
 # EXE_SYM: SYMBOL TABLE:
-# EXE_SYM: 00037ff4         *ABS*    00000000 _gp
+# EXE_SYM: 00037ff0         *ABS*    00000000 _gp
 #          ^-- .got + GP offset (0x7ff0)
-# EXE_SYM: 00030000 g       .data    00000004 v1
+# EXE_SYM: 00030010 g       .data    00000004 v1
 
 # EXE_GOT_BE: Contents of section .got:
-# EXE_GOT_BE:  30004 00000000 80000000 00030000
-#                    ^        ^        ^-- v1 (0x30000)
+# EXE_GOT_BE:  30000 00000000 80000000 00030010
+#                    ^        ^        ^-- v1 (0x30010)
 #                    |        +-- Module pointer (0x80000000)
 #                    +-- Lazy resolver (0x0)
 
 # EXE_GOT_EL: Contents of section .got:
-# EXE_GOT_EL:  30004 00000000 00000080 00000300
-#                    ^        ^        ^-- v1 (0x30000)
+# EXE_GOT_EL:  30000 00000000 00000080 10000300
+#                    ^        ^        ^-- v1 (0x30010)
 #                    |        +-- Module pointer (0x80000000)
 #                    +-- Lazy resolver (0x0)
 
 # v1GotAddr (0x3000c) - _gp (0x37ff4) = -0x7fe8 => 0x8018 = 32792
 # EXE_DIS_BE:  20000:  3c 02 80 18  lui $2, 32792
 # EXE_DIS_EL:  20000:  18 80 02 3c  lui $2, 32792
 
 # DSO_SYM: Sections:
-# DSO_SYM: .got 0000000c 0000000000020004 DATA
+# DSO_SYM: .got 0000000c 0000000000020000 DATA
 # DSO_SYM: SYMBOL TABLE:
-# DSO_SYM: 00027ff4         *ABS*    00000000 _gp
+# DSO_SYM: 00027ff0         *ABS*    00000000 _gp
 #          ^-- .got + GP offset (0x7ff0)
-# DSO_SYM: 00020000 g       .data    00000004 v1
+# DSO_SYM: 00020010 g       .data    00000004 v1
 
 # DSO_GOT_BE: Contents of section .got:
-# DSO_GOT_BE:  20004 00000000 80000000 00020000
-#                    ^        ^        ^-- v1 (0x20000)
+# DSO_GOT_BE:  20000 00000000 80000000 00020010
+#                    ^        ^        ^-- v1 (0x20010)
 #                    |        +-- Module pointer (0x80000000)
 #                    +-- Lazy resolver (0x0)
 
 # DSO_GOT_EL: Contents of section .got:
-# DSO_GOT_EL:  20004 00000000 00000080 00000200
-#                    ^        ^        ^-- v1 (0x20000)
+# DSO_GOT_EL:  20000 00000000 00000080 10000200
+#                    ^        ^        ^-- v1 (0x20010)
 #                    |        +-- Module pointer (0x80000000)
 #                    +-- Lazy resolver (0x0)
 
 # v1GotAddr (0x2000c) - _gp (0x27ff4) = -0x7fe8 => 0x8018 = 32792
 # DSO_DIS_BE:  10000:  3c 02 80 18  lui $2, 32792
 # DSO_DIS_EL:  10000:  18 80 02 3c  lui $2, 32792
 
 # NORELOC:      Relocations [
 # NORELOC-NEXT: ]
 
 # SHFLAGS:      Name: .got
 # SHFLAGS-NEXT: Type: SHT_PROGBITS
 # SHFLAGS-NEXT: Flags [ (0x10000003)
 #                        ^-- SHF_MIPS_GPREL | SHF_ALLOC | SHF_WRITE

lld/trunk/test/ELF/relative-dynamic-reloc-ppc64.s

 // RUN: llvm-mc -filetype=obj -triple=powerpc64-unknown-linux %s -o %t.o
 // RUN: ld.lld -shared %t.o -o %t.so
 // RUN: llvm-readobj -t -r -dyn-symbols %t.so | FileCheck %s
 // REQUIRES: ppc
 
 // Test that we create R_PPC64_RELATIVE relocations but don't put any
 // symbols in the dynamic symbol table.
 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section ({{.*}}) .rela.dyn {
 // CHECK-NEXT:     0x[[FOO_ADDR:.*]] R_PPC64_RELATIVE - 0x[[FOO_ADDR]]
 // CHECK-NEXT:     0x[[BAR_ADDR:.*]] R_PPC64_RELATIVE - 0x[[BAR_ADDR]]
 // CHECK-NEXT:     0x10010 R_PPC64_RELATIVE - 0x10009
 // CHECK-NEXT:     0x{{.*}} R_PPC64_RELATIVE - 0x[[ZED_ADDR:.*]]
 // CHECK-NEXT:     0x{{.*}} R_PPC64_RELATIVE - 0x[[FOO_ADDR]]
-// CHECK-NEXT:     0x160 R_PPC64_ADDR64 external 0x0
+// CHECK-NEXT:     0x198 R_PPC64_ADDR64 external 0x0
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
 // CHECK:      Symbols [
 // CHECK:        Name: foo
 // CHECK-NEXT:   Value: 0x[[FOO_ADDR]]
 // CHECK:        Name: bar
 // CHECK-NEXT:   Value: 0x[[BAR_ADDR]]

lld/trunk/test/ELF/relative-dynamic-reloc.s

 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 // RUN: ld.lld -shared %t.o -o %t.so
 // RUN: llvm-readobj -t -r -dyn-symbols %t.so | FileCheck %s
 
 // Test that we create R_X86_64_RELATIVE relocations but don't put any
 // symbols in the dynamic symbol table.
 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section ({{.*}}) .rela.dyn {
 // CHECK-NEXT:     0x[[FOO_ADDR:.*]] R_X86_64_RELATIVE - 0x[[FOO_ADDR]]
 // CHECK-NEXT:     0x[[BAR_ADDR:.*]] R_X86_64_RELATIVE - 0x[[BAR_ADDR]]
 // CHECK-NEXT:     0x1010 R_X86_64_RELATIVE - 0x1009
 // CHECK-NEXT:     0x{{.*}} R_X86_64_RELATIVE - 0x[[ZED_ADDR:.*]]
 // CHECK-NEXT:     0x{{.*}} R_X86_64_RELATIVE - 0x[[FOO_ADDR]]
-// CHECK-NEXT:     0x160 R_X86_64_64 external 0x0
+// CHECK-NEXT:     0x198 R_X86_64_64 external 0x0
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
 // CHECK:      Symbols [
 // CHECK:        Name: foo
 // CHECK-NEXT:   Value: 0x[[FOO_ADDR]]
 // CHECK:        Name: bar
 // CHECK-NEXT:   Value: 0x[[BAR_ADDR]]

lld/trunk/test/ELF/relocation.s

 // CHECK-NEXT:  1101c:   {{.*}}  movl $69696, %eax
 
 .section .R_X86_64_64,"a",@progbits
 .global R_X86_64_64
 R_X86_64_64:
  .quad R_X86_64_64
 
 // CHECK:      Contents of section .R_X86_64_64:
-// CHECK-NEXT:   10158 58010100 00000000
+// CHECK-NEXT:   10190 90010100 00000000
 
 .section .R_X86_64_GOTPCREL,"a",@progbits
 .global R_X86_64_GOTPCREL
 R_X86_64_GOTPCREL:
  .long zed@gotpcrel
 
 // 0x120A8 - 0x10160 = 8008
 // 8008 = 0x481f0000   in little endian
 // CHECK:      Contents of section .R_X86_64_GOTPCREL
-// CHECK-NEXT:   10160 801f0000
+// CHECK-NEXT:   10198 481f0000

lld/trunk/test/ELF/relro.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/shared.s -o %t2.o
+// RUN: ld.lld -shared %t2.o -o %t2.so
+// RUN: ld.lld %t.o %t2.so -z now -z relro -o %t
+// RUN: llvm-readobj --program-headers --dynamic-table -t -s -dyn-symbols -section-data %t | FileCheck --check-prefix=FULLRELRO %s
+// RUN: ld.lld %t.o %t2.so -z relro -o %t
+// RUN: llvm-readobj --program-headers --dynamic-table -t -s -dyn-symbols -section-data %t | FileCheck --check-prefix=PARTRELRO %s
+// RUN: ld.lld %t.o %t2.so -z norelro -o %t
+// RUN: llvm-readobj --program-headers --dynamic-table -t -s -dyn-symbols -section-data %t | FileCheck --check-prefix=NORELRO %s
+// REQUIRES: x86
+
+// FULLRELRO:        Section {
+// FULLRELRO:        Index: 9
+// FULLRELRO-NEXT:   Name: .got
+// FULLRELRO-NEXT:   Type: SHT_PROGBITS
+// FULLRELRO-NEXT:   Flags [
+// FULLRELRO-NEXT:     SHF_ALLOC
+// FULLRELRO-NEXT:     SHF_WRITE
+// FULLRELRO-NEXT:   ]
+// FULLRELRO-NEXT:   Address: 0x12100
+// FULLRELRO-NEXT:   Offset: 0x2100
+// FULLRELRO-NEXT:   Size: 8
+// FULLRELRO-NEXT:   Link: 0
+// FULLRELRO-NEXT:   Info: 0
+// FULLRELRO-NEXT:   AddressAlignment: 8
+// FULLRELRO-NEXT:   EntrySize: 0
+// FULLRELRO-NEXT:   SectionData (
+// FULLRELRO-NEXT:     0000: 00000000 00000000
+// FULLRELRO-NEXT:   )
+// FULLRELRO-NEXT: }
+// FULLRELRO-NEXT: Section {
+// FULLRELRO-NEXT:   Index: 10
+// FULLRELRO-NEXT:   Name: .got.plt
+// FULLRELRO-NEXT:   Type: SHT_PROGBITS
+// FULLRELRO-NEXT:   Flags [
+// FULLRELRO-NEXT:     SHF_ALLOC
+// FULLRELRO-NEXT:     SHF_WRITE
+// FULLRELRO-NEXT:   ]
+// FULLRELRO-NEXT:   Address: 0x12108
+// FULLRELRO-NEXT:   Offset: 0x2108
+// FULLRELRO-NEXT:   Size: 32
+// FULLRELRO-NEXT:   Link: 0
+// FULLRELRO-NEXT:   Info: 0
+// FULLRELRO-NEXT:   AddressAlignment: 8
+// FULLRELRO-NEXT:   EntrySize: 0
+// FULLRELRO-NEXT:   SectionData (
+// FULLRELRO-NEXT:     0000:
+// FULLRELRO-NEXT:     0010:
+// FULLRELRO-NEXT:   )
+// FULLRELRO-NEXT: }
+// FULLRELRO-NEXT: Section {
+// FULLRELRO-NEXT:   Index: 11
+// FULLRELRO-NEXT:   Name: .data
+// FULLRELRO-NEXT:   Type: SHT_PROGBITS
+// FULLRELRO-NEXT:   Flags [
+// FULLRELRO-NEXT:     SHF_ALLOC
+// FULLRELRO-NEXT:     SHF_WRITE
+// FULLRELRO-NEXT:   ]
+// FULLRELRO-NEXT:   Address: 0x12128
+// FULLRELRO-NEXT:   Offset: 0x2128
+// FULLRELRO-NEXT:   Size: 12
+// FULLRELRO-NEXT:   Link: 0
+// FULLRELRO-NEXT:   Info: 0
+// FULLRELRO-NEXT:   AddressAlignment:
+// FULLRELRO-NEXT:   EntrySize: 0
+// FULLRELRO-NEXT:   SectionData (
+// FULLRELRO-NEXT:     0000:
+// FULLRELRO-NEXT:   )
+// FULLRELRO-NEXT: }
+// FULLRELRO-NEXT: Section {
+// FULLRELRO-NEXT:   Index: 12
+// FULLRELRO-NEXT:   Name: .foo
+// FULLRELRO-NEXT:   Type: SHT_PROGBITS
+// FULLRELRO-NEXT:   Flags [
+// FULLRELRO-NEXT:     SHF_ALLOC
+// FULLRELRO-NEXT:     SHF_WRITE
+// FULLRELRO-NEXT:   ]
+// FULLRELRO-NEXT:   Address: 0x12134
+// FULLRELRO-NEXT:   Offset: 0x2134
+// FULLRELRO-NEXT:   Size: 0
+// FULLRELRO-NEXT:   Link: 0
+// FULLRELRO-NEXT:   Info: 0
+// FULLRELRO-NEXT:   AddressAlignment:
+// FULLRELRO-NEXT:   EntrySize: 0
+// FULLRELRO-NEXT:   SectionData (
+// FULLRELRO-NEXT:   )
+// FULLRELRO-NEXT: }
+// 308 - sizeof(.data)(12) = 296
+// FULLRELRO:       ProgramHeaders [
+// FULLRELRO:       Type: PT_LOAD
+// FULLRELRO:       Offset: 0x2000
+// FULLRELRO-NEXT:  VirtualAddress: [[RWADDR:.*]]
+// FULLRELRO-NEXT:  PhysicalAddress:
+// FULLRELRO-NEXT:  FileSize: 308
+// FULLRELRO-NEXT:  MemSize: 308
+// FULLRELRO-NEXT:  Flags [
+// FULLRELRO-NEXT:    PF_R
+// FULLRELRO-NEXT:    PF_W
+// FULLRELRO-NEXT:  ]
+// FULLRELRO-NEXT:  Alignment: 4096
+// FULLRELRO-NEXT:}
+// FULLRELRO:       Type: PT_GNU_RELRO
+// FULLRELRO-NEXT:  Offset: 0x
+// FULLRELRO-NEXT:  VirtualAddress: [[RWADDR]]
+// FULLRELRO-NEXT:  PhysicalAddress:
+// FULLRELRO-NEXT:  FileSize: 296
+// FULLRELRO-NEXT:  MemSize: 296
+// FULLRELRO-NEXT:  Flags [
+// FULLRELRO-NEXT:    PF_R
+// FULLRELRO-NEXT:  ]
+// FULLRELRO-NEXT:  Alignment: 1
+// FULLRELRO-NEXT:}
+
+// PARTRELRO:       Section {
+// PARTRELRO:       Index: 9
+// PARTRELRO-NEXT:  Name: .got
+// PARTRELRO-NEXT:  Type: SHT_PROGBITS
+// PARTRELRO-NEXT:  Flags [
+// PARTRELRO-NEXT:    SHF_ALLOC
+// PARTRELRO-NEXT:    SHF_WRITE
+// PARTRELRO-NEXT:  ]
+// PARTRELRO-NEXT:  Address: 0x120E0
+// PARTRELRO-NEXT:  Offset: 0x20E0
+// PARTRELRO-NEXT:  Size: 8
+// PARTRELRO-NEXT:  Link: 0
+// PARTRELRO-NEXT:  Info: 0
+// PARTRELRO-NEXT:  AddressAlignment: 8
+// PARTRELRO-NEXT:  EntrySize: 0
+// PARTRELRO-NEXT:  SectionData (
+// PARTRELRO-NEXT:    0000:
+// PARTRELRO-NEXT:  )
+// PARTRELRO-NEXT:  }
+// PARTRELRO-NEXT:  Section {
+// PARTRELRO-NEXT:  Index: 10
+// PARTRELRO-NEXT:  Name: .data
+// PARTRELRO-NEXT:  Type: SHT_PROGBITS
+// PARTRELRO-NEXT:  Flags [
+// PARTRELRO-NEXT:    SHF_ALLOC
+// PARTRELRO-NEXT:    SHF_WRITE
+// PARTRELRO-NEXT:  ]
+// PARTRELRO-NEXT:  Address: 0x120E8
+// PARTRELRO-NEXT:  Offset: 0x20E8
+// PARTRELRO-NEXT:  Size: 12
+// PARTRELRO-NEXT:  Link: 0
+// PARTRELRO-NEXT:  Info: 0
+// PARTRELRO-NEXT:  AddressAlignment: 1
+// PARTRELRO-NEXT:  EntrySize: 0
+// PARTRELRO-NEXT:  SectionData (
+// PARTRELRO-NEXT:    0000:
+// PARTRELRO-NEXT:  )
+// PARTRELRO-NEXT:  }
+// PARTRELRO-NEXT:  Section {
+// PARTRELRO-NEXT:    Index: 11
+// PARTRELRO-NEXT:    Name: .foo
+// PARTRELRO-NEXT:    Type: SHT_PROGBITS
+// PARTRELRO-NEXT:    Flags [
+// PARTRELRO-NEXT:      SHF_ALLOC
+// PARTRELRO-NEXT:      SHF_WRITE
+// PARTRELRO-NEXT:    ]
+// PARTRELRO-NEXT:    Address: 0x120F4
+// PARTRELRO-NEXT:    Offset: 0x20F4
+// PARTRELRO-NEXT:    Size: 0
+// PARTRELRO-NEXT:    Link: 0
+// PARTRELRO-NEXT:    Info: 0
+// PARTRELRO-NEXT:    AddressAlignment: 1
+// PARTRELRO-NEXT:    EntrySize: 0
+// PARTRELRO-NEXT:    SectionData (
+// PARTRELRO-NEXT:    )
+// PARTRELRO-NEXT:  }
+// PARTRELRO-NEXT:  Section {
+// PARTRELRO-NEXT:    Index: 12
+// PARTRELRO-NEXT:    Name: .got.plt
+// PARTRELRO-NEXT:    Type: SHT_PROGBITS
+// PARTRELRO-NEXT:    Flags [
+// PARTRELRO-NEXT:      SHF_ALLOC
+// PARTRELRO-NEXT:      SHF_WRITE
+// PARTRELRO-NEXT:    ]
+// PARTRELRO-NEXT:    Address: 0x120F8
+// PARTRELRO-NEXT:    Offset: 0x20F8
+// PARTRELRO-NEXT:    Size: 32
+// PARTRELRO-NEXT:    Link: 0
+// PARTRELRO-NEXT:    Info: 0
+// PARTRELRO-NEXT:    AddressAlignment: 8
+// PARTRELRO-NEXT:    EntrySize: 0
+// PARTRELRO-NEXT:    SectionData (
+// PARTRELRO-NEXT:      0000:
+// PARTRELRO-NEXT:      0010:
+// PARTRELRO-NEXT:    )
+// PARTRELRO-NEXT:  }
+// PARTRELRO-NEXT:  Section {
+// PARTRELRO-NEXT:    Index: 13
+// PARTRELRO-NEXT:    Name: .bss
+// PARTRELRO-NEXT:    Type: SHT_NOBITS
+// PARTRELRO-NEXT:    Flags [
+// PARTRELRO-NEXT:      SHF_ALLOC
+// PARTRELRO-NEXT:      SHF_WRITE
+// PARTRELRO-NEXT:    ]
+// PARTRELRO-NEXT:    Address: 0x12118
+// PARTRELRO-NEXT:    Offset: 0x2118
+// PARTRELRO-NEXT:    Size: 0
+// PARTRELRO-NEXT:    Link: 0
+// PARTRELRO-NEXT:    Info: 0
+// PARTRELRO-NEXT:    AddressAlignment: 1
+// PARTRELRO-NEXT:    EntrySize: 0
+// PARTRELRO-NEXT:  }
+// 232 + sizeof(.data)(12) + align(4) + sizeof(.got.plt)(32) = 280
+// PARTRELRO:       ProgramHeader {
+// PARTRELRO:       Type: PT_LOAD
+// PARTRELRO:       Offset: 0x2000
+// PARTRELRO-NEXT:  VirtualAddress: [[RWADDR:.*]]
+// PARTRELRO-NEXT:  PhysicalAddress:
+// PARTRELRO-NEXT:  FileSize: 280
+// PARTRELRO-NEXT:  MemSize: 280
+// PARTRELRO-NEXT:  Flags [
+// PARTRELRO-NEXT:    PF_R (0x4)
+// PARTRELRO-NEXT:    PF_W (0x2)
+// PARTRELRO-NEXT:  ]
+// PARTRELRO-NEXT:  Alignment: 4096
+// PARTRELRO:       Type: PT_GNU_RELRO
+// PARTRELRO-NEXT:  Offset: 0x2000
+// PARTRELRO-NEXT:  VirtualAddress: [[RWADDR]]
+// PARTRELRO-NEXT:  PhysicalAddress:
+// PARTRELRO-NEXT:  FileSize: 232
+// PARTRELRO-NEXT:  MemSize: 232
+// PARTRELRO-NEXT:  Flags [
+// PARTRELRO-NEXT:    PF_R
+// PARTRELRO-NEXT:  ]
+// PARTRELRO-NEXT:  Alignment: 1
+
+// NORELRO:     ProgramHeaders [
+// NORELRO-NOT: PT_GNU_RELRO
+
+.global _start
+_start:
+  .long bar
+  jmp *bar@GOTPCREL(%rip)
+
+.section .data,"aw"
+.quad 0
+
+.zero 4
+.section .foo,"aw"
+.section .bss,"",@nobits

lld/trunk/test/ELF/section-name.s

 .section .data.rel.ro.a,"aw",%progbits
 .section .data.rel.ro.local,"aw",%progbits
 .section .data.rel.ro.local.a,"aw",%progbits
 
 // CHECK-NOT: Name: .rodata.a
 // CHECK:     Name: .rodata
 // CHECK-NOT: Name: .text.a
 // CHECK:     Name: .text
+// CHECK-NOT: Name: .data.rel.ro.a
+// CHECK-NOT: Name: .data.rel.ro.local.a
+// CHECK:     Name: .data.rel.ro
 // CHECK-NOT: Name: .data.a
 // CHECK:     Name: .data
 // CHECK:     Name: .foo.a
 // CHECK:     Name: .foo
-// CHECK-NOT: Name: .data.rel.ro.a
-// CHECK-NOT: Name: .data.rel.ro.local.a
-// CHECK:     Name: .data.rel.ro
 // CHECK-NOT: Name: .bss.a
 // CHECK:     Name: .bss

lld/trunk/test/ELF/shared.s

 // test that .hash is linked to .dynsym
 // CHECK:        Index: 2
 // CHECK-NEXT:   Name: .dynsym
 // CHECK-NEXT:   Type: SHT_DYNSYM
 // CHECK-NEXT:   Flags [
 // CHECK-NEXT:     SHF_ALLOC
 // CHECK-NEXT:   ]
 // CHECK-NEXT:   Address: [[DYNSYMADDR:.*]]
-// CHECK-NEXT:   Offset: 0x110
+// CHECK-NEXT:   Offset: 0x130
 // CHECK-NEXT:   Size:
 // CHECK-NEXT:   Link: [[DYNSTR:.*]]
 // CHECK-NEXT:   Info: 1
 // CHECK-NEXT:   AddressAlignment: 4
 // CHECK-NEXT:   EntrySize: 16
 // CHECK-NEXT:   SectionData (
 // CHECK-NEXT:     0000:
 // CHECK-NEXT:     0010: