This document is based on Vircon32 DevTools v25.1.19; older versions will contain inconsistencies.

Use commas to separate values (create “array” of values)

There are 64 CPU opcodes, so instructions encode them in 6 bits. No invalid opcodes can exist. HLT is opcode 0 for safety: if an empty or invalid instruction is found, the CPU will stop execution.

    in R0,  TIM_FrameCounter    ; load current frame count into R0

Commands that can be issued to the GPU:

Active blending:

Commands for the SPU:

States of the sound channels:

• bits 31-26: opcode
• bit 25: immediate value
• bits 24-21: register 1
• bits 20-17: register 2
• bits 16-14: address mode
• bits 13-0: port number

If the immediate value bit is set, an additional word is read to be used as a parameter to the instruction.

Unconditional jump. Forcibly redirect program flow to indicated address. The address is somewhere else in the program logic, likely identified by some set label.

• Variant 1:

  JMP { ImmediateValue }

• Variant 2:

  JMP { Register1 }

• Variant 1:

  InstructionPointer = ImmediateValue

• Variant 2:

  InstructionPointer = Register1

JMP performs an unconditional jump to the address specified by its operand. After processing this instruction the CPU will continue execution at the new address.

Jumping to a label (memory address/offset):

    jmp _label
    ...
_label:

Jumping to address stored in register:

    jmp R0

Jump if True: a conditional jump typically used following a comparison instruction, should the queried register contain a true (1) value, jump to indicated address.

For the purposes of comparisons and conditional jumps on Vircon32:

• true is 1 (technically non-zero)
• false is 0

• Variant 1:

  JT { Register1 }, { ImmediateValue }

• Variant 2:

  JT { Register1 }, { Register2 }

• Variant 1:

  if Register1 != 0 then InstructionPointer = ImmediateValue

• Variant 2:

  if Register1 != 0 then InstructionPointer = Register2

JT performs a jump only if its first operand is true, i.e. non zero when taken as an integer. In that case its behavior is the same as an unconditional jump. Otherwise it has no effect.

Jump if False: a conditional jump typically used following a comparison instruction, should the queried register contain a false (0) value, jump to indicated address.

For the purposes of comparisons and conditional jumps on Vircon32:

• true is 1 (technically non-zero)
• false is 0

• Variant 1:

  JF { Register1 }, { ImmediateValue }

• Variant 2:

  JF { Register1 }, { Register2 }

• Variant 1:

  if Register1 == 0 then InstructionPointer = ImmediateValue

• Variant 2:

  if Register1 == 0 then InstructionPointer = Register2

JF performs a jump only if its first operand is false, i.e. zero when taken as an integer. In that case its behavior is the same as an unconditional jump. Otherwise it has no effect.

For the purposes of comparisons and conditional jumps on Vircon32:

• true is 1 (technically non-zero)
• false is 0

There are six relational operations:

• is equal to
• is not equal to
• is less than
• is than or equal to
• is greater than
• is greater than or equal to

Integer Compare Equality: comparisons allow us typically to evaluate two values, in accordance with some relational operation, resulting in a true (1) or false (0) result.

Should the first operand contain the same information as the second operand, the result will be true. Otherwise, false.

• Variant 1:

  IEQ { Register1 }, { ImmediateValue }

• Variant 2:

  IEQ { Register1 }, { Register2 }

• Variant 1:

  if Register1 == ImmediateValue then Register1 = 1 else Register1 = 0

• Variant 2:

  if Register1 == Register2 then Register1 = 1 else Register1 = 0

IEQ takes two operands interpreted as integers, and checks if they are equal. It will store the boolean result in the first operand, which is always a register.

Integer Not Equal: comparisons allow us typically to evaluate two values, in accordance with some relational operation, resulting in a true (1) or false (0) result.

Here, we test to see if the first operand is not equal to the second operand. If they are equal, the result is false, otherwise, not being equal yields a result of true.

• Variant 1:

  INE { Register1 }, { ImmediateValue }

• Variant 2:

  INE { Register1 }, { Register2 }

• Variant 1:

  if Register1 != ImmediateValue then Register1 = 1 else Register1 = 0

• Variant 2:

  if Register1 != Register2 then Register1 = 1 else Register1 = 0

INE takes two operands interpreted as integers, and checks if they are different. It will store the boolean result in the first operand, which is always a register.

Integer Greater Than: comparisons allow us typically to evaluate two values, in accordance with some relational operation, resulting in a true (1) or false (0) result.

In this case, we are testing if the first operand is greater than the second operand.

• Variant 1:

  IGT { Register1 }, { ImmediateValue }

• Variant 2:

  IGT { Register1 }, { Register2 }

• Variant 1:

  if Register1 > ImmediateValue then Register1 = 1 else Register1 = 0

• Variant 2:

  if Register1 > Register2 then Register1 = 1 else Register1 = 0

IGT takes two operands interpreted as integers, and checks if the first one is greater than the second. It will store the boolean result in the first operand, which is always a register.

Integer Greater Than Or Equal: comparisons allow us typically to evaluate two values, in accordance with some relational operation, resulting in a true (1) or false (0) result.

In this case, we are testing if the first operand is greater than or equal to the second operand.

For the purposes of comparisons and conditional jumps on Vircon32:

• true is 1 (technically non-zero)
• false is 0

There are six relational operations:

• is equal to
• is not equal to
• is less than
• is than or equal to
• is greater than
• is greater than or equal to

• Variant 1:

  IGE { Register1 }, { ImmediateValue }

• Variant 2:

  IGE { Register1 }, { Register2 }

• Variant 1:

  if Register1 >= ImmediateValue then Register1 = 1 else Register1 = 0

• Variant 2:

  if Register1 >= Register2 then Register1 = 1 else Register1 = 0

IGE takes two operands interpreted as integers, and checks if the first one is greater or equal to the second. It will store the boolean result in the first operand, which is always a register.

Integer Less Than: comparisons allow us typically to evaluate two values, in accordance with some relational operation, resulting in a true (1) or false (0) result.

In this case, we are testing if the first operand is less than the second operand.

For the purposes of comparisons and conditional jumps on Vircon32:

• true is 1 (technically non-zero)
• false is 0

There are six relational operations:

• is equal to
• is not equal to
• is less than
• is than or equal to
• is greater than
• is greater than or equal to

• Variant 1:

  ILT { Register1 }, { ImmediateValue }

• Variant 2:

  ILT { Register1 }, { Register2 }

• Variant 1:

  if Register1 < ImmediateValue then Register1 = 1 else Register1 = 0

• Variant 2:

  if Register1 < Register2 then Register1 = 1 else Register1 = 0

ILT takes two operands interpreted as integers, and checks if the first one is less than the second. It will store the boolean result in the first operand, which is always a register.

Integer Less Than Or Equal: comparisons allow us typically to evaluate two values, in accordance with some relational operation, resulting in a true (1) or false (0) result.

In this case, we are testing if the first operand is less than or equal to the second operand.

For the purposes of comparisons and conditional jumps on Vircon32:

• true is 1 (technically non-zero)
• false is 0

There are six relational operations:

• is equal to
• is not equal to
• is less than
• is than or equal to
• is greater than
• is greater than or equal to

ILE takes two operands interpreted as integers, and checks if the first one is less or equal to the second. It will store the boolean result in the first operand, which is always a register.

MOVE: your general purpose data-copying instruction.

MOVE, like other data-centric instructions, makes use of various addressing modes:

• register: source/destination is an inbuilt CPU register
• immediate: some literal constant (be it data or a memory address)
• indirect: value isn't the data, but a memory address to where the data is. Think pointer dereference. It comes in 3 varieties:
• indexed: an offset to some existing piece of data.
  • immediate: a literal constant (data or memory address)
  • indexed: used with immediate/register, but we can do additional math to get an offset from the address. Think pointer dereference on an array.
  • register: a CPU register

Indirect processing is accomplished with the [ ] (square brackets) surrounding the value we wish to dereference (we're not interested in the direct thing, but indirectly in what that thing contains).

MOV copies the value indicated in its second operand into the register or memory address indicated by its first operand. MOV is the most complex instruction to process because it needs to distinguish between 8 different addressing modes.

The instruction specifies which of the 8 modes to use in its “Addressing mode” field, being the possible values interpreted as follows:

Load Effective Address of a memory position.

LEA, like other data-centric instructions, makes use of various addressing modes:

• register: source/destination is an inbuilt CPU register
• immediate: some literal constant (be it data or a memory address)
• indirect: value isn't the data, but a memory address to where the data is. Think pointer dereference. It comes in 3 varieties:
• indexed: an offset to some existing piece of data.
  • immediate: a literal constant (data or memory address)
  • indexed: used with immediate/register, but we can do additional math to get an offset from the address. Think pointer dereference on an array.
  • register: a CPU register

Indirect processing is accomplished with the [ ] (square brackets) surrounding the value we wish to dereference (we're not interested in the direct thing, but indirectly in what that thing contains).

• Variant 1:

  LEA { Register1 }, [ { Register2 } ]

• Variant 2:

  LEA { Register1 }, [ { Register2 } + { ImmediateValue } ]

• Register:

  Register1 = Register2

• Indexed:

  Register1 = Register2 + ImmediateValue

LEA takes a memory address as second operand. It stores that address (not its contents) into the register given as first operand. The most useful case is when the address is given in the form pointer + offset, since the addition is automatically performed.

Save to top of stack

• PUSH { Register1 }

• Stack.Push(Register1)

PUSH uses the CPU hardware stack to add the value contained in the given register at the top of the stack. When you PUSH a value onto the stack, the STACK POINTER (SP) is adjusted downward by one address offset (stack grows down).

Load from top of stack

• POP { Register1 }

• Register1 = Stack.Pop()

POP uses the CPU hardware stack to remove a value from the top of the stack and write it in the given register. When you POP a value off the stack, the STACK POINTER (SP) is adjusted upward by one address offset (stack grows down, shrinks up).

Receive input from an I/O port

• IN {Register1}, {PortNumber}

• Register1 = Port[ PortNumber ]

In uses the control bus to read from an I/O port in another chip and stores the returned value in the specified register. This read request may lead to side effects depending on the specified port.

Write to an I/O port

• OUT {PortNumber}, [{ImmediateValue}]

• OUT {PortNumber}, {Register1}

• Port[PortNumber] = ImmediateValue

• Port[PortNumber] = Register1

OUT uses the control bus to write the specified value to an I/O port in another chip. This write request may lead to side effects depending on the specified port

Copy string (HW memcpy)

• MOVS

• Memory[ DR ] = Memory[ SR ]

• DR += 1

• SR += 1

• CR -= 1

• if CR > 0 then InstructionPointer -= 1

MOVS copies a value from the memory address pointed by SR to the one pointed by DR (as in a supposed MOV [DR], [SR]). It then implements a local loop to repeat itself until the counter in CR reaches 0, while working on consecutive addresses. Note that even when called with a value of CR of zero or less, MOVS will always perform the described loop at least once. This instruction is the only way in Vircon32 CPU to directly copy values from 2 places in memory without going through a register.

Set string (HW memset)

• SETS

• Memory[ DR ] = SR

• DR += 1

• CR -= 1

• if CR > 0 then InstructionPointer -= 1

SETS copies the value in SR to the address pointed by DR (as in a MOV [DR], SR). It then implements a local loop to repeat itself until the counter in CR reaches 0, while writing to consecutive addresses. Note that even when called with a value of CR of zero or less, SETS will always perform the described loop at least once.

Compare string (HW memcmp)

• CMPS { Register1 }

• Register1 = Memory[ DR ] – Memory[ SR ]

• if Register1 != 0 then end processing

• DR += 1

• SR += 1

• CR -= 1

• if CR > 0 then InstructionPointer -= 1

CMPS takes as a reference the compares the value in the address pointed by DR and compares it with the one pointed by SR, by subtracting. It then implements a local loop to repeat itself until the counter in CR reaches 0, while reading consecutive addresses. The comparison result will be stored in the specified register, and will be zero when equal, positive when some value at [DR] was greater, and negative when some value in [SR] was greater. Note that even when called with a value of CR of zero or less, CMPS will always perform the described loop at least once.

Convert Integer to Float

CIF interprets the specified register as an integer value. Then converts that value to a float representation and stores the result back in the same register. Note that, due to the limited precision of the float representation, high enough values of a 32-bit integer will result in a precision loss when represented as a float.

Convert Float to Integer

CFI interprets the specified register as a float value. Then converts that value to an integer representation and stores the result back in the same register. Conversion is not done through rounding, but instead by truncating (the fractional part is discarded). Note that, due to the much greater range of the float representation, high enough values of a float will result in a precision loss when represented as a 32-bit integer.

Convert Integer to Boolean

CIB interprets the specified register as an integer value. Then converts that value to its standard boolean representation and stores the result back in the same register. This means that all non-zero values will be converted to 1.

Convert Float to Boolean

CFB interprets the specified register as a float value. Then converts that value to either 0 (for float value 0.0), or 1 (for any other value) and stores it back in that register.

Bitwise NOT

• NOT { Register1 }

• Register1 = NOT Register1

NOT performs a binary ‘not’ by inverting all of the bits in the specified register.

Bitwise AND

AND performs a Bitwise AND between each pair of respective bits in the 2 specified operands. The result is stored in the first of them, which is always a register.

Bitwise iOR

OR performs a Bitwise iOR between each pair of respective bits in the 2 specified operands. The result is stored in the first of them, which is always a register.

Bitwise XOR

XOR performs a Bitwise EXCLUSIVE OR between each pair of respective bits in the 2 specified operands. The result is stored in the first of them, which is always a register.

Boolean NOT

• BNOT { Register1 }

• if Register1 == 0 then Register1 = 1 else Register1 = 0

BNOT interprets the specified register as a boolean and then converts it to the opposite boolean value. This is equivalent to first using CIB and then inverting bit number 0.

Bit shift left

• (Variant 1): SHL { Register1 }, { ImmediateValue }

• (Variant 2): SHL { Register1 }, { Register2 }

• (Variant 1): Register1 = Register1 << ImmediateValue

• (Variant 2): Register1 = Register1 << Register2

SHL performs an bit shift to the left in the specified register. The second operand is taken as an integer number of positions to shift. Shifting 0 positions has no effect, while negative values result in shifting right. The shift type is logical: in shifts left, overflow is discarded and zeroes are introduced as least significant bits. In shifts right, underflow is discarded and zeroes are introduced as most significant bits.

Integer Addition

• (Variant 1): IADD { Register1 }, { ImmediateValue }

• (Variant 2): IADD { Register1 }, { Register2 }

• (Variant 1): Register1 += ImmediateValue

• (Variant 2): Register1 += Register2

IADD interprets both of its operands as integers and performs an addition. The result is stored in the first operand, which is always a register. Overflow bits are discarded.

Integer Subtraction

• (Variant 1): ISUB { Register1 }, { ImmediateValue }

• (Variant 2): ISUB { Register1 }, { Register2 }

• (Variant 1): Register1 -= ImmediateValue

• (Variant 2): Register1 -= Register2

ISUB interprets both of its operands as integers and performs a subtraction. The result is stored in the first operand, which is always a register. Overflow bits are discarded.

Integer Multiplication

• (Variant 1): IMUL { Register1 }, { ImmediateValue }

• (Variant 2): IMUL { Register1 }, { Register2 }

• (Variant 1): Register1 *= ImmediateValue

• (Variant 2): Register1 *= Register2

IMUL interprets both of its operands as integers and performs a multiplication. The result is stored in the first operand, which is always a register. Overflow bits are discarded.

Integer Division

• (Variant 1): IDIV { Register1 }, { ImmediateValue }

• (Variant 2): IDIV { Register1 }, { Register2 }

• (Variant 1): Register1 /= ImmediateValue

• (Variant 2): Register1 /= Register2

IDIV interprets both of its operands as integers and performs a division. The result is stored in the first operand, which is always a register.

Integer Modulus

• (Variant 1): IMOD { Register1 }, { ImmediateValue }

• (Variant 2): IMOD { Register1 }, { Register2 }

• (Variant 1): Register1 = Register1 mod ImmediateValue

• (Variant 2): Register1 = Register1 mod Register2

IMOD interprets both of its operands as integers and performs a division. The remainder of that division is stored in the first operand, which is always a register.

Integer Sign Change

• ISGN { Register1 }

• Register1 = -Register1

ISGN interprets the operand register as an integer and inverts its sign.

Integer Minimum

• (Variant 1): IMIN { Register1 }, { ImmediateValue }

• (Variant 2): IMIN { Register1 }, { Register2 }

• (Variant 1): Register1 = min( Register1, ImmediateValue )

• (Variant 2): Register1 = min( Register1, Register2 )

IMIN interprets both of its operands as integers. It then takes the minimum of both values and stores it in the first operand, which is always a register.

Integer Maximum

• (Variant 1): IMAX { Register1 }, { ImmediateValue }

• (Variant 2): IMAX { Register1 }, { Register2 }

• (Variant 1): Register1 = max( Register1, ImmediateValue )

• (Variant 2): Register1 = max( Register1, Register2 )

IMAX interprets both of its operands as integers. It then takes the maximum of both values and stores it in the first operand, which is always a register.

Integer Absolute Value

• IABS { Register1 }

• Register1 = abs( Register1 )

IABS interprets the operand register as an integer and takes its absolute value.

Float Addition

• (Variant 1): FADD { Register1 }, { ImmediateValue }

• (Variant 2): FADD { Register1 }, { Register2 }

• (Variant 1): Register1 += ImmediateValue

• (Variant 2): Register1 += Register2

FADD interprets both of its operands as floats and performs an addition. The result is stored in the first operand, which is always a register. Overflow bits are discarded.

Float Subtraction

• (Variant 1): FSUB { Register1 }, { ImmediateValue }

• (Variant 2): FSUB { Register1 }, { Register2 }

• (Variant 1): Register1 -= ImmediateValue

• (Variant 2): Register1 -= Register2

FSUB interprets both of its operands as floats and performs a subtraction. The result is stored in the first operand, which is always a register. Overflow bits are discarded.

Float Multiplication

• (Variant 1): FMUL { Register1 }, { ImmediateValue }

• (Variant 2): FMUL { Register1 }, { Register2 }

• (Variant 1): Register1 *= ImmediateValue

• (Variant 2): Register1 *= Register2

FMUL interprets both of its operands as floats and performs a multiplication. The result is stored in the first operand, which is always a register. Overflow bits are discarded.

Float Division

• (Variant 1): FDIV { Register1 }, { ImmediateValue }

• (Variant 2): FDIV { Register1 }, { Register2 }

• (Variant 1): Register1 /= ImmediateValue

• (Variant 2): Register1 /= Register2

FDIV interprets both of its operands as floats and performs a division. The result is stored in the first operand, which is always a register.

Float Modulus

• (Variant 1): FMOD { Register1 }, { ImmediateValue }

• (Variant 2): FMOD { Register1 }, { Register2 }

• (Variant 1): Register1 = fmod(Register1, ImmediateValue)

• (Variant 2): Register1 = fmod(Register1, Register2)

FMOD interprets both of its operands as floats and performs a division. It then takes the remainder of that division when the result’s fractional part is discarded and stores it in the first operand, which is always a register.

Float Sign Change

• FSGN { Register1 }

• Register1 = -Register1

FSGN interprets the operand register as a float and inverts its sign.

Float Minimum

• (Variant 1): FMIN { Register1 }, { ImmediateValue }

• (Variant 2): FMIN { Register1 }, { Register2 }

• (Variant 1): Register1 = min( Register1, ImmediateValue )

• (Variant 2): Register1 = min( Register1, Register2 )

FMIN interprets both of its operands as floats. It then takes the minimum of both values and stores it in the first operand, which is always a register.

Float Maximum

• (Variant 1): FMAX { Register1 }, { ImmediateValue }

• (Variant 2): FMAX { Register1 }, { Register2 }

• (Variant 1): Register1 = max( Register1, ImmediateValue )

• (Variant 2): Register1 = max( Register1, Register2 )

FMAX interprets both of its operands as floats. It then takes the maximum of both values and stores it in the first operand, which is always a register.

Float Absolute Value

• FABS { Register1 }

• Register1 = abs( Register1 )

FABS interprets the operand register as a float and takes its absolute value.

Round down

• FLR { Register1 }

• Register1 = floor( Register1 )

FLR interprets the operand register as a float and rounds it downwards to an integer value. Note that the result is not converted to an integer, but is still a float.

Round up

• CEIL { Register1 }

• Register1 = ceil( Register1 )

CEIL interprets the operand register as a float and rounds it upwards to an integer value. Note that the result is not converted to an integer, but is still a float.

Round to nearest integer

• ROUND { Register1 }

• Register1 = round( Register1 )

ROUND interprets the operand register as a float and rounds it to the closest integer value. Note that the result is not converted to an integer, but is still a float.

Sine

• SIN { Register1 }

• Register1 = sin( Register1 )

SIN interprets the operand register as a float and calculates the sine of that value. The sine function will interpret its argument in radians.

Arc cosine

• ACOS { Register1 }

• Register1 = acos( Register1 )

ACOS interprets the operand register as a float and calculates the arc cosine of that value. The result is given in radians, in the range [0, pi].

Arc Tangent from x and y

• ATAN2 { Register1 }, { Register2 }

• Register1 = atan2( Register1, Register2 )

ATAN2 interprets both operand registers as floats and calculates the angle of a vector such that Vx = Register2 and Vy = Register1. The result is stored in the first operand register and will be given in radians, in the range [-pi, pi]. The origin of angles is located at (Vx > 0, Vy = 0) and angles grow when rotating towards (Vx = 0, Vy > 0).

Natural logarithm

• LOG { Register1 }

• Register1 = log( Register1 )

LOG interprets the operand register as a float and calculates the logarithm base e of that value.

Raise to a Power

• POW { Register1 }, { Register2 }

• Register1 = pow( Register1, Register2 )

POW interprets both operand registers as floats and calculates the result of raising the first operand to the power of the second operand. The result is stored in the first operand register.

    // -----------------------------------------------------------------------------
    
    enum class CPURegisters: int
    {
        // all 16 general-purpose registers
        Register00 = 0,
        Register01,
        Register02,
        Register03,
        Register04,
        Register05,
        Register06,
        Register07,
        Register08,
        Register09,
        Register10,
        Register11,
        Register12,
        Register13,
        Register14,
        Register15,
        
        // alternate names for specific registers
        CountRegister       = 11,
        SourceRegister      = 12,
        DestinationRegister = 13,
        BasePointer         = 14,
        StackPointer        = 15
    };
    
    // -----------------------------------------------------------------------------
    
    enum class AddressingModes : unsigned int
    {
        RegisterFromImmediate = 0,      // syntax: MOV R1, 25
        RegisterFromRegister,           // syntax: MOV R1, R2
        RegisterFromImmediateAddress,   // syntax: MOV R1, [25]
        RegisterFromRegisterAddress,    // syntax: MOV R1, [R2]
        RegisterFromAddressOffset,      // syntax: MOV R1, [R2+25]
        ImmediateAddressFromRegister,   // syntax: MOV [25], R2
        RegisterAddressFromRegister,    // syntax: MOV [R1], R2
        AddressOffsetFromRegister       // syntax: MOV [R1+25], R2
    };
    
    // -----------------------------------------------------------------------------
    
    enum class CPUErrorCodes: uint32_t
    {
        InvalidMemoryRead = 0,
        InvalidMemoryWrite,
        InvalidPortRead,
        InvalidPortWrite,
        StackOverflow,
        StackUnderflow,
        DivisionError,
        ArcCosineError,
        ArcTangent2Error,
        LogarithmError,
        PowerError
    };
}