[llvm-objcopy] Add support for .dynamic, .dynsym, and .dynstr

[jakehehrlich]

Summary

This change adds support for sections involved in dynamic loading such as SHT_DYNAMIC, SHT_DYNSYM, and allocated string tables.

The two added binaries used for tests can be downloaded here and here

[jhenderson]

I take it yaml2obj cannot create dynamic section/symbol table information? If it could, it would mean that no pre-built binaries would be needed for the tests.

A thought on the duplication of DynamicSymbolTableSection and DynamicSection: what would you think of having a shared class called something like "SectionWithStringTable", and then implementing these two section types as inheriting from that one. The only logic needed in DynamicSection/DynamicSymbolTableSection would then be the classof method.

test/tools/llvm-objcopy/dynsym.test

3

Please also check the section header data like in the other tests.

tools/llvm-objcopy/Object.cpp

347

Full stop.

356

Ditto. I'd also replace the last word "anyway" with "either".

364

DynamicSection not DynamicSymbolTableSection!

415

As with other cases, we need to check that the Link value is actually a valid section index, or we will get a crash. Since this is a recurring theme, perhaps Object should gain a getSection() method that does the error checking?

419

Ditto.

tools/llvm-objcopy/Object.h

180–183

As the DynamicSection class currently appears after this class, I think that either a) the comment should be moved to the second class to appear in order (i.e. DynamicSection), or b) the DynamicSection should be moved to before the DynamicSymbolTableSection. This means that the comment refers to something that a user reading top-down would have already read about.

[jakehehrlich]

In D36560#856314, @jhenderson wrote:

I take it yaml2obj cannot create dynamic section/symbol table information? If it could, it would mean that no pre-built binaries would be needed for the tests.

This is correct. It might not be so hard to add though. It supports just

A thought on the duplication of DynamicSymbolTableSection and DynamicSection: what would you think of having a shared class called something like "SectionWithStringTable", and then implementing these two section types as inheriting from that one. The only logic needed in DynamicSection/DynamicSymbolTableSection would then be the classof method.

I like that. I'll upload that in the next diff when I fix these other changes.

[jakehehrlich]

1. Added and used getSection methods to help with problem of constantly needed to access and error check sections
2. Used SectionWithStrTab change recomended
3. Fixed typos

[jhenderson]

tools/llvm-objcopy/Object.cpp

346

speical -> special

tools/llvm-objcopy/Object.h

193

Has this been clang-formatted? The line looks a bit long.

229

Not really important, but I'm not a massive fan of this name - maybe getSectionOfType?

[jakehehrlich]

1. Changed name of method to getSectionOfType
2. Fixed typos

[jhenderson]

LGTM with the suggested argument name changes.

tools/llvm-objcopy/Object.cpp

317

The last argument name now needs changing both here and in the header. It may be wise to change ErrMsg as well to clearly disambiguate the two. Suggestions: ErrMsg -> IndexErrMsg; CastErrMsg -> TypeErrMsg.

test/tools/llvm-objcopy/dynamic.test

+# RUN: llvm-objcopy %p/Inputs/dynamic.so %t
+# RUN: llvm-readobj -dynamic-table %t | FileCheck %s
+# RUN: llvm-readobj -sections %t | FileCheck -check-prefix=LINK %s
+
+#CHECK: DynamicSection [
+#CHECK-NEXT:  Tag                Type                 Name/Value
+#CHECK-NEXT:  0x0000000000000006 SYMTAB               0x1C8
+#CHECK-NEXT:  0x000000000000000B SYMENT               24
+#CHECK-NEXT:  0x0000000000000005 STRTAB               0x210
+#CHECK-NEXT:  0x000000000000000A STRSZ                5
+#CHECK-NEXT:  0x0000000000000004 HASH                 0x1F8
+#CHECK-NEXT:  0x0000000000000000 NULL                 0x0
+#CHECK-NEXT:]
+
+#LINK:         Index: 3
+#LINK-NEXT:    Name: .dynstr
+
+#LINK:         Name: .dynamic
+#LINK-NEXT:    Type: SHT_DYNAMIC
+#LINK-NEXT:    Flags [
+#LINK-NEXT:      SHF_ALLOC
+#LINK-NEXT:      SHF_WRITE
+#LINK-NEXT:    ]
+#LINK-NEXT:    Address:
+#LINK-NEXT:    Offset:
+#LINK-NEXT:    Size:
+#LINK-NEXT:    Link: 3

test/tools/llvm-objcopy/dynstr.test

+# RUN: yaml2obj %s > %t
+# RUN: llvm-objcopy %t %t2
+# RUN: llvm-readobj -sections -section-data %t2 | FileCheck %s
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_EXEC
+  Machine:         EM_X86_64
+Sections:
+  - Name:            .dynstr
+    Type:            SHT_STRTAB
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x1000
+    Content:         "002EDEADBEEF002EBAADF00D00"
+
+#CHECK:         Name: .dynstr
+#CHECK-NEXT:    Type: SHT_STRTAB
+#CHECK-NEXT:    Flags [
+#CHECK-NEXT:      SHF_ALLOC
+#CHECK-NEXT:    ]
+#CHECK-NEXT:    Address: 0x1000
+#CHECK-NEXT:    Offset:
+#CHECK-NEXT:    Size: 13
+#CHECK-NEXT:    Link:
+#CHECK-NEXT:    Info:
+#CHECK-NEXT:    AddressAlignment:
+#CHECK-NEXT:    EntrySize:
+#CHECK-NEXT:    SectionData (
+#CHECK-NEXT:      0000: 002EDEAD BEEF002E BAADF00D 00
+#CHECK-NEXT:    )

test/tools/llvm-objcopy/dynsym.test

+# RUN: llvm-objcopy %p/Inputs/dynsym.so %t
+# RUN: llvm-readobj -dyn-symbols %t | FileCheck %s
+
+#CHECK: DynamicSymbols [
+#CHECK-NEXT:  Symbol {
+#CHECK-NEXT:    Name: @ (0)
+#CHECK-NEXT:    Value: 0x0
+#CHECK-NEXT:    Size: 0
+#CHECK-NEXT:    Binding: Local
+#CHECK-NEXT:    Type: None (0x0)
+#CHECK-NEXT:    Other: 0
+#CHECK-NEXT:    Section: Undefined (0x0)
+#CHECK-NEXT:  }
+#CHECK-NEXT:  Symbol {
+#CHECK-NEXT:    Name: bang@ (1)
+#CHECK-NEXT:    Value: 0x4000
+#CHECK-NEXT:    Size: 8
+#CHECK-NEXT:    Binding: Global (0x1)
+#CHECK-NEXT:    Type: Object (0x1)
+#CHECK-NEXT:    Other: 0
+#CHECK-NEXT:    Section: .bss (0x7)
+#CHECK-NEXT:  }
+#CHECK-NEXT:  Symbol {
+#CHECK-NEXT:    Name: bar@ (6)
+#CHECK-NEXT:    Value: 0x1001
+#CHECK-NEXT:    Size: 0
+#CHECK-NEXT:    Binding: Global (0x1)
+#CHECK-NEXT:    Type: Function (0x2)
+#CHECK-NEXT:    Other: 0
+#CHECK-NEXT:    Section: .text (0x4)
+#CHECK-NEXT:  }
+#CHECK-NEXT:  Symbol {
+#CHECK-NEXT:    Name: baz@ (10)
+#CHECK-NEXT:    Value: 0x2000
+#CHECK-NEXT:    Size: 0
+#CHECK-NEXT:    Binding: Global (0x1)
+#CHECK-NEXT:    Type: Object (0x1)
+#CHECK-NEXT:    Other: 0
+#CHECK-NEXT:    Section: .data (0x5)
+#CHECK-NEXT:  }
+#CHECK-NEXT:  Symbol {
+#CHECK-NEXT:    Name: foo@ (14)
+#CHECK-NEXT:    Value: 0x1000
+#CHECK-NEXT:    Size: 0
+#CHECK-NEXT:    Binding: Global (0x1)
+#CHECK-NEXT:    Type: Function (0x2)
+#CHECK-NEXT:    Other: 0
+#CHECK-NEXT:    Section: .text (0x4)
+#CHECK-NEXT:  }
+#CHECK-NEXT:]

tools/llvm-objcopy/Object.h

public:
   void addRelocation(Relocation Rel) { Relocations.push_back(Rel); }
   void finalize() override;
   void writeSection(llvm::FileOutputBuffer &Out) const override;
   static bool classof(const SectionBase *S) {
     return S->Type == llvm::ELF::SHT_REL || S->Type == llvm::ELF::SHT_RELA;
   }
 };
 
+// Oddly this seems to be a complete duplication of DynamicSection because they
+// both need their sh_link to be changed if sections get moved around at all.
+// Still logically these are two different things so they have two different
+// classes.
+class DynamicSymbolTableSection : public Section {
+private:
+  StringTableSection *SymbolNames;
+
+public:
+  DynamicSymbolTableSection(llvm::ArrayRef<uint8_t> Data) : Section(Data) {}
+  void setStrTab(StringTableSection *StrTab) { SymbolNames = StrTab; }
+  void finalize() override;
+  static bool classof(const SectionBase *S) {
+    return S->Type == llvm::ELF::SHT_DYNSYM;
+  }
+};
+
+class DynamicSection : public Section {
+private:
+  StringTableSection *StrTab;
+
+public:
+  DynamicSection(llvm::ArrayRef<uint8_t> Data) : Section(Data) {}
+  void setStrTab(StringTableSection *StrTable) { this->StrTab = StrTable; }
+  void finalize() override;
+  static bool classof(const SectionBase *S) {
+    return S->Type == llvm::ELF::SHT_DYNAMIC;
+  }
+};
+
 template <class ELFT> class Object {
 private:
   typedef std::unique_ptr<SectionBase> SecPtr;
   typedef std::unique_ptr<Segment> SegPtr;
 
   typedef typename ELFT::Shdr Elf_Shdr;
   typedef typename ELFT::Ehdr Elf_Ehdr;
   typedef typename ELFT::Phdr Elf_Phdr;
 
   void initSymbolTable(const llvm::object::ELFFile<ELFT> &ElfFile,
                        SymbolTableSection<ELFT> *SymTab);
   SecPtr makeSection(const llvm::object::ELFFile<ELFT> &ElfFile,
                      const Elf_Shdr &Shdr);
   void readProgramHeaders(const llvm::object::ELFFile<ELFT> &ElfFile);
   void readSectionHeaders(const llvm::object::ELFFile<ELFT> &ElfFile);
 
 protected:
   StringTableSection *SectionNames;
   SymbolTableSection<ELFT> *SymbolTable;
   std::vector<SecPtr> Sections;
   std::vector<SegPtr> Segments;
 
   void writeHeader(llvm::FileOutputBuffer &Out) const;
   void writeProgramHeaders(llvm::FileOutputBuffer &Out) const;
   void writeSectionData(llvm::FileOutputBuffer &Out) const;
   void writeSectionHeaders(llvm::FileOutputBuffer &Out) const;
 
 public:

tools/llvm-objcopy/Object.cpp

 void RelocationSection<ELFT>::writeSection(llvm::FileOutputBuffer &Out) const {
   uint8_t *Buf = Out.getBufferStart() + Offset;
   if (Type == SHT_REL)
     writeRel(reinterpret_cast<Elf_Rel *>(Buf));
   else
     writeRela(reinterpret_cast<Elf_Rela *>(Buf));
 }
 
+void DynamicSymbolTableSection::finalize() { this->Link = SymbolNames->Index; }
+
+void DynamicSection::finalize() { this->Link = StrTab->Index; }
+
 // Returns true IFF a section is wholly inside the range of a segment
 static bool sectionWithinSegment(const SectionBase &Section,
                                  const Segment &Segment) {
   // If a section is empty it should be treated like it has a size of 1. This is
   // to clarify the case when an empty section lies on a boundary between two
   // segments and ensures that the section "belongs" to the second segment and
   // not the first.
   uint64_t SecSize = Section.Size ? Section.Size : 1;

 Object<ELFT>::makeSection(const llvm::object::ELFFile<ELFT> &ElfFile,
                           const Elf_Shdr &Shdr) {
   ArrayRef<uint8_t> Data;
   switch (Shdr.sh_type) {
   case SHT_RELA: {
     auto Sec = make_unique<RelocationSection<ELFT>>();
     auto SymTab = unwrapOrError(ElfFile.sections()).begin() + Shdr.sh_link;
     StringRef StrTabData =
         unwrapOrError(ElfFile.getStringTableForSymtab(*SymTab));
     for (const auto &Rel : unwrapOrError(ElfFile.relas(&Shdr))) {
       Relocation ToAdd;
       auto Sym = unwrapOrError(ElfFile.getSymbol(SymTab, Rel.getSymbol(false)));
       ToAdd.Offset = Rel.r_offset;
       ToAdd.Addend = Rel.r_addend;
       ToAdd.Type = Rel.getType(false);
       ToAdd.Symbol = unwrapOrError(Sym->getName(StrTabData));
       Sec->addRelocation(ToAdd);
for (const auto &Rel : unwrapOrError(ElfFile.rels(&Shdr))) {
       ToAdd.Offset = Rel.r_offset;
       ToAdd.Type = Rel.getType(false);
       ToAdd.Symbol = unwrapOrError(Sym->getName(StrTabData));
       Sec->addRelocation(ToAdd);
     }
     return Sec;
   }
   case SHT_STRTAB:
-    return llvm::make_unique<StringTableSection>();
+    // If a string table is allocated we don't want to mess with it. That would
+    // mean altering the memory image. There are no speical link types or
+    // anything so we can just use a Section
+    if (Shdr.sh_flags & SHF_ALLOC) {
+      Data = unwrapOrError(ElfFile.getSectionContents(&Shdr));
+      return make_unique<Section>(Data);
+    }
+    return make_unique<StringTableSection>();
+  case SHT_HASH:
+  case SHT_GNU_HASH:
+    // Hash tables should refer to SHT_DYNSYM which we're not going to change.
+    // Because of this we don't need to mess with the hash tables anyway
+    Data = unwrapOrError(ElfFile.getSectionContents(&Shdr));
+    return make_unique<Section>(Data);
+  case SHT_DYNSYM:
+    Data = unwrapOrError(ElfFile.getSectionContents(&Shdr));
+    return make_unique<DynamicSymbolTableSection>(Data);
+  case SHT_DYNAMIC:
+    Data = unwrapOrError(ElfFile.getSectionContents(&Shdr));
+    return make_unique<DynamicSymbolTableSection>(Data);
   case SHT_SYMTAB: {
     auto SymTab = make_unique<SymbolTableSection<ELFT>>();
     SymbolTable = SymTab.get();
     return SymTab;
   }
   case SHT_NOBITS:
     return llvm::make_unique<Section>(Data);
   default:
if (SymbolTable)
     initSymbolTable(ElfFile, SymbolTable);
 
   for (auto &Section : Sections) {
     if (auto RelSec = dyn_cast<RelocationSection<ELFT>>(Section.get())) {
       RelSec->setSymTab(
           dyn_cast<SymbolTableSection<ELFT>>(Sections[RelSec->Link - 1].get()));
       RelSec->setSection(Sections[RelSec->Info - 1].get());
     }
+    if (auto DynamicSec = dyn_cast<DynamicSection>(Section.get())) {
+      DynamicSec->setStrTab(
+          dyn_cast<StringTableSection>(Sections[DynamicSec->Link - 1].get()));
+    }
+    if (auto DynSymTab = dyn_cast<DynamicSymbolTableSection>(Section.get())) {
+      DynSymTab->setStrTab(
+          dyn_cast<StringTableSection>(Sections[DynSymTab->Link - 1].get()));
+    }
   }
 }
 
 template <class ELFT> Object<ELFT>::Object(const ELFObjectFile<ELFT> &Obj) {
   const auto &ElfFile = *Obj.getELFFile();
   const auto &Ehdr = *ElfFile.getHeader();
 
   std::copy(Ehdr.e_ident, Ehdr.e_ident + 16, Ident);