程序的加载原理

代码的编译过程

我们编写完成代码是需要通过编译器来完成编译后，才能变成可以执行的文件，也就是我们通常说的可执行文件。
那么编译过程是怎样的呢，下面我们来通过流程图为大家分析一下：
OC底层原理-objc 818（八）类的加载原理-dyld&_objc_init - 图1
程序的执行，就是把可执行的文件加载到内存中进行执行。我们将可执行文件叫做Mach-O，Mach-O的运行需要依赖运行库(.a .lib .so)，运行库分为动态库和静态库，这些库是可执行的二进制文件，能够被加载倒内存中。

静态库和动态库

  • 静态库：例如.a和.framework。静态库链接时，会被完整地复制到可执行文件中，被使用到了多次时，就会被复制到内存中多次，这样就会产生拷贝冗余，造成内存浪费。
  • 动态库：例如.lib和.framework。动态库链接时，只会存在一份，不会复制多份。动态库在内存中是共享的，系统只加载一次，加载完成后谁用就会去引用这块内存，这样就既节省了时间又省了内存。
  • 静态库就是我们常说的值拷贝，而动态库就是我们常说的地址拷贝。
  • 图解

image.png

  • 动态链接库加载倒内存的过程就是由dyld(dynamic link editor)动态链接器完成的。

    dyld动态连接器

  • dyld的介绍：dyld是iOS操作系统的一个重要组成部分，再系统内核做好程序准备工作之后，会交由dyld负责余下的工作。

  • dyld的作用：加载各个库，也就是image镜像文件，由dyld从内存中读到列表中，加载主程序，link链接各个动静态库，进行主程序的初始化工作。
  • dyld工作流程图如下，图中简单描述了动态库的注册和动态库的加载过程，具体的分析还需要看底层的源码，此处暂时不做深入探究。

image.png

_objc_init与dyld

_objc_init源码

首先我们再objc源码中全局搜索_objc_init，在objc_os.mm文件下可以看到实现源码如下：

  1. void _objc_init(void)
  2. {
  3.     static bool initialized = false;
  4.     if (initialized) return;
  5.     initialized = true;
  7.     // fixme defer initialization until an objc-using image is found?
  8.     // 读取影响运行时的环境变量
  9.     // 可以再Edite Scheme中的Environment Variable中进行配置，来打印环境变量帮助
  10.     environ_init();
  11.     // 关于线程key的绑定
  12.     tls_init();
  13.     // 运行C++静态构造函数 在dyld调用我们的静态构造函数之前，libc会调用objc_init，因此我们必须自己做
  14.     static_init();
  15.     // runtime运行时环境变量初始化
  16.     runtime_init();
  17.     // 初始化libobjc的异常处理方法
  18.     exception_init();
  19. #if __OBJC2__
  20.         // 缓存条件初始化
  21.     cache_t::init();
  22. #endif
  23.         // 启动回调机制
  24.     _imp_implementationWithBlock_init();
  25.         // 注册dyld
  26.     _dyld_objc_notify_register(&map_images, load_images, unmap_image);
  28. #if __OBJC2__
  29.     didCallDyldNotifyRegister = true;
  30. #endif
  31. }

根据源码所知，主要分为一下几部分：

  • environ_init：初始化一系列的环境变量，病读取影响运行的环境变量
  • tls_init：关于线程key的绑定
  • static_init：运行C++静态构造函数（只会运行系统级别的构造函数），在dyld调用静态析构函数之前，libc会调用_objc_init
  • runtime_init：runtime运行时环境初始化，里面操作是unattachedCategories、allocatedClasses表的初始化
  • exception_init：初始化libobjc的异常处理系统
  • cache_t::init：cache缓存初始化
  • _imp_implementationWithBlock_init：启动回调机制，通常这不会做什么，因为所有的初始化都是惰性的，但是对于某些进程，我们会迫不及待地加载trampolines dylib

  • _dyld_objc_notify_register：dyld的注册

    • 仅供objc运行时使用。注册应用程序，以便再映射、取消映射和初始化objc镜像文件时使用，dyld将使用包含objc_image_info的镜像文件数组，回调mapped函数。
    • map_images：dyld将image镜像文件加载进内存时，会触发该函数
    • load_image：dyld初始化image会触发该函数

    • unmap_image：dyld将image移除时会触发该函数

      environ_init方法：环境变量初始化

      environ_init源码如下，我截取了比较关键的部分，此处主要循环打印环境变量信息

      1. void environ_init(void) 
      2. {
      3. // ……省略
      4. // Print OBJC_HELP and OBJC_PRINT_OPTIONS output.
      5. if (PrintHelp  ||  PrintOptions) {
      6.    // …… 省略
      8.    // 核心代码
      9.    for (size_t i = 0; i < sizeof(Settings)/sizeof(Settings[0]); i++) {
      10.        const option_t *opt = &Settings[i];            
      11.        if (PrintHelp) _objc_inform("%s: %s", opt->env, opt->help);
      12.        if (PrintOptions && *opt->var) _objc_inform("%s is set", opt->env);
      13.    }
      14. }
      15. }

      环境变量打印

      方式一：修改源码的方式进行打印

      image.png

  • 首先我们移除掉内层和外层的if条件，只保留上述代码块；

  • 运行我们的objc源码项目；
  • 查看控制台打印结果，会打印出所有的环境变量信息

  • image.png

    方式二：通过终端命令打印环境变量

    需要再终端中输入export OBJC_HELP=1指令，打印环境变量
    image.png

    方式三：打印指定的环境变量信息

    设置方式：
    可以通过target — Edit Scheme — Run —Arguments — Environment Variables配置，其中常用的环境变量主要有以下几个：

  • DYLD_PRINT_STATISTICS：设置DYLD_PRINT_STATISTICS为YES，控制台就会打印APP的加载时长，包括整体加载时长和动态库加载时长，即main函数之前dyld的处理时间，可以通过设置了解耗时部分，并对其进行启动优化。

  • OBJC_DISABLE_NONPOINTER_ISA：杜绝生成相应的nonpointer isa制（nonpointer isa 优化后的isa，指针地址未优化的isa末尾为1，优化后的isa末尾为0），生成的都是普通的isa
  • OBJC_PRINT_LOAD_METHODS：打印Class即Category的load方法的调用信息
  • NSDoubleLocalizedStrings：项目国际化本地化的时候时一个耗时的工作，想要检测国际化翻译好的文字UI会变成什么样子，可以指定这个启动项，可以设置NSDoubleLocalizedStrings为YES。
  • NSShowNonLocalizedStrings：在完成国际化的时候，偶尔会有一些字符串没有做本地化，这时就可以设置NSShowNonLocalizedStrings为YES，所有没有本地化的字符串全都会变成大写。

    OBJC_DISABLE_NONPOINTER_ISA

    以OBJC_DISABLE_NONPOINTER_ISA为例，将其设置为YES
    image.png
    未设置OBJC_DISABLE_NONPOINTER_ISA时打印objc对象，isa地址的二进制末尾为1
    image.png
    设置OBJC_DISABLE_NONPOINTER_ISA时打印机objc对象，isa地址的二进制末尾为0
    image.png
    所以OBJC_DISABLE_NONPOINTER_ISA可以控制isa开关，从而优化整个内存结构

    tls_init：线程key的绑定

    主要是本地线程池的初始化以及析构，源码：
    1. void tls_init(void)
    2. {
    3. #if SUPPORT_DIRECT_THREAD_KEYS
    4.   pthread_key_init_np(TLS_DIRECT_KEY, &_objc_pthread_destroyspecific);
    5. #else
    6.   _objc_pthread_key = tls_create(&_objc_pthread_destroyspecific);
    7. #endif
    8. }

    static_init：运行系统级别的C++静态构造函数

    主要是运行系统级别的C++静态构造函数，在dyld调用我们的静态构造函数之前，libc调用_objc_init方法，即系统级别的C++构造函数，自定义的C++构造函数运行，源码：
    1. static void static_init()
    2. {
    3.   size_t count;
    4.   auto inits = getLibobjcInitializers(&_mh_dylib_header, &count);
    5.   for (size_t i = 0; i < count; i++) {
    6.       inits[i]();
    7.   }
    8.   auto offsets = getLibobjcInitializerOffsets(&_mh_dylib_header, &count);
    9.   for (size_t i = 0; i < count; i++) {
    10.       UnsignedInitializer init(offsets[i]);
    11.       init();
    12.   }
    13. }

    runtime_init：运行时环境初始化

    主要是运行时的初始化，主要分为两部分：分类初始化、类的表初始化，源码：
    1. void runtime_init(void)
    2. {
    3.   objc::unattachedCategories.init(32);
    4.   objc::allocatedClasses.init();
    5. }

    exception_init：初始化libobjc的异常处理系统

    主要是初始化libobjc的异常处理系统，注册异常处理的回调，从而监控异常的处理，源码： ```objectivec

void exception_init(void) { old_terminate = std::set_terminate(&_objc_terminate); }

  2. - 当有crash发生时，就会到old_terminate方法，最终走到uncaught_handler进行异常抛出
  3.    - crash：是指系统发生了一下不被允许的指令，然后系统会发出的一个信号
  4. - old_terminate源码
  5. ```objectivec
  7. static void (*old_terminate)(void) = nil;
  8. static void _objc_terminate(void)
  9. {
  10.     if (PrintExceptions) {
  11.         _objc_inform("EXCEPTIONS: terminating");
  12.     }
  14.     if (! __cxa_current_exception_type()) {
  15.         // No current exception.
  16.         (*old_terminate)();
  17.     }
  18.     else {
  19.         // There is a current exception. Check if it's an objc exception.
  20.         @try {
  21.             __cxa_rethrow();
  22.         } @catch (id e) {
  23.             // It's an objc object. Call Foundation's handler, if any.
  24.             (*uncaught_handler)((id)e);
  25.             (*old_terminate)();
  26.         } @catch (...) {
  27.             // It's not an objc object. Continue to C++ terminate.
  28.             (*old_terminate)();
  29.         }
  30.     }
  31. }
  • 搜索uncaught_handler，我们发现是一个全局静态变量，是在应用层通过objc_setUncaughtExceptionHandler传入一个异常处理的回调方法，并在该方法内将异常处理方法赋值给uncaught_handler。 ```objectivec

// uncaught_handler初始 static objc_uncaught_exception_handler uncaught_handler = _objc_default_uncaught_exception_handler;

// APP传入处理异常用的回调方法 objc_setUncaughtExceptionHandler(objc_uncaught_exception_handler fn) { objc_uncaught_exception_handler result = uncaught_handler; uncaught_handler = fn; return result; }

  1. <a name="COqJj"></a>
  2. ### cache_init：缓存初始化
  3. 主要是缓存初始化，源码：
  4. ```objectivec
  6. void cache_t::init()
  7. {
  8. #if HAVE_TASK_RESTARTABLE_RANGES
  9.     mach_msg_type_number_t count = 0;
  10.     kern_return_t kr;
  12.     while (objc_restartableRanges[count].location) {
  13.         count++;
  14.     }
  16.     kr = task_restartable_ranges_register(mach_task_self(),
  17.                                           objc_restartableRanges, count);
  18.     if (kr == KERN_SUCCESS) return;
  19.     _objc_fatal("task_restartable_ranges_register failed (result 0x%x: %s)",
  20.                 kr, mach_error_string(kr));
  21. #endif // HAVE_TASK_RESTARTABLE_RANGES
  22. }

_imp_implementationWithBlock_init：启动回调机制

该方法主要是启动回调机制，通常这不会做什么，因为所有的初始化都是惰性的，但是对于某些进程，我们会迫不及待地加载libobjc-trampolines.dylib，源码

  2. _imp_implementationWithBlock_init(void)
  3. {
  4. #if TARGET_OS_OSX
  5.     // Eagerly load libobjc-trampolines.dylib in certain processes. Some
  6.     // programs (most notably QtWebEngineProcess used by older versions of
  7.     // embedded Chromium) enable a highly restrictive sandbox profile which
  8.     // blocks access to that dylib. If anything calls
  9.     // imp_implementationWithBlock (as AppKit has started doing) then we'll
  10.     // crash trying to load it. Loading it here sets it up before the sandbox
  11.     // profile is enabled and blocks it.
  12.     //
  13.     // This fixes EA Origin (rdar://problem/50813789)
  14.     // and Steam (rdar://problem/55286131)
  15.     if (__progname &&
  16.         (strcmp(__progname, "QtWebEngineProcess") == 0 ||
  17.          strcmp(__progname, "Steam Helper") == 0)) {
  18.         Trampolines.Initialize();
  19.     }
  20. #endif
  21. }

_dyld_objc_notify_register：dyld注册

_dyld_objc_notify_register方法

这个方法是dyld的注册方法，其源码是在dyld源码中，下面是_dyld_objc_notify_register的声明

  2. //
  3. // Note: only for use by objc runtime
  4. // Register handlers to be called when objc images are mapped, unmapped, and initialized.
  5. // Dyld will call back the "mapped" function with an array of images that contain an objc-image-info section.
  6. // Those images that are dylibs will have the ref-counts automatically bumped, so objc will no longer need to
  7. // call dlopen() on them to keep them from being unloaded.  During the call to _dyld_objc_notify_register(),
  8. // dyld will call the "mapped" function with already loaded objc images.  During any later dlopen() call,
  9. // dyld will also call the "mapped" function.  Dyld will call the "init" function when dyld would be called
  10. // initializers in that image.  This is when objc calls any +load methods in that image.
  11. //
  12. void _dyld_objc_notify_register(_dyld_objc_notify_mapped    mapped,
  13.                                 _dyld_objc_notify_init      init,
  14.                                 _dyld_objc_notify_unmapped  unmapped);

通过注释可以分析出：

  • 仅运行objc运行时使用
  • 注册处理程序，以便在镜像映射和取消映射和初始化objc镜像是调用

  • dyld将会通过一个包含objc-image-info的镜像文件的数组回调mapped函数

    _dyld_objc_notify_register调用

    1. _dyld_objc_notify_register(&map_images, load_images, unmap_image);

    方法中的三个参数含义：

  • &map_images：dyld将image镜像文件加载倒内存中，会触发该函数

  • load_image：dyld初始化image会触发该函数
  • unmap_image：dyld将image移除时，会触发该函数

load_image方法其实就是调用load方法，map_image方法，&map_image是指针传递，指向是同一块实现的地址，如果有什么变化就可以第一时间知道。
接下来我们就研究一下map_images

map_images

map_images源码

首先，我们先来看一下map_images的源码

  2. void
  3. map_images(unsigned count, const char * const paths[],
  4.            const struct mach_header * const mhdrs[])
  5. {
  6.     mutex_locker_t lock(runtimeLock);
  7.     return map_images_nolock(count, paths, mhdrs);
  8. }

我们可以看到map_images方法内调用了map_images_nolock方法，下面我们看看map_images_nolock源码

map_images_nolock源码

  2. map_images_nolock(unsigned mhCount, const char * const mhPaths[],
  3.                   const struct mach_header * const mhdrs[])
  4. {
  5.     static bool firstTime = YES;
  6.     header_info *hList[mhCount];
  7.     uint32_t hCount;
  8.     size_t selrefCount = 0;
  10.        // …………省略
  12.     if (hCount > 0) {
  13.         _read_images(hList, hCount, totalClasses, unoptimizedTotalClasses);
  14.     }
  16.     firstTime = NO;
  18.     // Call image load funcs after everything is set up.
  19.     for (auto func : loadImageFuncs) {
  20.         for (uint32_t i = 0; i < mhCount; i++) {
  21.             func(mhdrs[i]);
  22.         }
  23.     }
  24. }

map_images_nolock中的关键就在read_image方法，加下来我们就来完整的看一下read_image具体做了什么

read_image

read_image源码

  2. void _read_images(header_info **hList, uint32_t hCount, int totalClasses, int unoptimizedTotalClasses)
  3. {
  4.     header_info *hi;
  5.     uint32_t hIndex;
  6.     size_t count;
  7.     size_t i;
  8.     Class *resolvedFutureClasses = nil;
  9.     size_t resolvedFutureClassCount = 0;
  10.     static bool doneOnce;
  11.     bool launchTime = NO;
  12.     TimeLogger ts(PrintImageTimes);
  14.     runtimeLock.assertLocked();
  16.     hIndex = 0;         \
  17.     hIndex < hCount && (hi = hList[hIndex]); \
  18.     hIndex++
  20.     // 条件控制进行一次加载
  21.     if (!doneOnce) {……}
  23.     // Fix up @selector references
  24.     // 修复预编译阶段的@selector的混乱问题
  25.     // 就是不同类中有相同方法 但是相同方法的地址是不一样的
  26.     static size_t UnfixedSelectors;
  27.     {……}
  29.     ts.log("IMAGE TIMES: fix up selector references");
  31.     // Discover classes. Fix up unresolved future classes. Mark bundle classes.
  32.     // 错误混乱的类处理
  33.     bool hasDyldRoots = dyld_shared_cache_some_image_overridden();
  35.     for (EACH_HEADER) {……}
  37.     ts.log("IMAGE TIMES: discover classes");
  39.     // Fix up remapped classes
  40.     // Class list and nonlazy class list remain unremapped.
  41.     // Class refs and super refs are remapped for message dispatching.
  42.        // 修复重映射一些没有被镜像文件加载进来的类
  43.     if (!noClassesRemapped()) {……}
  45.     ts.log("IMAGE TIMES: remap classes");
  47. #if SUPPORT_FIXUP
  48.     // Fix up old objc_msgSend_fixup call sites
  49.     // 修复一些消息
  50.     for (EACH_HEADER) {……}
  52.     ts.log("IMAGE TIMES: fix up objc_msgSend_fixup");
  53. #endif
  55.     // Discover protocols. Fix up protocol refs.
  56.     // 当类中有协议时 readProtocol
  57.     for (EACH_HEADER) {……}
  59.     ts.log("IMAGE TIMES: discover protocols");
  61.     // Fix up @protocol references
  62.     // Preoptimized images may have the right 
  63.     // answer already but we don't know for sure.
  64.     // 修复没有被加载的协议
  65.     for (EACH_HEADER) {……}
  67.     ts.log("IMAGE TIMES: fix up @protocol references");
  69.     // Discover categories. Only do this after the initial category
  70.     // attachment has been done. For categories present at startup,
  71.     // discovery is deferred until the first load_images call after
  72.     // the call to _dyld_objc_notify_register completes. rdar://problem/53119145
  73.     // 分类的处理
  74.     if (didInitialAttachCategories) {
  75.         for (EACH_HEADER) {
  76.             load_categories_nolock(hi);
  77.         }
  78.     }
  80.     ts.log("IMAGE TIMES: discover categories");
  82.     // Category discovery MUST BE Late to avoid potential races
  83.     // when other threads call the new category code before
  84.     // this thread finishes its fixups.
  86.     // +load handled by prepare_load_methods()
  88.     // Realize non-lazy classes (for +load methods and static instances)
  89.     // 类的加载处理
  90.     for (EACH_HEADER) {……}
  92.     ts.log("IMAGE TIMES: realize non-lazy classes");
  94.     // Realize newly-resolved future classes, in case CF manipulates them
  95.     // 没有被处理的类 优化那些被侵犯的类
  96.     if (resolvedFutureClasses) {……}
  98.     ts.log("IMAGE TIMES: realize future classes");
  99. #undef EACH_HEADER
  100. }

从整体上可以看出read_image是对一些log日志的打印输出，主要如下：

  • 条件控制运行一次加载
  • 修复预编译阶段的@selector的混乱的问题
  • 错误混乱的类处理
  • 修复重映射一些没有被镜像文件加载进来的类
  • 修复一些消息
  • 当类中有协议时 readProtocol
  • 修复没有被加载的协议
  • 分类的处理
  • 类的加载处理
  • 没有被处理的类，优化那些被侵犯的类

下面我来重点分析几个比较重要的逻辑：

doneOnce

源码

  2. if (!doneOnce) {
  3.     doneOnce = YES;
  4.     launchTime = YES;
  6.     // ……省略
  8.     // namedClasses
  9.     // Preoptimized classes don't go in this table.
  10.     // 4/3 is NXMapTable's load factor
  11.     int namedClassesSize = 
  12.         (isPreoptimized() ? unoptimizedTotalClasses : totalClasses) * 4 / 3;
  13.     // 创建哈希表 存放所有类
  14.     gdb_objc_realized_classes =
  15.         NXCreateMapTable(NXStrValueMapPrototype, namedClassesSize);
  17.     ts.log("IMAGE TIMES: first time tasks");
  18. }

加载一次下次就不会再次进入判断。只有第一次进来时创建表gdb_objc_realized_classes，表里存放所有的类（不管是实现的还是未实现的都存放在里面），是一张存放类的总表

UnfixedSelectors

源码

  2. // Fix up @selector references
  3. static size_t UnfixedSelectors;
  4. {
  5.     mutex_locker_t lock(selLock);
  6.     for (EACH_HEADER) {
  7.         if (hi->hasPreoptimizedSelectors()) continue;
  9.         bool isBundle = hi->isBundle();
  10.         // 从Mach-O中获取方法列表
  11.         SEL *sels = _getObjc2SelectorRefs(hi, &count);
  12.         UnfixedSelectors += count;
  13.         for (i = 0; i < count; i++) {
  14.             const char *name = sel_cname(sels[i]);
  15.             // 从dyld中获取方法
  16.             SEL sel = sel_registerNameNoLock(name, isBundle);
  17.             if (sels[i] != sel) {
  18.                 sels[i] = sel;
  19.             }
  20.         }
  21.     }
  22. }

不同类中可能存在相同的方法，但是相同的方法地址是不同的，dyld的方法是准确的，所以此处需要对Mach-O的方法进行纠正。
下面我们通过debug断电来打印一下。
image.png
sels是通过_getObjc2SelectorRefs获取Mach-O中的方法信息，Mach-O有相对位移地址偏移地址。
sel是通过sel_registerNameNoLock获取的dyld的方法信息，dyld是链接整个程序的，所以dyld是最准确的。因为方法是存放在类中，没给类中的位置是不一样的，所以方法的地址也就不一样，那么久必须对那些混乱的方法进行修复处理。
总结：
Mach-O中存储的是对当前类的相对地址，dyld是加载过程中内存中的实际地址，所以需要将dyld的imp为准进行纠正。

错误混乱的类处理

源码

  2. for (EACH_HEADER) {
  3.     if (! mustReadClasses(hi, hasDyldRoots)) {
  4.         // Image is sufficiently optimized that we need not call readClass()
  5.         continue;
  6.     }
  8.     // 从macho中读取类列表信息
  9.     classref_t const *classlist = _getObjc2ClassList(hi, &count);
  11.     bool headerIsBundle = hi->isBundle();
  12.     bool headerIsPreoptimized = hi->hasPreoptimizedClasses();
  14.     for (i = 0; i < count; i++) {
  15.         Class cls = (Class)classlist[i];
  16.         Class newCls = readClass(cls, headerIsBundle, headerIsPreoptimized);
  18.         // 类信息发生错乱，类运行时可能发生移动，但是没有被删除，就是我们常说的野指针
  19.         if (newCls != cls  &&  newCls) {
  20.             // Class was moved but not deleted. Currently this occurs 
  21.             // only when the new class resolved a future class.
  22.             // Non-lazily realize the class below.
  23.             resolvedFutureClasses = (Class *)
  24.                 realloc(resolvedFutureClasses, 
  25.                         (resolvedFutureClassCount+1) * sizeof(Class));
  26.             resolvedFutureClasses[resolvedFutureClassCount++] = newCls;
  27.         }
  28.     }
  29. }
  • cls：是我们从macho中读取出来的，指向的是一块内存地址。
  • newCls：是我们通过readClass获取的，但是newCls有特殊性，在我们未调用readClass为其赋值时，系统会给newClas分配一块脏地址，一旦调用了readClass后我们会对其重新赋值，并且会为他设置名称，我们我对象的名称也就是在这里进行设置的。
  • 下面我们通过代码来调试一下

image.png
image.png
通过上述调试，也证实了readClass的作用就是把类名和地址关联起来。

readClass

源码

  2. Class readClass(Class cls, bool headerIsBundle, bool headerIsPreoptimized)
  3. {
  4.         // 获取类名
  5.     const char *mangledName = cls->nonlazyMangledName();
  7.     if (missingWeakSuperclass(cls)) {……}
  9.     cls->fixupBackwardDeployingStableSwift();
  11.     Class replacing = nil;
  12.     if (mangledName != nullptr) {……}
  14.     if (headerIsPreoptimized  &&  !replacing) {……
  15.     } else {
  16.         if (mangledName) { //some Swift generic classes can lazily generate their names
  17.                    // 将类名和地址关联起来
  18.             addNamedClass(cls, mangledName, replacing);
  19.         } else {
  20.             Class meta = cls->ISA();
  21.             const class_ro_t *metaRO = meta->bits.safe_ro();
  22.             ASSERT(metaRO->getNonMetaclass() && "Metaclass with lazy name must have a pointer to the corresponding nonmetaclass.");
  23.             ASSERT(metaRO->getNonMetaclass() == cls && "Metaclass nonmetaclass pointer must equal the original class.");
  24.         }
  25.         // 将关联好的类插入到另一张哈希表中 初始化完成的类列表
  26.         addClassTableEntry(cls);
  27.     }
  29.     // for future reference: shared cache never contains MH_BUNDLEs
  30.     if (headerIsBundle) {……}
  32.     return cls;
  33. }

关键方法：

  • nonlazyMangledName获取类名
  • addNamedClass将类名和地址关联起来
  • addClassTableEntry将关联好的类插入到另一张哈希表中，这张表中都是已经初始化完成的类

下面我们通过对cls进行过滤，研究我们自己创建的Person类
image.png
此过程通过nonlazyMangledName获取到了类的名称

nonlazyMangledName源码：

  2. const char *nonlazyMangledName() const {
  3.     return bits.safe_ro()->getName();
  4. }

safe_ro源码：

  2. const class_ro_t *safe_ro() const {
  3.     class_rw_t *maybe_rw = data();
  4.     if (maybe_rw->flags & RW_REALIZED) {
  5.         // maybe_rw is rw
  6.         return maybe_rw->ro();
  7.     } else {
  8.         // maybe_rw is actually ro
  9.         return (class_ro_t *)maybe_rw;
  10.     }
  11. }

addNamedClass将类名和地址关联

  2. static void addNamedClass(Class cls, const char *name, Class replacing = nil)
  3. {
  4.     runtimeLock.assertLocked();
  5.     Class old;
  6.     if ((old = getClassExceptSomeSwift(name))  &&  old != replacing) {
  7.         inform_duplicate(name, old, cls);
  9.         // getMaybeUnrealizedNonMetaClass uses name lookups.
  10.         // Classes not found by name lookup must be in the
  11.         // secondary meta->nonmeta table.
  12.         addNonMetaClass(cls);
  13.     } else {
  14.             // 更新存储所有类的哈希表 key是name value是cls
  15.         NXMapInsert(gdb_objc_realized_classes, name, cls);
  16.     }
  17.     ASSERT(!(cls->data()->flags & RO_META));
  19.     // wrong: constructed classes are already realized when they get here
  20.     // ASSERT(!cls->isRealized());
  21. }

通过NXMapInsert方法更新gdb_objc_realized_classes哈希表，key是name，value是cls

NXMapInsert源码：

  2. void *NXMapInsert(NXMapTable *table, const void *key, const void *value) {
  3.     MapPair    *pairs = (MapPair *)table->buckets;
  4.     unsigned    index = bucketOf(table, key);
  5.     MapPair    *pair = pairs + index;
  6.     if (key == NX_MAPNOTAKEY) {
  7.     _objc_inform("*** NXMapInsert: invalid key: -1\n");
  8.     return NULL;
  9.     }
  11.     unsigned numBuckets = table->nbBucketsMinusOne + 1;
  13.     if (pair->key == NX_MAPNOTAKEY) {
  14.     pair->key = key; pair->value = value;
  15.     table->count++;
  16.     if (table->count * 4 > numBuckets * 3) _NXMapRehash(table);
  17.     return NULL;
  18.     }
  20.      // …………省略
  21. }

addClassTableEntry源码

  2. static void
  3. addClassTableEntry(Class cls, bool addMeta = true)
  4. {
  5.     runtimeLock.assertLocked();
  7.     // This class is allowed to be a known class via the shared cache or via
  8.     // data segments, but it is not allowed to be in the dynamic table already.
  9.     // allocatedClasses就是_objc_alloc runtime_init中初始化的
  10.     auto &set = objc::allocatedClasses.get();
  12.     ASSERT(set.find(cls) == set.end());
  14.     if (!isKnownClass(cls))
  15.         set.insert(cls);
  16.     if (addMeta)
  17.         addClassTableEntry(cls->ISA(), false);
  18. }

allocatedClasses在_objc_init中进行初始化，主要是unattachedCategories(分类)和allocatedClasses(类)两张表，此时addClassTableEntry的操作是插入到allocatedClasses表中。同时还对元类进行了相应的处理。

通过对源码的分析和断电调试，我们发现rw和ro的获取和赋值并不是在readClass里面，那么重新回到_read_image继续向下看。
最终我们断电继续向下走，走到了类加载的区域发现，调用了realizeClassWithoutSwift方法，先透露一下，rw和ro的查找和赋值就是在这个方法中完成的，这个方法我们下节进行探讨
image.png