Talos ASM

An 'x' denotes any immediate value
An 'r' denotes a register - 0 for register A, 1 for register B
Instructions in <angled brackets> are useless, but reserving them should make logic easier

Control Instructions:

00000000 - Nop
01000000 - Halt

0r000001 - Move [!r] into [r]
0r000010 - Clear
0r000011 - ???
0r001000 - Load High Address
0r001001 - Store High Address
0r001010 - ???
0r001011 - ???

Arithmetic Instructions
The high register bit is where the result is stored
The low register bit (if it exists) is the source register/left register in the equation

e.g.
01011010 -> B = A / B

0r010000 - Add
0r010010 - Multiply

0r010001 - <Add>
0r010011 - <Multiply>

0r01100r - Subtract
0r01101r - Divide

Logical Instructions:
The two register bits work the same way as arithmetic.

0r100000 - And
0r100010 - Or
0r101000 - Xor

0r100001 - <And>
0r100011 - <Or>
0r101001 - <Xor>

0r10101r - Invert
0r11000r - Logical Left Shift
0r11001r - Logical Right Shift
0r11100r - <Arithmetic Left Shift>
0r11101r - Arithmetic Right Shift


2 bit Immediates:
All operations work on the single defined register.
Immediates are unsigned.

e.g.
00001110 -> A = A - 2

0r0001xx - Add Immediate
0r0011xx - Subtract Immediate
0r0101xx - ???
0r0111xx - ???
0r1001xx - Logical Left Shift Immediate
0r1011xx - Logical Right Shift Immediate
0r1101xx - <Arithmetic Left Shift Immediate>
0r1111xx - Arithmetic Right Shift Immediate

4 bit immediate:
Immediates are unsigned.

1000xxxx - Jump
1100xxxx - Branch Equal to Zero

1r01xxxx - Store
1r10xxxx - Load
1r11xxxx - Load Immediate



All instructions:

00000000 - Nop
00000001 - Move B into A
00000010 - Clear A
00000011
000001xx - Add Immediate A
00001000 - Load High Address A
00001001 - Store High Address A
00001010
00001011
000011xx - Subtract Immediate A
00010000 - Add, Store A
00010001 - <Add, Store A>
00010010 - Multiply, Store A
00010011 - <Multiply, Store A>
000101xx
00011000 - Subtract A, Store A
00011001 - Subtract B, Store A
00011010 - Divide A, Store A
00011011 - Divide B, Store A
000111xx
00100000 - And, Store A
00100001 - <And, Store A>
00100010 - Or, Store A
00100011 - <Or, Store A>
001001xx - LLShift Immediate A
00101000 - Xor, Store A
00101001 - <Xor, Store A>
00101010 - Invert A, Store A
00101011 - Invert B, Store A
001011xx - LRShift Immediate A
00110000 - LLShift A, Store A
00110001 - LLShift B, Store A
00110010 - LRShift A, Store A
00110011 - LRShift B, Store A
001101xx - <ALShift Immediate A>
00111000 - <ALShift A, Store A>
00111001 - <ALShift B, Store A>
00111010 - ARShift A, Store A
00111011 - ARShift B, Store A
001111xx - ARShift Immediate A
01000000 - Halt
01000001 - Move B into A
01000010 - Clear B
01000011
010001xx - Add Immediate B
01001000 - Load High Address B
01001001 - Store High Address B
01001010
01001011
010011xx - Subtract Immediate B
00010000 - Add, Store B
00010001 - <Add, Store B>
00010010 - Multiply, Store B
00010011 - <Multiply, Store B>
000101xx
00011000 - Subtract A, Store B
00011001 - Subtract B, Store B
00011010 - Divide A, Store B
00011011 - Divide B, Store B
010111xx
01100000 - And, Store B
01100001 - <And, Store B>
01100010 - Or, Store B
01100011 - <Or, Store B>
011001xx - LLShift Immediate B
01101000 - Xor, Store B
01101001 - <Xor, Store B>
01101010 - Invert A, Store B
01101011 - Invert B, Store B
011011xx - LRShift Immediate B
01110000 - LLShift A, Store B
01110001 - LLShift B, Store B
01110010 - LRShift A, Store B
01110011 - LRShift B, Store B
011101xx - <ALShift Immediate B>
01111000 - <ALShift A, Store B>
01111001 - <ALShift B, Store B>
01111010 - ARShift A, Store B
01111011 - ARShift A, Store B
011111xx - ARShift Immediate B
1000xxxx - Jump
1001xxxx - Store A
1010xxxx - Load A
1011xxxx - Load Immediate A
1100xxxx - Branch Equal to Zero
1101xxxx - Store B
1110xxxx - Load B
1111xxxx - Load Immediate B