[LLD] [ELF] Add emission of an optional linkmap section

[bd1976llvm]

Summary

This adds the emission of an optional section, .debug_lld_linkmap, to the output.
The .debug_lld_linkmap section contains a list of entries that describe how the linker has mapped input sections to address regions.

The section starts with a header consisting of two fields:

length (uleb)

The length in bytes of the linkmap data not including the length field itself. 
This allows for padding to be added to the section, useful for purposes such as slop for incremental linking. The value cannot exceed Elf_Off.

version (uleb)

The version of this description information. Currently, 0. The value cannot exceed Elf_Word.

The header is followed by a single field:

entries (uleb)

The number of entries in this section.
This allows for pre-allocating an array of entry structures.
The value cannot exceed Elf_Off.

Followed by a list of entries. Each entry describes a section from an input file and its location in the runtime memory image of the output. Entries are composed of 4 ulebs:

File (uleb)

An offset into the .debug_lld_linkmap_str section.
The associated string contains the path of an object file that was a linker input.
The value cannot exceed Elf_Off.

Section (uleb)

An offset into the .debug_lld_linkmap_str section.
The associated string contains the name of an ELF section from the file identified by the first field in this entry.
The value cannot exceed Elf_Off.

Address (uleb)

The virtual address that the linker assigned to the section.
The value cannot exceed Elf_Addr.

Size (uleb)

The size of the section in the run-time memory image.
The value cannot exceed Elf_Off.

ELF section header fields are:

Property	Value
sh_type	SHT_DEBUG_LLD_LINKMAP
sh_flags	0
sh_addr	0
sh_offset	offset of the section in the file
sh_size	section size
sh_link	index of the corresponding .debug_lld_linkmap_str section
sh_info	0
sh_addralign	1
sh_entsize	1

See corresponding RFC for motivation: https://lists.llvm.org/pipermail/llvm-dev/2021-September/152697.html

Note that .debug_lld_linkmap provides similar information to the -Map option. However, emitting the section is *much* more efficient than generating a -Map file. Testing with a chromium package on my windows development box, I recorded the following results with this patch:

Base link = 3.524 s
With -Map =8.441 s
With --debug-sections = 3.910 s.

The additional information occupied 20% of the chromium ELF size (compiled without debugging data).

[bd1976llvm]

Fix linux build and formatting issues.

[bd1976llvm]

Fix off-by-one problem.

lld/ELF/Config.h

struct Configuration {
   bool asNeeded = false;
   BsymbolicKind bsymbolic = BsymbolicKind::None;
   bool callGraphProfileSort;
   bool checkSections;
   bool checkDynamicRelocs;
   bool compressDebugSections;
   bool cref;
   std::vector<std::pair<llvm::GlobPattern, uint64_t>> deadRelocInNonAlloc;
+  bool debugSections = false;
   bool defineCommon;
   bool demangle = true;
   bool dependentLibraries;
   bool disableVerify;
   bool ehFrameHdr;
   bool emitLLVM;
   bool emitRelocs;
   bool enableNewDtags;

lld/ELF/Driver.cpp

if (!config->shared && !config->auxiliaryList.empty())
     error("-f may not be used without -shared");
 
   if (!config->relocatable && !config->defineCommon)
     error("-no-define-common not supported in non relocatable output");
 
   if (config->strip == StripPolicy::All && config->emitRelocs)
     error("--strip-all and --emit-relocs may not be used together");
 
+  if (config->strip == StripPolicy::All && config->debugSections)
+    error("--strip-all and --debug-sections may not be used together");
+
   if (config->zText && config->zIfuncNoplt)
     error("-z text and -z ifunc-noplt may not be used together");
 
   if (config->relocatable) {
     if (config->shared)
       error("-r and -shared may not be used together");
     if (config->gdbIndex)
       error("-r and --gdb-index may not be used together");
     if (config->icf != ICFLevel::None)
       error("-r and --icf may not be used together");
     if (config->pie)
       error("-r and -pie may not be used together");
     if (config->exportDynamic)
       error("-r and --export-dynamic may not be used together");
+    if (config->debugSections)
+      error("-r and --debug-sections may not be used together");
   }
 
   if (config->executeOnly) {
     if (config->emachine != EM_AARCH64)
       error("-execute-only is only supported on AArch64 targets");
 
     if (config->singleRoRx && !script->hasSectionsCommand)
       error("-execute-only and -no-rosegment cannot be used together");
else if (s == "both")
       config->sysvHash = config->gnuHash = true;
     else
       error("unknown -hash-style: " + s);
   }
 
   if (args.hasArg(OPT_print_map))
     config->mapFile = "-";
 
+  if (args.hasArg(OPT_debug_sections))
+    config->debugSections = true;
+
   // Page alignment can be disabled by the -n (--nmagic) and -N (--omagic).
   // As PT_GNU_RELRO relies on Paging, do not create it when we have disabled
   // it.
   if (config->nmagic || config->omagic)
     config->zRelro = false;
 
   std::tie(config->buildId, config->buildIdVector) = getBuildId(args);
 

lld/ELF/Options.td

defm wrap : Eq<"wrap", "Redirect symbol references to __wrap_symbol and "
             MetaVarName<"<symbol>">;
 
 def z: JoinedOrSeparate<["-"], "z">, MetaVarName<"<option>">,
   HelpText<"Linker option extensions">;
 
 def visual_studio_diagnostics_format : F<"vs-diagnostics">,
 HelpText<"Format diagnostics for Visual Studio compatibility">;
 
+def debug_sections : F<"debug-sections">, HelpText<"Emit debug sections that describe the output">;
+
 // Aliases
 def: Separate<["-"], "f">, Alias<auxiliary>, HelpText<"Alias for --auxiliary">;
 def: F<"call_shared">, Alias<Bdynamic>, HelpText<"Alias for --Bdynamic">;
 def: F<"dy">, Alias<Bdynamic>, HelpText<"Alias for --Bdynamic">;
 def: F<"dn">, Alias<Bstatic>, HelpText<"Alias for --Bstatic">;
 def: F<"non_shared">, Alias<Bstatic>, HelpText<"Alias for --Bstatic">;
 def: F<"static">, Alias<Bstatic>, HelpText<"Alias for --Bstatic">;
 def: Flag<["-"], "d">, Alias<define_common>, HelpText<"Alias for --define-common">;

lld/ELF/OutputSections.cpp

void OutputSection::commitSection(InputSection *isec) {
 
   alignment = std::max(alignment, isec->alignment);
 
   // If this section contains a table of fixed-size entries, sh_entsize
   // holds the element size. If it contains elements of different size we
   // set sh_entsize to 0.
   if (entsize != isec->entsize)
     entsize = 0;
+
+  if (config->debugSections)
+    in.debugLinkMap->addSection(isec);
 }
 
 // This function scans over the InputSectionBase list sectionBases to create
 // InputSectionDescription::sections.
 //
 // It removes MergeInputSections from the input section array and adds
 // new synthetic sections at the location of the first input section
 // that it replaces. It then finalizes each synthetic section in order

lld/ELF/SyntheticSections.h

 public:
   EhFrameHeader();
   void write();
   void writeTo(uint8_t *buf) override;
   size_t getSize() const override;
   bool isNeeded() const override;
 };
 
+class DebugLinkMapSection final : public SyntheticSection {
+public:
+  DebugLinkMapSection(StringTableSection &strTab);
+  void writeTo(uint8_t *buf) override;
+  size_t getSize() const override;
+  void addSection(InputSectionBase *isec);
+  StringTableSection *getStrTab() { return &strTab; }
+  void finalizeContents() override;
+
+private:
+  std::vector<InputSection *> sections;
+  StringTableSection &strTab;
+
+  SmallVector<char, 0> sizeField;
+  SmallVector<char, 0> content;
+};
+
 // For more information about .gnu.version and .gnu.version_r see:
 // https://www.akkadia.org/drepper/symbol-versioning
 
 // The .gnu.version_d section which has a section type of SHT_GNU_verdef shall
 // contain symbol version definitions. The number of entries in this section
 // shall be contained in the DT_VERDEFNUM entry of the .dynamic section.
 // The section shall contain an array of Elf_Verdef structures, optionally
 // followed by an array of Elf_Verdaux structures.
struct InStruct {
   IgotPltSection *igotPlt;
   PPC64LongBranchTargetSection *ppc64LongBranchTarget;
   MipsGotSection *mipsGot;
   MipsRldMapSection *mipsRldMap;
   SyntheticSection *partEnd;
   SyntheticSection *partIndex;
   PltSection *plt;
   IpltSection *iplt;
+  DebugLinkMapSection *debugLinkMap;
   PPC32Got2Section *ppc32Got2;
   IBTPltSection *ibtPlt;
   RelocationBaseSection *relaPlt;
   RelocationBaseSection *relaIplt;
   StringTableSection *shStrTab;
   StringTableSection *strTab;
   SymbolTableBaseSection *symTab;
   SymtabShndxSection *symTabShndx;
 };
 
 extern InStruct in;
 
 } // namespace elf
 } // namespace lld
 
 #endif

lld/ELF/SyntheticSections.cpp

void EhFrameSection::writeTo(uint8_t *buf) {
   // getOffset() takes care of discontiguous section pieces.
   for (EhInputSection *s : sections)
     s->relocateAlloc(buf, nullptr);
 
   if (getPartition().ehFrameHdr && getPartition().ehFrameHdr->getParent())
     getPartition().ehFrameHdr->write();
 }
 
+DebugLinkMapSection::DebugLinkMapSection(StringTableSection &strTab)
+    : SyntheticSection(0, SHT_DEBUG_LLD_LINKMAP, 0, ".debug_lld_linkmap"),
+      strTab(strTab) {
+  this->entsize = 1;
+}
+
+size_t DebugLinkMapSection::getSize() const {
+  return sizeField.size() + content.size();
+}
+
+void DebugLinkMapSection::writeTo(uint8_t *buf) {
+  memcpy(buf, sizeField.data(), sizeField.size());
+  memcpy(buf + sizeField.size(), content.data(), content.size());
+}
+
+void DebugLinkMapSection::addSection(InputSectionBase *i) {
+  auto *isec = dyn_cast<InputSection>(i);
+  if (!isec || !isec->file || (isec->getSize() == 0))
+    return;
+  sections.push_back(isec);
+}
+
+void DebugLinkMapSection::finalizeContents() {
+  assert(getParent() && strTab.getParent());
+  getParent()->link = strTab.getParent()->sectionIndex;
+
+  raw_svector_ostream os(content);
+  auto add = [&](int64_t v) { encodeULEB128(v, os); };
+
+  add(0);               // Version
+  add(sections.size()); // Entry count
+
+  for (InputSection *isec : sections) {
+    StringRef secName = isec->name;
+    add(strTab.addString(StringRef(toString(isec->file)).copy(bAlloc),
+                         true));    // Filename
+    add(strTab.addString(secName)); // Section Name
+    add(isec->parent->getOutputSection()->addr + isec->outSecOff); // Address
+    add(isec->getSize());                                          // Size
+  }
+
+  // Finally calcuate the contents of the size field.
+  raw_svector_ostream sizeFieldOS(sizeField);
+  encodeULEB128(content.size(), sizeFieldOS);
+}
+
 GotSection::GotSection()
     : SyntheticSection(SHF_ALLOC | SHF_WRITE, SHT_PROGBITS,
                        target->gotEntrySize, ".got") {
   numEntries = target->gotHeaderEntriesNum;
 }
 
 void GotSection::addEntry(Symbol &sym) {
   sym.gotIndex = numEntries;

lld/ELF/Writer.cpp

for (size_t i = 1; i <= partitions.size(); ++i) {
       InputSection *sec = createInterpSection();
       sec->partition = i;
       inputSections.push_back(sec);
     }
   }
 
   auto add = [](SyntheticSection *sec) { inputSections.push_back(sec); };
 
+  if (config->debugSections) {
+    auto *debugLinkMapStrTab =
+        make<StringTableSection>(".debug_lld_linkmap_str", false);
+    debugLinkMapStrTab->type = SHT_PROGBITS;
+    add(debugLinkMapStrTab);
+
+    in.debugLinkMap = make<DebugLinkMapSection>(*debugLinkMapStrTab);
+    add(in.debugLinkMap);
+  }
+
   in.shStrTab = make<StringTableSection>(".shstrtab", false);
 
   Out::programHeaders = make<OutputSection>("", 0, SHF_ALLOC);
   Out::programHeaders->alignment = config->wordsize;
 
   if (config->strip != StripPolicy::All) {
     in.strTab = make<StringTableSection>(".strtab", false);
     in.symTab = make<SymbolTableSection<ELFT>>(*in.strTab);
template <class ELFT> void Writer<ELFT>::finalizeSections() {
   {
     llvm::TimeTraceScope timeScope("Finalize synthetic sections");
     // finalizeAddressDependentContent may have added local symbols to the
     // static symbol table.
     finalizeSynthetic(in.symTab);
     finalizeSynthetic(in.ppc64LongBranchTarget);
   }
 
+  if (config->debugSections) {
+    llvm::TimeTraceScope timeScope("Finalize debug sections");
+    // Finalize these now. They use variable length encoding
+    // and refer to section by address. So, we need the layout
+    // to be fixed before we know the size of these sections.
+    auto *debugLinkMap = in.debugLinkMap;
+    auto *debugLinkMapStrTab =
+        debugLinkMap ? debugLinkMap->getStrTab() : nullptr;
+    finalizeSynthetic(debugLinkMapStrTab);
+    finalizeSynthetic(in.debugLinkMap);
+
+    // Respin the layout to account for the final sizes
+    // of these sections.
+    script->assignAddresses();
+  }
+
   // Relaxation to delete inter-basic block jumps created by basic block
   // sections. Run after in.symTab is finalized as optimizeBasicBlockJumps
   // can relax jump instructions based on symbol offset.
   if (config->optimizeBBJumps)
     optimizeBasicBlockJumps();
 
   // Fill other section headers. The dynamic table is finalized
   // at the end because some tags like RELSZ depend on result

lld/test/ELF/debug_lld_linkmap.s

+## Show that the linkmap section is emitted correctly.
+
+# RUN: rm -rf %t.dir
+# RUN: split-file %s %t.dir
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %t.dir/1.s -o %t.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %t.dir/2.s -o %t2.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %t.dir/3.s -o %t3.o
+# RUN: llvm-ar rc %t.dir/archive.a %t2.o
+# RUN: llvm-ar rcT %t.dir/thin.a %t3.o
+
+## Sanity check that the metadata section is not emitted without --debug-sections.
+# RUN: ld.lld %t.o %t.dir/archive.a %t.dir/thin.a --build-id=none -o %t.default.elf
+# RUN: llvm-readelf --debug_lld_linkmap %t.default.elf 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=NOLINKMAP --allow-empty --implicit-check-not=warning:
+
+# NOLINKMAP-NOT:      DebugLLDLinkMap {
+
+## Show that the linkmap section headers and contents are as expected.
+# RUN: ld.lld %t.o %t.dir/archive.a %t.dir/thin.a --build-id=none -o %t.elf --debug-sections
+# RUN: llvm-readelf --sections --debug_lld_linkmap %t.elf 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=CONTENT --match-full-lines --implicit-check-not=warning: \
+# RUN:    -DOBJECT=%t.o \
+# RUN:      -DARDIR=%t.dir -DFARCHIVE='archive.a(%basename_t.tmp2.o)' \
+# RUN:        -DTARCHIVE='thin.a(%/t3.o)'
+
+# CONTENT:      Section Headers:
+# CONTENT-NEXT:   [Nr] Name             Type     Address            {{.*}} ES Flg Lk Inf Al
+# CONTENT-DAG:  {{.*}} .text            PROGBITS [[#%.16x,TEXTAD:]] {{.*}} 
+# CONTENT-DAG:  {{.*}} .data            PROGBITS [[#%.16x,DATAAD:]] {{.*}}
+# CONTENT-DAG:  {{.*}} .debug_lld_linkmap_str PROGBITS  0000000000000000 {{.*}} 00      0   0  1
+# CONTENT-DAG:  {{.*}} .debug_lld_linkmap DEBUG_LLD_LINKMAP 0000000000000000 {{.*}} 01       4   0  1
+
+
+# CONTENT:      DebugLLDLinkMap {
+# CONTENT-NEXT:   Length: 48
+# CONTENT-NEXT:   Version: 0
+# CONTENT-NEXT:   Entry Count: 6
+# CONTENT-NEXT:   Entry {
+# CONTENT-NEXT:     FileName: [[OBJECT]]
+# CONTENT-NEXT:     Section: .text.main
+# CONTENT-NEXT:     Address: 0x[[#%X,TEXTAD]]
+# CONTENT-NEXT:     Size: 10
+# CONTENT-NEXT:   }
+# CONTENT-NEXT:   Entry {
+# CONTENT-NEXT:     FileName: [[OBJECT]]
+# CONTENT-NEXT:     Section: .text.other
+# CONTENT-NEXT:     Address: 0x[[#%X,TEXTAD+10]]
+# CONTENT-NEXT:     Size: 10
+# CONTENT-NEXT:   }
+# CONTENT-NEXT:   Entry {
+# CONTENT-NEXT:     FileName: [[ARDIR]]{{[\\/]}}[[FARCHIVE]]
+# CONTENT-NEXT:     Section: .text.main
+# CONTENT-NEXT:     Address: 0x[[#%X,TEXTAD+20]]
+# CONTENT-NEXT:     Size: 5
+# CONTENT-NEXT:   }
+# CONTENT-NEXT:   Entry {
+# CONTENT-NEXT:     FileName: [[ARDIR]]{{[\\/]}}[[FARCHIVE]]
+# CONTENT-NEXT:     Section: .text.local
+# CONTENT-NEXT:     Address: 0x[[#%X,TEXTAD+25]]
+# CONTENT-NEXT:     Size: 1
+# CONTENT-NEXT:   }
+# CONTENT-NEXT:   Entry {
+# CONTENT-NEXT:     FileName: [[OBJECT]]
+# CONTENT-NEXT:     Section: .data
+# CONTENT-NEXT:     Address: 0x[[#%X,DATAAD]]
+# CONTENT-NEXT:     Size: 4
+# CONTENT-NEXT:   }
+# CONTENT-NEXT:   Entry {
+# CONTENT-NEXT:     FileName: [[ARDIR]]{{[\\/]}}[[TARCHIVE]]
+# CONTENT-NEXT:     Section: .data
+# CONTENT-NEXT:     Address: 0x[[#%X,DATAAD+4]]
+# CONTENT-NEXT:     Size: 8
+# CONTENT-NEXT:   }
+# CONTENT-NEXT: }
+
+## Show that the option is the help text.
+# RUN: ld.lld --help | FileCheck %s --check-prefix=HELP
+
+# HELP: {{^}}  --debug-sections{{ }}
+
+#--- 1.s
+.section .text.main,"ax",@progbits
+.global main
+main:
+  call bar
+  call other
+
+## Different contribution to same output section gets separate entry.
+.section .text.other,"ax",@progbits
+.global other
+other:
+  call foo
+  call thin
+
+## Empty section doesn't result in a linkmap entry.
+.section .text.empty,"ax",@progbits
+
+## Different contribution in different output section gets own entry.
+.data
+.global foo
+foo:
+.long 0x42
+
+#--- 2.s
+## Regular archive member has correct entries.
+
+## Same-named contribution in different file gets separate entry.
+.section .text.main,"ax",@progbits
+.global bar
+bar:
+  call local
+
+## Section only containing local symbols gets entry.
+.section .text.local,"ax",@progbits
+local:
+  ret
+
+#--- 3.s
+## Thin archive member has correct entry. 
+
+.data
+.weak thin
+thin:
+.quad 0x24

llvm/include/llvm/BinaryFormat/ELF.h

SHT_LLVM_ADDRSIG = 0x6fff4c03,        // List of address-significant symbols
                                         // for safe ICF.
   SHT_LLVM_DEPENDENT_LIBRARIES =
       0x6fff4c04,                    // LLVM Dependent Library Specifiers.
   SHT_LLVM_SYMPART = 0x6fff4c05,     // Symbol partition specification.
   SHT_LLVM_PART_EHDR = 0x6fff4c06,   // ELF header for loadable partition.
   SHT_LLVM_PART_PHDR = 0x6fff4c07,   // Phdrs for loadable partition.
   SHT_LLVM_BB_ADDR_MAP = 0x6fff4c08, // LLVM Basic Block Address Map.
   SHT_LLVM_CALL_GRAPH_PROFILE = 0x6fff4c09, // LLVM Call Graph Profile.
+  SHT_DEBUG_LLD_LINKMAP = 0x6fff4c0d,
   // Android's experimental support for SHT_RELR sections.
   // https://android.googlesource.com/platform/bionic/+/b7feec74547f84559a1467aca02708ff61346d2a/libc/include/elf.h#512
   SHT_ANDROID_RELR = 0x6fffff00,   // Relocation entries; only offsets.
   SHT_GNU_ATTRIBUTES = 0x6ffffff5, // Object attributes.
   SHT_GNU_HASH = 0x6ffffff6,       // GNU-style hash table.
   SHT_GNU_verdef = 0x6ffffffd,     // GNU version definitions.
   SHT_GNU_verneed = 0x6ffffffe,    // GNU version references.
   SHT_GNU_versym = 0x6fffffff,     // GNU symbol versions table.

llvm/lib/Object/ELF.cpp

switch (Type) {
     STRINGIFY_ENUM_CASE(ELF, SHT_SYMTAB_SHNDX);
     STRINGIFY_ENUM_CASE(ELF, SHT_RELR);
     STRINGIFY_ENUM_CASE(ELF, SHT_ANDROID_REL);
     STRINGIFY_ENUM_CASE(ELF, SHT_ANDROID_RELA);
     STRINGIFY_ENUM_CASE(ELF, SHT_ANDROID_RELR);
     STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_ODRTAB);
     STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_LINKER_OPTIONS);
     STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_CALL_GRAPH_PROFILE);
+    STRINGIFY_ENUM_CASE(ELF, SHT_DEBUG_LLD_LINKMAP);
     STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_ADDRSIG);
     STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_DEPENDENT_LIBRARIES);
     STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_SYMPART);
     STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_PART_EHDR);
     STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_PART_PHDR);
     STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_BB_ADDR_MAP);
     STRINGIFY_ENUM_CASE(ELF, SHT_GNU_ATTRIBUTES);
     STRINGIFY_ENUM_CASE(ELF, SHT_GNU_HASH);

llvm/tools/llvm-readobj/ELFDumper.cpp

public:
   void printNeededLibraries() override;
   void printHashTable() override;
   void printGnuHashTable() override;
   void printLoadName() override;
   void printVersionInfo() override;
   void printArchSpecificInfo() override;
   void printStackMap() const override;
 
+  void printDebugLLDLinkMap() override;
   const object::ELFObjectFile<ELFT> &getElfObject() const { return ObjF; };
 
   std::string describe(const Elf_Shdr &Sec) const;
 
   unsigned getHashTableEntSize() const {
     // EM_S390 and ELF::EM_ALPHA platforms use 8-bytes entries in SHT_HASH
     // sections. This violates the ELF specification.
     if (Obj.getHeader().e_machine == ELF::EM_S390 ||
protected:
   DynRegionInfo DynSymTabShndxRegion;
   DynRegionInfo DynamicTable;
   StringRef DynamicStringTable;
   const Elf_Hash *HashTable = nullptr;
   const Elf_GnuHash *GnuHashTable = nullptr;
   const Elf_Shdr *DotSymtabSec = nullptr;
   const Elf_Shdr *DotDynsymSec = nullptr;
   const Elf_Shdr *DotAddrsigSec = nullptr;
+  const Elf_Shdr *DotDebugLLDLinkMap = nullptr;
   DenseMap<const Elf_Shdr *, ArrayRef<Elf_Word>> ShndxTables;
   Optional<uint64_t> SONameOffset;
   Optional<DenseMap<uint64_t, std::vector<uint32_t>>> AddressToIndexMap;
 
   const Elf_Shdr *SymbolVersionSection = nullptr;   // .gnu.version
   const Elf_Shdr *SymbolVersionNeedSection = nullptr; // .gnu.version_r
   const Elf_Shdr *SymbolVersionDefSection = nullptr; // .gnu.version_d
 
for (const Elf_Shdr &Sec : Sections) {
     case ELF::SHT_GNU_verneed:
       if (!SymbolVersionNeedSection)
         SymbolVersionNeedSection = &Sec;
       break;
     case ELF::SHT_LLVM_ADDRSIG:
       if (!DotAddrsigSec)
         DotAddrsigSec = &Sec;
       break;
+    case ELF::SHT_DEBUG_LLD_LINKMAP:
+      if (!DotDebugLLDLinkMap)
+        DotDebugLLDLinkMap = &Sec;
+      break;
     }
   }
 
   loadDynamicTable();
 }
 
 template <typename ELFT> void ELFDumper<ELFT>::parseDynamicTable() {
   auto toMappedAddr = [&](uint64_t Tag, uint64_t VAddr) -> const uint8_t * {
template <typename ELFT> void ELFDumper<ELFT>::printVersionInfo() {
 
   // Dump version definition section.
   printVersionDefinitionSection(SymbolVersionDefSection);
 
   // Dump version dependency section.
   printVersionDependencySection(SymbolVersionNeedSection);
 }
 
+static Expected<std::vector<uint64_t>> toULEB128Array(ArrayRef<uint8_t> Data) {
+  std::vector<uint64_t> Ret;
+  const uint8_t *Cur = Data.begin();
+  const uint8_t *End = Data.end();
+  while (Cur != End) {
+    unsigned Size;
+    const char *Err;
+    Ret.push_back(decodeULEB128(Cur, &Size, End, &Err));
+    if (Err)
+      return createError(Err);
+    Cur += Size;
+  }
+  return Ret;
+}
+
+template <class ELFT> void ELFDumper<ELFT>::printDebugLLDLinkMap() {
+  const Elf_Shdr *Sec = this->DotDebugLLDLinkMap;
+  if (Sec == nullptr || !Sec->sh_link)
+    return;
+
+  Expected<const Elf_Shdr *> StrSecOrErr = Obj.getSection(Sec->sh_link);
+  if (!StrSecOrErr)
+    return;
+  const Elf_Shdr *StrSec = *StrSecOrErr;
+
+  DictScope D(W, "DebugLLDLinkMap");
+
+  StringRef StrTab = toStringRef(
+      unwrapOrError(ObjF.getFileName(), Obj.getSectionContents(*StrSec)));
+
+  auto GetStr = [&](uint32_t Offset) -> StringRef {
+    if (Offset >= StrTab.size())
+      return "<error>";
+    return StrTab.drop_front(Offset).take_until(
+        [](char C) { return C == '\0'; });
+  };
+
+  Expected<ArrayRef<uint8_t>> ContentsOrErr = Obj.getSectionContents(*Sec);
+  if (!ContentsOrErr) {
+    this->reportUniqueWarning(ContentsOrErr.takeError());
+    return;
+  }
+
+  unsigned LengthSize;
+  const char *LengthErr;
+  const size_t Length = decodeULEB128(ContentsOrErr->begin(), &LengthSize,
+                                      ContentsOrErr->end(), &LengthErr);
+  if (LengthErr) {
+    this->reportUniqueWarning(createError("unable to read length field in " +
+                                          ::describe(Obj, *Sec) + ": " +
+                                          LengthErr));
+    return;
+  }
+  const size_t PayloadSize = Length + LengthSize;
+
+  if (ContentsOrErr->size() < PayloadSize) {
+    this->reportUniqueWarning(createError("unable to read " +
+                                          ::describe(Obj, *Sec) + ": " +
+                                          "section too small for payload"));
+    return;
+  }
+
+  if (Expected<std::vector<uint64_t>> DecodedOrErr =
+          toULEB128Array(ArrayRef<uint8_t>(
+              ContentsOrErr->begin(), ContentsOrErr->begin() + PayloadSize))) {
+    std::vector<uint64_t> &Decoded = *DecodedOrErr;
+
+    if (Decoded.size() < 3) {
+      this->reportUniqueWarning(createError("unable to read " +
+                                            ::describe(Obj, *Sec) + ": " +
+                                            "not enough space for header"));
+      return;
+    }
+
+    size_t I = 0;
+    W.printNumber("Length", Decoded[I++]);
+    W.printNumber("Version", Decoded[I++]);
+    const size_t Entries = Decoded[I++];
+    W.printNumber("Entry Count", Entries);
+
+    size_t Entry = 0;
+    while (I < Decoded.size()) {
+      if (I + 4 > Decoded.size()) {
+        this->reportUniqueWarning(
+            createError("unable to parse " + ::describe(Obj, *Sec) + ": " +
+                        "entry " + Twine(Entry) + " truncated"));
+        return;
+      }
+
+      DictScope D(W, "Entry");
+      W.printString("FileName", GetStr(Decoded[I++]));
+      W.printString("Section", GetStr(Decoded[I++]));
+      W.printHex("Address", Decoded[I++]);
+      W.printNumber("Size", Decoded[I++]);
+      Entry++;
+    }
+
+    if (Entries != Entry)
+      this->reportUniqueWarning(
+          createError("parsing " + ::describe(Obj, *Sec) + ": " +
+                      "number of entries (" + Twine(Entry + 1) +
+                      ") does not match entry count (" + Twine(Entries) + ")"));
+
+  } else
+    this->reportUniqueWarning(createError("unable to decode " +
+                                          ::describe(Obj, *Sec) + ": " +
+                                          toString(DecodedOrErr.takeError())));
+}
+
 #define LLVM_READOBJ_DT_FLAG_ENT(prefix, enum)                                 \
   { #enum, prefix##_##enum }
 
 static const EnumEntry<unsigned> ElfDynamicDTFlags[] = {
   LLVM_READOBJ_DT_FLAG_ENT(DF, ORIGIN),
   LLVM_READOBJ_DT_FLAG_ENT(DF, SYMBOLIC),
   LLVM_READOBJ_DT_FLAG_ENT(DF, TEXTREL),
   LLVM_READOBJ_DT_FLAG_ENT(DF, BIND_NOW),

 template <class ELFT> void GNUELFDumper<ELFT>::printCGProfile() {
   OS << "GNUStyle::printCGProfile not implemented\n";
 }
 
 template <class ELFT> void GNUELFDumper<ELFT>::printBBAddrMaps() {
   OS << "GNUStyle::printBBAddrMaps not implemented\n";
 }
 
-static Expected<std::vector<uint64_t>> toULEB128Array(ArrayRef<uint8_t> Data) {
-  std::vector<uint64_t> Ret;
-  const uint8_t *Cur = Data.begin();
-  const uint8_t *End = Data.end();
-  while (Cur != End) {
-    unsigned Size;
-    const char *Err;
-    Ret.push_back(decodeULEB128(Cur, &Size, End, &Err));
-    if (Err)
-      return createError(Err);
-    Cur += Size;
-  }
-  return Ret;
-}
-
 template <class ELFT>
 static Expected<std::vector<uint64_t>>
 decodeAddrsigSection(const ELFFile<ELFT> &Obj, const typename ELFT::Shdr &Sec) {
   Expected<ArrayRef<uint8_t>> ContentsOrErr = Obj.getSectionContents(Sec);
   if (!ContentsOrErr)
     return ContentsOrErr.takeError();
 
   if (Expected<std::vector<uint64_t>> SymsOrErr =

llvm/tools/llvm-readobj/ObjDumper.h

public:
   virtual void printHashSymbols() {}
   virtual void printLoadName() {}
   virtual void printVersionInfo() {}
   virtual void printGroupSections() {}
   virtual void printHashHistograms() {}
   virtual void printCGProfile() {}
   virtual void printBBAddrMaps() {}
   virtual void printAddrsig() {}
+  virtual void printDebugLLDLinkMap() {}
   virtual void printNotes() {}
   virtual void printELFLinkerOptions() {}
   virtual void printStackSizes() {}
   virtual void printSectionDetails() {}
   virtual void printArchSpecificInfo() {}
 
   // Only implemented for PE/COFF.
   virtual void printCOFFImports() { }

llvm/tools/llvm-readobj/Opts.td

 def unwind : FF<"unwind", "Display unwind information">;
 
 // ELF specific options.
 def grp_elf : OptionGroup<"kind">, HelpText<"OPTIONS (ELF specific)">;
 def dynamic_table : FF<"dynamic-table", "Display the dynamic section table">, Group<grp_elf>;
 def elf_linker_options : FF<"elf-linker-options", "Display the .linker-options section">, Group<grp_elf>;
 defm elf_output_style : Eq<"elf-output-style", "Specify ELF dump style">, Group<grp_elf>;
 def histogram : FF<"histogram", "Display bucket list histogram for hash sections">, Group<grp_elf>;
+def debug_lld_linkmap : FF<"debug_lld_linkmap", "Display contents of lld's linkmap section">, Group<grp_elf>;
 def section_groups : FF<"section-groups", "Display section groups">, Group<grp_elf>;
 def gnu_hash_table : FF<"gnu-hash-table", "Display .gnu.hash section">, Group<grp_elf>;
 def hash_symbols : FF<"hash-symbols", "Display the dynamic symbols derived from the hash section">, Group<grp_elf>;
 def hash_table : FF<"hash-table", "Display .hash section">, Group<grp_elf>;
 def needed_libs : FF<"needed-libs", "Display the needed libraries">, Group<grp_elf>;
 def notes : FF<"notes", "Display notes">, Group<grp_elf>;
 def program_headers : FF<"program-headers", "Display program headers">, Group<grp_elf>;
 def raw_relr : FF<"raw-relr", "Do not decode relocations in SHT_RELR section, display raw contents">, Group<grp_elf>;

llvm/tools/llvm-readobj/llvm-readobj.cpp

 static bool COFFDebugDirectory;
 static bool COFFDirectives;
 static bool COFFExports;
 static bool COFFImports;
 static bool COFFLoadConfig;
 static bool COFFResources;
 static bool COFFTLSDirectory;
 
+static bool DebugLLDLinkMap;
 OutputStyleTy Output = OutputStyleTy::LLVM;
 static std::vector<std::string> InputFilenames;
 } // namespace opts
 
 static StringRef ToolName;
 
 namespace llvm {
 
static void parseOptions(const opt::InputArgList &Args) {
   opts::COFFDebugDirectory = Args.hasArg(OPT_coff_debug_directory);
   opts::COFFDirectives = Args.hasArg(OPT_coff_directives);
   opts::COFFExports = Args.hasArg(OPT_coff_exports);
   opts::COFFImports = Args.hasArg(OPT_coff_imports);
   opts::COFFLoadConfig = Args.hasArg(OPT_coff_load_config);
   opts::COFFResources = Args.hasArg(OPT_coff_resources);
   opts::COFFTLSDirectory = Args.hasArg(OPT_coff_tls_directory);
 
+  opts::DebugLLDLinkMap = Args.hasArg(OPT_debug_lld_linkmap);
   opts::InputFilenames = Args.getAllArgValues(OPT_INPUT);
 }
 
 namespace {
 struct ReadObjTypeTableBuilder {
   ReadObjTypeTableBuilder()
       : Allocator(), IDTable(Allocator), TypeTable(Allocator),
         GlobalIDTable(Allocator), GlobalTypeTable(Allocator) {}
if (Obj.isELF()) {
     if (opts::HashHistogram)
       Dumper->printHashHistograms();
     if (opts::CGProfile)
       Dumper->printCGProfile();
     if (opts::BBAddrMap)
       Dumper->printBBAddrMaps();
     if (opts::Addrsig)
       Dumper->printAddrsig();
+    if (opts::DebugLLDLinkMap)
+      Dumper->printDebugLLDLinkMap();
     if (opts::Notes)
       Dumper->printNotes();
   }
   if (Obj.isCOFF()) {
     if (opts::COFFImports)
       Dumper->printCOFFImports();
     if (opts::COFFExports)
       Dumper->printCOFFExports();