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