[lld] Make ALIGN work with -r in linker scripts

[kettenis]

Summary

Make ALIGN work in linker scripts used with the -r option. This works in GNU ld (ld.bfd) and is used to generate the "random gap" object for linking the OpenBSD kernel.

[ruiu]

LGTM

[jhenderson]

test/ELF/linkerscript/align.s

45

Nit: modificator -> modifier or expression

[grimar]

test/ELF/linkerscript/align.s

51

This script has no differences from the script right above on lines 35-41.
Hence you do not need it. And actually, you do not use it.

[kettenis]

test/ELF/linkerscript/align.s

45

What can I say; just copy and pasted it from the existing example. Want me to cange that one too?

51

Right. I'll remove that one and change the command slightly such that it doesn't overwrite the output of the previous test.

[jhenderson]

test/ELF/linkerscript/align.s

45

Yes, please. "Modificator" isn't a word.

[kettenis]

New diff that fixes the regression test.

[grimar]

LGTM

[kettenis]

Would one of you be so kind to commit this for me?

ELF/LinkerScript.cpp

void LinkerScript::adjustSectionsBeforeSorting() {
   // the previous sections. Only a few flags are needed to keep the impact low.
   uint64_t Flags = SHF_ALLOC;
 
   for (BaseCommand *&Cmd : SectionCommands) {
     auto *Sec = dyn_cast<OutputSection>(Cmd);
     if (!Sec)
       continue;
 
+    // Handle align (e.g. ".foo : ALIGN(16) { ... }").
+    if (Sec->AlignExpr)
+      Sec->Alignment =
+          std::max<uint32_t>(Sec->Alignment, Sec->AlignExpr().getValue());
+
     // A live output section means that some input section was added to it. It
     // might have been removed (if it was empty synthetic section), but we at
     // least know the flags.
     if (Sec->Live)
       Flags = Sec->Flags;
 
     // We do not want to keep any special flags for output section
     // in case it is empty.
for (BaseCommand *Base : SectionCommands) {
     if (auto *Sec = dyn_cast<OutputSection>(Base)) {
       if (!Sec->LMARegionName.empty()) {
         if (MemoryRegion *M = MemoryRegions.lookup(Sec->LMARegionName))
           Sec->LMARegion = M;
         else
           error("memory region '" + Sec->LMARegionName + "' not declared");
       }
       Sec->MemRegion = findMemoryRegion(Sec);
-      // Handle align (e.g. ".foo : ALIGN(16) { ... }").
-      if (Sec->AlignExpr)
-        Sec->Alignment =
-            std::max<uint32_t>(Sec->Alignment, Sec->AlignExpr().getValue());
     }
   }
 
   // If output section command doesn't specify any segments,
   // and we haven't previously assigned any section to segment,
   // then we simply assign section to the very first load segment.
   // Below is an example of such linker script:
   // PHDRS { seg PT_LOAD; }

test/ELF/linkerscript/align.s

 # RUN:  . = 0x10000;                       \
 # RUN:  .aaa : { *(.aaa) }                 \
 # RUN:  .bbb : ALIGN(4096) { *(.bbb) }     \
 # RUN:  .ccc : ALIGN(4096 * 4) { *(.ccc) } \
 # RUN: }" > %t2.script
 # RUN: ld.lld -o %t2 --script %t2.script %t
 # RUN: llvm-objdump -section-headers %t2 | FileCheck %s
 
+## Check output sections ALIGN modificator with -r
+# RUN: echo "SECTIONS {                    \
+# RUN:  . = 0x10000;                       \
+# RUN:  .aaa : { *(.aaa) }                 \
+# RUN:  .bbb : ALIGN(4096) { *(.bbb) }     \
+# RUN:  .ccc : ALIGN(4096 * 4) { *(.ccc) } \
+# RUN: }" > %t6.script
+# RUN: ld.lld -r -o %t2 --script %t2.script %t
+# RUN: llvm-readelf -s %t2 | FileCheck -check-prefix ALIGN %s
+
+# ALIGN:      Section Headers:
+# ALIGN-NEXT: Name Type     Address          Off    Size   ES Flg Lk Inf Al
+# ALIGN-NEXT:      NULL     0000000000000000 000000 000000 00
+# ALIGN-NEXT: .aaa PROGBITS 0000000000000000 000040 000008 00   A  0   0   1
+# ALIGN-NEXT: .bbb PROGBITS 0000000000000000 001000 000008 00   A  0   0  4096
+# ALIGN-NEXT: .ccc PROGBITS 0000000000000000 004000 000008 00   A  0   0  16384
+
 ## Check use of variables in align expressions:
 # RUN: echo "VAR = 0x1000;                                  \
 # RUN: __code_base__ = 0x10000;                             \
 # RUN: SECTIONS {                                           \
 # RUN:  . = __code_base__;                                  \
 # RUN:  .aaa : { *(.aaa) }                                  \
 # RUN:  .bbb : ALIGN(VAR) { *(.bbb) }                       \
 # RUN:  . = ALIGN(., VAR * 4);                              \