1 //===- TableGen.cpp - Top-Level TableGen implementation for LLVM ----------===// 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 LLVM's TableGen. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "TableGenBackends.h" // Declares all backends. 14 #include "llvm/Support/CommandLine.h" 15 #include "llvm/Support/ManagedStatic.h" 16 #include "llvm/Support/PrettyStackTrace.h" 17 #include "llvm/Support/Signals.h" 18 #include "llvm/TableGen/Main.h" 19 #include "llvm/TableGen/Record.h" 20 #include "llvm/TableGen/SetTheory.h" 21 22 using namespace llvm; 23 24 enum ActionType { 25 PrintRecords, 26 DumpJSON, 27 GenEmitter, 28 GenRegisterInfo, 29 GenInstrInfo, 30 GenInstrDocs, 31 GenAsmWriter, 32 GenAsmMatcher, 33 GenDisassembler, 34 GenPseudoLowering, 35 GenCompressInst, 36 GenCallingConv, 37 GenDAGISel, 38 GenDFAPacketizer, 39 GenFastISel, 40 GenSubtarget, 41 GenIntrinsicEnums, 42 GenIntrinsicImpl, 43 PrintEnums, 44 PrintSets, 45 GenOptParserDefs, 46 GenOptRST, 47 GenCTags, 48 GenAttributes, 49 GenSearchableTables, 50 GenGlobalISel, 51 GenGICombiner, 52 GenX86EVEX2VEXTables, 53 GenX86FoldTables, 54 GenRegisterBank, 55 GenExegesis, 56 GenAutomata, 57 GenDirectivesEnums, 58 }; 59 60 namespace llvm { 61 /// Storage for TimeRegionsOpt as a global so that backends aren't required to 62 /// include CommandLine.h 63 bool TimeRegions = false; 64 cl::opt<bool> EmitLongStrLiterals( 65 "long-string-literals", 66 cl::desc("when emitting large string tables, prefer string literals over " 67 "comma-separated char literals. This can be a readability and " 68 "compile-time performance win, but upsets some compilers"), 69 cl::Hidden, cl::init(true)); 70 } // end namespace llvm 71 72 namespace { 73 cl::opt<ActionType> Action( 74 cl::desc("Action to perform:"), 75 cl::values( 76 clEnumValN(PrintRecords, "print-records", 77 "Print all records to stdout (default)"), 78 clEnumValN(DumpJSON, "dump-json", 79 "Dump all records as machine-readable JSON"), 80 clEnumValN(GenEmitter, "gen-emitter", "Generate machine code emitter"), 81 clEnumValN(GenRegisterInfo, "gen-register-info", 82 "Generate registers and register classes info"), 83 clEnumValN(GenInstrInfo, "gen-instr-info", 84 "Generate instruction descriptions"), 85 clEnumValN(GenInstrDocs, "gen-instr-docs", 86 "Generate instruction documentation"), 87 clEnumValN(GenCallingConv, "gen-callingconv", 88 "Generate calling convention descriptions"), 89 clEnumValN(GenAsmWriter, "gen-asm-writer", "Generate assembly writer"), 90 clEnumValN(GenDisassembler, "gen-disassembler", 91 "Generate disassembler"), 92 clEnumValN(GenPseudoLowering, "gen-pseudo-lowering", 93 "Generate pseudo instruction lowering"), 94 clEnumValN(GenCompressInst, "gen-compress-inst-emitter", 95 "Generate RISCV compressed instructions."), 96 clEnumValN(GenAsmMatcher, "gen-asm-matcher", 97 "Generate assembly instruction matcher"), 98 clEnumValN(GenDAGISel, "gen-dag-isel", 99 "Generate a DAG instruction selector"), 100 clEnumValN(GenDFAPacketizer, "gen-dfa-packetizer", 101 "Generate DFA Packetizer for VLIW targets"), 102 clEnumValN(GenFastISel, "gen-fast-isel", 103 "Generate a \"fast\" instruction selector"), 104 clEnumValN(GenSubtarget, "gen-subtarget", 105 "Generate subtarget enumerations"), 106 clEnumValN(GenIntrinsicEnums, "gen-intrinsic-enums", 107 "Generate intrinsic enums"), 108 clEnumValN(GenIntrinsicImpl, "gen-intrinsic-impl", 109 "Generate intrinsic information"), 110 clEnumValN(PrintEnums, "print-enums", "Print enum values for a class"), 111 clEnumValN(PrintSets, "print-sets", 112 "Print expanded sets for testing DAG exprs"), 113 clEnumValN(GenOptParserDefs, "gen-opt-parser-defs", 114 "Generate option definitions"), 115 clEnumValN(GenOptRST, "gen-opt-rst", "Generate option RST"), 116 clEnumValN(GenCTags, "gen-ctags", "Generate ctags-compatible index"), 117 clEnumValN(GenAttributes, "gen-attrs", "Generate attributes"), 118 clEnumValN(GenSearchableTables, "gen-searchable-tables", 119 "Generate generic binary-searchable table"), 120 clEnumValN(GenGlobalISel, "gen-global-isel", 121 "Generate GlobalISel selector"), 122 clEnumValN(GenGICombiner, "gen-global-isel-combiner", 123 "Generate GlobalISel combiner"), 124 clEnumValN(GenX86EVEX2VEXTables, "gen-x86-EVEX2VEX-tables", 125 "Generate X86 EVEX to VEX compress tables"), 126 clEnumValN(GenX86FoldTables, "gen-x86-fold-tables", 127 "Generate X86 fold tables"), 128 clEnumValN(GenRegisterBank, "gen-register-bank", 129 "Generate registers bank descriptions"), 130 clEnumValN(GenExegesis, "gen-exegesis", 131 "Generate llvm-exegesis tables"), 132 clEnumValN(GenAutomata, "gen-automata", "Generate generic automata"), 133 clEnumValN(GenDirectivesEnums, "gen-directive-decls", 134 "Generate directive related declaration code"))); 135 136 cl::OptionCategory PrintEnumsCat("Options for -print-enums"); 137 cl::opt<std::string> Class("class", cl::desc("Print Enum list for this class"), 138 cl::value_desc("class name"), 139 cl::cat(PrintEnumsCat)); 140 141 cl::opt<bool, true> 142 TimeRegionsOpt("time-regions", 143 cl::desc("Time regions of tablegens execution"), 144 cl::location(TimeRegions)); 145 146 bool LLVMTableGenMain(raw_ostream &OS, RecordKeeper &Records) { 147 switch (Action) { 148 case PrintRecords: 149 OS << Records; // No argument, dump all contents 150 break; 151 case DumpJSON: 152 EmitJSON(Records, OS); 153 break; 154 case GenEmitter: 155 EmitCodeEmitter(Records, OS); 156 break; 157 case GenRegisterInfo: 158 EmitRegisterInfo(Records, OS); 159 break; 160 case GenInstrInfo: 161 EmitInstrInfo(Records, OS); 162 break; 163 case GenInstrDocs: 164 EmitInstrDocs(Records, OS); 165 break; 166 case GenCallingConv: 167 EmitCallingConv(Records, OS); 168 break; 169 case GenAsmWriter: 170 EmitAsmWriter(Records, OS); 171 break; 172 case GenAsmMatcher: 173 EmitAsmMatcher(Records, OS); 174 break; 175 case GenDisassembler: 176 EmitDisassembler(Records, OS); 177 break; 178 case GenPseudoLowering: 179 EmitPseudoLowering(Records, OS); 180 break; 181 case GenCompressInst: 182 EmitCompressInst(Records, OS); 183 break; 184 case GenDAGISel: 185 EmitDAGISel(Records, OS); 186 break; 187 case GenDFAPacketizer: 188 EmitDFAPacketizer(Records, OS); 189 break; 190 case GenFastISel: 191 EmitFastISel(Records, OS); 192 break; 193 case GenSubtarget: 194 EmitSubtarget(Records, OS); 195 break; 196 case GenIntrinsicEnums: 197 EmitIntrinsicEnums(Records, OS); 198 break; 199 case GenIntrinsicImpl: 200 EmitIntrinsicImpl(Records, OS); 201 break; 202 case GenOptParserDefs: 203 EmitOptParser(Records, OS); 204 break; 205 case GenOptRST: 206 EmitOptRST(Records, OS); 207 break; 208 case PrintEnums: 209 { 210 for (Record *Rec : Records.getAllDerivedDefinitions(Class)) 211 OS << Rec->getName() << ", "; 212 OS << "\n"; 213 break; 214 } 215 case PrintSets: 216 { 217 SetTheory Sets; 218 Sets.addFieldExpander("Set", "Elements"); 219 for (Record *Rec : Records.getAllDerivedDefinitions("Set")) { 220 OS << Rec->getName() << " = ["; 221 const std::vector<Record*> *Elts = Sets.expand(Rec); 222 assert(Elts && "Couldn't expand Set instance"); 223 for (Record *Elt : *Elts) 224 OS << ' ' << Elt->getName(); 225 OS << " ]\n"; 226 } 227 break; 228 } 229 case GenCTags: 230 EmitCTags(Records, OS); 231 break; 232 case GenAttributes: 233 EmitAttributes(Records, OS); 234 break; 235 case GenSearchableTables: 236 EmitSearchableTables(Records, OS); 237 break; 238 case GenGlobalISel: 239 EmitGlobalISel(Records, OS); 240 break; 241 case GenGICombiner: 242 EmitGICombiner(Records, OS); 243 break; 244 case GenRegisterBank: 245 EmitRegisterBank(Records, OS); 246 break; 247 case GenX86EVEX2VEXTables: 248 EmitX86EVEX2VEXTables(Records, OS); 249 break; 250 case GenX86FoldTables: 251 EmitX86FoldTables(Records, OS); 252 break; 253 case GenExegesis: 254 EmitExegesis(Records, OS); 255 break; 256 case GenAutomata: 257 EmitAutomata(Records, OS); 258 break; 259 case GenDirectivesEnums: 260 EmitDirectivesEnums(Records, OS); 261 break; 262 } 263 264 return false; 265 } 266 } 267 268 int main(int argc, char **argv) { 269 sys::PrintStackTraceOnErrorSignal(argv[0]); 270 PrettyStackTraceProgram X(argc, argv); 271 cl::ParseCommandLineOptions(argc, argv); 272 273 llvm_shutdown_obj Y; 274 275 return TableGenMain(argv[0], &LLVMTableGenMain); 276 } 277 278 #ifndef __has_feature 279 #define __has_feature(x) 0 280 #endif 281 282 #if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__) || \ 283 __has_feature(leak_sanitizer) 284 285 #include <sanitizer/lsan_interface.h> 286 // Disable LeakSanitizer for this binary as it has too many leaks that are not 287 // very interesting to fix. See compiler-rt/include/sanitizer/lsan_interface.h . 288 LLVM_ATTRIBUTE_USED int __lsan_is_turned_off() { return 1; } 289 290 #endif 291