[yaml2obj] - Refine how we set the sh_link field. NFCI.

[grimar]

Summary

This refactors the logic that sets the sh_link field.
With this patch we set it in a single place for all sections.

[MaskRay]

Thanks!

[grimar]

It turns out this wasn't NFC, one of LLDB test cases started to crash.
I've fixed it in rG2a33b092f5b175a21680b3980ff2019bc1c65b12.

The difference was that before this patch we set the sh_link for symbol tables basing on their names (E.g ".symtab"),
now we set this field basing on section types (e.g SHT_SYMTAB).
The mentioned test case has a .text section of type SHT_SYMTAB and it did not expect to see a sh_link field set it seeems.

[jhenderson]

In D95354#2522323, @grimar wrote:

It turns out this wasn't NFC, one of LLDB test cases started to crash.
I've fixed it in rG2a33b092f5b175a21680b3980ff2019bc1c65b12.

The difference was that before this patch we set the sh_link for symbol tables basing on their names (E.g ".symtab"),
now we set this field basing on section types (e.g SHT_SYMTAB).
The mentioned test case has a .text section of type SHT_SYMTAB and it did not expect to see a sh_link field set it seeems.

Based on my casual reading of that test, I wonder if you found a bug in the tool there - it looks like the intent is for section types to trump section names, which surely should mean the use of sh_link would be correctin this case? Perhaps we should highlight this to the LLDB developers (pinging @JDevlieghere for example).

[grimar]

In D95354#2522343, @jhenderson wrote:

In D95354#2522323, @grimar wrote:

It turns out this wasn't NFC, one of LLDB test cases started to crash.
I've fixed it in rG2a33b092f5b175a21680b3980ff2019bc1c65b12.

The difference was that before this patch we set the sh_link for symbol tables basing on their names (E.g ".symtab"),
now we set this field basing on section types (e.g SHT_SYMTAB).
The mentioned test case has a .text section of type SHT_SYMTAB and it did not expect to see a sh_link field set it seeems.

Based on my casual reading of that test, I wonder if you found a bug in the tool there - it looks like the intent is for section types to trump section names, which surely should mean the use of sh_link would be correctin this case? Perhaps we should highlight this to the LLDB developers (pinging @JDevlieghere for example).

Yeah, thanks! I was a bit too focused on fixing the BB ASAP and watching on it :)

FTR, the crash dump was:

******************** TEST 'lldb-shell :: ObjectFile/ELF/section-types-edgecases.yaml' FAILED ********************
Script:
--
: 'RUN: at line 5';   /home/worker/2.0.1/lldb-x86_64-debian/build/bin/yaml2obj /home/worker/2.0.1/lldb-x86_64-debian/llvm-project/lldb/test/Shell/ObjectFile/ELF/section-types-edgecases.yaml -o /home/worker/2.0.1/lldb-x86_64-debian/build/tools/lldb/test/ObjectFile/ELF/Output/section-types-edgecases.yaml.tmp
: 'RUN: at line 6';   /home/worker/2.0.1/lldb-x86_64-debian/build/bin/lldb-test object-file /home/worker/2.0.1/lldb-x86_64-debian/build/tools/lldb/test/ObjectFile/ELF/Output/section-types-edgecases.yaml.tmp | /home/worker/2.0.1/lldb-x86_64-debian/build/bin/FileCheck /home/worker/2.0.1/lldb-x86_64-debian/llvm-project/lldb/test/Shell/ObjectFile/ELF/section-types-edgecases.yaml
--
Exit Code: 2
Command Output (stderr):
--
 #0 0x0000000000532803 llvm::sys::PrintStackTrace(llvm::raw_ostream&, int) (/home/worker/2.0.1/lldb-x86_64-debian/build/bin/lldb-test+0x532803)
 #1 0x00000000005305bc llvm::sys::RunSignalHandlers() (/home/worker/2.0.1/lldb-x86_64-debian/build/bin/lldb-test+0x5305bc)
 #2 0x0000000000532bb6 SignalHandler(int) (/home/worker/2.0.1/lldb-x86_64-debian/build/bin/lldb-test+0x532bb6)
 #3 0x00007f5fafb5b730 __restore_rt (/lib/x86_64-linux-gnu/libpthread.so.0+0x12730)
 #4 0x0000000000945802 ObjectFileELF::ParseSymbolTable(lldb_private::Symtab*, unsigned long, lldb_private::Section*) (/home/worker/2.0.1/lldb-x86_64-debian/build/bin/lldb-test+0x945802)
 #5 0x0000000000946d79 ObjectFileELF::GetSymtab() (/home/worker/2.0.1/lldb-x86_64-debian/build/bin/lldb-test+0x946d79)
 #6 0x0000000000a3d057 SymbolFileDWARFDebugMap::InitOSO() (/home/worker/2.0.1/lldb-x86_64-debian/build/bin/lldb-test+0xa3d057)
 #7 0x0000000000a3db99 SymbolFileDWARFDebugMap::CalculateNumCompileUnits() (/home/worker/2.0.1/lldb-x86_64-debian/build/bin/lldb-test+0xa3db99)
 #8 0x00000000006b2402 lldb_private::SymbolFile::GetNumCompileUnits() (/home/worker/2.0.1/lldb-x86_64-debian/build/bin/lldb-test+0x6b2402)
 #9 0x0000000000a3db69 SymbolFileDWARFDebugMap::CalculateAbilities() (/home/worker/2.0.1/lldb-x86_64-debian/build/bin/lldb-test+0xa3db69)
#10 0x00000000006b2179 lldb_private::SymbolFile::FindPlugin(std::shared_ptr<lldb_private::ObjectFile>) (/home/worker/2.0.1/lldb-x86_64-debian/build/bin/lldb-test+0x6b2179)
#11 0x00000000006b3564 lldb_private::SymbolVendor::AddSymbolFileRepresentation(std::shared_ptr<lldb_private::ObjectFile> const&) (/home/worker/2.0.1/lldb-x86_64-debian/build/bin/lldb-test+0x6b3564)
#12 0x00000000006b344c lldb_private::SymbolVendor::FindPlugin(std::shared_ptr<lldb_private::Module> const&, lldb_private::Stream*) (/home/worker/2.0.1/lldb-x86_64-debian/build/bin/lldb-test+0x6b344c)
#13 0x00000000005aea45 lldb_private::Module::GetSymbolFile(bool, lldb_private::Stream*) (/home/worker/2.0.1/lldb-x86_64-debian/build/bin/lldb-test+0x5aea45)
#14 0x00000000004c8df8 main (/home/worker/2.0.1/lldb-x86_64-debian/build/bin/lldb-test+0x4c8df8)
#15 0x00007f5faf0d209b __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x2409b)
#16 0x00000000004c468a _start (/home/worker/2.0.1/lldb-x86_64-debian/build/bin/lldb-test+0x4c468a)
PLEASE submit a bug report to https://bugs.llvm.org/ and include the crash backtrace.
Stack dump:
0.	Program arguments: /home/worker/2.0.1/lldb-x86_64-debian/build/bin/lldb-test object-file /home/worker/2.0.1/lldb-x86_64-debian/build/tools/lldb/test/ObjectFile/ELF/Output/section-types-edgecases.yaml.tmp
FileCheck error: '<stdin>' is empty.
FileCheck command line:  /home/worker/2.0.1/lldb-x86_64-debian/build/bin/FileCheck /home/worker/2.0.1/lldb-x86_64-debian/llvm-project/lldb/test/Shell/ObjectFile/ELF/section-types-edgecases.yaml

llvm/lib/ObjectYAML/ELFEmitter.cpp

if (!SecHdrTable || !SecHdrTable->NoHeaders.getValueOr(false))
     ImplicitSections.insert(ImplicitSections.end(), {".shstrtab"});
 
   // Insert placeholders for implicit sections that are not
   // defined explicitly in YAML.
   for (StringRef SecName : ImplicitSections) {
     if (DocSections.count(SecName))
       continue;
 
-    std::unique_ptr<ELFYAML::Chunk> Sec = std::make_unique<ELFYAML::Section>(
+    std::unique_ptr<ELFYAML::Section> Sec = std::make_unique<ELFYAML::Section>(
         ELFYAML::Chunk::ChunkKind::RawContent, true /*IsImplicit*/);
     Sec->Name = SecName;
 
+    if (SecName == ".dynsym")
+      Sec->Type = ELF::SHT_DYNSYM;
+    else if (SecName == ".symtab")
+      Sec->Type = ELF::SHT_SYMTAB;
+    else
+      Sec->Type = ELF::SHT_STRTAB;
+
     // When the section header table is explicitly defined at the end of the
     // sections list, it is reasonable to assume that the user wants to reorder
     // section headers, but still wants to place the section header table after
     // all sections, like it normally happens. In this case we want to insert
     // other implicit sections right before the section header table.
     if (Doc.Chunks.back().get() == SecHdrTable)
       Doc.Chunks.insert(Doc.Chunks.end() - 1, std::move(Sec));
     else
static uint64_t writeContent(ContiguousBlobAccumulator &CBA,
 
   if (!Size)
     return ContentSize;
 
   CBA.writeZeros(*Size - ContentSize);
   return *Size;
 }
 
+static StringRef getDefaultLinkSec(unsigned SecType) {
+  switch (SecType) {
+  case ELF::SHT_REL:
+  case ELF::SHT_RELA:
+  case ELF::SHT_GROUP:
+  case ELF::SHT_LLVM_CALL_GRAPH_PROFILE:
+  case ELF::SHT_LLVM_ADDRSIG:
+    return ".symtab";
+  case ELF::SHT_GNU_versym:
+  case ELF::SHT_HASH:
+  case ELF::SHT_GNU_HASH:
+    return ".dynsym";
+  case ELF::SHT_DYNSYM:
+  case ELF::SHT_GNU_verdef:
+  case ELF::SHT_GNU_verneed:
+    return ".dynstr";
+  case ELF::SHT_SYMTAB:
+    return ".strtab";
+  default:
+    return "";
+  }
+}
+
 template <class ELFT>
 void ELFState<ELFT>::initSectionHeaders(std::vector<Elf_Shdr> &SHeaders,
                                         ContiguousBlobAccumulator &CBA) {
   // Ensure SHN_UNDEF entry is present. An all-zero section header is a
   // valid SHN_UNDEF entry since SHT_NULL == 0.
   SHeaders.resize(Doc.getSections().size());
 
   for (const std::unique_ptr<ELFYAML::Chunk> &D : Doc.Chunks) {
if (ELFYAML::SectionHeaderTable *S =
       continue;
     }
 
     ELFYAML::Section *Sec = cast<ELFYAML::Section>(D.get());
     bool IsFirstUndefSection = Sec == Doc.getSections().front();
     if (IsFirstUndefSection && Sec->IsImplicit)
       continue;
 
+    Elf_Shdr &SHeader = SHeaders[SN2I.get(Sec->Name)];
+    if (Sec->Link) {
+      SHeader.sh_link = toSectionIndex(*Sec->Link, Sec->Name);
+    } else {
+      StringRef LinkSec = getDefaultLinkSec(Sec->Type);
+      unsigned Link = 0;
+      if (!LinkSec.empty() && !ExcludedSectionHeaders.count(LinkSec) &&
+          SN2I.lookup(LinkSec, Link))
+        SHeader.sh_link = Link;
+    }
+
     // We have a few sections like string or symbol tables that are usually
     // added implicitly to the end. However, if they are explicitly specified
     // in the YAML, we need to write them here. This ensures the file offset
     // remains correct.
-    Elf_Shdr &SHeader = SHeaders[SN2I.get(Sec->Name)];
     if (initImplicitHeader(CBA, SHeader, Sec->Name,
                            Sec->IsImplicit ? nullptr : Sec))
       continue;
 
     assert(Sec && "It can't be null unless it is an implicit section. But all "
                   "implicit sections should already have been handled above.");
 
     SHeader.sh_name =
         getSectionNameOffset(ELFYAML::dropUniqueSuffix(Sec->Name));
     SHeader.sh_type = Sec->Type;
     if (Sec->Flags)
       SHeader.sh_flags = *Sec->Flags;
     SHeader.sh_addralign = Sec->AddressAlign;
 
     // Set the offset for all sections, except the SHN_UNDEF section with index
     // 0 when not explicitly requested.
     if (!IsFirstUndefSection || Sec->Offset)
       SHeader.sh_offset = alignToOffset(CBA, SHeader.sh_addralign, Sec->Offset);
 
     assignSectionAddress(SHeader, Sec);
 
-    if (Sec->Link)
-      SHeader.sh_link = toSectionIndex(*Sec->Link, Sec->Name);
-
     if (Sec->EntSize)
       SHeader.sh_entsize = *Sec->EntSize;
     else
       SHeader.sh_entsize = ELFYAML::getDefaultShEntSize<ELFT>(
           Doc.Header.Machine.getValueOr(ELF::EM_NONE), Sec->Type, Sec->Name);
 
     if (IsFirstUndefSection) {
       if (auto RawSec = dyn_cast<ELFYAML::RawContentSection>(Sec)) {
if (HasSymbolsDescription) {
                     " for symbol table section '" + RawSec->Name + "'");
       if (RawSec->Size)
         reportError("cannot specify both `Size` and " + Property +
                     " for symbol table section '" + RawSec->Name + "'");
       return;
     }
   }
 
-  zero(SHeader);
   SHeader.sh_name = getSectionNameOffset(IsStatic ? ".symtab" : ".dynsym");
 
   if (YAMLSec)
     SHeader.sh_type = YAMLSec->Type;
   else
     SHeader.sh_type = IsStatic ? ELF::SHT_SYMTAB : ELF::SHT_DYNSYM;
 
-  if (RawSec && RawSec->Link) {
-    // If the Link field is explicitly defined in the document,
-    // we should use it.
-    SHeader.sh_link = toSectionIndex(*RawSec->Link, RawSec->Name);
-  } else {
-    // When we describe the .dynsym section in the document explicitly, it is
-    // allowed to omit the "DynamicSymbols" tag. In this case .dynstr is not
-    // added implicitly and we should be able to leave the Link zeroed if
-    // .dynstr is not defined.
-    unsigned Link = 0;
-    if (IsStatic) {
-      if (!ExcludedSectionHeaders.count(".strtab"))
-        Link = SN2I.get(".strtab");
-    } else {
-      if (!ExcludedSectionHeaders.count(".dynstr"))
-        SN2I.lookup(".dynstr", Link);
-    }
-    SHeader.sh_link = Link;
-  }
-
   if (YAMLSec && YAMLSec->Flags)
     SHeader.sh_flags = *YAMLSec->Flags;
   else if (!IsStatic)
     SHeader.sh_flags = ELF::SHF_ALLOC;
 
   // If the symbol table section is explicitly described in the YAML
   // then we should set the fields requested.
   SHeader.sh_info = (RawSec && RawSec->Info) ? (unsigned)(*RawSec->Info)
void ELFState<ELFT>::initSymtabSectionHeader(Elf_Shdr &SHeader,
   CBA.write((const char *)Syms.data(), SHeader.sh_size);
 }
 
 template <class ELFT>
 void ELFState<ELFT>::initStrtabSectionHeader(Elf_Shdr &SHeader, StringRef Name,
                                              StringTableBuilder &STB,
                                              ContiguousBlobAccumulator &CBA,
                                              ELFYAML::Section *YAMLSec) {
-  zero(SHeader);
   SHeader.sh_name = getSectionNameOffset(Name);
   SHeader.sh_type = YAMLSec ? YAMLSec->Type : ELF::SHT_STRTAB;
   SHeader.sh_addralign = YAMLSec ? (uint64_t)YAMLSec->AddressAlign : 1;
 
   ELFYAML::RawContentSection *RawSec =
       dyn_cast_or_null<ELFYAML::RawContentSection>(YAMLSec);
 
   SHeader.sh_offset = alignToOffset(CBA, SHeader.sh_addralign,
Expected<uint64_t> emitDWARF(typename ELFT::Shdr &SHeader, StringRef Name,
 
   return CBA.tell() - BeginOffset;
 }
 
 template <class ELFT>
 void ELFState<ELFT>::initDWARFSectionHeader(Elf_Shdr &SHeader, StringRef Name,
                                             ContiguousBlobAccumulator &CBA,
                                             ELFYAML::Section *YAMLSec) {
-  zero(SHeader);
   SHeader.sh_name = getSectionNameOffset(ELFYAML::dropUniqueSuffix(Name));
   SHeader.sh_type = YAMLSec ? YAMLSec->Type : ELF::SHT_PROGBITS;
   SHeader.sh_addralign = YAMLSec ? (uint64_t)YAMLSec->AddressAlign : 1;
   SHeader.sh_offset = alignToOffset(CBA, SHeader.sh_addralign,
                                     YAMLSec ? YAMLSec->Offset : None);
 
   ELFYAML::RawContentSection *RawSec =
       dyn_cast_or_null<ELFYAML::RawContentSection>(YAMLSec);
void ELFState<ELFT>::initDWARFSectionHeader(Elf_Shdr &SHeader, StringRef Name,
   if (RawSec && RawSec->Info)
     SHeader.sh_info = *RawSec->Info;
 
   if (YAMLSec && YAMLSec->Flags)
     SHeader.sh_flags = *YAMLSec->Flags;
   else if (Name == ".debug_str")
     SHeader.sh_flags = ELF::SHF_MERGE | ELF::SHF_STRINGS;
 
-  if (YAMLSec && YAMLSec->Link)
-    SHeader.sh_link = toSectionIndex(*YAMLSec->Link, Name);
-
   assignSectionAddress(SHeader, YAMLSec);
 }
 
 template <class ELFT> void ELFState<ELFT>::reportError(const Twine &Msg) {
   ErrHandler(Msg);
   HasError = true;
 }
 

 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(
     Elf_Shdr &SHeader, const ELFYAML::RelocationSection &Section,
     ContiguousBlobAccumulator &CBA) {
   assert((Section.Type == llvm::ELF::SHT_REL ||
           Section.Type == llvm::ELF::SHT_RELA) &&
          "Section type is not SHT_REL nor SHT_RELA");
 
-  // For relocation section set link to .symtab by default.
-  unsigned Link = 0;
-  if (!Section.Link && !ExcludedSectionHeaders.count(".symtab") &&
-      SN2I.lookup(".symtab", Link))
-    SHeader.sh_link = Link;
-
   if (!Section.RelocatableSec.empty())
     SHeader.sh_info = toSectionIndex(Section.RelocatableSec, Section.Name);
 
   if (!Section.Relocations)
     return;
 
   const bool IsRela = Section.Type == llvm::ELF::SHT_RELA;
   for (const ELFYAML::Relocation &Rel : *Section.Relocations) {

 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::GroupSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
   assert(Section.Type == llvm::ELF::SHT_GROUP &&
          "Section type is not SHT_GROUP");
 
-  unsigned Link = 0;
-  if (!Section.Link && !ExcludedSectionHeaders.count(".symtab") &&
-      SN2I.lookup(".symtab", Link))
-    SHeader.sh_link = Link;
-
   if (Section.Signature)
     SHeader.sh_info =
         toSymbolIndex(*Section.Signature, Section.Name, /*IsDynamic=*/false);
 
   if (!Section.Members)
     return;
 
   for (const ELFYAML::SectionOrType &Member : *Section.Members) {
     unsigned int SectionIndex = 0;
     if (Member.sectionNameOrType == "GRP_COMDAT")
       SectionIndex = llvm::ELF::GRP_COMDAT;
     else
       SectionIndex = toSectionIndex(Member.sectionNameOrType, Section.Name);
     CBA.write<uint32_t>(SectionIndex, ELFT::TargetEndianness);
   }
   SHeader.sh_size = SHeader.sh_entsize * Section.Members->size();
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::SymverSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
-  unsigned Link = 0;
-  if (!Section.Link && !ExcludedSectionHeaders.count(".dynsym") &&
-      SN2I.lookup(".dynsym", Link))
-    SHeader.sh_link = Link;
-
   if (!Section.Entries)
     return;
 
   for (uint16_t Version : *Section.Entries)
     CBA.write<uint16_t>(Version, ELFT::TargetEndianness);
   SHeader.sh_size = Section.Entries->size() * SHeader.sh_entsize;
 }
 
ELFState<ELFT>::alignToOffset(ContiguousBlobAccumulator &CBA, uint64_t Align,
   CBA.writeZeros(AlignedOffset - CurrentOffset);
   return AlignedOffset;
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(
     Elf_Shdr &SHeader, const ELFYAML::CallGraphProfileSection &Section,
     ContiguousBlobAccumulator &CBA) {
-  unsigned Link = 0;
-  if (!Section.Link && !ExcludedSectionHeaders.count(".symtab") &&
-      SN2I.lookup(".symtab", Link))
-    SHeader.sh_link = Link;
-
   if (!Section.Entries)
     return;
 
   for (const ELFYAML::CallGraphEntry &E : *Section.Entries) {
     unsigned From = toSymbolIndex(E.From, Section.Name, /*IsDynamic=*/false);
     unsigned To = toSymbolIndex(E.To, Section.Name, /*IsDynamic=*/false);
 
     CBA.write<uint32_t>(From, ELFT::TargetEndianness);
     CBA.write<uint32_t>(To, ELFT::TargetEndianness);
     CBA.write<uint64_t>(E.Weight, ELFT::TargetEndianness);
     SHeader.sh_size += 16;
   }
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::HashSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
-  unsigned Link = 0;
-  if (!Section.Link && !ExcludedSectionHeaders.count(".dynsym") &&
-      SN2I.lookup(".dynsym", Link))
-    SHeader.sh_link = Link;
-
   if (!Section.Bucket)
     return;
 
   if (!Section.Bucket)
     return;
 
   CBA.write<uint32_t>(
       Section.NBucket.getValueOr(llvm::yaml::Hex64(Section.Bucket->size())),
void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::VerdefSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
 
   if (Section.Info)
     SHeader.sh_info = *Section.Info;
   else if (Section.Entries)
     SHeader.sh_info = Section.Entries->size();
 
-  unsigned Link = 0;
-  if (!Section.Link && !ExcludedSectionHeaders.count(".dynstr") &&
-      SN2I.lookup(".dynstr", Link))
-    SHeader.sh_link = Link;
-
   if (!Section.Entries)
     return;
 
   uint64_t AuxCnt = 0;
   for (size_t I = 0; I < Section.Entries->size(); ++I) {
     const ELFYAML::VerdefEntry &E = (*Section.Entries)[I];
 
     Elf_Verdef VerDef;

 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::VerneedSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
   if (Section.Info)
     SHeader.sh_info = *Section.Info;
   else if (Section.VerneedV)
     SHeader.sh_info = Section.VerneedV->size();
 
-  unsigned Link = 0;
-  if (!Section.Link && !ExcludedSectionHeaders.count(".dynstr") &&
-      SN2I.lookup(".dynstr", Link))
-    SHeader.sh_link = Link;
-
   if (!Section.VerneedV)
     return;
 
   uint64_t AuxCnt = 0;
   for (size_t I = 0; I < Section.VerneedV->size(); ++I) {
     const ELFYAML::VerneedEntry &VE = (*Section.VerneedV)[I];
 
     Elf_Verneed VerNeed;
void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
   }
   SHeader.sh_size = 2 * sizeof(uintX_t) * Section.Entries->size();
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::AddrsigSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
-  unsigned Link = 0;
-  if (!Section.Link && !ExcludedSectionHeaders.count(".symtab") &&
-      SN2I.lookup(".symtab", Link))
-    SHeader.sh_link = Link;
-
   if (!Section.Symbols)
     return;
 
   if (!Section.Symbols)
     return;
 
   for (StringRef Sym : *Section.Symbols)
     SHeader.sh_size +=
void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
 
   SHeader.sh_size = CBA.tell() - Offset;
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::GnuHashSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
-  unsigned Link = 0;
-  if (!Section.Link && !ExcludedSectionHeaders.count(".dynsym") &&
-      SN2I.lookup(".dynsym", Link))
-    SHeader.sh_link = Link;
-
   if (!Section.HashBuckets)
     return;
 
   if (!Section.Header)
     return;
 
   // We write the header first, starting with the hash buckets count. Normally
   // it is the number of entries in HashBuckets, but the "NBuckets" property can