arch/s390/lib/string.c

   1 /*
   2  *    Optimized string functions
   3  *
   4  *  S390 version
   5  *    Copyright IBM Corp. 2004
   6  *    Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com)
   7  */
   8
   9 #define IN_ARCH_STRING_C 1
  10
  11 #include <linux/types.h>
  12 #include <linux/module.h>
  13
  14 /*
  15  * Helper functions to find the end of a string
  16  */
  17 static inline char *__strend(const char *s)
  18 {
  19         register unsigned long r0 asm("0") = 0;
  20
  21         asm volatile ("0: srst  %0,%1\n"
  22                       "   jo    0b"
  23                       : "+d" (r0), "+a" (s) :  : "cc" );
  24         return (char *) r0;
  25 }
  26
  27 static inline char *__strnend(const char *s, size_t n)
  28 {
  29         register unsigned long r0 asm("0") = 0;
  30         const char *p = s + n;
  31
  32         asm volatile ("0: srst  %0,%1\n"
  33                       "   jo    0b"
  34                       : "+d" (p), "+a" (s) : "d" (r0) : "cc" );
  35         return (char *) p;
  36 }
  37
  38 /**
  39  * strlen - Find the length of a string
  40  * @s: The string to be sized
  41  *
  42  * returns the length of @s
  43  */
  44 size_t strlen(const char *s)
  45 {
  46         return __strend(s) - s;
  47 }
  48 EXPORT_SYMBOL(strlen);
  49
  50 /**
  51  * strnlen - Find the length of a length-limited string
  52  * @s: The string to be sized
  53  * @n: The maximum number of bytes to search
  54  *
  55  * returns the minimum of the length of @s and @n
  56  */
  57 size_t strnlen(const char * s, size_t n)
  58 {
  59         return __strnend(s, n) - s;
  60 }
  61 EXPORT_SYMBOL(strnlen);
  62
  63 /**
  64  * strcpy - Copy a %NUL terminated string
  65  * @dest: Where to copy the string to
  66  * @src: Where to copy the string from
  67  *
  68  * returns a pointer to @dest
  69  */
  70 char *strcpy(char *dest, const char *src)
  71 {
  72         register int r0 asm("0") = 0;
  73         char *ret = dest;
  74
  75         asm volatile ("0: mvst  %0,%1\n"
  76                       "   jo    0b"
  77                       : "+&a" (dest), "+&a" (src) : "d" (r0)
  78                       : "cc", "memory" );
  79         return ret;
  80 }
  81 EXPORT_SYMBOL(strcpy);
  82
  83 /**
  84  * strlcpy - Copy a %NUL terminated string into a sized buffer
  85  * @dest: Where to copy the string to
  86  * @src: Where to copy the string from
  87  * @size: size of destination buffer
  88  *
  89  * Compatible with *BSD: the result is always a valid
  90  * NUL-terminated string that fits in the buffer (unless,
  91  * of course, the buffer size is zero). It does not pad
  92  * out the result like strncpy() does.
  93  */
  94 size_t strlcpy(char *dest, const char *src, size_t size)
  95 {
  96         size_t ret = __strend(src) - src;
  97
  98         if (size) {
  99                 size_t len = (ret >= size) ? size-1 : ret;
 100                 dest[len] = '\0';
 101                 memcpy(dest, src, len);
 102         }
 103         return ret;
 104 }
 105 EXPORT_SYMBOL(strlcpy);
 106
 107 /**
 108  * strncpy - Copy a length-limited, %NUL-terminated string
 109  * @dest: Where to copy the string to
 110  * @src: Where to copy the string from
 111  * @n: The maximum number of bytes to copy
 112  *
 113  * The result is not %NUL-terminated if the source exceeds
 114  * @n bytes.
 115  */
 116 char *strncpy(char *dest, const char *src, size_t n)
 117 {
 118         size_t len = __strnend(src, n) - src;
 119         memset(dest + len, 0, n - len);
 120         memcpy(dest, src, len);
 121         return dest;
 122 }
 123 EXPORT_SYMBOL(strncpy);
 124
 125 /**
 126  * strcat - Append one %NUL-terminated string to another
 127  * @dest: The string to be appended to
 128  * @src: The string to append to it
 129  *
 130  * returns a pointer to @dest
 131  */
 132 char *strcat(char *dest, const char *src)
 133 {
 134         register int r0 asm("0") = 0;
 135         unsigned long dummy;
 136         char *ret = dest;
 137
 138         asm volatile ("0: srst  %0,%1\n"
 139                       "   jo    0b\n"
 140                       "1: mvst  %0,%2\n"
 141                       "   jo    1b"
 142                       : "=&a" (dummy), "+a" (dest), "+a" (src)
 143                       : "d" (r0), "0" (0UL) : "cc", "memory" );
 144         return ret;
 145 }
 146 EXPORT_SYMBOL(strcat);
 147
 148 /**
 149  * strlcat - Append a length-limited, %NUL-terminated string to another
 150  * @dest: The string to be appended to
 151  * @src: The string to append to it
 152  * @n: The size of the destination buffer.
 153  */
 154 size_t strlcat(char *dest, const char *src, size_t n)
 155 {
 156         size_t dsize = __strend(dest) - dest;
 157         size_t len = __strend(src) - src;
 158         size_t res = dsize + len;
 159
 160         if (dsize < n) {
 161                 dest += dsize;
 162                 n -= dsize;
 163                 if (len >= n)
 164                         len = n - 1;
 165                 dest[len] = '\0';
 166                 memcpy(dest, src, len);
 167         }
 168         return res;
 169 }
 170 EXPORT_SYMBOL(strlcat);
 171
 172 /**
 173  * strncat - Append a length-limited, %NUL-terminated string to another
 174  * @dest: The string to be appended to
 175  * @src: The string to append to it
 176  * @n: The maximum numbers of bytes to copy
 177  *
 178  * returns a pointer to @dest
 179  *
 180  * Note that in contrast to strncpy, strncat ensures the result is
 181  * terminated.
 182  */
 183 char *strncat(char *dest, const char *src, size_t n)
 184 {
 185         size_t len = __strnend(src, n) - src;
 186         char *p = __strend(dest);
 187
 188         p[len] = '\0';
 189         memcpy(p, src, len);
 190         return dest;
 191 }
 192 EXPORT_SYMBOL(strncat);
 193
 194 /**
 195  * strcmp - Compare two strings
 196  * @cs: One string
 197  * @ct: Another string
 198  *
 199  * returns   0 if @cs and @ct are equal,
 200  *         < 0 if @cs is less than @ct
 201  *         > 0 if @cs is greater than @ct
 202  */
 203 int strcmp(const char *cs, const char *ct)
 204 {
 205         register int r0 asm("0") = 0;
 206         int ret = 0;
 207
 208         asm volatile ("0: clst %2,%3\n"
 209                       "   jo   0b\n"
 210                       "   je   1f\n"
 211                       "   ic   %0,0(%2)\n"
 212                       "   ic   %1,0(%3)\n"
 213                       "   sr   %0,%1\n"
 214                       "1:"
 215                       : "+d" (ret), "+d" (r0), "+a" (cs), "+a" (ct)
 216                       : : "cc" );
 217         return ret;
 218 }
 219 EXPORT_SYMBOL(strcmp);
 220
 221 /**
 222  * strrchr - Find the last occurrence of a character in a string
 223  * @s: The string to be searched
 224  * @c: The character to search for
 225  */
 226 char * strrchr(const char * s, int c)
 227 {
 228        size_t len = __strend(s) - s;
 229
 230        if (len)
 231                do {
 232                        if (s[len] == (char) c)
 233                                return (char *) s + len;
 234                } while (--len > 0);
 235        return NULL;
 236 }
 237 EXPORT_SYMBOL(strrchr);
 238
 239 static inline int clcle(const char *s1, unsigned long l1,
 240                         const char *s2, unsigned long l2)
 241 {
 242         register unsigned long r2 asm("2") = (unsigned long) s1;
 243         register unsigned long r3 asm("3") = (unsigned long) l1;
 244         register unsigned long r4 asm("4") = (unsigned long) s2;
 245         register unsigned long r5 asm("5") = (unsigned long) l2;
 246         int cc;
 247
 248         asm volatile ("0: clcle %1,%3,0\n"
 249                       "   jo    0b\n"
 250                       "   ipm   %0\n"
 251                       "   srl   %0,28"
 252                       : "=&d" (cc), "+a" (r2), "+a" (r3),
 253                         "+a" (r4), "+a" (r5) : : "cc");
 254         return cc;
 255 }
 256
 257 /**
 258  * strstr - Find the first substring in a %NUL terminated string
 259  * @s1: The string to be searched
 260  * @s2: The string to search for
 261  */
 262 char * strstr(const char * s1,const char * s2)
 263 {
 264         int l1, l2;
 265
 266         l2 = __strend(s2) - s2;
 267         if (!l2)
 268                 return (char *) s1;
 269         l1 = __strend(s1) - s1;
 270         while (l1-- >= l2) {
 271                 int cc;
 272
 273                 cc = clcle(s1, l2, s2, l2);
 274                 if (!cc)
 275                         return (char *) s1;
 276                 s1++;
 277         }
 278         return NULL;
 279 }
 280 EXPORT_SYMBOL(strstr);
 281
 282 /**
 283  * memchr - Find a character in an area of memory.
 284  * @s: The memory area
 285  * @c: The byte to search for
 286  * @n: The size of the area.
 287  *
 288  * returns the address of the first occurrence of @c, or %NULL
 289  * if @c is not found
 290  */
 291 void *memchr(const void *s, int c, size_t n)
 292 {
 293         register int r0 asm("0") = (char) c;
 294         const void *ret = s + n;
 295
 296         asm volatile ("0: srst  %0,%1\n"
 297                       "   jo    0b\n"
 298                       "   jl    1f\n"
 299                       "   la    %0,0\n"
 300                       "1:"
 301                       : "+a" (ret), "+&a" (s) : "d" (r0) : "cc" );
 302         return (void *) ret;
 303 }
 304 EXPORT_SYMBOL(memchr);
 305
 306 /**
 307  * memcmp - Compare two areas of memory
 308  * @cs: One area of memory
 309  * @ct: Another area of memory
 310  * @count: The size of the area.
 311  */
 312 int memcmp(const void *cs, const void *ct, size_t n)
 313 {
 314         int ret;
 315
 316         ret = clcle(cs, n, ct, n);
 317         if (ret)
 318                 ret = ret == 1 ? -1 : 1;
 319         return ret;
 320 }
 321 EXPORT_SYMBOL(memcmp);
 322
 323 /**
 324  * memscan - Find a character in an area of memory.
 325  * @s: The memory area
 326  * @c: The byte to search for
 327  * @n: The size of the area.
 328  *
 329  * returns the address of the first occurrence of @c, or 1 byte past
 330  * the area if @c is not found
 331  */
 332 void *memscan(void *s, int c, size_t n)
 333 {
 334         register int r0 asm("0") = (char) c;
 335         const void *ret = s + n;
 336
 337         asm volatile ("0: srst  %0,%1\n"
 338                       "   jo    0b\n"
 339                       : "+a" (ret), "+&a" (s) : "d" (r0) : "cc" );
 340         return (void *) ret;
 341 }
 342 EXPORT_SYMBOL(memscan);