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

//! Unit tests for code generation

use gcrecomp_core::recompiler::analysis::FunctionMetadata;
use gcrecomp_core::recompiler::codegen::CodeGenerator;
use gcrecomp_core::recompiler::decoder::{
    DecodedInstruction, Instruction, InstructionType, Operand,
};
use smallvec::SmallVec;

fn create_test_instruction(opcode: u32, inst_type: InstructionType) -> DecodedInstruction {
    DecodedInstruction {
        instruction: Instruction {
            opcode,
            instruction_type: inst_type,
            operands: SmallVec::new(),
        },
        address: 0x80000000,
        raw: opcode << 26,
    }
}

#[test]
fn test_codegen_initialization() {
    // Just verify that codegen can be created
    let _codegen = CodeGenerator::new();
}

#[test]
fn test_codegen_with_optimizations() {
    let _codegen = CodeGenerator::new().with_optimizations(true);
}

#[test]
fn test_codegen_without_optimizations() {
    let _codegen = CodeGenerator::new().with_optimizations(false);
}

#[test]
fn test_generate_function_empty() {
    let mut codegen = CodeGenerator::new();
    let metadata = FunctionMetadata {
        address: 0x80000000,
        name: "test_function".to_string(),
        size: 0,
        calling_convention: "cdecl".to_string(),
        parameters: vec![],
        return_type: None,
        local_variables: vec![],
        basic_blocks: vec![],
    };

    let instructions = vec![];
    let result = codegen.generate_function(&metadata, &instructions);

    // Should generate at least function signature
    assert!(
        result.is_ok(),
        "Should generate function even with no instructions"
    );
    let code = result.unwrap();
    assert!(
        code.contains("test_function"),
        "Should include function name"
    );
    assert!(code.contains("pub fn"), "Should be a public function");
}

#[test]
fn test_sanitize_identifier() {
    let codegen = CodeGenerator::new();

    assert_eq!(
        codegen.sanitize_identifier("test_function"),
        "test_function"
    );
    assert_eq!(
        codegen.sanitize_identifier("test-function"),
        "test_function"
    );
    assert_eq!(
        codegen.sanitize_identifier("test.function"),
        "test_function"
    );
    assert_eq!(
        codegen.sanitize_identifier("test function"),
        "test_function"
    );
}