just check if its external

Author: RobertBColton

compiler/rustc_codegen_llvm/src/callee.rs

@@ -31,45 +31,50 @@ pub(crate) fn get_fn<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>, instance: Instance<'t
 
     let fn_abi = cx.fn_abi_of_instance(instance, ty::List::empty());
 
-    let instance_def_id = instance.def_id();
-    let existing_decl = cx.get_declared_value(sym);
-
-    let llfn = if tcx.sess.target.arch == "x86"
-            && let Some(dllimport) = get_dllimport(tcx, instance_def_id, sym) {
-        // When calling functions in generated import libraries, MSVC needs
-        // the fully decorated name (as would have been in the declaring
-        // object file), but MinGW wants the name as exported (as would be
-        // in the def file) which may be missing decorations.
-        let mingw_gnu_toolchain = common::is_mingw_gnu_toolchain(&tcx.sess.target);
-        let llfn = cx.declare_fn(
-            &common::i686_decorated_name(
-                dllimport,
-                mingw_gnu_toolchain,
-                true,
-                !mingw_gnu_toolchain,
-            ),
-            fn_abi,
-            Some(instance),
-        );
-
-        // Fix for https://github.com/rust-lang/rust/issues/104453
-        // On x86 Windows, LLVM uses 'L' as the prefix for any private
-        // global symbols, so when we create an undecorated function symbol
-        // that begins with an 'L' LLVM misinterprets that as a private
-        // global symbol that it created and so fails the compilation at a
-        // later stage since such a symbol must have a definition.
-        //
-        // To avoid this, we set the Storage Class to "DllImport" so that
-        // LLVM will prefix the name with `__imp_`. Ideally, we'd like the
-        // existing logic below to set the Storage Class, but it has an
-        // exemption for MinGW for backwards compatibility.
-        llvm::set_dllimport_storage_class(llfn);
+    
+    let llfn = if let Some(llfn) = cx.get_declared_value(sym)
+        if !cx.tcx.is_codegened_item(instance.def_id()) || !instance.def_id().is_local()
+    {
         llfn
     } else {
-        existing_decl.unwrap_or_else(|| cx.declare_fn(sym, fn_abi, Some(instance)))
-    };
+        let instance_def_id = instance.def_id();
+        let llfn = if tcx.sess.target.arch == "x86"
+            && let Some(dllimport) = crate::common::get_dllimport(tcx, instance_def_id, sym)
+        {
+            // When calling functions in generated import libraries, MSVC needs
+            // the fully decorated name (as would have been in the declaring
+            // object file), but MinGW wants the name as exported (as would be
+            // in the def file) which may be missing decorations.
+            let mingw_gnu_toolchain = common::is_mingw_gnu_toolchain(&tcx.sess.target);
+            let llfn = cx.declare_fn(
+                &common::i686_decorated_name(
+                    dllimport,
+                    mingw_gnu_toolchain,
+                    true,
+                    !mingw_gnu_toolchain,
+                ),
+                fn_abi,
+                Some(instance),
+            );
+
+            // Fix for https://github.com/rust-lang/rust/issues/104453
+            // On x86 Windows, LLVM uses 'L' as the prefix for any private
+            // global symbols, so when we create an undecorated function symbol
+            // that begins with an 'L' LLVM misinterprets that as a private
+            // global symbol that it created and so fails the compilation at a
+            // later stage since such a symbol must have a definition.
+            //
+            // To avoid this, we set the Storage Class to "DllImport" so that
+            // LLVM will prefix the name with `__imp_`. Ideally, we'd like the
+            // existing logic below to set the Storage Class, but it has an
+            // exemption for MinGW for backwards compatibility.
+            llvm::set_dllimport_storage_class(llfn);
+            llfn
+        } else {
+            cx.declare_fn(sym, fn_abi, Some(instance))
+        };
+        debug!("get_fn: not casting pointer!");
 
-    if existing_decl.map_or(true, |existing| existing != llfn) {
         // Apply an appropriate linkage/visibility value to our item that we
         // just declared.
         //
@@ -150,7 +155,7 @@ pub(crate) fn get_fn<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>, instance: Instance<'t
         cx.assume_dso_local(llfn, true);
 
         llfn
-    }
+    };
 
     cx.instances.borrow_mut().insert(instance, llfn);