tools/include/nolibc/string.h

   1 /* SPDX-License-Identifier: LGPL-2.1 OR MIT */
   2 /*
   3  * string function definitions for NOLIBC
   4  * Copyright (C) 2017-2021 Willy Tarreau <w@1wt.eu>
   5  */
   6
   7 #ifndef _NOLIBC_STRING_H
   8 #define _NOLIBC_STRING_H
   9
  10 #include "arch.h"
  11 #include "std.h"
  12
  13 static void *malloc(size_t len);
  14
  15 /*
  16  * As much as possible, please keep functions alphabetically sorted.
  17  */
  18
  19 static __attribute__((unused))
  20 int memcmp(const void *s1, const void *s2, size_t n)
  21 {
  22         size_t ofs = 0;
  23         int c1 = 0;
  24
  25         while (ofs < n && !(c1 = ((unsigned char *)s1)[ofs] - ((unsigned char *)s2)[ofs])) {
  26                 ofs++;
  27         }
  28         return c1;
  29 }
  30
  31 #ifndef NOLIBC_ARCH_HAS_MEMMOVE
  32 /* might be ignored by the compiler without -ffreestanding, then found as
  33  * missing.
  34  */
  35 __attribute__((weak,unused,section(".text.nolibc_memmove")))
  36 void *memmove(void *dst, const void *src, size_t len)
  37 {
  38         size_t dir, pos;
  39
  40         pos = len;
  41         dir = -1;
  42
  43         if (dst < src) {
  44                 pos = -1;
  45                 dir = 1;
  46         }
  47
  48         while (len) {
  49                 pos += dir;
  50                 ((char *)dst)[pos] = ((const char *)src)[pos];
  51                 len--;
  52         }
  53         return dst;
  54 }
  55 #endif /* #ifndef NOLIBC_ARCH_HAS_MEMMOVE */
  56
  57 #ifndef NOLIBC_ARCH_HAS_MEMCPY
  58 /* must be exported, as it's used by libgcc on ARM */
  59 __attribute__((weak,unused,section(".text.nolibc_memcpy")))
  60 void *memcpy(void *dst, const void *src, size_t len)
  61 {
  62         size_t pos = 0;
  63
  64         while (pos < len) {
  65                 ((char *)dst)[pos] = ((const char *)src)[pos];
  66                 pos++;
  67         }
  68         return dst;
  69 }
  70 #endif /* #ifndef NOLIBC_ARCH_HAS_MEMCPY */
  71
  72 #ifndef NOLIBC_ARCH_HAS_MEMSET
  73 /* might be ignored by the compiler without -ffreestanding, then found as
  74  * missing.
  75  */
  76 __attribute__((weak,unused,section(".text.nolibc_memset")))
  77 void *memset(void *dst, int b, size_t len)
  78 {
  79         char *p = dst;
  80
  81         while (len--) {
  82                 /* prevent gcc from recognizing memset() here */
  83                 __asm__ volatile("");
  84                 *(p++) = b;
  85         }
  86         return dst;
  87 }
  88 #endif /* #ifndef NOLIBC_ARCH_HAS_MEMSET */
  89
  90 static __attribute__((unused))
  91 char *strchr(const char *s, int c)
  92 {
  93         while (*s) {
  94                 if (*s == (char)c)
  95                         return (char *)s;
  96                 s++;
  97         }
  98         return NULL;
  99 }
 100
 101 static __attribute__((unused))
 102 int strcmp(const char *a, const char *b)
 103 {
 104         unsigned int c;
 105         int diff;
 106
 107         while (!(diff = (unsigned char)*a++ - (c = (unsigned char)*b++)) && c)
 108                 ;
 109         return diff;
 110 }
 111
 112 static __attribute__((unused))
 113 char *strcpy(char *dst, const char *src)
 114 {
 115         char *ret = dst;
 116
 117         while ((*dst++ = *src++));
 118         return ret;
 119 }
 120
 121 /* this function is only used with arguments that are not constants or when
 122  * it's not known because optimizations are disabled. Note that gcc 12
 123  * recognizes an strlen() pattern and replaces it with a jump to strlen(),
 124  * thus itself, hence the asm() statement below that's meant to disable this
 125  * confusing practice.
 126  */
 127 __attribute__((weak,unused,section(".text.nolibc_strlen")))
 128 size_t strlen(const char *str)
 129 {
 130         size_t len;
 131
 132         for (len = 0; str[len]; len++)
 133                 __asm__("");
 134         return len;
 135 }
 136
 137 /* do not trust __builtin_constant_p() at -O0, as clang will emit a test and
 138  * the two branches, then will rely on an external definition of strlen().
 139  */
 140 #if defined(__OPTIMIZE__)
 141 #define nolibc_strlen(x) strlen(x)
 142 #define strlen(str) ({                          \
 143         __builtin_constant_p((str)) ?           \
 144                 __builtin_strlen((str)) :       \
 145                 nolibc_strlen((str));           \
 146 })
 147 #endif
 148
 149 static __attribute__((unused))
 150 size_t strnlen(const char *str, size_t maxlen)
 151 {
 152         size_t len;
 153
 154         for (len = 0; (len < maxlen) && str[len]; len++);
 155         return len;
 156 }
 157
 158 static __attribute__((unused))
 159 char *strdup(const char *str)
 160 {
 161         size_t len;
 162         char *ret;
 163
 164         len = strlen(str);
 165         ret = malloc(len + 1);
 166         if (__builtin_expect(ret != NULL, 1))
 167                 memcpy(ret, str, len + 1);
 168
 169         return ret;
 170 }
 171
 172 static __attribute__((unused))
 173 char *strndup(const char *str, size_t maxlen)
 174 {
 175         size_t len;
 176         char *ret;
 177
 178         len = strnlen(str, maxlen);
 179         ret = malloc(len + 1);
 180         if (__builtin_expect(ret != NULL, 1)) {
 181                 memcpy(ret, str, len);
 182                 ret[len] = '\0';
 183         }
 184
 185         return ret;
 186 }
 187
 188 static __attribute__((unused))
 189 size_t strlcat(char *dst, const char *src, size_t size)
 190 {
 191         size_t len = strnlen(dst, size);
 192
 193         /*
 194          * We want len < size-1. But as size is unsigned and can wrap
 195          * around, we use len + 1 instead.
 196          */
 197         while (len + 1 < size) {
 198                 dst[len] = *src;
 199                 if (*src == '\0')
 200                         break;
 201                 len++;
 202                 src++;
 203         }
 204
 205         if (len < size)
 206                 dst[len] = '\0';
 207
 208         while (*src++)
 209                 len++;
 210
 211         return len;
 212 }
 213
 214 static __attribute__((unused))
 215 size_t strlcpy(char *dst, const char *src, size_t size)
 216 {
 217         size_t len;
 218
 219         for (len = 0; len < size; len++) {
 220                 dst[len] = src[len];
 221                 if (!dst[len])
 222                         return len;
 223         }
 224         if (size)
 225                 dst[size-1] = '\0';
 226
 227         while (src[len])
 228                 len++;
 229
 230         return len;
 231 }
 232
 233 static __attribute__((unused))
 234 char *strncat(char *dst, const char *src, size_t size)
 235 {
 236         char *orig = dst;
 237
 238         while (*dst)
 239                 dst++;
 240
 241         while (size && (*dst = *src)) {
 242                 src++;
 243                 dst++;
 244                 size--;
 245         }
 246
 247         *dst = 0;
 248         return orig;
 249 }
 250
 251 static __attribute__((unused))
 252 int strncmp(const char *a, const char *b, size_t size)
 253 {
 254         unsigned int c;
 255         int diff = 0;
 256
 257         while (size-- &&
 258                !(diff = (unsigned char)*a++ - (c = (unsigned char)*b++)) && c)
 259                 ;
 260
 261         return diff;
 262 }
 263
 264 static __attribute__((unused))
 265 char *strncpy(char *dst, const char *src, size_t size)
 266 {
 267         size_t len;
 268
 269         for (len = 0; len < size; len++)
 270                 if ((dst[len] = *src))
 271                         src++;
 272         return dst;
 273 }
 274
 275 static __attribute__((unused))
 276 char *strrchr(const char *s, int c)
 277 {
 278         const char *ret = NULL;
 279
 280         while (*s) {
 281                 if (*s == (char)c)
 282                         ret = s;
 283                 s++;
 284         }
 285         return (char *)ret;
 286 }
 287
 288 /* make sure to include all global symbols */
 289 #include "nolibc.h"
 290
 291 #endif /* _NOLIBC_STRING_H */