[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

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

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

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

388

Copy/paste error?

389–391

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

740–741

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

740–741

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

377

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

384

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.)

419–421

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;

480

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;
+  Optional<uint64_t> Val;
+  Optional<llvm::yaml::Hex64> Ptr;
+};
+
 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 Object {
   std::vector<ProgramHeader> ProgramHeaders;
   std::vector<std::unique_ptr<Section>> Sections;
   // Although in reality the symbols reside in a section, it is a lot
   // cleaner and nicer if we read them from the YAML as a separate
   // top-level key, which automatically ensures that invariants like there
   // being a single SHT_SYMTAB section are upheld.
   LocalGlobalWeakSymbols Symbols;
   LocalGlobalWeakSymbols DynamicSymbols;
+  std::vector<DynamicEntry> Dynamic;
 };
 
 } // 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);
+  static StringRef validate(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_LOOS);
+  ECase(DT_HIOS);
+  ECase(DT_LOPROC);
+  ECase(DT_HIPROC);
+  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);
+
+  // Hexagon specific dynamic table entries
+  ECase(DT_HEXAGON_SYMSZ);
+  ECase(DT_HEXAGON_VER);
+  ECase(DT_HEXAGON_PLT);
+
+  // Mips specific dynamic table entry tags.
+  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);
+
+  // 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.mapOptional("Value", Entry.Val);
+  IO.mapOptional("Pointer", Entry.Ptr);
+}
+
+StringRef
+MappingTraits<ELFYAML::DynamicEntry>::validate(IO &IO,
+                                               ELFYAML::DynamicEntry &Entry) {
+  if (Entry.Val.hasValue() == Entry.Ptr.hasValue())
+    return "Dynamic entry must have either Value OR Pointer specified";
+
+  return StringRef();
+}
+
 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) {}
 

 void MappingTraits<ELFYAML::Object>::mapping(IO &IO, ELFYAML::Object &Object) {
   assert(!IO.getContext() && "The IO context is initialized already");
   IO.setContext(&Object);
   IO.mapTag("!ELF", true);
   IO.mapRequired("FileHeader", Object.Header);
   IO.mapOptional("ProgramHeaders", Object.ProgramHeaders);
   IO.mapOptional("Sections", Object.Sections);
   IO.mapOptional("Symbols", Object.Symbols);
+  IO.mapOptional("DynamicEntries", Object.Dynamic);
   IO.mapOptional("DynamicSymbols", Object.DynamicSymbols);
   IO.setContext(nullptr);
 }
 
 LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_AFL_REG)
 LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_ABI_FP)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_EXT)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_ASE)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_FLAGS1)
 
 } // end namespace yaml
 
 } // end namespace llvm

llvm/test/tools/yaml2obj/dynamic-entry-extra-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
+DynamicEntries:
+  - Tag: DT_FLAGS
+    Value: 0xa
+    Pointer: 0xa
+  - Tag: DT_DEBUG
+    Pointer: 0x1000
+
+# CHECK: Dynamic entry must have either Value OR Pointer specified

llvm/test/tools/yaml2obj/dynamic-entry-missing-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
+DynamicEntries:
+  - Tag: DT_FLAGS
+  - Tag: DT_DEBUG
+    Pointer: 0x1000
+
+# CHECK: Dynamic entry must have either Value OR Pointer specified

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

-# Ensures that dynamic section has sh_entsize correctly set
 # 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
+DynamicEntries:
+  - Tag: DT_FLAGS
+    Value: 0xa
+  - Tag: DT_DEBUG
+    Pointer: 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:
-  - Name: .dynamic
-    Type: SHT_DYNAMIC
-    Flags: [ SHF_ALLOC, SHF_WRITE ]
+      - Section: .dynamic
+      - Section: .dynstr
+  - Type: PT_DYNAMIC
+    Flags: [ PF_X, PF_R ]
+    VAddr: 0x0000
+    PAddr: 0x0000
+    Sections:
+      - Section: .dynamic
 
-# SECTION: Name: .dynamic
+# SECTION: Name:      .dynamic
 # SECTION: EntrySize: 16
+# DYNAMIC: FLAGS  SYMBOLIC BIND_NOW
+# DYNAMIC: DEBUG  0x1000{{$}}

llvm/tools/yaml2obj/yaml2elf.cpp

class ELFState {
   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);
+  void finalizeDynamicSection(Elf_Shdr &DynamicHdr,
+                              Elf_Shdr &DynStrHeader,
+                              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) {}
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_link = getDotDynStrSecNo();
+  SHeader.sh_entsize = sizeof(Elf_Dyn);
+  SHeader.sh_addralign = 8;
+}
+
+template <class ELFT>
+void ELFState<ELFT>::finalizeDynamicSection(Elf_Shdr &DynamicHdr,
+                                            Elf_Shdr &DynStrHeader,
+                                            ContiguousBlobAccumulator &CBA) {
+  std::vector<Elf_Dyn> Dyn;
+  for (const auto &YamlEntry : Doc.Dynamic) {
+    Elf_Dyn Ent;
+    Ent.d_tag = YamlEntry.Tag;
+    if (YamlEntry.Val.hasValue())
+      Ent.d_un.d_val = *YamlEntry.Val;
+    else
+      Ent.d_un.d_ptr = *YamlEntry.Ptr;
+    Dyn.push_back(Ent);
+  }
+  {
+    // Ensure STN_UNDEF is present
+    Elf_Dyn NullEnt;
+    zero(NullEnt);
+    Dyn.push_back(NullEnt);
+  }
+  writeArrayData(
+      CBA.getOSAndAlignedOffset(DynamicHdr.sh_offset, DynamicHdr.sh_addralign),
+      makeArrayRef(Dyn));
+  DynamicHdr.sh_size = arrayDataSize(makeArrayRef(Dyn));
+}
+
+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;
     else
       PHeader.p_offset = 0;
 
     // Find the minimum offset for the program header.
     for (auto SecName : YamlPhdr.Sections) {
       uint32_t Index = 0;
       SN2I.lookup(SecName.Section, Index);
       const auto &SHeader = SHeaders[Index];
       PHeader.p_offset = std::min(PHeader.p_offset, SHeader.sh_offset);
     }
 
     // Find the maximum offset of the end of a section in order to set p_filesz.
     PHeader.p_filesz = 0;
     for (auto SecName : YamlPhdr.Sections) {
       uint32_t Index = 0;
       SN2I.lookup(SecName.Section, Index);
       const auto &SHeader = SHeaders[Index];
       uint64_t EndOfSection;
       if (SHeader.sh_type == llvm::ELF::SHT_NOBITS)
         EndOfSection = SHeader.sh_offset;
       else
         EndOfSection = SHeader.sh_offset + SHeader.sh_size;
for (const auto &Sym : Symbols) {
     if (!Sym.Name.empty())
       Symbol.st_name = Strtab.getOffset(Sym.Name);
     Symbol.setBindingAndType(SymbolBinding, Sym.Type);
     if (!Sym.Section.empty()) {
       unsigned Index;
       if (SN2I.lookup(Sym.Section, Index)) {
         WithColor::error() << "Unknown section referenced: '" << Sym.Section
                            << "' by YAML symbol " << Sym.Name << ".\n";
         exit(1);
       }
       Symbol.st_shndx = Index;
     } else if (Sym.Index) {
       Symbol.st_shndx = *Sym.Index;
     }
     // else Symbol.st_shndex == SHN_UNDEF (== 0), since it was zero'd earlier.
     Symbol.st_value = Sym.Value;
     Symbol.st_other = Sym.Other;
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;
   }
 
+  // Initialize .dynamic section header and write contents.
+  if (State.hasDynamicEntries()) {
+    auto DynamicIdx = State.SN2I.get(".dynamic");
+    auto DynStrIdx = State.SN2I.get(".dynstr");
+    State.initDynamicSectionHeader(SHeaders[DynamicIdx]);
+    State.finalizeDynamicSection(SHeaders[DynamicIdx], SHeaders[DynStrIdx],
+                                 CBA);
+    SHeaders[Index].sh_flags |= ELF::SHF_ALLOC;
+  }
+
   // 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 {
+  if (hasDynamicSymbols())
+    return true;
+
+  return Doc.Dynamic.size() > 0;
+}
+
 template <class ELFT>
 SmallVector<const char *, 5> ELFState<ELFT>::implicitSectionNames() const {
-  if (!hasDynamicSymbols())
-    return {".symtab", ".strtab", ".shstrtab"};
-  return {".symtab", ".strtab", ".shstrtab", ".dynsym", ".dynstr"};
+  if (hasDynamicSymbols())
+    return {".symtab", ".strtab", ".shstrtab",
+            ".dynsym", ".dynstr", ".dynamic"};
+  if (hasDynamicEntries())
+    return {".symtab", ".strtab", ".shstrtab", ".dynstr", ".dynamic"};
 }
 
 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);