anguy T - INSA Lyon · 2016-09-18 · Outils p our la rogrammationp GP: A rithmiqueAlgo et...

Outils pour la programmation

AGP: Algorithmique et programmation

tanguy.risset�insa-lyon.fr

Lab CITI, INSA de Lyon

Version du July 22, 2016

Tanguy Risset

July 22, 2016

Tanguy Risset AGP: Algorithmique et programmation 1


Table of Contents

1




Outils pour la programmation C

Outils de développement GNU

g

gdb

make

doxygen



Le projet GNU

Le projet GNU, initié par Ri hard Stallman en 1984, vise à réer un

système d'exploitation omplet qui réponde aux prin ipes du logi iel

libre

Li en e GPL (GNU General Publi Li ense) ou LGPL (GNU Lesser

General Publi Li ense)

Philosophie unix: programmes modulaires assemblés en un système

omplexe:

Portabilité

Standard Posix

Performan es

Prise en main plus di� ile que les outils ommer iaux.

Modèle é onomique de plus en plus suivi par les industriels.



prin ipaux outils de développement GNU

Le ompilateur g est la piè e maîtresse du projet GNU.

Compilateur C, C++ et Obje tive-C de très grande qualité, ses

performan es dépassent souvent elles des meilleurs ompilateurs

ommer iaux.

Autres ompilateurs g77, gnat, gp ,. . .

ema s éditeur de texte multifon tion qui peut faire aussi o� e

d'environnement intégré de programmation (IDE)

make permet d'automatiser l'ordonnan ement des di�érentes étapes

de ompilation

gdb est un débogueur pour les langages C, C++ et Fortran. ddd

apporte une interfa e graphique au-dessus de gdb.

automake, auto onf permette de produire fa ilement des

programmes portables.

Tous es programmes sont disponibles sur tous les type de systèmes.

Pour windows, 'est à travers l'environnement ygwin



GCC

La ommande g lan e plusieurs programmes suivant les options

Le pré-pro esseur pp

Le ompilateur 1

L'assembleur gas

L'éditeur de liens ld



Le pré-pro esseur: pp ou g -E

g -E ex1. -o ex1.i

Les tâ hes du prépro esseur sont :

élimination des ommentaires,

l'in lusion de � hier sour e,

la substitution de texte,

la dé�nition de ma ros,

la ompilation onditionnelle.

Exemple:

ex1.

#define MAX(a, b) ((a) > (b) ? (a) : (b))

...

f=MAX(3,b);

ex1.i

#define MAX(a, b) ((a) > (b) ? (a) : (b))

...

f=((3) > (b) ? (3) : (b));



Le ompilateur 1 ou g -S

Génère du ode assembleur

g -S exg . -o exg .s

Exemple:

#in lude <stdio.h>

int main()

{

printf("Hello world\n");

return(0);

}



Code assembleur du hello world (exg .s)

.file "exg . "

.se tion .rodata

.LC0:

.string "Hello world\n"

.text

.globl main

.type main, �fun tion

main:

pushl %ebp

movl %esp, %ebp

subl $8, %esp

andl $-16, %esp

movl $0, %eax

subl %eax, %esp

movl $.LC0, (%esp)

all printf

movl $0, %eax

leave

ret

.size main, .-main

.se tion .note.GNU-sta k,"",�progbits

.ident "GCC: (GNU) 3.3.5 (Debian 1:3.3.5-13)"



Assembleur as ou gas

Transforme un � hier assembleur en un ode objet (représentation

binaire du ode assembleur)

L'options - de g permet de ombiner ompilation et assemblage:

g - ex1. -o ex1.o



Éditeur de liens: ld

Produit l'exé utable (a.out par défaut) à partir des odes objets des

programmes et des librairies utilisées.

Il y a deux manières d'utiliser les librairies dans un programme

Librairies dynamiques ou partagées (shared, option par défaut): le ode

de la librairie n'est pas in lus dans l'exé utable, le système harge

dynamiquement le ode de la librairie en mémoire lors de l'appel du

programme. On n'a besoin que d'une version de la librairie en mémoire

même si plusieurs programmes utilisent la même librairie. La librairie

doit don être installée sur la ma hine, avant d'exé uter le ode.

Librairies statiques (stati ): le ode de la librairie est in lus dans

l'exé utable. Le � hier exé utable est plus gros mais on peut l'exé uter

sur une ma hine sur laquelle la librairie n'est pas installée.



Manipuler les � hiers binaires

Quelques ommandes utiles:

nm

permet de onnaître les symboles (en parti ulier les fon tions) utilisés

dans un � hier objet ou exé utable:

trisset�hom:~/ ours/2005/AGP/ ours_tri$ nm exg .o

00000000 T main

U printf

objdump permet d'analyser un � hier binaire. Par exemple pour

avoir la orrespondan e entre la représentation binaire et le ode

assembleur:

objdump -S exg

08048384 <main>:

8048384: 55 push %ebp

8048385: 89 e5 mov %esp,%ebp

8048387: 83 e 08 sub $0x8,%esp

804838a: 83 e4 f0 and $0xfffffff0,%esp

804838d: b8 00 00 00 00 mov $0x0,%eax

8048392: 29 4 sub %eax,%esp

8048394: 7 04 24 4 84 04 08 movl $0x80484 4,(%esp)

804839b: e8 10 ff ff ff all 80482b0 <_init+0x38>

80483a0: b8 00 00 00 00 mov $0x0,%eax

80483a5: 9 leave

80483a6: 3 ret



Options utiles de g

- :pas d'édition de liens

-o file: renomme le � hier de sortie file au lieu de a.out

-g : insère les informations né essaires à l'utilisation d'un déboggeur

(gbd, ddd).

-Wall : fait le maximum de véri� ations statiques possibles

-Oval :(val est un entier ompris entre 1 et 4), e�e tue des

optimisations de niveau val

-Ipath : re her he les � hiers d'en-tête dans le répertoire path

avant de les re her her dans les répertoires standards

(/usr/in lude, /usr/lo al/in lude).

-Lpath : re her he les librairies dans le répertoire path avant de les

re her her dans les répertoires standards (/usr/lib,

/usr/lo al/lib).

-Dflag=val : équivalent à é rire la dire tive

#define flag val dans le ode



Make

À l'aide d'un � hier de des ription, l'utilitaire make rée une suite de

ommandes qui seront exé utées par le shell d'unix.

Utilisé prin ipalement pour le développement logi iel mais peut aussi

servir à de nombreux projets: produ tion de gros do uments, mise en

pla e d'expérimentations et ...

Le prin ipal avantage est de ne pas tout re ompiler lorsque l'on a

hangé un seul � hier.

Lorsque l'on tape make, l'utilitaire re her he dans l'ordre un � hier

makefile puis un � hier Makefile, on peut lui indiquer d'utiliser un

autre � hier ave l'option -f:

make -f monFi h.mk



Make�le: Cibles et dépendan es

Dans un � hier Makefile, une ible est un objet qui va être produit

(par exemple un exé utable) par une règle de produ tion.

On produit une ible parti ulière à partir de � hiers parti uliers, es

� hiers sont les dépendan es de la ible.

Ces dépendan es peuvent être à leur tour des ibles d'autres règles

de produ tion.

Exemple (Attention, le ara tère tab est né essaire avant les règles

de produ tion):

all: main

main: main.o

g main.o -o main

main.o: main. type.h

g - main. -o main.o



Make�le: dé�nitions de variables

Les variables (ou ma ros) de make ont un omportement similaire

aux ma ros de C dé�nies par #define.

La syntaxe de la dé�nition de variable:

VAR1=quelque hose eten orequelque hose

On utilise la variable en mettant $(VAR1) ou ${VAR1}

Exemple typique d'utilisation:

TARGET_BIN = ../bin

OBJ = main.o utils.o tru .o

main: $(OBJ)

g -o main $(OBJ)

mv main $(TARGET_BIN)

la ommande make main exé ute:

g -o main main.o utils.o tru .o

mv main ../bin



Make�le: Variables prédé�nies

Un ertain nombre de variables sont fournies par défaut par make

SHELL indique sous quel shell est exé uté la ommande (en général

sh

CC indique le ompilateur C utilisé par le système.

CFLAGS indique les options par défaut du ompilateur.

LDFLAGS indique les options par défaut de l'éditeur de lien.

On peut visualiser l'ensemble des réglages par défaut de make ave

l'option -p



Make�le: substitution et variables dynamique

Si on a dé�ni une variable:

SRC = main. utils. tru .

Alors l'expression ${SRC:. =.o} vaudra:

main.o utils.o tru .o

Certaines variables sont positionnées dynamiquement lors de

l'évaluation d'une règle, par exemple $� est le nom de la ible de la

règle:

main: main.o utils.o tru .o

${CC} -o $� main.o utils.o tru .o

$< est le nom de la première dépendan e séle tionnée



Make�le: règles impli ites

La ompilation de programme C suit toujours le même s héma, par

exemple: g - monprog. -o monprog.o

On peut dé�nir des règles par défaut pour les ibles ayant un su�xe

parti ulier. Pour ela on indique à make quels sont les su�xes

intéressants et on spé i�e la règle impli ite. Par exemple

.SUFFIXES : .o .

. .o :

${CC} ${CFLAGS} - $< -o $�

On spé i�e alors uniquement les dépendan es pour haque � hier .o

.SUFFIXES : .o .

. .o :

${CC} ${CFLAGS} - $< -o $�

main.o: main. type.h



Make�le: Exemple

CC =g

EXE =ex1 ex1.1 ex1.2 ex1.3 ex2.1 ex3.1

SRC=$(EXE:=. )

OBJ=$(SRC:. =.o)

all: $(EXE)

tar:

make lean

d ..;tar - vf TD1_ orr.tar TD1/ex*. TD1/test*.in TD1/Makefile

.SUFFIXES : .o .

. .o :

${CC} ${CFLAGS} - $< -o $�

lean:

-rm -f *~ *.out $(EXE) *.o



Make�le: Exemple

Résultat de l'exé ution de la ommande make

g ex1.1. -o ex1.1

g ex1.2. -o ex1.2

g ex1.3. -o ex1.3

g ex2.1. -o ex2.1

g ex3.1. -o ex3.1



gdb: GNU symboli debugger

gdb est un debugger symbolique, 'est-à-dire un utilitaire Unix

permettant de ontr�ler le déroulement de programmes C.

gdb permet (entre autres) de mettre des points d'arrêt dans un

programme, de visualiser l'état de ses variables, de al uler des

expressions, d'appeler intera tivement des fon tions, et .

xxgdb ou ddd sont des interfa es graphiques qui fa ilitent

l'utilisation de gdb sous X-Window.

gdb ne né essite au un système de fenêtrage, il peut s'exé uter sur

un simple terminal shell (mode onsole).

Il est indispensable de omprendre le fon tionnement en mode de

gdb pour pouvoir utiliser les ddd.



Exemple de session gdb

int main()

{int i,*p;

i=1;

p=(int *)mallo (sizeof(int));

*p=2;

*p+=i;

fprintf(stdout,"i=%d, p=%X, *p=%d\n",i,p,*p);

free(p);

return(0);

}

ompilation ave -g:

shell$ g -g exgdb. -o exgdb

lan ement de gdb: shell$ gdb exgdb

GNU gdb 6.3-debian

(gbd)




Lorsque l'on lan e gdb ave la ommande gdb exgdb. , gdb a

hargé l'exé utable, il attend alors une ommande gdb, omme par

exemple run (pour exé uter le programme), break (pour mettre un

point d'arret dans le programme), step (pour avan er d'une

instru tion dans le programme), et .

Les points d'arrêt peuvent se positionner au début des fon tions

(break main, par exemple), ou à une ertaine ligne (break 6, par

exemple), ou lorsqu'une variable hange de valeur (wat h i, par

exemple).




(gdb) break main

Breakpoint 1 at 0x8048424: file exgdb. , line 6.

(gdb) run

Starting program: /home/trisset/ ours/2005/AGP/ ours_tri/exgdb

Breakpoint 1, main () at exgdb. :6

6 i=1;

(gdb)

gdb a lan é l'exé utable et arrêté l'exé ution à la ligne 6 du � hier (à la

première ligne de la fon tion main), le ode de ette ligne apparaît à

l�é ran.

On peut avan er d'un pas dans le programme:

(gdb) step

7 p=(int *)mallo (sizeof(int));

(gdb)

(gdb) print i

$1 = 1

(gdb)




(gdb) display i

1: i = 1

(gdb)

A� hage de pointeurs ( omme une variable):

(gdb) display p

2: p = (int *) 0xb8000540

(gdb)

A� hage d'objet pointés par les pointeurs :

(gdb) display *p

3: *p = -1208053760

(gdb)

(gdb) step

8 *p=2;

3: *p = 0

2: p = (int *) 0x804a008

1: i = 1

(gdb)




(gdb) step

9 *p+=i;

3: *p = 2

2: p = (int *) 0x804a008

1: i = 1

(gdb) step

10 fprintf(stdout,"i=%d, p=%X, *p=%d\n",i,p,*p);

3: *p = 3

2: p = (int *) 0x804a008

1: i = 1

(gdb) next

i=1, p=804A008, *p=3

11 free(p);

3: *p = 3

2: p = (int *) 0x804a008

1: i = 1

(gdb) ont

Continuing.

Program exited normally.

(gdb)



gdb ommandes abrégées

On peut taper la première lettres des ommandesx:

r est équivalent à run

b main est équivalent à break main

p var est équivalent à print var

d var est équivalent à display var

s est équivalent à step

n est équivalent à next

est équivalent à ontinue

La ommande run peut prendre des arguments, le programme est

alors exé uté ave les arguments donnés

la ommande info permet d'a� her des informations sur l'état du

programme dans le débugger. Par exemple info b liste les points

d'arrêt.

La ommande help est l'aide en ligne de gdb



ddd: data display debugger

ddd est une interfa e graphique pour gdb.

Après avoir ompilé ave l'option -g, on tape:

ddd nomduprog

Par exemple:

ddd exgdb



ddd: haut de la fenêtre



ddd: bas de la fenêtre



ddd: fenêtre de ommande



ddd: breakpoint



ddd: display



Doxygen

Ce que l'on dé rit bien, se onçoit bien

Do umenter (un fon tion)... n'est pas ommenter! (le ode)

Pour qui do umenter ou ommenter: programmeur ou utilisateur?

Choix du mode de do umentation: interne (dans le ode) ou externe

(do ument indépendant)

Fa ilité d'a ès, lisibilité,

Syn hronisation ave le ode.



Do umentation programmeur

Historique: qui/quand/quoi,

Algorithme,

Borne d'utilisation,

Paramètres/Valeur retournée,

Stru ture du module,

Mode d'utilisation,

Code d'erreur.



Problématique de la maintenan e

Historique: qui/quand/quoi,

Do umentation utilisée à jour?

Que fait la fon tion?

Quel module utilise quelle fon tion?

E�et de as ade de la modi� ation?

Test du programmeur?



Prin ipe de Doxygen

Système de do umentation automatique à partir de ommentaires

interne au ode.

Fon tionne ave C, C++ et Java.

Peut générer une do umentation en HTML, RTF, Latex ou en man

pages.

Utile aussi bien pour maintenir et omprendre le fon tionnement de

vos gros projets de développement que omme do umentation pour

d'autres qui vont lire votre ode.

Le ode sour e ontient des balise Doxygen (appelées ommandes

spé iales).

Un � hier de on�guration ASCII indique le paramétrage de Doxygen.

La ommande doxygen fi hierConfig génère la do umentation

désirée (html par défaut).



Commentaires Doxygen

Les blo s multi lignes visibles de Doxygen ommen ent ave /** ou

/*! et �nissent ave */

Une ligne unique de ommentaire peut être rendue visible par /// ou

//!

Il est re ommandé de pla er les ommentaires avant les parties

ommentées.

Les ommandes spé iales Doxygen ommen es par � ou \Il est possible de mettre dans les parties visibles de Doxygen:

des listes (hiérar hiques ou pas)

des référen es roisées (ave la notion de groupe)

des formules mathématiques (Latex ou HTML)

des graphiques (au format dot: http://www.graphviz.org)



Commandes spé iales

Il existe des ommandes spé iales:

de formatage du texte (ex: \b pour bold)

d'indi ation de stru ture (ex: \mainpage pour indiquer la page de

démarrage de la do ).

d'indi ateur de se tion (ex: \brief: des ription brève de l'élément)

Certaines ommandes attendent un premier argument parti ulier,

puis un autre (qui �ni à la �n de la ligne ou a la �n du paragraphe):

exemple: \param nom des ription du parametre

a� he

parameter:

nom des ription du paramètre

Les ommentaires mis au dessus du prototype d'une fon tion (dans

le � hier .h) sont ajoutés aux ommentaires prin ipaux (mieux vaut

ne pas les rendre visible de Doxygen)



Proposition d'utilisation minimale pour AGP

Utilisation d'un � hier de on�guration ommun (doxyfile)

Avant les dé larations de fon tion:

\brief pour la des ription de la fon tion

\param pour haque paramètre

\result pour le résultats

\warning pour les mises en garde parti ulières

Avant les dé larations de stru ture de donnée

\brief pour la des ription de la stru ture de donnée

éventuellement//! pour la des ription des hamps de la stru ture

Avant les dé�nitions de ma ros ommunes (dans les � hier .h)

\def pour la dé�nition de la ma ro



Liens à onnaître

make, do umentation

http://www.gnu.org/software/make/manual/make.html

g home page: http://g .gnu.org/

gdb do umentation

http://www.gnu.org/software/gdb/do umentation/,

ddd do umentation http://www.gnu.org/software/ddd/manual/

Qui k referen e ards: http://mirror.lzu.edu. n/do /qr /


anguy T - INSA Lyon · 2016-09-18 · Outils p our la rogrammationp GP: A rithmiqueAlgo et...

Documents

Transcript of anguy T - INSA Lyon · 2016-09-18 · Outils p our la rogrammationp GP: A rithmiqueAlgo et...