Merge branch 'upstream-linus' of master.kernel.org:/pub/scm/linux/kernel/git/jgarzik...
[linux-2.6] / include / asm-i386 / string.h
1 #ifndef _I386_STRING_H_
2 #define _I386_STRING_H_
3
4 #ifdef __KERNEL__
5 /*
6  * On a 486 or Pentium, we are better off not using the
7  * byte string operations. But on a 386 or a PPro the
8  * byte string ops are faster than doing it by hand
9  * (MUCH faster on a Pentium).
10  */
11
12 /*
13  * This string-include defines all string functions as inline
14  * functions. Use gcc. It also assumes ds=es=data space, this should be
15  * normal. Most of the string-functions are rather heavily hand-optimized,
16  * see especially strsep,strstr,str[c]spn. They should work, but are not
17  * very easy to understand. Everything is done entirely within the register
18  * set, making the functions fast and clean. String instructions have been
19  * used through-out, making for "slightly" unclear code :-)
20  *
21  *              NO Copyright (C) 1991, 1992 Linus Torvalds,
22  *              consider these trivial functions to be PD.
23  */
24
25 /* AK: in fact I bet it would be better to move this stuff all out of line.
26  */
27
28 #define __HAVE_ARCH_STRCPY
29 static inline char * strcpy(char * dest,const char *src)
30 {
31 int d0, d1, d2;
32 __asm__ __volatile__(
33         "1:\tlodsb\n\t"
34         "stosb\n\t"
35         "testb %%al,%%al\n\t"
36         "jne 1b"
37         : "=&S" (d0), "=&D" (d1), "=&a" (d2)
38         :"0" (src),"1" (dest) : "memory");
39 return dest;
40 }
41
42 #define __HAVE_ARCH_STRNCPY
43 static inline char * strncpy(char * dest,const char *src,size_t count)
44 {
45 int d0, d1, d2, d3;
46 __asm__ __volatile__(
47         "1:\tdecl %2\n\t"
48         "js 2f\n\t"
49         "lodsb\n\t"
50         "stosb\n\t"
51         "testb %%al,%%al\n\t"
52         "jne 1b\n\t"
53         "rep\n\t"
54         "stosb\n"
55         "2:"
56         : "=&S" (d0), "=&D" (d1), "=&c" (d2), "=&a" (d3)
57         :"0" (src),"1" (dest),"2" (count) : "memory");
58 return dest;
59 }
60
61 #define __HAVE_ARCH_STRCAT
62 static inline char * strcat(char * dest,const char * src)
63 {
64 int d0, d1, d2, d3;
65 __asm__ __volatile__(
66         "repne\n\t"
67         "scasb\n\t"
68         "decl %1\n"
69         "1:\tlodsb\n\t"
70         "stosb\n\t"
71         "testb %%al,%%al\n\t"
72         "jne 1b"
73         : "=&S" (d0), "=&D" (d1), "=&a" (d2), "=&c" (d3)
74         : "0" (src), "1" (dest), "2" (0), "3" (0xffffffffu):"memory");
75 return dest;
76 }
77
78 #define __HAVE_ARCH_STRNCAT
79 static inline char * strncat(char * dest,const char * src,size_t count)
80 {
81 int d0, d1, d2, d3;
82 __asm__ __volatile__(
83         "repne\n\t"
84         "scasb\n\t"
85         "decl %1\n\t"
86         "movl %8,%3\n"
87         "1:\tdecl %3\n\t"
88         "js 2f\n\t"
89         "lodsb\n\t"
90         "stosb\n\t"
91         "testb %%al,%%al\n\t"
92         "jne 1b\n"
93         "2:\txorl %2,%2\n\t"
94         "stosb"
95         : "=&S" (d0), "=&D" (d1), "=&a" (d2), "=&c" (d3)
96         : "0" (src),"1" (dest),"2" (0),"3" (0xffffffffu), "g" (count)
97         : "memory");
98 return dest;
99 }
100
101 #define __HAVE_ARCH_STRCMP
102 static inline int strcmp(const char * cs,const char * ct)
103 {
104 int d0, d1;
105 register int __res;
106 __asm__ __volatile__(
107         "1:\tlodsb\n\t"
108         "scasb\n\t"
109         "jne 2f\n\t"
110         "testb %%al,%%al\n\t"
111         "jne 1b\n\t"
112         "xorl %%eax,%%eax\n\t"
113         "jmp 3f\n"
114         "2:\tsbbl %%eax,%%eax\n\t"
115         "orb $1,%%al\n"
116         "3:"
117         :"=a" (__res), "=&S" (d0), "=&D" (d1)
118         :"1" (cs),"2" (ct)
119         :"memory");
120 return __res;
121 }
122
123 #define __HAVE_ARCH_STRNCMP
124 static inline int strncmp(const char * cs,const char * ct,size_t count)
125 {
126 register int __res;
127 int d0, d1, d2;
128 __asm__ __volatile__(
129         "1:\tdecl %3\n\t"
130         "js 2f\n\t"
131         "lodsb\n\t"
132         "scasb\n\t"
133         "jne 3f\n\t"
134         "testb %%al,%%al\n\t"
135         "jne 1b\n"
136         "2:\txorl %%eax,%%eax\n\t"
137         "jmp 4f\n"
138         "3:\tsbbl %%eax,%%eax\n\t"
139         "orb $1,%%al\n"
140         "4:"
141         :"=a" (__res), "=&S" (d0), "=&D" (d1), "=&c" (d2)
142         :"1" (cs),"2" (ct),"3" (count)
143         :"memory");
144 return __res;
145 }
146
147 #define __HAVE_ARCH_STRCHR
148 static inline char * strchr(const char * s, int c)
149 {
150 int d0;
151 register char * __res;
152 __asm__ __volatile__(
153         "movb %%al,%%ah\n"
154         "1:\tlodsb\n\t"
155         "cmpb %%ah,%%al\n\t"
156         "je 2f\n\t"
157         "testb %%al,%%al\n\t"
158         "jne 1b\n\t"
159         "movl $1,%1\n"
160         "2:\tmovl %1,%0\n\t"
161         "decl %0"
162         :"=a" (__res), "=&S" (d0)
163         :"1" (s),"0" (c)
164         :"memory");
165 return __res;
166 }
167
168 #define __HAVE_ARCH_STRRCHR
169 static inline char * strrchr(const char * s, int c)
170 {
171 int d0, d1;
172 register char * __res;
173 __asm__ __volatile__(
174         "movb %%al,%%ah\n"
175         "1:\tlodsb\n\t"
176         "cmpb %%ah,%%al\n\t"
177         "jne 2f\n\t"
178         "leal -1(%%esi),%0\n"
179         "2:\ttestb %%al,%%al\n\t"
180         "jne 1b"
181         :"=g" (__res), "=&S" (d0), "=&a" (d1)
182         :"0" (0),"1" (s),"2" (c)
183         :"memory");
184 return __res;
185 }
186
187 #define __HAVE_ARCH_STRLEN
188 static inline size_t strlen(const char * s)
189 {
190 int d0;
191 register int __res;
192 __asm__ __volatile__(
193         "repne\n\t"
194         "scasb\n\t"
195         "notl %0\n\t"
196         "decl %0"
197         :"=c" (__res), "=&D" (d0)
198         :"1" (s),"a" (0), "0" (0xffffffffu)
199         :"memory");
200 return __res;
201 }
202
203 static __always_inline void * __memcpy(void * to, const void * from, size_t n)
204 {
205 int d0, d1, d2;
206 __asm__ __volatile__(
207         "rep ; movsl\n\t"
208         "movl %4,%%ecx\n\t"
209         "andl $3,%%ecx\n\t"
210 #if 1   /* want to pay 2 byte penalty for a chance to skip microcoded rep? */
211         "jz 1f\n\t"
212 #endif
213         "rep ; movsb\n\t"
214         "1:"
215         : "=&c" (d0), "=&D" (d1), "=&S" (d2)
216         : "0" (n/4), "g" (n), "1" ((long) to), "2" ((long) from)
217         : "memory");
218 return (to);
219 }
220
221 /*
222  * This looks ugly, but the compiler can optimize it totally,
223  * as the count is constant.
224  */
225 static __always_inline void * __constant_memcpy(void * to, const void * from, size_t n)
226 {
227         long esi, edi;
228         if (!n) return to;
229 #if 1   /* want to do small copies with non-string ops? */
230         switch (n) {
231                 case 1: *(char*)to = *(char*)from; return to;
232                 case 2: *(short*)to = *(short*)from; return to;
233                 case 4: *(int*)to = *(int*)from; return to;
234 #if 1   /* including those doable with two moves? */
235                 case 3: *(short*)to = *(short*)from;
236                         *((char*)to+2) = *((char*)from+2); return to;
237                 case 5: *(int*)to = *(int*)from;
238                         *((char*)to+4) = *((char*)from+4); return to;
239                 case 6: *(int*)to = *(int*)from;
240                         *((short*)to+2) = *((short*)from+2); return to;
241                 case 8: *(int*)to = *(int*)from;
242                         *((int*)to+1) = *((int*)from+1); return to;
243 #endif
244         }
245 #endif
246         esi = (long) from;
247         edi = (long) to;
248         if (n >= 5*4) {
249                 /* large block: use rep prefix */
250                 int ecx;
251                 __asm__ __volatile__(
252                         "rep ; movsl"
253                         : "=&c" (ecx), "=&D" (edi), "=&S" (esi)
254                         : "0" (n/4), "1" (edi),"2" (esi)
255                         : "memory"
256                 );
257         } else {
258                 /* small block: don't clobber ecx + smaller code */
259                 if (n >= 4*4) __asm__ __volatile__("movsl"
260                         :"=&D"(edi),"=&S"(esi):"0"(edi),"1"(esi):"memory");
261                 if (n >= 3*4) __asm__ __volatile__("movsl"
262                         :"=&D"(edi),"=&S"(esi):"0"(edi),"1"(esi):"memory");
263                 if (n >= 2*4) __asm__ __volatile__("movsl"
264                         :"=&D"(edi),"=&S"(esi):"0"(edi),"1"(esi):"memory");
265                 if (n >= 1*4) __asm__ __volatile__("movsl"
266                         :"=&D"(edi),"=&S"(esi):"0"(edi),"1"(esi):"memory");
267         }
268         switch (n % 4) {
269                 /* tail */
270                 case 0: return to;
271                 case 1: __asm__ __volatile__("movsb"
272                         :"=&D"(edi),"=&S"(esi):"0"(edi),"1"(esi):"memory");
273                         return to;
274                 case 2: __asm__ __volatile__("movsw"
275                         :"=&D"(edi),"=&S"(esi):"0"(edi),"1"(esi):"memory");
276                         return to;
277                 default: __asm__ __volatile__("movsw\n\tmovsb"
278                         :"=&D"(edi),"=&S"(esi):"0"(edi),"1"(esi):"memory");
279                         return to;
280         }
281 }
282
283 #define __HAVE_ARCH_MEMCPY
284
285 #ifdef CONFIG_X86_USE_3DNOW
286
287 #include <asm/mmx.h>
288
289 /*
290  *      This CPU favours 3DNow strongly (eg AMD Athlon)
291  */
292
293 static inline void * __constant_memcpy3d(void * to, const void * from, size_t len)
294 {
295         if (len < 512)
296                 return __constant_memcpy(to, from, len);
297         return _mmx_memcpy(to, from, len);
298 }
299
300 static __inline__ void *__memcpy3d(void *to, const void *from, size_t len)
301 {
302         if (len < 512)
303                 return __memcpy(to, from, len);
304         return _mmx_memcpy(to, from, len);
305 }
306
307 #define memcpy(t, f, n) \
308 (__builtin_constant_p(n) ? \
309  __constant_memcpy3d((t),(f),(n)) : \
310  __memcpy3d((t),(f),(n)))
311
312 #else
313
314 /*
315  *      No 3D Now!
316  */
317  
318 #define memcpy(t, f, n) \
319 (__builtin_constant_p(n) ? \
320  __constant_memcpy((t),(f),(n)) : \
321  __memcpy((t),(f),(n)))
322
323 #endif
324
325 #define __HAVE_ARCH_MEMMOVE
326 void *memmove(void * dest,const void * src, size_t n);
327
328 #define memcmp __builtin_memcmp
329
330 #define __HAVE_ARCH_MEMCHR
331 static inline void * memchr(const void * cs,int c,size_t count)
332 {
333 int d0;
334 register void * __res;
335 if (!count)
336         return NULL;
337 __asm__ __volatile__(
338         "repne\n\t"
339         "scasb\n\t"
340         "je 1f\n\t"
341         "movl $1,%0\n"
342         "1:\tdecl %0"
343         :"=D" (__res), "=&c" (d0)
344         :"a" (c),"0" (cs),"1" (count)
345         :"memory");
346 return __res;
347 }
348
349 static inline void * __memset_generic(void * s, char c,size_t count)
350 {
351 int d0, d1;
352 __asm__ __volatile__(
353         "rep\n\t"
354         "stosb"
355         : "=&c" (d0), "=&D" (d1)
356         :"a" (c),"1" (s),"0" (count)
357         :"memory");
358 return s;
359 }
360
361 /* we might want to write optimized versions of these later */
362 #define __constant_count_memset(s,c,count) __memset_generic((s),(c),(count))
363
364 /*
365  * memset(x,0,y) is a reasonably common thing to do, so we want to fill
366  * things 32 bits at a time even when we don't know the size of the
367  * area at compile-time..
368  */
369 static __always_inline void * __constant_c_memset(void * s, unsigned long c, size_t count)
370 {
371 int d0, d1;
372 __asm__ __volatile__(
373         "rep ; stosl\n\t"
374         "testb $2,%b3\n\t"
375         "je 1f\n\t"
376         "stosw\n"
377         "1:\ttestb $1,%b3\n\t"
378         "je 2f\n\t"
379         "stosb\n"
380         "2:"
381         :"=&c" (d0), "=&D" (d1)
382         :"a" (c), "q" (count), "0" (count/4), "1" ((long) s)
383         :"memory");
384 return (s);     
385 }
386
387 /* Added by Gertjan van Wingerde to make minix and sysv module work */
388 #define __HAVE_ARCH_STRNLEN
389 static inline size_t strnlen(const char * s, size_t count)
390 {
391 int d0;
392 register int __res;
393 __asm__ __volatile__(
394         "movl %2,%0\n\t"
395         "jmp 2f\n"
396         "1:\tcmpb $0,(%0)\n\t"
397         "je 3f\n\t"
398         "incl %0\n"
399         "2:\tdecl %1\n\t"
400         "cmpl $-1,%1\n\t"
401         "jne 1b\n"
402         "3:\tsubl %2,%0"
403         :"=a" (__res), "=&d" (d0)
404         :"c" (s),"1" (count)
405         :"memory");
406 return __res;
407 }
408 /* end of additional stuff */
409
410 #define __HAVE_ARCH_STRSTR
411
412 extern char *strstr(const char *cs, const char *ct);
413
414 /*
415  * This looks horribly ugly, but the compiler can optimize it totally,
416  * as we by now know that both pattern and count is constant..
417  */
418 static __always_inline void * __constant_c_and_count_memset(void * s, unsigned long pattern, size_t count)
419 {
420         switch (count) {
421                 case 0:
422                         return s;
423                 case 1:
424                         *(unsigned char *)s = pattern;
425                         return s;
426                 case 2:
427                         *(unsigned short *)s = pattern;
428                         return s;
429                 case 3:
430                         *(unsigned short *)s = pattern;
431                         *(2+(unsigned char *)s) = pattern;
432                         return s;
433                 case 4:
434                         *(unsigned long *)s = pattern;
435                         return s;
436         }
437 #define COMMON(x) \
438 __asm__  __volatile__( \
439         "rep ; stosl" \
440         x \
441         : "=&c" (d0), "=&D" (d1) \
442         : "a" (pattern),"0" (count/4),"1" ((long) s) \
443         : "memory")
444 {
445         int d0, d1;
446         switch (count % 4) {
447                 case 0: COMMON(""); return s;
448                 case 1: COMMON("\n\tstosb"); return s;
449                 case 2: COMMON("\n\tstosw"); return s;
450                 default: COMMON("\n\tstosw\n\tstosb"); return s;
451         }
452 }
453   
454 #undef COMMON
455 }
456
457 #define __constant_c_x_memset(s, c, count) \
458 (__builtin_constant_p(count) ? \
459  __constant_c_and_count_memset((s),(c),(count)) : \
460  __constant_c_memset((s),(c),(count)))
461
462 #define __memset(s, c, count) \
463 (__builtin_constant_p(count) ? \
464  __constant_count_memset((s),(c),(count)) : \
465  __memset_generic((s),(c),(count)))
466
467 #define __HAVE_ARCH_MEMSET
468 #define memset(s, c, count) \
469 (__builtin_constant_p(c) ? \
470  __constant_c_x_memset((s),(0x01010101UL*(unsigned char)(c)),(count)) : \
471  __memset((s),(c),(count)))
472
473 /*
474  * find the first occurrence of byte 'c', or 1 past the area if none
475  */
476 #define __HAVE_ARCH_MEMSCAN
477 static inline void * memscan(void * addr, int c, size_t size)
478 {
479         if (!size)
480                 return addr;
481         __asm__("repnz; scasb\n\t"
482                 "jnz 1f\n\t"
483                 "dec %%edi\n"
484                 "1:"
485                 : "=D" (addr), "=c" (size)
486                 : "0" (addr), "1" (size), "a" (c)
487                 : "memory");
488         return addr;
489 }
490
491 #endif /* __KERNEL__ */
492
493 #endif