Afficher les instructions d'assemblage actuelles dans GDB

Je fais du débogage au niveau de l'assemblage dans GDB. Existe-t-il un moyen pour que GDB me montre l'instruction d'assemblage actuelle de la même manière qu'elle affiche la ligne source actuelle? La sortie par défaut après chaque commande ressemble à ceci:

0x0001433f      990         Foo::bar(p);

Cela me donne l'adresse de l'instruction en cours, mais je dois continuer à me référer à la sortie de disassemblepour voir quelle instruction j'exécute actuellement.

Vous pouvez passer à la mise en page d'assemblage dans GDB:

(gdb) layout asm

Voir ici pour plus d'informations. L'instruction d'assemblage actuelle sera affichée dans la fenêtre de l'assembleur.

   ┌───────────────────────────────────────────────────────────────────────────┐
   │0x7ffff740d756 <__libc_start_main+214>  mov    0x39670b(%rip),%rax        #│
   │0x7ffff740d75d <__libc_start_main+221>  mov    0x8(%rsp),%rsi              │
   │0x7ffff740d762 <__libc_start_main+226>  mov    0x14(%rsp),%edi             │
   │0x7ffff740d766 <__libc_start_main+230>  mov    (%rax),%rdx                 │
   │0x7ffff740d769 <__libc_start_main+233>  callq  *0x18(%rsp)                 │
  >│0x7ffff740d76d <__libc_start_main+237>  mov    %eax,%edi                   │
   │0x7ffff740d76f <__libc_start_main+239>  callq  0x7ffff7427970 <exit>       │
   │0x7ffff740d774 <__libc_start_main+244>  xor    %edx,%edx                   │
   │0x7ffff740d776 <__libc_start_main+246>  jmpq   0x7ffff740d6b9 <__libc_start│
   │0x7ffff740d77b <__libc_start_main+251>  mov    0x39ca2e(%rip),%rax        #│
   │0x7ffff740d782 <__libc_start_main+258>  ror    $0x11,%rax                  │
   │0x7ffff740d786 <__libc_start_main+262>  xor    %fs:0x30,%rax               │
   │0x7ffff740d78f <__libc_start_main+271>  callq  *%rax                       │
   └───────────────────────────────────────────────────────────────────────────┘
multi-thre process 3718 In: __libc_start_main     Line: ??   PC: 0x7ffff740d76d
#3  0x00007ffff7466eb5 in _IO_do_write () from /lib/x86_64-linux-gnu/libc.so.6
#4  0x00007ffff74671ff in _IO_file_overflow ()
   from /lib/x86_64-linux-gnu/libc.so.6
#5  0x0000000000408756 in ?? ()
#6  0x0000000000403980 in ?? ()
#7  0x00007ffff740d76d in __libc_start_main ()
   from /lib/x86_64-linux-gnu/libc.so.6
(gdb)

Tu peux faire

display/i $pc

et chaque fois que GDB s'arrête, il affichera le démontage de l'instruction suivante.

GDB-7.0prend également en charge set disassemble-next-line on, ce qui démontera toute la ligne suivante et vous donnera plus de contexte de démontage.

La commande

x/i $pc

peut être configuré pour fonctionner tout le temps en utilisant le mécanisme de configuration habituel.

Définition de l'option suivante:

set  disassemble-next-line on
show disassemble-next-line

Vous donnera des résultats qui ressemblent à ceci:

(gdb) stepi
0x000002ce in ResetISR () at startup_gcc.c:245
245 {
   0x000002cc <ResetISR+0>: 80 b5   push    {r7, lr}
=> 0x000002ce <ResetISR+2>: 82 b0   sub sp, #8
   0x000002d0 <ResetISR+4>: 00 af   add r7, sp, #0
(gdb) stepi
0x000002d0  245 {
   0x000002cc <ResetISR+0>: 80 b5   push    {r7, lr}
   0x000002ce <ResetISR+2>: 82 b0   sub sp, #8
=> 0x000002d0 <ResetISR+4>: 00 af   add r7, sp, #0

Si vous voulez que les quelques instructions suivantes s'affichent automatiquement pendant que vous parcourez le programme, vous pouvez utiliser la commande d' affichage comme suit -

display /3i $pc

Ce qui précède affichera 3 instructions chaque fois qu'un point d'arrêt est atteint ou lorsque vous effectuez une seule étape du programme.

Plus de détails à l'entrée du blog ici .

Tableau de bord GDB

https://github.com/cyrus-and/gdb-dashboard

Cette configuration GDB utilise l'API officielle GDB Python pour nous montrer ce que nous voulons chaque fois que GDB s'arrête après, par exemple next, un peu comme TUI.

Cependant, j'ai trouvé que cette implémentation est une alternative plus robuste et configurable au mode GDB TUI intégré comme expliqué à: gdb split view with code

Par exemple, nous pouvons configurer GDB Dashboard pour afficher le désassemblage, la source, les registres et la pile avec:

dashboard -layout source assembly registers stack

Voici à quoi cela ressemble si vous activez toutes les vues disponibles à la place:

Questions connexes:

• Passer à l'assemblage dans gdb

À partir de gdb, appuyez sur Ctrl x 2et l'écran se divisera en 3 parties.

La première partie vous montrera le code normal dans un langage de haut niveau.

Second vous montrera l'assemblage équivalent et correspondant instruction Pointer.

Third vous présentera l' gdbinvite normale pour entrer des commandes.

Il existe une solution simple qui consiste à utiliser stepi, qui à tour de rôle avance d'une instruction asm et montre le code asm environnant.