Add miri test and make it operate on ptr

Author: Centri3

compiler/rustc_codegen_llvm/src/context.rs

@@ -908,7 +908,10 @@ impl<'ll> CodegenCx<'ll, '_> {
         ifn!("llvm.lifetime.start.p0i8", fn(t_i64, ptr) -> void);
         ifn!("llvm.lifetime.end.p0i8", fn(t_i64, ptr) -> void);
 
-        ifn!("llvm.is.constant", fn(...) -> i1);
+        // Defining only the `ptr` variant of this overloaded intrinsic means
+        // we can call this on any type we want (that doesn't ICE), but at the
+        // slight cost of needing to write `addr_of!` everywhere.
+        ifn!("llvm.is.constant.ptr", fn(ptr) -> i1);
 
         ifn!("llvm.expect.i1", fn(i1, i1) -> i1);
         ifn!("llvm.eh.typeid.for", fn(ptr) -> t_i32);

compiler/rustc_codegen_llvm/src/intrinsic.rs

@@ -119,8 +119,8 @@ impl<'ll, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'_, 'll, 'tcx> {
             sym::likely => {
                 self.call_intrinsic("llvm.expect.i1", &[args[0].immediate(), self.const_bool(true)])
             }
-            sym::is_compile_time_known => {
-                self.call_intrinsic("llvm.is.constant", &[args[0].immediate()])
+            sym::is_val_statically_known => {
+                self.call_intrinsic("llvm.is.constant.ptr", &[args[0].immediate()])
             }
             sym::unlikely => self
                 .call_intrinsic("llvm.expect.i1", &[args[0].immediate(), self.const_bool(false)]),

compiler/rustc_const_eval/src/const_eval/machine.rs

@@ -531,7 +531,12 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for CompileTimeInterpreter<'mir,
                     )?;
                 }
             }
-            sym::is_compile_time_known => ecx.write_scalar(Scalar::from_bool(false), dest)?,
+            // The name of this intrinsic is actually misleading. It actually
+            // represents whether the value is known to the optimizer (LLVM).
+            // The value of `arg`, while known to the machine, should be
+            // considered unknown to the optimizer as we haven't gotten to the
+            // codegen stage or ran any sort of optimizations yet.
+            sym::is_val_statically_known => ecx.write_scalar(Scalar::from_bool(false), dest)?,
             _ => {
                 throw_unsup_format!(
                     "intrinsic `{intrinsic_name}` is not supported at compile-time"

compiler/rustc_const_eval/src/interpret/intrinsics.rs

@@ -216,7 +216,6 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             sym::copy => {
                 self.copy_intrinsic(&args[0], &args[1], &args[2], /*nonoverlapping*/ false)?;
             }
-            sym::is_compile_time_known => self.write_scalar(Scalar::from_bool(false), dest)?,
             sym::write_bytes => {
                 self.write_bytes_intrinsic(&args[0], &args[1], &args[2])?;
             }

compiler/rustc_hir_analysis/src/check/intrinsic.rs

@@ -453,7 +453,9 @@ pub fn check_intrinsic_type(tcx: TyCtxt<'_>, it: &hir::ForeignItem<'_>) {
 
             sym::black_box => (1, vec![param(0)], param(0)),
 
-            sym::is_compile_time_known => (1, vec![param(0)], tcx.types.bool),
+            sym::is_val_statically_known => {
+                (1, vec![Ty::new_imm_ptr(tcx, param(0))], tcx.types.bool)
+            }
 
             sym::const_eval_select => (4, vec![param(0), param(1), param(2)], param(3)),
 

compiler/rustc_span/src/symbol.rs

@@ -907,7 +907,7 @@ symbols! {
         io_stderr,
         io_stdout,
         irrefutable_let_patterns,
-        is_compile_time_known,
+        is_val_statically_known,
         isa_attribute,
         isize,
         issue,

library/core/src/intrinsics.rs

@@ -2512,11 +2512,12 @@ extern "rust-intrinsic" {
         G: FnOnce<ARG, Output = RET>,
         F: FnOnce<ARG, Output = RET>;
 
-    /// Returns whether the argument is known at compile-time.
+    /// Returns whether the argument's value is statically known at
+    /// compile-time.
     ///
     /// This is useful when there is a way of writing the code that will
     /// be *faster* when some variables have known values, but *slower*
-    /// in the general case: an `if is_compile_time_known(var)` can be used
+    /// in the general case: an `if is_val_statically_known(var)` can be used
     /// to select between these two variants. The `if` will be optimized away
     /// and only the desired branch remains.
     ///
@@ -2525,16 +2526,35 @@ extern "rust-intrinsic" {
     /// In other words, the following code has *Undefined Behavior*:
     ///
     /// ```rust
-    /// if !is_compile_time_known(0) { unreachable_unchecked(); }
+    /// if !is_val_statically_known(0) { unreachable_unchecked(); }
     /// ```
     ///
-    /// Unsafe code may not rely on `is_compile_time_known` returning any
+    /// This also means that the following code's behavior is unspecified; it
+    /// may panic, or it may not:
+    ///
+    /// ```rust,no_run
+    /// assert_eq!(is_val_statically_known(0), black_box(is_val_statically_known(0)))
+    /// ```
+    ///
+    /// Unsafe code may not rely on `is_val_statically_known` returning any
     /// particular value, ever. However, the compiler will generally make it
     /// return `true` only if the value of the argument is actually known.
-    #[rustc_const_unstable(feature = "is_compile_time_known", issue = "none")]
+    ///
+    /// When calling this in a `const fn`, both paths must be semantically
+    /// equivalent, that is, the result of the `true` branch and the `false`
+    /// branch return the same value *no matter what*.
+    #[rustc_const_unstable(feature = "is_val_statically_known", issue = "none")]
     #[rustc_nounwind]
     #[cfg(not(bootstrap))]
-    pub fn is_compile_time_known<T>(arg: T) -> bool;
+    pub fn is_val_statically_known<T>(arg: *const T) -> bool;
+}
+
+// FIXME: Seems using `unstable` here completely ignores `rustc_allow_const_fn_unstable`
+// and thus compiling stage0 core doesn't work.
+#[rustc_const_stable(feature = "is_val_statically_known", since = "never")]
+#[cfg(bootstrap)]
+pub const unsafe fn is_val_statically_known<T>(_: *const T) -> bool {
+    false
 }
 
 // Some functions are defined here because they accidentally got made

library/core/src/lib.rs

@@ -197,7 +197,7 @@
 //
 // Language features:
 // tidy-alphabetical-start
-#![cfg_attr(not(bootstrap), feature(is_compile_time_known))]
+#![cfg_attr(not(bootstrap), feature(is_val_statically_known))]
 #![feature(abi_unadjusted)]
 #![feature(adt_const_params)]
 #![feature(allow_internal_unsafe)]

library/core/src/num/int_macros.rs

@@ -2088,11 +2088,10 @@ macro_rules! int_impl {
                       without modifying the original"]
         #[inline]
         #[rustc_inherit_overflow_checks]
-        #[rustc_allow_const_fn_unstable(is_compile_time_known)]
+        #[rustc_allow_const_fn_unstable(is_val_statically_known)]
         pub const fn pow(self, mut exp: u32) -> Self {
-            #[cfg(not(bootstrap))]
             // SAFETY: This path has the same behavior as the other.
-            if unsafe { intrinsics::is_compile_time_known(self) }
+            if unsafe { intrinsics::is_val_statically_known(ptr::addr_of!(self)) }
                 && self > 0
                 && (self & (self - 1) == 0)
             {
@@ -2132,29 +2131,6 @@ macro_rules! int_impl {
                 // needless overflow.
                 acc * base
             }
-
-            #[cfg(bootstrap)]
-            {
-                if exp == 0 {
-                    return 1;
-                }
-                let mut base = self;
-                let mut acc = 1;
-
-                while exp > 1 {
-                    if (exp & 1) == 1 {
-                        acc = acc * base;
-                    }
-                    exp /= 2;
-                    base = base * base;
-                }
-
-                // since exp!=0, finally the exp must be 1.
-                // Deal with the final bit of the exponent separately, since
-                // squaring the base afterwards is not necessary and may cause a
-                // needless overflow.
-                acc * base
-            }
         }
 
         /// Returns the square root of the number, rounded down.

library/core/src/num/mod.rs

@@ -6,6 +6,7 @@ use crate::ascii;
 use crate::intrinsics;
 use crate::mem;
 use crate::ops::{Add, Mul, Sub};
+use crate::ptr;
 use crate::str::FromStr;
 
 // Used because the `?` operator is not allowed in a const context.

library/core/src/num/uint_macros.rs

@@ -1973,7 +1973,7 @@ macro_rules! uint_impl {
                       without modifying the original"]
         #[inline]
         #[rustc_inherit_overflow_checks]
-        #[rustc_allow_const_fn_unstable(is_compile_time_known)]
+        #[rustc_allow_const_fn_unstable(is_val_statically_known)]
         pub const fn pow(self, mut exp: u32) -> Self {
             // LLVM now knows that `self` is a constant value, but not a
             // constant in Rust. This allows us to compute the power used at
@@ -1986,9 +1986,10 @@ macro_rules! uint_impl {
             // get the power of a power of two and the exponent through a `shl`
             // instruction, but we must add a couple more checks for parity with
             // our own `pow`.
-            #[cfg(not(bootstrap))]
             // SAFETY: This path has the same behavior as the other.
-            if unsafe { intrinsics::is_compile_time_known(self) } && self.is_power_of_two() {
+            if unsafe { intrinsics::is_val_statically_known(ptr::addr_of!(self)) }
+                && self.is_power_of_two()
+            {
                 let power_used = match self.checked_ilog2() {
                     Some(v) => v,
                     // SAFETY: We just checked this is a power of two. `0` is not a
@@ -2026,29 +2027,6 @@ macro_rules! uint_impl {
                 // needless overflow.
                 acc * base
             }
-
-            #[cfg(bootstrap)]
-            {
-                if exp == 0 {
-                    return 1;
-                }
-                let mut base = self;
-                let mut acc = 1;
-
-                while exp > 1 {
-                    if (exp & 1) == 1 {
-                        acc = acc * base;
-                    }
-                    exp /= 2;
-                    base = base * base;
-                }
-
-                // since exp!=0, finally the exp must be 1.
-                // Deal with the final bit of the exponent separately, since
-                // squaring the base afterwards is not necessary and may cause a
-                // needless overflow.
-                acc * base
-            }
         }
 
         /// Returns the square root of the number, rounded down.

src/tools/miri/src/shims/intrinsics/mod.rs

@@ -5,6 +5,7 @@ use std::iter;
 
 use log::trace;
 
+use rand::Rng;
 use rustc_apfloat::{Float, Round};
 use rustc_middle::ty::layout::LayoutOf;
 use rustc_middle::{
@@ -141,16 +142,15 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 this.write_pointer(Pointer::new(ptr.provenance, masked_addr), dest)?;
             }
 
-            // The default implementation always returns `false`, but we want
-            // to return either `true` or `false` at random.
-            "is_comptile_time_known" => {
-                let rand = 0;
-                _ = getrandom::getrandom(&mut [rand]);
-
-                this.write_scalar(
-                    Scalar::from_bool(if (rand % 1) == 1 { true } else { false }),
-                    dest,
-                )?;
+            // We want to return either `true` or `false` at random, or else something like
+            // ```
+            // if !is_val_statically_known(0) { unreachable_unchecked(); }
+            // ```
+            // Would not be considered UB, or the other way around (`is_val_statically_known(0)`).
+            "is_val_statically_known" => {
+                let [_] = check_arg_count(args)?;
+                let branch = this.machine.rng.get_mut().gen();
+                this.write_scalar(Scalar::from_bool(branch), dest)?;
             }
 
             // Floating-point operations
@@ -477,10 +477,11 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 }
             }
             // Nothing else
-            _ => span_bug!(
-                this.cur_span(),
-                "`float_to_int_unchecked` called with non-int output type {dest_ty:?}"
-            ),
+            _ =>
+                span_bug!(
+                    this.cur_span(),
+                    "`float_to_int_unchecked` called with non-int output type {dest_ty:?}"
+                ),
         })
     }
 >>>>>>> acbf90a9489 (Make MIRI choose the path randomly and rename the intrinsic)

src/tools/miri/tests/pass/intrinsics.rs

@@ -33,6 +33,12 @@ fn main() {
     assert_eq!(intrinsics::likely(false), false);
     assert_eq!(intrinsics::unlikely(true), true);
 
+    if unsafe { intrinsics::is_val_statically_known(&0 as _) } {
+        0
+    } else {
+        0
+    };
+
     intrinsics::forget(Bomb);
 
     let _v = intrinsics::discriminant_value(&Some(()));