Method lift_program

src/lifter.cpp:261–386

    }

    IRProgram LifterRegistry::lift_program(const CFGBuilder& cfg) const {
        IRProgram prog;
        prog.arch = cfg.arch();
        prog.entry_va = cfg.base_va();

        ZydisDecoder decoder{};
        const auto mm = (cfg.arch() == Arch::X64) ? ZYDIS_MACHINE_MODE_LONG_64 : ZYDIS_MACHINE_MODE_LEGACY_32;
        const auto sw = (cfg.arch() == Arch::X64) ? ZYDIS_STACK_WIDTH_64 : ZYDIS_STACK_WIDTH_32;
        if (ZYAN_FAILED(ZydisDecoderInit(&decoder, mm, sw))) {
            throw Error("ZydisDecoderInit failed");
        }

        const auto code = cfg.code();
        const auto base = cfg.base_va();

        // collect every unsupported mnemonic, then report them all after
        // the full pass 
        std::set<std::string> unsupported_mnems;

        prog.blocks.reserve(cfg.blocks().size());
        const auto& cfg_blocks = cfg.blocks();
        for (std::size_t bi = 0; bi < cfg_blocks.size(); ++bi) {
            const auto& cb = cfg_blocks[bi];
            IRBlock blk;
            blk.id = static_cast<std::uint32_t>(prog.blocks.size());
            blk.start_va = cb.start_va;
            prog.va_to_block.emplace_back(cb.start_va, blk.id);

            IRBuilder builder{blk};
            for (std::uint64_t va : cb.insn_vas) {
                const std::size_t off = static_cast<std::size_t>(va - base);
                const std::size_t avail = code.size - off;

                ZydisDecodedInstruction insn{};
                ZydisDecodedOperand ops[ZYDIS_MAX_OPERAND_COUNT]{};
                if (ZYAN_FAILED(ZydisDecoderDecodeFull(
                                    &decoder,
                                    code.data + off,
                                    avail,
                                    &insn,
                                    ops
                                ))) {
                    throw Error("decoder failed mid-lift");
                }

                LiftContext ctx{
                    cfg.arch(),
                    va,
                    va + insn.length,
                    insn,
                    ops,
                    cfg,
                    &prog,
                };

                const auto* lf = find(insn.mnemonic);
                if (!lf) {
                    // record and skip so the rest of the lift can keep