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