| //===-- 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 "ASTTableGen.h" | |
| #include "TableGenBackends.h" // Declares all backends. | |
| #include "llvm/Support/CommandLine.h" | |
| #include "llvm/Support/ManagedStatic.h" | |
| #include "llvm/Support/PrettyStackTrace.h" | |
| #include "llvm/Support/Signals.h" | |
| #include "llvm/TableGen/Main.h" | |
| #include "llvm/TableGen/Record.h" | |
| using namespace llvm; | |
| using namespace clang; | |
| enum ActionType { | |
| PrintRecords, | |
| DumpJSON, | |
| GenCIRLowering, | |
| GenClangAttrClasses, | |
| GenClangAttrParserStringSwitches, | |
| GenClangAttrSubjectMatchRulesParserStringSwitches, | |
| GenClangAttrImpl, | |
| GenClangAttrList, | |
| GenClangAttrDocTable, | |
| GenClangAttrSubjectMatchRuleList, | |
| GenClangAttrPCHRead, | |
| GenClangAttrPCHWrite, | |
| GenClangRegularKeywordAttributeInfo, | |
| GenClangAttrHasAttributeImpl, | |
| GenClangAttrSpellingListIndex, | |
| GenClangAttrASTVisitor, | |
| GenClangAttrTemplateInstantiate, | |
| GenClangAttrParsedAttrList, | |
| GenClangAttrParsedAttrImpl, | |
| GenClangAttrParsedAttrKinds, | |
| GenClangAttrIsTypeDependent, | |
| GenClangAttrTextNodeDump, | |
| GenClangAttrNodeTraverse, | |
| GenClangAttrUndocumentedAttrList, | |
| GenClangBasicReader, | |
| GenClangBasicWriter, | |
| GenClangBuiltins, | |
| GenClangBuiltinTemplates, | |
| GenClangDiagsCompatIDs, | |
| GenClangDiagsDefs, | |
| GenClangDiagsEnums, | |
| GenClangDiagGroups, | |
| GenClangDiagsIndexName, | |
| GenClangDiagsStableIDs, | |
| GenClangDiagsInterface, | |
| GenClangCommentNodes, | |
| GenClangDeclNodes, | |
| GenClangStmtNodes, | |
| GenClangTypeNodes, | |
| GenClangTypeReader, | |
| GenClangTypeWriter, | |
| GenClangOpcodes, | |
| GenClangSACheckers, | |
| GenClangSyntaxNodeList, | |
| GenClangSyntaxNodeClasses, | |
| GenClangCommentHTMLTags, | |
| GenClangCommentHTMLTagsProperties, | |
| GenClangCommentHTMLNamedCharacterReferences, | |
| GenClangCommentCommandInfo, | |
| GenClangCommentCommandList, | |
| GenClangOpenCLBuiltins, | |
| GenClangOpenCLBuiltinHeader, | |
| GenClangOpenCLBuiltinTests, | |
| GenCXX11AttributeInfo, | |
| GenAttributeSpellingList, | |
| GenArmNeon, | |
| GenArmFP16, | |
| GenArmBF16, | |
| GenArmVectorType, | |
| GenArmNeonSema, | |
| GenArmNeonTest, | |
| GenArmImmCheckTypes, | |
| GenArmMveHeader, | |
| GenArmMveBuiltinDef, | |
| GenArmMveBuiltinSema, | |
| GenArmMveBuiltinCG, | |
| GenArmMveBuiltinAliases, | |
| GenArmSveHeader, | |
| GenArmSveBuiltins, | |
| GenArmSveBuiltinsJSON, | |
| GenArmSveBuiltinCG, | |
| GenArmSveTypeFlags, | |
| GenArmSveRangeChecks, | |
| GenArmSveStreamingAttrs, | |
| GenArmSmeHeader, | |
| GenArmSmeBuiltins, | |
| GenArmSmeBuiltinsJSON, | |
| GenArmSmeBuiltinCG, | |
| GenArmSmeRangeChecks, | |
| GenArmSmeStreamingAttrs, | |
| GenArmSmeBuiltinZAState, | |
| GenArmCdeHeader, | |
| GenArmCdeBuiltinDef, | |
| GenArmCdeBuiltinSema, | |
| GenArmCdeBuiltinCG, | |
| GenArmCdeBuiltinAliases, | |
| GenRISCVVectorHeader, | |
| GenRISCVVectorBuiltins, | |
| GenRISCVVectorBuiltinCG, | |
| GenRISCVVectorBuiltinSema, | |
| GenRISCVSiFiveVectorBuiltins, | |
| GenRISCVSiFiveVectorBuiltinCG, | |
| GenRISCVSiFiveVectorBuiltinSema, | |
| GenRISCVAndesVectorBuiltins, | |
| GenRISCVAndesVectorBuiltinCG, | |
| GenRISCVAndesVectorBuiltinSema, | |
| GenHLSLAliasIntrinsics, | |
| GenHLSLInlineIntrinsics, | |
| GenAttrDocs, | |
| GenBuiltinDocs, | |
| GenDiagDocs, | |
| GenOptDocs, | |
| GenDataCollectors, | |
| GenTestPragmaAttributeSupportedAttributes, | |
| GenClangBuiltinTraits | |
| }; | |
| 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(GenCIRLowering, "gen-cir-lowering", | |
| "Generate CIR operation lowering patterns"), | |
| 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(GenClangRegularKeywordAttributeInfo, | |
| "gen-clang-regular-keyword-attr-info", | |
| "Generate a list of regular keyword attributes with info " | |
| "about their arguments"), | |
| 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(GenClangAttrIsTypeDependent, | |
| "gen-clang-attr-is-type-dependent", | |
| "Generate clang is type dependent attribute code"), | |
| 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(GenClangAttrUndocumentedAttrList, | |
| "gen-clang-attr-undocumented-list", | |
| "Generate a list of undocumented attributes"), | |
| clEnumValN(GenClangBuiltins, "gen-clang-builtins", | |
| "Generate clang builtins list"), | |
| clEnumValN(GenClangBuiltinTemplates, "gen-clang-builtin-templates", | |
| "Generate clang builtins list"), | |
| clEnumValN(GenClangDiagsCompatIDs, "gen-clang-diags-compat-ids", | |
| "Generate Clang diagnostic compatibility ids"), | |
| clEnumValN(GenClangDiagsDefs, "gen-clang-diags-defs", | |
| "Generate Clang diagnostics definitions"), | |
| clEnumValN(GenClangDiagsEnums, "gen-clang-diags-enums", | |
| "Generate Clang diagnostic enums for selects"), | |
| clEnumValN(GenClangDiagGroups, "gen-clang-diag-groups", | |
| "Generate Clang diagnostic groups"), | |
| clEnumValN(GenClangDiagsIndexName, "gen-clang-diags-index-name", | |
| "Generate Clang diagnostic name index"), | |
| clEnumValN(GenClangDiagsStableIDs, "gen-clang-diags-stable-ids", | |
| "Generate Clang diagnostic stable IDs"), | |
| clEnumValN(GenClangDiagsInterface, "gen-clang-diags-iface", | |
| "Generate Clang diagnostic interface headers"), | |
| 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(GenClangOpenCLBuiltinHeader, | |
| "gen-clang-opencl-builtin-header", | |
| "Generate OpenCL builtin header"), | |
| clEnumValN(GenClangOpenCLBuiltinTests, "gen-clang-opencl-builtin-tests", | |
| "Generate OpenCL builtin declaration tests"), | |
| clEnumValN(GenCXX11AttributeInfo, "gen-cxx11-attribute-info", | |
| "Generate CXX11 attributes info"), | |
| clEnumValN(GenAttributeSpellingList, "gen-attribute-spelling-list", | |
| "Generate attribute spelling list"), | |
| 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(GenArmVectorType, "gen-arm-vector-type", | |
| "Generate arm_vector_types.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( | |
| GenArmImmCheckTypes, "gen-arm-immcheck-types", | |
| "Generate arm_immcheck_types.inc (immediate range check types)" | |
| " 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(GenArmSveBuiltinsJSON, "gen-arm-sve-builtins-json", | |
| "Generate arm_sve_buitins.json"), | |
| 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(GenArmSveStreamingAttrs, "gen-arm-sve-streaming-attrs", | |
| "Generate arm_sve_streaming_attrs.inc for clang"), | |
| clEnumValN(GenArmSmeHeader, "gen-arm-sme-header", | |
| "Generate arm_sme.h for clang"), | |
| clEnumValN(GenArmSmeBuiltins, "gen-arm-sme-builtins", | |
| "Generate arm_sme_builtins.inc for clang"), | |
| clEnumValN(GenArmSmeBuiltinsJSON, "gen-arm-sme-builtins-json", | |
| "Generate arm_sme_buitins.json"), | |
| clEnumValN(GenArmSmeBuiltinCG, "gen-arm-sme-builtin-codegen", | |
| "Generate arm_sme_builtin_cg_map.inc for clang"), | |
| clEnumValN(GenArmSmeRangeChecks, "gen-arm-sme-sema-rangechecks", | |
| "Generate arm_sme_sema_rangechecks.inc for clang"), | |
| clEnumValN(GenArmSmeStreamingAttrs, "gen-arm-sme-streaming-attrs", | |
| "Generate arm_sme_streaming_attrs.inc for clang"), | |
| clEnumValN(GenArmSmeBuiltinZAState, "gen-arm-sme-builtin-za-state", | |
| "Generate arm_sme_builtins_za_state.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(GenRISCVVectorBuiltinSema, "gen-riscv-vector-builtin-sema", | |
| "Generate riscv_vector_builtin_sema.inc for clang"), | |
| clEnumValN(GenRISCVSiFiveVectorBuiltins, | |
| "gen-riscv-sifive-vector-builtins", | |
| "Generate riscv_sifive_vector_builtins.inc for clang"), | |
| clEnumValN(GenRISCVSiFiveVectorBuiltinCG, | |
| "gen-riscv-sifive-vector-builtin-codegen", | |
| "Generate riscv_sifive_vector_builtin_cg.inc for clang"), | |
| clEnumValN(GenRISCVSiFiveVectorBuiltinSema, | |
| "gen-riscv-sifive-vector-builtin-sema", | |
| "Generate riscv_sifive_vector_builtin_sema.inc for clang"), | |
| clEnumValN(GenRISCVAndesVectorBuiltins, | |
| "gen-riscv-andes-vector-builtins", | |
| "Generate riscv_andes_vector_builtins.inc for clang"), | |
| clEnumValN(GenRISCVAndesVectorBuiltinCG, | |
| "gen-riscv-andes-vector-builtin-codegen", | |
| "Generate riscv_andes_vector_builtin_cg.inc for clang"), | |
| clEnumValN(GenRISCVAndesVectorBuiltinSema, | |
| "gen-riscv-andes-vector-builtin-sema", | |
| "Generate riscv_andes_vector_builtin_sema.inc for clang"), | |
| clEnumValN(GenHLSLAliasIntrinsics, "gen-hlsl-alias-intrinsics", | |
| "Generate HLSL alias intrinsic overloads for " | |
| "hlsl_alias_intrinsics.h"), | |
| clEnumValN(GenHLSLInlineIntrinsics, "gen-hlsl-inline-intrinsics", | |
| "Generate HLSL inline intrinsic overloads for " | |
| "hlsl_intrinsics.h"), | |
| clEnumValN(GenAttrDocs, "gen-attr-docs", | |
| "Generate attribute documentation"), | |
| clEnumValN(GenBuiltinDocs, "gen-builtin-docs", | |
| "Generate builtin 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"), | |
| clEnumValN(GenClangBuiltinTraits, "gen-clang-builtin-traits", | |
| "Generate BuiltinTraits.inc for clang"))); | |
| 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, const RecordKeeper &Records) { | |
| switch (Action) { | |
| case PrintRecords: | |
| OS << Records; // No argument, dump all contents | |
| break; | |
| case DumpJSON: | |
| EmitJSON(Records, OS); | |
| break; | |
| case GenCIRLowering: | |
| EmitCIRLowering(Records, OS); | |
| break; | |
| case GenClangAttrClasses: | |
| EmitClangAttrClass(Records, OS); | |
| break; | |
| case GenClangAttrParserStringSwitches: | |
| EmitClangAttrParserStringSwitches(Records, OS); | |
| break; | |
| case GenClangAttrSubjectMatchRulesParserStringSwitches: | |
| EmitClangAttrSubjectMatchRulesParserStringSwitches(Records, OS); | |
| break; | |
| case GenCXX11AttributeInfo: | |
| EmitCXX11AttributeInfo(Records, OS); | |
| break; | |
| case GenAttributeSpellingList: | |
| EmitAttributeSpellingList(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 GenClangRegularKeywordAttributeInfo: | |
| EmitClangRegularKeywordAttributeInfo(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 GenClangAttrIsTypeDependent: | |
| EmitClangAttrIsTypeDependent(Records, OS); | |
| break; | |
| case GenClangAttrTextNodeDump: | |
| EmitClangAttrTextNodeDump(Records, OS); | |
| break; | |
| case GenClangAttrNodeTraverse: | |
| EmitClangAttrNodeTraverse(Records, OS); | |
| break; | |
| case GenClangAttrUndocumentedAttrList: | |
| EmitClangUndocumentedAttrList(Records, OS); | |
| break; | |
| case GenClangBuiltins: | |
| EmitClangBuiltins(Records, OS); | |
| break; | |
| case GenClangBuiltinTemplates: | |
| EmitClangBuiltinTemplates(Records, OS); | |
| break; | |
| case GenClangDiagsCompatIDs: | |
| EmitClangDiagsCompatIDs(Records, OS, ClangComponent); | |
| break; | |
| case GenClangDiagsDefs: | |
| EmitClangDiagsDefs(Records, OS, ClangComponent); | |
| break; | |
| case GenClangDiagsEnums: | |
| EmitClangDiagsEnums(Records, OS, ClangComponent); | |
| break; | |
| case GenClangDiagGroups: | |
| EmitClangDiagGroups(Records, OS); | |
| break; | |
| case GenClangDiagsIndexName: | |
| EmitClangDiagsIndexName(Records, OS); | |
| break; | |
| case GenClangDiagsStableIDs: | |
| EmitClangDiagsStableIDs(Records, OS); | |
| break; | |
| case GenClangDiagsInterface: | |
| EmitClangDiagsInterface(OS, ClangComponent); | |
| break; | |
| case GenClangCommentNodes: | |
| EmitClangASTNodes(Records, OS, CommentNodeClassName, ""); | |
| break; | |
| case GenClangDeclNodes: | |
| EmitClangASTNodes(Records, OS, DeclNodeClassName, "Decl", | |
| DeclContextNodeClassName); | |
| 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 GenClangOpenCLBuiltinHeader: | |
| EmitClangOpenCLBuiltinHeader(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 GenArmVectorType: | |
| EmitVectorTypes(Records, OS); | |
| break; | |
| case GenArmBF16: | |
| EmitBF16(Records, OS); | |
| break; | |
| case GenArmNeonSema: | |
| EmitNeonSema(Records, OS); | |
| break; | |
| case GenArmNeonTest: | |
| EmitNeonTest(Records, OS); | |
| break; | |
| case GenArmImmCheckTypes: | |
| EmitImmCheckTypes(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 GenArmSveBuiltinsJSON: | |
| EmitSveBuiltinsJSON(Records, OS); | |
| break; | |
| case GenArmSveBuiltinCG: | |
| EmitSveBuiltinCG(Records, OS); | |
| break; | |
| case GenArmSveTypeFlags: | |
| EmitSveTypeFlags(Records, OS); | |
| break; | |
| case GenArmSveRangeChecks: | |
| EmitSveRangeChecks(Records, OS); | |
| break; | |
| case GenArmSveStreamingAttrs: | |
| EmitSveStreamingAttrs(Records, OS); | |
| break; | |
| case GenArmSmeHeader: | |
| EmitSmeHeader(Records, OS); | |
| break; | |
| case GenArmSmeBuiltins: | |
| EmitSmeBuiltins(Records, OS); | |
| break; | |
| case GenArmSmeBuiltinsJSON: | |
| EmitSmeBuiltinsJSON(Records, OS); | |
| break; | |
| case GenArmSmeBuiltinCG: | |
| EmitSmeBuiltinCG(Records, OS); | |
| break; | |
| case GenArmSmeRangeChecks: | |
| EmitSmeRangeChecks(Records, OS); | |
| break; | |
| case GenArmSmeStreamingAttrs: | |
| EmitSmeStreamingAttrs(Records, OS); | |
| break; | |
| case GenArmSmeBuiltinZAState: | |
| EmitSmeBuiltinZAState(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 GenRISCVVectorBuiltinSema: | |
| EmitRVVBuiltinSema(Records, OS); | |
| break; | |
| case GenRISCVSiFiveVectorBuiltins: | |
| EmitRVVBuiltins(Records, OS); | |
| break; | |
| case GenRISCVSiFiveVectorBuiltinCG: | |
| EmitRVVBuiltinCG(Records, OS); | |
| break; | |
| case GenRISCVSiFiveVectorBuiltinSema: | |
| EmitRVVBuiltinSema(Records, OS); | |
| break; | |
| case GenRISCVAndesVectorBuiltins: | |
| EmitRVVBuiltins(Records, OS); | |
| break; | |
| case GenRISCVAndesVectorBuiltinCG: | |
| EmitRVVBuiltinCG(Records, OS); | |
| break; | |
| case GenRISCVAndesVectorBuiltinSema: | |
| EmitRVVBuiltinSema(Records, OS); | |
| break; | |
| case GenHLSLAliasIntrinsics: | |
| EmitHLSLAliasIntrinsics(Records, OS); | |
| break; | |
| case GenHLSLInlineIntrinsics: | |
| EmitHLSLInlineIntrinsics(Records, OS); | |
| break; | |
| case GenAttrDocs: | |
| EmitClangAttrDocs(Records, OS); | |
| break; | |
| case GenBuiltinDocs: | |
| EmitClangBuiltinDocs(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; | |
| case GenClangBuiltinTraits: | |
| EmitClangBuiltinTraits(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) |