also remove redundant requirements from offset()

library/core/src/ptr/const_ptr.rs

@@ -623,7 +623,7 @@ impl<T: ?Sized> *const T {
     /// * The distance between the pointers, in bytes, must be an exact multiple
     ///   of the size of `T`.
     ///
-    /// As a consequence, the absolute distance between the pointers, **in bytes**, computed on
+    /// As a consequence, the absolute distance between the pointers, in bytes, computed on
     /// mathematical integers (without "wrapping around"), cannot overflow an `isize`. This is
     /// implied by the in-bounds requirement, and the fact that no allocated object can be larger
     /// than `isize::MAX`.

library/core/src/ptr/mut_ptr.rs

@@ -404,37 +404,25 @@ impl<T: ?Sized> *mut T {
         if self.is_null() { None } else { Some(unsafe { &*(self as *const MaybeUninit<T>) }) }
     }
 
-    /// Calculates the offset from a pointer.
+    /// Adds an offset to 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:
-    ///
-    /// * If the computed offset, **in bytes**, is non-zero, then both the starting and resulting
-    ///   pointer must be either in bounds or at the end of the same [allocated object].
-    ///   (If it is zero, then the function is always well-defined.)
+    /// The resulting pointer's address is computed as the address of the original pointer plus the
+    /// computed offset, `count * size_of::<T>()`, with infinite precision.
     ///
-    /// * The computed offset, **in bytes**, cannot overflow an `isize`.
+    /// If the following condition is violated, the result is Undefined Behavior:
     ///
-    /// * 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.
+    /// * If the computed offset is non-zero, then the entire memory range between `self` and the
+    ///   result must be in bounds of the [allocated object] `self` is derived from.
     ///
-    /// 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.
+    /// Allocated objects can never be larger than `isize::MAX` and they never "wrap around" the
+    /// edge of the address space, so as a consequence of this, `count * size_of::<T>()` must
+    /// fit in an `isize` and adding the computed offset to `self` produces a resulting address
+    /// that fits into a `usize`.
     ///
     /// Consider using [`wrapping_offset`] instead if these constraints are
     /// difficult to satisfy. The only advantage of this method is that it