[ELF] Allow output section data commands to take expressions

[meadori]

Summary

The current implementation of the output section data store commands
can only handle integer literals, but it should really handle arbitrary
expressions [1]. This commit fixes that.

[1] https://sourceware.org/binutils/docs-2.27/ld/Output-Section-Data.html#Output-Section-Data

[meadori]

Any comments on this one?

[ruiu]

ELF/LinkerScript.cpp

868

You want to pass 0 instead of Dot. When this function is called, Dot doesn't have any meaningful value.

[meadori]

Address review feedback.

[ruiu]

LGTM. Thanks!

[grimar]

test/ELF/linkerscript/data-commands.s

49

It's a bit wierd.
First 3 lines are equal with test above I think ?

# RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux %s -o %tmips64be
# RUN: ld.lld --script %t.script %tmips64be -o %t2
# RUN: llvm-objdump -s %t2 | FileCheck %s --check-prefix=BE

And you share "BE" with it, its very confusing. I think what you wanted to do is use test above and
just add checks:

# RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux %s -o %tmips64be
# RUN: ld.lld --script %t.script %tmips64be -o %t2
# RUN: llvm-objdump -s %t2 | FileCheck %s --check-prefix=BE
# BE:      Contents of section .foo:
# BE-NEXT:   ff11ff11 22ff1122 3344ff11 22334455
# BE-NEXT:   667788
# BE:      Contents of section .bar:
# BE-NEXT:   ff12ff11 22ff1122 3346ff11 22334455
# BE-NEXT:   667788

[meadori]

@grimar , you are right. The tests lines should be reworked. Thinko on my part. Fixed in r289278. Thanks for pointing this out!

ELF/LinkerScript.h

struct AssertCommand : BaseCommand {
 
   static bool classof(const BaseCommand *C);
 
   Expr Expression;
 };
 
 // Represents BYTE(), SHORT(), LONG(), or QUAD().
 struct BytesDataCommand : BaseCommand {
-  BytesDataCommand(uint64_t Data, unsigned Size)
-      : BaseCommand(BytesDataKind), Data(Data), Size(Size) {}
+  BytesDataCommand(Expr E, unsigned Size)
+      : BaseCommand(BytesDataKind), Expression(E), Size(Size) {}
 
   static bool classof(const BaseCommand *C);
 
-  uint64_t Data;
+  Expr Expression;
   unsigned Offset;
   unsigned Size;
 };
 
 struct PhdrsCommand {
   StringRef Name;
   unsigned Type;
   bool HasFilehdr;

ELF/LinkerScript.cpp

 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->Data, Data->Size);
+      writeInt<ELFT>(Buf + Data->Offset, Data->Expression(Dot), Data->Size);
 }
 
 template <class ELFT> bool LinkerScript<ELFT>::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;
int Size = StringSwitch<unsigned>(Tok)
                  .Case("BYTE", 1)
                  .Case("SHORT", 2)
                  .Case("LONG", 4)
                  .Case("QUAD", 8)
                  .Default(-1);
   if (Size == -1)
     return nullptr;
 
-  expect("(");
-  uint64_t Val = 0;
-  StringRef S = next();
-  if (!readInteger(S, Val))
-    setError("unexpected value: " + S);
-  expect(")");
-  return new BytesDataCommand(Val, Size);
+  return new BytesDataCommand(readParenExpr(), Size);
 }
 
 StringRef ScriptParser::readParenLiteral() {
   expect("(");
   StringRef Tok = next();
   expect(")");
   return Tok;
 }

test/ELF/linkerscript/data-commands.s

 # REQUIRES: x86,mips
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: echo "SECTIONS                \
 # RUN:  {                            \
 # RUN:    .foo : {                   \
 # RUN:      *(.foo.1)                \
 # RUN:      BYTE(0x11)               \
 # RUN:      *(.foo.2)                \
 # RUN:      SHORT(0x1122)            \
 # RUN:      *(.foo.3)                \
 # RUN:      LONG(0x11223344)         \
 # RUN:      *(.foo.4)                \
 # RUN:      QUAD(0x1122334455667788) \
 # RUN:    }                          \
+# RUN:    .bar : {                   \
+# RUN:      *(.bar.1)                \
+# RUN:      BYTE(a + 1)              \
+# RUN:      *(.bar.2)                \
+# RUN:      SHORT(b)                 \
+# RUN:      *(.bar.3)                \
+# RUN:      LONG(c + 2)              \
+# RUN:      *(.bar.4)                \
+# RUN:      QUAD(d)                  \
+# RUN:    }                          \
 # RUN:  }" > %t.script
-# RUN: ld.lld -o %t --script %t.script %t.o
+# RUN: ld.lld -o %t %t.o --script %t.script
 # RUN: llvm-objdump -s %t | FileCheck %s
 
 # CHECK:      Contents of section .foo:
 # CHECK-NEXT:   ff11ff22 11ff4433 2211ff88 77665544
 # CHECK-NEXT:   332211
 
+# CHECK:      Contents of section .bar:
+# CHECK-NEXT:   ff12ff22 11ff4633 2211ff88 77665544
+# CHECK-NEXT:   332211
+
 # RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux %s -o %tmips64be
 # RUN: ld.lld --script %t.script %tmips64be -o %t2
 # RUN: llvm-objdump -s %t2 | FileCheck %s --check-prefix=BE
 # BE:      Contents of section .foo:
 # BE-NEXT:   ff11ff11 22ff1122 3344ff11 22334455
 # BE-NEXT:   667788
 
+# RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux %s -o %tmips64be
+# RUN: ld.lld --script %t.script %tmips64be -o %t2
+# RUN: llvm-objdump -s %t2 | FileCheck %s --check-prefix=BE
+# BE:      Contents of section .bar:
+# BE-NEXT:   ff12ff11 22ff1122 3346ff11 22334455
+# BE-NEXT:   667788
+
+.global a
+a = 0x11
+
+.global b
+b = 0x1122
+
+.global c
+c = 0x11223344
+
+.global d
+d = 0x1122334455667788
+
 .section .foo.1, "a"
  .byte 0xFF
 
 .section .foo.2, "a"
  .byte 0xFF
 
 .section .foo.3, "a"
  .byte 0xFF
 
 .section .foo.4, "a"
  .byte 0xFF
+
+.section .bar.1, "a"
+ .byte 0xFF
+
+.section .bar.2, "a"
+ .byte 0xFF
+
+.section .bar.3, "a"
+ .byte 0xFF
+
+.section .bar.4, "a"
+ .byte 0xFF