#if __OBJC2__

#include "objc-private.h"

#include "objc-runtime-new.h"

#include "objc-file.h"

#include "objc-cache.h"

#include <Block.h>

#include <objc/message.h>

#include <mach/shared_region.h>

#define newprotocol(p) ((protocol_t *)p)

static void disableTaggedPointers();

static void detach_class(Class cls, bool isMeta);

static void free_class(Class cls);

static Class setSuperclass(Class cls, Class newSuper);

static Class realizeClass(Class cls);

static method_t *getMethodNoSuper_nolock(Class cls, SEL sel);

static method_t *getMethod_nolock(Class cls, SEL sel);

static IMP addMethod(Class cls, SEL name, IMP imp, const char *types, bool replace);

static bool isRRSelector(SEL sel);

static bool isAWZSelector(SEL sel);

static bool methodListImplementsRR(const method_list_t *mlist);

static bool methodListImplementsAWZ(const method_list_t *mlist);

static void updateCustomRR_AWZ(Class cls, method_t *meth);

static method_t *search_method_list(const method_list_t *mlist, SEL sel);

static void flushCaches(Class cls);

#if SUPPORT_FIXUP

static void fixupMessageRef(message_ref_t *msg);

#endif

static bool MetaclassNSObjectAWZSwizzled;

static bool ClassNSObjectRRSwizzled;

rwlock_t runtimeLock;

rwlock_t selLock;

mutex_t cacheUpdateLock;

recursive_mutex_t loadMethodLock;

#if SUPPORT_QOS_HACK

pthread_priority_t BackgroundPriority = 0;

pthread_priority_t MainPriority = 0;

# if DEBUG

static __unused void destroyQOSKey(void *arg) {

_objc_fatal("QoS override level at thread exit is %zu instead of zero",

(size_t)(uintptr_t)arg);

}

# endif

#endif

void lock_init(void)

{

#if SUPPORT_QOS_HACK

BackgroundPriority = _pthread_qos_class_encode(QOS_CLASS_BACKGROUND, 0, 0);

MainPriority = _pthread_qos_class_encode(qos_class_main(), 0, 0);

# if DEBUG

pthread_key_init_np(QOS_KEY, &destroyQOSKey);

# endif

#endif

}

const uintptr_t objc_debug_class_rw_data_mask = FAST_DATA_MASK;

#if SUPPORT_INDEXED_ISA

const uintptr_t objc_debug_indexed_isa_magic_mask = ISA_INDEX_MAGIC_MASK;

const uintptr_t objc_debug_indexed_isa_magic_value = ISA_INDEX_MAGIC_VALUE;

STATIC_ASSERT((ISA_INDEX_MASK & ISA_INDEX_MAGIC_MASK) == 0);

STATIC_ASSERT((~ISA_INDEX_MAGIC_MASK & ISA_INDEX_MAGIC_VALUE) == 0);

const uintptr_t objc_debug_indexed_isa_index_mask = ISA_INDEX_MASK;

const uintptr_t objc_debug_indexed_isa_index_shift = ISA_INDEX_SHIFT;

asm("\n .globl _objc_absolute_indexed_isa_magic_mask" \

"\n _objc_absolute_indexed_isa_magic_mask = " STRINGIFY2(ISA_INDEX_MAGIC_MASK));

asm("\n .globl _objc_absolute_indexed_isa_magic_value" \

"\n _objc_absolute_indexed_isa_magic_value = " STRINGIFY2(ISA_INDEX_MAGIC_VALUE));

asm("\n .globl _objc_absolute_indexed_isa_index_mask" \

"\n _objc_absolute_indexed_isa_index_mask = " STRINGIFY2(ISA_INDEX_MASK));

asm("\n .globl _objc_absolute_indexed_isa_index_shift" \

"\n _objc_absolute_indexed_isa_index_shift = " STRINGIFY2(ISA_INDEX_SHIFT));

uintptr_t objc_indexed_classes_count = 0;

#else

const uintptr_t objc_debug_indexed_isa_magic_mask = 0;

const uintptr_t objc_debug_indexed_isa_magic_value = 0;

const uintptr_t objc_debug_indexed_isa_index_mask = 0;

const uintptr_t objc_debug_indexed_isa_index_shift = 0;

Class objc_indexed_classes[1] = { nil };

uintptr_t objc_indexed_classes_count = 0;

#endif

#if SUPPORT_PACKED_ISA

asm("\n .globl _objc_absolute_packed_isa_class_mask" \

"\n _objc_absolute_packed_isa_class_mask = " STRINGIFY2(ISA_MASK));

const uintptr_t objc_debug_isa_class_mask = ISA_MASK;

const uintptr_t objc_debug_isa_magic_mask = ISA_MAGIC_MASK;

const uintptr_t objc_debug_isa_magic_value = ISA_MAGIC_VALUE;

STATIC_ASSERT((ISA_MASK & ISA_MAGIC_MASK) == 0);

STATIC_ASSERT((~ISA_MAGIC_MASK & ISA_MAGIC_VALUE) == 0);

STATIC_ASSERT((~ISA_MASK & MACH_VM_MAX_ADDRESS) == 0 ||

ISA_MASK + sizeof(void*) == MACH_VM_MAX_ADDRESS);

#else

const uintptr_t objc_debug_isa_class_mask = (~WORD_MASK);

const uintptr_t objc_debug_isa_magic_mask = WORD_MASK;

const uintptr_t objc_debug_isa_magic_value = 0;

#endif

typedef locstamped_category_list_t category_list;

static uint32_t fixed_up_method_list = 3;

static uint32_t fixed_up_protocol = PROTOCOL_FIXED_UP_1;

disableSharedCacheOptimizations(void)

{

fixed_up_method_list = 2;

fixed_up_protocol = PROTOCOL_FIXED_UP_1 | PROTOCOL_FIXED_UP_2;

}

bool method_list_t::isFixedUp() const {

return flags() == fixed_up_method_list;

}

void method_list_t::setFixedUp() {

runtimeLock.assertWriting();

assert(!isFixedUp());

entsizeAndFlags = entsize() | fixed_up_method_list;

}

bool protocol_t::isFixedUp() const {

return (flags & PROTOCOL_FIXED_UP_MASK) == fixed_up_protocol;

}

void protocol_t::setFixedUp() {

runtimeLock.assertWriting();

assert(!isFixedUp());

flags = (flags & ~PROTOCOL_FIXED_UP_MASK) | fixed_up_protocol;

}

method_list_t **method_array_t::endCategoryMethodLists(Class cls)

{

method_list_t **mlists = beginLists();

method_list_t **mlistsEnd = endLists();

if (mlists == mlistsEnd || !cls->data()->ro->baseMethods())

{

// No methods, or no base methods.

// Everything here is a category method.

return mlistsEnd;

}

// Have base methods. Category methods are

// everything except the last method list.

return mlistsEnd - 1;

}

static const char *sel_cname(SEL sel)

{

return (const char *)(void *)sel;

}

static size_t protocol_list_size(const protocol_list_t *plist)

{

return sizeof(protocol_list_t) + plist->count * sizeof(protocol_t *);

}

static void try_free(const void *p)

{

if (p && malloc_size(p)) free((void *)p);

}

static Class

alloc_class_for_subclass(Class supercls, size_t extraBytes)

{

if (!supercls || !supercls->isSwift()) {

return _calloc_class(sizeof(objc_class) + extraBytes);

}

// Superclass is a Swift class. New subclass must duplicate its extra bits.

// Allocate the new class, with space for super's prefix and suffix

// and self's extraBytes.

swift_class_t *swiftSupercls = (swift_class_t *)supercls;

size_t superSize = swiftSupercls->classSize;

void *superBits = swiftSupercls->baseAddress();

void *bits = malloc(superSize + extraBytes);

// Copy all of the superclass's data to the new class.

memcpy(bits, superBits, superSize);

// Erase the objc data and the Swift description in the new class.

swift_class_t *swcls = (swift_class_t *)

((uint8_t *)bits + swiftSupercls->classAddressOffset);

bzero(swcls, sizeof(objc_class));

swcls->description = nil;

// Mark this class as Swift-enhanced.

swcls->bits.setIsSwift();

return (Class)swcls;

}

void *object_getIndexedIvars(id obj)

{

uint8_t *base = (uint8_t *)obj;

if (!obj) return nil;

if (obj->isTaggedPointer()) return nil;

if (!obj->isClass()) return base + obj->ISA()->alignedInstanceSize();

Class cls = (Class)obj;

if (!cls->isSwift()) return base + sizeof(objc_class);

swift_class_t *swcls = (swift_class_t *)cls;

return base - swcls->classAddressOffset + word_align(swcls->classSize);

}

static class_ro_t *make_ro_writeable(class_rw_t *rw)

{

runtimeLock.assertWriting();

if (rw->flags & RW_COPIED_RO) {

// already writeable, do nothing

} else {

class_ro_t *ro = (class_ro_t *)

memdup(rw->ro, sizeof(*rw->ro));

rw->ro = ro;

rw->flags |= RW_COPIED_RO;

}

return (class_ro_t *)rw->ro;

}

static NXMapTable *unattachedCategories(void)

{

runtimeLock.assertWriting();

static NXMapTable *category_map = nil;

if (category_map) return category_map;

// fixme initial map size

category_map = NXCreateMapTable(NXPtrValueMapPrototype, 16);

return category_map;

}

static void addUnattachedCategoryForClass(category_t *cat, Class cls,

header_info *catHeader)

{

runtimeLock.assertWriting();

// DO NOT use cat->cls! cls may be cat->cls->isa instead

NXMapTable *cats = unattachedCategories();

category_list *list;

list = (category_list *)NXMapGet(cats, cls);

if (!list) {

list = (category_list *)

calloc(sizeof(*list) + sizeof(list->list[0]), 1);

} else {

list = (category_list *)

realloc(list, sizeof(*list) + sizeof(list->list[0]) * (list->count + 1));

}

list->list[list->count++] = (locstamped_category_t){cat, catHeader};

NXMapInsert(cats, cls, list);

}

static void removeUnattachedCategoryForClass(category_t *cat, Class cls)

{

runtimeLock.assertWriting();

// DO NOT use cat->cls! cls may be cat->cls->isa instead

NXMapTable *cats = unattachedCategories();

category_list *list;

list = (category_list *)NXMapGet(cats, cls);

if (!list) return;

uint32_t i;

for (i = 0; i < list->count; i++) {

if (list->list[i].cat == cat) {

// shift entries to preserve list order

memmove(&list->list[i], &list->list[i+1],

(list->count-i-1) * sizeof(list->list[i]));

list->count--;

return;

}

}

}

static category_list *

unattachedCategoriesForClass(Class cls, bool realizing)

{

runtimeLock.assertWriting();

return (category_list *)NXMapRemove(unattachedCategories(), cls);

}

static void removeAllUnattachedCategoriesForClass(Class cls)

{

runtimeLock.assertWriting();

void *list = NXMapRemove(unattachedCategories(), cls);

if (list) free(list);

}

static Class classNSObject(void)

{

extern objc_class OBJC_CLASS_$_NSObject;

return (Class)&OBJC_CLASS_$_NSObject;

}

static void printReplacements(Class cls, category_list *cats)

{

uint32_t c;

bool isMeta = cls->isMetaClass();

if (!cats) return;

// Newest categories are LAST in cats

// Later categories override earlier ones.

for (c = 0; c < cats->count; c++) {

category_t *cat = cats->list[c].cat;

method_list_t *mlist = cat->methodsForMeta(isMeta);

if (!mlist) continue;

for (const auto& meth : *mlist) {

SEL s = sel_registerName(sel_cname(meth.name));

// Search for replaced methods in method lookup order.

// Complain about the first duplicate only.

// Look for method in earlier categories

for (uint32_t c2 = 0; c2 < c; c2++) {

category_t *cat2 = cats->list[c2].cat;

const method_list_t *mlist2 = cat2->methodsForMeta(isMeta);

if (!mlist2) continue;

for (const auto& meth2 : *mlist2) {

SEL s2 = sel_registerName(sel_cname(meth2.name));

if (s == s2) {

logReplacedMethod(cls->nameForLogging(), s,

cls->isMetaClass(), cat->name,

meth2.imp, meth.imp);

goto complained;

}

}

}

// Look for method in cls

for (const auto& meth2 : cls->data()->methods) {

SEL s2 = sel_registerName(sel_cname(meth2.name));

if (s == s2) {

logReplacedMethod(cls->nameForLogging(), s,

cls->isMetaClass(), cat->name,

meth2.imp, meth.imp);

goto complained;

}

}

complained:

;

}

}

}

static bool isBundleClass(Class cls)

{

return cls->data()->ro->flags & RO_FROM_BUNDLE;

}

static void

fixupMethodList(method_list_t *mlist, bool bundleCopy, bool sort)

{

runtimeLock.assertWriting();

assert(!mlist->isFixedUp());

// fixme lock less in attachMethodLists ?

sel_lock();

// Unique selectors in list.

for (auto& meth : *mlist) {

const char *name = sel_cname(meth.name);

meth.name = sel_registerNameNoLock(name, bundleCopy);

}

sel_unlock();

// Sort by selector address.

if (sort) {

method_t::SortBySELAddress sorter;

std::stable_sort(mlist->begin(), mlist->end(), sorter);

}

// Mark method list as uniqued and sorted

mlist->setFixedUp();

}

static void

prepareMethodLists(Class cls, method_list_t **addedLists, int addedCount,

bool baseMethods, bool methodsFromBundle)

{

runtimeLock.assertWriting();

if (addedCount == 0) return;

// Don't scan redundantly

bool scanForCustomRR = !cls->hasCustomRR();

bool scanForCustomAWZ = !cls->hasCustomAWZ();

// There exist RR/AWZ special cases for some class's base methods.

// But this code should never need to scan base methods for RR/AWZ:

// default RR/AWZ cannot be set before setInitialized().

// Therefore we need not handle any special cases here.

if (baseMethods) {

assert(!scanForCustomRR && !scanForCustomAWZ);

}

// Add method lists to array.

// Reallocate un-fixed method lists.

// The new methods are PREPENDED to the method list array.

for (int i = 0; i < addedCount; i++) {

method_list_t *mlist = addedLists[i];

assert(mlist);

// Fixup selectors if necessary

if (!mlist->isFixedUp()) {

fixupMethodList(mlist, methodsFromBundle, true/*sort*/);

}

// Scan for method implementations tracked by the class's flags

if (scanForCustomRR && methodListImplementsRR(mlist)) {

cls->setHasCustomRR();

scanForCustomRR = false;

}

if (scanForCustomAWZ && methodListImplementsAWZ(mlist)) {

cls->setHasCustomAWZ();

scanForCustomAWZ = false;

}

}

}

static void

attachCategories(Class cls, category_list *cats, bool flush_caches)

{

if (!cats) return;

if (PrintReplacedMethods) printReplacements(cls, cats);

bool isMeta = cls->isMetaClass();

// fixme rearrange to remove these intermediate allocations

method_list_t **mlists = (method_list_t **)

malloc(cats->count * sizeof(*mlists));

property_list_t **proplists = (property_list_t **)

malloc(cats->count * sizeof(*proplists));

protocol_list_t **protolists = (protocol_list_t **)

malloc(cats->count * sizeof(*protolists));

// Count backwards through cats to get newest categories first

int mcount = 0;

int propcount = 0;

int protocount = 0;

int i = cats->count;

bool fromBundle = NO;

while (i--) {

auto& entry = cats->list[i];

method_list_t *mlist = entry.cat->methodsForMeta(isMeta);

if (mlist) {

mlists[mcount++] = mlist;

fromBundle |= entry.hi->isBundle();

}

property_list_t *proplist =

entry.cat->propertiesForMeta(isMeta, entry.hi);

if (proplist) {

proplists[propcount++] = proplist;

}

protocol_list_t *protolist = entry.cat->protocols;

if (protolist) {

protolists[protocount++] = protolist;

}

}

//⚠️获取到class_rw_t结构 将分类中方法/属性/协议信息添加到类信息结构中

auto rw = cls->data();

prepareMethodLists(cls, mlists, mcount, NO, fromBundle);

//⚠️搜索void attachLists(List* const * addedLists, uint32_t addedCount)

rw->methods.attachLists(mlists, mcount);

free(mlists);

if (flush_caches && mcount > 0) flushCaches(cls);

rw->properties.attachLists(proplists, propcount);

free(proplists);

rw->protocols.attachLists(protolists, protocount);

free(protolists);

}

static void methodizeClass(Class cls)

{

runtimeLock.assertWriting();

bool isMeta = cls->isMetaClass();

auto rw = cls->data();

auto ro = rw->ro;

// Methodizing for the first time

if (PrintConnecting) {

_objc_inform("CLASS: methodizing class '%s' %s",

cls->nameForLogging(), isMeta ? "(meta)" : "");

}

// Install methods and properties that the class implements itself.

method_list_t *list = ro->baseMethods();

if (list) {

prepareMethodLists(cls, &list, 1, YES, isBundleClass(cls));

rw->methods.attachLists(&list, 1);

}

property_list_t *proplist = ro->baseProperties;

if (proplist) {

rw->properties.attachLists(&proplist, 1);

}

protocol_list_t *protolist = ro->baseProtocols;

if (protolist) {

rw->protocols.attachLists(&protolist, 1);

}

// Root classes get bonus method implementations if they don't have

// them already. These apply before category replacements.

if (cls->isRootMetaclass()) {

// root metaclass

addMethod(cls, SEL_initialize, (IMP)&objc_noop_imp, "", NO);

}

// Attach categories.

category_list *cats = unattachedCategoriesForClass(cls, true /*realizing*/);

attachCategories(cls, cats, false /*don't flush caches*/);

if (PrintConnecting) {

if (cats) {

for (uint32_t i = 0; i < cats->count; i++) {

_objc_inform("CLASS: attached category %c%s(%s)",

isMeta ? '+' : '-',

cls->nameForLogging(), cats->list[i].cat->name);

}

}

}

if (cats) free(cats);

#if DEBUG

// Debug: sanity-check all SELs; log method list contents

for (const auto& meth : rw->methods) {

if (PrintConnecting) {

_objc_inform("METHOD %c[%s %s]", isMeta ? '+' : '-',

cls->nameForLogging(), sel_getName(meth.name));

}

assert(sel_registerName(sel_getName(meth.name)) == meth.name);

}

#endif

}

static void remethodizeClass(Class cls)

{

category_list *cats;

bool isMeta;

runtimeLock.assertWriting();

isMeta = cls->isMetaClass();

// Re-methodizing: check for more categories

if ((cats = unattachedCategoriesForClass(cls, false/*not realizing*/))) {

if (PrintConnecting) {

_objc_inform("CLASS: attaching categories to class '%s' %s",

cls->nameForLogging(), isMeta ? "(meta)" : "");

}

//⚠️：将分类信息添加到类信息中

attachCategories(cls, cats, true /*flush caches*/);

free(cats);

}

}

static NXMapTable *nonmeta_class_map = nil;

static NXMapTable *nonMetaClasses(void)

{

runtimeLock.assertLocked();

if (nonmeta_class_map) return nonmeta_class_map;

// nonmeta_class_map is typically small

INIT_ONCE_PTR(nonmeta_class_map,

NXCreateMapTable(NXPtrValueMapPrototype, 32),

NXFreeMapTable(v));

return nonmeta_class_map;

}

static void addNonMetaClass(Class cls)

{

runtimeLock.assertWriting();

void *old;

old = NXMapInsert(nonMetaClasses(), cls->ISA(), cls);

assert(!cls->isMetaClass());

assert(cls->ISA()->isMetaClass());

assert(!old);

}

static void removeNonMetaClass(Class cls)

{

runtimeLock.assertWriting();

NXMapRemove(nonMetaClasses(), cls->ISA());

}

static bool scanMangledField(const char *&string, const char *end,

const char *&field, int& length)

{

// Leading zero not allowed.

if (*string == '0') return false;

length = 0;

field = string;

while (field < end) {

char c = *field;

if (!isdigit(c)) break;

field++;

if (__builtin_smul_overflow(length, 10, &length)) return false;

if (__builtin_sadd_overflow(length, c - '0', &length)) return false;

}

string = field + length;

return length > 0 && string <= end;

}

static char *copySwiftV1DemangledName(const char *string, bool isProtocol = false)

{

if (!string) return nil;

// Swift mangling prefix.

if (strncmp(string, isProtocol ? "_TtP" : "_TtC", 4) != 0) return nil;

string += 4;

const char *end = string + strlen(string);

// Module name.

const char *prefix;

int prefixLength;

if (string[0] == 's') {

// "s" is the Swift module.

prefix = "Swift";

prefixLength = 5;

string += 1;

} else {

if (! scanMangledField(string, end, prefix, prefixLength)) return nil;

}

// Class or protocol name.

const char *suffix;

int suffixLength;

if (! scanMangledField(string, end, suffix, suffixLength)) return nil;

if (isProtocol) {

// Remainder must be "_".

if (strcmp(string, "_") != 0) return nil;

} else {

// Remainder must be empty.

if (string != end) return nil;

}

char *result;

asprintf(&result, "%.*s.%.*s", prefixLength,prefix, suffixLength,suffix);

return result;

}

static char *copySwiftV1MangledName(const char *string, bool isProtocol = false)

{

if (!string) return nil;

size_t dotCount = 0;

size_t dotIndex;

const char *s;

for (s = string; *s; s++) {

if (*s == '.') {

dotCount++;

dotIndex = s - string;

}

}

size_t stringLength = s - string;

if (dotCount != 1 || dotIndex == 0 || dotIndex >= stringLength-1) {

return nil;

}

const char *prefix = string;

size_t prefixLength = dotIndex;

const char *suffix = string + dotIndex + 1;

size_t suffixLength = stringLength - (dotIndex + 1);

char *name;

if (prefixLength == 5 && memcmp(prefix, "Swift", 5) == 0) {

asprintf(&name, "_Tt%cs%zu%.*s%s",

isProtocol ? 'P' : 'C',

suffixLength, (int)suffixLength, suffix,

isProtocol ? "_" : "");

} else {

asprintf(&name, "_Tt%c%zu%.*s%zu%.*s%s",

isProtocol ? 'P' : 'C',

prefixLength, (int)prefixLength, prefix,

suffixLength, (int)suffixLength, suffix,

isProtocol ? "_" : "");

}

return name;

}

NXMapTable *gdb_objc_realized_classes; // exported for debuggers in objc-gdb.h

static Class getClass_impl(const char *name)

{

runtimeLock.assertLocked();

// allocated in _read_images

assert(gdb_objc_realized_classes);

// Try runtime-allocated table

Class result = (Class)NXMapGet(gdb_objc_realized_classes, name);

if (result) return result;

// Try table from dyld shared cache

return getPreoptimizedClass(name);

}

static Class getClass(const char *name)

{

runtimeLock.assertLocked();

// Try name as-is

Class result = getClass_impl(name);

if (result) return result;

// Try Swift-mangled equivalent of the given name.

if (char *swName = copySwiftV1MangledName(name)) {

result = getClass_impl(swName);

free(swName);

return result;

}

return nil;

}