[llvm-commits] CVS: llvm/projects/Stacker/samples/Makefile fibonacci.st goof.st hello.st prime.st
Chris Lattner
lattner at cs.uiuc.edu
Sun Nov 23 11:56:01 PST 2003
Changes in directory llvm/projects/Stacker/samples:
Makefile added (r1.1)
fibonacci.st added (r1.1)
goof.st added (r1.1)
hello.st added (r1.1)
prime.st added (r1.1)
---
Log message:
Initial checkin of stacker samples
---
Diffs of the changes: (+236 -0)
Index: llvm/projects/Stacker/samples/Makefile
diff -c /dev/null llvm/projects/Stacker/samples/Makefile:1.1
*** /dev/null Sun Nov 23 11:55:29 2003
--- llvm/projects/Stacker/samples/Makefile Sun Nov 23 11:55:19 2003
***************
*** 0 ****
--- 1,48 ----
+ ##===- projects/sample/Makefile ----------------------------*- Makefile -*-===##
+ #
+ # This is a sample Makefile for a project that uses LLVM.
+ #
+ ##===----------------------------------------------------------------------===##
+
+ #
+ # Indicates our relative path to the top of the project's root directory.
+ #
+ LEVEL = ../../..
+
+ #
+ # Directories that needs to be built.
+ #
+ DIRS =
+
+ TESTS = fibonacci hello prime
+
+ all :: $(TESTS)
+
+ ifdef OPTIMIZE
+ %.bc : %.st
+ stkrc -e -o - $< | opt -stats -q -f -o $*.bc \
+ -aa-eval -adce -branch-combine -cee -constmerge -constprop -dce -die -ds-aa \
+ -ds-opt -gcse -globaldce -indvars -inline -instcombine \
+ -ipconstprop -licm -loopsimplify -mem2reg -pre -sccp -simplifycfg \
+ -tailcallelim -verify
+ else
+ %.bc : %.st
+ stkrc -e -f -o $*.bc $<
+ endif
+
+ %.s : %.bc
+ llc -f -o $*.s $<
+
+ % : %.s
+ gcc -g -L$(BUILD_OBJ_ROOT)/lib/Debug -lstkr_runtime -o $* $*.s
+
+ %.ll : %.bc
+ llvm-dis -f -o $*.ll $<
+
+ %.bc : $(BUILD_OBJ_ROOT)/tools/Debug/stkrc
+
+ .PRECIOUS: %.bc %.s %.ll %.st
+ #
+ # Include the Master Makefile that knows how to build all.
+ #
+ include $(LEVEL)/Makefile.common
Index: llvm/projects/Stacker/samples/fibonacci.st
diff -c /dev/null llvm/projects/Stacker/samples/fibonacci.st:1.1
*** /dev/null Sun Nov 23 11:55:29 2003
--- llvm/projects/Stacker/samples/fibonacci.st Sun Nov 23 11:55:19 2003
***************
*** 0 ****
--- 1,6 ----
+ #
+ # Fibonacci Algorithm in Stacker.
+ #
+ : print >d CR;
+ : fibonacci RROT DUP2 + print 3 PICK -- ;
+ : MAIN 0 print 1 print 44 WHILE fibonacci END ;
Index: llvm/projects/Stacker/samples/goof.st
diff -c /dev/null llvm/projects/Stacker/samples/goof.st:1.1
*** /dev/null Sun Nov 23 11:55:29 2003
--- llvm/projects/Stacker/samples/goof.st Sun Nov 23 11:55:19 2003
***************
*** 0 ****
--- 1 ----
+ : defmebaby 23 0 = ;
Index: llvm/projects/Stacker/samples/hello.st
diff -c /dev/null llvm/projects/Stacker/samples/hello.st:1.1
*** /dev/null Sun Nov 23 11:55:29 2003
--- llvm/projects/Stacker/samples/hello.st Sun Nov 23 11:55:19 2003
***************
*** 0 ****
--- 1,5 ----
+ #
+ # Traditional "Hello World" program in Stacker
+ #
+ : say_hello "Hello, World!" >s CR ;
+ : MAIN say_hello ;
Index: llvm/projects/Stacker/samples/prime.st
diff -c /dev/null llvm/projects/Stacker/samples/prime.st:1.1
*** /dev/null Sun Nov 23 11:55:29 2003
--- llvm/projects/Stacker/samples/prime.st Sun Nov 23 11:55:19 2003
***************
*** 0 ****
--- 1,176 ----
+ ################################################################################
+ #
+ # 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 )
+ 10000 < 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
+ 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
+ ;
+
+ ################################################################################
+ # The MAIN program just prints a banner and calls find_primes.
+ # STACK<: empty
+ # STACK>: empty
+ ################################################################################
+ : MAIN
+ "Prime Numbers: " >s CR ( say hello )
+ DROP ( get rid of that pesky string )
+ find_primes ( see how many we can find )
+ ;
More information about the llvm-commits
mailing list