Jak zrobić emulator 8051

Question

Dla celów edukacyjnych zamierzam zacząć budować emulator mikrokontrolera 8051. Jestem wygodny programowanie w C/C++/C#. To nie jest projekt klasy itp., Ale inicjatywa edukacyjna z mojej strony.

Znalazłem sporo pytań na ten temat. Chciałem jednak podzielić go na bardziej szczegółowy poziom, aby wiedzieć, które obszary muszę skupić, zanim zacznę pisać kod.

Moje początkowe wymagania to:

1. edytor tekstu (można używać kontroli polu edycji), gdzie użytkownik może napisać kod montaż

2. sprawdzania, czy składnia jest poprawna

3. mają małe okno który pokazuje wartości rejestru w czasie wykonywania.

4. kiedy użytkownik uruchamia program, instrukcje powinny być krok po kroku aktualizujące okna rejestru.

Więcej niż element GUI Jestem bardziej zainteresowany, aby wiedzieć, jak emulować mikrokontroler.

Sposób Rozumiem, że może dalej rozbicie go:

1. muszę spojrzeć w górę tabeli dla instrukcji lub w jakiś inny sposób na przechowywanie dostępne instrukcje i sprawdzenia poprawności składni. Wszelkie wskazówki, jak to wdrożyć, proszę dać mi znać.

2. Jak emulować każdą instrukcję dla 8051?

3. Dla rejestrów mogę używać liczb całkowitych Un/signed w oparciu o typ i aktualizować tabelę.

4. Ponieważ mikrokontroler ma ograniczoną pamięć RAM, w jaki sposób sprawdzać długość kodu, a raczej kod wykonywany w pamięci, aby uniknąć przepełnienia bufora lub innych problemów.

Jeśli są jakieś projekty typu open source, które szczegółowo opisują, jak zbudowany jest emulator, docenilibyśmy.

Answer 1

Wydaje mi się, że nie masz pewności co do zakresu tego projektu, przynajmniej w odniesieniu do tytułu.

Emulator wykonuje kod binarny i nic więcej. Emulator nie zawiera edytora (to narzędzie programistyczne) ani asemblera (ditto). Odpowiedzialność asemblera polega na sprawdzaniu składni i tłumaczeniu, w ten sposób emulator ma tylko stosunkowo łatwą pracę wykonania sprawdzonego, legalnego kodu.

Wygląda na to, że chcesz zbudować kompletne IDE. Spowoduje to wiele GUI wokół edytora, asemblera i emulatora. Zostawiłbym ten krok jako ostatni.

---

chodzi o pytania dotyczące samego emulatora:

można wykorzystać tablicę do (na przykład) 64K bajtów jako pamięć roboczą emulatora. Używasz zmiennych w swoim programie do emulowania rejestrów. Używałbym unsigned char * do emulacji licznika programów i int s dla większości innych rzeczy ...

Operacja jest całkiem prosta: Uruchom licznik programu na 0 (lub wcześniej ustaloną lokalizację rozruchową) i uruchom pętla, która pobiera instrukcje za pośrednictwem tego wskaźnika i stosuje się do rejestrów i pamięci niezależnie od operacji związanej z instrukcją. Prosta implementacja będzie koncentrować się wokół ogromnego oświadczenia switch, które zawiera wszystkie możliwe kody instrukcji.

Jak już powiedziałem, twój emulator nie powinien martwić się o nielegalne instrukcje, ponieważ asembler nie powinien wytwarzać żadnych. Możesz mieć swój program (tzn. Pętlę główną) zatrzymany, jeśli trafi on na nielegalną operację.

Podobnie, twój emulator nie musi martwić się o przekroczenie zakresu, indeksu lub przekroczenia rozmiaru ... to także problem assemblera, a może linker, jeśli go masz.

---

Aktualizacja: Kilka wskazówek od tutaj w SO:

Emulator Framework

Answer 2

Ostatnio ułożyła emulator dla chipa AVR, który jest również mały 8-bitowy mikrokontroler. Źródło znajduje się na GitHub jako ghewgill/emulino. Najciekawszym plikiem jest cpu.c, który zawiera implementacje dla każdej instrukcji CPU. Główne linie są w cpu_run() (pomijając pewne szczegóły):

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

Ten ładuje słowo 16-bitowe z pamięci programu wskazywany przez rejestr PC, a następnie używa tego jako indeksu do tabeli instrukcji skoku (co jest tablicą wskaźników funkcyjnych 64k - faktyczna tabela jest generowana przez skrypt w czasie kompilacji). Ta funkcja będzie jedną z funkcji do_XXX() w tym pliku źródłowym i może wykonać dalsze dekodowanie instrukcji przed wykonaniem instrukcji. Na przykład, do_ADD() funkcja:

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++; 
} 

To nie rzeczywista operacja dodawania (Data.Reg[d] + Data.Reg[r]), a następnie ustawia wszystkie różne flagi warunek w oparciu o wynik.