git.oblomov.eu Git - linux-2.6/blob - arch/x86/lib/string_32.c

   1 /*
   2  * Most of the string-functions are rather heavily hand-optimized,
   3  * see especially strsep,strstr,str[c]spn. They should work, but are not
   4  * very easy to understand. Everything is done entirely within the register
   5  * set, making the functions fast and clean. String instructions have been
   6  * used through-out, making for "slightly" unclear code :-)
   7  *
   8  * AK: On P4 and K7 using non string instruction implementations might be faster
   9  * for large memory blocks. But most of them are unlikely to be used on large
  10  * strings.
  11  */
  12
  13 #include <linux/string.h>
  14 #include <linux/module.h>
  15
  16 #ifdef __HAVE_ARCH_STRCPY
  17 char *strcpy(char *dest, const char *src)
  18 {
  19         int d0, d1, d2;
  20         asm volatile("1:\tlodsb\n\t"
  21                 "stosb\n\t"
  22                 "testb %%al,%%al\n\t"
  23                 "jne 1b"
  24                 : "=&S" (d0), "=&D" (d1), "=&a" (d2)
  25                 : "0" (src), "1" (dest) : "memory");
  26         return dest;
  27 }
  28 EXPORT_SYMBOL(strcpy);
  29 #endif
  30
  31 #ifdef __HAVE_ARCH_STRNCPY
  32 char *strncpy(char *dest, const char *src, size_t count)
  33 {
  34         int d0, d1, d2, d3;
  35         asm volatile("1:\tdecl %2\n\t"
  36                 "js 2f\n\t"
  37                 "lodsb\n\t"
  38                 "stosb\n\t"
  39                 "testb %%al,%%al\n\t"
  40                 "jne 1b\n\t"
  41                 "rep\n\t"
  42                 "stosb\n"
  43                 "2:"
  44                 : "=&S" (d0), "=&D" (d1), "=&c" (d2), "=&a" (d3)
  45                 : "0" (src), "1" (dest), "2" (count) : "memory");
  46         return dest;
  47 }
  48 EXPORT_SYMBOL(strncpy);
  49 #endif
  50
  51 #ifdef __HAVE_ARCH_STRCAT
  52 char *strcat(char *dest, const char *src)
  53 {
  54         int d0, d1, d2, d3;
  55         asm volatile("repne\n\t"
  56                 "scasb\n\t"
  57                 "decl %1\n"
  58                 "1:\tlodsb\n\t"
  59                 "stosb\n\t"
  60                 "testb %%al,%%al\n\t"
  61                 "jne 1b"
  62                 : "=&S" (d0), "=&D" (d1), "=&a" (d2), "=&c" (d3)
  63                 : "0" (src), "1" (dest), "2" (0), "3" (0xffffffffu) : "memory");
  64         return dest;
  65 }
  66 EXPORT_SYMBOL(strcat);
  67 #endif
  68
  69 #ifdef __HAVE_ARCH_STRNCAT
  70 char *strncat(char *dest, const char *src, size_t count)
  71 {
  72         int d0, d1, d2, d3;
  73         asm volatile("repne\n\t"
  74                 "scasb\n\t"
  75                 "decl %1\n\t"
  76                 "movl %8,%3\n"
  77                 "1:\tdecl %3\n\t"
  78                 "js 2f\n\t"
  79                 "lodsb\n\t"
  80                 "stosb\n\t"
  81                 "testb %%al,%%al\n\t"
  82                 "jne 1b\n"
  83                 "2:\txorl %2,%2\n\t"
  84                 "stosb"
  85                 : "=&S" (d0), "=&D" (d1), "=&a" (d2), "=&c" (d3)
  86                 : "0" (src), "1" (dest), "2" (0), "3" (0xffffffffu), "g" (count)
  87                 : "memory");
  88         return dest;
  89 }
  90 EXPORT_SYMBOL(strncat);
  91 #endif
  92
  93 #ifdef __HAVE_ARCH_STRCMP
  94 int strcmp(const char *cs, const char *ct)
  95 {
  96         int d0, d1;
  97         int res;
  98         asm volatile("1:\tlodsb\n\t"
  99                 "scasb\n\t"
 100                 "jne 2f\n\t"
 101                 "testb %%al,%%al\n\t"
 102                 "jne 1b\n\t"
 103                 "xorl %%eax,%%eax\n\t"
 104                 "jmp 3f\n"
 105                 "2:\tsbbl %%eax,%%eax\n\t"
 106                 "orb $1,%%al\n"
 107                 "3:"
 108                 : "=a" (res), "=&S" (d0), "=&D" (d1)
 109                 : "1" (cs), "2" (ct)
 110                 : "memory");
 111         return res;
 112 }
 113 EXPORT_SYMBOL(strcmp);
 114 #endif
 115
 116 #ifdef __HAVE_ARCH_STRNCMP
 117 int strncmp(const char *cs, const char *ct, size_t count)
 118 {
 119         int res;
 120         int d0, d1, d2;
 121         asm volatile("1:\tdecl %3\n\t"
 122                 "js 2f\n\t"
 123                 "lodsb\n\t"
 124                 "scasb\n\t"
 125                 "jne 3f\n\t"
 126                 "testb %%al,%%al\n\t"
 127                 "jne 1b\n"
 128                 "2:\txorl %%eax,%%eax\n\t"
 129                 "jmp 4f\n"
 130                 "3:\tsbbl %%eax,%%eax\n\t"
 131                 "orb $1,%%al\n"
 132                 "4:"
 133                 : "=a" (res), "=&S" (d0), "=&D" (d1), "=&c" (d2)
 134                 : "1" (cs), "2" (ct), "3" (count)
 135                 : "memory");
 136         return res;
 137 }
 138 EXPORT_SYMBOL(strncmp);
 139 #endif
 140
 141 #ifdef __HAVE_ARCH_STRCHR
 142 char *strchr(const char *s, int c)
 143 {
 144         int d0;
 145         char *res;
 146         asm volatile("movb %%al,%%ah\n"
 147                 "1:\tlodsb\n\t"
 148                 "cmpb %%ah,%%al\n\t"
 149                 "je 2f\n\t"
 150                 "testb %%al,%%al\n\t"
 151                 "jne 1b\n\t"
 152                 "movl $1,%1\n"
 153                 "2:\tmovl %1,%0\n\t"
 154                 "decl %0"
 155                 : "=a" (res), "=&S" (d0)
 156                 : "1" (s), "0" (c)
 157                 : "memory");
 158         return res;
 159 }
 160 EXPORT_SYMBOL(strchr);
 161 #endif
 162
 163 #ifdef __HAVE_ARCH_STRLEN
 164 size_t strlen(const char *s)
 165 {
 166         int d0;
 167         int res;
 168         asm volatile("repne\n\t"
 169                 "scasb\n\t"
 170                 "notl %0\n\t"
 171                 "decl %0"
 172                 : "=c" (res), "=&D" (d0)
 173                 : "1" (s), "a" (0), "0" (0xffffffffu)
 174                 : "memory");
 175         return res;
 176 }
 177 EXPORT_SYMBOL(strlen);
 178 #endif
 179
 180 #ifdef __HAVE_ARCH_MEMCHR
 181 void *memchr(const void *cs, int c, size_t count)
 182 {
 183         int d0;
 184         void *res;
 185         if (!count)
 186                 return NULL;
 187         asm volatile("repne\n\t"
 188                 "scasb\n\t"
 189                 "je 1f\n\t"
 190                 "movl $1,%0\n"
 191                 "1:\tdecl %0"
 192                 : "=D" (res), "=&c" (d0)
 193                 : "a" (c), "0" (cs), "1" (count)
 194                 : "memory");
 195         return res;
 196 }
 197 EXPORT_SYMBOL(memchr);
 198 #endif
 199
 200 #ifdef __HAVE_ARCH_MEMSCAN
 201 void *memscan(void *addr, int c, size_t size)
 202 {
 203         if (!size)
 204                 return addr;
 205         asm volatile("repnz; scasb\n\t"
 206             "jnz 1f\n\t"
 207             "dec %%edi\n"
 208             "1:"
 209             : "=D" (addr), "=c" (size)
 210             : "0" (addr), "1" (size), "a" (c)
 211             : "memory");
 212         return addr;
 213 }
 214 EXPORT_SYMBOL(memscan);
 215 #endif
 216
 217 #ifdef __HAVE_ARCH_STRNLEN
 218 size_t strnlen(const char *s, size_t count)
 219 {
 220         int d0;
 221         int res;
 222         asm volatile("movl %2,%0\n\t"
 223                 "jmp 2f\n"
 224                 "1:\tcmpb $0,(%0)\n\t"
 225                 "je 3f\n\t"
 226                 "incl %0\n"
 227                 "2:\tdecl %1\n\t"
 228                 "cmpl $-1,%1\n\t"
 229                 "jne 1b\n"
 230                 "3:\tsubl %2,%0"
 231                 : "=a" (res), "=&d" (d0)
 232                 : "c" (s), "1" (count)
 233                 : "memory");
 234         return res;
 235 }
 236 EXPORT_SYMBOL(strnlen);
 237 #endif