Split symbol name and signature calculation

Author: bjorn3

src/abi/mod.rs

@@ -179,12 +179,12 @@ fn clif_sig_from_fn_sig<'tcx>(
     }
 }
 
-pub(crate) fn get_function_name_and_sig<'tcx>(
+pub(crate) fn get_function_sig<'tcx>(
     tcx: TyCtxt<'tcx>,
     triple: &target_lexicon::Triple,
     inst: Instance<'tcx>,
     support_vararg: bool,
-) -> (String, Signature) {
+) -> Signature {
     assert!(!inst.substs.needs_infer());
     let fn_sig = tcx
         .normalize_erasing_late_bound_regions(ParamEnv::reveal_all(), fn_sig_for_fn_abi(tcx, inst));
@@ -194,14 +194,13 @@ pub(crate) fn get_function_name_and_sig<'tcx>(
             "Variadic function definitions are not yet supported",
         );
     }
-    let sig = clif_sig_from_fn_sig(
+    clif_sig_from_fn_sig(
         tcx,
         triple,
         fn_sig,
         false,
         inst.def.requires_caller_location(tcx),
-    );
-    (tcx.symbol_name(inst).name.to_string(), sig)
+    )
 }
 
 /// Instance must be monomorphized
@@ -210,7 +209,8 @@ pub(crate) fn import_function<'tcx>(
     module: &mut impl Module,
     inst: Instance<'tcx>,
 ) -> FuncId {
-    let (name, sig) = get_function_name_and_sig(tcx, module.isa().triple(), inst, true);
+    let name = tcx.symbol_name(inst).name.to_string();
+    let sig = get_function_sig(tcx, module.isa().triple(), inst, true);
     module
         .declare_function(&name, Linkage::Import, &sig)
         .unwrap()

src/base.rs

@@ -19,7 +19,8 @@ pub(crate) fn codegen_fn<'tcx>(
     let mir = tcx.instance_mir(instance.def);
 
     // Declare function
-    let (name, sig) = get_function_name_and_sig(tcx, cx.module.isa().triple(), instance, false);
+    let name = tcx.symbol_name(instance).name.to_string();
+    let sig = get_function_sig(tcx, cx.module.isa().triple(), instance, false);
     let func_id = cx.module.declare_function(&name, linkage, &sig).unwrap();
 
     cx.cached_context.clear();

src/driver/jit.rs

@@ -156,12 +156,8 @@ extern "C" fn __clif_jit_fn(instance_ptr: *const Instance<'static>) -> *const u8
             let jit_module = jit_module.as_mut().unwrap();
             let mut cx = crate::CodegenCx::new(tcx, jit_module, false, false);
 
-            let (name, sig) = crate::abi::get_function_name_and_sig(
-                tcx,
-                cx.module.isa().triple(),
-                instance,
-                true,
-            );
+            let name = tcx.symbol_name(instance).name.to_string();
+            let sig = crate::abi::get_function_sig(tcx, cx.module.isa().triple(), instance, true);
             let func_id = cx
                 .module
                 .declare_function(&name, Linkage::Export, &sig)
@@ -246,8 +242,8 @@ pub(super) fn codegen_shim<'tcx>(cx: &mut CodegenCx<'tcx, impl Module>, inst: In
 
     let pointer_type = cx.module.target_config().pointer_type();
 
-    let (name, sig) =
-        crate::abi::get_function_name_and_sig(tcx, cx.module.isa().triple(), inst, true);
+    let name = tcx.symbol_name(inst).name.to_string();
+    let sig = crate::abi::get_function_sig(tcx, cx.module.isa().triple(), inst, true);
     let func_id = cx
         .module
         .declare_function(&name, Linkage::Export, &sig)

src/driver/mod.rs

@@ -50,7 +50,8 @@ fn predefine_mono_items<'tcx>(
         for &(mono_item, (linkage, visibility)) in mono_items {
             match mono_item {
                 MonoItem::Fn(instance) => {
-                    let (name, sig) = get_function_name_and_sig(
+                    let name = cx.tcx.symbol_name(instance).name.to_string();
+                    let sig= get_function_sig(
                         cx.tcx,
                         cx.module.isa().triple(),
                         instance,

src/main_shim.rs

@@ -69,8 +69,8 @@ pub(crate) fn maybe_create_entry_wrapper(
 
         let instance = Instance::mono(tcx, rust_main_def_id).polymorphize(tcx);
 
-        let (main_name, main_sig) =
-            get_function_name_and_sig(tcx, m.isa().triple(), instance, false);
+        let main_name = tcx.symbol_name(instance).name.to_string();
+        let main_sig = get_function_sig(tcx, m.isa().triple(), instance, false);
         let main_func_id = m
             .declare_function(&main_name, Linkage::Import, &main_sig)
             .unwrap();