1 // Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 use arena
::TypedArena
;
12 use back
::link
::{self, mangle_internal_name_by_path_and_seq}
;
13 use llvm
::{ValueRef, get_params}
;
14 use middle
::def_id
::DefId
;
17 use trans
::attributes
;
20 use trans
::callee
::{self, ArgVals, Callee, TraitItem, MethodData}
;
21 use trans
::cleanup
::{CleanupMethods, CustomScope, ScopeId}
;
23 use trans
::datum
::{self, Datum, rvalue_scratch_datum, Rvalue}
;
24 use trans
::debuginfo
::{self, DebugLoc}
;
27 use trans
::monomorphize
::{MonoId}
;
28 use trans
::type_of
::*;
31 use session
::config
::FullDebugInfo
;
33 use syntax
::abi
::Abi
::RustCall
;
35 use syntax
::attr
::{ThinAttributes, ThinAttributesExt}
;
40 fn load_closure_environment
<'blk
, 'tcx
>(bcx
: Block
<'blk
, 'tcx
>,
41 closure_def_id
: DefId
,
42 arg_scope_id
: ScopeId
,
43 freevars
: &[ty
::Freevar
])
46 let _icx
= push_ctxt("closure::load_closure_environment");
48 // Special case for small by-value selfs.
49 let closure_ty
= node_id_type(bcx
, bcx
.fcx
.id
);
50 let self_type
= self_type_for_closure(bcx
.ccx(), closure_def_id
, closure_ty
);
51 let kind
= kind_for_closure(bcx
.ccx(), closure_def_id
);
52 let llenv
= if kind
== ty
::FnOnceClosureKind
&&
53 !arg_is_indirect(bcx
.ccx(), self_type
) {
54 let datum
= rvalue_scratch_datum(bcx
,
57 store_ty(bcx
, bcx
.fcx
.llenv
.unwrap(), datum
.val
, self_type
);
60 bcx
.fcx
.llenv
.unwrap()
63 // Store the pointer to closure data in an alloca for debug info because that's what the
64 // llvm.dbg.declare intrinsic expects
65 let env_pointer_alloca
= if bcx
.sess().opts
.debuginfo
== FullDebugInfo
{
66 let alloc
= alloca(bcx
, val_ty(llenv
), "__debuginfo_env_ptr");
67 Store(bcx
, llenv
, alloc
);
73 for (i
, freevar
) in freevars
.iter().enumerate() {
74 let upvar_id
= ty
::UpvarId
{ var_id
: freevar
.def
.var_id(),
75 closure_expr_id
: bcx
.fcx
.id
};
76 let upvar_capture
= bcx
.tcx().upvar_capture(upvar_id
).unwrap();
77 let mut upvar_ptr
= StructGEP(bcx
, llenv
, i
);
78 let captured_by_ref
= match upvar_capture
{
79 ty
::UpvarCapture
::ByValue
=> false,
80 ty
::UpvarCapture
::ByRef(..) => {
81 upvar_ptr
= Load(bcx
, upvar_ptr
);
85 let node_id
= freevar
.def
.var_id();
86 bcx
.fcx
.llupvars
.borrow_mut().insert(node_id
, upvar_ptr
);
88 if kind
== ty
::FnOnceClosureKind
&& !captured_by_ref
{
89 let hint
= bcx
.fcx
.lldropflag_hints
.borrow().hint_datum(upvar_id
.var_id
);
90 bcx
.fcx
.schedule_drop_mem(arg_scope_id
,
92 node_id_type(bcx
, node_id
),
96 if let Some(env_pointer_alloca
) = env_pointer_alloca
{
97 debuginfo
::create_captured_var_metadata(
110 pub enum ClosureEnv
<'a
> {
112 Closure(DefId
, &'a
[ty
::Freevar
]),
115 impl<'a
> ClosureEnv
<'a
> {
116 pub fn load
<'blk
,'tcx
>(self, bcx
: Block
<'blk
, 'tcx
>, arg_scope
: ScopeId
)
120 ClosureEnv
::NotClosure
=> bcx
,
121 ClosureEnv
::Closure(def_id
, freevars
) => {
122 if freevars
.is_empty() {
125 load_closure_environment(bcx
, def_id
, arg_scope
, freevars
)
132 /// Returns the LLVM function declaration for a closure, creating it if
133 /// necessary. If the ID does not correspond to a closure ID, returns None.
134 pub fn get_or_create_closure_declaration
<'a
, 'tcx
>(ccx
: &CrateContext
<'a
, 'tcx
>,
136 substs
: &ty
::ClosureSubsts
<'tcx
>)
138 // Normalize type so differences in regions and typedefs don't cause
139 // duplicate declarations
140 let substs
= ccx
.tcx().erase_regions(substs
);
141 let mono_id
= MonoId
{
143 params
: &substs
.func_substs
.types
146 if let Some(&llfn
) = ccx
.closure_vals().borrow().get(&mono_id
) {
147 debug
!("get_or_create_closure_declaration(): found closure {:?}: {:?}",
148 mono_id
, ccx
.tn().val_to_string(llfn
));
152 let path
= ccx
.tcx().def_path(closure_id
);
153 let symbol
= mangle_internal_name_by_path_and_seq(path
, "closure");
155 let function_type
= ccx
.tcx().mk_closure_from_closure_substs(closure_id
, Box
::new(substs
));
156 let llfn
= declare
::define_internal_rust_fn(ccx
, &symbol
[..], function_type
);
158 // set an inline hint for all closures
159 attributes
::inline(llfn
, attributes
::InlineAttr
::Hint
);
161 debug
!("get_or_create_declaration_if_closure(): inserting new \
162 closure {:?} (type {}): {:?}",
164 ccx
.tn().type_to_string(val_ty(llfn
)),
165 ccx
.tn().val_to_string(llfn
));
166 ccx
.closure_vals().borrow_mut().insert(mono_id
, llfn
);
171 pub enum Dest
<'a
, 'tcx
: 'a
> {
172 SaveIn(Block
<'a
, 'tcx
>, ValueRef
),
173 Ignore(&'a CrateContext
<'a
, 'tcx
>)
176 pub fn trans_closure_expr
<'a
, 'tcx
>(dest
: Dest
<'a
, 'tcx
>,
180 closure_def_id
: DefId
, // (*)
181 closure_substs
: &'tcx ty
::ClosureSubsts
<'tcx
>,
182 closure_expr_attrs
: &ThinAttributes
)
183 -> Option
<Block
<'a
, 'tcx
>>
185 // (*) Note that in the case of inlined functions, the `closure_def_id` will be the
186 // defid of the closure in its original crate, whereas `id` will be the id of the local
189 let param_substs
= closure_substs
.func_substs
;
191 let ccx
= match dest
{
192 Dest
::SaveIn(bcx
, _
) => bcx
.ccx(),
193 Dest
::Ignore(ccx
) => ccx
196 let _icx
= push_ctxt("closure::trans_closure_expr");
198 debug
!("trans_closure_expr(id={:?}, closure_def_id={:?}, closure_substs={:?})",
199 id
, closure_def_id
, closure_substs
);
201 let llfn
= get_or_create_closure_declaration(ccx
, closure_def_id
, closure_substs
);
203 // Get the type of this closure. Use the current `param_substs` as
204 // the closure substitutions. This makes sense because the closure
205 // takes the same set of type arguments as the enclosing fn, and
206 // this function (`trans_closure`) is invoked at the point
207 // of the closure expression.
209 let infcx
= infer
::normalizing_infer_ctxt(ccx
.tcx(), &ccx
.tcx().tables
);
210 let function_type
= infcx
.closure_type(closure_def_id
, closure_substs
);
212 let freevars
: Vec
<ty
::Freevar
> =
213 tcx
.with_freevars(id
, |fv
| fv
.iter().cloned().collect());
215 let sig
= tcx
.erase_late_bound_regions(&function_type
.sig
);
216 let sig
= infer
::normalize_associated_type(ccx
.tcx(), &sig
);
224 closure_expr_attrs
.as_attr_slice(),
227 ClosureEnv
::Closure(closure_def_id
, &freevars
));
229 // Don't hoist this to the top of the function. It's perfectly legitimate
230 // to have a zero-size closure (in which case dest will be `Ignore`) and
231 // we must still generate the closure body.
232 let (mut bcx
, dest_addr
) = match dest
{
233 Dest
::SaveIn(bcx
, p
) => (bcx
, p
),
235 debug
!("trans_closure_expr() ignoring result");
240 let repr
= adt
::represent_type(ccx
, node_id_type(bcx
, id
));
242 // Create the closure.
243 for (i
, freevar
) in freevars
.iter().enumerate() {
244 let datum
= expr
::trans_local_var(bcx
, freevar
.def
);
245 let upvar_slot_dest
= adt
::trans_field_ptr(
246 bcx
, &repr
, adt
::MaybeSizedValue
::sized(dest_addr
), Disr(0), i
);
247 let upvar_id
= ty
::UpvarId
{ var_id
: freevar
.def
.var_id(),
248 closure_expr_id
: id
};
249 match tcx
.upvar_capture(upvar_id
).unwrap() {
250 ty
::UpvarCapture
::ByValue
=> {
251 bcx
= datum
.store_to(bcx
, upvar_slot_dest
);
253 ty
::UpvarCapture
::ByRef(..) => {
254 Store(bcx
, datum
.to_llref(), upvar_slot_dest
);
258 adt
::trans_set_discr(bcx
, &repr
, dest_addr
, Disr(0));
263 pub fn trans_closure_method
<'a
, 'tcx
>(ccx
: &'a CrateContext
<'a
, 'tcx
>,
264 closure_def_id
: DefId
,
265 substs
: ty
::ClosureSubsts
<'tcx
>,
266 trait_closure_kind
: ty
::ClosureKind
)
269 // If this is a closure, redirect to it.
270 let llfn
= get_or_create_closure_declaration(ccx
, closure_def_id
, &substs
);
272 // If the closure is a Fn closure, but a FnOnce is needed (etc),
273 // then adapt the self type
274 let closure_kind
= ccx
.tcx().closure_kind(closure_def_id
);
275 trans_closure_adapter_shim(ccx
,
283 fn trans_closure_adapter_shim
<'a
, 'tcx
>(
284 ccx
: &'a CrateContext
<'a
, 'tcx
>,
285 closure_def_id
: DefId
,
286 substs
: ty
::ClosureSubsts
<'tcx
>,
287 llfn_closure_kind
: ty
::ClosureKind
,
288 trait_closure_kind
: ty
::ClosureKind
,
292 let _icx
= push_ctxt("trans_closure_adapter_shim");
295 debug
!("trans_closure_adapter_shim(llfn_closure_kind={:?}, \
296 trait_closure_kind={:?}, \
300 ccx
.tn().val_to_string(llfn
));
302 match (llfn_closure_kind
, trait_closure_kind
) {
303 (ty
::FnClosureKind
, ty
::FnClosureKind
) |
304 (ty
::FnMutClosureKind
, ty
::FnMutClosureKind
) |
305 (ty
::FnOnceClosureKind
, ty
::FnOnceClosureKind
) => {
306 // No adapter needed.
309 (ty
::FnClosureKind
, ty
::FnMutClosureKind
) => {
310 // The closure fn `llfn` is a `fn(&self, ...)`. We want a
311 // `fn(&mut self, ...)`. In fact, at trans time, these are
312 // basically the same thing, so we can just return llfn.
315 (ty
::FnClosureKind
, ty
::FnOnceClosureKind
) |
316 (ty
::FnMutClosureKind
, ty
::FnOnceClosureKind
) => {
317 // The closure fn `llfn` is a `fn(&self, ...)` or `fn(&mut
318 // self, ...)`. We want a `fn(self, ...)`. We can produce
319 // this by doing something like:
321 // fn call_once(self, ...) { call_mut(&self, ...) }
322 // fn call_once(mut self, ...) { call_mut(&mut self, ...) }
324 // These are both the same at trans time.
325 trans_fn_once_adapter_shim(ccx
, closure_def_id
, substs
, llfn
)
328 tcx
.sess
.bug(&format
!("trans_closure_adapter_shim: cannot convert {:?} to {:?}",
330 trait_closure_kind
));
335 fn trans_fn_once_adapter_shim
<'a
, 'tcx
>(
336 ccx
: &'a CrateContext
<'a
, 'tcx
>,
337 closure_def_id
: DefId
,
338 substs
: ty
::ClosureSubsts
<'tcx
>,
342 debug
!("trans_fn_once_adapter_shim(closure_def_id={:?}, substs={:?}, llreffn={})",
345 ccx
.tn().val_to_string(llreffn
));
348 let infcx
= infer
::normalizing_infer_ctxt(ccx
.tcx(), &ccx
.tcx().tables
);
350 // Find a version of the closure type. Substitute static for the
351 // region since it doesn't really matter.
352 let closure_ty
= tcx
.mk_closure_from_closure_substs(closure_def_id
, Box
::new(substs
.clone()));
353 let ref_closure_ty
= tcx
.mk_imm_ref(tcx
.mk_region(ty
::ReStatic
), closure_ty
);
355 // Make a version with the type of by-ref closure.
356 let ty
::ClosureTy { unsafety, abi, mut sig }
= infcx
.closure_type(closure_def_id
, &substs
);
357 sig
.0.inputs
.insert(0, ref_closure_ty
); // sig has no self type as of yet
358 let llref_bare_fn_ty
= tcx
.mk_bare_fn(ty
::BareFnTy
{ unsafety
: unsafety
,
361 let llref_fn_ty
= tcx
.mk_fn(None
, llref_bare_fn_ty
);
362 debug
!("trans_fn_once_adapter_shim: llref_fn_ty={:?}",
365 // Make a version of the closure type with the same arguments, but
366 // with argument #0 being by value.
367 assert_eq
!(abi
, RustCall
);
368 sig
.0.inputs
[0] = closure_ty
;
369 let llonce_bare_fn_ty
= tcx
.mk_bare_fn(ty
::BareFnTy
{ unsafety
: unsafety
,
372 let llonce_fn_ty
= tcx
.mk_fn(None
, llonce_bare_fn_ty
);
374 // Create the by-value helper.
375 let function_name
= link
::mangle_internal_name_by_type_and_seq(ccx
, llonce_fn_ty
, "once_shim");
376 let lloncefn
= declare
::define_internal_rust_fn(ccx
, &function_name
,
378 let sig
= tcx
.erase_late_bound_regions(&llonce_bare_fn_ty
.sig
);
379 let sig
= infer
::normalize_associated_type(ccx
.tcx(), &sig
);
381 let (block_arena
, fcx
): (TypedArena
<_
>, FunctionContext
);
382 block_arena
= TypedArena
::new();
383 fcx
= new_fn_ctxt(ccx
,
391 let mut bcx
= init_function(&fcx
, false, sig
.output
);
393 let llargs
= get_params(fcx
.llfn
);
395 // the first argument (`self`) will be the (by value) closure env.
396 let self_scope
= fcx
.push_custom_cleanup_scope();
397 let self_scope_id
= CustomScope(self_scope
);
398 let rvalue_mode
= datum
::appropriate_rvalue_mode(ccx
, closure_ty
);
399 let self_idx
= fcx
.arg_offset();
400 let llself
= llargs
[self_idx
];
401 let env_datum
= Datum
::new(llself
, closure_ty
, Rvalue
::new(rvalue_mode
));
402 let env_datum
= unpack_datum
!(bcx
,
403 env_datum
.to_lvalue_datum_in_scope(bcx
, "self",
406 debug
!("trans_fn_once_adapter_shim: env_datum={}",
407 bcx
.val_to_string(env_datum
.val
));
410 fcx
.llretslotptr
.get().map(
411 |_
| expr
::SaveIn(fcx
.get_ret_slot(bcx
, sig
.output
, "ret_slot")));
413 let callee_data
= TraitItem(MethodData
{ llfn
: llreffn
,
414 llself
: env_datum
.val
});
416 bcx
= callee
::trans_call_inner(bcx
, DebugLoc
::None
, |bcx
, _
| {
422 }, ArgVals(&llargs
[(self_idx
+ 1)..]), dest
).bcx
;
424 fcx
.pop_and_trans_custom_cleanup_scope(bcx
, self_scope
);
426 finish_fn(&fcx
, bcx
, sig
.output
, DebugLoc
::None
);