314 lines
8.8 KiB
OCaml
314 lines
8.8 KiB
OCaml
open Printf
|
|
|
|
(** http://bgb.bircd.org/pandocs.htm#cpuregistersandflags
|
|
http://gameboy.mongenel.com/dmg/lesson1.html *)
|
|
|
|
type registers = {
|
|
mutable a : char; (* accumulator *)
|
|
mutable f : char; (* flags *)
|
|
mutable b : char;
|
|
mutable c : char;
|
|
mutable d : char;
|
|
mutable e : char;
|
|
mutable h : char;
|
|
mutable l : char;
|
|
|
|
mutable sp : int; (* stack pointer *)
|
|
mutable pc : int; (* program counter *)
|
|
}
|
|
|
|
type flags = {
|
|
mutable z : bool; (* zero *)
|
|
mutable n : bool; (* substraction *)
|
|
mutable h : bool; (* half-carry *)
|
|
mutable c : bool; (* carry *)
|
|
}
|
|
|
|
type t = {
|
|
reg : registers;
|
|
flag : flags;
|
|
mutable cycles : int;
|
|
}
|
|
|
|
let print_cpu_state cpu =
|
|
printf "[Cpu state] Registers:\n";
|
|
printf "[Cpu state] \tA: 0x%02X \tF: 0x%02X\n" (int_of_char cpu.reg.a) (int_of_char cpu.reg.f);
|
|
printf "[Cpu state] \tB: 0x%02X \tC: 0x%02X\n" (int_of_char cpu.reg.b) (int_of_char cpu.reg.c);
|
|
printf "[Cpu state] \tD: 0x%02X \tE: 0x%02X\n" (int_of_char cpu.reg.d) (int_of_char cpu.reg.e);
|
|
printf "[Cpu state] \tH: 0x%02X \tL: 0x%02X\n" (int_of_char cpu.reg.h) (int_of_char cpu.reg.l);
|
|
printf "[Cpu state] \tPC: 0x%04X\n" cpu.reg.pc;
|
|
printf "[Cpu state] \tSP: 0x%04X\n" cpu.reg.sp;
|
|
|
|
printf "[Cpu state] Flags:\n";
|
|
printf "[Cpu state] \t ZNHC\n";
|
|
let z = if cpu.flag.z then 1 else 0 in
|
|
let n = if cpu.flag.n then 1 else 0 in
|
|
let h = if cpu.flag.h then 1 else 0 in
|
|
let c = if cpu.flag.c then 1 else 0 in
|
|
printf "[Cpu state] \t[%d%d%d%d]\n" z n h c
|
|
|
|
(** http://bgb.bircd.org/pandocs.htm#powerupsequence *)
|
|
let init_registers =
|
|
{
|
|
a = '\x00';
|
|
f = '\x00';
|
|
b = '\x00';
|
|
c = '\x00';
|
|
d = '\x00';
|
|
e = '\x00';
|
|
h = '\x00';
|
|
l = '\x00';
|
|
sp = 0xFFFE;
|
|
pc = 0x0100;
|
|
}
|
|
|
|
let init_flags =
|
|
{
|
|
z = false; n = false; h = false; c = false
|
|
}
|
|
|
|
let init_cpu =
|
|
{ reg = init_registers; flag = init_flags; cycles = 0 }
|
|
|
|
let update_flag_reg cpu =
|
|
let z = if cpu.flag.z then 0b10000000 else 0 in
|
|
let n = if cpu.flag.n then 0b01000000 else 0 in
|
|
let h = if cpu.flag.h then 0b00100000 else 0 in
|
|
let c = if cpu.flag.c then 0b00010000 else 0 in
|
|
cpu.reg.f <- char_of_int @@ z + n + h + c
|
|
|
|
let inc_pc cpu count =
|
|
cpu.reg.pc <- (cpu.reg.pc + count) mod 0xFFFF
|
|
|
|
let inc_cycles cpu count =
|
|
cpu.cycles <- cpu.cycles + count
|
|
|
|
let merge_bytes low high =
|
|
(int_of_char high) * 256 + (int_of_char low)
|
|
|
|
let split_2B x =
|
|
let low = x mod 256 |> char_of_int in
|
|
let high = x / 256 |> char_of_int in
|
|
(high, low)
|
|
|
|
let read_2B m addr =
|
|
let low = Memory.get m addr in
|
|
let high = Memory.get m (addr + 1) in
|
|
merge_bytes low high
|
|
|
|
let inc_BC cpu =
|
|
let v = merge_bytes cpu.reg.c cpu.reg.b in
|
|
let low, high = split_2B (v + 1) in
|
|
cpu.reg.c <- low;
|
|
cpu.reg.b <- high
|
|
|
|
let cmp_A cpu n =
|
|
let diff = int_of_char (cpu.reg.a) - n in
|
|
cpu.flag.z <- diff = 0;
|
|
cpu.flag.n <- true;
|
|
cpu.flag.h <- diff > 0x0F || diff < 0;
|
|
cpu.flag.c <- diff > 0xFF || diff < 0;
|
|
update_flag_reg cpu
|
|
|
|
let read_pc_byte cpu mem =
|
|
let b = Memory.get mem cpu.reg.pc in
|
|
inc_pc cpu 1;
|
|
int_of_char b
|
|
|
|
let read_pc_2bytes cpu mem =
|
|
let word = read_2B mem cpu.reg.pc in
|
|
inc_pc cpu 2;
|
|
word
|
|
|
|
let pop_stack cpu mem =
|
|
let low = Memory.get mem cpu.reg.sp in
|
|
cpu.reg.sp <- (cpu.reg.sp + 1) mod 0xFFFF;
|
|
let high = Memory.get mem cpu.reg.sp in
|
|
cpu.reg.sp <- (cpu.reg.sp + 1) mod 0xFFFF;
|
|
merge_bytes low high
|
|
|
|
|
|
|
|
(**
|
|
http://imrannazar.com/GameBoy-Z80-Opcode-Map
|
|
https://github.com/sinamas/gambatte/blob/master/libgambatte/src/cpu.cpp
|
|
*)
|
|
let run cpu (mem: Memory.map) =
|
|
printf "\n";
|
|
print_cpu_state cpu;
|
|
let opcode = read_pc_byte cpu mem |> char_of_int in
|
|
(* Hexa.print_slice cartridge.full_rom cpu.reg.pc (cpu.reg.pc + 7); *)
|
|
|
|
let inst = match opcode with
|
|
|
|
(* 8-bit load *)
|
|
(* LD r,(HL) *)
|
|
| '\x7E' -> let inst = sprintf "LD \tA, (HL)" in
|
|
let hl = merge_bytes cpu.reg.l cpu.reg.h in
|
|
cpu.reg.a <- Memory.get mem hl;
|
|
inc_cycles cpu 8;
|
|
inst
|
|
|
|
| '\x36' -> let n = read_pc_byte cpu mem in
|
|
let inst = sprintf "LD \t(HL) 0x%02X" n in
|
|
let hl = merge_bytes cpu.reg.l cpu.reg.h in
|
|
Memory.set mem hl (char_of_int n);
|
|
inc_cycles cpu 12;
|
|
inst
|
|
|
|
|
|
(* CPU control *)
|
|
| '\x00' -> let inst = sprintf "NOP" in
|
|
inc_cycles cpu 4;
|
|
inst
|
|
|
|
|
|
(* jump *)
|
|
| '\x20' -> let n = read_pc_byte cpu mem in
|
|
let inst = sprintf "JR \tNZ, 0x%02X" n in
|
|
if cpu.flag.z = false then
|
|
begin
|
|
inc_pc cpu (n - 1); inc_cycles cpu 12;
|
|
end else
|
|
inc_cycles cpu 8;
|
|
inst
|
|
|
|
| '\xC9' -> let inst = sprintf "RET" in
|
|
cpu.reg.pc <- pop_stack cpu mem;
|
|
inc_cycles cpu 16;
|
|
inst
|
|
|
|
| '\xC0' -> let inst = sprintf "RET \tNZ" in
|
|
if cpu.flag.z = false then
|
|
begin
|
|
cpu.reg.pc <- pop_stack cpu mem;
|
|
inc_cycles cpu 20;
|
|
end else
|
|
inc_cycles cpu 8;
|
|
inst
|
|
|
|
|
|
|
|
| '\x03' -> let inst = sprintf "INC \tBC" in
|
|
inc_BC cpu;
|
|
inc_cycles cpu 8;
|
|
inst
|
|
|
|
| '\x05' -> let inst = sprintf "DEC \tB" in
|
|
let dec = int_of_char(cpu.reg.b) - 1 in
|
|
cpu.flag.z <- dec = 0;
|
|
cpu.flag.n <- true;
|
|
cpu.flag.h <- dec < 0;
|
|
cpu.reg.b <- char_of_int @@ if dec >= 0 then dec else 0;
|
|
inc_cycles cpu 4;
|
|
inst
|
|
|
|
| '\x06' -> let n = read_pc_byte cpu mem in
|
|
let inst = sprintf "LD \tB, 0x%02X" n in
|
|
cpu.reg.b <- char_of_int n;
|
|
inc_cycles cpu 8;
|
|
inst
|
|
|
|
| '\x18' -> let n = read_pc_byte cpu mem in
|
|
let inst = sprintf "JP \t0x%02X" n in
|
|
inc_pc cpu (n - 1); inc_cycles cpu 12;
|
|
inst
|
|
|
|
| '\x21' -> let nn = read_pc_2bytes cpu mem in
|
|
let inst = sprintf "LD \tHL, 0x%04X" nn in
|
|
let high, low = split_2B nn in
|
|
cpu.reg.h <- high;
|
|
cpu.reg.l <- low;
|
|
inc_cycles cpu 12;
|
|
inst
|
|
|
|
| '\x22' -> let inst = sprintf "LDI \t(HL), A" in
|
|
let hl = merge_bytes cpu.reg.l cpu.reg.h in
|
|
Memory.set mem hl cpu.reg.a;
|
|
let high, low = split_2B (hl + 1) in
|
|
cpu.reg.h <- high;
|
|
cpu.reg.l <- low;
|
|
inc_cycles cpu 8;
|
|
inst
|
|
|
|
|
|
| '\x28' -> let n = read_pc_byte cpu mem in
|
|
let inst = sprintf "JR \tZ, 0x%02X" n in
|
|
if cpu.flag.z = true then
|
|
begin
|
|
inc_pc cpu (n - 1); inc_cycles cpu 12;
|
|
end else
|
|
inc_cycles cpu 8;
|
|
inst
|
|
|
|
| '\x34' -> let inst = sprintf "INC \t(HL)" in
|
|
let hl = merge_bytes cpu.reg.l cpu.reg.h in
|
|
let v = Memory.get mem hl |> int_of_char in
|
|
cpu.flag.z <- v + 1 = 0;
|
|
cpu.flag.n <- false;
|
|
cpu.flag.h <- v = 0b00001111;
|
|
Memory.set mem hl (char_of_int (v + 1));
|
|
inc_cycles cpu 12;
|
|
inst
|
|
|
|
|
|
| '\x3E' -> let n = read_pc_byte cpu mem in
|
|
let inst = sprintf "LD \tA, 0x%02X" n in
|
|
cpu.reg.a <- char_of_int n;
|
|
inc_cycles cpu 8;
|
|
inst
|
|
|
|
| '\xAF' -> let inst = sprintf "XOR \tA, A" in
|
|
let int_A = int_of_char cpu.reg.a in
|
|
cpu.reg.a <- char_of_int @@ int_A lxor int_A;
|
|
inc_cycles cpu 4;
|
|
inst
|
|
|
|
| '\xC3' -> let addr = read_pc_2bytes cpu mem in
|
|
let inst = sprintf "JP \t0x%04X" addr in
|
|
cpu.reg.pc <- addr; inc_cycles cpu 16;
|
|
inst
|
|
|
|
| '\xE0' -> let n = read_pc_byte cpu mem in
|
|
let inst = sprintf "LDH \t(0xFF%02X), A" n in
|
|
Memory.set mem (0xFF00 + n) cpu.reg.a;
|
|
inc_cycles cpu 12;
|
|
inst
|
|
|
|
| '\xEA' -> let addr = read_pc_2bytes cpu mem in
|
|
let inst = sprintf "LD \t(0X%04X), A" addr in
|
|
Memory.set mem addr cpu.reg.a;
|
|
inc_cycles cpu 16;
|
|
inst
|
|
|
|
|
|
| '\xF0' -> let n = read_pc_byte cpu mem in
|
|
let inst = sprintf "LDH \tA, (0xFF%02X)" n in
|
|
cpu.reg.a <- Memory.get mem (0xFF00 + n);
|
|
inc_cycles cpu 12;
|
|
inst
|
|
|
|
| '\xF3' -> let inst = sprintf "DI" in
|
|
(* fixme *)
|
|
inc_cycles cpu 4;
|
|
inst
|
|
|
|
| '\xFE' -> let n = read_pc_byte cpu mem in
|
|
let inst = sprintf "CP \t0x%02X" n in
|
|
cmp_A cpu n;
|
|
inc_cycles cpu 8;
|
|
inst
|
|
|
|
| '\xFB' -> let inst = sprintf "EI" in
|
|
(* enable interrupts, IME=1 *)
|
|
inc_cycles cpu 4;
|
|
inst
|
|
|
|
| x -> eprintf "opcode 0x%02X\n" (int_of_char x);
|
|
eprintf "#cycles: %d\n" cpu.cycles;
|
|
failwith "Unimplemented opcode."
|
|
|
|
in
|
|
|
|
printf "[Instruction] %s\n" inst
|