christian casteyde - freeploug22.free.fr/doc/gcc-casteyde.pdf · 2005-10-12 · le compilateur c++...

Mode d’emploi de GCC

Christian Casteyde

Mode d’emploi de GCCpar Christian Casteyde

Copyright (c) 2000 Christian Casteyde

Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1

or any later version published by the Free Software Foundation; with no Invariant Sections, with the no Front-Cover Texts, and with no

Back-Cover Texts.

A copy of the license is included in the section entitled "GNU Free Documentation License".

Une copie de la GNU Free Documentation License est donnée enAppendix A

Historique des versions

Version 1.2.4 31/07/2001 Revu par : CCCorrections orthographiques. Mise à jour pour GCC 3.0.3 et GDB 5.1.1.Version 1.2.3 05/12/2000 Revu par : CCCorrections orthographiques.Version 1.2.2 01/10/2000 Revu par : CCCorrections typographiques.Version 1.2.1 11/09/2000 Revu par : CCPassage au format de fichier SGML. Corrections mineures.Version 1.2 01/06/2000 Revu par : CCCorrections sur l’utilisation de l’analyseur de couverture et du profiler.Version 1.1 25/05/2000 Revu par : CCPrécision sur les chiens de garde hardware dans les programmes multithreadés.Version 1.0 23/05/2000 Revu par : CCVersion initiale.

Table des matièresPréface..................................................................................................................................................i

1. Introduction .....................................................................................................................................1

2. Droits d’utilisation ..........................................................................................................................3

3. Principaux outils .............................................................................................................................5

4. Utilisation de GCC..........................................................................................................................7

5. Le préprocesseur.............................................................................................................................9

6. Le compilateur..............................................................................................................................11

7. L’assembleur.................................................................................................................................13

8. L’archiveur ....................................................................................................................................15

9. L’éditeur de liens...........................................................................................................................17

10. Utilisation de make.....................................................................................................................19

11. strip ..............................................................................................................................................21

12. Windres........................................................................................................................................23

13. dlltool ...........................................................................................................................................25

14. Le débogueur...............................................................................................................................29

14.1. Chargement d’un programme..........................................................................................2914.2. Commandes fondamentales.............................................................................................3014.3. Les points d’arrêt.............................................................................................................3014.4. Contrôle de l’exécution....................................................................................................3314.5. Les chiens de garde..........................................................................................................3414.6. Examen et modification des données...............................................................................3414.7. Examen du contexte d’exécution.....................................................................................3714.8. Gestion des threads..........................................................................................................3814.9. Gestion des fichiers sources.............................................................................................3914.10. Spécification du langage................................................................................................3914.11. Complétion des commandes..........................................................................................40

15. Le profiler ....................................................................................................................................41

16. L’analyseur de couverture..........................................................................................................43

17. Programmation de composants COM en C++.........................................................................45

18. Conclusion...................................................................................................................................47

A. GNU Free Documentation License.............................................................................................49

v

Liste des tableaux3-1. Outils de développement GNU.....................................................................................................54-1. Options de gcc...............................................................................................................................75-1. Option du préprocesseur................................................................................................................96-1. Options du compilateur C............................................................................................................117-1. Options de l’assembleur..............................................................................................................139-1. Options de l’éditeur de liens........................................................................................................1711-1. Options de strip.........................................................................................................................2112-1. Options de windres....................................................................................................................2313-1. Options de dlltool......................................................................................................................2515-1. Options du profiler.....................................................................................................................41

vii

PréfaceCe document est un mode d’emploi simplifié des divers outils de développement réalisés par la FreeSoftware Foundation dans le cadre du projet GNU. Le projet GNU est un projet visant à réaliser unsystème Unix complet et libre de droits d’utilisation. Libre signifie ici que l’on peut aussi bien utiliserque modifier le système, le distribuer librement de façon rémunérée ou non.

Les outils de développement GNU font partie des meilleurs outils Unix disponibles actuellement. Ilssont fournis en standard avec Linux, mais ils sont également disponibles pour de nombreuses plates-formes. Des portages ont également été réalisés pour DOS, Win32 et OS/2.

Ce document est distribué sous la licence FDL du projet GNU. C’est une licence libre, vous en trou-verez un exemplaire enAnnexe A. Vous pourrez trouver la dernière version de ce document sur monsite Web (http://casteyde.christian.free.fr).

i

Préface

ii

Chapitre 1. IntroductionGCC est le nom générique de la suite d’outils de développement contenant, entre autres, le compila-teur C/C++ GNU développé par la Free Software Foundation. C’est en fait un front-end qui permetd’utiliser les programmes de développement. Ce front-end est très souple et peut être utilisé pour lesdifférentes phases de production des binaires : preprocessing des fichiers sources, compilation, as-semblage et édition de liens. Il dispose d’un grand nombre d’options, et peut être paramétré à l’aided’un fichier de configuration.

GCC existe en plusieurs versions. La dernière version officielle disponible est la 3.0.3. Cette versioncomprend un compilateur C/C++ et un compilateur Java. Le compilateur C++ est capable de com-prendre la plupart des constructions de ce langage, excepté le mot-cléexport . Il existe égalementune version plus ancienne mais nettement plus stable, la version 2.95.3, que l’on utilisera donc depréférence si l’on ne recherche pas les dernières fonctionnalités du langage et de la norme C++. Cetteversion ne comprend pas de compilateur Java.

La suite de développement GNU est certainement l’une des plus portables qui soit. Fondamentale-ment, elle a été conçue pour être utilisée sous UNIX. Cependant, il en existe également des versionspour d’autres systèmes d’exploitation. Ce document donne les notions relatives au développementavec le compilateur C/C++ de la suite de compilateurs GCC, pour les principales plates-formes pourlesquelles GCC a été porté. Ils donne également quelques informations spécifiques à chaque plate-forme, lorsque cela est nécessaire. Ces informations sont clairement identifiées dans le document.

SPÉCIFIQUE DOS : La version DOS est appelée DJGPP, elle correspond à la version 2.8.1. deGCC.

SPÉCIFIQUE WIN32 : Les versions Windows sont pour les plates-formes 32 bits de ce système.Il en existe trois version de GCC pour Windows.

La version fournie par Cygwin utilise une DLL d’émulation des appels UNIX sous l’API Win32 pourfaire fonctionner la suite de développement GNU. Les programmes générés par Cygwin utilisentégalement cette DLL, ce qui fait de cette version l’outil idéal pour compiler des programmes UNIXsous Windows. Il est également possible de générer des programmes natifs pour Windows, quin’utilisent pas la DLL d’émulation d’UNIX, pourvu que ces programmes n’utilisent pas la librairieC++.

Les deux autres versions utilisent le portage de la librairie C mingw32. Ces deux versions sontliées aux deux librairies C standard du système CRTDLL.DLL ou MSVCRT.DLL. Les programmescréés sont donc des programmes natifs (que ce soient des programmes C ou C++). Ces deuxversions utilisent le portage réalisé par Cygwin (en particulier les extensions du linker pour gérerla plate-forme Win32) et ont été recompilées avec mingw32.

Comme toutes ces versions sont réalisées à partir des mêmes fichiers sources, toutes les optionsde ces plates-formes sont identiques.

1

Chapitre 1. Introduction

2

Chapitre 2. Droits d’utilisationTous les programmes de la suite de développement sont soumis à la GPL (General Public License).La librairie GNU C++ est soumise à la LGPL (Library General Public License).

Note : La GPL implique un certain nombre de droits et d’obligations pour leurs utilisateurs. Le butprincipal de cette licence est de garantir le droit à échanger, utiliser et modifier librement les pro-grammes qui sont soumis à cette licence. Ceci signifie que les distributeurs de ces programmesdoivent également fournir les sources, ou au moins suffisamment d’information pour que les récip-iendaires puissent obtenir les sources librement. Bien entendu, toute personne désirant modifierle logiciel doit se plier aux exigences de la GPL, c’est à dire que la modification doit être signalée,que la version modifiée doit elle-même être soumise à la GPL, et que la version originale doitêtre accessible aux récipiendaires. Il en va de même pour les logiciels qui utilisent une partie ducode licencié sous les termes de la GPL. Il va donc de soi que le fait d’être libre pour un logicielsupprime toute garantie quant à son utilisation. En effet, le code source peut avoir été modifié, etun dysfonctionnement de sa part ne peut être imputé à l’auteur du logiciel.

La LGPL s’applique spécifiquement aux bibliothèques logicielles. Elle permet de faire la distinc-tion entre l’utilisation d’une bibliothèque, qui est à la convenance de l’utilisateur, et l’utilisationd’une partie du code source d’un logiciel soumis à la GPL. Elle permet à des développeurs deprogrammes non libres d’utiliser des bibliothèques soumises à la LGPL.

La LGPL stipule que tout programme qui utilise la bibliothèque n’est pas soumise à la GPL,puisqu’il ne contient pas de code appartenant à cette bibliothèque. Cependant, la version com-pilée de ce programme contient une partie du code de la bibliothèque, et est donc soumis àla LGPL. La version compilée peut être distribuée selon les termes de son auteur, mais elledoit impérativement être fournie avec le code source de la bibliothèque, y compris les modifica-tions qui y ont été apportées, et avec le code source ou le code objet du programme qui utilisela bibliothèque. Cette obligation a pour but d’assurer la liberté de tout un chacun de modifierla bibliothèque et d’effectuer l’édition de lien et du logiciel avec cette version modifiée et sondéboguage. Le distributeur n’est toutefois pas tenu d’assurer une édition de lien correcte si lesfichiers d’en-tête de la bibliothèque ont été modifiés.

Ces licences impliquent que vous pouvez utiliser les compilateurs GCC pour développer des pro-duits libres ou commerciaux. Cependant, si vous utilisez une bibliothèque soumise à la LGPL,vous devez fournir au moins les fichiers objets de votre produit en plus des sources de la biblio-thèque utilisée, afin que les utilisateurs puissent toujours avoir le droit de modifier la bibliothèqueet d’utiliser cette version modifiée avec votre produit. Vous pouvez également lier vos exécuta-bles avec les bibliothèques chargeables dynamiquement afin de séparer votre code de celui desbibliothèques utilisées.

La bibliothèque GNU libgpp est soumise à la LGPL (classes d’entrées/sorties C++). Cette biblio-thèque est en cours de remplacement par la librairie libstdc++ (ou libstdcxx), qui est égalementsoumise à la LGPL (ce remplacement a été réalisé avec les versions 3.0 et ultérieures de GCC).Cependant, les exécutables liés avec cette librairie ne sont pas soumis à la LGPL à titre excep-tionnel.

Les compilateurs GNU sont fournis également avec la librairie standard C++ (STL). Celle-ci estcopyrightée par Hewlett Packard. Elle peut être librement utilisée, sans aucune contrainte. Ellen’est fournie sans aucune garantie. De plus, les librairies C fournies avec les versions portéesde GCC sont copyrightées par les auteurs respectifs du portage. Leur utilisation est soumise à lanotice de copyright fournie par ces auteurs.

DJGPP requiert que l’utilisateur puisse trouver DJGPP librement et que votre programme men-tionne dans sa documentation et sa publicité la notice suivante :

This product includes software developed by the University ofCalifornia, Berkeley and its contributors.

3

Chapitre 2. Droits d’utilisation

En effet, une partie de la librairie C de DJGPP est utilise du code copyrighté par BSD. Mingw32est librement utilisable (c’est une bibliothèque freeware). Cygwin32 est également librement util-isable.

4

Chapitre 3. Principaux outilsLes outils disponibles sont les suivants :

Tableau 3-1. Outils de développement GNU

Outil Description

gcc Front-end pour le compilateur GNU C.

g++ Front-end pour le compilateur GNU C++.

c++ Alias de g++.

cpp Préprocesseur C.

cc1 Compilateur C.

cc1plus Compilateur C++.

gasp Préprocesseur pour l’assembleur.

as Assembleur.

ar Archiveur.

ld Éditeur de liens.

make Programme de gestion des dépendances pour la construction des projets.

gdb Débogueur symbolique.

strip Extracteur d’informations symboliques de déboguage.

gperf Profiler.

gcov Analyseur de taux de couverture.

g77 Traducteur de Fortran 77 en C.

dlltool Outil de génération des tables d’exportation et des bibliothèquesd’importation des DLLs pour Windows.

windres Compilateur de fichiers de ressources pour Windows.

gccest un front-end qui permet d’appeler le préprocesseur, le compilateur, l’assembleur et le linkerpour les langages C et C++. Les opérations que ce programme réalise sont les suivantes :

• appel du préprocesseur C (nommécpp) ;

• appel du compilateur C (nommécc1), ou C++ (cc1plus) selon le type de fichier à compiler (lesfichiers .c sont compilés en C, les fichiers .C, .cc et .cpp sont compilés en C++). Les compilateursgénèrent un fichier assembleur ;

• appel de l’assembleur (as) pour générer le fichier objet, si l’option-S n’est pas spécifiée ;

• appel de l’éditeur de liens (ld) pour générer l’exécutable ou la bibliothèque, si l’option-c n’estpas spécifiée. Dans ce cas, la librairie C standard est incluse par défaut dans la ligne de commandede l’édition de liens. La librairie C++ n’est en revanche pas incluse.

g++ est un front-end pour le langage C++, qui effectue le même travaille que gcc, mais qui ajouteégalement les librairies C++ à la ligne de commande de l’éditeur de liens.c++, s’il est présent, est lemême programme queg++, fourni sous un autre nom.

5

Chapitre 3. Principaux outils

SPÉCIFIQUE WIN32 : L’éditeur de liens n’est pas capable de générer des bibliothèques dy-namiques pour Windows (DLL). En effet, les DLL de Windows contiennent ce que l’on appelleune table de fonctions exportées, qui n’est rien d’autre qu’un tableau de pointeurs vers les fonc-tions exportées de la DLL. Cette table est utilisée par le chargeur de Windows pour résoudre dy-namiquement les liens vers les fonctions de la DLL dans les programmes qui l’utilisent. Commeld n’est qu’un éditeur de liens, il ne génère pas ces tables, et il faut recourrir à l’outil dlltool .Celui-ci peut créer un fichier objet contenant la table des fonctions exportées, que l’on utiliseraensuite pour effectuer l’édition de liens complète. L’outil dlltool permet également de générer lesbibliothèques d’importation statiques pour les DLL existantes, afin de pouvoir les charger automa-tiquement au chargement d’un programme.

Les chemins passés aux programmes appelés peuvent être spécifiés aussi bien au format DOSqu’au format UNIX. Cependant, il est préférable d’utiliser le format UNIX, car dans les fichiersmakefile, le séparateur \ ne peut être obtenu qu’en le doublant en raison de sa signification par-ticulière de fin de ligne. Ce problème n’apparaît pas avec les chemins UNIX, qui utilisent le sé-parateur /.

SPÉCIFIQUE DOS : Même remarque pour les chemins que pour Windows. De plus, les noms defichiers doivent être limités à 8 lettres et d’une extension au plus, de 3 lettres maximum.

La suite de développement GNU utilise un fichier spécial pour permettre à l’utilisateur de définir denouvelles options pour ses programmes. Ce fichier est souvent placé dans le répertoire où se trouventles bibliothèques, il se nommespecs . Il permet, pour chaque programme, de définir les nouvellesoptions, les conditions d’applications et ce par quoi ces options doivent être remplacées dans la lignede commande de l’outil.

L’utilisation des différents outils est décrite dans la suite de ce fichier.

6

Chapitre 4. Utilisation de GCCgccdispose des options classiques de la plupart des front-end de compilateurs. Les principales optionssont définies ci-dessous :

Tableau 4-1. Options de gcc

Option Signification

--help Affiche l’aide de GCC.

--version Donne la version de GCC.

-E Appelle le préprocesseur. N’effectue pas la compilation.

-S Appelle le préprocesseur et effectue la compilation. N’effectue pasl’assemblage ni l’édition de lien. Seuls les fichiers assembleur (« .S ») sontgénérés.

-c Appelle le préprocesseur, effectue la compilation et l’assemblage, mais nefait pas l’édition de lien. Seuls les fichiers objets (« .o ») sont générés.

-o nom Fixe le nom du fichier objet généré lors de la compilation d’un fichiersource.

-g Génère les informations symboliques de déboguage.

-fexceptions Active la gestion des exceptions C++.

-fpic Génère du code relogeable. Cette option est nécessaire pour lacompilation des fichiers utilisés dans une DLL ou un fichier chargeabledynamiquement.

-On Indique le niveau d’optimisation (n peut prendre les valeurs allant de 0 à3, ou «s » pour optimiser la taille des binaires).

-mcpu=cpu Indique le type de processeur pour lequel le code doit être optimisé. Lecode fonctionnera sur tous les processeurs de la famille de ce processeur.

-march=cpu Indique le type de processeur pour lequel le code doit être généré. Le codegénéré sera spécifique à ce processeur, et ne fonctionnera peut-être pas surun autre modèle de la même famille. Cette option active automatiquementl’option -mcpu avec le même processeur.

-pipe Utilise les pipes systèmes au lieu des fichiers temporaires pour lescommunications entre le préprocesseur, le compilateur et l’assembleur.

-w Supprime tous les warnings.

-W Active les warnings supplémentaires.

-Wall Active tous les warnings possibles.

-mwindows Crée un exécutable GUI Windows.

-mdll Crée une DLL Windows.

-fvtable-thunks Utilise le mécanisme des tables de fonctions virtuelles. Cette option estnécessaire pour utiliser les interfaces COM sous Windows.

La plupart des autres options ne sont pas gérées directement pargcc. Elles sont directement commu-niquées aux programmes appelés par lui. Les options de ces programmes peuvent donc souvent êtreutilisées avecgcc, voir la documentation de ces programmes pour plus de renseignements.

7

Chapitre 4. Utilisation de GCC

SPÉCIFIQUE WIN32 : Les options -mwindows et -dll ne sont pas des options natives de la suitede développement GNU. Elles sont définies dans le fichiers specs de la version Windows.

Il est également possible de passer des options spécifiques aux programmes appelés pargccà l’aidede l’option-W<lettre >. Les options les plus utiles sont les suivantes :


-Wa, <options > Passe les options suivantes à l’assembleur. Les options doivent êtreséparées par des virgules.

-Wp, <options > Passe les options suivantes au préprocesseur. Les options doivent êtreséparées par des virgules.

-Wl, <options > Passe les options suivantes à l’éditeur de liens. Les options doivent êtreséparées par des virgules.

gcc prend directement en ligne de commande les fichiers à traiter. L’ordre des fichiers n’a pasd’importance, sauf pour les fichiers de bibliothèques. Les bibliothèques doivent être passées à lafin, parce qu’elles ne sont utilisées que si l’éditeur de liens y trouve des symboles non résolus aumoment de l’utilisation de la bibliothèque.

8

Chapitre 5. Le préprocesseurLe préprocesseur est le premier programme appelé par gcc. Son rôle est de supprimer les commen-taires, d’inclure les fichiers spécifiés avec la directive «#include » et d’évaluer les macros. À l’issuede l’exécution du préprocesseur, le fichier peut être compilé directement sans autre traitement par lecompilateur.

La ligne de commande du préprocesseur est donnée ci-dessous :

cpp options source destination

oùoptions représente les diverses options que l’on peut passer au préprocesseur,source est le nomdu fichier source à traiter etdestination est le nom du fichier de sortie.

Les principales options du préprocesseur sont les suivantes :

Tableau 5-1. Option du préprocesseur


--help Affiche l’écran d’aide du préprocesseur.

-I répertoire Ajoute le répertoirerépertoire à la liste des répertoires. Ce répertoireest ajouté en tête de liste.

-D nom Déclare l’identificateurnom.

-D

macro=définition

Définit la macromacro .

-U nom Supprime la définition du symbolenom.

-trigraphs Autorise l’utilisation des trigraphes C.

9

Chapitre 5. Le préprocesseur

10

Chapitre 6. Le compilateurLe compilateur appelé pargcc est soitcc1, si le fichier source est un fichier C, soitcc1plus, s’ils’agit d’un fichier C++. Seules les principales options sont décrites ici. Pour plus de renseignements,consulter la documentation de GCC, ou demandez l’écran d’aide du compilateur.

Tableau 6-1. Options du compilateur C


--help Affiche l’écran d’aide du compilateur.

--version Affiche la version du compilateur.

-o nom Donne le nom du fichier de sortie.

-g Génère les informations symboliques de déboguage.

-On Active les optimisations (n allant de0 à3, ou «s » pour optimiser la tailledu code généré).

-f <option > Active une option.

-ansi Demande la compilation du code ANSI.

-pedantic Affiche les warnings requis par la norme ANSI du langage.

-pedantic-errors Génère les erreurs requis par la norme ANSI du langage.

-w Supprime tous les warnings.

-W Active les warnings supplémentaires.

-Wall Active tous les warnings possibles.

-p Active le profiling des fonctions.

-a Active le profiling des blocks.

-ax Active le profiling des branchements.

-fPIC Génère du code indépendant de son adresse de chargement (nécessairepour les bibliothèques dynamiques, dont le chargement peut être réalisépar le système n’importe où en mémoire a priori).

Le compilateur prend en ligne de commande le fichier à compiler. Il génère le code assembleur résul-tant de la compilation.

11

Chapitre 6. Le compilateur

12

Chapitre 7. L’assembleurL’assembleur GNU a été créé pour permettre l’assemblage des fichiers assembleurs générés par lecompilateur. Ceci signifie que toutes les constructions des autres assembleurs conçus spécialementpour utiliser l’assembleur en tant que code source d’un programme ne sont pas forcément géréespar l’assembleur GNU. En revanche, la syntaxe de l’assembleur reste à peu près identique entre lesdifférentes versions pour les différentes plates-formes. Bien entendu, les mnémoniques sont toujoursspécifiques au processeur.

L’assembleur GNU ne sera donc utilisé qu’avec le compilateur GNU pour la plate-forme correspon-dante en pratique. Si l’on veut réaliser du code assembleur soi-même, il est recommandé d’utiliser unassembleur spécialisé.

Les principales options de l’assembleur sont les suivantes :

Tableau 7-1. Options de l’assembleur


--help Affiche l’écran d’aide de l’assembleur.

--version Affiche le numéro de version de l’assembleur.

--statistics Affiche les statistiques sur l’exécution de l’assembleur.

-I répertoire Ajoute un répertoire pour la recherche des fichiers inclus.

-o nom Donne le nom du fichier objet à générer.

-W Supprime l’affichage des warnings.

En général, l’assemblage d’un fichier se fera avec la ligne de commande suivante :

as -o objet source

où objet est le nom du fichier objet résultat etsource le nom du fichier assembleur à assembler.

13

Chapitre 7. L’assembleur

14

Chapitre 8. L’archiveurL’archiveur permet de regrouper plusieurs fichiers objets dans un seul fichier bibliothèque. Les prin-cipales commandes dear sont l’ajout, la suppression et l’extraction des fichiers objets de la biblio-thèque. Toutes les commandes prennent en paramètre une lettre indiquant l’action à réaliser, avecéventuellement quelques modificateurs, et le fichier bibliothèque sur lequelar doit travailler. Lesnoms des fichiers objets doivent parfois être fournis également.

Pour créer une bibliothèque ou lui ajouter des fichiers, on utilisera la ligne de commande suivante :

ar -r bibliothèque fichiers

oùbibliothèque est le nom de la bibliothèque etfichiers est la liste des fichiers objets à ajouter.ar n’ajoute pas les extensions aux noms des fichiers, le nom de la bibliothèque doit donc comprendrel’extension « .a » et le nom des fichiers objets l’extension « .o ». Si l’archive contient déjà les fichiersobjets passés en paramètre, ceux-ci sont remplacés. Si l’on ne veut remplacer que les fichiers del’archive dont la date et l’heure de création est antérieure à la date et l’heure de création des fichiers àajouter, il faut utiliser l’option-ru à la place de l’option-r .

Pour supprimer un fichier objet d’une bibliothèque, il faut utiliser la ligne de commande suivante :

ar -d bibliothèque fichier

Pour lister les fichiers objets d’une archive, il faut utiliser la commande suivante :

ar -t bibliothèque

Pour extraire des fichiers objets d’une archive, il faut utiliser la ligne de commande suivante :

ar -x bibliothèque fichier

Si aucun fichier n’est spécifié, tous les fichiers sont extraits de l’archive. Si l’on fixer la date et l’heurede création des fichiers extraits à leur date d’archivage, il faut utiliser l’option-xo à la place de-x .

15

Chapitre 8. L’archiveur

16

Chapitre 9. L’éditeur de liensL’éditeur de liens permet de regrouper les fichiers .o et les bibliothèques .a pour former un exécutableou une nouvelle bibliothèque. La plupart des options spécifiques au système cible sont indiquées lorsde la phase d’édition de liens.

La syntaxe de l’éditeur de liens est relativement simple. Il prend en ligne de commande la liste desfichiers à utiliser pour la résolution des symboles, dans l’ordre dans lequel ils doivent être utilisés.Les principales options sont décrites ci-dessous :

Tableau 9-1. Options de l’éditeur de liens


--help Affiche l’écran d’aide de l’éditeur de liens.

--version Donne le numéro de version de l’éditeur de liens.

-o nom Spécifie le nom du fichier généré par l’éditeur de liens.

-L chemin Ajoute un répertoire à la liste des répertoires utilisés pour la recherche desbibliothèques.

-l bibliothèque Ajoute une bibliothèque dans la liste des fichiers à utiliser pour l’éditionde liens.

-e symbole Spécifie le symbole devant être utilisé comme point d’entrée dans lefichier généré.

-i Utilise l’édition de lien incrémentale.

-s Supprime tous les symboles du fichier généré.

-S Supprime les informations symboliques de déboguage du fichier généré.

--sybsystem

système

Permet d’indiquer le sous-système pour lequel l’exécutable est généré.

--rpath chemin Permet de donner le chemin dans lequel l’éditeur de liens doit rechercherles bibliothèques dynamiques dont dépend la bibliothèque ou leprogramme dont on réalise l’édition de liens. Cette option permet deréaliser une édition de lien avec des symboles externes se trouvant dansdes bibliothèques chargeables dynamiquement autre que celles installéesdans le système.

--soname nom Permet de donner un nom interne à la librairie autre que le nom du fichiergénéré par l’éditeur de lien. Ce nom est utilisé lors de l’édition de liensdynamiques afin de déterminer quelle bibliothèque doit être utilisée avec leprogramme en cours de chargement.

--dll Permet de créer une DLL Windows.

--base-file

fichier

Permet de créer un fichier map des symboles des DLL de Windows.

Note : On notera que bien que les fichiers contenant les bibliothèques ont tous la forme libNNN.a

ou libNNN.so , seul le nom NNNde la bibliothèque doit être utilisé dans la ligne de commande dulinker. Par exemple, pour utiliser la bibliothèque libc.a , il faudra utiliser l’option -lc .

17

Chapitre 9. L’éditeur de liens

SPÉCIFIQUE WIN32 : Les bibliothèques chargeables dynamiquement ne se nomme pas de lamême manière sous Windows que sous Unix. En effet, l’extension de ces bibliothèques est .DLL

d’une part, et les fichiers de bibliothèques ne disposent pas du suffixe lib . De plus, l’édition deliens avec une bibliothèque dynamique ne se fait pas directement, mais plutôt avec une librairied’importation statique.

Les options -mdll et -mwindows de gcc activent respectivement les options --subsystem win-

dows et --dll de l’éditeur de liens. La première option effectue l’édition de liens avec les biblio-thèques user32 , gdi32 et comdlg32 , et spécifie le fichier crt1.o comme fichier de démarrage.Elle permet donc de réaliser un exécutable GUI Windows. La deuxième option spécifie commepoint d’entrée la fonction DllMainCRTStartup , et le comme fichier de démarrage le fichier dll-

crt1.0 . Cette option permet donc de réaliser une DLL Windows. Aucune option particulière nedoit être utilisée pour réaliser un programme Win32 en mode console.

L’option suivante --base-file fichier est disponible afin de permettre la création de DLL rel-ogeable. Elle permet de demander à l’éditeur de liens de générer un fichier contenant les infor-mations sur les adresses relatives des symboles du fichier objet passé en paramètre par rapportà leur adresse de base. Ce fichier peut être exploité par l’outil dlltool , afin de générer le fichiercontenant la table d’exportation des symboles de la DLL. Cette table doit être communiquée enligne de commande, comme un fichier objet classique, lors de l’édition de lien finale de la DLL.L’outil dlltool sera décrit plus en détail plus loin.

Enfin, le fichier specs fourni avec les versions Win32 de GCC ajoute les bibliothèques suivantesà la ligne de commande de l’éditeur de liens :

• kernel32

• advapi32

• shell32

Ces bibliothèques sont les bibliothèques de base pour tous les programmes Windows.

18

Chapitre 10. Utilisation de makemake permet d’interpréter un fichier de dépendance entre les différents éléments nécessaires à lacréation d’un projet. Ce fichier est appelé «makefile ». En fait, il contient les relations entre fichiersqui permettent d’établir les dépendances nécessaires à la création d’autres fichiers. Si, pour créer unfichier A, il faut utiliser un fichierB, alors il va d’abord falloir créer le fichierB.

Le travail demake est essentiellement de vérifier les dates des fichiers pour déterminer quels sontceux qui sont à jour et ceux qu’il faut recréer afin de générer le projet. Pour chacun des fichiers àrecréer, une ligne de commande est exécutée.

La syntaxe des fichiers makefile dépasse le cadre de ce document. En revanche, l’utilisation demakelui-même est élémentaire, puisqu’il suffit de l’appeler en passant en paramètre le nom du projet àcréer :

make cible

En général, les fichiers makefile contiennent une cible nommée «all », qui permet de générer toutle projet.

En réalité,makepeut être utilisé dans un autre contexte que la programmation : il permet d’effectuerdes commandes de mises à jour de fichiers qui dépendent de la mise à jour d’autres fichiers.

19

Chapitre 10. Utilisation de make

20

Chapitre 11. stripstrip est un petit utilitaire qui permet de retirer les informations symboliques de déboguage d’unfichier. Son utilisation est des plus simples :

strip fichier

Le fichier est modifié à l’issue de cette commande. Il ne contient plus d’informations symboliques dedéboguage. Rappelons que ces informations sont générées par le compilateur si l’option-g est passéeen ligne de commande. On notera toutefois que le fait de ne pas mettre cette option n’implique pasque le résultat de l’édition de lien ne contient pas de telles informations, en effet, les bibliothèquesutilisées par l’éditeur de liens peuvent avoir été compilées avec cette option.

Les principales options destrip sont les suivantes :

Tableau 11-1. Options de strip


--help Affiche l’écran d’aide de strip.

--version Affiche le numéro de version de strip.

--strip-all Supprime toutes les informations de symboliques.

--strip-debug Supprime les infomations symboliques de déboguage.

--strip-unneeded Supprime toutes les informations symboliques, sauf celles nécessaires aurelogement des bibliothèques.

21

Chapitre 11. strip

22

Chapitre 12. WindresL’outil windres permet de compiler les fichiers ressources « .RC » de windows en fichiers objets,que l’éditeur de lien peut utiliser pour créer des exécutables ou des bibliothèques dynamiques. Lesprincipales options que ce programme acceptent sont décrites ci-dessous :

Tableau 12-1. Options de windres


--help Affiche l’écran d’aide de windres.

--version Donne le numéro de version de windres.

-i source ou--input-file

source

Nom du fichier .RC de ressource à compiler.

-o objet ou--output-file

objet

Nom du fichier objet à produire.

--include-dir

répertoire

Ajoute le répertoirerépertoire à la liste des répertoires pour les fichiersd’inclusion.

--define symbole Définit le symbolesymbole pour la compilation conditionnelle.

windres définit automatiquement l’identificateurRC_INVOKED, qui peut être utilisé dans la compila-tion conditionnelle des fichiers d’en-tête.

L’éditeur de liens n’accepte qu’un seul fichier objet pour les fichiers de ressources. Il faut donc placertoutes les ressources dans le même fichier de ressources.

23

Chapitre 12. Windres

24

Chapitre 13. dlltooldlltool est un outil utilisé pour la création de DLL windows et la création de bibliothèquesd’importation pour les DLL existantes. La plupart de ses options sont disponibles sous deux formes,une forme courte et une forme détaillée. Ces deux formes sont strictement équivalentes. Les optionsles plus utiles sont les suivantes :

Tableau 13-1. Options de dlltool


--help Affiche l’écran d’aide de dlltool.

-V ou --version Affiche le numéro de version de dlltool.

-e export ou--output-exp

export

Permet de générer un fichierexport contenant la table des symbolesexportés par la DLL. Ce fichier est utilisé par l’éditeur de liens lors de lacréation des DLL.

-l bibliothèque ou--output-lib

bibliothèque

Permet de générer une bibliothèque d’importationbibliothèque pourpermettre l’utilisation d’une bibliothèque dynamique.

-D nom ou--dll-name nom

Permet de donner le nom de la DLL pour les références à cette DLL dansles chemins stockés dans les fichiers générés.

-d def ou--input-def def

Permet de donner le nom du fichier .DEF à utiliser.

-z def ou--output-def def

Permet de donner le nom du fichier .DEF à générer.

--export-all-

symbols

Permet d’exporter tous les symboles d’un fichier objet dans le fichier.DEF généré.

-b base ou--base-file base

Permet de donner le nom du fichier d’informations à utiliser pour lerelogement des DLL relogeables.

La première utilisation dedlltool est de générer les bibliothèques d’importation pour les DLL exis-tantes. Pour cela, il faut disposer du fichier.DEF contenant la déclaration des symboles exportés parla DLL. Si l’on a développé cette DLL, ce fichier.DEF est disponible, sinon, il faut le générer. Pourcela, un petit utilitaire nomméimpdef peut être utilisé. Sa syntaxe est très simple :

impdef dll

où dll est le nom de la DLL à lire. Le fichier.DEF est affiché à l’écran, il suffit de rediriger la sortiede impdef pour obtenir ce fichier sur disque.

Une fois que le fichier.DEF créé, il suffit d’appelerdlltool avec la ligne de commande suivante :

dlltool --dllname dll --input-def def --output-lib bibliothèque

où dll est le nom de la DLL dont on veut faire une bibliothèque d’importation,def est le nom dufichier .DEF généré parimpdef, et bibliothèque est le nom de la bibliothèque d’importation àcréer.

La deuxième utilisation dedlltool est de générer le fichier.DEF pour une DLL en cours de déve-loppement.dlltool permet en effet de générer le fichier.DEF à partir des fichiers objets créés par le

25

Chapitre 13. dlltool

compilateur. Ces fichiers.DEF contiennent la déclaration des symboles exportés dans le fichier ob-jet. Cette fonctionnalité dedlltool est très pratique pour exporter des symboles C++, dont le nom estdécoré par le compilateur.

Pour que cette opération fonctionne correctement, il est nécessaire que les symboles qui doivent êtreexportés aient été déclarés avec l’attributdllexport dans le fichier source. Ceci se fait simplementà l’aide du mot-clé__attribute__ :

__attribute((dllexport))

Note : Les doubles parenthèses sont nécessaires.

La macro __declspec est également utilisable, elle est définie pour la portabilité avec le mot-clefdu même nom dans Visual C++.

Une fois le fichier compilé, il suffit d’appelerdlltool avec la syntaxe suivante :

dlltool objet --output-def def

où objet représente le fichier objet contenant la définition des symboles exportés, etdef le nom dufichier .DEF à générer.

Note : Notez que d’une manière générale, si les fonctions à exporter sont définies dans plusieursfichiers objets, il faudra générer plusieurs fichiers .DEF et les fusionner.

La troisième et plus importante utilisation dedlltool est la création de la table des symboles exportés,que le linker utilise pour créer la DLL. Cette opération nécessite le fichier.DEF contenant la liste dessymboles exportés par la DLL, et éventuellement le fichier d’information généré par le linker pour lerelogement de la DLL (il est impératif de faire des DLL relogeables, faute de quoi on s’expose à degraves problèmes lors de l’initialisation des programmes qui les utilisent).

La syntaxe à utiliser est la suivante :

dlltool --dllname dll --base-file base --output-exp exp --input-def def

où dll est le nom de la DLL (utilisé dans le fichier d’exportation),base est le nom du fichierd’information de relogement généré par le linker,exp est le nom du fichier d’exportation à créeret def est le nom du fichier d’importation.DEF .

Le fichier d’exportation ainsi créé doit alors être passé directement, comme un fichier objet normal,dans la ligne de commande du linker pour être lié avec le code objet de la DLL.

Note : Normalement, les fonctions exportées par les DLL suivent la convention d’appel STDCALL

de Windows, qui est en fait la convention d’appel standard du Pascal. Cependant, il n’est pasnécessaire d’utiliser ces conventions, sauf si l’on veut utiliser la DLL avec un autre compilateur.

Par ailleurs, la convention de nommage classique des fonctions exportées est le nom de la fonc-tion, sans ’_’ en préfixe, et avec le suffixe « @n», où n est le nombre d’octets passés sur la pile.Certaines DLL emploient une convention de nommage différente, où seul le nom de la fonctionest utilisé. Les fichiers .DEF générés par l’utilitaire impdef pour ces DLL contiennent donc tou-jours le nom exact des fonctions exportées dans la DLL passée en paramètre, c’est à dire avec« @n» ou sans selon le type de DLL.

26


Le problème est que le compilateur utilise toujours le nom décoré de « @n» d’une fonction dès lorsqu’elle est déclarée avec STDCALLou PASCAL. La bibliothèque d’importation générée par dlltoolà partir de ce fichier .DEF ne permet donc pas de résoudre les symboles lors de l’édition de liensdes programmes avec cette bibliothèque.

Ce problème peut être résolu en rajoutant les « @n» manquant aux noms de fonctions du fichier.DEF généré par impdef . La bibliothèque d’importation créée par dlltool résoudra alors tousles symboles de la DLL lors de l’édition de liens du programme qui l’utilise. Cependant, cettetechnique provoque une erreur à l’exécution, parce que cette fois, les symboles appelés par lesfonctions d’importation de la bibliothèque statique d’importation utiliseront les symboles « @n»pour appeler les fonctions de la DLL, or ces fonctions n’ont pas ces symboles dans leurs noms...C’est pour résoudre ce deuxième problème que dlltool dispose de l’option -k , qui permet desupprimer les symboles « @n» du nom des fonctions dans la bibliothèque statique d’importation,mais de les conserver pour les noms des fonctions d’importations en interne. Ainsi, la bibliothèqued’importation est liée correctement au programme qui utilise la DLL, et les symboles de la DLLsont correctement résolus à l’exécution.

Un autre problème peut se poser lorsque l’on cherche à réaliser une DLL dont les fonctionsexportées n’ont pas les symboles « @n», car les noms des fonctions générées par le compilateuront toujours ces symboles. La solution consiste cette fois à exporter les fonctions des DLL sousun autre nom. Pour cela, il faut spécifier les noms sous lesquels les fonctions seront exportéesdans le fichier .DEF , et indiquer leurs noms réels à l’aide de la syntaxe suivante :

EXPORTSexport=nom@n

où export est le nom sous lequel la fonction de la DLL doit être exportée, et nom@nest le nomréel de la fonction dans le code objet de la DLL (c’est à dire le nom utilisé par le compilateur).Ceci peut se faire simplement en éditant le fichier .DEF généré par dlltool à partir du fichierobjet contenant les fonctions à exporter, pour rajouter la définition des alias pour l’exportation.L’option -A de dlltool permet de faire en sorte que dlltool génère automatiquement ces aliaslors de la création des fichiers de définition à partir des fichiers objets. La DLL ainsi généréeexportera chacune des fonctions sous les deux noms, avec et sans les symboles « @n». L’option-k fonctionne toujours lors de la création de la bibliothèque d’importation, elle permet de n’utiliserque les noms sans ces symboles.

27


28

Chapitre 14. Le débogueurgdb est un débogueur complet permettant de travailler au niveau langage machine et au niveau source,pour les langages C et C++. Pour qu’un programme puisse être débogué avecgdb, il faut que sonfichier exécutable contienne des informations symboliques de déboguage. Ces informations peuventêtre générées si l’option-g est passée au compilateur et si ces informations n’ont pas été retirées del’exécutable généré par l’éditeur de lien à l’aide du programmestrip .

14.1. Chargement d’un programmeLe chargement d’un programme au lancement degdb se fait simplement en passant le nom du pro-gramme en ligne de commande :

gdb programme

Lorsquegdb se lance, le programme est chargé en mémoire mais n’est pas lancé.

Le chargement d’un fichier core peut être réalisé en précisant le nom du fichier core à la suite du nomdu programme. Les informations symboliques de déboguage seront lues à partir du fichier exécutable :

gdb programme core

SPÉCIFIQUE DOS : Les fichiers core n’existent pas sous DOS.

SPÉCIFIQUE WIN32 : Il est possible de générer des fichiers core sous Windows NT, 2000 ou XPà l’aide de l’outil Dr. Watson. Cependant, gdb ne sait pas lire ces fichiers. Pour cela, vous devrezutiliser le débogueur WinDBG, fourni en standard avec le Platform SDK de Windows.

Pour s’attacher à un programme, il est nécessaire de connaître son PID. La ligne de commande sui-vante peut alors être utilisée :

gdb programme PID

Il est également possible de charger un programme une foisgdb démarré. Pour cela, on utilisera lacommande suivante :

file exécutable

De même, l’attachement à un processus depuisgdb se fait à l’aide de la commande suivante :

attach PID

29

Chapitre 14. Le débogueur

Il est nécessaire d’utiliser la commandefile pour charger le fichier exécutable avant de s’attacher à unprocessus, faute de quoi les informations symboliques de déboguage ne seront pas disponibles. Enfin,pour se détacher d’un programme, il suffit de taperdetach.

La lecture d’un fichier core depuisgdb peut être réalisée avec la commande suivante :

core-file <core >

Comme pour l’attachement, cette commande suppose que le fichier exécutable ait été chargé au préa-lable avec la commandefile.

Note : Si l’exécutable et les informations symboliques de déboguage ne sont pas dans le mêmefichier, il est possible d’utiliser les commandes suivantes pour spécifier ces fichiers indépendam-ment l’un de l’autre :

exec_file exécutablesymbol_file symboles

14.2. Commandes fondamentalesUne foisgdb démarré, il est possible de lancer l’exécution du programme à l’aide de la commanderun paramètres, où paramètres représente les options en ligne de commande du programme. Laligne de commande peut être lue à tout moment à l’aide de la commandeshow args. Pour terminer unprogramme en cours d’exécution, il faut utiliser la commandekill . Pour quittergdb, il suffit de taperquit .

gdb dispose d’un grand nombre de commandes, que l’on saisie interactivement en fonction de l’étatdu programme en cours de déboguage. Cependant, il est également possible de programmer gdb avecun fichier de commande, qui lui sera passé en paramètre au lancement à l’aide de la syntaxe suivante :

gdb -command fichier

14.3. Les points d’arrêtLa commanderun citée ci-dessus lance l’exécution du programme inconditionnellement. Si le pro-gramme ne génère pas d’erreur, il se terminera normalement. Il faut donc utiliser les commandes depoint d’arrêts pour stopper l’exécution du programme afin d’examiner son état.gdb gère un grandnombre de types de points d’arrêt et permet de contrôler finement leur fonctionnement.

Pour placer un point d’arrêt dans le programme, il faut utiliser la commandebreak. Cette commandepermet de poser tout type de point d’arrêt, les formes les plus utiles de cette commande sont donnéesci-dessous :

Commande Signification

30



break fonction Pose un point d’arrêt à l’entrée de la fonctionfonction du fichiercourant.

break fichier:fonction Pose un point d’arrêt sur la fonctionfonction du fichierfichier .

break <+offset> oubreak <-offset>

Pose un point d’arrêt à la position courante plus l’offset précisé enparamètre. Cet offset est exprimé en nombre de lignes.

break <ligne> Pose un point d’arrêt à la ligneligne du fichier courant.

break <fichier:ligne> Pose un point d’arrêt à la ligneligne du fichierfichier .

break <*adresse> Pose un point d’arrêt à l’adresse spécifiée en langage machine.

break Pose un point d’arrêt à l’instruction suivante de celle en coursd’exécution. Si l’on se trouve dans un appel de fonction, il est possible dechanger le contexte d’appel pour celui de la fonction appelante (voir plusloin pour plus de détails à ce sujet). Dans ce cas, l’instruction suivante seral’instruction qui suit l’appel de cette fonction. La commandebreak permetdonc de placer un point d’arrêt au retour de la fonction en coursd’exécution.

Toutes ces commandes peuvent prendre une condition en paramètre. Cette condition est expriméeà l’aide d’une expression utilisant le langage du programme. Cette condition est évaluée à chaquepassage sur le point d’arrêt, et le programme n’est stoppé que si elle est vérifiée. La syntaxe pourposer une condition sur le point d’arrêt est la suivante :

break paramètres if condition

où paramètres représente les paramètres de la commandebreak sans condition, etcondition estl’expression permettant d’évaluer la condition.

Tous les points d’arrêt se voient attribué un numéro pargdb. Il est possible d’utiliser la commandesuivante :

info breakpoints [n]

pour obtenir des informations sur le point d’arrêtn. Si le numéro du point d’arrêt n’est pas indiqué,gdb affiche ces informations pour tous les points d’arrêt existants.

Il est possible de changer la condition sur un point d’arrêt à l’aide de la commandecondition. Lasyntaxe de cette commande est donnée ci-dessous :

condition n condition

où n est le numéro du point d’arrêt, etcondition la nouvelle condition à utiliser. Si cette nouvellecondition est vide, le point d’arrêt redevient un point d’arrêt non conditionnel.

Pour supprimer un point d’arrêt, il suffit d’utiliser la commandeclear. Cette commande fonctionneavec la même syntaxe que la commandebreak correspondante. Les principales formes de la com-mandeclear sont données ci-dessous :

clear <fonction >

clear <fichier:fonction >

clear <ligne >

clear <fichier:ligne >

clear

31


Cette dernière forme declear supprime le point d’arrêt de l’instruction suivante. Comme pour lacommandebreak, cette commande agit sur le contexte d’appel en vigueur au moment où elle estutilisée. La commandedeleteest également disponible, elle permet de supprimer des points d’arrêten spécifiant leur numéro :

delete n...

Si aucun argument n’est donné à la commandedelete, elle supprime tous les points d’arrêt existants.

Pour désactiver un point d’arrêt sans le supprimer, il suffit d’utiliser la commandedisable. La syntaxede cette commande est donnée ci-dessous :

disable n

où n est le numéro du point d’arrêt à désactiver. Si aucun numéro n’est passé en paramètre, la com-mandedisabledésactive tous les points d’arrêt existants.

La commandeenablepermet de réactiver ces points d’arrêt. Il est possible d’activer un point d’arrêtde plusieurs manières différentes. Les différentes formes de cette commande sont données ci-dessous :


enable liste Active les points d’arrêt de la liste de points d’arrêtliste .

enable once liste Active les points d’arrêt spécifiés pour un seul passage uniquement.Lorsque ces points d’arrêt seront atteints, ils seront automatiquementdésactivés.

enable delete liste Active les points d’arrêt spécifiés. Lorsque ces points d’arrêt serontatteints, ils seront automatiquement détruits.

Dans toutes ces commandes,liste est la liste des numéros des points d’arrêt à activer. Si aucunnuméro n’est spécifié, la commande s’appliquera à tous les points d’arrêt existants.

Il est possible de spécifier une condition sur le compteur de passage d’un point d’arrêt. À chaquefois que ce point d’arrêt sera rencontré, le compteur de passage sera incrémenté. Le point d’arrêt nedevient valide que lorsque la limite sur le nombre de passage est atteinte. Cette limite peut être fixéeà l’aide de la commande suivantes :

ignore n compte

où n est le numéro du point d’arrêt etcompte est le nombre de passages qui doivent se faire avantque le point d’arrêt ne soit activé.

gdb permet de définir une série de commande à effectuer pour un point d’arrêt lorsque celui-ci estatteint (et si la condition qu’il contient est vérifiée). Cette série de commande peut être spécifiée àl’aide de la syntaxe suivante :

commands nc1c2

...cnend

32


oùn représente le numéro du point d’arrêt, etc1 , c2 , etc... les commandes à exécuter. Pour supprimerune série de commande d’un point d’arrêt, il suffit de spécifier une série de commande vide.

14.4. Contrôle de l’exécutionComme on l’a vu ci-dessous, la commanderun lance l’exécution du programme. On ne peut utiliserla commanderun qu’une fois pour une instance donnée du programme, si on l’utilise une deuxièmefois, le programme est redémarré. Il existe donc d’autres commandes, qui permettent de relancerl’exécution du programme si celle-ci s’est arrêtée.

Un programme peut être arrêté pour trois raisons : soit parce qu’il s’est terminé, soit parce qu’il aatteint un point d’arrêt et que la condition de celui-ci est vérifiée, soit parce qu’il a reçu un signal dusystème. Dans le premier cas, il faut utiliser à nouveau la commanderun pour relancer une nouvelleinstance de ce programme. Le programme est rechargé exactement au même endroit en mémoire, sibien que les adresses des points d’arrêts sont toujours valides. Dans les deux autres cas, il faut relancerl’exécution. Ceci peut être fait à l’aide d’une des commandes décrites ci-dessous.

La commandecontinuepermet de relancer l’exécution du programme jusqu’à ce qu’il soit à nouveauarrêté. La commandecontinue peut prendre en paramètre un nombre entier si le programme vientjuste d’être interrompu par un point d’arrêt :

continue n

Ce nombren indique la valeur du compteur à utiliser pour activer ce point d’arrêt. Ainsi, le programmene sera à nouveau stoppé par ce point d’arrêt que si l’exécution passen fois dessus.

La commandesteppermet d’exécuter une instruction du programme. La notion d’instruction ici estcelle du langage du fichier source où le pointeur d’instruction se trouve. Si l’on veut exécuter uneinstruction du langage machine, il faut utiliser la commandestepi, ousi en abrégé. Si l’instruction àexécuter est un appel de fonction, l’exécution se poursuit à l’intérieur de cette fonction.

Les commandesnext et nexti sont similaires àstepet stepi, à ceci près qu’elles n’entrent pas dansles fonctions lorsqu’elles sont utilisées pour exécuter un appel de fonction.

La commandefinish permet de sortir de la fonction courante, et de s’arrêter avant l’instruction qui suitson appel. Le reste du code de la fonction s’exécute normalement. Si l’on veut sortir immédiatementde la fonction (sans exécuter le code restant jusqu’à la prochaine instruction de retour de fonction), ilfaut utiliser la commande suivante :

return expression

où expression une expression permettant d’évaluer l’éventuelle valeur de retour de la fonction.

La commandeuntil permet de reprendre l’exécution du programme jusqu’à ce qu’il atteigne un pointdu code placé après l’endroit où se trouve le compteur d’instruction. La syntaxe de cette commandeest la même que celle de la commandebreak. L’exécution du programme est automatiquement arrêtéepar la commandeuntil si la fonction courante se termine.

Si l’on veut placer le compteur d’instruction en un endroit donné, sans relancer le programme, il faututiliser la commandejump . La syntaxe de cette commande est la même que celle de la commandebreak.

Enfin, si le programme a été arrêté par la réception d’un signal, la reprise de l’exécution de ce pro-gramme se fait en général par le traitement du signal par le programme. Il est cependant possibled’envoyer un autre signal au programme que celui qu’il a reçu, grâce à la commandesignal :

33


signal n

où n est le numéro du signal à envoyer. Si ce numéro est0, le programme reprend son exécutioncomme s’il n’avait pas reçu de signal.

14.5. Les chiens de gardeEn plus des points d’arrêt,gdb gère la notion de chien de garde. Les chiens de garde permettentd’arrêter l’exécution d’un programme dès qu’une condition est vérifiée. À la différence des pointsd’arrêts, cette condition est évaluée à chaque instruction du programme et non à l’arrivée sur le pointd’arrêt qui définit la condition. Les chiens de garde permettent donc de faire une condition d’arrêtglobale sur tout le programme. Il va de soi que les chiens de garde ralentissent l’exécution d’unprogramme (sauf s’ils sont gérés par un dispositif matériel quelconque), car leur condition doit êtreévaluée à chaque instruction du programme.

Il existe plusieurs formes de chiens de garde. La forme la plus générale permet d’évaluer une expres-sion à chaque instruction et de stopper l’exécution du programme si cette expression change de valeur.Ceci permet de vérifier la validité d’un invariant dans un programme ou de localiser les instructionsqui modifient certaines variables. La syntaxe pour ce type de points d’arrêts est donnée ci-dessous :

watch expression

La deuxième forme de chien de garde permet de stopper l’exécution du programme lorsqu’une donnéeest lue (mais pas forcément modifiée). La syntaxe est donnée ci-dessous :

rwatch variable

Enfin, la troisième et dernière forme permet de stopper l’exécution dès qu’une variable est accédée,que ce soit en lecture ou en écriture. La syntaxe est donnée ci-dessous :

awatch variable

Ces deux derniers types de chiens de garde ne sont disponibles que sur les plates-formes capables degérer les points d’arrêt matériel. Ceci implique qu’un nombre limité seulement de tels points d’arrêtpeut être créé. En revanche, les chiens de garde créés à l’aide de la commandewatch sont toujoursgérés, car ils ne nécessitent aucun support matériel particulier.

SPÉCIFIQUE WIN32 : Bien que les processeurs ix86 puissent gérer les points d’arrêt et leschiens de garde au niveau matériel, la version Win32 actuelle de gdb n’est pas capable d’utiliserces fonctionnalités sous Windows. Il n’est donc possible de créer des chiens de garde qu’avec lacommande watch .

Tous les chiens de garde sont traités comme des points d’arrêt pargdb. Des numéros de points d’arrêtleurs sont donc affectés, et les commandes permettant de supprimer, d’activer et de désactiver lespoints d’arrêt sont utilisables sur les chiens de garde. En particulier, il est possible d’obtenir desinformations sur les chiens de garde grâce à l’instructioninfo watchpoints.

34


14.6. Examen et modification des donnéesIl est possible d’examiner la valeur de toute expression exprimée dans le langage du fichier source.L’expression est évaluée dans le contexte du programme en cours de déboguage, ce qui impliqueque si elle dispose d’effets de bords, l’état du programme est modifié. La commande pour afficher lerésultat d’une expression estprint , elle s’utilise de la manière suivante :

print [/format] expression

Le paramètre/format est facultatif. Il permet de spécifier le type avec lequel l’expression doit êtreaffichée. Si ce type est indiqué,format peut prendre l’une des valeurs suivantes :

Valeur Signification

x Entier en héxadécimal.

d Entier signé.

u Entier non signé.

o Entier en octal.

t Entier en binaire.

a Adresse.

c Caractère.

f Flottant.

La commandecall permet d’évaluer l’expression sans afficher le résultat. Elle peut être utilisée pourévaluer les expressions qui ne renvoient pas de valeur, et éviter ainsi l’affichage devoid . Sa syntaxeest la même que celle deprint .

gdb peut afficher le résultat d’une expression à chaque arrêt du programme. Ceci permet de tracerl’évolution de la valeur de cette expression au fur et à mesure de l’exécution du programme. Pourtracer une expression, il faut utiliser la commandedisplay à la place de la commandeprint . Pourchaque expression tracée,gdb affecte un numéro automatique. La commandeinfo permet d’afficherla liste des expressions tracées :

info display

Comme pour les points d’arrêt, il est possible d’activer et de désactiver la trace d’une expression àl’aide des commandes suivantes :

enable display ndisable display n

où n est le numéro de la trace.

Pour supprimer la trace automatique d’une variable, il faut utiliser l’une des commandes suivantes :

undisplay ndelete display n

Il est possible d’examiner la mémoire du programme avec la commande suivante :

35


x [[/NFT] adresse]

oùadresse est l’adresse de la zone de mémoire à afficher, etNFTpermet de spécifier respectivementle nombre d’objets à afficher (paramètreN), le format avec lequel ces objets doivent être affichés(paramètreF), et la taille de ces objets (paramètreT). Les formats disponibles sont les mêmes queles formats de la commandeprint . La taille des objets affichés est spécifiée par l’une des valeurssuivantes :

Format Signification

b Taille d’un octet.

h Taille d’un demi-mot, soit deux octets.

w Taille d’un mot mémoire, soit quatre octets.

g Taille d’un double mot, soit huit octets.

Il est possible d’utiliser deux autres formats avec la commandex, qui ne sont pas disponibles avec lacommandeprint . Ces formats sont donnés ci-dessous :

Format Signification

i Instruction langage machine.

s Chaîne de caractère terminée par un caractère nul.

Pour ces deux formats, on ne peut pas spécifier la taille des objets, car elle est variable et déterminéeautomatiquement pargdb.

Le paramètre/NFT est facultatif, s’il n’est pas précisé, les mêmes options sont reprises pour la com-mandex suivante. De même, le paramètreadresse est facultatif, s’il n’est pas précisé, la commandex affiche l’objet suivant avec le même format et en supposant qu’il a la même taille que celle utiliséepour la dernière commande.

Les registres du microprocesseur peuvent être examinés à l’aide de la commandeinfo registers. Lesregistres flottants ne sont pas affichés par cette commande. Si l’on veut consulter leur valeur, il faututiliser la commandeinfo all-registers. Il est également possible de consulter la valeur de quelquesregistres indépendamment les uns des autres à l’aide de la syntaxe suivante :

info registers registres

où registres est la liste des registres à consulter. Les valeurs des registres sont affichées dansle contexte d’exécution sélectionné. Ceci signifie que les valeurs affichées sont celles qui seraientstockées dans les registres si l’on se trouvait dans la fonction en cours ou dans l’une des fonctionsappelantes, selon le contexte d’exécution sélectionné. Voir plus loin pour plus de détails à ce sujet.

gdb définit quatre noms standards pour les registres les plus classiques. Ces noms peuvent être utiliséspour référencer ces registres indépendamment de la plate-forme. Il s’agit du registrepc pour le poin-teur d’instruction, du registresp pour le pointeur de pile, du registrefp pour le pointeur de structurede pile et du registreps pour le registre d’état du processeur.

La modification des données se fait simplement par l’évaluation d’une expression contenant une af-fectation. Il est également possible d’utiliser la commandeset:

set [variable] variable=valeur

36


où variable est la variable à modifier etvaleur est sa valeur. Par défaut, il n’est pas nécessaired’utiliser le mot-clévariable , mais comme la commandeset peut être utilisée pour fixer les va-riables d’environnement, il est préférable de le faire.

La commandesetdoit être utilisée si l’on veut modifier la valeur d’un registre du processeur. Le nomde la variable à utiliser est alors le nom du registre, précédé d’un dollar :

set $registre=valeur

où registre est l’un des noms de registres affiché par la commandeinfo all-registers.

14.7. Examen du contexte d’exécutionLe contexte d’exécution est sauvegardé lors de chaque appel de fonction. Classiquement, ceci se faitpar stockage dans la pile de certains registres du processeur. En particulier, le registre de sélection destructure de pile est le registre qui sert d’adresse de base pour accéder à toutes les variables locales.

gdb permet de consulter la liste des appelants de la fonction en cours pour déterminer le contexted’exécution qui a permis d’arriver aux points d’arrêts. Il permet également de choisir un contexted’exécution donné, c’est à dire de remonter dans la pile des appels, afin de permettre la manipulationdes variables locales d’une des fonctions appelantes de la fonction en cours. Les contextes d’exécutionsont numérotés par gdb dans l’ordre inverse des appels. Normalement, le contexte d’exécution esttoujours celui de la fonction en cours d’exécution, c’est à dire le contexte 0. Le contexte de la fonctionappelante est le contexte 1, et ainsi de suite.

Pour changer ce contexte, il faut utiliser la commande suivante :

frame n

où n est le numéro du contexte désiré. La commandeframe affiche le contexte d’exécution atteint àchaque changement. Pour changer de contexte sans avoir cet affichage, il faut utiliser la commandeselect-frameà la place de la commandeframe. Il est possible de déterminer le contexte courant àl’aide de la commandeframe sans arguments. Une description plus détaillée est disponible avec lacommandeinfo frame.

Les commandesup et down permettent de remonter et de redescendre dans la pile d’appel d’uncertain nombre de contextes d’exécution. Leur syntaxe est donnée ci-dessous :

up ndown n

où n est le nombre de contextes d’exécution dont on veut se déplacer. Comme pour frame, les com-mandesup etdown affichent le contexte d’exécution atteint à chaque fois. Pour se déplacer sans avoircet affichage, il faut utiliser les commandesup-silently etdown-silently.

Pour visualiser le contexte d’exécution après un point d’arrêt, il faut utiliser la commandebacktrace(bt en abrégé). Cette commande peut prendre un paramètre :

backtrace n

oùn est un entier. Sin est positif, les n contextes d’exécutions précédents sont affichés. S’il est négatif,ce sont les n premiers contextes d’exécution qui sont affichés.

À tout moment, gdb peut afficher les arguments, les variables locales et les gestionnairesd’exceptions C++ disponibles pour le contexte d’exécution sélectionné. Ceci se fait à l’aide descommandes suivantes :

37



info args Affiche les arguments.

info locals Affiche les variables locales.

info catch Affiche les gestionnaires d’exceptions actifs.

Note : Le contexte d’exécution influe sur le résultat des commandes d’affichage des valeurs deregistres et sur l’effet de la commande break .

14.8. Gestion des threadsgdb prend en charge les programmes multithreadés pour les plates-formes qui disposent de cette fonc-tionnalité. À chaque fois qu’un processus est stoppé, tous ses threads sont gelés. De même, lorsquele processus est relancé, tous les threads sont relancés. Il n’est donc pas possible de « geler » certainsthreads et de laisser les autres s’exécuter, car l’exécution des threads est du ressort du scheduler dusystème sous-jacent.

SPÉCIFIQUE LINUX : Le débogage des threads sous Linux nécessite la version 4.18 oupostérieure de gdb . D’autre part, gdb récupère des paramètres de linuxthreads en lisant dansla mémoire de celui-ci lorsque le programme à déboguer est chargé. Par conséquent, il estnécessaire (et recommandé de toutes manières) que la libraire C du système soit compilée avecles informations symboliques de débogage.

Lorsque l’on manipule un programme stoppé, le contexte d’exécution courant est celui du thread quia provoqué l’arrêt du programme. Ceci signifie que les variables locales accessibles sont celles quise trouvent sur la pile de ce thread, et que les registres du processeur ont pour valeurs celles qui sontassociées à ce thread. Ce thread spécial se nomme le « thread courant ».

Bien entendu, il est possible de changer de thread courant, à l’aide de la commandethread :

thread n

où n est le numéro quegdb a assigné à ce thread. Ce numéro n’est pas forcément l’identifiant utilisépar le système pour ce thread.gdb utilise en effet sa propre numérotation. Vous pourrez obtenir laliste des threads du processus à l’aide de la commande suivante :

info threads

gdb permet également de spécifier les threads pour lequels les points d’arrêts et les chiens de gardesont valides. Par défaut, ceux-ci sont actifs pour tous les threads du processus, mais il est possible dene définir un point d’arrêt que pour un thread donné. Ceci se fait avec le mot-cléthread à la suite dela définition du point d’arrêt (et avant la condition de ce point d’arrêt si elle existe) :

break ligne thread nbreak ligne thread n condition

38


oùn est le numéro du thread pour lequel ce point d’arrêt est défini. Les paramètresligne etcondi-

tion spécifient l’emplacement du point d’arrêt et la condition d’activation, comme pour la commandebreak générale.

Note : Les chiens de garde gérés au niveau hardware ne peuvent pas, actuellement, être util-isés dans un programme multithreadé. En particulier, sur les plates-formes qui gèrent les chiensde garde avec un support matériel (dont les plates-formes x86, sauf Windows) utilisent systé-matiquement des chiens de garde matériels s’il reste des registres de déboguage dans le pro-cesseur.

14.9. Gestion des fichiers sourcesLa commandelist permet d’afficher les lignes du fichier source correspondantes à l’endroit oùl’exécution du programme s’est arrêté. Par défaut, la commandelist affiche dix lignes, centréesautour de l’instruction en cours. Il est également possible d’afficher dix lignes centrées autour d’unsymbole, avec la syntaxe suivante :

list symbole

La manière de spécifier le symbolesymbole est la même que pour la commandebreak. Si l’on répètela commandelist, les dix lignes suivantes sont affichées. La commandelist - permet d’afficher les dixlignes précédentes.

Le nombre de lignes affichées par la commandelist peut être fixé à l’aide de la commande suivante :

set listsize n

Enfin,gdb peut afficher une partie du fichier source, à l’aide de la syntaxe suivante :

list [début],fin | début,[fin]

où début et fin sont les spécifications des lignes du début et de la fin de la zone à lister.

14.10. Spécification du langagegdb utilise le langage correspondant à l’extension du fichier source correspondant aux informationssymboliques de déboguage dont il dispose. Ceci implique qu’il comprend automatiquement les ex-pressions et la syntaxe de ce langage.

Cependant, si le programme a été compilé par un front-end qui a traduit le code source d’un langageen un autre langage,gdb peut se tromper de langage. Les commandes suivantes pourront être utiles :


show language Affiche le langage courant.

set language langage Fixe le langage manuellement.

39


Dans la dernière commande, les valeurs acceptées pourlangage sont c , c++ , modula-2 , asm etlocal . Cette dernière option permet de demander àgdb de détecter automatiquement le langage enfonction de l’extension du fichier source.gdb ne gère nativement que les langages C, C++ et Modula2.

14.11. Complétion des commandesIl est inutile de taper les commandes entièrement dansgdb. En effet, celui-ci utilise un mécanisme decomplétion pour toutes les commandes et pour les symboles du programme, s’il n’y a pas d’ambiguïté.Pour l’utiliser, il suffit de taper le début de la commande et d’appuyer sur la touche de tabulation. Lacommande sera alors complétée, sauf s’il y a ambiguïté. Dans ce cas,gdb émettra un bip, et attendrala suite de la saisie. Pour voir la liste des commandes ambiguës, il suffit d’appuyer à nouveau sur latouche de tabulation.gdb recopie automatiquement la saisie après avoir affiché la liste des commandescorrespondantes afin de permettre la suite de la saisie. Ce mécanisme de complétion est égalementvalable avec les symboles du programme.

Il est souvent inutile d’utiliser la complétion des commandes, parce que la plupart des commandespeuvent être utilisées même lorsqu’elles sont partiellement saisies. En fait, certaines commandes par-tiellement saisies peuvent être ambiguës, dans ce cas, c’est la commande la plus couramment utiliséequi est exécutée.

Enfin, la touche Entrée permet en général de répéter la commande précédente, sauf pour certainescommandes pour lesquelles ce comportement serait très gênant.

40

Chapitre 15. Le profilerLe compilateur C/C++ GNU peut, lors de la compilation, inclure du code additionnel pour chacunedes fonctions afin de tracer le temps que le processeur passe dans celles-ci. Le programme est ainsiinstrumenté, ce qui signifie que les résultats obtenus par cette méthode de mesure changent les tempsd’exécution réels. Cependant, le code additionnel généré par le compilateur n’influe pas trop pour lesfonctions les plus lentes. On peut ainsi déterminer relativement facilement les parties du programmequi doivent être optimisées.

Afin de générer les données de profiling, il faut compiler chacun des fichiers à analyser avec l’option-pg . L’édition de lien doit également se faire avec l’option-pg si l’on utilise GCC. Cette option serten fait à préciser un fichier de démarrage différent à l’éditeur de lien, fichier qui permet l’initialisationdu code de profiling et l’écriture des résultats lors de la terminaison du programme.

Comme l’écriture des résultats est réalisée dans le code de terminaison normale du programme, il estnécessaire que celui-ci se termine correctement. Il faut donc qu’il appelle la fonctionexit ou qu’ilfasse unreturn dans la fonction principale. S’il se termine en raison d’un signal ou d’une exception,aucune donnée ne sera écrite sur disque.

Une fois le programme compilé, il suffit de l’exécuter. Il va de soi que les résultats dépendront destâches effectuées par le programme : ils varieront selon les fonctions appelées et selon les paramètresfournis. On notera qu’une même fonction peut s’exécuter plus ou moins rapidement selon les para-mètres qu’elle reçoit. La méthode de profiling utilisée ici est globale, on ne pourra donc obtenir quedes résultats moyens, sauf si l’on répète plusieurs fois le même cas de test.

Lorsque le programme se termine, il génère un fichier de données nommégmon.out . Si un fichierde même nom existe, il est écrasé. Il n’est pas possible de spécifier un autre nom pour ce fichier. Enrevanche, il est toujours possible de le renommer et de l’utiliser sous ce nouveau nom par la suite. Cefichier est écrit dans le répertoire courant du programme au moment où il s’est terminé.

Pour analyser ces résultats, il faut utiliser le programmegprof. La ligne de commande de ce pro-gramme est donnée ci-dessous :

gprof option [exécutable [données]]

Parmi les options, on trouvera celles-ci (liste non exhaustive) :

Tableau 15-1. Options du profiler


--help Affiche l’écran d’aide de gprof.

--version Affiche le numéro de version de gprof.

-b Supprime les commentaires expliquant la signification des données.

-s Consolide les résultats passés en paramètres avec des résultats existants.Le résultat de la consolidation est écrit dans un fichier nommégmon.sum .Si ce fichier existe déjà, les résultats sont consolidés avec ceux déjàprésent dans ce fichier. Cette option permet de regrouper des statistiquessur plusieurs cas de test.

À part pour les deux premières options, le nom de l’exécutable doit être fourni en paramètre àgprof.Si aucun exécutable n’est donné,a.out est utilisé par défaut. Cet exécutable est requis parce que

41

Chapitre 15. Le profiler

gprof utilise les informations symboliques de déboguage pour interpréter les données.

Un ou plusieurs fichiers de données peuvent être passés en paramètre. Ces fichiers sont les différentsfichiersgmon.out générés par l’exécutable (éventuellement renommés). Si aucun fichier n’est passéen paramètre, le fichiergmon.out est utilisé par défaut.

SPÉCIFIQUE DOS : Le profiler ne fonctionne pas très bien sous DOS.

42

Chapitre 16. L’analyseur de couvertureL’analyseur de couverturegcov utilise, comme le profiler, une instrumentation du code. Il permetde déterminer le nombre de fois que chaque branche du programme a été exécutée. Il génère unfichier de donnée pour chaque fichier source. Ces fichiers sont nommés comme les fichiers sources,et l’extension « .gcov » leur est ajoutée.

Pour pouvoir utiliser l’analyseur de couverture, il faut avoir compilé le programme avec les options-fprofile-arcs et -ftest-coverage . Il faut ensuite exécuter le programme. Celui-ci écrira alorsdes fichiers de données lorsqu’il se terminera. Comme pour le profiler, les résultats dépendront des ac-tions effectuées par le programme. Les résultats sont automatiquement cumulés par le code d’analysede couverture dans les fichiers de données, ce qui permet de calculer le taux de couverture d’unesérie de cas de tests. Si l’on veut remettre à zéro le décompte de passage pour chaque branche, il fautsupprimer les multiples fichiers de données générés après l’exécution du programme.

Les résultats de ces fichiers de données peuvent être interprétés grâce au programmegcov. Ce pro-gramme prend en paramètre le nom d’un fichier source et génère un fichier du même nom et portantl’extension .gcov. Ce fichier contient les statistiques de couverture pour ce fichier source.

SPÉCIFIQUE DOS : L’analyseur de couverture n’est pas disponible dans la version actuelle deGCC pour DOS (impossibilité d’avoir plus d’une extension dans un nom de fichier).

43

Chapitre 16. L’analyseur de couverture

44

Chapitre 17. Programmation de composantsCOM en C++

Les interfaces de programmation COM ont été définies par Microsoft au niveau binaire. Une interfaceCOM est en réalité un pointeur sur un tableau de pointeurs fonctions, qui prennent toutes en premierparamètre le pointeur sur le premier pointeur. Cette structure est exactement la structure qu’utilise lecompilateur Visual C++ pour les classes C++ qui disposent de fonctions virtuelles. Les instances deces classes contiennent en effet un pointeur sur la table des fonctions virtuelles, fonctions qui elles-mêmes prennent en premier paramètre un pointeur sur l’objetthis (donc l’adresse du pointeur sur latable de fonctions virtuelles). De ce fait, il est très facile de définir une interface en C++ avec VisualC++ : il suffit de définir une classe abstraite, dont les méthodes virtuelles pures sont les méthodes del’interface.

Pour des raisons de portabilité entre les différentes plates-formes sur lesquelles il est supposé fonction-ner, GCC n’utilise pas cette structure pour les tables de fonctions virtuelles (il utilise un mécanismeun peu plus complexe en fait). Par conséquent, il n’est pas possible de définir des interfaces COMsimplement en définissant une classe abstraite.

Cependant, étant donné l’importance des composants COM dans le monde Windows, une extensiona été ajoutée à la version Windows de GCC pour permettre la définition des interfaces en C++. Cetteextension indique au compilateur qu’il doit utiliser le même mécanisme que Visual C++ pour gérerles fonctions virtuelles d’une classe. Cependant, cette extension n’est activée que classe par classe.

Les classes qui doivent utiliser ce mécanisme doivent être déclarées avec la syntaxe suivante :

struct __attribute__((com_interface)) structure{

...};

où structure est le nom de l’interface.

L’attribut qui est ainsi spécifié doit être placé entre le mot clefstruct et le nom de l’interface.Pour des raisons de portabilité, il est préférable d’utiliser les macros du typeDECLARE_INTERFACE,qui ajoutent automatiquement cet attribut et qui s’utilisent de la même manière qu’avec Visual C++.Enfin, il faut compiler tous les fichiers sources avec l’option-fvtable-thunks du compilateur pourautoriser la gestion des tables de fonctions virtuelles.

Ainsi, il est possible de déclarer une interface en C++ avec GCC. Cependant, aucun compilateur defichier IDL n’est fourni, et GCC n’est pas capable de compiler les fichiers d’en-têtes générés parMIDL (il utilise des extensions spécifiques à Visual C++). Vous pouvez donc utiliser des composants,à condition de redéfinir vous-même les interfaces de manière portable (c’est à dire sans les extensionsspécifiques à Visual C++), mais vous ne pouvez pas en créer de nouveau.

45

Chapitre 17. Programmation de composants COM en C++

46

Chapitre 18. ConclusionLes outils de la suite de développement GNU sont puissants, fiables, portables et très souples. Ils dis-posent d’un grand nombre d’options pour les paramétrer. En revanche, ce sont des produits provenantdu monde UNIX, ce qui signifie que leur puissance se paie un peu par l’ésotérisme, et tout est enligne de commande. Le compilateur est excellent : il comprend très bien la plupart des constructionsgrammaticales des langages C et C++ et le code généré est performant. Malheureusement, le supportpartiel de COM ainsi que la grande complexité de la gestion des bibliothèques dynamiques Windowsréduit sérieusement l’utilité de GCC sous Windows.

En général, pour simplifier l’utilisation de ces outils, il est recommandé d’utilisergccetg++ pour lesappeler. Ceci arrange sérieusement les lignes de commande et résout beaucoup de problèmes relatifsaux mauvaises options que l’on peut passer aux outils.

Cependant, il est bon de savoir comment le processus de compilation est réalisé. Si l’on veut avoir unordre d’idée du travail réalisé pargcc, il suffit de l’appeler avec l’option-v dans les commandes decompilation et d’édition de liens. Il affichera alors toutes les commandes qu’il utilise pour effectuer letravail demandé. Cette option peut être utilisée pour mettre au point des makefile qui ne fonctionnentpas bien.

Rappelons que tous ces outils sont disponibles sur un grand nombre de plates-formes, ce qui signifieque les programmes créés seront relativement portables. Enfin ils sont absolument gratuits, alors,pourquoi ne pas les utiliser ?

47

Chapitre 18. Conclusion

48

Appendix A. GNU Free DocumentationLicense

Version 1.1, March 2000

Copyright (C) 2000 Free Software Foundation, Inc.

59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

Everyone is permitted to copy and distribute verbatim copies of this license document, but changingit is not allowed.

0. PREAMBLE

The purpose of this License is to make a manual, textbook, or other written document "free" in thesense of freedom: to assure everyone the effective freedom to copy and redistribute it, with or withoutmodifying it, either commercially or noncommercially. Secondarily, this License preserves for theauthor and publisher a way to get credit for their work, while not being considered responsible formodifications made by others.

This License is a kind of "copyleft", which means that derivative works of the document must them-selves be free in the same sense. It complements the GNU General Public License, which is a copyleftlicense designed for free software.

We have designed this License in order to use it for manuals for free software, because free softwareneeds free documentation: a free program should come with manuals providing the same freedomsthat the software does. But this License is not limited to software manuals; it can be used for anytextual work, regardless of subject matter or whether it is published as a printed book. We recommendthis License principally for works whose purpose is instruction or reference.

1. APPLICABILITY AND DEFINITIONS

This License applies to any manual or other work that contains a notice placed by the copyright holdersaying it can be distributed under the terms of this License. The "Document", below, refers to any suchmanual or work. Any member of the public is a licensee, and is addressed as "you".

A "Modified Version" of the Document means any work containing the Document or a portion of it,either copied verbatim, or with modifications and/or translated into another language.

A "Secondary Section" is a named appendix or a front-matter section of the Document that dealsexclusively with the relationship of the publishers or authors of the Document to the Document’soverall subject (or to related matters) and contains nothing that could fall directly within that overallsubject. (For example, if the Document is in part a textbook of mathematics, a Secondary Sectionmay not explain any mathematics.) The relationship could be a matter of historical connection withthe subject or with related matters, or of legal, commercial, philosophical, ethical or political positionregarding them.

The "Invariant Sections" are certain Secondary Sections whose titles are designated, as being those ofInvariant Sections, in the notice that says that the Document is released under this License.

The "Cover Texts" are certain short passages of text that are listed, as Front-Cover Texts or Back-Cover Texts, in the notice that says that the Document is released under this License.

A "Transparent" copy of the Document means a machine-readable copy, represented in a formatwhose specification is available to the general public, whose contents can be viewed and edited di-rectly and straightforwardly with generic text editors or (for images composed of pixels) generic paintprograms or (for drawings) some widely available drawing editor, and that is suitable for input to textformatters or for automatic translation to a variety of formats suitable for input to text formatters.

49

Appendix A. GNU Free Documentation License

A copy made in an otherwise Transparent file format whose markup has been designed to thwart ordiscourage subsequent modification by readers is not Transparent. A copy that is not "Transparent" iscalled "Opaque".

Examples of suitable formats for Transparent copies include plain ASCII without markup, Texinfoinput format, LaTeX input format, SGML or XML using a publicly available DTD, and standard-conforming simple HTML designed for human modification. Opaque formats include PostScript,PDF, proprietary formats that can be read and edited only by proprietary word processors, SGMLor XML for which the DTD and/or processing tools are not generally available, and the machine-generated HTML produced by some word processors for output purposes only.

The "Title Page" means, for a printed book, the title page itself, plus such following pages as areneeded to hold, legibly, the material this License requires to appear in the title page. For works informats which do not have any title page as such, "Title Page" means the text near the most prominentappearance of the work’s title, preceding the beginning of the body of the text.

2. VERBATIM COPYING

You may copy and distribute the Document in any medium, either commercially or noncommercially,provided that this License, the copyright notices, and the license notice saying this License appliesto the Document are reproduced in all copies, and that you add no other conditions whatsoever tothose of this License. You may not use technical measures to obstruct or control the reading or furthercopying of the copies you make or distribute. However, you may accept compensation in exchangefor copies. If you distribute a large enough number of copies you must also follow the conditions insection 3.

You may also lend copies, under the same conditions stated above, and you may publicly displaycopies.

3. COPYING IN QUANTITY

If you publish printed copies of the Document numbering more than 100, and the Document’s licensenotice requires Cover Texts, you must enclose the copies in covers that carry, clearly and legibly, allthese Cover Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on the back cover.Both covers must also clearly and legibly identify you as the publisher of these copies. The frontcover must present the full title with all words of the title equally prominent and visible. You may addother material on the covers in addition. Copying with changes limited to the covers, as long as theypreserve the title of the Document and satisfy these conditions, can be treated as verbatim copying inother respects.

If the required texts for either cover are too voluminous to fit legibly, you should put the first oneslisted (as many as fit reasonably) on the actual cover, and continue the rest onto adjacent pages.

If you publish or distribute Opaque copies of the Document numbering more than 100, you must eitherinclude a machine-readable Transparent copy along with each Opaque copy, or state in or with eachOpaque copy a publicly-accessible computer-network location containing a complete Transparentcopy of the Document, free of added material, which the general network-using public has access todownload anonymously at no charge using public-standard network protocols. If you use the latteroption, you must take reasonably prudent steps, when you begin distribution of Opaque copies inquantity, to ensure that this Transparent copy will remain thus accessible at the stated location untilat least one year after the last time you distribute an Opaque copy (directly or through your agents orretailers) of that edition to the public.

It is requested, but not required, that you contact the authors of the Document well before redistribut-ing any large number of copies, to give them a chance to provide you with an updated version of theDocument.

4. MODIFICATIONS

50


You may copy and distribute a Modified Version of the Document under the conditions of sections2 and 3 above, provided that you release the Modified Version under precisely this License, with theModified Version filling the role of the Document, thus licensing distribution and modification ofthe Modified Version to whoever possesses a copy of it. In addition, you must do these things in theModified Version:

A. Use in the Title Page (and on the covers, if any) a title distinct from that of the Document, andfrom those of previous versions (which should, if there were any, be listed in the History sectionof the Document). You may use the same title as a previous version if the original publisher ofthat version gives permission.

B. List on the Title Page, as authors, one or more persons or entities responsible for authorship ofthe modifications in the Modified Version, together with at least five of the principal authors ofthe Document (all of its principal authors, if it has less than five).

C. State on the Title page the name of the publisher of the Modified Version, as the publisher.

D. Preserve all the copyright notices of the Document.

E. Add an appropriate copyright notice for your modifications adjacent to the other copyright no-tices.

F. Include, immediately after the copyright notices, a license notice giving the public permissionto use the Modified Version under the terms of this License, in the form shown in the Addendumbelow.

G. Preserve in that license notice the full lists of Invariant Sections and required Cover Texts givenin the Document’s license notice.

H. Include an unaltered copy of this License.

I. Preserve the section entitled "History", and its title, and add to it an item stating at least thetitle, year, new authors, and publisher of the Modified Version as given on the Title Page. If thereis no section entitled "History" in the Document, create one stating the title, year, authors, andpublisher of the Document as given on its Title Page, then add an item describing the ModifiedVersion as stated in the previous sentence.

J. Preserve the network location, if any, given in the Document for public access to a Transparentcopy of the Document, and likewise the network locations given in the Document for previousversions it was based on. These may be placed in the "History" section. You may omit a networklocation for a work that was published at least four years before the Document itself, or if theoriginal publisher of the version it refers to gives permission.

K. In any section entitled "Acknowledgements" or "Dedications", preserve the section’s title, andpreserve in the section all the substance and tone of each of the contributor acknowledgementsand/or dedications given therein.

L. Preserve all the Invariant Sections of the Document, unaltered in their text and in their titles.Section numbers or the equivalent are not considered part of the section titles.

M. Delete any section entitled "Endorsements". Such a section may not be included in the ModifiedVersion.

N. Do not retitle any existing section as "Endorsements" or to conflict in title with any InvariantSection.

If the Modified Version includes new front-matter sections or appendices that qualify as SecondarySections and contain no material copied from the Document, you may at your option designate some

51


or all of these sections as invariant. To do this, add their titles to the list of Invariant Sections in theModified Version’s license notice. These titles must be distinct from any other section titles.

You may add a section entitled "Endorsements", provided it contains nothing but endorsements ofyour Modified Version by various parties—for example, statements of peer review or that the text hasbeen approved by an organization as the authoritative definition of a standard.

You may add a passage of up to five words as a Front-Cover Text, and a passage of up to 25 words asa Back-Cover Text, to the end of the list of Cover Texts in the Modified Version. Only one passage ofFront-Cover Text and one of Back-Cover Text may be added by (or through arrangements made by)any one entity. If the Document already includes a cover text for the same cover, previously added byyou or by arrangement made by the same entity you are acting on behalf of, you may not add another;but you may replace the old one, on explicit permission from the previous publisher that added theold one.

The author(s) and publisher(s) of the Document do not by this License give permission to use theirnames for publicity for or to assert or imply endorsement of any Modified Version.

5. COMBINING DOCUMENTS

You may combine the Document with other documents released under this License, under the termsdefined in section 4 above for modified versions, provided that you include in the combination allof the Invariant Sections of all of the original documents, unmodified, and list them all as InvariantSections of your combined work in its license notice.

The combined work need only contain one copy of this License, and multiple identical InvariantSections may be replaced with a single copy. If there are multiple Invariant Sections with the samename but different contents, make the title of each such section unique by adding at the end of it, inparentheses, the name of the original author or publisher of that section if known, or else a uniquenumber. Make the same adjustment to the section titles in the list of Invariant Sections in the licensenotice of the combined work.

In the combination, you must combine any sections entitled "History" in the various original docu-ments, forming one section entitled "History"; likewise combine any sections entitled "Acknowledge-ments", and any sections entitled "Dedications". You must delete all sections entitled "Endorsements."

6. COLLECTIONS OF DOCUMENTS

You may make a collection consisting of the Document and other documents released under thisLicense, and replace the individual copies of this License in the various documents with a singlecopy that is included in the collection, provided that you follow the rules of this License for verbatimcopying of each of the documents in all other respects.

You may extract a single document from such a collection, and distribute it individually under thisLicense, provided you insert a copy of this License into the extracted document, and follow thisLicense in all other respects regarding verbatim copying of that document.

7. AGGREGATION WITH INDEPENDENT WORKS

A compilation of the Document or its derivatives with other separate and independent documents orworks, in or on a volume of a storage or distribution medium, does not as a whole count as a ModifiedVersion of the Document, provided no compilation copyright is claimed for the compilation. Such acompilation is called an "aggregate", and this License does not apply to the other self-contained worksthus compiled with the Document, on account of their being thus compiled, if they are not themselvesderivative works of the Document.

If the Cover Text requirement of section 3 is applicable to these copies of the Document, then if theDocument is less than one quarter of the entire aggregate, the Document’s Cover Texts may be placedon covers that surround only the Document within the aggregate. Otherwise they must appear oncovers around the whole aggregate.

52


8. TRANSLATION

Translation is considered a kind of modification, so you may distribute translations of the Documentunder the terms of section 4. Replacing Invariant Sections with translations requires special permis-sion from their copyright holders, but you may include translations of some or all Invariant Sectionsin addition to the original versions of these Invariant Sections. You may include a translation of thisLicense provided that you also include the original English version of this License. In case of adisagreement between the translation and the original English version of this License, the originalEnglish version will prevail.

9. TERMINATION

You may not copy, modify, sublicense, or distribute the Document except as expressly provided forunder this License. Any other attempt to copy, modify, sublicense or distribute the Document is void,and will automatically terminate your rights under this License. However, parties who have receivedcopies, or rights, from you under this License will not have their licenses terminated so long as suchparties remain in full compliance.

10. FUTURE REVISIONS OF THIS LICENSE

The Free Software Foundation may publish new, revised versions of the GNU Free DocumentationLicense from time to time. Such new versions will be similar in spirit to the present version, but maydiffer in detail to address new problems or concerns. See http://www.gnu.org/copyleft/.

Each version of the License is given a distinguishing version number. If the Document specifies thata particular numbered version of this License "or any later version" applies to it, you have the optionof following the terms and conditions either of that specified version or of any later version that hasbeen published (not as a draft) by the Free Software Foundation. If the Document does not specifya version number of this License, you may choose any version ever published (not as a draft) by theFree Software Foundation.

53


54

christian casteyde - freeploug22.free.fr/doc/gcc-casteyde.pdf · 2005-10-12 · le compilateur c++...

Documents