Blame - docs/ExtendingLLVM.html - fp2-dev/platform/external/llvm

blob: baad89a6ae260b750a4f78b82a61025b67d19417 [file] [log] [blame]

Misha Brukman	a3ce429	2004-04-06 03:53:49 +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>Extending LLVM: Adding instructions, intrinsics, types, etc.</title>
				6	<link rel="stylesheet" href="llvm.css" type="text/css">
				7	</head>
				8
				9	<body>
				10
				11	<div class="doc_title">
				12	Extending LLVM: Adding instructions, intrinsics, types, etc.
				13	</div>
				14
				15	<ol>
				16	<li><a href="#introduction">Introduction and Warning</a></li>
Misha Brukman	a3ce429	2004-04-06 03:53:49 +0000	[diff] [blame]	17	<li><a href="#intrinsic">Adding a new intrinsic function</a></li>
Chris Lattner	3636540	2004-04-09 19:24:20 +0000	[diff] [blame]	18	<li><a href="#instruction">Adding a new instruction</a></li>
Nate Begeman	099d76c	2006-01-16 07:54:23 +0000	[diff] [blame]	19	<li><a href="#sdnode">Adding a new SelectionDAG node</a></li>
Misha Brukman	a3ce429	2004-04-06 03:53:49 +0000	[diff] [blame]	20	<li><a href="#type">Adding a new type</a>
				21	<ol>
				22	<li><a href="#fund_type">Adding a new fundamental type</a></li>
				23	<li><a href="#derived_type">Adding a new derived type</a></li>
				24	</ol></li>
				25	</ol>
				26
Chris Lattner	7911ce2	2004-05-23 21:07:27 +0000	[diff] [blame]	27	<div class="doc_author">
Chris Lattner	5eb9f0d	2005-05-11 03:53:53 +0000	[diff] [blame]	28	<p>Written by <a href="http://misha.brukman.net">Misha Brukman</a>,
Chris Lattner	b5f6e25	2006-01-16 16:31:40 +0000	[diff] [blame]	29	Brad Jones, Nate Begeman,
				30	and <a href="http://nondot.org/sabre">Chris Lattner</a></p>
Misha Brukman	a3ce429	2004-04-06 03:53:49 +0000	[diff] [blame]	31	</div>
				32
				33	<!-- *********************************************************************** -->
				34	<div class="doc_section">
				35	<a name="introduction">Introduction and Warning</a>
				36	</div>
				37	<!-- *********************************************************************** -->
				38
				39	<div class="doc_text">
				40
				41	<p>During the course of using LLVM, you may wish to customize it for your
				42	research project or for experimentation. At this point, you may realize that
				43	you need to add something to LLVM, whether it be a new fundamental type, a new
				44	intrinsic function, or a whole new instruction.</p>
				45
				46	<p>When you come to this realization, stop and think. Do you really need to
				47	extend LLVM? Is it a new fundamental capability that LLVM does not support at
				48	its current incarnation or can it be synthesized from already pre-existing LLVM
				49	elements? If you are not sure, ask on the <a
				50	href="http://mail.cs.uiuc.edu/mailman/listinfo/llvmdev">LLVM-dev</a> list. The
				51	reason is that extending LLVM will get involved as you need to update all the
				52	different passes that you intend to use with your extension, and there are
				53	<em>many</em> LLVM analyses and transformations, so it may be quite a bit of
				54	work.</p>
				55
Chris Lattner	35dd5b0	2006-04-12 17:42:39 +0000	[diff] [blame]	56	<p>Adding an <a href="#intrinsic">intrinsic function</a> is far easier than
				57	adding an instruction, and is transparent to optimization passes. If your added
				58	functionality can be expressed as a
Misha Brukman	b3b2827	2004-04-06 04:17:51 +0000	[diff] [blame]	59	function call, an intrinsic function is the method of choice for LLVM
				60	extension.</p>
				61
Misha Brukman	a3ce429	2004-04-06 03:53:49 +0000	[diff] [blame]	62	<p>Before you invest a significant amount of effort into a non-trivial
				63	extension, <span class="doc_warning">ask on the list</span> if what you are
				64	looking to do can be done with already-existing infrastructure, or if maybe
				65	someone else is already working on it. You will save yourself a lot of time and
				66	effort by doing so.</p>
				67
Misha Brukman	a3ce429	2004-04-06 03:53:49 +0000	[diff] [blame]	68	</div>
				69
				70	<!-- *********************************************************************** -->
				71	<div class="doc_section">
Chris Lattner	3636540	2004-04-09 19:24:20 +0000	[diff] [blame]	72	<a name="intrinsic">Adding a new intrinsic function</a>
				73	</div>
				74	<!-- *********************************************************************** -->
				75
				76	<div class="doc_text">
				77
				78	<p>Adding a new intrinsic function to LLVM is much easier than adding a new
				79	instruction. Almost all extensions to LLVM should start as an intrinsic
				80	function and then be turned into an instruction if warranted.</p>
				81
				82	<ol>
				83	<li><tt>llvm/docs/LangRef.html</tt>:
				84	Document the intrinsic. Decide whether it is code generator specific and
				85	what the restrictions are. Talk to other people about it so that you are
				86	sure it's a good idea.</li>
				87
Chris Lattner	35dd5b0	2006-04-12 17:42:39 +0000	[diff] [blame]	88	<li><tt>llvm/include/llvm/Intrinsics*.td</tt>:
				89	Add an entry for your intrinsic. Describe its memory access characteristics
Reid Spencer	c8d0636	2007-04-01 07:44:52 +0000	[diff] [blame]	90	for optimization (this controls whether it will be DCE'd, CSE'd, etc). Note
				91	that any intrinsic using the <tt>llvm_int_ty</tt> type for an argument will
				92	be deemed by <tt>tblgen</tt> as overloaded and the corresponding suffix
				93	will be required on the intrinsic's name.</li>
Chris Lattner	0190fdb	2004-04-10 06:56:53 +0000	[diff] [blame]	94
Nate Begeman	2f86c22	2006-01-14 01:27:10 +0000	[diff] [blame]	95	<li><tt>llvm/lib/Analysis/ConstantFolding.cpp</tt>: If it is possible to
				96	constant fold your intrinsic, add support to it in the
				97	<tt>canConstantFoldCallTo</tt> and <tt>ConstantFoldCall</tt> functions.</li>
				98
Nate Begeman	099d76c	2006-01-16 07:54:23 +0000	[diff] [blame]	99	<li><tt>llvm/test/Regression/*</tt>: Add test cases for your test cases to the
				100	test suite</li>
Chris Lattner	3636540	2004-04-09 19:24:20 +0000	[diff] [blame]	101	</ol>
				102
Chris Lattner	5eb9f0d	2005-05-11 03:53:53 +0000	[diff] [blame]	103	<p>Once the intrinsic has been added to the system, you must add code generator
				104	support for it. Generally you must do the following steps:</p>
				105
				106	<dl>
				107	<dt>Add support to the C backend in <tt>lib/Target/CBackend/</tt></dt>
				108
Nate Begeman	099d76c	2006-01-16 07:54:23 +0000	[diff] [blame]	109	<dd>Depending on the intrinsic, there are a few ways to implement this. For
				110	most intrinsics, it makes sense to add code to lower your intrinsic in
				111	<tt>LowerIntrinsicCall</tt> in <tt>lib/CodeGen/IntrinsicLowering.cpp</tt>.
				112	Second, if it makes sense to lower the intrinsic to an expanded sequence of C
				113	code in all cases, just emit the expansion in <tt>visitCallInst</tt> in
				114	<tt>Writer.cpp</tt>. If the intrinsic has some way to express it with GCC
				115	(or any other compiler) extensions, it can be conditionally supported based on
Chris Lattner	b5f6e25	2006-01-16 16:31:40 +0000	[diff] [blame]	116	the compiler compiling the CBE output (see <tt>llvm.prefetch</tt> for an
				117	example).
Nate Begeman	099d76c	2006-01-16 07:54:23 +0000	[diff] [blame]	118	Third, if the intrinsic really has no way to be lowered, just have the code
				119	generator emit code that prints an error message and calls abort if executed.
Chris Lattner	5eb9f0d	2005-05-11 03:53:53 +0000	[diff] [blame]	120	</dd>
				121
Nate Begeman	099d76c	2006-01-16 07:54:23 +0000	[diff] [blame]	122	<dl>
Chris Lattner	35dd5b0	2006-04-12 17:42:39 +0000	[diff] [blame]	123	<dt>Add support to the .td file for the target(s) of your choice in
				124	<tt>lib/Target//.td</tt>.</dt>
Chris Lattner	5eb9f0d	2005-05-11 03:53:53 +0000	[diff] [blame]	125
Chris Lattner	35dd5b0	2006-04-12 17:42:39 +0000	[diff] [blame]	126	<dd>This is usually a matter of adding a pattern to the .td file that matches
				127	the intrinsic, though it may obviously require adding the instructions you
				128	want to generate as well. There are lots of examples in the PowerPC and X86
				129	backend to follow.</dd>
Chris Lattner	5eb9f0d	2005-05-11 03:53:53 +0000	[diff] [blame]	130
Nate Begeman	099d76c	2006-01-16 07:54:23 +0000	[diff] [blame]	131	</div>
Chris Lattner	5eb9f0d	2005-05-11 03:53:53 +0000	[diff] [blame]	132
Nate Begeman	099d76c	2006-01-16 07:54:23 +0000	[diff] [blame]	133	<!-- *********************************************************************** -->
				134	<div class="doc_section">
				135	<a name="sdnode">Adding a new SelectionDAG node</a>
				136	</div>
				137	<!-- *********************************************************************** -->
Chris Lattner	5eb9f0d	2005-05-11 03:53:53 +0000	[diff] [blame]	138
Nate Begeman	099d76c	2006-01-16 07:54:23 +0000	[diff] [blame]	139	<div class="doc_text">
Chris Lattner	5eb9f0d	2005-05-11 03:53:53 +0000	[diff] [blame]	140
Nate Begeman	099d76c	2006-01-16 07:54:23 +0000	[diff] [blame]	141	<p>As with intrinsics, adding a new SelectionDAG node to LLVM is much easier
				142	than adding a new instruction. New nodes are often added to help represent
				143	instructions common to many targets. These nodes often map to an LLVM
				144	instruction (add, sub) or intrinsic (byteswap, population count). In other
				145	cases, new nodes have been added to allow many targets to perform a common task
				146	(converting between floating point and integer representation) or capture more
				147	complicated behavior in a single node (rotate).</p>
Chris Lattner	5eb9f0d	2005-05-11 03:53:53 +0000	[diff] [blame]	148
Nate Begeman	099d76c	2006-01-16 07:54:23 +0000	[diff] [blame]	149	<ol>
				150	<li><tt>include/llvm/CodeGen/SelectionDAGNodes.h</tt>:
				151	Add an enum value for the new SelectionDAG node.</li>
				152	<li><tt>lib/CodeGen/SelectionDAG/SelectionDAG.cpp</tt>:
				153	Add code to print the node to <tt>getOperationName</tt>. If your new node
				154	can be evaluated at compile time when given constant arguments (such as an
				155	add of a constant with another constant), find the <tt>getNode</tt> method
				156	that takes the appropriate number of arguments, and add a case for your node
				157	to the switch statement that performs constant folding for nodes that take
				158	the same number of arguments as your new node.</li>
				159	<li><tt>lib/CodeGen/SelectionDAG/LegalizeDAG.cpp</tt>:
				160	Add code to <a href="CodeGenerator.html#selectiondag_legalize">legalize,
				161	promote, and expand</a> the node as necessary. At a minimum, you will need
				162	to add a case statement for your node in <tt>LegalizeOp</tt> which calls
				163	LegalizeOp on the node's operands, and returns a new node if any of the
				164	operands changed as a result of being legalized. It is likely that not all
				165	targets supported by the SelectionDAG framework will natively support the
				166	new node. In this case, you must also add code in your node's case
				167	statement in <tt>LegalizeOp</tt> to Expand your node into simpler, legal
Chris Lattner	b5f6e25	2006-01-16 16:31:40 +0000	[diff] [blame]	168	operations. The case for <tt>ISD::UREM</tt> for expanding a remainder into
				169	a divide, multiply, and a subtract is a good example.</li>
Nate Begeman	099d76c	2006-01-16 07:54:23 +0000	[diff] [blame]	170	<li><tt>lib/CodeGen/SelectionDAG/LegalizeDAG.cpp</tt>:
				171	If targets may support the new node being added only at certain sizes, you
				172	will also need to add code to your node's case statement in
				173	<tt>LegalizeOp</tt> to Promote your node's operands to a larger size, and
				174	perform the correct operation. You will also need to add code to
Chris Lattner	b5f6e25	2006-01-16 16:31:40 +0000	[diff] [blame]	175	<tt>PromoteOp</tt> to do this as well. For a good example, see
				176	<tt>ISD::BSWAP</tt>,
Nate Begeman	099d76c	2006-01-16 07:54:23 +0000	[diff] [blame]	177	which promotes its operand to a wider size, performs the byteswap, and then
				178	shifts the correct bytes right to emulate the narrower byteswap in the
				179	wider type.</li>
				180	<li><tt>lib/CodeGen/SelectionDAG/LegalizeDAG.cpp</tt>:
				181	Add a case for your node in <tt>ExpandOp</tt> to teach the legalizer how to
				182	perform the action represented by the new node on a value that has been
				183	split into high and low halves. This case will be used to support your
				184	node with a 64 bit operand on a 32 bit target.</li>
				185	<li><tt>lib/CodeGen/SelectionDAG/DAGCombiner.cpp</tt>:
				186	If your node can be combined with itself, or other existing nodes in a
				187	peephole-like fashion, add a visit function for it, and call that function
				188	from <tt></tt>. There are several good examples for simple combines you
				189	can do; <tt>visitFABS</tt> and <tt>visitSRL</tt> are good starting places.
				190	</li>
				191	<li><tt>lib/Target/PowerPC/PPCISelLowering.cpp</tt>:
				192	Each target has an implementation of the <tt>TargetLowering</tt> class,
				193	usually in its own file (although some targets include it in the same
				194	file as the DAGToDAGISel). The default behavior for a target is to
				195	assume that your new node is legal for all types that are legal for
				196	that target. If this target does not natively support your node, then
				197	tell the target to either Promote it (if it is supported at a larger
				198	type) or Expand it. This will cause the code you wrote in
				199	<tt>LegalizeOp</tt> above to decompose your new node into other legal
				200	nodes for this target.</li>
				201	<li><tt>lib/Target/TargetSelectionDAG.td</tt>:
				202	Most current targets supported by LLVM generate code using the DAGToDAG
				203	method, where SelectionDAG nodes are pattern matched to target-specific
				204	nodes, which represent individual instructions. In order for the targets
				205	to match an instruction to your new node, you must add a def for that node
				206	to the list in this file, with the appropriate type constraints. Look at
				207	<tt>add</tt>, <tt>bswap</tt>, and <tt>fadd</tt> for examples.</li>
				208	<li><tt>lib/Target/PowerPC/PPCInstrInfo.td</tt>:
				209	Each target has a tablegen file that describes the target's instruction
				210	set. For targets that use the DAGToDAG instruction selection framework,
				211	add a pattern for your new node that uses one or more target nodes.
				212	Documentation for this is a bit sparse right now, but there are several
				213	decent examples. See the patterns for <tt>rotl</tt> in
				214	<tt>PPCInstrInfo.td</tt>.</li>
				215	<li>TODO: document complex patterns.</li>
				216	<li><tt>llvm/test/Regression/CodeGen/*</tt>: Add test cases for your new node
				217	to the test suite. <tt>llvm/test/Regression/CodeGen/X86/bswap.ll</tt> is
				218	a good example.</li>
				219	</ol>
Chris Lattner	3636540	2004-04-09 19:24:20 +0000	[diff] [blame]	220
				221	</div>
				222
				223	<!-- *********************************************************************** -->
				224	<div class="doc_section">
Misha Brukman	a3ce429	2004-04-06 03:53:49 +0000	[diff] [blame]	225	<a name="instruction">Adding a new instruction</a>
				226	</div>
				227	<!-- *********************************************************************** -->
				228
				229	<div class="doc_text">
				230
				231	<p><span class="doc_warning">WARNING: adding instructions changes the bytecode
Misha Brukman	b3b2827	2004-04-06 04:17:51 +0000	[diff] [blame]	232	format, and it will take some effort to maintain compatibility with
				233	the previous version.</span> Only add an instruction if it is absolutely
Misha Brukman	a3ce429	2004-04-06 03:53:49 +0000	[diff] [blame]	234	necessary.</p>
				235
				236	<ol>
Misha Brukman	b3b2827	2004-04-06 04:17:51 +0000	[diff] [blame]	237
Misha Brukman	a3ce429	2004-04-06 03:53:49 +0000	[diff] [blame]	238	<li><tt>llvm/include/llvm/Instruction.def</tt>:
				239	add a number for your instruction and an enum name</li>
				240
Misha Brukman	47b14a4	2004-07-29 17:30:56 +0000	[diff] [blame]	241	<li><tt>llvm/include/llvm/Instructions.h</tt>:
Misha Brukman	a3ce429	2004-04-06 03:53:49 +0000	[diff] [blame]	242	add a definition for the class that will represent your instruction</li>
				243
				244	<li><tt>llvm/include/llvm/Support/InstVisitor.h</tt>:
				245	add a prototype for a visitor to your new instruction type</li>
				246
				247	<li><tt>llvm/lib/AsmParser/Lexer.l</tt>:
				248	add a new token to parse your instruction from assembly text file</li>
				249
				250	<li><tt>llvm/lib/AsmParser/llvmAsmParser.y</tt>:
				251	add the grammar on how your instruction can be read and what it will
				252	construct as a result</li>
				253
Misha Brukman	e39cd63	2004-09-28 16:58:12 +0000	[diff] [blame]	254	<li><tt>llvm/lib/Bytecode/Reader/Reader.cpp</tt>:
Misha Brukman	a3ce429	2004-04-06 03:53:49 +0000	[diff] [blame]	255	add a case for your instruction and how it will be parsed from bytecode</li>
				256
				257	<li><tt>llvm/lib/VMCore/Instruction.cpp</tt>:
				258	add a case for how your instruction will be printed out to assembly</li>
				259
Chris Lattner	8f36321	2004-07-29 17:31:57 +0000	[diff] [blame]	260	<li><tt>llvm/lib/VMCore/Instructions.cpp</tt>:
Misha Brukman	e39cd63	2004-09-28 16:58:12 +0000	[diff] [blame]	261	implement the class you defined in
				262	<tt>llvm/include/llvm/Instructions.h</tt></li>
Misha Brukman	a3ce429	2004-04-06 03:53:49 +0000	[diff] [blame]	263
Misha Brukman	a424228	2004-12-01 20:58:54 +0000	[diff] [blame]	264	<li>Test your instruction</li>
				265
				266	<li><tt>llvm/lib/Target/*</tt>:
				267	Add support for your instruction to code generators, or add a lowering
				268	pass.</li>
				269
				270	<li><tt>llvm/test/Regression/*</tt>: add your test cases to the test suite.</li>
				271
Misha Brukman	a3ce429	2004-04-06 03:53:49 +0000	[diff] [blame]	272	</ol>
				273
				274	<p>Also, you need to implement (or modify) any analyses or passes that you want
				275	to understand this new instruction.</p>
				276
				277	</div>
				278
Misha Brukman	a3ce429	2004-04-06 03:53:49 +0000	[diff] [blame]	279
				280	<!-- *********************************************************************** -->
				281	<div class="doc_section">
				282	<a name="type">Adding a new type</a>
				283	</div>
				284	<!-- *********************************************************************** -->
				285
				286	<div class="doc_text">
				287
				288	<p><span class="doc_warning">WARNING: adding new types changes the bytecode
				289	format, and will break compatibility with currently-existing LLVM
				290	installations.</span> Only add new types if it is absolutely necessary.</p>
				291
				292	</div>
				293
				294	<!-- ======================================================================= -->
				295	<div class="doc_subsection">
				296	<a name="fund_type">Adding a fundamental type</a>
				297	</div>
				298
				299	<div class="doc_text">
				300
				301	<ol>
				302
Misha Brukman	a3ce429	2004-04-06 03:53:49 +0000	[diff] [blame]	303	<li><tt>llvm/include/llvm/Type.h</tt>:
Chris Lattner	55f9501	2005-04-23 21:59:11 +0000	[diff] [blame]	304	add enum for the new type; add static <tt>Type*</tt> for this type</li>
Misha Brukman	a3ce429	2004-04-06 03:53:49 +0000	[diff] [blame]	305
				306	<li><tt>llvm/lib/VMCore/Type.cpp</tt>:
				307	add mapping from <tt>TypeID</tt> => <tt>Type*</tt>;
				308	initialize the static <tt>Type*</tt></li>
				309
				310	<li><tt>llvm/lib/AsmReader/Lexer.l</tt>:
				311	add ability to parse in the type from text assembly</li>
				312
				313	<li><tt>llvm/lib/AsmReader/llvmAsmParser.y</tt>:
				314	add a token for that type</li>
				315
				316	</ol>
				317
				318	</div>
				319
				320	<!-- ======================================================================= -->
				321	<div class="doc_subsection">
				322	<a name="derived_type">Adding a derived type</a>
				323	</div>
				324
				325	<div class="doc_text">
				326
Chris Lattner	8dad40c	2004-08-12 19:06:24 +0000	[diff] [blame]	327	<ol>
Chris Lattner	8dad40c	2004-08-12 19:06:24 +0000	[diff] [blame]	328	<li><tt>llvm/include/llvm/Type.h</tt>:
Chris Lattner	55f9501	2005-04-23 21:59:11 +0000	[diff] [blame]	329	add enum for the new type; add a forward declaration of the type
Misha Brukman	7cc8a89	2004-08-12 19:58:43 +0000	[diff] [blame]	330	also</li>
Chris Lattner	8dad40c	2004-08-12 19:06:24 +0000	[diff] [blame]	331
Chris Lattner	47746aa	2005-11-13 02:09:55 +0000	[diff] [blame]	332	<li><tt>llvm/include/llvm/DerivedTypes.h</tt>:
Chris Lattner	8dad40c	2004-08-12 19:06:24 +0000	[diff] [blame]	333	add new class to represent new class in the hierarchy; add forward
				334	declaration to the TypeMap value type</li>
				335
				336	<li><tt>llvm/lib/VMCore/Type.cpp</tt>:
				337	add support for derived type to:
Misha Brukman	7cc8a89	2004-08-12 19:58:43 +0000	[diff] [blame]	338	<div class="doc_code">
				339	<pre>
				340	std::string getTypeDescription(const Type &Ty,
				341	std::vector<const Type*> &TypeStack)
				342	bool TypesEqual(const Type Ty, const Type Ty2,
				343	std::map<const Type, const Type> & EqTypes)
				344	</pre>
				345	</div>
				346	add necessary member functions for type, and factory methods</li>
Chris Lattner	8dad40c	2004-08-12 19:06:24 +0000	[diff] [blame]	347
				348	<li><tt>llvm/lib/AsmReader/Lexer.l</tt>:
				349	add ability to parse in the type from text assembly</li>
				350
				351	<li><tt>llvm/lib/ByteCode/Writer/Writer.cpp</tt>:
Misha Brukman	7cc8a89	2004-08-12 19:58:43 +0000	[diff] [blame]	352	modify <tt>void BytecodeWriter::outputType(const Type *T)</tt> to serialize
				353	your type</li>
Chris Lattner	8dad40c	2004-08-12 19:06:24 +0000	[diff] [blame]	354
				355	<li><tt>llvm/lib/ByteCode/Reader/Reader.cpp</tt>:
Misha Brukman	7cc8a89	2004-08-12 19:58:43 +0000	[diff] [blame]	356	modify <tt>const Type *BytecodeReader::ParseType()</tt> to read your data
				357	type</li>
Chris Lattner	8dad40c	2004-08-12 19:06:24 +0000	[diff] [blame]	358
				359	<li><tt>llvm/lib/VMCore/AsmWriter.cpp</tt>:
Misha Brukman	7cc8a89	2004-08-12 19:58:43 +0000	[diff] [blame]	360	modify
				361	<div class="doc_code">
				362	<pre>
				363	void calcTypeName(const Type *Ty,
				364	std::vector<const Type*> &TypeStack,
				365	std::map<const Type*,std::string> &TypeNames,
				366	std::string & Result)
				367	</pre>
				368	</div>
Chris Lattner	8dad40c	2004-08-12 19:06:24 +0000	[diff] [blame]	369	to output the new derived type
				370	</li>
				371
				372
				373	</ol>
Misha Brukman	a3ce429	2004-04-06 03:53:49 +0000	[diff] [blame]	374
				375	</div>
				376
				377	<!-- *********************************************************************** -->
				378
				379	<hr>
				380	<address>
				381	<a href="http://jigsaw.w3.org/css-validator/check/referer"><img
				382	src="http://jigsaw.w3.org/css-validator/images/vcss" alt="Valid CSS!"></a>
				383	<a href="http://validator.w3.org/check/referer"><img
				384	src="http://www.w3.org/Icons/valid-html401" alt="Valid HTML 4.01!" /></a>
				385
Reid Spencer	05fe4b0	2006-03-14 05:39:39 +0000	[diff] [blame]	386	<a href="http://llvm.org">The LLVM Compiler Infrastructure</a>
Misha Brukman	a3ce429	2004-04-06 03:53:49 +0000	[diff] [blame]	387	<br>
				388	Last modified: $Date$
				389	</address>
				390
				391	</body>
				392	</html>