1 // Copyright 2012 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 //! Handles translation of callees as well as other call-related
12 //! things. Callees are a superset of normal rust values and sometimes
13 //! have different representations. In particular, top-level fn items
14 //! and methods are represented as just a fn ptr and not a full
17 pub use self::CalleeData::*;
19 use llvm::{self, ValueRef, get_params};
20 use rustc::hir::def_id::DefId;
21 use rustc::ty::subst::Substs;
23 use abi::{Abi, FnType};
27 use common::{self, CrateContext, SharedCrateContext};
28 use cleanup::CleanupScope;
29 use mir::lvalue::LvalueRef;
34 use monomorphize::{self, Instance};
35 use trans_item::TransItem;
38 use rustc::ty::{self, Ty, TypeFoldable};
42 use syntax_pos::DUMMY_SP;
44 use mir::lvalue::Alignment;
48 /// Constructor for enum variant/tuple-like-struct.
49 NamedTupleConstructor(Disr),
56 /// Trait object found in the vtable at that index.
61 pub struct Callee<'tcx> {
66 impl<'tcx> Callee<'tcx> {
68 pub fn ptr(llfn: ValueRef, ty: Ty<'tcx>) -> Callee<'tcx> {
75 /// Function or method definition.
76 pub fn def<'a>(ccx: &CrateContext<'a, 'tcx>, def_id: DefId, substs: &'tcx Substs<'tcx>)
80 if let Some(trait_id) = tcx.trait_of_item(def_id) {
81 return Callee::trait_method(ccx, trait_id, def_id, substs);
84 let fn_ty = def_ty(ccx.shared(), def_id, substs);
85 if let ty::TyFnDef(.., f) = fn_ty.sty {
86 if f.abi == Abi::RustIntrinsic || f.abi == Abi::PlatformIntrinsic {
94 // FIXME(eddyb) Detect ADT constructors more efficiently.
95 if let Some(adt_def) = fn_ty.fn_ret().skip_binder().ty_adt_def() {
96 if let Some(i) = adt_def.variants.iter().position(|v| def_id == v.did) {
98 data: NamedTupleConstructor(Disr::for_variant(tcx, adt_def, i)),
104 let (llfn, ty) = get_fn(ccx, def_id, substs);
105 Callee::ptr(llfn, ty)
108 /// Trait method, which has to be resolved to an impl method.
109 pub fn trait_method<'a>(ccx: &CrateContext<'a, 'tcx>,
112 substs: &'tcx Substs<'tcx>)
116 let trait_ref = ty::TraitRef::from_method(tcx, trait_id, substs);
117 let trait_ref = tcx.normalize_associated_type(&ty::Binder(trait_ref));
118 match common::fulfill_obligation(ccx.shared(), DUMMY_SP, trait_ref) {
119 traits::VtableImpl(vtable_impl) => {
120 let name = tcx.item_name(def_id);
121 let (def_id, substs) = traits::find_method(tcx, name, substs, &vtable_impl);
123 // Translate the function, bypassing Callee::def.
124 // That is because default methods have the same ID as the
125 // trait method used to look up the impl method that ended
126 // up here, so calling Callee::def would infinitely recurse.
127 let (llfn, ty) = get_fn(ccx, def_id, substs);
128 Callee::ptr(llfn, ty)
130 traits::VtableClosure(vtable_closure) => {
131 // The substitutions should have no type parameters remaining
132 // after passing through fulfill_obligation
133 let trait_closure_kind = tcx.lang_items.fn_trait_kind(trait_id).unwrap();
134 let instance = Instance::new(def_id, substs);
135 let llfn = trans_closure_method(
137 vtable_closure.closure_def_id,
138 vtable_closure.substs,
142 let method_ty = def_ty(ccx.shared(), def_id, substs);
143 Callee::ptr(llfn, method_ty)
145 traits::VtableFnPointer(vtable_fn_pointer) => {
146 let trait_closure_kind = tcx.lang_items.fn_trait_kind(trait_id).unwrap();
147 let instance = Instance::new(def_id, substs);
148 let llfn = trans_fn_pointer_shim(ccx, instance,
150 vtable_fn_pointer.fn_ty);
152 let method_ty = def_ty(ccx.shared(), def_id, substs);
153 Callee::ptr(llfn, method_ty)
155 traits::VtableObject(ref data) => {
157 data: Virtual(tcx.get_vtable_index_of_object_method(data, def_id)),
158 ty: def_ty(ccx.shared(), def_id, substs)
162 bug!("resolved vtable bad vtable {:?} in trans", vtable);
167 /// Get the abi::FnType for a direct call. Mainly deals with the fact
168 /// that a Virtual call doesn't take the vtable, like its shim does.
169 /// The extra argument types are for variadic (extern "C") functions.
170 pub fn direct_fn_type<'a>(&self, ccx: &CrateContext<'a, 'tcx>,
171 extra_args: &[Ty<'tcx>]) -> FnType {
172 let abi = self.ty.fn_abi();
173 let sig = ccx.tcx().erase_late_bound_regions_and_normalize(self.ty.fn_sig());
174 let mut fn_ty = FnType::unadjusted(ccx, abi, &sig, extra_args);
175 if let Virtual(_) = self.data {
176 // Don't pass the vtable, it's not an argument of the virtual fn.
177 fn_ty.args[1].ignore();
179 fn_ty.adjust_for_abi(ccx, abi, &sig);
183 /// Turn the callee into a function pointer.
184 pub fn reify<'a>(self, ccx: &CrateContext<'a, 'tcx>) -> ValueRef {
187 Virtual(_) => meth::trans_object_shim(ccx, self),
188 NamedTupleConstructor(disr) => match self.ty.sty {
189 ty::TyFnDef(def_id, substs, _) => {
190 let instance = Instance::new(def_id, substs);
191 if let Some(&llfn) = ccx.instances().borrow().get(&instance) {
195 let sym = ccx.symbol_map().get_or_compute(ccx.shared(),
196 TransItem::Fn(instance));
197 assert!(!ccx.codegen_unit().contains_item(&TransItem::Fn(instance)));
198 let lldecl = declare::define_internal_fn(ccx, &sym, self.ty);
199 base::trans_ctor_shim(ccx, def_id, substs, disr, lldecl);
200 ccx.instances().borrow_mut().insert(instance, lldecl);
204 _ => bug!("expected fn item type, found {}", self.ty)
206 Intrinsic => bug!("intrinsic {} getting reified", self.ty)
211 /// Given a DefId and some Substs, produces the monomorphic item type.
212 fn def_ty<'a, 'tcx>(shared: &SharedCrateContext<'a, 'tcx>,
214 substs: &'tcx Substs<'tcx>)
216 let ty = shared.tcx().item_type(def_id);
217 monomorphize::apply_param_substs(shared, substs, &ty)
221 fn trans_closure_method<'a, 'tcx>(ccx: &'a CrateContext<'a, 'tcx>,
223 substs: ty::ClosureSubsts<'tcx>,
224 method_instance: Instance<'tcx>,
225 trait_closure_kind: ty::ClosureKind)
228 // If this is a closure, redirect to it.
229 let (llfn, _) = get_fn(ccx, def_id, substs.substs);
231 // If the closure is a Fn closure, but a FnOnce is needed (etc),
232 // then adapt the self type
233 let llfn_closure_kind = ccx.tcx().closure_kind(def_id);
235 debug!("trans_closure_adapter_shim(llfn_closure_kind={:?}, \
236 trait_closure_kind={:?}, llfn={:?})",
237 llfn_closure_kind, trait_closure_kind, Value(llfn));
239 match needs_fn_once_adapter_shim(llfn_closure_kind, trait_closure_kind) {
240 Ok(true) => trans_fn_once_adapter_shim(ccx,
247 bug!("trans_closure_adapter_shim: cannot convert {:?} to {:?}",
254 pub fn needs_fn_once_adapter_shim(actual_closure_kind: ty::ClosureKind,
255 trait_closure_kind: ty::ClosureKind)
258 match (actual_closure_kind, trait_closure_kind) {
259 (ty::ClosureKind::Fn, ty::ClosureKind::Fn) |
260 (ty::ClosureKind::FnMut, ty::ClosureKind::FnMut) |
261 (ty::ClosureKind::FnOnce, ty::ClosureKind::FnOnce) => {
262 // No adapter needed.
265 (ty::ClosureKind::Fn, ty::ClosureKind::FnMut) => {
266 // The closure fn `llfn` is a `fn(&self, ...)`. We want a
267 // `fn(&mut self, ...)`. In fact, at trans time, these are
268 // basically the same thing, so we can just return llfn.
271 (ty::ClosureKind::Fn, ty::ClosureKind::FnOnce) |
272 (ty::ClosureKind::FnMut, ty::ClosureKind::FnOnce) => {
273 // The closure fn `llfn` is a `fn(&self, ...)` or `fn(&mut
274 // self, ...)`. We want a `fn(self, ...)`. We can produce
275 // this by doing something like:
277 // fn call_once(self, ...) { call_mut(&self, ...) }
278 // fn call_once(mut self, ...) { call_mut(&mut self, ...) }
280 // These are both the same at trans time.
287 fn trans_fn_once_adapter_shim<'a, 'tcx>(
288 ccx: &'a CrateContext<'a, 'tcx>,
290 substs: ty::ClosureSubsts<'tcx>,
291 method_instance: Instance<'tcx>,
295 if let Some(&llfn) = ccx.instances().borrow().get(&method_instance) {
299 debug!("trans_fn_once_adapter_shim(def_id={:?}, substs={:?}, llreffn={:?})",
300 def_id, substs, Value(llreffn));
304 // Find a version of the closure type. Substitute static for the
305 // region since it doesn't really matter.
306 let closure_ty = tcx.mk_closure_from_closure_substs(def_id, substs);
307 let ref_closure_ty = tcx.mk_imm_ref(tcx.mk_region(ty::ReErased), closure_ty);
309 // Make a version with the type of by-ref closure.
310 let ty::ClosureTy { unsafety, abi, mut sig } = tcx.closure_type(def_id, substs);
311 sig.0 = tcx.mk_fn_sig(
312 iter::once(ref_closure_ty).chain(sig.0.inputs().iter().cloned()),
316 let llref_fn_ty = tcx.mk_fn_ptr(tcx.mk_bare_fn(ty::BareFnTy {
321 debug!("trans_fn_once_adapter_shim: llref_fn_ty={:?}",
325 // Make a version of the closure type with the same arguments, but
326 // with argument #0 being by value.
327 assert_eq!(abi, Abi::RustCall);
328 sig.0 = tcx.mk_fn_sig(
329 iter::once(closure_ty).chain(sig.0.inputs().iter().skip(1).cloned()),
334 let sig = tcx.erase_late_bound_regions_and_normalize(&sig);
335 let fn_ty = FnType::new(ccx, abi, &sig, &[]);
337 let llonce_fn_ty = tcx.mk_fn_ptr(tcx.mk_bare_fn(ty::BareFnTy {
343 // Create the by-value helper.
344 let function_name = method_instance.symbol_name(ccx.shared());
345 let lloncefn = declare::define_internal_fn(ccx, &function_name, llonce_fn_ty);
346 attributes::set_frame_pointer_elimination(ccx, lloncefn);
348 let orig_fn_ty = fn_ty;
349 let mut bcx = Builder::new_block(ccx, lloncefn, "entry-block");
351 let callee = Callee {
356 // the first argument (`self`) will be the (by value) closure env.
358 let mut llargs = get_params(lloncefn);
359 let fn_ret = callee.ty.fn_ret();
360 let fn_ty = callee.direct_fn_type(bcx.ccx, &[]);
361 let self_idx = fn_ty.ret.is_indirect() as usize;
362 let env_arg = &orig_fn_ty.args[0];
363 let env = if env_arg.is_indirect() {
364 LvalueRef::new_sized_ty(llargs[self_idx], closure_ty, Alignment::AbiAligned)
366 let scratch = LvalueRef::alloca(&bcx, closure_ty, "self");
367 let mut llarg_idx = self_idx;
368 env_arg.store_fn_arg(&bcx, &mut llarg_idx, scratch.llval);
372 debug!("trans_fn_once_adapter_shim: env={:?}", env);
373 // Adjust llargs such that llargs[self_idx..] has the call arguments.
374 // For zero-sized closures that means sneaking in a new argument.
375 if env_arg.is_ignore() {
376 llargs.insert(self_idx, env.llval);
378 llargs[self_idx] = env.llval;
381 // Call the by-ref closure body with `self` in a cleanup scope,
382 // to drop `self` when the body returns, or in case it unwinds.
383 let self_scope = CleanupScope::schedule_drop_mem(&bcx, env);
385 let llfn = callee.reify(bcx.ccx);
387 if let Some(landing_pad) = self_scope.landing_pad {
388 let normal_bcx = bcx.build_sibling_block("normal-return");
389 llret = bcx.invoke(llfn, &llargs[..], normal_bcx.llbb(), landing_pad, None);
392 llret = bcx.call(llfn, &llargs[..], None);
394 fn_ty.apply_attrs_callsite(llret);
396 if fn_ret.0.is_never() {
399 self_scope.trans(&bcx);
401 if fn_ty.ret.is_indirect() || fn_ty.ret.is_ignore() {
408 ccx.instances().borrow_mut().insert(method_instance, lloncefn);
413 /// Translates an adapter that implements the `Fn` trait for a fn
414 /// pointer. This is basically the equivalent of something like:
417 /// impl<'a> Fn(&'a int) -> &'a int for fn(&int) -> &int {
418 /// extern "rust-abi" fn call(&self, args: (&'a int,)) -> &'a int {
424 /// but for the bare function type given.
425 fn trans_fn_pointer_shim<'a, 'tcx>(
426 ccx: &'a CrateContext<'a, 'tcx>,
427 method_instance: Instance<'tcx>,
428 closure_kind: ty::ClosureKind,
429 bare_fn_ty: Ty<'tcx>)
434 // Normalize the type for better caching.
435 let bare_fn_ty = tcx.normalize_associated_type(&bare_fn_ty);
437 // If this is an impl of `Fn` or `FnMut` trait, the receiver is `&self`.
438 let is_by_ref = match closure_kind {
439 ty::ClosureKind::Fn | ty::ClosureKind::FnMut => true,
440 ty::ClosureKind::FnOnce => false,
443 let llfnpointer = match bare_fn_ty.sty {
444 ty::TyFnDef(def_id, substs, _) => {
445 // Function definitions have to be turned into a pointer.
446 let llfn = Callee::def(ccx, def_id, substs).reify(ccx);
448 // A by-value fn item is ignored, so the shim has
449 // the same signature as the original function.
457 let bare_fn_ty_maybe_ref = if is_by_ref {
458 tcx.mk_imm_ref(tcx.mk_region(ty::ReErased), bare_fn_ty)
463 // Check if we already trans'd this shim.
464 if let Some(&llval) = ccx.fn_pointer_shims().borrow().get(&bare_fn_ty_maybe_ref) {
468 debug!("trans_fn_pointer_shim(bare_fn_ty={:?})",
471 // Construct the "tuply" version of `bare_fn_ty`. It takes two arguments: `self`,
472 // which is the fn pointer, and `args`, which is the arguments tuple.
473 let sig = match bare_fn_ty.sty {
475 &ty::BareFnTy { unsafety: hir::Unsafety::Normal,
478 ty::TyFnPtr(&ty::BareFnTy { unsafety: hir::Unsafety::Normal,
483 bug!("trans_fn_pointer_shim invoked on invalid type: {}",
487 let sig = tcx.erase_late_bound_regions_and_normalize(sig);
488 let tuple_input_ty = tcx.intern_tup(sig.inputs(), false);
489 let sig = tcx.mk_fn_sig(
490 [bare_fn_ty_maybe_ref, tuple_input_ty].iter().cloned(),
494 let fn_ty = FnType::new(ccx, Abi::RustCall, &sig, &[]);
495 let tuple_fn_ty = tcx.mk_fn_ptr(tcx.mk_bare_fn(ty::BareFnTy {
496 unsafety: hir::Unsafety::Normal,
500 debug!("tuple_fn_ty: {:?}", tuple_fn_ty);
503 let function_name = method_instance.symbol_name(ccx.shared());
504 let llfn = declare::define_internal_fn(ccx, &function_name, tuple_fn_ty);
505 attributes::set_frame_pointer_elimination(ccx, llfn);
507 let bcx = Builder::new_block(ccx, llfn, "entry-block");
509 let mut llargs = get_params(llfn);
511 let self_arg = llargs.remove(fn_ty.ret.is_indirect() as usize);
512 let llfnpointer = llfnpointer.unwrap_or_else(|| {
513 // the first argument (`self`) will be ptr to the fn pointer
515 bcx.load(self_arg, None)
521 let callee = Callee {
522 data: Fn(llfnpointer),
525 let fn_ret = callee.ty.fn_ret();
526 let fn_ty = callee.direct_fn_type(ccx, &[]);
527 let llret = bcx.call(llfnpointer, &llargs, None);
528 fn_ty.apply_attrs_callsite(llret);
530 if fn_ret.0.is_never() {
533 if fn_ty.ret.is_indirect() || fn_ty.ret.is_ignore() {
540 ccx.fn_pointer_shims().borrow_mut().insert(bare_fn_ty_maybe_ref, llfn);
545 /// Translates a reference to a fn/method item, monomorphizing and
546 /// inlining as it goes.
550 /// - `ccx`: the crate context
551 /// - `def_id`: def id of the fn or method item being referenced
552 /// - `substs`: values for each of the fn/method's parameters
553 fn get_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
555 substs: &'tcx Substs<'tcx>)
556 -> (ValueRef, Ty<'tcx>) {
559 debug!("get_fn(def_id={:?}, substs={:?})", def_id, substs);
561 assert!(!substs.needs_infer());
562 assert!(!substs.has_escaping_regions());
563 assert!(!substs.has_param_types());
565 let substs = tcx.normalize_associated_type(&substs);
566 let instance = Instance::new(def_id, substs);
567 let item_ty = ccx.tcx().item_type(def_id);
568 let fn_ty = monomorphize::apply_param_substs(ccx.shared(), substs, &item_ty);
570 if let Some(&llfn) = ccx.instances().borrow().get(&instance) {
571 return (llfn, fn_ty);
574 let sym = ccx.symbol_map().get_or_compute(ccx.shared(),
575 TransItem::Fn(instance));
576 debug!("get_fn({:?}: {:?}) => {}", instance, fn_ty, sym);
578 // This is subtle and surprising, but sometimes we have to bitcast
579 // the resulting fn pointer. The reason has to do with external
580 // functions. If you have two crates that both bind the same C
581 // library, they may not use precisely the same types: for
582 // example, they will probably each declare their own structs,
583 // which are distinct types from LLVM's point of view (nominal
586 // Now, if those two crates are linked into an application, and
587 // they contain inlined code, you can wind up with a situation
588 // where both of those functions wind up being loaded into this
589 // application simultaneously. In that case, the same function
590 // (from LLVM's point of view) requires two types. But of course
591 // LLVM won't allow one function to have two types.
593 // What we currently do, therefore, is declare the function with
594 // one of the two types (whichever happens to come first) and then
595 // bitcast as needed when the function is referenced to make sure
596 // it has the type we expect.
598 // This can occur on either a crate-local or crate-external
599 // reference. It also occurs when testing libcore and in some
600 // other weird situations. Annoying.
602 // Create a fn pointer with the substituted signature.
603 let fn_ptr_ty = tcx.mk_fn_ptr(tcx.mk_bare_fn(common::ty_fn_ty(ccx, fn_ty).into_owned()));
604 let llptrty = type_of::type_of(ccx, fn_ptr_ty);
606 let llfn = if let Some(llfn) = declare::get_declared_value(ccx, &sym) {
607 if common::val_ty(llfn) != llptrty {
608 debug!("get_fn: casting {:?} to {:?}", llfn, llptrty);
609 consts::ptrcast(llfn, llptrty)
611 debug!("get_fn: not casting pointer!");
615 let llfn = declare::declare_fn(ccx, &sym, fn_ty);
616 assert_eq!(common::val_ty(llfn), llptrty);
617 debug!("get_fn: not casting pointer!");
619 let attrs = ccx.tcx().get_attrs(def_id);
620 attributes::from_fn_attrs(ccx, &attrs, llfn);
622 let is_local_def = ccx.shared().translation_items().borrow()
623 .contains(&TransItem::Fn(instance));
625 // FIXME(eddyb) Doubt all extern fn should allow unwinding.
626 attributes::unwind(llfn, true);
628 llvm::LLVMRustSetLinkage(llfn, llvm::Linkage::ExternalLinkage);
631 if ccx.use_dll_storage_attrs() && ccx.sess().cstore.is_dllimport_foreign_item(def_id) {
633 llvm::LLVMSetDLLStorageClass(llfn, llvm::DLLStorageClass::DllImport);
639 ccx.instances().borrow_mut().insert(instance, llfn);