1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * arch/arm/boot/compressed/string.c
  4 *
  5 * Small subset of simple string routines
  6 */
  7
 
  8#include <linux/string.h>
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  9
 10void *memcpy(void *__dest, __const void *__src, size_t __n)
 11{
 12	int i = 0;
 13	unsigned char *d = (unsigned char *)__dest, *s = (unsigned char *)__src;
 14
 15	for (i = __n >> 3; i > 0; i--) {
 16		*d++ = *s++;
 17		*d++ = *s++;
 18		*d++ = *s++;
 19		*d++ = *s++;
 20		*d++ = *s++;
 21		*d++ = *s++;
 22		*d++ = *s++;
 23		*d++ = *s++;
 24	}
 25
 26	if (__n & 1 << 2) {
 27		*d++ = *s++;
 28		*d++ = *s++;
 29		*d++ = *s++;
 30		*d++ = *s++;
 31	}
 32
 33	if (__n & 1 << 1) {
 34		*d++ = *s++;
 35		*d++ = *s++;
 36	}
 37
 38	if (__n & 1)
 39		*d++ = *s++;
 40
 41	return __dest;
 42}
 43
 44void *memmove(void *__dest, __const void *__src, size_t count)
 45{
 46	unsigned char *d = __dest;
 47	const unsigned char *s = __src;
 48
 49	if (__dest == __src)
 50		return __dest;
 51
 52	if (__dest < __src)
 53		return memcpy(__dest, __src, count);
 54
 55	while (count--)
 56		d[count] = s[count];
 57	return __dest;
 58}
 59
 60size_t strlen(const char *s)
 61{
 62	const char *sc = s;
 63
 64	while (*sc != '\0')
 65		sc++;
 66	return sc - s;
 67}
 68
 69size_t strnlen(const char *s, size_t count)
 70{
 71	const char *sc;
 72
 73	for (sc = s; count-- && *sc != '\0'; ++sc)
 74		/* nothing */;
 75	return sc - s;
 76}
 77
 78int memcmp(const void *cs, const void *ct, size_t count)
 79{
 80	const unsigned char *su1 = cs, *su2 = ct, *end = su1 + count;
 81	int res = 0;
 82
 83	while (su1 < end) {
 84		res = *su1++ - *su2++;
 85		if (res)
 86			break;
 87	}
 88	return res;
 89}
 90
 91int strcmp(const char *cs, const char *ct)
 92{
 93	unsigned char c1, c2;
 94	int res = 0;
 95
 96	do {
 97		c1 = *cs++;
 98		c2 = *ct++;
 99		res = c1 - c2;
100		if (res)
101			break;
102	} while (c1);
103	return res;
104}
105
106void *memchr(const void *s, int c, size_t count)
107{
108	const unsigned char *p = s;
109
110	while (count--)
111		if ((unsigned char)c == *p++)
112			return (void *)(p - 1);
113	return NULL;
114}
115
116char *strchr(const char *s, int c)
117{
118	while (*s != (char)c)
119		if (*s++ == '\0')
120			return NULL;
121	return (char *)s;
122}
123
124char *strrchr(const char *s, int c)
125{
126	const char *last = NULL;
127	do {
128		if (*s == (char)c)
129			last = s;
130	} while (*s++);
131	return (char *)last;
132}
133
134#undef memset
135
136void *memset(void *s, int c, size_t count)
137{
138	char *xs = s;
139	while (count--)
140		*xs++ = c;
141	return s;
142}

  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * arch/arm/boot/compressed/string.c
  4 *
  5 * Small subset of simple string routines
  6 */
  7
  8#define __NO_FORTIFY
  9#include <linux/string.h>
 10
 11/*
 12 * The decompressor is built without KASan but uses the same redirects as the
 13 * rest of the kernel when CONFIG_KASAN is enabled, defining e.g. memcpy()
 14 * to __memcpy() but since we are not linking with the main kernel string
 15 * library in the decompressor, that will lead to link failures.
 16 *
 17 * Undefine KASan's versions, define the wrapped functions and alias them to
 18 * the right names so that when e.g. __memcpy() appear in the code, it will
 19 * still be linked to this local version of memcpy().
 20 */
 21#ifdef CONFIG_KASAN
 22#undef memcpy
 23#undef memmove
 24#undef memset
 25void *__memcpy(void *__dest, __const void *__src, size_t __n) __alias(memcpy);
 26void *__memmove(void *__dest, __const void *__src, size_t count) __alias(memmove);
 27void *__memset(void *s, int c, size_t count) __alias(memset);
 28#endif
 29
 30void *memcpy(void *__dest, __const void *__src, size_t __n)
 31{
 32	int i = 0;
 33	unsigned char *d = (unsigned char *)__dest, *s = (unsigned char *)__src;
 34
 35	for (i = __n >> 3; i > 0; i--) {
 36		*d++ = *s++;
 37		*d++ = *s++;
 38		*d++ = *s++;
 39		*d++ = *s++;
 40		*d++ = *s++;
 41		*d++ = *s++;
 42		*d++ = *s++;
 43		*d++ = *s++;
 44	}
 45
 46	if (__n & 1 << 2) {
 47		*d++ = *s++;
 48		*d++ = *s++;
 49		*d++ = *s++;
 50		*d++ = *s++;
 51	}
 52
 53	if (__n & 1 << 1) {
 54		*d++ = *s++;
 55		*d++ = *s++;
 56	}
 57
 58	if (__n & 1)
 59		*d++ = *s++;
 60
 61	return __dest;
 62}
 63
 64void *memmove(void *__dest, __const void *__src, size_t count)
 65{
 66	unsigned char *d = __dest;
 67	const unsigned char *s = __src;
 68
 69	if (__dest == __src)
 70		return __dest;
 71
 72	if (__dest < __src)
 73		return memcpy(__dest, __src, count);
 74
 75	while (count--)
 76		d[count] = s[count];
 77	return __dest;
 78}
 79
 80size_t strlen(const char *s)
 81{
 82	const char *sc = s;
 83
 84	while (*sc != '\0')
 85		sc++;
 86	return sc - s;
 87}
 88
 89size_t strnlen(const char *s, size_t count)
 90{
 91	const char *sc;
 92
 93	for (sc = s; count-- && *sc != '\0'; ++sc)
 94		/* nothing */;
 95	return sc - s;
 96}
 97
 98int memcmp(const void *cs, const void *ct, size_t count)
 99{
100	const unsigned char *su1 = cs, *su2 = ct, *end = su1 + count;
101	int res = 0;
102
103	while (su1 < end) {
104		res = *su1++ - *su2++;
105		if (res)
106			break;
107	}
108	return res;
109}
110
111int strcmp(const char *cs, const char *ct)
112{
113	unsigned char c1, c2;
114	int res = 0;
115
116	do {
117		c1 = *cs++;
118		c2 = *ct++;
119		res = c1 - c2;
120		if (res)
121			break;
122	} while (c1);
123	return res;
124}
125
126void *memchr(const void *s, int c, size_t count)
127{
128	const unsigned char *p = s;
129
130	while (count--)
131		if ((unsigned char)c == *p++)
132			return (void *)(p - 1);
133	return NULL;
134}
135
136char *strchr(const char *s, int c)
137{
138	while (*s != (char)c)
139		if (*s++ == '\0')
140			return NULL;
141	return (char *)s;
142}
143
144char *strrchr(const char *s, int c)
145{
146	const char *last = NULL;
147	do {
148		if (*s == (char)c)
149			last = s;
150	} while (*s++);
151	return (char *)last;
152}
153
154#undef memset
155
156void *memset(void *s, int c, size_t count)
157{
158	char *xs = s;
159	while (count--)
160		*xs++ = c;
161	return s;
162}