[ELF] - Linkrscript: change the way of creating PT_LOADs segments when LS is used.

[grimar]

Summary

I noticed that logic of PT_LOADs creation when script is used in gnu linekrs is different from what we have now.
For example ld seems to create 2 PT_LOADs. In first one it puts all sections before first writable, it is text load,
and also it has data load where all sections after and including first writable are placed.

FreeBSD script seems to rely on this logic, and also it seems to be clear and simple, so patch implements the same.

Alternative to this can be solution to force align to memory page boundary of sections with different flags.
That is the same we do for non-LS case. This method also can help to avoid unaligned segments.

[ruiu]

How did you know that FreeBSD's linker scripts depend on this behavior?

If you think the new behavior you are implementing in this patch simpler than the current one, why don't you just replace it with the new one, instead of keeping two different functions?

ELF/Writer.cpp

968

What if the current section is writable and NewFlags are not writable? This code seems to merge them, but is it the right thing to do?

[grimar]

In D23505#515896, @ruiu wrote:

How did you know that FreeBSD's linker scripts depend on this behavior?

ld output of FreeBSD kernel is 2 PT_LOADS:

LOAD           0x0000000000000000 0xffffffff80200000 0xffffffff80200000
                 0x0000000000fe2de8 0x0000000000fe2de8  R E    200000
LOAD           0x0000000000fe3000 0xffffffff813e3000 0xffffffff813e3000
                 0x0000000000129430 0x00000000003313c0  RW     200000

lld output currently is:

LOAD           0x0000000000000000 0xffffffff80001000 0xffffffff80001000
                0x00000000000e410e 0x00000000000e410e  R      1000
LOAD           0x00000000000e4110 0xffffffff800e5110 0xffffffff800e5110
                0x0000000000ba2b0c 0x0000000000ba2b0c  R E    1000
LOAD           0x0000000000c86c20 0xffffffff80c87c20 0xffffffff80c87c20
                0x000000000038ab28 0x000000000038ab28  R      1000
LOAD           0x0000000001012000 0xffffffff81013000 0xffffffff81013000
                0x000000000012ae30 0x0000000000331e30  RW     1000

2 and 3 lld loads are not aligned to memory page. Script does not so that, assuming that
alignment for first section and for last (writable) is enough because 2 loads will be created.

So fix for that can be:

1. Changing script (not always acceptable).
2. Forced alignment of sections when flags are changed (should work, but not so obvious as 3 + will create more loads and waste more VA space).
3. This patch's solution (create 2 PT_LOADS just like ld do).

If you think the new behavior you are implementing in this patch simpler than the current one, why don't you just replace it with the new one, instead of keeping two different functions?

This patch changes the way we create PT_LOADS when use linkerscript. I was unsure if I should change the non-linkerscript case as well.
Though I think it will work fine either. This will require fix for many testcases I guess, but this is in the nature of the case.

[grimar]

ELF/Writer.cpp

968

That is what ld do. I think it is fine because writable sections go after all other ones.
At least it is assumed they should.

[grimar]

In D23505#515896, @ruiu wrote:

If you think the new behavior you are implementing in this patch simpler than the current one, why don't you just replace it with the new one, instead of keeping two different functions?

I just checked what will happen if I leave only this implementation for all (for non-scripted case) and had 187 testcases fails.

Current patch changes logic only for scripted case and already had to modify 20 testcases. We probably can land it first and check if it satisfies our needs
generally for scripted path before trying to change all 187 testcases for non-scripted one.

[evgeny777]

2 and 3 lld loads are not aligned to memory page. Script does not so that, assuming that

I think you mean these ones:

LOAD 0x00000000000e4110 0xffffffff800e5110 0xffffffff800e5110
LOAD 0x0000000000c86c20 0xffffffff80c87c20 0xffffffff80c87c20

What I see is that file offset and VA are properly aligned.

(0x00000000000e4110 mod 0x1000) == (0xffffffff800e5110 mod 0x1000) == 0x110

and

(0x0000000000c86c20 mod 0x1000) == (0xffffffff80c87c20 mod 0x1000) == 0xc20

If it were just some ELF binary it would work fine.
Does FreeBSD bootloader require segments to start on page boundary? Did you check this?

[grimar]

In D23505#516296, @evgeny777 wrote:

If it were just some ELF binary it would work fine.
Does FreeBSD bootloader require segments to start on page boundary? Did you check this?

Nope. Why some binary would work fine ?

Type           Offset             VirtAddr           PhysAddr
                 FileSiz            MemSiz              Flags  Align
LOAD           0x00000000000e4110 0xffffffff800e5110 0xffffffff800e5110
                0x0000000000ba2b0c 0x0000000000ba2b0c  R E    1000
LOAD           0x0000000000c86c20 0xffffffff80c87c20 0xffffffff80c87c20
                0x000000000038ab28 0x000000000038ab28  R      1000

End of first load is :
0xffffffff800e5110 + 0x0000000000ba2b0c = FFFFFFFF80C87C1C

It shares the same memory page with the second load at 0xffffffff80c87c20,
though they have different access attributes.

Should this really work fine ?

[evgeny777]

Nope. Why some binary would work fine ?

Well at least it will be loaded by the kernel. I didn't mean actual result of execution.

End of first load is :

That's the problem, yes, but initially you talked about "aligning to memory page", not overlapping. May be just adding one page to
3rd segment VA will fix the problem, no?

[grimar]

In D23505#516380, @evgeny777 wrote:

Nope. Why some binary would work fine ?

Well at least it will be loaded by the kernel. I didn't mean actual result of execution.

I guess since this patch looks the same with ld, it should solve whole problem, but not the part.

End of first load is :

That's the problem, yes, but initially you talked about "aligning to memory page", not overlapping. May be just adding one page to
3rd segment VA will fix the problem, no?

That option is mentioned in the end of description of the patch. And in one of my comments above ("will create more loads and waste more VA space").
Looks we might need 2M memory page size (D23352) and creating tons of loads does not look a good option for me.

[evgeny777]

I see, but you're suggesting merging segment attributes which is a potential security hole. May be for FreeBSD kernel this is just fine, but doing this always?

[grimar]

In D23505#516418, @evgeny777 wrote:

I see, but you're suggesting merging segment attributes which is a potential security hole. May be for FreeBSD kernel this is just fine, but doing this always?

I think security hole is mostly about when segment is Writable + Executable. This patch does not do that.
I do not think that combine of Readable + Executable is critical. At least looks like ld do that many years.

[ruiu]

ELF/Writer.cpp

968

I do not understand. Why it is guaranteed that writable sections are written after all other sections? If you are using linker scripts, you have a full control over the section layout, so you can put read-only sections before writable sections.

In addition to that, probably needless to say, but doing the same thing as ld does is not the ultimate goal. It's an important goal, but the ultimate goal should be to implement a logic that we understand and can justify. The last part is important. (So, we don't want to say "we don't know why, but this is what ld does, so do we.")

[grimar]

ELF/Writer.cpp

968

I do not understand. Why it is guaranteed that writable sections are written after all other sections? If you are using linker scripts, you have a full >control over the section layout, so you can put read-only sections before writable sections.

It is not quaranteed. Using linkerscript you can do whatever you want, even useless things. At fact ld looks always create 2 loads which are text and data. At least that means that:

1. This should met everybodies needs as programs in the wild that use ld works with this behavior.
2. It is probably makes no sence to mix or reorder sections in the way when writable are not after readable, just because it was impossible with ld, what I guess means nobody wants and use that.
3. This approach of 2 loads instead N simplifies things.
4. If you want full control over headers you always can use PHDRS command.

In addition to that, probably needless to say, but doing the same thing as ld does is not the ultimate goal. It's an important goal, but the ultimate >goal should be to implement a logic that we understand and can justify. The last part is important. (So, we don't want to say "we don't know why, >but this is what ld does, so do we.")

Sure. My point is ld behavior is just simpler and looks is enough for users, so see no reasons why not to use it. Spec says "The linker will create reasonable program headers by default". From what we see when linking such programs like FreeBSD kernel, lld creates 4 PT_LOADS when ld 2. Question is what is more reasonable and why we create something that looks not really needed ?

[ruiu]

ELF/Writer.cpp

968

I don't think none of your arguments justify the behavior you are implementing here. How would you describe to the user why we merge section A and B if A is read-only and B is writable but don't merge if A is writable and B is read-only?

If we don't want to merge read-only sections with writable sections, we always put them in separate segments. If not, we should merge them. The proposed behavior seems inconsistent and hard to justify.

[grimar]

ELF/Writer.cpp

968

I don't think none of your arguments justify the behavior you are implementing here. How would you describe to the user why we merge section > A and B if A is read-only and B is writable but don't merge if A is writable and B is read-only?

This patch merges all sections before first writable to first segment, we can call it "text segment". All other following sections no matter of their flags are placed to another segment ("data segment"). There is no any inconsistency here, behavior is always to do that.
It is much easier than have multiple segments and care about proper memory page alignment for all of them in script.

If we don't want to merge read-only sections with writable sections, we always put them in separate segments. If not, we should merge them. The proposed behavior seems inconsistent and hard to justify.

[ruiu]

ELF/Writer.cpp

968

I think I still do not understand why you want it. What's the motivation to implement this logic? Do you have a program that doesn't work without this change?

[grimar]

ELF/Writer.cpp

968

Nope. Initially I thought that FreeBSD kernel needs this, but looks it lives fine without.
I am almost sure there are such programms but I do not know any, so I think I have no solid motivation (except except my faith in idea of 2 loads). I'll abandon this for now.

ELF/Writer.cpp

private:
   void createSections();
   void forEachRelSec(
       std::function<void(InputSectionBase<ELFT> &, const typename ELFT::Shdr &)>
           Fn);
   void finalizeSections();
   void addPredefinedSections();
   bool needsGot();
 
+  void createLoads(std::vector<Phdr>& Dest);
   std::vector<Phdr> createPhdrs();
+  void createLinkerscriptLoads(std::vector<Phdr> &Dest);
   void assignAddresses();
   void assignFileOffsets();
   void setPhdrs();
   void fixHeaders();
   void fixSectionAlignments();
   void fixAbsoluteSymbols();
   void openFile();
   void writeHeader();
template <class ELFT> static bool needsPtLoad(OutputSectionBase<ELFT> *Sec) {
   // Don't allocate VA space for TLS NOBITS sections. The PT_TLS PHDR is
   // responsible for allocating space for them, not the PT_LOAD that
   // contains the TLS initialization image.
   if (Sec->getFlags() & SHF_TLS && Sec->getType() == SHT_NOBITS)
     return false;
   return true;
 }
 
+template <class ELFT>
+static PhdrEntry<ELFT> *addHdr(std::vector<PhdrEntry<ELFT>> &Dest,
+                               unsigned Type, unsigned Flags) {
+  Dest.emplace_back(Type, Flags);
+  return &Dest.back();
+}
+
+template <class ELFT> void Writer<ELFT>::createLoads(std::vector<Phdr> &Dest) {
+  // Add the first PT_LOAD segment for regular output sections.
+  uintX_t Flags = PF_R;
+  Phdr *Load = addHdr(Dest, PT_LOAD, Flags);
+  Load->add(Out<ELFT>::ElfHeader);
+  Load->add(Out<ELFT>::ProgramHeaders);
+
+  for (OutputSectionBase<ELFT> *Sec : OutputSections) {
+    if (!needsPtLoad(Sec))
+      continue;
+
+    // If flags changed then we want new load segment.
+    uintX_t NewFlags = Sec->getPhdrFlags();
+    if (Flags != NewFlags) {
+      Load = addHdr(Dest, PT_LOAD, NewFlags);
+      Flags = NewFlags;
+    }
+
+    Load->add(Sec);
+  }
+}
+
+template <class ELFT>
+void Writer<ELFT>::createLinkerscriptLoads(std::vector<Phdr> &Dest) {
+  // Create text segment. All non-writable sections will be put inside.
+  Phdr *Load = addHdr(Dest, PT_LOAD, PF_R);
+  Load->add(Out<ELFT>::ElfHeader);
+  Load->add(Out<ELFT>::ProgramHeaders);
+
+  for (OutputSectionBase<ELFT> *Sec : OutputSections) {
+    if (!needsPtLoad(Sec))
+      continue;
+
+    // If current load is not writable and we met section that is
+    // writable, create new data segment to place this and all following
+    // sections to.
+    uintX_t NewFlags = Sec->getPhdrFlags();
+    if (((Load->H.p_flags & PF_W) == 0) && ((NewFlags & PF_W) != 0))
+      Load = addHdr(Dest, PT_LOAD, NewFlags);
+
+    // Merge access flags and add section to load.
+    Load->H.p_flags |= NewFlags;
+    Load->add(Sec);
+  }
+}
+
 // Decide which program headers to create and which sections to include in each
 // one.
-template <class ELFT>
-std::vector<PhdrEntry<ELFT>> Writer<ELFT>::createPhdrs() {
+template <class ELFT> std::vector<PhdrEntry<ELFT>> Writer<ELFT>::createPhdrs() {
   std::vector<Phdr> Ret;
 
-  auto AddHdr = [&](unsigned Type, unsigned Flags) -> Phdr * {
-    Ret.emplace_back(Type, Flags);
-    return &Ret.back();
-  };
-
   // The first phdr entry is PT_PHDR which describes the program header itself.
-  Phdr &Hdr = *AddHdr(PT_PHDR, PF_R);
+  Phdr &Hdr = *addHdr(Ret, PT_PHDR, PF_R);
   Hdr.add(Out<ELFT>::ProgramHeaders);
 
   // PT_INTERP must be the second entry if exists.
   if (Out<ELFT>::Interp) {
-    Phdr &Hdr = *AddHdr(PT_INTERP, Out<ELFT>::Interp->getPhdrFlags());
+    Phdr &Hdr = *addHdr(Ret, PT_INTERP, Out<ELFT>::Interp->getPhdrFlags());
     Hdr.add(Out<ELFT>::Interp);
   }
 
-  // Add the first PT_LOAD segment for regular output sections.
-  uintX_t Flags = PF_R;
-  Phdr *Load = AddHdr(PT_LOAD, Flags);
-  Load->add(Out<ELFT>::ElfHeader);
-  Load->add(Out<ELFT>::ProgramHeaders);
+  if (ScriptConfig->HasContents)
+    createLinkerscriptLoads(Ret);
+  else
+    createLoads(Ret);
 
   Phdr TlsHdr(PT_TLS, PF_R);
   Phdr RelRo(PT_GNU_RELRO, PF_R);
   Phdr Note(PT_NOTE, PF_R);
   for (OutputSectionBase<ELFT> *Sec : OutputSections) {
     if (!(Sec->getFlags() & SHF_ALLOC))
       break;
 
     // If we meet TLS section then we create TLS header
     // and put all TLS sections inside for futher use when
     // assign addresses.
     if (Sec->getFlags() & SHF_TLS)
       TlsHdr.add(Sec);
 
     if (!needsPtLoad(Sec))
       continue;
 
-    // If flags changed then we want new load segment.
-    uintX_t NewFlags = Sec->getPhdrFlags();
-    if (Flags != NewFlags) {
-      Load = AddHdr(PT_LOAD, NewFlags);
-      Flags = NewFlags;
-    }
-
-    Load->add(Sec);
-
     if (isRelroSection(Sec))
       RelRo.add(Sec);
     if (Sec->getType() == SHT_NOTE)
       Note.add(Sec);
   }
 
   // Add the TLS segment unless it's empty.
   if (TlsHdr.First)
     Ret.push_back(std::move(TlsHdr));
 
   // Add an entry for .dynamic.
   if (Out<ELFT>::DynSymTab) {
-    Phdr &H = *AddHdr(PT_DYNAMIC, Out<ELFT>::Dynamic->getPhdrFlags());
+    Phdr &H = *addHdr(Ret, PT_DYNAMIC, Out<ELFT>::Dynamic->getPhdrFlags());
     H.add(Out<ELFT>::Dynamic);
   }
 
   // PT_GNU_RELRO includes all sections that should be marked as
   // read-only by dynamic linker after proccessing relocations.
   if (RelRo.First)
     Ret.push_back(std::move(RelRo));
 
   // PT_GNU_EH_FRAME is a special section pointing on .eh_frame_hdr.
   if (!Out<ELFT>::EhFrame->empty() && Out<ELFT>::EhFrameHdr) {
-    Phdr &Hdr = *AddHdr(PT_GNU_EH_FRAME, Out<ELFT>::EhFrameHdr->getPhdrFlags());
+    Phdr &Hdr =
+        *addHdr(Ret, PT_GNU_EH_FRAME, Out<ELFT>::EhFrameHdr->getPhdrFlags());
     Hdr.add(Out<ELFT>::EhFrameHdr);
   }
 
   // PT_GNU_STACK is a special section to tell the loader to make the
   // pages for the stack non-executable.
   if (!Config->ZExecStack)
-    AddHdr(PT_GNU_STACK, PF_R | PF_W);
+    addHdr(Ret, PT_GNU_STACK, PF_R | PF_W);
 
   if (Note.First)
     Ret.push_back(std::move(Note));
   return Ret;
 }
 
 // The first section of each PT_LOAD and the first section after PT_GNU_RELRO
 // have to be page aligned so that the dynamic linker can set the permissions.

test/ELF/arm-blx.s

  .arm
  .balign 0x100
  .type callee_arm_high,%function
 callee_arm_high:
   bx lr
 
 // CHECK-THUMB: Disassembly of section .callee1:
 // CHECK-THUMB-NEXT: callee_low:
-// CHECK-THUMB-NEXT:    b4:       70 47   bx      lr
+// CHECK-THUMB-NEXT:    94:       70 47   bx      lr
 // CHECK-THUMB: callee_low2:
-// CHECK-THUMB-NEXT:    b6:       70 47   bx      lr
+// CHECK-THUMB-NEXT:    96:       70 47   bx      lr
 
 // CHECK-ARM: Disassembly of section .callee2:
 // CHECK-ARM-NEXT: callee_arm_low:
 // CHECK-ARM-NEXT:    100:        1e ff 2f e1     bx      lr
 
 // CHECK-ARM: Disassembly of section .caller:
 // CHECK-ARM-NEXT: _start:
-// CHECK-ARM-NEXT:   10000:       2b c0 ff fa     blx     #-65364 <callee_low>
-// CHECK-ARM-NEXT:   10004:       2a c0 ff fa     blx     #-65368 <callee_low>
-// CHECK-ARM-NEXT:   10008:       29 c0 ff fb     blx     #-65370 <callee_low2>
-// CHECK-ARM-NEXT:   1000c:       28 c0 ff fb     blx     #-65374 <callee_low2>
+// CHECK-ARM-NEXT:   10000:       23 c0 ff fa     blx     #-65396 <callee_low>
+// CHECK-ARM-NEXT:   10004:       22 c0 ff fa     blx     #-65400 <callee_low>
+// CHECK-ARM-NEXT:   10008:       21 c0 ff fb     blx     #-65402 <callee_low2>
+// CHECK-ARM-NEXT:   1000c:       20 c0 ff fb     blx     #-65406 <callee_low2>
 // CHECK-ARM-NEXT:   10010:       3a 00 00 fa     blx     #232 <callee_high>
 // CHECK-ARM-NEXT:   10014:       39 00 00 fa     blx     #228 <callee_high>
 // CHECK-ARM-NEXT:   10018:       38 00 00 fb     blx     #226 <callee_high2>
 // CHECK-ARM-NEXT:   1001c:       37 00 00 fb     blx     #222 <callee_high2>
 // 10020 + 1FFFFFC + 8 = 0x2010024 = blx_far
 // CHECK-ARM-NEXT:   10020:       ff ff 7f fa     blx     #33554428
 // 10024 + 1FFFFFC + 8 = 0x2010028 = blx_far2
 // CHECK-ARM-NEXT:   10024:       ff ff 7f fa     blx     #33554428

test/ELF/arm-branch.s

 // RUN: llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi %s -o %t
 // RUN: llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi %S/Inputs/far-arm-abs.s -o %tfar
 // RUN: echo "SECTIONS { \
 // RUN:          .callee1 : { *(.callee_low) } \
 // RUN:          .caller : { *(.text) } \
 // RUN:          .callee2 : { *(.callee_high) } } " > %t.script
 // RUN: ld.lld --script %t.script %t %tfar -o %t2 2>&1
-// RUN: llvm-objdump -d -triple=armv7a-none-linux-gnueabi %t2 | FileCheck  %s
+// RUN: llvm-objdump -s -d -triple=armv7a-none-linux-gnueabi %t2 | FileCheck  %s
 // REQUIRES: arm
  .syntax unified
  .section .callee_low, "ax",%progbits
  .align 2
  .type callee_low,%function
 callee_low:
  bx lr
 

  .section .callee_high, "ax",%progbits
  .align 2
  .type callee_high,%function
 callee_high:
  bx lr
 
 // CHECK: Disassembly of section .caller:
 // CHECK-NEXT: _start:
-// S(callee_low) = 0xb4 P = 0x10000 A = -8 = -0xff54 = -65364
-// CHECK-NEXT:   10000:       2b c0 ff eb          bl      #-65364 <callee_low>
-// S(callee_low) = 0xb4 P = 0x10004 A = -8 = -0xff58 = -65368
-// CHECK-NEXT:   10004:       2a c0 ff ea          b       #-65368 <callee_low>
-// S(callee_low) = 0xb4 P = 0x10008 A = -8 = -0xff5c -65372
-// CHECK-NEXT:   10008:       29 c0 ff 0a          beq     #-65372 <callee_low>
+// S(callee_low) = 0x94 P = 0x10000 A = -8 = -0xff74 = -65364
+// CHECK-NEXT:   10000:       23 c0 ff eb          bl      #-65396 <callee_low>
+// S(callee_low) = 0x94 P = 0x10004 A = -8 = -0xff78 = -65400
+// CHECK-NEXT:   10004:       22 c0 ff ea          b       #-65400 <callee_low>
+// S(callee_low) = 0x94 P = 0x10008 A = -8 = -0xff7c = -65404
+// CHECK-NEXT:   10008:       21 c0 ff 0a          beq     #-65404 <callee_low>
 // S(callee_high) = 0x10028 P = 0x1000c A = -8 = 0x14 = 20
 // CHECK-NEXT:   1000c:       05 00 00 eb          bl      #20 <callee_high>
 // S(callee_high) = 0x10028 P = 0x10010 A = -8 = 0x10 = 16
 // CHECK-NEXT:   10010:       04 00 00 ea          b       #16 <callee_high>
 // S(callee_high) = 0x10028 P = 0x10014 A = -8 = 0x0c =12
 // CHECK-NEXT:   10014:       03 00 00 1a          bne     #12 <callee_high>
 // S(far) = 0x201001c P = 0x10018 A = -8 = 0x1fffffc = 33554428
 // CHECK-NEXT:   10018:       ff ff 7f eb          bl      #33554428
 // S(far) = 0x201001c P = 0x1001c A = -8 = 0x1fffff8 = 33554424
 // CHECK-NEXT:   1001c:       fe ff 7f ea          b       #33554424
 // S(far) = 0x201001c P = 0x10020 A = -8 = 0x1fffff4 = 33554420
 // CHECK-NEXT:   10020:       fd ff 7f ca          bgt     #33554420
 // CHECK-NEXT:   10024:       1e ff 2f e1          bx      lr

test/ELF/arm-thumb-branch.s

  .section .callee_high, "ax",%progbits
  .align 2
  .type callee_high,%function
 callee_high:
  bx lr
 
 // CHECK: Disassembly of section .callee1:
 // CHECK-NEXT: callee_low:
-// CHECK-NEXT:      b4:       70 47   bx      lr
+// CHECK-NEXT:      94:       70 47   bx      lr
 // CHECK-NEXT: Disassembly of section .caller:
 // CHECK-NEXT: _start:
-// CHECK-NEXT:   10000:       f0 f7 58 f8     bl      #-65360
-// CHECK-NEXT:   10004:       f0 f7 56 b8     b.w     #-65364
-// CHECK-NEXT:   10008:       30 f4 54 a8     beq.w   #-65368
+// CHECK-NEXT:   10000:       f0 f7 48 f8     bl      #-65392
+// CHECK-NEXT:   10004:       f0 f7 46 b8     b.w     #-65396
+// CHECK-NEXT:   10008:       30 f4 44 a8     beq.w   #-65400
 // CHECK-NEXT:   1000c:       00 f0 0c f8     bl      #24
 // CHECK-NEXT:   10010:       00 f0 0a b8     b.w     #20
 // CHECK-NEXT:   10014:       40 f0 08 80     bne.w   #16
 // CHECK-NEXT:   10018:       ff f3 ff d7     bl      #16777214
 // CHECK-NEXT:   1001c:       ff f3 fd 97     b.w     #16777210
 // CHECK-NEXT:   10020:       3f f3 ff af     bgt.w   #1048574
 // CHECK-NEXT:   10024:       70 47   bx      lr
 // CHECK-NEXT:   10026:       00 00   movs    r0, r0
 // CHECK-NEXT: Disassembly of section .callee2:
 // CHECK-NEXT: callee_high:
 // CHECK-NEXT:   10028:       70 47   bx      lr

test/ELF/linkerscript/linkerscript-common.s

 # CHECK:         Index: 1
 # CHECK-NEXT:    Name: .common (1)
 # CHECK-NEXT:    Type: SHT_NOBITS (0x8)
 # CHECK-NEXT:    Flags [ (0x3)
 # CHECK-NEXT:      SHF_ALLOC (0x2)
 # CHECK-NEXT:      SHF_WRITE (0x1)
 # CHECK-NEXT:    ]
 # CHECK-NEXT:    Address: 0x200
-# CHECK-NEXT:    Offset: 0x158
+# CHECK-NEXT:    Offset: 0x120
 # CHECK-NEXT:    Size: 256
 # CHECK-NEXT:    Link: 0
 # CHECK-NEXT:    Info: 0
 # CHECK-NEXT:    AddressAlignment: 256
 # CHECK-NEXT:    EntrySize: 0
 # CHECK-NEXT:  }
 # CHECK:       Symbol {
 # CHECK:         Name: q1 (8)

test/ELF/linkerscript/linkerscript-excludefile.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux \
 # RUN:   %p/Inputs/include.s -o %t2
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux \
 # RUN:   %p/Inputs/notinclude.s -o %t3.notinclude
 
 # RUN: echo "SECTIONS {} " > %t.script
 # RUN: ld.lld -o %t --script %t.script %t1 %t2 %t3.notinclude
 # RUN: llvm-objdump -d %t | \
 # RUN:   FileCheck %s
 
 # CHECK: Disassembly of section .text:
 # CHECK: _start:
-# CHECK:      120:       48 c7 c0 3c 00 00 00    movq    $60, %rax
-# CHECK:      127:       48 c7 c7 2a 00 00 00    movq    $42, %rdi
-# CHECK:      12e:       00 00   addb    %al, (%rax)
+# CHECK:      e8:        48 c7 c0 3c 00 00 00    movq    $60, %rax
+# CHECK:      ef:        48 c7 c7 2a 00 00 00    movq    $42, %rdi
+# CHECK:      f6:        00 00   addb    %al, (%rax)
 # CHECK: _potato:
-# CHECK:      130:       90      nop
-# CHECK:      131:       90      nop
-# CHECK:      132:       00 00   addb    %al, (%rax)
+# CHECK:      f8:       90      nop
+# CHECK:      f9:       90      nop
+# CHECK:      fa:       00 00   addb    %al, (%rax)
 # CHECK: tomato:
-# CHECK:      134:       b8 01 00 00 00  movl    $1, %eax
+# CHECK:      fc:       b8 01 00 00 00  movl    $1, %eax
 
 # RUN: echo "SECTIONS { .patatino : \
 # RUN: { KEEP(*(EXCLUDE_FILE(*notinclude) .text)) } }" \
 # RUN:  > %t.script
 # RUN: ld.lld -o %t2 --script %t.script %t1 %t2 %t3.notinclude
 # RUN: llvm-objdump -d %t2 | \
 # RUN:   FileCheck %s --check-prefix=EXCLUDE
 
 # EXCLUDE: Disassembly of section .patatino:
 # EXCLUDE: _start:
-# EXCLUDE:      120:       48 c7 c0 3c 00 00 00    movq    $60, %rax
-# EXCLUDE:      127:       48 c7 c7 2a 00 00 00    movq    $42, %rdi
-# EXCLUDE:      12e:       00 00   addb    %al, (%rax)
+# EXCLUDE:      e8:       48 c7 c0 3c 00 00 00    movq    $60, %rax
+# EXCLUDE:      ef:       48 c7 c7 2a 00 00 00    movq    $42, %rdi
+# EXCLUDE:      f6:       00 00   addb    %al, (%rax)
 # EXCLUDE: _potato:
-# EXCLUDE:      130:       90      nop
-# EXCLUDE:      131:       90      nop
+# EXCLUDE:      f8:       90      nop
+# EXCLUDE:      f9:       90      nop
 # EXCLUDE: Disassembly of section .text:
 # EXCLUDE: tomato:
-# EXCLUDE:      134:       b8 01 00 00 00  movl    $1, %eax
+# EXCLUDE:      fc:       b8 01 00 00 00  movl    $1, %eax
 
 .section .text
 .globl _start
 _start:
     mov $60, %rax
     mov $42, %rdi

test/ELF/linkerscript/linkerscript-filename-spec.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %tfirst.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux \
 # RUN:   %p/Inputs/linkerscript-filename-spec.s -o %tsecond.o
 
 # RUN: echo "SECTIONS { .foo : { \
 # RUN:   KEEP(*first.o(.foo)) \
 # RUN:   KEEP(*second.o(.foo)) } }" > %t1.script
 # RUN: ld.lld -o %t1 --script %t1.script %tfirst.o %tsecond.o
 # RUN: llvm-objdump -s %t1 | FileCheck --check-prefix=FIRSTSECOND %s
 # FIRSTSECOND:      Contents of section .foo:
-# FIRSTSECOND-NEXT:   0120 01000000 00000000 11000000 00000000
+# FIRSTSECOND-NEXT:  01000000 00000000 11000000 00000000
 
 # RUN: echo "SECTIONS { .foo : { \
 # RUN:   KEEP(*second.o(.foo)) \
 # RUN:   KEEP(*first.o(.foo)) } }" > %t2.script
 # RUN: ld.lld -o %t2 --script %t2.script %tfirst.o %tsecond.o
 # RUN: llvm-objdump -s %t2 | FileCheck --check-prefix=SECONDFIRST %s
 # SECONDFIRST:      Contents of section .foo:
-# SECONDFIRST-NEXT:   0120 11000000 00000000 01000000 00000000
+# SECONDFIRST-NEXT:  11000000 00000000 01000000 00000000
 
 ## Now the same tests but without KEEP. Checking that file name inside
 ## KEEP is parsed fine.
 # RUN: echo "SECTIONS { .foo : { \
 # RUN:   *first.o(.foo) \
 # RUN:   *second.o(.foo) } }" > %t3.script
 # RUN: ld.lld -o %t3 --script %t3.script %tfirst.o %tsecond.o
 # RUN: llvm-objdump -s %t3 | FileCheck --check-prefix=FIRSTSECOND %s

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

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 
 # RUN: echo "SECTIONS { .foo : { *(.foo.*) } }" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -s %t1 | FileCheck %s
 # CHECK:      Contents of section .foo:
-# CHECK-NEXT:  0158 01000000 02000000 00000000 73686f72  ............shor
-# CHECK-NEXT:  0168 7420756e 7369676e 65642069 6e7400    t unsigned int.
+# CHECK-NEXT:  01000000 02000000 00000000 73686f72  ............shor
+# CHECK-NEXT:  7420756e 7369676e 65642069 6e7400    t unsigned int.
 
 .global _start
 _start:
   nop
 
 .section .foo.1, "aw"
 writable:
  .long 1

test/ELF/linkerscript/linkerscript-ptloads.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+# RUN: echo "SECTIONS {                   \
+# RUN:  . = ALIGN(CONSTANT(MAXPAGESIZE)); \
+# RUN:  .A : { *(.A.1) }                  \
+# RUN:  . = ALIGN(CONSTANT(MAXPAGESIZE)); \
+# RUN:  .AX : { *(.AX.1) }                \
+# RUN:  . = ALIGN(CONSTANT(MAXPAGESIZE)); \
+# RUN:  .AW : { *(.AW.1) }                \
+# RUN:  . = ALIGN(CONSTANT(MAXPAGESIZE)); \
+# RUN:  .A2 : { *(.A.2) }                 \
+# RUN:  . = ALIGN(CONSTANT(MAXPAGESIZE)); \
+# RUN:  .AX2 : { *(.AX.2) }               \
+# RUN:  . = ALIGN(CONSTANT(MAXPAGESIZE)); \
+# RUN:  .AW2 : { *(.AW.2) }               \
+# RUN:  }" > %t.script
+
+# RUN: ld.lld -o %t1 --script %t.script %t
+# RUN: llvm-readobj -s -program-headers %t1 | \
+# RUN:   FileCheck %s --check-prefix=HEADERS
+# RUN: llvm-objdump -section-headers %t1 | \
+# RUN:  FileCheck %s --check-prefix=SEC
+# HEADERS:      ProgramHeader {
+# HEADERS:        Type: PT_LOAD
+# HEADERS-NEXT:   Offset: 0x0
+# HEADERS-NEXT:   VirtualAddress: 0x0
+# HEADERS-NEXT:   PhysicalAddress: 0x0
+# HEADERS-NEXT:   FileSize: 8200
+# HEADERS-NEXT:   MemSize: 8200
+# HEADERS-NEXT:   Flags [
+# HEADERS-NEXT:     PF_R
+# HEADERS-NEXT:     PF_X
+# HEADERS-NEXT:   ]
+# HEADERS-NEXT:   Alignment: 4096
+# HEADERS-NEXT: }
+# HEADERS-NEXT: ProgramHeader {
+# HEADERS-NEXT:   Type: PT_LOAD
+# HEADERS-NEXT:   Offset: 0x3000
+# HEADERS-NEXT:   VirtualAddress: 0x3000
+# HEADERS-NEXT:   PhysicalAddress: 0x3000
+# HEADERS-NEXT:   FileSize: 12297
+# HEADERS-NEXT:   MemSize: 12297
+# HEADERS-NEXT:   Flags [
+# HEADERS-NEXT:     PF_R
+# HEADERS-NEXT:     PF_W
+# HEADERS-NEXT:     PF_X
+# HEADERS-NEXT:   ]
+# HEADERS-NEXT:   Alignment: 4096
+# HEADERS-NEXT: }
+# SEC:         Sections:
+# SEC-NEXT:    Idx Name          Size      Address          Type
+# SEC-NEXT:      0               00000000 0000000000000000
+# SEC-NEXT:      1 .A            00000008 0000000000001000 DATA
+# SEC-NEXT:      2 .AX           00000008 0000000000002000 TEXT DATA
+# SEC-NEXT:      3 .AW           00000008 0000000000003000 DATA
+# SEC-NEXT:      4 .A2           00000008 0000000000004000 DATA
+# SEC-NEXT:      5 .AX2          00000008 0000000000005000 TEXT DATA
+# SEC-NEXT:      6 .AW2          00000008 0000000000006000 DATA
+# SEC-NEXT:      7 .text         00000001 0000000000006008 TEXT DATA
+# SEC-NEXT:      8 .symtab       00000030 0000000000000000
+# SEC-NEXT:      9 .shstrtab     0000003a 0000000000000000
+# SEC-NEXT:     10 .strtab       00000008 0000000000000000
+
+.global _start
+_start:
+ nop
+
+.section .AX.1,"ax"
+.quad 1
+
+.section .A.1,"a"
+.quad 2
+
+.section .AW.1,"aw"
+.quad 3
+
+.section .AX.2,"ax"
+.quad 1
+
+.section .A.2,"a"
+.quad 2
+
+.section .AW.2,"aw"
+.quad 3
+

test/ELF/linkerscript/linkerscript-repsection-va.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 
 # RUN: echo "SECTIONS {.foo : {*(.foo.*)} }" > %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          00000008 0000000000000120 DATA
-# CHECK-NEXT:   2 .text         00000001 0000000000000128 TEXT DATA
+# CHECK-NEXT:   1 .foo          00000008 00000000000000e8 DATA
+# CHECK-NEXT:   2 .text         00000001 00000000000000f0 TEXT DATA
 
 .global _start
 _start:
  nop
 
 .section .foo.1,"a"
 foo1:
  .long 0
 
 .section .foo.2,"aw"
 foo2:
  .long 0

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-NEXT:   1 .writable     00000004 0000000000000120 DATA
+# BASE-NEXT:   2 .readable     00000004 0000000000000124 DATA
 
 # 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 0000000000000120 DATA
+# NO1-NEXT: 2 .readable     00000004 0000000000000124 DATA
+# NO1-NEXT: 3 .text         00000001 0000000000000128 TEXT DATA
+# NO1-NEXT: 4 .foo.2        00000004 0000000000000129 DATA
+# NO1-NEXT: 5 .foo.1        00000004 000000000000012d TEXT DATA
 
 .global _start
 _start:
   nop
 
 .section .writable, "aw"
 writable:
  .long 1

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

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 
 ## First check that section "keep" is garbage collected without using KEEP
 # RUN: echo "SECTIONS { \
 # RUN:  .text : { *(.text) } \
 # RUN:  .keep : { *(.keep) } \
 # RUN:  .temp : { *(.temp) }}" > %t.script
 # RUN: ld.lld --gc-sections -o %t1 --script %t.script %t
 # RUN: llvm-objdump -section-headers %t1 | \
 # RUN:   FileCheck -check-prefix=SECGC %s
 # SECGC:      Sections:
 # SECGC-NEXT: Idx Name          Size      Address          Type
 # SECGC-NEXT:   0               00000000 0000000000000000
-# SECGC-NEXT:   1 .text         00000007 0000000000000158 TEXT DATA
-# SECGC-NEXT:   2 .temp         00000004 000000000000015f DATA
+# SECGC-NEXT:   1 .text         00000007 00000000000000e8 TEXT DATA
+# SECGC-NEXT:   2 .temp         00000004 00000000000000ef DATA
 
 ## Now apply KEEP command to preserve the section.
 # RUN: echo "SECTIONS { \
 # RUN:  .text : { *(.text) } \
 # RUN:  .keep : { KEEP(*(.keep)) } \
 # RUN:  .temp : { *(.temp) }}" > %t.script
 # RUN: ld.lld --gc-sections -o %t1 --script %t.script %t
 # RUN: llvm-objdump -section-headers %t1 | \
 # RUN:   FileCheck -check-prefix=SECNOGC %s
 # SECNOGC:      Sections:
 # SECNOGC-NEXT: Idx Name          Size      Address          Type
 # SECNOGC-NEXT:   0               00000000 0000000000000000
-# SECNOGC-NEXT:   1 .text         00000007 0000000000000158 TEXT DATA
-# SECNOGC-NEXT:   2 .keep         00000004 000000000000015f DATA
-# SECNOGC-NEXT:   3 .temp         00000004 0000000000000163 DATA
+# SECNOGC-NEXT:   1 .text         00000007 00000000000000e8 TEXT DATA
+# SECNOGC-NEXT:   2 .keep         00000004 00000000000000ef DATA
+# SECNOGC-NEXT:   3 .temp         00000004 00000000000000f3 DATA
 
 ## A section name matches two entries in the SECTIONS directive. The
 ## first one doesn't have KEEP, the second one does. If section that have
 ## KEEP is the first in order then section is NOT collected.
 # RUN: echo "SECTIONS { \
 # RUN:  .keep : { KEEP(*(.keep)) } \
 # RUN:  .nokeep : { *(.keep) }}" > %t.script
 # RUN: ld.lld --gc-sections -o %t1 --script %t.script %t
 # RUN: llvm-objdump -section-headers %t1 | FileCheck -check-prefix=MIXED1 %s
 # MIXED1:      Sections:
 # MIXED1-NEXT: Idx Name          Size      Address         Type
 # MIXED1-NEXT:   0               00000000 0000000000000000
-# MIXED1-NEXT:   1 .keep         00000004 0000000000000120 DATA
-# MIXED1-NEXT:   2 .temp         00000004 0000000000000124 DATA
-# MIXED1-NEXT:   3 .text         00000007 0000000000000128 TEXT DATA
+# MIXED1-NEXT:   1 .keep         00000004 00000000000000e8 DATA
+# MIXED1-NEXT:   2 .temp         00000004 00000000000000ec DATA
+# MIXED1-NEXT:   3 .text         00000007 00000000000000f0 TEXT DATA
 # MIXED1-NEXT:   4 .symtab       00000060 0000000000000000
 # MIXED1-NEXT:   5 .shstrtab     0000002d 0000000000000000
 # MIXED1-NEXT:   6 .strtab       00000012 0000000000000000
 
 ## The same, but now section without KEEP is at first place.
 ## gold and bfd linkers disagree here. gold collects .keep while
 ## bfd keeps it. Our current behavior is compatible with bfd although
 ## we can choose either way.
 # RUN: echo "SECTIONS { \
 # RUN:  .nokeep : { *(.keep) } \
 # RUN:  .keep : { KEEP(*(.keep)) }}" > %t.script
 # RUN: ld.lld --gc-sections -o %t1 --script %t.script %t
 # RUN: llvm-objdump -section-headers %t1 | FileCheck -check-prefix=MIXED2 %s
 # MIXED2:      Sections:
 # MIXED2-NEXT: Idx Name          Size      Address         Type
 # MIXED2-NEXT:   0               00000000 0000000000000000
-# MIXED2-NEXT:   1 .nokeep       00000004 0000000000000120 DATA
-# MIXED2-NEXT:   2 .temp         00000004 0000000000000124 DATA
-# MIXED2-NEXT:   3 .text         00000007 0000000000000128 TEXT DATA
+# MIXED2-NEXT:   1 .nokeep       00000004 00000000000000e8 DATA
+# MIXED2-NEXT:   2 .temp         00000004 00000000000000ec DATA
+# MIXED2-NEXT:   3 .text         00000007 00000000000000f0 TEXT DATA
 # MIXED2-NEXT:   4 .symtab       00000060 0000000000000000
 # MIXED2-NEXT:   5 .shstrtab     0000002f 0000000000000000
 # MIXED2-NEXT:   6 .strtab       00000012 0000000000000000
 
 .global _start
 _start:
  mov temp, %eax
 
 .section .keep, "a"
 keep:
  .long 1
 
 .section .temp, "a"
 temp:
  .long 2

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

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 
 ## Check that padding value works:
 # RUN: echo "SECTIONS { .mysec : { *(.mysec*) } =0x112233445566778899 }" > %t.script
 # RUN: ld.lld -o %t.out --script %t.script %t
 # RUN: llvm-objdump -s %t.out | FileCheck -check-prefix=YES %s
-# YES: 0120  66223344 55667788 99112233 44556677
+# YES: 00f0  66223344 55667788 99112233 44556677
 
 ## Confirming that address was correct:
 # RUN: echo "SECTIONS { .mysec : { *(.mysec*) } =0x998877665544332211 }" > %t.script
 # RUN: ld.lld -o %t.out --script %t.script %t
 # RUN: llvm-objdump -s %t.out | FileCheck -check-prefix=YES2 %s
-# YES2: 0120  66887766 55443322 11998877 66554433
+# YES2: 00f0  66887766 55443322 11998877 66554433
 
 ## Default padding value is 0x00:
 # RUN: echo "SECTIONS { .mysec : { *(.mysec*) } }" > %t.script
 # RUN: ld.lld -o %t.out --script %t.script %t
 # RUN: llvm-objdump -s %t.out | FileCheck -check-prefix=NO %s
-# NO: 0120  66000000 00000000 00000000 00000000
+# NO: 00f0  66000000 00000000 00000000 00000000
 
 ## Decimal value.
 # RUN: echo "SECTIONS { .mysec : { *(.mysec*) } =777 }" > %t.script
 # RUN: ld.lld -o %t.out --script %t.script %t
 # RUN: llvm-objdump -s %t.out | FileCheck -check-prefix=DEC %s
-# DEC: 0120  66000309 00000309 00000309 00000309
+# DEC: 00f0  66000309 00000309 00000309 00000309
 
 ## Invalid hex value:
 # RUN: echo "SECTIONS { .mysec : { *(.mysec*) } =0x99XX }" > %t.script
 # RUN: not ld.lld -o %t.out --script %t.script %t 2>&1 \
 # RUN:   | FileCheck --check-prefix=ERR2 %s
 # ERR2: not a hexadecimal value: XX
 
 .section        .mysec.1,"a"

test/ELF/linkerscript/linkerscript-sizeof.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 
 # RUN: echo "SECTIONS { \
 # RUN:   .aaa         : { *(.aaa) } \
 # RUN:   .bbb         : { *(.bbb) } \
 # RUN:   .ccc         : { *(.ccc) } \
 # RUN:   _aaa = SIZEOF(.aaa); \
 # RUN:   _bbb = SIZEOF(.bbb); \
 # RUN:   _ccc = SIZEOF(.ccc); \
 # RUN: }" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -t -section-headers %t1 | FileCheck %s
 # CHECK:      Sections:
 # CHECK-NEXT:  Idx Name          Size      Address          Type
 # CHECK-NEXT:    0               00000000 0000000000000000
-# CHECK-NEXT:    1 .aaa          00000008 0000000000000120 DATA
-# CHECK-NEXT:    2 .bbb          00000010 0000000000000128 DATA
-# CHECK-NEXT:    3 .ccc          00000018 0000000000000138 DATA
+# CHECK-NEXT:    1 .aaa          00000008 00000000000000e8 DATA
+# CHECK-NEXT:    2 .bbb          00000010 00000000000000f0 DATA
+# CHECK-NEXT:    3 .ccc          00000018 0000000000000100 DATA
 # CHECK:      SYMBOL TABLE:
 # CHECK-NEXT:  0000000000000000 *UND* 00000000
-# CHECK-NEXT:  0000000000000150 .text 00000000 _start
+# CHECK-NEXT:  0000000000000118 .text 00000000 _start
 # CHECK-NEXT:  0000000000000008 *ABS* 00000000 _aaa
 # CHECK-NEXT:  0000000000000010 *ABS* 00000000 _bbb
 # CHECK-NEXT:  0000000000000018 *ABS* 00000000 _ccc
 
 ## Check that we error out if trying to get size of
 ## section that does not exist.
 # RUN: echo "SECTIONS { \
 # RUN:   .aaa         : { *(.aaa) } \

test/ELF/linkerscript/linkerscript-sizeofheaders.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 # RUN: echo " SECTIONS {             \
 # RUN:          . = SIZEOF_HEADERS;  \
 # RUN:          _size = SIZEOF_HEADERS;  \
 # RUN:          .text : {*(.text*)} \
 # RUN:          }" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -t %t1 | FileCheck %s
 
 #CHECK:      SYMBOL TABLE:
 #CHECK-NEXT:  0000000000000000 *UND* 00000000
-#CHECK-NEXT:  0000000000000120 .text 00000000 _start
-#CHECK-NEXT:  0000000000000120 *ABS* 00000000 _size
+#CHECK-NEXT:  00000000000000e8 .text 00000000 _start
+#CHECK-NEXT:  00000000000000e8 *ABS* 00000000 _size
 
 .global _start
 _start:
  nop

test/ELF/linkerscript/linkerscript-sort-nested.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux \
 # RUN:   %p/Inputs/linkerscript-sort-nested.s -o %t2.o
 
 ## Check sorting first by alignment and then by name.
 # RUN: echo "SECTIONS { .aaa : { *(SORT_BY_ALIGNMENT(SORT_BY_NAME(.aaa.*))) } }" > %t1.script
 # RUN: ld.lld -o %t1 --script %t1.script %t1.o %t2.o
 # RUN: llvm-objdump -s %t1 | FileCheck -check-prefix=SORTED_AN %s
 # SORTED_AN:      Contents of section .aaa:
-# SORTED_AN-NEXT:   0120 01000000 00000000 00000000 00000000
-# SORTED_AN-NEXT:   0130 11000000 00000000 00000000 00000000
-# SORTED_AN-NEXT:   0140 55000000 00000000 22000000 00000000
-# SORTED_AN-NEXT:   0150 02000000 00000000
+# SORTED_AN-NEXT:   01000000 00000000 00000000 00000000
+# SORTED_AN-NEXT:   11000000 00000000 00000000 00000000
+# SORTED_AN-NEXT:   55000000 00000000 22000000 00000000
+# SORTED_AN-NEXT:   02000000 00000000
 
 ## Check sorting first by name and then by alignment.
 # RUN: echo "SECTIONS { .aaa : { *(SORT_BY_NAME(SORT_BY_ALIGNMENT(.aaa.*))) } }" > %t2.script
 # RUN: ld.lld -o %t2 --script %t2.script %t1.o %t2.o
 # RUN: llvm-objdump -s %t2 | FileCheck -check-prefix=SORTED_NA %s
 # SORTED_NA: Contents of section .aaa:
 # SORTED_NA:   01000000 00000000 00000000 00000000
 # SORTED_NA:   11000000 00000000 22000000 00000000

test/ELF/linkerscript/linkerscript-sort.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux \
 # RUN:   %p/Inputs/linkerscript-sort.s -o %t2.o
 
 # RUN: echo "SECTIONS { .aaa : { *(.aaa.*) } }" > %t1.script
 # RUN: ld.lld -o %t1 --script %t1.script %t2.o %t1.o
 # RUN: llvm-objdump -s %t1 | FileCheck -check-prefix=UNSORTED %s
 # UNSORTED:       Contents of section .aaa:
-# UNSORTED-NEXT:   0120 55000000 00000000 00000000 00000000
-# UNSORTED-NEXT:   0130 00000000 00000000 00000000 00000000
-# UNSORTED-NEXT:   0140 11000000 00000000 33000000 00000000
-# UNSORTED-NEXT:   0150 22000000 00000000 44000000 00000000
-# UNSORTED-NEXT:   0160 05000000 00000000 01000000 00000000
-# UNSORTED-NEXT:   0170 03000000 00000000 02000000 00000000
-# UNSORTED-NEXT:   0180 04000000 00000000
+# UNSORTED-NEXT:    55000000 00000000 00000000 00000000
+# UNSORTED-NEXT:    00000000 00000000 00000000 00000000
+# UNSORTED-NEXT:    11000000 00000000 33000000 00000000
+# UNSORTED-NEXT:    22000000 00000000 44000000 00000000
+# UNSORTED-NEXT:    05000000 00000000 01000000 00000000
+# UNSORTED-NEXT:    03000000 00000000 02000000 00000000
+# UNSORTED-NEXT:   04000000 00000000
 
 ## Check that SORT works (sorted by name of section).
 # RUN: echo "SECTIONS { .aaa : { *(SORT(.aaa.*)) } }" > %t2.script
 # RUN: ld.lld -o %t2 --script %t2.script %t2.o %t1.o
 # RUN: llvm-objdump -s %t2 | FileCheck -check-prefix=SORTED_A %s
 # SORTED_A:      Contents of section .aaa:
-# SORTED_A-NEXT:  0120 11000000 00000000 01000000 00000000
-# SORTED_A-NEXT:  0130 22000000 00000000 02000000 00000000
-# SORTED_A-NEXT:  0140 33000000 00000000 03000000 00000000
-# SORTED_A-NEXT:  0150 44000000 00000000 00000000 00000000
-# SORTED_A-NEXT:  0160 04000000 00000000 55000000 00000000
-# SORTED_A-NEXT:  0170 00000000 00000000 00000000 00000000
-# SORTED_A-NEXT:  0180 05000000 00000000
+# SORTED_A-NEXT:   11000000 00000000 01000000 00000000
+# SORTED_A-NEXT:   22000000 00000000 02000000 00000000
+# SORTED_A-NEXT:   33000000 00000000 03000000 00000000
+# SORTED_A-NEXT:   44000000 00000000 00000000 00000000
+# SORTED_A-NEXT:   04000000 00000000 55000000 00000000
+# SORTED_A-NEXT:   00000000 00000000 00000000 00000000
+# SORTED_A-NEXT:   05000000 00000000
 
 ## When we switch the order of files, check that sorting by
 ## section names is stable.
 # RUN: echo "SECTIONS { .aaa : { *(SORT(.aaa.*)) } }" > %t3.script
 # RUN: ld.lld -o %t3 --script %t3.script %t1.o %t2.o
 # RUN: llvm-objdump -s %t3 | FileCheck -check-prefix=SORTED_B %s
 # SORTED_B:      Contents of section .aaa:
-# SORTED_B-NEXT:  0120 01000000 00000000 00000000 00000000
-# SORTED_B-NEXT:  0130 00000000 00000000 00000000 00000000
-# SORTED_B-NEXT:  0140 11000000 00000000 02000000 00000000
-# SORTED_B-NEXT:  0150 22000000 00000000 03000000 00000000
-# SORTED_B-NEXT:  0160 33000000 00000000 00000000 00000000
-# SORTED_B-NEXT:  0170 04000000 00000000 44000000 00000000
-# SORTED_B-NEXT:  0180 05000000 00000000 55000000 00000000
+# SORTED_B-NEXT:   01000000 00000000 00000000 00000000
+# SORTED_B-NEXT:   00000000 00000000 00000000 00000000
+# SORTED_B-NEXT:   11000000 00000000 02000000 00000000
+# SORTED_B-NEXT:   22000000 00000000 03000000 00000000
+# SORTED_B-NEXT:   33000000 00000000 00000000 00000000
+# SORTED_B-NEXT:   04000000 00000000 44000000 00000000
+# SORTED_B-NEXT:   05000000 00000000 55000000 00000000
 
 ## Check that SORT surrounded with KEEP also works.
 # RUN: echo "SECTIONS { .aaa : { KEEP (*(SORT(.aaa.*))) } }" > %t3.script
 # RUN: ld.lld -o %t3 --script %t3.script %t2.o %t1.o
 # RUN: llvm-objdump -s %t3 | FileCheck -check-prefix=SORTED_A %s
 
 ## Check that SORT_BY_NAME works (SORT is alias).
 # RUN: echo "SECTIONS { .aaa : { *(SORT_BY_NAME(.aaa.*)) } }" > %t4.script
 # RUN: ld.lld -o %t4 --script %t4.script %t2.o %t1.o
 # RUN: llvm-objdump -s %t4 | FileCheck -check-prefix=SORTED_A %s
 
 ## Check that sections ordered by alignment.
 # RUN: echo "SECTIONS { .aaa : { *(SORT_BY_ALIGNMENT(.aaa.*)) } }" > %t5.script
 # RUN: ld.lld -o %t5 --script %t5.script %t1.o %t2.o
 # RUN: llvm-objdump -s %t5 | FileCheck -check-prefix=SORTED_ALIGNMENT %s
 # SORTED_ALIGNMENT:      Contents of section .aaa:
-# SORTED_ALIGNMENT-NEXT:  0120 05000000 00000000 00000000 00000000
-# SORTED_ALIGNMENT-NEXT:  0130 00000000 00000000 00000000 00000000
-# SORTED_ALIGNMENT-NEXT:  0140 11000000 00000000 00000000 00000000
-# SORTED_ALIGNMENT-NEXT:  0150 04000000 00000000 00000000 00000000
-# SORTED_ALIGNMENT-NEXT:  0160 22000000 00000000 03000000 00000000
-# SORTED_ALIGNMENT-NEXT:  0170 33000000 00000000 02000000 00000000
-# SORTED_ALIGNMENT-NEXT:  0180 44000000 00000000 01000000 00000000
-# SORTED_ALIGNMENT-NEXT:  0190 55000000 00000000
+# SORTED_ALIGNMENT-NEXT:   05000000 00000000 00000000 00000000
+# SORTED_ALIGNMENT-NEXT:   00000000 00000000 00000000 00000000
+# SORTED_ALIGNMENT-NEXT:   11000000 00000000 00000000 00000000
+# SORTED_ALIGNMENT-NEXT:   04000000 00000000 00000000 00000000
+# SORTED_ALIGNMENT-NEXT:   22000000 00000000 03000000 00000000
+# SORTED_ALIGNMENT-NEXT:   33000000 00000000 02000000 00000000
+# SORTED_ALIGNMENT-NEXT:   44000000 00000000 01000000 00000000
+# SORTED_ALIGNMENT-NEXT:   55000000 00000000
 
 .global _start
 _start:
  nop
 
 .section .aaa.5, "a"
 .align 32
 .quad 5

test/ELF/linkerscript/linkerscript-symbol-assignexpr.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 
 # RUN: echo "SECTIONS { \
 # RUN:         symbol = CONSTANT(MAXPAGESIZE); \
 # RUN:         symbol2 = symbol + 0x1234; \
 # RUN:         symbol3 = symbol2; \
 # RUN:       }" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -t %t1 | FileCheck %s
 
 # CHECK:      SYMBOL TABLE:
 # CHECK-NEXT: 0000000000000000 *UND* 00000000
-# CHECK-NEXT: 0000000000000120 .text 00000000 _start
-# CHECK-NEXT: 0000000000000121 .text 00000000 foo
+# CHECK-NEXT: 00000000000000e8 .text 00000000 _start
+# CHECK-NEXT: 00000000000000e9 .text 00000000 foo
 # CHECK-NEXT: 0000000000001000 *ABS* 00000000 symbol
 # CHECK-NEXT: 0000000000002234 *ABS* 00000000 symbol2
 # CHECK-NEXT: 0000000000002234 *ABS* 00000000 symbol3
 
 # RUN: echo "SECTIONS { \
 # RUN:         symbol2 = symbol; \
 # RUN:       }" > %t2.script
 # RUN: not ld.lld -o %t2 --script %t2.script %t 2>&1 \

test/ELF/linkerscript/linkerscript-symbol-conflict.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 
 # RUN: echo "SECTIONS {.text : {*(.text.*)} end = .;}" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -t %t1 | FileCheck %s
-# CHECK: 0000000000000121         *ABS*    00000000 end
+# CHECK: 00000000000000e9         *ABS*    00000000 end
 
 .global _start
 _start:
  nop

test/ELF/linkerscript/linkerscript-symbols-synthetic.s

 # RUN:              begin_bar = .; \
 # RUN:              *(.bar) \
 # RUN:              end_bar = .; \
 # RUN:              size_foo_2 = SIZEOF(.foo); \ 
 # RUN:            } \
 # RUN:            size_foo_3 = SIZEOF(.foo); }" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=SIMPLE %s
-# SIMPLE:      0000000000000120         .foo    00000000 begin_foo
-# SIMPLE-NEXT: 0000000000000128         .foo    00000000 end_foo
+# SIMPLE:      00000000000000e8         .foo    00000000 begin_foo
+# SIMPLE-NEXT: 00000000000000f0         .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: 0000000000000ee4         .foo    00000000 size_foo_2
-# SIMPLE-NEXT: 0000000000000ee4         *ABS*   00000000 size_foo_3
+# SIMPLE-NEXT: 0000000000000f1c         .foo    00000000 size_foo_2
+# SIMPLE-NEXT: 0000000000000f1c         *ABS*   00000000 size_foo_3
 
 .global _start
 _start:
  nop
 
 .section .foo,"a"
  .quad 0
 
 .section .bar,"a"
  .long 0

test/ELF/linkerscript/linkerscript-symbols.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 
 # Simple symbol assignment. Should raise conflict in case we
 # have duplicates in any input section, but currently simply
 # replaces the value.
 # RUN: echo "SECTIONS {.text : {*(.text.*)} text_end = .;}" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=SIMPLE %s
-# SIMPLE: 0000000000000121         *ABS*    00000000 text_end
+# SIMPLE: 00000000000000e9         *ABS*    00000000 text_end
 
 # The symbol is not referenced. Don't provide it.
 # RUN: echo "SECTIONS { PROVIDE(newsym = 1);}" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=PROVIDE1 %s
 # PROVIDE1-NOT: 0000000000000001         *ABS*    00000000 newsym
 
 # The symbol is not referenced. Don't provide it.

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 .foo          00000004 00000000000000e8 DATA
+# CHECK-NEXT:   2 .boo          00000004 00000000000000ec DATA
+# CHECK-NEXT:   3 .text         00000001 00000000000000f0 TEXT DATA
 
 .global _start
 _start:
  nop
 
 .section .foo, "a"
 foo:
  .long 0
 
 .section .boo, "a"
 boo:
  .long 0

test/ELF/phdr-align.s

 # CHECK-NEXT:  Section {
 # CHECK-NEXT:    Index: 1
 # CHECK-NEXT:    Name: .bss
 # CHECK-NEXT:    Type: SHT_NOBITS
 # CHECK-NEXT:    Flags [
 # CHECK-NEXT:      SHF_ALLOC
 # CHECK-NEXT:      SHF_WRITE
 # CHECK-NEXT:    ]
-# CHECK-NEXT:    Address: 0x158
-# CHECK-NEXT:    Offset: 0x158
+# CHECK-NEXT:    Address: 0x120
+# CHECK-NEXT:    Offset: 0x120
 # CHECK-NEXT:    Size: 6
 # CHECK-NEXT:    Link: 0
 # CHECK-NEXT:    Info: 0
 # CHECK-NEXT:    AddressAlignment: 1
 # CHECK-NEXT:    EntrySize: 0
 # CHECK-NEXT:  }
 # CHECK-NEXT:  Section {
 # CHECK-NEXT:    Index: 2
 # CHECK-NEXT:    Name: .data
 # CHECK-NEXT:    Type: SHT_PROGBITS
 # CHECK-NEXT:    Flags [
 # CHECK-NEXT:      SHF_ALLOC
 # CHECK-NEXT:      SHF_WRITE
 # CHECK-NEXT:    ]
-# CHECK-NEXT:    Address: 0x15E
-# CHECK-NEXT:    Offset: 0x15E
+# CHECK-NEXT:    Address: 0x126
+# CHECK-NEXT:    Offset: 0x126
 # CHECK-NEXT:    Size: 2
 # CHECK-NEXT:    Link: 0
 # CHECK-NEXT:    Info: 0
 # CHECK-NEXT:    AddressAlignment: 1
 # CHECK-NEXT:    EntrySize: 0
 # CHECK-NEXT:  }
 # CHECK-NEXT:  Section {
 # CHECK-NEXT:    Index: 3
 # CHECK-NEXT:    Name: .text
 # CHECK-NEXT:    Type: SHT_PROGBITS
 # CHECK-NEXT:    Flags [
 # CHECK-NEXT:      SHF_ALLOC
 # CHECK-NEXT:      SHF_EXECINSTR
 # CHECK-NEXT:    ]
-# CHECK-NEXT:    Address: 0x160
-# CHECK-NEXT:    Offset: 0x160
+# CHECK-NEXT:    Address: 0x128
+# CHECK-NEXT:    Offset: 0x128
 # CHECK-NEXT:    Size: 1
 # CHECK-NEXT:    Link: 0
 # CHECK-NEXT:    Info: 0
 # CHECK-NEXT:    AddressAlignment: 4
 # CHECK-NEXT:    EntrySize: 0
 # CHECK-NEXT:  }
 
 .global _start
 .text
 _start:
  nop
 .data
  .word 1
 .bss
  .space 6

test/ELF/wildcards.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 
 ## Default case: abc and abx included in text.
 # RUN: echo "SECTIONS { \
 # RUN:      .text : { *(.abc .abx) } }" > %t.script
 # RUN: ld.lld -o %t.out --script %t.script %t
 # RUN: llvm-objdump -section-headers %t.out | \
 # RUN:   FileCheck -check-prefix=SEC-DEFAULT %s
 # SEC-DEFAULT:      Sections:
 # SEC-DEFAULT-NEXT: Idx Name          Size      Address          Type
 # SEC-DEFAULT-NEXT:   0               00000000 0000000000000000
-# SEC-DEFAULT-NEXT:   1 .text         00000008 0000000000000120 TEXT DATA
-# SEC-DEFAULT-NEXT:   2 .abcd         00000004 0000000000000128 TEXT DATA
-# SEC-DEFAULT-NEXT:   3 .ad           00000004 000000000000012c TEXT DATA
-# SEC-DEFAULT-NEXT:   4 .ag           00000004 0000000000000130 TEXT DATA
+# SEC-DEFAULT-NEXT:   1 .text         00000008 00000000000000e8 TEXT DATA
+# SEC-DEFAULT-NEXT:   2 .abcd         00000004 00000000000000f0 TEXT DATA
+# SEC-DEFAULT-NEXT:   3 .ad           00000004 00000000000000f4 TEXT DATA
+# SEC-DEFAULT-NEXT:   4 .ag           00000004 00000000000000f8 TEXT DATA
 # SEC-DEFAULT-NEXT:   5 .symtab       00000030 0000000000000000
 # SEC-DEFAULT-NEXT:   6 .shstrtab     0000002f 0000000000000000
 # SEC-DEFAULT-NEXT:   7 .strtab       00000008 0000000000000000
 
 ## Now replace the symbol with '?' and check that results are the same.
 # RUN: echo "SECTIONS { \
 # RUN:      .text : { *(.abc .ab?) } }" > %t.script
 # RUN: ld.lld -o %t.out --script %t.script %t
 # RUN: llvm-objdump -section-headers %t.out | \
 # RUN:   FileCheck -check-prefix=SEC-DEFAULT %s
 
 ## Now see how replacing '?' with '*' will consume whole abcd.
 # RUN: echo "SECTIONS { \
 # RUN:      .text : { *(.abc .ab*) } }" > %t.script
 # RUN: ld.lld -o %t.out --script %t.script %t
 # RUN: llvm-objdump -section-headers %t.out | \
 # RUN:   FileCheck -check-prefix=SEC-ALL %s
 # SEC-ALL:      Sections:
 # SEC-ALL-NEXT: Idx Name          Size      Address          Type
 # SEC-ALL-NEXT:   0               00000000 0000000000000000
-# SEC-ALL-NEXT:   1 .text         0000000c 0000000000000120 TEXT DATA
-# SEC-ALL-NEXT:   2 .ad           00000004 000000000000012c TEXT DATA
-# SEC-ALL-NEXT:   3 .ag           00000004 0000000000000130 TEXT DATA
+# SEC-ALL-NEXT:   1 .text         0000000c 00000000000000e8 TEXT DATA
+# SEC-ALL-NEXT:   2 .ad           00000004 00000000000000f4 TEXT DATA
+# SEC-ALL-NEXT:   3 .ag           00000004 00000000000000f8 TEXT DATA
 # SEC-ALL-NEXT:   4 .symtab       00000030 0000000000000000
 # SEC-ALL-NEXT:   5 .shstrtab     00000029 0000000000000000
 # SEC-ALL-NEXT:   6 .strtab       00000008 0000000000000000
 
 ## All sections started with .a are merged.
 # RUN: echo "SECTIONS { \
 # RUN:      .text : { *(.a*) } }" > %t.script
 # RUN: ld.lld -o %t.out --script %t.script %t
 # RUN: llvm-objdump -section-headers %t.out | \
 # RUN:   FileCheck -check-prefix=SEC-NO %s
 # SEC-NO: Sections:
 # SEC-NO-NEXT: Idx Name          Size      Address          Type
 # SEC-NO-NEXT:   0               00000000 0000000000000000
-# SEC-NO-NEXT:   1 .text         00000014 0000000000000120 TEXT DATA
+# SEC-NO-NEXT:   1 .text         00000014 00000000000000e8 TEXT DATA
 # SEC-NO-NEXT:   2 .symtab       00000030 0000000000000000
 # SEC-NO-NEXT:   3 .shstrtab     00000021 0000000000000000
 # SEC-NO-NEXT:   4 .strtab       00000008 0000000000000000
 
 .text
 .section .abc,"ax",@progbits
 .long 0