1 //===- TableGen.cpp - Top-Level TableGen implementation -------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // TableGen is a tool which can be used to build up a description of something, 11 // then invoke one or more "tablegen backends" to emit information about the 12 // description in some predefined format. In practice, this is used by the LLVM 13 // code generators to automate generation of a code generator through a 14 // high-level description of the target. 15 // 16 //===----------------------------------------------------------------------===// 17 18 #include "AsmMatcherEmitter.h" 19 #include "AsmWriterEmitter.h" 20 #include "CallingConvEmitter.h" 21 #include "ClangASTNodesEmitter.h" 22 #include "ClangAttrEmitter.h" 23 #include "ClangDiagnosticsEmitter.h" 24 #include "CodeEmitterGen.h" 25 #include "DAGISelEmitter.h" 26 #include "DisassemblerEmitter.h" 27 #include "EDEmitter.h" 28 #include "FastISelEmitter.h" 29 #include "InstrEnumEmitter.h" 30 #include "InstrInfoEmitter.h" 31 #include "IntrinsicEmitter.h" 32 #include "LLVMCConfigurationEmitter.h" 33 #include "NeonEmitter.h" 34 #include "OptParserEmitter.h" 35 #include "Record.h" 36 #include "RegisterInfoEmitter.h" 37 #include "ARMDecoderEmitter.h" 38 #include "SubtargetEmitter.h" 39 #include "TGParser.h" 40 #include "llvm/Support/CommandLine.h" 41 #include "llvm/Support/MemoryBuffer.h" 42 #include "llvm/Support/PrettyStackTrace.h" 43 #include "llvm/Support/raw_ostream.h" 44 #include "llvm/System/Signals.h" 45 #include <algorithm> 46 #include <cstdio> 47 using namespace llvm; 48 49 enum ActionType { 50 PrintRecords, 51 GenEmitter, 52 GenRegisterEnums, GenRegister, GenRegisterHeader, 53 GenInstrEnums, GenInstrs, GenAsmWriter, GenAsmMatcher, 54 GenARMDecoder, 55 GenDisassembler, 56 GenCallingConv, 57 GenClangAttrClasses, 58 GenClangAttrImpl, 59 GenClangAttrList, 60 GenClangAttrPCHRead, 61 GenClangAttrPCHWrite, 62 GenClangDiagsDefs, 63 GenClangDiagGroups, 64 GenClangDeclNodes, 65 GenClangStmtNodes, 66 GenDAGISel, 67 GenFastISel, 68 GenOptParserDefs, GenOptParserImpl, 69 GenSubtarget, 70 GenIntrinsic, 71 GenTgtIntrinsic, 72 GenLLVMCConf, 73 GenEDInfo, 74 GenArmNeon, 75 GenArmNeonSema, 76 PrintEnums 77 }; 78 79 namespace { 80 cl::opt<ActionType> 81 Action(cl::desc("Action to perform:"), 82 cl::values(clEnumValN(PrintRecords, "print-records", 83 "Print all records to stdout (default)"), 84 clEnumValN(GenEmitter, "gen-emitter", 85 "Generate machine code emitter"), 86 clEnumValN(GenRegisterEnums, "gen-register-enums", 87 "Generate enum values for registers"), 88 clEnumValN(GenRegister, "gen-register-desc", 89 "Generate a register info description"), 90 clEnumValN(GenRegisterHeader, "gen-register-desc-header", 91 "Generate a register info description header"), 92 clEnumValN(GenInstrEnums, "gen-instr-enums", 93 "Generate enum values for instructions"), 94 clEnumValN(GenInstrs, "gen-instr-desc", 95 "Generate instruction descriptions"), 96 clEnumValN(GenCallingConv, "gen-callingconv", 97 "Generate calling convention descriptions"), 98 clEnumValN(GenAsmWriter, "gen-asm-writer", 99 "Generate assembly writer"), 100 clEnumValN(GenARMDecoder, "gen-arm-decoder", 101 "Generate decoders for ARM/Thumb"), 102 clEnumValN(GenDisassembler, "gen-disassembler", 103 "Generate disassembler"), 104 clEnumValN(GenAsmMatcher, "gen-asm-matcher", 105 "Generate assembly instruction matcher"), 106 clEnumValN(GenDAGISel, "gen-dag-isel", 107 "Generate a DAG instruction selector"), 108 clEnumValN(GenFastISel, "gen-fast-isel", 109 "Generate a \"fast\" instruction selector"), 110 clEnumValN(GenOptParserDefs, "gen-opt-parser-defs", 111 "Generate option definitions"), 112 clEnumValN(GenOptParserImpl, "gen-opt-parser-impl", 113 "Generate option parser implementation"), 114 clEnumValN(GenSubtarget, "gen-subtarget", 115 "Generate subtarget enumerations"), 116 clEnumValN(GenIntrinsic, "gen-intrinsic", 117 "Generate intrinsic information"), 118 clEnumValN(GenTgtIntrinsic, "gen-tgt-intrinsic", 119 "Generate target intrinsic information"), 120 clEnumValN(GenClangAttrClasses, "gen-clang-attr-classes", 121 "Generate clang attribute clases"), 122 clEnumValN(GenClangAttrImpl, "gen-clang-attr-impl", 123 "Generate clang attribute implementations"), 124 clEnumValN(GenClangAttrList, "gen-clang-attr-list", 125 "Generate a clang attribute 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(GenClangDiagsDefs, "gen-clang-diags-defs", 131 "Generate Clang diagnostics definitions"), 132 clEnumValN(GenClangDiagGroups, "gen-clang-diag-groups", 133 "Generate Clang diagnostic groups"), 134 clEnumValN(GenClangDeclNodes, "gen-clang-decl-nodes", 135 "Generate Clang AST statement nodes"), 136 clEnumValN(GenClangStmtNodes, "gen-clang-stmt-nodes", 137 "Generate Clang AST statement nodes"), 138 clEnumValN(GenLLVMCConf, "gen-llvmc", 139 "Generate LLVMC configuration library"), 140 clEnumValN(GenEDInfo, "gen-enhanced-disassembly-info", 141 "Generate enhanced disassembly info"), 142 clEnumValN(GenArmNeon, "gen-arm-neon", 143 "Generate arm_neon.h for clang"), 144 clEnumValN(GenArmNeonSema, "gen-arm-neon-sema", 145 "Generate ARM NEON sema support for clang"), 146 clEnumValN(PrintEnums, "print-enums", 147 "Print enum values for a class"), 148 clEnumValEnd)); 149 150 cl::opt<std::string> 151 Class("class", cl::desc("Print Enum list for this class"), 152 cl::value_desc("class name")); 153 154 cl::opt<std::string> 155 OutputFilename("o", cl::desc("Output filename"), cl::value_desc("filename"), 156 cl::init("-")); 157 158 cl::opt<std::string> 159 InputFilename(cl::Positional, cl::desc("<input file>"), cl::init("-")); 160 161 cl::list<std::string> 162 IncludeDirs("I", cl::desc("Directory of include files"), 163 cl::value_desc("directory"), cl::Prefix); 164 165 cl::opt<std::string> 166 ClangComponent("clang-component", 167 cl::desc("Only use warnings from specified component"), 168 cl::value_desc("component"), cl::Hidden); 169 } 170 171 172 // FIXME: Eliminate globals from tblgen. 173 RecordKeeper llvm::Records; 174 175 static SourceMgr SrcMgr; 176 177 void llvm::PrintError(SMLoc ErrorLoc, const std::string &Msg) { 178 SrcMgr.PrintMessage(ErrorLoc, Msg, "error"); 179 } 180 181 182 183 /// ParseFile - this function begins the parsing of the specified tablegen 184 /// file. 185 static bool ParseFile(const std::string &Filename, 186 const std::vector<std::string> &IncludeDirs, 187 SourceMgr &SrcMgr) { 188 std::string ErrorStr; 189 MemoryBuffer *F = MemoryBuffer::getFileOrSTDIN(Filename.c_str(), &ErrorStr); 190 if (F == 0) { 191 errs() << "Could not open input file '" << Filename << "': " 192 << ErrorStr <<"\n"; 193 return true; 194 } 195 196 // Tell SrcMgr about this buffer, which is what TGParser will pick up. 197 SrcMgr.AddNewSourceBuffer(F, SMLoc()); 198 199 // Record the location of the include directory so that the lexer can find 200 // it later. 201 SrcMgr.setIncludeDirs(IncludeDirs); 202 203 TGParser Parser(SrcMgr); 204 205 return Parser.ParseFile(); 206 } 207 208 int main(int argc, char **argv) { 209 sys::PrintStackTraceOnErrorSignal(); 210 PrettyStackTraceProgram X(argc, argv); 211 cl::ParseCommandLineOptions(argc, argv); 212 213 214 // Parse the input file. 215 if (ParseFile(InputFilename, IncludeDirs, SrcMgr)) 216 return 1; 217 218 std::string Error; 219 tool_output_file Out(OutputFilename.c_str(), Error); 220 if (!Error.empty()) { 221 errs() << argv[0] << ": error opening " << OutputFilename 222 << ":" << Error << "\n"; 223 return 1; 224 } 225 226 try { 227 switch (Action) { 228 case PrintRecords: 229 Out.os() << Records; // No argument, dump all contents 230 break; 231 case GenEmitter: 232 CodeEmitterGen(Records).run(Out.os()); 233 break; 234 235 case GenRegisterEnums: 236 RegisterInfoEmitter(Records).runEnums(Out.os()); 237 break; 238 case GenRegister: 239 RegisterInfoEmitter(Records).run(Out.os()); 240 break; 241 case GenRegisterHeader: 242 RegisterInfoEmitter(Records).runHeader(Out.os()); 243 break; 244 case GenInstrEnums: 245 InstrEnumEmitter(Records).run(Out.os()); 246 break; 247 case GenInstrs: 248 InstrInfoEmitter(Records).run(Out.os()); 249 break; 250 case GenCallingConv: 251 CallingConvEmitter(Records).run(Out.os()); 252 break; 253 case GenAsmWriter: 254 AsmWriterEmitter(Records).run(Out.os()); 255 break; 256 case GenARMDecoder: 257 ARMDecoderEmitter(Records).run(Out.os()); 258 break; 259 case GenAsmMatcher: 260 AsmMatcherEmitter(Records).run(Out.os()); 261 break; 262 case GenClangAttrClasses: 263 ClangAttrClassEmitter(Records).run(Out.os()); 264 break; 265 case GenClangAttrImpl: 266 ClangAttrImplEmitter(Records).run(Out.os()); 267 break; 268 case GenClangAttrList: 269 ClangAttrListEmitter(Records).run(Out.os()); 270 break; 271 case GenClangAttrPCHRead: 272 ClangAttrPCHReadEmitter(Records).run(Out.os()); 273 break; 274 case GenClangAttrPCHWrite: 275 ClangAttrPCHWriteEmitter(Records).run(Out.os()); 276 break; 277 case GenClangDiagsDefs: 278 ClangDiagsDefsEmitter(Records, ClangComponent).run(Out.os()); 279 break; 280 case GenClangDiagGroups: 281 ClangDiagGroupsEmitter(Records).run(Out.os()); 282 break; 283 case GenClangDeclNodes: 284 ClangASTNodesEmitter(Records, "Decl", "Decl").run(Out.os()); 285 ClangDeclContextEmitter(Records).run(Out.os()); 286 break; 287 case GenClangStmtNodes: 288 ClangASTNodesEmitter(Records, "Stmt", "").run(Out.os()); 289 break; 290 case GenDisassembler: 291 DisassemblerEmitter(Records).run(Out.os()); 292 break; 293 case GenOptParserDefs: 294 OptParserEmitter(Records, true).run(Out.os()); 295 break; 296 case GenOptParserImpl: 297 OptParserEmitter(Records, false).run(Out.os()); 298 break; 299 case GenDAGISel: 300 DAGISelEmitter(Records).run(Out.os()); 301 break; 302 case GenFastISel: 303 FastISelEmitter(Records).run(Out.os()); 304 break; 305 case GenSubtarget: 306 SubtargetEmitter(Records).run(Out.os()); 307 break; 308 case GenIntrinsic: 309 IntrinsicEmitter(Records).run(Out.os()); 310 break; 311 case GenTgtIntrinsic: 312 IntrinsicEmitter(Records, true).run(Out.os()); 313 break; 314 case GenLLVMCConf: 315 LLVMCConfigurationEmitter(Records).run(Out.os()); 316 break; 317 case GenEDInfo: 318 EDEmitter(Records).run(Out.os()); 319 break; 320 case GenArmNeon: 321 NeonEmitter(Records).run(Out.os()); 322 break; 323 case GenArmNeonSema: 324 NeonEmitter(Records).runHeader(Out.os()); 325 break; 326 case PrintEnums: 327 { 328 std::vector<Record*> Recs = Records.getAllDerivedDefinitions(Class); 329 for (unsigned i = 0, e = Recs.size(); i != e; ++i) 330 Out.os() << Recs[i]->getName() << ", "; 331 Out.os() << "\n"; 332 break; 333 } 334 default: 335 assert(1 && "Invalid Action"); 336 return 1; 337 } 338 339 // Declare success. 340 Out.keep(); 341 return 0; 342 343 } catch (const TGError &Error) { 344 errs() << argv[0] << ": error:\n"; 345 PrintError(Error.getLoc(), Error.getMessage()); 346 347 } catch (const std::string &Error) { 348 errs() << argv[0] << ": " << Error << "\n"; 349 } catch (const char *Error) { 350 errs() << argv[0] << ": " << Error << "\n"; 351 } catch (...) { 352 errs() << argv[0] << ": Unknown unexpected exception occurred.\n"; 353 } 354 355 return 1; 356 } 357