use glue::DropGlueKind;
use llvm;
use monomorphize::{self, Instance};
-use inline;
use rustc::dep_graph::DepNode;
use rustc::hir;
-use rustc::hir::map as hir_map;
use rustc::hir::def_id::DefId;
use rustc::ty::{self, Ty, TyCtxt, TypeFoldable};
use rustc::ty::subst::Substs;
use rustc_const_eval::fatal_const_eval_err;
use std::hash::{Hash, Hasher};
use syntax::ast::{self, NodeId};
-use syntax::{attr,errors};
+use syntax::attr;
use type_of;
use glue;
use abi::{Abi, FnType};
let ty = ccx.tcx().lookup_item_type(def_id).ty;
let llty = type_of::type_of(ccx, ty);
- match ccx.tcx().map.get(node_id) {
- hir::map::NodeItem(&hir::Item {
- span, node: hir::ItemStatic(..), ..
- }) => {
- let g = declare::define_global(ccx, symbol_name, llty).unwrap_or_else(|| {
- ccx.sess().span_fatal(span,
- &format!("symbol `{}` is already defined", symbol_name))
- });
+ let g = declare::define_global(ccx, symbol_name, llty).unwrap_or_else(|| {
+ ccx.sess().span_fatal(ccx.tcx().map.span(node_id),
+ &format!("symbol `{}` is already defined", symbol_name))
+ });
- unsafe { llvm::LLVMSetLinkage(g, linkage) };
- }
+ unsafe { llvm::LLVMSetLinkage(g, linkage) };
- item => bug!("predefine_static: expected static, found {:?}", item)
- }
+ let instance = Instance::mono(ccx.shared(), def_id);
+ ccx.instances().borrow_mut().insert(instance, g);
+ ccx.statics().borrow_mut().insert(g, def_id);
}
fn predefine_fn(ccx: &CrateContext<'a, 'tcx>,
instance: Instance<'tcx>,
linkage: llvm::Linkage,
symbol_name: &str) {
- assert!(!instance.substs.types.needs_infer() &&
- !instance.substs.types.has_param_types());
-
- let instance = inline::maybe_inline_instance(ccx, instance);
+ assert!(!instance.substs.needs_infer() &&
+ !instance.substs.has_param_types());
let item_ty = ccx.tcx().lookup_item_type(instance.def).ty;
let item_ty = ccx.tcx().erase_regions(&item_ty);
- let mono_ty = monomorphize::apply_param_substs(ccx.tcx(), instance.substs, &item_ty);
-
- let fn_node_id = ccx.tcx().map.as_local_node_id(instance.def).unwrap();
- let map_node = errors::expect(
- ccx.sess().diagnostic(),
- ccx.tcx().map.find(fn_node_id),
- || {
- format!("while instantiating `{}`, couldn't find it in \
- the item map (may have attempted to monomorphize \
- an item defined in a different crate?)",
- instance)
- });
-
- match map_node {
- hir_map::NodeItem(&hir::Item {
- ref attrs, node: hir::ItemFn(..), ..
- }) |
- hir_map::NodeTraitItem(&hir::TraitItem {
- ref attrs, node: hir::MethodTraitItem(..), ..
- }) |
- hir_map::NodeImplItem(&hir::ImplItem {
- ref attrs, node: hir::ImplItemKind::Method(..), ..
- }) => {
- let lldecl = declare::declare_fn(ccx, symbol_name, mono_ty);
- unsafe { llvm::LLVMSetLinkage(lldecl, linkage) };
- base::set_link_section(ccx, lldecl, attrs);
- if linkage == llvm::LinkOnceODRLinkage ||
- linkage == llvm::WeakODRLinkage {
- llvm::SetUniqueComdat(ccx.llmod(), lldecl);
- }
+ let mono_ty = monomorphize::apply_param_substs(ccx.shared(), instance.substs, &item_ty);
- attributes::from_fn_attrs(ccx, attrs, lldecl);
- ccx.instances().borrow_mut().insert(instance, lldecl);
- }
- _ => bug!("Invalid item for TransItem::Fn: `{:?}`", map_node)
- };
+ let attrs = ccx.tcx().get_attrs(instance.def);
+ let lldecl = declare::declare_fn(ccx, symbol_name, mono_ty);
+ unsafe { llvm::LLVMSetLinkage(lldecl, linkage) };
+ base::set_link_section(ccx, lldecl, &attrs);
+ if linkage == llvm::LinkOnceODRLinkage ||
+ linkage == llvm::WeakODRLinkage {
+ llvm::SetUniqueComdat(ccx.llmod(), lldecl);
+ }
+
+ attributes::from_fn_attrs(ccx, &attrs, lldecl);
+ ccx.instances().borrow_mut().insert(instance, lldecl);
}
fn predefine_drop_glue(ccx: &CrateContext<'a, 'tcx>,
pub fn requests_inline(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>) -> bool {
match *self {
TransItem::Fn(ref instance) => {
- !instance.substs.types.is_empty() || {
+ instance.substs.types().next().is_some() || {
let attributes = tcx.get_attrs(instance.def);
attr::requests_inline(&attributes[..])
}
pub fn is_instantiated_only_on_demand(&self) -> bool {
match *self {
- TransItem::Fn(ref instance) => !instance.def.is_local() ||
- !instance.substs.types.is_empty(),
+ TransItem::Fn(ref instance) => {
+ !instance.def.is_local() || instance.substs.types().next().is_some()
+ }
TransItem::DropGlue(..) => true,
TransItem::Static(..) => false,
}
pub fn is_generic_fn(&self) -> bool {
match *self {
- TransItem::Fn(ref instance) => !instance.substs.types.is_empty(),
+ TransItem::Fn(ref instance) => {
+ instance.substs.types().next().is_some()
+ }
TransItem::DropGlue(..) |
TransItem::Static(..) => false,
}
/// Same as `unique_type_name()` but with the result pushed onto the given
/// `output` parameter.
pub fn push_unique_type_name<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
- t: ty::Ty<'tcx>,
+ t: Ty<'tcx>,
output: &mut String) {
match t.sty {
ty::TyBool => output.push_str("bool"),
ty::TyStruct(adt_def, substs) |
ty::TyEnum(adt_def, substs) => {
push_item_name(tcx, adt_def.did, output);
- push_type_params(tcx, &substs.types, &[], output);
+ push_type_params(tcx, substs, &[], output);
},
ty::TyTuple(component_types) => {
output.push('(');
ty::TyTrait(ref trait_data) => {
push_item_name(tcx, trait_data.principal.def_id(), output);
push_type_params(tcx,
- &trait_data.principal.skip_binder().substs.types,
+ trait_data.principal.skip_binder().substs,
&trait_data.projection_bounds,
output);
},
output.push_str("{");
output.push_str(&format!("{}:{}", def_id.krate, def_id.index.as_usize()));
output.push_str("}");
- push_type_params(tcx, &closure_substs.func_substs.types, &[], output);
+ push_type_params(tcx, closure_substs.func_substs, &[], output);
}
ty::TyError |
ty::TyInfer(_) |
}
fn push_type_params<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
- types: &[Ty<'tcx>],
+ substs: &Substs<'tcx>,
projections: &[ty::PolyExistentialProjection<'tcx>],
output: &mut String) {
- if types.is_empty() && projections.is_empty() {
+ if substs.types().next().is_none() && projections.is_empty() {
return;
}
output.push('<');
- for &type_parameter in types {
+ for type_parameter in substs.types() {
push_unique_type_name(tcx, type_parameter, output);
output.push_str(", ");
}
instance: Instance<'tcx>,
output: &mut String) {
push_item_name(tcx, instance.def, output);
- push_type_params(tcx, &instance.substs.types, &[], output);
+ push_type_params(tcx, instance.substs, &[], output);
}
pub fn def_id_to_string(tcx: TyCtxt, def_id: DefId) -> String {
}
pub fn type_to_string<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
- ty: ty::Ty<'tcx>)
+ ty: Ty<'tcx>)
-> String {
let mut output = String::new();
push_unique_type_name(tcx, ty, &mut output);