[ELF] Use late evaluation for ALIGN in expression

[phosek]

Summary

While the following expression is handled fine:

PROVIDE_HIDDEN(newsym = oldsym + address);

The following expression triggers an error because the expression
is evaluated as absolute:

PROVIDE_HIDDEN(newsym = ALIGN(oldsym, CONSTANT(MAXPAGESIZE)) + address);

To avoid this error, we use late evaluation for ALIGN by making the
alignment an attribute of the expression itself.

[ruiu]

LGTM

ELF/LinkerScript.h

44

Can you rename this Alignment? (For member variables, I think we use that name.)

Also = 1.

ELF/LinkerScript.h

 class OutputSectionFactory;
 class InputSectionBase;
 class SectionBase;
 
 struct ExprValue {
   SectionBase *Sec;
   uint64_t Val;
   bool ForceAbsolute;
+  uint64_t Align;
 
+  ExprValue(SectionBase *Sec, bool ForceAbsolute, uint64_t Val, uint64_t Align)
+      : Sec(Sec), Val(Val), ForceAbsolute(ForceAbsolute), Align(Align) {}
   ExprValue(SectionBase *Sec, bool ForceAbsolute, uint64_t Val)
-      : Sec(Sec), Val(Val), ForceAbsolute(ForceAbsolute) {}
+      : Sec(Sec), Val(Val), ForceAbsolute(ForceAbsolute), Align(1) {}
   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;
   uint64_t getSecAddr() const;
 };
 
 // This represents an expression in the linker script.

ELF/LinkerScript.cpp

 using namespace lld;
 using namespace lld::elf;
 
 LinkerScript *elf::Script;
 
 uint64_t ExprValue::getValue() const {
   if (Sec) {
     if (Sec->getOutputSection())
-      return Sec->getOffset(Val) + Sec->getOutputSection()->Addr;
+      return alignTo(Sec->getOffset(Val) + Sec->getOutputSection()->Addr,
+                     Align);
     error("unable to evaluate expression: input section " + Sec->Name +
           " has no output section assigned");
   }
-  return Val;
+  return alignTo(Val, Align);
 }
 
 uint64_t ExprValue::getSecAddr() const {
   if (Sec)
     return Sec->getOffset(0) + Sec->getOutputSection()->Addr;
   return 0;
 }
 
void LinkerScript::assignSymbol(SymbolAssignment *Cmd, bool InSec) {
 
   auto *Sym = cast<DefinedRegular>(Cmd->Sym);
   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;
+      Sym->Value = alignTo(V.Val, V.Align);
     else
       Sym->Value = V.getValue();
   }
 }
 
 static SymbolBody *findSymbol(StringRef S) {
   switch (Config->EKind) {
   case ELF32LEKind:

ELF/ScriptParser.cpp

Expr ScriptParser::readPrimary() {
   if (Tok == "ALIGN") {
     expect("(");
     Expr E = readExpr();
     if (consume(")"))
       return [=] { return alignTo(Script->getDot(), E().getValue()); };
     expect(",");
     Expr E2 = readExpr();
     expect(")");
-    return [=] { return alignTo(E().getValue(), E2().getValue()); };
+    return [=] {
+      ExprValue V = E();
+      V.Align = E2().getValue();
+      return V;
+    };
   }
   if (Tok == "ALIGNOF") {
     StringRef Name = readParenLiteral();
     return [=] { return Script->getOutputSection(Location, Name)->Alignment; };
   }
   if (Tok == "ASSERT")
     return readAssertExpr();
   if (Tok == "CONSTANT") {

test/ELF/linkerscript/align.s

 # RUN: llvm-objdump -t %t3 | FileCheck -check-prefix SYMBOLS %s
 
 # SYMBOLS-LABEL: SYMBOL TABLE:
 # SYMBOLS-NEXT: 0000000000000000         *UND*           00000000
 # SYMBOLS-NEXT: 0000000000014008         .text           00000000 _start
 # SYMBOLS-NEXT: 0000000000010000         *ABS*           00000000 __code_base__
 # SYMBOLS-NEXT: 0000000000001000         *ABS*           00000000 VAR
 # SYMBOLS-NEXT: 0000000000011000         .bbb            00000000 __start_bbb
-# SYMBOLS-NEXT: 0000000000012000         *ABS*           00000000 __end_bbb
+# SYMBOLS-NEXT: 0000000000012000         .bbb            00000000 __end_bbb
 
 .global _start
 _start:
  nop
 
 .section .aaa, "a"
 .quad 0
 
 .section .bbb, "a"
 .quad 0
 
 .section .ccc, "a"
 .quad 0

test/ELF/linkerscript/symbol-reserved.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 # RUN: echo "PROVIDE_HIDDEN(newsym = __ehdr_start + 5);" > %t.script
 # RUN: ld.lld -o %t1 %t.script %t
 # RUN: llvm-objdump -t %t1 | FileCheck %s
 
 # CHECK: 0000000000200005 .text 00000000 .hidden newsym
 
 # RUN: ld.lld -o %t1.so %t.script %t -shared
 # RUN: llvm-objdump -t %t1.so | FileCheck --check-prefix=SHARED %s
 
 # SHARED: 0000000000000005 .dynsym 00000000 .hidden newsym
 
+# RUN: echo "PROVIDE_HIDDEN(newsym = ALIGN(__ehdr_start, CONSTANT(MAXPAGESIZE)) + 5);" > %t.script
+# RUN: ld.lld -o %t1 %t.script %t
+# RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=ALIGNED %s
+
+# ALIGNED: 0000000000200005 .text 00000000 .hidden newsym
+
 .global _start
 _start:
   lea newsym(%rip),%rax