arch/s390/lib/string.c - fp2-dev/kernel/msm - Gitiles

 /*
  *  arch/s390/lib/string.c
  *    Optimized string functions
  *
  *  S390 version
  *    Copyright (C) 2004 IBM Deutschland Entwicklung GmbH, IBM Corporation
  *    Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com)
  */

 #define IN_ARCH_STRING_C 1

 #include <linux/types.h>
 #include <linux/module.h>

 /*
  * Helper functions to find the end of a string
  */
 static inline char *__strend(const char *s)
 {
 	register unsigned long r0 asm("0") = 0;

 	asm volatile ("0: srst  %0,%1\n"
 		      "   jo    0b"
 		      : "+d" (r0), "+a" (s) :  : "cc" );
 	return (char *) r0;
 }

 static inline char *__strnend(const char *s, size_t n)
 {
 	register unsigned long r0 asm("0") = 0;
 	const char *p = s + n;

 	asm volatile ("0: srst  %0,%1\n"
 		      "   jo    0b"
 		      : "+d" (p), "+a" (s) : "d" (r0) : "cc" );
 	return (char *) p;
 }

 /**
  * strlen - Find the length of a string
  * @s: The string to be sized
  *
  * returns the length of @s
  */
 size_t strlen(const char *s)
 {
 	return __strend(s) - s;
 }
 EXPORT_SYMBOL(strlen);

 /**
  * strnlen - Find the length of a length-limited string
  * @s: The string to be sized
  * @n: The maximum number of bytes to search
  *
  * returns the minimum of the length of @s and @n
  */
 size_t strnlen(const char * s, size_t n)
 {
 	return __strnend(s, n) - s;
 }
 EXPORT_SYMBOL(strnlen);

 /**
  * strcpy - Copy a %NUL terminated string
  * @dest: Where to copy the string to
  * @src: Where to copy the string from
  *
  * returns a pointer to @dest
  */
 char *strcpy(char *dest, const char *src)
 {
 	register int r0 asm("0") = 0;
 	char *ret = dest;

 	asm volatile ("0: mvst  %0,%1\n"
 		      "   jo    0b"
 		      : "+&a" (dest), "+&a" (src) : "d" (r0)
 		      : "cc", "memory" );
 	return ret;
 }
 EXPORT_SYMBOL(strcpy);

 /**
  * strlcpy - Copy a %NUL terminated string into a sized buffer
  * @dest: Where to copy the string to
  * @src: Where to copy the string from
  * @size: size of destination buffer
  *
  * Compatible with *BSD: the result is always a valid
  * NUL-terminated string that fits in the buffer (unless,
  * of course, the buffer size is zero). It does not pad
  * out the result like strncpy() does.
  */
 size_t strlcpy(char *dest, const char *src, size_t size)
 {
 	size_t ret = __strend(src) - src;

 	if (size) {
 		size_t len = (ret >= size) ? size-1 : ret;
 		dest[len] = '\0';
 		__builtin_memcpy(dest, src, len);
 	}
 	return ret;
 }
 EXPORT_SYMBOL(strlcpy);

 /**
  * strncpy - Copy a length-limited, %NUL-terminated string
  * @dest: Where to copy the string to
  * @src: Where to copy the string from
  * @n: The maximum number of bytes to copy
  *
  * The result is not %NUL-terminated if the source exceeds
  * @n bytes.
  */
 char *strncpy(char *dest, const char *src, size_t n)
 {
 	size_t len = __strnend(src, n) - src;
 	__builtin_memset(dest + len, 0, n - len);
 	__builtin_memcpy(dest, src, len);
 	return dest;
 }
 EXPORT_SYMBOL(strncpy);

 /**
  * strcat - Append one %NUL-terminated string to another
  * @dest: The string to be appended to
  * @src: The string to append to it
  *
  * returns a pointer to @dest
  */
 char *strcat(char *dest, const char *src)
 {
 	register int r0 asm("0") = 0;
 	unsigned long dummy;
 	char *ret = dest;

 	asm volatile ("0: srst  %0,%1\n"
 		      "   jo    0b\n"
 		      "1: mvst  %0,%2\n"
 		      "   jo    1b"
 		      : "=&a" (dummy), "+a" (dest), "+a" (src)
 		      : "d" (r0), "0" (0UL) : "cc", "memory" );
 	return ret;
 }
 EXPORT_SYMBOL(strcat);

 /**
  * strlcat - Append a length-limited, %NUL-terminated string to another
  * @dest: The string to be appended to
  * @src: The string to append to it
  * @n: The size of the destination buffer.
  */
 size_t strlcat(char *dest, const char *src, size_t n)
 {
 	size_t dsize = __strend(dest) - dest;
 	size_t len = __strend(src) - src;
 	size_t res = dsize + len;

 	if (dsize < n) {
 		dest += dsize;
 		n -= dsize;
 		if (len >= n)
 			len = n - 1;
 		dest[len] = '\0';
 		__builtin_memcpy(dest, src, len);
 	}
 	return res;
 }
 EXPORT_SYMBOL(strlcat);

 /**
  * strncat - Append a length-limited, %NUL-terminated string to another
  * @dest: The string to be appended to
  * @src: The string to append to it
  * @n: The maximum numbers of bytes to copy
  *
  * returns a pointer to @dest
  *
  * Note that in contrast to strncpy, strncat ensures the result is
  * terminated.
  */
 char *strncat(char *dest, const char *src, size_t n)
 {
 	size_t len = __strnend(src, n) - src;
 	char *p = __strend(dest);

 	p[len] = '\0';
 	__builtin_memcpy(p, src, len);
 	return dest;
 }
 EXPORT_SYMBOL(strncat);

 /**
  * strcmp - Compare two strings
  * @cs: One string
  * @ct: Another string
  *
  * returns   0 if @cs and @ct are equal,
  *         < 0 if @cs is less than @ct
  *         > 0 if @cs is greater than @ct
  */
 int strcmp(const char *cs, const char *ct)
 {
 	register int r0 asm("0") = 0;
 	int ret = 0;

 	asm volatile ("0: clst %2,%3\n"
 		      "   jo   0b\n"
 		      "   je   1f\n"
 		      "   ic   %0,0(%2)\n"
 		      "   ic   %1,0(%3)\n"
 		      "   sr   %0,%1\n"
 		      "1:"
 		      : "+d" (ret), "+d" (r0), "+a" (cs), "+a" (ct)
 		      : : "cc" );
 	return ret;
 }
 EXPORT_SYMBOL(strcmp);

 /**
  * strrchr - Find the last occurrence of a character in a string
  * @s: The string to be searched
  * @c: The character to search for
  */
 char * strrchr(const char * s, int c)
 {
        size_t len = __strend(s) - s;

        if (len)
 	       do {
 		       if (s[len] == (char) c)
 			       return (char *) s + len;
 	       } while (--len > 0);
        return 0;
 }
 EXPORT_SYMBOL(strrchr);

 /**
  * strstr - Find the first substring in a %NUL terminated string
  * @s1: The string to be searched
  * @s2: The string to search for
  */
 char * strstr(const char * s1,const char * s2)
 {
 	int l1, l2;

 	l2 = __strend(s2) - s2;
 	if (!l2)
 		return (char *) s1;
 	l1 = __strend(s1) - s1;
 	while (l1-- >= l2) {
 		register unsigned long r2 asm("2") = (unsigned long) s1;
 		register unsigned long r3 asm("3") = (unsigned long) l2;
 		register unsigned long r4 asm("4") = (unsigned long) s2;
 		register unsigned long r5 asm("5") = (unsigned long) l2;
 		int cc;

 		asm volatile ("0: clcle %1,%3,0\n"
 			      "   jo    0b\n"
 			      "   ipm   %0\n"
 			      "   srl   %0,28"
 			      : "=&d" (cc), "+a" (r2), "+a" (r3),
 			        "+a" (r4), "+a" (r5) : : "cc" );
 		if (!cc)
 			return (char *) s1;
 		s1++;
 	}
 	return 0;
 }
 EXPORT_SYMBOL(strstr);

 /**
  * memchr - Find a character in an area of memory.
  * @s: The memory area
  * @c: The byte to search for
  * @n: The size of the area.
  *
  * returns the address of the first occurrence of @c, or %NULL
  * if @c is not found
  */
 void *memchr(const void *s, int c, size_t n)
 {
 	register int r0 asm("0") = (char) c;
 	const void *ret = s + n;

 	asm volatile ("0: srst  %0,%1\n"
 		      "   jo    0b\n"
 		      "   jl	1f\n"
 		      "   la    %0,0\n"
 		      "1:"
 		      : "+a" (ret), "+&a" (s) : "d" (r0) : "cc" );
 	return (void *) ret;
 }
 EXPORT_SYMBOL(memchr);

 /**
  * memcmp - Compare two areas of memory
  * @cs: One area of memory
  * @ct: Another area of memory
  * @count: The size of the area.
  */
 int memcmp(const void *cs, const void *ct, size_t n)
 {
 	register unsigned long r2 asm("2") = (unsigned long) cs;
 	register unsigned long r3 asm("3") = (unsigned long) n;
 	register unsigned long r4 asm("4") = (unsigned long) ct;
 	register unsigned long r5 asm("5") = (unsigned long) n;
 	int ret;

 	asm volatile ("0: clcle %1,%3,0\n"
 		      "   jo    0b\n"
 		      "   ipm   %0\n"
 		      "   srl   %0,28"
 		      : "=&d" (ret), "+a" (r2), "+a" (r3), "+a" (r4), "+a" (r5)
 		      : : "cc" );
 	if (ret)
 		ret = *(char *) r2 - *(char *) r4;
 	return ret;
 }
 EXPORT_SYMBOL(memcmp);

 /**
  * memscan - Find a character in an area of memory.
  * @s: The memory area
  * @c: The byte to search for
  * @n: The size of the area.
  *
  * returns the address of the first occurrence of @c, or 1 byte past
  * the area if @c is not found
  */
 void *memscan(void *s, int c, size_t n)
 {
 	register int r0 asm("0") = (char) c;
 	const void *ret = s + n;

 	asm volatile ("0: srst  %0,%1\n"
 		      "   jo    0b\n"
 		      : "+a" (ret), "+&a" (s) : "d" (r0) : "cc" );
 	return (void *) ret;
 }
 EXPORT_SYMBOL(memscan);

 /**
  * memcpy - Copy one area of memory to another
  * @dest: Where to copy to
  * @src: Where to copy from
  * @n: The size of the area.
  *
  * returns a pointer to @dest
  */
 void *memcpy(void *dest, const void *src, size_t n)
 {
 	return __builtin_memcpy(dest, src, n);
 }
 EXPORT_SYMBOL(memcpy);

 /**
  * memset - Fill a region of memory with the given value
  * @s: Pointer to the start of the area.
  * @c: The byte to fill the area with
  * @n: The size of the area.
  *
  * returns a pointer to @s
  */
 void *memset(void *s, int c, size_t n)
 {
 	char *xs;

 	if (c == 0)
 		return __builtin_memset(s, 0, n);

 	xs = (char *) s;
 	if (n > 0)
 		do {
 			*xs++ = c;
 		} while (--n > 0);
 	return s;
 }
 EXPORT_SYMBOL(memset);
	/*
	* arch/s390/lib/string.c
	* Optimized string functions
	*
	* S390 version
	* Copyright (C) 2004 IBM Deutschland Entwicklung GmbH, IBM Corporation
	* Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com)
	*/

	#define IN_ARCH_STRING_C 1

	#include <linux/types.h>
	#include <linux/module.h>

	/*
	* Helper functions to find the end of a string
	*/
	static inline char __strend(const char s)
	{
	register unsigned long r0 asm("0") = 0;

	asm volatile ("0: srst %0,%1\n"
	" jo 0b"
	: "+d" (r0), "+a" (s) : : "cc" );
	return (char *) r0;
	}

	static inline char __strnend(const char s, size_t n)
	{
	register unsigned long r0 asm("0") = 0;
	const char *p = s + n;

	asm volatile ("0: srst %0,%1\n"
	" jo 0b"
	: "+d" (p), "+a" (s) : "d" (r0) : "cc" );
	return (char *) p;
	}

	/**
	* strlen - Find the length of a string
	* @s: The string to be sized
	*
	* returns the length of @s
	*/
	size_t strlen(const char *s)
	{
	return __strend(s) - s;
	}
	EXPORT_SYMBOL(strlen);

	/**
	* strnlen - Find the length of a length-limited string
	* @s: The string to be sized
	* @n: The maximum number of bytes to search
	*
	* returns the minimum of the length of @s and @n
	*/
	size_t strnlen(const char * s, size_t n)
	{
	return __strnend(s, n) - s;
	}
	EXPORT_SYMBOL(strnlen);

	/**
	* strcpy - Copy a %NUL terminated string
	* @dest: Where to copy the string to
	* @src: Where to copy the string from
	*
	* returns a pointer to @dest
	*/
	char strcpy(char dest, const char *src)
	{
	register int r0 asm("0") = 0;
	char *ret = dest;

	asm volatile ("0: mvst %0,%1\n"
	" jo 0b"
	: "+&a" (dest), "+&a" (src) : "d" (r0)
	: "cc", "memory" );
	return ret;
	}
	EXPORT_SYMBOL(strcpy);

	/**
	* strlcpy - Copy a %NUL terminated string into a sized buffer
	* @dest: Where to copy the string to
	* @src: Where to copy the string from
	* @size: size of destination buffer
	*
	* Compatible with *BSD: the result is always a valid
	* NUL-terminated string that fits in the buffer (unless,
	* of course, the buffer size is zero). It does not pad
	* out the result like strncpy() does.
	*/
	size_t strlcpy(char dest, const char src, size_t size)
	{
	size_t ret = __strend(src) - src;

	if (size) {
	size_t len = (ret >= size) ? size-1 : ret;
	dest[len] = '\0';
	__builtin_memcpy(dest, src, len);
	}
	return ret;
	}
	EXPORT_SYMBOL(strlcpy);

	/**
	* strncpy - Copy a length-limited, %NUL-terminated string
	* @dest: Where to copy the string to
	* @src: Where to copy the string from
	* @n: The maximum number of bytes to copy
	*
	* The result is not %NUL-terminated if the source exceeds
	* @n bytes.
	*/
	char strncpy(char dest, const char *src, size_t n)
	{
	size_t len = __strnend(src, n) - src;
	__builtin_memset(dest + len, 0, n - len);
	__builtin_memcpy(dest, src, len);
	return dest;
	}
	EXPORT_SYMBOL(strncpy);

	/**
	* strcat - Append one %NUL-terminated string to another
	* @dest: The string to be appended to
	* @src: The string to append to it
	*
	* returns a pointer to @dest
	*/
	char strcat(char dest, const char *src)
	{
	register int r0 asm("0") = 0;
	unsigned long dummy;
	char *ret = dest;

	asm volatile ("0: srst %0,%1\n"
	" jo 0b\n"
	"1: mvst %0,%2\n"
	" jo 1b"
	: "=&a" (dummy), "+a" (dest), "+a" (src)
	: "d" (r0), "0" (0UL) : "cc", "memory" );
	return ret;
	}
	EXPORT_SYMBOL(strcat);

	/**
	* strlcat - Append a length-limited, %NUL-terminated string to another
	* @dest: The string to be appended to
	* @src: The string to append to it
	* @n: The size of the destination buffer.
	*/
	size_t strlcat(char dest, const char src, size_t n)
	{
	size_t dsize = __strend(dest) - dest;
	size_t len = __strend(src) - src;
	size_t res = dsize + len;

	if (dsize < n) {
	dest += dsize;
	n -= dsize;
	if (len >= n)
	len = n - 1;
	dest[len] = '\0';
	__builtin_memcpy(dest, src, len);
	}
	return res;
	}
	EXPORT_SYMBOL(strlcat);

	/**
	* strncat - Append a length-limited, %NUL-terminated string to another
	* @dest: The string to be appended to
	* @src: The string to append to it
	* @n: The maximum numbers of bytes to copy
	*
	* returns a pointer to @dest
	*
	* Note that in contrast to strncpy, strncat ensures the result is
	* terminated.
	*/
	char strncat(char dest, const char *src, size_t n)
	{
	size_t len = __strnend(src, n) - src;
	char *p = __strend(dest);

	p[len] = '\0';
	__builtin_memcpy(p, src, len);
	return dest;
	}
	EXPORT_SYMBOL(strncat);

	/**
	* strcmp - Compare two strings
	* @cs: One string
	* @ct: Another string
	*
	* returns 0 if @cs and @ct are equal,
	* < 0 if @cs is less than @ct
	* > 0 if @cs is greater than @ct
	*/
	int strcmp(const char cs, const char ct)
	{
	register int r0 asm("0") = 0;
	int ret = 0;

	asm volatile ("0: clst %2,%3\n"
	" jo 0b\n"
	" je 1f\n"
	" ic %0,0(%2)\n"
	" ic %1,0(%3)\n"
	" sr %0,%1\n"
	"1:"
	: "+d" (ret), "+d" (r0), "+a" (cs), "+a" (ct)
	: : "cc" );
	return ret;
	}
	EXPORT_SYMBOL(strcmp);

	/**
	* strrchr - Find the last occurrence of a character in a string
	* @s: The string to be searched
	* @c: The character to search for
	*/
	char * strrchr(const char * s, int c)
	{
	size_t len = __strend(s) - s;

	if (len)
	do {
	if (s[len] == (char) c)
	return (char *) s + len;
	} while (--len > 0);
	return 0;
	}
	EXPORT_SYMBOL(strrchr);

	/**
	* strstr - Find the first substring in a %NUL terminated string
	* @s1: The string to be searched
	* @s2: The string to search for
	*/
	char * strstr(const char * s1,const char * s2)
	{
	int l1, l2;

	l2 = __strend(s2) - s2;
	if (!l2)
	return (char *) s1;
	l1 = __strend(s1) - s1;
	while (l1-- >= l2) {
	register unsigned long r2 asm("2") = (unsigned long) s1;
	register unsigned long r3 asm("3") = (unsigned long) l2;
	register unsigned long r4 asm("4") = (unsigned long) s2;
	register unsigned long r5 asm("5") = (unsigned long) l2;
	int cc;

	asm volatile ("0: clcle %1,%3,0\n"
	" jo 0b\n"
	" ipm %0\n"
	" srl %0,28"
	: "=&d" (cc), "+a" (r2), "+a" (r3),
	"+a" (r4), "+a" (r5) : : "cc" );
	if (!cc)
	return (char *) s1;
	s1++;
	}
	return 0;
	}
	EXPORT_SYMBOL(strstr);

	/**
	* memchr - Find a character in an area of memory.
	* @s: The memory area
	* @c: The byte to search for
	* @n: The size of the area.
	*
	* returns the address of the first occurrence of @c, or %NULL
	* if @c is not found
	*/
	void memchr(const void s, int c, size_t n)
	{
	register int r0 asm("0") = (char) c;
	const void *ret = s + n;

	asm volatile ("0: srst %0,%1\n"
	" jo 0b\n"
	" jl 1f\n"
	" la %0,0\n"
	"1:"
	: "+a" (ret), "+&a" (s) : "d" (r0) : "cc" );
	return (void *) ret;
	}
	EXPORT_SYMBOL(memchr);

	/**
	* memcmp - Compare two areas of memory
	* @cs: One area of memory
	* @ct: Another area of memory
	* @count: The size of the area.
	*/
	int memcmp(const void cs, const void ct, size_t n)
	{
	register unsigned long r2 asm("2") = (unsigned long) cs;
	register unsigned long r3 asm("3") = (unsigned long) n;
	register unsigned long r4 asm("4") = (unsigned long) ct;
	register unsigned long r5 asm("5") = (unsigned long) n;
	int ret;

	asm volatile ("0: clcle %1,%3,0\n"
	" jo 0b\n"
	" ipm %0\n"
	" srl %0,28"
	: "=&d" (ret), "+a" (r2), "+a" (r3), "+a" (r4), "+a" (r5)
	: : "cc" );
	if (ret)
	ret = (char ) r2 - (char ) r4;
	return ret;
	}
	EXPORT_SYMBOL(memcmp);

	/**
	* memscan - Find a character in an area of memory.
	* @s: The memory area
	* @c: The byte to search for
	* @n: The size of the area.
	*
	* returns the address of the first occurrence of @c, or 1 byte past
	* the area if @c is not found
	*/
	void memscan(void s, int c, size_t n)
	{
	register int r0 asm("0") = (char) c;
	const void *ret = s + n;

	asm volatile ("0: srst %0,%1\n"
	" jo 0b\n"
	: "+a" (ret), "+&a" (s) : "d" (r0) : "cc" );
	return (void *) ret;
	}
	EXPORT_SYMBOL(memscan);

	/**
	* memcpy - Copy one area of memory to another
	* @dest: Where to copy to
	* @src: Where to copy from
	* @n: The size of the area.
	*
	* returns a pointer to @dest
	*/
	void memcpy(void dest, const void *src, size_t n)
	{
	return __builtin_memcpy(dest, src, n);
	}
	EXPORT_SYMBOL(memcpy);

	/**
	* memset - Fill a region of memory with the given value
	* @s: Pointer to the start of the area.
	* @c: The byte to fill the area with
	* @n: The size of the area.
	*
	* returns a pointer to @s
	*/
	void memset(void s, int c, size_t n)
	{
	char *xs;

	if (c == 0)
	return __builtin_memset(s, 0, n);

	xs = (char *) s;
	if (n > 0)
	do {
	*xs++ = c;
	} while (--n > 0);
	return s;
	}
	EXPORT_SYMBOL(memset);