gcrecomp-core 0.0.1-alpha

Static recompiler for GameCube games to Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

//! IR to Rust Translation
//!
//! This module translates intermediate representation (IR) instructions to Rust code.
//! The translation produces idiomatic Rust code that can be compiled and executed.
//!
//! # Translation Strategy
//! - **IR instructions**: Converted to Rust statements
//! - **Basic blocks**: Converted to Rust code blocks
//! - **Control flow**: Converted to Rust control flow (if, loop, match)
//!
//! # Memory Optimizations
//! - Pre-allocates string buffer with estimated capacity
//! - Uses efficient string operations

use crate::recompiler::ir::instruction::IRFunction;
use anyhow::Result;

/// IR to Rust translator.
pub struct IRToRust;

impl IRToRust {
    /// Translate an IR function to Rust code.
    ///
    /// # Algorithm
    /// Converts IR function structure to Rust function:
    /// 1. Generate function signature
    /// 2. Initialize runtime context
    /// 3. Translate basic blocks to Rust code
    /// 4. Generate function closing brace
    ///
    /// # Arguments
    /// * `function` - IR function to translate
    ///
    /// # Returns
    /// `Result<String>` - Generated Rust code
    ///
    /// # Errors
    /// Returns error if translation fails
    ///
    /// # Examples
    /// ```rust
    /// let rust_code = IRToRust::translate(&ir_function)?;
    /// ```
    #[inline] // May be called frequently
    pub fn translate(function: &IRFunction) -> Result<String> {
        // Pre-allocate string buffer with estimated capacity
        // Estimate: ~100 bytes per instruction
        let estimated_capacity: usize = function.basic_blocks.iter()
            .map(|block| block.instructions.len())
            .sum::<usize>() * 100usize;
        let mut code: String = String::with_capacity(estimated_capacity);
        
        code.push_str(&format!("fn {}() {{\n", function.name));
        code.push_str("    let mut ctx = gcrecomp_runtime::CpuContext::new();\n");
        code.push_str("    let mut memory = gcrecomp_runtime::MemoryManager::new();\n");
        code.push('\n');
        
        for block in function.basic_blocks.iter() {
            for inst in block.instructions.iter() {
                code.push_str(&Self::translate_instruction(inst)?);
            }
        }
        
        code.push_str("}\n");
        
        Ok(code)
    }
    
    /// Translate a single IR instruction to Rust code.
    ///
    /// # Arguments
    /// * `inst` - IR instruction to translate
    ///
    /// # Returns
    /// `Result<String>` - Generated Rust code for the instruction
    ///
    /// # Errors
    /// Returns error if translation fails
    #[inline] // Hot path - called for every instruction
    fn translate_instruction(inst: &crate::recompiler::ir::instruction::IRInstruction) -> Result<String> {
        match inst {
            crate::recompiler::ir::instruction::IRInstruction::Add { dst, src1, src2 } => {
                Ok(format!(
                    "    ctx.set_register({}, ctx.get_register({}) + ctx.get_register({}));\n",
                    dst, src1, src2
                ))
            }
            crate::recompiler::ir::instruction::IRInstruction::Sub { dst, src1, src2 } => {
                Ok(format!(
                    "    ctx.set_register({}, ctx.get_register({}) - ctx.get_register({}));\n",
                    dst, src1, src2
                ))
            }
            crate::recompiler::ir::instruction::IRInstruction::Mul { dst, src1, src2 } => {
                Ok(format!(
                    "    ctx.set_register({}, ctx.get_register({}) * ctx.get_register({}));\n",
                    dst, src1, src2
                ))
            }
            crate::recompiler::ir::instruction::IRInstruction::Div { dst, src1, src2 } => {
                Ok(format!(
                    "    ctx.set_register({}, ctx.get_register({}) / ctx.get_register({}));\n",
                    dst, src1, src2
                ))
            }
            crate::recompiler::ir::instruction::IRInstruction::Move { dst, src } => {
                Ok(format!(
                    "    ctx.set_register({}, ctx.get_register({}));\n",
                    dst, src
                ))
            }
            crate::recompiler::ir::instruction::IRInstruction::MoveImm { dst, imm } => {
                Ok(format!(
                    "    ctx.set_register({}, {}u32);\n",
                    dst, imm
                ))
            }
            _ => Ok("    // IR instruction\n".to_string()),
        }
    }
}