Come XOR su una CPU che non ha un'istruzione XOR

Question

Questa è più di una domanda solo per divertimento. Sto lavorando su una CPU SC61860, che è una CPU a 8 bit per un PC Pocket PC 1360 Sharp del 1987 (utilizzato anche in PC-1401 & 1403). Il suo set di istruzioni in realtà non include un XOR. Ha istruzioni AND, OR, comparative, sottrazione e aggiunta.

Ho provato alcune variazioni dei valori di ANDing e ORing per ottenere risultati che XOR avrebbe prodotto, ma senza fortuna. Speravo di evitare il confronto, ma sembra che non ho scelta.

Se sei interessato, puoi dare un'occhiata allo instruction set.

BTW, questa CPU è stata fantastica per imparare il montaggio. Bello e semplice, e abbastanza lento (768kHz) che il linguaggio macchina è notevolmente più veloce che usare i computer costruiti in BASIC;) Di solito programma in C/C++/Java. Il montaggio è stato una boccata d'aria fresca.

Answer 1

dell'algebra booleana sappiamo che:

A XOR B = (NOT(A) AND B) OR (A AND NOT(B)) 

Aggiornamento: Grazie @Brett Hale, @slebetman, come la CPU sorprendentemente non sostenere l'istruzione NOT, può essere emulato da negazione aritmetica e sottrazione , assumendo complemento a 2 negativi rappresentazione):

NOT(A) = (-1) - A 

o in caso di diversa rappresentazione negativa della -1 può essere sostituito dal valore massimo del tipo di memoria corrispondente (ad es. 255 per registri a 8 bit o 65565 per registri a 16 bit).

Answer 2

Chiazza di petrolio! Grazie, ha funzionato davvero bene.

9 XOR 11 = 2 

a XOR b = (NOT(a) AND b) OR (a AND NOT(b)) 
     = ((255-9) and 11) or (9 and (255-11)) 
     = (246 and 11) or (9 and 244)  
     = 2 or 0 
     = 2 

Ecco il programma che utilizza registri a 8 bit. Per utilizzare 2 registri insieme, come per ANDing, devi puntare P al secondo registro. Quindi è possibile [P] e A -> P:

############################################################################## 
## xor.asm 
## perform a logical XOR operation on numA and numB and store to numC 
## numC = numA XOR numB 
############################################################################## 

       $JR 
       org  &C030 

       jp  start 

I_REG   equ  0    # Internal Registers 
J_REG   equ  1 
A_REG   equ  2 
B_REG   equ  3 
XL_REG   equ  4 
XH_REG   equ  5 
YL_REG   equ  6 
YH_REG   equ  7 
K_REG   equ  8 
L_REG   equ  9 
M_REG   equ  10 
N_REG   equ  11 
PORTC   equ  95 

numA:   db  9 
numB:   db  11 
numC:   db  0 

# EXAB   A <-> B 
# SBM   [P] - A -> [P] 
# ANMA   [P] and A -> [P] 
# ORMA   [P] or A -> [P] 
# PUSH   push A onto the stack 
# POP   pop A from the stack 

start:   lp  B_REG   # point P to the B register 
       lidp numA   # (not a & b) 
       ldd      # A = numA 
       lib  255 
       sbm      # B = 255 - numA 
       lidp numB   # A = numB 
       ldd 
       anma     # B = 255-numA & numB 
       exab     # swap A and B to store result on the stack 
       push     # push A (result) to the stack 

       lidp numB   # (a & not b) 
       ldd 
       lib  255 
       sbm      # B = 255 - numB, B = not b 
       lidp numA 
       ldd 
       anma     # B = numA & (255 - numB) 
       pop      # grab the first result 
       orma     # B = final result 
       lidp numC 
       exab 
       std      # numC = numA XOR numB 

end:   rtn