Loading...
--- libmalloc/libmalloc-657.60.21/src/malloc_exclaves.c
+++ libmalloc/libmalloc-521.100.59/src/malloc_exclaves.c
@@ -53,7 +53,7 @@
malloc_zero_policy_t malloc_zero_policy = MALLOC_ZERO_POLICY_DEFAULT;
static inline malloc_zone_t *
-_find_registered_zone(const void * __unsafe_indexable ptr, size_t *returned_size,
+find_registered_zone(const void * __unsafe_indexable ptr, size_t *returned_size,
bool known_non_default)
{
malloc_zone_t *zone;
@@ -87,13 +87,6 @@
return zone;
}
-malloc_zone_t *
-find_registered_zone(const void * __unsafe_indexable ptr, size_t *returned_size,
- bool known_non_default)
-{
- return _find_registered_zone(ptr, returned_size, known_non_default);
-}
-
/********* Creation and destruction ************/
static void
@@ -161,7 +154,7 @@
/********* Block creation and manipulation ************/
-void * __sized_by_or_null(size)
+void *
_malloc_zone_malloc(malloc_zone_t *zone, size_t size, malloc_zone_options_t mzo)
{
// This and similar conditionals are commented out to avoid compiler
@@ -176,13 +169,13 @@
}
MALLOC_NOINLINE
-void * __sized_by_or_null(size)
+void *
malloc_zone_malloc(malloc_zone_t *zone, size_t size)
{
return _malloc_zone_malloc(zone, size, MZ_NONE);
}
-void * __sized_by_or_null(num_items * size)
+void *
_malloc_zone_calloc(malloc_zone_t *zone, size_t num_items, size_t size,
malloc_zone_options_t mzo)
{
@@ -198,13 +191,13 @@
}
MALLOC_NOINLINE
-void * __sized_by_or_null(num_items * size)
+void *
malloc_zone_calloc(malloc_zone_t *zone, size_t num_items, size_t size)
{
return _malloc_zone_calloc(zone, num_items, size, MZ_NONE);
}
-void * __sized_by_or_null(size)
+void *
_malloc_zone_valloc(malloc_zone_t *zone, size_t size, malloc_zone_options_t mzo)
{
// if (os_unlikely(malloc_too_large(size))) {
@@ -221,13 +214,13 @@
}
MALLOC_NOINLINE
-void * __sized_by_or_null(size)
+void *
malloc_zone_valloc(malloc_zone_t *zone, size_t size)
{
return _malloc_zone_valloc(zone, size, MZ_NONE);
}
-void * __sized_by_or_null(size)
+void *
_malloc_zone_realloc(malloc_zone_t *zone, void * __unsafe_indexable ptr,
size_t size, malloc_type_descriptor_t type_desc)
{
@@ -239,7 +232,7 @@
}
MALLOC_NOINLINE
-void * __sized_by_or_null(size)
+void *
malloc_zone_realloc(malloc_zone_t *zone, void * __unsafe_indexable ptr,
size_t size)
{
@@ -266,11 +259,11 @@
if (!ptr) {
return NULL;
} else {
- return _find_registered_zone(ptr, NULL, false);
- }
-}
-
-void * __alloc_align(2) __alloc_size(3) __sized_by_or_null(size)
+ return find_registered_zone(ptr, NULL, false);
+ }
+}
+
+void * __alloc_align(2) __alloc_size(3)
_malloc_zone_memalign(malloc_zone_t *zone, size_t alignment, size_t size,
malloc_zone_options_t mzo, malloc_type_descriptor_t type_desc)
{
@@ -310,7 +303,7 @@
}
MALLOC_NOINLINE
-void * __sized_by_or_null(size)
+void *
malloc_zone_memalign(malloc_zone_t *zone, size_t alignment, size_t size)
{
return _malloc_zone_memalign(zone, alignment, size, MZ_NONE,
@@ -318,7 +311,7 @@
}
MALLOC_NOINLINE
-void * __sized_by_or_null(size)
+void *
malloc_zone_malloc_with_options_np(malloc_zone_t *zone, size_t align,
size_t size, malloc_options_np_t options)
{
@@ -331,7 +324,7 @@
zone = malloc_zones[0];
}
- if (zone->version >= 15 && zone->malloc_with_options) {
+ if (zone->version >= 15) {
return zone->malloc_with_options(zone, align, size, options);
}
@@ -371,7 +364,7 @@
malloc_set_zone_name(malloc_zone_t *z, const char *name)
{
if (z->zone_name) {
- malloc_zone_t *old_zone = _find_registered_zone(z->zone_name, NULL,
+ malloc_zone_t *old_zone = find_registered_zone(z->zone_name, NULL,
false);
if (old_zone) {
malloc_zone_free(old_zone, (char *)z->zone_name);
@@ -407,7 +400,7 @@
return;
}
- zone = _find_registered_zone(ptr, &size, known_non_default);
+ zone = find_registered_zone(ptr, &size, known_non_default);
if (!zone) {
malloc_report(MALLOC_REPORT_DEBUG | MALLOC_REPORT_NOLOG,
"*** error for object %p: pointer being freed was not allocated\n",
@@ -422,23 +415,27 @@
/********* Generic ANSI callouts ************/
-void * __sized_by_or_null(size)
+// FIXME: Return NULL instead but we need bounds checking support
+// rdar://75598414 (Support __counted_by_or_null and __sized_by_or_null)
+#define NONZERO_SZ(sz) ((sz) ? (sz) : 1)
+
+void *
malloc(size_t size)
{
- return malloc_zone_malloc(_malloc_zones[0], size);
-}
-
-void * __sized_by_or_null(size)
+ return malloc_zone_malloc(_malloc_zones[0], NONZERO_SZ(size));
+}
+
+void *
aligned_alloc(size_t alignment, size_t size)
{
- return _malloc_zone_memalign(_malloc_zones[0], alignment, size,
+ return _malloc_zone_memalign(_malloc_zones[0], alignment, NONZERO_SZ(size),
MZ_POSIX | MZ_C11, MALLOC_TYPE_DESCRIPTOR_NONE);
}
-void * __sized_by_or_null(num_items * size)
+void *
calloc(size_t num_items, size_t size)
{
- return malloc_zone_calloc(_malloc_zones[0], num_items, size);
+ return malloc_zone_calloc(_malloc_zones[0], num_items, NONZERO_SZ(size));
}
void
@@ -462,7 +459,7 @@
return _free(ptr);
}
-void * __sized_by_or_null(new_size)
+void *
_realloc(void * __unsafe_indexable in_ptr, size_t new_size)
{
void * __bidi_indexable retval = NULL;
@@ -479,9 +476,9 @@
// size." So we only free the original memory if the allocation succeeds.
old_ptr = (new_size == 0) ? NULL : in_ptr;
if (!old_ptr) {
- retval = malloc_zone_malloc(_malloc_zones[0], new_size);
- } else {
- zone = _find_registered_zone(old_ptr, NULL, false);
+ retval = malloc_zone_malloc(_malloc_zones[0], NONZERO_SZ(new_size));
+ } else {
+ zone = find_registered_zone(old_ptr, NULL, false);
if (!zone) {
malloc_report(MALLOC_REPORT_CRASH,
"*** error for object %p: pointer being realloc'd was not allocated\n",
@@ -499,33 +496,28 @@
return retval;
}
-void * __sized_by_or_null(new_size)
+void *
realloc(void * __unsafe_indexable in_ptr, size_t new_size)
{
return _realloc(in_ptr, new_size);
}
-void * __sized_by_or_null(new_size)
+void *
reallocf(void * __unsafe_indexable in_ptr, size_t new_size)
{
void *ptr = realloc(in_ptr, new_size);
if (!ptr && in_ptr && new_size != 0) {
- // Save and restore `errno`, because `realloc` will set it to ENOMEM
- // on allocation failure, but it could be overwritten if `free` calls
- // into a library function that also modifies `errno`
- errno_t error = errno;
free(in_ptr);
- errno = error;
}
return ptr;
}
-void * __sized_by_or_null(size)
+void *
valloc(size_t size)
{
- return _malloc_zone_valloc(_malloc_zones[0], size, MZ_POSIX);
+ return _malloc_zone_valloc(_malloc_zones[0], NONZERO_SZ(size), MZ_POSIX);
}
size_t
@@ -537,7 +529,7 @@
return size;
}
- (void)_find_registered_zone(ptr, &size, false);
+ (void)find_registered_zone(ptr, &size, false);
return size;
}
@@ -556,7 +548,7 @@
/* POSIX is silent on NULL == memptr !?! */
- retval = malloc_zone_memalign(_malloc_zones[0], alignment, size);
+ retval = malloc_zone_memalign(_malloc_zones[0], alignment, NONZERO_SZ(size));
if (retval == NULL) {
// To avoid testing the alignment constraints redundantly, we'll rely on
// the test made in malloc_zone_memalign to vet each request. Only if
@@ -599,7 +591,7 @@
return false;
}
-void * __sized_by_or_null(nmemb * size)
+void *
reallocarray(void * in_ptr, size_t nmemb, size_t size)
{
size_t alloc_size;
@@ -610,7 +602,7 @@
return realloc(in_ptr, alloc_size);
}
-void * __sized_by_or_null(nmemb * size)
+void *
reallocarrayf(void * in_ptr, size_t nmemb, size_t size)
{
size_t alloc_size;
@@ -694,6 +686,5 @@
void
malloc_zero_on_free_disable(void)
{
- malloc_zone_error(MALLOC_ABORT_ON_ERROR, false,
- "xzone cannot disable zero on free");
-}
+ malloc_zero_policy = MALLOC_ZERO_NONE;
+}