Merge #57

57: LLVM can have little a #[inline] as a treat r=CAD97 a=CAD97



Co-authored-by: CAD97 <[email protected]>

Author: bors[bot]

crates/erasable/src/lib.rs

@@ -195,6 +195,7 @@ pub unsafe trait Erasable {
     /// Turn this erasable pointer into an erased pointer.
     ///
     /// To retrieve the original pointer, use `unerase`.
+    #[inline(always)]
     fn erase(this: ptr::NonNull<Self>) -> ErasedPtr {
         erase(this)
     }
@@ -266,6 +267,7 @@ pub unsafe trait Erasable {
 }
 
 /// Erase a pointer.
+#[inline(always)]
 pub fn erase<T: ?Sized>(ptr: ptr::NonNull<T>) -> ErasedPtr {
     unsafe { ptr::NonNull::new_unchecked(ptr.as_ptr() as *mut Erased) }
 }
@@ -298,6 +300,7 @@ unsafe impl<P: ErasablePtr> Send for Thin<P> where P: Send {}
 unsafe impl<P: ErasablePtr> Sync for Thin<P> where P: Sync {}
 
 impl<P: ErasablePtr> From<P> for Thin<P> {
+    #[inline(always)]
     fn from(this: P) -> Self {
         Thin::<P> {
             ptr: P::erase(this),
@@ -698,11 +701,13 @@ macro_rules! impl_erasable {
         where
             T: Erasable,
         {
+            #[inline]
             fn erase(this: Self) -> ErasedPtr {
                 let ptr = unsafe { ptr::NonNull::new_unchecked(<$ty>::into_raw(this) as *mut _) };
                 T::erase(ptr)
             }
 
+            #[inline]
             unsafe fn unerase(this: ErasedPtr) -> Self {
                 Self::from_raw(T::unerase(this).as_ptr())
             }
@@ -723,10 +728,12 @@ impl_erasable!(for<T>
 
 #[cfg(has_never)]
 unsafe impl ErasablePtr for ! {
+    #[inline(always)]
     fn erase(this: !) -> ErasedPtr {
         this
     }
     #[rustfmt::skip]
+    #[inline(always)]
     unsafe fn unerase(_this: ErasedPtr) -> Self {
         #[cfg(debug_assertions)] {
             panic!("attempted to unerase erased pointer to !")
@@ -737,10 +744,12 @@ unsafe impl ErasablePtr for ! {
     }
 }
 
+#[inline(always)]
 unsafe fn erase_lt<'a, 'b, T: ?Sized>(this: &'a T) -> &'b T {
     &*(this as *const T)
 }
 
+#[inline(always)]
 unsafe fn erase_lt_mut<'a, 'b, T: ?Sized>(this: &'a mut T) -> &'b mut T {
     &mut *(this as *mut T)
 }

crates/ptr-union/src/lib.rs

@@ -24,20 +24,22 @@ const TAG_B: usize = 0b01;
 const TAG_C: usize = 0b10;
 const TAG_D: usize = 0b11;
 
+#[inline(always)]
 fn check_tag(ptr: ErasedPtr, mask: usize, tag: usize) -> bool {
     debug_assert_eq!(tag & mask, tag);
     (ptr.as_ptr() as usize & mask) == tag
 }
 
+#[inline(always)]
 fn set_tag(ptr: ErasedPtr, mask: usize, tag: usize) -> ErasedPtr {
     debug_assert_eq!(tag & mask, tag);
     debug_assert!(check_tag(ptr, mask, 0));
-    let high = ptr.as_ptr() as usize & !mask;
-    let low = tag & mask;
-    unsafe { ErasedPtr::new_unchecked((high | low) as *mut _) }
+    unsafe { ErasedPtr::new_unchecked((ptr.as_ptr() as usize | tag) as *mut _) }
 }
 
+#[inline(always)]
 fn unset_tag(ptr: ErasedPtr, mask: usize, tag: usize) -> ErasedPtr {
+    debug_assert_eq!(tag & mask, tag);
     debug_assert!(check_tag(ptr, mask, tag));
     unsafe { ErasedPtr::new_unchecked((ptr.as_ptr() as usize & !mask) as *mut _) }
 }
@@ -52,9 +54,11 @@ mod never_ptr {
     #[derive(Debug, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
     pub enum NeverPtr {}
     unsafe impl ErasablePtr for NeverPtr {
+        #[inline]
         fn erase(this: Self) -> ErasedPtr {
             match this {}
         }
+        #[inline]
         unsafe fn unerase(_this: ErasedPtr) -> Self {
             unreachable!()
         }

crates/rc-borrow/src/lib.rs

@@ -65,6 +65,7 @@ trait RawRc<T: ?Sized> {
 
 impl<T: ?Sized> RawRc<T> for Arc<T> {
     #[rustfmt::skip]
+    #[inline(always)]
     fn as_raw(this: &Self) -> *const T {
         #[cfg(not(has_Arc__as_raw))] {
             Arc::into_raw(unsafe { ptr::read(this) })
@@ -75,6 +76,7 @@ impl<T: ?Sized> RawRc<T> for Arc<T> {
     }
 
     #[rustfmt::skip]
+    #[inline(always)]
     unsafe fn clone_raw(this: *const T) -> Self {
         #[cfg(not(has_Arc__clone_raw))] {
             Arc::clone(&ManuallyDrop::new(Arc::from_raw(this)))
@@ -87,6 +89,7 @@ impl<T: ?Sized> RawRc<T> for Arc<T> {
 
 impl<T: ?Sized> RawRc<T> for Rc<T> {
     #[rustfmt::skip]
+    #[inline(always)]
     fn as_raw(this: &Self) -> *const T {
         #[cfg(not(has_Rc__as_raw))] {
             Rc::into_raw(unsafe { ptr::read(this) })
@@ -97,6 +100,7 @@ impl<T: ?Sized> RawRc<T> for Rc<T> {
     }
 
     #[rustfmt::skip]
+    #[inline(always)]
     unsafe fn clone_raw(this: *const T) -> Self {
         #[cfg(not(has_Rc__clone_raw))] {
             Rc::clone(&ManuallyDrop::new(Rc::from_raw(this)))
@@ -181,10 +185,12 @@ between the two types, and the types must be transmute-compatible."),
         where
             T: Erasable
         {
+            #[inline(always)]
             fn erase(this: Self) -> ErasedPtr {
                 T::erase(this.raw)
             }
 
+            #[inline(always)]
             unsafe fn unerase(this: ErasedPtr) -> Self {
                 $RcBorrow {
                     raw: T::unerase(this),

crates/rc-box/src/lib.rs

@@ -123,6 +123,7 @@ print_if_string(my_number.try_into().unwrap());
 
 The unsizing as `", stringify!($Rc), "` is required until
 [DST coercions](https://github.com/rust-lang/rust/issues/27732) are stabilized."),
+                #[inline]
                 pub fn downcast<T>(self) -> Result<$RcBox<T>, Self>
                 where T: Any,
                 {
@@ -164,6 +165,7 @@ print_if_string(my_number.try_into().unwrap());
 
 The unsizing as `", stringify!($Rc), "` is required until
 [DST coercions](https://github.com/rust-lang/rust/issues/27732) are stabilized."),
+                #[inline]
                 pub fn downcast<T>(self) -> Result<$RcBox<T>, Self>
                 where T: Any + Send
                 {
@@ -205,6 +207,7 @@ print_if_string(my_number.try_into().unwrap());
 
 The unsizing as `", stringify!($Rc), "` is required until
 [DST coercions](https://github.com/rust-lang/rust/issues/27732) are stabilized."),
+                #[inline]
                 pub fn downcast<T>(self) -> Result<$RcBox<T>, Self>
                 where T: Any + Send + Sync
                 {

crates/slice-dst/src/layout_polyfill.rs

@@ -3,6 +3,7 @@ use core::{
     cmp,
 };
 
+#[inline]
 pub(crate) fn extend_layout(this: &Layout, next: Layout) -> Result<(Layout, usize), LayoutErr> {
     let new_align = cmp::max(this.align(), next.align());
     let pad = layout_padding_needed_for(&this, next.align());
@@ -12,16 +13,19 @@ pub(crate) fn extend_layout(this: &Layout, next: Layout) -> Result<(Layout, usiz
     Ok((layout, offset))
 }
 
+#[inline]
 pub(crate) fn pad_layout_to_align(this: &Layout) -> Layout {
     let pad = layout_padding_needed_for(this, this.align());
     let new_size = this.size() + pad;
     unsafe { Layout::from_size_align_unchecked(new_size, this.align()) }
 }
 
+#[inline]
 pub(crate) fn layout_array<T>(n: usize) -> Result<Layout, LayoutErr> {
     repeat_layout(&Layout::new::<T>(), n).map(|(k, _)| k)
 }
 
+#[inline]
 pub(crate) fn repr_c_3(fields: [Layout; 3]) -> Result<(Layout, [usize; 3]), LayoutErr> {
     let mut offsets: [usize; 3] = [0; 3];
     let mut layout = fields[0];
@@ -33,12 +37,14 @@ pub(crate) fn repr_c_3(fields: [Layout; 3]) -> Result<(Layout, [usize; 3]), Layo
     Ok((pad_layout_to_align(&layout), offsets))
 }
 
+#[inline]
 fn layout_padding_needed_for(this: &Layout, align: usize) -> usize {
     let len = this.size();
     let len_rounded_up = len.wrapping_add(align).wrapping_sub(1) & !align.wrapping_sub(1);
     len_rounded_up.wrapping_sub(len)
 }
 
+#[inline]
 fn repeat_layout(this: &Layout, n: usize) -> Result<(Layout, usize), LayoutErr> {
     let padded_size = pad_layout_to_align(this).size();
     let alloc_size = padded_size.checked_mul(n).ok_or_else(layout_err)?;
@@ -50,6 +56,7 @@ fn repeat_layout(this: &Layout, n: usize) -> Result<(Layout, usize), LayoutErr>
     }
 }
 
+#[inline]
 fn layout_err() -> LayoutErr {
     Layout::from_size_align(0, 0).unwrap_err()
 }