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 "TableGenBackends.h" // Declares all backends.
14 #include "ASTTableGen.h"
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/Error.h"
20 #include "llvm/TableGen/Main.h"
21 #include "llvm/TableGen/Record.h"
22
23 using namespace llvm;
24 using namespace clang;
25
26 enum ActionType {
27 PrintRecords,
28 DumpJSON,
29 GenClangAttrClasses,
30 GenClangAttrParserStringSwitches,
31 GenClangAttrSubjectMatchRulesParserStringSwitches,
32 GenClangAttrImpl,
33 GenClangAttrList,
34 GenClangAttrDocTable,
35 GenClangAttrSubjectMatchRuleList,
36 GenClangAttrPCHRead,
37 GenClangAttrPCHWrite,
38 GenClangAttrHasAttributeImpl,
39 GenClangAttrSpellingListIndex,
40 GenClangAttrASTVisitor,
41 GenClangAttrTemplateInstantiate,
42 GenClangAttrParsedAttrList,
43 GenClangAttrParsedAttrImpl,
44 GenClangAttrParsedAttrKinds,
45 GenClangAttrTextNodeDump,
46 GenClangAttrNodeTraverse,
47 GenClangBasicReader,
48 GenClangBasicWriter,
49 GenClangDiagsDefs,
50 GenClangDiagGroups,
51 GenClangDiagsIndexName,
52 GenClangCommentNodes,
53 GenClangDeclNodes,
54 GenClangStmtNodes,
55 GenClangTypeNodes,
56 GenClangTypeReader,
57 GenClangTypeWriter,
58 GenClangOpcodes,
59 GenClangSACheckers,
60 GenClangSyntaxNodeList,
61 GenClangSyntaxNodeClasses,
62 GenClangCommentHTMLTags,
63 GenClangCommentHTMLTagsProperties,
64 GenClangCommentHTMLNamedCharacterReferences,
65 GenClangCommentCommandInfo,
66 GenClangCommentCommandList,
67 GenClangOpenCLBuiltins,
68 GenClangOpenCLBuiltinTests,
69 GenArmNeon,
70 GenArmFP16,
71 GenArmBF16,
72 GenArmNeonSema,
73 GenArmNeonTest,
74 GenArmMveHeader,
75 GenArmMveBuiltinDef,
76 GenArmMveBuiltinSema,
77 GenArmMveBuiltinCG,
78 GenArmMveBuiltinAliases,
79 GenArmSveHeader,
80 GenArmSveBuiltins,
81 GenArmSveBuiltinCG,
82 GenArmSveTypeFlags,
83 GenArmSveRangeChecks,
84 GenArmCdeHeader,
85 GenArmCdeBuiltinDef,
86 GenArmCdeBuiltinSema,
87 GenArmCdeBuiltinCG,
88 GenArmCdeBuiltinAliases,
89 GenRISCVVectorHeader,
90 GenRISCVVectorBuiltins,
91 GenRISCVVectorBuiltinCG,
92 GenRISCVVectorBuiltinSema,
93 GenAttrDocs,
94 GenDiagDocs,
95 GenOptDocs,
96 GenDataCollectors,
97 GenTestPragmaAttributeSupportedAttributes
98 };
99
100 namespace {
101 cl::opt<ActionType> Action(
102 cl::desc("Action to perform:"),
103 cl::values(
104 clEnumValN(PrintRecords, "print-records",
105 "Print all records to stdout (default)"),
106 clEnumValN(DumpJSON, "dump-json",
107 "Dump all records as machine-readable JSON"),
108 clEnumValN(GenClangAttrClasses, "gen-clang-attr-classes",
109 "Generate clang attribute clases"),
110 clEnumValN(GenClangAttrParserStringSwitches,
111 "gen-clang-attr-parser-string-switches",
112 "Generate all parser-related attribute string switches"),
113 clEnumValN(GenClangAttrSubjectMatchRulesParserStringSwitches,
114 "gen-clang-attr-subject-match-rules-parser-string-switches",
115 "Generate all parser-related attribute subject match rule"
116 "string switches"),
117 clEnumValN(GenClangAttrImpl, "gen-clang-attr-impl",
118 "Generate clang attribute implementations"),
119 clEnumValN(GenClangAttrList, "gen-clang-attr-list",
120 "Generate a clang attribute list"),
121 clEnumValN(GenClangAttrDocTable, "gen-clang-attr-doc-table",
122 "Generate a table of attribute documentation"),
123 clEnumValN(GenClangAttrSubjectMatchRuleList,
124 "gen-clang-attr-subject-match-rule-list",
125 "Generate a clang attribute subject match rule list"),
126 clEnumValN(GenClangAttrPCHRead, "gen-clang-attr-pch-read",
127 "Generate clang PCH attribute reader"),
128 clEnumValN(GenClangAttrPCHWrite, "gen-clang-attr-pch-write",
129 "Generate clang PCH attribute writer"),
130 clEnumValN(GenClangAttrHasAttributeImpl,
131 "gen-clang-attr-has-attribute-impl",
132 "Generate a clang attribute spelling list"),
133 clEnumValN(GenClangAttrSpellingListIndex,
134 "gen-clang-attr-spelling-index",
135 "Generate a clang attribute spelling index"),
136 clEnumValN(GenClangAttrASTVisitor, "gen-clang-attr-ast-visitor",
137 "Generate a recursive AST visitor for clang attributes"),
138 clEnumValN(GenClangAttrTemplateInstantiate,
139 "gen-clang-attr-template-instantiate",
140 "Generate a clang template instantiate code"),
141 clEnumValN(GenClangAttrParsedAttrList,
142 "gen-clang-attr-parsed-attr-list",
143 "Generate a clang parsed attribute list"),
144 clEnumValN(GenClangAttrParsedAttrImpl,
145 "gen-clang-attr-parsed-attr-impl",
146 "Generate the clang parsed attribute helpers"),
147 clEnumValN(GenClangAttrParsedAttrKinds,
148 "gen-clang-attr-parsed-attr-kinds",
149 "Generate a clang parsed attribute kinds"),
150 clEnumValN(GenClangAttrTextNodeDump, "gen-clang-attr-text-node-dump",
151 "Generate clang attribute text node dumper"),
152 clEnumValN(GenClangAttrNodeTraverse, "gen-clang-attr-node-traverse",
153 "Generate clang attribute traverser"),
154 clEnumValN(GenClangDiagsDefs, "gen-clang-diags-defs",
155 "Generate Clang diagnostics definitions"),
156 clEnumValN(GenClangDiagGroups, "gen-clang-diag-groups",
157 "Generate Clang diagnostic groups"),
158 clEnumValN(GenClangDiagsIndexName, "gen-clang-diags-index-name",
159 "Generate Clang diagnostic name index"),
160 clEnumValN(GenClangBasicReader, "gen-clang-basic-reader",
161 "Generate Clang BasicReader classes"),
162 clEnumValN(GenClangBasicWriter, "gen-clang-basic-writer",
163 "Generate Clang BasicWriter classes"),
164 clEnumValN(GenClangCommentNodes, "gen-clang-comment-nodes",
165 "Generate Clang AST comment nodes"),
166 clEnumValN(GenClangDeclNodes, "gen-clang-decl-nodes",
167 "Generate Clang AST declaration nodes"),
168 clEnumValN(GenClangStmtNodes, "gen-clang-stmt-nodes",
169 "Generate Clang AST statement nodes"),
170 clEnumValN(GenClangTypeNodes, "gen-clang-type-nodes",
171 "Generate Clang AST type nodes"),
172 clEnumValN(GenClangTypeReader, "gen-clang-type-reader",
173 "Generate Clang AbstractTypeReader class"),
174 clEnumValN(GenClangTypeWriter, "gen-clang-type-writer",
175 "Generate Clang AbstractTypeWriter class"),
176 clEnumValN(GenClangOpcodes, "gen-clang-opcodes",
177 "Generate Clang constexpr interpreter opcodes"),
178 clEnumValN(GenClangSACheckers, "gen-clang-sa-checkers",
179 "Generate Clang Static Analyzer checkers"),
180 clEnumValN(GenClangSyntaxNodeList, "gen-clang-syntax-node-list",
181 "Generate list of Clang Syntax Tree node types"),
182 clEnumValN(GenClangSyntaxNodeClasses, "gen-clang-syntax-node-classes",
183 "Generate definitions of Clang Syntax Tree node clasess"),
184 clEnumValN(GenClangCommentHTMLTags, "gen-clang-comment-html-tags",
185 "Generate efficient matchers for HTML tag "
186 "names that are used in documentation comments"),
187 clEnumValN(GenClangCommentHTMLTagsProperties,
188 "gen-clang-comment-html-tags-properties",
189 "Generate efficient matchers for HTML tag "
190 "properties"),
191 clEnumValN(GenClangCommentHTMLNamedCharacterReferences,
192 "gen-clang-comment-html-named-character-references",
193 "Generate function to translate named character "
194 "references to UTF-8 sequences"),
195 clEnumValN(GenClangCommentCommandInfo, "gen-clang-comment-command-info",
196 "Generate command properties for commands that "
197 "are used in documentation comments"),
198 clEnumValN(GenClangCommentCommandList, "gen-clang-comment-command-list",
199 "Generate list of commands that are used in "
200 "documentation comments"),
201 clEnumValN(GenClangOpenCLBuiltins, "gen-clang-opencl-builtins",
202 "Generate OpenCL builtin declaration handlers"),
203 clEnumValN(GenClangOpenCLBuiltinTests, "gen-clang-opencl-builtin-tests",
204 "Generate OpenCL builtin declaration tests"),
205 clEnumValN(GenArmNeon, "gen-arm-neon", "Generate arm_neon.h for clang"),
206 clEnumValN(GenArmFP16, "gen-arm-fp16", "Generate arm_fp16.h for clang"),
207 clEnumValN(GenArmBF16, "gen-arm-bf16", "Generate arm_bf16.h for clang"),
208 clEnumValN(GenArmNeonSema, "gen-arm-neon-sema",
209 "Generate ARM NEON sema support for clang"),
210 clEnumValN(GenArmNeonTest, "gen-arm-neon-test",
211 "Generate ARM NEON tests for clang"),
212 clEnumValN(GenArmSveHeader, "gen-arm-sve-header",
213 "Generate arm_sve.h for clang"),
214 clEnumValN(GenArmSveBuiltins, "gen-arm-sve-builtins",
215 "Generate arm_sve_builtins.inc for clang"),
216 clEnumValN(GenArmSveBuiltinCG, "gen-arm-sve-builtin-codegen",
217 "Generate arm_sve_builtin_cg_map.inc for clang"),
218 clEnumValN(GenArmSveTypeFlags, "gen-arm-sve-typeflags",
219 "Generate arm_sve_typeflags.inc for clang"),
220 clEnumValN(GenArmSveRangeChecks, "gen-arm-sve-sema-rangechecks",
221 "Generate arm_sve_sema_rangechecks.inc for clang"),
222 clEnumValN(GenArmMveHeader, "gen-arm-mve-header",
223 "Generate arm_mve.h for clang"),
224 clEnumValN(GenArmMveBuiltinDef, "gen-arm-mve-builtin-def",
225 "Generate ARM MVE builtin definitions for clang"),
226 clEnumValN(GenArmMveBuiltinSema, "gen-arm-mve-builtin-sema",
227 "Generate ARM MVE builtin sema checks for clang"),
228 clEnumValN(GenArmMveBuiltinCG, "gen-arm-mve-builtin-codegen",
229 "Generate ARM MVE builtin code-generator for clang"),
230 clEnumValN(GenArmMveBuiltinAliases, "gen-arm-mve-builtin-aliases",
231 "Generate list of valid ARM MVE builtin aliases for clang"),
232 clEnumValN(GenArmCdeHeader, "gen-arm-cde-header",
233 "Generate arm_cde.h for clang"),
234 clEnumValN(GenArmCdeBuiltinDef, "gen-arm-cde-builtin-def",
235 "Generate ARM CDE builtin definitions for clang"),
236 clEnumValN(GenArmCdeBuiltinSema, "gen-arm-cde-builtin-sema",
237 "Generate ARM CDE builtin sema checks for clang"),
238 clEnumValN(GenArmCdeBuiltinCG, "gen-arm-cde-builtin-codegen",
239 "Generate ARM CDE builtin code-generator for clang"),
240 clEnumValN(GenArmCdeBuiltinAliases, "gen-arm-cde-builtin-aliases",
241 "Generate list of valid ARM CDE builtin aliases for clang"),
242 clEnumValN(GenRISCVVectorHeader, "gen-riscv-vector-header",
243 "Generate riscv_vector.h for clang"),
244 clEnumValN(GenRISCVVectorBuiltins, "gen-riscv-vector-builtins",
245 "Generate riscv_vector_builtins.inc for clang"),
246 clEnumValN(GenRISCVVectorBuiltinCG, "gen-riscv-vector-builtin-codegen",
247 "Generate riscv_vector_builtin_cg.inc for clang"),
248 clEnumValN(GenRISCVVectorBuiltinSema, "gen-riscv-vector-builtin-sema",
249 "Generate riscv_vector_builtin_sema.inc for clang"),
250 clEnumValN(GenAttrDocs, "gen-attr-docs",
251 "Generate attribute documentation"),
252 clEnumValN(GenDiagDocs, "gen-diag-docs",
253 "Generate diagnostic documentation"),
254 clEnumValN(GenOptDocs, "gen-opt-docs", "Generate option documentation"),
255 clEnumValN(GenDataCollectors, "gen-clang-data-collectors",
256 "Generate data collectors for AST nodes"),
257 clEnumValN(GenTestPragmaAttributeSupportedAttributes,
258 "gen-clang-test-pragma-attribute-supported-attributes",
259 "Generate a list of attributes supported by #pragma clang "
260 "attribute for testing purposes")));
261
262 cl::opt<std::string>
263 ClangComponent("clang-component",
264 cl::desc("Only use warnings from specified component"),
265 cl::value_desc("component"), cl::Hidden);
266
ClangTableGenMain(raw_ostream & OS,RecordKeeper & Records)267 bool ClangTableGenMain(raw_ostream &OS, RecordKeeper &Records) {
268 switch (Action) {
269 case PrintRecords:
270 OS << Records; // No argument, dump all contents
271 break;
272 case DumpJSON:
273 EmitJSON(Records, OS);
274 break;
275 case GenClangAttrClasses:
276 EmitClangAttrClass(Records, OS);
277 break;
278 case GenClangAttrParserStringSwitches:
279 EmitClangAttrParserStringSwitches(Records, OS);
280 break;
281 case GenClangAttrSubjectMatchRulesParserStringSwitches:
282 EmitClangAttrSubjectMatchRulesParserStringSwitches(Records, OS);
283 break;
284 case GenClangAttrImpl:
285 EmitClangAttrImpl(Records, OS);
286 break;
287 case GenClangAttrList:
288 EmitClangAttrList(Records, OS);
289 break;
290 case GenClangAttrDocTable:
291 EmitClangAttrDocTable(Records, OS);
292 break;
293 case GenClangAttrSubjectMatchRuleList:
294 EmitClangAttrSubjectMatchRuleList(Records, OS);
295 break;
296 case GenClangAttrPCHRead:
297 EmitClangAttrPCHRead(Records, OS);
298 break;
299 case GenClangAttrPCHWrite:
300 EmitClangAttrPCHWrite(Records, OS);
301 break;
302 case GenClangAttrHasAttributeImpl:
303 EmitClangAttrHasAttrImpl(Records, OS);
304 break;
305 case GenClangAttrSpellingListIndex:
306 EmitClangAttrSpellingListIndex(Records, OS);
307 break;
308 case GenClangAttrASTVisitor:
309 EmitClangAttrASTVisitor(Records, OS);
310 break;
311 case GenClangAttrTemplateInstantiate:
312 EmitClangAttrTemplateInstantiate(Records, OS);
313 break;
314 case GenClangAttrParsedAttrList:
315 EmitClangAttrParsedAttrList(Records, OS);
316 break;
317 case GenClangAttrParsedAttrImpl:
318 EmitClangAttrParsedAttrImpl(Records, OS);
319 break;
320 case GenClangAttrParsedAttrKinds:
321 EmitClangAttrParsedAttrKinds(Records, OS);
322 break;
323 case GenClangAttrTextNodeDump:
324 EmitClangAttrTextNodeDump(Records, OS);
325 break;
326 case GenClangAttrNodeTraverse:
327 EmitClangAttrNodeTraverse(Records, OS);
328 break;
329 case GenClangDiagsDefs:
330 EmitClangDiagsDefs(Records, OS, ClangComponent);
331 break;
332 case GenClangDiagGroups:
333 EmitClangDiagGroups(Records, OS);
334 break;
335 case GenClangDiagsIndexName:
336 EmitClangDiagsIndexName(Records, OS);
337 break;
338 case GenClangCommentNodes:
339 EmitClangASTNodes(Records, OS, CommentNodeClassName, "");
340 break;
341 case GenClangDeclNodes:
342 EmitClangASTNodes(Records, OS, DeclNodeClassName, "Decl");
343 EmitClangDeclContext(Records, OS);
344 break;
345 case GenClangStmtNodes:
346 EmitClangASTNodes(Records, OS, StmtNodeClassName, "");
347 break;
348 case GenClangTypeNodes:
349 EmitClangTypeNodes(Records, OS);
350 break;
351 case GenClangTypeReader:
352 EmitClangTypeReader(Records, OS);
353 break;
354 case GenClangTypeWriter:
355 EmitClangTypeWriter(Records, OS);
356 break;
357 case GenClangBasicReader:
358 EmitClangBasicReader(Records, OS);
359 break;
360 case GenClangBasicWriter:
361 EmitClangBasicWriter(Records, OS);
362 break;
363 case GenClangOpcodes:
364 EmitClangOpcodes(Records, OS);
365 break;
366 case GenClangSACheckers:
367 EmitClangSACheckers(Records, OS);
368 break;
369 case GenClangCommentHTMLTags:
370 EmitClangCommentHTMLTags(Records, OS);
371 break;
372 case GenClangCommentHTMLTagsProperties:
373 EmitClangCommentHTMLTagsProperties(Records, OS);
374 break;
375 case GenClangCommentHTMLNamedCharacterReferences:
376 EmitClangCommentHTMLNamedCharacterReferences(Records, OS);
377 break;
378 case GenClangCommentCommandInfo:
379 EmitClangCommentCommandInfo(Records, OS);
380 break;
381 case GenClangCommentCommandList:
382 EmitClangCommentCommandList(Records, OS);
383 break;
384 case GenClangOpenCLBuiltins:
385 EmitClangOpenCLBuiltins(Records, OS);
386 break;
387 case GenClangOpenCLBuiltinTests:
388 EmitClangOpenCLBuiltinTests(Records, OS);
389 break;
390 case GenClangSyntaxNodeList:
391 EmitClangSyntaxNodeList(Records, OS);
392 break;
393 case GenClangSyntaxNodeClasses:
394 EmitClangSyntaxNodeClasses(Records, OS);
395 break;
396 case GenArmNeon:
397 EmitNeon(Records, OS);
398 break;
399 case GenArmFP16:
400 EmitFP16(Records, OS);
401 break;
402 case GenArmBF16:
403 EmitBF16(Records, OS);
404 break;
405 case GenArmNeonSema:
406 EmitNeonSema(Records, OS);
407 break;
408 case GenArmNeonTest:
409 EmitNeonTest(Records, OS);
410 break;
411 case GenArmMveHeader:
412 EmitMveHeader(Records, OS);
413 break;
414 case GenArmMveBuiltinDef:
415 EmitMveBuiltinDef(Records, OS);
416 break;
417 case GenArmMveBuiltinSema:
418 EmitMveBuiltinSema(Records, OS);
419 break;
420 case GenArmMveBuiltinCG:
421 EmitMveBuiltinCG(Records, OS);
422 break;
423 case GenArmMveBuiltinAliases:
424 EmitMveBuiltinAliases(Records, OS);
425 break;
426 case GenArmSveHeader:
427 EmitSveHeader(Records, OS);
428 break;
429 case GenArmSveBuiltins:
430 EmitSveBuiltins(Records, OS);
431 break;
432 case GenArmSveBuiltinCG:
433 EmitSveBuiltinCG(Records, OS);
434 break;
435 case GenArmSveTypeFlags:
436 EmitSveTypeFlags(Records, OS);
437 break;
438 case GenArmSveRangeChecks:
439 EmitSveRangeChecks(Records, OS);
440 break;
441 case GenArmCdeHeader:
442 EmitCdeHeader(Records, OS);
443 break;
444 case GenArmCdeBuiltinDef:
445 EmitCdeBuiltinDef(Records, OS);
446 break;
447 case GenArmCdeBuiltinSema:
448 EmitCdeBuiltinSema(Records, OS);
449 break;
450 case GenArmCdeBuiltinCG:
451 EmitCdeBuiltinCG(Records, OS);
452 break;
453 case GenArmCdeBuiltinAliases:
454 EmitCdeBuiltinAliases(Records, OS);
455 break;
456 case GenRISCVVectorHeader:
457 EmitRVVHeader(Records, OS);
458 break;
459 case GenRISCVVectorBuiltins:
460 EmitRVVBuiltins(Records, OS);
461 break;
462 case GenRISCVVectorBuiltinCG:
463 EmitRVVBuiltinCG(Records, OS);
464 break;
465 case GenRISCVVectorBuiltinSema:
466 EmitRVVBuiltinSema(Records, OS);
467 break;
468 case GenAttrDocs:
469 EmitClangAttrDocs(Records, OS);
470 break;
471 case GenDiagDocs:
472 EmitClangDiagDocs(Records, OS);
473 break;
474 case GenOptDocs:
475 EmitClangOptDocs(Records, OS);
476 break;
477 case GenDataCollectors:
478 EmitClangDataCollectors(Records, OS);
479 break;
480 case GenTestPragmaAttributeSupportedAttributes:
481 EmitTestPragmaAttributeSupportedAttributes(Records, OS);
482 break;
483 }
484
485 return false;
486 }
487 }
488
main(int argc,char ** argv)489 int main(int argc, char **argv) {
490 sys::PrintStackTraceOnErrorSignal(argv[0]);
491 PrettyStackTraceProgram X(argc, argv);
492 cl::ParseCommandLineOptions(argc, argv);
493
494 llvm_shutdown_obj Y;
495
496 return TableGenMain(argv[0], &ClangTableGenMain);
497 }
498
499 #ifdef __has_feature
500 #if __has_feature(address_sanitizer)
501 #include <sanitizer/lsan_interface.h>
502 // Disable LeakSanitizer for this binary as it has too many leaks that are not
503 // very interesting to fix. See compiler-rt/include/sanitizer/lsan_interface.h .
__lsan_is_turned_off()504 int __lsan_is_turned_off() { return 1; }
505 #endif // __has_feature(address_sanitizer)
506 #endif // defined(__has_feature)
507