(Redoing check-in lost by SourceForge's failure.)
[people/xl0/gpxe.git] / src / arch / i386 / include / bits / string.h
1 #ifndef ETHERBOOT_BITS_STRING_H
2 #define ETHERBOOT_BITS_STRING_H
3 /*
4  * Taken from Linux /usr/include/asm/string.h
5  * All except memcpy, memmove, memset and memcmp removed.
6  *
7  * Non-standard memswap() function added because it saves quite a bit
8  * of code (mbrown@fensystems.co.uk).
9  */
10
11 /*
12  * This string-include defines all string functions as inline
13  * functions. Use gcc. It also assumes ds=es=data space, this should be
14  * normal. Most of the string-functions are rather heavily hand-optimized,
15  * see especially strtok,strstr,str[c]spn. They should work, but are not
16  * very easy to understand. Everything is done entirely within the register
17  * set, making the functions fast and clean. String instructions have been
18  * used through-out, making for "slightly" unclear code :-)
19  *
20  *              NO Copyright (C) 1991, 1992 Linus Torvalds,
21  *              consider these trivial functions to be PD.
22  */
23
24 #define __HAVE_ARCH_MEMCPY
25 static inline __attribute__ (( always_inline )) void *
26 __memcpy ( void *dest, const void *src, size_t len ) {
27         int d0, d1, d2;
28         __asm__ __volatile__ ( "rep ; movsb"
29                                : "=&c" ( d0 ), "=&S" ( d1 ), "=&D" ( d2 )
30                                : "0" ( len ), "1" ( src ), "2" ( dest )
31                                : "memory" );
32         return dest; 
33 }
34
35 static inline __attribute__ (( always_inline )) void *
36 __constant_memcpy ( void *dest, const void *src, size_t len ) {
37         union {
38                 uint32_t u32[2];
39                 uint16_t u16[4];
40                 uint8_t  u8[8];
41         } __attribute__ (( __may_alias__ )) *dest_u = dest;
42         const union {
43                 uint32_t u32[2];
44                 uint16_t u16[4];
45                 uint8_t  u8[8];
46         } __attribute__ (( __may_alias__ )) *src_u = src;
47         const void *esi;
48         void *edi;
49
50         switch ( len ) {
51         case 0 : /* 0 bytes */
52                 return dest;
53         /*
54          * Single-register moves; these are always better than a
55          * string operation.  We can clobber an arbitrary two
56          * registers (data, source, dest can re-use source register)
57          * instead of being restricted to esi and edi.  There's also a
58          * much greater potential for optimising with nearby code.
59          *
60          */
61         case 1 : /* 4 bytes */
62                 dest_u->u8[0]  = src_u->u8[0];
63                 return dest;
64         case 2 : /* 6 bytes */
65                 dest_u->u16[0] = src_u->u16[0];
66                 return dest;
67         case 4 : /* 4 bytes */
68                 dest_u->u32[0] = src_u->u32[0];
69                 return dest;
70         /*
71          * Double-register moves; these are probably still a win.
72          *
73          */
74         case 3 : /* 12 bytes */
75                 dest_u->u16[0] = src_u->u16[0];
76                 dest_u->u8[2]  = src_u->u8[2];
77                 return dest;
78         case 5 : /* 10 bytes */
79                 dest_u->u32[0] = src_u->u32[0];
80                 dest_u->u8[4]  = src_u->u8[4];
81                 return dest;
82         case 6 : /* 12 bytes */
83                 dest_u->u32[0] = src_u->u32[0];
84                 dest_u->u16[2] = src_u->u16[2];
85                 return dest;
86         case 8 : /* 10 bytes */
87                 dest_u->u32[0] = src_u->u32[0];
88                 dest_u->u32[1] = src_u->u32[1];
89                 return dest;
90         }
91
92         /* Even if we have to load up esi and edi ready for a string
93          * operation, we can sometimes save space by using multiple
94          * single-byte "movs" operations instead of loading up ecx and
95          * using "rep movsb".
96          *
97          * "load ecx, rep movsb" is 7 bytes, plus an average of 1 byte
98          * to allow for saving/restoring ecx 50% of the time.
99          *
100          * "movsl" and "movsb" are 1 byte each, "movsw" is two bytes.
101          * (In 16-bit mode, "movsl" is 2 bytes and "movsw" is 1 byte,
102          * but "movsl" moves twice as much data, so it balances out).
103          *
104          * The cutoff point therefore occurs around 26 bytes; the byte
105          * requirements for each method are:
106          *
107          * len             16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
108          * #bytes (ecx)     8  8  8  8  8  8  8  8  8  8  8  8  8  8  8  8
109          * #bytes (no ecx)  4  5  6  7  5  6  7  8  6  7  8  9  7  8  9 10
110          */
111
112         esi = src;
113         edi = dest;
114         
115         if ( len >= 26 )
116                 return __memcpy ( dest, src, len );
117         
118         if ( len >= 6*4 )
119                 __asm__ __volatile__ ( "movsl" : "=&D" ( edi ), "=&S" ( esi )
120                                        : "0" ( edi ), "1" ( esi ) : "memory" );
121         if ( len >= 5*4 )
122                 __asm__ __volatile__ ( "movsl" : "=&D" ( edi ), "=&S" ( esi )
123                                        : "0" ( edi ), "1" ( esi ) : "memory" );
124         if ( len >= 4*4 )
125                 __asm__ __volatile__ ( "movsl" : "=&D" ( edi ), "=&S" ( esi )
126                                        : "0" ( edi ), "1" ( esi ) : "memory" );
127         if ( len >= 3*4 )
128                 __asm__ __volatile__ ( "movsl" : "=&D" ( edi ), "=&S" ( esi )
129                                        : "0" ( edi ), "1" ( esi ) : "memory" );
130         if ( len >= 2*4 )
131                 __asm__ __volatile__ ( "movsl" : "=&D" ( edi ), "=&S" ( esi )
132                                        : "0" ( edi ), "1" ( esi ) : "memory" );
133         if ( len >= 1*4 )
134                 __asm__ __volatile__ ( "movsl" : "=&D" ( edi ), "=&S" ( esi )
135                                        : "0" ( edi ), "1" ( esi ) : "memory" );
136         if ( ( len % 4 ) >= 2 )
137                 __asm__ __volatile__ ( "movsw" : "=&D" ( edi ), "=&S" ( esi )
138                                        : "0" ( edi ), "1" ( esi ) : "memory" );
139         if ( ( len % 2 ) >= 1 )
140                 __asm__ __volatile__ ( "movsb" : "=&D" ( edi ), "=&S" ( esi )
141                                        : "0" ( edi ), "1" ( esi ) : "memory" );
142
143         return dest;
144 }
145
146 #define memcpy( dest, src, len )                        \
147         ( __builtin_constant_p ( (len) ) ?              \
148           __constant_memcpy ( (dest), (src), (len) ) :  \
149           __memcpy ( (dest), (src), (len) ) )
150
151 #define __HAVE_ARCH_MEMMOVE
152 static inline void * memmove(void * dest,const void * src, size_t n)
153 {
154 int d0, d1, d2;
155 if (dest<src)
156 __asm__ __volatile__(
157         "cld\n\t"
158         "rep\n\t"
159         "movsb"
160         : "=&c" (d0), "=&S" (d1), "=&D" (d2)
161         :"0" (n),"1" (src),"2" (dest)
162         : "memory");
163 else
164 __asm__ __volatile__(
165         "std\n\t"
166         "rep\n\t"
167         "movsb\n\t"
168         "cld"
169         : "=&c" (d0), "=&S" (d1), "=&D" (d2)
170         :"0" (n),
171          "1" (n-1+(const char *)src),
172          "2" (n-1+(char *)dest)
173         :"memory");
174 return dest;
175 }
176
177 #define __HAVE_ARCH_MEMSET
178 static inline void * memset(void *s, int c,size_t count)
179 {
180 int d0, d1;
181 __asm__ __volatile__(
182         "cld\n\t"
183         "rep\n\t"
184         "stosb"
185         : "=&c" (d0), "=&D" (d1)
186         :"a" (c),"1" (s),"0" (count)
187         :"memory");
188 return s;
189 }
190
191 #define __HAVE_ARCH_MEMSWAP
192 static inline void * memswap(void *dest, void *src, size_t n)
193 {
194 int d0, d1, d2, d3;
195 __asm__ __volatile__(
196         "\n1:\t"
197         "movb (%%edi),%%al\n\t"
198         "xchgb (%%esi),%%al\n\t"
199         "incl %%esi\n\t"
200         "stosb\n\t"
201         "loop 1b"
202         : "=&c" (d0), "=&S" (d1), "=&D" (d2), "=&a" (d3)
203         : "0" (n), "1" (src), "2" (dest)
204         : "memory" );
205 return dest;
206 }
207
208 #define __HAVE_ARCH_STRNCMP
209 static inline int strncmp(const char * cs,const char * ct,size_t count)
210 {
211 register int __res;
212 int d0, d1, d2;
213 __asm__ __volatile__(
214         "1:\tdecl %3\n\t"
215         "js 2f\n\t"
216         "lodsb\n\t"
217         "scasb\n\t"
218         "jne 3f\n\t"
219         "testb %%al,%%al\n\t"
220         "jne 1b\n"
221         "2:\txorl %%eax,%%eax\n\t"
222         "jmp 4f\n"
223         "3:\tsbbl %%eax,%%eax\n\t"
224         "orb $1,%%al\n"
225         "4:"
226                      :"=a" (__res), "=&S" (d0), "=&D" (d1), "=&c" (d2)
227                      :"1" (cs),"2" (ct),"3" (count));
228 return __res;
229 }
230
231 #define __HAVE_ARCH_STRLEN
232 static inline size_t strlen(const char * s)
233 {
234 int d0;
235 register int __res;
236 __asm__ __volatile__(
237         "repne\n\t"
238         "scasb\n\t"
239         "notl %0\n\t"
240         "decl %0"
241         :"=c" (__res), "=&D" (d0) :"1" (s),"a" (0), "0" (0xffffffff));
242 return __res;
243 }
244
245 #endif /* ETHERBOOT_BITS_STRING_H */