Objective-C类结构分析(class_rw_t)
上一篇分析了cache_t的结构和怎么缓存方法的，这里继续分析objc_class中的class_data_bits_t，搜索可以找到主要结构如下
struct class_data_bits_t {
friend objc_class;
uintptr_t bits;
class_rw_t* data() const {
return (class_rw_t *)(bits & FAST_DATA_MASK);
}
bool isAnySwift() {
return isSwiftStable() || isSwiftLegacy();
}
};
可以看出，结构体里面只有一个bits，然后主要方法就是获取class_rw_t，和判断是不是Swift的类。
看标题就知道，这篇文章的重点就是class_rw_t，源码中搜索找到结构体定义
struct class_rw_t {
uint32_t flags; //标记位
uint16_t witness; //存放cls地址 缓存range的索引
explicit_atomic<uintptr_t> ro_or_rw_ext;
Class firstSubclass; //第一个子类
Class nextSiblingClass; //兄弟类
}
这里主要关注ro_or_rw_ext，使用的时候，会通过联合指针转换成ro_or_rw_ext_t
using ro_or_rw_ext_t = objc::PointerUnion<const class_ro_t, class_rw_ext_t, PTRAUTH_STR("class_ro_t"), PTRAUTH_STR("class_rw_ext_t")>;
const ro_or_rw_ext_t get_ro_or_rwe() const {
return ro_or_rw_ext_t{ro_or_rw_ext};
}
void set_ro_or_rwe(const class_ro_t *ro) {
ro_or_rw_ext_t{ro, &ro_or_rw_ext}.storeAt(ro_or_rw_ext, memory_order_relaxed);
}
void set_ro_or_rwe(class_rw_ext_t *rwe, const class_ro_t *ro) {
// the release barrier is so that the class_rw_ext_t::ro initialization
// is visible to lockless readers
rwe->ro = ro;
ro_or_rw_ext_t{rwe, &ro_or_rw_ext}.storeAt(ro_or_rw_ext, memory_order_release);
}
这个里面可能存储着const class_ro_t或者class_rw_ext_t，但只有class_ro_t的时候，就存储class_ro_t，当两者同时存在的时候，就存储class_rw_ext_t。也就是需要的时候才会加载class_rw_ext_t进行分配内存。
class_rw_ext_t *extAllocIfNeeded() {
auto v = get_ro_or_rwe();
if (fastpath(v.is<class_rw_ext_t *>())) {
return v.get<class_rw_ext_t *>(&ro_or_rw_ext);
} else {
return extAlloc(v.get<const class_ro_t *>(&ro_or_rw_ext));
}
}
class_rw_ext_t *
class_rw_t::extAlloc(const class_ro_t *ro, bool deepCopy)
{
runtimeLock.assertLocked();
auto rwe = objc::zalloc<class_rw_ext_t>();
rwe->version = (ro->flags & RO_META) ? 7 : 0;
method_list_t *list = ro->baseMethods();
if (list) {
if (deepCopy) list = list->duplicate();
rwe->methods.attachLists(&list, 1);
}
// See comments in objc_duplicateClass
// property lists and protocol lists historically
// have not been deep-copied
//
// This is probably wrong and ought to be fixed some day
property_list_t *proplist = ro->baseProperties;
if (proplist) {
rwe->properties.attachLists(&proplist, 1);
}
protocol_list_t *protolist = ro->baseProtocols;
if (protolist) {
rwe->protocols.attachLists(&protolist, 1);
}
set_ro_or_rwe(rwe, ro);
return rwe;
}
搜索extAllocIfNeeded，会发现在以下方法中调用
static void
attachCategories(Class cls, const locstamped_category_t *cats_list, uint32_t cats_count,int flags)
BOOL class_addProtocol(Class cls, Protocol *protocol_gen)
static bool
_class_addProperty(Class cls, const char *name, const objc_property_attribute_t *attrs, unsigned int count, bool replace)
可以看出，当类的方法、协议、属性，除类本身外有额外添加的时候就会加载class_rw_ext_t分配内存。
class_rw_ext_t 结构如下
struct class_rw_ext_t {
DECLARE_AUTHED_PTR_TEMPLATE(class_ro_t)
class_ro_t_authed_ptr<const class_ro_t> ro;
method_array_t methods;
property_array_t properties;
protocol_array_t protocols;
char *demangledName;
uint32_t version;
};
这里面存储着，*_array_t类型的方法、属性、协议。
char *demangledName;，可以找到如下方法，应该是Swift类OC化的类名。
const char *
protocol_t::demangledName()
{
if (!hasDemangledNameField())
return mangledName;
if (! _demangledName) {
char *de = copySwiftV1DemangledName(mangledName, true/*isProtocol*/);
if (! OSAtomicCompareAndSwapPtrBarrier(nil, (void*)(de ?: mangledName),
(void**)&_demangledName))
{
if (de) free(de);
}
}
return _demangledName;
}
version应该是版本，这里如果是7的话当前类为元类，0的话为普通类
rwe->version = (ro->flags & RO_META) ? 7 : 0;
class_ro_t结构如下
struct class_ro_t {
uint32_t flags;
uint32_t instanceStart;
uint32_t instanceSize;
#ifdef __LP64__
uint32_t reserved;
#endif
union {
const uint8_t * ivarLayout;
Class nonMetaclass;
};
explicit_atomic<const char *> name;
// With ptrauth, this is signed if it points to a small list, but
// may be unsigned if it points to a big list.
void *baseMethodList;
protocol_list_t * baseProtocols;
const ivar_list_t * ivars;
const uint8_t * weakIvarLayout;
property_list_t *baseProperties;
method_list_t *baseMethods() const {
#if __has_feature(ptrauth_calls)
method_list_t *ptr = ptrauth_strip((method_list_t *)baseMethodList, ptrauth_key_method_list_pointer);
if (ptr == nullptr)
return nullptr;
// Don't auth if the class_ro and the method list are both in the shared cache.
// This is secure since they'll be read-only, and this allows the shared cache
// to cut down on the number of signed pointers it has.
bool roInSharedCache = objc::inSharedCache((uintptr_t)this);
bool listInSharedCache = objc::inSharedCache((uintptr_t)ptr);
if (roInSharedCache && listInSharedCache)
return ptr;
// Auth all other small lists.
if (ptr->isSmallList())
ptr = ptrauth_auth_data((method_list_t *)baseMethodList,
ptrauth_key_method_list_pointer,
ptrauth_blend_discriminator(&baseMethodList,
methodListPointerDiscriminator));
return ptr;
#else
return (method_list_t *)baseMethodList;
#endif
}
};
这里面主要存储着类的信息，包含大小、类名、成员变量、属性列表、方法列表、协议等信息。还有就是class_ro_t是只读的，存储的信息在编译时期就已经确定了，不能再更改，并且必要的时候可以清除，需要用的时候重磁盘中加载就好了。
class_rw_t 是可读可写的，它信息的存储是在运行的时候，需要用到的时候才会写入，并且一直存在于内存中。因为class_rw_ext_t没有成员变量列表，这就是为什么分类中不能添加成员变量的原因。
继续看下 *_array_t 和 *_list_t，查找代码可以找到如下代码
class *_array_t : public list_array_tt<*_t, *_list_t, *_list_t_authed_ptr>
*_array_t 继承于list_array_tt，里面存放着*_list_t。相当于一个二维数组，结构如下
class list_array_tt {
struct array_t {
uint32_t count;
Ptr<List> lists[0];
static size_t byteSize(uint32_t count) {
return sizeof(array_t) + count*sizeof(lists[0]);
}
size_t byteSize() {
return byteSize(count);
}
};
}
*_list_t里面存储着各自的*_t的对象，分别包含各自的信息，列如method_t（简化）
struct method_t {
//…
struct big {
SEL name;
const char *types;
MethodListIMP imp;
};
//…
}
其他更多请查看源码，这里就不贴代码了。
