diff options
author | Thomas Martitz <kugel@rockbox.org> | 2012-01-07 19:56:09 +0100 |
---|---|---|
committer | Thomas Martitz <kugel@rockbox.org> | 2012-01-22 18:46:45 +0100 |
commit | a035261089403de259e74ce4dd196e2715138ed2 (patch) | |
tree | 440d75109a7ebfefef2a58076b38b1bfe9db8f63 /firmware/asm/memmove.c | |
parent | 8e8e978de6b6283b66a6829fa8c5e3b94674ce7d (diff) | |
download | rockbox-a035261089403de259e74ce4dd196e2715138ed2.tar.gz rockbox-a035261089403de259e74ce4dd196e2715138ed2.zip |
Move optimized memcpy and friends and strlen to firmware/asm,
using the new automatic-asm-picking infrastructure.
Diffstat (limited to 'firmware/asm/memmove.c')
-rw-r--r-- | firmware/asm/memmove.c | 147 |
1 files changed, 147 insertions, 0 deletions
diff --git a/firmware/asm/memmove.c b/firmware/asm/memmove.c new file mode 100644 index 0000000000..5f423964bb --- /dev/null +++ b/firmware/asm/memmove.c | |||
@@ -0,0 +1,147 @@ | |||
1 | /* | ||
2 | FUNCTION | ||
3 | <<memmove>>---move possibly overlapping memory | ||
4 | |||
5 | INDEX | ||
6 | memmove | ||
7 | |||
8 | ANSI_SYNOPSIS | ||
9 | #include <string.h> | ||
10 | void *memmove(void *<[dst]>, const void *<[src]>, size_t <[length]>); | ||
11 | |||
12 | TRAD_SYNOPSIS | ||
13 | #include <string.h> | ||
14 | void *memmove(<[dst]>, <[src]>, <[length]>) | ||
15 | void *<[dst]>; | ||
16 | void *<[src]>; | ||
17 | size_t <[length]>; | ||
18 | |||
19 | DESCRIPTION | ||
20 | This function moves <[length]> characters from the block of | ||
21 | memory starting at <<*<[src]>>> to the memory starting at | ||
22 | <<*<[dst]>>>. <<memmove>> reproduces the characters correctly | ||
23 | at <<*<[dst]>>> even if the two areas overlap. | ||
24 | |||
25 | |||
26 | RETURNS | ||
27 | The function returns <[dst]> as passed. | ||
28 | |||
29 | PORTABILITY | ||
30 | <<memmove>> is ANSI C. | ||
31 | |||
32 | <<memmove>> requires no supporting OS subroutines. | ||
33 | |||
34 | QUICKREF | ||
35 | memmove ansi pure | ||
36 | */ | ||
37 | |||
38 | #include "config.h" | ||
39 | #include <_ansi.h> | ||
40 | #include <string.h> | ||
41 | |||
42 | /* Nonzero if either X or Y is not aligned on a "long" boundary. */ | ||
43 | #define UNALIGNED(X, Y) \ | ||
44 | (((long)X & (sizeof (long) - 1)) | ((long)Y & (sizeof (long) - 1))) | ||
45 | |||
46 | /* How many bytes are copied each iteration of the 4X unrolled loop. */ | ||
47 | #define BIGBLOCKSIZE (sizeof (long) << 2) | ||
48 | |||
49 | /* How many bytes are copied each iteration of the word copy loop. */ | ||
50 | #define LITTLEBLOCKSIZE (sizeof (long)) | ||
51 | |||
52 | /* Threshhold for punting to the byte copier. */ | ||
53 | #define TOO_SMALL(LEN) ((LEN) < BIGBLOCKSIZE) | ||
54 | |||
55 | _PTR | ||
56 | _DEFUN (memmove, (dst_void, src_void, length), | ||
57 | _PTR dst_void _AND | ||
58 | _CONST _PTR src_void _AND | ||
59 | size_t length) ICODE_ATTR; | ||
60 | |||
61 | _PTR | ||
62 | _DEFUN (memmove, (dst_void, src_void, length), | ||
63 | _PTR dst_void _AND | ||
64 | _CONST _PTR src_void _AND | ||
65 | size_t length) | ||
66 | { | ||
67 | #if defined(PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__) | ||
68 | char *dst = dst_void; | ||
69 | _CONST char *src = src_void; | ||
70 | |||
71 | if (src < dst && dst < src + length) | ||
72 | { | ||
73 | /* Have to copy backwards */ | ||
74 | src += length; | ||
75 | dst += length; | ||
76 | while (length--) | ||
77 | { | ||
78 | *--dst = *--src; | ||
79 | } | ||
80 | } | ||
81 | else | ||
82 | { | ||
83 | while (length--) | ||
84 | { | ||
85 | *dst++ = *src++; | ||
86 | } | ||
87 | } | ||
88 | |||
89 | return dst_void; | ||
90 | #else | ||
91 | char *dst = dst_void; | ||
92 | _CONST char *src = src_void; | ||
93 | long *aligned_dst; | ||
94 | _CONST long *aligned_src; | ||
95 | unsigned int len = length; | ||
96 | |||
97 | if (src < dst && dst < src + len) | ||
98 | { | ||
99 | /* Destructive overlap...have to copy backwards */ | ||
100 | src += len; | ||
101 | dst += len; | ||
102 | while (len--) | ||
103 | { | ||
104 | *--dst = *--src; | ||
105 | } | ||
106 | } | ||
107 | else | ||
108 | { | ||
109 | /* Use optimizing algorithm for a non-destructive copy to closely | ||
110 | match memcpy. If the size is small or either SRC or DST is unaligned, | ||
111 | then punt into the byte copy loop. This should be rare. */ | ||
112 | if (!TOO_SMALL(len) && !UNALIGNED (src, dst)) | ||
113 | { | ||
114 | aligned_dst = (long*)dst; | ||
115 | aligned_src = (long*)src; | ||
116 | |||
117 | /* Copy 4X long words at a time if possible. */ | ||
118 | while (len >= BIGBLOCKSIZE) | ||
119 | { | ||
120 | *aligned_dst++ = *aligned_src++; | ||
121 | *aligned_dst++ = *aligned_src++; | ||
122 | *aligned_dst++ = *aligned_src++; | ||
123 | *aligned_dst++ = *aligned_src++; | ||
124 | len -= BIGBLOCKSIZE; | ||
125 | } | ||
126 | |||
127 | /* Copy one long word at a time if possible. */ | ||
128 | while (len >= LITTLEBLOCKSIZE) | ||
129 | { | ||
130 | *aligned_dst++ = *aligned_src++; | ||
131 | len -= LITTLEBLOCKSIZE; | ||
132 | } | ||
133 | |||
134 | /* Pick up any residual with a byte copier. */ | ||
135 | dst = (char*)aligned_dst; | ||
136 | src = (char*)aligned_src; | ||
137 | } | ||
138 | |||
139 | while (len--) | ||
140 | { | ||
141 | *dst++ = *src++; | ||
142 | } | ||
143 | } | ||
144 | |||
145 | return dst_void; | ||
146 | #endif /* not PREFER_SIZE_OVER_SPEED */ | ||
147 | } | ||