Scrivere un emulatore grafico Z80 in C o C ++ [chiuso]

https://stackoverflow.com/questions/1215777

06-07-2019
|

Domanda

Voglio interessarmi a scrivere il mio semplice emulatore per il processore Z80 . Non ho esperienza con questo tipo di programmazione. Per lo più sto bene usando i linguaggi basati su C poiché sono quelli che conosco meglio.

Di cosa ho bisogno per raggiungere questo obiettivo e quali sono alcuni buoni tutorial / riferimenti che potrebbero aiutarmi in questo progetto?

Vorrei anche un tutorial per la codifica di un'applicazione ROM-dumping per il mio TI-84 Plus in modo da poter usare la sua ROM con questo emulatore.

Soluzione

Forse inizia guardando questi:

Un buon tutorial può essere trovato qui: Guida di montaggio indipendente Z80

DOCUMENTAZIONE Z80

The Undocumented Z80 Documented v0.91 (pdf)

Il riferimento completo alle istruzioni Z80

Riepilogo set di istruzioni per microprocessore Z80

Altri suggerimenti

È un po 'un viaggio laterale, ma poiché dici di non avere esperienza con questo tipo di programmazione, potresti voler iniziare creando un emulatore per Macchina virtuale universale dal concorso di programmazione ICFP 2006 . Questo è un compito che richiede a un programmatore esperto 90 minuti, ma molti team senza esperienza sono stati in grado di completarlo in pochi giorni. Quando finisci l'emulatore sblocca un sacco di cose divertenti e potrebbe essere un buon riscaldamento prima di affrontare la Z80.

Alcune cose da aggiungere (specialmente per Z80):

Non fidarti della documentazione è al 100% priva di bug

Non ho visto alcun bug senza quelli citati qui.
Testa correttamente il core della CPU per individuare eventuali bug

Ti salverà da molti mal di testa e confusione in seguito.

Per i test sto usando tre approcci:

Passaggio / tracciamento contro codice noto (di solito disassemblaggio ROM commentato)

È il primo passo quando non funziona ancora nulla. Vedrai istruzioni (de) codificate male.
Includi diversi core Z80 nel tuo emulatore ed elabora tutto come doppia emulazione

Crea due emulatori "separati" con lo stesso sistema di stepping, tracing e running. Entrambe le CPU dovrebbero avere il proprio hardware di memoria, ecc.
- Esegui l'emulatore e dopo ogni istruzione confronta i registri e le posizioni di memoria immediate come [hl], [sp], [sp-1] ...
- Alla prima differenza, fermati e guarda quali istruzioni l'hanno causata.
  Esegui il debug e continua fino a quando non sei "privo di bug". Attenzione, il secondo core può anche essere difettoso, quindi eseguire il debug con cautela.

Quando sei più in grado di correre, usa il core tester

Usa Esercitatore ZEXALL . È il migliore su Z80 (almeno dalla mia esperienza). Mi ha aiutato con molte cose (il mio core è ora compatibile al 100% con ZEXALL). Viene eseguito su hardware reale, quindi non ci sono bug. Viene da CP / M quindi alcune versioni richiedono 64K RAM mode per l'esecuzione. OS / ROM diversi o qualsiasi altra cosa può causare il fallimento di alcune istruzioni con accesso alla memoria, quindi per quelli è necessario trovare CRC corretti o confrontarli con l'hardware reale.

Ad esempio, ZEXALL non elaborato fallisce molte cose su ZX Spectrum (come avviene per MSX e 64K RAM senza ROM ), ma ci sono versioni fatte per il vero ZX Spectrum e sono al 100% OK su ZX Spectrum (e anche sul mio emulatore :))

Z80all instruction exerciser

<adc,sbc> hl,<bc,de,hl,sp>...OK
add hl,<bc,de,hl,sp>.........OK
add ix,<bc,de,ix,sp>.........OK
add iy,<bc,de,iy,sp>.........OK
aluop a,nn...................OK
aluop a,<b,c,d,e,h,l,(hl),a>.OK
aluop a,<ixh,ixl,iyh,iyl>....OK
aluop a,(<ix,iy>+1)..........OK
bit n,(<ix,iy>+1)............OK
bit n,<b,c,d,e,h,l,(hl),a>...OK
cpd<r>.......................OK
cpi<r>.......................OK
<daa,cpl,scf,ccf>............OK
<inc,dec> a..................OK
<inc,dec> b..................OK
<inc,dec> bc.................OK
<inc,dec> c..................OK
<inc,dec> d..................OK
<inc,dec> de.................OK
<inc,dec> e..................OK
<inc,dec> h..................OK
<inc,dec> hl.................OK
<inc,dec> ix.................OK
<inc,dec> iy.................OK
<inc,dec> l..................OK
<inc,dec> (hl)...............OK
<inc,dec> sp.................OK
<inc,dec> (<ix,iy>+1)........OK
<inc,dec> ixh................OK
<inc,dec> ixl................OK
<inc,dec>  iyh...............OK
<inc,dec> iyl................OK
ld <bc,de>,(nnnn)............OK
ld hl,(nnnn).................OK
ld sp,(nnnn).................OK
ld <ix,iy>,(nnnn)............OK
ld (nnnn),<bc,de>............OK
ld (nnnn),hl.................OK
ld (nnnn),sp.................OK
ld (nnnn),<ix,iy>............OK
ld <bc,de,hl,sp>,nnnn........OK
ld <ix,iy>,nnnn..............OK
ld a,<(bc),(de)>.............OK
ld <b,c,d,e,h,l,(hl),a>,nn...OK
ld (<ix,iy>+1),nn............OK
ld <b,c,d,e>,(<ix,iy>+1).....OK
ld <h,l>,(<ix,iy>+1).........OK
ld a,(<ix,iy>+1).............OK
ld <ixh,ixl,iyh,iyl>,nn......OK
ld <bcdehla>,<bcdehla>.......OK
ld <bcdexya>,<bcdexya>.......OK
ld a,(nnnn) / ld (nnnn),a....OK
ldd<r> (1)...................OK
ldd<r> (2)...................OK
ldi<r> (1)...................OK
ldi<r> (2)...................OK
neg..........................OK
<rrd,rld>....................OK
<rlca,rrca,rla,rra>..........OK
shf/rot (<ix,iy>+1)..........OK
shf/rot <b,c,d,e,h,l,(hl),a>.OK
<set,res> n,<bcdehl(hl)a>....OK
<set,res> n,(<ix,iy>+1)......OK
ld (<ix,iy>+1),<b,c,d,e>.....OK
ld (<ix,iy>+1),<h,l>.........OK
ld (<ix,iy>+1),a.............OK
ld (<bc,de>),a...............OK
Tests complete

Nel caso in cui tu stia per usare ZEXALL stai attento, è un test davvero esauriente e IIRC su ~ 50MHz emulazione ha richiesto 30-60 minimo per il completamento. E deve premere un tasto per scorrere alcune volte ...

Se è necessario un modello di contesa, aggiungere test appropriati. Quindi trovane uno. Per ZX Spectrum ci sono molti bus flottanti, interrupt e tester dello schermo. Per TI non ho idea ... (Non sono un TI utente calcolatrice)

A proposito: come è andata con il tuo emulatore? (L'hai fatto?)

Set di istruzioni

Vorrei copiare il mio set di istruzioni qui ma ha 1792 righe e 121 & nbsp; KB, quindi non si adatta a un limite di 30 & nbsp; KB. Invece puoi trovarlo in un link per il download in questa mia risposta

Qual è l'implementazione corretta per l'emulazione hardware .

Contiene "tutte" le ZX istruzioni con i codici OP corretti, i tempi di codifica e i cicli macchina. Mi ci sono voluti alcuni anni per mettere insieme tutta la documentazione, quindi sto passando ZEXALL 100% correttamente. Il mio emulatore carica questo file di testo (istruzioni 1792) nel core su init e configura il decodificatore e il processore delle istruzioni in fase di esecuzione, quindi sono stato in grado di cambiare le cose in modo abbastanza veloce e abbastanza semplice (se è stato rilevato un bug ) ... Mi ha risparmiato un lotto di tempo.

Mitch è completamente corretto. Inizia capendo il processore. Quindi gioca un po 'scrivendo il codice per implementare istruzioni particolari. Usa C ++ per questo, BTW, non C, o i concetti del processore non verranno mappati alle classi nel tuo codice.

Nel processo di implementazione delle istruzioni, troverai che devi definire cose come i flag e il puntatore delle istruzioni. Questo dovrebbe portarti dove devi implementare il modello di memoria e persino il modello I / O.

Alla fine dovrai capire come caricare codice e dati in memoria e forse come scaricarli di nuovo su disco.

Solo allora devi arrivare al punto di emulare l'esecuzione del codice, caricato in memoria, a un dato puntatore a istruzioni.

Prova a dare un'occhiata agli emulatori Sega Master System e Game Gear (sono abbastanza sicuro che alcuni siano open source). Quelle console hanno uno Z80 come CPU e ZX Spectrum lo usava anche, http://www.worldofspectrum.org/emulators.html .

Sembra che tu voglia un emulatore per più di un processore, ma per una macchina completa. Avrai anche il compito di emulare il resto dell'hardware e trovare la documentazione per quello potrebbe essere il compito più difficile che ti aspetta.

A seconda del tuo obiettivo, potresti voler iniziare con un emulatore già esistente per Z80. Una rapida ricerca ne fornisce diversi ma nessun emulatore per la TI-84. simh , un framework per l'emulazione di vecchi computer ha già l'emulazione di un processore Z80, aggiungendo l'emulazione del resto del tuo l'hardware dovrebbe essere più semplice che iniziare da zero. Anche se non segui questa strada, ci sono alcuni documenti di progettazione che potrebbero aiutarti.

Consiglio di prendere in considerazione l'idea di scrivere un emulatore per una CPU leggermente più semplice, ma correlata, la 8080 . Lo Z80 è in realtà piuttosto complicato (istruzioni multi-byte, più modalità di indirizzamento, registri indice, ecc.), Mentre le istruzioni 8080 sono molto facili da decodificare (puoi semplicemente usare una tabella di ricerca a 256 voci, come soluzione di primo ordine) .

Tutto il codice che scrivi per controllare il programma (display, immissione dati, dump della memoria, ecc.) dovrebbe essere riutilizzabile se decidi di continuare a provare lo Z80, e in effetti dovresti progettare l'interfaccia utente per essere simulato indipendentemente dal processore.

Ho imparato tutto ciò che so sull'assemblaggio di Z80 e calcolatrice proprio qui: http://www.ticalc.org / programmazione /

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow