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