Blame - llvm/docs/TableGenFundamentals.html - toolchain/llvm-project

blob: 90836e91bda8462c73e1fd213438a42e7aaabc62 [file] [log] [blame]

Chris Lattner	149a249	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	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	12	<div class="doc_text">
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	13	<ul>
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	14	<li><a href="#introduction">Introduction</a>
Chris Lattner	149a249	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	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	19	</ol></li>
				20	<li><a href="#syntax">TableGen syntax</a>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	21	<ol>
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	22	<li><a href="#primitives">TableGen primitives</a>
Chris Lattner	149a249	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	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	27	</ol></li>
				28	<li><a href="#classesdefs">Classes and definitions</a>
Chris Lattner	149a249	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	f01a85b	2006-09-01 21:44:18 +0000	[diff] [blame]	33	<li><a href="#multiclass">Multiclass definitions and instances</a></li>
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	34	</ol></li>
				35	<li><a href="#filescope">File scope entities</a>
Chris Lattner	149a249	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	692cec0	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	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	42	<ol>
Chris Lattner	1215e32	2004-02-06 06:04:25 +0000	[diff] [blame]	43	<li><a href="#">todo</a></li>
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	44	</ol></li>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	45	</ul>
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	46	</div>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	47
Chris Lattner	020e1fc	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	149a249	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	7f50013	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	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	69
Misha Brukman	692cec0	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
				71	find an emacs "TableGen mode" and a vim language file in
				72	<tt>llvm/utils/emacs</tt> and <tt>llvm/utils/vim</tt> directory of your LLVM
				73	distribution, respectively.</p>
Chris Lattner	1215e32	2004-02-06 06:04:25 +0000	[diff] [blame]	74
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	75	</div>
				76
				77	<!-- ======================================================================= -->
Jim Laskey	ea05a06	2006-09-09 09:10:37 +0000	[diff] [blame^]	78	<div class="doc_subsection"><a name="concepts">Basic concepts</a></div>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	79
				80	<div class="doc_text">
				81
Misha Brukman	692cec0	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	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	84
Misha Brukman	692cec0	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
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	86	superclasses. The list of values is main data that TableGen builds for each
				87	record, it is this that holds the domain specific information for the
				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
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	90	taken care of and fixed by TableGen.</p>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	91
Misha Brukman	692cec0	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	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	95
Misha Brukman	692cec0	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
				98	abstractions for either the domain they are targetting (such as "Register",
				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	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	105
Chris Lattner	f01a85b	2006-09-01 21:44:18 +0000	[diff] [blame]	106	<p><b>TableGen multiclasses</b> are groups of abstract records that are
				107	instantiated all at once. Each instantiation can result in multiple TableGen
				108	definitions.</p>
				109
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	110	</div>
				111
				112	<!-- ======================================================================= -->
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	113	<div class="doc_subsection"><a name="example">An example record</a></div>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	114
				115	<div class="doc_text">
				116
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	117	<p>With no other arguments, TableGen parses the specified file and prints out
				118	all of the classes, then all of the definitions. This is a good way to see what
				119	the various definitions expand to fully. Running this on the <tt>X86.td</tt>
				120	file prints this (at the time of this writing):</p>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	121
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	122	<pre>
				123	...
Chris Lattner	1215e32	2004-02-06 06:04:25 +0000	[diff] [blame]	124	<b>def</b> ADDrr8 { <i>// Instruction X86Inst I2A8 Pattern</i>
				125	<b>string</b> Name = "add";
				126	<b>string</b> Namespace = "X86";
				127	<b>list</b><Register> Uses = [];
				128	<b>list</b><Register> Defs = [];
				129	<b>bit</b> isReturn = 0;
				130	<b>bit</b> isBranch = 0;
				131	<b>bit</b> isCall = 0;
				132	<b>bit</b> isTwoAddress = 1;
				133	<b>bit</b> isTerminator = 0;
				134	<b>dag</b> Pattern = (set R8, (plus R8, R8));
				135	<b>bits</b><8> Opcode = { 0, 0, 0, 0, 0, 0, 0, 0 };
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	136	Format Form = MRMDestReg;
Chris Lattner	1215e32	2004-02-06 06:04:25 +0000	[diff] [blame]	137	<b>bits</b><5> FormBits = { 0, 0, 0, 1, 1 };
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	138	ArgType Type = Arg8;
Chris Lattner	1215e32	2004-02-06 06:04:25 +0000	[diff] [blame]	139	<b>bits</b><3> TypeBits = { 0, 0, 1 };
				140	<b>bit</b> hasOpSizePrefix = 0;
				141	<b>bit</b> printImplicitUses = 0;
				142	<b>bits</b><4> Prefix = { 0, 0, 0, 0 };
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	143	FPFormat FPForm = ?;
Chris Lattner	1215e32	2004-02-06 06:04:25 +0000	[diff] [blame]	144	<b>bits</b><3> FPFormBits = { 0, 0, 0 };
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	145	}
				146	...
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	147	</pre>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	148
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	149	<p>This definition corresponds to an 8-bit register-register add instruction in
				150	the X86. The string after the '<tt>def</tt>' string indicates the name of the
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	151	record ("<tt>ADDrr8</tt>" in this case), and the comment at the end of the line
				152	indicates the superclasses of the definition. The body of the record contains
				153	all of the data that TableGen assembled for the record, indicating that the
				154	instruction is part of the "X86" namespace, should be printed as "<tt>add</tt>"
				155	in the assembly file, it is a two-address instruction, has a particular
				156	encoding, etc. The contents and semantics of the information in the record is
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	157	specific to the needs of the X86 backend, and is only shown as an example.</p>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	158
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	159	<p>As you can see, a lot of information is needed for every instruction
				160	supported by the code generator, and specifying it all manually would be
				161	unmaintainble, prone to bugs, and tiring to do in the first place. Because we
				162	are using TableGen, all of the information was derived from the following
				163	definition:</p>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	164
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	165	<pre>
Chris Lattner	1215e32	2004-02-06 06:04:25 +0000	[diff] [blame]	166	<b>def</b> ADDrr8 : I2A8<"add", 0x00, MRMDestReg>,
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	167	Pattern<(set R8, (plus R8, R8))>;
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	168	</pre>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	169
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	170	<p>This definition makes use of the custom I2A8 (two address instruction with
				171	8-bit operand) class, which is defined in the X86-specific TableGen file to
				172	factor out the common features that instructions of its class share. A key
				173	feature of TableGen is that it allows the end-user to define the abstractions
				174	they prefer to use when describing their information.</p>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	175
				176	</div>
				177
				178	<!-- ======================================================================= -->
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	179	<div class="doc_subsection"><a name="running">Running TableGen</a></div>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	180
				181	<div class="doc_text">
				182
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	183	<p>TableGen runs just like any other LLVM tool. The first (optional) argument
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	184	specifies the file to read. If a filename is not specified, <tt>tblgen</tt>
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	185	reads from standard input.</p>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	186
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	187	<p>To be useful, one of the <a href="#backends">TableGen backends</a> must be
				188	used. These backends are selectable on the command line (type '<tt>tblgen
				189	--help</tt>' for a list). For example, to get a list of all of the definitions
				190	that subclass a particular type (which can be useful for building up an enum
				191	list of these records), use the <tt>--print-enums</tt> option:</p>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	192
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	193	<pre>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	194	$ tblgen X86.td -print-enums -class=Register
				195	AH, AL, AX, BH, BL, BP, BX, CH, CL, CX, DH, DI, DL, DX,
				196	EAX, EBP, EBX, ECX, EDI, EDX, ESI, ESP, FP0, FP1, FP2, FP3, FP4, FP5, FP6,
				197	SI, SP, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7,
				198
				199	$ tblgen X86.td -print-enums -class=Instruction
				200	ADCrr32, ADDri16, ADDri16b, ADDri32, ADDri32b, ADDri8, ADDrr16, ADDrr32,
				201	ADDrr8, ADJCALLSTACKDOWN, ADJCALLSTACKUP, ANDri16, ANDri16b, ANDri32, ANDri32b,
				202	ANDri8, ANDrr16, ANDrr32, ANDrr8, BSWAPr32, CALLm32, CALLpcrel32, ...
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	203	</pre>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	204
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	205	<p>The default backend prints out all of the records, as described <a
				206	href="#example">above</a>.</p>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	207
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	208	<p>If you plan to use TableGen for some purpose, you will most likely have to
				209	<a href="#backends">write a backend</a> that extracts the information specific
				210	to what you need and formats it in the appropriate way.</p>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	211
				212	</div>
				213
				214
				215	<!-- *********************************************************************** -->
				216	<div class="doc_section"><a name="syntax">TableGen syntax</a></div>
				217	<!-- *********************************************************************** -->
				218
				219	<div class="doc_text">
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	220	<p>TableGen doesn't care about the meaning of data (that is up to the backend
				221	to define), but it does care about syntax, and it enforces a simple type system.
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	222	This section describes the syntax and the constructs allowed in a TableGen file.
				223	</p>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	224	</div>
				225
				226	<!-- ======================================================================= -->
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	227	<div class="doc_subsection"><a name="primitives">TableGen primitives</a></div>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	228
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	229	<!-- -------------------------------------------------------------------------->
				230	<div class="doc_subsubsection"><a name="comments">TableGen comments</a></div>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	231
				232	<div class="doc_text">
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	233	<p>TableGen supports BCPL style "<tt>//</tt>" comments, which run to the end of
				234	the line, and it also supports <b>nestable</b> "<tt>/* */</tt>" comments.</p>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	235	</div>
				236
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	237	<!-- -------------------------------------------------------------------------->
Misha Brukman	94192b6	2004-06-03 16:59:59 +0000	[diff] [blame]	238	<div class="doc_subsubsection">
				239	<a name="types">The TableGen type system</a>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	240	</div>
				241
				242	<div class="doc_text">
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	243	<p>TableGen files are strongly typed, in a simple (but complete) type-system.
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	244	These types are used to perform automatic conversions, check for errors, and to
				245	help interface designers constrain the input that they allow. Every <a
				246	href="#valuedef">value definition</a> is required to have an associated type.
				247	</p>
				248
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	249	<p>TableGen supports a mixture of very low-level types (such as <tt>bit</tt>)
				250	and very high-level types (such as <tt>dag</tt>). This flexibility is what
				251	allows it to describe a wide range of information conveniently and compactly.
				252	The TableGen types are:</p>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	253
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	254	<ul>
Chris Lattner	1215e32	2004-02-06 06:04:25 +0000	[diff] [blame]	255	<li>"<tt><b>bit</b></tt>" - A 'bit' is a boolean value that can hold either 0 or
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	256	1.</li>
				257
Chris Lattner	1215e32	2004-02-06 06:04:25 +0000	[diff] [blame]	258	<li>"<tt><b>int</b></tt>" - The 'int' type represents a simple 32-bit integer
				259	value, such as 5.</li>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	260
Chris Lattner	1215e32	2004-02-06 06:04:25 +0000	[diff] [blame]	261	<li>"<tt><b>string</b></tt>" - The 'string' type represents an ordered sequence
				262	of characters of arbitrary length.</li>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	263
John Criswell	407f6d4	2004-02-12 18:11:53 +0000	[diff] [blame]	264	<li>"<tt><b>bits</b><n></tt>" - A 'bits' type is an arbitrary, but fixed,
Chris Lattner	1215e32	2004-02-06 06:04:25 +0000	[diff] [blame]	265	size integer that is broken up into individual bits. This type is useful
				266	because it can handle some bits being defined while others are undefined.</li>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	267
Chris Lattner	1215e32	2004-02-06 06:04:25 +0000	[diff] [blame]	268	<li>"<tt><b>list</b><ty></tt>" - This type represents a list whose
				269	elements are some other type. The contained type is arbitrary: it can even be
				270	another list type.</li>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	271
				272	<li>Class type - Specifying a class name in a type context means that the
				273	defined value must be a subclass of the specified class. This is useful in
				274	conjunction with the "list" type, for example, to constrain the elements of the
Chris Lattner	1215e32	2004-02-06 06:04:25 +0000	[diff] [blame]	275	list to a common base class (e.g., a <tt><b>list</b><Register></tt> can
				276	only contain definitions derived from the "<tt>Register</tt>" class).</li>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	277
Chris Lattner	1215e32	2004-02-06 06:04:25 +0000	[diff] [blame]	278	<li>"<tt><b>code</b></tt>" - This represents a big hunk of text. NOTE: I don't
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	279	remember why this is distinct from string!</li>
				280
Chris Lattner	1215e32	2004-02-06 06:04:25 +0000	[diff] [blame]	281	<li>"<tt><b>dag</b></tt>" - This type represents a nestable directed graph of
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	282	elements.</li>
				283	</ul>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	284
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	285	<p>To date, these types have been sufficient for describing things that
				286	TableGen has been used for, but it is straight-forward to extend this list if
				287	needed.</p>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	288
				289	</div>
				290
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	291	<!-- -------------------------------------------------------------------------->
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	292	<div class="doc_subsubsection">
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	293	<a name="values">TableGen values and expressions</a>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	294	</div>
				295
Misha Brukman	94192b6	2004-06-03 16:59:59 +0000	[diff] [blame]	296	<div class="doc_text">
				297
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	298	<p>TableGen allows for a pretty reasonable number of different expression forms
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	299	when building up values. These forms allow the TableGen file to be written in a
				300	natural syntax and flavor for the application. The current expression forms
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	301	supported include:</p>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	302
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	303	<ul>
Misha Brukman	0fc57a6	2004-07-28 22:09:29 +0000	[diff] [blame]	304	<li><tt>?</tt> - uninitialized field</li>
				305	<li><tt>0b1001011</tt> - binary integer value</li>
				306	<li><tt>07654321</tt> - octal integer value (indicated by a leading 0)</li>
				307	<li><tt>7</tt> - decimal integer value</li>
				308	<li><tt>0x7F</tt> - hexadecimal integer value</li>
				309	<li><tt>"foo"</tt> - string value</li>
				310	<li><tt>[{ ... }]</tt> - code fragment</li>
				311	<li><tt>[ X, Y, Z ]</tt> - list value.</li>
				312	<li><tt>{ a, b, c }</tt> - initializer for a "bits<3>" value</li>
				313	<li><tt>value</tt> - value reference</li>
				314	<li><tt>value{17}</tt> - access to one bit of a value</li>
				315	<li><tt>value{15-17}</tt> - access to multiple bits of a value</li>
				316	<li><tt>DEF</tt> - reference to a record definition</li>
Chris Lattner	808c642	2005-09-08 18:47:21 +0000	[diff] [blame]	317	<li><tt>CLASS<val list></tt> - reference to a new anonymous definition of
				318	CLASS with the specified template arguments.</li>
Misha Brukman	0fc57a6	2004-07-28 22:09:29 +0000	[diff] [blame]	319	<li><tt>X.Y</tt> - reference to the subfield of a value</li>
Misha Brukman	9590888	2004-08-04 22:00:05 +0000	[diff] [blame]	320	<li><tt>list[4-7,17,2-3]</tt> - A slice of the 'list' list, including elements
				321	4,5,6,7,17,2, and 3 from it. Elements may be included multiple times.</li>
Misha Brukman	0fc57a6	2004-07-28 22:09:29 +0000	[diff] [blame]	322	<li><tt>(DEF a, b)</tt> - a dag value. The first element is required to be a
				323	record definition, the remaining elements in the list may be arbitrary other
				324	values, including nested `<tt>dag</tt>' values.</li>
Chris Lattner	b5b0c1a	2006-09-01 21:46:01 +0000	[diff] [blame]	325	<li><tt>!strconcat(a, b)</tt> - A string value that is the result of
				326	concatenating the 'a' and 'b' strings.</li>
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	327	</ul>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	328
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	329	<p>Note that all of the values have rules specifying how they convert to values
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	330	for different types. These rules allow you to assign a value like "7" to a
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	331	"bits<4>" value, for example.</p>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	332
				333	</div>
				334
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	335	<!-- ======================================================================= -->
Misha Brukman	94192b6	2004-06-03 16:59:59 +0000	[diff] [blame]	336	<div class="doc_subsection">
				337	<a name="classesdefs">Classes and definitions</a>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	338	</div>
				339
Misha Brukman	94192b6	2004-06-03 16:59:59 +0000	[diff] [blame]	340	<div class="doc_text">
				341
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	342	<p>As mentioned in the <a href="#concepts">intro</a>, classes and definitions
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	343	(collectively known as 'records') in TableGen are the main high-level unit of
				344	information that TableGen collects. Records are defined with a <tt>def</tt> or
				345	<tt>class</tt> keyword, the record name, and an optional list of "<a
Misha Brukman	3155159	2004-06-03 23:42:24 +0000	[diff] [blame]	346	href="#templateargs">template arguments</a>". If the record has superclasses,
Jeff Cohen	dd24d7c	2005-10-24 16:54:55 +0000	[diff] [blame]	347	they are specified as a comma separated list that starts with a colon character
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	348	(":"). If <a href="#valuedef">value definitions</a> or <a href="#recordlet">let
John Criswell	407f6d4	2004-02-12 18:11:53 +0000	[diff] [blame]	349	expressions</a> are needed for the class, they are enclosed in curly braces
				350	("{}"); otherwise, the record ends with a semicolon. Here is a simple TableGen
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	351	file:</p>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	352
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	353	<pre>
Chris Lattner	1215e32	2004-02-06 06:04:25 +0000	[diff] [blame]	354	<b>class</b> C { <b>bit</b> V = 1; }
				355	<b>def</b> X : C;
				356	<b>def</b> Y : C {
				357	<b>string</b> Greeting = "hello";
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	358	}
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	359	</pre>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	360
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	361	<p>This example defines two definitions, <tt>X</tt> and <tt>Y</tt>, both of
				362	which derive from the <tt>C</tt> class. Because of this, they both get the
				363	<tt>V</tt> bit value. The <tt>Y</tt> definition also gets the Greeting member
				364	as well.</p>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	365
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	366	<p>In general, classes are useful for collecting together the commonality
				367	between a group of records and isolating it in a single place. Also, classes
				368	permit the specification of default values for their subclasses, allowing the
				369	subclasses to override them as they wish.</p>
Chris Lattner	5592723	2004-02-06 06:37:00 +0000	[diff] [blame]	370
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	371	</div>
				372
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	373	<!---------------------------------------------------------------------------->
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	374	<div class="doc_subsubsection">
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	375	<a name="valuedef">Value definitions</a>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	376	</div>
				377
				378	<div class="doc_text">
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	379	<p>Value definitions define named entries in records. A value must be defined
John Criswell	407f6d4	2004-02-12 18:11:53 +0000	[diff] [blame]	380	before it can be referred to as the operand for another value definition or
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	381	before the value is reset with a <a href="#recordlet">let expression</a>. A
				382	value is defined by specifying a <a href="#types">TableGen type</a> and a name.
				383	If an initial value is available, it may be specified after the type with an
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	384	equal sign. Value definitions require terminating semicolons.</p>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	385	</div>
				386
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	387	<!-- -------------------------------------------------------------------------->
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	388	<div class="doc_subsubsection">
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	389	<a name="recordlet">'let' expressions</a>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	390	</div>
				391
				392	<div class="doc_text">
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	393	<p>A record-level let expression is used to change the value of a value
				394	definition in a record. This is primarily useful when a superclass defines a
				395	value that a derived class or definition wants to override. Let expressions
				396	consist of the '<tt>let</tt>' keyword followed by a value name, an equal sign
				397	("="), and a new value. For example, a new class could be added to the example
				398	above, redefining the <tt>V</tt> field for all of its subclasses:</p>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	399
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	400	<pre>
Chris Lattner	1215e32	2004-02-06 06:04:25 +0000	[diff] [blame]	401	<b>class</b> D : C { let V = 0; }
				402	<b>def</b> Z : D;
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	403	</pre>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	404
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	405	<p>In this case, the <tt>Z</tt> definition will have a zero value for its "V"
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	406	value, despite the fact that it derives (indirectly) from the <tt>C</tt> class,
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	407	because the <tt>D</tt> class overrode its value.</p>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	408
				409	</div>
				410
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	411	<!-- -------------------------------------------------------------------------->
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	412	<div class="doc_subsubsection">
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	413	<a name="templateargs">Class template arguments</a>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	414	</div>
				415
				416	<div class="doc_text">
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	417	<p>TableGen permits the definition of parameterized classes as well as normal
Chris Lattner	5592723	2004-02-06 06:37:00 +0000	[diff] [blame]	418	concrete classes. Parameterized TableGen classes specify a list of variable
				419	bindings (which may optionally have defaults) that are bound when used. Here is
				420	a simple example:</p>
				421
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	422	<pre>
Chris Lattner	5592723	2004-02-06 06:37:00 +0000	[diff] [blame]	423	<b>class</b> FPFormat<<b>bits</b><3> val> {
				424	<b>bits</b><3> Value = val;
				425	}
				426	<b>def</b> NotFP : FPFormat<0>;
				427	<b>def</b> ZeroArgFP : FPFormat<1>;
				428	<b>def</b> OneArgFP : FPFormat<2>;
				429	<b>def</b> OneArgFPRW : FPFormat<3>;
				430	<b>def</b> TwoArgFP : FPFormat<4>;
				431	<b>def</b> SpecialFP : FPFormat<5>;
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	432	</pre>
Chris Lattner	5592723	2004-02-06 06:37:00 +0000	[diff] [blame]	433
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	434	<p>In this case, template arguments are used as a space efficient way to specify
				435	a list of "enumeration values", each with a "Value" field set to the specified
Chris Lattner	5592723	2004-02-06 06:37:00 +0000	[diff] [blame]	436	integer.</p>
				437
				438	<p>The more esoteric forms of <a href="#values">TableGen expressions</a> are
				439	useful in conjunction with template arguments. As an example:</p>
				440
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	441	<pre>
Chris Lattner	5592723	2004-02-06 06:37:00 +0000	[diff] [blame]	442	<b>class</b> ModRefVal<<b>bits</b><2> val> {
				443	<b>bits</b><2> Value = val;
				444	}
				445
				446	<b>def</b> None : ModRefVal<0>;
				447	<b>def</b> Mod : ModRefVal<1>;
				448	<b>def</b> Ref : ModRefVal<2>;
				449	<b>def</b> ModRef : ModRefVal<3>;
				450
				451	<b>class</b> Value<ModRefVal MR> {
				452	<i>// decode some information into a more convenient format, while providing
				453	// a nice interface to the user of the "Value" class.</i>
				454	<b>bit</b> isMod = MR.Value{0};
				455	<b>bit</b> isRef = MR.Value{1};
				456
				457	<i>// other stuff...</i>
				458	}
				459
				460	<i>// Example uses</i>
				461	<b>def</b> bork : Value<Mod>;
				462	<b>def</b> zork : Value<Ref>;
				463	<b>def</b> hork : Value<ModRef>;
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	464	</pre>
Chris Lattner	5592723	2004-02-06 06:37:00 +0000	[diff] [blame]	465
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	466	<p>This is obviously a contrived example, but it shows how template arguments
				467	can be used to decouple the interface provided to the user of the class from the
Chris Lattner	5592723	2004-02-06 06:37:00 +0000	[diff] [blame]	468	actual internal data representation expected by the class. In this case,
				469	running <tt>tblgen</tt> on the example prints the following definitions:</p>
				470
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	471	<pre>
Chris Lattner	5592723	2004-02-06 06:37:00 +0000	[diff] [blame]	472	<b>def</b> bork { <i>// Value</i>
Chris Lattner	f01a85b	2006-09-01 21:44:18 +0000	[diff] [blame]	473	<b>bit</b> isMod = 1;
				474	<b>bit</b> isRef = 0;
Chris Lattner	5592723	2004-02-06 06:37:00 +0000	[diff] [blame]	475	}
				476	<b>def</b> hork { <i>// Value</i>
Chris Lattner	f01a85b	2006-09-01 21:44:18 +0000	[diff] [blame]	477	<b>bit</b> isMod = 1;
				478	<b>bit</b> isRef = 1;
Chris Lattner	5592723	2004-02-06 06:37:00 +0000	[diff] [blame]	479	}
				480	<b>def</b> zork { <i>// Value</i>
Chris Lattner	f01a85b	2006-09-01 21:44:18 +0000	[diff] [blame]	481	<b>bit</b> isMod = 0;
				482	<b>bit</b> isRef = 1;
Chris Lattner	5592723	2004-02-06 06:37:00 +0000	[diff] [blame]	483	}
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	484	</pre>
Chris Lattner	5592723	2004-02-06 06:37:00 +0000	[diff] [blame]	485
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	486	<p> This shows that TableGen was able to dig into the argument and extract a
				487	piece of information that was requested by the designer of the "Value" class.
				488	For more realistic examples, please see existing users of TableGen, such as the
				489	X86 backend.</p>
Chris Lattner	5592723	2004-02-06 06:37:00 +0000	[diff] [blame]	490
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	491	</div>
				492
Chris Lattner	f01a85b	2006-09-01 21:44:18 +0000	[diff] [blame]	493	<!-- -------------------------------------------------------------------------->
				494	<div class="doc_subsubsection">
				495	<a name="multiclass">Multiclass definitions and instances</a>
				496	</div>
				497
				498	<div class="doc_text">
				499
				500	<p>
				501	While classes with template arguments are a good way to factor commonality
				502	between two instances of a definition, multiclasses allow a convenient notation
				503	for defining multiple definitions at once (instances of implicitly constructed
				504	classes). For example, consider an 3-address instruction set whose instructions
				505	come in two forms: "reg = reg op reg" and "reg = reg op imm" (e.g. SPARC). In
				506	this case, you'd like to specify in one place that this commonality exists, then
				507	in a separate place indicate what all the ops are.
				508	</p>
				509
				510	<p>
				511	Here is an example TableGen fragment that shows this idea:
				512	</p>
				513
				514	<pre>
				515	<b>def</b> ops;
				516	<b>def</b> GPR;
				517	<b>def</b> Imm;
				518	<b>class</b> inst<<b>int</b> opc, <b>string</b> asmstr, <b>dag</b> operandlist>;
				519
				520	<b>multiclass</b> ri_inst<<b>int</b> opc, <b>string</b> asmstr> {
				521	def _rr : inst<opc, !strconcat(asmstr, " $dst, $src1, $src2"),
				522	(ops GPR:$dst, GPR:$src1, GPR:$src2)>;
				523	def _ri : inst<opc, !strconcat(asmstr, " $dst, $src1, $src2"),
				524	(ops GPR:$dst, GPR:$src1, Imm:$src2)>;
				525	}
				526
				527	// Instantiations of the ri_inst multiclass.
				528	<b>defm</b> ADD : ri_inst<0b111, "add">;
				529	<b>defm</b> SUB : ri_inst<0b101, "sub">;
				530	<b>defm</b> MUL : ri_inst<0b100, "mul">;
				531	...
				532	</pre>
				533
Chris Lattner	2836812	2006-09-01 22:01:36 +0000	[diff] [blame]	534	<p>The name of the resultant definitions has the multidef fragment names
Chris Lattner	f01a85b	2006-09-01 21:44:18 +0000	[diff] [blame]	535	appended to them, so this defines ADD_rr, ADD_ri, SUB_rr, etc. Using a
				536	multiclass this way is exactly equivalent to instantiating the
				537	classes multiple times yourself, e.g. by writing:</p>
				538
				539	<pre>
				540	<b>def</b> ops;
				541	<b>def</b> GPR;
				542	<b>def</b> Imm;
				543	<b>class</b> inst<<b>int</b> opc, <b>string</b> asmstr, <b>dag</b> operandlist>;
				544
				545	<b>class</b> rrinst<<b>int</b> opc, <b>string</b> asmstr>
				546	: inst<opc, !strconcat(asmstr, " $dst, $src1, $src2"),
				547	(ops GPR:$dst, GPR:$src1, GPR:$src2)>;
				548
				549	<b>class</b> riinst<<b>int</b> opc, <b>string</b> asmstr>
				550	: inst<opc, !strconcat(asmstr, " $dst, $src1, $src2"),
				551	(ops GPR:$dst, GPR:$src1, Imm:$src2)>;
				552
				553	// Instantiations of the ri_inst multiclass.
				554	<b>def</b> ADD_rr : rrinst<0b111, "add">;
				555	<b>def</b> ADD_ri : riinst<0b111, "add">;
				556	<b>def</b> SUB_rr : rrinst<0b101, "sub">;
				557	<b>def</b> SUB_ri : riinst<0b101, "sub">;
				558	<b>def</b> MUL_rr : rrinst<0b100, "mul">;
				559	<b>def</b> MUL_ri : riinst<0b100, "mul">;
				560	...
				561	</pre>
				562
				563	</div>
				564
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	565	<!-- ======================================================================= -->
				566	<div class="doc_subsection">
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	567	<a name="filescope">File scope entities</a>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	568	</div>
				569
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	570	<!-- -------------------------------------------------------------------------->
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	571	<div class="doc_subsubsection">
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	572	<a name="include">File inclusion</a>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	573	</div>
				574
				575	<div class="doc_text">
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	576	<p>TableGen supports the '<tt>include</tt>' token, which textually substitutes
				577	the specified file in place of the include directive. The filename should be
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	578	specified as a double quoted string immediately after the '<tt>include</tt>'
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	579	keyword. Example:</p>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	580
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	581	<pre>
Chris Lattner	5592723	2004-02-06 06:37:00 +0000	[diff] [blame]	582	<b>include</b> "foo.td"
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	583	</pre>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	584
				585	</div>
				586
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	587	<!-- -------------------------------------------------------------------------->
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	588	<div class="doc_subsubsection">
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	589	<a name="globallet">'let' expressions</a>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	590	</div>
				591
				592	<div class="doc_text">
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	593	<p> "let" expressions at file scope are similar to <a href="#recordlet">"let"
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	594	expressions within a record</a>, except they can specify a value binding for
				595	multiple records at a time, and may be useful in certain other cases.
				596	File-scope let expressions are really just another way that TableGen allows the
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	597	end-user to factor out commonality from the records.</p>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	598
Jeff Cohen	dd24d7c	2005-10-24 16:54:55 +0000	[diff] [blame]	599	<p>File-scope "let" expressions take a comma-separated list of bindings to
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	600	apply, and one of more records to bind the values in. Here are some
				601	examples:</p>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	602
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	603	<pre>
Chris Lattner	1215e32	2004-02-06 06:04:25 +0000	[diff] [blame]	604	<b>let</b> isTerminator = 1, isReturn = 1 <b>in</b>
				605	<b>def</b> RET : X86Inst<"ret", 0xC3, RawFrm, NoArg>;
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	606
Chris Lattner	1215e32	2004-02-06 06:04:25 +0000	[diff] [blame]	607	<b>let</b> isCall = 1 <b>in</b>
				608	<i>// All calls clobber the non-callee saved registers...</i>
				609	<b>let</b> Defs = [EAX, ECX, EDX, FP0, FP1, FP2, FP3, FP4, FP5, FP6] in {
				610	<b>def</b> CALLpcrel32 : X86Inst<"call", 0xE8, RawFrm, NoArg>;
				611	<b>def</b> CALLr32 : X86Inst<"call", 0xFF, MRMS2r, Arg32>;
				612	<b>def</b> CALLm32 : X86Inst<"call", 0xFF, MRMS2m, Arg32>;
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	613	}
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	614	</pre>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	615
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	616	<p>File-scope "let" expressions are often useful when a couple of definitions
				617	need to be added to several records, and the records do not otherwise need to be
				618	opened, as in the case with the CALL* instructions above.</p>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	619	</div>
				620
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	621	<!-- *********************************************************************** -->
				622	<div class="doc_section"><a name="backends">TableGen backends</a></div>
				623	<!-- *********************************************************************** -->
				624
				625	<div class="doc_text">
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	626	<p>How they work, how to write one. This section should not contain details
				627	about any particular backend, except maybe -print-enums as an example. This
				628	should highlight the APIs in <tt>TableGen/Record.h</tt>.</p>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	629	</div>
				630
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	631	<!-- *********************************************************************** -->
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	632
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	633	<hr>
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	634	<address>
				635	<a href="http://jigsaw.w3.org/css-validator/check/referer"><img
				636	src="http://jigsaw.w3.org/css-validator/images/vcss" alt="Valid CSS!"></a>
				637	<a href="http://validator.w3.org/check/referer"><img
				638	src="http://www.w3.org/Icons/valid-html401" alt="Valid HTML 4.01!" /></a>
				639
				640	<a href="mailto:sabre@nondot.org">Chris Lattner</a><br>
Reid Spencer	ca05854	2006-03-14 05:39:39 +0000	[diff] [blame]	641	<a href="http://llvm.org">LLVM Compiler Infrastructure</a><br>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	642	Last modified: $Date$
Misha Brukman	692cec0	2004-05-12 18:31:21 +0000	[diff] [blame]	643	</address>
Chris Lattner	149a249	2004-02-06 05:42:53 +0000	[diff] [blame]	644
				645	</body>
				646	</html>