Merge 2584fdda8d into 4fe9018b6f

- underlying functions were copied from musl, licensed MIT

Signed-off-by: Tavi <tavi@divested.dev>

CREDITS

@@ -23,6 +23,30 @@ h_malloc.c open-addressed hash table (regions_grow, regions_insert, regions_find
     ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
     OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
+*_musl functions extracted from musl and macros removed:
+    Copyright © 2005-2020 Rich Felker, et al.
+
+    Permission is hereby granted, free of charge, to any person obtaining
+    a copy of this software and associated documentation files (the
+    "Software"), to deal in the Software without restriction, including
+    without limitation the rights to use, copy, modify, merge, publish,
+    distribute, sublicense, and/or sell copies of the Software, and to
+    permit persons to whom the Software is furnished to do so, subject to
+    the following conditions:
+
+    The above copyright notice and this permission notice shall be
+    included in all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+    IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+    CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+    TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+    SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+    Contributor list: https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
+
 libdivide:
 
     Copyright (C) 2010 - 2019 ridiculous_fish, <libdivide@ridiculousfish.com>

h_malloc.c

@@ -19,7 +19,6 @@
 #include "pages.h"
 #include "random.h"
 #include "util.h"
-#include <dlfcn.h>
 
 #ifdef USE_PKEY
 #include <sys/mman.h>
@@ -1876,10 +1875,13 @@ EXPORT size_t h_malloc_object_size_fast(const void *p) {
 }
 
 #if CONFIG_BLOCK_OPS_CHECK_SIZE && !defined(HAS_ARM_MTE)
-FILE *(*original_memcpy)(void *restrict, const void *restrict, size_t);
+inline void EXCLUDE_REPLACEMENT *h_memcpy_musl(void *restrict dst, const void *restrict src, size_t len) {
-inline void *h_memcpy_real(void *restrict dst, const void *restrict src, size_t len) {
+    unsigned char *d = dst;
-    if(!original_memcpy) original_memcpy = dlsym(RTLD_NEXT, "memcpy");
+    const unsigned char *s = src;
-    return (*original_memcpy)(dst, src, len);
+
+    for (; len; len--) *d++ = *s++;
+
+    return dst;
 }
 
 EXPORT void *h_memcpy_wrapped(void *restrict dst, const void *restrict src, size_t len) {
@@ -1895,13 +1897,20 @@ EXPORT void *h_memcpy_wrapped(void *restrict dst, const void *restrict src, size
     if (len > malloc_object_size(dst)) {
         fatal_error("memcpy buffer overflow");
     }
-    return h_memcpy_real(dst, src, len);
+    return h_memcpy_musl(dst, src, len);
 }
 
-FILE *(*original_memmove)(void *, const void *, size_t);
+inline void EXCLUDE_REPLACEMENT *h_memmove_musl(void *dst, const void *src, size_t len) {
-inline void *h_memmove_real(void *dst, const void *src, size_t len) {
+    char *d = dst;
-    if(!original_memmove) original_memmove = dlsym(RTLD_NEXT, "memmove");
+    const char *s = src;
-    return (*original_memmove)(dst, src, len);
+
+    if (d < s) {
+        for (; len; len--) *d++ = *s++;
+    } else {
+        while (len) len--, d[len] = s[len];
+    }
+
+    return dst;
 }
 
 EXPORT void *h_memmove_wrapped(void *dst, const void *src, size_t len) {
@@ -1914,13 +1923,15 @@ EXPORT void *h_memmove_wrapped(void *dst, const void *src, size_t len) {
     if (len > malloc_object_size(dst)) {
         fatal_error("memmove buffer overflow");
     }
-    return h_memmove_real(dst, src, len);
+    return h_memmove_musl(dst, src, len);
 }
 
-FILE *(*original_memset)(void *, int, size_t);
+inline void EXCLUDE_REPLACEMENT *h_memset_musl(void *dst, int value, size_t len) {
-inline void *h_memset_real(void *dst, int value, size_t len) {
+    unsigned char *s = dst;
-    if(!original_memset) original_memset = dlsym(RTLD_NEXT, "memset");
+
-    return (*original_memset)(dst, value, len);
+    for (; len; len--, s++) *s = value;
+
+    return dst;
 }
 
 EXPORT void *h_memset_wrapped(void *dst, int value, size_t len) {
@@ -1930,13 +1941,15 @@ EXPORT void *h_memset_wrapped(void *dst, int value, size_t len) {
     if (len > malloc_object_size(dst)) {
         fatal_error("memset buffer overflow");
     }
-    return h_memset_real(dst, value, len);
+    return h_memset_musl(dst, value, len);
 }
 
-wchar_t *(*original_wmemcpy)(wchar_t *restrict, const wchar_t *restrict, size_t);
+inline wchar_t EXCLUDE_REPLACEMENT *h_wmemcpy_musl(wchar_t *restrict dst, const wchar_t *restrict src, size_t len) {
-inline wchar_t *h_wmemcpy_real(wchar_t *restrict dst, const wchar_t *restrict src, size_t len) {
+    wchar_t *ret = dst;
-    if(!original_wmemcpy) original_wmemcpy = dlsym(RTLD_NEXT, "wmemcpy");
+
-    return (*original_wmemcpy)(dst, src, len);
+    while (len--) *dst++ = *src++;
+
+    return ret;
 }
 
 EXPORT wchar_t *h_wmemcpy_wrapped(wchar_t *restrict dst, const wchar_t *restrict src, size_t len) {
@@ -1952,13 +1965,19 @@ EXPORT wchar_t *h_wmemcpy_wrapped(wchar_t *restrict dst, const wchar_t *restrict
     if (len > malloc_object_size(dst)) {
         fatal_error("wmemcpy buffer overflow");
     }
-    return h_wmemcpy_real(dst, src, len);
+    return h_wmemcpy_musl(dst, src, len);
 }
 
-wchar_t *(*original_wmemmove)(wchar_t *, const wchar_t *, size_t);
+inline wchar_t EXCLUDE_REPLACEMENT *h_wmemmove_musl(wchar_t *dst, const wchar_t *src, size_t len) {
-inline wchar_t *h_wmemmove_real(wchar_t *dst, const wchar_t *src, size_t len) {
+    wchar_t *ret = dst;
-    if(!original_wmemmove) original_wmemmove = dlsym(RTLD_NEXT, "wmemmove");
+
-    return (*original_wmemmove)(dst, src, len);
+    if ((uintptr_t)dst-(uintptr_t)src < len * sizeof *dst) {
+        while (len--) dst[len] = src[len];
+    } else {
+	while (len--) *dst++ = *src++;
+    }
+
+    return ret;
 }
 
 EXPORT wchar_t *h_wmemmove_wrapped(wchar_t *dst, const wchar_t *src, size_t len) {
@@ -1971,13 +1990,15 @@ EXPORT wchar_t *h_wmemmove_wrapped(wchar_t *dst, const wchar_t *src, size_t len)
     if (len > malloc_object_size(dst)) {
         fatal_error("wmemmove buffer overflow");
     }
-    return h_wmemmove_real(dst, src, len);
+    return h_wmemmove_musl(dst, src, len);
 }
 
-wchar_t *(*original_wmemset)(wchar_t *, wchar_t, size_t);
+inline wchar_t EXCLUDE_REPLACEMENT *h_wmemset_musl(wchar_t *dst, wchar_t value, size_t len) {
-inline wchar_t *h_wmemset_real(wchar_t *dst, wchar_t value, size_t len) {
+    wchar_t *ret = dst;
-    if(!original_wmemset) original_wmemset = dlsym(RTLD_NEXT, "wmemset");
+
-    return (*original_wmemset)(dst, value, len);
+    while (len--) *dst++ = value;
+
+    return ret;
 }
 
 EXPORT wchar_t *h_wmemset_wrapped(wchar_t *dst, wchar_t value, size_t len) {
@@ -1987,7 +2008,7 @@ EXPORT wchar_t *h_wmemset_wrapped(wchar_t *dst, wchar_t value, size_t len) {
     if (len > malloc_object_size(dst)) {
         fatal_error("wmemset buffer overflow");
     }
-    return h_wmemset_real(dst, value, len);
+    return h_wmemset_musl(dst, value, len);
 }
 #endif
 

include/h_malloc.h

@@ -62,23 +62,27 @@ __attribute__((alloc_size(2))) void *h_realloc(void *ptr, size_t size);
 __attribute__((malloc)) __attribute__((alloc_size(2))) __attribute__((alloc_align(1)))
 void *h_aligned_alloc(size_t alignment, size_t size);
 void h_free(void *ptr);
-
 #if CONFIG_BLOCK_OPS_CHECK_SIZE && !defined(HAS_ARM_MTE)
-void *h_memcpy_real(void *dst, const void *src, size_t len);
+#if defined(__clang__)
+#define EXCLUDE_REPLACEMENT __attribute__((optnone))
+#elif defined(__GNUC__) || defined(__GNUG__)
+#define EXCLUDE_REPLACEMENT __attribute__((__optimize__("-fno-tree-loop-distribute-patterns")))
+#endif
+void *h_memcpy_musl(void *dst, const void *src, size_t len);
 void *h_memcpy_wrapped(void *dst, const void *src, size_t len);
-void *h_memmove_real(void *dst, const void *src, size_t len);
+void *h_memmove_musl(void *dst, const void *src, size_t len);
 void *h_memmove_wrapped(void *dst, const void *src, size_t len);
-void *h_memset_real(void *dst, int value, size_t len);
+void *h_memset_musl(void *dst, int value, size_t len);
 void *h_memset_wrapped(void *dst, int value, size_t len);
-wchar_t *h_wmemcpy_real(wchar_t *dst, const wchar_t *src, size_t len);
+wchar_t *h_wmemcpy_musl(wchar_t *dst, const wchar_t *src, size_t len);
 wchar_t *h_wmemcpy_wrapped(wchar_t *dst, const wchar_t *src, size_t len);
-wchar_t *h_wmemmove_real(wchar_t *dst, const wchar_t *src, size_t len);
+wchar_t *h_wmemmove_musl(wchar_t *dst, const wchar_t *src, size_t len);
 wchar_t *h_wmemmove_wrapped(wchar_t *dst, const wchar_t *src, size_t len);
-wchar_t *h_wmemset_real(wchar_t *dst, wchar_t value, size_t len);
+wchar_t *h_wmemset_musl(wchar_t *dst, wchar_t value, size_t len);
 wchar_t *h_wmemset_wrapped(wchar_t *dst, wchar_t value, size_t len);
-#define h_memcpy_internal h_memcpy_real
+#define h_memcpy_internal h_memcpy_musl
-#define h_memove_internal h_memmove_real
+#define h_memove_internal h_memmove_musl
-#define h_memset_internal h_memset_real
+#define h_memset_internal h_memset_musl
 #else
 #define h_memcpy_internal __builtin_memcpy
 #define h_memove_internal __builtin_memmove