Add comdat support.

[ruiu]

I'm not in favor of the optimization you made by merging two hash tables, one for group merging and the other for regular symbols, into one hash table using tagged pointer. I'd really want to simply use StringSet for group dedup'ing and keep the symbol table as is.

Except that the patch looks good overall.

[• rafael]

It was missing some cleanups.

[ruiu]

This looks much better! A few minor comments.

ELF/OutputSections.cpp

551

Add a comment saying that returning false if Sym is pointing to a discarded section group member.

ELF/SymbolTable.h

98

You are not using ComdatSet type here. Maybe we should just remove ComdatSet typedef and always write as DenseSet<StringRef>?

[Eugene.Zelenko]

Committed in r249881.

ELF/InputFiles.h

 
 // The root class of input files.
 class InputFile {
 public:
   enum Kind { ObjectKind, SharedKind, ArchiveKind };
   Kind kind() const { return FileKind; }
   virtual ~InputFile() {}
 
-  // Reads a file (constructors don't do that).
-  virtual void parse() = 0;
-
   StringRef getName() const { return MB.getBufferIdentifier(); }
 
 protected:
   InputFile(Kind K, MemoryBufferRef M) : MB(M), FileKind(K) {}
   MemoryBufferRef MB;
 
 private:
   const Kind FileKind;
public:
   ELFKind getELFKind() const { return EKind; }
 
   uint16_t getEMachine() const;
 
 protected:
   const ELFKind EKind;
 };
 
+typedef llvm::DenseSet<StringRef> ComdatSet;
+
 // .o file.
 class ObjectFileBase : public ELFFileBase {
 public:
   ObjectFileBase(ELFKind EKind, MemoryBufferRef M)
       : ELFFileBase(ObjectKind, EKind, M) {}
   static bool classof(const InputFile *F) { return F->kind() == ObjectKind; }
 
   ArrayRef<SymbolBody *> getSymbols() { return SymbolBodies; }
+  virtual void parse(ComdatSet &Comdats) = 0;
 
 protected:
   // List of all symbols referenced or defined by this file.
   std::vector<SymbolBody *> SymbolBodies;
 
   llvm::BumpPtrAllocator Alloc;
 };
 

 
 template <class ELFT>
 class ObjectFile : public ObjectFileBase, public ELFData<ELFT> {
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym_Range Elf_Sym_Range;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Word Elf_Word;
 
+  typedef llvm::support::detail::packed_endian_specific_integral<
+      uint32_t, ELFT::TargetEndianness, 2> GroupEntryType;
+  StringRef getShtGroupSignature(const Elf_Shdr &Sec);
+  ArrayRef<GroupEntryType> getShtGroupEntries(const Elf_Shdr &Sec);
+
 public:
   using ELFData<ELFT>::getEMachine;
 
   static bool classof(const InputFile *F) {
     return F->kind() == ObjectKind &&
            cast<ELFFileBase>(F)->getELFKind() == getStaticELFKind<ELFT>();
   }
 
   explicit ObjectFile(MemoryBufferRef M);
-  void parse() override;
+  void parse(ComdatSet &Comdats) override;
 
   ArrayRef<InputSection<ELFT> *> getSections() const { return Sections; }
 
   SymbolBody *getSymbolBody(uint32_t SymbolIndex) const {
     uint32_t FirstNonLocal = this->Symtab->sh_info;
     if (SymbolIndex < FirstNonLocal)
       return nullptr;
     return SymbolBodies[SymbolIndex - FirstNonLocal]->repl();
   }
 
   Elf_Sym_Range getLocalSymbols();
 
   const Elf_Shdr *getSymbolTable() const { return this->Symtab; };
   ArrayRef<Elf_Word> getSymbolTableShndx() const { return SymtabSHNDX; };
 
 private:
-  void initializeSections();
+  void initializeSections(ComdatSet &Comdats);
   void initializeSymbols();
 
   SymbolBody *createSymbolBody(StringRef StringTable, const Elf_Sym *Sym);
 
   // List of all sections defined by this file.
   std::vector<InputSection<ELFT> *> Sections;
 
   ArrayRef<Elf_Word> SymtabSHNDX;
 };
 
 class ArchiveFile : public InputFile {
 public:
   explicit ArchiveFile(MemoryBufferRef M) : InputFile(ArchiveKind, M) {}
   static bool classof(const InputFile *F) { return F->kind() == ArchiveKind; }
-  void parse() override;
+  void parse();
 
   // Returns a memory buffer for a given symbol. An empty memory buffer
   // is returned if we have already returned the same memory buffer.
   // (So that we don't instantiate same members more than once.)
   MemoryBufferRef getMember(const Archive::Symbol *Sym);
 
   llvm::MutableArrayRef<Lazy> getLazySymbols() { return LazySymbols; }
   std::vector<MemoryBufferRef> getMembers();
protected:
   StringRef SoName;
 
 public:
   SharedFileBase(ELFKind EKind, MemoryBufferRef M)
       : ELFFileBase(SharedKind, EKind, M) {}
   static bool classof(const InputFile *F) { return F->kind() == SharedKind; }
   StringRef getSoName() const { return SoName; }
   virtual void parseSoName() = 0;
+  virtual void parse() = 0;
 };
 
 template <class ELFT>
 class SharedFile : public SharedFileBase, public ELFData<ELFT> {
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym_Range Elf_Sym_Range;
 

ELF/InputFiles.cpp

 ObjectFile<ELFT>::ObjectFile(MemoryBufferRef M)
     : ObjectFileBase(getStaticELFKind<ELFT>(), M), ELFData<ELFT>(M) {}
 
 template <class ELFT>
 typename ObjectFile<ELFT>::Elf_Sym_Range ObjectFile<ELFT>::getLocalSymbols() {
   return this->getSymbolsHelper(true);
 }
 
-template <class ELFT> void elf2::ObjectFile<ELFT>::parse() {
+template <class ELFT> void elf2::ObjectFile<ELFT>::parse(ComdatSet &Comdats) {
   // Read section and symbol tables.
-  initializeSections();
+  initializeSections(Comdats);
   initializeSymbols();
 }
 
-template <class ELFT> void elf2::ObjectFile<ELFT>::initializeSections() {
+template <class ELFT>
+StringRef ObjectFile<ELFT>::getShtGroupSignature(const Elf_Shdr &Sec) {
+  const ELFFile<ELFT> &Obj = this->ELFObj;
+  uint32_t SymtabdSectionIndex = Sec.sh_link;
+  ErrorOr<const Elf_Shdr *> SecOrErr = Obj.getSection(SymtabdSectionIndex);
+  error(SecOrErr);
+  const Elf_Shdr *SymtabSec = *SecOrErr;
+  uint32_t SymIndex = Sec.sh_info;
+  const Elf_Sym *Sym = Obj.getSymbol(SymtabSec, SymIndex);
+  ErrorOr<StringRef> StringTableOrErr = Obj.getStringTableForSymtab(*SymtabSec);
+  error(StringTableOrErr);
+  ErrorOr<StringRef> SignatureOrErr = Sym->getName(*StringTableOrErr);
+  error(SignatureOrErr);
+  return *SignatureOrErr;
+}
+
+template <class ELFT>
+ArrayRef<typename ObjectFile<ELFT>::GroupEntryType>
+ObjectFile<ELFT>::getShtGroupEntries(const Elf_Shdr &Sec) {
+  const ELFFile<ELFT> &Obj = this->ELFObj;
+  ErrorOr<ArrayRef<GroupEntryType>> EntriesOrErr =
+      Obj.template getSectionContentsAsArray<GroupEntryType>(&Sec);
+  error(EntriesOrErr.getError());
+  ArrayRef<GroupEntryType> Entries = *EntriesOrErr;
+  if (Entries.empty() || Entries[0] != GRP_COMDAT)
+    error("Unsupported SHT_GROUP format");
+  return Entries.slice(1);
+}
+
+template <class ELFT>
+void elf2::ObjectFile<ELFT>::initializeSections(ComdatSet &Comdats) {
   uint64_t Size = this->ELFObj.getNumSections();
   Sections.resize(Size);
-  unsigned I = 0;
+  unsigned I = -1;
   const ELFFile<ELFT> &Obj = this->ELFObj;
   for (const Elf_Shdr &Sec : Obj.sections()) {
+    ++I;
+    if (Sections[I] == &InputSection<ELFT>::Discarded)
+      continue;
+
     switch (Sec.sh_type) {
+    case SHT_GROUP:
+      Sections[I] = &InputSection<ELFT>::Discarded;
+      if (Comdats.insert(getShtGroupSignature(Sec)).second)
+        continue;
+      for (GroupEntryType E : getShtGroupEntries(Sec)) {
+        uint32_t SecIndex = E;
+        if (SecIndex >= Size)
+          error("Invalid section index in group");
+        Sections[SecIndex] = &InputSection<ELFT>::Discarded;
+      }
+      break;
     case SHT_SYMTAB:
       this->Symtab = &Sec;
       break;
     case SHT_SYMTAB_SHNDX: {
       ErrorOr<ArrayRef<Elf_Word>> ErrorOrTable = Obj.getSHNDXTable(Sec);
       error(ErrorOrTable);
       SymtabSHNDX = *ErrorOrTable;
       break;
case SHT_REL: {
         error("Unsupported relocation reference");
       RelocatedSection->RelocSections.push_back(&Sec);
       break;
     }
     default:
       Sections[I] = new (Alloc) InputSection<ELFT>(this, &Sec);
       break;
     }
-    ++I;
   }
 }
 
 template <class ELFT> void elf2::ObjectFile<ELFT>::initializeSymbols() {
   this->initStringTable();
   Elf_Sym_Range Syms = this->getNonLocalSymbols();
   uint32_t NumSymbols = std::distance(Syms.begin(), Syms.end());
   SymbolBodies.reserve(NumSymbols);
SymbolBody *elf2::ObjectFile<ELFT>::createSymbolBody(StringRef StringTable,
   if (SecIndex >= Sections.size() || !SecIndex || !Sections[SecIndex])
     error("Invalid section index");
 
   switch (Sym->getBinding()) {
   default:
     error("unexpected binding");
   case STB_GLOBAL:
   case STB_WEAK:
-  case STB_GNU_UNIQUE:
-    return new (Alloc) DefinedRegular<ELFT>(Name, *Sym, *Sections[SecIndex]);
+  case STB_GNU_UNIQUE: {
+    InputSection<ELFT> *Sec = Sections[SecIndex];
+    if (Sec == &InputSection<ELFT>::Discarded)
+      return new (Alloc) Undefined<ELFT>(Name, *Sym);
+    return new (Alloc) DefinedRegular<ELFT>(Name, *Sym, *Sec);
+  }
   }
 }
 
 static std::unique_ptr<Archive> openArchive(MemoryBufferRef MB) {
   ErrorOr<std::unique_ptr<Archive>> ArchiveOrErr = Archive::create(MB);
   error(ArchiveOrErr, "Failed to parse archive");
   return std::move(*ArchiveOrErr);
 }

ELF/InputSection.h

public:
   void setOutputSectionOff(uint64_t V) { OutputSectionOff = V; }
 
   void setOutputSection(OutputSection<ELFT> *O) { OutSec = O; }
   OutputSection<ELFT> *getOutputSection() const { return OutSec; }
 
   // Relocation sections that refer to this one.
   SmallVector<const Elf_Shdr *, 1> RelocSections;
 
+  static InputSection<ELFT> Discarded;
+
 private:
   template <bool isRela>
   void relocate(uint8_t *Buf,
                 llvm::iterator_range<
                     const llvm::object::Elf_Rel_Impl<ELFT, isRela> *> Rels,
                 const ObjectFile<ELFT> &File, uintX_t BaseAddr);
 
   // The offset from beginning of the output sections this section was assigned
   // to. The writer sets a value.
   uint64_t OutputSectionOff = 0;
 
   // The file this section is from.
   ObjectFile<ELFT> *File;
 
   OutputSection<ELFT> *OutSec = nullptr;
 
   const Elf_Shdr *Header;
 };
 
+template <class ELFT>
+InputSection<ELFT> InputSection<ELFT>::Discarded(nullptr, nullptr);
+
 } // namespace elf2
 } // namespace lld
 
 #endif

ELF/OutputSections.h

getLocalSymVA(const typename llvm::object::ELFFile<ELFT>::Elf_Sym *Sym,
               const ObjectFile<ELFT> &File);
 bool canBePreempted(const SymbolBody *Body);
 template <class ELFT> bool includeInSymtab(const SymbolBody &B);
 
 bool includeInDynamicSymtab(const SymbolBody &B);
 
 template <class ELFT>
 bool shouldKeepInSymtab(
-    StringRef Name, const typename llvm::object::ELFFile<ELFT>::Elf_Sym &Sym);
+    const ObjectFile<ELFT> &File, StringRef Name,
+    const typename llvm::object::ELFFile<ELFT>::Elf_Sym &Sym);
 
 // This represents a section in an output file.
 // Different sub classes represent different types of sections. Some contain
 // input sections, others are created by the linker.
 // The writer creates multiple OutputSections and assign them unique,
 // non-overlapping file offsets and VAs.
 template <bool Is64Bits> class OutputSectionBase {
 public:

ELF/OutputSections.cpp

lld::elf2::getLocalSymVA(const typename ELFFile<ELFT>::Elf_Sym *Sym,
                          const ObjectFile<ELFT> &File) {
   uint32_t SecIndex = Sym->st_shndx;
 
   if (SecIndex == SHN_XINDEX)
     SecIndex = File.getObj().getExtendedSymbolTableIndex(
         Sym, File.getSymbolTable(), File.getSymbolTableShndx());
   ArrayRef<InputSection<ELFT> *> Sections = File.getSections();
   InputSection<ELFT> *Section = Sections[SecIndex];
+
+  // According to the ELF spec reference to a local symbol from outside
+  // the group are not allowed. Unfortunately .eh_frame breaks that rule
+  // and must be treated specially. For now we just replace the symbol with
+  // 0.
+  if (Section == &InputSection<ELFT>::Discarded)
+    return 0;
+
   OutputSection<ELFT> *OutSec = Section->getOutputSection();
   return OutSec->getVA() + Section->getOutputSectionOff() + Sym->st_value;
 }
 
 bool lld::elf2::canBePreempted(const SymbolBody *Body) {
   if (!Body)
     return false;
   if (Body->isShared())
if (V != STV_DEFAULT && V != STV_PROTECTED)
     return false;
 
   if (Config->ExportDynamic || Config->Shared)
     return true;
   return B.isUsedInDynamicReloc();
 }
 
 template <class ELFT>
-bool lld::elf2::shouldKeepInSymtab(StringRef SymName,
+bool lld::elf2::shouldKeepInSymtab(const ObjectFile<ELFT> &File,
+                                   StringRef SymName,
                                    const typename ELFFile<ELFT>::Elf_Sym &Sym) {
   if (Sym.getType() == STT_SECTION)
     return false;
 
+  uint32_t SecIndex = Sym.st_shndx;
+  if (SecIndex != SHN_ABS) {
+    if (SecIndex == SHN_XINDEX)
+      SecIndex = File.getObj().getExtendedSymbolTableIndex(
+          &Sym, File.getSymbolTable(), File.getSymbolTableShndx());
+    ArrayRef<InputSection<ELFT> *> Sections = File.getSections();
+    const InputSection<ELFT> *Section = Sections[SecIndex];
+    if (Section == &InputSection<ELFT>::Discarded)
+      return false;
+  }
+
   if (Config->DiscardNone)
     return true;
 
   // ELF defines dynamic locals as symbols which name starts with ".L".
   return !(Config->DiscardLocals && SymName.startswith(".L"));
 }
 
 template <class ELFT>
void SymbolTableSection<ELFT>::writeLocalSymbols(uint8_t *&Buf) {
   // to the output symbol table pointed by Buf.
   for (const std::unique_ptr<ObjectFileBase> &FileB : Table.getObjectFiles()) {
     auto &File = cast<ObjectFile<ELFT>>(*FileB);
     Elf_Sym_Range Syms = File.getLocalSymbols();
     for (const Elf_Sym &Sym : Syms) {
       ErrorOr<StringRef> SymNameOrErr = Sym.getName(File.getStringTable());
       error(SymNameOrErr);
       StringRef SymName = *SymNameOrErr;
-      if (!shouldKeepInSymtab<ELFT>(SymName, Sym))
+      if (!shouldKeepInSymtab<ELFT>(File, SymName, Sym))
         continue;
+
       auto *ESym = reinterpret_cast<Elf_Sym *>(Buf);
       Buf += sizeof(*ESym);
       ESym->st_name = StrTabSec.getFileOff(SymName);
       ESym->st_size = Sym.st_size;
       ESym->setBindingAndType(Sym.getBinding(), Sym.getType());
       uint32_t SecIndex = Sym.st_shndx;
       uintX_t VA = Sym.st_value;
       if (SecIndex == SHN_ABS) {

 template ELFFile<ELF64BE>::uintX_t
 getLocalSymVA(const ELFFile<ELF64BE>::Elf_Sym *, const ObjectFile<ELF64BE> &);
 
 template bool includeInSymtab<ELF32LE>(const SymbolBody &);
 template bool includeInSymtab<ELF32BE>(const SymbolBody &);
 template bool includeInSymtab<ELF64LE>(const SymbolBody &);
 template bool includeInSymtab<ELF64BE>(const SymbolBody &);
 
-template bool shouldKeepInSymtab<ELF32LE>(StringRef,
+template bool shouldKeepInSymtab<ELF32LE>(const ObjectFile<ELF32LE> &,
+                                          StringRef,
                                           const ELFFile<ELF32LE>::Elf_Sym &);
-template bool shouldKeepInSymtab<ELF32BE>(StringRef,
+template bool shouldKeepInSymtab<ELF32BE>(const ObjectFile<ELF32BE> &,
+                                          StringRef,
                                           const ELFFile<ELF32BE>::Elf_Sym &);
-template bool shouldKeepInSymtab<ELF64LE>(StringRef,
+template bool shouldKeepInSymtab<ELF64LE>(const ObjectFile<ELF64LE> &,
+                                          StringRef,
                                           const ELFFile<ELF64LE>::Elf_Sym &);
-template bool shouldKeepInSymtab<ELF64BE>(StringRef,
+template bool shouldKeepInSymtab<ELF64BE>(const ObjectFile<ELF64BE> &,
+                                          StringRef,
                                           const ELFFile<ELF64BE>::Elf_Sym &);
 }
 }

ELF/SymbolTable.h

private:
   // The default hashing of StringRef produces different results on 32 and 64
   // bit systems so we use a MapVector. That is arbitrary, deterministic but
   // a bit inefficient.
   // FIXME: Experiment with passing in a custom hashing or sorting the symbols
   // once symbol resolution is finished.
   llvm::MapVector<StringRef, Symbol *> Symtab;
   llvm::BumpPtrAllocator Alloc;
 
+  llvm::DenseSet<StringRef> Comdats;
+
   // The writer needs to infer the machine type from the object files.
   std::vector<std::unique_ptr<ObjectFileBase>> ObjectFiles;
 
   std::vector<std::unique_ptr<SharedFileBase>> SharedFiles;
   llvm::DenseSet<StringRef> IncludedSoNames;
 
   SymbolBody *EntrySym = nullptr;
 };
 
 } // namespace elf2
 } // namespace lld
 
 #endif

ELF/SymbolTable.cpp

if (auto *AF = dyn_cast<ArchiveFile>(File.get())) {
     for (Lazy &Sym : AF->getLazySymbols())
       addLazy(&Sym);
     return;
   }
   if (auto *S = dyn_cast<SharedFileBase>(File.get())) {
     S->parseSoName();
     if (!IncludedSoNames.insert(S->getSoName()).second)
       return;
+    S->parse();
+  } else {
+    cast<ObjectFileBase>(File.get())->parse(Comdats);
   }
-  File->parse();
   addELFFile(cast<ELFFileBase>(File.release()));
 }
 
 static TargetInfo *createTarget(uint16_t EMachine) {
   switch (EMachine) {
   case EM_386:
     return new X86TargetInfo();
   case EM_AARCH64:

ELF/Writer.cpp

 // each object file's symbol table to copy local symbols to the output.
 template <class ELFT> void Writer<ELFT>::copyLocalSymbols() {
   for (const std::unique_ptr<ObjectFileBase> &FileB : Symtab.getObjectFiles()) {
     auto &File = cast<ObjectFile<ELFT>>(*FileB);
     for (const Elf_Sym &Sym : File.getLocalSymbols()) {
       ErrorOr<StringRef> SymNameOrErr = Sym.getName(File.getStringTable());
       error(SymNameOrErr);
       StringRef SymName = *SymNameOrErr;
-      if (shouldKeepInSymtab<ELFT>(SymName, Sym))
-        Out<ELFT>::SymTab->addSymbol(SymName, true);
+      if (!shouldKeepInSymtab<ELFT>(File, SymName, Sym))
+        continue;
     }
   }
 }
 
 // Output section ordering is determined by this function.
 template <class ELFT>
 static bool compareOutputSections(OutputSectionBase<ELFT::Is64Bits> *A,
                                   OutputSectionBase<ELFT::Is64Bits> *B) {
template <class ELFT> void Writer<ELFT>::createSections() {
   // __tls_get_addr, so it's not defined anywhere. Create a hidden definition
   // to avoid the undefined symbol error.
   if (!isOutputDynamic())
     Symtab.addIgnoredSym<ELFT>("__tls_get_addr");
 
   for (const std::unique_ptr<ObjectFileBase> &FileB : Symtab.getObjectFiles()) {
     auto &File = cast<ObjectFile<ELFT>>(*FileB);
     for (InputSection<ELFT> *C : File.getSections()) {
-      if (!C)
+      if (!C || C == &InputSection<ELFT>::Discarded)
         continue;
       const Elf_Shdr *H = C->getSectionHdr();
-      SectionKey<ELFT::Is64Bits> Key{C->getSectionName(), H->sh_type,
-                                     H->sh_flags};
+      uintX_t OutFlags = H->sh_flags & ~SHF_GROUP;
+      SectionKey<ELFT::Is64Bits> Key{C->getSectionName(), H->sh_type, OutFlags};
       OutputSection<ELFT> *&Sec = Map[Key];
       if (!Sec) {
         Sec = new (CAlloc.Allocate())
             OutputSection<ELFT>(Key.Name, Key.Type, Key.Flags);
         OutputSections.push_back(Sec);
       }
       Sec->addSection(C);
       scanRelocs(*C);

test/elf2/Inputs/comdat.s

+        .section .text3,"axG",@progbits,zed,comdat,unique,0
+        .global abc
+abc:

test/elf2/comdat.s

+// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
+// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/comdat.s -o %t2.o
+// RUN: ld.lld2 -shared %t.o %t.o %t2.o -o %t
+// RUN: llvm-objdump -d %t | FileCheck %s
+// RUN: llvm-readobj -s -t %t | FileCheck --check-prefix=READ %s
+// REQUIRES: x86
+
+        .section  .text2,"axG",@progbits,foo,comdat,unique,0
+foo:
+        nop
+
+// CHECK: Disassembly of section .text2:
+// CHECK-NEXT: foo:
+// CHECK-NEXT:   2000: {{.*}}  nop
+// CHECK-NOT: nop
+
+        .section bar, "ax"
+        call foo
+
+// CHECK: Disassembly of section bar:
+// CHECK-NEXT: bar:
+// 0x2000 - 0x2001 - 5 = -6
+// 0      - 0x2006 - 5 = -8203
+// CHECK-NEXT:   2001:  {{.*}}  callq  -6
+// CHECK-NEXT:   2006:  {{.*}}  callq  -8203
+
+        .section .text3,"axG",@progbits,zed,comdat,unique,0
+
+
+// READ:      Name: .text2
+// READ-NEXT: Type: SHT_PROGBITS
+// READ-NEXT: Flags [
+// READ-NEXT:   SHF_ALLOC
+// READ-NEXT:   SHF_EXECINSTR
+// READ-NEXT: ]
+
+// READ:      Name: .text3
+// READ-NEXT: Type: SHT_PROGBITS
+// READ-NEXT: Flags [
+// READ-NEXT:   SHF_ALLOC
+// READ-NEXT:   SHF_EXECINSTR
+// READ-NEXT: ]
+
+// READ:      Symbols [
+// READ-NEXT:   Symbol {
+// READ-NEXT:     Name:  (0)
+// READ-NEXT:     Value: 0x0
+// READ-NEXT:     Size: 0
+// READ-NEXT:     Binding: Local
+// READ-NEXT:     Type: None
+// READ-NEXT:     Other: 0
+// READ-NEXT:     Section: Undefined
+// READ-NEXT:   }
+// READ-NEXT:   Symbol {
+// READ-NEXT:     Name: foo
+// READ-NEXT:     Value
+// READ-NEXT:     Size: 0
+// READ-NEXT:     Binding: Local
+// READ-NEXT:     Type: None
+// READ-NEXT:     Other: 0
+// READ-NEXT:     Section: .text
+// READ-NEXT:   }
+// READ-NEXT:   Symbol {
+// READ-NEXT:     Name: abc
+// READ-NEXT:     Value: 0x0
+// READ-NEXT:     Size: 0
+// READ-NEXT:     Binding: Global
+// READ-NEXT:     Type: None
+// READ-NEXT:     Other: 0
+// READ-NEXT:     Section: Undefined
+// READ-NEXT:   }
+// READ-NEXT: ]