diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td
--- a/clang/include/clang/Driver/Options.td
+++ b/clang/include/clang/Driver/Options.td
@@ -249,6 +249,13 @@
                MarshallingInfoFlag<keypath, "false">;
 }
 
+multiclass BooleanMarshalledFFlag<string name, code keypath, code default_value, string pos_help = "", string neg_help=""> {
+  def f#NAME : Flag<["-"], "f"#name>, HelpText<pos_help>,
+    MarshallingInfoBooleanTrueFlag<keypath, default_value, "fno_"#NAME>;
+  def fno_#NAME : Flag<["-"], "fno-"#name>, HelpText<neg_help>,
+    MarshallingInfoBooleanFalseFlag<keypath, default_value, "f"#NAME>;
+}
+
 /////////
 // Options
 
@@ -1257,9 +1264,9 @@
   HelpText<"Enables the global instruction selector">;
 def fexperimental_isel : Flag<["-"], "fexperimental-isel">, Group<f_clang_Group>,
   Alias<fglobal_isel>;
-def fexperimental_new_pass_manager : Flag<["-"], "fexperimental-new-pass-manager">,
-  Group<f_clang_Group>, Flags<[CC1Option]>,
-  HelpText<"Enables an experimental new pass manager in LLVM.">;
+defm experimental_new_pass_manager : BooleanMarshalledFFlag<"experimental-new-pass-manager", "CodeGenOpts.ExperimentalNewPassManager",
+  "static_cast<unsigned>(ENABLE_EXPERIMENTAL_NEW_PASS_MANAGER)", "Enables an experimental new pass manager in LLVM.",
+  "Disables an experimental new pass manager in LLVM.">, Group<f_clang_Group>, Flags<[CC1Option]>;
 def finput_charset_EQ : Joined<["-"], "finput-charset=">, Group<f_Group>;
 def fexec_charset_EQ : Joined<["-"], "fexec-charset=">, Group<f_Group>;
 def finstrument_functions : Flag<["-"], "finstrument-functions">, Group<f_Group>, Flags<[CC1Option]>,
@@ -1537,9 +1544,6 @@
   HelpText<"Disables the global instruction selector">;
 def fno_experimental_isel : Flag<["-"], "fno-experimental-isel">, Group<f_clang_Group>,
   Alias<fno_global_isel>;
-def fno_experimental_new_pass_manager : Flag<["-"], "fno-experimental-new-pass-manager">,
-  Group<f_clang_Group>, Flags<[CC1Option]>,
-  HelpText<"Disables an experimental new pass manager in LLVM.">;
 def fveclib : Joined<["-"], "fveclib=">, Group<f_Group>, Flags<[CC1Option]>,
     HelpText<"Use the given vector functions library">, Values<"Accelerate,MASSV,SVML,none">;
 def fno_lax_vector_conversions : Flag<["-"], "fno-lax-vector-conversions">, Group<f_Group>,
diff --git a/clang/lib/Frontend/CompilerInvocation.cpp b/clang/lib/Frontend/CompilerInvocation.cpp
--- a/clang/lib/Frontend/CompilerInvocation.cpp
+++ b/clang/lib/Frontend/CompilerInvocation.cpp
@@ -138,6 +138,13 @@
   return !Args.hasArg(Opt);
 }
 
+void denormalizeSimpleFlag(SmallVectorImpl<const char *> &Args,
+                           const char *Spelling,
+                           CompilerInvocation::StringAllocator SA,
+                           unsigned TableIndex, unsigned Value) {
+  Args.push_back(Spelling);
+}
+
 template <typename T, T Value>
 static llvm::Optional<T>
 normalizeFlagToValue(OptSpecifier Opt, unsigned TableIndex, const ArgList &Args,
@@ -147,6 +154,33 @@
   return None;
 }
 
+template <unsigned NegOpt>
+static Optional<bool>
+normalizeBooleanTrueFlag(OptSpecifier PosOpt, unsigned TableIndex,
+                         const ArgList &Args, DiagnosticsEngine &Diags) {
+  if (!Args.hasArg(PosOpt, NegOpt))
+    return None;
+  return Args.hasFlag(PosOpt, NegOpt);
+}
+
+template <unsigned PosOpt>
+static Optional<bool>
+normalizeBooleanFalseFlag(OptSpecifier NegOpt, unsigned TableIndex,
+                          const ArgList &Args, DiagnosticsEngine &Diags) {
+  if (!Args.hasArg(PosOpt, NegOpt))
+    return None;
+  return Args.hasFlag(PosOpt, NegOpt);
+}
+
+template <bool IsPositive>
+static void denormalizeBooleanFlag(SmallVectorImpl<const char *> &Args,
+                                   const char *Spelling,
+                                   CompilerInvocation::StringAllocator SA,
+                                   unsigned TableIndex, unsigned Value) {
+  if (Value == IsPositive)
+    Args.push_back(Spelling);
+}
+
 static llvm::Optional<unsigned> normalizeSimpleEnum(OptSpecifier Opt,
                                                     unsigned TableIndex,
                                                     const ArgList &Args,
@@ -169,12 +203,14 @@
 }
 
 static void denormalizeSimpleEnum(SmallVectorImpl<const char *> &Args,
+                                  const char *Spelling,
                                   CompilerInvocation::StringAllocator SA,
                                   unsigned TableIndex, unsigned Value) {
   assert(TableIndex < SimpleEnumValueTablesSize);
   const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex];
   for (int I = 0, E = Table.Size; I != E; ++I) {
     if (Value == Table.Table[I].Value) {
+      Args.push_back(Spelling);
       Args.push_back(Table.Table[I].Name);
       return;
     }
@@ -185,8 +221,10 @@
 }
 
 static void denormalizeString(SmallVectorImpl<const char *> &Args,
+                              const char *Spelling,
                               CompilerInvocation::StringAllocator SA,
                               unsigned TableIndex, const std::string &Value) {
+  Args.push_back(Spelling);
   Args.push_back(SA(Value));
 }
 
@@ -782,10 +820,6 @@
     }
   }
 
-  Opts.ExperimentalNewPassManager = Args.hasFlag(
-      OPT_fexperimental_new_pass_manager, OPT_fno_experimental_new_pass_manager,
-      /* Default */ ENABLE_EXPERIMENTAL_NEW_PASS_MANAGER);
-
   Opts.DebugPassManager =
       Args.hasFlag(OPT_fdebug_pass_manager, OPT_fno_debug_pass_manager,
                    /* Default */ false);
@@ -3895,13 +3929,7 @@
     TYPE, NORMALIZER, DENORMALIZER, MERGER, EXTRACTOR, TABLE_INDEX)            \
   if (((FLAGS)&options::CC1Option) &&                                          \
       (ALWAYS_EMIT || EXTRACTOR(this->KEYPATH) != DEFAULT_VALUE)) {            \
-    if (Option::KIND##Class == Option::FlagClass) {                            \
-      Args.push_back(SPELLING);                                                \
-    }                                                                          \
-    if (Option::KIND##Class == Option::SeparateClass) {                        \
-      Args.push_back(SPELLING);                                                \
-      DENORMALIZER(Args, SA, TABLE_INDEX, EXTRACTOR(this->KEYPATH));           \
-    }                                                                          \
+    DENORMALIZER(Args, SPELLING, SA, TABLE_INDEX, EXTRACTOR(this->KEYPATH));   \
   }
 
 #include "clang/Driver/Options.inc"
diff --git a/llvm/include/llvm/Option/OptParser.td b/llvm/include/llvm/Option/OptParser.td
--- a/llvm/include/llvm/Option/OptParser.td
+++ b/llvm/include/llvm/Option/OptParser.td
@@ -156,6 +156,7 @@
   : MarshallingInfo<keypath, defaultvalue> {
   code NormalizerRetTy = ty;
   code Normalizer = "normalizeSimpleFlag";
+  code Denormalizer = "denormalizeSimpleFlag";
 }
 
 class MarshallingInfoBitfieldFlag<code keypath, code value> : MarshallingInfoFlag<keypath, "0u", "unsigned"> {
@@ -164,6 +165,20 @@
   code ValueExtractor = "(extractMaskValue<unsigned, decltype("#value#"), "#value#">)";
 }
 
+class MarshallingInfoBooleanTrueFlag<code keypath, code defaultvalue, string neg_name>
+  : MarshallingInfoFlag<keypath, defaultvalue> {
+  bit ShouldAlwaysEmit = 1;
+  code Normalizer ="normalizeBooleanTrueFlag<OPT_"#neg_name#">";
+  code Denormalizer = "denormalizeBooleanFlag<true>";
+}
+
+class MarshallingInfoBooleanFalseFlag<code keypath, code defaultvalue, string pos_name>
+  : MarshallingInfoFlag<keypath, defaultvalue> {
+  bit ShouldAlwaysEmit = 1;
+  code Normalizer ="normalizeBooleanFalseFlag<OPT_"#pos_name#">";
+  code Denormalizer = "denormalizeBooleanFlag<false>";
+}
+
 // Mixins for additional marshalling attributes.
 
 class IsNegative {