Allow reifying intrinsics to fn pointers.

Author: eddyb

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -41,6 +41,7 @@ use rustc_span::source_map::Spanned;
 use rustc_span::symbol::sym;
 use rustc_span::{DUMMY_SP, Span};
 use rustc_target::abi::{FIRST_VARIANT, FieldIdx};
+use rustc_target::spec::abi::Abi;
 use rustc_trait_selection::traits::query::type_op::custom::{
     CustomTypeOp, scrape_region_constraints,
 };
@@ -2028,6 +2029,16 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                             };
                         }
 
+                        // NOTE(eddyb) see comment on `prepare_fn_sig_for_reify`
+                        // in `rustc_typeck::check::coercion`.
+                        let src_sig = src_sig.map_bound(|mut sig| -> _ {
+                            if matches!(sig.abi, Abi::RustIntrinsic) {
+                                sig.abi = Abi::Rust;
+                            }
+
+                            sig
+                        });
+
                         let src_ty = Ty::new_fn_ptr(tcx, src_sig);
                         // HACK: We want to assert that the signature of the source fn is
                         // well-formed, because we don't enforce that via the WF of FnDef

compiler/rustc_hir_typeck/src/cast.rs

@@ -37,7 +37,6 @@ use rustc_macros::{TypeFoldable, TypeVisitable};
 use rustc_middle::mir::Mutability;
 use rustc_middle::ty::adjustment::AllowTwoPhase;
 use rustc_middle::ty::cast::{CastKind, CastTy};
-use rustc_middle::ty::error::TypeError;
 use rustc_middle::ty::{self, Ty, TyCtxt, TypeAndMut, TypeVisitableExt, VariantDef};
 use rustc_middle::{bug, span_bug};
 use rustc_session::lint;
@@ -746,9 +745,6 @@ impl<'a, 'tcx> CastCheck<'tcx> {
                             AllowTwoPhase::No,
                             None,
                         );
-                        if let Err(TypeError::IntrinsicCast) = res {
-                            return Err(CastError::IllegalCast);
-                        }
                         if res.is_err() {
                             return Err(CastError::NonScalar);
                         }

compiler/rustc_hir_typeck/src/coercion.rs

@@ -99,6 +99,23 @@ impl<'a, 'tcx> Deref for Coerce<'a, 'tcx> {
 
 type CoerceResult<'tcx> = InferResult<'tcx, (Vec<Adjustment<'tcx>>, Ty<'tcx>)>;
 
+/// Make any adjustments necessary for a function signature to be compatible
+/// with reification to a `fn` pointer. In particular, intrinsics are imported
+/// using pseudo-ABIs (`extern "rust-intrinsic" {...}`) currently, but that's
+/// an implementation detail and any `fn` pointers that may be taken to them
+/// should be indistinguishable from those to regular Rust functions, in order
+/// to allow e.g. libcore public APIs to be replaced with intrinsics, without
+/// breaking code that was, explicitly or implicitly, creating `fn` pointers.
+// FIXME(eddyb) intrinsics shouldn't use pseudo-ABIs, but rather the  Rust ABI
+// and some other way to indicate that they are intrinsics (e.g. new attributes).
+fn prepare_fn_sig_for_reify<'tcx>(mut sig: ty::FnSig<'tcx>) -> ty::FnSig<'tcx> {
+    if matches!(sig.abi, Abi::RustIntrinsic) {
+        sig.abi = Abi::Rust;
+    }
+
+    sig
+}
+
 /// Coercing a mutable reference to an immutable works, while
 /// coercing `&T` to `&mut T` should be forbidden.
 fn coerce_mutbls<'tcx>(
@@ -915,12 +932,9 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
         match b.kind() {
             ty::FnPtr(_, b_hdr) => {
                 let a_sig = a.fn_sig(self.tcx);
+                // NOTE(eddyb) see comment on `prepare_fn_sig_for_reify`.
+                let a_sig = a_sig.map_bound(prepare_fn_sig_for_reify);
                 if let ty::FnDef(def_id, _) = *a.kind() {
-                    // Intrinsics are not coercible to function pointers
-                    if self.tcx.intrinsic(def_id).is_some() {
-                        return Err(TypeError::IntrinsicCast);
-                    }
-
                     // Safe `#[target_feature]` functions are not assignable to safe fn pointers (RFC 2396).
 
                     if b_hdr.safety == hir::Safety::Safe
@@ -1246,10 +1260,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             }
         };
         if let (Some(a_sig), Some(b_sig)) = (a_sig, b_sig) {
-            // Intrinsics are not coercible to function pointers.
-            if a_sig.abi() == Abi::RustIntrinsic || b_sig.abi() == Abi::RustIntrinsic {
-                return Err(TypeError::IntrinsicCast);
-            }
+            // NOTE(eddyb) see comment on `prepare_fn_sig_for_reify`.
+            let a_sig = a_sig.map_bound(prepare_fn_sig_for_reify);
+            let b_sig = b_sig.map_bound(prepare_fn_sig_for_reify);
             // The signature must match.
             let (a_sig, b_sig) = self.normalize(new.span, (a_sig, b_sig));
             let sig = self

compiler/rustc_middle/src/ty/error.rs

@@ -110,7 +110,6 @@ impl<'tcx> TypeError<'tcx> {
             TypeError::ConstMismatch(ref values) => {
                 format!("expected `{}`, found `{}`", values.expected, values.found).into()
             }
-            TypeError::IntrinsicCast => "cannot coerce intrinsics to function pointers".into(),
             TypeError::TargetFeatureCast(_) => {
                 "cannot coerce functions with `#[target_feature]` to safe function pointers".into()
             }

compiler/rustc_middle/src/ty/instance.rs

@@ -639,6 +639,10 @@ impl<'tcx> Instance<'tcx> {
                     // unresolved instance.
                     resolved = Instance { def: InstanceKind::ReifyShim(def_id, reason), args }
                 }
+                InstanceKind::Intrinsic(def_id) => {
+                    debug!(" => fn pointer created for intrinsic call");
+                    resolved.def = InstanceKind::ReifyShim(def_id, reason);
+                }
                 _ => {}
             }
 

compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs

@@ -2051,7 +2051,6 @@ impl<'tcx> ObligationCause<'tcx> {
                 {
                     FailureCode::Error0644
                 }
-                TypeError::IntrinsicCast => FailureCode::Error0308,
                 _ => FailureCode::Error0308,
             },
         }
@@ -2117,9 +2116,6 @@ impl<'tcx> ObligationCause<'tcx> {
                 {
                     ObligationCauseFailureCode::ClosureSelfref { span }
                 }
-                TypeError::IntrinsicCast => {
-                    ObligationCauseFailureCode::CantCoerce { span, subdiags }
-                }
                 _ => ObligationCauseFailureCode::Generic { span, subdiags },
             },
         }

compiler/rustc_type_ir/src/error.rs

@@ -54,7 +54,6 @@ pub enum TypeError<I: Interner> {
     ExistentialMismatch(ExpectedFound<I::BoundExistentialPredicates>),
     ConstMismatch(ExpectedFound<I::Const>),
 
-    IntrinsicCast,
     /// Safe `#[target_feature]` functions are not assignable to safe function pointers.
     TargetFeatureCast(I::DefId),
 }
@@ -86,8 +85,7 @@ impl<I: Interner> TypeError<I> {
             | Traits(_)
             | ProjectionMismatched(_)
             | ExistentialMismatch(_)
-            | ConstMismatch(_)
-            | IntrinsicCast => true,
+            | ConstMismatch(_) => true,
         }
     }
 }

tests/ui/intrinsics/reify-intrinsic.rs

@@ -1,22 +1,38 @@
-//@ check-fail
+//@ run-pass
 
 #![feature(core_intrinsics, intrinsics)]
 
-fn a() {
-    let _: unsafe extern "rust-intrinsic" fn(isize) -> usize = std::mem::transmute;
-    //~^ ERROR cannot coerce
+// NOTE(eddyb) `#[inline(never)]` and returning `fn` pointers from functions is
+// done to force codegen (of the reification-to-`fn`-ptr shims around intrinsics).
+
+#[inline(never)]
+fn a() -> unsafe fn(isize) -> usize {
+    let f: unsafe fn(isize) -> usize = std::mem::transmute;
+    f
 }
 
-fn b() {
-    let _ = std::mem::transmute as unsafe extern "rust-intrinsic" fn(isize) -> usize;
-    //~^ ERROR casting
+#[inline(never)]
+fn b() -> unsafe fn(isize) -> usize {
+    let f = std::mem::transmute as unsafe fn(isize) -> usize;
+    f
 }
 
-fn c() {
-    let _: [unsafe extern "rust-intrinsic" fn(bool) -> bool; 2] = [
-        std::intrinsics::likely, //~ ERROR cannot coerce
+#[inline(never)]
+fn c() -> [fn(bool) -> bool; 2] {
+    let fs = [
+        std::intrinsics::likely,
         std::intrinsics::unlikely,
     ];
+    fs
 }
 
-fn main() {}
+fn main() {
+    unsafe {
+        assert_eq!(a()(-1), !0);
+        assert_eq!(b()(-1), !0);
+    }
+
+    let [likely_ptr, unlikely_ptr] = c();
+    assert!(likely_ptr(true));
+    assert!(unlikely_ptr(true));
+}

tests/ui/intrinsics/reify-intrinsic.stderr

@@ -0,0 +1,31 @@
+//@ normalize-stderr-test: "\d+ bits" -> "N bits"
+
+// Tests that `transmute` cannot be indirectly called on types of different size.
+
+#![allow(warnings)]
+#![feature(specialization)]
+
+use std::mem::transmute;
+
+unsafe fn f() {
+    let _: i8 = (transmute as unsafe fn(_) -> _)(16i16);
+    //~^ ERROR cannot transmute between types of different sizes, or dependently-sized types
+}
+
+unsafe fn g<T>(x: &T) {
+    let _: i8 = (transmute as unsafe fn(_) -> _)(x);
+    //~^ ERROR cannot transmute between types of different sizes, or dependently-sized types
+}
+
+trait Specializable { type Output; }
+
+impl<T> Specializable for T {
+    default type Output = u16;
+}
+
+unsafe fn specializable<T>(x: u16) -> <T as Specializable>::Output {
+    (transmute as unsafe fn(_) -> _)(x)
+    //~^ ERROR cannot transmute between types of different sizes, or dependently-sized types
+}
+
+fn main() {}