]>
git.proxmox.com Git - mirror_ubuntu-focal-kernel.git/blob - arch/s390/lib/string.c
2 * Optimized string functions
5 * Copyright IBM Corp. 2004
6 * Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com)
9 #define IN_ARCH_STRING_C 1
11 #include <linux/types.h>
12 #include <linux/string.h>
13 #include <linux/export.h>
16 * Helper functions to find the end of a string
18 static inline char *__strend(const char *s
)
20 register unsigned long r0
asm("0") = 0;
22 asm volatile ("0: srst %0,%1\n"
24 : "+d" (r0
), "+a" (s
) : : "cc", "memory");
28 static inline char *__strnend(const char *s
, size_t n
)
30 register unsigned long r0
asm("0") = 0;
31 const char *p
= s
+ n
;
33 asm volatile ("0: srst %0,%1\n"
35 : "+d" (p
), "+a" (s
) : "d" (r0
) : "cc", "memory");
40 * strlen - Find the length of a string
41 * @s: The string to be sized
43 * returns the length of @s
45 size_t strlen(const char *s
)
47 return __strend(s
) - s
;
49 EXPORT_SYMBOL(strlen
);
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
56 * returns the minimum of the length of @s and @n
58 size_t strnlen(const char * s
, size_t n
)
60 return __strnend(s
, n
) - s
;
62 EXPORT_SYMBOL(strnlen
);
65 * strcpy - Copy a %NUL terminated string
66 * @dest: Where to copy the string to
67 * @src: Where to copy the string from
69 * returns a pointer to @dest
71 char *strcpy(char *dest
, const char *src
)
73 register int r0
asm("0") = 0;
76 asm volatile ("0: mvst %0,%1\n"
78 : "+&a" (dest
), "+&a" (src
) : "d" (r0
)
82 EXPORT_SYMBOL(strcpy
);
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
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.
95 size_t strlcpy(char *dest
, const char *src
, size_t size
)
97 size_t ret
= __strend(src
) - src
;
100 size_t len
= (ret
>= size
) ? size
-1 : ret
;
102 memcpy(dest
, src
, len
);
106 EXPORT_SYMBOL(strlcpy
);
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
114 * The result is not %NUL-terminated if the source exceeds
117 char *strncpy(char *dest
, const char *src
, size_t n
)
119 size_t len
= __strnend(src
, n
) - src
;
120 memset(dest
+ len
, 0, n
- len
);
121 memcpy(dest
, src
, len
);
124 EXPORT_SYMBOL(strncpy
);
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
131 * returns a pointer to @dest
133 char *strcat(char *dest
, const char *src
)
135 register int r0
asm("0") = 0;
139 asm volatile ("0: srst %0,%1\n"
143 : "=&a" (dummy
), "+a" (dest
), "+a" (src
)
144 : "d" (r0
), "0" (0UL) : "cc", "memory" );
147 EXPORT_SYMBOL(strcat
);
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.
155 size_t strlcat(char *dest
, const char *src
, size_t n
)
157 size_t dsize
= __strend(dest
) - dest
;
158 size_t len
= __strend(src
) - src
;
159 size_t res
= dsize
+ len
;
167 memcpy(dest
, src
, len
);
171 EXPORT_SYMBOL(strlcat
);
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
179 * returns a pointer to @dest
181 * Note that in contrast to strncpy, strncat ensures the result is
184 char *strncat(char *dest
, const char *src
, size_t n
)
186 size_t len
= __strnend(src
, n
) - src
;
187 char *p
= __strend(dest
);
193 EXPORT_SYMBOL(strncat
);
196 * strcmp - Compare two strings
198 * @ct: Another string
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
204 int strcmp(const char *cs
, const char *ct
)
206 register int r0
asm("0") = 0;
209 asm volatile ("0: clst %2,%3\n"
216 : "+d" (ret
), "+d" (r0
), "+a" (cs
), "+a" (ct
)
220 EXPORT_SYMBOL(strcmp
);
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
227 char * strrchr(const char * s
, int c
)
229 size_t len
= __strend(s
) - s
;
233 if (s
[len
] == (char) c
)
234 return (char *) s
+ len
;
238 EXPORT_SYMBOL(strrchr
);
240 static inline int clcle(const char *s1
, unsigned long l1
,
241 const char *s2
, unsigned long l2
)
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
;
249 asm volatile ("0: clcle %1,%3,0\n"
253 : "=&d" (cc
), "+a" (r2
), "+a" (r3
),
254 "+a" (r4
), "+a" (r5
) : : "cc", "memory");
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
263 char * strstr(const char * s1
,const char * s2
)
267 l2
= __strend(s2
) - s2
;
270 l1
= __strend(s1
) - s1
;
274 cc
= clcle(s1
, l2
, s2
, l2
);
281 EXPORT_SYMBOL(strstr
);
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.
289 * returns the address of the first occurrence of @c, or %NULL
292 void *memchr(const void *s
, int c
, size_t n
)
294 register int r0
asm("0") = (char) c
;
295 const void *ret
= s
+ n
;
297 asm volatile ("0: srst %0,%1\n"
302 : "+a" (ret
), "+&a" (s
) : "d" (r0
) : "cc", "memory");
305 EXPORT_SYMBOL(memchr
);
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.
313 int memcmp(const void *cs
, const void *ct
, size_t n
)
317 ret
= clcle(cs
, n
, ct
, n
);
319 ret
= ret
== 1 ? -1 : 1;
322 EXPORT_SYMBOL(memcmp
);
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.
330 * returns the address of the first occurrence of @c, or 1 byte past
331 * the area if @c is not found
333 void *memscan(void *s
, int c
, size_t n
)
335 register int r0
asm("0") = (char) c
;
336 const void *ret
= s
+ n
;
338 asm volatile ("0: srst %0,%1\n"
340 : "+a" (ret
), "+&a" (s
) : "d" (r0
) : "cc", "memory");
343 EXPORT_SYMBOL(memscan
);