WebSVN – HelenOS – Diff – //branches/sparc/kernel/generic/src/lib/memstr.c



 
/**
 * @file
 * @brief   Memory string operations.
 *
 * This file provides architecture independent functions to manipulate blocks of
 
 * memory. These functions are optimized as much as generic functions of this
 * type can be. However, architectures are free to provide even more optimized
 
 * versions of these functions.
 */
 
#include <memstr.h>
#include <arch/types.h>
#include <align.h>
 
/** Copy block of memory.
 *
 * Copy cnt bytes from src address to dst address.  The copying is done
 * word-by-word and then byte-by-byte.  The source and destination memory areas
 * cannot overlap.
 *
 * @param src       Source address to copy from.
 * @param dst       Destination address to copy to.
 * @param cnt       Number of bytes to copy.
 *
 * @return      Destination address.
 */
void *_memcpy(void *dst, const void *src, size_t cnt)
{
    unsigned int i, j;
   
    if (ALIGN_UP((uintptr_t) src, sizeof(unative_t)) != (uintptr_t) src ||
        ALIGN_UP((uintptr_t) dst, sizeof(unative_t)) != (uintptr_t) dst) {
        for (i = 0; i < cnt; i++)
            ((uint8_t *) dst)[i] = ((uint8_t *) src)[i];
    } else {
 
        for (i = 0; i < cnt / sizeof(unative_t); i++)
            ((unative_t *) dst)[i] = ((unative_t *) src)[i];
       
        for (j = 0; j < cnt % sizeof(unative_t); j++)
            ((uint8_t *)(((unative_t *) dst) + i))[j] =
                ((uint8_t *)(((unative_t *) src) + i))[j];
    }
       
    return (char *) dst;
}
 
/** Fill block of memory
 *
 * Fill cnt bytes at dst address with the value x.  The filling is done
 * byte-by-byte.
 *
 * @param dst       Destination address to fill.
 * @param cnt       Number of bytes to fill.
 * @param x     Value to fill.
 *
 */
void _memsetb(void *dst, size_t cnt, uint8_t x)
{
    unsigned int i;

   
    for (i = 0; i < cnt; i++)
        p[i] = x;
}
 
/** Fill block of memory.
 *
 * Fill cnt words at dst address with the value x.  The filling is done
 * word-by-word.
 *
 * @param dst       Destination address to fill.
 * @param cnt       Number of words to fill.
 * @param x     Value to fill.
 *
 */
void _memsetw(void *dst, size_t cnt, uint16_t x)
{
    unsigned int i;

   
    for (i = 0; i < cnt; i++)
        p[i] = x;  
}
 
/** Copy string.
 *
 * Copy string from src address to dst address.  The copying is done
 
 * char-by-char until the null character. The source and destination memory
 * areas cannot overlap.
 *
 * @param src       Source string to copy from.
 * @param dst       Destination string to copy to.
 *
 * @return      Address of the destination string.
 */
char *strcpy(char *dest, const char *src)
{
    char *orig = dest;
   

Rev 3343	Rev 3492
Line 32...	Line 32...
32		32
33	/**	33	/**
34	* @file	34	* @file
35	* @brief Memory string operations.	35	* @brief Memory string operations.
36	*	36	*
37	* This file provides architecture independent functions	37	* This file provides architecture independent functions to manipulate blocks of
38	* to manipulate blocks of memory. These functions	-
39	* are optimized as much as generic functions of	38	* memory. These functions are optimized as much as generic functions of this
40	* this type can be. However, architectures are	39	* type can be. However, architectures are free to provide even more optimized
41	* free to provide even more optimized versions of these	-
42	* functions.	40	* versions of these functions.
43	*/	41	*/
44		42
45	#include <memstr.h>	43	#include <memstr.h>
46	#include <arch/types.h>	44	#include <arch/types.h>
47	#include <align.h>	45	#include <align.h>
48		46
49	/** Copy block of memory	47	/** Copy block of memory.
50	*	48	*
51	* Copy cnt bytes from src address to dst address.	49	* Copy cnt bytes from src address to dst address. The copying is done
52	* The copying is done word-by-word and then byte-by-byte.	50	* word-by-word and then byte-by-byte. The source and destination memory areas
53	* The source and destination memory areas cannot overlap.	51	* cannot overlap.
54	*	52	*
55	* @param src Origin address to copy from.	53	* @param src Source address to copy from.
56	* @param dst Origin address to copy to.	54	* @param dst Destination address to copy to.
57	* @param cnt Number of bytes to copy.	55	* @param cnt Number of bytes to copy.
58	*	56	*
-		57	* @return Destination address.
59	*/	58	*/
60	void _memcpy(void dst, const void *src, size_t cnt)	59	void _memcpy(void dst, const void *src, size_t cnt)
61	{	60	{
62	unsigned int i, j;	61	unsigned int i, j;
63		62
64	if (ALIGN_UP((uintptr_t) src, sizeof(unative_t)) != (uintptr_t) src \|\|	63	if (ALIGN_UP((uintptr_t) src, sizeof(unative_t)) != (uintptr_t) src \|\|
65	ALIGN_UP((uintptr_t) dst, sizeof(unative_t)) != (uintptr_t) dst) {	64	ALIGN_UP((uintptr_t) dst, sizeof(unative_t)) != (uintptr_t) dst) {
66	for (i = 0; i < cnt; i++)	65	for (i = 0; i < cnt; i++)
67	((uint8_t ) dst)[i] = ((uint8_t ) src)[i];	66	((uint8_t ) dst)[i] = ((uint8_t ) src)[i];
68	} else {	67	} else {
69		-
70	for (i = 0; i < cnt / sizeof(unative_t); i++)	68	for (i = 0; i < cnt / sizeof(unative_t); i++)
71	((unative_t ) dst)[i] = ((unative_t ) src)[i];	69	((unative_t ) dst)[i] = ((unative_t ) src)[i];
72		70
73	for (j = 0; j < cnt % sizeof(unative_t); j++)	71	for (j = 0; j < cnt % sizeof(unative_t); j++)
-		72	((uint8_t )(((unative_t ) dst) + i))[j] =
74	((uint8_t )(((unative_t ) dst) + i))[j] = ((uint8_t )(((unative_t ) src) + i))[j];	73	((uint8_t )(((unative_t ) src) + i))[j];
75	}	74	}
76		75
77	return (char *) dst;	76	return (char *) dst;
78	}	77	}
79		78
80	/** Fill block of memory	79	/** Fill block of memory
81	*	80	*
82	* Fill cnt bytes at dst address with the value x.	81	* Fill cnt bytes at dst address with the value x. The filling is done
83	* The filling is done byte-by-byte.	82	* byte-by-byte.
84	*	83	*
85	* @param dst Origin address to fill.	84	* @param dst Destination address to fill.
86	* @param cnt Number of bytes to fill.	85	* @param cnt Number of bytes to fill.
87	* @param x Value to fill.	86	* @param x Value to fill.
88	*	87	*
89	*/	88	*/
90	void _memsetb(void *dst, size_t cnt, uint8_t x)	89	void _memsetb(void *dst, size_t cnt, uint8_t x)
91	{	90	{
92	unsigned int i;	91	unsigned int i;
Line 94...	Line 93...
94		93
95	for (i = 0; i < cnt; i++)	94	for (i = 0; i < cnt; i++)
96	p[i] = x;	95	p[i] = x;
97	}	96	}
98		97
99	/** Fill block of memory	98	/** Fill block of memory.
100	*	99	*
101	* Fill cnt words at dst address with the value x.	100	* Fill cnt words at dst address with the value x. The filling is done
102	* The filling is done word-by-word.	101	* word-by-word.
103	*	102	*
104	* @param dst Origin address to fill.	103	* @param dst Destination address to fill.
105	* @param cnt Number of words to fill.	104	* @param cnt Number of words to fill.
106	* @param x Value to fill.	105	* @param x Value to fill.
107	*	106	*
108	*/	107	*/
109	void _memsetw(void *dst, size_t cnt, uint16_t x)	108	void _memsetw(void *dst, size_t cnt, uint16_t x)
110	{	109	{
111	unsigned int i;	110	unsigned int i;
Line 113...	Line 112...
113		112
114	for (i = 0; i < cnt; i++)	113	for (i = 0; i < cnt; i++)
115	p[i] = x;	114	p[i] = x;
116	}	115	}
117		116
118	/** Copy string	117	/** Copy string.
119	*	118	*
120	* Copy string from src address to dst address.	119	* Copy string from src address to dst address. The copying is done
121	* The copying is done char-by-char until the null	-
122	* character. The source and destination memory areas	120	* char-by-char until the null character. The source and destination memory
123	* cannot overlap.	121	* areas cannot overlap.
124	*	122	*
125	* @param src Origin string to copy from.	123	* @param src Source string to copy from.
126	* @param dst Origin string to copy to.	124	* @param dst Destination string to copy to.
127	*	125	*
-		126	* @return Address of the destination string.
128	*/	127	*/
129	char strcpy(char dest, const char *src)	128	char strcpy(char dest, const char *src)
130	{	129	{
131	char *orig = dest;	130	char *orig = dest;
132		131

Subversion Repositories HelenOS

(root)//branches/sparc/kernel/generic/src/lib/memstr.c – Rev 3343 → 3492