use crate::marker::Unsize;
use crate::slice::{Iter, IterMut};
-#[cfg(not(bootstrap))]
mod iter;
-#[cfg(not(bootstrap))]
#[unstable(feature = "array_value_iter", issue = "65798")]
pub use iter::IntoIter;
///
/// [#64715]: https://github.com/rust-lang/rust/issues/64715
#[stable(feature = "convert_infallible", since = "1.34.0")]
-#[cfg(not(bootstrap))]
#[rustc_reservation_impl="permitting this impl would forbid us from adding \
`impl<T> From<!> for T` later; see rust-lang/rust#64715 for details"]
impl<T> From<!> for T {
pub fn panic_if_uninhabited<T>();
/// Gets a reference to a static `Location` indicating where it was called.
- #[cfg(not(bootstrap))]
pub fn caller_location() -> &'static crate::panic::Location<'static>;
/// Creates a value initialized to zero.
pub fn nontemporal_store<T>(ptr: *mut T, val: T);
/// See documentation of `<*const T>::offset_from` for details.
- #[cfg(not(bootstrap))]
pub fn ptr_offset_from<T>(ptr: *const T, base: *const T) -> isize;
}
#![feature(hexagon_target_feature)]
#![feature(const_int_conversion)]
#![feature(const_transmute)]
-#![cfg_attr(bootstrap, feature(non_exhaustive))]
#![feature(structural_match)]
#![feature(abi_unadjusted)]
#![feature(adx_target_feature)]
/// Panics the current thread.
///
/// For details, see `std::macros`.
-#[cfg(bootstrap)]
-#[macro_export]
-#[allow_internal_unstable(core_panic, panic_internals)]
-#[stable(feature = "core", since = "1.6.0")]
-macro_rules! panic {
- () => (
- $crate::panic!("explicit panic")
- );
- ($msg:expr) => ({
- $crate::panicking::panic(&($msg, $crate::file!(), $crate::line!(), $crate::column!()))
- });
- ($msg:expr,) => (
- $crate::panic!($msg)
- );
- ($fmt:expr, $($arg:tt)+) => ({
- $crate::panicking::panic_fmt($crate::format_args!($fmt, $($arg)+),
- &($crate::file!(), $crate::line!(), $crate::column!()))
- });
-}
-
-/// Panics the current thread.
-///
-/// For details, see `std::macros`.
-#[cfg(not(bootstrap))]
#[macro_export]
#[allow_internal_unstable(core_panic,
// FIXME(anp, eddyb) `core_intrinsics` is used here to allow calling
///
/// [RFC1445]: https://github.com/rust-lang/rfcs/blob/master/text/1445-restrict-constants-in-patterns.md
/// [issue 63438]: https://github.com/rust-lang/rust/issues/63438
-#[cfg(not(bootstrap))]
#[unstable(feature = "structural_match", issue = "31434")]
#[rustc_on_unimplemented(message="the type `{Self}` does not `#[derive(PartialEq)]`")]
#[lang = "structural_peq"]
/// As a hack to work around this, we use two separate traits injected by each
/// of the two derives (`#[derive(PartialEq)]` and `#[derive(Eq)]`) and check
/// that both of them are present as part of structural-match checking.
-#[cfg(not(bootstrap))]
#[unstable(feature = "structural_match", issue = "31434")]
#[rustc_on_unimplemented(message="the type `{Self}` does not `#[derive(Eq)]`")]
#[lang = "structural_teq"]
}
}
- #[cfg(not(bootstrap))]
#[unstable(feature = "structural_match", issue = "31434")]
impl<T: ?Sized> StructuralPartialEq for $t<T> { }
- #[cfg(not(bootstrap))]
#[unstable(feature = "structural_match", issue = "31434")]
impl<T: ?Sized> StructuralEq for $t<T> { }
)
/// extracting those success or failure values from an existing instance and
/// creating a new instance from a success or failure value.
#[unstable(feature = "try_trait", issue = "42327")]
-#[cfg_attr(bootstrap, rustc_on_unimplemented(
- on(all(
- any(from_method="from_error", from_method="from_ok"),
- from_desugaring="QuestionMark"),
- message="the `?` operator can only be used in a \
- function that returns `Result` or `Option` \
- (or another type that implements `{Try}`)",
- label="cannot use the `?` operator in a function that returns `{Self}`"),
- on(all(from_method="into_result", from_desugaring="QuestionMark"),
- message="the `?` operator can only be applied to values \
- that implement `{Try}`",
- label="the `?` operator cannot be applied to type `{Self}`")
-))]
-#[cfg_attr(not(bootstrap), rustc_on_unimplemented(
+#[rustc_on_unimplemented(
on(all(
any(from_method="from_error", from_method="from_ok"),
from_desugaring="QuestionMark"),
message="the `?` operator can only be applied to values \
that implement `{Try}`",
label="the `?` operator cannot be applied to type `{Self}`")
-))]
+)]
#[doc(alias = "?")]
pub trait Try {
/// The type of this value when viewed as successful.
///
/// panic!("Normal panic");
/// ```
-#[cfg_attr(not(bootstrap), lang = "panic_location")]
+#[lang = "panic_location"]
#[derive(Debug)]
#[stable(feature = "panic_hooks", since = "1.10.0")]
pub struct Location<'a> {
use crate::fmt;
use crate::panic::{Location, PanicInfo};
-#[cfg(bootstrap)]
-#[cold]
-// never inline unless panic_immediate_abort to avoid code
-// bloat at the call sites as much as possible
-#[cfg_attr(not(feature="panic_immediate_abort"),inline(never))]
-#[lang = "panic"]
-pub fn panic(expr_file_line_col: &(&'static str, &'static str, u32, u32)) -> ! {
- if cfg!(feature = "panic_immediate_abort") {
- unsafe { super::intrinsics::abort() }
- }
-
- // Use Arguments::new_v1 instead of format_args!("{}", expr) to potentially
- // reduce size overhead. The format_args! macro uses str's Display trait to
- // write expr, which calls Formatter::pad, which must accommodate string
- // truncation and padding (even though none is used here). Using
- // Arguments::new_v1 may allow the compiler to omit Formatter::pad from the
- // output binary, saving up to a few kilobytes.
- let (expr, file, line, col) = *expr_file_line_col;
- panic_fmt(fmt::Arguments::new_v1(&[expr], &[]), &(file, line, col))
-}
-
-#[cfg(not(bootstrap))]
#[cold]
// never inline unless panic_immediate_abort to avoid code
// bloat at the call sites as much as possible
panic_fmt(fmt::Arguments::new_v1(&[expr], &[]), location)
}
-#[cfg(bootstrap)]
-#[cold]
-#[cfg_attr(not(feature="panic_immediate_abort"),inline(never))]
-#[lang = "panic_bounds_check"]
-fn panic_bounds_check(file_line_col: &(&'static str, u32, u32),
- index: usize, len: usize) -> ! {
- if cfg!(feature = "panic_immediate_abort") {
- unsafe { super::intrinsics::abort() }
- }
-
- panic_fmt(format_args!("index out of bounds: the len is {} but the index is {}",
- len, index), file_line_col)
-}
-
-#[cfg(not(bootstrap))]
#[cold]
#[cfg_attr(not(feature="panic_immediate_abort"),inline(never))]
#[lang = "panic_bounds_check"]
)
}
-#[cfg(bootstrap)]
-#[cold]
-#[cfg_attr(not(feature="panic_immediate_abort"),inline(never))]
-#[cfg_attr( feature="panic_immediate_abort" ,inline)]
-pub fn panic_fmt(fmt: fmt::Arguments<'_>, file_line_col: &(&'static str, u32, u32)) -> ! {
- if cfg!(feature = "panic_immediate_abort") {
- unsafe { super::intrinsics::abort() }
- }
-
- // NOTE This function never crosses the FFI boundary; it's a Rust-to-Rust call
- extern "Rust" {
- #[lang = "panic_impl"]
- fn panic_impl(pi: &PanicInfo<'_>) -> !;
- }
-
- let (file, line, col) = *file_line_col;
- let location = Location::internal_constructor(file, line, col);
- let pi = PanicInfo::internal_constructor(Some(&fmt), &location);
- unsafe { panic_impl(&pi) }
-}
-
-#[cfg(not(bootstrap))]
#[cold]
#[cfg_attr(not(feature="panic_immediate_abort"),inline(never))]
#[cfg_attr( feature="panic_immediate_abort" ,inline)]
/// }
/// ```
#[unstable(feature = "ptr_offset_from", issue = "41079")]
- #[cfg(not(bootstrap))]
#[rustc_const_unstable(feature = "const_ptr_offset_from")]
#[inline]
pub const unsafe fn offset_from(self, origin: *const T) -> isize where T: Sized {
intrinsics::ptr_offset_from(self, origin)
}
- #[unstable(feature = "ptr_offset_from", issue = "41079")]
- #[inline]
- #[cfg(bootstrap)]
- /// bootstrap
- pub unsafe fn offset_from(self, origin: *const T) -> isize where T: Sized {
- let pointee_size = mem::size_of::<T>();
- assert!(0 < pointee_size && pointee_size <= isize::max_value() as usize);
-
- // This is the same sequence that Clang emits for pointer subtraction.
- // It can be neither `nsw` nor `nuw` because the input is treated as
- // unsigned but then the output is treated as signed, so neither works.
- let d = isize::wrapping_sub(self as _, origin as _);
- intrinsics::exact_div(d, pointee_size as _)
- }
-
/// Calculates the distance between two pointers. The returned value is in
/// units of T: the distance in bytes is divided by `mem::size_of::<T>()`.
///
/// This type has the same in-memory representation as a [`bool`].
///
/// [`bool`]: ../../../std/primitive.bool.html
-#[cfg(any(bootstrap, target_has_atomic_load_store = "8"))]
+#[cfg(target_has_atomic_load_store = "8")]
#[stable(feature = "rust1", since = "1.0.0")]
#[repr(C, align(1))]
pub struct AtomicBool {
v: UnsafeCell<u8>,
}
-#[cfg(any(bootstrap, target_has_atomic_load_store = "8"))]
+#[cfg(target_has_atomic_load_store = "8")]
#[stable(feature = "rust1", since = "1.0.0")]
impl Default for AtomicBool {
/// Creates an `AtomicBool` initialized to `false`.
}
// Send is implicitly implemented for AtomicBool.
-#[cfg(any(bootstrap, target_has_atomic_load_store = "8"))]
+#[cfg(target_has_atomic_load_store = "8")]
#[stable(feature = "rust1", since = "1.0.0")]
unsafe impl Sync for AtomicBool {}
/// A raw pointer type which can be safely shared between threads.
///
/// This type has the same in-memory representation as a `*mut T`.
-#[cfg(any(bootstrap, target_has_atomic_load_store = "ptr"))]
+#[cfg(target_has_atomic_load_store = "ptr")]
#[stable(feature = "rust1", since = "1.0.0")]
#[cfg_attr(target_pointer_width = "16", repr(C, align(2)))]
#[cfg_attr(target_pointer_width = "32", repr(C, align(4)))]
p: UnsafeCell<*mut T>,
}
-#[cfg(any(bootstrap, target_has_atomic_load_store = "ptr"))]
+#[cfg(target_has_atomic_load_store = "ptr")]
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> Default for AtomicPtr<T> {
/// Creates a null `AtomicPtr<T>`.
}
}
-#[cfg(any(bootstrap, target_has_atomic_load_store = "ptr"))]
+#[cfg(target_has_atomic_load_store = "ptr")]
#[stable(feature = "rust1", since = "1.0.0")]
unsafe impl<T> Send for AtomicPtr<T> {}
-#[cfg(any(bootstrap, target_has_atomic_load_store = "ptr"))]
+#[cfg(target_has_atomic_load_store = "ptr")]
#[stable(feature = "rust1", since = "1.0.0")]
unsafe impl<T> Sync for AtomicPtr<T> {}
/// An [`AtomicBool`] initialized to `false`.
///
/// [`AtomicBool`]: struct.AtomicBool.html
-#[cfg(any(bootstrap, target_has_atomic_load_store = "8"))]
+#[cfg(target_has_atomic_load_store = "8")]
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_deprecated(
since = "1.34.0",
)]
pub const ATOMIC_BOOL_INIT: AtomicBool = AtomicBool::new(false);
-#[cfg(any(bootstrap, target_has_atomic_load_store = "8"))]
+#[cfg(target_has_atomic_load_store = "8")]
impl AtomicBool {
/// Creates a new `AtomicBool`.
///
}
}
-#[cfg(any(bootstrap, target_has_atomic_load_store = "ptr"))]
+#[cfg(target_has_atomic_load_store = "ptr")]
impl<T> AtomicPtr<T> {
/// Creates a new `AtomicPtr`.
///
}
}
-#[cfg(any(bootstrap, target_has_atomic_load_store = "8"))]
+#[cfg(target_has_atomic_load_store = "8")]
#[stable(feature = "atomic_bool_from", since = "1.24.0")]
impl From<bool> for AtomicBool {
/// Converts a `bool` into an `AtomicBool`.
fn from(b: bool) -> Self { Self::new(b) }
}
-#[cfg(any(bootstrap, target_has_atomic_load_store = "ptr"))]
+#[cfg(target_has_atomic_load_store = "ptr")]
#[stable(feature = "atomic_from", since = "1.23.0")]
impl<T> From<*mut T> for AtomicPtr<T> {
#[inline]
fn from(p: *mut T) -> Self { Self::new(p) }
}
-#[cfg(any(bootstrap, target_has_atomic_load_store = "8"))]
+#[cfg(target_has_atomic_load_store = "8")]
macro_rules! atomic_int {
($cfg_cas:meta,
$stable:meta,
}
}
-#[cfg(any(bootstrap, target_has_atomic_load_store = "8"))]
+#[cfg(target_has_atomic_load_store = "8")]
atomic_int! {
cfg(target_has_atomic = "8"),
stable(feature = "integer_atomics_stable", since = "1.34.0"),
"AtomicI8::new(0)",
i8 AtomicI8 ATOMIC_I8_INIT
}
-#[cfg(any(bootstrap, target_has_atomic_load_store = "8"))]
+#[cfg(target_has_atomic_load_store = "8")]
atomic_int! {
cfg(target_has_atomic = "8"),
stable(feature = "integer_atomics_stable", since = "1.34.0"),
"AtomicU8::new(0)",
u8 AtomicU8 ATOMIC_U8_INIT
}
-#[cfg(any(bootstrap, target_has_atomic_load_store = "16"))]
+#[cfg(target_has_atomic_load_store = "16")]
atomic_int! {
cfg(target_has_atomic = "16"),
stable(feature = "integer_atomics_stable", since = "1.34.0"),
"AtomicI16::new(0)",
i16 AtomicI16 ATOMIC_I16_INIT
}
-#[cfg(any(bootstrap, target_has_atomic_load_store = "16"))]
+#[cfg(target_has_atomic_load_store = "16")]
atomic_int! {
cfg(target_has_atomic = "16"),
stable(feature = "integer_atomics_stable", since = "1.34.0"),
"AtomicU16::new(0)",
u16 AtomicU16 ATOMIC_U16_INIT
}
-#[cfg(any(bootstrap, target_has_atomic_load_store = "32"))]
+#[cfg(target_has_atomic_load_store = "32")]
atomic_int! {
cfg(target_has_atomic = "32"),
stable(feature = "integer_atomics_stable", since = "1.34.0"),
"AtomicI32::new(0)",
i32 AtomicI32 ATOMIC_I32_INIT
}
-#[cfg(any(bootstrap, target_has_atomic_load_store = "32"))]
+#[cfg(target_has_atomic_load_store = "32")]
atomic_int! {
cfg(target_has_atomic = "32"),
stable(feature = "integer_atomics_stable", since = "1.34.0"),
"AtomicU32::new(0)",
u32 AtomicU32 ATOMIC_U32_INIT
}
-#[cfg(any(
- all(bootstrap, target_has_atomic = "64"),
- target_has_atomic_load_store = "64"
-))]
+#[cfg(target_has_atomic_load_store = "64")]
atomic_int! {
cfg(target_has_atomic = "64"),
stable(feature = "integer_atomics_stable", since = "1.34.0"),
"AtomicI64::new(0)",
i64 AtomicI64 ATOMIC_I64_INIT
}
-#[cfg(any(
- all(bootstrap, target_has_atomic = "64"),
- target_has_atomic_load_store = "64"
-))]
+#[cfg(target_has_atomic_load_store = "64")]
atomic_int! {
cfg(target_has_atomic = "64"),
stable(feature = "integer_atomics_stable", since = "1.34.0"),
"AtomicU128::new(0)",
u128 AtomicU128 ATOMIC_U128_INIT
}
-#[cfg(any(bootstrap, target_has_atomic_load_store = "ptr"))]
+#[cfg(target_has_atomic_load_store = "ptr")]
#[cfg(target_pointer_width = "16")]
macro_rules! ptr_width {
() => { 2 }
}
-#[cfg(any(bootstrap, target_has_atomic_load_store = "ptr"))]
+#[cfg(target_has_atomic_load_store = "ptr")]
#[cfg(target_pointer_width = "32")]
macro_rules! ptr_width {
() => { 4 }
}
-#[cfg(any(bootstrap, target_has_atomic_load_store = "ptr"))]
+#[cfg(target_has_atomic_load_store = "ptr")]
#[cfg(target_pointer_width = "64")]
macro_rules! ptr_width {
() => { 8 }
}
-#[cfg(any(bootstrap, target_has_atomic_load_store = "ptr"))]
+#[cfg(target_has_atomic_load_store = "ptr")]
atomic_int!{
cfg(target_has_atomic = "ptr"),
stable(feature = "rust1", since = "1.0.0"),
"AtomicIsize::new(0)",
isize AtomicIsize ATOMIC_ISIZE_INIT
}
-#[cfg(any(bootstrap, target_has_atomic_load_store = "ptr"))]
+#[cfg(target_has_atomic_load_store = "ptr")]
atomic_int!{
cfg(target_has_atomic = "ptr"),
stable(feature = "rust1", since = "1.0.0"),
}
-#[cfg(any(bootstrap, target_has_atomic_load_store = "8"))]
+#[cfg(target_has_atomic_load_store = "8")]
#[stable(feature = "atomic_debug", since = "1.3.0")]
impl fmt::Debug for AtomicBool {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
}
}
-#[cfg(any(bootstrap, target_has_atomic_load_store = "ptr"))]
+#[cfg(target_has_atomic_load_store = "ptr")]
#[stable(feature = "atomic_debug", since = "1.3.0")]
impl<T> fmt::Debug for AtomicPtr<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
}
}
-#[cfg(any(bootstrap, target_has_atomic_load_store = "ptr"))]
+#[cfg(target_has_atomic_load_store = "ptr")]
#[stable(feature = "atomic_pointer", since = "1.24.0")]
impl<T> fmt::Pointer for AtomicPtr<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
mod imp {
pub type ptr_t = *mut u8;
- #[cfg(bootstrap)]
- pub const NAME1: [u8; 7] = [b'.', b'P', b'A', b'_', b'K', 0, 0];
-
macro_rules! ptr {
(0) => (core::ptr::null_mut());
($e:expr) => ($e as *mut u8);
mod imp {
pub type ptr_t = u32;
- #[cfg(bootstrap)]
- pub const NAME1: [u8; 7] = [b'.', b'P', b'E', b'A', b'_', b'K', 0];
-
extern "C" {
pub static __ImageBase: u8;
}
pub struct _TypeDescriptor {
pub pVFTable: *const u8,
pub spare: *mut u8,
- #[cfg(bootstrap)]
- pub name: [u8; 7],
- #[cfg(not(bootstrap))]
pub name: [u8; 11],
}
// Note that we intentionally ignore name mangling rules here: we don't want C++
// to be able to catch Rust panics by simply declaring a `struct rust_panic`.
-#[cfg(bootstrap)]
-use imp::NAME1 as TYPE_NAME;
-#[cfg(not(bootstrap))]
const TYPE_NAME: [u8; 11] = *b"rust_panic\0";
static mut THROW_INFO: _ThrowInfo = _ThrowInfo {
pdisp: -1,
vdisp: 0,
},
- #[cfg(bootstrap)]
- sizeOrOffset: mem::size_of::<*mut u64>() as c_int,
- #[cfg(not(bootstrap))]
sizeOrOffset: mem::size_of::<[u64; 2]>() as c_int,
copy_function: ptr!(0),
};
// an argument to the C++ personality function.
//
// Again, I'm not entirely sure what this is describing, it just seems to work.
-#[cfg_attr(bootstrap, lang = "msvc_try_filter")]
-#[cfg_attr(not(any(test, bootstrap)), lang = "eh_catch_typeinfo")]
+#[cfg_attr(not(test), lang = "eh_catch_typeinfo")]
static mut TYPE_DESCRIPTOR: _TypeDescriptor = _TypeDescriptor {
pVFTable: unsafe { &TYPE_INFO_VTABLE } as *const _ as *const _,
spare: core::ptr::null_mut(),
let ptrs = mem::transmute::<_, raw::TraitObject>(data);
let mut ptrs = [ptrs.data as u64, ptrs.vtable as u64];
let mut ptrs_ptr = ptrs.as_mut_ptr();
- let throw_ptr = if cfg!(bootstrap) {
- &mut ptrs_ptr as *mut _ as *mut _
- } else {
- ptrs_ptr as *mut _
- };
+ let throw_ptr = ptrs_ptr as *mut _;
// This... may seems surprising, and justifiably so. On 32-bit MSVC the
// pointers between these structure are just that, pointers. On 64-bit MSVC,
#![feature(extern_types)]
#![feature(in_band_lifetimes)]
#![feature(optin_builtin_traits)]
-#![cfg_attr(bootstrap, feature(non_exhaustive))]
#![feature(rustc_attrs)]
#![feature(specialization)]
#![feature(overlapping_marker_traits)]
#![feature(extern_types)]
#![feature(nll)]
-#![cfg_attr(bootstrap, feature(non_exhaustive))]
#![feature(optin_builtin_traits)]
#![feature(option_expect_none)]
#![feature(range_is_empty)]
#![feature(test)]
#![feature(in_band_lifetimes)]
#![feature(crate_visibility_modifier)]
-#![cfg_attr(bootstrap, feature(proc_macro_hygiene))]
#![feature(log_syntax)]
#![feature(associated_type_bounds)]
#![feature(rustc_attrs)]
#![feature(needs_panic_runtime)]
#![feature(never_type)]
#![feature(nll)]
-#![cfg_attr(bootstrap, feature(non_exhaustive))]
#![cfg_attr(bootstrap, feature(on_unimplemented))]
#![feature(optin_builtin_traits)]
#![feature(panic_info_message)]
use crate::ptr::{Unique, NonNull};
use crate::rc::Rc;
use crate::sync::{Arc, Mutex, RwLock};
-#[cfg(not(bootstrap))]
use crate::sync::atomic;
use crate::task::{Context, Poll};
use crate::thread::Result;
#![feature(const_fn)]
#![feature(crate_visibility_modifier)]
#![feature(nll)]
-#![cfg_attr(bootstrap, feature(non_exhaustive))]
#![feature(optin_builtin_traits)]
#![feature(rustc_attrs)]
-#![cfg_attr(bootstrap, feature(proc_macro_hygiene))]
#![feature(specialization)]
#![feature(step_trait)]
projects / rust.git / commitdiff