1 //===- TableGenBackends.h - Declarations for LLVM TableGen Backends -------===// 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 // This file contains the declarations for all of the LLVM TableGen 11 // backends. A "TableGen backend" is just a function. See below for a 12 // precise description. 13 // 14 //===----------------------------------------------------------------------===// 15 16 #ifndef LLVM_UTILS_TABLEGEN_TABLEGENBACKENDS_H 17 #define LLVM_UTILS_TABLEGEN_TABLEGENBACKENDS_H 18 19 // A TableGen backend is a function that looks like 20 // 21 // EmitFoo(RecordKeeper &RK, raw_ostream &OS /*, anything else you need */ ) 22 // 23 // What you do inside of that function is up to you, but it will usually 24 // involve generating C++ code to the provided raw_ostream. 25 // 26 // The RecordKeeper is just a top-level container for an in-memory 27 // representation of the data encoded in the TableGen file. What a TableGen 28 // backend does is walk around that in-memory representation and generate 29 // stuff based on the information it contains. 30 // 31 // The in-memory representation is a node-graph (think of it like JSON but 32 // with a richer ontology of types), where the nodes are subclasses of 33 // Record. The methods `getClass`, `getDef` are the basic interface to 34 // access the node-graph. RecordKeeper also provides a handy method 35 // `getAllDerivedDefinitions`. Consult "include/llvm/TableGen/Record.h" for 36 // the exact interfaces provided by Record's and RecordKeeper. 37 // 38 // A common pattern for TableGen backends is for the EmitFoo function to 39 // instantiate a class which holds some context for the generation process, 40 // and then have most of the work happen in that class's methods. This 41 // pattern partly has historical roots in the previous TableGen backend API 42 // that involved a class and an invocation like `FooEmitter(RK).run(OS)`. 43 // 44 // Remember to wrap private things in an anonymous namespace. For most 45 // backends, this means that the EmitFoo function is the only thing not in 46 // the anonymous namespace. 47 48 49 // FIXME: Reorganize TableGen so that build dependencies can be more 50 // accurately expressed. Currently, touching any of the emitters (or 51 // anything that they transitively depend on) causes everything dependent 52 // on TableGen to be rebuilt (this includes all the targets!). Perhaps have 53 // a standalone TableGen binary and have the backends be loadable modules 54 // of some sort; then the dependency could be expressed as being on the 55 // module, and all the modules would have a common dependency on the 56 // TableGen binary with as few dependencies as possible on the rest of 57 // LLVM. 58 59 60 namespace llvm { 61 62 class raw_ostream; 63 class RecordKeeper; 64 65 void EmitIntrinsics(RecordKeeper &RK, raw_ostream &OS, bool TargetOnly = false); 66 void EmitAsmMatcher(RecordKeeper &RK, raw_ostream &OS); 67 void EmitAsmWriter(RecordKeeper &RK, raw_ostream &OS); 68 void EmitCallingConv(RecordKeeper &RK, raw_ostream &OS); 69 void EmitCodeEmitter(RecordKeeper &RK, raw_ostream &OS); 70 void EmitDAGISel(RecordKeeper &RK, raw_ostream &OS); 71 void EmitDFAPacketizer(RecordKeeper &RK, raw_ostream &OS); 72 void EmitDisassembler(RecordKeeper &RK, raw_ostream &OS); 73 void EmitFastISel(RecordKeeper &RK, raw_ostream &OS); 74 void EmitInstrInfo(RecordKeeper &RK, raw_ostream &OS); 75 void EmitPseudoLowering(RecordKeeper &RK, raw_ostream &OS); 76 void EmitRegisterInfo(RecordKeeper &RK, raw_ostream &OS); 77 void EmitSubtarget(RecordKeeper &RK, raw_ostream &OS); 78 void EmitMapTable(RecordKeeper &RK, raw_ostream &OS); 79 void EmitOptParser(RecordKeeper &RK, raw_ostream &OS); 80 void EmitCTags(RecordKeeper &RK, raw_ostream &OS); 81 82 } // End llvm namespace 83 84 #endif 85