Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 1 | <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" |
| 2 | "http://www.w3.org/TR/html4/strict.dtd"> |
| 3 | <html> |
| 4 | <head> |
| 5 | <title>TableGen Fundamentals</title> |
| 6 | <link rel="stylesheet" href="llvm.css" type="text/css"> |
| 7 | </head> |
| 8 | <body> |
| 9 | |
| 10 | <div class="doc_title">TableGen Fundamentals</div> |
| 11 | |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 12 | <div class="doc_text"> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 13 | <ul> |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 14 | <li><a href="#introduction">Introduction</a> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 15 | <ol> |
| 16 | <li><a href="#concepts">Basic concepts</a></li> |
| 17 | <li><a href="#example">An example record</a></li> |
| 18 | <li><a href="#running">Running TableGen</a></li> |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 19 | </ol></li> |
| 20 | <li><a href="#syntax">TableGen syntax</a> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 21 | <ol> |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 22 | <li><a href="#primitives">TableGen primitives</a> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 23 | <ol> |
| 24 | <li><a href="#comments">TableGen comments</a></li> |
| 25 | <li><a href="#types">The TableGen type system</a></li> |
| 26 | <li><a href="#values">TableGen values and expressions</a></li> |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 27 | </ol></li> |
| 28 | <li><a href="#classesdefs">Classes and definitions</a> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 29 | <ol> |
| 30 | <li><a href="#valuedef">Value definitions</a></li> |
| 31 | <li><a href="#recordlet">'let' expressions</a></li> |
| 32 | <li><a href="#templateargs">Class template arguments</a></li> |
Chris Lattner | 84b3598 | 2006-09-01 21:44:18 +0000 | [diff] [blame] | 33 | <li><a href="#multiclass">Multiclass definitions and instances</a></li> |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 34 | </ol></li> |
| 35 | <li><a href="#filescope">File scope entities</a> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 36 | <ol> |
| 37 | <li><a href="#include">File inclusion</a></li> |
| 38 | <li><a href="#globallet">'let' expressions</a></li> |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 39 | </ol></li> |
| 40 | </ol></li> |
| 41 | <li><a href="#backends">TableGen backends</a> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 42 | <ol> |
Chris Lattner | fa6f309 | 2004-02-06 06:04:25 +0000 | [diff] [blame] | 43 | <li><a href="#">todo</a></li> |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 44 | </ol></li> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 45 | </ul> |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 46 | </div> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 47 | |
Chris Lattner | 7911ce2 | 2004-05-23 21:07:27 +0000 | [diff] [blame] | 48 | <div class="doc_author"> |
| 49 | <p>Written by <a href="mailto:sabre@nondot.org">Chris Lattner</a></p> |
| 50 | </div> |
| 51 | |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 52 | <!-- *********************************************************************** --> |
| 53 | <div class="doc_section"><a name="introduction">Introduction</a></div> |
| 54 | <!-- *********************************************************************** --> |
| 55 | |
| 56 | <div class="doc_text"> |
| 57 | |
| 58 | <p>TableGen's purpose is to help a human develop and maintain records of |
| 59 | domain-specific information. Because there may be a large number of these |
| 60 | records, it is specifically designed to allow writing flexible descriptions and |
| 61 | for common features of these records to be factored out. This reduces the |
| 62 | amount of duplication in the description, reduces the chance of error, and |
| 63 | makes it easier to structure domain specific information.</p> |
| 64 | |
| 65 | <p>The core part of TableGen <a href="#syntax">parses a file</a>, instantiates |
| 66 | the declarations, and hands the result off to a domain-specific "<a |
| 67 | href="#backends">TableGen backend</a>" for processing. The current major user |
Chris Lattner | 1aab327 | 2004-07-26 21:16:55 +0000 | [diff] [blame] | 68 | of TableGen is the <a href="CodeGenerator.html">LLVM code generator</a>.</p> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 69 | |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 70 | <p>Note that if you work on TableGen much, and use emacs or vim, that you can |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 71 | find an emacs "TableGen mode" and a vim language file in the |
| 72 | <tt>llvm/utils/emacs</tt> and <tt>llvm/utils/vim</tt> directories of your LLVM |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 73 | distribution, respectively.</p> |
Chris Lattner | fa6f309 | 2004-02-06 06:04:25 +0000 | [diff] [blame] | 74 | |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 75 | </div> |
| 76 | |
| 77 | <!-- ======================================================================= --> |
Jim Laskey | f1b5adb | 2006-09-09 09:10:37 +0000 | [diff] [blame] | 78 | <div class="doc_subsection"><a name="concepts">Basic concepts</a></div> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 79 | |
| 80 | <div class="doc_text"> |
| 81 | |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 82 | <p>TableGen files consist of two key parts: 'classes' and 'definitions', both |
| 83 | of which are considered 'records'.</p> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 84 | |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 85 | <p><b>TableGen records</b> have a unique name, a list of values, and a list of |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 86 | superclasses. The list of values is the main data that TableGen builds for each |
| 87 | record; it is this that holds the domain specific information for the |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 88 | application. The interpretation of this data is left to a specific <a |
| 89 | href="#backends">TableGen backend</a>, but the structure and format rules are |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 90 | taken care of and are fixed by TableGen.</p> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 91 | |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 92 | <p><b>TableGen definitions</b> are the concrete form of 'records'. These |
| 93 | generally do not have any undefined values, and are marked with the |
| 94 | '<tt>def</tt>' keyword.</p> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 95 | |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 96 | <p><b>TableGen classes</b> are abstract records that are used to build and |
| 97 | describe other records. These 'classes' allow the end-user to build |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 98 | abstractions for either the domain they are targeting (such as "Register", |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 99 | "RegisterClass", and "Instruction" in the LLVM code generator) or for the |
| 100 | implementor to help factor out common properties of records (such as "FPInst", |
| 101 | which is used to represent floating point instructions in the X86 backend). |
| 102 | TableGen keeps track of all of the classes that are used to build up a |
| 103 | definition, so the backend can find all definitions of a particular class, such |
| 104 | as "Instruction".</p> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 105 | |
Chris Lattner | 84b3598 | 2006-09-01 21:44:18 +0000 | [diff] [blame] | 106 | <p><b>TableGen multiclasses</b> are groups of abstract records that are |
David Greene | de444af | 2009-04-22 16:42:54 +0000 | [diff] [blame] | 107 | instantiated all at once. Each instantiation can result in multiple |
| 108 | TableGen definitions. If a multiclass inherits from another multiclass, |
| 109 | the definitions in the sub-multiclass become part of the current |
| 110 | multiclass, as if they were declared in the current multiclass.</p> |
Chris Lattner | 84b3598 | 2006-09-01 21:44:18 +0000 | [diff] [blame] | 111 | |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 112 | </div> |
| 113 | |
| 114 | <!-- ======================================================================= --> |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 115 | <div class="doc_subsection"><a name="example">An example record</a></div> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 116 | |
| 117 | <div class="doc_text"> |
| 118 | |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 119 | <p>With no other arguments, TableGen parses the specified file and prints out |
| 120 | all of the classes, then all of the definitions. This is a good way to see what |
| 121 | the various definitions expand to fully. Running this on the <tt>X86.td</tt> |
| 122 | file prints this (at the time of this writing):</p> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 123 | |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 124 | <div class="doc_code"> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 125 | <pre> |
| 126 | ... |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 127 | <b>def</b> ADD32rr { <i>// Instruction X86Inst I</i> |
Chris Lattner | fa6f309 | 2004-02-06 06:04:25 +0000 | [diff] [blame] | 128 | <b>string</b> Namespace = "X86"; |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 129 | <b>dag</b> OutOperandList = (outs GR32:$dst); |
| 130 | <b>dag</b> InOperandList = (ins GR32:$src1, GR32:$src2); |
| 131 | <b>string</b> AsmString = "add{l}\t{$src2, $dst|$dst, $src2}"; |
| 132 | <b>list</b><dag> Pattern = [(set GR32:$dst, (add GR32:$src1, GR32:$src2))]; |
Chris Lattner | fa6f309 | 2004-02-06 06:04:25 +0000 | [diff] [blame] | 133 | <b>list</b><Register> Uses = []; |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 134 | <b>list</b><Register> Defs = [EFLAGS]; |
| 135 | <b>list</b><Predicate> Predicates = []; |
| 136 | <b>int</b> CodeSize = 3; |
| 137 | <b>int</b> AddedComplexity = 0; |
Chris Lattner | fa6f309 | 2004-02-06 06:04:25 +0000 | [diff] [blame] | 138 | <b>bit</b> isReturn = 0; |
| 139 | <b>bit</b> isBranch = 0; |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 140 | <b>bit</b> isIndirectBranch = 0; |
| 141 | <b>bit</b> isBarrier = 0; |
Chris Lattner | fa6f309 | 2004-02-06 06:04:25 +0000 | [diff] [blame] | 142 | <b>bit</b> isCall = 0; |
Dan Gohman | 15511cf | 2008-12-03 18:15:48 +0000 | [diff] [blame] | 143 | <b>bit</b> canFoldAsLoad = 0; |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 144 | <b>bit</b> mayLoad = 0; |
| 145 | <b>bit</b> mayStore = 0; |
| 146 | <b>bit</b> isImplicitDef = 0; |
Chris Lattner | fa6f309 | 2004-02-06 06:04:25 +0000 | [diff] [blame] | 147 | <b>bit</b> isTwoAddress = 1; |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 148 | <b>bit</b> isConvertibleToThreeAddress = 1; |
| 149 | <b>bit</b> isCommutable = 1; |
Chris Lattner | fa6f309 | 2004-02-06 06:04:25 +0000 | [diff] [blame] | 150 | <b>bit</b> isTerminator = 0; |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 151 | <b>bit</b> isReMaterializable = 0; |
| 152 | <b>bit</b> isPredicable = 0; |
| 153 | <b>bit</b> hasDelaySlot = 0; |
| 154 | <b>bit</b> usesCustomDAGSchedInserter = 0; |
| 155 | <b>bit</b> hasCtrlDep = 0; |
| 156 | <b>bit</b> isNotDuplicable = 0; |
| 157 | <b>bit</b> hasSideEffects = 0; |
| 158 | <b>bit</b> mayHaveSideEffects = 0; |
| 159 | <b>bit</b> neverHasSideEffects = 0; |
| 160 | InstrItinClass Itinerary = NoItinerary; |
| 161 | <b>string</b> Constraints = ""; |
| 162 | <b>string</b> DisableEncoding = ""; |
| 163 | <b>bits</b><8> Opcode = { 0, 0, 0, 0, 0, 0, 0, 1 }; |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 164 | Format Form = MRMDestReg; |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 165 | <b>bits</b><6> FormBits = { 0, 0, 0, 0, 1, 1 }; |
| 166 | ImmType ImmT = NoImm; |
| 167 | <b>bits</b><3> ImmTypeBits = { 0, 0, 0 }; |
Chris Lattner | fa6f309 | 2004-02-06 06:04:25 +0000 | [diff] [blame] | 168 | <b>bit</b> hasOpSizePrefix = 0; |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 169 | <b>bit</b> hasAdSizePrefix = 0; |
Chris Lattner | fa6f309 | 2004-02-06 06:04:25 +0000 | [diff] [blame] | 170 | <b>bits</b><4> Prefix = { 0, 0, 0, 0 }; |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 171 | <b>bit</b> hasREX_WPrefix = 0; |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 172 | FPFormat FPForm = ?; |
Chris Lattner | fa6f309 | 2004-02-06 06:04:25 +0000 | [diff] [blame] | 173 | <b>bits</b><3> FPFormBits = { 0, 0, 0 }; |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 174 | } |
| 175 | ... |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 176 | </pre> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 177 | </div> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 178 | |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 179 | <p>This definition corresponds to a 32-bit register-register add instruction in |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 180 | the X86. The string after the '<tt>def</tt>' string indicates the name of the |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 181 | record—"<tt>ADD32rr</tt>" in this case—and the comment at the end of |
| 182 | the line indicates the superclasses of the definition. The body of the record |
| 183 | contains all of the data that TableGen assembled for the record, indicating that |
| 184 | the instruction is part of the "X86" namespace, the pattern indicating how the |
| 185 | the instruction should be emitted into the assembly file, that it is a |
| 186 | two-address instruction, has a particular encoding, etc. The contents and |
| 187 | semantics of the information in the record is specific to the needs of the X86 |
| 188 | backend, and is only shown as an example.</p> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 189 | |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 190 | <p>As you can see, a lot of information is needed for every instruction |
| 191 | supported by the code generator, and specifying it all manually would be |
| 192 | unmaintainble, prone to bugs, and tiring to do in the first place. Because we |
| 193 | are using TableGen, all of the information was derived from the following |
| 194 | definition:</p> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 195 | |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 196 | <div class="doc_code"> |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 197 | <pre> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 198 | let Defs = [EFLAGS], |
| 199 | isCommutable = 1, <i>// X = ADD Y,Z --> X = ADD Z,Y</i> |
| 200 | isConvertibleToThreeAddress = 1 <b>in</b> <i>// Can transform into LEA.</i> |
| 201 | def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), |
| 202 | (ins GR32:$src1, GR32:$src2), |
| 203 | "add{l}\t{$src2, $dst|$dst, $src2}", |
| 204 | [(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>; |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 205 | </pre> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 206 | </div> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 207 | |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 208 | <p>This definition makes use of the custom class <tt>I</tt> (extended from the |
| 209 | custom class <tt>X86Inst</tt>), which is defined in the X86-specific TableGen |
| 210 | file, to factor out the common features that instructions of its class share. A |
| 211 | key feature of TableGen is that it allows the end-user to define the |
| 212 | abstractions they prefer to use when describing their information.</p> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 213 | |
| 214 | </div> |
| 215 | |
| 216 | <!-- ======================================================================= --> |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 217 | <div class="doc_subsection"><a name="running">Running TableGen</a></div> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 218 | |
| 219 | <div class="doc_text"> |
| 220 | |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 221 | <p>TableGen runs just like any other LLVM tool. The first (optional) argument |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 222 | specifies the file to read. If a filename is not specified, <tt>tblgen</tt> |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 223 | reads from standard input.</p> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 224 | |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 225 | <p>To be useful, one of the <a href="#backends">TableGen backends</a> must be |
| 226 | used. These backends are selectable on the command line (type '<tt>tblgen |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 227 | -help</tt>' for a list). For example, to get a list of all of the definitions |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 228 | that subclass a particular type (which can be useful for building up an enum |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 229 | list of these records), use the <tt>-print-enums</tt> option:</p> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 230 | |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 231 | <div class="doc_code"> |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 232 | <pre> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 233 | $ tblgen X86.td -print-enums -class=Register |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 234 | AH, AL, AX, BH, BL, BP, BPL, BX, CH, CL, CX, DH, DI, DIL, DL, DX, EAX, EBP, EBX, |
| 235 | ECX, EDI, EDX, EFLAGS, EIP, ESI, ESP, FP0, FP1, FP2, FP3, FP4, FP5, FP6, IP, |
| 236 | MM0, MM1, MM2, MM3, MM4, MM5, MM6, MM7, R10, R10B, R10D, R10W, R11, R11B, R11D, |
| 237 | R11W, R12, R12B, R12D, R12W, R13, R13B, R13D, R13W, R14, R14B, R14D, R14W, R15, |
| 238 | R15B, R15D, R15W, R8, R8B, R8D, R8W, R9, R9B, R9D, R9W, RAX, RBP, RBX, RCX, RDI, |
| 239 | RDX, RIP, RSI, RSP, SI, SIL, SP, SPL, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, |
| 240 | XMM0, XMM1, XMM10, XMM11, XMM12, XMM13, XMM14, XMM15, XMM2, XMM3, XMM4, XMM5, |
| 241 | XMM6, XMM7, XMM8, XMM9, |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 242 | |
| 243 | $ tblgen X86.td -print-enums -class=Instruction |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 244 | ABS_F, ABS_Fp32, ABS_Fp64, ABS_Fp80, ADC32mi, ADC32mi8, ADC32mr, ADC32ri, |
| 245 | ADC32ri8, ADC32rm, ADC32rr, ADC64mi32, ADC64mi8, ADC64mr, ADC64ri32, ADC64ri8, |
| 246 | ADC64rm, ADC64rr, ADD16mi, ADD16mi8, ADD16mr, ADD16ri, ADD16ri8, ADD16rm, |
| 247 | ADD16rr, ADD32mi, ADD32mi8, ADD32mr, ADD32ri, ADD32ri8, ADD32rm, ADD32rr, |
| 248 | ADD64mi32, ADD64mi8, ADD64mr, ADD64ri32, ... |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 249 | </pre> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 250 | </div> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 251 | |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 252 | <p>The default backend prints out all of the records, as described <a |
| 253 | href="#example">above</a>.</p> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 254 | |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 255 | <p>If you plan to use TableGen, you will most likely have to <a |
| 256 | href="#backends">write a backend</a> that extracts the information specific to |
| 257 | what you need and formats it in the appropriate way.</p> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 258 | |
| 259 | </div> |
| 260 | |
| 261 | |
| 262 | <!-- *********************************************************************** --> |
| 263 | <div class="doc_section"><a name="syntax">TableGen syntax</a></div> |
| 264 | <!-- *********************************************************************** --> |
| 265 | |
| 266 | <div class="doc_text"> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 267 | |
| 268 | <p>TableGen doesn't care about the meaning of data (that is up to the backend to |
| 269 | define), but it does care about syntax, and it enforces a simple type system. |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 270 | This section describes the syntax and the constructs allowed in a TableGen file. |
| 271 | </p> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 272 | |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 273 | </div> |
| 274 | |
| 275 | <!-- ======================================================================= --> |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 276 | <div class="doc_subsection"><a name="primitives">TableGen primitives</a></div> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 277 | |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 278 | <!-- --------------------------------------------------------------------------> |
| 279 | <div class="doc_subsubsection"><a name="comments">TableGen comments</a></div> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 280 | |
| 281 | <div class="doc_text"> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 282 | |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 283 | <p>TableGen supports BCPL style "<tt>//</tt>" comments, which run to the end of |
| 284 | the line, and it also supports <b>nestable</b> "<tt>/* */</tt>" comments.</p> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 285 | |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 286 | </div> |
| 287 | |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 288 | <!-- --------------------------------------------------------------------------> |
Misha Brukman | 78b648c | 2004-06-03 16:59:59 +0000 | [diff] [blame] | 289 | <div class="doc_subsubsection"> |
| 290 | <a name="types">The TableGen type system</a> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 291 | </div> |
| 292 | |
| 293 | <div class="doc_text"> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 294 | |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 295 | <p>TableGen files are strongly typed, in a simple (but complete) type-system. |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 296 | These types are used to perform automatic conversions, check for errors, and to |
| 297 | help interface designers constrain the input that they allow. Every <a |
| 298 | href="#valuedef">value definition</a> is required to have an associated type. |
| 299 | </p> |
| 300 | |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 301 | <p>TableGen supports a mixture of very low-level types (such as <tt>bit</tt>) |
| 302 | and very high-level types (such as <tt>dag</tt>). This flexibility is what |
| 303 | allows it to describe a wide range of information conveniently and compactly. |
| 304 | The TableGen types are:</p> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 305 | |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 306 | <dl> |
Bill Wendling | 58d96d6 | 2008-02-12 07:09:05 +0000 | [diff] [blame] | 307 | <dt><tt><b>bit</b></tt></dt> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 308 | <dd>A 'bit' is a boolean value that can hold either 0 or 1.</dd> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 309 | |
Bill Wendling | 58d96d6 | 2008-02-12 07:09:05 +0000 | [diff] [blame] | 310 | <dt><tt><b>int</b></tt></dt> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 311 | <dd>The 'int' type represents a simple 32-bit integer value, such as 5.</dd> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 312 | |
Bill Wendling | 58d96d6 | 2008-02-12 07:09:05 +0000 | [diff] [blame] | 313 | <dt><tt><b>string</b></tt></dt> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 314 | <dd>The 'string' type represents an ordered sequence of characters of |
| 315 | arbitrary length.</dd> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 316 | |
Bill Wendling | 58d96d6 | 2008-02-12 07:09:05 +0000 | [diff] [blame] | 317 | <dt><tt><b>bits</b><n></tt></dt> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 318 | <dd>A 'bits' type is an arbitrary, but fixed, size integer that is broken up |
| 319 | into individual bits. This type is useful because it can handle some bits |
| 320 | being defined while others are undefined.</dd> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 321 | |
Bill Wendling | 58d96d6 | 2008-02-12 07:09:05 +0000 | [diff] [blame] | 322 | <dt><tt><b>list</b><ty></tt></dt> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 323 | <dd>This type represents a list whose elements are some other type. The |
| 324 | contained type is arbitrary: it can even be another list type.</dd> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 325 | |
Bill Wendling | 58d96d6 | 2008-02-12 07:09:05 +0000 | [diff] [blame] | 326 | <dt>Class type</dt> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 327 | <dd>Specifying a class name in a type context means that the defined value |
| 328 | must be a subclass of the specified class. This is useful in conjunction with |
| 329 | the <b><tt>list</tt></b> type, for example, to constrain the elements of the |
| 330 | list to a common base class (e.g., a <tt><b>list</b><Register></tt> can |
| 331 | only contain definitions derived from the "<tt>Register</tt>" class).</dd> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 332 | |
Bill Wendling | 58d96d6 | 2008-02-12 07:09:05 +0000 | [diff] [blame] | 333 | <dt><tt><b>dag</b></tt></dt> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 334 | <dd>This type represents a nestable directed graph of elements.</dd> |
| 335 | |
Bill Wendling | 58d96d6 | 2008-02-12 07:09:05 +0000 | [diff] [blame] | 336 | <dt><tt><b>code</b></tt></dt> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 337 | <dd>This represents a big hunk of text. NOTE: I don't remember why this is |
| 338 | distinct from string!</dd> |
| 339 | </dl> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 340 | |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 341 | <p>To date, these types have been sufficient for describing things that |
| 342 | TableGen has been used for, but it is straight-forward to extend this list if |
| 343 | needed.</p> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 344 | |
| 345 | </div> |
| 346 | |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 347 | <!-- --------------------------------------------------------------------------> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 348 | <div class="doc_subsubsection"> |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 349 | <a name="values">TableGen values and expressions</a> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 350 | </div> |
| 351 | |
Misha Brukman | 78b648c | 2004-06-03 16:59:59 +0000 | [diff] [blame] | 352 | <div class="doc_text"> |
| 353 | |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 354 | <p>TableGen allows for a pretty reasonable number of different expression forms |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 355 | when building up values. These forms allow the TableGen file to be written in a |
| 356 | natural syntax and flavor for the application. The current expression forms |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 357 | supported include:</p> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 358 | |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 359 | <dl> |
Bill Wendling | 58d96d6 | 2008-02-12 07:09:05 +0000 | [diff] [blame] | 360 | <dt><tt>?</tt></dt> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 361 | <dd>uninitialized field</dd> |
Bill Wendling | 58d96d6 | 2008-02-12 07:09:05 +0000 | [diff] [blame] | 362 | <dt><tt>0b1001011</tt></dt> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 363 | <dd>binary integer value</dd> |
Bill Wendling | 58d96d6 | 2008-02-12 07:09:05 +0000 | [diff] [blame] | 364 | <dt><tt>07654321</tt></dt> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 365 | <dd>octal integer value (indicated by a leading 0)</dd> |
Bill Wendling | 58d96d6 | 2008-02-12 07:09:05 +0000 | [diff] [blame] | 366 | <dt><tt>7</tt></dt> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 367 | <dd>decimal integer value</dd> |
Bill Wendling | 58d96d6 | 2008-02-12 07:09:05 +0000 | [diff] [blame] | 368 | <dt><tt>0x7F</tt></dt> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 369 | <dd>hexadecimal integer value</dd> |
Bill Wendling | 58d96d6 | 2008-02-12 07:09:05 +0000 | [diff] [blame] | 370 | <dt><tt>"foo"</tt></dt> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 371 | <dd>string value</dd> |
Bill Wendling | 58d96d6 | 2008-02-12 07:09:05 +0000 | [diff] [blame] | 372 | <dt><tt>[{ ... }]</tt></dt> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 373 | <dd>code fragment</dd> |
David Greene | ccbfb8d | 2009-06-08 22:38:07 +0000 | [diff] [blame] | 374 | <dt><tt>[ X, Y, Z ]<type></tt></dt> |
| 375 | <dd>list value. <type> is the type of the list |
| 376 | element and is usually optional. In rare cases, |
| 377 | TableGen is unable to deduce the element type in |
| 378 | which case the user must specify it explicitly.</dd> |
Bill Wendling | 58d96d6 | 2008-02-12 07:09:05 +0000 | [diff] [blame] | 379 | <dt><tt>{ a, b, c }</tt></dt> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 380 | <dd>initializer for a "bits<3>" value</dd> |
Bill Wendling | 58d96d6 | 2008-02-12 07:09:05 +0000 | [diff] [blame] | 381 | <dt><tt>value</tt></dt> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 382 | <dd>value reference</dd> |
Bill Wendling | 58d96d6 | 2008-02-12 07:09:05 +0000 | [diff] [blame] | 383 | <dt><tt>value{17}</tt></dt> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 384 | <dd>access to one bit of a value</dd> |
Bill Wendling | 58d96d6 | 2008-02-12 07:09:05 +0000 | [diff] [blame] | 385 | <dt><tt>value{15-17}</tt></dt> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 386 | <dd>access to multiple bits of a value</dd> |
Bill Wendling | 58d96d6 | 2008-02-12 07:09:05 +0000 | [diff] [blame] | 387 | <dt><tt>DEF</tt></dt> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 388 | <dd>reference to a record definition</dd> |
Bill Wendling | 58d96d6 | 2008-02-12 07:09:05 +0000 | [diff] [blame] | 389 | <dt><tt>CLASS<val list></tt></dt> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 390 | <dd>reference to a new anonymous definition of CLASS with the specified |
| 391 | template arguments.</dd> |
Bill Wendling | 58d96d6 | 2008-02-12 07:09:05 +0000 | [diff] [blame] | 392 | <dt><tt>X.Y</tt></dt> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 393 | <dd>reference to the subfield of a value</dd> |
Bill Wendling | 58d96d6 | 2008-02-12 07:09:05 +0000 | [diff] [blame] | 394 | <dt><tt>list[4-7,17,2-3]</tt></dt> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 395 | <dd>A slice of the 'list' list, including elements 4,5,6,7,17,2, and 3 from |
| 396 | it. Elements may be included multiple times.</dd> |
Bill Wendling | 58d96d6 | 2008-02-12 07:09:05 +0000 | [diff] [blame] | 397 | <dt><tt>(DEF a, b)</tt></dt> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 398 | <dd>a dag value. The first element is required to be a record definition, the |
| 399 | remaining elements in the list may be arbitrary other values, including nested |
| 400 | `<tt>dag</tt>' values.</dd> |
Evan Cheng | a7185b2 | 2009-05-18 22:14:45 +0000 | [diff] [blame] | 401 | <dt><tt>(implicit a)</tt></dt> |
| 402 | <dd>an implicitly defined physical register. This tells the dag instruction |
| 403 | selection emitter the input pattern's extra definitions matches implicit |
| 404 | physical register definitions.</dd> |
| 405 | <dt><tt>(parallel (a), (b))</tt></dt> |
| 406 | <dd>a list of dags specifying parallel operations which map to the same |
| 407 | instruction.</dd> |
Bill Wendling | 58d96d6 | 2008-02-12 07:09:05 +0000 | [diff] [blame] | 408 | <dt><tt>!strconcat(a, b)</tt></dt> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 409 | <dd>A string value that is the result of concatenating the 'a' and 'b' |
| 410 | strings.</dd> |
David Greene | e6c27de | 2009-05-14 21:22:49 +0000 | [diff] [blame] | 411 | <dt><tt>!cast<type>(a)</tt></dt> |
| 412 | <dd>A symbol of type <em>type</em> obtained by looking up the string 'a' in |
| 413 | the symbol table. If the type of 'a' does not match <em>type</em>, TableGen |
David Greene | 2c02662 | 2009-06-29 20:05:29 +0000 | [diff] [blame^] | 414 | aborts with an error. !cast<string> is a special case in that the argument must |
| 415 | be an object defined by a 'def' construct.</dd> |
David Greene | 3f47c29 | 2009-04-23 21:27:58 +0000 | [diff] [blame] | 416 | <dt><tt>!nameconcat<type>(a, b)</tt></dt> |
David Greene | e6c27de | 2009-05-14 21:22:49 +0000 | [diff] [blame] | 417 | <dd>Shorthand for !cast<type>(!strconcat(a, b))</dd> |
David Greene | 4afc509 | 2009-05-14 21:54:42 +0000 | [diff] [blame] | 418 | <dt><tt>!subst(a, b, c)</tt></dt> |
| 419 | <dd>If 'a' and 'b' are of string type or are symbol references, substitute |
| 420 | 'b' for 'a' in 'c.' This operation is analogous to $(subst) in GNU make.</dd> |
David Greene | beb31a5 | 2009-05-14 22:23:47 +0000 | [diff] [blame] | 421 | <dt><tt>!foreach(a, b, c)</tt></dt> |
| 422 | <dd>For each member 'b' of dag or list 'a' apply operator 'c.' 'b' is a |
| 423 | dummy variable that should be declared as a member variable of an instantiated |
| 424 | class. This operation is analogous to $(foreach) in GNU make.</dd> |
David Greene | 5f9f9ba | 2009-05-14 22:38:31 +0000 | [diff] [blame] | 425 | <dt><tt>!car(a)</tt></dt> |
| 426 | <dd>The first element of list 'a.'</dd> |
| 427 | <dt><tt>!cdr(a)</tt></dt> |
| 428 | <dd>The 2nd-N elements of list 'a.'</dd> |
| 429 | <dt><tt>!null(a)</tt></dt> |
| 430 | <dd>An integer {0,1} indicating whether list 'a' is empty.</dd> |
David Greene | 9bea7c8 | 2009-05-14 23:26:46 +0000 | [diff] [blame] | 431 | <dt><tt>!if(a,b,c)</tt></dt> |
| 432 | <dd>'b' if the result of integer operator 'a' is nonzero, 'c' otherwise.</dd> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 433 | </dl> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 434 | |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 435 | <p>Note that all of the values have rules specifying how they convert to values |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 436 | for different types. These rules allow you to assign a value like "<tt>7</tt>" |
| 437 | to a "<tt>bits<4></tt>" value, for example.</p> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 438 | |
| 439 | </div> |
| 440 | |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 441 | <!-- ======================================================================= --> |
Misha Brukman | 78b648c | 2004-06-03 16:59:59 +0000 | [diff] [blame] | 442 | <div class="doc_subsection"> |
| 443 | <a name="classesdefs">Classes and definitions</a> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 444 | </div> |
| 445 | |
Misha Brukman | 78b648c | 2004-06-03 16:59:59 +0000 | [diff] [blame] | 446 | <div class="doc_text"> |
| 447 | |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 448 | <p>As mentioned in the <a href="#concepts">intro</a>, classes and definitions |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 449 | (collectively known as 'records') in TableGen are the main high-level unit of |
| 450 | information that TableGen collects. Records are defined with a <tt>def</tt> or |
| 451 | <tt>class</tt> keyword, the record name, and an optional list of "<a |
Misha Brukman | 179bf4b | 2004-06-03 23:42:24 +0000 | [diff] [blame] | 452 | href="#templateargs">template arguments</a>". If the record has superclasses, |
Jeff Cohen | 0b81cda | 2005-10-24 16:54:55 +0000 | [diff] [blame] | 453 | they are specified as a comma separated list that starts with a colon character |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 454 | ("<tt>:</tt>"). If <a href="#valuedef">value definitions</a> or <a |
| 455 | href="#recordlet">let expressions</a> are needed for the class, they are |
| 456 | enclosed in curly braces ("<tt>{}</tt>"); otherwise, the record ends with a |
| 457 | semicolon.</p> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 458 | |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 459 | <p>Here is a simple TableGen file:</p> |
| 460 | |
| 461 | <div class="doc_code"> |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 462 | <pre> |
Chris Lattner | fa6f309 | 2004-02-06 06:04:25 +0000 | [diff] [blame] | 463 | <b>class</b> C { <b>bit</b> V = 1; } |
| 464 | <b>def</b> X : C; |
| 465 | <b>def</b> Y : C { |
| 466 | <b>string</b> Greeting = "hello"; |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 467 | } |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 468 | </pre> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 469 | </div> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 470 | |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 471 | <p>This example defines two definitions, <tt>X</tt> and <tt>Y</tt>, both of |
| 472 | which derive from the <tt>C</tt> class. Because of this, they both get the |
| 473 | <tt>V</tt> bit value. The <tt>Y</tt> definition also gets the Greeting member |
| 474 | as well.</p> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 475 | |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 476 | <p>In general, classes are useful for collecting together the commonality |
| 477 | between a group of records and isolating it in a single place. Also, classes |
| 478 | permit the specification of default values for their subclasses, allowing the |
| 479 | subclasses to override them as they wish.</p> |
Chris Lattner | 23f54fa | 2004-02-06 06:37:00 +0000 | [diff] [blame] | 480 | |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 481 | </div> |
| 482 | |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 483 | <!----------------------------------------------------------------------------> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 484 | <div class="doc_subsubsection"> |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 485 | <a name="valuedef">Value definitions</a> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 486 | </div> |
| 487 | |
| 488 | <div class="doc_text"> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 489 | |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 490 | <p>Value definitions define named entries in records. A value must be defined |
John Criswell | aa55c8c | 2004-02-12 18:11:53 +0000 | [diff] [blame] | 491 | before it can be referred to as the operand for another value definition or |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 492 | before the value is reset with a <a href="#recordlet">let expression</a>. A |
| 493 | value is defined by specifying a <a href="#types">TableGen type</a> and a name. |
| 494 | If an initial value is available, it may be specified after the type with an |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 495 | equal sign. Value definitions require terminating semicolons.</p> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 496 | |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 497 | </div> |
| 498 | |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 499 | <!-- --------------------------------------------------------------------------> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 500 | <div class="doc_subsubsection"> |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 501 | <a name="recordlet">'let' expressions</a> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 502 | </div> |
| 503 | |
| 504 | <div class="doc_text"> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 505 | |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 506 | <p>A record-level let expression is used to change the value of a value |
| 507 | definition in a record. This is primarily useful when a superclass defines a |
| 508 | value that a derived class or definition wants to override. Let expressions |
| 509 | consist of the '<tt>let</tt>' keyword followed by a value name, an equal sign |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 510 | ("<tt>=</tt>"), and a new value. For example, a new class could be added to the |
| 511 | example above, redefining the <tt>V</tt> field for all of its subclasses:</p> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 512 | |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 513 | <div class="doc_code"> |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 514 | <pre> |
Chris Lattner | fa6f309 | 2004-02-06 06:04:25 +0000 | [diff] [blame] | 515 | <b>class</b> D : C { let V = 0; } |
| 516 | <b>def</b> Z : D; |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 517 | </pre> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 518 | </div> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 519 | |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 520 | <p>In this case, the <tt>Z</tt> definition will have a zero value for its "V" |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 521 | value, despite the fact that it derives (indirectly) from the <tt>C</tt> class, |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 522 | because the <tt>D</tt> class overrode its value.</p> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 523 | |
| 524 | </div> |
| 525 | |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 526 | <!-- --------------------------------------------------------------------------> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 527 | <div class="doc_subsubsection"> |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 528 | <a name="templateargs">Class template arguments</a> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 529 | </div> |
| 530 | |
| 531 | <div class="doc_text"> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 532 | |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 533 | <p>TableGen permits the definition of parameterized classes as well as normal |
Chris Lattner | 23f54fa | 2004-02-06 06:37:00 +0000 | [diff] [blame] | 534 | concrete classes. Parameterized TableGen classes specify a list of variable |
| 535 | bindings (which may optionally have defaults) that are bound when used. Here is |
| 536 | a simple example:</p> |
| 537 | |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 538 | <div class="doc_code"> |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 539 | <pre> |
Chris Lattner | 23f54fa | 2004-02-06 06:37:00 +0000 | [diff] [blame] | 540 | <b>class</b> FPFormat<<b>bits</b><3> val> { |
| 541 | <b>bits</b><3> Value = val; |
| 542 | } |
| 543 | <b>def</b> NotFP : FPFormat<0>; |
| 544 | <b>def</b> ZeroArgFP : FPFormat<1>; |
| 545 | <b>def</b> OneArgFP : FPFormat<2>; |
| 546 | <b>def</b> OneArgFPRW : FPFormat<3>; |
| 547 | <b>def</b> TwoArgFP : FPFormat<4>; |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 548 | <b>def</b> CompareFP : FPFormat<5>; |
| 549 | <b>def</b> CondMovFP : FPFormat<6>; |
| 550 | <b>def</b> SpecialFP : FPFormat<7>; |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 551 | </pre> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 552 | </div> |
Chris Lattner | 23f54fa | 2004-02-06 06:37:00 +0000 | [diff] [blame] | 553 | |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 554 | <p>In this case, template arguments are used as a space efficient way to specify |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 555 | a list of "enumeration values", each with a "<tt>Value</tt>" field set to the |
| 556 | specified integer.</p> |
Chris Lattner | 23f54fa | 2004-02-06 06:37:00 +0000 | [diff] [blame] | 557 | |
| 558 | <p>The more esoteric forms of <a href="#values">TableGen expressions</a> are |
| 559 | useful in conjunction with template arguments. As an example:</p> |
| 560 | |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 561 | <div class="doc_code"> |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 562 | <pre> |
Chris Lattner | 23f54fa | 2004-02-06 06:37:00 +0000 | [diff] [blame] | 563 | <b>class</b> ModRefVal<<b>bits</b><2> val> { |
| 564 | <b>bits</b><2> Value = val; |
| 565 | } |
| 566 | |
| 567 | <b>def</b> None : ModRefVal<0>; |
| 568 | <b>def</b> Mod : ModRefVal<1>; |
| 569 | <b>def</b> Ref : ModRefVal<2>; |
| 570 | <b>def</b> ModRef : ModRefVal<3>; |
| 571 | |
| 572 | <b>class</b> Value<ModRefVal MR> { |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 573 | <i>// Decode some information into a more convenient format, while providing |
Chris Lattner | 23f54fa | 2004-02-06 06:37:00 +0000 | [diff] [blame] | 574 | // a nice interface to the user of the "Value" class.</i> |
| 575 | <b>bit</b> isMod = MR.Value{0}; |
| 576 | <b>bit</b> isRef = MR.Value{1}; |
| 577 | |
| 578 | <i>// other stuff...</i> |
| 579 | } |
| 580 | |
| 581 | <i>// Example uses</i> |
| 582 | <b>def</b> bork : Value<Mod>; |
| 583 | <b>def</b> zork : Value<Ref>; |
| 584 | <b>def</b> hork : Value<ModRef>; |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 585 | </pre> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 586 | </div> |
Chris Lattner | 23f54fa | 2004-02-06 06:37:00 +0000 | [diff] [blame] | 587 | |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 588 | <p>This is obviously a contrived example, but it shows how template arguments |
| 589 | can be used to decouple the interface provided to the user of the class from the |
Chris Lattner | 23f54fa | 2004-02-06 06:37:00 +0000 | [diff] [blame] | 590 | actual internal data representation expected by the class. In this case, |
| 591 | running <tt>tblgen</tt> on the example prints the following definitions:</p> |
| 592 | |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 593 | <div class="doc_code"> |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 594 | <pre> |
Chris Lattner | 23f54fa | 2004-02-06 06:37:00 +0000 | [diff] [blame] | 595 | <b>def</b> bork { <i>// Value</i> |
Chris Lattner | 84b3598 | 2006-09-01 21:44:18 +0000 | [diff] [blame] | 596 | <b>bit</b> isMod = 1; |
| 597 | <b>bit</b> isRef = 0; |
Chris Lattner | 23f54fa | 2004-02-06 06:37:00 +0000 | [diff] [blame] | 598 | } |
| 599 | <b>def</b> hork { <i>// Value</i> |
Chris Lattner | 84b3598 | 2006-09-01 21:44:18 +0000 | [diff] [blame] | 600 | <b>bit</b> isMod = 1; |
| 601 | <b>bit</b> isRef = 1; |
Chris Lattner | 23f54fa | 2004-02-06 06:37:00 +0000 | [diff] [blame] | 602 | } |
| 603 | <b>def</b> zork { <i>// Value</i> |
Chris Lattner | 84b3598 | 2006-09-01 21:44:18 +0000 | [diff] [blame] | 604 | <b>bit</b> isMod = 0; |
| 605 | <b>bit</b> isRef = 1; |
Chris Lattner | 23f54fa | 2004-02-06 06:37:00 +0000 | [diff] [blame] | 606 | } |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 607 | </pre> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 608 | </div> |
Chris Lattner | 23f54fa | 2004-02-06 06:37:00 +0000 | [diff] [blame] | 609 | |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 610 | <p> This shows that TableGen was able to dig into the argument and extract a |
| 611 | piece of information that was requested by the designer of the "Value" class. |
| 612 | For more realistic examples, please see existing users of TableGen, such as the |
| 613 | X86 backend.</p> |
Chris Lattner | 23f54fa | 2004-02-06 06:37:00 +0000 | [diff] [blame] | 614 | |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 615 | </div> |
| 616 | |
Chris Lattner | 84b3598 | 2006-09-01 21:44:18 +0000 | [diff] [blame] | 617 | <!-- --------------------------------------------------------------------------> |
| 618 | <div class="doc_subsubsection"> |
| 619 | <a name="multiclass">Multiclass definitions and instances</a> |
| 620 | </div> |
| 621 | |
| 622 | <div class="doc_text"> |
| 623 | |
| 624 | <p> |
| 625 | While classes with template arguments are a good way to factor commonality |
| 626 | between two instances of a definition, multiclasses allow a convenient notation |
| 627 | for defining multiple definitions at once (instances of implicitly constructed |
| 628 | classes). For example, consider an 3-address instruction set whose instructions |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 629 | come in two forms: "<tt>reg = reg op reg</tt>" and "<tt>reg = reg op imm</tt>" |
| 630 | (e.g. SPARC). In this case, you'd like to specify in one place that this |
| 631 | commonality exists, then in a separate place indicate what all the ops are. |
Chris Lattner | 84b3598 | 2006-09-01 21:44:18 +0000 | [diff] [blame] | 632 | </p> |
| 633 | |
| 634 | <p> |
| 635 | Here is an example TableGen fragment that shows this idea: |
| 636 | </p> |
| 637 | |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 638 | <div class="doc_code"> |
Chris Lattner | 84b3598 | 2006-09-01 21:44:18 +0000 | [diff] [blame] | 639 | <pre> |
| 640 | <b>def</b> ops; |
| 641 | <b>def</b> GPR; |
| 642 | <b>def</b> Imm; |
| 643 | <b>class</b> inst<<b>int</b> opc, <b>string</b> asmstr, <b>dag</b> operandlist>; |
| 644 | |
| 645 | <b>multiclass</b> ri_inst<<b>int</b> opc, <b>string</b> asmstr> { |
| 646 | def _rr : inst<opc, !strconcat(asmstr, " $dst, $src1, $src2"), |
| 647 | (ops GPR:$dst, GPR:$src1, GPR:$src2)>; |
| 648 | def _ri : inst<opc, !strconcat(asmstr, " $dst, $src1, $src2"), |
| 649 | (ops GPR:$dst, GPR:$src1, Imm:$src2)>; |
| 650 | } |
| 651 | |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 652 | <i>// Instantiations of the ri_inst multiclass.</i> |
Chris Lattner | 84b3598 | 2006-09-01 21:44:18 +0000 | [diff] [blame] | 653 | <b>defm</b> ADD : ri_inst<0b111, "add">; |
| 654 | <b>defm</b> SUB : ri_inst<0b101, "sub">; |
| 655 | <b>defm</b> MUL : ri_inst<0b100, "mul">; |
| 656 | ... |
| 657 | </pre> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 658 | </div> |
Chris Lattner | 84b3598 | 2006-09-01 21:44:18 +0000 | [diff] [blame] | 659 | |
Chris Lattner | e7173e1 | 2006-09-01 22:01:36 +0000 | [diff] [blame] | 660 | <p>The name of the resultant definitions has the multidef fragment names |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 661 | appended to them, so this defines <tt>ADD_rr</tt>, <tt>ADD_ri</tt>, |
David Greene | 5654613 | 2009-04-22 22:17:51 +0000 | [diff] [blame] | 662 | <tt>SUB_rr</tt>, etc. A defm may inherit from multiple multiclasses, |
| 663 | instantiating definitions from each multiclass. Using a multiclass |
| 664 | this way is exactly equivalent to instantiating the classes multiple |
| 665 | times yourself, e.g. by writing:</p> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 666 | |
| 667 | <div class="doc_code"> |
Chris Lattner | 84b3598 | 2006-09-01 21:44:18 +0000 | [diff] [blame] | 668 | <pre> |
| 669 | <b>def</b> ops; |
| 670 | <b>def</b> GPR; |
| 671 | <b>def</b> Imm; |
| 672 | <b>class</b> inst<<b>int</b> opc, <b>string</b> asmstr, <b>dag</b> operandlist>; |
| 673 | |
| 674 | <b>class</b> rrinst<<b>int</b> opc, <b>string</b> asmstr> |
| 675 | : inst<opc, !strconcat(asmstr, " $dst, $src1, $src2"), |
| 676 | (ops GPR:$dst, GPR:$src1, GPR:$src2)>; |
| 677 | |
| 678 | <b>class</b> riinst<<b>int</b> opc, <b>string</b> asmstr> |
| 679 | : inst<opc, !strconcat(asmstr, " $dst, $src1, $src2"), |
| 680 | (ops GPR:$dst, GPR:$src1, Imm:$src2)>; |
| 681 | |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 682 | <i>// Instantiations of the ri_inst multiclass.</i> |
Chris Lattner | 84b3598 | 2006-09-01 21:44:18 +0000 | [diff] [blame] | 683 | <b>def</b> ADD_rr : rrinst<0b111, "add">; |
| 684 | <b>def</b> ADD_ri : riinst<0b111, "add">; |
| 685 | <b>def</b> SUB_rr : rrinst<0b101, "sub">; |
| 686 | <b>def</b> SUB_ri : riinst<0b101, "sub">; |
| 687 | <b>def</b> MUL_rr : rrinst<0b100, "mul">; |
| 688 | <b>def</b> MUL_ri : riinst<0b100, "mul">; |
| 689 | ... |
| 690 | </pre> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 691 | </div> |
Chris Lattner | 84b3598 | 2006-09-01 21:44:18 +0000 | [diff] [blame] | 692 | |
| 693 | </div> |
| 694 | |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 695 | <!-- ======================================================================= --> |
| 696 | <div class="doc_subsection"> |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 697 | <a name="filescope">File scope entities</a> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 698 | </div> |
| 699 | |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 700 | <!-- --------------------------------------------------------------------------> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 701 | <div class="doc_subsubsection"> |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 702 | <a name="include">File inclusion</a> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 703 | </div> |
| 704 | |
| 705 | <div class="doc_text"> |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 706 | <p>TableGen supports the '<tt>include</tt>' token, which textually substitutes |
| 707 | the specified file in place of the include directive. The filename should be |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 708 | specified as a double quoted string immediately after the '<tt>include</tt>' |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 709 | keyword. Example:</p> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 710 | |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 711 | <div class="doc_code"> |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 712 | <pre> |
Chris Lattner | 23f54fa | 2004-02-06 06:37:00 +0000 | [diff] [blame] | 713 | <b>include</b> "foo.td" |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 714 | </pre> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 715 | </div> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 716 | |
| 717 | </div> |
| 718 | |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 719 | <!-- --------------------------------------------------------------------------> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 720 | <div class="doc_subsubsection"> |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 721 | <a name="globallet">'let' expressions</a> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 722 | </div> |
| 723 | |
| 724 | <div class="doc_text"> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 725 | |
| 726 | <p>"Let" expressions at file scope are similar to <a href="#recordlet">"let" |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 727 | expressions within a record</a>, except they can specify a value binding for |
| 728 | multiple records at a time, and may be useful in certain other cases. |
| 729 | File-scope let expressions are really just another way that TableGen allows the |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 730 | end-user to factor out commonality from the records.</p> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 731 | |
Jeff Cohen | 0b81cda | 2005-10-24 16:54:55 +0000 | [diff] [blame] | 732 | <p>File-scope "let" expressions take a comma-separated list of bindings to |
Matthijs Kooijman | 94199da | 2008-10-20 08:45:34 +0000 | [diff] [blame] | 733 | apply, and one or more records to bind the values in. Here are some |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 734 | examples:</p> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 735 | |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 736 | <div class="doc_code"> |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 737 | <pre> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 738 | <b>let</b> isTerminator = 1, isReturn = 1, isBarrier = 1, hasCtrlDep = 1 <b>in</b> |
| 739 | <b>def</b> RET : I<0xC3, RawFrm, (outs), (ins), "ret", [(X86retflag 0)]>; |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 740 | |
Chris Lattner | fa6f309 | 2004-02-06 06:04:25 +0000 | [diff] [blame] | 741 | <b>let</b> isCall = 1 <b>in</b> |
| 742 | <i>// All calls clobber the non-callee saved registers...</i> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 743 | <b>let</b> Defs = [EAX, ECX, EDX, FP0, FP1, FP2, FP3, FP4, FP5, FP6, ST0, |
| 744 | MM0, MM1, MM2, MM3, MM4, MM5, MM6, MM7, |
| 745 | XMM0, XMM1, XMM2, XMM3, XMM4, XMM5, XMM6, XMM7, EFLAGS] <b>in</b> { |
Dan Gohman | 364a39f | 2008-10-14 17:00:38 +0000 | [diff] [blame] | 746 | <b>def</b> CALLpcrel32 : Ii32<0xE8, RawFrm, (outs), (ins i32imm:$dst,variable_ops), |
| 747 | "call\t${dst:call}", []>; |
| 748 | <b>def</b> CALL32r : I<0xFF, MRM2r, (outs), (ins GR32:$dst, variable_ops), |
| 749 | "call\t{*}$dst", [(X86call GR32:$dst)]>; |
| 750 | <b>def</b> CALL32m : I<0xFF, MRM2m, (outs), (ins i32mem:$dst, variable_ops), |
| 751 | "call\t{*}$dst", []>; |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 752 | } |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 753 | </pre> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 754 | </div> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 755 | |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 756 | <p>File-scope "let" expressions are often useful when a couple of definitions |
| 757 | need to be added to several records, and the records do not otherwise need to be |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 758 | opened, as in the case with the <tt>CALL*</tt> instructions above.</p> |
| 759 | |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 760 | </div> |
| 761 | |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 762 | <!-- *********************************************************************** --> |
| 763 | <div class="doc_section"><a name="backends">TableGen backends</a></div> |
| 764 | <!-- *********************************************************************** --> |
| 765 | |
| 766 | <div class="doc_text"> |
Bill Wendling | 643eb5d | 2008-02-12 07:06:19 +0000 | [diff] [blame] | 767 | |
| 768 | <p>TODO: How they work, how to write one. This section should not contain |
| 769 | details about any particular backend, except maybe -print-enums as an example. |
| 770 | This should highlight the APIs in <tt>TableGen/Record.h</tt>.</p> |
| 771 | |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 772 | </div> |
| 773 | |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 774 | <!-- *********************************************************************** --> |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 775 | |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 776 | <hr> |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 777 | <address> |
| 778 | <a href="http://jigsaw.w3.org/css-validator/check/referer"><img |
Misha Brukman | 4440870 | 2008-12-11 17:34:48 +0000 | [diff] [blame] | 779 | src="http://jigsaw.w3.org/css-validator/images/vcss-blue" alt="Valid CSS"></a> |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 780 | <a href="http://validator.w3.org/check/referer"><img |
Misha Brukman | 4440870 | 2008-12-11 17:34:48 +0000 | [diff] [blame] | 781 | src="http://www.w3.org/Icons/valid-html401-blue" alt="Valid HTML 4.01"></a> |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 782 | |
| 783 | <a href="mailto:sabre@nondot.org">Chris Lattner</a><br> |
Reid Spencer | 05fe4b0 | 2006-03-14 05:39:39 +0000 | [diff] [blame] | 784 | <a href="http://llvm.org">LLVM Compiler Infrastructure</a><br> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 785 | Last modified: $Date$ |
Misha Brukman | 85234ac | 2004-05-12 18:31:21 +0000 | [diff] [blame] | 786 | </address> |
Chris Lattner | b54c99c | 2004-02-06 05:42:53 +0000 | [diff] [blame] | 787 | |
| 788 | </body> |
| 789 | </html> |