Auto merge of #149146 - kotauskas:patch-1, r=<try>

Disable inlining of custom `io::Error` destructor

Author: bors

library/std/src/io/error/repr_bitpacked.rs

@@ -226,21 +226,53 @@ impl Repr {
 }
 
 impl Drop for Repr {
+    // What this will end up inlining into the destructor call site is merely a
+    // bitwise AND of the pointer with the constant TAG_MASK, a comparison to
+    // the constant TAG_CUSTOM, and a call to drop_custom that is jumped over
+    // if the tag isn't TAG_CUSTOM.
     #[inline]
     fn drop(&mut self) {
-        // Safety: We're a Repr, decode_repr is fine. The `Box::from_raw` is
-        // safe because we're being dropped.
+        // Inlining the destructor of a custom error does not confer any
+        // optimization opportunities, as it is type-erased. The cost,
+        // meanwhile, is a code size increase by a factor of up to 5.4 in the
+        // case of dropping multiple io::Results in the same function
+        // (https://godbolt.org/z/8hfGchjsT).
+        //
+        // FIXME the 32-bit variant still has the code bloat that is being
+        // avoided here, see the discussion in
+        // https://github.com/rust-lang/rust/pull/149146
+        #[inline(never)]
+        // The destructor of a custom error value is normally only called
+        // after it has been displayed or logged, or if it has been downcasted
+        // and handled appropriately. Displaying and logging errors is
+        // considered a cold path in most programs, and downcasting is
+        // similarly not something that is considered performance-critical.
+        // Thus, in the interest of happy path performance, have block
+        // placement get the calls to this function out of the way.
+        #[cold]
+        fn drop_custom(ptr: *mut Custom) {
+            unsafe {
+                // SAFETY: we're being dropped
+                let _ = Box::from_raw(ptr);
+            }
+        }
         unsafe {
-            let _ = decode_repr(self.0, |p| Box::<Custom>::from_raw(p));
+            // SAFETY: we're a Repr
+            let _ = decode_repr(self.0, drop_custom);
         }
     }
 }
 
-// Shared helper to decode a `Repr`'s internal pointer into an ErrorData.
-//
-// Safety: `ptr`'s bits should be encoded as described in the document at the
-// top (it should `some_repr.0`)
-#[inline]
+/// Shared helper to decode a [`Repr`]'s internal pointer into an [`ErrorData`].
+///
+/// # Safety
+/// `ptr`'s bits should be encoded as described in the document at the
+/// top (it should be `some_repr.0`).
+// Allow outlining only if that debug assert below is actually there. We
+// don't say inline(never) for the second case here because people sometimes
+// enable debug assertions in release builds.
+#[cfg_attr(not(debug_assertions), inline(always))]
+#[cfg_attr(debug_assertions, inline)]
 unsafe fn decode_repr<C, F>(ptr: NonNull<()>, make_custom: F) -> ErrorData<C>
 where
     F: FnOnce(*mut Custom) -> C,