Added __constant_memcpy() based on version in Linux's string.h.

Added memswap().

src/arch/i386/include/bits/string.h

@@ -3,6 +3,9 @@
 /*
  * Taken from Linux /usr/include/asm/string.h
  * All except memcpy, memmove, memset and memcmp removed.
+ *
+ * Non-standard memswap() function added because it saves quite a bit
+ * of code (mbrown@fensystems.co.uk).
  */
 
 /*
@@ -19,19 +22,122 @@
  */
 
 #define __HAVE_ARCH_MEMCPY
-static inline void * memcpy(void *dest, const void *src, size_t n)
+static inline __attribute__ (( always_inline )) void *
-{
+__memcpy ( void *dest, const void *src, size_t len ) {
-int d0, d1, d2;
+	int d0, d1, d2;
-__asm__ __volatile__ (
+	__asm__ __volatile__ ( "rep ; movsb"
-	"cld\n\t"
+			       : "=&c" ( d0 ), "=&S" ( d1 ), "=&D" ( d2 )
-	"rep\n\t"
+			       : "0" ( len ), "1" ( src ), "2" ( dest )
-	"movsb"
+			       : "memory" );
-	: "=&c" (d0), "=&S" (d1), "=&D" (d2)
+	return dest; 
-	:"0" (n), "1" (src), "2" (dest)
-	: "memory");
-return dest; 
 }
 
+static inline __attribute__ (( always_inline )) void *
+__constant_memcpy ( void *dest, const void *src, size_t len ) {
+	const void *esi;
+	void *edi;
+
+	switch ( len ) {
+	case 0 : /* 0 bytes */
+		return dest;
+	/*
+	 * Single-register moves; these are always better than a
+	 * string operation.  We can clobber an arbitrary two
+	 * registers (data, source, dest can re-use source register)
+	 * instead of being restricted to esi and edi.  There's also a
+	 * much greater potential for optimising with nearby code.
+	 *
+	 */
+	case 1 : /* 4 bytes */
+		* ( uint8_t  * ) ( dest + 0 ) = * ( uint8_t  * ) ( src + 0 );
+		return dest;
+	case 2 : /* 6 bytes */
+		* ( uint16_t * ) ( dest + 0 ) = * ( uint16_t * ) ( src + 0 );
+		return dest;
+	case 4 : /* 4 bytes */
+		* ( uint32_t * ) ( dest + 0 ) = * ( uint32_t * ) ( src + 0 );
+		return dest;
+	/*
+	 * Double-register moves; these are probably still a win.
+	 *
+	 */
+	case 3 : /* 12 bytes */
+		* ( uint16_t * ) ( dest + 0 ) = * ( uint16_t * ) ( src + 0 );
+		* ( uint8_t  * ) ( dest + 2 ) = * ( uint8_t  * ) ( src + 2 );
+		return dest;
+	case 5 : /* 10 bytes */
+		* ( uint32_t * ) ( dest + 0 ) = * ( uint32_t * ) ( src + 0 );
+		* ( uint8_t  * ) ( dest + 4 ) = * ( uint8_t  * ) ( src + 4 );
+		return dest;
+	case 6 : /* 12 bytes */
+		* ( uint32_t * ) ( dest + 0 ) = * ( uint32_t * ) ( src + 0 );
+		* ( uint16_t * ) ( dest + 4 ) = * ( uint16_t * ) ( src + 4 );
+		return dest;
+	case 8 : /* 10 bytes */
+		* ( uint32_t * ) ( dest + 0 ) = * ( uint32_t * ) ( src + 0 );
+		* ( uint32_t * ) ( dest + 4 ) = * ( uint32_t * ) ( src + 4 );
+		return dest;
+	}
+
+	/* Even if we have to load up esi and edi ready for a string
+	 * operation, we can sometimes save space by using multiple
+	 * single-byte "movs" operations instead of loading up ecx and
+	 * using "rep movsb".
+	 *
+	 * "load ecx, rep movsb" is 7 bytes, plus an average of 1 byte
+	 * to allow for saving/restoring ecx 50% of the time.
+	 *
+	 * "movsl" and "movsb" are 1 byte each, "movsw" is two bytes.
+	 * (In 16-bit mode, "movsl" is 2 bytes and "movsw" is 1 byte,
+	 * but "movsl" moves twice as much data, so it balances out).
+	 *
+	 * The cutoff point therefore occurs around 26 bytes; the byte
+	 * requirements for each method are:
+	 *
+	 * len		   16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
+	 * #bytes (ecx)	    8  8  8  8  8  8  8  8  8  8  8  8  8  8  8  8
+	 * #bytes (no ecx)  4  5  6  7  5  6  7  8  6  7  8  9  7  8  9 10
+	 */
+
+	esi = src;
+	edi = dest;
+	
+	if ( len >= 26 )
+		return __memcpy ( dest, src, len );
+	
+	if ( len >= 6*4 )
+		__asm__ __volatile__ ( "movsl" : "=&D" ( edi ), "=&S" ( esi )
+				       : "0" ( edi ), "1" ( esi ) : "memory" );
+	if ( len >= 5*4 )
+		__asm__ __volatile__ ( "movsl" : "=&D" ( edi ), "=&S" ( esi )
+				       : "0" ( edi ), "1" ( esi ) : "memory" );
+	if ( len >= 4*4 )
+		__asm__ __volatile__ ( "movsl" : "=&D" ( edi ), "=&S" ( esi )
+				       : "0" ( edi ), "1" ( esi ) : "memory" );
+	if ( len >= 3*4 )
+		__asm__ __volatile__ ( "movsl" : "=&D" ( edi ), "=&S" ( esi )
+				       : "0" ( edi ), "1" ( esi ) : "memory" );
+	if ( len >= 2*4 )
+		__asm__ __volatile__ ( "movsl" : "=&D" ( edi ), "=&S" ( esi )
+				       : "0" ( edi ), "1" ( esi ) : "memory" );
+	if ( len >= 1*4 )
+		__asm__ __volatile__ ( "movsl" : "=&D" ( edi ), "=&S" ( esi )
+				       : "0" ( edi ), "1" ( esi ) : "memory" );
+	if ( ( len % 4 ) >= 2 )
+		__asm__ __volatile__ ( "movsw" : "=&D" ( edi ), "=&S" ( esi )
+				       : "0" ( edi ), "1" ( esi ) : "memory" );
+	if ( ( len % 2 ) >= 1 )
+		__asm__ __volatile__ ( "movsb" : "=&D" ( edi ), "=&S" ( esi )
+				       : "0" ( edi ), "1" ( esi ) : "memory" );
+
+	return dest;
+}
+
+#define memcpy( dest, src, len )			\
+	( __builtin_constant_p ( (len) ) ?		\
+	  __constant_memcpy ( (dest), (src), (len) ) :	\
+	  __memcpy ( (dest), (src), (len) ) )
+
 #define __HAVE_ARCH_MEMMOVE
 static inline void * memmove(void * dest,const void * src, size_t n)
 {
@@ -59,7 +165,7 @@ return dest;
 }
 
 #define __HAVE_ARCH_MEMSET
-static inline void *memset(void *s, int c,size_t count)
+static inline void * memset(void *s, int c,size_t count)
 {
 int d0, d1;
 __asm__ __volatile__(
@@ -72,6 +178,23 @@ __asm__ __volatile__(
 return s;
 }
 
+#define __HAVE_ARCH_MEMSWAP
+static inline void * memswap(void *dest, void *src, size_t n)
+{
+int d0, d1, d2, d3;
+__asm__ __volatile__(
+	"\n1:\t"
+	"movb (%%edi),%%al\n\t"
+	"xchgb (%%esi),%%al\n\t"
+	"incl %%esi\n\t"
+	"stosb\n\t"
+	"loop 1b"
+	: "=&c" (d0), "=&S" (d1), "=&D" (d2), "=&a" (d3)
+	: "0" (n), "1" (src), "2" (dest)
+	: "memory" );
+return dest;
+}
+
 #define __HAVE_ARCH_STRNCMP
 static inline int strncmp(const char * cs,const char * ct,size_t count)
 {