mirror of
https://github.com/rust-lang/rust
synced 2024-10-01 06:14:33 +00:00
Auto merge of #124703 - matthiaskrgr:rollup-2lljptd, r=matthiaskrgr
Rollup of 8 pull requests Successful merges: - #123356 (Reduce code size of `thread::set_current`) - #124159 (Move thread parking to `sys::sync`) - #124293 (Let miri and const eval execute intrinsics' fallback bodies) - #124677 (Set non-leaf frame pointers on Fuchsia targets) - #124692 (We do not coerce `&mut &mut T -> *mut mut T`) - #124698 (Rewrite `rustdoc-determinism` test in Rust) - #124700 (Remove an unnecessary cast) - #124701 (Docs: suggest `uN::checked_sub` instead of check-then-unchecked) r? `@ghost` `@rustbot` modify labels: rollup
This commit is contained in:
bors
commit
d7ea27808d
|
|
@ -105,7 +105,7 @@ fn call_intrinsic(
|
|||
_destination: &interpret::MPlaceTy<'tcx, Self::Provenance>,
|
||||
_target: Option<BasicBlock>,
|
||||
_unwind: UnwindAction,
|
||||
) -> interpret::InterpResult<'tcx> {
|
||||
) -> interpret::InterpResult<'tcx, Option<ty::Instance<'tcx>>> {
|
||||
unimplemented!()
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -459,16 +459,26 @@ fn call_intrinsic(
|
|||
dest: &MPlaceTy<'tcx, Self::Provenance>,
|
||||
target: Option<mir::BasicBlock>,
|
||||
_unwind: mir::UnwindAction,
|
||||
) -> InterpResult<'tcx> {
|
||||
) -> InterpResult<'tcx, Option<ty::Instance<'tcx>>> {
|
||||
// Shared intrinsics.
|
||||
if ecx.emulate_intrinsic(instance, args, dest, target)? {
|
||||
return Ok(());
|
||||
return Ok(None);
|
||||
}
|
||||
let intrinsic_name = ecx.tcx.item_name(instance.def_id());
|
||||
|
||||
// CTFE-specific intrinsics.
|
||||
let Some(ret) = target else {
|
||||
throw_unsup_format!("intrinsic `{intrinsic_name}` is not supported at compile-time");
|
||||
// Handle diverging intrinsics. We can't handle any of them (that are not already
|
||||
// handled above), but check if there is a fallback body.
|
||||
if ecx.tcx.intrinsic(instance.def_id()).unwrap().must_be_overridden {
|
||||
throw_unsup_format!(
|
||||
"intrinsic `{intrinsic_name}` is not supported at compile-time"
|
||||
);
|
||||
}
|
||||
return Ok(Some(ty::Instance {
|
||||
def: ty::InstanceDef::Item(instance.def_id()),
|
||||
args: instance.args,
|
||||
}));
|
||||
};
|
||||
match intrinsic_name {
|
||||
sym::ptr_guaranteed_cmp => {
|
||||
|
|
@ -536,14 +546,21 @@ fn call_intrinsic(
|
|||
// not the optimization stage.)
|
||||
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"
|
||||
);
|
||||
// We haven't handled the intrinsic, let's see if we can use a fallback body.
|
||||
if ecx.tcx.intrinsic(instance.def_id()).unwrap().must_be_overridden {
|
||||
throw_unsup_format!(
|
||||
"intrinsic `{intrinsic_name}` is not supported at compile-time"
|
||||
);
|
||||
}
|
||||
return Ok(Some(ty::Instance {
|
||||
def: ty::InstanceDef::Item(instance.def_id()),
|
||||
args: instance.args,
|
||||
}));
|
||||
}
|
||||
}
|
||||
|
||||
ecx.go_to_block(ret);
|
||||
Ok(())
|
||||
Ok(None)
|
||||
}
|
||||
|
||||
fn assert_panic(
|
||||
|
|
|
|||
|
|
@ -414,7 +414,7 @@ pub fn emulate_intrinsic(
|
|||
}
|
||||
self.copy_op(&self.project_index(&input, index)?, dest)?;
|
||||
}
|
||||
sym::likely | sym::unlikely | sym::black_box => {
|
||||
sym::black_box => {
|
||||
// These just return their argument
|
||||
self.copy_op(&args[0], dest)?;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -216,6 +216,9 @@ fn call_extra_fn(
|
|||
|
||||
/// Directly process an intrinsic without pushing a stack frame. It is the hook's
|
||||
/// responsibility to advance the instruction pointer as appropriate.
|
||||
///
|
||||
/// Returns `None` if the intrinsic was fully handled.
|
||||
/// Otherwise, returns an `Instance` of the function that implements the intrinsic.
|
||||
fn call_intrinsic(
|
||||
ecx: &mut InterpCx<'mir, 'tcx, Self>,
|
||||
instance: ty::Instance<'tcx>,
|
||||
|
|
@ -223,7 +226,7 @@ fn call_intrinsic(
|
|||
destination: &MPlaceTy<'tcx, Self::Provenance>,
|
||||
target: Option<mir::BasicBlock>,
|
||||
unwind: mir::UnwindAction,
|
||||
) -> InterpResult<'tcx>;
|
||||
) -> InterpResult<'tcx, Option<ty::Instance<'tcx>>>;
|
||||
|
||||
/// Called to evaluate `Assert` MIR terminators that trigger a panic.
|
||||
fn assert_panic(
|
||||
|
|
|
|||
|
|
@ -539,14 +539,28 @@ pub(crate) fn eval_fn_call(
|
|||
ty::InstanceDef::Intrinsic(def_id) => {
|
||||
assert!(self.tcx.intrinsic(def_id).is_some());
|
||||
// FIXME: Should `InPlace` arguments be reset to uninit?
|
||||
M::call_intrinsic(
|
||||
if let Some(fallback) = M::call_intrinsic(
|
||||
self,
|
||||
instance,
|
||||
&self.copy_fn_args(args),
|
||||
destination,
|
||||
target,
|
||||
unwind,
|
||||
)
|
||||
)? {
|
||||
assert!(!self.tcx.intrinsic(fallback.def_id()).unwrap().must_be_overridden);
|
||||
assert!(matches!(fallback.def, ty::InstanceDef::Item(_)));
|
||||
return self.eval_fn_call(
|
||||
FnVal::Instance(fallback),
|
||||
(caller_abi, caller_fn_abi),
|
||||
args,
|
||||
with_caller_location,
|
||||
destination,
|
||||
target,
|
||||
unwind,
|
||||
);
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
ty::InstanceDef::VTableShim(..)
|
||||
| ty::InstanceDef::ReifyShim(..)
|
||||
|
|
|
|||
|
|
@ -141,7 +141,7 @@ pub(crate) fn registered_tools(tcx: TyCtxt<'_>, (): ()) -> RegisteredTools {
|
|||
}
|
||||
// We implicitly add `rustfmt`, `clippy`, `diagnostic` to known tools,
|
||||
// but it's not an error to register them explicitly.
|
||||
let predefined_tools = [sym::clippy, sym::rustfmt, sym::diagnostic];
|
||||
let predefined_tools = [sym::clippy, sym::rustfmt, sym::diagnostic, sym::miri];
|
||||
registered_tools.extend(predefined_tools.iter().cloned().map(Ident::with_dummy_span));
|
||||
registered_tools
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,4 +1,6 @@
|
|||
use crate::spec::{crt_objects, cvs, Cc, LinkOutputKind, LinkerFlavor, Lld, TargetOptions};
|
||||
use crate::spec::{
|
||||
crt_objects, cvs, Cc, FramePointer, LinkOutputKind, LinkerFlavor, Lld, TargetOptions,
|
||||
};
|
||||
|
||||
pub fn opts() -> TargetOptions {
|
||||
// This mirrors the linker options provided by clang. We presume lld for
|
||||
|
|
@ -38,6 +40,7 @@ pub fn opts() -> TargetOptions {
|
|||
]),
|
||||
position_independent_executables: true,
|
||||
has_thread_local: true,
|
||||
frame_pointer: FramePointer::NonLeaf,
|
||||
..Default::default()
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -987,6 +987,7 @@ pub unsafe fn drop_in_place<T: ?Sized>(to_drop: *mut T) {
|
|||
#[unstable(feature = "core_intrinsics", issue = "none")]
|
||||
#[rustc_intrinsic]
|
||||
#[rustc_nounwind]
|
||||
#[cfg_attr(not(bootstrap), miri::intrinsic_fallback_checks_ub)]
|
||||
pub const fn likely(b: bool) -> bool {
|
||||
b
|
||||
}
|
||||
|
|
@ -1006,6 +1007,7 @@ pub const fn likely(b: bool) -> bool {
|
|||
#[unstable(feature = "core_intrinsics", issue = "none")]
|
||||
#[rustc_intrinsic]
|
||||
#[rustc_nounwind]
|
||||
#[cfg_attr(not(bootstrap), miri::intrinsic_fallback_checks_ub)]
|
||||
pub const fn unlikely(b: bool) -> bool {
|
||||
b
|
||||
}
|
||||
|
|
@ -2469,6 +2471,7 @@ pub const fn unlikely(b: bool) -> bool {
|
|||
#[rustc_nounwind]
|
||||
#[rustc_do_not_const_check]
|
||||
#[inline]
|
||||
#[cfg_attr(not(bootstrap), miri::intrinsic_fallback_checks_ub)]
|
||||
pub const fn ptr_guaranteed_cmp<T>(ptr: *const T, other: *const T) -> u8 {
|
||||
(ptr == other) as u8
|
||||
}
|
||||
|
|
@ -2733,8 +2736,10 @@ pub const fn ub_checks() -> bool {
|
|||
#[unstable(feature = "core_intrinsics", issue = "none")]
|
||||
#[rustc_nounwind]
|
||||
#[rustc_intrinsic]
|
||||
#[cfg_attr(not(bootstrap), miri::intrinsic_fallback_checks_ub)]
|
||||
pub const unsafe fn const_allocate(_size: usize, _align: usize) -> *mut u8 {
|
||||
// const eval overrides this function, but runtime code should always just return null pointers.
|
||||
// const eval overrides this function, but runtime code for now just returns null pointers.
|
||||
// See <https://github.com/rust-lang/rust/issues/93935>.
|
||||
crate::ptr::null_mut()
|
||||
}
|
||||
|
||||
|
|
@ -2752,7 +2757,10 @@ pub const fn ub_checks() -> bool {
|
|||
#[unstable(feature = "core_intrinsics", issue = "none")]
|
||||
#[rustc_nounwind]
|
||||
#[rustc_intrinsic]
|
||||
pub const unsafe fn const_deallocate(_ptr: *mut u8, _size: usize, _align: usize) {}
|
||||
#[cfg_attr(not(bootstrap), miri::intrinsic_fallback_checks_ub)]
|
||||
pub const unsafe fn const_deallocate(_ptr: *mut u8, _size: usize, _align: usize) {
|
||||
// Runtime NOP
|
||||
}
|
||||
|
||||
/// `ptr` must point to a vtable.
|
||||
/// The intrinsic will return the size stored in that vtable.
|
||||
|
|
|
|||
|
|
@ -77,7 +77,7 @@ macro_rules! uint_impl {
|
|||
without modifying the original"]
|
||||
#[inline(always)]
|
||||
pub const fn count_ones(self) -> u32 {
|
||||
return intrinsics::ctpop(self as $ActualT);
|
||||
return intrinsics::ctpop(self);
|
||||
}
|
||||
|
||||
/// Returns the number of zeros in the binary representation of `self`.
|
||||
|
|
@ -636,6 +636,31 @@ pub const fn strict_sub(self, rhs: Self) -> Self {
|
|||
/// If you're just trying to avoid the panic in debug mode, then **do not**
|
||||
/// use this. Instead, you're looking for [`wrapping_sub`].
|
||||
///
|
||||
/// If you find yourself writing code like this:
|
||||
///
|
||||
/// ```
|
||||
/// # let foo = 30_u32;
|
||||
/// # let bar = 20;
|
||||
/// if foo >= bar {
|
||||
/// // SAFETY: just checked it will not overflow
|
||||
/// let diff = unsafe { foo.unchecked_sub(bar) };
|
||||
/// // ... use diff ...
|
||||
/// }
|
||||
/// ```
|
||||
///
|
||||
/// Consider changing it to
|
||||
///
|
||||
/// ```
|
||||
/// # let foo = 30_u32;
|
||||
/// # let bar = 20;
|
||||
/// if let Some(diff) = foo.checked_sub(bar) {
|
||||
/// // ... use diff ...
|
||||
/// }
|
||||
/// ```
|
||||
///
|
||||
/// As that does exactly the same thing -- including telling the optimizer
|
||||
/// that the subtraction cannot overflow -- but avoids needing `unsafe`.
|
||||
///
|
||||
/// # Safety
|
||||
///
|
||||
/// This results in undefined behavior when
|
||||
|
|
|
|||
|
|
@ -67,7 +67,7 @@ pub(super) fn lock() -> MutexGuard<'static, Vec<Task>> {
|
|||
pub mod wait_notify {
|
||||
use crate::pin::Pin;
|
||||
use crate::sync::Arc;
|
||||
use crate::sys_common::thread_parking::Parker;
|
||||
use crate::sys::sync::Parker;
|
||||
|
||||
pub struct Notifier(Arc<Parker>);
|
||||
|
||||
|
|
|
|||
|
|
@ -30,8 +30,6 @@
|
|||
pub mod thread_local_dtor;
|
||||
#[path = "../unix/thread_local_key.rs"]
|
||||
pub mod thread_local_key;
|
||||
#[path = "../unsupported/thread_parking.rs"]
|
||||
pub mod thread_parking;
|
||||
#[allow(non_upper_case_globals)]
|
||||
#[path = "../unix/time.rs"]
|
||||
pub mod time;
|
||||
|
|
|
|||
|
|
@ -30,8 +30,6 @@
|
|||
pub mod thread;
|
||||
#[path = "../unsupported/thread_local_key.rs"]
|
||||
pub mod thread_local_key;
|
||||
#[path = "../unsupported/thread_parking.rs"]
|
||||
pub mod thread_parking;
|
||||
pub mod time;
|
||||
|
||||
mod helpers;
|
||||
|
|
|
|||
|
|
@ -1,3 +1,7 @@
|
|||
// Only used on NetBSD. If other platforms start using id-based parking, use
|
||||
// separate modules for each platform.
|
||||
#![cfg(target_os = "netbsd")]
|
||||
|
||||
use crate::ffi::{c_int, c_void};
|
||||
use crate::ptr;
|
||||
use crate::time::Duration;
|
||||
|
|
@ -1,24 +0,0 @@
|
|||
//! Thread parking on systems without futex support.
|
||||
|
||||
#![cfg(not(any(
|
||||
target_os = "linux",
|
||||
target_os = "android",
|
||||
all(target_os = "emscripten", target_feature = "atomics"),
|
||||
target_os = "freebsd",
|
||||
target_os = "openbsd",
|
||||
target_os = "dragonfly",
|
||||
target_os = "fuchsia",
|
||||
)))]
|
||||
|
||||
cfg_if::cfg_if! {
|
||||
if #[cfg(all(target_vendor = "apple", not(miri)))] {
|
||||
mod darwin;
|
||||
pub use darwin::Parker;
|
||||
} else if #[cfg(target_os = "netbsd")] {
|
||||
mod netbsd;
|
||||
pub use netbsd::{current, park, park_timeout, unpark, ThreadId};
|
||||
} else {
|
||||
mod pthread;
|
||||
pub use pthread::Parker;
|
||||
}
|
||||
}
|
||||
|
|
@ -14,7 +14,6 @@
|
|||
#[cfg(target_thread_local)]
|
||||
pub mod thread_local_dtor;
|
||||
pub mod thread_local_key;
|
||||
pub mod thread_parking;
|
||||
pub mod time;
|
||||
|
||||
mod common;
|
||||
|
|
|
|||
|
|
@ -39,13 +39,6 @@
|
|||
pub mod thread_local_key;
|
||||
pub mod time;
|
||||
|
||||
cfg_if::cfg_if! {
|
||||
if #[cfg(not(target_feature = "atomics"))] {
|
||||
#[path = "../unsupported/thread_parking.rs"]
|
||||
pub mod thread_parking;
|
||||
}
|
||||
}
|
||||
|
||||
#[path = "../unsupported/common.rs"]
|
||||
#[deny(unsafe_op_in_unsafe_fn)]
|
||||
#[allow(unused)]
|
||||
|
|
|
|||
|
|
@ -41,15 +41,6 @@
|
|||
#[path = "../wasi/time.rs"]
|
||||
pub mod time;
|
||||
|
||||
cfg_if::cfg_if! {
|
||||
if #[cfg(target_feature = "atomics")] {
|
||||
compile_error!("The wasm32-wasip2 target does not support atomics");
|
||||
} else {
|
||||
#[path = "../unsupported/thread_parking.rs"]
|
||||
pub mod thread_parking;
|
||||
}
|
||||
}
|
||||
|
||||
#[path = "../unsupported/common.rs"]
|
||||
#[deny(unsafe_op_in_unsafe_fn)]
|
||||
#[allow(unused)]
|
||||
|
|
|
|||
|
|
@ -50,8 +50,6 @@
|
|||
} else {
|
||||
#[path = "../unsupported/thread.rs"]
|
||||
pub mod thread;
|
||||
#[path = "../unsupported/thread_parking.rs"]
|
||||
pub mod thread_parking;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -33,7 +33,6 @@
|
|||
pub mod thread;
|
||||
pub mod thread_local_dtor;
|
||||
pub mod thread_local_key;
|
||||
pub mod thread_parking;
|
||||
pub mod time;
|
||||
cfg_if::cfg_if! {
|
||||
if #[cfg(not(target_vendor = "uwp"))] {
|
||||
|
|
|
|||
|
|
@ -18,7 +18,6 @@
|
|||
pub mod stdio;
|
||||
pub mod thread;
|
||||
pub mod thread_local_key;
|
||||
pub mod thread_parking;
|
||||
pub mod time;
|
||||
|
||||
#[path = "../unsupported/common.rs"]
|
||||
|
|
|
|||
|
|
@ -32,9 +32,6 @@
|
|||
#[path = "../unsupported/thread.rs"]
|
||||
pub mod thread;
|
||||
|
||||
#[path = "../unsupported/thread_parking.rs"]
|
||||
pub mod thread_parking;
|
||||
|
||||
mod abi;
|
||||
|
||||
use crate::io as std_io;
|
||||
|
|
|
|||
|
|
@ -2,8 +2,10 @@
|
|||
mod mutex;
|
||||
mod once;
|
||||
mod rwlock;
|
||||
mod thread_parking;
|
||||
|
||||
pub use condvar::Condvar;
|
||||
pub use mutex::Mutex;
|
||||
pub use once::{Once, OnceState};
|
||||
pub use rwlock::RwLock;
|
||||
pub use thread_parking::Parker;
|
||||
|
|
|
|||
|
|
@ -10,6 +10,8 @@
|
|||
//! provided by libdispatch, as the underlying Mach semaphore is only dubiously
|
||||
//! public.
|
||||
|
||||
#![allow(non_camel_case_types)]
|
||||
|
||||
use crate::pin::Pin;
|
||||
use crate::sync::atomic::{
|
||||
AtomicI8,
|
||||
|
|
@ -18,7 +18,20 @@
|
|||
))] {
|
||||
mod id;
|
||||
pub use id::Parker;
|
||||
} else if #[cfg(target_os = "windows")] {
|
||||
mod windows;
|
||||
pub use windows::Parker;
|
||||
} else if #[cfg(all(target_vendor = "apple", not(miri)))] {
|
||||
mod darwin;
|
||||
pub use darwin::Parker;
|
||||
} else if #[cfg(target_os = "xous")] {
|
||||
mod xous;
|
||||
pub use xous::Parker;
|
||||
} else if #[cfg(target_family = "unix")] {
|
||||
mod pthread;
|
||||
pub use pthread::Parker;
|
||||
} else {
|
||||
pub use crate::sys::thread_parking::Parker;
|
||||
mod unsupported;
|
||||
pub use unsupported::Parker;
|
||||
}
|
||||
}
|
||||
|
|
@ -134,7 +134,7 @@ pub unsafe fn new_in_place(parker: *mut Parker) {
|
|||
// This implementation doesn't require `unsafe`, but other implementations
|
||||
// may assume this is only called by the thread that owns the Parker.
|
||||
//
|
||||
// For memory ordering, see std/src/sys_common/thread_parking/futex.rs
|
||||
// For memory ordering, see futex.rs
|
||||
pub unsafe fn park(self: Pin<&Self>) {
|
||||
// If we were previously notified then we consume this notification and
|
||||
// return quickly.
|
||||
|
|
@ -26,7 +26,6 @@
|
|||
pub mod lazy_box;
|
||||
pub mod process;
|
||||
pub mod thread_local_dtor;
|
||||
pub mod thread_parking;
|
||||
pub mod wstr;
|
||||
pub mod wtf8;
|
||||
|
||||
|
|
|
|||
|
|
@ -174,8 +174,8 @@
|
|||
use crate::str;
|
||||
use crate::sync::atomic::{AtomicUsize, Ordering};
|
||||
use crate::sync::Arc;
|
||||
use crate::sys::sync::Parker;
|
||||
use crate::sys::thread as imp;
|
||||
use crate::sys_common::thread_parking::Parker;
|
||||
use crate::sys_common::{AsInner, IntoInner};
|
||||
use crate::time::{Duration, Instant};
|
||||
|
||||
|
|
@ -703,9 +703,14 @@ pub fn spawn<F, T>(f: F) -> JoinHandle<T>
|
|||
|
||||
/// Sets the thread handle for the current thread.
|
||||
///
|
||||
/// Panics if the handle has been set already or when called from a TLS destructor.
|
||||
/// Aborts if the handle has been set already to reduce code size.
|
||||
pub(crate) fn set_current(thread: Thread) {
|
||||
CURRENT.with(|current| current.set(thread).unwrap());
|
||||
// Using `unwrap` here can add ~3kB to the binary size. We have complete
|
||||
// control over where this is called, so just abort if there is a bug.
|
||||
CURRENT.with(|current| match current.set(thread) {
|
||||
Ok(()) => {}
|
||||
Err(_) => rtabort!("thread::set_current should only be called once per thread"),
|
||||
});
|
||||
}
|
||||
|
||||
/// Gets a handle to the thread that invokes it.
|
||||
|
|
|
|||
|
|
@ -986,7 +986,7 @@ fn call_intrinsic(
|
|||
dest: &MPlaceTy<'tcx, Provenance>,
|
||||
ret: Option<mir::BasicBlock>,
|
||||
unwind: mir::UnwindAction,
|
||||
) -> InterpResult<'tcx> {
|
||||
) -> InterpResult<'tcx, Option<ty::Instance<'tcx>>> {
|
||||
ecx.call_intrinsic(instance, args, dest, ret, unwind)
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -14,12 +14,13 @@ pub enum AtomicOp {
|
|||
impl<'mir, 'tcx: 'mir> EvalContextExt<'mir, 'tcx> for crate::MiriInterpCx<'mir, 'tcx> {}
|
||||
pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
|
||||
/// Calls the atomic intrinsic `intrinsic`; the `atomic_` prefix has already been removed.
|
||||
/// Returns `Ok(true)` if the intrinsic was handled.
|
||||
fn emulate_atomic_intrinsic(
|
||||
&mut self,
|
||||
intrinsic_name: &str,
|
||||
args: &[OpTy<'tcx, Provenance>],
|
||||
dest: &MPlaceTy<'tcx, Provenance>,
|
||||
) -> InterpResult<'tcx> {
|
||||
) -> InterpResult<'tcx, bool> {
|
||||
let this = self.eval_context_mut();
|
||||
|
||||
let intrinsic_structure: Vec<_> = intrinsic_name.split('_').collect();
|
||||
|
|
@ -113,9 +114,9 @@ fn fence_ord<'tcx>(ord: &str) -> InterpResult<'tcx, AtomicFenceOrd> {
|
|||
this.atomic_rmw_op(args, dest, AtomicOp::Max, rw_ord(ord)?)?;
|
||||
}
|
||||
|
||||
_ => throw_unsup_format!("unimplemented intrinsic: `atomic_{intrinsic_name}`"),
|
||||
_ => return Ok(false),
|
||||
}
|
||||
Ok(())
|
||||
Ok(true)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -11,6 +11,7 @@
|
|||
ty::{self, FloatTy},
|
||||
};
|
||||
use rustc_target::abi::Size;
|
||||
use rustc_span::{sym, Symbol};
|
||||
|
||||
use crate::*;
|
||||
use atomic::EvalContextExt as _;
|
||||
|
|
@ -26,12 +27,12 @@ fn call_intrinsic(
|
|||
dest: &MPlaceTy<'tcx, Provenance>,
|
||||
ret: Option<mir::BasicBlock>,
|
||||
_unwind: mir::UnwindAction,
|
||||
) -> InterpResult<'tcx> {
|
||||
) -> InterpResult<'tcx, Option<ty::Instance<'tcx>>> {
|
||||
let this = self.eval_context_mut();
|
||||
|
||||
// See if the core engine can handle this intrinsic.
|
||||
if this.emulate_intrinsic(instance, args, dest, ret)? {
|
||||
return Ok(());
|
||||
return Ok(None);
|
||||
}
|
||||
let intrinsic_name = this.tcx.item_name(instance.def_id());
|
||||
let intrinsic_name = intrinsic_name.as_str();
|
||||
|
|
@ -48,32 +49,50 @@ fn call_intrinsic(
|
|||
|
||||
// All remaining supported intrinsics have a return place.
|
||||
let ret = match ret {
|
||||
// FIXME: add fallback body support once we actually have a diverging intrinsic with a fallback body
|
||||
None => throw_unsup_format!("unimplemented (diverging) intrinsic: `{intrinsic_name}`"),
|
||||
Some(p) => p,
|
||||
};
|
||||
|
||||
// Some intrinsics are special and need the "ret".
|
||||
match intrinsic_name {
|
||||
"catch_unwind" => return this.handle_catch_unwind(args, dest, ret),
|
||||
"catch_unwind" => {
|
||||
this.handle_catch_unwind(args, dest, ret)?;
|
||||
return Ok(None);
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
|
||||
// The rest jumps to `ret` immediately.
|
||||
this.emulate_intrinsic_by_name(intrinsic_name, instance.args, args, dest)?;
|
||||
if !this.emulate_intrinsic_by_name(intrinsic_name, instance.args, args, dest)? {
|
||||
// We haven't handled the intrinsic, let's see if we can use a fallback body.
|
||||
if this.tcx.intrinsic(instance.def_id()).unwrap().must_be_overridden {
|
||||
throw_unsup_format!("unimplemented intrinsic: `{intrinsic_name}`")
|
||||
}
|
||||
let intrinsic_fallback_checks_ub = Symbol::intern("intrinsic_fallback_checks_ub");
|
||||
if this.tcx.get_attrs_by_path(instance.def_id(), &[sym::miri, intrinsic_fallback_checks_ub]).next().is_none() {
|
||||
throw_unsup_format!("miri can only use intrinsic fallback bodies that check UB. After verifying that `{intrinsic_name}` does so, add the `#[miri::intrinsic_fallback_checks_ub]` attribute to it; also ping @rust-lang/miri when you do that");
|
||||
}
|
||||
return Ok(Some(ty::Instance {
|
||||
def: ty::InstanceDef::Item(instance.def_id()),
|
||||
args: instance.args,
|
||||
}))
|
||||
}
|
||||
|
||||
trace!("{:?}", this.dump_place(&dest.clone().into()));
|
||||
this.go_to_block(ret);
|
||||
Ok(())
|
||||
Ok(None)
|
||||
}
|
||||
|
||||
/// Emulates a Miri-supported intrinsic (not supported by the core engine).
|
||||
/// Returns `Ok(true)` if the intrinsic was handled.
|
||||
fn emulate_intrinsic_by_name(
|
||||
&mut self,
|
||||
intrinsic_name: &str,
|
||||
generic_args: ty::GenericArgsRef<'tcx>,
|
||||
args: &[OpTy<'tcx, Provenance>],
|
||||
dest: &MPlaceTy<'tcx, Provenance>,
|
||||
) -> InterpResult<'tcx> {
|
||||
) -> InterpResult<'tcx, bool> {
|
||||
let this = self.eval_context_mut();
|
||||
|
||||
if let Some(name) = intrinsic_name.strip_prefix("atomic_") {
|
||||
|
|
@ -84,24 +103,6 @@ fn emulate_intrinsic_by_name(
|
|||
}
|
||||
|
||||
match intrinsic_name {
|
||||
// Miri overwriting CTFE intrinsics.
|
||||
"ptr_guaranteed_cmp" => {
|
||||
let [left, right] = check_arg_count(args)?;
|
||||
let left = this.read_immediate(left)?;
|
||||
let right = this.read_immediate(right)?;
|
||||
let val = this.wrapping_binary_op(mir::BinOp::Eq, &left, &right)?;
|
||||
// We're type punning a bool as an u8 here.
|
||||
this.write_scalar(val.to_scalar(), dest)?;
|
||||
}
|
||||
"const_allocate" => {
|
||||
// For now, for compatibility with the run-time implementation of this, we just return null.
|
||||
// See <https://github.com/rust-lang/rust/issues/93935>.
|
||||
this.write_null(dest)?;
|
||||
}
|
||||
"const_deallocate" => {
|
||||
// complete NOP
|
||||
}
|
||||
|
||||
// Raw memory accesses
|
||||
"volatile_load" => {
|
||||
let [place] = check_arg_count(args)?;
|
||||
|
|
@ -425,9 +426,9 @@ fn emulate_intrinsic_by_name(
|
|||
throw_machine_stop!(TerminationInfo::Abort(format!("trace/breakpoint trap")))
|
||||
}
|
||||
|
||||
name => throw_unsup_format!("unimplemented intrinsic: `{name}`"),
|
||||
_ => return Ok(false),
|
||||
}
|
||||
|
||||
Ok(())
|
||||
Ok(true)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -16,13 +16,14 @@ pub(crate) enum MinMax {
|
|||
impl<'mir, 'tcx: 'mir> EvalContextExt<'mir, 'tcx> for crate::MiriInterpCx<'mir, 'tcx> {}
|
||||
pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
|
||||
/// Calls the simd intrinsic `intrinsic`; the `simd_` prefix has already been removed.
|
||||
/// Returns `Ok(true)` if the intrinsic was handled.
|
||||
fn emulate_simd_intrinsic(
|
||||
&mut self,
|
||||
intrinsic_name: &str,
|
||||
generic_args: ty::GenericArgsRef<'tcx>,
|
||||
args: &[OpTy<'tcx, Provenance>],
|
||||
dest: &MPlaceTy<'tcx, Provenance>,
|
||||
) -> InterpResult<'tcx> {
|
||||
) -> InterpResult<'tcx, bool> {
|
||||
let this = self.eval_context_mut();
|
||||
match intrinsic_name {
|
||||
#[rustfmt::skip]
|
||||
|
|
@ -743,9 +744,9 @@ enum Op {
|
|||
}
|
||||
}
|
||||
|
||||
name => throw_unsup_format!("unimplemented intrinsic: `simd_{name}`"),
|
||||
_ => return Ok(false),
|
||||
}
|
||||
Ok(())
|
||||
Ok(true)
|
||||
}
|
||||
|
||||
fn fminmax_op(
|
||||
|
|
|
|||
14
src/tools/miri/tests/fail/intrinsic_fallback_checks_ub.rs
Normal file
14
src/tools/miri/tests/fail/intrinsic_fallback_checks_ub.rs
Normal file
|
|
@ -0,0 +1,14 @@
|
|||
#![feature(rustc_attrs, effects)]
|
||||
|
||||
#[rustc_intrinsic]
|
||||
#[rustc_nounwind]
|
||||
#[rustc_do_not_const_check]
|
||||
#[inline]
|
||||
pub const fn ptr_guaranteed_cmp<T>(ptr: *const T, other: *const T) -> u8 {
|
||||
(ptr == other) as u8
|
||||
}
|
||||
|
||||
fn main() {
|
||||
ptr_guaranteed_cmp::<()>(std::ptr::null(), std::ptr::null());
|
||||
//~^ ERROR: can only use intrinsic fallback bodies that check UB.
|
||||
}
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
error: unsupported operation: miri can only use intrinsic fallback bodies that check UB. After verifying that `ptr_guaranteed_cmp` does so, add the `#[miri::intrinsic_fallback_checks_ub]` attribute to it; also ping @rust-lang/miri when you do that
|
||||
--> $DIR/intrinsic_fallback_checks_ub.rs:LL:CC
|
||||
|
|
||||
LL | ptr_guaranteed_cmp::<()>(std::ptr::null(), std::ptr::null());
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ miri can only use intrinsic fallback bodies that check UB. After verifying that `ptr_guaranteed_cmp` does so, add the `#[miri::intrinsic_fallback_checks_ub]` attribute to it; also ping @rust-lang/miri when you do that
|
||||
|
|
||||
= help: this is likely not a bug in the program; it indicates that the program performed an operation that the interpreter does not support
|
||||
= note: BACKTRACE:
|
||||
= note: inside `main` at $DIR/intrinsic_fallback_checks_ub.rs:LL:CC
|
||||
|
||||
note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
|
||||
|
||||
error: aborting due to 1 previous error
|
||||
|
||||
|
|
@ -245,7 +245,6 @@ run-make/rlib-format-packed-bundled-libs-3/Makefile
|
|||
run-make/rlib-format-packed-bundled-libs/Makefile
|
||||
run-make/rmeta-preferred/Makefile
|
||||
run-make/rustc-macro-dep-files/Makefile
|
||||
run-make/rustdoc-determinism/Makefile
|
||||
run-make/rustdoc-error-lines/Makefile
|
||||
run-make/rustdoc-io-error/Makefile
|
||||
run-make/rustdoc-map-file/Makefile
|
||||
|
|
|
|||
|
|
@ -1,16 +0,0 @@
|
|||
include ../tools.mk
|
||||
|
||||
# Assert that the search index is generated deterministically, regardless of the
|
||||
# order that crates are documented in.
|
||||
|
||||
# ignore-windows
|
||||
# Uses `diff`.
|
||||
|
||||
all:
|
||||
$(RUSTDOC) foo.rs -o $(TMPDIR)/foo_first
|
||||
$(RUSTDOC) bar.rs -o $(TMPDIR)/foo_first
|
||||
|
||||
$(RUSTDOC) bar.rs -o $(TMPDIR)/bar_first
|
||||
$(RUSTDOC) foo.rs -o $(TMPDIR)/bar_first
|
||||
|
||||
diff $(TMPDIR)/foo_first/search-index.js $(TMPDIR)/bar_first/search-index.js
|
||||
18
tests/run-make/rustdoc-determinism/rmake.rs
Normal file
18
tests/run-make/rustdoc-determinism/rmake.rs
Normal file
|
|
@ -0,0 +1,18 @@
|
|||
use run_make_support::{diff, rustc, rustdoc, tmp_dir};
|
||||
|
||||
/// Assert that the search index is generated deterministically, regardless of the
|
||||
/// order that crates are documented in.
|
||||
fn main() {
|
||||
let dir_first = tmp_dir().join("first");
|
||||
rustdoc().out_dir(&dir_first).input("foo.rs").run();
|
||||
rustdoc().out_dir(&dir_first).input("bar.rs").run();
|
||||
|
||||
let dir_second = tmp_dir().join("second");
|
||||
rustdoc().out_dir(&dir_second).input("bar.rs").run();
|
||||
rustdoc().out_dir(&dir_second).input("foo.rs").run();
|
||||
|
||||
diff()
|
||||
.expected_file(dir_first.join("search-index.js"))
|
||||
.actual_file(dir_second.join("search-index.js"))
|
||||
.run();
|
||||
}
|
||||
43
tests/ui/coercion/mut-mut-wont-coerce.rs
Normal file
43
tests/ui/coercion/mut-mut-wont-coerce.rs
Normal file
|
|
@ -0,0 +1,43 @@
|
|||
// Documents that Rust currently does not permit the coercion &mut &mut T -> *mut *mut T
|
||||
// Making this compile was a feature request in rust-lang/rust#34117 but this is currently
|
||||
// "working as intended". Allowing "deep pointer coercion" seems footgun-prone, and would
|
||||
// require proceeding carefully.
|
||||
use std::ops::{Deref, DerefMut};
|
||||
|
||||
struct Foo(i32);
|
||||
|
||||
struct SmartPtr<T>(*mut T);
|
||||
|
||||
impl<T> SmartPtr<T> {
|
||||
fn get_addr(&mut self) -> &mut *mut T {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> Deref for SmartPtr<T> {
|
||||
type Target = T;
|
||||
fn deref(&self) -> &T {
|
||||
unsafe { &*self.0 }
|
||||
}
|
||||
}
|
||||
impl<T> DerefMut for SmartPtr<T> {
|
||||
fn deref_mut(&mut self) -> &mut T {
|
||||
unsafe { &mut *self.0 }
|
||||
}
|
||||
}
|
||||
|
||||
/// Puts a Foo into the pointer provided by the caller
|
||||
fn make_foo(_: *mut *mut Foo) {
|
||||
unimplemented!()
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let mut result: SmartPtr<Foo> = SmartPtr(std::ptr::null_mut());
|
||||
make_foo(&mut &mut *result); //~ mismatched types
|
||||
//~^ expected `*mut *mut Foo`, found `&mut &mut Foo`
|
||||
make_foo(out(&mut result)); // works, but makes one wonder why above coercion cannot happen
|
||||
}
|
||||
|
||||
fn out<T>(ptr: &mut SmartPtr<T>) -> &mut *mut T {
|
||||
ptr.get_addr()
|
||||
}
|
||||
19
tests/ui/coercion/mut-mut-wont-coerce.stderr
Normal file
19
tests/ui/coercion/mut-mut-wont-coerce.stderr
Normal file
|
|
@ -0,0 +1,19 @@
|
|||
error[E0308]: mismatched types
|
||||
--> $DIR/mut-mut-wont-coerce.rs:36:14
|
||||
|
|
||||
LL | make_foo(&mut &mut *result);
|
||||
| -------- ^^^^^^^^^^^^^^^^^ expected `*mut *mut Foo`, found `&mut &mut Foo`
|
||||
| |
|
||||
| arguments to this function are incorrect
|
||||
|
|
||||
= note: expected raw pointer `*mut *mut Foo`
|
||||
found mutable reference `&mut &mut Foo`
|
||||
note: function defined here
|
||||
--> $DIR/mut-mut-wont-coerce.rs:30:4
|
||||
|
|
||||
LL | fn make_foo(_: *mut *mut Foo) {
|
||||
| ^^^^^^^^ ----------------
|
||||
|
||||
error: aborting due to 1 previous error
|
||||
|
||||
For more information about this error, try `rustc --explain E0308`.
|
||||
Loading…
Reference in a new issue