diff --git a/docs/ExtendingLLVM.html b/docs/ExtendingLLVM.html
index ef78498..d40b18f 100644
--- a/docs/ExtendingLLVM.html
+++ b/docs/ExtendingLLVM.html
@@ -24,8 +24,8 @@
 </ol>
 
 <div class="doc_author">    
-  <p>Written by <a href="http://misha.brukman.net">Misha Brukman</a> and
-  Brad Jones</p>
+  <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>
 </div>
 
 <!-- *********************************************************************** -->
@@ -86,9 +86,6 @@
 <li><tt>llvm/include/llvm/Intrinsics.h</tt>:
     add an enum in the <tt>llvm::Intrinsic</tt> namespace</li>
 
-<li><tt>llvm/lib/CodeGen/IntrinsicLowering.cpp</tt>:
-    implement the lowering for this intrinsic</li>
-
 <li><tt>llvm/lib/VMCore/Verifier.cpp</tt>:
     Add code to check the invariants of the intrinsic are respected.</li>
 
@@ -100,17 +97,63 @@
     not access memory or does not write to memory, add it to the relevant list
     of functions.</li>
 
-<li><tt>llvm/lib/Transforms/Utils/Local.cpp</tt>: If it is possible to
-    constant-propagate 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 it is possible to constant
+fold your intrinsic, add support to it in the <tt>canConstantFoldCallTo</tt> and
+<tt>ConstantFoldCall</tt> functions.</li>
 
 <li>Test your intrinsic</li>
 
 <li><tt>llvm/test/Regression/*</tt>: add your test cases to the test suite</li>
 </ol>
 
-<p>If this intrinsic requires code generator support (i.e., it cannot be
-lowered), you should also add support to the code generator in question.</p>
+<p>Once the intrinsic has been added to the system, you must add code generator
+support for it.  Generally you must do the following steps:</p>
+
+<dl>
+<dt>Add support to the C backend in <tt>lib/Target/CBackend/</tt></dt>
+
+<dd>Depending on the intrinsic, there are a few ways to implement this.  First,
+if it makes sense to lower the intrinsic to an expanded sequence of C code in
+all cases, just emit the expansion in <tt>visitCallInst</tt>.  Second, 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).  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>
+
+<dt>Add a enum value for the SelectionDAG node in
+<tt>include/llvm/CodeGen/SelectionDAGNodes.h</tt></dt>
+
+<dd>Also, add code to <tt>lib/CodeGen/SelectionDAG/SelectionDAG.cpp</tt> (and
+<tt>SelectionDAGPrinter.cpp</tt>) to print the node.</dd>
+
+<dt>Add code to <tt>SelectionDAG/SelectionDAGISel.cpp</tt> to recognize the
+intrinsic.</dt>
+
+<dd>Presumably the intrinsic should be recognized and turned into the node you
+added above.</dd>
+
+<dt>Add code to <tt>SelectionDAG/LegalizeDAG.cpp</tt> to <a
+href="CodeGenerator.html#selectiondag_legalize">legalize, promote, and
+expand</a> the node as necessary.</dt>
+
+<dd>If the intrinsic can be expanded to primitive operations, legalize can break
+the node down into other elementary operations that are be supported.</dd>
+
+<dt>Add target-specific support to specific code generators.</dt>
+
+<dd>Extend the code generators you are interested in to recognize and support
+the node, emitting the code you want.</dd>
+</dl>
+
+<p>
+Unfortunately, the process of extending the code generator to support a new node
+is not extremely well documented.  As such, it is often helpful to look at other
+intrinsics (e.g. <tt>llvm.ctpop</tt>) to see how they are recognized and turned
+into a node by <tt>SelectionDAGISel.cpp</tt>, legalized by
+<tt>LegalizeDAG.cpp</tt>, then finally emitted by the various code generators.
+</p>
 
 </div>
 
@@ -277,7 +320,6 @@
   <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://misha.brukman.net">Misha Brukman</a><br>
   <a href="http://llvm.cs.uiuc.edu">The LLVM Compiler Infrastructure</a>
   <br>
   Last modified: $Date$
