Change our linker script expr representation

[• rafael]

Summary

This fixes pr32031 by representing the expressions results as a SectionBase and offset. This allows us to use an input section directly instead of getting lost trying to compute an offset in an outputsection when not all the information is available yet.

This also creates a struct to represent the *value* of and expression, allowing the expression itself to be a simple typedef. I think this is easier to read and will make it easier to extend the expression computation to handle more complicated cases.

[ruiu]

I'm not a huge fan of operator overloading. That is undeniably convenient and useful in some situations, but for this file this is probably a bit too much. Do you mind if I ask you to do this without operator overloading?

[• rafael]

Rebased.

[• rafael]

Rebased again.

Given that this fixes a bug, opens the way to fix more bugs with regards to what is or is not absolute, and the only disagreement is on the use of operator overloading, I would like to request that

• We check this in
• I will try to fix more cases and add diagnostics on invalid expressions.
• We then discuss alternative proposals to operator overloading.

[• rafael]

getting phab to send email

[• rafael]

Avoid operator overloading by renaming the functions.

[ruiu]

LGTM

[• espindola]

298079

[• espindola]

298079

ELF/LinkerScript.h

 class SymbolBody;
 class InputSectionBase;
 class InputSection;
 class OutputSection;
 class OutputSectionFactory;
 class InputSectionBase;
 class SectionBase;
 
+struct ExprValue {
+  SectionBase *Sec;
+  uint64_t Val;
+  bool ForceAbsolute;
+
+  ExprValue(SectionBase *Sec, bool ForceAbsolute, uint64_t Val)
+      : Sec(Sec), Val(Val), ForceAbsolute(ForceAbsolute) {}
+  ExprValue(SectionBase *Sec, uint64_t Val) : ExprValue(Sec, false, Val) {}
+  ExprValue(uint64_t Val) : ExprValue(nullptr, Val) {}
+  bool isAbsolute() const { return ForceAbsolute || Sec == nullptr; }
+  uint64_t getValue() const;
+};
+
 // This represents an expression in the linker script.
 // ScriptParser::readExpr reads an expression and returns an Expr.
-// Later, we evaluate the expression by calling the function
-// with the value of special context variable ".".
-struct Expr {
-  std::function<uint64_t()> Val;
-  std::function<bool()> IsAbsolute;
-
-  // If expression is section-relative the function below is used
-  // to get the output section pointer.
-  std::function<SectionBase *()> Section;
-
-  uint64_t operator()() const { return Val(); }
-  operator bool() const { return (bool)Val; }
-
-  Expr(std::function<uint64_t()> Val, std::function<bool()> IsAbsolute,
-       std::function<SectionBase *()> Section)
-      : Val(Val), IsAbsolute(IsAbsolute), Section(Section) {}
-  template <typename T>
-  Expr(T V) : Expr(V, [] { return true; }, [] { return nullptr; }) {}
-  Expr() : Expr(nullptr) {}
-};
+// Later, we evaluate the expression by calling the function.
+typedef std::function<ExprValue()> Expr;
 
 // Parses a linker script. Calling this function updates
 // Config and ScriptConfig.
 void readLinkerScript(MemoryBufferRef MB);
 
 // Parses a version script.
 void readVersionScript(MemoryBufferRef MB);
 
struct MemoryRegion {
   std::string Name;
   uint64_t Origin;
   uint64_t Length;
   uint64_t Offset;
   uint32_t Flags;
   uint32_t NegFlags;
 };
 
-
 // ScriptConfiguration holds linker script parse results.
 struct ScriptConfiguration {
   // Used to assign addresses to sections.
   std::vector<std::unique_ptr<BaseCommand>> Commands;
 
   // Used to assign sections to headers.
   std::vector<PhdrsCommand> PhdrsCommands;
 
protected:
   MemoryRegion *findMemoryRegion(OutputSectionCommand *Cmd, OutputSection *Sec);
 
   void switchTo(OutputSection *Sec);
   void flush();
   void output(InputSection *Sec);
   void process(BaseCommand &Base);
 
   OutputSection *Aether;
+  bool ErrorOnMissingSection = false;
 
   // "ScriptConfig" is a bit too long, so define a short name for it.
   ScriptConfiguration &Opt = *ScriptConfig;
 
   uint64_t Dot;
   uint64_t ThreadBssOffset = 0;
 
   std::function<uint64_t()> LMAOffset;
   OutputSection *CurOutSec = nullptr;
   MemoryRegion *CurMemRegion = nullptr;
 
   llvm::DenseSet<OutputSection *> AlreadyOutputOS;
   llvm::DenseSet<InputSectionBase *> AlreadyOutputIS;
 
 public:
   bool hasPhdrsCommands() { return !Opt.PhdrsCommands.empty(); }
   uint64_t getDot() { return Dot; }
   OutputSection *getOutputSection(const Twine &Loc, StringRef S);
   uint64_t getOutputSectionSize(StringRef S);
   void discard(ArrayRef<InputSectionBase *> V);
 
-  virtual uint64_t getSymbolValue(const Twine &Loc, StringRef S) = 0;
+  virtual ExprValue getSymbolValue(const Twine &Loc, StringRef S) = 0;
   virtual bool isDefined(StringRef S) = 0;
-  virtual bool isAbsolute(StringRef S) = 0;
-  virtual OutputSection *getSymbolSection(StringRef S) = 0;
 
   std::vector<OutputSection *> *OutputSections;
   void addOrphanSections(OutputSectionFactory &Factory);
   void removeEmptyCommands();
   void adjustSectionsBeforeSorting();
   void adjustSectionsAfterSorting();
 
   std::vector<PhdrEntry> createPhdrs();

 public:
   LinkerScript();
   ~LinkerScript();
 
   void writeDataBytes(StringRef Name, uint8_t *Buf);
   void addSymbol(SymbolAssignment *Cmd);
   void processCommands(OutputSectionFactory &Factory);
 
-  uint64_t getSymbolValue(const Twine &Loc, StringRef S) override;
+  ExprValue getSymbolValue(const Twine &Loc, StringRef S) override;
   bool isDefined(StringRef S) override;
-  bool isAbsolute(StringRef S) override;
-  OutputSection *getSymbolSection(StringRef S) override;
 };
 
 // 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;
 
 extern LinkerScriptBase *ScriptBase;
 
 } // end namespace elf
 } // end namespace lld
 
 #endif // LLD_ELF_LINKER_SCRIPT_H

ELF/LinkerScript.cpp

 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 using namespace llvm::support::endian;
 using namespace lld;
 using namespace lld::elf;
 
+uint64_t ExprValue::getValue() const {
+  if (Sec)
+    return Sec->getOffset(Val) + Sec->getOutputSection()->Addr;
+  return Val;
+}
+
+static ExprValue add(ExprValue A, ExprValue B) {
+  return {A.Sec, A.ForceAbsolute, A.Val + B.getValue()};
+}
+static ExprValue sub(ExprValue A, ExprValue B) {
+  return {A.Sec, A.Val - B.getValue()};
+}
+static ExprValue mul(ExprValue A, ExprValue B) {
+  return A.getValue() * B.getValue();
+}
+static ExprValue div(ExprValue A, ExprValue B) {
+  if (uint64_t BV = B.getValue())
+    return A.getValue() / BV;
+  error("division by zero");
+  return 0;
+}
+static ExprValue leftShift(ExprValue A, ExprValue B) {
+  return A.getValue() << B.getValue();
+}
+static ExprValue rightShift(ExprValue A, ExprValue B) {
+  return A.getValue() >> B.getValue();
+}
+static ExprValue lessThan(ExprValue A, ExprValue B) {
+  return A.getValue() < B.getValue();
+}
+static ExprValue greaterThan(ExprValue A, ExprValue B) {
+  return A.getValue() > B.getValue();
+}
+static ExprValue greaterThanOrEqual(ExprValue A, ExprValue B) {
+  return A.getValue() >= B.getValue();
+}
+static ExprValue lessThanOrEqual(ExprValue A, ExprValue B) {
+  return A.getValue() <= B.getValue();
+}
+static ExprValue equal(ExprValue A, ExprValue B) {
+  return A.getValue() == B.getValue();
+}
+static ExprValue notEqual(ExprValue A, ExprValue B) {
+  return A.getValue() != B.getValue();
+}
+static ExprValue bitAnd(ExprValue A, ExprValue B) {
+  return A.getValue() & B.getValue();
+}
+static ExprValue bitOr(ExprValue A, ExprValue B) {
+  return A.getValue() | B.getValue();
+}
+static ExprValue bitNot(ExprValue A) { return ~A.getValue(); }
+static ExprValue minus(ExprValue A) { return -A.getValue(); }
+
 LinkerScriptBase *elf::ScriptBase;
 ScriptConfiguration *elf::ScriptConfig;
 
 template <class ELFT> static SymbolBody *addRegular(SymbolAssignment *Cmd) {
   Symbol *Sym;
   uint8_t Visibility = Cmd->Hidden ? STV_HIDDEN : STV_DEFAULT;
   std::tie(Sym, std::ignore) = Symtab<ELFT>::X->insert(
       Cmd->Name, /*Type*/ 0, Visibility, /*CanOmitFromDynSym*/ false,
       /*File*/ nullptr);
   Sym->Binding = STB_GLOBAL;
-  SectionBase *Sec =
-      Cmd->Expression.IsAbsolute() ? nullptr : Cmd->Expression.Section();
+  ExprValue Value = Cmd->Expression();
+  SectionBase *Sec = Value.isAbsolute() ? nullptr : Value.Sec;
   replaceBody<DefinedRegular>(Sym, Cmd->Name, /*IsLocal=*/false, Visibility,
                               STT_NOTYPE, 0, 0, Sec, nullptr);
   return Sym->body();
 }
 
 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;
 }
 
 OutputSection *LinkerScriptBase::getOutputSection(const Twine &Loc,
                                                   StringRef Name) {
   static OutputSection FakeSec("", 0, 0);
 
   for (OutputSection *Sec : *OutputSections)
     if (Sec->Name == Name)
       return Sec;
 
+  if (ErrorOnMissingSection)
     error(Loc + ": undefined section " + Name);
   return &FakeSec;
 }
 
 // This function is essentially the same as getOutputSection(Name)->Size,
 // but it won't print out an error message if a given section is not found.
 //
 // Linker script does not create an output section if its content is empty.
 // We want to allow SIZEOF(.foo) where .foo is a section which happened to
 // be empty. That is why this function is different from getOutputSection().
 uint64_t LinkerScriptBase::getOutputSectionSize(StringRef Name) {
   for (OutputSection *Sec : *OutputSections)
     if (Sec->Name == Name)
       return Sec->Size;
   return 0;
 }
 
 void LinkerScriptBase::setDot(Expr E, const Twine &Loc, bool InSec) {
-  uint64_t Val = E();
+  uint64_t Val = E().getValue();
   if (Val < Dot) {
     if (InSec)
       error(Loc + ": unable to move location counter backward for: " +
             CurOutSec->Name);
     else
       error(Loc + ": unable to move location counter backward");
   }
   Dot = Val;
if (Cmd->Name == ".") {
     setDot(Cmd->Expression, Cmd->Location, InSec);
     return;
   }
 
   if (!Cmd->Sym)
     return;
 
   auto *Sym = cast<DefinedRegular>(Cmd->Sym);
-  Sym->Value = Cmd->Expression();
-  if (!Cmd->Expression.IsAbsolute()) {
-    Sym->Section = Cmd->Expression.Section();
-    if (auto *Sec = dyn_cast_or_null<OutputSection>(Sym->Section))
-      if (Sec->Flags & SHF_ALLOC)
-        Sym->Value -= Sec->Addr;
+  ExprValue V = Cmd->Expression();
+  if (V.isAbsolute()) {
+    Sym->Value = V.getValue();
+  } else {
+    Sym->Section = V.Sec;
+    if (Sym->Section->Flags & SHF_ALLOC)
+      Sym->Value = V.Val;
+    else
+      Sym->Value = V.getValue();
   }
 }
 
 template <class ELFT>
 void LinkerScript<ELFT>::addSymbol(SymbolAssignment *Cmd) {
   if (Cmd->Name == ".")
     return;
 
if (auto *Cmd = dyn_cast<OutputSectionCommand>(Base1.get())) {
       for (const std::unique_ptr<BaseCommand> &Base : Cmd->Commands)
         if (auto *OutCmd = dyn_cast<SymbolAssignment>(Base.get()))
           addSymbol(OutCmd);
 
       // Handle subalign (e.g. ".foo : SUBALIGN(32) { ... }"). If subalign
       // is given, input sections are aligned to that value, whether the
       // given value is larger or smaller than the original section alignment.
       if (Cmd->SubalignExpr) {
-        uint32_t Subalign = Cmd->SubalignExpr();
+        uint32_t Subalign = Cmd->SubalignExpr().getValue();
         for (InputSectionBase *S : V)
           S->Alignment = Subalign;
       }
 
       // Add input sections to an output section.
       for (InputSectionBase *S : V)
         Factory.addInputSec(S, Cmd->Name);
     }
void LinkerScriptBase::assignOffsets(OutputSectionCommand *Cmd) {
   if (!Sec)
     return;
 
   if (Cmd->AddrExpr && Sec->Flags & SHF_ALLOC)
     setDot(Cmd->AddrExpr, Cmd->Location);
 
   if (Cmd->LMAExpr) {
     uint64_t D = Dot;
-    LMAOffset = [=] { return Cmd->LMAExpr() - D; };
+    LMAOffset = [=] { return Cmd->LMAExpr().getValue() - D; };
   }
 
   // Handle align (e.g. ".foo : ALIGN(16) { ... }").
   if (Cmd->AlignExpr)
-    Sec->updateAlignment(Cmd->AlignExpr());
+    Sec->updateAlignment(Cmd->AlignExpr().getValue());
 
   // Try and find an appropriate memory region to assign offsets in.
   CurMemRegion = findMemoryRegion(Cmd, Sec);
   if (CurMemRegion)
     Dot = CurMemRegion->Offset;
   switchTo(Sec);
 
   // Find the last section output location. We will output orphan sections
for (const std::unique_ptr<BaseCommand> &Base : Opt.Commands) {
     else if (auto *Cmd = dyn_cast<AssertCommand>(Base.get()))
       Cmd->Expression();
   }
 }
 
 void LinkerScriptBase::assignAddresses(std::vector<PhdrEntry> &Phdrs) {
   // Assign addresses as instructed by linker script SECTIONS sub-commands.
   Dot = 0;
+  ErrorOnMissingSection = true;
   switchTo(Aether);
 
   for (const std::unique_ptr<BaseCommand> &Base : Opt.Commands) {
     if (auto *Cmd = dyn_cast<SymbolAssignment>(Base.get())) {
       assignSymbol(Cmd);
       continue;
     }
 
for (const PhdrsCommand &Cmd : Opt.PhdrsCommands) {
     PhdrEntry &Phdr = Ret.back();
 
     if (Cmd.HasFilehdr)
       Phdr.add(Out::ElfHeader);
     if (Cmd.HasPhdrs)
       Phdr.add(Out::ProgramHeaders);
 
     if (Cmd.LMAExpr) {
-      Phdr.p_paddr = Cmd.LMAExpr();
+      Phdr.p_paddr = Cmd.LMAExpr().getValue();
       Phdr.HasLMA = true;
     }
   }
 
   // Add output sections to program headers.
   for (OutputSection *Sec : *OutputSections) {
     if (!(Sec->Flags & SHF_ALLOC))
       break;

 void LinkerScript<ELFT>::writeDataBytes(StringRef Name, uint8_t *Buf) {
   int I = getSectionIndex(Name);
   if (I == INT_MAX)
     return;
 
   auto *Cmd = dyn_cast<OutputSectionCommand>(Opt.Commands[I].get());
   for (const std::unique_ptr<BaseCommand> &Base : Cmd->Commands)
     if (auto *Data = dyn_cast<BytesDataCommand>(Base.get()))
-      writeInt<ELFT>(Buf + Data->Offset, Data->Expression(), Data->Size);
+      writeInt<ELFT>(Buf + Data->Offset, Data->Expression().getValue(),
+                     Data->Size);
 }
 
 bool LinkerScriptBase::hasLMA(StringRef Name) {
   for (const std::unique_ptr<BaseCommand> &Base : Opt.Commands)
     if (auto *Cmd = dyn_cast<OutputSectionCommand>(Base.get()))
       if (Cmd->LMAExpr && Cmd->Name == Name)
         return true;
   return false;
 }
 
 // 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.
 int LinkerScriptBase::getSectionIndex(StringRef Name) {
   for (int I = 0, E = Opt.Commands.size(); I != E; ++I)
     if (auto *Cmd = dyn_cast<OutputSectionCommand>(Opt.Commands[I].get()))
       if (Cmd->Name == Name)
         return I;
   return INT_MAX;
 }
 
 template <class ELFT>
-uint64_t LinkerScript<ELFT>::getSymbolValue(const Twine &Loc, StringRef S) {
+ExprValue LinkerScript<ELFT>::getSymbolValue(const Twine &Loc, StringRef S) {
   if (S == ".")
-    return Dot;
-  if (SymbolBody *B = Symtab<ELFT>::X->find(S))
-    return B->getVA<ELFT>();
+    return {CurOutSec, Dot - CurOutSec->Addr};
+  if (SymbolBody *B = Symtab<ELFT>::X->find(S)) {
+    if (auto *D = dyn_cast<DefinedRegular>(B))
+      return {D->Section, D->Value};
+    auto *C = cast<DefinedCommon>(B);
+    return {In<ELFT>::Common, C->Offset};
+  }
   error(Loc + ": symbol not found: " + S);
   return 0;
 }
 
 template <class ELFT> bool LinkerScript<ELFT>::isDefined(StringRef S) {
   return Symtab<ELFT>::X->find(S) != nullptr;
 }
 
-template <class ELFT> bool LinkerScript<ELFT>::isAbsolute(StringRef S) {
-  if (S == ".")
-    return false;
-  SymbolBody *Sym = Symtab<ELFT>::X->find(S);
-  auto *DR = dyn_cast_or_null<DefinedRegular>(Sym);
-  return DR && !DR->Section;
-}
-
-// Gets section symbol belongs to. Symbol "." doesn't belong to any
-// specific section but isn't absolute at the same time, so we try
-// to find suitable section for it as well.
-template <class ELFT>
-OutputSection *LinkerScript<ELFT>::getSymbolSection(StringRef S) {
-  if (SymbolBody *Sym = Symtab<ELFT>::X->find(S))
-    return Sym->getOutputSection();
-  return CurOutSec;
-}
-
 // Returns indices of ELF headers containing specific section, identified
 // by Name. Each index is a zero based number of ELF header listed within
 // PHDRS {} script block.
 std::vector<size_t> LinkerScriptBase::getPhdrIndices(StringRef SectionName) {
   for (const std::unique_ptr<BaseCommand> &Base : Opt.Commands) {
     auto *Cmd = dyn_cast<OutputSectionCommand>(Base.get());
     if (!Cmd || Cmd->Name != SectionName)
       continue;
do {
       else if (Tok == "PHDRS")
         PhdrCmd.HasPhdrs = true;
       else if (Tok == "AT")
         PhdrCmd.LMAExpr = readParenExpr();
       else if (Tok == "FLAGS") {
         expect("(");
         // Passing 0 for the value of dot is a bit of a hack. It means that
         // we accept expressions like ".|1".
-        PhdrCmd.Flags = readExpr()();
+        PhdrCmd.Flags = readExpr()().getValue();
         expect(")");
       } else
         setError("unexpected header attribute: " + Tok);
     } while (!Error);
   }
 }
 
 void ScriptParser::readSearchDir() {

 
 Expr ScriptParser::readAssert() {
   expect("(");
   Expr E = readExpr();
   expect(",");
   StringRef Msg = unquote(next());
   expect(")");
   return [=] {
-    if (!E())
+    if (!E().getValue())
       error(Msg);
     return ScriptBase->getDot();
   };
 }
 
 // Reads a FILL(expr) command. We handle the FILL command as an
 // alias for =fillexp section attribute, which is different from
 // what GNU linkers do.

 }
 
 SymbolAssignment *ScriptParser::readAssignment(StringRef Name) {
   StringRef Op = next();
   assert(Op == "=" || Op == "+=");
   Expr E = readExpr();
   if (Op == "+=") {
     std::string Loc = getCurrentLocation();
-    E = [=] { return ScriptBase->getSymbolValue(Loc, Name) + E(); };
+    E = [=] { return add(ScriptBase->getSymbolValue(Loc, Name), E()); };
   }
   return new SymbolAssignment(Name, E, getCurrentLocation());
 }
 
 // This is an operator-precedence parser to parse a linker
 // script expression.
 Expr ScriptParser::readExpr() {
   // Our lexer is context-aware. Set the in-expression bit so that
   // they apply different tokenization rules.
   bool Orig = InExpr;
   InExpr = true;
   Expr E = readExpr1(readPrimary(), 0);
   InExpr = Orig;
   return E;
 }
 
 static Expr combine(StringRef Op, Expr L, Expr R) {
-  auto IsAbs = [=] { return L.IsAbsolute() && R.IsAbsolute(); };
-  auto GetOutSec = [=] {
-    SectionBase *S = L.Section();
-    return S ? S : R.Section();
-  };
-
   if (Op == "*")
-    return [=] { return L() * R(); };
+    return [=] { return mul(L(), R()); };
   if (Op == "/") {
-    return [=]() -> uint64_t {
-      uint64_t RHS = R();
-      if (RHS == 0) {
-        error("division by zero");
-        return 0;
-      }
-      return L() / RHS;
-    };
+    return [=] { return div(L(), R()); };
   }
   if (Op == "+")
-    return {[=] { return L() + R(); }, IsAbs, GetOutSec};
+    return [=] { return add(L(), R()); };
   if (Op == "-")
-    return {[=] { return L() - R(); }, IsAbs, GetOutSec};
+    return [=] { return sub(L(), R()); };
   if (Op == "<<")
-    return [=] { return L() << R(); };
+    return [=] { return leftShift(L(), R()); };
   if (Op == ">>")
-    return [=] { return L() >> R(); };
+    return [=] { return rightShift(L(), R()); };
   if (Op == "<")
-    return [=] { return L() < R(); };
+    return [=] { return lessThan(L(), R()); };
   if (Op == ">")
-    return [=] { return L() > R(); };
+    return [=] { return greaterThan(L(), R()); };
   if (Op == ">=")
-    return [=] { return L() >= R(); };
+    return [=] { return greaterThanOrEqual(L(), R()); };
   if (Op == "<=")
-    return [=] { return L() <= R(); };
+    return [=] { return lessThanOrEqual(L(), R()); };
   if (Op == "==")
-    return [=] { return L() == R(); };
+    return [=] { return ::equal(L(), R()); };
   if (Op == "!=")
-    return [=] { return L() != R(); };
+    return [=] { return notEqual(L(), R()); };
   if (Op == "&")
-    return [=] { return L() & R(); };
+    return [=] { return bitAnd(L(), R()); };
   if (Op == "|")
-    return [=] { return L() | R(); };
+    return [=] { return bitOr(L(), R()); };
   llvm_unreachable("invalid operator");
 }
 
 // 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) {
   while (!atEOF() && !Error) {
     // Read an operator and an expression.
Expr ScriptParser::readPrimary() {
   if (peek() == "(")
     return readParenExpr();
 
   StringRef Tok = next();
   std::string Location = getCurrentLocation();
 
   if (Tok == "~") {
     Expr E = readPrimary();
-    return [=] { return ~E(); };
+    return [=] { return bitNot(E()); };
   }
   if (Tok == "-") {
     Expr E = readPrimary();
-    return [=] { return -E(); };
+    return [=] { return minus(E()); };
   }
 
   // Built-in functions are parsed here.
   // https://sourceware.org/binutils/docs/ld/Builtin-Functions.html.
   if (Tok == "ABSOLUTE") {
-    Expr E = readParenExpr();
-    E.IsAbsolute = [] { return true; };
-    return E;
+    Expr Inner = readParenExpr();
+    return [=] {
+      ExprValue I = Inner();
+      I.ForceAbsolute = true;
+      return I;
+    };
   }
   if (Tok == "ADDR") {
     StringRef Name = readParenLiteral();
-    return {[=] { return ScriptBase->getOutputSection(Location, Name)->Addr; },
-            [=] { return false; },
-            [=] { return ScriptBase->getOutputSection(Location, Name); }};
+    return [=]() -> ExprValue {
+      return {ScriptBase->getOutputSection(Location, Name), 0};
+    };
   }
   if (Tok == "LOADADDR") {
     StringRef Name = readParenLiteral();
     return
         [=] { return ScriptBase->getOutputSection(Location, Name)->getLMA(); };
   }
   if (Tok == "ASSERT")
     return readAssert();
   if (Tok == "ALIGN") {
     expect("(");
     Expr E = readExpr();
     if (consume(",")) {
       Expr E2 = readExpr();
       expect(")");
-      return [=] { return alignTo(E(), E2()); };
+      return [=] { return alignTo(E().getValue(), E2().getValue()); };
     }
     expect(")");
-    return [=] { return alignTo(ScriptBase->getDot(), E()); };
+    return [=] { return alignTo(ScriptBase->getDot(), E().getValue()); };
   }
   if (Tok == "CONSTANT") {
     StringRef Name = readParenLiteral();
     return [=] { return getConstant(Name); };
   }
   if (Tok == "DEFINED") {
     StringRef Name = readParenLiteral();
     return [=] { return ScriptBase->isDefined(Name) ? 1 : 0; };
   }
   if (Tok == "SEGMENT_START") {
     expect("(");
     skip();
     expect(",");
     Expr E = readExpr();
     expect(")");
     return [=] { return E(); };
   }
   if (Tok == "DATA_SEGMENT_ALIGN") {
     expect("(");
     Expr E = readExpr();
     expect(",");
     readExpr();
     expect(")");
-    return [=] { return alignTo(ScriptBase->getDot(), E()); };
+    return [=] { return alignTo(ScriptBase->getDot(), E().getValue()); };
   }
   if (Tok == "DATA_SEGMENT_END") {
     expect("(");
     expect(".");
     expect(")");
-    return []() { return ScriptBase->getDot(); };
+    return [] { return ScriptBase->getDot(); };
   }
   // 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("(");
     readExpr();
     expect(",");
     readExpr();
     expect(")");
-    return []() { return alignTo(ScriptBase->getDot(), Target->PageSize); };
+    return [] { return alignTo(ScriptBase->getDot(), Target->PageSize); };
   }
   if (Tok == "SIZEOF") {
     StringRef Name = readParenLiteral();
     return [=] { return ScriptBase->getOutputSectionSize(Name); };
   }
   if (Tok == "ALIGNOF") {
     StringRef Name = readParenLiteral();
     return
         [=] { return ScriptBase->getOutputSection(Location, Name)->Alignment; };
   }
   if (Tok == "SIZEOF_HEADERS")
     return [=] { return elf::getHeaderSize(); };
 
   // Tok is a literal number.
   uint64_t V;
   if (readInteger(Tok, V))
     return [=] { return V; };
 
   // Tok is a symbol name.
   if (Tok != "." && !isValidCIdentifier(Tok))
     setError("malformed number: " + Tok);
-  return {[=] { return ScriptBase->getSymbolValue(Location, Tok); },
-          [=] { return ScriptBase->isAbsolute(Tok); },
-          [=] { return ScriptBase->getSymbolSection(Tok); }};
+  return [=] { return ScriptBase->getSymbolValue(Location, Tok); };
 }
 
 Expr ScriptParser::readTernary(Expr Cond) {
   Expr L = readExpr();
   expect(":");
   Expr R = readExpr();
-  return [=] { return Cond() ? L() : R(); };
+  return [=] { return Cond().getValue() ? L() : R(); };
 }
 
 Expr ScriptParser::readParenExpr() {
   expect("(");
   Expr E = readExpr();
   expect(")");
   return E;
 }

test/ELF/linkerscript/obj-symbol-value.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
+# RUN: echo "SECTIONS { foo = bar; .bar : { *(.bar*) } }" > %t.script
+# RUN: ld.lld %t.o --script %t.script -o %t.so -shared
+# RUN: llvm-readobj -t %t.so | FileCheck %s
+
+# CHECK:     Symbol {
+# CHECK:      Name: bar
+# CHECK-NEXT: Value: 0x[[VAL:.*]]
+# CHECK:      Name: foo
+# CHECK-NEXT: Value: 0x[[VAL]]
+
+.section .bar.1, "a"
+.quad 0
+
+.section .bar.2, "a"
+.quad 0
+.global bar
+bar: