[PATCH] tiny: Make *[ug]id16 support optional
[linux-3.10.git] / arch / m68k / lib / string.c
1
2 #include <linux/types.h>
3 #include <linux/module.h>
4
5 void *memset(void *s, int c, size_t count)
6 {
7         void *xs = s;
8         size_t temp, temp1;
9
10         if (!count)
11                 return xs;
12         c &= 0xff;
13         c |= c << 8;
14         c |= c << 16;
15         if ((long)s & 1) {
16                 char *cs = s;
17                 *cs++ = c;
18                 s = cs;
19                 count--;
20         }
21         if (count > 2 && (long)s & 2) {
22                 short *ss = s;
23                 *ss++ = c;
24                 s = ss;
25                 count -= 2;
26         }
27         temp = count >> 2;
28         if (temp) {
29                 long *ls = s;
30
31                 asm volatile (
32                         "       movel %1,%2\n"
33                         "       andw  #7,%2\n"
34                         "       lsrl  #3,%1\n"
35                         "       negw  %2\n"
36                         "       jmp   %%pc@(2f,%2:w:2)\n"
37                         "1:     movel %3,%0@+\n"
38                         "       movel %3,%0@+\n"
39                         "       movel %3,%0@+\n"
40                         "       movel %3,%0@+\n"
41                         "       movel %3,%0@+\n"
42                         "       movel %3,%0@+\n"
43                         "       movel %3,%0@+\n"
44                         "       movel %3,%0@+\n"
45                         "2:     dbra  %1,1b\n"
46                         "       clrw  %1\n"
47                         "       subql #1,%1\n"
48                         "       jpl   1b"
49                         : "=a" (ls), "=d" (temp), "=&d" (temp1)
50                         : "d" (c), "0" (ls), "1" (temp));
51                 s = ls;
52         }
53         if (count & 2) {
54                 short *ss = s;
55                 *ss++ = c;
56                 s = ss;
57         }
58         if (count & 1) {
59                 char *cs = s;
60                 *cs = c;
61         }
62         return xs;
63 }
64 EXPORT_SYMBOL(memset);
65
66 void *memcpy(void *to, const void *from, size_t n)
67 {
68         void *xto = to;
69         size_t temp, temp1;
70
71         if (!n)
72                 return xto;
73         if ((long)to & 1) {
74                 char *cto = to;
75                 const char *cfrom = from;
76                 *cto++ = *cfrom++;
77                 to = cto;
78                 from = cfrom;
79                 n--;
80         }
81         if (n > 2 && (long)to & 2) {
82                 short *sto = to;
83                 const short *sfrom = from;
84                 *sto++ = *sfrom++;
85                 to = sto;
86                 from = sfrom;
87                 n -= 2;
88         }
89         temp = n >> 2;
90         if (temp) {
91                 long *lto = to;
92                 const long *lfrom = from;
93
94                 asm volatile (
95                         "       movel %2,%3\n"
96                         "       andw  #7,%3\n"
97                         "       lsrl  #3,%2\n"
98                         "       negw  %3\n"
99                         "       jmp   %%pc@(1f,%3:w:2)\n"
100                         "4:     movel %0@+,%1@+\n"
101                         "       movel %0@+,%1@+\n"
102                         "       movel %0@+,%1@+\n"
103                         "       movel %0@+,%1@+\n"
104                         "       movel %0@+,%1@+\n"
105                         "       movel %0@+,%1@+\n"
106                         "       movel %0@+,%1@+\n"
107                         "       movel %0@+,%1@+\n"
108                         "1:     dbra  %2,4b\n"
109                         "       clrw  %2\n"
110                         "       subql #1,%2\n"
111                         "       jpl   4b"
112                         : "=a" (lfrom), "=a" (lto), "=d" (temp), "=&d" (temp1)
113                         : "0" (lfrom), "1" (lto), "2" (temp));
114                 to = lto;
115                 from = lfrom;
116         }
117         if (n & 2) {
118                 short *sto = to;
119                 const short *sfrom = from;
120                 *sto++ = *sfrom++;
121                 to = sto;
122                 from = sfrom;
123         }
124         if (n & 1) {
125                 char *cto = to;
126                 const char *cfrom = from;
127                 *cto = *cfrom;
128         }
129         return xto;
130 }
131 EXPORT_SYMBOL(memcpy);
132
133 void *memmove(void *dest, const void *src, size_t n)
134 {
135         void *xdest = dest;
136         size_t temp;
137
138         if (!n)
139                 return xdest;
140
141         if (dest < src) {
142                 if ((long)dest & 1) {
143                         char *cdest = dest;
144                         const char *csrc = src;
145                         *cdest++ = *csrc++;
146                         dest = cdest;
147                         src = csrc;
148                         n--;
149                 }
150                 if (n > 2 && (long)dest & 2) {
151                         short *sdest = dest;
152                         const short *ssrc = src;
153                         *sdest++ = *ssrc++;
154                         dest = sdest;
155                         src = ssrc;
156                         n -= 2;
157                 }
158                 temp = n >> 2;
159                 if (temp) {
160                         long *ldest = dest;
161                         const long *lsrc = src;
162                         temp--;
163                         do
164                                 *ldest++ = *lsrc++;
165                         while (temp--);
166                         dest = ldest;
167                         src = lsrc;
168                 }
169                 if (n & 2) {
170                         short *sdest = dest;
171                         const short *ssrc = src;
172                         *sdest++ = *ssrc++;
173                         dest = sdest;
174                         src = ssrc;
175                 }
176                 if (n & 1) {
177                         char *cdest = dest;
178                         const char *csrc = src;
179                         *cdest = *csrc;
180                 }
181         } else {
182                 dest = (char *)dest + n;
183                 src = (const char *)src + n;
184                 if ((long)dest & 1) {
185                         char *cdest = dest;
186                         const char *csrc = src;
187                         *--cdest = *--csrc;
188                         dest = cdest;
189                         src = csrc;
190                         n--;
191                 }
192                 if (n > 2 && (long)dest & 2) {
193                         short *sdest = dest;
194                         const short *ssrc = src;
195                         *--sdest = *--ssrc;
196                         dest = sdest;
197                         src = ssrc;
198                         n -= 2;
199                 }
200                 temp = n >> 2;
201                 if (temp) {
202                         long *ldest = dest;
203                         const long *lsrc = src;
204                         temp--;
205                         do
206                                 *--ldest = *--lsrc;
207                         while (temp--);
208                         dest = ldest;
209                         src = lsrc;
210                 }
211                 if (n & 2) {
212                         short *sdest = dest;
213                         const short *ssrc = src;
214                         *--sdest = *--ssrc;
215                         dest = sdest;
216                         src = ssrc;
217                 }
218                 if (n & 1) {
219                         char *cdest = dest;
220                         const char *csrc = src;
221                         *--cdest = *--csrc;
222                 }
223         }
224         return xdest;
225 }
226 EXPORT_SYMBOL(memmove);
227
228 int memcmp(const void *cs, const void *ct, size_t count)
229 {
230         const unsigned char *su1, *su2;
231
232         for (su1 = cs, su2 = ct; count > 0; ++su1, ++su2, count--)
233                 if (*su1 != *su2)
234                         return *su1 < *su2 ? -1 : +1;
235         return 0;
236 }
237 EXPORT_SYMBOL(memcmp);