Make MIRI choose the path randomly and rename the intrinsic

Author: Centri3

compiler/rustc_codegen_llvm/src/intrinsic.rs

@@ -119,7 +119,9 @@ 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_constant => self.call_intrinsic("llvm.is.constant", &[args[0].immediate()]),
+            sym::is_compile_time_known => {
+                self.call_intrinsic("llvm.is.constant", &[args[0].immediate()])
+            }
             sym::unlikely => self
                 .call_intrinsic("llvm.expect.i1", &[args[0].immediate(), self.const_bool(false)]),
             kw::Try => {

compiler/rustc_const_eval/src/const_eval/machine.rs

@@ -531,6 +531,7 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for CompileTimeInterpreter<'mir,
                     )?;
                 }
             }
+            sym::is_compile_time_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,7 @@ 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_constant => self.write_scalar(Scalar::from_bool(true), dest)?,
+            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

@@ -112,8 +112,7 @@ pub fn intrinsic_operation_unsafety(tcx: TyCtxt<'_>, intrinsic_id: DefId) -> hir
         | sym::forget
         | sym::black_box
         | sym::variant_count
-        | sym::ptr_mask
-        | sym::is_constant => hir::Unsafety::Normal,
+        | sym::ptr_mask => hir::Unsafety::Normal,
         _ => hir::Unsafety::Unsafe,
     };
 
@@ -454,10 +453,7 @@ pub fn check_intrinsic_type(tcx: TyCtxt<'_>, it: &hir::ForeignItem<'_>) {
 
             sym::black_box => (1, vec![param(0)], param(0)),
 
-            sym::is_constant => {
-                // FIXME: ZSTs cause an ICE. We should check for this.
-                (1, vec![param(0)], tcx.types.bool)
-            }
+            sym::is_compile_time_known => (1, vec![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_constant,
+        is_compile_time_known,
         isa_attribute,
         isize,
         issue,

library/core/src/intrinsics.rs

@@ -2512,24 +2512,29 @@ extern "rust-intrinsic" {
         G: FnOnce<ARG, Output = RET>,
         F: FnOnce<ARG, Output = RET>;
 
-    /// Returns whether the argument is known at compile-time. This opens the
-    /// door for additional optimizations, in that LLVM can then optimize
-    /// following checks to either `true` or `false`. This is often paired with
-    /// an `if-else` statement, as LLVM will only keep one branch (if
-    /// optimizations are on).
+    /// Returns whether the argument is known at compile-time.
     ///
-    /// "Constant" in this context is not the same as a constant in Rust. As
-    /// such, this should only be used for optimizations.
+    /// 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
+    /// to select between these two variants. The `if` will be optimized away
+    /// and only the desired branch remains.
     ///
-    /// Note that, unlike most intrinsics, this is safe to call;
-    /// it does not require an `unsafe` block.
-    /// Therefore, implementations must not require the user to uphold
-    /// any safety invariants.
-    #[rustc_const_stable(feature = "todo", since = "never")]
-    #[rustc_safe_intrinsic]
+    /// Formally speaking, this function non-deterministically returns `true`
+    /// or `false`, and the caller has to ensure sound behavior for both cases.
+    /// In other words, the following code has *Undefined Behavior*:
+    ///
+    /// ```rust
+    /// if !is_compile_time_known(0) { unreachable_unchecked(); }
+    /// ```
+    ///
+    /// Unsafe code may not rely on `is_compile_time_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")]
     #[rustc_nounwind]
     #[cfg(not(bootstrap))]
-    pub fn is_constant<T>(arg: T) -> bool;
+    pub fn is_compile_time_known<T>(arg: T) -> bool;
 }
 
 // Some functions are defined here because they accidentally got made

library/core/src/lib.rs

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

library/core/src/num/int_macros.rs

@@ -2088,9 +2088,14 @@ macro_rules! int_impl {
                       without modifying the original"]
         #[inline]
         #[rustc_inherit_overflow_checks]
+        #[rustc_allow_const_fn_unstable(is_compile_time_known)]
         pub const fn pow(self, mut exp: u32) -> Self {
             #[cfg(not(bootstrap))]
-            if intrinsics::is_constant(self) && self > 0 && (self & (self - 1) == 0) {
+            // SAFETY: This path has the same behavior as the other.
+            if unsafe { intrinsics::is_compile_time_known(self) }
+                && self > 0
+                && (self & (self - 1) == 0)
+            {
                 let power_used = match self.checked_ilog2() {
                     Some(v) => v,
                     // SAFETY: We just checked this is a power of two. and above zero.
@@ -2099,7 +2104,9 @@ macro_rules! int_impl {
                 // So it panics. Have to use `overflowing_mul` to efficiently set the
                 // result to 0 if not.
                 #[cfg(debug_assertions)]
-                power_used * exp;
+                {
+                    _ = power_used * exp;
+                }
                 let (num_shl, overflowed) = power_used.overflowing_mul(exp);
                 let fine = !overflowed
                     & (num_shl < (mem::size_of::<Self>() * 8) as u32);

library/core/src/num/uint_macros.rs

@@ -1973,6 +1973,7 @@ macro_rules! uint_impl {
                       without modifying the original"]
         #[inline]
         #[rustc_inherit_overflow_checks]
+        #[rustc_allow_const_fn_unstable(is_compile_time_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,7 +1987,8 @@ macro_rules! uint_impl {
             // instruction, but we must add a couple more checks for parity with
             // our own `pow`.
             #[cfg(not(bootstrap))]
-            if intrinsics::is_constant(self) && self.is_power_of_two() {
+            // SAFETY: This path has the same behavior as the other.
+            if unsafe { intrinsics::is_compile_time_known(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
@@ -1996,7 +1998,9 @@ macro_rules! uint_impl {
                 // So it panics. Have to use `overflowing_mul` to efficiently set the
                 // result to 0 if not.
                 #[cfg(debug_assertions)]
-                power_used * exp;
+                {
+                    _ = power_used * exp;
+                }
                 let (num_shl, overflowed) = power_used.overflowing_mul(exp);
                 let fine = !overflowed
                     & (num_shl < (mem::size_of::<Self>() * 8) as u32);

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

@@ -141,6 +141,18 @@ 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,
+                )?;
+            }
+
             // Floating-point operations
             "fabsf32" => {
                 let [f] = check_arg_count(args)?;
@@ -417,4 +429,59 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
 
         Ok(())
     }
+<<<<<<< HEAD
+=======
+
+    fn float_to_int_unchecked<F>(
+        &self,
+        f: F,
+        dest_ty: Ty<'tcx>,
+    ) -> InterpResult<'tcx, Scalar<Provenance>>
+    where
+        F: Float + Into<Scalar<Provenance>>,
+    {
+        let this = self.eval_context_ref();
+
+        // Step 1: cut off the fractional part of `f`. The result of this is
+        // guaranteed to be precisely representable in IEEE floats.
+        let f = f.round_to_integral(Round::TowardZero).value;
+
+        // Step 2: Cast the truncated float to the target integer type and see if we lose any information in this step.
+        Ok(match dest_ty.kind() {
+            // Unsigned
+            ty::Uint(t) => {
+                let size = Integer::from_uint_ty(this, *t).size();
+                let res = f.to_u128(size.bits_usize());
+                if res.status.is_empty() {
+                    // No status flags means there was no further rounding or other loss of precision.
+                    Scalar::from_uint(res.value, size)
+                } else {
+                    // `f` was not representable in this integer type.
+                    throw_ub_format!(
+                        "`float_to_int_unchecked` intrinsic called on {f} which cannot be represented in target type `{dest_ty:?}`",
+                    );
+                }
+            }
+            // Signed
+            ty::Int(t) => {
+                let size = Integer::from_int_ty(this, *t).size();
+                let res = f.to_i128(size.bits_usize());
+                if res.status.is_empty() {
+                    // No status flags means there was no further rounding or other loss of precision.
+                    Scalar::from_int(res.value, size)
+                } else {
+                    // `f` was not representable in this integer type.
+                    throw_ub_format!(
+                        "`float_to_int_unchecked` intrinsic called on {f} which cannot be represented in target type `{dest_ty:?}`",
+                    );
+                }
+            }
+            // Nothing else
+            _ => 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)
 }

tests/codegen/is_constant.rs

@@ -6,8 +6,8 @@
 pub fn a(exp: u32) -> u64 {
     // CHECK: %[[R:.+]] = and i32 %exp, 63
     // CHECK: %[[R:.+]] = zext i32 %[[R:.+]] to i64
-    // CHECK: %[[R:.+]].i = shl nuw i64 1, %[[R:.+]]
-    // CHECK: ret i64 %[[R:.+]].i
+    // CHECK: %[[R:.+]] = shl nuw i64 %[[R:.+]].i, %[[R:.+]]
+    // CHECK: ret i64 %[[R:.+]]
     2u64.pow(exp)
 }
 
@@ -21,37 +21,43 @@ pub fn b(exp: u32) -> i64 {
 pub fn c(exp: u32) -> u32 {
     // CHECK: %[[R:.+]].0.i = shl i32 %exp, 1
     // CHECK: %[[R:.+]].1.i = icmp sgt i32 %exp, -1
-    // CHECK: %[[R:.+]] = and i32 %[[R:.+]].0.i, 30
-    // CHECK: %[[R:.+]].i = zext i1 %[[R:.+]].1.i to i32
-    // CHECK: %[[R:.+]] = shl nuw nsw i32 %[[R:.+]].i, %[[R:.+]]
+    // CHECK: %[[R:.+]].i = icmp ult i32 %[[R:.+]].0.i, 32
+    // CHECK: %fine.i = and i1 %[[R:.+]].1.i, %[[R:.+]].i
+    // CHECK: %0 = and i32 %[[R:.+]].0.i, 30
+    // CHECK: %[[R:.+]].i = zext i1 %fine.i to i32
+    // CHECK: %[[R:.+]] = shl nuw nsw i32 %[[R:.+]].i, %0
     // CHECK: ret i32 %[[R:.+]]
     4u32.pow(exp)
 }
 
 // CHECK-LABEL: @d(
 #[no_mangle]
 pub fn d(exp: u32) -> u32 {
-    // CHECK: %[[R:.+]] = tail call { i32, i1 } @llvm.umul.with.overflow.i32(i32 %exp, i32 5)
+    // CHECK: tail call { i32, i1 } @llvm.umul.with.overflow.i32(i32 %exp, i32 5)
     // CHECK: %[[R:.+]].0.i = extractvalue { i32, i1 } %[[R:.+]], 0
     // CHECK: %[[R:.+]].1.i = extractvalue { i32, i1 } %[[R:.+]], 1
     // CHECK: %[[R:.+]].i = xor i1 %[[R:.+]].1.i, true
+    // CHECK: %[[R:.+]].i = icmp ult i32 %[[R:.+]].0.i, 32
+    // CHECK: %fine.i = and i1 %[[R:.+]].i, %[[R:.+]].i
     // CHECK: %[[R:.+]] = and i32 %[[R:.+]].0.i, 31
-    // CHECK: %[[R:.+]].i = zext i1 %[[R:.+]].i to i32
-    // CHECK: %[[R:.+]] = shl nuw i32 %[[R:.+]].i, %[[R:.+]]
+    // CHECK: %[[R:.+]].i = zext i1 %fine.i to i32
+    // CHECK: %[[R:.+]] = shl nuw i32 %[[R:.+]].i, %1
     // CHECK: ret i32 %[[R:.+]]
     32u32.pow(exp)
 }
 
 // CHECK-LABEL: @e(
 #[no_mangle]
 pub fn e(exp: u32) -> i32 {
-    // CHECK: %[[R:.+]] = tail call { i32, i1 } @llvm.umul.with.overflow.i32(i32 %exp, i32 5)
+    // CHECK: tail call { i32, i1 } @llvm.umul.with.overflow.i32(i32 %exp, i32 5)
+    // CHECK: %[[R:.+]].0.i = extractvalue { i32, i1 } %[[R:.+]], 0
+    // CHECK: %[[R:.+]].i = icmp ult i32 %[[R:.+]].0.i, 32
     // CHECK: %[[R:.+]].1.i = extractvalue { i32, i1 } %[[R:.+]], 1
     // CHECK: %[[R:.+]].i = xor i1 %[[R:.+]].1.i, true
-    // CHECK: %[[R:.+]].i = zext i1 %[[R:.+]].i to i32
-    // CHECK: %[[R:.+]].0.i = extractvalue { i32, i1 } %[[R:.+]], 0
+    // CHECK: %fine.i = and i1 %[[R:.+]].i, %[[R:.+]].i
+    // CHECK: %[[R:.+]].i = zext i1 %fine.i to i32
     // CHECK: %[[R:.+]] = and i32 %[[R:.+]].0.i, 31
-    // CHECK: %[[R:.+]].010.i = shl nuw i32 %[[R:.+]].i, %[[R:.+]]
-    // CHECK: ret i32 %[[R:.+]].010.i
+    // CHECK: %[[R:.+]] = shl nuw i32 %[[R:.+]].i, %1
+    // CHECK: ret i32 %[[R:.+]]
     32i32.pow(exp)
 }