[ELF] - Linkerscript: use expression instead of uint64_t for Dot argument.

[grimar]

Summary

Sometimes it can be useful to restrict the use of Dot in expression.
Patch allows to do that by replacing the uint64_t with a std::function,
which will be able either to return Dot value or error out.

I am using this in D23063.

[grimar]

We can live without this.

ELF/LinkerScript.h

 namespace lld {
 namespace elf {
 class SymbolBody;
 template <class ELFT> class InputSectionBase;
 template <class ELFT> class OutputSectionBase;
 template <class ELFT> class OutputSectionFactory;
 template <class ELFT> class DefinedCommon;
 
-typedef std::function<uint64_t(uint64_t)> Expr;
+typedef std::function<uint64_t()> DotExpr;
+typedef std::function<uint64_t(DotExpr)> 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;

ELF/LinkerScript.cpp

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();
   uintX_t MinVA = std::numeric_limits<uintX_t>::max();
   uintX_t ThreadBssOffset = 0;
 
+  auto LocationCounter = [=]() { return Dot; };
   for (const std::unique_ptr<BaseCommand> &Base : Opt.Commands) {
     if (auto *Cmd = dyn_cast<SymbolAssignment>(Base.get())) {
       if (Cmd->Name == ".") {
-        Dot = Cmd->Expression(Dot);
+        Dot = Cmd->Expression(LocationCounter);
       } else if (Cmd->Sym) {
-        cast<DefinedRegular<ELFT>>(Cmd->Sym)->Value = Cmd->Expression(Dot);
+        cast<DefinedRegular<ELFT>>(Cmd->Sym)->Value =
+            Cmd->Expression(LocationCounter);
       }
       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 (Cmd->AddrExpr)
-        Dot = Cmd->AddrExpr(Dot);
+        Dot = Cmd->AddrExpr(LocationCounter);
 
       if (Cmd->AlignExpr)
-        Sec->updateAlignment(Cmd->AlignExpr(Dot));
+        Sec->updateAlignment(Cmd->AlignExpr(LocationCounter));
 
       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;
       }
static uint64_t getSectionSize(StringRef Name) {
   return 0;
 }
 
 SymbolAssignment *ScriptParser::readAssignment(StringRef Name) {
   StringRef Op = next();
   assert(Op == "=" || Op == "+=");
   Expr E = readExpr();
   if (Op == "+=")
-    E = [=](uint64_t Dot) { return getSymbolValue(Name, Dot) + E(Dot); };
+    E = [=](DotExpr Dot) { return getSymbolValue(Name, Dot()) + E(Dot); };
   auto *Cmd = new SymbolAssignment(Name, E);
   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); }
Expr ScriptParser::readPrimary() {
   }
 
   // Built-in functions are parsed here.
   // https://sourceware.org/binutils/docs/ld/Builtin-Functions.html.
   if (Tok == "ALIGN") {
     expect("(");
     Expr E = readExpr();
     expect(")");
-    return [=](uint64_t Dot) { return alignTo(Dot, E(Dot)); };
+    return [=](DotExpr Dot) { return alignTo(Dot(), E(Dot)); };
   }
   if (Tok == "CONSTANT") {
     expect("(");
     StringRef Tok = next();
     expect(")");
-    return [=](uint64_t Dot) { return getConstant(Tok); };
+    return [=](DotExpr Dot) { return getConstant(Tok); };
   }
   if (Tok == "SEGMENT_START") {
     expect("(");
     next();
     expect(",");
     uint64_t Val;
     next().getAsInteger(0, Val);
     expect(")");
-    return [=](uint64_t Dot) { return Val; };
+    return [=](DotExpr Dot) { return Val; };
   }
   if (Tok == "DATA_SEGMENT_ALIGN") {
     expect("(");
     Expr E = readExpr();
     expect(",");
     readExpr();
     expect(")");
-    return [=](uint64_t Dot) { return alignTo(Dot, E(Dot)); };
+    return [=](DotExpr Dot) { return alignTo(Dot(), E(Dot)); };
   }
   if (Tok == "DATA_SEGMENT_END") {
     expect("(");
     expect(".");
     expect(")");
-    return [](uint64_t Dot) { return Dot; };
+    return [](DotExpr Dot) { return Dot(); };
   }
   // GNU linkers implements more complicated logic to handle
   // DATA_SEGMENT_RELRO_END. We instead ignore the arguments and just align to
   // the next page boundary for simplicity.
   if (Tok == "DATA_SEGMENT_RELRO_END") {
     expect("(");
     next();
     expect(",");
     readExpr();
     expect(")");
-    return [](uint64_t Dot) { return alignTo(Dot, Target->PageSize); };
+    return [](DotExpr Dot) { return alignTo(Dot(), Target->PageSize); };
   }
   if (Tok == "SIZEOF") {
     expect("(");
     StringRef Name = next();
     expect(")");
-    return [=](uint64_t Dot) { return getSectionSize(Name); };
+    return [=](DotExpr Dot) { return getSectionSize(Name); };
   }
 
   // Parse a symbol name or a number literal.
   uint64_t V = 0;
   if (Tok.getAsInteger(0, V)) {
     if (Tok != "." && !isValidCIdentifier(Tok))
       setError("malformed number: " + Tok);
-    return [=](uint64_t Dot) { return getSymbolValue(Tok, Dot); };
+    return [=](DotExpr Dot) { return getSymbolValue(Tok, Dot()); };
   }
-  return [=](uint64_t Dot) { return V; };
+  return [=](DotExpr Dot) { return V; };
 }
 
 Expr ScriptParser::readTernary(Expr Cond) {
   next();
   Expr L = readExpr();
   expect(":");
   Expr R = readExpr();
-  return [=](uint64_t Dot) { return Cond(Dot) ? L(Dot) : R(Dot); };
+  return [=](DotExpr Dot) { return Cond(Dot) ? L(Dot) : R(Dot); };
 }
 
 Expr ScriptParser::combine(StringRef Op, Expr L, Expr R) {
   if (Op == "*")
-    return [=](uint64_t Dot) { return L(Dot) * R(Dot); };
+    return [=](DotExpr Dot) { return L(Dot) * R(Dot); };
   if (Op == "/") {
-    return [=](uint64_t Dot) -> uint64_t {
+    return [=](DotExpr Dot) -> uint64_t {
       uint64_t RHS = R(Dot);
       if (RHS == 0) {
         error("division by zero");
         return 0;
       }
       return L(Dot) / RHS;
     };
   }
   if (Op == "+")
-    return [=](uint64_t Dot) { return L(Dot) + R(Dot); };
+    return [=](DotExpr Dot) { return L(Dot) + R(Dot); };
   if (Op == "-")
-    return [=](uint64_t Dot) { return L(Dot) - R(Dot); };
+    return [=](DotExpr Dot) { return L(Dot) - R(Dot); };
   if (Op == "<")
-    return [=](uint64_t Dot) { return L(Dot) < R(Dot); };
+    return [=](DotExpr Dot) { return L(Dot) < R(Dot); };
   if (Op == ">")
-    return [=](uint64_t Dot) { return L(Dot) > R(Dot); };
+    return [=](DotExpr Dot) { return L(Dot) > R(Dot); };
   if (Op == ">=")
-    return [=](uint64_t Dot) { return L(Dot) >= R(Dot); };
+    return [=](DotExpr Dot) { return L(Dot) >= R(Dot); };
   if (Op == "<=")
-    return [=](uint64_t Dot) { return L(Dot) <= R(Dot); };
+    return [=](DotExpr Dot) { return L(Dot) <= R(Dot); };
   if (Op == "==")
-    return [=](uint64_t Dot) { return L(Dot) == R(Dot); };
+    return [=](DotExpr Dot) { return L(Dot) == R(Dot); };
   if (Op == "!=")
-    return [=](uint64_t Dot) { return L(Dot) != R(Dot); };
+    return [=](DotExpr Dot) { return L(Dot) != R(Dot); };
   if (Op == "&")
-    return [=](uint64_t Dot) { return L(Dot) & R(Dot); };
+    return [=](DotExpr Dot) { return L(Dot) & R(Dot); };
   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);