[LLD][ELF] Refactor to remove loop copying all Sections in OS->finalize() [NFC]

[peter.smith]

Summary

Moving the SHF_LINK_ORDER processing out of OutputSection::finalize() means that we no longer need to copy all InputSections as we now only need the first InputSection.

This is patch 2 of 3 in sequence:

• D40964 Move SHF_LINK_ORDER processing earlier in Writer.cpp [NFC]
• D40966 Refactor to remove loop copying all Sections in OS->finalize() [NFC]
• Remove Duplicate .ARM.exidx sections

ELF/OutputSections.cpp

template <class ELFT> void OutputSection::writeTo(uint8_t *Buf) {
   // can write arbitrary bytes to the output. Process them if any.
   for (BaseCommand *Base : SectionCommands)
     if (auto *Data = dyn_cast<ByteCommand>(Base))
       writeInt(Buf + Data->Offset, Data->Expression().getValue(), Data->Size);
 }
 
 template <class ELFT>
 static void finalizeShtGroup(OutputSection *OS,
-                             ArrayRef<InputSection *> Sections) {
-  assert(Config->Relocatable && Sections.size() == 1);
+                             InputSection *Section) {
+  assert(Config->Relocatable);
 
   // sh_link field for SHT_GROUP sections should contain the section index of
   // the symbol table.
   OS->Link = InX::SymTab->getParent()->SectionIndex;
 
   // sh_info then contain index of an entry in symbol table section which
   // provides signature of the section group.
-  ObjFile<ELFT> *Obj = Sections[0]->getFile<ELFT>();
+  ObjFile<ELFT> *Obj = Section->getFile<ELFT>();
   ArrayRef<Symbol *> Symbols = Obj->getSymbols();
-  OS->Info = InX::SymTab->getSymbolIndex(Symbols[Sections[0]->Info]);
+  OS->Info = InX::SymTab->getSymbolIndex(Symbols[Section->Info]);
 }
 
 template <class ELFT> void OutputSection::finalize() {
-  std::vector<InputSection *> Sections;
-  for (BaseCommand *Base : SectionCommands) {
+  InputSection *First = nullptr;
+  for (BaseCommand *Base : SectionCommands)
     if (auto *ISD = dyn_cast<InputSectionDescription>(Base)) {
-      for (InputSection *&IS : ISD->Sections)
-        Sections.push_back(IS);
-    }
+      if (ISD->Sections.empty())
+        continue;
+      First = ISD->Sections.front();
+      break;
     }
 
   if (Flags & SHF_LINK_ORDER) {
     // We must preserve the link order dependency of sections with the
     // SHF_LINK_ORDER flag. The dependency is indicated by the sh_link field. We
     // need to translate the InputSection sh_link to the OutputSection sh_link,
     // all InputSections in the OutputSection have the same dependency.
-    if (auto *D = Sections.front()->getLinkOrderDep())
+    if (auto *D = First->getLinkOrderDep())
       Link = D->getParent()->SectionIndex;
   }
 
   if (Type == SHT_GROUP) {
-    finalizeShtGroup<ELFT>(this, Sections);
+    finalizeShtGroup<ELFT>(this, First);
     return;
   }
 
   if (!Config->CopyRelocs || (Type != SHT_RELA && Type != SHT_REL))
     return;
 
-  InputSection *First = Sections[0];
   if (isa<SyntheticSection>(First))
     return;
 
   Link = InX::SymTab->getParent()->SectionIndex;
   // sh_info for SHT_REL[A] sections should contain the section header index of
   // the section to which the relocation applies.
   InputSectionBase *S = First->getRelocatedSection();
   Info = S->getOutputSection()->SectionIndex;