Merge c0b4033769 into 4fe9018b6f

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

CREDITS

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

include/h_malloc.h

@@ -62,27 +62,23 @@ __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)
-#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_real(void *dst, const void *src, size_t len);
 void *h_memcpy_wrapped(void *dst, const void *src, size_t len);
-void *h_memmove_musl(void *dst, const void *src, size_t len);
+void *h_memmove_real(void *dst, const void *src, size_t len);
 void *h_memmove_wrapped(void *dst, const void *src, size_t len);
-void *h_memset_musl(void *dst, int value, size_t len);
+void *h_memset_real(void *dst, int value, size_t len);
 void *h_memset_wrapped(void *dst, int value, size_t len);
-wchar_t *h_wmemcpy_musl(wchar_t *dst, const wchar_t *src, size_t len);
+wchar_t *h_wmemcpy_real(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_musl(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_wrapped(wchar_t *dst, const wchar_t *src, size_t len);
-wchar_t *h_wmemset_musl(wchar_t *dst, wchar_t value, size_t len);
+wchar_t *h_wmemset_real(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_musl
-#define h_memove_internal h_memmove_musl
-#define h_memset_internal h_memset_musl
+#define h_memcpy_internal h_memcpy_real
+#define h_memove_internal h_memmove_real
+#define h_memset_internal h_memset_real
 #else
 #define h_memcpy_internal __builtin_memcpy
 #define h_memove_internal __builtin_memmove