]> git.ipfire.org Git - thirdparty/glibc.git/blob - sysdeps/i386/i486/bits/string.h
projects / thirdparty / glibc.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Update.
[thirdparty/glibc.git] / sysdeps / i386 / i486 / bits / string.h
1 /* Optimized, inlined string functions. i486 version.
2 Copyright (C) 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Library General Public License as
7 published by the Free Software Foundation; either version 2 of the
8 License, or (at your option) any later version.
9
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Library General Public License for more details.
14
15 You should have received a copy of the GNU Library General Public
16 License along with the GNU C Library; see the file COPYING.LIB. If not,
17 write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 Boston, MA 02111-1307, USA. */
19
20 #ifndef _STRING_H
21 # error "Never use <bits/string.h> directly; include <string.h> instead."
22 #endif
23
24 /* The ix86 processors can access unaligned multi-byte variables. */
25 #define _STRING_ARCH_unaligned 1
26
27
28 /* We only provide optimizations if the user selects them and if
29 GNU CC is used. */
30 #if !defined __NO_STRING_INLINES && defined __USE_STRING_INLINES \
31 && defined __GNUC__ && __GNUC__ >= 2 && !__BOUNDED_POINTERS__
32
33 #ifndef __STRING_INLINE
34 # ifdef __cplusplus
35 # define __STRING_INLINE inline
36 # else
37 # define __STRING_INLINE extern __inline
38 # endif
39 #endif
40
41 /* The macros are used in some of the optimized implementations below. */
42 #define __STRING_SMALL_GET16(src, idx) \
43 (((src)[idx + 1] << 8) | (src)[idx])
44 #define __STRING_SMALL_GET32(src, idx) \
45 ((((src)[idx + 3] << 8 | (src)[idx + 2]) << 8 \
46 | (src)[idx + 1]) << 8 | (src)[idx])
47
48
49 /* Copy N bytes of SRC to DEST. */
50 #define _HAVE_STRING_ARCH_memcpy 1
51 #define memcpy(dest, src, n) \
52 (__extension__ (__builtin_constant_p (n) \
53 ? __memcpy_c (dest, src, n) \
54 : __memcpy_g (dest, src, n)))
55 #define __memcpy_c(dest, src, n) \
56 ((n) == 0 \
57 ? (dest) \
58 : (((n) % 4 == 0) \
59 ? __memcpy_by4 (dest, src, n) \
60 : (((n) % 2 == 0) \
61 ? __memcpy_by2 (dest, src, n) \
62 : __memcpy_g (dest, src, n))))
63
64 __STRING_INLINE void *__memcpy_by4 (void *__dest, __const void *__src,
65 size_t __n);
66
67 __STRING_INLINE void *
68 __memcpy_by4 (void *__dest, __const void *__src, size_t __n)
69 {
70 register unsigned long int __d0, __d1;
71 register void *__tmp = __dest;
72 __asm__ __volatile__
73 ("1:\n\t"
74 "movl (%2),%0\n\t"
75 "leal 4(%2),%2\n\t"
76 "movl %0,(%1)\n\t"
77 "leal 4(%1),%1\n\t"
78 "decl %3\n\t"
79 "jnz 1b"
80 : "=&r" (__d0), "=&r" (__tmp), "=&r" (__src), "=&r" (__d1)
81 : "1" (__tmp), "2" (__src), "3" (__n / 4)
82 : "memory", "cc");
83 return __dest;
84 }
85
86 __STRING_INLINE void *__memcpy_by2 (void *__dest, __const void *__src,
87 size_t __n);
88
89 __STRING_INLINE void *
90 __memcpy_by2 (void *__dest, __const void *__src, size_t __n)
91 {
92 register unsigned long int __d0, __d1;
93 register void *__tmp = __dest;
94 __asm__ __volatile__
95 ("shrl $1,%3\n\t"
96 "jz 2f\n" /* only a word */
97 "1:\n\t"
98 "movl (%2),%0\n\t"
99 "leal 4(%2),%2\n\t"
100 "movl %0,(%1)\n\t"
101 "leal 4(%1),%1\n\t"
102 "decl %3\n\t"
103 "jnz 1b\n"
104 "2:\n\t"
105 "movw (%2),%w0\n\t"
106 "movw %w0,(%1)"
107 : "=&q" (__d0), "=&r" (__tmp), "=&r" (__src), "=&r" (__d1)
108 : "1" (__tmp), "2" (__src), "3" (__n / 2)
109 : "memory", "cc");
110 return __dest;
111 }
112
113 __STRING_INLINE void *__memcpy_g (void *__dest, __const void *__src,
114 size_t __n);
115
116 __STRING_INLINE void *
117 __memcpy_g (void *__dest, __const void *__src, size_t __n)
118 {
119 register unsigned long int __d0, __d1, __d2;
120 register void *__tmp = __dest;
121 __asm__ __volatile__
122 ("cld\n\t"
123 "shrl $1,%%ecx\n\t"
124 "jnc 1f\n\t"
125 "movsb\n"
126 "1:\n\t"
127 "shrl $1,%%ecx\n\t"
128 "jnc 2f\n\t"
129 "movsw\n"
130 "2:\n\t"
131 "rep; movsl"
132 : "=&c" (__d0), "=&D" (__d1), "=&S" (__d2)
133 : "0" (__n), "1" (__tmp), "2" (__src)
134 : "memory", "cc");
135 return __dest;
136 }
137
138 #define _HAVE_STRING_ARCH_memmove 1
139 #ifndef _FORCE_INLINES
140 /* Copy N bytes of SRC to DEST, guaranteeing
141 correct behavior for overlapping strings. */
142 __STRING_INLINE void *
143 memmove (void *__dest, __const void *__src, size_t __n)
144 {
145 register unsigned long int __d0, __d1, __d2;
146 register void *__tmp = __dest;
147 if (__dest < __src)
148 __asm__ __volatile__
149 ("cld\n\t"
150 "rep; movsb"
151 : "=&c" (__d0), "=&S" (__d1), "=&D" (__d2)
152 : "0" (__n), "1" (__src), "2" (__tmp)
153 : "memory");
154 else
155 __asm__ __volatile__
156 ("std\n\t"
157 "rep; movsb\n\t"
158 "cld"
159 : "=&c" (__d0), "=&S" (__d1), "=&D" (__d2)
160 : "0" (__n), "1" (__n - 1 + (__const char *) __src),
161 "2" (__n - 1 + (char *) __tmp)
162 : "memory");
163 return __dest;
164 }
165 #endif
166
167 /* Compare N bytes of S1 and S2. */
168 #define _HAVE_STRING_ARCH_memcmp 1
169 #ifndef _FORCE_INLINES
170 # ifndef __PIC__
171 /* gcc has problems to spill registers when using PIC. */
172 __STRING_INLINE int
173 memcmp (__const void *__s1, __const void *__s2, size_t __n)
174 {
175 register unsigned long int __d0, __d1, __d2;
176 register int __res;
177 __asm__ __volatile__
178 ("cld\n\t"
179 "testl %3,%3\n\t"
180 "repe; cmpsb\n\t"
181 "je 1f\n\t"
182 "sbbl %0,%0\n\t"
183 "orl $1,%0\n"
184 "1:"
185 : "=a" (__res), "=&S" (__d0), "=&D" (__d1), "=&c" (__d2)
186 : "0" (0), "1" (__s1), "2" (__s2), "3" (__n)
187 : "cc");
188 return __res;
189 }
190 # endif
191 #endif
192
193 /* Set N bytes of S to C. */
194 #define _HAVE_STRING_ARCH_memset 1
195 #define memset(s, c, n) \
196 (__extension__ (__builtin_constant_p (n) && (n) <= 16 \
197 ? ((n) == 1 \
198 ? __memset_c1 (s, c) \
199 : __memset_gc (s, c, n)) \
200 : (__builtin_constant_p (c) \
201 ? (__builtin_constant_p (n) \
202 ? __memset_ccn (s, c, n) \
203 : memset (s, c, n)) \
204 : (__builtin_constant_p (n) \
205 ? __memset_gcn (s, c, n) \
206 : memset (s, c, n)))))
207
208 #define __memset_c1(s, c) ({ void *__s = (s); \
209 *((unsigned char *) __s) = (unsigned char) (c); \
210 __s; })
211
212 #define __memset_gc(s, c, n) \
213 ({ void *__s = (s); \
214 union { \
215 unsigned int __ui; \
216 unsigned short int __usi; \
217 unsigned char __uc; \
218 } *__u = __s; \
219 unsigned int __c = ((unsigned int) ((unsigned char) (c))) * 0x01010101; \
220 \
221 /* We apply a trick here. `gcc' would implement the following \
222 assignments using immediate operands. But this uses to much \
223 memory (7, instead of 4 bytes). So we force the value in a \
224 registers. */ \
225 if (n == 3 || n >= 5) \
226 __asm__ __volatile__ ("" : "=r" (__c) : "0" (__c)); \
227 \
228 /* This `switch' statement will be removed at compile-time. */ \
229 switch (n) \
230 { \
231 case 15: \
232 __u->__ui = __c; \
233 __u = __extension__ ((void *) __u + 4); \
234 case 11: \
235 __u->__ui = __c; \
236 __u = __extension__ ((void *) __u + 4); \
237 case 7: \
238 __u->__ui = __c; \
239 __u = __extension__ ((void *) __u + 4); \
240 case 3: \
241 __u->__usi = (unsigned short int) __c; \
242 __u = __extension__ ((void *) __u + 2); \
243 __u->__uc = (unsigned char) __c; \
244 break; \
245 \
246 case 14: \
247 __u->__ui = __c; \
248 __u = __extension__ ((void *) __u + 4); \
249 case 10: \
250 __u->__ui = __c; \
251 __u = __extension__ ((void *) __u + 4); \
252 case 6: \
253 __u->__ui = __c; \
254 __u = __extension__ ((void *) __u + 4); \
255 case 2: \
256 __u->__usi = (unsigned short int) __c; \
257 break; \
258 \
259 case 13: \
260 __u->__ui = __c; \
261 __u = __extension__ ((void *) __u + 4); \
262 case 9: \
263 __u->__ui = __c; \
264 __u = __extension__ ((void *) __u + 4); \
265 case 5: \
266 __u->__ui = __c; \
267 __u = __extension__ ((void *) __u + 4); \
268 case 1: \
269 __u->__uc = (unsigned char) __c; \
270 break; \
271 \
272 case 16: \
273 __u->__ui = __c; \
274 __u = __extension__ ((void *) __u + 4); \
275 case 12: \
276 __u->__ui = __c; \
277 __u = __extension__ ((void *) __u + 4); \
278 case 8: \
279 __u->__ui = __c; \
280 __u = __extension__ ((void *) __u + 4); \
281 case 4: \
282 __u->__ui = __c; \
283 case 0: \
284 break; \
285 } \
286 \
287 __s; })
288
289 #define __memset_ccn(s, c, n) \
290 (((n) % 4 == 0) \
291 ? __memset_ccn_by4 (s, ((unsigned int) ((unsigned char) (c))) * 0x01010101,\
292 n) \
293 : (((n) % 2 == 0) \
294 ? __memset_ccn_by2 (s, \
295 ((unsigned int) ((unsigned char) (c))) * 0x01010101,\
296 n) \
297 : memset (s, c, n)))
298
299 __STRING_INLINE void *__memset_ccn_by4 (void *__s, unsigned int __c,
300 size_t __n);
301
302 __STRING_INLINE void *
303 __memset_ccn_by4 (void *__s, unsigned int __c, size_t __n)
304 {
305 register void *__tmp = __s;
306 register unsigned long int __d0;
307 #ifdef __i686__
308 __asm__ __volatile__
309 ("cld\n\t"
310 "rep; stosl"
311 : "=&a" (__c), "=&D" (__tmp), "=&c" (__d0)
312 : "0" ((unsigned int) __c), "1" (__tmp), "2" (__n / 4)
313 : "memory", "cc");
314 #else
315 __asm__ __volatile__
316 ("1:\n\t"
317 "movl %0,(%1)\n\t"
318 "addl $4,%1\n\t"
319 "decl %2\n\t"
320 "jnz 1b\n"
321 : "=&r" (__c), "=&r" (__tmp), "=&r" (__d0)
322 : "0" ((unsigned int) __c), "1" (__tmp), "2" (__n / 4)
323 : "memory", "cc");
324 #endif
325 return __s;
326 }
327
328 __STRING_INLINE void *__memset_ccn_by2 (void *__s, unsigned int __c,
329 size_t __n);
330
331 __STRING_INLINE void *
332 __memset_ccn_by2 (void *__s, unsigned int __c, size_t __n)
333 {
334 register unsigned long int __d0, __d1;
335 register void *__tmp = __s;
336 #ifdef __i686__
337 __asm__ __volatile__
338 ("cld\n\t"
339 "rep; stosl\n"
340 "stosw"
341 : "=&a" (__d0), "=&D" (__tmp), "=&c" (__d1)
342 : "0" ((unsigned int) __c), "1" (__tmp), "2" (__n / 4)
343 : "memory", "cc");
344 #else
345 __asm__ __volatile__
346 ("1:\tmovl %0,(%1)\n\t"
347 "leal 4(%1),%1\n\t"
348 "decl %2\n\t"
349 "jnz 1b\n"
350 "movw %w0,(%1)"
351 : "=&q" (__d0), "=&r" (__tmp), "=&r" (__d1)
352 : "0" ((unsigned int) __c), "1" (__tmp), "2" (__n / 4)
353 : "memory", "cc");
354 #endif
355 return __s;
356 }
357
358 #define __memset_gcn(s, c, n) \
359 (((n) % 4 == 0) \
360 ? __memset_gcn_by4 (s, c, n) \
361 : (((n) % 2 == 0) \
362 ? __memset_gcn_by2 (s, c, n) \
363 : memset (s, c, n)))
364
365 __STRING_INLINE void *__memset_gcn_by4 (void *__s, int __c, size_t __n);
366
367 __STRING_INLINE void *
368 __memset_gcn_by4 (void *__s, int __c, size_t __n)
369 {
370 register void *__tmp = __s;
371 register unsigned long int __d0;
372 __asm__ __volatile__
373 ("movb %b0,%h0\n"
374 "pushw %w0\n\t"
375 "shll $16,%0\n\t"
376 "popw %w0\n"
377 "1:\n\t"
378 "movl %0,(%1)\n\t"
379 "addl $4,%1\n\t"
380 "decl %2\n\t"
381 "jnz 1b\n"
382 : "=&q" (__c), "=&r" (__tmp), "=&r" (__d0)
383 : "0" ((unsigned int) __c), "1" (__tmp), "2" (__n / 4)
384 : "memory", "cc");
385 return __s;
386 }
387
388 __STRING_INLINE void *__memset_gcn_by2 (void *__s, int __c, size_t __n);
389
390 __STRING_INLINE void *
391 __memset_gcn_by2 (void *__s, int __c, size_t __n)
392 {
393 register unsigned long int __d0, __d1;
394 register void *__tmp = __s;
395 __asm__ __volatile__
396 ("movb %b0,%h0\n\t"
397 "pushw %w0\n\t"
398 "shll $16,%0\n\t"
399 "popw %w0\n"
400 "1:\n\t"
401 "movl %0,(%1)\n\t"
402 "leal 4(%1),%1\n\t"
403 "decl %2\n\t"
404 "jnz 1b\n"
405 "movw %w0,(%1)"
406 : "=&q" (__d0), "=&r" (__tmp), "=&r" (__d1)
407 : "0" ((unsigned int) __c), "1" (__tmp), "2" (__n / 4)
408 : "memory", "cc");
409 return __s;
410 }
411
412
413 /* Search N bytes of S for C. */
414 #define _HAVE_STRING_ARCH_memchr 1
415 #ifndef _FORCE_INLINES
416 __STRING_INLINE void *
417 memchr (__const void *__s, int __c, size_t __n)
418 {
419 register unsigned long int __d0;
420 #ifdef __i686__
421 register unsigned long int __d1;
422 #endif
423 register unsigned char *__res;
424 if (__n == 0)
425 return NULL;
426 #ifdef __i686__
427 __asm__ __volatile__
428 ("cld\n\t"
429 "repne; scasb\n\t"
430 "cmovne %2,%0"
431 : "=D" (__res), "=&c" (__d0), "=&r" (__d1)
432 : "a" (__c), "0" (__s), "1" (__n), "2" (1)
433 : "cc");
434 #else
435 __asm__ __volatile__
436 ("cld\n\t"
437 "repne; scasb\n\t"
438 "je 1f\n\t"
439 "movl $1,%0\n"
440 "1:"
441 : "=D" (__res), "=&c" (__d0)
442 : "a" (__c), "0" (__s), "1" (__n)
443 : "cc");
444 #endif
445 return __res - 1;
446 }
447 #endif
448
449 #define _HAVE_STRING_ARCH_memrchr 1
450 #ifndef _FORCE_INLINES
451 __STRING_INLINE void *
452 __memrchr (__const void *__s, int __c, size_t __n)
453 {
454 register unsigned long int __d0;
455 # ifdef __i686__
456 register unsigned long int __d1;
457 # endif
458 register void *__res;
459 if (__n == 0)
460 return NULL;
461 # ifdef __i686__
462 __asm__ __volatile__
463 ("std\n\t"
464 "repne; scasb\n\t"
465 "cmovne %2,%0\n\t"
466 "cld"
467 : "=D" (__res), "=&c" (__d0), "=&r" (__d1)
468 : "a" (__c), "0" (__s + __n - 1), "1" (__n), "2" (-1)
469 : "cc");
470 # else
471 __asm__ __volatile__
472 ("std\n\t"
473 "repne; scasb\n\t"
474 "je 1f\n\t"
475 "orl $-1,%0\n"
476 "1:\tcld"
477 : "=D" (__res), "=&c" (__d0)
478 : "a" (__c), "0" (__s + __n - 1), "1" (__n)
479 : "cc");
480 # endif
481 return __res + 1;
482 }
483 # ifdef __USE_GNU
484 # define memrchr(s, c, n) __memrchr (s, c, n)
485 # endif
486 #endif
487
488 /* Return pointer to C in S. */
489 #define _HAVE_STRING_ARCH_rawmemchr 1
490 __STRING_INLINE void *__rawmemchr (const void *__s, int __c);
491
492 #ifndef _FORCE_INLINES
493 __STRING_INLINE void *
494 __rawmemchr (const void *__s, int __c)
495 {
496 register unsigned long int __d0;
497 register unsigned char *__res;
498 __asm__ __volatile__
499 ("cld\n\t"
500 "repne; scasb\n\t"
501 : "=D" (__res), "=&c" (__d0)
502 : "a" (__c), "0" (__s), "1" (0xffffffff)
503 : "cc");
504 return __res - 1;
505 }
506 # ifdef __USE_GNU
507 __STRING_INLINE void *
508 rawmemchr (const void *__s, int __c)
509 {
510 return __rawmemchr (__s, __c);
511 }
512 # endif /* use GNU */
513 #endif
514
515
516 /* Return the length of S. */
517 #define _HAVE_STRING_ARCH_strlen 1
518 #define strlen(str) \
519 (__extension__ (__builtin_constant_p (str) \
520 ? __builtin_strlen (str) \
521 : __strlen_g (str)))
522 __STRING_INLINE size_t __strlen_g (__const char *__str);
523
524 __STRING_INLINE size_t
525 __strlen_g (__const char *__str)
526 {
527 register char __dummy;
528 register __const char *__tmp = __str;
529 __asm__ __volatile__
530 ("1:\n\t"
531 "movb (%0),%b1\n\t"
532 "leal 1(%0),%0\n\t"
533 "testb %b1,%b1\n\t"
534 "jne 1b"
535 : "=r" (__tmp), "=&q" (__dummy)
536 : "0" (__str)
537 : "memory", "cc" );
538 return __tmp - __str - 1;
539 }
540
541
542 /* Copy SRC to DEST. */
543 #define _HAVE_STRING_ARCH_strcpy 1
544 #define strcpy(dest, src) \
545 (__extension__ (__builtin_constant_p (src) \
546 ? (sizeof ((src)[0]) == 1 && strlen (src) + 1 <= 8 \
547 ? __strcpy_small (dest, src, strlen (src) + 1) \
548 : (char *) memcpy ((char *) dest, \
549 (__const char *) src, \
550 strlen (src) + 1)) \
551 : __strcpy_g (dest, src)))
552
553 #define __strcpy_small(dest, src, srclen) \
554 (__extension__ ({ char *__dest = (dest); \
555 union { \
556 unsigned int __ui; \
557 unsigned short int __usi; \
558 unsigned char __uc; \
559 char __c; \
560 } *__u = (void *) __dest; \
561 switch (srclen) \
562 { \
563 case 1: \
564 __u->__uc = '\0'; \
565 break; \
566 case 2: \
567 __u->__usi = __STRING_SMALL_GET16 (src, 0); \
568 break; \
569 case 3: \
570 __u->__usi = __STRING_SMALL_GET16 (src, 0); \
571 __u = __extension__ ((void *) __u + 2); \
572 __u->__uc = '\0'; \
573 break; \
574 case 4: \
575 __u->__ui = __STRING_SMALL_GET32 (src, 0); \
576 break; \
577 case 5: \
578 __u->__ui = __STRING_SMALL_GET32 (src, 0); \
579 __u = __extension__ ((void *) __u + 4); \
580 __u->__uc = '\0'; \
581 break; \
582 case 6: \
583 __u->__ui = __STRING_SMALL_GET32 (src, 0); \
584 __u = __extension__ ((void *) __u + 4); \
585 __u->__usi = __STRING_SMALL_GET16 (src, 4); \
586 break; \
587 case 7: \
588 __u->__ui = __STRING_SMALL_GET32 (src, 0); \
589 __u = __extension__ ((void *) __u + 4); \
590 __u->__usi = __STRING_SMALL_GET16 (src, 4); \
591 __u = __extension__ ((void *) __u + 2); \
592 __u->__uc = '\0'; \
593 break; \
594 case 8: \
595 __u->__ui = __STRING_SMALL_GET32 (src, 0); \
596 __u = __extension__ ((void *) __u + 4); \
597 __u->__ui = __STRING_SMALL_GET32 (src, 4); \
598 break; \
599 } \
600 (char *) __dest; }))
601
602 __STRING_INLINE char *__strcpy_g (char *__dest, __const char *__src);
603
604 __STRING_INLINE char *
605 __strcpy_g (char *__dest, __const char *__src)
606 {
607 register char *__tmp = __dest;
608 register char __dummy;
609 __asm__ __volatile__
610 (
611 "1:\n\t"
612 "movb (%0),%b2\n\t"
613 "leal 1(%0),%0\n\t"
614 "movb %b2,(%1)\n\t"
615 "leal 1(%1),%1\n\t"
616 "testb %b2,%b2\n\t"
617 "jne 1b"
618 : "=&r" (__src), "=&r" (__tmp), "=&q" (__dummy)
619 : "0" (__src), "1" (__tmp)
620 : "memory", "cc");
621 return __dest;
622 }
623
624
625 #ifdef __USE_GNU
626 # define _HAVE_STRING_ARCH_stpcpy 1
627 /* Copy SRC to DEST. */
628 # define __stpcpy(dest, src) \
629 (__extension__ (__builtin_constant_p (src) \
630 ? (strlen (src) + 1 <= 8 \
631 ? __stpcpy_small (dest, src, strlen (src) + 1) \
632 : __stpcpy_c (dest, src, strlen (src) + 1)) \
633 : __stpcpy_g (dest, src)))
634 # define __stpcpy_c(dest, src, srclen) \
635 ((srclen) % 4 == 0 \
636 ? __mempcpy_by4 (dest, src, srclen) - 1 \
637 : ((srclen) % 2 == 0 \
638 ? __mempcpy_by2 (dest, src, srclen) - 1 \
639 : __mempcpy_byn (dest, src, srclen) - 1))
640
641 /* In glibc itself we use this symbol for namespace reasons. */
642 # define stpcpy(dest, src) __stpcpy (dest, src)
643
644 # define __stpcpy_small(dest, src, srclen) \
645 (__extension__ ({ union { \
646 unsigned int __ui; \
647 unsigned short int __usi; \
648 unsigned char __uc; \
649 char __c; \
650 } *__u = (void *) (dest); \
651 switch (srclen) \
652 { \
653 case 1: \
654 __u->__uc = '\0'; \
655 break; \
656 case 2: \
657 __u->__usi = __STRING_SMALL_GET16 (src, 0); \
658 __u = __extension__ ((void *) __u + 1); \
659 break; \
660 case 3: \
661 __u->__usi = __STRING_SMALL_GET16 (src, 0); \
662 __u = __extension__ ((void *) __u + 2); \
663 __u->__uc = '\0'; \
664 break; \
665 case 4: \
666 __u->__ui = __STRING_SMALL_GET32 (src, 0); \
667 __u = __extension__ ((void *) __u + 3); \
668 break; \
669 case 5: \
670 __u->__ui = __STRING_SMALL_GET32 (src, 0); \
671 __u = __extension__ ((void *) __u + 4); \
672 __u->__uc = '\0'; \
673 break; \
674 case 6: \
675 __u->__ui = __STRING_SMALL_GET32 (src, 0); \
676 __u = __extension__ ((void *) __u + 4); \
677 __u->__usi = __STRING_SMALL_GET16 (src, 4); \
678 __u = __extension__ ((void *) __u + 1); \
679 break; \
680 case 7: \
681 __u->__ui = __STRING_SMALL_GET32 (src, 0); \
682 __u = __extension__ ((void *) __u + 4); \
683 __u->__usi = __STRING_SMALL_GET16 (src, 4); \
684 __u = __extension__ ((void *) __u + 2); \
685 __u->__uc = '\0'; \
686 break; \
687 case 8: \
688 __u->__ui = __STRING_SMALL_GET32 (src, 0); \
689 __u = __extension__ ((void *) __u + 4); \
690 __u->__ui = __STRING_SMALL_GET32 (src, 4); \
691 __u = __extension__ ((void *) __u + 3); \
692 break; \
693 } \
694 (char *) __u; }))
695
696 __STRING_INLINE char *__mempcpy_by4 (char *__dest, __const char *__src,
697 size_t __srclen);
698
699 __STRING_INLINE char *
700 __mempcpy_by4 (char *__dest, __const char *__src, size_t __srclen)
701 {
702 register char *__tmp = __dest;
703 register unsigned long int __d0, __d1;
704 __asm__ __volatile__
705 ("1:\n\t"
706 "movl (%2),%0\n\t"
707 "leal 4(%2),%2\n\t"
708 "movl %0,(%1)\n\t"
709 "leal 4(%1),%1\n\t"
710 "decl %3\n\t"
711 "jnz 1b"
712 : "=&r" (__d0), "=r" (__tmp), "=&r" (__src), "=&r" (__d1)
713 : "1" (__tmp), "2" (__src), "3" (__srclen / 4)
714 : "memory", "cc");
715 return __tmp;
716 }
717
718 __STRING_INLINE char *__mempcpy_by2 (char *__dest, __const char *__src,
719 size_t __srclen);
720
721 __STRING_INLINE char *
722 __mempcpy_by2 (char *__dest, __const char *__src, size_t __srclen)
723 {
724 register char *__tmp = __dest;
725 register unsigned long int __d0, __d1;
726 __asm__ __volatile__
727 ("shrl $1,%3\n\t"
728 "jz 2f\n" /* only a word */
729 "1:\n\t"
730 "movl (%2),%0\n\t"
731 "leal 4(%2),%2\n\t"
732 "movl %0,(%1)\n\t"
733 "leal 4(%1),%1\n\t"
734 "decl %3\n\t"
735 "jnz 1b\n"
736 "2:\n\t"
737 "movw (%2),%w0\n\t"
738 "movw %w0,(%1)"
739 : "=&q" (__d0), "=r" (__tmp), "=&r" (__src), "=&r" (__d1)
740 : "1" (__tmp), "2" (__src), "3" (__srclen / 2)
741 : "memory", "cc");
742 return __tmp + 2;
743 }
744
745 __STRING_INLINE char *__mempcpy_byn (char *__dest, __const char *__src,
746 size_t __srclen);
747
748 __STRING_INLINE char *
749 __mempcpy_byn (char *__dest, __const char *__src, size_t __srclen)
750 {
751 register unsigned long __d0, __d1;
752 register char *__tmp = __dest;
753 __asm__ __volatile__
754 ("cld\n\t"
755 "shrl $1,%%ecx\n\t"
756 "jnc 1f\n\t"
757 "movsb\n"
758 "1:\n\t"
759 "shrl $1,%%ecx\n\t"
760 "jnc 2f\n\t"
761 "movsw\n"
762 "2:\n\t"
763 "rep; movsl"
764 : "=D" (__tmp), "=&c" (__d0), "=&S" (__d1)
765 : "0" (__tmp), "1" (__srclen), "2" (__src)
766 : "memory", "cc");
767 return __tmp;
768 }
769
770 __STRING_INLINE char *__stpcpy_g (char *__dest, __const char *__src);
771
772 __STRING_INLINE char *
773 __stpcpy_g (char *__dest, __const char *__src)
774 {
775 register char *__tmp = __dest;
776 register char __dummy;
777 __asm__ __volatile__
778 (
779 "1:\n\t"
780 "movb (%0),%b2\n\t"
781 "leal 1(%0),%0\n\t"
782 "movb %b2,(%1)\n\t"
783 "leal 1(%1),%1\n\t"
784 "testb %b2,%b2\n\t"
785 "jne 1b"
786 : "=&r" (__src), "=r" (__tmp), "=&q" (__dummy)
787 : "0" (__src), "1" (__tmp)
788 : "memory", "cc");
789 return __tmp - 1;
790 }
791 #endif
792
793
794 /* Copy no more than N characters of SRC to DEST. */
795 #define _HAVE_STRING_ARCH_strncpy 1
796 #define strncpy(dest, src, n) \
797 (__extension__ (__builtin_constant_p (src) \
798 ? ((strlen (src) + 1 >= ((size_t) (n)) \
799 ? (char *) memcpy ((char *) dest, \
800 (__const char *) src, n) \
801 : __strncpy_cg (dest, src, strlen (src) + 1, n))) \
802 : __strncpy_gg (dest, src, n)))
803 #define __strncpy_cg(dest, src, srclen, n) \
804 (((srclen) % 4 == 0) \
805 ? __strncpy_by4 (dest, src, srclen, n) \
806 : (((srclen) % 2 == 0) \
807 ? __strncpy_by2 (dest, src, srclen, n) \
808 : __strncpy_byn (dest, src, srclen, n)))
809
810 __STRING_INLINE char *__strncpy_by4 (char *__dest, __const char __src[],
811 size_t __srclen, size_t __n);
812
813 __STRING_INLINE char *
814 __strncpy_by4 (char *__dest, __const char __src[], size_t __srclen, size_t __n)
815 {
816 register char *__tmp = __dest;
817 register int __dummy1, __dummy2;
818 __asm__ __volatile__
819 ("1:\n\t"
820 "movl (%2),%0\n\t"
821 "leal 4(%2),%2\n\t"
822 "movl %0,(%1)\n\t"
823 "leal 4(%1),%1\n\t"
824 "decl %3\n\t"
825 "jnz 1b"
826 : "=&r" (__dummy1), "=r" (__tmp), "=&r" (__src), "=&r" (__dummy2)
827 : "1" (__tmp), "2" (__src), "3" (__srclen / 4)
828 : "memory", "cc");
829 (void) memset (__tmp, '\0', __n - __srclen);
830 return __dest;
831 }
832
833 __STRING_INLINE char *__strncpy_by2 (char *__dest, __const char __src[],
834 size_t __srclen, size_t __n);
835
836 __STRING_INLINE char *
837 __strncpy_by2 (char *__dest, __const char __src[], size_t __srclen, size_t __n)
838 {
839 register char *__tmp = __dest;
840 register int __dummy1, __dummy2;
841 __asm__ __volatile__
842 ("shrl $1,%3\n\t"
843 "jz 2f\n" /* only a word */
844 "1:\n\t"
845 "movl (%2),%0\n\t"
846 "leal 4(%2),%2\n\t"
847 "movl %0,(%1)\n\t"
848 "leal 4(%1),%1\n\t"
849 "decl %3\n\t"
850 "jnz 1b\n"
851 "2:\n\t"
852 "movw (%2),%w0\n\t"
853 "movw %w0,(%1)\n\t"
854 : "=&q" (__dummy1), "=r" (__tmp), "=&r" (__src), "=&r" (__dummy2)
855 : "1" (__tmp), "2" (__src), "3" (__srclen / 2)
856 : "memory", "cc");
857 (void) memset (__tmp + 2, '\0', __n - __srclen);
858 return __dest;
859 }
860
861 __STRING_INLINE char *__strncpy_byn (char *__dest, __const char __src[],
862 size_t __srclen, size_t __n);
863
864 __STRING_INLINE char *
865 __strncpy_byn (char *__dest, __const char __src[], size_t __srclen, size_t __n)
866 {
867 register unsigned long int __d0, __d1;
868 register char *__tmp = __dest;
869 __asm__ __volatile__
870 ("cld\n\t"
871 "shrl $1,%1\n\t"
872 "jnc 1f\n\t"
873 "movsb\n"
874 "1:\n\t"
875 "shrl $1,%1\n\t"
876 "jnc 2f\n\t"
877 "movsw\n"
878 "2:\n\t"
879 "rep; movsl"
880 : "=D" (__tmp), "=&c" (__d0), "=&S" (__d1)
881 : "1" (__srclen), "0" (__tmp),"2" (__src)
882 : "memory", "cc");
883 (void) memset (__tmp, '\0', __n - __srclen);
884 return __dest;
885 }
886
887 __STRING_INLINE char *__strncpy_gg (char *__dest, __const char *__src,
888 size_t __n);
889
890 __STRING_INLINE char *
891 __strncpy_gg (char *__dest, __const char *__src, size_t __n)
892 {
893 register char *__tmp = __dest;
894 register char __dummy;
895 if (__n > 0)
896 __asm__ __volatile__
897 ("1:\n\t"
898 "movb (%0),%2\n\t"
899 "incl %0\n\t"
900 "movb %2,(%1)\n\t"
901 "incl %1\n\t"
902 "decl %3\n\t"
903 "je 3f\n\t"
904 "testb %2,%2\n\t"
905 "jne 1b\n\t"
906 "2:\n\t"
907 "movb %2,(%1)\n\t"
908 "incl %1\n\t"
909 "decl %3\n\t"
910 "jne 2b\n\t"
911 "3:"
912 : "=&r" (__src), "=&r" (__tmp), "=&q" (__dummy), "=&r" (__n)
913 : "0" (__src), "1" (__tmp), "3" (__n)
914 : "memory", "cc");
915
916 return __dest;
917 }
918
919
920 /* Append SRC onto DEST. */
921 #define _HAVE_STRING_ARCH_strcat 1
922 #define strcat(dest, src) \
923 (__extension__ (__builtin_constant_p (src) \
924 ? __strcat_c (dest, src, strlen (src) + 1) \
925 : __strcat_g (dest, src)))
926
927 __STRING_INLINE char *__strcat_c (char *__dest, __const char __src[],
928 size_t __srclen);
929
930 __STRING_INLINE char *
931 __strcat_c (char *__dest, __const char __src[], size_t __srclen)
932 {
933 #ifdef __i686__
934 register unsigned long int __d0;
935 register char *__tmp;
936 __asm__ __volatile__
937 ("repne; scasb"
938 : "=D" (__tmp), "=&c" (__d0)
939 : "0" (__dest), "1" (0xffffffff), "a" (0)
940 : "cc");
941 --__tmp;
942 #else
943 register char *__tmp = __dest - 1;
944 __asm__ __volatile__
945 ("1:\n\t"
946 "incl %0\n\t"
947 "cmpb $0,(%0)\n\t"
948 "jne 1b\n"
949 : "=r" (__tmp)
950 : "0" (__tmp)
951 : "cc");
952 #endif
953 (void) memcpy (__tmp, __src, __srclen);
954 return __dest;
955 }
956
957 __STRING_INLINE char *__strcat_g (char *__dest, __const char *__src);
958
959 __STRING_INLINE char *
960 __strcat_g (char *__dest, __const char *__src)
961 {
962 register char *__tmp = __dest - 1;
963 register char __dummy;
964 __asm__ __volatile__
965 ("1:\n\t"
966 "incl %1\n\t"
967 "cmpb $0,(%1)\n\t"
968 "jne 1b\n"
969 "2:\n\t"
970 "movb (%2),%b0\n\t"
971 "incl %2\n\t"
972 "movb %b0,(%1)\n\t"
973 "incl %1\n\t"
974 "testb %b0,%b0\n\t"
975 "jne 2b\n"
976 : "=&q" (__dummy), "=&r" (__tmp), "=&r" (__src)
977 : "1" (__tmp), "2" (__src)
978 : "memory", "cc");
979 return __dest;
980 }
981
982
983 /* Append no more than N characters from SRC onto DEST. */
984 #define _HAVE_STRING_ARCH_strncat 1
985 #define strncat(dest, src, n) \
986 (__extension__ ({ char *__dest = (dest); \
987 __builtin_constant_p (src) && __builtin_constant_p (n) \
988 ? (strlen (src) < ((size_t) (n)) \
989 ? strcat (__dest, src) \
990 : (memcpy (strchr (__dest, '\0'), \
991 (__const char *) src, n), __dest)) \
992 : __strncat_g (__dest, src, n); }))
993
994 __STRING_INLINE char *__strncat_g (char *__dest, __const char __src[],
995 size_t __n);
996
997 __STRING_INLINE char *
998 __strncat_g (char *__dest, __const char __src[], size_t __n)
999 {
1000 register char *__tmp = __dest;
1001 register char __dummy;
1002 #ifdef __i686__
1003 __asm__ __volatile__
1004 ("repne; scasb\n"
1005 "decl %1\n\t"
1006 "1:\n\t"
1007 "decl %3\n\t"
1008 "js 2f\n\t"
1009 "movb (%2),%b0\n\t"
1010 "movsb\n\t"
1011 "testb %b0,%b0\n\t"
1012 "jne 1b\n\t"
1013 "decl %1\n"
1014 "2:\n\t"
1015 "movb $0,(%1)"
1016 : "=&a" (__dummy), "=&D" (__tmp), "=&S" (__src), "=&r" (__n)
1017 : "0" (0), "1" (__tmp), "2" (__src), "3" (__n)
1018 : "memory", "cc");
1019 #else
1020 --__tmp;
1021 __asm__ __volatile__
1022 ("1:\n\t"
1023 "cmpb $0,1(%1)\n\t"
1024 "leal 1(%1),%1\n\t"
1025 "jne 1b\n"
1026 "2:\n\t"
1027 "decl %3\n\t"
1028 "js 3f\n\t"
1029 "movb (%2),%b0\n\t"
1030 "leal 1(%2),%2\n\t"
1031 "movb %b0,(%1)\n\t"
1032 "leal 1(%1),%1\n\t"
1033 "testb %b0,%b0\n\t"
1034 "jne 2b\n\t"
1035 "decl %1\n"
1036 "3:\n\t"
1037 "movb $0,(%1)"
1038 : "=&q" (__dummy), "=&r" (__tmp), "=&r" (__src), "=&r" (__n)
1039 : "1" (__tmp), "2" (__src), "3" (__n)
1040 : "memory", "cc");
1041 #endif
1042 return __dest;
1043 }
1044
1045
1046 /* Compare S1 and S2. */
1047 #define _HAVE_STRING_ARCH_strcmp 1
1048 #define strcmp(s1, s2) \
1049 (__extension__ (__builtin_constant_p (s1) && __builtin_constant_p (s2) \
1050 && (sizeof ((s1)[0]) != 1 || strlen (s1) >= 4) \
1051 && (sizeof ((s2)[0]) != 1 || strlen (s2) >= 4) \
1052 ? memcmp ((__const char *) s1, (__const char *) s2, \
1053 (strlen (s1) < strlen (s2) \
1054 ? strlen (s1) : strlen (s2)) + 1) \
1055 : (__builtin_constant_p (s1) && sizeof ((s1)[0]) == 1 \
1056 && sizeof ((s2)[0]) == 1 && strlen (s1) < 4 \
1057 ? (__builtin_constant_p (s2) && sizeof ((s2)[0]) == 1 \
1058 ? __strcmp_cc (s1, s2, strlen (s1)) \
1059 : __strcmp_cg (s1, s2, strlen (s1))) \
1060 : (__builtin_constant_p (s2) && sizeof ((s1)[0]) == 1 \
1061 && sizeof ((s2)[0]) == 1 && strlen (s2) < 4 \
1062 ? (__builtin_constant_p (s1) \
1063 ? __strcmp_cc (s1, s2, strlen (s2)) \
1064 : __strcmp_gc (s1, s2, strlen (s2))) \
1065 : __strcmp_gg (s1, s2)))))
1066
1067 #define __strcmp_cc(s1, s2, l) \
1068 (__extension__ ({ register int __result = ((unsigned char) (s1)[0] \
1069 - (unsigned char) (s2)[0]); \
1070 if (l > 0 && __result == 0) \
1071 { \
1072 __result = ((unsigned char) (s1)[1] \
1073 - (unsigned char) (s2)[1]); \
1074 if (l > 1 && __result == 0) \
1075 { \
1076 __result = ((unsigned char) (s1)[2] \
1077 - (unsigned char) (s2)[2]); \
1078 if (l > 2 && __result == 0) \
1079 __result = ((unsigned char) (s1)[3] \
1080 - (unsigned char) (s2)[3]); \
1081 } \
1082 } \
1083 __result; }))
1084
1085 #define __strcmp_cg(s1, s2, l1) \
1086 (__extension__ ({ __const unsigned char *__s2 = (unsigned char *) (s2); \
1087 register int __result = (unsigned char) (s1)[0] - __s2[0];\
1088 if (l1 > 0 && __result == 0) \
1089 { \
1090 __result = (unsigned char) (s1)[1] - __s2[1]; \
1091 if (l1 > 1 && __result == 0) \
1092 { \
1093 __result = (unsigned char) (s1)[2] - __s2[2]; \
1094 if (l1 > 2 && __result == 0) \
1095 __result = (unsigned char) (s1)[3] - __s2[3]; \
1096 } \
1097 } \
1098 __result; }))
1099
1100 #define __strcmp_gc(s1, s2, l2) \
1101 (__extension__ ({ __const unsigned char *__s1 = (unsigned char *) (s1); \
1102 register int __result = __s1[0] - (unsigned char) (s2)[0];\
1103 if (l2 > 0 && __result == 0) \
1104 { \
1105 __result = __s1[1] - (unsigned char) (s2)[1]; \
1106 if (l2 > 1 && __result == 0) \
1107 { \
1108 __result = __s1[2] - (unsigned char) (s2)[2]; \
1109 if (l2 > 2 && __result == 0) \
1110 __result = __s1[3] - (unsigned char) (s2)[3]; \
1111 } \
1112 } \
1113 __result; }))
1114
1115 __STRING_INLINE int __strcmp_gg (__const char *__s1, __const char *__s2);
1116
1117 __STRING_INLINE int
1118 __strcmp_gg (__const char *__s1, __const char *__s2)
1119 {
1120 register int __res;
1121 __asm__ __volatile__
1122 ("1:\n\t"
1123 "movb (%1),%b0\n\t"
1124 "leal 1(%1),%1\n\t"
1125 "cmpb %b0,(%2)\n\t"
1126 "jne 2f\n\t"
1127 "leal 1(%2),%2\n\t"
1128 "testb %b0,%b0\n\t"
1129 "jne 1b\n\t"
1130 "xorl %0,%0\n\t"
1131 "jmp 3f\n"
1132 "2:\n\t"
1133 "movl $1,%0\n\t"
1134 "jb 3f\n\t"
1135 "negl %0\n"
1136 "3:"
1137 : "=q" (__res), "=&r" (__s1), "=&r" (__s2)
1138 : "1" (__s1), "2" (__s2)
1139 : "cc");
1140 return __res;
1141 }
1142
1143
1144 /* Compare N characters of S1 and S2. */
1145 #define _HAVE_STRING_ARCH_strncmp 1
1146 #define strncmp(s1, s2, n) \
1147 (__extension__ (__builtin_constant_p (s1) && strlen (s1) < ((size_t) (n)) \
1148 ? strcmp (s1, s2) \
1149 : (__builtin_constant_p (s2) && strlen (s2) < ((size_t) (n))\
1150 ? strcmp (s1, s2) \
1151 : __strncmp_g (s1, s2, n))))
1152
1153 __STRING_INLINE int __strncmp_g (__const char *__s1, __const char *__s2,
1154 size_t __n);
1155
1156 __STRING_INLINE int
1157 __strncmp_g (__const char *__s1, __const char *__s2, size_t __n)
1158 {
1159 register int __res;
1160 __asm__ __volatile__
1161 ("1:\n\t"
1162 "decl %3\n\t"
1163 "js 2f\n\t"
1164 "movb (%1),%b0\n\t"
1165 "incl %1\n\t"
1166 "cmpb %b0,(%2)\n\t"
1167 "jne 3f\n\t"
1168 "incl %2\n\t"
1169 "testb %b0,%b0\n\t"
1170 "jne 1b\n"
1171 "2:\n\t"
1172 "xorl %0,%0\n\t"
1173 "jmp 4f\n"
1174 "3:\n\t"
1175 "movl $1,%0\n\t"
1176 "jb 4f\n\t"
1177 "negl %0\n"
1178 "4:"
1179 : "=q" (__res), "=&r" (__s1), "=&r" (__s2), "=&r" (__n)
1180 : "1" (__s1), "2" (__s2), "3" (__n)
1181 : "cc");
1182 return __res;
1183 }
1184
1185
1186 /* Find the first occurrence of C in S. */
1187 #define _HAVE_STRING_ARCH_strchr 1
1188 #define strchr(s, c) \
1189 (__extension__ (__builtin_constant_p (c) \
1190 ? ((c) == '\0' \
1191 ? (char *) __rawmemchr (s, c) \
1192 : __strchr_c (s, ((c) & 0xff) << 8)) \
1193 : __strchr_g (s, c)))
1194
1195 __STRING_INLINE char *__strchr_c (__const char *__s, int __c);
1196
1197 __STRING_INLINE char *
1198 __strchr_c (__const char *__s, int __c)
1199 {
1200 register unsigned long int __d0;
1201 register char *__res;
1202 __asm__ __volatile__
1203 ("1:\n\t"
1204 "movb (%0),%%al\n\t"
1205 "cmpb %%ah,%%al\n\t"
1206 "je 2f\n\t"
1207 "leal 1(%0),%0\n\t"
1208 "testb %%al,%%al\n\t"
1209 "jne 1b\n\t"
1210 "xorl %0,%0\n"
1211 "2:"
1212 : "=r" (__res), "=&a" (__d0)
1213 : "0" (__s), "1" (__c)
1214 : "cc");
1215 return __res;
1216 }
1217
1218 __STRING_INLINE char *__strchr_g (__const char *__s, int __c);
1219
1220 __STRING_INLINE char *
1221 __strchr_g (__const char *__s, int __c)
1222 {
1223 register unsigned long int __d0;
1224 register char *__res;
1225 __asm__ __volatile__
1226 ("movb %%al,%%ah\n"
1227 "1:\n\t"
1228 "movb (%0),%%al\n\t"
1229 "cmpb %%ah,%%al\n\t"
1230 "je 2f\n\t"
1231 "leal 1(%0),%0\n\t"
1232 "testb %%al,%%al\n\t"
1233 "jne 1b\n\t"
1234 "xorl %0,%0\n"
1235 "2:"
1236 : "=r" (__res), "=&a" (__d0)
1237 : "0" (__s), "1" (__c)
1238 : "cc");
1239 return __res;
1240 }
1241
1242
1243 /* Find the first occurrence of C in S or the final NUL byte. */
1244 #define _HAVE_STRING_ARCH_strchrnul 1
1245 #define __strchrnul(s, c) \
1246 (__extension__ (__builtin_constant_p (c) \
1247 ? ((c) == '\0' \
1248 ? (char *) __rawmemchr (s, c) \
1249 : __strchrnul_c (s, ((c) & 0xff) << 8)) \
1250 : __strchrnul_g (s, c)))
1251
1252 __STRING_INLINE char *__strchrnul_c (__const char *__s, int __c);
1253
1254 __STRING_INLINE char *
1255 __strchrnul_c (__const char *__s, int __c)
1256 {
1257 register unsigned long int __d0;
1258 register char *__res;
1259 __asm__ __volatile__
1260 ("1:\n\t"
1261 "movb (%0),%%al\n\t"
1262 "cmpb %%ah,%%al\n\t"
1263 "je 2f\n\t"
1264 "leal 1(%0),%0\n\t"
1265 "testb %%al,%%al\n\t"
1266 "jne 1b\n\t"
1267 "decl %0\n"
1268 "2:"
1269 : "=r" (__res), "=&a" (__d0)
1270 : "0" (__s), "1" (__c)
1271 : "cc");
1272 return __res;
1273 }
1274
1275 __STRING_INLINE char *__strchrnul_g (__const char *__s, int __c);
1276
1277 __STRING_INLINE char *
1278 __strchrnul_g (__const char *__s, int __c)
1279 {
1280 register unsigned long int __d0;
1281 register char *__res;
1282 __asm__ __volatile__
1283 ("movb %%al,%%ah\n"
1284 "1:\n\t"
1285 "movb (%0),%%al\n\t"
1286 "cmpb %%ah,%%al\n\t"
1287 "je 2f\n\t"
1288 "leal 1(%0),%0\n\t"
1289 "testb %%al,%%al\n\t"
1290 "jne 1b\n\t"
1291 "decl %0\n"
1292 "2:"
1293 : "=r" (__res), "=&a" (__d0)
1294 : "0" (__s), "1" (__c)
1295 : "cc");
1296 return __res;
1297 }
1298 #ifdef __USE_GNU
1299 # define strchrnul(s, c) __strchrnul (s, c)
1300 #endif
1301
1302
1303 #if defined __USE_BSD || defined __USE_XOPEN_EXTENDED
1304 /* Find the first occurrence of C in S. This is the BSD name. */
1305 # define _HAVE_STRING_ARCH_index 1
1306 # define index(s, c) \
1307 (__extension__ (__builtin_constant_p (c) \
1308 ? __strchr_c (s, ((c) & 0xff) << 8) \
1309 : __strchr_g (s, c)))
1310 #endif
1311
1312
1313 /* Find the last occurrence of C in S. */
1314 #define _HAVE_STRING_ARCH_strrchr 1
1315 #define strrchr(s, c) \
1316 (__extension__ (__builtin_constant_p (c) \
1317 ? __strrchr_c (s, ((c) & 0xff) << 8) \
1318 : __strrchr_g (s, c)))
1319
1320 #ifdef __i686__
1321 __STRING_INLINE char *__strrchr_c (__const char *__s, int __c);
1322
1323 __STRING_INLINE char *
1324 __strrchr_c (__const char *__s, int __c)
1325 {
1326 register unsigned long int __d0, __d1;
1327 register char *__res;
1328 __asm__ __volatile__
1329 ("cld\n"
1330 "1:\n\t"
1331 "lodsb\n\t"
1332 "cmpb %h2,%b2\n\t"
1333 "cmove %1,%0\n\t"
1334 "testb %b2,%b2\n\t"
1335 "jne 1b"
1336 : "=d" (__res), "=&S" (__d0), "=&a" (__d1)
1337 : "0" (1), "1" (__s), "2" (__c)
1338 : "cc");
1339 return __res - 1;
1340 }
1341
1342 __STRING_INLINE char *__strrchr_g (__const char *__s, int __c);
1343
1344 __STRING_INLINE char *
1345 __strrchr_g (__const char *__s, int __c)
1346 {
1347 register unsigned long int __d0, __d1;
1348 register char *__res;
1349 __asm__ __volatile__
1350 ("movb %b2,%h2\n"
1351 "cld\n\t"
1352 "1:\n\t"
1353 "lodsb\n\t"
1354 "cmpb %h2,%b2\n\t"
1355 "cmove %1,%0\n\t"
1356 "testb %b2,%b2\n\t"
1357 "jne 1b"
1358 : "=d" (__res), "=&S" (__d0), "=&a" (__d1)
1359 : "0" (1), "1" (__s), "2" (__c)
1360 : "cc");
1361 return __res - 1;
1362 }
1363 #else
1364 __STRING_INLINE char *__strrchr_c (__const char *__s, int __c);
1365
1366 __STRING_INLINE char *
1367 __strrchr_c (__const char *__s, int __c)
1368 {
1369 register unsigned long int __d0, __d1;
1370 register char *__res;
1371 __asm__ __volatile__
1372 ("cld\n"
1373 "1:\n\t"
1374 "lodsb\n\t"
1375 "cmpb %%ah,%%al\n\t"
1376 "jne 2f\n\t"
1377 "leal -1(%%esi),%0\n"
1378 "2:\n\t"
1379 "testb %%al,%%al\n\t"
1380 "jne 1b"
1381 : "=d" (__res), "=&S" (__d0), "=&a" (__d1)
1382 : "0" (0), "1" (__s), "2" (__c)
1383 : "cc");
1384 return __res;
1385 }
1386
1387 __STRING_INLINE char *__strrchr_g (__const char *__s, int __c);
1388
1389 __STRING_INLINE char *
1390 __strrchr_g (__const char *__s, int __c)
1391 {
1392 register unsigned long int __d0, __d1;
1393 register char *__res;
1394 __asm__ __volatile__
1395 ("movb %%al,%%ah\n"
1396 "cld\n\t"
1397 "1:\n\t"
1398 "lodsb\n\t"
1399 "cmpb %%ah,%%al\n\t"
1400 "jne 2f\n\t"
1401 "leal -1(%%esi),%0\n"
1402 "2:\n\t"
1403 "testb %%al,%%al\n\t"
1404 "jne 1b"
1405 : "=r" (__res), "=&S" (__d0), "=&a" (__d1)
1406 : "0" (0), "1" (__s), "2" (__c)
1407 : "cc");
1408 return __res;
1409 }
1410 #endif
1411
1412
1413 #if defined __USE_BSD || defined __USE_XOPEN_EXTENDED
1414 /* Find the last occurrence of C in S. This is the BSD name. */
1415 # define _HAVE_STRING_ARCH_rindex 1
1416 # define rindex(s, c) \
1417 (__extension__ (__builtin_constant_p (c) \
1418 ? __strrchr_c (s, ((c) & 0xff) << 8) \
1419 : __strrchr_g (s, c)))
1420 #endif
1421
1422
1423 /* Return the length of the initial segment of S which
1424 consists entirely of characters not in REJECT. */
1425 #define _HAVE_STRING_ARCH_strcspn 1
1426 #define strcspn(s, reject) \
1427 (__extension__ (__builtin_constant_p (reject) && sizeof ((reject)[0]) == 1 \
1428 ? ((reject)[0] == '\0' \
1429 ? strlen (s) \
1430 : ((reject)[1] == '\0' \
1431 ? __strcspn_c1 (s, (((reject)[0] << 8) & 0xff00)) \
1432 : __strcspn_cg (s, reject, strlen (reject)))) \
1433 : __strcspn_g (s, reject)))
1434
1435 __STRING_INLINE size_t __strcspn_c1 (__const char *__s, int __reject);
1436
1437 __STRING_INLINE size_t
1438 __strcspn_c1 (__const char *__s, int __reject)
1439 {
1440 register unsigned long int __d0;
1441 register char *__res;
1442 __asm__ __volatile__
1443 ("1:\n\t"
1444 "movb (%0),%%al\n\t"
1445 "leal 1(%0),%0\n\t"
1446 "cmpb %%ah,%%al\n\t"
1447 "je 2f\n\t"
1448 "testb %%al,%%al\n\t"
1449 "jne 1b\n"
1450 "2:"
1451 : "=r" (__res), "=&a" (__d0)
1452 : "0" (__s), "1" (__reject)
1453 : "cc");
1454 return (__res - 1) - __s;
1455 }
1456
1457 __STRING_INLINE size_t __strcspn_cg (__const char *__s, __const char __reject[],
1458 size_t __reject_len);
1459
1460 __STRING_INLINE size_t
1461 __strcspn_cg (__const char *__s, __const char __reject[], size_t __reject_len)
1462 {
1463 register unsigned long int __d0, __d1, __d2;
1464 register __const char *__res;
1465 __asm__ __volatile__
1466 ("cld\n"
1467 "1:\n\t"
1468 "lodsb\n\t"
1469 "testb %%al,%%al\n\t"
1470 "je 2f\n\t"
1471 "movl %5,%%edi\n\t"
1472 "movl %6,%%ecx\n\t"
1473 "repne; scasb\n\t"
1474 "jne 1b\n"
1475 "2:"
1476 : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2)
1477 : "0" (__s), "d" (__reject), "g" (__reject_len)
1478 : "cc");
1479 return (__res - 1) - __s;
1480 }
1481
1482 __STRING_INLINE size_t __strcspn_g (__const char *__s, __const char *__reject);
1483 #ifdef __PIC__
1484
1485 __STRING_INLINE size_t
1486 __strcspn_g (__const char *__s, __const char *__reject)
1487 {
1488 register unsigned long int __d0, __d1, __d2;
1489 register __const char *__res;
1490 __asm__ __volatile__
1491 ("pushl %%ebx\n\t"
1492 "movl %4,%%edi\n\t"
1493 "cld\n\t"
1494 "repne; scasb\n\t"
1495 "notl %%ecx\n\t"
1496 "leal -1(%%ecx),%%ebx\n"
1497 "1:\n\t"
1498 "lodsb\n\t"
1499 "testb %%al,%%al\n\t"
1500 "je 2f\n\t"
1501 "movl %4,%%edi\n\t"
1502 "movl %%ebx,%%ecx\n\t"
1503 "repne; scasb\n\t"
1504 "jne 1b\n"
1505 "2:\n\t"
1506 "popl %%ebx"
1507 : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2)
1508 : "r" (__reject), "0" (__s), "1" (0), "2" (0xffffffff)
1509 : "cc");
1510 return (__res - 1) - __s;
1511 }
1512 #else
1513 __STRING_INLINE size_t
1514 __strcspn_g (__const char *__s, __const char *__reject)
1515 {
1516 register unsigned long int __d0, __d1, __d2, __d3;
1517 register __const char *__res;
1518 __asm__ __volatile__
1519 ("cld\n\t"
1520 "repne; scasb\n\t"
1521 "notl %%ecx\n\t"
1522 "leal -1(%%ecx),%%edx\n"
1523 "1:\n\t"
1524 "lodsb\n\t"
1525 "testb %%al,%%al\n\t"
1526 "je 2f\n\t"
1527 "movl %%ebx,%%edi\n\t"
1528 "movl %%edx,%%ecx\n\t"
1529 "repne; scasb\n\t"
1530 "jne 1b\n"
1531 "2:"
1532 : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2), "=&d" (__d3)
1533 : "0" (__s), "1" (0), "2" (0xffffffff), "3" (__reject), "b" (__reject)
1534 : "cc");
1535 return (__res - 1) - __s;
1536 }
1537 #endif
1538
1539
1540 /* Return the length of the initial segment of S which
1541 consists entirely of characters in ACCEPT. */
1542 #define _HAVE_STRING_ARCH_strspn 1
1543 #define strspn(s, accept) \
1544 (__extension__ (__builtin_constant_p (accept) && sizeof ((accept)[0]) == 1 \
1545 ? ((accept)[0] == '\0' \
1546 ? 0 \
1547 : ((accept)[1] == '\0' \
1548 ? __strspn_c1 (s, (((accept)[0] << 8 ) & 0xff00)) \
1549 : __strspn_cg (s, accept, strlen (accept)))) \
1550 : __strspn_g (s, accept)))
1551
1552 __STRING_INLINE size_t __strspn_c1 (__const char *__s, int __accept);
1553
1554 __STRING_INLINE size_t
1555 __strspn_c1 (__const char *__s, int __accept)
1556 {
1557 register unsigned long int __d0;
1558 register char *__res;
1559 /* Please note that __accept never can be '\0'. */
1560 __asm__ __volatile__
1561 ("1:\n\t"
1562 "movb (%0),%b1\n\t"
1563 "leal 1(%0),%0\n\t"
1564 "cmpb %h1,%b1\n\t"
1565 "je 1b"
1566 : "=r" (__res), "=&q" (__d0)
1567 : "0" (__s), "1" (__accept)
1568 : "cc");
1569 return (__res - 1) - __s;
1570 }
1571
1572 __STRING_INLINE size_t __strspn_cg (__const char *__s, __const char __accept[],
1573 size_t __accept_len);
1574
1575 __STRING_INLINE size_t
1576 __strspn_cg (__const char *__s, __const char __accept[], size_t __accept_len)
1577 {
1578 register unsigned long int __d0, __d1, __d2;
1579 register __const char *__res;
1580 __asm__ __volatile__
1581 ("cld\n"
1582 "1:\n\t"
1583 "lodsb\n\t"
1584 "testb %%al,%%al\n\t"
1585 "je 2f\n\t"
1586 "movl %1,%%edi\n\t"
1587 "movl %6,%%ecx\n\t"
1588 "repne; scasb\n\t"
1589 "je 1b\n"
1590 "2:"
1591 : "=S" (__res), "=&d" (__d0), "=&c" (__d1), "=&D" (__d2)
1592 : "0" (__s), "1" (__accept), "g" (__accept_len)
1593 : "cc");
1594 return (__res - 1) - __s;
1595 }
1596
1597 __STRING_INLINE size_t __strspn_g (__const char *__s, __const char *__accept);
1598 #ifdef __PIC__
1599
1600 __STRING_INLINE size_t
1601 __strspn_g (__const char *__s, __const char *__accept)
1602 {
1603 register unsigned long int __d0, __d1, __d2;
1604 register __const char *__res;
1605 __asm__ __volatile__
1606 ("pushl %%ebx\n\t"
1607 "cld\n\t"
1608 "repne; scasb\n\t"
1609 "notl %%ecx\n\t"
1610 "leal -1(%%ecx),%%ebx\n"
1611 "1:\n\t"
1612 "lodsb\n\t"
1613 "testb %%al,%%al\n\t"
1614 "je 2f\n\t"
1615 "movl %%edx,%%edi\n\t"
1616 "movl %%ebx,%%ecx\n\t"
1617 "repne; scasb\n\t"
1618 "je 1b\n"
1619 "2:\n\t"
1620 "popl %%ebx"
1621 : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2)
1622 : "d" (__accept), "0" (__s), "1" (0), "2" (0xffffffff), "3" (__accept)
1623 : "cc");
1624 return (__res - 1) - __s;
1625 }
1626 #else
1627 __STRING_INLINE size_t
1628 __strspn_g (__const char *__s, __const char *__accept)
1629 {
1630 register unsigned long int __d0, __d1, __d2, __d3;
1631 register __const char *__res;
1632 __asm__ __volatile__
1633 ("cld\n\t"
1634 "repne; scasb\n\t"
1635 "notl %%ecx\n\t"
1636 "leal -1(%%ecx),%%edx\n"
1637 "1:\n\t"
1638 "lodsb\n\t"
1639 "testb %%al,%%al\n\t"
1640 "je 2f\n\t"
1641 "movl %%ebx,%%edi\n\t"
1642 "movl %%edx,%%ecx\n\t"
1643 "repne; scasb\n\t"
1644 "je 1b\n"
1645 "2:"
1646 : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2), "=&d" (__d3)
1647 : "0" (__s), "1" (0), "2" (0xffffffff), "3" (__accept), "b" (__accept)
1648 : "cc");
1649 return (__res - 1) - __s;
1650 }
1651 #endif
1652
1653
1654 /* Find the first occurrence in S of any character in ACCEPT. */
1655 #define _HAVE_STRING_ARCH_strpbrk 1
1656 #define strpbrk(s, accept) \
1657 (__extension__ (__builtin_constant_p (accept) && sizeof ((accept)[0]) == 1 \
1658 ? ((accept)[0] == '\0' \
1659 ? NULL \
1660 : ((accept)[1] == '\0' \
1661 ? strchr (s, (accept)[0]) \
1662 : __strpbrk_cg (s, accept, strlen (accept)))) \
1663 : __strpbrk_g (s, accept)))
1664
1665 __STRING_INLINE char *__strpbrk_cg (__const char *__s, __const char __accept[],
1666 size_t __accept_len);
1667
1668 __STRING_INLINE char *
1669 __strpbrk_cg (__const char *__s, __const char __accept[], size_t __accept_len)
1670 {
1671 register unsigned long int __d0, __d1, __d2;
1672 register char *__res;
1673 __asm__ __volatile__
1674 ("cld\n"
1675 "1:\n\t"
1676 "lodsb\n\t"
1677 "testb %%al,%%al\n\t"
1678 "je 2f\n\t"
1679 "movl %5,%%edi\n\t"
1680 "movl %6,%%ecx\n\t"
1681 "repne; scasb\n\t"
1682 "jne 1b\n\t"
1683 "decl %0\n\t"
1684 "jmp 3f\n"
1685 "2:\n\t"
1686 "xorl %0,%0\n"
1687 "3:"
1688 : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2)
1689 : "0" (__s), "d" (__accept), "g" (__accept_len)
1690 : "cc");
1691 return __res;
1692 }
1693
1694 __STRING_INLINE char *__strpbrk_g (__const char *__s, __const char *__accept);
1695 #ifdef __PIC__
1696
1697 __STRING_INLINE char *
1698 __strpbrk_g (__const char *__s, __const char *__accept)
1699 {
1700 register unsigned long int __d0, __d1, __d2;
1701 register char *__res;
1702 __asm__ __volatile__
1703 ("pushl %%ebx\n\t"
1704 "movl %%edx,%%edi\n\t"
1705 "cld\n\t"
1706 "repne; scasb\n\t"
1707 "notl %%ecx\n\t"
1708 "leal -1(%%ecx),%%ebx\n"
1709 "1:\n\t"
1710 "lodsb\n\t"
1711 "testb %%al,%%al\n\t"
1712 "je 2f\n\t"
1713 "movl %%edx,%%edi\n\t"
1714 "movl %%ebx,%%ecx\n\t"
1715 "repne; scasb\n\t"
1716 "jne 1b\n\t"
1717 "decl %0\n\t"
1718 "jmp 3f\n"
1719 "2:\n\t"
1720 "xorl %0,%0\n"
1721 "3:\n\t"
1722 "popl %%ebx"
1723 : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2)
1724 : "d" (__accept), "0" (__s), "1" (0), "2" (0xffffffff)
1725 : "cc");
1726 return __res;
1727 }
1728 #else
1729 __STRING_INLINE char *
1730 __strpbrk_g (__const char *__s, __const char *__accept)
1731 {
1732 register unsigned long int __d0, __d1, __d2, __d3;
1733 register char *__res;
1734 __asm__ __volatile__
1735 ("movl %%ebx,%%edi\n\t"
1736 "cld\n\t"
1737 "repne; scasb\n\t"
1738 "notl %%ecx\n\t"
1739 "leal -1(%%ecx),%%edx\n"
1740 "1:\n\t"
1741 "lodsb\n\t"
1742 "testb %%al,%%al\n\t"
1743 "je 2f\n\t"
1744 "movl %%ebx,%%edi\n\t"
1745 "movl %%edx,%%ecx\n\t"
1746 "repne; scasb\n\t"
1747 "jne 1b\n\t"
1748 "decl %0\n\t"
1749 "jmp 3f\n"
1750 "2:\n\t"
1751 "xorl %0,%0\n"
1752 "3:"
1753 : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&d" (__d2), "=&D" (__d3)
1754 : "0" (__s), "1" (0), "2" (0xffffffff), "b" (__accept)
1755 : "cc");
1756 return __res;
1757 }
1758 #endif
1759
1760
1761 /* Find the first occurrence of NEEDLE in HAYSTACK. */
1762 #define _HAVE_STRING_ARCH_strstr 1
1763 #define strstr(haystack, needle) \
1764 (__extension__ (__builtin_constant_p (needle) && sizeof ((needle)[0]) == 1 \
1765 ? ((needle)[0] == '\0' \
1766 ? haystack \
1767 : ((needle)[1] == '\0' \
1768 ? strchr (haystack, (needle)[0]) \
1769 : __strstr_cg (haystack, needle, strlen (needle)))) \
1770 : __strstr_g (haystack, needle)))
1771
1772 /* Please note that this function need not handle NEEDLEs with a
1773 length shorter than two. */
1774 __STRING_INLINE char *__strstr_cg (__const char *__haystack, __const char __needle[],
1775 size_t __needle_len);
1776
1777 __STRING_INLINE char *
1778 __strstr_cg (__const char *__haystack, __const char __needle[],
1779 size_t __needle_len)
1780 {
1781 register unsigned long int __d0, __d1, __d2;
1782 register char *__res;
1783 __asm__ __volatile__
1784 ("cld\n" \
1785 "1:\n\t"
1786 "movl %6,%%edi\n\t"
1787 "movl %5,%%eax\n\t"
1788 "movl %4,%%ecx\n\t"
1789 "repe; cmpsb\n\t"
1790 "je 2f\n\t"
1791 "cmpb $0,-1(%%esi)\n\t"
1792 "leal 1(%%eax),%5\n\t"
1793 "jne 1b\n\t"
1794 "xorl %%eax,%%eax\n"
1795 "2:"
1796 : "=a" (__res), "=&S" (__d0), "=&D" (__d1), "=&c" (__d2)
1797 : "g" (__needle_len), "1" (__haystack), "d" (__needle)
1798 : "cc");
1799 return __res;
1800 }
1801
1802 __STRING_INLINE char *__strstr_g (__const char *__haystack, __const char *__needle);
1803 #ifdef __PIC__
1804
1805 __STRING_INLINE char *
1806 __strstr_g (__const char *__haystack, __const char *__needle)
1807 {
1808 register unsigned long int __d0, __d1, __d2;
1809 register char *__res;
1810 __asm__ __volatile__
1811 ("cld\n\t"
1812 "repne; scasb\n\t"
1813 "notl %%ecx\n\t"
1814 "pushl %%ebx\n\t"
1815 "decl %%ecx\n\t" /* NOTE! This also sets Z if searchstring='' */
1816 "movl %%ecx,%%ebx\n"
1817 "1:\n\t"
1818 "movl %%edx,%%edi\n\t"
1819 "movl %%esi,%%eax\n\t"
1820 "movl %%ebx,%%ecx\n\t"
1821 "repe; cmpsb\n\t"
1822 "je 2f\n\t" /* also works for empty string, see above */
1823 "cmpb $0,-1(%%esi)\n\t"
1824 "leal 1(%%eax),%%esi\n\t"
1825 "jne 1b\n\t"
1826 "xorl %%eax,%%eax\n"
1827 "2:\n\t"
1828 "popl %%ebx"
1829 : "=a" (__res), "=&c" (__d0), "=&S" (__d1), "=&D" (__d2)
1830 : "0" (0), "1" (0xffffffff), "2" (__haystack), "3" (__needle),
1831 "d" (__needle)
1832 : "cc");
1833 return __res;
1834 }
1835 #else
1836 __STRING_INLINE char *
1837 __strstr_g (__const char *__haystack, __const char *__needle)
1838 {
1839 register unsigned long int __d0, __d1, __d2, __d3;
1840 register char *__res;
1841 __asm__ __volatile__
1842 ("cld\n\t"
1843 "repne; scasb\n\t"
1844 "notl %%ecx\n\t"
1845 "decl %%ecx\n\t" /* NOTE! This also sets Z if searchstring='' */
1846 "movl %%ecx,%%edx\n"
1847 "1:\n\t"
1848 "movl %%ebx,%%edi\n\t"
1849 "movl %%esi,%%eax\n\t"
1850 "movl %%edx,%%ecx\n\t"
1851 "repe; cmpsb\n\t"
1852 "je 2f\n\t" /* also works for empty string, see above */
1853 "cmpb $0,-1(%%esi)\n\t"
1854 "leal 1(%%eax),%%esi\n\t"
1855 "jne 1b\n\t"
1856 "xorl %%eax,%%eax\n"
1857 "2:"
1858 : "=a" (__res), "=&c" (__d0), "=&S" (__d1), "=&D" (__d2), "=&d" (__d3)
1859 : "0" (0), "1" (0xffffffff), "2" (__haystack), "3" (__needle),
1860 "b" (__needle)
1861 : "cc");
1862 return __res;
1863 }
1864 #endif
1865
1866
1867 /* Bit find functions. We define only the i686 version since for the other
1868 processors gcc generates good code. */
1869 #if defined __USE_BSD || defined __USE_XOPEN_EXTENDED
1870 # ifdef __i686__
1871 # define _HAVE_STRING_ARCH_ffs 1
1872 # define ffs(word) (__builtin_constant_p (word) \
1873 ? __builtin_ffs (word) \
1874 : ({ int __cnt, __tmp; \
1875 __asm__ __volatile__ \
1876 ("bsfl %2,%0\n\t" \
1877 "cmovel %1,%0" \
1878 : "=&r" (__cnt), "=r" (__tmp) \
1879 : "rm" (word), "1" (-1)); \
1880 __cnt + 1; }))
1881
1882 # ifndef ffsl
1883 # define ffsl(word) ffs(word)
1884 # endif
1885 # endif /* i686 */
1886 #endif /* BSD || X/Open */
1887
1888 #ifndef _FORCE_INLINES
1889 # undef __STRING_INLINE
1890 #endif
1891
1892 #endif /* use string inlines && GNU CC */
A mirror of the official glibc repository