remove duplicated functions

Author: Lukas Markeffsky

library/core/src/lib.rs

@@ -129,7 +129,7 @@
 #![feature(const_option)]
 #![feature(const_option_ext)]
 #![feature(const_pin)]
-#![cfg_attr(not(bootstrap), feature(const_pointer_is_aligned))]
+#![feature(const_pointer_is_aligned)]
 #![feature(const_ptr_sub_ptr)]
 #![feature(const_replace)]
 #![feature(const_ptr_as_ref)]

library/core/src/ptr/const_ptr.rs

@@ -1348,26 +1348,15 @@ impl<T: ?Sized> *const T {
     #[inline]
     #[unstable(feature = "pointer_is_aligned", issue = "96284")]
     #[rustc_const_unstable(feature = "const_pointer_is_aligned", issue = "none")]
-    #[cfg(not(bootstrap))]
+    // #[cfg(not(bootstrap))] -- Calling this function in a const context from the bootstrap
+    // compiler will always return false.
     pub const fn is_aligned(self) -> bool
     where
         T: Sized,
     {
         self.is_aligned_to(core::mem::align_of::<T>())
     }
 
-    #[must_use]
-    #[inline]
-    #[unstable(feature = "pointer_is_aligned", issue = "96284")]
-    #[allow(missing_docs)]
-    #[cfg(bootstrap)]
-    pub fn is_aligned(self) -> bool
-    where
-        T: Sized,
-    {
-        self.is_aligned_to(core::mem::align_of::<T>())
-    }
-
     /// Returns whether the pointer is aligned to `align`.
     ///
     /// For non-`Sized` pointees this operation considers only the data pointer,
@@ -1380,7 +1369,8 @@ impl<T: ?Sized> *const T {
     #[inline]
     #[unstable(feature = "pointer_is_aligned", issue = "96284")]
     #[rustc_const_unstable(feature = "const_pointer_is_aligned", issue = "none")]
-    #[cfg(not(bootstrap))]
+    // #[cfg(not(bootstrap))] -- Calling this function in a const context from the bootstrap
+    // compiler will always return false.
     pub const fn is_aligned_to(self, align: usize) -> bool {
         assert!(align.is_power_of_two(), "is_aligned_to: align is not a power-of-two");
 
@@ -1396,20 +1386,6 @@ impl<T: ?Sized> *const T {
         // SAFETY: `ptr.align_offset(align)` returns 0 if and only if the pointer is already aligned.
         unsafe { intrinsics::const_eval_select((self.cast::<u8>(), align), comptime, runtime) }
     }
-
-    #[must_use]
-    #[inline]
-    #[unstable(feature = "pointer_is_aligned", issue = "96284")]
-    #[allow(missing_docs)]
-    #[cfg(bootstrap)]
-    pub fn is_aligned_to(self, align: usize) -> bool {
-        if !align.is_power_of_two() {
-            panic!("is_aligned_to: align is not a power-of-two");
-        }
-
-        // Cast is needed for `T: !Sized`
-        self.cast::<u8>().addr() & align - 1 == 0
-    }
 }
 
 impl<T> *const [T] {

library/core/src/ptr/mod.rs

@@ -1570,8 +1570,9 @@ pub unsafe fn write_volatile<T>(dst: *mut T, src: T) {
 /// than trying to adapt this to accommodate that change.
 ///
 /// Any questions go to @nagisa.
+// #[cfg(not(bootstrap))] -- Calling this function in a const context from the bootstrap
+// compiler will always cause an error.
 #[lang = "align_offset"]
-#[cfg(not(bootstrap))]
 pub(crate) const unsafe fn align_offset<T: Sized>(p: *const T, a: usize) -> usize {
     // FIXME(#75598): Direct use of these intrinsics improves codegen significantly at opt-level <=
     // 1, where the method versions of these operations are not inlined.
@@ -1734,165 +1735,6 @@ pub(crate) const unsafe fn align_offset<T: Sized>(p: *const T, a: usize) -> usiz
     usize::MAX
 }
 
-#[lang = "align_offset"]
-#[cfg(bootstrap)]
-pub(crate) unsafe fn align_offset<T: Sized>(p: *const T, a: usize) -> usize {
-    // FIXME(#75598): Direct use of these intrinsics improves codegen significantly at opt-level <=
-    // 1, where the method versions of these operations are not inlined.
-    use intrinsics::{
-        cttz_nonzero, exact_div, unchecked_rem, unchecked_shl, unchecked_shr, unchecked_sub,
-        wrapping_add, wrapping_mul, wrapping_sub,
-    };
-
-    /// Calculate multiplicative modular inverse of `x` modulo `m`.
-    ///
-    /// This implementation is tailored for `align_offset` and has following preconditions:
-    ///
-    /// * `m` is a power-of-two;
-    /// * `x < m`; (if `x ≥ m`, pass in `x % m` instead)
-    ///
-    /// Implementation of this function shall not panic. Ever.
-    #[inline]
-    unsafe fn mod_inv(x: usize, m: usize) -> usize {
-        /// Multiplicative modular inverse table modulo 2⁴ = 16.
-        ///
-        /// Note, that this table does not contain values where inverse does not exist (i.e., for
-        /// `0⁻¹ mod 16`, `2⁻¹ mod 16`, etc.)
-        const INV_TABLE_MOD_16: [u8; 8] = [1, 11, 13, 7, 9, 3, 5, 15];
-        /// Modulo for which the `INV_TABLE_MOD_16` is intended.
-        const INV_TABLE_MOD: usize = 16;
-        /// INV_TABLE_MOD²
-        const INV_TABLE_MOD_SQUARED: usize = INV_TABLE_MOD * INV_TABLE_MOD;
-
-        let table_inverse = INV_TABLE_MOD_16[(x & (INV_TABLE_MOD - 1)) >> 1] as usize;
-        // SAFETY: `m` is required to be a power-of-two, hence non-zero.
-        let m_minus_one = unsafe { unchecked_sub(m, 1) };
-        if m <= INV_TABLE_MOD {
-            table_inverse & m_minus_one
-        } else {
-            // We iterate "up" using the following formula:
-            //
-            // $$ xy ≡ 1 (mod 2ⁿ) → xy (2 - xy) ≡ 1 (mod 2²ⁿ) $$
-            //
-            // until 2²ⁿ ≥ m. Then we can reduce to our desired `m` by taking the result `mod m`.
-            let mut inverse = table_inverse;
-            let mut going_mod = INV_TABLE_MOD_SQUARED;
-            loop {
-                // y = y * (2 - xy) mod n
-                //
-                // Note, that we use wrapping operations here intentionally – the original formula
-                // uses e.g., subtraction `mod n`. It is entirely fine to do them `mod
-                // usize::MAX` instead, because we take the result `mod n` at the end
-                // anyway.
-                inverse = wrapping_mul(inverse, wrapping_sub(2usize, wrapping_mul(x, inverse)));
-                if going_mod >= m {
-                    return inverse & m_minus_one;
-                }
-                going_mod = wrapping_mul(going_mod, going_mod);
-            }
-        }
-    }
-
-    let addr = p.addr();
-    let stride = mem::size_of::<T>();
-    // SAFETY: `a` is a power-of-two, therefore non-zero.
-    let a_minus_one = unsafe { unchecked_sub(a, 1) };
-
-    if stride == 0 {
-        // SPECIAL_CASE: handle 0-sized types. No matter how many times we step, the address will
-        // stay the same, so no offset will be able to align the pointer unless it is already
-        // aligned. This branch _will_ be optimized out as `stride` is known at compile-time.
-        let p_mod_a = addr & a_minus_one;
-        return if p_mod_a == 0 { 0 } else { usize::MAX };
-    }
-
-    // SAFETY: `stride == 0` case has been handled by the special case above.
-    let a_mod_stride = unsafe { unchecked_rem(a, stride) };
-    if a_mod_stride == 0 {
-        // SPECIAL_CASE: In cases where the `a` is divisible by `stride`, byte offset to align a
-        // pointer can be computed more simply through `-p (mod a)`. In the off-chance the byte
-        // offset is not a multiple of `stride`, the input pointer was misaligned and no pointer
-        // offset will be able to produce a `p` aligned to the specified `a`.
-        //
-        // The naive `-p (mod a)` equation  inhibits LLVM's ability to select instructions
-        // like `lea`. We compute `(round_up_to_next_alignment(p, a) - p)` instead. This
-        // redistributes operations around the load-bearing, but pessimizing `and` instruction
-        // sufficiently for LLVM to be able to utilize the various optimizations it knows about.
-        //
-        // LLVM handles the branch here particularly nicely. If this branch needs to be evaluated
-        // at runtime, it will produce a mask `if addr_mod_stride == 0 { 0 } else { usize::MAX }`
-        // in a branch-free way and then bitwise-OR it with whatever result the `-p mod a`
-        // computation produces.
-
-        // SAFETY: `stride == 0` case has been handled by the special case above.
-        let addr_mod_stride = unsafe { unchecked_rem(addr, stride) };
-
-        return if addr_mod_stride == 0 {
-            let aligned_address = wrapping_add(addr, a_minus_one) & wrapping_sub(0, a);
-            let byte_offset = wrapping_sub(aligned_address, addr);
-            // SAFETY: `stride` is non-zero. This is guaranteed to divide exactly as well, because
-            // addr has been verified to be aligned to the original type’s alignment requirements.
-            unsafe { exact_div(byte_offset, stride) }
-        } else {
-            usize::MAX
-        };
-    }
-
-    // GENERAL_CASE: From here on we’re handling the very general case where `addr` may be
-    // misaligned, there isn’t an obvious relationship between `stride` and `a` that we can take an
-    // advantage of, etc. This case produces machine code that isn’t particularly high quality,
-    // compared to the special cases above. The code produced here is still within the realm of
-    // miracles, given the situations this case has to deal with.
-
-    // SAFETY: a is power-of-two hence non-zero. stride == 0 case is handled above.
-    let gcdpow = unsafe { cttz_nonzero(stride).min(cttz_nonzero(a)) };
-    // SAFETY: gcdpow has an upper-bound that’s at most the number of bits in a usize.
-    let gcd = unsafe { unchecked_shl(1usize, gcdpow) };
-    // SAFETY: gcd is always greater or equal to 1.
-    if addr & unsafe { unchecked_sub(gcd, 1) } == 0 {
-        // This branch solves for the following linear congruence equation:
-        //
-        // ` p + so = 0 mod a `
-        //
-        // `p` here is the pointer value, `s` - stride of `T`, `o` offset in `T`s, and `a` - the
-        // requested alignment.
-        //
-        // With `g = gcd(a, s)`, and the above condition asserting that `p` is also divisible by
-        // `g`, we can denote `a' = a/g`, `s' = s/g`, `p' = p/g`, then this becomes equivalent to:
-        //
-        // ` p' + s'o = 0 mod a' `
-        // ` o = (a' - (p' mod a')) * (s'^-1 mod a') `
-        //
-        // The first term is "the relative alignment of `p` to `a`" (divided by the `g`), the
-        // second term is "how does incrementing `p` by `s` bytes change the relative alignment of
-        // `p`" (again divided by `g`). Division by `g` is necessary to make the inverse well
-        // formed if `a` and `s` are not co-prime.
-        //
-        // Furthermore, the result produced by this solution is not "minimal", so it is necessary
-        // to take the result `o mod lcm(s, a)`. This `lcm(s, a)` is the same as `a'`.
-
-        // SAFETY: `gcdpow` has an upper-bound not greater than the number of trailing 0-bits in
-        // `a`.
-        let a2 = unsafe { unchecked_shr(a, gcdpow) };
-        // SAFETY: `a2` is non-zero. Shifting `a` by `gcdpow` cannot shift out any of the set bits
-        // in `a` (of which it has exactly one).
-        let a2minus1 = unsafe { unchecked_sub(a2, 1) };
-        // SAFETY: `gcdpow` has an upper-bound not greater than the number of trailing 0-bits in
-        // `a`.
-        let s2 = unsafe { unchecked_shr(stride & a_minus_one, gcdpow) };
-        // SAFETY: `gcdpow` has an upper-bound not greater than the number of trailing 0-bits in
-        // `a`. Furthermore, the subtraction cannot overflow, because `a2 = a >> gcdpow` will
-        // always be strictly greater than `(p % a) >> gcdpow`.
-        let minusp2 = unsafe { unchecked_sub(a2, unchecked_shr(addr & a_minus_one, gcdpow)) };
-        // SAFETY: `a2` is a power-of-two, as proven above. `s2` is strictly less than `a2`
-        // because `(s % a) >> gcdpow` is strictly less than `a >> gcdpow`.
-        return wrapping_mul(minusp2, unsafe { mod_inv(s2, a2) }) & a2minus1;
-    }
-
-    // Cannot be aligned at all.
-    usize::MAX
-}
-
 /// Compares raw pointers for equality.
 ///
 /// This is the same as using the `==` operator, but less generic:

library/core/src/ptr/mut_ptr.rs

@@ -1619,26 +1619,15 @@ impl<T: ?Sized> *mut T {
     #[inline]
     #[unstable(feature = "pointer_is_aligned", issue = "96284")]
     #[rustc_const_unstable(feature = "const_pointer_is_aligned", issue = "none")]
-    #[cfg(not(bootstrap))]
+    // #[cfg(not(bootstrap))] -- Calling this function in a const context from the bootstrap
+    // compiler will always return false.
     pub const fn is_aligned(self) -> bool
     where
         T: Sized,
     {
         self.is_aligned_to(core::mem::align_of::<T>())
     }
 
-    #[must_use]
-    #[inline]
-    #[unstable(feature = "pointer_is_aligned", issue = "96284")]
-    #[allow(missing_docs)]
-    #[cfg(bootstrap)]
-    pub fn is_aligned(self) -> bool
-    where
-        T: Sized,
-    {
-        self.is_aligned_to(core::mem::align_of::<T>())
-    }
-
     /// Returns whether the pointer is aligned to `align`.
     ///
     /// For non-`Sized` pointees this operation considers only the data pointer,
@@ -1651,7 +1640,8 @@ impl<T: ?Sized> *mut T {
     #[inline]
     #[unstable(feature = "pointer_is_aligned", issue = "96284")]
     #[rustc_const_unstable(feature = "const_pointer_is_aligned", issue = "none")]
-    #[cfg(not(bootstrap))]
+    // #[cfg(not(bootstrap))] -- Calling this function in a const context from the bootstrap
+    // compiler will always return false.
     pub const fn is_aligned_to(self, align: usize) -> bool {
         assert!(align.is_power_of_two(), "is_aligned_to: align is not a power-of-two");
 
@@ -1667,20 +1657,6 @@ impl<T: ?Sized> *mut T {
         // SAFETY: `ptr.align_offset(align)` returns 0 if and only if the pointer is already aligned.
         unsafe { intrinsics::const_eval_select((self.cast::<u8>(), align), comptime, runtime) }
     }
-
-    #[must_use]
-    #[inline]
-    #[unstable(feature = "pointer_is_aligned", issue = "96284")]
-    #[allow(missing_docs)]
-    #[cfg(bootstrap)]
-    pub fn is_aligned_to(self, align: usize) -> bool {
-        if !align.is_power_of_two() {
-            panic!("is_aligned_to: align is not a power-of-two");
-        }
-
-        // Cast is needed for `T: !Sized`
-        self.cast::<u8>().addr() & align - 1 == 0
-    }
 }
 
 impl<T> *mut [T] {

library/core/tests/lib.rs

@@ -17,7 +17,7 @@
 #![feature(const_nonnull_new)]
 #![feature(const_num_from_num)]
 #![feature(const_pointer_byte_offsets)]
-#![cfg_attr(not(bootstrap), feature(const_pointer_is_aligned))]
+#![feature(const_pointer_is_aligned)]
 #![feature(const_ptr_as_ref)]
 #![feature(const_ptr_read)]
 #![feature(const_ptr_write)]

library/core/tests/ptr.rs

@@ -656,6 +656,18 @@ fn is_aligned_const() {
     }
 }
 
+#[test]
+#[cfg(bootstrap)]
+fn is_aligned_const() {
+    const {
+        let data = 42;
+        let ptr: *const i32 = &data;
+        // The bootstrap compiler always returns false for is_aligned
+        assert!(!ptr.is_aligned());
+        assert!(!ptr.is_aligned_to(1));
+    }
+}
+
 #[test]
 fn offset_from() {
     let mut a = [0; 5];