void llvm_compiler_compile_all(lua_State *L, Proto *p) {
LLVMCompiler *compiler = llvm_get_compiler(L);
if(compiler == NULL) {
llvm_compiler_main(1);
}
compiler->compileAll(L, p);
}
Object* System::vm_jit_block(STATE, BlockEnvironment* env, Object* show) {
#ifdef ENABLE_LLVM
LLVMState* ls = LLVMState::get(state);
timer::Running timer(ls->time_spent);
VMMethod* vmm = env->vmmethod(state);
LLVMCompiler* jit = new LLVMCompiler();
jit->compile(ls, vmm, true);
if(show->true_p()) {
jit->show_assembly(state);
}
env->set_native_function(jit->function_pointer(state));
#endif
return show;
}
virtual void perform() {
for(;;) { // forever
BackgroundCompileRequest* req = 0;
// Lock, wait, get a request, unlock
{
thread::Mutex::LockGuard guard(mutex_);
if(pause_) {
state = cPaused;
paused_ = true;
pause_condition_.signal();
while(pause_) {
condition_.wait(mutex_);
}
state = cUnknown;
paused_ = false;
}
// If we've been asked to stop, do so now.
if(stop_) return;
while(pending_requests_.size() == 0) {
state = cIdle;
// unlock and wait...
condition_.wait(mutex_);
if(stop_) return;
}
// now locked again, shift a request
req = pending_requests_.front();
pending_requests_.pop_front();
state = cRunning;
}
// mutex now unlock, allowing others to push more requests
//
LLVMCompiler* jit = new LLVMCompiler();
{
timer::Running timer(ls_->time_spent);
jit->compile(ls_, req->vmmethod(), req->is_block());
jit->generate_function(ls_);
}
if(show_machine_code_) {
jit->show_machine_code();
}
// Ok, compiled, generated machine code, now update MachineMethod
// Ok, now we are manipulating managed memory, so make
// sure the GC doesn't run.
ls_->shared().gc_dependent();
req->vmmethod()->set_jitted(jit->llvm_function(),
jit->code_bytes(),
jit->function_pointer());
if(req->is_block()) {
BlockEnvironment* be = req->block_env();
if(!be) {
llvm::outs() << "Fatal error in JIT. Expected a BlockEnvironment.\n";
} else {
be->set_native_function(jit->function_pointer());
}
} else {
MachineMethod* mm = req->machine_method();
if(!mm) {
llvm::outs() << "Fatal error in JIT. Expected a MachineMethod.\n";
} else {
mm->update(req->vmmethod(), jit);
mm->activate();
}
}
int which = ls_->add_jitted_method();
if(ls_->config().jit_show_compiling) {
llvm::outs() << "[[[ JIT finished background compiling "
<< which
<< (req->is_block() ? " (block)" : " (method)")
<< " ]]]\n";
}
delete req;
// We don't depend on the GC here, so let it run independent
// of us.
ls_->shared().gc_independent();
}
}
void llvm_compiler_free(lua_State *L, Proto *p) {
LLVMCompiler *compiler = llvm_get_compiler(L);
if(compiler != NULL) {
compiler->free(L, p);
}
}
