350 lines
12 KiB
Rust
350 lines
12 KiB
Rust
// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
|
|
// file at the top-level directory of this distribution and at
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
|
|
use back::link::exported_name;
|
|
use driver::session;
|
|
use lib::llvm::ValueRef;
|
|
use middle::trans::base::{set_llvm_fn_attrs, set_inline_hint};
|
|
use middle::trans::base::{trans_enum_variant, push_ctxt, get_item_val};
|
|
use middle::trans::base::{trans_fn, decl_internal_rust_fn};
|
|
use middle::trans::base;
|
|
use middle::trans::common::*;
|
|
use middle::trans::intrinsic;
|
|
use middle::ty;
|
|
use middle::typeck;
|
|
use util::ppaux::Repr;
|
|
|
|
use syntax::abi;
|
|
use syntax::ast;
|
|
use syntax::ast_map;
|
|
use syntax::ast_util::local_def;
|
|
use std::hash::{sip, Hash};
|
|
|
|
pub fn monomorphic_fn(ccx: &CrateContext,
|
|
fn_id: ast::DefId,
|
|
real_substs: &ty::substs,
|
|
vtables: Option<typeck::vtable_res>,
|
|
self_vtables: Option<typeck::vtable_param_res>,
|
|
ref_id: Option<ast::NodeId>)
|
|
-> (ValueRef, bool) {
|
|
debug!("monomorphic_fn(\
|
|
fn_id={}, \
|
|
real_substs={}, \
|
|
vtables={}, \
|
|
self_vtable={}, \
|
|
ref_id={:?})",
|
|
fn_id.repr(ccx.tcx()),
|
|
real_substs.repr(ccx.tcx()),
|
|
vtables.repr(ccx.tcx()),
|
|
self_vtables.repr(ccx.tcx()),
|
|
ref_id);
|
|
|
|
assert!(real_substs.tps.iter().all(|t| {
|
|
!ty::type_needs_infer(*t) && !ty::type_has_params(*t)
|
|
}));
|
|
|
|
let _icx = push_ctxt("monomorphic_fn");
|
|
|
|
let substs_iter = real_substs.self_ty.iter().chain(real_substs.tps.iter());
|
|
let param_ids: Vec<MonoParamId> = match vtables {
|
|
Some(ref vts) => {
|
|
debug!("make_mono_id vtables={} psubsts={}",
|
|
vts.repr(ccx.tcx()), real_substs.tps.repr(ccx.tcx()));
|
|
let vts_iter = self_vtables.iter().chain(vts.iter());
|
|
vts_iter.zip(substs_iter).map(|(vtable, subst)| MonoParamId {
|
|
subst: *subst,
|
|
// Do we really need the vtables to be hashed? Isn't the type enough?
|
|
vtables: vtable.iter().map(|vt| make_vtable_id(ccx, vt)).collect()
|
|
}).collect()
|
|
}
|
|
None => substs_iter.map(|subst| MonoParamId {
|
|
subst: *subst,
|
|
vtables: Vec::new()
|
|
}).collect()
|
|
};
|
|
|
|
let hash_id = MonoId {
|
|
def: fn_id,
|
|
params: param_ids
|
|
};
|
|
|
|
match ccx.monomorphized.borrow().find(&hash_id) {
|
|
Some(&val) => {
|
|
debug!("leaving monomorphic fn {}",
|
|
ty::item_path_str(ccx.tcx(), fn_id));
|
|
return (val, false);
|
|
}
|
|
None => ()
|
|
}
|
|
|
|
let psubsts = param_substs {
|
|
tys: real_substs.tps.clone(),
|
|
vtables: vtables,
|
|
self_ty: real_substs.self_ty.clone(),
|
|
self_vtables: self_vtables
|
|
};
|
|
|
|
debug!("monomorphic_fn(\
|
|
fn_id={}, \
|
|
psubsts={}, \
|
|
hash_id={:?})",
|
|
fn_id.repr(ccx.tcx()),
|
|
psubsts.repr(ccx.tcx()),
|
|
hash_id);
|
|
|
|
let tpt = ty::lookup_item_type(ccx.tcx(), fn_id);
|
|
let llitem_ty = tpt.ty;
|
|
|
|
// We need to do special handling of the substitutions if we are
|
|
// calling a static provided method. This is sort of unfortunate.
|
|
let mut is_static_provided = None;
|
|
|
|
let map_node = session::expect(
|
|
ccx.sess(),
|
|
ccx.tcx.map.find(fn_id.node),
|
|
|| {
|
|
(format!("while monomorphizing {:?}, couldn't find it in the \
|
|
item map (may have attempted to monomorphize an item \
|
|
defined in a different crate?)", fn_id)).to_strbuf()
|
|
});
|
|
|
|
match map_node {
|
|
ast_map::NodeForeignItem(_) => {
|
|
if ccx.tcx.map.get_foreign_abi(fn_id.node) != abi::RustIntrinsic {
|
|
// Foreign externs don't have to be monomorphized.
|
|
return (get_item_val(ccx, fn_id.node), true);
|
|
}
|
|
}
|
|
ast_map::NodeTraitMethod(method) => {
|
|
match *method {
|
|
ast::Provided(m) => {
|
|
// If this is a static provided method, indicate that
|
|
// and stash the number of params on the method.
|
|
if m.explicit_self.node == ast::SelfStatic {
|
|
is_static_provided = Some(m.generics.ty_params.len());
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
|
|
debug!("monomorphic_fn about to subst into {}", llitem_ty.repr(ccx.tcx()));
|
|
let mono_ty = match is_static_provided {
|
|
None => ty::subst_tps(ccx.tcx(), real_substs.tps.as_slice(),
|
|
real_substs.self_ty, llitem_ty),
|
|
Some(num_method_ty_params) => {
|
|
// Static default methods are a little unfortunate, in
|
|
// that the "internal" and "external" type of them differ.
|
|
// Internally, the method body can refer to Self, but the
|
|
// externally visible type of the method has a type param
|
|
// inserted in between the trait type params and the
|
|
// method type params. The substs that we are given are
|
|
// the proper substs *internally* to the method body, so
|
|
// we have to use those when compiling it.
|
|
//
|
|
// In order to get the proper substitution to use on the
|
|
// type of the method, we pull apart the substitution and
|
|
// stick a substitution for the self type in.
|
|
// This is a bit unfortunate.
|
|
|
|
let idx = real_substs.tps.len() - num_method_ty_params;
|
|
let substs = real_substs.tps.slice(0, idx) +
|
|
&[real_substs.self_ty.unwrap()] + real_substs.tps.tailn(idx);
|
|
debug!("static default: changed substitution to {}",
|
|
substs.repr(ccx.tcx()));
|
|
|
|
ty::subst_tps(ccx.tcx(), substs, None, llitem_ty)
|
|
}
|
|
};
|
|
|
|
let f = match ty::get(mono_ty).sty {
|
|
ty::ty_bare_fn(ref f) => {
|
|
assert!(f.abi == abi::Rust || f.abi == abi::RustIntrinsic);
|
|
f
|
|
}
|
|
_ => fail!("expected bare rust fn or an intrinsic")
|
|
};
|
|
|
|
ccx.stats.n_monos.set(ccx.stats.n_monos.get() + 1);
|
|
|
|
let depth;
|
|
{
|
|
let mut monomorphizing = ccx.monomorphizing.borrow_mut();
|
|
depth = match monomorphizing.find(&fn_id) {
|
|
Some(&d) => d, None => 0
|
|
};
|
|
|
|
// Random cut-off -- code that needs to instantiate the same function
|
|
// recursively more than thirty times can probably safely be assumed
|
|
// to be causing an infinite expansion.
|
|
if depth > ccx.sess().recursion_limit.get() {
|
|
ccx.sess().span_fatal(ccx.tcx.map.span(fn_id.node),
|
|
"reached the recursion limit during monomorphization");
|
|
}
|
|
|
|
monomorphizing.insert(fn_id, depth + 1);
|
|
}
|
|
|
|
let s = ccx.tcx.map.with_path(fn_id.node, |path| {
|
|
let mut state = sip::SipState::new();
|
|
hash_id.hash(&mut state);
|
|
mono_ty.hash(&mut state);
|
|
|
|
exported_name(path, format!("h{}", state.result()),
|
|
ccx.link_meta.crateid.version_or_default())
|
|
});
|
|
debug!("monomorphize_fn mangled to {}", s);
|
|
|
|
// This shouldn't need to option dance.
|
|
let mut hash_id = Some(hash_id);
|
|
let mk_lldecl = || {
|
|
let lldecl = decl_internal_rust_fn(ccx, false,
|
|
f.sig.inputs.as_slice(),
|
|
f.sig.output, s);
|
|
ccx.monomorphized.borrow_mut().insert(hash_id.take_unwrap(), lldecl);
|
|
lldecl
|
|
};
|
|
|
|
let lldecl = match map_node {
|
|
ast_map::NodeItem(i) => {
|
|
match *i {
|
|
ast::Item {
|
|
node: ast::ItemFn(decl, _, _, _, body),
|
|
..
|
|
} => {
|
|
let d = mk_lldecl();
|
|
set_llvm_fn_attrs(i.attrs.as_slice(), d);
|
|
trans_fn(ccx, decl, body, d, Some(&psubsts), fn_id.node, []);
|
|
d
|
|
}
|
|
_ => {
|
|
ccx.sess().bug("Can't monomorphize this kind of item")
|
|
}
|
|
}
|
|
}
|
|
ast_map::NodeForeignItem(i) => {
|
|
let simple = intrinsic::get_simple_intrinsic(ccx, i);
|
|
match simple {
|
|
Some(decl) => decl,
|
|
None => {
|
|
let d = mk_lldecl();
|
|
intrinsic::trans_intrinsic(ccx, d, i, &psubsts, ref_id);
|
|
d
|
|
}
|
|
}
|
|
}
|
|
ast_map::NodeVariant(v) => {
|
|
let parent = ccx.tcx.map.get_parent(fn_id.node);
|
|
let tvs = ty::enum_variants(ccx.tcx(), local_def(parent));
|
|
let this_tv = tvs.iter().find(|tv| { tv.id.node == fn_id.node}).unwrap();
|
|
let d = mk_lldecl();
|
|
set_inline_hint(d);
|
|
match v.node.kind {
|
|
ast::TupleVariantKind(ref args) => {
|
|
trans_enum_variant(ccx,
|
|
parent,
|
|
v,
|
|
args.as_slice(),
|
|
this_tv.disr_val,
|
|
Some(&psubsts),
|
|
d);
|
|
}
|
|
ast::StructVariantKind(_) =>
|
|
ccx.sess().bug("can't monomorphize struct variants"),
|
|
}
|
|
d
|
|
}
|
|
ast_map::NodeMethod(mth) => {
|
|
let d = mk_lldecl();
|
|
set_llvm_fn_attrs(mth.attrs.as_slice(), d);
|
|
trans_fn(ccx, mth.decl, mth.body, d, Some(&psubsts), mth.id, []);
|
|
d
|
|
}
|
|
ast_map::NodeTraitMethod(method) => {
|
|
match *method {
|
|
ast::Provided(mth) => {
|
|
let d = mk_lldecl();
|
|
set_llvm_fn_attrs(mth.attrs.as_slice(), d);
|
|
trans_fn(ccx, mth.decl, mth.body, d, Some(&psubsts), mth.id, []);
|
|
d
|
|
}
|
|
_ => {
|
|
ccx.sess().bug(format!("can't monomorphize a {:?}",
|
|
map_node))
|
|
}
|
|
}
|
|
}
|
|
ast_map::NodeStructCtor(struct_def) => {
|
|
let d = mk_lldecl();
|
|
set_inline_hint(d);
|
|
base::trans_tuple_struct(ccx,
|
|
struct_def.fields.as_slice(),
|
|
struct_def.ctor_id.expect("ast-mapped tuple struct \
|
|
didn't have a ctor id"),
|
|
Some(&psubsts),
|
|
d);
|
|
d
|
|
}
|
|
|
|
// Ugh -- but this ensures any new variants won't be forgotten
|
|
ast_map::NodeLifetime(..) |
|
|
ast_map::NodeExpr(..) |
|
|
ast_map::NodeStmt(..) |
|
|
ast_map::NodeArg(..) |
|
|
ast_map::NodeBlock(..) |
|
|
ast_map::NodeLocal(..) => {
|
|
ccx.sess().bug(format!("can't monomorphize a {:?}", map_node))
|
|
}
|
|
};
|
|
|
|
ccx.monomorphizing.borrow_mut().insert(fn_id, depth);
|
|
|
|
debug!("leaving monomorphic fn {}", ty::item_path_str(ccx.tcx(), fn_id));
|
|
(lldecl, false)
|
|
}
|
|
|
|
// Used to identify cached monomorphized functions and vtables
|
|
#[deriving(Eq, TotalEq, Hash)]
|
|
pub struct MonoParamId {
|
|
pub subst: ty::t,
|
|
// Do we really need the vtables to be hashed? Isn't the type enough?
|
|
pub vtables: Vec<MonoId>
|
|
}
|
|
|
|
#[deriving(Eq, TotalEq, Hash)]
|
|
pub struct MonoId {
|
|
pub def: ast::DefId,
|
|
pub params: Vec<MonoParamId>
|
|
}
|
|
|
|
pub fn make_vtable_id(ccx: &CrateContext,
|
|
origin: &typeck::vtable_origin)
|
|
-> MonoId {
|
|
match origin {
|
|
&typeck::vtable_static(impl_id, ref substs, ref sub_vtables) => {
|
|
MonoId {
|
|
def: impl_id,
|
|
params: sub_vtables.iter().zip(substs.iter()).map(|(vtable, subst)| {
|
|
MonoParamId {
|
|
subst: *subst,
|
|
// Do we really need the vtables to be hashed? Isn't the type enough?
|
|
vtables: vtable.iter().map(|vt| make_vtable_id(ccx, vt)).collect()
|
|
}
|
|
}).collect()
|
|
}
|
|
}
|
|
|
|
// can't this be checked at the callee?
|
|
_ => fail!("make_vtable_id needs vtable_static")
|
|
}
|
|
}
|