From be64090489ad294ddc46e902b08c81c4c0d162b3 Mon Sep 17 00:00:00 2001
From: Arthur Carcano <arthur.carcano@ocamlpro.com>
Date: Thu, 13 Jul 2023 12:46:14 +0200
Subject: [PATCH 1/2] A more efficient slice comparison implementation for T:
 !BytewiseEq

The previous implementation was not optimized properly by the compiler,
which didn't leverage the fact that both length were equal.
---
 library/core/src/slice/cmp.rs | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

diff --git a/library/core/src/slice/cmp.rs b/library/core/src/slice/cmp.rs
index 7601dd3c75608..ac149d8012f22 100644
--- a/library/core/src/slice/cmp.rs
+++ b/library/core/src/slice/cmp.rs
@@ -70,7 +70,24 @@ where
             return false;
         }
 
-        self.iter().zip(other.iter()).all(|(x, y)| x == y)
+        let mut i = self.len();
+        let mut ptr_self = self.as_ptr();
+        let mut ptr_other = other.as_ptr();
+        // SAFETY:
+        // This is sound because:
+        // - self.len == other.len
+        // - self.len <= isize::MAX
+        // so the two pointers will not overflow,
+        // will remain in bounds of the slice,
+        // and dereferencing them is sound.
+        unsafe {
+            while (i > 0) && (*ptr_self == *ptr_other) {
+                i -= 1;
+                ptr_self = ptr_self.add(1);
+                ptr_other = ptr_other.add(1);
+            }
+        }
+        i == 0
     }
 }
 

From f5665525bb344c1ea76a3a2263bd2a762f3f6730 Mon Sep 17 00:00:00 2001
From: Arthur Carcano <arthur.carcano@ocamlpro.com>
Date: Thu, 13 Jul 2023 14:02:22 +0200
Subject: [PATCH 2/2] Do not use memcmp on musl

Musl implementation is equivalent to our general case implementation.
Not using it:
 - Allows for better optimization leveraging alignment information
 - Prevents a `call`
 - Likely favors inlining and further optimization
---
 library/core/src/slice/cmp.rs | 37 +++++++++++++++++++++--------------
 src/tools/tidy/src/pal.rs     |  1 +
 2 files changed, 23 insertions(+), 15 deletions(-)

diff --git a/library/core/src/slice/cmp.rs b/library/core/src/slice/cmp.rs
index ac149d8012f22..17d12f11aab2b 100644
--- a/library/core/src/slice/cmp.rs
+++ b/library/core/src/slice/cmp.rs
@@ -1,8 +1,7 @@
 //! Comparison traits for `[T]`.
 
-use crate::cmp::{self, BytewiseEq, Ordering};
+use crate::cmp::{self, Ordering};
 use crate::ffi;
-use crate::mem;
 
 use super::from_raw_parts;
 use super::memchr;
@@ -92,20 +91,28 @@ where
 }
 
 // Use memcmp for bytewise equality when the types allow
-impl<A, B> SlicePartialEq<B> for [A]
-where
-    A: BytewiseEq<B>,
-{
-    fn equal(&self, other: &[B]) -> bool {
-        if self.len() != other.len() {
-            return false;
-        }
+// and `memcmp` is not equivalent to our generic case
+#[cfg(not(target_env = "musl"))]
+mod bytewise_memcmp {
+    use super::{memcmp, SlicePartialEq};
+    use crate::cmp::BytewiseEq;
+    use crate::mem;
+
+    impl<A, B> SlicePartialEq<B> for [A]
+    where
+        A: BytewiseEq<B>,
+    {
+        fn equal(&self, other: &[B]) -> bool {
+            if self.len() != other.len() {
+                return false;
+            }
 
-        // SAFETY: `self` and `other` are references and are thus guaranteed to be valid.
-        // The two slices have been checked to have the same size above.
-        unsafe {
-            let size = mem::size_of_val(self);
-            memcmp(self.as_ptr() as *const u8, other.as_ptr() as *const u8, size) == 0
+            // SAFETY: `self` and `other` are references and are thus guaranteed to be valid.
+            // The two slices have been checked to have the same size above.
+            unsafe {
+                let size = mem::size_of_val(self);
+                memcmp(self.as_ptr() as *const u8, other.as_ptr() as *const u8, size) == 0
+            }
         }
     }
 }
diff --git a/src/tools/tidy/src/pal.rs b/src/tools/tidy/src/pal.rs
index b386b000beff8..c212309d846cb 100644
--- a/src/tools/tidy/src/pal.rs
+++ b/src/tools/tidy/src/pal.rs
@@ -55,6 +55,7 @@ const EXCEPTION_PATHS: &[&str] = &[
     "library/std/src/path.rs",
     "library/std/src/sys_common", // Should only contain abstractions over platforms
     "library/std/src/net/test.rs", // Utility helpers for tests
+    "library/core/src/slice/cmp.rs", // To comment better
 ];
 
 pub fn check(path: &Path, bad: &mut bool) {