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

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