rustc_codegen_ssa: use FnAbi::of_instance wherever possible.

Author: eddyb

src/librustc_codegen_llvm/callee.rs

@@ -11,7 +11,7 @@ use crate::context::CodegenCx;
 use crate::value::Value;
 use rustc_codegen_ssa::traits::*;
 
-use rustc::ty::{self, TypeFoldable, Instance};
+use rustc::ty::{TypeFoldable, Instance};
 use rustc::ty::layout::{FnAbiExt, LayoutOf, HasTyCtxt};
 
 /// Codegens a reference to a fn/method item, monomorphizing and
@@ -37,12 +37,12 @@ pub fn get_fn(
         return llfn;
     }
 
-    let sig = instance.fn_sig(cx.tcx());
     let sym = tcx.symbol_name(instance).name.as_str();
-    debug!("get_fn({:?}: {:?}) => {}", instance, sig, sym);
+    debug!("get_fn({:?}: {:?}) => {}", instance, instance.fn_sig(cx.tcx()), sym);
 
     let llfn = if let Some(llfn) = cx.get_declared_value(&sym) {
         // Create a fn pointer with the substituted signature.
+        let sig = instance.fn_sig(cx.tcx());
         let fn_ptr_ty = tcx.mk_fn_ptr(sig);
         let llptrty = cx.backend_type(cx.layout_of(fn_ptr_ty));
 
@@ -77,15 +77,17 @@ pub fn get_fn(
             llfn
         }
     } else {
-        let sig = tcx.normalize_erasing_late_bound_regions(ty::ParamEnv::reveal_all(), &sig);
-        let fn_abi = FnAbi::new(cx, sig, &[]);
+        let fn_abi = FnAbi::of_instance(cx, instance);
         let llfn = cx.declare_fn(&sym, &fn_abi);
         debug!("get_fn: not casting pointer!");
 
         if instance.def.is_inline(tcx) {
             attributes::inline(cx, llfn, attributes::InlineAttr::Hint);
         }
-        attributes::from_fn_attrs(cx, llfn, Some(instance.def.def_id()), sig.abi);
+        // FIXME(eddyb) avoid this `Instance::fn_sig` call.
+        // Perhaps store the relevant information in `FnAbi`?
+        let sig_abi = instance.fn_sig(cx.tcx()).abi();
+        attributes::from_fn_attrs(cx, llfn, Some(instance.def.def_id()), sig_abi);
 
         let instance_def_id = instance.def_id();
 

src/librustc_codegen_llvm/mono_item.rs

@@ -6,7 +6,7 @@ use crate::llvm;
 use crate::type_of::LayoutLlvmExt;
 use rustc::hir::def_id::{DefId, LOCAL_CRATE};
 use rustc::mir::mono::{Linkage, Visibility};
-use rustc::ty::{self, TypeFoldable, Instance};
+use rustc::ty::{TypeFoldable, Instance};
 use rustc::ty::layout::{FnAbiExt, LayoutOf, HasTyCtxt};
 use rustc_codegen_ssa::traits::*;
 
@@ -43,12 +43,7 @@ impl PreDefineMethods<'tcx> for CodegenCx<'ll, 'tcx> {
         assert!(!instance.substs.needs_infer() &&
                 !instance.substs.has_param_types());
 
-        let mono_sig = instance.fn_sig(self.tcx());
-        let mono_sig = self.tcx().normalize_erasing_late_bound_regions(
-            ty::ParamEnv::reveal_all(),
-            &mono_sig,
-        );
-        let fn_abi = FnAbi::new(self, mono_sig, &[]);
+        let fn_abi = FnAbi::of_instance(self, instance);
         let lldecl = self.declare_fn(symbol_name, &fn_abi);
         unsafe { llvm::LLVMRustSetLinkage(lldecl, base::linkage_to_llvm(linkage)) };
         let attrs = self.tcx.codegen_fn_attrs(instance.def_id());
@@ -73,15 +68,18 @@ impl PreDefineMethods<'tcx> for CodegenCx<'ll, 'tcx> {
             }
         }
 
-        debug!("predefine_fn: mono_sig = {:?} instance = {:?}", mono_sig, instance);
+        debug!("predefine_fn: instance = {:?}", instance);
         if instance.def.is_inline(self.tcx) {
             attributes::inline(self, lldecl, attributes::InlineAttr::Hint);
         }
+        // FIXME(eddyb) avoid this `Instance::fn_sig` call.
+        // Perhaps store the relevant information in `FnAbi`?
+        let mono_sig_abi = instance.fn_sig(self.tcx()).abi();
         attributes::from_fn_attrs(
             self,
             lldecl,
             Some(instance.def.def_id()),
-            mono_sig.abi,
+            mono_sig_abi,
         );
 
         self.instances.borrow_mut().insert(instance, lldecl);

src/librustc_codegen_ssa/mir/mod.rs

@@ -127,13 +127,16 @@ pub fn codegen_mir<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
 
     let mir = cx.tcx().instance_mir(instance.def);
 
-    let sig = instance.fn_sig(cx.tcx());
-    let sig = cx.tcx().normalize_erasing_late_bound_regions(ty::ParamEnv::reveal_all(), &sig);
-    let fn_abi = FnAbi::new(cx, sig, &[]);
+    let fn_abi = FnAbi::of_instance(cx, instance);
     debug!("fn_abi: {:?}", fn_abi);
 
-    let debug_context =
-        cx.create_function_debug_context(instance, sig, llfn, mir);
+    let debug_context = {
+        // FIXME(eddyb) avoid this `Instance::fn_sig` call.
+        // Perhaps pass `fn_abi` to `create_function_debug_context`?
+        let sig = instance.fn_sig(cx.tcx());
+        let sig = cx.tcx().normalize_erasing_late_bound_regions(ty::ParamEnv::reveal_all(), &sig);
+        cx.create_function_debug_context(instance, sig, llfn, mir)
+    };
 
     let mut bx = Bx::new_block(cx, llfn, "start");