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