[ELF] Move KeepUnique to InputSectionBase and update comments

[sbc100]

Summary

KeepUnique is only ever used by InputSection.

Also, its seems that the Live bit is indeed used by output sections
as well as input ones.

ELF/Driver.cpp

template <class ELFT> static void demoteSymbols() {
   }
 }
 
 // Record sections that define symbols mentioned in --keep-unique <symbol>
 // these sections are inelligible for ICF.
 static void findKeepUniqueSections(opt::InputArgList &Args) {
   for (auto *Arg : Args.filtered(OPT_keep_unique)) {
     StringRef Name = Arg->getValue();
-    if (auto *Sym = dyn_cast_or_null<Defined>(Symtab->find(Name)))
-      Sym->Section->KeepUnique = true;
-    else
-      warn("could not find symbol " + Name + " to keep unique");
+    if (auto *Sym = dyn_cast_or_null<Defined>(Symtab->find(Name))) {
+      if (auto *Sec = dyn_cast<InputSectionBase>(Sym->Section)) {
+        Sec->KeepUnique = true;
+        continue;
+      }
+    }
   }
 }
 
 // Do actual linking. Note that when this function is called,
 // all linker scripts have already been parsed.
 template <class ELFT> void LinkerDriver::link(opt::InputArgList &Args) {
   Target = getTarget();
 

ELF/InputSection.h

public:
   // Usually Repl == this. However, if ICF merges two sections,
   // Repl pointer of one section points to another section. So,
   // if you need to get a pointer to this instance, do not use
   // this but instead this->Repl.
   SectionBase *Repl;
 
   unsigned SectionKind : 3;
 
-  // The next two bit fields are only used by InputSectionBase, but we
-  // put them here so the struct packs better.
-
-  // The garbage collector sets sections' Live bits.
+  // The garbage collector sets the input sections' Live bits.
   // If GC is disabled, all sections are considered live by default.
+  // Output sections are live if they they have any input sections added to
+  // them.
   unsigned Live : 1;
 
   unsigned Bss : 1;
 
-  // Set for sections that should not be folded by ICF.
-  unsigned KeepUnique : 1;
-
   // These corresponds to the fields in Elf_Shdr.
   uint32_t Alignment;
   uint64_t Flags;
   uint64_t Entsize;
   uint32_t Type;
   uint32_t Link;
   uint32_t Info;
 
   OutputSection *getOutputSection();
   const OutputSection *getOutputSection() const {
     return const_cast<SectionBase *>(this)->getOutputSection();
   }
 
   // Translate an offset in the input section to an offset in the output
   // section.
   uint64_t getOffset(uint64_t Offset) const;
 
   uint64_t getVA(uint64_t Offset = 0) const;
 
 protected:
   SectionBase(Kind SectionKind, StringRef Name, uint64_t Flags,
               uint64_t Entsize, uint64_t Alignment, uint32_t Type,
               uint32_t Info, uint32_t Link)
       : Name(Name), Repl(this), SectionKind(SectionKind), Live(false),
-        Bss(false), KeepUnique(false), Alignment(Alignment), Flags(Flags),
+        Bss(false), Alignment(Alignment), Flags(Flags),
         Entsize(Entsize), Type(Type), Link(Link), Info(Info) {}
 };
 
 // This corresponds to a section of an input file.
 class InputSectionBase : public SectionBase {
 public:
   template <class ELFT>
   InputSectionBase(ObjFile<ELFT> &File, const typename ELFT::Shdr &Header,
public:
   // the following linker script,
   //
   //   .foo : { *(.text) }
   //   .bar : { *(.text) }
   //
   // .foo takes all .text sections, and .bar becomes empty. To achieve
   // this, we need to memorize whether a section has been placed or
   // not for each input section.
-  bool Assigned = false;
+  unsigned Assigned : 1;
+
+  // Set for sections that should not be folded by ICF.
+  unsigned KeepUnique : 1;
 
   // Input sections are part of an output section. Special sections
   // like .eh_frame and merge sections are first combined into a
   // synthetic section that is then added to an output section. In all
   // cases this points one level up.
   SectionBase *Parent = nullptr;
 
   // Relocations that refer to this section.

ELF/InputSection.cpp

 
 InputSectionBase::InputSectionBase(InputFile *File, uint64_t Flags,
                                    uint32_t Type, uint64_t Entsize,
                                    uint32_t Link, uint32_t Info,
                                    uint32_t Alignment, ArrayRef<uint8_t> Data,
                                    StringRef Name, Kind SectionKind)
     : SectionBase(SectionKind, Name, Flags, Entsize, Alignment, Type, Info,
                   Link),
-      File(File), Data(Data) {
+      File(File), Data(Data), Assigned(false), KeepUnique(false) {
   // In order to reduce memory allocation, we assume that mergeable
   // sections are smaller than 4 GiB, which is not an unreasonable
   // assumption as of 2017.
   if (SectionKind == SectionBase::Merge && Data.size() > UINT32_MAX)
     error(toString(this) + ": section too large");
 
   NumRelocations = 0;
   AreRelocsRela = false;