Come rendere l'emulatore 8051

Question

Per scopi didattici, intendo iniziare a costruire un emulatore di microcontroller 8051. Sono a mio agio nella programmazione in C/C++/C#. Questo non è un progetto di classe ecc. Ma un'iniziativa di apprendimento dalla mia parte.

Ho trovato un sacco di domande su questo argomento. Tuttavia, ho voluto rompere un po 'più a livello granulare in modo da poter sapere quali aree ho bisogno di mettere a fuoco prima di iniziare effettivamente a scrivere il codice.

miei requisiti iniziali sono:

1. editor di testo (è possibile utilizzare il controllo EditBox), dove l'utente può scrivere codice assembly

2. confermare se la sintassi è corretta

3. Avere piccola finestra che mostra i valori del registro in fase di esecuzione.

4. quando l'utente avvia il programma, le istruzioni dovrebbero essere passo passo aggiornando le finestre di registro.

Più dell'elemento GUI sono più interessato a sapere come emulare il microcontrollore.

Il modo in cui ho capito che posso rompere ulteriormente verso il basso:

1. ho bisogno di avere una tabella di ricerca per le istruzioni o qualche altro modo per memorizzare le istruzioni disponibili e convalidare la sintassi. Qualsiasi suggerimento su come implementarlo, per favore fatemelo sapere.

2. Come si emula ciascuna istruzione per 8051?

3. Per i registri, posso avere l'uso di interi un/signed in base al tipo e aggiornare la tabella.

4. Poiché il microcontrollore ha una memoria RAM limitata, come posso mantenere un controllo della lunghezza del codice o piuttosto del codice che si sta eseguendo nella memoria per evitare e bufferare l'overflow o altri problemi.

Se ci sono alcuni progetti opensource che descrivono dettagliatamente come viene costruito un emulatore, apprezzeremmo.

Answer 1

Penso che tu sia un po 'oscuro sulla portata di questo progetto, almeno in relazione al titolo.

Un emulatore esegue codice binario e nient'altro. L'emulatore non include un editor (che è uno strumento di sviluppo) né un assemblatore (idem). È responsabilità dell'assemblatore eseguire il controllo e la traduzione della sintassi, in questo modo l'emulatore ha solo il compito relativamente facile di eseguire un codice legale pre-validato.

Sembra che si desideri creare un IDE completo. Questo avrebbe avvolto un sacco di GUI per l'editor, l'assemblatore e l'emulatore. Vorrei lasciare quel passo come l'ultimo.

---

Per quanto riguarda le vostre domande per quanto riguarda l'emulatore stesso:

È possibile utilizzare una serie di fino a (per esempio) 64K byte come memoria di lavoro dell'emulatore. Si usano variabili nel programma per emulare i registri. Mi piacerebbe usare un unsigned char * di emulare il contatore di programma, e int s per la maggior parte altre cose ...

Il funzionamento è piuttosto semplice: avviare il contatore programma a 0 (o un determinato pre-posizione di avvio), e l'avvio un ciclo che recupera le istruzioni tramite quel puntatore e applica ai registri e alla memoria qualsiasi operazione associata all'istruzione. Una semplice implementazione verrebbe centrata su un'enorme istruzione switch che include tutti i possibili codici di istruzioni.

Come ho detto, il tuo emulatore non dovrebbe preoccuparsi di istruzioni illegali, perché l'assemblatore non dovrebbe produrne. Potresti avere il tuo programma (cioè il ciclo principale) che si arresta se colpisce un'operazione illegale.

Allo stesso modo, il tuo emulatore non deve preoccuparsi del superamento di intervalli, indici o dimensioni ... questo è anche il problema dell'assemblatore, o forse del linker, se ne hai uno.

---

Aggiornamento: Alcune indicazioni da destra qui in SO:

Emulator Framework

Answer 2

Recentemente ho messo insieme un emulatore per il chip AVR, che è anche un piccolo microcontroller 8-bit. La fonte è su GitHub come ghewgill/emulino. Il file più interessante è cpu.c che contiene le implementazioni per ogni istruzione della CPU. Le linee principali sono cpu_run() (omettendo alcuni dettagli):

while (state == CPU_RUN) { 
    u16 instr = Program[PC++]; 
    Instr[instr](instr); 
} 

Questo carica una parola di 16 bit dalla memoria di programma indicato dal registro PC, allora usi che come indice in una tabella di salto (che è una matrice di 64k di puntatori di funzione - la tabella effettiva viene generata da uno script in fase di compilazione). Questa funzione sarà una delle funzioni do_XXX() in quel file sorgente e potrebbe eseguire ulteriori decodifiche delle istruzioni prima di eseguire l'istruzione effettiva. Ad esempio, la funzione do_ADD():

static void do_ADD(u16 instr) 
{ 
    trace(__FUNCTION__); 
    // ------rdddddrrrr 
    u16 r = (instr & 0xf) | ((instr >> 5) & 0x10); 
    u16 d = ((instr >> 4) & 0x1f); 
    u8 x = Data.Reg[d] + Data.Reg[r]; 
    Data.SREG.H = (((Data.Reg[d] & Data.Reg[r]) | (Data.Reg[r] & ~x) | (~x & Data.Reg[d])) & 0x08) != 0; 
    Data.SREG.V = (((Data.Reg[d] & Data.Reg[r] & ~x) | (~Data.Reg[d] & ~Data.Reg[r] & x)) & 0x80) != 0; 
    Data.SREG.N = (x & 0x80) != 0; 
    Data.SREG.S = Data.SREG.N^Data.SREG.V; 
    Data.SREG.Z = x == 0; 
    Data.SREG.C = (((Data.Reg[d] & Data.Reg[r]) | (Data.Reg[r] & ~x) | (~x & Data.Reg[d])) & 0x80) != 0; 
    Data.Reg[d] = x; 
    Cycle++; 
} 

Ciò l'operazione di addizione effettivo (Data.Reg[d] + Data.Reg[r]), quindi imposta i vari flag di condizione in base al risultato.