i386/linux-2.3.21/include/asm-i386/string-486.h

   1 #ifndef _I386_STRING_I486_H_
   2 #define _I386_STRING_I486_H_
   3
   4 /*
   5  * This string-include defines all string functions as inline
   6  * functions. Use gcc. It also assumes ds=es=data space, this should be
   7  * normal. Most of the string-functions are rather heavily hand-optimized,
   8  * see especially strtok,strstr,str[c]spn. They should work, but are not
   9  * very easy to understand. Everything is done entirely within the register
  10  * set, making the functions fast and clean.
  11  *
  12  *              Copyright (C) 1991, 1992 Linus Torvalds
  13  *              Revised and optimized for i486/pentium
  14  *              1994/03/15 by Alberto Vignani/Davide Parodi @crf.it
  15  *
  16  *      Split into 2 CPU specific files by Alan Cox to keep #ifdef noise down.
  17  *
  18  *      99/9/15  Proper reg args for newer gcc/egcs - Petkan (petkan@spct.net)
  19  */
  20
  21 #define __HAVE_ARCH_STRCPY
  22 extern inline char * strcpy(char * dest,const char *src)
  23 {
  24 register char *tmp= (char *)dest;
  25 register char dummy;
  26 __asm__ __volatile__(
  27         "\n1:\t"
  28         "movb (%0),%2\n\t"
  29         "incl %0\n\t"
  30         "movb %2,(%1)\n\t"
  31         "incl %1\n\t"
  32         "testb %2,%2\n\t"
  33         "jne 1b"
  34         :"=r" (src), "=r" (tmp), "=q" (dummy)
  35         :"0" (src), "1" (tmp)
  36         :"memory");
  37 return dest;
  38 }
  39
  40 #define __HAVE_ARCH_STRNCPY
  41 extern inline char * strncpy(char * dest,const char *src,size_t count)
  42 {
  43 register char *tmp= (char *)dest;
  44 register char dummy;
  45 if (count) {
  46 __asm__ __volatile__(
  47         "\n1:\t"
  48         "movb (%0),%2\n\t"
  49         "incl %0\n\t"
  50         "movb %2,(%1)\n\t"
  51         "incl %1\n\t"
  52         "decl %3\n\t"
  53         "je 3f\n\t"
  54         "testb %2,%2\n\t"
  55         "jne 1b\n\t"
  56         "2:\tmovb %2,(%1)\n\t"
  57         "incl %1\n\t"
  58         "decl %3\n\t"
  59         "jne 2b\n\t"
  60         "3:"
  61         :"=r" (src), "=r" (tmp), "=q" (dummy), "=r" (count)
  62         :"0" (src), "1" (tmp), "3" (count)
  63         :"memory");
  64     } /* if (count) */
  65 return dest;
  66 }
  67
  68 #define __HAVE_ARCH_STRCAT
  69 extern inline char * strcat(char * dest,const char * src)
  70 {
  71 register char *tmp = (char *)(dest-1);
  72 register char dummy;
  73 __asm__ __volatile__(
  74         "\n1:\tincl %1\n\t"
  75         "cmpb $0,(%1)\n\t"
  76         "jne 1b\n"
  77         "2:\tmovb (%2),%b0\n\t"
  78         "incl %2\n\t"
  79         "movb %b0,(%1)\n\t"
  80         "incl %1\n\t"
  81         "testb %b0,%b0\n\t"
  82         "jne 2b\n"
  83         :"=q" (dummy), "=r" (tmp), "=r" (src)
  84         :"1"  (tmp), "2"  (src)
  85         :"memory");
  86 return dest;
  87 }
  88
  89 #define __HAVE_ARCH_STRNCAT
  90 extern inline char * strncat(char * dest,const char * src,size_t count)
  91 {
  92 register char *tmp = (char *)(dest-1);
  93 register char dummy;
  94 __asm__ __volatile__(
  95         "\n1:\tincl %1\n\t"
  96         "cmpb $0,(%1)\n\t"
  97         "jne 1b\n"
  98         "2:\tdecl %3\n\t"
  99         "js 3f\n\t"
 100         "movb (%2),%b0\n\t"
 101         "incl %2\n\t"
 102         "movb %b0,(%1)\n\t"
 103         "incl %1\n\t"
 104         "testb %b0,%b0\n\t"
 105         "jne 2b\n"
 106         "3:\txorl %0,%0\n\t"
 107         "movb %b0,(%1)\n\t"
 108         :"=q" (dummy), "=r" (tmp), "=r" (src), "=r" (count)
 109         :"1"  (tmp), "2"  (src), "3"  (count)
 110         :"memory");
 111 return dest;
 112 }
 113
 114 #define __HAVE_ARCH_STRCMP
 115 extern inline int strcmp(const char * cs,const char * ct)
 116 {
 117 register int __res;
 118 __asm__ __volatile__(
 119         "\n1:\tmovb (%1),%b0\n\t"
 120         "incl %1\n\t"
 121         "cmpb %b0,(%2)\n\t"
 122         "jne 2f\n\t"
 123         "incl %2\n\t"
 124         "testb %b0,%b0\n\t"
 125         "jne 1b\n\t"
 126         "xorl %0,%0\n\t"
 127         "jmp 3f\n"
 128         "2:\tmovl $1,%0\n\t"
 129         "jb 3f\n\t"
 130         "negl %0\n"
 131         "3:"
 132         :"=q" (__res), "=r" (cs), "=r" (ct)
 133         :"1" (cs), "2" (ct)
 134         : "memory" );
 135 return __res;
 136 }
 137
 138 #define __HAVE_ARCH_STRNCMP
 139 extern inline int strncmp(const char * cs,const char * ct,size_t count)
 140 {
 141 register int __res;
 142 __asm__ __volatile__(
 143         "\n1:\tdecl %3\n\t"
 144         "js 2f\n\t"
 145         "movb (%1),%b0\n\t"
 146         "incl %1\n\t"
 147         "cmpb %b0,(%2)\n\t"
 148         "jne 3f\n\t"
 149         "incl %2\n\t"
 150         "testb %b0,%b0\n\t"
 151         "jne 1b\n"
 152         "2:\txorl %0,%0\n\t"
 153         "jmp 4f\n"
 154         "3:\tmovl $1,%0\n\t"
 155         "jb 4f\n\t"
 156         "negl %0\n"
 157         "4:"
 158         :"=q" (__res), "=r" (cs), "=r" (ct), "=r" (count)
 159         :"1"  (cs), "2"  (ct),  "3" (count));
 160 return __res;
 161 }
 162
 163 #define __HAVE_ARCH_STRCHR
 164 extern inline char * strchr(const char * s, int c)
 165 {
 166 register char * __res;
 167 __asm__ __volatile__(
 168         "movb %%al,%%ah\n"
 169         "1:\tmovb (%1),%%al\n\t"
 170         "cmpb %%ah,%%al\n\t"
 171         "je 2f\n\t"
 172         "incl %1\n\t"
 173         "testb %%al,%%al\n\t"
 174         "jne 1b\n\t"
 175         "xorl %1,%1\n"
 176         "2:\tmovl %1,%0\n\t"
 177         :"=a" (__res), "=r" (s)
 178         :"0" (c),      "1"  (s));
 179 return __res;
 180 }
 181
 182 #define __HAVE_ARCH_STRRCHR
 183 extern inline char * strrchr(const char * s, int c)
 184 {
 185 int     d0, d1;
 186 register char * __res;
 187 __asm__ __volatile__(
 188         "cld\n\t"
 189         "movb %%al,%%ah\n"
 190         "1:\tlodsb\n\t"
 191         "cmpb %%ah,%%al\n\t"
 192         "jne 2f\n\t"
 193         "leal -1(%%esi),%0\n"
 194         "2:\ttestb %%al,%%al\n\t"
 195         "jne 1b"
 196         :"=d" (__res), "=&S" (d0), "=&a" (d1)
 197         :"0" (0), "1" (s), "2" (c));
 198 return __res;
 199 }
 200
 201 #define __HAVE_ARCH_STRSPN
 202 extern inline size_t strspn(const char * cs, const char * ct)
 203 {
 204 int     d0, d1;
 205 register char * __res;
 206 __asm__ __volatile__(
 207         "cld\n\t"
 208         "movl %6,%%edi\n\t"
 209         "repne\n\t"
 210         "scasb\n\t"
 211         "notl %%ecx\n\t"
 212         "decl %%ecx\n\t"
 213         "movl %%ecx,%%edx\n"
 214         "1:\tlodsb\n\t"
 215         "testb %%al,%%al\n\t"
 216         "je 2f\n\t"
 217         "movl %6,%%edi\n\t"
 218         "movl %%edx,%%ecx\n\t"
 219         "repne\n\t"
 220         "scasb\n\t"
 221         "je 1b\n"
 222         "2:\tdecl %0"
 223         :"=S" (__res), "=&a" (d0), "=&c" (d1)
 224         :"0" (cs), "1" (0), "2" (0xffffffff), "g" (ct)
 225         :"dx", "di");
 226 return __res-cs;
 227 }
 228
 229 #define __HAVE_ARCH_STRCSPN
 230 extern inline size_t strcspn(const char * cs, const char * ct)
 231 {
 232 int     d0, d1;
 233 register char * __res;
 234 __asm__ __volatile__(
 235         "cld\n\t"
 236         "movl %6,%%edi\n\t"
 237         "repne\n\t"
 238         "scasb\n\t"
 239         "notl %%ecx\n\t"
 240         "decl %%ecx\n\t"
 241         "movl %%ecx,%%edx\n"
 242         "1:\tlodsb\n\t"
 243         "testb %%al,%%al\n\t"
 244         "je 2f\n\t"
 245         "movl %6,%%edi\n\t"
 246         "movl %%edx,%%ecx\n\t"
 247         "repne\n\t"
 248         "scasb\n\t"
 249         "jne 1b\n"
 250         "2:\tdecl %0"
 251         :"=S" (__res), "=&a" (d0), "=&c" (d1)
 252         :"0" (cs), "1" (0), "2" (0xffffffff), "g" (ct)
 253         :"dx", "di");
 254 return __res-cs;
 255 }
 256
 257 #define __HAVE_ARCH_STRPBRK
 258 extern inline char * strpbrk(const char * cs,const char * ct)
 259 {
 260 int     d0, d1;
 261 register char * __res;
 262 __asm__ __volatile__(
 263         "cld\n\t"
 264         "movl %4,%%edi\n\t"
 265         "repne\n\t"
 266         "scasb\n\t"
 267         "notl %%ecx\n\t"
 268         "decl %%ecx\n\t"
 269         "movl %%ecx,%%edx\n"
 270         "1:\tlodsb\n\t"
 271         "testb %%al,%%al\n\t"
 272         "je 2f\n\t"
 273         "movl %4,%%edi\n\t"
 274         "movl %%edx,%%ecx\n\t"
 275         "repne\n\t"
 276         "scasb\n\t"
 277         "jne 1b\n\t"
 278         "decl %0\n\t"
 279         "jmp 3f\n"
 280         "2:\txorl %0,%0\n"
 281         "3:"
 282         :"=S" (__res), "=&a" (d0), "=&c" (d1)
 283         :"0" (cs), "1" (0), "2" (0xffffffff), "g" (ct)
 284         :"dx", "di");
 285 return __res;
 286 }
 287
 288 #define __HAVE_ARCH_STRSTR
 289 extern inline char * strstr(const char * cs,const char * ct)
 290 {
 291 int     d0, d1;
 292 register char * __res;
 293 __asm__ __volatile__(
 294         "cld\n\t" \
 295         "movl %4,%%edi\n\t"
 296         "repne\n\t"
 297         "scasb\n\t"
 298         "notl %%ecx\n\t"
 299         "decl %%ecx\n\t"        /* NOTE! This also sets Z if searchstring='' */
 300         "movl %%ecx,%%edx\n"
 301         "1:\tmovl %4,%%edi\n\t"
 302         "movl %%esi,%%eax\n\t"
 303         "movl %%edx,%%ecx\n\t"
 304         "repe\n\t"
 305         "cmpsb\n\t"
 306         "je 2f\n\t"             /* also works for empty string, see above */
 307         "xchgl %%eax,%%esi\n\t"
 308         "incl %%esi\n\t"
 309         "cmpb $0,-1(%%eax)\n\t"
 310         "jne 1b\n\t"
 311         "xorl %%eax,%%eax\n\t"
 312         "2:"
 313         :"=a" (__res), "=&c" (d0), "=&S" (d1)
 314         :"0" (0), "1" (0xffffffff), "2" (cs), "g" (ct)
 315         :"dx", "di");
 316 return __res;
 317 }
 318
 319 #define __HAVE_ARCH_STRLEN
 320 extern inline size_t strlen(const char * s)
 321 {
 322 /*
 323  * slightly slower on a 486, but with better chances of
 324  * register allocation
 325  */
 326 register char dummy, *tmp= (char *)s;
 327 __asm__ __volatile__(
 328         "\n1:\t"
 329         "movb\t(%0),%1\n\t"
 330         "incl\t%0\n\t"
 331         "testb\t%1,%1\n\t"
 332         "jne\t1b"
 333         :"=r" (tmp),"=q" (dummy)
 334         :"0" (s)
 335         : "memory" );
 336 return (tmp-s-1);
 337 }
 338
 339 /* Added by Gertjan van Wingerde to make minix and sysv module work */
 340 #define __HAVE_ARCH_STRNLEN
 341 extern inline size_t strnlen(const char * s, size_t count)
 342 {
 343 int     d0;
 344 register int __res;
 345 __asm__ __volatile__(
 346         "movl %1,%0\n\t"
 347         "jmp 2f\n"
 348         "1:\tcmpb $0,(%0)\n\t"
 349         "je 3f\n\t"
 350         "incl %0\n"
 351         "2:\tdecl %2\n\t"
 352         "cmpl $-1,%2\n\t"
 353         "jne 1b\n"
 354         "3:\tsubl %1,%0"
 355         :"=a" (__res), "=&d" (d0)
 356         :"1" (count), "c" (s));
 357 return __res;
 358 }
 359 /* end of additional stuff */
 360
 361 #define __HAVE_ARCH_STRTOK
 362 extern inline char * strtok(char * s,const char * ct)
 363 {
 364 register char * __res;
 365 __asm__ __volatile__(
 366         "testl %1,%1\n\t"
 367         "jne 1f\n\t"
 368         "testl %0,%0\n\t"
 369         "je 8f\n\t"
 370         "movl %0,%1\n"
 371         "1:\txorl %0,%0\n\t"
 372         "movl $-1,%%ecx\n\t"
 373         "xorl %%eax,%%eax\n\t"
 374         "cld\n\t"
 375         "movl %4,%%edi\n\t"
 376         "repne\n\t"
 377         "scasb\n\t"
 378         "notl %%ecx\n\t"
 379         "decl %%ecx\n\t"
 380         "je 7f\n\t"                     /* empty delimiter-string */
 381         "movl %%ecx,%%edx\n"
 382         "2:\tlodsb\n\t"
 383         "testb %%al,%%al\n\t"
 384         "je 7f\n\t"
 385         "movl %4,%%edi\n\t"
 386         "movl %%edx,%%ecx\n\t"
 387         "repne\n\t"
 388         "scasb\n\t"
 389         "je 2b\n\t"
 390         "decl %1\n\t"
 391         "cmpb $0,(%1)\n\t"
 392         "je 7f\n\t"
 393         "movl %1,%0\n"
 394         "3:\tlodsb\n\t"
 395         "testb %%al,%%al\n\t"
 396         "je 5f\n\t"
 397         "movl %4,%%edi\n\t"
 398         "movl %%edx,%%ecx\n\t"
 399         "repne\n\t"
 400         "scasb\n\t"
 401         "jne 3b\n\t"
 402         "decl %1\n\t"
 403         "cmpb $0,(%1)\n\t"
 404         "je 5f\n\t"
 405         "movb $0,(%1)\n\t"
 406         "incl %1\n\t"
 407         "jmp 6f\n"
 408         "5:\txorl %1,%1\n"
 409         "6:\tcmpb $0,(%0)\n\t"
 410         "jne 7f\n\t"
 411         "xorl %0,%0\n"
 412         "7:\ttestl %0,%0\n\t"
 413         "jne 8f\n\t"
 414         "movl %0,%1\n"
 415         "8:"
 416         :"=b" (__res),"=S" (___strtok)
 417         :"0" (___strtok),"1" (s),"g" (ct)
 418         :"ax","cx","dx","di","memory");
 419 return __res;
 420 }
 421
 422 #define __memcpy_c(d,s,count) \
 423 ((count%4==0) ? \
 424  __memcpy_by4((d),(s),(count)) : \
 425  ((count%2==0) ? \
 426   __memcpy_by2((d),(s),(count)) : \
 427   __memcpy_g((d),(s),(count))))
 428
 429 #define __HAVE_ARCH_MEMCPY
 430 #define memcpy(d,s,count) \
 431 (__builtin_constant_p(count) ? \
 432  __memcpy_c((d),(s),(count)) : \
 433  __memcpy_g((d),(s),(count)))
 434
 435 /*
 436  *      These ought to get tweaked to do some cache priming.
 437  */
 438
 439 extern inline void * __memcpy_by4(void * to, const void * from, size_t n)
 440 {
 441 register void *tmp = (void *)to;
 442 register int dummy1,dummy2;
 443 __asm__ __volatile__ (
 444         "\n1:\tmovl (%2),%0\n\t"
 445         "addl $4,%2\n\t"
 446         "movl %0,(%1)\n\t"
 447         "addl $4,%1\n\t"
 448         "decl %3\n\t"
 449         "jnz 1b"
 450         :"=r" (dummy1), "=r" (tmp), "=r" (from), "=r" (dummy2)
 451         :"1" (tmp), "2" (from), "3" (n/4)
 452         :"memory");
 453 return (to);
 454 }
 455
 456 extern inline void * __memcpy_by2(void * to, const void * from, size_t n)
 457 {
 458 register void *tmp = (void *)to;
 459 register int dummy1,dummy2;
 460 __asm__ __volatile__ (
 461         "shrl $1,%3\n\t"
 462         "jz 2f\n"                 /* only a word */
 463         "1:\tmovl (%2),%0\n\t"
 464         "addl $4,%2\n\t"
 465         "movl %0,(%1)\n\t"
 466         "addl $4,%1\n\t"
 467         "decl %3\n\t"
 468         "jnz 1b\n"
 469         "2:\tmovw (%2),%w0\n\t"
 470         "movw %w0,(%1)"
 471         :"=r" (dummy1), "=r" (tmp), "=r" (from), "=r" (dummy2)
 472         :"1" (tmp), "2" (from), "3" (n/2)
 473         :"memory");
 474 return (to);
 475 }
 476
 477 extern inline void * __memcpy_g(void * to, const void * from, size_t n)
 478 {
 479 int     d0, d1, d2;
 480 register void *tmp = (void *)to;
 481 __asm__ __volatile__ (
 482         "cld\n\t"
 483         "shrl $1,%%ecx\n\t"
 484         "jnc 1f\n\t"
 485         "movsb\n"
 486         "1:\tshrl $1,%%ecx\n\t"
 487         "jnc 2f\n\t"
 488         "movsw\n"
 489         "2:\trep\n\t"
 490         "movsl"
 491         :"=&c" (d0), "=&D" (d1), "=&S" (d2)
 492         :"0" (n), "1" ((long) tmp), "2" ((long) from)
 493         :"memory");
 494 return (to);
 495 }
 496
 497
 498 #define __HAVE_ARCH_MEMMOVE
 499 extern inline void * memmove(void * dest,const void * src, size_t n)
 500 {
 501 int     d0, d1, d2;
 502 register void *tmp = (void *)dest;
 503 if (dest<src)
 504 __asm__ __volatile__ (
 505         "cld\n\t"
 506         "rep\n\t"
 507         "movsb"
 508         :"=&c" (d0), "=&S" (d1), "=&D" (d2)
 509         :"0" (n), "1" (src), "2" (tmp)
 510         :"memory");
 511 else
 512 __asm__ __volatile__ (
 513         "std\n\t"
 514         "rep\n\t"
 515         "movsb\n\t"
 516         "cld"
 517         :"=&c" (d0), "=&S" (d1), "=&D" (d2)
 518         :"0" (n), "1" (n-1+(const char *)src), "2" (n-1+(char *)tmp)
 519         :"memory");
 520 return dest;
 521 }
 522
 523 extern inline int memcmp(const void * cs,const void * ct,size_t count)
 524 {
 525 int     d0, d1, d2;
 526 register int __res;
 527 __asm__ __volatile__(
 528         "cld\n\t"
 529         "repe\n\t"
 530         "cmpsb\n\t"
 531         "je 1f\n\t"
 532         "sbbl %0,%0\n\t"
 533         "orb $1,%b0\n"
 534         "1:"
 535         :"=a" (__res), "=&S" (d0), "=&D" (d1), "=&c" (d2)
 536         :"0" (0), "1" (cs), "2" (ct), "3" (count));
 537 return __res;
 538 }
 539
 540 #define __HAVE_ARCH_MEMCHR
 541 extern inline void * memchr(const void * cs,int c,size_t count)
 542 {
 543 int     d0;
 544 register void * __res;
 545 if (!count)
 546         return NULL;
 547 __asm__ __volatile__(
 548         "cld\n\t"
 549         "repne\n\t"
 550         "scasb\n\t"
 551         "je 1f\n\t"
 552         "movl $1,%0\n"
 553         "1:\tdecl %0"
 554         :"=D" (__res), "=&c" (d0)
 555         :"a" (c), "0" (cs), "1" (count));
 556 return __res;
 557 }
 558
 559 #define __memset_cc(s,c,count) \
 560 ((count%4==0) ? \
 561  __memset_cc_by4((s),(c),(count)) : \
 562  ((count%2==0) ? \
 563   __memset_cc_by2((s),(c),(count)) : \
 564   __memset_cg((s),(c),(count))))
 565
 566 #define __memset_gc(s,c,count) \
 567 ((count%4==0) ? \
 568  __memset_gc_by4((s),(c),(count)) : \
 569  ((count%2==0) ? \
 570   __memset_gc_by2((s),(c),(count)) : \
 571   __memset_gg((s),(c),(count))))
 572
 573 #define __HAVE_ARCH_MEMSET
 574 #define memset(s,c,count) \
 575 (__builtin_constant_p(c) ? \
 576  (__builtin_constant_p(count) ? \
 577   __memset_cc((s),(c),(count)) : \
 578   __memset_cg((s),(c),(count))) : \
 579  (__builtin_constant_p(count) ? \
 580   __memset_gc((s),(c),(count)) : \
 581   __memset_gg((s),(c),(count))))
 582
 583 extern inline void * __memset_cc_by4(void * s, char c, size_t count)
 584 {
 585 /*
 586  * register char *tmp = s;
 587  */
 588 register char *tmp = (char *)s;
 589 register int  dummy;
 590 __asm__ __volatile__ (
 591         "\n1:\tmovl %2,(%0)\n\t"
 592         "addl $4,%0\n\t"
 593         "decl %1\n\t"
 594         "jnz 1b"
 595         :"=r" (tmp), "=r" (dummy)
 596         :"q" (0x01010101UL * (unsigned char) c), "0" (tmp), "1" (count/4)
 597         :"memory");
 598 return s;
 599 }
 600
 601 extern inline void * __memset_cc_by2(void * s, char c, size_t count)
 602 {
 603 register void *tmp = (void *)s;
 604 register int  dummy;
 605 __asm__ __volatile__ (
 606         "shrl $1,%1\n\t"          /* may be divisible also by 4 */
 607         "jz 2f\n"
 608         "\n1:\tmovl %2,(%0)\n\t"
 609         "addl $4,%0\n\t"
 610         "decl %1\n\t"
 611         "jnz 1b\n"
 612         "2:\tmovw %w2,(%0)"
 613         :"=r" (tmp), "=r" (dummy)
 614         :"q" (0x01010101UL * (unsigned char) c), "0" (tmp), "1" (count/2)
 615         :"memory");
 616 return s;
 617 }
 618
 619 extern inline void * __memset_gc_by4(void * s, char c, size_t count)
 620 {
 621 register void *tmp = (void *)s;
 622 register int dummy;
 623 __asm__ __volatile__ (
 624         "movb %b0,%h0\n"
 625         "pushw %w0\n\t"
 626         "shll $16,%0\n\t"
 627         "popw %w0\n"
 628         "1:\tmovl %0,(%1)\n\t"
 629         "addl $4,%1\n\t"
 630         "decl %2\n\t"
 631         "jnz 1b\n"
 632         :"=q" (c), "=r" (tmp), "=r" (dummy)
 633         :"0" ((unsigned) c),  "1"  (tmp), "2" (count/4)
 634         :"memory");
 635 return s;
 636 }
 637
 638 extern inline void * __memset_gc_by2(void * s, char c, size_t count)
 639 {
 640 register void *tmp = (void *)s;
 641 register int dummy1,dummy2;
 642 __asm__ __volatile__ (
 643         "movb %b0,%h0\n\t"
 644         "shrl $1,%2\n\t"          /* may be divisible also by 4 */
 645         "jz 2f\n\t"
 646         "pushw %w0\n\t"
 647         "shll $16,%0\n\t"
 648         "popw %w0\n"
 649         "1:\tmovl %0,(%1)\n\t"
 650         "addl $4,%1\n\t"
 651         "decl %2\n\t"
 652         "jnz 1b\n"
 653         "2:\tmovw %w0,(%1)"
 654         :"=q" (dummy1), "=r" (tmp), "=r" (dummy2)
 655         :"0" ((unsigned) c),  "1"  (tmp), "2" (count/2)
 656         :"memory");
 657 return s;
 658 }
 659
 660 extern inline void * __memset_cg(void * s, char c, size_t count)
 661 {
 662 int     d0, d1;
 663 register void *tmp = (void *)s;
 664 __asm__ __volatile__ (
 665         "shrl $1,%%ecx\n\t"
 666         "rep\n\t"
 667         "stosw\n\t"
 668         "jnc 1f\n\t"
 669         "movb %%al,(%%edi)\n"
 670         "1:"
 671         :"=&c" (d0), "=&D" (d1)
 672         :"a" (0x0101U * (unsigned char) c), "0" (count), "1" (tmp)
 673         :"memory");
 674 return s;
 675 }
 676
 677 extern inline void * __memset_gg(void * s,char c,size_t count)
 678 {
 679 int     d0, d1, d2;
 680 register void *tmp = (void *)s;
 681 __asm__ __volatile__ (
 682         "movb %%al,%%ah\n\t"
 683         "shrl $1,%%ecx\n\t"
 684         "rep\n\t"
 685         "stosw\n\t"
 686         "jnc 1f\n\t"
 687         "movb %%al,(%%edi)\n"
 688         "1:"
 689         :"=&c" (d0), "=&D" (d1), "=&D" (d2)
 690         :"0" (count), "1" (tmp), "2" (c)
 691         :"memory");
 692 return s;
 693 }
 694
 695
 696 /*
 697  * find the first occurrence of byte 'c', or 1 past the area if none
 698  */
 699 #define __HAVE_ARCH_MEMSCAN
 700 extern inline void * memscan(void * addr, int c, size_t size)
 701 {
 702         if (!size)
 703                 return addr;
 704         __asm__("cld
 705                 repnz; scasb
 706                 jnz 1f
 707                 dec %%edi
 708 1:              "
 709                 : "=D" (addr), "=c" (size)
 710                 : "0" (addr), "1" (size), "a" (c));
 711         return addr;
 712 }
 713
 714 #endif