Programmeren voor de Gigatron

Disclaimer: dit is geen officiële Gigatron-pagina en ik ben niet verantwoordelijk voor eventuele fouten. Deze pagina kan verouderd raken indien er een nieuwe revisie van de ROM wordt uitgebracht.

De CPU

De CPU die is geïmplementeerd met de TTL IC's van de Gigatron heeft een Harvard-architectuur. Dit betekent dat er geen gedeelde bus is voor het ROM en het RAM. In feite wordt het ROM alleen gebruikt om instructies op te slaan; er zijn geen instructies om het ROM direct te benaderen (hoewel er een slimme truc bestaat waarmee het toch mogelijk is om data uit het ROM te 'lezen').

De CPU is een 8-bit processor met een 14-bit program counter en een RAM-bereik van 15-bit. Hij beschikt over drie 8-bit registers en een 8-bit input en output.

CPU-instructies

Ik heb het programma gtemu.c herschreven zodat het uitprint wat de verschillende instructies precies doen in pseudo-C. Na diverse revisies resulteerde dit in de onderstaande tabel. De getallen van de rijen en kolommen moeten bij elkaar worden opgeteld om het instructienummer te verkrijgen. Ik heb de volgorde van de rijen aangepast zodat vergelijkbare (of identieke) instructies gegroepeerd zijn.

De functie hi retourneert het hoge byte van de waarde. Let op dat de waarde die gebruikt wordt om het RAM te benaderen, is begrensd tot 0x7fff, aangezien er slechts 32 kilobyte RAM beschikbaar is. De program counter wordt na elke instructie verhoogd, behalve bij instructies die de program counter zelf wijzigen. Wanneer een instructie twee bewerkingen uitvoert, worden deze gescheiden door een puntkomma.

# 00# 20# 40# 60# 80# a0# c0# e0
00A = operA &= operA \= operA ^= operA += operA -= operRAM[oper] = operPC = (Y>>8)\oper
04A = operA &= operA \= operA ^= operA += operA -= operRAM[X] = operif (A < 0) PC = hi(PC)\oper
08A = operA &= operA \= operA ^= operA += operA -= operRAM[(Y>>8)\oper] = operif (A > 0) PC = hi(PC)\oper
0cA = operA &= operA \= operA ^= operA += operA -= operRAM[(Y>>8)\X] = operif (A != 0) PC = hi(PC)\oper
10X = operX = A & operX = A \operX = A ^ operX = A + operX = A - operRAM[oper] = oper; X = Aif (A == 0) PC = hi(PC)\oper
14Y = operY = A & operY = A \operY = A ^ operY = A + operY = A - operRAM[oper] = oper; Y = Aif (A <= 0) PC = hi(PC)\oper
18OUT = operOUT = A & operOUT = A \operOUT = A ^ operOUT = A + operOUT = A - operRAM[oper] = operif (A >= 0) PC = hi(PC)\oper
1cOUT = oper; X++OUT = A & oper; X++OUT = A \oper; X++OUT = A ^ oper; X++OUT = A + oper; X++OUT = A - oper; X++RAM[(Y>>8)\X++] = operPC = hi(PC)\oper
01A = RAM[oper]A &= RAM[oper]A \= RAM[oper]A ^= RAM[oper]A += RAM[oper]A -= RAM[oper]RAM[oper] = undefPC = (Y>>8)\RAM[oper]
05A = RAM[X]A &= RAM[X]A \= RAM[X]A ^= RAM[X]A += RAM[X]A -= RAM[X]RAM[X] = undefif (A < 0) PC = hi(PC)\RAM[oper]
09A = RAM[(Y>>8)\oper]A &= RAM[(Y>>8)\oper]A \= RAM[(Y>>8)\oper]A ^= RAM[(Y>>8)\oper]A += RAM[(Y>>8)\oper]A -= RAM[(Y>>8)\oper]RAM[(Y>>8)\oper] = undefif (A > 0) PC = hi(PC)\RAM[oper]
0dA = RAM[(Y>>8)\X]A &= RAM[(Y>>8)\X]A \= RAM[(Y>>8)\X]A ^= RAM[(Y>>8)\X]A += RAM[(Y>>8)\X]A -= RAM[(Y>>8)\X]RAM[(Y>>8)\X] = undefif (A != 0) PC = hi(PC)\RAM[oper]
11X = RAM[oper]X = A & RAM[oper]X = A \RAM[oper]X = A ^ RAM[oper]X = A + RAM[oper]X = A - RAM[oper]RAM[oper] = undef; X = Aif (A == 0) PC = hi(PC)\RAM[oper]
15Y = RAM[oper]Y = A & RAM[oper]Y = A \RAM[oper]Y = A ^ RAM[oper]Y = A + RAM[oper]Y = A - RAM[oper]RAM[oper] = undef; Y = Aif (A <= 0) PC = hi(PC)\RAM[oper]
19OUT = RAM[oper]OUT = A & RAM[oper]OUT = A \RAM[oper]OUT = A ^ RAM[oper]OUT = A + RAM[oper]OUT = A - RAM[oper]RAM[oper] = undefif (A >= 0) PC = hi(PC)\RAM[oper]
1dOUT = RAM[(Y>>8)\X++]OUT = A & RAM[(Y>>8)\X++]OUT = A \RAM[(Y>>8)\X++]OUT = A ^ RAM[(Y>>8)\X++]OUT = A + RAM[(Y>>8)\X++]OUT = A - RAM[(Y>>8)\X++]RAM[(Y>>8)\X++] = undefPC = hi(PC)\RAM[oper]
02/nop//nop//nop/A = 0A *= 2A = 0RAM[oper] = APC = (Y>>8)\A
06/nop//nop//nop/A = 0A *= 2A = 0RAM[X] = Aif (A < 0) PC = hi(PC)\A
0a/nop//nop//nop/A = 0A *= 2A = 0RAM[(Y>>8)\oper] = Aif (A > 0) PC = hi(PC)\A
0e/nop//nop//nop/A = 0A *= 2A = 0RAM[(Y>>8)\X] = Aif (A != 0) PC = hi(PC)\A
12X = AX = AX = AX = 0X = 2*AX = 0RAM[oper] = A; X = Aif (A == 0) PC = hi(PC)\A
16Y = AY = AY = AY = 0Y = 2*AY = 0RAM[oper] = A; Y = Aif (A <= 0) PC = hi(PC)\A
1aOUT = AOUT = AOUT = AOUT = 0OUT = 2*AOUT = 0RAM[oper] = Aif (A >= 0) PC = hi(PC)\A
1eOUT = A; X++OUT = A; X++OUT = A; X++OUT = 0; X++OUT = 2*A; X++OUT = 0; X++RAM[(Y>>8)\X++] = APC = hi(PC)\A
03A = INA &= INA \= INA ^= INA += INA -= INRAM[oper] = INPC = (Y>>8)\IN
07A = INA &= INA \= INA ^= INA += INA -= INRAM[X] = INif (A < 0) PC = hi(PC)\IN
0bA = INA &= INA \= INA ^= INA += INA -= INRAM[(Y>>8)\oper] = INif (A > 0) PC = hi(PC)\IN
0fA = INA &= INA \= INA ^= INA += INA -= INRAM[(Y>>8)\X] = INif (A != 0) PC = hi(PC)\IN
13X = INX = A & INX = A \INX = A ^ INX = A + INX = A - INRAM[oper] = IN; X = Aif (A == 0) PC = hi(PC)\IN
17Y = INY = A & INY = A \INY = A ^ INY = A + INY = A - INRAM[oper] = IN; Y = Aif (A <= 0) PC = hi(PC)\IN
1bOUT = INOUT = A & INOUT = A \INOUT = A ^ INOUT = A + INOUT = A - INRAM[oper] = INif (A >= 0) PC = hi(PC)\IN
1fOUT = IN; X++OUT = A & IN; X++OUT = A \IN; X++OUT = A ^ IN; X++OUT = A + IN; X++OUT = A - IN; X++RAM[(Y>>8)\X++] = INPC = hi(PC)\IN

Vervolgens heb ik een programma geschreven om het bestand theloop.asm te analyseren en te ontdekken welke instructies daadwerkelijk worden gebruikt. Dit leverde de volgende resultaten op (waarbij $00 staat voor de operand):

InstAantalPseudo-CMnemonic
02586/nop/nop
0054305A = operld $00
01505A = RAM[oper]ld [$00]
031A = INld in
0526A = RAM[X]ld [x]
092`A = RAM[(Y<<8)\oper]`ld [y,$00]
0d32`A = RAM[(Y<<8)\X]`ld [y,x]
101X = operld $00,x
1127X = RAM[oper]ld [$00],x
1211X = Ald ac,x
14326Y = operld $00,y
1519Y = RAM[oper]ld [$00],y
162Y = Ald ac,y
1814OUT = operld $00,out
196OUT = RAM[oper]ld [$00],out
2033A &= operanda $00
218A &= RAM[oper]anda [$00]
252A &= RAM[X]anda [x]
292`A &= RAM[(Y<<8)\oper]`anda [y,$00]
309X = A & operanda $00,x
4014`A \= oper`ora $00
4117`A \= RAM[oper]`ora [$00]
453`A \= RAM[X]`ora [x]
506`X = A \oper`ora $00,x
5d3`OUT = A \RAM[(Y<<8)\X++]`ora [y,x++],out
6016A ^= operxora $bf
6111A ^= RAM[oper]xora [$00]
695`A ^= RAM[(Y<<8)\oper]`xora [y,$00]
80402A += operadda $00
8128A += RAM[oper]adda [$00]
8236A *= 2adda ac
852A += RAM[X]adda [x]
896`A += RAM[(Y<<8)\oper]`adda [y,$00]
8d4`A += RAM[(Y<<8)\X]`adda [y,x]
9011X = A + operadda $00,x
911X = A + RAM[oper]adda [$00],x
922X = 2*Aadda ac,x
951Y = A + RAM[oper]adda [$00],y
a028A -= opersuba $00
a13A -= RAM[oper]suba [$00]
a55A -= RAM[X]suba [x]
b03X = A - opersuba $00,x
c04RAM[oper] = operst $00,[$00]
c2662RAM[oper] = Ast [$00]
c32RAM[oper] = INst in,[$00]
c68RAM[X] = Ast [x]
ca6`RAM[(Y<<8)\oper] = A`st [y,$00]
ce9`RAM[(Y<<8)\X] = A`st [y,x]
d27RAM[oper] = A; X = Ast [$00],x
d68RAM[oper] = A; Y = Ast [$00],y
de27`RAM[(Y<<8)\X++] = A`st [y,x++]
dc52`RAM[(Y<<8)\X++] = oper`st $00,[y,x++]
e0314`PC = (Y<<8)\oper`jmp y,$00
e12`PC = (Y<<8)\RAM[oper]`jmp y,[$00]
e213`PC = (Y<<8)\A`jmp y,ac
e43`if (A > 0) PC = hi(PC)\oper`bgt $00
e814`if (A < 0) PC = hi(PC)\oper`blt $00
ec30`if (A != 0) PC = hi(PC)\oper`bne $00
f010`if (A == 0) PC = hi(PC)\oper`beq $00
f45`if (A >= 0) PC = hi(PC)\oper`bge $00
f82`if (A <= 0) PC = hi(PC)\oper`ble $00
fc497`PC = hi(PC)\oper`bra $00
fd2`PC = hi(PC)\RAM[oper]`bra [$00]
fe612`PC = hi(PC)\A`bra ac

De vCPU

De virtuele CPU (vCPU) heeft een Von Neumann-architectuur.

vCPU-instructies

Het ROM implementeert een virtuele 16-bit CPU die draait wanneer de fysieke CPU niet bezig is met het genereren van het VGA-signaal. In het begin begreep ik niet hoe deze instructies gecodeerd waren, maar later ontdekte ik dat ze simpelweg een offset hebben in een van de geheugensegmenten. Dit betekent dat er feitelijk 256 instructies zijn geïmplementeerd door de vCPU, waarvan vele niets nuttigs doen (of de Gigatron kunnen laten crashen).

De vCPU beschikt over:

  • Een accumulator (vA, opgeslagen op geheugenlocatie 0x18 en 0x19).
  • Een program counter (vPC, opgeslagen op locatie 0x16 en 0x17).
  • Een stack pointer (vSP, opgeslagen op locatie 0x1c).
  • Een retouradres (vLR, opgeslagen op locatie 0x1a en 0x1b).

De instructies kunnen in pseudo-C als volgt worden beschreven (opcodes tussen haakjes):

ST(0x5e) oper            RAM[oper] = lo(vA);
STW(0x2b) oper           RAM[oper] = lo(vA); RAM[oper+1] = hi(vA);
STLW(0xec) oper          RAM[vSP+oper] = lo(vA); RAM[vSP+oper+1] = hi(vA);
LD(0x1a) oper            vA = RAM[oper];
LDI(0x59) oper           vA = oper;
LDWI(0x11) op1 op2       vA = op1 | (op2<<8);
LDW(0x21) oper           vA = RAM[oper] | (RAM[oper+1]<<8);
LDLW(0xee) oper          vA = RAM[vSP+oper] | (RAM[vSP+oper+1]<<8);
ADDI(0xe3) oper          vA += oper;
ADDW(0x99) oper          vA += RAM[oper] | (RAM[oper+1]<<8);
SUBI(0xe6) oper          vA -= oper;
SUBW(0xb8) oper          vA -= RAM[oper] | (RAM[oper+1]<<8);
ANDI(0x83) oper          vA &= oper;
ANDW(0xf8) oper          vA &= RAM[oper] | (RAM[oper+1]<<8);
ORI(0x88) oper           vA |= oper;
ORW(0xfa) oper           vA |= RAM[oper] | (RAM[oper+1]<<8);
XORI(0x8c) oper          vA ^= oper;
XORW(0xfc) oper          vA ^= RAM[oper] | (RAM[oper+1]<<8);
INC(0x93) oper           RAM[oper]++;
PEEK(0xad)               vA = RAM[vA];
DEEK(0xf6)               vA = RAM[vA] | (RAM[vA+1]<<8);
POKE(0xf3) oper          RAM[RAM[oper]|(RAM[oper+1]<<8)] = lo(vA);
DOKE(0xf3) oper          addr = RAM[oper]|(RAM[oper+1]<<8); RAM[addr] = lo(vA); RAM[addr+1] = hi(vA);
LSLW(0xe9)               vA = vA << 1;
BCC(0x35) EQ(0x3f) addr  if (vA == 0) vPC = hi(vPC)|addr;
BCC(0x35) GT(0x4d) addr  if (vA > 0) vPC = hi(vPC)|addr;
BCC(0x35) LT(0x50) addr  if (vA < 0) vPC = hi(vPC)|addr;
BCC(0x35) GE(0x53) addr  if (vA >= 0) vPC = hi(vPC)|addr;
BCC(0x35) LE(0x56) addr  if (vA <= 0) vPC = hi(vPC)|addr;
BCC(0x35) NE(0x73) addr  if (vA != 0) vPC = hi(vPC)|addr;
BRA(0x90)                vPC = hi(vPC)|addr;
LUP((0x7f) oper          vA = ROM[vA | (oper<<8)];
CALL(0xcf) oper          vLR = vPC+2; vPC = RAM[oper] | (RAM[oper+1]<<8);
RET(0xff)                vPC = vLR-2;
PUSH(0x75)               RAM[--vSP] = lo(vLR); RAM[--vSP] = hi(vLR);
POP(0x63)                vLR = RAM[vSP] | (RAM[vSP+1]<<8); vSP += 2;
ALLOC(0xdf) oper         vSP += oper;
DEF(0xcd) oper           vA = vCP+2; vCP = hi(vCP)|oper;
SYS(0xb4) ticks          syscall(RAM[0x22] | (RAM[0x23]<<8));

De SYS-instructie voert de systeemaanroep uit waarvan het adres is opgeslagen in sysFn (locaties 0x22 en 0x23). De argumenten voor de aanroep staan in sysArgs (locaties 0x24 tot 0x2b).

Systeemaanroepen:

  • SYSRandom34 (0x04a7)
  • SYSLSRW730 (0x04b9)
  • SYSLSRW824 (0x04c6)
  • SYSLSLW824 (0x04cd)
  • SYSDraw430 (0x04d4)
  • SYSVDrawBits134 (0x04e1)
  • SYSLSRW148 (0x0600)
  • SYSLSRW252 (0x0619)
  • SYSLSRW352 (0x0636)
  • SYSLSRW450 (0x0652)
  • SYSLSRW550 (0x066d)
  • SYSLSRW648 (0x0687)
  • SYSLSLW446 (0x06a0)
  • SYSRead340 (0x06c0)
  • SYSPayloadCopy34 (0x06e7)
  • SYSRacerUpdateVideoX40 (0xd700)
  • SYSRacerUpdateVideoY40 (0xd719)
  • SYSLoaderProcessInput48 (0xd731)
  • SYSReset36 (0x009a)
  • SYSExec88 (0x00ad)
  • SYSOut22 (0x00f4)
  • SYSIn24 (0x00f9)
  • SYSNextByteIn32 (0x02e9)

Mapping van GLC naar vCPU-instructies

De onderstaande tabel beschrijft de koppeling tussen GLC-taalelementen en vCPU-instructies.

GLC ElementvCPU Instructie
if<>0BCC EQ addr
if=;0BCC NE addr
if>=0BCC LT addr
if<=0BCC GT addr
if>0BCC LE addr
if<0BCC GE addr
if<>0loopBCC EQ addr
if=;0loopBCC NE oper
if>=0loopBCC LT addr
if<=0loopBCC GT addr
if>0loopBCC LE addr
if<0loppBCC GE addr
elseBRA addr
pushPUSH
popPOP
retRET
callCALL oper
peekPEEK
XLDW addr(X)
[0..255]LDI oper
[256..65,535]LDWI oper oper
[0..255];LDW oper
X=STW addr(X)
[0..255]=STW oper
X+ADDW addr(X)
[0..255]+ADDI oper
X;-SUBW addr(X)
[0..255]-SUBI oper
X&ANDW addr(X)
[0..255]&ANDI oper
`X\`ORIW addr(X)
`[0..255]\`ORI oper
X^XORIW addr(X)
[0..255]^XORI oper
[0..255]<<LSLW (repeated)
[0..255]--ALLOC (-oper&255)
[0..255]++ALLOC oper
[0..255]%=STLW oper
[0..255]%=LDLW oper
[0..255]#oper
[0..255]?LUP oper
[0..255].ST oper
[0..255],LD oper
X.POKE addr(X)
X<ST addr(X)
X>ST addr(X)+1
X,LDW addr(X) PEEK
[0..255]<++INC oper
X<++INC addr(X)
X>++INC addr(X)+1
X<,LD addr(X)
X>,LD addr(X)+1
X!CALL addr(X)

Grammatica voor gt-C

Hieronder volgt de grammatica voor gt-C, een zeer beperkte subset van C, die dient als basis voor het schrijven van een compiler.

primary_expr
: ident
| int
| char
| "(" expr ")"
.

postfix_expr
: postfix_expr "[" expr "]"  [array]
| postfix_expr "(" assignment_expr LIST OPT ")"  [call]
| postfix_expr "++"  [post_inc]
| postfix_expr "--"  [post_dec]
| primary_expr
.

unary_expr
: "++" unary_expr  [pre_inc]
| "--" unary_expr  [pre_dec]
| "-" cast_expr  [min]
| "~" cast_expr  [invert]
| "!" cast_expr  [not]
| postfix_expr
.

cast_expr
: "(" simple_type ")" cast_expr  [cast]
| unary_expr
.

l_expr2 : l_expr2 "+" cast_expr  [add]
| l_expr2 "-" cast_expr  [sub]
| cast_expr
.

l_expr3 : l_expr3 "<<" l_expr2  [ls]
| l_expr3 ">>" l_expr2  [rs]
| l_expr2
.

l_expr4 : l_expr4 "<=" l_expr3  [le]
| l_expr4 ">=" l_expr3  [ge]
| l_expr4 "<"  l_expr3  [lt]
| l_expr4 ">"  l_expr3  [gt]
| l_expr4 "==" l_expr3  [eq]
| l_expr4 "!=" l_expr3  [ne]
| l_expr3
.

l_expr5 : l_expr5 "^"  l_expr4 [bexor] | l_expr4 .
l_expr6 : l_expr6 "&"  l_expr5 [band]  | l_expr5 .
l_expr7 : l_expr7 "|"  l_expr6 [bor]   | l_expr6 .
l_expr8 : l_expr8 "&&" l_expr7 [land]  | l_expr7 .
l_expr9 : l_expr9 "||" l_expr8 [lor]   | l_expr8 .

conditional_expr
: l_expr9 "?" l_expr9 ":" conditional_expr  [if_expr]
| l_expr9
.

assignment_expr
: unary_expr "=" assignment_expr  [ass]
| unary_expr "+=" assignment_expr  [add_ass]
| unary_expr "-=" assignment_expr  [sub_ass]
| unary_expr "<<=" assignment_expr  [sl_ass]
| unary_expr ">>=" assignment_expr  [sr_ass]
| unary_expr "&=" assignment_expr  [and_ass]
| unary_expr "|=" assignment_expr  [or_ass]
| unary_expr "^=" assignment_expr  [exor_ass]
| conditional_expr
.

expr    : assignment_expr LIST.

simple_type
: "word" [word]
| "byte" [byte]
.

func_decl
: ("void"[void]|simple_type) ident "(" (simple_type ident)LIST OPT ")"
"{" statement SEQ OPT "}" [funcdef]
.

statement
: "{" statement SEQ OPT "}"
| simple_type ident ("=" conditional_expr) OPT ";" [vardecl]
| expr OPT ";" [expr]
| "if" "(" expr ")" statement  ("else" statement) OPT  [if]
| "while" "(" expr ")" statement  [while]
| "do" statement "while" "(" expr ")" ";"  [do]
| "for" "(" (simple_type OPT ident "=" expr)OPT ";"
expr OPT ";"
expr OPT ")" statement  [for]
| "continue" ";"  [cont]
| "break" ";"  [break]
| "return" expr OPT ";"  [ret]
.

root    : ( func_decl | statement ) SEQ OPT eof
.

Eerste doelprogramma

Het eerste programma waar ik aan ga werken, is een implementatie van Conway's Game of Life. Dit programma maakt geen gebruik van alle constructies uit de bovenstaande grammatica.

// Clear the screen
for (word h = 0; h < 200; h++)
    for (word v = 0; v < 200; v++)
        setScreen(h, v, 0);

// Initialize some random part
for (word h = 90; h < 110; h++)
    for (word v = 90; v < 110; v++)
        if (random() < 110)
            setScreen(h, v, 0x3f);

while (true)
{
    for (word h = 1; h < 199; h++)
        for (word v = 1; v < 199; v++)
        {
            word c = 0;
            word vk = v - 1;
            if (getScreen(h-1,vk) < 0) c++;
            vk++;
            if (getScreen(h-1,vk) < 0) c++;
            vk++;
            if (getScreen(h-1,vk) < 0) c++;
            vk -= 2;
            if (getScreen(h,vk) < 0) c++;
            vk++;
            word m = getScreen(h, vk) & 0x3f;
            vk++;
            if (getScreen(h,vk) & 0x3f != 0) c++;
            vk -= 2;
            if (getScreen(h+1,vk) & 0x3f != 0) c++;
            vk++;
            if (getScreen(h+1,vk) & 0x3f != 0) c++;
            vk++;
            if (getScreen(h+1,vk) & 0x3f != 0) c++;

            if (m != 0)
            {
                if (c == 2 || c == 3)
                    m = 0xff;
                else
                    m = 0xd0;
            }
            else
            {
                if (c == 3)
                    m = 0x3f;
                else
                    m = 0;
            }
            setScreen(h, v, m);
        }
}