LitaVM is a 32 bit CPU Virtual Machine, created because who doesn't like understanding how low level programming and hardware works? The name lita comes from my grandma who I love dearly.

The main goals of this project is to create a CPU with a set of instructions to manipulate memory and create an assembly language to program the fancy CPU. If I feel adventurous enough, I may create a C like language for it as well.

I'm not sure where this project will end up, but I'll continue to churn on it until it becomes a chore.

Enough introduction, let's get to the meat.

Each instruction consists of a 32 bit integer. There are two primary formats, one for JMP/CALL opcodes and another for the rest of the opcodes.

The first 6 bits are to always used to identify the opcode to execute.

The JMP and CALL instructions have their own special format as they need the ability to have a large number to support the ability to jump anywhere in the code. As such, no program can have more than 2^24 (16,777,216) instructions and be able to fully support JMP and CALL operations.

The remaining 24 bits for the JMP and CALL instructions is an immediate mode unsigned number. This number represents where in the program to jump to, it is a zero based absolute index.

For all other instructions, they use the remaining 24 bits for two arguments. The first argument takes 5 bits, were the first bit designates if the value in the register should be treated as an address or value. The remaining 4 bits identify which register. Although, the format supports up to 16 registers, the CPU only has 12 registers.

The second argument takes 21 bits. The first bit designates if the argument is a register. If its set to 1, then the second bit designates if the value in the register should be treated as an address or value. The remaining 19 bits identify which register. Although, the format supports up to 2^19 registers, the CPU only has 12 registers.

If the first bit is 0, then the second bit designates if the value should be treated either as an immediate value (second bit = 1) or a constant index lookup (second bit = 0). In the immediate value case, the immediate value is an unsigned value with a max value of (2^19) (524,288). In the constant index lookup case, the remaining 19 bits are used as a constant index to look up in the constant pool.

There are 12 total registers, four reserved and six general purpose. Registers can contain a 32 bit value (either int or float); use the appropriate opcode to interpret the value of the register correctly (opcodes come in three flavors I, F, B to parse 32 bit int, 32 bit float and 8 bit bytes respectively. Additionally, a register can contain a memory address, as all memory addresses are 32 bit.

• $sp is the stack pointer and is available for read/write
• $pc is the program counter and is available for read
• $r stores the return address when invoking a CALL instruction; this is available for read/write
• $h is the heap pointer that is the address of where heap allocations can begin
• $a is a general purpose register for read/write
• $b is a general purpose register for read/write
• $c is a general purpose register for read/write
• $d is a general purpose register for read/write
• $i is a general purpose register for read/write
• $j is a general purpose register for read/write
• $k is a general purpose register for read/write
• $u is a general purpose register for read/write

When instantiating the vm (or thru command line arguments) you may specify the amount of RAM that the VM has available. By default, there is 1 MiB. The memory layout consists of:

There are a number of opcodes the CPU can handle.

The LitaVM assembly language syntax is pretty standard.

Hello World program, which prints out "Hello World" to system out

;; Create a constant
.text "Hello World"


ldca $a .text        ;; Load the constant address in $a
pushi $a             ;; push the address on the stack, so that print_string can use it
call :print_string   ;; call the print_string subroutine

jmp :exit            ; exit out of the program
printi #11           ; shouldn't get invoked, because we are jumping to the :exit label

;;
;; Prints the supplied string to sysout
;;
;; input:
;;    <address> to string constant, retreived from top of the stack
;; output:
;;    <void>
;;
:print_string        
        popi $a          ;; stores the address of the string constant
    :print_loop
        ifb &$a #0       ;; loops until the value at address $a = 0; strings are null terminated
        jmp :print_end_loop
        printc &$a       ;; prints out the ASCII byte character
        addi $a #1       ;; increments to the next character byte
        jmp :print_loop
    :print_end_loop    
        ret              ;; Stores return $pc in $r register, RET sets the $pc to value of $r
       
:exit