A implementation of the assembler and emulator for the simple processor design presented in the Gary explains videos on YouTube.

Specific videos:

• Design your own instruction format
• Write Your Own Assembler for Your Own CPU
• As yet un released video

Gary's original source is available on Github, this is in the python file vASM.py at the top level. My project is written in C# and ever so slightly larger.

This page contains a descriptions of the Instruction Set Architecture and the tooling that the suite provides to assemble and execute that ISA. Specific pages exist that outline the implementation of the tools in the suite

• The Assembler
• The Emulator
• The Compiler

Assembly language is written one instruction per line. Lines starting with the comment character # are ignored. Any lines with trailing comments :

    LD R1, 65535 # set all bits to 1

will have the training comment removed before parsing.

Instructions are parsed in a case insensitive manner. The following two lines are the same

LD R1, 0xFE03
ld r1, 0xfe03

Numeric constants can be decimal, hexadecimal, or octal.

There are eight general purpose registers r0 ... r7, available to user code. Register r8 is the program counter and r9 the stack pointer, neither of which can be accessed by user code. So there.

Instruction definitions. All instructions are 32 bits long, unused bytes set to 0. Registers are 16 bit.

Software interrupts allow the program to invoke methods in the pseudo-kernel or ROM (What ever takes your fancy). These software interrupts allow the user to read and write strings and integers etc. the following software interrupts are defined, and the associated symbols are pre-defined in the assembler symbol table.

    ld r0, hello-world      # load r0 with the address of the string
    swi sys-write-string    # invoke the software interrupt
    halt                    # hal the processor we are done

.hello-world    
    defm "\nHello world!\n\n\0"

this will produce the following output

Hello world!

Halted

• Make sure you have the DotNet Core 5 SDK installed.
• Clone the git repository

cd into the folder repo\DesignYourOwnCpu (where repo is the folder you cloned the source into)

To assemble the hello-world.asm file on windows:

dotnet run -p .\Assembler\Assembler.csproj --input .\Asm\hello-world.asm

and on Linux, use:

dotnet run -p ./Assembler/Assembler.csproj --input ./Asm/hello-world.asm

Output

Source file: .\Asm\hello-world.asm
Output file: .\Asm\hello-world.bin
Symbol file: .\Asm\hello-world.sym

0x0000  00 00 00 0C  # ld  r0, 0x000C
0x0004  54 00 00 01  # swi 0x0001 => sys-write-string
0x0008  FE 00 00 00  # halt
0x000C  .. .. .. ..  # defm "\nHello world!\n\n\0" (20 chars

Symbols

0x000C hello-world
0x0003 sys-read-string
0x0004 sys-read-word
0x0001 sys-write-string
0x0002 sys-write-word

The assembler will assemble the code in hello-world.asm and will produce two files: hello-world.bin and hello-world.sym. The assembler also shows the opcodes associated with the assembly code and a dump of the symbol table including built in symbols like sys-write-string.

To execute the assembled code use the emulator via dotnet run. In windows use

dotnet run -p .\Emulator\Emulator.csproj --input .\Asm\hello-world.bin

and on Linux, it's

dotnet run -p ./Emulator/Emulator.csproj --input ./Asm/hello-world.bin

This produces the following output

Hello world!

Halted

PC: 0X000C: SP: 0XFFFF:
R0: 0X000C: R1: 0X0000: R2: 0X0000: R3: 0X0000: R4: 0X0000: R5: 0X0000: R6: 0X0000: R7: 0X0000:

0000 00 00 00 0C 54 00 00 01 FE 00 00 00 0A 48 65 6C ....T...■....Hel
0010 6C 6F 20 77 6F 72 6C 64 21 0A 0A 00 00 00 00 00 lo world!.......
0020 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
0030 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
0040 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................

The output consists of the text output from the emulation and then a dump of the final state of the registers and low memory addresses.

The following example applications available

Here is the assembler and emulator running on windows

and here they are gamboling on Linux

¹ A new instruction not in the original Gary explains Instruction Set Architecture

² Altered instruction syntax for addressing which replaces the $constant format with the form (constant), which is closer to real world syntax used in assemblers. The original syntax of $constant made the parser easier to implement. At the cost of a more complex assembler implementation, the bracketed format is easier to understand, particularly for those of use who are dyslexic.