[llvm-elfabi] Emit ELF .dynsym and .dynamic sections

[haowei]

Summary

This change makes llvm-elfabi tool to generate a minimal stub ELF shared library just for linking purpose from a tbe file. Tested with lld.

[mcgrathr]

LGTM. The section ordering details are conventional but not supposed to be semantically meaningful anyway.

llvm/lib/InterfaceStub/ELFObjHandler.cpp

115

Seems safer to use s{}.

128

Making this S{} both obviates the need to set any values explicitly to zero and also ensures no field was forgotten.

143

This could be a single memcpy call using Symbols.data().

203

This could be a single memcpy call using Entries.data().

209

Just constexpr Elf_Dyn{} is enough here. You could also just memset directly instead of copying some zero bytes with memcpy.

221

No other flags are expected for SHT_DYNSYM or SHT_SYMTAB.

235

This need not set SHF_WRITE. e.g. Fuchsia uses -z rodynamic and some other platforms use R/O .dynamic sections. The writability does not matter at link time.

260

sizeof(Elf_Addr) seems clearest here and in other such cases.

267–272

Traditionally the ordering is to put all SHF_ALLOC sections before all others. .shstrtab in particular is usually the last section.

274

Traditional ordering between these is: .dynsym, .dynstr, .dynamic.

[plotfi]

Nice. Will you folks be updating llvm-ifs to use this support instead of yaml2obj soon? If so add me to the review, I will be happy to take a look.

[MaskRay]

There appears to multiple review comments from @mcgrathr so I think "Request Changes" is the suitable action for now.

llvm/lib/InterfaceStub/ELFObjHandler.cpp

131

Remove the TODO. 0 is safe.

[phosek]

In D89432#2350758, @plotfi wrote:

Nice. Will you folks be updating llvm-ifs to use this support instead of yaml2obj soon? If so add me to the review, I will be happy to take a look.

That's the plan. When the InterfaceStub library is ready, which should be soon hopefully, we'll integrate it into llvm-ifs and remove llvm-elfabi.

[MaskRay]

llvm/lib/InterfaceStub/ELFObjHandler.cpp

266–267

Remove braces
http://llvm.org/docs/CodingStandards.html#don-t-use-braces-on-simple-single-statement-bodies-of-if-else-loop-statements

289

Capitalize the comment and end with a period.

https://llvm.org/docs/CodingStandards.html#commenting

299

ditto

303

ditto

358

Usually linkers place .dynsym .dynstr before .strtab .shstrtab .symtab

The source order does not reflect the actual order and can cause confusion

llvm/test/tools/llvm-elfabi/binary-write-sheaders.test

96

The section order should be changed. See the comment above.

[haowei]

Address review comments.

[haowei]

llvm/lib/InterfaceStub/ELFObjHandler.cpp

358

I have reordered the section headers. The StrTab here is actually .dynstr since a stub SO does not need .strtab .

[grimar]

llvm/lib/InterfaceStub/ELFObjHandler.cpp

113

You can avoid having 2 public: areas by merging them.

195

If you add DT_NULL explicitly in the code, then you can simplify these 2 methods to:

size_t getSize() const { return Entries.size() * sizeof(Elf_Dyn); }
 
void write(uint8_t *Buf) const { memcpy(Buf, Entries.data(), getSize()); }

[grimar]

llvm/lib/InterfaceStub/ELFObjHandler.cpp

183

It is not clear why these e methods are needed? You could just call addValue on the caller side.

[haowei]

address review comments.

[haowei]

llvm/lib/InterfaceStub/ELFObjHandler.cpp

113

The private section needs the "Elf_Sym" type alias declared in the first public section and the second public section requires the private "Symbols" variable. So I don't think I can merge the two public sections as it is a chicken and egg issue.

183

I feel these methods are better for readability. I removed those in latest patch.

195

I prefer to keep "add DT_NULL" in the builder class instead of explicitly in the code. It reduces the chance a maintainer add new entries after DT_NULL entry in the future.

[grimar]

llvm/lib/InterfaceStub/ELFObjHandler.cpp

113

There is no chicken and egg issue here. C++ doesn't work like that.
You don`t have ro declare the Symbols member before using it in member functions.
So, you can do the following:

template <class ELFT> class ELFSymbolTableBuilder {
public:
  using Elf_Sym = typename ELFT::Sym;

  ELFSymbolTableBuilder() {
    Elf_Sym S{};
    Symbols.push_back(S);
  }

  void add(ELFStringTableBuilder &StrTabBuilder, StringRef StName,
           uint64_t StSize, uint8_t StBind, uint8_t StType, uint8_t StOther,
           uint16_t StShndx) {
    Elf_Sym S{};
    S.st_name = StrTabBuilder.getOffset(StName);
    S.st_size = StSize;
    S.st_info = (StBind << 4) | (StType & 0xf);
    S.st_other = StOther;
    S.st_shndx = StShndx;
    Symbols.push_back(S);
  }

  size_t getSize() const { return Symbols.size() * sizeof(Elf_Sym); }

  void write(uint8_t *Buf) const {
    memcpy(Buf, Symbols.data(), sizeof(Elf_Sym) * Symbols.size());
  }

private:
  llvm::SmallVector<Elf_Sym, 64> Symbols;
};

119

Instead of passing both StrTabBuilder abd StName you can just pass an offset.

195

I think, this is a design issue. With this approach Entries doesn't contain all entries written.
DT_NULL is a terminator entry, but it is still an entry.

Though, if you want go this way, then you should be able to use memset:
memset(Buf + sizeof(Elf_Dyn) * Entries.size(), 0, sizeof(Elf_Dyn));

instead of

constexpr Elf_Dyn Terminator{};
memcpy(Buf + sizeof(Elf_Dyn) * Entries.size(), &Terminator,
       sizeof(Elf_Dyn));

[grimar]

Also, I was unable to apply this patch. Seems it is rebased on a different one. In this way you probably might want to add a parent revision,
so that dependencies can be seen.

[MaskRay]

llvm/lib/InterfaceStub/ELFObjHandler.cpp

111

64 is too large. This costs 24*64 bytes to the class. 0 may be fine assuming you always need a dynamic allocation (which is not a big deal)

300

Linkers don't read DT_SYMTAB or DT_STRTAB.

[haowei]

Address review comments

[haowei]

llvm/lib/InterfaceStub/ELFObjHandler.cpp

111

I changed the value to 8, similar to other SmallVector used in this file. I think it should be small enough now.

113

Thanks for pointing out. I have merged 2 public sections.

119

Done.

195

I changed it to memset.

300

I tried locally to remove DT_SYMTAB and DT_STRTAB and confirm it does not affect linking. But I would prefer to keep these 2 entries since the generated Stub SO file does have .dynstr and .dynsym sections. There might be other tools would look for these references in .dynamic table and it would yield unexpected results if they are removed.

[haowei]

In D89432#2355544, @grimar wrote:

Also, I was unable to apply this patch. Seems it is rebased on a different one. In this way you probably might want to add a parent revision,
so that dependencies can be seen.

Sorry about that. I thought the attachment to the parent revision would be automatic. I have manually attached the parent revision to this diff.

[grimar]

I have no more comments (added a minor nit).

In D89432#2357600, @haowei wrote:

I thought the attachment to the parent revision would be automatic. I have manually attached the parent revision to this diff.

It can be automatic if you add the following line to the patch description when posting:
"Depends on D<patchid>". E.g. "Depends on D61767" in this case.

llvm/lib/InterfaceStub/ELFObjHandler.cpp

112

nit: you should be able to do:

Symbols.push_back({});

[haowei]

address review comments

[MaskRay]

Please let @grimar approve:)

[grimar]

After revisiting this patch I have some more questions :]

llvm/lib/InterfaceStub/ELFObjHandler.cpp

150

Can't this be the following?

void modifyAddr(size_t Index, uint64_t Addr) {
  Entries[Index].d_un.d_ptr = Addr;
}

(the same below)

294

I am not sure what is happening here. Could you explain?
Why a symbol is attached to .text and why it is assumed that .text has index 1?
Also, where it is tested?

[haowei]

Address review concerns.

[haowei]

llvm/lib/InterfaceStub/ELFObjHandler.cpp

150

Fixed in latest diff.

294

This snippet adds symbols from the ELFStub structure into the .dynsym section builder. The "1" here is a placeholder. It does not mean ".text" has to be index 1. The issue here is for non-Undefined symbols, the shndx needs to be a value other than 0. Please correct me if I am wrong, at link time, for dynamic linking, the shndx value does not matter as long as it is not SHN_UNDEF for non-Undefined symbols, that why I put 1 here, which in current state, it points to ".dynsym" itself.

The TODO message means I would like to add a dummy place holder ".text" section and point symbols to it in the stub SO in case any tool need a valid shndx value. For linking with ld/lld, I don't think that is necessary.

I added section name in the binary-write-sheaders.test to verify shndx is filled with expected value. I do want to add some integration test to verify this elfabi tool will work with clang and lld, but it looks like I don't have access to the lld in the llvm test. If you have any good suggestion for integration testing, please let me know.

We did performed end to end testing with elfabi tool in Fuchsia build and the linked binary from stub SO were equivalent to the ones linked from original SO files. If we chose to preserve the order of symbol table, the build results were the same bit by bit.

[grimar]

llvm/lib/InterfaceStub/ELFObjHandler.cpp

150

Not fixed. I suggested a one line method.

294

Please correct me if I am wrong, at link time, for dynamic linking, the shndx value does not matter as long as it is not SHN_UNDEF for non-Undefined symbols, that why I put 1 here, which in current state, it points to ".dynsym" itself.

I guess you are right. I can't imagine a good reason why shndx can be important in run time. Perhaps someone else who are more familar with the logic of existent dynamic loaders can confirm.

The TODO message means I would like to add a dummy place holder ".text" section and point symbols to it in the stub SO in case any tool need a valid shndx value.

I think you should use "point" word, not "points" then (in the TODO comment). Now the comment sounds like it already points to .text.

Also, I think it worth to update this comment to explain that the symbol index is not really important and you assign an arbitrary non-SNH_UNDEF value, which now points to .dynsym itself.

I am not sure how much is useful to mention ".text" here (i.e. how much usefull would be to add this section and TODO about that plan).
As far I understand there is no known tool that is known to not like the existent behavior.

I added section name in the binary-write-sheaders.test to verify shndx is filled with expected value.

I think it is enough. The behavior of LLD is tested separatelly.

[haowei]

llvm/lib/InterfaceStub/ELFObjHandler.cpp

150

I see, I misunderstood your suggestion. It should be fixed in latest diff now.

294

I have updated the comment section and remove the TODO.

[grimar]

LGTM I think.

llvm/lib/InterfaceStub/ELFObjHandler.cpp

 
 // default constructable. This class just wraps it for the purpose of adding a
 // default constructor.
 class ELFStringTableBuilder : public StringTableBuilder {
 public:
   ELFStringTableBuilder() : StringTableBuilder(StringTableBuilder::ELF) {}
 };
 
+template <class ELFT> class ELFSymbolTableBuilder {
+public:
+  using Elf_Sym = typename ELFT::Sym;
+
+  ELFSymbolTableBuilder() {
+    Elf_Sym S{};
+    Symbols.push_back(S);
+  }
+
+  void add(size_t StNameOffset, uint64_t StSize, uint8_t StBind, uint8_t StType,
+           uint8_t StOther, uint16_t StShndx) {
+    Elf_Sym S{};
+    S.st_name = StNameOffset;
+    S.st_size = StSize;
+    S.st_info = (StBind << 4) | (StType & 0xf);
+    S.st_other = StOther;
+    S.st_shndx = StShndx;
+    Symbols.push_back(S);
+  }
+
+  size_t getSize() const { return Symbols.size() * sizeof(Elf_Sym); }
+
+  void write(uint8_t *Buf) const {
+    memcpy(Buf, Symbols.data(), sizeof(Elf_Sym) * Symbols.size());
+  }
+
+private:
+  llvm::SmallVector<Elf_Sym, 8> Symbols;
+};
+
+template <class ELFT> class ELFDynamicTableBuilder {
+public:
+  using Elf_Dyn = typename ELFT::Dyn;
+
+private:
+  llvm::SmallVector<Elf_Dyn, 8> Entries;
+
+public:
+  size_t addAddr(uint64_t Tag, uint64_t Addr) {
+    Elf_Dyn Entry;
+    Entry.d_tag = Tag;
+    Entry.d_un.d_ptr = Addr;
+    Entries.push_back(Entry);
+    return Entries.size() - 1;
+  }
+
+  void modifyAddr(size_t Index, uint64_t Tag, uint64_t Addr) {
+    Elf_Dyn Entry;
+    Entry.d_tag = Tag;
+    Entry.d_un.d_ptr = Addr;
+    Entries[Index] = Entry;
+  }
+
+  size_t addValue(uint64_t Tag, uint64_t Value) {
+    Elf_Dyn Entry;
+    Entry.d_tag = Tag;
+    Entry.d_un.d_val = Value;
+    Entries.push_back(Entry);
+    return Entries.size() - 1;
+  }
+
+  void modifyValue(size_t Index, uint64_t Tag, uint64_t Value) {
+    Elf_Dyn Entry;
+    Entry.d_tag = Tag;
+    Entry.d_un.d_val = Value;
+    Entries[Index] = Entry;
+  }
+
+  size_t getSize() const {
+    // Add DT_NULL entry at the end.
+    return (Entries.size() + 1) * sizeof(Elf_Dyn);
+  }
+
+  void write(uint8_t *Buf) const {
+    memcpy(Buf, Entries.data(), sizeof(Elf_Dyn) * Entries.size());
+    // Add DT_NULL entry at the end.
+    memset(Buf + sizeof(Elf_Dyn) * Entries.size(), 0, sizeof(Elf_Dyn));
+  }
+};
+
 template <class ELFT> class ELFStubBuilder {
 public:
   using Elf_Ehdr = typename ELFT::Ehdr;
   using Elf_Shdr = typename ELFT::Shdr;
   using Elf_Phdr = typename ELFT::Phdr;
   using Elf_Sym = typename ELFT::Sym;
   using Elf_Addr = typename ELFT::Addr;
   using Elf_Dyn = typename ELFT::Dyn;
 
 private:
   Elf_Ehdr ElfHeader;
   ContentSection<ELFStringTableBuilder, ELFT> StrTab;
   ContentSection<ELFStringTableBuilder, ELFT> ShStrTab;
+  ContentSection<ELFSymbolTableBuilder<ELFT>, ELFT> DynSym;
+  ContentSection<ELFDynamicTableBuilder<ELFT>, ELFT> DynTab;
 
   template <class T> static void write(uint8_t *Data, const T &Value) {
     *reinterpret_cast<T *>(Data) = Value;
   }
   void fillStrTabShdr(ContentSection<ELFStringTableBuilder, ELFT> &StrTab,
                       uint32_t ShFlags = 0) const {
     StrTab.Shdr.sh_type = SHT_STRTAB;
     StrTab.Shdr.sh_flags = ShFlags;
     StrTab.Shdr.sh_addr = StrTab.Addr;
     StrTab.Shdr.sh_offset = StrTab.Offset;
     StrTab.Shdr.sh_info = 0;
     StrTab.Shdr.sh_size = StrTab.Size;
     StrTab.Shdr.sh_name = this->ShStrTab.Content.getOffset(StrTab.Name);
     StrTab.Shdr.sh_addralign = StrTab.Align;
     StrTab.Shdr.sh_entsize = 0;
     StrTab.Shdr.sh_link = 0;
   }
+  void fillSymTabShdr(ContentSection<ELFSymbolTableBuilder<ELFT>, ELFT> &SymTab,
+                      uint32_t ShType) const {
+    SymTab.Shdr.sh_type = ShType;
+    SymTab.Shdr.sh_flags = SHF_ALLOC;
+    SymTab.Shdr.sh_addr = SymTab.Addr;
+    SymTab.Shdr.sh_offset = SymTab.Offset;
+    SymTab.Shdr.sh_info = SymTab.Size / sizeof(Elf_Sym) > 1 ? 1 : 0;
+    SymTab.Shdr.sh_size = SymTab.Size;
+    SymTab.Shdr.sh_name = this->ShStrTab.Content.getOffset(SymTab.Name);
+    SymTab.Shdr.sh_addralign = SymTab.Align;
+    SymTab.Shdr.sh_entsize = sizeof(Elf_Sym);
+    SymTab.Shdr.sh_link = this->StrTab.Index;
+  }
+  void fillDynTabShdr(
+      ContentSection<ELFDynamicTableBuilder<ELFT>, ELFT> &DynTab) const {
+    DynTab.Shdr.sh_type = SHT_DYNAMIC;
+    DynTab.Shdr.sh_flags = SHF_ALLOC;
+    DynTab.Shdr.sh_addr = DynTab.Addr;
+    DynTab.Shdr.sh_offset = DynTab.Offset;
+    DynTab.Shdr.sh_info = 0;
+    DynTab.Shdr.sh_size = DynTab.Size;
+    DynTab.Shdr.sh_name = this->ShStrTab.Content.getOffset(DynTab.Name);
+    DynTab.Shdr.sh_addralign = DynTab.Align;
+    DynTab.Shdr.sh_entsize = sizeof(Elf_Dyn);
+    DynTab.Shdr.sh_link = this->StrTab.Index;
+  }
   uint64_t shdrOffset(const OutputSection<ELFT> &Sec) const {
     return ElfHeader.e_shoff + Sec.Index * sizeof(Elf_Shdr);
   }
   void writeShdr(uint8_t *Data, const OutputSection<ELFT> &Sec) const {
     write(Data + shdrOffset(Sec), Sec.Shdr);
   }
 
 public:
   ELFStubBuilder(const ELFStubBuilder &) = delete;
   ELFStubBuilder(ELFStubBuilder &&) = default;
   explicit ELFStubBuilder(const ELFStub &Stub) {
-    // populate string tables.
-    ShStrTab.Name = ".shstrtab";
-    ShStrTab.Align = 0;
+    DynSym.Name = ".dynsym";
+    DynSym.Align = sizeof(Elf_Addr);
     StrTab.Name = ".dynstr";
     StrTab.Align = 0;
-    for (const auto &Sym : Stub.Symbols) {
+    DynTab.Name = ".dynamic";
+    DynTab.Align = sizeof(Elf_Addr);
+    ShStrTab.Name = ".shstrtab";
+    ShStrTab.Align = 0;
+
+    // Populate string tables.
+    for (const auto &Sym : Stub.Symbols)
       StrTab.Content.add(Sym.Name);
-    }
-    std::vector<OutputSection<ELFT> *> Sections;
-    Sections.push_back(&ShStrTab);
+    for (const auto &Lib : Stub.NeededLibs)
+      StrTab.Content.add(Lib);
+    if (Stub.SoName)
+      StrTab.Content.add(Stub.SoName.getValue());
+    llvm::SmallVector<OutputSection<ELFT> *, 8> Sections;
+    Sections.push_back(&DynSym);
     Sections.push_back(&StrTab);
+    Sections.push_back(&DynTab);
+    Sections.push_back(&ShStrTab);
     const OutputSection<ELFT> *LastSection = Sections.back();
     // Now set the Index and put sections names into .shstrtab .
     uint64_t Index = 1;
     for (auto Sec : Sections) {
       Sec->Index = Index++;
       if (!Sec->Name.empty())
         ShStrTab.Content.add(Sec->Name);
     }
     ShStrTab.Content.finalize();
     ShStrTab.Size = ShStrTab.Content.getSize();
     StrTab.Content.finalize();
     StrTab.Size = StrTab.Content.getSize();
+
+    // Populate dynamic symbol table.
+    for (const auto &Sym : Stub.Symbols) {
+      uint8_t Bind = Sym.Weak ? STB_WEAK : STB_GLOBAL;
+      // TODO: Points st_shndx to a dummy .text section.
+      uint16_t Shndx = Sym.Undefined ? SHN_UNDEF : 1;
+      DynSym.Content.add(StrTab.Content.getOffset(Sym.Name), Sym.Size, Bind,
+                         (uint8_t)Sym.Type, 0, Shndx);
+    }
+    DynSym.Size = DynSym.Content.getSize();
+
+    // Poplulate dynamic table.
+    size_t DynSymIndex = DynTab.Content.addAddr(DT_SYMTAB, 0);
+    size_t DynStrIndex = DynTab.Content.addAddr(DT_STRTAB, 0);
+    for (const auto &Lib : Stub.NeededLibs)
+      DynTab.Content.addValue(DT_NEEDED, StrTab.Content.getOffset(Lib));
+    if (Stub.SoName)
+      DynTab.Content.addValue(DT_SONAME,
+                              StrTab.Content.getOffset(Stub.SoName.getValue()));
+    DynTab.Size = DynTab.Content.getSize();
     // Calculate sections' addrs and offsets.
     const OutputSection<ELFT> *Prev = nullptr;
     uint64_t StartOffset = sizeof(Elf_Ehdr);
     for (auto Sec : Sections) {
       uint64_t Align = Sec->Align ? Sec->Align : 1;
       if (Sec->NoBits)
         Align = 1;
       if (Prev == nullptr) {
         Sec->Offset = alignTo(StartOffset, Align);
       } else if (Prev->NoBits)
         Sec->Offset = alignTo(Prev->Offset, Align);
       else
         Sec->Offset = alignTo(Prev->Offset + Prev->Size, Align);
       if (Prev == nullptr)
         Sec->Addr = alignTo(StartOffset, Align);
       else
         Sec->Addr = alignTo(Prev->Addr + Prev->Size, Align);
       Prev = Sec;
     }
+    // Fill Addr back to dynamic table.
+    DynTab.Content.modifyAddr(DynSymIndex, DT_SYMTAB, DynSym.Addr);
+    DynTab.Content.modifyAddr(DynStrIndex, DT_STRTAB, StrTab.Addr);
     // Write Shdr of String tables
     fillStrTabShdr(StrTab, SHF_ALLOC);
     fillStrTabShdr(ShStrTab);
+    fillSymTabShdr(DynSym, SHT_DYNSYM);
+    fillDynTabShdr(DynTab);
     // Initilize ELFheader
     initELFHeader<ELFT>(ElfHeader, Stub.Arch);
     ElfHeader.e_shstrndx = ShStrTab.Index;
     ElfHeader.e_shnum = LastSection->Index + 1;
     ElfHeader.e_phnum = 0;
     ElfHeader.e_phoff = 0;
     if (LastSection->NoBits)
       ElfHeader.e_shoff = alignTo(LastSection->Offset, sizeof(Elf_Addr));
     else
       ElfHeader.e_shoff =
           alignTo(LastSection->Offset + LastSection->Size, sizeof(Elf_Addr));
   }
   size_t getSize() const {
     return ElfHeader.e_shoff + ElfHeader.e_shnum * sizeof(Elf_Shdr);
   }
   void write(uint8_t *Data) const {
     write(Data, ElfHeader);
-    ShStrTab.Content.write(Data + ShStrTab.Shdr.sh_offset);
+    DynSym.Content.write(Data + DynSym.Shdr.sh_offset);
     StrTab.Content.write(Data + StrTab.Shdr.sh_offset);
-    writeShdr(Data, ShStrTab);
+    DynTab.Content.write(Data + DynTab.Shdr.sh_offset);
+    ShStrTab.Content.write(Data + ShStrTab.Shdr.sh_offset);
+    writeShdr(Data, DynSym);
     writeShdr(Data, StrTab);
+    writeShdr(Data, DynTab);
+    writeShdr(Data, ShStrTab);
   }
 };
 /// This function behaves similarly to StringRef::substr(), but attempts to
 /// terminate the returned StringRef at the first null terminator. If no null
 /// terminator is found, an error is returned.
 ///
 /// @param Str Source string to create a substring from.
 /// @param Offset The start index of the desired substring.

llvm/test/tools/llvm-elfabi/binary-write-sheaders.test

 # RUN: llvm-elfabi %s --output-target=elf64-little %t
 # RUN: llvm-readobj -h %t | FileCheck %s --check-prefix=ELFHEADER
 # RUN: llvm-readobj -S %t | FileCheck %s --check-prefix=SECTIONS
 # RUN: llvm-readobj --string-dump .shstrtab %t | FileCheck %s --check-prefix=SHSTRTAB
 # RUN: llvm-readobj --string-dump .dynstr %t | FileCheck %s --check-prefix=DYNSTR
-
+# RUN: llvm-readobj --dyn-symbols %t | FileCheck %s --check-prefix=DYNSYM
+# RUN: llvm-readobj --dynamic-table %t | FileCheck %s --check-prefix=DYNAMIC
 
 --- !tapi-tbe
 TbeVersion: 1.0
 Arch: x86_64
+NeededLibs:
+  - libc.so.6
 Symbols:
   bar: { Type: Object, Size: 42 }
   baz: { Type: TLS, Size: 3 }
+  plus: { Type: Func }
 ...
 
-# ELFHEADER: SectionHeaderCount: 3
-# ELFHEADER: StringTableSectionIndex: 1
+# ELFHEADER: SectionHeaderCount: 5
+# ELFHEADER: StringTableSectionIndex: 4
 
 # SECTIONS:      Section {
 # SECTIONS-NEXT:   Index: 0
 # SECTIONS-NEXT:   Name:  (0)
 # SECTIONS-NEXT:   Type: SHT_NULL
 # SECTIONS-NEXT:   Flags [
 # SECTIONS-NEXT:   ]
 # SECTIONS-NEXT:   Address: 0x0
 # SECTIONS-NEXT:   Offset: 0x0
 # SECTIONS-NEXT:   Size: 0
 # SECTIONS-NEXT:   Link: 0
 # SECTIONS-NEXT:   Info: 0
 # SECTIONS-NEXT:   AddressAlignment: 0
 # SECTIONS-NEXT:   EntrySize: 0
 # SECTIONS-NEXT: }
-# SECTIONS-NEXT: Section {
-# SECTIONS-NEXT:   Index: 1
-# SECTIONS-NEXT:   Name: .shstrtab
+# SECTIONS-NEXT:  Section {
+# SECTIONS-NEXT:    Index: 1
+# SECTIONS-NEXT:    Name: .dynsym
+# SECTIONS-NEXT:    Type: SHT_DYNSYM
+# SECTIONS-NEXT:    Flags [
+# SECTIONS-NEXT:      SHF_ALLOC
+# SECTIONS-NEXT:    ]
+# SECTIONS-NEXT:    Address:
+# SECTIONS-NEXT:    Offset:
+# SECTIONS-NEXT:    Size:
+# SECTIONS-NEXT:    Link: 2
+# SECTIONS-NEXT:    Info: 1
+# SECTIONS-NEXT:    AddressAlignment: 8
+# SECTIONS-NEXT:    EntrySize: 24
+# SECTIONS-NEXT:  }
+# SECTIONS-NEXT: Section {
+# SECTIONS-NEXT:   Index: 2
+# SECTIONS-NEXT:   Name: .dynstr
 # SECTIONS-NEXT:   Type: SHT_STRTAB
 # SECTIONS-NEXT:   Flags [
+# SECTIONS-NEXT:     SHF_ALLOC
 # SECTIONS-NEXT:   ]
 # SECTIONS-NEXT:   Address:
 # SECTIONS-NEXT:   Offset:
 # SECTIONS-NEXT:   Size:
 # SECTIONS-NEXT:   Link: 0
 # SECTIONS-NEXT:   Info: 0
 # SECTIONS-NEXT:   AddressAlignment: 0
 # SECTIONS-NEXT:   EntrySize: 0
 # SECTIONS-NEXT: }
-# SECTIONS-NEXT: Section {
-# SECTIONS-NEXT:   Index: 2
-# SECTIONS-NEXT:   Name: .dynstr
-# SECTIONS-NEXT:   Type: SHT_STRTAB
-# SECTIONS-NEXT:   Flags [
-# SECTIONS-NEXT:     SHF_ALLOC
-# SECTIONS-NEXT:   ]
-# SECTIONS-NEXT:   Address:
-# SECTIONS-NEXT:   Offset:
-# SECTIONS-NEXT:   Size:
+# SECTIONS-NEXT:  Section {
+# SECTIONS-NEXT:    Index: 3
+# SECTIONS-NEXT:    Name: .dynamic
+# SECTIONS-NEXT:    Type: SHT_DYNAMIC
+# SECTIONS-NEXT:    Flags [
+# SECTIONS-NEXT:      SHF_ALLOC
+# SECTIONS-NEXT:    ]
+# SECTIONS-NEXT:    Address:
+# SECTIONS-NEXT:    Offset:
+# SECTIONS-NEXT:    Size:
+# SECTIONS-NEXT:    Link: 2
+# SECTIONS-NEXT:    Info: 0
+# SECTIONS-NEXT:    AddressAlignment: 8
+# SECTIONS-NEXT:    EntrySize: 16
+# SECTIONS-NEXT:  }
+# SECTIONS-NEXT: Section {
+# SECTIONS-NEXT:   Index: 4
+# SECTIONS-NEXT:   Name: .shstrtab
+# SECTIONS-NEXT:   Type: SHT_STRTAB
+# SECTIONS-NEXT:   Flags [
+# SECTIONS-NEXT:   ]
+# SECTIONS-NEXT:   Address:
+# SECTIONS-NEXT:   Offset:
+# SECTIONS-NEXT:   Size:
 # SECTIONS-NEXT:   Link: 0
 # SECTIONS-NEXT:   Info: 0
 # SECTIONS-NEXT:   AddressAlignment: 0
 # SECTIONS-NEXT:   EntrySize: 0
 # SECTIONS-NEXT: }
 
 # SHSTRTAB:      String dump of section '.shstrtab':
 # SHSTRTAB-NEXT: [     1] .dynstr
-# SHSTRTAB-NEXT: [     9] .shstrtab
+# SHSTRTAB-NEXT: [     9] .dynsym
+# SHSTRTAB-NEXT: [    11] .dynamic
+# SHSTRTAB-NEXT: [    1a] .shstrtab
 
 # DYNSTR:      String dump of section '.dynstr':
 # DYNSTR-NEXT: [     1] baz
-# DYNSTR-NEXT: [     5] bar
+# DYNSTR-NEXT: [     5] plus
+# DYNSTR-NEXT: [     a] bar
+# DYNSTR-NEXT: [     e] libc.so.6
+
+# DYNSYM:        Symbol {
+# DYNSYM-NEXT:     Name:
+# DYNSYM-NEXT:     Value:
+# DYNSYM-NEXT:     Size:
+# DYNSYM-NEXT:     Binding: Local
+# DYNSYM-NEXT:     Type: None
+# DYNSYM-NEXT:     Other: 0
+# DYNSYM-NEXT:     Section: Undefined
+# DYNSYM-NEXT:   }
+# DYNSYM-NEXT:   Symbol {
+# DYNSYM-NEXT:     Name: bar
+# DYNSYM-NEXT:     Value:
+# DYNSYM-NEXT:     Size: 42
+# DYNSYM-NEXT:     Binding: Global
+# DYNSYM-NEXT:     Type: Object
+# DYNSYM-NEXT:     Other: 0
+# DYNSYM-NEXT:     Section:
+# DYNSYM-NEXT:   }
+# DYNSYM-NEXT:   Symbol {
+# DYNSYM-NEXT:     Name: baz
+# DYNSYM-NEXT:     Value:
+# DYNSYM-NEXT:     Size: 3
+# DYNSYM-NEXT:     Binding: Global
+# DYNSYM-NEXT:     Type: TLS
+# DYNSYM-NEXT:     Other: 0
+# DYNSYM-NEXT:     Section:
+# DYNSYM-NEXT:   }
+# DYNSYM-NEXT:   Symbol {
+# DYNSYM-NEXT:     Name: plus
+# DYNSYM-NEXT:     Value:
+# DYNSYM-NEXT:     Size:
+# DYNSYM-NEXT:     Binding: Global
+# DYNSYM-NEXT:     Type: Function
+# DYNSYM-NEXT:     Other: 0
+# DYNSYM-NEXT:     Section:
+# DYNSYM-NEXT: }
+
+# DYNAMIC:      DynamicSection [
+# DYNAMIC-NEXT:   Tag                Type   Name/Value
+# DYNAMIC-NEXT:   0x0000000000000006 SYMTAB
+# DYNAMIC-NEXT:   0x0000000000000005 STRTAB
+# DYNAMIC-NEXT:   0x0000000000000001 NEEDED Shared library: [libc.so.6]
+# DYNAMIC-NEXT:   0x0000000000000000 NULL
+# DYNAMIC-NEXT: ]