ZPU instruction set

Since ZPU is a stack-based processor, all operands are in stack except for load instructions. Similarly, all target for operations is the stack, except for store instructions.

Mnemonic Opcode Description Clocks
BREAKPOINT 00000000 Stop processing or jump to debugger 4
IM x 1xxxxxxx Push or append 7-bit immediate 4
STORESP x 010xxxxx Pop and store to stack with offset 5
LOADSP x 010xxxxx Push value present on stack with offset 4
ADDSP x 0001xxxx Add value present on stack with offset to TOS 6
EMULATE x 001xxxxx Emulate instruction. See emulation table. 4
POPPC 00000100 Pop current value and set PC 5
LOAD 00001000 Pop current value and push memory value 4 (b)
STORE 00001100 Store NOS into memory pointed by TOS, Pop both 6 (b)
PUSHSP 00000010 Push current SP -
POPSP 00001101 Pop and store into SP 5
ADD 00000101 Integer addition 5
AND 00000110 Bitwise AND 5
OR 00000111 Bitwise OR 5
NOT 00001001 Bitwise NOT 4
FLIP 00001010 Flip bits 4
NOP 00001011 NO-Operation 4

Optional instructions (emulated)

Emulation opcodes start at 33, and may be implemented in hardware or use emulation code

Mnemonic Opcode Description Clocks
N/A 33 This instruction is not available
LOADH 34 Load short (a)
STOREH 35 Store short (a)
LESSTHAN 36 Signed less-than comparison (a)
LESSTHANOREQUAL 37 Signed less-than-or-equal comparison (a)
ULESSTHAN 38 Unsigned less-than comparison (a)
ULESSTHANOREQUAL 39 Unsigned less-than-or-equal comparison (a)
SWAP 40 Instruction not implemented
MULT 41 Signed 32-bit multiplication (a)
LSHIFTRIGHT 42 Logical shift right (a)
ASHIFTLEFT 43 Arithmetic shift left (a)
ASHIFTRIGHT 44 Arithmetic shift right (a)
CALL 45 Call function (a)
EQ 46 Comparison equal (a)
NEQ 47 Comparison not equal (a)
NEG 48 Negative (a)
SUB 49 Subtract (a)
XOR 50 Exclusive-OR (a)
LOADB 51 Load byte (a)
STOREB 52 Store byte (a)
DIV 53 Signed 32-bit division (a)
MOD 54 Signed 32-bit modulus (a)
EQBRANCH 55 Branch if equal (a)
NEQBRANCH 56 Branch if not equal (a)
POPPCREL 57 Pop PC relative (a)
CONFIG 58 Internal configuration (a)
PUSHPC (a) 59 Push current PC (a)
SYSCALL (a) 60 System Call (currently not implemented) (a)
PUSHSPADD 61 Push SP + offset 48 (a)
HALFMULT 62 Instruction not implemented
CALLPCREL 63 Call relative function (a)

Instruction details

BREAKPOINT

Purpose
Hardware breakpoint

IM

Purpose
Push or append 7-bit immediate
Description
Push or append 7-bit immediate, specified by the lowermost 7 bits of opcode. If previous instruction was not IM, then immediate value is pushed into stack. If previous instruction was an IM, then current TOS is shifted 7 bits to the left, and immediate value is added to it. Interrupts are disabled while processing IM instructions.
C Algorithm
unsigned offset = opcode & 0x7F; if (idim_flag) { unsigned X = Pop(); Push( ( X << 7 ) | offset ); } else { Push ( offset ); idim_flag = 1; }
Examples
All other instructions reset idim_flag to 0.

LOADSP

Purpose
Push SP-relative value into stack
Description
Push value of memory location SP+xxxxx*4, where xxxxx is a positive integer, onto stack. "xxxxx" are the lowermost 5 bits of opcode, but with most significant bit inverted.
C Algorithm
unsigned offset = ( opcode & 0x1f ) ^ 0x10; Push( MEMORY[SP + offset * 4] );

STORESP

Purpose
Store value in top of stack to SP-relative position
Description
Pop value off stack and store it in the SP+xxxxx*4 memory location, where xxxxx is a positive integer. "xxxxx" are the lowermost 5 bits of opcode, but with most significant bit inverted.
C Algorithm
unsigned X = Pop(); unsigned offset = ( opcode & 0x1f ) ^ 0x10; MEMORY[SP + offset * 4] = X;

ADDSP

Purpose
Add SP-relative value to top of stack
Description
Add value of memory location SP+xxxx*4 to value on top of stack. "xxxx" are the lowermost 4 bits of opcode.
C Algorithm
unsigned offset = ( opcode & 0x0f ); Push( Pop() + MEMORY[SP + offset * 4] );

EMULATE

Purpose

Emulate instruction
Description
Instruction emulation opcode. See emulation table for a list and description of emulated opcodes. Push PC to stack and set PC to 0x0+xxxxx*32. This mnemonic cannot be used directly.
C Algorithm
unsigned offset = ( opcode & 0x1f ); Push( PC ); PC = offset * 32;

POPPC

Purpose

Pop value from stack, and set PC (Program Counter)
Description
This is a jump instruction. Desired location is popped from stack and written to Program Counter.
C Algorithm
PC = Pop();

LOAD

Purpose

Load 32-bit value from memory.
Description
Pops address stored on stack and loads the value of that address onto stack. Bit 0 and 1 of address are always treated as 0(i.e. ignored) by the HDL implementations and C code is guaranteed by the programming model never to use 32 bit LOAD on non-32 bit aligned addresses(i.e. if a program does this, then it has a bug).
C Algorithm
unsigned address = Pop(); Push( MEMORY[ address & ~3 ] );

STORE

Purpose

Store 32-bit value to memory.
Description
Pops address, then value from stack and stores the value into the memory location of the address. Bit 0 and 1 of address are always treated as 0.
C Algorithm
unsigned address = Pop(); unsigned value = Pop(); MEMORY[ address & ~3 ] = value;

PUSHSP

Purpose

Push current stack pointer.
Description
Push current SP (stack pointer) value.
C Algorithm
Push( SP );

POPSP

Purpose

Pop and set stack pointer.
Description
Pops value off top of stack and sets SP to that value. Used to allocate/deallocate space on stack for variables or when changing threads.
C Algorithm
SP = Pop();

ADD

Purpose

Add two values.
Description
Pop two values from stack, add them and push the result.
C Algorithm
unsigned A = Pop(); unsigned B = Pop(); Push( A + B );

AND

Purpose

Bitwise AND two values.
Description
Pop two values from stack, do a bitwise AND and push the result.
C Algorithm
unsigned A = Pop(); unsigned B = Pop(); Push( A & B );

OR

Purpose

Bitwise OR two values.
Description
Pop two values from stack, do a bitwise OR and push the result.
C Algorithm
unsigned A = Pop(); unsigned B = Pop(); Push( A | B );

NOT

Purpose

Bitwise NOT
Description
Pop value from stack, invert all bits and push back
C Algorithm
unsigned A = Pop(); Push( ~A );

FLIP

Purpose

Flip all bits
Description
Reverses the bit order of the value on the stack, i.e. abc->cba, 100->001, 110->011, etc. The raison d'etre for this instruction is mainly to emulate other instructions.
C Algorithm
unsigned A = Pop(); unsigned B = 0; for (i=0; i<32; i++) { if (A & (1<<i)) { B |= (1<<(31-i)); } } Push( B );

NOP

Purpose

No Operation
Description
No Operation. This will still cause idim_flag to be set to 0.