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