[analyzer][NFC] Demonstrate a move from the analyzer-configs `.def` file to a TableGen file

[Szelethus]

Summary

As of now, analyzer configs are specified in the preprocessor file clang/include/clang/StaticAnalyzer/Core/AnalyzerOptions.def, something like this:

#define ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC, DEFAULT_VAL)

ANALYZER_OPTION(bool, ShouldIncludeImplicitDtorsInCFG, "cfg-implicit-dtors",
                "Whether or not implicit destructors for C++ objects "
                "should be included in the CFG.",
                true)

ANALYZER_OPTION(
    unsigned, AlwaysInlineSize, "ipa-always-inline-size",
    "The size of the functions (in basic blocks), which should be considered "
    "to be small enough to always inline.",
    3)

ANALYZER_OPTION(
    StringRef, RawSilencedCheckersAndPackages, "silence-checkers",
    "A semicolon separated list of checker and package names to silence. "
    "Silenced checkers will not emit reports, but the modeling remain enabled.",
    "")

ANALYZER_OPTION(
    StringRef, CXXMemberInliningMode, "c++-inlining",
    "Controls which C++ member functions will be considered for inlining. "
    "Value: \"constructors\", \"destructors\", \"methods\".",
    "destructors")

This patch proposes to move to a TableGen format, seen in the diff below. The file generated from it (build/tools/clang/include/clang/StaticAnalyzer/Core/Config.inc) looks like this:

// This file is automatically generated. Do not edit this file by hand.

#ifdef BOOLEAN_OPTIONS
BOOLEAN_OPTION(bool, ShouldIncludeImplicitDtorsInCFG, "cfg-implicit-dtors",
               "Whether or not implicit destructors for C++ objects should be "
               "included in the CFG.",
               true)
#endif // BOOLEAN_OPTIONS

#ifdef INTEGER_OPTIONS
INTEGER_OPTION(int, AlwaysInlineSize, "ipa-always-inline-size",
               "The size of the functions (in basic blocks), which should be "
               "considered to be small enough to always inline.",
               3)
#endif // INTEGER_OPTIONS

#ifdef STRING_OPTIONS
STRING_OPTION(
    StringRef, RawSilencedCheckersAndPackages, "silence-checkers",
    "A semicolon separated list of checker and package names to silence. "
    "Silenced checkers will not emit reports, but the modeling remain enabled.",
    "")
#endif // STRING_OPTIONS

#ifdef ENUM_OPTIONS
ENUM_OPTION(
    CXXMemberInliningModeKind, CXXMemberInliningMode, "c++-inlining",
    "Controls which C++ member functions will be considered for inlining.",
    "destructors",
    "none,"
    "constructors,"
    "destructors,"
    "methods,")
#endif // ENUM_OPTIONS

#ifdef ENUMS
enum class CXXMemberInliningModeKind {
  CIMK_None = 0,
  CIMK_Constructors = 1,
  CIMK_Destructors = 2,
  CIMK_Memberfunctions = 3,
}

#endif // ENUMS

---

So, we're changing from writing a preprocessor file to generating it -- it'd be a stretch to say that all the trouble synonymous with the preprocessor are now gone. Its also rather easy and intuitive to add a new config to the existing format, and TableGen isn't universally liked in the analyzer. So, here is my pros and cons for why this is would be a good change:

Pros:

• Any changes to the current analyzer config format is miserable.
  • Might affect every macro, or needs manual #define shenanigans. Making changes to the TableGen emitter file are rather easy and not as invasive.
  • We may want to add features like what we're already seen in the checker TableGen file: development status (whether its in alpha, developer, or are okay for the end user to tinker with) and documentation uri.
  • As arguments aren't strongly typed (there are 3 string arguments one after the other), its easy to make a mistake in them. TableGen doesn't entirely negate this issue -- care still needs to be taken when using the preprocessor file it generates, but leading up to that point is far safer.
  • As there are a lot of entries in that file already, unless you compile with a single job, compilation errors can become really long and confusing, and thats true even if you do compile on a single job. TableGen again doesn't negate this entirely, but gets rid of them at least to the point of writing the configs. Errors are caught while generating the file, and easy to digest errors are emitted.
• There are in fact 2 .def files for configuring the analyzer: the other is clang/include/clang/StaticAnalyzer/Core/Analyses.def. The latter contains values acceptable values for some of the string configs, for example:

#ifndef ANALYSIS_STORE
#define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATFN)
#endif

ANALYSIS_STORE(RegionStore, "region", "Use region-based analyzer store",
               CreateRegionStoreManager)

• (cont.) In general, we don't have a good handle on string option accepting only a set of values. In the help text, its redundantly hardcoded in the text. We can't just generate it into the help text like this:

#define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATFN) #CMDFLAG ","
ANALYZER_OPTION(StringRef, AnalyzerStoreStr, "analyzer-store",
                "The Store implementation of the analyzer. The store is "
                "a mapping from variables or regions to values. Note: The "
                "analyzer was designed with its store being a replaceable "
                "component, but over the years it became increasingly unlikely "
                "that another kind of it will be developed. Value:"
#include "clang/StaticAnalyzer/Core/Analyses.def"
                ,
                "region")
#undef ANALYSIS_STORE

• (cont.) because such an #include is not portable, not to mention that it is rather ugly. So that redundancy is unavoidable, but thats not an issue if we generate that with TableGen.
• TableGen allows for more thorough, and arguably less cheesy ways to validate whether the specified analyzer config is valid.
• Unless you use /*comments=*/, arguments aren't as obvious. I argue that this is far more readable in the attached tablegen file.

Cons:

• Making changes to the TableGen emitter file might be okay, but still requires TableGen specific knowledge. However, making changes to the .td file itself is a nightmare unless you have some experience with it. In fact, it can be a bit troublesome even if you know a bit of it! Its usually only a few lines of class definition code, but even that can be a bit of a struggle.
• TableGen helps a lot on the issues faced by working with the preprocessor, but it doesn't negate them. At the end of the day, the generated file still needs to be included in the same, or similar way as before.
• Likely a bit slower to compile. Not that much, but its something.

It is my personal opinion that the pros outweigh the cons. The inspiration came from that I wanted to move some options (like -analyzer_constraints) from frontend flags one level lower into -analyzer-configs (in a backward compatible manner), and realized I'd need to redundantly hardcore the acceptable values for each of the enum-like configs.

---

So, about this patch. This serves as little more than a demonstration of how the TableGen file looks like, and what it could generate. The biggest item to highlight is how we can easily define enum configs:

• We can put all the acceptable values in the help text AND generate the enum class WITHOUT any redundancy.
• While not demonstrated, it'd be easy to add help texts to the enum values as well.
• You can see that in the generated file, all the values are squashed into a single string, and would need a string split -- thats just the way it goes, it seems like, as other tablegen files seem to do that as well. Maybe I could use variadic macro arguments...
• Automatic initialization and validation of the user input can be done by marshalling, but its so strongly tied to regular llvm/clang flags, I'd rather use it as a source of inspiration.

[Szelethus]

Ping.

The main question with this patch really is whether we want TableGen at all or not, as for what we generate precisely and how we'd utilize it is a discussion for later.

[vsavchenko]

In D104439#2832984, @Szelethus wrote:

Ping.

The main question with this patch really is whether we want TableGen at all or not, as for what we generate precisely and how we'd utilize it is a discussion for later.

I don't really have strong opinions here. On one hand, I'd prefer TableGen to a purely macro-based solution. On the other hand, something, let's say, C++-native (like cl::opt) seems better than TableGen.

[steakhal]

We can put all the acceptable values in the help text AND generate the enum class WITHOUT any redundancy.

+1

While not demonstrated, it'd be easy to add help texts to the enum values as well.

Ah yes! We should take it one step further. Generate user-facing documentation from the descriptions embedded in the `td file.
We should really have a doc page for analyzer configs as well, similarly to the one we have for checkers.
That being said, I would vote for generating the checker's user-facing docs as well, from the Checkers.td file. That way they would be always in sync and we could easily check if an option/checker is not documented.`

Automatic initialization and validation of the user input can be done by marshaling, but its so strongly tied to regular llvm/clang flags, I'd rather use it as a source of inspiration.

I think we can introduce marshaling and cl::opts in a subsequent patch if we need to, but I cannot immediately foresee the impact of any of these.

Let me invite @myhsu for Tablegen and @jansvoboda11 for marshaling.

clang/include/clang/StaticAnalyzer/AnalyzerFlagsBase.td

9

typo

clang/utils/TableGen/ClangSAConfigsEmitter.cpp

19

Where do you use std::map?

35–38

43–49

How does this return a sorted data structure? SortedRecords aliases llvm::StringMap<const Record *>.

114

typo

[myhsu]

Just curious: Have you considered using llvm::opt or even llvm::cl infrastructure? What are the pros & cons?

clang/utils/TableGen/ClangSAConfigsEmitter.cpp

24

32

I'm not an expert in clang-analyzer, but can DefaultVal be optional in an analyzer config? It you want it to be optional -- which, I think, also makes the TableGen file more concise -- you can use Record::getValueasOptionalString instead.

57

Please use llvm::emitSourceFileHeader (in llvm/TableGen/TableGenBackend.h)

76

IIRC usually we will also write /*IsDefaultValString=*/

140

if R->isValueUnset("Values") returns true, the resulting code will have a trailing comma just right before the right brace:

ENUM_OPTION(Foo, Foo, "bar", "...",)

which I don't think is valid for C/C++ macro.
Please use llvm::ListSeparator(in StringExtras.h) to print commas instead.

clang/include/clang/CMakeLists.txt

 add_subdirectory(AST)
 add_subdirectory(Basic)
 add_subdirectory(Driver)
 add_subdirectory(Parse)
 add_subdirectory(Sema)
 add_subdirectory(Serialization)
-add_subdirectory(StaticAnalyzer/Checkers)
+add_subdirectory(StaticAnalyzer)
 add_subdirectory(Tooling/Syntax)

clang/include/clang/StaticAnalyzer/AnalyzerFlagsBase.td

+//===-- AnalyzerFlagBase.td - Static Analyzer Flags TableGen base classes -===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+/// Describes ain option type. This is important for validating user supplied
+/// inputs.
+/// New option types can be added by modifying this enum. Note that this
+/// requires changes in the TableGen emitter files found in
+/// clang/utils/TableGen.
+class CmdLineOptionTypeEnum<bits<2> val> {
+  bits<2> Type = val;
+}
+def Integer : CmdLineOptionTypeEnum<0>;
+def String : CmdLineOptionTypeEnum<1>;
+def Boolean : CmdLineOptionTypeEnum<2>;
+
+/// A description. May be displayed to the user when clang is invoked with
+/// a '-help'-like command line option.
+class HelpText<string text> { string HelpText = text; }

clang/include/clang/StaticAnalyzer/CMakeLists.txt

+add_subdirectory(Checkers)
+add_subdirectory(Core)

clang/include/clang/StaticAnalyzer/Checkers/CheckerBase.td

 //===--- CheckerBase.td - Checker TableGen classes ------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines the TableGen core definitions for checkers
 //
 //===----------------------------------------------------------------------===//
 
-/// Describes a checker or package option type. This is important for validating
-/// user supplied inputs.
-/// New option types can be added by modifying this enum. Note that this
-/// requires changes in the TableGen emitter file ClangSACheckersEmitter.cpp.
-class CmdLineOptionTypeEnum<bits<2> val> {
-  bits<2> Type = val;
-}
-def Integer : CmdLineOptionTypeEnum<0>;
-def String : CmdLineOptionTypeEnum<1>;
-def Boolean : CmdLineOptionTypeEnum<2>;
+include "../AnalyzerFlagsBase.td"
 
 /// Describes the state of the entry. We wouldn't like to display, for example,
 /// developer only entries for a list meant for end users.
 class DevelopmentStageEnum<bits<1> val> {
   bits<1> Val = val;
 }
 
 /// Alpha entries are under development, might be incomplet, inkorrekt and

 
 /// Describes a 'super' package that holds another package inside it. This is
 /// used to nest packages in one another. One may, for example, create the
 /// 'builtin' package inside 'core', thus creating the package 'core.builtin'.
 /// Example:
 ///   def CoreBuiltin : Package<"builtin">, ParentPackage<Core>;
 class ParentPackage<Package P> { Package ParentPackage = P; }
 
-/// A description. May be displayed to the user when clang is invoked with
-/// a '-help'-like command line option.
-class HelpText<string text> { string HelpText = text; }
-
 /// Describes what kind of documentation exists for the checker.
 class DocumentationEnum<bits<2> val> {
   bits<2> Documentation = val;
 }
 def NotDocumented : DocumentationEnum<0>;
 def HasDocumentation : DocumentationEnum<1>;
 def HasAlphaDocumentation : DocumentationEnum<2>;
 

clang/include/clang/StaticAnalyzer/Core/AnalyzerOptions.td

+//===--- AnalyzerOptions.td - Analyzer configs ----------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file defines the analyzer options avaible with -analyzer-config.
+//  TODO: Copy documentation from AnalyzerOptions.def before deleting it.
+//
+//===----------------------------------------------------------------------===//
+
+include "../AnalyzerFlagsBase.td"
+
+
+class Config<string name, CmdLineOptionTypeEnum type> {
+  string Name = name;
+  bits<2> Type = type.Type;
+  string  HelpText;
+  string  DefaultVal;
+}
+
+class DefaultVal<string val> { string DefaultVal = val; }
+//===----------------------------------------------------------------------===//
+
+class BooleanConfig<string name> : Config<name, Boolean>;
+//===----------------------------------------------------------------------===//
+
+class IntegerConfig<string name> : Config<name, Integer> {
+  list<int> Values = ?;
+}
+
+class IntValues<list<int> Vals> {
+  list<int> Values = Vals;
+}
+//===----------------------------------------------------------------------===//
+
+class StringConfig<string name> : Config<name, String> {
+  bit NeedsNoValidation = 0;
+}
+//===----------------------------------------------------------------------===//
+
+class FileNameConfig<string name> : Config<name, String>;
+//===----------------------------------------------------------------------===//
+
+class EnumVal<string cmdFlag, string enumName> {
+  string CmdFlag = cmdFlag;
+  string EnumName = enumName;
+}
+
+class EnumConfig<string name> : Config<name, String> {
+  list<EnumVal> Values;
+  string EnumPrefix;
+}
+
+class EnumValues<list<EnumVal> Vals> {
+  list<EnumVal> Values = Vals;
+}
+
+class EnumPrefix<string enumPrefix> {
+  string EnumPrefix = enumPrefix;
+}
+//===----------------------------------------------------------------------===//
+
+
+def ShouldIncludeImplicitDtorsInCFG : BooleanConfig<"cfg-implicit-dtors">,
+  HelpText<"Whether or not implicit destructors for C++ objects should be "
+           "included in the CFG.">,
+  DefaultVal<"true">;
+
+def AlwaysInlineSize : IntegerConfig<"ipa-always-inline-size">,
+  HelpText<"The size of the functions (in basic blocks), which should be "
+           "considered to be small enough to always inline.">,
+  DefaultVal<"3">;
+
+def RawSilencedCheckersAndPackages : StringConfig<"silence-checkers">,
+  HelpText<"A semicolon separated list of checker and package names to "
+           "silence. Silenced checkers will not emit reports, but the modeling "
+           "remain enabled.">,
+  DefaultVal<"">;
+
+def CXXMemberInliningMode : EnumConfig<"c++-inlining">,
+  HelpText<"Controls which C++ member functions will be considered for "
+           "inlining.">,
+  EnumPrefix<"CIMK">,
+  EnumValues<[
+    EnumVal<"none", "None">,
+    EnumVal<"constructors", "Constructors">,
+    EnumVal<"destructors", "Destructors">,
+    EnumVal<"methods", "Memberfunctions">
+  ]>,
+  DefaultVal<"destructors">;
+

clang/include/clang/StaticAnalyzer/Core/CMakeLists.txt

+clang_tablegen(Configs.inc -gen-clang-sa-configs
+  SOURCE AnalyzerOptions.td
+  TARGET ClangSAConfigs)

clang/utils/TableGen/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS Support)
 
 add_tablegen(clang-tblgen CLANG
   ASTTableGen.cpp
   ClangASTNodesEmitter.cpp
   ClangASTPropertiesEmitter.cpp
   ClangAttrEmitter.cpp
   ClangCommentCommandInfoEmitter.cpp
   ClangCommentHTMLNamedCharacterReferenceEmitter.cpp
   ClangCommentHTMLTagsEmitter.cpp
   ClangDataCollectorsEmitter.cpp
   ClangDiagnosticsEmitter.cpp
   ClangOpcodesEmitter.cpp
   ClangOpenCLBuiltinEmitter.cpp
   ClangOptionDocEmitter.cpp
   ClangSACheckersEmitter.cpp
+  ClangSAConfigsEmitter.cpp
   ClangSyntaxEmitter.cpp
   ClangTypeNodesEmitter.cpp
   MveEmitter.cpp
   NeonEmitter.cpp
   RISCVVEmitter.cpp
   SveEmitter.cpp
   TableGen.cpp
   )
 set_target_properties(clang-tblgen PROPERTIES FOLDER "Clang tablegenning")

clang/utils/TableGen/ClangSAConfigsEmitter.cpp

+//==- ClangSAConfigsEmitter.cpp - Generate Clang SA config tables -*- C++ -*-
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This tablegen backend emits Clang Static Analyzer -analyzer-config tables.
+//
+//===----------------------------------------------------------------------===//
+
+#include "TableGenBackends.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/TableGen/Error.h"
+#include "llvm/TableGen/Record.h"
+#include "llvm/TableGen/TableGenBackend.h"
+#include <map>
+#include <string>
+
+using namespace llvm;
+
+using SortedRecords = llvm::StringMap<const Record *>;
+
+static void printOptionFields(const Record *R, raw_ostream &OS,
+                              bool IsDefaultValString) {
+  OS << R->getName() << ","
+     << "\"";
+  OS.write_escaped(R->getValueAsString("Name")) << "\",\"";
+  OS.write_escaped(R->getValueAsString("HelpText")) << "\",";
+  StringRef DefaultVal = R->getValueAsString("DefaultVal");
+
+  if (IsDefaultValString) {
+    if (DefaultVal == "")
+      OS << "\"\"";
+    else
+      OS << "\"" << DefaultVal << "\"";
+  } else
+    OS << DefaultVal;
+}
+
+static SortedRecords getSortedDerivedDefinitions(RecordKeeper &Records,
+                                                 StringRef ClassName) {
+  SortedRecords Ret;
+  for (const Record *R : Records.getAllDerivedDefinitions(ClassName))
+    Ret[R->getValueAsString("Name")] = R;
+  return Ret;
+}
+
+static std::string getEnumName(const Record *R) {
+  return R->getNameInitAsString() + "Kind";
+}
+
+void clang::EmitClangSAConfigs(RecordKeeper &Records, raw_ostream &OS) {
+
+  OS << "// This file is automatically generated. Do not edit this file by "
+        "hand.\n";
+
+  // Emit boolean options.
+  //
+  // BOOLEAN_OPTION(TYPE, FIELD_NAME, CMDFLAG, HELPTEXT, DEFAULTVAL)
+  // - TYPE: Type of the option in class AnalyzerOptions.
+  // - FIELD_NAME: Name of the field in class AnalyzerOptions.
+  // - CMDFLAG: Name of the flag to be specified on the command line. For
+  //            specifics, check clang -cc1 -analyzer-config-help.
+  // - HELPTEXT: Text displayed under -analyzer-config-help.
+  // - DEFAULTVAL: Default value of the option if its not specified in the
+  //               command line.
+  OS << "\n"
+        "#ifdef BOOLEAN_OPTIONS\n";
+  for (const auto &Pair :
+       getSortedDerivedDefinitions(Records, "BooleanConfig")) {
+    const Record *R = Pair.second;
+    OS << "BOOLEAN_OPTION(bool,";
+    printOptionFields(R, OS, /*IsDefaultValString*/false);
+    OS << ")\n";
+  }
+  OS << "#endif // BOOLEAN_OPTIONS\n"
+        "\n";
+
+  // Emit integer options.
+  //
+  // INTEGER_OPTIONS(TYPE, FIELD_NAME, CMDFLAG, HELPTEXT, DEFAULTVAL)
+  // Check the comments around BOOLEAN_OPTION for description of the parameters.
+  OS << "\n"
+        "#ifdef INTEGER_OPTIONS\n";
+  for (const auto &Pair :
+       getSortedDerivedDefinitions(Records, "IntegerConfig")) {
+    const Record *R = Pair.second;
+    OS << "INTEGER_OPTION(int,";
+    printOptionFields(R, OS, /*IsDefaultValString*/false);
+    OS << ")\n";
+  }
+  OS << "#endif // INTEGER_OPTIONS\n"
+        "\n";
+
+  // Emit string options.
+  //
+  // STRING_OPTIONS(TYPE, FIELD_NAME, CMDFLAG, HELPTEXT, DEFAULTVAL)
+  // Check the comments around BOOLEAN_OPTION for description of the parameters.
+  OS << "\n"
+        "#ifdef STRING_OPTIONS\n";
+  for (const auto &Pair :
+       getSortedDerivedDefinitions(Records, "StringConfig")) {
+    const Record *R = Pair.second;
+    OS << "STRING_OPTION(StringRef,";
+    printOptionFields(R, OS, /*IsDefaultValString*/true);
+    OS << ")\n";
+  }
+  OS << "#endif // STRING_OPTIONS\n"
+        "\n";
+
+  // Emit enum options. These are string options can only take a select fe
+  // values, and are parsed into enums.
+  //
+  // ENUM_OPTIONS(
+  //   TYPE, FIELD_NAME, CMDFLAG, HELPTEXT, DEFAULTVAL, VALUES)
+  //
+  // Check the comments around BOOLEAN_OPTION for description of the first few
+  // parameters.
+  // - VALUES: A string that lists all options that can be specified on the
+  //           command line. Each value is separated with a comma (its still one
+  //           big string!). They correspond with enum values with the same
+  //           index (see ENUMS below).
+  OS << "\n"
+        "#ifdef ENUM_OPTIONS\n";
+  for (const auto &Pair : getSortedDerivedDefinitions(Records, "EnumConfig")) {
+    const Record *R = Pair.second;
+    OS << "ENUM_OPTION(" << getEnumName(R) << ",";
+    printOptionFields(R, OS, /*IsDefaultValString*/true);
+    OS << ',';
+    if (!R->isValueUnset("Values")) {
+      for (const Record *EnumVal : R->getValueAsListOfDefs("Values")) {
+        OS << "\"";
+        OS.write_escaped(EnumVal->getValueAsString("CmdFlag"));
+        OS << ",\"";
+      }
+    }
+    OS << ")\n";
+  }
+  OS << "#endif // ENUM_OPTIONS\n"
+        "\n";
+
+  // Emit enum classes corresponding with the enum options.
+  //
+  // enum class <option name>Kind {
+  //   <first enum value> = 0,
+  //   ...
+  //   <nth enum value> = n - 1
+  // };
+  //
+  // Enum values are equal with the index of the command line option in VALUES
+  // in ENUM_OPTIONS.
+  OS << "\n"
+        "#ifdef ENUMS\n";
+  for (const auto &Pair : getSortedDerivedDefinitions(Records, "EnumConfig")) {
+
+    const Record *R = Pair.second;
+    OS << "enum class " << getEnumName(R) << "{\n";
+    int Counter = 0;
+    for (const Record *EnumVal : R->getValueAsListOfDefs("Values")) {
+      OS << "  ";
+      OS.write_escaped(R->getValueAsString("EnumPrefix")) << '_';
+      OS.write_escaped(EnumVal->getValueAsString("EnumName"))
+          << " = " << Counter++;
+      OS << ",\n";
+    }
+    OS << "}\n\n";
+  }
+  OS << "#endif // ENUMS\n"
+        "\n";
+}

clang/utils/TableGen/TableGen.cpp

enum ActionType {
   GenClangCommentNodes,
   GenClangDeclNodes,
   GenClangStmtNodes,
   GenClangTypeNodes,
   GenClangTypeReader,
   GenClangTypeWriter,
   GenClangOpcodes,
   GenClangSACheckers,
+  GenClangSAConfigs,
   GenClangSyntaxNodeList,
   GenClangSyntaxNodeClasses,
   GenClangCommentHTMLTags,
   GenClangCommentHTMLTagsProperties,
   GenClangCommentHTMLNamedCharacterReferences,
   GenClangCommentCommandInfo,
   GenClangCommentCommandList,
   GenClangOpenCLBuiltins,
cl::values(
         clEnumValN(GenClangTypeReader, "gen-clang-type-reader",
                    "Generate Clang AbstractTypeReader class"),
         clEnumValN(GenClangTypeWriter, "gen-clang-type-writer",
                    "Generate Clang AbstractTypeWriter class"),
         clEnumValN(GenClangOpcodes, "gen-clang-opcodes",
                    "Generate Clang constexpr interpreter opcodes"),
         clEnumValN(GenClangSACheckers, "gen-clang-sa-checkers",
                    "Generate Clang Static Analyzer checkers"),
+        clEnumValN(GenClangSAConfigs, "gen-clang-sa-configs",
+                   "Generate Clang Static Analyzer -analyzer-configs"),
         clEnumValN(GenClangSyntaxNodeList, "gen-clang-syntax-node-list",
                    "Generate list of Clang Syntax Tree node types"),
         clEnumValN(GenClangSyntaxNodeClasses, "gen-clang-syntax-node-classes",
                    "Generate definitions of Clang Syntax Tree node clasess"),
         clEnumValN(GenClangCommentHTMLTags, "gen-clang-comment-html-tags",
                    "Generate efficient matchers for HTML tag "
                    "names that are used in documentation comments"),
         clEnumValN(GenClangCommentHTMLTagsProperties,
case GenClangBasicWriter:
     EmitClangBasicWriter(Records, OS);
     break;
   case GenClangOpcodes:
     EmitClangOpcodes(Records, OS);
     break;
   case GenClangSACheckers:
     EmitClangSACheckers(Records, OS);
     break;
+  case GenClangSAConfigs:
+    EmitClangSAConfigs(Records, OS);
+    break;
   case GenClangCommentHTMLTags:
     EmitClangCommentHTMLTags(Records, OS);
     break;
   case GenClangCommentHTMLTagsProperties:
     EmitClangCommentHTMLTagsProperties(Records, OS);
     break;
   case GenClangCommentHTMLNamedCharacterReferences:
     EmitClangCommentHTMLNamedCharacterReferences(Records, OS);

clang/utils/TableGen/TableGenBackends.h

 void EmitClangDiagsDefs(llvm::RecordKeeper &Records, llvm::raw_ostream &OS,
                         const std::string &Component);
 void EmitClangDiagGroups(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
 void EmitClangDiagsIndexName(llvm::RecordKeeper &Records,
                              llvm::raw_ostream &OS);
 
 void EmitClangSACheckers(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
 
+void EmitClangSAConfigs(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
+
 void EmitClangCommentHTMLTags(llvm::RecordKeeper &Records,
                               llvm::raw_ostream &OS);
 void EmitClangCommentHTMLTagsProperties(llvm::RecordKeeper &Records,
                                         llvm::raw_ostream &OS);
 void EmitClangCommentHTMLNamedCharacterReferences(llvm::RecordKeeper &Records,
                                                   llvm::raw_ostream &OS);
 
 void EmitClangCommentCommandInfo(llvm::RecordKeeper &Records,