Object* MachineCode::execute_specialized(STATE, CallFrame* previous,
Executable* exec, Module* mod, Arguments& args) {
CompiledCode* code = as<CompiledCode>(exec);
MachineCode* mcode = code->machine_code();
StackVariables* scope = ALLOCA_STACKVARIABLES(mcode->number_of_locals);
// Originally, I tried using msg.module directly, but what happens is if
// super is used, that field is read. If you combine that with the method
// being called recursively, msg.module can change, causing super() to
// look in the wrong place.
//
// Thus, we have to cache the value in the StackVariables.
scope->initialize(args.recv(), args.block(), mod, mcode->number_of_locals);
InterpreterCallFrame* frame = ALLOCA_CALLFRAME(mcode->stack_size);
// If argument handling fails..
if(ArgumentHandler::call(state, mcode, scope, args) == false) {
Exception* exc =
Exception::make_argument_error(state, mcode->total_args, args.total(), args.name());
exc->locations(state, Location::from_call_stack(state, previous));
state->raise_exception(exc);
return NULL;
}
frame->prepare(mcode->stack_size);
frame->previous = previous;
frame->constant_scope_ = 0;
frame->dispatch_data = 0;
frame->compiled_code = code;
frame->flags = 0;
frame->optional_jit_data = 0;
frame->top_scope_ = 0;
frame->scope = scope;
frame->arguments = &args;
GCTokenImpl gct;
#ifdef ENABLE_LLVM
// A negative call_count means we've disabled usage based JIT
// for this method.
if(mcode->call_count >= 0) {
if(mcode->call_count >= state->shared().config.jit_call_til_compile) {
LLVMState* ls = LLVMState::get(state);
OnStack<3> os(state, exec, mod, code);
ls->compile_callframe(state, gct, code, frame);
} else {
mcode->call_count++;
}
}
#endif
OnStack<3> os(state, exec, mod, code);
#ifdef RBX_PROFILER
if(unlikely(state->vm()->tooling())) {
// Check the stack and interrupts here rather than in the interpreter
// loop itself.
if(!state->check_interrupts(gct, frame, frame)) return NULL;
state->checkpoint(gct, frame);
tooling::MethodEntry method(state, exec, mod, args, code);
RUBINIUS_METHOD_ENTRY_HOOK(state, mod, args.name(), previous);
Object* result = (*mcode->run)(state, mcode, frame);
RUBINIUS_METHOD_RETURN_HOOK(state, mod, args.name(), previous);
return result;
} else {
if(!state->check_interrupts(gct, frame, frame)) return NULL;
state->checkpoint(gct, frame);
RUBINIUS_METHOD_ENTRY_HOOK(state, mod, args.name(), previous);
Object* result = (*mcode->run)(state, mcode, frame);
RUBINIUS_METHOD_RETURN_HOOK(state, mod, args.name(), previous);
return result;
}
#else
if(!state->check_interrupts(gct, frame, frame)) return NULL;
state->checkpoint(gct, frame);
RUBINIUS_METHOD_ENTRY_HOOK(state, mod, args.name(), previous);
Object* result = (*mcode->run)(state, mcode, frame);
RUBINIUS_METHOD_RETURN_HOOK(state, mod, args.name(), previous);
return result;
#endif
}
Object* VMMethod::execute_specialized(STATE, CallFrame* previous,
Dispatch& msg, Arguments& args) {
CompiledMethod* cm = as<CompiledMethod>(msg.method);
VMMethod* vmm = cm->backend_method();
#ifdef ENABLE_LLVM
// A negative call_count means we've disabled usage based JIT
// for this method.
if(vmm->call_count >= 0) {
if(vmm->call_count >= state->shared.config.jit_call_til_compile) {
LLVMState* ls = LLVMState::get(state);
ls->compile_callframe(state, cm, previous);
} else {
vmm->call_count++;
}
}
#endif
size_t scope_size = sizeof(StackVariables) +
(vmm->number_of_locals * sizeof(Object*));
StackVariables* scope =
reinterpret_cast<StackVariables*>(alloca(scope_size));
// Originally, I tried using msg.module directly, but what happens is if
// super is used, that field is read. If you combine that with the method
// being called recursively, msg.module can change, causing super() to
// look in the wrong place.
//
// Thus, we have to cache the value in the StackVariables.
scope->initialize(args.recv(), args.block(), msg.module, vmm->number_of_locals);
InterpreterCallFrame* frame = ALLOCA_CALLFRAME(vmm->stack_size);
// If argument handling fails..
if(ArgumentHandler::call(state, vmm, scope, args) == false) {
Exception* exc =
Exception::make_argument_error(state, vmm->required_args, args.total(), msg.name);
exc->locations(state, Location::from_call_stack(state, previous));
state->thread_state()->raise_exception(exc);
return NULL;
}
frame->prepare(vmm->stack_size);
frame->previous = previous;
frame->flags = 0;
frame->arguments = &args;
frame->dispatch_data = &msg;
frame->cm = cm;
frame->scope = scope;
#ifdef RBX_PROFILER
if(unlikely(state->shared.profiling())) {
profiler::MethodEntry method(state, msg, args, cm);
return (*vmm->run)(state, vmm, frame);
} else {
return (*vmm->run)(state, vmm, frame);
}
#else
return (*vmm->run)(state, vmm, frame);
#endif
}