void interpretert::step()
{
if(PC==function->second.body.instructions.end())
{
if(call_stack.empty())
done=true;
else
{
PC=call_stack.top().return_PC;
function=call_stack.top().return_function;
stack_pointer=call_stack.top().old_stack_pointer;
call_stack.pop();
}
return;
}
next_PC=PC;
next_PC++;
switch(PC->type)
{
case GOTO:
execute_goto();
break;
case ASSUME:
execute_assume();
break;
case ASSERT:
execute_assert();
break;
case OTHER:
execute_other();
break;
case DECL:
execute_decl();
break;
case SKIP:
case LOCATION:
case END_FUNCTION:
break;
case RETURN:
if(call_stack.empty())
throw "RETURN without call";
if(PC->code.operands().size()==1 &&
call_stack.top().return_value_address!=0)
{
std::vector<mp_integer> rhs;
evaluate(PC->code.op0(), rhs);
assign(call_stack.top().return_value_address, rhs);
}
next_PC=function->second.body.instructions.end();
break;
case ASSIGN:
execute_assign();
break;
case FUNCTION_CALL:
execute_function_call();
break;
case START_THREAD:
throw "START_THREAD not yet implemented";
case END_THREAD:
throw "END_THREAD not yet implemented";
break;
case ATOMIC_BEGIN:
throw "ATOMIC_BEGIN not yet implemented";
case ATOMIC_END:
throw "ATOMIC_END not yet implemented";
case DEAD:
throw "DEAD not yet implemented";
default:
throw "encountered instruction with undefined instruction type";
}
PC=next_PC;
}
void simulator_ctt::execute_instruction(
statet &state,
const program_formulat::formula_goto_programt::instructiont &instruction)
{
switch(instruction.type)
{
case GOTO:
assert(false);
// done somewhere else
break;
case ASSUME:
execute_assume(state, instruction);
break;
case ASSERT:
execute_assert(state, instruction);
break;
case ASSIGN:
execute_assign(state, instruction);
break;
case FUNCTION_CALL:
assert(false); // done somewhere else
break;
case OTHER:
assert(false);
break;
case SKIP:
case LOCATION:
case END_FUNCTION:
// do nothing
break;
case START_THREAD:
throw "start_thread is not supported";
break;
case END_THREAD:
assert(false);
break;
case ATOMIC_BEGIN:
state.data_w().in_atomic_section=true;
break;
case ATOMIC_END:
state.data_w().in_atomic_section=false;
break;
case DEAD:
break;
case RETURN:
assert(false); // done somewhere else
break;
default:
std::cerr << instruction.type << std::endl;
assert(false);
}
}
