Architecture: Processor

The processor reads and evaluates instructions serially from program memory.

Instruction cycle

An instruction value will be read from the memory address currently referenced by the program counter, the program counter will be incremented by 1, and then the processor will evaluate the instruction. This cycle will repeat until an instruction value of zero is encountered, at which point the processor will halt.

Instruction encoding

Instructions for the Bedrock processor are encoded as 8-bit values. The lower five bits of the value determine which operation will be performed, and the higher three bits of the value are mode flags which determine how the operation will be performed.

Return-mode flag

If the return-mode flag is set, the instruction will use the return stack in place of the working stack, and the working stack in place of the return stack.

Literal-mode flag

If the literal-mode flag is set, the first time the instruction would pop a value from a stack, it will instead read a value from the next byte or double of program memory, incrementing the program counter by 1 for each byte read in the process.

Double-mode flag

If the double-mode flag is set, the instruction will operate on double-size values, otherwise the instruction will operate on byte-size values. Some operations use fixed-size values, which will not be affected by this flag. Fixed-size byte values are denoted by a trailing ! in a signature, and fixed-size double values are denoted by a trailing * in a signature.

Operation code

The processor can perform 32 different operations, as per the following table:

Operations

HLT

Halt the processor. If any mode flag is set, do nothing.

The instruction variants DB1, DB2, DB3, DB4, DB5, and DB6 can be used as hooks for implementation defined debug functionality.

JMP

Jump to an address.

The double a is popped from the primary stack. If the double-mode flag is set, the double b is then read from the program counter and pushed to the secondary stack. The double a is then written to the program counter.

JCN

Conditionally jump to an address.

The double a is popped from the primary stack, then the byte t is popped from the primary stack. If the double-mode flag is set and t is not zero, the double b is then read from the program counter and pushed to the secondary stack. If t is not zero, the double a is then written to the program counter.

JCK

Conditionally jump to an address, keeping the test value.

The double a is popped from the primary stack, then the value t is popped from the primary stack, then the value t is written to the primary stack. The double a is then written to the program counter if t is not zero.

LDA

Read a value from program memory.

The double a is popped from the primary stack, and then the value v is read from program memory starting at the memory address referenced by a and is pushed to the primary stack.

STA

Write a value to program memory.

The double a is popped from the primary stack, then the value v is popped from the primary stack, and then the value v is written to program memory starting at the memory address referenced by a.

LDD

Read a value from the device bus.

The byte p is popped from the primary stack, and then the value v is read from the device bus starting at the device port referenced by p and is pushed to the primary stack.

STD

Write a value to the device bus.

The byte p is popped from the primary stack, then the value v is popped from the primary stack, and then the value v is written to the device bus starting at the device port referenced by p.

PSH

Move the top value from one stack to the other.

The value x is popped from the secondary stack, and then the value x is pushed to the primary stack.

POP

Remove the top value of a stack.

The value x is popped from the primary stack.

CPY

Copy the top value from one stack to the other.

The value x is popped from the secondary stack, then the value x is pushed to the secondary stack, and then the value x is pushed to the primary stack.

SPL

Split packed values into multiple bytes.

The value x is popped from the primary stack. For each byte b of x, starting with the high byte, create a byte y where the high four bits of b are the low four bits of y, and push y to the primary stack, then create a byte z where the low four bits of b are the low four bits of z, and push z to the primary stack.

DUP

Duplicate the top value of a stack.

The value x is popped from the primary stack, then the value x is pushed to the primary stack, and then the value x is pushed to the primary stack.

OVR

Duplicate the second value of a stack.

The value y is popped from the primary stack, then the value x is popped from the primary stack, then the value x is pushed to the primary stack, then the value y is pushed to the primary stack, and then the value x is pushed to the primary stack.

SWP

Swap the top two values on a stack.

The value y is popped from the primary stack, then the value x is popped from the primary stack, then the value y is pushed to the primary stack, and then the value x is pushed to the primary stack.

ROT

Rotate the top three values on a stack.

The value z is popped from the primary stack, then the value y is popped from the primary stack, then the value x is popped from the primary stack, then the value y is pushed to the primary stack, then the value z is pushed to the primary stack, and then the value x is pushed to the primary stack.

ADD

Find the sum of two values.

The value y is popped from the primary stack, then the value x is popped from the primary stack, and then the value r is calculated as the wrapped addition of y to x and is pushed to the primary stack.

SUB

Find the difference of two values.

The value y is popped from the primary stack, then the value x is popped from the primary stack, and then the value r is calculated as the wrapped subtraction of y from x and is pushed to the primary stack.

INC

Increment a value by 1.

The value x is popped from the primary stack, and then the value r is calculated as the wrapped addition of 1 to x and is pushed to the primary stack.

DEC

Decrement a value by 1.

The value x is popped from the primary stack, and then the value r is calculated as the wrapped subtraction of 1 from x and is pushed to the primary stack.

LTH

Test if one value is less than another.

The value y is popped from the primary stack, and then the value x is popped from the primary stack. If x is less than y, the byte 0xff is pushed to the primary stack, otherwise the byte 0x00 is pushed to the primary stack.

GTH

Test if one value is greater than another.

The value y is popped from the primary stack, and then the value x is popped from the primary stack. If x is greater than y, the byte 0xff is pushed to the primary stack, otherwise the byte 0x00 is pushed to the primary stack.

EQU

Test if two values are equal.

The value y is popped from the primary stack, and then the value x is popped from the primary stack. If x is equal to y, the byte 0xff is pushed to the primary stack, otherwise the byte 0x00 is pushed to the primary stack.

NQK

Test if two values are inequal, keeping the values.

The value y is popped from the primary stack, then the value x is popped from the primary stack, then the value x is pushed to the primary stack, and then the value y is pushed to the primary stack. If x is not equal to y, the byte 0xff is pushed to the primary stack, otherwise the byte 0x00 is pushed to the primary stack.

IOR

Find the bitwise disjunction of two values. This operation is also known as ‘inclusive-or’.

The value y is popped from the primary stack, and then the value x is popped from the primary stack. The value r is then calculated bitwise, where each bit of r is set only if at least one of the corresponding bits of x and y is set. The value r is then pushed to the primary stack.

XOR

Find the bitwise non-equivalence of two values. This operation is also known as ‘exclusive-or’.

The value y is popped from the primary stack, and then the value x is popped from the primary stack. The value r is then calculated bitwise, where each bit of r is set only if exactly one of the corresponding bits of x and y is set. The value r is then pushed to the primary stack.

AND

Find the bitwise conjunction of two values. This operation is also known as ‘and’.

The value y is popped from the primary stack, and then the value x is popped from the primary stack. The value r is then calculated bitwise, where each bit of r is set only if both of the corresponding bits of x and y are set. The value r is then pushed to the primary stack.

NOT

Find the bitwise compliment of a value. This operation is also known as ‘not’.

The value x is popped from the primary stack. The value r is then calculated bitwise, where each bit of r is set only if the corresponding bit of x is not set. The value r is then pushed to the primary stack.

SHF

Shift the bits of a value.

The byte y is popped from the primary stack, then the value x is popped from the primary stack. The value r is calculated from x by shifting the bits of x rightwards by a distance represented by the lower four bits of y, and then by shifting the resultant bits leftwards by a distance represented by the higher four bits of y. The value r is then pushed to the primary stack.

When a value is shifted n bits in one direction, each bit of the value is set to the state of the bit lying n bits in the opposite direction. If this would reach past the end of the value, the bit is unset.

SHC

Rotate the bits of a value. This operation is also known as a ‘circular shift’.

The byte y is popped from the primary stack, then the value x is popped from the primary stack. The value r is calculated from x by rotating the bits of x rightwards by a distance represented by the lower four bits of y, and then by rotating the resultant bits leftwards by a distance represented by the higher four bits of y. The value r is then pushed to the primary stack.

When a value is rotated n bits in one direction, each bit of the value is set to the state of the bit lying n bits in the opposite direction. If this would reach past the end of the value, wrap around to the other end of the value and continue.

TAL

Count the number of set bits in a value. This operation is also known as ‘population count’.

The value x is popped from the primary stack, and then the value r is calculated as the number of bits set in x and is pushed to the primary stack.

REV

Reverse the order of bits in a value.

The value x is popped from the primary stack. The value r is then calculated bitwise, where each bit of r starting from one end of the value is set only if the corresponding bit of x starting from the opposite end of the value is set. The value r is then pushed to the primary stack.