root/arch/arm/boot/compressed/string.c

DEFINITIONS

1. memcpy
2. memmove
3. strlen
4. strnlen
5. memcmp
6. strcmp
7. memchr
8. strchr
9. strrchr
10. memset

   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 
  10 void *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 
  44 void *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 
  60 size_t strlen(const char *s)
  61 {
  62         const char *sc = s;
  63 
  64         while (*sc != '\0')
  65                 sc++;
  66         return sc - s;
  67 }
  68 
  69 size_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 
  78 int 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 
  91 int 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 
 106 void *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 
 116 char *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 
 124 char *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 
 136 void *memset(void *s, int c, size_t count)
 137 {
 138         char *xs = s;
 139         while (count--)
 140                 *xs++ = c;
 141         return s;
 142 }