// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool RecursionElimination::IsTailCallWithMoveBefore(CallInstr* callInstr,
ReturnInstr* retInstr,
TailCallInfo& info) {
// Check if all instructions between 'call' and 'ret'
// can be moved before the 'call'. If it's possible
// then we can apply tail-recursion elimination.
for(auto instr = callInstr->NextInstruction();
instr && (instr != retInstr); instr = instr->NextInstruction()) {
if(CanBeMovedBeforeCall(instr, callInstr) == false) {
// Instruction can't be moved, give up.
return false;
}
}
// It's possible to move the instructions, now do it.
auto block = callInstr->ParentBlock();
while(callInstr->NextInstruction() != retInstr) {
auto instr = callInstr->NextInstruction();
callInstr->RemoveFromBlock();
block->InsertInstructionBefore(instr, callInstr);
}
// Make sure we don't have any remaining operands.
info.Additive.Clear();
info.Multiplicative.Clear();
return true;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool RecursionElimination::AnalyzeCalls() {
// Scan all instructions and search for tail-recursive calls.
bool hasTailCall = false;
for(auto block = funct_->FirstBlock(); block; block = block->NextBlock()) {
for(auto instr = block->FirstInstruction(); instr;
instr = instr->NextInstruction()) {
if(auto callInstr = instr->As<CallInstr>()) {
TailCallInfo info;
if(IsTailCall(callInstr, info)) {
// We process it later. Mark the 'ret' instruction as visited.
tailCalls_.Add(info);
processedReturns_.Add(info.TailReturn, true);
hasTailCall = true;
}
}
else if(auto retInstr = instr->As<ReturnInstr>()) {
// Add the 'ret' to the list if it isn't
// part of a tail-call.
if(processedReturns_.ContainsKey(retInstr) == false) {
returnInstrs_.Add(retInstr);
}
}
}
}
return hasTailCall;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void VariableAnalysis::ComputeScalarAddressTaken(Function* function) {
funct_ = function;
for(Block* block = funct_->FirstBlock(); block; block = block->NextBlock()) {
for(auto instr = block->FirstInstruction(); instr;
instr = instr->NextInstruction()) {
MarkAddressTaken(instr);
}
}
}
/*
====================
idInterpreter::LeaveFunction
====================
*/
void idInterpreter::LeaveFunction( idVarDef *returnDef ) {
prstack_t *stack;
varEval_t ret;
if ( callStackDepth <= 0 ) {
Error( "prog stack underflow" );
}
// return value
if ( returnDef ) {
switch( returnDef->Type() ) {
case ev_string :
gameLocal.program.ReturnString( GetString( returnDef ) );
break;
case ev_vector :
ret = GetVariable( returnDef );
gameLocal.program.ReturnVector( *ret.vectorPtr );
break;
default :
ret = GetVariable( returnDef );
gameLocal.program.ReturnInteger( *ret.intPtr );
}
}
// remove locals from the stack
PopParms( currentFunction->locals );
assert( localstackUsed == localstackBase );
if ( debug ) {
statement_t &line = gameLocal.program.GetStatement( instructionPointer );
gameLocal.Printf( "%d: %s(%d): exit %s", gameLocal.time, gameLocal.program.GetFilename( line.file ), line.linenumber, currentFunction->Name() );
if ( callStackDepth > 1 ) {
gameLocal.Printf( " return to %s(line %d)\n", callStack[ callStackDepth - 1 ].f->Name(), gameLocal.program.GetStatement( callStack[ callStackDepth - 1 ].s ).linenumber );
} else {
gameLocal.Printf( " done\n" );
}
}
// up stack
callStackDepth--;
stack = &callStack[ callStackDepth ];
currentFunction = stack->f;
localstackBase = stack->stackbase;
NextInstruction( stack->s );
if ( !callStackDepth ) {
// all done
doneProcessing = true;
threadDying = true;
currentFunction = 0;
}
}
/*
====================
idInterpreter::EnterFunction
Returns the new program statement counter
NOTE: If this is called from within a event called by this interpreter, the function arguments will be invalid after calling this function.
====================
*/
void idInterpreter::EnterFunction( const function_t *func, bool clearStack ) {
int c;
prstack_t *stack;
if( clearStack ) {
Reset();
}
if( popParms ) {
PopParms( popParms );
popParms = 0;
}
if( callStackDepth >= MAX_STACK_DEPTH ) {
Error( "call stack overflow" );
}
stack = &callStack[ callStackDepth ];
stack->s = instructionPointer + 1; // point to the next instruction to execute
stack->f = currentFunction;
stack->stackbase = localstackBase;
callStackDepth++;
if( callStackDepth > maxStackDepth ) {
maxStackDepth = callStackDepth;
}
if( !func ) {
Error( "NULL function" );
}
if( debug ) {
if( currentFunction ) {
gameLocal.Printf( "%d: call '%s' from '%s'(line %d)%s\n", gameLocal.time, func->Name(), currentFunction->Name(),
gameLocal.program.GetStatement( instructionPointer ).linenumber, clearStack ? " clear stack" : "" );
} else {
gameLocal.Printf( "%d: call '%s'%s\n", gameLocal.time, func->Name(), clearStack ? " clear stack" : "" );
}
}
currentFunction = func;
assert( !func->eventdef );
NextInstruction( func->firstStatement );
// allocate space on the stack for locals
// parms are already on stack
c = func->locals - func->parmTotal;
assert( c >= 0 );
if( localstackUsed + c > LOCALSTACK_SIZE ) {
Error( "EnterFuncton: locals stack overflow\n" );
}
// initialize local stack variables to zero
memset( &localstack[ localstackUsed ], 0, c );
localstackUsed += c;
localstackBase = localstackUsed - func->locals;
if( localstackUsed > maxLocalstackUsed ) {
maxLocalstackUsed = localstackUsed ;
}
}
/*
================
idInterpreter::Reset
================
*/
void idInterpreter::Reset( void ) {
callStackDepth = 0;
localstackUsed = 0;
localstackBase = 0;
maxLocalstackUsed = 0;
maxStackDepth = 0;
popParms = 0;
multiFrameEvent = NULL;
eventEntity = NULL;
currentFunction = 0;
NextInstruction( 0 );
threadDying = false;
doneProcessing = true;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void VariableAnalysis::AnayzeAggregateOperations(OperandVariableDict& opDict) {
// We use a reverse-postorder walk that guarantees that we visit
// all predecessors of a block before we visit that block.
CFGInfo<Block, Function> cfgInfo(funct_, false /* edgeInfoNeeded */);
auto& postorderList = cfgInfo.PostorderList();
for(int i = postorderList.Count() - 1; i >= 0; i--) {
auto block = const_cast<Block*>(postorderList[i]);
for(auto instr = block->FirstInstruction(); instr;
instr = instr->NextInstruction()) {
AnalyzeAggregatesInIntruction(instr, opDict);
}
}
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void AggregateCopyPropagation::RemovedDeadCopySetCalls() {
// We count how many times each copy is used in the function.
// All copies that are not used anymore can be removed,
// allowing Dead Code Elimination to do it's job.
List<int> copyCount(infoList_.Count());
for(int i = 0; i < infoList_.Count(); i++) {
copyCount.Add(0);
}
// Scan all instructions in the function.
for(auto block = funct_->FirstBlock(); block; block = block->NextBlock()) {
for(auto instr = block->FirstInstruction(); instr;
instr = instr->NextInstruction()) {
// We check 'store', 'load' and 'call' instructions only,
// because they're the ones that can access the copy.
if(auto loadInstr = instr->As<LoadInstr>()) {
VisitedDict visited;
MarkUsedCopies(loadInstr->SourceOp(),
copyCount, visited);
}
else if(auto storeInstr = instr->As<StoreInstr>()) {
VisitedDict visited1;
MarkUsedCopies(storeInstr->DestinationOp(), copyCount,
visited1, true /* ignoreLocals */);
VisitedDict visited2;
MarkUsedCopies(storeInstr->SourceOp(), copyCount,
visited2, true /* ignoreLocals */);
}
else if(auto callInstr = instr->As<CallInstr>()) {
for(int i = 0; i < callInstr->ArgumentCount(); i++) {
VisitedDict visited;
MarkUsedCopies(callInstr->GetArgument(i),
copyCount, visited);
}
}
}
}
// Remove any copy that is definitely dead.
for(int i = 0; i < copyCount.Count(); i++) {
if((copyCount[i] - infoList_[i].Replacements) < 2) {
infoList_[i].CopySetCall->RemoveFromBlock(true /* free */);
}
}
}
//
// Cineractive::GameTimeSim
//
void Cineractive::GameTimeSim()
{
if (moviePrim)
{
if (moviePrim->done)
{
delete moviePrim;
moviePrim = NULL;
}
else
{
moviePrim->Notify(0x7FEF2C7B); // "CycleTick"
return;
}
}
// Currently elapsed seconds
elapsedCycles = GameTime::GameCycle() - startCycle;
// Any new instructions to instantiate?
while (nextScope && (nextCycle <= elapsedCycles && !moviePrim))
{
ExecBlock(nextScope);
NextInstruction();
}
// Send all primitives a cycle tick message
NList<Prim>::Iterator i(&primitiveList);
Prim *prim;
while ((prim = i++) != NULL)
{
if (prim->done)
{
primitiveList.Dispose(prim);
}
else
{
prim->Notify(0x7FEF2C7B); // "CycleTick"
}
}
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void AddressLowering::Execute(Function* function) {
irGen_ = IRGenerator(function->ParentUnit());
// Process each instruction in the function.
for(auto block = function->FirstBlock(); block; block = block->NextBlock()) {
auto instr = block->FirstInstruction();
while(instr) {
if(auto indexInstr = instr->As<IndexInstr>()) {
instr = LowerIndex(indexInstr);
}
else if(auto addrInstr = instr->As<AddressInstr>()) {
instr = LowerAddress(addrInstr);
}
else if(auto elemInstr = instr->As<ElementInstr>()) {
instr = LowerElement(elemInstr);
}
else instr = instr->NextInstruction();
}
}
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void AggregateCopyPropagation::CollectCopySetFromBlock(Block* block) {
// We scan all instructions in the block and search for calls
// to 'copyMemory' and 'setMemory' that target records or arrays.
// While scanning we also perform local copy propagation.
copySets_.Add(block, BitVector(infoList_.Count() + 4));
killSets_.Add(block, BitVector(infoList_.Count() + 4));
auto& copySet = copySets_[block];
auto& killSet = killSets_[block];
TOperandToIdDict availableCopies;
for(auto instr = block->FirstInstruction(); instr;
instr = instr->NextInstruction()) {
if(auto callInstr = instr->As<CallInstr>()) {
// This might be a call that kills copies.
AddToKillSet(callInstr, killSet, copySet);
// Check if a copy is made by this call.
Operand* destOp;
int id = ExtractCopySetInfo(callInstr, destOp);
if(id != -1) {
// We found a copy/set operation, make it available
// in this block.
SetBit(copySet, id);
auto& info = infoList_[infoList_.Count() - 1];
availableCopies.Add(destOp, id);
}
else ReplaceWithOriginal(callInstr, availableCopies, killSet);
}
else if(auto storeInstr = instr->As<StoreInstr>()) {
// Stores might kill available copies.
AddToKillSet(storeInstr, killSet, copySet);
}
else if(auto loadInstr = instr->As<LoadInstr>()) {
// Try to replace the operands with the original ones.
ReplaceWithOriginal(loadInstr, availableCopies, killSet);
}
}
}
void VariableAnalysis::ComputeAddressTakenAndDefinitions(Function* function) {
DebugValidator::IsNotNull(function);
// We consider that the variable has it's address taken
// if it's used in any instruction that depends on it's address.
// This includes storing the address, passing it as a parameter to a function,
// converting it to an integer or another pointer type, etc.
funct_ = function;
// Initialize the map from block-id to block.
for(auto block = function->FirstBlock(); block; block = block->NextBlock()) {
idToBlock_.Add(block->Id(), block);
}
for(Block* block = funct_->FirstBlock(); block; block = block->NextBlock()) {
for(auto instr = block->FirstInstruction(); instr;
instr = instr->NextInstruction()) {
MarkAddressTaken(instr);
MarkDefinition(instr);
}
}
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void VariableAnalysis::ComputeBlockExposedAndKillSets(Block* block,
BitVector& exposedSet,
BitVector& killSet) {
// Scan all the instructions in the block and look for 'load' and 'store'.
for(auto instr = block->FirstInstruction(); instr;
instr = instr->NextInstruction()) {
if(auto storeInstr = instr->As<StoreInstr>()) {
// A variable can be killed only if it's stored into.
// Note that we don't care about the effects of function calls,
// because in that case the variable is marked as "address taken"
// and it isn't considered for SSA conversion anyway.
if(auto variableRef = storeInstr->DestinationOp()->As<VariableReference>()) {
auto localVar = variableRef->GetVariable();
if(localVar == nullptr) {
continue;
}
killSet.SetBit(localVar->Id());
}
}
else if(auto loadInstr = instr->As<LoadInstr>()) {
// The only way a variable can be "used" is through a 'load' instruction.
// All other kinds of uses will render the variable as being "address taken".
if(auto variableRef = loadInstr->SourceOp()->As<VariableReference>()) {
auto localVar = variableRef->GetVariable();
if(localVar == nullptr) {
continue;
}
// Mark the variable as 'exposed' only if it's not in the 'kill' set.
if(killSet.IsSet(localVar->Id()) == false) {
exposedSet.SetBit(localVar->Id());
}
}
}
}
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void AggregateCopyPropagation::LocalCopyPropagation(Block* block,
TOperandToIdDict& availableCopies) {
BitVector killSet(infoList_.Count());
BitVector copySet(infoList_.Count()); // Unused here.
// Try to use the original operand instead of the copy.
// We need to recompute the 'kill' set, because copies available
// at the block entry might be invalidated by 'store' and 'call'.
for(auto instr = block->FirstInstruction(); instr;
instr = instr->NextInstruction()) {
if(auto callInstr = instr->As<CallInstr>()) {
// This might be a call that kills copies.
AddToKillSet(callInstr, killSet, copySet);
ReplaceWithOriginal(callInstr, availableCopies, killSet);
}
else if(auto storeInstr = instr->As<StoreInstr>()) {
AddToKillSet(storeInstr, killSet, copySet);
}
else if(auto loadInstr = instr->As<LoadInstr>()) {
// Try to replace the operands with the original ones.
ReplaceWithOriginal(loadInstr, availableCopies, killSet);
}
}
}
//
// Cineractive::Cineractive
//
Cineractive::Cineractive(Team *team, FScope *fScope)
: team(team),
done(FALSE),
alphaNear(FALSE),
primitiveList(&Prim::node)
{
moviePrim = NULL;
// Initialise instructions
instructions = fScope;
instructions->InitIterators();
NextInstruction();
// Initialise time counter
startCycle = GameTime::GameCycle();
elapsedCycles = 0;
elapsedReal = 0.0F;
//flags = 0;
bookmarkPtr.Clear();
alphaNearStart = Vid::renderState.status.alphaNear;
Vid::renderState.status.alphaNear = alphaNear;
}
/*
====================
idInterpreter::Execute
====================
*/
bool idInterpreter::Execute( void ) {
varEval_t var_a;
varEval_t var_b;
varEval_t var_c;
varEval_t var;
statement_t *st;
int runaway;
idThread *newThread;
float floatVal;
idScriptObject *obj;
const function_t *func;
if ( threadDying || !currentFunction ) {
return true;
}
if ( multiFrameEvent ) {
// move to previous instruction and call it again
instructionPointer--;
}
runaway = 5000000;
doneProcessing = false;
while( !doneProcessing && !threadDying ) {
instructionPointer++;
if ( !--runaway ) {
Error( "runaway loop error" );
}
// next statement
st = &gameLocal.program.GetStatement( instructionPointer );
switch( st->op ) {
case OP_RETURN:
LeaveFunction( st->a );
break;
case OP_THREAD:
newThread = new idThread( this, st->a->value.functionPtr, st->b->value.argSize );
newThread->Start();
// return the thread number to the script
gameLocal.program.ReturnFloat( newThread->GetThreadNum() );
PopParms( st->b->value.argSize );
break;
case OP_OBJTHREAD:
var_a = GetVariable( st->a );
obj = GetScriptObject( *var_a.entityNumberPtr );
if ( obj ) {
func = obj->GetTypeDef()->GetFunction( st->b->value.virtualFunction );
assert( st->c->value.argSize == func->parmTotal );
newThread = new idThread( this, GetEntity( *var_a.entityNumberPtr ), func, func->parmTotal );
newThread->Start();
// return the thread number to the script
gameLocal.program.ReturnFloat( newThread->GetThreadNum() );
} else {
// return a null thread to the script
gameLocal.program.ReturnFloat( 0.0f );
}
PopParms( st->c->value.argSize );
break;
case OP_CALL:
EnterFunction( st->a->value.functionPtr, false );
break;
case OP_EVENTCALL:
CallEvent( st->a->value.functionPtr, st->b->value.argSize );
break;
case OP_OBJECTCALL:
var_a = GetVariable( st->a );
obj = GetScriptObject( *var_a.entityNumberPtr );
if ( obj ) {
func = obj->GetTypeDef()->GetFunction( st->b->value.virtualFunction );
EnterFunction( func, false );
} else {
// return a 'safe' value
gameLocal.program.ReturnVector( vec3_zero );
gameLocal.program.ReturnString( "" );
PopParms( st->c->value.argSize );
}
break;
case OP_SYSCALL:
CallSysEvent( st->a->value.functionPtr, st->b->value.argSize );
break;
case OP_IFNOT:
var_a = GetVariable( st->a );
if ( *var_a.intPtr == 0 ) {
NextInstruction( instructionPointer + st->b->value.jumpOffset );
}
break;
case OP_IF:
var_a = GetVariable( st->a );
if ( *var_a.intPtr != 0 ) {
NextInstruction( instructionPointer + st->b->value.jumpOffset );
}
break;
case OP_GOTO:
NextInstruction( instructionPointer + st->a->value.jumpOffset );
break;
case OP_ADD_F:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = *var_a.floatPtr + *var_b.floatPtr;
break;
case OP_ADD_V:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.vectorPtr = *var_a.vectorPtr + *var_b.vectorPtr;
break;
case OP_ADD_S:
SetString( st->c, GetString( st->a ) );
AppendString( st->c, GetString( st->b ) );
break;
case OP_ADD_FS:
var_a = GetVariable( st->a );
SetString( st->c, FloatToString( *var_a.floatPtr ) );
AppendString( st->c, GetString( st->b ) );
break;
case OP_ADD_SF:
var_b = GetVariable( st->b );
SetString( st->c, GetString( st->a ) );
AppendString( st->c, FloatToString( *var_b.floatPtr ) );
break;
case OP_ADD_VS:
var_a = GetVariable( st->a );
SetString( st->c, var_a.vectorPtr->ToString() );
AppendString( st->c, GetString( st->b ) );
break;
case OP_ADD_SV:
var_b = GetVariable( st->b );
SetString( st->c, GetString( st->a ) );
AppendString( st->c, var_b.vectorPtr->ToString() );
break;
case OP_SUB_F:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = *var_a.floatPtr - *var_b.floatPtr;
break;
case OP_SUB_V:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.vectorPtr = *var_a.vectorPtr - *var_b.vectorPtr;
break;
case OP_MUL_F:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = *var_a.floatPtr * *var_b.floatPtr;
break;
case OP_MUL_V:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = *var_a.vectorPtr * *var_b.vectorPtr;
break;
case OP_MUL_FV:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.vectorPtr = *var_a.floatPtr * *var_b.vectorPtr;
break;
case OP_MUL_VF:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.vectorPtr = *var_a.vectorPtr * *var_b.floatPtr;
break;
case OP_DIV_F:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
if ( *var_b.floatPtr == 0.0f ) {
Warning( "Divide by zero" );
*var_c.floatPtr = idMath::INFINITY;
} else {
*var_c.floatPtr = *var_a.floatPtr / *var_b.floatPtr;
}
break;
case OP_MOD_F:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable ( st->c );
if ( *var_b.floatPtr == 0.0f ) {
Warning( "Divide by zero" );
*var_c.floatPtr = *var_a.floatPtr;
} else {
*var_c.floatPtr = static_cast<int>( *var_a.floatPtr ) % static_cast<int>( *var_b.floatPtr );
}
break;
case OP_BITAND:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = static_cast<int>( *var_a.floatPtr ) & static_cast<int>( *var_b.floatPtr );
break;
case OP_BITOR:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = static_cast<int>( *var_a.floatPtr ) | static_cast<int>( *var_b.floatPtr );
break;
case OP_GE:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.floatPtr >= *var_b.floatPtr );
break;
case OP_LE:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.floatPtr <= *var_b.floatPtr );
break;
case OP_GT:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.floatPtr > *var_b.floatPtr );
break;
case OP_LT:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.floatPtr < *var_b.floatPtr );
break;
case OP_AND:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.floatPtr != 0.0f ) && ( *var_b.floatPtr != 0.0f );
break;
case OP_AND_BOOLF:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.intPtr != 0 ) && ( *var_b.floatPtr != 0.0f );
break;
case OP_AND_FBOOL:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.floatPtr != 0.0f ) && ( *var_b.intPtr != 0 );
break;
case OP_AND_BOOLBOOL:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.intPtr != 0 ) && ( *var_b.intPtr != 0 );
break;
case OP_OR:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.floatPtr != 0.0f ) || ( *var_b.floatPtr != 0.0f );
break;
case OP_OR_BOOLF:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.intPtr != 0 ) || ( *var_b.floatPtr != 0.0f );
break;
case OP_OR_FBOOL:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.floatPtr != 0.0f ) || ( *var_b.intPtr != 0 );
break;
case OP_OR_BOOLBOOL:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.intPtr != 0 ) || ( *var_b.intPtr != 0 );
break;
case OP_NOT_BOOL:
var_a = GetVariable( st->a );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.intPtr == 0 );
break;
case OP_NOT_F:
var_a = GetVariable( st->a );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.floatPtr == 0.0f );
break;
case OP_NOT_V:
var_a = GetVariable( st->a );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.vectorPtr == vec3_zero );
break;
case OP_NOT_S:
var_c = GetVariable( st->c );
*var_c.floatPtr = ( strlen( GetString( st->a ) ) == 0 );
break;
case OP_NOT_ENT:
var_a = GetVariable( st->a );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( GetEntity( *var_a.entityNumberPtr ) == NULL );
break;
case OP_NEG_F:
var_a = GetVariable( st->a );
var_c = GetVariable( st->c );
*var_c.floatPtr = -*var_a.floatPtr;
break;
case OP_NEG_V:
var_a = GetVariable( st->a );
var_c = GetVariable( st->c );
*var_c.vectorPtr = -*var_a.vectorPtr;
break;
case OP_INT_F:
var_a = GetVariable( st->a );
var_c = GetVariable( st->c );
*var_c.floatPtr = static_cast<int>( *var_a.floatPtr );
break;
case OP_EQ_F:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.floatPtr == *var_b.floatPtr );
break;
case OP_EQ_V:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.vectorPtr == *var_b.vectorPtr );
break;
case OP_EQ_S:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( idStr::Cmp( GetString( st->a ), GetString( st->b ) ) == 0 );
break;
case OP_EQ_E:
case OP_EQ_EO:
case OP_EQ_OE:
case OP_EQ_OO:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.entityNumberPtr == *var_b.entityNumberPtr );
break;
case OP_NE_F:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.floatPtr != *var_b.floatPtr );
break;
case OP_NE_V:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.vectorPtr != *var_b.vectorPtr );
break;
case OP_NE_S:
var_c = GetVariable( st->c );
*var_c.floatPtr = ( idStr::Cmp( GetString( st->a ), GetString( st->b ) ) != 0 );
break;
case OP_NE_E:
case OP_NE_EO:
case OP_NE_OE:
case OP_NE_OO:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.entityNumberPtr != *var_b.entityNumberPtr );
break;
case OP_UADD_F:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
*var_b.floatPtr += *var_a.floatPtr;
break;
case OP_UADD_V:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
*var_b.vectorPtr += *var_a.vectorPtr;
break;
case OP_USUB_F:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
*var_b.floatPtr -= *var_a.floatPtr;
break;
case OP_USUB_V:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
*var_b.vectorPtr -= *var_a.vectorPtr;
break;
case OP_UMUL_F:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
*var_b.floatPtr *= *var_a.floatPtr;
break;
case OP_UMUL_V:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
*var_b.vectorPtr *= *var_a.floatPtr;
break;
case OP_UDIV_F:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
if ( *var_a.floatPtr == 0.0f ) {
Warning( "Divide by zero" );
*var_b.floatPtr = idMath::INFINITY;
} else {
*var_b.floatPtr = *var_b.floatPtr / *var_a.floatPtr;
}
break;
case OP_UDIV_V:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
if ( *var_a.floatPtr == 0.0f ) {
Warning( "Divide by zero" );
var_b.vectorPtr->Set( idMath::INFINITY, idMath::INFINITY, idMath::INFINITY );
} else {
*var_b.vectorPtr = *var_b.vectorPtr / *var_a.floatPtr;
}
break;
case OP_UMOD_F:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
if ( *var_a.floatPtr == 0.0f ) {
Warning( "Divide by zero" );
*var_b.floatPtr = *var_a.floatPtr;
} else {
*var_b.floatPtr = static_cast<int>( *var_b.floatPtr ) % static_cast<int>( *var_a.floatPtr );
}
break;
case OP_UOR_F:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
*var_b.floatPtr = static_cast<int>( *var_b.floatPtr ) | static_cast<int>( *var_a.floatPtr );
break;
case OP_UAND_F:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
*var_b.floatPtr = static_cast<int>( *var_b.floatPtr ) & static_cast<int>( *var_a.floatPtr );
break;
case OP_UINC_F:
var_a = GetVariable( st->a );
( *var_a.floatPtr )++;
break;
case OP_UINCP_F:
var_a = GetVariable( st->a );
obj = GetScriptObject( *var_a.entityNumberPtr );
if ( obj ) {
var.bytePtr = &obj->data[ st->b->value.ptrOffset ];
( *var.floatPtr )++;
}
break;
case OP_UDEC_F:
var_a = GetVariable( st->a );
( *var_a.floatPtr )--;
break;
case OP_UDECP_F:
var_a = GetVariable( st->a );
obj = GetScriptObject( *var_a.entityNumberPtr );
if ( obj ) {
var.bytePtr = &obj->data[ st->b->value.ptrOffset ];
( *var.floatPtr )--;
}
break;
case OP_COMP_F:
var_a = GetVariable( st->a );
var_c = GetVariable( st->c );
*var_c.floatPtr = ~static_cast<int>( *var_a.floatPtr );
break;
case OP_STORE_F:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
*var_b.floatPtr = *var_a.floatPtr;
break;
case OP_STORE_ENT:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
*var_b.entityNumberPtr = *var_a.entityNumberPtr;
break;
case OP_STORE_BOOL:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
*var_b.intPtr = *var_a.intPtr;
break;
case OP_STORE_OBJENT:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
obj = GetScriptObject( *var_a.entityNumberPtr );
if ( !obj ) {
*var_b.entityNumberPtr = 0;
} else if ( !obj->GetTypeDef()->Inherits( st->b->TypeDef() ) ) {
//Warning( "object '%s' cannot be converted to '%s'", obj->GetTypeName(), st->b->TypeDef()->Name() );
*var_b.entityNumberPtr = 0;
} else {
*var_b.entityNumberPtr = *var_a.entityNumberPtr;
}
break;
case OP_STORE_OBJ:
case OP_STORE_ENTOBJ:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
*var_b.entityNumberPtr = *var_a.entityNumberPtr;
break;
case OP_STORE_S:
SetString( st->b, GetString( st->a ) );
break;
case OP_STORE_V:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
*var_b.vectorPtr = *var_a.vectorPtr;
break;
case OP_STORE_FTOS:
var_a = GetVariable( st->a );
SetString( st->b, FloatToString( *var_a.floatPtr ) );
break;
case OP_STORE_BTOS:
var_a = GetVariable( st->a );
SetString( st->b, *var_a.intPtr ? "true" : "false" );
break;
case OP_STORE_VTOS:
var_a = GetVariable( st->a );
SetString( st->b, var_a.vectorPtr->ToString() );
break;
case OP_STORE_FTOBOOL:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
if ( *var_a.floatPtr != 0.0f ) {
*var_b.intPtr = 1;
} else {
*var_b.intPtr = 0;
}
break;
case OP_STORE_BOOLTOF:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
*var_b.floatPtr = static_cast<float>( *var_a.intPtr );
break;
case OP_STOREP_F:
var_b = GetVariable( st->b );
if ( var_b.evalPtr && var_b.evalPtr->floatPtr ) {
var_a = GetVariable( st->a );
*var_b.evalPtr->floatPtr = *var_a.floatPtr;
}
break;
case OP_STOREP_ENT:
var_b = GetVariable( st->b );
if ( var_b.evalPtr && var_b.evalPtr->entityNumberPtr ) {
var_a = GetVariable( st->a );
*var_b.evalPtr->entityNumberPtr = *var_a.entityNumberPtr;
}
break;
case OP_STOREP_FLD:
var_b = GetVariable( st->b );
if ( var_b.evalPtr && var_b.evalPtr->intPtr ) {
var_a = GetVariable( st->a );
*var_b.evalPtr->intPtr = *var_a.intPtr;
}
break;
case OP_STOREP_BOOL:
var_b = GetVariable( st->b );
if ( var_b.evalPtr && var_b.evalPtr->intPtr ) {
var_a = GetVariable( st->a );
*var_b.evalPtr->intPtr = *var_a.intPtr;
}
break;
case OP_STOREP_S:
var_b = GetVariable( st->b );
if ( var_b.evalPtr && var_b.evalPtr->stringPtr ) {
idStr::Copynz( var_b.evalPtr->stringPtr, GetString( st->a ), MAX_STRING_LEN );
}
break;
case OP_STOREP_V:
var_b = GetVariable( st->b );
if ( var_b.evalPtr && var_b.evalPtr->vectorPtr ) {
var_a = GetVariable( st->a );
*var_b.evalPtr->vectorPtr = *var_a.vectorPtr;
}
break;
case OP_STOREP_FTOS:
var_b = GetVariable( st->b );
if ( var_b.evalPtr && var_b.evalPtr->stringPtr ) {
var_a = GetVariable( st->a );
idStr::Copynz( var_b.evalPtr->stringPtr, FloatToString( *var_a.floatPtr ), MAX_STRING_LEN );
}
break;
case OP_STOREP_BTOS:
var_b = GetVariable( st->b );
if ( var_b.evalPtr && var_b.evalPtr->stringPtr ) {
var_a = GetVariable( st->a );
if ( *var_a.floatPtr != 0.0f ) {
idStr::Copynz( var_b.evalPtr->stringPtr, "true", MAX_STRING_LEN );
} else {
idStr::Copynz( var_b.evalPtr->stringPtr, "false", MAX_STRING_LEN );
}
}
break;
case OP_STOREP_VTOS:
var_b = GetVariable( st->b );
if ( var_b.evalPtr && var_b.evalPtr->stringPtr ) {
var_a = GetVariable( st->a );
idStr::Copynz( var_b.evalPtr->stringPtr, var_a.vectorPtr->ToString(), MAX_STRING_LEN );
}
break;
case OP_STOREP_FTOBOOL:
var_b = GetVariable( st->b );
if ( var_b.evalPtr && var_b.evalPtr->intPtr ) {
var_a = GetVariable( st->a );
if ( *var_a.floatPtr != 0.0f ) {
*var_b.evalPtr->intPtr = 1;
} else {
*var_b.evalPtr->intPtr = 0;
}
}
break;
case OP_STOREP_BOOLTOF:
var_b = GetVariable( st->b );
if ( var_b.evalPtr && var_b.evalPtr->floatPtr ) {
var_a = GetVariable( st->a );
*var_b.evalPtr->floatPtr = static_cast<float>( *var_a.intPtr );
}
break;
case OP_STOREP_OBJ:
var_b = GetVariable( st->b );
if ( var_b.evalPtr && var_b.evalPtr->entityNumberPtr ) {
var_a = GetVariable( st->a );
*var_b.evalPtr->entityNumberPtr = *var_a.entityNumberPtr;
}
break;
case OP_STOREP_OBJENT:
var_b = GetVariable( st->b );
if ( var_b.evalPtr && var_b.evalPtr->entityNumberPtr ) {
var_a = GetVariable( st->a );
obj = GetScriptObject( *var_a.entityNumberPtr );
if ( !obj ) {
*var_b.evalPtr->entityNumberPtr = 0;
// st->b points to type_pointer, which is just a temporary that gets its type reassigned, so we store the real type in st->c
// so that we can do a type check during run time since we don't know what type the script object is at compile time because it
// comes from an entity
} else if ( !obj->GetTypeDef()->Inherits( st->c->TypeDef() ) ) {
//Warning( "object '%s' cannot be converted to '%s'", obj->GetTypeName(), st->c->TypeDef()->Name() );
*var_b.evalPtr->entityNumberPtr = 0;
} else {
*var_b.evalPtr->entityNumberPtr = *var_a.entityNumberPtr;
}
}
break;
case OP_ADDRESS:
var_a = GetVariable( st->a );
var_c = GetVariable( st->c );
obj = GetScriptObject( *var_a.entityNumberPtr );
if ( obj ) {
var_c.evalPtr->bytePtr = &obj->data[ st->b->value.ptrOffset ];
} else {
var_c.evalPtr->bytePtr = NULL;
}
break;
case OP_INDIRECT_F:
var_a = GetVariable( st->a );
var_c = GetVariable( st->c );
obj = GetScriptObject( *var_a.entityNumberPtr );
if ( obj ) {
var.bytePtr = &obj->data[ st->b->value.ptrOffset ];
*var_c.floatPtr = *var.floatPtr;
} else {
*var_c.floatPtr = 0.0f;
}
break;
case OP_INDIRECT_ENT:
var_a = GetVariable( st->a );
var_c = GetVariable( st->c );
obj = GetScriptObject( *var_a.entityNumberPtr );
if ( obj ) {
var.bytePtr = &obj->data[ st->b->value.ptrOffset ];
*var_c.entityNumberPtr = *var.entityNumberPtr;
} else {
*var_c.entityNumberPtr = 0;
}
break;
case OP_INDIRECT_BOOL:
var_a = GetVariable( st->a );
var_c = GetVariable( st->c );
obj = GetScriptObject( *var_a.entityNumberPtr );
if ( obj ) {
var.bytePtr = &obj->data[ st->b->value.ptrOffset ];
*var_c.intPtr = *var.intPtr;
} else {
*var_c.intPtr = 0;
}
break;
case OP_INDIRECT_S:
var_a = GetVariable( st->a );
obj = GetScriptObject( *var_a.entityNumberPtr );
if ( obj ) {
var.bytePtr = &obj->data[ st->b->value.ptrOffset ];
SetString( st->c, var.stringPtr );
} else {
SetString( st->c, "" );
}
break;
case OP_INDIRECT_V:
var_a = GetVariable( st->a );
var_c = GetVariable( st->c );
obj = GetScriptObject( *var_a.entityNumberPtr );
if ( obj ) {
var.bytePtr = &obj->data[ st->b->value.ptrOffset ];
*var_c.vectorPtr = *var.vectorPtr;
} else {
var_c.vectorPtr->Zero();
}
break;
case OP_INDIRECT_OBJ:
var_a = GetVariable( st->a );
var_c = GetVariable( st->c );
obj = GetScriptObject( *var_a.entityNumberPtr );
if ( !obj ) {
*var_c.entityNumberPtr = 0;
} else {
var.bytePtr = &obj->data[ st->b->value.ptrOffset ];
*var_c.entityNumberPtr = *var.entityNumberPtr;
}
break;
case OP_PUSH_F:
var_a = GetVariable( st->a );
Push( *var_a.intPtr );
break;
case OP_PUSH_FTOS:
var_a = GetVariable( st->a );
PushString( FloatToString( *var_a.floatPtr ) );
break;
case OP_PUSH_BTOF:
var_a = GetVariable( st->a );
floatVal = *var_a.intPtr;
Push( *reinterpret_cast<int *>( &floatVal ) );
break;
case OP_PUSH_FTOB:
var_a = GetVariable( st->a );
if ( *var_a.floatPtr != 0.0f ) {
Push( 1 );
} else {
Push( 0 );
}
break;
case OP_PUSH_VTOS:
var_a = GetVariable( st->a );
PushString( var_a.vectorPtr->ToString() );
break;
case OP_PUSH_BTOS:
var_a = GetVariable( st->a );
PushString( *var_a.intPtr ? "true" : "false" );
break;
case OP_PUSH_ENT:
var_a = GetVariable( st->a );
Push( *var_a.entityNumberPtr );
break;
case OP_PUSH_S:
PushString( GetString( st->a ) );
break;
case OP_PUSH_V:
var_a = GetVariable( st->a );
Push( *reinterpret_cast<int *>( &var_a.vectorPtr->x ) );
Push( *reinterpret_cast<int *>( &var_a.vectorPtr->y ) );
Push( *reinterpret_cast<int *>( &var_a.vectorPtr->z ) );
break;
case OP_PUSH_OBJ:
var_a = GetVariable( st->a );
Push( *var_a.entityNumberPtr );
break;
case OP_PUSH_OBJENT:
var_a = GetVariable( st->a );
Push( *var_a.entityNumberPtr );
break;
case OP_BREAK:
case OP_CONTINUE:
default:
Error( "Bad opcode %i", st->op );
break;
}
}
return threadDying;
}
bool RARExecuteProgram(RARVirtualMachine *vm, RARProgram *prog)
{
RAROpcode *opcode = prog->opcodes;
uint32_t flags = 0;
uint32_t op1, op2, carry, i;
uint32_t counter = 0;
if (!RARIsProgramTerminated(prog))
return false;
while ((uint32_t)(opcode - prog->opcodes) < prog->length && counter++ < RARRuntimeMaxInstructions) {
switch (opcode->instruction) {
case RARMovInstruction:
SetOperand1(GetOperand2());
NextInstruction();
case RARCmpInstruction:
op1 = GetOperand1();
SetFlagsWithCarry(op1 - GetOperand2(), result > op1);
NextInstruction();
case RARAddInstruction:
op1 = GetOperand1();
if (opcode->bytemode)
SetOperand1AndByteFlagsWithCarry((op1 + GetOperand2()) & 0xFF, result < op1);
else
SetOperand1AndFlagsWithCarry(op1 + GetOperand2(), result < op1);
NextInstruction();
case RARSubInstruction:
op1 = GetOperand1();
#if 0 /* apparently not correctly implemented in the RAR VM */
if (opcode->bytemode)
SetOperand1AndByteFlagsWithCarry((op1 - GetOperand2()) & 0xFF, result > op1);
else
#endif
SetOperand1AndFlagsWithCarry(op1 - GetOperand2(), result > op1);
NextInstruction();
case RARJzInstruction:
if ((flags & ZeroFlag))
Jump(GetOperand1());
NextInstruction();
case RARJnzInstruction:
if (!(flags & ZeroFlag))
Jump(GetOperand1());
NextInstruction();
case RARIncInstruction:
if (opcode->bytemode)
SetOperand1AndFlags((GetOperand1() + 1) & 0xFF);
else
SetOperand1AndFlags(GetOperand1() + 1);
NextInstruction();
case RARDecInstruction:
if (opcode->bytemode)
SetOperand1AndFlags((GetOperand1() - 1) & 0xFF);
else
SetOperand1AndFlags(GetOperand1() - 1);
NextInstruction();
case RARJmpInstruction:
Jump(GetOperand1());
case RARXorInstruction:
SetOperand1AndFlags(GetOperand1() ^ GetOperand2());
NextInstruction();
case RARAndInstruction:
SetOperand1AndFlags(GetOperand1() & GetOperand2());
NextInstruction();
case RAROrInstruction:
SetOperand1AndFlags(GetOperand1() | GetOperand2());
NextInstruction();
case RARTestInstruction:
SetFlags(GetOperand1() & GetOperand2());
NextInstruction();
case RARJsInstruction:
if ((flags & SignFlag))
Jump(GetOperand1());
NextInstruction();
case RARJnsInstruction:
if (!(flags & SignFlag))
Jump(GetOperand1());
NextInstruction();
case RARJbInstruction:
if ((flags & CarryFlag))
Jump(GetOperand1());
NextInstruction();
case RARJbeInstruction:
if ((flags & (CarryFlag | ZeroFlag)))
Jump(GetOperand1());
NextInstruction();
case RARJaInstruction:
if (!(flags & (CarryFlag | ZeroFlag)))
Jump(GetOperand1());
NextInstruction();
case RARJaeInstruction:
if (!(flags & CarryFlag))
Jump(GetOperand1());
NextInstruction();
case RARPushInstruction:
vm->registers[7] -= 4;
RARVirtualMachineWrite32(vm, vm->registers[7], GetOperand1());
NextInstruction();
case RARPopInstruction:
SetOperand1(RARVirtualMachineRead32(vm, vm->registers[7]));
vm->registers[7] += 4;
NextInstruction();
case RARCallInstruction:
vm->registers[7] -= 4;
RARVirtualMachineWrite32(vm, vm->registers[7], (uint32_t)(opcode - prog->opcodes + 1));
Jump(GetOperand1());
case RARRetInstruction:
if (vm->registers[7] >= RARProgramMemorySize)
return true;
i = RARVirtualMachineRead32(vm, vm->registers[7]);
vm->registers[7] += 4;
Jump(i);
case RARNotInstruction:
SetOperand1(~GetOperand1());
NextInstruction();
case RARShlInstruction:
op1 = GetOperand1();
op2 = GetOperand2();
SetOperand1AndFlagsWithCarry(op1 << op2, ((op1 << (op2 - 1)) & 0x80000000) != 0);
NextInstruction();
case RARShrInstruction:
op1 = GetOperand1();
op2 = GetOperand2();
SetOperand1AndFlagsWithCarry(op1 >> op2, ((op1 >> (op2 - 1)) & 1) != 0);
NextInstruction();
case RARSarInstruction:
op1 = GetOperand1();
op2 = GetOperand2();
SetOperand1AndFlagsWithCarry(((int32_t)op1) >> op2, ((op1 >> (op2 - 1)) & 1) != 0);
NextInstruction();
case RARNegInstruction:
SetOperand1AndFlagsWithCarry(-(int32_t)GetOperand1(), result != 0);
NextInstruction();
case RARPushaInstruction:
vm->registers[7] -= 32;
for (i = 0; i < 8; i++)
RARVirtualMachineWrite32(vm, vm->registers[7] + (7 - i) * 4, vm->registers[i]);
NextInstruction();
case RARPopaInstruction:
for (i = 0; i < 8; i++)
vm->registers[i] = RARVirtualMachineRead32(vm, vm->registers[7] + (7 - i) * 4);
vm->registers[7] += 32;
NextInstruction();
case RARPushfInstruction:
vm->registers[7] -= 4;
RARVirtualMachineWrite32(vm, vm->registers[7], flags);
NextInstruction();
case RARPopfInstruction:
flags = RARVirtualMachineRead32(vm, vm->registers[7]);
vm->registers[7] += 4;
NextInstruction();
case RARMovzxInstruction:
SetOperand1(GetOperand2());
NextInstruction();
case RARMovsxInstruction:
SetOperand1(SignExtend(GetOperand2()));
NextInstruction();
case RARXchgInstruction:
op1 = GetOperand1();
op2 = GetOperand2();
SetOperand1(op2);
SetOperand2(op1);
NextInstruction();
case RARMulInstruction:
SetOperand1(GetOperand1() * GetOperand2());
NextInstruction();
case RARDivInstruction:
op2 = GetOperand2();
if (op2 != 0)
SetOperand1(GetOperand1() / op2);
NextInstruction();
case RARAdcInstruction:
op1 = GetOperand1();
carry = (flags & CarryFlag);
if (opcode->bytemode)
SetOperand1AndFlagsWithCarry((op1 + GetOperand2() + carry) & 0xFF, result < op1 || (result == op1 && carry)); /* does not correctly set sign bit */
else
SetOperand1AndFlagsWithCarry(op1 + GetOperand2() + carry, result < op1 || (result == op1 && carry));
NextInstruction();
case RARSbbInstruction:
op1 = GetOperand1();
carry = (flags & CarryFlag);
if (opcode->bytemode)
SetOperand1AndFlagsWithCarry((op1 - GetOperand2() - carry) & 0xFF, result > op1 || (result == op1 && carry)); /* does not correctly set sign bit */
else
SetOperand1AndFlagsWithCarry(op1 - GetOperand2() - carry, result > op1 || (result == op1 && carry));
NextInstruction();
case RARPrintInstruction:
/* TODO: ??? */
NextInstruction();
}
}
return false;
}
void OpcodesTest() {
printf(">>> OpcodesTest \n");
struct State state;
struct CompilationState compilationState;
Mem memory[512];
InitState(&state, memory, sizeof(memory));
InitCompilationState(&compilationState, memory, sizeof(memory));
int opcodeTestOffset = 127;
char* string = "OpcodeTest #1";
long len = strlen(string);
memcpy(memory+opcodeTestOffset, string, len);
int argNum = 0;
PutCall(&compilationState, "MethodEnter");
PutByte(&compilationState, (argNum+1) * sizeof(Short));
NextInstruction(&state);
PutCall(&compilationState, "PushShortToStack");
PutShort(&compilationState, opcodeTestOffset);
NextInstruction(&state);
AssertStackTopShort(&state, opcodeTestOffset);
PutCall(&compilationState, "StoreShort");
PutByte(&compilationState, argNum);
NextInstruction(&state);
PutCall(&compilationState, "LoadByte");
PutByte(&compilationState, argNum);
NextInstruction(&state);
AssertStackTopByte(&state, (Byte)opcodeTestOffset);
PutCall(&compilationState, "StoreByte");
PutByte(&compilationState, argNum);
NextInstruction(&state);
PutCall(&compilationState, "LoadShort");
PutByte(&compilationState, argNum);
NextInstruction(&state);
AssertStackTopShort(&state, opcodeTestOffset);
PutCall(&compilationState, "PushByteToStack");
PutByte(&compilationState, 1);
NextInstruction(&state);
PutCall(&compilationState, "JumpIf");
PutShort(&compilationState, CodeSizeForInstruction("ZeroOpcodeFail") + CodeSizeForInstruction("Jump"));
PutCall(&compilationState, "ZeroOpcodeFail");
PutCall(&compilationState, "Jump");
PutShort(&compilationState, CodeSizeForInstruction("Jump") + CodeSizeForInstruction("ZeroOpcodeFail"));
PutCall(&compilationState, "Jump");
PutShort(&compilationState, -CodeSizeForInstruction("Jump")*2);
PutCall(&compilationState, "ZeroOpcodeFail");
PutCall(&compilationState, "PassToPutS");
NextInstruction(&state);
NextInstruction(&state);
NextInstruction(&state);
AssertStackTopShort(&state, opcodeTestOffset);
NextInstruction(&state);
PutCall(&compilationState, "PushByteToStack");
PutByte(&compilationState, 0);
NextInstruction(&state);
PutCall(&compilationState, "JumpIf");
PutShort(&compilationState, -CodeSizeForInstruction("JumpIf") );
NextInstruction(&state);
PutCall(&compilationState, "PushByteToStack");
PutByte(&compilationState, 2);
NextInstruction(&state);
PutCall(&compilationState, "PushByteToStack");
PutByte(&compilationState, 2);
NextInstruction(&state);
PutCall(&compilationState, "CompareBytes");
NextInstruction(&state);
PutCall(&compilationState, "JumpIf");
PutShort(&compilationState, CodeSizeForInstruction("ZeroOpcodeFail"));
PutCall(&compilationState, "ZeroOpcodeFail");
NextInstruction(&state);
PutCall(&compilationState, "PushShortToStack");
PutShort(&compilationState, 2000);
NextInstruction(&state);
PutCall(&compilationState, "PushShortToStack");
PutShort(&compilationState, 2000);
NextInstruction(&state);
PutCall(&compilationState, "CompareShorts");
NextInstruction(&state);
PutCall(&compilationState, "JumpIf");
PutShort(&compilationState, CodeSizeForInstruction("ZeroOpcodeFail"));
PutCall(&compilationState, "ZeroOpcodeFail");
NextInstruction(&state);
PutCall(&compilationState, "PushShortToStack");
PutShort(&compilationState, 100);
NextInstruction(&state);
PutCall(&compilationState, "StoreByte");
PutByte(&compilationState, 1);
NextInstruction(&state);
PutCall(&compilationState, "LoadShort");
PutByte(&compilationState, 1);
NextInstruction(&state);
PutCall(&compilationState, "Inc");
NextInstruction(&state);
PutCall(&compilationState, "Dec");
NextInstruction(&state);
PutCall(&compilationState, "LoadShort");
PutByte(&compilationState, 1);
NextInstruction(&state);
PutCall(&compilationState, "CompareShorts");
NextInstruction(&state);
PutCall(&compilationState, "JumpIf");
PutShort(&compilationState, CodeSizeForInstruction("ZeroOpcodeFail"));
PutCall(&compilationState, "ZeroOpcodeFail");
NextInstruction(&state);
PutCall(&compilationState, "LoadShort");
PutByte(&compilationState, 1);
NextInstruction(&state);
PutCall(&compilationState, "DupShort");
NextInstruction(&state);
PutCall(&compilationState, "CompareShorts");
NextInstruction(&state);
PutCall(&compilationState, "JumpIf");
PutShort(&compilationState, CodeSizeForInstruction("ZeroOpcodeFail"));
PutCall(&compilationState, "ZeroOpcodeFail");
NextInstruction(&state);
PutCall(&compilationState, "LoadByte");
PutByte(&compilationState, 1);
NextInstruction(&state);
PutCall(&compilationState, "DupByte");
NextInstruction(&state);
PutCall(&compilationState, "CompareBytes");
NextInstruction(&state);
PutCall(&compilationState, "JumpIf");
PutShort(&compilationState, CodeSizeForInstruction("ZeroOpcodeFail"));
PutCall(&compilationState, "ZeroOpcodeFail");
NextInstruction(&state);
PutCall(&compilationState, "LoadShort");
PutByte(&compilationState, 1);
NextInstruction(&state);
PutCall(&compilationState, "DupShort");
NextInstruction(&state);
PutCall(&compilationState, "Add");
NextInstruction(&state);
AssertStackTopShort(&state, 200);
PutCall(&compilationState, "PushShortToStack");
PutShort(&compilationState, -2);
NextInstruction(&state);
AssertStackTopShort(&state, -2);
PutCall(&compilationState, "Mul");
NextInstruction(&state);
AssertStackTopShort(&state, -400);
PutCall(&compilationState, "PushShortToStack");
PutShort(&compilationState, -4);
NextInstruction(&state);
PutCall(&compilationState, "Div");
NextInstruction(&state);
AssertStackTopShort(&state, 100);
PutCall(&compilationState, "PushShortToStack");
PutShort(&compilationState, 99);
NextInstruction(&state);
PutCall(&compilationState, "Sub");
NextInstruction(&state);
AssertStackTopShort(&state, 1);
int methodOffset = 200;
MemPtr mainPC = compilationState.PC;
{
compilationState.PC = compilationState.memory + methodOffset;
PutCall(&compilationState, "MethodEnter");
PutByte(&compilationState, 0);
PutCall(&compilationState, "PushShortToStack");
PutShort(&compilationState, opcodeTestOffset);
PutCall(&compilationState, "PassToPutS");
PutCall(&compilationState, "MethodExit");
}
compilationState.PC = mainPC;
PutCall(&compilationState, "PushShortToStack");
PutShort(&compilationState, methodOffset);
NextInstruction(&state);
PutCall(&compilationState, "CallStackPtr");
NextInstruction(&state);
NextInstruction(&state);
NextInstruction(&state);
NextInstruction(&state);
NextInstruction(&state);
methodOffset = 200;
int argValue = 0x40;
PutCall(&compilationState, "PushByteToStack");
PutByte(&compilationState, argValue);
PutCall(&compilationState, "Call");
PutShort(&compilationState, methodOffset);
mainPC = compilationState.PC;
{
compilationState.PC = compilationState.memory + methodOffset;
PutCall(&compilationState, "MethodEnter");
PutByte(&compilationState, 1*sizeof(Short));
PutCall(&compilationState, "SetupArgsStack");
PutCall(&compilationState, "StoreByte");
PutByte(&compilationState, 0);
PutCall(&compilationState, "SetupFrameStack");
PutCall(&compilationState, "LoadShort");
PutByte(&compilationState, 0);
PutCall(&compilationState, "MethodReturn");
PutByte(&compilationState, sizeof(Short));
}
compilationState.PC = mainPC;
NextInstruction(&state);
NextInstruction(&state);
NextInstruction(&state);
NextInstruction(&state);
AssertStackTopByte(&state, argValue);
NextInstruction(&state);
NextInstruction(&state);
NextInstruction(&state);
AssertStackTopShort(&state, argValue);
NextInstruction(&state);
AssertStackTopShort(&state, argValue);
PutCall(&compilationState, "MethodExit");
NextInstruction(&state);
}
static bool RunVirtualMachineOrGetLabels(RARVirtualMachine *self,
RAROpcode *opcodes,int numopcodes,void ***instructionlabels)
{
static void *labels[2][RARNumberOfInstructions]=
{
[0][RARMovInstruction]=&&MovLabel,[1][RARMovInstruction]=&&MovLabel,
[0][RARCmpInstruction]=&&CmpLabel,[1][RARCmpInstruction]=&&CmpLabel,
[0][RARAddInstruction]=&&AddLabel,[1][RARAddInstruction]=&&AddByteLabel,
[0][RARSubInstruction]=&&SubLabel,[1][RARSubInstruction]=&&SubLabel,
[0][RARJzInstruction]=&&JzLabel,
[0][RARJnzInstruction]=&&JnzLabel,
[0][RARIncInstruction]=&&IncLabel,[1][RARIncInstruction]=&&IncByteLabel,
[0][RARDecInstruction]=&&DecLabel,[1][RARDecInstruction]=&&DecByteLabel,
[0][RARJmpInstruction]=&&JmpLabel,
[0][RARXorInstruction]=&&XorLabel,[1][RARXorInstruction]=&&XorLabel,
[0][RARAndInstruction]=&&AndLabel,[1][RARAndInstruction]=&&AndLabel,
[0][RAROrInstruction]=&&OrLabel,[1][RAROrInstruction]=&&OrLabel,
[0][RARTestInstruction]=&&TestLabel,[1][RARTestInstruction]=&&TestLabel,
[0][RARJsInstruction]=&&JsLabel,
[0][RARJnsInstruction]=&&JnsLabel,
[0][RARJbInstruction]=&&JbLabel,
[0][RARJbeInstruction]=&&JbeLabel,
[0][RARJaInstruction]=&&JaLabel,
[0][RARJaeInstruction]=&&JaeLabel,
[0][RARPushInstruction]=&&PushLabel,
[0][RARPopInstruction]=&&PopLabel,
[0][RARCallInstruction]=&&CallLabel,
[0][RARRetInstruction]=&&RetLabel,
[0][RARNotInstruction]=&&NotLabel,[1][RARNotInstruction]=&&NotLabel,
[0][RARShlInstruction]=&&ShlLabel,[1][RARShlInstruction]=&&ShlLabel,
[0][RARShrInstruction]=&&ShrLabel,[1][RARShrInstruction]=&&ShrLabel,
[0][RARSarInstruction]=&&SarLabel,[1][RARSarInstruction]=&&SarLabel,
[0][RARNegInstruction]=&&NegLabel,[1][RARNegInstruction]=&&NegLabel,
[0][RARPushaInstruction]=&&PushaLabel,
[0][RARPopaInstruction]=&&PopaLabel,
[0][RARPushfInstruction]=&&PushfLabel,
[0][RARPopfInstruction]=&&PopfLabel,
[0][RARMovzxInstruction]=&&MovzxLabel,
[0][RARMovsxInstruction]=&&MovsxLabel,
[0][RARXchgInstruction]=&&XchgLabel,
[0][RARMulInstruction]=&&MulLabel,[1][RARMulInstruction]=&&MulLabel,
[0][RARDivInstruction]=&&DivLabel,[1][RARDivInstruction]=&&DivLabel,
[0][RARAdcInstruction]=&&AdcLabel,[1][RARAdcInstruction]=&&AdcByteLabel,
[0][RARSbbInstruction]=&&SbbLabel,[1][RARSbbInstruction]=&&SbbByteLabel,
[0][RARPrintInstruction]=&&PrintLabel,
};
if(instructionlabels)
{
*instructionlabels=&labels[0][0];
return true;
}
RAROpcode *opcode;
uint32_t flags=self->flags;
Jump(0);
MovLabel:
SetOperand1(GetOperand2());
NextInstruction();
CmpLabel:
{
uint32_t term1=GetOperand1();
SetFlagsWithCarry(term1-GetOperand2(),result>term1);
NextInstruction();
}
AddLabel:
{
uint32_t term1=GetOperand1();
SetOperand1AndFlagsWithCarry(term1+GetOperand2(),result<term1);
NextInstruction();
}
AddByteLabel:
{
uint32_t term1=GetOperand1();
SetOperand1AndByteFlagsWithCarry(term1+GetOperand2()&0xff,result<term1);
NextInstruction();
}
SubLabel:
{
uint32_t term1=GetOperand1();
SetOperand1AndFlagsWithCarry(term1-GetOperand2(),result>term1);
NextInstruction();
}
/* SubByteLabel: // Not correctly implemented in the RAR VM
{
uint32_t term1=GetOperand1();
SetOperandAndByteFlagsWithCarry(term1-GetOperand2()&0xff,result>term1);
NextInstruction();
}*/
JzLabel:
if(flags&ZeroFlag) Jump(GetOperand1());
else NextInstruction();
JnzLabel:
if(!(flags&ZeroFlag)) Jump(GetOperand1());
else NextInstruction();
IncLabel:
SetOperand1AndFlags(GetOperand1()+1);
NextInstruction();
IncByteLabel:
SetOperand1AndFlags(GetOperand1()+1&0xff);
NextInstruction();
DecLabel:
SetOperand1AndFlags(GetOperand1()-1);
NextInstruction();
DecByteLabel:
SetOperand1AndFlags(GetOperand1()-1&0xff);
NextInstruction();
JmpLabel:
Jump(GetOperand1());
XorLabel:
SetOperand1AndFlags(GetOperand1()^GetOperand2());
NextInstruction();
AndLabel:
SetOperand1AndFlags(GetOperand1()&GetOperand2());
NextInstruction();
OrLabel:
SetOperand1AndFlags(GetOperand1()|GetOperand2());
NextInstruction();
TestLabel:
SetFlags(GetOperand1()&GetOperand2());
NextInstruction();
JsLabel:
if(flags&SignFlag) Jump(GetOperand1());
else NextInstruction();
JnsLabel:
if(!(flags&SignFlag)) Jump(GetOperand1());
else NextInstruction();
JbLabel:
if(flags&CarryFlag) Jump(GetOperand1());
else NextInstruction();
JbeLabel:
if(flags&(CarryFlag|ZeroFlag)) Jump(GetOperand1());
else NextInstruction();
JaLabel:
if(!(flags&(CarryFlag|ZeroFlag))) Jump(GetOperand1());
else NextInstruction();
JaeLabel:
if(!(flags&CarryFlag)) Jump(GetOperand1());
else NextInstruction();
PushLabel:
self->registers[7]-=4;
RARVirtualMachineWrite32(self,self->registers[7],GetOperand1());
NextInstruction();
PopLabel:
SetOperand1(RARVirtualMachineRead32(self,self->registers[7]));
self->registers[7]+=4;
NextInstruction();
CallLabel:
self->registers[7]-=4;
RARVirtualMachineWrite32(self,self->registers[7],opcode-opcodes+1);
Jump(GetOperand1());
RetLabel:
{
if(self->registers[7]>=RARProgramMemorySize)
{
self->flags=flags;
return true;
}
uint32_t retaddr=RARVirtualMachineRead32(self,self->registers[7]);
self->registers[7]+=4;
Jump(retaddr);
}
NotLabel:
SetOperand1(~GetOperand1());
NextInstruction();
ShlLabel:
{
uint32_t op1=GetOperand1();
uint32_t op2=GetOperand2();
SetOperand1AndFlagsWithCarry(op1<<op2,((op1<<(op2-1))&0x80000000)!=0);
NextInstruction();
}
ShrLabel:
{
uint32_t op1=GetOperand1();
uint32_t op2=GetOperand2();
SetOperand1AndFlagsWithCarry(op1>>op2,((op1>>(op2-1))&1)!=0);
NextInstruction();
}
SarLabel:
{
uint32_t op1=GetOperand1();
uint32_t op2=GetOperand2();
SetOperand1AndFlagsWithCarry(((int32_t)op1)>>op2,((op1>>(op2-1))&1)!=0);
NextInstruction();
}
NegLabel:
SetOperand1AndFlagsWithCarry(-GetOperand1(),result!=0);
NextInstruction();
PushaLabel:
for(int i=0;i<8;i++) RARVirtualMachineWrite32(self,self->registers[7]-4-i*4,self->registers[i]);
self->registers[7]-=32;
NextInstruction();
PopaLabel:
for(int i=0;i<8;i++) self->registers[i]=RARVirtualMachineRead32(self,self->registers[7]+28-i*4);
NextInstruction();
PushfLabel:
self->registers[7]-=4;
RARVirtualMachineWrite32(self,self->registers[7],flags);
NextInstruction();
PopfLabel:
flags=RARVirtualMachineRead32(self,self->registers[7]);
self->registers[7]+=4;
NextInstruction();
MovzxLabel:
SetOperand1(GetOperand2());
NextInstruction();
MovsxLabel:
SetOperand1(SignExtend(GetOperand2()));
NextInstruction();
XchgLabel:
{
uint32_t op1=GetOperand1();
uint32_t op2=GetOperand2();
SetOperand1(op2);
SetOperand2(op1);
NextInstruction();
}
MulLabel:
SetOperand1(GetOperand1()*GetOperand2());
NextInstruction();
DivLabel:
{
uint32_t denominator=GetOperand2();
if(denominator!=0) SetOperand1(GetOperand1()/denominator);
NextInstruction();
}
AdcLabel:
{
uint32_t term1=GetOperand1();
uint32_t carry=flags&CarryFlag;
SetOperand1AndFlagsWithCarry(term1+GetOperand2()+carry,result<term1 || result==term1 && carry);
NextInstruction();
}
AdcByteLabel:
{
uint32_t term1=GetOperand1();
uint32_t carry=flags&CarryFlag;
SetOperand1AndFlagsWithCarry(term1+GetOperand2()+carry&0xff,result<term1 || result==term1 && carry); // Does not correctly set sign bit.
NextInstruction();
}
SbbLabel:
{
uint32_t term1=GetOperand1();
uint32_t carry=flags&CarryFlag;
SetOperand1AndFlagsWithCarry(term1-GetOperand2()-carry,result>term1 || result==term1 && carry);
NextInstruction();
}
SbbByteLabel:
{
uint32_t term1=GetOperand1();
uint32_t carry=flags&CarryFlag;
SetOperand1AndFlagsWithCarry(term1-GetOperand2()-carry&0xff,result>term1 || result==term1 && carry); // Does not correctly set sign bit.
NextInstruction();
}
PrintLabel:
NextInstruction();
return false;
}
