Inline some functions

Author: EFanZh

library/alloc/src/raw_rc/mod.rs

@@ -214,6 +214,7 @@ impl RefCounts {
 ///
 /// - `value_ptr` must point to a value object (can be uninitialized or dropped) that lives in a
 ///   reference-counted allocation.
+#[inline]
 unsafe fn ref_counts_ptr_from_value_ptr(value_ptr: NonNull<()>) -> NonNull<RefCounts> {
     // SAFETY: Caller guarantees `value_ptr` point to the value inside some reference counted, our
     // implementation guarantees the `RefCounts` object has offset of `size_of::<RefCounts>()` to
@@ -228,6 +229,7 @@ unsafe fn ref_counts_ptr_from_value_ptr(value_ptr: NonNull<()>) -> NonNull<RefCo
 ///
 /// - `value_ptr` must point to a value object (can be uninitialized or dropped) that lives in a
 ///   reference-counted allocation.
+#[inline]
 unsafe fn strong_count_ptr_from_value_ptr(value_ptr: NonNull<()>) -> NonNull<UnsafeCell<usize>> {
     let ref_counts_ptr = unsafe { ref_counts_ptr_from_value_ptr(value_ptr) };
 
@@ -241,6 +243,7 @@ unsafe fn strong_count_ptr_from_value_ptr(value_ptr: NonNull<()>) -> NonNull<Uns
 ///
 /// - `value_ptr` must point to a value object (can be uninitialized or dropped) that lives in a
 ///   reference-counted allocation.
+#[inline]
 unsafe fn weak_count_ptr_from_value_ptr(value_ptr: NonNull<()>) -> NonNull<UnsafeCell<usize>> {
     let ref_counts_ptr = unsafe { ref_counts_ptr_from_value_ptr(value_ptr) };
 
@@ -415,6 +418,7 @@ where
 /// Allocates a reference-counted memory chunk for storing a value according to `rc_layout`, then
 /// initialize the value with `f`. If `f` panics, the allocated memory will be deallocated.
 #[cfg(not(no_global_oom_handling))]
+#[inline]
 fn allocate_with_in<A, F, const STRONG_COUNT: usize>(
     alloc: &A,
     rc_layout: RcLayout,
@@ -456,6 +460,7 @@ where
 /// described by `rc_layout`. `f` will be called with a pointer that points the value storage to
 /// initialize the allocated memory. If `f` panics, the allocated memory will be deallocated.
 #[cfg(not(no_global_oom_handling))]
+#[inline]
 fn allocate_with<A, F, const STRONG_COUNT: usize>(rc_layout: RcLayout, f: F) -> (NonNull<()>, A)
 where
     A: Allocator + Default,
@@ -475,6 +480,7 @@ where
 /// - Memory pointed to by `src_ptr` has enough data to read for filling the value in an allocation
 ///   that is described by `rc_layout`.
 #[cfg(not(no_global_oom_handling))]
+#[inline]
 unsafe fn allocate_with_bytes_in<A, const STRONG_COUNT: usize>(
     src_ptr: NonNull<()>,
     alloc: &A,
@@ -499,6 +505,7 @@ where
 
 /// Allocates a chunk of reference-counted memory with a value that is copied from `value`.
 #[cfg(not(no_global_oom_handling))]
+#[inline]
 fn allocate_with_value_in<T, A, const STRONG_COUNT: usize>(src: &T, alloc: &A) -> NonNull<T>
 where
     T: ?Sized,

library/alloc/src/raw_rc/raw_rc.rs

@@ -32,6 +32,7 @@ use crate::vec::Vec;
 
 /// Decrements strong reference count in a reference-counted allocation with a value object that is
 /// pointed to by `value_ptr`.
+#[inline]
 unsafe fn decrement_strong_ref_count<R>(value_ptr: NonNull<()>) -> bool
 where
     R: RcOps,
@@ -41,13 +42,15 @@ where
 
 /// Increments strong reference count in a reference-counted allocation with a value object that is
 /// pointed to by `value_ptr`.
+#[inline]
 unsafe fn increment_strong_ref_count<R>(value_ptr: NonNull<()>)
 where
     R: RcOps,
 {
     unsafe { R::increment_ref_count(super::strong_count_ptr_from_value_ptr(value_ptr).as_ref()) }
 }
 
+#[inline]
 unsafe fn is_unique<R>(value_ptr: NonNull<()>) -> bool
 where
     R: RcOps,

library/alloc/src/raw_rc/raw_weak.rs

@@ -35,6 +35,7 @@ fn is_dangling(value_ptr: NonNull<()>) -> bool {
 
 /// Decrements weak reference count in a reference-counted allocation with a value object that is
 /// pointed to by `value_ptr`.
+#[inline]
 unsafe fn decrement_weak_ref_count<R>(value_ptr: NonNull<()>) -> bool
 where
     R: RcOps,
@@ -44,6 +45,7 @@ where
 
 /// Increments weak reference count in a reference-counted allocation with a value object that is
 /// pointed to by `value_ptr`.
+#[inline]
 unsafe fn increment_weak_ref_count<R>(value_ptr: NonNull<()>)
 where
     R: RcOps,