OSDev.org

Code: Select all

char *memcpy(char *from, char *to, unsigned int n)
{
	if(cpu.sse2)
	{
		int i;
		for(i=0; i<n/16; i++)
		{
			__asm__ __volatile__("movntdq (%0), %%xmm0\n" "movntdq %%xmm0, (%1)\n"::"r"(from), "r"(to):"memory");

			from += 16;
			to += 16;
		}
		if(n & 7)
		{
			n = n&7;
			while(n--)
				*to++ = *from++;
		}
		return (to);
	}
	if(cpu.sse)
	{
		int i;
		for(i=0; i<n/16; i++)
		{
			__asm__ __volatile__("movntq (%0), %%xmm0\n" "movntq %%xmm0, (%1)\n"::"r"(from), "r"(to):"memory");

			from += 16;
			to += 16;
		}
		if(n & 7)
		{
			n = n&7;
			while(n--)
				*to++ = *from++;
		}
		return (to);
	}
	if(cpu.mmx)
	{
		int i;
		for(i=0; i<n/8; i++)
		{
			__asm__ __volatile__("movq (%0), %%mm0\n" "movq %%mm0, (%1)\n"::"r"(from), "r"(to):"memory");

			from += 8;
			to += 8;
		}
		if(n & 7)
		{
			n = n&7;
			while(n--)
				*to++ = *from++;
		}
		return (to);
	}

	while(n--)
		*to++ = *from++;

	return (to);
}

Code: Select all

mov dword[C0000000h], RGBA

Code: Select all

mov byte[C0000000h], A
mov byte[C0000001h], G
mov byte[C0000002h], B
mov byte[C0000003h], R

Code: Select all

#include <string.h>
#include <assert.h>
#include <stdint.h>

/* quick and dirty macro that tests if a pointer is properly aligned to it's
 * native boundary, we need this because some arches don't like multibyte
 * accesses to cross a page boundary
 */
#define IS_ALIGNED(x) (((uintptr_t)(x) & (sizeof(*(x)) - 1)) == 0)

/* valid options here are, 1, 2, 4 and 8 */
#define MAX_MULTIBYTE 4

/*------------------------------------------------------------------------------
// Name: memcpy(void *dest, const void *src, size_t n
//----------------------------------------------------------------------------*/
void *memcpy(void *_RESTRICT dest, const void *_RESTRICT src, size_t n) {

#if 0
	/* traditional memory copy */
	assert(dest != 0);
	assert(src != 0);

	char *d_ptr			= dest;
	const char *s_ptr	= src;
	
	while(n--) {
		*d_ptr++ = *s_ptr++;
	}
#else

	/* this one is optimized for dword and word aligned copies */
	union {
		void		*ptr;
#if MAX_MULTIBYTE >= 8
		uint64_t	*ptr64;
#endif
#if MAX_MULTIBYTE >= 4
		uint32_t	*ptr32;
#endif
#if MAX_MULTIBYTE >= 2
		uint16_t	*ptr16;
#endif
		uint8_t		*ptr8;	
	} d_ptr;
		
	union {
		const void		*ptr;
#if MAX_MULTIBYTE >= 8
		const uint64_t	*ptr64;
#endif
#if MAX_MULTIBYTE >= 4
		const uint32_t	*ptr32;
#endif
#if MAX_MULTIBYTE >= 2
		const uint16_t	*ptr16;
#endif
		const uint8_t	*ptr8;	
	} s_ptr;
	
	assert(dest != 0);
	assert(src != 0);

	d_ptr.ptr = dest;
	s_ptr.ptr = src;
	
	switch(n & (MAX_MULTIBYTE - 1)) {
	case 0:
#if MAX_MULTIBYTE >= 2
#if MAX_MULTIBYTE >= 4
#if MAX_MULTIBYTE >= 8
		if(!IS_ALIGNED(d_ptr.ptr64) || !IS_ALIGNED(s_ptr.ptr64)) {
			goto unaligned;
		}
	
		/* multiple of 8 */
		n /= 8;
		while(n--) {
			*(d_ptr.ptr64)++ = *(s_ptr.ptr64)++;
		}
		break;
	case 4:
#endif
		if(!IS_ALIGNED(d_ptr.ptr32) || !IS_ALIGNED(s_ptr.ptr32)) {
			goto unaligned;
		}
	
		/* multiple of 4 */
		n /= 4;
		while(n--) {
			*(d_ptr.ptr32)++ = *(s_ptr.ptr32)++;
		}
		break;
	case 6:
	case 2:
#endif
		if(!IS_ALIGNED(d_ptr.ptr16) || !IS_ALIGNED(s_ptr.ptr16)) {
			goto unaligned;
		}
	
		/* multiple of 2 */	
		n /= 2;		
		while(n--) {
			*(d_ptr.ptr16)++ = *(s_ptr.ptr16)++;
		}
		break;
	unaligned:
	default:
#endif
		/* multiple of 1 */
		while(n--) {
			*(d_ptr.ptr8)++ = *(s_ptr.ptr8)++;
		}
	}
#endif
	return dest;
}

#undef IS_ALIGNED
#undef MAX_MULTIBYTE

Code: Select all

#include <string.h>
#include <assert.h>
#include <stdint.h>

/* quick and dirty macro that tests if a pointer is properly aligned to it's
 * native boundary, we need this because some arches don't like multibyte
 * accesses to cross a page boundary
 */
#define IS_ALIGNED(x) (((uintptr_t)(x) & (sizeof(*(x)) - 1)) == 0)

/* valid options here are, 1, 2, 4 and 8 */
#define MAX_MULTIBYTE 4

/*------------------------------------------------------------------------------
// Name: memset(void *s, int c, size_t n)
//----------------------------------------------------------------------------*/
void *memset(void *s, int c, size_t n) {

#if 0
	/* traditional memset */
	char *s_ptr = s;
	const char ch = (char)(c & 0xff);
	
	assert(s != 0);
	
	while(n--) {
		*s_ptr++ = ch;
	}

#else
	/* this one is optimized for dword and word aligned copies */
	union {
		void		*ptr;
#if MAX_MULTIBYTE >= 8
		uint64_t	*ptr64;
#endif
#if MAX_MULTIBYTE >= 4
		uint32_t	*ptr32;
#endif
#if MAX_MULTIBYTE >= 2
		uint16_t	*ptr16;
#endif
		uint8_t		*ptr8;	
	} d_ptr;
	
	const char ch = (char)(c & 0xff);
		
	assert(s != 0);

	d_ptr.ptr = s;
	
	switch(n & (MAX_MULTIBYTE - 1)) {
	case 0:
#if MAX_MULTIBYTE >= 2
#if MAX_MULTIBYTE >= 4
#if MAX_MULTIBYTE >= 8
		if(!IS_ALIGNED(d_ptr.ptr64)) {
			goto unaligned;
		}
	
		/* multiple of 8 */
		do {
			const uint64_t source = ch * UINT64_C(0x0101010101010101);
			n /= 8;
			while(n--) {
				*(d_ptr.ptr64)++ = source;
			}
		} while(0);
		break;
	case 4:
#endif
		if(!IS_ALIGNED(d_ptr.ptr32)) {
			goto unaligned;
		}
	
		/* multiple of 4 */
		do {
			const uint32_t source = ch * UINT32_C(0x01010101);
			n /= 4;
			while(n--) {
				*(d_ptr.ptr32)++ = source;
			}
		} while(0);
		break;
	case 6:
	case 2:
#endif
		if(!IS_ALIGNED(d_ptr.ptr16)) {
			goto unaligned;
		}
	
		/* multiple of 2 */	
		do {
			const uint16_t source = ch * UINT16_C(0x0101);
			n /= 2;
			while(n--) {
				*(d_ptr.ptr16)++ = source;
			}
		} while(0);
		break;
	unaligned:
	default:
#endif
		/* multiple of 1 */
		while(n--) {
			*(d_ptr.ptr8)++ = ch;
		}
	}
#endif
	return s;
}