Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544/* SPDX-License-Identifier: LGPL-2.1 OR MIT *//* * stdlib function definitions for NOLIBC * Copyright (C) 2017-2021 Willy Tarreau <w@1wt.eu> */
/* make sure to include all global symbols */#include "nolibc.h"
#ifndef _NOLIBC_STDLIB_H#define _NOLIBC_STDLIB_H
#include "std.h"#include "arch.h"#include "types.h"#include "sys.h"#include "string.h"#include <linux/auxvec.h>
struct nolibc_heap { size_t len; char user_p[] __attribute__((__aligned__));};
/* Buffer used to store int-to-ASCII conversions. Will only be implemented if * any of the related functions is implemented. The area is large enough to * store "18446744073709551615" or "-9223372036854775808" and the final zero. */static __attribute__((unused)) char itoa_buffer[21];
/* * As much as possible, please keep functions alphabetically sorted. */
static __inline__int abs(int j){ return j >= 0 ? j : -j;}
static __inline__long labs(long j){ return j >= 0 ? j : -j;}
static __inline__long long llabs(long long j){ return j >= 0 ? j : -j;}
/* must be exported, as it's used by libgcc for various divide functions */void abort(void);__attribute__((weak,unused,noreturn,section(".text.nolibc_abort")))void abort(void){ _sys_kill(_sys_getpid(), SIGABRT); for (;;);}
static __attribute__((unused))long atol(const char *s){ unsigned long ret = 0; unsigned long d; int neg = 0;
if (*s == '-') { neg = 1; s++; }
while (1) { d = (*s++) - '0'; if (d > 9) break; ret *= 10; ret += d; }
return neg ? -ret : ret;}
static __attribute__((unused))int atoi(const char *s){ return atol(s);}
static __attribute__((unused))void free(void *ptr){ struct nolibc_heap *heap;
if (!ptr) return;
heap = container_of(ptr, struct nolibc_heap, user_p); munmap(heap, heap->len);}
#ifndef NOLIBC_NO_RUNTIME/* getenv() tries to find the environment variable named <name> in the * environment array pointed to by global variable "environ" which must be * declared as a char **, and must be terminated by a NULL (it is recommended * to set this variable to the "envp" argument of main()). If the requested * environment variable exists its value is returned otherwise NULL is * returned. */static __attribute__((unused))char *getenv(const char *name){ int idx, i;
if (environ) { for (idx = 0; environ[idx]; idx++) { for (i = 0; name[i] && name[i] == environ[idx][i];) i++; if (!name[i] && environ[idx][i] == '=') return &environ[idx][i+1]; } } return NULL;}#endif /* NOLIBC_NO_RUNTIME */
static __attribute__((unused))void *malloc(size_t len){ struct nolibc_heap *heap;
/* Always allocate memory with size multiple of 4096. */ len = sizeof(*heap) + len; len = (len + 4095UL) & -4096UL; heap = mmap(NULL, len, PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0); if (__builtin_expect(heap == MAP_FAILED, 0)) return NULL;
heap->len = len; return heap->user_p;}
static __attribute__((unused))void *calloc(size_t size, size_t nmemb){ size_t x;
if (__builtin_expect(__builtin_mul_overflow(size, nmemb, &x), 0)) { SET_ERRNO(ENOMEM); return NULL; }
/* * No need to zero the heap, the MAP_ANONYMOUS in malloc() * already does it. */ return malloc(x);}
static __attribute__((unused))void *realloc(void *old_ptr, size_t new_size){ struct nolibc_heap *heap; size_t user_p_len; void *ret;
if (!old_ptr) return malloc(new_size);
heap = container_of(old_ptr, struct nolibc_heap, user_p); user_p_len = heap->len - sizeof(*heap); /* * Don't realloc() if @user_p_len >= @new_size, this block of * memory is still enough to handle the @new_size. Just return * the same pointer. */ if (user_p_len >= new_size) return old_ptr;
ret = malloc(new_size); if (__builtin_expect(!ret, 0)) return NULL;
memcpy(ret, heap->user_p, user_p_len); munmap(heap, heap->len); return ret;}
/* Converts the unsigned 64bit integer <in> to base <base> ascii into * buffer <buffer>, which must be long enough to store the number and the * trailing zero. The buffer is filled from the first byte, and the number * of characters emitted (not counting the trailing zero) is returned. * The function uses 'multiply by reciprocal' for the divisions and * requires the caller pass the correct reciprocal. * * Note that unlike __div64_const32() in asm-generic/div64.h there isn't * an extra shift done (by ___p), the reciprocal has to be lower resulting * in a slightly low quotient. * Keep things simple by correcting for the error. * This also saves calculating the 'low * low' product (e2 below) which is * very unlikely to be significant. * * Some maths: * recip = p2 / base - e1; // With e1 < base. * q = (recip * in - e2) / p2; // With e2 < p2. * = base / in - (e1 * in + e2) / p2; * > base / in - (e1 * p2 + p2) / p2; * = base / in - ((e1 + 1) * p2) / p2; * > base / in - base; * So the maximum error is less than 'base'. * Hence the largest possible digit is '2 * base - 1'. * For base 10 e1 is 6 and you can get digits of 15 (eg from 2**64-1). * Error e1 is largest for a base that is a factor of 2**64+1, the smallest is 274177 * and converting 2**42-1 in base 274177 does generate a digit of 274177+274175. * This all means only a single correction is needed rather than a loop. * * __int128 isn't used for mips because gcc prior to 10.0 will call * __multi3 for MIPS64r6. The same also happens for SPARC and clang. */#define _NOLIBC_U64TOA_RECIP(base) ((base) & 1 ? ~0ull / (base) : (1ull << 63) / ((base) / 2))static __attribute__((unused, noinline))int _nolibc_u64toa_base(uint64_t in, char *buffer, unsigned int base, uint64_t recip){ unsigned int digits = 0; unsigned int dig; uint64_t q; char *p;
/* Generate least significant digit first */ do {#if defined(__SIZEOF_INT128__) && !defined(__mips__) && !defined(__sparc__) q = ((unsigned __int128)in * recip) >> 64;#else uint64_t p = (uint32_t)in * (recip >> 32); q = (in >> 32) * (recip >> 32) + (p >> 32); p = (uint32_t)p + (in >> 32) * (uint32_t)recip; q += p >> 32;#endif dig = in - q * base; /* Correct for any rounding errors */ if (dig >= base) { dig -= base; q++; } if (dig > 9) dig += 'a' - '0' - 10; buffer[digits++] = '0' + dig; } while ((in = q));
buffer[digits] = 0;
/* Order reverse to result */ for (p = buffer + digits - 1; p > buffer; buffer++, p--) { dig = *buffer; *buffer = *p; *p = dig; }
return digits;}
/* Converts the unsigned long integer <in> to its hex representation into * buffer <buffer>, which must be long enough to store the number and the * trailing zero (17 bytes for "ffffffffffffffff" or 9 for "ffffffff"). The * buffer is filled from the first byte, and the number of characters emitted * (not counting the trailing zero) is returned. */static __inline__ __attribute__((unused))int utoh_r(unsigned long in, char *buffer){ return _nolibc_u64toa_base(in, buffer, 16, _NOLIBC_U64TOA_RECIP(16));}
/* converts unsigned long <in> to an hex string using the static itoa_buffer * and returns the pointer to that string. */static __inline__ __attribute__((unused))char *utoh(unsigned long in){ utoh_r(in, itoa_buffer); return itoa_buffer;}
/* Converts the unsigned long integer <in> to its string representation into * buffer <buffer>, which must be long enough to store the number and the * trailing zero (21 bytes for 18446744073709551615 in 64-bit, 11 for * 4294967295 in 32-bit). The buffer is filled from the first byte, and the * number of characters emitted (not counting the trailing zero) is returned. */static __inline__ __attribute__((unused))int utoa_r(unsigned long in, char *buffer){ return _nolibc_u64toa_base(in, buffer, 10, _NOLIBC_U64TOA_RECIP(10));}
/* Converts the signed long integer <in> to its string representation into * buffer <buffer>, which must be long enough to store the number and the * trailing zero (21 bytes for -9223372036854775808 in 64-bit, 12 for * -2147483648 in 32-bit). The buffer is filled from the first byte, and the * number of characters emitted (not counting the trailing zero) is returned. */static __attribute__((unused))int itoa_r(long in, char *buffer){ char *ptr = buffer; int len = 0;
if (in < 0) { in = -(unsigned long)in; *(ptr++) = '-'; len++; } len += utoa_r(in, ptr); return len;}
/* for historical compatibility, same as above but returns the pointer to the * buffer. */static __inline__ __attribute__((unused))char *ltoa_r(long in, char *buffer){ itoa_r(in, buffer); return buffer;}
/* converts long integer <in> to a string using the static itoa_buffer and * returns the pointer to that string. */static __inline__ __attribute__((unused))char *itoa(long in){ itoa_r(in, itoa_buffer); return itoa_buffer;}
/* converts long integer <in> to a string using the static itoa_buffer and * returns the pointer to that string. Same as above, for compatibility. */static __inline__ __attribute__((unused))char *ltoa(long in){ itoa_r(in, itoa_buffer); return itoa_buffer;}
/* converts unsigned long integer <in> to a string using the static itoa_buffer * and returns the pointer to that string. */static __inline__ __attribute__((unused))char *utoa(unsigned long in){ utoa_r(in, itoa_buffer); return itoa_buffer;}
/* Converts the unsigned 64-bit integer <in> to its hex representation into * buffer <buffer>, which must be long enough to store the number and the * trailing zero (17 bytes for "ffffffffffffffff"). The buffer is filled from * the first byte, and the number of characters emitted (not counting the * trailing zero) is returned. */static __inline__ __attribute__((unused))int u64toh_r(uint64_t in, char *buffer){ return _nolibc_u64toa_base(in, buffer, 16, _NOLIBC_U64TOA_RECIP(16));}
/* converts uint64_t <in> to an hex string using the static itoa_buffer and * returns the pointer to that string. */static __inline__ __attribute__((unused))char *u64toh(uint64_t in){ u64toh_r(in, itoa_buffer); return itoa_buffer;}
/* Converts the unsigned 64-bit integer <in> to its string representation into * buffer <buffer>, which must be long enough to store the number and the * trailing zero (21 bytes for 18446744073709551615). The buffer is filled from * the first byte, and the number of characters emitted (not counting the * trailing zero) is returned. */static __inline__ __attribute__((unused))int u64toa_r(uint64_t in, char *buffer){ return _nolibc_u64toa_base(in, buffer, 10, _NOLIBC_U64TOA_RECIP(10));}
/* Converts the signed 64-bit integer <in> to its string representation into * buffer <buffer>, which must be long enough to store the number and the * trailing zero (21 bytes for -9223372036854775808). The buffer is filled from * the first byte, and the number of characters emitted (not counting the * trailing zero) is returned. */static __attribute__((unused))int i64toa_r(int64_t in, char *buffer){ char *ptr = buffer; int len = 0;
if (in < 0) { in = -(uint64_t)in; *(ptr++) = '-'; len++; } len += u64toa_r(in, ptr); return len;}
/* converts int64_t <in> to a string using the static itoa_buffer and returns * the pointer to that string. */static __inline__ __attribute__((unused))char *i64toa(int64_t in){ i64toa_r(in, itoa_buffer); return itoa_buffer;}
/* converts uint64_t <in> to a string using the static itoa_buffer and returns * the pointer to that string. */static __inline__ __attribute__((unused))char *u64toa(uint64_t in){ u64toa_r(in, itoa_buffer); return itoa_buffer;}
static __attribute__((unused))uintmax_t __strtox(const char *nptr, char **endptr, int base, intmax_t lower_limit, uintmax_t upper_limit){ const char signed_ = lower_limit != 0; unsigned char neg = 0, overflow = 0; uintmax_t val = 0, limit, old_val; char c;
if (base < 0 || base > 36) { SET_ERRNO(EINVAL); goto out; }
while (isspace(*nptr)) nptr++;
if (*nptr == '+') { nptr++; } else if (*nptr == '-') { neg = 1; nptr++; }
if (signed_ && neg) limit = -(uintmax_t)lower_limit; else limit = upper_limit;
if ((base == 0 || base == 16) && (strncmp(nptr, "0x", 2) == 0 || strncmp(nptr, "0X", 2) == 0)) { base = 16; nptr += 2; } else if (base == 0 && strncmp(nptr, "0", 1) == 0) { base = 8; nptr += 1; } else if (base == 0) { base = 10; }
while (*nptr) { c = *nptr;
if (c >= '0' && c <= '9') c -= '0'; else if (c >= 'a' && c <= 'z') c = c - 'a' + 10; else if (c >= 'A' && c <= 'Z') c = c - 'A' + 10; else goto out;
if (c >= base) goto out;
nptr++; old_val = val; val *= base; val += c;
if (val > limit || val < old_val) overflow = 1; }
out: if (overflow) { SET_ERRNO(ERANGE); val = limit; } if (endptr) *endptr = (char *)nptr; return neg ? -val : val;}
static __attribute__((unused))long strtol(const char *nptr, char **endptr, int base){ return __strtox(nptr, endptr, base, LONG_MIN, LONG_MAX);}
static __attribute__((unused))unsigned long strtoul(const char *nptr, char **endptr, int base){ return __strtox(nptr, endptr, base, 0, ULONG_MAX);}
static __attribute__((unused))long long strtoll(const char *nptr, char **endptr, int base){ return __strtox(nptr, endptr, base, LLONG_MIN, LLONG_MAX);}
static __attribute__((unused))unsigned long long strtoull(const char *nptr, char **endptr, int base){ return __strtox(nptr, endptr, base, 0, ULLONG_MAX);}
static __attribute__((unused))intmax_t strtoimax(const char *nptr, char **endptr, int base){ return __strtox(nptr, endptr, base, INTMAX_MIN, INTMAX_MAX);}
static __attribute__((unused))uintmax_t strtoumax(const char *nptr, char **endptr, int base){ return __strtox(nptr, endptr, base, 0, UINTMAX_MAX);}
#endif /* _NOLIBC_STDLIB_H */