summaryrefslogtreecommitdiff
path: root/d/dev/tools/tools.txt
blob: d0538baabd7f3b3c8ddc0724e6dd3c6e432400ee (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
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
*Title: Outils utiles pour coder
*Author: Nicolas Haller

*TOC

* Introduction

Pour coder au Robot et en g�n�ral, il existe certain outils, certain sont 
indispensables. Je vais ici montrer comment fonctionnent quelques outils que 
j'utilise personnellement, le but n'�tant pas de faire un guide complet mais
plut�t une pr�sentation assez d�taill�e pour les utiliser.

* Editeurs

** Vim

Vim est un �diteur de texte tr�s puissant qui peut faire beaucoup de chose dont
du C.

*** Fonctionnement

Taper vim dans un bash. Attention, pour coder en C il est n�cessaire de modifier
quelques options dans le .vimrc, notamment :
	* _syntax on_, pour avoir de la couleurs en codant ;
	* _set shiftwidth=4_, pour une indentation de 4 caract�res (voir les 
	standards du robot) ;
	* _set cinoptions={.5s:.5sg.5sh.5st0(0=.5s_, pour le style Efrei
	Robotique.

*** Quelques commandes

Pour vim et pour coder, quelques commandes :
	* :q quitter
	* :x sauvegarder et quitter
	* :w enregistrer
	* :e ouvrir
	* == pour indenter une ligne
	* =G indente du curseur � la fin du fichier
	* :make ex�cute le makefile et affiche les erreurs �ventuelles
	* :cc aller � l'erreur actuelle
	* :cn aller � l'erreur suivante
	* :copen ouvre la liste des erreurs
	* :cclose la ferme

Y'en a plein d'autre mais si vous utilisez vim, elles viendront vite.

* Compilateurs

** Pour le C

Pour coder en C, gcc, le GNU C Compiler. C'est un compilateur tr�s puissant
avec un beaucoup d'options.

** Pour le C++

Pour coder en C il faut juste remplacer gcc par g++.

** Comment �a marche

Il suffit de taper gcc (ou g++) et le nom du fichier source (on ne met pas les
headers). Si il n'y a qu'un seul fichier source, �a marche, et il y aura comme
r�sultat un fichier a.out, bon a part pour faire un Hello World, �a sert �
rien, pour des projets plus cons�quent, le Makefile est tout indiqu�.

Si la compilation foire, le compilateur fera en sorte d'afficher les erreurs
avec le nom des fichiers et les lignes o� se trouve � 3 lignes pr�s l'erreur.
Il se peut aussi qu'il annonce des warnings, c'est pas bon !! Les warnings
portent bien leurs noms, et g�n�ralement, laisser des warnings dans un
programme est suicidaire, donc, � �viter.

** Quelques options

Dans la ligne de commandes gcc, il y a quelques options et librairies
indispensables :
	* -o <fichier> permet de nommer le fichier ex�cutable, sinon il
	  s'appelle a.out ;
	* -W et -Wall pour voir tout les warnings qui pourrait passer ;
	* -g permet d'ajouter les info de debuggage ;
	* -Olevel Permet d'optimiser le programme, plus level est grand plus
	  c'est optimiser (level 3 max);
	* -Os permet d'optimiser le code pour obtenir un ex�cutable plus
	  petit ;
	* -lm permet d'inclure la librairie math�matique ;

* make

La commande make est une commande tr�s puissante qui fait ce qu'on lui
dit de faire. Elle est intelligente pour certaine action mais pour des
choses un peu pouss�, elle regarde dans un Makefile ce quel doit faire.
C'est avec elle que sont compiler la plupart des programmes.

** Comment �a marche

Taper make et si il y a un makefile qui va bien �a s'ex�cute.
make tente de faire de la divination, pour un programme compos� d'un
code source, il suffit de taper make nomdufichiersansextension.
Sinon, l'�criture d'un makefile est obligatoire.

** Le makefile

Le makefile s'appelle Makefile (n'oublier pas la majuscule, c'est mieux). Dans
le fichier ont trouve des variables et des r�gles. Les variables sont d�finies
et utilis�es comme dans les scripts bash, mais certaines variables sont
standards et nous serviront plus tard. Pour faire simple, un makefile pour
compiler un programme en C ressemble � �a.
^<<

barbecue: main.o merguez.o thermostat.o
	gcc -o barbecue main.o merguez.o thermostat.o

^>>

barbecue est le nom de la cible, main.o merguez.o thermostat.o les
"d�pendances", la ligne du dessous qui commence obligatoirement par une
tabulation est la ou les actions � ex�cuter.
make �tant tr�s intelligent, il va essayer de voir si il peut r�soudre
les d�pendances, ici, il va compiler les sources pour produire les .o requis.
Cela dit pour un projet plus important, le Makefile peut contenir
plusieurs cibles et plusieurs actions, pour �viter de r��crire les choses
plusieurs fois, il y a les variables.
Les variables fonctionnent comme pour les scripts bash � peu pr�s.
Pour reprendre l'exemple au dessus on pourrait marquer
^<<

OBJECTS=main.o merguez.o thermostat.o

barbecue: ${OBJECTS}
	gcc -o $@ $^

^>>

Les fichiers object sont dans la variable OBJECTS qui est utilis� dans la
ligne de commande gcc, $@ est une variable sp�ciale qui correspond au
nom de la cible et $^ en est une autre indiquant les d�pendances.

Avec �a, make peut compiler un projet entier, comme il est tr�s
intelligent, il regardera ce qu'il a besoin de faire, c'est-�-dire qu'il
ne recompilera ce qui est n�cessaire, faite le test, compiler quelque
chose avec make et refaite le.

^<<

nicolas@hermes:~/testmake$ ls 
casertarien.c
nicolas@hermes:~/testmake$ make casertarien
cc     casertarien.c   -o casertarien
nicolas@hermes:~/testmake$ make casertarien
make: � casertarien � est � jour.

^>>

L'exemple pr�c�dent montre �galement une chose, c'est ce qu'ex�cute make
lorsqu'on ne lui dit rien. On voit qu'il utilise cc comme compilateur et
qu'il n'utilise rien. Vous allez me dire, m'en fiche je fais un
Makefile, certes, mais les d�pendances en .o, il les faits tout seul
donc, il faut lui dire quoi faire, et pour cela, il existe les variables
sp�ciales.

** Quelques variables utiles

Pour dire � make comment faire ses trucs intelligents, certaines
variables sont bien utiles, en voici quelques une :
	* CC permet de d�finir le compilateur C (exemple: CC=gcc) ;
	* CLIBS permet de d�finir les librairie C � utiliser (exemple:CLIBS=-lm) ;
	* CFLAGS qui permet de d�finir les flags (exemple CFLAGS=-g -W -Wall).

Pour le C++ il y a les �quivalents
	* CXX pour le compilo C++ ;
	* CXXLIBS pour les librairies C++ ;
	* CXXFLAGS pour les flags C++.
Mais il en existe bien d'autre.

En d�finitive, notre Makefile pour un programme en C pourrait ressembler
� �a:

^<<

CC=gcc
CLIBS=-lm
CFLAGS=-g -W -Wall -pipe

barbecue: main.o merguez.o thermostat.o
	${CC} ${CLIBS} ${CFLAGS} -o $@ $^

^>>

Et on aura � l'�cran:

^<<
nicolas@hermes:~/testmake/barbecue$ make
gcc -g -W -Wall -pipe   -c -o main.o main.c
gcc -g -W -Wall -pipe   -c -o thermostat.o thermostat.c
gcc -g -W -Wall -pipe   -c -o merguez.o merguez.c
gcc -lm -g -W -Wall -pipe -o barbecue main.o thermostat.o merguez.o
^>>
Voila un beau Makefile qui comme le dirais Ni, permet de briller en
soci�t�.

* Le d�bugueur

Pour debuguer le jolie code qui marche pas comme pr�vu, il y a le
d�buggueur GDB (pour GNU Debbuger, ouais ils ont vachement
d'imagination). Pour l'utiliser, il est utile de sortir le -g lors de
la compilation du programme foireux.
GDB permet plusieurs chose comme examiner les cadavre (les fichiers core
par exemple) ou de s'attacher � un processus. Mais je vais juste
expliquer le debuggage d'un programme lanc�e par gdb.
Pour lancer gdb, il faut taper gdb <nom du prog foireux>, et ensuite, le
programme est pr�t � �tre espionn�. Il suffit de taper les commandes qui
vont bien pour voir le fonctionnement du programme.

** Quelques commandes

Voici quelques fonctions sympa
	* b ou breakpoint permet de mettre un point d'arr�t, c'est un
endroit o� le d�buggueur va s'arr�ter. On peut lui donner le nom d'une
fonction ou d'un num�ro de ligne.
	* r ou run lance le programme � debugguer
	* n ou next permet de passer � l'instruction suivante au m�me niveau
dans la pile(reste dans l'instruction)
	* s ou step permet de passer � l'instruction suivante � un niveau plus
profond de la pile le cas �ch�ant(typiquement les instructions d'une fonction appel�)
	* c ou continue ex�cute le programme jusqu'au prochain point d'arr�t
	* l \[num�ro de ligne] ou list \[NDL] permet de lister dix lignes du code source.
	* p ou print \[variable] permet d'obtenir la valeur d'une variable. la
variable est � rentrer sous la forme d'une instruction, donc si il
 est possible d'appel� une variable temp, il est possible de marquer
thermostat->temp ou *temp ou encore temp\[0].
	* d ou display marche comme print sauf que l'�tat de la variable est
indiqu� � chaque instruction
	* up qui permet de remonter d'un niveau dans la pile
	* down qui permet de descendre d'un niveau de la pile
	* info \[truc], donne des infos sur beaucoup de chose. En tapant
		* address \[fonction] les adresses des fonctions
		* stack, on a les info sur la pile
		* breakpoints qui indique les points d'arr�t d�finis
	* q ou quit qui permet de quitter

* Programmes contre les fuites de m�moire

** Eletric fence

Electric fence est une librairie qui permet d'envoyer un SIGSEGV (erreur de
segmentation) d�s que l'on lit ou que l'on �crit dans l'espace.

*** Comment �a marche

Electric fence est une librairie qui a l'avantage de ne pas toucher au code,
par contre il faut rajouter la librairie lefence sur la ligne du compilateur.
Un d�savantage �galement est qu'une allocation de m�moire prend beaucoup plus
de place en m�moire et de temps avec que sans electric fence. Donc en cas de
grosse allocation ou d'allocation r�p�t�, �a risque de trancher ch�rie.

Electric Fence est � utiliser avec gdb pour conna�tre la position du segfault
et de l'instruction incrimin�, car le terminal n'est pas tr�s loquace et
renverra juste un message "erreur de segmentation".

Personnellement, je n'utilise plus Electric fence que j'ai remplac� par
valgrind.

** Valgrind

Valgrind est un programme tr�s utiles pour tout ce qui touche � la m�moire. Il
a �galement d'autre fonctions comme le profiling du cache que je ne
d�taillerais pas. 

*** Comment �a marche

Il suffit d'ex�cuter le programme en rajoutant valgrind et les options qui vont
bien avant le nom du programme.
Par exemple
^<<
nicolas@hermes:~\valgrind --tool=memcheck --leak-check=yes -v barbecue
^>>

La j'utilise l'outil memcheck pour v�rifier la m�moire (mais c'est l'option
par d�faut), j'aurais pu mettre cachegrind pour profiler le cache.
leak-check permet d'afficher les fuites de m�moire et v c'est verbose.

Il n'est pas obligatoire mais hautement conseill� de compiler le programme
avec les infos de debbugage (-g) pour avoir toutes les infos sur la
localisation d'un probl�me.

Valgrind note les erreurs mais ne forcera pas l'envoie d'un segfault
contrairement � electric fence, par cons�quent, ce n'est pas parce que y'a pas
segfault qu'il n'y a pas d'erreur grave.

*** Qu'elle erreurs Valgrind indique

Pratiquement toutes les erreurs li�es � la m�moire, c'est � dire:
	* les tests sur des variables qui ne sont pas initialis�s exemple
^<<
int
main (void)
{
    int p, t;
    if (p == 5)             /* Ho une erreur. */
        t = p + 1;
    return 0;
}
^>>
	* Les lecture/�criture dans l'espace
	En gros, les tentatives de lecture/�criture sur des espaces de la
	m�moires qui ne sont pas allou�e pour �a. exemple
^<<
#include <stdlib.h>
int
main (void)
{
    int *p, i, a;
    p = malloc (10 * sizeof (int));
    p[11] = 1;                /* Ecriture dans l'espace. */
    a = p[11];                /* Lecture dans l'espace. */
    free (p);
    return 0;
}
^>>
	* Les lib�rations invalides
	Vous essayez de lib�rer un blocs qui n'est pas allou�. Exemple:
^<<
#include <stdlib.h>
int
main (void)
{
    int *p, i;
    p = malloc (10 * sizeof (int));
    for (i = 0; i < 10; i++)
        p[i] = i;
    free (p);
    free (p);	/* Oui mais non, p est d�j� lib�r�. */
    return 0;
}
^>>
	* Les mauvaises utilisations de fonctions
	Typiquement, les allocations par malloc qui sont lib�r�es par delete.
	Exemple:
^<<
#include <stdlib.h>
int
main (void)
{
    int *p, i;
    p = (int*) malloc (10 * sizeof (int));
    for (i = 0; i < 10; i++)
    	p[i] = i;
    delete p;		/* C'est pas la bonne fonction (non, c'est un op�rateur !). */
    return 0;
}
^>>
	* Les mauvais param�tres sur des fonctions utilisant la m�moire
	* Les pertes de m�moires dans le cosmos
	Typiquement, vous avez perdu le pointeur qui avait l'adresse du bloc
	allou�. Cela donne lieu � une fuite de m�moire.

* Conclusion

Voil� quelques outils qui sont tr�s utiles pour d�velopper, si vous en voyez
d'autre ou si j'ai �cris une b�tise, n'h�sitez pas � me le dire �
nicolas@popple.dyndns.org.