[ELF] - Linkerscript: implemented simple heuristic for placing orphan sections.

[grimar]

Summary

Previously we put orphans to the end. Patch implements simple heuristic instead.
Each orphan is placed after the last section in sequence with the same access
attributes.

Testcase is provided to show the behavior.
Currently it looks the same or very close to what ld do.

[ruiu]

What's the motivation behind it? I think our general stance to the user is "if you don't like our orphan section layout, you need to specify precise layout yourself."

[grimar]

In D23352#512203, @ruiu wrote:

What's the motivation behind it? I think our general stance to the user is "if you don't like our orphan section layout, you need to specify precise layout yourself."

I think that was that before. But as Davide mentioned "If FreeBSD can change his linker script, fine, great for them. But not everybody has the same luxury."
Basing on that we probably want to implement something very simple and short. This heuristics looks work equal to ld and it is just a single method, probably
it can meet the needs of users well.

I also think we can implement a warning, saying there are orphan sections found to force users to update their scripts in a soft way.

[evgeny777]

I think, the motivation is that listing all sections in linker script is not always a good idea. For example we have about dozen of linker scripts and more than hundred of projects which are linked using those scripts, so that single script is shared between several projects. The set of sections from project to project might be different, so without any heuristic I have to investigate all of them and modify scripts to cover all possible layouts. Needless to say, that serious amount of work may be required, so if heuristic can be implemented with a dozen lines of code then I'd like to have it as well.

[grimar]

• Rebased.

[evgeny777]

ELF/LinkerScript.cpp

222

I suggest not using Current here, because it is not needed outside of addOrphan. Let's minimize side effects:

OutputSectionBase<ELFT> *Orphan;
bool IsNew;
std::tie(Orphan, IsNew) = Facrory.Create(...);
// ...

[grimar]

• Addressed review comments
• Cosmetic changes

[grimar]

ELF/LinkerScript.cpp

222

Sounds reasonable.

[ruiu]

I imagine that if you want to implement a logic for orphan sections, you want to implement the same rule for the non-linker-script case. I'ts hard to review because there are many patches on the fly. I'm wondering how this change will relate to https://reviews.llvm.org/D23315.

[grimar]

In D23352#513092, @ruiu wrote:

I imagine that if you want to implement a logic for orphan sections, you want to implement the same rule for the non-linker-script case. I'ts hard to review because there are many patches on the fly. I'm wondering how this change will relate to https://reviews.llvm.org/D23315.

Sorry, but I don't understand the idea I think. Why we would want to implement the same rule as we have for non-script case ?
In non-script case there is no oprhans, sections just grouped together by attributes. When script is present, sections should be placed
in a order specified by script. That violates the non-scripted rule.
This patch places orphans to be in group with the sections with the same attributes. So here it is close to what non-scripted case do.
The only difference that script has a priority against any other rules and that is what expected I think.

I guess D23315 is no more actual, I am going to rebase and update this one soon.

[grimar]

• Rebased.

[grimar]

By the way with this change orphans section order in kernel is almost the same as ld does:
lld output:

Segment Sections...
 00     
 01     .interp 
 02     .interp .hash .dynsym .dynstr 
 03     .text 
 04     .rodata set_sysctl_set set_sysinit_set set_sysuninit_set set_modmetadata_set set_ah_chips set_ah_rfs set_kbddriver_set set_cons_set usb_host_id set_vt_drv_set set_sdt_providers_set set_sdt_probes_set set_sdt_argtypes_set set_kdb_dbbe_set set_ratectl_set set_crypto_set set_ieee80211_ioctl_getset set_ieee80211_ioctl_setset set_scanner_set set_videodriver_set set_scterm_set set_scrndr_set set_vga_set kern_conf .eh_frame 
 05     .dynamic .data .bss set_pcpu 
 06     .dynamic 
 07     .dynamic 
 08

ld output:

Segment Sections...
 00     
 01     .interp 
 02     .interp .hash .dynsym .dynstr .text .rodata set_sysctl_set set_sysinit_set set_sysuninit_set set_modmetadata_set set_ah_chips set_ah_rfs set_kbddriver_set set_cons_set usb_host_id set_vt_drv_set set_sdt_providers_set set_sdt_probes_set set_sdt_argtypes_set set_kdb_dbbe_set set_ratectl_set set_crypto_set set_ieee80211_ioctl_getset set_ieee80211_ioctl_setset set_scanner_set set_videodriver_set set_scterm_set set_scrndr_set set_vga_set kern_conf .eh_frame 
 03     .dynamic .got.plt .data set_pcpu .bss 
 04     .dynamic 
 05

Difference is that ld creates less segments, but that is unrelative to this patch.

[ruiu]

ELF/LinkerScript.cpp

45

Let's name this getPermissions as this is RWX permissions.

58

Orphan sections are a concept of input sections. I don't think we call output sections containing orphan sections as orphan sections. So let's name this OutSec.

64

Why do you have to use rbegin and rend?

69–85

This code is hard to understand. In short, what are you trying to do in this function?

[grimar]

ELF/LinkerScript.cpp

64

I am searching the last section with the same access attributes to place orphan right after. So I had to search from the end to start.

I`ve added notes for each piece of code below.

67

1. At first I search the last section with the attributes equal to atributes of orphan I am inserting.

74

2. If there is no section with the same attributes - I just add orphan to the end, also I create and add output section command either to the end.

77

3. I add orphan to the position I found above and take the name of the section which goes before the orphan. This name is required to find the proper position for new OutputSectionCommand.

85

Please see new notes above. That piece is:

4. Find the proper place for new OutputSectionCommand and add it. This position matches the position of orphan section added:

OutputSections content: Sec1 Sec2 Oprhan Sec4
ScriptConfig->Commands content: Cmd_Sec1 Cmd_Sec2 Cmd_Orphan Cmd_Sec4

[grimar]

• Addressed review comments.

ELF/LinkerScript.cpp

45

Done.

58

Done.

[ruiu]

ELF/LinkerScript.cpp

365

I think I understand what you are trying to do, but still it seems a bit too complicated. Isn't there any way to simplify?

[silvas]

Thanks for working on this George, this is really helpful for building the FreeBSD kernel. One comment inline.

FYI, Michael and I are also debugging why the bootloader doesn't like LLD produced binaries. Besides the issue addressed by this patch, so far we have identified two other issues (there are more, but these are the ones we've identified so far):

• __start_SECNAME/__stop_SECNAME are not exported in the dynamic symbol table. This is needed for the loader which looks up __start_set_modmetadata_set/__stop_set_modmetadata_set.

• LLD does not honor MAXPAGESIZE (needs to be 2M for amd64), this causes the kernel load address to get set far too low (at 4K, close to where the loader lives), which clobbers the loader's text / data structures when copying in the kernel :)

Hopefully it saves you some time!

ELF/LinkerScript.cpp

345

I think this also needs to check && !(S->getType() & SHT_NOBITS) so that we don't add a PROGBITS section into BSS.

E.g. with this patch applied I get this error during a FreeBSD kernel build:

BFD: stc5VrZP: section set_pcpu lma 0xffffffff81529d80 overlaps previous sections
BFD: stc5VrZP: section `set_pcpu' can't be allocated in segment 5
objcopy: stc5VrZP: Bad value
BFD: stc5VrZP: section set_pcpu lma 0xffffffff81529d80 overlaps previous sections
BFD: stc5VrZP: section `set_pcpu' can't be allocated in segment 5
objcopy: stc5VrZP: Bad value
*** Error code 1

Relevant section of readelf --sections output on the binary produced by this patch:

[33] .data             PROGBITS         ffffffff81401000  01015000
     000000000012823c  0000000000000000  WA       0     0     32
[34] .bss              NOBITS           ffffffff81529280  0113d23c
     0000000000207ad0  0000000000000000  WA       0     0     128
[35] set_pcpu          PROGBITS         ffffffff81730d80  0113dd80
     00000000000010b0  0000000000000000  WA       0     0     128

[grimar]

In D23352#516156, @silvas wrote:

• __start_SECNAME/__stop_SECNAME are not exported in the dynamic symbol table. This is needed for the loader which looks up __start_set_modmetadata_set/__stop_set_modmetadata_set.

• LLD does not honor MAXPAGESIZE (needs to be 2M for amd64), this causes the kernel load address to get set far too low (at 4K, close to where the loader lives), which clobbers the loader's text / data structures when copying in the kernel :)

Hopefully it saves you some time!

I`ll take a look on these, thanks a lot for this info !

[grimar]

• Addressed review comments.

[grimar]

ELF/LinkerScript.cpp

345

Done, thanks !

365

I refactored that.
Though there are probably not much space to simplify since
I need to insert different things into two different async lists.

[grimar]

In D23352#516156, @silvas wrote:

• LLD does not honor MAXPAGESIZE (needs to be 2M for amd64), this causes the kernel load address to get set far too low (at 4K, close to where the loader lives), which clobbers the loader's text / data structures when copying in the kernel :)

So I wonder do we want implement -z max-page-size (D19600, this will require adding that option to FreeBSD cmd line I think)
or change X86_64TargetInfo::PageSize to handle this ?

[grimar]

• Rebased.
• Added more comments.

[ruiu]

ELF/LinkerScript.cpp

365

I think the complexity comes from the very fact that you need to insert new commands into existing commands to keep two parallel arrays consistent. Parallel arrays are easy to create when you create one array from the other, but parallel arrays are not suitable for modification because you need to keep them consistent when you remove or add new elements. If you can do this without a parallel array, it would be easier to understand than this. (I'm not sure if it's doable, but I believe it's worth trying.)

[grimar]

• Addressed review comment.

ELF/LinkerScript.cpp

365

Ok, that makes sense. What about updated variant ? (I had to use void* because output command is not template class, but change affects only one local method so I think that should not be a problem).

[ruiu]

ELF/LinkerScript.cpp

344

That's what you are doing, but why do you have to do that?

369

What I meant by "parallel array", I meant ScriptConfig->Commands and OutputSections. You are inserting new elements as you create new output sections, so you are still maintaining them as a parallel array. Is this intended?

[grimar]

ELF/LinkerScript.cpp

344

That is just a variant of possible heuristic.
That works for orphans in freebsd script and probably will work for other scripts.
Attemp to group sections together by attributes seems reasonable.
Do you think about some different algorithm ?

369

Yes, intended, but approach was changed:
I am creating the elements of ScriptConfig->Commands at first. And then at the end of createSections() construct OutputSections entries from ScriptConfig->Commands. So I do not need to mantain both arrays at the same time during sections creation and processing orphans anymore. Was not that the point ?

[grimar]

Ping ?

[ruiu]

Please ping me again once D23866 has landed.

[ruiu]

ELF/LinkerScript.cpp

352

Why rbegin and rend? If it doesn't have to be rbegin/rend, use begin/end.

364

What is base()?

[grimar]

In D23352#528358, @ruiu wrote:

Please ping me again once D23866 has landed.

It seems that it will never be landed. If we decide to go with multiple output sections solution so support SHT_MERGE,
there is no more point to do D23866.
So this patch is still uses Factory, what is looks what we want.

ELF/LinkerScript.cpp

352

I am searching the last section with the same access attributes to place orphan right after. So I had to search from the end to start.

364

base() converts reverse iterator to regular:
http://en.cppreference.com/w/cpp/iterator/reverse_iterator/base

[grimar]

• Rebased.

[emaste]

While attempting to apply the patch locally for testing I encountered line ending issues and two conflicts marked above.

ELF/LinkerScript.cpp

42–1

patch failed to apply for me with a conflict here

test/ELF/linkerscript/symbols-synthetic.s

53–65 ↗

(On Diff #70331)

conflict here

[grimar]

ELF/LinkerScript.cpp

42–1

Yes, it is already outdated. I`ll rebase it soon.

[grimar]

In D23352#537149, @emaste wrote:

While attempting to apply the patch locally for testing I encountered line ending issues and two conflicts marked above.

Sorry, Ed. I think I want to spend more time before updating this patch. After change we had about we can have multiple output sections fot single description I do not like the result after just rebasing this. It was not ideal before, but now it is even more complicated, I am going to rework it and unfortunately have no good ideas right now.

[grimar]

• Rebased/reimplemented. Latest changes in lld (r281778) allowed to simplify this patch a lot.

[grimar]

• Updated comment.

[grimar]

Patch was about placing orphans right after the other sections with the same attributes instead of placing them to the end.
As far I understand, that is already solved with use sorting in latest changes.
And as I mentioned in llvm discussion, this patch does not do something new here for orphans, so I am abandoning it.

ELF/LinkerScript.cpp

 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 using namespace lld;
 using namespace lld::elf;
 
 ScriptConfiguration *elf::ScriptConfig;
 
 template <class ELFT>
 static Symbol *addSymbolToSymtabAux(StringRef Name, uint8_t StOther) {
   return Symtab<ELFT>::X->addRegular(Name, STB_GLOBAL, StOther);
 }
 
 template <class ELFT>
 static Symbol *addSymbolToSymtabAux(StringRef Name, typename ELFT::uint Value,
                                     OutputSectionBase<ELFT> *Section) {
   return Symtab<ELFT>::X->addSynthetic(Name, Section, Value);
 }
 
 template <class ELFT, class... ArgsT>
 static bool addSymbolToSymtab(SymbolAssignment &Cmd, ArgsT... Args) {
   if (Cmd.Name == ".")
     return false;
 
   // If a symbol was in PROVIDE(), define it only when it is an
   // undefined symbol.
   SymbolBody *B = Symtab<ELFT>::X->find(Cmd.Name);
   if (Cmd.Provide && !(B && B->isUndefined()))
     return false;
 
   Symbol *Sym =
       addSymbolToSymtabAux<ELFT>(Cmd.Name, std::forward<ArgsT>(Args)...);
 
   Sym->Visibility = Cmd.Hidden ? STV_HIDDEN : STV_DEFAULT;
   Cmd.Sym = Sym->body();
   return true;
 }
 
 bool SymbolAssignment::classof(const BaseCommand *C) {
   return C->Kind == AssignmentKind;
 }
 
 bool OutputSectionCommand::classof(const BaseCommand *C) {
   return C->Kind == OutputSectionKind;
 }
 
 bool InputSectionDescription::classof(const BaseCommand *C) {
   return C->Kind == InputSectionKind;
 }
 
 bool AssertCommand::classof(const BaseCommand *C) {
   return C->Kind == AssertKind;
 }
 
 template <class ELFT> static bool isDiscarded(InputSectionBase<ELFT> *S) {
   return !S || !S->Live;
public:
   OutputSectionBuilder(OutputSectionFactory<ELFT> &F,
                        std::vector<OutputSectionBase<ELFT> *> *Out)
       : Factory(F), OutputSections(Out) {}
 
   void addSection(StringRef OutputName, InputSectionBase<ELFT> *I);
   void addSymbol(SymbolAssignment *Cmd) {
     PendingSymbols.emplace_back(new LayoutInputSection<ELFT>(Cmd));
   }
+  void addOrphan(StringRef OutputName, InputSectionBase<ELFT> *I);
   void flushSymbols();
   void flushSection();
   void finalize();
 
 private:
   OutputSectionFactory<ELFT> &Factory;
   std::vector<OutputSectionBase<ELFT> *> *OutputSections;
   OutputSectionBase<ELFT> *Current = nullptr;
void OutputSectionBuilder<ELFT>::addSection(StringRef OutputName,
   bool IsNew;
   std::tie(Current, IsNew) = Factory.create(C, OutputName);
   if (IsNew)
     OutputSections->push_back(Current);
   flushSymbols();
   Current->addSection(C);
 }
 
+template <class ELFT>
+static typename ELFT::uint getAccessFlags(OutputSectionBase<ELFT> *Sec) {
+  return Sec->getFlags() & (SHF_WRITE | SHF_ALLOC | SHF_EXECINSTR);
+}
+
+// Places orphan section to desired position. Which is place after
+// the last section with the same access attributes.
+// If there is no such section - just adds ophan to the end. Also
+// updates the command queue with new output section entry.
+template <class ELFT>
+void OutputSectionBuilder<ELFT>::addOrphan(StringRef OutputName,
+                                           InputSectionBase<ELFT> *I) {
+  bool IsNew;
+  std::tie(Current, IsNew) = Factory.create(I, OutputName);
+  Current->addSection(I);
+  if (!IsNew)
+    return;
+
+  auto R = std::find_if(OutputSections->rbegin(), OutputSections->rend(),
+                        [&](OutputSectionBase<ELFT> *S) {
+                          return getAccessFlags(S) == getAccessFlags(Current);
+                        });
+
+  OutputSectionCommand *Cmd = new OutputSectionCommand(OutputName);
+  if (R == OutputSections->rend()) {
+    OutputSections->push_back(Current);
+    ScriptConfig->Commands.emplace_back(Cmd);
+  } else {
+    StringRef InsertAfter = (*R)->getName();
+    OutputSections->insert(R.base(), Current);
+
+    auto I = llvm::find_if(
+        ScriptConfig->Commands, [&](std::unique_ptr<BaseCommand> &Base) {
+          if (auto *O = dyn_cast<OutputSectionCommand>(Base.get()))
+            return O->Name == InsertAfter;
+          return false;
+        });
+    ScriptConfig->Commands.emplace(I + 1, Cmd);
+  }
+}
+
 template <class ELFT> void OutputSectionBuilder<ELFT>::flushSymbols() {
   for (std::unique_ptr<LayoutInputSection<ELFT>> &I : PendingSymbols)
     if (I->Cmd->Name == "." || addSymbolToSymtab<ELFT>(*I->Cmd, 0, Current)) {
       // Only regular output sections are supported.
       if (dyn_cast_or_null<OutputSection<ELFT>>(Current)) {
         Current->addSection(I.get());
         OwningSections.push_back(std::move(I));
       }
if (auto *Cmd = dyn_cast<OutputSectionCommand>(Base1.get())) {
       addSymbolToSymtab<ELFT>(*Cmd2, STV_DEFAULT);
     }
 
   // Add all other input sections, which are not listed in script.
   for (const std::unique_ptr<ObjectFile<ELFT>> &F :
        Symtab<ELFT>::X->getObjectFiles())
     for (InputSectionBase<ELFT> *S : F->getSections())
       if (!isDiscarded(S) && !S->OutSec)
-        Builder.addSection(getOutputSectionName(S), S);
+        Builder.addOrphan(getOutputSectionName(S), S);
 
   // Remove from the output all the sections which did not meet
   // the optional constraints.
   filter();
   Builder.finalize();
 }
 
 template <class R, class T>
 static inline void removeElementsIf(R &Range, const T &Pred) {
   Range.erase(std::remove_if(Range.begin(), Range.end(), Pred), Range.end());
 }
 
 // Process ONLY_IF_RO and ONLY_IF_RW.
 template <class ELFT> void LinkerScript<ELFT>::filter() {
   // In this loop, we remove output sections if they don't satisfy
   // requested properties.
   for (const std::unique_ptr<BaseCommand> &Base : Opt.Commands) {
     auto *Cmd = dyn_cast<OutputSectionCommand>(Base.get());
     if (!Cmd || Cmd->Name == "/DISCARD/")
       continue;
 
     if (Cmd->Constraint == ConstraintKind::NoConstraint)
       continue;
 
     bool RO = (Cmd->Constraint == ConstraintKind::ReadOnly);
     bool RW = (Cmd->Constraint == ConstraintKind::ReadWrite);
 
     removeElementsIf(*OutputSections, [&](OutputSectionBase<ELFT> *S) {
       bool Writable = (S->getFlags() & SHF_WRITE);
       return S->getName() == Cmd->Name &&
              ((RO && Writable) || (RW && !Writable));
     });
   }
 }
 
if (auto *L = dyn_cast<LayoutInputSection<ELFT>>(I)) {
         Off = Value;
       else
         cast<DefinedSynthetic<ELFT>>(L->Cmd->Sym)->Value = Value;
     } else {
       Off = alignTo(Off, I->Alignment);
       I->OutSecOff = Off;
       Off += I->getSize();
     }
-    // Update section size inside for-loop, so that SIZEOF 
+    // Update section size inside for-loop, so that SIZEOF
     // works correctly in the case below:
     // .foo { *(.aaa) a = SIZEOF(.foo); *(.bbb) }
     Sec->setSize(Off);
   }
 }
 
 template <class ELFT> void LinkerScript<ELFT>::assignAddresses() {
   ArrayRef<OutputSectionBase<ELFT> *> Sections = *OutputSections;

test/ELF/linkerscript/linkerscript-orphans.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 
-# RUN: echo "SECTIONS { .writable : { *(.writable) } }" > %t.script
+# RUN: echo "SECTIONS { \
+# RUN:  .foo1 : { *(.foo1) } \
+# RUN:  .foo2 : { *(.foo2) } \
+# RUN:  .bar1 : { *(.bar1) } }" > %t.script
 # RUN: ld.lld -o %t.out --script %t.script %t
-# RUN: llvm-objdump -section-headers %t.out | \
-# RUN:   FileCheck -check-prefix=TEXTORPHAN %s
+# RUN: llvm-objdump -section-headers %t.out | FileCheck %s
 
-# RUN: echo "SECTIONS { .text : { *(.text) } }" > %t.script
-# RUN: ld.lld -o %t.out --script %t.script %t
-# RUN: llvm-objdump -section-headers %t.out | \
-# RUN:   FileCheck -check-prefix=WRITABLEORPHAN %s
-
-# TEXTORPHAN:      Sections:
-# TEXTORPHAN-NEXT: Idx Name
-# TEXTORPHAN-NEXT:   0
-# TEXTORPHAN-NEXT:   1 .writable
-# TEXTORPHAN-NEXT:   2 .text
-
-# WRITABLEORPHAN:      Sections:
-# WRITABLEORPHAN-NEXT: Idx Name
-# WRITABLEORPHAN-NEXT:   0
-# WRITABLEORPHAN-NEXT:   1 .text
-# WRITABLEORPHAN-NEXT:   2 .writable
+# CHECK:      Sections:
+# CHECK-NEXT: Idx Name          Size      Address          Type
+# CHECK-NEXT:   0               00000000 0000000000000000
+# CHECK-NEXT:   1 .foo1         00000004 0000000000000158 DATA
+# CHECK-NEXT:   2 .foo2         00000004 000000000000015c DATA
+# CHECK-NEXT:   3 .foo3         00000004 0000000000000160 DATA
+# CHECK-NEXT:   4 .bar1         00000004 0000000000000164 DATA
+# CHECK-NEXT:   5 .bar2         00000004 0000000000000168 DATA
+# CHECK-NEXT:   6 .text         00000001 000000000000016c TEXT DATA
+# CHECK-NEXT:   7 .symtab       000000a8 0000000000000000
+# CHECK-NEXT:   8 .shstrtab     0000003f 0000000000000000
+# CHECK-NEXT:   9 .strtab       00000021 0000000000000000
 
 .global _start
 _start:
   nop
 
-.section .writable,"aw"
- .zero 4
+.section .foo1, "a"
+foo1:
+ .long 1
+
+.section .foo2, "a"
+foo2:
+ .long 1
+
+.section .foo3, "a"
+foo3:
+ .long 1
+
+.section .bar1, "aw"
+bar1:
+ .long 1
+
+.section .bar2, "aw"
+bar2:
+ .long 1

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

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 # RUN: echo "SECTIONS { \
 # RUN:  .writable : ONLY_IF_RW { *(.writable) } \
 # RUN:  .readable : ONLY_IF_RO { *(.readable) }}" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -section-headers %t1 | \
 # RUN:   FileCheck -check-prefix=BASE %s
 # BASE: Sections:
-# BASE-NEXT: Idx Name          Size      Address          Type
-# BASE-NEXT:   0               00000000 0000000000000000
-# BASE-NEXT:   1 .writable     00000004 0000000000000200 DATA
-# BASE-NEXT:   2 .readable     00000004 0000000000000204 DATA
+# BASE:  .writable
+# BASE:  .readable
 
 # RUN: echo "SECTIONS { \
 # RUN:  .writable : ONLY_IF_RO { *(.writable) } \
 # RUN:  .readable : ONLY_IF_RW { *(.readable) }}" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -section-headers %t1 | \
 # RUN:   FileCheck -check-prefix=NOSECTIONS %s
 # NOSECTIONS: Sections:

test/ELF/linkerscript/linkerscript-sections.s

 # RUN:   FileCheck -check-prefix=SEC-DEFAULT %s
 
 #             Idx Name          Size
 # SEC-DEFAULT: 1 .text         0000000e {{[0-9a-f]*}} TEXT DATA
 # 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 .shstrtab     00000002 {{[0-9a-f]*}}
-# SEC-DEFAULT: 6 .symtab       00000030 {{[0-9a-f]*}}
-# SEC-DEFAULT: 7 .shstrtab     00000032 {{[0-9a-f]*}}
+# SEC-DEFAULT: 6 .shstrtab     00000032 {{[0-9a-f]*}}
+# SEC-DEFAULT: 7 .symtab       00000030 {{[0-9a-f]*}}
 # SEC-DEFAULT: 8 .strtab       00000008 {{[0-9a-f]*}}
 
 # Sections are put in order specified in linker script.
 # RUN: echo "SECTIONS { \
 # RUN:          .bss : { *(.bss) } \
 # RUN:          other : { *(other) } \
 # RUN:          .shstrtab : { *(.shstrtab) } \
 # RUN:          .symtab : { *(.symtab) } \

 # RUN:   FileCheck -check-prefix=SEC-SWAP-NAMES %s
 
 #                Idx Name          Size
 # SEC-SWAP-NAMES: 1 .data         0000000e {{[0-9a-f]*}} TEXT DATA
 # SEC-SWAP-NAMES: 2 .text         00000020 {{[0-9a-f]*}} DATA
 # SEC-SWAP-NAMES: 3 other         00000003 {{[0-9a-f]*}} DATA
 # SEC-SWAP-NAMES: 4 .bss          00000002 {{[0-9a-f]*}} BSS
 # SEC-SWAP-NAMES: 5 .shstrtab     00000002 {{[0-9a-f]*}}
-# SEC-SWAP-NAMES: 6 .symtab       00000030 {{[0-9a-f]*}}
-# SEC-SWAP-NAMES: 7 .shstrtab     00000032 {{[0-9a-f]*}}
+# SEC-SWAP-NAMES: 6 .shstrtab     00000032 {{[0-9a-f]*}}
+# SEC-SWAP-NAMES: 7 .symtab       00000030 {{[0-9a-f]*}}
 # SEC-SWAP-NAMES: 8 .strtab       00000008 {{[0-9a-f]*}}
 
 # .shstrtab from the input object file is discarded.
 # RUN: echo "SECTIONS { \
 # RUN:          /DISCARD/ : { *(.shstrtab) } }" > %t.script
 # RUN: ld.lld -o %t5 --script %t.script %t
 # RUN: llvm-objdump -section-headers %t5 | \
 # RUN:   FileCheck -check-prefix=SEC-DISCARD %s

 # RUN: llvm-objdump -section-headers %t6 | \
 # RUN:   FileCheck -check-prefix=SEC-MULTI %s
 
 #           Idx Name          Size
 # SEC-MULTI: 1 .text         0000000e {{[0-9a-f]*}} TEXT DATA
 # SEC-MULTI: 2 .data         00000023 {{[0-9a-f]*}} DATA
 # SEC-MULTI: 3 .bss          00000002 {{[0-9a-f]*}} BSS
 # SEC-MULTI: 4 .shstrtab     00000002 {{[0-9a-f]*}}
-# SEC-MULTI: 5 .symtab       00000030 {{[0-9a-f]*}}
-# SEC-MULTI: 6 .shstrtab     0000002c {{[0-9a-f]*}}
+# SEC-MULTI: 5 .shstrtab     0000002c {{[0-9a-f]*}}
+# SEC-MULTI: 6 .symtab       00000030 {{[0-9a-f]*}}
 # SEC-MULTI: 7 .strtab       00000008 {{[0-9a-f]*}}
 
 .globl _start
 _start:
     mov $60, %rax
     mov $42, %rdi
 
 .section .data,"aw"
 .quad 10, 10, 20, 20
 .section other,"aw"
 .short 10
 .byte 20
 .section .shstrtab,""
 .short 20
 .section .bss,"",@nobits
 .short 0

test/ELF/linkerscript/linkerscript-va.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 
 # RUN: echo "SECTIONS {}" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -section-headers %t1 | FileCheck %s
 # CHECK:      Sections:
 # CHECK-NEXT: Idx Name          Size      Address          Type
 # CHECK-NEXT:   0               00000000 0000000000000000
-# CHECK-NEXT:   1 .foo          00000004 0000000000000120 DATA
-# CHECK-NEXT:   2 .boo          00000004 0000000000000124 DATA
-# CHECK-NEXT:   3 .text         00000001 0000000000000128 TEXT DATA
+# CHECK-NEXT:   1 .text         00000001 0000000000000158 TEXT DATA
+# CHECK-NEXT:   2 .foo          00000004 0000000000000159 DATA
+# CHECK-NEXT:   3 .boo          00000004 000000000000015d DATA
 
 .global _start
 _start:
  nop
 
 .section .foo, "a"
 foo:
  .long 0
 
 .section .boo, "a"
 boo:
  .long 0