[ELF] Initial support for symbol assignment in linker scripts

[davide]

Summary

This just adds the symbol to the symboltable but doesn't update st_value.
I'd prefer to do that in my next patch. I'm not quite familiar with the linker script parsing code so a careful review would be appreciated. Thanks!

[grimar]

As far I remember, linker script implementation story was suspended with idea that redesign is required at first (please see comments for D19190).
My suggestion for redesign was here: D19976, it is long time without movements.

So I just not sure is it worth to continue that patch when it seems there is no clear desicion about LS design. At least that moment should be
clarified at first I think.

[grimar]

btw, PROVIDE command implemented in mentioned "[ELF] - Implemented PROVIDE linker script command." (D19190) is
very close to this I think. I would probably combine the PROVIDE tag and such assignments.
But again we need to clarify the design at first.

[davide]

In D21965#473554, @grimar wrote:

btw, PROVIDE command implemented in mentioned "[ELF] - Implemented PROVIDE linker script command." (D19190) is
very close to this I think. I would probably combine the PROVIDE tag and such assignments.
But again we need to clarify the design at first.

OK, I'm abandoning this for now then.
I'll try to take a look at D19190. Thanks!

ELF/LinkerScript.h

 
 // Parses a linker script. Calling this function updates
 // Config and ScriptConfig.
 void readLinkerScript(MemoryBufferRef MB);
 
 class ScriptParser;
 template <class ELFT> class InputSectionBase;
 template <class ELFT> class OutputSectionBase;
+template <class ELFT> class SymbolTable;
 
 // This class represents each rule in SECTIONS command.
 struct SectionRule {
   SectionRule(StringRef D, StringRef S)
       : Dest(D), SectionPattern(S) {}
 
   StringRef Dest;
 
   StringRef SectionPattern;
 };
 
 // This enum represents what we can observe in SECTIONS tag of script:
+// AssignmentKind is an assignment of a symbol to a value, like ".blah = 0x100"
 // ExprKind is a location counter change, like ". = . + 0x1000"
 // SectionKind is a description of output section, like ".data :..."
-enum SectionsCommandKind { ExprKind, SectionKind };
+enum SectionsCommandKind { AssignmentKind, ExprKind, SectionKind };
 
 struct SectionsCommand {
   SectionsCommandKind Kind;
   std::vector<StringRef> Expr;
-  StringRef SectionName;
+  StringRef SectionOrSymbolName;
 };
 
 // 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;
 
+  bool AddSymbols = false;
   bool DoLayout = false;
 
   llvm::BumpPtrAllocator Alloc;
 
   // List of section patterns specified with KEEP commands. They will
   // be kept even if they are unused and --gc-sections is specified.
   std::vector<StringRef> KeptSections;
 };
 
 extern ScriptConfiguration *ScriptConfig;
 
 // This is a runner of the linker script.
 template <class ELFT> class LinkerScript {
   typedef typename ELFT::uint uintX_t;
 
 public:
   StringRef getOutputSection(InputSectionBase<ELFT> *S);
   ArrayRef<uint8_t> getFiller(StringRef Name);
   bool isDiscarded(InputSectionBase<ELFT> *S);
   bool shouldKeep(InputSectionBase<ELFT> *S);
+  void addSymbols();
   void assignAddresses(ArrayRef<OutputSectionBase<ELFT> *> S);
   int compareSections(StringRef A, StringRef B);
 
 private:
   // "ScriptConfig" is a bit too long, so define a short name for it.
   ScriptConfiguration &Opt = *ScriptConfig;
 
   int getSectionIndex(StringRef Name);

ELF/LinkerScript.cpp

 bool LinkerScript<ELFT>::shouldKeep(InputSectionBase<ELFT> *S) {
   for (StringRef Pat : Opt.KeptSections)
     if (globMatch(Pat, S->getSectionName()))
       return true;
   return false;
 }
 
 template <class ELFT>
+void LinkerScript<ELFT>::addSymbols() {
+  for (SectionsCommand &Cmd : Opt.Commands)
+    if (Cmd.Kind == AssignmentKind)
+      Symtab<ELFT>::X->addAbsolute(Cmd.SectionOrSymbolName, STV_DEFAULT);
+}
+
+template <class ELFT>
 void LinkerScript<ELFT>::assignAddresses(
     ArrayRef<OutputSectionBase<ELFT> *> Sections) {
   // Orphan sections are sections present in the input files which
   // are not explicitly placed into the output file by the linker script.
   // We place orphan sections at end of file.
   // Other linkers places them using some heuristics as described in
   // https://sourceware.org/binutils/docs/ld/Orphan-Sections.html#Orphan-Sections.
   for (OutputSectionBase<ELFT> *Sec : Sections) {
if (Cmd.Kind == ExprKind) {
       Dot = evalExpr(Cmd.Expr, Dot);
       continue;
     }
 
     // Find all the sections with required name. There can be more than
     // ont section with such name, if the alignment, flags or type
     // attribute differs.
     for (OutputSectionBase<ELFT> *Sec : Sections) {
-      if (Sec->getName() != Cmd.SectionName)
+      if (Sec->getName() != Cmd.SectionOrSymbolName)
         continue;
 
       if ((Sec->getFlags() & SHF_TLS) && Sec->getType() == SHT_NOBITS) {
         uintX_t TVA = Dot + ThreadBssOffset;
         TVA = alignTo(TVA, Sec->getAlignment());
         Sec->setVA(TVA);
         ThreadBssOffset = TVA - Dot + Sec->getSize();
         continue;

 // 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) {
   auto Begin = Opt.Commands.begin();
   auto End = Opt.Commands.end();
   auto I = std::find_if(Begin, End, [&](SectionsCommand &N) {
-    return N.Kind == SectionKind && N.SectionName == Name;
+    return N.Kind == SectionKind && N.SectionOrSymbolName == Name;
   });
   return I == End ? INT_MAX : (I - Begin);
 }
 
 // A compartor to sort output sections. Returns -1 or 1 if
 // A or B are mentioned in linker script. Otherwise, returns 0.
 template <class ELFT>
 int LinkerScript<ELFT>::compareSections(StringRef A, StringRef B) {
private:
   void readNothing() {}
   void readOutput();
   void readOutputArch();
   void readOutputFormat();
   void readSearchDir();
   void readSections();
 
   void readLocationCounterValue();
-  void readOutputSectionDescription();
+  void readSymbolAssignment(StringRef SymName);
+  void readOutputSectionDescription(StringRef OutSec);
 
   const static StringMap<Handler> Cmd;
   ScriptConfiguration &Opt = *ScriptConfig;
   StringSaver Saver = {ScriptConfig->Alloc};
   bool IsUnderSysroot;
 };
 
 const StringMap<elf::ScriptParser::Handler> elf::ScriptParser::Cmd = {
void ScriptParser::readSearchDir() {
   Config->SearchPaths.push_back(next());
   expect(")");
 }
 
 void ScriptParser::readSections() {
   Opt.DoLayout = true;
   expect("{");
   while (!Error && !skip("}")) {
-    StringRef Tok = peek();
+    StringRef Tok = next();
+    StringRef NextTok = peek();
+    if (NextTok == "=") {
       if (Tok == ".")
         readLocationCounterValue();
       else
-      readOutputSectionDescription();
+        readSymbolAssignment(Tok);
+    }
+    else {
+      readOutputSectionDescription(Tok);
+    }
+  }
+}
+
+void ScriptParser::readSymbolAssignment(StringRef SymName) {
+  Opt.AddSymbols = true;
+  expect("=");
+  Opt.Commands.push_back({AssignmentKind, {}, SymName});
+  SectionsCommand &Cmd = Opt.Commands.back();
+  while (!Error) {
+    StringRef Tok = next();
+    if (Tok == ";")
+      break;
+    Cmd.Expr.push_back(Tok);
   }
+  if (Cmd.Expr.empty())
+    error("error in symbol assignment expression");
 }
 
 void ScriptParser::readLocationCounterValue() {
-  expect(".");
   expect("=");
   Opt.Commands.push_back({ExprKind, {}, ""});
   SectionsCommand &Cmd = Opt.Commands.back();
   while (!Error) {
     StringRef Tok = next();
     if (Tok == ";")
       break;
     Cmd.Expr.push_back(Tok);
   }
   if (Cmd.Expr.empty())
     error("error in location counter expression");
 }
 
-void ScriptParser::readOutputSectionDescription() {
-  StringRef OutSec = next();
+void ScriptParser::readOutputSectionDescription(StringRef OutSec) {
   Opt.Commands.push_back({SectionKind, {}, OutSec});
   expect(":");
   expect("{");
 
   while (!Error && !skip("}")) {
     StringRef Tok = next();
     if (Tok == "*") {
       expect("(");

ELF/Writer.cpp

template <class ELFT> void elf::writeResult(SymbolTable<ELFT> *Symtab) {
   Writer<ELFT>(*Symtab).run();
 }
 
 // The main function of the writer.
 template <class ELFT> void Writer<ELFT>::run() {
   if (!Config->DiscardAll)
     copyLocalSymbols();
   addReservedSymbols();
+  if (ScriptConfig->AddSymbols)
+    Script<ELFT>::X->addSymbols();
   createSections();
   if (HasError)
     return;
 
   if (Config->Relocatable) {
     assignFileOffsets();
   } else {
     createPhdrs();

test/ELF/linkerscript-assignment.s

+# REQUIRES: x86
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/shared.s -o %t2.o
+# RUN: ld.lld -shared %t2.o -soname shared -o %t2.so
+
+# RUN: echo "SECTIONS { __executable_start = 0x100; }" > %t.script
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
+# RUN: ld.lld -T %t.script %t.o -o %t
+# RUN: llvm-readobj -t %t | FileCheck %s
+
+# CHECK: Symbol {
+# CHECK:   Name: __executable_start
+# CHECK:   Value: 0x0
+# CHECK:   Size: 0
+# CHECK:   Binding: Global
+# CHECK:   Type: None
+# CHECK:   Other: 0
+# CHECK:   Section: Absolute
+# CHECK: }
+
+.globl _start
+_start:
+  ret