Split LinkerScript::createSections into small functions.

[ruiu]

Summary

createSections function is getting longer, so it is time to split it
into small functions. The reason why the function is long is because
it has deeply nested for-loops. This patch constructs temporary data
to reduce nesting level.

[davide]

lg. I have a patch that depends on this one. I'll submit the review after you commit.

lld/trunk/ELF/LinkerScript.h

public:
   ArrayRef<uint8_t> getFiller(StringRef Name);
   bool shouldKeep(InputSectionBase<ELFT> *S);
   void assignAddresses(ArrayRef<OutputSectionBase<ELFT> *> S);
   int compareSections(StringRef A, StringRef B);
   void addScriptedSymbols();
   bool hasPhdrsCommands();
 
 private:
+  std::vector<std::pair<StringRef, ArrayRef<StringRef>>> getSectionMap();
+
+  std::vector<InputSectionBase<ELFT> *>
+  getInputSections(ArrayRef<StringRef> Patterns);
+
   // "ScriptConfig" is a bit too long, so define a short name for it.
   ScriptConfiguration &Opt = *ScriptConfig;
 
   std::vector<OutputSectionBase<ELFT> *>
   filter(std::vector<OutputSectionBase<ELFT> *> &Sections);
 
   int getSectionIndex(StringRef Name);
   std::vector<size_t> getPhdrIndices(StringRef SectionName);

lld/trunk/ELF/LinkerScript.cpp

 
 static bool match(ArrayRef<StringRef> Patterns, StringRef S) {
   for (StringRef Pat : Patterns)
     if (globMatch(Pat, S))
       return true;
   return false;
 }
 
+// Create a vector of (<output section name>, <input section name patterns>).
+// For example, if a returned vector contains (".text" (".foo.*" ".bar.*")),
+// input sections start with ".foo." or ".bar." should be added to
+// ".text" section.
+template <class ELFT>
+std::vector<std::pair<StringRef, ArrayRef<StringRef>>>
+LinkerScript<ELFT>::getSectionMap() {
+  std::vector<std::pair<StringRef, ArrayRef<StringRef>>> Ret;
+
+  for (const std::unique_ptr<BaseCommand> &Base1 : Opt.Commands)
+    if (auto *Cmd1 = dyn_cast<OutputSectionCommand>(Base1.get()))
+      for (const std::unique_ptr<BaseCommand> &Base2 : Cmd1->Commands)
+        if (auto *Cmd2 = dyn_cast<InputSectionDescription>(Base2.get()))
+          Ret.emplace_back(Cmd1->Name, Cmd2->Patterns);
+
+  return Ret;
+}
+
+// Returns input sections filtered by given glob patterns.
+template <class ELFT>
+std::vector<InputSectionBase<ELFT> *>
+LinkerScript<ELFT>::getInputSections(ArrayRef<StringRef> Patterns) {
+  std::vector<InputSectionBase<ELFT> *> Ret;
+  for (const std::unique_ptr<ObjectFile<ELFT>> &F :
+       Symtab<ELFT>::X->getObjectFiles())
+    for (InputSectionBase<ELFT> *S : F->getSections())
+      if (!isDiscarded(S) && !S->OutSec && match(Patterns, S->getSectionName()))
+        Ret.push_back(S);
+  return Ret;
+}
+
 template <class ELFT>
 std::vector<OutputSectionBase<ELFT> *>
 LinkerScript<ELFT>::createSections(OutputSectionFactory<ELFT> &Factory) {
-  typedef const std::unique_ptr<ObjectFile<ELFT>> ObjectFile;
-  std::vector<OutputSectionBase<ELFT> *> Result;
+  std::vector<OutputSectionBase<ELFT> *> Ret;
 
   // Add input section to output section. If there is no output section yet,
   // then create it and add to output section list.
-  auto AddInputSec = [&](InputSectionBase<ELFT> *C, StringRef Name) {
+  auto Add = [&](InputSectionBase<ELFT> *C, StringRef Name) {
     OutputSectionBase<ELFT> *Sec;
     bool IsNew;
     std::tie(Sec, IsNew) = Factory.create(C, Name);
     if (IsNew)
-      Result.push_back(Sec);
+      Ret.push_back(Sec);
     Sec->addSection(C);
   };
 
-  // Select input sections matching rule and add them to corresponding
-  // output section. Section rules are processed in order they're listed
-  // in script, so correct input section order is maintained by design.
-  for (const std::unique_ptr<BaseCommand> &Base : Opt.Commands) {
-    auto *OutCmd = dyn_cast<OutputSectionCommand>(Base.get());
-    if (!OutCmd)
-      continue;
-
-    for (const std::unique_ptr<BaseCommand> &Cmd : OutCmd->Commands) {
-      auto *InCmd = dyn_cast<InputSectionDescription>(Cmd.get());
-      if (!InCmd)
-        continue;
-
-      for (ObjectFile &F : Symtab<ELFT>::X->getObjectFiles()) {
-        for (InputSectionBase<ELFT> *S : F->getSections()) {
-          if (isDiscarded(S) || S->OutSec)
-            continue;
-
-          if (match(InCmd->Patterns, S->getSectionName())) {
-            if (OutCmd->Name == "/DISCARD/")
-              S->Live = false;
-            else
-              AddInputSec(S, OutCmd->Name);
-          }
-        }
+  for (auto &P : getSectionMap()) {
+    StringRef OutputName = P.first;
+    ArrayRef<StringRef> InputPatterns = P.second;
+    for (InputSectionBase<ELFT> *S : getInputSections(InputPatterns)) {
+      if (OutputName == "/DISCARD/") {
+        reportDiscarded(S);
+        continue;
       }
+      Add(S, OutputName);
     }
   }
 
   // Add all other input sections, which are not listed in script.
-  for (ObjectFile &F : Symtab<ELFT>::X->getObjectFiles())
-    for (InputSectionBase<ELFT> *S : F->getSections()) {
-      if (!isDiscarded(S)) {
-        if (!S->OutSec)
-          AddInputSec(S, getOutputSectionName(S));
-      } else
-        reportDiscarded(S);
-    }
+  for (const std::unique_ptr<ObjectFile<ELFT>> &F :
+       Symtab<ELFT>::X->getObjectFiles())
+    for (InputSectionBase<ELFT> *S : F->getSections())
+      if (!isDiscarded(S) && !S->OutSec)
+        Add(S, getOutputSectionName(S));
 
   // Remove from the output all the sections which did not meet
   // the optional constraints.
-  return filter(Result);
+  return filter(Ret);
 }
 
 // Process ONLY_IF_RO and ONLY_IF_RW.
 template <class ELFT>
 std::vector<OutputSectionBase<ELFT> *>
 LinkerScript<ELFT>::filter(std::vector<OutputSectionBase<ELFT> *> &Sections) {
   // Sections and OutputSectionCommands are parallel arrays.
   // In this loop, we remove output sections if they don't satisfy