// 简化自 bucket_t::set()
void bucket_set(bucket_t *bucket, bucket_t *base, SEL sel, IMP imp, Class cls) {
    // IMP 可能需要编码：arm64e 使用 ptrauth，部分配置用 isa/class XOR。
    uintptr_t encoded = encodeImp(base, imp, sel, cls);

    // 非 arm64 的关键约束：
    // 1. 先写 IMP，再写 SEL。
    // 2. 读取者如果看到“新 IMP + 空 SEL”，只会 miss。
    // 3. 绝不能让读取者看到“新 SEL + 旧 IMP”，否则会跳错函数。
    bucket->_imp.store(encoded, relaxed);
    publish_barrier_if_needed();
    bucket->_sel.store(sel, release_or_relaxed);

    // arm64 路径用成对 store，让观察者看到旧二元组或新二元组。
}

// 简化自 cache_t::insert(sel, imp, receiver)
void cache_insert(cache_t *cache, SEL sel, IMP imp, id receiver) {
    // 未完成 +initialize 的类不缓存，避免初始化同步被绕过。
    if (!cache->cls()->isInitialized()) return;

    // 动态插入不能发生在已安装的 preoptimized constant cache 上。
    if (cache->isConstantOptimizedCache()) fatal();

    lock(cacheUpdateLock_if_configured);

    unsigned oldCapacity = cache->capacity();
    unsigned capacity = oldCapacity;
    mask_t newOccupied = cache->occupied() + 1;

    if (cache->isConstantEmptyCache()) {
        // 共享空表是只读语义，第一次插入要换成私有 buckets。
        if (!capacity) capacity = INIT_CACHE_SIZE;
        cache->reallocate(oldCapacity, capacity, false);
    } else if (newOccupied + CACHE_END_MARKER <= cache_fill_ratio(capacity)) {
        // 还没超过填充阈值，原地插入。
    } else if (small_cache_can_be_filled_completely(capacity, newOccupied)) {
        // 小表可允许 100% 利用。
    } else {
        // 扩容到两倍，但不超过 MAX_CACHE_SIZE。
        capacity = min(capacity ? capacity * 2 : INIT_CACHE_SIZE, MAX_CACHE_SIZE);
        cache->reallocate(oldCapacity, capacity, true);
    }

    bucket_t *b = cache->buckets();
    mask_t m = capacity - 1;
    mask_t begin = cache_hash(sel, m);

    // 从哈希槽开始线性探测，找到空 selector 后写入。
    for (mask_t i = begin;; i = cache_next(i, m)) {
        if (b[i].sel() == 0) {
            cache->incrementOccupied();
            b[i].set<Atomic, Encoded>(b, sel, imp, cache->cls());
            return;
        }
        if (b[i].sel() == sel) return; // 其他线程已填充。
        if (wrapped_to_begin(i, begin)) cache->bad_cache(receiver, sel);
    }
}

// 简化自 lookUpImpOrForward / log_and_fill_cache
IMP lookup_then_fill(id obj, SEL sel, Class cls, int behavior) {
    IMP imp = cache_getImp(cls, sel);
    if (imp) return imp;

    runtimeLock.lock();

    // 在锁内查方法列表和父类链，保证“查找 + 填 cache”
    // 不会与 category 添加、方法替换等修改交错出永久旧结果。
    Method m = search_method_lists_and_superclasses(cls, sel);
    imp = m ? method_get_imp(m) : _objc_msgForward_impcache;

    if (!(behavior & LOOKUP_NOCACHE)) {
        // 子类命中父类实现时，也可把父类 IMP 填到子类 cache。
        cls->cache.insert(sel, imp, obj);
    }

    runtimeLock.unlock();
    return imp;
}

// 简化自 flushCaches() 与 cache_t::eraseNolock()
void erase_cache(cache_t *cache, const char *why) {
    if (cache->isConstantOptimizedCache()) {
        // 常量 preopt cache 被丢弃后，同时标记该类不再允许 preopt cache。
        cache->setBucketsAndMask(cache_t::emptyBuckets(), 0);
        cache->cls()->setDisallowPreoptCaches();
        return;
    }

    if (cache->occupied() > 0) {
        unsigned cap = cache->capacity();
        bucket_t *old = cache->buckets();

        // 注意：不缩容。换成同容量共享空表，保持无锁读者的安全假设。
        cache->setBucketsAndMask(emptyBucketsForCapacity(cap), cap - 1);

        // 旧表不能立即 free；可能仍被并发 objc_msgSend 扫描。
        collect_free_later(old, cap);
    }
}

// 简化自 initializeToPreoptCacheInDisguise() 和 maybeConvertToPreoptimized()
void initialize_with_preopt(cache_t *cache, const preopt_cache_t *preopt) {
    // 类 realize 但尚未初始化时，不能让 cache 直接命中；
    // 所以先把 preopt 指针“伪装”为 capacity=1 的 bucket。
    bucket_t *disguised = pointer_that_makes_preopt_bit_one_look_like_SEL(preopt);
    cache->setBucketsAndMask(disguised, 0);
    cache->_occupied = preopt->occupied;
}

void convert_after_initialized(cache_t *cache) {
    const preopt_cache_t *preopt = cache->disguised_preopt_cache();
    if (!preopt) return;

    if (!cache->cls()->allowsPreoptCaches()) {
        cache->setBucketsAndMask(cache_t::emptyBuckets(), 0);
        return;
    }

    // entries 指针、hash 参数和 marker 被打包进 _bucketsAndMaybeMask。
    cache->_bucketsAndMaybeMask.store(pack_preopt_entries_pointer(preopt));
    cache->_occupied = preopt->occupied;
}