Make lld actually compatible with gold in terms of filler handling.

[ruiu]

Summary

GNU gold handles output section fillers as 32-bit values.
This patch makes LLD compatible with that behavior.

[ruiu]

• Update comments.

[grimar]

Not relative to this patch, but relative to filler functionality:

I still have consern about how OutputSection<ELFT>::writeTo() works with filler() method.
Currently it just fills buffer with filler and places sections on top. Filler is usually NOP, nop on x86 can be 0x90,
so that works fine for that case.
But imagine someone decides to use 2 byte version of NOP. For x86 it is (according to wiki https://en.wikipedia.org/wiki/NOP) 0x0F 0x1F.
Lets say we have 2 sections, each one is one byte (0xFF for example) and has aligment of 4. So filler is 0x0F1F0F1F

Current implementation will produce:

1. Step 1 - place filler to buffer: 0x0F 0x1F 0x0F 0x1F 0x0F 0x1F 0x0F 0x1F
2. Step 2 - place sections on top: 0xFF 0x1F 0x0F 0x1F 0xFF 0x1F 0x0F 0x1F

At the same time gold/bfd as far I remember starts placing filler in between of sections,
so they would produce:
0xFF 0x0F 0x1F 0x0F 0x1F 0xFF 0x0F 0x1F 0x0F 0x1F

That looks more correct as NOP is 0x0F 0x1F and not the reverse.

[ruiu]

If you have an easy fix, please send it to review, but discussing it in a different review thread is probably not a good idea.

[• rafael]

LGTM

ELF/LinkerScript.cpp

while (!Error && !skip("}")) {
     }
     setError("unknown command " + peek());
   }
   Cmd->Phdrs = readOutputSectionPhdrs();
   Cmd->Filler = readOutputSectionFiller();
   return Cmd;
 }
 
+// Read "=<number>" where <number> is a octal/decimal/hexadecimal number.
+// https://sourceware.org/binutils/docs/ld/Output-Section-Fill.html
+//
+// ld.gold is not fully compatible with ld.bfd. ld.bfd handles
+// hexstrings as a blob of arbitrary size, while ld.gold handles them
+// as 32-bit big-endian values. We will do the same as ld.gold does
+// because it's simpler than what ld.bfd does.
 std::vector<uint8_t> ScriptParser::readOutputSectionFiller() {
-  StringRef Tok = peek();
-  if (!Tok.startswith("="))
+  if (!peek().startswith("="))
     return {};
-  next();
 
-  // Read a hexstring of arbitrary length.
-  if (Tok.startswith("=0x"))
-    return parseHex(Tok.substr(3));
-
-  // Read a decimal or octal value as a big-endian 32 bit value.
-  // Why do this? I don't know, but that's what gold does.
+  StringRef Tok = next();
   uint32_t V;
   if (Tok.substr(1).getAsInteger(0, V)) {
     setError("invalid filler expression: " + Tok);
     return {};
   }
-  return { uint8_t(V >> 24), uint8_t(V >> 16), uint8_t(V >> 8), uint8_t(V) };
+  return {uint8_t(V >> 24), uint8_t(V >> 16), uint8_t(V >> 8), uint8_t(V)};
 }
 
 SymbolAssignment *ScriptParser::readProvide(bool Hidden) {
   expect("(");
   SymbolAssignment *Cmd = readAssignment(next());
   Cmd->Provide = true;
   Cmd->Hidden = Hidden;
   expect(")");

test/ELF/linkerscript/linkerscript-sections-padding.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 
 ## Check that padding value works:
-# RUN: echo "SECTIONS { .mysec : { *(.mysec*) } =0x112233445566778899 }" > %t.script
+# RUN: echo "SECTIONS { .mysec : { *(.mysec*) } =0x1122 }" > %t.script
 # RUN: ld.lld -o %t.out --script %t.script %t
 # RUN: llvm-objdump -s %t.out | FileCheck -check-prefix=YES %s
-# YES: 0120  66223344 55667788 99112233 44556677
+# YES: 0120  66001122 00001122 00001122 00001122
 
 ## Confirming that address was correct:
-# RUN: echo "SECTIONS { .mysec : { *(.mysec*) } =0x998877665544332211 }" > %t.script
+# RUN: echo "SECTIONS { .mysec : { *(.mysec*) } =0x99887766 }" > %t.script
 # RUN: ld.lld -o %t.out --script %t.script %t
 # RUN: llvm-objdump -s %t.out | FileCheck -check-prefix=YES2 %s
-# YES2: 0120  66887766 55443322 11998877 66554433
+# YES2: 0120  66887766 99887766 99887766 99887766
 
 ## Default padding value is 0x00:
 # RUN: echo "SECTIONS { .mysec : { *(.mysec*) } }" > %t.script
 # RUN: ld.lld -o %t.out --script %t.script %t
 # RUN: llvm-objdump -s %t.out | FileCheck -check-prefix=NO %s
 # NO: 0120  66000000 00000000 00000000 00000000
 
 ## Decimal value.
 # RUN: echo "SECTIONS { .mysec : { *(.mysec*) } =777 }" > %t.script
 # RUN: ld.lld -o %t.out --script %t.script %t
 # RUN: llvm-objdump -s %t.out | FileCheck -check-prefix=DEC %s
 # DEC: 0120  66000309 00000309 00000309 00000309
 
 ## Invalid hex value:
 # RUN: echo "SECTIONS { .mysec : { *(.mysec*) } =0x99XX }" > %t.script
 # RUN: not ld.lld -o %t.out --script %t.script %t 2>&1 \
 # RUN:   | FileCheck --check-prefix=ERR2 %s
-# ERR2: not a hexadecimal value: XX
+# ERR2: invalid filler expression: =0x99XX
 
 .section        .mysec.1,"a"
 .align  16
 .byte   0x66
 
 .section        .mysec.2,"a"
 .align  16
 .byte   0x66
 
 .globl _start
 _start:
  nop