Method emit_switch

LiveRecomp/live_generator.cpp:1589–1649

}

void N64Recomp::LiveGenerator::emit_switch(const Context& recompiler_context, const JumpTable& jtbl, int reg) const {
    // Populate the switch's labels.
    std::vector<std::string> cur_labels{};
    cur_labels.resize(jtbl.entries.size());
    for (size_t i = 0; i < cur_labels.size(); i++) {
        cur_labels[i] = fmt::format("L_{:08X}", jtbl.entries[i]);
    }
    context->switch_jump_labels.emplace_back(std::move(cur_labels));

    // Allocate the jump table.
    std::unique_ptr<void* []> cur_jump_table = std::make_unique<void* []>(jtbl.entries.size());

    /// Codegen

    // Load the jump target register. The lw instruction was patched into an addiu, so this holds
    // the address of the jump table entry instead of the actual jump target.
    sljit_emit_op1(compiler, SLJIT_MOV, Registers::arithmetic_temp1, 0, SLJIT_MEM1(Registers::ctx), get_gpr_context_offset(reg));
    // Subtract the jump table's address from the jump target to get the jump table addend.
    // Sign extend the jump table address to 64 bits so that the entire register's contents are used instead of just the lower 32 bits.
    const auto& jtbl_section = recompiler_context.sections[jtbl.section_index];
    if (jtbl_section.relocatable) {
        // Make a dummy instruction context to pass to `load_relocated_address`.
        InstructionContext dummy_context{};
        
        // Get the relocated address of the jump table.
        uint32_t section_offset = jtbl.vram - jtbl_section.ram_addr;

        // Get the section index to use for relocation at runtime.
        uint16_t reloc_section_index = jtbl.section_index;
        if (!inputs.original_section_indices.empty()) {
            reloc_section_index = inputs.original_section_indices[reloc_section_index];
        }

        // Populate the necessary fields of the dummy context and load the relocated address into temp2.
        dummy_context.reloc_section_index = reloc_section_index;
        dummy_context.reloc_target_section_offset = section_offset;
        load_relocated_address(dummy_context, Registers::arithmetic_temp2);

        // Subtract the relocated jump table start address from the loaded address. 
        sljit_emit_op2(compiler, SLJIT_SUB, Registers::arithmetic_temp1, 0, Registers::arithmetic_temp1, 0, Registers::arithmetic_temp2, 0);
    }
    else {
        sljit_emit_op2(compiler, SLJIT_SUB, Registers::arithmetic_temp1, 0, Registers::arithmetic_temp1, 0, SLJIT_IMM, (sljit_sw)((int32_t)jtbl.vram));
    }
    
    // Bounds check the addend. If it's greater than or equal to the jump table size (entries * sizeof(u32)) then jump to the switch error.
    sljit_jump* switch_error_jump = sljit_emit_cmp(compiler, SLJIT_GREATER_EQUAL, Registers::arithmetic_temp1, 0, SLJIT_IMM, jtbl.entries.size() * sizeof(uint32_t));
    context->switch_error_jumps.emplace_back(SwitchErrorJump{.instr_vram = jtbl.jr_vram, .jtbl_vram = jtbl.vram, .jump = switch_error_jump});

    // Multiply the jump table addend by 2 to get the addend for the real jump table. (4 bytes per entry to 8 bytes per entry).
    sljit_emit_op2(compiler, SLJIT_ADD, Registers::arithmetic_temp1, 0, Registers::arithmetic_temp1, 0, Registers::arithmetic_temp1, 0);
    // Load the real jump table address.
    sljit_emit_op1(compiler, SLJIT_MOV, Registers::arithmetic_temp2, 0, SLJIT_IMM, (sljit_sw)cur_jump_table.get());
    // Load the real jump entry.
    sljit_emit_op1(compiler, SLJIT_MOV, Registers::arithmetic_temp1, 0, SLJIT_MEM2(Registers::arithmetic_temp1, Registers::arithmetic_temp2), 0);
    // Jump to the loaded entry.
    sljit_emit_ijump(compiler, SLJIT_JUMP, Registers::arithmetic_temp1, 0);