[llvm-commits] CVS: llvm-www/releases/1.1/docs/ProgrammersManual.html WritingAnLLVMPass.html

Tanya Brethour tbrethou at cs.uiuc.edu
Tue Jun 22 03:10:10 PDT 2004

Changes in directory llvm-www/releases/1.1/docs:

ProgrammersManual.html updated: 1.2 -> 1.3
WritingAnLLVMPass.html updated: 1.1 -> 1.2

Log message:

Fixing broken links

Diffs of the changes:  (+39 -39)

Index: llvm-www/releases/1.1/docs/ProgrammersManual.html
diff -u llvm-www/releases/1.1/docs/ProgrammersManual.html:1.2 llvm-www/releases/1.1/docs/ProgrammersManual.html:1.3
--- llvm-www/releases/1.1/docs/ProgrammersManual.html:1.2	Mon Jun 21 23:25:36 2004
+++ llvm-www/releases/1.1/docs/ProgrammersManual.html	Tue Jun 22 03:01:42 2004
@@ -653,7 +653,7 @@
 the same way, even though their most-specific common base class is <tt>Instruction</tt>,
 which includes lots of less closely-related things. For these cases,
 LLVM provides a handy wrapper class called <a
- href="http://llvm.cs.uiuc.edu/doxygen/classCallSite.html"><tt>CallSite </tt></a>.
+ href="http://llvm.cs.uiuc.edu/doxygen/classllvm_1_1CallSite.html"><tt>CallSite </tt></a>.
 It is essentially a wrapper around an <tt>Instruction</tt> pointer,
 with some methods that provide functionality common to <tt>CallInst</tt>s
 and <tt>InvokeInst</tt>s.</p>
@@ -670,7 +670,7 @@
 use-def chains</a></h4>
 Frequently, we might have an instance of the <a
- href="/doxygen/classValue.html">Value Class</a> and we want to
+ href="/doxygen/structllvm_1_1Value.html">Value Class</a> and we want to
 determine which <tt>User</tt>s use the <tt>Value</tt>.  The list of
 all <tt>User</tt>s of a particular <tt>Value</tt> is called a <i>def-use</i>
 chain. For example, let's say we have a <tt>Function*</tt> named <tt>F</tt>
@@ -679,7 +679,7 @@
 chain of <tt>F</tt>:
   <pre>Function* F = ...;<br><br>for (Value::use_iterator i = F->use_begin(), e = F->use_end(); i != e; ++i) {<br>    if (Instruction *Inst = dyn_cast<Instruction>(*i)) {<br>        cerr << "F is used in instruction:\n";<br>        cerr << *Inst << "\n";<br>    }<br>}<br></pre>
 Alternately, it's common to have an instance of the <a
- href="/doxygen/classUser.html">User Class</a> and need to know what <tt>Value</tt>s
+ href="/doxygen/classllvm_1_1User.html">User Class</a> and need to know what <tt>Value</tt>s
 are used by it.  The list of all <tt>Value</tt>s used by a <tt>User</tt>
 is known as a <i>use-def</i> chain.  Instances of class <tt>Instruction</tt>
 are common <tt>User</tt>s, so we might want to iterate over all of the
@@ -722,7 +722,7 @@
 allocation of one integer in the current stack frame, at runtime. Each <tt>Instruction</tt>
 subclass is likely to have varying default parameters which change the
 semantics of the instruction, so refer to the <a
- href="/doxygen/classInstruction.html">doxygen documentation for the
+ href="/doxygen/classllvm_1_1Instruction.html>doxygen documentation for the
 subclass of Instruction</a> that you're interested in instantiating.
   <p><i>Naming values</i></p>
   <p> It is very useful to name the values of instructions when you're
@@ -819,8 +819,8 @@
   <p><i>Replacing multiple uses of <tt>User</tt>s and 		 <tt>Value</tt>s</i></p>
 You can use <tt>Value::replaceAllUsesWith</tt> and <tt>User::replaceUsesOfWith</tt>
 to change more than one use at a time.  See the doxygen documentation
-for the <a href="/doxygen/classValue.html">Value Class</a> and <a
- href="/doxygen/classUser.html">User Class</a>, respectively, for more
+for the <a href="/doxygen/structllvm_1_1Value.html">Value Class</a> and <a
+ href="/doxygen/classllvm_1_1User.html">User Class</a>, respectively, for more
 information.<!-- Value::replaceAllUsesWith User::replaceUsesOfWith Point out:
 include/llvm/Transforms/Utils/ especially BasicBlockUtils.h with:
 ReplaceInstWithValue, ReplaceInstWithInst
@@ -856,7 +856,7 @@
   <tt>#include "<a href="/doxygen/Value_8h-source.html">llvm/Value.h</a>"</tt><br>
-doxygen info: <a href="/doxygen/classValue.html">Value Class</a>
+doxygen info: <a href="/doxygen/structllvm_1_1Value.html">Value Class</a>
   <p> The <tt>Value</tt> class is the most important class in the LLVM
 Source base.  It represents a typed value that may be used (among other
 things) as an operand to an instruction.  There are many different types
@@ -950,7 +950,7 @@
   <tt>#include "<a href="/doxygen/User_8h-source.html">llvm/User.h</a>"</tt><br>
-doxygen info: <a href="/doxygen/classUser.html">User Class</a><br>
+doxygen info: <a href="/doxygen/classllvm_1_1User.html">User Class</a><br>
 Superclass: <a href="#Value"><tt>Value</tt></a>
   <p> The <tt>User</tt> class is the common base class of all LLVM nodes
 that may refer to <a href="#Value"><tt>Value</tt></a>s.  It exposes a
@@ -1001,7 +1001,7 @@
   <tt>#include "</tt><tt><a href="/doxygen/Instruction_8h-source.html">llvm/Instruction.h</a>"</tt><br>
-doxygen info: <a href="/doxygen/classInstruction.html">Instruction
+doxygen info: <a href="/doxygen/classllvm_1_1Instruction.html">Instruction
 Superclasses: <a href="#User"><tt>User</tt></a>, <a href="#Value"><tt>Value</tt></a>
   <p> The <tt>Instruction</tt> class is the common base class for all
@@ -1023,7 +1023,7 @@
 implement the instruction (for example <tt><a href="#BinaryOperator">BinaryOperator</a></tt>
 and <tt><a href="#SetCondInst">SetCondInst</a></tt>).  Unfortunately,
 the use of macros in this file confuses doxygen, so these enum values
-don't show up correctly in the <a href="/doxygen/classInstruction.html">doxygen
+don't show up correctly in the <a href="/doxygen/classllvm_1_1Instruction.html">doxygen
   <p><!-- _______________________________________________________________________ --> </p>
@@ -1065,7 +1065,7 @@
   <tt>#include "<a href="/doxygen/BasicBlock_8h-source.html">llvm/BasicBlock.h</a>"</tt><br>
-doxygen info: <a href="/doxygen/classBasicBlock.html">BasicBlock Class</a><br>
+doxygen info: <a href="/doxygen/structllvm_1_1BasicBlock.html">BasicBlock Class</a><br>
 Superclass: <a href="#Value"><tt>Value</tt></a>
   <p> This class represents a single entry multiple exit section of the
 code, commonly known as a basic block by the compiler community.  The <tt>BasicBlock</tt>
@@ -1145,7 +1145,7 @@
   <tt>#include "<a href="/doxygen/GlobalValue_8h-source.html">llvm/GlobalValue.h</a>"</tt><br>
-doxygen info: <a href="/doxygen/classGlobalValue.html">GlobalValue
+doxygen info: <a href="/doxygen/classllvm_1_1GlobalValue.html">GlobalValue
 Superclasses: <a href="#User"><tt>User</tt></a>, <a href="#Value"><tt>Value</tt></a>
   <p> Global values (<a href="#GlobalVariable"><tt>GlobalVariable</tt></a>s
@@ -1215,7 +1215,7 @@
   <tt>#include "<a href="/doxygen/Function_8h-source.html">llvm/Function.h</a>"</tt><br>
-doxygen info: <a href="/doxygen/classFunction.html">Function Class</a><br>
+doxygen info: <a href="/doxygen/classllvm_1_1Function.html">Function Class</a><br>
 Superclasses: <a href="#GlobalValue"><tt>GlobalValue</tt></a>, <a
  href="#User"><tt>User</tt></a>, <a href="#Value"><tt>Value</tt></a>
   <p> The <tt>Function</tt> class represents a single procedure in LLVM.
@@ -1338,7 +1338,7 @@
   <tt>#include "<a href="/doxygen/GlobalVariable_8h-source.html">llvm/GlobalVariable.h</a>"</tt><br>
-doxygen info: <a href="/doxygen/classGlobalVariable.html">GlobalVariable
+doxygen info: <a href="/doxygen/classllvm_1_1GlobalVariable.html">GlobalVariable
 Superclasses: <a href="#GlobalValue"><tt>GlobalValue</tt></a>, <a
  href="#User"><tt>User</tt></a>, <a href="#Value"><tt>Value</tt></a>
@@ -1402,7 +1402,7 @@
   <tt>#include "<a href="/doxygen/Module_8h-source.html">llvm/Module.h</a>"</tt><br>
-doxygen info: <a href="/doxygen/classModule.html">Module Class</a>
+doxygen info: <a href="/doxygen/classllvm_1_1Module.html">Module Class</a>
   <p> The <tt>Module</tt> class represents the top level structure
 present in LLVM programs.  An LLVM module is effectively either a
 translation unit of the original program or a combination of several

Index: llvm-www/releases/1.1/docs/WritingAnLLVMPass.html
diff -u llvm-www/releases/1.1/docs/WritingAnLLVMPass.html:1.1 llvm-www/releases/1.1/docs/WritingAnLLVMPass.html:1.2
--- llvm-www/releases/1.1/docs/WritingAnLLVMPass.html:1.1	Sat Dec 13 16:03:43 2003
+++ llvm-www/releases/1.1/docs/WritingAnLLVMPass.html	Tue Jun 22 03:01:42 2004
@@ -96,13 +96,13 @@
 all, a structuring technique for compiler code.<p>
 All LLVM passes are subclasses of the <tt><a
-href="http://llvm.cs.uiuc.edu/doxygen/classPass.html">Pass</a></tt> class, which
+href="http://llvm.cs.uiuc.edu/doxygen/classllvm_1_1Pass.html">Pass</a></tt> class, which
 implement functionality by overriding virtual methods inherited from
 <tt>Pass</tt>.  Depending on how your pass works, you may be able to inherit
 from the <tt><a
 or <tt><a
 which gives the system more information about what your pass does, and how it
 can be combined with other passes.  One of the main features of the LLVM Pass
 Framework is that it schedules passes to run in an efficient way based on the
@@ -181,9 +181,9 @@
 Which are needed because we are writing a <tt><a
-href="http://llvm.cs.uiuc.edu/doxygen/classPass.html">Pass</a></tt>, and we are
+href="http://llvm.cs.uiuc.edu/doxygen/classllvm_1_1Pass.html">Pass</a></tt>, and we are
 operating on <tt><a
 Next we have:<p>
@@ -204,7 +204,7 @@
 This declares a "<tt>Hello</tt>" class that is a subclass of <tt><a
 The different builtin pass subclasses are described in detail <a
 href="#passtype">later</a>, but for now, know that <a href="#FunctionPass"><tt>FunctionPass</tt></a>'s
 operate a function at a time.<p>
@@ -380,7 +380,7 @@
 The most plain and boring type of pass is the "<tt><a
 class.  This pass type is used for passes that do not have to be run, do not
 change state, and never need to be updated.  This is not a normal type of
 transformation or analysis, but can provide information about the current
@@ -401,7 +401,7 @@
 <a name="Pass">The <tt>Pass</tt> class
-The "<tt><a href="http://llvm.cs.uiuc.edu/doxygen/classPass.html">Pass</a></tt>"
+The "<tt><a href="http://llvm.cs.uiuc.edu/doxygen/classllvm_1_1Pass.html">Pass</a></tt>"
 class is the most general of all superclasses that you can use.  Deriving from
 <tt>Pass</tt> indicates that your pass uses the entire program as a unit,
 refering to function bodies in no predictable order, or adding and removing
@@ -433,7 +433,7 @@
 In contrast to direct <tt>Pass</tt> subclasses, direct <tt><a
 subclasses do have a predictable, local behavior that can be expected by the
 system.  All <tt>FunctionPass</tt> execute on each function in the program
 independent of all of the other functions in the program.
@@ -730,9 +730,9 @@
 By implementing the <tt>getAnalysisUsage</tt> method, the required and
 invalidated sets may be specified for your transformation.  The implementation
 should fill in the <tt><a
 object with information about which passes are required and not invalidated.  To do this, the following set methods are provided by the <tt><a
-href="http://llvm.cs.uiuc.edu/doxygen/classAnalysisUsage.html">AnalysisUsage</a></tt> class:<p>
+href="http://llvm.cs.uiuc.edu/doxygen/classllvm_1_1AnalysisUsage.html">AnalysisUsage</a></tt> class:<p>
   <i>// addRequires - Add the specified pass to the required set for your pass.</i>
@@ -762,9 +762,9 @@
   <i>// This is an example implementation from an analysis, which does not modify
   // the program at all, yet has a prerequisite.</i>
-  <b>void</b> <a href="http://llvm.cs.uiuc.edu/doxygen/structPostDominanceFrontier.html">PostDominanceFrontier</a>::getAnalysisUsage(AnalysisUsage &AU) <b>const</b> {
+  <b>void</b> <a href="http://llvm.cs.uiuc.edu/doxygen/structllvm_1_1PostDominanceFrontier.html">PostDominanceFrontier</a>::getAnalysisUsage(AnalysisUsage &AU) <b>const</b> {
-    AU.addRequired<<a href="http://llvm.cs.uiuc.edu/doxygen/structPostDominatorTree.html">PostDominatorTree</a>>();
+    AU.addRequired<<a href="http://llvm.cs.uiuc.edu/doxygen/structllvm_1_1PostDominatorTree.html">PostDominatorTree</a>>();
@@ -774,7 +774,7 @@
   <i>// This example modifies the program, but does not modify the CFG</i>
   <b>void</b> <a href="http://llvm.cs.uiuc.edu/doxygen/structLICM.html">LICM</a>::getAnalysisUsage(AnalysisUsage &AU) <b>const</b> {
-    AU.addRequired<<a href="http://llvm.cs.uiuc.edu/doxygen/classLoopInfo.html">LoopInfo</a>>();
+    AU.addRequired<<a href="http://llvm.cs.uiuc.edu/doxygen/classllvm_1_1LoopInfo.html">LoopInfo</a>>();
@@ -848,16 +848,16 @@
 As a concrete example of an Analysis Group in action, consider the <a
 analysis group.  The default implementation of the alias analysis interface (the
 pass) just does a few simple checks that don't require significant analysis to
 compute (such as: two different globals can never alias each other, etc).
 Passes that use the <tt><a
 interface (for example the <tt><a
-href="http://llvm.cs.uiuc.edu/doxygen/classGCSE.html">gcse</a></tt> pass), do not care which implementation
+href="http://llvm.cs.uiuc.edu/doxygen/structGCSE.html">gcse</a></tt> pass), do not care which implementation
 of alias analysis is actually provided, they just use the designated
@@ -879,7 +879,7 @@
 for the Analysis Group Interface itself, because it is "abstract":<p>
-  <b>static</b> RegisterAnalysisGroup<<a href="http://llvm.cs.uiuc.edu/doxygen/structAliasAnalysis.html">AliasAnalysis</a>> A("<i>Alias Analysis</i>");
+  <b>static</b> RegisterAnalysisGroup<<a href="http://llvm.cs.uiuc.edu/doxygen/classllvm_1_1AliasAnalysis.html">AliasAnalysis</a>> A("<i>Alias Analysis</i>");
 Once the analysis is registered, passes can declare that they are valid
@@ -892,13 +892,13 @@
   B("<i>somefancyaa</i>", "<i>A more complex alias analysis implementation</i>");
   //<i> Declare that we implement the AliasAnalysis interface</i>
-  RegisterAnalysisGroup<<a href="http://llvm.cs.uiuc.edu/doxygen/structAliasAnalysis.html">AliasAnalysis</a>, FancyAA> C;
+  RegisterAnalysisGroup<<a href="http://llvm.cs.uiuc.edu/doxygen/classllvm_1_1AliasAnalysis.html">AliasAnalysis</a>, FancyAA> C;
 This just shows a class <tt>FancyAA</tt> that is registered normally, then uses
 the <tt>RegisterAnalysisGroup</tt> template to "join" the <tt><a
 analysis group.  Every implementation of an analysis group should join using
 this template.  A single pass may join multiple different analysis groups with
 no problem.<p>
@@ -910,7 +910,7 @@
   D("<i>basicaa</i>", "<i>Basic Alias Analysis (default AA impl)</i>");
   //<i> Declare that we implement the AliasAnalysis interface</i>
-  RegisterAnalysisGroup<<a href="http://llvm.cs.uiuc.edu/doxygen/structAliasAnalysis.html">AliasAnalysis</a>, <a href="http://llvm.cs.uiuc.edu/doxygen/structBasicAliasAnalysis.html">BasicAliasAnalysis</a>, <b>true</b>> E;
+  RegisterAnalysisGroup<<a href="http://llvm.cs.uiuc.edu/doxygen/classllvm_1_1AliasAnalysis.html">AliasAnalysis</a>, <a href="http://llvm.cs.uiuc.edu/doxygen/structBasicAliasAnalysis.html">BasicAliasAnalysis</a>, <b>true</b>> E;
@@ -931,7 +931,7 @@
 The <a
-<a href="http://llvm.cs.uiuc.edu/doxygen/classPassManager.html">class</a> takes
+<a href="http://llvm.cs.uiuc.edu/doxygen/classllvm_1_1PassManager.html">class</a> takes
 a list of passes, ensures their <a href="#interaction">prerequisites</a> are set
 up correctly, and then schedules passes to run efficiently.  All of the LLVM
 tools that run passes use the <tt>PassManager</tt> for execution of these
@@ -962,7 +962,7 @@
 the LLVM program representation for a single function at a time, instead of
 traversing the entire program.  It reduces the memory consumption of compiler,
 because, for example, only one <a
 needs to be calculated at a time.  This also makes it possible some <a
 href="#SMP">interesting enhancements</a> in the future.<p>
@@ -1232,7 +1232,7 @@
 </ul><h4><a name="ModuleSource"><hr size=0>A new <tt>ModuleSource</tt> interface</h4><ul>
 Currently, the <tt>PassManager</tt>'s <tt>run</tt> method takes a <tt><a
-href="http://llvm.cs.uiuc.edu/doxygen/classModule.html">Module</a></tt> as
+href="http://llvm.cs.uiuc.edu/doxygen/classllvm_1_1Module.html">Module</a></tt> as
 input, and runs all of the passes on this module.  The problem with this
 approach is that none of the <tt>PassManager</tt> features can be used for
 timing and debugging the actual <b>loading</b> of the module from disk or

More information about the llvm-commits mailing list