[linux-2.6-block.git] / arch / microblaze / lib / memmove.c

/*
 * Copyright (C) 2008-2009 Michal Simek <monstr@monstr.eu>
 * Copyright (C) 2008-2009 PetaLogix
 * Copyright (C) 2007 John Williams
 *
 * Reasonably optimised generic C-code for memcpy on Microblaze
 * This is generic C code to do efficient, alignment-aware memmove.
 *
 * It is based on demo code originally Copyright 2001 by Intel Corp, taken from
 * http://www.embedded.com/showArticle.jhtml?articleID=19205567
 *
 * Attempts were made, unsuccessfully, to contact the original
 * author of this code (Michael Morrow, Intel).  Below is the original
 * copyright notice.
 *
 * This software has been developed by Intel Corporation.
 * Intel specifically disclaims all warranties, express or
 * implied, and all liability, including consequential and
 * other indirect damages, for the use of this program, including
 * liability for infringement of any proprietary rights,
 * and including the warranties of merchantability and fitness
 * for a particular purpose. Intel does not assume any
 * responsibility for and errors which may appear in this program
 * not any responsibility to update it.
 */

#include <linux/types.h>
#include <linux/stddef.h>
#include <linux/compiler.h>
#include <linux/module.h>
#include <linux/string.h>

#ifdef __HAVE_ARCH_MEMMOVE
void *memmove(void *v_dst, const void *v_src, __kernel_size_t c)
{
	const char *src = v_src;
	char *dst = v_dst;

#ifdef CONFIG_OPT_LIB_FUNCTION
	const uint32_t *i_src;
	uint32_t *i_dst;
#endif

	if (!c)
		return v_dst;

	/* Use memcpy when source is higher than dest */
	if (v_dst <= v_src)
		return memcpy(v_dst, v_src, c);

#ifndef CONFIG_OPT_LIB_FUNCTION
	/* copy backwards, from end to beginning */
	src += c;
	dst += c;

	/* Simple, byte oriented memmove. */
	while (c--)
		*--dst = *--src;

	return v_dst;
#else
	/* The following code tries to optimize the copy by using unsigned
	 * alignment. This will work fine if both source and destination are
	 * aligned on the same boundary. However, if they are aligned on
	 * different boundaries shifts will be necessary. This might result in
	 * bad performance on MicroBlaze systems without a barrel shifter.
	 */
	/* FIXME this part needs more test */
	/* Do a descending copy - this is a bit trickier! */
	dst += c;
	src += c;

	if (c >= 4) {
		unsigned  value, buf_hold;

		/* Align the destination to a word boundry. */
		/* This is done in an endian independant manner. */

		switch ((unsigned long)dst & 3) {
		case 3:
			*--dst = *--src;
			--c;
		case 2:
			*--dst = *--src;
			--c;
		case 1:
			*--dst = *--src;
			--c;
		}

		i_dst = (void *)dst;
		/* Choose a copy scheme based on the source */
		/* alignment relative to dstination. */
		switch ((unsigned long)src & 3) {
		case 0x0:	/* Both byte offsets are aligned */

			i_src  = (const void *)src;

			for (; c >= 4; c -= 4)
				*--i_dst = *--i_src;

			src  = (const void *)i_src;
			break;
		case 0x1:	/* Unaligned - Off by 1 */
			/* Word align the source */
			i_src = (const void *) (((unsigned)src + 4) & ~3);

			/* Load the holding buffer */
			buf_hold = *--i_src >> 24;

			for (; c >= 4; c -= 4) {
				value = *--i_src;
				*--i_dst = buf_hold << 8 | value;
				buf_hold = value >> 24;
			}

			/* Realign the source */
			src = (const void *)i_src;
			src += 1;
			break;
		case 0x2:	/* Unaligned - Off by 2 */
			/* Word align the source */
			i_src = (const void *) (((unsigned)src + 4) & ~3);

			/* Load the holding buffer */
			buf_hold = *--i_src >> 16;

			for (; c >= 4; c -= 4) {
				value = *--i_src;
				*--i_dst = buf_hold << 16 | value;
				buf_hold = value >> 16;
			}

			/* Realign the source */
			src = (const void *)i_src;
			src += 2;
			break;
		case 0x3:	/* Unaligned - Off by 3 */
			/* Word align the source */
			i_src = (const void *) (((unsigned)src + 4) & ~3);

			/* Load the holding buffer */
			buf_hold = *--i_src >> 8;

			for (; c >= 4; c -= 4) {
				value = *--i_src;
				*--i_dst = buf_hold << 24 | value;
				buf_hold = value >> 8;
			}

			/* Realign the source */
			src = (const void *)i_src;
			src += 3;
			break;
		}
		dst = (void *)i_dst;
	}

	/* simple fast copy, ... unless a cache boundry is crossed */
	/* Finish off any remaining bytes */
	switch (c) {
	case 4:
		*--dst = *--src;
	case 3:
		*--dst = *--src;
	case 2:
		*--dst = *--src;
	case 1:
		*--dst = *--src;
	}
	return v_dst;
#endif
}
EXPORT_SYMBOL(memmove);
#endif /* __HAVE_ARCH_MEMMOVE */
Commit	Line	Data
322ae8eb MS	1	/*
	2	* Copyright (C) 2008-2009 Michal Simek <monstr@monstr.eu>
	3	* Copyright (C) 2008-2009 PetaLogix
	4	* Copyright (C) 2007 John Williams
	5	*
	6	* Reasonably optimised generic C-code for memcpy on Microblaze
	7	* This is generic C code to do efficient, alignment-aware memmove.
	8	*
	9	* It is based on demo code originally Copyright 2001 by Intel Corp, taken from
	10	* http://www.embedded.com/showArticle.jhtml?articleID=19205567
	11	*
af901ca1	12	* Attempts were made, unsuccessfully, to contact the original
322ae8eb MS	13	* author of this code (Michael Morrow, Intel). Below is the original
	14	* copyright notice.
	15	*
	16	* This software has been developed by Intel Corporation.
	17	* Intel specifically disclaims all warranties, express or
	18	* implied, and all liability, including consequential and
	19	* other indirect damages, for the use of this program, including
	20	* liability for infringement of any proprietary rights,
	21	* and including the warranties of merchantability and fitness
	22	* for a particular purpose. Intel does not assume any
	23	* responsibility for and errors which may appear in this program
	24	* not any responsibility to update it.
	25	*/
	26
	27	#include <linux/types.h>
	28	#include <linux/stddef.h>
	29	#include <linux/compiler.h>
	30	#include <linux/module.h>
	31	#include <linux/string.h>
	32
	33	#ifdef __HAVE_ARCH_MEMMOVE
	34	void memmove(void v_dst, const void *v_src, __kernel_size_t c)
	35	{
	36	const char *src = v_src;
	37	char *dst = v_dst;
	38
	39	#ifdef CONFIG_OPT_LIB_FUNCTION
	40	const uint32_t *i_src;
	41	uint32_t *i_dst;
	42	#endif
	43
	44	if (!c)
	45	return v_dst;
	46
	47	/* Use memcpy when source is higher than dest */
	48	if (v_dst <= v_src)
	49	return memcpy(v_dst, v_src, c);
	50
	51	#ifndef CONFIG_OPT_LIB_FUNCTION
	52	/* copy backwards, from end to beginning */
	53	src += c;
	54	dst += c;
	55
	56	/* Simple, byte oriented memmove. */
	57	while (c--)
	58	--dst = --src;
	59
	60	return v_dst;
	61	#else
	62	/* The following code tries to optimize the copy by using unsigned
	63	* alignment. This will work fine if both source and destination are
	64	* aligned on the same boundary. However, if they are aligned on
	65	* different boundaries shifts will be necessary. This might result in
	66	* bad performance on MicroBlaze systems without a barrel shifter.
	67	*/
	68	/* FIXME this part needs more test */
	69	/* Do a descending copy - this is a bit trickier! */
	70	dst += c;
	71	src += c;
	72
	73	if (c >= 4) {
	74	unsigned value, buf_hold;
	75
	76	/* Align the destination to a word boundry. */
77	/* This is done in an endian independant manner. */
78
79	switch ((unsigned long)dst & 3) {
80	case 3:
81	--dst = --src;
82	--c;
83	case 2:
84	--dst = --src;
85	--c;
86	case 1:
87	--dst = --src;
88	--c;
89	}
90
91	i_dst = (void *)dst;
92	/* Choose a copy scheme based on the source */
93	/* alignment relative to dstination. */
94	switch ((unsigned long)src & 3) {
95	case 0x0: /* Both byte offsets are aligned */
96
97	i_src = (const void *)src;
98
99	for (; c >= 4; c -= 4)
100	--i_dst = --i_src;
101
102	src = (const void *)i_src;
103	break;
104	case 0x1: /* Unaligned - Off by 1 */
105	/* Word align the source */
106	i_src = (const void *) (((unsigned)src + 4) & ~3);
107
108	/* Load the holding buffer */
109	buf_hold = *--i_src >> 24;
110
111	for (; c >= 4; c -= 4) {
112	value = *--i_src;
113	*--i_dst = buf_hold << 8 \| value;
114	buf_hold = value >> 24;
115	}
116
117	/* Realign the source */
118	src = (const void *)i_src;
119	src += 1;
120	break;
121	case 0x2: /* Unaligned - Off by 2 */
122	/* Word align the source */
123	i_src = (const void *) (((unsigned)src + 4) & ~3);
124
125	/* Load the holding buffer */
126	buf_hold = *--i_src >> 16;
127
128	for (; c >= 4; c -= 4) {
129	value = *--i_src;
130	*--i_dst = buf_hold << 16 \| value;
131	buf_hold = value >> 16;
132	}
133
134	/* Realign the source */
135	src = (const void *)i_src;
136	src += 2;
137	break;
138	case 0x3: /* Unaligned - Off by 3 */
139	/* Word align the source */
140	i_src = (const void *) (((unsigned)src + 4) & ~3);
141
142	/* Load the holding buffer */
143	buf_hold = *--i_src >> 8;
144
145	for (; c >= 4; c -= 4) {
146	value = *--i_src;
147	*--i_dst = buf_hold << 24 \| value;
148	buf_hold = value >> 8;
149	}
150
151	/* Realign the source */
152	src = (const void *)i_src;
153	src += 3;
154	break;
155	}
156	dst = (void *)i_dst;
157	}
158
159	/* simple fast copy, ... unless a cache boundry is crossed */
160	/* Finish off any remaining bytes */
161	switch (c) {
162	case 4:
163	--dst = --src;
164	case 3:
165	--dst = --src;
166	case 2:
167	--dst = --src;
168	case 1:
169	--dst = --src;
170	}
171	return v_dst;
172	#endif
173	}
174	EXPORT_SYMBOL(memmove);
175	#endif /* __HAVE_ARCH_MEMMOVE */