Add support for options with two flags for controlling the same field.

[jansvoboda11]

Summary

This enables automatically parsing and generating CC1 arguments for options where two flags control the same field, e.g. -fexperimental-new-pass-manager and -fno-experimental new pass manager.

[dexonsmith]

clang/lib/Frontend/CompilerInvocation.cpp

150

I'm not sure if removing the llvm:: namespace is intentional here, but if so please do it in a separate NFC patch to avoid adding noise in this one.

185–187

This should be:

if (Arg *A = Args.getLastArg(PosOpt, NegOpt))
  return A->getOption().matches(PosOpt);
return None;

Note that hasArg and hasFlag both resolve to getLastArg, so calling them one after another would be unfortunate.

... but I'm not even sure where NegOpt is coming from here, that looks like it hasn't been passed in. I think you need to change the signature to something like this:

static llvm::Optional<bool>
normalizeSimpleFlag(OptSpecifier Opt,
                    Optional<OptSpecifier> NegOpt,
                    unsigned TableIndex,
                    const ArgList &Args,
                    DiagnosticsEngine &Diags) {
  // Handle case without a `no-*` flag.
  if (!NegOpt)
    return Args.hasArg(Opt);

  // Handle case with a `no-*` flag.
  return Args.hasFlagAsOptional(Opt, *NegOpt);
}

It's possible you'll need to split up OPTION_WITH_MARSHALLING into two disjoint lists of options:

• The list of options that can't be negated.
• The list of options that can be negated, calling a different macro that adds macro arguments for the CANCEL_ID and CANCEL_SPELLING. For the denormalizer you might also need CANCEL_VALUE.
• Note: the negating options themselves wouldn't be visited in either list.
• Note: the (de)normalizer APIs would ideally work naturally for something like -farg=val1 vs. -farg=val2 vs. -fno-arg.

3938–3950

I realize this commit doesn't introduce it, but it seems unfortunate to call EXTRACTOR twice. Maybe in a follow-up or prep commit you can fix that... maybe something like this?

if ((FLAGS)&options::CC1Option) {
  const auto &Extracted = EXTRACTOR(this->KEYPATH);
  if (ALWAYS_EMIT || Extracted != DEFAULT_VALUE)
    DENORMALIZER(Args, SPELLING, SA, TABLE_INDEX, EXTRACTOR(this->KEYPATH));
}

llvm/include/llvm/Option/OptParser.td

175

Nit: missing a space in ... Normalizer ="norma...; same typo repeats below.

[dang]

Revert accidental namespace removal.

[dang]

clang/lib/Frontend/CompilerInvocation.cpp

150

Yes it was accidental sorry about that.

185–187

NegOpt is passed in via the template parameter, the only weird bit about it is that the option name (for example OPT_fno_experimental_pass_manager) is constructed in tablegen by hardcoding the OPT_ prefix. What is currently there supports the case where the positive option takes a value and the negative one doesn't by using different normalizer/denormalizer pairs for the positive and the negative option. The bad thing about the current setup is that both options have identical normalizers, but I felt that was less bad than splitting the list of options and using different macros.

3938–3950

Yes I can do that of course. Although EXTRACTOR is meant to be very cheap and in most cases it expands to just this->KEYPATH

[dang]

Address some code review feedback.

[dang]

clang/lib/Frontend/CompilerInvocation.cpp

3938–3950

See D83211

[dang]

Make mergers use values directly instead of constant references

[dang]

Rebase on top of some changes to parent patches.

[dang]

Split into two macro kinds.

[dang]

Update with latest changes

[Bigcheese]

lgtm

[jansvoboda11]

Taking control of this revision, as Daniel is no longer involved.

[jansvoboda11]

Rebase on top of recent changes.

[jansvoboda11]

Apply unique_ptr workaround for older Clang versions

clang/include/clang/Driver/Options.td

multiclass OptOutFFlag<string name, string pos_prefix, string neg_prefix,
                        string help="", list<OptionFlag> flags=[], code keypath=""> {
   def f#NAME : Flag<["-"], "f"#name>, Flags<flags>,
                Group<f_Group>, HelpText<!strconcat(pos_prefix, help)>;
   def fno_#NAME : Flag<["-"], "fno-"#name>, Flags<!listconcat([CC1Option], flags)>,
                Group<f_Group>, HelpText<!strconcat(neg_prefix, help)>,
                MarshallingInfoFlag<keypath, "false">;
 }
 
+multiclass BooleanMarshalledFFlag<string name, code keypath, code default_value, string pos_help = "", string neg_help=""> {
+  def fno_#NAME : Flag<["-"], "fno-"#name>, HelpText<neg_help>;
+  def f#NAME : Flag<["-"], "f"#name>, HelpText<pos_help>,
+    MarshallingInfoBooleanFlag<keypath, default_value, !cast<Option>("fno_"#NAME)>;
+}
+
 /////////
 // Options
 
 // The internal option ID must be a valid C++ identifier and results in a
 // clang::driver::options::OPT_XX enum constant for XX.
 //
 // We want to unambiguously be able to refer to options from the driver source
 // code, for this reason the option name is mangled into an ID. This mangling
def finline_functions : Flag<["-"], "finline-functions">, Group<f_clang_Group>, Flags<[CC1Option]>,
   HelpText<"Inline suitable functions">;
 def finline_hint_functions: Flag<["-"], "finline-hint-functions">, Group<f_clang_Group>, Flags<[CC1Option]>,
   HelpText<"Inline functions which are (explicitly or implicitly) marked inline">;
 def finline : Flag<["-"], "finline">, Group<clang_ignored_f_Group>;
 def fglobal_isel : Flag<["-"], "fglobal-isel">, Group<f_clang_Group>, 
   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]>,
   HelpText<"Generate calls to instrument function entry and exit">;
 def finstrument_functions_after_inlining : Flag<["-"], "finstrument-functions-after-inlining">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Like -finstrument-functions, but insert the calls after inlining">;
 def finstrument_function_entry_bare : Flag<["-"], "finstrument-function-entry-bare">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Instrument function entry only, after inlining, without arguments to the instrumentation call">;

 def fno_eliminate_unused_debug_symbols : Flag<["-"], "fno-eliminate-unused-debug-symbols">, Group<f_Group>;
 def fno_gnu_keywords : Flag<["-"], "fno-gnu-keywords">, Group<f_Group>, Flags<[CC1Option]>;
 def fno_inline_functions : Flag<["-"], "fno-inline-functions">, Group<f_clang_Group>, Flags<[CC1Option]>;
 def fno_inline : Flag<["-"], "fno-inline">, Group<f_clang_Group>, Flags<[CC1Option]>;
 def fno_global_isel : Flag<["-"], "fno-global-isel">, Group<f_clang_Group>,
   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>,
   Alias<flax_vector_conversions_EQ>, AliasArgs<["none"]>;
 def fno_merge_all_constants : Flag<["-"], "fno-merge-all-constants">, Group<f_Group>,
   HelpText<"Disallow merging of constants">;
 def fno_modules : Flag <["-"], "fno-modules">, Group<f_Group>,
   Flags<[DriverOption]>;

clang/lib/Frontend/CompilerInvocation.cpp

 }
 
 static llvm::Optional<bool>
 normalizeSimpleNegativeFlag(OptSpecifier Opt, unsigned TableIndex,
                             const ArgList &Args, DiagnosticsEngine &Diags) {
   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,
                      DiagnosticsEngine &Diags) {
   if (Args.hasArg(Opt))
     return Value;
   return None;
 }
 
+static Optional<bool> normalizeBooleanFlag(OptSpecifier PosOpt,
+                                           OptSpecifier NegOpt,
+                                           unsigned TableIndex,
+                                           const ArgList &Args,
+                                           DiagnosticsEngine &Diags) {
+  if (const Arg *A = Args.getLastArg(PosOpt, NegOpt))
+    return A->getOption().matches(PosOpt);
+  return None;
+}
+
+static void denormalizeBooleanFlag(SmallVectorImpl<const char *> &Args,
+                                   const char *Spelling,
+                                   const char *NegSpelling,
+                                   CompilerInvocation::StringAllocator SA,
+                                   unsigned TableIndex, unsigned Value) {
+  if (Value)
+    Args.push_back(Spelling);
+  else
+    Args.push_back(NegSpelling);
+}
+
 static llvm::Optional<unsigned> normalizeSimpleEnum(OptSpecifier Opt,
                                                     unsigned TableIndex,
                                                     const ArgList &Args,
                                                     DiagnosticsEngine &Diags) {
   assert(TableIndex < SimpleEnumValueTablesSize);
   const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex];
 
   auto *Arg = Args.getLastArg(Opt);
   if (!Arg)
     return None;
 
   StringRef ArgValue = Arg->getValue();
   for (int I = 0, E = Table.Size; I != E; ++I)
     if (ArgValue == Table.Table[I].Name)
       return Table.Table[I].Value;
 
   Diags.Report(diag::err_drv_invalid_value)
       << Arg->getAsString(Args) << ArgValue;
   return None;
 }
 
 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;
     }
   }
 
   llvm_unreachable("The simple enum value was not correctly defined in "
                    "the tablegen option description");
 }
 
 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));
 }
 
 static Optional<std::string> normalizeTriple(OptSpecifier Opt, int TableIndex,
                                              const ArgList &Args,
                                              DiagnosticsEngine &Diags) {
   auto *Arg = Args.getLastArg(Opt);
   if (!Arg)
if (Opts.OptimizationLevel > 0) {
         Opts.setInlining(CodeGenOptions::NormalInlining);
       else if (InlineOpt.matches(options::OPT_finline_hint_functions))
         Opts.setInlining(CodeGenOptions::OnlyHintInlining);
       else
         Opts.setInlining(CodeGenOptions::OnlyAlwaysInlining);
     }
   }
 
-  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);
 
   if (Arg *A = Args.getLastArg(OPT_fveclib)) {
     StringRef Name = A->getValue();
     if (Name == "Accelerate")
       Opts.setVecLib(CodeGenOptions::Accelerate);
#define OPTION_WITH_MARSHALLING(                                               \
     TYPE, NORMALIZER, DENORMALIZER, MERGER, EXTRACTOR, TABLE_INDEX)            \
   {                                                                            \
     if (auto MaybeValue = NORMALIZER(OPT_##ID, TABLE_INDEX, Args, Diags))      \
       this->KEYPATH = MERGER(this->KEYPATH, static_cast<TYPE>(*MaybeValue));   \
     else                                                                       \
       this->KEYPATH = MERGER(this->KEYPATH, DEFAULT_VALUE);                    \
   }
 
+#define OPTION_WITH_MARSHALLING_BOOLEAN(                                       \
+    PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
+    HELPTEXT, METAVAR, VALUES, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE,  \
+    TYPE, NORMALIZER, DENORMALIZER, MERGER, EXTRACTOR, TABLE_INDEX, NEG_ID,    \
+    NEG_SPELLING)                                                              \
+  {                                                                            \
+    if (auto MaybeValue =                                                      \
+            NORMALIZER(OPT_##ID, OPT_##NEG_ID, TABLE_INDEX, Args, Diags))      \
+      this->KEYPATH = MERGER(this->KEYPATH, static_cast<TYPE>(*MaybeValue));   \
+    else                                                                       \
+      this->KEYPATH = MERGER(this->KEYPATH, DEFAULT_VALUE);                    \
+  }
+
 #include "clang/Driver/Options.inc"
+#undef OPTION_WITH_MARSHALLING_BOOLEAN
 #undef OPTION_WITH_MARSHALLING
   return true;
 }
 
 bool CompilerInvocation::CreateFromArgs(CompilerInvocation &Res,
                                         ArrayRef<const char *> CommandLineArgs,
                                         DiagnosticsEngine &Diags,
                                         const char *Argv0) {

 
 void CompilerInvocation::generateCC1CommandLine(
     SmallVectorImpl<const char *> &Args, StringAllocator SA) const {
 #define OPTION_WITH_MARSHALLING(                                               \
     PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
     HELPTEXT, METAVAR, VALUES, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE,  \
     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));   \
+  }
+
+#define OPTION_WITH_MARSHALLING_BOOLEAN(                                       \
+    PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
+    HELPTEXT, METAVAR, VALUES, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE,  \
+    TYPE, NORMALIZER, DENORMALIZER, MERGER, EXTRACTOR, TABLE_INDEX, NEG_ID,    \
+    NEG_SPELLING)                                                              \
+  if (((FLAGS)&options::CC1Option) &&                                          \
+      (ALWAYS_EMIT || EXTRACTOR(this->KEYPATH) != DEFAULT_VALUE)) {            \
+    DENORMALIZER(Args, SPELLING, NEG_SPELLING, SA, TABLE_INDEX,                \
+                 EXTRACTOR(this->KEYPATH));                                    \
   }
 
 #include "clang/Driver/Options.inc"
+#undef OPTION_WITH_MARSHALLING_BOOLEAN
 #undef OPTION_WITH_MARSHALLING
 }
 
 namespace clang {
 
 IntrusiveRefCntPtr<llvm::vfs::FileSystem>
 createVFSFromCompilerInvocation(const CompilerInvocation &CI,
                                 DiagnosticsEngine &Diags) {

llvm/include/llvm/Option/OptParser.td

class Option<list<string> prefixes, string name, OptionKind kind> {
   string HelpText = ?;
   string MetaVarName = ?;
   string Values = ?;
   code ValuesCode = ?;
   list<OptionFlag> Flags = [];
   OptionGroup Group = ?;
   Option Alias = ?;
   list<string> AliasArgs = [];
+  string MarshallingInfoKind = ?;
   code KeyPath = ?;
   code DefaultValue = ?;
   bit ShouldAlwaysEmit = 0;
   code NormalizerRetTy = ?;
   code NormalizedValuesScope = "";
   code Normalizer = "";
   code Denormalizer = "";
   code ValueMerger = "mergeForwardValue";
   code ValueExtractor = "extractForwardValue";
   list<code> NormalizedValues = ?;
+  // Used for BooleanFlagKind
+  Option NegOption = ?;
 }
 
 // Helpers for defining options.
 
 class Flag<list<string> prefixes, string name>
   : Option<prefixes, name, KIND_FLAG>;
 class Joined<list<string> prefixes, string name>
   : Option<prefixes, name, KIND_JOINED>;

 class HelpText<string text> { string HelpText = text; }
 class MetaVarName<string name> { string MetaVarName = name; }
 class Values<string value> { string Values = value; }
 class ValuesCode<code valuecode> { code ValuesCode = valuecode; }
 
 // Helpers for defining marshalling information.
 
 class MarshallingInfo<code keypath, code defaultvalue> {
+  string MarshallingInfoKind = "Default";
   code KeyPath = keypath;
   code DefaultValue = defaultvalue;
 }
 
 class MarshallingInfoString<code keypath, code defaultvalue, code normalizerretty>
   : MarshallingInfo<keypath, defaultvalue> {
   code NormalizerRetTy = normalizerretty;
 }
 
 class MarshallingInfoFlag<code keypath, code defaultvalue, code ty="unsigned">
   : MarshallingInfo<keypath, defaultvalue> {
   code NormalizerRetTy = ty;
   code Normalizer = "normalizeSimpleFlag";
+  code Denormalizer = "denormalizeSimpleFlag";
 }
 
 class MarshallingInfoBitfieldFlag<code keypath, code value> : MarshallingInfoFlag<keypath, "0u", "unsigned"> {
   code Normalizer = "(normalizeFlagToValue<unsigned, "#value#">)";
   code ValueMerger = "mergeMaskValue";
   code ValueExtractor = "(extractMaskValue<unsigned, decltype("#value#"), "#value#">)";
 }
 
+class MarshallingInfoBooleanFlag<code keypath, code defaultvalue, Option negopt>
+  : MarshallingInfoFlag<keypath, defaultvalue> {
+  bit ShouldAlwaysEmit = 1;
+  string MarshallingInfoKind = "BooleanFlag";
+  code Normalizer = "normalizeBooleanFlag";
+  code Denormalizer = "denormalizeBooleanFlag";
+  Option NegOption = negopt;
+}
+
 // Mixins for additional marshalling attributes.
 
 class IsNegative {
   code Normalizer = "normalizeSimpleNegativeFlag";
 }
 class AlwaysEmit { bit ShouldAlwaysEmit = 1; }
 class Normalizer<code normalizer> { code Normalizer = normalizer; }
 class Denormalizer<code denormalizer> { code Denormalizer = denormalizer; }

llvm/utils/TableGen/OptParserEmitter.cpp

static void emitNameUsingSpelling(raw_ostream &OS, const Record &R) {
   size_t PrefixLength;
   OS << "&";
   write_cstring(OS, StringRef(getOptionSpelling(R, PrefixLength)));
   OS << "[" << PrefixLength << "]";
 }
 
 class MarshallingInfo {
 public:
-  static constexpr const char *MacroName = "OPTION_WITH_MARSHALLING";
+  using Ptr = std::unique_ptr<MarshallingInfo>;
 
+  const char *MacroName;
   const Record &R;
   bool ShouldAlwaysEmit;
   StringRef KeyPath;
   StringRef DefaultValue;
   StringRef NormalizedValuesScope;
   StringRef NormalizerRetTy;
   StringRef Normalizer;
   StringRef Denormalizer;
   StringRef ValueMerger;
   StringRef ValueExtractor;
   int TableIndex = -1;
   std::vector<StringRef> Values;
   std::vector<StringRef> NormalizedValues;
   std::string ValueTableName;
 
+  static size_t NextTableIndex;
+
   static constexpr const char *ValueTablePreamble = R"(
 struct SimpleEnumValue {
   const char *Name;
   unsigned Value;
 };
 
 struct SimpleEnumValueTable {
   const SimpleEnumValue *Table;
   unsigned Size;
 };
 )";
 
   static constexpr const char *ValueTablesDecl =
       "static const SimpleEnumValueTable SimpleEnumValueTables[] = ";
 
-  void emit(raw_ostream &OS) const {
+  MarshallingInfo(const Record &R)
+      : MacroName("OPTION_WITH_MARSHALLING"), R(R) {}
+  MarshallingInfo(const char *MacroName, const Record &R)
+      : MacroName(MacroName), R(R){};
+
+  virtual ~MarshallingInfo() = default;
+
+  virtual void emit(raw_ostream &OS) const {
     write_cstring(OS, StringRef(getOptionSpelling(R)));
     OS << ", ";
     OS << ShouldAlwaysEmit;
     OS << ", ";
     OS << KeyPath;
     OS << ", ";
     emitScopedNormalizedValue(OS, DefaultValue);
     OS << ", ";
for (unsigned I = 0, E = Values.size(); I != E; ++I) {
       OS << "static_cast<unsigned>(";
       emitScopedNormalizedValue(OS, NormalizedValues[I]);
       OS << ")},";
     }
     OS << "};\n";
     return StringRef(ValueTableName);
   }
 
-  static MarshallingInfo create(const Record &R) {
-    assert(!isa<UnsetInit>(R.getValueInit("KeyPath")) &&
-           !isa<UnsetInit>(R.getValueInit("DefaultValue")) &&
-           !isa<UnsetInit>(R.getValueInit("NormalizerRetTy")) &&
-           !isa<UnsetInit>(R.getValueInit("ValueMerger")) &&
-           "MarshallingInfo must have a type");
+private:
+  void emitScopedNormalizedValue(raw_ostream &OS,
+                                 StringRef NormalizedValue) const {
+    if (!NormalizedValuesScope.empty())
+      OS << NormalizedValuesScope << "::";
+    OS << NormalizedValue;
+  }
+};
+
+size_t MarshallingInfo::NextTableIndex = 0;
+
+class MarshallingInfoBooleanFlag : public MarshallingInfo {
+public:
+  const Record &NegOption;
+
+  MarshallingInfoBooleanFlag(const Record &Option, const Record &NegOption)
+      : MarshallingInfo("OPTION_WITH_MARSHALLING_BOOLEAN", Option),
+        NegOption(NegOption) {}
+
+  void emit(raw_ostream &OS) const override {
+    MarshallingInfo::emit(OS);
+    OS << ", ";
+    OS << getOptionName(NegOption);
+    OS << ", ";
+    write_cstring(OS, getOptionSpelling(NegOption));
+  }
+};
+
+static MarshallingInfo::Ptr createMarshallingInfo(const Record &R) {
 
-    MarshallingInfo Ret(R);
-    Ret.ShouldAlwaysEmit = R.getValueAsBit("ShouldAlwaysEmit");
-    Ret.KeyPath = R.getValueAsString("KeyPath");
-    Ret.DefaultValue = R.getValueAsString("DefaultValue");
-    Ret.NormalizedValuesScope = R.getValueAsString("NormalizedValuesScope");
-    Ret.NormalizerRetTy = R.getValueAsString("NormalizerRetTy");
-
-    Ret.Normalizer = R.getValueAsString("Normalizer");
-    Ret.Denormalizer = R.getValueAsString("Denormalizer");
-    Ret.ValueMerger = R.getValueAsString("ValueMerger");
-    Ret.ValueExtractor = R.getValueAsString("ValueExtractor");
+  MarshallingInfo::Ptr Ret;
+  if (Record *MaybeNegOption = R.getValueAsOptionalDef("NegOption")) {
+    Ret = std::make_unique<MarshallingInfoBooleanFlag>(R, *MaybeNegOption);
+  } else {
+    Ret = std::make_unique<MarshallingInfo>(R);
+  }
+
+  Ret->ShouldAlwaysEmit = R.getValueAsBit("ShouldAlwaysEmit");
+  Ret->KeyPath = R.getValueAsString("KeyPath");
+  Ret->DefaultValue = R.getValueAsString("DefaultValue");
+  Ret->NormalizedValuesScope = R.getValueAsString("NormalizedValuesScope");
+  Ret->NormalizerRetTy = R.getValueAsString("NormalizerRetTy");
+
+  Ret->Normalizer = R.getValueAsString("Normalizer");
+  Ret->Denormalizer = R.getValueAsString("Denormalizer");
+  Ret->ValueMerger = R.getValueAsString("ValueMerger");
+  Ret->ValueExtractor = R.getValueAsString("ValueExtractor");
 
-    if (!isa<UnsetInit>(R.getValueInit("NormalizedValues"))) {
-      assert(!isa<UnsetInit>(R.getValueInit("Values")) &&
-             "Cannot provide normalized values for value-less options");
-      Ret.TableIndex = NextTableIndex++;
-      Ret.NormalizedValues = R.getValueAsListOfStrings("NormalizedValues");
-      Ret.Values.reserve(Ret.NormalizedValues.size());
-      Ret.ValueTableName = getOptionName(R) + "ValueTable";
+    Ret->TableIndex = MarshallingInfo::NextTableIndex++;
+    Ret->NormalizedValues = R.getValueAsListOfStrings("NormalizedValues");
+    Ret->Values.reserve(Ret->NormalizedValues.size());
+    Ret->ValueTableName = getOptionName(R) + "ValueTable";
 
-      StringRef ValuesStr = R.getValueAsString("Values");
-      for (;;) {
-        size_t Idx = ValuesStr.find(',');
-        if (Idx == StringRef::npos)
-          break;
-        if (Idx > 0)
-          Ret.Values.push_back(ValuesStr.slice(0, Idx));
-        ValuesStr = ValuesStr.slice(Idx + 1, StringRef::npos);
-      }
-      if (!ValuesStr.empty())
-        Ret.Values.push_back(ValuesStr);
+        Ret->Values.push_back(ValuesStr.slice(0, Idx));
+      Ret->Values.push_back(ValuesStr);
 
-      assert(Ret.Values.size() == Ret.NormalizedValues.size() &&
-             "The number of normalized values doesn't match the number of "
-             "values");
-    }
+    assert(Ret->Values.size() == Ret->NormalizedValues.size() &&
 
-    return Ret;
-  }
 
-private:
-  void emitScopedNormalizedValue(raw_ostream &OS,
-                                 StringRef NormalizedValue) const {
-    if (!NormalizedValuesScope.empty())
-      OS << NormalizedValuesScope << "::";
-    OS << NormalizedValue;
-  }
-
-  MarshallingInfo(const Record &R) : R(R){};
-
-  static size_t NextTableIndex;
-};
-
-size_t MarshallingInfo::NextTableIndex = 0;
-
 /// OptParserEmitter - This tablegen backend takes an input .td file
 /// describing a list of options and emits a data structure for parsing and
 /// working with those options when given an input command line.
 namespace llvm {
 void EmitOptParser(RecordKeeper &Records, raw_ostream &OS) {
   // Get the option groups and options.
   const std::vector<Record*> &Groups =
     Records.getAllDerivedDefinitions("OptionGroup");
auto WriteOptRecordFields = [&](raw_ostream &OS, const Record &R) {
     // The option Values. Used for shell autocompletion.
     OS << ", ";
     if (!isa<UnsetInit>(R.getValueInit("Values")))
       write_cstring(OS, R.getValueAsString("Values"));
     else
       OS << "nullptr";
   };
 
-  std::vector<MarshallingInfo> OptsWithMarshalling;
+  std::vector<MarshallingInfo::Ptr> OptsWithMarshalling;
   for (unsigned I = 0, E = Opts.size(); I != E; ++I) {
     const Record &R = *Opts[I];
 
     // Start a single option entry.
     OS << "OPTION(";
     WriteOptRecordFields(OS, R);
     OS << ")\n";
     if (!isa<UnsetInit>(R.getValueInit("KeyPath")) &&
         !R.getValueAsString("KeyPath").empty())
-      OptsWithMarshalling.push_back(MarshallingInfo::create(R));
+      OptsWithMarshalling.push_back(createMarshallingInfo(R));
   }
   OS << "#endif // OPTION\n";
 
   for (const auto &KindInfo : OptsWithMarshalling) {
-    OS << "#ifdef " << KindInfo.MacroName << "\n";
-    OS << KindInfo.MacroName << "(";
-    WriteOptRecordFields(OS, KindInfo.R);
+    OS << "#ifdef " << KindInfo->MacroName << "\n";
+    OS << KindInfo->MacroName << "(";
+    WriteOptRecordFields(OS, KindInfo->R);
     OS << ", ";
-    KindInfo.emit(OS);
+    KindInfo->emit(OS);
     OS << ")\n";
-    OS << "#endif // " << KindInfo.MacroName << "\n";
+    OS << "#endif // " << KindInfo->MacroName << "\n";
   }
 
   OS << "\n";
   OS << "#ifdef SIMPLE_ENUM_VALUE_TABLE";
   OS << "\n";
   OS << MarshallingInfo::ValueTablePreamble;
   std::vector<StringRef> ValueTableNames;
   for (const auto &KindInfo : OptsWithMarshalling)
-    if (auto MaybeValueTableName = KindInfo.emitValueTable(OS))
+    if (auto MaybeValueTableName = KindInfo->emitValueTable(OS))
       ValueTableNames.push_back(*MaybeValueTableName);
 
   OS << MarshallingInfo::ValueTablesDecl << "{";
   for (auto ValueTableName : ValueTableNames)
     OS << "{" << ValueTableName << ", sizeof(" << ValueTableName
        << ") / sizeof(SimpleEnumValue)"
        << "},\n";
   OS << "};\n";