[ELF] - Linkerscript: add LinkerScript::addInputSection() method.

[grimar]

Summary

It was suggested during review of D37561 that "All sections passed to addInputSec should be live.".
Patch do this change.

[grimar]

In favor of D37735.

ELF/LinkerScript.h

public:
 
   bool shouldKeep(InputSectionBase *S);
   void assignOffsets(OutputSection *Sec);
   void assignAddresses();
   void allocateHeaders(std::vector<PhdrEntry *> &Phdrs);
   void addSymbol(SymbolAssignment *Cmd);
   void processCommands(OutputSectionFactory &Factory);
 
+  void addInputSection(OutputSectionFactory &Factory, InputSectionBase *IS,
+                       StringRef OutsecName, OutputSection *Sec);
+
   // Parsed linker script configurations are set to this struct.
   ScriptConfiguration Opt;
 };
 
 extern LinkerScript *Script;
 
 } // end namespace elf
 } // end namespace lld
 
 #endif // LLD_ELF_LINKER_SCRIPT_H

ELF/LinkerScript.cpp

for (BaseCommand *Base : OutCmd.Commands) {
 
     Cmd->Sections = computeInputSections(Cmd);
     Ret.insert(Ret.end(), Cmd->Sections.begin(), Cmd->Sections.end());
   }
 
   return Ret;
 }
 
+void LinkerScript::addInputSection(OutputSectionFactory &F,
+                                   InputSectionBase *IS, StringRef OutsecName,
+                                   OutputSection *Sec) {
+  if (!IS->Live) {
+    reportDiscarded(IS);
+    return;
+  }
+  if (!Sec)
+    F.addInputSec(IS, OutsecName);
+  else
+    F.addInputSecToOutput(IS, OutsecName, Sec);
+}
+
 void LinkerScript::processCommands(OutputSectionFactory &Factory) {
   // A symbol can be assigned before any section is mentioned in the linker
   // script. In an DSO, the symbol values are addresses, so the only important
   // section values are:
   // * SHN_UNDEF
   // * SHN_ABS
   // * Any value meaning a regular section.
   // To handle that, create a dummy aether section that fills the void before
if (auto *Sec = dyn_cast<OutputSection>(Opt.Commands[I])) {
       if (Sec->SubalignExpr) {
         uint32_t Subalign = Sec->SubalignExpr().getValue();
         for (InputSectionBase *S : V)
           S->Alignment = Subalign;
       }
 
       // Add input sections to an output section.
       for (InputSectionBase *S : V)
-        Factory.addInputSec(S, Sec->Name, Sec);
+        addInputSection(Factory, S, Sec->Name, Sec);
       assert(Sec->SectionIndex == INT_MAX);
       Sec->SectionIndex = I;
       if (Sec->Noload)
         Sec->Type = SHT_NOBITS;
     }
   }
   CurAddressState = nullptr;
 }
for (InputSectionBase *S : InputSections) {
     StringRef Name = getOutputSectionName(S->Name);
     auto End = Opt.Commands.begin() + NumCommands;
     auto I = std::find_if(Opt.Commands.begin(), End, [&](BaseCommand *Base) {
       if (auto *Sec = dyn_cast<OutputSection>(Base))
         return Sec->Name == Name;
       return false;
     });
     if (I == End) {
-      Factory.addInputSec(S, Name);
+      addInputSection(Factory, S, Name, nullptr);
       assert(S->getOutputSection()->SectionIndex == INT_MAX);
     } else {
       OutputSection *Sec = cast<OutputSection>(*I);
-      Factory.addInputSec(S, Name, Sec);
+      addInputSection(Factory, S, Name, Sec);
       unsigned Index = std::distance(Opt.Commands.begin(), I);
       assert(Sec->SectionIndex == INT_MAX || Sec->SectionIndex == Index);
       Sec->SectionIndex = Index;
     }
   }
 }
 
 uint64_t LinkerScript::advance(uint64_t Size, unsigned Align) {

ELF/OutputSections.h

 // factors, including input section's sh_flags, sh_type and
 // linker scripts.
 class OutputSectionFactory {
 public:
   OutputSectionFactory();
   ~OutputSectionFactory();
 
   void addInputSec(InputSectionBase *IS, StringRef OutsecName);
-  void addInputSec(InputSectionBase *IS, StringRef OutsecName,
+  void addInputSecToOutput(InputSectionBase *IS, StringRef OutsecName,
                            OutputSection *&Sec);
 
 private:
   llvm::SmallDenseMap<SectionKey, OutputSection *> Map;
 };
 
 uint64_t getHeaderSize();
 void reportDiscarded(InputSectionBase *IS);
 void sortByOrder(llvm::MutableArrayRef<InputSection *> In,
                  std::function<int(InputSectionBase *S)> Order);
 
 extern std::vector<OutputSection *> OutputSections;
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/OutputSections.cpp

void OutputSectionFactory::addInputSec(InputSectionBase *IS,
                                        StringRef OutsecName) {
   // Sections with the SHT_GROUP attribute reach here only when the - r option
   // is given. Such sections define "section groups", and InputFiles.cpp has
   // dedup'ed section groups by their signatures. For the -r, we want to pass
   // through all SHT_GROUP sections without merging them because merging them
   // creates broken section contents.
   if (IS->Type == SHT_GROUP) {
     OutputSection *Out = nullptr;
-    addInputSec(IS, OutsecName, Out);
+    addInputSecToOutput(IS, OutsecName, Out);
     return;
   }
 
   // Imagine .zed : { *(.foo) *(.bar) } script. Both foo and bar may have
   // relocation sections .rela.foo and .rela.bar for example. Most tools do
   // not allow multiple REL[A] sections for output section. Hence we
   // should combine these relocation sections into single output.
   // We skip synthetic sections because it can be .rela.dyn/.rela.plt or any
   // other REL[A] sections created by linker itself.
   if (!isa<SyntheticSection>(IS) &&
       (IS->Type == SHT_REL || IS->Type == SHT_RELA)) {
     auto *Sec = cast<InputSection>(IS);
     OutputSection *Out = Sec->getRelocatedSection()->getOutputSection();
-    addInputSec(IS, OutsecName, Out->RelocationSection);
+    addInputSecToOutput(IS, OutsecName, Out->RelocationSection);
     return;
   }
 
   SectionKey Key = createKey(IS, OutsecName);
   OutputSection *&Sec = Map[Key];
-  addInputSec(IS, OutsecName, Sec);
+  addInputSecToOutput(IS, OutsecName, Sec);
 }
 
-void OutputSectionFactory::addInputSec(InputSectionBase *IS,
+void OutputSectionFactory::addInputSecToOutput(InputSectionBase *IS,
                                                StringRef OutsecName,
                                                OutputSection *&Sec) {
-  if (!IS->Live) {
-    reportDiscarded(IS);
-    return;
-  }
-
   if (Sec && Sec->Live) {
     if (getIncompatibleFlags(Sec->Flags) != getIncompatibleFlags(IS->Flags))
       error("incompatible section flags for " + Sec->Name + "\n>>> " +
             toString(IS) + ": 0x" + utohexstr(IS->Flags) +
             "\n>>> output section " + Sec->Name + ": 0x" +
             utohexstr(Sec->Flags));
     if (Sec->Type != IS->Type) {
       if (canMergeToProgbits(Sec->Type) && canMergeToProgbits(IS->Type))

ELF/Writer.cpp

for (EhInputSection *ES : In<ELFT>::EhFrame->Sections)
       Fn(*ES);
   }
 }
 
 template <class ELFT> void Writer<ELFT>::createSections() {
   std::vector<BaseCommand *> Old = Script->Opt.Commands;
   Script->Opt.Commands.clear();
   for (InputSectionBase *IS : InputSections)
-    if (IS)
-      Factory.addInputSec(IS, getOutputSectionName(IS->Name));
+    Script->addInputSection(Factory, IS, getOutputSectionName(IS->Name),
+                            nullptr);
   Script->Opt.Commands.insert(Script->Opt.Commands.end(), Old.begin(),
                               Old.end());
 
   Script->fabricateDefaultCommands();
   sortBySymbolsOrder<ELFT>();
   sortInitFini(findSection(".init_array"));
   sortInitFini(findSection(".fini_array"));
   sortCtorsDtors(findSection(".ctors"));