Allow reifying intrinsics to fn pointers.

Author: eddyb

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -3,7 +3,7 @@
 use std::rc::Rc;
 use std::{fmt, iter, mem};
 
-use rustc_abi::FieldIdx;
+use rustc_abi::{ExternAbi, FieldIdx};
 use rustc_data_structures::frozen::Frozen;
 use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
 use rustc_errors::ErrorGuaranteed;
@@ -39,7 +39,8 @@ use rustc_mir_dataflow::move_paths::MoveData;
 use rustc_mir_dataflow::points::DenseLocationMap;
 use rustc_span::def_id::CRATE_DEF_ID;
 use rustc_span::source_map::Spanned;
-use rustc_span::{DUMMY_SP, Span, sym};
+use rustc_span::symbol::sym;
+use rustc_span::{DUMMY_SP, Span};
 use rustc_trait_selection::traits::query::type_op::custom::scrape_region_constraints;
 use rustc_trait_selection::traits::query::type_op::{TypeOp, TypeOpOutput};
 use tracing::{debug, instrument, trace};
@@ -1743,6 +1744,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, ExternAbi::RustIntrinsic) {
+                                sig.abi = ExternAbi::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

@@ -38,7 +38,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;
@@ -748,9 +747,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

@@ -98,6 +98,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, ExternAbi::RustIntrinsic) {
+        sig.abi = ExternAbi::Rust;
+    }
+
+    sig
+}
+
 /// Coercing a mutable reference to an immutable works, while
 /// coercing `&T` to `&mut T` should be forbidden.
 fn coerce_mutbls<'tcx>(
@@ -911,12 +928,10 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
         match b.kind() {
             ty::FnPtr(_, b_hdr) => {
                 let mut a_sig = a.fn_sig(self.tcx);
-                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);
-                    }
+                // NOTE(eddyb) see comment on `prepare_fn_sig_for_reify`.
+                a_sig = a_sig.map_bound(prepare_fn_sig_for_reify);
 
+                if let ty::FnDef(def_id, _) = *a.kind() {
                     let fn_attrs = self.tcx.codegen_fn_attrs(def_id);
                     if matches!(fn_attrs.inline, InlineAttr::Force { .. }) {
                         return Err(TypeError::ForceInlineCast);
@@ -1266,10 +1281,6 @@ 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() == ExternAbi::RustIntrinsic || b_sig.abi() == ExternAbi::RustIntrinsic {
-                return Err(TypeError::IntrinsicCast);
-            }
             // 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

@@ -112,7 +112,6 @@ impl<'tcx> TypeError<'tcx> {
             TypeError::ForceInlineCast => {
                 "cannot coerce functions which must be inlined to function pointers".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

@@ -656,6 +656,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

@@ -2321,7 +2321,7 @@ impl<'tcx> ObligationCause<'tcx> {
                 {
                     FailureCode::Error0644
                 }
-                TypeError::IntrinsicCast | TypeError::ForceInlineCast => FailureCode::Error0308,
+                TypeError::ForceInlineCast => FailureCode::Error0308,
                 _ => FailureCode::Error0308,
             },
         }
@@ -2387,9 +2387,6 @@ impl<'tcx> ObligationCause<'tcx> {
                 TypeError::ForceInlineCast => {
                     ObligationCauseFailureCode::CantCoerceForceInline { span, subdiags }
                 }
-                TypeError::IntrinsicCast => {
-                    ObligationCauseFailureCode::CantCoerceIntrinsic { span, subdiags }
-                }
                 _ => ObligationCauseFailureCode::Generic { span, subdiags },
             },
         }

compiler/rustc_type_ir/src/error.rs

@@ -50,7 +50,6 @@ pub enum TypeError<I: Interner> {
     ExistentialMismatch(ExpectedFound<I::BoundExistentialPredicates>),
     ConstMismatch(ExpectedFound<I::Const>),
 
-    IntrinsicCast,
     /// `#[rustc_force_inline]` functions must be inlined and must not be codegened independently,
     /// so casting to a function pointer must be prohibited.
     ForceInlineCast,
@@ -86,8 +85,7 @@ impl<I: Interner> TypeError<I> {
             | ProjectionMismatched(_)
             | ExistentialMismatch(_)
             | ConstMismatch(_)
-            | ForceInlineCast
-            | IntrinsicCast => true,
+            | ForceInlineCast => true,
         }
     }
 }

tests/ui/intrinsics/reify-intrinsic.rs

@@ -1,22 +1,38 @@
-//@ check-fail
+//@ run-pass
 
 #![feature(core_intrinsics, intrinsics)]
 
-fn a() {
-    let _: unsafe 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 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 fn(f32) -> f32; 2] = [
-        std::intrinsics::floorf32, //~ ERROR cannot coerce
+#[inline(never)]
+fn c() -> [unsafe fn(f32) -> f32; 2] {
+    let fs = [
+        std::intrinsics::floorf32,
         std::intrinsics::log2f32,
     ];
+    fs
 }
 
-fn main() {}
+fn main() {
+    unsafe {
+        assert_eq!(a()(-1), !0);
+        assert_eq!(b()(-1), !0);
+
+        let [floorf32_ptr, log2f32_ptr] = c();
+        assert_eq!(floorf32_ptr(1.5), 1.0);
+        assert_eq!(log2f32_ptr(2.0), 1.0);
+    }
+}

tests/ui/intrinsics/reify-intrinsic.stderr

@@ -0,0 +1,31 @@
+//@ normalize-stderr: "\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() {}