gpxe/src/arch/x86/include/bits/string.h - platform/external/syslinux - Git at Google

 #ifndef ETHERBOOT_BITS_STRING_H
 #define ETHERBOOT_BITS_STRING_H
 /*
  * 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).
  */

 /*
  * This string-include defines all string functions as inline
  * functions. Use gcc. It also assumes ds=es=data space, this should be
  * normal. Most of the string-functions are rather heavily hand-optimized,
  * see especially strtok,strstr,str[c]spn. They should work, but are not
  * very easy to understand. Everything is done entirely within the register
  * set, making the functions fast and clean. String instructions have been
  * used through-out, making for "slightly" unclear code :-)
  *
  *		NO Copyright (C) 1991, 1992 Linus Torvalds,
  *		consider these trivial functions to be PD.
  */

 FILE_LICENCE ( PUBLIC_DOMAIN );

 #define __HAVE_ARCH_MEMCPY

 extern void * __memcpy ( void *dest, const void *src, size_t len );

 #if 0
 static inline __attribute__ (( always_inline )) void *
 __memcpy ( void *dest, const void *src, size_t len ) {
 	int d0, d1, d2;
 	__asm__ __volatile__ ( "rep ; movsb"
 			       : "=&c" ( d0 ), "=&S" ( d1 ), "=&D" ( d2 )
 			       : "0" ( len ), "1" ( src ), "2" ( dest )
 			       : "memory" );
 	return dest;
 }
 #endif

 static inline __attribute__ (( always_inline )) void *
 __constant_memcpy ( void *dest, const void *src, size_t len ) {
 	union {
 		uint32_t u32[2];
 		uint16_t u16[4];
 		uint8_t  u8[8];
 	} __attribute__ (( __may_alias__ )) *dest_u = dest;
 	const union {
 		uint32_t u32[2];
 		uint16_t u16[4];
 		uint8_t  u8[8];
 	} __attribute__ (( __may_alias__ )) *src_u = src;
 	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 */
 		dest_u->u8[0]  = src_u->u8[0];
 		return dest;
 	case 2 : /* 6 bytes */
 		dest_u->u16[0] = src_u->u16[0];
 		return dest;
 	case 4 : /* 4 bytes */
 		dest_u->u32[0] = src_u->u32[0];
 		return dest;
 	/*
 	 * Double-register moves; these are probably still a win.
 	 *
 	 */
 	case 3 : /* 12 bytes */
 		dest_u->u16[0] = src_u->u16[0];
 		dest_u->u8[2]  = src_u->u8[2];
 		return dest;
 	case 5 : /* 10 bytes */
 		dest_u->u32[0] = src_u->u32[0];
 		dest_u->u8[4]  = src_u->u8[4];
 		return dest;
 	case 6 : /* 12 bytes */
 		dest_u->u32[0] = src_u->u32[0];
 		dest_u->u16[2] = src_u->u16[2];
 		return dest;
 	case 8 : /* 10 bytes */
 		dest_u->u32[0] = src_u->u32[0];
 		dest_u->u32[1] = src_u->u32[1];
 		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)
 {
 int d0, d1, d2;
 if (dest<src)
 __asm__ __volatile__(
 	"cld\n\t"
 	"rep\n\t"
 	"movsb"
 	: "=&c" (d0), "=&S" (d1), "=&D" (d2)
 	:"0" (n),"1" (src),"2" (dest)
 	: "memory");
 else
 __asm__ __volatile__(
 	"std\n\t"
 	"rep\n\t"
 	"movsb\n\t"
 	"cld"
 	: "=&c" (d0), "=&S" (d1), "=&D" (d2)
 	:"0" (n),
 	 "1" (n-1+(const char *)src),
 	 "2" (n-1+(char *)dest)
 	:"memory");
 return dest;
 }

 #define __HAVE_ARCH_MEMSET
 static inline void * memset(void *s, int c,size_t count)
 {
 int d0, d1;
 __asm__ __volatile__(
 	"cld\n\t"
 	"rep\n\t"
 	"stosb"
 	: "=&c" (d0), "=&D" (d1)
 	:"a" (c),"1" (s),"0" (count)
 	:"memory");
 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)
 {
 register int __res;
 int d0, d1, d2;
 __asm__ __volatile__(
 	"1:\tdecl %3\n\t"
 	"js 2f\n\t"
 	"lodsb\n\t"
 	"scasb\n\t"
 	"jne 3f\n\t"
 	"testb %%al,%%al\n\t"
 	"jne 1b\n"
 	"2:\txorl %%eax,%%eax\n\t"
 	"jmp 4f\n"
 	"3:\tsbbl %%eax,%%eax\n\t"
 	"orb $1,%%al\n"
 	"4:"
 		     :"=a" (__res), "=&S" (d0), "=&D" (d1), "=&c" (d2)
 		     :"1" (cs),"2" (ct),"3" (count));
 return __res;
 }

 #define __HAVE_ARCH_STRLEN
 static inline size_t strlen(const char * s)
 {
 int d0;
 register int __res;
 __asm__ __volatile__(
 	"repne\n\t"
 	"scasb\n\t"
 	"notl %0\n\t"
 	"decl %0"
 	:"=c" (__res), "=&D" (d0) :"1" (s),"a" (0), "0" (0xffffffff));
 return __res;
 }

 #endif /* ETHERBOOT_BITS_STRING_H */
	#ifndef ETHERBOOT_BITS_STRING_H
	#define ETHERBOOT_BITS_STRING_H
	/*
	* 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).
	*/

	/*
	* This string-include defines all string functions as inline
	* functions. Use gcc. It also assumes ds=es=data space, this should be
	* normal. Most of the string-functions are rather heavily hand-optimized,
	* see especially strtok,strstr,str[c]spn. They should work, but are not
	* very easy to understand. Everything is done entirely within the register
	* set, making the functions fast and clean. String instructions have been
	* used through-out, making for "slightly" unclear code :-)
	*
	* NO Copyright (C) 1991, 1992 Linus Torvalds,
	* consider these trivial functions to be PD.
	*/

	FILE_LICENCE ( PUBLIC_DOMAIN );

	#define __HAVE_ARCH_MEMCPY

	extern void * __memcpy ( void dest, const void src, size_t len );

	#if 0
	static inline __attribute__ (( always_inline )) void *
	__memcpy ( void dest, const void src, size_t len ) {
	int d0, d1, d2;
	__asm__ __volatile__ ( "rep ; movsb"
	: "=&c" ( d0 ), "=&S" ( d1 ), "=&D" ( d2 )
	: "0" ( len ), "1" ( src ), "2" ( dest )
	: "memory" );
	return dest;
	}
	#endif

	static inline __attribute__ (( always_inline )) void *
	__constant_memcpy ( void dest, const void src, size_t len ) {
	union {
	uint32_t u32[2];
	uint16_t u16[4];
	uint8_t u8[8];
	} __attribute__ (( __may_alias__ )) *dest_u = dest;
	const union {
	uint32_t u32[2];
	uint16_t u16[4];
	uint8_t u8[8];
	} __attribute__ (( __may_alias__ )) *src_u = src;
	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 */
	dest_u->u8[0] = src_u->u8[0];
	return dest;
	case 2 : /* 6 bytes */
	dest_u->u16[0] = src_u->u16[0];
	return dest;
	case 4 : /* 4 bytes */
	dest_u->u32[0] = src_u->u32[0];
	return dest;
	/*
	* Double-register moves; these are probably still a win.
	*
	*/
	case 3 : /* 12 bytes */
	dest_u->u16[0] = src_u->u16[0];
	dest_u->u8[2] = src_u->u8[2];
	return dest;
	case 5 : /* 10 bytes */
	dest_u->u32[0] = src_u->u32[0];
	dest_u->u8[4] = src_u->u8[4];
	return dest;
	case 6 : /* 12 bytes */
	dest_u->u32[0] = src_u->u32[0];
	dest_u->u16[2] = src_u->u16[2];
	return dest;
	case 8 : /* 10 bytes */
	dest_u->u32[0] = src_u->u32[0];
	dest_u->u32[1] = src_u->u32[1];
	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)
	{
	int d0, d1, d2;
	if (dest<src)
	__asm__ __volatile__(
	"cld\n\t"
	"rep\n\t"
	"movsb"
	: "=&c" (d0), "=&S" (d1), "=&D" (d2)
	:"0" (n),"1" (src),"2" (dest)
	: "memory");
	else
	__asm__ __volatile__(
	"std\n\t"
	"rep\n\t"
	"movsb\n\t"
	"cld"
	: "=&c" (d0), "=&S" (d1), "=&D" (d2)
	:"0" (n),
	"1" (n-1+(const char *)src),
	"2" (n-1+(char *)dest)
	:"memory");
	return dest;
	}

	#define __HAVE_ARCH_MEMSET
	static inline void * memset(void *s, int c,size_t count)
	{
	int d0, d1;
	__asm__ __volatile__(
	"cld\n\t"
	"rep\n\t"
	"stosb"
	: "=&c" (d0), "=&D" (d1)
	:"a" (c),"1" (s),"0" (count)
	:"memory");
	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)
	{
	register int __res;
	int d0, d1, d2;
	__asm__ __volatile__(
	"1:\tdecl %3\n\t"
	"js 2f\n\t"
	"lodsb\n\t"
	"scasb\n\t"
	"jne 3f\n\t"
	"testb %%al,%%al\n\t"
	"jne 1b\n"
	"2:\txorl %%eax,%%eax\n\t"
	"jmp 4f\n"
	"3:\tsbbl %%eax,%%eax\n\t"
	"orb $1,%%al\n"
	"4:"
	:"=a" (__res), "=&S" (d0), "=&D" (d1), "=&c" (d2)
	:"1" (cs),"2" (ct),"3" (count));
	return __res;
	}

	#define __HAVE_ARCH_STRLEN
	static inline size_t strlen(const char * s)
	{
	int d0;
	register int __res;
	__asm__ __volatile__(
	"repne\n\t"
	"scasb\n\t"
	"notl %0\n\t"
	"decl %0"
	:"=c" (__res), "=&D" (d0) :"1" (s),"a" (0), "0" (0xffffffff));
	return __res;
	}

	#endif /* ETHERBOOT_BITS_STRING_H */