kmx20 cpu

Hardware registers

The kmx20 has 3 hardware registers,

Name	Size	Description
`ip`	Word	Instruction pointer
`dp`	Byte	Data Stack Pointer
`rp`	Byte	Return Stack Pointer

Busses

The kmx20 has 2 data busses.

mem
- Memory bus
- Byte-addressed
- Where data is to be read and writ
  - Numbers greater than 1 byte are stored and read in big-endian order
- Interrupt Vector Table starts at address #00000
- CPU resets to address #00100
- Data stack lives in mem at #40000
  - Word-addressed by dp
- Return stack lives in mem at #40400
  - Word-addressed by rp

+---0x00000---+ <-- IVT
|    (rwx)    |
+---0x00100---+ <-- Boot
|    (rwx)    |
|             |
|             |
.             .
.             .
.             .
|             |
+---0x40000---+ <-- Data Stack
|    (rw-)    |
+---0x40400---+ <-- Return Stack
|    (rw-)    |
+---0x40800---+

io
- Input/Output Bus
- Word-addressed
- Peripherals are directly connected to this bus
- See kip.md for kip computer i/o

Instructions

Instructions take 1 byte in memory. If you looked at an instructions binary representation with letters: KFOOOOOO

K if set will keep all left hand operands. (e.g. (a -- n) becomes (a -- a n))
F if set will flip return and data stacks. (e.g. pb with F puts the next byte on the return stack.)
O is the 5-bit opcode. See the table below.

Opcodes

Op	Stack effect	Description
`np`	`--`	no-op
`ex`	`--`	halt execution
`pb`	`--n`	puts the next byte (8 bits) in memory onto the stack
`ph`	`--n`	^ same but next half-word (16 bits)
`pw`	`--n`	^ same but next word (32 bits)
`pr`	`--n`	puts ip+the next byte plus onto the stack
`fb`	`a--n`	fetches a byte from address `a` and puts it onto the stack
`fh`	`a--n`	^ same but with half-word
`fw`	`a--n`	^ same but with word
`mb`	`n a--`	truncate stack item `n` into a byte and put it in memory address `a
`mh`	`n a--`	^ same but with half-word
`mw`	`n a--`	^ same but with word
`io`	`n p--`	move cell `n` to io port `p`
`ii`	`p--n`	gets cell from io port `p` and pushes it onto the stack
`ss`	`n-~n`	move cell from data stack to return stack
`dr`	`n--`	drop item from data stack
`sw`	`n m--m n`	swap items
`du`	`n--n n`	duplicate item on data stack
`ov`	`n m--n m n`	bring second item on data stack over
`ad`	`n m--n+m`	add
`su`	`n m--n-m`	subtract
`mu`	`n m--n*m`	multiply
`di`	`n m--n/m n%m`	div rem
`an`	`n m--n&m`	bitwise and
`or`	`n m--n\|m`	bitwise or
`xr`	`n m--n^m`	bitwise xor
`sl`	`n m--n<<m`	bitwise shift left
`sr`	`n m--n>>m`	bitwise shift right
`sa`	`n m--n>>>m`	bitwise arithmetic shift right
`eq`	`n m--n==m`	logical equals
`lt`	`n m--n<m`	logical less than
`gt`	`n m--n>m`	logical greater than
`no`	`n--!n`	logical not
`ju`	`a--`	jump to address `a`
`jc`	`n a--`	jump to address `a` if `n!=0`
`ca`	`a-~r`	push ip onto return stack, then jump to address `a`
`cc`	`n a-~r`	push ip onto return stack and jump to address `a` if `n!=0`