arch/s390/lib/string.c

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