Lines Matching refs:cls
42 static void detach_class(Class cls, BOOL isMeta);
43 static void free_class(Class cls);
44 static Class setSuperclass(Class cls, Class newSuper);
45 static Class realizeClass(Class cls);
46 static method_t *getMethodNoSuper_nolock(Class cls, SEL sel);
47 static method_t *getMethod_nolock(Class cls, SEL sel);
49 static IMP addMethod(Class cls, SEL name, IMP imp, const char *types, BOOL replace);
55 static void updateCustomRR_AWZ(Class cls, method_t *meth);
367 Class cls = (Class)obj;
368 if (!cls->isSwift()) return base + sizeof(objc_class);
370 swift_class_t *swcls = (swift_class_t *)cls;
422 static void addUnattachedCategoryForClass(category_t *cat, Class cls,
429 // DO NOT use cat->cls! cls may be cat->cls->isa instead
433 list = (category_list *)NXMapGet(cats, cls);
442 NXMapInsert(cats, cls, list);
451 static void removeUnattachedCategoryForClass(category_t *cat, Class cls)
455 // DO NOT use cat->cls! cls may be cat->cls->isa instead
459 list = (category_list *)NXMapGet(cats, cls);
482 static category_list *unattachedCategoriesForClass(Class cls)
485 return (category_list *)NXMapRemove(unattachedCategories(), cls);
504 * Warn about methods from cats that override other methods in cats or cls.
505 * Assumes no methods from cats have been added to cls yet.
507 static void printReplacements(Class cls, category_list *cats)
510 BOOL isMeta = cls->isMetaClass();
540 // Look for method in cls
541 FOREACH_METHOD_LIST(mlist, cls, {
554 logReplacedMethod(cls->nameForLogging(), s,
555 cls->isMetaClass(), cat->name,
563 static BOOL isBundleClass(Class cls)
565 return (cls->data()->ro->flags & RO_FROM_BUNDLE) ? YES : NO;
612 attachMethodLists(Class cls, method_list_t **addedLists, int addedCount,
619 bool scanForCustomRR = !UseGC && !cls->hasCustomRR();
620 bool scanForCustomAWZ = !UseGC && !cls->hasCustomAWZ();
636 if (cls->data()->flags & RW_METHOD_ARRAY) {
637 oldLists = cls->data()->method_lists;
639 oldBuf[0] = cls->data()->method_list;
678 cls->setHasCustomRR();
682 cls->setHasCustomAWZ();
688 cache_eraseMethods(cls, mlist);
706 cls->data()->method_lists = newLists;
707 cls->setInfo(RW_METHOD_ARRAY);
710 cls->data()->method_list = newLists[0];
711 assert(!(cls->data()->flags & RW_METHOD_ARRAY));
716 attachCategoryMethods(Class cls, category_list *cats, bool flushCaches)
719 if (PrintReplacedMethods) printReplacements(cls, cats);
721 bool isMeta = cls->isMetaClass();
737 attachMethodLists(cls, mlists, mcount, NO, fromBundle, flushCaches);
862 * Fixes up cls's method list, protocol list, and property list.
866 static void methodizeClass(Class cls)
873 isMeta = cls->isMetaClass();
878 cls->nameForLogging(), isMeta ? "(meta)" : "");
884 attachMethodLists(cls, (method_list_t **)&cls->data()->ro->baseMethods, 1,
885 YES, isBundleClass(cls), NO);
890 if (cls->isRootMetaclass()) {
892 addMethod(cls, SEL_initialize, (IMP)&objc_noop_imp, "", NO);
895 cats = unattachedCategoriesForClass(cls);
896 attachCategoryMethods(cls, cats, NO);
898 if (cats || cls->data()->ro->baseProperties) {
899 cls->data()->properties =
900 buildPropertyList(cls->data()->ro->baseProperties, cats, isMeta);
903 if (cats || cls->data()->ro->baseProtocols) {
904 cls->data()->protocols =
905 buildProtocolList(cats, cls->data()->ro->baseProtocols, nil);
914 cls->nameForLogging(), cats->list[i].cat->name);
923 FOREACH_METHOD_LIST(mlist, cls, {
929 cls->nameForLogging(), sel_getName(iter->name));
941 * Fixes up cls's method list, protocol list, and property list.
942 * Updates method caches for cls and its subclasses.
945 static void remethodizeClass(Class cls)
952 isMeta = cls->isMetaClass();
955 if ((cats = unattachedCategoriesForClass(cls))) {
961 cls->nameForLogging(), isMeta ? "(meta)" : "");
966 attachCategoryMethods(cls, cats, YES);
970 newproperties->next = cls->data()->properties;
971 cls->data()->properties = newproperties;
974 newprotos = buildProtocolList(cats, nil, cls->data()->protocols);
975 if (cls->data()->protocols && cls->data()->protocols != newprotos) {
976 _free_internal(cls->data()->protocols);
978 cls->data()->protocols = newprotos;
1018 * Adds metacls => cls to the secondary metaclass map
1021 static void addNonMetaClass(Class cls)
1025 old = NXMapInsert(nonMetaClasses(), cls->ISA(), cls);
1027 assert(!cls->isMetaClass());
1028 assert(cls->ISA()->isMetaClass());
1033 static void removeNonMetaClass(Class cls)
1036 NXMapRemove(nonMetaClasses(), cls->ISA());
1202 * Adds name => cls to the named non-meta class map.
1206 static void addNamedClass(Class cls, const char *name)
1211 inform_duplicate(name, old, cls);
1215 addNonMetaClass(cls);
1217 NXMapInsert(gdb_objc_realized_classes, name, cls);
1219 assert(!(cls->data()->flags & RO_META));
1222 // assert(!cls->isRealized());
1228 * Removes cls from the name => cls map.
1231 static void removeNamedClass(Class cls, const char *name)
1234 assert(!(cls->data()->flags & RO_META));
1235 if (cls == NXMapGet(gdb_objc_realized_classes, name)) {
1238 // cls has a name collision with another class - don't remove the other
1239 // but do remove cls from the secondary metaclass->class map.
1240 removeNonMetaClass(cls);
1282 * Adds cls to the realized non-meta class hash.
1285 static void addRealizedClass(Class cls)
1289 old = NXHashInsert(realizedClasses(), cls);
1290 objc_addRegisteredClass(cls);
1291 assert(!cls->isMetaClass());
1298 * Removes cls from the realized non-meta class hash.
1301 static void removeRealizedClass(Class cls)
1304 if (cls->isRealized()) {
1305 assert(!cls->isMetaClass());
1306 NXHashRemove(realizedClasses(), cls);
1307 objc_removeRegisteredClass(cls);
1314 * Adds cls to the realized metaclass hash.
1317 static void addRealizedMetaclass(Class cls)
1321 old = NXHashInsert(realizedMetaclasses(), cls);
1322 assert(cls->isMetaClass());
1329 * Removes cls from the realized metaclass hash.
1332 static void removeRealizedMetaclass(Class cls)
1335 if (cls->isRealized()) {
1336 assert(cls->isMetaClass());
1337 NXHashRemove(realizedMetaclasses(), cls);
1366 * Installs cls as the class structure to use for the named class if it appears.
1369 static void addFutureNamedClass(const char *name, Class cls)
1376 _objc_inform("FUTURE: reserving %p for %s", (void*)cls, name);
1383 cls->setData(rw);
1384 cls->data()->flags = RO_FUTURE;
1386 old = NXMapKeyCopyingInsert(futureNamedClasses(), name, cls);
1467 * Returns the live class pointer for cls, which may be pointing to
1469 * Returns nil if cls is ignored because of weak linking.
1472 static Class remapClass(Class cls)
1478 if (!cls) return nil;
1480 if (NXMapMember(remappedClasses(YES), cls, (void**)&c2) == NX_MAPNOTAKEY) {
1481 return cls;
1487 static Class remapClass(classref_t cls)
1489 return remapClass((Class)cls);
1492 Class _class_remap(Class cls)
1495 Class result = remapClass(cls);
1518 * `inst` is an instance of `cls` or a subclass thereof, or nil.
1532 // return cls itself if it's already a non-meta class
1540 Class cls = metacls->superclass;
1541 assert(cls->isRealized());
1542 assert(!cls->isMetaClass());
1543 assert(cls->ISA() == metacls);
1544 if (cls->ISA() == metacls) return cls;
1549 Class cls = (Class)inst;
1550 realizeClass(cls);
1551 // cls may be a subclass - find the real class for metacls
1552 while (cls && cls->ISA() != metacls) {
1553 cls = cls->superclass;
1554 realizeClass(cls);
1556 if (cls) {
1557 assert(!cls->isMetaClass());
1558 assert(cls->ISA() == metacls);
1559 return cls;
1562 _objc_fatal("cls is not an instance of metacls");
1570 Class cls = getClass(metacls->mangledName());
1571 if (cls->ISA() == metacls) {
1579 realizeClass(cls);
1580 return cls;
1586 Class cls = (Class)NXMapGet(nonMetaClasses(), metacls);
1587 if (cls) {
1595 assert(cls->ISA() == metacls);
1596 realizeClass(cls);
1597 return cls;
1603 Class cls = nil;
1610 cls = classes[i];
1617 if (cls) {
1625 realizeClass(cls);
1626 return cls;
1640 Class _class_getNonMetaClass(Class cls, id obj)
1643 cls = getNonMetaClass(cls, obj);
1644 assert(cls->isRealized());
1647 return cls;
1875 static ivar_t *getIvar(Class cls, const char *name)
1880 assert(cls->isRealized());
1881 if ((ivars = cls->data()->ro->ivars)) {
1898 static void reconcileInstanceVariables(Class cls, Class supercls, const class_ro_t*& ro)
1900 class_rw_t *rw = cls->data();
1903 assert(!cls->isMetaClass());
1938 const char *clsname = cls->mangledName();
1969 cls->nameForLogging(), (size_t)oldStart,
2022 "disregarding ivar layout", cls->nameForLogging());
2048 cls->nameForLogging(), ro->instanceStart,
2056 gdb_objc_class_changed(cls, OBJC_CLASS_IVARS_CHANGED, ro->name);
2084 cls->nameForLogging());
2104 * Performs first-time initialization on class cls,
2109 static Class realizeClass(Class cls)
2119 if (!cls) return nil;
2120 if (cls->isRealized()) return cls;
2121 assert(cls == remapClass(cls));
2125 ro = (const class_ro_t *)cls->data();
2128 rw = cls->data();
2129 ro = cls->data()->ro;
2130 cls->changeInfo(RW_REALIZED|RW_REALIZING, RW_FUTURE);
2136 cls->setData(rw);
2145 cls->nameForLogging(), isMeta ? "(meta)" : "",
2146 (void*)cls, ro);
2151 supercls = realizeClass(remapClass(cls->superclass));
2152 metacls = realizeClass(remapClass(cls->ISA()));
2155 cls->superclass = supercls;
2156 cls->initClassIsa(metacls);
2160 if (supercls && !isMeta) reconcileInstanceVariables(cls, supercls, ro);
2163 cls->setInstanceSize(ro->instanceSize);
2167 cls->setHasCxxDtor();
2169 cls->setHasCxxCtor();
2192 cls->setRequiresRawIsa(false/*inherited*/);
2199 addSubclass(supercls, cls);
2203 methodizeClass(cls);
2206 addRealizedClass(cls);
2208 addRealizedMetaclass(cls);
2211 return cls;
2217 * Return YES if some superclass of cls was weak-linked and is missing.
2220 missingWeakSuperclass(Class cls)
2222 assert(!cls->isRealized());
2224 if (!cls->superclass) {
2226 return (!(cls->data()->flags & RO_ROOT));
2229 Class supercls = remapClass(cls->superclass);
2230 assert(cls != cls->superclass);
2231 assert(cls != supercls);
2290 Class cls;
2293 if ((cls = (Class)NXMapGet(future_named_class_map, name))) {
2296 return cls;
2299 cls = _calloc_class(sizeof(objc_class));
2300 addFutureNamedClass(name, cls);
2303 return cls;
2316 Class cls;
2320 cls = look_up_class(name, YES, NO);
2321 if (cls) {
2324 (void*)cls, name);
2327 return cls;
2340 void objc_setFutureClass(Class cls, const char *name)
2346 BOOL _class_isFutureClass(Class cls)
2348 return cls && cls->isFuture();
2355 * (Historical behavior: flush caches for cls, its metaclass,
2359 static void flushCaches(Class cls)
2365 if (cls) {
2366 foreach_realized_class_and_subclass(cls, ^(Class c){
2370 if (!cls->superclass) {
2373 foreach_realized_class_and_subclass(cls->ISA(), ^(Class c){
2396 static void flushImps(Class cls, SEL sel1, IMP imp1, SEL sel2, IMP imp2)
2402 if (cls) {
2403 foreach_realized_class_and_subclass(cls, ^(Class c){
2408 if (!cls->superclass) {
2411 foreach_realized_class_and_subclass(cls->ISA(), ^(Class c){
2437 void _objc_flush_caches(Class cls)
2440 flushCaches(cls);
2443 if (!cls) {
2444 // collectALot if cls==nil
2530 * - cls
2531 * - nil (cls has a missing weak-linked superclass)
2541 Class readClass(Class cls, bool headerIsBundle, bool headerInSharedCache)
2543 const char *mangledName = cls->mangledName();
2545 if (missingWeakSuperclass(cls)) {
2551 cls->nameForLogging());
2553 addRemappedClass(cls, nil);
2554 cls->superclass = nil;
2568 if (cls->cache._mask) cls->cache._mask = 0;
2569 if (cls->cache._occupied) cls->cache._occupied = 0;
2570 if (cls->ISA()->cache._mask) cls->ISA()->cache._mask = 0;
2571 if (cls->ISA()->cache._occupied) cls->ISA()->cache._occupied = 0;
2588 cls->nameForLogging());
2593 memcpy(newCls, cls, sizeof(objc_class));
2599 addRemappedClass(cls, newCls);
2601 cls = newCls;
2609 // assert(cls == getClass(name));
2613 addNamedClass(cls, mangledName);
2618 cls->data()->flags |= RO_FROM_BUNDLE;
2619 cls->ISA()->data()->flags |= RO_FROM_BUNDLE;
2624 if ((mlist = ((class_ro_t *)cls->data())->baseMethods)) {
2628 if ((mlist = ((class_ro_t *)cls->ISA()->data())->baseMethods)) {
2634 return cls;
2739 Class cls = (Class)classlist[i];
2740 Class newCls = readClass(cls, headerIsBundle, headerInSharedCache);
2742 if (newCls != cls && newCls) {
2829 Class cls = (Class)&OBJC_CLASS_$_Protocol;
2830 assert(cls);
2844 newproto->initIsa(cls); // fixme pinned
2872 Class cls = remapClass(classlist[i]);
2873 if (!cls) continue;
2877 if (cls->cache._buckets == (void*)&_objc_empty_cache &&
2878 (cls->cache._mask || cls->cache._occupied))
2880 cls->cache._mask = 0;
2881 cls->cache._occupied = 0;
2883 if (cls->ISA()->cache._buckets == (void*)&_objc_empty_cache &&
2884 (cls->ISA()->cache._mask || cls->ISA()->cache._occupied))
2886 cls->ISA()->cache._mask = 0;
2887 cls->ISA()->cache._occupied = 0;
2891 realizeClass(cls);
2910 Class cls = remapClass(cat->cls);
2912 if (!cls) {
2932 addUnattachedCategoryForClass(cat, cls, hi);
2933 if (cls->isRealized()) {
2934 remethodizeClass(cls);
2939 cls->nameForLogging(), cat->name,
2947 addUnattachedCategoryForClass(cat, cls->ISA(), hi);
2948 if (cls->ISA()->isRealized()) {
2949 remethodizeClass(cls->ISA());
2953 cls->nameForLogging(), cat->name);
2978 // Recursively schedule +load for cls and any un-+load-ed superclasses.
2979 // cls must already be connected.
2980 static void schedule_class_load(Class cls)
2982 if (!cls) return;
2983 assert(cls->isRealized()); // _read_images should realize
2985 if (cls->data()->flags & RW_LOADED) return;
2988 schedule_class_load(cls->superclass);
2990 add_class_to_loadable_list(cls);
2991 cls->setInfo(RW_LOADED);
3009 Class cls = remapClass(cat->cls);
3010 if (!cls) continue; // category for ignored weak-linked class
3011 realizeClass(cls);
3012 assert(cls->ISA()->isRealized());
3036 Class cls = remapClass(cat->cls);
3037 assert(cls); // shouldn't have live category for dead class
3042 removeUnattachedCategoryForClass(cat, cls);
3056 Class cls = remapClass(classlist[i]);
3057 if (cls) {
3058 remove_class_from_loadable_list(cls);
3059 detach_class(cls->ISA(), YES);
3060 detach_class(cls, NO);
3065 Class cls = remapClass(classlist[i]);
3066 if (cls) {
3067 free_class(cls->ISA());
3068 free_class(cls);
3148 _method_setImplementation(Class cls, method_t *m, IMP imp)
3163 // Class-side cache updates are slow if cls is nil (i.e. unknown)
3164 // RR/AWZ updates are slow if cls is nil (i.e. unknown)
3170 flushImps(cls, m->name, old, nil, nil);
3173 updateCustomRR_AWZ(cls, m);
3921 Class cls = (Class)&OBJC_CLASS_$___IncompleteProtocol;
3922 result->initProtocolIsa(cls);
3950 Class cls = (Class)&OBJC_CLASS_$_Protocol;
3952 if (proto->ISA() == cls) {
3965 proto->initProtocolIsa(cls);
3987 Class cls = (Class)&OBJC_CLASS_$___IncompleteProtocol;
3994 if (proto->ISA() != cls) {
4000 if (addition->ISA() == cls) {
4057 Class cls = (Class)&OBJC_CLASS_$___IncompleteProtocol;
4063 if (proto->ISA() != cls) {
4118 Class cls = (Class)&OBJC_CLASS_$___IncompleteProtocol;
4125 if (proto->ISA() != cls) {
4161 Class cls;
4174 NXNextHashState(classes, &state, (void **)&cls))
4176 buffer[count++] = cls;
4207 Class cls;
4211 while (NXNextHashState(classes, &state, (void **)&cls)) {
4212 result[count++] = cls;
4288 class_copyMethodList(Class cls, unsigned int *outCount)
4293 if (!cls) {
4300 assert(cls->isRealized());
4302 FOREACH_METHOD_LIST(mlist, cls, {
4311 FOREACH_METHOD_LIST(mlist, cls, {
4338 class_copyIvarList(Class cls, unsigned int *outCount)
4345 if (!cls) {
4352 assert(cls->isRealized());
4354 if ((ivars = cls->data()->ro->ivars) && ivars->count) {
4380 class_copyPropertyList(Class cls, unsigned int *outCount)
4386 if (!cls) {
4393 assert(cls->isRealized());
4395 for (plist = cls->data()->properties; plist; plist = plist->next) {
4404 for (plist = cls->data()->properties; plist; plist = plist->next) {
4477 return remapClass(cat->cls)->nameForLogging();
4491 Class result = remapClass(cat->cls);
4533 class_copyProtocolList(Class cls, unsigned int *outCount)
4541 if (!cls) {
4548 assert(cls->isRealized());
4550 for (p = cls->data()->protocols; p && *p; p++) {
4557 for (p = cls->data()->protocols; p && *p; p++) {
4592 Class cls = remapClass(classlist[i]);
4593 if (cls) {
4594 names[i-shift] = cls->demangledName(true/*realize*/);
4617 alignedInstanceStart(Class cls)
4619 assert(cls);
4620 assert(cls->isRealized());
4621 return (uint32_t)word_align(cls->data()->ro->instanceStart);
4624 uint32_t _class_getInstanceStart(Class cls) {
4625 return alignedInstanceStart(cls);
4730 const char *class_getName(Class cls)
4732 if (!cls) return "nil";
4733 assert(cls->isRealized() || cls->isFuture());
4734 return cls->demangledName();
4744 class_getVersion(Class cls)
4746 if (!cls) return 0;
4747 assert(cls->isRealized());
4748 return cls->data()->version;
4758 class_setVersion(Class cls, int version)
4760 if (!cls) return;
4761 assert(cls->isRealized());
4762 cls->data()->version = version;
4836 getMethodNoSuper_nolock(Class cls, SEL sel)
4840 assert(cls->isRealized());
4841 // fixme nil cls?
4844 FOREACH_METHOD_LIST(mlist, cls, {
4859 getMethod_nolock(Class cls, SEL sel)
4865 // fixme nil cls?
4868 assert(cls->isRealized());
4870 while (cls && ((m = getMethodNoSuper_nolock(cls, sel))) == nil) {
4871 cls = cls->superclass;
4883 static Method _class_getMethod(Class cls, SEL sel)
4887 m = getMethod_nolock(cls, sel);
4897 Method class_getInstanceMethod(Class cls, SEL sel)
4899 if (!cls || !sel) return nil;
4909 lookUpImpOrNil(cls, sel, nil,
4914 return _class_getMethod(cls, sel);
4921 * cls is the method whose cache should be filled.
4925 log_and_fill_cache(Class cls, Class implementer, IMP imp, SEL sel)
4930 cls->nameForLogging(),
4936 cache_fill (cls, sel, imp);
4946 IMP _class_lookupMethodAndLoadCache3(id obj, SEL sel, Class cls)
4948 return lookUpImpOrForward(cls, sel, obj,
4959 * inst is an instance of cls or a subclass thereof, or nil if none is known.
4960 * If cls is an un-initialized metaclass then a non-nil inst is faster.
4965 IMP lookUpImpOrForward(Class cls, SEL sel, id inst,
4977 imp = cache_getImp(cls, sel);
4981 if (!cls->isRealized()) {
4983 realizeClass(cls);
4987 if (initialize && !cls->isInitialized()) {
4988 _class_initialize (_class_getNonMetaClass(cls, inst));
5005 cache_fill(cls, sel, imp);
5011 imp = cache_getImp(cls, sel);
5016 meth = getMethodNoSuper_nolock(cls, sel);
5018 log_and_fill_cache(cls, cls, meth->imp, sel);
5025 curClass = cls;
5032 log_and_fill_cache(cls, curClass, imp, sel);
5046 log_and_fill_cache(cls, curClass, meth->imp, sel);
5056 _class_resolveMethod(cls, sel, inst);
5067 cache_fill(cls, sel, imp);
5086 IMP lookUpImpOrNil(Class cls, SEL sel, id inst,
5089 IMP imp = lookUpImpOrForward(cls, sel, inst, initialize, cache, resolver);
5100 IMP lookupMethodInClassAndLoadCache(Class cls, SEL sel)
5110 imp = cache_getImp(cls, sel);
5117 meth = getMethodNoSuper_nolock(cls, sel);
5121 cache_fill(cls, sel, meth->imp);
5126 cache_fill(cls, sel, _objc_msgForward_impcache);
5138 objc_property_t class_getProperty(Class cls, const char *name)
5143 if (!cls || !name) return nil;
5147 assert(cls->isRealized());
5149 for ( ; cls; cls = cls->superclass) {
5150 for (plist = cls->data()->properties; plist; plist = plist->next) {
5172 Class gdb_class_getClass(Class cls)
5174 const char *className = cls->mangledName();
5194 Class cls;
5198 cls = (Class)this;
5199 metacls = cls->ISA();
5269 if (cls == classNSObject()) {
5271 FOREACH_CATEGORY_METHOD_LIST(mlist, cls, {
5279 else if (!cls->superclass) {
5284 else if (cls->superclass->hasCustomRR()) {
5291 FOREACH_METHOD_LIST(mlist, cls, {
5299 if (!clsCustomRR) cls->setHasDefaultRR();
5301 // cls->printCustomAWZ();
5302 if (PrintCustomRR && clsCustomRR) cls->printCustomRR(inherited);
5316 BOOL _class_usesAutomaticRetainRelease(Class cls)
5318 return (cls->data()->ro->flags & RO_IS_ARR) ? YES : NO;
5410 Class cls = (Class)this;
5415 foreach_realized_class_and_subclass(cls, ^(Class c){
5416 if (c != cls && !c->isInitialized()) {
5428 if (PrintCustomRR) c->printCustomRR(inherited || c != cls);
5438 Class cls = (Class)this;
5443 foreach_realized_class_and_subclass(cls, ^(Class c){
5444 if (c != cls && !c->isInitialized()) {
5456 if (PrintCustomAWZ) c->printCustomAWZ(inherited || c != cls);
5466 Class cls = (Class)this;
5471 foreach_realized_class_and_subclass(cls, ^(Class c){
5483 if (PrintRawIsa) c->printRequiresRawIsa(inherited || c != cls);
5492 updateCustomRR_AWZ(Class cls, method_t *meth)
5508 if (cls == classNSObject()) {
5539 if (cls == classNSObject()->ISA()) {
5575 class_getIvarLayout(Class cls)
5577 if (cls) return cls->data()->ro->ivarLayout;
5589 class_getWeakIvarLayout(Class cls)
5591 if (cls) return cls->data()->ro->weakIvarLayout;
5606 class_setIvarLayout(Class cls, const uint8_t *layout)
5608 if (!cls) return;
5615 if (!(cls->data()->flags & RW_CONSTRUCTING)) {
5617 "class '%s'", cls->nameForLogging());
5622 class_ro_t *ro_w = make_ro_writeable(cls->data());
5633 _class_setIvarLayoutAccessor(Class cls, const uint8_t* (*accessor) (id object)) {
5634 if (!cls) return;
5638 class_ro_t *ro_w = make_ro_writeable(cls->data());
5641 if (!(cls->data()->flags & RW_HAS_INSTANCE_SPECIFIC_LAYOUT)) try_free(ro_w->ivarLayout);
5643 cls->setInfo(RW_HAS_INSTANCE_SPECIFIC_LAYOUT);
5649 _object_getIvarLayout(Class cls, id object)
5651 if (cls) {
5652 const uint8_t* layout = cls->data()->ro->ivarLayout;
5653 if (cls->data()->flags & RW_HAS_INSTANCE_SPECIFIC_LAYOUT) {
5672 class_setWeakIvarLayout(Class cls, const uint8_t *layout)
5674 if (!cls) return;
5681 if (!(cls->data()->flags & RW_CONSTRUCTING)) {
5683 "class '%s'", cls->nameForLogging());
5688 class_ro_t *ro_w = make_ro_writeable(cls->data());
5703 _class_getVariable(Class cls, const char *name, Class *memberOf)
5707 for ( ; cls; cls = cls->superclass) {
5708 ivar_t *ivar = getIvar(cls, name);
5711 if (memberOf) *memberOf = cls;
5727 BOOL class_conformsToProtocol(Class cls, Protocol *proto_gen)
5734 if (!cls) return NO;
5739 assert(cls->isRealized());
5741 for (plist = cls->data()->protocols; plist && *plist; plist++) {
5764 addMethod(Class cls, SEL name, IMP imp, const char *types, BOOL replace)
5771 assert(cls->isRealized());
5774 if ((m = getMethodNoSuper_nolock(cls, name))) {
5779 result = _method_setImplementation(cls, m, imp);
5795 attachMethodLists(cls, &newlist, 1, NO, NO, YES);
5805 class_addMethod(Class cls, SEL name, IMP imp, const char *types)
5807 if (!cls) return NO;
5810 IMP old = addMethod(cls, name, imp, types ?: "", NO);
5817 class_replaceMethod(Class cls, SEL name, IMP imp, const char *types)
5819 if (!cls) return nil;
5822 IMP old = addMethod(cls, name, imp, types ?: "", YES);
5834 class_addIvar(Class cls, const char *name, size_t size,
5837 if (!cls) return NO;
5844 assert(cls->isRealized());
5847 if (cls->isMetaClass()) {
5853 if (!(cls->data()->flags & RW_CONSTRUCTING)) {
5861 if ((name && getIvar(cls, name)) || size > UINT32_MAX) {
5866 class_ro_t *ro_w = make_ro_writeable(cls->data());
5871 if ((oldlist = (ivar_list_t *)cls->data()->ro->ivars)) {
5883 uint32_t offset = cls->unalignedInstanceSize();
5902 cls->setInstanceSize((uint32_t)(offset + size));
5917 BOOL class_addProtocol(Class cls, Protocol *protocol_gen)
5923 if (!cls) return NO;
5924 if (class_conformsToProtocol(cls, protocol_gen)) return NO;
5928 assert(cls->isRealized());
5937 for (plistp = cls->data()->protocols; plistp && *plistp; plistp++) {
5941 cls->data()->protocols = (const protocol_list_t **)
5942 _realloc_internal(cls->data()->protocols,
5944 cls->data()->protocols[count] = plist;
5945 cls->data()->protocols[count+1] = nil;
5961 _class_addProperty(Class cls, const char *name,
5967 if (!cls) return NO;
5970 property_t *prop = class_getProperty(cls, name);
5986 assert(cls->isRealized());
5994 plist->next = cls->data()->properties;
5995 cls->data()->properties = plist;
6004 class_addProperty(Class cls, const char *name,
6007 return _class_addProperty(cls, name, attrs, n, NO);
6011 class_replaceProperty(Class cls, const char *name,
6014 _class_addProperty(cls, name, attrs, n, YES);
6132 static void objc_initializeClassPair_internal(Class superclass, const char *name, Class cls, Class meta)
6138 cls->cache.setEmpty();
6141 cls->setData((class_rw_t *)_calloc_internal(sizeof(class_rw_t), 1));
6145 cls->data()->ro = cls_ro_w;
6150 cls->data()->flags = RW_CONSTRUCTING | RW_COPIED_RO | RW_REALIZED | RW_REALIZING;
6152 cls->data()->version = 0;
6164 cls->setInstanceSize(cls_ro_w->instanceStart);
6169 cls->setInstanceSize((uint32_t)sizeof(id)); // just an isa
6180 cls->initClassIsa(meta);
6183 cls->superclass = superclass;
6185 addSubclass(superclass, cls);
6189 cls->superclass = Nil;
6190 meta->superclass = cls;
6191 addSubclass(cls, meta);
6224 Class objc_initializeClassPair(Class superclass, const char *name, Class cls, Class meta)
6235 objc_initializeClassPair_internal(superclass, name, cls, meta);
6238 return cls;
6250 Class cls, meta;
6262 cls = alloc_class_for_subclass(superclass, extraBytes);
6266 objc_initializeClassPair_internal(superclass, name, cls, meta);
6270 return cls;
6279 void objc_registerClassPair(Class cls)
6283 if ((cls->data()->flags & RW_CONSTRUCTED) ||
6284 (cls->ISA()->data()->flags & RW_CONSTRUCTED))
6287 "registered!", cls->data()->ro->name);
6292 if (!(cls->data()->flags & RW_CONSTRUCTING) ||
6293 !(cls->ISA()->data()->flags & RW_CONSTRUCTING))
6297 cls->data()->ro->name);
6304 Class supercls = cls->superclass;
6305 class_ro_t *ro_w = (class_ro_t *)cls->data()->ro;
6324 cls->unalignedInstanceSize(), NO);
6357 cls->ISA()->changeInfo(RW_CONSTRUCTED, RW_CONSTRUCTING | RW_REALIZING);
6358 cls->changeInfo(RW_CONSTRUCTED, RW_CONSTRUCTING | RW_REALIZING);
6361 addNamedClass(cls, cls->data()->ro->name);
6362 addRealizedClass(cls);
6363 addRealizedMetaclass(cls->ISA());
6395 Class cls = readClass(bits, false/*bundle*/, false/*shared cache*/);
6396 if (cls != bits) {
6399 cls->nameForLogging(), bits, cls);
6401 realizeClass(cls);
6405 return cls;
6416 static void detach_class(Class cls, BOOL isMeta)
6422 cats = unattachedCategoriesForClass(cls);
6426 if (cls->isRealized()) {
6427 Class supercls = cls->superclass;
6429 removeSubclass(supercls, cls);
6435 removeNamedClass(cls, cls->mangledName());
6436 removeRealizedClass(cls);
6438 removeRealizedMetaclass(cls);
6449 static void free_class(Class cls)
6453 if (! cls->isRealized()) return;
6457 if (cls->cache.canBeFreed()) {
6458 free(cls->cache.buckets());
6461 FOREACH_METHOD_LIST(mlist, cls, {
6468 if (cls->data()->flags & RW_METHOD_ARRAY) {
6469 try_free(cls->data()->method_lists);
6472 const ivar_list_t *ilist = cls->data()->ro->ivars;
6484 for (plistp = cls->data()->protocols; plistp && *plistp; plistp++) {
6487 try_free(cls->data()->protocols);
6489 const chained_property_list *proplist = cls->data()->properties;
6503 try_free(cls->data()->ro->ivarLayout);
6504 try_free(cls->data()->ro->weakIvarLayout);
6505 try_free(cls->data()->ro->name);
6506 try_free(cls->data()->ro);
6507 try_free(cls->data());
6508 try_free(cls);
6512 void objc_disposeClassPair(Class cls)
6516 if (!(cls->data()->flags & (RW_CONSTRUCTED|RW_CONSTRUCTING)) ||
6517 !(cls->ISA()->data()->flags & (RW_CONSTRUCTED|RW_CONSTRUCTING)))
6523 cls->data()->ro->name);
6528 if (cls->isMetaClass()) {
6530 "not a class!", cls->data()->ro->name);
6536 if (cls->data()->firstSubclass) {
6538 "including '%s'!", cls->data()->ro->name,
6539 cls->data()->firstSubclass->nameForLogging());
6541 if (cls->ISA()->data()->firstSubclass) {
6543 "including '%s'!", cls->data()->ro->name,
6544 cls->ISA()->data()->firstSubclass->nameForLogging());
6549 detach_class(cls->ISA(), YES);
6550 detach_class(cls, NO);
6551 free_class(cls->ISA());
6552 free_class(cls);
6560 * Creates an instance of `cls` at the location pointed to by `bytes`.
6561 * `bytes` must point to at least class_getInstanceSize(cls) bytes of
6564 * Returns `bytes` if successful. Returns nil if `cls` or `bytes` is
6569 objc_constructInstance(Class cls, void *bytes)
6571 if (!cls || !bytes) return nil;
6576 bool hasCxxCtor = cls->hasCxxCtor();
6577 bool hasCxxDtor = cls->hasCxxDtor();
6578 bool fast = cls->canAllocIndexed();
6581 obj->initInstanceIsa(cls, hasCxxDtor);
6583 obj->initIsa(cls);
6587 return object_cxxConstructFromClass(obj, cls);
6602 _class_createInstanceFromZone(Class cls, size_t extraBytes, void *zone)
6604 if (!cls) return nil;
6606 assert(cls->isRealized());
6609 bool hasCxxCtor = cls->hasCxxCtor();
6610 bool hasCxxDtor = cls->hasCxxDtor();
6611 bool fast = cls->canAllocIndexed();
6613 size_t size = cls->instanceSize(extraBytes);
6619 obj->initInstanceIsa(cls, hasCxxDtor);
6637 obj->initIsa(cls);
6641 obj = _objc_constructOrFree(obj, cls);
6649 class_createInstance(Class cls, size_t extraBytes)
6651 return _class_createInstanceFromZone(cls, extraBytes, nil);
6664 class_createInstances(Class cls, size_t extraBytes,
6667 return _class_createInstancesFromZone(cls, extraBytes, nil,
6671 static BOOL classOrSuperClassesUseARR(Class cls) {
6672 while (cls) {
6673 if (_class_usesAutomaticRetainRelease(cls)) return true;
6674 cls = cls->superclass;
6682 Class cls = oldObject->ISA();
6683 for ( ; cls; cls = cls->superclass) {
6684 if (_class_usesAutomaticRetainRelease(cls)) {
6687 size_t instanceStart = _class_getInstanceStart(cls);
6688 const uint8_t *strongLayout = class_getIvarLayout(cls);
6703 const uint8_t *weakLayout = class_getWeakIvarLayout(cls);
6786 class_createInstanceFromZone(Class cls, size_t extraBytes, void *zone)
6788 return _class_createInstanceFromZone(cls, extraBytes, zone);
6941 _objc_registerTaggedPointerClass(objc_tag_index_t tag, Class cls)
6954 if (cls && oldCls && cls != oldCls) {
6958 cls, cls->nameForLogging());
6961 objc_tag_classes[slot] = cls;
7066 static Class setSuperclass(Class cls, Class newSuper)
7072 assert(cls->isRealized());
7075 oldSuper = cls->superclass;
7076 removeSubclass(oldSuper, cls);
7077 removeSubclass(oldSuper->ISA(), cls->ISA());
7079 cls->superclass = newSuper;
7080 cls->ISA()->superclass = newSuper->ISA();
7081 addSubclass(newSuper, cls);
7082 addSubclass(newSuper->ISA(), cls->ISA());
7087 if (cls->isInitialized() || cls->ISA()->isInitialized()) {
7088 flushCaches(cls);
7095 Class class_setSuperclass(Class cls, Class newSuper)
7100 oldSuper = setSuperclass(cls, newSuper);