GNU Linux-libre 4.9.288-gnu1
[releases.git] / 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         ssize_t len = __strend(s) - s;
229
230         do {
231                 if (s[len] == (char)c)
232                         return (char *)s + len;
233         } while (--len >= 0);
234         return NULL;
235 }
236 EXPORT_SYMBOL(strrchr);
237
238 static inline int clcle(const char *s1, unsigned long l1,
239                         const char *s2, unsigned long l2)
240 {
241         register unsigned long r2 asm("2") = (unsigned long) s1;
242         register unsigned long r3 asm("3") = (unsigned long) l1;
243         register unsigned long r4 asm("4") = (unsigned long) s2;
244         register unsigned long r5 asm("5") = (unsigned long) l2;
245         int cc;
246
247         asm volatile ("0: clcle %1,%3,0\n"
248                       "   jo    0b\n"
249                       "   ipm   %0\n"
250                       "   srl   %0,28"
251                       : "=&d" (cc), "+a" (r2), "+a" (r3),
252                         "+a" (r4), "+a" (r5) : : "cc");
253         return cc;
254 }
255
256 /**
257  * strstr - Find the first substring in a %NUL terminated string
258  * @s1: The string to be searched
259  * @s2: The string to search for
260  */
261 char * strstr(const char * s1,const char * s2)
262 {
263         int l1, l2;
264
265         l2 = __strend(s2) - s2;
266         if (!l2)
267                 return (char *) s1;
268         l1 = __strend(s1) - s1;
269         while (l1-- >= l2) {
270                 int cc;
271
272                 cc = clcle(s1, l2, s2, l2);
273                 if (!cc)
274                         return (char *) s1;
275                 s1++;
276         }
277         return NULL;
278 }
279 EXPORT_SYMBOL(strstr);
280
281 /**
282  * memchr - Find a character in an area of memory.
283  * @s: The memory area
284  * @c: The byte to search for
285  * @n: The size of the area.
286  *
287  * returns the address of the first occurrence of @c, or %NULL
288  * if @c is not found
289  */
290 void *memchr(const void *s, int c, size_t n)
291 {
292         register int r0 asm("0") = (char) c;
293         const void *ret = s + n;
294
295         asm volatile ("0: srst  %0,%1\n"
296                       "   jo    0b\n"
297                       "   jl    1f\n"
298                       "   la    %0,0\n"
299                       "1:"
300                       : "+a" (ret), "+&a" (s) : "d" (r0) : "cc" );
301         return (void *) ret;
302 }
303 EXPORT_SYMBOL(memchr);
304
305 /**
306  * memcmp - Compare two areas of memory
307  * @cs: One area of memory
308  * @ct: Another area of memory
309  * @count: The size of the area.
310  */
311 int memcmp(const void *cs, const void *ct, size_t n)
312 {
313         int ret;
314
315         ret = clcle(cs, n, ct, n);
316         if (ret)
317                 ret = ret == 1 ? -1 : 1;
318         return ret;
319 }
320 EXPORT_SYMBOL(memcmp);
321
322 /**
323  * memscan - Find a character in an area of memory.
324  * @s: The memory area
325  * @c: The byte to search for
326  * @n: The size of the area.
327  *
328  * returns the address of the first occurrence of @c, or 1 byte past
329  * the area if @c is not found
330  */
331 void *memscan(void *s, int c, size_t n)
332 {
333         register int r0 asm("0") = (char) c;
334         const void *ret = s + n;
335
336         asm volatile ("0: srst  %0,%1\n"
337                       "   jo    0b\n"
338                       : "+a" (ret), "+&a" (s) : "d" (r0) : "cc" );
339         return (void *) ret;
340 }
341 EXPORT_SYMBOL(memscan);