Method VMConfig

src/vm_isa.cpp:8–165

namespace mkpivm {
    VMConfig::VMConfig(Arch arch, SeedRng& rng) : arch_{arch}, master_seed_{rng.next()} {
        // register file shape
        // need 16 arch gprs + 4 tmps + at least 4 scratch = 24 minimum
        reg_count_ = static_cast<std::uint8_t>(rng.uniform(24, 32));

        // XReg to slot mapping. random permutation over 0..reg_count_-1 with
        // the first 16 reserved for x86 gprs
        std::vector<std::uint8_t> perm(reg_count_);
        for (std::uint8_t i = 0; i < reg_count_; ++i) perm[i] = i;
        shuffle_in_place(perm, rng);

        const std::uint8_t gpr_count = arch_native_gpr_count(arch);
        xreg_to_slot_.fill(0xFF);
        for (std::uint8_t i = 0; i < gpr_count; ++i) {
            xreg_to_slot_[i] = perm[i];
        }

        // four slots for Tmp0..Tmp3. these sit past the arch gprs 
        const std::uint8_t tmp_count = 4;
        for (std::uint8_t i = 0; i < tmp_count; ++i) {
            xreg_to_slot_[16 + i] = perm[gpr_count + i];
        }
        scratch_slots_.assign(perm.begin() + gpr_count + tmp_count, perm.begin() + reg_count_);

        // VMState layout. fields go in random order 
        auto pad = [&](std::uint16_t cur, std::uint16_t align) {
            const std::uint16_t over = cur % align;
            return over ? static_cast<std::uint16_t>(cur + (align - over)) : cur;
        };
        
        auto sprinkle_gap = [&](std::uint16_t cur)->std::uint16_t {
            return cur + static_cast<std::uint16_t>(rng.uniform(0, 7));
        };

        std::uint16_t cur = static_cast<std::uint16_t>(rng.uniform(0, 31)); // random initial offset
        cur = pad(cur, 8);

        // reg-slot array.
        state_.regs_base         = cur;
        state_.regs_total_bytes  = static_cast<std::uint16_t>(reg_count_ * 8);
        cur = static_cast<std::uint16_t>(cur + state_.regs_total_bytes);

        // scalar fields, placed in random order.
        enum Field { F_OP, F_A, F_B, F_RES, F_W, F_DF, F_CSP, F_RSP, F_BCB, F_DIB, F_BTB, F_BTC, F_TRB, F_EXT, F_CSB, F_END };
        std::array<std::uint8_t, F_END> order{};
        for (std::uint8_t i = 0; i < F_END; ++i) order[i] = i;
        shuffle_in_place(order, rng);

        for (auto f : order) {
            cur = sprinkle_gap(cur);
            cur = pad(cur, 8);
            switch (f) {
                case F_OP:  state_.flags_op          = cur; cur += 8;   break;
                case F_A:   state_.flags_a           = cur; cur += 8;   break;
                case F_B:   state_.flags_b           = cur; cur += 8;   break;
                case F_RES: state_.flags_result      = cur; cur += 8;   break;
                case F_W:   state_.flags_width       = cur; cur += 8;   break;
                case F_DF:  state_.df                = cur; cur += 8;   break;