v2.0 raw ### CHOSEN instructions (see InstrDec.hex): #uCode #-In-NAME--+----INPUTS---INPUTS--+ #WOOCCR # Acc | 11110000 11110000 | #WOOCCR # Reg | 11001100 11001100 | #WOOCCR # Ci | 10101010 10101010 | #uCode #-In-NAME--+-Wr-ALU-OUT-CrryCtrl-+ 0f0aa0 # 00 NOP | 11110000 10101010 | "Do nothing" [Ignore Reg,C] 0aaf00 # 01 SHL | 10101010 11110000 | C<<--Acc<<--C PREV 8x [Ignore Reg] 0f0000 # 02 CCLR | 11110000 00000000 | C=0 (Acc=Acc) PREV 0x [Ignore Reg] 0f0ff0 # 03 CSET | 11110000 11111111 | C=1 (Acc=Acc) PREV 1x [Ignore Reg] 0f00a0 # 04 IfZ | 11110000 00001010 | if C=1 and Acc==0 [Ignore Reg] 0f0fa0 # 05 IfNZ | 11110000 11111010 | if C=0 and Acc!=0 [Ignore Reg] 0f0f00 # 06 IfNeg | 11110000 11110000 | C=1 if A is -ve (top bit 1) [Ignore Reg,C] 0f00f0 # 07 IfPos | 11110000 00001111 | C=1 if A is +ve (top bit 0) [Ignore Reg,C] 0aa000 # 08 CONE | 10101010 00000000 | Acc = 0 or 1 (from C) [Ignore Reg,Acc] 0aaaa0 # 09 CFF | 10101010 10101010 | Acc = 0 or -1 (from )C [Ignore Reg,Acc] 00faa0 # 0a INV | 00001111 10101010 | Acc = !Acc [Ignore Reg,C] 05aaa0 # 0b CINV | 01011010 10101010 | If C then Acc=!Acc [Ignore Reg] 05aa00 # 0c CINC | 01011010 10100000 | Acc++ if C [Ignore Reg] 05a0a0 # 0d CDEC | 01011010 00001010 | Acc-- if C [Ignore Reg] 0a50a0 # 0e NEG | 10100101 00001010 | Acc=-Acc if C=1 else Acc=!Acc [Ignore Reg] 000aa0 # 0f 0 | 00000000 10101010 | Acc=0 [CONST] 0ccaa0 # 10 FETCH | 11001100 10101010 | Acc = E PREV 20 0ccaa1 # 11 FETCH | 11001100 10101010 | Acc = F PREV 21 0ccaa2 # 12 FETCH | 11001100 10101010 | Acc = G PREV 22 0ccaa3 # 13 FETCH | 11001100 10101010 | Acc = H PREV 23 0ccaa4 # 14 FETCH | 11001100 10101010 | Acc = I PREV 24 0ccaa5 # 15 FETCH | 11001100 10101010 | Acc = J PREV 25 0ccaa6 # 16 FETCH | 11001100 10101010 | Acc = K PREV 26 0ccaa7 # 17 FETCH | 11001100 10101010 | Acc = L PREV 27 0ccaa8 # 18 FETCH | 11001100 10101010 | Acc = M PREV 28 0ccaa9 # 19 FETCH | 11001100 10101010 | Acc = N PREV 29 0ccaaa # 1a FETCH | 11001100 10101010 | Acc = A PREV 2a 0ccaab # 1b FETCH | 11001100 10101010 | Acc = P PREV 2b 0ccaac # 1c FETCH | 11001100 10101010 | Acc = C PREV 2c 0ccaad # 1d FETCH | 11001100 10101010 | Acc = D PREV 2d 0ccaae # 1e FETCH | 11001100 10101010 | Acc = [AD++] PREV 2e 0ccaaf # 1f FETCH | 11001100 10101010 | Acc = [PC++] PREV 2f 1f0aa0 # 20 STORE | Y 11110000 10101010 | E = Acc PREV 30 1f0aa1 # 21 STORE | Y 11110000 10101010 | F = Acc PREV 31 1f0aa2 # 22 STORE | Y 11110000 10101010 | G = Acc PREV 32 1f0aa3 # 23 STORE | Y 11110000 10101010 | H = Acc PREV 33 1f0aa4 # 24 STORE | Y 11110000 10101010 | I = Acc PREV 34 1f0aa5 # 25 STORE | Y 11110000 10101010 | J = Acc PREV 35 1f0aa6 # 26 STORE | Y 11110000 10101010 | K = Acc PREV 36 1f0aa7 # 27 STORE | Y 11110000 10101010 | L = Acc PREV 37 1f0aa8 # 28 STORE | Y 11110000 10101010 | M = Acc PREV 38 1f0aa9 # 29 STORE | Y 11110000 10101010 | N = Acc PREV 39 1f0aaa # 2a STORE | Y 11110000 10101010 | A = Acc PREV 3a 1f0aab # 2b STORE | Y 11110000 10101010 | P = Acc PREV 3b 1f0aac # 2c STORE | Y 11110000 10101010 | C = Acc - JUMP! PREV 3c 1f0aad # 2d STORE | Y 11110000 10101010 | D = Acc PREV 3d 1f0aae # 2e STORE | Y 11110000 10101010 | [--AD] = Acc PREV 3e 1f0aaf # 2f STORE | Y 11110000 10101010 | [--PC] = Acc - (ab)usable as HALT PREV 3f 2d8aa0 # 30 CSTORE| C 11011000 10101010 | if C then E = Acc else Acc = E PREV 40 2d8aa1 # 31 CSTORE| C 11011000 10101010 | if C then F = Acc else Acc = F PREV 41 2d8aa2 # 32 CSTORE| C 11011000 10101010 | if C then G = Acc else Acc = G PREV 42 2d8aa3 # 33 CSTORE| C 11011000 10101010 | if C then H = Acc else Acc = H PREV 43 2d8aa4 # 34 CSTORE| C 11011000 10101010 | if C then I = Acc else Acc = I PREV 44 2d8aa5 # 35 CSTORE| C 11011000 10101010 | if C then J = Acc else Acc = J PREV 45 2d8aa6 # 36 CSTORE| C 11011000 10101010 | if C then K = Acc else Acc = K PREV 46 2d8aa7 # 37 CSTORE| C 11011000 10101010 | if C then L = Acc else Acc = L PREV 47 2d8aa8 # 38 CSTORE| C 11011000 10101010 | if C then M = Acc else Acc = M PREV 48 2d8aa9 # 39 CSTORE| C 11011000 10101010 | if C then N = Acc else Acc = N PREV 49 2d8aaa # 3a CSTORE| C 11011000 10101010 | if C then A = Acc else Acc = A PREV 4a 2d8aab # 3b CSTORE| C 11011000 10101010 | if C then P = Acc else Acc = P PREV 4b 2d8aac # 3c CSTORE| C 11011000 10101010 | if C then C = Acc else Acc = C (cond jumps) PREV 4c 2d8aad # 3d CSTORE| C 11011000 10101010 | if C then D = Acc else Acc = D PREV 4d 2d8aae # 3e CSTORE| C 11011000 10101010 | if C then [AD++] = Acc else Acc = [--AD] PREV 4e 2d8aaf # 3f CSTORE| C 11011000 10101010 | if C then [PC++] = Acc else Acc = [--PC] PREV 4f 0e4aa0 # 40 ELSE | 11100100 10101010 | if C then NOP else Acc = E PREV 50 0e4aa1 # 41 ELSE | 11100100 10101010 | if C then NOP else Acc = F PREV 51 0e4aa2 # 42 ELSE | 11100100 10101010 | if C then NOP else Acc = G PREV 52 0e4aa3 # 43 ELSE | 11100100 10101010 | if C then NOP else Acc = H PREV 53 0e4aa4 # 44 ELSE | 11100100 10101010 | if C then NOP else Acc = I PREV 54 0e4aa5 # 45 ELSE | 11100100 10101010 | if C then NOP else Acc = J PREV 55 0e4aa6 # 46 ELSE | 11100100 10101010 | if C then NOP else Acc = K PREV 56 0e4aa7 # 47 ELSE | 11100100 10101010 | if C then NOP else Acc = L PREV 57 0e4aa8 # 48 ELSE | 11100100 10101010 | if C then NOP else Acc = M PREV 58 0e4aa9 # 49 ELSE | 11100100 10101010 | if C then NOP else Acc = N PREV 59 0e4aaa # 4a ELSE | 11100100 10101010 | if C then NOP else Acc = A PREV 5a 0e4aab # 4b ELSE | 11100100 10101010 | if C then NOP else Acc = P PREV 5b 0e4aac # 4c ELSE | 11100100 10101010 | if C then NOP else Acc = C PREV 5c 0e4aad # 4d ELSE | 11100100 10101010 | if C then NOP else Acc = D PREV 5d 0e4aae # 4e ELSE | 11100100 10101010 | if C then AD++ else Acc = [AD++] PREV 5e 0e4aaf # 4f ELSE | 11100100 10101010 | if C then PC++ else Acc = [PC++] PREV 5f 096e80 # 50 ADD | 10010110 11101000 | Acc = (Acc + E + C) PREV 60 096e81 # 51 ADD | 10010110 11101000 | Acc = (Acc + F + C) PREV 61 096e82 # 52 ADD | 10010110 11101000 | Acc = (Acc + G + C) PREV 62 096e83 # 53 ADD | 10010110 11101000 | Acc = (Acc + H + C) PREV 63 096e84 # 54 ADD | 10010110 11101000 | Acc = (Acc + I + C) PREV 64 096e85 # 55 ADD | 10010110 11101000 | Acc = (Acc + J + C) PREV 65 096e86 # 56 ADD | 10010110 11101000 | Acc = (Acc + K + C) PREV 66 096e87 # 57 ADD | 10010110 11101000 | Acc = (Acc + L + C) PREV 67 096e88 # 58 ADD | 10010110 11101000 | Acc = (Acc + M + C) PREV 68 096e89 # 59 ADD | 10010110 11101000 | Acc = (Acc + N + C) PREV 69 096e8a # 5a ADD | 10010110 11101000 | Acc = (Acc + A + C) PREV 6a 096e8b # 5b ADD | 10010110 11101000 | Acc = (Acc + P + C) PREV 6b 096e8c # 5c ADD | 10010110 11101000 | Acc = (Acc + C + C) PREV 6c 096e8d # 5d ADD | 10010110 11101000 | Acc = (Acc + D + C) PREV 6d 096e8e # 5e ADD | 10010110 11101000 | Acc = (Acc + [AD++] + C) PREV 6e 096e8f # 5f ADD | 10010110 11101000 | Acc = (Acc + [PC++] + C) PREV 6f 0968e0 # 60 SUB | 10010110 10001110 | Acc = (Acc - E - C) PREV 70 0968e1 # 61 SUB | 10010110 10001110 | Acc = (Acc - F - C) PREV 71 0968e2 # 62 SUB | 10010110 10001110 | Acc = (Acc - G - C) PREV 72 0968e3 # 63 SUB | 10010110 10001110 | Acc = (Acc - H - C) PREV 73 0968e4 # 64 SUB | 10010110 10001110 | Acc = (Acc - I - C) PREV 74 0968e5 # 65 SUB | 10010110 10001110 | Acc = (Acc - J - C) PREV 75 0968e6 # 66 SUB | 10010110 10001110 | Acc = (Acc - K - C) PREV 76 0968e7 # 67 SUB | 10010110 10001110 | Acc = (Acc - L - C) PREV 77 0968e8 # 68 SUB | 10010110 10001110 | Acc = (Acc - M - C) PREV 78 0968e9 # 69 SUB | 10010110 10001110 | Acc = (Acc - N - C) PREV 79 0968ea # 6a SUB | 10010110 10001110 | Acc = (Acc - A - C) PREV 7a 0968eb # 6b SUB | 10010110 10001110 | Acc = (Acc - P - C) PREV 7b 0968ec # 6c SUB | 10010110 10001110 | Acc = (Acc - C - C) PREV 7c 0968ed # 6d SUB | 10010110 10001110 | Acc = (Acc - D - C) PREV 7d 0968ee # 6e SUB | 10010110 10001110 | Acc = (Acc - [AD++] - C) PREV 7e 0968ef # 6f SUB | 10010110 10001110 | Acc = (Acc - [PC++] - C) PREV 7f 0c0ea0 # 70 AND | 11000000 11101010 | C=1 if Acc AND E non-zero PREV 90 0c0ea1 # 71 AND | 11000000 11101010 | C=1 if Acc AND F non-zero PREV 91 0c0ea2 # 72 AND | 11000000 11101010 | C=1 if Acc AND G non-zero PREV 92 0c0ea3 # 73 AND | 11000000 11101010 | C=1 if Acc AND H non-zero PREV 93 0c0ea4 # 74 AND | 11000000 11101010 | C=1 if Acc AND I non-zero PREV 94 0c0ea5 # 75 AND | 11000000 11101010 | C=1 if Acc AND J non-zero PREV 95 0c0ea6 # 76 AND | 11000000 11101010 | C=1 if Acc AND K non-zero PREV 96 0c0ea7 # 77 AND | 11000000 11101010 | C=1 if Acc AND L non-zero PREV 97 0c0ea8 # 78 AND | 11000000 11101010 | C=1 if Acc AND M non-zero PREV 98 0c0ea9 # 79 AND | 11000000 11101010 | C=1 if Acc AND N non-zero PREV 99 0c0eaa # 7a AND | 11000000 11101010 | C=1 if Acc AND A non-zero PREV 9a 0c0eab # 7b AND | 11000000 11101010 | C=1 if Acc AND P non-zero PREV 9b 0c0eac # 7c AND | 11000000 11101010 | C=1 if Acc AND C non-zero PREV 9c 0c0ead # 7d AND | 11000000 11101010 | C=1 if Acc AND D non-zero PREV 9d 0c0eae # 7e AND | 11000000 11101010 | C=1 if Acc AND [AD++] non-zero PREV 9e 0c0eaf # 7f AND | 11000000 11101010 | C=1 if Acc AND [PC++] non-zero PREV 9f 0fcfe0 # 80 OR | 11111100 11111110 | C=1 if Acc OR E non-zero PREV a0 0fcfe1 # 81 OR | 11111100 11111110 | C=1 if Acc OR F non-zero PREV a1 0fcfe2 # 82 OR | 11111100 11111110 | C=1 if Acc OR G non-zero PREV a2 0fcfe3 # 83 OR | 11111100 11111110 | C=1 if Acc OR H non-zero PREV a3 0fcfe4 # 84 OR | 11111100 11111110 | C=1 if Acc OR I non-zero PREV a4 0fcfe5 # 85 OR | 11111100 11111110 | C=1 if Acc OR J non-zero PREV a5 0fcfe6 # 86 OR | 11111100 11111110 | C=1 if Acc OR K non-zero PREV a6 0fcfe7 # 87 OR | 11111100 11111110 | C=1 if Acc OR L non-zero PREV a7 0fcfe8 # 88 OR | 11111100 11111110 | C=1 if Acc OR M non-zero PREV a8 0fcfe9 # 89 OR | 11111100 11111110 | C=1 if Acc OR N non-zero PREV a9 0fcfea # 8a OR | 11111100 11111110 | C=1 if Acc OR A non-zero PREV aa 0fcfeb # 8b OR | 11111100 11111110 | C=1 if Acc OR P non-zero PREV ab 0fcfec # 8c OR | 11111100 11111110 | C=1 if Acc OR C non-zero PREV ac 0fcfed # 8d OR | 11111100 11111110 | C=1 if Acc OR D non-zero PREV ad 0fcfee # 8e OR | 11111100 11111110 | C=1 if Acc OR [AD++] non-zero PREV ae 0fcfef # 8f OR | 11111100 11111110 | C=1 if Acc OR [PC++] non-zero PREV af 03c960 # 90 XOR | 00111100 10010110 | Acc = Acc XOR E, C = Parity(E,C) PREV b0 03c961 # 91 XOR | 00111100 10010110 | Acc = Acc XOR F, C = Parity(F,C) PREV b1 03c962 # 92 XOR | 00111100 10010110 | Acc = Acc XOR G, C = Parity(G,C) PREV b2 03c963 # 93 XOR | 00111100 10010110 | Acc = Acc XOR H, C = Parity(H,C) PREV b3 03c964 # 94 XOR | 00111100 10010110 | Acc = Acc XOR I, C = Parity(I,C) PREV b4 03c965 # 95 XOR | 00111100 10010110 | Acc = Acc XOR J, C = Parity(J,C) PREV b5 03c966 # 96 XOR | 00111100 10010110 | Acc = Acc XOR K, C = Parity(K,C) PREV b6 03c967 # 97 XOR | 00111100 10010110 | Acc = Acc XOR L, C = Parity(L,C) PREV b7 03c968 # 98 XOR | 00111100 10010110 | Acc = Acc XOR M, C = Parity(M,C) PREV b8 03c969 # 99 XOR | 00111100 10010110 | Acc = Acc XOR N, C = Parity(N,C) PREV b9 03c96a # 9a XOR | 00111100 10010110 | Acc = Acc XOR A, C = Parity(A,C) PREV ba 03c96b # 9b XOR | 00111100 10010110 | Acc = Acc XOR P, C = Parity(P,C) PREV bb 03c96c # 9c XOR | 00111100 10010110 | Acc = Acc XOR C, C = Parity(C,C) PREV bc 03c96d # 9d XOR | 00111100 10010110 | Acc = Acc XOR D, C = Parity(D,C) PREV bd 03c96e # 9e XOR | 00111100 10010110 | Acc = Acc XOR [AD], C = Parity([AD],C), AD++ PREV be 03c96f # 9f XOR | 00111100 10010110 | Acc = Acc XOR [PC], C = Parity([PC],C), PC++ PREV bf # +++ space for ax, bx, cx, dx, ex, fx opcodes #uCode #-In-NAME--+-Wr-ALU-OUT-CrryCtrl-+ #WOOCCR # Acc | 11110000 11110000 | #WOOCCR # Reg | 11001100 11001100 | #WOOCCR # Ci | 10101010 10101010 | #uCode #-In-NAME--+----INPUTS---INPUTS--+ #W------------------^ # OO------------------^^^^^^^^ # CC-------------------------^^^^^^^^ # R --- which register? or 0 ### Registers: # Hex Read Write # x0 E E \ # x1 F F | # x2 G G | # x3 H H | # x4 I I | Regular # x5 J J | Registers # x6 K K | # x7 L L | # x8 M M | # x9 N N / # xa A A' Part of AD # xb P P' Part of PC # xc C C Part of PC - Writes P'->P # xd D D Part of AD - Writes A'->A # xe [AD++] [--AD] AD Indirect with post-inc or pre-dec # xf [PC++] [--PC] PC Immediate with post-inc or pre-dec #uCode # In-NAME--+----INPUTS---INPUTS--+ #WOOCCR # Acc | 11110000 11110000 | #WOOCCR # Reg | 11001100 11001100 | #WOOCCR # Ci | 10101010 10101010 | #uCode # In-NAME--+-Wr-ALU-OUT-CrryCtrl-+ ### CARRY-ONLY OPERATIONS (complete) [Ignore Reg,Acc] #0??aa? # Co=Ci | 10101010 | NOP? #0??55? # Co=!Ci| 01010101 | BUT not after 2N (EG 8) bits :-/ #0??00? # CCLR | 00000000 | [CONST] #0??ff? # CSET | 11111111 | [CONST] ### CONDITIONS (Acc+Reg -> C) (incomplete) #0??0a? # A==0? | 00001010 | if C=1 [Ignore Reg] #0??fa? # A!=0? | 11111010 | if C=0 [Ignore Reg] #0??82? # A==R? | 10000010 | if C=1 #0??be? # A!=R? | 10111110 | if C=0 #0??22? # R==0? | 00100010 | if C=1 [Ignore Acc] #0??ee? # R!=0? | 11101110 | if C=0 [Ignore Acc] #0??02? # AR=0? | 00000010 | if C=1 #0??fe? # AR!=0?| 11111110 | if C=0 #0??8e? # AR? | 10110010 | if C=0, U8 #0??b2? # A>=R? | 10110010 | if C=1, U8 #0??f0? # A<0? | 11110000 | Cout=1 if A is -ve (top bit set) [Ignore Reg,C] #0??0f? # A>=0? | 00001111 | Cout=1 if A is +ve (top bit 0) [Ignore Reg,C] #0??cc? # R<0? | 11001100 | Cout=1 if R is -ve (top bit set) [Ignore Acc,C] #0??33? # R>=0? | 00110011 | Cout=1 if R is +ve (top bit 0) [Ignore Acc,C] #0??5a? # PArity| 01011010 | (XOR all bits of A inc C) [Ignore Reg] #0??66? # Rarity| 01100110 | (XOR all bits of R inc C) [Ignore Acc] #0??96? # RArity| 10010110 | (XOR all bits of A, R, C) ### A/R OPERATIONS (complete) [Ignore C] #000??? # 0 | 00000000 | [CONST] #003??? # NOR | 00000011 | #00c??? # R&!A | 00001100 | Reg AND !Aacc #00f??? # !A | 00001111 | INV [Ignore Reg,C] #030??? # A&!R | 00110000 | Acc AND !Reg #033??? # !Reg | 00110011 | [Ignore Acc,C] #03c??? # XOR | 00111100 | #03f??? # NAND | 00111111 | #0c0??? # AND | 11000000 | #0c3??? # NEXOR | 11000011 | #0cc??? # Reg | 11001100 | [Ignore Acc,C] #0cf??? # R|!A | 11001111 | Reg OR !Acc #0f0??? # Acc | 11110000 | NOP? [Ignore Reg,C] #0f3??? # A|!R | 11110011 | Acc OR !Reg #0fc??? # OR | 11111100 | #0ff??? # -1 | 11111111 | [CONST] ### OTHER CONSTANTS (consume C, but why not FETCH [PC++] ?!?) [Ignore Reg,Acc] #0aa00? # 1 | 10101010 00000000 | if C=1 #055ff? # 1 | 01010101 11111111 | if C=0 #05500? # -2 | 01010101 00000000 | if C=1 #0aaff? # -2 | 10101010 11111111 | if C=0 ### NEGATIONS #0a50a? # -Acc | 10100101 00001010 | if C=1 [Ignore Reg] #05afa? # -Acc | 01011010 11111010 | if C=0 [Ignore Reg] #09922? # -Reg | 10011001 00100010 | if C=1 [Ignore Acc] #066ee? # -Reg | 01100110 11101110 | if C=0 [Ignore Acc] ### MATHS / SHIFTS #096e8? # ADD | 10010110 11101000 | (A + R + C) #0692b? # ADD | 01101001 00101011 | (A + R + !C) #069b2? # SUB | 01101001 10110010 | (A - R - !C) #0968e? # SUB | 10010110 10001110 | (A - R - C) #0aaf0? # SHLA | 10101010 11110000 | C shifts in, Cout shifts out [Ignore Reg] #0aacc? # SHLR | 10101010 11001100 | C shifts in, Cout shifts out [Ignore Acc] ### "Use C to pick from any 2 A/R operations"... (V incomplete) #0e4aa? # C?A:R | 11100100 10101010 | if C then Acc, else Reg #0d8aa? # C?R:A | 11011000 10101010 | if C then Reg, else Acc #05aaa? # C?!A:A| 01011010 10101010 | invert A if C [Ignore Reg] CINV #0a5aa? # C?A:!A| 10100101 10101010 | invert A if !C [Ignore Reg] #066aa? # C?!R:R| 01100110 10101010 | invert R if C [Ignore Acc] #099aa? # C?R:!R| 10011001 10101010 | invert R if !C [Ignore Acc] ### ... Inc "C to Const" [Ignore Reg,Acc] #0aaaa? # C?-1:0| 10101010 10101010 | -C #055aa? # C?0:-1| 01010101 10101010 | -(!C) #0aa00? # C?1:0 | 10101010 00000000 | C #055ff? # C?0:1 | 01010101 11111111 | !C ### CONDITIONAL INC/DECs on Acc [Ignore Reg] #05aa0? # A+C | 01011010 10100000 | A++ if C #05a0a? # A-C | 01011010 00001010 | A-- if C #0a5af? # A+!C| 10100101 10101111 | A++ unless C #0a5fa? # A-!C| 10100101 11111010 | A-- unless C ### CONDITIONAL INC/DECs on Reg [Ignore Acc] #06688? # R+C | 01100110 10001000 | #06622? # R-C | 01100110 00100010 | #099bb? # R+!C| 10011001 10111011 | #099ee? # R-!C| 10011001 11101110 | #uCode # In-NAME--+-Wr-ALU-OUT-CrryCtrl-+ #WOOCCR # Acc | 11110000 11110000 | #WOOCCR # Reg | 11001100 11001100 | #WOOCCR # Ci | 10101010 10101010 | #uCode # In-NAME--+----INPUTS---INPUTS--+