[ELF] - Linkerscript: do not use outputsections factory.

[grimar]

Summary

As was requested in comments for D23603,
this patch removes using of Factory from linkerscript,

Next step after this can be stop exporting the factory from
writer.cpp.

[grimar]

• Simplified.

[grimar]

• Simplified more.
• Removed unintended changes.

[grimar]

• Simplify even more (previous diff contained changes for easy integration of code to merge section attributes when combining them, but

since this patch just about removing the dependency on section factory, this changes are unnessecary for now, so I removed them what allowed to simplify a bit more).

[ruiu]

ELF/LinkerScript.cpp

263

This can be a non-member function now, I guess?

267

Move the variable definition closer to the first use of the variable.

268

Remove {}

ELF/LinkerScript.h

180

Use Out<ELFT>::Pool instead.

ELF/OutputSections.cpp

1789

Remove this variable and use early returns.

[grimar]

• Addressed review comments.

ELF/LinkerScript.cpp

263

Yep, done.

267

Done.

268

I can't :( This is neccesary for VS2015, otherwise it shows:

error C2143: syntax error: missing ';' before '}'

ELF/LinkerScript.h

180

Done.

ELF/OutputSections.cpp

1789

Done.

[grimar]

If we are going with multiple output sections for single declaration, this one is no more actual.

ELF/LinkerScript.h

 
 // This is a runner of the linker script.
 template <class ELFT> class LinkerScript {
   typedef typename ELFT::uint uintX_t;
 
 public:
   LinkerScript();
   ~LinkerScript();
-  void createSections(OutputSectionFactory<ELFT> &Factory);
+  void createSections();
 
   std::vector<PhdrEntry<ELFT>> createPhdrs();
   bool ignoreInterpSection();
 
   ArrayRef<uint8_t> getFiller(StringRef Name);
   Expr getLma(StringRef Name);
   bool shouldKeep(InputSectionBase<ELFT> *S);
   void assignAddresses();
   int compareSections(StringRef A, StringRef B);
   bool hasPhdrsCommands();
   uintX_t getOutputSectionSize(StringRef Name);
   uintX_t getHeaderSize();
 
   std::vector<OutputSectionBase<ELFT> *> *OutputSections;
 
 private:
   std::vector<InputSectionBase<ELFT> *>
   getInputSections(const InputSectionDescription *);
 
   void discard(OutputSectionCommand &Cmd);
 
   std::vector<InputSectionBase<ELFT> *>
   createInputSectionList(OutputSectionCommand &Cmd);
 
+  std::pair<OutputSectionBase<ELFT> *, bool>
+  createOutputSection(InputSectionBase<ELFT> *C, StringRef Name);
+
   // "ScriptConfig" is a bit too long, so define a short name for it.
   ScriptConfiguration &Opt = *ScriptConfig;
 
   int getSectionIndex(StringRef Name);
   std::vector<size_t> getPhdrIndices(StringRef SectionName);
   size_t getPhdrIndex(StringRef PhdrName);
 
   llvm::SpecificBumpPtrAllocator<LayoutInputSection<ELFT>> LAlloc;
 
+  std::vector<std::unique_ptr<OutputSectionBase<ELFT>>> OwningSections;
+
   uintX_t Dot;
 };
 
 // Variable template is a C++14 feature, so we can't template
 // a global variable. Use a struct to workaround.
 template <class ELFT> struct Script { static LinkerScript<ELFT> *X; };
 template <class ELFT> LinkerScript<ELFT> *Script<ELFT>::X;
 
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/LinkerScript.cpp

for (const std::unique_ptr<BaseCommand> &Base : OutCmd.Commands) {
     if (Cmd->SortOuter)
       std::stable_sort(V.begin(), V.end(), getComparator<ELFT>(Cmd->SortOuter));
     Ret.insert(Ret.end(), V.begin(), V.end());
   }
   return Ret;
 }
 
 template <class ELFT>
-void LinkerScript<ELFT>::createSections(OutputSectionFactory<ELFT> &Factory) {
+std::pair<OutputSectionBase<ELFT> *, bool>
+LinkerScript<ELFT>::createOutputSection(InputSectionBase<ELFT> *C,
+                                        StringRef Name) {
+  typedef typename ELFT::Shdr Elf_Shdr;
+
+  bool IsNew = true;
+  OutputSectionBase<ELFT> *Sec = nullptr;
+  for (std::unique_ptr<OutputSectionBase<ELFT>> &S : OwningSections)
+    if (S->getName() == Name) {
+      Sec = S.get();
+      IsNew = false;
+      break;
+    }
+
+  const Elf_Shdr *H = C->getSectionHdr();
+  uintX_t Flags = H->sh_flags & ~SHF_GROUP & ~SHF_COMPRESSED;
+  uintX_t Alignment = 0;
+  if (isa<MergeInputSection<ELFT>>(C))
+    Alignment = std::max(H->sh_addralign, H->sh_entsize);
+  uint32_t Type = H->sh_type;
+
+  if (!Sec) {
+    std::tie(Sec, IsNew) =
+        allocSection<ELFT>(C->SectionKind, Name, Flags, Alignment, Type);
+    if (IsNew)
+      OwningSections.emplace_back(Sec);
+    return {Sec, IsNew};
+  }
+
+  return{ Sec, IsNew };
+}
+
+template <class ELFT>
+void LinkerScript<ELFT>::createSections() {
   for (const std::unique_ptr<BaseCommand> &Base1 : Opt.Commands) {
     if (auto *Cmd = dyn_cast<SymbolAssignment>(Base1.get())) {
       if (shouldDefine<ELFT>(Cmd))
         addRegular<ELFT>(Cmd);
       continue;
     }
 
     if (auto *Cmd = dyn_cast<OutputSectionCommand>(Base1.get())) {
       if (Cmd->Name == "/DISCARD/") {
         discard(*Cmd);
         continue;
       }
 
       std::vector<InputSectionBase<ELFT> *> V = createInputSectionList(*Cmd);
       InputSectionBase<ELFT> *Head = getNonLayoutSection<ELFT>(V);
       if (!Head)
         continue;
 
       OutputSectionBase<ELFT> *OutSec;
       bool IsNew;
-      std::tie(OutSec, IsNew) = Factory.create(Head, Cmd->Name);
+      std::tie(OutSec, IsNew) = createOutputSection(Head, Cmd->Name);
       if (IsNew)
         OutputSections->push_back(OutSec);
 
       uint32_t Subalign = Cmd->SubalignExpr ? Cmd->SubalignExpr(0) : 0;
       for (InputSectionBase<ELFT> *Sec : V) {
         if (Subalign)
           Sec->Alignment = Subalign;
         if (!Sec->OutSec)
           OutSec->addSection(Sec);
       }
     }
   }
 
   // Add orphan sections.
   for (const std::unique_ptr<ObjectFile<ELFT>> &F :
        Symtab<ELFT>::X->getObjectFiles()) {
     for (InputSectionBase<ELFT> *S : F->getSections()) {
       if (isDiscarded(S) || S->OutSec)
         continue;
       OutputSectionBase<ELFT> *OutSec;
       bool IsNew;
-      std::tie(OutSec, IsNew) = Factory.create(S, getOutputSectionName(S));
+      std::tie(OutSec, IsNew) = createOutputSection(S, getOutputSectionName(S));
       if (IsNew)
         OutputSections->push_back(OutSec);
       OutSec->addSection(S);
     }
   }
 }
 
 template <class ELFT> void assignOffsets(OutputSectionBase<ELFT> *Sec) {

ELF/OutputSections.h

 template <class ELFT> class SymbolTableSection;
 template <class ELFT> class StringTableSection;
 template <class ELFT> class EhInputSection;
 template <class ELFT> class InputSection;
 template <class ELFT> class InputSectionBase;
 template <class ELFT> class MergeInputSection;
 template <class ELFT> class MipsReginfoInputSection;
 template <class ELFT> class OutputSection;
+template <class ELFT> class OutputSectionBase;
 template <class ELFT> class ObjectFile;
 template <class ELFT> class SharedFile;
 template <class ELFT> class SharedSymbol;
 template <class ELFT> class DefinedRegular;
 
+template <class ELFT>
+std::pair<OutputSectionBase<ELFT> *, bool>
+allocSection(unsigned Kind, StringRef Name, typename ELFT::uint Flags,
+             typename ELFT::uint Alignment, uint32_t Type);
+
 // This represents a section in an output file.
 // Different sub classes represent different types of sections. Some contain
 // input sections, others are created by the linker.
 // The writer creates multiple OutputSections and assign them unique,
 // non-overlapping file offsets and VAs.
 template <class ELFT> class OutputSectionBase {
 public:
   typedef typename ELFT::uint uintX_t;

ELF/OutputSections.cpp

void MipsAbiFlagsOutputSection<ELFT>::addSection(InputSectionBase<ELFT> *C) {
   Flags.flags1 |= S->Flags->flags1;
   Flags.flags2 |= S->Flags->flags2;
   Flags.fp_abi = elf::getMipsFpAbiFlag(Flags.fp_abi, S->Flags->fp_abi,
                                        getFilename(S->getFile()));
 }
 
 template <class ELFT>
 std::pair<OutputSectionBase<ELFT> *, bool>
-OutputSectionFactory<ELFT>::create(InputSectionBase<ELFT> *C,
-                                   StringRef OutsecName) {
-  SectionKey<ELFT::Is64Bits> Key = createKey(C, OutsecName);
-  OutputSectionBase<ELFT> *&Sec = Map[Key];
-  if (Sec)
-    return {Sec, false};
-
-  switch (C->SectionKind) {
+elf::allocSection(unsigned Kind, StringRef Name, typename ELFT::uint Flags,
+                  typename ELFT::uint Alignment, uint32_t Type) {
+  OutputSectionBase<ELFT> *Sec;
+  switch (Kind) {
   case InputSectionBase<ELFT>::Regular:
-    Sec = new OutputSection<ELFT>(Key.Name, Key.Type, Key.Flags);
+    Sec = new OutputSection<ELFT>(Name, Type, Flags);
     break;
   case InputSectionBase<ELFT>::EHFrame:
     return {Out<ELFT>::EhFrame, false};
   case InputSectionBase<ELFT>::Merge:
-    Sec = new MergeOutputSection<ELFT>(Key.Name, Key.Type, Key.Flags,
-                                       Key.Alignment);
+    Sec = new MergeOutputSection<ELFT>(Name, Type, Flags, Alignment);
     break;
   case InputSectionBase<ELFT>::MipsReginfo:
     Sec = new MipsReginfoOutputSection<ELFT>();
     break;
   case InputSectionBase<ELFT>::MipsOptions:
     Sec = new MipsOptionsOutputSection<ELFT>();
     break;
   case InputSectionBase<ELFT>::MipsAbiFlags:
     Sec = new MipsAbiFlagsOutputSection<ELFT>();
     break;
   case InputSectionBase<ELFT>::Layout:
     llvm_unreachable("Invalid section type");
   }
-  Out<ELFT>::Pool.emplace_back(Sec);
   return {Sec, true};
 }
 
 template <class ELFT>
+std::pair<OutputSectionBase<ELFT> *, bool>
+OutputSectionFactory<ELFT>::create(InputSectionBase<ELFT> *C,
+                                   StringRef OutsecName) {
+  SectionKey<ELFT::Is64Bits> Key = createKey(C, OutsecName);
+  OutputSectionBase<ELFT> *&Sec = Map[Key];
+  if (Sec)
+    return {Sec, false};
+
+  bool Allocated;
+  std::tie(Sec, Allocated) = allocSection<ELFT>(
+      C->SectionKind, Key.Name, Key.Flags, Key.Alignment, Key.Type);
+  if (Allocated)
+    Out<ELFT>::Pool.emplace_back(Sec);
+  return {Sec, Allocated};
+}
+
+template <class ELFT>
 SectionKey<ELFT::Is64Bits>
 OutputSectionFactory<ELFT>::createKey(InputSectionBase<ELFT> *C,
                                       StringRef OutsecName) {
   const Elf_Shdr *H = C->getSectionHdr();
   uintX_t Flags = H->sh_flags & ~SHF_GROUP & ~SHF_COMPRESSED;
 
   // For SHF_MERGE we create different output sections for each alignment.
   // This makes each output section simple and keeps a single level mapping from

 template class BuildIdHexstring<ELF64BE>;
 
 template class OutputSectionFactory<ELF32LE>;
 template class OutputSectionFactory<ELF32BE>;
 template class OutputSectionFactory<ELF64LE>;
 template class OutputSectionFactory<ELF64BE>;
 }
 }
+
+template std::pair<OutputSectionBase<ELF32LE> *, bool>
+elf::allocSection(unsigned Kind, StringRef Name, ELF32LE::uint Flags,
+                  ELF32LE::uint Alignment, uint32_t Type);
+template std::pair<OutputSectionBase<ELF32BE> *, bool>
+elf::allocSection(unsigned Kind, StringRef Name, ELF32BE::uint Flags,
+                  ELF32BE::uint Alignment, uint32_t Type);
+template std::pair<OutputSectionBase<ELF64LE> *, bool>
+elf::allocSection(unsigned Kind, StringRef Name, ELF64LE::uint Flags,
+                  ELF64LE::uint Alignment, uint32_t Type);
+template std::pair<OutputSectionBase<ELF64BE> *, bool>
+elf::allocSection(unsigned Kind, StringRef Name, ELF64BE::uint Flags,
+                  ELF64BE::uint Alignment, uint32_t Type);

ELF/Writer.cpp

template <class ELFT> void Writer<ELFT>::run() {
   if (Target->NeedsThunks)
     forEachRelSec(createThunks<ELFT>);
 
   CommonInputSection<ELFT> Common(getCommonSymbols<ELFT>());
   CommonInputSection<ELFT>::X = &Common;
 
   Script<ELFT>::X->OutputSections = &OutputSections;
   if (ScriptConfig->HasContents)
-    Script<ELFT>::X->createSections(Factory);
+    Script<ELFT>::X->createSections();
   else
     createSections();
 
   finalizeSections();
   if (HasError)
     return;
 
   if (Config->Relocatable) {