src/librustc/middle/trans/monomorphize.rs

   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.
   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 back::link::exported_name;
  12 use driver::session;
  13 use lib::llvm::ValueRef;
  14 use middle::subst;
  15 use middle::subst::Subst;
  16 use middle::trans::base::{set_llvm_fn_attrs, set_inline_hint};
  17 use middle::trans::base::{trans_enum_variant, push_ctxt, get_item_val};
  18 use middle::trans::base::{trans_fn, decl_internal_rust_fn};
  19 use middle::trans::base;
  20 use middle::trans::common::*;
  21 use middle::ty;
  22 use middle::typeck;
  23 use util::ppaux::Repr;
  24
  25 use syntax::abi;
  26 use syntax::ast;
  27 use syntax::ast_map;
  28 use syntax::ast_util;
  29 use syntax::ast_util::local_def;
  30 use std::hash::{sip, Hash};
  31
  32 pub fn monomorphic_fn(ccx: &CrateContext,
  33                       fn_id: ast::DefId,
  34                       real_substs: &subst::Substs,
  35                       vtables: typeck::vtable_res,
  36                       ref_id: Option<ast::NodeId>)
  37     -> (ValueRef, bool) {
  38     debug!("monomorphic_fn(\
  39             fn_id={}, \
  40             real_substs={}, \
  41             vtables={}, \
  42             ref_id={:?})",
  43            fn_id.repr(ccx.tcx()),
  44            real_substs.repr(ccx.tcx()),
  45            vtables.repr(ccx.tcx()),
  46            ref_id);
  47
  48     assert!(real_substs.types.all(|t| {
  49         !ty::type_needs_infer(*t) && !ty::type_has_params(*t)
  50     }));
  51
  52     let _icx = push_ctxt("monomorphic_fn");
  53
  54     let hash_id = MonoId {
  55         def: fn_id,
  56         params: real_substs.types.clone()
  57     };
  58
  59     match ccx.monomorphized.borrow().find(&hash_id) {
  60         Some(&val) => {
  61             debug!("leaving monomorphic fn {}",
  62             ty::item_path_str(ccx.tcx(), fn_id));
  63             return (val, false);
  64         }
  65         None => ()
  66     }
  67
  68     let psubsts = param_substs {
  69         substs: (*real_substs).clone(),
  70         vtables: vtables,
  71     };
  72
  73     debug!("monomorphic_fn(\
  74             fn_id={}, \
  75             psubsts={}, \
  76             hash_id={:?})",
  77            fn_id.repr(ccx.tcx()),
  78            psubsts.repr(ccx.tcx()),
  79            hash_id);
  80
  81     let tpt = ty::lookup_item_type(ccx.tcx(), fn_id);
  82     let llitem_ty = tpt.ty;
  83
  84     let map_node = session::expect(
  85         ccx.sess(),
  86         ccx.tcx.map.find(fn_id.node),
  87         || {
  88             format!("while monomorphizing {:?}, couldn't find it in \
  89                      the item map (may have attempted to monomorphize \
  90                      an item defined in a different crate?)",
  91                     fn_id)
  92         });
  93
  94     match map_node {
  95         ast_map::NodeForeignItem(_) => {
  96             if ccx.tcx.map.get_foreign_abi(fn_id.node) != abi::RustIntrinsic {
  97                 // Foreign externs don't have to be monomorphized.
  98                 return (get_item_val(ccx, fn_id.node), true);
  99             }
 100         }
 101         _ => {}
 102     }
 103
 104     debug!("monomorphic_fn about to subst into {}", llitem_ty.repr(ccx.tcx()));
 105     let mono_ty = llitem_ty.subst(ccx.tcx(), real_substs);
 106
 107     ccx.stats.n_monos.set(ccx.stats.n_monos.get() + 1);
 108
 109     let depth;
 110     {
 111         let mut monomorphizing = ccx.monomorphizing.borrow_mut();
 112         depth = match monomorphizing.find(&fn_id) {
 113             Some(&d) => d, None => 0
 114         };
 115
 116         // Random cut-off -- code that needs to instantiate the same function
 117         // recursively more than thirty times can probably safely be assumed
 118         // to be causing an infinite expansion.
 119         if depth > ccx.sess().recursion_limit.get() {
 120             ccx.sess().span_fatal(ccx.tcx.map.span(fn_id.node),
 121                 "reached the recursion limit during monomorphization");
 122         }
 123
 124         monomorphizing.insert(fn_id, depth + 1);
 125     }
 126
 127     let s = ccx.tcx.map.with_path(fn_id.node, |path| {
 128         let mut state = sip::SipState::new();
 129         hash_id.hash(&mut state);
 130         mono_ty.hash(&mut state);
 131
 132         exported_name(path, format!("h{}", state.result()).as_slice())
 133     });
 134     debug!("monomorphize_fn mangled to {}", s);
 135
 136     // This shouldn't need to option dance.
 137     let mut hash_id = Some(hash_id);
 138     let mk_lldecl = || {
 139         let lldecl = decl_internal_rust_fn(ccx, mono_ty, s.as_slice());
 140         ccx.monomorphized.borrow_mut().insert(hash_id.take_unwrap(), lldecl);
 141         lldecl
 142     };
 143
 144     let lldecl = match map_node {
 145         ast_map::NodeItem(i) => {
 146             match *i {
 147               ast::Item {
 148                   node: ast::ItemFn(ref decl, _, _, _, ref body),
 149                   ..
 150               } => {
 151                   let d = mk_lldecl();
 152                   set_llvm_fn_attrs(i.attrs.as_slice(), d);
 153                   trans_fn(ccx, &**decl, &**body, d, &psubsts, fn_id.node, []);
 154                   d
 155               }
 156               _ => {
 157                 ccx.sess().bug("Can't monomorphize this kind of item")
 158               }
 159             }
 160         }
 161         ast_map::NodeVariant(v) => {
 162             let parent = ccx.tcx.map.get_parent(fn_id.node);
 163             let tvs = ty::enum_variants(ccx.tcx(), local_def(parent));
 164             let this_tv = tvs.iter().find(|tv| { tv.id.node == fn_id.node}).unwrap();
 165             let d = mk_lldecl();
 166             set_inline_hint(d);
 167             match v.node.kind {
 168                 ast::TupleVariantKind(ref args) => {
 169                     trans_enum_variant(ccx,
 170                                        parent,
 171                                        &*v,
 172                                        args.as_slice(),
 173                                        this_tv.disr_val,
 174                                        &psubsts,
 175                                        d);
 176                 }
 177                 ast::StructVariantKind(_) =>
 178                     ccx.sess().bug("can't monomorphize struct variants"),
 179             }
 180             d
 181         }
 182         ast_map::NodeMethod(mth) => {
 183             let d = mk_lldecl();
 184             set_llvm_fn_attrs(mth.attrs.as_slice(), d);
 185             trans_fn(ccx, ast_util::method_fn_decl(&*mth),
 186                      ast_util::method_body(&*mth), d, &psubsts, mth.id, []);
 187             d
 188         }
 189         ast_map::NodeTraitMethod(method) => {
 190             match *method {
 191                 ast::Provided(mth) => {
 192                     let d = mk_lldecl();
 193                     set_llvm_fn_attrs(mth.attrs.as_slice(), d);
 194                     trans_fn(ccx, ast_util::method_fn_decl(&*mth),
 195                              ast_util::method_body(&*mth), d, &psubsts, mth.id, []);
 196                     d
 197                 }
 198                 _ => {
 199                     ccx.sess().bug(format!("can't monomorphize a {:?}",
 200                                            map_node).as_slice())
 201                 }
 202             }
 203         }
 204         ast_map::NodeStructCtor(struct_def) => {
 205             let d = mk_lldecl();
 206             set_inline_hint(d);
 207             base::trans_tuple_struct(ccx,
 208                                      struct_def.fields.as_slice(),
 209                                      struct_def.ctor_id.expect("ast-mapped tuple struct \
 210                                                                 didn't have a ctor id"),
 211                                      &psubsts,
 212                                      d);
 213             d
 214         }
 215
 216         // Ugh -- but this ensures any new variants won't be forgotten
 217         ast_map::NodeForeignItem(..) |
 218         ast_map::NodeLifetime(..) |
 219         ast_map::NodeExpr(..) |
 220         ast_map::NodeStmt(..) |
 221         ast_map::NodeArg(..) |
 222         ast_map::NodeBlock(..) |
 223         ast_map::NodePat(..) |
 224         ast_map::NodeLocal(..) => {
 225             ccx.sess().bug(format!("can't monomorphize a {:?}",
 226                                    map_node).as_slice())
 227         }
 228     };
 229
 230     ccx.monomorphizing.borrow_mut().insert(fn_id, depth);
 231
 232     debug!("leaving monomorphic fn {}", ty::item_path_str(ccx.tcx(), fn_id));
 233     (lldecl, false)
 234 }
 235
 236 // Used to identify cached monomorphized functions and vtables
 237 #[deriving(PartialEq, Eq, Hash)]
 238 pub struct MonoParamId {
 239     pub subst: ty::t,
 240 }
 241
 242 #[deriving(PartialEq, Eq, Hash)]
 243 pub struct MonoId {
 244     pub def: ast::DefId,
 245     pub params: subst::VecPerParamSpace<ty::t>
 246 }
 247
 248 pub fn make_vtable_id(_ccx: &CrateContext,
 249                       origin: &typeck::vtable_origin)
 250                       -> MonoId {
 251     match origin {
 252         &typeck::vtable_static(impl_id, ref substs, _) => {
 253             MonoId {
 254                 def: impl_id,
 255                 params: substs.types.clone()
 256             }
 257         }
 258
 259         // can't this be checked at the callee?
 260         _ => fail!("make_vtable_id needs vtable_static")
 261     }
 262 }