<div class="doc_author">
<p>Written by <a href="http://misha.brukman.net">Misha Brukman</a>,
- Brad Jones, and <a href="http://nondot.org/sabre">Chris Lattner</a></p>
+ Brad Jones, Nate Begeman,
+ and <a href="http://nondot.org/sabre">Chris Lattner</a></p>
</div>
<!-- *********************************************************************** -->
<em>many</em> LLVM analyses and transformations, so it may be quite a bit of
work.</p>
-<p>Adding an <a href="#intrinsic">intrinsic function</a> is easier than adding
-an instruction, and is transparent to optimization passes which treat it as an
-unanalyzable function. If your added functionality can be expressed as a
+<p>Adding an <a href="#intrinsic">intrinsic function</a> is far easier than
+adding an instruction, and is transparent to optimization passes. If your added
+functionality can be expressed as a
function call, an intrinsic function is the method of choice for LLVM
extension.</p>
what the restrictions are. Talk to other people about it so that you are
sure it's a good idea.</li>
-<li><tt>llvm/include/llvm/Intrinsics.h</tt>:
- add an enum in the <tt>llvm::Intrinsic</tt> namespace</li>
-
-<li><tt>llvm/lib/VMCore/Verifier.cpp</tt>:
- Add code to check the invariants of the intrinsic are respected.</li>
-
-<li><tt>llvm/lib/VMCore/Function.cpp (<tt>Function::getIntrinsicID()</tt>)</tt>:
- Identify the new intrinsic function, returning the enum for the intrinsic
- that you added.</li>
-
-<li><tt>llvm/lib/Analysis/BasicAliasAnalysis.cpp</tt>: If the new intrinsic does
- not access memory or does not write to memory, add it to the relevant list
- of functions.</li>
+<li><tt>llvm/include/llvm/Intrinsics*.td</tt>:
+ Add an entry for your intrinsic. Describe its memory access characteristics
+ for optimization (this controls whether it will be DCE'd, CSE'd, etc).</li>
<li><tt>llvm/lib/Analysis/ConstantFolding.cpp</tt>: If it is possible to
constant fold your intrinsic, add support to it in the
<tt>canConstantFoldCallTo</tt> and <tt>ConstantFoldCall</tt> functions.</li>
-<li><tt>llvm/lib/Transforms/Utils/Local.cpp</tt>: If your intrinsic has no side-
- effects, add it to the list of intrinsics in the
- <tt>isInstructionTriviallyDead</tt> function.</li>
-
<li><tt>llvm/test/Regression/*</tt>: Add test cases for your test cases to the
test suite</li>
</ol>
code in all cases, just emit the expansion in <tt>visitCallInst</tt> in
<tt>Writer.cpp</tt>. If the intrinsic has some way to express it with GCC
(or any other compiler) extensions, it can be conditionally supported based on
-the compiler compiling the CBE output (see llvm.prefetch for an example).
+the compiler compiling the CBE output (see <tt>llvm.prefetch</tt> for an
+example).
Third, if the intrinsic really has no way to be lowered, just have the code
generator emit code that prints an error message and calls abort if executed.
</dd>
<dl>
-<dt>Add support to the SelectionDAG Instruction Selector in
-<tt>lib/CodeGen/SelectionDAG/</tt></dt>
-
-<dd>Since most targets in LLVM use the SelectionDAG framework for generating
-code, you will likely need to add support for your intrinsic there as well.
-This is usually accomplished by adding a new node, and then teaching the
-SelectionDAG code how to handle that node. To do this, follow the steps in
-the next section, Adding a new SelectionDAG node.</dd>
+<dt>Add support to the .td file for the target(s) of your choice in
+ <tt>lib/Target/*/*.td</tt>.</dt>
-<dl>
-<dt>Once you have added the new node, add code to
-<tt>SelectionDAG/SelectionDAGISel.cpp</tt> to recognize the intrinsic. In most
-cases, the intrinsic will just be turned into the node you just added. For an
-example of this, see how <tt>visitIntrinsicCall</tt> handles Intrinsic::ctpop
-</dt>
+<dd>This is usually a matter of adding a pattern to the .td file that matches
+ the intrinsic, though it may obviously require adding the instructions you
+ want to generate as well. There are lots of examples in the PowerPC and X86
+ backend to follow.</dd>
</div>
targets supported by the SelectionDAG framework will natively support the
new node. In this case, you must also add code in your node's case
statement in <tt>LegalizeOp</tt> to Expand your node into simpler, legal
- operations. The case for ISD::UREM for expanding a remainder into a
- multiply and a subtract is a good example.</li>
+ operations. The case for <tt>ISD::UREM</tt> for expanding a remainder into
+ a divide, multiply, and a subtract is a good example.</li>
<li><tt>lib/CodeGen/SelectionDAG/LegalizeDAG.cpp</tt>:
If targets may support the new node being added only at certain sizes, you
will also need to add code to your node's case statement in
<tt>LegalizeOp</tt> to Promote your node's operands to a larger size, and
perform the correct operation. You will also need to add code to
- <tt>PromoteOp</tt> to do this as well. For a good example, see ISD::BSWAP,
+ <tt>PromoteOp</tt> to do this as well. For a good example, see
+ <tt>ISD::BSWAP</tt>,
which promotes its operand to a wider size, performs the byteswap, and then
shifts the correct bytes right to emulate the narrower byteswap in the
wider type.</li>
<a href="http://validator.w3.org/check/referer"><img
src="http://www.w3.org/Icons/valid-html401" alt="Valid HTML 4.01!" /></a>
- <a href="http://llvm.cs.uiuc.edu">The LLVM Compiler Infrastructure</a>
+ <a href="http://llvm.org">The LLVM Compiler Infrastructure</a>
<br>
Last modified: $Date$
</address>