Newsgroup: it.comp.os.linux.development
Titolo: [debug] gdb interrompere quando cambia una locazione di memoria

Ho questo problema.
Mi cambia una locazione di memoria di un array di puntatori (la numero 1) 
senza che io lo faccia direttamente.
Vorrei fare in modo da controllare in quale riga di codice questo valore 
viene cambiato.
Io ho settato con memset tutta la memoria a 0 e poi alloco degli indici solo 
in determinate posizioni. Ma quella locazione table[1] risulta sempre 
diversa da zero ma mai e nessuno vi alloca un oggetto. (E' un array di 
puntatori).
Come devo impostare il debbuger per poter fare questo controllo?
Grazie...
-- 
__________________________________
"Ama e fai c'ho che vuoi".... 
__________________________________

valore viene cambiato.
setta un watchpoint:
(gdb) help watch
-- 
sux ?

vjt wrote:

già fatto e provato prima di postare sul ng.
Non ci sono riuscito.
Devo sapere in quale riga di codice la locazione &table[1] cambia di valore 
da 0 a un altro valore.
Come si fa? Grazie.


Come si fa? Grazie.
table e` una var locale o globale ? se e` locale ( se ben mi ricordo ) i
watchpoint vengono cancellati all`uscita dal blocco di codice per cui
esiste quella variabile. quindi, dovresti prima settare un break sulla
funzione che dichiara quella variabile, e poi un watch sulla var stessa.
se e` globale invece, il watch lo puoi settare quando vuoi.
ciao
-- 
:wq

vjt wrote:

non riesco a fermare l'esecuzione del programma quando il valore cambia.
Sto facendo le prove in un semplice e vuoto main.
un array di int settati tutti a 0.
Fermare l'esecuzione quando diventa diverso da zero.
Io faccio così:
file main
break (prima linea del programma)
run
watch table[1]
continue
ma esce senza fermarsi mentre cambio il valore.
Come mai?
Ho provato anche con altre espressioni table[1]!=0  table[1]==0
ciao


Sto facendo le prove in un semplice e vuoto main.
]zac[
Metti un break point nel punto in cui vuoi fare il controllo, poi metti
una 'condizione' al breakpoint.
Credo che il controllo della 'condizione' venga fatto solo in un punto
preciso, cioè ogni volta che il flusso del programma passa per il
breakpoint.

Della Bianca Giuseppe wrote:

ora starò anche facendo questo tipo di prove ma il mio problema è un'altro.
Io non so chi e dove cambia il valore di un array, in particolare ho un 
array di puntatori (tutto a 0) e mi ritrovo che table[1] è diverso da zero 
senza che io abbia cambiato o instaziato nulla (esplicitamente lì!).
Quindi io vorrei bloccare l'esecuzione del programma (per di più è un 
programma con chiamate molto annidate e l'array è un membro privato di una 
classe) quando questo valore cambia. Magari usando un puntatore 
globale...non so.
Per es. 
myclass **table; //privata
myclass *spia = table[1]; //globale
e nel debbugger bloccare quando cambia il valore di spia.
Bho...


senza che io abbia cambiato o instaziato nulla (esplicitamente lě!).
]zac[
Io ho capito, sei tu che non hai capito che il tuo problema e' quello
 :) a scanso di equivoci).
Ricorda che il C e' un linguaggio che ha come priorita' le prestazioni e
quindi molto vicino alla 'macchina'.
Il concetto di intercettare la scrittura di una variabile e' troppo
invasivo, non credo che sia nemmeno tecnicamente fattibile usando il C
.... se poi tieni conto che una determinata zona di memoria (in cui
risiede una la variabile) puo' essere tranquillamente sovrascritta da
qualcos'altro (tipo l'uso di un array fuori dai suoi limiti), insomma il
concetto di variabile nel C e' sostituito dal concetto di accesso a una
zona di memoria, quindi niente super debug.
In sintesi, credo che dovrai scordarti l'idea del globale, e inserire
dei punti di controllo, magari usando gli assert, e in futuro, se
possibile, scrivere codice in maniera che sia il piu' facile possibile
da debuggare.
In sintesi della sintesi, altro non c'e' (o almeno non mi risulta), con
quello devi fare.