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