Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * arch/s390/lib/string.c | |
3 | * Optimized string functions | |
4 | * | |
5 | * S390 version | |
6 | * Copyright (C) 2004 IBM Deutschland Entwicklung GmbH, IBM Corporation | |
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/module.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" ); | |
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" ); | |
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 | { | |
1edad85b | 47 | #if __GNUC__ < 4 |
1da177e4 | 48 | return __strend(s) - s; |
1edad85b HC |
49 | #else |
50 | return __builtin_strlen(s); | |
51 | #endif | |
1da177e4 LT |
52 | } |
53 | EXPORT_SYMBOL(strlen); | |
54 | ||
55 | /** | |
56 | * strnlen - Find the length of a length-limited string | |
57 | * @s: The string to be sized | |
58 | * @n: The maximum number of bytes to search | |
59 | * | |
60 | * returns the minimum of the length of @s and @n | |
61 | */ | |
62 | size_t strnlen(const char * s, size_t n) | |
63 | { | |
64 | return __strnend(s, n) - s; | |
65 | } | |
66 | EXPORT_SYMBOL(strnlen); | |
67 | ||
68 | /** | |
69 | * strcpy - Copy a %NUL terminated string | |
70 | * @dest: Where to copy the string to | |
71 | * @src: Where to copy the string from | |
72 | * | |
73 | * returns a pointer to @dest | |
74 | */ | |
75 | char *strcpy(char *dest, const char *src) | |
76 | { | |
1edad85b | 77 | #if __GNUC__ < 4 |
1da177e4 LT |
78 | register int r0 asm("0") = 0; |
79 | char *ret = dest; | |
80 | ||
81 | asm volatile ("0: mvst %0,%1\n" | |
82 | " jo 0b" | |
83 | : "+&a" (dest), "+&a" (src) : "d" (r0) | |
84 | : "cc", "memory" ); | |
85 | return ret; | |
1edad85b HC |
86 | #else |
87 | return __builtin_strcpy(dest, src); | |
88 | #endif | |
1da177e4 LT |
89 | } |
90 | EXPORT_SYMBOL(strcpy); | |
91 | ||
92 | /** | |
93 | * strlcpy - Copy a %NUL terminated string into a sized buffer | |
94 | * @dest: Where to copy the string to | |
95 | * @src: Where to copy the string from | |
96 | * @size: size of destination buffer | |
97 | * | |
98 | * Compatible with *BSD: the result is always a valid | |
99 | * NUL-terminated string that fits in the buffer (unless, | |
100 | * of course, the buffer size is zero). It does not pad | |
101 | * out the result like strncpy() does. | |
102 | */ | |
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 | __builtin_memcpy(dest, src, len); | |
111 | } | |
112 | return ret; | |
113 | } | |
114 | EXPORT_SYMBOL(strlcpy); | |
115 | ||
116 | /** | |
117 | * strncpy - Copy a length-limited, %NUL-terminated string | |
118 | * @dest: Where to copy the string to | |
119 | * @src: Where to copy the string from | |
120 | * @n: The maximum number of bytes to copy | |
121 | * | |
122 | * The result is not %NUL-terminated if the source exceeds | |
123 | * @n bytes. | |
124 | */ | |
125 | char *strncpy(char *dest, const char *src, size_t n) | |
126 | { | |
127 | size_t len = __strnend(src, n) - src; | |
128 | __builtin_memset(dest + len, 0, n - len); | |
129 | __builtin_memcpy(dest, src, len); | |
130 | return dest; | |
131 | } | |
132 | EXPORT_SYMBOL(strncpy); | |
133 | ||
134 | /** | |
135 | * strcat - Append one %NUL-terminated string to another | |
136 | * @dest: The string to be appended to | |
137 | * @src: The string to append to it | |
138 | * | |
139 | * returns a pointer to @dest | |
140 | */ | |
141 | char *strcat(char *dest, const char *src) | |
142 | { | |
143 | register int r0 asm("0") = 0; | |
144 | unsigned long dummy; | |
145 | char *ret = dest; | |
146 | ||
147 | asm volatile ("0: srst %0,%1\n" | |
148 | " jo 0b\n" | |
149 | "1: mvst %0,%2\n" | |
150 | " jo 1b" | |
151 | : "=&a" (dummy), "+a" (dest), "+a" (src) | |
152 | : "d" (r0), "0" (0UL) : "cc", "memory" ); | |
153 | return ret; | |
154 | } | |
155 | EXPORT_SYMBOL(strcat); | |
156 | ||
157 | /** | |
158 | * strlcat - Append a length-limited, %NUL-terminated string to another | |
159 | * @dest: The string to be appended to | |
160 | * @src: The string to append to it | |
161 | * @n: The size of the destination buffer. | |
162 | */ | |
163 | size_t strlcat(char *dest, const char *src, size_t n) | |
164 | { | |
165 | size_t dsize = __strend(dest) - dest; | |
166 | size_t len = __strend(src) - src; | |
167 | size_t res = dsize + len; | |
168 | ||
169 | if (dsize < n) { | |
170 | dest += dsize; | |
171 | n -= dsize; | |
172 | if (len >= n) | |
173 | len = n - 1; | |
174 | dest[len] = '\0'; | |
175 | __builtin_memcpy(dest, src, len); | |
176 | } | |
177 | return res; | |
178 | } | |
179 | EXPORT_SYMBOL(strlcat); | |
180 | ||
181 | /** | |
182 | * strncat - Append a length-limited, %NUL-terminated string to another | |
183 | * @dest: The string to be appended to | |
184 | * @src: The string to append to it | |
185 | * @n: The maximum numbers of bytes to copy | |
186 | * | |
187 | * returns a pointer to @dest | |
188 | * | |
189 | * Note that in contrast to strncpy, strncat ensures the result is | |
190 | * terminated. | |
191 | */ | |
192 | char *strncat(char *dest, const char *src, size_t n) | |
193 | { | |
194 | size_t len = __strnend(src, n) - src; | |
195 | char *p = __strend(dest); | |
196 | ||
197 | p[len] = '\0'; | |
198 | __builtin_memcpy(p, src, len); | |
199 | return dest; | |
200 | } | |
201 | EXPORT_SYMBOL(strncat); | |
202 | ||
203 | /** | |
204 | * strcmp - Compare two strings | |
205 | * @cs: One string | |
206 | * @ct: Another string | |
207 | * | |
208 | * returns 0 if @cs and @ct are equal, | |
209 | * < 0 if @cs is less than @ct | |
210 | * > 0 if @cs is greater than @ct | |
211 | */ | |
212 | int strcmp(const char *cs, const char *ct) | |
213 | { | |
214 | register int r0 asm("0") = 0; | |
215 | int ret = 0; | |
216 | ||
217 | asm volatile ("0: clst %2,%3\n" | |
218 | " jo 0b\n" | |
219 | " je 1f\n" | |
220 | " ic %0,0(%2)\n" | |
221 | " ic %1,0(%3)\n" | |
222 | " sr %0,%1\n" | |
223 | "1:" | |
224 | : "+d" (ret), "+d" (r0), "+a" (cs), "+a" (ct) | |
225 | : : "cc" ); | |
226 | return ret; | |
227 | } | |
228 | EXPORT_SYMBOL(strcmp); | |
229 | ||
230 | /** | |
231 | * strrchr - Find the last occurrence of a character in a string | |
232 | * @s: The string to be searched | |
233 | * @c: The character to search for | |
234 | */ | |
235 | char * strrchr(const char * s, int c) | |
236 | { | |
237 | size_t len = __strend(s) - s; | |
238 | ||
239 | if (len) | |
240 | do { | |
241 | if (s[len] == (char) c) | |
242 | return (char *) s + len; | |
243 | } while (--len > 0); | |
d2c993d8 | 244 | return NULL; |
1da177e4 LT |
245 | } |
246 | EXPORT_SYMBOL(strrchr); | |
247 | ||
248 | /** | |
249 | * strstr - Find the first substring in a %NUL terminated string | |
250 | * @s1: The string to be searched | |
251 | * @s2: The string to search for | |
252 | */ | |
253 | char * strstr(const char * s1,const char * s2) | |
254 | { | |
255 | int l1, l2; | |
256 | ||
257 | l2 = __strend(s2) - s2; | |
258 | if (!l2) | |
259 | return (char *) s1; | |
260 | l1 = __strend(s1) - s1; | |
261 | while (l1-- >= l2) { | |
262 | register unsigned long r2 asm("2") = (unsigned long) s1; | |
263 | register unsigned long r3 asm("3") = (unsigned long) l2; | |
264 | register unsigned long r4 asm("4") = (unsigned long) s2; | |
265 | register unsigned long r5 asm("5") = (unsigned long) l2; | |
266 | int cc; | |
267 | ||
268 | asm volatile ("0: clcle %1,%3,0\n" | |
269 | " jo 0b\n" | |
270 | " ipm %0\n" | |
271 | " srl %0,28" | |
272 | : "=&d" (cc), "+a" (r2), "+a" (r3), | |
273 | "+a" (r4), "+a" (r5) : : "cc" ); | |
274 | if (!cc) | |
275 | return (char *) s1; | |
276 | s1++; | |
277 | } | |
d2c993d8 | 278 | return NULL; |
1da177e4 LT |
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 | register unsigned long r2 asm("2") = (unsigned long) cs; | |
315 | register unsigned long r3 asm("3") = (unsigned long) n; | |
316 | register unsigned long r4 asm("4") = (unsigned long) ct; | |
317 | register unsigned long r5 asm("5") = (unsigned long) n; | |
318 | int ret; | |
319 | ||
320 | asm volatile ("0: clcle %1,%3,0\n" | |
321 | " jo 0b\n" | |
322 | " ipm %0\n" | |
323 | " srl %0,28" | |
324 | : "=&d" (ret), "+a" (r2), "+a" (r3), "+a" (r4), "+a" (r5) | |
325 | : : "cc" ); | |
326 | if (ret) | |
327 | ret = *(char *) r2 - *(char *) r4; | |
328 | return ret; | |
329 | } | |
330 | EXPORT_SYMBOL(memcmp); | |
331 | ||
332 | /** | |
333 | * memscan - Find a character in an area of memory. | |
334 | * @s: The memory area | |
335 | * @c: The byte to search for | |
336 | * @n: The size of the area. | |
337 | * | |
338 | * returns the address of the first occurrence of @c, or 1 byte past | |
339 | * the area if @c is not found | |
340 | */ | |
341 | void *memscan(void *s, int c, size_t n) | |
342 | { | |
343 | register int r0 asm("0") = (char) c; | |
344 | const void *ret = s + n; | |
345 | ||
346 | asm volatile ("0: srst %0,%1\n" | |
347 | " jo 0b\n" | |
348 | : "+a" (ret), "+&a" (s) : "d" (r0) : "cc" ); | |
349 | return (void *) ret; | |
350 | } | |
351 | EXPORT_SYMBOL(memscan); | |
352 | ||
353 | /** | |
354 | * memcpy - Copy one area of memory to another | |
355 | * @dest: Where to copy to | |
356 | * @src: Where to copy from | |
357 | * @n: The size of the area. | |
358 | * | |
359 | * returns a pointer to @dest | |
360 | */ | |
361 | void *memcpy(void *dest, const void *src, size_t n) | |
362 | { | |
363 | return __builtin_memcpy(dest, src, n); | |
364 | } | |
365 | EXPORT_SYMBOL(memcpy); | |
366 | ||
367 | /** | |
368 | * memset - Fill a region of memory with the given value | |
369 | * @s: Pointer to the start of the area. | |
370 | * @c: The byte to fill the area with | |
371 | * @n: The size of the area. | |
372 | * | |
373 | * returns a pointer to @s | |
374 | */ | |
375 | void *memset(void *s, int c, size_t n) | |
376 | { | |
377 | char *xs; | |
378 | ||
379 | if (c == 0) | |
380 | return __builtin_memset(s, 0, n); | |
381 | ||
382 | xs = (char *) s; | |
383 | if (n > 0) | |
384 | do { | |
385 | *xs++ = c; | |
386 | } while (--n > 0); | |
387 | return s; | |
388 | } | |
389 | EXPORT_SYMBOL(memset); |