[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

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

[grimar]

ELF/Driver.cpp

192

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

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

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

329

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

329

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

386

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

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

return AIsRelRo;

768

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

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

ELF/Writer.cpp

763

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

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

386

Done.

763

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.

768

Done.

[• rafael]

ELF/Writer.cpp

327

This has to be a whitelist.

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

692

delete the empty line.

[ruiu]

ELF/Driver.cpp

192

We probably should enable this by default, too.

ELF/Writer.cpp

48

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

693

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

700

Remove this blank line.

803

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

839–840

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

[grimar]

Review comments addressed.

ELF/Writer.cpp

327

Done.

692

Done.

693

Done.

700

Done.

839–840

Fixed

[• rafael]

ELF/Writer.cpp

333

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

336

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

[grimar]

ELF/Writer.cpp

336

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

386

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

622

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.

ELF/Config.h

struct Configuration {
   bool Shared;
   bool Static = false;
   bool StripAll;
   bool SysvHash = true;
   bool Verbose;
   bool ZNodelete = false;
   bool ZNow = false;
   bool ZOrigin = false;
+  bool ZRelro = false;
   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

ELF/Driver.cpp

void LinkerDriver::createFiles(opt::InputArgList &Args) {
   for (auto *Arg : Args.filtered(OPT_z)) {
     StringRef S = Arg->getValue();
     if (S == "nodelete")
       Config->ZNodelete = true;
     else if (S == "now")
       Config->ZNow = true;
     else if (S == "origin")
       Config->ZOrigin = true;
+    else if (S == "relro")
+      Config->ZRelro = true;
+    else if (S == "norelro")
+      Config->ZRelro = false;
   }
 
   for (auto *Arg : Args) {
     switch (Arg->getOption().getID()) {
     case OPT_l:
       addFile(searchLibrary(Arg->getValue()));
       break;
     case OPT_INPUT:

ELF/Writer.cpp

 
 private:
   void copyLocalSymbols();
   void createSections();
   template <bool isRela>
   void scanRelocs(const InputSection<ELFT> &C,
                   iterator_range<const Elf_Rel_Impl<ELFT, isRela> *> Rels);
   void scanRelocs(const InputSection<ELFT> &C);
+  void updateRelRo(Elf_Phdr *Cur, Elf_Phdr *GnuRelroPhdr,
+                   OutputSectionBase<ELFT> *Sec, uintX_t VA);
   void assignAddresses();
   void openFile(StringRef OutputPath);
   void writeHeader();
   void writeSections();
   bool needsInterpSection() const {
     return !Symtab.getSharedFiles().empty() && !Config->DynamicLinker.empty();
   }
   bool isOutputDynamic() const {
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) {
+  if (Sec == Out<ELFT>::GotPlt)
+    return Config->ZNow;
+  return (Sec->getName() != ".data" && Sec->getType() != SHT_NOBITS);
+}
+
 // 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();
 
   // Allocatable sections go first to reduce the total PT_LOAD size and
   // so debug info doesn't change addresses in actual code.
   bool AIsAlloc = AFlags & SHF_ALLOC;
   bool BIsAlloc = BFlags & SHF_ALLOC;
   if (AIsAlloc != BIsAlloc)
     return AIsAlloc;
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;
 
+  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>::Plt->empty())
     OutputSections.push_back(Out<ELFT>::Plt);
 
   std::stable_sort(OutputSections.begin(), OutputSections.end(),
                    compareOutputSections<ELFT>);
 
   for (unsigned I = 0, N = OutputSections.size(); I < N; ++I)
     OutputSections[I]->SectionIndex = I + 1;
 
   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.
   Out<ELFT>::Dynamic->finalize();
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))
+    return;
+
+  if (isRelroSection(Sec)) {
+    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)) {
         if (Sec->getType() == SHT_NOBITS) {
           ThreadBSSOffset = TVA - VA + Sec->getSize();
         } else {
           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)) {
       Elf_Phdr *Cur = &Phdrs[PhdrIdx];
template <class ELFT> void Writer<ELFT>::assignAddresses() {
   }
 
   // Fix up PT_INTERP as we now know the address of .interp section.
   if (Interp) {
     Interp->p_type = PT_INTERP;
     copyPhdr(Interp, Out<ELFT>::Interp);
   }
 
+  if (GnuRelroPhdr.p_filesz) {
+    Elf_Phdr *PH = &Phdrs[++PhdrIdx];
+    *PH = GnuRelroPhdr;
+  }
+
   // Add space for section headers.
   SectionHeaderOff = RoundUpToAlignment(FileOff, ELFT::Is64Bits ? 8 : 4);
   FileSize = SectionHeaderOff + getNumSections() * sizeof(Elf_Shdr);
 
   // Update MIPS _gp absolute symbol so that it points to the static data.
   if (Config->EMachine == EM_MIPS)
     DefinedAbsolute<ELFT>::MipsGp.st_value = getMipsGpAddr<ELFT>();
 }
for (OutputSectionBase<ELFT> *Sec : OutputSections) {
     uintX_t Flags = toPhdrFlags(Sec->getFlags());
     if (Last != Flags) {
       Last = Flags;
       ++I;
     }
   }
   if (Tls)
     ++I;
+  if (Config->ZRelro)
+    ++I;
   return I;
 }
 
 template <class ELFT> void Writer<ELFT>::writeHeader() {
   uint8_t *Buf = Buffer->getBufferStart();
   memcpy(Buf, "\177ELF", 4);
 
   // Write the ELF header.

test/elf2/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 0000000000020034 DATA
+# DSO_SYM: .got 0000000c 0000000000020030 DATA
 # DSO_SYM: SYMBOL TABLE:
-# DSO_SYM: 00028024         *ABS*    00000000 _gp
+# DSO_SYM: 00028020         *ABS*    00000000 _gp
 #          ^-- .got + GP offset (0x7ff0)
-# DSO_SYM: 00020000 g       .data    00000004 v1
+# DSO_SYM: 00020040 g       .data    00000004 v1
 
 # DSO_GOT_BE: Contents of section .got:
-# DSO_GOT_BE:  20034 00000000 80000000 00020000
-#                    ^        ^        ^-- v1 (0x20000)
+# DSO_GOT_BE:  20030 00000000 80000000 00020040
+#                    ^        ^        ^-- v1 (0x20040)
 #                    |        +-- Module pointer (0x80000000)
 #                    +-- Lazy resolver (0x0)
 
 # DSO_GOT_EL: Contents of section .got:
-# DSO_GOT_EL:  20034 00000000 00000080 00000200
-#                    ^        ^        ^-- v1 (0x20000)
+# DSO_GOT_EL:  20030 00000000 00000080 40000200
+#                    ^        ^        ^-- v1 (0x20040)
 #                    |        +-- Module pointer (0x80000000)
 #                    +-- Lazy resolver (0x0)
 
 # v1GotAddr (0x2003c) - _gp (0x28024) = -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

test/elf2/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.lld2 -shared %t2.o -o %t2.so
+// RUN: ld.lld2 %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.lld2 %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.lld2 %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
+// RUN: ld.lld2 %t.o %t2.so -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: .bss
+// FULLRELRO-NEXT:   Type: SHT_NOBITS
+// 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: }
+// 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: .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: 12
+// 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
+.bss

test/elf2/section-name.s

 .section .bss,"",@nobits
 .section .foo.a,"aw"
 .section .foo,"aw"
 
 // CHECK-NOT: Name: .rodata.a
 // CHECK:     Name: .rodata
 // CHECK-NOT: Name: .text.a
 // CHECK:     Name: .text
-// CHECK-NOT: Name: .data.a
-// CHECK:     Name: .data
 // CHECK:     Name: .foo.a
 // CHECK:     Name: .foo
+// CHECK-NOT: Name: .data.a
+// CHECK:     Name: .data
 // CHECK-NOT: Name: .bss.a
 // CHECK:     Name: .bss