Moo CPU

Overview

All CPUs execute instructions. These very simple instructions are called "machine language". They are entirely numeric and are not human readable (by normal humans). The source code to produce machine language is called "assembly language". Assembly is human readable (just barely). It "assembles" into machine language with a one-for-one correspondence between an assembly language instruction and a machine language instruction. Higher level languages compile on instruction to many machine language instructions.

A CPU starts reading memory at an address and finds a machine language instructon. Following the instruction, there are often several bytes of parameters for that instruction. As the CPU executes the instruction, it advances a special register, (a tiny amount of memory built onto the chip) called a program counter, to "point at" the memory being read and interpreted.

Typical machine language instructions include moving a value from memory to a general purpose register or back, doing math on values in memory or in registers, making comparisons between memory and registers, or affecting the program counter to read and execute a different portion of memory.

Machine language instruction must be told how to address memory or registers. This is referred to as an "addressing mode" or "scheme". Typically the addressing modes include (among many others):

immediate mode - The value to be moved is right there after the instruction

absolute mode - The memory address where the value is is specified after the instruction

indirect mode - The address or register after the instruction holds the address used to find the value.

The syntax of the assembly langauge is used to specify the instruction and its addressing mode. Different chips, and different assemblers, often use differing syntaxes to specify the same addressing modes.

The Moo CPU emulator emulates in software a completely fictional CPU. The Moo CPU uses a very basic machine language with only 42 instructions. These instructions are intended to be typical of those used by a very simple CPU. The purpose of the emulator is to teach programmers already familiar with higher level languages the basics of assembly language and CPU operation.

The Moo CPU has 8 general purpose registers and 8 floating point registers. It has also has a stack pointer and a program counter. The registers are labeled A though H. The stack pointer is labeled "SP" and the program counter is labeled "CP". All of the registers, including the stack pointer and the program counter are 32 bit.

Instruction Types

The following instruction types are supported:

Load Instructions - move a value to a register

Store Instructions - move a value from a register

Math Instructions - add, subtract, multiply, and divide

Compare and Branch Instructions - Comnpare two values and change the program counter to a new address based on outcome of the comparison

Stack Instructions - Push and pop values on the hardware stack

Control Flow Instructions - Change the program counter to jump off to other portions of the program

Bitwise Instructions - Operations that affect the individual bits in a value

All of the Moo CPU instructions have zero, one, or two arguments. Add, for example has two arguments, a register specifier (A-H) and an address specifier. So to add 82 to the value in register A, you would write "load A #82". The "#" indicates immediate mode. To add the value at memory address 20020 to the value in register B, you would write "add B 20020". Because there is no "#" or parenthesis around the 20020, absolute mode is assumed. The add instruction finds the value in memory address 20020 and adds it to the value in register B, leaving the result in register B. If you have loaded register C with the address value 20020, you could accomplish the same thing by specifying

load C #20020
add B (C)

The parentheses around "C" indicate that the add instruction should get the address out of C, then get the value to be added in from that address, leaving the result in register B.

Most of the instructions operate on full integers (32-bits, 4 bytes). Some instructions are duplicated to work on single bytes or on the floating point numbers. This is indicated by a "B" or an "F" preceeding the instruction name.

load A #22 ; load integer 22 into A
fload B #22.89 ; load floating point value 22.89 into floating point register B
bload C #65 ; load byte 65 (ASCII "A") into register C

The built in assembler also supports a handful operations that specify how to assemble the source code, rather than resulting in machine language instructions. These include the ability to set a portion of memory to a constant ascii string, declare labels in place of addresses, and notate code with comments.

The emulator also features 1 megabyte of main memory, which includes 2,000 bytes of video memory (addresses 0 - 1999) and 8,000 bytes of dedicated stack memory (addresses 2000-9999). The remaining memory (addresses 10000 - 1048575) is reserved for the user's program. The emulator includes a 80 column by 25 row ASCII based "video screen", and a simple text editor for loading, saving, and assembling Moo CPU source code.

Here is a simple "Hello World" Moo code example:

:hello                ; label the "hello world" constant
                      ; the first "." on the following line indicates that the rest of the line is a constant to be put in memory
.hello world.
jmp :begin            ; Jump over the two subroutines to the start of the main program

:index                ; label the indexing subroutine that calculates the X,Y position at which to print
mult B #80            ; multiply the B register (holding X) with 80 because there are 80 columns
add B A               ; add the A register into B to produce "address = (Y * 8) + X"
ret                   ; return to the calling routine. "call" pushes the return address on the stack. "ret" pops the address and jumps to it

:print                ; label the print subroutine. The address of the string is in A. The address at which to print is in B.
bload C (A)           ; load C with the value from the address that is held in A
bstore C (B)          ; store the value in C at the address that is held in B
add A #1              ; add 1 to the address in A, moving along the NULL terminated string
add B #1              ; add 1 to the address in B
cmp C #0              ; compare the value in C with 0 (the NULL terminator)
ifne :print           ; If it is not 0, jump to the start of the print subroutine
ret                   ; return

:begin                ; label the start of the main routine
load A #10            ; put 10 in A, the X position
load B #5             ; put 5 in B, the Y position
call :index           ; calculate the video memory address from X and Y, leaving the result in B
load A #:hello        ; load the address of the "hello" constant string into A
call :print           ; call the print subroutine
end                   ; end of the program

The User Interface

The user interface is divided into several sections. In the upper left corner is the "CPU Status" section. This section has "lights" indicating different CPU conditions.

CPU Status

The "GT", "EQ", and "LT" lights indicate if the last comparison operation resulted in the number being less than, equal to, or greater than the compared number. The "ERR" light indicated that the CPU experienced a runtime failure and has stopped. The "Exec" light indicates that the CPU is executing a single instruction. Because this CPU runs in slow motion, this light will flicker on and off while the program is executing.

Registers

The register section displays the values in the 18 registers. The first 8 registers are general purpose registers that can only hold 32 bit integers. They are labeled "A" through "H". The next 8 registers are floating point registers. These can only hold 32 bit floating point numbers. Unlike the general purpose registers, these can not be used for indirect addressing. They are labeled "FA" through "FH". Note: while these are labeled with a leading "F", when referenced in Moo assembly language the leading "F" is omitted. The "SP" element shows the current value of the stack pointer. The "PC" element shows the current value of the program counter. This is the address in memory of the currently executing CPU instruction. All of the register fields are read-only and do not allow user editing.

Memory View

The memory view panel shows the memory of the pretend computer. It is divided into four columns. The first column displays the memory address, labeled from 0 to 1048575. The second column show the byte value at that memory address. The third and fourth columns show the source value of any instructions at that memory cell. The video memory is colored cyan. The stack memory is colored blue. Depending on mode, accessed memory will be highlighted in yellow. In SP, PC, MEM, and VID modes, the view will automatically scroll to show memory being accessed. When in USER mode, the view can be scrolled by clicking in the view and using the scrollbar, Page Up, Page Down, Home, and End keys. Page Up and Home scroll toward lower addresses. Page Down and End scroll toward higher addresses.

Command Buttons

The command buttons are the primary means of operating the Moo CPU.

Edit - The Edit button brings up the simple text editor. From the text editor, you can load, save, edit, and assemble your Moo CPU assembly source code. This is typically the first button you will want to press.

Assemble - The Assemble button assembles the source code into a machine language that the Moo CPU is able to execute. If successful, it also places the resulting program into the CPU's memory at address 10000 and creates the source view (see: Source View) with the execuatable source on numbered lines.

Execute - The Execute button is inactive until a source program has been assembled. When pressed it executes the Moo program, waiting for the number of milliseconds specified in the "Delay" input next to the button. As the program is executed, depending on view mode, the memory will be highlighted and track activity, the registers will change, the source view will update and scroll, and lights in the status area may update. The program will continue to execute until it reaches an "end" instruction, or the user pressses the "Stop" button.

Step - The Step button is inactive until a source program has been assembled. It is also inactive if a program is currently executing. This button allows the user to execute a program one instruction at a time.

Stop - The Stop button is inactive unless a program is executing. It stops the program. The program can then be resumed where it was stopped using the Resume button.

Resume - The Resume button is inactive until a running program has been stopped with the Stop button or the program has been stepped using the Step button. It continues running the program where it was stopped.

User, SP, PC, MEM, VID - These buttons indicate the monitoring mode for the Memory View. The User mode allows the user to scroll the memory shown using the scrollbar, or the Page Up, Page Down, Home, and End key. The SP mode shows the memory dedicated to the stack and tracks memory accesses in the stack's range. The PC mode shows and tracks the memory address in the program counter. This is the address of the currently executing instruction. The MEM mode tracks the last memory address to be read or written by the CPU. The VID mode shows and tracks memory accesses in the portion of memory dedicated to the video screen.

Screen

The screen shows the memory from 0 to 1999. It is 80 columns by 25 rows. The bytes in that memory range are interpreted as ASCII and displayed on the screen in a position corresponding to that memory address, starting with the top left corner. So, memory 0 throgh 79 would be the first row. Memory 80 through 159 would be the second row. Etc. Placing 65 in memory 1000, would put a capital "A" (ASCII 65) in the center of the screen.

The screen has some silly controls along the bottom edge. The first is a button labeled "C". This cycles the text color between green, amber and white. The next button, labeled "R", toggles the screen between normal and reverse mode. In reverse mode the background (usually black) gets the text color and the text becomes black. There are two knobs. The leftmost controls brightness. The other controls contrast.

Source View

The source view shows the source code that resulted in executable machine language after it has been assembled. The line that is currently executing is shown and highlighted, otherwise the view scrolls using the scrollbar or navigation keystrokes. Source code that does not result in executable code (constants, labels, and comments) is not shown.

Instructions Reference

Load and Store

Math

Compare and Branch

Stack

Control Flow

Bitwise

Assembler