Mitigate relocation overflow [part 1 of 2]

[shenhan]

Summary

This CL is to mitigate R_X86_64_PC32 relocation overflow problems for huge binaries that has near 2G allocated sections.

By examining those binaries, I found these 2 issues contributes to the problem:
1). huge ".dynsym" and ".dynstr" stands in the way between .rodata and .text
2). _init_array_start/end are placed at 0 if no ".init_array" presents, this causes .text relocation against them become more prone to overflow.

This CL addresses 1st problem (the 2nd will be addressed in another CL.) by assigning a smaller sortrank to .dynsym and .dynstr thus they no longer stand in between

Note: this CL affects multiple tests, I include in this CL only 2 of many changes to the tests. And I'll provide the rest once this main part of this CL gets approved.

[ruiu]

ELF/Writer.cpp

721–722

Please expand the comment to explain that we want to put progbits sections closer so that relocations as an effort to prevent relocation overflow between these sections.

722

What is this isRelroSection condition for?

1694

Please use clang-format.

I think that Config->ImageBase is a better default value than an address of .text section because a section whose name is .text may not exist.

[shenhan]

ELF/Writer.cpp

722

This is used to skip reordering for relro sections, because these to be put into RelRo segment must be contiguous, otherwise lld complains.

1694

Done clang-format.

In some cases, Config->ImageBase is too small, like I see 0x1000. And 0x1000 is still too far away from some .text sections.

[ruiu]

ELF/Writer.cpp

722

How did it work before this patch? I thought that all relro sections are progbits sections, so setting PF_PROGBITS to everybody doesn't change the existing behavior. It is confusing if you don't set RF_PROGBITS to everybody unconditionally.

1693–1697

Please find .text section outside of this lambda to call findSection only once.

p needs to be P by the LLVM coding style. But I prefer Text.

OutputSection* p -> OutputSection *P by the LLVM coding style.

Please look around to make sure your new code matches with other code in the same file in style.

[shenhan]

ELF/Writer.cpp

722

Most of relro have PROGBITS, but ".dynamic" & ".tbss" don't. So the condition test is to keep those 2 sections contiguous with other relro sections.

[ruiu]

ELF/Writer.cpp

722

Doesn't that mean that the priority you gave to RF_NON_TLS_BSS_RO is not appropriate? If you give it lower priority than the RELRO priority (i.e. RF_NON_TLS_BSS_RO), it should automatically work, no?

[ruiu]

ELF/Writer.cpp

1690

Please separate this part as a separate patch, as this patch contains two unrelated changes.

[shenhan]

@espindola would you mind take a look?

[grimar]

Can you add a test case showing the difference in layout after this patch applied?

ELF/Writer.cpp

720

"ALLOC" -> SHF_ALLOC or "ALLOC" -> allocatable

725

Please be consistent. You mix ALLOC and "ALLOC". I would just use SHF_ALLOC everywhere.

[shenhan]

Thanks. Done with a test case.

[shenhan]

Any further thoughts? If not, I'll proceed to fixing all the other test failures caused by section re-arrangement.

[grimar]

ELF/Writer.cpp

744

So, this places SHT_DYNSYM and SHT_SYMTAB sections first
in "a" sections group just because they do not get RF_NOT_TLS rank
(like other "a" sections) because of this early return, right?

Then it seems that behavior is based on an accident.
I would suggest adding new RF_* rank probably to make it explicit.

test/ELF/dynsec-at-beginning.s

17

I am not sure having "aw" section is useful here.
I would instead expect to see foo as "a" section instead. To show
how non-synthetic SHF _ALLOC sections are placed with the new code.
Because currently, you show the layout of "a" synthetic sections
(.dynsym, .dynstr, .hash) only.

[grimar]

This change looks good for me (with a better name for rank).
Currently, as you know, there are 57 failing test cases.
Please fix them and update the patch.

ELF/Writer.cpp

705

RF_DYN_SYM does not seem to be a good name because
you use it for both SHT_DYNSYM and SHT_STRTAB.

I do not have an idea about the good name now. Maybe RF_ALLOC_FIRST?

[shenhan]

Fixed all affected test cases.

[grimar]

Few comments for now + please upload the patch with the context (just read the https://llvm.org/docs/Phabricator.html).

test/ELF/basic-ppc.s

15

Remove trailing whitespace, please.

60

(1) is new and excessive. The same issues below.

test/ELF/dynsec-at-beginning.s

13

.text is AX please keep the full attributes name.

[ruiu]

LGTM

[grimar]

Please update the patch with my comments addressed, I would like to review the test cases carefully.

[shenhan]

Refined test cases changes and provide more context.

[grimar]

Ok, I reviewed the changed test cases and unfortunately, now I have many concerns about this patch.
Issues I found are in comments, I think they are critical and needs fix/investigation first of all.

But I also think that given the issues observed and the fact that it makes
output different with the default output from gnu linkers,
I probably want to suggest to hide this new functionality under some -z <option> flag.

Will be happy to see the opinions of other people.

test/ELF/arm-exidx-shared.s

43–44

This calculation comment needs an update since values changed.

test/ELF/dynsec-at-beginning.s

14

Please address this comment (.text is AX, not just A)

test/ELF/linkerscript/no-space.s

4

I do not think this is correct, sorry. This change broke the intention of the test case I believe.

You did that because LLD starts triggering an error:

error: section .dynsym file range overlaps with foo
>>> .dynsym range is [0x1000, 0x1017]
>>> foo range is [0x1000, 0x1007]

What happens because orphan section .dynsym is placed before foo. And then during
assigning of VA, Dot is explicitly set to 0 for foo, making it intersect with .dynsym.

I think the expected behavior is to not place these orphan sections before foo, since
the position of foo is explicitly requested by linker script. And sure I do not think
we should emit an error in that case.

This case needs some investigation.
I'll be happy to hear other people opinion on that too.

test/ELF/linkerscript/out-of-order.s

3

The same here. I do not think you should "fix" this script. It was valid by itself. It should just work.

With the original linker script, this patch makes LLD to produce invalid output (actually no output at all as FileSize is broken).

[shenhan]

test/ELF/linkerscript/no-space.s

4

Thanks for pointing this out, yes, I agree we need to have consensus on this (and the "out-of-order.s" test case below).

Here is my thoughts:

1. The test writer assume the fact that "foo" must be the first section in its segment (which is a group of output sections), otherwise, its address intersects with the first output section in the segment, because DOT is set to 0 for "foo" by linkerscript.

2. There is no fact in the test case supports this assumption.

3. So this test case might cause linker error whenever output sections change relative order in the segment.

So my suggestion:
Honor the assumption, so instead of change the DOT for foo, change it for .dynsym (the first output section of segment):

• # RUN: echo "SECTIONS {foo 0 : {*(foo*)} }" > %t.script

+ # RUN: echo "SECTIONS {.dynsym 0 : {*(.dynsym)} }" > %t.script
This reserves the origin test intention.

.OR.
Always layout output sections with explicit address assignment first, then layout those without. So for this particular case, the origin output section order is:

.dynsym .dynstr foo

We layout it like below:

foo .dynsym .dynstr

.OR.
Report error on rewinding "." to a conflict address.

[This also applies to out-of-order.s test case below.]

I'm happy to go any direction.

Comments?

[grimar]

test/ELF/linkerscript/no-space.s

4

.OR.
Always layout output sections with explicit address assignment first

I believe it is the correct way. A script should specify the layout, any orphans
should be placed after the explicitly specified sections. That seems logically correct
and consistent with gnu linkers behavior (I think).

I would really want to hear from other people before proceeding this place probably.

[shenhan]

test/ELF/linkerscript/no-space.s

4

Thanks, George.

@ruiu Can you comment?

[grimar]

test/ELF/linkerscript/no-space.s

4

Can you update the test cases you had to change so that these sections be not the orphans (will be listed explicitly)?
Let's see if we can try to go with that change then and watch how it works in practice.

[shenhan]

Revised linkerscript/out-of-order.s and linkerscript/no-space.s to honor layout constraint (also added notes). Also addressed previous 2 minor comments.

[grimar]

Thanks for an update!

I tested check-lld both on windows and ubuntu and
there are still 6 test cases that are failing for me.
(I think that was true for previous iteration too).

50> Failing Tests (6):
50> lld :: ELF/aarch64-copy.s
50> lld :: ELF/arm-copy.s
50> lld :: ELF/map-file.s
50> lld :: ELF/relocation.s
50> lld :: ELF/version-script-extern.s
50> lld :: ELF/x86-64-retpoline-znow-linkerscript.s

My suggestions about how we should adjust the test cases are also inline.
Let's discuss if anything I am suggesting does not look OK for some reason to you.

test/ELF/linkerscript/no-space.s

8

synsym -> dynsym

SECTIONS {foo : {*(foo*)} .dynsym : { *(.dynsym) } .dynstr : { *(.dynstr) } }

10

.dynstr is still an orphan.

Let's just list them explicitly here:
SECTIONS {foo 0 : {*(foo*)} .dynsym : { *(.dynsym) } .dynstr : { *(.dynstr) } }

test/ELF/linkerscript/out-of-order.s

3

I do not understand why you changed .data to .dynamic actually.
What your patch changed is the order of "a" sections. That breaks the current scripts
which previously would put dynsym/dynstr correctly, but now - don't.
And I think we should adjust only that part, no need to update anything else probably.

Lets do this:
SECTIONS { .data 0x4000 : { *(.data) } .dynsym 0x2000 : { *(.dynsym ) } .dynstr : { *(.dynstr ) } }

So what changed is that we explicitly start the second segment from .dynsym instead of .text,
so that '.dynsym'/.dynstr are not an orphans now, and that allows to place it correctly. Layout is then:

1 .data         00000008 0000000000004000 DATA
2 .dynamic      00000060 0000000000004008
3 .dynsym       00000018 0000000000002000
4 .dynstr       00000001 0000000000002018
5 .text         00000008 000000000000201c TEXT DATA

[shenhan]

Updated according to review feedback. Also synced to upstream HEAD and re-run all tests. All passed now.

[shenhan]

Thanks for the review.

[grimar]

I do not know what is wrong, but the following tests are still failing for me.

30> Failing Tests (5):
30> lld :: ELF/aarch64-copy.s
30> lld :: ELF/arm-copy.s
30> lld :: ELF/note-noalloc.s
30> lld :: ELF/relocation.s
30> lld :: ELF/version-script-extern.s

note-noalloc.s is a new one, you have to update it, but others are old and I see you already updated them in the patch,
they seem to be trivial, so not sure what is wrong here, please check your configuration because I tested on 2 and result was the same.

The rest of changes looks fine to me mostly I think (I'll probably adjust few minor things after your commit).

I do not want to be a stopper for this one anymore, so please feel free to commit after fixing above tests.
And let's see how this change works in practice.

[shenhan]

Synced to newest and re-ran tests, make sure everything passes.

[shenhan]

Thanks. Landed as https://llvm.org/svn/llvm-project/lld/trunk@332038

[shenhan]

Some clarification why my test result is different from George's.

I noticed that my build tree is configured with option "-DLLVM_OPTIMIZED_TABLEGEN=On", this seemingly innocuous option changed the behavior of at least 4 cases. After I dropped these 4 options, I saw the 4 new failures, and a new CL has been submitted to fix these 4. https://reviews.llvm.org/D46730

[grimar]

In D45788#1095337, @shenhan wrote:

Some clarification why my test result is different from George's.

I noticed that my build tree is configured with option "-DLLVM_OPTIMIZED_TABLEGEN=On", this seemingly innocuous option changed the behavior of at least 4 cases. After I dropped these 4 options, I saw the 4 new failures, and a new CL has been submitted to fix these 4. https://reviews.llvm.org/D46730

FWIW, I am using -DLLVM_OPTIMIZED_TABLEGEN=1 for windows build too.

[grimar]

Sorry, but I had to revert this in r332085 "[ELF] - Revert of: r332038, r332054, r332060, r332061, r332062, r332063"

Bots were still broken. We need to find a reason for the failures.
Please, next time check the bots after commit. That is undesirable to have them broken for a long time.

Failing bots I observed were:
http://lab.llvm.org:8011/builders/llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast/builds/17042
http://lab.llvm.org:8011/builders/llvm-clang-lld-x86_64-scei-ps4-ubuntu-fast/builds/29845

Now they are OK.

[mstorsjo]

In D45788#1095683, @grimar wrote:

Sorry, but I had to revert this in r332085 "[ELF] - Revert of: r332038, r332054, r332060, r332061, r332062, r332063"

Thanks for reverting, I was also scratching my head over this.

Bots were still broken. We need to find a reason for the failures.
Please, next time check the bots after commit. That is undesirable to have them broken for a long time.

Failing bots I observed were:
http://lab.llvm.org:8011/builders/llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast/builds/17042
http://lab.llvm.org:8011/builders/llvm-clang-lld-x86_64-scei-ps4-ubuntu-fast/builds/29845

A couple more ones:
http://lab.llvm.org:8011/builders/sanitizer-x86_64-linux-bootstrap/builds/5428
http://lab.llvm.org:8011/builders/clang-with-lto-ubuntu/builds/8464
http://lab.llvm.org:8011/builders/clang-lld-x86_64-2stage/builds/5405
http://lab.llvm.org:8011/builders/clang-cmake-aarch64-lld/builds/4560

[grimar]

btw, before reverting I tried check-lld locally. I had test failures too, though I had 4 when bots had 2. My guess is that something is wrong with the sorting of output sections.
Maybe stable/unstable sorting is a key to resolving the issue, I had no chance to look closer yet, I am busy with a different task right now. I'll try to take a look when finish things I am working on.

[shenhan]

Sorry for breaking the builders. Should double check again after my fix for the broken 4 cases.

I'll look into the unstableness of output section sorting.

[shenhan]

Merge D46764 (Fix test cases that check addresses that are not always invariable) into this.

Also address Peter Smith's comments.

[grimar]

All tests pass for me now. LGTM, thanks!

[NickHung]

test/ELF/linkerscript/addr-zero.test

11

This change breaks the value of foo.
The expected value of foo is 0x0.

[grimar]

test/ELF/linkerscript/addr-zero.test

11

I think the script should be just changed to

foo = ADDR(.dynsym) - ABSOLUTE(ADDR(.dynsym));

where .dynsym is the first section now.

The problem with this script seems to be that it tries to evaluate ABSOLUTE value for .text
too early. When we assign to foo we do not yet know the absolute address of the .text.

Before this patch, .text was the first section at VA = 0, so this just worked.
Such script would not produce zero value for foo with any other
section other than .text I believe.

I am not sure (and did not find) what was the initial intention to support script like this.
Perhaps there was some other issue which produced some broken value instead of zero.

ELF/Writer.cpp

 // Using flags has two key properties:
 // * It is easy to check if a give branch was taken.
 // * It is easy two see how similar two ranks are (see getRankProximity).
 enum RankFlags {
   RF_NOT_ADDR_SET = 1 << 18,
   RF_NOT_INTERP = 1 << 17,
   RF_NOT_ALLOC = 1 << 16,
   RF_WRITE = 1 << 15,
-  RF_EXEC_WRITE = 1 << 13,
-  RF_EXEC = 1 << 12,
-  RF_NON_TLS_BSS = 1 << 11,
-  RF_NON_TLS_BSS_RO = 1 << 10,
-  RF_NOT_TLS = 1 << 9,
+  RF_EXEC_WRITE = 1 << 14,
+  RF_EXEC = 1 << 13,
+  RF_NON_TLS_BSS = 1 << 12,
+  RF_NON_TLS_BSS_RO = 1 << 11,
+  RF_NOT_TLS = 1 << 10,
+  RF_ALLOC_FIRST = 1 << 9,
   RF_BSS = 1 << 8,
   RF_NOTE = 1 << 7,
   RF_PPC_NOT_TOCBSS = 1 << 6,
   RF_PPC_TOCL = 1 << 4,
   RF_PPC_TOC = 1 << 3,
   RF_PPC_BRANCH_LT = 1 << 2,
   RF_MIPS_GPREL = 1 << 1,
   RF_MIPS_NOT_GOT = 1 << 0
 };
 
 static unsigned getSectionRank(const OutputSection *Sec) {
   unsigned Rank = 0;
 
   // We want to put section specified by -T option first, so we
   // can start assigning VA starting from them later.
   if (Config->SectionStartMap.count(Sec->Name))
     return Rank;
   Rank |= RF_NOT_ADDR_SET;
 
   // Put .interp first because some loaders want to see that section
   // on the first page of the executable file when loaded into memory.
   if (Sec->Name == ".interp")
     return Rank;
   Rank |= RF_NOT_INTERP;
 
   // Allocatable sections go first to reduce the total PT_LOAD size and
   // so debug info doesn't change addresses in actual code.
   if (!(Sec->Flags & SHF_ALLOC))
     return Rank | RF_NOT_ALLOC;
 
+  // Place .dynsym and .dynstr at the beginning of SHF_ALLOC
+  // sections. We want to do this to mitigate the possibility that
+  // huge .dynsym and .dynstr sections placed between ro-data and text
+  // sections cause relocation overflow.  Note: .dynstr has SHT_STRTAB
+  // type and SHF_ALLOC attribute, whereas sections that only have
+  // SHT_STRTAB but without SHF_ALLOC is placed at the end. All "Sec"
+  // reaching here has SHF_ALLOC bit set.
+  if (Sec->Type == SHT_DYNSYM || Sec->Type == SHT_STRTAB)
+    return Rank | RF_ALLOC_FIRST;
+
   // Sort sections based on their access permission in the following
   // order: R, RX, RWX, RW.  This order is based on the following
   // considerations:
   // * Read-only sections come first such that they go in the
   //   PT_LOAD covering the program headers at the start of the file.
   // * Read-only, executable sections come next, unless the
   //   -no-rosegment option is used.
   // * Writable, executable sections follow such that .plt on
do {
         Changed |= A64P.createFixes();
       }
       if (InX::MipsGot)
         InX::MipsGot->updateAllocSize();
       Changed |= InX::RelaDyn->updateAllocSize();
     } while (Changed);
   }
 
   // createThunks may have added local symbols to the static symbol table
   applySynthetic({InX::SymTab},
                  [](SyntheticSection *SS) { SS->postThunkContents(); });
 
   // Fill other section headers. The dynamic table is finalized
   // at the end because some tags like RELSZ depend on result
   // of finalizing other sections.
   for (OutputSection *Sec : OutputSections)
     Sec->finalize<ELFT>();
 }
 
 // The linker is expected to define SECNAME_start and SECNAME_end
 // symbols for a few sections. This function defines them.
 template <class ELFT> void Writer<ELFT>::addStartEndSymbols() {
   auto Define = [&](StringRef Start, StringRef End, OutputSection *OS) {
     // These symbols resolve to the image base if the section does not exist.

test/ELF/aarch64-copy.s

 // REQUIRES: aarch64
 // RUN: llvm-mc -filetype=obj -triple=aarch64-pc-freebsd %s -o %t.o
 // RUN: llvm-mc -filetype=obj -triple=aarch64-pc-freebsd %p/Inputs/relocation-copy.s -o %t2.o
-// RUN: ld.lld -shared %t2.o -o %t2.so
+// RUN: ld.lld -shared %t2.o -soname fixed-length-string.so -o %t2.so
 // RUN: ld.lld %t.o %t2.so -o %t3
 // RUN: llvm-readobj -s -r --expand-relocs -symbols %t3 | FileCheck %s
 // RUN: llvm-objdump -d %t3 | FileCheck -check-prefix=CODE %s
 // RUN: llvm-objdump -s -section=.rodata %t3 | FileCheck -check-prefix=RODATA %s
 
 .text
 .globl _start
 _start:

 // Page(S + A) - Page(P) = 0x40000 - 0x20000 = 0x20000 = 131072
 // CODE-NEXT:  20004: {{.*}} adrp x2, #131072
 // S(y) = 0x40010, A = 0
 // (S + A) & 0xFFF = 0x10 = 16
 // CODE-NEXT:  20008: {{.*}} add  x2, x2, #16
 
 // RODATA: Contents of section .rodata:
 // S(z) = 0x40014
-// RODATA-NEXT:  101c8 14000400
+// RODATA-NEXT:  10246 14000400

test/ELF/aarch64-thunk-pi.s

  ret
 // CHECK: low_target2:
 // CHECK-NEXT:        8:        05 00 00 94     bl      #20
 // CHECK-NEXT:        c:        c0 03 5f d6     ret
 
 // Expect range extension thunks for .text_low
 // adrp calculation is (PC + signed immediate) & (!0xfff)
 // CHECK: __AArch64ADRPThunk_high_target:
-// CHECK-NEXT:       10:       10 00 08 90     adrp    x16, #268435456
-// CHECK-NEXT:       14:       10 82 04 91     add     x16, x16, #288
-// CHECK-NEXT:       18:       00 02 1f d6     br      x16
+// CHECK-NEXT:       70:       10 00 08 90     adrp    x16, #268435456
+// CHECK-NEXT:       74:       10 02 03 91     add     x16, x16, #192
+// CHECK-NEXT:       78:       00 02 1f d6     br      x16
 // CHECK: __AArch64ADRPThunk_high_target2:
-// CHECK-NEXT:       1c:       10 00 08 90     adrp    x16, #268435456
-// CHECK-NEXT:       20:       10 22 00 91     add     x16, x16, #8
-// CHECK-NEXT:       24:       00 02 1f d6     br      x16
+// CHECK-NEXT:       7c:       10 00 08 90     adrp    x16, #268435456
+// CHECK-NEXT:       80:       10 22 00 91     add     x16, x16, #8
+// CHECK-NEXT:       84:       00 02 1f d6     br      x16
 
 
  .section .text_high, "ax", %progbits
  .globl high_target
  .type high_target, %function
 high_target:
  // No thunk needed as we can reach low_target@plt
  bl low_target
  ret
 // CHECK: high_target:
-// CHECK-NEXT: 10000000:        4c 00 00 94     bl      #304
+// CHECK-NEXT: 10000000:        34 00 00 94     bl      #208
 // CHECK-NEXT: 10000004:        c0 03 5f d6     ret
 
  .hidden high_target2
  .globl high_target2
  .type high_target2, %function
 high_target2:
  // Need thunk to low_target
  bl low_target2
  ret
 // CHECK: high_target2:
 // CHECK-NEXT: 10000008:        02 00 00 94     bl      #8
 // CHECK-NEXT: 1000000c:        c0 03 5f d6     ret
 
 // Expect Thunk for .text.high
 
 // CHECK: __AArch64ADRPThunk_low_target2:
 // CHECK-NEXT: 10000010:  10 00 f8 90   adrp  x16, #-268435456
-// CHECK-NEXT: 10000014:  10 22 00 91   add x16, x16, #8
+// CHECK-NEXT: 10000014:  10 a2 01 91   add x16, x16, #104
 // CHECK-NEXT: 10000018:  00 02 1f d6   br  x16
 
 // CHECK: Disassembly of section .plt:
 // CHECK-NEXT: .plt:
-// CHECK-NEXT: 10000100:        f0 7b bf a9     stp     x16, x30, [sp, #-16]!
-// CHECK-NEXT: 10000104:        10 00 00 90     adrp    x16, #0
-// CHECK-NEXT: 10000108:        11 aa 40 f9     ldr     x17, [x16, #336]
-// CHECK-NEXT: 1000010c:        10 42 05 91     add     x16, x16, #336
-// CHECK-NEXT: 10000110:        20 02 1f d6     br      x17
-// CHECK-NEXT: 10000114:        1f 20 03 d5     nop
-// CHECK-NEXT: 10000118:        1f 20 03 d5     nop
-// CHECK-NEXT: 1000011c:        1f 20 03 d5     nop
-// CHECK-NEXT: 10000120:        10 00 00 90     adrp    x16, #0
-// CHECK-NEXT: 10000124:        11 ae 40 f9     ldr     x17, [x16, #344]
-// CHECK-NEXT: 10000128:        10 62 05 91     add     x16, x16, #344
-// CHECK-NEXT: 1000012c:        20 02 1f d6     br      x17
-// CHECK-NEXT: 10000130:        10 00 00 90     adrp    x16, #0
-// CHECK-NEXT: 10000134:        11 b2 40 f9     ldr     x17, [x16, #352]
-// CHECK-NEXT: 10000138:        10 82 05 91     add     x16, x16, #352
-// CHECK-NEXT: 1000013c:        20 02 1f d6     br      x17
+// CHECK-NEXT: 100000a0:       f0 7b bf a9     stp     x16, x30, [sp, #-16]!
+// CHECK-NEXT: 100000a4:       10 00 00 90     adrp    x16, #0
+// CHECK-NEXT: 100000a8:       11 7a 40 f9     ldr     x17, [x16, #240]
+// CHECK-NEXT: 100000ac:       10 c2 03 91     add     x16, x16, #240
+// CHECK-NEXT: 100000b0:       20 02 1f d6     br      x17
+// CHECK-NEXT: 100000b4:       1f 20 03 d5     nop
+// CHECK-NEXT: 100000b8:       1f 20 03 d5     nop
+// CHECK-NEXT: 100000bc:       1f 20 03 d5     nop
+// CHECK-NEXT: 100000c0:       10 00 00 90     adrp    x16, #0
+// CHECK-NEXT: 100000c4:       11 7e 40 f9     ldr     x17, [x16, #248]
+// CHECK-NEXT: 100000c8:       10 e2 03 91     add     x16, x16, #248
+// CHECK-NEXT: 100000cc:       20 02 1f d6     br      x17
+// CHECK-NEXT: 100000d0:       10 00 00 90     adrp    x16, #0
+// CHECK-NEXT: 100000d4:       11 82 40 f9     ldr     x17, [x16, #256]
+// CHECK-NEXT: 100000d8:       10 02 04 91     add     x16, x16, #256
+// CHECK-NEXT: 100000dc:       20 02 1f d6     br      x17

test/ELF/arm-copy.s

 // REQUIRES: arm
 // RUN: llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi %s -o %t.o
 // RUN: llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi %p/Inputs/relocation-copy-arm.s -o %t2.o
-// RUN: ld.lld -shared %t2.o -o %t2.so
+// RUN: ld.lld -shared %t2.o -soname fixed-length-string.so -o %t2.so
 // RUN: ld.lld --hash-style=sysv %t.o %t2.so -o %t3
 // RUN: llvm-readobj -s -r --expand-relocs -symbols %t3 | FileCheck %s
 // RUN: llvm-objdump -d -triple=armv7a-none-linux-gnueabi %t3 | FileCheck -check-prefix=CODE %s
 // RUN: llvm-objdump -s -triple=armv7a-none-linux-gnueabi -section=.rodata %t3 | FileCheck -check-prefix=RODATA %s
 
 // Copy relocations R_ARM_COPY are required for y and z
  .syntax unified
  .text

 // ((S + A) & 0xffff0000) >> 16 = 0x1
 // CODE-NEXT:   11004:       01 20 40 e3    movt    r2, #1
 // CODE-NEXT:   11008:       04 30 9f e5    ldr     r3, [pc, #4]
 // CODE-NEXT:   1100c:       00 30 93 e5    ldr     r3, [r3]
 
 
 // RODATA: Contents of section .rodata:
 // S(z) = 0x13004
-// RODATA-NEXT: 10114 04300100
+// RODATA-NEXT: 10160 04300100

test/ELF/arm-execute-only.s

 // REQUIRES: arm
 
 // RUN: llvm-mc -filetype=obj -triple=armv7-pc-linux %s -o %t.o
 // RUN: ld.lld %t.o -o %t.so -shared
 // RUN: llvm-readelf -l %t.so | FileCheck %s
 
 // RUN: ld.lld %t.o %t.o -o %t.so -shared
 // RUN: llvm-readelf -l %t.so | FileCheck %s
 
 // RUN: echo ".section .foo,\"ax\"; \
 // RUN:       bx lr" > %t.s
 // RUN: llvm-mc -filetype=obj -triple=armv7-pc-linux %t.s -o %t2.o
 // RUN: ld.lld %t.o %t2.o -o %t.so -shared
 // RUN: llvm-readelf -l %t.so | FileCheck --check-prefix=DIFF %s
 
 // CHECK-NOT:  LOAD
-// CHECK:      LOAD           0x000000 0x00000000 0x00000000 0x0016d  0x0016d  R   0x1000
+// CHECK:      LOAD           0x000000 0x00000000 0x00000000 0x00170 0x00170  R 0x1000
 // CHECK:      LOAD           0x001000 0x00001000 0x00001000 0x{{.*}} 0x{{.*}} R E 0x1000
 // CHECK:      LOAD           0x002000 0x00002000 0x00002000 0x{{.*}} 0x{{.*}}   E 0x1000
 // CHECK:      LOAD           0x003000 0x00003000 0x00003000 0x00038  0x00038  RW  0x1000
 // CHECK-NOT:  LOAD
 
-// CHECK: 01     .dynsym .gnu.hash .hash .dynstr
+// CHECK: 01     .dynsym .dynstr .gnu.hash .hash
 // CHECK: 02     .text
 // CHECK: 03     .foo
 // CHECK: 04     .dynamic
 
 // DIFF-NOT:  LOAD
-// DIFF:      LOAD           0x000000 0x00000000 0x00000000 0x0014d 0x0014d R   0x1000
+// DIFF:      LOAD           0x000000 0x00000000 0x00000000 0x00150 0x00150 R   0x1000
 // DIFF:      LOAD           0x001000 0x00001000 0x00001000 0x0000c 0x0000c R E 0x1000
 // DIFF:      LOAD           0x002000 0x00002000 0x00002000 0x00038 0x00038 RW  0x1000
 // DIFF-NOT:  LOAD
 
-// DIFF: 01     .dynsym .gnu.hash .hash .dynstr
+// DIFF: 01     .dynsym .dynstr .gnu.hash .hash
 // DIFF: 02     .text .foo
 // DIFF: 03     .dynamic
 
         bx lr
         .section .foo,"axy"
         bx lr

test/ELF/arm-exidx-shared.s

  .global __aeabi_unwind_cpp_pr0
 __aeabi_unwind_cpp_pr0:
  bx lr
 
 // CHECK: Relocations [
 // CHECK-NEXT:   Section (6) .rel.plt {
 // CHECK-NEXT:     0x200C R_ARM_JUMP_SLOT __gxx_personality_v0
 
 // CHECK-EXTAB: Contents of section .ARM.extab:
-// 014c + 0ee4 = 0x1030 = __gxx_personality_v0(PLT)
-// CHECK-EXTAB-NEXT:  014c e40e0000 b0b0b000 00000000
+// 01d8 + 0e58 = 0x1030 = __gxx_personality_v0(PLT)
+// CHECK-EXTAB-NEXT:  01d8 580e0000 b0b0b000 00000000

test/ELF/basic-ppc.s

 # RUN: llvm-mc -filetype=obj -triple=powerpc-unknown-freebsd %s -o %t
 # RUN: ld.lld --hash-style=sysv -discard-all -shared %t -o %t2
 # RUN: llvm-readobj -file-headers -sections -section-data -program-headers %t2 | FileCheck %s
 # REQUIRES: ppc
 
 # exits with return code 42 on FreeBSD
 .text
  li      0,1
  li      3,1
  sc
 
 // CHECK: Format: ELF32-ppc
 // CHECK-NEXT: Arch: powerpc
 // CHECK-NEXT: AddressSize: 32bit
 // CHECK-NEXT: LoadName:
 // CHECK-NEXT: ElfHeader {
 // CHECK-NEXT:   Ident {
 // CHECK-NEXT:     Magic: (7F 45 4C 46)
 // CHECK-NEXT:     Class: 32-bit (0x1)
 // CHECK-NEXT:     DataEncoding: BigEndian (0x2)
 // CHECK-NEXT:     FileVersion: 1
 // CHECK-NEXT:     OS/ABI: FreeBSD (0x9)
 // CHECK-NEXT:     ABIVersion: 0

 // CHECK-NEXT:     Info: 0
 // CHECK-NEXT:     AddressAlignment: 0
 // CHECK-NEXT:     EntrySize: 0
 // CHECK-NEXT:     SectionData (
 // CHECK-NEXT:     )
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Section {
 // CHECK-NEXT:     Index: 1
 // CHECK-NEXT:     Name: .dynsym
 // CHECK-NEXT:     Type: SHT_DYNSYM (0xB)
 // CHECK-NEXT:     Flags [ (0x2)
 // CHECK-NEXT:       SHF_ALLOC (0x2)
 // CHECK-NEXT:     ]
 // CHECK-NEXT:     Address: 0x114
 // CHECK-NEXT:     Offset: 0x114
 // CHECK-NEXT:     Size: 16
-// CHECK-NEXT:     Link: 3
+// CHECK-NEXT:     Link: 2
 // CHECK-NEXT:     Info: 1
 // CHECK-NEXT:     AddressAlignment: 4
 // CHECK-NEXT:     EntrySize: 16
 // CHECK-NEXT:     SectionData (
 // CHECK-NEXT:       0000: 00000000 00000000 00000000 00000000  |................|
 // CHECK-NEXT:     )
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Section {
 // CHECK-NEXT:     Index: 2
-// CHECK-NEXT:     Name: .hash
-// CHECK-NEXT:     Type: SHT_HASH (0x5)
+// CHECK-NEXT:     Name: .dynstr
+// CHECK-NEXT:     Type: SHT_STRTAB (0x3)
 // CHECK-NEXT:     Flags [ (0x2)
 // CHECK-NEXT:       SHF_ALLOC (0x2)
 // CHECK-NEXT:     ]
 // CHECK-NEXT:     Address: 0x124
 // CHECK-NEXT:     Offset: 0x124
-// CHECK-NEXT:     Size: 16
-// CHECK-NEXT:     Link: 1
+// CHECK-NEXT:     Size: 1
+// CHECK-NEXT:     Link: 0
 // CHECK-NEXT:     Info: 0
-// CHECK-NEXT:     AddressAlignment: 4
-// CHECK-NEXT:     EntrySize: 4
+// CHECK-NEXT:     AddressAlignment: 1
+// CHECK-NEXT:     EntrySize: 0
 // CHECK-NEXT:     SectionData (
-// CHECK-NEXT:       0000: 00000001 00000001 00000000 00000000  |................|
+// CHECK-NEXT:       0000: 00                                   |.|
 // CHECK-NEXT:     )
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Section {
 // CHECK-NEXT:     Index: 3
-// CHECK-NEXT:     Name: .dynstr
-// CHECK-NEXT:     Type: SHT_STRTAB (0x3)
+// CHECK-NEXT:     Name: .hash
+// CHECK-NEXT:     Type: SHT_HASH (0x5)
 // CHECK-NEXT:     Flags [ (0x2)
 // CHECK-NEXT:       SHF_ALLOC (0x2)
 // CHECK-NEXT:     ]
-// CHECK-NEXT:     Address: 0x134
-// CHECK-NEXT:     Offset: 0x134
-// CHECK-NEXT:     Size: 1
-// CHECK-NEXT:     Link: 0
+// CHECK-NEXT:     Address: 0x128
+// CHECK-NEXT:     Offset: 0x128
+// CHECK-NEXT:     Size: 16
+// CHECK-NEXT:     Link: 1
 // CHECK-NEXT:     Info: 0
-// CHECK-NEXT:     AddressAlignment: 1
-// CHECK-NEXT:     EntrySize: 0
+// CHECK-NEXT:     AddressAlignment: 4
+// CHECK-NEXT:     EntrySize: 4
 // CHECK-NEXT:     SectionData (
-// CHECK-NEXT:       0000: 00                                   |.|
+// CHECK-NEXT:       0000: 00000001 00000001 00000000 00000000  |................|
 // CHECK-NEXT:     )
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Section {
 // CHECK-NEXT:     Index: 4
 // CHECK-NEXT:     Name: .text
 // CHECK-NEXT:     Type: SHT_PROGBITS (0x1)
 // CHECK-NEXT:     Flags [ (0x6)
 // CHECK-NEXT:       SHF_ALLOC (0x2)

 // CHECK-NEXT:     Type: SHT_DYNAMIC (0x6)
 // CHECK-NEXT:     Flags [ (0x3)
 // CHECK-NEXT:       SHF_ALLOC (0x2)
 // CHECK-NEXT:       SHF_WRITE (0x1)
 // CHECK-NEXT:     ]
 // CHECK-NEXT:     Address: 0x2000
 // CHECK-NEXT:     Offset: 0x2000
 // CHECK-NEXT:     Size: 48
-// CHECK-NEXT:     Link: 3
+// CHECK-NEXT:     Link: 2
 // CHECK-NEXT:     Info: 0
 // CHECK-NEXT:     AddressAlignment: 4
 // CHECK-NEXT:     EntrySize: 8
 // CHECK-NEXT:     SectionData (
 // CHECK-NEXT:       0000: 00000006 00000114 0000000B 00000010  |................|
-// CHECK-NEXT:       0010: 00000005 00000134 0000000A 00000001  |.......4........|
-// CHECK-NEXT:       0020: 00000004 00000124 00000000 00000000  |.......$........|
+// CHECK-NEXT:       0010: 00000005 00000124 0000000A 00000001  |.......$........|
+// CHECK-NEXT:       0020: 00000004 00000128 00000000 00000000  |.......(........|
 // CHECK-NEXT:     )
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Section {
 // CHECK-NEXT:     Index: 6
 // CHECK-NEXT:     Name: .comment
 // CHECK-NEXT:     Type: SHT_PROGBITS (0x1)
 // CHECK-NEXT:     Flags [ (0x30)
 // CHECK-NEXT:       SHF_MERGE (0x10)
 // CHECK-NEXT:       SHF_STRINGS (0x20)
 // CHECK-NEXT:     ]
 // CHECK-NEXT:     Address: 0x0
 // CHECK-NEXT:     Offset: 0x2030
 // CHECK-NEXT:     Size: 8
 // CHECK-NEXT:     Link: 0
 // CHECK-NEXT:     Info: 0
 // CHECK-NEXT:     AddressAlignment: 1
 // CHECK-NEXT:     EntrySize: 1
 // CHECK-NEXT:     SectionData (
-// CHECK-NEXT:       0000: 4C4C4420 312E3000 |LLD 1.0.|
+// CHECK-NEXT:       0000: 4C4C4420 312E3000                    |LLD 1.0.|
 // CHECK-NEXT:     )
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Section {
 // CHECK-NEXT:     Index: 7
 // CHECK-NEXT:     Name: .symtab
 // CHECK-NEXT:     Type: SHT_SYMTAB (0x2)
 // CHECK-NEXT:     Flags [ (0x0)
 // CHECK-NEXT:     ]

 // CHECK-NEXT:     Address: 0x0
 // CHECK-NEXT:     Offset: 0x2058
 // CHECK-NEXT:     Size: 73
 // CHECK-NEXT:     Link: 0
 // CHECK-NEXT:     Info: 0
 // CHECK-NEXT:     AddressAlignment: 1
 // CHECK-NEXT:     EntrySize: 0
 // CHECK-NEXT:     SectionData (
-// CHECK-NEXT:       0000: 002E6479 6E73796D 002E6861 7368002E  |..dynsym..hash..|
-// CHECK-NEXT:       0010: 64796E73 7472002E 74657874 002E6479  |dynstr..text..dy|
+// CHECK-NEXT:       0000: 002E6479 6E73796D 002E6479 6E737472  |..dynsym..dynstr|
+// CHECK-NEXT:       0010: 002E6861 7368002E 74657874 002E6479  |..hash..text..dy|
 // CHECK-NEXT:       0020: 6E616D69 63002E63 6F6D6D65 6E74002E  |namic..comment..|
 // CHECK-NEXT:       0030: 73796D74 6162002E 73687374 72746162  |symtab..shstrtab|
 // CHECK-NEXT:       0040: 002E7374 72746162 00                 |..strtab.|
 // CHECK-NEXT:     )
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Section {
 // CHECK-NEXT:     Index: 9
 // CHECK-NEXT:     Name: .strtab
 // CHECK-NEXT:     Type: SHT_STRTAB (0x3)
 // CHECK-NEXT:     Flags [ (0x0)
 // CHECK-NEXT:     ]
 // CHECK-NEXT:     Address: 0x0
 // CHECK-NEXT:     Offset: 0x20A1
-// CHECK-NEXT:     Size: 1
+// CHECK-NEXT:     Size: 10
 // CHECK-NEXT:     Link: 0
 // CHECK-NEXT:     Info: 0
 // CHECK-NEXT:     AddressAlignment: 1
 // CHECK-NEXT:     EntrySize: 0
 // CHECK-NEXT:     SectionData (
 // CHECK-NEXT:       0000: 005F4459 4E414D49 4300               |._DYNAMIC.|
 // CHECK-NEXT:     )
 // CHECK-NEXT:   }

 // CHECK-NEXT:     ]
 // CHECK-NEXT:     Alignment: 4
 // CHECK-NEXT:   }
 // CHECK-NEXT:   ProgramHeader {
 // CHECK-NEXT:     Type: PT_LOAD (0x1)
 // CHECK-NEXT:     Offset: 0x0
 // CHECK-NEXT:     VirtualAddress: 0x0
 // CHECK-NEXT:     PhysicalAddress: 0x0
-// CHECK-NEXT:     FileSize: 309
-// CHECK-NEXT:     MemSize: 309
+// CHECK-NEXT:     FileSize: 312
+// CHECK-NEXT:     MemSize: 312
 // CHECK-NEXT:     Flags [ (0x4)
 // CHECK-NEXT:       PF_R (0x4)
 // CHECK-NEXT:     ]
 // CHECK-NEXT:     Alignment: 4096
 // CHECK-NEXT:   }
 // CHECK-NEXT:   ProgramHeader {
 // CHECK-NEXT:     Type: PT_LOAD (0x1)
 // CHECK-NEXT:     Offset: 0x1000

test/ELF/basic-ppc64.s

 // CHECK-NEXT:    Name: .dynsym (1)
 // CHECK-NEXT:    Type: SHT_DYNSYM (0xB)
 // CHECK-NEXT:    Flags [ (0x2)
 // CHECK-NEXT:      SHF_ALLOC (0x2)
 // CHECK-NEXT:    ]
 // CHECK-NEXT:    Address: 0x1C8
 // CHECK-NEXT:    Offset: 0x1C8
 // CHECK-NEXT:    Size: 24
-// CHECK-NEXT:    Link: 3
+// CHECK-NEXT:    Link: 2
 // CHECK-NEXT:    Info: 1
 // CHECK-NEXT:    AddressAlignment: 8
 // CHECK-NEXT:    EntrySize: 24
 // CHECK-NEXT:    SectionData (
 // CHECK-NEXT:      0000: 00000000 00000000 00000000 00000000  |................|
 // CHECK-NEXT:      0010: 00000000 00000000                    |........|
 // CHECK-NEXT:    )
 // CHECK-NEXT:  }
 // CHECK-NEXT:  Section {
 // CHECK-NEXT:    Index: 2
-// CHECK-NEXT:    Name: .hash (9)
-// CHECK-NEXT:    Type: SHT_HASH (0x5)
+// CHECK-NEXT:    Name: .dynstr (9)
+// CHECK-NEXT:    Type: SHT_STRTAB (0x3)
 // CHECK-NEXT:    Flags [ (0x2)
 // CHECK-NEXT:      SHF_ALLOC (0x2)
 // CHECK-NEXT:    ]
 // CHECK-NEXT:    Address: 0x1E0
 // CHECK-NEXT:    Offset: 0x1E0
-// CHECK-NEXT:    Size: 16
-// CHECK-NEXT:    Link: 1
+// CHECK-NEXT:    Size: 1
+// CHECK-NEXT:    Link: 0
 // CHECK-NEXT:    Info: 0
-// CHECK-NEXT:    AddressAlignment: 4
-// CHECK-NEXT:    EntrySize: 4
+// CHECK-NEXT:    AddressAlignment: 1
+// CHECK-NEXT:    EntrySize: 0
 // CHECK-NEXT:    SectionData (
-// CHECK-NEXT:      0000: 01000000 01000000 00000000 00000000  |................|
+// CHECK-NEXT:      0000: 00                                   |.|
 // CHECK-NEXT:    )
 // CHECK-NEXT:  }
 // CHECK-NEXT:  Section {
 // CHECK-NEXT:    Index: 3
-// CHECK-NEXT:    Name: .dynstr (15)
-// CHECK-NEXT:    Type: SHT_STRTAB (0x3)
+// CHECK-NEXT:    Name: .hash (17)
+// CHECK-NEXT:    Type: SHT_HASH (0x5)
 // CHECK-NEXT:    Flags [ (0x2)
 // CHECK-NEXT:      SHF_ALLOC (0x2)
 // CHECK-NEXT:    ]
-// CHECK-NEXT:    Address: 0x1F0
-// CHECK-NEXT:    Offset: 0x1F0
-// CHECK-NEXT:    Size: 1
-// CHECK-NEXT:    Link: 0
+// CHECK-NEXT:    Address: 0x1E4
+// CHECK-NEXT:    Offset: 0x1E4
+// CHECK-NEXT:    Size: 16
+// CHECK-NEXT:    Link: 1
 // CHECK-NEXT:    Info: 0
-// CHECK-NEXT:    AddressAlignment: 1
-// CHECK-NEXT:    EntrySize: 0
+// CHECK-NEXT:    AddressAlignment: 4
+// CHECK-NEXT:    EntrySize: 4
 // CHECK-NEXT:    SectionData (
-// CHECK-NEXT:      0000: 00                                   |.|
+// CHECK-NEXT:      0000: 01000000 01000000 00000000 00000000  |................|
 // CHECK-NEXT:    )
 // CHECK-NEXT:  }
 // CHECK-NEXT:  Section {
 // CHECK-NEXT:    Index: 4
 // CHECK-NEXT:    Name: .text (23)
 // CHECK-NEXT:    Type: SHT_PROGBITS (0x1)
 // CHECK-NEXT:    Flags [ (0x6)
 // CHECK-NEXT:      SHF_ALLOC (0x2)

 // CHECK-NEXT:    Type: SHT_DYNAMIC (0x6)
 // CHECK-NEXT:    Flags [ (0x3)
 // CHECK-NEXT:      SHF_ALLOC (0x2)
 // CHECK-NEXT:      SHF_WRITE (0x1)
 // CHECK-NEXT:    ]
 // CHECK-NEXT:    Address: 0x20000
 // CHECK-NEXT:    Offset: 0x20000
 // CHECK-NEXT:    Size: 96
-// CHECK-NEXT:    Link: 3
+// CHECK-NEXT:    Link: 2
 // CHECK-NEXT:    Info: 0
 // CHECK-NEXT:    AddressAlignment: 8
 // CHECK-NEXT:    EntrySize: 16
 // CHECK-NEXT:    SectionData (
 // CHECK-NEXT:      0000: 06000000 00000000 C8010000 00000000  |................|
 // CHECK-NEXT:      0010: 0B000000 00000000 18000000 00000000  |................|
-// CHECK-NEXT:      0020: 05000000 00000000 F0010000 00000000  |................|
+// CHECK-NEXT:      0020: 05000000 00000000 E0010000 00000000  |................|
 // CHECK-NEXT:      0030: 0A000000 00000000 01000000 00000000  |................|
-// CHECK-NEXT:      0040: 04000000 00000000 E0010000 00000000  |................|
+// CHECK-NEXT:      0040: 04000000 00000000 E4010000 00000000  |................|
 // CHECK-NEXT:      0050: 00000000 00000000 00000000 00000000  |................|
 // CHECK-NEXT:    )
 // CHECK-NEXT:  }
 // CHECK-NEXT:  Section {
 // CHECK-NEXT:    Index: 6
 // CHECK-NEXT:    Name: .comment (38)
 // CHECK-NEXT:    Type: SHT_PROGBITS (0x1)
 // CHECK-NEXT:    Flags [ (0x30)
 // CHECK-NEXT:      SHF_MERGE (0x10)
 // CHECK-NEXT:      SHF_STRINGS (0x20)
 // CHECK-NEXT:    ]
 // CHECK-NEXT:    Address: 0x0
 // CHECK-NEXT:    Offset: 0x20060
 // CHECK-NEXT:    Size: 8
 // CHECK-NEXT:    Link: 0
 // CHECK-NEXT:    Info: 0
 // CHECK-NEXT:    AddressAlignment: 1
 // CHECK-NEXT:    EntrySize: 1
 // CHECK-NEXT:    SectionData (
-// CHECK-NEXT:      0000: 4C4C4420 312E3000 |LLD 1.0.|
+// CHECK-NEXT:      0000: 4C4C4420 312E3000                    |LLD 1.0.|
 // CHECK-NEXT:    )
 // CHECK-NEXT:  }
 // CHECK-NEXT:  Section {
 // CHECK-NEXT:    Index: 7
 // CHECK-NEXT:    Name: .symtab (47)
 // CHECK-NEXT:    Type: SHT_SYMTAB (0x2)
 // CHECK-NEXT:    Flags [ (0x0)
 // CHECK-NEXT:    ]

 // CHECK-NEXT:    Address: 0x0
 // CHECK-NEXT:    Offset: 0x20098
 // CHECK-NEXT:    Size: 73
 // CHECK-NEXT:    Link: 0
 // CHECK-NEXT:    Info: 0
 // CHECK-NEXT:    AddressAlignment: 1
 // CHECK-NEXT:    EntrySize: 0
 // CHECK-NEXT:    SectionData (
-// CHECK-NEXT:      0000: 002E6479 6E73796D 002E6861 7368002E  |..dynsym..hash..|
-// CHECK-NEXT:      0010: 64796E73 7472002E 74657874 002E6479  |dynstr..text..dy|
+// CHECK-NEXT:      0000: 002E6479 6E73796D 002E6479 6E737472  |..dynsym..dynstr|
+// CHECK-NEXT:      0010: 002E6861 7368002E 74657874 002E6479  |..hash..text..dy|
 // CHECK-NEXT:      0020: 6E616D69 63002E63 6F6D6D65 6E74002E  |namic..comment..|
 // CHECK-NEXT:      0030: 73796D74 6162002E 73687374 72746162  |symtab..shstrtab|
 // CHECK-NEXT:      0040: 002E7374 72746162 00                 |..strtab.|
 // CHECK-NEXT:    )
 // CHECK-NEXT:  }
 // CHECK-NEXT:  Section {
 // CHECK-NEXT:    Index: 9
 // CHECK-NEXT:    Name: .strtab (65)

 // CHECK-NEXT:    ]
 // CHECK-NEXT:    Alignment: 8
 // CHECK-NEXT:  }
 // CHECK-NEXT:  ProgramHeader {
 // CHECK-NEXT:    Type: PT_LOAD (0x1)
 // CHECK-NEXT:    Offset: 0x0
 // CHECK-NEXT:    VirtualAddress: 0x0
 // CHECK-NEXT:    PhysicalAddress: 0x0
-// CHECK-NEXT:    FileSize: 497
-// CHECK-NEXT:    MemSize: 497
+// CHECK-NEXT:    FileSize: 500
+// CHECK-NEXT:    MemSize: 500
 // CHECK-NEXT:    Flags [ (0x4)
 // CHECK-NEXT:      PF_R (0x4)
 // CHECK-NEXT:    ]
 // CHECK-NEXT:    Alignment: 65536
 // CHECK-NEXT:  }
 // CHECK-NEXT:  ProgramHeader {
 // CHECK-NEXT:    Type: PT_LOAD (0x1)
 // CHECK-NEXT:    Offset: 0x10000

test/ELF/dynamic-no-rosegment.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: ld.lld -shared --no-rosegment -z rodynamic -o %t %t.o
 # RUN: llvm-readobj -dynamic-table -s %t | FileCheck %s
 
 # CHECK:      DynamicSection [ (7 entries)
 # CHECK-NEXT:   Tag                Type                 Name/Value
 # CHECK-NEXT:   0x0000000000000006 SYMTAB               0x120
 # CHECK-NEXT:   0x000000000000000B SYMENT               24 (bytes)
-# CHECK-NEXT:   0x0000000000000005 STRTAB               0x1D8
+# CHECK-NEXT:   0x0000000000000005 STRTAB               0x138
 # CHECK-NEXT:   0x000000000000000A STRSZ                1 (bytes)
-# CHECK-NEXT:   0x000000006FFFFEF5 GNU_HASH             0x138
-# CHECK-NEXT:   0x0000000000000004 HASH                 0x154
+# CHECK-NEXT:   0x000000006FFFFEF5 GNU_HASH             0x140
+# CHECK-NEXT:   0x0000000000000004 HASH                 0x15C
 # CHECK-NEXT:   0x0000000000000000 NULL                 0x0
 # CHECK-NEXT: ]

test/ELF/dynsec-at-beginning.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t
+
+# RUN: ld.lld --hash-style=gnu -o %t1  %t -shared
+# RUN: llvm-readobj -elf-output-style=GNU -s %t1 | FileCheck %s
+
+# Dynamic symbol and dynamic strtab sections are at the beginning of
+# SHF_ALLOC sections.
+# CHECK:      .dynsym  {{.*}}   A
+# CHECK-NEXT: .dynstr  {{.*}}   A
+# CHECK-NEXT: foo      {{.*}}   A
+# CHECK-NEXT: .hash    {{.*}}   A
+# CHECK-NEXT: .text    {{.*}}   AX
+
+.section foo, "a"
+.byte 0

test/ELF/eh-frame-padding-no-rosegment.s

 // CHECK-NEXT: Offset:
 // CHECK-NEXT: Size:
 // CHECK-NEXT: Link:
 // CHECK-NEXT: Info:
 // CHECK-NEXT: AddressAlignment:
 // CHECK-NEXT: EntrySize:
 // CHECK-NEXT: SectionData (
 // CHECK-NEXT:   0000: 1C000000 00000000 017A5052 00017810
-// CHECK-NEXT:   0010: 061BBEFF FFFF1B0C 07089001 00000000
-// CHECK-NEXT:   0020: 14000000 24000000 A8FFFFFF 00000000
+// CHECK-NEXT:   0010: 061BDAFF FFFF1B0C 07089001 00000000
+// CHECK-NEXT:   0020: 14000000 24000000 C4FFFFFF 00000000
 // CHECK-NEXT:   0030: 00000000 00000000
 // CHECK-NEXT: )

test/ELF/gc-merge-local-sym.s

 // RUN: llvm-mc %s -o %t.o -filetype=obj -triple=x86_64-pc-linux
 // RUN: ld.lld %t.o -o %t.so -shared -O3 --gc-sections
 // RUN: llvm-readobj -s -section-data -t %t.so | FileCheck %s
 
 // CHECK:      Name: .rodata
 // 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: Address: 0x1FD
 // CHECK-NEXT: Offset:
 // CHECK-NEXT: Size: 4
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 1
 // CHECK-NEXT: EntrySize: 1
 // CHECK-NEXT: SectionData (
 // CHECK-NEXT:   0000: 61626300 |abc.|

test/ELF/gnu-ifunc-dyntags.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: ld.lld -pie %t.o -o %tout
 # RUN: llvm-objdump -section-headers %tout | FileCheck %s
 # RUN: llvm-readobj -dynamic-table -r %tout | FileCheck %s --check-prefix=TAGS
 
 ## Check we produce DT_PLTREL/DT_JMPREL/DT_PLTGOT and DT_PLTRELSZ tags
 ## when there are no other relocations except R_*_IRELATIVE.
 
 # CHECK:  Name          Size      Address
-# CHECK:  .rela.plt   00000030 0000000000000210
+# CHECK:  .rela.plt   00000030 0000000000000218
 # CHECK:  .got.plt    00000010 0000000000002000
 
 # TAGS:      Relocations [
 # TAGS-NEXT:   Section {{.*}} .rela.plt {
 # TAGS-NEXT:     R_X86_64_IRELATIVE
 # TAGS-NEXT:     R_X86_64_IRELATIVE
 # TAGS-NEXT:   }
 # TAGS-NEXT: ]
 
 # TAGS:   Tag                Type                 Name/Value
-# TAGS:   0x0000000000000017 JMPREL               0x210
+# TAGS:   0x0000000000000017 JMPREL               0x218
 # TAGS:   0x0000000000000002 PLTRELSZ             48
 # TAGS:   0x0000000000000003 PLTGOT               0x2000
 # TAGS:   0x0000000000000014 PLTREL               RELA
 
 .text
 .type foo STT_GNU_IFUNC
 .globl foo
 foo:

test/ELF/i386-merge.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=i386-pc-linux %s -o %t.o
 // RUN: ld.lld %t.o -o %t -shared
 // RUN: llvm-readobj -s -section-data %t | FileCheck %s
 
 // CHECK:      Name: .mysec
 // CHECK-NEXT: Type:
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_MERGE
 // CHECK-NEXT: ]
-// CHECK-NEXT: Address: 0x114
+// CHECK-NEXT: Address: 0x128
 // CHECK-NEXT: Offset:
 // CHECK-NEXT: Size:
 // CHECK-NEXT: Link:
 // CHECK-NEXT: Info:
 // CHECK-NEXT: AddressAlignment:
 // CHECK-NEXT: EntrySize:
 // CHECK-NEXT: SectionData (
 // CHECK-NEXT:   0000: 42000000 |

 // CHECK-NEXT: Address: 0x1000
 // CHECK-NEXT: Offset: 0x1000
 // CHECK-NEXT: Size: 4
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 1
 // CHECK-NEXT: EntrySize: 0
 // CHECK-NEXT: SectionData (
-// CHECK-NEXT:   0000: 14010000 |
+// CHECK-NEXT:   0000: 28010000 |
 // CHECK-NEXT: )
 
 // The content of .data should be the address of .mysec. 14010000 is 0x114 in
 // little endian.
 
         .data
         .long .mysec+4
 
         .section        .mysec,"aM",@progbits,4
         .align  4
         .long   0x42
         .long   0x42

test/ELF/i386-retpoline-nopic-linkerscript.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=i386-unknown-linux %s -o %t1.o
 // RUN: llvm-mc -filetype=obj -triple=i386-unknown-linux %p/Inputs/shared.s -o %t2.o
 // RUN: ld.lld -shared %t2.o -o %t2.so
 
 // RUN: echo "SECTIONS { \
 // RUN:   .text : { *(.text) } \
 // RUN:   .plt : { *(.plt) } \
 // RUN:   .got.plt : { *(.got.plt) } \
 // RUN:   .dynstr : { *(.dynstr) } \
 // RUN: }" > %t.script
 // RUN: ld.lld %t1.o %t2.so -o %t.exe -z retpolineplt --script %t.script
 // RUN: llvm-objdump -d -s %t.exe | FileCheck %s
 
 // CHECK:      Disassembly of section .plt:
 // CHECK-NEXT: .plt:
-// CHECK-NEXT: 10:       ff 35 fc 00 00 00       pushl   252
+// CHECK-NEXT: 10:       ff 35 cc 00 00 00       pushl   204
 // CHECK-NEXT: 16:       50      pushl   %eax
-// CHECK-NEXT: 17:       a1 00 01 00 00  movl    256, %eax
+// CHECK-NEXT: 17:       a1 d0 00 00 00 movl    208, %eax
 // CHECK-NEXT: 1c:       e8 0f 00 00 00  calll   15 <.plt+0x20>
 // CHECK-NEXT: 21:       f3 90   pause
 // CHECK-NEXT: 23:       0f ae e8        lfence
 // CHECK-NEXT: 26:       eb f9   jmp     -7 <.plt+0x11>
 // CHECK-NEXT: 28:       cc      int3
 // CHECK-NEXT: 29:       cc      int3
 // CHECK-NEXT: 2a:       cc      int3
 // CHECK-NEXT: 2b:       cc      int3
 // CHECK-NEXT: 2c:       cc      int3
 // CHECK-NEXT: 2d:       cc      int3
 // CHECK-NEXT: 2e:       cc      int3
 // CHECK-NEXT: 2f:       cc      int3
 // CHECK-NEXT: 30:       89 0c 24        movl    %ecx, (%esp)
 // CHECK-NEXT: 33:       8b 4c 24 04     movl    4(%esp), %ecx
 // CHECK-NEXT: 37:       89 44 24 04     movl    %eax, 4(%esp)
 // CHECK-NEXT: 3b:       89 c8   movl    %ecx, %eax
 // CHECK-NEXT: 3d:       59      popl    %ecx
 // CHECK-NEXT: 3e:       c3      retl
 // CHECK-NEXT: 3f:       cc      int3
 // CHECK-NEXT: 40:       50      pushl   %eax
-// CHECK-NEXT: 41:       a1 04 01 00 00  movl    260, %eax
+// CHECK-NEXT: 41:       a1 d4 00 00 00  movl    212, %eax
 // CHECK-NEXT: 46:       e8 e5 ff ff ff  calll   -27 <.plt+0x20>
 // CHECK-NEXT: 4b:       e9 d1 ff ff ff  jmp     -47 <.plt+0x11>
 // CHECK-NEXT: 50:       68 00 00 00 00  pushl   $0
 // CHECK-NEXT: 55:       e9 b6 ff ff ff  jmp     -74 <.plt>
 // CHECK-NEXT: 5a:       cc      int3
 // CHECK-NEXT: 5b:       cc      int3
 // CHECK-NEXT: 5c:       cc      int3
 // CHECK-NEXT: 5d:       cc      int3
 // CHECK-NEXT: 5e:       cc      int3
 // CHECK-NEXT: 5f:       cc      int3
 // CHECK-NEXT: 60:       50      pushl   %eax
-// CHECK-NEXT: 61:       a1 08 01 00 00  movl    264, %eax
+// CHECK-NEXT: 61:       a1 d8 00 00 00  movl    216, %eax
 // CHECK-NEXT: 66:       e8 c5 ff ff ff  calll   -59 <.plt+0x20>
 // CHECK-NEXT: 6b:       e9 b1 ff ff ff  jmp     -79 <.plt+0x11>
 // CHECK-NEXT: 70:       68 08 00 00 00  pushl   $8
 // CHECK-NEXT: 75:       e9 96 ff ff ff  jmp     -106 <.plt>
 // CHECK-NEXT: 7a:       cc      int3
 // CHECK-NEXT: 7b:       cc      int3
 // CHECK-NEXT: 7c:       cc      int3
 // CHECK-NEXT: 7d:       cc      int3
 // CHECK-NEXT: 7e:       cc      int3
 // CHECK-NEXT: 7f:       cc      int3
 
 .global _start
 _start:
   jmp bar@PLT
   jmp zed@PLT

test/ELF/i386-retpoline-pic-linkerscript.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=i386-unknown-linux -position-independent %s -o %t1.o
 // RUN: llvm-mc -filetype=obj -triple=i386-unknown-linux -position-independent %p/Inputs/shared.s -o %t2.o
 // RUN: ld.lld -shared %t2.o -o %t2.so
 
 // RUN: echo "SECTIONS { \
 // RUN:   .text : { *(.text) } \
 // RUN:   .plt : { *(.plt) } \
 // RUN:   .got.plt : { *(.got.plt) } \
 // RUN:   .dynstr : { *(.dynstr) } \
 // RUN: }" > %t.script
 // RUN: ld.lld %t1.o %t2.so -o %t.exe -z retpolineplt -pie --script %t.script
 // RUN: llvm-objdump -d -s %t.exe | FileCheck %s
 
 // CHECK:      Disassembly of section .plt:
 // CHECK-NEXT: .plt:
-// CHECK-NEXT: 10:       ff b3 fc 00 00 00       pushl   252(%ebx)
+// CHECK-NEXT: 10:       ff b3 cc 00 00 00       pushl   204(%ebx)
 // CHECK-NEXT: 16:       50      pushl   %eax
-// CHECK-NEXT: 17:       8b 83 00 01 00 00       movl    256(%ebx), %eax
+// CHECK-NEXT: 17:       8b 83 d0 00 00 00 movl    208(%ebx), %eax
 // CHECK-NEXT: 1d:       e8 0e 00 00 00  calll   14 <.plt+0x20>
 // CHECK-NEXT: 22:       f3 90   pause
 // CHECK-NEXT: 24:       0f ae e8        lfence
 // CHECK-NEXT: 27:       eb f9   jmp     -7 <.plt+0x12>
 // CHECK-NEXT: 29:       cc      int3
 // CHECK-NEXT: 2a:       cc      int3
 // CHECK-NEXT: 2b:       cc      int3
 // CHECK-NEXT: 2c:       cc      int3
 // CHECK-NEXT: 2d:       cc      int3
 // CHECK-NEXT: 2e:       cc      int3
 // CHECK-NEXT: 2f:       cc      int3
 // CHECK-NEXT: 30:       89 0c 24        movl    %ecx, (%esp)
 // CHECK-NEXT: 33:       8b 4c 24 04     movl    4(%esp), %ecx
 // CHECK-NEXT: 37:       89 44 24 04     movl    %eax, 4(%esp)
 // CHECK-NEXT: 3b:       89 c8   movl    %ecx, %eax
 // CHECK-NEXT: 3d:       59      popl    %ecx
 // CHECK-NEXT: 3e:       c3      retl
 // CHECK-NEXT: 3f:       cc      int3
 // CHECK-NEXT: 40:       50      pushl   %eax
-// CHECK-NEXT: 41:       8b 83 04 01 00 00       movl    260(%ebx), %eax
+// CHECK-NEXT: 41:       8b 83 d4 00 00 00       movl    212(%ebx), %eax
 // CHECK-NEXT: 47:       e8 e4 ff ff ff  calll   -28 <.plt+0x20>
 // CHECK-NEXT: 4c:       e9 d1 ff ff ff  jmp     -47 <.plt+0x12>
 // CHECK-NEXT: 51:       68 00 00 00 00  pushl   $0
 // CHECK-NEXT: 56:       e9 b5 ff ff ff  jmp     -75 <.plt>
 // CHECK-NEXT: 5b:       cc      int3
 // CHECK-NEXT: 5c:       cc      int3
 // CHECK-NEXT: 5d:       cc      int3
 // CHECK-NEXT: 5e:       cc      int3
 // CHECK-NEXT: 5f:       cc      int3
 // CHECK-NEXT: 60:       50      pushl   %eax
-// CHECK-NEXT: 61:       8b 83 08 01 00 00       movl    264(%ebx), %eax
+// CHECK-NEXT: 61:       8b 83 d8 00 00 00       movl    216(%ebx), %eax
 // CHECK-NEXT: 67:       e8 c4 ff ff ff  calll   -60 <.plt+0x20>
 // CHECK-NEXT: 6c:       e9 b1 ff ff ff  jmp     -79 <.plt+0x12>
 // CHECK-NEXT: 71:       68 08 00 00 00  pushl   $8
 // CHECK-NEXT: 76:       e9 95 ff ff ff  jmp     -107 <.plt>
 // CHECK-NEXT: 7b:       cc      int3
 // CHECK-NEXT: 7c:       cc      int3
 // CHECK-NEXT: 7d:       cc      int3
 // CHECK-NEXT: 7e:       cc      int3
 // CHECK-NEXT: 7f:       cc      int3
 
 .global _start
 _start:
   jmp bar@PLT
   jmp zed@PLT

test/ELF/linkerscript/addr-zero.test

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux /dev/null -o %t.o
 # RUN: ld.lld -o %t.so --script %s %t.o -shared
 # RUN: llvm-readobj --symbols %t.so | FileCheck %s
 
 # Test that the script creates a non absolute symbol with value
 # 0 I.E., a symbol that refers to the load address.
 
 # CHECK:      Symbol {
 # CHECK:        Name: foo
-# CHECK-NEXT:   Value: 0x0
+# CHECK-NEXT:   Value: 0x38
 # CHECK-NEXT:   Size: 0
 # CHECK-NEXT:   Binding: Global
 # CHECK-NEXT:   Type: None
 # CHECK-NEXT:   Other: 0
 # CHECK-NEXT:   Section: .text
 # CHECK-NEXT: }
 
 SECTIONS {
   foo = ADDR(.text) - ABSOLUTE(ADDR(.text));
 };

test/ELF/linkerscript/align-empty.test

SECTIONS {
   abc : {}
   . = ALIGN(0x1000);
   foo : { *(foo) }
 }
 
 # CHECK:      Sections:
 # CHECK-NEXT: Idx Name          Size      Address
 # CHECK-NEXT:   0               00000000 0000000000000000
-# CHECK-NEXT:   1 foo           00000001 0000000000001000
+# CHECK-NEXT:   1 .dynsym       00000018 0000000000000190
+# CHECK-NEXT:   2 .dynstr       00000001 00000000000001a8
+# CHECK-NEXT:   3 foo           00000001 0000000000001000

test/ELF/linkerscript/dot-is-not-abs.s

 # CHECK:      Section {
 # CHECK:        Index:
 # CHECK:        Name: .text
 # CHECK-NEXT:   Type: SHT_PROGBITS
 # CHECK-NEXT:   Flags [
 # CHECK-NEXT:     SHF_ALLOC
 # CHECK-NEXT:     SHF_EXECINSTR
 # CHECK-NEXT:   ]
-# CHECK-NEXT:   Address: 0x0
+# CHECK-NEXT:   Address: 0x1C
 # CHECK-NEXT:   Offset:
 # CHECK-NEXT:   Size: 4
 # CHECK-NEXT:   Link:
 # CHECK-NEXT:   Info:
 # CHECK-NEXT:   AddressAlignment:
 # CHECK-NEXT:   EntrySize:
 # CHECK-NEXT:   SectionData (
 # CHECK-NEXT:     0000: 04000000 |
 # CHECK-NEXT:   )
 # CHECK-NEXT: }
 
 # CHECK:      Symbol {
 # CHECK:        Name: foo
-# CHECK-NEXT:   Value: 0x4
+# CHECK-NEXT:   Value: 0x20
 # CHECK-NEXT:   Size: 0
 # CHECK-NEXT:   Binding: Local
 # CHECK-NEXT:   Type: None
 # CHECK-NEXT:   Other [
 # CHECK-NEXT:     STV_HIDDEN
 # CHECK-NEXT:   ]
 # CHECK-NEXT:   Section: .text
 # CHECK-NEXT: }

test/ELF/linkerscript/emit-reloc.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: echo "SECTIONS { .rela.dyn : { *(.rela.data) } }" > %t.script
 # RUN: ld.lld --hash-style=sysv -T %t.script --emit-relocs %t.o -o %t.so -shared
 # RUN: llvm-readobj -r %t.so | FileCheck %s
 
 .data
 .quad .foo
 
 # CHECK:      Relocations [
 # CHECK-NEXT:   Section ({{.*}}) .rela.dyn {
-# CHECK-NEXT:     0x66 R_X86_64_64 .foo 0x0
+# CHECK-NEXT:     0x68 R_X86_64_64 .foo 0x0
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Section ({{.*}}) .rela.data {
-# CHECK-NEXT:     0x66 R_X86_64_64 .foo 0x0
+# CHECK-NEXT:     0x68 R_X86_64_64 .foo 0x0
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]

test/ELF/linkerscript/expr-sections.test

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux /dev/null -o %t.o
 # RUN: ld.lld -o %t.so --script %s %t.o -shared
 # RUN: llvm-objdump -t -h %t.so | FileCheck %s
 
 SECTIONS {
   . = . + 4;
   .text : {
     *(.text)
     foo1 = ADDR(.text) + 1; bar1 = 1 + ADDR(.text);
     foo2 = ADDR(.text) & 1; bar2 = 1 & ADDR(.text);
     foo3 = ADDR(.text) | 1; bar3 = 1 | ADDR(.text);
   }
 };
 
-# CHECK:  1 .text         00000000 0000000000000004 TEXT DATA
+# CHECK:  3 .text         00000000 00000000000000d0 TEXT DATA
 
-# CHECK: 0000000000000005         .text    00000000 foo1
-# CHECK: 0000000000000005         .text    00000000 bar1
+# CHECK: 00000000000000d1         .text    00000000 foo1
+# CHECK: 00000000000000d1         .text    00000000 bar1
 # CHECK: 0000000000000000         .text    00000000 foo2
 # CHECK: 0000000000000000         .text    00000000 bar2
-# CHECK: 0000000000000005         .text    00000000 foo3
-# CHECK: 0000000000000005         .text    00000000 bar3
+# CHECK: 00000000000000d1         .text    00000000 foo3
+# CHECK: 00000000000000d1         .text    00000000 bar3

test/ELF/linkerscript/implicit-program-header.test

 # REQUIRES: x86
 
 # RUN: echo '.section .text,"ax"; .quad 0' > %t.s
 # RUN: echo '.section .foo,"ax"; .quad 0' >> %t.s
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %t.s -o %t.o
 # RUN: ld.lld --hash-style=sysv -o %t1 --script %s  \
 # RUN:   %t.o -shared
 # RUN: llvm-readobj -elf-output-style=GNU -l %t1 | FileCheck %s
 
 # CHECK:      Segment Sections...
-# CHECK-NEXT:   00     .text .dynsym .hash .dynstr .dynamic
-# CHECK-NEXT:   01     .bar .foo
+# CHECK-NEXT:   00     .text .hash .dynamic
+# CHECK-NEXT:   01     .bar .dynsym .dynstr .foo
 
 PHDRS {
   ph_write PT_LOAD FLAGS(2);
   ph_exec  PT_LOAD FLAGS(1);
 }
 
 SECTIONS {
   .bar : { *(.bar) } : ph_exec
   .foo : { *(.foo) }
   .text : { *(.text) } : ph_write
 }

test/ELF/linkerscript/locationcountererr2.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: echo "SECTIONS {" > %t.script
-# RUN: echo ". = 0x20; . = 0x10; .text : {} }" >> %t.script
+# RUN: echo ". = 0x150; . = 0x10; .text : {} }" >> %t.script
 # RUN: ld.lld %t.o --script %t.script -o %t -shared
 # RUN: llvm-objdump -section-headers %t | FileCheck %s
 # CHECK: Idx Name   Size      Address
-# CHECK:  1 .text 00000000 0000000000000010
+# CHECK:  3 .text 00000000 0000000000000010
 
 # RUN: echo "SECTIONS { . = 0x20; . = ASSERT(0x1, "foo"); }" > %t2.script
 # RUN: ld.lld %t.o --script %t2.script -o %t -shared

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

 # CHECK-NEXT:     Size:
 # CHECK-NEXT:     Binding:
 # CHECK-NEXT:     Type:
 # CHECK-NEXT:     Other:
 # CHECK-NEXT:     Section:
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Symbol {
 # CHECK-NEXT:     Name: A
-# CHECK-NEXT:     Value: 0x195
+# CHECK-NEXT:     Value: 0x1E2
 # CHECK-NEXT:     Size:
 # CHECK-NEXT:     Binding:
 # CHECK-NEXT:     Type:
 # CHECK-NEXT:     Other:
 # CHECK-NEXT:     Section:
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Symbol {
 # CHECK-NEXT:     Name: B
-# CHECK-NEXT:     Value: 0x196
+# CHECK-NEXT:     Value: 0x1E3
 # CHECK-NEXT:     Size:
 # CHECK-NEXT:     Binding:
 # CHECK-NEXT:     Type:
 # CHECK-NEXT:     Other:
 # CHECK-NEXT:     Section:
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]
 

test/ELF/linkerscript/merge-sections.s

 # CHECK-NEXT:   EntrySize: 0
 # CHECK-NEXT: }
 
 # CHECK:      Name: begin
 # CHECK-NEXT: Value: 0x[[ADDR1]]
 
 # CHECK:      Name: end
 # 0x19E = begin + sizeof(.foo) = 0x190 + 0xE
-# CHECK-NEXT: Value: 0x19E
+# CHECK-NEXT: Value: 0x1F2
 
 # Check that we don't crash with --gc-sections
 # RUN: ld.lld --gc-sections -o %t2 --script %t.script %t -shared
 # RUN: llvm-readobj -s -t %t2 | FileCheck %s --check-prefix=GC
 
 # GC:        Name: .foo
 # GC-NEXT:   Type: SHT_NOBITS
 # GC-NEXT:   Flags [

test/ELF/linkerscript/no-space.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 
-# RUN: echo "SECTIONS {foo 0 : {*(foo*)} }" > %t.script
+# RUN: echo "SECTIONS {foo 0 : {*(foo*)} .dynsym : {*(.dynsym)} .dynstr : {*(.dynstr)} }" > %t.script
 # RUN: ld.lld --hash-style=sysv -o %t --script %t.script %t.o -shared
 # RUN: llvm-readobj -elf-output-style=GNU -l %t | FileCheck %s
 
-# RUN: echo "SECTIONS {foo : {*(foo*)} }" > %t.script
+# RUN: echo "SECTIONS {foo : {*(foo*)} .dynsym : { *(.dynsym) } .dynstr : { *(.dynstr) } }" > %t.script
 # RUN: ld.lld --hash-style=sysv -o %t --script %t.script %t.o -shared
 # RUN: llvm-readobj -elf-output-style=GNU -l %t | FileCheck %s
 
 # There is not enough address space available for the header, so just start the PT_LOAD
 # after it. Don't create a PT_PHDR as the header is not allocated.
 
 # CHECK: Program Headers:
 # CHECK-NEXT: Type  Offset   VirtAddr           PhysAddr
 # CHECK-NEXT: LOAD  0x001000 0x0000000000000000 0x0000000000000000
 
 # CHECK:      Section to Segment mapping:
 # CHECK-NEXT:  Segment Sections...
-# CHECK-NEXT:   00     foo .text .dynsym .hash .dynstr
+# CHECK-NEXT:   00     foo .text .hash .dynsym .dynstr
 
 .section foo, "a"
 .quad 0

test/ELF/linkerscript/non-absolute.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t1.o
 # RUN: echo "SECTIONS { A = . - 0x10; B = A + 0x1; }" > %t.script
 # RUN: ld.lld -shared %t1.o --script %t.script -o %t
 # RUN: llvm-objdump -d %t | FileCheck %s --check-prefix=DUMP
 # RUN: llvm-readobj -t %t | FileCheck %s --check-prefix=SYMBOL
 
 # DUMP:       Disassembly of section .text:
 # DUMP-NEXT:  foo:
-# DUMP-NEXT:   0: {{.*}} -21(%rip), %eax
+# DUMP-NEXT:   50: {{.*}} -101(%rip), %eax
 
 # SYMBOL:     Symbol {
 # SYMBOL:        Name: B
 # SYMBOL-NEXT:   Value: 0xFFFFFFFFFFFFFFF1
 # SYMBOL-NEXT:   Size: 0
 # SYMBOL-NEXT:   Binding: Local
 # SYMBOL-NEXT:   Type: None
 # SYMBOL-NEXT:   Other [
 # SYMBOL-NEXT:     STV_HIDDEN
 # SYMBOL-NEXT:   ]
-# SYMBOL-NEXT:   Section: .text
+# SYMBOL-NEXT:   Section: .dynsym
 # SYMBOL-NEXT: }
 
 .text
 .globl foo
 .type foo, @function
 foo:
  movl B(%rip), %eax
 
 .hidden B

test/ELF/linkerscript/non-absolute2.test

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux /dev/null -o %t1.o
 # RUN: ld.lld -shared %t1.o --script %s -o %t
 # RUN: llvm-objdump -section-headers -t %t | FileCheck %s
 
 SECTIONS {
   A = . + 0x1;
   . += 0x1000;
 }
 
 # CHECK:       Sections:
-# CHECK-NEXT:   Idx Name          Size      Address
-# CHECK-NEXT:    0               00000000 0000000000000000
-# CHECK-NEXT:    1 .text         00000000 0000000000001000
+# CHECK-NEXT:  Idx Name          Size      Address          Type
+# CHECK-NEXT:    0               00000000 0000000000000000 
+# CHECK-NEXT:    1 .dynsym       00000030 0000000000001000 
+# CHECK-NEXT:    2 .dynstr       00000003 0000000000001030 
+# CHECK-NEXT:    3 .text         00000000 0000000000001034
 
-# CHECK: 0000000000000001         .text            00000000 A
+# CHECK: 0000000000000001         .dynsym            00000000 A

test/ELF/linkerscript/non-alloc.s

 
 # CHECK: Program Headers:
 # CHECK-NEXT:  Type
 # CHECK-NEXT:  LOAD {{.*}} R E
 # CHECK-NEXT:  LOAD {{.*}} RW
 
 # CHECK:      Section to Segment mapping:
 # CHECK-NEXT:  Segment Sections...
-# CHECK-NEXT:   00     .text .dynsym .hash .dynstr
+# CHECK-NEXT:   00     .dynsym .dynstr .text .hash 
 # CHECK-NEXT:   01     .dynamic
 
 nop
 .section foo
 .quad 0

test/ELF/linkerscript/orphan-first-cmd.test

 }
 
 # CHECK:      Name: .text
 # CHECK-NEXT: Type: SHT_PROGBITS
 # CHECK-NEXT: Flags [
 # CHECK-NEXT:   SHF_ALLOC
 # CHECK-NEXT:   SHF_EXECINSTR
 # CHECK-NEXT: ]
-# CHECK-NEXT: Address: 0x1000
+# CHECK-NEXT: Address: 0x1038

test/ELF/linkerscript/out-of-order.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-linux %s -o %t.o
-# RUN: echo "SECTIONS { .data 0x4000 : { *(.data) } .text 0x2000 : { *(.text) } }" > %t.script
+# RUN: echo "SECTIONS { .data 0x4000 : {*(.data)} .dynsym 0x2000 : {*(.dynsym)} .dynstr : {*(.dynstr)} }" > %t.script
 # RUN: ld.lld --hash-style=sysv -o %t.so --script %t.script %t.o -shared
 # RUN: llvm-objdump -section-headers %t.so | FileCheck %s
 
+# Note: how the layout is done:
+#  we need to layout 2 segments, each contains sections:
+#    seg1: .data .dynamic
+#    seg2: .dynsym .dynstr .text .hash
+# for each segment, we start from the first section, regardless
+# whether it is an orphan or not (sections that are not listed in the
+# linkerscript are orphans):
+#   for seg1, we assign address: .data(0x4000), .dynamic(0x4008)
+#   for seg2, we assign address: .dynsym(0x2000), .dynstr(0x2018) ...
+# .dynsym is not an orphan, so we take address from script, we assign
+# .dynstr current address cursor, which is the end # of .dynsym and so
+# on for later sections.
+
+# Also note, it is absolutely *illegal* to have section addresses of
+# the same segment in none-increasing order, authors of linker scripts
+# must take responsibility to make sure this does not happen.
+
 # CHECK:      Sections:
 # CHECK-NEXT: Idx Name          Size      Address          Type
 # CHECK-NEXT:   0               00000000 0000000000000000
-# CHECK-NEXT:   1 .data         00000008 0000000000004000  DATA
+# CHECK-NEXT:   1 .data         00000008 0000000000004000
 # CHECK-NEXT:   2 .dynamic      00000060 0000000000004008
-# CHECK-NEXT:   3 .text         00000008 0000000000002000  TEXT DATA
-# CHECK-NEXT:   4 .dynsym       00000018 0000000000002008
-# CHECK-NEXT:   5 .hash         00000010 0000000000002020
-# CHECK-NEXT:   6 .dynstr       00000001 0000000000002030
+# CHECK-NEXT:   3 .dynsym       00000018 0000000000002000 
+# CHECK-NEXT:   4 .dynstr       00000001 0000000000002018
+# CHECK-NEXT:   5 .text         00000008 000000000000201c
+# CHECK-NEXT:   6 .hash         00000010 0000000000002024
 
 .quad 0
 .data
 .quad 0
+

test/ELF/linkerscript/overlapping-sections.s

 # Verify that the .sec2 was indeed placed in a PT_LOAD where the PhysAddr
 # overlaps with where .sec1 is loaded:
 # RUN: llvm-readobj -sections -program-headers -elf-output-style=GNU %t.so | FileCheck %s -check-prefix BAD-LMA
 # BAD-LMA-LABEL: Section Headers:
 # BAD-LMA: .sec1             PROGBITS        0000000000008000 002000 000100 00  WA  0   0  1
 # BAD-LMA: .sec2             PROGBITS        0000000000008800 002800 000100 00  WA  0   0  1
 # BAD-LMA-LABEL: Program Headers:
 # BAD-LMA-NEXT:  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align
-# BAD-LMA-NEXT:  LOAD           0x001000 0x0000000000000000 0x0000000000000000 0x0000fd 0x0000fd R E 0x1000
+# BAD-LMA-NEXT:  LOAD           0x001000 0x0000000000000000 0x0000000000000000 0x000104 0x000104 R E 0x1000
 # BAD-LMA-NEXT:  LOAD           0x002000 0x0000000000008000 0x0000000000008000 0x000100 0x000100 RW  0x1000
 # BAD-LMA-NEXT:  LOAD           0x002800 0x0000000000008800 0x0000000000008080 0x000170 0x000170 RW  0x1000
 # BAD-LMA-LABEL: Section to Segment mapping:
 # BAD-LMA:  01     .sec1
 # BAD-LMA:  02     .sec2 .dynamic
 
 # Now try a script where the virtual memory addresses overlap but ensure that the
 # load addresses don't:

 # Check that the expected binary was created with --noinhibit-exec:
 # RUN: ld.lld -o %t.so --script %t-vaddr.script %t.o -shared --noinhibit-exec
 # RUN: llvm-readobj -sections -program-headers -elf-output-style=GNU %t.so | FileCheck %s -check-prefix BAD-VADDR
 # BAD-VADDR-LABEL: Section Headers:
 # BAD-VADDR: .sec1             PROGBITS        0000000000008000 002000 000100 00  WA  0   0  1
 # BAD-VADDR: .sec2             PROGBITS        0000000000008020 003020 000100 00  WA  0   0  1
 # BAD-VADDR-LABEL: Program Headers:
 # BAD-VADDR-NEXT:  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align
-# BAD-VADDR-NEXT:  LOAD           0x001000 0x0000000000000000 0x0000000000000000 0x0000fd 0x0000fd R E 0x1000
+# BAD-VADDR-NEXT:  LOAD           0x001000 0x0000000000000000 0x0000000000000000 0x000104 0x000104 R E 0x1000
 # BAD-VADDR-NEXT:  LOAD           0x002000 0x0000000000008000 0x0000000000008000 0x000100 0x000100 RW  0x1000
 # BAD-VADDR-NEXT:  LOAD           0x003020 0x0000000000008020 0x0000000000008800 0x000170 0x000170 RW  0x1000
 # BAD-VADDR-LABEL: Section to Segment mapping:
 # BAD-VADDR:  01     .sec1
 # BAD-VADDR:  02     .sec2 .dynamic
 
 # Finally check the case where both LMA and vaddr overlap
 

 # BROKEN-OUTPUT-FILE-NEXT: 8040 02020202 02020202 02020202 02020202
 
 # RUN: llvm-readobj -sections -program-headers -elf-output-style=GNU %t.so | FileCheck %s -check-prefix BAD-BOTH
 # BAD-BOTH-LABEL: Section Headers:
 # BAD-BOTH: .sec1             PROGBITS        0000000000008000 002000 000100 00  WA  0   0  1
 # BAD-BOTH: .sec2             PROGBITS        0000000000008040 002040 000100 00  WA  0   0  1
 # BAD-BOTH-LABEL: Program Headers:
 # BAD-BOTH-NEXT:  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align
-# BAD-BOTH-NEXT:  LOAD           0x001000 0x0000000000000000 0x0000000000000000 0x0000fd 0x0000fd R E 0x1000
+# BAD-BOTH-NEXT:  LOAD 0x001000 0x0000000000000000 0x0000000000000000 0x000104 0x000104 R E 0x1000
 # BAD-BOTH-NEXT:  LOAD           0x002000 0x0000000000008000 0x0000000000008000 0x0001b0 0x0001b0 RW  0x1000
 # BAD-BOTH-LABEL: Section to Segment mapping:
 # BAD-BOTH:   01     .sec1 .sec2 .dynamic
 
 .section        .first_sec,"aw",@progbits
 .rept 0x100
 .byte 1
 .endr
 
 .section        .second_sec,"aw",@progbits
 .rept 0x100
 .byte 2
 .endr

test/ELF/linkerscript/sections-sort.s

 
 nop
 
 .section foo, "a"
 .byte 0
 
 # CHECK: Id
 # CHECK-NEXT: 0
-# CHECK-NEXT: 1 .text
-# CHECK-NEXT: 2 foo
-# CHECK-NEXT: 3 .dynsym
-# CHECK-NEXT: 4 .hash
-# CHECK-NEXT: 5 .dynstr
+# CHECK-NEXT: 1 .dynsym
+# CHECK-NEXT: 2 .dynstr
+# CHECK-NEXT: 3 .text
+# CHECK-NEXT: 4 foo
+# CHECK-NEXT: 5 .hash
 # CHECK-NEXT: 6 .dynamic
 # CHECK-NEXT: 7 .comment
 # CHECK-NEXT: 8 .symtab
 # CHECK-NEXT: 9 .shstrtab
 # CHECK-NEXT: 10 .strtab

test/ELF/linkerscript/sort-non-script.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t
 
 # RUN: echo "SECTIONS { foo : {*(foo)} }" > %t.script
 # RUN: ld.lld --hash-style=sysv -o %t1 --script %t.script %t -shared
 # RUN: llvm-readobj -elf-output-style=GNU -s %t1 | FileCheck %s
 
-# CHECK:      .text    {{.*}}   AX
-# CHECK-NEXT: .dynsym  {{.*}}   A
-# CHECK-NEXT: .hash    {{.*}}   A
+# CHECK:      .dynsym  {{.*}}   A
 # CHECK-NEXT: .dynstr  {{.*}}   A
+# CHECK-NEXT: .text    {{.*}}   AX
+# CHECK-NEXT: .hash    {{.*}}   A
 # CHECK-NEXT: foo      {{.*}}  WA
 # CHECK-NEXT: .dynamic {{.*}}  WA
 
 .section foo, "aw"
 .byte 0

test/ELF/linkerscript/symbol-only.test

SECTIONS {
   . = ALIGN(0x1000);
   bar : { *(bar) }
 }
 
 # CHECK:      Sections:
 # CHECK-NEXT: Idx Name          Size      Address
 # CHECK-NEXT:   0               00000000 0000000000000000
 # CHECK:          abc           00000000 [[ADDR:[0-9a-f]*]] BSS
+# CHECK-NEXT:     .dynsym       00000030 0000000000000190
+# CHECK-NEXT:     .dynstr       00000005 00000000000001c0
 # CHECK-NEXT:     bar           00000000 0000000000001000 DATA
 
 # CHECK: SYMBOL TABLE:
 # CHECK:     [[ADDR]]         abc                00000000 foo

test/ELF/linkerscript/unused-synthetic.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: echo "SECTIONS { \
 # RUN:    .got  : { *(.got) *(.got) } \
 # RUN:    .plt  : { *(.plt) } \
 # RUN:    .text : { *(.text) } \
 # RUN:  }" > %t.script
 # RUN: ld.lld -shared -o %t.so --script %t.script %t.o
 
 # RUN: llvm-objdump -section-headers %t.so | FileCheck %s
 # CHECK-NOT:  .got
 # CHECK-NOT:  .plt
-# CHECK:      .text
-# CHECK-NEXT: .dynsym
+# CHECK:      .dynsym
+# CHECK-NEXT: .dynstr
+# CHECK-NEXT: .text
+# CHECK-NEXT: .gnu.hash
 
 # Test that the size of a removed unused synthetic input section is not added
 # to the output section size. Adding a symbol assignment prevents removal of
 # the output section, but does not cause the section size to be recomputed.
 # RUN: echo "SECTIONS { \
 # RUN:    .got.plt : { a_sym = .; *(.got.plt) } \
 # RUN:  }" > %t2.script
 # RUN: ld.lld -shared -o %t2.so --script %t2.script %t.o
 # RUN: llvm-objdump -section-headers %t2.so | FileCheck %s --check-prefix=CHECK2
 # CHECK2: .got.plt 00000000
 
 .global _start
 _start:
   nop

test/ELF/map-file.s

 .comm   common,4,16
 .global abs
 abs = 0xAB5
 labs = 0x1AB5
 
 // CHECK:         VMA              LMA     Size Align Out     In      Symbol
 // CHECK-NEXT: 2001c8           2001c8       78     8 .dynsym
 // CHECK-NEXT: 2001c8           2001c8       78     8         <internal>:(.dynsym)
-// CHECK-NEXT: 200240           200240       2c     8 .gnu.hash
-// CHECK-NEXT: 200240           200240       2c     8         <internal>:(.gnu.hash)
-// CHECK-NEXT: 20026c           20026c       30     4 .hash
-// CHECK-NEXT: 20026c           20026c       30     4         <internal>:(.hash)
-// CHECK-NEXT: 20029c           20029c       31     1 .dynstr
-// CHECK-NEXT: 20029c           20029c       31     1         <internal>:(.dynstr)
-// CHECK-NEXT: 2002d0           2002d0       30     8 .rela.dyn
-// CHECK-NEXT: 2002d0           2002d0       30     8         <internal>:(.rela.dyn)
-// CHECK-NEXT: 200300           200300       30     8 .rela.plt
-// CHECK-NEXT: 200300           200300       30     8         <internal>:(.rela.plt)
-// CHECK-NEXT: 200330           200330       64     8 .eh_frame
-// CHECK-NEXT: 200330           200330       2c     1         {{.*}}{{/|\\}}map-file.s.tmp1.o:(.eh_frame+0x0)
-// CHECK-NEXT: 200360           200360       14     1         {{.*}}{{/|\\}}map-file.s.tmp1.o:(.eh_frame+0x2c)
-// CHECK-NEXT: 200378           200378       18     1         {{.*}}{{/|\\}}map-file.s.tmp2.o:(.eh_frame+0x18)
+// CHECK-NEXT: 200240           200240       31     1 .dynstr
+// CHECK-NEXT: 200240           200240       31     1         <internal>:(.dynstr)
+// CHECK-NEXT: 200278           200278       2c     8 .gnu.hash
+// CHECK-NEXT: 200278           200278       2c     8         <internal>:(.gnu.hash)
+// CHECK-NEXT: 2002a4           2002a4       30     4 .hash
+// CHECK-NEXT: 2002a4           2002a4       30     4         <internal>:(.hash)
+// CHECK-NEXT: 2002d8           2002d8       30     8 .rela.dyn
+// CHECK-NEXT: 2002d8           2002d8       30     8         <internal>:(.rela.dyn)
+// CHECK-NEXT: 200308           200308       30     8 .rela.plt
+// CHECK-NEXT: 200308           200308       30     8         <internal>:(.rela.plt)
+// CHECK-NEXT: 200338           200338       64     8 .eh_frame
+// CHECK-NEXT: 200338           200338       2c     1         {{.*}}{{/|\\}}map-file.s.tmp1.o:(.eh_frame+0x0)
+// CHECK-NEXT: 200368           200368       14     1         {{.*}}{{/|\\}}map-file.s.tmp1.o:(.eh_frame+0x2c)
+// CHECK-NEXT: 200380           200380       18     1         {{.*}}{{/|\\}}map-file.s.tmp2.o:(.eh_frame+0x18)
 // CHECK-NEXT: 201000           201000       2d     4 .text
 // CHECK-NEXT: 201000           201000       28     4         {{.*}}{{/|\\}}map-file.s.tmp1.o:(.text)
 // CHECK-NEXT: 201000           201000        0     1                 _start
 // CHECK-NEXT: 20101f           20101f        0     1                 f(int)
 // CHECK-NEXT: 201028           201028        0     1                 local
 // CHECK-NEXT: 201028           201028        2     4         {{.*}}{{/|\\}}map-file.s.tmp2.o:(.text)
 // CHECK-NEXT: 201028           201028        0     1                 foo
 // CHECK-NEXT: 201029           201029        0     1                 bar

 // CHECK-NEXT:      0                0        8     1         <internal>:(.comment)
 // CHECK-NEXT:      0                0      198     8 .symtab
 // CHECK-NEXT:      0                0      198     8         <internal>:(.symtab)
 // CHECK-NEXT:      0                0       84     1 .shstrtab
 // CHECK-NEXT:      0                0       84     1         <internal>:(.shstrtab)
 // CHECK-NEXT:      0                0       6d     1 .strtab
 // CHECK-NEXT:      0                0       6d     1         <internal>:(.strtab)
 
+
 // RUN: not ld.lld %t1.o %t2.o %t3.o %t4.a -o %t -Map=/ 2>&1 \
 // RUN:  | FileCheck -check-prefix=FAIL %s
 // FAIL: cannot open map file /

test/ELF/merge-gc-piece.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: ld.lld %t.o -o %t.so -shared --gc-sections
 # RUN: llvm-readobj -s -section-data %t.so | FileCheck %s
 
 
 # CHECK:      Name: .foo
 # CHECK-NEXT: Type: SHT_PROGBITS
 # CHECK-NEXT: Flags [
 # CHECK-NEXT:   SHF_ALLOC
 # CHECK-NEXT:   SHF_MERGE
 # CHECK-NEXT: ]
-# CHECK-NEXT: Address: 0x190
+# CHECK-NEXT: Address: 0x1C8
 
 # CHECK:      Name: .bar
 # CHECK-NEXT: Type: SHT_PROGBITS
 # CHECK-NEXT: Flags [
 # CHECK-NEXT: ]
 # CHECK-NEXT: Address:
 # CHECK-NEXT: Offset:
 # CHECK-NEXT: Size: 16
 # CHECK-NEXT: Link:
 # CHECK-NEXT: Info:
 # CHECK-NEXT: AddressAlignment:
 # CHECK-NEXT: EntrySize:
 # CHECK-NEXT: SectionData (
-# CHECK-NEXT:   0000: 91010000 00000000 92010000 00000000
+# CHECK-NEXT:   0000: C9010000 00000000 CA010000 00000000
 # CHECK-NEXT: )
 
         .section .foo,"aM",@progbits,8
         .quad 42
         .global sym
 sym:
         .quad 43
 
         .section .bar
         .quad .foo + 1
         .quad .foo + 2

test/ELF/merge-shared-str.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: Address: 0x1E1
 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section ({{.*}}) .rela.dyn {
-// CHECK-NEXT:     0x{{.*}} R_X86_64_RELATIVE - 0x1C9
+// CHECK-NEXT:     0x{{.*}} R_X86_64_RELATIVE - 0x1E2
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]

test/ELF/merge-shared.s

 
 
 // CHECK:      Name: foo
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_MERGE
 // CHECK-NEXT: ]
-// CHECK-NEXT: Address: 0x1C8
+// CHECK-NEXT: Address: 0x1E4
 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section ({{.*}}) .rela.dyn {
-// CHECK-NEXT:     0x{{.*}} R_X86_64_RELATIVE - 0x1CA
+// CHECK-NEXT:     0x{{.*}} R_X86_64_RELATIVE - 0x1E6
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]

test/ELF/merge-string.s

 
 // CHECK:      Name:    .rodata1
 // 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: 0x1E1
+// CHECK-NEXT: Offset: 0x1E1
 // CHECK-NEXT: Size:    4
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 1
 // CHECK-NEXT: EntrySize: 1
 // CHECK-NEXT: SectionData (
 // CHECK-NEXT:   0000: 61626300                             |abc.|
 // CHECK-NEXT: )
 
 // NOTAIL:      Name:    .rodata1
 // NOTAIL-NEXT: Type:    SHT_PROGBITS
 // NOTAIL-NEXT: Flags [
 // NOTAIL-NEXT:   SHF_ALLOC
 // NOTAIL-NEXT:   SHF_MERGE
 // NOTAIL-NEXT:   SHF_STRINGS
 // NOTAIL-NEXT: ]
-// NOTAIL-NEXT: Address:         0x1C8
-// NOTAIL-NEXT: Offset:  0x1C8
+// NOTAIL-NEXT: Address: 0x1E1
+// NOTAIL-NEXT: Offset: 0x1E1
 // NOTAIL-NEXT: Size:    7
 // NOTAIL-NEXT: Link: 0
 // NOTAIL-NEXT: Info: 0
 // NOTAIL-NEXT: AddressAlignment: 1
 // NOTAIL-NEXT: EntrySize: 1
 // NOTAIL-NEXT: SectionData (
 // NOTAIL-NEXT:   0000: 62630061 626300                     |bc.abc.|
 // NOTAIL-NEXT: )
 
 // NOMERGE:      Name:    .rodata1
 // NOMERGE-NEXT: Type:    SHT_PROGBITS
 // NOMERGE-NEXT: Flags [
 // NOMERGE-NEXT:   SHF_ALLOC
 // NOMERGE-NEXT:   SHF_MERGE
 // NOMERGE-NEXT:   SHF_STRINGS
 // NOMERGE-NEXT: ]
-// NOMERGE-NEXT: Address:         0x1C8
-// NOMERGE-NEXT: Offset:  0x1C8
+// NOMERGE-NEXT: Address: 0x1E1
+// NOMERGE-NEXT: Offset: 0x1E1
 // NOMERGE-NEXT: Size:    11
 // NOMERGE-NEXT: Link: 0
 // NOMERGE-NEXT: Info: 0
 // NOMERGE-NEXT: AddressAlignment: 1
 // NOMERGE-NEXT: EntrySize: 1
 // NOMERGE-NEXT: SectionData (
 // NOMERGE-NEXT:   0000: 61626300 61626300 626300 |abc.abc.bc.|
 // NOMERGE-NEXT: )
 
 // CHECK:      Name: .rodata2
 // 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: 0x1CC
-// CHECK-NEXT: Offset: 0x1CC
+// CHECK-NEXT: Address: 0x1E6
+// CHECK-NEXT: Offset: 0x1E6
 // CHECK-NEXT: Size: 4
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 2
 // CHECK-NEXT: EntrySize: 2
 // CHECK-NEXT: SectionData (
 // CHECK-NEXT:   0000: 14000000                             |....|
 // CHECK-NEXT: )
 
 
 // CHECK:      Name:    bar
-// CHECK-NEXT: Value:   0x1C9
+// CHECK-NEXT: Value: 0x1E2
 
 // CHECK:      Name:    foo
-// CHECK-NEXT: Value:   0x1C8
+// CHECK-NEXT: Value: 0x1E1
 
 // CHECK:      Name: zed
-// CHECK-NEXT: Value: 0x1CC
+// CHECK-NEXT: Value: 0x1E6
 // CHECK-NEXT: Size: 0

test/ELF/merge-sym.s

 
 
 // CHECK:      Name: .rodata
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_MERGE
 // CHECK-NEXT: ]
-// CHECK-NEXT: Address: 0x1C8
+// CHECK-NEXT: Address: 0x1E4
 
 // CHECK:      Name: foo
-// CHECK-NEXT: Value: 0x1CA
+// CHECK-NEXT: Value: 0x1E6

test/ELF/merge-to-non-alloc.s

 // CHECK-NEXT: Address:
 // CHECK-NEXT: Offset:
 // CHECK-NEXT: Size: 16
 // CHECK-NEXT: Link:
 // CHECK-NEXT: Info:
 // CHECK-NEXT: AddressAlignment:
 // CHECK-NEXT: EntrySize:
 // CHECK-NEXT: SectionData (
-// CHECK-NEXT:   0000: C8010000 00000000 D0010000 00000000  |
+// CHECK-NEXT:   0000: E4010000 00000000 EC010000 00000000  |
 // CHECK-NEXT: )
 
 // CHECK:      Name: foo
-// CHECK-NEXT: Value: 0x1C8
+// CHECK-NEXT: Value: 0x1E4
 
         .section        .foo,"aM",@progbits,4
         .align  4
         .global foo
         .hidden foo
 foo:
         .long   0x42
 
         .section .bar
         .quad foo
         .quad foo + 8

test/ELF/mips-got-string.s

 # Check R_MIPS_GOT16 relocation against merge section.
 
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux -o %t.o %s
 # RUN: ld.lld -shared -o %t.so %t.o
 # RUN: llvm-readobj -t -mips-plt-got %t.so | FileCheck %s
 
 # REQUIRES: mips
 
 # CHECK:      Symbol {
 # CHECK:        Name: $.str
-# CHECK-NEXT:   Value: 0xF4
+# CHECK-NEXT:   Value: 0x105
 # CHECK:      }
 
 # CHECK:      Local entries [
 # CHECK-NEXT:   Entry {
 # CHECK-NEXT:     Address:
 # CHECK-NEXT:     Access: -32744
 # CHECK-NEXT:     Initial: 0x0
 # CHECK:        }

test/ELF/mips-gp-ext.s

 # RUN:          _gp = 0x200; \
 # RUN:          .got  : { *(.got) } }" > %t.abs.script
 # RUN: ld.lld -shared -o %t.abs.so --script %t.abs.script %t.o
 # RUN: llvm-objdump -s -t %t.abs.so | FileCheck --check-prefix=ABS %s
 
 # REQUIRES: mips
 
 # REL:      Contents of section .text:
-# REL-NEXT:  0000 3c080000 2108010c 8f82fffc
+# REL-NEXT:  0030 3c080000 2108010c 8f82ffcc
 #                 ^-- %hi(_gp_disp)
 #                          ^-- %lo(_gp_disp)
 #                                   ^-- 8 - (0x10c - 0x100)
 #                                       G - (GP - .got)
 
 # REL:      Contents of section .reginfo:
-# REL-NEXT:  0028 10000104 00000000 00000000 00000000
-# REL-NEXT:  0038 00000000 0000010c
+# REL-NEXT:  0058 10000104 00000000 00000000 00000000
+# REL-NEXT:  0068 00000000 0000013c
 #                          ^-- _gp
 
 # REL:      Contents of section .data:
 # REL-NEXT:  00f0 fffffef4
 #                 ^-- 0-0x10c
 
-# REL: 00000000         .text           00000000 foo
+# REL: 00000030         .text           00000000 foo
 # REL: 00000000         *ABS*           00000000 .hidden _gp_disp
-# REL: 0000010c         *ABS*           00000000 .hidden _gp
+# REL: 0000013c         *ABS*           00000000 .hidden _gp
 
 # ABS:      Contents of section .text:
-# ABS-NEXT:  0000 3c080000 21080200 8f82ff08
+# ABS-NEXT:  0030 3c080000 210801d0 8f82ff08
 #                 ^-- %hi(_gp_disp)
 #                          ^-- %lo(_gp_disp)
 #                                   ^-- 8 - (0x200 - 0x100)
 #                                       G - (GP - .got)
 
 # ABS:      Contents of section .reginfo:
-# ABS-NEXT:  0028 10000104 00000000 00000000 00000000
-# ABS-NEXT:  0038 00000000 00000200
+# ABS-NEXT:  0058 10000104 00000000 00000000 00000000
+# ABS-NEXT:  0068 00000000 00000200
 #                          ^-- _gp
 
 # ABS:      Contents of section .data:
-# ABS-NEXT:  00f0 fffffe00
+# ABS-NEXT:  00f0 fffffe30
 #                 ^-- 0-0x200
 
-# ABS: 00000000         .text           00000000 foo
+# ABS: 00000030         .text           00000000 foo
 # ABS: 00000000         *ABS*           00000000 .hidden _gp_disp
 # ABS: 00000200         *ABS*           00000000 .hidden _gp
 
   .text
 foo:
   lui    $t0, %hi(_gp_disp)
   addi   $t0, $t0, %lo(_gp_disp)
   lw     $v0, %call16(bar)($gp)
 
   .data
   .gpword foo

test/ELF/mips-gp-lowest.s

 # CHECK:      Section {
 # CHECK:        Name: .sdata
 # CHECK-NEXT:   Type: SHT_PROGBITS
 # CHECK-NEXT:   Flags [
 # CHECK-NEXT:     SHF_ALLOC
 # CHECK-NEXT:     SHF_MIPS_GPREL
 # CHECK-NEXT:     SHF_WRITE
 # CHECK-NEXT:   ]
-# CHECK-NEXT:   Address: 0xE0
+# CHECK-NEXT:   Address: 0xF0
 # CHECK:      }
 # CHECK:      Section {
 # CHECK:        Name: .got
 # CHECK-NEXT:   Type: SHT_PROGBITS
 # CHECK-NEXT:   Flags [
 # CHECK-NEXT:     SHF_ALLOC
 # CHECK-NEXT:     SHF_MIPS_GPREL
 # CHECK-NEXT:     SHF_WRITE
 # CHECK-NEXT:   ]
-# CHECK-NEXT:   Address: 0xF0
+# CHECK-NEXT:   Address: 0x100
 # CHECK:      }
 
 # CHECK:      Name: _gp (5)
-# CHECK-NEXT: Value: 0x80D0
+# CHECK-NEXT: Value: 0x80E0
 #                    ^-- 0xE0 + 0x7ff0

test/ELF/note-noalloc.s

 // CHECK-NEXT:   Type: SHT_NOTE
 // CHECK-NEXT:   Flags [
 // CHECK-NEXT:   ]
 
 // CHECK:      ProgramHeader {
 // CHECK:        Type: PT_NOTE
 // CHECK-NEXT:   Offset:
 // CHECK-NEXT:   VirtualAddress: 0x[[ADDR]]
-// CHECK-NEXT:   PhysicalAddress: 0x245
+// CHECK-NEXT:   PhysicalAddress: 0x24C
 // CHECK-NEXT:   FileSize: 16
 // CHECK-NEXT:   MemSize: 16
 // CHECK-NOT:  PT_NOTE
 
 .section        .note.a,"a",@note
 .quad 1
 .quad 2
 
 .section        .note.b,"",@note
 .quad 3

test/ELF/relocation-shared.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 // RUN: ld.lld %t.o -shared -o %t.so
 // RUN: llvm-readobj -r -s -section-data %t.so | FileCheck %s
 
 // CHECK:      Name: foo
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT: ]
-// CHECK-NEXT: Address: 0x1C8
+// CHECK-NEXT: Address: 0x1E1
 // CHECK-NEXT: Offset:
 // CHECK-NEXT: Size: 8
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 1
 // CHECK-NEXT: EntrySize: 0
 // CHECK-NEXT: SectionData (
-// CHECK-NEXT:   0000: 380E0000 00000000
-//                     0x1000 - 0x1C8 = 0xE38
+// CHECK-NEXT:   0000: 1F0E0000 00000000
+//                     0x1000 - 0x1E1 = 0xE1F
 // CHECK-NEXT: )
 
 // CHECK:      Name: .text
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_EXECINSTR
 // CHECK-NEXT: ]
 // CHECK-NEXT: Address: 0x1000
 
 // CHECK:      Relocations [
 // CHECK-NEXT: ]
 
 bar:
         .section foo,"a",@progbits
         .quad bar - .

test/ELF/relocation.s

 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/shared.s -o %t2
-// RUN: ld.lld %t2 -o %t2.so -shared
+// RUN: ld.lld %t2 -soname fixed-length-string.so -o %t2.so -shared
 // RUN: ld.lld --hash-style=sysv %t %t2.so -o %t3
 // RUN: llvm-readobj -s  %t3 | FileCheck --check-prefix=SEC %s
 // RUN: llvm-objdump -s -d %t3 | FileCheck %s
 // REQUIRES: x86
 
 // SEC:      Name: .plt
 // SEC-NEXT: Type: SHT_PROGBITS
 // SEC-NEXT: Flags [

 // CHECK-NEXT: 201021: {{.*}}  movl    2101328, %eax
 
 .section .R_X86_64_64,"a",@progbits
 .global R_X86_64_64
 R_X86_64_64:
  .quad R_X86_64_64
 
 // CHECK:      Contents of section .R_X86_64_64:
-// CHECK-NEXT:   2001c8 c8012000 00000000
+// CHECK-NEXT:   20024d 4d022000 00000000
 
 .section .R_X86_64_GOTPCREL,"a",@progbits
 .global R_X86_64_GOTPCREL
 R_X86_64_GOTPCREL:
  .long zed@gotpcrel
 
-// 0x2020F8 - 0x2001D8 = 7952
-// 7952 = 0x101f0000 in little endian
+// 0x2020F0(.got) - 0x200255(.R_X86_64_GOTPCREL) = 0x2e9b
 // CHECK:      Contents of section .R_X86_64_GOTPCREL
-// CHECK-NEXT:   2001d0 202f0000
+// CHECK-NEXT:   200255 9b2e0000
 
 .section .R_X86_64_GOT32,"a",@progbits
 .global R_X86_64_GOT32
 R_X86_64_GOT32:
         .long zed@got
 
 // CHECK: Contents of section .R_X86_64_GOT32:
 // CHECK-NEXT: f8ffffff
 
 
 // CHECK: Contents of section .R_X86_64_GOT64:
 // CHECK-NEXT: f8ffffff ffffffff
 .section .R_X86_64_GOT64,"a",@progbits
 .global R_X86_64_GOT64
 R_X86_64_GOT64:
         .quad zed@got

test/ELF/relro-omagic.s

 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/shared.s -o %t2.o
 # RUN: ld.lld -shared %t2.o -o %t2.so -soname relro-omagic.s.tmp2.so
 # RUN: ld.lld --hash-style=sysv -N %t.o %t2.so -o %t
 # RUN: llvm-objdump -section-headers %t | FileCheck --check-prefix=NORELRO %s
 # RUN: llvm-readobj --program-headers %t | FileCheck --check-prefix=NOPHDRS %s
 
 # NORELRO:      Sections:
 # NORELRO-NEXT: Idx Name          Size      Address          Type
 # NORELRO-NEXT:   0               00000000 0000000000000000
 # NORELRO-NEXT:   1 .dynsym       00000048 0000000000200120
-# NORELRO-NEXT:   2 .hash         00000020 0000000000200168
-# NORELRO-NEXT:   3 .dynstr       00000021 0000000000200188
+# NORELRO-NEXT:   2 .dynstr       00000021 0000000000200168
+# NORELRO-NEXT:   3 .hash         00000020 000000000020018c
 # NORELRO-NEXT:   4 .rela.dyn     00000018 00000000002001b0
 # NORELRO-NEXT:   5 .rela.plt     00000018 00000000002001c8
 # NORELRO-NEXT:   6 .text         0000000a 00000000002001e0 TEXT DATA
 # NORELRO-NEXT:   7 .plt          00000020 00000000002001f0 TEXT DATA
 # NORELRO-NEXT:   8 .data         00000008 0000000000200210 DATA
 # NORELRO-NEXT:   9 .foo          00000004 0000000000200218 DATA
 # NORELRO-NEXT:  10 .dynamic      000000f0 0000000000200220
 # NORELRO-NEXT:  11 .got          00000008 0000000000200310 DATA

test/ELF/shared.s

 // CHECK-NEXT:   EntrySize: 16
 // CHECK-NEXT:   SectionData (
 // CHECK-NEXT:     0000:
 // CHECK-NEXT:     0010:
 // CHECK-NEXT:     0020:
 // CHECK-NEXT:     0030:
 // CHECK-NEXT:   )
 // CHECK-NEXT: }
-// CHECK-NEXT: Section {
-// CHECK-NEXT:   Index: 3
-// CHECK-NEXT:    Name: .hash
-// CHECK-NEXT:    Type: SHT_HASH
-// CHECK-NEXT:    Flags [
-// CHECK-NEXT:      SHF_ALLOC
-// CHECK-NEXT:    ]
-// CHECK-NEXT:    Address: [[HASHADDR:.*]]
-// CHECK-NEXT:    Offset:
-// CHECK-NEXT:    Size:
-// CHECK-NEXT:    Link: 2
-// CHECK-NEXT:    Info: 0
-// CHECK-NEXT:    AddressAlignment: 4
-// CHECK-NEXT:    EntrySize: 4
-
 // CHECK:        Index: [[DYNSTR]]
 // CHECK-NEXT:   Name: .dynstr
 // CHECK-NEXT:   Type: SHT_STRTAB
 // CHECK-NEXT:   Flags [
 // CHECK-NEXT:     SHF_ALLOC
 // CHECK-NEXT:   ]
 // CHECK-NEXT:   Address: [[DYNSTRADDR:.*]]
 // CHECK-NEXT:   Offset:
 // CHECK-NEXT:   Size:
 // CHECK-NEXT:   Link: 0
 // CHECK-NEXT:   Info: 0
 // CHECK-NEXT:   AddressAlignment: 1
 // CHECK-NEXT:   EntrySize: 0
 // CHECK-NEXT:   SectionData (
 // CHECK:        )
 // CHECK-NEXT: }
+// CHECK-NEXT: Section {
+// CHECK-NEXT:   Index: 4
+// CHECK-NEXT:    Name: .hash
+// CHECK-NEXT:    Type: SHT_HASH
+// CHECK-NEXT:    Flags [
+// CHECK-NEXT:      SHF_ALLOC
+// CHECK-NEXT:    ]
+// CHECK-NEXT:    Address: [[HASHADDR:.*]]
+// CHECK-NEXT:    Offset:
+// CHECK-NEXT:    Size:
+// CHECK-NEXT:    Link: 2
+// CHECK-NEXT:    Info: 0
+// CHECK-NEXT:    AddressAlignment: 4
+// CHECK-NEXT:    EntrySize: 4
 
 // CHECK:      Name: .rel.dyn
 // CHECK-NEXT: Type: SHT_REL
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT: ]
 // CHECK-NEXT: Address: [[RELADDR:.*]]
 // CHECK-NEXT: Offset:

test/ELF/sort-norosegment.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t
 
 # RUN: ld.lld --hash-style=sysv -no-rosegment -o %t1  %t -shared
 # RUN: llvm-readobj -elf-output-style=GNU -s %t1 | FileCheck %s
 
-# CHECK:      .text    {{.*}}   AX
-# CHECK-NEXT: .dynsym  {{.*}}   A
-# CHECK-NEXT: .hash    {{.*}}   A
+# CHECK:      .dynsym  {{.*}}   A
 # CHECK-NEXT: .dynstr  {{.*}}   A
+# CHECK-NEXT: .text    {{.*}}   AX
+# CHECK-NEXT: .hash    {{.*}}   A
 # CHECK-NEXT: foo      {{.*}}  WA
 # CHECK-NEXT: .dynamic {{.*}}  WA
 
 .section foo, "aw"
 .byte 0

test/ELF/synthetic-got.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: echo "SECTIONS { }" > %t0.script
 # RUN: ld.lld --hash-style=sysv -shared %t.o -o %t0.out --script %t0.script
 # RUN: llvm-objdump -section-headers %t0.out | FileCheck %s --check-prefix=GOT
 # RUN: llvm-objdump -s -section=.got -section=.got.plt %t0.out \
 # RUN:   | FileCheck %s --check-prefix=GOTDATA
 
 # GOT:     Sections:
-# GOT:      8  .got.plt     00000020 00000000000000e0 DATA
-# GOT:      10 .got         00000008 00000000000001d0 DATA
+# GOT:      8  .got.plt     00000020 00000000000000d0 DATA
+# GOT:      10 .got         00000008 00000000000001c0 DATA
 # GOTDATA:     Contents of section .got.plt:
-# GOTDATA-NEXT:  00e0 00010000 00000000 00000000 00000000
-# GOTDATA-NEXT:  00f0 00000000 00000000 d6000000 00000000
+# GOTDATA-NEXT:  00d0 f0000000 00000000 00000000 00000000
+# GOTDATA-NEXT:  00e0 00000000 00000000 c6000000 00000000
 # GOTDATA-NEXT: Contents of section .got:
-# GOTDATA-NEXT:  01d0 00000000 00000000
+# GOTDATA-NEXT:  01c0 00000000 00000000
 
 # RUN: echo "SECTIONS { .mygot : { *(.got) *(.got.plt) } }" > %t1.script
 # RUN: ld.lld --hash-style=sysv -shared %t.o -o %t1.out --script %t1.script
 # RUN: llvm-objdump -section-headers %t1.out | FileCheck %s --check-prefix=MYGOT
 # RUN: llvm-objdump -s -section=.mygot %t1.out | FileCheck %s --check-prefix=MYGOTDATA
 
 # MYGOT:     Sections:
-# MYGOT:      8  .mygot     00000028 00000000000000e0 DATA
+# MYGOT:      8  .mygot     00000028 00000000000000d0 DATA
 # MYGOT-NOT:  .got
 # MYGOT-NOT:  .got.plt
-# MYGOTDATA:      00e0 00000000 00000000 08010000 00000000
-# MYGOTDATA-NEXT: 00f0 00000000 00000000 00000000 00000000
-# MYGOTDATA-NEXT: 0100 d6000000 00000000
+# MYGOTDATA:      00d0 00000000 00000000 f8000000 00000000
+# MYGOTDATA-NEXT: 00e0 00000000 00000000 00000000 00000000
+# MYGOTDATA-NEXT: 00f0 c6000000 00000000
 
 mov bar@gotpcrel(%rip), %rax
 call foo@plt

test/ELF/verdef-defaultver.s

 # DSO-NEXT:      Binding: Global
 # DSO-NEXT:      Type: Function
 # DSO-NEXT:      Other: 0
 # DSO-NEXT:      Section: .text
 # DSO-NEXT:    }
 # DSO-NEXT:  ]
 # DSO-NEXT:  Version symbols {
 # DSO-NEXT:    Section Name: .gnu.version
-# DSO-NEXT:    Address: 0x240
-# DSO-NEXT:    Offset: 0x240
+# DSO-NEXT:    Address: 0x256
+# DSO-NEXT:    Offset: 0x256
 # DSO-NEXT:    Link: 1
 # DSO-NEXT:    Symbols [
 # DSO-NEXT:      Symbol {
 # DSO-NEXT:        Version: 0
 # DSO-NEXT:        Name: @
 # DSO-NEXT:      }
 # DSO-NEXT:      Symbol {
 # DSO-NEXT:        Version: 2

 # EXE-NEXT:      Binding: Global
 # EXE-NEXT:      Type: Function
 # EXE-NEXT:      Other: 0
 # EXE-NEXT:      Section: Undefined
 # EXE-NEXT:    }
 # EXE-NEXT:  ]
 # EXE-NEXT:  Version symbols {
 # EXE-NEXT:    Section Name: .gnu.version
-# EXE-NEXT:    Address: 0x200228
-# EXE-NEXT:    Offset: 0x228
+# EXE-NEXT:    Address: 0x20023C
+# EXE-NEXT:    Offset: 0x23C
 # EXE-NEXT:    Link: 1
 # EXE-NEXT:    Symbols [
 # EXE-NEXT:      Symbol {
 # EXE-NEXT:        Version: 0
 # EXE-NEXT:        Name: @
 # EXE-NEXT:      }
 # EXE-NEXT:      Symbol {
 # EXE-NEXT:        Version: 2

test/ELF/verdef.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: echo "LIBSAMPLE_1.0 { global: a; local: *; };" > %t.script
 # RUN: echo "LIBSAMPLE_2.0 { global: b; local: *; };" >> %t.script
 # RUN: echo "LIBSAMPLE_3.0 { global: c; local: *; };" >> %t.script
 # RUN: ld.lld --hash-style=sysv --version-script %t.script -shared -soname shared %t.o -o %t.so
 # RUN: llvm-readobj -V -dyn-symbols %t.so | FileCheck --check-prefix=DSO %s
 
 # DSO:        Version symbols {
 # DSO-NEXT:   Section Name: .gnu.version
-# DSO-NEXT:   Address: 0x228
-# DSO-NEXT:   Offset: 0x228
+# DSO-NEXT:   Address: 0x260
+# DSO-NEXT:   Offset: 0x260
 # DSO-NEXT:   Link: 1
 # DSO-NEXT:   Symbols [
 # DSO-NEXT:     Symbol {
 # DSO-NEXT:       Version: 0
 # DSO-NEXT:       Name: @
 # DSO-NEXT:     }
 # DSO-NEXT:     Symbol {
 # DSO-NEXT:       Version: 2

 
 ## Check that we can link agains DSO we produced.
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %S/Inputs/verdef.s -o %tmain.o
 # RUN: ld.lld --hash-style=sysv %tmain.o %t.so -o %tout
 # RUN: llvm-readobj -V %tout | FileCheck --check-prefix=MAIN %s
 
 # MAIN:      Version symbols {
 # MAIN-NEXT:   Section Name: .gnu.version
-# MAIN-NEXT:   Address: 0x200228
-# MAIN-NEXT:   Offset: 0x228
+# MAIN-NEXT:   Address: 0x200260
+# MAIN-NEXT:   Offset: 0x260
 # MAIN-NEXT:   Link: 1
 # MAIN-NEXT:   Symbols [
 # MAIN-NEXT:     Symbol {
 # MAIN-NEXT:       Version: 0
 # MAIN-NEXT:       Name: @
 # MAIN-NEXT:     }
 # MAIN-NEXT:     Symbol {
 # MAIN-NEXT:       Version: 2

test/ELF/verneed.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %S/Inputs/verneed1.s -o %t1.o
 # RUN: echo "v1 {}; v2 {}; v3 { local: *; };" > %t.script
 # RUN: ld.lld -shared %t1.o --version-script %t.script -o %t1.so -soname verneed1.so.0
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %S/Inputs/verneed2.s -o %t2.o
 # RUN: ld.lld -shared %t2.o --version-script %t.script -o %t2.so -soname verneed2.so.0
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: ld.lld --hash-style=sysv %t.o %t1.so %t2.so -o %t
 # RUN: llvm-readobj -V -sections -section-data -dyn-symbols -dynamic-table %t | FileCheck %s
 
 # CHECK:        Section {
-# CHECK:         Index: 1
-# CHECK-NEXT:    Name: .dynsym
-# CHECK-NEXT:    Type: SHT_DYNSYM (0xB)
-# CHECK-NEXT:    Flags [ (0x2)
-# CHECK-NEXT:      SHF_ALLOC (0x2)
-# CHECK-NEXT:    ]
-# CHECK-NEXT:    Address: 0x2001C8
-# CHECK-NEXT:    Offset: 0x1C8
-# CHECK-NEXT:    Size: 96
-# CHECK-NEXT:    Link: 5
-# CHECK-NEXT:    Info: 1
-# CHECK-NEXT:    AddressAlignment: 8
-# CHECK-NEXT:    EntrySize: 24
-# CHECK:       Section {
-# CHECK-NEXT:   Index: 2
-# CHECK-NEXT:   Name: .gnu.version
-# CHECK-NEXT:   Type: SHT_GNU_versym (0x6FFFFFFF)
-# CHECK-NEXT:   Flags [ (0x2)
-# CHECK-NEXT:     SHF_ALLOC (0x2)
-# CHECK-NEXT:   ]
-# CHECK-NEXT:   Address: 0x200228
-# CHECK-NEXT:   Offset: 0x228
-# CHECK-NEXT:   Size: 8
-# CHECK-NEXT:   Link: 1
-# CHECK-NEXT:   Info: 0
-# CHECK-NEXT:   AddressAlignment: 2
-# CHECK-NEXT:   EntrySize: 2
+# CHECK:          Index: 1
+# CHECK-NEXT:     Name: .dynsym
+# CHECK-NEXT:     Type: SHT_DYNSYM (0xB)
+# CHECK-NEXT:     Flags [ (0x2)
+# CHECK-NEXT:       SHF_ALLOC (0x2)
+# CHECK-NEXT:     ]
+# CHECK-NEXT:     Address: 0x2001C8
+# CHECK-NEXT:     Offset: 0x1C8
+# CHECK-NEXT:     Size: 96
+# CHECK-NEXT:     Link: 2
+# CHECK-NEXT:     Info: 1
+# CHECK-NEXT:     AddressAlignment: 8
+# CHECK-NEXT:     EntrySize: 24
+
+# CHECK:        Section {
+# CHECK-NEXT:     Index: 2
+# CHECK-NEXT:     Name: .dynstr
+# CHECK-NEXT:     Type: SHT_STRTAB (0x3)
+# CHECK-NEXT:     Flags [ (0x2)
+# CHECK-NEXT:       SHF_ALLOC (0x2)
+# CHECK-NEXT:     ]
+# CHECK-NEXT:     Address: 0x200228
+# CHECK-NEXT:     Offset: 0x228
+# CHECK-NEXT:     Size: 47
+# CHECK-NEXT:     Link: 0
+# CHECK-NEXT:     Info: 0
+# CHECK-NEXT:     AddressAlignment: 1
+# CHECK-NEXT:     EntrySize: 0
+# CHECK-NEXT:     SectionData (
+# CHECK-NEXT:       0000: 00766572 6E656564 312E736F 2E300076  |.verneed1.so.0.v|
+# CHECK-NEXT:       0010: 65726E65 6564322E 736F2E30 00663100  |erneed2.so.0.f1.|
+# CHECK-NEXT:       0020: 76330066 32007632 00673100 763100    |v3.f2.v2.g1.v1.|
+# CHECK-NEXT:     )
+# CHECK-NEXT:   }
+
+# CHECK:       Section {
+# CHECK-NEXT:    Index: 3
+# CHECK-NEXT:    Name: .gnu.version
+# CHECK-NEXT:    Type: SHT_GNU_versym (0x6FFFFFFF)
+# CHECK-NEXT:    Flags [ (0x2)
+# CHECK-NEXT:      SHF_ALLOC (0x2)
+# CHECK-NEXT:    ]
+# CHECK-NEXT:    Address: 0x200258
+# CHECK-NEXT:    Offset: 0x258
+# CHECK-NEXT:    Size: 8
+# CHECK-NEXT:    Link: 1
+# CHECK-NEXT:    Info: 0
+# CHECK-NEXT:    AddressAlignment: 2
+# CHECK-NEXT:    EntrySize: 2
+
 # CHECK:       Section {
-# CHECK-NEXT:   Index: 3
-# CHECK-NEXT:   Name: .gnu.version_r
-# CHECK-NEXT:   Type: SHT_GNU_verneed (0x6FFFFFFE)
-# CHECK-NEXT:   Flags [ (0x2)
-# CHECK-NEXT:     SHF_ALLOC (0x2)
-# CHECK-NEXT:   ]
-# CHECK-NEXT:   Address: 0x200230
-# CHECK-NEXT:   Offset: 0x230
-# CHECK-NEXT:   Size: 80
-# CHECK-NEXT:   Link: 5
-# CHECK-NEXT:   Info: 2
-# CHECK-NEXT:   AddressAlignment: 4
-# CHECK-NEXT:   EntrySize: 0
-# CHECK:      Section {
-# CHECK:        Index: 5
-# CHECK-NEXT:   Name: .dynstr
-# CHECK-NEXT:   Type: SHT_STRTAB
-# CHECK-NEXT:   Flags [ (0x2)
-# CHECK-NEXT:     SHF_ALLOC (0x2)
-# CHECK-NEXT:   ]
-# CHECK-NEXT:   Address: 0x2002A8
-# CHECK-NEXT:   Offset: 0x2A8
-# CHECK-NEXT:   Size: 47
-# CHECK-NEXT:   Link: 0
-# CHECK-NEXT:   Info: 0
-# CHECK-NEXT:   AddressAlignment: 1
-# CHECK-NEXT:   EntrySize: 0
-# CHECK-NEXT:   SectionData (
-# CHECK-NEXT:     0000: 00766572 6E656564 312E736F 2E300076  |.verneed1.so.0.v|
-# CHECK-NEXT:     0010: 65726E65 6564322E 736F2E30 00663100  |erneed2.so.0.f1.|
-# CHECK-NEXT:     0020: 76330066 32007632 00673100 763100    |v3.f2.v2.g1.v1.|
-# CHECK-NEXT:   )
-# CHECK-NEXT: }
+# CHECK-NEXT:    Index: 4
+# CHECK-NEXT:    Name: .gnu.version_r
+# CHECK-NEXT:    Type: SHT_GNU_verneed (0x6FFFFFFE)
+# CHECK-NEXT:    Flags [ (0x2)
+# CHECK-NEXT:      SHF_ALLOC (0x2)
+# CHECK-NEXT:    ]
+# CHECK-NEXT:    Address: 0x200260
+# CHECK-NEXT:    Offset: 0x260
+# CHECK-NEXT:    Size: 80
+# CHECK-NEXT:    Link: 2
+# CHECK-NEXT:    Info: 2
+# CHECK-NEXT:    AddressAlignment: 4
+# CHECK-NEXT:    EntrySize: 0
 
 # CHECK:      DynamicSymbols [
 # CHECK-NEXT:   Symbol {
 # CHECK-NEXT:     Name: @
 # CHECK-NEXT:     Value: 0x0
 # CHECK-NEXT:     Size: 0
 # CHECK-NEXT:     Binding: Local (0x0)
 # CHECK-NEXT:     Type: None (0x0)

 # CHECK-NEXT:     Size: 0
 # CHECK-NEXT:     Binding: Global (0x1)
 # CHECK-NEXT:     Type: None (0x0)
 # CHECK-NEXT:     Other: 0
 # CHECK-NEXT:     Section: Undefined (0x0)
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]
 
-# CHECK:      0x000000006FFFFFF0 VERSYM               0x200228
-# CHECK-NEXT: 0x000000006FFFFFFE VERNEED              0x200230
+# CHECK:      0x000000006FFFFFF0 VERSYM               0x200258
+# CHECK-NEXT: 0x000000006FFFFFFE VERNEED              0x200260
 # CHECK-NEXT: 0x000000006FFFFFFF VERNEEDNUM           2
 
 # CHECK:      Version symbols {
 # CHECK-NEXT:    Section Name: .gnu.version
-# CHECK-NEXT:    Address: 0x200228
-# CHECK-NEXT:    Offset: 0x228
+# CHECK-NEXT:    Address: 0x200258
+# CHECK-NEXT:    Offset: 0x258
 # CHECK-NEXT:    Link: 1
 # CHECK-NEXT:    Symbols [
 # CHECK-NEXT:      Symbol {
 # CHECK-NEXT:        Version: 0
 # CHECK-NEXT:        Name: @
 # CHECK-NEXT:      }
 # CHECK-NEXT:      Symbol {
 # CHECK-NEXT:        Version: 2

test/ELF/version-script-extern.s

 # REQUIRES: x86
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: echo "LIBSAMPLE_1.0 { global:" > %t.script
 # RUN: echo '  extern "C++" { "foo(int)"; "zed(int)"; "abc::abc()"; };' >> %t.script
 # RUN: echo "};" >> %t.script
 # RUN: echo "LIBSAMPLE_2.0 { global:" >> %t.script
 # RUN: echo '  extern "C" { _Z3bari; };' >> %t.script
 # RUN: echo "};" >> %t.script
-# RUN: ld.lld --hash-style=sysv --version-script %t.script -shared %t.o -o %t.so
+# RUN: ld.lld --hash-style=sysv --version-script %t.script -soname fixed-length-string -shared %t.o -o %t.so
 # RUN: llvm-readobj -V -dyn-symbols %t.so | FileCheck --check-prefix=DSO %s
 
 # DSO:      DynamicSymbols [
 # DSO-NEXT:    Symbol {
 # DSO-NEXT:      Name: @
 # DSO-NEXT:      Value: 0x0
 # DSO-NEXT:      Size: 0
 # DSO-NEXT:      Binding: Local

 # DSO-NEXT:      Binding: Global (0x1)
 # DSO-NEXT:      Type: Function (0x2)
 # DSO-NEXT:      Other: 0
 # DSO-NEXT:      Section: .text (0x6)
 # DSO-NEXT:    }
 # DSO-NEXT:  ]
 # DSO-NEXT:  Version symbols {
 # DSO-NEXT:    Section Name: .gnu.version
-# DSO-NEXT:    Address: 0x258
-# DSO-NEXT:    Offset: 0x258
+# DSO-NEXT:    Address: 0x2BA
+# DSO-NEXT:    Offset: 0x2BA
 # DSO-NEXT:    Link: 1
 # DSO-NEXT:    Symbols [
 # DSO-NEXT:      Symbol {
 # DSO-NEXT:        Version: 0
 # DSO-NEXT:        Name: @
 # DSO-NEXT:      }
 # DSO-NEXT:      Symbol {
 # DSO-NEXT:        Version: 3

test/ELF/x86-64-retpoline-linkerscript.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 %p/Inputs/shared.s -o %t2.o
 // RUN: ld.lld -shared %t2.o -o %t2.so
 
 // RUN: echo "SECTIONS { \
 // RUN:   .text : { *(.text) } \
 // RUN:   .plt : { *(.plt) } \
 // RUN:   .got.plt : { *(.got.plt) } \
 // RUN:   .dynstr : { *(.dynstr) } \
 // RUN: }" > %t.script
 // RUN: ld.lld -shared %t1.o %t2.so -o %t.exe -z retpolineplt --script %t.script
 // RUN: llvm-objdump -d -s %t.exe | FileCheck %s
 
 // CHECK:      Disassembly of section .plt:
 // CHECK-NEXT: .plt:
-// CHECK-NEXT: 10:       ff 35 4a 01 00 00       pushq   330(%rip)
-// CHECK-NEXT: 16:       4c 8b 1d 4b 01 00 00    movq    331(%rip), %r11
+// CHECK-NEXT: 10:       ff 35 ea 00 00 00       pushq   234(%rip)
+// CHECK-NEXT: 16:       4c 8b 1d eb 00 00 00    movq    235(%rip), %r11
 // CHECK-NEXT: 1d:       e8 0e 00 00 00  callq   14 <.plt+0x20>
 // CHECK-NEXT: 22:       f3 90   pause
 // CHECK-NEXT: 24:       0f ae e8        lfence
 // CHECK-NEXT: 27:       eb f9   jmp     -7 <.plt+0x12>
 // CHECK-NEXT: 29:       cc      int3
 // CHECK-NEXT: 2a:       cc      int3
 // CHECK-NEXT: 2b:       cc      int3
 // CHECK-NEXT: 2c:       cc      int3
 // CHECK-NEXT: 2d:       cc      int3
 // CHECK-NEXT: 2e:       cc      int3
 // CHECK-NEXT: 2f:       cc      int3
 // CHECK-NEXT: 30:       4c 89 1c 24     movq    %r11, (%rsp)
 // CHECK-NEXT: 34:       c3      retq
 // CHECK-NEXT: 35:       cc      int3
 // CHECK-NEXT: 36:       cc      int3
 // CHECK-NEXT: 37:       cc      int3
 // CHECK-NEXT: 38:       cc      int3
 // CHECK-NEXT: 39:       cc      int3
 // CHECK-NEXT: 3a:       cc      int3
 // CHECK-NEXT: 3b:       cc      int3
 // CHECK-NEXT: 3c:       cc      int3
 // CHECK-NEXT: 3d:       cc      int3
 // CHECK-NEXT: 3e:       cc      int3
 // CHECK-NEXT: 3f:       cc      int3
-// CHECK-NEXT: 40:       4c 8b 1d 29 01 00 00    movq    297(%rip), %r11
+// CHECK-NEXT: 40:       4c 8b 1d c9 00 00 00    movq    201(%rip), %r11
 // CHECK-NEXT: 47:       e8 e4 ff ff ff  callq   -28 <.plt+0x20>
 // CHECK-NEXT: 4c:       e9 d1 ff ff ff  jmp     -47 <.plt+0x12>
 // CHECK-NEXT: 51:       68 00 00 00 00  pushq   $0
 // CHECK-NEXT: 56:       e9 b5 ff ff ff  jmp     -75 <.plt>
 // CHECK-NEXT: 5b:       cc      int3
 // CHECK-NEXT: 5c:       cc      int3
 // CHECK-NEXT: 5d:       cc      int3
 // CHECK-NEXT: 5e:       cc      int3
 // CHECK-NEXT: 5f:       cc      int3
-// CHECK-NEXT: 60:       4c 8b 1d 11 01 00 00    movq    273(%rip), %r11
+// CHECK-NEXT: 60:       4c 8b 1d b1 00 00 00    movq    177(%rip), %r11
 // CHECK-NEXT: 67:       e8 c4 ff ff ff  callq   -60 <.plt+0x20>
 // CHECK-NEXT: 6c:       e9 b1 ff ff ff  jmp     -79 <.plt+0x12>
 // CHECK-NEXT: 71:       68 01 00 00 00  pushq   $1
 // CHECK-NEXT: 76:       e9 95 ff ff ff  jmp     -107 <.plt>
 // CHECK-NEXT: 7b:       cc      int3
 // CHECK-NEXT: 7c:       cc      int3
 // CHECK-NEXT: 7d:       cc      int3
 // CHECK-NEXT: 7e:       cc      int3
 // CHECK-NEXT: 7f:       cc      int3
 
 .global _start
 _start:
   jmp bar@PLT
   jmp zed@PLT

test/ELF/x86-64-retpoline-znow-linkerscript.s

 // CHECK-NEXT: 28:  cc  int3
 // CHECK-NEXT: 29:  cc  int3
 // CHECK-NEXT: 2a:  cc  int3
 // CHECK-NEXT: 2b:  cc  int3
 // CHECK-NEXT: 2c:  cc  int3
 // CHECK-NEXT: 2d:  cc  int3
 // CHECK-NEXT: 2e:  cc  int3
 // CHECK-NEXT: 2f:  cc  int3
-// CHECK-NEXT: 30:  4c 8b 1d 09 01 00 00  movq  265(%rip), %r11
+// CHECK-NEXT: 30:  4c 8b 1d a9 00 00 00  movq  169(%rip), %r11
 // CHECK-NEXT: 37:  e9 d4 ff ff ff  jmp -44 <.plt>
 // CHECK-NEXT: 3c:  cc  int3
 // CHECK-NEXT: 3d:  cc  int3
 // CHECK-NEXT: 3e:  cc  int3
 // CHECK-NEXT: 3f:  cc  int3
-// CHECK-NEXT: 40: 4c 8b 1d 01 01 00 00   movq  257(%rip), %r11
+// CHECK-NEXT: 40:      4c 8b 1d a1 00 00 00  movq  161(%rip), %r11
 // CHECK-NEXT: 47:  e9 c4 ff ff ff  jmp -60 <.plt>
 // CHECK-NEXT: 4c:  cc  int3
 // CHECK-NEXT: 4d:  cc  int3
 // CHECK-NEXT: 4e:  cc  int3
 // CHECK-NEXT: 4f:  cc  int3
 
 .global _start
 _start:
   jmp bar@PLT
   jmp zed@PLT