2011-12-14 15:57:10 -06:00
|
|
|
import syntax::ast;
|
|
|
|
import syntax::ast_util;
|
2011-12-15 13:06:48 -06:00
|
|
|
import lib::llvm::llvm;
|
|
|
|
import llvm::{ValueRef, TypeRef};
|
2011-12-14 15:57:10 -06:00
|
|
|
import trans_common::*;
|
|
|
|
import trans_build::*;
|
|
|
|
import trans::*;
|
2011-12-16 18:07:54 -06:00
|
|
|
import middle::freevars::{get_freevars, freevar_info};
|
2011-12-14 15:57:10 -06:00
|
|
|
import option::{some, none};
|
|
|
|
import back::abi;
|
|
|
|
import syntax::codemap::span;
|
2011-12-15 13:06:48 -06:00
|
|
|
import back::link::{
|
|
|
|
mangle_internal_name_by_path,
|
|
|
|
mangle_internal_name_by_path_and_seq};
|
2011-12-14 15:57:10 -06:00
|
|
|
import trans::{
|
|
|
|
trans_shared_malloc,
|
|
|
|
type_of_inner,
|
|
|
|
size_of,
|
|
|
|
node_id_type,
|
|
|
|
INIT,
|
|
|
|
trans_shared_free,
|
|
|
|
drop_ty,
|
|
|
|
new_sub_block_ctxt,
|
|
|
|
load_if_immediate,
|
|
|
|
dest
|
|
|
|
};
|
|
|
|
|
2011-12-15 13:06:48 -06:00
|
|
|
// ___Good to know (tm)__________________________________________________
|
|
|
|
//
|
|
|
|
// The layout of a closure environment in memory is
|
|
|
|
// roughly as follows:
|
|
|
|
//
|
|
|
|
// struct closure_box {
|
|
|
|
// unsigned ref_count; // only used for sharid environments
|
|
|
|
// struct closure {
|
|
|
|
// type_desc *tydesc; // descriptor for the env type
|
|
|
|
// type_desc *bound_tdescs[]; // bound descriptors
|
|
|
|
// struct {
|
|
|
|
// upvar1_t upvar1;
|
|
|
|
// ...
|
|
|
|
// upvarN_t upvarN;
|
|
|
|
// } bound_data;
|
|
|
|
// };
|
|
|
|
// };
|
|
|
|
//
|
|
|
|
// NB: this is defined in the code in T_closure_ptr and
|
|
|
|
// closure_ty_to_tuple_ty (below).
|
|
|
|
//
|
|
|
|
// Note that the closure carries a type descriptor that describes
|
|
|
|
// itself. Trippy. This is needed because the precise types of the
|
|
|
|
// closed over data are lost in the closure type (`fn(T)->U`), so if
|
|
|
|
// we need to take/drop, we must know what data is in the upvars and
|
|
|
|
// so forth.
|
|
|
|
//
|
|
|
|
// The allocation strategy for this closure depends on the closure
|
|
|
|
// type. For a sendfn, the closure (and the referenced type
|
|
|
|
// descriptors) will be allocated in the exchange heap. For a fn, the
|
|
|
|
// closure is allocated in the task heap and is reference counted.
|
|
|
|
// For a block, the closure is allocated on the stack. Note that in
|
|
|
|
// all cases we allocate space for a ref count just to make our lives
|
|
|
|
// easier when upcasting to block(T)->U, in the shape code, and so
|
|
|
|
// forth.
|
|
|
|
//
|
|
|
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
|
2011-12-14 15:57:10 -06:00
|
|
|
tag environment_value {
|
|
|
|
env_expr(@ast::expr);
|
|
|
|
env_direct(ValueRef, ty::t, bool);
|
|
|
|
}
|
|
|
|
|
2011-12-15 13:06:48 -06:00
|
|
|
// Given a closure ty, emits a corresponding tuple ty
|
|
|
|
fn mk_closure_ty(tcx: ty::ctxt,
|
|
|
|
ck: ty::closure_kind,
|
|
|
|
n_bound_tds: uint,
|
|
|
|
bound_data_ty: ty::t)
|
|
|
|
-> ty::t {
|
|
|
|
let tydesc_ty = alt ck {
|
|
|
|
ty::closure_block. | ty::closure_shared. { ty::mk_type(tcx) }
|
|
|
|
ty::closure_send. { ty::mk_send_type(tcx) }
|
|
|
|
};
|
|
|
|
ret ty::mk_tup(tcx, [
|
|
|
|
tydesc_ty,
|
|
|
|
ty::mk_tup(tcx, vec::init_elt(tydesc_ty, n_bound_tds)),
|
|
|
|
bound_data_ty]);
|
|
|
|
}
|
|
|
|
|
|
|
|
fn shared_opaque_closure_box_ty(tcx: ty::ctxt) -> ty::t {
|
|
|
|
let opaque_closure_ty = ty::mk_opaque_closure(tcx);
|
|
|
|
ret ty::mk_imm_box(tcx, opaque_closure_ty);
|
|
|
|
}
|
|
|
|
|
|
|
|
fn send_opaque_closure_box_ty(tcx: ty::ctxt) -> ty::t {
|
|
|
|
let opaque_closure_ty = ty::mk_opaque_closure(tcx);
|
|
|
|
let tup_ty = ty::mk_tup(tcx, [ty::mk_int(tcx), opaque_closure_ty]);
|
|
|
|
ret ty::mk_uniq(tcx, {ty: tup_ty, mut: ast::imm});
|
|
|
|
}
|
|
|
|
|
|
|
|
type closure_result = {
|
|
|
|
llbox: ValueRef, // llvalue of boxed environment
|
|
|
|
box_ty: ty::t, // type of boxed environment
|
|
|
|
bcx: @block_ctxt // final bcx
|
|
|
|
};
|
|
|
|
|
2011-12-14 15:57:10 -06:00
|
|
|
// Given a block context and a list of tydescs and values to bind
|
|
|
|
// construct a closure out of them. If copying is true, it is a
|
|
|
|
// heap allocated closure that copies the upvars into environment.
|
|
|
|
// Otherwise, it is stack allocated and copies pointers to the upvars.
|
2011-12-15 13:06:48 -06:00
|
|
|
fn store_environment(
|
|
|
|
bcx: @block_ctxt, lltydescs: [ValueRef],
|
|
|
|
bound_values: [environment_value],
|
|
|
|
ck: ty::closure_kind)
|
|
|
|
-> closure_result {
|
2011-12-14 15:57:10 -06:00
|
|
|
|
|
|
|
fn dummy_environment_box(bcx: @block_ctxt, r: result)
|
|
|
|
-> (@block_ctxt, ValueRef, ValueRef) {
|
|
|
|
// Prevent glue from trying to free this.
|
|
|
|
let ccx = bcx_ccx(bcx);
|
|
|
|
let ref_cnt = GEPi(bcx, r.val, [0, abi::box_rc_field_refcnt]);
|
|
|
|
Store(r.bcx, C_int(ccx, 2), ref_cnt);
|
|
|
|
let closure = GEPi(r.bcx, r.val, [0, abi::box_rc_field_body]);
|
|
|
|
(r.bcx, closure, r.val)
|
|
|
|
}
|
|
|
|
|
2011-12-15 13:06:48 -06:00
|
|
|
fn maybe_clone_tydesc(bcx: @block_ctxt,
|
|
|
|
ck: ty::closure_kind,
|
|
|
|
td: ValueRef) -> ValueRef {
|
|
|
|
ret alt ck {
|
|
|
|
ty::closure_block. | ty::closure_shared. {
|
|
|
|
td
|
|
|
|
}
|
|
|
|
ty::closure_send. {
|
|
|
|
Call(bcx, bcx_ccx(bcx).upcalls.create_shared_type_desc, [td])
|
|
|
|
}
|
2011-12-14 15:57:10 -06:00
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2011-12-14 17:41:14 -06:00
|
|
|
//let ccx = bcx_ccx(bcx);
|
2011-12-14 15:57:10 -06:00
|
|
|
let tcx = bcx_tcx(bcx);
|
|
|
|
|
|
|
|
// First, synthesize a tuple type containing the types of all the
|
|
|
|
// bound expressions.
|
|
|
|
// bindings_ty = [bound_ty1, bound_ty2, ...]
|
|
|
|
let bound_tys = [];
|
|
|
|
for bv in bound_values {
|
|
|
|
bound_tys += [alt bv {
|
|
|
|
env_direct(_, t, _) { t }
|
|
|
|
env_expr(e) { ty::expr_ty(tcx, e) }
|
|
|
|
}];
|
|
|
|
}
|
2011-12-15 13:06:48 -06:00
|
|
|
let bound_data_ty = ty::mk_tup(tcx, bound_tys);
|
|
|
|
let closure_ty =
|
|
|
|
mk_closure_ty(tcx, ck, vec::len(lltydescs), bound_data_ty);
|
2011-12-14 15:57:10 -06:00
|
|
|
|
|
|
|
let temp_cleanups = [];
|
|
|
|
|
|
|
|
// Allocate a box that can hold something closure-sized.
|
|
|
|
//
|
|
|
|
// For now, no matter what kind of closure we have, we always allocate
|
|
|
|
// space for a ref cnt in the closure. If the closure is a block or
|
|
|
|
// unique closure, this ref count isn't really used: we initialize it to 2
|
|
|
|
// so that it will never drop to zero. This is a hack and could go away
|
|
|
|
// but then we'd have to modify the code to do the right thing when
|
|
|
|
// casting from a shared closure to a block.
|
2011-12-15 13:06:48 -06:00
|
|
|
let (bcx, closure, box) = alt ck {
|
|
|
|
ty::closure_shared. {
|
2011-12-14 15:57:10 -06:00
|
|
|
let r = trans::trans_malloc_boxed(bcx, closure_ty);
|
|
|
|
add_clean_free(bcx, r.box, false);
|
|
|
|
temp_cleanups += [r.box];
|
|
|
|
(r.bcx, r.body, r.box)
|
|
|
|
}
|
2011-12-15 13:06:48 -06:00
|
|
|
ty::closure_send. {
|
2011-12-14 15:57:10 -06:00
|
|
|
// Dummy up a box in the exchange heap.
|
|
|
|
let tup_ty = ty::mk_tup(tcx, [ty::mk_int(tcx), closure_ty]);
|
|
|
|
let box_ty = ty::mk_uniq(tcx, {ty: tup_ty, mut: ast::imm});
|
|
|
|
check trans_uniq::type_is_unique_box(bcx, box_ty);
|
|
|
|
let r = trans_uniq::alloc_uniq(bcx, box_ty);
|
|
|
|
add_clean_free(bcx, r.val, true);
|
2011-12-15 17:59:33 -06:00
|
|
|
temp_cleanups += [r.val];
|
2011-12-14 15:57:10 -06:00
|
|
|
dummy_environment_box(bcx, r)
|
|
|
|
}
|
2011-12-15 13:06:48 -06:00
|
|
|
ty::closure_block. {
|
2011-12-14 15:57:10 -06:00
|
|
|
// Dummy up a box on the stack,
|
|
|
|
let ty = ty::mk_tup(tcx, [ty::mk_int(tcx), closure_ty]);
|
|
|
|
let r = trans::alloc_ty(bcx, ty);
|
|
|
|
dummy_environment_box(bcx, r)
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
// Store bindings tydesc.
|
2011-12-15 13:06:48 -06:00
|
|
|
alt ck {
|
|
|
|
ty::closure_shared. | ty::closure_send. {
|
2011-12-14 15:57:10 -06:00
|
|
|
let bound_tydesc = GEPi(bcx, closure, [0, abi::closure_elt_tydesc]);
|
|
|
|
let ti = none;
|
2011-12-15 15:20:43 -06:00
|
|
|
|
|
|
|
// NDM I believe this is the correct value,
|
|
|
|
// but using it exposes bugs and limitations
|
|
|
|
// in the shape code. Therefore, I am using
|
|
|
|
// tps_normal, which is what we used before.
|
|
|
|
//
|
|
|
|
// let tps = tps_fn(vec::len(lltydescs));
|
|
|
|
|
|
|
|
let tps = tps_normal;
|
2011-12-15 13:06:48 -06:00
|
|
|
let {result:closure_td, _} =
|
|
|
|
trans::get_tydesc(bcx, closure_ty, true, tps, ti);
|
2011-12-14 15:57:10 -06:00
|
|
|
trans::lazily_emit_tydesc_glue(bcx, abi::tydesc_field_drop_glue, ti);
|
|
|
|
trans::lazily_emit_tydesc_glue(bcx, abi::tydesc_field_free_glue, ti);
|
2011-12-15 13:06:48 -06:00
|
|
|
bcx = closure_td.bcx;
|
|
|
|
let td = maybe_clone_tydesc(bcx, ck, closure_td.val);
|
2011-12-14 15:57:10 -06:00
|
|
|
Store(bcx, td, bound_tydesc);
|
|
|
|
}
|
2011-12-15 13:06:48 -06:00
|
|
|
ty::closure_block. { /* skip this for blocks, not really relevant */ }
|
|
|
|
}
|
|
|
|
|
|
|
|
check type_is_tup_like(bcx, closure_ty);
|
|
|
|
let box_ty = ty::mk_imm_box(bcx_tcx(bcx), closure_ty);
|
|
|
|
|
|
|
|
// If necessary, copy tydescs describing type parameters into the
|
|
|
|
// appropriate slot in the closure.
|
|
|
|
let {bcx:bcx, val:ty_params_slot} =
|
|
|
|
GEP_tup_like_1(bcx, closure_ty, closure,
|
|
|
|
[0, abi::closure_elt_ty_params]);
|
2011-12-16 08:55:42 -06:00
|
|
|
vec::iteri(lltydescs) { |i, td|
|
2011-12-15 13:06:48 -06:00
|
|
|
let ty_param_slot = GEPi(bcx, ty_params_slot, [0, i as int]);
|
|
|
|
let cloned_td = maybe_clone_tydesc(bcx, ck, td);
|
|
|
|
Store(bcx, cloned_td, ty_param_slot);
|
2011-12-14 15:57:10 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
// Copy expr values into boxed bindings.
|
|
|
|
// Silly check
|
2011-12-16 08:55:42 -06:00
|
|
|
vec::iteri(bound_values) { |i, bv|
|
2011-12-15 13:06:48 -06:00
|
|
|
let bound = trans::GEP_tup_like_1(bcx, box_ty, box,
|
2011-12-14 15:57:10 -06:00
|
|
|
[0, abi::box_rc_field_body,
|
|
|
|
abi::closure_elt_bindings,
|
|
|
|
i as int]);
|
|
|
|
bcx = bound.bcx;
|
|
|
|
alt bv {
|
|
|
|
env_expr(e) {
|
|
|
|
bcx = trans::trans_expr_save_in(bcx, e, bound.val);
|
|
|
|
add_clean_temp_mem(bcx, bound.val, bound_tys[i]);
|
|
|
|
temp_cleanups += [bound.val];
|
|
|
|
}
|
|
|
|
env_direct(val, ty, is_mem) {
|
2011-12-15 13:06:48 -06:00
|
|
|
alt ck {
|
|
|
|
ty::closure_shared. | ty::closure_send. {
|
2011-12-14 15:57:10 -06:00
|
|
|
let val1 = is_mem ? load_if_immediate(bcx, val, ty) : val;
|
|
|
|
bcx = trans::copy_val(bcx, INIT, bound.val, val1, ty);
|
|
|
|
}
|
2011-12-15 13:06:48 -06:00
|
|
|
ty::closure_block. {
|
2011-12-14 15:57:10 -06:00
|
|
|
let addr = is_mem ? val : do_spill_noroot(bcx, val);
|
|
|
|
Store(bcx, addr, bound.val);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for cleanup in temp_cleanups { revoke_clean(bcx, cleanup); }
|
|
|
|
|
2011-12-15 13:06:48 -06:00
|
|
|
ret {llbox: box, box_ty: box_ty, bcx: bcx};
|
2011-12-14 15:57:10 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
// Given a context and a list of upvars, build a closure. This just
|
2011-12-15 13:06:48 -06:00
|
|
|
// collects the upvars and packages them up for store_environment.
|
2011-12-14 15:57:10 -06:00
|
|
|
fn build_closure(cx: @block_ctxt,
|
2011-12-16 18:07:54 -06:00
|
|
|
upvars: freevar_info,
|
2011-12-15 13:06:48 -06:00
|
|
|
ck: ty::closure_kind)
|
|
|
|
-> closure_result {
|
2011-12-14 15:57:10 -06:00
|
|
|
// If we need to, package up the iterator body to call
|
|
|
|
let env_vals = [];
|
2011-12-15 13:06:48 -06:00
|
|
|
let tcx = bcx_tcx(cx);
|
2011-12-14 15:57:10 -06:00
|
|
|
// Package up the upvars
|
2011-12-16 18:07:54 -06:00
|
|
|
vec::iter(*upvars) { |upvar|
|
|
|
|
let lv = trans_local_var(cx, upvar.def);
|
|
|
|
let nid = ast_util::def_id_of_def(upvar.def).node;
|
2011-12-15 13:06:48 -06:00
|
|
|
let ty = ty::node_id_to_monotype(tcx, nid);
|
|
|
|
alt ck {
|
|
|
|
ty::closure_block. { ty = ty::mk_mut_ptr(tcx, ty); }
|
|
|
|
ty::closure_send. | ty::closure_shared. {}
|
2011-12-14 15:57:10 -06:00
|
|
|
}
|
|
|
|
env_vals += [env_direct(lv.val, ty, lv.kind == owned)];
|
|
|
|
}
|
2011-12-15 13:06:48 -06:00
|
|
|
ret store_environment(cx, copy cx.fcx.lltydescs, env_vals, ck);
|
2011-12-14 15:57:10 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
// Given an enclosing block context, a new function context, a closure type,
|
|
|
|
// and a list of upvars, generate code to load and populate the environment
|
|
|
|
// with the upvars and type descriptors.
|
2011-12-15 13:06:48 -06:00
|
|
|
fn load_environment(enclosing_cx: @block_ctxt,
|
|
|
|
fcx: @fn_ctxt,
|
|
|
|
boxed_closure_ty: ty::t,
|
2011-12-16 18:07:54 -06:00
|
|
|
upvars: freevar_info,
|
2011-12-15 13:06:48 -06:00
|
|
|
ck: ty::closure_kind) {
|
2011-12-14 15:57:10 -06:00
|
|
|
let bcx = new_raw_block_ctxt(fcx, fcx.llloadenv);
|
|
|
|
|
|
|
|
let ccx = bcx_ccx(bcx);
|
|
|
|
let sp = bcx.sp;
|
2011-12-15 13:06:48 -06:00
|
|
|
check (type_has_static_size(ccx, boxed_closure_ty));
|
|
|
|
let llty = type_of(ccx, sp, boxed_closure_ty);
|
2011-12-14 15:57:10 -06:00
|
|
|
let llclosure = PointerCast(bcx, fcx.llenv, llty);
|
|
|
|
|
|
|
|
// Populate the type parameters from the environment. We need to
|
|
|
|
// do this first because the tydescs are needed to index into
|
|
|
|
// the bindings if they are dynamically sized.
|
|
|
|
let tydesc_count = vec::len(enclosing_cx.fcx.lltydescs);
|
2011-12-15 13:06:48 -06:00
|
|
|
let lltydescs = GEPi(bcx, llclosure,
|
|
|
|
[0, abi::box_rc_field_body,
|
|
|
|
abi::closure_elt_ty_params]);
|
|
|
|
uint::range(0u, tydesc_count) { |i|
|
2011-12-14 15:57:10 -06:00
|
|
|
let lltydescptr = GEPi(bcx, lltydescs, [0, i as int]);
|
|
|
|
fcx.lltydescs += [Load(bcx, lltydescptr)];
|
|
|
|
}
|
|
|
|
|
|
|
|
// Populate the upvars from the environment.
|
|
|
|
let path = [0, abi::box_rc_field_body, abi::closure_elt_bindings];
|
2011-12-16 18:07:54 -06:00
|
|
|
vec::iteri(*upvars) { |i, upvar|
|
2011-12-15 13:06:48 -06:00
|
|
|
check type_is_tup_like(bcx, boxed_closure_ty);
|
|
|
|
let upvarptr =
|
|
|
|
GEP_tup_like(bcx, boxed_closure_ty, llclosure, path + [i as int]);
|
2011-12-14 15:57:10 -06:00
|
|
|
bcx = upvarptr.bcx;
|
|
|
|
let llupvarptr = upvarptr.val;
|
2011-12-15 13:06:48 -06:00
|
|
|
alt ck {
|
|
|
|
ty::closure_block. { llupvarptr = Load(bcx, llupvarptr); }
|
|
|
|
ty::closure_send. | ty::closure_shared. { }
|
2011-12-14 15:57:10 -06:00
|
|
|
}
|
2011-12-16 18:07:54 -06:00
|
|
|
let def_id = ast_util::def_id_of_def(upvar.def);
|
2011-12-14 15:57:10 -06:00
|
|
|
fcx.llupvars.insert(def_id.node, llupvarptr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn trans_expr_fn(bcx: @block_ctxt, f: ast::_fn, sp: span,
|
|
|
|
id: ast::node_id, dest: dest) -> @block_ctxt {
|
|
|
|
if dest == ignore { ret bcx; }
|
|
|
|
let ccx = bcx_ccx(bcx), bcx = bcx;
|
|
|
|
let fty = node_id_type(ccx, id);
|
|
|
|
check returns_non_ty_var(ccx, fty);
|
|
|
|
let llfnty = type_of_fn_from_ty(ccx, sp, fty, 0u);
|
|
|
|
let sub_cx = extend_path(bcx.fcx.lcx, ccx.names.next("anon"));
|
|
|
|
let s = mangle_internal_name_by_path(ccx, sub_cx.path);
|
|
|
|
let llfn = decl_internal_cdecl_fn(ccx.llmod, s, llfnty);
|
2011-12-19 00:36:37 -06:00
|
|
|
register_fn(ccx, sp, sub_cx.path, "anon fn", [], id);
|
2011-12-14 15:57:10 -06:00
|
|
|
|
2011-12-15 13:06:48 -06:00
|
|
|
let trans_closure_env = lambda(ck: ty::closure_kind) -> ValueRef {
|
2011-12-14 15:57:10 -06:00
|
|
|
let upvars = get_freevars(ccx.tcx, id);
|
2011-12-15 13:06:48 -06:00
|
|
|
let {llbox, box_ty, bcx} = build_closure(bcx, upvars, ck);
|
2011-12-14 08:23:11 -06:00
|
|
|
trans_closure(sub_cx, sp, f, llfn, no_self, [], id, {|fcx|
|
2011-12-15 13:06:48 -06:00
|
|
|
load_environment(bcx, fcx, box_ty, upvars, ck);
|
2011-12-14 15:57:10 -06:00
|
|
|
});
|
2011-12-15 13:06:48 -06:00
|
|
|
llbox
|
|
|
|
};
|
|
|
|
|
|
|
|
let closure = alt f.proto {
|
|
|
|
ast::proto_block. { trans_closure_env(ty::closure_block) }
|
|
|
|
ast::proto_shared(_) { trans_closure_env(ty::closure_shared) }
|
|
|
|
ast::proto_send. { trans_closure_env(ty::closure_send) }
|
2011-12-14 15:57:10 -06:00
|
|
|
ast::proto_bare. {
|
2011-12-15 13:06:48 -06:00
|
|
|
let closure = C_null(T_opaque_boxed_closure_ptr(ccx));
|
2011-12-14 08:23:11 -06:00
|
|
|
trans_closure(sub_cx, sp, f, llfn, no_self, [], id, {|_fcx|});
|
2011-12-15 13:06:48 -06:00
|
|
|
closure
|
2011-12-14 15:57:10 -06:00
|
|
|
}
|
|
|
|
};
|
2011-12-15 13:06:48 -06:00
|
|
|
fill_fn_pair(bcx, get_dest_addr(dest), llfn, closure);
|
2011-12-14 15:57:10 -06:00
|
|
|
ret bcx;
|
|
|
|
}
|
|
|
|
|
|
|
|
fn trans_bind(cx: @block_ctxt, f: @ast::expr, args: [option::t<@ast::expr>],
|
|
|
|
id: ast::node_id, dest: dest) -> @block_ctxt {
|
|
|
|
let f_res = trans_callee(cx, f);
|
|
|
|
ret trans_bind_1(cx, ty::expr_ty(bcx_tcx(cx), f), f_res, args,
|
|
|
|
ty::node_id_to_type(bcx_tcx(cx), id), dest);
|
|
|
|
}
|
|
|
|
|
|
|
|
fn trans_bind_1(cx: @block_ctxt, outgoing_fty: ty::t,
|
|
|
|
f_res: lval_maybe_callee,
|
|
|
|
args: [option::t<@ast::expr>], pair_ty: ty::t,
|
|
|
|
dest: dest) -> @block_ctxt {
|
|
|
|
let bound: [@ast::expr] = [];
|
|
|
|
for argopt: option::t<@ast::expr> in args {
|
|
|
|
alt argopt { none. { } some(e) { bound += [e]; } }
|
|
|
|
}
|
|
|
|
let bcx = f_res.bcx;
|
|
|
|
if dest == ignore {
|
|
|
|
for ex in bound { bcx = trans_expr(bcx, ex, ignore); }
|
|
|
|
ret bcx;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Figure out which tydescs we need to pass, if any.
|
|
|
|
let outgoing_fty_real; // the type with typarams still in it
|
|
|
|
let lltydescs: [ValueRef];
|
|
|
|
alt f_res.generic {
|
|
|
|
none. { outgoing_fty_real = outgoing_fty; lltydescs = []; }
|
|
|
|
some(ginfo) {
|
|
|
|
lazily_emit_all_generic_info_tydesc_glues(cx, ginfo);
|
|
|
|
outgoing_fty_real = ginfo.item_type;
|
|
|
|
lltydescs = ginfo.tydescs;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
let ty_param_count = vec::len(lltydescs);
|
|
|
|
if vec::len(bound) == 0u && ty_param_count == 0u {
|
|
|
|
// Trivial 'binding': just return the closure
|
|
|
|
let lv = lval_maybe_callee_to_lval(f_res, pair_ty);
|
|
|
|
bcx = lv.bcx;
|
|
|
|
ret memmove_ty(bcx, get_dest_addr(dest), lv.val, pair_ty);
|
|
|
|
}
|
|
|
|
let closure = alt f_res.env {
|
|
|
|
null_env. { none }
|
|
|
|
_ { let (_, cl) = maybe_add_env(cx, f_res); some(cl) }
|
|
|
|
};
|
|
|
|
|
|
|
|
// FIXME: should follow from a precondition on trans_bind_1
|
|
|
|
let ccx = bcx_ccx(cx);
|
|
|
|
check (type_has_static_size(ccx, outgoing_fty));
|
|
|
|
|
|
|
|
// Arrange for the bound function to live in the first binding spot
|
|
|
|
// if the function is not statically known.
|
|
|
|
let (env_vals, target_res) = alt closure {
|
|
|
|
some(cl) {
|
|
|
|
// Cast the function we are binding to be the type that the
|
|
|
|
// closure will expect it to have. The type the closure knows
|
|
|
|
// about has the type parameters substituted with the real types.
|
|
|
|
let sp = cx.sp;
|
|
|
|
let llclosurety = T_ptr(type_of(ccx, sp, outgoing_fty));
|
|
|
|
let src_loc = PointerCast(bcx, cl, llclosurety);
|
|
|
|
([env_direct(src_loc, pair_ty, true)], none)
|
|
|
|
}
|
|
|
|
none. { ([], some(f_res.val)) }
|
|
|
|
};
|
|
|
|
|
|
|
|
// Actually construct the closure
|
2011-12-15 13:06:48 -06:00
|
|
|
let {llbox, box_ty, bcx} = store_environment(
|
|
|
|
bcx, lltydescs,
|
2011-12-16 08:27:50 -06:00
|
|
|
env_vals + vec::map(bound, {|x| env_expr(x)}),
|
2011-12-15 13:06:48 -06:00
|
|
|
ty::closure_shared);
|
2011-12-14 15:57:10 -06:00
|
|
|
|
|
|
|
// Make thunk
|
|
|
|
let llthunk =
|
|
|
|
trans_bind_thunk(cx.fcx.lcx, cx.sp, pair_ty, outgoing_fty_real, args,
|
2011-12-15 13:06:48 -06:00
|
|
|
box_ty, ty_param_count, target_res);
|
2011-12-14 15:57:10 -06:00
|
|
|
|
|
|
|
// Fill the function pair
|
2011-12-15 13:06:48 -06:00
|
|
|
fill_fn_pair(bcx, get_dest_addr(dest), llthunk.val, llbox);
|
2011-12-14 15:57:10 -06:00
|
|
|
ret bcx;
|
|
|
|
}
|
|
|
|
|
2011-12-15 13:06:48 -06:00
|
|
|
fn make_fn_glue(
|
|
|
|
cx: @block_ctxt,
|
|
|
|
v: ValueRef,
|
|
|
|
t: ty::t,
|
|
|
|
glue_fn: fn(@block_ctxt, v: ValueRef, t: ty::t) -> @block_ctxt)
|
|
|
|
-> @block_ctxt {
|
|
|
|
let bcx = cx;
|
|
|
|
let tcx = bcx_tcx(cx);
|
|
|
|
|
|
|
|
let fn_env = lambda(blk: block(@block_ctxt, ValueRef) -> @block_ctxt)
|
|
|
|
-> @block_ctxt {
|
|
|
|
let box_cell_v = GEPi(cx, v, [0, abi::fn_field_box]);
|
|
|
|
let box_ptr_v = Load(cx, box_cell_v);
|
|
|
|
let inner_cx = new_sub_block_ctxt(cx, "iter box");
|
|
|
|
let next_cx = new_sub_block_ctxt(cx, "next");
|
|
|
|
let null_test = IsNull(cx, box_ptr_v);
|
|
|
|
CondBr(cx, null_test, next_cx.llbb, inner_cx.llbb);
|
|
|
|
inner_cx = blk(inner_cx, box_cell_v);
|
|
|
|
Br(inner_cx, next_cx.llbb);
|
|
|
|
ret next_cx;
|
|
|
|
};
|
|
|
|
|
|
|
|
ret alt ty::struct(tcx, t) {
|
|
|
|
ty::ty_native_fn(_, _) | ty::ty_fn(ast::proto_bare., _, _, _, _) {
|
|
|
|
bcx
|
|
|
|
}
|
|
|
|
ty::ty_fn(ast::proto_block., _, _, _, _) {
|
|
|
|
bcx
|
|
|
|
}
|
|
|
|
ty::ty_fn(ast::proto_send., _, _, _, _) {
|
|
|
|
fn_env({ |bcx, box_cell_v|
|
|
|
|
let box_ty = trans_closure::send_opaque_closure_box_ty(tcx);
|
|
|
|
glue_fn(bcx, box_cell_v, box_ty)
|
|
|
|
})
|
|
|
|
}
|
|
|
|
ty::ty_fn(ast::proto_shared(_), _, _, _, _) {
|
|
|
|
fn_env({ |bcx, box_cell_v|
|
|
|
|
let box_ty = trans_closure::shared_opaque_closure_box_ty(tcx);
|
|
|
|
glue_fn(bcx, box_cell_v, box_ty)
|
|
|
|
})
|
|
|
|
}
|
|
|
|
_ { fail "make_fn_glue invoked on non-function type" }
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
fn call_opaque_closure_glue(bcx: @block_ctxt,
|
|
|
|
v: ValueRef, // ptr to an opaque closure
|
|
|
|
field: int) -> @block_ctxt {
|
|
|
|
let ccx = bcx_ccx(bcx);
|
|
|
|
let v = PointerCast(bcx, v, T_ptr(T_opaque_closure(ccx)));
|
|
|
|
let tydescptr = GEPi(bcx, v, [0, abi::closure_elt_tydesc]);
|
|
|
|
let tydesc = Load(bcx, tydescptr);
|
|
|
|
let ti = none;
|
|
|
|
call_tydesc_glue_full(bcx, v, tydesc, field, ti);
|
|
|
|
ret bcx;
|
|
|
|
}
|
|
|
|
|
|
|
|
// pth is cx.path
|
|
|
|
fn trans_bind_thunk(cx: @local_ctxt,
|
|
|
|
sp: span,
|
|
|
|
incoming_fty: ty::t,
|
|
|
|
outgoing_fty: ty::t,
|
|
|
|
args: [option::t<@ast::expr>],
|
|
|
|
boxed_closure_ty: ty::t,
|
|
|
|
ty_param_count: uint,
|
|
|
|
target_fn: option::t<ValueRef>)
|
|
|
|
-> {val: ValueRef, ty: TypeRef} {
|
|
|
|
// If we supported constraints on record fields, we could make the
|
|
|
|
// constraints for this function:
|
|
|
|
/*
|
|
|
|
: returns_non_ty_var(ccx, outgoing_fty),
|
|
|
|
type_has_static_size(ccx, incoming_fty) ->
|
|
|
|
*/
|
|
|
|
// but since we don't, we have to do the checks at the beginning.
|
|
|
|
let ccx = cx.ccx;
|
|
|
|
check type_has_static_size(ccx, incoming_fty);
|
|
|
|
|
|
|
|
// Here we're not necessarily constructing a thunk in the sense of
|
|
|
|
// "function with no arguments". The result of compiling 'bind f(foo,
|
|
|
|
// bar, baz)' would be a thunk that, when called, applies f to those
|
|
|
|
// arguments and returns the result. But we're stretching the meaning of
|
|
|
|
// the word "thunk" here to also mean the result of compiling, say, 'bind
|
|
|
|
// f(foo, _, baz)', or any other bind expression that binds f and leaves
|
|
|
|
// some (or all) of the arguments unbound.
|
|
|
|
|
|
|
|
// Here, 'incoming_fty' is the type of the entire bind expression, while
|
|
|
|
// 'outgoing_fty' is the type of the function that is having some of its
|
|
|
|
// arguments bound. If f is a function that takes three arguments of type
|
|
|
|
// int and returns int, and we're translating, say, 'bind f(3, _, 5)',
|
|
|
|
// then outgoing_fty is the type of f, which is (int, int, int) -> int,
|
|
|
|
// and incoming_fty is the type of 'bind f(3, _, 5)', which is int -> int.
|
|
|
|
|
|
|
|
// Once translated, the entire bind expression will be the call f(foo,
|
|
|
|
// bar, baz) wrapped in a (so-called) thunk that takes 'bar' as its
|
|
|
|
// argument and that has bindings of 'foo' to 3 and 'baz' to 5 and a
|
|
|
|
// pointer to 'f' all saved in its environment. So, our job is to
|
|
|
|
// construct and return that thunk.
|
|
|
|
|
|
|
|
// Give the thunk a name, type, and value.
|
|
|
|
let s: str = mangle_internal_name_by_path_and_seq(ccx, cx.path, "thunk");
|
|
|
|
let llthunk_ty: TypeRef = get_pair_fn_ty(type_of(ccx, sp, incoming_fty));
|
|
|
|
let llthunk: ValueRef = decl_internal_cdecl_fn(ccx.llmod, s, llthunk_ty);
|
|
|
|
|
|
|
|
// Create a new function context and block context for the thunk, and hold
|
|
|
|
// onto a pointer to the first block in the function for later use.
|
|
|
|
let fcx = new_fn_ctxt(cx, sp, llthunk);
|
|
|
|
let bcx = new_top_block_ctxt(fcx);
|
|
|
|
let lltop = bcx.llbb;
|
|
|
|
// Since we might need to construct derived tydescs that depend on
|
|
|
|
// our bound tydescs, we need to load tydescs out of the environment
|
|
|
|
// before derived tydescs are constructed. To do this, we load them
|
|
|
|
// in the load_env block.
|
|
|
|
let load_env_bcx = new_raw_block_ctxt(fcx, fcx.llloadenv);
|
|
|
|
|
|
|
|
// The 'llenv' that will arrive in the thunk we're creating is an
|
|
|
|
// environment that will contain the values of its arguments and a pointer
|
|
|
|
// to the original function. So, let's create one of those:
|
|
|
|
|
|
|
|
// The llenv pointer needs to be the correct size. That size is
|
|
|
|
// 'boxed_closure_ty', which was determined by trans_bind.
|
|
|
|
check (type_has_static_size(ccx, boxed_closure_ty));
|
|
|
|
let llclosure_ptr_ty = type_of(ccx, sp, boxed_closure_ty);
|
|
|
|
let llclosure = PointerCast(load_env_bcx, fcx.llenv, llclosure_ptr_ty);
|
|
|
|
|
|
|
|
// "target", in this context, means the function that's having some of its
|
|
|
|
// arguments bound and that will be called inside the thunk we're
|
|
|
|
// creating. (In our running example, target is the function f.) Pick
|
|
|
|
// out the pointer to the target function from the environment. The
|
|
|
|
// target function lives in the first binding spot.
|
|
|
|
let (lltargetfn, lltargetenv, starting_idx) = alt target_fn {
|
|
|
|
some(fptr) {
|
|
|
|
(fptr, llvm::LLVMGetUndef(T_opaque_boxed_closure_ptr(ccx)), 0)
|
|
|
|
}
|
|
|
|
none. {
|
|
|
|
// Silly check
|
|
|
|
check type_is_tup_like(bcx, boxed_closure_ty);
|
|
|
|
let {bcx: cx, val: pair} =
|
|
|
|
GEP_tup_like(bcx, boxed_closure_ty, llclosure,
|
|
|
|
[0, abi::box_rc_field_body,
|
|
|
|
abi::closure_elt_bindings, 0]);
|
|
|
|
let lltargetenv =
|
|
|
|
Load(cx, GEPi(cx, pair, [0, abi::fn_field_box]));
|
|
|
|
let lltargetfn = Load
|
|
|
|
(cx, GEPi(cx, pair, [0, abi::fn_field_code]));
|
|
|
|
bcx = cx;
|
|
|
|
(lltargetfn, lltargetenv, 1)
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
// And then, pick out the target function's own environment. That's what
|
|
|
|
// we'll use as the environment the thunk gets.
|
|
|
|
|
|
|
|
// Get f's return type, which will also be the return type of the entire
|
|
|
|
// bind expression.
|
|
|
|
let outgoing_ret_ty = ty::ty_fn_ret(cx.ccx.tcx, outgoing_fty);
|
|
|
|
|
|
|
|
// Get the types of the arguments to f.
|
|
|
|
let outgoing_args = ty::ty_fn_args(cx.ccx.tcx, outgoing_fty);
|
|
|
|
|
|
|
|
// The 'llretptr' that will arrive in the thunk we're creating also needs
|
|
|
|
// to be the correct type. Cast it to f's return type, if necessary.
|
|
|
|
let llretptr = fcx.llretptr;
|
|
|
|
let ccx = cx.ccx;
|
|
|
|
if ty::type_contains_params(ccx.tcx, outgoing_ret_ty) {
|
|
|
|
check non_ty_var(ccx, outgoing_ret_ty);
|
|
|
|
let llretty = type_of_inner(ccx, sp, outgoing_ret_ty);
|
|
|
|
llretptr = PointerCast(bcx, llretptr, T_ptr(llretty));
|
|
|
|
}
|
|
|
|
|
|
|
|
// Set up the three implicit arguments to the thunk.
|
|
|
|
let llargs: [ValueRef] = [llretptr, lltargetenv];
|
|
|
|
|
|
|
|
// Copy in the type parameters.
|
|
|
|
let i: uint = 0u;
|
|
|
|
while i < ty_param_count {
|
|
|
|
// Silly check
|
|
|
|
check type_is_tup_like(load_env_bcx, boxed_closure_ty);
|
|
|
|
let lltyparam_ptr =
|
|
|
|
GEP_tup_like(load_env_bcx, boxed_closure_ty, llclosure,
|
|
|
|
[0, abi::box_rc_field_body,
|
|
|
|
abi::closure_elt_ty_params, i as int]);
|
|
|
|
load_env_bcx = lltyparam_ptr.bcx;
|
|
|
|
let td = Load(load_env_bcx, lltyparam_ptr.val);
|
|
|
|
llargs += [td];
|
|
|
|
fcx.lltydescs += [td];
|
|
|
|
i += 1u;
|
|
|
|
}
|
|
|
|
|
|
|
|
let a: uint = 2u; // retptr, env come first
|
|
|
|
let b: int = starting_idx;
|
|
|
|
let outgoing_arg_index: uint = 0u;
|
|
|
|
let llout_arg_tys: [TypeRef] =
|
|
|
|
type_of_explicit_args(cx.ccx, sp, outgoing_args);
|
|
|
|
for arg: option::t<@ast::expr> in args {
|
|
|
|
let out_arg = outgoing_args[outgoing_arg_index];
|
|
|
|
let llout_arg_ty = llout_arg_tys[outgoing_arg_index];
|
|
|
|
alt arg {
|
|
|
|
// Arg provided at binding time; thunk copies it from
|
|
|
|
// closure.
|
|
|
|
some(e) {
|
|
|
|
// Silly check
|
|
|
|
check type_is_tup_like(bcx, boxed_closure_ty);
|
|
|
|
let bound_arg =
|
|
|
|
GEP_tup_like(bcx, boxed_closure_ty, llclosure,
|
|
|
|
[0, abi::box_rc_field_body,
|
|
|
|
abi::closure_elt_bindings, b]);
|
|
|
|
bcx = bound_arg.bcx;
|
|
|
|
let val = bound_arg.val;
|
|
|
|
if out_arg.mode == ast::by_val { val = Load(bcx, val); }
|
|
|
|
if out_arg.mode == ast::by_copy {
|
|
|
|
let {bcx: cx, val: alloc} = alloc_ty(bcx, out_arg.ty);
|
|
|
|
bcx = memmove_ty(cx, alloc, val, out_arg.ty);
|
|
|
|
bcx = take_ty(bcx, alloc, out_arg.ty);
|
|
|
|
val = alloc;
|
|
|
|
}
|
|
|
|
// If the type is parameterized, then we need to cast the
|
|
|
|
// type we actually have to the parameterized out type.
|
|
|
|
if ty::type_contains_params(cx.ccx.tcx, out_arg.ty) {
|
|
|
|
val = PointerCast(bcx, val, llout_arg_ty);
|
|
|
|
}
|
|
|
|
llargs += [val];
|
|
|
|
b += 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Arg will be provided when the thunk is invoked.
|
|
|
|
none. {
|
|
|
|
let arg: ValueRef = llvm::LLVMGetParam(llthunk, a);
|
|
|
|
if ty::type_contains_params(cx.ccx.tcx, out_arg.ty) {
|
|
|
|
arg = PointerCast(bcx, arg, llout_arg_ty);
|
|
|
|
}
|
|
|
|
llargs += [arg];
|
|
|
|
a += 1u;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
outgoing_arg_index += 1u;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Cast the outgoing function to the appropriate type.
|
|
|
|
// This is necessary because the type of the function that we have
|
|
|
|
// in the closure does not know how many type descriptors the function
|
|
|
|
// needs to take.
|
|
|
|
let ccx = bcx_ccx(bcx);
|
|
|
|
|
|
|
|
check returns_non_ty_var(ccx, outgoing_fty);
|
|
|
|
let lltargetty =
|
|
|
|
type_of_fn_from_ty(ccx, sp, outgoing_fty, ty_param_count);
|
|
|
|
lltargetfn = PointerCast(bcx, lltargetfn, T_ptr(lltargetty));
|
|
|
|
Call(bcx, lltargetfn, llargs);
|
|
|
|
build_return(bcx);
|
|
|
|
finish_fn(fcx, lltop);
|
|
|
|
ret {val: llthunk, ty: llthunk_ty};
|
|
|
|
}
|
|
|
|
|