user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

refactor trans into trans_closure; restore original closure repr

Browse source
This commit is contained in:
Niko Matsakis 2011-12-14 13:57:10 -08:00
parent 5a5f33c779
commit 6cdb69cccb
5 changed files with 442 additions and 415 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/comp/back/abi.rs
View file

@ -74,8 +74,8 @@ const fn_field_box: int = 1;
const closure_elt_tydesc: int = 0;
const closure_elt_bindings: int = 1;
const closure_elt_n_ty_params: int = 2;
const closure_elt_ty_params: int = 3;
//const closure_elt_n_ty_params: int = 2;
const closure_elt_ty_params: int = 2; // 3;
const vec_elt_fill: int = 0;

424
src/comp/middle/trans.rs
View file

@ -1297,7 +1297,7 @@ fn make_take_glue(cx: @block_ctxt, v: ValueRef, t: ty::t) {
fn take_fn_env(cx: @block_ctxt,
v: ValueRef,
blk: block(@block_ctxt, ValueRef) -> @block_ctxt)
blk: block(@block_ctxt, ValueRef, 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);
@ -1305,7 +1305,7 @@ fn make_take_glue(cx: @block_ctxt, v: ValueRef, t: ty::t) {
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_ptr_v);
inner_cx = blk(inner_cx, box_cell_v, box_ptr_v);
Br(inner_cx, next_cx.llbb);
ret next_cx;
}
@ -1336,7 +1336,7 @@ fn make_take_glue(cx: @block_ctxt, v: ValueRef, t: ty::t) {
bcx
}
ty::ty_fn(ast::proto_send., _, _, _, _) {
take_fn_env(bcx, v, { |bcx, box_ptr_v|
take_fn_env(bcx, v, { |bcx, _box_cell_v, box_ptr_v|
// Here, box_ptr_v is a unique pointer which
// must be cloned.
call_bound_data_glue_for_closure(
@ -1345,7 +1345,7 @@ fn make_take_glue(cx: @block_ctxt, v: ValueRef, t: ty::t) {
})
}
ty::ty_native_fn(_, _) | ty::ty_fn(ast::proto_shared(_), _, _, _, _) {
take_fn_env(bcx, v, { |bcx, box_ptr_v|
take_fn_env(bcx, v, { |bcx, _box_cell_v, box_ptr_v|
incr_refcnt_of_boxed(bcx, box_ptr_v)
})
}
@ -2232,42 +2232,6 @@ fn trans_unary(bcx: @block_ctxt, op: ast::unop, e: @ast::expr,
}
}
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);
let mode = alt f.proto {
ast::proto_shared(_) { for_closure }
ast::proto_send. { for_send }
ast::proto_bare. | ast::proto_block. { for_block }
};
let env;
alt f.proto {
ast::proto_block. | ast::proto_shared(_) | ast::proto_send. {
let upvars = get_freevars(ccx.tcx, id);
let env_r = build_closure(bcx, upvars, mode);
env = env_r.ptr;
bcx = env_r.bcx;
trans_closure(sub_cx, sp, f, llfn, none, [], id, {|fcx|
load_environment(bcx, fcx, env_r.ptrty, upvars, mode);
});
}
ast::proto_bare. {
env = C_null(T_opaque_closure_ptr(ccx));
trans_closure(sub_cx, sp, f, llfn, none, [], id, {|_fcx|});
}
};
fill_fn_pair(bcx, get_dest_addr(dest), llfn, env);
ret bcx;
}
fn trans_compare(cx: @block_ctxt, op: ast::binop, lhs: ValueRef,
_lhs_t: ty::t, rhs: ValueRef, rhs_t: ty::t) -> result {
if ty::type_is_scalar(bcx_tcx(cx), rhs_t) {
@ -2602,294 +2566,6 @@ fn trans_for(cx: @block_ctxt, local: @ast::local, seq: @ast::expr,
ret next_cx;
}
// Iterator translation
tag environment_value {
env_expr(@ast::expr);
env_direct(ValueRef, ty::t, bool);
}
// 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.
fn build_environment(bcx: @block_ctxt, lltydescs: [ValueRef],
bound_values: [environment_value],
mode: closure_constr_mode) ->
{ptr: ValueRef, ptrty: ty::t, bcx: @block_ctxt} {
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)
}
fn clone_tydesc(bcx: @block_ctxt,
mode: closure_constr_mode,
td: ValueRef) -> ValueRef {
ret alt mode {
for_block. | for_closure. { td }
for_send. { Call(bcx, bcx_ccx(bcx).upcalls.clone_type_desc, [td]) }
};
}
let ccx = bcx_ccx(bcx);
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) }
}];
}
let bindings_ty: ty::t = ty::mk_tup(tcx, bound_tys);
// NB: keep this in sync with T_closure_ptr; we're making
// a ty::t structure that has the same "shape" as the LLVM type
// it constructs.
// Make a vector that contains ty_param_count copies of tydesc_ty.
// (We'll need room for that many tydescs in the closure.)
let ty_param_count = vec::len(lltydescs);
let tydesc_ty: ty::t = ty::mk_type(tcx);
let captured_tys: [ty::t] = vec::init_elt(tydesc_ty, ty_param_count);
// Get all the types we've got (some of which we synthesized
// ourselves) into a vector. The whole things ends up looking
// like:
// closure_ty = (tydesc_ty, (bound_ty1, bound_ty2, ...), int, (tydesc_ty,
// tydesc_ty, ...))
let closure_tys: [ty::t] =
[tydesc_ty, bindings_ty,
ty::mk_uint(tcx), ty::mk_tup(tcx, captured_tys)];
let closure_ty: ty::t = ty::mk_tup(tcx, closure_tys);
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.
let (bcx, closure, box) = alt mode {
for_closure. {
let r = trans_malloc_boxed(bcx, closure_ty);
add_clean_free(bcx, r.box, false);
temp_cleanups += [r.box];
(r.bcx, r.body, r.box)
}
for_send. {
// 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);
dummy_environment_box(bcx, r)
}
for_block. {
// Dummy up a box on the stack,
let ty = ty::mk_tup(tcx, [ty::mk_int(tcx), closure_ty]);
let r = alloc_ty(bcx, ty);
dummy_environment_box(bcx, r)
}
};
// Store bindings tydesc.
alt mode {
for_closure. | for_send. {
let bound_tydesc = GEPi(bcx, closure, [0, abi::closure_elt_tydesc]);
let ti = none;
let bindings_tydesc =
get_tydesc(bcx, bindings_ty, true, tps_normal, ti).result;
lazily_emit_tydesc_glue(bcx, abi::tydesc_field_drop_glue, ti);
lazily_emit_tydesc_glue(bcx, abi::tydesc_field_free_glue, ti);
bcx = bindings_tydesc.bcx;
let td = clone_tydesc(bcx, mode, bindings_tydesc.val);
Store(bcx, td, bound_tydesc);
}
for_block. {}
}
// Copy expr values into boxed bindings.
// Silly check
check type_is_tup_like(bcx, closure_ty);
let closure_box = box;
let closure_box_ty = ty::mk_imm_box(bcx_tcx(bcx), closure_ty);
let i = 0u;
for bv in bound_values {
let bound = GEP_tup_like_1(bcx, closure_box_ty, closure_box,
[0, abi::box_rc_field_body,
abi::closure_elt_bindings,
i as int]);
bcx = bound.bcx;
alt bv {
env_expr(e) {
bcx = 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) {
alt mode {
for_closure. | for_send. {
let val1 = is_mem ? load_if_immediate(bcx, val, ty) : val;
bcx = copy_val(bcx, INIT, bound.val, val1, ty);
}
for_block. {
let addr = is_mem ? val : do_spill_noroot(bcx, val);
Store(bcx, addr, bound.val);
}
}
}
}
i += 1u;
}
for cleanup in temp_cleanups { revoke_clean(bcx, cleanup); }
// If necessary, copy tydescs describing type parameters into the
// appropriate slot in the closure.
// Silly check as well
check type_is_tup_like(bcx, closure_ty);
let {bcx:bcx, val:n_ty_params_slot} =
GEP_tup_like(bcx, closure_ty, closure,
[0, abi::closure_elt_n_ty_params]);
Store(bcx, C_uint(ccx, vec::len(lltydescs)), n_ty_params_slot);
check type_is_tup_like(bcx, closure_ty);
let {bcx:bcx, val:ty_params_slot} =
GEP_tup_like(bcx, closure_ty, closure,
[0, abi::closure_elt_ty_params]);
i = 0u;
for td: ValueRef in lltydescs {
let ty_param_slot = GEPi(bcx, ty_params_slot, [0, i as int]);
let cloned_td = clone_tydesc(bcx, mode, td);
Store(bcx, cloned_td, ty_param_slot);
i += 1u;
}
ret {ptr: box, ptrty: closure_ty, bcx: bcx};
}
tag closure_constr_mode {
for_block;
for_closure;
for_send;
}
// Given a context and a list of upvars, build a closure. This just
// collects the upvars and packages them up for build_environment.
fn build_closure(cx: @block_ctxt,
upvars: @[ast::def],
mode: closure_constr_mode)
-> {ptr: ValueRef, ptrty: ty::t, bcx: @block_ctxt} {
// If we need to, package up the iterator body to call
let env_vals = [];
// Package up the upvars
for def in *upvars {
let lv = trans_local_var(cx, def);
let nid = ast_util::def_id_of_def(def).node;
let ty = ty::node_id_to_monotype(bcx_tcx(cx), nid);
alt mode {
for_block. { ty = ty::mk_mut_ptr(bcx_tcx(cx), ty); }
for_send. | for_closure. {}
}
env_vals += [env_direct(lv.val, ty, lv.kind == owned)];
}
ret build_environment(cx, copy cx.fcx.lltydescs, env_vals, mode);
}
// Return a pointer to the stored typarams in a closure.
// This is awful. Since the size of the bindings stored in the closure might
// be dynamically sized, we can't skip past them to get to the tydescs until
// we have loaded the tydescs. Thus we use the stored size of the bindings
// in the tydesc for the closure to skip over them. Ugh.
fn find_environment_tydescs(bcx: @block_ctxt, envty: ty::t, closure: ValueRef)
-> ValueRef {
ret if !ty::type_has_dynamic_size(bcx_tcx(bcx), envty) {
// If we can find the typarams statically, do it
GEPi(bcx, closure,
[0, abi::box_rc_field_body, abi::closure_elt_ty_params])
} else {
// Ugh. We need to load the size of the bindings out of the
// closure's tydesc and use that to skip over the bindings.
let descsty =
ty::get_element_type(bcx_tcx(bcx), envty,
abi::closure_elt_ty_params as uint);
let llenv = GEPi(bcx, closure, [0, abi::box_rc_field_body]);
// Load the tydesc and find the size of the body
let lldesc =
Load(bcx, GEPi(bcx, llenv, [0, abi::closure_elt_tydesc]));
let llsz =
Load(bcx, GEPi(bcx, lldesc, [0, abi::tydesc_field_size]));
// Get the bindings pointer and add the size to it
let llbinds = GEPi(bcx, llenv, [0, abi::closure_elt_bindings]);
bump_ptr(bcx, descsty, llbinds, llsz)
}
}
// 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.
fn load_environment(enclosing_cx: @block_ctxt, fcx: @fn_ctxt, envty: ty::t,
upvars: @[ast::def], mode: closure_constr_mode) {
let bcx = new_raw_block_ctxt(fcx, fcx.llloadenv);
let ty = ty::mk_imm_box(bcx_tcx(bcx), envty);
let ccx = bcx_ccx(bcx);
let sp = bcx.sp;
// FIXME: should have postcondition on mk_imm_box,
// so this check won't be necessary
check (type_has_static_size(ccx, ty));
let llty = type_of(ccx, sp, ty);
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);
let lltydescs = find_environment_tydescs(bcx, envty, llclosure);
let i = 0u;
while i < tydesc_count {
let lltydescptr = GEPi(bcx, lltydescs, [0, i as int]);
fcx.lltydescs += [Load(bcx, lltydescptr)];
i += 1u;
}
// Populate the upvars from the environment.
let path = [0, abi::box_rc_field_body, abi::closure_elt_bindings];
i = 0u;
// Load the actual upvars.
for upvar_def in *upvars {
// Silly check
check type_is_tup_like(bcx, ty);
let upvarptr = GEP_tup_like(bcx, ty, llclosure, path + [i as int]);
bcx = upvarptr.bcx;
let llupvarptr = upvarptr.val;
alt mode {
for_block. { llupvarptr = Load(bcx, llupvarptr); }
for_send. | for_closure. { }
}
let def_id = ast_util::def_id_of_def(upvar_def);
fcx.llupvars.insert(def_id.node, llupvarptr);
i += 1u;
}
}
fn trans_while(cx: @block_ctxt, cond: @ast::expr, body: ast::blk)
-> @block_ctxt {
let next_cx = new_sub_block_ctxt(cx, "while next");
@ -3292,8 +2968,8 @@ fn lval_maybe_callee_to_lval(c: lval_maybe_callee, ty: ty::t) -> lval_result {
let n_args = vec::len(ty::ty_fn_args(bcx_tcx(c.bcx), ty));
let args = vec::init_elt(none::<@ast::expr>, n_args);
let space = alloc_ty(c.bcx, ty);
let bcx = trans_bind_1(space.bcx, ty, c, args, ty,
save_in(space.val));
let bcx = trans_closure::trans_bind_1(space.bcx, ty, c, args, ty,
save_in(space.val));
add_clean_temp(bcx, space.val, ty);
ret {bcx: bcx, val: space.val, kind: temporary};
}
@ -3580,86 +3256,6 @@ fn trans_bind_thunk(cx: @local_ctxt, sp: span, incoming_fty: ty::t,
ret {val: llthunk, ty: llthunk_ty};
}
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
let closure = build_environment(bcx, lltydescs, env_vals +
vec::map({|x| env_expr(x)}, bound),
for_closure);
bcx = closure.bcx;
// Make thunk
let llthunk =
trans_bind_thunk(cx.fcx.lcx, cx.sp, pair_ty, outgoing_fty_real, args,
closure.ptrty, ty_param_count, target_res);
// Fill the function pair
fill_fn_pair(bcx, get_dest_addr(dest), llthunk.val, closure.ptr);
ret bcx;
}
fn trans_arg_expr(cx: @block_ctxt, arg: ty::arg, lldestty0: TypeRef,
&to_zero: [{v: ValueRef, t: ty::t}],
&to_revoke: [{v: ValueRef, t: ty::t}], e: @ast::expr) ->
@ -4166,8 +3762,12 @@ fn trans_expr(bcx: @block_ctxt, e: @ast::expr, dest: dest) -> @block_ctxt {
ret trans_unary(bcx, op, x, e.id, dest);
}
// NDM captures
ast::expr_fn(f, cap) { ret trans_expr_fn(bcx, f, e.span, e.id, dest); }
ast::expr_bind(f, args) { ret trans_bind(bcx, f, args, e.id, dest); }
ast::expr_fn(f, cap) {
ret trans_closure::trans_expr_fn(bcx, f, e.span, e.id, dest);
}
ast::expr_bind(f, args) {
ret trans_closure::trans_bind(bcx, f, args, e.id, dest);
}
ast::expr_copy(a) {
if !ty::expr_is_lval(tcx, a) { ret trans_expr(bcx, a, dest); }
else { ret lval_to_dps(bcx, a, dest); }

426
src/comp/middle/trans_closure.rs Normal file
View file

@ -0,0 +1,426 @@
import syntax::ast;
import syntax::ast_util;
import lib::llvm::llvm::ValueRef;
import trans_common::*;
import trans_build::*;
import trans::*;
import middle::freevars::get_freevars;
import option::{some, none};
import back::abi;
import syntax::codemap::span;
import back::link::mangle_internal_name_by_path;
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
};
tag environment_value {
env_expr(@ast::expr);
env_direct(ValueRef, ty::t, bool);
}
// 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.
fn build_environment(bcx: @block_ctxt, lltydescs: [ValueRef],
bound_values: [environment_value],
mode: closure_constr_mode) ->
{ptr: ValueRef, ptrty: ty::t, bcx: @block_ctxt} {
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)
}
fn clone_tydesc(bcx: @block_ctxt,
mode: closure_constr_mode,
td: ValueRef) -> ValueRef {
ret alt mode {
for_block. | for_closure. { td }
for_send. { Call(bcx, bcx_ccx(bcx).upcalls.clone_type_desc, [td]) }
};
}
let ccx = bcx_ccx(bcx);
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) }
}];
}
let bindings_ty: ty::t = ty::mk_tup(tcx, bound_tys);
// NB: keep this in sync with T_closure_ptr; we're making
// a ty::t structure that has the same "shape" as the LLVM type
// it constructs.
// Make a vector that contains ty_param_count copies of tydesc_ty.
// (We'll need room for that many tydescs in the closure.)
let ty_param_count = vec::len(lltydescs);
let tydesc_ty: ty::t = ty::mk_type(tcx);
let captured_tys: [ty::t] = vec::init_elt(tydesc_ty, ty_param_count);
// Get all the types we've got (some of which we synthesized
// ourselves) into a vector. The whole things ends up looking
// like:
// closure_ty = (
// tydesc_ty, (bound_ty1, bound_ty2, ...),
// /*int,*/ (tydesc_ty, tydesc_ty, ...))
let closure_tys: [ty::t] =
[tydesc_ty, bindings_ty,
/*ty::mk_uint(tcx),*/ ty::mk_tup(tcx, captured_tys)];
let closure_ty: ty::t = ty::mk_tup(tcx, closure_tys);
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.
let (bcx, closure, box) = alt mode {
for_closure. {
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)
}
for_send. {
// 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);
dummy_environment_box(bcx, r)
}
for_block. {
// 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.
alt mode {
for_closure. | for_send. {
let bound_tydesc = GEPi(bcx, closure, [0, abi::closure_elt_tydesc]);
let ti = none;
let {result:bindings_tydesc, _} =
trans::get_tydesc(bcx, bindings_ty, true, trans::tps_normal, ti);
trans::lazily_emit_tydesc_glue(bcx, abi::tydesc_field_drop_glue, ti);
trans::lazily_emit_tydesc_glue(bcx, abi::tydesc_field_free_glue, ti);
bcx = bindings_tydesc.bcx;
let td = clone_tydesc(bcx, mode, bindings_tydesc.val);
Store(bcx, td, bound_tydesc);
}
for_block. {}
}
// Copy expr values into boxed bindings.
// Silly check
check type_is_tup_like(bcx, closure_ty);
let closure_box = box;
let closure_box_ty = ty::mk_imm_box(bcx_tcx(bcx), closure_ty);
let i = 0u;
for bv in bound_values {
let bound = trans::GEP_tup_like_1(bcx, closure_box_ty, closure_box,
[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) {
alt mode {
for_closure. | for_send. {
let val1 = is_mem ? load_if_immediate(bcx, val, ty) : val;
bcx = trans::copy_val(bcx, INIT, bound.val, val1, ty);
}
for_block. {
let addr = is_mem ? val : do_spill_noroot(bcx, val);
Store(bcx, addr, bound.val);
}
}
}
}
i += 1u;
}
for cleanup in temp_cleanups { revoke_clean(bcx, cleanup); }
// If necessary, copy tydescs describing type parameters into the
// appropriate slot in the closure.
// Silly check as well
//check type_is_tup_like(bcx, closure_ty);
//let {bcx:bcx, val:n_ty_params_slot} =
// GEP_tup_like(bcx, closure_ty, closure,
// [0, abi::closure_elt_n_ty_params]);
//Store(bcx, C_uint(ccx, vec::len(lltydescs)), n_ty_params_slot);
check type_is_tup_like(bcx, closure_ty);
let {bcx:bcx, val:ty_params_slot} =
GEP_tup_like(bcx, closure_ty, closure,
[0, abi::closure_elt_ty_params]);
i = 0u;
for td: ValueRef in lltydescs {
let ty_param_slot = GEPi(bcx, ty_params_slot, [0, i as int]);
let cloned_td = clone_tydesc(bcx, mode, td);
Store(bcx, cloned_td, ty_param_slot);
i += 1u;
}
ret {ptr: box, ptrty: closure_ty, bcx: bcx};
}
tag closure_constr_mode {
for_block;
for_closure;
for_send;
}
// Given a context and a list of upvars, build a closure. This just
// collects the upvars and packages them up for build_environment.
fn build_closure(cx: @block_ctxt,
upvars: @[ast::def],
mode: closure_constr_mode)
-> {ptr: ValueRef, ptrty: ty::t, bcx: @block_ctxt} {
// If we need to, package up the iterator body to call
let env_vals = [];
// Package up the upvars
for def in *upvars {
let lv = trans_local_var(cx, def);
let nid = ast_util::def_id_of_def(def).node;
let ty = ty::node_id_to_monotype(bcx_tcx(cx), nid);
alt mode {
for_block. { ty = ty::mk_mut_ptr(bcx_tcx(cx), ty); }
for_send. | for_closure. {}
}
env_vals += [env_direct(lv.val, ty, lv.kind == owned)];
}
ret build_environment(cx, copy cx.fcx.lltydescs, env_vals, mode);
}
// Return a pointer to the stored typarams in a closure.
// This is awful. Since the size of the bindings stored in the closure might
// be dynamically sized, we can't skip past them to get to the tydescs until
// we have loaded the tydescs. Thus we use the stored size of the bindings
// in the tydesc for the closure to skip over them. Ugh.
fn find_environment_tydescs(bcx: @block_ctxt, envty: ty::t, closure: ValueRef)
-> ValueRef {
ret if !ty::type_has_dynamic_size(bcx_tcx(bcx), envty) {
// If we can find the typarams statically, do it
GEPi(bcx, closure,
[0, abi::box_rc_field_body, abi::closure_elt_ty_params])
} else {
// Ugh. We need to load the size of the bindings out of the
// closure's tydesc and use that to skip over the bindings.
let descsty =
ty::get_element_type(bcx_tcx(bcx), envty,
abi::closure_elt_ty_params as uint);
let llenv = GEPi(bcx, closure, [0, abi::box_rc_field_body]);
// Load the tydesc and find the size of the body
let lldesc =
Load(bcx, GEPi(bcx, llenv, [0, abi::closure_elt_tydesc]));
let llsz =
Load(bcx, GEPi(bcx, lldesc, [0, abi::tydesc_field_size]));
// Get the bindings pointer and add the size to it
let llbinds = GEPi(bcx, llenv, [0, abi::closure_elt_bindings]);
bump_ptr(bcx, descsty, llbinds, llsz)
}
}
// 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.
fn load_environment(enclosing_cx: @block_ctxt, fcx: @fn_ctxt, envty: ty::t,
upvars: @[ast::def], mode: closure_constr_mode) {
let bcx = new_raw_block_ctxt(fcx, fcx.llloadenv);
let ty = ty::mk_imm_box(bcx_tcx(bcx), envty);
let ccx = bcx_ccx(bcx);
let sp = bcx.sp;
// FIXME: should have postcondition on mk_imm_box,
// so this check won't be necessary
check (type_has_static_size(ccx, ty));
let llty = type_of(ccx, sp, ty);
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);
let lltydescs = find_environment_tydescs(bcx, envty, llclosure);
let i = 0u;
while i < tydesc_count {
let lltydescptr = GEPi(bcx, lltydescs, [0, i as int]);
fcx.lltydescs += [Load(bcx, lltydescptr)];
i += 1u;
}
// Populate the upvars from the environment.
let path = [0, abi::box_rc_field_body, abi::closure_elt_bindings];
i = 0u;
// Load the actual upvars.
for upvar_def in *upvars {
// Silly check
check type_is_tup_like(bcx, ty);
let upvarptr = GEP_tup_like(bcx, ty, llclosure, path + [i as int]);
bcx = upvarptr.bcx;
let llupvarptr = upvarptr.val;
alt mode {
for_block. { llupvarptr = Load(bcx, llupvarptr); }
for_send. | for_closure. { }
}
let def_id = ast_util::def_id_of_def(upvar_def);
fcx.llupvars.insert(def_id.node, llupvarptr);
i += 1u;
}
}
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);
let mode = alt f.proto {
ast::proto_shared(_) { for_closure }
ast::proto_send. { for_send }
ast::proto_bare. | ast::proto_block. { for_block }
};
let env;
alt f.proto {
ast::proto_block. | ast::proto_shared(_) | ast::proto_send. {
let upvars = get_freevars(ccx.tcx, id);
let env_r = build_closure(bcx, upvars, mode);
env = env_r.ptr;
bcx = env_r.bcx;
trans_closure(sub_cx, sp, f, llfn, none, [], id, {|fcx|
load_environment(bcx, fcx, env_r.ptrty, upvars, mode);
});
}
ast::proto_bare. {
env = C_null(T_opaque_closure_ptr(ccx));
trans_closure(sub_cx, sp, f, llfn, none, [], id, {|_fcx|});
}
};
fill_fn_pair(bcx, get_dest_addr(dest), llfn, env);
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
let closure = build_environment(bcx, lltydescs, env_vals +
vec::map({|x| env_expr(x)}, bound),
for_closure);
bcx = closure.bcx;
// Make thunk
let llthunk =
trans_bind_thunk(cx.fcx.lcx, cx.sp, pair_ty, outgoing_fty_real, args,
closure.ptrty, ty_param_count, target_res);
// Fill the function pair
fill_fn_pair(bcx, get_dest_addr(dest), llthunk.val, closure.ptr);
ret bcx;
}

2
src/comp/middle/trans_common.rs
View file

@ -695,7 +695,7 @@ fn T_closure_ptr(cx: @crate_ctxt, llbindings_ty: TypeRef,
// it constructs.
ret T_ptr(T_box(cx, T_struct([T_ptr(cx.tydesc_type),
llbindings_ty,
cx.int_type,
//cx.int_type,
T_captured_tydescs(cx, n_ty_params)])));
}

1
src/comp/rustc.rc
View file

@ -20,6 +20,7 @@ mod middle {
mod trans_alt;
mod trans_objects;
mod trans_uniq;
mod trans_closure;
mod trans_vec;
mod ty;
mod ast_map;