replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Changes to make the Stacker Stack use 64 bit values. This *should* get 

around the problem with Stacker on Solaris because the Stack can handle
64-bit entries (pointer sized).

llvm-svn: 13441
This commit is contained in:
Reid Spencer 2004-05-09 23:20:19 +00:00
parent a367dd745b
commit be4fadf1b8
5 changed files with 37 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
llvm/projects/Stacker/lib/compiler/Lexer.l
View File

@ -31,10 +31,10 @@
#include "StackerParser.h" #include "StackerParser.h"
/* Conversion of text ints to binary */ /* Conversion of text ints to binary */
static uint64_t IntToVal(const char *Buffer) { static int64_t IntToVal(const char *Buffer) {
uint64_t Result = 0; int64_t Result = 0;
for (; *Buffer; Buffer++) { for (; *Buffer; Buffer++) {
uint64_t OldRes = Result; int64_t OldRes = Result;
Result *= 10; Result *= 10;
Result += *Buffer-'0'; Result += *Buffer-'0';
if (Result < OldRes) // Uh, oh, overflow detected!!! if (Result < OldRes) // Uh, oh, overflow detected!!!
@ -44,10 +44,10 @@ static uint64_t IntToVal(const char *Buffer) {
} }
/* Conversion of text hexadecimal ints to binary */ /* Conversion of text hexadecimal ints to binary */
static uint64_t HexIntToVal(const char *Buffer) { static int64_t HexIntToVal(const char *Buffer) {
uint64_t Result = 0; int64_t Result = 0;
for (; *Buffer; ++Buffer) { for (; *Buffer; ++Buffer) {
uint64_t OldRes = Result; int64_t OldRes = Result;
Result *= 16; Result *= 16;
char C = *Buffer; char C = *Buffer;
if (C >= '0' && C <= '9') if (C >= '0' && C <= '9')

48
llvm/projects/Stacker/lib/compiler/StackerCompiler.cpp
View File

@ -60,9 +60,6 @@ StackerCompiler::StackerCompiler()
, Three(0) , Three(0)
, Four(0) , Four(0)
, Five(0) , Five(0)
, IZero(0)
, IOne(0)
, ITwo(0)
, no_arguments() , no_arguments()
, echo(false) , echo(false)
, stack_size(256) , stack_size(256)
@ -121,8 +118,8 @@ StackerCompiler::compile(
TheModule = new Module( CurFilename ); TheModule = new Module( CurFilename );
// Create a type to represent the stack. This is the same as the LLVM // Create a type to represent the stack. This is the same as the LLVM
// Assembly type [ 256 x int ] // Assembly type [ 256 x long ]
stack_type = ArrayType::get( Type::IntTy, stack_size ); stack_type = ArrayType::get( Type::LongTy, stack_size );
// Create a global variable for the stack. Note the use of appending // Create a global variable for the stack. Note the use of appending
// linkage linkage so that multiple modules will make the stack larger. // linkage linkage so that multiple modules will make the stack larger.
@ -240,9 +237,6 @@ StackerCompiler::compile(
Three = ConstantInt::get( Type::LongTy, 3 ); Three = ConstantInt::get( Type::LongTy, 3 );
Four = ConstantInt::get( Type::LongTy, 4 ); Four = ConstantInt::get( Type::LongTy, 4 );
Five = ConstantInt::get( Type::LongTy, 5 ); Five = ConstantInt::get( Type::LongTy, 5 );
IZero = ConstantInt::get( Type::IntTy, 0 );
IOne = ConstantInt::get( Type::IntTy, 1 );
ITwo = ConstantInt::get( Type::IntTy, 2 );
// Reset the current line number // Reset the current line number
Stackerlineno = 1; Stackerlineno = 1;
@ -366,8 +360,8 @@ StackerCompiler::push_value( BasicBlock* bb, Value* val )
GetElementPtrInst* gep = cast<GetElementPtrInst>( GetElementPtrInst* gep = cast<GetElementPtrInst>(
get_stack_pointer( bb ) ); get_stack_pointer( bb ) );
// Cast the value to an integer .. hopefully it works // Cast the value to a long .. hopefully it works
CastInst* cast_inst = new CastInst( val, Type::IntTy ); CastInst* cast_inst = new CastInst( val, Type::LongTy );
bb->getInstList().push_back( cast_inst ); bb->getInstList().push_back( cast_inst );
// Store the value // Store the value
@ -378,10 +372,10 @@ StackerCompiler::push_value( BasicBlock* bb, Value* val )
} }
Instruction* Instruction*
StackerCompiler::push_integer(BasicBlock* bb, int32_t value ) StackerCompiler::push_integer(BasicBlock* bb, int64_t value )
{ {
// Just push a constant integer value // Just push a constant integer value
return push_value( bb, ConstantSInt::get( Type::IntTy, value ) ); return push_value( bb, ConstantSInt::get( Type::LongTy, value ) );
} }
Instruction* Instruction*
@ -639,7 +633,7 @@ StackerCompiler::handle_if( char* ifTrue, char* ifFalse )
// Compare the condition against 0 // Compare the condition against 0
SetCondInst* cond_inst = new SetCondInst( Instruction::SetNE, cond, SetCondInst* cond_inst = new SetCondInst( Instruction::SetNE, cond,
ConstantSInt::get( Type::IntTy, 0) ); ConstantSInt::get( Type::LongTy, 0) );
bb->getInstList().push_back( cond_inst ); bb->getInstList().push_back( cond_inst );
// Create an exit block // Create an exit block
@ -723,7 +717,7 @@ StackerCompiler::handle_while( char* todo )
// Compare the condition against 0 // Compare the condition against 0
SetCondInst* cond_inst = new SetCondInst( SetCondInst* cond_inst = new SetCondInst(
Instruction::SetNE, cond, ConstantSInt::get( Type::IntTy, 0) ); Instruction::SetNE, cond, ConstantSInt::get( Type::LongTy, 0) );
test->getInstList().push_back( cond_inst ); test->getInstList().push_back( cond_inst );
// Add the branch instruction // Add the branch instruction
@ -789,7 +783,7 @@ StackerCompiler::handle_string( char * value )
} }
BasicBlock* BasicBlock*
StackerCompiler::handle_integer( const int32_t value ) StackerCompiler::handle_integer( const int64_t value )
{ {
// Create a new basic block for the push operation // Create a new basic block for the push operation
BasicBlock* bb = new BasicBlock((echo?"int":"")); BasicBlock* bb = new BasicBlock((echo?"int":""));
@ -927,7 +921,7 @@ StackerCompiler::handle_word( int tkn )
if (echo) bb->setName("INCR"); if (echo) bb->setName("INCR");
LoadInst* op1 = cast<LoadInst>(pop_integer(bb)); LoadInst* op1 = cast<LoadInst>(pop_integer(bb));
BinaryOperator* addop = BinaryOperator* addop =
BinaryOperator::create( Instruction::Add, op1, IOne ); BinaryOperator::create( Instruction::Add, op1, One );
bb->getInstList().push_back( addop ); bb->getInstList().push_back( addop );
push_value( bb, addop ); push_value( bb, addop );
break; break;
@ -937,7 +931,7 @@ StackerCompiler::handle_word( int tkn )
if (echo) bb->setName("DECR"); if (echo) bb->setName("DECR");
LoadInst* op1 = cast<LoadInst>(pop_integer(bb)); LoadInst* op1 = cast<LoadInst>(pop_integer(bb));
BinaryOperator* subop = BinaryOperator::create( Instruction::Sub, op1, BinaryOperator* subop = BinaryOperator::create( Instruction::Sub, op1,
ConstantSInt::get( Type::IntTy, 1 ) ); ConstantSInt::get( Type::LongTy, 1 ) );
bb->getInstList().push_back( subop ); bb->getInstList().push_back( subop );
push_value( bb, subop ); push_value( bb, subop );
break; break;
@ -1007,7 +1001,7 @@ StackerCompiler::handle_word( int tkn )
// bb->getInstList().push_back( negop ); // bb->getInstList().push_back( negop );
// So we'll multiply by -1 (ugh) // So we'll multiply by -1 (ugh)
BinaryOperator* multop = BinaryOperator::create( Instruction::Mul, op1, BinaryOperator* multop = BinaryOperator::create( Instruction::Mul, op1,
ConstantSInt::get( Type::IntTy, -1 ) ); ConstantSInt::get( Type::LongTy, -1 ) );
bb->getInstList().push_back( multop ); bb->getInstList().push_back( multop );
push_value( bb, multop ); push_value( bb, multop );
break; break;
@ -1020,7 +1014,7 @@ StackerCompiler::handle_word( int tkn )
// Determine if its negative // Determine if its negative
SetCondInst* cond_inst = SetCondInst* cond_inst =
new SetCondInst( Instruction::SetLT, op1, IZero ); new SetCondInst( Instruction::SetLT, op1, Zero );
bb->getInstList().push_back( cond_inst ); bb->getInstList().push_back( cond_inst );
// Create a block for storing the result // Create a block for storing the result
@ -1367,7 +1361,7 @@ StackerCompiler::handle_word( int tkn )
if (echo) bb->setName("PICK"); if (echo) bb->setName("PICK");
LoadInst* n = cast<LoadInst>( stack_top( bb ) ); LoadInst* n = cast<LoadInst>( stack_top( bb ) );
BinaryOperator* addop = BinaryOperator* addop =
BinaryOperator::create( Instruction::Add, n, IOne ); BinaryOperator::create( Instruction::Add, n, One );
bb->getInstList().push_back( addop ); bb->getInstList().push_back( addop );
LoadInst* x0 = cast<LoadInst>( stack_top( bb, addop ) ); LoadInst* x0 = cast<LoadInst>( stack_top( bb, addop ) );
replace_top( bb, x0 ); replace_top( bb, x0 );
@ -1379,11 +1373,11 @@ StackerCompiler::handle_word( int tkn )
LoadInst* m = cast<LoadInst>( stack_top(bb) ); LoadInst* m = cast<LoadInst>( stack_top(bb) );
LoadInst* n = cast<LoadInst>( stack_top(bb, One) ); LoadInst* n = cast<LoadInst>( stack_top(bb, One) );
BinaryOperator* index = BinaryOperator* index =
BinaryOperator::create( Instruction::Add, m, IOne ); BinaryOperator::create( Instruction::Add, m, One );
bb->getInstList().push_back( index ); bb->getInstList().push_back( index );
LoadInst* Xm = cast<LoadInst>( stack_top(bb, index ) ); LoadInst* Xm = cast<LoadInst>( stack_top(bb, index ) );
BinaryOperator* n_plus_1 = BinaryOperator* n_plus_1 =
BinaryOperator::create( Instruction::Add, n, IOne ); BinaryOperator::create( Instruction::Add, n, One );
bb->getInstList().push_back( n_plus_1 ); bb->getInstList().push_back( n_plus_1 );
decr_stack_index( bb, n_plus_1 ); decr_stack_index( bb, n_plus_1 );
replace_top( bb, Xm ); replace_top( bb, Xm );
@ -1496,9 +1490,13 @@ StackerCompiler::handle_word( int tkn )
// Get the result value // Get the result value
LoadInst* op1 = cast<LoadInst>(pop_integer(bb)); LoadInst* op1 = cast<LoadInst>(pop_integer(bb));
// Cast down to an integer
CastInst* caster = new CastInst( op1, Type::IntTy );
bb->getInstList().push_back( caster );
// Call exit(3) // Call exit(3)
std::vector<Value*> params; std::vector<Value*> params;
params.push_back(op1); params.push_back(caster);
CallInst* call_inst = new CallInst( TheExit, params ); CallInst* call_inst = new CallInst( TheExit, params );
bb->getInstList().push_back( call_inst ); bb->getInstList().push_back( call_inst );
break; break;
@ -1514,7 +1512,7 @@ StackerCompiler::handle_word( int tkn )
new GetElementPtrInst( ChrFormat, indexVec ); new GetElementPtrInst( ChrFormat, indexVec );
bb->getInstList().push_back( format_gep ); bb->getInstList().push_back( format_gep );
// Get the character to print (a newline) // Get the character to print (a tab)
ConstantSInt* newline = ConstantSInt::get(Type::IntTy, ConstantSInt* newline = ConstantSInt::get(Type::IntTy,
static_cast<int>('\t')); static_cast<int>('\t'));
@ -1536,7 +1534,7 @@ StackerCompiler::handle_word( int tkn )
new GetElementPtrInst( ChrFormat, indexVec ); new GetElementPtrInst( ChrFormat, indexVec );
bb->getInstList().push_back( format_gep ); bb->getInstList().push_back( format_gep );
// Get the character to print (a newline) // Get the character to print (a space)
ConstantSInt* newline = ConstantSInt::get(Type::IntTy, ConstantSInt* newline = ConstantSInt::get(Type::IntTy,
static_cast<int>(' ')); static_cast<int>(' '));

7
llvm/projects/Stacker/lib/compiler/StackerCompiler.h
View File

@ -140,7 +140,7 @@ class StackerCompiler
/// @brief Handle the push of an integer onto the stack. /// @brief Handle the push of an integer onto the stack.
/// @param value The integer value to be pushed. /// @param value The integer value to be pushed.
BasicBlock* handle_integer( const int32_t value ); BasicBlock* handle_integer( const int64_t value );
/// @brief Handle one of the reserved words (given as a token) /// @brief Handle one of the reserved words (given as a token)
BasicBlock* handle_word( int tkn ); BasicBlock* handle_word( int tkn );
@ -169,7 +169,7 @@ class StackerCompiler
/// @brief Generate code to push any value onto the stack. /// @brief Generate code to push any value onto the stack.
Instruction* push_value( BasicBlock* bb, Value* value ); Instruction* push_value( BasicBlock* bb, Value* value );
/// @brief Generate code to push a constant integer onto the stack. /// @brief Generate code to push a constant integer onto the stack.
Instruction* push_integer( BasicBlock* bb, int32_t value ); Instruction* push_integer( BasicBlock* bb, int64_t value );
/// @brief Generate code to pop an integer off the stack. /// @brief Generate code to pop an integer off the stack.
Instruction* pop_integer( BasicBlock* bb ); Instruction* pop_integer( BasicBlock* bb );
/// @brief Generate code to push a string pointer onto the stack. /// @brief Generate code to push a string pointer onto the stack.
@ -211,9 +211,6 @@ class StackerCompiler
ConstantInt* Three; ///< long constant 3 ConstantInt* Three; ///< long constant 3
ConstantInt* Four; ///< long constant 4 ConstantInt* Four; ///< long constant 4
ConstantInt* Five; ///< long constant 5 ConstantInt* Five; ///< long constant 5
ConstantInt* IZero; ///< int constant 0
ConstantInt* IOne; ///< int constant 1
ConstantInt* ITwo; ///< int constant 2
std::vector<Value*> no_arguments; ///< no arguments for Stacker std::vector<Value*> no_arguments; ///< no arguments for Stacker
bool echo; ///< Echo flag bool echo; ///< Echo flag
size_t stack_size; ///< Size of stack to gen. size_t stack_size; ///< Size of stack to gen.

2
llvm/projects/Stacker/lib/compiler/StackerParser.y
View File

@ -39,7 +39,7 @@ int yyparse();
llvm::Module* ModuleVal; llvm::Module* ModuleVal;
llvm::Function* FunctionVal; llvm::Function* FunctionVal;
llvm::BasicBlock* BasicBlockVal; llvm::BasicBlock* BasicBlockVal;
uint32_t IntegerVal; int64_t IntegerVal;
char* StringVal; char* StringVal;
} }

10
llvm/projects/Stacker/lib/runtime/stacker_rt.c
View File

@ -21,18 +21,18 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
extern long long _index_; extern int64_t _index_;
extern int _stack_[]; extern int64_t _stack_[];
extern void _MAIN_(); extern void _MAIN_();
void void
_stacker_dump_stack_() _stacker_dump_stack_()
{ {
int i; int64_t i;
printf("Stack Dump:\n"); printf("Stack Dump:\n");
for (i = _index_; i > 0; i-- ) for (i = _index_; i > 0; i-- )
{ {
printf("#%03d: %d\n", i, _stack_[i] ); printf("#%03lld: %lld\n", i, _stack_[i] );
} }
} }
@ -51,7 +51,7 @@ main ( int argc, char** argv )
{ {
if ( isdigit( (int) argv[--a][0] ) ) if ( isdigit( (int) argv[--a][0] ) )
{ {
_stack_[_index_++] = atoi( argv[a] ); _stack_[_index_++] = atoll( argv[a] );
} }
else else
{ {