⚡ Protocole GDB/MI2 🖥️ Assembleur x86 (32 bits) & x86_64 (64 bits) 🧮 GPR • EFLAGS • SIMD (SSE / AVX / AVX-512) 🎨 Thème Sombre Midnight Aurora

Déboguez l'Assembleur Visuellement avec PyEzGDB

PyEzGDB (pyezgdb) est une interface graphique moderne en Python/Tkinter et une bibliothèque de pilotage GDB permettant d'assembler automatiquement vos sources x86 32 ou 64 bits NASM (.asm) ou GAS (.s), d'exécuter votre code instruction par instruction et d'inspecter en temps réel les registres, les drapeaux d'état, les vecteurs SIMD, les sections mémoire et la pile sous Linux.

Ce logiciel remplace xxgdb ou ddd (Data Display Debugger)

⚙️ Règle 32 / 64 bits avant ouverture .asm 🖼️ Explorer l'interface en images 🚀 Guide de démarrage rapide
⚠️ Détection automatique du mode 32 ou 64 bits lors du chargement d'un fichier .asm

Lors du chargement d'un fichier source assembleur (.asm ou .s), PyEzGDB lance immédiatement l'assemblage (nasm) et l'édition de liens (ld ou gcc) selon l'architecture active. La détection du mode 32 ou 64 bits est réalisée automatiquement mais il est toujours possible de choisir le mode dans la liste déroulante « Bits : » de la barre d'outils avant d'ouvrir votre fichier .asm.

1
Choix de l'architecture cible (Bits : 64 ou 32) Dans la barre d'outils supérieure, sélectionnez 32 pour un programme x86 (EAX, ESP…) ou 64 pour un programme x86_64 (RAX, RSP…) ou laissez le programme détecter le mode.
2
Ouverture d'un fichier source (.asm / .s) Cliquez sur 📂 Ouvrir (Ctrl+O). PyEzGDB détecte le mode 32 ou 64 bits assemble alors le source avec elf32 / -m32 ou elf64 / -m64 et génère les symboles DWARF (-g).
3
En cas de changement après coup : Ctrl+R Si vous modifiez le sélecteur Bits après avoir déjà ouvert un fichier, appuyez sur Ctrl+R (Fichier → Recharger / Réassembler) pour recompiler avec la nouvelle architecture.
PyEzGDB v1.0.6 — Interface de Débogage Assembleur (GDB) — exemple.asm (64 bits) 🔍 Cliquez sur une image pour l'agrandir
Vue d'ensemble de l'interface PyEzGDB en mode 64 bits avec code source assembleur, registres, flags et sections de données
Vue générale de PyEzGDB (mode 64 bits) : Éditeur source NASM avec point d'arrêt actif (●) et curseur d'instruction courante (➔ ligne 74), bandeau des drapeaux ZF/CF/SF/OF, registres généraux (✱ RAX modifié), inspection des sections .rodata/.data/.bss et consoles Output / GDB. Thème Midnight Aurora
Architecture Cible x86 / x86_64

PyEzGDB prend en charge aussi bien les programmes assembleur 32 bits (i386) que 64 bits (x86_64). Voici comment sélectionner dans la barre d'outils le mode adéquat.

🔎 Gros plan sur la barre d'outils supérieure de PyEzGDB

Repérez le menu déroulant Bits : [ 64 | 32 ] situé à droite du sélecteur de syntaxe (intel / att) et juste avant les boutons de zoom de police (A- / A+) :

Barre d'outils de PyEzGDB montrant le sélecteur Bits 32 ou 64 et le bouton Ouvrir
① Sélectionner « Bits : 32 » ou « Bits : 64 » EN PREMIER ② Cliquer sur « 📂 Ouvrir » (Ctrl+O) pour charger le fichier .asm ③ Lancer l'exécution pas-à-pas avec « 🔄 Début (Ctrl+D) »

Mode 32 bits (x86 / IA-32) Bits : 32

  • Assemblage NASM automatique : nasm -f elf32 -g -F dwarf fichier.asm
  • Édition de liens :
    • sans bibliothèque C : méthode _start et ld -m elf_i386
    • avec la glibc : méthode main et gcc -m32 -no-pie -g
  • Registres affichés : EAX, EBX, ECX, EDX, ESI, EDI, EBP, ESP, EIP, EFLAGS.
  • Alignement de la pile : Mots de 4 octets (ESP+0x00, ESP+0x04, ESP+0x08…) avec passage d'arguments sur la pile (push dword).

Mode 64 bits (x86_64 / AMD64) Bits : 64

  • Assemblage NASM automatique : nasm -f elf64 -g -F dwarf fichier.asm
  • Édition de liens :
    • sans bibliothèque C : méthode _start et ld -m elf_x86_64
    • avec la glibc : méthode main et gcc -m64 -no-pie -g
  • Registres affichés : RAX, RBX, RCX, RDX, RSI, RDI, RBP, RSP, R8 à R15, RIP, EFLAGS.
  • Alignement de la pile : Mots de 8 octets (RSP+0x00, RSP+0x08…) et convention d'appel System V AMD64 ABI (RDI, RSI, RDX, RCX, R8, R9).
Panorama Technique

Toutes les fonctionnalités de PyEzGDB

Conçu pour l'enseignement supérieur, les travaux pratiques d'architecture des ordinateurs et le développement système bas-niveau.

⚙️

Assemblage & Édition de Liens Intelligents

Chargez directement vos fichiers sources sans écrire de Makefile complexe : PyEzGDB détecte automatiquement la structure du programme.

  • Support natif des sources NASM (.asm), GAS (.s, .S) et des exécutables ELF déjà compilés.
  • Détection automatique du point d'entrée (_start ou main) et des symboles externes (extern printf, scanf…).
  • Compilation systématique avec les informations de débogage DWARF (-g -F dwarf) pour relier chaque instruction machine à sa ligne source.
📜

Éditeur Visuel & Points d'Arrêt (Breakpoints)

Visualisez votre code assembleur avec une coloration syntaxique riche et contrôlez finement les points d'arrêt.

  • Coloration syntaxique dédiée : instructions générales et SIMD, registres, directives, labels, constantes et commentaires.
  • Bascule instantanée entre la Vue Source (.asm) et la Vue Désassemblage GDB (syntaxe intel ou att).
  • Ajout/suppression de Breakpoints (●) par simple clic sur le numéro de ligne, double-clic sur l'instruction ou saisie du numéro de ligne.
  • Suivi en temps réel du pointeur d'instruction RIP / EIP par la flèche émeraude ➔.
🧮

Registres Généraux (GPR) & Drapeaux EFLAGS

Observez l'effet exact de chaque instruction arithmétique, logique ou de branchement sur l'état du processeur.

  • Bandeau de Flags dédié : 4 badges visuels temps réel pour ZF (Zero), CF (Carry), SF (Sign) et OF (Overflow) + détail complet de EFLAGS.
  • Double affichage simultané de chaque registre en hexadécimal et en décimal signé.
  • Mise en évidence ambre doré (✱) de tous les registres et drapeaux modifiés par la dernière instruction exécutée.
⚡

Registres Vectoriels SIMD (SSE / AVX / AVX-512)

Inspectez les calculs parallèles flottants et entiers sur les architectures x86 modernes sans commandes GDB fastidieuses.

  • Détection matérielle automatique du CPU hôte : SSE (XMM0..15, 128 bits), AVX/AVX2 (YMM0..15, 256 bits) ou AVX-512 (ZMM0..31, 512 bits).
  • Conversion instantanée à la volée en float (IEEE 754 32 bits), double (64 bits), int32, int64, hex32 ou hex64.
  • Compteur d'activité [✱N] sur l'onglet dès qu'un registre vectoriel change de valeur.
🗂️

Sections Mémoire (.data, .rodata, .bss) & Pile

Explorez vos variables globales, vos chaînes de caractères et l'évolution du cadre de pile (stack frame).

  • Onglet Sections : inspection hexadécimale et décodage ASCII/UTF-8 avec détection des symboles, filtrage par section et 3 modes (sym16, symbol, hex16).
  • Onglet Pile (Stack) : affichage en ordre d'adresses décroissantes ancré sur la base de pile initiale ; le pointeur ← RSP / ← ESP descend visuellement lors d'un push et remonte lors d'un pop.
🖥️

Terminal Output / Stdin (PTY) & Console GDB

Interagissez avec les entrées/sorties de votre programme assembleur exactement comme dans un vrai terminal.

  • Pseudo-terminal (PTY) dédié avec préchargement de libstdbuf.so : même un printf sans \n s'affiche immédiatement après call printf.
  • Saisie clavier interactive (stdin) : support complet de scanf et du syscall sys_read avec indicateur visuel d'attente de saisie.
  • Console GDB intégrée : exécutez n'importe quelle commande GDB classique (x/16gx $rsp, print $rax) avec resynchronisation automatique des panneaux.
Visite Guidée Visuelle

L'interface de PyEzGDB en action

Découvrez les différents panneaux de l'environnement à travers des sessions de débogage réelles en 32 bits et 64 bits.

Session 32 bits (i386) & Entrées/Sorties

Débogage 32 bits, Pile ESP / EBP et saisie clavier scanf

Après avoir sélectionné Bits : 32 dans la barre d'outils puis chargé 32bits_scanf.asm, PyEzGDB adapte automatiquement l'ensemble de ses panneaux à l'architecture 32 bits :

  • Les registres généraux passent en 32 bits (EAX, EBX, ECX, EDX, ESI, EDI, EBP, ESP, EIP).
  • L'onglet Pile (Stack) affiche les mots de 4 octets (ESP+0x00, ESP+0x04…) et matérialise les pointeurs ← ESP et ← EBP.
  • La barre inférieure ⌨️ Clavier (stdin) permet de préparer ou d'envoyer à la volée les valeurs lues par call scanf (ici 42 108).
Bits : 32 nasm -f elf32 gcc -m32 -no-pie ESP / EBP printf & scanf
32bits_scanf.asm — Mode 32 bits + Pile ESP/EBP + Clavier (stdin) 🔍 Agrandir
Débogage d'un programme assembleur 32 bits avec scanf et visualisation de la pile ESP et EBP
Inspecteur Vectoriel SIMD (Format float) & Pile 64 bits (RSP) 🔍 Agrandir
Inspection des registres vectoriels SIMD en format float et de la pile 64 bits RSP
Calcul Vectoriel & Stack Frame

Inspecteur SIMD (XMM / YMM / ZMM) et Pile descendante

Lors de l'exécution d'instructions vectorielles telles que movaps ou addps, basculez sur l'onglet Vecteurs SIMD et choisissez le format d'interprétation (float, double, int32, hex64…) :

  • Visualisation immédiate des composantes flottantes : XMM0 = [4.5, 3.5, 2.5, 1.5], XMM1 = [40, 30, 20, 10] et leur somme XMM2 = [44.5, 33.5, 22.5, 11.5].
  • Bandeau de détail inférieur affichant l'intégralité des composantes du registre sélectionné.
  • En dessous, l'onglet Pile (Stack — RSP / ESP) montre les valeurs empilées par push rdi (10) et push rsi (5 ← RSP).
SSE / AVX / AVX-512 Format : float / double push / pop ← RSP / ← RBP
Bas-Niveau & Sortie Programme

Vue Désassemblage GDB, Section .bss et Terminal Output

En un clic sur le bouton radio Vue : Désassemblage, comparez votre code source avec les instructions réellement assemblées en mémoire par NASM/GCC :

  • Affichage des adresses hexadécimales (0x401018…), des déplacements relatifs aux symboles (<_start+75>, <calcul_somme_ponderee+0>) et des commentaires d'adressage relatif à RIP.
  • Détection en temps réel des écritures en mémoire : l'onglet Sections (.data, .rodata, .bss) [✱1] signale que la variable resultat_bss vient de recevoir la valeur 45 (0x2d).
  • Le panneau 🖥️ Output affiche la chaîne envoyée par l'appel système syscall (sys_write).
Syntaxe Intel / AT&T Adresses RIP-relative .bss [✱1] PTY Output
Vue Désassemblage GDB (Intel) + Modification .bss + Sortie syscall 🔍 Agrandir
Vue Désassemblage GDB avec inspection de la section .bss modifiée et sortie dans le panneau Output
Centre d'Aide & Référence des Commandes intégré (Touche F1) 🔍 Agrandir
Fenêtre d'aide intégrée de PyEzGDB accessible via la touche F1
Ergonomie & Autonomie

Centre d'Aide intégré (F1) & Zoom de police (A- / A+)

Pour accompagner les étudiants en séance de TP comme lors de présentations sur vidéoprojecteur en amphithéâtre :

  • Aide contextuelle (F1) : récapitule toutes les combinaisons de touches, leurs équivalents GDB (tbreak + run, nexti, stepi, x/16gx $rsp…) ainsi que le guide détaillé des panneaux.
  • Zoom global instantané (A- / A+) : agrandit ou réduit simultanément la police (de 8 pt à 24 pt) du code source, des tableaux de registres, de la pile et des consoles via Ctrl++, Ctrl+- ou Ctrl + Molette souris.
Pilotage Pas-à-Pas

Contrôles d'Exécution & Raccourcis Clavier

Les 5 commandes principales disposent de raccourcis doublés (Ctrl+… et touches de fonction F5 à F9) spécialement choisis pour éviter tout conflit avec les raccourcis système de Linux / Ubuntu (comme F10).

🔄 Début (Ctrl+D)
Ctrl+D ou F6

Place un point d'arrêt temporaire sur _start ou main, (re)lance le programme et s'arrête sur la 1re instruction.

⏭ Suivante (Ctrl+N)
Ctrl+N ou F7 — nexti

Exécute une instruction assembleur sans entrer dans les sous-programmes appelés par call (Step Over).

⏬ Entrer (Ctrl+S)
Ctrl+S ou F8 — stepi

Exécute une instruction assembleur et entre à l'intérieur des fonctions appelées par call (Step Into).

▶ Continuer (Ctrl+E)
Ctrl+E ou F5 — continue

Poursuit l'exécution normale jusqu'au prochain point d'arrêt (●), une saisie clavier ou la fin du processus.

⏹ Arrêter (Ctrl+K)
Ctrl+K ou F9 — kill

Interrompt immédiatement le processus en cours de débogage et réinitialise l'état d'exécution.

Raccourci Clavier / Souris Bouton / Action dans PyEzGDB Commande GDB Équivalente
Sélecteur Bits : 32 / 64 ⚠️ À choisir AVANT d'ouvrir un fichier .asm pour définir l'architecture d'assemblage (32 ou 64 bits) nasm -f elf32/elf64 + gcc -m32/-m64
Ctrl+O 📂 Ouvrir un fichier source (.asm, .s) ou un binaire ELF file <exécutable>
Ctrl+R 🔁 Recharger et réassembler le fichier courant (en prenant en compte le sélecteur Bits actuel) file <exécutable>
Ctrl+D ou F6 🔄 Recommencer depuis le début (arrêt sur _start ou main) tbreak _start/main + run
Ctrl+N ou F7 ⏭ Instruction suivante sans entrer dans les appels call (Step Over) nexti (ni)
Ctrl+S ou F8 ⏬ Exécuter l'instruction et entrer dans un sous-programme call (Step Into) stepi (si)
Ctrl+E ou F5 ▶ Continuer l'exécution jusqu'au prochain breakpoint continue (c)
Ctrl+K ou F9 ⏹ Arrêter immédiatement le programme débogué kill
Clic N° de ligne ou Double-clic ● Activer / désactiver un point d'arrêt (Breakpoint) sur la ligne break / delete
Ctrl++ / Ctrl+Molette haut 🔍 Agrandir la police d'affichage sur tous les panneaux (bouton A+, jusqu'à 24 pt) —
Ctrl+- / Ctrl+Molette bas 🔎 Rétrécir la police d'affichage sur tous les panneaux (bouton A-, jusqu'à 8 pt) —
Ctrl+0 📏 Réinitialiser la taille de la police à sa valeur par défaut (11 pt) —
F1 📖 Ouvrir le Centre d'Aide & Référence des commandes help
Ctrl+Q 🚪 Fermer proprement GDB et quitter PyEzGDB quit
Mise en route & Intégration

Installation, Lancement CLI et API Python

Installez pyezgdb en quelques secondes sous Linux (Debian, Ubuntu, Mint, Fedora, Arch) et utilisez-le en mode graphique ou depuis vos scripts Python.

1. Prérequis système & Installation (Debian / Ubuntu) bash 
# Installation des outils système (inclure gcc-multilib pour le mode 32 bits)
sudo apt update
sudo apt install python3 python3-tk python3-pip gdb nasm binutils gcc gcc-multilib
# Création d'un environnement virtuel
python3 -m venv ~/venvasm
# Activation de l'environnement virtuel
source ~/venvasm/bin/activate
# Récupération du fichier .whl
(venvasm) wget https://leria-info.univ-angers.fr/~jeanmichel.richer/pub/pyezgdb-1.0.6-py3-none-any.whl
# Installation du package PyEzGDB grâce au fichier .whl
(venvasm) pip install pyezgdb-1.0.6-py3-none-any.whl
# Lancement de l'interface graphique
(venvasm) pyezgdb
2. Pilotage par programmation via GDBController python 
from pyezgdb import GDBController

ctrl = GDBController()
# Spécifier preferred_arch_bits=32 ou 64 lors du chargement d'un .asm
ok, log = ctrl.load_target("examples/32bits_simple_example.asm", preferred_arch_bits=32)
if ok:
    ctrl.toggle_breakpoint_source_line(59)
    ctrl.start_or_restart()
    ctrl.continue_execution()
    print("EAX =", hex(ctrl.registers.get("eax", 0)))
    print("Flags =", ctrl.get_main_flags())
    print("Output :", ctrl.drain_program_output())
ctrl.cleanup()