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