[ELF] Support symbol assignment inside SECTIONS {} block in linker scripts

[evgeny777]

Summary

This patch implements minimal support for symbol assignment. Only assignment within SECTIONS block is supported

[ruiu]

ELF/LinkerScript.cpp

235

Why don't you directly call SymbolTable::addAbsolute here?

512–515

Hmm, so you are changing the grammar to LL(2). Do you really need to do that? I think you could do something like this to keep it LL(1).

if (Tok == ".") {
  readLocationCounterValue();
  continue;
}
next();
if (peek() == "=")
  readSymbolAssignment(Tok);
else
  readOutputSectionDescription(Tok);

ELF/LinkerScript.h

13–14

Instead of including these headers, please declare the classes you need in this header.

namespace lld {
namespace elf {
template <class ELFT> class SymbolTable;
...
}
}

86

The symbol table is globally visible as Symtab<ELFT>::X, so you don't need to pass it around.

[evgeny777]

ELF/LinkerScript.cpp

235

I doubt this is possible.
Adding symbol will increase size of .symtab and (possibly) .dyntab which in its turn can affect virtual addresses of some sections.
Also symbols are copied from Symtab object to output sections in createSections() method, which is called before assignAddresses (and even before createPhdrs) - see Writer::run()

512–515

Makes sense. Although, strictly speaking, this doesn't make grammar LL(1) - you still have two lookahead tokens (one is saved in Tok)

[evgeny777]

Review updated. Symbols.h header file is still required in LinkerScript.h for DefinedRegular<ELFT>

[ruiu]

ELF/LinkerScript.cpp

235

Can you replace this with

Symtab<ELFT>::X->find(Cmd.Name)->Value = evalExpr(Cmd.Expr, Dot);

so that we can remove SymIndex and Symbols from this class? This code is slightly slower because it looks up the symbol table, but it should be negligible because the number of symbols appear in symbol scripts is small.

512–515

Well, I think technically it is LL(1) because it recognizes the language with one token look ahead. For semantic actions, we save a token, but it is different from recognizing a language, I think.

573

I'd make this function return a std::vector<StringRef> and use that as

Opt.Command = readSectionsCommandExpr();

It is slightly inefficient, but I believe it's easier to read.

ELF/LinkerScript.h

22

I think you can add

template <class ELFT> class DefinedRegular;

to remove #include "Symbols.h".

50

It is very confusing to reuse SectionName field for symbol name because symbol name is not a section name. Maybe we should rename this Name.

[evgeny777]

Review updated

[ruiu]

ELF/LinkerScript.cpp

237

Do you need this assert? If there's a bug, it would crash with a null pointer dereference.

311

You can remove {}

525

This can be

Opt.Commands.push_back({ExprKind, readSectionsCommandExpr(), ""});

569

This can be

std::vector<StringRef> Exprs = readSectionsCommandExpr();
if (Exprs.empty())
  error(...);
Opt.Command.push_back({SymbolAssignmentKind, Exprs, Name});

ELF/Writer.cpp

788

Add a blank line before this comment.

test/ELF/linkerscript-symbols.s

13

Remove this blank line at end of file.

[evgeny777]

ELF/LinkerScript.cpp

525

This will omit error message and break unit test. Also, I suggest to use move semantics here for performance reasons

569

I would use move semantics for initializer list for performance reasons.

Opt.Command.push_back({SymbolAssignmentKind, std::move(Exprs), Name})

[evgeny777]

Review updated

[ruiu]

LGTM

[grimar]

D21965

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.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_LINKER_SCRIPT_H
 #define LLD_ELF_LINKER_SCRIPT_H
 
+#include "Symbols.h"
 #include "lld/Core/LLVM.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/MemoryBuffer.h"
 
 namespace lld {
 namespace elf {
+template <class ELFT> class SymbolTable;
 
 // 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;
 
 // 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:
 // ExprKind is a location counter change, like ". = . + 0x1000"
 // SectionKind is a description of output section, like ".data :..."
-enum SectionsCommandKind { ExprKind, SectionKind };
+enum SectionsCommandKind { ExprKind, SectionKind, SymbolAssignmentKind };
 
 struct SectionsCommand {
   SectionsCommandKind Kind;
   std::vector<StringRef> Expr;
   StringRef SectionName;
 };
 
 // ScriptConfiguration holds linker script parse results.
 struct ScriptConfiguration {
   // SECTIONS commands.
   std::vector<SectionRule> Sections;
 
   // Section fill attribute for each section.

 
 public:
   StringRef getOutputSection(InputSectionBase<ELFT> *S);
   ArrayRef<uint8_t> getFiller(StringRef Name);
   bool isDiscarded(InputSectionBase<ELFT> *S);
   bool shouldKeep(InputSectionBase<ELFT> *S);
   void assignAddresses(ArrayRef<OutputSectionBase<ELFT> *> S);
   int compareSections(StringRef A, StringRef B);
+  void addScriptedSymbols();
 
 private:
   // "ScriptConfig" is a bit too long, so define a short name for it.
   ScriptConfiguration &Opt = *ScriptConfig;
 
   int getSectionIndex(StringRef Name);
 
   uintX_t Dot;
+
+  std::vector<DefinedRegular<ELFT> *> Symbols;
 };
 
 // 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

ELF/LinkerScript.cpp

for (OutputSectionBase<ELFT> *Sec : Sections) {
     StringRef Name = Sec->getName();
     if (getSectionIndex(Name) == INT_MAX)
       Opt.Commands.push_back({SectionKind, {}, Name});
   }
 
   // Assign addresses as instructed by linker script SECTIONS sub-commands.
   Dot = Out<ELFT>::ElfHeader->getSize() + Out<ELFT>::ProgramHeaders->getSize();
   uintX_t MinVA = std::numeric_limits<uintX_t>::max();
+  uintX_t SymIndex = 0;
   uintX_t ThreadBssOffset = 0;
 
   for (SectionsCommand &Cmd : Opt.Commands) {
-    if (Cmd.Kind == ExprKind) {
+    switch (Cmd.Kind) {
+    case ExprKind:
       Dot = evalExpr(Cmd.Expr, Dot);
       continue;
+    case SymbolAssignmentKind:
+      Symbols[SymIndex++]->Value = evalExpr(Cmd.Expr, Dot);
+      continue;
+    default:
+      break;
     }
 
     // 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)
         continue;

 int LinkerScript<ELFT>::compareSections(StringRef A, StringRef B) {
   int I = getSectionIndex(A);
   int J = getSectionIndex(B);
   if (I == INT_MAX && J == INT_MAX)
     return 0;
   return I < J ? -1 : 1;
 }
 
+template <class ELFT>
+void LinkerScript<ELFT>::addScriptedSymbols() {
+  for (SectionsCommand &Cmd : Opt.Commands) {
+    if (Cmd.Kind == SymbolAssignmentKind) {
+      DefinedRegular<ELFT> *D =
+          Symtab<ELFT>::X->addAbsolute(Cmd.SectionName, STV_DEFAULT);
+      Symbols.push_back(D);
+    }
+  }
+}
+
 class elf::ScriptParser : public ScriptParserBase {
   typedef void (ScriptParser::*Handler)();
 
 public:
   ScriptParser(StringRef S, bool B) : ScriptParserBase(S), IsUnderSysroot(B) {}
 
   void run();
 
 private:
   void addFile(StringRef Path);
 
   void readAsNeeded();
   void readEntry();
   void readExtern();
   void readGroup();
   void readInclude();
   void readNothing() {}
   void readOutput();
   void readOutputArch();
   void readOutputFormat();
   void readSearchDir();
   void readSections();
 
   void readLocationCounterValue();
-  void readOutputSectionDescription();
+  void readOutputSectionDescription(StringRef OutSec);
+  void readSymbolAssignment(StringRef Name);
+  void readSectionsCommandExpr();
 
   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() {
   expect(")");
 }
 
 void ScriptParser::readSections() {
   Opt.DoLayout = true;
   expect("{");
   while (!Error && !skip("}")) {
     StringRef Tok = peek();
-    if (Tok == ".")
+    if (Tok == ".") {
       readLocationCounterValue();
+      continue;
+    }
+    next();
+    if (peek() == "=")
+      readSymbolAssignment(Tok);
     else
-      readOutputSectionDescription();
+      readOutputSectionDescription(Tok);
   }
 }
 
 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");
+  readSectionsCommandExpr();
 }
 
-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("(");
if (!Tok.startswith("=0x")) {
       return;
     }
     Tok = Tok.substr(3);
     Opt.Filler[OutSec] = parseHex(Tok);
     next();
   }
 }
 
+void ScriptParser::readSymbolAssignment(StringRef Name) {
+  expect("=");
+  Opt.Commands.push_back({SymbolAssignmentKind, {}, Name});
+  readSectionsCommandExpr();
+}
+
+void ScriptParser::readSectionsCommandExpr() {
+  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");
+}
+
 static bool isUnderSysroot(StringRef Path) {
   if (Config->Sysroot == "")
     return false;
   for (; !Path.empty(); Path = sys::path::parent_path(Path))
     if (sys::fs::equivalent(Config->Sysroot, Path))
       return true;
   return false;
 }

ELF/Writer.cpp

template <class ELFT> void Writer<ELFT>::createSections() {
   // It should be okay as no one seems to care about the type.
   // Even the author of gold doesn't remember why gold behaves that way.
   // https://sourceware.org/ml/binutils/2002-03/msg00360.html
   if (isOutputDynamic())
     Symtab.addSynthetic("_DYNAMIC", Out<ELFT>::Dynamic, 0);
 
   // Define __rel[a]_iplt_{start,end} symbols if needed.
   addRelIpltSymbols();
+  // Add scripted symbols with zero values now.
+  // Real values will be assigned later
+  Script<ELFT>::X->addScriptedSymbols();
 
   if (!Out<ELFT>::EhFrame->empty()) {
     OutputSections.push_back(Out<ELFT>::EhFrame);
     Out<ELFT>::EhFrame->finalize();
   }
 
   // Scan relocations. This must be done after every symbol is declared so that
   // we can correctly decide if a dynamic relocation is needed.

test/ELF/linkerscript-symbols.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+
+# RUN: echo "SECTIONS {.text : {*(.text.*)} text_end = .;}" > %t.script
+# RUN: ld.lld -o %t1 --script %t.script %t
+# RUN: llvm-objdump -t %t1 | FileCheck %s
+# CHECK: 0000000000000121         *ABS*    00000000 text_end
+
+.global _start
+_start:
+ nop
+