src/librustc_trans/trans/closure.rs

   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.
   4 //
   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.
  10
  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;
  15 use middle::infer;
  16 use trans::adt;
  17 use trans::attributes;
  18 use trans::base::*;
  19 use trans::build::*;
  20 use trans::callee::{self, ArgVals, Callee, TraitItem, MethodData};
  21 use trans::cleanup::{CleanupMethods, CustomScope, ScopeId};
  22 use trans::common::*;
  23 use trans::datum::{self, Datum, rvalue_scratch_datum, Rvalue};
  24 use trans::debuginfo::{self, DebugLoc};
  25 use trans::declare;
  26 use trans::expr;
  27 use trans::monomorphize::{MonoId};
  28 use trans::type_of::*;
  29 use trans::Disr;
  30 use middle::ty;
  31 use session::config::FullDebugInfo;
  32
  33 use syntax::abi::Abi::RustCall;
  34 use syntax::ast;
  35 use syntax::attr::{ThinAttributes, ThinAttributesExt};
  36
  37 use rustc_front::hir;
  38
  39
  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])
  44                                         -> Block<'blk, 'tcx>
  45 {
  46     let _icx = push_ctxt("closure::load_closure_environment");
  47
  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,
  55                                          self_type,
  56                                          "closure_env");
  57         store_ty(bcx, bcx.fcx.llenv.unwrap(), datum.val, self_type);
  58         datum.val
  59     } else {
  60         bcx.fcx.llenv.unwrap()
  61     };
  62
  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);
  68         Some(alloc)
  69     } else {
  70         None
  71     };
  72
  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);
  82                 true
  83             }
  84         };
  85         let node_id = freevar.def.var_id();
  86         bcx.fcx.llupvars.borrow_mut().insert(node_id, upvar_ptr);
  87
  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,
  91                                       upvar_ptr,
  92                                       node_id_type(bcx, node_id),
  93                                       hint)
  94         }
  95
  96         if let Some(env_pointer_alloca) = env_pointer_alloca {
  97             debuginfo::create_captured_var_metadata(
  98                 bcx,
  99                 node_id,
 100                 env_pointer_alloca,
 101                 i,
 102                 captured_by_ref,
 103                 freevar.span);
 104         }
 105     }
 106
 107     bcx
 108 }
 109
 110 pub enum ClosureEnv<'a> {
 111     NotClosure,
 112     Closure(DefId, &'a [ty::Freevar]),
 113 }
 114
 115 impl<'a> ClosureEnv<'a> {
 116     pub fn load<'blk,'tcx>(self, bcx: Block<'blk, 'tcx>, arg_scope: ScopeId)
 117                            -> Block<'blk, 'tcx>
 118     {
 119         match self {
 120             ClosureEnv::NotClosure => bcx,
 121             ClosureEnv::Closure(def_id, freevars) => {
 122                 if freevars.is_empty() {
 123                     bcx
 124                 } else {
 125                     load_closure_environment(bcx, def_id, arg_scope, freevars)
 126                 }
 127             }
 128         }
 129     }
 130 }
 131
 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>,
 135                                                    closure_id: DefId,
 136                                                    substs: &ty::ClosureSubsts<'tcx>)
 137                                                    -> ValueRef {
 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 {
 142         def: closure_id,
 143         params: &substs.func_substs.types
 144     };
 145
 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));
 149         return llfn;
 150     }
 151
 152     let path = ccx.tcx().def_path(closure_id);
 153     let symbol = mangle_internal_name_by_path_and_seq(path, "closure");
 154
 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);
 157
 158     // set an inline hint for all closures
 159     attributes::inline(llfn, attributes::InlineAttr::Hint);
 160
 161     debug!("get_or_create_declaration_if_closure(): inserting new \
 162             closure {:?} (type {}): {:?}",
 163            mono_id,
 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);
 167
 168     llfn
 169 }
 170
 171 pub enum Dest<'a, 'tcx: 'a> {
 172     SaveIn(Block<'a, 'tcx>, ValueRef),
 173     Ignore(&'a CrateContext<'a, 'tcx>)
 174 }
 175
 176 pub fn trans_closure_expr<'a, 'tcx>(dest: Dest<'a, 'tcx>,
 177                                     decl: &hir::FnDecl,
 178                                     body: &hir::Block,
 179                                     id: ast::NodeId,
 180                                     closure_def_id: DefId, // (*)
 181                                     closure_substs: &'tcx ty::ClosureSubsts<'tcx>,
 182                                     closure_expr_attrs: &ThinAttributes)
 183                                     -> Option<Block<'a, 'tcx>>
 184 {
 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
 187     // inlined copy.
 188
 189     let param_substs = closure_substs.func_substs;
 190
 191     let ccx = match dest {
 192         Dest::SaveIn(bcx, _) => bcx.ccx(),
 193         Dest::Ignore(ccx) => ccx
 194     };
 195     let tcx = ccx.tcx();
 196     let _icx = push_ctxt("closure::trans_closure_expr");
 197
 198     debug!("trans_closure_expr(id={:?}, closure_def_id={:?}, closure_substs={:?})",
 199            id, closure_def_id, closure_substs);
 200
 201     let llfn = get_or_create_closure_declaration(ccx, closure_def_id, closure_substs);
 202
 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.
 208
 209     let infcx = infer::normalizing_infer_ctxt(ccx.tcx(), &ccx.tcx().tables);
 210     let function_type = infcx.closure_type(closure_def_id, closure_substs);
 211
 212     let freevars: Vec<ty::Freevar> =
 213         tcx.with_freevars(id, |fv| fv.iter().cloned().collect());
 214
 215     let sig = tcx.erase_late_bound_regions(&function_type.sig);
 216     let sig = infer::normalize_associated_type(ccx.tcx(), &sig);
 217
 218     trans_closure(ccx,
 219                   decl,
 220                   body,
 221                   llfn,
 222                   param_substs,
 223                   id,
 224                   closure_expr_attrs.as_attr_slice(),
 225                   sig.output,
 226                   function_type.abi,
 227                   ClosureEnv::Closure(closure_def_id, &freevars));
 228
 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),
 234         Dest::Ignore(_) => {
 235             debug!("trans_closure_expr() ignoring result");
 236             return None;
 237         }
 238     };
 239
 240     let repr = adt::represent_type(ccx, node_id_type(bcx, id));
 241
 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);
 252             }
 253             ty::UpvarCapture::ByRef(..) => {
 254                 Store(bcx, datum.to_llref(), upvar_slot_dest);
 255             }
 256         }
 257     }
 258     adt::trans_set_discr(bcx, &repr, dest_addr, Disr(0));
 259
 260     Some(bcx)
 261 }
 262
 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)
 267                                       -> ValueRef
 268 {
 269     // If this is a closure, redirect to it.
 270     let llfn = get_or_create_closure_declaration(ccx, closure_def_id, &substs);
 271
 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,
 276                                closure_def_id,
 277                                substs,
 278                                closure_kind,
 279                                trait_closure_kind,
 280                                llfn)
 281 }
 282
 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,
 289     llfn: ValueRef)
 290     -> ValueRef
 291 {
 292     let _icx = push_ctxt("trans_closure_adapter_shim");
 293     let tcx = ccx.tcx();
 294
 295     debug!("trans_closure_adapter_shim(llfn_closure_kind={:?}, \
 296            trait_closure_kind={:?}, \
 297            llfn={})",
 298            llfn_closure_kind,
 299            trait_closure_kind,
 300            ccx.tn().val_to_string(llfn));
 301
 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.
 307             llfn
 308         }
 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.
 313             llfn
 314         }
 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:
 320             //
 321             //     fn call_once(self, ...) { call_mut(&self, ...) }
 322             //     fn call_once(mut self, ...) { call_mut(&mut self, ...) }
 323             //
 324             // These are both the same at trans time.
 325             trans_fn_once_adapter_shim(ccx, closure_def_id, substs, llfn)
 326         }
 327         _ => {
 328             tcx.sess.bug(&format!("trans_closure_adapter_shim: cannot convert {:?} to {:?}",
 329                                   llfn_closure_kind,
 330                                   trait_closure_kind));
 331         }
 332     }
 333 }
 334
 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>,
 339     llreffn: ValueRef)
 340     -> ValueRef
 341 {
 342     debug!("trans_fn_once_adapter_shim(closure_def_id={:?}, substs={:?}, llreffn={})",
 343            closure_def_id,
 344            substs,
 345            ccx.tn().val_to_string(llreffn));
 346
 347     let tcx = ccx.tcx();
 348     let infcx = infer::normalizing_infer_ctxt(ccx.tcx(), &ccx.tcx().tables);
 349
 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);
 354
 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,
 359                                                                abi: abi,
 360                                                                sig: sig.clone() });
 361     let llref_fn_ty = tcx.mk_fn(None, llref_bare_fn_ty);
 362     debug!("trans_fn_once_adapter_shim: llref_fn_ty={:?}",
 363            llref_fn_ty);
 364
 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,
 370                                                                 abi: abi,
 371                                                                 sig: sig });
 372     let llonce_fn_ty = tcx.mk_fn(None, llonce_bare_fn_ty);
 373
 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,
 377                                                     llonce_fn_ty);
 378     let sig = tcx.erase_late_bound_regions(&llonce_bare_fn_ty.sig);
 379     let sig = infer::normalize_associated_type(ccx.tcx(), &sig);
 380
 381     let (block_arena, fcx): (TypedArena<_>, FunctionContext);
 382     block_arena = TypedArena::new();
 383     fcx = new_fn_ctxt(ccx,
 384                       lloncefn,
 385                       ast::DUMMY_NODE_ID,
 386                       false,
 387                       sig.output,
 388                       substs.func_substs,
 389                       None,
 390                       &block_arena);
 391     let mut bcx = init_function(&fcx, false, sig.output);
 392
 393     let llargs = get_params(fcx.llfn);
 394
 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",
 404                                                                      self_scope_id));
 405
 406     debug!("trans_fn_once_adapter_shim: env_datum={}",
 407            bcx.val_to_string(env_datum.val));
 408
 409     let dest =
 410         fcx.llretslotptr.get().map(
 411             |_| expr::SaveIn(fcx.get_ret_slot(bcx, sig.output, "ret_slot")));
 412
 413     let callee_data = TraitItem(MethodData { llfn: llreffn,
 414                                              llself: env_datum.val });
 415
 416     bcx = callee::trans_call_inner(bcx, DebugLoc::None, |bcx, _| {
 417         Callee {
 418             bcx: bcx,
 419             data: callee_data,
 420             ty: llref_fn_ty
 421         }
 422     }, ArgVals(&llargs[(self_idx + 1)..]), dest).bcx;
 423
 424     fcx.pop_and_trans_custom_cleanup_scope(bcx, self_scope);
 425
 426     finish_fn(&fcx, bcx, sig.output, DebugLoc::None);
 427
 428     lloncefn
 429 }