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::trans::intrinsic;
  22 use middle::ty;
  23 use middle::typeck;
  24 use util::ppaux::Repr;
  25
  26 use syntax::abi;
  27 use syntax::ast;
  28 use syntax::ast_map;
  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::NodeForeignItem(i) => {
 162             let simple = intrinsic::get_simple_intrinsic(ccx, &*i);
 163             match simple {
 164                 Some(decl) => decl,
 165                 None => {
 166                     let d = mk_lldecl();
 167                     intrinsic::trans_intrinsic(ccx, d, &*i, &psubsts, ref_id);
 168                     d
 169                 }
 170             }
 171         }
 172         ast_map::NodeVariant(v) => {
 173             let parent = ccx.tcx.map.get_parent(fn_id.node);
 174             let tvs = ty::enum_variants(ccx.tcx(), local_def(parent));
 175             let this_tv = tvs.iter().find(|tv| { tv.id.node == fn_id.node}).unwrap();
 176             let d = mk_lldecl();
 177             set_inline_hint(d);
 178             match v.node.kind {
 179                 ast::TupleVariantKind(ref args) => {
 180                     trans_enum_variant(ccx,
 181                                        parent,
 182                                        &*v,
 183                                        args.as_slice(),
 184                                        this_tv.disr_val,
 185                                        &psubsts,
 186                                        d);
 187                 }
 188                 ast::StructVariantKind(_) =>
 189                     ccx.sess().bug("can't monomorphize struct variants"),
 190             }
 191             d
 192         }
 193         ast_map::NodeMethod(mth) => {
 194             let d = mk_lldecl();
 195             set_llvm_fn_attrs(mth.attrs.as_slice(), d);
 196             trans_fn(ccx, &*mth.decl, &*mth.body, d, &psubsts, mth.id, []);
 197             d
 198         }
 199         ast_map::NodeTraitMethod(method) => {
 200             match *method {
 201                 ast::Provided(mth) => {
 202                     let d = mk_lldecl();
 203                     set_llvm_fn_attrs(mth.attrs.as_slice(), d);
 204                     trans_fn(ccx, &*mth.decl, &*mth.body, d, &psubsts, mth.id, []);
 205                     d
 206                 }
 207                 _ => {
 208                     ccx.sess().bug(format!("can't monomorphize a {:?}",
 209                                            map_node).as_slice())
 210                 }
 211             }
 212         }
 213         ast_map::NodeStructCtor(struct_def) => {
 214             let d = mk_lldecl();
 215             set_inline_hint(d);
 216             base::trans_tuple_struct(ccx,
 217                                      struct_def.fields.as_slice(),
 218                                      struct_def.ctor_id.expect("ast-mapped tuple struct \
 219                                                                 didn't have a ctor id"),
 220                                      &psubsts,
 221                                      d);
 222             d
 223         }
 224
 225         // Ugh -- but this ensures any new variants won't be forgotten
 226         ast_map::NodeLifetime(..) |
 227         ast_map::NodeExpr(..) |
 228         ast_map::NodeStmt(..) |
 229         ast_map::NodeArg(..) |
 230         ast_map::NodeBlock(..) |
 231         ast_map::NodePat(..) |
 232         ast_map::NodeLocal(..) => {
 233             ccx.sess().bug(format!("can't monomorphize a {:?}",
 234                                    map_node).as_slice())
 235         }
 236     };
 237
 238     ccx.monomorphizing.borrow_mut().insert(fn_id, depth);
 239
 240     debug!("leaving monomorphic fn {}", ty::item_path_str(ccx.tcx(), fn_id));
 241     (lldecl, false)
 242 }
 243
 244 // Used to identify cached monomorphized functions and vtables
 245 #[deriving(PartialEq, Eq, Hash)]
 246 pub struct MonoParamId {
 247     pub subst: ty::t,
 248 }
 249
 250 #[deriving(PartialEq, Eq, Hash)]
 251 pub struct MonoId {
 252     pub def: ast::DefId,
 253     pub params: subst::VecPerParamSpace<ty::t>
 254 }
 255
 256 pub fn make_vtable_id(_ccx: &CrateContext,
 257                       origin: &typeck::vtable_origin)
 258                       -> MonoId {
 259     match origin {
 260         &typeck::vtable_static(impl_id, ref substs, _) => {
 261             MonoId {
 262                 def: impl_id,
 263                 params: substs.types.clone()
 264             }
 265         }
 266
 267         // can't this be checked at the callee?
 268         _ => fail!("make_vtable_id needs vtable_static")
 269     }
 270 }