X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=docs%2FStacker.html;h=225a27bbf77556707220239e905f8a3d89dff404;hb=b627eab0402edabb19c702fd1f04c6c59ee2b339;hp=5fb5fe39d71ba7b44f6a9246d296497631aa1984;hpb=88eed81802c777552b5e77a2331d3ae0cadaaf72;p=oota-llvm.git diff --git a/docs/Stacker.html b/docs/Stacker.html index 5fb5fe39d71..225a27bbf77 100644 --- a/docs/Stacker.html +++ b/docs/Stacker.html @@ -4,10 +4,6 @@ Stacker: An Example Of Using LLVM - @@ -143,7 +139,7 @@ this:

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); @@ -202,7 +198,7 @@ should be constructed. In general, here's what I learned:
  • Create your blocks early. 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.
  • Terminate your blocks early. This just reduces the chances that you forget to terminate your blocks which is required (go @@ -233,7 +229,7 @@ in a single function using LLVM in the following way: 

     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(); 
@@ -312,7 +308,7 @@ things, this leads to the idiom:
 
    
 
     std::vector<Value*> 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 );
 
    
@@ -371,9 +367,9 @@ functions in the LLVM IR that make things easier. Here's what I learned: 
    
 
@@ -515,16 +511,16 @@ using the following construction:
    
 
 
 
    
-    
-
-
-
+    
    Definition Of Operation Of Built In Words
    LOGICAL OPERATIONS
    
+
+
+
-
+
@@ -581,7 +577,7 @@ using the following construction:
    
-
+
@@ -623,7 +619,7 @@ using the following construction:
    
     are bitwise exclusive OR'd together and pushed back on the stack. 
     For example, The sequence 1 3 XOR yields 2.
-
+
@@ -704,7 +700,7 @@ using the following construction:
    
-
+
@@ -791,7 +787,7 @@ using the following construction:
    
-    
+    
@@ -849,7 +845,7 @@ using the following construction:
    
     how much to rotate. That is, ROLL with n=1 is the same as ROT and 
     ROLL with n=2 is the same as ROT2.
-
+
@@ -902,7 +898,7 @@ using the following construction:
    
 	pushed back on the stack so this doesn't count as a "use ptr"
 	in the FREE idiom.
-
+
@@ -950,26 +946,30 @@ using the following construction:
    
 	executed. In either case, after the (words....) have executed, execution continues
         immediately following the ENDIF. 
-
-    
+
+    
-    
-
-
+	10 WHILE >d -- END
    
+        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 >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.
+      
+
+
@@ -1298,11 +1298,16 @@ remainder of the story.
 
     Directory Structure
    
 
    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 
-Getting Started document).
    
-
    Under the "projects" directory there is a directory named "Stacker". That
-directory contains everything, as follows:
    
+in the LLVM repository named llvm-stacker This should be checked out to
+the projects directory so that it will auto-configure. To do that, make
+sure you have the llvm sources in llvm 
+(see Getting Started) and then use these 
+commands:
    +    cd llvm/projects
+    cvs co llvm-stacker
    
+
    
+
    Under the projects/llvm-stacker directory you will find the
+implementation of the Stacker compiler, as follows:
    
 
      
     
    • lib - contains most of the source code
     
        
@@ -1320,32 +1325,32 @@ directory contains everything, as follows:
        
 
 
        The Lexer
        
 
        
-
        See projects/Stacker/lib/compiler/Lexer.l
        
+
        See projects/llvm-stacker/lib/compiler/Lexer.l
        
 
        
 
 
        The Parser
        
 
        
-
        See projects/Stacker/lib/compiler/StackerParser.y
        
+
        See projects/llvm-stacker/lib/compiler/StackerParser.y
        
 
        
 
 
        The Compiler
        
 
        
-
        See projects/Stacker/lib/compiler/StackerCompiler.cpp
        
+
        See projects/llvm-stacker/lib/compiler/StackerCompiler.cpp
        
 
        
 
 
        The Runtime
        
 
        
-
        See projects/Stacker/lib/runtime/stacker_rt.c
        
+
        See projects/llvm-stacker/lib/runtime/stacker_rt.c
        
 
        
 
 
        Compiler Driver
        
 
        
-
        See projects/Stacker/tools/stkrc/stkrc.cpp
        
+
        See projects/llvm-stacker/tools/stkrc/stkrc.cpp
        
 
        
 
 
        Test Programs
        
 
        
-
        See projects/Stacker/test/*.st
        
+
        See projects/llvm-stacker/test/*.st
        
 
        
 
 
         Exercise
        
@@ -1404,7 +1409,7 @@ interested, here are some things that could be implemented better:
        
   src="http://www.w3.org/Icons/valid-html401" alt="Valid HTML 4.01!">
 
   Reid Spencer
        
-  LLVM Compiler Infrastructure
        
+  LLVM Compiler Infrastructure
        
   Last modified: $Date$
 
 

    Definition Of Operation Of Built In Words
    LOGICAL OPERATIONS
    
     Word
     Name
     Operation
     Description
 
    
     <
     LT
     w1 w2 -- b
      -- b
     The boolean value TRUE (-1) is pushed on to the stack.
 
    BITWISE OPERATORS
    BITWISE OPERATORS
    
 
    
     Word
     Name
 
    ARITHMETIC OPERATORS
    ARITHMETIC OPERATORS
    
 
    
     Word
     Name
     Two values are popped off the stack. The larger value is pushed back
 	on to the stack.
 
    STACK MANIPULATION OPERATORS
    STACK MANIPULATION OPERATORS
    
 
    
     Word
     Name
 
    
 
    RROT
     RROTw1 w2 w3 -- w2 w3 w1w1 w2 w3 -- w3 w1 w2
     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.
 
    MEMORY OPERATORS
    MEMORY OPERATORS
    
 
    
     Word
     Name
 
    CONTROL FLOW OPERATORS
    CONTROL FLOW OPERATORS
    
 
    
     Word
     Name
 
    WHILE (words...) ENDWHILE (words...) END
    WHILE word ENDWHILE word END
     b -- b 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:
    
-	(push count) WHILE (words...) -- END
    
+        		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:
    
+	(push count) WHILE word -- END
    
 	For example:
    
-	10 WHILE DUP >d -- END
    
-	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 >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.
    INPUT & OUTPUT OPERATORS
    INPUT & OUTPUT OPERATORS
    
 
    
     Word
     Name