Add support for specifying only a denormalizer

[dang]

Summary

This commit adds a denormalyzer for optimization level.
Depends on D83406

clang/include/clang/Driver/Options.td

def MV : Flag<["-"], "MV">, Group<M_Group>, Flags<[CC1Option]>,
     HelpText<"Use NMake/Jom format for the depfile">;
 def Mach : Flag<["-"], "Mach">, Group<Link_Group>;
 def O0 : Flag<["-"], "O0">, Group<O_Group>, Flags<[CC1Option, HelpHidden]>;
 def O4 : Flag<["-"], "O4">, Group<O_Group>, Flags<[CC1Option, HelpHidden]>;
 def ObjCXX : Flag<["-"], "ObjC++">, Flags<[DriverOption]>,
   HelpText<"Treat source input files as Objective-C++ inputs">;
 def ObjC : Flag<["-"], "ObjC">, Flags<[DriverOption]>,
   HelpText<"Treat source input files as Objective-C inputs">;
-def O : Joined<["-"], "O">, Group<O_Group>, Flags<[CC1Option]>;
+def O : Joined<["-"], "O">, Group<O_Group>, Flags<[CC1Option]>,
+  MarshallingInfoString<"CodeGenOpts.OptimizationLevel", "llvm::CodeGenOpt::Default">,
+  AlwaysEmit, Denormalizer<"denormalizeOptimizationLevel">; 
 def O_flag : Flag<["-"], "O">, Flags<[CC1Option]>, Alias<O>, AliasArgs<["1"]>;
 def Ofast : Joined<["-"], "Ofast">, Group<O_Group>, Flags<[CC1Option]>;
 def P : Flag<["-"], "P">, Flags<[CC1Option]>, Group<Preprocessor_Group>,
   HelpText<"Disable linemarker output in -E mode">;
 def Qy : Flag<["-"], "Qy">, Flags<[CC1Option]>,
   HelpText<"Emit metadata containing compiler name and version">;
 def Qn : Flag<["-"], "Qn">, Flags<[CC1Option]>,
   HelpText<"Do not emit metadata containing compiler name and version">;

clang/lib/Frontend/CompilerInvocation.cpp

static Optional<std::string> normalizeTriple(OptSpecifier Opt, int TableIndex,
                                              const ArgList &Args,
                                              DiagnosticsEngine &Diags) {
   auto *Arg = Args.getLastArg(Opt);
   if (!Arg)
     return None;
   return llvm::Triple::normalize(Arg->getValue());
 }
 
+static void denormalizeOptimizationLevel(SmallVectorImpl<const char *> &Args,
+                                         const char *Spelling,
+                                         CompilerInvocation::StringAllocator SA,
+                                         unsigned TableIndex,
+                                         const unsigned Value) {
+  Args.push_back(SA(Twine(Spelling) + Twine(Value)));
+}
+
 template <typename T, typename U>
 static T mergeForwardValue(T KeyPath, U Value) {
   return Value;
 }
 
 template <typename T, typename U> static T mergeMaskValue(T KeyPath, U Value) {
   return KeyPath | Value;
 }
if (Version.tryParse(A->getValue()))
           << A->getAsString(Args) << A->getValue();
     else
       Opts.SDKVersion = Version;
   }
 }
 
 bool CompilerInvocation::parseSimpleArgs(const ArgList &Args,
                                          DiagnosticsEngine &Diags) {
-#define OPTION_WITH_MARSHALLING(                                               \
-    PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
-    HELPTEXT, METAVAR, VALUES, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE,  \
-    NORMALIZER, DENORMALIZER, MERGER, EXTRACTOR, TABLE_INDEX)                  \
+#define OPTION_WITH_PARSING(PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS,         \
+                            ALIASARGS, FLAGS, PARAM, HELPTEXT, METAVAR,        \
+                            VALUES, KEYPATH, DEFAULT_VALUE, NORMALIZER,        \
+                            MERGER, TABLE_INDEX)                               \
   {                                                                            \
     if (auto MaybeValue = NORMALIZER(OPT_##ID, TABLE_INDEX, Args, Diags))      \
       this->KEYPATH = MERGER(                                                  \
           this->KEYPATH, static_cast<decltype(this->KEYPATH)>(*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,  \
-    NORMALIZER, DENORMALIZER, MERGER, EXTRACTOR, TABLE_INDEX, NEG_ID,          \
-    NEG_SPELLING)                                                              \
+#define OPTION_WITH_PARSING_BOOLEAN(PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, \
+                                    ALIASARGS, FLAGS, PARAM, HELPTEXT,         \
+                                    METAVAR, VALUES, KEYPATH, DEFAULT_VALUE,   \
+                                    NORMALIZER, MERGER, TABLE_INDEX, NEG_ID)   \
   {                                                                            \
     if (auto MaybeValue =                                                      \
             NORMALIZER(OPT_##ID, OPT_##NEG_ID, TABLE_INDEX, Args, Diags))      \
       this->KEYPATH = MERGER(                                                  \
           this->KEYPATH, static_cast<decltype(this->KEYPATH)>(*MaybeValue));   \
     else                                                                       \
       this->KEYPATH = MERGER(this->KEYPATH, DEFAULT_VALUE);                    \
   }
 
 #include "clang/Driver/Options.inc"
-#undef OPTION_WITH_MARSHALLING_BOOLEAN
-#undef OPTION_WITH_MARSHALLING
+#undef OPTION_WITH_PARSING_BOOLEAN
+#undef OPTION_WITH_PARSING
   return true;
 }
 
 bool CompilerInvocation::CreateFromArgs(CompilerInvocation &Res,
                                         ArrayRef<const char *> CommandLineArgs,
                                         DiagnosticsEngine &Diags,
                                         const char *Argv0) {
   bool Success = true;
#include "clang/Basic/LangOptions.def"
   if (!SanHash.empty())
     code = hash_combine(code, SanHash.Mask);
 
   return llvm::APInt(64, code).toString(36, /*Signed=*/false);
 }
 
 void CompilerInvocation::generateCC1CommandLine(
     SmallVectorImpl<const char *> &Args, StringAllocator SA) const {
-#define OPTION_WITH_MARSHALLING(                                               \
+#define OPTION_WITH_SERIALIZING(                                               \
     PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
-    HELPTEXT, METAVAR, VALUES, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE,  \
-    NORMALIZER, DENORMALIZER, MERGER, EXTRACTOR, TABLE_INDEX)                  \
+    HELPTEXT, METAVAR, VALUES, KEYPATH, DEFAULT_VALUE, SPELLING, ALWAYS_EMIT,  \
+    DENORMALIZER, EXTRACTOR, TABLE_INDEX)                                      \
   if ((FLAGS)&options::CC1Option) {                                            \
     const auto &Extracted = EXTRACTOR(this->KEYPATH);                          \
     if (ALWAYS_EMIT || Extracted != DEFAULT_VALUE)                             \
       DENORMALIZER(Args, SPELLING, SA, TABLE_INDEX, Extracted);                \
   }
 
-#define OPTION_WITH_MARSHALLING_BOOLEAN(                                       \
+#define OPTION_WITH_SERIALIZING_BOOLEAN(                                       \
     PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
-    HELPTEXT, METAVAR, VALUES, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE,  \
-    NORMALIZER, DENORMALIZER, MERGER, EXTRACTOR, TABLE_INDEX, NEG_ID,          \
-    NEG_SPELLING)                                                              \
+    HELPTEXT, METAVAR, VALUES, KEYPATH, DEFAULT_VALUE, SPELLING, ALWAYS_EMIT,  \
+    DENORMALIZER, EXTRACTOR, TABLE_INDEX, NEG_SPELLING)                        \
   if ((FLAGS)&options::CC1Option) {                                            \
     const auto &Extracted = EXTRACTOR(this->KEYPATH);                          \
     if (ALWAYS_EMIT || Extracted != DEFAULT_VALUE)                             \
       DENORMALIZER(Args, SPELLING, NEG_SPELLING, SA, TABLE_INDEX, Extracted);  \
   }
 
 #include "clang/Driver/Options.inc"
-#undef OPTION_WITH_MARSHALLING_BOOLEAN
-#undef OPTION_WITH_MARSHALLING
+#undef OPTION_WITH_SERIALIZING_BOOLEAN
+#undef OPTION_WITH_SERIALIZING
 }
 
 namespace clang {
 
 IntrusiveRefCntPtr<llvm::vfs::FileSystem>
 createVFSFromCompilerInvocation(const CompilerInvocation &CI,
                                 DiagnosticsEngine &Diags) {
   return createVFSFromCompilerInvocation(CI, Diags,

llvm/include/llvm/Option/OptParser.td

class Option<list<string> prefixes, string name, OptionKind kind> {
   Option Alias = ?;
   list<string> AliasArgs = [];
   string MarshallingInfoKind = ?;
   code KeyPath = ?;
   code DefaultValue = ?;
   bit ShouldAlwaysEmit = 0;
   code NormalizerRetTy = ?;
   code NormalizedValuesScope = "";
-  code Normalizer = "";
-  code Denormalizer = "";
+  code Normalizer = ?;
+  code Denormalizer = ?;
   code ValueMerger = "mergeForwardValue";
   code ValueExtractor = "extractForwardValue";
   list<code> NormalizedValues = ?;
   // Used for BooleanFlagKind
   Option NegOption = ?;
 }
 
 // Helpers for defining options.

llvm/utils/TableGen/OptParserEmitter.cpp

static void emitNameUsingSpelling(raw_ostream &OS, const Record &R) {
   write_cstring(OS, StringRef(getOptionSpelling(R, PrefixLength)));
   OS << "[" << PrefixLength << "]";
 }
 
 class MarshallingInfo {
 public:
   using Ptr = std::unique_ptr<MarshallingInfo>;
 
-  const char *MacroName;
+  static constexpr const char *MacroNameSerializing = "OPTION_WITH_SERIALIZING";
+  static constexpr const char *MacroNameParsing = "OPTION_WITH_PARSING";
+
   const Record &R;
+  bool CanParse;
   bool ShouldAlwaysEmit;
   StringRef KeyPath;
   StringRef DefaultValue;
   StringRef NormalizedValuesScope;
   StringRef Normalizer;
   StringRef Denormalizer;
   StringRef ValueMerger;
   StringRef ValueExtractor;
struct SimpleEnumValueTable {
   const SimpleEnumValue *Table;
   unsigned Size;
 };
 )";
 
   static constexpr const char *ValueTablesDecl =
       "static const SimpleEnumValueTable SimpleEnumValueTables[] = ";
 
-  MarshallingInfo(const Record &R)
-      : MacroName("OPTION_WITH_MARSHALLING"), R(R) {}
-  MarshallingInfo(const char *MacroName, const Record &R)
-      : MacroName(MacroName), R(R){};
+  MarshallingInfo(const Record &R) : 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 << ", ";
-    OS << Normalizer;
-    OS << ", ";
-    OS << Denormalizer;
-    OS << ", ";
-    OS << ValueMerger;
+  virtual void
+  emitParsing(raw_ostream &OS,
+              llvm::function_ref<void(raw_ostream &, const Record &)>
+                  WriteOptRecordFields) const {
+    if (!CanParse)
+      return;
+    OS << "#ifdef " << MacroNameParsing << "\n";
+    OS << MacroNameParsing << "(";
+    WriteOptRecordFields(OS, R);
     OS << ", ";
-    OS << ValueExtractor;
+    emitParsingFields(OS);
+    OS << ")\n";
+    OS << "#endif // " << MacroNameParsing << "\n";
+  }
+
+  virtual void
+  emitSerialiazing(raw_ostream &OS,
+                   llvm::function_ref<void(raw_ostream &, const Record &)>
+                       WriteOptRecordFields) const {
+    OS << "#ifdef " << MacroNameSerializing << "\n";
+    OS << MacroNameSerializing << "(";
+    WriteOptRecordFields(OS, R);
     OS << ", ";
-    OS << TableIndex;
+    emitSerializingFields(OS);
+    OS << ")\n";
+    OS << "#endif // " << MacroNameSerializing << "\n";
   }
 
   Optional<StringRef> emitValueTable(raw_ostream &OS) const {
     if (TableIndex == -1)
       return {};
     OS << "static const SimpleEnumValue " << ValueTableName << "[] = {\n";
     for (unsigned I = 0, E = Values.size(); I != E; ++I) {
       OS << "{";
       write_cstring(OS, Values[I]);
       OS << ",";
       OS << "static_cast<unsigned>(";
       emitScopedNormalizedValue(OS, NormalizedValues[I]);
       OS << ")},";
     }
     OS << "};\n";
     return StringRef(ValueTableName);
   }
 
+protected:
+  void emitParsingFields(raw_ostream &OS) const {
+    OS << KeyPath;
+    OS << ", ";
+    emitScopedNormalizedValue(OS, DefaultValue);
+    OS << ", ";
+    OS << Normalizer;
+    OS << ", ";
+    OS << ValueMerger;
+    OS << ", ";
+    OS << TableIndex;
+  }
+
+  void emitSerializingFields(raw_ostream &OS) const {
+    OS << KeyPath;
+    OS << ", ";
+    emitScopedNormalizedValue(OS, DefaultValue);
+    OS << ", ";
+    write_cstring(OS, StringRef(getOptionSpelling(R)));
+    OS << ", ";
+    OS << ShouldAlwaysEmit;
+    OS << ", ";
+    OS << Denormalizer;
+    OS << ", ";
+    OS << ValueExtractor;
+    OS << ", ";
+    OS << TableIndex;
+  }
+
 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) {}
+      : MarshallingInfo(Option), NegOption(NegOption) {}
 
-  void emit(raw_ostream &OS) const override {
-    MarshallingInfo::emit(OS);
+  void emitParsing(raw_ostream &OS,
+                   llvm::function_ref<void(raw_ostream &, const Record &)>
+                       WriteOptRecordFields) const override {
+    if (!CanParse)
+      return;
+    OS << "#ifdef " << MacroNameParsing << "_BOOLEAN\n";
+    OS << MacroNameParsing << "_BOOLEAN(";
+    WriteOptRecordFields(OS, R);
+    OS << ", ";
+    emitParsingFields(OS);
     OS << ", ";
     OS << getOptionName(NegOption);
+    OS << ")\n";
+    OS << "#endif // " << MacroNameParsing << "_BOOLEAN\n";
+  }
+
+  void emitSerialiazing(raw_ostream &OS,
+                        llvm::function_ref<void(raw_ostream &, const Record &)>
+                            WriteOptRecordFields) const override {
+    OS << "#ifdef " << MacroNameSerializing << "_BOOLEAN\n";
+    OS << MacroNameSerializing << "_BOOLEAN(";
+    WriteOptRecordFields(OS, R);
+    OS << ", ";
+    emitSerializingFields(OS);
     OS << ", ";
     write_cstring(OS, getOptionSpelling(NegOption));
+    OS << ")\n";
+    OS << "#endif // " << MacroNameSerializing << "_BOOLEAN\n";
   }
 };
 
 static MarshallingInfo::Ptr createMarshallingInfo(const Record &R) {
   assert(!isa<UnsetInit>(R.getValueInit("KeyPath")) &&
          !isa<UnsetInit>(R.getValueInit("DefaultValue")) &&
-         !isa<UnsetInit>(R.getValueInit("ValueMerger")) &&
+         !isa<UnsetInit>(R.getValueInit("Denormalizer")) &&
          "MarshallingInfo must have a provide a keypath, default value and a "
-         "value merger");
+         "denormalizer");
 
   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->Denormalizer = R.getValueAsString("Denormalizer");
 
+  Ret->CanParse = false;
+  if (!isa<UnsetInit>(R.getValueInit("Normalizer"))) {
     Ret->Normalizer = R.getValueAsString("Normalizer");
-  Ret->Denormalizer = R.getValueAsString("Denormalizer");
+    Ret->CanParse = true;
+  }
+  Ret->NormalizedValuesScope = R.getValueAsString("NormalizedValuesScope");
   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 = MarshallingInfo::NextTableIndex++;
     Ret->NormalizedValues = R.getValueAsListOfStrings("NormalizedValues");
for (unsigned I = 0, E = Opts.size(); I != E; ++I) {
     OS << ")\n";
     if (!isa<UnsetInit>(R.getValueInit("KeyPath")) &&
         !R.getValueAsString("KeyPath").empty())
       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 << ", ";
-    KindInfo->emit(OS);
-    OS << ")\n";
-    OS << "#endif // " << KindInfo->MacroName << "\n";
+    KindInfo->emitParsing(OS, WriteOptRecordFields);
+    KindInfo->emitSerialiazing(OS, WriteOptRecordFields);
   }
 
   OS << "\n";
   OS << "#ifdef SIMPLE_ENUM_VALUE_TABLE";
   OS << "\n";
   OS << MarshallingInfo::ValueTablePreamble;
   std::vector<StringRef> ValueTableNames;
   for (const auto &KindInfo : OptsWithMarshalling)