Method post_process

src/lib/parse/post_process.cpp:30–169

}

void ParseContext::post_process() {
    std::unordered_map<index_t, index_t> typemap;
    {
        // Deduplicate types
        std::unordered_map<FuncType, index_t> funcmap;
        std::vector<FuncType> functypes;
        for (index_t i = 0; i < module_.types.size(); ++i) {
            if (funcmap.contains(module_.types[i])) {
                typemap[i] = funcmap[module_.types[i]];
            } else {
                funcmap[module_.types[i]] = functypes.size();
                typemap[i] = functypes.size();
                functypes.emplace_back(module_.types[i]);
            }
        }
        module_.types = functypes;
    }
    std::unordered_map<index_t, index_t> funcmap    = reorder_map(func_map_);
    std::unordered_map<index_t, index_t> tablemap   = reorder_map(table_map_);
    std::unordered_map<index_t, index_t> memorymap  = reorder_map(mem_map_);
    std::unordered_map<index_t, index_t> globalmap  = reorder_map(global_map_);

    // funcs
    for (WasmFunc& func : module_.funcs) {
        if (typemap.contains(func.typeidx))
            func.typeidx = typemap[func.typeidx];
        for (WasmInstr& instr : func.body) {
            switch(instr.opcode) {
                case Opcode::Block: case Opcode::Loop: case Opcode::If: {
                    auto& blk = std::get<WasmInstr::BlockType>(instr.imm);
                    if (blk.type && typemap.contains(blk.type.value())) blk.type = typemap[blk.type.value()];
                } break;
                case Opcode::Call_indirect: {
                    auto& tw = std::get<WasmInstr::TwoIdx>(instr.imm);
                    if (typemap.contains(tw.b)) tw.b = typemap[tw.b]; // b = typeidx
                } break;
                case Opcode::Ref_func: {
                    auto& o = std::get<WasmInstr::OneIdx>(instr.imm);
                    if (funcmap.contains(o.index)) o.index = funcmap[o.index];
                } break;
                case Opcode::Global_get: case Opcode::Global_set: {
                    auto& o = std::get<WasmInstr::OneIdx>(instr.imm);
                    if (globalmap.contains(o.index)) o.index = globalmap[o.index];
                } break;
                case Opcode::Table_get: case Opcode::Table_set:
                case Opcode::Table_size: case Opcode::Table_grow: case Opcode::Table_fill: {
                    auto& o = std::get<WasmInstr::OneIdx>(instr.imm);
                    if (tablemap.contains(o.index)) o.index = tablemap[o.index];
                } break;
                case Opcode::Table_copy: {
                    auto& tw = std::get<WasmInstr::TwoIdx>(instr.imm);
                    if (tablemap.contains(tw.a)) tw.a = tablemap[tw.a]; // a = dstidx
                    if (tablemap.contains(tw.b)) tw.b = tablemap[tw.b]; // b = srcidx
                } break;
                case Opcode::Table_init: {
                    auto& tw = std::get<WasmInstr::TwoIdx>(instr.imm);
                    if (tablemap.contains(tw.a)) tw.a = tablemap[tw.a]; // a = tableidx
                } break;