Prepare dropping release-fast profile

Author: oech3

src/uucore/src/lib/mods/error.rs

@@ -407,56 +407,65 @@ impl Error for UIoError {}
 
 impl Display for UIoError {
     fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
-        use std::io::ErrorKind::*;
-
-        let message;
-        let message = if self.inner.raw_os_error().is_some() {
-            // These are errors that come directly from the OS.
-            // We want to normalize their messages across systems,
-            // and we want to strip the "(os error X)" suffix.
-            match self.inner.kind() {
-                NotFound => "No such file or directory",
-                PermissionDenied => "Permission denied",
-                ConnectionRefused => "Connection refused",
-                ConnectionReset => "Connection reset",
-                ConnectionAborted => "Connection aborted",
-                NotConnected => "Not connected",
-                AddrInUse => "Address in use",
-                AddrNotAvailable => "Address not available",
-                BrokenPipe => "Broken pipe",
-                AlreadyExists => "Already exists",
-                WouldBlock => "Would block",
-                InvalidInput => "Invalid input",
-                InvalidData => "Invalid data",
-                TimedOut => "Timed out",
-                WriteZero => "Write zero",
-                Interrupted => "Interrupted",
-                UnexpectedEof => "Unexpected end of file",
-                _ => {
-                    // TODO: When the new error variants
-                    // (https://github.com/rust-lang/rust/issues/86442)
-                    // are stabilized, we should add them to the match statement.
-                    message = strip_errno(&self.inner);
-                    &message
-                }
+        cold_io_error(f, &self.context, &self.inner)
+    }
+}
+
+#[cold] //for codegen-units=1
+#[inline(never)]
+fn cold_io_error(
+    f: &mut Formatter<'_>,
+    ctx: &Option<String>,
+    inner: &std::io::Error,
+) -> Result<(), std::fmt::Error> {
+    use std::io::ErrorKind::*;
+
+    let message_hold;
+    let message = if inner.raw_os_error().is_some() {
+        // These are errors that come directly from the OS.
+        // We want to normalize their messages across systems,
+        // and we want to strip the "(os error X)" suffix.
+        match inner.kind() {
+            NotFound => "No such file or directory",
+            PermissionDenied => "Permission denied",
+            ConnectionRefused => "Connection refused",
+            ConnectionReset => "Connection reset",
+            ConnectionAborted => "Connection aborted",
+            NotConnected => "Not connected",
+            AddrInUse => "Address in use",
+            AddrNotAvailable => "Address not available",
+            BrokenPipe => "Broken pipe",
+            AlreadyExists => "Already exists",
+            WouldBlock => "Would block",
+            InvalidInput => "Invalid input",
+            InvalidData => "Invalid data",
+            TimedOut => "Timed out",
+            WriteZero => "Write zero",
+            Interrupted => "Interrupted",
+            UnexpectedEof => "Unexpected end of file",
+            _ => {
+                // TODO: When the new error variants
+                // (https://github.com/rust-lang/rust/issues/86442)
+                // are stabilized, we should add them to the match statement.
+                message_hold = strip_errno(inner);
+                &message_hold
             }
-        } else {
-            // These messages don't need as much normalization, and the above
-            // messages wouldn't always be a good substitute.
-            // For example, ErrorKind::NotFound doesn't necessarily mean it was
-            // a file that was not found.
-            // There are also errors with entirely custom messages.
-            message = self.inner.to_string();
-            &message
-        };
-        if let Some(ctx) = &self.context {
-            write!(f, "{ctx}: {message}")
-        } else {
-            write!(f, "{message}")
         }
+    } else {
+        // These messages don't need as much normalization, and the above
+        // messages wouldn't always be a good substitute.
+        // For example, ErrorKind::NotFound doesn't necessarily mean it was
+        // a file that was not found.
+        // There are also errors with entirely custom messages.
+        message_hold = inner.to_string();
+        &message_hold
+    };
+    if let Some(c) = ctx {
+        write!(f, "{c}: {message}")
+    } else {
+        write!(f, "{message}")
     }
 }
-
 /// Strip the trailing " (os error XX)" from io error strings.
 pub fn strip_errno(err: &std::io::Error) -> String {
     let mut msg = err.to_string();