Add ELF dynamic symbol support to yaml2obj/obj2yaml

[kastiglione]

Summary

This change introduces a DynamicSymbols field to the ELF specific YAML
supported by yaml2obj and obj2yaml. This grouping of symbols provides a way
to represent ELF dynamic symbols. The DynamicSymbols structure is identical to
the existing Symbols.

[jakehehrlich]

Can you add tests?

Also thanks for working on this! I've been needing yaml2obj to support more features of dynamic libraries.

[kastiglione]

@jakehehrlich I will definitely add tests. I put it up as is to get any initial feedback before writing tests.

I expect I'll need support for some parts of SHT_DYNAMIC, particularly SONAME, so that change might follow this.

[jakehehrlich]

In general this looks like a good approach to me. I have concerns about deciding section indexes for users as mentioned but other than that I just have a couple nits.

tools/yaml2obj/yaml2elf.cpp

162–163

.dyn* sections are going to be allocated and so we need to be able place them next to certain other allocated sections so that we can't put them in program headers. It won't be sufficient to decide for the user, at least not this way. One way might be to require that the user add a .dynsym section if they want to use DynamicSymbols and then using the index of that section if they do. This will require that you compute the size of the .dynsym and .dynstr sections early enough for the standard layout algorithm to work.

301

Can this just be "bool IsStatic = STType == SymtabType::Static"? Better yet do we really need SymtabType? What if we just pass "IsStatic" as a parameter?

311

.dynsym should be allocated so sh_flags should be set to SHF_ALLOC if IsStatic is true.

[kastiglione]

@jakehehrlich thanks for the review! I have more experience with macho/pecoff so I appreciate the insights. I'll update this with tests and something for the section ordering.

tools/yaml2obj/yaml2elf.cpp

301

🤦‍♂️

The choice to use the enum was to avoid opaque true/false arguments at the call site. I'll go with bools if that's preferred.

[kastiglione]

tools/yaml2obj/yaml2elf.cpp

162–163

What about making the .dynsym section optional? If it's there, that's the order that's used, and if it no .dynsym section is specified, then this default ordering is used? The same could be applied to these other sections (.symtab etc) if desired.

[kastiglione]

tools/yaml2obj/yaml2elf.cpp

162–163

@silvas Hi Sean, do you have an opinion on how you would like to see section ordering handled, particularly as it relates to dynamic symbols?

[kastiglione]

tools/yaml2obj/yaml2elf.cpp

162–163

@jakehehrlich I have a diff (D39749) to allow the input yaml to control section order. If folks are happy with that, I will rebase this change on top of that, which will allow the .dynsym sections to be ordered as specified in the input.

[jakehehrlich]

I'm happy with D39749 and using that to resolve the ordering isue. I'm not a reviewer here but this looks good to me other than the ternary operator nit.

tools/yaml2obj/yaml2elf.cpp

301

I'm not sure I have a preference on bools vs enums, you pick, but the ternary operator use seems funny to me.

[kastiglione]

tools/yaml2obj/yaml2elf.cpp

301

Agreed, I got rid of this ternary right away, just haven't update the diff.

[kastiglione]

Rebased on D39749; Added tests

[kastiglione]

Fixed unfinished comment updates

[kastiglione]

This change is ready for a rereview. Note this change depends on D39908, for existing tests to pass.

[jakehehrlich]

Mostly looks good to me, I want someone to review the ELFDumper and elf2yaml changes but the ELFYAML and yaml2elf changes look good. I just have one request about making .dynstr allocated (see inline).

tools/yaml2obj/yaml2elf.cpp

649

.dynstr needs to have SHF_ALLOC set as well

[jakehehrlich]

test/tools/yaml2obj/dynamic-symbols.yaml

30–31 ↗

(On Diff #122300)

You should also confirm that these sections a) have type SHT_DYNSYM and SHT_DYNSTR. Also you should check that they have SHF_ALLOC set.

[kastiglione]

Made .dynstr SHF_ALLOC; Added a few more FileChecks

[jakehehrlich]

Knowing nothing about elf2yaml this LGTM

[silvas]

tools/yaml2obj/yaml2elf.cpp

162–163

Sorry for the very late reply. Don't know why it only just now showed up in my inbox.

I really like the approach you've taken in D39749. LGTM.

include/llvm/ObjectYAML/ELFYAML.h

struct Object {
   FileHeader Header;
   std::vector<ProgramHeader> ProgramHeaders;
   std::vector<std::unique_ptr<Section>> Sections;
   // Although in reality the symbols reside in a section, it is a lot
   // cleaner and nicer if we read them from the YAML as a separate
   // top-level key, which automatically ensures that invariants like there
   // being a single SHT_SYMTAB section are upheld.
   LocalGlobalWeakSymbols Symbols;
+  LocalGlobalWeakSymbols DynamicSymbols;
 };
 
 } // end namespace ELFYAML
 } // end namespace llvm
 
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::ProgramHeader)
 LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<llvm::ELFYAML::Section>)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Symbol)

lib/ObjectYAML/ELFYAML.cpp

 void MappingTraits<ELFYAML::Object>::mapping(IO &IO, ELFYAML::Object &Object) {
   assert(!IO.getContext() && "The IO context is initialized already");
   IO.setContext(&Object);
   IO.mapTag("!ELF", true);
   IO.mapRequired("FileHeader", Object.Header);
   IO.mapOptional("ProgramHeaders", Object.ProgramHeaders);
   IO.mapOptional("Sections", Object.Sections);
   IO.mapOptional("Symbols", Object.Symbols);
+  IO.mapOptional("DynamicSymbols", Object.DynamicSymbols);
   IO.setContext(nullptr);
 }
 
 LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_AFL_REG)
 LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_ABI_FP)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_EXT)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_ASE)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_FLAGS1)
 
 } // end namespace yaml
 
 } // end namespace llvm

tools/obj2yaml/elf2yaml.cpp

class ELFDumper {
   std::vector<std::string> SectionNames;
   Expected<StringRef> getUniquedSectionName(const Elf_Shdr *Sec);
   Expected<StringRef> getSymbolName(const Elf_Sym *Sym, StringRef StrTable,
                                     const Elf_Shdr *SymTab);
 
   const object::ELFFile<ELFT> &Obj;
   ArrayRef<Elf_Word> ShndxTable;
 
+  std::error_code dumpSymbols(const Elf_Shdr *Symtab,
+                              ELFYAML::LocalGlobalWeakSymbols &Symbols);
   std::error_code dumpSymbol(const Elf_Sym *Sym, const Elf_Shdr *SymTab,
                              StringRef StrTable, ELFYAML::Symbol &S);
   std::error_code dumpCommonSection(const Elf_Shdr *Shdr, ELFYAML::Section &S);
   std::error_code dumpCommonRelocationSection(const Elf_Shdr *Shdr,
                                               ELFYAML::RelocationSection &S);
   template <class RelT>
   std::error_code dumpRelocation(const RelT *Rel, const Elf_Shdr *SymTab,
                                  ELFYAML::Relocation &R);
template <class ELFT> ErrorOr<ELFYAML::Object *> ELFDumper<ELFT>::dump() {
   Y->Header.Data = ELFYAML::ELF_ELFDATA(Obj.getHeader()->getDataEncoding());
   Y->Header.OSABI = Obj.getHeader()->e_ident[ELF::EI_OSABI];
   Y->Header.Type = Obj.getHeader()->e_type;
   Y->Header.Machine = Obj.getHeader()->e_machine;
   Y->Header.Flags = Obj.getHeader()->e_flags;
   Y->Header.Entry = Obj.getHeader()->e_entry;
 
   const Elf_Shdr *Symtab = nullptr;
+  const Elf_Shdr *DynSymtab = nullptr;
 
   // Dump sections
   auto SectionsOrErr = Obj.sections();
   if (!SectionsOrErr)
     return errorToErrorCode(SectionsOrErr.takeError());
   Sections = *SectionsOrErr;
   SectionNames.resize(Sections.size());
   for (const Elf_Shdr &Sec : Sections) {
     switch (Sec.sh_type) {
     case ELF::SHT_NULL:
-    case ELF::SHT_DYNSYM:
     case ELF::SHT_STRTAB:
       // Do not dump these sections.
       break;
     case ELF::SHT_SYMTAB:
       Symtab = &Sec;
       break;
+    case ELF::SHT_DYNSYM:
+      DynSymtab = &Sec;
+      break;
     case ELF::SHT_SYMTAB_SHNDX: {
       auto TableOrErr = Obj.getSHNDXTable(Sec);
       if (!TableOrErr)
         return errorToErrorCode(TableOrErr.takeError());
       ShndxTable = *TableOrErr;
       break;
     }
     case ELF::SHT_RELA: {
default: {
       ErrorOr<ELFYAML::RawContentSection *> S = dumpContentSection(&Sec);
       if (std::error_code EC = S.getError())
         return EC;
       Y->Sections.push_back(std::unique_ptr<ELFYAML::Section>(S.get()));
     }
     }
   }
 
-  // Dump symbols
+  if (auto EC = dumpSymbols(Symtab, Y->Symbols))
+    return EC;
+  if (auto EC = dumpSymbols(DynSymtab, Y->DynamicSymbols))
+    return EC;
+
+  return Y.release();
+}
+
+template <class ELFT>
+std::error_code
+ELFDumper<ELFT>::dumpSymbols(const Elf_Shdr *Symtab,
+                             ELFYAML::LocalGlobalWeakSymbols &Symbols) {
   if (!Symtab)
-    return Y.release(); // if the symbol table is missing return early
+    return std::error_code();
+
   auto StrTableOrErr = Obj.getStringTableForSymtab(*Symtab);
   if (!StrTableOrErr)
     return errorToErrorCode(StrTableOrErr.takeError());
   StringRef StrTable = *StrTableOrErr;
 
-  bool IsFirstSym = true;
   auto SymtabOrErr = Obj.symbols(Symtab);
   if (!SymtabOrErr)
     return errorToErrorCode(SymtabOrErr.takeError());
-  for (const Elf_Sym &Sym : *SymtabOrErr) {
+
+  bool IsFirstSym = true;
+  for (const auto &Sym : *SymtabOrErr) {
     if (IsFirstSym) {
       IsFirstSym = false;
       continue;
     }
 
     ELFYAML::Symbol S;
-    if (std::error_code EC =
-            ELFDumper<ELFT>::dumpSymbol(&Sym, Symtab, StrTable, S))
+    if (auto EC = dumpSymbol(&Sym, Symtab, StrTable, S))
       return EC;
 
-    switch (Sym.getBinding())
-    {
+    switch (Sym.getBinding()) {
     case ELF::STB_LOCAL:
-      Y->Symbols.Local.push_back(S);
+      Symbols.Local.push_back(S);
       break;
     case ELF::STB_GLOBAL:
-      Y->Symbols.Global.push_back(S);
+      Symbols.Global.push_back(S);
       break;
     case ELF::STB_WEAK:
-      Y->Symbols.Weak.push_back(S);
+      Symbols.Weak.push_back(S);
       break;
     default:
       llvm_unreachable("Unknown ELF symbol binding");
     }
   }
 
-  return Y.release();
+  return std::error_code();
 }
 
 template <class ELFT>
 std::error_code
 ELFDumper<ELFT>::dumpSymbol(const Elf_Sym *Sym, const Elf_Shdr *SymTab,
                             StringRef StrTable, ELFYAML::Symbol &S) {
   S.Type = Sym->getType();
   S.Value = Sym->st_value;

tools/yaml2obj/yaml2elf.cpp

 class ELFState {
   typedef typename object::ELFFile<ELFT>::Elf_Ehdr Elf_Ehdr;
   typedef typename object::ELFFile<ELFT>::Elf_Phdr Elf_Phdr;
   typedef typename object::ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
   typedef typename object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename object::ELFFile<ELFT>::Elf_Rel Elf_Rel;
   typedef typename object::ELFFile<ELFT>::Elf_Rela Elf_Rela;
 
+  enum class SymtabType { Static, Dynamic };
+
   /// \brief The future ".strtab" section.
   StringTableBuilder DotStrtab{StringTableBuilder::ELF};
 
   /// \brief The future ".shstrtab" section.
   StringTableBuilder DotShStrtab{StringTableBuilder::ELF};
 
+  /// \brief The future ".dynstr" section.
+  StringTableBuilder DotDynstr{StringTableBuilder::ELF};
+
   NameToIdxMap SN2I;
   NameToIdxMap SymN2I;
   const ELFYAML::Object &Doc;
 
   bool buildSectionIndex();
   bool buildSymbolIndex(std::size_t &StartIndex,
                         const std::vector<ELFYAML::Symbol> &Symbols);
   void initELFHeader(Elf_Ehdr &Header);
   void initProgramHeaders(std::vector<Elf_Phdr> &PHeaders);
   bool initSectionHeaders(std::vector<Elf_Shdr> &SHeaders,
                           ContiguousBlobAccumulator &CBA);
-  void initSymtabSectionHeader(Elf_Shdr &SHeader,
+  void initSymtabSectionHeader(Elf_Shdr &SHeader, SymtabType STType,
                                ContiguousBlobAccumulator &CBA);
   void initStrtabSectionHeader(Elf_Shdr &SHeader, StringRef Name,
                                StringTableBuilder &STB,
                                ContiguousBlobAccumulator &CBA);
   void setProgramHeaderLayout(std::vector<Elf_Phdr> &PHeaders,
                               std::vector<Elf_Shdr> &SHeaders);
   void addSymbols(const std::vector<ELFYAML::Symbol> &Symbols,
-                  std::vector<Elf_Sym> &Syms, unsigned SymbolBinding);
+                  std::vector<Elf_Sym> &Syms, unsigned SymbolBinding,
+                  const StringTableBuilder &Strtab);
   void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::RawContentSection &Section,
                            ContiguousBlobAccumulator &CBA);
   bool writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::RelocationSection &Section,
                            ContiguousBlobAccumulator &CBA);
   bool writeSectionContent(Elf_Shdr &SHeader, const ELFYAML::Group &Group,
                            ContiguousBlobAccumulator &CBA);
   bool writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::MipsABIFlags &Section,
                            ContiguousBlobAccumulator &CBA);
+  bool hasDynamicSymbols() const;
 
   // - SHT_NULL entry (placed first, i.e. 0'th entry)
-  // - symbol table (.symtab) (placed third to last)
-  // - string table (.strtab) (placed second to last)
-  // - section header string table (.shstrtab) (placed last)
+  // - symbol table (.symtab) (placed after last yaml section)
+  // - string table (.strtab) (placed after .symtab)
+  // - section header string table (.shstrtab) (placed after .strtab)
+  // - dynamic symbol table (.dynsym) (placed after .shstrtab)
+  // - dynamic string table (.dynstr) (placed after .dynsym)
   unsigned getDotSymTabSecNo() const { return Doc.Sections.size() + 1; }
   unsigned getDotStrTabSecNo() const { return Doc.Sections.size() + 2; }
   unsigned getDotShStrTabSecNo() const { return Doc.Sections.size() + 3; }
-  unsigned getSectionCount() const { return Doc.Sections.size() + 4; }
+  unsigned getDotDynSymSecNo() const { return Doc.Sections.size() + 4; }
+  unsigned getDotDynStrSecNo() const { return Doc.Sections.size() + 5; }
+  unsigned getSectionCount() const {
+    return 1 +
+           (hasDynamicSymbols() ? getDotDynStrSecNo() : getDotShStrTabSecNo());
+  }
 
   ELFState(const ELFYAML::Object &D) : Doc(D) {}
 
 public:
   static int writeELF(raw_ostream &OS, const ELFYAML::Object &Doc);
 };
 } // end anonymous namespace
 
for (const auto &Sec : Doc.Sections) {
 
     SHeaders.push_back(SHeader);
   }
   return true;
 }
 
 template <class ELFT>
 void ELFState<ELFT>::initSymtabSectionHeader(Elf_Shdr &SHeader,
+                                             SymtabType STType,
                                              ContiguousBlobAccumulator &CBA) {
   zero(SHeader);
-  SHeader.sh_name = DotShStrtab.getOffset(".symtab");
-  SHeader.sh_type = ELF::SHT_SYMTAB;
-  SHeader.sh_link = getDotStrTabSecNo();
+  bool IsStatic = STType == SymtabType::Static ? true : false;
+  SHeader.sh_name = DotShStrtab.getOffset(IsStatic ? ".symtab" : ".dynsym");
+  SHeader.sh_type = IsStatic ? ELF::SHT_SYMTAB : ELF::SHT_DYNSYM;
+  SHeader.sh_link = IsStatic ? getDotStrTabSecNo() : getDotDynStrSecNo();
+  const auto &Symbols = IsStatic ? Doc.Symbols : Doc.DynamicSymbols;
+  auto &Strtab = IsStatic ? DotStrtab : DotDynstr;
   // One greater than symbol table index of the last local symbol.
-  SHeader.sh_info = Doc.Symbols.Local.size() + 1;
+  SHeader.sh_info = Symbols.Local.size() + 1;
   SHeader.sh_entsize = sizeof(Elf_Sym);
   SHeader.sh_addralign = 8;
 
   std::vector<Elf_Sym> Syms;
   {
     // Ensure STN_UNDEF is present
     Elf_Sym Sym;
     zero(Sym);
     Syms.push_back(Sym);
   }
 
-  // Add symbol names to .strtab.
-  for (const auto &Sym : Doc.Symbols.Local)
-    DotStrtab.add(Sym.Name);
-  for (const auto &Sym : Doc.Symbols.Global)
-    DotStrtab.add(Sym.Name);
-  for (const auto &Sym : Doc.Symbols.Weak)
-    DotStrtab.add(Sym.Name);
-  DotStrtab.finalize();
-
-  addSymbols(Doc.Symbols.Local, Syms, ELF::STB_LOCAL);
-  addSymbols(Doc.Symbols.Global, Syms, ELF::STB_GLOBAL);
-  addSymbols(Doc.Symbols.Weak, Syms, ELF::STB_WEAK);
+  // Add symbol names to .strtab or .dynstr.
+  for (const auto &Sym : Symbols.Local)
+    Strtab.add(Sym.Name);
+  for (const auto &Sym : Symbols.Global)
+    Strtab.add(Sym.Name);
+  for (const auto &Sym : Symbols.Weak)
+    Strtab.add(Sym.Name);
+  Strtab.finalize();
+
+  addSymbols(Symbols.Local, Syms, ELF::STB_LOCAL, Strtab);
+  addSymbols(Symbols.Global, Syms, ELF::STB_GLOBAL, Strtab);
+  addSymbols(Symbols.Weak, Syms, ELF::STB_WEAK, Strtab);
 
   writeArrayData(
       CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign),
       makeArrayRef(Syms));
   SHeader.sh_size = arrayDataSize(makeArrayRef(Syms));
 }
 
 template <class ELFT>
for (auto SecName : YamlPhdr.Sections) {
         PHeader.p_align = std::max(PHeader.p_align, SHeader.sh_addralign);
     }
   }
 }
 
 template <class ELFT>
 void ELFState<ELFT>::addSymbols(const std::vector<ELFYAML::Symbol> &Symbols,
                                 std::vector<Elf_Sym> &Syms,
-                                unsigned SymbolBinding) {
+                                unsigned SymbolBinding,
+                                const StringTableBuilder &Strtab) {
   for (const auto &Sym : Symbols) {
     Elf_Sym Symbol;
     zero(Symbol);
     if (!Sym.Name.empty())
-      Symbol.st_name = DotStrtab.getOffset(Sym.Name);
+      Symbol.st_name = Strtab.getOffset(Sym.Name);
     Symbol.setBindingAndType(SymbolBinding, Sym.Type);
     if (!Sym.Section.empty()) {
       unsigned Index;
       if (SN2I.lookup(Sym.Section, Index)) {
         errs() << "error: Unknown section referenced: '" << Sym.Section
                << "' by YAML symbol " << Sym.Name << ".\n";
         exit(1);
       }
bool ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
 
   return true;
 }
 
 template <class ELFT> bool ELFState<ELFT>::buildSectionIndex() {
   SN2I.addName(".symtab", getDotSymTabSecNo());
   SN2I.addName(".strtab", getDotStrTabSecNo());
   SN2I.addName(".shstrtab", getDotShStrTabSecNo());
+  if (hasDynamicSymbols()) {
+    SN2I.addName(".dynsym", getDotDynSymSecNo());
+    SN2I.addName(".dynstr", getDotDynStrSecNo());
+  }
 
   for (unsigned i = 0, e = Doc.Sections.size(); i != e; ++i) {
     StringRef Name = Doc.Sections[i]->Name;
     if (Name.empty())
       continue;
     // "+ 1" to take into account the SHT_NULL entry.
     if (SN2I.addName(Name, i + 1)) {
       errs() << "error: Repeated section name: '" << Name
int ELFState<ELFT>::writeELF(raw_ostream &OS, const ELFYAML::Object &Doc) {
 
   // XXX: This offset is tightly coupled with the order that we write
   // things to `OS`.
   const size_t SectionContentBeginOffset = Header.e_ehsize +
                                            Header.e_phentsize * Header.e_phnum +
                                            Header.e_shentsize * Header.e_shnum;
   ContiguousBlobAccumulator CBA(SectionContentBeginOffset);
 
-  // Doc might not contain .symtab, .strtab and .shstrtab sections,
-  // but we will emit them, so make sure to add them to ShStrTabSHeader.
+  // Doc might not contain these common sections, but we will emit them, so make
+  // sure to add them to ShStrTabSHeader.
   State.DotShStrtab.add(".symtab");
   State.DotShStrtab.add(".strtab");
   State.DotShStrtab.add(".shstrtab");
+  if (State.hasDynamicSymbols()) {
+    State.DotShStrtab.add(".dynsym");
+    State.DotShStrtab.add(".dynstr");
+  }
 
   std::vector<Elf_Shdr> SHeaders;
   if(!State.initSectionHeaders(SHeaders, CBA))
     return 1;
 
   // .symtab section.
   Elf_Shdr SymtabSHeader;
-  State.initSymtabSectionHeader(SymtabSHeader, CBA);
+  State.initSymtabSectionHeader(SymtabSHeader, SymtabType::Static, CBA);
   SHeaders.push_back(SymtabSHeader);
 
   // .strtab string table header.
   Elf_Shdr DotStrTabSHeader;
   State.initStrtabSectionHeader(DotStrTabSHeader, ".strtab", State.DotStrtab,
                                 CBA);
   SHeaders.push_back(DotStrTabSHeader);
 
   // .shstrtab string table header.
   Elf_Shdr ShStrTabSHeader;
   State.initStrtabSectionHeader(ShStrTabSHeader, ".shstrtab", State.DotShStrtab,
                                 CBA);
   SHeaders.push_back(ShStrTabSHeader);
 
+  if (State.hasDynamicSymbols()) {
+    // .dynsym section.
+    Elf_Shdr DynSymtabSHeader;
+    State.initSymtabSectionHeader(DynSymtabSHeader, SymtabType::Dynamic, CBA);
+    SHeaders.push_back(DynSymtabSHeader);
+
+    // .dynstr string table header.
+    Elf_Shdr DynStrSHeader;
+    State.initStrtabSectionHeader(DynStrSHeader, ".dynstr", State.DotDynstr,
+                                  CBA);
+    SHeaders.push_back(DynStrSHeader);
+  }
+
   // Now we can decide segment offsets
   State.setProgramHeaderLayout(PHeaders, SHeaders);
 
   OS.write((const char *)&Header, sizeof(Header));
   writeArrayData(OS, makeArrayRef(PHeaders));
   writeArrayData(OS, makeArrayRef(SHeaders));
   CBA.writeBlobToStream(OS);
   return 0;
 }
 
+template <class ELFT> bool ELFState<ELFT>::hasDynamicSymbols() const {
+  return Doc.DynamicSymbols.Global.size() > 0 ||
+         Doc.DynamicSymbols.Weak.size() > 0 ||
+         Doc.DynamicSymbols.Local.size() > 0;
+}
+
 static bool is64Bit(const ELFYAML::Object &Doc) {
   return Doc.Header.Class == ELFYAML::ELF_ELFCLASS(ELF::ELFCLASS64);
 }
 
 static bool isLittleEndian(const ELFYAML::Object &Doc) {
   return Doc.Header.Data == ELFYAML::ELF_ELFDATA(ELF::ELFDATA2LSB);
 }