[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

28

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

32

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

33

Remove {}

ELF/LinkerScript.h

1

Use Out<ELFT>::Pool instead.

ELF/OutputSections.cpp

19

Remove this variable and use early returns.

[grimar]

• Addressed review comments.

ELF/LinkerScript.cpp

28

Yep, done.

32

Done.

33

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

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

ELF/LinkerScript.h

1

Done.

ELF/OutputSections.cpp

19

Done.

[grimar]

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

ELF/LinkerScript.h

 //===- LinkerScript.h -------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 

 
 // 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();

ELF/LinkerScript.cpp

 #include "LinkerScript.h"
 #include "Config.h"
 #include "Driver.h"
 #include "InputSection.h"
 #include "OutputSections.h"
 #include "ScriptParser.h"
 #include "Strings.h"
 #include "Symbols.h"
 #include "SymbolTable.h"
 #include "Target.h"
 #include "Writer.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/ELF.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/StringSaver.h"
 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 using namespace lld;
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) {
+static std::pair<OutputSectionBase<ELFT> *, bool>
+createOutputSection(InputSectionBase<ELFT> *C, StringRef Name) {
+  typedef typename ELFT::Shdr Elf_Shdr;
+  typedef typename ELFT::uint uintX_t;
+
+  for (std::unique_ptr<OutputSectionBase<ELFT>> &S : Out<ELFT>::Pool) {
+    if (S->getName() == Name)
+      return {S.get(), false};
+  }
+
+  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;
+
+  bool IsNew;
+  OutputSectionBase<ELFT> *Sec = nullptr;
+  std::tie(Sec, IsNew) =
+      allocSection<ELFT>(C->SectionKind, Name, Flags, Alignment, Type);
+  if (IsNew)
+    Out<ELFT>::Pool.emplace_back(Sec);
+  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

 #include "Config.h"
 #include "EhFrame.h"
 #include "LinkerScript.h"
 #include "Strings.h"
 #include "SymbolTable.h"
 #include "Target.h"
 #include "lld/Core/Parallel.h"
 #include "llvm/Support/Dwarf.h"
 #include "llvm/Support/MD5.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/SHA1.h"
 #include "llvm/Support/RandomNumberGenerator.h"
 
 using namespace llvm;
 using namespace llvm::dwarf;
 using namespace llvm::object;
 using namespace llvm::support::endian;
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) {
+  switch (Kind) {
   case InputSectionBase<ELFT>::Regular:
-    Sec = new OutputSection<ELFT>(Key.Name, Key.Type, Key.Flags);
-    break;
+    return {new OutputSection<ELFT>(Name, Type, Flags), true};
   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);
-    break;
+    return {new MergeOutputSection<ELFT>(Name, Type, Flags, Alignment), true};
   case InputSectionBase<ELFT>::MipsReginfo:
-    Sec = new MipsReginfoOutputSection<ELFT>();
-    break;
+    return {new MipsReginfoOutputSection<ELFT>(), true};
   case InputSectionBase<ELFT>::MipsOptions:
-    Sec = new MipsOptionsOutputSection<ELFT>();
-    break;
+    return {new MipsOptionsOutputSection<ELFT>(), true};
   case InputSectionBase<ELFT>::MipsAbiFlags:
-    Sec = new MipsAbiFlagsOutputSection<ELFT>();
-    break;
-  case InputSectionBase<ELFT>::Layout:
+    return {new MipsAbiFlagsOutputSection<ELFT>(), true};
+  default:
     llvm_unreachable("Invalid section type");
   }
+}
+
+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, true};
+  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;

 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) {