1 | /* ---------------------------------------------------------------------------- |
2 | Copyright (c) 2018-2021, Microsoft Research, Daan Leijen |
3 | This is free software; you can redistribute it and/or modify it under the |
4 | terms of the MIT license. A copy of the license can be found in the file |
5 | "LICENSE" at the root of this distribution. |
6 | -----------------------------------------------------------------------------*/ |
7 | |
8 | // ------------------------------------------------------------------------ |
9 | // mi prefixed publi definitions of various Posix, Unix, and C++ functions |
10 | // for convenience and used when overriding these functions. |
11 | // ------------------------------------------------------------------------ |
12 | #include "mimalloc.h" |
13 | #include "mimalloc-internal.h" |
14 | |
15 | // ------------------------------------------------------ |
16 | // Posix & Unix functions definitions |
17 | // ------------------------------------------------------ |
18 | |
19 | #include <errno.h> |
20 | #include <string.h> // memset |
21 | #include <stdlib.h> // getenv |
22 | |
23 | #ifdef _MSC_VER |
24 | #pragma warning(disable:4996) // getenv _wgetenv |
25 | #endif |
26 | |
27 | #ifndef EINVAL |
28 | #define EINVAL 22 |
29 | #endif |
30 | #ifndef ENOMEM |
31 | #define ENOMEM 12 |
32 | #endif |
33 | |
34 | |
35 | mi_decl_nodiscard size_t mi_malloc_size(const void* p) mi_attr_noexcept { |
36 | //if (!mi_is_in_heap_region(p)) return 0; |
37 | return mi_usable_size(p); |
38 | } |
39 | |
40 | mi_decl_nodiscard size_t mi_malloc_usable_size(const void *p) mi_attr_noexcept { |
41 | //if (!mi_is_in_heap_region(p)) return 0; |
42 | return mi_usable_size(p); |
43 | } |
44 | |
45 | mi_decl_nodiscard size_t mi_malloc_good_size(size_t size) mi_attr_noexcept { |
46 | return mi_good_size(size); |
47 | } |
48 | |
49 | void mi_cfree(void* p) mi_attr_noexcept { |
50 | if (mi_is_in_heap_region(p)) { |
51 | mi_free(p); |
52 | } |
53 | } |
54 | |
55 | int mi_posix_memalign(void** p, size_t alignment, size_t size) mi_attr_noexcept { |
56 | // Note: The spec dictates we should not modify `*p` on an error. (issue#27) |
57 | // <http://man7.org/linux/man-pages/man3/posix_memalign.3.html> |
58 | if (p == NULL) return EINVAL; |
59 | if (alignment % sizeof(void*) != 0) return EINVAL; // natural alignment |
60 | if (alignment==0 || !_mi_is_power_of_two(alignment)) return EINVAL; // not a power of 2 |
61 | void* q = mi_malloc_aligned(size, alignment); |
62 | if (q==NULL && size != 0) return ENOMEM; |
63 | mi_assert_internal(((uintptr_t)q % alignment) == 0); |
64 | *p = q; |
65 | return 0; |
66 | } |
67 | |
68 | mi_decl_nodiscard mi_decl_restrict void* mi_memalign(size_t alignment, size_t size) mi_attr_noexcept { |
69 | void* p = mi_malloc_aligned(size, alignment); |
70 | mi_assert_internal(((uintptr_t)p % alignment) == 0); |
71 | return p; |
72 | } |
73 | |
74 | mi_decl_nodiscard mi_decl_restrict void* mi_valloc(size_t size) mi_attr_noexcept { |
75 | return mi_memalign( _mi_os_page_size(), size ); |
76 | } |
77 | |
78 | mi_decl_nodiscard mi_decl_restrict void* mi_pvalloc(size_t size) mi_attr_noexcept { |
79 | size_t psize = _mi_os_page_size(); |
80 | if (size >= SIZE_MAX - psize) return NULL; // overflow |
81 | size_t asize = _mi_align_up(size, psize); |
82 | return mi_malloc_aligned(asize, psize); |
83 | } |
84 | |
85 | mi_decl_nodiscard mi_decl_restrict void* mi_aligned_alloc(size_t alignment, size_t size) mi_attr_noexcept { |
86 | // C11 requires the size to be an integral multiple of the alignment, see <https://en.cppreference.com/w/c/memory/aligned_alloc>. |
87 | // unfortunately, it turns out quite some programs pass a size that is not an integral multiple so skip this check.. |
88 | /* if mi_unlikely((size & (alignment - 1)) != 0) { // C11 requires alignment>0 && integral multiple, see <https://en.cppreference.com/w/c/memory/aligned_alloc> |
89 | #if MI_DEBUG > 0 |
90 | _mi_error_message(EOVERFLOW, "(mi_)aligned_alloc requires the size to be an integral multiple of the alignment (size %zu, alignment %zu)\n", size, alignment); |
91 | #endif |
92 | return NULL; |
93 | } |
94 | */ |
95 | // C11 also requires alignment to be a power-of-two (and > 0) which is checked in mi_malloc_aligned |
96 | void* p = mi_malloc_aligned(size, alignment); |
97 | mi_assert_internal(((uintptr_t)p % alignment) == 0); |
98 | return p; |
99 | } |
100 | |
101 | mi_decl_nodiscard void* mi_reallocarray( void* p, size_t count, size_t size ) mi_attr_noexcept { // BSD |
102 | void* newp = mi_reallocn(p,count,size); |
103 | if (newp==NULL) { errno = ENOMEM; } |
104 | return newp; |
105 | } |
106 | |
107 | mi_decl_nodiscard int mi_reallocarr( void* p, size_t count, size_t size ) mi_attr_noexcept { // NetBSD |
108 | mi_assert(p != NULL); |
109 | if (p == NULL) { |
110 | errno = EINVAL; |
111 | return EINVAL; |
112 | } |
113 | void** op = (void**)p; |
114 | void* newp = mi_reallocarray(*op, count, size); |
115 | if mi_unlikely(newp == NULL) { return errno; } |
116 | *op = newp; |
117 | return 0; |
118 | } |
119 | |
120 | void* mi__expand(void* p, size_t newsize) mi_attr_noexcept { // Microsoft |
121 | void* res = mi_expand(p, newsize); |
122 | if (res == NULL) { errno = ENOMEM; } |
123 | return res; |
124 | } |
125 | |
126 | mi_decl_nodiscard mi_decl_restrict unsigned short* mi_wcsdup(const unsigned short* s) mi_attr_noexcept { |
127 | if (s==NULL) return NULL; |
128 | size_t len; |
129 | for(len = 0; s[len] != 0; len++) { } |
130 | size_t size = (len+1)*sizeof(unsigned short); |
131 | unsigned short* p = (unsigned short*)mi_malloc(size); |
132 | if (p != NULL) { |
133 | _mi_memcpy(p,s,size); |
134 | } |
135 | return p; |
136 | } |
137 | |
138 | mi_decl_nodiscard mi_decl_restrict unsigned char* mi_mbsdup(const unsigned char* s) mi_attr_noexcept { |
139 | return (unsigned char*)mi_strdup((const char*)s); |
140 | } |
141 | |
142 | int mi_dupenv_s(char** buf, size_t* size, const char* name) mi_attr_noexcept { |
143 | if (buf==NULL || name==NULL) return EINVAL; |
144 | if (size != NULL) *size = 0; |
145 | char* p = getenv(name); // mscver warning 4996 |
146 | if (p==NULL) { |
147 | *buf = NULL; |
148 | } |
149 | else { |
150 | *buf = mi_strdup(p); |
151 | if (*buf==NULL) return ENOMEM; |
152 | if (size != NULL) *size = strlen(p); |
153 | } |
154 | return 0; |
155 | } |
156 | |
157 | int mi_wdupenv_s(unsigned short** buf, size_t* size, const unsigned short* name) mi_attr_noexcept { |
158 | if (buf==NULL || name==NULL) return EINVAL; |
159 | if (size != NULL) *size = 0; |
160 | #if !defined(_WIN32) || (defined(WINAPI_FAMILY) && (WINAPI_FAMILY != WINAPI_FAMILY_DESKTOP_APP)) |
161 | // not supported |
162 | *buf = NULL; |
163 | return EINVAL; |
164 | #else |
165 | unsigned short* p = (unsigned short*)_wgetenv((const wchar_t*)name); // msvc warning 4996 |
166 | if (p==NULL) { |
167 | *buf = NULL; |
168 | } |
169 | else { |
170 | *buf = mi_wcsdup(p); |
171 | if (*buf==NULL) return ENOMEM; |
172 | if (size != NULL) *size = wcslen((const wchar_t*)p); |
173 | } |
174 | return 0; |
175 | #endif |
176 | } |
177 | |
178 | mi_decl_nodiscard void* mi_aligned_offset_recalloc(void* p, size_t newcount, size_t size, size_t alignment, size_t offset) mi_attr_noexcept { // Microsoft |
179 | return mi_recalloc_aligned_at(p, newcount, size, alignment, offset); |
180 | } |
181 | |
182 | mi_decl_nodiscard void* mi_aligned_recalloc(void* p, size_t newcount, size_t size, size_t alignment) mi_attr_noexcept { // Microsoft |
183 | return mi_recalloc_aligned(p, newcount, size, alignment); |
184 | } |
185 | |