hg80 1.0.0

Z80 and Z80N CPU core, stepped one clock edge at a time
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

use super::*;

#[test]
fn setting_the_carry_reports_the_undocumented_flags_from_the_accumulator_and_the_flags() {
    let (cpu, _, _) = run_from(&[0x37], |cpu| cpu.registers_mut().af = 0x00FF, 1);
    assert_eq!(cpu.registers().af, 0x00ED);

    let (cpu, _, _) = run_from(&[0x37], |cpu| cpu.registers_mut().af = 0xFF00, 1);
    assert_eq!(cpu.registers().af, 0xFF29);
}

#[test]
fn complementing_the_carry_reports_them_the_same_way() {
    let (cpu, _, _) = run_from(&[0x3F], |cpu| cpu.registers_mut().af = 0x005B, 1);
    assert_eq!(cpu.registers().af, 0x0058);
}

#[test]
fn a_displaced_bit_test_takes_its_undocumented_flags_from_the_address() {
    let mut program = vec![0xDD, 0xCB, 0x00, 0x46];
    program.resize(0x2801, 0);
    program[0x2800] = 0x01;
    let (cpu, _, t) = run_from(
        &program,
        |cpu| {
            cpu.registers_mut().ix = 0x2800;
        },
        1,
    );
    assert_eq!(t, 20);
    assert_eq!(cpu.flags() & crate::flag::Z_MASK, 0);
    assert_eq!(cpu.flags() & crate::flag::XY_MASK, crate::flag::XY_MASK);
    assert_eq!(cpu.flags() & crate::flag::H_MASK, crate::flag::H_MASK);
    assert_eq!(cpu.flags() & crate::flag::N_MASK, 0);
}

#[test]
fn a_displaced_bit_test_reports_a_clear_bit_through_the_zero_flag() {
    let mut program = vec![0xDD, 0xCB, 0x00, 0x4E];
    program.resize(0x2801, 0);
    program[0x2800] = 0x01;
    let (cpu, _, _) = run_from(
        &program,
        |cpu| {
            cpu.registers_mut().ix = 0x2800;
        },
        1,
    );
    assert_eq!(cpu.flags() & crate::flag::Z_MASK, crate::flag::Z_MASK);
    assert_eq!(cpu.flags() & crate::flag::P_MASK, crate::flag::P_MASK);
}

#[test]
fn a_bit_test_on_a_register_still_takes_its_flags_from_the_operand() {
    let (cpu, _, _) = run(&[0x3E, 0x28, 0xCB, 0x47], 2);
    assert_eq!(cpu.flags() & crate::flag::XY_MASK, crate::flag::XY_MASK);

    let (cpu, _, _) = run(&[0x3E, 0x01, 0xCB, 0x47], 2);
    assert_eq!(cpu.flags() & crate::flag::XY_MASK, 0);
}

#[test]
fn taking_the_carry_flags_from_the_accumulator_alone_discards_the_incoming_bits() {
    let from_accumulator = |cpu: &mut Cpu| {
        cpu.set_undocumented_flags(crate::UndocumentedFlags::Accumulator);
    };

    let (cpu, _, _) = run_from(
        &[0x37],
        |cpu| {
            from_accumulator(cpu);
            cpu.registers_mut().af = 0x00FF;
        },
        1,
    );
    assert_eq!(cpu.registers().af, 0x00C5);

    let (cpu, _, _) = run_from(
        &[0x3F],
        |cpu| {
            from_accumulator(cpu);
            cpu.registers_mut().af = 0x005B;
        },
        1,
    );
    assert_eq!(cpu.flags() & crate::flag::XY_MASK, 0);

    for opcode in [0x37u8, 0x3F] {
        let (cpu, _, _) = run_from(
            &[opcode],
            |cpu| {
                from_accumulator(cpu);
                cpu.registers_mut().af = 0x0028;
            },
            1,
        );
        assert_eq!(cpu.flags() & crate::flag::XY_MASK, 0, "{opcode:#04X}");

        let (cpu, _, _) = run_from(
            &[opcode],
            |cpu| {
                from_accumulator(cpu);
                cpu.registers_mut().af = 0x2800;
            },
            1,
        );
        assert_eq!(
            cpu.flags() & crate::flag::XY_MASK,
            crate::flag::XY_MASK,
            "{opcode:#04X}"
        );
    }
}

#[test]
fn the_two_flag_sources_are_independent_of_the_instruction_set() {
    let (cpu, _, _) = run_from(
        &[0x37],
        |cpu| {
            cpu.set_z80n_enabled(true);
            cpu.registers_mut().af = 0x00FF;
        },
        1,
    );
    assert_eq!(cpu.registers().af, 0x00ED);
    assert_eq!(cpu.undocumented_flags(), crate::UndocumentedFlags::Combined);
}