[ELF] Delete SectionBase::assigned

[MaskRay]

Summary

D67504 removed uses of assigned from OutputSection::addSection, which
makes assigned purely used in processSectionCommands() and its
callees. By replacing its references with parent, we can remove
assigned.

[grimar]

LGTM

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 three bit fields are only used by InputSectionBase, but we
+  // The next two bit fields are only used by InputSectionBase, but we
   // put them here so the struct packs better.
 
-  // True if this section has already been placed to a linker script
-  // output section. This is needed because, in a linker script, you
-  // can refer to the same section more than once. For example, in
-  // 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.
-  unsigned assigned : 1;
-
   unsigned bss : 1;
 
   // Set for sections that should not be folded by ICF.
   unsigned keepUnique : 1;
 
   // The 1-indexed partition that this section is assigned to by the garbage
   // collector, or 0 if this section is dead. Normally there is only one
   // partition, so this will either be 0 or 1.
public:
   bool isLive() const { return partition != 0; }
   void markLive() { partition = 1; }
   void markDead() { partition = 0; }
 
 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), assigned(false),
-        bss(false), keepUnique(false), partition(0), alignment(alignment),
-        flags(flags), entsize(entsize), type(type), link(link), info(info) {}
+      : name(name), repl(this), sectionKind(sectionKind), bss(false),
+        keepUnique(false), partition(0), 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,
                    StringRef name, Kind sectionKind);

ELF/LinkerScript.cpp

 LinkerScript::computeInputSections(const InputSectionDescription *cmd) {
   std::vector<InputSectionBase *> ret;
 
   // Collects all sections that satisfy constraints of Cmd.
   for (const SectionPattern &pat : cmd->sectionPatterns) {
     size_t sizeBefore = ret.size();
 
     for (InputSectionBase *sec : inputSections) {
-      if (!sec->isLive() || sec->assigned)
+      if (!sec->isLive() || sec->parent)
         continue;
 
       // For -emit-relocs we have to ignore entries like
       //   .rela.dyn : { *(.rela.data) }
       // which are common because they are in the default bfd script.
       // We do not ignore SHT_REL[A] linker-synthesized sections here because
       // want to support scripts that do custom layout for them.
       if (isa<InputSection>(sec) &&
           cast<InputSection>(sec)->getRelocatedSection())
         continue;
 
       std::string filename = getFilename(sec->file);
       if (!cmd->filePat.match(filename) ||
           pat.excludedFilePat.match(filename) ||
           !pat.sectionPat.match(sec->name))
         continue;
 
       ret.push_back(sec);
-      sec->assigned = true;
     }
 
     sortInputSections(
         MutableArrayRef<InputSectionBase *>(ret).slice(sizeBefore), pat);
   }
   return ret;
 }
 
 void LinkerScript::discard(InputSectionBase *s) {
   if (s == in.shStrTab || s == mainPart->relaDyn || s == mainPart->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 == mainPart->gnuHashTab)
     mainPart->gnuHashTab = nullptr;
   if (s == mainPart->hashTab)
     mainPart->hashTab = nullptr;
 
   s->markDead();
+  s->parent = nullptr;
   for (InputSection *ds : s->dependentSections)
     discard(ds);
 }
 
 std::vector<InputSectionBase *>
 LinkerScript::createInputSectionList(OutputSection &outCmd) {
   std::vector<InputSectionBase *> ret;
 
   for (BaseCommand *base : outCmd.sectionCommands) {
     if (auto *cmd = dyn_cast<InputSectionDescription>(base)) {
       cmd->sectionBases = computeInputSections(cmd);
+      for (InputSectionBase *s : cmd->sectionBases)
+        s->parent = &outCmd;
       ret.insert(ret.end(), cmd->sectionBases.begin(), cmd->sectionBases.end());
     }
   }
   return ret;
 }
 
 // Create output sections described by SECTIONS commands.
 void LinkerScript::processSectionCommands() {
if (auto *sec = dyn_cast<OutputSection>(base)) {
       // ".foo : ONLY_IF_R[OW] { ... }" is handled only if all member input
       // sections satisfy a given constraint. If not, a directive is handled
       // as if it wasn't present from the beginning.
       //
       // Because we'll iterate over SectionCommands many more times, the easy
       // way to "make it as if it wasn't present" is to make it empty.
       if (!matchConstraints(v, sec->constraint)) {
         for (InputSectionBase *s : v)
-          s->assigned = false;
+          s->parent = nullptr;
         sec->sectionCommands.clear();
         continue;
       }
 
       // Handle subalign (e.g. ".foo : SUBALIGN(32) { ... }"). If subalign
       // is given, input sections are aligned to that value, whether the
       // given value is larger or smaller than the original section alignment.
       if (sec->subalignExpr) {
         uint32_t subalign = sec->subalignExpr().getValue();
         for (InputSectionBase *s : v)
           s->alignment = subalign;
       }
 
       sec->sectionIndex = i++;
-      for (InputSectionBase *s : v)
-        s->parent = sec;
     }
   }
 }
 
 void LinkerScript::processSymbolAssignments() {
   // Dot outside an output section still represents a relative address, whose
   // sh_shndx should not be SHN_UNDEF or SHN_ABS. Create a dummy aether section
   // that fills the void outside a section. It has an index of one, which is