1//===-- TableGen.cpp - Top-Level TableGen implementation for Clang --------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file contains the main function for Clang's TableGen.
10//
11//===----------------------------------------------------------------------===//
12
13#include "ASTTableGen.h"
14#include "TableGenBackends.h" // Declares all backends.
15#include "llvm/Support/CommandLine.h"
16#include "llvm/Support/ManagedStatic.h"
17#include "llvm/Support/PrettyStackTrace.h"
18#include "llvm/Support/Signals.h"
19#include "llvm/TableGen/Main.h"
20#include "llvm/TableGen/Record.h"
21
22using namespace llvm;
23using namespace clang;
24
25enum ActionType {
26 PrintRecords,
27 DumpJSON,
28 GenCIRLowering,
29 GenClangAttrClasses,
30 GenClangAttrParserStringSwitches,
31 GenClangAttrSubjectMatchRulesParserStringSwitches,
32 GenClangAttrImpl,
33 GenClangAttrList,
34 GenClangAttrDocTable,
35 GenClangAttrSubjectMatchRuleList,
36 GenClangAttrPCHRead,
37 GenClangAttrPCHWrite,
38 GenClangRegularKeywordAttributeInfo,
39 GenClangAttrHasAttributeImpl,
40 GenClangAttrSpellingListIndex,
41 GenClangAttrASTVisitor,
42 GenClangAttrTemplateInstantiate,
43 GenClangAttrParsedAttrList,
44 GenClangAttrParsedAttrImpl,
45 GenClangAttrParsedAttrKinds,
46 GenClangAttrIsTypeDependent,
47 GenClangAttrTextNodeDump,
48 GenClangAttrNodeTraverse,
49 GenClangAttrUndocumentedAttrList,
50 GenClangBasicReader,
51 GenClangBasicWriter,
52 GenClangBuiltins,
53 GenClangBuiltinTemplates,
54 GenClangDiagsCompatIDs,
55 GenClangDiagsDefs,
56 GenClangDiagsEnums,
57 GenClangDiagGroups,
58 GenClangDiagsIndexName,
59 GenClangDiagsStableIDs,
60 GenClangDiagsInterface,
61 GenClangCommentNodes,
62 GenClangDeclNodes,
63 GenClangStmtNodes,
64 GenClangTypeNodes,
65 GenClangTypeReader,
66 GenClangTypeWriter,
67 GenClangOpcodes,
68 GenClangSACheckers,
69 GenClangSyntaxNodeList,
70 GenClangSyntaxNodeClasses,
71 GenClangCommentHTMLTags,
72 GenClangCommentHTMLTagsProperties,
73 GenClangCommentHTMLNamedCharacterReferences,
74 GenClangCommentCommandInfo,
75 GenClangCommentCommandList,
76 GenClangOpenCLBuiltins,
77 GenClangOpenCLBuiltinHeader,
78 GenClangOpenCLBuiltinTests,
79 GenCXX11AttributeInfo,
80 GenAttributeSpellingList,
81 GenArmNeon,
82 GenArmFP16,
83 GenArmBF16,
84 GenArmVectorType,
85 GenArmNeonSema,
86 GenArmNeonTest,
87 GenArmImmCheckTypes,
88 GenArmMveHeader,
89 GenArmMveBuiltinDef,
90 GenArmMveBuiltinSema,
91 GenArmMveBuiltinCG,
92 GenArmMveBuiltinAliases,
93 GenArmSveHeader,
94 GenArmSveBuiltins,
95 GenArmSveBuiltinsJSON,
96 GenArmSveBuiltinCG,
97 GenArmSveTypeFlags,
98 GenArmSveRangeChecks,
99 GenArmSveStreamingAttrs,
100 GenArmSmeHeader,
101 GenArmSmeBuiltins,
102 GenArmSmeBuiltinsJSON,
103 GenArmSmeBuiltinCG,
104 GenArmSmeRangeChecks,
105 GenArmSmeStreamingAttrs,
106 GenArmSmeBuiltinZAState,
107 GenArmCdeHeader,
108 GenArmCdeBuiltinDef,
109 GenArmCdeBuiltinSema,
110 GenArmCdeBuiltinCG,
111 GenArmCdeBuiltinAliases,
112 GenRISCVVectorHeader,
113 GenRISCVVectorBuiltins,
114 GenRISCVVectorBuiltinCG,
115 GenRISCVVectorBuiltinSema,
116 GenRISCVSiFiveVectorBuiltins,
117 GenRISCVSiFiveVectorBuiltinCG,
118 GenRISCVSiFiveVectorBuiltinSema,
119 GenRISCVAndesVectorBuiltins,
120 GenRISCVAndesVectorBuiltinCG,
121 GenRISCVAndesVectorBuiltinSema,
122 GenHLSLAliasIntrinsics,
123 GenHLSLInlineIntrinsics,
124 GenAttrDocs,
125 GenBuiltinDocs,
126 GenDiagDocs,
127 GenOptDocs,
128 GenDataCollectors,
129 GenTestPragmaAttributeSupportedAttributes,
130 GenClangTraits
131};
132
133namespace {
134cl::opt<ActionType> Action(
135 cl::desc("Action to perform:"),
136 cl::values(
137 clEnumValN(PrintRecords, "print-records",
138 "Print all records to stdout (default)"),
139 clEnumValN(DumpJSON, "dump-json",
140 "Dump all records as machine-readable JSON"),
141 clEnumValN(GenCIRLowering, "gen-cir-lowering",
142 "Generate CIR operation lowering patterns"),
143 clEnumValN(GenClangAttrClasses, "gen-clang-attr-classes",
144 "Generate clang attribute clases"),
145 clEnumValN(GenClangAttrParserStringSwitches,
146 "gen-clang-attr-parser-string-switches",
147 "Generate all parser-related attribute string switches"),
148 clEnumValN(GenClangAttrSubjectMatchRulesParserStringSwitches,
149 "gen-clang-attr-subject-match-rules-parser-string-switches",
150 "Generate all parser-related attribute subject match rule"
151 "string switches"),
152 clEnumValN(GenClangAttrImpl, "gen-clang-attr-impl",
153 "Generate clang attribute implementations"),
154 clEnumValN(GenClangAttrList, "gen-clang-attr-list",
155 "Generate a clang attribute list"),
156 clEnumValN(GenClangAttrDocTable, "gen-clang-attr-doc-table",
157 "Generate a table of attribute documentation"),
158 clEnumValN(GenClangAttrSubjectMatchRuleList,
159 "gen-clang-attr-subject-match-rule-list",
160 "Generate a clang attribute subject match rule list"),
161 clEnumValN(GenClangAttrPCHRead, "gen-clang-attr-pch-read",
162 "Generate clang PCH attribute reader"),
163 clEnumValN(GenClangAttrPCHWrite, "gen-clang-attr-pch-write",
164 "Generate clang PCH attribute writer"),
165 clEnumValN(GenClangRegularKeywordAttributeInfo,
166 "gen-clang-regular-keyword-attr-info",
167 "Generate a list of regular keyword attributes with info "
168 "about their arguments"),
169 clEnumValN(GenClangAttrHasAttributeImpl,
170 "gen-clang-attr-has-attribute-impl",
171 "Generate a clang attribute spelling list"),
172 clEnumValN(GenClangAttrSpellingListIndex,
173 "gen-clang-attr-spelling-index",
174 "Generate a clang attribute spelling index"),
175 clEnumValN(GenClangAttrASTVisitor, "gen-clang-attr-ast-visitor",
176 "Generate a recursive AST visitor for clang attributes"),
177 clEnumValN(GenClangAttrTemplateInstantiate,
178 "gen-clang-attr-template-instantiate",
179 "Generate a clang template instantiate code"),
180 clEnumValN(GenClangAttrParsedAttrList,
181 "gen-clang-attr-parsed-attr-list",
182 "Generate a clang parsed attribute list"),
183 clEnumValN(GenClangAttrParsedAttrImpl,
184 "gen-clang-attr-parsed-attr-impl",
185 "Generate the clang parsed attribute helpers"),
186 clEnumValN(GenClangAttrParsedAttrKinds,
187 "gen-clang-attr-parsed-attr-kinds",
188 "Generate a clang parsed attribute kinds"),
189 clEnumValN(GenClangAttrIsTypeDependent,
190 "gen-clang-attr-is-type-dependent",
191 "Generate clang is type dependent attribute code"),
192 clEnumValN(GenClangAttrTextNodeDump, "gen-clang-attr-text-node-dump",
193 "Generate clang attribute text node dumper"),
194 clEnumValN(GenClangAttrNodeTraverse, "gen-clang-attr-node-traverse",
195 "Generate clang attribute traverser"),
196 clEnumValN(GenClangAttrUndocumentedAttrList,
197 "gen-clang-attr-undocumented-list",
198 "Generate a list of undocumented attributes"),
199 clEnumValN(GenClangBuiltins, "gen-clang-builtins",
200 "Generate clang builtins list"),
201 clEnumValN(GenClangBuiltinTemplates, "gen-clang-builtin-templates",
202 "Generate clang builtins list"),
203 clEnumValN(GenClangDiagsCompatIDs, "gen-clang-diags-compat-ids",
204 "Generate Clang diagnostic compatibility ids"),
205 clEnumValN(GenClangDiagsDefs, "gen-clang-diags-defs",
206 "Generate Clang diagnostics definitions"),
207 clEnumValN(GenClangDiagsEnums, "gen-clang-diags-enums",
208 "Generate Clang diagnostic enums for selects"),
209 clEnumValN(GenClangDiagGroups, "gen-clang-diag-groups",
210 "Generate Clang diagnostic groups"),
211 clEnumValN(GenClangDiagsIndexName, "gen-clang-diags-index-name",
212 "Generate Clang diagnostic name index"),
213 clEnumValN(GenClangDiagsStableIDs, "gen-clang-diags-stable-ids",
214 "Generate Clang diagnostic stable IDs"),
215 clEnumValN(GenClangDiagsInterface, "gen-clang-diags-iface",
216 "Generate Clang diagnostic interface headers"),
217 clEnumValN(GenClangBasicReader, "gen-clang-basic-reader",
218 "Generate Clang BasicReader classes"),
219 clEnumValN(GenClangBasicWriter, "gen-clang-basic-writer",
220 "Generate Clang BasicWriter classes"),
221 clEnumValN(GenClangCommentNodes, "gen-clang-comment-nodes",
222 "Generate Clang AST comment nodes"),
223 clEnumValN(GenClangDeclNodes, "gen-clang-decl-nodes",
224 "Generate Clang AST declaration nodes"),
225 clEnumValN(GenClangStmtNodes, "gen-clang-stmt-nodes",
226 "Generate Clang AST statement nodes"),
227 clEnumValN(GenClangTypeNodes, "gen-clang-type-nodes",
228 "Generate Clang AST type nodes"),
229 clEnumValN(GenClangTypeReader, "gen-clang-type-reader",
230 "Generate Clang AbstractTypeReader class"),
231 clEnumValN(GenClangTypeWriter, "gen-clang-type-writer",
232 "Generate Clang AbstractTypeWriter class"),
233 clEnumValN(GenClangOpcodes, "gen-clang-opcodes",
234 "Generate Clang constexpr interpreter opcodes"),
235 clEnumValN(GenClangSACheckers, "gen-clang-sa-checkers",
236 "Generate Clang Static Analyzer checkers"),
237 clEnumValN(GenClangSyntaxNodeList, "gen-clang-syntax-node-list",
238 "Generate list of Clang Syntax Tree node types"),
239 clEnumValN(GenClangSyntaxNodeClasses, "gen-clang-syntax-node-classes",
240 "Generate definitions of Clang Syntax Tree node clasess"),
241 clEnumValN(GenClangCommentHTMLTags, "gen-clang-comment-html-tags",
242 "Generate efficient matchers for HTML tag "
243 "names that are used in documentation comments"),
244 clEnumValN(GenClangCommentHTMLTagsProperties,
245 "gen-clang-comment-html-tags-properties",
246 "Generate efficient matchers for HTML tag "
247 "properties"),
248 clEnumValN(GenClangCommentHTMLNamedCharacterReferences,
249 "gen-clang-comment-html-named-character-references",
250 "Generate function to translate named character "
251 "references to UTF-8 sequences"),
252 clEnumValN(GenClangCommentCommandInfo, "gen-clang-comment-command-info",
253 "Generate command properties for commands that "
254 "are used in documentation comments"),
255 clEnumValN(GenClangCommentCommandList, "gen-clang-comment-command-list",
256 "Generate list of commands that are used in "
257 "documentation comments"),
258 clEnumValN(GenClangOpenCLBuiltins, "gen-clang-opencl-builtins",
259 "Generate OpenCL builtin declaration handlers"),
260 clEnumValN(GenClangOpenCLBuiltinHeader,
261 "gen-clang-opencl-builtin-header",
262 "Generate OpenCL builtin header"),
263 clEnumValN(GenClangOpenCLBuiltinTests, "gen-clang-opencl-builtin-tests",
264 "Generate OpenCL builtin declaration tests"),
265 clEnumValN(GenCXX11AttributeInfo, "gen-cxx11-attribute-info",
266 "Generate CXX11 attributes info"),
267 clEnumValN(GenAttributeSpellingList, "gen-attribute-spelling-list",
268 "Generate attribute spelling list"),
269 clEnumValN(GenArmNeon, "gen-arm-neon", "Generate arm_neon.h for clang"),
270 clEnumValN(GenArmFP16, "gen-arm-fp16", "Generate arm_fp16.h for clang"),
271 clEnumValN(GenArmBF16, "gen-arm-bf16", "Generate arm_bf16.h for clang"),
272 clEnumValN(GenArmVectorType, "gen-arm-vector-type",
273 "Generate arm_vector_types.h for clang"),
274 clEnumValN(GenArmNeonSema, "gen-arm-neon-sema",
275 "Generate ARM NEON sema support for clang"),
276 clEnumValN(GenArmNeonTest, "gen-arm-neon-test",
277 "Generate ARM NEON tests for clang"),
278 clEnumValN(
279 GenArmImmCheckTypes, "gen-arm-immcheck-types",
280 "Generate arm_immcheck_types.inc (immediate range check types)"
281 " for clang"),
282 clEnumValN(GenArmSveHeader, "gen-arm-sve-header",
283 "Generate arm_sve.h for clang"),
284 clEnumValN(GenArmSveBuiltins, "gen-arm-sve-builtins",
285 "Generate arm_sve_builtins.inc for clang"),
286 clEnumValN(GenArmSveBuiltinsJSON, "gen-arm-sve-builtins-json",
287 "Generate arm_sve_buitins.json"),
288 clEnumValN(GenArmSveBuiltinCG, "gen-arm-sve-builtin-codegen",
289 "Generate arm_sve_builtin_cg_map.inc for clang"),
290 clEnumValN(GenArmSveTypeFlags, "gen-arm-sve-typeflags",
291 "Generate arm_sve_typeflags.inc for clang"),
292 clEnumValN(GenArmSveRangeChecks, "gen-arm-sve-sema-rangechecks",
293 "Generate arm_sve_sema_rangechecks.inc for clang"),
294 clEnumValN(GenArmSveStreamingAttrs, "gen-arm-sve-streaming-attrs",
295 "Generate arm_sve_streaming_attrs.inc for clang"),
296 clEnumValN(GenArmSmeHeader, "gen-arm-sme-header",
297 "Generate arm_sme.h for clang"),
298 clEnumValN(GenArmSmeBuiltins, "gen-arm-sme-builtins",
299 "Generate arm_sme_builtins.inc for clang"),
300 clEnumValN(GenArmSmeBuiltinsJSON, "gen-arm-sme-builtins-json",
301 "Generate arm_sme_buitins.json"),
302 clEnumValN(GenArmSmeBuiltinCG, "gen-arm-sme-builtin-codegen",
303 "Generate arm_sme_builtin_cg_map.inc for clang"),
304 clEnumValN(GenArmSmeRangeChecks, "gen-arm-sme-sema-rangechecks",
305 "Generate arm_sme_sema_rangechecks.inc for clang"),
306 clEnumValN(GenArmSmeStreamingAttrs, "gen-arm-sme-streaming-attrs",
307 "Generate arm_sme_streaming_attrs.inc for clang"),
308 clEnumValN(GenArmSmeBuiltinZAState, "gen-arm-sme-builtin-za-state",
309 "Generate arm_sme_builtins_za_state.inc for clang"),
310 clEnumValN(GenArmMveHeader, "gen-arm-mve-header",
311 "Generate arm_mve.h for clang"),
312 clEnumValN(GenArmMveBuiltinDef, "gen-arm-mve-builtin-def",
313 "Generate ARM MVE builtin definitions for clang"),
314 clEnumValN(GenArmMveBuiltinSema, "gen-arm-mve-builtin-sema",
315 "Generate ARM MVE builtin sema checks for clang"),
316 clEnumValN(GenArmMveBuiltinCG, "gen-arm-mve-builtin-codegen",
317 "Generate ARM MVE builtin code-generator for clang"),
318 clEnumValN(GenArmMveBuiltinAliases, "gen-arm-mve-builtin-aliases",
319 "Generate list of valid ARM MVE builtin aliases for clang"),
320 clEnumValN(GenArmCdeHeader, "gen-arm-cde-header",
321 "Generate arm_cde.h for clang"),
322 clEnumValN(GenArmCdeBuiltinDef, "gen-arm-cde-builtin-def",
323 "Generate ARM CDE builtin definitions for clang"),
324 clEnumValN(GenArmCdeBuiltinSema, "gen-arm-cde-builtin-sema",
325 "Generate ARM CDE builtin sema checks for clang"),
326 clEnumValN(GenArmCdeBuiltinCG, "gen-arm-cde-builtin-codegen",
327 "Generate ARM CDE builtin code-generator for clang"),
328 clEnumValN(GenArmCdeBuiltinAliases, "gen-arm-cde-builtin-aliases",
329 "Generate list of valid ARM CDE builtin aliases for clang"),
330 clEnumValN(GenRISCVVectorHeader, "gen-riscv-vector-header",
331 "Generate riscv_vector.h for clang"),
332 clEnumValN(GenRISCVVectorBuiltins, "gen-riscv-vector-builtins",
333 "Generate riscv_vector_builtins.inc for clang"),
334 clEnumValN(GenRISCVVectorBuiltinCG, "gen-riscv-vector-builtin-codegen",
335 "Generate riscv_vector_builtin_cg.inc for clang"),
336 clEnumValN(GenRISCVVectorBuiltinSema, "gen-riscv-vector-builtin-sema",
337 "Generate riscv_vector_builtin_sema.inc for clang"),
338 clEnumValN(GenRISCVSiFiveVectorBuiltins,
339 "gen-riscv-sifive-vector-builtins",
340 "Generate riscv_sifive_vector_builtins.inc for clang"),
341 clEnumValN(GenRISCVSiFiveVectorBuiltinCG,
342 "gen-riscv-sifive-vector-builtin-codegen",
343 "Generate riscv_sifive_vector_builtin_cg.inc for clang"),
344 clEnumValN(GenRISCVSiFiveVectorBuiltinSema,
345 "gen-riscv-sifive-vector-builtin-sema",
346 "Generate riscv_sifive_vector_builtin_sema.inc for clang"),
347 clEnumValN(GenRISCVAndesVectorBuiltins,
348 "gen-riscv-andes-vector-builtins",
349 "Generate riscv_andes_vector_builtins.inc for clang"),
350 clEnumValN(GenRISCVAndesVectorBuiltinCG,
351 "gen-riscv-andes-vector-builtin-codegen",
352 "Generate riscv_andes_vector_builtin_cg.inc for clang"),
353 clEnumValN(GenRISCVAndesVectorBuiltinSema,
354 "gen-riscv-andes-vector-builtin-sema",
355 "Generate riscv_andes_vector_builtin_sema.inc for clang"),
356 clEnumValN(GenHLSLAliasIntrinsics, "gen-hlsl-alias-intrinsics",
357 "Generate HLSL alias intrinsic overloads for "
358 "hlsl_alias_intrinsics.h"),
359 clEnumValN(GenHLSLInlineIntrinsics, "gen-hlsl-inline-intrinsics",
360 "Generate HLSL inline intrinsic overloads for "
361 "hlsl_intrinsics.h"),
362 clEnumValN(GenAttrDocs, "gen-attr-docs",
363 "Generate attribute documentation"),
364 clEnumValN(GenBuiltinDocs, "gen-builtin-docs",
365 "Generate builtin documentation"),
366 clEnumValN(GenDiagDocs, "gen-diag-docs",
367 "Generate diagnostic documentation"),
368 clEnumValN(GenOptDocs, "gen-opt-docs", "Generate option documentation"),
369 clEnumValN(GenDataCollectors, "gen-clang-data-collectors",
370 "Generate data collectors for AST nodes"),
371 clEnumValN(GenTestPragmaAttributeSupportedAttributes,
372 "gen-clang-test-pragma-attribute-supported-attributes",
373 "Generate a list of attributes supported by #pragma clang "
374 "attribute for testing purposes"),
375 clEnumValN(GenClangTraits, "gen-clang-traits",
376 "Generate Traits.inc for clang")));
377
378cl::opt<std::string>
379ClangComponent("clang-component",
380 cl::desc("Only use warnings from specified component"),
381 cl::value_desc("component"), cl::Hidden);
382
383bool ClangTableGenMain(raw_ostream &OS, const RecordKeeper &Records) {
384 switch (Action) {
385 case PrintRecords:
386 OS << Records; // No argument, dump all contents
387 break;
388 case DumpJSON:
389 EmitJSON(RK: Records, OS);
390 break;
391 case GenCIRLowering:
392 EmitCIRLowering(RK: Records, OS);
393 break;
394 case GenClangAttrClasses:
395 EmitClangAttrClass(Records, OS);
396 break;
397 case GenClangAttrParserStringSwitches:
398 EmitClangAttrParserStringSwitches(Records, OS);
399 break;
400 case GenClangAttrSubjectMatchRulesParserStringSwitches:
401 EmitClangAttrSubjectMatchRulesParserStringSwitches(Records, OS);
402 break;
403 case GenCXX11AttributeInfo:
404 EmitCXX11AttributeInfo(Records, OS);
405 break;
406 case GenAttributeSpellingList:
407 EmitAttributeSpellingList(Records, OS);
408 break;
409 case GenClangAttrImpl:
410 EmitClangAttrImpl(Records, OS);
411 break;
412 case GenClangAttrList:
413 EmitClangAttrList(Records, OS);
414 break;
415 case GenClangAttrDocTable:
416 EmitClangAttrDocTable(Records, OS);
417 break;
418 case GenClangAttrSubjectMatchRuleList:
419 EmitClangAttrSubjectMatchRuleList(Records, OS);
420 break;
421 case GenClangAttrPCHRead:
422 EmitClangAttrPCHRead(Records, OS);
423 break;
424 case GenClangAttrPCHWrite:
425 EmitClangAttrPCHWrite(Records, OS);
426 break;
427 case GenClangRegularKeywordAttributeInfo:
428 EmitClangRegularKeywordAttributeInfo(Records, OS);
429 break;
430 case GenClangAttrHasAttributeImpl:
431 EmitClangAttrHasAttrImpl(Records, OS);
432 break;
433 case GenClangAttrSpellingListIndex:
434 EmitClangAttrSpellingListIndex(Records, OS);
435 break;
436 case GenClangAttrASTVisitor:
437 EmitClangAttrASTVisitor(Records, OS);
438 break;
439 case GenClangAttrTemplateInstantiate:
440 EmitClangAttrTemplateInstantiate(Records, OS);
441 break;
442 case GenClangAttrParsedAttrList:
443 EmitClangAttrParsedAttrList(Records, OS);
444 break;
445 case GenClangAttrParsedAttrImpl:
446 EmitClangAttrParsedAttrImpl(Records, OS);
447 break;
448 case GenClangAttrParsedAttrKinds:
449 EmitClangAttrParsedAttrKinds(Records, OS);
450 break;
451 case GenClangAttrIsTypeDependent:
452 EmitClangAttrIsTypeDependent(Records, OS);
453 break;
454 case GenClangAttrTextNodeDump:
455 EmitClangAttrTextNodeDump(Records, OS);
456 break;
457 case GenClangAttrNodeTraverse:
458 EmitClangAttrNodeTraverse(Records, OS);
459 break;
460 case GenClangAttrUndocumentedAttrList:
461 EmitClangUndocumentedAttrList(Records, OS);
462 break;
463 case GenClangBuiltins:
464 EmitClangBuiltins(Records, OS);
465 break;
466 case GenClangBuiltinTemplates:
467 EmitClangBuiltinTemplates(Records, OS);
468 break;
469 case GenClangDiagsCompatIDs:
470 EmitClangDiagsCompatIDs(Records, OS, Component: ClangComponent);
471 break;
472 case GenClangDiagsDefs:
473 EmitClangDiagsDefs(Records, OS, Component: ClangComponent);
474 break;
475 case GenClangDiagsEnums:
476 EmitClangDiagsEnums(Records, OS, Component: ClangComponent);
477 break;
478 case GenClangDiagGroups:
479 EmitClangDiagGroups(Records, OS);
480 break;
481 case GenClangDiagsIndexName:
482 EmitClangDiagsIndexName(Records, OS);
483 break;
484 case GenClangDiagsStableIDs:
485 EmitClangDiagsStableIDs(Records, OS);
486 break;
487 case GenClangDiagsInterface:
488 EmitClangDiagsInterface(OS, Component: ClangComponent);
489 break;
490 case GenClangCommentNodes:
491 EmitClangASTNodes(RK: Records, OS, CommentNodeClassName, S: "");
492 break;
493 case GenClangDeclNodes:
494 EmitClangASTNodes(RK: Records, OS, DeclNodeClassName, S: "Decl",
495 DeclContextNodeClassName);
496 EmitClangDeclContext(RK: Records, OS);
497 break;
498 case GenClangStmtNodes:
499 EmitClangASTNodes(RK: Records, OS, StmtNodeClassName, S: "");
500 break;
501 case GenClangTypeNodes:
502 EmitClangTypeNodes(Records, OS);
503 break;
504 case GenClangTypeReader:
505 EmitClangTypeReader(Records, OS);
506 break;
507 case GenClangTypeWriter:
508 EmitClangTypeWriter(Records, OS);
509 break;
510 case GenClangBasicReader:
511 EmitClangBasicReader(Records, OS);
512 break;
513 case GenClangBasicWriter:
514 EmitClangBasicWriter(Records, OS);
515 break;
516 case GenClangOpcodes:
517 EmitClangOpcodes(Records, OS);
518 break;
519 case GenClangSACheckers:
520 EmitClangSACheckers(Records, OS);
521 break;
522 case GenClangCommentHTMLTags:
523 EmitClangCommentHTMLTags(Records, OS);
524 break;
525 case GenClangCommentHTMLTagsProperties:
526 EmitClangCommentHTMLTagsProperties(Records, OS);
527 break;
528 case GenClangCommentHTMLNamedCharacterReferences:
529 EmitClangCommentHTMLNamedCharacterReferences(Records, OS);
530 break;
531 case GenClangCommentCommandInfo:
532 EmitClangCommentCommandInfo(Records, OS);
533 break;
534 case GenClangCommentCommandList:
535 EmitClangCommentCommandList(Records, OS);
536 break;
537 case GenClangOpenCLBuiltins:
538 EmitClangOpenCLBuiltins(Records, OS);
539 break;
540 case GenClangOpenCLBuiltinHeader:
541 EmitClangOpenCLBuiltinHeader(Records, OS);
542 break;
543 case GenClangOpenCLBuiltinTests:
544 EmitClangOpenCLBuiltinTests(Records, OS);
545 break;
546 case GenClangSyntaxNodeList:
547 EmitClangSyntaxNodeList(Records, OS);
548 break;
549 case GenClangSyntaxNodeClasses:
550 EmitClangSyntaxNodeClasses(Records, OS);
551 break;
552 case GenArmNeon:
553 EmitNeon(Records, OS);
554 break;
555 case GenArmFP16:
556 EmitFP16(Records, OS);
557 break;
558 case GenArmVectorType:
559 EmitVectorTypes(Records, OS);
560 break;
561 case GenArmBF16:
562 EmitBF16(Records, OS);
563 break;
564 case GenArmNeonSema:
565 EmitNeonSema(Records, OS);
566 break;
567 case GenArmNeonTest:
568 EmitNeonTest(Records, OS);
569 break;
570 case GenArmImmCheckTypes:
571 EmitImmCheckTypes(Records, OS);
572 break;
573 case GenArmMveHeader:
574 EmitMveHeader(Records, OS);
575 break;
576 case GenArmMveBuiltinDef:
577 EmitMveBuiltinDef(Records, OS);
578 break;
579 case GenArmMveBuiltinSema:
580 EmitMveBuiltinSema(Records, OS);
581 break;
582 case GenArmMveBuiltinCG:
583 EmitMveBuiltinCG(Records, OS);
584 break;
585 case GenArmMveBuiltinAliases:
586 EmitMveBuiltinAliases(Records, OS);
587 break;
588 case GenArmSveHeader:
589 EmitSveHeader(Records, OS);
590 break;
591 case GenArmSveBuiltins:
592 EmitSveBuiltins(Records, OS);
593 break;
594 case GenArmSveBuiltinsJSON:
595 EmitSveBuiltinsJSON(Records, OS);
596 break;
597 case GenArmSveBuiltinCG:
598 EmitSveBuiltinCG(Records, OS);
599 break;
600 case GenArmSveTypeFlags:
601 EmitSveTypeFlags(Records, OS);
602 break;
603 case GenArmSveRangeChecks:
604 EmitSveRangeChecks(Records, OS);
605 break;
606 case GenArmSveStreamingAttrs:
607 EmitSveStreamingAttrs(Records, OS);
608 break;
609 case GenArmSmeHeader:
610 EmitSmeHeader(Records, OS);
611 break;
612 case GenArmSmeBuiltins:
613 EmitSmeBuiltins(Records, OS);
614 break;
615 case GenArmSmeBuiltinsJSON:
616 EmitSmeBuiltinsJSON(Records, OS);
617 break;
618 case GenArmSmeBuiltinCG:
619 EmitSmeBuiltinCG(Records, OS);
620 break;
621 case GenArmSmeRangeChecks:
622 EmitSmeRangeChecks(Records, OS);
623 break;
624 case GenArmSmeStreamingAttrs:
625 EmitSmeStreamingAttrs(Records, OS);
626 break;
627 case GenArmSmeBuiltinZAState:
628 EmitSmeBuiltinZAState(Records, OS);
629 break;
630 case GenArmCdeHeader:
631 EmitCdeHeader(Records, OS);
632 break;
633 case GenArmCdeBuiltinDef:
634 EmitCdeBuiltinDef(Records, OS);
635 break;
636 case GenArmCdeBuiltinSema:
637 EmitCdeBuiltinSema(Records, OS);
638 break;
639 case GenArmCdeBuiltinCG:
640 EmitCdeBuiltinCG(Records, OS);
641 break;
642 case GenArmCdeBuiltinAliases:
643 EmitCdeBuiltinAliases(Records, OS);
644 break;
645 case GenRISCVVectorHeader:
646 EmitRVVHeader(Records, OS);
647 break;
648 case GenRISCVVectorBuiltins:
649 EmitRVVBuiltins(Records, OS);
650 break;
651 case GenRISCVVectorBuiltinCG:
652 EmitRVVBuiltinCG(Records, OS);
653 break;
654 case GenRISCVVectorBuiltinSema:
655 EmitRVVBuiltinSema(Records, OS);
656 break;
657 case GenRISCVSiFiveVectorBuiltins:
658 EmitRVVBuiltins(Records, OS);
659 break;
660 case GenRISCVSiFiveVectorBuiltinCG:
661 EmitRVVBuiltinCG(Records, OS);
662 break;
663 case GenRISCVSiFiveVectorBuiltinSema:
664 EmitRVVBuiltinSema(Records, OS);
665 break;
666 case GenRISCVAndesVectorBuiltins:
667 EmitRVVBuiltins(Records, OS);
668 break;
669 case GenRISCVAndesVectorBuiltinCG:
670 EmitRVVBuiltinCG(Records, OS);
671 break;
672 case GenRISCVAndesVectorBuiltinSema:
673 EmitRVVBuiltinSema(Records, OS);
674 break;
675 case GenHLSLAliasIntrinsics:
676 EmitHLSLAliasIntrinsics(Records, OS);
677 break;
678 case GenHLSLInlineIntrinsics:
679 EmitHLSLInlineIntrinsics(Records, OS);
680 break;
681 case GenAttrDocs:
682 EmitClangAttrDocs(Records, OS);
683 break;
684 case GenBuiltinDocs:
685 EmitClangBuiltinDocs(Records, OS);
686 break;
687 case GenDiagDocs:
688 EmitClangDiagDocs(Records, OS);
689 break;
690 case GenOptDocs:
691 EmitClangOptDocs(Records, OS);
692 break;
693 case GenDataCollectors:
694 EmitClangDataCollectors(Records, OS);
695 break;
696 case GenTestPragmaAttributeSupportedAttributes:
697 EmitTestPragmaAttributeSupportedAttributes(Records, OS);
698 break;
699 case GenClangTraits:
700 EmitClangTraits(Records, OS);
701 break;
702 }
703
704 return false;
705}
706}
707
708int main(int argc, char **argv) {
709 sys::PrintStackTraceOnErrorSignal(Argv0: argv[0]);
710 PrettyStackTraceProgram X(argc, argv);
711 cl::ParseCommandLineOptions(argc, argv);
712
713 llvm_shutdown_obj Y;
714
715 return TableGenMain(argv0: argv[0], MainFn: &ClangTableGenMain);
716}
717
718#ifdef __has_feature
719#if __has_feature(address_sanitizer)
720#include <sanitizer/lsan_interface.h>
721// Disable LeakSanitizer for this binary as it has too many leaks that are not
722// very interesting to fix. See compiler-rt/include/sanitizer/lsan_interface.h .
723int __lsan_is_turned_off() { return 1; }
724#endif // __has_feature(address_sanitizer)
725#endif // defined(__has_feature)
726