[llvm-objdump][X86] Add @plt symbols for .plt.got

[MaskRay]

Summary

If a symbol needs both JUMP_SLOT and GLOB_DAT relocations, there is a
minor linker optimization to keep just GLOB_DAT. This optimization
is only implemented by GNU ld's x86 port and mold.
https://maskray.me/blog/2021-08-29-all-about-global-offset-table#combining-.got-and-.got.plt

With the optimizing, the PLT entry is placed in .plt.got and the
associated GOTPLT entry is placed in .got (ld.bfd -z now) or .got.plt (ld.bfd -z lazy).
The relocation is in .rel[a].dyn.

This patch synthesizes symbol@plt labels for these .plt.got entries.

Example:

cat > a.s <<e
.globl _start; _start:
mov combined0@gotpcrel(%rip), %rax; mov combined1@gotpcrel(%rip), %rax
call combined0@plt; call combined1@plt
call foo0@plt; call foo1@plt
e
cat > b.s <<e
.globl foo0, foo1, combined0, combined1
foo0: foo1: combined0: combined1:
e
gcc -fuse-ld=bfd -shared b.s -o b.so
gcc -fuse-ld=bfd -pie -nostdlib a.s b.so -o a

Disassembly of section .plt:

0000000000001000 <.plt>:
    1000: ff 35 ea 1f 00 00             pushq   0x1fea(%rip)            # 0x2ff0 <_GLOBAL_OFFSET_TABLE_+0x8>
    1006: ff 25 ec 1f 00 00             jmpq    *0x1fec(%rip)           # 0x2ff8 <_GLOBAL_OFFSET_TABLE_+0x10>
    100c: 0f 1f 40 00                   nopl    (%rax)

0000000000001010 <foo1@plt>:
    1010: ff 25 ea 1f 00 00             jmpq    *0x1fea(%rip)           # 0x3000 <_GLOBAL_OFFSET_TABLE_+0x18>
    1016: 68 00 00 00 00                pushq   $0x0
    101b: e9 e0 ff ff ff                jmp     0x1000 <.plt>

0000000000001020 <foo0@plt>:
    1020: ff 25 e2 1f 00 00             jmpq    *0x1fe2(%rip)           # 0x3008 <_GLOBAL_OFFSET_TABLE_+0x20>
    1026: 68 01 00 00 00                pushq   $0x1
    102b: e9 d0 ff ff ff                jmp     0x1000 <.plt>

Disassembly of section .plt.got:

0000000000001030 <combined0@plt>:
    1030: ff 25 a2 1f 00 00             jmpq    *0x1fa2(%rip)           # 0x2fd8 <foo1+0x2fd8>
    1036: 66 90                         nop

0000000000001038 <combined1@plt>:
    1038: ff 25 a2 1f 00 00             jmpq    *0x1fa2(%rip)           # 0x2fe0 <foo1+0x2fe0>
    103e: 66 90                         nop

For x86-32, with -z now, if we remove foo0 and foo1, the absence of regular
PLT will cause GNU ld to omit .got.plt, and our code cannot synthesize @plt
labels. This is an extreme corner case that almost never happens in practice (to
trigger the case, ensure every PLT symbol has been taken address). To fix it, we
can get the _GLOBAL_OFFSET_TABLE_ symbol value, but the complexity is not
worth it.

Close https://github.com/llvm/llvm-project/issues/62537

[MaskRay]

Ping:)

[bd1976llvm]

Thanks for working on this and sorry for the lack of response.

Generally looks good, LGTM from me.

I'm happy with the missing corner case for x86-32, given that you mentioned that it is extremely unlikely to occur. Do the GNU tools support that corner case? If they have gone to the trouble to support it I'm wondering if they have a use-case that hasn't occurred to us?
In the description, I think we should have a link to the optimisation in the PS ABI documents in addition to your blog entry.
I wonder if the LLDB folks are aware of this? Might be worth informing them?
I have mentioned a few improvements that seemed worthwhile to me. Feel free to ignore these if they are not helpful.

llvm/lib/Object/ELFObjectFile.cpp

678

R instead of Relocation to match the RelaDyn code?

Also the RelaPlt code here looks very similar to the RelaDyn code below. I would be tempted to factor out the common parts?

llvm/test/tools/llvm-objdump/X86/plt-got.test

3

Would be nice to expand this comment to also mention more details of the optimisation e.g. dropping the JUMP_SLOT entry.

40

The check for the x86-64 case includes the registers?

62

don't need this empty line

[MaskRay]

address comments

[MaskRay]

In D149817#4342333, @bd1976llvm wrote:

Thanks for working on this and sorry for the lack of response.

Generally looks good, LGTM from me.

I'm happy with the missing corner case for x86-32, given that you mentioned that it is extremely unlikely to occur. Do the GNU tools support that corner case? If they have gone to the trouble to support it I'm wondering if they have a use-case that hasn't occurred to us?
In the description, I think we should have a link to the optimisation in the PS ABI documents in addition to your blog entry.
I wonder if the LLDB folks are aware of this? Might be worth informing them?
I have mentioned a few improvements that seemed worthwhile to me. Feel free to ignore these if they are not helpful.

Thanks for the review! Sorry for the shameless plug. The official psABI mentions combining JUMP_SLOT and GLOB_DAT, but doesn't say anything about .plt.got, or the fact that .got.plt can be omitted...

With int main() {} gcc x.c -o x -z now -fuse-ld=bfd -m32, we don't get .got.plt. If we add a libc function call, a regular PLT will be needed. To omit .got.plt again, we need to take the address of the libc function call. For every PLT we need an address-taken operation in the code.
This is why I said that the corner case nearly never happens in the wild.
It seems that objdump does symbolize .plt.got in this case. I believe it takes quite some code to retrieve the value _GLOBAL_OFFSET_TABLE_.

Thanks for mentioning lldb. This gives me a motivation to study how it performs symbolization...

[bd1976llvm]

In D149817#4344774, @MaskRay wrote:

In D149817#4342333, @bd1976llvm wrote:

Thanks for working on this and sorry for the lack of response.

Generally looks good, LGTM from me.

I'm happy with the missing corner case for x86-32, given that you mentioned that it is extremely unlikely to occur. Do the GNU tools support that corner case? If they have gone to the trouble to support it I'm wondering if they have a use-case that hasn't occurred to us?
In the description, I think we should have a link to the optimisation in the PS ABI documents in addition to your blog entry.
I wonder if the LLDB folks are aware of this? Might be worth informing them?
I have mentioned a few improvements that seemed worthwhile to me. Feel free to ignore these if they are not helpful.

Thanks for the review! Sorry for the shameless plug. The official psABI mentions combining JUMP_SLOT and GLOB_DAT, but doesn't say anything about .plt.got, or the fact that .got.plt can be omitted...

No problem. I have been known to read your blog entries myself :)

With int main() {} gcc x.c -o x -z now -fuse-ld=bfd -m32, we don't get .got.plt. If we add a libc function call, a regular PLT will be needed. To omit .got.plt again, we need to take the address of the libc function call. For every PLT we need an address-taken operation in the code.
This is why I said that the corner case nearly never happens in the wild.
It seems that objdump does symbolize .plt.got in this case. I believe it takes quite some code to retrieve the value _GLOBAL_OFFSET_TABLE_.

Thanks for mentioning lldb. This gives me a motivation to study how it performs symbolization...

Thanks for the extra information, makes sense to me.

LGTM.

llvm/include/llvm/Object/ELFObjectFile.h

 
 namespace object {
 
 constexpr int NumElfSymbolTypes = 16;
 extern const llvm::EnumEntry<unsigned> ElfSymbolTypes[NumElfSymbolTypes];
 
 class elf_symbol_iterator;
 
+struct ELFPltEntry {
+  StringRef Section;
+  std::optional<DataRefImpl> Symbol;
+  uint64_t Address;
+};
+
 class ELFObjectFileBase : public ObjectFile {
   friend class ELFRelocationRef;
   friend class ELFSectionRef;
   friend class ELFSymbolRef;
 
   SubtargetFeatures getMIPSFeatures() const;
   SubtargetFeatures getARMFeatures() const;
   Expected<SubtargetFeatures> getRISCVFeatures() const;
public:
   std::optional<StringRef> tryGetCPUName() const override;
 
   void setARMSubArch(Triple &TheTriple) const override;
 
   virtual uint16_t getEType() const = 0;
 
   virtual uint16_t getEMachine() const = 0;
 
-  std::vector<std::pair<std::optional<DataRefImpl>, uint64_t>>
-  getPltAddresses() const;
+  std::vector<ELFPltEntry> getPltEntries() const;
 
   /// Returns a vector containing a symbol version for each dynamic symbol.
   /// Returns an empty vector if version sections do not exist.
   Expected<std::vector<VersionEntry>> readDynsymVersions() const;
 
   /// Returns a vector of all BB address maps in the object file. When
   // `TextSectionIndex` is specified, only returns the BB address maps
   // corresponding to the section with that index.

llvm/lib/Object/ELFObjectFile.cpp

if (Attr) {
     }
   }
   if (!isLittleEndian())
     Triple += "eb";
 
   TheTriple.setArchName(Triple);
 }
 
-std::vector<std::pair<std::optional<DataRefImpl>, uint64_t>>
-ELFObjectFileBase::getPltAddresses() const {
+std::vector<ELFPltEntry> ELFObjectFileBase::getPltEntries() const {
   std::string Err;
   const auto Triple = makeTriple();
   const auto *T = TargetRegistry::lookupTarget(Triple.str(), Err);
   if (!T)
     return {};
-  uint64_t JumpSlotReloc = 0;
+  uint32_t JumpSlotReloc = 0, GlobDatReloc = 0;
   switch (Triple.getArch()) {
     case Triple::x86:
       JumpSlotReloc = ELF::R_386_JUMP_SLOT;
+      GlobDatReloc = ELF::R_386_GLOB_DAT;
       break;
     case Triple::x86_64:
       JumpSlotReloc = ELF::R_X86_64_JUMP_SLOT;
+      GlobDatReloc = ELF::R_X86_64_GLOB_DAT;
       break;
     case Triple::aarch64:
     case Triple::aarch64_be:
       JumpSlotReloc = ELF::R_AARCH64_JUMP_SLOT;
       break;
     default:
       return {};
   }
   std::unique_ptr<const MCInstrInfo> MII(T->createMCInstrInfo());
   std::unique_ptr<const MCInstrAnalysis> MIA(
       T->createMCInstrAnalysis(MII.get()));
   if (!MIA)
     return {};
-  std::optional<SectionRef> Plt, RelaPlt;
+  std::vector<std::pair<uint64_t, uint64_t>> PltEntries;
+  std::optional<SectionRef> RelaPlt, RelaDyn;
   uint64_t GotBaseVA = 0;
   for (const SectionRef &Section : sections()) {
     Expected<StringRef> NameOrErr = Section.getName();
     if (!NameOrErr) {
       consumeError(NameOrErr.takeError());
       continue;
     }
     StringRef Name = *NameOrErr;
 
-    if (Name == ".plt")
-      Plt = Section;
-    else if (Name == ".rela.plt" || Name == ".rel.plt")
+    if (Name == ".rela.plt" || Name == ".rel.plt") {
       RelaPlt = Section;
-    else if (Name == ".got.plt")
+    } else if (Name == ".rela.dyn" || Name == ".rel.dyn") {
+      RelaDyn = Section;
+    } else if (Name == ".got.plt") {
       GotBaseVA = Section.getAddress();
-  }
-  if (!Plt || !RelaPlt)
-    return {};
-  Expected<StringRef> PltContents = Plt->getContents();
+    } else if (Name == ".plt" || Name == ".plt.got") {
+      Expected<StringRef> PltContents = Section.getContents();
       if (!PltContents) {
         consumeError(PltContents.takeError());
         return {};
       }
-  auto PltEntries = MIA->findPltEntries(
-      Plt->getAddress(), arrayRefFromStringRef(*PltContents), Triple);
+      llvm::append_range(
+          PltEntries,
+          MIA->findPltEntries(Section.getAddress(),
+                              arrayRefFromStringRef(*PltContents), Triple));
+    }
+  }
 
   // Build a map from GOT entry virtual address to PLT entry virtual address.
   DenseMap<uint64_t, uint64_t> GotToPlt;
-  for (auto [Plt, GotPltEntry] : PltEntries) {
+  for (auto [Plt, GotPlt] : PltEntries) {
+    uint64_t GotPltEntry = GotPlt;
     // An x86-32 PIC PLT uses jmp DWORD PTR [ebx-offset]. Add
     // _GLOBAL_OFFSET_TABLE_ (EBX) to get the .got.plt (or .got) entry address.
-    if (static_cast<int64_t>(GotPltEntry) < 0 && getEMachine() == ELF::EM_386)
-      GotPltEntry = ~GotPltEntry + GotBaseVA;
+    // See X86MCTargetDesc.cpp:findPltEntries for the 1 << 32 bit.
+    if (GotPltEntry & (uint64_t(1) << 32) && getEMachine() == ELF::EM_386)
+      GotPltEntry = static_cast<int32_t>(GotPltEntry) + GotBaseVA;
     GotToPlt.insert(std::make_pair(GotPltEntry, Plt));
   }
+
   // Find the relocations in the dynamic relocation table that point to
   // locations in the GOT for which we know the corresponding PLT entry.
-  std::vector<std::pair<std::optional<DataRefImpl>, uint64_t>> Result;
-  for (const auto &Relocation : RelaPlt->relocations()) {
-    if (Relocation.getType() != JumpSlotReloc)
+  std::vector<ELFPltEntry> Result;
+  auto handleRels = [&](iterator_range<relocation_iterator> Rels,
+                        uint32_t RelType, StringRef PltSec) {
+    for (const auto &R : Rels) {
+      if (R.getType() != RelType)
         continue;
-    auto PltEntryIter = GotToPlt.find(Relocation.getOffset());
+      auto PltEntryIter = GotToPlt.find(R.getOffset());
       if (PltEntryIter != GotToPlt.end()) {
-      symbol_iterator Sym = Relocation.getSymbol();
+        symbol_iterator Sym = R.getSymbol();
         if (Sym == symbol_end())
-        Result.emplace_back(std::nullopt, PltEntryIter->second);
+          Result.push_back(
+              ELFPltEntry{PltSec, std::nullopt, PltEntryIter->second});
         else
-        Result.emplace_back(Sym->getRawDataRefImpl(), PltEntryIter->second);
+          Result.push_back(ELFPltEntry{PltSec, Sym->getRawDataRefImpl(),
+                                       PltEntryIter->second});
       }
     }
+  };
+
+  if (RelaPlt)
+    handleRels(RelaPlt->relocations(), JumpSlotReloc, ".plt");
+
+  // If a symbol needing a PLT entry also needs a GLOB_DAT relocation, GNU ld's
+  // x86 port places the PLT entry in the .plt.got section.
+  if (RelaDyn)
+    handleRels(RelaDyn->relocations(), GlobDatReloc, ".plt.got");
+
   return Result;
 }
 
 template <class ELFT>
 Expected<std::vector<BBAddrMap>> static readBBAddrMapImpl(
     const ELFFile<ELFT> &EF, std::optional<unsigned> TextSectionIndex) {
   using Elf_Shdr = typename ELFT::Shdr;
   bool IsRelocatable = EF.getHeader().e_type == ELF::ET_REL;

llvm/lib/Target/X86/MCTargetDesc/X86MCTargetDesc.cpp

 findX86PltEntries(uint64_t PltSectionVA, ArrayRef<uint8_t> PltContents) {
   // Do a lightweight parsing of PLT entries.
   std::vector<std::pair<uint64_t, uint64_t>> Result;
   for (uint64_t Byte = 0, End = PltContents.size(); Byte + 6 < End; ) {
     // Recognize a jmp.
     if (PltContents[Byte] == 0xff && PltContents[Byte + 1] == 0xa3) {
       // The jmp instruction at the beginning of each PLT entry jumps to the
       // address of the base of the .got.plt section plus the immediate.
+      // Set the 1 << 32 bit to let ELFObjectFileBase::getPltEntries convert the
+      // offset to an address. Imm may be a negative int32_t if the GOT entry is
+      // in .got.
       uint32_t Imm = support::endian::read32le(PltContents.data() + Byte + 2);
-      Result.emplace_back(PltSectionVA + Byte, ~static_cast<uint64_t>(Imm));
+      Result.emplace_back(PltSectionVA + Byte, Imm | (uint64_t(1) << 32));
       Byte += 6;
     } else if (PltContents[Byte] == 0xff && PltContents[Byte + 1] == 0x25) {
       // The jmp instruction at the beginning of each PLT entry jumps to the
       // immediate.
       uint32_t Imm = support::endian::read32le(PltContents.data() + Byte + 2);
       Result.push_back(std::make_pair(PltSectionVA + Byte, Imm));
       Byte += 6;
     } else

llvm/test/tools/llvm-objdump/X86/plt-got.test

+## If a symbol needing a PLT entry also needs a GLOB_DAT relocation, GNU ld's
+## x86 port places the PLT entry in .plt.got, relocated by a GLOB_DAT. The
+## JUMP_SLOT relocation is unused in this case.
+## Test that we synthesize @plt symbols for such PLT entries.
+# RUN: yaml2obj --docnum=1 %s -o %t.x86-64
+# RUN: llvm-objdump -d %t.x86-64 | FileCheck %s --check-prefix=64
+# RUN: yaml2obj --docnum=2 %s -o %t.x86-32
+# RUN: llvm-objdump -d %t.x86-32 | FileCheck %s --check-prefix=32
+
+# 64:      Disassembly of section .plt:
+# 64-EMPTY:
+# 64-NEXT: <.plt>:
+# 64:      <foo1@plt>:
+# 64:      <foo0@plt>:
+
+# 64:      Disassembly of section .plt.got:
+# 64-EMPTY:
+# 64-NEXT: <combined0@plt>:
+# 64:      <combined1@plt>:
+
+# 64:      <_start>:
+# 64-NEXT:   movq    {{.*}}(%rip), %rax
+# 64-NEXT:   movq    {{.*}}(%rip), %rax
+# 64-NEXT:   callq   {{.*}} <combined0@plt>
+# 64-NEXT:   callq   {{.*}} <combined1@plt>
+# 64-NEXT:   callq   {{.*}} <foo0@plt>
+# 64-NEXT:   callq   {{.*}} <foo1@plt>
+
+# 32:      Disassembly of section .plt:
+# 32-EMPTY:
+# 32-NEXT: <.plt>:
+# 32:      <foo1@plt>:
+# 32:      <foo0@plt>:
+
+# 32:      Disassembly of section .plt.got:
+# 32-EMPTY:
+# 32-NEXT: <combined0@plt>:
+# 32:      <combined1@plt>:
+
+# 32:      <_start>:
+# 32-NEXT:   movl    -0x8(%eax), %eax
+# 32-NEXT:   movl    -0x4(%eax), %eax
+# 32-NEXT:   calll   {{.*}} <combined0@plt>
+# 32-NEXT:   calll   {{.*}} <combined1@plt>
+# 32-NEXT:   calll   {{.*}} <foo0@plt>
+# 32-NEXT:   calll   {{.*}} <foo1@plt>
+
+## %t.x86-64 is linked with ld.bfd -pie -z now a.o b.so and
+## doesn't have .got.plt.
+## %t.x86-32 is linked with ld.bfd -pie -z lazy a.o b.so and
+## has .got.plt.
+
+## a.s
+## .globl _start; _start:
+## mov combined0@gotpcrel(%rip), %rax  # movl combined0@GOT(%eax), %eax  for x86-32
+## mov combined1@gotpcrel(%rip), %rax  # movl combined1@GOT(%eax), %eax  for x86-32
+## call combined0@plt
+## call combined1@plt
+## call foo0@plt
+## call foo1@plt
+
+## b.s
+## .globl foo0, foo1, combined0, combined1
+## foo0: foo1: combined0: combined1:
+
+--- !ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_DYN
+  Machine:         EM_X86_64
+  Entry:           0x1040
+Sections:
+  - Name:            .rela.dyn
+    Type:            SHT_RELA
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x340
+    Link:            .dynsym
+    AddressAlign:    0x8
+    Relocations:
+      - Offset:          0x2FF0
+        Symbol:          combined0
+        Type:            R_X86_64_GLOB_DAT
+      - Offset:          0x2FF8
+        Symbol:          combined1
+        Type:            R_X86_64_GLOB_DAT
+  - Name:            .rela.plt
+    Type:            SHT_RELA
+    Flags:           [ SHF_ALLOC, SHF_INFO_LINK ]
+    Address:         0x370
+    Link:            .dynsym
+    AddressAlign:    0x8
+    Info:            .got
+    Relocations:
+      - Offset:          0x2FE0
+        Symbol:          foo1
+        Type:            R_X86_64_JUMP_SLOT
+      - Offset:          0x2FE8
+        Symbol:          foo0
+        Type:            R_X86_64_JUMP_SLOT
+  - Name:            .plt
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:         0x1000
+    AddressAlign:    0x10
+    EntSize:         0x10
+    Offset:          0x1000
+    Content:         FF35CA1F0000FF25CC1F00000F1F4000FF25CA1F00006800000000E9E0FFFFFFFF25C21F00006801000000E9D0FFFFFF
+  - Name:            .plt.got
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:         0x1030
+    AddressAlign:    0x8
+    EntSize:         0x8
+    Content:         FF25BA1F00006690FF25BA1F00006690
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:         0x1040
+    AddressAlign:    0x1
+    Content:         488B05A91F0000488B05AA1F0000E8DDFFFFFFE8E0FFFFFFE8C3FFFFFFE8AEFFFFFF
+  - Name:            .got
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    Address:         0x2FC8
+    AddressAlign:    0x8
+    EntSize:         0x8
+    Content:         '682E000000000000000000000000000000000000000000001610000000000000261000000000000000000000000000000000000000000000'
+Symbols:
+  - Name:            _start
+    Section:         .text
+    Binding:         STB_GLOBAL
+    Value:           0x1040
+DynamicSymbols:
+  - Name:            foo1
+    Binding:         STB_GLOBAL
+  - Name:            foo0
+    Binding:         STB_GLOBAL
+  - Name:            combined0
+    Binding:         STB_GLOBAL
+  - Name:            combined1
+    Binding:         STB_GLOBAL
+...
+
+--- !ELF
+FileHeader:
+  Class:           ELFCLASS32
+  Data:            ELFDATA2LSB
+  Type:            ET_DYN
+  Machine:         EM_386
+  Entry:           0x1040
+Sections:
+  - Name:            .rel.dyn
+    Type:            SHT_REL
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x218
+    Link:            .dynsym
+    AddressAlign:    0x4
+    Relocations:
+      - Offset:          0x2FEC
+        Symbol:          combined0
+        Type:            R_386_GLOB_DAT
+      - Offset:          0x2FF0
+        Symbol:          combined1
+        Type:            R_386_GLOB_DAT
+  - Name:            .rel.plt
+    Type:            SHT_REL
+    Flags:           [ SHF_ALLOC, SHF_INFO_LINK ]
+    Address:         0x228
+    Link:            .dynsym
+    AddressAlign:    0x4
+    Info:            .got.plt
+    Relocations:
+      - Offset:          0x3000
+        Symbol:          foo1
+        Type:            R_386_JUMP_SLOT
+      - Offset:          0x3004
+        Symbol:          foo0
+        Type:            R_386_JUMP_SLOT
+  - Name:            .plt
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:         0x1000
+    AddressAlign:    0x10
+    EntSize:         0x4
+    Offset:          0x1000
+    Content:         FFB304000000FFA30800000000000000FFA30C0000006800000000E9E0FFFFFFFFA3100000006808000000E9D0FFFFFF
+  - Name:            .plt.got
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:         0x1030
+    AddressAlign:    0x8
+    EntSize:         0x8
+    Content:         FFA3F8FFFFFF6690FFA3FCFFFFFF6690
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:         0x1040
+    AddressAlign:    0x1
+    Content:         8B80F8FFFFFF8B80FCFFFFFFE8DFFFFFFFE8E2FFFFFFE8C5FFFFFFE8B0FFFFFF
+  - Name:            .got
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    Address:         0x2FEC
+    AddressAlign:    0x4
+    EntSize:         0x4
+    Content:         '0000000000000000'
+  - Name:            .got.plt
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    Address:         0x2FF4
+    AddressAlign:    0x4
+    EntSize:         0x4
+    Content:         442F000000000000000000001610000026100000
+Symbols:
+  - Name:            _GLOBAL_OFFSET_TABLE_
+    Type:            STT_OBJECT
+    Section:         .got.plt
+    Value:           0x2FF4
+  - Name:            _start
+    Section:         .text
+    Binding:         STB_GLOBAL
+    Value:           0x1040
+DynamicSymbols:
+  - Name:            combined0
+    Binding:         STB_GLOBAL
+  - Name:            foo1
+    Binding:         STB_GLOBAL
+  - Name:            foo0
+    Binding:         STB_GLOBAL
+  - Name:            combined1
+    Binding:         STB_GLOBAL
+...

llvm/tools/llvm-cfi-verify/lib/FileAnalysis.cpp

else if (TrapOnFailFunctions.contains(*SymNameOrErr)) {
       auto AddrOrErr = Sym.getAddress();
       if (!AddrOrErr)
         consumeError(AddrOrErr.takeError());
       else
         TrapOnFailFunctionAddresses.insert(*AddrOrErr);
     }
   }
   if (auto *ElfObject = dyn_cast<object::ELFObjectFileBase>(Object)) {
-    for (const auto &Addr : ElfObject->getPltAddresses()) {
-      if (!Addr.first)
+    for (const auto &Plt : ElfObject->getPltEntries()) {
+      if (!Plt.Symbol)
         continue;
-      object::SymbolRef Sym(*Addr.first, Object);
+      object::SymbolRef Sym(*Plt.Symbol, Object);
       auto SymNameOrErr = Sym.getName();
       if (!SymNameOrErr)
         consumeError(SymNameOrErr.takeError());
       else if (TrapOnFailFunctions.contains(*SymNameOrErr))
-        TrapOnFailFunctionAddresses.insert(Addr.second);
+        TrapOnFailFunctionAddresses.insert(Plt.Address);
     }
   }
   return Error::success();
 }
 
 UnsupportedDisassembly::UnsupportedDisassembly(StringRef Text)
     : Text(std::string(Text)) {}
 

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

 }
 
 static void addPltEntries(const ObjectFile &Obj,
                           std::map<SectionRef, SectionSymbolsTy> &AllSymbols,
                           StringSaver &Saver) {
   auto *ElfObj = dyn_cast<ELFObjectFileBase>(&Obj);
   if (!ElfObj)
     return;
-  std::optional<SectionRef> Plt;
-  for (const SectionRef &Section : Obj.sections()) {
+  DenseMap<StringRef, SectionRef> Sections;
+  for (SectionRef Section : Obj.sections()) {
     Expected<StringRef> SecNameOrErr = Section.getName();
     if (!SecNameOrErr) {
       consumeError(SecNameOrErr.takeError());
       continue;
     }
-    if (*SecNameOrErr == ".plt")
-      Plt = Section;
+    Sections[*SecNameOrErr] = Section;
   }
-  if (!Plt)
-    return;
-  for (auto PltEntry : ElfObj->getPltAddresses()) {
-    if (PltEntry.first) {
-      SymbolRef Symbol(*PltEntry.first, ElfObj);
+  for (auto Plt : ElfObj->getPltEntries()) {
+    if (Plt.Symbol) {
+      SymbolRef Symbol(*Plt.Symbol, ElfObj);
       uint8_t SymbolType = getElfSymbolType(Obj, Symbol);
       if (Expected<StringRef> NameOrErr = Symbol.getName()) {
         if (!NameOrErr->empty())
-          AllSymbols[*Plt].emplace_back(
-              PltEntry.second, Saver.save((*NameOrErr + "@plt").str()),
-              SymbolType);
+          AllSymbols[Sections[Plt.Section]].emplace_back(
+              Plt.Address, Saver.save((*NameOrErr + "@plt").str()), SymbolType);
         continue;
       } else {
         // The warning has been reported in disassembleObject().
         consumeError(NameOrErr.takeError());
       }
     }
-    reportWarning("PLT entry at 0x" + Twine::utohexstr(PltEntry.second) +
+    reportWarning("PLT entry at 0x" + Twine::utohexstr(Plt.Address) +
                       " references an invalid symbol",
                   Obj.getFileName());
   }
 }
 
 // Normally the disassembly output will skip blocks of zeroes. This function
 // returns the number of zero bytes that can be skipped when dumping the
 // disassembly of the instructions in Buf.