[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

189

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

189

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

34

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

47

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.

53

Why do you have to use rbegin and rend?

58–74

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

[grimar]

ELF/LinkerScript.cpp

53

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.

56

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

63

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.

66

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.

74

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

34

Done.

47

Done.

[ruiu]

ELF/LinkerScript.cpp

267

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

247

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

247

Done, thanks !

267

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

267

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

267

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

246

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

271

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

246

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 ?

271

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

254

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

266

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

254

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.

266

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

31–1

patch failed to apply for me with a conflict here

test/ELF/linkerscript/symbols-synthetic.s

0–1

conflict here

[grimar]

ELF/LinkerScript.cpp

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

public:
   uint64_t getHeaderSize() override;
   uint64_t getSymbolValue(StringRef S) override;
 
   std::vector<OutputSectionBase<ELFT> *> *OutputSections;
 
 private:
   void computeInputSections(InputSectionDescription *);
 
-  void addSection(OutputSectionFactory<ELFT> &Factory,
+  bool addSection(OutputSectionFactory<ELFT> &Factory,
                   InputSectionBase<ELFT> *Sec, StringRef Name);
   void discard(ArrayRef<InputSectionBase<ELFT> *> V);
 
   std::vector<InputSectionBase<ELFT> *>
   createInputSectionList(OutputSectionCommand &Cmd);
 
   // "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;
   OutputSectionBase<ELFT> *CurOutSec = nullptr;
   uintX_t ThreadBssOffset = 0;
   void switchTo(OutputSectionBase<ELFT> *Sec);
   void flush();
   void output(InputSection<ELFT> *Sec);
   void process(BaseCommand &Base);
   llvm::DenseSet<OutputSectionBase<ELFT> *> AlreadyOutputOS;
   llvm::DenseSet<InputSectionData *> AlreadyOutputIS;
+
+  std::vector<StringRef> SectionsOrder;
 };
 
 // Variable template is a C++14 feature, so we can't template
 // a global variable. Use a struct to workaround.
 template <class ELFT> struct Script { static LinkerScript<ELFT> *X; };
 template <class ELFT> LinkerScript<ELFT> *Script<ELFT>::X;
 
 extern LinkerScriptBase *ScriptBase;
 
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/LinkerScript.cpp

 #include "Strings.h"
 #include "Symbols.h"
 #include "SymbolTable.h"
 #include "Target.h"
 #include "Writer.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/ELF.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/StringSaver.h"
 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 using namespace lld;
 using namespace lld::elf;
 
 LinkerScriptBase *elf::ScriptBase;
 ScriptConfiguration *elf::ScriptConfig;
 
 template <class ELFT> static void addRegular(SymbolAssignment *Cmd) {
   Symbol *Sym = Symtab<ELFT>::X->addRegular(Cmd->Name, STB_GLOBAL, STV_DEFAULT);
   Sym->Visibility = Cmd->Hidden ? STV_HIDDEN : STV_DEFAULT;
   Cmd->Sym = Sym->body();
 
   // If we have no SECTIONS then we don't have '.' and don't call
   // assignAddresses(). We calculate symbol value immediately in this case.
   if (!ScriptConfig->HasSections)
     cast<DefinedRegular<ELFT>>(Cmd->Sym)->Value = Cmd->Expression(0);
 }
 
 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();
 }
 
 template <class ELFT> static void addSymbol(SymbolAssignment *Cmd) {
   if (Cmd->IsAbsolute)
     addRegular<ELFT>(Cmd);
   else
     addSynthetic<ELFT>(Cmd);
 }
 // 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;
for (SectionPattern &Pat : I->SectionPatterns) {
     }
   }
 
   // Sort for SORT() commands.
   if (I->SortInner != SortSectionPolicy::Default)
     std::stable_sort(I->Sections.begin(), I->Sections.end(),
                      getComparator(I->SortInner));
   if (I->SortOuter != SortSectionPolicy::Default)
     std::stable_sort(I->Sections.begin(), I->Sections.end(),
                      getComparator(I->SortOuter));
 
   // We do not add duplicate input sections, so mark them with a dummy output
   // section for now.
   for (InputSectionData *S : I->Sections) {
     auto *S2 = static_cast<InputSectionBase<ELFT> *>(S);
     S2->OutSec = (OutputSectionBase<ELFT> *)-1;
   }
static SectionKey<ELFT::Is64Bits> createKey(InputSectionBase<ELFT> *C,
 
   // An extra annoyance is that we cannot simply disable merging of the contents
   // of SHF_MERGE sections, but our implementation requires one output section
   // per "kind" (string or not, which size/aligment).
   // Fortunately, creating symbols in the middle of a merge section is not
   // supported by bfd or gold, so we can just create multiple section in that
   // case.
   const typename ELFT::Shdr *H = C->getSectionHdr();
   typedef typename ELFT::uint uintX_t;
   uintX_t Flags = H->sh_flags & (SHF_MERGE | SHF_STRINGS);
 
   uintX_t Alignment = 0;
   if (isa<MergeInputSection<ELFT>>(C))
     Alignment = std::max(H->sh_addralign, H->sh_entsize);
 
   return SectionKey<ELFT::Is64Bits>{OutsecName, /*Type*/ 0, Flags, Alignment};
 }
 
 template <class ELFT>
-void LinkerScript<ELFT>::addSection(OutputSectionFactory<ELFT> &Factory,
+bool LinkerScript<ELFT>::addSection(OutputSectionFactory<ELFT> &Factory,
                                     InputSectionBase<ELFT> *Sec,
                                     StringRef Name) {
   OutputSectionBase<ELFT> *OutSec;
   bool IsNew;
   std::tie(OutSec, IsNew) = Factory.create(createKey(Sec, Name), Sec);
   if (IsNew)
     OutputSections->push_back(OutSec);
   OutSec->addSection(Sec);
+  return IsNew;
 }
 
 template <class ELFT>
 void LinkerScript<ELFT>::processCommands(OutputSectionFactory<ELFT> &Factory) {
 
   for (unsigned I = 0; I < Opt.Commands.size(); ++I) {
     auto Iter = Opt.Commands.begin() + I;
     const std::unique_ptr<BaseCommand> &Base1 = *Iter;
     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 (uint32_t Subalign = Cmd->SubalignExpr ? Cmd->SubalignExpr(0) : 0)
           Sec->Alignment = Subalign;
       }
     }
   }
 }
 
 template <class ELFT>
+static typename ELFT::uint getPermissions(OutputSectionBase<ELFT> *Sec) {
+  return Sec->getFlags() & (SHF_WRITE | SHF_ALLOC | SHF_EXECINSTR);
+}
+
+template <class ELFT>
 void LinkerScript<ELFT>::createSections(OutputSectionFactory<ELFT> &Factory) {
   processCommands(Factory);
-  // Add orphan sections.
-  for (ObjectFile<ELFT> *F : Symtab<ELFT>::X->getObjectFiles())
-    for (InputSectionBase<ELFT> *S : F->getSections())
-      if (!isDiscarded(S) && !S->OutSec)
-        addSection(Factory, S, getOutputSectionName(S));
+
+  // 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.
+  for (ObjectFile<ELFT> *F : Symtab<ELFT>::X->getObjectFiles()) {
+    for (InputSectionBase<ELFT> *S : F->getSections()) {
+      if (isDiscarded(S) || S->OutSec)
+        continue;
+
+      // Add the orphan section and check if it is newly created.
+      // If so, we need to move it inside OutputSections list.
+      bool New = addSection(Factory, S, getOutputSectionName(S));
+      if (!New)
+        continue;
+
+      OutputSectionBase<ELFT> *Orphan = OutputSections->back();
+      OutputSections->pop_back();
+      auto R =
+          std::find_if(OutputSections->rbegin(), OutputSections->rend(),
+                       [&](OutputSectionBase<ELFT> *S) {
+                         if (S->getType() == SHT_NOBITS)
+                           return false;
+                         return getPermissions(S) == getPermissions(Orphan);
+                       });
+      auto Pos = R != OutputSections->rend() ? R.base() : OutputSections->end();
+      OutputSections->emplace(Pos, Orphan);
+    }
+  }
+
+  // Finally we can build the sections order list. We need it because
+  // do not create the commands for orphans here, though getSectionIndex()
+  // needs to know section index.
+  for (OutputSectionBase<ELFT> *Sec : *OutputSections)
+    SectionsOrder.push_back(Sec->getName());
 }
 
 // Sets value of a section-defined symbol. Two kinds of
 // symbols are processed: synthetic symbols, whose value
 // is an offset from beginning of section and regular
 // symbols whose value is absolute.
 template <class ELFT>
 static void assignSectionSymbol(SymbolAssignment *Cmd,
template <class ELFT> Expr LinkerScript<ELFT>::getLma(StringRef Name) {
   return {};
 }
 
 // Returns the index of the given section name in linker script
 // SECTIONS commands. Sections are laid out as the same order as they
 // were in the script. If a given name did not appear in the script,
 // it returns INT_MAX, so that it will be laid out at end of file.
 template <class ELFT> int LinkerScript<ELFT>::getSectionIndex(StringRef Name) {
-  int I = 0;
-  for (std::unique_ptr<BaseCommand> &Base : Opt.Commands) {
-    if (auto *Cmd = dyn_cast<OutputSectionCommand>(Base.get()))
-      if (Cmd->Name == Name)
-        return I;
-    ++I;
-  }
+  auto I = llvm::find(SectionsOrder, Name);
+  if (I == SectionsOrder.end())
     return INT_MAX;
+  return std::distance(SectionsOrder.begin(), I);
 }
 
 // A compartor to sort output sections. Returns -1 or 1 if
 // A or B are mentioned in linker script. Otherwise, returns 0.
 template <class ELFT>
 int LinkerScript<ELFT>::compareSections(StringRef A, StringRef B) {
   int I = getSectionIndex(A);
   int J = getSectionIndex(B);

test/ELF/linkerscript/data-segment-relro.s

 ## With relro or without DATA_SEGMENT_RELRO_END just aligns to
 ## page boundary.
 # RUN: ld.lld -z norelro %t1.o %t2.so --script %t.script -o %t
 # RUN: llvm-readobj -s %t | FileCheck %s
 # RUN: ld.lld -z relro %t1.o %t2.so --script %t.script -o %t2
 # RUN: llvm-readobj -s %t2 | FileCheck %s
 
 # CHECK:       Section {
-# CHECK:         Index: 4
+# CHECK:         Index: 12
 # CHECK-NEXT:    Name: .got
 # CHECK-NEXT:    Type: SHT_PROGBITS
 # CHECK-NEXT:    Flags [
 # CHECK-NEXT:      SHF_ALLOC
 # CHECK-NEXT:      SHF_WRITE
 # CHECK-NEXT:    ]
 # CHECK-NEXT:    Address: 0x2000F0
 # CHECK-NEXT:    Offset: 0x10F0
 # CHECK-NEXT:    Size:
 # CHECK-NEXT:    Link:
 # CHECK-NEXT:    Info:
 # CHECK-NEXT:    AddressAlignment:
 # CHECK-NEXT:    EntrySize:
 # CHECK-NEXT:  }
 # CHECK-NEXT:  Section {
-# CHECK-NEXT:    Index: 5
+# CHECK-NEXT:    Index: 13
 # CHECK-NEXT:    Name: .got.plt
 # CHECK-NEXT:    Type: SHT_PROGBITS
 # CHECK-NEXT:    Flags [
 # CHECK-NEXT:      SHF_ALLOC
 # CHECK-NEXT:      SHF_WRITE
 # CHECK-NEXT:    ]
 # CHECK-NEXT:    Address: 0x201000
 # CHECK-NEXT:    Offset: 0x2000

test/ELF/linkerscript/eh-frame-hdr.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 # RUN: echo "SECTIONS { \
 # RUN:          .eh_frame_hdr : {} \
 # RUN:          .eh_frame : {} \
 # RUN:       }" > %t.script
 # RUN: ld.lld -o %t1 --eh-frame-hdr --script %t.script %t
 # RUN: llvm-objdump -s -section=".eh_frame_hdr" %t1 | FileCheck %s
 
-# CHECK:      0158 011b033b 14000000 01000000 49000000
-# CHECK-NEXT: 0168 30000000
+# CHECK:      01c8 011b033b ccffffff 01000000 c9ffffff
+# CHECK-NEXT: 01d8 e8ffffff
 
 .global _start
 _start:
  nop
 
 .section .dah,"ax",@progbits
 .cfi_startproc
  nop
 .cfi_endproc

test/ELF/linkerscript/merge-sections.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 
 # RUN: echo "SECTIONS {.foo : { begin = .; *(.foo.*) end = .;} }" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t -shared
 # RUN: llvm-readobj -s -t %t1 | FileCheck %s
 
 # CHECK:        Name: .foo
 # CHECK-NEXT:   Type: SHT_PROGBITS
 # CHECK-NEXT:   Flags [
 # CHECK-NEXT:     SHF_ALLOC
 # CHECK-NEXT:     SHF_MERGE
 # CHECK-NEXT:     SHF_STRINGS
 # CHECK-NEXT:   ]
-# CHECK-NEXT:   Address: 0x1C8
-# CHECK-NEXT:   Offset: 0x1C8
+# CHECK-NEXT:   Address: 0x200
+# CHECK-NEXT:   Offset: 0x200
 # CHECK-NEXT:   Size: 4
 # CHECK-NEXT:   Link: 0
 # CHECK-NEXT:   Info: 0
 # CHECK-NEXT:   AddressAlignment: 1
 # CHECK-NEXT:   EntrySize: 1
 # CHECK-NEXT: }
 # CHECK-NEXT: Section {
 # CHECK-NEXT:   Index:
 # CHECK-NEXT:   Name: .foo
 # CHECK-NEXT:   Type: SHT_PROGBITS
 # CHECK-NEXT:   Flags [
 # CHECK-NEXT:     SHF_ALLOC
 # CHECK-NEXT:     SHF_MERGE
 # CHECK-NEXT:   ]
-# CHECK-NEXT:   Address: 0x1CC
-# CHECK-NEXT:   Offset: 0x1CC
+# CHECK-NEXT:   Address: 0x204
+# CHECK-NEXT:   Offset: 0x204
 # CHECK-NEXT:   Size: 1
 # CHECK-NEXT:   Link: 0
 # CHECK-NEXT:   Info: 0
 # CHECK-NEXT:   AddressAlignment: 1
 # CHECK-NEXT:   EntrySize: 1
 # CHECK-NEXT: }
 # CHECK-NEXT: Section {
 # CHECK-NEXT:   Index:
 # CHECK-NEXT:   Name: .foo
 # CHECK-NEXT:   Type: SHT_PROGBITS
 # CHECK-NEXT:   Flags [
 # CHECK-NEXT:     SHF_ALLOC
 # CHECK-NEXT:     SHF_MERGE
 # CHECK-NEXT:   ]
-# CHECK-NEXT:   Address: 0x1CE
-# CHECK-NEXT:   Offset: 0x1CE
+# CHECK-NEXT:   Address: 0x206
+# CHECK-NEXT:   Offset: 0x206
 # CHECK-NEXT:   Size: 2
 # CHECK-NEXT:   Link: 0
 # CHECK-NEXT:   Info: 0
 # CHECK-NEXT:   AddressAlignment: 2
 # CHECK-NEXT:   EntrySize: 2
 
 
 # CHECK:      Name: begin
-# CHECK-NEXT: Value: 0x1C8
+# CHECK-NEXT: Value: 0x200
 
 # CHECK:      Name: end
-# CHECK-NEXT: Value: 0x1D0
+# CHECK-NEXT: Value: 0x208
 
 .section        .foo.1a,"aMS",@progbits,1
 .asciz "foo"
 
 .section        .foo.1b,"aMS",@progbits,1
 .asciz "foo"
 
 .section        .foo.2a,"aM",@progbits,1

test/ELF/linkerscript/non-alloc.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t
 
 # RUN: echo "SECTIONS { .foo 0 : {*(foo)} }" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t -shared
 # RUN: llvm-readobj -elf-output-style=GNU -s -l %t1 | FileCheck %s
 
 # Test that we create all necessary PT_LOAD. We use to stop at the first
 # non-alloc, causing us to not create PT_LOAD for linker generated sections.
 
 # CHECK: Program Headers:
 # CHECK-NEXT:  Type
 # CHECK-NEXT:  PHDR
 # CHECK-NEXT:  LOAD {{.*}} R
 # CHECK-NEXT:  LOAD {{.*}} R E
+# CHECK-NEXT:  LOAD {{.*}} R
 # CHECK-NEXT:  LOAD {{.*}} RW
 
 # CHECK:      Section to Segment mapping:
 # CHECK-NEXT:  Segment Sections...
 # CHECK-NEXT:   00
-# CHECK-NEXT:   01     .dynsym .hash .dynstr
+# CHECK-NEXT:   01
 # CHECK-NEXT:   02     .text
-# CHECK-NEXT:   03     .dynamic
+# CHECK-NEXT:   03     .dynsym .hash .dynstr
+# CHECK-NEXT:   04     .dynamic
 
 nop
 .section foo
 .quad 0

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-orphans.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+
+# RUN: echo "SECTIONS { \
+# RUN:  .text : { *(.text) } \
+# RUN:  .foo1 : { *(.foo1) } \
+# RUN:  .bar1 : { *(.bar1) } \
+# RUN:  .bss : { *(.bss) } } " > %t.script
+# RUN: ld.lld -o %t.out --script %t.script %t
+# RUN: llvm-objdump -section-headers %t.out | FileCheck %s
+
+# CHECK:      Sections:
+# CHECK-NEXT: Idx Name          Size      Address          Type
+# CHECK-NEXT:   0               00000000 0000000000000000
+# CHECK-NEXT:   1  .text        00000001 0000000000000190 TEXT DATA
+# CHECK-NEXT:   2  .foo1        00000004 0000000000000191 DATA
+# CHECK-NEXT:   3  .foo2        00000004 0000000000000195 DATA
+# CHECK-NEXT:   4  .foo3        00000004 0000000000000199 DATA
+# CHECK-NEXT:   5  .bar1        00000004 000000000000019d DATA
+# CHECK-NEXT:   6  .bar2        00000004 00000000000001a1 DATA
+# CHECK-NEXT:   7  .bss         00000002 00000000000001a5 BSS
+# CHECK-NEXT:   8  .symtab      000000a8 0000000000000000
+# CHECK-NEXT:   9  .shstrtab    00000044 0000000000000000
+# CHECK-NEXT:   10 .strtab      00000021 0000000000000000
+
+.global _start
+_start:
+  nop
+
+.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
+
+.section .bss,"",@nobits
+.short 0

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, other than alloc
 # sections going first.
 # RUN: echo "SECTIONS { \
 # RUN:          .bss : { *(.bss) } \
 # RUN:          other : { *(other) } \
 # RUN:          .shstrtab : { *(.shstrtab) } \

 # 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

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 # Simple symbol assignment within input section list. The '.' symbol
 # is not location counter but offset from the beginning of output
 # section .foo
 # RUN: echo "SECTIONS { \
 # RUN:          .foo : { \
 # RUN:              begin_foo = .; \
 # RUN:              PROVIDE(_begin_sec = .); \

 # RUN:             PROVIDE_HIDDEN(_begin_sec = .); \
 # RUN:             *(.eh_frame_hdr) \
 # RUN:             *(.eh_frame_hdr) \
 # RUN:             PROVIDE_HIDDEN(_end_sec_abs = ABSOLUTE(.)); \
 # 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-NEXT: 0000000000000158         .foo    00000000 _begin_sec
-# SIMPLE-NEXT: 0000000000000160         *ABS*   00000000 _end_sec_abs
-# SIMPLE-NEXT: 0000000000001048         .text   00000000 _start
-# SIMPLE-NEXT: 0000000000000158         .foo    00000000 begin_foo
-# SIMPLE-NEXT: 0000000000000160         .foo    00000000 end_foo
+# SIMPLE:      0000000000000198         .foo    00000000 .hidden _end_sec
+# SIMPLE-NEXT: 0000000000000190         .foo    00000000 _begin_sec
+# SIMPLE-NEXT: 0000000000000198         *ABS*   00000000 _end_sec_abs
+# SIMPLE-NEXT: 0000000000001004         .text   00000000 _start
+# SIMPLE-NEXT: 0000000000000190         .foo    00000000 begin_foo
+# SIMPLE-NEXT: 0000000000000198         .foo    00000000 end_foo
 # SIMPLE-NEXT: 0000000000000008         .foo    00000000 size_foo_1
 # SIMPLE-NEXT: 0000000000000008         *ABS*   00000000 size_foo_1_abs
 # 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         *ABS*             00000000 __eh_frame_hdr_start2
-# SIMPLE-NEXT: 0000000000001018         .eh_frame_hdr     00000000 __eh_frame_hdr_end
-# SIMPLE-NEXT: 0000000000001020         *ABS*             00000000 __eh_frame_hdr_end2
+# SIMPLE-NEXT: 0000000000000e74         .foo    00000000 size_foo_2
+# SIMPLE-NEXT: 0000000000000e74         *ABS*   00000000 size_foo_3
+# SIMPLE-NEXT: 0000000000001038         .eh_frame_hdr     00000000 __eh_frame_hdr_start
+# SIMPLE-NEXT: 0000000000001040         *ABS*             00000000 __eh_frame_hdr_start2
+# SIMPLE-NEXT: 000000000000104c         .eh_frame_hdr     00000000 __eh_frame_hdr_end
+# SIMPLE-NEXT: 0000000000001050         *ABS*             00000000 __eh_frame_hdr_end2
 
 .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