Errore di segmentazione durante l'esecuzione, ma successo durante il debug

Question

Ho riscontrato un errore di segmentazione cablato. Sto sviluppando un software in C utilizzando Eclipse CDT. Quando si esegue il mio programma sul terminale (Ubuntu 10, 64 bit), riporta semplicemente "Errore di segmentazione". Tuttavia, quando eseguo il debug usando gdb in Eclipse, questo va alla fine e il risultato è corretto.

Capisco che potrebbero esserci molte ragioni per i difetti di segmentazione. E mi dispiace di non essere in grado di mostrare il mio codice poiché non so dove potrebbe essere il problema ...

Ma qualcuno potrebbe aiutarmi, c'è una situazione che potrebbe accadere nel mio caso: errore di segmentazione sui terminali, mentre va bene nel debugging? Grazie mille.

---

Grazie, tutto. Avrei passato un po 'di tempo ad imparare Valgrind. Ho corretto il bug sostituendo un malloc() di realloc(). La chiamata è seguita da due memcpy. È questa la ragione? Ecco il codice snippet:

bwa_seq_t *merge_seq (bwa_seq_t *s1, bwa_seq_t *s2) { 
    ubyte_t *seq1, *seq2, *tmp; 
    if (!s1 || !s2) 
    return 0; 
    seq1 = s1->seq; 
    seq2 = s2->seq; 
    tmp = (ubyte_t*) calloc (sizeof(ubyte_t), (s2->len + s1->len + 1)); 
    memcpy(tmp, seq1, sizeof(ubyte_t) * s1->len); 
    memcpy(&tmp[s1->len], seq2, sizeof(ubyte_t) * s2->len); 
    s1->len += s2->len; 
    tmp[s1->len] = '\0'; 
    s1->seq = tmp; 
    return s1; 
} 

Qualcuno può spiegare perché?

Answer 1

provare le seguenti operazioni:

• tipo ulimit -c unlimited in un xterm (questo permette la creazione di core/file postmorterm)

• avviare il programma (e lasciarlo crash): un file core dovrebbe ora essere presente nella directory.

• lancio del debugger con gdb <yourprogram> <corefile>

• tipo bt al prompt di gdb per vedere su quale linea ha fatto crash.

• (opzionale) correggere l'errore.

Answer 2

Questo è probabilmente il risultato di una variabile non inizializzata. (In linea 14 del programma)

Answer 3

Se sai come il crash dal terminale, si può fare a creare un corefile e controllare il punto in cui si è schiantato in questo modo:

$ ulimit -c unlimited # to create a corefile 
$ yourprogram 
... 
crash     # this will create file "core" in the current directory 
$ gdb yourprogram core # shows the state at the moment of the crash 

domanda su quel argomento:

• Info on where is the core dump located
• What do you do with a core file
• How do you generate core dumps

Answer 4

Compilare con informazioni di debug e utilizzare gdb per identificare dove si verifica l'errore utilizzando il dump.

Answer 5

È molto probabile che si stia verificando una sorta di comportamento non definito. Come già detto, usa Valgrind per eseguire il debug di questo problema. Prima di tutto cerca gli errori INVALID READ, INVALID WRITE nell'output di Valgrind. Produrrà anche stack di chiamate aggiuntivi quando accadono cose brutte nel tuo codice. Questo dovrebbe aiutare a capire il motivo del bug.

Answer 6

Ho anche affrontato questo problema prima. Non in Linux con il compilatore GCC ma in Visual Studio 2005. Era come se il mio codice fosse stato eseguito correttamente in modalità debug mentre in modalità rilascio (Direct running) stava andando in crash. Il fatto è che quando si esegue il debug del codice, il debugger si occupa di eccezioni come violazione di Access, array fuori limite ecc. E non lascia che il codice si blocchi. Nella modalità di esecuzione diretta non c'è nessuno che si prenda cura delle eccezioni e quindi il codice si blocca.

Ti suggerisco di utilizzare printf per visualizzare il risultato dell'intervento intermedio in quanto è il modo migliore per individuare il codice.

Spero che questo potrebbe aiutare .. :-)

Answer 7

BTW: si sta perdendo la memoria qui. s1-> seq è fondamentalmente in fase di realizzazione, ma si dimentica di liberare la vecchia memoria. Cambio:

s1->len += s2->len; 
tmp[s1->len] = '\0'; 
s1->seq = tmp; 
return s1; 

in:

void *del; // <<-- 
s1->len += s2->len; 
tmp[s1->len] = '\0'; 
del = s1->seq; // <<-- 
s1->seq = tmp; 
free (del); // <-- 
return s1; 

, E almeno smetterai perdite.