X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=docs%2FStacker.html;h=81b623efa9a15eca20c51a6d4b78b7f755147b7c;hb=9f99b7c595b6c8ce68cd5f9f85e473f68705bed1;hp=04b796b1122121f37205b02f747dc9d2797f0712;hpb=1f92301a7dc8a0670b8bb625343d0956cd3c0d8a;p=oota-llvm.git

diff --git a/docs/Stacker.html b/docs/Stacker.html
index 04b796b1122..81b623efa9a 100644
--- a/docs/Stacker.html
+++ b/docs/Stacker.html
@@ -139,7 +139,7 @@ this: </p>
 Value* 
 expression(BasicBlock* bb, Value* a, Value* b, Value* x, Value* y )
 {
-    ConstantSInt* one = ConstantSInt::get(Type::IntTy, 1);
+    ConstantInt* one = ConstantInt::get(Type::IntTy, 1);
     BinaryOperator* or1 = BinaryOperator::createOr(a, b, "", bb);
     BinaryOperator* add1 = BinaryOperator::createAdd(x, one, "", bb);
     BinaryOperator* add2 = BinaryOperator::createAdd(y, one, "", bb);
@@ -198,7 +198,7 @@ should be constructed. In general, here's what I learned:
     <li><em>Create your blocks early.</em> While writing your compiler, you 
     will encounter several situations where you know apriori that you will
     need several blocks. For example, if-then-else, switch, while, and for
-    statements in C/C++ all need multiple blocks for expression in LVVM. 
+    statements in C/C++ all need multiple blocks for expression in LLVM. 
     The rule is, create them early.</li>
     <li><em>Terminate your blocks early.</em> This just reduces the chances 
     that you forget to terminate your blocks which is required (go 
@@ -219,8 +219,8 @@ should be constructed. In general, here's what I learned:
 </ol>
 <p>The foregoing is such an important principal, its worth making an idiom:</p>
 <pre>
-BasicBlock* bb = new BasicBlock();
-bb->getInstList().push_back( new Branch( ... ) );
+BasicBlock* bb = BasicBlock::Create();
+bb->getInstList().push_back( BranchInst::Create( ... ) );
 new Instruction(..., bb->getTerminator() );
 </pre>
 <p>To make this clear, consider the typical if-then-else statement
@@ -229,19 +229,19 @@ in a single function using LLVM in the following way: </p>
 <pre>
 using namespace llvm;
 BasicBlock*
-MyCompiler::handle_if( BasicBlock* bb, SetCondInst* condition )
+MyCompiler::handle_if( BasicBlock* bb, ICmpInst* condition )
 {
     // Create the blocks to contain code in the structure of if/then/else
-    BasicBlock* then_bb = new BasicBlock(); 
-    BasicBlock* else_bb = new BasicBlock();
-    BasicBlock* exit_bb = new BasicBlock();
+    BasicBlock* then_bb = BasicBlock::Create(); 
+    BasicBlock* else_bb = BasicBlock::Create();
+    BasicBlock* exit_bb = BasicBlock::Create();
 
     // Insert the branch instruction for the "if"
-    bb->getInstList().push_back( new BranchInst( then_bb, else_bb, condition ) );
+    bb->getInstList().push_back( BranchInst::Create( then_bb, else_bb, condition ) );
 
     // Set up the terminating instructions
-    then->getInstList().push_back( new BranchInst( exit_bb ) );
-    else->getInstList().push_back( new BranchInst( exit_bb ) );
+    then->getInstList().push_back( BranchInst::Create( exit_bb ) );
+    else->getInstList().push_back( BranchInst::Create( exit_bb ) );
 
     // Fill in the then part .. details excised for brevity
     this->fill_in( then_bb );
@@ -308,9 +308,9 @@ things, this leads to the idiom:
 </p>
 <pre>
 std::vector&lt;Value*&gt; index_vector;
-index_vector.push_back( ConstantSInt::get( Type::LongTy, 0 );
+index_vector.push_back( ConstantInt::get( Type::LongTy, 0 );
 // ... push other indices ...
-GetElementPtrInst* gep = new GetElementPtrInst( ptr, index_vector );
+GetElementPtrInst* gep = GetElementPtrInst::Create( ptr, index_vector );
 </pre>
 <p>For example, suppose we have a global variable whose type is [24 x int]. The
 variable itself represents a <em>pointer</em> to that array. To subscript the
@@ -367,9 +367,9 @@ functions in the LLVM IR that make things easier. Here's what I learned: </p>
 <ul>
  <li>Constants are Values like anything else and can be operands of instructions</li>
  <li>Integer constants, frequently needed, can be created using the static "get"
- methods of the ConstantInt, ConstantSInt, and ConstantUInt classes. The nice thing
- about these is that you can "get" any kind of integer quickly.</li>
- <li>There's a special method on Constant class which allows you to get the null 
+ methods of the ConstantInt class. The nice thing about these is that you can 
+ "get" any kind of integer quickly.</li>
+ <li>There's a special method on Constant class which allows you to get the null
  constant for <em>any</em> type. This is really handy for initializing large 
  arrays or structures, etc.</li>
 </ul>
@@ -787,7 +787,7 @@ using the following construction:</p>
 </tr>
 <tr><td>RROT</td>
     <td>RROT</td>
-    <td>w1 w2 w3 -- w2 w3 w1</td>
+    <td>w1 w2 w3 -- w3 w1 w2</td>
     <td>Reverse rotation. Like ROT, but it rotates the other way around.
 	Essentially, the third element on the stack is moved to the top
 	of the stack.</td>
@@ -946,24 +946,28 @@ using the following construction:</p>
 	executed. In either case, after the (words....) have executed, execution continues
         immediately following the ENDIF. </td>
 </tr>
-<tr><td>WHILE (words...) END</td>
-    <td>WHILE (words...) END</td>
+<tr><td>WHILE word END</td>
+    <td>WHILE word END</td>
     <td>b -- b </td>
-    <td>The boolean value on the top of the stack is examined. If it is non-zero then the 
-	"words..." between WHILE and END are executed. Execution then begins again at the WHILE where another
-	boolean is popped off the stack. To prevent this operation from eating up the entire
-	stack, you should push on to the stack (just before the END) a boolean value that indicates
-	whether to terminate. Note that since booleans and integers can be coerced you can
-	use the following "for loop" idiom:<br/>
-	<code>(push count) WHILE (words...) -- END</code><br/>
+    <td>The boolean value on the top of the stack is examined (not popped). If 
+      it is non-zero then the "word" between WHILE and END is executed. 
+      Execution then begins again at the WHILE where the boolean on the top of 
+      the stack is examined again. The stack is not modified by the WHILE...END 
+      loop, only examined. It is imperative that the "word" in the body of the
+      loop ensure that the top of the stack contains the next boolean to examine
+      when it completes.  Note that since booleans and integers can be coerced 
+      you can use the following "for loop" idiom:<br/>
+	<code>(push count) WHILE word -- END</code><br/>
 	For example:<br/>
-	<code>10 WHILE DUP &gt;d -- END</code><br/>
-	This will print the numbers from 10 down to 1. 10 is pushed on the stack. Since that is
-	non-zero, the while loop is entered. The top of the stack (10) is duplicated and then
-	printed out with &gt;d. The top of the stack is decremented, yielding 9 and control is
-	transfered back to the WHILE keyword. The process starts all over again and repeats until
-	the top of stack is decremented to 0 at which the WHILE test fails and control is
-	transfered to the word after the END.</td>
+	<code>10 WHILE &gt;d -- END</code><br/>
+        This will print the numbers from 10 down to 1. 10 is pushed on the 
+        stack. Since that is non-zero, the while loop is entered. The top of 
+        the stack (10) is printed out with &gt;d. The top of the stack is 
+        decremented, yielding 9 and control is transfered back to the WHILE 
+        keyword. The process starts all over again and repeats until
+        the top of stack is decremented to 0 at which point the WHILE test 
+        fails and control is transfered to the word after the END.
+      </td>
 </tr>
 <tr><th colspan="4"><b>INPUT &amp; OUTPUT OPERATORS</b></th></tr>
 <tr>
@@ -1292,13 +1296,26 @@ remainder of the story.
 </div>
 <!-- ======================================================================= -->
 <div class="doc_subsection"> <a name="directory">Directory Structure</a></div>
+
 <div class="doc_text">
 <p>The source code, test programs, and sample programs can all be found
-under the LLVM "projects" directory. You will need to obtain the LLVM sources
-to find it (either via anonymous CVS or a tarball. See the 
-<a href="GettingStarted.html">Getting Started</a> document).</p>
-<p>Under the "projects" directory there is a directory named "Stacker". That
-directory contains everything, as follows:</p>
+in the LLVM repository named <tt>llvm-stacker</tt> This should be checked out to
+the <tt>projects</tt> directory so that it will auto-configure. To do that, make
+sure you have the llvm sources in <tt><i>llvm</i></tt> 
+(see <a href="GettingStarted.html">Getting Started</a>) and then use these 
+commands:</p>
+
+<div class="doc_code">
+<pre>
+% svn co http://llvm.org/svn/llvm-project/llvm-top/trunk llvm-top
+% cd llvm-top
+% make build MODULE=stacker
+</pre>
+</div>
+
+<p>Under the <tt>projects/llvm-stacker</tt> directory you will find the
+implementation of the Stacker compiler, as follows:</p>
+
 <ul>
     <li><em>lib</em> - contains most of the source code
     <ul>
@@ -1313,35 +1330,38 @@ directory contains everything, as follows:</p>
     <li><em>sample</em> - contains the sample programs</li>
 </ul>
 </div>
+
 <!-- ======================================================================= -->
 <div class="doc_subsection"><a name="lexer"></a>The Lexer</div>
+
 <div class="doc_text">
-<p>See projects/Stacker/lib/compiler/Lexer.l</p>
+<p>See projects/llvm-stacker/lib/compiler/Lexer.l</p>
 </div>
+
 <!-- ======================================================================= -->
 <div class="doc_subsection"><a name="parser"></a>The Parser</div>
 <div class="doc_text">
-<p>See projects/Stacker/lib/compiler/StackerParser.y</p>
+<p>See projects/llvm-stacker/lib/compiler/StackerParser.y</p>
 </div>
 <!-- ======================================================================= -->
 <div class="doc_subsection"><a name="compiler"></a>The Compiler</div>
 <div class="doc_text">
-<p>See projects/Stacker/lib/compiler/StackerCompiler.cpp</p>
+<p>See projects/llvm-stacker/lib/compiler/StackerCompiler.cpp</p>
 </div>
 <!-- ======================================================================= -->
 <div class="doc_subsection"><a name="runtime"></a>The Runtime</div>
 <div class="doc_text">
-<p>See projects/Stacker/lib/runtime/stacker_rt.c</p>
+<p>See projects/llvm-stacker/lib/runtime/stacker_rt.c</p>
 </div>
 <!-- ======================================================================= -->
 <div class="doc_subsection"><a name="driver"></a>Compiler Driver</div>
 <div class="doc_text">
-<p>See projects/Stacker/tools/stkrc/stkrc.cpp</p>
+<p>See projects/llvm-stacker/tools/stkrc/stkrc.cpp</p>
 </div>
 <!-- ======================================================================= -->
 <div class="doc_subsection"><a name="tests"></a>Test Programs</div>
 <div class="doc_text">
-<p>See projects/Stacker/test/*.st</p>
+<p>See projects/llvm-stacker/test/*.st</p>
 </div>
 <!-- ======================================================================= -->
 <div class="doc_subsection"> <a name="exercise">Exercise</a></div>
@@ -1400,7 +1420,7 @@ interested, here are some things that could be implemented better:</p>
   src="http://www.w3.org/Icons/valid-html401" alt="Valid HTML 4.01!"></a>
 
   <a href="mailto:rspencer@x10sys.com">Reid Spencer</a><br>
-  <a href="http://llvm.cs.uiuc.edu">LLVM Compiler Infrastructure</a><br>
+  <a href="http://llvm.org">LLVM Compiler Infrastructure</a><br>
   Last modified: $Date$
 </address>