[C problemi con diverse versioni del gcc]

[fracarro]

Salve a tutti,
ho un problema che mi sta facendo impazzire. Un amico mi ha fornito un codice C per la creazione di alcune istanze di un problema su grafi. Ora compilando il codice ( con le opzioni -Wall -ggdb3 ) sotto linux suse 9,1 ( gcc versione 3.3.3) non vengono riscontrati problemi o warning e l'output del programma è perfetto. Copiando il codice sotto un altro linux con la versione gcc version 3.4.2 20041017 (Red Hat 3.4.2-6.fc3) la compilazione va a buon fine ( nessun warning ) ma ci sono due procedure nel codice che mi danno problemi ( una cicla all'infinito e l'altra va in segmentation fault). Ora se il programma contiene accessi in zone di memoria non allocata (ragion per cui mi da la seg.fault) come mai su un computer il problema NON si presenta MAI e sull'altro SEMPRE? Ci sono altri flag in compilazione che posso utilizzare per "aumentare" la trasportabilità del codice o stabilire qual'è la causa del problema? Grazie per l'aiuto.

P.S. E' possibile installare la versione 3.4 del gcc sulla suse 9.1?

[AnonimoVeneziano]

L'accesso a memoria non allocata su un sistema non dovrebbe mai verificarsi , poichè il risultato di tale accesso è imprevisto.

Per qualche motivo su un sistema non da problemi , e su un altro da Seg fault.

In ogni caso se tale accesso nel tuo programma c'è devi toglierlo per assicurarne il corretto funzionamento su ogni sistema

[fracarro]

si sono riuscito a trovare e modificare la parte di codice che creava la seg fault ma tuttavia non riesco a capire com'è possibile che su una macchina venga segnalato l'errore e su un'altra no ( ho controllato le due esecuzioni del programma, SONO IDENTICHE, ovviamente, ma su una l'accesso alla zona di memoria non allocata da problemi e sull'altra no, bo?. Facendo delle ricerche ho scoperto il flag -lefence che dovrebbe dare ulteriori informazioni sui problemi di accesso in memoria o qualcosa del genere. Ebbene su un programma funzionante ho provato questo flag e voilà , mi segnalava una segmentation fault nell'allocazione della memoria per un array all'inizio del programma. Posso capire che usando flag come -O4 si possono verificare problemi nel codice per via delle ottimizzazioni ma non con il flag -lefence perchè?. Qualcuno sa darmi delucidazioni a riguardo? Grazie

[ilsensine]

Non capisco cosa pretendi...l'accesso a memoria non inizializzata (che _è_ un errore di programmazione, e non sempre dei più banali) dà per forza risultati imprevedibili e non riproducibili tra un sistema e un altro. Può aiutarti per il debug prendere l'abitudine di inizializzare sempre la memoria (ad es. allocandola con calloc invece che con malloc; inizializzando tutte le variabili di una classe nel costruttore, ecc.), quando non è evidente l'uso che ne verrà fatto.

[anx721]

mi pare che non si tratti di un semplice flag..con -lefence linki la libreria electric fence che è un memory checker:

ElectricFence uses virtual memory hardware to detect when software overruns malloc() buffer boundaries, and/or to detect any accesses of memory released by free().

quello che so che fa electric fence è che se te allochi ad esempio 10 bytes, allora e-fence alloca 2 pagine di memoria:

|-----prima pagina---|---seconda pagina---|

e se p è l'indirizzo della seconda pagina, allora ti restituisce come indirizzo dell'allocazione (p-10)

|-----prima pagina---|---seconda pagina---|
                 ^ 
.................| (p-10)

inoltre imposta per la seconda pagina una protezione che impedisce lettura e scrittura.

in questo modo se te per errore vai oltre le dieci locazioni del tuo array, vai a finire nella seconda pagina, che è protetta, e ci sarà segmentation fault. Se non ci fosse la seconda pagina, al suo posto potebbe eserci un altra variabile del tuo programma, e l'accesso erroneo a quella variabile non sarebbe considerato errore.

Il fatto che l'errore di seg fault scatti o meno dipende quindi a anche da come viene allocata la memoria per le variabili, da qual è la configurazione della memoria in quel momento in cui fai l'accesso, per cui anche due esecuzioni di uno stesso programma possono dare esiti diverse sulla stessa macchina

[ilsensine]

Originariamente inviato da fracarro
Facendo delle ricerche ho scoperto il flag -lefence che dovrebbe dare ulteriori informazioni sui problemi di accesso in memoria o qualcosa del genere

La libreria libefence (che linki tramite -lefence) serve principalmente per il debug di buffer overflow o di accessi a memoria liberata con free; funziona inserendo degli hook sulle funzioni di allocazione. E' meno utile per individuare riferimenti a memoria allocata ma non inizializzata; potrebbe incidentalmente essere di aiuto anche in questo, ma non è il suo scopo principale. Non è di aiuto per il debug degli accessi a variabili globali(*) non inizializzate, ma solo quando l'allocazione della memoria è dinamica.


(*) Per beccare le variabili locali non inizializzate, generalmente è sufficiente compilare con -Wall

[fracarro]

forse non mi sono spiegato bene. Io non vado ad utilizzare zone di memoria non INIZIALIZZATA. Il mio problema è semplicemente che se dichiaro un array in questo modo "int pippo[10]", VORREI che un accesso del tipo pippo[1000] mi dia una seg fault perchè io non ho ALLOCATO la memoria per 1000 caselle. Tuttavia come mi faceva notare anx721, se sono talmente sfortunato da beccare con quella istruzione un'altra zona di memoria allocata dal mio programma sono fregato perchè CORRETTAMENTE non mi segnalerà la seg fault. I flag -W e -Wall purtroppo non mi aiutano in questo ma potrebbe farlo la electric fence mediante la sua seconda pagina protetta. Grazie ad entrambi per le risposte (tutti sti casini per un codice che non ho scritto io, sigh!!!)

[ilsensine]

Originariamente inviato da fracarro
forse non mi sono spiegato bene. Io non vado ad utilizzare zone di memoria non INIZIALIZZATA

Ah ok

Il mio problema è semplicemente che se dichiaro un array in questo modo "int pippo[10]", VORREI che un accesso del tipo pippo[1000] mi dia una seg fault perchè io non ho ALLOCATO la memoria per 1000 caselle.

Il classico buffer overflow. Non ci sono molte difese "automatiche" se la memoria non è allocata tramite malloc (solo così le efence possono essere d'aiuto).

[fracarro]

Concludendo, se ho capito bene mi conviene compilare con i seguenti flag -W -Wall -lefence per avere warning e maggiori informazioni sugli eventuali errori di accesso in memoria, giusto? L'esempio che ho fatto prima con un allocazione statica era solo per chiarire meglio il mio problema, in realtà gli array li alloco dinamicamente con la malloc. Mi consigliate di rimpiazzare quest'ultima con la calloc? (in questo modo mi verranno segnalati eventuali accessi iin memoria a zone non inizializzate, giusto?). Un'ultima cosa, a questo punto visti i problemi che ho avuto, poichè il programma compilato con lefence mi da seg fault posso essere certo che c'è qualche altro errore di accesso alla memoria? (se mi riscrivevo il codice d'accapo facevo prima!!!)

[anx721]

la calloc serve semplicemente a inizializare a zero il blocco di memoria allocato...se il programma con e-fence ti dà errore significa che c'è un accesso di memoria illegale