| use super::*; |
| use crate::cmp::Ordering::{self, Equal, Greater, Less}; |
| use crate::intrinsics; |
| use crate::slice::{self, SliceIndex}; |
| |
| #[lang = "mut_ptr"] |
| impl<T: ?Sized> *mut T { |
| /// Returns `true` if the pointer is null. |
| /// |
| /// Note that unsized types have many possible null pointers, as only the |
| /// raw data pointer is considered, not their length, vtable, etc. |
| /// Therefore, two pointers that are null may still not compare equal to |
| /// each other. |
| /// |
| /// ## Behavior during const evaluation |
| /// |
| /// When this function is used during const evaluation, it may return `false` for pointers |
| /// that turn out to be null at runtime. Specifically, when a pointer to some memory |
| /// is offset beyond its bounds in such a way that the resulting pointer is null, |
| /// the function will still return `false`. There is no way for CTFE to know |
| /// the absolute position of that memory, so we cannot tell if the pointer is |
| /// null or not. |
| /// |
| /// # Examples |
| /// |
| /// Basic usage: |
| /// |
| /// ``` |
| /// let mut s = [1, 2, 3]; |
| /// let ptr: *mut u32 = s.as_mut_ptr(); |
| /// assert!(!ptr.is_null()); |
| /// ``` |
| #[stable(feature = "rust1", since = "1.0.0")] |
| #[rustc_const_unstable(feature = "const_ptr_is_null", issue = "74939")] |
| #[inline] |
| pub const fn is_null(self) -> bool { |
| // Compare via a cast to a thin pointer, so fat pointers are only |
| // considering their "data" part for null-ness. |
| (self as *mut u8).guaranteed_eq(null_mut()) |
| } |
| |
| /// Casts to a pointer of another type. |
| #[stable(feature = "ptr_cast", since = "1.38.0")] |
| #[rustc_const_stable(feature = "const_ptr_cast", since = "1.38.0")] |
| #[inline] |
| pub const fn cast<U>(self) -> *mut U { |
| self as _ |
| } |
| |
| /// Decompose a (possibly wide) pointer into is address and metadata components. |
| /// |
| /// The pointer can be later reconstructed with [`from_raw_parts_mut`]. |
| #[unstable(feature = "ptr_metadata", issue = "81513")] |
| #[rustc_const_unstable(feature = "ptr_metadata", issue = "81513")] |
| #[inline] |
| pub const fn to_raw_parts(self) -> (*mut (), <T as super::Pointee>::Metadata) { |
| (self.cast(), super::metadata(self)) |
| } |
| |
| /// Returns `None` if the pointer is null, or else returns a shared reference to |
| /// the value wrapped in `Some`. If the value may be uninitialized, [`as_uninit_ref`] |
| /// must be used instead. |
| /// |
| /// For the mutable counterpart see [`as_mut`]. |
| /// |
| /// [`as_uninit_ref`]: #method.as_uninit_ref-1 |
| /// [`as_mut`]: #method.as_mut |
| /// |
| /// # Safety |
| /// |
| /// When calling this method, you have to ensure that *either* the pointer is NULL *or* |
| /// all of the following is true: |
| /// |
| /// * The pointer must be properly aligned. |
| /// |
| /// * It must be "dereferencable" in the sense defined in [the module documentation]. |
| /// |
| /// * The pointer must point to an initialized instance of `T`. |
| /// |
| /// * You must enforce Rust's aliasing rules, since the returned lifetime `'a` is |
| /// arbitrarily chosen and does not necessarily reflect the actual lifetime of the data. |
| /// In particular, for the duration of this lifetime, the memory the pointer points to must |
| /// not get mutated (except inside `UnsafeCell`). |
| /// |
| /// This applies even if the result of this method is unused! |
| /// (The part about being initialized is not yet fully decided, but until |
| /// it is, the only safe approach is to ensure that they are indeed initialized.) |
| /// |
| /// [the module documentation]: crate::ptr#safety |
| /// |
| /// # Examples |
| /// |
| /// Basic usage: |
| /// |
| /// ``` |
| /// let ptr: *mut u8 = &mut 10u8 as *mut u8; |
| /// |
| /// unsafe { |
| /// if let Some(val_back) = ptr.as_ref() { |
| /// println!("We got back the value: {}!", val_back); |
| /// } |
| /// } |
| /// ``` |
| /// |
| /// # Null-unchecked version |
| /// |
| /// If you are sure the pointer can never be null and are looking for some kind of |
| /// `as_ref_unchecked` that returns the `&T` instead of `Option<&T>`, know that you can |
| /// dereference the pointer directly. |
| /// |
| /// ``` |
| /// let ptr: *mut u8 = &mut 10u8 as *mut u8; |
| /// |
| /// unsafe { |
| /// let val_back = &*ptr; |
| /// println!("We got back the value: {}!", val_back); |
| /// } |
| /// ``` |
| #[stable(feature = "ptr_as_ref", since = "1.9.0")] |
| #[inline] |
| pub unsafe fn as_ref<'a>(self) -> Option<&'a T> { |
| // SAFETY: the caller must guarantee that `self` is valid for a |
| // reference if it isn't null. |
| if self.is_null() { None } else { unsafe { Some(&*self) } } |
| } |
| |
| /// Returns `None` if the pointer is null, or else returns a shared reference to |
| /// the value wrapped in `Some`. In contrast to [`as_ref`], this does not require |
| /// that the value has to be initialized. |
| /// |
| /// For the mutable counterpart see [`as_uninit_mut`]. |
| /// |
| /// [`as_ref`]: #method.as_ref-1 |
| /// [`as_uninit_mut`]: #method.as_uninit_mut |
| /// |
| /// # Safety |
| /// |
| /// When calling this method, you have to ensure that *either* the pointer is NULL *or* |
| /// all of the following is true: |
| /// |
| /// * The pointer must be properly aligned. |
| /// |
| /// * It must be "dereferencable" in the sense defined in [the module documentation]. |
| /// |
| /// * You must enforce Rust's aliasing rules, since the returned lifetime `'a` is |
| /// arbitrarily chosen and does not necessarily reflect the actual lifetime of the data. |
| /// In particular, for the duration of this lifetime, the memory the pointer points to must |
| /// not get mutated (except inside `UnsafeCell`). |
| /// |
| /// This applies even if the result of this method is unused! |
| /// |
| /// [the module documentation]: crate::ptr#safety |
| /// |
| /// # Examples |
| /// |
| /// Basic usage: |
| /// |
| /// ``` |
| /// #![feature(ptr_as_uninit)] |
| /// |
| /// let ptr: *mut u8 = &mut 10u8 as *mut u8; |
| /// |
| /// unsafe { |
| /// if let Some(val_back) = ptr.as_uninit_ref() { |
| /// println!("We got back the value: {}!", val_back.assume_init()); |
| /// } |
| /// } |
| /// ``` |
| #[inline] |
| #[unstable(feature = "ptr_as_uninit", issue = "75402")] |
| pub unsafe fn as_uninit_ref<'a>(self) -> Option<&'a MaybeUninit<T>> |
| where |
| T: Sized, |
| { |
| // SAFETY: the caller must guarantee that `self` meets all the |
| // requirements for a reference. |
| if self.is_null() { None } else { Some(unsafe { &*(self as *const MaybeUninit<T>) }) } |
| } |
| |
| /// Calculates the offset from a pointer. |
| /// |
| /// `count` is in units of T; e.g., a `count` of 3 represents a pointer |
| /// offset of `3 * size_of::<T>()` bytes. |
| /// |
| /// # Safety |
| /// |
| /// If any of the following conditions are violated, the result is Undefined |
| /// Behavior: |
| /// |
| /// * Both the starting and resulting pointer must be either in bounds or one |
| /// byte past the end of the same [allocated object]. |
| /// |
| /// * The computed offset, **in bytes**, cannot overflow an `isize`. |
| /// |
| /// * The offset being in bounds cannot rely on "wrapping around" the address |
| /// space. That is, the infinite-precision sum, **in bytes** must fit in a usize. |
| /// |
| /// The compiler and standard library generally tries to ensure allocations |
| /// never reach a size where an offset is a concern. For instance, `Vec` |
| /// and `Box` ensure they never allocate more than `isize::MAX` bytes, so |
| /// `vec.as_ptr().add(vec.len())` is always safe. |
| /// |
| /// Most platforms fundamentally can't even construct such an allocation. |
| /// For instance, no known 64-bit platform can ever serve a request |
| /// for 2<sup>63</sup> bytes due to page-table limitations or splitting the address space. |
| /// However, some 32-bit and 16-bit platforms may successfully serve a request for |
| /// more than `isize::MAX` bytes with things like Physical Address |
| /// Extension. As such, memory acquired directly from allocators or memory |
| /// mapped files *may* be too large to handle with this function. |
| /// |
| /// Consider using [`wrapping_offset`] instead if these constraints are |
| /// difficult to satisfy. The only advantage of this method is that it |
| /// enables more aggressive compiler optimizations. |
| /// |
| /// [`wrapping_offset`]: #method.wrapping_offset |
| /// [allocated object]: crate::ptr#allocated-object |
| /// |
| /// # Examples |
| /// |
| /// Basic usage: |
| /// |
| /// ``` |
| /// let mut s = [1, 2, 3]; |
| /// let ptr: *mut u32 = s.as_mut_ptr(); |
| /// |
| /// unsafe { |
| /// println!("{}", *ptr.offset(1)); |
| /// println!("{}", *ptr.offset(2)); |
| /// } |
| /// ``` |
| #[stable(feature = "rust1", since = "1.0.0")] |
| #[must_use = "returns a new pointer rather than modifying its argument"] |
| #[rustc_const_unstable(feature = "const_ptr_offset", issue = "71499")] |
| #[inline(always)] |
| pub const unsafe fn offset(self, count: isize) -> *mut T |
| where |
| T: Sized, |
| { |
| // SAFETY: the caller must uphold the safety contract for `offset`. |
| // The obtained pointer is valid for writes since the caller must |
| // guarantee that it points to the same allocated object as `self`. |
| unsafe { intrinsics::offset(self, count) as *mut T } |
| } |
| |
| /// Calculates the offset from a pointer using wrapping arithmetic. |
| /// `count` is in units of T; e.g., a `count` of 3 represents a pointer |
| /// offset of `3 * size_of::<T>()` bytes. |
| /// |
| /// # Safety |
| /// |
| /// This operation itself is always safe, but using the resulting pointer is not. |
| /// |
| /// The resulting pointer "remembers" the [allocated object] that `self` points to; it may not |
| /// be used to read or write other allocated objects. |
| /// |
| /// In other words, `let z = x.wrapping_offset((y as isize) - (x as isize))` does *not* make `z` |
| /// the same as `y` even if we assume `T` has size `1` and there is no overflow: `z` is still |
| /// attached to the object `x` is attached to, and dereferencing it is Undefined Behavior unless |
| /// `x` and `y` point into the same allocated object. |
| /// |
| /// Compared to [`offset`], this method basically delays the requirement of staying within the |
| /// same allocated object: [`offset`] is immediate Undefined Behavior when crossing object |
| /// boundaries; `wrapping_offset` produces a pointer but still leads to Undefined Behavior if a |
| /// pointer is dereferenced when it is out-of-bounds of the object it is attached to. [`offset`] |
| /// can be optimized better and is thus preferable in performance-sensitive code. |
| /// |
| /// The delayed check only considers the value of the pointer that was dereferenced, not the |
| /// intermediate values used during the computation of the final result. For example, |
| /// `x.wrapping_offset(o).wrapping_offset(o.wrapping_neg())` is always the same as `x`. In other |
| /// words, leaving the allocated object and then re-entering it later is permitted. |
| /// |
| /// [`offset`]: #method.offset |
| /// [allocated object]: crate::ptr#allocated-object |
| /// |
| /// # Examples |
| /// |
| /// Basic usage: |
| /// |
| /// ``` |
| /// // Iterate using a raw pointer in increments of two elements |
| /// let mut data = [1u8, 2, 3, 4, 5]; |
| /// let mut ptr: *mut u8 = data.as_mut_ptr(); |
| /// let step = 2; |
| /// let end_rounded_up = ptr.wrapping_offset(6); |
| /// |
| /// while ptr != end_rounded_up { |
| /// unsafe { |
| /// *ptr = 0; |
| /// } |
| /// ptr = ptr.wrapping_offset(step); |
| /// } |
| /// assert_eq!(&data, &[0, 2, 0, 4, 0]); |
| /// ``` |
| #[stable(feature = "ptr_wrapping_offset", since = "1.16.0")] |
| #[must_use = "returns a new pointer rather than modifying its argument"] |
| #[rustc_const_unstable(feature = "const_ptr_offset", issue = "71499")] |
| #[inline(always)] |
| pub const fn wrapping_offset(self, count: isize) -> *mut T |
| where |
| T: Sized, |
| { |
| // SAFETY: the `arith_offset` intrinsic has no prerequisites to be called. |
| unsafe { intrinsics::arith_offset(self, count) as *mut T } |
| } |
| |
| /// Returns `None` if the pointer is null, or else returns a unique reference to |
| /// the value wrapped in `Some`. If the value may be uninitialized, [`as_uninit_mut`] |
| /// must be used instead. |
| /// |
| /// For the shared counterpart see [`as_ref`]. |
| /// |
| /// [`as_uninit_mut`]: #method.as_uninit_mut |
| /// [`as_ref`]: #method.as_ref-1 |
| /// |
| /// # Safety |
| /// |
| /// When calling this method, you have to ensure that *either* the pointer is NULL *or* |
| /// all of the following is true: |
| /// |
| /// * The pointer must be properly aligned. |
| /// |
| /// * It must be "dereferencable" in the sense defined in [the module documentation]. |
| /// |
| /// * The pointer must point to an initialized instance of `T`. |
| /// |
| /// * You must enforce Rust's aliasing rules, since the returned lifetime `'a` is |
| /// arbitrarily chosen and does not necessarily reflect the actual lifetime of the data. |
| /// In particular, for the duration of this lifetime, the memory the pointer points to must |
| /// not get accessed (read or written) through any other pointer. |
| /// |
| /// This applies even if the result of this method is unused! |
| /// (The part about being initialized is not yet fully decided, but until |
| /// it is, the only safe approach is to ensure that they are indeed initialized.) |
| /// |
| /// [the module documentation]: crate::ptr#safety |
| /// |
| /// # Examples |
| /// |
| /// Basic usage: |
| /// |
| /// ``` |
| /// let mut s = [1, 2, 3]; |
| /// let ptr: *mut u32 = s.as_mut_ptr(); |
| /// let first_value = unsafe { ptr.as_mut().unwrap() }; |
| /// *first_value = 4; |
| /// # assert_eq!(s, [4, 2, 3]); |
| /// println!("{:?}", s); // It'll print: "[4, 2, 3]". |
| /// ``` |
| /// |
| /// # Null-unchecked version |
| /// |
| /// If you are sure the pointer can never be null and are looking for some kind of |
| /// `as_mut_unchecked` that returns the `&mut T` instead of `Option<&mut T>`, know that |
| /// you can dereference the pointer directly. |
| /// |
| /// ``` |
| /// let mut s = [1, 2, 3]; |
| /// let ptr: *mut u32 = s.as_mut_ptr(); |
| /// let first_value = unsafe { &mut *ptr }; |
| /// *first_value = 4; |
| /// # assert_eq!(s, [4, 2, 3]); |
| /// println!("{:?}", s); // It'll print: "[4, 2, 3]". |
| /// ``` |
| #[stable(feature = "ptr_as_ref", since = "1.9.0")] |
| #[inline] |
| pub unsafe fn as_mut<'a>(self) -> Option<&'a mut T> { |
| // SAFETY: the caller must guarantee that `self` is be valid for |
| // a mutable reference if it isn't null. |
| if self.is_null() { None } else { unsafe { Some(&mut *self) } } |
| } |
| |
| /// Returns `None` if the pointer is null, or else returns a unique reference to |
| /// the value wrapped in `Some`. In contrast to [`as_mut`], this does not require |
| /// that the value has to be initialized. |
| /// |
| /// For the shared counterpart see [`as_uninit_ref`]. |
| /// |
| /// [`as_mut`]: #method.as_mut |
| /// [`as_uninit_ref`]: #method.as_uninit_ref-1 |
| /// |
| /// # Safety |
| /// |
| /// When calling this method, you have to ensure that *either* the pointer is NULL *or* |
| /// all of the following is true: |
| /// |
| /// * The pointer must be properly aligned. |
| /// |
| /// * It must be "dereferencable" in the sense defined in [the module documentation]. |
| /// |
| /// * You must enforce Rust's aliasing rules, since the returned lifetime `'a` is |
| /// arbitrarily chosen and does not necessarily reflect the actual lifetime of the data. |
| /// In particular, for the duration of this lifetime, the memory the pointer points to must |
| /// not get accessed (read or written) through any other pointer. |
| /// |
| /// This applies even if the result of this method is unused! |
| /// |
| /// [the module documentation]: crate::ptr#safety |
| #[inline] |
| #[unstable(feature = "ptr_as_uninit", issue = "75402")] |
| pub unsafe fn as_uninit_mut<'a>(self) -> Option<&'a mut MaybeUninit<T>> |
| where |
| T: Sized, |
| { |
| // SAFETY: the caller must guarantee that `self` meets all the |
| // requirements for a reference. |
| if self.is_null() { None } else { Some(unsafe { &mut *(self as *mut MaybeUninit<T>) }) } |
| } |
| |
| /// Returns whether two pointers are guaranteed to be equal. |
| /// |
| /// At runtime this function behaves like `self == other`. |
| /// However, in some contexts (e.g., compile-time evaluation), |
| /// it is not always possible to determine equality of two pointers, so this function may |
| /// spuriously return `false` for pointers that later actually turn out to be equal. |
| /// But when it returns `true`, the pointers are guaranteed to be equal. |
| /// |
| /// This function is the mirror of [`guaranteed_ne`], but not its inverse. There are pointer |
| /// comparisons for which both functions return `false`. |
| /// |
| /// [`guaranteed_ne`]: #method.guaranteed_ne |
| /// |
| /// The return value may change depending on the compiler version and unsafe code may not |
| /// rely on the result of this function for soundness. It is suggested to only use this function |
| /// for performance optimizations where spurious `false` return values by this function do not |
| /// affect the outcome, but just the performance. |
| /// The consequences of using this method to make runtime and compile-time code behave |
| /// differently have not been explored. This method should not be used to introduce such |
| /// differences, and it should also not be stabilized before we have a better understanding |
| /// of this issue. |
| #[unstable(feature = "const_raw_ptr_comparison", issue = "53020")] |
| #[rustc_const_unstable(feature = "const_raw_ptr_comparison", issue = "53020")] |
| #[inline] |
| pub const fn guaranteed_eq(self, other: *mut T) -> bool |
| where |
| T: Sized, |
| { |
| intrinsics::ptr_guaranteed_eq(self as *const _, other as *const _) |
| } |
| |
| /// Returns whether two pointers are guaranteed to be unequal. |
| /// |
| /// At runtime this function behaves like `self != other`. |
| /// However, in some contexts (e.g., compile-time evaluation), |
| /// it is not always possible to determine the inequality of two pointers, so this function may |
| /// spuriously return `false` for pointers that later actually turn out to be unequal. |
| /// But when it returns `true`, the pointers are guaranteed to be unequal. |
| /// |
| /// This function is the mirror of [`guaranteed_eq`], but not its inverse. There are pointer |
| /// comparisons for which both functions return `false`. |
| /// |
| /// [`guaranteed_eq`]: #method.guaranteed_eq |
| /// |
| /// The return value may change depending on the compiler version and unsafe code may not |
| /// rely on the result of this function for soundness. It is suggested to only use this function |
| /// for performance optimizations where spurious `false` return values by this function do not |
| /// affect the outcome, but just the performance. |
| /// The consequences of using this method to make runtime and compile-time code behave |
| /// differently have not been explored. This method should not be used to introduce such |
| /// differences, and it should also not be stabilized before we have a better understanding |
| /// of this issue. |
| #[unstable(feature = "const_raw_ptr_comparison", issue = "53020")] |
| #[rustc_const_unstable(feature = "const_raw_ptr_comparison", issue = "53020")] |
| #[inline] |
| pub const unsafe fn guaranteed_ne(self, other: *mut T) -> bool |
| where |
| T: Sized, |
| { |
| intrinsics::ptr_guaranteed_ne(self as *const _, other as *const _) |
| } |
| |
| /// 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 function is the inverse of [`offset`]. |
| /// |
| /// [`offset`]: #method.offset-1 |
| /// |
| /// # Safety |
| /// |
| /// If any of the following conditions are violated, the result is Undefined |
| /// Behavior: |
| /// |
| /// * Both the starting and other pointer must be either in bounds or one |
| /// byte past the end of the same [allocated object]. |
| /// |
| /// * Both pointers must be *derived from* a pointer to the same object. |
| /// (See below for an example.) |
| /// |
| /// * The distance between the pointers, in bytes, must be an exact multiple |
| /// of the size of `T`. |
| /// |
| /// * The distance between the pointers, **in bytes**, cannot overflow an `isize`. |
| /// |
| /// * The distance being in bounds cannot rely on "wrapping around" the address space. |
| /// |
| /// Rust types are never larger than `isize::MAX` and Rust allocations never wrap around the |
| /// address space, so two pointers within some value of any Rust type `T` will always satisfy |
| /// the last two conditions. The standard library also generally ensures that allocations |
| /// never reach a size where an offset is a concern. For instance, `Vec` and `Box` ensure they |
| /// never allocate more than `isize::MAX` bytes, so `ptr_into_vec.offset_from(vec.as_ptr())` |
| /// always satisfies the last two conditions. |
| /// |
| /// Most platforms fundamentally can't even construct such a large allocation. |
| /// For instance, no known 64-bit platform can ever serve a request |
| /// for 2<sup>63</sup> bytes due to page-table limitations or splitting the address space. |
| /// However, some 32-bit and 16-bit platforms may successfully serve a request for |
| /// more than `isize::MAX` bytes with things like Physical Address |
| /// Extension. As such, memory acquired directly from allocators or memory |
| /// mapped files *may* be too large to handle with this function. |
| /// (Note that [`offset`] and [`add`] also have a similar limitation and hence cannot be used on |
| /// such large allocations either.) |
| /// |
| /// [`add`]: #method.add |
| /// [allocated object]: crate::ptr#allocated-object |
| /// |
| /// # Panics |
| /// |
| /// This function panics if `T` is a Zero-Sized Type ("ZST"). |
| /// |
| /// # Examples |
| /// |
| /// Basic usage: |
| /// |
| /// ``` |
| /// let mut a = [0; 5]; |
| /// let ptr1: *mut i32 = &mut a[1]; |
| /// let ptr2: *mut i32 = &mut a[3]; |
| /// unsafe { |
| /// assert_eq!(ptr2.offset_from(ptr1), 2); |
| /// assert_eq!(ptr1.offset_from(ptr2), -2); |
| /// assert_eq!(ptr1.offset(2), ptr2); |
| /// assert_eq!(ptr2.offset(-2), ptr1); |
| /// } |
| /// ``` |
| /// |
| /// *Incorrect* usage: |
| /// |
| /// ```rust,no_run |
| /// let ptr1 = Box::into_raw(Box::new(0u8)); |
| /// let ptr2 = Box::into_raw(Box::new(1u8)); |
| /// let diff = (ptr2 as isize).wrapping_sub(ptr1 as isize); |
| /// // Make ptr2_other an "alias" of ptr2, but derived from ptr1. |
| /// let ptr2_other = (ptr1 as *mut u8).wrapping_offset(diff); |
| /// assert_eq!(ptr2 as usize, ptr2_other as usize); |
| /// // Since ptr2_other and ptr2 are derived from pointers to different objects, |
| /// // computing their offset is undefined behavior, even though |
| /// // they point to the same address! |
| /// unsafe { |
| /// let zero = ptr2_other.offset_from(ptr2); // Undefined Behavior |
| /// } |
| /// ``` |
| #[stable(feature = "ptr_offset_from", since = "1.47.0")] |
| #[rustc_const_unstable(feature = "const_ptr_offset_from", issue = "41079")] |
| #[inline] |
| pub const unsafe fn offset_from(self, origin: *const T) -> isize |
| where |
| T: Sized, |
| { |
| // SAFETY: the caller must uphold the safety contract for `offset_from`. |
| unsafe { (self as *const T).offset_from(origin) } |
| } |
| |
| /// Calculates the offset from a pointer (convenience for `.offset(count as isize)`). |
| /// |
| /// `count` is in units of T; e.g., a `count` of 3 represents a pointer |
| /// offset of `3 * size_of::<T>()` bytes. |
| /// |
| /// # Safety |
| /// |
| /// If any of the following conditions are violated, the result is Undefined |
| /// Behavior: |
| /// |
| /// * Both the starting and resulting pointer must be either in bounds or one |
| /// byte past the end of the same [allocated object]. |
| /// |
| /// * The computed offset, **in bytes**, cannot overflow an `isize`. |
| /// |
| /// * The offset being in bounds cannot rely on "wrapping around" the address |
| /// space. That is, the infinite-precision sum must fit in a `usize`. |
| /// |
| /// The compiler and standard library generally tries to ensure allocations |
| /// never reach a size where an offset is a concern. For instance, `Vec` |
| /// and `Box` ensure they never allocate more than `isize::MAX` bytes, so |
| /// `vec.as_ptr().add(vec.len())` is always safe. |
| /// |
| /// Most platforms fundamentally can't even construct such an allocation. |
| /// For instance, no known 64-bit platform can ever serve a request |
| /// for 2<sup>63</sup> bytes due to page-table limitations or splitting the address space. |
| /// However, some 32-bit and 16-bit platforms may successfully serve a request for |
| /// more than `isize::MAX` bytes with things like Physical Address |
| /// Extension. As such, memory acquired directly from allocators or memory |
| /// mapped files *may* be too large to handle with this function. |
| /// |
| /// Consider using [`wrapping_add`] instead if these constraints are |
| /// difficult to satisfy. The only advantage of this method is that it |
| /// enables more aggressive compiler optimizations. |
| /// |
| /// [`wrapping_add`]: #method.wrapping_add |
| /// |
| /// # Examples |
| /// |
| /// Basic usage: |
| /// |
| /// ``` |
| /// let s: &str = "123"; |
| /// let ptr: *const u8 = s.as_ptr(); |
| /// |
| /// unsafe { |
| /// println!("{}", *ptr.add(1) as char); |
| /// println!("{}", *ptr.add(2) as char); |
| /// } |
| /// ``` |
| #[stable(feature = "pointer_methods", since = "1.26.0")] |
| #[must_use = "returns a new pointer rather than modifying its argument"] |
| #[rustc_const_unstable(feature = "const_ptr_offset", issue = "71499")] |
| #[inline(always)] |
| pub const unsafe fn add(self, count: usize) -> Self |
| where |
| T: Sized, |
| { |
| // SAFETY: the caller must uphold the safety contract for `offset`. |
| unsafe { self.offset(count as isize) } |
| } |
| |
| /// Calculates the offset from a pointer (convenience for |
| /// `.offset((count as isize).wrapping_neg())`). |
| /// |
| /// `count` is in units of T; e.g., a `count` of 3 represents a pointer |
| /// offset of `3 * size_of::<T>()` bytes. |
| /// |
| /// # Safety |
| /// |
| /// If any of the following conditions are violated, the result is Undefined |
| /// Behavior: |
| /// |
| /// * Both the starting and resulting pointer must be either in bounds or one |
| /// byte past the end of the same [allocated object]. |
| /// |
| /// * The computed offset cannot exceed `isize::MAX` **bytes**. |
| /// |
| /// * The offset being in bounds cannot rely on "wrapping around" the address |
| /// space. That is, the infinite-precision sum must fit in a usize. |
| /// |
| /// The compiler and standard library generally tries to ensure allocations |
| /// never reach a size where an offset is a concern. For instance, `Vec` |
| /// and `Box` ensure they never allocate more than `isize::MAX` bytes, so |
| /// `vec.as_ptr().add(vec.len()).sub(vec.len())` is always safe. |
| /// |
| /// Most platforms fundamentally can't even construct such an allocation. |
| /// For instance, no known 64-bit platform can ever serve a request |
| /// for 2<sup>63</sup> bytes due to page-table limitations or splitting the address space. |
| /// However, some 32-bit and 16-bit platforms may successfully serve a request for |
| /// more than `isize::MAX` bytes with things like Physical Address |
| /// Extension. As such, memory acquired directly from allocators or memory |
| /// mapped files *may* be too large to handle with this function. |
| /// |
| /// Consider using [`wrapping_sub`] instead if these constraints are |
| /// difficult to satisfy. The only advantage of this method is that it |
| /// enables more aggressive compiler optimizations. |
| /// |
| /// [`wrapping_sub`]: #method.wrapping_sub |
| /// [allocated object]: crate::ptr#allocated-object |
| /// |
| /// # Examples |
| /// |
| /// Basic usage: |
| /// |
| /// ``` |
| /// let s: &str = "123"; |
| /// |
| /// unsafe { |
| /// let end: *const u8 = s.as_ptr().add(3); |
| /// println!("{}", *end.sub(1) as char); |
| /// println!("{}", *end.sub(2) as char); |
| /// } |
| /// ``` |
| #[stable(feature = "pointer_methods", since = "1.26.0")] |
| #[must_use = "returns a new pointer rather than modifying its argument"] |
| #[rustc_const_unstable(feature = "const_ptr_offset", issue = "71499")] |
| #[inline] |
| pub const unsafe fn sub(self, count: usize) -> Self |
| where |
| T: Sized, |
| { |
| // SAFETY: the caller must uphold the safety contract for `offset`. |
| unsafe { self.offset((count as isize).wrapping_neg()) } |
| } |
| |
| /// Calculates the offset from a pointer using wrapping arithmetic. |
| /// (convenience for `.wrapping_offset(count as isize)`) |
| /// |
| /// `count` is in units of T; e.g., a `count` of 3 represents a pointer |
| /// offset of `3 * size_of::<T>()` bytes. |
| /// |
| /// # Safety |
| /// |
| /// This operation itself is always safe, but using the resulting pointer is not. |
| /// |
| /// The resulting pointer "remembers" the [allocated object] that `self` points to; it may not |
| /// be used to read or write other allocated objects. |
| /// |
| /// In other words, `let z = x.wrapping_add((y as usize) - (x as usize))` does *not* make `z` |
| /// the same as `y` even if we assume `T` has size `1` and there is no overflow: `z` is still |
| /// attached to the object `x` is attached to, and dereferencing it is Undefined Behavior unless |
| /// `x` and `y` point into the same allocated object. |
| /// |
| /// Compared to [`add`], this method basically delays the requirement of staying within the |
| /// same allocated object: [`add`] is immediate Undefined Behavior when crossing object |
| /// boundaries; `wrapping_add` produces a pointer but still leads to Undefined Behavior if a |
| /// pointer is dereferenced when it is out-of-bounds of the object it is attached to. [`add`] |
| /// can be optimized better and is thus preferable in performance-sensitive code. |
| /// |
| /// The delayed check only considers the value of the pointer that was dereferenced, not the |
| /// intermediate values used during the computation of the final result. For example, |
| /// `x.wrapping_add(o).wrapping_sub(o)` is always the same as `x`. In other words, leaving the |
| /// allocated object and then re-entering it later is permitted. |
| /// |
| /// [`add`]: #method.add |
| /// [allocated object]: crate::ptr#allocated-object |
| /// |
| /// # Examples |
| /// |
| /// Basic usage: |
| /// |
| /// ``` |
| /// // Iterate using a raw pointer in increments of two elements |
| /// let data = [1u8, 2, 3, 4, 5]; |
| /// let mut ptr: *const u8 = data.as_ptr(); |
| /// let step = 2; |
| /// let end_rounded_up = ptr.wrapping_add(6); |
| /// |
| /// // This loop prints "1, 3, 5, " |
| /// while ptr != end_rounded_up { |
| /// unsafe { |
| /// print!("{}, ", *ptr); |
| /// } |
| /// ptr = ptr.wrapping_add(step); |
| /// } |
| /// ``` |
| #[stable(feature = "pointer_methods", since = "1.26.0")] |
| #[must_use = "returns a new pointer rather than modifying its argument"] |
| #[rustc_const_unstable(feature = "const_ptr_offset", issue = "71499")] |
| #[inline(always)] |
| pub const fn wrapping_add(self, count: usize) -> Self |
| where |
| T: Sized, |
| { |
| self.wrapping_offset(count as isize) |
| } |
| |
| /// Calculates the offset from a pointer using wrapping arithmetic. |
| /// (convenience for `.wrapping_offset((count as isize).wrapping_neg())`) |
| /// |
| /// `count` is in units of T; e.g., a `count` of 3 represents a pointer |
| /// offset of `3 * size_of::<T>()` bytes. |
| /// |
| /// # Safety |
| /// |
| /// This operation itself is always safe, but using the resulting pointer is not. |
| /// |
| /// The resulting pointer "remembers" the [allocated object] that `self` points to; it may not |
| /// be used to read or write other allocated objects. |
| /// |
| /// In other words, `let z = x.wrapping_sub((x as usize) - (y as usize))` does *not* make `z` |
| /// the same as `y` even if we assume `T` has size `1` and there is no overflow: `z` is still |
| /// attached to the object `x` is attached to, and dereferencing it is Undefined Behavior unless |
| /// `x` and `y` point into the same allocated object. |
| /// |
| /// Compared to [`sub`], this method basically delays the requirement of staying within the |
| /// same allocated object: [`sub`] is immediate Undefined Behavior when crossing object |
| /// boundaries; `wrapping_sub` produces a pointer but still leads to Undefined Behavior if a |
| /// pointer is dereferenced when it is out-of-bounds of the object it is attached to. [`sub`] |
| /// can be optimized better and is thus preferable in performance-sensitive code. |
| /// |
| /// The delayed check only considers the value of the pointer that was dereferenced, not the |
| /// intermediate values used during the computation of the final result. For example, |
| /// `x.wrapping_add(o).wrapping_sub(o)` is always the same as `x`. In other words, leaving the |
| /// allocated object and then re-entering it later is permitted. |
| /// |
| /// [`sub`]: #method.sub |
| /// [allocated object]: crate::ptr#allocated-object |
| /// |
| /// # Examples |
| /// |
| /// Basic usage: |
| /// |
| /// ``` |
| /// // Iterate using a raw pointer in increments of two elements (backwards) |
| /// let data = [1u8, 2, 3, 4, 5]; |
| /// let mut ptr: *const u8 = data.as_ptr(); |
| /// let start_rounded_down = ptr.wrapping_sub(2); |
| /// ptr = ptr.wrapping_add(4); |
| /// let step = 2; |
| /// // This loop prints "5, 3, 1, " |
| /// while ptr != start_rounded_down { |
| /// unsafe { |
| /// print!("{}, ", *ptr); |
| /// } |
| /// ptr = ptr.wrapping_sub(step); |
| /// } |
| /// ``` |
| #[stable(feature = "pointer_methods", since = "1.26.0")] |
| #[must_use = "returns a new pointer rather than modifying its argument"] |
| #[rustc_const_unstable(feature = "const_ptr_offset", issue = "71499")] |
| #[inline] |
| pub const fn wrapping_sub(self, count: usize) -> Self |
| where |
| T: Sized, |
| { |
| self.wrapping_offset((count as isize).wrapping_neg()) |
| } |
| |
| /// Sets the pointer value to `ptr`. |
| /// |
| /// In case `self` is a (fat) pointer to an unsized type, this operation |
| /// will only affect the pointer part, whereas for (thin) pointers to |
| /// sized types, this has the same effect as a simple assignment. |
| /// |
| /// The resulting pointer will have provenance of `val`, i.e., for a fat |
| /// pointer, this operation is semantically the same as creating a new |
| /// fat pointer with the data pointer value of `val` but the metadata of |
| /// `self`. |
| /// |
| /// # Examples |
| /// |
| /// This function is primarily useful for allowing byte-wise pointer |
| /// arithmetic on potentially fat pointers: |
| /// |
| /// ``` |
| /// #![feature(set_ptr_value)] |
| /// # use core::fmt::Debug; |
| /// let mut arr: [i32; 3] = [1, 2, 3]; |
| /// let mut ptr = arr.as_mut_ptr() as *mut dyn Debug; |
| /// let thin = ptr as *mut u8; |
| /// unsafe { |
| /// ptr = ptr.set_ptr_value(thin.add(8)); |
| /// # assert_eq!(*(ptr as *mut i32), 3); |
| /// println!("{:?}", &*ptr); // will print "3" |
| /// } |
| /// ``` |
| #[unstable(feature = "set_ptr_value", issue = "75091")] |
| #[must_use = "returns a new pointer rather than modifying its argument"] |
| #[inline] |
| pub fn set_ptr_value(mut self, val: *mut u8) -> Self { |
| let thin = &mut self as *mut *mut T as *mut *mut u8; |
| // SAFETY: In case of a thin pointer, this operations is identical |
| // to a simple assignment. In case of a fat pointer, with the current |
| // fat pointer layout implementation, the first field of such a |
| // pointer is always the data pointer, which is likewise assigned. |
| unsafe { *thin = val }; |
| self |
| } |
| |
| /// Reads the value from `self` without moving it. This leaves the |
| /// memory in `self` unchanged. |
| /// |
| /// See [`ptr::read`] for safety concerns and examples. |
| /// |
| /// [`ptr::read`]: crate::ptr::read() |
| #[stable(feature = "pointer_methods", since = "1.26.0")] |
| #[rustc_const_unstable(feature = "const_ptr_read", issue = "80377")] |
| #[inline] |
| pub const unsafe fn read(self) -> T |
| where |
| T: Sized, |
| { |
| // SAFETY: the caller must uphold the safety contract for ``. |
| unsafe { read(self) } |
| } |
| |
| /// Performs a volatile read of the value from `self` without moving it. This |
| /// leaves the memory in `self` unchanged. |
| /// |
| /// Volatile operations are intended to act on I/O memory, and are guaranteed |
| /// to not be elided or reordered by the compiler across other volatile |
| /// operations. |
| /// |
| /// See [`ptr::read_volatile`] for safety concerns and examples. |
| /// |
| /// [`ptr::read_volatile`]: crate::ptr::read_volatile() |
| #[stable(feature = "pointer_methods", since = "1.26.0")] |
| #[inline] |
| pub unsafe fn read_volatile(self) -> T |
| where |
| T: Sized, |
| { |
| // SAFETY: the caller must uphold the safety contract for `read_volatile`. |
| unsafe { read_volatile(self) } |
| } |
| |
| /// Reads the value from `self` without moving it. This leaves the |
| /// memory in `self` unchanged. |
| /// |
| /// Unlike `read`, the pointer may be unaligned. |
| /// |
| /// See [`ptr::read_unaligned`] for safety concerns and examples. |
| /// |
| /// [`ptr::read_unaligned`]: crate::ptr::read_unaligned() |
| #[stable(feature = "pointer_methods", since = "1.26.0")] |
| #[rustc_const_unstable(feature = "const_ptr_read", issue = "80377")] |
| #[inline] |
| pub const unsafe fn read_unaligned(self) -> T |
| where |
| T: Sized, |
| { |
| // SAFETY: the caller must uphold the safety contract for `read_unaligned`. |
| unsafe { read_unaligned(self) } |
| } |
| |
| /// Copies `count * size_of<T>` bytes from `self` to `dest`. The source |
| /// and destination may overlap. |
| /// |
| /// NOTE: this has the *same* argument order as [`ptr::copy`]. |
| /// |
| /// See [`ptr::copy`] for safety concerns and examples. |
| /// |
| /// [`ptr::copy`]: crate::ptr::copy() |
| #[rustc_const_unstable(feature = "const_intrinsic_copy", issue = "80697")] |
| #[stable(feature = "pointer_methods", since = "1.26.0")] |
| #[inline] |
| pub const unsafe fn copy_to(self, dest: *mut T, count: usize) |
| where |
| T: Sized, |
| { |
| // SAFETY: the caller must uphold the safety contract for `copy`. |
| unsafe { copy(self, dest, count) } |
| } |
| |
| /// Copies `count * size_of<T>` bytes from `self` to `dest`. The source |
| /// and destination may *not* overlap. |
| /// |
| /// NOTE: this has the *same* argument order as [`ptr::copy_nonoverlapping`]. |
| /// |
| /// See [`ptr::copy_nonoverlapping`] for safety concerns and examples. |
| /// |
| /// [`ptr::copy_nonoverlapping`]: crate::ptr::copy_nonoverlapping() |
| #[rustc_const_unstable(feature = "const_intrinsic_copy", issue = "80697")] |
| #[stable(feature = "pointer_methods", since = "1.26.0")] |
| #[inline] |
| pub const unsafe fn copy_to_nonoverlapping(self, dest: *mut T, count: usize) |
| where |
| T: Sized, |
| { |
| // SAFETY: the caller must uphold the safety contract for `copy_nonoverlapping`. |
| unsafe { copy_nonoverlapping(self, dest, count) } |
| } |
| |
| /// Copies `count * size_of<T>` bytes from `src` to `self`. The source |
| /// and destination may overlap. |
| /// |
| /// NOTE: this has the *opposite* argument order of [`ptr::copy`]. |
| /// |
| /// See [`ptr::copy`] for safety concerns and examples. |
| /// |
| /// [`ptr::copy`]: crate::ptr::copy() |
| #[rustc_const_unstable(feature = "const_intrinsic_copy", issue = "80697")] |
| #[stable(feature = "pointer_methods", since = "1.26.0")] |
| #[inline] |
| pub const unsafe fn copy_from(self, src: *const T, count: usize) |
| where |
| T: Sized, |
| { |
| // SAFETY: the caller must uphold the safety contract for `copy`. |
| unsafe { copy(src, self, count) } |
| } |
| |
| /// Copies `count * size_of<T>` bytes from `src` to `self`. The source |
| /// and destination may *not* overlap. |
| /// |
| /// NOTE: this has the *opposite* argument order of [`ptr::copy_nonoverlapping`]. |
| /// |
| /// See [`ptr::copy_nonoverlapping`] for safety concerns and examples. |
| /// |
| /// [`ptr::copy_nonoverlapping`]: crate::ptr::copy_nonoverlapping() |
| #[rustc_const_unstable(feature = "const_intrinsic_copy", issue = "80697")] |
| #[stable(feature = "pointer_methods", since = "1.26.0")] |
| #[inline] |
| pub const unsafe fn copy_from_nonoverlapping(self, src: *const T, count: usize) |
| where |
| T: Sized, |
| { |
| // SAFETY: the caller must uphold the safety contract for `copy_nonoverlapping`. |
| unsafe { copy_nonoverlapping(src, self, count) } |
| } |
| |
| /// Executes the destructor (if any) of the pointed-to value. |
| /// |
| /// See [`ptr::drop_in_place`] for safety concerns and examples. |
| /// |
| /// [`ptr::drop_in_place`]: crate::ptr::drop_in_place() |
| #[stable(feature = "pointer_methods", since = "1.26.0")] |
| #[inline] |
| pub unsafe fn drop_in_place(self) { |
| // SAFETY: the caller must uphold the safety contract for `drop_in_place`. |
| unsafe { drop_in_place(self) } |
| } |
| |
| /// Overwrites a memory location with the given value without reading or |
| /// dropping the old value. |
| /// |
| /// See [`ptr::write`] for safety concerns and examples. |
| /// |
| /// [`ptr::write`]: crate::ptr::write() |
| #[stable(feature = "pointer_methods", since = "1.26.0")] |
| #[inline] |
| pub unsafe fn write(self, val: T) |
| where |
| T: Sized, |
| { |
| // SAFETY: the caller must uphold the safety contract for `write`. |
| unsafe { write(self, val) } |
| } |
| |
| /// Invokes memset on the specified pointer, setting `count * size_of::<T>()` |
| /// bytes of memory starting at `self` to `val`. |
| /// |
| /// See [`ptr::write_bytes`] for safety concerns and examples. |
| /// |
| /// [`ptr::write_bytes`]: crate::ptr::write_bytes() |
| #[stable(feature = "pointer_methods", since = "1.26.0")] |
| #[inline] |
| pub unsafe fn write_bytes(self, val: u8, count: usize) |
| where |
| T: Sized, |
| { |
| // SAFETY: the caller must uphold the safety contract for `write_bytes`. |
| unsafe { write_bytes(self, val, count) } |
| } |
| |
| /// Performs a volatile write of a memory location with the given value without |
| /// reading or dropping the old value. |
| /// |
| /// Volatile operations are intended to act on I/O memory, and are guaranteed |
| /// to not be elided or reordered by the compiler across other volatile |
| /// operations. |
| /// |
| /// See [`ptr::write_volatile`] for safety concerns and examples. |
| /// |
| /// [`ptr::write_volatile`]: crate::ptr::write_volatile() |
| #[stable(feature = "pointer_methods", since = "1.26.0")] |
| #[inline] |
| pub unsafe fn write_volatile(self, val: T) |
| where |
| T: Sized, |
| { |
| // SAFETY: the caller must uphold the safety contract for `write_volatile`. |
| unsafe { write_volatile(self, val) } |
| } |
| |
| /// Overwrites a memory location with the given value without reading or |
| /// dropping the old value. |
| /// |
| /// Unlike `write`, the pointer may be unaligned. |
| /// |
| /// See [`ptr::write_unaligned`] for safety concerns and examples. |
| /// |
| /// [`ptr::write_unaligned`]: crate::ptr::write_unaligned() |
| #[stable(feature = "pointer_methods", since = "1.26.0")] |
| #[rustc_const_unstable(feature = "const_ptr_write", issue = "none")] |
| #[inline] |
| pub const unsafe fn write_unaligned(self, val: T) |
| where |
| T: Sized, |
| { |
| // SAFETY: the caller must uphold the safety contract for `write_unaligned`. |
| unsafe { write_unaligned(self, val) } |
| } |
| |
| /// Replaces the value at `self` with `src`, returning the old |
| /// value, without dropping either. |
| /// |
| /// See [`ptr::replace`] for safety concerns and examples. |
| /// |
| /// [`ptr::replace`]: crate::ptr::replace() |
| #[stable(feature = "pointer_methods", since = "1.26.0")] |
| #[inline] |
| pub unsafe fn replace(self, src: T) -> T |
| where |
| T: Sized, |
| { |
| // SAFETY: the caller must uphold the safety contract for `replace`. |
| unsafe { replace(self, src) } |
| } |
| |
| /// Swaps the values at two mutable locations of the same type, without |
| /// deinitializing either. They may overlap, unlike `mem::swap` which is |
| /// otherwise equivalent. |
| /// |
| /// See [`ptr::swap`] for safety concerns and examples. |
| /// |
| /// [`ptr::swap`]: crate::ptr::swap() |
| #[stable(feature = "pointer_methods", since = "1.26.0")] |
| #[inline] |
| pub unsafe fn swap(self, with: *mut T) |
| where |
| T: Sized, |
| { |
| // SAFETY: the caller must uphold the safety contract for `swap`. |
| unsafe { swap(self, with) } |
| } |
| |
| /// Computes the offset that needs to be applied to the pointer in order to make it aligned to |
| /// `align`. |
| /// |
| /// If it is not possible to align the pointer, the implementation returns |
| /// `usize::MAX`. It is permissible for the implementation to *always* |
| /// return `usize::MAX`. Only your algorithm's performance can depend |
| /// on getting a usable offset here, not its correctness. |
| /// |
| /// The offset is expressed in number of `T` elements, and not bytes. The value returned can be |
| /// used with the `wrapping_add` method. |
| /// |
| /// There are no guarantees whatsoever that offsetting the pointer will not overflow or go |
| /// beyond the allocation that the pointer points into. It is up to the caller to ensure that |
| /// the returned offset is correct in all terms other than alignment. |
| /// |
| /// # Panics |
| /// |
| /// The function panics if `align` is not a power-of-two. |
| /// |
| /// # Examples |
| /// |
| /// Accessing adjacent `u8` as `u16` |
| /// |
| /// ``` |
| /// # fn foo(n: usize) { |
| /// # use std::mem::align_of; |
| /// # unsafe { |
| /// let x = [5u8, 6u8, 7u8, 8u8, 9u8]; |
| /// let ptr = x.as_ptr().add(n) as *const u8; |
| /// let offset = ptr.align_offset(align_of::<u16>()); |
| /// if offset < x.len() - n - 1 { |
| /// let u16_ptr = ptr.add(offset) as *const u16; |
| /// assert_ne!(*u16_ptr, 500); |
| /// } else { |
| /// // while the pointer can be aligned via `offset`, it would point |
| /// // outside the allocation |
| /// } |
| /// # } } |
| /// ``` |
| #[stable(feature = "align_offset", since = "1.36.0")] |
| pub fn align_offset(self, align: usize) -> usize |
| where |
| T: Sized, |
| { |
| if !align.is_power_of_two() { |
| panic!("align_offset: align is not a power-of-two"); |
| } |
| // SAFETY: `align` has been checked to be a power of 2 above |
| unsafe { align_offset(self, align) } |
| } |
| } |
| |
| #[lang = "mut_slice_ptr"] |
| impl<T> *mut [T] { |
| /// Returns the length of a raw slice. |
| /// |
| /// The returned value is the number of **elements**, not the number of bytes. |
| /// |
| /// This function is safe, even when the raw slice cannot be cast to a slice |
| /// reference because the pointer is null or unaligned. |
| /// |
| /// # Examples |
| /// |
| /// ```rust |
| /// #![feature(slice_ptr_len)] |
| /// use std::ptr; |
| /// |
| /// let slice: *mut [i8] = ptr::slice_from_raw_parts_mut(ptr::null_mut(), 3); |
| /// assert_eq!(slice.len(), 3); |
| /// ``` |
| #[inline] |
| #[unstable(feature = "slice_ptr_len", issue = "71146")] |
| #[rustc_const_unstable(feature = "const_slice_ptr_len", issue = "71146")] |
| pub const fn len(self) -> usize { |
| metadata(self) |
| } |
| |
| /// Returns a raw pointer to the slice's buffer. |
| /// |
| /// This is equivalent to casting `self` to `*mut T`, but more type-safe. |
| /// |
| /// # Examples |
| /// |
| /// ```rust |
| /// #![feature(slice_ptr_get)] |
| /// use std::ptr; |
| /// |
| /// let slice: *mut [i8] = ptr::slice_from_raw_parts_mut(ptr::null_mut(), 3); |
| /// assert_eq!(slice.as_mut_ptr(), 0 as *mut i8); |
| /// ``` |
| #[inline] |
| #[unstable(feature = "slice_ptr_get", issue = "74265")] |
| #[rustc_const_unstable(feature = "slice_ptr_get", issue = "74265")] |
| pub const fn as_mut_ptr(self) -> *mut T { |
| self as *mut T |
| } |
| |
| /// Returns a raw pointer to an element or subslice, without doing bounds |
| /// checking. |
| /// |
| /// Calling this method with an out-of-bounds index or when `self` is not dereferencable |
| /// is *[undefined behavior]* even if the resulting pointer is not used. |
| /// |
| /// [undefined behavior]: https://doc.rust-lang.org/reference/behavior-considered-undefined.html |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// #![feature(slice_ptr_get)] |
| /// |
| /// let x = &mut [1, 2, 4] as *mut [i32]; |
| /// |
| /// unsafe { |
| /// assert_eq!(x.get_unchecked_mut(1), x.as_mut_ptr().add(1)); |
| /// } |
| /// ``` |
| #[unstable(feature = "slice_ptr_get", issue = "74265")] |
| #[inline] |
| pub unsafe fn get_unchecked_mut<I>(self, index: I) -> *mut I::Output |
| where |
| I: SliceIndex<[T]>, |
| { |
| // SAFETY: the caller ensures that `self` is dereferencable and `index` in-bounds. |
| unsafe { index.get_unchecked_mut(self) } |
| } |
| |
| /// Returns `None` if the pointer is null, or else returns a shared slice to |
| /// the value wrapped in `Some`. In contrast to [`as_ref`], this does not require |
| /// that the value has to be initialized. |
| /// |
| /// For the mutable counterpart see [`as_uninit_slice_mut`]. |
| /// |
| /// [`as_ref`]: #method.as_ref-1 |
| /// [`as_uninit_slice_mut`]: #method.as_uninit_slice_mut |
| /// |
| /// # Safety |
| /// |
| /// When calling this method, you have to ensure that *either* the pointer is NULL *or* |
| /// all of the following is true: |
| /// |
| /// * The pointer must be [valid] for reads for `ptr.len() * mem::size_of::<T>()` many bytes, |
| /// and it must be properly aligned. This means in particular: |
| /// |
| /// * The entire memory range of this slice must be contained within a single [allocated object]! |
| /// Slices can never span across multiple allocated objects. |
| /// |
| /// * The pointer must be aligned even for zero-length slices. One |
| /// reason for this is that enum layout optimizations may rely on references |
| /// (including slices of any length) being aligned and non-null to distinguish |
| /// them from other data. You can obtain a pointer that is usable as `data` |
| /// for zero-length slices using [`NonNull::dangling()`]. |
| /// |
| /// * The total size `ptr.len() * mem::size_of::<T>()` of the slice must be no larger than `isize::MAX`. |
| /// See the safety documentation of [`pointer::offset`]. |
| /// |
| /// * You must enforce Rust's aliasing rules, since the returned lifetime `'a` is |
| /// arbitrarily chosen and does not necessarily reflect the actual lifetime of the data. |
| /// In particular, for the duration of this lifetime, the memory the pointer points to must |
| /// not get mutated (except inside `UnsafeCell`). |
| /// |
| /// This applies even if the result of this method is unused! |
| /// |
| /// See also [`slice::from_raw_parts`][]. |
| /// |
| /// [valid]: crate::ptr#safety |
| /// [allocated object]: crate::ptr#allocated-object |
| #[inline] |
| #[unstable(feature = "ptr_as_uninit", issue = "75402")] |
| pub unsafe fn as_uninit_slice<'a>(self) -> Option<&'a [MaybeUninit<T>]> { |
| if self.is_null() { |
| None |
| } else { |
| // SAFETY: the caller must uphold the safety contract for `as_uninit_slice`. |
| Some(unsafe { slice::from_raw_parts(self as *const MaybeUninit<T>, self.len()) }) |
| } |
| } |
| |
| /// Returns `None` if the pointer is null, or else returns a unique slice to |
| /// the value wrapped in `Some`. In contrast to [`as_mut`], this does not require |
| /// that the value has to be initialized. |
| /// |
| /// For the shared counterpart see [`as_uninit_slice`]. |
| /// |
| /// [`as_mut`]: #method.as_mut |
| /// [`as_uninit_slice`]: #method.as_uninit_slice-1 |
| /// |
| /// # Safety |
| /// |
| /// When calling this method, you have to ensure that *either* the pointer is NULL *or* |
| /// all of the following is true: |
| /// |
| /// * The pointer must be [valid] for reads and writes for `ptr.len() * mem::size_of::<T>()` |
| /// many bytes, and it must be properly aligned. This means in particular: |
| /// |
| /// * The entire memory range of this slice must be contained within a single [allocated object]! |
| /// Slices can never span across multiple allocated objects. |
| /// |
| /// * The pointer must be aligned even for zero-length slices. One |
| /// reason for this is that enum layout optimizations may rely on references |
| /// (including slices of any length) being aligned and non-null to distinguish |
| /// them from other data. You can obtain a pointer that is usable as `data` |
| /// for zero-length slices using [`NonNull::dangling()`]. |
| /// |
| /// * The total size `ptr.len() * mem::size_of::<T>()` of the slice must be no larger than `isize::MAX`. |
| /// See the safety documentation of [`pointer::offset`]. |
| /// |
| /// * You must enforce Rust's aliasing rules, since the returned lifetime `'a` is |
| /// arbitrarily chosen and does not necessarily reflect the actual lifetime of the data. |
| /// In particular, for the duration of this lifetime, the memory the pointer points to must |
| /// not get accessed (read or written) through any other pointer. |
| /// |
| /// This applies even if the result of this method is unused! |
| /// |
| /// See also [`slice::from_raw_parts_mut`][]. |
| /// |
| /// [valid]: crate::ptr#safety |
| /// [allocated object]: crate::ptr#allocated-object |
| #[inline] |
| #[unstable(feature = "ptr_as_uninit", issue = "75402")] |
| pub unsafe fn as_uninit_slice_mut<'a>(self) -> Option<&'a mut [MaybeUninit<T>]> { |
| if self.is_null() { |
| None |
| } else { |
| // SAFETY: the caller must uphold the safety contract for `as_uninit_slice_mut`. |
| Some(unsafe { slice::from_raw_parts_mut(self as *mut MaybeUninit<T>, self.len()) }) |
| } |
| } |
| } |
| |
| // Equality for pointers |
| #[stable(feature = "rust1", since = "1.0.0")] |
| impl<T: ?Sized> PartialEq for *mut T { |
| #[inline] |
| fn eq(&self, other: &*mut T) -> bool { |
| *self == *other |
| } |
| } |
| |
| #[stable(feature = "rust1", since = "1.0.0")] |
| impl<T: ?Sized> Eq for *mut T {} |
| |
| #[stable(feature = "rust1", since = "1.0.0")] |
| impl<T: ?Sized> Ord for *mut T { |
| #[inline] |
| fn cmp(&self, other: &*mut T) -> Ordering { |
| if self < other { |
| Less |
| } else if self == other { |
| Equal |
| } else { |
| Greater |
| } |
| } |
| } |
| |
| #[stable(feature = "rust1", since = "1.0.0")] |
| impl<T: ?Sized> PartialOrd for *mut T { |
| #[inline] |
| fn partial_cmp(&self, other: &*mut T) -> Option<Ordering> { |
| Some(self.cmp(other)) |
| } |
| |
| #[inline] |
| fn lt(&self, other: &*mut T) -> bool { |
| *self < *other |
| } |
| |
| #[inline] |
| fn le(&self, other: &*mut T) -> bool { |
| *self <= *other |
| } |
| |
| #[inline] |
| fn gt(&self, other: &*mut T) -> bool { |
| *self > *other |
| } |
| |
| #[inline] |
| fn ge(&self, other: &*mut T) -> bool { |
| *self >= *other |
| } |
| } |
