diff --git a/llvm/include/llvm/ObjectYAML/ELFYAML.h b/llvm/include/llvm/ObjectYAML/ELFYAML.h
--- a/llvm/include/llvm/ObjectYAML/ELFYAML.h
+++ b/llvm/include/llvm/ObjectYAML/ELFYAML.h
@@ -15,6 +15,8 @@
 #ifndef LLVM_OBJECTYAML_ELFYAML_H
 #define LLVM_OBJECTYAML_ELFYAML_H
 
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ObjectYAML/YAML.h"
 #include "llvm/Support/YAMLTraits.h"
@@ -498,6 +500,11 @@
   Optional<std::vector<Symbol>> Symbols;
   Optional<std::vector<Symbol>> DynamicSymbols;
 
+  DenseMap<StringRef, StringRef> Overridden;
+  DenseSet<StringRef> SeenOverridden;
+
+  Object(DenseMap<StringRef, StringRef> Overridden) : Overridden(Overridden) {}
+
   std::vector<Section *> getSections() {
     std::vector<Section *> Ret;
     for (const std::unique_ptr<Chunk> &Sec : Chunks)
@@ -538,8 +545,8 @@
 };
 
 template <>
-struct ScalarEnumerationTraits<ELFYAML::ELF_EM> {
-  static void enumeration(IO &IO, ELFYAML::ELF_EM &Value);
+struct ScalarEnumerationContextTraits<ELFYAML::ELF_EM, ELFYAML::Object> {
+  static void enumeration(IO &IO, ELFYAML::ELF_EM &Value, ELFYAML::Object &Ctx);
 };
 
 template <>
diff --git a/llvm/include/llvm/ObjectYAML/ObjectYAML.h b/llvm/include/llvm/ObjectYAML/ObjectYAML.h
--- a/llvm/include/llvm/ObjectYAML/ObjectYAML.h
+++ b/llvm/include/llvm/ObjectYAML/ObjectYAML.h
@@ -29,6 +29,7 @@
   std::unique_ptr<MachOYAML::UniversalBinary> FatMachO;
   std::unique_ptr<MinidumpYAML::Object> Minidump;
   std::unique_ptr<WasmYAML::Object> Wasm;
+  DenseMap<StringRef, StringRef> Overridden;
 };
 
 template <> struct MappingTraits<YamlObjectFile> {
diff --git a/llvm/include/llvm/ObjectYAML/yaml2obj.h b/llvm/include/llvm/ObjectYAML/yaml2obj.h
--- a/llvm/include/llvm/ObjectYAML/yaml2obj.h
+++ b/llvm/include/llvm/ObjectYAML/yaml2obj.h
@@ -14,6 +14,8 @@
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
 #include <memory>
+#include <string>
+#include <vector>
 
 namespace llvm {
 class raw_ostream;
@@ -54,7 +56,8 @@
 bool yaml2wasm(WasmYAML::Object &Doc, raw_ostream &Out, ErrorHandler EH);
 
 bool convertYAML(Input &YIn, raw_ostream &Out, ErrorHandler ErrHandler,
-                 unsigned DocNum = 1);
+                 unsigned DocNum = 1,
+                 std::vector<std::string> Substitutions = {});
 
 /// Convenience function for tests.
 std::unique_ptr<object::ObjectFile>
diff --git a/llvm/include/llvm/Support/YAMLTraits.h b/llvm/include/llvm/Support/YAMLTraits.h
--- a/llvm/include/llvm/Support/YAMLTraits.h
+++ b/llvm/include/llvm/Support/YAMLTraits.h
@@ -106,6 +106,10 @@
   // static void enumeration(IO &io, T &value);
 };
 
+/// Similar to ScalarEnumerationTraits<T>, but allows you to pass in an
+/// additional context.
+template <class T, class Context> struct ScalarEnumerationContextTraits {};
+
 /// This class should be specialized by any integer type that is a union
 /// of bit values and the YAML representation is a flow sequence of
 /// strings.  For example:
@@ -306,20 +310,25 @@
 template <typename T>
 struct MissingTrait;
 
-// Test if ScalarEnumerationTraits<T> is defined on type T.
-template <class T>
-struct has_ScalarEnumerationTraits
-{
-  using Signature_enumeration = void (*)(class IO&, T&);
-
+// Test if ScalarEnumerationContextTraits<T> is defined on type T.
+template <class T, class Context> struct has_ScalarEnumerationTraits {
   template <typename U>
-  static char test(SameType<Signature_enumeration, &U::enumeration>*);
+  static char
+  test(SameType<void (*)(class IO &, T &, Context &), &U::enumeration> *);
+  template <typename U> static double test(...);
+
+  static bool const value =
+      (sizeof(test<ScalarEnumerationContextTraits<T, Context>>(nullptr)) == 1);
+};
 
+// Test if ScalarEnumerationCTraits<T> is defined on type T.
+template <class T> struct has_ScalarEnumerationTraits<T, EmptyContext> {
   template <typename U>
-  static double test(...);
+  static char test(SameType<void (*)(class IO &, T &), &U::enumeration> *);
+  template <typename U> static double test(...);
 
   static bool const value =
-    (sizeof(test<ScalarEnumerationTraits<T>>(nullptr)) == 1);
+      (sizeof(test<ScalarEnumerationTraits<T>>(nullptr)) == 1);
 };
 
 // Test if ScalarBitSetTraits<T> is defined on type T.
@@ -719,17 +728,17 @@
 
 template <typename T, typename Context>
 struct missingTraits
-    : public std::integral_constant<bool,
-                                    !has_ScalarEnumerationTraits<T>::value &&
-                                        !has_ScalarBitSetTraits<T>::value &&
-                                        !has_ScalarTraits<T>::value &&
-                                        !has_BlockScalarTraits<T>::value &&
-                                        !has_TaggedScalarTraits<T>::value &&
-                                        !has_MappingTraits<T, Context>::value &&
-                                        !has_SequenceTraits<T>::value &&
-                                        !has_CustomMappingTraits<T>::value &&
-                                        !has_DocumentListTraits<T>::value &&
-                                        !has_PolymorphicTraits<T>::value> {};
+    : public std::integral_constant<
+          bool, !has_ScalarEnumerationTraits<T, Context>::value &&
+                    !has_ScalarBitSetTraits<T>::value &&
+                    !has_ScalarTraits<T>::value &&
+                    !has_BlockScalarTraits<T>::value &&
+                    !has_TaggedScalarTraits<T>::value &&
+                    !has_MappingTraits<T, Context>::value &&
+                    !has_SequenceTraits<T>::value &&
+                    !has_CustomMappingTraits<T>::value &&
+                    !has_DocumentListTraits<T>::value &&
+                    !has_PolymorphicTraits<T>::value> {};
 
 template <typename T, typename Context>
 struct validatedMappingTraits
@@ -815,6 +824,17 @@
     }
   }
 
+  template <typename FBT, typename T>
+  void enumFallbackWithOverridden(StringRef Overridden, T &Val) {
+    if (matchEnumFallback()) {
+      FBT Res = static_cast<typename FBT::BaseType>(Val);
+      StringRef Err = ScalarTraits<FBT>::input(Overridden, getContext(), Res);
+      if (!Err.empty())
+        setError(Err);
+      Val = static_cast<T>(static_cast<typename FBT::BaseType>(Res));
+    }
+  }
+
   template <typename T>
   void bitSetCase(T &Val, const char* Str, const T ConstVal) {
     if ( bitSetMatch(Str, outputting() && (Val & ConstVal) == ConstVal) ) {
@@ -953,6 +973,15 @@
 
 namespace detail {
 
+template <typename T, typename Context>
+void doEnumeration(IO &io, T &Val, Context &Ctx) {
+  ScalarEnumerationContextTraits<T, Context>::enumeration(io, Val, Ctx);
+}
+
+template <typename T> void doEnumeration(IO &io, T &Val, EmptyContext &) {
+  ScalarEnumerationTraits<T>::enumeration(io, Val);
+}
+
 template <typename T, typename Context>
 void doMapping(IO &io, T &Val, Context &Ctx) {
   MappingContextTraits<T, Context>::mapping(io, Val, Ctx);
@@ -964,11 +993,12 @@
 
 } // end namespace detail
 
-template <typename T>
-typename std::enable_if<has_ScalarEnumerationTraits<T>::value, void>::type
-yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
+template <typename T, typename Context = EmptyContext>
+typename std::enable_if<has_ScalarEnumerationTraits<T, Context>::value,
+                        void>::type
+yamlize(IO &io, T &Val, bool, Context &Ctx) {
   io.beginEnumScalar();
-  ScalarEnumerationTraits<T>::enumeration(io, Val);
+  detail::doEnumeration(io, Val, Ctx);
   io.endEnumScalar();
 }
 
@@ -1276,7 +1306,7 @@
     support::detail::packed_endian_specific_integral<value_type, endian,
                                                      alignment>,
     typename std::enable_if<
-        has_ScalarEnumerationTraits<value_type>::value>::type> {
+        has_ScalarEnumerationTraits<value_type, EmptyContext>::value>::type> {
   using endian_type =
       support::detail::packed_endian_specific_integral<value_type, endian,
                                                        alignment>;
diff --git a/llvm/lib/ObjectYAML/ELFYAML.cpp b/llvm/lib/ObjectYAML/ELFYAML.cpp
--- a/llvm/lib/ObjectYAML/ELFYAML.cpp
+++ b/llvm/lib/ObjectYAML/ELFYAML.cpp
@@ -59,9 +59,27 @@
   IO.enumFallback<Hex32>(Value);
 }
 
-void ScalarEnumerationTraits<ELFYAML::ELF_EM>::enumeration(
-    IO &IO, ELFYAML::ELF_EM &Value) {
-#define ECase(X) IO.enumCase(Value, #X, ELF::X)
+void ScalarEnumerationContextTraits<
+    ELFYAML::ELF_EM, ELFYAML::Object>::enumeration(IO &io,
+                                                   ELFYAML::ELF_EM &Value,
+                                                   ELFYAML::Object &Ctx) {
+  bool Output = io.outputting();
+  Optional<StringRef> OverriddenStr;
+  auto It = Ctx.Overridden.find("e_machine");
+  if (It != Ctx.Overridden.end() && !Output) {
+    OverriddenStr = It->second;
+    Ctx.SeenOverridden.insert("e_machine");
+  }
+
+#define ECase(X)                                                               \
+  if (!OverriddenStr)                                                          \
+    io.enumCase(Value, #X, ELF::X);                                            \
+  else if (*OverriddenStr == #X) {                                             \
+    Value = ELF::X;                                                            \
+    io.matchEnumFallback();                                                    \
+    return;                                                                    \
+  }
+
   ECase(EM_NONE);
   ECase(EM_M32);
   ECase(EM_SPARC);
@@ -222,7 +240,11 @@
   ECase(EM_LANAI);
   ECase(EM_BPF);
 #undef ECase
-  IO.enumFallback<Hex16>(Value);
+
+  if (!Output && OverriddenStr)
+    io.enumFallbackWithOverridden<Hex16>(*OverriddenStr, Value);
+  else
+    io.enumFallback<Hex16>(Value);
 }
 
 void ScalarEnumerationTraits<ELFYAML::ELF_ELFCLASS>::enumeration(
@@ -827,12 +849,13 @@
 
 void MappingTraits<ELFYAML::FileHeader>::mapping(IO &IO,
                                                  ELFYAML::FileHeader &FileHdr) {
+  auto &Ctx = *static_cast<ELFYAML::Object *>(IO.getContext());
   IO.mapRequired("Class", FileHdr.Class);
   IO.mapRequired("Data", FileHdr.Data);
   IO.mapOptional("OSABI", FileHdr.OSABI, ELFYAML::ELF_ELFOSABI(0));
   IO.mapOptional("ABIVersion", FileHdr.ABIVersion, Hex8(0));
   IO.mapRequired("Type", FileHdr.Type);
-  IO.mapRequired("Machine", FileHdr.Machine);
+  IO.mapRequired("Machine", FileHdr.Machine, Ctx);
   IO.mapOptional("Flags", FileHdr.Flags, ELFYAML::ELF_EF(0));
   IO.mapOptional("Entry", FileHdr.Entry, Hex64(0));
 
diff --git a/llvm/lib/ObjectYAML/ObjectYAML.cpp b/llvm/lib/ObjectYAML/ObjectYAML.cpp
--- a/llvm/lib/ObjectYAML/ObjectYAML.cpp
+++ b/llvm/lib/ObjectYAML/ObjectYAML.cpp
@@ -32,10 +32,15 @@
       MappingTraits<MachOYAML::UniversalBinary>::mapping(IO,
                                                          *ObjectFile.FatMachO);
   } else {
+    DenseMap<StringRef, StringRef> Overridden;
+    DenseSet<StringRef> SeenOverridden;
     Input &In = (Input &)IO;
     if (IO.mapTag("!ELF")) {
-      ObjectFile.Elf.reset(new ELFYAML::Object());
+      ObjectFile.Elf.reset(
+          new ELFYAML::Object(std::move(ObjectFile.Overridden)));
       MappingTraits<ELFYAML::Object>::mapping(IO, *ObjectFile.Elf);
+      Overridden = std::move(ObjectFile.Elf->Overridden);
+      SeenOverridden = std::move(ObjectFile.Elf->SeenOverridden);
     } else if (IO.mapTag("!COFF")) {
       ObjectFile.Coff.reset(new COFFYAML::Object());
       MappingTraits<COFFYAML::Object>::mapping(IO, *ObjectFile.Coff);
@@ -59,5 +64,11 @@
         IO.setError("YAML Object File unsupported document type tag '" +
                     N->getRawTag() + "'!");
     }
+
+    for (auto &It : Overridden)
+      if (!SeenOverridden.count(It.first)) {
+        IO.setError("'" + It.first + "' is overridden but not used");
+        break;
+      }
   }
 }
diff --git a/llvm/lib/ObjectYAML/yaml2obj.cpp b/llvm/lib/ObjectYAML/yaml2obj.cpp
--- a/llvm/lib/ObjectYAML/yaml2obj.cpp
+++ b/llvm/lib/ObjectYAML/yaml2obj.cpp
@@ -19,13 +19,23 @@
 namespace yaml {
 
 bool convertYAML(yaml::Input &YIn, raw_ostream &Out, ErrorHandler ErrHandler,
-                 unsigned DocNum) {
+                 unsigned DocNum, std::vector<std::string> Overridden) {
+  yaml::YamlObjectFile Doc;
+  for (StringRef O : Overridden) {
+    StringRef F, V;
+    std::tie(F, V) = O.split('=');
+    if (!O.count('=') || F.empty()) {
+      ErrHandler("bad override, missing field name: " + O);
+      return false;
+    }
+    Doc.Overridden.try_emplace(F, V);
+  }
+
   unsigned CurDocNum = 0;
   do {
     if (++CurDocNum != DocNum)
       continue;
 
-    yaml::YamlObjectFile Doc;
     YIn >> Doc;
     if (std::error_code EC = YIn.error()) {
       ErrHandler("failed to parse YAML input: " + EC.message());
diff --git a/llvm/test/tools/yaml2obj/ELF/emachine.yaml b/llvm/test/tools/yaml2obj/ELF/emachine.yaml
--- a/llvm/test/tools/yaml2obj/ELF/emachine.yaml
+++ b/llvm/test/tools/yaml2obj/ELF/emachine.yaml
@@ -53,3 +53,21 @@
   Data:    ELFDATA2MSB
   Type:    ET_REL
   Machine: EM_UNKNOWN_FOO
+
+## Test we can override e_machine with -D.
+
+# RUN: yaml2obj --docnum=1 -D e_machine=0x4321 %s -o %t1.4321
+# RUN: llvm-readobj --file-headers %t1.4321 | FileCheck %s --check-prefix=4321
+
+# 4321: Machine: 0x4321
+
+# RUN: yaml2obj --docnum=1 -D e_machine=EM_386 %s -o %t1.386
+# RUN: llvm-readobj --file-headers %t1.386 | FileCheck %s --check-prefix=386
+
+# 386: Machine: EM_386
+
+## TODO Report that the overridden value is invalid.
+# RUN: not yaml2obj --docnum=1 -D e_machine=invalid %s -o /dev/null 2>&1 | FileCheck --check-prefix=INVALID %s
+
+# INVALID: error: invalid hex16 number
+# INVALID-NEXT: Machine: 0x1234
diff --git a/llvm/test/tools/yaml2obj/ELF/unused-overridden.yaml b/llvm/test/tools/yaml2obj/ELF/unused-overridden.yaml
new file mode 100644
--- /dev/null
+++ b/llvm/test/tools/yaml2obj/ELF/unused-overridden.yaml
@@ -0,0 +1,11 @@
+## Test that an unused -D option emits a diagnostic.
+
+# RUN: not yaml2obj -D unused=1 %s -o /dev/null 2>&1 | FileCheck %s
+# CHECK: error: 'unused' is overridden but not used
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS32
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_386
diff --git a/llvm/test/tools/yaml2obj/invalid-override.yaml b/llvm/test/tools/yaml2obj/invalid-override.yaml
new file mode 100644
--- /dev/null
+++ b/llvm/test/tools/yaml2obj/invalid-override.yaml
@@ -0,0 +1,5 @@
+# RUN: not yaml2obj -D field %s 2>&1 | FileCheck --check-prefix=ERR1 %s
+# ERR1: error: bad override, missing field name: field
+
+# RUN: not yaml2obj -D =value %s 2>&1 | FileCheck --check-prefix=ERR2 %s
+# ERR2: error: bad override, missing field name: =value
diff --git a/llvm/tools/obj2yaml/elf2yaml.cpp b/llvm/tools/obj2yaml/elf2yaml.cpp
--- a/llvm/tools/obj2yaml/elf2yaml.cpp
+++ b/llvm/tools/obj2yaml/elf2yaml.cpp
@@ -155,7 +155,7 @@
 }
 
 template <class ELFT> Expected<ELFYAML::Object *> ELFDumper<ELFT>::dump() {
-  auto Y = std::make_unique<ELFYAML::Object>();
+  auto Y = std::make_unique<ELFYAML::Object>(DenseMap<StringRef, StringRef>());
 
   // Dump header. We do not dump SHEntSize, SHOff, SHNum and SHStrNdx fields.
   // When not explicitly set, the values are set by yaml2obj automatically
diff --git a/llvm/tools/yaml2obj/yaml2obj.cpp b/llvm/tools/yaml2obj/yaml2obj.cpp
--- a/llvm/tools/yaml2obj/yaml2obj.cpp
+++ b/llvm/tools/yaml2obj/yaml2obj.cpp
@@ -31,6 +31,9 @@
 static cl::opt<std::string>
   Input(cl::Positional, cl::desc("<input>"), cl::init("-"));
 
+static cl::list<std::string>
+    D("D", cl::desc("list of overridden fields: field=value"));
+
 static cl::opt<unsigned>
     DocNum("docnum", cl::init(1),
            cl::desc("Read specified document from input (default = 1)"));
@@ -63,7 +66,7 @@
     return 1;
 
   yaml::Input YIn(Buf.get()->getBuffer());
-  if (!convertYAML(YIn, Out->os(), ErrHandler, DocNum))
+  if (!convertYAML(YIn, Out->os(), ErrHandler, DocNum, D))
     return 1;
 
   Out->keep();