[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

62

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

62

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

212

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

225

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.

231

Why do you have to use rbegin and rend?

236–252

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

[grimar]

ELF/LinkerScript.cpp

231

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.

234

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

241

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.

244

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.

252

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

212

Done.

225

Done.

[ruiu]

ELF/LinkerScript.cpp

90

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

70

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

70

Done, thanks !

90

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

90

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

90

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

69

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

94

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

69

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 ?

94

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

77

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

89

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

77

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.

89

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

294

patch failed to apply for me with a conflict here

test/ELF/linkerscript/symbols-synthetic.s

53–65

conflict here

[grimar]

ELF/LinkerScript.cpp

294

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.h

struct OutputSectionCommand : BaseCommand {
   Expr AddrExpr;
   Expr AlignExpr;
   Expr LmaExpr;
   Expr SubalignExpr;
   std::vector<std::unique_ptr<BaseCommand>> Commands;
   std::vector<StringRef> Phdrs;
   std::vector<uint8_t> Filler;
   ConstraintKind Constraint = ConstraintKind::NoConstraint;
+  void *OutputSection = nullptr;
 };
 
 enum SortKind { SortNone, SortByName, SortByAlignment };
 
 struct InputSectionDescription : BaseCommand {
   InputSectionDescription(StringRef FilePattern)
       : BaseCommand(InputSectionKind),
         FileRe(compileGlobPatterns({FilePattern})) {}
private:
   std::vector<InputSectionBase<ELFT> *>
   getInputSections(const InputSectionDescription *);
 
   void discard(OutputSectionCommand &Cmd);
 
   std::vector<InputSectionBase<ELFT> *>
   createInputSectionList(OutputSectionCommand &Cmd);
 
+  OutputSectionBase<ELFT> *addOrphan(OutputSectionFactory<ELFT> &Factory,
+                                     StringRef OutputName,
+                                     InputSectionBase<ELFT> *I);
+
   // "ScriptConfig" is a bit too long, so define a short name for it.
   ScriptConfiguration &Opt = *ScriptConfig;
 
   int getSectionIndex(StringRef Name);
   std::vector<size_t> getPhdrIndices(StringRef SectionName);
   size_t getPhdrIndex(StringRef PhdrName);
 
   uintX_t Dot;

ELF/LinkerScript.cpp

template <class ELFT> static void addSynthetic(SymbolAssignment *Cmd) {
   Symbol *Sym = Symtab<ELFT>::X->addSynthetic(
       Cmd->Name, nullptr, 0, Cmd->Hidden ? STV_HIDDEN : STV_DEFAULT);
   Cmd->Sym = Sym->body();
 }
 
 // If a symbol was in PROVIDE(), we need to define it only when
 // it is an undefined symbol.
 template <class ELFT> static bool shouldDefine(SymbolAssignment *Cmd) {
   if (Cmd->Name == ".")
     return false;
   if (!Cmd->Provide)
     return true;
   SymbolBody *B = Symtab<ELFT>::X->find(Cmd->Name);
   return B && B->isUndefined();
 }
 
 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;
 }
 
 template <class ELFT> LinkerScript<ELFT>::LinkerScript() {}
 template <class ELFT> LinkerScript<ELFT>::~LinkerScript() {}
 
 template <class ELFT>
 bool LinkerScript<ELFT>::shouldKeep(InputSectionBase<ELFT> *S) {
   for (Regex *Re : Opt.KeptSections)
     if (Re->match(S->getSectionName()))
       return true;
   return false;
 }
 
 static bool fileMatches(const InputSectionDescription *Desc,
                         StringRef Filename) {
for (InputSectionBase<ELFT> *S : V)
       if (SectionIndex.insert(S).second)
         Ret.push_back(S);
   }
   return Ret;
 }
 
 template <class ELFT>
 void LinkerScript<ELFT>::createAssignments() {
   for (const std::unique_ptr<SymbolAssignment> &Cmd : Opt.Assignments) {
     if (shouldDefine<ELFT>(Cmd.get()))
       addRegular<ELFT>(Cmd.get());
     if (Cmd->Sym)
       cast<DefinedRegular<ELFT>>(Cmd->Sym)->Value = Cmd->Expression(0);
   }
 }
 
 template <class ELFT>
+static typename ELFT::uint getPermissions(OutputSectionBase<ELFT> *Sec) {
+  return Sec->getFlags() & (SHF_WRITE | SHF_ALLOC | SHF_EXECINSTR);
+}
+
+template <class ELFT>
+static OutputSectionBase<ELFT> *
+getOutputSection(const std::unique_ptr<BaseCommand> &Base) {
+  if (auto *Cmd = dyn_cast<OutputSectionCommand>(Base.get()))
+    if (Cmd->OutputSection)
+      return reinterpret_cast<OutputSectionBase<ELFT> *>(Cmd->OutputSection);
+  return nullptr;
+}
+
+// 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.
+// Returns output section where input section was landed.
+template <class ELFT>
+OutputSectionBase<ELFT> *
+LinkerScript<ELFT>::addOrphan(OutputSectionFactory<ELFT> &Factory,
+                              StringRef OutputName, InputSectionBase<ELFT> *C) {
+  bool IsNew;
+  OutputSectionBase<ELFT> *OutSec;
+  std::tie(OutSec, IsNew) = Factory.create(C, OutputName);
+  OutSec->addSection(C);
+  if (!IsNew)
+    return OutSec;
+
+  auto R = std::find_if(
+      ScriptConfig->Commands.rbegin(), ScriptConfig->Commands.rend(),
+      [&](std::unique_ptr<BaseCommand> &Base) {
+        OutputSectionBase<ELFT> *S = getOutputSection<ELFT>(Base);
+        if (!S || S->getType() == SHT_NOBITS)
+          return false;
+        return getPermissions(S) == getPermissions(OutSec);
+      });
+
+  // We want to place orphan section somewhere. Default position (in the case
+  // if we did not find some section with the same flags) is end.
+  // Otherwise we just add orphan section after the last section
+  // with the same attributes we found earlier.
+  auto Pos = R != ScriptConfig->Commands.rend() ? R.base()
+                                                : ScriptConfig->Commands.end();
+  OutputSectionCommand* OutSecCmd = new OutputSectionCommand(OutputName);
+  OutSecCmd->OutputSection = OutSec;
+  ScriptConfig->Commands.emplace(Pos, OutSecCmd);
+
+  return OutSec;
+}
+
+template <class ELFT>
 void LinkerScript<ELFT>::createSections(OutputSectionFactory<ELFT> &Factory) {
   for (const std::unique_ptr<BaseCommand> &Base1 : Opt.Commands) {
     if (auto *Cmd = dyn_cast<SymbolAssignment>(Base1.get())) {
       if (shouldDefine<ELFT>(Cmd))
         addRegular<ELFT>(Cmd);
       continue;
     }
 
     if (auto *Cmd = dyn_cast<OutputSectionCommand>(Base1.get())) {
       if (Cmd->Name == "/DISCARD/") {
         discard(*Cmd);
         continue;
       }
 
       std::vector<InputSectionBase<ELFT> *> V = createInputSectionList(*Cmd);
       if (V.empty())
         continue;
 
       OutputSectionBase<ELFT> *OutSec;
       bool IsNew;
       std::tie(OutSec, IsNew) = Factory.create(V.front(), Cmd->Name);
       if (IsNew)
-        OutputSections->push_back(OutSec);
+        Cmd->OutputSection = OutSec;
 
       uint32_t Subalign = Cmd->SubalignExpr ? Cmd->SubalignExpr(0) : 0;
       for (InputSectionBase<ELFT> *Sec : V) {
         if (Subalign)
           Sec->Alignment = Subalign;
         OutSec->addSection(Sec);
       }
     }
   }
 
   // Add orphan sections.
   for (const std::unique_ptr<ObjectFile<ELFT>> &F :
-       Symtab<ELFT>::X->getObjectFiles()) {
-    for (InputSectionBase<ELFT> *S : F->getSections()) {
-      if (isDiscarded(S) || S->OutSec)
-        continue;
-      OutputSectionBase<ELFT> *OutSec;
-      bool IsNew;
-      std::tie(OutSec, IsNew) = Factory.create(S, getOutputSectionName(S));
-      if (IsNew)
-        OutputSections->push_back(OutSec);
-      OutSec->addSection(S);
-    }
-  }
+       Symtab<ELFT>::X->getObjectFiles())
+    for (InputSectionBase<ELFT> *S : F->getSections())
+      if (!isDiscarded(S) && !S->OutSec)
+        addOrphan(Factory, getOutputSectionName(S), S);
+
+  // Add created output sections to the OutputSections list.
+  for (const std::unique_ptr<BaseCommand> &Base : Opt.Commands)
+    if (OutputSectionBase<ELFT> *S = getOutputSection<ELFT>(Base))
+      OutputSections->push_back(S);
 }
 
 // Linker script may define start and end symbols for special section types,
 // like .got, .eh_frame_hdr, .eh_frame and others. Those sections are not a list
 // of regular input input sections, therefore our way of defining symbols for
 // regular sections will not work. The approach we use for special section types
 // is not perfect - it handles only start and end symbols.
 template <class ELFT>

test/ELF/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:  .foo : ONLY_IF_RO { *(.foo.*) } \
 # RUN:  .writable : ONLY_IF_RW { *(.writable) } \
 # RUN:  .readable : ONLY_IF_RO { *(.readable) }}" > %t2.script
 # RUN: ld.lld -o %t2 --script %t2.script %t
 # RUN: llvm-objdump -section-headers %t2 | \
 # RUN:   FileCheck -check-prefix=NO1 %s
 # NO1: Sections:
 # NO1-NEXT: Idx Name          Size      Address          Type
 # NO1-NEXT: 0               00000000 0000000000000000
-# NO1-NEXT: 1 .writable     00000004 0000000000000200 DATA
-# NO1-NEXT: 2 .readable     00000004 0000000000000204 DATA
-# NO1-NEXT: 3 .text         00000001 0000000000000208 TEXT DATA
-# NO1-NEXT: 4 .foo.2        00000004 0000000000000209 DATA
-# NO1-NEXT: 5 .foo.1        00000004 000000000000020d TEXT DATA
+# NO1-NEXT: 1 .writable     00000004 00000000000001c8 DATA
+# NO1-NEXT: 2 .foo.2        00000004 00000000000001cc DATA
+# NO1-NEXT: 3 .readable     00000004 00000000000001d0 DATA
+# NO1-NEXT: 4 .text         00000001 00000000000001d4 TEXT DATA
+# NO1-NEXT: 5 .foo.1        00000004 00000000000001d5 TEXT DATA
 
 .global _start
 _start:
   nop
 
 .section .writable, "aw"
 writable:
  .long 1

test/ELF/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/symbols-synthetic.s

 # RUN:          .eh_frame_hdr : { \
 # RUN:             PROVIDE_HIDDEN(_begin_sec = .); \
 # RUN:             *(.eh_frame_hdr) \
 # RUN:             *(.eh_frame_hdr) \
 # RUN:             PROVIDE_HIDDEN(_end_sec = .); } \
 # RUN:         }" > %t.script
 # RUN: ld.lld -o %t1 --eh-frame-hdr --script %t.script %t
 
-# SIMPLE:      0000000000000160         .foo    00000000 .hidden _end_sec
-# SIMPLE:      0000000000000158         .foo    00000000 _begin_sec
-# SIMPLE-NEXT: 0000000000000158         .foo    00000000 begin_foo
-# SIMPLE-NEXT: 0000000000000160         .foo    00000000 end_foo
-# SIMPLE-NEXT: 0000000000000008         .foo    00000000 size_foo_1
-# SIMPLE-NEXT: 0000000000001000         .foo    00000000 begin_bar
-# SIMPLE-NEXT: 0000000000001004         .foo    00000000 end_bar
-# SIMPLE-NEXT: 0000000000000eac         .foo    00000000 size_foo_2
-# SIMPLE-NEXT: 0000000000000eac         *ABS*   00000000 size_foo_3
-# SIMPLE-NEXT: 0000000000001004         .eh_frame_hdr     00000000 __eh_frame_hdr_start
-# SIMPLE-NEXT: 0000000000001010         .eh_frame_hdr     00000000 __eh_frame_hdr_start2
-# SIMPLE-NEXT: 0000000000001018         .eh_frame_hdr     00000000 __eh_frame_hdr_end
-# SIMPLE-NEXT: 0000000000001020         .eh_frame_hdr     00000000 __eh_frame_hdr_end2
+# SIMPLE:       0000000000000198         .foo    00000000 .hidden _end_sec
+# SIMPLE:       0000000000000190         .foo    00000000 _begin_sec
+# SIMPLE-NEXT:  0000000000000190         .foo    00000000 begin_foo
+# SIMPLE-NEXT:  0000000000000198         .foo    00000000 end_foo
+# SIMPLE-NEXT:  0000000000000008         .foo    00000000 size_foo_1
+# SIMPLE-NEXT:  0000000000001000         .foo    00000000 begin_bar
+# SIMPLE-NEXT:  0000000000001004         .foo    00000000 end_bar
+# SIMPLE-NEXT:  0000000000000e74         .foo    00000000 size_foo_2
+# SIMPLE-NEXT:  0000000000000e74         *ABS*     00000000 size_foo_3
+# SIMPLE-NEXT:  0000000000001004         .eh_frame_hdr     00000000 __eh_frame_hdr_start
+# SIMPLE-NEXT:  0000000000001010         .eh_frame_hdr     00000000 __eh_frame_hdr_start2
+# SIMPLE-NEXT:  0000000000001018         .eh_frame_hdr     00000000 __eh_frame_hdr_end
+# SIMPLE-NEXT:  0000000000001020         .eh_frame_hdr     00000000 __eh_frame_hdr_end2
 # ERROR: section '.eh_frame_hdr' supports only start and end symbols
 
 .global _start
 _start:
  nop
 
 .section .foo,"a"
  .quad 0

test/ELF/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