Split LinkerScript::createSections.

[ruiu]

Summary

createSections is getting longer, so it is probably time to split.

[davide]

lg

lld/trunk/ELF/LinkerScript.h

public:
   int compareSections(StringRef A, StringRef B);
   void addScriptedSymbols();
   bool hasPhdrsCommands();
 
 private:
   // "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> getPhdrIndicesForSection(StringRef Name);
   void dispatchAssignment(SymbolAssignment *Cmd);
 
   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

lld/trunk/ELF/LinkerScript.cpp

static bool match(StringRef Pattern, ArrayRef<StringRef> Arr) {
   return false;
 }
 
 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;
-  DenseSet<OutputSectionBase<ELFT> *> Removed;
 
   // 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,
-                         ConstraintKind Constraint) {
+  auto AddInputSec = [&](InputSectionBase<ELFT> *C, StringRef Name) {
     OutputSectionBase<ELFT> *Sec;
     bool IsNew;
     std::tie(Sec, IsNew) = Factory.create(C, Name);
     if (IsNew)
       Result.push_back(Sec);
-    if ((!(C->getSectionHdr()->sh_flags & SHF_WRITE)) &&
-        Constraint == ReadWrite) {
-      Removed.insert(Sec);
-      return;
-    }
-    if ((C->getSectionHdr()->sh_flags & SHF_WRITE) && Constraint == ReadOnly) {
-      Removed.insert(Sec);
-      return;
-    }
     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());
for (const std::unique_ptr<BaseCommand> &Cmd : OutCmd->Commands) {
         for (InputSectionBase<ELFT> *S : F->getSections()) {
           if (isDiscarded(S) || S->OutSec)
             continue;
 
           if (match(S->getSectionName(), InCmd->Patterns)) {
             if (OutCmd->Name == "/DISCARD/")
               S->Live = false;
             else
-              AddInputSec(S, OutCmd->Name, OutCmd->Constraint);
+              AddInputSec(S, OutCmd->Name);
           }
         }
       }
     }
   }
 
   // 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), NoConstraint);
+          AddInputSec(S, getOutputSectionName(S));
       } else
         reportDiscarded(S, F);
     }
 
-  // Remove from the output all the sections which did not met the constraints.
-  Result.erase(std::remove_if(Result.begin(), Result.end(),
-                              [&](OutputSectionBase<ELFT> *Sec) {
-                                return Removed.count(Sec);
-                              }),
-               Result.end());
-  return Result;
+  // Remove from the output all the sections which did not meet
+  // the optional constraints.
+  return filter(Result);
+}
+
+// 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
+  // requested properties.
+  auto It = Sections.begin();
+  for (const std::unique_ptr<BaseCommand> &Base : Opt.Commands) {
+    auto *Cmd = dyn_cast<OutputSectionCommand>(Base.get());
+    if (!Cmd)
+      continue;
+
+    OutputSectionBase<ELFT> *Sec = *It;
+    switch (Cmd->Constraint) {
+    case ConstraintKind::NoConstraint:
+      ++It;
+      continue;
+    case ConstraintKind::ReadOnly:
+      if (Sec->getFlags() & SHF_WRITE)
+        break;
+      ++It;
+      continue;
+    case ConstraintKind::ReadWrite:
+      if (!(Sec->getFlags() & SHF_WRITE))
+        break;
+      ++It;
+      continue;
+    }
+    Sections.erase(It);
+  }
+  return Sections;
 }
 
 template <class ELFT>
 void LinkerScript<ELFT>::dispatchAssignment(SymbolAssignment *Cmd) {
   uint64_t Val = evalExpr(Cmd->Expr, Dot);
   if (Cmd->Name == ".") {
     Dot = Val;
   } else if (!Cmd->Ignore) {