[ObjectYAML] Let dynamic entries use section names as values

[amontanez]

Summary

This change adds functionality to yaml2obj that allows dynamic entries to have string values via the String field. In this change, using a section name in the String field tells yaml2obj to use that section's address (pulled from the section header).

This is the first patch seeking to implement the associated RFC here: http://lists.llvm.org/pipermail/llvm-dev/2019-January/129231.html

Added:

• String values treated as section names that are converted to addresses.

[amontanez]

Rebase, reduced patch contents to only include one feature addition. Rather than using a unified Value field, there's now Value and String fields. This was done because a unified Value field that could accept strings and numbers made it somewhat difficult for obj2yaml to output an appropriately formatted value. This is up for discussion, though, as I'm not sure what I've done is the best solution.

[jhenderson]

In D57975#1400108, @amontanez wrote:

Rebase, reduced patch contents to only include one feature addition. Rather than using a unified Value field, there's now Value and String fields. This was done because a unified Value field that could accept strings and numbers made it somewhat difficult for obj2yaml to output an appropriately formatted value. This is up for discussion, though, as I'm not sure what I've done is the best solution.

Honestly, I feel that a unified field would be better (note, I haven't thought much about how that would affect the implementation). I think that matches what we already do with other fields like Section's Info etc. It is also more intuitive, and you don't have to handle the case of both being specified. I also don't think it matters if yaml2obj -> obj2yaml produces the output identical to the input, as long as it is still valid. In this case, it could (should?) use the actual address of the referenced section, rather than trying to figure out the section name.

llvm/lib/ObjectYAML/ELFYAML.cpp

663–664

Why has this assert disappeared? It seems unrelated to the change?

llvm/test/tools/yaml2obj/dynamic-entries.yaml

3

Nit: Avoid mixing single and double dash long args in the same test. I prefer double-dash to avoid ambiguity with option grouping, but it's not a big deal.

llvm/test/tools/yaml2obj/dynamic-entry-invalid-val.yaml

20

I'd specify the name of the section being searched for in this error message (i.e. "xxyyzz").

llvm/tools/yaml2obj/yaml2elf.cpp

394

Why can't this be done now by calling getDotDynStrSecNo?

423

Assuming you stick with different fields for string and value, I think this and the other comments and error messages in this area might need a bit of tweaking.

776

This is a personal thing, so feel free to ignore, but I find it easier to read if this explicitly compares against null.

llvm/include/llvm/ObjectYAML/ELFYAML.h

 // reading/generating binary object files.
 // The naming of these types is intended to be ELF_PREFIX, where PREFIX is
 // the common prefix of the respective constants. E.g. ELF_EM corresponds
 // to the `e_machine` constants, like `EM_X86_64`.
 // In the future, these would probably be better suited by C++11 enum
 // class's with appropriate fixed underlying type.
 LLVM_YAML_STRONG_TYPEDEF(uint16_t, ELF_ET)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, ELF_PT)
+LLVM_YAML_STRONG_TYPEDEF(int64_t, ELF_DT)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, ELF_EM)
 LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_ELFCLASS)
 LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_ELFDATA)
 LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_ELFOSABI)
 // Just use 64, since it can hold 32-bit values too.
 LLVM_YAML_STRONG_TYPEDEF(uint64_t, ELF_EF)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, ELF_PF)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, ELF_SHT)
struct ProgramHeader {
   ELF_PT Type;
   ELF_PF Flags;
   llvm::yaml::Hex64 VAddr;
   llvm::yaml::Hex64 PAddr;
   Optional<llvm::yaml::Hex64> Align;
   std::vector<SectionName> Sections;
 };
 
+struct DynamicEntry {
+  ELF_DT Tag;
+  StringRef Val;
+};
+
 struct Symbol {
   StringRef Name;
   ELF_STT Type;
   StringRef Section;
   Optional<ELF_SHN> Index;
   llvm::yaml::Hex64 Value;
   llvm::yaml::Hex64 Size;
   uint8_t Other;
struct SectionOrType {
   StringRef sectionNameOrType;
 };
 
 struct Section {
   enum class SectionKind {
     Group,
     RawContent,
     Relocation,
+    Dynamic,
     NoBits,
     MipsABIFlags
   };
   SectionKind Kind;
   StringRef Name;
   ELF_SHT Type;
   ELF_SHF Flags;
   llvm::yaml::Hex64 Address;
   StringRef Link;
   StringRef Info;
   llvm::yaml::Hex64 AddressAlign;
   Optional<llvm::yaml::Hex64> EntSize;
 
   Section(SectionKind Kind) : Kind(Kind) {}
   virtual ~Section();
 };
+
 struct RawContentSection : Section {
   yaml::BinaryRef Content;
   llvm::yaml::Hex64 Size;
 
   RawContentSection() : Section(SectionKind::RawContent) {}
 
   static bool classof(const Section *S) {
-    return S->Kind == SectionKind::RawContent;
+    return S->Kind == SectionKind::RawContent ||
+           S->Kind == SectionKind::Dynamic;
+  }
+
+protected:
+  RawContentSection(SectionKind Kind) : Section(Kind) {}
+};
+
+struct DynamicSection : RawContentSection {
+  std::vector<DynamicEntry> DynamicEntries;
+
+  DynamicSection() : RawContentSection(SectionKind::Dynamic) {}
+
+  static bool classof(const Section *S) {
+    return S->Kind == SectionKind::Dynamic;
   }
 };
 
 struct NoBitsSection : Section {
   llvm::yaml::Hex64 Size;
 
   NoBitsSection() : Section(SectionKind::NoBits) {}
 
struct Object {
   LocalGlobalWeakSymbols Symbols;
   LocalGlobalWeakSymbols DynamicSymbols;
 };
 
 } // end namespace ELFYAML
 } // end namespace llvm
 
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::ProgramHeader)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::DynamicEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<llvm::ELFYAML::Section>)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Symbol)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Relocation)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionOrType)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionName)
 
 namespace llvm {
 namespace yaml {
 
 template <>
 struct ScalarEnumerationTraits<ELFYAML::ELF_ET> {
   static void enumeration(IO &IO, ELFYAML::ELF_ET &Value);
 };
 
 template <> struct ScalarEnumerationTraits<ELFYAML::ELF_PT> {
   static void enumeration(IO &IO, ELFYAML::ELF_PT &Value);
 };
 
 template <>
+struct ScalarEnumerationTraits<ELFYAML::ELF_DT> {
+  static void enumeration(IO &IO, ELFYAML::ELF_DT &Value);
+};
+
+template <>
 struct ScalarEnumerationTraits<ELFYAML::ELF_EM> {
   static void enumeration(IO &IO, ELFYAML::ELF_EM &Value);
 };
 
 template <>
 struct ScalarEnumerationTraits<ELFYAML::ELF_ELFCLASS> {
   static void enumeration(IO &IO, ELFYAML::ELF_ELFCLASS &Value);
 };
struct MappingTraits<ELFYAML::FileHeader> {
   static void mapping(IO &IO, ELFYAML::FileHeader &FileHdr);
 };
 
 template <> struct MappingTraits<ELFYAML::ProgramHeader> {
   static void mapping(IO &IO, ELFYAML::ProgramHeader &FileHdr);
 };
 
 template <>
+struct MappingTraits<ELFYAML::DynamicEntry> {
+  static void mapping(IO &IO, ELFYAML::DynamicEntry &Entry);
+};
+
+template <>
 struct MappingTraits<ELFYAML::Symbol> {
   static void mapping(IO &IO, ELFYAML::Symbol &Symbol);
   static StringRef validate(IO &IO, ELFYAML::Symbol &Symbol);
 };
 
 template <>
 struct MappingTraits<ELFYAML::LocalGlobalWeakSymbols> {
   static void mapping(IO &IO, ELFYAML::LocalGlobalWeakSymbols &Symbols);

llvm/lib/ObjectYAML/ELFYAML.cpp

#define ECase(X) IO.enumCase(Value, #X, ELF::X)
   ECase(PT_SHLIB);
   ECase(PT_PHDR);
   ECase(PT_TLS);
   ECase(PT_GNU_EH_FRAME);
 #undef ECase
   IO.enumFallback<Hex32>(Value);
 }
 
+void ScalarEnumerationTraits<ELFYAML::ELF_DT>::enumeration(
+    IO &IO, ELFYAML::ELF_DT &Value) {
+#define DYNAMIC_TAG(Name, Value) ECase(DT_##Name)
+#define HEXAGON_DYNAMIC_TAG(Name, Value) ECase(DT_##Name)
+#define MIPS_DYNAMIC_TAG(Name, Value) ECase(DT_##Name)
+#define PPC64_DYNAMIC_TAG(Name, Value) ECase(DT_##Name)
+// Ignore marker tags.
+#define DT_TAG_MARKER(Name, Value)
+
+// Add tags.
+#define ECase(X) IO.enumCase(Value, #X, ELF::X);
+#include "llvm/BinaryFormat/DynamicTags.def"
+
+#undef ECase
+#undef DT_TAG_MARKER
+#undef PPC64_DYNAMIC_TAG
+#undef MIPS_DYNAMIC_TAG
+#undef HEXAGON_DYNAMIC_TAG
+#undef DYNAMIC_TAG
+}
+
 void ScalarEnumerationTraits<ELFYAML::ELF_EM>::enumeration(
     IO &IO, ELFYAML::ELF_EM &Value) {
 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
   ECase(EM_NONE);
   ECase(EM_M32);
   ECase(EM_SPARC);
   ECase(EM_386);
   ECase(EM_68K);

 #include "llvm/BinaryFormat/ELFRelocs/BPF.def"
     break;
   default:
     llvm_unreachable("Unsupported architecture");
   }
 #undef ELF_RELOC
   IO.enumFallback<Hex32>(Value);
 }
 
 void ScalarEnumerationTraits<ELFYAML::MIPS_AFL_REG>::enumeration(
     IO &IO, ELFYAML::MIPS_AFL_REG &Value) {
 #define ECase(X) IO.enumCase(Value, #X, Mips::AFL_##X)
   ECase(REG_NONE);
   ECase(REG_32);
   ECase(REG_64);
   ECase(REG_128);
 #undef ECase
 }
void MappingTraits<ELFYAML::ProgramHeader>::mapping(
   IO.mapRequired("Type", Phdr.Type);
   IO.mapOptional("Flags", Phdr.Flags, ELFYAML::ELF_PF(0));
   IO.mapOptional("Sections", Phdr.Sections);
   IO.mapOptional("VAddr", Phdr.VAddr, Hex64(0));
   IO.mapOptional("PAddr", Phdr.PAddr, Hex64(0));
   IO.mapOptional("Align", Phdr.Align);
 }
 
+void MappingTraits<ELFYAML::DynamicEntry>::mapping(
+    IO &IO, ELFYAML::DynamicEntry &Entry) {
+  IO.mapRequired("Tag", Entry.Tag);
+  IO.mapRequired("Value", Entry.Val);
+}
+
 namespace {
 
 struct NormalizedOther {
   NormalizedOther(IO &)
       : Visibility(ELFYAML::ELF_STV(0)), Other(ELFYAML::ELF_STO(0)) {}
   NormalizedOther(IO &, uint8_t Original)
       : Visibility(Original & 0x3), Other(Original & ~0x3) {}
 

 }
 
 static void sectionMapping(IO &IO, ELFYAML::RawContentSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Content", Section.Content);
   IO.mapOptional("Size", Section.Size, Hex64(Section.Content.binary_size()));
 }
 
+static void sectionMapping(IO &IO, ELFYAML::DynamicSection &Section) {
+  // commonSectionMapping() is implicitly called in RawContentSection's
+  // sectionMapping().
+  sectionMapping(IO, (ELFYAML::RawContentSection &)Section);
+  IO.mapOptional("Entries", Section.DynamicEntries);
+}
+
 static void sectionMapping(IO &IO, ELFYAML::NoBitsSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Size", Section.Size, Hex64(0));
 }
 
 static void sectionMapping(IO &IO, ELFYAML::RelocationSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Relocations", Section.Relocations);
void MappingTraits<std::unique_ptr<ELFYAML::Section>>::mapping(
 
   switch (sectionType) {
   case ELF::SHT_REL:
   case ELF::SHT_RELA:
     if (!IO.outputting())
       Section.reset(new ELFYAML::RelocationSection());
     sectionMapping(IO, *cast<ELFYAML::RelocationSection>(Section.get()));
     break;
+  case ELF::SHT_DYNAMIC:
+    if (!IO.outputting())
+      Section.reset(new ELFYAML::DynamicSection());
+    sectionMapping(IO, *cast<ELFYAML::DynamicSection>(Section.get()));
+    break;
   case ELF::SHT_GROUP:
     if (!IO.outputting())
       Section.reset(new ELFYAML::Group());
     groupSectionMapping(IO, *cast<ELFYAML::Group>(Section.get()));
     break;
   case ELF::SHT_NOBITS:
     if (!IO.outputting())
       Section.reset(new ELFYAML::NoBitsSection());
     sectionMapping(IO, *cast<ELFYAML::NoBitsSection>(Section.get()));
     break;
   case ELF::SHT_MIPS_ABIFLAGS:
     if (!IO.outputting())
       Section.reset(new ELFYAML::MipsABIFlags());
     sectionMapping(IO, *cast<ELFYAML::MipsABIFlags>(Section.get()));
     break;
   default:
     if (!IO.outputting())
       Section.reset(new ELFYAML::RawContentSection());
     sectionMapping(IO, *cast<ELFYAML::RawContentSection>(Section.get()));
   }
 }
 
 StringRef MappingTraits<std::unique_ptr<ELFYAML::Section>>::validate(
     IO &io, std::unique_ptr<ELFYAML::Section> &Section) {
-  const auto *RawSection = dyn_cast<ELFYAML::RawContentSection>(Section.get());
-  if (!RawSection || RawSection->Size >= RawSection->Content.binary_size())
-    return StringRef();
+  if (const auto *Dyn = dyn_cast<ELFYAML::DynamicSection>(Section.get())) {
+    if (Dyn->DynamicEntries.size() > 0 && Dyn->Content.binary_size() > 0)
+      return "Dynamic section can't have Entries and Content simultaneously";
+  }
+  if (const auto *RawSection =
+                 dyn_cast<ELFYAML::RawContentSection>(Section.get())) {
+    if ((uint64_t)RawSection->Size <
+        (uint64_t)RawSection->Content.binary_size())
       return "Section size must be greater or equal to the content size";
   }
+  return StringRef();
+}
 
 namespace {
 
 struct NormalizedMips64RelType {
   NormalizedMips64RelType(IO &)
       : Type(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),
         Type2(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),
         Type3(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),

llvm/test/tools/yaml2obj/dynamic-entries-and-content.yaml

+# RUN: not yaml2obj %s -o %t 2>&1 | FileCheck %s
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_DYN
+  Machine:         EM_X86_64
+Sections:
+  - Name: .somestrings
+    Type: SHT_STRTAB
+    Flags: [ SHF_ALLOC, SHF_WRITE ]
+    #        "\0libsomething.so\0"
+    Content: "006c6962736f6d657468696e672e736f00"
+    Address: 0x1000
+  - Name: .dynamic
+    Type: SHT_DYNAMIC
+    Flags: [ SHF_ALLOC, SHF_WRITE ]
+    Link: .somestrings
+    Content: "0a00000000000000110000000000000005000000000000000010000000000000"
+    Entries:
+      - Tag: DT_STRSZ
+        Value: 17
+      - Tag: DT_STRTAB
+        Value: .somestrings
+
+# CHECK: error: Dynamic section can't have Entries and Content simultaneously

llvm/test/tools/yaml2obj/dynamic-entries-invalid-name.yaml

+# RUN: not yaml2obj %s -o %t 2>&1 | FileCheck %s
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_DYN
+  Machine:         EM_X86_64
+Sections:
+  - Name: .somestrings
+    Type: SHT_STRTAB
+    Flags: [ SHF_ALLOC, SHF_WRITE ]
+    #        "\0libsomething.so\0"
+    Content: "006c6962736f6d657468696e672e736f00"
+    Address: 0x1000
+  - Name: .mydynamic
+    Type: SHT_DYNAMIC
+    Flags: [ SHF_ALLOC, SHF_WRITE ]
+    Link: .somestrings
+    Entries:
+      - Tag: DT_STRSZ
+        Value: 17
+      - Tag: DT_STRTAB
+        Value: .somestrings
+
+# CHECK: error: Dynamic section must be named `.dynamic` when using Entries to populate the section

llvm/test/tools/yaml2obj/dynamic-entries.yaml

+# RUN: yaml2obj %s -o %t
+# RUN: llvm-readobj -dynamic %t | FileCheck %s --check-prefix=DYNAMIC
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_DYN
+  Machine:         EM_X86_64
+Sections:
+  - Name: .somestrings
+    Type: SHT_STRTAB
+    Flags: [ SHF_ALLOC, SHF_WRITE ]
+    #        "\0libsomething.so\0"
+    Content: "006c6962736f6d657468696e672e736f00"
+    Address: 0x1000
+  - Name: .dynamic
+    Type: SHT_DYNAMIC
+    Flags: [ SHF_ALLOC, SHF_WRITE ]
+    Link: .somestrings
+    Entries:
+      - Tag: DT_STRSZ
+        Value: 17
+      - Tag: DT_STRTAB
+        Value: .somestrings
+# llvm-readobj requires some program headers to read .dynamic entries.
+ProgramHeaders:
+  - Type: PT_LOAD
+    Flags: [ PF_R ]
+    VAddr: 0x0000
+    PAddr: 0x0000
+    Align: 8
+    Sections:
+      - Section: .dynamic
+      - Section: .dynstr
+  - Type: PT_DYNAMIC
+    Flags: [ PF_X, PF_R ]
+    VAddr: 0x0000
+    PAddr: 0x0000
+    Sections:
+      - Section: .dynamic
+  - Type: PT_LOAD
+    Flags: [ PF_R ]
+    VAddr: 0x1000
+    PAddr: 0x1000
+    Align: 8
+    Sections:
+      - Section: .somestrings
+
+# DYNAMIC: STRSZ 17 (bytes)
+# DYNAMIC: STRTAB 0x1000{{$}}
+# DYNAMIC: NULL 0x0{{$}}

llvm/test/tools/yaml2obj/dynamic-entry-invalid-val.yaml

+# RUN: not yaml2obj %s -o %t 2>&1 | FileCheck %s
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_DYN
+  Machine:         EM_X86_64
+Sections:
+  - Name: .somestrings
+    Type: SHT_STRTAB
+    Flags: [ SHF_ALLOC, SHF_WRITE ]
+    #        "\0libsomething.so\0"
+    Content: "006c6962736f6d657468696e672e736f00"
+    Address: 0x1000
+  - Name: .dynamic
+    Type: SHT_DYNAMIC
+    Flags: [ SHF_ALLOC, SHF_WRITE ]
+    Link: .somestrings
+    Entries:
+      - Tag: DT_STRSZ
+        Value: 17
+      - Tag: DT_STRTAB
+        Value: xxyyzz
+
+# CHECK: error: Value is not a number or valid section name

llvm/test/tools/yaml2obj/dynamic-raw-invalid-size.yaml

+# RUN: not yaml2obj %s -o %t 2>&1 | FileCheck %s
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_DYN
+  Machine:         EM_X86_64
+Sections:
+  - Name: .dynamic
+    Type: SHT_DYNAMIC
+    Flags: [ SHF_ALLOC, SHF_WRITE ]
+    Content: "0000000000000000000000000000000000000000000000000000000000000000"
+    Size: 16
+
+# CHECK: error: Section size must be greater or equal to the content size

llvm/tools/yaml2obj/yaml2elf.cpp

class ELFState {
   StringTableBuilder DotStrtab{StringTableBuilder::ELF};
 
   /// The future ".shstrtab" section.
   StringTableBuilder DotShStrtab{StringTableBuilder::ELF};
 
   /// The future ".dynstr" section.
   StringTableBuilder DotDynstr{StringTableBuilder::ELF};
 
+  /// Retain a pointer to the ELFYAML::DynamicSection as state.
+  /// This is required as the .dynamic section isn't written until after the
+  /// .dynstr section.
+  ELFYAML::DynamicSection *YamlDynamicSection = nullptr;
+
   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, SymtabType STType,
                                ContiguousBlobAccumulator &CBA);
   void initStrtabSectionHeader(Elf_Shdr &SHeader, StringRef Name,
                                StringTableBuilder &STB,
                                ContiguousBlobAccumulator &CBA);
+  void initDynamicSectionHeader(Elf_Shdr &SHeader);
+  bool finalizeDynamicSection(Elf_Shdr &DynamicHdr,
+                              std::vector<Elf_Shdr> &AllShdrs,
+                              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,
                   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;
+  bool hasDynamicEntries() const;
   SmallVector<const char *, 5> implicitSectionNames() const;
 
   // - SHT_NULL entry (placed first, i.e. 0'th entry)
   // - symbol table (.symtab) (defaults to after last yaml section)
   // - string table (.strtab) (defaults to after .symtab)
   // - section header string table (.shstrtab) (defaults to after .strtab)
   // - dynamic symbol table (.dynsym) (defaults to after .shstrtab)
   // - dynamic string table (.dynstr) (defaults to after .dynsym)
+  // - dynamic section (.dynamic) (defaults to after .dynstr)
   unsigned getDotSymTabSecNo() const { return SN2I.get(".symtab"); }
   unsigned getDotStrTabSecNo() const { return SN2I.get(".strtab"); }
   unsigned getDotShStrTabSecNo() const { return SN2I.get(".shstrtab"); }
   unsigned getDotDynSymSecNo() const { return SN2I.get(".dynsym"); }
   unsigned getDotDynStrSecNo() const { return SN2I.get(".dynstr"); }
   unsigned getSectionCount() const { return SN2I.size() + 1; }
 
   ELFState(const ELFYAML::Object &D) : Doc(D) {}
for (const auto &Sec : Doc.Sections) {
 
     if (!Sec->Link.empty()) {
       unsigned Index;
       if (!convertSectionIndex(SN2I, Sec->Name, Sec->Link, Index))
         return false;
       SHeader.sh_link = Index;
     }
 
-    if (auto S = dyn_cast<ELFYAML::RawContentSection>(Sec.get()))
+    if (auto S = dyn_cast<ELFYAML::DynamicSection>(Sec.get())) {
+      // Determine whether to use `Entries` or older raw `Contents`.
+      if (S->DynamicEntries.empty()) {
+        ELFYAML::RawContentSection *RawSec =
+            dyn_cast<ELFYAML::RawContentSection>(S);
+        writeSectionContent(SHeader, *RawSec, CBA);
+      } else {
+        // To use DynamicEntries, the section name must be `.dynamic`
+        if (S->Name != ".dynamic") {
+          WithColor::error() << "Dynamic section must be named `.dynamic` "
+                                "when using Entries to populate the section\n";
+          return false;
+        }
+        YamlDynamicSection = S;
+      }
+    } else if (auto S = dyn_cast<ELFYAML::RawContentSection>(Sec.get())) {
       writeSectionContent(SHeader, *S, CBA);
-    else if (auto S = dyn_cast<ELFYAML::RelocationSection>(Sec.get())) {
+    } else if (auto S = dyn_cast<ELFYAML::RelocationSection>(Sec.get())) {
       if (S->Link.empty())
         // For relocation section set link to .symtab by default.
         SHeader.sh_link = getDotSymTabSecNo();
 
       unsigned Index;
       if (!convertSectionIndex(SN2I, S->Name, S->Info, Index))
         return false;
       SHeader.sh_info = Index;
void ELFState<ELFT>::initStrtabSectionHeader(Elf_Shdr &SHeader, StringRef Name,
   SHeader.sh_name = DotShStrtab.getOffset(Name);
   SHeader.sh_type = ELF::SHT_STRTAB;
   STB.write(CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign));
   SHeader.sh_size = STB.getSize();
   SHeader.sh_addralign = 1;
 }
 
 template <class ELFT>
+void ELFState<ELFT>::initDynamicSectionHeader(Elf_Shdr &SHeader) {
+  SHeader.sh_name = DotShStrtab.getOffset(".dynamic");
+  SHeader.sh_type = ELF::SHT_DYNAMIC;
+  SHeader.sh_entsize = sizeof(Elf_Dyn);
+  SHeader.sh_addralign = sizeof(Elf_Dyn)/2;
+  // TODO: Link .dynamic to .dynstr by default.
+}
+
+template <class ELFT>
+bool ELFState<ELFT>::finalizeDynamicSection(Elf_Shdr &DynamicHdr,
+                                            std::vector<Elf_Shdr> &AllShdrs,
+                                            ContiguousBlobAccumulator &CBA) {
+  std::vector<Elf_Dyn> Dyn;
+  auto printYamlError = [](ELFYAML::DynamicEntry YamlObj, StringRef After) {
+    yaml::Output Yout(errs());
+    Yout << YamlObj;
+    WithColor::error() << After << "\n";
+  };
+
+  for (const auto &YamlEntry : YamlDynamicSection->DynamicEntries) {
+    Elf_Dyn Ent;
+    Ent.d_tag = YamlEntry.Tag;
+    uint64_t Value;
+    unsigned SectionIdx;
+
+    // If a section name, use that section's sh_addr.
+    if (!SN2I.lookup(YamlEntry.Val, SectionIdx)) {
+      Value = AllShdrs[SectionIdx].sh_addr;
+
+    // Otherwise, attempt to treat as a number.
+    } else if (!to_integer(YamlEntry.Val, Value)) {
+      printYamlError(YamlEntry,
+                     "Value is not a number or valid section name");
+      return false;
+    }
+    Ent.d_un.d_val = Value;
+    Dyn.push_back(Ent);
+  }
+
+  // Ensure DT_NULL is present.
+  // TODO: Check if DT_NULL already present instead of always adding.
+  Elf_Dyn NullEnt;
+  NullEnt.d_tag = ELF::DT_NULL;
+  NullEnt.d_un.d_val = 0;
+  Dyn.push_back(NullEnt);
+
+  writeArrayData(
+      CBA.getOSAndAlignedOffset(DynamicHdr.sh_offset, DynamicHdr.sh_addralign),
+      makeArrayRef(Dyn));
+  DynamicHdr.sh_size = arrayDataSize(makeArrayRef(Dyn));
+
+  return true;
+}
+
+template <class ELFT>
 void ELFState<ELFT>::setProgramHeaderLayout(std::vector<Elf_Phdr> &PHeaders,
                                             std::vector<Elf_Shdr> &SHeaders) {
   uint32_t PhdrIdx = 0;
   for (auto &YamlPhdr : Doc.ProgramHeaders) {
     auto &PHeader = PHeaders[PhdrIdx++];
 
     if (YamlPhdr.Sections.size())
       PHeader.p_offset = UINT32_MAX;
if (State.hasDynamicSymbols()) {
     Index = State.SN2I.get(".dynsym");
     State.initSymtabSectionHeader(SHeaders[Index], SymtabType::Dynamic, CBA);
     SHeaders[Index].sh_flags |= ELF::SHF_ALLOC;
     Index = State.SN2I.get(".dynstr");
     State.initStrtabSectionHeader(SHeaders[Index], ".dynstr", State.DotDynstr, CBA);
     SHeaders[Index].sh_flags |= ELF::SHF_ALLOC;
   }
 
+  // Write .dynamic section header and contents.
+  if (State.hasDynamicEntries()) {
+    Index = State.SN2I.get(".dynamic");
+    if (!State.finalizeDynamicSection(SHeaders[Index], SHeaders, CBA))
+      return 1;
+  }
+
   // 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;
 }
 
+template <class ELFT> bool ELFState<ELFT>::hasDynamicEntries() const {
+  return YamlDynamicSection;
+}
+
 template <class ELFT>
 SmallVector<const char *, 5> ELFState<ELFT>::implicitSectionNames() const {
   if (!hasDynamicSymbols())
     return {".symtab", ".strtab", ".shstrtab"};
   return {".symtab", ".strtab", ".shstrtab", ".dynsym", ".dynstr"};
 }
 
 static bool is64Bit(const ELFYAML::Object &Doc) {