[ELF] Assign RF_EXEC rank even if --no-rosegment or SECTIONS command is used

[MaskRay]

Summary

Currently when --no-rosegment is specified or a linker script with SECTIONS command is used,
.rodata (A) .text (AX) are assigned the same rank and .rodata may be placed after .text .
This increases the gap between .text and .bss and can cause pc-relative relocation overflow (e.g. gcc crtbegin.o crtbegin.S have R_X86_64_PC32 relocation from .text to .bss).

This patch makes SingleRoRx affect only segment layout, not section layout. As a consequence, .rodata will be placed before .text regardless of SingleRoRx.

[MaskRay]

30+ failing tests because of changed addresses...

[MaskRay]

Update test. 30 more...

[MaskRay]

Fix some tests

[MaskRay]

Update description

[MaskRay]

More

[MaskRay]

Updated all tests

[atanasyan]

test/ELF/mips-gp-ext.s

28–29

Please change in this comment 0x13c to 0x1ec (new _gp value)

[MaskRay]

update _gp in mips-gp-ext.s

[echristo]

I think this is obsolete after the other patch?

-eric

[MaskRay]

Sorry this has been superseded by https://reviews.llvm.org/D48406

(The only commands about arc I know are arc diff origin/master and sometimes it got messed up)

[MaskRay]

Sorry this is still useful...

This is a subset of https://reviews.llvm.org/D48406 but this also has less failing tests to update (30+)

D48406 requires to update 60+ tests. I'd like to see this revision reviewed first before working on D48406 tests.

[echristo]

ELF/Writer.cpp

767

Can you rebase this on the other patch and then add some comments about the ranking into the source?

[MaskRay]

ELF/Writer.cpp

767

D48406 is based on this one (which I'd like to collect some feedback about section reordering as fixing 60+ tests are painful)

This one D48405 is not dependent on the other.

[MaskRay]

ELF/Writer.cpp

767

This patch merely removes code (the if (!Config->SingleRoRx) condition). It is fairly obvious what it does.

I think SingleRoRx (true if --no-rosegment or SECTION command is used) should be an option that changes the segment layout (one more PT_LOAD), not an option that also changes section layout (so I think it should have been documented why the SingleRoRx flag disabled the RF_EXEC assignment).

[echristo]

ELF/Writer.cpp

767

I agree with all of that. I'm still pretty sure that the comment above it needs to be updated :)

[grimar]

This patch seems to do a lot of unnecessary changes to the test cases.
Generally, a best practice for the patch is to do a minimal amount of changes,
though here I see unnecessary renaming changes, refactoring(?) changes etc in tests.

test/ELF/arm-exidx-order.s

2

Can you avoid unnecessary changes in the patches, please?
Moving "requires" is OK, but can be done separately. Such changes makes doing review harder.

test/ELF/arm-exidx-sentinel-orphan.s

2

The same.

test/ELF/arm-plt-reloc.s

165 ↗

(On Diff #152327)

This can be

Section {{.*}} .rel.plt

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

10

Why you had to add that?

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

7

Was it necessary change?

test/ELF/linkerscript/locationcountererr2.s

5

Why are you changing the way how we writing the script?

test/ELF/linkerscript/no-space.s

6

Why are you doing this in this patch?

test/ELF/linkerscript/non-absolute.s

8

This seems wrong

0x94 - 168 != 0xB

test/ELF/linkerscript/non-alloc.s

6

Again, why? What is wrong with using %t and llvm-readelf?

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

20

Why you removed this?

test/ELF/linkerscript/sections-keep.s

3

Why are you renaming inputs? It brings so many changes to the rest of the test case, please don't do that.

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

6

Same here and below.

[MaskRay]

test/ELF/arm-exidx-order.s

2

Sorry if it did any *unnecessary* changes. But I don't there any change is refactoring.

2

s/there/think/

[MaskRay]

test/ELF/arm-exidx-order.s

2

Fixing these tests are already painful and I am not prepared to split to simple REQUIRES: moving change to a separate patch (double work for the case that is not worthy)

[MaskRay]

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

10

Otherwise .text is zero-sized and the segment layout will be different.

PHDR: Segment Sections
PHDR: .eh_frame {{.*}}.text

zero-sized section may have weird display in llvm-readelf (it may be counted multiple times).

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

7

llvm-readelf is more common. I happened to change this place so I replaced the command.

test/ELF/linkerscript/locationcountererr2.s

5

OK. reverted the change.

This backslash form is more common so I replaced it. Since you have objection, I reverted it.

test/ELF/linkerscript/no-space.s

6

Just before llvm-readelf is used more and for consistency I wanted to replace them.

If you insist removing them I would probably have to move that to a separate revision

test/ELF/linkerscript/non-absolute.s

8

Thanks! Fixed.

test/ELF/linkerscript/non-alloc.s

6

Nothing wrong but just for consistency.

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

20

Added back.

# CHECK-NEXT: Address: 0x1070

But I do not think this address is useful (it merely causes trouble when section layout is changed)

[MaskRay]

You regard these changes:

llvm-readobj --elf-output-style=GNU -> llvm-readelf
llvm-mc ... -o %t -> llvm-mc ... -o %t.o

as "refactoring". They were for the purpose of consistency.
Sorry about all these and I did not know they made you think so. I thought the reviewer would be annoyed to see these changes being reviewed twice as I took them as lifting a finger when I happened to change places nearby. (it was really really painful for me to go through the 30+ failing tests and I didn't want to double my work) If you had mercy upon me and let me save my efforts on D48406 I would very appreciate it (also a section layout change and would affect another 30+ failing tests. But the section layout has not been finalized. I do want to remove some hackery DYNSTR DYNSYM nad make them more general).

Another annoyance I found when updating the tests is the llvm-objdump display of TEXT DATA. I have made D48472 and its companion LLD change D48473 and if you can review it I will be very grateful. (I promise there are only TEXT DATA -> DATA changes, absolutely nothing else sneaked in! 😼)

[grimar]

In D48405#1140879, @MaskRay wrote:

You regard these changes:

llvm-readobj --elf-output-style=GNU -> llvm-readelf
llvm-mc ... -o %t -> llvm-mc ... -o %t.o

as "refactoring". They were for the purpose of consistency.

Please do not do it. I am OK if you will commit this changes separately as NFC,
but don't mix functionality changes and unrelative cosmetic changes in the patches.

test/ELF/arm-exidx-order.s

2

Then just revert it, please. There is no need to move this "REQUIRES arm" in this patch.

Doing as less as possible changes in the patch is really important not only during the review stage.
It is also useful for future cases when we might need to review previous commits. Imagine what is better,
to review many places where most of them are unimportant or to focus on the changes which were a purpose of the patch?

Also if we might want to revert this patch (who knows, that is possible) then such "refactorings" would be probably reverted too.

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

10

Thanks for the explanation, that was no obvious.

test/ELF/linkerscript/locationcountererr2.s

5

I have no objections using "backslash form" or even maybe writing this echo in a single line,
but best practice is to do as minimum changes as possible in the patch you are posting,
so that you should focus the reviewer's attention on the necessary changes you make and not on the refactorings.

So such changes can be committed as NFC separately if you wish, but not included into patch doing functional change.

test/ELF/linkerscript/no-space.s

6

Yes, please.

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

20

Actually, it seems to be the most important line of the test case for me. It shows where the orphan .text section was placed.
Without that line, what this test does/checks in your opinion?

Initial commit message of this test case says: "Don't put an orphan before the first . assignment.
This is an horrible special case, but seems to match bfd's behaviour
and is important for avoiding placing an orphan section before the
expected start of the file."

I think that line checks that behavior.

[MaskRay]

Committed style change separately as grimar suggested. Thanks!

[MaskRay]

Reword description

[MaskRay]

Change comment as echristo suggested

[ruiu]

LGTM

I dug into the history of this file to see why we have this if condition in the first place, and looks like there's no strong reason to do that.

[grimar]

LGTM with 2 nits.

test/ELF/arm-exidx-order.s

2

One more place to commit separately.

test/ELF/linkerscript/non-absolute.s

8

The calculation is now correct, but I am not sure how it is useful.

What is -0xF here? How is it correlated with the output which is 0xFFFFFFFFFFFFFFF1?
Since there was no such comment originally, I would either remove it or fix so that it becomes useful.

ELF/Writer.cpp

static unsigned getSectionRank(const OutputSection *Sec) {
   // * Writable sections come last, such that .bss lands at the very
   //   end of the last PT_LOAD.
   bool IsExec = Sec->Flags & SHF_EXECINSTR;
   bool IsWrite = Sec->Flags & SHF_WRITE;
 
   if (IsExec) {
     if (IsWrite)
       Rank |= RF_EXEC_WRITE;
-    else if (!Config->SingleRoRx)
+    else
       Rank |= RF_EXEC;
   } else {
     if (IsWrite)
       Rank |= RF_WRITE;
   }
 
   // If we got here we know that both A and B are in the same PT_LOAD.
 

test/ELF/aarch64-thunk-pi.s

  .section .text_low, "ax", %progbits
  .globl low_target
  .type low_target, %function
 low_target:
  // Need thunk to high_target@plt
  bl high_target
  ret
 // CHECK: low_target:
-// CHECK-NEXT:        0:        04 00 00 94     bl      #16
-// CHECK-NEXT:        4:        c0 03 5f d6     ret
+// CHECK-NEXT:        8:        04 00 00 94     bl      #16
+// CHECK-NEXT:        c:        c0 03 5f d6     ret
 
  .hidden low_target2
  .globl low_target2
  .type low_target2, %function
 low_target2:
  // Need thunk to high_target
  bl high_target2
  ret
 // CHECK: low_target2:
-// CHECK-NEXT:        8:        05 00 00 94     bl      #20
-// CHECK-NEXT:        c:        c0 03 5f d6     ret
+// CHECK-NEXT:        0:        05 00 00 94     bl      #20
+// CHECK-NEXT:        4:        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:       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-NEXT:       e8:       10 00 08 90     adrp    x16, #268435456
+// CHECK-NEXT:       ec:       10 02 01 91     add     x16, x16, #64
+// CHECK-NEXT:       f0:       00 02 1f d6     br      x16
 // CHECK: __AArch64ADRPThunk_high_target2:
-// 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
+// CHECK-NEXT:       f4:       10 00 08 90     adrp    x16, #268435456
+// CHECK-NEXT:       f8:       10 22 00 91     add     x16, x16, #8
+// CHECK-NEXT:       fc:       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:        34 00 00 94     bl      #208
+// CHECK-NEXT: 10000000:        14 00 00 94     bl #80
 // 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 a2 01 91   add x16, x16, #104
+// CHECK-NEXT: 10000014:  10 82 03 91   add x16, x16, #224
 // CHECK-NEXT: 10000018:  00 02 1f d6   br  x16
 
 // CHECK: Disassembly of section .plt:
 // CHECK-NEXT: .plt:
-// 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
+// CHECK-NEXT: 10000020:       f0 7b bf a9     stp     x16, x30, [sp, #-16]!
+// CHECK-NEXT: 10000024:       10 00 00 90     adrp    x16, #0
+// CHECK-NEXT: 10000028:       11 3a 40 f9     ldr     x17, [x16, #112]
+// CHECK-NEXT: 1000002c:       10 c2 01 91     add     x16, x16, #112
+// CHECK-NEXT: 10000030:       20 02 1f d6     br      x17
+// CHECK-NEXT: 10000034:       1f 20 03 d5     nop
+// CHECK-NEXT: 10000038:       1f 20 03 d5     nop
+// CHECK-NEXT: 1000003c:       1f 20 03 d5     nop
+// CHECK-NEXT: 10000040:       10 00 00 90     adrp    x16, #0
+// CHECK-NEXT: 10000044:       11 3e 40 f9     ldr     x17, [x16, #120]
+// CHECK-NEXT: 10000048:       10 e2 01 91     add     x16, x16, #120
+// CHECK-NEXT: 1000004c:       20 02 1f d6     br      x17
+// CHECK-NEXT: 10000050:       10 00 00 90     adrp    x16, #0
+// CHECK-NEXT: 10000054:       11 42 40 f9     ldr     x17, [x16, #128]
+// CHECK-NEXT: 10000058:       10 02 02 91     add     x16, x16, #128
+// CHECK-NEXT: 1000005c:       20 02 1f d6     br      x17

test/ELF/arm-exidx-order.s

+// REQUIRES: arm
 // RUN: llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi %s -o %t
 // RUN: llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi %S/Inputs/arm-exidx-cantunwind.s -o %tcantunwind
 // RUN: ld.lld --no-merge-exidx-entries %t %tcantunwind -o %t2 2>&1
 // RUN: llvm-objdump -d -triple=armv7a-none-linux-gnueabi %t2 | FileCheck %s
 // RUN: llvm-objdump -s -triple=armv7a-none-linux-gnueabi %t2 | FileCheck -check-prefix=CHECK-EXIDX %s
 // RUN: llvm-readobj --program-headers --sections %t2 | FileCheck -check-prefix=CHECK-PT %s
 // Use Linker script to place .ARM.exidx in between .text and orphan sections
 // RUN: echo "SECTIONS { \
 // RUN:          .text 0x11000 : { *(.text*) } \
 // RUN:          .ARM.exidx : { *(.ARM.exidx) } } " > %t.script
 // RUN: ld.lld --no-merge-exidx-entries --script %t.script %tcantunwind %t -o %t3 2>&1
 // RUN: llvm-objdump -d -triple=armv7a-none-linux-gnueabi %t3 | FileCheck -check-prefix=CHECK-SCRIPT %s
 // RUN: llvm-objdump -s -triple=armv7a-none-linux-gnueabi %t3 | FileCheck -check-prefix=CHECK-SCRIPT-EXIDX %s
-// REQUIRES: arm
 
 // Each assembler created .ARM.exidx section has the SHF_LINK_ORDER flag set
 // with the sh_link containing the section index of the executable section
 // containing the function it describes. The linker must combine the .ARM.exidx
 // InputSections in the same order that it has combined the executable section,
 // such that the combined .ARM.exidx OutputSection can be used as a binary
 // search table.
 

 // CHECK-SCRIPT:      f1:
 // CHECK-SCRIPT-NEXT:    1100c:       1e ff 2f e1     bx      lr
 // CHECK-SCRIPT:      f2:
 // CHECK-SCRIPT-NEXT:    11010:       1e ff 2f e1     bx      lr
 // CHECK-SCRIPT:      f3:
 // CHECK-SCRIPT-NEXT:    11014:       1e ff 2f e1     bx      lr
 // CHECK-SCRIPT-NEXT: Disassembly of section .func1:
 // CHECK-SCRIPT-NEXT: func1:
-// CHECK-SCRIPT-NEXT:    11068:       1e ff 2f e1     bx      lr
+// CHECK-SCRIPT-NEXT:    11018:       1e ff 2f e1     bx      lr
 // CHECK-SCRIPT-NEXT: Disassembly of section .func2:
 // CHECK-SCRIPT-NEXT: func2:
-// CHECK-SCRIPT-NEXT:    1106c:       1e ff 2f e1     bx      lr
+// CHECK-SCRIPT-NEXT:    1101c:       1e ff 2f e1     bx      lr
 // CHECK-SCRIPT-NEXT: Disassembly of section .func3:
 // CHECK-SCRIPT-NEXT: func3:
-// CHECK-SCRIPT-NEXT:    11070:       1e ff 2f e1     bx      lr
+// CHECK-SCRIPT-NEXT:    11020:       1e ff 2f e1     bx      lr
 
 // Check that the .ARM.exidx section is sorted in order as the functions
 // The offset in field 1, is 32-bit so in the binary the most significant bit
-// 11018 - 18 = 11000 func4
-// 11020 - 1c = 11004 func5
-// CHECK-SCRIPT-EXIDX:       11018 e8ffff7f 01000000 e4ffff7f 01000000
-// 11028 - 20 = 11008 _start
-// 11030 - 24 = 1100c f1
-// CHECK-SCRIPT-EXIDX-NEXT:  11028 e0ffff7f 01000000 dcffff7f 01000000
-// 11038 - 28 = 11010 f2
-// 11040 - 2c = 11014 f3
-// CHECK-SCRIPT-EXIDX-NEXT:  11038 d8ffff7f 01000000 d4ffff7f 01000000
-// 11048 + 20 = 11068 func1
-// 11050 + 1c = 1106c func2
-// CHECK-SCRIPT-EXIDX-NEXT:  11048 20000000 01000000 1c000000 01000000
-// 11058 + 18 = 11070 func3
-// 11060 + 14 = 11074 func3 + sizeof(func3)
-// CHECK-SCRIPT-EXIDX-NEXT:  11058 18000000 01000000 14000000 01000000
+// 11024 - 24 = 11000 func4
+// 1102c - 28 = 11004 func5
+// CHECK-SCRIPT-EXIDX:       11024 dcffff7f 01000000 d8ffff7f 01000000
+// 11034 - 2c = 11008 _start
+// 1103c - 30 = 1100c f1
+// CHECK-SCRIPT-EXIDX-NEXT:  11034 d4ffff7f 01000000 d0ffff7f 01000000
+// 11044 - 34 = 11010 f2
+// 1104c - 38 = 11014 f3
+// CHECK-SCRIPT-EXIDX-NEXT:  11044 ccffff7f 01000000 c8ffff7f 01000000
+// 11054 - 3c = 11018 func1
+// 1105c - 40 = 1101c func2
+// CHECK-SCRIPT-EXIDX-NEXT:  11054 c4ffff7f 01000000 c0ffff7f 01000000
+// 11064 - 44 = 11020 func3
+// 11068 - 48 = 11024 func3 + sizeof(func3)
+// CHECK-SCRIPT-EXIDX-NEXT:  11064 bcffff7f 01000000 b8ffff7f 01000000

test/ELF/arm-exidx-sentinel-orphan.s

 // REQUIRES: arm
 // RUN: llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi %s -o %t
 // Use Linker script without .ARM.exidx Output Section so it is treated as
 // an orphan. We must still add the sentinel table entry
 // RUN: echo "SECTIONS { \
 // RUN:          .text 0x11000 : { *(.text*) } \
 // RUN:          } " > %t.script
 // RUN: ld.lld --no-merge-exidx-entries --script %t.script %t -o %t2
 // RUN: llvm-objdump -s -triple=armv7a-none-linux-gnueabi %t2 | FileCheck %s
 
  .syntax unified
  .text
  .global _start
 _start:
  .fnstart
  .cantunwind
  bx lr
  .fnend
 
 // CHECK: Contents of section .ARM.exidx:
 // 11004 - 4 = 0x11000 = _start
 // 1100c - 8 = 0x11004 = _start + sizeof(_start)
-// CHECK-NEXT: 11004 fcffff7f 01000000 f8ffff7f 01000000
+// CHECK-NEXT: 0000 00100100 01000000 fc0f0100 01000000

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

 // REQUIRES: x86
 
 .cfi_startproc
 .cfi_personality 0x1b, bar
 .cfi_endproc
 
 .global bar
 .hidden bar
 bar:
+  ret
 
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 
 // Check the size of the CIE (0x18 + 4) and FDE (0x10 + 4)
 // RUN: llvm-readobj -s -section-data %t.o | FileCheck --check-prefix=OBJ %s
 
 // OBJ:      Name: .eh_frame
 // OBJ-NEXT: Type:

 // OBJ-NEXT: )
 
 // RUN: ld.lld --hash-style=sysv %t.o -no-rosegment -o %t -shared
 
 // Check that .eh_frame is in the same segment as .text
 // RUN: llvm-readobj -l --elf-output-style=GNU %t | FileCheck --check-prefix=PHDR %s
 
 // PHDR: Segment Sections
-// PHDR: .text
-// PHDR-SAME: .eh_frame
+// PHDR: .eh_frame {{.*}}.text
 
 // Check that the CIE and FDE are padded with 0x00 and not 0xCC when the
 // .eh_frame section is placed in the executable segment
 // RUN: llvm-readobj -s -section-data %t | FileCheck %s
 
 // CHECK:      Name: .eh_frame
 // CHECK-NEXT: Type:
 // CHECK-NEXT: Flags
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT: ]
 // CHECK-NEXT: Address:
 // 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: 061BDAFF FFFF1B0C 07089001 00000000
-// CHECK-NEXT:   0020: 14000000 24000000 C4FFFFFF 00000000
+// CHECK-NEXT:   0010: 061B2A00 00001B0C 07089001 00000000
+// CHECK-NEXT:   0020: 14000000 24000000 14000000 00000000
 // CHECK-NEXT:   0030: 00000000 00000000
 // CHECK-NEXT: )

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 cc 00 00 00       pushl   204
+// CHECK-NEXT: 10:       ff 35 84 00 00 00       pushl   132
 // CHECK-NEXT: 16:       50      pushl   %eax
-// CHECK-NEXT: 17:       a1 d0 00 00 00 movl    208, %eax
+// CHECK-NEXT: 17:       a1 88 00 00 00 movl    136, %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 d4 00 00 00  movl    212, %eax
+// CHECK-NEXT: 41:       a1 8c 00 00 00  movl    140, %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 d8 00 00 00  movl    216, %eax
+// CHECK-NEXT: 61:       a1 90 00 00 00  movl    144, %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 cc 00 00 00       pushl   204(%ebx)
+// CHECK-NEXT: 10:       ff b3 84 00 00 00       pushl   132(%ebx)
 // CHECK-NEXT: 16:       50      pushl   %eax
-// CHECK-NEXT: 17:       8b 83 d0 00 00 00 movl    208(%ebx), %eax
+// CHECK-NEXT: 17:       8b 83 88 00 00 00 movl    136(%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 d4 00 00 00       movl    212(%ebx), %eax
+// CHECK-NEXT: 41:       8b 83 8c 00 00 00       movl    140(%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 d8 00 00 00       movl    216(%ebx), %eax
+// CHECK-NEXT: 61:       8b 83 90 00 00 00       movl    144(%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: 0x38
+# CHECK-NEXT:   Value: 0x70
 # 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/data-commands-gc.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: echo "SECTIONS { .text : { *(.text*) QUAD(bar) } }" > %t.script
 # RUN: ld.lld --gc-sections -o %t %t.o --script %t.script
 # RUN: llvm-objdump -t %t | FileCheck %s
 
-# CHECK: 0000000000000011         .rodata                 00000000 bar
+# CHECK: 0000000000000008         .rodata                 00000000 bar
 
 .section .rodata.bar
 .quad 0x1122334455667788
 .global bar
 bar:
 
 .section .text
 .global _start
 _start:
   nop

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: 0x1C
+# CHECK-NEXT:   Address: 0x0
 # 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: 0x20
+# CHECK-NEXT:   Value: 0x4
 # 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/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:  3 .text         00000000 00000000000000d0 TEXT
+# CHECK:  5 .text         00000000 000000000000014c
 
-# CHECK: 00000000000000d1         .text    00000000 foo1
-# CHECK: 00000000000000d1         .text    00000000 bar1
+# CHECK: 000000000000014d         .text    00000000 foo1
+# CHECK: 000000000000014d         .text    00000000 bar1
 # CHECK: 0000000000000000         .text    00000000 foo2
 # CHECK: 0000000000000000         .text    00000000 bar2
-# CHECK: 00000000000000d1         .text    00000000 foo3
-# CHECK: 00000000000000d1         .text    00000000 bar3
+# CHECK: 000000000000014d         .text    00000000 foo3
+# CHECK: 000000000000014d         .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 %t.o -shared
 # RUN: llvm-readelf -l %t1 | FileCheck %s
 
 # CHECK:      Segment Sections...
-# CHECK-NEXT:   00     .text .hash .dynamic
-# CHECK-NEXT:   01     .bar .dynsym .dynstr .foo
+# CHECK-NEXT:   00     .dynsym .dynstr .hash .bar .foo .text .dynamic
+# CHECK-NEXT:   01     .bar .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 ". = 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:  3 .text 00000000 0000000000000010
+# CHECK:  Name   Size      Address
+# CHECK: .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/map-file2.test

 # CHECK-NEXT:       1008             2000        8     1 .bbb
 # CHECK-NEXT:       1008             2000        8     1         {{.*}}{{/|\\}}map-file2.test.tmp.o:(.bbb)
 # CHECK-NEXT:       1010             3000        8     1 .ccc
 # CHECK-NEXT:       1010             3000        8     1         {{.*}}{{/|\\}}map-file2.test.tmp.o:(.ccc)
 # CHECK-NEXT:       1018             3008      109     1 .ddd
 # CHECK-NEXT:       1018             3008        1     1         BYTE ( 0x11 )
 # CHECK-NEXT:       1019             3009      100     1         . += 0x100
 # CHECK-NEXT:       1119             3109        8     1         {{.*}}{{/|\\}}map-file2.test.tmp.o:(.ddd)
-# CHECK-NEXT:       1124             3114        1     4 .text
-# CHECK-NEXT:       1124             3114        1     4         {{.*}}{{/|\\}}map-file2.test.tmp.o:(.text)
-# CHECK-NEXT:       1124             3114        0     1                 f(int)
-# CHECK-NEXT:       1124             3114        0     1                 _start
 # CHECK-NEXT:       1128             3118       34     8 .eh_frame
 # CHECK-NEXT:       1128             3118       30     1         {{.*}}{{/|\\}}map-file2.test.tmp.o:(.eh_frame+0x0)
+# CHECK-NEXT:       115c             314c        1     4 .text
+# CHECK-NEXT:       115c             314c        1     4         {{.*}}{{/|\\}}map-file2.test.tmp.o:(.text)
+# CHECK-NEXT:       115c             314c        0     1                 f(int)
+# CHECK-NEXT:       115c             314c        0     1                 _start
 # CHECK-NEXT:          0                0        8     1 .comment
 # CHECK-NEXT:          0                0        8     1         <internal>:(.comment)
 # CHECK-NEXT:          0                0       48     8 .symtab
 # CHECK-NEXT:          0                0       48     8         <internal>:(.symtab)
 # CHECK-NEXT:          0                0       48     1 .shstrtab
 # CHECK-NEXT:          0                0       48     1         <internal>:(.shstrtab)
 # CHECK-NEXT:          0                0        e     1 .strtab
 # CHECK-NEXT:          0                0        e     1         <internal>:(.strtab)

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*)} .dynsym : {*(.dynsym)} .dynstr : {*(.dynstr)} }" > %t.script
 # RUN: ld.lld --hash-style=sysv -o %t --script %t.script %t.o -shared
 # RUN: llvm-readelf -l %t | FileCheck %s
 
 # 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-readelf -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 .hash .dynsym .dynstr
+# CHECK-NEXT:   00     foo .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
 
+# 0x94+6 - 169 = B = -0xf
 # DUMP:       Disassembly of section .text:
 # DUMP-NEXT:  foo:
-# DUMP-NEXT:   50: {{.*}} -101(%rip), %eax
+# DUMP-NEXT:   94: {{.*}} -169(%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 [

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          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:         5 .text         00000000 0000000000001070
 
 # CHECK: 0000000000000001         .dynsym            00000000 A

test/ELF/linkerscript/non-alloc.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: ld.lld --hash-style=sysv -o %t --script %t.script %t.o -shared
 # RUN: llvm-readelf -s -l %t | FileCheck %s
 
 # Test that we create all necessary PT_LOAD. We use to stop at the first
 # non-alloc, causing us to not create PT_LOAD for linker generated sections.
 
 # CHECK: Program Headers:
 # CHECK-NEXT:  Type
 # CHECK-NEXT:  LOAD {{.*}} R E
 # CHECK-NEXT:  LOAD {{.*}} RW
 
 # CHECK:      Section to Segment mapping:
 # CHECK-NEXT:  Segment Sections...
-# CHECK-NEXT:   00     .dynsym .dynstr .text .hash 
+# CHECK-NEXT:   00     .dynsym .dynstr .hash .text
 # 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: 0x1038
+# CHECK-NEXT: Address: 0x1070

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

 # 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
 # CHECK-NEXT:   2 .dynamic      00000060 0000000000004008
-# CHECK-NEXT:   3 .dynsym       00000018 0000000000002000 
+# CHECK-NEXT:   3 .dynsym       00000018 0000000000002000
 # CHECK-NEXT:   4 .dynstr       00000001 0000000000002018
-# CHECK-NEXT:   5 .text         00000008 000000000000201c
-# CHECK-NEXT:   6 .hash         00000010 0000000000002024
+# CHECK-NEXT:   5 .hash         00000010 000000000000201c
+# CHECK-NEXT:   6 .text         00000008 000000000000202c
 
 .quad 0
 .data
 .quad 0
 

test/ELF/linkerscript/section-metadata.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 
 # RUN: echo "SECTIONS { .text : { *(.text.bar) *(.text.foo)  } }" > %t.script
 # RUN: ld.lld -o %t --script %t.script %t.o
 # RUN: llvm-objdump -s %t | FileCheck %s
 
 # RUN: echo "SECTIONS { .text : { *(.text.foo) *(.text.bar) } }" > %t.script
 # RUN: ld.lld -o %t --script %t.script %t.o
 # RUN: llvm-objdump -s %t | FileCheck --check-prefix=INV %s
 
 
-# CHECK:      Contents of section .text:
-# CHECK-NEXT: 02000000 00000000 01000000 00000000
 # CHECK:      Contents of section .rodata:
 # CHECK-NEXT: 02000000 00000000 01000000 00000000
+# CHECK:      Contents of section .text:
+# CHECK-NEXT: 02000000 00000000 01000000 00000000
 
-# INV:      Contents of section .text:
-# INV-NEXT: 01000000 00000000 02000000 00000000
 # INV:      Contents of section .rodata:
 # INV-NEXT: 01000000 00000000 02000000 00000000
+# INV:      Contents of section .text:
+# INV-NEXT: 01000000 00000000 02000000 00000000
 
 .global _start
 _start:
 
 .section .text.bar,"a",@progbits
 .quad 2
 .section .text.foo,"a",@progbits
 .quad 1
 .section .rodata.foo,"ao",@progbits,.text.foo
 .quad 1
 .section .rodata.bar,"ao",@progbits,.text.bar
 .quad 2

test/ELF/linkerscript/section-metadata2.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: echo "SECTIONS { .text : { *(.text.*) } }" > %t.script
 
 # RUN: echo "_bar" > %t.ord
 # RUN: echo "_foo" >> %t.ord
 # RUN: ld.lld --symbol-ordering-file %t.ord -o %t --script %t.script %t.o
 # RUN: llvm-objdump -s %t | FileCheck %s
 
-# CHECK:      Contents of section .text:
-# CHECK-NEXT: 02000000 00000000 01000000 00000000
 # CHECK:      Contents of section .rodata:
 # CHECK-NEXT: 02000000 00000000 01000000 00000000
+# CHECK:      Contents of section .text:
+# CHECK-NEXT: 02000000 00000000 01000000 00000000
 
 # RUN: echo "_foo" > %t.ord
 # RUN: echo "_bar" >> %t.ord
 # RUN: ld.lld --symbol-ordering-file %t.ord -o %t --script %t.script %t.o
 # RUN: llvm-objdump -s %t | FileCheck %s --check-prefix=INV
 
-# INV:      Contents of section .text:
-# INV-NEXT: 01000000 00000000 02000000 00000000
 # INV:      Contents of section .rodata:
 # INV-NEXT: 01000000 00000000 02000000 00000000
+# INV:      Contents of section .text:
+# INV-NEXT: 01000000 00000000 02000000 00000000
 
 .section .text.foo,"a",@progbits
 _foo:
 .quad 1
 
 .section .text.bar,"a",@progbits
 _bar:
 .quad 2
 
 .section .rodata.foo,"ao",@progbits,.text.foo
 .quad 1
 
 .section .rodata.bar,"ao",@progbits,.text.bar
 .quad 2

test/ELF/linkerscript/sections-keep.s

 # REQUIRES: x86
 # 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/keep.s -o %t1.o
 
 ## First check that section "keep" is garbage collected without using KEEP
 # RUN: echo "SECTIONS { \
 # RUN:  .text : { *(.text) } \
 # RUN:  .keep : { *(.keep) } \
 # RUN:  .temp : { *(.temp) }}" > %t.script
 # RUN: ld.lld --gc-sections -o %t --script %t.script %t.o
 # RUN: llvm-objdump -section-headers %t | \

 # RUN:  .keep : { KEEP(*(.keep)) } \
 # RUN:  .nokeep : { *(.keep) }}" > %t.script
 # RUN: ld.lld --gc-sections -o %t --script %t.script %t.o
 # RUN: llvm-objdump -section-headers %t | FileCheck -check-prefix=MIXED1 %s
 # MIXED1:      Sections:
 # MIXED1-NEXT: Idx Name          Size
 # MIXED1-NEXT:   0               00000000
 # MIXED1-NEXT:   1 .keep         00000004
-# MIXED1-NEXT:   2 .text         00000007 00000000000000ec
-# MIXED1-NEXT:   3 .temp         00000004 00000000000000f3
+# MIXED1-NEXT:   2 .temp         00000004 00000000000000ec
+# MIXED1-NEXT:   3 .text         00000007 00000000000000f0
 # MIXED1-NEXT:   4 .comment      00000008 0000000000000000
 # MIXED1-NEXT:   5 .symtab       00000060 0000000000000000
 # MIXED1-NEXT:   6 .shstrtab     00000036 0000000000000000
 # MIXED1-NEXT:   7 .strtab       00000012 0000000000000000
 
 ## The same, but now section without KEEP is at first place.
 ## gold and bfd linkers disagree here. gold collects .keep while
 ## bfd keeps it. Our current behavior is compatible with bfd although
 ## we can choose either way.
 # RUN: echo "SECTIONS { \
 # RUN:  . = SIZEOF_HEADERS; \
 # RUN:  .nokeep : { *(.keep) } \
 # RUN:  .keep : { KEEP(*(.keep)) }}" > %t.script
 # RUN: ld.lld --gc-sections -o %t --script %t.script %t.o
 # RUN: llvm-objdump -section-headers %t | FileCheck -check-prefix=MIXED2 %s
 # MIXED2:      Sections:
 # MIXED2-NEXT: Idx Name          Size
 # MIXED2-NEXT:   0               00000000
 # MIXED2-NEXT:   1 .nokeep       00000004 00000000000000e8
-# MIXED2-NEXT:   2 .text         00000007 00000000000000ec
-# MIXED2-NEXT:   3 .temp         00000004 00000000000000f3
+# MIXED2-NEXT:   2 .temp         00000004 00000000000000ec
+# MIXED2-NEXT:   3 .text         00000007 00000000000000f0
 # MIXED2-NEXT:   4 .comment      00000008 0000000000000000
 # MIXED2-NEXT:   5 .symtab       00000060 0000000000000000
 # MIXED2-NEXT:   6 .shstrtab     00000038 0000000000000000
 # MIXED2-NEXT:   7 .strtab       00000012 0000000000000000
 
 # Check file pattern for kept sections.
 # RUN: echo "SECTIONS { \
 # RUN:  . = SIZEOF_HEADERS; \

test/ELF/linkerscript/sections-sort.s

 
 nop
 
 .section foo, "a"
 .byte 0
 
 # CHECK: Idx
 # CHECK-NEXT: 0
-# CHECK-NEXT: 1 .dynsym
-# CHECK-NEXT: 2 .dynstr
-# CHECK-NEXT: 3 .text
+# CHECK-NEXT: 1 .text
+# CHECK-NEXT: 2 .dynsym
+# CHECK-NEXT: 3 .dynstr
 # 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.o
 
 # RUN: echo "SECTIONS { foo : {*(foo)} }" > %t.script
 # RUN: ld.lld --hash-style=sysv -o %t --script %t.script %t.o -shared
 # RUN: llvm-readelf -s %t | FileCheck %s
 
 # CHECK:      .dynsym  {{.*}}   A
 # CHECK-NEXT: .dynstr  {{.*}}   A
-# CHECK-NEXT: .text    {{.*}}   AX
 # CHECK-NEXT: .hash    {{.*}}   A
+# CHECK-NEXT: .text    {{.*}}   AX
 # CHECK-NEXT: foo      {{.*}}  WA
 # CHECK-NEXT: .dynamic {{.*}}  WA
 
 .section foo, "aw"
 .byte 0

test/ELF/linkerscript/synthetic-symbols4.test

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/synthetic-symbols.s -o %t.o
 # RUN: ld.lld -o %t --eh-frame-hdr --script %s %t.o
 # RUN: llvm-objdump -t %t | FileCheck %s
 
 SECTIONS {
   . = 0x201000;
   .text : { *(.text) }
   PROVIDE_HIDDEN(_begin_sec = ADDR(.text));
   PROVIDE_HIDDEN(_end_sec = ADDR(.text) + SIZEOF(.text));
 }
 
-# CHECK:       0000000000201000         .text     00000000 .hidden _begin_sec
-# CHECK-NEXT:  0000000000201001         .text     00000000 .hidden _end_sec
+# CHECK:       0000000000201054         .text     00000000 .hidden _begin_sec
+# CHECK-NEXT:  0000000000201055         .text     00000000 .hidden _end_sec

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
+# RUN: llvm-readelf -s %t.so | FileCheck %s
 # CHECK-NOT:  .got
 # CHECK-NOT:  .plt
 # CHECK:      .dynsym
 # CHECK-NEXT: .dynstr
-# CHECK-NEXT: .text
 # CHECK-NEXT: .gnu.hash
+# CHECK:      .text
 
 # 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/linkerscript/va.s

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

test/ELF/mips-gp-ext.s

 # RUN: echo "SECTIONS { \
 # RUN:          .text : { *(.text) } \
 # 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 .reginfo:
+# REL-NEXT:  0040 10000104 00000000 00000000 00000000
+# REL-NEXT:  0050 00000000 000001ec
+#                          ^-- _gp
+
 # REL:      Contents of section .text:
-# REL-NEXT:  0030 3c080000 2108010c 8f82ffcc
+# REL-NEXT:  00e0 3c080000 2108010c 8f82ff1c
 #                 ^-- %hi(_gp_disp)
 #                          ^-- %lo(_gp_disp)
-#                                   ^-- 8 - (0x13c - 0x100)
+#                                   ^-- 8 - (0x1ec - 0x100)
 #                                       G - (GP - .got)
 
-# REL:      Contents of section .reginfo:
-# REL-NEXT:  0058 10000104 00000000 00000000 00000000
-# REL-NEXT:  0068 00000000 0000013c
-#                          ^-- _gp
-
 # REL:      Contents of section .data:
 # REL-NEXT:  00f0 fffffef4
-#                 ^-- 0x30-0x13c
+#                 ^-- 0x30-0x1ec
 #                     foo - GP
 
-# REL: 00000030         .text           00000000 foo
+# REL: 000000e0         .text           00000000 foo
 # REL: 00000000         *ABS*           00000000 .hidden _gp_disp
-# REL: 0000013c         *ABS*           00000000 .hidden _gp
+# REL: 000001ec         *ABS*           00000000 .hidden _gp
+
+# ABS:      Contents of section .reginfo:
+# ABS-NEXT:  0040 10000104 00000000 00000000 00000000
+# ABS-NEXT:  0050 00000000 00000200
+#                          ^-- _gp
 
 # ABS:      Contents of section .text:
-# ABS-NEXT:  0030 3c080000 210801d0 8f82ff08
+# ABS-NEXT:  00e0 3c080000 21080120 8f82ff08
 #                 ^-- %hi(_gp_disp)
 #                          ^-- %lo(_gp_disp)
 #                                   ^-- 8 - (0x200 - 0x100)
 #                                       G - (GP - .got)
 
-# ABS:      Contents of section .reginfo:
-# ABS-NEXT:  0058 10000104 00000000 00000000 00000000
-# ABS-NEXT:  0068 00000000 00000200
-#                          ^-- _gp
-
 # ABS:      Contents of section .data:
-# ABS-NEXT:  00f0 fffffe30
-#                 ^-- 0x30-0x200
+# ABS-NEXT:  00f0 fffffee0
+#                 ^-- 0xe0-0x200
 #                     foo - GP
 
-# ABS: 00000030         .text           00000000 foo
+# ABS: 000000e0         .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/sort-norosegment.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 
 # RUN: ld.lld --hash-style=sysv -no-rosegment -o %t %t.o -shared
 # RUN: llvm-readelf -s %t | FileCheck %s
 
 # CHECK:      .dynsym  {{.*}}   A
 # CHECK-NEXT: .dynstr  {{.*}}   A
-# CHECK-NEXT: .text    {{.*}}   AX
 # CHECK-NEXT: .hash    {{.*}}   A
+# CHECK-NEXT: .text    {{.*}}   AX
 # 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 00000000000000d0 DATA
-# GOT:      10 .got         00000008 00000000000001c0 DATA
+# GOT:      8  .got.plt     00000020 00000000000000e0 DATA
+# GOT:      10 .got         00000008 00000000000001d0 DATA
 # GOTDATA:     Contents of section .got.plt:
-# GOTDATA-NEXT:  00d0 f0000000 00000000 00000000 00000000
-# GOTDATA-NEXT:  00e0 00000000 00000000 c6000000 00000000
+# GOTDATA-NEXT:  00e0 00010000 00000000 00000000 00000000
+# GOTDATA-NEXT:  00f0 00000000 00000000 d6000000 00000000
 # GOTDATA-NEXT: Contents of section .got:
-# GOTDATA-NEXT:  01c0 00000000 00000000
+# GOTDATA-NEXT:  01d0 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 00000000000000d0 DATA
+# MYGOT:      8  .mygot     00000028 00000000000000e0 DATA
 # MYGOT-NOT:  .got
 # MYGOT-NOT:  .got.plt
-# MYGOTDATA:      00d0 00000000 00000000 f8000000 00000000
-# MYGOTDATA-NEXT: 00e0 00000000 00000000 00000000 00000000
-# MYGOTDATA-NEXT: 00f0 c6000000 00000000
+# MYGOTDATA:      00e0 00000000 00000000 08010000 00000000
+# MYGOTDATA-NEXT: 00f0 00000000 00000000 00000000 00000000
+# MYGOTDATA-NEXT: 0100 d6000000 00000000
 
 mov bar@gotpcrel(%rip), %rax
 call foo@plt

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 ea 00 00 00       pushq   234(%rip)
-// CHECK-NEXT: 16:       4c 8b 1d eb 00 00 00    movq    235(%rip), %r11
+// CHECK-NEXT: 10:       ff 35 72 00 00 00       pushq   114(%rip)
+// CHECK-NEXT: 16:       4c 8b 1d 73 00 00 00    movq    115(%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 c9 00 00 00    movq    201(%rip), %r11
+// CHECK-NEXT: 40:       4c 8b 1d 51 00 00 00    movq    81(%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 b1 00 00 00    movq    177(%rip), %r11
+// CHECK-NEXT: 60:       4c 8b 1d 39 00 00 00    movq    57(%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 a9 00 00 00  movq  169(%rip), %r11
+// CHECK-NEXT: 30:  4c 8b 1d 31 00 00 00  movq  49(%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 a1 00 00 00  movq  161(%rip), %r11
+// CHECK-NEXT: 40:      4c 8b 1d 29 00 00 00  movq  41(%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