//===- TableGen.cpp - Top-Level TableGen implementation for Clang ---------===//

//

// 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 contains the main function for Clang's TableGen.

//

//===----------------------------------------------------------------------===//

#include "TableGenBackends.h" // Declares all backends.

#include "ASTTableGen.h"

#include "llvm/Support/CommandLine.h"

#include "llvm/Support/PrettyStackTrace.h"

#include "llvm/Support/Signals.h"

#include "llvm/TableGen/Error.h"

#include "llvm/TableGen/Main.h"

#include "llvm/TableGen/Record.h"

using namespace llvm;

using namespace clang;

enum ActionType {

  PrintRecords,

  DumpJSON,

  GenClangAttrClasses,

  GenClangAttrParserStringSwitches,

  GenClangAttrSubjectMatchRulesParserStringSwitches,

  GenClangAttrImpl,

  GenClangAttrList,

  GenClangAttrDocTable,

  GenClangAttrSubjectMatchRuleList,

  GenClangAttrPCHRead,

  GenClangAttrPCHWrite,

  GenClangAttrHasAttributeImpl,

  GenClangAttrSpellingListIndex,

  GenClangAttrASTVisitor,

  GenClangAttrTemplateInstantiate,

  GenClangAttrParsedAttrList,

  GenClangAttrParsedAttrImpl,

  GenClangAttrParsedAttrKinds,

  GenClangAttrTextNodeDump,

  GenClangAttrNodeTraverse,

  GenClangBasicReader,

  GenClangBasicWriter,

  GenClangDiagsDefs,

  GenClangDiagGroups,

  GenClangDiagsIndexName,

  GenClangCommentNodes,

  GenClangDeclNodes,

  GenClangStmtNodes,

  GenClangTypeNodes,

  GenClangTypeReader,

  GenClangTypeWriter,

  GenClangOpcodes,

  GenClangSACheckers,

  GenClangSyntaxNodeList,

  GenClangSyntaxNodeClasses,

  GenClangCommentHTMLTags,

  GenClangCommentHTMLTagsProperties,

  GenClangCommentHTMLNamedCharacterReferences,

  GenClangCommentCommandInfo,

  GenClangCommentCommandList,

  GenClangOpenCLBuiltins,

  GenClangOpenCLBuiltinTests,

  GenArmNeon,

  GenArmFP16,

  GenArmBF16,

  GenArmNeonSema,

  GenArmNeonTest,

  GenArmMveHeader,

  GenArmMveBuiltinDef,

  GenArmMveBuiltinSema,

  GenArmMveBuiltinCG,

  GenArmMveBuiltinAliases,

  GenArmSveHeader,

  GenArmSveBuiltins,

  GenArmSveBuiltinCG,

  GenArmSveTypeFlags,

  GenArmSveRangeChecks,

  GenArmCdeHeader,

  GenArmCdeBuiltinDef,

  GenArmCdeBuiltinSema,

  GenArmCdeBuiltinCG,

  GenArmCdeBuiltinAliases,

  GenRISCVVectorHeader,

  GenRISCVVectorBuiltins,

  GenRISCVVectorBuiltinCG,

  GenAttrDocs,

  GenDiagDocs,

  GenOptDocs,

  GenDataCollectors,

  GenTestPragmaAttributeSupportedAttributes

};

namespace {

cl::opt<ActionType> Action(

    cl::desc("Action to perform:"),

    cl::values(

        clEnumValN(PrintRecords, "print-records",

                   "Print all records to stdout (default)"),

        clEnumValN(DumpJSON, "dump-json",

                   "Dump all records as machine-readable JSON"),

        clEnumValN(GenClangAttrClasses, "gen-clang-attr-classes",

                   "Generate clang attribute clases"),

        clEnumValN(GenClangAttrParserStringSwitches,

                   "gen-clang-attr-parser-string-switches",

                   "Generate all parser-related attribute string switches"),

        clEnumValN(GenClangAttrSubjectMatchRulesParserStringSwitches,

                   "gen-clang-attr-subject-match-rules-parser-string-switches",

                   "Generate all parser-related attribute subject match rule"

                   "string switches"),

        clEnumValN(GenClangAttrImpl, "gen-clang-attr-impl",

                   "Generate clang attribute implementations"),

        clEnumValN(GenClangAttrList, "gen-clang-attr-list",

                   "Generate a clang attribute list"),

        clEnumValN(GenClangAttrDocTable, "gen-clang-attr-doc-table",

                   "Generate a table of attribute documentation"),

        clEnumValN(GenClangAttrSubjectMatchRuleList,

                   "gen-clang-attr-subject-match-rule-list",

                   "Generate a clang attribute subject match rule list"),

        clEnumValN(GenClangAttrPCHRead, "gen-clang-attr-pch-read",

                   "Generate clang PCH attribute reader"),

        clEnumValN(GenClangAttrPCHWrite, "gen-clang-attr-pch-write",

                   "Generate clang PCH attribute writer"),

        clEnumValN(GenClangAttrHasAttributeImpl,

                   "gen-clang-attr-has-attribute-impl",

                   "Generate a clang attribute spelling list"),

        clEnumValN(GenClangAttrSpellingListIndex,

                   "gen-clang-attr-spelling-index",

                   "Generate a clang attribute spelling index"),

        clEnumValN(GenClangAttrASTVisitor, "gen-clang-attr-ast-visitor",

                   "Generate a recursive AST visitor for clang attributes"),

        clEnumValN(GenClangAttrTemplateInstantiate,

                   "gen-clang-attr-template-instantiate",

                   "Generate a clang template instantiate code"),

        clEnumValN(GenClangAttrParsedAttrList,

                   "gen-clang-attr-parsed-attr-list",

                   "Generate a clang parsed attribute list"),

        clEnumValN(GenClangAttrParsedAttrImpl,

                   "gen-clang-attr-parsed-attr-impl",

                   "Generate the clang parsed attribute helpers"),

        clEnumValN(GenClangAttrParsedAttrKinds,

                   "gen-clang-attr-parsed-attr-kinds",

                   "Generate a clang parsed attribute kinds"),

        clEnumValN(GenClangAttrTextNodeDump, "gen-clang-attr-text-node-dump",

                   "Generate clang attribute text node dumper"),

        clEnumValN(GenClangAttrNodeTraverse, "gen-clang-attr-node-traverse",

                   "Generate clang attribute traverser"),

        clEnumValN(GenClangDiagsDefs, "gen-clang-diags-defs",

                   "Generate Clang diagnostics definitions"),

        clEnumValN(GenClangDiagGroups, "gen-clang-diag-groups",

                   "Generate Clang diagnostic groups"),

        clEnumValN(GenClangDiagsIndexName, "gen-clang-diags-index-name",

                   "Generate Clang diagnostic name index"),

        clEnumValN(GenClangBasicReader, "gen-clang-basic-reader",

                   "Generate Clang BasicReader classes"),

        clEnumValN(GenClangBasicWriter, "gen-clang-basic-writer",

                   "Generate Clang BasicWriter classes"),

        clEnumValN(GenClangCommentNodes, "gen-clang-comment-nodes",

                   "Generate Clang AST comment nodes"),

        clEnumValN(GenClangDeclNodes, "gen-clang-decl-nodes",

                   "Generate Clang AST declaration nodes"),

        clEnumValN(GenClangStmtNodes, "gen-clang-stmt-nodes",

                   "Generate Clang AST statement nodes"),

        clEnumValN(GenClangTypeNodes, "gen-clang-type-nodes",

                   "Generate Clang AST type nodes"),

        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(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,

                   "gen-clang-comment-html-tags-properties",

                   "Generate efficient matchers for HTML tag "

                   "properties"),

        clEnumValN(GenClangCommentHTMLNamedCharacterReferences,

                   "gen-clang-comment-html-named-character-references",

                   "Generate function to translate named character "

                   "references to UTF-8 sequences"),

        clEnumValN(GenClangCommentCommandInfo, "gen-clang-comment-command-info",

                   "Generate command properties for commands that "

                   "are used in documentation comments"),

        clEnumValN(GenClangCommentCommandList, "gen-clang-comment-command-list",

                   "Generate list of commands that are used in "

                   "documentation comments"),

        clEnumValN(GenClangOpenCLBuiltins, "gen-clang-opencl-builtins",

                   "Generate OpenCL builtin declaration handlers"),

        clEnumValN(GenClangOpenCLBuiltinTests, "gen-clang-opencl-builtin-tests",

                   "Generate OpenCL builtin declaration tests"),

        clEnumValN(GenArmNeon, "gen-arm-neon", "Generate arm_neon.h for clang"),

        clEnumValN(GenArmFP16, "gen-arm-fp16", "Generate arm_fp16.h for clang"),

        clEnumValN(GenArmBF16, "gen-arm-bf16", "Generate arm_bf16.h for clang"),

        clEnumValN(GenArmNeonSema, "gen-arm-neon-sema",

                   "Generate ARM NEON sema support for clang"),

        clEnumValN(GenArmNeonTest, "gen-arm-neon-test",

                   "Generate ARM NEON tests for clang"),

        clEnumValN(GenArmSveHeader, "gen-arm-sve-header",

                   "Generate arm_sve.h for clang"),

        clEnumValN(GenArmSveBuiltins, "gen-arm-sve-builtins",

                   "Generate arm_sve_builtins.inc for clang"),

        clEnumValN(GenArmSveBuiltinCG, "gen-arm-sve-builtin-codegen",

                   "Generate arm_sve_builtin_cg_map.inc for clang"),

        clEnumValN(GenArmSveTypeFlags, "gen-arm-sve-typeflags",

                   "Generate arm_sve_typeflags.inc for clang"),

        clEnumValN(GenArmSveRangeChecks, "gen-arm-sve-sema-rangechecks",

                   "Generate arm_sve_sema_rangechecks.inc for clang"),

        clEnumValN(GenArmMveHeader, "gen-arm-mve-header",

                   "Generate arm_mve.h for clang"),

        clEnumValN(GenArmMveBuiltinDef, "gen-arm-mve-builtin-def",

                   "Generate ARM MVE builtin definitions for clang"),

        clEnumValN(GenArmMveBuiltinSema, "gen-arm-mve-builtin-sema",

                   "Generate ARM MVE builtin sema checks for clang"),

        clEnumValN(GenArmMveBuiltinCG, "gen-arm-mve-builtin-codegen",

                   "Generate ARM MVE builtin code-generator for clang"),

        clEnumValN(GenArmMveBuiltinAliases, "gen-arm-mve-builtin-aliases",

                   "Generate list of valid ARM MVE builtin aliases for clang"),

        clEnumValN(GenArmCdeHeader, "gen-arm-cde-header",

                   "Generate arm_cde.h for clang"),

        clEnumValN(GenArmCdeBuiltinDef, "gen-arm-cde-builtin-def",

                   "Generate ARM CDE builtin definitions for clang"),

        clEnumValN(GenArmCdeBuiltinSema, "gen-arm-cde-builtin-sema",

                   "Generate ARM CDE builtin sema checks for clang"),

        clEnumValN(GenArmCdeBuiltinCG, "gen-arm-cde-builtin-codegen",

                   "Generate ARM CDE builtin code-generator for clang"),

        clEnumValN(GenArmCdeBuiltinAliases, "gen-arm-cde-builtin-aliases",

                   "Generate list of valid ARM CDE builtin aliases for clang"),

        clEnumValN(GenRISCVVectorHeader, "gen-riscv-vector-header",

                   "Generate riscv_vector.h for clang"),

        clEnumValN(GenRISCVVectorBuiltins, "gen-riscv-vector-builtins",

                   "Generate riscv_vector_builtins.inc for clang"),

        clEnumValN(GenRISCVVectorBuiltinCG, "gen-riscv-vector-builtin-codegen",

                   "Generate riscv_vector_builtin_cg.inc for clang"),

        clEnumValN(GenAttrDocs, "gen-attr-docs",

                   "Generate attribute documentation"),

        clEnumValN(GenDiagDocs, "gen-diag-docs",

                   "Generate diagnostic documentation"),

        clEnumValN(GenOptDocs, "gen-opt-docs", "Generate option documentation"),

        clEnumValN(GenDataCollectors, "gen-clang-data-collectors",

                   "Generate data collectors for AST nodes"),

        clEnumValN(GenTestPragmaAttributeSupportedAttributes,

                   "gen-clang-test-pragma-attribute-supported-attributes",

                   "Generate a list of attributes supported by #pragma clang "

                   "attribute for testing purposes")));

cl::opt<std::string>

ClangComponent("clang-component",

               cl::desc("Only use warnings from specified component"),

               cl::value_desc("component"), cl::Hidden);

bool ClangTableGenMain(raw_ostream &OS, RecordKeeper &Records) {

  switch (Action) {

  case PrintRecords:

    OS << Records;           // No argument, dump all contents

    break;

  case DumpJSON:

    EmitJSON(Records, OS);

    break;

  case GenClangAttrClasses:

    EmitClangAttrClass(Records, OS);

    break;

  case GenClangAttrParserStringSwitches:

    EmitClangAttrParserStringSwitches(Records, OS);

    break;

  case GenClangAttrSubjectMatchRulesParserStringSwitches:

    EmitClangAttrSubjectMatchRulesParserStringSwitches(Records, OS);

    break;

  case GenClangAttrImpl:

    EmitClangAttrImpl(Records, OS);

    break;

  case GenClangAttrList:

    EmitClangAttrList(Records, OS);

    break;

  case GenClangAttrDocTable:

    EmitClangAttrDocTable(Records, OS);

    break;

  case GenClangAttrSubjectMatchRuleList:

    EmitClangAttrSubjectMatchRuleList(Records, OS);

    break;

  case GenClangAttrPCHRead:

    EmitClangAttrPCHRead(Records, OS);

    break;

  case GenClangAttrPCHWrite:

    EmitClangAttrPCHWrite(Records, OS);

    break;

  case GenClangAttrHasAttributeImpl:

    EmitClangAttrHasAttrImpl(Records, OS);

    break;

  case GenClangAttrSpellingListIndex:

    EmitClangAttrSpellingListIndex(Records, OS);

    break;

  case GenClangAttrASTVisitor:

    EmitClangAttrASTVisitor(Records, OS);

    break;

  case GenClangAttrTemplateInstantiate:

    EmitClangAttrTemplateInstantiate(Records, OS);

    break;

  case GenClangAttrParsedAttrList:

    EmitClangAttrParsedAttrList(Records, OS);

    break;

  case GenClangAttrParsedAttrImpl:

    EmitClangAttrParsedAttrImpl(Records, OS);

    break;

  case GenClangAttrParsedAttrKinds:

    EmitClangAttrParsedAttrKinds(Records, OS);

    break;

  case GenClangAttrTextNodeDump:

    EmitClangAttrTextNodeDump(Records, OS);

    break;

  case GenClangAttrNodeTraverse:

    EmitClangAttrNodeTraverse(Records, OS);

    break;

  case GenClangDiagsDefs:

    EmitClangDiagsDefs(Records, OS, ClangComponent);

    break;

  case GenClangDiagGroups:

    EmitClangDiagGroups(Records, OS);

    break;

  case GenClangDiagsIndexName:

    EmitClangDiagsIndexName(Records, OS);

    break;

  case GenClangCommentNodes:

    EmitClangASTNodes(Records, OS, CommentNodeClassName, "");

    break;

  case GenClangDeclNodes:

    EmitClangASTNodes(Records, OS, DeclNodeClassName, "Decl");

    EmitClangDeclContext(Records, OS);

    break;

  case GenClangStmtNodes:

    EmitClangASTNodes(Records, OS, StmtNodeClassName, "");

    break;

  case GenClangTypeNodes:

    EmitClangTypeNodes(Records, OS);

    break;

  case GenClangTypeReader:

    EmitClangTypeReader(Records, OS);

    break;

  case GenClangTypeWriter:

    EmitClangTypeWriter(Records, OS);

    break;

  case GenClangBasicReader:

    EmitClangBasicReader(Records, OS);

    break;

  case GenClangBasicWriter:

    EmitClangBasicWriter(Records, OS);

    break;

  case GenClangOpcodes:

    EmitClangOpcodes(Records, OS);

    break;

  case GenClangSACheckers:

    EmitClangSACheckers(Records, OS);

    break;

  case GenClangCommentHTMLTags:

    EmitClangCommentHTMLTags(Records, OS);

    break;

  case GenClangCommentHTMLTagsProperties:

    EmitClangCommentHTMLTagsProperties(Records, OS);

    break;

  case GenClangCommentHTMLNamedCharacterReferences:

    EmitClangCommentHTMLNamedCharacterReferences(Records, OS);

    break;

  case GenClangCommentCommandInfo:

    EmitClangCommentCommandInfo(Records, OS);

    break;

  case GenClangCommentCommandList:

    EmitClangCommentCommandList(Records, OS);

    break;

  case GenClangOpenCLBuiltins:

    EmitClangOpenCLBuiltins(Records, OS);

    break;

  case GenClangOpenCLBuiltinTests:

    EmitClangOpenCLBuiltinTests(Records, OS);

    break;

  case GenClangSyntaxNodeList:

    EmitClangSyntaxNodeList(Records, OS);

    break;

  case GenClangSyntaxNodeClasses:

    EmitClangSyntaxNodeClasses(Records, OS);

    break;

  case GenArmNeon:

    EmitNeon(Records, OS);

    break;

  case GenArmFP16:

    EmitFP16(Records, OS);

    break;

  case GenArmBF16:

    EmitBF16(Records, OS);

    break;

  case GenArmNeonSema:

    EmitNeonSema(Records, OS);

    break;

  case GenArmNeonTest:

    EmitNeonTest(Records, OS);

    break;

  case GenArmMveHeader:

    EmitMveHeader(Records, OS);

    break;

  case GenArmMveBuiltinDef:

    EmitMveBuiltinDef(Records, OS);

    break;

  case GenArmMveBuiltinSema:

    EmitMveBuiltinSema(Records, OS);

    break;

  case GenArmMveBuiltinCG:

    EmitMveBuiltinCG(Records, OS);

    break;

  case GenArmMveBuiltinAliases:

    EmitMveBuiltinAliases(Records, OS);

    break;

  case GenArmSveHeader:

    EmitSveHeader(Records, OS);

    break;

  case GenArmSveBuiltins:

    EmitSveBuiltins(Records, OS);

    break;

  case GenArmSveBuiltinCG:

    EmitSveBuiltinCG(Records, OS);

    break;

  case GenArmSveTypeFlags:

    EmitSveTypeFlags(Records, OS);

    break;

  case GenArmSveRangeChecks:

    EmitSveRangeChecks(Records, OS);

    break;

  case GenArmCdeHeader:

    EmitCdeHeader(Records, OS);

    break;

  case GenArmCdeBuiltinDef:

    EmitCdeBuiltinDef(Records, OS);

    break;

  case GenArmCdeBuiltinSema:

    EmitCdeBuiltinSema(Records, OS);

    break;

  case GenArmCdeBuiltinCG:

    EmitCdeBuiltinCG(Records, OS);

    break;

  case GenArmCdeBuiltinAliases:

    EmitCdeBuiltinAliases(Records, OS);

    break;

  case GenRISCVVectorHeader:

    EmitRVVHeader(Records, OS);

    break;

  case GenRISCVVectorBuiltins:

    EmitRVVBuiltins(Records, OS);

    break;

  case GenRISCVVectorBuiltinCG:

    EmitRVVBuiltinCG(Records, OS);

    break;

  case GenAttrDocs:

    EmitClangAttrDocs(Records, OS);

    break;

  case GenDiagDocs:

    EmitClangDiagDocs(Records, OS);

    break;

  case GenOptDocs:

    EmitClangOptDocs(Records, OS);

    break;

  case GenDataCollectors:

    EmitClangDataCollectors(Records, OS);

    break;

  case GenTestPragmaAttributeSupportedAttributes:

    EmitTestPragmaAttributeSupportedAttributes(Records, OS);

    break;

  }

  return false;

}

}

int main(int argc, char **argv) {

  sys::PrintStackTraceOnErrorSignal(argv[0]);

  PrettyStackTraceProgram X(argc, argv);

  cl::ParseCommandLineOptions(argc, argv);

  llvm_shutdown_obj Y;

  return TableGenMain(argv[0], &ClangTableGenMain);

}

#ifdef __has_feature

#if __has_feature(address_sanitizer)

#include <sanitizer/lsan_interface.h>

// Disable LeakSanitizer for this binary as it has too many leaks that are not

// very interesting to fix. See compiler-rt/include/sanitizer/lsan_interface.h .

int __lsan_is_turned_off() { return 1; }

#endif  // __has_feature(address_sanitizer)

#endif  // defined(__has_feature)