Comment faire l'émulateur 8051

Question

Pour l'apprentissage j'ai l'intention de commencer à construire un émulateur de microcontrôleur 8051. Je suis à l'aise en programmation en C/C++/C#. Ce n'est pas un projet de classe, mais une initiative d'apprentissage de mon côté.

J'ai trouvé beaucoup de questions à ce sujet. Cependant, je voulais le casser un peu plus sur un niveau granulaire afin que je puisse savoir sur quels domaines je dois me concentrer avant de commencer à écrire le code.

Mes exigences initiales sont:

1. éditeur de texte (peut utiliser le contrôle EditBox) où l'utilisateur peut écrire du code assembleur

2. Valider si la syntaxe est correcte

3. Avez petite fenêtre qui montre les valeurs de registre à l'exécution. Lorsque l'utilisateur démarre le programme, les instructions doivent être une mise à jour étape par étape des fenêtres de registre.

Plus que l'élément GUI, je suis plus intéressé de savoir comment émuler le microcontrôleur.

La façon dont je comprends que je peux encore le décomposer:

1. je dois avoir une table pour obtenir des instructions ou un autre moyen de stocker des instructions disponibles et valider la syntaxe. Tout pointeur sur la façon de mettre en œuvre cela, s'il vous plaît faites le moi savoir. Comment puis-je émuler chaque instruction pour 8051?

2. Pour les registres, je peux utiliser des entiers non signés/basés sur le type et mettre à jour la table. Comme le microcontrôleur a une mémoire RAM limitée, comment garder une vérification de la longueur du code ou plutôt le code qui s'exécute dans la mémoire pour éviter et surpasser le buffer ou d'autres problèmes.

S'il existe des projets opensource qui détaillent la façon dont un émulateur est construit à la terre, apprécierait.

Answer 1

Je pense que vous êtes un peu clair sur la portée de ce projet, au moins en ce qui concerne le titre.

Un émulateur exécute du code binaire et rien d'autre. L'émulateur n'inclut pas d'éditeur (c'est un outil de développement) ni d'assembleur (idem). Il est de la responsabilité de l'assembleur de faire la vérification syntaxique et la traduction, de cette façon l'émulateur n'a que le travail relativement facile d'exécuter le code légal pré-validé.

Il semble que vous vouliez construire un IDE complet. Cela encapsulerait beaucoup de GUI autour de l'éditeur, de l'assembleur et de l'émulateur. Je laisserais cette étape comme la dernière.

---

Quant à vos questions concernant l'émulateur lui-même:

Vous pouvez utiliser un tableau jusqu'à (par exemple) 64Ko comme la mémoire de travail de l'émulateur. Vous utilisez des variables dans votre programme pour émuler les registres. Je voudrais utiliser un unsigned char * pour émuler le compteur de programme, et int s pour la plupart des autres choses ...

L'opération est assez simple: Démarrer le compteur de programme à 0 (ou un emplacement de démarrage prédéterminé), et commencer une boucle qui récupère les instructions via ce pointeur, et applique aux registres et à la mémoire toute opération associée à l'instruction. Une mise en œuvre simple serait centrée autour d'une énorme déclaration switch qui comprend tous les codes d'instruction possibles.

Comme je l'ai dit, votre émulateur ne devrait pas avoir à s'inquiéter des instructions illégales, car l'assembleur ne devrait pas en produire. Vous pourriez faire arrêter votre programme (c'est-à-dire la boucle principale) s'il frappe une opération illégale.

De même, votre émulateur n'a pas à se soucier des dépassements de plage, d'index ou de taille ... c'est aussi le problème de l'assembleur, ou peut-être celui du lieur, si vous en avez un.

---

Mise à jour: Quelques pointeurs à partir d'ici dans SO:

Emulator Framework

Answer 2

Récemment, je mis ensemble un émulateur de la puce AVR, qui est aussi un petit microcontrôleur 8 bits. La source est sur GitHub comme ghewgill/emulino. Le fichier le plus intéressant est cpu.c qui contient les implémentations pour chaque instruction CPU. Les lignes principales sont cpu_run() (en omettant quelques détails):

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

Cette charge un mot de 16 bits de la mémoire du programme pointé par le registre PC, utilise alors que l'indice dans une table de saut d'instruction (qui est un tableau 64k de pointeurs de fonction - la table réelle est générée par un script lors de la compilation). Cette fonction sera l'une des fonctions do_XXX() dans ce fichier source, et peut effectuer d'autres opérations de décodage avant d'exécuter l'instruction elle-même. Par exemple, la fonction 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++; 
} 

Cela ne l'opération d'addition réelle (Data.Reg[d] + Data.Reg[r]), définit ensuite tous les différents indicateurs de condition en fonction du résultat.