void MethodBuilder::setup() { std::vector<Type*> ftypes; ftypes.push_back(ls_->ptr_type("VM")); ftypes.push_back(ls_->ptr_type("CallFrame")); ftypes.push_back(ls_->ptr_type("Executable")); ftypes.push_back(ls_->ptr_type("Module")); ftypes.push_back(ls_->ptr_type("Arguments")); FunctionType* ft = FunctionType::get(ls_->ptr_type("Object"), ftypes, false); std::ostringstream ss; ss << std::string("_X_") << ls_->enclosure_name(info_.method()) << "#" << ls_->symbol_debug_str(info_.method()->name()) << "@" << ls_->add_jitted_method(); llvm::Function* func = Function::Create(ft, GlobalValue::ExternalLinkage, ss.str().c_str(), ls_->module()); Function::arg_iterator ai = func->arg_begin(); llvm::Value* vm = ai++; vm->setName("state"); llvm::Value* prev = ai++; prev->setName("previous"); exec = ai++; exec->setName("exec"); module = ai++; module->setName("mod"); llvm::Value* args = ai++; args->setName("args"); BasicBlock* block = BasicBlock::Create(ls_->ctx(), "entry", func); builder_.SetInsertPoint(block); info_.context().set_function(func); info_.set_vm(vm); info_.set_args(args); info_.set_previous(prev); info_.set_entry(block); alloc_frame("method_body"); check_arity(); // check_self_type(); initialize_frame(vmm_->stack_size); nil_stack(vmm_->stack_size, constant(cNil, obj_type)); import_args(); import_args_ = b().GetInsertBlock(); b().CreateBr(body_); b().SetInsertPoint(body_); }
void BlockBuilder::setup() { std::vector<const Type*> ftypes; ftypes.push_back(ls_->ptr_type("VM")); ftypes.push_back(ls_->ptr_type("CallFrame")); ftypes.push_back(ls_->ptr_type("BlockEnvironment")); ftypes.push_back(ls_->ptr_type("Arguments")); ftypes.push_back(ls_->ptr_type("BlockInvocation")); FunctionType* ft = FunctionType::get(ls_->ptr_type("Object"), ftypes, false); std::ostringstream ss; ss << std::string("_X_") << ls_->enclosure_name(info_.method()) << "#" << ls_->symbol_debug_str(info_.method()->name()) << "$block@" << ls_->add_jitted_method(); llvm::Function* func = Function::Create(ft, GlobalValue::ExternalLinkage, ss.str().c_str(), ls_->module()); Function::arg_iterator ai = func->arg_begin(); llvm::Value* vm = ai++; vm->setName("state"); llvm::Value* prev = ai++; prev->setName("previous"); block_env = ai++; block_env->setName("env"); llvm::Value* args = ai++; args->setName("args"); block_inv = ai++; block_inv->setName("invocation"); BasicBlock* block = BasicBlock::Create(ls_->ctx(), "entry", func); b().SetInsertPoint(block); info_.context().set_function(func); info_.set_vm(vm); info_.set_args(args); info_.set_previous(prev); info_.set_entry(block); alloc_frame("block_body"); initialize_frame(vmm_->stack_size); nil_stack(vmm_->stack_size, constant(Qnil, obj_type)); setup_block_scope(); if(ls_->config().version >= 19) { import_args_19_style(); } if(ls_->include_profiling()) { Value* test = b().CreateLoad(ls_->profiling(), "profiling"); BasicBlock* setup_profiling = BasicBlock::Create(ls_->ctx(), "setup_profiling", func); BasicBlock* cont = BasicBlock::Create(ls_->ctx(), "continue", func); b().CreateCondBr(test, setup_profiling, cont); b().SetInsertPoint(setup_profiling); Signature sig(ls_, ls_->VoidTy); sig << "VM"; sig << llvm::PointerType::getUnqual(ls_->Int8Ty); sig << "BlockEnvironment"; sig << "Module"; sig << "CompiledMethod"; Value* call_args[] = { vm, method_entry_, block_env, module_, method }; sig.call("rbx_begin_profiling_block", call_args, 5, "", b()); b().CreateBr(cont); b().SetInsertPoint(cont); } b().CreateBr(body_); b().SetInsertPoint(body_); }
void BlockBuilder::setup() { std::vector<const Type*> ftypes; ftypes.push_back(ls_->ptr_type("VM")); ftypes.push_back(ls_->ptr_type("CallFrame")); ftypes.push_back(ls_->ptr_type("BlockEnvironment")); ftypes.push_back(ls_->ptr_type("Arguments")); ftypes.push_back(ls_->ptr_type("BlockInvocation")); FunctionType* ft = FunctionType::get(ls_->ptr_type("Object"), ftypes, false); std::stringstream ss; ss << std::string("_X_") << ls_->enclosure_name(info_.method()) << "#" << ls_->symbol_cstr(info_.method()->name()) << "$block@" << ls_->add_jitted_method(); func = Function::Create(ft, GlobalValue::ExternalLinkage, ss.str().c_str(), ls_->module()); Function::arg_iterator ai = func->arg_begin(); vm = ai++; vm->setName("state"); prev = ai++; prev->setName("previous"); block_env = ai++; block_env->setName("env"); args = ai++; args->setName("args"); block_inv = ai++; block_inv->setName("invocation"); BasicBlock* block = BasicBlock::Create(ls_->ctx(), "entry", func); b().SetInsertPoint(block); info_.set_function(func); info_.set_vm(vm); info_.set_args(args); info_.set_previous(prev); info_.set_entry(block); BasicBlock* body = BasicBlock::Create(ls_->ctx(), "block_body", func); pass_one(body); info_.set_counter(b().CreateAlloca(ls_->Int32Ty, 0, "counter_alloca")); counter2_ = b().CreateAlloca(ls_->Int32Ty, 0, "counter2"); // The 3 here is because we store {ip, sp, type} per unwind. info_.set_unwind_info(b().CreateAlloca(ls_->Int32Ty, ConstantInt::get(ls_->Int32Ty, rubinius::kMaxUnwindInfos * 3), "unwind_info")); valid_flag = b().CreateAlloca(ls_->Int1Ty, 0, "valid_flag"); Value* cfstk = b().CreateAlloca(obj_type, ConstantInt::get(ls_->Int32Ty, (sizeof(CallFrame) / sizeof(Object*)) + vmm_->stack_size), "cfstk"); call_frame = b().CreateBitCast( cfstk, llvm::PointerType::getUnqual(cf_type), "call_frame"); info_.set_out_args(b().CreateAlloca(ls_->type("Arguments"), 0, "out_args")); if(ls_->include_profiling()) { method_entry_ = b().CreateAlloca(ls_->Int8Ty, ConstantInt::get(ls_->Int32Ty, sizeof(tooling::MethodEntry)), "method_entry"); info_.set_profiling_entry(method_entry_); } info_.set_call_frame(call_frame); stk = b().CreateConstGEP1_32(cfstk, sizeof(CallFrame) / sizeof(Object*), "stack"); info_.set_stack(stk); Value* var_mem = b().CreateAlloca(obj_type, ConstantInt::get(ls_->Int32Ty, (sizeof(StackVariables) / sizeof(Object*)) + vmm_->number_of_locals), "var_mem"); vars = b().CreateBitCast( var_mem, llvm::PointerType::getUnqual(stack_vars_type), "vars"); info_.set_variables(vars); initialize_frame(vmm_->stack_size); nil_stack(vmm_->stack_size, constant(Qnil, obj_type)); setup_block_scope(); if(ls_->config().version >= 19) { import_args_19_style(); } if(ls_->include_profiling()) { Value* test = b().CreateLoad(ls_->profiling(), "profiling"); BasicBlock* setup_profiling = BasicBlock::Create(ls_->ctx(), "setup_profiling", func); BasicBlock* cont = BasicBlock::Create(ls_->ctx(), "continue", func); b().CreateCondBr(test, setup_profiling, cont); b().SetInsertPoint(setup_profiling); Signature sig(ls_, ls_->VoidTy); sig << "VM"; sig << llvm::PointerType::getUnqual(ls_->Int8Ty); sig << "BlockEnvironment"; sig << "Module"; sig << "CompiledMethod"; Value* call_args[] = { vm, method_entry_, block_env, module_, method }; sig.call("rbx_begin_profiling_block", call_args, 5, "", b()); b().CreateBr(cont); b().SetInsertPoint(cont); } b().CreateBr(body); b().SetInsertPoint(body); }
BasicBlock* InlineMethodBuilder::setup_inline(Value* self, Value* blk, std::vector<Value*>& stack_args) { llvm::Value* prev = info_.parent_call_frame(); llvm::Value* args = ConstantExpr::getNullValue(ctx_->ptr_type("Arguments")); BasicBlock* entry = BasicBlock::Create(ctx_->llvm_context(), "inline_entry", info_.function()); b().SetInsertPoint(entry); info_.set_args(args); info_.set_previous(prev); info_.set_entry(entry); BasicBlock* body = BasicBlock::Create(ctx_->llvm_context(), "method_body", info_.function()); pass_one(body); BasicBlock* alloca_block = &info_.function()->getEntryBlock(); Value* cfstk = new AllocaInst(obj_type, ConstantInt::get(ctx_->Int32Ty, (sizeof(CallFrame) / sizeof(Object*)) + machine_code_->stack_size), "cfstk", alloca_block->getTerminator()); call_frame = b().CreateBitCast( cfstk, llvm::PointerType::getUnqual(cf_type), "call_frame"); stk = b().CreateConstGEP1_32(cfstk, sizeof(CallFrame) / sizeof(Object*), "stack"); info_.set_call_frame(call_frame); info_.set_stack(stk); Value* var_mem = new AllocaInst(obj_type, ConstantInt::get(ctx_->Int32Ty, (sizeof(StackVariables) / sizeof(Object*)) + machine_code_->number_of_locals), "var_mem", alloca_block->getTerminator()); vars = b().CreateBitCast( var_mem, llvm::PointerType::getUnqual(stack_vars_type), "vars"); info_.set_variables(vars); Value* rd = constant(runtime_data_, ctx_->ptr_type("jit::RuntimeData")); // Setup the CallFrame // // previous b().CreateStore(prev, get_field(call_frame, offset::CallFrame::previous)); // msg b().CreateStore( b().CreatePointerCast(rd, ctx_->Int8PtrTy), get_field(call_frame, offset::CallFrame::dispatch_data)); // compiled_code method = b().CreateLoad( b().CreateConstGEP2_32(rd, 0, offset::jit_RuntimeData::method, "method_pos"), "compiled_code"); Value* code_gep = get_field(call_frame, offset::CallFrame::compiled_code); b().CreateStore(method, code_gep); // constant_scope Value* constant_scope = b().CreateLoad( b().CreateConstGEP2_32(method, 0, offset::CompiledCode::scope, "constant_scope_pos"), "constant_scope"); Value* constant_scope_gep = get_field(call_frame, offset::CallFrame::constant_scope); b().CreateStore(constant_scope, constant_scope_gep); // flags int flags = CallFrame::cInlineFrame; if(!use_full_scope_) flags |= CallFrame::cClosedScope; b().CreateStore(cint(flags), get_field(call_frame, offset::CallFrame::flags)); // ip b().CreateStore(cint(0), get_field(call_frame, offset::CallFrame::ip)); // scope b().CreateStore(vars, get_field(call_frame, offset::CallFrame::scope)); nil_stack(machine_code_->stack_size, constant(cNil, obj_type)); Value* mod = b().CreateLoad( b().CreateConstGEP2_32(rd, 0, offset::jit_RuntimeData::module, "module_pos"), "module"); setup_inline_scope(self, blk, mod); // We know the right arguments are present, so we just need to put them // in the right place. // // We don't support splat in an inlined method! assert(machine_code_->splat_position < 0); assert(stack_args.size() <= (size_t)machine_code_->total_args); for(size_t i = 0; i < stack_args.size(); i++) { Value* int_pos = cint(i); Value* idx2[] = { cint(0), cint(offset::StackVariables::locals), int_pos }; Value* pos = b().CreateGEP(vars, idx2, "local_pos"); Value* arg_val = stack_args.at(i); LocalInfo* li = info_.get_local(i); li->make_argument(); if(ctx_->llvm_state()->type_optz()) { if(type::KnownType::has_hint(ctx_, arg_val)) { type::KnownType kt = type::KnownType::extract(ctx_, arg_val); li->set_known_type(kt); } } b().CreateStore(arg_val, pos); } b().CreateBr(body); b().SetInsertPoint(body); return entry; }