[ELF] - Introduce output section description class for holding section command

[grimar]

Summary

OutputSectionDescription represents the state of SectionKind linker script command.
Previously Phdrs and Filler were somewhere outside when at fact they are a part
of output section description:
https://sourceware.org/binutils/docs/ld/Output-Section-Description.html#Output-Section-Description

That is the first patch to support "tree" view of LS.

[ruiu]

ELF/LinkerScript.h

49–59

I think this is towards the right direction, but it doesn't still reflect the structure of SECTIONS linker script command.

As per the linker script manual (#1), SECTIONS command contains one of the following sub-commands:

• an ENTRY command
• an overlay description
• a symbol assignment
• an output section description

Since we do not support the first two, I'll ignore them in this comment. So focus on the last two. We can represent the two like this.

enum SectionsCommandKind { AssignmentKind, DescriptionKind  };

struct SectionsCommand {
  SectionsCommandKind Kind;
  std::vector<StringRef> Expr;  // For AssignmentKind
  OutputSectionDescription Desc; // For DescriptionKind
};

The above struct doesn't have Name field because SECTIONS doesn't have a name.

Name is instead in output section description as described in #2. To reflect that grammar, you want to define a class like this.

struct OutputSectionDescription {
  StringRef Name;
  std::vector<OutputSectionCommand> Commands;
  std::vector<uint8_t> Filler;
};

And then you want to define OutputSectionCommand to reflect output-section-command as described in #2.

So the point is to construct an AST whose structure logically matches with the grammar.

#1 https://sourceware.org/binutils/docs/ld/SECTIONS.html#SECTIONS
#2 https://sourceware.org/binutils/docs/ld/Output-Section-Description.html#Output-Section-Description

[grimar]

I see, nice.

But we use and have Name and for assignment, because can assign to location counter and to symbols outside of section declarations.
So I think it should be like next ?

struct SectionsCommand {
  SectionsCommandKind Kind;
  AssignmentDescription Assignment;  // For AssignmentKind
  OutputSectionDescription Desc; // For DescriptionKind
};

struct AssignmentDescription {
  StringRef Name;
  std::vector<StringRef> Expr;
};

[grimar]

Probably

struct AssignmentDescription {
  StringRef Symbol;
  std::vector<StringRef> Expr;
};

As location counter is also a special symbol name.
(https://sourceware.org/binutils/docs/ld/Simple-Assignments.html#Simple-Assignments)

[ruiu]

I feel like the approach of using a simple struct is getting closer to its limit as we are defining more and more different kinds of sections sub-commands. It is probably time to switch to the LLVM-style RTTI.

[ruiu]

What I was trying to say is https://reviews.llvm.org/D22597. I got to go, so I'm not going to finish this anytime soon. Feel free to take it over.

[grimar]

In D22589#490390, @ruiu wrote:

What I was trying to say is https://reviews.llvm.org/D22597. I got to go, so I'm not going to finish this anytime soon. Feel free to take it over.

I`ll take a look, thanks !

[grimar]

another design was landed

ELF/LinkerScript.h

struct SectionRule {
   StringRef SectionPattern;
 };
 
 // This enum represents what we can observe in SECTIONS tag of script:
 // ExprKind is a location counter change, like ". = . + 0x1000"
 // SectionKind is a description of output section, like ".data :..."
 enum SectionsCommandKind { SectionKind, AssignmentKind };
 
+struct OutputSectionDescription {
+  std::vector<StringRef> Phdrs;
+  std::vector<uint8_t> Filler;
+};
+
 struct SectionsCommand {
   SectionsCommandKind Kind;
   std::vector<StringRef> Expr;
   StringRef Name;
-  std::vector<StringRef> Phdrs;
+  OutputSectionDescription Section;
 };
 
 struct PhdrsCommand {
   StringRef Name;
   unsigned Type;
   bool HasFilehdr;
   bool HasPhdrs;
 };
 
 // ScriptConfiguration holds linker script parse results.
 struct ScriptConfiguration {
   // SECTIONS commands.
   std::vector<SectionRule> Sections;
 
-  // Section fill attribute for each section.
-  llvm::StringMap<std::vector<uint8_t>> Filler;
-
   // Used to assign addresses to sections.
   std::vector<SectionsCommand> Commands;
 
   // Used to assign sections to headers.
   std::vector<PhdrsCommand> PhdrsCommands;
 
   bool DoLayout = false;
 

ELF/LinkerScript.cpp

for (OutputSectionBase<ELFT> *Sec : Sections) {
     if (NoteNum != -1 && Sec->getType() == SHT_NOTE)
       Phdrs[NoteNum].add(Sec);
   }
   return Phdrs;
 }
 
 template <class ELFT>
 ArrayRef<uint8_t> LinkerScript<ELFT>::getFiller(StringRef Name) {
-  auto I = Opt.Filler.find(Name);
-  if (I == Opt.Filler.end())
-    return {};
-  return I->second;
+  for (SectionsCommand &Cmd : Opt.Commands)
+    if (Cmd.Kind == SectionKind && Cmd.Name == Name)
+      return Cmd.Section.Filler;
 }
 
 // Returns the index of the given section name in linker script
 // SECTIONS commands. Sections are laid out as the same order as they
 // were in the script. If a given name did not appear in the script,
 // it returns INT_MAX, so that it will be laid out at end of file.
 template <class ELFT>
 int LinkerScript<ELFT>::getSectionIndex(StringRef Name) {

 // PHDRS {} script block.
 template <class ELFT>
 std::vector<size_t>
 LinkerScript<ELFT>::getPhdrIndicesForSection(StringRef Name) {
   for (SectionsCommand &Cmd : Opt.Commands) {
     if (Cmd.Kind != SectionKind || Cmd.Name != Name)
       continue;
 
+    OutputSectionDescription &OutSec = Cmd.Section;
     std::vector<size_t> Indices;
-    for (StringRef PhdrName : Cmd.Phdrs) {
+    for (StringRef PhdrName : OutSec.Phdrs) {
       auto ItPhdr =
           std::find_if(Opt.PhdrsCommands.rbegin(), Opt.PhdrsCommands.rend(),
                        [&](PhdrsCommand &Cmd) { return Cmd.Name == PhdrName; });
       if (ItPhdr == Opt.PhdrsCommands.rend())
         error("section header '" + PhdrName + "' is not listed in PHDRS");
       else
         Indices.push_back(std::distance(ItPhdr, Opt.PhdrsCommands.rend()) - 1);
     }
void ScriptParser::readLocationCounterValue() {
   if (Expr.empty())
     error("error in location counter expression");
   else
     Opt.Commands.push_back({AssignmentKind, std::move(Expr), ".", {}});
 }
 
 void ScriptParser::readOutputSectionDescription(StringRef OutSec) {
   Opt.Commands.push_back({SectionKind, {}, OutSec, {}});
-  SectionsCommand &Cmd = Opt.Commands.back();
+  OutputSectionDescription &S = Opt.Commands.back().Section;
   expect(":");
   expect("{");
 
   while (!Error && !skip("}")) {
     StringRef Tok = next();
     if (Tok == "*") {
       expect("(");
       while (!Error && !skip(")"))
         Opt.Sections.emplace_back(OutSec, next());
     } else if (Tok == "KEEP") {
       expect("(");
       expect("*");
       expect("(");
       while (!Error && !skip(")")) {
         StringRef Sec = next();
         Opt.Sections.emplace_back(OutSec, Sec);
         Opt.KeptSections.push_back(Sec);
       }
       expect(")");
     } else {
       setError("unknown command " + Tok);
     }
   }
-  Cmd.Phdrs = readOutputSectionPhdrs();
+  S.Phdrs = readOutputSectionPhdrs();
 
   StringRef Tok = peek();
   if (Tok.startswith("=")) {
     if (!Tok.startswith("=0x")) {
       setError("filler should be a hexadecimal value");
       return;
     }
     Tok = Tok.substr(3);
-    Opt.Filler[OutSec] = parseHex(Tok);
+    S.Filler = parseHex(Tok);
     next();
   }
 }
 
 void ScriptParser::readSymbolAssignment(StringRef Name) {
   expect("=");
   std::vector<StringRef> Expr = readSectionsCommandExpr();
   if (Expr.empty())