Mostra le istruzioni di assemblaggio correnti in GDB

Sto eseguendo il debug a livello di assembly in GDB. C'è un modo per convincere GDB a mostrarmi le istruzioni di assemblaggio correnti nello stesso modo in cui mostra la linea di origine corrente? L'output predefinito dopo ogni comando è simile al seguente:

0x0001433f      990         Foo::bar(p);

Questo mi dà l'indirizzo dell'istruzione corrente, ma devo continuare a fare riferimento all'output di disassembleper vedere quale istruzione sto eseguendo.

È possibile passare al layout dell'assieme in GDB:

(gdb) layout asm

Vedi qui per maggiori informazioni. Le istruzioni di assemblaggio correnti verranno visualizzate nella finestra dell'assemblatore.

   ┌───────────────────────────────────────────────────────────────────────────┐
   │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 puoi fare

display/i $pc

e ogni volta che GDB si ferma, mostrerà lo smontaggio della prossima istruzione.

GDB-7.0supporta anche set disassemble-next-line on, che disassemblerà l'intera riga successiva e ti darà più contesto di disassemblaggio.

Il comando

x/i $pc

può essere impostato per l'esecuzione in qualsiasi momento utilizzando il normale meccanismo di configurazione.

Impostazione della seguente opzione:

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

Ti darà risultati simili a questi:

(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

Se si desidera che le seguenti istruzioni vengano visualizzate automaticamente mentre si scorre il programma, è possibile utilizzare il comando display come segue:

display /3i $pc

Quanto sopra visualizzerà 3 istruzioni ogni volta che viene raggiunto un breakpoint o quando si esegue un singolo passaggio del programma.

Maggiori dettagli sul post di blog qui .

Dall'interno di gdb premere Ctrl x 2e lo schermo si dividerà in 3 parti.

La prima parte ti mostrerà il codice normale in un linguaggio di alto livello.

Il secondo ti mostrerà l'equivalente dell'assieme e il corrispondente instruction Pointer.

Terzo ti presenterà il normale gdbprompt per inserire i comandi.

Dashboard GDB

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

Questa configurazione GDB utilizza l'API Python GDB ufficiale per mostrarci quello che vogliamo ogni volta che GDB si ferma dopo, ad esempio next TUI.

Tuttavia ho scoperto che questa implementazione è un'alternativa più solida e configurabile alla modalità TUI GDB integrata, come spiegato in: gdb split view with code

Ad esempio, possiamo configurare Dashboard GDB per mostrare disassemblaggio, sorgente, registri e stack con:

dashboard -layout source assembly registers stack

Ecco come appare se abiliti invece tutte le viste disponibili:

Domande correlate:

• Passare all'assemblaggio in gdb