| //===- TableGen.cpp - Top-Level TableGen implementation for LLVM ----------===// | |
| // | |
| // The LLVM Compiler Infrastructure | |
| // | |
| // This file is distributed under the University of Illinois Open Source | |
| // License. See LICENSE.TXT for details. | |
| // | |
| //===----------------------------------------------------------------------===// | |
| // | |
| // This file contains the main function for LLVM's TableGen. | |
| // | |
| //===----------------------------------------------------------------------===// | |
| #include "TableGenBackends.h" // Declares all backends. | |
| #include "llvm/Support/CommandLine.h" | |
| #include "llvm/Support/ManagedStatic.h" | |
| #include "llvm/Support/PrettyStackTrace.h" | |
| #include "llvm/Support/Signals.h" | |
| #include "llvm/TableGen/Main.h" | |
| #include "llvm/TableGen/Record.h" | |
| #include "llvm/TableGen/SetTheory.h" | |
| using namespace llvm; | |
| enum ActionType { | |
| PrintRecords, | |
| DumpJSON, | |
| GenEmitter, | |
| GenRegisterInfo, | |
| GenInstrInfo, | |
| GenInstrDocs, | |
| GenAsmWriter, | |
| GenAsmMatcher, | |
| GenDisassembler, | |
| GenPseudoLowering, | |
| GenCompressInst, | |
| GenCallingConv, | |
| GenDAGISel, | |
| GenDFAPacketizer, | |
| GenFastISel, | |
| GenSubtarget, | |
| GenIntrinsicEnums, | |
| GenIntrinsicImpl, | |
| GenTgtIntrinsicEnums, | |
| GenTgtIntrinsicImpl, | |
| PrintEnums, | |
| PrintSets, | |
| GenOptParserDefs, | |
| GenCTags, | |
| GenAttributes, | |
| GenSearchableTables, | |
| GenGlobalISel, | |
| GenX86EVEX2VEXTables, | |
| GenX86FoldTables, | |
| GenRegisterBank, | |
| }; | |
| namespace { | |
| cl::opt<ActionType> | |
| Action(cl::desc("Action to perform:"), | |
| cl::values(clEnumValN(PrintRecords, "print-records", | |
| "Print all records to stdout (default)"), | |
| clEnumValN(DumpJSON, "dump-json", | |
| "Dump all records as machine-readable JSON"), | |
| clEnumValN(GenEmitter, "gen-emitter", | |
| "Generate machine code emitter"), | |
| clEnumValN(GenRegisterInfo, "gen-register-info", | |
| "Generate registers and register classes info"), | |
| clEnumValN(GenInstrInfo, "gen-instr-info", | |
| "Generate instruction descriptions"), | |
| clEnumValN(GenInstrDocs, "gen-instr-docs", | |
| "Generate instruction documentation"), | |
| clEnumValN(GenCallingConv, "gen-callingconv", | |
| "Generate calling convention descriptions"), | |
| clEnumValN(GenAsmWriter, "gen-asm-writer", | |
| "Generate assembly writer"), | |
| clEnumValN(GenDisassembler, "gen-disassembler", | |
| "Generate disassembler"), | |
| clEnumValN(GenPseudoLowering, "gen-pseudo-lowering", | |
| "Generate pseudo instruction lowering"), | |
| clEnumValN(GenCompressInst, "gen-compress-inst-emitter", | |
| "Generate RISCV compressed instructions."), | |
| clEnumValN(GenAsmMatcher, "gen-asm-matcher", | |
| "Generate assembly instruction matcher"), | |
| clEnumValN(GenDAGISel, "gen-dag-isel", | |
| "Generate a DAG instruction selector"), | |
| clEnumValN(GenDFAPacketizer, "gen-dfa-packetizer", | |
| "Generate DFA Packetizer for VLIW targets"), | |
| clEnumValN(GenFastISel, "gen-fast-isel", | |
| "Generate a \"fast\" instruction selector"), | |
| clEnumValN(GenSubtarget, "gen-subtarget", | |
| "Generate subtarget enumerations"), | |
| clEnumValN(GenIntrinsicEnums, "gen-intrinsic-enums", | |
| "Generate intrinsic enums"), | |
| clEnumValN(GenIntrinsicImpl, "gen-intrinsic-impl", | |
| "Generate intrinsic information"), | |
| clEnumValN(GenTgtIntrinsicEnums, "gen-tgt-intrinsic-enums", | |
| "Generate target intrinsic enums"), | |
| clEnumValN(GenTgtIntrinsicImpl, "gen-tgt-intrinsic-impl", | |
| "Generate target intrinsic information"), | |
| clEnumValN(PrintEnums, "print-enums", | |
| "Print enum values for a class"), | |
| clEnumValN(PrintSets, "print-sets", | |
| "Print expanded sets for testing DAG exprs"), | |
| clEnumValN(GenOptParserDefs, "gen-opt-parser-defs", | |
| "Generate option definitions"), | |
| clEnumValN(GenCTags, "gen-ctags", | |
| "Generate ctags-compatible index"), | |
| clEnumValN(GenAttributes, "gen-attrs", | |
| "Generate attributes"), | |
| clEnumValN(GenSearchableTables, "gen-searchable-tables", | |
| "Generate generic binary-searchable table"), | |
| clEnumValN(GenGlobalISel, "gen-global-isel", | |
| "Generate GlobalISel selector"), | |
| clEnumValN(GenX86EVEX2VEXTables, "gen-x86-EVEX2VEX-tables", | |
| "Generate X86 EVEX to VEX compress tables"), | |
| clEnumValN(GenX86FoldTables, "gen-x86-fold-tables", | |
| "Generate X86 fold tables"), | |
| clEnumValN(GenRegisterBank, "gen-register-bank", | |
| "Generate registers bank descriptions"))); | |
| cl::OptionCategory PrintEnumsCat("Options for -print-enums"); | |
| cl::opt<std::string> | |
| Class("class", cl::desc("Print Enum list for this class"), | |
| cl::value_desc("class name"), cl::cat(PrintEnumsCat)); | |
| bool LLVMTableGenMain(raw_ostream &OS, RecordKeeper &Records) { | |
| switch (Action) { | |
| case PrintRecords: | |
| OS << Records; // No argument, dump all contents | |
| break; | |
| case DumpJSON: | |
| EmitJSON(Records, OS); | |
| break; | |
| case GenEmitter: | |
| EmitCodeEmitter(Records, OS); | |
| break; | |
| case GenRegisterInfo: | |
| EmitRegisterInfo(Records, OS); | |
| break; | |
| case GenInstrInfo: | |
| EmitInstrInfo(Records, OS); | |
| break; | |
| case GenInstrDocs: | |
| EmitInstrDocs(Records, OS); | |
| break; | |
| case GenCallingConv: | |
| EmitCallingConv(Records, OS); | |
| break; | |
| case GenAsmWriter: | |
| EmitAsmWriter(Records, OS); | |
| break; | |
| case GenAsmMatcher: | |
| EmitAsmMatcher(Records, OS); | |
| break; | |
| case GenDisassembler: | |
| EmitDisassembler(Records, OS); | |
| break; | |
| case GenPseudoLowering: | |
| EmitPseudoLowering(Records, OS); | |
| break; | |
| case GenCompressInst: | |
| EmitCompressInst(Records, OS); | |
| break; | |
| case GenDAGISel: | |
| EmitDAGISel(Records, OS); | |
| break; | |
| case GenDFAPacketizer: | |
| EmitDFAPacketizer(Records, OS); | |
| break; | |
| case GenFastISel: | |
| EmitFastISel(Records, OS); | |
| break; | |
| case GenSubtarget: | |
| EmitSubtarget(Records, OS); | |
| break; | |
| case GenIntrinsicEnums: | |
| EmitIntrinsicEnums(Records, OS); | |
| break; | |
| case GenIntrinsicImpl: | |
| EmitIntrinsicImpl(Records, OS); | |
| break; | |
| case GenTgtIntrinsicEnums: | |
| EmitIntrinsicEnums(Records, OS, true); | |
| break; | |
| case GenTgtIntrinsicImpl: | |
| EmitIntrinsicImpl(Records, OS, true); | |
| break; | |
| case GenOptParserDefs: | |
| EmitOptParser(Records, OS); | |
| break; | |
| case PrintEnums: | |
| { | |
| for (Record *Rec : Records.getAllDerivedDefinitions(Class)) | |
| OS << Rec->getName() << ", "; | |
| OS << "\n"; | |
| break; | |
| } | |
| case PrintSets: | |
| { | |
| SetTheory Sets; | |
| Sets.addFieldExpander("Set", "Elements"); | |
| for (Record *Rec : Records.getAllDerivedDefinitions("Set")) { | |
| OS << Rec->getName() << " = ["; | |
| const std::vector<Record*> *Elts = Sets.expand(Rec); | |
| assert(Elts && "Couldn't expand Set instance"); | |
| for (Record *Elt : *Elts) | |
| OS << ' ' << Elt->getName(); | |
| OS << " ]\n"; | |
| } | |
| break; | |
| } | |
| case GenCTags: | |
| EmitCTags(Records, OS); | |
| break; | |
| case GenAttributes: | |
| EmitAttributes(Records, OS); | |
| break; | |
| case GenSearchableTables: | |
| EmitSearchableTables(Records, OS); | |
| break; | |
| case GenGlobalISel: | |
| EmitGlobalISel(Records, OS); | |
| break; | |
| case GenRegisterBank: | |
| EmitRegisterBank(Records, OS); | |
| break; | |
| case GenX86EVEX2VEXTables: | |
| EmitX86EVEX2VEXTables(Records, OS); | |
| break; | |
| case GenX86FoldTables: | |
| EmitX86FoldTables(Records, OS); | |
| break; | |
| } | |
| return false; | |
| } | |
| } | |
| int main(int argc, char **argv) { | |
| sys::PrintStackTraceOnErrorSignal(argv[0]); | |
| PrettyStackTraceProgram X(argc, argv); | |
| cl::ParseCommandLineOptions(argc, argv); | |
| llvm_shutdown_obj Y; | |
| return TableGenMain(argv[0], &LLVMTableGenMain); | |
| } | |
| #ifdef __has_feature | |
| #if __has_feature(address_sanitizer) | |
| #include <sanitizer/lsan_interface.h> | |
| // Disable LeakSanitizer for this binary as it has too many leaks that are not | |
| // very interesting to fix. See compiler-rt/include/sanitizer/lsan_interface.h . | |
| LLVM_ATTRIBUTE_USED int __lsan_is_turned_off() { return 1; } | |
| #endif // __has_feature(address_sanitizer) | |
| #endif // defined(__has_feature) |