Écrivons un désassembleur Intel 8080

Table des matières

1. Introduction
2. Présentation de l'assembleur
3. La puce Intel 8080
   1. Caractéristiques de la puce
   2. Architecture simple
4. Référence de l'ensemble d'instructions Intel 8080
5. Mise en place de l'environnement
   1. Choix du langage de programmation
   2. Compilation et exécution
6. La fonction de désassemblage
   1. Lecture des octets d'opcodes
   2. Structure du désassemblage
7. Implémentation des instructions
   1. Instructions non reconnues
   2. Instructions LXi
   3. Instructions stacks
   4. Instructions iNX
   5. Autres instructions
8. Conclusion
9. Ressources

Introduction

Dans cet article, nous allons explorer les bases de l'écriture d'un désassembleur pour la puce Intel 8080. Le désassemblage est le processus de conversion du code machine en code assembleur lisible par l'homme. Bien que la création d'un désassembleur pour une plateforme moderne soit une tâche complexe, nous nous concentrerons sur la puce Intel 8080, qui est plus simple à comprendre. Nous allons passer en revue l'architecture de cette puce, étudier l'ensemble d'instructions utilisé et mettre en place l'environnement de développement nécessaire. Ensuite, nous aborderons la fonction de désassemblage et implémenterons certaines des instructions de base.

Présentation de l'assembleur

Avant de plonger dans les détails du désassemblage, examinons rapidement ce qu'est l'assembleur. L'assembleur est un langage de programmation de bas niveau qui permet d'écrire des instructions directement compréhensibles par le processeur. Contrairement aux langages de haut niveau tels que C ou Java, l'assembleur est spécifique à une architecture de processeur donnée. Chaque processeur a son propre ensemble d'instructions qui peuvent être utilisées pour effectuer des opérations telles que l'arithmétique, les opérations logiques et le contrôle du flux d'exécution.

La puce Intel 8080

La puce Intel 8080 est un processeur 8 bits sorti en 1974. Malgré sa simplicité en comparaison des processeurs modernes, elle offre un bon point de départ pour comprendre les principes du désassemblage. Voici quelques caractéristiques clés de la puce Intel 8080 :

• La puce dispose de sept registres généraux de 8 bits : a, b, c, d, e, h, et l.
• Elle possède également un registre de compteur de programme de 16 bits (pc) et un registre de pointeur de pile de 16 bits (sp).
• Chaque instruction est encodée sur un seul octet et l'architecture est little endian.
• Chaque opération peut être suivie d'un ou deux octets de données, qui peuvent être une adresse mémoire, un numéro de port ou un opérande.

Référence de l'ensemble d'instructions Intel 8080

Pour désassembler correctement les instructions de la puce Intel 8080, nous avons besoin d'une référence fiable de son ensemble d'instructions. Il existe de nombreuses ressources disponibles en ligne, mais j'ai personnellement utilisé celle-ci : lien vers la référence. Cette référence fournit une table simple à utiliser, indiquant les opcodes correspondant à chaque instruction. Par exemple, l'opcode 0x00 correspond à l'instruction NOP, l'opcode 0x01 correspond à l'instruction LXI B, etc. Pour cet article, nous allons uniquement implémenter quelques-unes de ces instructions de base.

Mise en place de l'environnement

Avant de commencer à désassembler notre programme, nous devons mettre en place l'environnement de développement. Dans notre cas, nous allons utiliser le langage de programmation C, car il offre un bon équilibre entre abstraction de niveau supérieur et bas niveau. Vous pouvez compiler et exécuter le code C sur Linux en utilisant la chaîne d'outils de compilation GCC. Le code C que nous allons écrire peut également être exécuté sur d'autres plateformes telles que Windows ou MacOS en utilisant les outils de compilation appropriés, tels que Visual Studio ou Xcode. Le code complet que nous écrirons tiendra dans un seul fichier, ce qui facilitera sa compilation et son exécution.

La fonction de désassemblage

Maintenant que nous avons configuré notre environnement de développement, nous pouvons commencer à implémenter la fonction de désassemblage proprement dite. Cette fonction prendra en entrée notre tampon d'octets (qui représente le contenu de notre ROM) ainsi que le compteur de programme actuel. Voici le squelette de notre fonction de désassemblage :

int desassembler(unsigned char *buffer, int programmeCounter) {
    // Lire l'opcode à partir du tampon d'octets
    unsigned char opcode = buffer[programmeCounter];

    // Structure principale du désassemblage

    // Retourner le nombre d'octets du programme incrementé
}

Comme vous pouvez le voir, cette fonction est assez simple. Nous allons lire l'opcode à partir du tampon d'octets en utilisant le compteur de programme actuel. Ensuite, nous implémenterons la logique spécifique à chaque instruction à l'intérieur de cette fonction.

Implémentation des instructions

Passons maintenant à l'implémentation des instructions. Nous allons utiliser une déclaration switch où chaque cas représente une instruction spécifique. Voici un exemple d'implémentation pour quelques instructions de base :

switch(opcode) {
    case 0x00:
        printf("NOP\n");
        break;

    case 0x01:
        printf("LXI B, #$%02x%02x\n", buffer[programmeCounter + 2], buffer[programmeCounter + 1]);
        return 3;

    case 0x02:
        printf("STAX B\n");
        return 1;

    // Autres instructions
}

Comme vous pouvez le voir, chaque instruction est représentée par un cas dans la déclaration switch. Nous imprimons simplement le nom de l'instruction et, le cas échéant, les octets de données supplémentaires. Ensuite, nous retournons le nombre d'octets de l'instruction (y compris l'opcode) pour faire avancer correctement le compteur de programme.

Pour compléter notre programme, il suffit d'ajouter les cas pour les autres instructions de l'ensemble d'instructions Intel 8080. Cette tâche peut être fastidieuse, mais cela vous donnera une compréhension approfondie du désassemblage et des opérations de la puce.

Conclusion

Dans cet article, nous avons exploré les bases de l'écriture d'un désassembleur pour la puce Intel 8080. Nous avons examiné les caractéristiques de cette puce, son ensemble d'instructions et mis en place l'environnement de développement nécessaire. Ensuite, nous avons implémenté la fonction de désassemblage et quelques-unes des instructions de base. Le désassemblage est une tâche complexe, mais c'est une excellente façon de comprendre le fonctionnement interne des processeurs et la conversion du code machine en code assembleur. J'espère que cet article vous a été utile et vous a donné une idée de la manière de commencer à créer votre propre désassembleur. N'hésitez pas à consulter les ressources supplémentaires mentionnées dans la section suivante pour en savoir plus.

Ressources

• Référence de l'ensemble d'instructions Intel 8080
• Code source complet du désassembleur
• Article original de l'auteur