[ELF] - Allow discarding .dynsym from the linker script.

[grimar]

Summary

This is a part of https://bugs.llvm.org/show_bug.cgi?id=39810.
The patch allows discarding the .dynsym section using linker script.

[ruiu]

Not needed anymore?

[nickdesaulniers]

These might still be needed: http://lists.infradead.org/pipermail/linux-arm-kernel/2018-December/617179.html.

[ruiu]

LGTM

ELF/LinkerScript.cpp

for (const SectionPattern &Pat : Cmd->SectionPatterns) {
     sortInputSections(MutableArrayRef<InputSection *>(Ret).slice(SizeBefore),
                       Pat);
   }
   return Ret;
 }
 
 void LinkerScript::discard(ArrayRef<InputSection *> V) {
   for (InputSection *S : V) {
-    if (S == In.ShStrTab || S == In.Dynamic || S == In.DynSymTab ||
-        S == In.RelaDyn || S == In.RelrDyn)
+    if (S == In.ShStrTab || S == In.Dynamic || S == In.RelaDyn ||
+        S == In.RelrDyn)
       error("discarding " + S->Name + " section is not allowed");
 
     // You can discard .hash and .gnu.hash sections by linker scripts. Since
     // they are synthesized sections, we need to handle them differently than
     // other regular sections.
     if (S == In.GnuHashTab)
       In.GnuHashTab = nullptr;
     if (S == In.HashTab)

ELF/SyntheticSections.cpp

void RelocationBaseSection::addReloc(const DynamicReloc &Reloc) {
   Relocs.push_back(Reloc);
 }
 
 void RelocationBaseSection::finalizeContents() {
   // When linking glibc statically, .rel{,a}.plt contains R_*_IRELATIVE
   // relocations due to IFUNC (e.g. strcpy). sh_link will be set to 0 in that
   // case.
   InputSection *SymTab = Config->Relocatable ? In.SymTab : In.DynSymTab;
-  getParent()->Link = SymTab ? SymTab->getParent()->SectionIndex : 0;
+  if (SymTab && SymTab->getParent())
+    getParent()->Link = SymTab->getParent()->SectionIndex;
+  else
+    getParent()->Link = 0;
 
   if (In.RelaIplt == this || In.RelaPlt == this)
     getParent()->Info = In.GotPlt->getParent()->SectionIndex;
 }
 
 RelrBaseSection::RelrBaseSection()
     : SyntheticSection(SHF_ALLOC,
                        Config->UseAndroidRelrTags ? SHT_ANDROID_RELR : SHT_RELR,

 // DSOs very quickly. If you are sure that your dynamic linker knows
 // about .gnu.hash, you want to specify -hash-style=gnu. Otherwise, a
 // safe bet is to specify -hash-style=both for backward compatibilty.
 GnuHashTableSection::GnuHashTableSection()
     : SyntheticSection(SHF_ALLOC, SHT_GNU_HASH, Config->Wordsize, ".gnu.hash") {
 }
 
 void GnuHashTableSection::finalizeContents() {
-  getParent()->Link = In.DynSymTab->getParent()->SectionIndex;
+  if (OutputSection *Sec = In.DynSymTab->getParent())
+    getParent()->Link = Sec->SectionIndex;
 
   // Computes bloom filter size in word size. We want to allocate 12
   // bits for each symbol. It must be a power of two.
   if (Symbols.empty()) {
     MaskWords = 1;
   } else {
     uint64_t NumBits = Symbols.size() * 12;
     MaskWords = NextPowerOf2(NumBits / (Config->Wordsize * 8));

 }
 
 HashTableSection::HashTableSection()
     : SyntheticSection(SHF_ALLOC, SHT_HASH, 4, ".hash") {
   this->Entsize = 4;
 }
 
 void HashTableSection::finalizeContents() {
-  getParent()->Link = In.DynSymTab->getParent()->SectionIndex;
+  if (OutputSection *Sec = In.DynSymTab->getParent())
+    getParent()->Link = Sec->SectionIndex;
 
   unsigned NumEntries = 2;                       // nbucket and nchain.
   NumEntries += In.DynSymTab->getNumSymbols();   // The chain entries.
 
   // Create as many buckets as there are symbols.
   NumEntries += In.DynSymTab->getNumSymbols();
   this->Size = NumEntries * 4;
 }

test/ELF/linkerscript/discard-section-err.s

 # REQUIRES: x86
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 
 # RUN: echo "SECTIONS { /DISCARD/ : { *(.shstrtab) } }" > %t.script
 # RUN: not ld.lld -o %t --script %t.script %t.o 2>&1 | \
 # RUN:   FileCheck -check-prefix=SHSTRTAB %s
 # SHSTRTAB: discarding .shstrtab section is not allowed
 
 # RUN: echo "SECTIONS { /DISCARD/ : { *(.dynamic) } }" > %t.script
 # RUN: not ld.lld -pie -o %t --script %t.script %t.o 2>&1 | \
 # RUN:   FileCheck -check-prefix=DYNAMIC %s
 # DYNAMIC: discarding .dynamic section is not allowed
 
+## We allow discarding .dynsym, check we don't crash.
 # RUN: echo "SECTIONS { /DISCARD/ : { *(.dynsym) } }" > %t.script
-# RUN: not ld.lld -pie -o %t --script %t.script %t.o 2>&1 | \
-# RUN:   FileCheck -check-prefix=DYNSYM %s
-# DYNSYM: discarding .dynsym section is not allowed
+# RUN: ld.lld -pie -o %t --script %t.script %t.o
 
 ## We allow discarding .dynstr, check we don't crash.
 # RUN: echo "SECTIONS { /DISCARD/ : { *(.dynstr) } }" > %t.script
 # RUN: ld.lld -pie -o %t --script %t.script %t.o
 
 # RUN: echo "SECTIONS { /DISCARD/ : { *(.rela.dyn) } }" > %t.script
 # RUN: not ld.lld -pie -o %t --script %t.script %t.o 2>&1 | \
 # RUN:   FileCheck -check-prefix=RELADYN %s
 # RELADYN: discarding .rela.dyn section is not allowed
 
 .comm foo,4,4