align_offset, align_to: no longer allow implementations to spuriously…

… fail to align
rust-lang · Feb 16, 2024 · 51b3496 · 51b3496
1 parent d2e8ecd
commit 51b3496
Show file tree

Hide file tree

Showing 2 changed files with 13 additions and 13 deletions.
diff --git a/library/core/src/ptr/const_ptr.rs b/library/core/src/ptr/const_ptr.rs
@@ -1322,9 1322,7 @@ impl<T: ?Sized> *const T {
  /// `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.
  /// `usize::MAX`.
  ///
  /// The offset is expressed in number of `T` elements, and not bytes. The value returned can be
  /// used with the `wrapping_add` method.
@@ -1333,6 1331,14 @@ impl<T: ?Sized> *const T {
  /// 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.
  ///
  /// When this is called during compile-time evaluation (which is unstable), the implementation
  /// may return `usize::MAX` in cases where that can never happen at runtime. This is because the
  /// actual alignment of pointers is not known yet during compile-time, so an offset with
  /// guaranteed alignment can sometimes not be computed. For example, a buffer declared as `[u8;
  /// N]` might be allocated at an odd or an even address, but at compile-time this is not yet
  /// known, so the execution has to be correct for either choice. It is therefore impossible to
  /// find an offset that is guaranteed to be 2-aligned.
  ///
  /// # Panics
  ///
  /// The function panics if `align` is not a power-of-two.

diff --git a/library/core/src/slice/mod.rs b/library/core/src/slice/mod.rs
@@ -3756,11 3756,8 @@ impl<T> [T] {
  /// maintained.
  ///
  /// This method splits the slice into three distinct slices: prefix, correctly aligned middle
- /// slice of a new type, and the suffix slice. How exactly the slice is split up is not
- /// specified; the middle part may be smaller than necessary. However, if this fails to return a
- /// maximal middle part, that is because code is running in a context where performance does not
- /// matter, such as a sanitizer attempting to find alignment bugs. Regular code running
- /// in a default (debug or release) execution *will* return a maximal middle part.
  /// slice of a new type, and the suffix slice. The middle part will be as big as possible under
  /// the given alignment constraint and element size.
  ///
  /// This method has no purpose when either input element `T` or output element `U` are
  /// zero-sized and will return the original slice without splitting anything.
@@ -3824,11 3821,8 @@ impl<T> [T] {
  /// types is maintained.
  ///
  /// This method splits the slice into three distinct slices: prefix, correctly aligned middle
- /// slice of a new type, and the suffix slice. How exactly the slice is split up is not
- /// specified; the middle part may be smaller than necessary. However, if this fails to return a
- /// maximal middle part, that is because code is running in a context where performance does not
- /// matter, such as a sanitizer attempting to find alignment bugs. Regular code running
- /// in a default (debug or release) execution *will* return a maximal middle part.
  /// slice of a new type, and the suffix slice. The middle part will be as big as possible under
  /// the given alignment constraint and element size.
  ///
  /// This method has no purpose when either input element `T` or output element `U` are
  /// zero-sized and will return the original slice without splitting anything.