Move Dot variable from LinkerScript to ScriptConfig.

[ruiu]

Summary

The special variable "." is needed to evaluate expressions.
Currently we pass Dot variable to expressions as an argument.
But "." is actually not the only variable that needs to be passed
to expressions. SIZEOF_HEADERS is also need to be passed to
expressions in some way.

We could pass such variables as arguments. But if we do that way,
we'll end up having dozens of functions that takes many arguments.
Placing these varaibles in a shared place is probably a better way.

This patch moves Dot to ScriptConfig, so that it's accessible
both from LinkerScript and the expression evaluator.

[grimar]

I am not sure that this change reflects the script context properly.
I mean that documentation says: ". actually refers to the byte offset from the start of the current containing object. Normally this is the SECTIONS statement, whose start address is 0, hence . can be used as an absolute address. If . is used inside a section description however, it refers to the byte offset from the start of that section, not an absolute address. "
(https://sourceware.org/binutils/docs-2.23/ld/Location-Counter.html)

Currently we are using "." only in assignAddresses, so we use absolete address. But we also will need to support the second case. In this implementation looks like we will need to reset the location counter for each OutputSectionCommand in createSections():

for (const std::unique_ptr<BaseCommand> &Base : Opt.Commands) {
    auto *OutCmd = dyn_cast<OutputSectionCommand>(Base.get());
    if (!OutCmd)
      continue;

Opt.Dot = 0;
....

I am not sure how nice that will look. As Dot becoming not the configuration state, but just temporarily variable, moved to configuration class.

I think we do not want to pass other such things like SIZEOF_HEADERS as arguments, they always have the same meaning. But dot itself looks better as argument for me.

[ruiu]

I don't think this patch changes the behavior at all. It just moves a variable from one class to another. So I don't think there's no concern on semantics.

[grimar]

In D22740#494857, @ruiu wrote:

I don't think this patch changes the behavior at all. It just moves a variable from one class to another. So I don't think there's no concern on semantics.

It does not change, and IMO does not help. It is just neutral.
What I meant that I just think we will probably want some different solution for Dot generally.
Since there is no big difference I am not against landing this if you feel it is better.

ELF/LinkerScript.h

27

I would really leave Expr type, that was nice and clear to have.

[• rafael]

I am not sure how complex linker scripts expression will get, so it is hard to have an opinion on this.

In general when interpreting an expression, the interpretation is made in an Environment, which maps names to values. It would be another way of doing this, but tt is not clear if that generality is needed for linker scripts. Is Dot the only variable that can have different values in different contexts?

ELF/LinkerScript.h

27

Agreed.

[davide]

Rui, are you still pursuing this path?

[ruiu]

It may not be a bad idea, but I'm not pursuing this at least at the moment. Will abandon.

ELF/LinkerScript.h

 #include <functional>
 
 namespace lld {
 namespace elf {
 template <class ELFT> class InputSectionBase;
 template <class ELFT> class OutputSectionBase;
 template <class ELFT> class OutputSectionFactory;
 
-typedef std::function<uint64_t(uint64_t)> Expr;
-
 // 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 enum is used to implement linker script SECTIONS command.
 // https://sourceware.org/binutils/docs/ld/SECTIONS.html#SECTIONS
 enum SectionsCommandKind {
   AssignmentKind,
   OutputSectionKind,
   InputSectionKind
 };
 
 struct BaseCommand {
   BaseCommand(int K) : Kind(K) {}
   virtual ~BaseCommand() {}
   int Kind;
 };
 
 struct SymbolAssignment : BaseCommand {
-  SymbolAssignment(StringRef Name, Expr E)
-      : BaseCommand(AssignmentKind), Name(Name), Expression(E) {}
+  SymbolAssignment(StringRef Name, std::function<uint64_t()> Expr)
+      : BaseCommand(AssignmentKind), Name(Name), Expr(Expr) {}
   static bool classof(const BaseCommand *C);
   StringRef Name;
-  Expr Expression;
+  std::function<uint64_t()> Expr;
   bool Provide = false;
   // Hidden and Ignore can be true, only if Provide is true
   bool Hidden = false;
   bool Ignore = false;
 };
 
 // Linker scripts allow additional constraints to be put on ouput sections.
 // An output section will only be created if all of its input sections are
struct ScriptConfiguration {
 
   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;
+
+  // The current value of the special variable ".".
+  uint64_t Dot = 0;
 };
 
 extern ScriptConfiguration *ScriptConfig;
 
 // This is a runner of the linker script.
 template <class ELFT> class LinkerScript {
   typedef typename ELFT::uint uintX_t;
 

 
 private:
   // "ScriptConfig" is a bit too long, so define a short name for it.
   ScriptConfiguration &Opt = *ScriptConfig;
 
   int getSectionIndex(StringRef Name);
   std::vector<size_t> getPhdrIndices(StringRef SectionName);
   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

ELF/LinkerScript.cpp

Result.erase(std::remove_if(Result.begin(), Result.end(),
                                 return Removed.count(Sec);
                               }),
                Result.end());
   return Result;
 }
 
 template <class ELFT>
 void LinkerScript<ELFT>::dispatchAssignment(SymbolAssignment *Cmd) {
-  uint64_t Val = Cmd->Expression(Dot);
   if (Cmd->Name == ".") {
-    Dot = Val;
+    Opt.Dot = Cmd->Expr();
   } else if (!Cmd->Ignore) {
     auto *D = cast<DefinedRegular<ELFT>>(Symtab<ELFT>::X->find(Cmd->Name));
-    D->Value = Val;
+    D->Value = Cmd->Expr();
   }
 }
 
 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) {
     StringRef Name = Sec->getName();
     if (getSectionIndex(Name) == INT_MAX)
       Opt.Commands.push_back(llvm::make_unique<OutputSectionCommand>(Name));
   }
 
   // Assign addresses as instructed by linker script SECTIONS sub-commands.
-  Dot = Out<ELFT>::ElfHeader->getSize() + Out<ELFT>::ProgramHeaders->getSize();
+  Opt.Dot =
+      Out<ELFT>::ElfHeader->getSize() + Out<ELFT>::ProgramHeaders->getSize();
   uintX_t MinVA = std::numeric_limits<uintX_t>::max();
   uintX_t ThreadBssOffset = 0;
 
   for (const std::unique_ptr<BaseCommand> &Base : Opt.Commands) {
     if (auto *Cmd = dyn_cast<SymbolAssignment>(Base.get())) {
       dispatchAssignment(Cmd);
       continue;
     }
 
     // Find all the sections with required name. There can be more than
     // one section with such name, if the alignment, flags or type
     // attribute differs.
     auto *Cmd = cast<OutputSectionCommand>(Base.get());
     for (OutputSectionBase<ELFT> *Sec : Sections) {
       if (Sec->getName() != Cmd->Name)
         continue;
 
       if ((Sec->getFlags() & SHF_TLS) && Sec->getType() == SHT_NOBITS) {
-        uintX_t TVA = Dot + ThreadBssOffset;
+        uintX_t TVA = Opt.Dot + ThreadBssOffset;
         TVA = alignTo(TVA, Sec->getAlignment());
         Sec->setVA(TVA);
-        ThreadBssOffset = TVA - Dot + Sec->getSize();
+        ThreadBssOffset = TVA - Opt.Dot + Sec->getSize();
         continue;
       }
 
       if (Sec->getFlags() & SHF_ALLOC) {
-        Dot = alignTo(Dot, Sec->getAlignment());
-        Sec->setVA(Dot);
-        MinVA = std::min(MinVA, Dot);
-        Dot += Sec->getSize();
+        Opt.Dot = alignTo(Opt.Dot, Sec->getAlignment());
+        Sec->setVA(Opt.Dot);
+        MinVA = std::min(MinVA, (uintX_t)Opt.Dot);
+        Opt.Dot += Sec->getSize();
         continue;
       }
     }
   }
 
   // ELF and Program headers need to be right before the first section in
   // memory. Set their addresses accordingly.
   MinVA = alignDown(MinVA - Out<ELFT>::ElfHeader->getSize() -
private:
   void readSections();
 
   SymbolAssignment *readAssignment(StringRef Name);
   void readOutputSectionDescription(StringRef OutSec);
   std::vector<StringRef> readOutputSectionPhdrs();
   unsigned readPhdrType();
   void readProvide(bool Hidden);
 
-  Expr readExpr();
-  Expr readExpr1(Expr Lhs, int MinPrec);
-  Expr readPrimary();
-  Expr readTernary(Expr Cond);
-  Expr combine(StringRef Op, Expr Lhs, Expr Rhs);
+  std::function<uint64_t()> readExpr();
+  std::function<uint64_t()> readExpr1(std::function<uint64_t()> Lhs,
+                                      int MinPrec);
+  std::function<uint64_t()> readPrimary();
+  std::function<uint64_t()> readTernary(std::function<uint64_t()> Cond);
+  std::function<uint64_t()> combine(StringRef Op, std::function<uint64_t()> Lhs,
+                                    std::function<uint64_t()> Rhs);
 
   const static StringMap<Handler> Cmd;
   ScriptConfiguration &Opt = *ScriptConfig;
   StringSaver Saver = {ScriptConfig->Alloc};
   bool IsUnderSysroot;
 };
 
 const StringMap<elf::ScriptParser::Handler> elf::ScriptParser::Cmd = {
if (SymbolAssignment *Assignment = readAssignment(next())) {
     Assignment->Hidden = Hidden;
   }
   expect(")");
   expect(";");
 }
 
 SymbolAssignment *ScriptParser::readAssignment(StringRef Name) {
   expect("=");
-  Expr E = readExpr();
-  auto *Cmd = new SymbolAssignment(Name, E);
+  auto *Cmd = new SymbolAssignment(Name, readExpr());
   Opt.Commands.emplace_back(Cmd);
   return Cmd;
 }
 
 // This is an operator-precedence parser to parse a linker
 // script expression.
-Expr ScriptParser::readExpr() { return readExpr1(readPrimary(), 0); }
+std::function<uint64_t()> ScriptParser::readExpr() {
+  return readExpr1(readPrimary(), 0);
+}
 
 // This is a part of the operator-precedence parser. This function
 // assumes that the remaining token stream starts with an operator.
-Expr ScriptParser::readExpr1(Expr Lhs, int MinPrec) {
+std::function<uint64_t()> ScriptParser::readExpr1(std::function<uint64_t()> Lhs,
+                                                  int MinPrec) {
   while (!atEOF() && !Error) {
     // Read an operator and an expression.
     StringRef Op1 = peek();
     if (Op1 == "?")
       return readTernary(Lhs);
     if (precedence(Op1) < MinPrec)
       break;
     next();
-    Expr Rhs = readPrimary();
+    std::function<uint64_t()> Rhs = readPrimary();
 
     // Evaluate the remaining part of the expression first if the
     // next operator has greater precedence than the previous one.
     // For example, if we have read "+" and "3", and if the next
     // operator is "*", then we'll evaluate 3 * ... part first.
     while (!atEOF()) {
       StringRef Op2 = peek();
       if (precedence(Op2) <= precedence(Op1))
         break;
       Rhs = readExpr1(Rhs, precedence(Op2));
     }
 
     Lhs = combine(Op1, Lhs, Rhs);
   }
   return Lhs;
 }
 
 uint64_t static getConstant(StringRef S) {
   if (S == "COMMONPAGESIZE" || S == "MAXPAGESIZE")
     return Target->PageSize;
   error("unknown constant: " + S);
   return 0;
 }
 
-Expr ScriptParser::readPrimary() {
+std::function<uint64_t()> ScriptParser::readPrimary() {
   StringRef Tok = next();
 
   if (Tok == ".")
-    return [](uint64_t Dot) { return Dot; };
+    return []() { return ScriptConfig->Dot; };
 
   if (Tok == "(") {
-    Expr E = readExpr();
+    std::function<uint64_t()> E = readExpr();
     expect(")");
     return E;
   }
 
   // Built-in functions are parsed here.
   // https://sourceware.org/binutils/docs/ld/Builtin-Functions.html.
   if (Tok == "ALIGN") {
     expect("(");
-    Expr E = readExpr();
+    std::function<uint64_t()> E = readExpr();
     expect(")");
-    return [=](uint64_t Dot) { return alignTo(Dot, E(Dot)); };
+    return [=]() { return alignTo(ScriptConfig->Dot, E()); };
   }
   if (Tok == "CONSTANT") {
     expect("(");
     StringRef Tok = next();
     expect(")");
-    return [=](uint64_t Dot) { return getConstant(Tok); };
+    return [=]() { return getConstant(Tok); };
   }
   if (Tok == "DATA_SEGMENT_ALIGN") {
     expect("(");
-    Expr E = readExpr();
+    std::function<uint64_t()> E = readExpr();
     expect(",");
     readExpr();
     expect(")");
-    return [=](uint64_t Dot) -> uint64_t {
-      uint64_t Val = E(Dot);
+    return [=]() -> uint64_t {
+      uint64_t Val = E();
+      uint64_t Dot = ScriptConfig->Dot;
       return alignTo(Dot, Val) + (Dot & (Val - 1));
     };
   }
   if (Tok == "DATA_SEGMENT_END") {
     expect("(");
     expect(".");
     expect(")");
-    return [](uint64_t Dot) { return Dot; };
+    return []() { return ScriptConfig->Dot; };
   }
 
   // Parse a number literal
   uint64_t V = 0;
   if (Tok.getAsInteger(0, V))
     setError("malformed number: " + Tok);
-  return [=](uint64_t Dot) { return V; };
+  return [=]() { return V; };
 }
 
-Expr ScriptParser::readTernary(Expr Cond) {
+std::function<uint64_t()>
+ScriptParser::readTernary(std::function<uint64_t()> Cond) {
   next();
-  Expr L = readExpr();
+  std::function<uint64_t()> L = readExpr();
   expect(":");
-  Expr R = readExpr();
-  return [=](uint64_t Dot) { return Cond(Dot) ? L(Dot) : R(Dot); };
+  std::function<uint64_t()> R = readExpr();
+  return [=]() { return Cond() ? L() : R(); };
 }
 
-Expr ScriptParser::combine(StringRef Op, Expr L, Expr R) {
+std::function<uint64_t()> ScriptParser::combine(StringRef Op,
+                                                std::function<uint64_t()> L,
+                                                std::function<uint64_t()> R) {
   if (Op == "*")
-    return [=](uint64_t Dot) { return L(Dot) * R(Dot); };
+    return [=]() { return L() * R(); };
   if (Op == "/") {
-    return [=](uint64_t Dot) -> uint64_t {
-      uint64_t RHS = R(Dot);
+    return [=]() -> uint64_t {
+      uint64_t RHS = R();
       if (RHS == 0) {
         error("division by zero");
         return 0;
       }
-      return L(Dot) / RHS;
+      return L() / RHS;
     };
   }
   if (Op == "+")
-    return [=](uint64_t Dot) { return L(Dot) + R(Dot); };
+    return [=]() { return L() + R(); };
   if (Op == "-")
-    return [=](uint64_t Dot) { return L(Dot) - R(Dot); };
+    return [=]() { return L() - R(); };
   if (Op == "<")
-    return [=](uint64_t Dot) { return L(Dot) < R(Dot); };
+    return [=]() { return L() < R(); };
   if (Op == ">")
-    return [=](uint64_t Dot) { return L(Dot) > R(Dot); };
+    return [=]() { return L() > R(); };
   if (Op == ">=")
-    return [=](uint64_t Dot) { return L(Dot) >= R(Dot); };
+    return [=]() { return L() >= R(); };
   if (Op == "<=")
-    return [=](uint64_t Dot) { return L(Dot) <= R(Dot); };
+    return [=]() { return L() <= R(); };
   if (Op == "==")
-    return [=](uint64_t Dot) { return L(Dot) == R(Dot); };
+    return [=]() { return L() == R(); };
   if (Op == "!=")
-    return [=](uint64_t Dot) { return L(Dot) != R(Dot); };
+    return [=]() { return L() != R(); };
   if (Op == "&")
-    return [=](uint64_t Dot) { return L(Dot) & R(Dot); };
+    return [=]() { return L() & R(); };
   llvm_unreachable("invalid operator");
 }
 
 std::vector<StringRef> ScriptParser::readOutputSectionPhdrs() {
   std::vector<StringRef> Phdrs;
   while (!Error && peek().startswith(":")) {
     StringRef Tok = next();
     Tok = (Tok.size() == 1) ? next() : Tok.substr(1);