[llvm-objdump] Use <first-symbol>-<offset> as the section start symbol

[ychen]

Summary

provided that later symbol exists. If not, use section name.

https://bugs.llvm.org/show_bug.cgi?id=41946

[ychen]

• update

[MaskRay]

In the context of PR41946:

Disassembly of section .text:

0000000000001000 .text:
    1000: 90                            nop

I agree that 0000000000001000 .text: is not useful as it repeats what Disassembly of section .text: says. However, in the bar@plt-0x10 case (when the PLT resolver stub doesn't get a symbol name), I'm not sure this improves readability.

[ychen]

In D63280#1542919, @MaskRay wrote:

In the context of PR41946:

Disassembly of section .text:

0000000000001000 .text:
    1000: 90                            nop

I agree that 0000000000001000 .text: is not useful as it repeats what Disassembly of section .text: says. However, in the bar@plt-0x10 case (when the PLT resolver stub doesn't get a symbol name), I'm not sure this improves readability.

I agree it is not very readable but it matches GNU output.

[MaskRay]

In D63280#1542922, @ychen wrote:

In D63280#1542919, @MaskRay wrote:

In the context of PR41946:

Disassembly of section .text:

0000000000001000 .text:
    1000: 90                            nop

I agree that 0000000000001000 .text: is not useful as it repeats what Disassembly of section .text: says. However, in the bar@plt-0x10 case (when the PLT resolver stub doesn't get a symbol name), I'm not sure this improves readability.

I agree it is not very readable but it matches GNU output.

I know this what GNU objdump does:) While working on lld's ppc32/riscv .plt support recently, I constantly see the annoying __libc_start_main@plt-0x20 as a branch target. Compatibility is important, for people who use llvm-objdump as a drop-in replacement of GNU objectdump. However, in some places, where there are several ways to do a thing (e.g. how to render .plt), I believe we do not necessarily copy its behavior if we can find better ways.

Having said this, .plt looking better than blah@plt-0x20 is my opinion. Other reviewers may have different ideas. I don't mind changing it to blah@plt-0x20 if the majority of reviewers agree so.

[ychen]

In D63280#1542942, @MaskRay wrote:

In D63280#1542922, @ychen wrote:

In D63280#1542919, @MaskRay wrote:

In the context of PR41946:

Disassembly of section .text:

0000000000001000 .text:
    1000: 90                            nop

I agree that 0000000000001000 .text: is not useful as it repeats what Disassembly of section .text: says. However, in the bar@plt-0x10 case (when the PLT resolver stub doesn't get a symbol name), I'm not sure this improves readability.

I agree it is not very readable but it matches GNU output.

I know this what GNU objdump does:) While working on lld's ppc32/riscv .plt support recently, I constantly see the annoying __libc_start_main@plt-0x20 as a branch target. Compatibility is important, for people who use llvm-objdump as a drop-in replacement of GNU objectdump. However, in some places, where there are several ways to do a thing (e.g. how to render .plt), I believe we do not necessarily copy its behavior if we can find better ways.

Having said this, .plt looking better than blah@plt-0x20 is my opinion. Other reviewers may have different ideas. I don't mind changing it to blah@plt-0x20 if the majority of reviewers agree so.

.plt definitely looks better for the case. I don't have a strong opinion for each. Looks like it is (consistency+compatibility-with-GNU vs readability). I'm slightly in favor of consistency as a light user of binary tools.

[grimar]

llvm/tools/llvm-objdump/llvm-objdump.cpp

1195–1196

Does the following look simpler?

if (Symbols.empty()) {
  Symbols.push_back({SectionAddr, SectionName,
                     Section.isText() ? ELF::STT_FUNC : ELF::STT_OBJECT});
} else {
  uint64_t Addr = std::get<0>(Symbols[0]);
  if (Addr != SectionAddr) {
    std::string Sym = Demangle ? demangle(std::get<1>(Symbols[0]))
                               : std::get<1>(Symbols[0]);
    Symbols.insert(Symbols.begin(),
                   {SectionAddr,
                    Sym + "-0x" + utohexstr(Addr - SectionAddr),
                    Section.isText() ? ELF::STT_FUNC : ELF::STT_OBJECT});
  }
}

1195–1196

The comment need an update.

[ychen]

• address comments
• add a few missing tests that need fixup

[MaskRay]

lld/test/ELF/ppc-relocs.s

45 ↗

(On Diff #204791)

This is another example that demonstrates <section-offset> may not be aesthetically appealing.

[jhenderson]

I absolutely agree with @MaskRay that the GNU format is less than ideal, but the overwhelming feedback at last year's BoF on the topic was that we should match the output of GNU unless the output was wrong. If it were up to me, I'd just omit the reference entirely in these instances, since they don't really add any value!

Maybe this is another indication that we need separate GNU and LLVM styles for llvm-objdump, similar to llvm-readobj/llvm-readelf?

llvm/test/MC/AMDGPU/branch-comment.s

13

This one is particularly concerning. Does this case match GNU? I'd expect it to fold the two sums together (i.e. keep_symbol-0x4)

llvm/test/tools/llvm-objdump/X86/elf-disassemble-no-start-symbol.test

3

Nit: missing trailing full stop. It might be wise to quote the bit after "with the name".

llvm/tools/llvm-objdump/llvm-objdump.cpp

1196

if later -> if a later

[ychen]

• Add the code and test to show that the dummy section start symbol should not be used to resolve branch target in disassembly.
• Update test and some comments.

[ychen]

llvm/test/MC/AMDGPU/branch-comment.s

13

Thanks for pointing this out. GNU objdump does not use the dummy start symbol for branch target resolving (folding). Code updated. Added a test case for this llvm/test/MC/X86/branch-comment.s.

[ychen]

• add comment

[jhenderson]

llvm/tools/llvm-objdump/llvm-objdump.cpp

1403

This check is rather horrid, if I'm honest, for all sorts of reasons (apart from anything else, ELF places no restrictions on symbol names so a valid symbol name could actually contain "-0x").

I think you need a different way of identifying these inserted symbols (assuming that it's not possible to just change when they are inserted). You might need a list of sections that have had symbols inserted, for example.

[ychen]

• - perform start symbols insertion before disassembling

[ychen]

llvm/tools/llvm-objdump/llvm-objdump.cpp

1403

This check is rather horrid, if I'm honest, for all sorts of reasons (apart from anything else, ELF places no restrictions on symbol names so a valid symbol name could actually contain "-0x").

It is horrible. I was assuming the low chance of an ELF name having "-0x" before this start symbol insertion, but it is still legitimate.

I think you need a different way of identifying these inserted symbols (assuming that it's not possible to just change when they are inserted).

Yes, the insertion is just before disassembling so it could happen earlier but not later.

You might need a list of sections that have had symbols inserted, for example.

Did exactly this. I think it does the right thing.

[ychen]

• update

[MaskRay]

riscv-objdump appears to use STT_SECTION symbols to symbolize addresses, e.g.:

Disassembly of section .plt:

000027d0 <.plt>:
    27d0:       00011397                auipc   t2,0x11

x86-64 and some other may not. I need to dig into the details. I also filed a binutils-gdb bug about this https://sourceware.org/bugzilla/show_bug.cgi?id=24702

[ychen]

In D63280#1549635, @MaskRay wrote:

riscv-objdump appears to use STT_SECTION symbols to symbolize addresses, e.g.:

Disassembly of section .plt:

000027d0 <.plt>:
    27d0:       00011397                auipc   t2,0x11

x86-64 and some other may not. I need to dig into the details. I also filed a binutils-gdb bug about this https://sourceware.org/bugzilla/show_bug.cgi?id=24702

Thanks. That's great to know! Once it is confirmed from GNU side, I will update the patch to reflect that.

[jhenderson]

llvm/tools/llvm-objdump/llvm-objdump.cpp

348

It's not clear from the function name what this function is supposed to be doing. Please at least add a comment, and also consider renaming the function. Perhaps shouldKeepForDisassembly?

1126

Perhaps worth calling this StartProxySymbols (or just ProxySymbols), since they aren't real symbols.

[ychen]

• update

[jhenderson]

Okay, LGTM, but @MaskRay probably should confirm he's happy enough for now (we can improve the STT_SECTION bit later, if we want).

llvm/tools/llvm-objdump/llvm-objdump.cpp

348

disassemble -> disassembly

[MaskRay]

Sorry for doing this. It is very late in my timezone, but I think I have to mark it as "Request Changes" as I saw it accepted and I really don't want it to be committed...

If you all agree bar2@plt-0x20 is less ideal and our .plt is better, I'm not sure why you want to copy the behavior of GNU objdump. I believe this belongs to the aesthetical area where 100% compatibility is not necessary. Programs/shell scripts parsing <bar@plt-0x20> should be extremely brittle and they should be avoided. If the programs need addresses, they should just parse the address part, not the stuff in angle quotes.

I have found someone who agrees with me that firstsym-x is awful and the behavior should not be replicated. Let me check if I can get more opinions tomorrow.

[ychen]

In D63280#1552108, @MaskRay wrote:

Sorry for doing this. It is very late in my timezone, but I think I have to mark it as "Request Changes" as I saw it accepted and I really don't want it to be committed...

If you all agree bar2@plt-0x20 is less ideal and our .plt is better, I'm not sure why you want to copy the behavior of GNU objdump. I believe this belongs to the aesthetical area where 100% compatibility is not necessary. Programs/shell scripts parsing <bar@plt-0x20> should be extremely brittle and they should be avoided. If the programs need addresses, they should just parse the address part, not the stuff in angle quotes.

I have found someone who agrees with me that firstsym-x is awful and the behavior should not be replicated. Let me check if I can get more opinions tomorrow.

I think the basis of this patch to have a consistent output as GNU objdump so it is easier for existing GNU users migrate to llvm binutils. Your proposal is definitely an improvement in the functionality of the tool but probably less ideal for the migration?

Like @jhenderson suggested, I assume it does not sacrifice anything if we land this first, then revisit the issue later when GNU make the change also? This makes sure we are always consistent with GNU.

[MaskRay]

Like @jhenderson suggested, I assume it does not sacrifice anything if we land this first, then revisit the issue later when GNU make the change also? This makes sure we are always consistent with GNU.

As I said, I don't know in what scenarios existing GNU objdump users cannot migrate to llvm-objdump just because of this incompatibility.

I am against the very idea of symbolizing an address with <firstsym - offset>. We all agree it is less ideal than <.section>, then I am not sure how this issue can be improved in the future. This patch would just create unnecessary churn if we later decide to change them back to .plt

- // DISASM-NEXT: 0000000000201020 .plt:
+ // DISASM-NEXT: 0000000000201020 bar2@plt-0x10:

May I ask you to start a thread on https://lists.llvm.org/pipermail/llvm-dev/2019-June to discuss this?

[jhenderson]

May I ask you to start a thread on https://lists.llvm.org/pipermail/llvm-dev/2019-June to discuss this?

I agree that this needs a wider audience. @ychen, could you go ahead and start that email, please. Feel free to run a draft by me first if you want.

[peter.smith]

In D63280#1553187, @jhenderson wrote:

May I ask you to start a thread on https://lists.llvm.org/pipermail/llvm-dev/2019-June to discuss this?

I agree that this needs a wider audience. @ychen, could you go ahead and start that email, please. Feel free to run a draft by me first if you want.

I'll make sure I comment on the list when the email thread starts. Some more data points for you from some gcc 8 toolchains. Arm and AArch64 use <.plt> in the same way as RiscV does. I would prefer this change not to be made for Arm and AArch64. There often can be a lot of target specific decisions made in binutils, we may find that there is little consistency in disassembly across targets.

aarch64-linux-gnu-objdump -d libgomp.so

Disassembly of section .plt:

0000000000007700 <.plt>:
    7700:       a9bf7bf0        stp     x16, x30, [sp, #-16]!
    7704:       f0000190        adrp    x16, 3a000 <__FRAME_END__+0xf3a4>
    7708:       f947fe11        ldr     x17, [x16, #4088]
    770c:       913fe210        add     x16, x16, #0xff8
    7710:       d61f0220        br      x17
    7714:       d503201f        nop
    7718:       d503201f        nop
    771c:       d503201f        nop

0000000000007720 <memcpy@plt>:
    7720:       900001b0        adrp    x16, 3b000 <memcpy@GLIBC_2.17>
    7724:       f9400211        ldr     x17, [x16]
    7728:       91000210        add     x16, x16, #0x0
    772c:       d61f0220        br      x17

arm-linux-gnueabihf-objdump -d libgomp.so

Disassembly of section .plt:

0000602c <.plt>:
    602c:       e52de004        push    {lr}            ; (str lr, [sp, #-4]!)
    6030:       e59fe004        ldr     lr, [pc, #4]    ; 603c <.plt+0x10>
    6034:       e08fe00e        add     lr, pc, lr
    6038:       e5bef008        ldr     pc, [lr, #8]!
    603c:       00030fc4        .word   0x00030fc4

00006040 <calloc@plt>:
    6040:       e28fc600        add     ip, pc, #0, 12
    6044:       e28cca30        add     ip, ip, #48, 20 ; 0x30000
    6048:       e5bcffc4        ldr     pc, [ip, #4036]!        ; 0xfc4

[jhenderson]

@MaskRay, @peter.smith, is it just the PLT that is specially handled? Perhaps we could just special-case that in llvm-objdump? I think there's clear precedence for this for other versions of objdump, so I'm okay with that difference in behaviour.

It seems to me like other cases of this syntax appearing are going to be very rare overall.

[peter.smith]

In D63280#1553221, @jhenderson wrote:

@MaskRay, @peter.smith, is it just the PLT that is specially handled? Perhaps we could just special-case that in llvm-objdump? I think there's clear precedence for this for other versions of objdump, so I'm okay with that difference in behaviour.

It seems to me like other cases of this syntax appearing are going to be very rare overall.

From a cursory scan https://github.com/bminor/binutils-gdb/blob/master/binutils/objdump.c#L749 it looks like the .plt and .got are treated specially by objdump and can remain candidates for disassembly. I agree that it is likely to be linker generated content such as .plt sections that are likely to not have a code symbol at address 0.

[ychen]

@MaskRay @jhenderson @peter.smith Thank you for the comments. I'll start a thread to collect more opinions.

[ychen]

To help writing up the discussion thread, I'm trying to gather some data on how each target handle the case with GNU objdump. Weird that I could not reproduce the results @MaskRay @peter.smith was able to obtain. This is not to show favor for either choice but to understand the current situation on GNU side so we make a sensible decision.

➜  Bld lsb_release -a
No LSB modules are available.
Distributor ID: Ubuntu
Description:    Ubuntu 18.04.2 LTS
Release:        18.04
Codename:       bionic

risc-v

➜  Bld /usr/riscv64-linux-gnu/bin/objdump --version
GNU objdump (GNU Binutils for Ubuntu) 2.30
Copyright (C) 2018 Free Software Foundation, Inc.
This program is free software; you may redistribute it under the terms of
the GNU General Public License version 3 or (at your option) any later version.
This program has absolutely no warranty.
➜  Bld file /usr/riscv64-linux-gnu/lib/libgomp.so.1.0.0
/usr/riscv64-linux-gnu/lib/libgomp.so.1.0.0: ELF 64-bit LSB shared object, UCB RISC-V, version 1 (SYSV), dynamically linked, BuildID[sha1]=5af4a2eff63e94f36b40ad145b1c281908cfe8f9, stripped
➜  Bld /usr/riscv64-linux-gnu/bin/objdump -d /usr/riscv64-linux-gnu/lib/libgomp.so.1.0.0 | head -n 20

/usr/riscv64-linux-gnu/lib/libgomp.so.1.0.0:     file format elf64-littleriscv


Disassembly of section .plt:

0000000000006dc0 <pthread_attr_setdetachstate@plt-0x20>:
    6dc0:       00016397                auipc   t2,0x16
    6dc4:       41c30333                sub     t1,t1,t3
    6dc8:       4203be03                ld      t3,1056(t2) # 1d1e0 <acc_is_present_array_h_@@OACC_2.0+0x3046>
    6dcc:       fd430313                addi    t1,t1,-44
    6dd0:       42038293                addi    t0,t2,1056
    6dd4:       00135313                srli    t1,t1,0x1
    6dd8:       0082b283                ld      t0,8(t0)
    6ddc:       000e0067                jr      t3

0000000000006de0 <pthread_attr_setdetachstate@plt>:
    6de0:       00016e17                auipc   t3,0x16
    6de4:       410e3e03                ld      t3,1040(t3) # 1d1f0 <pthread_attr_setdetachstate@GLIBC_2.27>
    6de8:       000e0367                jalr    t1,t3

aarch64

➜  Bld /usr/aarch64-linux-gnu/bin/objdump --version
GNU objdump (GNU Binutils for Ubuntu) 2.30
Copyright (C) 2018 Free Software Foundation, Inc.
This program is free software; you may redistribute it under the terms of
the GNU General Public License version 3 or (at your option) any later version.
This program has absolutely no warranty.
➜  Bld file /usr/aarch64-linux-gnu/lib/libgomp.so.1.0.0
/usr/aarch64-linux-gnu/lib/libgomp.so.1.0.0: ELF 64-bit LSB shared object, ARM aarch64, version 1 (SYSV), dynamically linked, BuildID[sha1]=1106de22dfcbfbef7445bbcbe38479bcec8b8780, stripped
➜  Bld /usr/aarch64-linux-gnu/bin/objdump -d /usr/aarch64-linux-gnu/lib/libgomp.so.1.0.0 | head -n 30

/usr/aarch64-linux-gnu/lib/libgomp.so.1.0.0:     file format elf64-littleaarch64


Disassembly of section .init:

0000000000006db8 <.init>:
    6db8:       a9bf7bfd        stp     x29, x30, [sp, #-16]!
    6dbc:       910003fd        mov     x29, sp
    6dc0:       94000a77        bl      979c <acc_async_test_all@plt+0x246c>
    6dc4:       a8c17bfd        ldp     x29, x30, [sp], #16
    6dc8:       d65f03c0        ret

Disassembly of section .plt:

0000000000006dd0 <memcpy@plt-0x20>:
    6dd0:       a9bf7bf0        stp     x16, x30, [sp, #-16]!
    6dd4:       b00001b0        adrp    x16, 3b000 <acc_is_present_array_h_@@OACC_2.0+0x17a3c>
    6dd8:       f947fe11        ldr     x17, [x16, #4088]
    6ddc:       913fe210        add     x16, x16, #0xff8
    6de0:       d61f0220        br      x17
    6de4:       d503201f        nop
    6de8:       d503201f        nop
    6dec:       d503201f        nop

0000000000006df0 <memcpy@plt>:
    6df0:       d00001b0        adrp    x16, 3c000 <memcpy@GLIBC_2.17>
    6df4:       f9400211        ldr     x17, [x16]
    6df8:       91000210        add     x16, x16, #0x0
    6dfc:       d61f0220        br      x17

Test with GNU bintutils master branch just in case:

➜  Bld ~/Src/binutils-bld/binutils/objdump -d /usr/riscv64-linux-gnu/lib/libgomp.so.1.0.0 | head -n 20

/usr/riscv64-linux-gnu/lib/libgomp.so.1.0.0:     file format elf64-littleriscv


Disassembly of section .plt:

0000000000006dc0 <pthread_attr_setdetachstate@plt-0x20>:
    6dc0:       00016397                auipc   t2,0x16
    6dc4:       41c30333                sub     t1,t1,t3
    6dc8:       4203be03                ld      t3,1056(t2) # 1d1e0 <acc_is_present_array_h_@@OACC_2.0+0x3046>
    6dcc:       fd430313                addi    t1,t1,-44
    6dd0:       42038293                addi    t0,t2,1056
    6dd4:       00135313                srli    t1,t1,0x1
    6dd8:       0082b283                ld      t0,8(t0)
    6ddc:       000e0067                jr      t3

0000000000006de0 <pthread_attr_setdetachstate@plt>:
    6de0:       00016e17                auipc   t3,0x16
    6de4:       410e3e03                ld      t3,1040(t3) # 1d1f0 <pthread_attr_setdetachstate@GLIBC_2.27>
    6de8:       000e0367                jalr    t1,t3


➜  Bld ~/Src/binutils-bld/binutils/objdump -d /usr/aarch64-linux-gnu/lib/libgomp.so.1.0.0 | head -n 30

/usr/aarch64-linux-gnu/lib/libgomp.so.1.0.0:     file format elf64-littleaarch64


Disassembly of section .init:

0000000000006db8 <.init>:
    6db8:       a9bf7bfd        stp     x29, x30, [sp, #-16]!
    6dbc:       910003fd        mov     x29, sp
    6dc0:       94000a77        bl      979c <acc_async_test_all@plt+0x246c>
    6dc4:       a8c17bfd        ldp     x29, x30, [sp], #16
    6dc8:       d65f03c0        ret

Disassembly of section .plt:

0000000000006dd0 <memcpy@plt-0x20>:
    6dd0:       a9bf7bf0        stp     x16, x30, [sp, #-16]!
    6dd4:       b00001b0        adrp    x16, 3b000 <acc_is_present_array_h_@@OACC_2.0+0x17a3c>
    6dd8:       f947fe11        ldr     x17, [x16, #4088]
    6ddc:       913fe210        add     x16, x16, #0xff8
    6de0:       d61f0220        br      x17
    6de4:       d503201f        nop
    6de8:       d503201f        nop
    6dec:       d503201f        nop

0000000000006df0 <memcpy@plt>:
    6df0:       d00001b0        adrp    x16, 3c000 <memcpy@GLIBC_2.17>
    6df4:       f9400211        ldr     x17, [x16]
    6df8:       91000210        add     x16, x16, #0x0
    6dfc:       d61f0220        br      x17

[peter.smith]

In D63280#1554470, @ychen wrote:

To help writing up the discussion thread, I'm trying to gather some data on how each target handle the case with GNU objdump. Weird that I could not reproduce the results @MaskRay @peter.smith was able to obtain. This is not to show favor for either choice but to understand the current situation on GNU side so we make a sensible decision.

It looks like there was a fairly recent change in binutils, my version was 2.32. An older version I happen to have lying around 2.25, seems to match the behaviour you are seeing. If I had to guess I'd say it was this change in binutils: https://sourceware.org/bugzilla/show_bug.cgi?id=22911

➜  Bld lsb_release -a
No LSB modules are available.
Distributor ID: Ubuntu
Description:    Ubuntu 18.04.2 LTS
Release:        18.04
Codename:       bionic

risc-v

➜  Bld /usr/riscv64-linux-gnu/bin/objdump --version
GNU objdump (GNU Binutils for Ubuntu) 2.30
Copyright (C) 2018 Free Software Foundation, Inc.
This program is free software; you may redistribute it under the terms of
the GNU General Public License version 3 or (at your option) any later version.
This program has absolutely no warranty.
➜  Bld file /usr/riscv64-linux-gnu/lib/libgomp.so.1.0.0
/usr/riscv64-linux-gnu/lib/libgomp.so.1.0.0: ELF 64-bit LSB shared object, UCB RISC-V, version 1 (SYSV), dynamically linked, BuildID[sha1]=5af4a2eff63e94f36b40ad145b1c281908cfe8f9, stripped
➜  Bld /usr/riscv64-linux-gnu/bin/objdump -d /usr/riscv64-linux-gnu/lib/libgomp.so.1.0.0 | head -n 20

/usr/riscv64-linux-gnu/lib/libgomp.so.1.0.0:     file format elf64-littleriscv


Disassembly of section .plt:

0000000000006dc0 <pthread_attr_setdetachstate@plt-0x20>:
    6dc0:       00016397                auipc   t2,0x16
    6dc4:       41c30333                sub     t1,t1,t3
    6dc8:       4203be03                ld      t3,1056(t2) # 1d1e0 <acc_is_present_array_h_@@OACC_2.0+0x3046>
    6dcc:       fd430313                addi    t1,t1,-44
    6dd0:       42038293                addi    t0,t2,1056
    6dd4:       00135313                srli    t1,t1,0x1
    6dd8:       0082b283                ld      t0,8(t0)
    6ddc:       000e0067                jr      t3

0000000000006de0 <pthread_attr_setdetachstate@plt>:
    6de0:       00016e17                auipc   t3,0x16
    6de4:       410e3e03                ld      t3,1040(t3) # 1d1f0 <pthread_attr_setdetachstate@GLIBC_2.27>
    6de8:       000e0367                jalr    t1,t3

aarch64

➜  Bld /usr/aarch64-linux-gnu/bin/objdump --version
GNU objdump (GNU Binutils for Ubuntu) 2.30
Copyright (C) 2018 Free Software Foundation, Inc.
This program is free software; you may redistribute it under the terms of
the GNU General Public License version 3 or (at your option) any later version.
This program has absolutely no warranty.
➜  Bld file /usr/aarch64-linux-gnu/lib/libgomp.so.1.0.0
/usr/aarch64-linux-gnu/lib/libgomp.so.1.0.0: ELF 64-bit LSB shared object, ARM aarch64, version 1 (SYSV), dynamically linked, BuildID[sha1]=1106de22dfcbfbef7445bbcbe38479bcec8b8780, stripped
➜  Bld /usr/aarch64-linux-gnu/bin/objdump -d /usr/aarch64-linux-gnu/lib/libgomp.so.1.0.0 | head -n 30

/usr/aarch64-linux-gnu/lib/libgomp.so.1.0.0:     file format elf64-littleaarch64


Disassembly of section .init:

0000000000006db8 <.init>:
    6db8:       a9bf7bfd        stp     x29, x30, [sp, #-16]!
    6dbc:       910003fd        mov     x29, sp
    6dc0:       94000a77        bl      979c <acc_async_test_all@plt+0x246c>
    6dc4:       a8c17bfd        ldp     x29, x30, [sp], #16
    6dc8:       d65f03c0        ret

Disassembly of section .plt:

0000000000006dd0 <memcpy@plt-0x20>:
    6dd0:       a9bf7bf0        stp     x16, x30, [sp, #-16]!
    6dd4:       b00001b0        adrp    x16, 3b000 <acc_is_present_array_h_@@OACC_2.0+0x17a3c>
    6dd8:       f947fe11        ldr     x17, [x16, #4088]
    6ddc:       913fe210        add     x16, x16, #0xff8
    6de0:       d61f0220        br      x17
    6de4:       d503201f        nop
    6de8:       d503201f        nop
    6dec:       d503201f        nop

0000000000006df0 <memcpy@plt>:
    6df0:       d00001b0        adrp    x16, 3c000 <memcpy@GLIBC_2.17>
    6df4:       f9400211        ldr     x17, [x16]
    6df8:       91000210        add     x16, x16, #0x0
    6dfc:       d61f0220        br      x17

Test with GNU bintutils master branch just in case:

➜  Bld ~/Src/binutils-bld/binutils/objdump -d /usr/riscv64-linux-gnu/lib/libgomp.so.1.0.0 | head -n 20

/usr/riscv64-linux-gnu/lib/libgomp.so.1.0.0:     file format elf64-littleriscv


Disassembly of section .plt:

0000000000006dc0 <pthread_attr_setdetachstate@plt-0x20>:
    6dc0:       00016397                auipc   t2,0x16
    6dc4:       41c30333                sub     t1,t1,t3
    6dc8:       4203be03                ld      t3,1056(t2) # 1d1e0 <acc_is_present_array_h_@@OACC_2.0+0x3046>
    6dcc:       fd430313                addi    t1,t1,-44
    6dd0:       42038293                addi    t0,t2,1056
    6dd4:       00135313                srli    t1,t1,0x1
    6dd8:       0082b283                ld      t0,8(t0)
    6ddc:       000e0067                jr      t3

0000000000006de0 <pthread_attr_setdetachstate@plt>:
    6de0:       00016e17                auipc   t3,0x16
    6de4:       410e3e03                ld      t3,1040(t3) # 1d1f0 <pthread_attr_setdetachstate@GLIBC_2.27>
    6de8:       000e0367                jalr    t1,t3


➜  Bld ~/Src/binutils-bld/binutils/objdump -d /usr/aarch64-linux-gnu/lib/libgomp.so.1.0.0 | head -n 30

/usr/aarch64-linux-gnu/lib/libgomp.so.1.0.0:     file format elf64-littleaarch64


Disassembly of section .init:

0000000000006db8 <.init>:
    6db8:       a9bf7bfd        stp     x29, x30, [sp, #-16]!
    6dbc:       910003fd        mov     x29, sp
    6dc0:       94000a77        bl      979c <acc_async_test_all@plt+0x246c>
    6dc4:       a8c17bfd        ldp     x29, x30, [sp], #16
    6dc8:       d65f03c0        ret

Disassembly of section .plt:

0000000000006dd0 <memcpy@plt-0x20>:
    6dd0:       a9bf7bf0        stp     x16, x30, [sp, #-16]!
    6dd4:       b00001b0        adrp    x16, 3b000 <acc_is_present_array_h_@@OACC_2.0+0x17a3c>
    6dd8:       f947fe11        ldr     x17, [x16, #4088]
    6ddc:       913fe210        add     x16, x16, #0xff8
    6de0:       d61f0220        br      x17
    6de4:       d503201f        nop
    6de8:       d503201f        nop
    6dec:       d503201f        nop

0000000000006df0 <memcpy@plt>:
    6df0:       d00001b0        adrp    x16, 3c000 <memcpy@GLIBC_2.17>
    6df4:       f9400211        ldr     x17, [x16]
    6df8:       91000210        add     x16, x16, #0x0
    6dfc:       d61f0220        br      x17

[jimw]

This one had me confused for a while, but after a bit of experimenting I figured out that the problem is strip.

hifiveu017:1075$ cat tmp.c
extern int sub2 (void);
int sub (void) { return sub2 (); }
hifiveu017:1076$ gcc --shared -fpic -O -o tmp.so tmp.c
hifiveu017:1077$ objdump -d tmp.so | head

tmp.so: file format elf64-littleriscv

Disassembly of section .plt:

00000000000003d0 <.plt>:
3d0: 00002397 auipc t2,0x2
3d4: 41c30333 sub t1,t1,t3
3d8: c303be03 ld t3,-976(t2) # 2000 <TMC_END>
hifiveu017:1078$ strip tmp.so
hifiveu017:1079$ objdump -d tmp.so | head

tmp.so: file format elf64-littleriscv

Disassembly of section .plt:

00000000000003d0 <sub2@plt-0x20>:
3d0: 00002397 auipc t2,0x2
3d4: 41c30333 sub t1,t1,t3
3d8: c303be03 ld t3,-976(t2) # 2000 <sub@@Base+0x1b6e>
hifiveu017:1080$

MaskRay is looking at system libraries which have all been stripped. I've been looking at libraries built as part of the toolchain build, which are not stripped. The difference between the stripped and unstripped file is that the unstripped file has a section symbol for each section. Readelf --syms shows it as

9: 00000000000003d0     0 SECTION LOCAL  DEFAULT    9

and nm shows it as
00000000000003d0 l d .plt 0000000000000000 .plt
The stripped file doesn't have the section symbols.

Objdump always uses the nearest symbol, so if you have the section symbols, then the output starts with that symbol name. This was mentioned near the top, when discussing
Disassembly of section .text:
0000000000001000 .text:
The first .text is the section, the second one is the section symbol. And that section symbol disappears when you strip the file, if it isn't needed by something else like a dynamic reloc.

So the issue here is that the objdump output is a little confusing when run on stripped files. I don't think that is a bug. If you want good objdump output, don't strip the files.

There is a secondary issue that the first plt in the plt section does not have a symbol of its own, and certainly not one that will survive strip, but I don't think that is a bug either.

Perhaps objdump could be extended to create synthetic section symbols if they don't exist, to get better output for stripped files, but that would be an enhancement not a bug fix.

lld/test/ELF/aarch64-condb-reloc.s

 #DSO-NEXT:     10020: {{.*}} nop
 #DSO:      _start:
 #DSO-NEXT:     10024: {{.*}} b.eq #44
 #DSO-NEXT:     10028: {{.*}} b.eq #56
 #DSO-NEXT:     1002c: {{.*}} b.eq #68
 #DSO-EMPTY:
 #DSO-NEXT: Disassembly of section .plt:
 #DSO-EMPTY:
-#DSO-NEXT: .plt:
+#DSO-NEXT:   _foo@plt-0x20:
 #DSO-NEXT:     10030: {{.*}} stp x16, x30, [sp, #-16]!
 #DSO-NEXT:     10034: {{.*}} adrp x16, #131072
 #DSO-NEXT:     10038: {{.*}} ldr x17, [x16, #16]
 #DSO-NEXT:     1003c: {{.*}} add x16, x16, #16
 #DSO-NEXT:     10040: {{.*}} br x17
 #DSO-NEXT:     10044: {{.*}} nop
 #DSO-NEXT:     10048: {{.*}} nop
 #DSO-NEXT:     1004c: {{.*}} nop

lld/test/ELF/aarch64-feature-bti.s

 
 # NOBTIDYN-NOT:   0x0000000070000001 (AARCH64_BTI_PLT)
 # NOBTIDYN-NOT:   0x0000000070000003 (AARCH64_PAC_PLT)
 
 # NOBTI: 0000000000010000 func2:
 # NOBTI-NEXT:    10000: bl      #48 <func3@plt>
 # NOBTI-NEXT:    10004: ret
 # NOBTI: Disassembly of section .plt:
-# NOBTI: 0000000000010010 .plt:
+# NOBTI: 0000000000010010 func3@plt-0x20:
 # NOBTI-NEXT:    10010: stp     x16, x30, [sp, #-16]!
 # NOBTI-NEXT:    10014: adrp    x16, #131072
 # NOBTI-NEXT:    10018: ldr     x17, [x16, #16]
 # NOBTI-NEXT:    1001c: add     x16, x16, #16
 # NOBTI-NEXT:    10020: br      x17
 # NOBTI-NEXT:    10024: nop
 # NOBTI-NEXT:    10028: nop
 # NOBTI-NEXT:    1002c: nop

 
 # BTIDYN:      0x0000000070000001 (AARCH64_BTI_PLT)
 # BTIDYN-NOT:  0x0000000070000003 (AARCH64_PAC_PLT)
 
 # BTISO: 0000000000010000 func2:
 # BTISO-NEXT:    10000: bl      #48 <func3@plt>
 # BTISO-NEXT:    10004: ret
 # BTISO: Disassembly of section .plt:
-# BTISO: 0000000000010010 .plt:
+# BTISO: 0000000000010010 func3@plt-0x20:
 # BTISO-NEXT:    10010: bti     c
 # BTISO-NEXT:    10014: stp     x16, x30, [sp, #-16]!
 # BTISO-NEXT:    10018: adrp    x16, #131072
 # BTISO-NEXT:    1001c: ldr     x17, [x16, #16]
 # BTISO-NEXT:    10020: add     x16, x16, #16
 # BTISO-NEXT:    10024: br      x17
 # BTISO-NEXT:    10028: nop
 # BTISO-NEXT:    1002c: nop

 # RUN: llvm-readelf --dynamic-table -n %t.exe | FileCheck --check-prefix=BTIPROP %s
 # RUN: llvm-objdump -d -mattr=+bti --no-show-raw-insn %t.exe | FileCheck --check-prefix=EXECBTI %s
 
 # EXECBTI: Disassembly of section .text:
 # EXECBTI: 0000000000210000 func1:
 # EXECBTI-NEXT:   210000: bl      #48 <func2@plt>
 # EXECBTI-NEXT:   210004: ret
 # EXECBTI: Disassembly of section .plt:
-# EXECBTI: 0000000000210010 .plt:
+# EXECBTI: 0000000000210010 func2@plt-0x20:
 # EXECBTI-NEXT:   210010: bti     c
 # EXECBTI-NEXT:   210014: stp     x16, x30, [sp, #-16]!
 # EXECBTI-NEXT:   210018: adrp    x16, #131072
 # EXECBTI-NEXT:   21001c: ldr     x17, [x16, #16]
 # EXECBTI-NEXT:   210020: add     x16, x16, #16
 # EXECBTI-NEXT:   210024: br      x17
 # EXECBTI-NEXT:   210028: nop
 # EXECBTI-NEXT:   21002c: nop

 # RUN: llvm-readelf --dynamic-table -n %tpie.exe | FileCheck --check-prefix=BTIPROP %s
 # RUN: llvm-objdump -d -mattr=+bti --no-show-raw-insn %tpie.exe | FileCheck --check-prefix=PIE %s
 
 # PIE: Disassembly of section .text:
 # PIE: 0000000000010000 func1:
 # PIE-NEXT:    10000: bl      #48 <func2@plt>
 # PIE-NEXT:    10004: ret
 # PIE: Disassembly of section .plt:
-# PIE: 0000000000010010 .plt:
+# PIE: 0000000000010010 func2@plt-0x20:
 # PIE-NEXT:    10010: bti     c
 # PIE-NEXT:    10014: stp     x16, x30, [sp, #-16]!
 # PIE-NEXT:    10018: adrp    x16, #131072
 # PIE-NEXT:    1001c: ldr     x17, [x16, #16]
 # PIE-NEXT:    10020: add     x16, x16, #16
 # PIE-NEXT:    10024: br      x17
 # PIE-NEXT:    10028: nop
 # PIE-NEXT:    1002c: nop

 
 # NOEX: Disassembly of section .text:
 # NOEX: 0000000000210000 func1:
 # NOEX-NEXT:   210000: bl      #48 <func2@plt>
 # NOEX-NEXT:   210004: ret
 # NOEX: 0000000000210008 func3:
 # NOEX-NEXT:   210008: ret
 # NOEX: Disassembly of section .plt:
-# NOEX: 0000000000210010 .plt:
+# NOEX: 0000000000210010 func2@plt-0x20:
 # NOEX-NEXT:   210010: stp     x16, x30, [sp, #-16]!
 # NOEX-NEXT:   210014: adrp    x16, #131072
 # NOEX-NEXT:   210018: ldr     x17, [x16, #16]
 # NOEX-NEXT:   21001c: add     x16, x16, #16
 # NOEX-NEXT:   210020: br      x17
 # NOEX-NEXT:   210024: nop
 # NOEX-NEXT:   210028: nop
 # NOEX-NEXT:   21002c: nop

 
 # FORCE: Disassembly of section .text:
 # FORCE: 0000000000210000 func1:
 # FORCE-NEXT:   210000: bl      #48 <func2@plt>
 # FORCE-NEXT:   210004: ret
 # FORCE: 0000000000210008 func3:
 # FORCE-NEXT:   210008: ret
 # FORCE: Disassembly of section .plt:
-# FORCE: 0000000000210010 .plt:
+# FORCE: 0000000000210010 func2@plt-0x20:
 # FORCE-NEXT:   210010: bti     c
 # FORCE-NEXT:   210014: stp     x16, x30, [sp, #-16]!
 # FORCE-NEXT:   210018: adrp    x16, #131072
 # FORCE-NEXT:   21001c: ldr     x17, [x16, #16]
 # FORCE-NEXT:   210020: add     x16, x16, #16
 # FORCE-NEXT:   210024: br      x17
 # FORCE-NEXT:   210028: nop
 # FORCE-NEXT:   21002c: nop

lld/test/ELF/aarch64-feature-btipac.s

 
 # BTIPACSO: Disassembly of section .text:
 # BTIPACSO: 0000000000010000 func2:
 # BTIPACSO-NEXT:    10000: bl      #48 <func3@plt>
 # BTIPACSO-NEXT:    10004: ret
 # BTIPACSO: 0000000000010008 func3:
 # BTIPACSO-NEXT:    10008: ret
 # BTIPACSO: Disassembly of section .plt:
-# BTIPACSO: 0000000000010010 .plt:
+# BTIPACSO: 0000000000010010 func3@plt-0x20:
 # BTIPACSO-NEXT:    10010: bti     c
 # BTIPACSO-NEXT:    10014: stp     x16, x30, [sp, #-16]!
 # BTIPACSO-NEXT:    10018: adrp    x16, #131072
 # BTIPACSO-NEXT:    1001c: ldr     x17, [x16, #16]
 # BTIPACSO-NEXT:    10020: add     x16, x16, #16
 # BTIPACSO-NEXT:    10024: br      x17
 # BTIPACSO-NEXT:    10028: nop
 # BTIPACSO-NEXT:    1002c: nop

 # BTIPACEX: Disassembly of section .text:
 # BTIPACEX: 0000000000210000 func1:
 # BTIPACEX-NEXT:   210000: bl      #48 <func2@plt>
 # BTIPACEX-NEXT:   210004: ret
 # BTIPACEX-NEXT:   210008: ret
 # BTIPACEX: 000000000021000c func3:
 # BTIPACEX-NEXT:   21000c: ret
 # BTIPACEX: Disassembly of section .plt:
-# BTIPACEX: 0000000000210010 .plt:
+# BTIPACEX: 0000000000210010 func2@plt-0x20:
 # BTIPACEX-NEXT:   210010: bti     c
 # BTIPACEX-NEXT:   210014: stp     x16, x30, [sp, #-16]!
 # BTIPACEX-NEXT:   210018: adrp    x16, #131072
 # BTIPACEX-NEXT:   21001c: ldr     x17, [x16, #16]
 # BTIPACEX-NEXT:   210020: add     x16, x16, #16
 # BTIPACEX-NEXT:   210024: br      x17
 # BTIPACEX-NEXT:   210028: nop
 # BTIPACEX-NEXT:   21002c: nop

 # EX: Disassembly of section .text:
 # EX: 0000000000210000 func1:
 # EX-NEXT:   210000: bl      #48 <func2@plt>
 # EX-NEXT:   210004: ret
 # EX-NEXT:   210008: ret
 # EX: 000000000021000c func3:
 # EX-NEXT:   21000c: ret
 # EX: Disassembly of section .plt:
-# EX: 0000000000210010 .plt:
+# EX: 0000000000210010 func2@plt-0x20:
 # EX-NEXT:   210010: stp     x16, x30, [sp, #-16]!
 # EX-NEXT:   210014: adrp    x16, #131072
 # EX-NEXT:   210018: ldr     x17, [x16, #16]
 # EX-NEXT:   21001c: add     x16, x16, #16
 # EX-NEXT:   210020: br      x17
 # EX-NEXT:   210024: nop
 # EX-NEXT:   210028: nop
 # EX-NEXT:   21002c: nop

lld/test/ELF/aarch64-feature-pac.s

 # RUN: llvm-objdump -d -mattr=+v8.3a --no-show-raw-insn %tno.so | FileCheck --check-prefix=NOPAC %s
 # RUN: llvm-readelf -x .got.plt %tno.so | FileCheck --check-prefix SOGOTPLT %s
 # RUN: llvm-readelf --dynamic-table %tno.so | FileCheck --check-prefix NOPACDYN %s
 
 # NOPAC: 0000000000010000 func2:
 # NOPAC-NEXT:    10000: bl      #48 <func3@plt>
 # NOPAC-NEXT:    10004: ret
 # NOPAC: Disassembly of section .plt:
-# NOPAC: 0000000000010010 .plt:
+# NOPAC: 0000000000010010 func3@plt-0x20:
 # NOPAC-NEXT:    10010: stp     x16, x30, [sp, #-16]!
 # NOPAC-NEXT:    10014: adrp    x16, #131072
 # NOPAC-NEXT:    10018: ldr     x17, [x16, #16]
 # NOPAC-NEXT:    1001c: add     x16, x16, #16
 # NOPAC-NEXT:    10020: br      x17
 # NOPAC-NEXT:    10024: nop
 # NOPAC-NEXT:    10028: nop
 # NOPAC-NEXT:    1002c: nop

 
 ## PAC has no effect on PLT[0], for PLT[N] autia1716 is used to authenticate
 ## the address in x17 (context in x16) before branching to it. The dynamic
 ## loader is responsible for calling pacia1716 on the entry.
 # PACSO: 0000000000010000 func2:
 # PACSO-NEXT:    10000: bl      #48 <func3@plt>
 # PACSO-NEXT:    10004: ret
 # PACSO: Disassembly of section .plt:
-# PACSO: 0000000000010010 .plt:
+# PACSO: 0000000000010010 func3@plt-0x20:
 # PACSO-NEXT:    10010: stp     x16, x30, [sp, #-16]!
 # PACSO-NEXT:    10014: adrp    x16, #131072
 # PACSO-NEXT:    10018: ldr     x17, [x16, #16]
 # PACSO-NEXT:    1001c: add     x16, x16, #16
 # PACSO-NEXT:    10020: br      x17
 # PACSO-NEXT:    10024: nop
 # PACSO-NEXT:    10028: nop
 # PACSO-NEXT:    1002c: nop

 
 # PACPLT: Disassembly of section .text:
 # PACPLT: 0000000000210000 func1:
 # PACPLT-NEXT:   210000: bl      #48 <func2@plt>
 # PACPLT-NEXT:   210004: ret
 # PACPLT: 0000000000210008 func3:
 # PACPLT-NEXT:   210008: ret
 # PACPLT: Disassembly of section .plt:
-# PACPLT: 0000000000210010 .plt:
+# PACPLT: 0000000000210010 func2@plt-0x20:
 # PACPLT-NEXT:   210010: stp     x16, x30, [sp, #-16]!
 # PACPLT-NEXT:   210014: adrp    x16, #131072
 # PACPLT-NEXT:   210018: ldr     x17, [x16, #16]
 # PACPLT-NEXT:   21001c: add     x16, x16, #16
 # PACPLT-NEXT:   210020: br      x17
 # PACPLT-NEXT:   210024: nop
 # PACPLT-NEXT:   210028: nop
 # PACPLT-NEXT:   21002c: nop

lld/test/ELF/aarch64-gnu-ifunc-plt.s

 // DISASM:      _start:
 // DISASM-NEXT:    210008: {{.*}} bl      #88
 // DISASM-NEXT:    21000c: {{.*}} bl      #100
 // DISASM-NEXT:    210010: {{.*}} bl      #48
 // DISASM-NEXT:    210014: {{.*}} bl      #60
 // DISASM-EMPTY:
 // DISASM-NEXT: Disassembly of section .plt:
 // DISASM-EMPTY:
-// DISASM-NEXT: .plt:
+// DISASM-NEXT:   bar2@plt-0x20:
 // DISASM-NEXT:    210020: {{.*}} stp     x16, x30, [sp, #-16]!
 // DISASM-NEXT:    210024: {{.*}} adrp    x16, #131072
 // DISASM-NEXT:    210028: {{.*}} ldr     x17, [x16, #16]
 // DISASM-NEXT:    21002c: {{.*}} add     x16, x16, #16
 // DISASM-NEXT:    210030: {{.*}} br      x17
 // DISASM-NEXT:    210034: {{.*}} nop
 // DISASM-NEXT:    210038: {{.*}} nop
 // DISASM-NEXT:    21003c: {{.*}} nop

lld/test/ELF/aarch64-ifunc-bti.s

 # REQUIRES: aarch64
 # RUN: llvm-mc -filetype=obj -triple=aarch64-none-linux-gnu %s -o %t.o
 # RUN: llvm-mc -filetype=obj -triple=aarch64-none-linux-gnu %p/Inputs/aarch64-addrifunc.s -o %t1.o
 
 # RUN: ld.lld --shared %t1.o -o %t1.so
 # RUN: ld.lld --pie %t1.so %t.o -o %t
 # RUN: llvm-objdump -d -mattr=+bti -triple=aarch64-linux-gnu %t | FileCheck %s
 
 # When the address of an ifunc is taken using a non-got reference which clang
 # can do, LLD exports a canonical PLT entry that may have its address taken so
 # we must use bti c.
 
 # CHECK: Disassembly of section .plt:
-# CHECK: 0000000000010020 .plt:
+# CHECK: 0000000000010020 func1@plt-0x20:
 # CHECK-NEXT:    10020: 5f 24 03 d5                     bti     c
 # CHECK-NEXT:    10024: f0 7b bf a9                     stp     x16, x30, [sp, #-16]!
 # CHECK-NEXT:    10028: 10 01 00 90                     adrp    x16, #131072
 # CHECK-NEXT:    1002c: 11 0a 40 f9                     ldr     x17, [x16, #16]
 # CHECK-NEXT:    10030: 10 42 00 91                     add     x16, x16, #16
 # CHECK-NEXT:    10034: 20 02 1f d6                     br      x17
 # CHECK-NEXT:    10038: 1f 20 03 d5                     nop
 # CHECK-NEXT:    1003c: 1f 20 03 d5                     nop

lld/test/ELF/aarch64-thunk-pi.s

 
 // CHECK: __AArch64ADRPThunk_low_target2:
 // CHECK-NEXT: 10000010:  10 00 f8 90   adrp  x16, #-268435456
 // 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-EMPTY:
-// CHECK-NEXT: .plt:
+// CHECK-NEXT: high_target@plt-0x20:
 // 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 92 40 f9     ldr     x17, [x16, #288]
 // CHECK-NEXT: 1000002c:       10 82 04 91     add     x16, x16, #288
 // 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

lld/test/ELF/aarch64-tstbr14-reloc.s

 # 0x10028 + 56 = 0x10060 = PLT[2]
 #DSO-NEXT:  1001c: {{.*}} tbnz w3, #15, #52
 #DSO-NEXT:  10020: {{.*}} tbnz w3, #15, #64
 #DSO-NEXT:  10024: {{.*}} tbz x6, #45, #44
 #DSO-NEXT:  10028: {{.*}} tbz x6, #45, #56
 #DSO-EMPTY:
 #DSO-NEXT: Disassembly of section .plt:
 #DSO-EMPTY:
-#DSO-NEXT: .plt:
+#DSO-NEXT:   _foo@plt-0x20:
 #DSO-NEXT:  10030: {{.*}} stp x16, x30, [sp, #-16]!
 #DSO-NEXT:  10034: {{.*}} adrp x16, #131072
 #DSO-NEXT:  10038: {{.*}} ldr x17, [x16, #16]
 #DSO-NEXT:  1003c: {{.*}} add x16, x16, #16
 #DSO-NEXT:  10040: {{.*}} br x17
 #DSO-NEXT:  10044: {{.*}} nop
 #DSO-NEXT:  10048: {{.*}} nop
 #DSO-NEXT:  1004c: {{.*}} nop

lld/test/ELF/gnu-ifunc-noplt-i386.s

 // DISASM-NEXT: 00401002 _start:
 // DISASM-NEXT:   401002:       calll -4 <_start+0x1>
 // DISASM-NEXT:   401007:       calll -4 <_start+0x6>
 // DISASM-NEXT:   40100c:       calll 31 <bar2@plt>
 // DISASM-NEXT:   401011:       calll 42 <zed2@plt>
 // DISASM-EMPTY:
 // DISASM-NEXT: Disassembly of section .plt:
 // DISASM-EMPTY:
-// DISASM-NEXT: 00401020 .plt:
+// DISASM-NEXT: 00401020 bar2@plt-0x10:
 // DISASM-NEXT:   401020:       pushl 4206596
 // DISASM-NEXT:   401026:       jmpl  *4206600
 // DISASM-NEXT:   40102c:       nop
 // DISASM-NEXT:   40102d:       nop
 // DISASM-NEXT:   40102e:       nop
 // DISASM-NEXT:   40102f:       nop
 // DISASM-EMPTY:
 // DISASM-NEXT: 00401030 bar2@plt:
 // DISASM-NEXT:   401030:       jmpl  *4206604
 // DISASM-NEXT:   401036:       pushl $0
-// DISASM-NEXT:   40103b:       jmp -32 <.plt>
+// DISASM-NEXT:   40103b:       jmp -32 <bar2@plt-0x10>
 // DISASM-EMPTY:
 // DISASM-NEXT: 00401040 zed2@plt:
 // DISASM-NEXT:   401040:       jmpl  *4206608
 // DISASM-NEXT:   401046:       pushl $8
-// DISASM-NEXT:   40104b:       jmp -48 <.plt>
+// DISASM-NEXT:   40104b:       jmp -48 <bar2@plt-0x10>
 
 .text
 .type foo STT_GNU_IFUNC
 .globl foo
 foo:
  ret
 
 .type bar STT_GNU_IFUNC

lld/test/ELF/gnu-ifunc-noplt.s

 // DISASM-NEXT: 0000000000201002 _start:
 // DISASM-NEXT:   201002:       callq 0 <_start+0x5>
 // DISASM-NEXT:   201007:       callq 0 <_start+0xa>
 // DISASM-NEXT:   20100c:       callq 31 <bar2@plt>
 // DISASM-NEXT:   201011:       callq 42 <zed2@plt>
 // DISASM-EMPTY:
 // DISASM-NEXT: Disassembly of section .plt:
 // DISASM-EMPTY:
-// DISASM-NEXT: 0000000000201020 .plt:
+// DISASM-NEXT: 0000000000201020 bar2@plt-0x10:
 // DISASM-NEXT:   201020:       pushq 8162(%rip)
 // DISASM-NEXT:   201026:       jmpq  *8164(%rip)
 // DISASM-NEXT:   20102c:       nopl  (%rax)
 // DISASM-EMPTY:
 // DISASM-NEXT: 0000000000201030 bar2@plt:
 // DISASM-NEXT:   201030:       jmpq  *8162(%rip)
 // DISASM-NEXT:   201036:       pushq $0
-// DISASM-NEXT:   20103b:       jmp -32 <.plt>
+// DISASM-NEXT:   20103b:       jmp -32 <bar2@plt-0x10>
 // DISASM-EMPTY:
 // DISASM-NEXT: 0000000000201040 zed2@plt:
 // DISASM-NEXT:   201040:       jmpq  *8154(%rip)
 // DISASM-NEXT:   201046:       pushq $1
-// DISASM-NEXT:   20104b:       jmp -48 <.plt>
+// DISASM-NEXT:   20104b:       jmp -48 <bar2@plt-0x10>
 
 .text
 .type foo STT_GNU_IFUNC
 .globl foo
 foo:
  ret
 
 .type bar STT_GNU_IFUNC

lld/test/ELF/gnu-ifunc-plt-i386.s

 // DISASM:      _start:
 // DISASM-NEXT:    401002:       e8 49 00 00 00          calll   73
 // DISASM-NEXT:    401007:       e8 54 00 00 00          calll   84
 // DISASM-NEXT:    40100c:       e8 1f 00 00 00          calll   31
 // DISASM-NEXT:    401011:       e8 2a 00 00 00          calll   42
 // DISASM-EMPTY:
 // DISASM-NEXT: Disassembly of section .plt:
 // DISASM-EMPTY:
-// DISASM-NEXT: .plt:
+// DISASM-NEXT:   bar2@plt-0x10:
 // DISASM-NEXT:    401020:       ff 35 04 30 40 00       pushl   4206596
 // DISASM-NEXT:    401026:       ff 25 08 30 40 00       jmpl    *4206600
 // DISASM-NEXT:    40102c:       90      nop
 // DISASM-NEXT:    40102d:       90      nop
 // DISASM-NEXT:    40102e:       90      nop
 // DISASM-NEXT:    40102f:       90      nop
 // DISASM-EMPTY:
 // DISASM-NEXT:   bar2@plt:
 // DISASM-NEXT:    401030:       ff 25 0c 30 40 00       jmpl    *4206604
 // DISASM-NEXT:    401036:       68 00 00 00 00          pushl   $0
-// DISASM-NEXT:    40103b:       e9 e0 ff ff ff          jmp     -32 <.plt>
+// DISASM-NEXT:    40103b:       e9 e0 ff ff ff          jmp     -32 <bar2@plt-0x10>
 // DISASM-EMPTY:
 // DISASM-NEXT:   zed2@plt:
 // DISASM-NEXT:    401040:       ff 25 10 30 40 00       jmpl    *4206608
 // DISASM-NEXT:    401046:       68 08 00 00 00          pushl   $8
-// DISASM-NEXT:    40104b:       e9 d0 ff ff ff          jmp     -48 <.plt>
+// DISASM-NEXT:    40104b:       e9 d0 ff ff ff          jmp     -48 <bar2@plt-0x10>
 // DISASM-NEXT:    401050:       ff 25 14 30 40 00       jmpl    *4206612
 // DISASM-NEXT:    401056:       68 30 00 00 00          pushl   $48
 // DISASM-NEXT:    40105b:       e9 e0 ff ff ff          jmp     -32 <zed2@plt>
 // DISASM-NEXT:    401060:       ff 25 18 30 40 00       jmpl    *4206616
 // DISASM-NEXT:    401066:       68 38 00 00 00          pushl   $56
 // DISASM-NEXT:    40106b:       e9 d0 ff ff ff          jmp     -48 <zed2@plt>
 
 .text

lld/test/ELF/gnu-ifunc-plt.s

 // DISASM:      _start:
 // DISASM-NEXT:   201002:       e8 49 00 00 00          callq   73
 // DISASM-NEXT:   201007:       e8 54 00 00 00          callq   84
 // DISASM-NEXT:   20100c:       e8 1f 00 00 00          callq   31
 // DISASM-NEXT:   201011:       e8 2a 00 00 00          callq   42
 // DISASM-EMPTY:
 // DISASM-NEXT: Disassembly of section .plt:
 // DISASM-EMPTY:
-// DISASM-NEXT: .plt:
+// DISASM-NEXT:   bar2@plt-0x10:
 // DISASM-NEXT:   201020:       ff 35 e2 1f 00 00       pushq   8162(%rip)
 // DISASM-NEXT:   201026:       ff 25 e4 1f 00 00       jmpq    *8164(%rip)
 // DISASM-NEXT:   20102c:       0f 1f 40 00     nopl    (%rax)
 // DISASM-EMPTY:
 // DISASM-NEXT:   bar2@plt:
 // DISASM-NEXT:   201030:       ff 25 e2 1f 00 00       jmpq    *8162(%rip)
 // DISASM-NEXT:   201036:       68 00 00 00 00          pushq   $0
-// DISASM-NEXT:   20103b:       e9 e0 ff ff ff          jmp     -32 <.plt>
+// DISASM-NEXT:   20103b:       e9 e0 ff ff ff          jmp     -32 <bar2@plt-0x10>
 // DISASM-EMPTY:
 // DISASM-NEXT:   zed2@plt:
 // DISASM-NEXT:   201040:       ff 25 da 1f 00 00       jmpq    *8154(%rip)
 // DISASM-NEXT:   201046:       68 01 00 00 00          pushq   $1
-// DISASM-NEXT:   20104b:       e9 d0 ff ff ff          jmp     -48 <.plt>
+// DISASM-NEXT:   20104b:       e9 d0 ff ff ff          jmp     -48 <bar2@plt-0x10>
 // DISASM-NEXT:   201050:       ff 25 d2 1f 00 00       jmpq    *8146(%rip)
 // DISASM-NEXT:   201056:       68 00 00 00 00          pushq   $0
 // DISASM-NEXT:   20105b:       e9 e0 ff ff ff          jmp     -32 <zed2@plt>
 // DISASM-NEXT:   201060:       ff 25 ca 1f 00 00       jmpq    *8138(%rip)
 // DISASM-NEXT:   201066:       68 01 00 00 00          pushq   $1
 // DISASM-NEXT:   20106b:       e9 d0 ff ff ff          jmp     -48 <zed2@plt>
 
 .text

lld/test/ELF/gnu-ifunc-shared.s

 // DISASM-NEXT:     1007:       e8 24 00 00 00          callq   36
 // DISASM-NEXT:     100c:       e8 2f 00 00 00          callq   47
 // DISASM-NEXT:     1011:       c3      retq
 // DISASM:     f2:
 // DISASM-NEXT:     1012:       c3      retq
 // DISASM-EMPTY:
 // DISASM-NEXT: Disassembly of section .plt:
 // DISASM-EMPTY:
-// DISASM-NEXT: .plt:
+// DISASM-NEXT:   fct2@plt-0x10:
 // DISASM-NEXT:     1020:       ff 35 e2 1f 00 00       pushq   8162(%rip)
 // DISASM-NEXT:     1026:       ff 25 e4 1f 00 00       jmpq    *8164(%rip)
 // DISASM-NEXT:     102c:       0f 1f 40 00     nopl    (%rax)
 // DISASM-EMPTY:
 // DISASM-NEXT:   fct2@plt:
 // DISASM-NEXT:     1030:       ff 25 e2 1f 00 00       jmpq    *8162(%rip)
 // DISASM-NEXT:     1036:       68 00 00 00 00          pushq   $0
-// DISASM-NEXT:     103b:       e9 e0 ff ff ff          jmp     -32 <.plt>
+// DISASM-NEXT:     103b:       e9 e0 ff ff ff          jmp     -32 <fct2@plt-0x10>
 // DISASM-EMPTY:
 // DISASM-NEXT:   f2@plt:
 // DISASM-NEXT:     1040:       ff 25 da 1f 00 00       jmpq    *8154(%rip)
 // DISASM-NEXT:     1046:       68 01 00 00 00          pushq   $1
-// DISASM-NEXT:     104b:       e9 d0 ff ff ff          jmp     -48 <.plt>
+// DISASM-NEXT:     104b:       e9 d0 ff ff ff          jmp     -48 <fct2@plt-0x10>
 // DISASM-NEXT:     1050:       ff 25 d2 1f 00 00       jmpq    *8146(%rip)
 // DISASM-NEXT:     1056:       68 00 00 00 00          pushq   $0
 // DISASM-NEXT:     105b:       e9 e0 ff ff ff          jmp     -32 <f2@plt>
 
 // CHECK: Relocations [
 // CHECK-NEXT:   Section (4) .rela.plt {
 // CHECK-NEXT:     0x3018 R_X86_64_JUMP_SLOT fct2 0x0
 // CHECK-NEXT:     0x3020 R_X86_64_JUMP_SLOT f2 0x0

lld/test/ELF/plt-aarch64.s

 // 0x10050 - 0x10008 = 0x48 = 72
 // DISASMDSO-NEXT:     10008: 12 00 00 14   b #72
 
 // DISASMDSO: foo:
 // DISASMDSO-NEXT:     1000c: 1f 20 03 d5   nop
 
 // DISASMDSO: Disassembly of section .plt:
 // DISASMDSO-EMPTY:
-// DISASMDSO-NEXT: .plt:
+// DISASMDSO-NEXT: foo@plt-0x20:
 // DISASMDSO-NEXT:     10010: f0 7b bf a9   stp x16, x30, [sp, #-16]!
 // &(.got.plt[2]) = 0x3000 + 2 * 8 = 0x3010
 // Page(0x30010) - Page(0x10014) = 0x30000 - 0x10000 = 0x20000 = 131072
 // DISASMDSO-NEXT:     10014: 10 01 00 90   adrp  x16, #131072
 // 0x3010 & 0xFFF = 0x10 = 16
 // DISASMDSO-NEXT:     10018: 11 0a 40 f9 ldr x17, [x16, #16]
 // DISASMDSO-NEXT:     1001c: 10 42 00 91   add x16, x16, #16
 // DISASMDSO-NEXT:     10020: 20 02 1f d6   br  x17

 // 0x210040 - 0x210008 = 0x38 = 56
 // DISASMEXE-NEXT:    210008: 0e 00 00 14   b #56
 
 // DISASMEXE: foo:
 // DISASMEXE-NEXT:    21000c: 1f 20 03 d5   nop
 
 // DISASMEXE: Disassembly of section .plt:
 // DISASMEXE-EMPTY:
-// DISASMEXE-NEXT: .plt:
+// DISASMEXE-NEXT: bar@plt-0x20:
 // DISASMEXE-NEXT:    210010: f0 7b bf a9   stp x16, x30, [sp, #-16]!
 // &(.got.plt[2]) = 0x2200B0 + 2 * 8 = 0x2200C0
 // Page(0x230010) - Page(0x210014) = 0x230000 - 0x210000 = 0x20000 = 131072
 // DISASMEXE-NEXT:    210014: 10 01 00 90   adrp  x16, #131072
 // 0x120c0 & 0xFFF = 0xC0 = 192
 // DISASMEXE-NEXT:    210018: 11 0a 40 f9   ldr x17, [x16, #16]
 // DISASMEXE-NEXT:    21001c: 10 42 00 91   add x16, x16, #16
 // DISASMEXE-NEXT:    210020: 20 02 1f d6   br  x17

lld/test/ELF/plt-i686.s

 // 0x401010 - 0x40102b - 5 = -32
 // 0x401010 - 0x40103b - 5 = -48
 // 4206596 = 0x403004 = .got.plt (0x403000) + 4
 // 4206600 = 0x403008 = .got.plt (0x403000) + 8
 // 4206604 = 0x40300C = .got.plt (0x403000) + got.plt.reserved(12)
 // 4206608 = 0x403010 = .got.plt (0x403000) + got.plt.reserved(12) + 4
 // DISASM:      Disassembly of section .plt:
 // DISASM-EMPTY:
-// DISASM-NEXT: .plt:
+// DISASM-NEXT:   bar@plt-0x10:
 // DISASM-NEXT:    401020: ff 35 04 30 40 00 pushl 4206596
 // DISASM-NEXT:    401026: ff 25 08 30 40 00 jmpl *4206600
 // DISASM-NEXT:    40102c: 90 nop
 // DISASM-NEXT:    40102d: 90 nop
 // DISASM-NEXT:    40102e: 90 nop
 // DISASM-NEXT:    40102f: 90 nop
 // DISASM-EMPTY:
 // DISASM-NEXT:   bar@plt:
 // DISASM-NEXT:    401030: ff 25 0c 30 40 00 jmpl *4206604
 // DISASM-NEXT:    401036: 68 00 00 00 00 pushl $0
-// DISASM-NEXT:    40103b: e9 e0 ff ff ff jmp -32 <.plt>
+// DISASM-NEXT:    40103b: e9 e0 ff ff ff jmp -32 <bar@plt-0x10>
 // DISASM-EMPTY:
 // DISASM-NEXT:   zed@plt:
 // DISASM-NEXT:    401040: ff 25 10 30 40 00 jmpl *4206608
 // DISASM-NEXT:    401046: 68 08 00 00 00 pushl $8
-// DISASM-NEXT:    40104b: e9 d0 ff ff ff jmp -48 <.plt>
+// DISASM-NEXT:    40104b: e9 d0 ff ff ff jmp -48 <bar@plt-0x10>
 
 // CHECKSHARED:        Name: .plt
 // CHECKSHARED-NEXT:   Type: SHT_PROGBITS
 // CHECKSHARED-NEXT:   Flags [
 // CHECKSHARED-NEXT:     SHF_ALLOC
 // CHECKSHARED-NEXT:     SHF_EXECINSTR
 // CHECKSHARED-NEXT:   ]
 // CHECKSHARED-NEXT:   Address: 0x1020

 // 0x1013 + 5 - 24 = 0x1000
 // DISASMSHARED-NEXT:  1004: e9 27 00 00 00 jmp 39
 // DISASMSHARED-NEXT:  1009: e9 22 00 00 00 jmp 34
 // DISASMSHARED-NEXT:  100e: e9 2d 00 00 00 jmp 45
 // DISASMSHARED-NEXT:  1013: e9 e8 ff ff ff jmp -24
 // DISASMSHARED-EMPTY:
 // DISASMSHARED-NEXT:  Disassembly of section .plt:
 // DISASMSHARED-EMPTY:
-// DISASMSHARED-NEXT:  .plt:
+// DISASMSHARED-NEXT:  bar@plt-0x10:
 // DISASMSHARED-NEXT:  1020: ff b3 04 00 00 00 pushl 4(%ebx)
 // DISASMSHARED-NEXT:  1026: ff a3 08 00 00 00 jmpl *8(%ebx)
 // DISASMSHARED-NEXT:  102c: 90 nop
 // DISASMSHARED-NEXT:  102d: 90 nop
 // DISASMSHARED-NEXT:  102e: 90 nop
 // DISASMSHARED-NEXT:  102f: 90 nop
 // DISASMSHARED:       bar@plt:
 // DISASMSHARED-NEXT:  1030: ff a3 0c 00 00 00 jmpl *12(%ebx)
 // DISASMSHARED-NEXT:  1036: 68 00 00 00 00     pushl $0
-// DISASMSHARED-NEXT:  103b: e9 e0 ff ff ff     jmp -32 <.plt>
+// DISASMSHARED-NEXT:  103b: e9 e0 ff ff ff     jmp -32 <bar@plt-0x10>
 // DISASMSHARED:       zed@plt:
 // DISASMSHARED-NEXT:  1040: ff a3 10 00 00 00 jmpl *16(%ebx)
 // DISASMSHARED-NEXT:  1046: 68 08 00 00 00     pushl $8
-// DISASMSHARED-NEXT:  104b: e9 d0 ff ff ff     jmp -48 <.plt>
+// DISASMSHARED-NEXT:  104b: e9 d0 ff ff ff     jmp -48 <bar@plt-0x10>
 
 // DISASMPIE:      Disassembly of section .plt:
 // DISASMPIE-EMPTY:
-// DISASMPIE-NEXT: .plt:
+// DISASMPIE-NEXT:   bar@plt-0x10:
 // DISASMPIE-NEXT:   1020:  ff b3 04 00 00 00 pushl 4(%ebx)
 // DISASMPIE-NEXT:   1026:  ff a3 08 00 00 00 jmpl *8(%ebx)
 // DISASMPIE-NEXT:   102c:  90 nop
 // DISASMPIE-NEXT:   102d:  90 nop
 // DISASMPIE-NEXT:   102e:  90 nop
 // DISASMPIE-NEXT:   102f:  90 nop
 // DISASMPIE:        bar@plt:
 // DISASMPIE-NEXT:   1030:  ff a3 0c 00 00 00 jmpl *12(%ebx)
 // DISASMPIE-NEXT:   1036:  68 00 00 00 00 pushl $0
-// DISASMPIE-NEXT:   103b:  e9 e0 ff ff ff jmp -32 <.plt>
+// DISASMPIE-NEXT:   103b:  e9 e0 ff ff ff jmp -32 <bar@plt-0x10>
 // DISASMPIE:        zed@plt:
 // DISASMPIE-NEXT:   1040:  ff a3 10 00 00 00 jmpl *16(%ebx)
 // DISASMPIE-NEXT:   1046:  68 08 00 00 00 pushl $8
-// DISASMPIE-NEXT:   104b:  e9 d0 ff ff ff jmp -48 <.plt>
+// DISASMPIE-NEXT:   104b:  e9 d0 ff ff ff jmp -48 <bar@plt-0x10>
 
 local:
 .long 0
 
 .global _start
 _start:
   jmp bar@PLT
   jmp bar@PLT
   jmp zed@PLT
   jmp local@plt

lld/test/ELF/plt.s

 // DISASM-NEXT:   100f:  e9 {{.*}}       jmp  60
 
 // 0x3018 - 0x1036  = 8162
 // 0x3020 - 0x1046  = 8154
 // 0x3028 - 0x1056  = 8146
 
 // DISASM:      Disassembly of section .plt:
 // DISASM-EMPTY:
-// DISASM-NEXT: .plt:
+// DISASM-NEXT:   bar@plt-0x10:
 // DISASM-NEXT:   1020:  ff 35 e2 1f 00 00  pushq 8162(%rip)
 // DISASM-NEXT:   1026:  ff 25 e4 1f 00 00  jmpq *8164(%rip)
 // DISASM-NEXT:   102c:  0f 1f 40 00        nopl (%rax)
 // DISASM-EMPTY:
 // DISASM-NEXT:   bar@plt:
 // DISASM-NEXT:   1030:  ff 25 e2 1f 00 00  jmpq *8162(%rip)
 // DISASM-NEXT:   1036:  68 00 00 00 00     pushq $0
-// DISASM-NEXT:   103b:  e9 e0 ff ff ff     jmp -32 <.plt>
+// DISASM-NEXT:   103b:  e9 e0 ff ff ff     jmp -32 <bar@plt-0x10>
 // DISASM-EMPTY:
 // DISASM-NEXT:   zed@plt:
 // DISASM-NEXT:   1040:  ff 25 da 1f 00 00  jmpq *8154(%rip)
 // DISASM-NEXT:   1046:  68 01 00 00 00     pushq $1
-// DISASM-NEXT:   104b:  e9 d0 ff ff ff     jmp -48 <.plt>
+// DISASM-NEXT:   104b:  e9 d0 ff ff ff     jmp -48 <bar@plt-0x10>
 // DISASM-EMPTY:
 // DISASM-NEXT:   _start@plt:
 // DISASM-NEXT:   1050:  ff 25 d2 1f 00 00  jmpq *8146(%rip)
 // DISASM-NEXT:   1056:  68 02 00 00 00     pushq $2
-// DISASM-NEXT:   105b:  e9 c0 ff ff ff     jmp -64 <.plt>
+// DISASM-NEXT:   105b:  e9 c0 ff ff ff     jmp -64 <bar@plt-0x10>
 
 // 0x201030 - (0x201000 + 1) - 4 = 43
 // 0x201030 - (0x201005 + 1) - 4 = 38
 // 0x201040 - (0x20100a + 1) - 4 = 49
 // 0x201000 - (0x20100f + 1) - 4 = -20
 
 // DISASM2:      _start:
 // DISASM2-NEXT:   201000:  e9 {{.*}}     jmp  43
 // DISASM2-NEXT:   201005:  e9 {{.*}}     jmp  38
 // DISASM2-NEXT:   20100a:  e9 {{.*}}     jmp  49
 // DISASM2-NEXT:   20100f:  e9 {{.*}}     jmp  -20
 
 // 0x202018 - 0x201036  = 4066
 // 0x202020 - 0x201046  = 4058
 
 // DISASM2:      Disassembly of section .plt:
 // DISASM2-EMPTY:
-// DISASM2-NEXT: .plt:
+// DISASM2-NEXT:   bar@plt-0x10:
 // DISASM2-NEXT:  201020:  ff 35 e2 1f 00 00   pushq 8162(%rip)
 // DISASM2-NEXT:  201026:  ff 25 e4 1f 00 00   jmpq *8164(%rip)
 // DISASM2-NEXT:  20102c:  0f 1f 40 00         nopl  (%rax)
 // DISASM2-EMPTY:
 // DISASM2-NEXT:   bar@plt:
 // DISASM2-NEXT:  201030:  ff 25 e2 1f 00 00   jmpq *8162(%rip)
 // DISASM2-NEXT:  201036:  68 00 00 00 00      pushq $0
-// DISASM2-NEXT:  20103b:  e9 e0 ff ff ff      jmp -32 <.plt>
+// DISASM2-NEXT:  20103b:  e9 e0 ff ff ff      jmp -32 <bar@plt-0x10>
 // DISASM2-EMPTY:
 // DISASM2-NEXT:   zed@plt:
 // DISASM2-NEXT:  201040:  ff 25 da 1f 00 00   jmpq *8154(%rip)
 // DISASM2-NEXT:  201046:  68 01 00 00 00      pushq $1
-// DISASM2-NEXT:  20104b:  e9 d0 ff ff ff      jmp -48 <.plt>
+// DISASM2-NEXT:  20104b:  e9 d0 ff ff ff      jmp -48 <bar@plt-0x10>
 // DISASM2-NOT:   2010C0
 
 .global _start
 _start:
   jmp bar@PLT
   jmp bar@PLT
   jmp zed@PLT
   jmp _start@plt

lld/test/ELF/ppc64-relocs.s

 # equals the address of __foo.
 # 0x100001ea + 0xfe6e = 0x10010058
 # DATALE: section '.eh_frame':
 # DATALE: 0x100001e8 {{....}}6efe
 
 # DATABE: section '.eh_frame':
 # DATABE: 0x100001e8 {{[0-9a-f]+ [0-9a-f]+}} fe6e{{....}}
 
-# CHECK: __foo
+# CHECK: __foo:
 # CHECK-NEXT: 10010058:       li 3, 0

lld/test/ELF/startstop-gccollect.s

 # DISASM-EMPTY:
 # DISASM-NEXT: Disassembly of section foo:
 # DISASM-EMPTY:
 # DISASM-NEXT: __start_foo:
 # DISASM-NEXT: 20100a:        90      nop
 # DISASM-EMPTY:
 # DISASM-NEXT: Disassembly of section bar:
 # DISASM-EMPTY:
-# DISASM-NEXT: bar:
+# DISASM-NEXT: __stop_bar-0x1:
 # DISASM-NEXT: 20100b:        90      nop
 
 .global _start
 .text
 _start:
  callq __start_foo
  callq __stop_bar
 
 .section foo,"ax"
  nop
 
 .section bar,"ax"
  nop

llvm/test/MC/AMDGPU/branch-comment.s

 // RUN: llvm-mc -arch=amdgcn -mcpu=fiji -filetype=obj %s | llvm-objcopy -S -K keep_symbol - | llvm-objdump -disassemble -mcpu=fiji - | FileCheck %s --check-prefix=BIN
 
 // FIXME: Immediate operands to sopp_br instructions are currently scaled by a
 // factor of 4, are unsigned, are always PC relative, don't accept most
 // expressions, and are not range checked.
 
 loop_start_nosym:
 s_branch loop_start_nosym
 // BIN-NOT: loop_start_nosym:
-// BIN: s_branch 65535 // 000000000000: BF82FFFF <.text>
+// BIN: s_branch 65535 // 000000000000: BF82FFFF <keep_symbol-0xc>
 
 s_branch loop_end_nosym
-// BIN: s_branch 0 // 000000000004: BF820000 <.text+0x8>
+// BIN: s_branch 0 // 000000000004: BF820000 <keep_symbol-0x4>
 // BIN-NOT: loop_end_nosym:
 loop_end_nosym:
   s_nop 0
 
 keep_symbol:
   s_nop 0
 
 loop_start_sym:

llvm/test/MC/X86/branch-comment.s

+## This test checks that the dummy section start symbol (<keep_symbol-0xa> in
+## this test) is not used for branch target resolving in disassembly output.
+## The first `jmp` in this case is a special case that the branch target
+## address is the same as the dummy section start symbol address.
+
+# RUN: llvm-mc -filetype=obj --triple=x86_64-pc-linux %s | llvm-objcopy -S -K keep_symbol - | llvm-objdump -disassemble - | FileCheck %s
+
+# CHECK-NOT: loop_start_nosym:
+# CHECK: 0000000000000000 keep_symbol-0xa:
+# CHECK: jmp {{.*}} <keep_symbol-0xa>
+# CHECK: jmp {{.*}} <keep_symbol-0x1>
+# CHECK: 000000000000000a keep_symbol:
+# CHECK-NOT: loop_end_nosym:
+
+loop_start_nosym:
+  nop
+  nop
+  nop
+  nop
+  nop
+  jmp loop_start_nosym
+  jmp loop_end_nosym
+
+loop_end_nosym:
+  nop
+
+keep_symbol:
+  nop

llvm/test/tools/llvm-objdump/X86/elf-disassemble-dynamic-symbols.test

 ## Show the disassembly behaviour when dynamic symbols are present.
 # RUN: yaml2obj %s -o %t
 
 ## Case 1: Both static and dynamic symbols are present. Only static
 ## symbols are displayed.
 # RUN: llvm-objdump -d %t | FileCheck %s --check-prefixes=CHECK,STATIC
 
 ## Case 2: Only the dynamic symbols are present. These should be displayed, if
 ## they meet the necessary criteria.
 # RUN: llvm-objcopy --strip-all %t %t2
 # RUN: llvm-objdump -d %t2 | FileCheck %s --check-prefixes=CHECK,DYN
 
 # CHECK:       Disassembly of section .text:
 # CHECK-EMPTY:
-# STATIC-NEXT: 0000000000001000 .text:
+# STATIC-NEXT: 0000000000001000 both_static-0x1:
 # DYN-NEXT:    0000000000001000 only_dyn:
 # CHECK-NEXT:      1000:
 # CHECK-EMPTY:
 # STATIC-NEXT: 0000000000001001 both_static:
 # DYN-NEXT:    0000000000001001 both_dyn:
 # CHECK-NEXT:      1001:
 # STATIC-EMPTY:
 # STATIC-NEXT: 0000000000001002 only_static:

llvm/test/tools/llvm-objdump/X86/elf-disassemble-no-start-symbol.test

+## Test that if there is no symbol at the start of a section, we show a label
+## with the name "<first-symbol-name>-0x<offset-of-first-symbol>".
+
+# RUN: yaml2obj %s -o %t
+# RUN: llvm-objdump -d %t | FileCheck %s
+
+# CHECK:       Disassembly of section .text:
+# CHECK-EMPTY:
+# CHECK-NEXT:  0000000000001000 first_symbol-0x1:
+# CHECK-NEXT:      1000:
+# CHECK-EMPTY:
+# CHECK-NEXT:  0000000000001001 first_symbol:
+# CHECK-NEXT:      1001:
+# CHECK-EMPTY:
+# CHECK-NEXT:  Disassembly of section .text.no.sym:
+# CHECK-EMPTY:
+# CHECK-NEXT:  0000000000001002 .text.no.sym:
+# CHECK-NEXT:      1002:
+# CHECK-NEXT:      1003:{{.*}}
+# CHECK-NOT:   {{.}}
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name:    .text
+    Type:    SHT_PROGBITS
+    Flags:   [SHF_ALLOC, SHF_EXECINSTR]
+    Address: 0x1000
+    Content: 9090
+  - Name:    .text.no.sym
+    Type:    SHT_PROGBITS
+    Flags:   [SHF_ALLOC, SHF_EXECINSTR]
+    Address: 0x1002
+    Content: 9090
+Symbols:
+  - Name:    first_symbol
+    Value:   0x1001
+    Section: .text
+  - Name:    sym_with_no_section
+    Value:   0x1003

llvm/test/tools/llvm-objdump/X86/elf-disassemble-symbol-labels-rel.test

 # RUN:                                   --implicit-check-not=other
 
 # CHECK: {{.*}}: file format {{.*}}
 # CHECK: Disassembly of section .text:
 # CHECK: 0000000000000000 first:
 # CHECK: 0000000000000001 second:
 # CHECK: 0000000000000002 third:
 # CHECK: Disassembly of section .text2:
+# CHECK: 0000000000000000 other-0x4:
 # CHECK: 0000000000000004 other:
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64

llvm/tools/llvm-objdump/llvm-objdump.cpp

if (FilterSections.empty())
     return true;
   StringRef String;
   std::error_code error = S.getName(String);
   if (error)
     return false;
   return is_contained(FilterSections, String);
 }
 
+static bool shouldKeepDisassemble(object::SectionRef S) {
+  if (!shouldKeep(S) || !S.getSize())
+    return false;
+
+  if (FilterSections.empty() && !DisassembleAll &&
+      (!S.isText() || S.isVirtual()))
+    return false;
+
+  return true;
+}
+
 SectionFilter ToolSectionFilter(object::ObjectFile const &O) {
   return SectionFilter([](object::SectionRef S) { return shouldKeep(S); }, O);
 }
 
+SectionFilter DisassembleSectionFilter(object::ObjectFile const &O) {
+  return SectionFilter([](object::SectionRef S) {
+                          return shouldKeepDisassemble(S);
+                       }, O);
+}
+
 void error(std::error_code EC) {
   if (!EC)
     return;
   WithColor::error(errs(), ToolName)
       << "reading file: " << EC.message() << ".\n";
   errs().flush();
   exit(1);
 }
static void disassembleObject(const Target *TheTarget, const ObjectFile *Obj,
 
   // Sort all the symbols, this allows us to use a simple binary search to find
   // a symbol near an address.
   StringSet<> FoundDisasmFuncsSet;
   for (std::pair<const SectionRef, SectionSymbolsTy> &SecSyms : AllSymbols)
     array_pod_sort(SecSyms.second.begin(), SecSyms.second.end());
   array_pod_sort(AbsoluteSymbols.begin(), AbsoluteSymbols.end());
 
-  for (const SectionRef &Section : ToolSectionFilter(*Obj)) {
-    if (FilterSections.empty() && !DisassembleAll &&
-        (!Section.isText() || Section.isVirtual()))
-      continue;
+  // If the section has no symbol at the start, create one with the name
+  // "<first-symbol>-<offset>" if a later symbol exists; if not, use section
+  // name. This is performed for each section before disassembling because
+  // these symbols are needed for branch target resolving.
+  StringSet<> StartSymbols;
+  for (const SectionRef &Section : DisassembleSectionFilter(*Obj)) {
+    SectionSymbolsTy &Symbols = AllSymbols[Section];
+    uint64_t SectionAddr = Section.getAddress();
 
+    if (Symbols.empty()) {
+      StringRef SectionName;
+      error(Section.getName(SectionName));
+      Symbols.push_back({SectionAddr, SectionName,
+                         Section.isText() ? ELF::STT_FUNC : ELF::STT_OBJECT});
+    } else {
+      uint64_t Addr = std::get<0>(Symbols[0]);
+      if (Addr != SectionAddr) {
+        std::string Sym = Demangle ? demangle(std::get<1>(Symbols[0]))
+                                   : std::get<1>(Symbols[0]).str();
+        auto It = StartSymbols.insert(Sym + "-0x" +
+                                      utohexstr(Addr - SectionAddr, true));
+        Symbols.insert(Symbols.begin(),
+                      {SectionAddr, It.first->getKey(),
+                       Section.isText() ? ELF::STT_FUNC : ELF::STT_OBJECT});
+      }
+    }
+  }
+
+  for (const SectionRef &Section : DisassembleSectionFilter(*Obj)) {
     uint64_t SectionAddr = Section.getAddress();
     uint64_t SectSize = Section.getSize();
-    if (!SectSize)
-      continue;
 
     // Get the list of all the symbols in this section.
     SectionSymbolsTy &Symbols = AllSymbols[Section];
     std::vector<uint64_t> DataMappingSymsAddr;
     std::vector<uint64_t> TextMappingSymsAddr;
     if (isArmElf(Obj)) {
       for (const auto &Symb : Symbols) {
         uint64_t Address = std::get<0>(Symb);
for (const SectionRef &Section : DisassembleSectionFilter(*Obj)) {
 
     StringRef SegmentName = "";
     if (const MachOObjectFile *MachO = dyn_cast<const MachOObjectFile>(Obj)) {
       DataRefImpl DR = Section.getRawDataRefImpl();
       SegmentName = MachO->getSectionFinalSegmentName(DR);
     }
     StringRef SectionName;
     error(Section.getName(SectionName));
 
-    // If the section has no symbol at the start, just insert a dummy one.
-    if (Symbols.empty() || std::get<0>(Symbols[0]) != 0) {
-      Symbols.insert(
-          Symbols.begin(),
-          std::make_tuple(SectionAddr, SectionName,
-                          Section.isText() ? ELF::STT_FUNC : ELF::STT_OBJECT));
-    }
-
     SmallString<40> Comments;
     raw_svector_ostream CommentStream(Comments);
 
     ArrayRef<uint8_t> Bytes = arrayRefFromStringRef(
         unwrapOrError(Section.getContents(), Obj->getFileName()));
 
     uint64_t VMAAdjustment = 0;
     if (shouldAdjustVA(Section))
       VMAAdjustment = AdjustVMA;
#endif
                   [=](const std::tuple<uint64_t, StringRef, uint8_t> &RHS) {
                     return Target < std::get<0>(RHS);
                   });
             }
             if (TargetSym != TargetSectionSymbols->begin()) {
               --TargetSym;
               uint64_t TargetAddress = std::get<0>(*TargetSym);
               StringRef TargetName = std::get<1>(*TargetSym);
+              // Use the first real symbol instead of the dummy section start
+              // symbol.
+              if (StartSymbols.count(TargetName)) {
+                ++TargetSym;
+                TargetAddress = std::get<0>(*TargetSym);
+                TargetName = std::get<1>(*TargetSym);
+              }
               outs() << " <" << TargetName;
-              uint64_t Disp = Target - TargetAddress;
-              if (Disp)
-                outs() << "+0x" << Twine::utohexstr(Disp);
+              if (Target > TargetAddress)
+                outs() << "+0x" << Twine::utohexstr(Target - TargetAddress);
+              else if (Target < TargetAddress)
+                outs() << "-0x" << Twine::utohexstr(TargetAddress - Target);
               outs() << '>';
             }
           }
         }
         outs() << "\n";
 
         // Hexagon does this in pretty printer
         if (Obj->getArch() != Triple::hexagon) {