mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

get rid of the internal unlikely macro

Browse Source
This commit is contained in:
Ralf Jung 2024-10-08 14:11:44 +02:00
parent 3854e16fa2
commit 16b9bb744d
5 changed files with 31 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
library/core/src/intrinsics.rs
View File

@ -986,7 +986,10 @@ pub unsafe fn drop_in_place<T: ?Sized>(to_drop: *mut T) {
/// any safety invariants.
///
/// This intrinsic does not have a stable counterpart.
#[cfg_attr(bootstrap, rustc_const_unstable(feature = "const_likely", issue = "none"))]
#[cfg_attr(
bootstrap,
rustc_const_stable(feature = "const_likely", since = "CURRENT_RUSTC_VERSION")
)]
#[cfg_attr(not(bootstrap), rustc_const_stable_indirect)]
#[unstable(feature = "core_intrinsics", issue = "none")]
#[rustc_intrinsic]
@ -1007,7 +1010,10 @@ pub const fn likely(b: bool) -> bool {
/// any safety invariants.
///
/// This intrinsic does not have a stable counterpart.
#[cfg_attr(bootstrap, rustc_const_unstable(feature = "const_likely", issue = "none"))]
#[cfg_attr(
bootstrap,
rustc_const_stable(feature = "const_likely", since = "CURRENT_RUSTC_VERSION")
)]
#[cfg_attr(not(bootstrap), rustc_const_stable_indirect)]
#[unstable(feature = "core_intrinsics", issue = "none")]
#[rustc_intrinsic]

30
library/core/src/num/int_macros.rs
View File

@ -449,7 +449,7 @@ pub const fn to_le(self) -> Self {
#[inline]
pub const fn checked_add(self, rhs: Self) -> Option<Self> {
let (a, b) = self.overflowing_add(rhs);
if unlikely!(b) { None } else { Some(a) }
if intrinsics::unlikely(b) { None } else { Some(a) }
}
/// Strict integer addition. Computes `self + rhs`, panicking
@ -545,7 +545,7 @@ pub const fn strict_add(self, rhs: Self) -> Self {
#[inline]
pub const fn checked_add_unsigned(self, rhs: $UnsignedT) -> Option<Self> {
let (a, b) = self.overflowing_add_unsigned(rhs);
if unlikely!(b) { None } else { Some(a) }
if intrinsics::unlikely(b) { None } else { Some(a) }
}
/// Strict addition with an unsigned integer. Computes `self + rhs`,
@ -601,7 +601,7 @@ pub const fn strict_add_unsigned(self, rhs: $UnsignedT) -> Self {
#[inline]
pub const fn checked_sub(self, rhs: Self) -> Option<Self> {
let (a, b) = self.overflowing_sub(rhs);
if unlikely!(b) { None } else { Some(a) }
if intrinsics::unlikely(b) { None } else { Some(a) }
}
/// Strict integer subtraction. Computes `self - rhs`, panicking if
@ -697,7 +697,7 @@ pub const fn strict_sub(self, rhs: Self) -> Self {
#[inline]
pub const fn checked_sub_unsigned(self, rhs: $UnsignedT) -> Option<Self> {
let (a, b) = self.overflowing_sub_unsigned(rhs);
if unlikely!(b) { None } else { Some(a) }
if intrinsics::unlikely(b) { None } else { Some(a) }
}
/// Strict subtraction with an unsigned integer. Computes `self - rhs`,
@ -753,7 +753,7 @@ pub const fn strict_sub_unsigned(self, rhs: $UnsignedT) -> Self {
#[inline]
pub const fn checked_mul(self, rhs: Self) -> Option<Self> {
let (a, b) = self.overflowing_mul(rhs);
if unlikely!(b) { None } else { Some(a) }
if intrinsics::unlikely(b) { None } else { Some(a) }
}
/// Strict integer multiplication. Computes `self * rhs`, panicking if
@ -849,7 +849,7 @@ pub const fn strict_mul(self, rhs: Self) -> Self {
without modifying the original"]
#[inline]
pub const fn checked_div(self, rhs: Self) -> Option<Self> {
if unlikely!(rhs == 0 || ((self == Self::MIN) && (rhs == -1))) {
if intrinsics::unlikely(rhs == 0 || ((self == Self::MIN) && (rhs == -1))) {
None
} else {
// SAFETY: div by zero and by INT_MIN have been checked above
@ -924,7 +924,7 @@ pub const fn strict_div(self, rhs: Self) -> Self {
#[inline]
pub const fn checked_div_euclid(self, rhs: Self) -> Option<Self> {
// Using `&` helps LLVM see that it is the same check made in division.
if unlikely!(rhs == 0 || ((self == Self::MIN) & (rhs == -1))) {
if intrinsics::unlikely(rhs == 0 || ((self == Self::MIN) & (rhs == -1))) {
None
} else {
Some(self.div_euclid(rhs))
@ -997,7 +997,7 @@ pub const fn strict_div_euclid(self, rhs: Self) -> Self {
without modifying the original"]
#[inline]
pub const fn checked_rem(self, rhs: Self) -> Option<Self> {
if unlikely!(rhs == 0 || ((self == Self::MIN) && (rhs == -1))) {
if intrinsics::unlikely(rhs == 0 || ((self == Self::MIN) && (rhs == -1))) {
None
} else {
// SAFETY: div by zero and by INT_MIN have been checked above
@ -1071,7 +1071,7 @@ pub const fn strict_rem(self, rhs: Self) -> Self {
#[inline]
pub const fn checked_rem_euclid(self, rhs: Self) -> Option<Self> {
// Using `&` helps LLVM see that it is the same check made in division.
if unlikely!(rhs == 0 || ((self == Self::MIN) & (rhs == -1))) {
if intrinsics::unlikely(rhs == 0 || ((self == Self::MIN) & (rhs == -1))) {
None
} else {
Some(self.rem_euclid(rhs))
@ -1142,7 +1142,7 @@ pub const fn strict_rem_euclid(self, rhs: Self) -> Self {
#[inline]
pub const fn checked_neg(self) -> Option<Self> {
let (a, b) = self.overflowing_neg();
if unlikely!(b) { None } else { Some(a) }
if intrinsics::unlikely(b) { None } else { Some(a) }
}
/// Unchecked negation. Computes `-self`, assuming overflow cannot occur.
@ -2564,7 +2564,7 @@ pub const fn overflowing_mul(self, rhs: Self) -> (Self, bool) {
without modifying the original"]
pub const fn overflowing_div(self, rhs: Self) -> (Self, bool) {
// Using `&` helps LLVM see that it is the same check made in division.
if unlikely!((self == Self::MIN) & (rhs == -1)) {
if intrinsics::unlikely((self == Self::MIN) & (rhs == -1)) {
(self, true)
} else {
(self / rhs, false)
@ -2595,7 +2595,7 @@ pub const fn overflowing_div(self, rhs: Self) -> (Self, bool) {
without modifying the original"]
pub const fn overflowing_div_euclid(self, rhs: Self) -> (Self, bool) {
// Using `&` helps LLVM see that it is the same check made in division.
if unlikely!((self == Self::MIN) & (rhs == -1)) {
if intrinsics::unlikely((self == Self::MIN) & (rhs == -1)) {
(self, true)
} else {
(self.div_euclid(rhs), false)
@ -2625,7 +2625,7 @@ pub const fn overflowing_div_euclid(self, rhs: Self) -> (Self, bool) {
#[must_use = "this returns the result of the operation, \
without modifying the original"]
pub const fn overflowing_rem(self, rhs: Self) -> (Self, bool) {
if unlikely!(rhs == -1) {
if intrinsics::unlikely(rhs == -1) {
(0, self == Self::MIN)
} else {
(self % rhs, false)
@ -2657,7 +2657,7 @@ pub const fn overflowing_rem(self, rhs: Self) -> (Self, bool) {
#[inline]
#[track_caller]
pub const fn overflowing_rem_euclid(self, rhs: Self) -> (Self, bool) {
if unlikely!(rhs == -1) {
if intrinsics::unlikely(rhs == -1) {
(0, self == Self::MIN)
} else {
(self.rem_euclid(rhs), false)
@ -2686,7 +2686,7 @@ pub const fn overflowing_rem_euclid(self, rhs: Self) -> (Self, bool) {
without modifying the original"]
#[allow(unused_attributes)]
pub const fn overflowing_neg(self) -> (Self, bool) {
if unlikely!(self == Self::MIN) {
if intrinsics::unlikely(self == Self::MIN) {
(Self::MIN, true)
} else {
(-self, false)

7
library/core/src/num/mod.rs
View File

@ -16,13 +16,6 @@ macro_rules! try_opt {
};
}
#[cfg_attr(bootstrap, allow_internal_unstable(const_likely))]
macro_rules! unlikely {
($e: expr) => {
intrinsics::unlikely($e)
};
}
// Use this when the generated code should differ between signed and unsigned types.
macro_rules! sign_dependent_expr {
(signed ? if signed { $signed_case:expr } if unsigned { $unsigned_case:expr } ) => {

16
library/core/src/num/uint_macros.rs
View File

@ -491,7 +491,7 @@ pub const fn checked_add(self, rhs: Self) -> Option<Self> {
// Per <https://github.com/rust-lang/rust/pull/124114#issuecomment-2066173305>,
// LLVM is happy to re-form the intrinsic later if useful.
if unlikely!(intrinsics::add_with_overflow(self, rhs).1) {
if intrinsics::unlikely(intrinsics::add_with_overflow(self, rhs).1) {
None
} else {
// SAFETY: Just checked it doesn't overflow
@ -593,7 +593,7 @@ pub const fn strict_add(self, rhs: Self) -> Self {
#[inline]
pub const fn checked_add_signed(self, rhs: $SignedT) -> Option<Self> {
let (a, b) = self.overflowing_add_signed(rhs);
if unlikely!(b) { None } else { Some(a) }
if intrinsics::unlikely(b) { None } else { Some(a) }
}
/// Strict addition with a signed integer. Computes `self + rhs`,
@ -845,7 +845,7 @@ pub const fn checked_signed_diff(self, rhs: Self) -> Option<$SignedT> {
#[inline]
pub const fn checked_mul(self, rhs: Self) -> Option<Self> {
let (a, b) = self.overflowing_mul(rhs);
if unlikely!(b) { None } else { Some(a) }
if intrinsics::unlikely(b) { None } else { Some(a) }
}
/// Strict integer multiplication. Computes `self * rhs`, panicking if
@ -940,7 +940,7 @@ pub const fn strict_mul(self, rhs: Self) -> Self {
without modifying the original"]
#[inline]
pub const fn checked_div(self, rhs: Self) -> Option<Self> {
if unlikely!(rhs == 0) {
if intrinsics::unlikely(rhs == 0) {
None
} else {
// SAFETY: div by zero has been checked above and unsigned types have no other
@ -1001,7 +1001,7 @@ pub const fn strict_div(self, rhs: Self) -> Self {
without modifying the original"]
#[inline]
pub const fn checked_div_euclid(self, rhs: Self) -> Option<Self> {
if unlikely!(rhs == 0) {
if intrinsics::unlikely(rhs == 0) {
None
} else {
Some(self.div_euclid(rhs))
@ -1061,7 +1061,7 @@ pub const fn strict_div_euclid(self, rhs: Self) -> Self {
without modifying the original"]
#[inline]
pub const fn checked_rem(self, rhs: Self) -> Option<Self> {
if unlikely!(rhs == 0) {
if intrinsics::unlikely(rhs == 0) {
None
} else {
// SAFETY: div by zero has been checked above and unsigned types have no other
@ -1123,7 +1123,7 @@ pub const fn strict_rem(self, rhs: Self) -> Self {
without modifying the original"]
#[inline]
pub const fn checked_rem_euclid(self, rhs: Self) -> Option<Self> {
if unlikely!(rhs == 0) {
if intrinsics::unlikely(rhs == 0) {
None
} else {
Some(self.rem_euclid(rhs))
@ -1362,7 +1362,7 @@ pub const fn checked_ilog10(self) -> Option<u32> {
#[inline]
pub const fn checked_neg(self) -> Option<Self> {
let (a, b) = self.overflowing_neg();
if unlikely!(b) { None } else { Some(a) }
if intrinsics::unlikely(b) { None } else { Some(a) }
}
/// Strict negation. Computes `-self`, panicking unless `self ==

1
library/core/tests/lib.rs
View File

@ -1,5 +1,4 @@
// tidy-alphabetical-start
#![cfg_attr(bootstrap, feature(const_likely))]
#![cfg_attr(bootstrap, feature(strict_provenance))]
#![cfg_attr(not(bootstrap), feature(strict_provenance_lints))]
#![cfg_attr(target_has_atomic = "128", feature(integer_atomics))]