Method analyze_function

src/analysis.cpp:267–351

}

bool N64Recomp::analyze_function(const N64Recomp::Context& context, const N64Recomp::Function& func,
    const std::vector<rabbitizer::InstructionCpu>& instructions, N64Recomp::FunctionStats& stats) {
    const Section* section = &context.sections[func.section_index];
    std::optional<uint32_t> got_ram_addr = section->got_ram_addr;

    // Create a state to track each register (r0 won't be used)
    RegState reg_states[32] {};
    std::vector<RegState> stack_states{};

    // Look for jump tables
    // A linear search through the func won't be accurate due to not taking control flow into account, but it'll work for finding jtables
    for (const auto& instr : instructions) {
        if (!analyze_instruction(instr, func, stats, reg_states, stack_states, got_ram_addr.has_value())) {
            return false;
        }
    }

    // Calculate absolute addresses for position-independent jump tables
    if (got_ram_addr.has_value()) {
        uint32_t got_rom_addr = got_ram_addr.value() + func.rom - func.vram;

        for (size_t i = 0; i < stats.jump_tables.size(); i++) {
            JumpTable& cur_jtbl = stats.jump_tables[i];

            if (cur_jtbl.got_offset.has_value()) {
                uint32_t got_word = byteswap(*reinterpret_cast<const uint32_t*>(&context.rom[got_rom_addr + cur_jtbl.got_offset.value()]));

                cur_jtbl.vram += (section->ram_addr + got_word);
            }
        }
    }

    // Sort jump tables by their address
    std::sort(stats.jump_tables.begin(), stats.jump_tables.end(),
        [](const JumpTable& a, const JumpTable& b)
    {
        return a.vram < b.vram;
    });

    // Determine jump table sizes
    for (size_t i = 0; i < stats.jump_tables.size(); i++) {
        JumpTable& cur_jtbl = stats.jump_tables[i];
        uint32_t end_address = (uint32_t)-1;
        uint32_t entry_count = 0;
        uint32_t vram = cur_jtbl.vram;

        if (i < stats.jump_tables.size() - 1) {
            end_address = stats.jump_tables[i + 1].vram;
        }

        // TODO this assumes that the jump table is in the same section as the function itself
        cur_jtbl.rom = cur_jtbl.vram + func.rom - func.vram;
        cur_jtbl.section_index = func.section_index;

        while (vram < end_address) {
            // Retrieve the current entry of the jump table
            // TODO same as above
            uint32_t rom_addr = vram + func.rom - func.vram;