[ObjectYAML][yaml2obj][ELF] Add basic support for dynamic entries

[amontanez]

Summary

This change introduces basic support for adding .dynamic entries to an ELF binary produced with yaml2obj.
Added:

• YAML traits for .dynamic section contents.
• d_tag can be populated by using the names of the tags.
• yaml2obj writes .dynamic entries.
• Some dynamic entries are validated for correctness.
• Some dynamic entries can be automatically inferred.
• Values can be numbers, strings (for things like DT_SONAME and DT_NEEDED, for example), or section names that are converted to addresses.

[ruiu]

I wonder if you really want to distinguish d_val from d_ptr. Here is the definition of the Elf_Dyn struct:

struct Elf32_Dyn {
  Elf32_Sword d_tag; // Type of dynamic table entry.
  union {
    Elf32_Word d_val; // Integer value of entry.
    Elf32_Addr d_ptr; // Pointer value of entry.
  } d_un;
};

d_val and d_ptr are exclusive and are just aliases to each other. As far as I know, people don't usually try to distinguish them; instead just use d_val.

You could distinguish them and use either d_val and d_ptr depending on a d_tag value, but if you actually to do that, you have to explicitly specify which field, d_val or d_ptr, you want to use for *every* d_tag value. That's perhaps isn't worth it.

So, if I were you, I'd simply use d_val for all d_tag values and don't use d_ptr. In other words, I'd define DynamicEntry as follows:

struct DynamicEntry {
  ELF_DT Tag;
  int64 Val;
};

instead of this:

struct DynamicEntry {
  ELF_DT Tag;
  Optional<uint64_t> Val;
  Optional<llvm::yaml::Hex64> Ptr;
};

[amontanez]

I was thinking the same while writing this. The only argument I have is that this allows obj2yaml to print values in decimal and pointers in hexadecimal. That's a rather weak argument though. I'm totally fine with simplifying it down to just using d_val.

[jhenderson]

On the hex versus decimal front, I think hex is the better way to go.

llvm/include/llvm/ObjectYAML/ELFYAML.h

94

Somewhat moot if you follow @ruiu's suggestion (which I support), but this should be an int64_t.

llvm/lib/ObjectYAML/ELFYAML.cpp

60

Where did you get this list from? It looks like you might have missed some that LLVM supports (e.g. the DT_RELR* tags). I'd recommend taking the list from the list in BinaryFormat/DynamicTags.def.

95–98

I'm not sure these 4 really should be accepted, since they don't actually represent true dynamic tag values, but are rather markers.

That being said, I see that the equivalents in SHT_* are, so I'm okay with them being left in.

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

14 ↗

(On Diff #181192)

Is it possible to give more context to this message, e.g. Dynamic entry "DT_FLAGS"... or something similar that allows easier identification?

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

1 ↗

(On Diff #181192)

I think that there was nothing wrong with the original test. I'd like to be able to write dynamic sections with custom headers and contents, as well as with custom tag lists. You should have both tests, in my opinion.

On that note, bonus points if you can do a section definition of .dynamic (e.g. with custom sh_link field set), but with dynamic tags using this kind of format. I think relocation sections work like that?

15 ↗

(On Diff #181192)

It would be good if these sort of things could be specified both with arbitrary hex values and with references to things, e.g. sections, so that they can be specified like:

DynamicEntries:
  - Tag: DT_STRTAB
    Pointer: .dynstr

llvm/tools/yaml2obj/yaml2elf.cpp

428

Copy/paste error?

429–431

Why not create an explicit DT_NULL tag, rather than calling zero()?

906–907

I'm unconvinced by this line here, unless you're going to auto-populate the dynamic section with tags such as DT_SYMTAB in this case.

[amontanez]

I changed a lot and included the majority of what was originally going to be in a second follow-up patch.

Added:

• Some dynamic entries are validated for correctness.
• Some dynamic entries can be automatically inferred.
• Values can be numbers, strings (for things like DT_SONAME and DT_NEEDED, for example), or section names that are converted to addresses.

Changed:

• initSymtabSectionHeader() is split into initSymtabSectionHeader() and finalizeSymtabSection(). This allows .dynamic strings to be placed in .dynstr alongside the strings from .dynsym (since DotDynstr.finalize() is now separated out).

Removed:

• SHT_DYNAMIC no longer supports the "Content" tag for sections that have raw content. This breaks tools/llvm-objdump/private-headers-no-dynamic-segment.test
• zero(SHeader) removed from beginning of finalizeSymtabSection() and initStrtabSectionHeader(). This prevented sh_addr from being populated when symbol tables were specified.

[amontanez]

llvm/tools/yaml2obj/yaml2elf.cpp

906–907

That was the original goal, it just wasn't included in the patch. I've adjusted the implicit section names for now since that functionality isn't added yet.

[ruiu]

llvm/include/llvm/ObjectYAML/ELFYAML.h

94

Hmm, why is this of type StringRef? Isn't this uint64_t?

llvm/tools/yaml2obj/yaml2elf.cpp

417

Perhaps you should inverse the condition and continue early, to reduce the indentation depth.

424

Stray break? (You don't need this because this is at the end of the last case, and if you really want it it is not indented correctly.)

459–461

At first I thought that yamlError(...) creates a new object and you were returning it, but that's actually not the case. You are just returning false. Why don't you write it in two lines?

printError(YamlEntry, "value and linked string table address are inconsistent");
return false;

If you define a helper lambda function inside this function like this

auto Report = [&](StringRef Msg) {
  yaml::Output Yout(errs());
  Yout << YamlObj;
  WithColor::error() << Msg << "\n";
};

then you can write like this:

Report("value and linked string table address are inconsistent");
return false;

520

I don't think you need to work that hard to minimize a scope of a variable.

[amontanez]

llvm/include/llvm/ObjectYAML/ELFYAML.h

94

Making Value a StringRef gives more flexibility for how the value of a dynamic entry can be populated. I've listed a few examples below that illustrate how this is currently used.

Using a section name rather than manually entering the address of a section:

Tag: DT_STRTAB
Value: .dynstr

Using a string that will be added to .dynstr:

Tag: DT_SONAME
Value: libsomething.so

Or, the simple case of using a numeric value:

Tag: DT_STRSZ
Value:  0xa0

[ruiu]

llvm/include/llvm/ObjectYAML/ELFYAML.h

94

Tag: DT_STRTAB
Value: .dynstr

What if two or more sections have the same name ".dynstr"? In ELF, at least in spirit, section names are not significant.

I feel that in order to discuss the final file format of the text-based ELF in YAML, code review is not the best place. Also, I think that we shouldn't discuss one YAML tag at a time. I'd rather want to take a look at the final form of the text-based ELF file so that I can get a big picture. Do you have such example? It doesn't have to be a formal document or anything, but just an example or two of a text-based ELF file should suffice.

[amontanez]

llvm/include/llvm/ObjectYAML/ELFYAML.h

94

What if two or more sections have the same name ".dynstr"? In ELF, at least in spirit, section names are not significant.

I completely agree with your sentiment here. yaml2elf requires section names to be unique (see buildSectionIndex()), and a large portion of the tool's design depends on this. I know this isn't the case for regular ELF files, but it's a design choice this tool makes and a non-trivial amount of yaml2elf would have to be re-written to change that.

I'll draft up a few examples and add them to the main comment thread of this patch so we can focus on that discussion.

[amontanez]

The goal of this change is to introduce a new type of YAML section that allows the population of .dynamic entries by providing a list of tag and value pairs. These entries are interpreted (and potentially validated) before being written to the .dynamic section.

The simplest way to satisfy this requirement is for all dynamic entry values to be numeric values. However, this poses a few problems. The first problem I encountered is that if dynamic symbols are specified, the contents of .dynstr can't be manually specified or modified. This inherently prevents entries like DT_SONAME, DT_NEEDED, DT_RPATH, and DT_RUNPATH from being specified alongside dynamic symbols unless everything (all contents of .dynstr and .dynsym) is specified manually through raw contents (i.e. hex strings). The second problem is that in a given YAML file, multiple references to the same thing might not remain consistent. I had an issue where manually entering .dynamic contents via hex would often result in the annotations for the hex being inconsistent with the hex itself. A good example of this is maintaining a correct DT_STRSZ as the contents of a string table are updated.

To address these issues, this patch introduces three ways to input a value for a dynamic entry. All of these cases are illustrated later with an example.

• For strings that belong in .dynstr, the string itself can be used as the value for an entry.
• A section name can be used in place of an address. In this case, the value of the dynamic entry is the sh_addr of the specified section.
• A value can be specified using hexadecimal or decimal (or other bases supported by StringRef::to_integer()).

When writing the .dynamic section entries, yaml2elf can validate the correctness of some tags. For example, DT_STRTAB's value must be consistent with the address specified in the section header of the linked section (in pseudocode, StrtabEnt.Val == SHdrs[Dynamic.sh_link].sh_addr). If dynamic entries have strict enough constraints, they can also be inferred and automatically added (whether or not this should happen and how to control this from the user's side is up for discussion).

Here's an example to illustrate some of this.

!ELF
FileHeader:
  Class:           ELFCLASS64
  Data:            ELFDATA2LSB
  Type:            ET_DYN
  Machine:         EM_X86_64
Sections:
  - Name: .dynsym
    Type: SHT_DYNSYM
    Address: 0x1000
  - Name: .data
    Type: SHT_PROGBITS
    Flags: [ SHF_ALLOC, SHF_WRITE ]
  - Name: .dynamic
    Type: SHT_DYNAMIC
    Entries:
      - Tag: DT_SONAME
        Value: libsomething.so
      - Tag: DT_SYMTAB
        Value: .dynsym
      - Tag: DT_SYMENT
        Value: 0x18
DynamicSymbols:
  Global:
    - Name: foo
      Type: STT_FUNC
      Section: .data
    - Name: bar
      Type: STT_OBJECT
      Section: .data

The final section is of type SHT_DYNAMIC, and the Entries: key illustrates the proposed addition. Walking through the three dynamic entries,

1. DT_SONAME: The value of this entry is a string that will be inserted into the dynamic string table (.dynstr) alongside the symbol names specified in DynamicSymbols. This is possible due to the nature of .dynstr being represented as a StringTableBuilder, and that .dynamic is linked to .dynstr by default. If the .dynamic section had been linked to a section other than .dynstr, the value of this entry would have to be a number (the offset of the string in the linked string table) rather than a string.

2. DT_SYMTAB: This tag doesn't have any unique treatment or validation specified, but it illustrates the option of using the name of a section rather than the address. This resolves to 0x1000 since .dynsym is declared with an address of 0x1000. It would have been equally valid to make this entry have a value of 0x1000, but this means that changes to .dynsym's address don't need to be updated in the dynamic entry. It's also worth noting that in the case of DT_SYMTAB it wouldn't be difficult to infer this, meaning it would be possible to later add this entry if it was missing.

3. DT_SYMENT: This tag also doesn't have any unique treatment or validation specified. Since 0x18 isn't a section name, it is treated as a number. This entry could also easily be automatically inferred.

I understand that automatically adding .dynamic entries that aren't explicitly specified could easily be undesirable, but it also simplifies the process of generating an ELF binary with all the required dynamic entries. Currently I have one proposed "solution" for this: if a DT_NULL entry is specified at the end of a set of dynamic entries, no additional dynamic entries will be generated. This isn't currently implemented, but does give the user control over the behavior. This behavior would need to be very clearly documented. I'm not dead-set on having entries automatically added to the binary even if absent from the explicit list of dynamic entries, though it's something I'd certainly take advantage of when creating tests for llvm-elfabi. I'm very much open to discussion on this.

Hopefully this better explains where the goals of this change, where it currently stands, and why it was designed in this way.

[amontanez]

Quick changes to address some of Rui's comments, and introduced support for the older raw "Content" tag so tools/llvm-objdump/private-headers-no-dynamic-segment.test doesn't fail anymore.

I'll try not to make any other changes until we have more discussion about what we'd like this patch to look like at a macro level.

Edit: Oof, forgot to delete the old printYamlError() function. I've fixed it and will include the change in the next update.

[jhenderson]

I agree that the design maybe needs a bit more discussion. Perhaps the message you posted in the comment thread should be posted as an RFC on the llvm-dev mailing list?

[ruiu]

Oh, sorry, I was thinking that this patch is for llvm-tapi, but this is really for yaml2obj. I'm sorry, perhaps my previous comments might be pointless...

I'd like to ask first what is the motivation of this change. As far as I know, yaml2obj is used for generating test binary files in the LLVM lit tests. Do you have a need to generate an ELF file with a .dynamic section for testing? If so, could you explain why?

[amontanez]

There were quite a few tests that required the .dynamic section in D55629. D55852 tests also have a number of .dynamic entries as well. Without the ability to write .dynamic entries in yaml2obj, these will continue to contain a good portion of hexidecimal section contents with annotations. This addition to yaml2obj is going to be rather low-priority for me, but I feel it's the best way to make llvm-elfabi tests more legible. It also will make creation of new tests significantly easier.

[jhenderson]

See also D56791. I needed it to test llvm-readobj's printing of dynamic relocations, which is driven via the dynamic section. I ended up hand-crafting the contents, but it was a bit messy, and definitely unreadable.

[grimar]

In D56569#1362258, @amontanez wrote:

There were quite a few tests that required the .dynamic section in D55629. D55852 tests also have a number of .dynamic entries as well. Without the ability to write .dynamic entries in yaml2obj, these will continue to contain a good portion of hexidecimal section contents with annotations. This addition to yaml2obj is going to be rather low-priority for me, but I feel it's the best way to make llvm-elfabi tests more legible. It also will make creation of new tests significantly easier.

Hi Armando! Sorry, I did not notice this patch earlier. I have a simple solution implemented in D57691 which teaches the tools to parse and dump the .dynamic section and its dynamic tags.
It does not try to do anything else rather than dumping and parsing the existent entries, though that seems to be enough for the purposes of improving the tests.

Would you mind if I try to land it? It seems to me that features of this patch like "dynamic entries are validated for correctness.", "dynamic entries can be automatically inferred." and
others are something more complicated and can/should be implemented on top.

[amontanez]

This change as-is does a lot, which was what sparked the desire for a RFC. My plan was to trim down this patch once the RFC reached a general consensus so we could have the basic functionality of tag/value pairs and build on that. Further additions (like automatically adding required entries) would be addressed in subsequent changes. If you have anything you'd like to add to the RFC, feel free. I'm fine with you working to land D57691 first if that is high-priority. Otherwise, I can reduce this patch to reflect the general functionality of yours while using some nuances that will prepare for the future features.

[grimar]

In D56569#1385707, @amontanez wrote:

Otherwise, I can reduce this patch to reflect the general functionality of yours while using some nuances that will prepare for the future features.

I think we should start from little, so yes, that would be great.
Any other opinions?

[jhenderson]

As nobody has really fed back on the RFC, I think we should just go with the consensus among the (very limited) set of developers who have responded to that and on here. I'd go ahead and respin this patch to a minimal set and/or progress @grimar's in a similar manner. It might be nice to keep this patch in some form as a sort of target to aim for with the sum of the patches going forwards, i.e. rather than overwriting the diff here, create a new patch with the small subset.

[amontanez]

See D57975 for the new patch introducing support for writing .dynamic entries. It doesn't include any changes to obj2yaml, or seek to update existing tests. I'm marking this patch as "planned changes" to reduce confusion as to which should be reviewed.

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,
+    DynamicSection,
     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) {}
+  RawContentSection(SectionKind Kind) : Section(Kind) {}
 
   static bool classof(const Section *S) {
     return S->Kind == SectionKind::RawContent;
   }
 };
 
+struct DynamicSection : RawContentSection {
+  std::vector<DynamicEntry> DynamicEntries;
+
+  DynamicSection() : RawContentSection(SectionKind::DynamicSection) {}
+
+  static bool classof(const Section *S) {
+    return S->Kind == SectionKind::DynamicSection;
+  }
+};
+
 struct NoBitsSection : Section {
   llvm::yaml::Hex64 Size;
 
   NoBitsSection() : Section(SectionKind::NoBits) {}
 
   static bool classof(const Section *S) {
     return S->Kind == 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 ECase(X) IO.enumCase(Value, #X, ELF::X)
+  ECase(DT_NULL);
+  ECase(DT_NEEDED);
+  ECase(DT_PLTRELSZ);
+  ECase(DT_PLTGOT);
+  ECase(DT_HASH);
+  ECase(DT_STRTAB);
+  ECase(DT_SYMTAB);
+  ECase(DT_RELA);
+  ECase(DT_RELASZ);
+  ECase(DT_RELAENT);
+  ECase(DT_STRSZ);
+  ECase(DT_SYMENT);
+  ECase(DT_INIT);
+  ECase(DT_FINI);
+  ECase(DT_SONAME);
+  ECase(DT_RPATH);
+  ECase(DT_SYMBOLIC);
+  ECase(DT_REL);
+  ECase(DT_RELSZ);
+  ECase(DT_RELENT);
+  ECase(DT_PLTREL);
+  ECase(DT_DEBUG);
+  ECase(DT_TEXTREL);
+  ECase(DT_JMPREL);
+  ECase(DT_BIND_NOW);
+  ECase(DT_INIT_ARRAY);
+  ECase(DT_FINI_ARRAY);
+  ECase(DT_INIT_ARRAYSZ);
+  ECase(DT_FINI_ARRAYSZ);
+  ECase(DT_RUNPATH);
+  ECase(DT_FLAGS);
+  ECase(DT_ENCODING);
+  ECase(DT_PREINIT_ARRAY);
+  ECase(DT_PREINIT_ARRAYSZ);
+  ECase(DT_SYMTAB_SHNDX);
+  ECase(DT_RELRSZ);
+  ECase(DT_RELR);
+  ECase(DT_RELRENT);
+  ECase(DT_ANDROID_REL);
+  ECase(DT_ANDROID_RELSZ);
+  ECase(DT_ANDROID_RELA);
+  ECase(DT_ANDROID_RELASZ);
+  ECase(DT_ANDROID_RELR);
+  ECase(DT_ANDROID_RELRSZ);
+  ECase(DT_ANDROID_RELRENT);
+  ECase(DT_GNU_HASH);
+  ECase(DT_TLSDESC_PLT);
+  ECase(DT_TLSDESC_GOT);
+  ECase(DT_RELACOUNT);
+  ECase(DT_RELCOUNT);
+  ECase(DT_FLAGS_1);
+  ECase(DT_VERSYM);
+  ECase(DT_VERDEF);
+  ECase(DT_VERDEFNUM);
+  ECase(DT_VERNEED);
+  ECase(DT_VERNEEDNUM);
+  ECase(DT_HEXAGON_SYMSZ);
+  ECase(DT_HEXAGON_VER);
+  ECase(DT_HEXAGON_PLT);
+  ECase(DT_MIPS_RLD_VERSION);
+  ECase(DT_MIPS_TIME_STAMP);
+  ECase(DT_MIPS_ICHECKSUM);
+  ECase(DT_MIPS_IVERSION);
+  ECase(DT_MIPS_FLAGS);
+  ECase(DT_MIPS_BASE_ADDRESS);
+  ECase(DT_MIPS_MSYM);
+  ECase(DT_MIPS_CONFLICT);
+  ECase(DT_MIPS_LIBLIST);
+  ECase(DT_MIPS_LOCAL_GOTNO);
+  ECase(DT_MIPS_CONFLICTNO);
+  ECase(DT_MIPS_LIBLISTNO);
+  ECase(DT_MIPS_SYMTABNO);
+  ECase(DT_MIPS_UNREFEXTNO);
+  ECase(DT_MIPS_GOTSYM);
+  ECase(DT_MIPS_HIPAGENO);
+  ECase(DT_MIPS_RLD_MAP);
+  ECase(DT_MIPS_DELTA_CLASS);
+  ECase(DT_MIPS_DELTA_CLASS_NO);
+  ECase(DT_MIPS_DELTA_INSTANCE);
+  ECase(DT_MIPS_DELTA_INSTANCE_NO);
+  ECase(DT_MIPS_DELTA_RELOC);
+  ECase(DT_MIPS_DELTA_RELOC_NO);
+  ECase(DT_MIPS_DELTA_SYM);
+  ECase(DT_MIPS_DELTA_SYM_NO);
+  ECase(DT_MIPS_DELTA_CLASSSYM);
+  ECase(DT_MIPS_DELTA_CLASSSYM_NO);
+  ECase(DT_MIPS_CXX_FLAGS);
+  ECase(DT_MIPS_PIXIE_INIT);
+  ECase(DT_MIPS_SYMBOL_LIB);
+  ECase(DT_MIPS_LOCALPAGE_GOTIDX);
+  ECase(DT_MIPS_LOCAL_GOTIDX);
+  ECase(DT_MIPS_HIDDEN_GOTIDX);
+  ECase(DT_MIPS_PROTECTED_GOTIDX);
+  ECase(DT_MIPS_OPTIONS);
+  ECase(DT_MIPS_INTERFACE);
+  ECase(DT_MIPS_DYNSTR_ALIGN);
+  ECase(DT_MIPS_INTERFACE_SIZE);
+  ECase(DT_MIPS_RLD_TEXT_RESOLVE_ADDR);
+  ECase(DT_MIPS_PERF_SUFFIX);
+  ECase(DT_MIPS_COMPACT_SIZE);
+  ECase(DT_MIPS_GP_VALUE);
+  ECase(DT_MIPS_AUX_DYNAMIC);
+  ECase(DT_MIPS_PLTGOT);
+  ECase(DT_MIPS_RWPLT);
+  ECase(DT_MIPS_RLD_MAP_REL);
+  ECase(DT_PPC64_GLINK);
+  // Sun machine-independent extensions.
+  ECase(DT_AUXILIARY);
+  ECase(DT_FILTER);
+#undef ECase
+}
+
 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);
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(IO, Section);
+  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());

llvm/test/tools/yaml2obj/dynamic-dtstrtab-inconsistent.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 ]
+    Content: "00"
+    Address: 0x1000
+  - Name: .dynamic
+    Type: SHT_DYNAMIC
+    Flags: [ SHF_ALLOC, SHF_WRITE ]
+    Link: .somestrings
+    Entries:
+      # This entry conflicts with the previously specified `Link` key.
+      - Tag: DT_STRTAB
+        Value: .dynstr
+
+# CHECK:      ---
+# CHECK-NEXT: Tag: DT_STRTAB
+# CHECK-NEXT: Value: .dynstr
+# CHECK-NEXT: ...
+# CHECK-NEXT: error: value and linked string table are inconsistent

llvm/test/tools/yaml2obj/dynamic-dtstrtab-invalid.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 ]
+    Content: "00"
+    Address: 0x1000
+  - Name: .dynamic
+    Type: SHT_DYNAMIC
+    Flags: [ SHF_ALLOC, SHF_WRITE ]
+    Link: .somestrings
+    Entries:
+      # This isn't a declared section.
+      - Tag: DT_STRTAB
+        Value: .notasection
+
+# CHECK:      ---
+# CHECK-NEXT: Tag: DT_STRTAB
+# CHECK-NEXT: Value: .notasection
+# CHECK-NEXT: ...
+# CHECK-NEXT: error: value is not an address or valid section name

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

+# RUN: yaml2obj %s -o %t
+# RUN: llvm-readobj -sections %t | FileCheck %s --check-prefix=SECTION
+# 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: .dynamic
+    Type: SHT_DYNAMIC
+    Flags: [ SHF_ALLOC, SHF_WRITE ]
+    Entries:
+      - Tag: DT_FLAGS
+        Value: 0xa
+      - Tag: DT_DEBUG
+        Value: 0x1000
+# 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
+
+# SECTION: Name:      .dynamic
+# SECTION: EntrySize: 16
+# DYNAMIC: FLAGS  SYMBOLIC BIND_NOW
+# DYNAMIC: DEBUG  0x1000{{$}}

llvm/test/tools/yaml2obj/dynamic-link-str-offset.yaml

+# This test links .dynamic to .somestrings and ensures that DT_SONAME is still
+# correct.
+# 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_SONAME
+        Value: 1
+      - Tag: DT_STRTAB
+        Value: 0x1000
+# 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: Library soname: [libsomething.so]
+# DYNAMIC: STRTAB 0x1000{{$}}
+# DYNAMIC: STRSZ 17 (bytes)

llvm/test/tools/yaml2obj/dynamic-link-str-req-offset.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 ]
+    Content: "00"
+  - Name: .dynamic
+    Type: SHT_DYNAMIC
+    Flags: [ SHF_ALLOC, SHF_WRITE ]
+    Link: .somestrings
+    Entries:
+      - Tag: DT_SONAME
+        Value: somelib.so
+
+# CHECK:      ---
+# CHECK-NEXT: Tag: DT_SONAME
+# CHECK-NEXT: Value: somelib.so
+# CHECK-NEXT: ...
+# CHECK-NEXT: error: must be a numerical offset since .dynamic is not linked to .dynstr

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

+# RUN: yaml2obj %s -o %t
+# RUN: llvm-readobj -sections %t | FileCheck %s --check-prefix=SECTION
+# 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: .dynamic
+    Type: SHT_DYNAMIC
+    Flags: [ SHF_ALLOC, SHF_WRITE ]
+    Entries:
+      - Tag: DT_SONAME
+        Value: libsomething.so
+      - Tag: DT_DEBUG
+        Value: 0x1000
+# 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
+
+# SECTION: Name:      .dynamic
+# SECTION: EntrySize: 16
+# DYNAMIC: Library soname: [libsomething.so]
+# DYNAMIC: DEBUG  0x1000{{$}}

llvm/test/tools/yaml2obj/dynamic-strsz-gt.yaml

+# This test checks to ensure that an error occurs if the DT_STRSZ entry
+# value is greater than the size of the linked section.
+# 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: 24
+
+# CHECK:      ---
+# CHECK-NEXT: Tag: DT_STRSZ
+# CHECK-NEXT: Value: '24'
+# CHECK-NEXT: ...
+# CHECK-NEXT: error: value is larger than linked string table size

llvm/test/tools/yaml2obj/dynamic-strsz-invalid.yaml

+# This test checks to ensure that an error occurs if the DT_STRSZ entry
+# value is greater than the size of the linked section.
+# 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: char
+
+# CHECK:      ---
+# CHECK-NEXT: Tag: DT_STRSZ
+# CHECK-NEXT: Value: char
+# CHECK-NEXT: ...
+# CHECK-NEXT: error: value is not a number

llvm/test/tools/yaml2obj/dynamic-strsz-lt.yaml

+# This test checks to ensure that a warning is emitted if the DT_STRSZ entry
+# value is less than the size of the linked section.
+# RUN: yaml2obj %s -o %t 2>&1 | FileCheck %s --check-prefix=WARNING
+# 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: 5
+# 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
+# WARNING: warning: DT_STRSZ value is less than linked string table size
+# DYNAMIC: STRSZ 5 (bytes)
+# DYNAMIC: STRTAB 0x1000{{$}}

llvm/tools/yaml2obj/yaml2elf.cpp

 //===- yaml2elf - Convert YAML to a ELF object file -----------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// The ELF component of yaml2obj.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "yaml2obj.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/SmallSet.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/MC/StringTableBuilder.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/ObjectYAML/ELFYAML.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Support/YAMLTraits.h"
 #include "llvm/Support/raw_ostream.h"
static void writeArrayData(raw_ostream &OS, ArrayRef<T> A) {
   OS.write((const char *)A.data(), arrayDataSize(A));
 }
 
 template <class T>
 static void zero(T &Obj) {
   memset(&Obj, 0, sizeof(Obj));
 }
 
+/// This function uses YAML to output a guilty object before printing an error.
+/// Using this approach provides more context than a simple assert can while
+/// also allowing more graceful termination.
+///
+/// @param YamlObj An object with YAML traits that triggered this error.
+/// @param After The error message to print after the YAML object.
+/*
+template <typename T> bool printYamlError(T YamlObj, StringRef After) {
+  yaml::Output Yout(errs());
+  Yout << YamlObj;
+  WithColor::error() << After << "\n";
+  return false;
+}
+*/
 namespace {
 /// "Single point of truth" for the ELF file construction.
 /// TODO: This class still has a ways to go before it is truly a "single
 /// point of truth".
 template <class ELFT>
 class ELFState {
   typedef typename ELFT::Ehdr Elf_Ehdr;
   typedef typename ELFT::Phdr Elf_Phdr;
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 can't be written until after the
+  /// .dynstr section. The contents of .dynamic depend on the final contents of
+  /// .dynstr.
+  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 initSymtabSectionHeader(Elf_Shdr &SHeader, SymtabType STType);
+  void finalizeSymtabSection(Elf_Shdr &SHeader, SymtabType STType,
   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) {}
else if (auto S = dyn_cast<ELFYAML::RelocationSection>(Sec.get())) {
         SHeader.sh_link = getDotSymTabSecNo();
 
       unsigned Index;
       if (!convertSectionIndex(SN2I, S->Name, S->Info, Index))
         return false;
       SHeader.sh_info = Index;
       if (!writeSectionContent(SHeader, *S, CBA))
         return false;
+    } else if (auto S = dyn_cast<ELFYAML::DynamicSection>(Sec.get())) {
+      // Determine whether to use `Entries` or older raw `Contents`.
+      if (!S->DynamicEntries.empty())
+        YamlDynamicSection = S;
+      else
+        writeSectionContent(SHeader, (ELFYAML::RawContentSection &)*S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::Group>(Sec.get())) {
       unsigned SymIdx;
       if (SymN2I.lookup(S->Info, SymIdx) && !to_integer(S->Info, SymIdx)) {
         WithColor::error() << "Unknown symbol referenced: '" << S->Info
                            << "' at YAML section '" << S->Name << "'.\n";
         return false;
       }
       SHeader.sh_info = SymIdx;
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);
+                                             SymtabType STType) {
   bool IsStatic = STType == SymtabType::Static;
   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 = 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 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();
+}
+
+template <class ELFT>
+void ELFState<ELFT>::finalizeSymtabSection(Elf_Shdr &SHeader,
+                                           SymtabType STType,
+                                           ContiguousBlobAccumulator &CBA) {
+  bool IsStatic = STType == SymtabType::Static;
+  const auto &Symbols = IsStatic ? Doc.Symbols : Doc.DynamicSymbols;
+  auto &Strtab = IsStatic ? DotStrtab : DotDynstr;
+
+  std::vector<Elf_Sym> Syms;
+  {
+    // Ensure STN_UNDEF is present
+    Elf_Sym Sym;
+    zero(Sym);
+    Syms.push_back(Sym);
+  }
 
   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>
 void ELFState<ELFT>::initStrtabSectionHeader(Elf_Shdr &SHeader, StringRef Name,
                                              StringTableBuilder &STB,
                                              ContiguousBlobAccumulator &CBA) {
-  zero(SHeader);
   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 = 8;
+  // For .dynamic section set link to .dynstr by default.
+  if (YamlDynamicSection->Link.empty())
+    SHeader.sh_link = getDotDynStrSecNo();
+
+  // If not linked to .dynstr, this is done.
+  if (SHeader.sh_link != getDotDynStrSecNo())
+    return;
+
+  // If linked to .dynstr, DT_* entries whose values refer to offsets in
+  // .dynstr table may be populated with strings.
+  for (const auto &YamlEntry : YamlDynamicSection->DynamicEntries) {
+    switch (YamlEntry.Tag) {
+    case ELF::DT_NEEDED:
+    case ELF::DT_SONAME:
+    case ELF::DT_RPATH:
+    case ELF::DT_RUNPATH:
+      DotDynstr.add(YamlEntry.Val);
+    }
+  }
+}
+
+template <class ELFT>
+bool ELFState<ELFT>::finalizeDynamicSection(Elf_Shdr &DynamicHdr,
+                                            std::vector<Elf_Shdr> &AllShdrs,
+                                            ContiguousBlobAccumulator &CBA) {
+  std::vector<Elf_Dyn> Dyn;
+  SmallSet<int64_t, 32> FoundTags;
+  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;
+    FoundTags.insert(Ent.d_tag);
+    uint64_t Value;
+
+    // Handle .dynamic entries whose values represent offsets in .dynstr.
+    if (Ent.d_tag == ELF::DT_NEEDED || Ent.d_tag == ELF::DT_SONAME ||
+        Ent.d_tag == ELF::DT_RPATH || Ent.d_tag == ELF::DT_RUNPATH) {
+      if (DynamicHdr.sh_link == getDotDynStrSecNo())
+        Value = DotDynstr.getOffset(YamlEntry.Val);
+      else if (!to_integer(YamlEntry.Val, Value)) {
+        printYamlError(YamlEntry, "must be a numerical offset since "
+                                  ".dynamic is not linked to .dynstr");
+        return false;
+      }
+      // Ensure correctness of DT_STRTAB entry.
+    } else if (Ent.d_tag == ELF::DT_STRTAB) {
+      // Validate that DT_STRTAB is either the name of the linked section, or it
+      // is the address of the linked section.
+      unsigned LinkedStrTab = DynamicHdr.sh_link;
+      // Case that DT_STRTAB value is an address.
+      if (to_integer(YamlEntry.Val, Value)) {
+        if (Value != AllShdrs[LinkedStrTab].sh_addr) {
+          printYamlError(
+              YamlEntry,
+              "value and linked string table address are inconsistent");
+          return false;
+        }
+      // Case that DT_STRTAB is the name of a section.
+      } else if (!SN2I.lookup(YamlEntry.Val, LinkedStrTab)) {
+        if (LinkedStrTab != DynamicHdr.sh_link) {
+          printYamlError(YamlEntry,
+                         "value and linked string table are inconsistent");
+          return false;
+        }
+        Value = AllShdrs[LinkedStrTab].sh_addr;
+      // Neither a valid address nor a valid section name.
+      } else {
+        printYamlError(YamlEntry,
+                       "value is not an address or valid section name");
+        return false;
+      }
+    // Ensure correctness of DT_STRSZ entry.
+    } else if (Ent.d_tag == ELF::DT_STRSZ) {
+      unsigned LinkedStrTab = DynamicHdr.sh_link;
+      if (!to_integer(YamlEntry.Val, Value)) {
+        printYamlError(YamlEntry, "value is not a number");
+        return false;
+      }
+      if (Value < AllShdrs[LinkedStrTab].sh_size) {
+        WithColor::warning()
+            << "DT_STRSZ value is less than linked string table size\n";
+      } else if (Value > AllShdrs[LinkedStrTab].sh_size) {
+        printYamlError(YamlEntry,
+                       "value is larger than linked string table size");
+        return false;
+      }
+    // General case for unspecialized dynamic entries.
+    } else {
+      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);
+  }
+  // Automatically add missing dynamic entries that can be inferred.
+  if (!FoundTags.count(ELF::DT_STRTAB)) {
+    unsigned LinkedStrTab = DynamicHdr.sh_link;
+    Elf_Dyn DTStrTab;
+    DTStrTab.d_tag = ELF::DT_STRTAB;
+    DTStrTab.d_un.d_ptr = AllShdrs[LinkedStrTab].sh_addr;
+    Dyn.push_back(DTStrTab);
+  }
+  if (!FoundTags.count(ELF::DT_STRSZ)) {
+    unsigned LinkedStrTab = DynamicHdr.sh_link;
+    Elf_Dyn DTStrTabSz;
+    DTStrTabSz.d_tag = ELF::DT_STRSZ;
+    DTStrTabSz.d_un.d_val = AllShdrs[LinkedStrTab].sh_size;
+    Dyn.push_back(DTStrTabSz);
+  }
+  // Ensure DT_NULL is present.
+  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;
int ELFState<ELFT>::writeELF(raw_ostream &OS, const ELFYAML::Object &Doc) {
   if(!State.initSectionHeaders(SHeaders, CBA))
     return 1;
 
   // Populate SHeaders with implicit sections not present in the Doc
   for (const auto &Name : State.implicitSectionNames())
     if (State.SN2I.get(Name) >= SHeaders.size())
       SHeaders.push_back({});
 
-  // Initialize the implicit sections
+  // Initialize and write .symtab symbol table and section header.
   auto Index = State.SN2I.get(".symtab");
-  State.initSymtabSectionHeader(SHeaders[Index], SymtabType::Static, CBA);
+  State.initSymtabSectionHeader(SHeaders[Index], SymtabType::Static);
+  State.DotStrtab.finalize();
+  State.finalizeSymtabSection(SHeaders[Index], SymtabType::Static, CBA);
   Index = State.SN2I.get(".strtab");
   State.initStrtabSectionHeader(SHeaders[Index], ".strtab", State.DotStrtab, CBA);
   Index = State.SN2I.get(".shstrtab");
   State.initStrtabSectionHeader(SHeaders[Index], ".shstrtab", State.DotShStrtab, CBA);
+
+  // Populate DotDynstr by initializing both .dynsym and .dynamic sections.
+  // Initialize .dynsym section.
   if (State.hasDynamicSymbols()) {
     Index = State.SN2I.get(".dynsym");
-    State.initSymtabSectionHeader(SHeaders[Index], SymtabType::Dynamic, CBA);
+    State.initSymtabSectionHeader(SHeaders[Index], SymtabType::Dynamic);
     SHeaders[Index].sh_flags |= ELF::SHF_ALLOC;
+  }
+  // Initialize .dynamic section.
+  if (State.hasDynamicEntries()) {
+    Index = State.SN2I.get(".dynamic");
+    State.initDynamicSectionHeader(SHeaders[Index]);
+    SHeaders[Index].sh_flags |= ELF::SHF_ALLOC;
+  }
+  // Finalize and write .dynstr, .dynsym, and .dynamic.
+  if (State.hasDynamicSymbols() || State.hasDynamicEntries()) {
+    State.DotDynstr.finalize();
+
+    // Write .dynsym section header and contents.
+    if (State.hasDynamicSymbols()) {
+      Index = State.SN2I.get(".dynsym");
+      State.finalizeSymtabSection(SHeaders[Index], SymtabType::Dynamic, CBA);
+    }
+
+    // Write .dynstr section header and contents.
     Index = State.SN2I.get(".dynstr");
-    State.initStrtabSectionHeader(SHeaders[Index], ".dynstr", State.DotDynstr, CBA);
+    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 {
+  for (const auto &Sec : Doc.Sections) {
+    if (auto S = dyn_cast<ELFYAML::DynamicSection>(Sec.get())) {
+      return !S->DynamicEntries.empty();
+    }
+  }
+  return false;
+}
+
 template <class ELFT>
 SmallVector<const char *, 5> ELFState<ELFT>::implicitSectionNames() const {
-  if (!hasDynamicSymbols())
-    return {".symtab", ".strtab", ".shstrtab"};
+  if (hasDynamicSymbols())
     return {".symtab", ".strtab", ".shstrtab", ".dynsym", ".dynstr"};
+  if (hasDynamicEntries())
+    return {".symtab", ".strtab", ".shstrtab", ".dynstr", ".dynamic"};
+  return {".symtab", ".strtab", ".shstrtab"};
 }
 
 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);