[ELF] Assign file offsets of non-SHF_ALLOC after SHF_ALLOC and set sh_addr=0 to non-SHF_ALLOC

[MaskRay]

Summary

• GNU ld places non-SHF_ALLOC sections after SHF_ALLOC sections. This has the advantage that the file offsets of a non-SHF_ALLOC cannot be contained in a PT_LOAD. This patch matches the behavior.
• For non-SHF_ALLOC non-orphan sections, GNU ld may assign non-zero sh_addr and treat them similar to SHT_NOBITS (not advance location counter). This is an alternative approach to what we have done in D85100. By placing non-SHF_ALLOC sections at the end, we can drop special cases in createSection and findOrphanPos added by D85100.
  
  Different from GNU ld, we set sh_addr to 0 for non-SHF_ALLOC sections. 0 arguably is better because non-SHF_ALLOC sections don't appear in the memory image.

ELF spec says:

sh_addr - If the section will appear in the memory image of a process, this
member gives the address at which the section's first byte should
reside. Otherwise, the member contains 0.

D85100 appeared to take a detour. If we take a combined view on D85100 and this
patch, the overall complexity slightly increases (one more 3-line loop) and
compatibility with GNU ld improves.

The behavior we don't want to match is the special treatment of .symtab
.shstrtab .strtab: they can be matched in LLD but not in GNU ld.

[psmith]

Just to check I understand.

In D85100 we moved non SHF_ALLOC orphans after all other SHF_ALLOC sections so that they didn't affect address assignment of SHF_ALLOC sections. Now we don't move the SHF_ALLOC section positions but instead we do not move the location counter, and also move their file offset after all SHF_ALLOC sections so that they have no affect on addresses of SHF_ALLOC sections and cannot be part of a PT_LOAD section.

This is related to pr47094.

I don't have any objections, in the general case I think compatibility with BFD is worthwhile.

lld/ELF/LinkerScript.cpp

856

May be worth writing the condition the other way around as it is the most common case. Only a weak preference though.

if (sec->flags & SHF_ALLOC) {
...
} else {
  // Non-SHF_ALLOC OutputSections start at address 0
  ...
}

925

I think it's worth adding a comment. Suggest something like:
// Non-SHF_ALLOC sections do not affect the addresses of other OutputSections as they are not part of the process image.

lld/ELF/Writer.cpp

1236–1237

I guess we've removed this as it is not strictly necessary any more?

[jhenderson]

I think this looks like it makes sense. Having the section header table out of order is a little weird to me, but also not illegal (indeed, I've used it on a few occasions to do crazy things before).

I've added @edd who reported pr47094, who might have further insight.

lld/test/ELF/linkerscript/sections-nonalloc.s

22–24

Just to confirm - these three sections appear here in the section header table (before data2 and .text), because they are being placed near the other non-alloc sections, due to orphan section handling, I presume?

[MaskRay]

Just to check I understand.

In D85100 we moved non SHF_ALLOC orphans after all other SHF_ALLOC sections so that they didn't affect address assignment of SHF_ALLOC sections. Now we don't move the SHF_ALLOC section positions but instead we do not move the location counter, and also move their file offset after all SHF_ALLOC sections so that they have no affect on addresses of SHF_ALLOC sections and cannot be part of a PT_LOAD section.

Yes

lld/test/ELF/linkerscript/sections-nonalloc.s

22–24

Yes.In GNU ld, the three sections are special: they can't be matched by output section descriptions.

Other than orphan section placement, our approach assigning section addresses is identical to GNU ld after this patch.

[MaskRay]

Address comments

[psmith]

Thanks for the update. I'm happy with the changes. I've tentatively approved, James/Edd please shout if you have any objections?

[MaskRay]

lld/ELF/LinkerScript.cpp

925

Adopted. Thanks

lld/ELF/Writer.cpp

1236–1237

Correct. Non-SHF_ALLOC sections affected address ranges so we moved orphan sections to the end to avoid their side effect. Now non-SHF_ALLOC orphan sections do not affect SHF_ALLOC.

[grimar]

I have nothing useful to add. Happy if others are happy, the change looks fine to me I think.

[MaskRay]

@edd @jhenderson 🤡

[jhenderson]

@edd is now off for the week, and didn't get a chance to look as far as I know, so LGTM'ing myself. We can always fix any unexpected fallout post-commit if needed.

[edd]

Apologies for not keeping on top of this while I was off work. FTR, looks good. Thanks for taking the time to look at it.

lld/ELF/LinkerScript.cpp

if (auto *sec = dyn_cast<OutputSection>(base))
       if (sec->name == name)
         return sec;
   return nullptr;
 }
 
 static OutputSection *createSection(InputSectionBase *isec,
                                     StringRef outsecName) {
   OutputSection *sec = script->createOutputSection(outsecName, "<internal>");
-  if (!(isec->flags & SHF_ALLOC))
-    sec->addrExpr = [] { return 0; };
   sec->recordSection(isec);
   return sec;
 }
 
 static OutputSection *
 addInputSec(StringMap<TinyPtrVector<OutputSection *>> &map,
             InputSectionBase *isec, StringRef outsecName) {
   // Sections with SHT_GROUP or SHF_GROUP attributes reach here only when the -r
static OutputSection *findFirstSection(PhdrEntry *load) {
   return nullptr;
 }
 
 // This function assigns offsets to input sections and an output section
 // for a single sections command (e.g. ".text { *(.text); }").
 void LinkerScript::assignOffsets(OutputSection *sec) {
   const bool sameMemRegion = ctx->memRegion == sec->memRegion;
   const bool prevLMARegionIsDefault = ctx->lmaRegion == nullptr;
+  const uint64_t savedDot = dot;
   ctx->memRegion = sec->memRegion;
   ctx->lmaRegion = sec->lmaRegion;
+
+  if (sec->flags & SHF_ALLOC) {
     if (ctx->memRegion)
       dot = ctx->memRegion->curPos;
-
     if (sec->addrExpr)
       setDot(sec->addrExpr, sec->location, false);
 
     // If the address of the section has been moved forward by an explicit
     // expression so that it now starts past the current curPos of the enclosing
     // region, we need to expand the current region to account for the space
     // between the previous section, if any, and the start of this section.
     if (ctx->memRegion && ctx->memRegion->curPos < dot)
       expandMemoryRegion(ctx->memRegion, dot - ctx->memRegion->curPos,
                          ctx->memRegion->name, sec->name);
+  } else {
+    // Non-SHF_ALLOC sections have zero addresses.
+    dot = 0;
+  }
 
   switchTo(sec);
 
   // ctx->lmaOffset is LMA minus VMA. If LMA is explicitly specified via AT() or
   // AT>, recompute ctx->lmaOffset; otherwise, if both previous/current LMA
   // region is the default, and the two sections are in the same memory region,
   // reuse previous lmaOffset; otherwise, reset lmaOffset to 0. This emulates
   // heuristics described in
for (BaseCommand *base : sec->sectionCommands) {
     }
 
     // Handle a single input section description command.
     // It calculates and assigns the offsets for each section and also
     // updates the output section size.
     for (InputSection *sec : cast<InputSectionDescription>(base)->sections)
       output(sec);
   }
+
+  // Non-SHF_ALLOC sections do not affect the addresses of other OutputSections
+  // as they are not part of the process image.
+  if (!(sec->flags & SHF_ALLOC))
+    dot = savedDot;
 }
 
 static bool isDiscardable(OutputSection &sec) {
   if (sec.name == "/DISCARD/")
     return true;
 
   // We do not remove empty sections that are explicitly
   // assigned to any segment.

lld/ELF/Writer.cpp

static bool shouldSkip(BaseCommand *cmd) {
   return false;
 }
 
 // We want to place orphan sections so that they share as much
 // characteristics with their neighbors as possible. For example, if
 // both are rw, or both are tls.
 static std::vector<BaseCommand *>::iterator
 findOrphanPos(std::vector<BaseCommand *>::iterator b,
               std::vector<BaseCommand *>::iterator e) {
-  // OutputSections without the SHF_ALLOC flag are not part of the memory image
-  // and their addresses usually don't matter. Place any orphan sections without
-  // the SHF_ALLOC flag at the end so that these do not affect the address
-  // assignment of OutputSections with the SHF_ALLOC flag.
   OutputSection *sec = cast<OutputSection>(*e);
-  if (!(sec->flags & SHF_ALLOC))
-    return e;
 
   // Find the first element that has as close a rank as possible.
   auto i = std::max_element(b, e, [=](BaseCommand *a, BaseCommand *b) {
     return getRankProximity(sec, a) < getRankProximity(sec, b);
   });
   if (i == e)
     return e;
 
template <class ELFT> void Writer<ELFT>::assignFileOffsets() {
   off = setFileOffset(Out::programHeaders, off);
 
   PhdrEntry *lastRX = nullptr;
   for (Partition &part : partitions)
     for (PhdrEntry *p : part.phdrs)
       if (p->p_type == PT_LOAD && (p->p_flags & PF_X))
         lastRX = p;
 
+  // Layout SHF_ALLOC sections before non-SHF_ALLOC sections. A non-SHF_ALLOC
+  // will not occupy file offsets contained by a PT_LOAD.
   for (OutputSection *sec : outputSections) {
+    if (!(sec->flags & SHF_ALLOC))
+      continue;
     off = setFileOffset(sec, off);
 
     // If this is a last section of the last executable segment and that
     // segment is the last loadable segment, align the offset of the
     // following section to avoid loading non-segments parts of the file.
     if (config->zSeparate != SeparateSegmentKind::None && lastRX &&
         lastRX->lastSec == sec)
       off = alignTo(off, config->commonPageSize);
   }
+  for (OutputSection *sec : outputSections)
+    if (!(sec->flags & SHF_ALLOC))
+      off = setFileOffset(sec, off);
 
   sectionHeaderOff = alignTo(off, config->wordsize);
   fileSize = sectionHeaderOff + (outputSections.size() + 1) * sizeof(Elf_Shdr);
 
   // Our logic assumes that sections have rising VA within the same segment.
   // With use of linker scripts it is possible to violate this rule and get file
   // offset overlaps or overflows. That should never happen with a valid script
   // which does not move the location counter backwards and usually scripts do

lld/test/ELF/linkerscript/memory-region-alignment.test

 # REQUIRES: x86
-# RUN: echo '.section .foo,"a"; .quad 0; .section .zed,"M",@progbits,1; .byte 0' > %t.s
+# RUN: echo '.section .foo,"a"; .quad 0; .section .zed,"aM",@progbits,1; .byte 0' > %t.s
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %t.s -o %t.o
 
 MEMORY {
   ram (rwx): org = 0x1, len = 96K
 }
 
 SECTIONS {
   .foo : ALIGN(8) {

 # CHECK-NEXT:   Type: SHT_PROGBITS
 # CHECK-NEXT:   Flags [
 # CHECK-NEXT:     SHF_ALLOC
 # CHECK-NEXT:   ]
 # CHECK-NEXT:   Address: 0x8
 # CHECK-NEXT:   Offset: 0x1008
 # CHECK-NEXT:   Size: 8
 
-# CHECK:        Name: .text
+# CHECK:        Name: .zed
 # CHECK-NEXT:   Type: SHT_PROGBITS
 # CHECK-NEXT:   Flags [
 # CHECK-NEXT:     SHF_ALLOC
-# CHECK-NEXT:     SHF_EXECINSTR
+# CHECK-NEXT:     SHF_MERGE
 # CHECK-NEXT:   ]
 # CHECK-NEXT:   Address: 0x10
 # CHECK-NEXT:   Offset: 0x1010
-# CHECK-NEXT:   Size: 0
+# CHECK-NEXT:   Size: 1
 
-# CHECK:        Name: .zed
+# CHECK:        Name: .text
 # CHECK-NEXT:   Type: SHT_PROGBITS
 # CHECK-NEXT:   Flags [
-# CHECK-NEXT:     SHF_MERGE
+# CHECK-NEXT:     SHF_ALLOC
+# CHECK-NEXT:     SHF_EXECINSTR
 # CHECK-NEXT:   ]
-# CHECK-NEXT:   Address: 0x10
-# CHECK-NEXT:   Offset: 0x1010
-# CHECK-NEXT:   Size: 1
+# CHECK-NEXT:   Address: 0x14
+# CHECK-NEXT:   Offset: 0x1014
+# CHECK-NEXT:   Size: 0
 
 # CHECK:        Name: .comment
 # CHECK-NEXT:   Type: SHT_PROGBITS
 # CHECK-NEXT:   Flags [
 # CHECK-NEXT:     SHF_MERGE
 # CHECK-NEXT:     SHF_STRINGS
 # CHECK-NEXT:   ]
 # CHECK-NEXT:   Address: 0x0
-# CHECK-NEXT:   Offset: 0x1011
+# CHECK-NEXT:   Offset: 0x1014
 # CHECK-NEXT:   Size: 8

lld/test/ELF/linkerscript/sections-nonalloc.s

+# REQUIRES: x86
+# RUN: split-file %s %t
+# RUN: llvm-mc -filetype=obj -triple=x86_64 %t/main.s -o %t.o
+
+## Non-SHF_ALLOC sections are placed after all SHF_ALLOC sections. They will
+## thus not be contained in a PT_LOAD segment. data2 has a PT_LOAD segment,
+## even if it is preceded by a non-SHF_ALLOC section. Non-SHF_ALLOC orphan
+## sections have zero addresses.
+## NOTE: GNU ld assigns non-zero addresses to non-SHF_ALLOC non-orphan sections.
+# RUN: ld.lld -T %t/a.lds %t.o -o %ta
+# RUN: llvm-readelf -S -l %ta | FileCheck %s
+
+# CHECK:       [Nr] Name      Type     Address          Off    Size   ES Flg Lk
+# CHECK-NEXT:  [ 0]           NULL     0000000000000000 000000 000000 00      0
+# CHECK-NEXT:  [ 1] .bss      NOBITS   0000000000000000 001000 000001 00  WA  0
+# CHECK-NEXT:  [ 2] data1     PROGBITS 0000000000000001 001001 000001 00  WA  0
+# CHECK-NEXT:  [ 3] data3     PROGBITS 0000000000000002 001002 000001 00  WA  0
+# CHECK-NEXT:  [ 4] other1    PROGBITS 0000000000000000 001008 000001 00      0
+# CHECK-NEXT:  [ 5] other2    PROGBITS 0000000000000000 001010 000001 00      0
+## Orphan placement places other3, .symtab, .shstrtab and .strtab after other2.
+# CHECK-NEXT:  [ 6] other3    PROGBITS 0000000000000000 001020 000001 00      0
+# CHECK-NEXT:  [ 7] .symtab   SYMTAB   0000000000000000 001028 000030 18      9
+# CHECK-NEXT:  [ 8] .shstrtab STRTAB   0000000000000000 001058 00004d 00      0
+# CHECK-NEXT:  [ 9] .strtab   STRTAB   0000000000000000 0010a5 000008 00      0
+# CHECK-NEXT:  [10] data2     PROGBITS 0000000000000003 001003 000001 00  WA  0
+# CHECK-NEXT:  [11] .text     PROGBITS 0000000000000004 001004 000001 00  AX  0
+
+# CHECK:       Type       Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align
+# CHECK-NEXT:  LOAD       0x001000 0x0000000000000000 0x0000000000000000 0x000004 0x000004 RW  0x1000
+# CHECK-NEXT:  LOAD       0x001004 0x0000000000000004 0x0000000000000004 0x000001 0x000001 R E 0x1000
+# CHECK-NEXT:  GNU_STACK  0x000000 0x0000000000000000 0x0000000000000000 0x000000 0x000000 RW  0
+
+# RUN: ld.lld -T %t/b.lds %t.o -o %tb
+# RUN: llvm-readelf -S -l %tb | FileCheck %s --check-prefix=CHECK1
+
+# CHECK1:      [Nr] Name      Type     Address          Off    Size   ES Flg Lk
+# CHECK1-NEXT: [ 0]           NULL     0000000000000000 000000 000000 00      0
+# CHECK1-NEXT: [ 1] .text     PROGBITS 00000000000000b0 0000b0 000001 00  AX  0
+# CHECK1-NEXT: [ 2] .bss      NOBITS   00000000000000b1 0000b1 000001 00  WA  0
+# CHECK1-NEXT: [ 3] data1     PROGBITS 00000000000000b2 0000b2 000001 00  WA  0
+# CHECK1-NEXT: [ 4] data3     PROGBITS 00000000000000b3 0000b3 000001 00  WA  0
+# CHECK1-NEXT: [ 5] other1    PROGBITS 0000000000000000 0000b8 000001 00      0
+# CHECK1-NEXT: [ 6] other2    PROGBITS 0000000000000000 0000c0 000001 00      0
+# CHECK1-NEXT: [ 7] other3    PROGBITS 0000000000000000 0000d0 000001 00      0
+# CHECK1-NEXT: [ 8] .symtab   SYMTAB   0000000000000000 0000d8 000030 18     10
+# CHECK1-NEXT: [ 9] .shstrtab STRTAB   0000000000000000 000108 00004d 00      0
+# CHECK1-NEXT: [10] .strtab   STRTAB   0000000000000000 000155 000008 00      0
+# CHECK1-NEXT: [11] data2     PROGBITS 00000000000000b4 0000b4 000001 00  WA  0
+# CHECK1:      Type       Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align
+# CHECK1-NEXT: LOAD       0x000000 0x0000000000000000 0x0000000000000000 0x0000b5 0x0000b5 RWE 0x1000
+# CHECK1-NEXT: 0x60000000 0x0000b8 0x0000000000000000 0x0000000000000000 0x000009 0x000001     0x8
+
+#--- a.lds
+SECTIONS {
+  .bss : { *(.bss) }
+  data1 : { *(data1) }
+  other1 : { *(other1) }
+  other2 : { *(other2) }
+  data2 : { *(data2) }
+  .text : { *(.text) }
+  /DISCARD/ : { *(.comment) }
+}
+
+#--- b.lds
+PHDRS {
+  text PT_LOAD FILEHDR PHDRS;
+  foo 0x60000000 FLAGS (0);
+}
+SECTIONS {
+  . = SIZEOF_HEADERS;
+  .text : { *(.text) } : text
+  .bss : { *(.bss) } : text
+  data1 : { *(data1) } : text
+  other1 : { *(other1) } : foo
+  other2 : { *(other2) } : foo
+  data2 : { *(data1) } : text
+  /DISCARD/ : { *(.comment) }
+}
+
+#--- main.s
+.globl _start
+_start: nop
+.section data1,"aw"; .byte 0
+.section data2,"aw"; .byte 0
+.section data3,"aw"; .byte 0
+.bss; .byte 0
+
+.section other1; .p2align 2; .byte 0
+.section other2; .p2align 3; .byte 0
+.section other3; .p2align 4; .byte 0

lld/test/ELF/linkerscript/sections.s

 # SEC-DEFAULT: 2 .data         00000020 {{[0-9a-f]*}} DATA
 # SEC-DEFAULT: 3 other         00000003 {{[0-9a-f]*}} DATA
 # SEC-DEFAULT: 4 .bss          00000002 {{[0-9a-f]*}} BSS
 # SEC-DEFAULT: 5 .comment      00000008 {{[0-9a-f]*}}
 # SEC-DEFAULT: 6 .symtab       00000030 {{[0-9a-f]*}}
 # SEC-DEFAULT: 7 .shstrtab     0000003b {{[0-9a-f]*}}
 # SEC-DEFAULT: 8 .strtab       00000008 {{[0-9a-f]*}}
 
-## Sections are placed in the order specified by the linker script. .data has
-## a PT_LOAD segment, even if it is preceded by a non-alloc section. To
-## allow this, place non-alloc orphan sections at the end and advance
-## location counters for non-alloc non-orphan sections.
-# RUN: echo "SECTIONS { \
-# RUN:          .bss : { *(.bss) } \
-# RUN:          other : { *(other) } \
-# RUN:          .shstrtab : { *(.shstrtab) } \
-# RUN:          .symtab : { *(.symtab) } \
-# RUN:          .strtab : { *(.strtab) } \
-# RUN:          .data : { *(.data) } \
-# RUN:          .text : { *(.text) } }" > %t3.lds
-# RUN: ld.lld -o %t3a -T %t3.lds %t
-# RUN: llvm-readelf -S -l %t3a | FileCheck --check-prefix=SEC-ORDER %s
-# RUN: ld.lld -o %t3b -T %t3.lds --unique %t
-# RUN: llvm-readelf -S -l %t3b | FileCheck --check-prefix=SEC-ORDER %s
-
-# SEC-ORDER:       [Nr] Name      Type     Address          Off    Size   ES Flg
-# SEC-ORDER:       [ 0]           NULL     0000000000000000 000000 000000 00
-# SEC-ORDER-NEXT:  [ 1] .bss      NOBITS   0000000000000000 001000 000002 00  WA
-# SEC-ORDER-NEXT:  [ 2] other     PROGBITS 0000000000000002 001002 000003 00  WA
-# SEC-ORDER-NEXT:  [ 3] .shstrtab STRTAB   0000000000000005 001005 00003b 00
-# SEC-ORDER-NEXT:  [ 4] .symtab   SYMTAB   0000000000000040 001040 000030 18
-# SEC-ORDER-NEXT:  [ 5] .strtab   STRTAB   0000000000000070 001070 000008 00
-# SEC-ORDER-NEXT:  [ 6] .data     PROGBITS 0000000000000078 001078 000020 00  WA
-# SEC-ORDER-NEXT:  [ 7] .text     PROGBITS 0000000000000098 001098 00000e 00  AX
-# SEC-ORDER-NEXT:  [ 8] .comment  PROGBITS 0000000000000000 0010a6 000008 01  MS
-
-# SEC-ORDER:        Type      Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align
-# SEC-ORDER-NEXT:   LOAD      0x001000 0x0000000000000000 0x0000000000000000 0x000098 0x000098 RW  0x1000
-# SEC-ORDER-NEXT:   LOAD      0x001098 0x0000000000000098 0x0000000000000098 0x00000e 0x00000e R E 0x1000
-# SEC-ORDER-NEXT:   GNU_STACK 0x000000 0x0000000000000000 0x0000000000000000 0x000000 0x000000 RW  0
-
 # .text and .data have swapped names but proper sizes and types.
 # RUN: echo "SECTIONS { \
 # RUN:          .data : { *(.text) } \
 # RUN:          .text : { *(.data) } }" > %t.script
 # RUN: ld.lld -o %t4 --script %t.script %t
 # RUN: llvm-objdump --section-headers %t4 | \
 # RUN:   FileCheck -check-prefix=SEC-SWAP-NAMES %s
 

 # RUN:          other : { *(other) } }' > %t5.lds
 # RUN: ld.lld -o %t5 -T %t5.lds %t
 # RUN: llvm-readelf -S -l %t5 | FileCheck --check-prefix=SEP-BY-NONALLOC %s
 
 # SEP-BY-NONALLOC:      [Nr] Name      Type     Address          Off    Size   ES Flg
 # SEP-BY-NONALLOC:      [ 1] .text     PROGBITS 0000000000000000 001000 00000e 00  AX
 # SEP-BY-NONALLOC-NEXT: [ 2] .data     PROGBITS 000000000000000e 00100e 000020 00  WA
 # SEP-BY-NONALLOC-NEXT: [ 3] .bss      NOBITS   000000000000002e 00102e 000002 00  WA
-# SEP-BY-NONALLOC-NEXT: [ 4] .comment  PROGBITS 0000000000000030 00102e 000008 01  MS
-# SEP-BY-NONALLOC-NEXT: [ 5] other     PROGBITS 0000000000000038 001038 000003 00  WA
+# SEP-BY-NONALLOC-NEXT: [ 4] .comment  PROGBITS 0000000000000000 001033 000008 01  MS
+# SEP-BY-NONALLOC:      [ 8] other     PROGBITS 0000000000000030 001030 000003 00  WA
 
 # SEP-BY-NONALLOC:      Type      Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align
 # SEP-BY-NONALLOC-NEXT: LOAD      0x001000 0x0000000000000000 0x0000000000000000 0x00000e 0x00000e R E 0x1000
-# SEP-BY-NONALLOC-NEXT: LOAD      0x00100e 0x000000000000000e 0x000000000000000e 0x00002d 0x00002d RW  0x1000
+# SEP-BY-NONALLOC-NEXT: LOAD      0x00100e 0x000000000000000e 0x000000000000000e 0x000025 0x000025 RW  0x1000
 # SEP-BY-NONALLOC-NEXT: GNU_STACK 0x000000 0x0000000000000000 0x0000000000000000 0x000000 0x000000 RW  0
 
 # Input section pattern contains additional semicolon.
 # Case found in linux kernel script. Check we are able to parse it.
 # RUN: echo "SECTIONS { .text : { ;;*(.text);;S = 0;; } }" > %t.script
 # RUN: ld.lld -o /dev/null --script %t.script %t
 
 .globl _start

lld/test/ELF/linkerscript/symbols-non-alloc.test

 # REQUIRES: x86
 ## The address of a symbol assignment after a non-SHF_ALLOC section equals the
-## end address of the section.
+## end address of the last SHF_ALLOC section.
 
 # RUN: echo '.section .nonalloc,""; .quad 0' \
 # RUN:   | llvm-mc -filetype=obj -triple=x86_64-unknown-linux - -o %t
 # RUN: ld.lld -o %t2 --script %s %t
 # RUN: llvm-objdump --section-headers -t %t2 | FileCheck %s
 
 # CHECK: Sections:
-# CHECK:  .nonalloc     00000008 0000000000000120
+# CHECK:  .text         00000000 0000000000000120
+# CHECK:  .nonalloc     00000008 0000000000000000
 
 # CHECK: SYMBOL TABLE:
-# CHECK:  0000000000000128 g .nonalloc 0000000000000000 Sym
+# CHECK:  0000000000000120 g .nonalloc 0000000000000000 Sym
 
 SECTIONS {
   . = SIZEOF_HEADERS;
   .text : { *(.text) }
   .nonalloc : { *(.nonalloc) }
   Sym = .;
 }