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"
/* Conversion of text ints to binary */
static uint64_t IntToVal(const char *Buffer) {
uint64_t Result = 0;
static int64_t IntToVal(const char *Buffer) {
int64_t Result = 0;
for (; *Buffer; Buffer++) {
uint64_t OldRes = Result;
int64_t OldRes = Result;
Result *= 10;
Result += *Buffer-'0';
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 */
static uint64_t HexIntToVal(const char *Buffer) {
uint64_t Result = 0;
static int64_t HexIntToVal(const char *Buffer) {
int64_t Result = 0;
for (; *Buffer; ++Buffer) {
uint64_t OldRes = Result;
int64_t OldRes = Result;
Result *= 16;
char C = *Buffer;
if (C >= '0' && C <= '9')

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

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

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

@ -21,18 +21,18 @@
#include <stdio.h>
#include <stdlib.h>
extern long long _index_;
extern int _stack_[];
extern int64_t _index_;
extern int64_t _stack_[];
extern void _MAIN_();
void
_stacker_dump_stack_()
{
int i;
int64_t i;
printf("Stack Dump:\n");
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] ) )
{
_stack_[_index_++] = atoi( argv[a] );
_stack_[_index_++] = atoll( argv[a] );
}
else
{