diff options
| author | Brian Gaeke <gaeke@uiuc.edu> | 2003-11-24 02:52:51 +0000 |
|---|---|---|
| committer | Brian Gaeke <gaeke@uiuc.edu> | 2003-11-24 02:52:51 +0000 |
| commit | 9018148f87e958b4536284eca29abbde6f3f25e1 (patch) | |
| tree | f6152a8fdd774894bbab9e168f15f631269dbe23 | |
| parent | ac981ae3e859b5d024fa23364fb7f1eaab78c8e7 (diff) | |
| download | external_llvm-9018148f87e958b4536284eca29abbde6f3f25e1.zip external_llvm-9018148f87e958b4536284eca29abbde6f3f25e1.tar.gz external_llvm-9018148f87e958b4536284eca29abbde6f3f25e1.tar.bz2 | |
Add documentation for Stacker.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@10189 91177308-0d34-0410-b5e6-96231b3b80d8
| -rw-r--r-- | docs/Stacker.html | 987 |
1 files changed, 987 insertions, 0 deletions
diff --git a/docs/Stacker.html b/docs/Stacker.html new file mode 100644 index 0000000..81ad60e --- /dev/null +++ b/docs/Stacker.html @@ -0,0 +1,987 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd"> +<html> +<head> + <title>Stacker: An Example Of Using LLVM</title> + <link rel="stylesheet" href="llvm.css" type="text/css"> +</head> +<body> +<div class="doc_title">Stacker: An Example Of Using LLVM</div> +<ol> + <li><a href="#abstract">Abstract</a></li> + <li><a href="#introduction">Introduction</a></li> + <li><a href="#lexicon">The Stacker Lexicon</a> + <ol> + <li><a href="#stack">The Stack</a> + <li><a href="#punctuation">Punctuation</a> + <li><a href="#literals">Literals</a> + <li><a href="#words">Words</a> + <li><a href="#builtins">Built-Ins</a> + </ol> + </li> + <li><a href="#directory">The Directory Structure </a> +</ol> +<div class="doc_text"> +<p><b>Written by <a href="mailto:rspencer@x10sys.com">Reid Spencer</a> </b></p> +<p> </p> +</div> +<!-- ======================================================================= --> +<div class="doc_section"> <a name="abstract">Abstract </a></div> +<div class="doc_text"> +<p>This document is another way to learn about LLVM. Unlike the +<a href="LangRef.html">LLVM Reference Manual</a> or +<a href="ProgrammersManual.html">LLVM Programmer's Manual</a>, this +document walks you through the implementation of a programming language +named Stacker. Stacker was invented specifically as a demonstration of +LLVM. The emphasis in this document is not on describing the +intricacies of LLVM itself, but on how to use it to build your own +compiler system.</p> +</div> +<!-- ======================================================================= --> +<div class="doc_section"> <a name="introduction">Introduction</a> </div> +<div class="doc_text"> +<p>Amongst other things, LLVM is a platform for compiler writers. +Because of its exceptionally clean and small IR (intermediate +representation), compiler writing with LLVM is much easier than with +other system. As proof, the author of Stacker wrote the entire +compiler (language definition, lexer, parser, code generator, etc.) in +about <em>four days</em>! That's important to know because it shows +how quickly you can get a new +language up when using LLVM. Furthermore, this was the <em >first</em> +language the author ever created using LLVM. The learning curve is +included in that four days.</p> +<p>The language described here, Stacker, is Forth-like. Programs +are simple collections of word definitions and the only thing definitions +can do is manipulate a stack or generate I/O. Stacker is not a "real" +programming language; its very simple. Although it is computationally +complete, you wouldn't use it for your next big project. However, +the fact that it is complete, its simple, and it <em>doesn't</em> have +a C-like syntax make it useful for demonstration purposes. It shows +that LLVM could be applied to a wide variety of language syntaxes.</p> +<p>The basic notions behind stacker is very simple. There's a stack of +integers (or character pointers) that the program manipulates. Pretty +much the only thing the program can do is manipulate the stack and do +some limited I/O operations. The language provides you with several +built-in words that manipulate the stack in interesting ways. To get +your feet wet, here's how you write the traditional "Hello, World" +program in Stacker:</p> +<p><code>: hello_world "Hello, World!" >s DROP CR ;<br> +: MAIN hello_world ;<br></code></p> +<p>This has two "definitions" (Stacker manipulates words, not +functions and words have definitions): <code>MAIN</code> and <code> +hello_world</code>. The <code>MAIN</code> definition is standard, it +tells Stacker where to start. Here, <code>MAIN</code> is defined to +simply invoke the word <code>hello_world</code>. The +<code>hello_world</code> definition tells stacker to push the +<code>"Hello, World!"</code> string onto the stack, print it out +(<code>>s</code>), pop it off the stack (<code>DROP</code>), and +finally print a carriage return (<code>CR</code>). Although +<code>hello_world</code> uses the stack, its net effect is null. Well +written Stacker definitions have that characteristic. </p> +<p>Exercise for the reader: how could you make this a one line program?</p> +</div> +<!-- ======================================================================= --> +<div class="doc_section"><a name="stack"></a>Lessons Learned About LLVM</div> +<div class="doc_text"> +<p>Stacker was written for two purposes: (a) to get the author over the +learning curve and (b) to provide a simple example of how to write a compiler +using LLVM. During the development of Stacker, many lessons about LLVM were +learned. Those lessons are described in the following subsections.<p> +</div> +<div class="doc_subsection"><a name="linkage"></a>Getting Linkage Types Right</div> +<div class="doc_text"><p>To be completed.</p></div> +<div class="doc_subsection"><a name="linkage"></a>Everything's a Value!</div> +<div class="doc_text"><p>To be completed.</p></div> +<div class="doc_subsection"><a name="linkage"></a>The Wily GetElementPtrInst</div> +<div class="doc_text"><p>To be completed.</p></div> +<div class="doc_subsection"><a name="linkage"></a>Constants Are Easier Than That!</div> +<div class="doc_text"><p>To be completed.</p></div> +<div class="doc_subsection"><a name="linkage"></a>Terminate Those Blocks!</div> +<div class="doc_text"><p>To be completed.</p></div> +<div class="doc_subsection"><a name="linkage"></a>new,get,create .. Its All The Same</div> +<div class="doc_text"><p>To be completed.</p></div> +<div class="doc_subsection"><a name="linkage"></a>Utility Functions To The Rescue</div> +<div class="doc_text"><p>To be completed.</p></div> +<div class="doc_subsection"><a name="linkage"></a>push_back Is Your Friend</div> +<div class="doc_text"><p>To be completed.</p></div> +<div class="doc_subsection"><a name="linkage"></a>Block Heads Come First</div> +<div class="doc_text"><p>To be completed.</p></div> +<!-- ======================================================================= --> +<div class="doc_section"> <a name="lexicon">The Stacker Lexicon</a></div> +<div class="doc_subsection"><a name="stack"></a>The Stack</div> +<div class="doc_text"> +<p>Stacker definitions define what they do to the global stack. Before +proceeding, a few words about the stack are in order. The stack is simply +a global array of 32-bit integers or pointers. A global index keeps track +of the location of the to of the stack. All of this is hidden from the +programmer but it needs to be noted because it is the foundation of the +conceptual programming model for Stacker. When you write a definition, +you are, essentially, saying how you want that definition to manipulate +the global stack.</p> +<p>Manipulating the stack can be quite hazardous. There is no distinction +given and no checking for the various types of values that can be placed +on the stack. Automatic coercion between types is performed. In many +cases this is useful. For example, a boolean value placed on the stack +can be interpreted as an integer with good results. However, using a +word that interprets that boolean value as a pointer to a string to +print out will almost always yield a crash. Stacker simply leaves it +to the programmer to get it right without any interference or hindering +on interpretation of the stack values. You've been warned :) </p> +</div> +<!-- ======================================================================= --> +<div class="doc_subsection"> <a name="punctuation"></a>Punctuation</div> +<div class="doc_text"> +<p>Punctuation in Stacker is very simple. The colon and semi-colon +characters are used to introduce and terminate a definition +(respectively). Except for <em>FORWARD</em> declarations, definitions +are all you can specify in Stacker. Definitions are read left to right. +Immediately after the semi-colon comes the name of the word being defined. +The remaining words in the definition specify what the word does.</p> +</div> +<!-- ======================================================================= --> +<div class="doc_subsection"><a name="literals"></a>Literals</div> +<div class="doc_text"> + <p>There are three kinds of literal values in Stacker. Integer, Strings, + and Booleans. In each case, the stack operation is to simply push the + value onto the stack. So, for example:<br/> + <code> 42 " is the answer." TRUE </code><br/> + will push three values onto the stack: the integer 42, the + string " is the answer." and the boolean TRUE.</p> +</div> +<!-- ======================================================================= --> +<div class="doc_subsection"><a name="words"></a>Words</div> +<div class="doc_text"> +<p>Each definition in Stacker is composed of a set of words. Words are +read and executed in order from left to right. There is very little +checking in Stacker to make sure you're doing the right thing with +the stack. It is assumed that the programmer knows how the stack +transformation he applies will affect the program.</p> +<p>Words in a definition come in two flavors: built-in and programmer +defined. Simply mentioning the name of a previously defined or declared +programmer-defined word causes that words definition to be invoked. It +is somewhat like a function call in other languages. The built-in +words have various effects, described below.</p> +<p>Sometimes you need to call a word before it is defined. For this, you can +use the <code>FORWARD</code> declaration. It looks like this</p> +<p><code>FORWARD name ;</code></p> +<p>This simply states to Stacker that "name" is the name of a definition +that is defined elsewhere. Generally it means the definition can be found +"forward" in the file. But, it doesn't have to be in the current compilation +unit. Anything declared with <code>FORWARD</code> is an external symbol for +linking.</p> +</div> +<!-- ======================================================================= --> +<div class="doc_subsection"><a name="builtins"></a>Built In Words</div> +<div class="doc_text"> +<p>The built-in words of the Stacker language are put in several groups +depending on what they do. The groups are as follows:</p> +<ol> + <li><em>Logical</em>These words provide the logical operations for + comparing stack operands.<br/>The words are: < > <= >= + = <> true false.</li> + <li><em>Bitwise</em>These words perform bitwise computations on + their operands. <br/> The words are: << >> XOR AND NOT</li> + <li><em>Arithmetic</em>These words perform arithmetic computations on + their operands. <br/> The words are: ABS NEG + - * / MOD */ ++ -- MIN MAX</li> + <li><em>Stack</em>These words manipulate the stack directly by moving + its elements around.<br/> The words are: DROP DUP SWAP OVER ROT DUP2 DROP2 PICK TUCK</li> + <li><em>Memory></em>These words allocate, free and manipulate memory + areas outside the stack.<br/>The words are: MALLOC FREE GET PUT</li> + <li><em>Control</em>These words alter the normal left to right flow + of execution.<br/>The words are: IF ELSE ENDIF WHILE END RETURN EXIT RECURSE</li> + <li><em>I/O</em> These words perform output on the standard output + and input on the standard input. No other I/O is possible in Stacker. + <br/>The words are: SPACE TAB CR >s >d >c <s <d <c.</li> +</ol> +<p>While you may be familiar with many of these operations from other +programming languages, a careful review of their semantics is important +for correct programming in Stacker. Of most importance is the effect +that each of these built-in words has on the global stack. The effect is +not always intuitive. To better describe the effects, we'll borrow from Forth the idiom of +describing the effect on the stack with:</p> +<p><code> BEFORE -- AFTER </code></p> +<p>That is, to the left of the -- is a representation of the stack before +the operation. To the right of the -- is a representation of the stack +after the operation. In the table below that describes the operation of +each of the built in words, we will denote the elements of the stack +using the following construction:</p> +<ol> + <li><em>b</em> - a boolean truth value</li> + <li><em>w</em> - a normal integer valued word.</li> + <li><em>s</em> - a pointer to a string value</li> + <li><em>p</em> - a pointer to a malloc's memory block</li> +</ol> +</div> +<div class="doc_text"> +<table class="doc_table" > +<tr class="doc_table"><td colspan="4">Definition Of Operation Of Built In Words</td></tr> +<tr class="doc_table"><td colspan="4">LOGICAL OPERATIONS</td></tr> +<tr class="doc_table"><td>Word</td><td>Name</td><td>Operation</td><td>Description</td></tr> +<tr class="doc_table"><td><</td> + <td>LT</td> + <td>w1 w2 -- b</td> + <td>Two values (w1 and w2) are popped off the stack and + compared. If w1 is less than w2, TRUE is pushed back on + the stack, otherwise FALSE is pushed back on the stack.</td> +</tr> +<tr><td>></td> + <td>GT</td> + <td>w1 w2 -- b</td> + <td>Two values (w1 and w2) are popped off the stack and + compared. If w1 is greater than w2, TRUE is pushed back on + the stack, otherwise FALSE is pushed back on the stack.</td> +</tr> +<tr><td>>=</td> + <td>GE</td> + <td>w1 w2 -- b</td> + <td>Two values (w1 and w2) are popped off the stack and + compared. If w1 is greater than or equal to w2, TRUE is + pushed back on the stack, otherwise FALSE is pushed back + on the stack.</td> +</tr> +<tr><td><=</td> + <td>LE</td> + <td>w1 w2 -- b</td> + <td>Two values (w1 and w2) are popped off the stack and + compared. If w1 is less than or equal to w2, TRUE is + pushed back on the stack, otherwise FALSE is pushed back + on the stack.</td> +</tr> +<tr><td>=</td> + <td>EQ</td> + <td>w1 w2 -- b</td> + <td>Two values (w1 and w2) are popped off the stack and + compared. If w1 is equal to w2, TRUE is + pushed back on the stack, otherwise FALSE is pushed back + </td> +</tr> +<tr><td><></td> + <td>NE</td> + <td>w1 w2 -- b</td> + <td>Two values (w1 and w2) are popped off the stack and + compared. If w1 is equal to w2, TRUE is + pushed back on the stack, otherwise FALSE is pushed back + </td> +</tr> +<tr><td>FALSE</td> + <td>FALSE</td> + <td> -- b</td> + <td>The boolean value FALSE (0) is pushed onto the stack.</td> +</tr> +<tr><td>TRUE</td> + <td>TRUE</td> + <td> -- b</td> + <td>The boolean value TRUE (-1) is pushed onto the stack.</td> +</tr> +<tr><td colspan="4">BITWISE OPERATIONS</td></tr> +<tr><td>Word</td><td>Name</td><td>Operation</td><td>Description</td></tr> +<tr><td><<</td> + <td>SHL</td> + <td>w1 w2 -- w1<<w2</td> + <td>Two values (w1 and w2) are popped off the stack. The w2 + operand is shifted left by the number of bits given by the + w1 operand. The result is pushed back to the stack.</td> +</tr> +<tr><td>>></td> + <td>SHR</td> + <td>w1 w2 -- w1>>w2</td> + <td>Two values (w1 and w2) are popped off the stack. The w2 + operand is shifted right by the number of bits given by the + w1 operand. The result is pushed back to the stack.</td> +</tr> +<tr><td>OR</td> + <td>OR</td> + <td>w1 w2 -- w2|w1</td> + <td>Two values (w1 and w2) are popped off the stack. The values + are bitwise OR'd together and pushed back on the stack. This is + not a logical OR. The sequence 1 2 OR yields 3 not 1.</td> +</tr> +<tr><td>AND</td> + <td>AND</td> + <td>w1 w2 -- w2&w1</td> + <td>Two values (w1 and w2) are popped off the stack. The values + are bitwise AND'd together and pushed back on the stack. This is + not a logical AND. The sequence 1 2 AND yields 0 not 1.</td> +</tr> +<tr><td>XOR</td> + <td>XOR</td> + <td>w1 w2 -- w2^w1</td> + <td>Two values (w1 and w2) are popped off the stack. The values + are bitwise exclusive OR'd together and pushed back on the stack. + For example, The sequence 1 3 XOR yields 2.</td> +</tr> +<tr><td colspan="4">ARITHMETIC OPERATIONS</td></tr> +<tr><td>Word</td><td>Name</td><td>Operation</td><td>Description</td></tr> +<tr><td>ABS</td> + <td>ABS</td> + <td>w -- |w|</td> + <td>One value s popped off the stack; its absolute value is computed + and then pushed onto the stack. If w1 is -1 then w2 is 1. If w1 is + 1 then w2 is also 1.</td> +</tr> +<tr><td>NEG</td> + <td>NEG</td> + <td>w -- -w</td> + <td>One value is popped off the stack which is negated and then + pushed back onto the stack. If w1 is -1 then w2 is 1. If w1 is + 1 then w2 is -1.</td> +</tr> +<tr><td> + </td> + <td>ADD</td> + <td>w1 w2 -- w2+w1</td> + <td>Two values are popped off the stack. Their sum is pushed back + onto the stack</td> +</tr> +<tr><td> - </td> + <td>SUB</td> + <td>w1 w2 -- w2-w1</td> + <td>Two values are popped off the stack. Their difference is pushed back + onto the stack</td> +</tr> +<tr><td> * </td> + <td>MUL</td> + <td>w1 w2 -- w2*w1</td> + <td>Two values are popped off the stack. Their product is pushed back + onto the stack</td> +</tr> +<tr><td> / </td> + <td>DIV</td> + <td>w1 w2 -- w2/w1</td> + <td>Two values are popped off the stack. Their quotient is pushed back + onto the stack</td> +</tr> +<tr><td>MOD</td> + <td>MOD</td> + <td>w1 w2 -- w2%w1</td> + <td>Two values are popped off the stack. Their remainder after division + of w1 by w2 is pushed back onto the stack</td> +</tr> +<tr><td> */ </td> + <td>STAR_SLAH</td> + <td>w1 w2 w3 -- (w3*w2)/w1</td> + <td>Three values are popped off the stack. The product of w1 and w2 is + divided by w3. The result is pushed back onto the stack.</td> +</tr> +<tr><td> ++ </td> + <td>INCR</td> + <td>w -- w+1</td> + <td>One value is popped off the stack. It is incremented by one and then + pushed back onto the stack.</td> +</tr> +<tr><td> -- </td> + <td>DECR</td> + <td>w -- w-1</td> + <td>One value is popped off the stack. It is decremented by one and then + pushed back onto the stack.</td> +</tr> +<tr><td>MIN</td> + <td>MIN</td> + <td>w1 w2 -- (w2<w1?w2:w1)</td> + <td>Two values are popped off the stack. The larger one is pushed back + onto the stack.</td> +</tr> +<tr><td>MAX</td> + <td>MAX</td> + <td>w1 w2 -- (w2>w1?w2:w1)</td> + <td>Two values are popped off the stack. The larger value is pushed back + onto the stack.</td> +</tr> +<tr><td colspan="4">STACK MANIPULATION OPERATIONS</td></tr> +<tr><td>Word</td><td>Name</td><td>Operation</td><td>Description</td></tr> +<tr><td>DROP</td> + <td>DROP</td> + <td>w -- </td> + <td>One value is popped off the stack.</td> +</tr> +<tr><td>DROP2</td> + <td>DROP2</td> + <td>w1 w2 -- </td> + <td>Two values are popped off the stack.</td> +</tr> +<tr><td>NIP</td> + <td>NIP</td> + <td>w1 w2 -- w2</td> + <td>The second value on the stack is removed from the stack. That is, + a value is popped off the stack and retained. Then a second value is + popped and the retained value is pushed.</td> +</tr> +<tr><td>NIP2</td> + <td>NIP2</td> + <td>w1 w2 w3 w4 -- w3 w4</td> + <td>The third and fourth values on the stack are removed from it. That is, + two values are popped and retained. Then two more values are popped and + the two retained values are pushed back on.</td> +</tr> +<tr><td>DUP</td> + <td>DUP</td> + <td>w1 -- w1 w1</td> + <td>One value is popped off the stack. That value is then pushed onto + the stack twice to duplicate the top stack vaue.</td> +</tr> +<tr><td>DUP2</td> + <td>DUP2</td> + <td>w1 w2 -- w1 w2 w1 w2</td> + <td>The top two values on the stack are duplicated. That is, two vaues + are popped off the stack. They are alternately pushed back on the + stack twice each.</td> +</tr> +<tr><td>SWAP</td> + <td>SWAP</td> + <td>w1 w2 -- w2 w1</td> + <td>The top two stack items are reversed in their order. That is, two + values are popped off the stack and pushed back onto the stack in + the opposite order they were popped.</td> +</tr> +<tr><td>SWAP2</td> + <td>SWAP2</td> + <td>w1 w2 w3 w4 -- w3 w4 w2 w1</td> + <td>The top four stack items are swapped in pairs. That is, two values + are popped and retained. Then, two more values are popped and retained. + The values are pushed back onto the stack in the reverse order but + in pairs.</p> +</tr> +<tr><td>OVER</td> + <td>OVER</td> + <td>w1 w2-- w1 w2 w1</td> + <td>Two values are popped from the stack. They are pushed back + onto the stack in the order w1 w2 w1. This seems to cause the + top stack element to be duplicated "over" the next value.</td> +</tr> +<tr><td>OVER2</td> + <td>OVER2</td> + <td>w1 w2 w3 w4 -- w1 w2 w3 w4 w1 w2</td> + <td>The third and fourth values on the stack are replicated onto the + top of the stack</td> +</tr> +<tr><td>ROT</td> + <td>ROT</td> + <td>w1 w2 w3 -- w2 w3 w1</td> + <td>The top three values are rotated. That is, three value are popped + off the stack. They are pushed back onto the stack in the order + w1 w3 w2.</td> +</tr> +<tr><td>ROT2</td> + <td>ROT2</td> + <td>w1 w2 w3 w4 w5 w6 -- w3 w4 w5 w6 w1 w2</td> + <td>Like ROT but the rotation is done using three pairs instead of + three singles.</td> +</tr> +<tr><td>RROT</td> + <td>RROT</td> + <td>w1 w2 w3 -- w2 w3 w1</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> +</tr> +<tr><td>RROT2</td> + <td>RROT2</td> + <td>w1 w2 w3 w4 w5 w6 -- w3 w4 w5 w6 w1 w2</td> + <td>Double reverse rotation. Like RROT but the rotation is done using + three pairs instead of three singles. The fifth and sixth stack + elements are moved to the first and second positions</td> +</tr> +<tr><td>TUCK</td> + <td>TUCK</td> + <td>w1 w2 -- w2 w1 w2</td> + <td>Similar to OVER except that the second operand is being + replicated. Essentially, the first operand is being "tucked" + in between two instances of the second operand. Logically, two + values are popped off the stack. They are placed back on the + stack in the order w2 w1 w2.</td> +</tr> +<tr><td>TUCK2</td> + <td>TUCK2</td> + <td>w1 w2 w3 w4 -- w3 w4 w1 w2 w3 w4</td> + <td>Like TUCK but a pair of elements is tucked over two pairs. + That is, the top two elements of the stack are duplicated and + inserted into the stack at the fifth and positions.</td> +</tr> +<tr><td>PICK</td> + <td>PICK</td> + <td>x0 ... Xn n -- x0 ... Xn x0</td> + <td>The top of the stack is used as an index into the remainder of + the stack. The element at the nth position replaces the index + (top of stack). This is useful for cycling through a set of + values. Note that indexing is zero based. So, if n=0 then you + get the second item on the stack. If n=1 you get the third, etc. + Note also that the index is replaced by the n'th value. </td> +</tr> +<tr><td>SELECT</td> + <td>SELECT</td> + <td>m n X0..Xm Xm+1 .. Xn -- Xm</td> + <td>This is like PICK but the list is removed and you need to specify + both the index and the size of the list. Careful with this one, + the wrong value for n can blow away a huge amount of the stack.</td> +</tr> +<tr><td>ROLL</td> + <td>ROLL</td> + <td>x0 x1 .. xn n -- x1 .. xn x0</td> + <td><b>Not Implemented</b>. This one has been left as an exercise to + the student. If you can implement this one you understand Stacker + and probably a fair amount about LLVM since this is one of the + more complicated Stacker operations. See the StackerCompiler.cpp + file in the projects/Stacker/lib/compiler directory. The operation + of ROLL is like a generalized ROT. That is ROLL with n=1 is the + same as ROT. The n value (top of stack) is used as an index to + select a value up the stack that is <em>moved</em> to the top of + the stack. See the implementations of PICk and SELECT to get + some hints.<p> +</tr> +<tr><td colspan="4">MEMORY OPERATIONS</td></tr> +<tr><td>Word</td><td>Name</td><td>Operation</td><td>Description</td></tr> +<tr><td>MALLOC</td> + <td>MALLOC</td> + <td>w1 -- p</td> + <td>One value is popped off the stack. The value is used as the size + of a memory block to allocate. The size is in bytes, not words. + The memory allocation is completed and the address of the memory + block is pushed onto the stack.</td> +</tr> +<tr><td>FREE</td> + <td>FREE</td> + <td>p -- </td> + <td>One pointer value is popped off the stack. The value should be + the address of a memory block created by the MALLOC operation. The + associated memory block is freed. Nothing is pushed back on the + stack. Many bugs can be created by attempting to FREE something + that isn't a pointer to a MALLOC allocated memory block. Make + sure you know what's on the stack. One way to do this is with + the following idiom:<br/> + <code>64 MALLOC DUP DUP (use ptr) DUP (use ptr) ... FREE</code> + <br/>This ensures that an extra copy of the pointer is placed on + the stack (for the FREE at the end) and that every use of the + pointer is preceded by a DUP to retain the copy for FREE.</td> +</tr> +<tr><td>GET</td> + <td>GET</td> + <td>w1 p -- w2 p</td> + <td>An integer index and a pointer to a memory block are popped of + the block. The index is used to index one byte from the memory + block. That byte value is retained, the pointer is pushed again + and the retained value is pushed. Note that the pointer value + s essentially retained in its position so this doesn't count + as a "use ptr" in the FREE idiom.</td> +</tr> +<tr><td>PUT</td> + <td>PUT</td> + <td>w1 w2 p -- p </td> + <td>An integer value is popped of the stack. This is the value to + be put into a memory block. Another integer value is popped of + the stack. This is the indexed byte in the memory block. A + pointer to the memory block is popped off the stack. The + first value (w1) is then converted to a byte and written + to the element of the memory block(p) at the index given + by the second value (w2). The pointer to the memory block is + pushed back on the stack so this doesn't count as a "use ptr" + in the FREE idiom.</td> +</tr> +<tr><td colspan="4">CONTROL FLOW OPERATIONS</td></tr> +<tr><td>Word</td><td>Name</td><td>Operation</td><td>Description</td></tr> +<tr><td>RETURN</td> + <td>RETURN</td> + <td> -- </td> + <td>The currently executing definition returns immediately to its caller. + Note that there is an implicit <code>RETURN</code> at the end of each + definition, logically located at the semi-colon. The sequence + <code>RETURN ;</code> is valid but redundant.</td> +</tr> +<tr><td>EXIT</td> + <td>EXIT</td> + <td>w1 -- </td> + <td>A return value for the program is popped off the stack. The program is + then immediately terminated. This is normally an abnormal exit from the + program. For a normal exit (when <code>MAIN</code> finishes), the exit + code will always be zero in accordance with UNIX conventions.</td> +</tr> +<tr><td>RECURSE</td> + <td>RECURSE</td> + <td> -- </td> + <td>The currently executed definition is called again. This operation is + needed since the definition of a word doesn't exist until the semi colon + is reacher. Attempting something like:<br/> + <code> : recurser recurser ; </code><br/> will yield and error saying that + "recurser" is not defined yet. To accomplish the same thing, change this + to:<br/> + <code> : recurser RECURSE ; </code></td> +</tr> +<tr><td>IF (words...) ENDIF</td> + <td>IF (words...) ENDIF</td> + <td>b -- </td> + <td>A boolean value is popped of the stack. If it is non-zero then the "words..." + are executed. Otherwise, execution continues immediately following the ENDIF.</td> +</tr> +<tr><td>IF (words...) ELSE (words...) ENDIF</td> + <td>IF (words...) ELSE (words...) ENDIF</td> + <td>b -- </td> + <td>A boolean value is popped of the stack. If it is non-zero then the "words..." + between IF and ELSE are executed. Otherwise the words between ELSE and ENDIF are + 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> + <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 onto 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/> + For example:<br/> + <code>10 WHILE DUP >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 >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> +</tr> +<tr><td colspan="4">INPUT & OUTPUT OPERATIONS</td></tr> +<tr><td>Word</td><td>Name</td><td>Operation</td><td>Description</td></tr> +<tr><td>SPACE</td> + <td>SPACE</td> + <td> -- </td> + <td>A space character is put out. There is no stack effect.</td> +</tr> +<tr><td>TAB</td> + <td>TAB</td> + <td> -- </td> + <td>A tab character is put out. There is no stack effect.</td> +</tr> +<tr><td>CR</td> + <td>CR</td> + <td> -- </td> + <td>A carriage return character is put out. There is no stack effect.</td> +</tr> +<tr><td>>s</td> + <td>OUT_STR</td> + <td> -- </td> + <td>A string pointer is popped from the stack. It is put out.</td> +</tr> +<tr><td>>d</td> + <td>OUT_STR</td> + <td> -- </td> + <td>A value is popped from the stack. It is put out as a decimal integer.</td> +</tr> +<tr><td>>c</td> + <td>OUT_CHR</td> + <td> -- </td> + <td>A value is popped from the stack. It is put out as an ASCII character.</td> +</tr> +<tr><td><s</td> + <td>IN_STR</td> + <td> -- s </td> + <td>A string is read from the input via the scanf(3) format string " %as". The + resulting string is pushed onto the stack.</td> +</tr> +<tr><td><d</td> + <td>IN_STR</td> + <td> -- w </td> + <td>An integer is read from the input via the scanf(3) format string " %d". The + resulting value is pushed onto the stack</td> +</tr> +<tr><td><c</td> + <td>IN_CHR</td> + <td> -- w </td> + <td>A single character is read from the input via the scanf(3) format string + " %c". The value is converted to an integer and pushed onto the stack.</td> +</tr> +<tr><td>DUMP</td> + <td>DUMP</td> + <td> -- </td> + <td>The stack contents are dumped to standard output. This is useful for + debugging your definitions. Put DUMP at the beginning and end of a definition + to see instantly the net effect of the definition.</td> +</tr> +</table> +</div> +<!-- ======================================================================= --> +<div class="doc_section"> <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> +<ul> + <li><em>lib</em> - contains most of the source code + <ul> + <li><em>lib/compiler</em> - contains the compiler library + <li><em>lib/runtime</em> - contains the runtime library + </ul></li> + <li><em>test</em> - contains the test programs</li> + <li><em>tools</em> - contains the Stacker compiler main program, stkrc + <ul> + <li><em>lib/stkrc</em> - contains the Stacker compiler main program + </ul</li> + <li><em>sample</em> - contains the sample programs</li> +</ul> +</div> +<!-- ======================================================================= --> +<div class="doc_section"> <a name="directory">Prime: A Complete Example</a></div> +<div class="doc_text"> +<p>The following fully documented program highlights many of features of both +the Stacker language and what is possible with LLVM. The program simply +prints out the prime numbers until it reaches +</p> +</div> +<div class="doc_text"> +<p><code> +<![CDATA[ +################################################################################ +# +# Brute force prime number generator +# +# This program is written in classic Stacker style, that being the style of a +# stack. Start at the bottom and read your way up ! +# +# Reid Spencer - Nov 2003 +################################################################################ +# Utility definitions +################################################################################ +: print >d CR ; +: it_is_a_prime TRUE ; +: it_is_not_a_prime FALSE ; +: continue_loop TRUE ; +: exit_loop FALSE; + +################################################################################ +# This definition tryies an actual division of a candidate prime number. It +# determines whether the division loop on this candidate should continue or +# not. +# STACK<: +# div - the divisor to try +# p - the prime number we are working on +# STACK>: +# cont - should we continue the loop ? +# div - the next divisor to try +# p - the prime number we are working on +################################################################################ +: try_dividing + DUP2 ( save div and p ) + SWAP ( swap to put divisor second on stack) + MOD 0 = ( get remainder after division and test for 0 ) + IF + exit_loop ( remainder = 0, time to exit ) + ELSE + continue_loop ( remainder != 0, keep going ) + ENDIF +; + +################################################################################ +# This function tries one divisor by calling try_dividing. But, before doing +# that it checks to see if the value is 1. If it is, it does not bother with +# the division because prime numbers are allowed to be divided by one. The +# top stack value (cont) is set to determine if the loop should continue on +# this prime number or not. +# STACK<: +# cont - should we continue the loop (ignored)? +# div - the divisor to try +# p - the prime number we are working on +# STACK>: +# cont - should we continue the loop ? +# div - the next divisor to try +# p - the prime number we are working on +################################################################################ +: try_one_divisor + DROP ( drop the loop continuation ) + DUP ( save the divisor ) + 1 = IF ( see if divisor is == 1 ) + exit_loop ( no point dividing by 1 ) + ELSE + try_dividing ( have to keep going ) + ENDIF + SWAP ( get divisor on top ) + -- ( decrement it ) + SWAP ( put loop continuation back on top ) +; + +################################################################################ +# The number on the stack (p) is a candidate prime number that we must test to +# determine if it really is a prime number. To do this, we divide it by every +# number from one p-1 to 1. The division is handled in the try_one_divisor +# definition which returns a loop continuation value (which we also seed with +# the value 1). After the loop, we check the divisor. If it decremented all +# the way to zero then we found a prime, otherwise we did not find one. +# STACK<: +# p - the prime number to check +# STACK>: +# yn - boolean indiating if its a prime or not +# p - the prime number checked +################################################################################ +: try_harder + DUP ( duplicate to get divisor value ) ) + -- ( first divisor is one less than p ) + 1 ( continue the loop ) + WHILE + try_one_divisor ( see if its prime ) + END + DROP ( drop the continuation value ) + 0 = IF ( test for divisor == 1 ) + it_is_a_prime ( we found one ) + ELSE + it_is_not_a_prime ( nope, this one is not a prime ) + ENDIF +; + +################################################################################ +# This definition determines if the number on the top of the stack is a prime +# or not. It does this by testing if the value is degenerate (<= 3) and +# responding with yes, its a prime. Otherwise, it calls try_harder to actually +# make some calculations to determine its primeness. +# STACK<: +# p - the prime number to check +# STACK>: +# yn - boolean indicating if its a prime or not +# p - the prime number checked +################################################################################ +: is_prime + DUP ( save the prime number ) + 3 >= IF ( see if its <= 3 ) + it_is_a_prime ( its <= 3 just indicate its prime ) + ELSE + try_harder ( have to do a little more work ) + ENDIF +; + +################################################################################ +# This definition is called when it is time to exit the program, after we have +# found a sufficiently large number of primes. +# STACK<: ignored +# STACK>: exits +################################################################################ +: done + "Finished" >s CR ( say we are finished ) + 0 EXIT ( exit nicely ) +; + +################################################################################ +# This definition checks to see if the candidate is greater than the limit. If +# it is, it terminates the program by calling done. Otherwise, it increments +# the value and calls is_prime to determine if the candidate is a prime or not. +# If it is a prime, it prints it. Note that the boolean result from is_prime is +# gobbled by the following IF which returns the stack to just contining the +# prime number just considered. +# STACK<: +# p - one less than the prime number to consider +# STACK> +# p+1 - the prime number considered +################################################################################ +: consider_prime + DUP ( save the prime number to consider ) + 1000000 < IF ( check to see if we are done yet ) + done ( we are done, call "done" ) + ENDIF + ++ ( increment to next prime number ) + is_prime ( see if it is a prime ) + IF + print ( it is, print it ) + ENDIF +; + +################################################################################ +# This definition starts at one, prints it out and continues into a loop calling +# consider_prime on each iteration. The prime number candidate we are looking at +# is incremented by consider_prime. +# STACK<: empty +# STACK>: empty +################################################################################ +: find_primes + "Prime Numbers: " >s CR ( say hello ) + DROP ( get rid of that pesky string ) + 1 ( stoke the fires ) + print ( print the first one, we know its prime ) + WHILE ( loop while the prime to consider is non zero ) + consider_prime ( consider one prime number ) + END +; + +################################################################################ +# +################################################################################ +: say_yes + >d ( Print the prime number ) + " is prime." ( push string to output ) + >s ( output it ) + CR ( print carriage return ) + DROP ( pop string ) +; + +: say_no + >d ( Print the prime number ) + " is NOT prime." ( push string to put out ) + >s ( put out the string ) + CR ( print carriage return ) + DROP ( pop string ) +; + +################################################################################ +# This definition processes a single command line argument and determines if it +# is a prime number or not. +# STACK<: +# n - number of arguments +# arg1 - the prime numbers to examine +# STACK>: +# n-1 - one less than number of arguments +# arg2 - we processed one argument +################################################################################ +: do_one_argument + -- ( decrement loop counter ) + SWAP ( get the argument value ) + is_prime IF ( determine if its prime ) + say_yes ( uhuh ) + ELSE + say_no ( nope ) + ENDIF + DROP ( done with that argument ) +; + +################################################################################ +# The MAIN program just prints a banner and processes its arguments. +# STACK<: +# n - number of arguments +# ... - the arguments +################################################################################ +: process_arguments + WHILE ( while there are more arguments ) + do_one_argument ( process one argument ) + END +; + +################################################################################ +# The MAIN program just prints a banner and processes its arguments. +# STACK<: arguments +################################################################################ +: MAIN + NIP ( get rid of the program name ) + -- ( reduce number of arguments ) + DUP ( save the arg counter ) + 1 <= IF ( See if we got an argument ) + process_arguments ( tell user if they are prime ) + ELSE + find_primes ( see how many we can find ) + ENDIF + 0 ( push return code ) +; +]]> +</code> +</p> +</div> +<!-- ======================================================================= --> +<div class="doc_section"> <a name="lexicon">Internals</a></div> +<div class="doc_text"><p>To be completed.</p></div> +<div class="doc_subsection"><a name="stack"></a>The Lexer</div> +<div class="doc_subsection"><a name="stack"></a>The Parser</div> +<div class="doc_subsection"><a name="stack"></a>The Compiler</div> +<div class="doc_subsection"><a name="stack"></a>The Stack</div> +<div class="doc_subsection"><a name="stack"></a>Definitions Are Functions</div> +<div class="doc_subsection"><a name="stack"></a>Words Are BasicBlocks</div> +<!-- ======================================================================= --> +<hr> +<div class="doc_footer"> +<address><a href="mailto:rspencer@x10sys.com">Reid Spencer</a></address> +<a href="http://llvm.cs.uiuc.edu">The LLVM Compiler Infrastructure</a> +<br>Last modified: $Date$ </div> +</body> +</html> |