Bitspinner - learn how your CPU works!

Programming

After we have successfully designed our 1st processor, we must of course write programs to be executed. Normally there are already compilers that translate source code from higher level languages like C, C++, Java into machine code. Unfortunately there is no compiler for our small processor yet but we can write a simple assembler that translates assembly into machine code and then load this program into our main memory and execute it. The provided Python source code is a simple assembler that transforms our instructions into machine code.

#!/usr/bin/env python3

import re
import sys

progf = sys.argv[1]

inst = {
    "nop": 0x00,
    "call": 0b00000001,
    "ret": 0b00000010,
    "lda": 0b10000111,
    "out": 0b00000011,
    "in": 0b00000100,
    "hlt": 0b00000101,
    "cmp": 0b00000110,
    "sta": 0b10111000,
    "jmp": 0b00011000,
    "jz": 0b00011001,
    "jnz": 0b00011010,
    "je":  0b00011001,
    "jne": 0b00011010,
    "jc":  0b00011011,
    "jnc": 0b00011100,
    "push": 0b00100000,
    "pop": 0b00101000,
    "add": 0b01000000,
    "sub": 0b01001000,
    "inc": 0b01010000,
    "dec": 0b01011000,
    "and": 0b01100000,
    "or": 0b01101000,
    "xor": 0b01110000,
    "adc": 0b01111000,
    "ldi": 0b00010000,
    "mov": 0b10000000,
}

reg = {
    "A": 0b000,
    "B": 0b001,
    "C": 0b010,
    "D": 0b011,
    "E": 0b100,
    "F": 0b101,
    "G": 0b110,
    "M": 0b111,
}

TEXT, DATA = 0, 1
MEM_SIZE = 256

mem = [0 for _ in range(MEM_SIZE)]
#Current
cnt = 0

labels = {}
data = {}
data_addr = {}

def rich_int(v):
    if v.startswith("0x"):
        return int(v, 16)
    elif v.startswith("0b"):
        return int(v, 2)
    else:
        return int(v)

with open(progf) as f:
    for l in f:
        l = re.sub(";.*", "", l)

l = l.strip()
        if l == "":
            continue

if l == ".text":
            section = TEXT
        elif l == ".data":
            section = DATA

else:
            if section == DATA:
                n, v = map(str.strip, l.split("=", 2))
                data[str(n)] = int(v)
            elif section == TEXT:
                kw = l.split()
                #Check if function
                #Get first word last character
                if kw[0][-1] == ":":
                    #start:
                    #remove : and store start with current addr! EXAMPLE
                    labels[kw[0].rstrip(":")] = cnt
                else:#If its not a function, its an instruction
                    current_inst = kw[0]
                    if current_inst == "ldi":
                        r = reg[kw[1]]
                        kw[0] = (inst[kw[0]] & 0b11111000) | r
                        del kw[1]
                        kw[1] = rich_int(kw[1])
                    elif current_inst in ("push", "pop"):
                        r = reg[kw[1]]
                        kw[0] = (inst[kw[0]] & 0b11111000) | r
                        del kw[1]
                    elif current_inst == "mov":
                        #8'b10-
                        op1 = reg[kw[1]]
                        op2 = reg[kw[2]]
                        kw[0] = (inst[kw[0]] & 0b11111000) | op2
                        kw[0] = (kw[0] & 0b11000111) | (op1 << 3)
                        del kw[2]
                        del kw[1]
                    else:
                        kw[0] = inst[kw[0]]
                    print("---------")
                    for a in kw:
                        print(kw)
                        mem[cnt] = a
                        cnt += 1

# Write data into memory
for k, v in data.items():
    data_addr[k] = cnt
    mem[cnt] = v
    cnt += 1

data_addr.update(labels)

# Replace variables
for i, b in enumerate(mem):
    if str(b).startswith("%"):
        print(b)
        mem[i] = data_addr[b.lstrip("%")]
print(mem)
print(" ")
#Each number gets translated into HEX!
print(' '.join(['%02x' % int(b) for b in mem]))

Fibonacci

In the following example we will implement an algorithm that calculates the Fibonacci series. On the left side is the assembler source code which uses the presented Python code to generate the machine code. We can now load this machine code into the main memory using a testbench in a Verilog simulation and execute the program. The processor never terminates but repeats the last instruction an infinite number of times.

We are now through with the first tutorial and have successfully developed an 8-bit processor. From here on there are no more limits and we can extend, improve and add functionality to the processor. There are no limits to creativity.

Starting Page

Programming

Fibonacci

Not registered yet? Sign up to Bitspinner

About

Connect

Contact

Donate (Bitcoin & Lightning)

Programming

Fibonacci

Not registered yet? Sign up to Bitspinner

About

Connect

Contact

Donate (Bitcoin & Lightning)

Choose Payment Method