From 3be2c3b3092e934bdc2db67d5bdcabd611deca9c Mon Sep 17 00:00:00 2001
From: Ruud van Asseldonk <dev@veniogames.com>
Date: Sat, 12 Nov 2016 15:58:58 +0100
Subject: [PATCH] Move small-copy optimization into <&[u8] as Read>

Based on the discussion in https://github.com/rust-lang/rust/pull/37573,
it is likely better to keep this limited to std::io, instead of
modifying a function which users expect to be a memcpy.
---
 src/libcore/slice.rs   | 16 +++-------------
 src/libstd/io/impls.rs | 22 ++++++++++++++++++++--
 2 files changed, 23 insertions(+), 15 deletions(-)

diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs
index b238623eabaa7..a4a90e7a9da7a 100644
--- a/src/libcore/slice.rs
+++ b/src/libcore/slice.rs
@@ -515,19 +515,9 @@ impl<T> SliceExt for [T] {
     fn copy_from_slice(&mut self, src: &[T]) where T: Copy {
         assert!(self.len() == src.len(),
                 "destination and source slices have different lengths");
-        // First check if the amount of elements we want to copy is small:
-        // `copy_nonoverlapping` will do a memcopy, which involves an indirect
-        // function call when `memcpy` is in the dynamically-linked libc. For
-        // small elements (such as a single byte or pointer), the overhead is
-        // significant. If the element is big then the assignment is a memcopy
-        // anyway.
-        if self.len() == 1 {
-            self[0] = src[0];
-        } else {
-            unsafe {
-                ptr::copy_nonoverlapping(
-                    src.as_ptr(), self.as_mut_ptr(), self.len());
-            }
+        unsafe {
+            ptr::copy_nonoverlapping(
+                src.as_ptr(), self.as_mut_ptr(), self.len());
         }
     }
 
diff --git a/src/libstd/io/impls.rs b/src/libstd/io/impls.rs
index 6b26c016638a7..f691289811bc6 100644
--- a/src/libstd/io/impls.rs
+++ b/src/libstd/io/impls.rs
@@ -157,7 +157,16 @@ impl<'a> Read for &'a [u8] {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         let amt = cmp::min(buf.len(), self.len());
         let (a, b) = self.split_at(amt);
-        buf[..amt].copy_from_slice(a);
+
+        // First check if the amount of bytes we want to read is small:
+        // `copy_from_slice` will generally expand to a call to `memcpy`, and
+        // for a single byte the overhead is significant.
+        if amt == 1 {
+            buf[0] = a[0];
+        } else {
+            buf[..amt].copy_from_slice(a);
+        }
+
         *self = b;
         Ok(amt)
     }
@@ -169,7 +178,16 @@ impl<'a> Read for &'a [u8] {
                                   "failed to fill whole buffer"));
         }
         let (a, b) = self.split_at(buf.len());
-        buf.copy_from_slice(a);
+
+        // First check if the amount of bytes we want to read is small:
+        // `copy_from_slice` will generally expand to a call to `memcpy`, and
+        // for a single byte the overhead is significant.
+        if buf.len() == 1 {
+            buf[0] = a[0];
+        } else {
+            buf.copy_from_slice(a);
+        }
+
         *self = b;
         Ok(())
     }