z80

package module
v0.10.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 24, 2024 License: MIT Imports: 6 Imported by: 4

README

koron-go/z80

PkgGoDev Actions/Go Go Report Card

Z80 emulation in Go.

koron-go/z80 is highly compatible with the actual Z80, and is extremely fast.

Getting started

Install or update:

$ go get github.com/koron-go/z80@latest

(WRITE MINIMAL SAMPLE CODES HERE)

Compatibility

Z80 instruction set exerciser (documented), passed all 67/67 (100%) tests.

You can try it with...

$ make zexdoc

Z80 instruction set exerciser (all), passed all 67/67 (100%) tests.

You can try it with...

$ make zexall
  • adc16 - <adc,sbc> hl,<bc,de,hl,sp> (38,912 cycles)
  • add16 - add hl,<bc,de,hl,sp> (19,456 cycles)
  • add16x - add ix,<bc,de,ix,sp> (19,456 cycles)
  • add16y - add iy,<bc,de,iy,sp> (19,456 cycles)
  • alu8i - aluop a,nn (28,672 cycles)
  • alu8r - aluop a,<b,c,d,e,h,l,(hl),a> (753,664 cycles)
  • alu8rx - aluop a,<ixh,ixl,iyh,iyl> (376,832 cycles)
  • alu8x - aluop a,(<ix,iy>+1) (229,376 cycles)
  • bitx - bit n,(<ix,iy>+1) (2048 cycles)
  • bitz80 - bit n,<b,c,d,e,h,l,(hl),a> (49,152 cycles)
  • cpd1 - cpd<r> (1) (6144 cycles)
  • cpi1 - cpi<r> (1) (6144 cycles)
  • daaop - <daa,cpl,scf,ccf> (65,536 cycles)
  • inca - <inc,dec> a (3072 cycles)
  • incb - <inc,dec> b (3072 cycles)
  • incbc - <inc,dec> bc (1536 cycles)
  • incc - <inc,dec> c (3072 cycles)
  • incd - <inc,dec> d (3072 cycles)
  • incde - <inc,dec> de (1536 cycles)
  • ince - <inc,dec> e (3072 cycles)
  • inch - <inc,dec> h (3072 cycles)
  • inchl - <inc,dec> hl (1536 cycles)
  • incix - <inc,dec> ix (1536 cycles)
  • inciy - <inc,dec> iy (1536 cycles)
  • incl - <inc,dec> l (3072 cycles)
  • incm - <inc,dec> (hl) (3072 cycles)
  • incsp - <inc,dec> sp (1536 cycles)
  • incx - <inc,dec> (<ix,iy>+1) (6144 cycles)
  • incxh - <inc,dec> ixh (3072 cycles)
  • incxl - <inc,dec> ixl (3072 cycles)
  • incyh - <inc,dec> iyh (3072 cycles)
  • incyl - <inc,dec> iyl (3072 cycles)
  • ld161 - ld <bc,de>,(nnnn) (32 cycles)
  • ld162 - ld hl,(nnnn) (16 cycles)
  • ld163 - ld sp,(nnnn) (16 cycles)
  • ld164 - ld <ix,iy>,(nnnn) (32 cycles)
  • ld165 - ld (nnnn),<bc,de> (64 cycles)
  • ld166 - ld (nnnn),hl (16 cycles)
  • ld167 - ld (nnnn),sp (16 cycles)
  • ld168 - ld (nnnn),<ix,iy> (64 cycles)
  • ld16im - ld <bc,de,hl,sp>,nnnn (64 cycles)
  • ld16ix - ld <ix,iy>,nnnn (32 cycles)
  • ld8bd - ld a,<(bc),(de)> (44 cycles)
  • ld8im - ld <b,c,d,e,h,l,(hl),a>,nn (64 cycles)
  • ld8imx - ld (<ix,iy>+1),nn (32 cycles)
  • ld8ix1 - ld <b,c,d,e>,(<ix,iy>+1) (512 cycles)
  • ld8ix2 - ld <h,l>,(<ix,iy>+1) (256 cycles)
  • ld8ix3 - ld a,(<ix,iy>+1) (128 cycles)
  • ld8ixy - ld <ixh,ixl,iyh,iyl>,nn (32 cycles)
  • ld8rr - ld <b,c,d,e,h,l,a>,<b,c,d,e,h,l,a> (3456 cycles)
  • ld8rrx - ld <b,c,d,e,ixy,a>,<b,c,d,e,ixy,a> (6912 cycles)
  • lda - ld a,(nnnn) / ld (nnnn),a (44 cycles)
  • ldd1 - ldd<r> (1) (44 cycles)
  • ldd2 - ldd<r> (2) (44 cycles)
  • ldi1 - ldi<r> (1) (44 cycles)
  • ldi2 - ldi<r> (2) (44 cycles)
  • negop - neg (16,384 cycles)
  • rldop - <rld,rrd> (7168 cycles)
  • rot8080 - <rlca,rrca,rla,rra> (6144 cycles)
  • rotxy - shift/rotate (<ix,iy>+1) (416 cycles)
  • rotz80 - shift/rotate <b,c,d,e,h,l,(hl),a> (6784 cycles)
  • srz80 - <set,res> n,<b,c,d,e,h,l,(hl),a> (7936 cycles)
  • srzx - <set,res> n,(<ix,iy>+1) (1792 cycles)
  • st8ix1 - ld (<ix,iy>+1),<b,c,d,e> (1024 cycles)
  • st8ix2 - ld (<ix,iy>+1),<h,l> (256 cycles)
  • st8ix3 - ld (<ix,iy>+1),a (64 cycles)
  • stabd - ld (<bc,de>),a (96 cycles)

References

Japanese documents

Documentation

Overview

Package z80 emulates Zilog's Z80 CPU.

Index

Constants

This section is empty.

Variables

View Source 
var ErrBreakPoint = errors.New("break point reached")

ErrBreakPoint shows PC is reached to one of break points.

Functions

This section is empty.

Types

type CPU 

type CPU struct {
	States

	Memory Memory
	IO     IO

	// RETNHandle is called when CPU execute a RETN op.
	RETNHandler RETNHandler
	// RETIHandle is called when CPU execute a RETI op.
	RETIHandler RETIHandler

	// Interrupt is a signal to interrupt.  When you set non-nil value, then
	// CPU.Step and CPU.Run treat it as one of Z80 interruptions.
	Interrupt *Interrupt

	BreakPoints map[uint16]struct{}

	// HALT indicates whether the last Run() is terminated with HALT op.
	HALT bool
}

CPU is the core of Z80 emulator.

func (*CPU) Run 

func (cpu *CPU) Run(ctx context.Context) error

Run executes instructions till HALT or error.

func (*CPU) Step 

func (cpu *CPU) Step()

Step executes an instruction.

type DumbIO 

type DumbIO []uint8

DumbIO provides IO interface as wrapper of []uint8

func (DumbIO) In 

func (dio DumbIO) In(addr uint8) uint8

In gets a byte at addr of IO

func (DumbIO) Out 

func (dio DumbIO) Out(addr uint8, value uint8)

Out sets a byte at addr of IO

type DumbMemory 

type DumbMemory []uint8

DumbMemory provides Memory interface as wrapper of []uint8

func (DumbMemory) Get 

func (dm DumbMemory) Get(addr uint16) uint8

Get gets a byte at addr of memory.

func (DumbMemory) Put 

func (dm DumbMemory) Put(addr uint16, data ...uint8) DumbMemory

Put puts "data" block from addr.

func (DumbMemory) Set 

func (dm DumbMemory) Set(addr uint16, value uint8)

Set sets a byte at addr of memory.

type Flag added in v0.10.1 

type Flag uint8

Flag is the flag value used for GetFlag etc. Each value can be combined with the OR (|) operator. 

const (
	FlagC  Flag = 0x01 // FlagC is carry flag.
	FlagN  Flag = 0x02 // FlagN is subtract flag.
	FlagPV Flag = 0x04 // FlagPV is parity/overflow flag.
	FlagH  Flag = 0x10 // FlagH is half carry flag.
	FlagZ  Flag = 0x40 // FlagZ is zero flag.
	FlagS  Flag = 0x80 // FlagS is sign flag.

	Flag3 Flag = 0x08 // Flag3 is undefined flag, at 3rd from LSB.
	Flag5 Flag = 0x20 // Flag5 is undefined flag, at 5th from LSB.
)

type GPR 

type GPR struct {
	AF Register
	BC Register
	DE Register
	HL Register
}

GPR is general purpose reigsters, pair of four registers AF, BC, DE and HL.

func (GPR) GetFlag added in v0.10.1 

func (gpr GPR) GetFlag(f Flag) bool

GetFlag gets a flag status. For available flags, see Flag type. When multiple flags are combined, if any one of them is true, this returns true.

func (*GPR) ResetFlag added in v0.10.1 

func (gpr *GPR) ResetFlag(f Flag)

ResetFlag resets the specified flag to false. Fo available flags, see Flag type. When multiple flags are combined, all flags are set to false.

func (*GPR) SetFlag added in v0.10.1 

func (gpr *GPR) SetFlag(f Flag)

SetFlag sets the specified flag to true. For available flags, see Flag type. When multiple flags are combined, all flags are set to true.

type INT 

type INT interface {
	// CheckINT should return valid interruption data if maskable interruption
	// made. The data is used for interruption codes or as a vector depending
	// on interruption mode.
	CheckINT() []uint8

	// ReturnINT is called when "RETI" op is executed.
	ReturnINT()
}

INT is interface for maskable interrupt.

type IO 

type IO interface {
	In(addr uint8) uint8
	Out(addr uint8, value uint8)
}

IO is requirements interface for I/O.

type Interrupt added in v0.10.0 

type Interrupt struct {
	Type InterruptType
	Data []uint8
}

Interrupt is interruption signal. Put a point of Interrupt to CPU.Interrupt, when you want to make an interrupt.

func IM0Interrupt added in v0.10.0 

func IM0Interrupt(d uint8, others ...uint8) *Interrupt

IM0Interrupt creates an Interrupt object for IM0.

func IM1Interrupt added in v0.10.0 

func IM1Interrupt() *Interrupt

IM1Interrupt creates an Interrupt object for IM1.

func IM2Interrupt added in v0.10.0 

func IM2Interrupt(n uint8) *Interrupt

IM2Interrupt creates an Interrupt object for IM2.

func NMIInterrupt added in v0.10.0 

func NMIInterrupt() *Interrupt

NMIInterrupt creates a Interrupt objct for NMI.

type InterruptType added in v0.10.0 

type InterruptType int

InterruptType is type of interruption. 

const (
	// NMIType is a type of NMI interruption.
	NMIType InterruptType = iota
	// IMType is a type of normal interruptions.
	IMType
)

type MapMemory 

type MapMemory map[uint16]uint8

MapMemory implements Memory interface with a map.

func (MapMemory) Clear 

func (mm MapMemory) Clear()

Clear removes all.

func (MapMemory) Clone 

func (mm MapMemory) Clone() MapMemory

Clone creates a clone of this.

func (MapMemory) Equal 

func (mm MapMemory) Equal(a0 interface{}) bool

Equal checks two MapMemory same or not.

func (MapMemory) Get 

func (mm MapMemory) Get(addr uint16) uint8

Get gets a byte at addr of memory.

func (MapMemory) Put 

func (mm MapMemory) Put(addr uint16, data ...uint8) MapMemory

Put puts "data" block from addr.

func (MapMemory) Set 

func (mm MapMemory) Set(addr uint16, v uint8)

Set sets a byte at addr of memory.

type Memory 

type Memory interface {
	Get(addr uint16) uint8
	Set(addr uint16, value uint8)
}

Memory is requirements interface for memory.

type NMI 

type NMI interface {
	// CheckNMI should return true if non-maskable interruption made.
	CheckNMI() bool

	// ReturnNMI is called when "RETN" op is executed.
	ReturnNMI()
}

NMI is interruption for non-maskable interrupt.

type RETIHandler added in v0.10.0 

type RETIHandler interface {
	RETIHandle()
}

RETIHandler will be called before execute RETI opcode.

type RETNHandler added in v0.10.0 

type RETNHandler interface {
	RETNHandle()
}

RETNHandler will be called before execute RETN opcode.

type Register 

type Register struct {
	Hi uint8
	Lo uint8
}

Register is 16 bits register.

func (*Register) SetU16 

func (r *Register) SetU16(v uint16)

SetU16 updates 16 bits value of this register.

func (Register) U16 

func (r Register) U16() uint16

U16 gets 16 bits value of this register.

type SPR 

type SPR struct {
	IR Register
	IX uint16
	IY uint16
	SP uint16
	PC uint16
}

SPR is special purpose registers.

type States 

type States struct {
	GPR
	SPR

	Alternate GPR

	IFF1 bool
	IFF2 bool
	IM   int
}

States is collection of Z80's internal state.

Source Files

View all Source files

Directories

Path Synopsis
cmd
cim2bin
cim2cas
convert_case
zexdoc
internal
tinycpm
Package tinycpm provides minimal CP/M compatible BIOS to run Z80 Exerciser tests.
 Package tinycpm provides minimal CP/M compatible BIOS to run Z80 Exerciser tests.
zex
Package zex provides test cases of Z80 Exerciser.
 Package zex provides test cases of Z80 Exerciser.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.