This document is based on Vircon32 DevTools v24.02.04; older versions will contain inconsistencies.

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

    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:

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.

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.

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.

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:

  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.

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:

  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.

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:

  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

• Variant 1:

  ILE { Register1 }, { ImmediateValue }

• Variant 2:

  ILE { Register1 }, { Register2 }

• Variant 1:

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

• Variant 2: if Register1 ⇐ Register2 then Register1 = 1 else Register1 = 0</code>

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).

• Variant 1:

  MOV { Register1 }, { ImmediateValue }

• Variant 2:

  MOV { Register1 }, { Register2 }

• Variant 3:

  MOV { Register1 }, [ { ImmediateValue } ]

• Variant 4:

  MOV { Register1 }, [ { Register2 } ]

• Variant 5:

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

• Variant 6:

  MOV [ { ImmediateValue } ], { Register2 }

• Variant 7:

  MOV [ { Register1 } ], { Register2 }

• Variant 8:

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

• Immediate:

  Register1 = ImmediateValue

• Register:

  Register1 = Register2

• Indirect with Immediate reference:

  Register1 = Memory[ImmediateValue]

• Indirect with Register reference:

  Register1 = Memory[Register2]

• Indirect Indexed with Register:

  Register1 = Memory[Register2 + ImmediateValue]

• Indirect with Immediate reference:

  Memory[ImmediateValue] = Register2

• Indirect with Register reference:

  Memory[Register1] = Register2

• Indirect with Indexed reference:

  Memory[Register1 + ImmediateValue] = Register2

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.

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).

• 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).

        IN,         // Read from an I/O port
        OUT,        // Write to an I/O port
        
        // string operations
        MOVS,       // Copy string (HW memcpy)
        SETS,       // Set string (HW memset)
        CMPS,       // Compare string (HW memcmp)
        
        // data conversion
        CIF,        // Convert Integer to Float
        CFI,        // Convert Float to Integer
        CIB,        // Convert Integer to Boolean
        CFB,        // Convert Float to Boolean
        
        // binary operations
        NOT,        // Bitwise NOT
        AND,        // Bitwise AND
        OR,         // Bitwise OR
        XOR,        // Bitwise XOR
        BNOT,       // Boolean NOT
        SHL,        // Bit shift left
        
        // integer arithmetic
        IADD,       // Integer Addition
        ISUB,       // Integer Subtraction
        IMUL,       // Integer Multiplication
        IDIV,       // Integer Division
        IMOD,       // Integer Modulus
        ISGN,       // Integer Sign change
        IMIN,       // Integer Minimum
        IMAX,       // Integer Maximum
        IABS,       // Integer Absolute value
        
        // float arithmetic
        FADD,       // Float Addition
        FSUB,       // Float Subtraction
        FMUL,       // Float Multiplication
        FDIV,       // Float Division
        FMOD,       // Float Modulus
        FSGN,       // Float Sign change
        FMIN,       // Float Minimum
        FMAX,       // Float Maximum
        FABS,       // Float Absolute value
        
        // extended float operations
        FLR,        // Round down
        CEIL,       // Round up
        ROUND,      // Round to nearest integer
        SIN,        // Sine
        ACOS,       // Arc cosine
        ATAN2,      // Arc Tangent from x and y
        LOG,        // Natural logarithm
        POW         // Raise to a Power
    };
    
    // -----------------------------------------------------------------------------
    
    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
    };
}