CFBase.c

/*
 * Copyright (c) 2008-2012 Brent Fulgham <bfulgham@gmail.org>. All rights reserved.
 * Copyright (c) 2009 Grant Erickson <gerickson@nuovations.com>. All rights reserved.
 *
 * This source code is a modified version of the CoreFoundation sources released by Apple Inc. under
 * the terms of the APSL version 2.0 (see below).
 *
 * For information about changes from the original Apple source release can be found by reviewing the
 * source control system for the project at https://sourceforge.net/svn/?group_id=246198.
 *
 * The original license information is as follows:
 * 
 * Copyright (c) 2012 Apple Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */

/* CFBase.c
 Copyright (c) 1998-2011, Apple Inc. All rights reserved.
 Responsibility: Christopher Kane
*/

#include<CoreFoundation/CFBase.h>
#include<CoreFoundation/CoreFoundation_Prefix.h>
#include"CFInternal.h"
#ifDEPLOYMENT_TARGET_MACOSX||DEPLOYMENT_TARGET_EMBEDDED||DEPLOYMENT_TARGET_LINUX||DEPLOYMENT_TARGET_FREEBSD
#include<pthread.h>
#endif
#ifDEPLOYMENT_TARGET_MACOSX||DEPLOYMENT_TARGET_EMBEDDED
#include<malloc/malloc.h>
externsize_tmalloc_good_size(size_tsize);
#include<mach/mach.h>
#include<dlfcn.h>
#endif
#include<stdlib.h>
#include<string.h>

// -------- -------- -------- -------- -------- -------- -------- --------

#ifDEPLOYMENT_TARGET_MACOSX||DEPLOYMENT_TARGET_EMBEDDED
// CFAllocator structure must match struct _malloc_zone_t!
// The first two reserved fields in struct _malloc_zone_t are for us with CFRuntimeBase
#endif


struct__CFAllocator {
CFRuntimeBase_base;
#ifDEPLOYMENT_TARGET_MACOSX||DEPLOYMENT_TARGET_EMBEDDED
size_t (*size)(struct_malloc_zone_t*zone, constvoid*ptr); /* returns the size of a block or 0 if not in this zone; must be fast, especially for negative answers */
void*(*malloc)(struct_malloc_zone_t*zone, size_tsize);
void*(*calloc)(struct_malloc_zone_t*zone, size_tnum_items, size_tsize); /* same as malloc, but block returned is set to zero */
void*(*valloc)(struct_malloc_zone_t*zone, size_tsize); /* same as malloc, but block returned is set to zero and is guaranteed to be page aligned */
void (*free)(struct_malloc_zone_t*zone, void*ptr);
void*(*realloc)(struct_malloc_zone_t*zone, void*ptr, size_tsize);
void (*destroy)(struct_malloc_zone_t*zone); /* zone is destroyed and all memory reclaimed */
constchar*zone_name;

/* Optional batch callbacks; these may be NULL */
unsigned (*batch_malloc)(struct_malloc_zone_t*zone, size_tsize, void**results, unsignednum_requested); /* given a size, returns pointers capable of holding that size; returns the number of pointers allocated (maybe 0 or less than num_requested) */
void (*batch_free)(struct_malloc_zone_t*zone, void**to_be_freed, unsignednum_to_be_freed); /* frees all the pointers in to_be_freed; note that to_be_freed may be overwritten during the process */

structmalloc_introspection_t*introspect;
unsignedversion;

/* aligned memory allocation. The callback may be NULL. */
void*(*memalign)(struct_malloc_zone_t*zone, size_talignment, size_tsize);

/* free a pointer known to be in zone and known to have the given size. The callback may be NULL. */
void (*free_definite_size)(struct_malloc_zone_t*zone, void*ptr, size_tsize);
#endif
CFAllocatorRef_allocator;
CFAllocatorContext_context;
};

CF_INLINECFAllocatorRetainCallBack__CFAllocatorGetRetainFunction(constCFAllocatorContext*context) {
CFAllocatorRetainCallBackretval=NULL;
retval=context->retain;
returnretval;
}

CF_INLINECFAllocatorReleaseCallBack__CFAllocatorGetReleaseFunction(constCFAllocatorContext*context) {
CFAllocatorReleaseCallBackretval=NULL;
retval=context->release;
returnretval;
}

CF_INLINECFAllocatorCopyDescriptionCallBack__CFAllocatorGetCopyDescriptionFunction(constCFAllocatorContext*context) {
CFAllocatorCopyDescriptionCallBackretval=NULL;
retval=context->copyDescription;
returnretval;
}

CF_INLINECFAllocatorAllocateCallBack__CFAllocatorGetAllocateFunction(constCFAllocatorContext*context) {
CFAllocatorAllocateCallBackretval=NULL;
retval=context->allocate;
returnretval;
}

CF_INLINECFAllocatorReallocateCallBack__CFAllocatorGetReallocateFunction(constCFAllocatorContext*context) {
CFAllocatorReallocateCallBackretval=NULL;
retval=context->reallocate;
returnretval;
}

CF_INLINECFAllocatorDeallocateCallBack__CFAllocatorGetDeallocateFunction(constCFAllocatorContext*context) {
CFAllocatorDeallocateCallBackretval=NULL;
retval=context->deallocate;
returnretval;
}

CF_INLINECFAllocatorPreferredSizeCallBack__CFAllocatorGetPreferredSizeFunction(constCFAllocatorContext*context) {
CFAllocatorPreferredSizeCallBackretval=NULL;
retval=context->preferredSize;
returnretval;
}

#ifDEPLOYMENT_TARGET_MACOSX||DEPLOYMENT_TARGET_EMBEDDED

__private_extern__void__CFAllocatorDeallocate(CFTypeRefcf);

statickern_return_t__CFAllocatorZoneIntrospectNoOp(void) {
return0;
}

staticboolean_t__CFAllocatorZoneIntrospectTrue(void) {
return1;
}

staticsize_t__CFAllocatorCustomSize(malloc_zone_t*zone, constvoid*ptr) {
return0;

// The only way to implement this with a version 0 allocator would be
// for CFAllocator to keep track of all blocks allocated itself, which
// could be done, but would be bad for performance, so we don't do it.
// size_t (*size)(struct _malloc_zone_t *zone, const void *ptr);
/* returns the size of a block or 0 if not in this zone;
 * must be fast, especially for negative answers */
}

staticvoid*__CFAllocatorCustomMalloc(malloc_zone_t*zone, size_tsize) {
CFAllocatorRefallocator= (CFAllocatorRef)zone;
returnCFAllocatorAllocate(allocator, size, 0);
}

staticvoid*__CFAllocatorCustomCalloc(malloc_zone_t*zone, size_tnum_items, size_tsize) {
CFAllocatorRefallocator= (CFAllocatorRef)zone;
void*newptr=CFAllocatorAllocate(allocator, size, 0);
if (newptr) memset(newptr, 0, size);
returnnewptr;
}

staticvoid*__CFAllocatorCustomValloc(malloc_zone_t*zone, size_tsize) {
CFAllocatorRefallocator= (CFAllocatorRef)zone;
if (size >= ULONG_MAX-2*vm_page_size) returnNULL; // avoid integer overflow plus don't allow all pages to be allocated either
void*newptr=CFAllocatorAllocate(allocator, size+vm_page_size, 0);
newptr= (void*)round_page((uintptr_t)newptr);
returnnewptr;
}

staticvoid__CFAllocatorCustomFree(malloc_zone_t*zone, void*ptr) {
CFAllocatorRefallocator= (CFAllocatorRef)zone;
CFAllocatorDeallocate(allocator, ptr);
}

staticvoid*__CFAllocatorCustomRealloc(malloc_zone_t*zone, void*ptr, size_tsize) {
CFAllocatorRefallocator= (CFAllocatorRef)zone;
returnCFAllocatorReallocate(allocator, ptr, size, 0);
}

staticvoid__CFAllocatorCustomDestroy(malloc_zone_t*zone) {
CFAllocatorRefallocator= (CFAllocatorRef)zone;
// !!! we do it, and caller of malloc_destroy_zone() assumes
// COMPLETE responsibility for the result; NO Apple library
// code should be modified as a result of discovering that
// some activity results in inconveniences to developers
// trying to use malloc_destroy_zone() with a CFAllocatorRef;
// that's just too bad for them.
__CFAllocatorDeallocate(allocator);
}

staticsize_t__CFAllocatorCustomGoodSize(malloc_zone_t*zone, size_tsize) {
CFAllocatorRefallocator= (CFAllocatorRef)zone;
returnCFAllocatorGetPreferredSizeForSize(allocator, size, 0);
}

staticstructmalloc_introspection_t__CFAllocatorZoneIntrospect= {
 (void*)__CFAllocatorZoneIntrospectNoOp,
 (void*)__CFAllocatorCustomGoodSize,
 (void*)__CFAllocatorZoneIntrospectTrue,
 (void*)__CFAllocatorZoneIntrospectNoOp,
 (void*)__CFAllocatorZoneIntrospectNoOp,
 (void*)__CFAllocatorZoneIntrospectNoOp,
 (void*)__CFAllocatorZoneIntrospectNoOp,
 (void*)__CFAllocatorZoneIntrospectNoOp
};

staticsize_t__CFAllocatorNullSize(malloc_zone_t*zone, constvoid*ptr) {
return0;
}

staticvoid*__CFAllocatorNullMalloc(malloc_zone_t*zone, size_tsize) {
returnNULL;
}

staticvoid*__CFAllocatorNullCalloc(malloc_zone_t*zone, size_tnum_items, size_tsize) {
returnNULL;
}

staticvoid*__CFAllocatorNullValloc(malloc_zone_t*zone, size_tsize) {
returnNULL;
}

staticvoid__CFAllocatorNullFree(malloc_zone_t*zone, void*ptr) {
}

staticvoid*__CFAllocatorNullRealloc(malloc_zone_t*zone, void*ptr, size_tsize) {
returnNULL;
}

staticvoid__CFAllocatorNullDestroy(malloc_zone_t*zone) {
}

staticsize_t__CFAllocatorNullGoodSize(malloc_zone_t*zone, size_tsize) {
returnsize;
}

staticstructmalloc_introspection_t__CFAllocatorNullZoneIntrospect= {
 (void*)__CFAllocatorZoneIntrospectNoOp,
 (void*)__CFAllocatorNullGoodSize,
 (void*)__CFAllocatorZoneIntrospectTrue,
 (void*)__CFAllocatorZoneIntrospectNoOp,
 (void*)__CFAllocatorZoneIntrospectNoOp,
 (void*)__CFAllocatorZoneIntrospectNoOp,
 (void*)__CFAllocatorZoneIntrospectNoOp,
 (void*)__CFAllocatorZoneIntrospectNoOp
};

staticvoid*__CFAllocatorSystemAllocate(CFIndexsize, CFOptionFlagshint, void*info) {
returnmalloc_zone_malloc(info, size);
}

staticvoid*__CFAllocatorSystemReallocate(void*ptr, CFIndexnewsize, CFOptionFlagshint, void*info) {
returnmalloc_zone_realloc(info, ptr, newsize);
}

staticvoid__CFAllocatorSystemDeallocate(void*ptr, void*info) {
#if defined(DEBUG)
size_tsize=malloc_size(ptr);
if (size) memset(ptr, 0xCC, size);
#endif
malloc_zone_free(info, ptr);
}

#endif

#ifDEPLOYMENT_TARGET_WINDOWS||DEPLOYMENT_TARGET_LINUX||DEPLOYMENT_TARGET_FREEBSD
staticvoid*__CFAllocatorSystemAllocate(CFIndexsize, CFOptionFlagshint, void*info) {
returnmalloc(size);
}

staticvoid*__CFAllocatorSystemReallocate(void*ptr, CFIndexnewsize, CFOptionFlagshint, void*info) {
returnrealloc(ptr, newsize);
}

staticvoid__CFAllocatorSystemDeallocate(void*ptr, void*info) {
free(ptr);
}
#endif

staticvoid*__CFAllocatorNullAllocate(CFIndexsize, CFOptionFlagshint, void*info) {
returnNULL;
}

staticvoid*__CFAllocatorNullReallocate(void*ptr, CFIndexnewsize, CFOptionFlagshint, void*info) {
returnNULL;
}

#if defined (__cplusplus)
staticvoid*__CFAllocatorCPPMalloc(CFIndexallocSize, CFOptionFlagshint, void*info)
{
returnmalloc(allocSize); 
}
staticvoid*__CFAllocatorCPPReAlloc(void*ptr, CFIndexnewsize, CFOptionFlagshint, void*info)
{
returnrealloc(ptr, newsize);
}
staticvoid__CFAllocatorCPPFree(void*ptr, void*info)
{
free(ptr);
}
#endif// C++


staticstruct__CFAllocator__kCFAllocatorMalloc= {
INIT_CFRUNTIME_BASE(),
#ifDEPLOYMENT_TARGET_MACOSX||DEPLOYMENT_TARGET_EMBEDDED
__CFAllocatorCustomSize,
__CFAllocatorCustomMalloc,
__CFAllocatorCustomCalloc,
__CFAllocatorCustomValloc,
__CFAllocatorCustomFree,
__CFAllocatorCustomRealloc,
__CFAllocatorNullDestroy,
"kCFAllocatorMalloc",
NULL,
NULL,
&__CFAllocatorZoneIntrospect,
6,
NULL,
NULL,
#endif
NULL, // _allocator
// Using the malloc functions directly is a total cheat, but works (in C)
// because the function signatures match in their common prefix of arguments.
// This saves us one hop through an adaptor function.
#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
};

staticstruct__CFAllocator__kCFAllocatorMallocZone= {
INIT_CFRUNTIME_BASE(),
#ifDEPLOYMENT_TARGET_MACOSX||DEPLOYMENT_TARGET_EMBEDDED
__CFAllocatorCustomSize,
__CFAllocatorCustomMalloc,
__CFAllocatorCustomCalloc,
__CFAllocatorCustomValloc,
__CFAllocatorCustomFree,
__CFAllocatorCustomRealloc,
__CFAllocatorNullDestroy,
"kCFAllocatorMallocZone",
NULL,
NULL,
&__CFAllocatorZoneIntrospect,
6,
NULL,
NULL,
#endif
NULL, // _allocator
 {0, NULL, NULL, NULL, NULL, __CFAllocatorSystemAllocate, __CFAllocatorSystemReallocate, __CFAllocatorSystemDeallocate, NULL}
};

staticstruct__CFAllocator__kCFAllocatorSystemDefault= {
INIT_CFRUNTIME_BASE(),
#ifDEPLOYMENT_TARGET_MACOSX||DEPLOYMENT_TARGET_EMBEDDED
__CFAllocatorCustomSize,
__CFAllocatorCustomMalloc,
__CFAllocatorCustomCalloc,
__CFAllocatorCustomValloc,
__CFAllocatorCustomFree,
__CFAllocatorCustomRealloc,
__CFAllocatorNullDestroy,
"kCFAllocatorSystemDefault",
NULL,
NULL,
&__CFAllocatorZoneIntrospect,
6,
NULL,
NULL,
#endif
NULL, // _allocator
 {0, NULL, NULL, NULL, NULL, __CFAllocatorSystemAllocate, __CFAllocatorSystemReallocate, __CFAllocatorSystemDeallocate, NULL}
};

staticstruct__CFAllocator__kCFAllocatorNull= {
INIT_CFRUNTIME_BASE(),
#ifDEPLOYMENT_TARGET_MACOSX||DEPLOYMENT_TARGET_EMBEDDED
__CFAllocatorNullSize,
__CFAllocatorNullMalloc,
__CFAllocatorNullCalloc,
__CFAllocatorNullValloc,
__CFAllocatorNullFree,
__CFAllocatorNullRealloc,
__CFAllocatorNullDestroy,
"kCFAllocatorNull",
NULL,
NULL,
&__CFAllocatorNullZoneIntrospect,
6,
NULL,
NULL,
#endif
NULL, // _allocator
 {0, NULL, NULL, NULL, NULL, __CFAllocatorNullAllocate, __CFAllocatorNullReallocate, NULL, NULL}
};

constCFAllocatorRefkCFAllocatorDefault=NULL;
constCFAllocatorRefkCFAllocatorSystemDefault=&__kCFAllocatorSystemDefault;
constCFAllocatorRefkCFAllocatorMalloc=&__kCFAllocatorMalloc;
constCFAllocatorRefkCFAllocatorMallocZone=&__kCFAllocatorMallocZone;
constCFAllocatorRefkCFAllocatorNull=&__kCFAllocatorNull;
constCFAllocatorRefkCFAllocatorUseContext= (CFAllocatorRef)0x03ab;
#undef kCFAllocatorSystemDefaultGCRefZero
#undef kCFAllocatorDefaultGCRefZero
constCFAllocatorRefkCFAllocatorSystemDefaultGCRefZero= (CFAllocatorRef)0x03ad;
constCFAllocatorRefkCFAllocatorDefaultGCRefZero= (CFAllocatorRef)0x03af;

staticCFStringRef__CFAllocatorCopyDescription(CFTypeRefcf) {
CFAllocatorRefself= (CFAllocatorRef)cf;
CFAllocatorRefallocator= (kCFAllocatorUseContext==self->_allocator) ? self : self->_allocator;
returnCFStringCreateWithFormat(allocator, NULL, CFSTR("<CFAllocator %p [%p]>{info = %p}"), cf, allocator, self->_context.info);
// CF: should use copyDescription function here to describe info field
// remember to release value returned from copydescr function when this happens
}

__private_extern__CFAllocatorRef__CFAllocatorGetAllocator(CFTypeRefcf) {
CFAllocatorRefallocator= (CFAllocatorRef)cf;
return (kCFAllocatorUseContext==allocator->_allocator) ? allocator : allocator->_allocator;
}

__private_extern__void__CFAllocatorDeallocate(CFTypeRefcf) {
CFAllocatorRefself= (CFAllocatorRef)cf;
CFAllocatorRefallocator=self->_allocator;
CFAllocatorReleaseCallBackreleaseFunc=__CFAllocatorGetReleaseFunction(&self->_context);
if (kCFAllocatorUseContext==allocator) {
/* Rather a chicken and egg problem here, so we do things
 in the reverse order from what was done at create time. */
CFAllocatorDeallocateCallBackdeallocateFunc=__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);
 }
if (!CF_IS_COLLECTABLE_ALLOCATOR(allocator)) CFAllocatorDeallocate(allocator, (void*)self);
 }
}

staticCFTypeID__kCFAllocatorTypeID=_kCFRuntimeNotATypeID;

staticconstCFRuntimeClass__CFAllocatorClass= {
0,
"CFAllocator",
NULL, // init
NULL, // copy
NULL,
NULL, // equal
NULL, // hash
NULL, // 
__CFAllocatorCopyDescription
};

__private_extern__void__CFAllocatorInitialize(void) {
__kCFAllocatorTypeID=_CFRuntimeRegisterClass(&__CFAllocatorClass);

_CFRuntimeSetInstanceTypeID(&__kCFAllocatorSystemDefault, __kCFAllocatorTypeID);
__kCFAllocatorSystemDefault._base._cfisa=__CFISAForTypeID(__kCFAllocatorTypeID);
#ifDEPLOYMENT_TARGET_MACOSX||DEPLOYMENT_TARGET_EMBEDDED
__kCFAllocatorSystemDefault._context.info= (kCFUseCollectableAllocator ? objc_collectableZone() : malloc_default_zone());
#endif
__kCFAllocatorSystemDefault._allocator=kCFAllocatorSystemDefault;

_CFRuntimeSetInstanceTypeID(&__kCFAllocatorMalloc, __kCFAllocatorTypeID);
__kCFAllocatorMalloc._base._cfisa=__CFISAForTypeID(__kCFAllocatorTypeID);
__kCFAllocatorMalloc._allocator=kCFAllocatorSystemDefault;

#ifDEPLOYMENT_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;

}

CFTypeIDCFAllocatorGetTypeID(void) {
return__kCFAllocatorTypeID;
}

CFAllocatorRefCFAllocatorGetDefault(void) {
return__CFGetDefaultAllocator();
}

voidCFAllocatorSetDefault(CFAllocatorRefallocator) {
if (kCFAllocatorSystemDefaultGCRefZero==allocator||kCFAllocatorDefaultGCRefZero==allocator) {
HALT;
 }
CFAllocatorRefcurrent=__CFGetDefaultAllocator();
#if defined(DEBUG) 
if (NULL!=allocator) {
__CFGenericValidateType(allocator, __kCFAllocatorTypeID);
 }
#endif
#ifDEPLOYMENT_TARGET_MACOSX||DEPLOYMENT_TARGET_EMBEDDED
if (allocator&&allocator->_base._cfisa!=__CFISAForTypeID(__kCFAllocatorTypeID)) { // malloc_zone_t *
return; // require allocator to this function to be an allocator
 }
#endif
if (NULL!=allocator&&allocator!=current) {
if (current) CFRelease(current);
CFRetain(allocator);
// We retain an extra time so that anything set as the default
// allocator never goes away.
CFRetain(allocator);
_CFSetTSD(__CFTSDKeyAllocator, (void*)allocator, NULL);
 }
}

staticCFAllocatorRef__CFAllocatorCreate(CFAllocatorRefallocator, CFAllocatorContext*context) {
struct__CFAllocator*memory=NULL;
CFAllocatorRetainCallBackretainFunc;
CFAllocatorAllocateCallBackallocateFunc;
void*retainedInfo;
#ifDEPLOYMENT_TARGET_MACOSX||DEPLOYMENT_TARGET_EMBEDDED
if (allocator&&kCFAllocatorUseContext!=allocator&&allocator->_base._cfisa!=__CFISAForTypeID(__kCFAllocatorTypeID)) { // malloc_zone_t *
returnNULL; // require allocator to this function to be an allocator
 }
#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;
 }
// We don't use _CFRuntimeCreateInstance()
if (kCFAllocatorUseContext==allocator) {
memory=NULL;
if (allocateFunc) {
memory= (struct__CFAllocator*)INVOKE_CALLBACK3(allocateFunc, sizeof(struct__CFAllocator), 0, retainedInfo);
 }
if (NULL==memory) {
returnNULL;
 }
 } else {
allocator= (NULL==allocator) ? __CFGetDefaultAllocator() : allocator;
memory= (struct__CFAllocator*)CFAllocatorAllocate(allocator, sizeof(struct__CFAllocator), __kCFAllocatorGCObjectMemory);
if (NULL==memory) {
returnNULL;
 }
if (__CFOASafe) __CFSetLastAllocationEventName(memory, "CFAllocator");
 }
memset(memory, 0, sizeof(CFRuntimeBase));
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);
#ifDEPLOYMENT_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->version=6;
memory->memalign=NULL;
memory->free_definite_size=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));

returnmemory;
}

CFAllocatorRefCFAllocatorCreate(CFAllocatorRefallocator, CFAllocatorContext*context) {
return__CFAllocatorCreate(allocator, context);
}

void*CFAllocatorAllocate(CFAllocatorRefallocator, CFIndexsize, CFOptionFlagshint) {
CFAllocatorAllocateCallBackallocateFunc;
void*newptr=NULL;

BooleaninitialRefcountOne= true;
if (kCFAllocatorSystemDefaultGCRefZero==allocator) {
allocator=kCFAllocatorSystemDefault;
initialRefcountOne= false;
 } elseif (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;
 } elseif (NULL==allocator) {
allocator=__CFGetDefaultAllocator();
 }

#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) returnNULL;
#ifDEPLOYMENT_TARGET_MACOSX||DEPLOYMENT_TARGET_EMBEDDED
if (allocator->_base._cfisa!=__CFISAForTypeID(__kCFAllocatorTypeID)) { // malloc_zone_t *
returnmalloc_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);
 }
 }
returnnewptr;
}

void*CFAllocatorReallocate(CFAllocatorRefallocator, void*ptr, CFIndexnewsize, CFOptionFlagshint) {
CFAllocatorAllocateCallBackallocateFunc;
CFAllocatorReallocateCallBackreallocateFunc;
CFAllocatorDeallocateCallBackdeallocateFunc;
void*newptr;

if (kCFAllocatorSystemDefaultGCRefZero==allocator) {
allocator=kCFAllocatorSystemDefault;
 } elseif (kCFAllocatorDefaultGCRefZero==allocator) {
// Under GC, we can't use just any old allocator when the GCRefZero allocator was requested
allocator=kCFUseCollectableAllocator ? kCFAllocatorSystemDefault : __CFGetDefaultAllocator();
 } elseif (NULL==allocator) {
allocator=__CFGetDefaultAllocator();
 }

#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) {
#ifDEPLOYMENT_TARGET_MACOSX||DEPLOYMENT_TARGET_EMBEDDED
if (allocator->_base._cfisa!=__CFISAForTypeID(__kCFAllocatorTypeID)) { // malloc_zone_t *
returnmalloc_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);
 }
returnnewptr;
 }
if (NULL!=ptr&&0==newsize) {
#ifDEPLOYMENT_TARGET_MACOSX||DEPLOYMENT_TARGET_EMBEDDED
if (allocator->_base._cfisa!=__CFISAForTypeID(__kCFAllocatorTypeID)) { // malloc_zone_t *
#if defined(DEBUG)
size_tsize=malloc_size(ptr);
if (size) memset(ptr, 0xCC, size);
#endif
malloc_zone_free((malloc_zone_t*)allocator, ptr);
returnNULL;
 }
#endif
deallocateFunc=__CFAllocatorGetDeallocateFunction(&allocator->_context);
if (NULL!=deallocateFunc) {
INVOKE_CALLBACK2(deallocateFunc, ptr, allocator->_context.info);
 }
returnNULL;
 }
if (NULL==ptr&&0==newsize) returnNULL;
#ifDEPLOYMENT_TARGET_MACOSX||DEPLOYMENT_TARGET_EMBEDDED
if (allocator->_base._cfisa!=__CFISAForTypeID(__kCFAllocatorTypeID)) { // malloc_zone_t *
returnmalloc_zone_realloc((malloc_zone_t*)allocator, ptr, newsize);
 }
#endif
reallocateFunc=__CFAllocatorGetReallocateFunction(&allocator->_context);
if (NULL==reallocateFunc) returnNULL;
newptr= (void*)INVOKE_CALLBACK4(reallocateFunc, ptr, newsize, hint, allocator->_context.info);
returnnewptr;
}

voidCFAllocatorDeallocate(CFAllocatorRefallocator, void*ptr) {
CFAllocatorDeallocateCallBackdeallocateFunc;

if (kCFAllocatorSystemDefaultGCRefZero==allocator) {
if (_CFAllocatorIsGCRefZero(allocator)) return;
allocator=kCFAllocatorSystemDefault;
 } elseif (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)) return;
 } elseif (NULL==allocator) {
allocator=__CFGetDefaultAllocator();
 }

#if defined(DEBUG) && (DEPLOYMENT_TARGET_MACOSX||DEPLOYMENT_TARGET_EMBEDDED)
if (allocator->_base._cfisa==__CFISAForTypeID(__kCFAllocatorTypeID)) {
__CFGenericValidateType(allocator, __kCFAllocatorTypeID);
 }
#else
__CFGenericValidateType(allocator, __kCFAllocatorTypeID);
#endif
#ifDEPLOYMENT_TARGET_MACOSX||DEPLOYMENT_TARGET_EMBEDDED
if (allocator->_base._cfisa!=__CFISAForTypeID(__kCFAllocatorTypeID)) { // malloc_zone_t *
#if defined(DEBUG)
size_tsize=malloc_size(ptr);
if (size) memset(ptr, 0xCC, size);
#endif
returnmalloc_zone_free((malloc_zone_t*)allocator, ptr);
 }
#endif
deallocateFunc=__CFAllocatorGetDeallocateFunction(&allocator->_context);
if (NULL!=ptr&&NULL!=deallocateFunc) {
INVOKE_CALLBACK2(deallocateFunc, ptr, allocator->_context.info);
 }
}

CFIndexCFAllocatorGetPreferredSizeForSize(CFAllocatorRefallocator, CFIndexsize, CFOptionFlagshint) {
CFAllocatorPreferredSizeCallBackprefFunc;
CFIndexnewsize=0;

if (kCFAllocatorSystemDefaultGCRefZero==allocator) {
allocator=kCFAllocatorSystemDefault;
 } elseif (kCFAllocatorDefaultGCRefZero==allocator) {
// Under GC, we can't use just any old allocator when the GCRefZero allocator was requested
allocator=kCFUseCollectableAllocator ? kCFAllocatorSystemDefault : __CFGetDefaultAllocator();
 } elseif (NULL==allocator) {
allocator=__CFGetDefaultAllocator();
 }

#if defined(DEBUG) && (DEPLOYMENT_TARGET_MACOSX||DEPLOYMENT_TARGET_EMBEDDED)
if (allocator->_base._cfisa==__CFISAForTypeID(__kCFAllocatorTypeID)) {
__CFGenericValidateType(allocator, __kCFAllocatorTypeID);
 }
#else
__CFGenericValidateType(allocator, __kCFAllocatorTypeID);
#endif
#ifDEPLOYMENT_TARGET_MACOSX||DEPLOYMENT_TARGET_EMBEDDED
if (allocator->_base._cfisa!=__CFISAForTypeID(__kCFAllocatorTypeID)) { // malloc_zone_t *
returnmalloc_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;
returnnewsize;
}

voidCFAllocatorGetContext(CFAllocatorRefallocator, CFAllocatorContext*context) {
if (kCFAllocatorSystemDefaultGCRefZero==allocator) {
allocator=kCFAllocatorSystemDefault;
 } elseif (kCFAllocatorDefaultGCRefZero==allocator) {
// Under GC, we can't use just any old allocator when the GCRefZero allocator was requested
allocator=kCFUseCollectableAllocator ? kCFAllocatorSystemDefault : __CFGetDefaultAllocator();
 } elseif (NULL==allocator) {
allocator=__CFGetDefaultAllocator();
 }

#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__);
#ifDEPLOYMENT_TARGET_MACOSX||DEPLOYMENT_TARGET_EMBEDDED
if (allocator->_base._cfisa!=__CFISAForTypeID(__kCFAllocatorTypeID)) { // malloc_zone_t *
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);
#ifSUPPORT_CFM
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(CFAllocatorRefallocator, CFIndexsize, CFOptionFlagshint)
{
if (CF_IS_COLLECTABLE_ALLOCATOR(allocator))
returnauto_zone_allocate_object((auto_zone_t*)kCFAllocatorSystemDefault->_context.info, size, CF_GET_GC_MEMORY_TYPE(hint), false, false);
else
returnCFAllocatorAllocate(allocator, size, hint);
}

__private_extern__void*_CFAllocatorReallocateGC(CFAllocatorRefallocator, void*ptr, CFIndexnewsize, CFOptionFlagshint)
{
if (CF_IS_COLLECTABLE_ALLOCATOR(allocator)) {
if (ptr&& (newsize==0)) {
returnNULL; // equivalent to _CFAllocatorDeallocateGC.
 }
if (ptr==NULL) {
returnauto_zone_allocate_object((auto_zone_t*)kCFAllocatorSystemDefault->_context.info, newsize, CF_GET_GC_MEMORY_TYPE(hint), false, false); // eq. to _CFAllocator
 }
 }
// otherwise, auto_realloc() now preserves layout type and refCount.
returnCFAllocatorReallocate(allocator, ptr, newsize, hint);
}

__private_extern__void_CFAllocatorDeallocateGC(CFAllocatorRefallocator, void*ptr)
{
// when running GC, don't deallocate.
if (!CF_IS_COLLECTABLE_ALLOCATOR(allocator)) CFAllocatorDeallocate(allocator, ptr);
}

// -------- -------- -------- -------- -------- -------- -------- --------


CFRange__CFRangeMake(CFIndexloc, CFIndexlen) {
CFRangerange;
range.location=loc;
range.length=len;
returnrange;
}


struct__CFNull {
CFRuntimeBase_base;
};

staticstruct__CFNull__kCFNull= {
INIT_CFRUNTIME_BASE()
};
constCFNullRefkCFNull=&__kCFNull;

staticCFStringRef__CFNullCopyDescription(CFTypeRefcf) {
returnCFStringCreateWithFormat(kCFAllocatorSystemDefault, NULL, CFSTR("<CFNull %p [%p]>"), cf, CFGetAllocator(cf));
}

staticCFStringRef__CFNullCopyFormattingDescription(CFTypeRefcf, CFDictionaryRefformatOptions) {
return (CFStringRef)CFRetain(CFSTR("null"));
}

staticvoid__CFNullDeallocate(CFTypeRefcf) {
CFAssert(false, __kCFLogAssertion, "Deallocated CFNull!");
}

staticCFTypeID__kCFNullTypeID=_kCFRuntimeNotATypeID;

staticconstCFRuntimeClass__CFNullClass= {
0,
"CFNull",
NULL, // init
NULL, // copy
__CFNullDeallocate,
NULL,
NULL,
__CFNullCopyFormattingDescription,
__CFNullCopyDescription
};

__private_extern__void__CFNullInitialize(void) {
__kCFNullTypeID=_CFRuntimeRegisterClass(&__CFNullClass);
_CFRuntimeSetInstanceTypeID(&__kCFNull, __kCFNullTypeID);
__kCFNull._base._cfisa=__CFISAForTypeID(__kCFNullTypeID);
}

CFTypeIDCFNullGetTypeID(void) {
return__kCFNullTypeID;
}

voidCFCollection_non_gc_storage_error(void) { }


#if !SUPPORT_CFM
void_CFRuntimeSetCFMPresent(void*addr) {
}
#endif

#ifSUPPORT_CFM

staticinthasCFM=0;

void_CFRuntimeSetCFMPresent(void*addr) {
hasCFM=1;
}

/* See comments below */
__private_extern__void__CF_FAULT_CALLBACK(void**ptr) {
uintptr_tp= (uintptr_t)*ptr;
if ((0==p) || (p&0x1)) return;
if (0==hasCFM|| (0x90000000 <= p&&p<0xA0000000)) {
*ptr= (void*)(p | 0x1);
 } else {
uintptr_tknown= ~0;
Dl_infoinfo;
known=dladdr((void*)p, &info);
*ptr= (void*)(p | (known ? 0x1 : 0x3));
 }
}

/*
Jump to callback function. r2 is not saved and restored
in the jump-to-CFM case, since we assume that dyld code
never uses that register and that CF is dyld.

There are three states for (ptr & 0x3):
 0b00: check not yet done (or not going to be done, and is a dyld func ptr)
 0b01: check done, dyld function pointer
 0b11: check done, CFM tvector pointer
(but a NULL callback just stays NULL)

There may be up to 5 word-sized arguments. Floating point
arguments can be done, but count as two word arguments.
Return value can be integral or real.
*/

/* Keep this assembly at the bottom of the source file! */

__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


// void __HALT(void);

/* Keep this assembly at the bottom of the source file! */


externvoid__HALT() {
#if defined(__ppc__)
 __asm__("trap");
#elif defined(__i386__) || defined(__x86_64__)
#if defined(_MSC_VER)
 __asm int3;
#else
 __asm__("int3");
#endif
#endif
}