feo3boy 0.1.0

Emulator core for the gameboy
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234

use std::{iter, mem};

use feo3boy::gbz80core::direct_executor::DirectExecutor;
use feo3boy::gbz80core::direct_executor_v2::DirectExecutorV2;
use feo3boy::gbz80core::microcode_executor::MicrocodeExecutor;
use feo3boy::gbz80core::stepping_executor::SteppingExecutor;

macro_rules! executor_tests {
    ($executor:ty, $modname:ident) => {
        mod $modname {
            use feo3boy::gbz80core::executor::Executor;
            use feo3boy::gbz80core::Gbz80State;
            use feo3boy::memdev::{AllRam, RootMemDevice};

            use super::*;

            #[test]
            fn fibonacci() {
                const OUTPUT: u16 = 0xC000;

                let mut mem = AllRam::from(include_bytes!("fibonacci.bin"));
                let mut cpu = Gbz80State::default();
                let mut state = <$executor as Executor>::State::default();
                while !cpu.halted {
                    <$executor>::run_single_instruction(&mut (&mut cpu, &mut mem, &mut state));
                }

                let (mut f1, mut f2) = (0, 1);
                for (i, fib) in iter::from_fn(move || {
                    let res = f1;
                    f1 += f2;
                    mem::swap(&mut f1, &mut f2);
                    Some(res)
                })
                .enumerate()
                {
                    if fib > u8::MAX as u32 {
                        break;
                    }
                    assert_eq!(mem.read_byte(OUTPUT + i as u16), fib as u8);
                }
            }

            #[test]
            fn fibonacci16() {
                const OUTPUT: u16 = 0xC000;

                let mut mem = AllRam::from(include_bytes!("fibonacci16.bin"));
                let mut cpu = Gbz80State::default();
                let mut state = <$executor as Executor>::State::default();
                while !cpu.halted {
                    <$executor>::run_single_instruction(&mut (&mut cpu, &mut mem, &mut state));
                }

                let (mut f1, mut f2) = (0u32, 1);
                for (i, fib) in iter::from_fn(move || {
                    let res = f1;
                    f1 += f2;
                    mem::swap(&mut f1, &mut f2);
                    Some(res)
                })
                .enumerate()
                {
                    if fib > u16::MAX as u32 {
                        break;
                    }
                    let val: u16 = mem.read(OUTPUT + i as u16 * 2);
                    assert_eq!(val, fib as u16);
                }
            }

            #[test]
            fn squares() {
                const OUTPUT: u16 = 0xC000;

                let mut mem = AllRam::from(include_bytes!("squares.bin"));
                let mut cpu = Gbz80State::default();
                let mut state = <$executor as Executor>::State::default();
                while !cpu.halted {
                    <$executor>::run_single_instruction(&mut (&mut cpu, &mut mem, &mut state));
                }

                for (i, square) in (1..).map(|x| x * x).enumerate() {
                    if square > u8::MAX as u32 {
                        break;
                    }
                    assert_eq!(mem.read_byte(OUTPUT + i as u16), square as u8);
                }
            }

            #[cfg(feature = "test-roms")]
            mod test_roms {
                use std::ops::ControlFlow;

                use feo3boy::gb::Gb;
                use feo3boy::memdev::{BiosRom, Cartridge};

                use super::*;
                use crate::test_roms::check_cpu_instrs_output;

                /// Run the "cpu_instrs" cartridge.
                #[test]
                fn cpu_instrs() {
                    let cart = Cartridge::parse(&include_bytes!("cpu_instrs.gb")[..]).unwrap();
                    let bios = BiosRom::new(*include_bytes!("bios.bin"));

                    let mut gb =
                        Box::new(Gb::<$executor>::for_executor(bios.clone(), cart.clone()));
                    let mut output = Vec::new();

                    loop {
                        output.extend(gb.serial.stream.receive_bytes());
                        let output = String::from_utf8_lossy(&output);
                        if let ControlFlow::Break(()) = check_cpu_instrs_output(output.as_ref()) {
                            break;
                        }
                        <$executor>::run_single_instruction(&mut *gb);
                    }
                }
            }
        }
    };
}

executor_tests!(DirectExecutor, direct_executor);
executor_tests!(MicrocodeExecutor, microcode_executor);
executor_tests!(DirectExecutorV2, direct_executor_v2);
executor_tests!(SteppingExecutor, stepping_executor);

/// Tests which depend on the cpu_instrs.gb test rom. cpu_instrs is not included in the
/// repository for licensing reasons. Copy it to this folder before trying to run these
/// tests.
#[cfg(feature = "test-roms")]
mod test_roms {
    use std::ops::ControlFlow;

    use feo3boy::gb::Gb;
    use feo3boy::gbz80core::direct_executor::DirectExecutor;
    use feo3boy::gbz80core::direct_executor_v2::DirectExecutorV2;
    use feo3boy::gbz80core::executor::Executor;
    use feo3boy::gbz80core::microcode_executor::MicrocodeExecutor;
    use feo3boy::gbz80core::stepping_executor::SteppingExecutor;
    use feo3boy::memdev::{BiosRom, Cartridge, RootMemDevice};
    use feo3boy_opcodes::opcode::Opcode;

    /// Checks if output matches the cpu_instrs output. Returns break when at the end of
    /// the passing output.
    pub fn check_cpu_instrs_output(output: &str) -> ControlFlow<()> {
        // There are two extra spaces on the end of the line of test outputs, which we
        // make clear by escaping them as \u{0020}
        const EXPECTED: &'static str = "cpu_instrs

01:ok  02:ok  03:ok  04:ok  05:ok  06:ok  07:ok  08:ok  09:ok  10:ok  11:ok\u{0020}\u{0020}

Passed all tests";
        if output.len() < EXPECTED.len() {
            assert!(
                EXPECTED.starts_with(output),
                "Output was not a prefix of expected.\nExpected:\n{}\n\nOutput:\n{}",
                EXPECTED,
                output
            );
        } else if output.len() == EXPECTED.len() {
            assert_eq!(EXPECTED, output);
            return ControlFlow::Break(());
        } else {
            panic!(
                "Output is longer than expected.\nExpected:\n{}\n\nOutput:\n{}",
                EXPECTED, output
            );
        }
        ControlFlow::Continue(())
    }

    /// Run the "cpu_instrs" comparing state between microcode and direct execution.
    #[test]
    fn cpu_instrs_comparison() {
        let cart = Cartridge::parse(&include_bytes!("cpu_instrs.gb")[..]).unwrap();
        let bios = BiosRom::new(*include_bytes!("bios.bin"));

        let mut gb_direct = Box::new(Gb::new(bios.clone(), cart.clone()));
        let mut gb_microcode = Box::new(Gb::new_microcode(bios.clone(), cart.clone()));
        let mut gb_direct_v2 = Box::new(Gb::new_v2(bios.clone(), cart.clone()));
        let mut gb_stepping = Box::new(Gb::new_stepping(bios.clone(), cart.clone()));
        let mut output_direct = Vec::new();
        let mut output_microcode = Vec::new();
        let mut output_direct_v2 = Vec::new();
        let mut output_stepping = Vec::new();

        loop {
            output_direct.extend(gb_direct.serial.stream.receive_bytes());
            output_microcode.extend(gb_microcode.serial.stream.receive_bytes());
            output_direct_v2.extend(gb_direct_v2.serial.stream.receive_bytes());
            output_stepping.extend(gb_stepping.serial.stream.receive_bytes());

            let ex_pc = gb_direct.cpustate.regs.pc;
            let instr_direct = Opcode::decode(gb_direct.mmu.read_byte(ex_pc));
            let instr_microcode = Opcode::decode(gb_microcode.mmu.read_byte(ex_pc));
            let instr_direct_v2 = Opcode::decode(gb_direct_v2.mmu.read_byte(ex_pc));
            let instr_stepping = Opcode::decode(gb_stepping.mmu.read_byte(ex_pc));
            DirectExecutor::run_single_instruction(&mut *gb_direct);
            MicrocodeExecutor::run_single_instruction(&mut *gb_microcode);
            DirectExecutorV2::run_single_instruction(&mut *gb_direct_v2);
            SteppingExecutor::run_single_instruction(&mut *gb_stepping);
            assert!(
                gb_direct.cpustate == gb_microcode.cpustate
                    && gb_direct.cpustate == gb_direct_v2.cpustate
                    && gb_direct.cpustate == gb_stepping.cpustate,
                "Mismatch after PC {}: {}/{}/{}/{}\nDirect: {:?}\nMicrodode: {:?}\n\
                Direct V2: {:?}\nStepping: {:?}",
                ex_pc,
                instr_direct,
                instr_microcode,
                instr_direct_v2,
                instr_stepping,
                gb_direct.cpustate,
                gb_microcode.cpustate,
                gb_direct_v2.cpustate,
                gb_stepping.cpustate,
            );

            let output_direct = String::from_utf8_lossy(&output_direct);
            let output_microcode = String::from_utf8_lossy(&output_microcode);
            let output_direct_v2 = String::from_utf8_lossy(&output_direct_v2);
            let output_stepping = String::from_utf8_lossy(&output_stepping);
            assert_eq!(output_direct, output_microcode);
            assert_eq!(output_direct, output_direct_v2);
            assert_eq!(output_direct, output_stepping);
            if let ControlFlow::Break(()) = check_cpu_instrs_output(output_direct.as_ref()) {
                break;
            }
        }
    }
}