Remove #[inline(never)]

core/src/parking_lot.rs

@@ -181,7 +181,6 @@ fn get_hashtable() -> *mut HashTable {
 
 // Get a pointer to the latest hash table, creating one if it doesn't exist yet.
 #[cold]
-#[inline(never)]
 fn create_hashtable() -> *mut HashTable {
     let new_table = Box::into_raw(HashTable::new(LOAD_FACTOR, ptr::null()));
 

core/src/thread_parker/windows/mod.rs

@@ -34,7 +34,6 @@ impl Backend {
     }
 
     #[cold]
-    #[inline(never)]
     fn create() -> &'static Backend {
         // Try to create a new Backend
         let backend;

core/src/word_lock.rs

@@ -103,7 +103,6 @@ impl WordLock {
     }
 
     #[cold]
-    #[inline(never)]
     fn lock_slow(&self) {
         let mut spinwait = SpinWait::new();
         let mut state = self.state.load(Ordering::Relaxed);
@@ -171,7 +170,6 @@ impl WordLock {
     }
 
     #[cold]
-    #[inline(never)]
     fn unlock_slow(&self) {
         let mut state = self.state.load(Ordering::Relaxed);
         loop {

src/condvar.rs

@@ -129,7 +129,6 @@ impl Condvar {
     }
 
     #[cold]
-    #[inline(never)]
     fn notify_one_slow(&self, mutex: *mut RawMutex) -> bool {
         unsafe {
             // Unpark one thread and requeue the rest onto the mutex
@@ -191,7 +190,6 @@ impl Condvar {
     }
 
     #[cold]
-    #[inline(never)]
     fn notify_all_slow(&self, mutex: *mut RawMutex) -> usize {
         unsafe {
             // Unpark one thread and requeue the rest onto the mutex

src/once.rs

@@ -209,7 +209,6 @@ impl Once {
     // currently no way to take an `FnOnce` and call it via virtual dispatch
     // without some allocation overhead.
     #[cold]
-    #[inline(never)]
     fn call_once_slow(&self, ignore_poison: bool, f: &mut dyn FnMut(OnceState)) {
         let mut spinwait = SpinWait::new();
         let mut state = self.0.load(Ordering::Relaxed);

src/raw_mutex.rs

@@ -174,7 +174,6 @@ impl RawMutex {
     }
 
     #[cold]
-    #[inline(never)]
     fn lock_slow(&self, timeout: Option<Instant>) -> bool {
         let mut spinwait = SpinWait::new();
         let mut state = self.state.load(Ordering::Relaxed);
@@ -253,7 +252,6 @@ impl RawMutex {
     }
 
     #[cold]
-    #[inline(never)]
     fn unlock_slow(&self, force_fair: bool) {
         // Unpark one thread and leave the parked bit set if there might
         // still be parked threads on this address.
@@ -285,7 +283,6 @@ impl RawMutex {
     }
 
     #[cold]
-    #[inline(never)]
     fn bump_slow(&self) {
         unsafe { deadlock::release_resource(self as *const _ as usize) };
         self.unlock_slow(true);

src/raw_rwlock.rs

@@ -492,7 +492,6 @@ impl RawRwLock {
     }
 
     #[cold]
-    #[inline(never)]
     fn try_lock_shared_slow(&self, recursive: bool) -> bool {
         let mut state = self.state.load(Ordering::Relaxed);
         loop {
@@ -541,7 +540,6 @@ impl RawRwLock {
     }
 
     #[cold]
-    #[inline(never)]
     fn try_lock_upgradable_slow(&self) -> bool {
         let mut state = self.state.load(Ordering::Relaxed);
         loop {
@@ -565,7 +563,6 @@ impl RawRwLock {
     }
 
     #[cold]
-    #[inline(never)]
     fn lock_exclusive_slow(&self, timeout: Option<Instant>) -> bool {
         // Step 1: grab exclusive ownership of WRITER_BIT
         let timed_out = !self.lock_common(
@@ -600,7 +597,6 @@ impl RawRwLock {
     }
 
     #[cold]
-    #[inline(never)]
     fn unlock_exclusive_slow(&self, force_fair: bool) {
         // There are threads to unpark. Try to unpark as many as we can.
         let callback = |mut new_state, result: UnparkResult| {
@@ -626,7 +622,6 @@ impl RawRwLock {
     }
 
     #[cold]
-    #[inline(never)]
     fn lock_shared_slow(&self, recursive: bool, timeout: Option<Instant>) -> bool {
         self.lock_common(
             timeout,
@@ -676,7 +671,6 @@ impl RawRwLock {
     }
 
     #[cold]
-    #[inline(never)]
     fn unlock_shared_slow(&self) {
         // At this point WRITER_PARKED_BIT is set and READER_MASK is empty. We
         // just need to wake up a potentially sleeping pending writer.
@@ -695,7 +689,6 @@ impl RawRwLock {
     }
 
     #[cold]
-    #[inline(never)]
     fn lock_upgradable_slow(&self, timeout: Option<Instant>) -> bool {
         self.lock_common(
             timeout,
@@ -734,7 +727,6 @@ impl RawRwLock {
     }
 
     #[cold]
-    #[inline(never)]
     fn unlock_upgradable_slow(&self, force_fair: bool) {
         // Just release the lock if there are no parked threads.
         let mut state = self.state.load(Ordering::Relaxed);
@@ -801,7 +793,6 @@ impl RawRwLock {
     }
 
     #[cold]
-    #[inline(never)]
     fn try_upgrade_slow(&self) -> bool {
         let mut state = self.state.load(Ordering::Relaxed);
         loop {
@@ -821,13 +812,11 @@ impl RawRwLock {
     }
 
     #[cold]
-    #[inline(never)]
     fn upgrade_slow(&self, timeout: Option<Instant>) -> bool {
         self.wait_for_readers(timeout, ONE_READER | UPGRADABLE_BIT)
     }
 
     #[cold]
-    #[inline(never)]
     fn downgrade_slow(&self) {
         // We only reach this point if PARKED_BIT is set.
         let callback = |_, result: UnparkResult| {
@@ -841,7 +830,6 @@ impl RawRwLock {
     }
 
     #[cold]
-    #[inline(never)]
     fn downgrade_to_upgradable_slow(&self) {
         // We only reach this point if PARKED_BIT is set.
         let callback = |_, result: UnparkResult| {
@@ -855,22 +843,19 @@ impl RawRwLock {
     }
 
     #[cold]
-    #[inline(never)]
     fn bump_shared_slow(&self) {
         self.unlock_shared();
         self.lock_shared();
     }
 
     #[cold]
-    #[inline(never)]
     fn bump_exclusive_slow(&self) {
         self.deadlock_release();
         self.unlock_exclusive_slow(true);
         self.lock_exclusive();
     }
 
     #[cold]
-    #[inline(never)]
     fn bump_upgradable_slow(&self) {
         self.deadlock_release();
         self.unlock_upgradable_slow(true);