#include <CoreFoundation/CFBase.h>
#include "CFInternal.h"
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_LINUX || DEPLOYMENT_TARGET_FREEBSD
#include <pthread.h>
#endif
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED
#include <malloc/malloc.h>
extern size_t malloc_good_size(size_t size);
#include <mach/mach.h>
#include <dlfcn.h>
#endif
#include <stdlib.h>
#include <string.h>
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED
#endif
struct __CFAllocator {
CFRuntimeBase _base;
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED
size_t (*size)(struct _malloc_zone_t *zone, const void *ptr);
void *(*malloc)(struct _malloc_zone_t *zone, size_t size);
void *(*calloc)(struct _malloc_zone_t *zone, size_t num_items, size_t size);
void *(*valloc)(struct _malloc_zone_t *zone, size_t size);
void (*free)(struct _malloc_zone_t *zone, void *ptr);
void *(*realloc)(struct _malloc_zone_t *zone, void *ptr, size_t size);
void (*destroy)(struct _malloc_zone_t *zone);
const char *zone_name;
unsigned (*batch_malloc)(struct _malloc_zone_t *zone, size_t size, void **results, unsigned num_requested);
void (*batch_free)(struct _malloc_zone_t *zone, void **to_be_freed, unsigned num_to_be_freed);
struct malloc_introspection_t *introspect;
void *reserved5;
#endif
CFAllocatorRef _allocator;
CFAllocatorContext _context;
};
CF_INLINE CFAllocatorRetainCallBack __CFAllocatorGetRetainFunction(const CFAllocatorContext *context) {
CFAllocatorRetainCallBack retval = NULL;
retval = context->retain;
return retval;
}
CF_INLINE CFAllocatorReleaseCallBack __CFAllocatorGetReleaseFunction(const CFAllocatorContext *context) {
CFAllocatorReleaseCallBack retval = NULL;
retval = context->release;
return retval;
}
CF_INLINE CFAllocatorCopyDescriptionCallBack __CFAllocatorGetCopyDescriptionFunction(const CFAllocatorContext *context) {
CFAllocatorCopyDescriptionCallBack retval = NULL;
retval = context->copyDescription;
return retval;
}
CF_INLINE CFAllocatorAllocateCallBack __CFAllocatorGetAllocateFunction(const CFAllocatorContext *context) {
CFAllocatorAllocateCallBack retval = NULL;
retval = context->allocate;
return retval;
}
CF_INLINE CFAllocatorReallocateCallBack __CFAllocatorGetReallocateFunction(const CFAllocatorContext *context) {
CFAllocatorReallocateCallBack retval = NULL;
retval = context->reallocate;
return retval;
}
CF_INLINE CFAllocatorDeallocateCallBack __CFAllocatorGetDeallocateFunction(const CFAllocatorContext *context) {
CFAllocatorDeallocateCallBack retval = NULL;
retval = context->deallocate;
return retval;
}
CF_INLINE CFAllocatorPreferredSizeCallBack __CFAllocatorGetPreferredSizeFunction(const CFAllocatorContext *context) {
CFAllocatorPreferredSizeCallBack retval = NULL;
retval = context->preferredSize;
return retval;
}
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED
__private_extern__ void __CFAllocatorDeallocate(CFTypeRef cf);
static kern_return_t __CFAllocatorZoneIntrospectNoOp(void) {
return 0;
}
static boolean_t __CFAllocatorZoneIntrospectTrue(void) {
return 1;
}
static size_t __CFAllocatorCustomSize(malloc_zone_t *zone, const void *ptr) {
return 0;
}
static void *__CFAllocatorCustomMalloc(malloc_zone_t *zone, size_t size) {
CFAllocatorRef allocator = (CFAllocatorRef)zone;
return CFAllocatorAllocate(allocator, size, 0);
}
static void *__CFAllocatorCustomCalloc(malloc_zone_t *zone, size_t num_items, size_t size) {
CFAllocatorRef allocator = (CFAllocatorRef)zone;
void *newptr = CFAllocatorAllocate(allocator, size, 0);
if (newptr) memset(newptr, 0, size);
return newptr;
}
static void *__CFAllocatorCustomValloc(malloc_zone_t *zone, size_t size) {
CFAllocatorRef allocator = (CFAllocatorRef)zone;
void *newptr = CFAllocatorAllocate(allocator, size + vm_page_size, 0);
newptr = (void *)round_page((uintptr_t)newptr);
return newptr;
}
static void __CFAllocatorCustomFree(malloc_zone_t *zone, void *ptr) {
CFAllocatorRef allocator = (CFAllocatorRef)zone;
CFAllocatorDeallocate(allocator, ptr);
}
static void *__CFAllocatorCustomRealloc(malloc_zone_t *zone, void *ptr, size_t size) {
CFAllocatorRef allocator = (CFAllocatorRef)zone;
return CFAllocatorReallocate(allocator, ptr, size, 0);
}
static void __CFAllocatorCustomDestroy(malloc_zone_t *zone) {
CFAllocatorRef allocator = (CFAllocatorRef)zone;
__CFAllocatorDeallocate(allocator);
}
static size_t __CFAllocatorCustomGoodSize(malloc_zone_t *zone, size_t size) {
CFAllocatorRef allocator = (CFAllocatorRef)zone;
return CFAllocatorGetPreferredSizeForSize(allocator, size, 0);
}
static struct malloc_introspection_t __CFAllocatorZoneIntrospect = {
(void *)__CFAllocatorZoneIntrospectNoOp,
(void *)__CFAllocatorCustomGoodSize,
(void *)__CFAllocatorZoneIntrospectTrue,
(void *)__CFAllocatorZoneIntrospectNoOp,
(void *)__CFAllocatorZoneIntrospectNoOp,
(void *)__CFAllocatorZoneIntrospectNoOp,
(void *)__CFAllocatorZoneIntrospectNoOp,
(void *)__CFAllocatorZoneIntrospectNoOp
};
static size_t __CFAllocatorNullSize(malloc_zone_t *zone, const void *ptr) {
return 0;
}
static void * __CFAllocatorNullMalloc(malloc_zone_t *zone, size_t size) {
return NULL;
}
static void * __CFAllocatorNullCalloc(malloc_zone_t *zone, size_t num_items, size_t size) {
return NULL;
}
static void * __CFAllocatorNullValloc(malloc_zone_t *zone, size_t size) {
return NULL;
}
static void __CFAllocatorNullFree(malloc_zone_t *zone, void *ptr) {
}
static void * __CFAllocatorNullRealloc(malloc_zone_t *zone, void *ptr, size_t size) {
return NULL;
}
static void __CFAllocatorNullDestroy(malloc_zone_t *zone) {
}
static size_t __CFAllocatorNullGoodSize(malloc_zone_t *zone, size_t size) {
return size;
}
static struct malloc_introspection_t __CFAllocatorNullZoneIntrospect = {
(void *)__CFAllocatorZoneIntrospectNoOp,
(void *)__CFAllocatorNullGoodSize,
(void *)__CFAllocatorZoneIntrospectTrue,
(void *)__CFAllocatorZoneIntrospectNoOp,
(void *)__CFAllocatorZoneIntrospectNoOp,
(void *)__CFAllocatorZoneIntrospectNoOp,
(void *)__CFAllocatorZoneIntrospectNoOp,
(void *)__CFAllocatorZoneIntrospectNoOp
};
static void *__CFAllocatorSystemAllocate(CFIndex size, CFOptionFlags hint, void *info) {
return malloc_zone_malloc(info, size);
}
static void *__CFAllocatorSystemReallocate(void *ptr, CFIndex newsize, CFOptionFlags hint, void *info) {
return malloc_zone_realloc(info, ptr, newsize);
}
static void __CFAllocatorSystemDeallocate(void *ptr, void *info) {
#if defined(DEBUG)
size_t size = malloc_size(ptr);
if (size) memset(ptr, 0xCC, size);
#endif
malloc_zone_free(info, ptr);
}
#endif
#if DEPLOYMENT_TARGET_WINDOWS || DEPLOYMENT_TARGET_LINUX || DEPLOYMENT_TARGET_FREEBSD
static void *__CFAllocatorSystemAllocate(CFIndex size, CFOptionFlags hint, void *info) {
return malloc(size);
}
static void *__CFAllocatorSystemReallocate(void *ptr, CFIndex newsize, CFOptionFlags hint, void *info) {
return realloc(ptr, newsize);
}
static void __CFAllocatorSystemDeallocate(void *ptr, void *info) {
free(ptr);
}
#endif
static void *__CFAllocatorNullAllocate(CFIndex size, CFOptionFlags hint, void *info) {
return NULL;
}
static void *__CFAllocatorNullReallocate(void *ptr, CFIndex newsize, CFOptionFlags hint, void *info) {
return NULL;
}
#if defined (__cplusplus)
static void * __CFAllocatorCPPMalloc(CFIndex allocSize, CFOptionFlags hint, void *info)
{
return malloc(allocSize);
}
static void * __CFAllocatorCPPReAlloc(void *ptr, CFIndex newsize, CFOptionFlags hint, void *info)
{
return realloc(ptr, newsize);
}
static void __CFAllocatorCPPFree(void *ptr, void *info)
{
free(ptr);
}
#endif // C++
static struct __CFAllocator __kCFAllocatorMalloc = {
INIT_CFRUNTIME_BASE(),
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED
__CFAllocatorCustomSize,
__CFAllocatorCustomMalloc,
__CFAllocatorCustomCalloc,
__CFAllocatorCustomValloc,
__CFAllocatorCustomFree,
__CFAllocatorCustomRealloc,
__CFAllocatorNullDestroy,
"kCFAllocatorMalloc",
NULL,
NULL,
&__CFAllocatorZoneIntrospect,
NULL,
#endif
NULL, #if !defined (__cplusplus)
{0, NULL, NULL, NULL, NULL, (void *)malloc, (void *)realloc, (void *)free, NULL}
#else
{0, NULL, NULL, NULL, NULL, __CFAllocatorCPPMalloc,__CFAllocatorCPPReAlloc, __CFAllocatorCPPFree, NULL}
#endif // __cplusplus
};
static struct __CFAllocator __kCFAllocatorMallocZone = {
INIT_CFRUNTIME_BASE(),
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED
__CFAllocatorCustomSize,
__CFAllocatorCustomMalloc,
__CFAllocatorCustomCalloc,
__CFAllocatorCustomValloc,
__CFAllocatorCustomFree,
__CFAllocatorCustomRealloc,
__CFAllocatorNullDestroy,
"kCFAllocatorMallocZone",
NULL,
NULL,
&__CFAllocatorZoneIntrospect,
NULL,
#endif
NULL, {0, NULL, NULL, NULL, NULL, __CFAllocatorSystemAllocate, __CFAllocatorSystemReallocate, __CFAllocatorSystemDeallocate, NULL}
};
static struct __CFAllocator __kCFAllocatorSystemDefault = {
INIT_CFRUNTIME_BASE(),
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED
__CFAllocatorCustomSize,
__CFAllocatorCustomMalloc,
__CFAllocatorCustomCalloc,
__CFAllocatorCustomValloc,
__CFAllocatorCustomFree,
__CFAllocatorCustomRealloc,
__CFAllocatorNullDestroy,
"kCFAllocatorSystemDefault",
NULL,
NULL,
&__CFAllocatorZoneIntrospect,
NULL,
#endif
NULL, {0, NULL, NULL, NULL, NULL, __CFAllocatorSystemAllocate, __CFAllocatorSystemReallocate, __CFAllocatorSystemDeallocate, NULL}
};
static struct __CFAllocator __kCFAllocatorNull = {
INIT_CFRUNTIME_BASE(),
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED
__CFAllocatorNullSize,
__CFAllocatorNullMalloc,
__CFAllocatorNullCalloc,
__CFAllocatorNullValloc,
__CFAllocatorNullFree,
__CFAllocatorNullRealloc,
__CFAllocatorNullDestroy,
"kCFAllocatorNull",
NULL,
NULL,
&__CFAllocatorNullZoneIntrospect,
NULL,
#endif
NULL, {0, NULL, NULL, NULL, NULL, __CFAllocatorNullAllocate, __CFAllocatorNullReallocate, NULL, NULL}
};
const CFAllocatorRef kCFAllocatorDefault = NULL;
const CFAllocatorRef kCFAllocatorSystemDefault = &__kCFAllocatorSystemDefault;
const CFAllocatorRef kCFAllocatorMalloc = &__kCFAllocatorMalloc;
const CFAllocatorRef kCFAllocatorMallocZone = &__kCFAllocatorMallocZone;
const CFAllocatorRef kCFAllocatorNull = &__kCFAllocatorNull;
const CFAllocatorRef kCFAllocatorUseContext = (CFAllocatorRef)0x0257;
static CFStringRef __CFAllocatorCopyDescription(CFTypeRef cf) {
CFAllocatorRef self = (CFAllocatorRef)cf;
CFAllocatorRef allocator = (kCFAllocatorUseContext == self->_allocator) ? self : self->_allocator;
return CFStringCreateWithFormat(allocator, NULL, CFSTR("<CFAllocator %p [%p]>{info = %p}"), cf, allocator, self->_context.info);
}
__private_extern__ CFAllocatorRef __CFAllocatorGetAllocator(CFTypeRef cf) {
CFAllocatorRef allocator = (CFAllocatorRef)cf;
return (kCFAllocatorUseContext == allocator->_allocator) ? allocator : allocator->_allocator;
}
__private_extern__ void __CFAllocatorDeallocate(CFTypeRef cf) {
CFAllocatorRef self = (CFAllocatorRef)cf;
CFAllocatorRef allocator = self->_allocator;
CFAllocatorReleaseCallBack releaseFunc = __CFAllocatorGetReleaseFunction(&self->_context);
if (kCFAllocatorUseContext == allocator) {
CFAllocatorDeallocateCallBack deallocateFunc = __CFAllocatorGetDeallocateFunction(&self->_context);
void *info = self->_context.info;
if (NULL != deallocateFunc) {
INVOKE_CALLBACK2(deallocateFunc, (void *)self, info);
}
if (NULL != releaseFunc) {
INVOKE_CALLBACK1(releaseFunc, info);
}
} else {
if (NULL != releaseFunc) {
INVOKE_CALLBACK1(releaseFunc, self->_context.info);
}
_CFAllocatorDeallocateGC(allocator, (void *)self);
}
}
static CFTypeID __kCFAllocatorTypeID = _kCFRuntimeNotATypeID;
static const CFRuntimeClass __CFAllocatorClass = {
0,
"CFAllocator",
NULL, NULL, NULL,
NULL, NULL, NULL, __CFAllocatorCopyDescription
};
__private_extern__ void __CFAllocatorInitialize(void) {
__kCFAllocatorTypeID = _CFRuntimeRegisterClass(&__CFAllocatorClass);
_CFRuntimeSetInstanceTypeID(&__kCFAllocatorSystemDefault, __kCFAllocatorTypeID);
__kCFAllocatorSystemDefault._base._cfisa = __CFISAForTypeID(__kCFAllocatorTypeID);
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED
__kCFAllocatorSystemDefault._context.info = (kCFUseCollectableAllocator ? auto_zone() : malloc_default_zone());
memset(malloc_default_zone(), 0, 2 * sizeof(void *));
#endif
__kCFAllocatorSystemDefault._allocator = kCFAllocatorSystemDefault;
_CFRuntimeSetInstanceTypeID(&__kCFAllocatorMalloc, __kCFAllocatorTypeID);
__kCFAllocatorMalloc._base._cfisa = __CFISAForTypeID(__kCFAllocatorTypeID);
__kCFAllocatorMalloc._allocator = kCFAllocatorSystemDefault;
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED
_CFRuntimeSetInstanceTypeID(&__kCFAllocatorMallocZone, __kCFAllocatorTypeID);
__kCFAllocatorMallocZone._base._cfisa = __CFISAForTypeID(__kCFAllocatorTypeID);
__kCFAllocatorMallocZone._allocator = kCFAllocatorSystemDefault;
__kCFAllocatorMallocZone._context.info = malloc_default_zone();
#endif
_CFRuntimeSetInstanceTypeID(&__kCFAllocatorNull, __kCFAllocatorTypeID);
__kCFAllocatorNull._base._cfisa = __CFISAForTypeID(__kCFAllocatorTypeID);
__kCFAllocatorNull._allocator = kCFAllocatorSystemDefault;
}
CFTypeID CFAllocatorGetTypeID(void) {
return __kCFAllocatorTypeID;
}
CFAllocatorRef CFAllocatorGetDefault(void) {
return __CFGetDefaultAllocator();
}
void CFAllocatorSetDefault(CFAllocatorRef allocator) {
CFAllocatorRef current = __CFGetDefaultAllocator();
#if defined(DEBUG)
if (NULL != allocator) {
__CFGenericValidateType(allocator, __kCFAllocatorTypeID);
}
#endif
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED
if (allocator && allocator->_base._cfisa != __CFISAForTypeID(__kCFAllocatorTypeID)) { return; }
#endif
if (NULL != allocator && allocator != current) {
if (current) CFRelease(current);
CFRetain(allocator);
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED
pthread_setspecific(__CFTSDKeyAllocator, allocator);
#else
CFRetain(allocator);
__CFGetThreadSpecificData_inline()->_allocator = (void *)allocator;
#endif
}
}
static CFAllocatorRef __CFAllocatorCreate(CFAllocatorRef allocator, CFAllocatorContext *context) {
struct __CFAllocator *memory = NULL;
CFAllocatorRetainCallBack retainFunc;
CFAllocatorAllocateCallBack allocateFunc;
void *retainedInfo;
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED
if (allocator && kCFAllocatorUseContext != allocator && allocator->_base._cfisa != __CFISAForTypeID(__kCFAllocatorTypeID)) { return NULL; }
#endif
retainFunc = context->retain;
FAULT_CALLBACK((void **)&retainFunc);
allocateFunc = context->allocate;
FAULT_CALLBACK((void **)&allocateFunc);
if (NULL != retainFunc) {
retainedInfo = (void *)INVOKE_CALLBACK1(retainFunc, context->info);
} else {
retainedInfo = context->info;
}
if (kCFAllocatorUseContext == allocator) {
memory = NULL;
if (allocateFunc) {
memory = (struct __CFAllocator *)INVOKE_CALLBACK3(allocateFunc, sizeof(struct __CFAllocator), 0, retainedInfo);
}
if (NULL == memory) {
return NULL;
}
} else {
allocator = (NULL == allocator) ? __CFGetDefaultAllocator() : allocator;
memory = (struct __CFAllocator *)CFAllocatorAllocate(allocator, sizeof(struct __CFAllocator), __kCFAllocatorGCObjectMemory);
if (__CFOASafe) __CFSetLastAllocationEventName(memory, "CFAllocator");
if (NULL == memory) {
return NULL;
}
}
memory->_base._cfisa = 0;
#if __LP64__
memory->_base._rc = 1;
#else
memory->_base._cfinfo[CF_RC_BITS] = 1;
#endif
memory->_base._cfinfo[CF_INFO_BITS] = 0;
_CFRuntimeSetInstanceTypeID(memory, __kCFAllocatorTypeID);
memory->_base._cfisa = __CFISAForTypeID(__kCFAllocatorTypeID);
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED
memory->size = __CFAllocatorCustomSize;
memory->malloc = __CFAllocatorCustomMalloc;
memory->calloc = __CFAllocatorCustomCalloc;
memory->valloc = __CFAllocatorCustomValloc;
memory->free = __CFAllocatorCustomFree;
memory->realloc = __CFAllocatorCustomRealloc;
memory->destroy = __CFAllocatorCustomDestroy;
memory->zone_name = "Custom CFAllocator";
memory->batch_malloc = NULL;
memory->batch_free = NULL;
memory->introspect = &__CFAllocatorZoneIntrospect;
memory->reserved5 = NULL;
#endif
memory->_allocator = allocator;
memory->_context.version = context->version;
memory->_context.info = retainedInfo;
memory->_context.retain = retainFunc;
memory->_context.release = context->release;
FAULT_CALLBACK((void **)&(memory->_context.release));
memory->_context.copyDescription = context->copyDescription;
FAULT_CALLBACK((void **)&(memory->_context.copyDescription));
memory->_context.allocate = allocateFunc;
memory->_context.reallocate = context->reallocate;
FAULT_CALLBACK((void **)&(memory->_context.reallocate));
memory->_context.deallocate = context->deallocate;
FAULT_CALLBACK((void **)&(memory->_context.deallocate));
memory->_context.preferredSize = context->preferredSize;
FAULT_CALLBACK((void **)&(memory->_context.preferredSize));
return memory;
}
CFAllocatorRef CFAllocatorCreate(CFAllocatorRef allocator, CFAllocatorContext *context) {
return __CFAllocatorCreate(allocator, context);
}
void *CFAllocatorAllocate(CFAllocatorRef allocator, CFIndex size, CFOptionFlags hint) {
CFAllocatorAllocateCallBack allocateFunc;
void *newptr = NULL;
allocator = (NULL == allocator) ? __CFGetDefaultAllocator() : allocator;
#if defined(DEBUG) && (DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED)
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
if (allocator->_base._cfisa != __CFISAForTypeID(__kCFAllocatorTypeID)) { 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;
allocator = (NULL == allocator) ? __CFGetDefaultAllocator() : allocator;
#if defined(DEBUG) && (DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED)
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
if (allocator->_base._cfisa != __CFISAForTypeID(__kCFAllocatorTypeID)) { 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
if (allocator->_base._cfisa != __CFISAForTypeID(__kCFAllocatorTypeID)) { #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
if (allocator->_base._cfisa != __CFISAForTypeID(__kCFAllocatorTypeID)) { 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;
}
void CFAllocatorDeallocate(CFAllocatorRef allocator, void *ptr) {
CFAllocatorDeallocateCallBack deallocateFunc;
allocator = (NULL == allocator) ? __CFGetDefaultAllocator() : allocator;
#if defined(DEBUG) && (DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED)
if (allocator->_base._cfisa == __CFISAForTypeID(__kCFAllocatorTypeID)) {
__CFGenericValidateType(allocator, __kCFAllocatorTypeID);
}
#else
__CFGenericValidateType(allocator, __kCFAllocatorTypeID);
#endif
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED
if (allocator->_base._cfisa != __CFISAForTypeID(__kCFAllocatorTypeID)) { #if defined(DEBUG)
size_t size = malloc_size(ptr);
if (size) memset(ptr, 0xCC, size);
#endif
return malloc_zone_free((malloc_zone_t *)allocator, ptr);
}
#endif
deallocateFunc = __CFAllocatorGetDeallocateFunction(&allocator->_context);
if (NULL != ptr && NULL != deallocateFunc) {
INVOKE_CALLBACK2(deallocateFunc, ptr, allocator->_context.info);
}
}
CFIndex CFAllocatorGetPreferredSizeForSize(CFAllocatorRef allocator, CFIndex size, CFOptionFlags hint) {
CFAllocatorPreferredSizeCallBack prefFunc;
CFIndex newsize = 0;
allocator = (NULL == allocator) ? __CFGetDefaultAllocator() : allocator;
#if defined(DEBUG) && (DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED)
if (allocator->_base._cfisa == __CFISAForTypeID(__kCFAllocatorTypeID)) {
__CFGenericValidateType(allocator, __kCFAllocatorTypeID);
}
#else
__CFGenericValidateType(allocator, __kCFAllocatorTypeID);
#endif
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED
if (allocator->_base._cfisa != __CFISAForTypeID(__kCFAllocatorTypeID)) { return malloc_good_size(size);
}
#endif
prefFunc = __CFAllocatorGetPreferredSizeFunction(&allocator->_context);
if (0 < size && NULL != prefFunc) {
newsize = (CFIndex)(INVOKE_CALLBACK3(prefFunc, size, hint, allocator->_context.info));
}
if (newsize < size) newsize = size;
return newsize;
}
void CFAllocatorGetContext(CFAllocatorRef allocator, CFAllocatorContext *context) {
allocator = (NULL == allocator) ? __CFGetDefaultAllocator() : allocator;
#if defined(DEBUG) && (DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED)
if (allocator->_base._cfisa == __CFISAForTypeID(__kCFAllocatorTypeID)) {
__CFGenericValidateType(allocator, __kCFAllocatorTypeID);
}
#else
__CFGenericValidateType(allocator, __kCFAllocatorTypeID);
#endif
CFAssert1(0 == context->version, __kCFLogAssertion, "%s(): context version not initialized to 0", __PRETTY_FUNCTION__);
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED
if (allocator->_base._cfisa != __CFISAForTypeID(__kCFAllocatorTypeID)) { return;
}
#endif
context->version = 0;
context->info = allocator->_context.info;
context->retain = __CFAllocatorGetRetainFunction(&allocator->_context);
context->release = __CFAllocatorGetReleaseFunction(&allocator->_context);
context->copyDescription = __CFAllocatorGetCopyDescriptionFunction(&allocator->_context);
context->allocate = __CFAllocatorGetAllocateFunction(&allocator->_context);
context->reallocate = __CFAllocatorGetReallocateFunction(&allocator->_context);
context->deallocate = __CFAllocatorGetDeallocateFunction(&allocator->_context);
context->preferredSize = __CFAllocatorGetPreferredSizeFunction(&allocator->_context);
#if DEPLOYMENT_TARGET_MACOSX && defined(__ppc__)
context->retain = (void *)((uintptr_t)context->retain & ~0x3);
context->release = (void *)((uintptr_t)context->release & ~0x3);
context->copyDescription = (void *)((uintptr_t)context->copyDescription & ~0x3);
context->allocate = (void *)((uintptr_t)context->allocate & ~0x3);
context->reallocate = (void *)((uintptr_t)context->reallocate & ~0x3);
context->deallocate = (void *)((uintptr_t)context->deallocate & ~0x3);
context->preferredSize = (void *)((uintptr_t)context->preferredSize & ~0x3);
#endif
}
__private_extern__ void *_CFAllocatorAllocateGC(CFAllocatorRef allocator, CFIndex size, CFOptionFlags hint)
{
if (CF_IS_COLLECTABLE_ALLOCATOR(allocator))
return auto_zone_allocate_object((auto_zone_t*)kCFAllocatorSystemDefault->_context.info, size, CF_GET_GC_MEMORY_TYPE(hint), false, false);
else
return CFAllocatorAllocate(allocator, size, hint);
}
__private_extern__ void *_CFAllocatorReallocateGC(CFAllocatorRef allocator, void *ptr, CFIndex newsize, CFOptionFlags hint)
{
if (CF_IS_COLLECTABLE_ALLOCATOR(allocator)) {
if (ptr && (newsize == 0)) {
return NULL; }
if (ptr == NULL) {
return auto_zone_allocate_object((auto_zone_t*)kCFAllocatorSystemDefault->_context.info, newsize, CF_GET_GC_MEMORY_TYPE(hint), false, false); }
}
return CFAllocatorReallocate(allocator, ptr, newsize, hint);
}
__private_extern__ void _CFAllocatorDeallocateGC(CFAllocatorRef allocator, void *ptr)
{
if (!CF_IS_COLLECTABLE_ALLOCATOR(allocator)) CFAllocatorDeallocate(allocator, ptr);
}
#if DEPLOYMENT_TARGET_WINDOWS
__private_extern__ DWORD __CFTSDKey = 0xFFFFFFFF;
#endif
#if DEPLOYMENT_TARGET_WINDOWS
extern void __CFStringEncodingICUThreadDataCleaner(void *);
__private_extern__ void __CFFinalizeThreadData(void *arg) {
__CFThreadSpecificData *tsd = (__CFThreadSpecificData*)TlsGetValue(__CFTSDKey);
TlsSetValue(__CFTSDKey, NULL);
if (NULL == tsd) return;
if (tsd->_allocator) CFRelease(tsd->_allocator);
if (tsd->_messageHook) UnhookWindowsHookEx(tsd->_messageHook);
if (tsd->_icuThreadData) __CFStringEncodingICUThreadDataCleaner(tsd->_icuThreadData);
CFAllocatorDeallocate(kCFAllocatorSystemDefault, tsd);
}
__private_extern__ __CFThreadSpecificData *__CFGetThreadSpecificData(void) {
__CFThreadSpecificData *data;
data = (__CFThreadSpecificData *)TlsGetValue(__CFTSDKey);
if (data) {
return data;
}
data = (__CFThreadSpecificData *)CFAllocatorAllocate(kCFAllocatorSystemDefault, sizeof(__CFThreadSpecificData), 0);
if (__CFOASafe) __CFSetLastAllocationEventName(data, "CFUtilities (thread-data)");
memset(data, 0, sizeof(__CFThreadSpecificData));
TlsSetValue(__CFTSDKey, data);
return data;
}
#endif
__private_extern__ void __CFBaseInitialize(void) {
#if DEPLOYMENT_TARGET_WINDOWS
__CFTSDKey = TlsAlloc();
#endif
}
#if DEPLOYMENT_TARGET_WINDOWS
__private_extern__ void __CFBaseCleanup(void) {
TlsFree(__CFTSDKey);
}
#endif
CFRange __CFRangeMake(CFIndex loc, CFIndex len) {
CFRange range;
range.location = loc;
range.length = len;
return range;
}
struct __CFNull {
CFRuntimeBase _base;
};
static struct __CFNull __kCFNull = {
INIT_CFRUNTIME_BASE()
};
const CFNullRef kCFNull = &__kCFNull;
static CFStringRef __CFNullCopyDescription(CFTypeRef cf) {
return CFStringCreateWithFormat(kCFAllocatorSystemDefault, NULL, CFSTR("<CFNull %p [%p]>"), cf, CFGetAllocator(cf));
}
static CFStringRef __CFNullCopyFormattingDescription(CFTypeRef cf, CFDictionaryRef formatOptions) {
return (CFStringRef)CFRetain(CFSTR("null"));
}
static void __CFNullDeallocate(CFTypeRef cf) {
CFAssert(false, __kCFLogAssertion, "Deallocated CFNull!");
}
static CFTypeID __kCFNullTypeID = _kCFRuntimeNotATypeID;
static const CFRuntimeClass __CFNullClass = {
0,
"CFNull",
NULL, NULL, __CFNullDeallocate,
NULL,
NULL,
__CFNullCopyFormattingDescription,
__CFNullCopyDescription
};
__private_extern__ void __CFNullInitialize(void) {
__kCFNullTypeID = _CFRuntimeRegisterClass(&__CFNullClass);
_CFRuntimeSetInstanceTypeID(&__kCFNull, __kCFNullTypeID);
__kCFNull._base._cfisa = __CFISAForTypeID(__kCFNullTypeID);
}
CFTypeID CFNullGetTypeID(void) {
return __kCFNullTypeID;
}
void CFCollection_non_gc_storage_error(void) { }
static int hasCFM = 0;
void _CFRuntimeSetCFMPresent(void *addr) {
hasCFM = 1;
}
#if DEPLOYMENT_TARGET_MACOSX && defined(__ppc__)
__private_extern__ void __CF_FAULT_CALLBACK(void **ptr) {
uintptr_t p = (uintptr_t)*ptr;
if ((0 == p) || (p & 0x1)) return;
if (0 == hasCFM || (0x90000000 <= p && p < 0xA0000000)) {
*ptr = (void *)(p | 0x1);
} else {
static CFMutableDictionaryRef cache = NULL;
static CFSpinLock_t lock = CFSpinLockInit;
uintptr_t known = ~0;
__CFSpinLock(&lock);
if (!cache || !CFDictionaryGetValueIfPresent(cache, (const void *)p, (const void **)&known)) {
if (!cache) {
cache = CFDictionaryCreateMutable(kCFAllocatorSystemDefault, 0, NULL, NULL);
}
Dl_info info;
known = dladdr((void *)p, &info);
CFDictionarySetValue(cache, (const void *)p, (const void *)known);
}
__CFSpinUnlock(&lock);
*ptr = (void *)(p | (known ? 0x1 : 0x3));
}
}
__asm__ (
".text\n"
" .align 2\n"
".private_extern ___CF_INVOKE_CALLBACK\n"
"___CF_INVOKE_CALLBACK:\n"
"rlwinm r12,r3,0,0,29\n"
"andi. r0,r3,0x2\n"
"or r3,r4,r4\n"
"or r4,r5,r5\n"
"or r5,r6,r6\n"
"or r6,r7,r7\n"
"or r7,r8,r8\n"
"beq- Lcall\n"
"lwz r2,0x4(r12)\n"
"lwz r12,0x0(r12)\n"
"Lcall: mtspr ctr,r12\n"
"bctr\n");
#endif
#if defined(__ppc__)
__asm__ (
".text\n"
" .align 2\n"
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED
".private_extern ___HALT\n"
#else
".globl ___HALT\n"
#endif
"___HALT:\n"
" trap\n"
);
#endif
#if defined(__i386__) || defined(__x86_64__)
#if defined(_MSC_VER)
void __HALT() {
__asm int 3;
}
#else
__asm__ (
".text\n"
" .align 2, 0x90\n"
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED
".private_extern ___HALT\n"
#else
".globl ___HALT\n"
#endif
"___HALT:\n"
" int3\n"
);
#endif
#endif