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