#include "objc-private.h"

#include "objc-abi.h"

#include <objc/message.h>

OBJC_EXPORT id (*_alloc)(Class, size_t);

OBJC_EXPORT id (*_copy)(id, size_t);

OBJC_EXPORT id (*_realloc)(id, size_t);

OBJC_EXPORT id (*_dealloc)(id);

OBJC_EXPORT id (*_zoneAlloc)(Class, size_t, void *);

OBJC_EXPORT id (*_zoneRealloc)(id, size_t, void *);

OBJC_EXPORT id (*_zoneCopy)(id, size_t, void *);

Class object_getClass(id obj)

{

if (obj) return obj->getIsa();

else return Nil;

}

Class object_setClass(id obj, Class cls)

{

if (!obj) return nil;

// Prevent a deadlock between the weak reference machinery

// and the +initialize machinery by ensuring that no

// weakly-referenced object has an un-+initialized isa.

// Unresolved future classes are not so protected.

if (!cls->isFuture() && !cls->isInitialized()) {

_class_initialize(_class_getNonMetaClass(cls, nil));

}

return obj->changeIsa(cls);

}

BOOL object_isClass(id obj)

{

if (!obj) return NO;

return obj->isClass();

}

const char *object_getClassName(id obj)

{

return class_getName(obj ? obj->getIsa() : nil);

}

IMP object_getMethodImplementation(id obj, SEL name)

{

Class cls = (obj ? obj->getIsa() : nil);

return class_getMethodImplementation(cls, name);

}

#if SUPPORT_STRET

IMP object_getMethodImplementation_stret(id obj, SEL name)

{

Class cls = (obj ? obj->getIsa() : nil);

return class_getMethodImplementation_stret(cls, name);

}

#endif

static bool isScanned(ptrdiff_t ivar_offset, const uint8_t *layout)

{

if (!layout) return NO;

ptrdiff_t index = 0, ivar_index = ivar_offset / sizeof(void*);

uint8_t byte;

while ((byte = *layout++)) {

unsigned skips = (byte >> 4);

unsigned scans = (byte & 0x0F);

index += skips;

if (index > ivar_index) return NO;

index += scans;

if (index > ivar_index) return YES;

}

return NO;

}

static void

_class_lookUpIvar(Class cls, Ivar ivar, ptrdiff_t& ivarOffset,

objc_ivar_memory_management_t& memoryManagement)

{

ivarOffset = ivar_getOffset(ivar);

// Look for ARC variables and ARC-style weak.

// Preflight the hasAutomaticIvars check

// because _class_getClassForIvar() may need to take locks.

bool hasAutomaticIvars = NO;

for (Class c = cls; c; c = c->superclass) {

if (c->hasAutomaticIvars()) {

hasAutomaticIvars = YES;

break;

}

}

if (hasAutomaticIvars) {

Class ivarCls = _class_getClassForIvar(cls, ivar);

if (ivarCls->hasAutomaticIvars()) {

// ARC layout bitmaps encode the class's own ivars only.

// Use alignedInstanceStart() because unaligned bytes at the start

// of this class's ivars are not represented in the layout bitmap.

ptrdiff_t localOffset =

ivarOffset - ivarCls->alignedInstanceStart();

if (isScanned(localOffset, class_getIvarLayout(ivarCls))) {

memoryManagement = objc_ivar_memoryStrong;

return;

}

if (isScanned(localOffset, class_getWeakIvarLayout(ivarCls))) {

memoryManagement = objc_ivar_memoryWeak;

return;

}

// Unretained is only for true ARC classes.

if (ivarCls->isARC()) {

memoryManagement = objc_ivar_memoryUnretained;

return;

}

}

}

memoryManagement = objc_ivar_memoryUnknown;

}

objc_ivar_memory_management_t

_class_getIvarMemoryManagement(Class cls, Ivar ivar)

{

ptrdiff_t offset;

objc_ivar_memory_management_t memoryManagement;

_class_lookUpIvar(cls, ivar, offset, memoryManagement);

return memoryManagement;

}

static ALWAYS_INLINE

void _object_setIvar(id obj, Ivar ivar, id value, bool assumeStrong)

{

if (!obj || !ivar || obj->isTaggedPointer()) return;

ptrdiff_t offset;

objc_ivar_memory_management_t memoryManagement;

_class_lookUpIvar(obj->ISA(), ivar, offset, memoryManagement);

if (memoryManagement == objc_ivar_memoryUnknown) {

if (assumeStrong) memoryManagement = objc_ivar_memoryStrong;

else memoryManagement = objc_ivar_memoryUnretained;

}

id *location = (id *)((char *)obj + offset);

switch (memoryManagement) {

case objc_ivar_memoryWeak: objc_storeWeak(location, value); break;

case objc_ivar_memoryStrong: objc_storeStrong(location, value); break;

case objc_ivar_memoryUnretained: *location = value; break;

case objc_ivar_memoryUnknown: _objc_fatal("impossible");

}

}

void object_setIvar(id obj, Ivar ivar, id value)

{

return _object_setIvar(obj, ivar, value, false /*not strong default*/);

}

void object_setIvarWithStrongDefault(id obj, Ivar ivar, id value)

{

return _object_setIvar(obj, ivar, value, true /*strong default*/);

}

id object_getIvar(id obj, Ivar ivar)

{

if (!obj || !ivar || obj->isTaggedPointer()) return nil;

ptrdiff_t offset;

objc_ivar_memory_management_t memoryManagement;

_class_lookUpIvar(obj->ISA(), ivar, offset, memoryManagement);

id *location = (id *)((char *)obj + offset);

if (memoryManagement == objc_ivar_memoryWeak) {

return objc_loadWeak(location);

} else {

return *location;

}

}

static ALWAYS_INLINE

Ivar _object_setInstanceVariable(id obj, const char *name, void *value,

bool assumeStrong)

{

Ivar ivar = nil;

if (obj && name && !obj->isTaggedPointer()) {

if ((ivar = _class_getVariable(obj->ISA(), name))) {

_object_setIvar(obj, ivar, (id)value, assumeStrong);

}

}

return ivar;

}

Ivar object_setInstanceVariable(id obj, const char *name, void *value)

{

return _object_setInstanceVariable(obj, name, value, false);

}

Ivar object_setInstanceVariableWithStrongDefault(id obj, const char *name,

void *value)

{

return _object_setInstanceVariable(obj, name, value, true);

}

Ivar object_getInstanceVariable(id obj, const char *name, void **value)

{

if (obj && name && !obj->isTaggedPointer()) {

Ivar ivar;

if ((ivar = class_getInstanceVariable(obj->ISA(), name))) {

if (value) *value = (void *)object_getIvar(obj, ivar);

return ivar;

}

}

if (value) *value = nil;

return nil;

}

static void object_cxxDestructFromClass(id obj, Class cls)

{

void (*dtor)(id);

// Call cls's dtor first, then superclasses's dtors.

for ( ; cls; cls = cls->superclass) {

if (!cls->hasCxxDtor()) return;

dtor = (void(*)(id))

lookupMethodInClassAndLoadCache(cls, SEL_cxx_destruct);

if (dtor != (void(*)(id))_objc_msgForward_impcache) {

if (PrintCxxCtors) {

_objc_inform("CXX: calling C++ destructors for class %s",

cls->nameForLogging());

}

// 执行的其实是 SEL_cxx_destruct 这个SEL标记的函数；SEL对应的正是之前看到的 .cxx_destruct 方法

(*dtor)(obj);

}

}

}

void object_cxxDestruct(id obj)

{

if (!obj) return;

if (obj->isTaggedPointer()) return;

object_cxxDestructFromClass(obj, obj->ISA());

}

id

object_cxxConstructFromClass(id obj, Class cls)

{

assert(cls->hasCxxCtor()); // required for performance, not correctness

id (*ctor)(id);

Class supercls;

supercls = cls->superclass;

// Call superclasses' ctors first, if any.

if (supercls && supercls->hasCxxCtor()) {

bool ok = object_cxxConstructFromClass(obj, supercls);

if (!ok) return nil; // some superclass's ctor failed - give up

}

// Find this class's ctor, if any.

ctor = (id(*)(id))lookupMethodInClassAndLoadCache(cls, SEL_cxx_construct);

if (ctor == (id(*)(id))_objc_msgForward_impcache) return obj; // no ctor - ok

// Call this class's ctor.

if (PrintCxxCtors) {

_objc_inform("CXX: calling C++ constructors for class %s",

cls->nameForLogging());

}

if ((*ctor)(obj)) return obj; // ctor called and succeeded - ok

// This class's ctor was called and failed.

// Call superclasses's dtors to clean up.

if (supercls) object_cxxDestructFromClass(obj, supercls);

return nil;

}

void fixupCopiedIvars(id newObject, id oldObject)

{

for (Class cls = oldObject->ISA(); cls; cls = cls->superclass) {

if (cls->hasAutomaticIvars()) {

// Use alignedInstanceStart() because unaligned bytes at the start

// of this class's ivars are not represented in the layout bitmap.

size_t instanceStart = cls->alignedInstanceStart();

const uint8_t *strongLayout = class_getIvarLayout(cls);

if (strongLayout) {

id *newPtr = (id *)((char*)newObject + instanceStart);

unsigned char byte;

while ((byte = *strongLayout++)) {

unsigned skips = (byte >> 4);

unsigned scans = (byte & 0x0F);

newPtr += skips;

while (scans--) {

// ensure strong references are properly retained.

id value = *newPtr++;

if (value) objc_retain(value);

}

}

}

const uint8_t *weakLayout = class_getWeakIvarLayout(cls);

// fix up weak references if any.

if (weakLayout) {

id *newPtr = (id *)((char*)newObject + instanceStart), *oldPtr = (id *)((char*)oldObject + instanceStart);

unsigned char byte;

while ((byte = *weakLayout++)) {

unsigned skips = (byte >> 4);

unsigned weaks = (byte & 0x0F);

newPtr += skips, oldPtr += skips;

while (weaks--) {

objc_copyWeak(newPtr, oldPtr);

++newPtr, ++oldPtr;

}

}

}

}

}

}

static void _class_resolveClassMethod(Class cls, SEL sel, id inst)

{

assert(cls->isMetaClass());

if (! lookUpImpOrNil(cls, SEL_resolveClassMethod, inst,

NO/*initialize*/, YES/*cache*/, NO/*resolver*/))

{

// Resolver not implemented.

return;

}

BOOL (*msg)(Class, SEL, SEL) = (typeof(msg))objc_msgSend;

bool resolved = msg(_class_getNonMetaClass(cls, inst),

SEL_resolveClassMethod, sel);

// Cache the result (good or bad) so the resolver doesn't fire next time.

// +resolveClassMethod adds to self->ISA() a.k.a. cls

IMP imp = lookUpImpOrNil(cls, sel, inst,

NO/*initialize*/, YES/*cache*/, NO/*resolver*/);

if (resolved && PrintResolving) {

if (imp) {

_objc_inform("RESOLVE: method %c[%s %s] "

"dynamically resolved to %p",

cls->isMetaClass() ? '+' : '-',

cls->nameForLogging(), sel_getName(sel), imp);

}

else {

// Method resolver didn't add anything?

_objc_inform("RESOLVE: +[%s resolveClassMethod:%s] returned YES"

", but no new implementation of %c[%s %s] was found",

cls->nameForLogging(), sel_getName(sel),

cls->isMetaClass() ? '+' : '-',

cls->nameForLogging(), sel_getName(sel));

}

}

}

static void _class_resolveInstanceMethod(Class cls, SEL sel, id inst)

{

if (! lookUpImpOrNil(cls->ISA(), SEL_resolveInstanceMethod, cls,

NO/*initialize*/, YES/*cache*/, NO/*resolver*/))

{

// Resolver not implemented.

return;

}

BOOL (*msg)(Class, SEL, SEL) = (typeof(msg))objc_msgSend;

bool resolved = msg(cls, SEL_resolveInstanceMethod, sel);

// Cache the result (good or bad) so the resolver doesn't fire next time.

// +resolveInstanceMethod adds to self a.k.a. cls

IMP imp = lookUpImpOrNil(cls, sel, inst,

NO/*initialize*/, YES/*cache*/, NO/*resolver*/);

if (resolved && PrintResolving) {

if (imp) {

_objc_inform("RESOLVE: method %c[%s %s] "

"dynamically resolved to %p",

cls->isMetaClass() ? '+' : '-',

cls->nameForLogging(), sel_getName(sel), imp);

}

else {

// Method resolver didn't add anything?

_objc_inform("RESOLVE: +[%s resolveInstanceMethod:%s] returned YES"

", but no new implementation of %c[%s %s] was found",

cls->nameForLogging(), sel_getName(sel),

cls->isMetaClass() ? '+' : '-',

cls->nameForLogging(), sel_getName(sel));

}

}

}

void _class_resolveMethod(Class cls, SEL sel, id inst)

{

if (! cls->isMetaClass()) {

// try [cls resolveInstanceMethod:sel]

_class_resolveInstanceMethod(cls, sel, inst);

}

else {

// try [nonMetaClass resolveClassMethod:sel]

// and [cls resolveInstanceMethod:sel]

_class_resolveClassMethod(cls, sel, inst);

if (!lookUpImpOrNil(cls, sel, inst,

NO/*initialize*/, YES/*cache*/, NO/*resolver*/))

{

_class_resolveInstanceMethod(cls, sel, inst);

}

}

}

Method class_getClassMethod(Class cls, SEL sel)

{

if (!cls || !sel) return nil;

return class_getInstanceMethod(cls->getMeta(), sel);

}

Ivar class_getInstanceVariable(Class cls, const char *name)

{

if (!cls || !name) return nil;

return _class_getVariable(cls, name);

}

Ivar class_getClassVariable(Class cls, const char *name)

{

if (!cls) return nil;

return class_getInstanceVariable(cls->ISA(), name);

}

BREAKPOINT_FUNCTION(

void gdb_objc_class_changed(Class cls, unsigned long changes, const char *classname)

);

BOOL class_respondsToMethod(Class cls, SEL sel)

{

OBJC_WARN_DEPRECATED;

return class_respondsToSelector(cls, sel);

}

BOOL class_respondsToSelector(Class cls, SEL sel)

{

return class_respondsToSelector_inst(cls, sel, nil);

}

bool class_respondsToSelector_inst(Class cls, SEL sel, id inst)

{

IMP imp;

if (!sel || !cls) return NO;

// Avoids +initialize because it historically did so.

// We're not returning a callable IMP anyway.

imp = lookUpImpOrNil(cls, sel, inst,

NO/*initialize*/, YES/*cache*/, YES/*resolver*/);

return bool(imp);

}

IMP class_lookupMethod(Class cls, SEL sel)

{

OBJC_WARN_DEPRECATED;

// No one responds to zero!

if (!sel) {

__objc_error(cls, "invalid selector (null)");

}

return class_getMethodImplementation(cls, sel);

}

IMP class_getMethodImplementation(Class cls, SEL sel)

{

IMP imp;

if (!cls || !sel) return nil;

imp = lookUpImpOrNil(cls, sel, nil,

YES/*initialize*/, YES/*cache*/, YES/*resolver*/);

// Translate forwarding function to C-callable external version

if (!imp) {

return _objc_msgForward;

}

return imp;

}

#if SUPPORT_STRET

IMP class_getMethodImplementation_stret(Class cls, SEL sel)

{

IMP imp = class_getMethodImplementation(cls, sel);

// Translate forwarding function to struct-returning version

if (imp == (IMP)&_objc_msgForward /* not _internal! */) {

return (IMP)&_objc_msgForward_stret;

}

return imp;

}

#endif

spinlock_t objcMsgLogLock;

#if !SUPPORT_MESSAGE_LOGGING

void instrumentObjcMessageSends(BOOL flag)

{

}

#else

bool objcMsgLogEnabled = false;

static int objcMsgLogFD = -1;

bool logMessageSend(bool isClassMethod,

const char *objectsClass,

const char *implementingClass,

SEL selector)

{

char buf[ 1024 ];

// Create/open the log file

if (objcMsgLogFD == (-1))

{

snprintf (buf, sizeof(buf), "/tmp/msgSends-%d", (int) getpid ());

objcMsgLogFD = secure_open (buf, O_WRONLY | O_CREAT, geteuid());

if (objcMsgLogFD < 0) {

// no log file - disable logging

objcMsgLogEnabled = false;

objcMsgLogFD = -1;

return true;

}

}

// Make the log entry

snprintf(buf, sizeof(buf), "%c %s %s %s\n",

isClassMethod ? '+' : '-',

objectsClass,

implementingClass,

sel_getName(selector));

objcMsgLogLock.lock();

write (objcMsgLogFD, buf, strlen(buf));

objcMsgLogLock.unlock();

// Tell caller to not cache the method

return false;

}

void instrumentObjcMessageSends(BOOL flag)

{

bool enable = flag;

// Shortcut NOP

if (objcMsgLogEnabled == enable)

return;

// If enabling, flush all method caches so we get some traces

if (enable)

_objc_flush_caches(Nil);

// Sync our log file

if (objcMsgLogFD != -1)

fsync (objcMsgLogFD);

objcMsgLogEnabled = enable;

}

#endif

Class _calloc_class(size_t size)

{

return (Class) calloc(1, size);

}

Class class_getSuperclass(Class cls)

{

if (!cls) return nil;

return cls->superclass;

}

BOOL class_isMetaClass(Class cls)

{

if (!cls) return NO;

return cls->isMetaClass();

}

size_t class_getInstanceSize(Class cls)

{

if (!cls) return 0;

return cls->alignedInstanceSize();

}

unsigned int method_getNumberOfArguments(Method m)

{

if (!m) return 0;

return encoding_getNumberOfArguments(method_getTypeEncoding(m));

}

void method_getReturnType(Method m, char *dst, size_t dst_len)

{

encoding_getReturnType(method_getTypeEncoding(m), dst, dst_len);

}

char * method_copyReturnType(Method m)

{

return encoding_copyReturnType(method_getTypeEncoding(m));

}

void method_getArgumentType(Method m, unsigned int index,

char *dst, size_t dst_len)

{

encoding_getArgumentType(method_getTypeEncoding(m),

index, dst, dst_len);

}

char * method_copyArgumentType(Method m, unsigned int index)

{

return encoding_copyArgumentType(method_getTypeEncoding(m), index);

}

_objc_constructOrFree(id bytes, Class cls)

{

assert(cls->hasCxxCtor()); // for performance, not correctness

id obj = object_cxxConstructFromClass(bytes, cls);

if (!obj) free(bytes);

return obj;

}

_class_createInstancesFromZone(Class cls, size_t extraBytes, void *zone,

id *results, unsigned num_requested)

{

unsigned num_allocated;

if (!cls) return 0;