[ELF] Skip over empty sections when checking for contiguous relro

[peter.smith]

Summary

This is patch 2 of 3 spun out from D40029 covering : Relax handling of empty sections..

When checking for contiguous relro sections we can skip over empty sections. If there is an empty non-relro section in the middle of a contiguous block of relro sections then it cannot be written to so it is safe to include in PT_GNU_RELRO header. If there is a contiguous block of empty relro sections then no PT_GNU_RELRO header is required for them.

The check for an OutputSection being empty is a little more complex than I'd like. As the size of some synthetic sections isn't known at the point we need to check for zero size we have to use SyntheticSection::empty() to check.

Patch 3 will cover:

• Name change when linker scripts are used.

lld/trunk/ELF/Writer.cpp

 static uint64_t computeFlags(uint64_t Flags) {
   if (Config->Omagic)
     return PF_R | PF_W | PF_X;
   if (Config->SingleRoRx && !(Flags & PF_W))
     return Flags | PF_X;
   return Flags;
 }
 
+// Prior to finalizeContents() an OutputSection containing SyntheticSections
+// may have 0 Size, but contain SyntheticSections that haven't had their size
+// calculated yet. We must use SyntheticSection->empty() for these sections.
+static bool isOutputSectionZeroSize(const OutputSection* Sec) {
+  if (Sec->Size > 0)
+    return false;
+  for (BaseCommand *BC : Sec->SectionCommands) {
+    if (auto *ISD = dyn_cast<InputSectionDescription>(BC))
+      for (InputSection *IS : ISD->Sections)
+        if (SyntheticSection *SS = dyn_cast<SyntheticSection>(IS))
+          if (!SS->empty())
+            return false;
+    }
+  return true;
+}
+
 // Decide which program headers to create and which sections to include in each
 // one.
 template <class ELFT> std::vector<PhdrEntry *> Writer<ELFT>::createPhdrs() {
   std::vector<PhdrEntry *> Ret;
   auto AddHdr = [&](unsigned Type, unsigned Flags) -> PhdrEntry * {
     Ret.push_back(make<PhdrEntry>(Type, Flags));
     return Ret.back();
   };
template <class ELFT> std::vector<PhdrEntry *> Writer<ELFT>::createPhdrs() {
   // PT_GNU_RELRO includes all sections that should be marked as
   // read-only by dynamic linker after proccessing relocations.
   // Current dynamic loaders only support one PT_GNU_RELRO PHDR, give
   // an error message if more than one PT_GNU_RELRO PHDR is required.
   PhdrEntry *RelRo = make<PhdrEntry>(PT_GNU_RELRO, PF_R);
   bool InRelroPhdr = false;
   bool IsRelroFinished = false;
   for (OutputSection *Sec : OutputSections) {
-    if (!needsPtLoad(Sec))
+    if (!needsPtLoad(Sec) || isOutputSectionZeroSize(Sec))
       continue;
     if (isRelroSection(Sec)) {
       InRelroPhdr = true;
       if (!IsRelroFinished)
         RelRo->add(Sec);
       else
         error("section: " + Sec->Name + " is not contiguous with other relro" +
               " sections");

lld/trunk/test/ELF/relro-non-contiguous-zerosize.s

+// RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/shared.s -o %t.o
+// RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/copy-in-shared.s -o %t2.o
+// RUN: ld.lld -shared %t.o %t2.o -o %t.so
+
+// Check that we ignore zero sized non-relro sections that are covered by the
+// range of addresses covered by the PT_GNU_RELRO header.
+// Check that we ignore zero sized relro sections that are disjoint from the
+// range of addresses covered by the PT_GNU_RELRO header.
+// REQUIRES: x86
+
+// RUN: echo "SECTIONS { \
+// RUN: .ctors : { *(.ctors) } \
+// RUN: .large1 : { *(.large1) } \
+// RUN: .dynamic : { *(.dynamic) } \
+// RUN: .zero_size : { *(.zero_size) } \
+// RUN: .jcr : { *(.jcr) } \
+// RUN: .got.plt : { *(.got.plt) } \
+// RUN: .large2 : { *(.large2) } \
+// RUN: .data.rel.ro : { *(.data.rel.ro.*) } \
+// RUN: } " > %t.script
+// RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t3.o
+// RUN: ld.lld %t3.o %t.so -o %t --script=%t.script
+// RUN: llvm-readobj -program-headers %t | FileCheck %s
+
+// CHECK: Type: PT_GNU_RELRO
+// CHECK-NEXT: Offset:
+// CHECK-NEXT: VirtualAddress:
+// CHECK-NEXT: PhysicalAddress:
+// CHECK-NEXT: FileSize:
+// CHECK-NEXT: MemSize: 4096
+
+        .section .text, "ax", @progbits
+        .global _start
+        .global bar
+        .global foo
+_start:
+        callq bar
+
+        // page size non-relro sections that would alter PT_GNU_RELRO header
+        // MemSize if counted as part of relro.
+        .section .large1, "aw", @progbits
+        .space 4 * 1024
+
+        .section .large2, "aw", @progbits
+        .space 4 * 1024
+        
+        // empty relro section
+        .section .ctors, "aw", @progbits
+        
+        // non-empty relro section
+        .section .jcr, "aw", @progbits
+        .quad 0
+
+        // empty non-relro section
+        .section .zero_size, "aw", @progbits
+        .global sym
+sym:
+
+        // empty relro section
+        .section .data.rel.ro, "aw", @progbits
+        .global sym2
+sym2: