void *CFAllocatorAllocate(CFAllocatorRef allocator, CFIndex size, CFOptionFlags hint) {
CFAllocatorAllocateCallBack allocateFunc;
void *newptr = NULL;
if (NULL == allocator) {
allocator = __CFGetDefaultAllocator();
}
#if defined(DEBUG) && (DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI)
if (allocator->_base._cfisa == __CFISAForCFAllocator()) {
__CFGenericValidateType(allocator, _kCFRuntimeIDCFAllocator);
}
#else
__CFGenericValidateType(allocator, _kCFRuntimeIDCFAllocator);
#endif
if (0 == size) return NULL;
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
if (allocator->_base._cfisa != __CFISAForCFAllocator()) { // malloc_zone_t *
return malloc_zone_malloc((malloc_zone_t *)allocator, size);
}
#endif
newptr = NULL;
allocateFunc = __CFAllocatorGetAllocateFunction(&allocator->_context);
if (allocateFunc) {
newptr = (void *)INVOKE_CALLBACK3(allocateFunc, size, hint, allocator->_context.info);
}
return newptr;
}
void *
unexec_malloc (size_t size)
{
if (in_dumped_exec)
{
void *p;
p = malloc (size);
#if MACOSX_MALLOC_MULT16
assert (((vm_address_t) p % 16) == 0);
#endif
return p;
}
else
{
unexec_malloc_header_t *ptr;
ptr = (unexec_malloc_header_t *)
malloc_zone_malloc (emacs_zone, size + sizeof (unexec_malloc_header_t));
ptr->u.size = size;
ptr++;
#if MACOSX_MALLOC_MULT16
assert (((vm_address_t) ptr % 16) == 8);
#endif
return (void *) ptr;
}
}
void test_introspection(malloc_zone_t *zone, boolean_t exact) {
static void* pointers[1000];
BlockRecorderContext context = { 0, 0, zone };
malloc_statistics_t stats;
size_t i;
// allocate 1000 randomly sized blocks.
for (i = 0; i < 1000; ++i) {
size_t random_size = (random() & 0x1FFFF);
pointers[i] = malloc_zone_malloc(zone, random_size);
}
// deallocate a random number of the blocks.
for (i = 0; i < 1000; ++i) {
if (random() & 0x1) {
malloc_zone_free(zone, pointers[i]);
pointers[i] = NULL;
}
}
// validate that these agree with the values returned by the enumeration APIs.
zone->introspect->enumerator(mach_task_self(), &context, MALLOC_PTR_IN_USE_RANGE_TYPE, (vm_address_t)zone, NULL, blockRecorder);
malloc_zone_statistics(zone, &stats);
if (exact) {
assert(stats.blocks_in_use == context.blocks_in_use);
assert(stats.size_in_use == context.size_in_use);
} else {
// the malloc default zone enumerators don't currently match the statistics.
assert(stats.blocks_in_use >= context.blocks_in_use);
assert(stats.size_in_use >= context.size_in_use);
}
}
void *CFAllocatorAllocate(CFAllocatorRef allocator, CFIndex size, CFOptionFlags hint) {
CFAllocatorAllocateCallBack allocateFunc;
void *newptr = NULL;
allocator = (NULL == allocator) ? __CFGetDefaultAllocator() : allocator;
#if (DEPLOYMENT_TARGET_MACOSX) && defined(DEBUG)
if (allocator->_base._cfisa == __CFISAForTypeID(__kCFAllocatorTypeID)) {
__CFGenericValidateType(allocator, __kCFAllocatorTypeID);
}
#else
__CFGenericValidateType(allocator, __kCFAllocatorTypeID);
#endif
if (0 == size) return NULL;
#if DEPLOYMENT_TARGET_MACOSX
if (allocator->_base._cfisa != __CFISAForTypeID(__kCFAllocatorTypeID)) { // malloc_zone_t *
return malloc_zone_malloc((malloc_zone_t *)allocator, size);
}
#endif
if (CF_IS_COLLECTABLE_ALLOCATOR(allocator)) {
newptr = auto_zone_allocate_object((auto_zone_t*)allocator->_context.info, size, CF_GET_GC_MEMORY_TYPE(hint), true, false);
} else {
newptr = NULL;
allocateFunc = __CFAllocatorGetAllocateFunction(&allocator->_context);
if (allocateFunc) {
newptr = (void *)INVOKE_CALLBACK3(allocateFunc, size, hint, allocator->_context.info);
}
}
return newptr;
}
void *CFAllocatorReallocate(CFAllocatorRef allocator, void *ptr, CFIndex newsize, CFOptionFlags hint) {
CFAllocatorAllocateCallBack allocateFunc;
CFAllocatorReallocateCallBack reallocateFunc;
CFAllocatorDeallocateCallBack deallocateFunc;
void *newptr;
if (NULL == allocator) {
allocator = __CFGetDefaultAllocator();
}
#if defined(DEBUG) && (DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI)
if (allocator->_base._cfisa == __CFISAForCFAllocator()) {
__CFGenericValidateType(allocator, _kCFRuntimeIDCFAllocator);
}
#else
__CFGenericValidateType(allocator, _kCFRuntimeIDCFAllocator);
#endif
if (NULL == ptr && 0 < newsize) {
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
if (allocator->_base._cfisa != __CFISAForCFAllocator()) { // malloc_zone_t *
return malloc_zone_malloc((malloc_zone_t *)allocator, newsize);
}
#endif
newptr = NULL;
allocateFunc = __CFAllocatorGetAllocateFunction(&allocator->_context);
if (allocateFunc) {
newptr = (void *)INVOKE_CALLBACK3(allocateFunc, newsize, hint, allocator->_context.info);
}
return newptr;
}
if (NULL != ptr && 0 == newsize) {
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
if (allocator->_base._cfisa != __CFISAForCFAllocator()) { // malloc_zone_t *
#if defined(DEBUG)
size_t size = malloc_size(ptr);
if (size) memset(ptr, 0xCC, size);
#endif
malloc_zone_free((malloc_zone_t *)allocator, ptr);
return NULL;
}
#endif
deallocateFunc = __CFAllocatorGetDeallocateFunction(&allocator->_context);
if (NULL != deallocateFunc) {
INVOKE_CALLBACK2(deallocateFunc, ptr, allocator->_context.info);
}
return NULL;
}
if (NULL == ptr && 0 == newsize) return NULL;
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
if (allocator->_base._cfisa != __CFISAForCFAllocator()) { // malloc_zone_t *
return malloc_zone_realloc((malloc_zone_t *)allocator, ptr, newsize);
}
#endif
reallocateFunc = __CFAllocatorGetReallocateFunction(&allocator->_context);
if (NULL == reallocateFunc) return NULL;
newptr = (void *)INVOKE_CALLBACK4(reallocateFunc, ptr, newsize, hint, allocator->_context.info);
return newptr;
}
/* grow a cache. */
static void *
incdep_cache_allocator (void *thrd, unsigned int size)
{
(void)thrd;
#ifdef __APPLE__
return malloc_zone_malloc (incdep_zone, size);
#else
return xmalloc (size);
#endif
}
/* xmalloc wrapper.
For working around multithreaded performance problems found on Darwin,
Linux (glibc), and possibly other systems. */
static void *
incdep_xmalloc (struct incdep *cur, size_t size)
{
void *ptr;
#ifdef __APPLE__
if (cur && cur->worker_tid != -1)
{
ptr = malloc_zone_malloc (incdep_zone, size);
if (!ptr)
fatal (NILF, _("virtual memory exhausted"));
}
else
ptr = xmalloc (size);
#else
ptr = xmalloc (size);
#endif
(void)cur;
return ptr;
}
void *CFAllocatorAllocate(CFAllocatorRef allocator, CFIndex size, CFOptionFlags hint) {
CFAllocatorAllocateCallBack allocateFunc;
void *newptr = NULL;
Boolean initialRefcountOne = true;
if (kCFAllocatorSystemDefaultGCRefZero == allocator) {
allocator = kCFAllocatorSystemDefault;
initialRefcountOne = false;
} else if (kCFAllocatorDefaultGCRefZero == allocator) {
// Under GC, we can't use just any old allocator when the GCRefZero allocator was requested
allocator = kCFUseCollectableAllocator ? kCFAllocatorSystemDefault : __CFGetDefaultAllocator();
if (CF_IS_COLLECTABLE_ALLOCATOR(allocator)) initialRefcountOne = false;
} else if (NULL == allocator) {
allocator = __CFGetDefaultAllocator();
}
#if defined(DEBUG) && (DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI)
if (allocator->_base._cfisa == __CFISAForTypeID(__kCFAllocatorTypeID)) {
__CFGenericValidateType(allocator, __kCFAllocatorTypeID);
}
#else
__CFGenericValidateType(allocator, __kCFAllocatorTypeID);
#endif
if (0 == size) return NULL;
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
if (allocator->_base._cfisa != __CFISAForTypeID(__kCFAllocatorTypeID)) { // malloc_zone_t *
return malloc_zone_malloc((malloc_zone_t *)allocator, size);
}
#endif
if (CF_IS_COLLECTABLE_ALLOCATOR(allocator)) {
newptr = auto_zone_allocate_object((auto_zone_t*)allocator->_context.info, size, CF_GET_GC_MEMORY_TYPE(hint), initialRefcountOne, false);
} else {
newptr = NULL;
allocateFunc = __CFAllocatorGetAllocateFunction(&allocator->_context);
if (allocateFunc) {
newptr = (void *)INVOKE_CALLBACK3(allocateFunc, size, hint, allocator->_context.info);
}
}
return newptr;
}
static void *__CFAllocatorSystemAllocate(CFIndex size, CFOptionFlags hint, void *info) {
return malloc_zone_malloc(info, size);
}
void* FMacMallocZone::Malloc( SIZE_T Size, uint32 Alignment )
{
check( MemoryZone );
void* Result = malloc_zone_malloc( MemoryZone, Size );
return Result;
}
void *CFAllocatorReallocate(CFAllocatorRef allocator, void *ptr, CFIndex newsize, CFOptionFlags hint) {
CFAllocatorAllocateCallBack allocateFunc;
CFAllocatorReallocateCallBack reallocateFunc;
CFAllocatorDeallocateCallBack deallocateFunc;
void *newptr;
if (kCFAllocatorSystemDefaultGCRefZero == allocator) {
allocator = kCFAllocatorSystemDefault;
} else if (kCFAllocatorDefaultGCRefZero == allocator) {
// Under GC, we can't use just any old allocator when the GCRefZero allocator was requested
allocator = kCFUseCollectableAllocator ? kCFAllocatorSystemDefault : __CFGetDefaultAllocator();
} else if (NULL == allocator) {
allocator = __CFGetDefaultAllocator();
}
#if defined(DEBUG) && (DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI)
if (allocator->_base._cfisa == __CFISAForTypeID(__kCFAllocatorTypeID)) {
__CFGenericValidateType(allocator, __kCFAllocatorTypeID);
}
#else
__CFGenericValidateType(allocator, __kCFAllocatorTypeID);
#endif
if (NULL == ptr && 0 < newsize) {
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
if (allocator->_base._cfisa != __CFISAForTypeID(__kCFAllocatorTypeID)) { // malloc_zone_t *
return malloc_zone_malloc((malloc_zone_t *)allocator, newsize);
}
#endif
newptr = NULL;
allocateFunc = __CFAllocatorGetAllocateFunction(&allocator->_context);
if (allocateFunc) {
newptr = (void *)INVOKE_CALLBACK3(allocateFunc, newsize, hint, allocator->_context.info);
}
return newptr;
}
if (NULL != ptr && 0 == newsize) {
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
if (allocator->_base._cfisa != __CFISAForTypeID(__kCFAllocatorTypeID)) { // malloc_zone_t *
#if defined(DEBUG)
size_t size = malloc_size(ptr);
if (size) memset(ptr, 0xCC, size);
#endif
malloc_zone_free((malloc_zone_t *)allocator, ptr);
return NULL;
}
#endif
deallocateFunc = __CFAllocatorGetDeallocateFunction(&allocator->_context);
if (NULL != deallocateFunc) {
INVOKE_CALLBACK2(deallocateFunc, ptr, allocator->_context.info);
}
return NULL;
}
if (NULL == ptr && 0 == newsize) return NULL;
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
if (allocator->_base._cfisa != __CFISAForTypeID(__kCFAllocatorTypeID)) { // malloc_zone_t *
return malloc_zone_realloc((malloc_zone_t *)allocator, ptr, newsize);
}
#endif
reallocateFunc = __CFAllocatorGetReallocateFunction(&allocator->_context);
if (NULL == reallocateFunc) return NULL;
newptr = (void *)INVOKE_CALLBACK4(reallocateFunc, ptr, newsize, hint, allocator->_context.info);
return newptr;
}
static void *__CFAllocatorSystemAllocate(CFIndex size, CFOptionFlags hint, void *info) {
malloc_zone_t * const zone = (info == &__MallocDefaultZoneInfoPlaceholder) ? malloc_default_zone() : (malloc_zone_t *)info;
return malloc_zone_malloc(zone, size);
}