void load_images(const _dyld_objc_notify_mapped_info *info)
{
    // 先无锁快速扫 Mach-O 的非懒加载类/分类 section。
    // 没有 +load 候选项时直接返回，避免进入 runtime 锁路径。
    if (!hasLoadMethods((const headerType *)info->mh,
                        info->sectionLocationMetadata)) {
        return;
    }

    // 保护 +load 队列。它是递归锁，因为 +load 里可能 dlopen，
    // dlopen 又会重新触发 load_images。
    recursive_mutex_locker_t lock(loadMethodLock);

    {
        // 只在发现/准备阶段持有 runtimeLock。
        // 这里会实现类、附着分类、读取方法列表。
        mutex_locker_t lock2(runtimeLock);
        loadAllCategoriesIfNeeded();
        prepare_load_methods((const headerType *)info->mh,
                             info->sectionLocationMetadata);
    }

    // 调用用户 +load 前已经释放 runtimeLock，允许重入 runtime。
    call_load_methods();
}

static void schedule_class_load(Class cls)
{
    if (!cls) return;

    // _read_images 已经实现类；重复排队由 RW_LOADED 拦住。
    ASSERT(cls->isRealized());
    if (cls->data()->flags & RW_LOADED) return;

    // 递归先排父类。这样不需要额外排序，队列天然父类在前。
    schedule_class_load(cls->getSuperclass());

    // 只有类自己实现 +load 才会真正进入 loadable_classes。
    add_class_to_loadable_list(cls);

    // 标记“已经安排过 +load”，避免子类或后续镜像再次安排。
    cls->setInfo(RW_LOADED);
}

void prepare_load_methods(const headerType *mhdr,
                          const _dyld_section_location_info_t info)
{
    // 1. 扫非懒加载类列表，逐个安排类 +load。
    classref_t const *classlist =
        getSectionData<classref_t>(mhdr, info,
            _dyld_section_location_data_non_lazy_class_list, &count);
    for (size_t i = 0; i < count; i++) {
        schedule_class_load(remapClass(classlist[i]));
    }

    // 2. 扫非懒加载分类列表，先确认宿主类可用。
    category_t * const *categorylist =
        getSectionData<category_t *>(mhdr, info,
            _dyld_section_location_data_non_lazy_category_list, &count);
    for (size_t i = 0; i < count; i++) {
        category_t *cat = categorylist[i];
        Class cls = remapClass(cat->cls);
        if (!cls) continue;

        // Swift 稳定 ABI 类不允许 Objective-C category 带 +load。
        if (cls->isSwiftStable()) fatal(...);

        // 确保宿主类及其元类已实现，再把分类加入分类队列。
        realizeClassWithoutSwift(cls, nil);
        add_category_to_loadable_list(cat);
    }
}

void call_load_methods(void)
{
    static bool loading = NO;

    // 调用者必须已经持有 loadMethodLock。
    lockdebug::assert_locked(&loadMethodLock.get());

    // 如果 +load 里触发 dlopen，内层 load_images 会再次调用这里。
    // 内层直接返回，保证外层 +load 先完成，顺序不被打乱。
    if (loading) return;
    loading = YES;

    void *pool = objc_autoreleasePoolPush();
    do {
        // 只要类队列非空就持续调用。
        // call_class_loads 会摘下当前队列；调用期间新增的类进入新队列，下一轮处理。
        while (loadable_classes_used > 0) {
            call_class_loads();
        }

        // 分类队列每轮只尝试一次。
        // 这样分类 +load 触发的新类仍能在下一轮先于新分类执行。
        bool more_categories = call_category_loads();

        // 有新类，或有新加入且尚未尝试的分类，就继续外层循环。
    } while (loadable_classes_used > 0 || more_categories);

    objc_autoreleasePoolPop(pool);
    loading = NO;
}

static bool call_category_loads(void)
{
    // 摘下当前分类队列。调用 +load 时新加入的分类会进入新的全局队列。
    struct loadable_category *cats = loadable_categories;
    int used = loadable_categories_used;
    loadable_categories = nil;
    loadable_categories_used = 0;

    for (int i = 0; i < used; i++) {
        Category cat = cats[i].cat;
        if (!cat) continue;

        Class cls = _category_getClass(cat);
        // 宿主类存在且已可 load 时才调用分类 +load。
        // 不满足条件的分类保留在 cats 中，稍后重新挂回队列。
        if (cls && cls->isLoadable()) {
            ((load_method_t)cats[i].method)(cls, @selector(load));
            cats[i].cat = nil;
        }
    }

    // 把未调用的分类稳定压缩到前面，再把调用期间新加入的分类追加到后面。
    // 返回值告诉外层：是否存在“刚加入、还没尝试过”的分类。
    compact_remaining_categories();
    append_new_categories();
    return new_categories_added;
}