Perché GDB salta in modo imprevedibile tra le righe e stampa le variabili come "<valore ottimizzato>"?

Qualcuno può spiegare questo comportamento di gdb?

900         memset(&new_ckpt_info,'\0',sizeof(CKPT_INFO));
(gdb)
**903         prev_offset   = cp_node->offset;**
(gdb)
**905         m_CPND_CKPTINFO_READ(ckpt_info,(char *)cb->shm_addr.ckpt_addr+sizeof(CKPT_** HDR),i_offset);
(gdb)
**903         prev_offset   = cp_node->offset;**
(gdb)
**905         m_CPND_CKPTINFO_READ(ckpt_info,(char *)cb->shm_addr.ckpt_addr+sizeof(CKPT_ HDR),i_offset);**
(gdb)
**908         bitmap_offset  = client_hdl/32;**
(gdb)
**910         bitmap_value = cpnd_client_bitmap_set(client_hdl%32);**
(gdb)
**908         bitmap_offset  = client_hdl/32;**
(gdb)
**910         bitmap_value = cpnd_client_bitmap_set(client_hdl%32);**
(gdb)
**908         bitmap_offset  = client_hdl/32;**
(gdb)
**910         bitmap_value = cpnd_client_bitmap_set(client_hdl%32);**
(gdb)
913         found = cpnd_find_exact_ckptinfo(cb , &ckpt_info , bitmap_offset , &offset , &prev_offset);
(gdb)
916         if(!found)
(gdb) p found
$1 = <value optimized out>
(gdb) set found=0
Left operand of assignment is not an lvalue.

Perché dopo aver eseguito la riga 903, viene eseguita nuovamente la stessa per 905 908 910?

Un'altra cosa è che foundè una boolvariabile di tipo, quindi perché viene visualizzata value optimized out? Non sono in grado di impostare anche il valore di found.

Questa sembra essere un'ottimizzazione del compilatore (in questo caso la sua -O2); come posso ancora impostare il valore di found?

Per eseguire il debug del codice ottimizzato, impara il linguaggio assembly / macchina.

Usa la modalità TUI GDB. La mia copia di GDB lo abilita quando digito il meno e Invio. Quindi digita Cx 2 (ovvero tieni premuto Control e premi X, rilascia entrambi e quindi premi 2). Ciò lo metterà nella sorgente divisa e nel display di smontaggio. Quindi utilizzare stepie nextiper spostare un'istruzione macchina alla volta. Usa Cx o per passare tra le finestre TUI.

Scarica un PDF sul linguaggio macchina della tua CPU e sulle convenzioni di chiamata delle funzioni. Imparerai rapidamente a riconoscere cosa viene fatto con gli argomenti della funzione e i valori di ritorno.

È possibile visualizzare il valore di un registro utilizzando un comando GDB come p $eax

Ricompila senza ottimizzazioni (-O0 su gcc).

Dichiara trovato come "volatile". Questo dovrebbe dire al compilatore di NON ottimizzarlo.

volatile int found = 0;

Il compilatore inizierà a fare cose molto intelligenti con le ottimizzazioni attivate. Il debugger mostrerà il codice che salta avanti e indietro molto a causa del modo ottimizzato di memorizzare le variabili nei registri. Questo è probabilmente il motivo per cui non è possibile impostare la variabile (o in alcuni casi vederne il valore) poiché è stata distribuita in modo intelligente tra i registri per la velocità, piuttosto che avere una posizione di memoria diretta a cui il debugger può accedere.

Compilare senza ottimizzazioni?

In genere, i valori booleani utilizzati nei rami immediatamente dopo essere stati calcolati in questo modo non vengono mai effettivamente memorizzati nelle variabili. Invece, il compilatore si dirama direttamente dai codici di condizione impostati dal confronto precedente. Per esempio,

int a = SomeFunction();
bool result = --a >= 0; // use subtraction as example computation
if ( result ) 
{
   foo(); 
}
else
{
   bar();
}
return;

Di solito si compila in qualcosa di simile:

call .SomeFunction  ; calls to SomeFunction(), which stores its return value in eax
sub eax, 1 ; subtract 1 from eax and store in eax, set S (sign) flag if result is negative
jl ELSEBLOCK ; GOTO label "ELSEBLOCK" if S flag is set
call .foo ; this is the "if" black, call foo()
j FINISH ; GOTO FINISH; skip over the "else" block
ELSEBLOCK: ; label this location to the assembler
call .bar
FINISH: ; both paths end up here
ret ; return

Notare come il "bool" non viene mai effettivamente memorizzato da nessuna parte.

Non puoi praticamente impostare il valore di trovato. Il debug di programmi ottimizzati raramente vale la pena, il compilatore può riorganizzare il codice in modi che non corrisponderà in alcun modo al codice sorgente (a parte produrre lo stesso risultato), confondendo così i debugger a non finire.

Quando si esegue il debug di programmi ottimizzati (che potrebbe essere necessario se il bug non viene visualizzato nelle build di debug), spesso è necessario comprendere il compilatore di assembly generato.

Nel tuo caso particolare, il valore di ritorno di cpnd_find_exact_ckptinfoverrà memorizzato nel registro che viene utilizzato sulla tua piattaforma per i valori di ritorno. Su ix86, sarebbe %eax. Su x86_64:, %raxecc. Potrebbe essere necessario cercare su Google la "convenzione di chiamata della procedura [del processore]" se non è presente nessuna delle precedenti.

Puoi esaminare quel registro in GDBe puoi impostarlo. Ad esempio su ix86:

(gdb) p $eax
(gdb) set $eax = 0 

Sto usando QtCreator con gdb.

Aggiunta

QMAKE_CXXFLAGS += -O0
QMAKE_CXXFLAGS -= -O1
QMAKE_CXXFLAGS -= -O2
QMAKE_CXXFLAGS -= -O3

Funziona bene per me