summaryrefslogtreecommitdiffstats
path: root/tde-i18n-it/docs/tdevelop/tdevelop/debugger.docbook
blob: c1ffbeda17d05b898ff4d2ac55382075eaa82893 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
<chapter id="debugger">
<title
>L'interfaccia del debugger</title>
<indexterm zone="debugger"
><primary
>debugger</primary
></indexterm>

<para
>Per i linguaggi C e C++, KDevelop contiene un debugger interno che è direttamente integrato nell'editor. Tecnicamente è implementato come un frontend che usa <application
>gdb</application
> (portable &GNU; debugger) attraverso una pipe. Il debugger può essere avviato in diversi modi: </para>

<itemizedlist>
<listitem>
<para
>Con <menuchoice
><guimenu
>Debug</guimenu
><guimenuitem
>Avvia</guimenuitem
></menuchoice
>, il programma principale del proprio progetto viene caricato nel debugger. </para>
</listitem>

<listitem>
<para
>Usando <menuchoice
><guimenu
>Debug</guimenu
><guimenuitem
>Esamina il file core...</guimenuitem
></menuchoice
> viene caricato in memoria un file core che è stato generato dal kernel del sistema operativo quando il programma è andato in crash (la generazione di file core potrebbe essere disattivata sul proprio sistema, vedere <application
>ulimit(1)</application
>). Questo è utile per un'analisi post-mortem del programma. </para>
</listitem>

<listitem>
<para
>Con <menuchoice
><guimenu
>Debug</guimenu
><guimenuitem
>Collega al processo</guimenuitem
></menuchoice
> si usa il debugger su un programma già in esecuzione. Verrà mostrata una lista di processi da dove si può selezionare quello che dovrà essere supervisionato dal debugger. </para>
</listitem>

<listitem>
<para
>Notare che questo debug è possibile se il proprio progetto è stato compilato con l'attivazione delle informazioni di debug. Possono essere attivate nella finestra di dialogo <guibutton
>Opzioni compilatore</guibutton
>. Quando questa opzione è attivata il compilatore genera dati aggiuntivi che permettono al debugger di associare i nomi dei file e numeri di linea con gli indirizzi nel file eseguibile. </para>
</listitem>
</itemizedlist>

<para
>Il frontend del debugger fornisce diverse viste <quote
>nel</quote
> processo: </para>

<para
>Se si tenta di effettuare il debug di un progetto che non ha le informazioni di debug si riceverà il messaggio <computeroutput
>Sorgente inesistente...</computeroutput
> nella barra di stato. Se si tenta di impostare un breakpoint, viene visualizzato come <computeroutput
>Pendente (aggiungi)</computeroutput
> nella finestra dei breakpoint (vedere sotto). </para>

<variablelist>
<varlistentry>
<term
>Variabili</term>
<listitem>
<indexterm zone="debugger"
><primary
>osservare variabili</primary
></indexterm>
<para
>Questa finestra elenca i valori di tutte le variabili locali del punto corrente dell'esecuzione del programma. Esso include le variabili dell'intero stack delle chiamate, &ie; la funzione dove è stato interrotto il processo, la funzione che ha chiamato quella funzione e così via fino a <function
>main()</function
>. </para>

<para
>Un altro ramo di variabili contiene le variabili di osservazione. Si possono configurare quali variabili mostrare qui. Possono essere osservate sia le variabili locali che globali. Si possono aggiungere variabili facendo clic sul pulsante <guibutton
>Aggiungi</guibutton
> o premendo <keycap
>RETURN</keycap
> mentre è selezionata la voce <guilabel
>Espressione da controllare</guilabel
>. Possono essere rimosse nuovamente attraverso il menu contestuale. </para>
</listitem>
</varlistentry>

<varlistentry>
<term
>Stack del frame</term>
<listitem>
<indexterm zone="debugger"
><primary
>Stack del frame</primary
></indexterm>
<para
>(... da scrivere ...) </para>
</listitem>
</varlistentry>

<varlistentry>
<term
>Breakpoint</term>
<listitem>
<indexterm zone="debugger"
><primary
>Breakpoint</primary
></indexterm>
<para
>In questa finestra vengono mostrati e modificati i breakpoint. &tdevelop; usa <application
>GDB</application
>, quindi per capire pienamente le sue funzionalità di debug, è necessario conoscere anche <ulink url="http://www.gnu.org/software/gdb"
>quest'ultimo</ulink
>. </para>

<para
>Se si vuole controllare il codice sorgente, i breakpoint sono definiti nel file <filename
>tdevelop/languages/cpp/debugger/breakpoint.h</filename
>. </para>

<para
>Nel bordo sinistro la finestra presenta vari pulsanti per:</para>

<itemizedlist>
<listitem
><para
>Aggiungere un breakpoint vuoto</para
></listitem>
<listitem
><para
>Modificare il breakpoint selezionato</para
></listitem>
 <listitem
><para
>Eliminare il breakpoint selezionato</para
></listitem>
<listitem
><para
>Rimuovere tutti i breakpoint</para
></listitem>
</itemizedlist>

<para
>La parte principale della finestra è costituita da una tabella con 7 colonne. Ogni linea della tabella rappresenta un breakpoint. Le colonne sono:</para>

<orderedlist>
<listitem
><para
>Casella di selezione</para
></listitem>
<listitem
><para
>Il tipo può essere: Non Valido, File:Linea, Punto di Controllo, Indirizzo, Funzione</para
></listitem>
<listitem
><para
>Stato: i valori possono essere:</para>
<itemizedlist>
  <listitem
><para
>Attivo</para
></listitem>
  <listitem
><para
>Disabilitato: ogni breakpoint può essere <quote
>abilitato</quote
> o <quote
>disabilitato</quote
>; finché non viene abilitato, non ha effetti sul programma.</para
></listitem>
  <listitem
><para
>Pendente (aggiungi): un breakpoint è in questo stato se non è disponibile nessuna informazione di debug. Dalla pagina Info di GDB: <blockquote
><para
>Se una specifica posizione del breakpoint non viene trovata, potrebbe essere all'interno di una libreria condivisa (shared) che non è stata ancora caricata. In questo caso, si può far creare a GDB un breakpoint speciale (noto come <quote
>breakpoint pendente</quote
>) che tenterà di effettuare la propria risoluzione quando verrà caricata la libreria condivisa.</para
> </blockquote
> </para
></listitem>
</itemizedlist>
</listitem>
<listitem
><para
>Pendente (chiaro)</para
></listitem>
<listitem
><para
>Pendente (modifica)</para
></listitem>
<listitem
><para
>Posizione nel formato nomefile:numerolinea</para
></listitem>
<listitem
><para
>Condizione</para
></listitem>
<listitem
><para
>Ignora il conteggio: se esiste un numero <varname
>COUNT</varname
> maggiore di zero, per le prossime <varname
>COUNT</varname
> volte in cui viene raggiunto il breakpoint, l'esecuzione del programma non verrà interrotta; <application
>gdb</application
> non intraprende alcuna azione, a parte decrementare il valore della variabile.</para
></listitem>
<listitem
><para
>Trovati: conta quante volte è stato raggiunto il breakpoint.</para
></listitem>
</orderedlist>


</listitem>
</varlistentry>

<varlistentry>
<term
>Disassembla</term>
<listitem>
<indexterm zone="debugger"
><primary
>disassembla</primary
></indexterm>
<para
>(... da scrivere ...)</para>

</listitem>
</varlistentry>
</variablelist>


<sect1 id="settingbreakpoints">
<title
>Impostare i breakpoint</title>

<para
>(... da scrivere ...) </para>

</sect1
> <!-- settingbreakpoints -->

<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->

<sect1 id ="debuggeroptions">
<title
>Opzioni</title>

<variablelist>
<varlistentry>
<term
>Visualizzare nomi mangled (storpiati)</term>
<listitem>
<indexterm zone="debugger"
><primary
>nomi storpiati</primary
></indexterm>
<indexterm zone="debugger"
><primary
>storpiatura</primary
><secondary
>nome</secondary
></indexterm>

<para
>Nel C++, i nomi delle funzioni negli eseguibili sono detti <quote
>mangled</quote
> (storpiati), &ie; il nome della funzione include le informazioni sul tipo degli argomenti. Questo è necessario per il supporto al sovraccaricamento delle funzioni. L'algoritmo di mangling non è standardizzato e differisce persino tra versioni diverse del compilatore C++ &GNU;. </para>

<para
>Normalmente nella finestra di disassemblaggio vengono visualizzati nomi non mangled, quindi le firme delle funzioni sono simili a come appaiono nel codice sorgente, quindi facilmente leggibili. In alternativa si può decidere di vedere i nomi mangled. </para>
</listitem>
</varlistentry>

<varlistentry>
<term
>Tentare di impostare i breakpoint al caricamento delle librerie</term>
<listitem>
<indexterm zone="debugger"
><primary
>lazy breakpoint</primary
></indexterm>
<indexterm zone="debugger"
><primary
>Breakpoint</primary
><secondary
>lazy</secondary
></indexterm>

<para
>Il backend del debugger <application
>gdb</application
> non permette di inserire breakpoint all'interno di codice non caricato. Questo potrebbe essere sconveniente in una applicazione altamente modulare, dove spesso il codice viene caricato su richiesta come un plugin (usando la funzione di libc <function
>dlopen(3)</function
>), quindi &tdevelop; ha esteso il proprio supporto per i breakpoint nelle librerie condivise. Se si imposta questa opzione si potranno impostare i breakpoint in librerie che non sono state caricate. Quando <application
>gdb</application
> notificherà che una libreria è stata caricata, &tdevelop; tenterà di impostare i breakpoint sospesi. </para>
</listitem>
</varlistentry>

<varlistentry>
<term
>Abilitare la barra degli strumenti fluttuante</term>
<listitem>
<indexterm zone="debugger"
><primary
>barra degli strumenti del debugger</primary
></indexterm>
<indexterm zone="debugger"
><primary
>barra degli strumenti</primary
><secondary
>debugger</secondary
></indexterm>

<para
>(... da scrivere ...) </para>
</listitem>
</varlistentry>
</variablelist>

</sect1
> <!-- debuggeroptions -->

</chapter
> <!-- debugger -->