dpkg-buildflags - Renvoie les options de compilation à
utiliser pour la construction du paquet
dpkg-buildflags [option...] [commande]
dpkg-buildflags est un script qui permet de
récupérer les options de compilation à utiliser pour la
construction d'un paquet.
Les drapeaux par défaut sont définis par le
distributeur mais peuvent être étendus ou remplacés de
plusieurs façons :
- 1.
- pour tout le système avec
/etc/dpkg/buildflags.conf ;
- 2.
- pour l'utilisateur courant avec
$XDG_CONFIG_HOME/dpkg/buildflags.conf
où la valeur par défaut de
$XDG_CONFIG_HOME est
$HOME/.config ;
- 3.
- temporairement par l'utilisateur avec des variables d'environnement (voir
VARIABLES D'ENVIRONNEMENT) ;
- 4.
- dynamiquement par le responsable du paquet avec des variables
d'environnement à l'aide de debian/rules (voir
VARIABLES D'ENVIRONNEMENT).
Les fichiers de configuration peuvent contenir quatre types de
directives :
- SET drapeau
valeur
- Remplace le drapeau drapeau par la valeur valeur.
- STRIP drapeau
valeur
- Retire du drapeau drapeau tous les drapeaux de construction
listés dans valeur.
- APPEND drapeau
valeur
- Étend le drapeau drapeau avec les options indiquées
dans valeur. Une espace est ajoutée au début de ce
qui est ajouté si la valeur actuelle du drapeau n'est pas
vide.
- PREPEND
drapeau valeur
- Préfixe le drapeau drapeau avec les options indiquées
dans valeur. Une espace est ajoutée au début de ce
qui est ajouté si la valeur actuelle du drapeau n'est pas
vide.
Les fichiers de configuration peuvent contenir des commentaires
sur les lignes commençant par un dièse (#). Les lignes vides
sont également ignorées.
- --dump
- Affiche sur la sortie standard tous les drapeaux de compilation et leurs
valeurs. Un drapeau par ligne est affiché, suivi de sa valeur,
séparée par le caractère
« égal »
(« drapeau=valeur »). Il s'agit
de l'action par défaut.
- --list
- Affiche la liste des drapeaux gérés par le distributeur
actuel (un par ligne). Voir la section DRAPEAUX GÉRÉS
pour plus d'informations sur chacun d'eux.
- --status
- Affiche toute information utile pour expliquer le comportement de
dpkg-buildflags (depuis dpkg 1.16.5) : variables
d'environnement, distributeur actuel, état de tous les drapeaux de
fonctionnalités. Affiche également les drapeaux de
compilation résultants ainsi que leur origine.
Cette option est destinée à être
utilisée depuis debian/rules, afin de garder dans le
journal de construction une trace claire des drapeaux de compilation
utilisés. Cela peut être utile pour diagnostiquer des
problèmes qui y seraient liés.
- --export=format
- Affiche sur la sortie standard les commandes qui permettent d'exporter
tous les drapeaux de compilation pour un outil particulier. Si
format n'est pas spécifié, sa valeur est sh.
Seuls les drapeaux de compilation commençant par une majuscule sont
inclus, les autres étant supposés inadaptés à
l'environnement. Formats pris en charge :
- sh
- Commandes shell pour définir et exporter tous les drapeaux de
compilation dans l'environnement. Les valeurs drapeau sont
protégées et ainsi la sortie est prête à
être évaluée par un shell.
- cmdline
- Arguments à passer à la ligne de commande d'un programme de
construction pour utiliser tous les drapeaux de compilation (depuis
dpkg 1.17.0). Les valeurs drapeau sont protégées dans
la syntaxe du shell.
- configure
- C'est un ancien alias pour cmdline.
- make
- Directives de make pour définir et exporter tous les drapeaux de
compilation dans l'environnement. La sortie peut être écrite
dans un fragment de Makefile et évaluée en utilisant une
directive include.
- --get
drapeau
- Affiche la valeur de ce drapeau sur la sortie standard. Retourne un code
de sortie 0 si le drapeau est connu et 1 s'il est
inconnu.
- --origin
drapeau
- Affiche l'origine de la valeur renvoyée par --get. Retourne
un code de sortie 0 si le drapeau est connu et 1 s'il est
inconnu. L'origine est une des valeurs suivantes :
- vendor
- le drapeau défini à l'origine par le distributeur est
renvoyé ;
- system
- le drapeau est placé ou modifié par un réglage
système ;
- user
- le drapeau est placé ou modifié par une configuration
spécifique à l'utilisateur ;
- env
- le drapeau est placé ou modifié par une configuration
spécifique dans l'environnement.
- --query
- Affiche toute information utile pour expliquer le comportement du
programme : distributeur actuel, variables d'environnement,
domaines des fonctionnalités, état de tous les drapeaux de
fonctionnalités. Affiche également les drapeaux de
compilation résultants ainsi que leur origine (depuis
dpkg 1.19.0).
Par exemple :
Vendor: Debian
Environment:
DEB_CFLAGS_SET=-O0 -Wall
Area: qa
Features:
bug=no
canary=no
Area: reproducible
Features:
timeless=no
Flag: CFLAGS
Value: -O0 -Wall
Origin: env
Flag: CPPFLAGS
Value: -D_FORTIFY_SOURCE=2
Origin: vendor
- --query-features
domaine
- Affiche les fonctionnalités activées pour un domaine
donné (depuis dpkg 1.16.2). Les seuls domaines reconnus
actuellement sur Debian et ses dérivés sont future,
qa, reproducible, sanitize et hardening, voir
la section ZONES D'OPTION pour plus de détails. Retourne un
code de sortie 0 si le domaine est connu et 1 s'il est
inconnu.
L'affichage est dans le format RFC822, avec une section par
fonctionnalité. Par exemple :
Feature: pie
Enabled: yes
Feature: stackprotector
Enabled: yes
- --help
- Affiche un message d'aide puis quitte.
- --version
- Affiche le numéro de version puis quitte.
- CFLAGS
- Options du compilateur C. La valeur par défaut
définie par le distributeur comporte -g et le niveau
d'optimisation par défaut (-O2 en général, ou
-O0 si la variable d'environnement DEB_BUILD_OPTIONS
contient noopt).
- CPPFLAGS
- Options du préprocesseur C. Valeur par
défaut : aucune.
- CXXFLAGS
- Options du compilateur C++. Analogue à CFLAGS.
- OBJCFLAGS
- Options du compilateur Objective C. Analogue à
CFLAGS.
- OBJCXXFLAGS
- Options du compilateur Objective C++. Analogue à
CXXFLAGS.
- GCJFLAGS
- Options du compilateur Java GNU (gcj). Un sous-ensemble de
CFLAGS.
- DFLAGS
- Options for the D compiler (ldc or gdc). Since dpkg 1.20.6.
- FFLAGS
- Options du compilateur Fortran 77. Un sous-ensemble de
CFLAGS.
- FCFLAGS
- Options du compilateur Fortran 9x. Analogue à
FFLAGS.
- LDFLAGS
- Options passées au compilateur lors du processus de liaison des
exécutables ou des objets partagés (si le linker est
appelé directement, alors -Wl et , doivent
être retirés de ces options). Valeur par
défaut : aucune.
De nouveaux drapeaux pourront être ajoutés si besoin
est (par exemple pour la prise en charge de nouveaux langages).
Chaque option de zone peut être activée ou
désactivée avec les valeurs DEB_BUILD_OPTIONS et
DEB_BUIL_MAINT_OPTIONS de l'espace de variables d'environnement
grâce aux modificateurs « + » et
« - ». Par exemple, pour activer l'option
hardening « pie » et désactiver
l'option « fortify », il est possible d'indiquer
cela dans debian/rules :
export DEB_BUILD_MAINT_OPTIONS=hardening=+pie,-fortify
L'option spéciale all (valable dans toutes les
zones) peut être utilisée pour activer ou désactiver
toutes les options de la zone à la fois. Ainsi, tout
désactiver dans la zone hardening en n'activant que
« format » et
« fortify » peut être
réalisé avec :
export DEB_BUILD_MAINT_OPTIONS=hardening=-all,+format,+fortify
Plusieurs options de compilation (détaillées
ci-dessous) peuvent être utilisées pour activer des
fonctionnalités qui devraient être activées par
défaut, mais ne peuvent pas l'être pour des raisons de
compatibilité avec les versions précédentes.
- lfs
- Ce paramètre (désactivé par défaut) active la
prise en charge des gros fichiers (LFS) sur les architectures
32 bits où l'ABI n'inclut pas LFS par défaut, en
ajoutant -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 à
CPPFLAGS.
Plusieurs options de compilation (détaillées
ci-dessous) peuvent être utilisées pour détecter des
problèmes dans le code source ou dans le système de
construction.
- bug
- Ce paramètre (désactivé par défaut) ajoute
toutes les options d'avertissement détectant de façon fiable
du code source problématique. Les avertissements sont fatals. Les
seuls drapeaux actuellement gérés sont CFLAGS et
CXXFLAGS avec des drapeaux définis à
-Werror=array-bounds, -Werror=clobbered,
-Werror=implicit-function-declaration et
-Werror=volatile-register-var.
- canary
- Ce paramètre (désactivé par défaut) ajoute des
options détectrices « canary » factices
aux drapeaux de construction de telle sorte que les rapports de
compilation permettront de vérifier la façon dont ces
drapeaux se propagent et de repérer toute omission des
paramètres de drapeaux habituels. Les drapeaux actuellement pris en
charge sont CPPFLAGS, CFLAGS, OBJCFLAGS,
CXXFLAGS ainsi que OBJCXXFLAGS, avec les drapeaux
définis à
-D__DEB_CANARY_flag_random-id__, et
LDFLAGS paramétré à
-Wl,-z,deb-canary-random-id.
Plusieurs options de compilation (détaillées
ci-dessous) peuvent être utilisées pour aider à
nettoyer le binaire compilé face aux corruptions de la
mémoire, aux fuites de mémoire, à l'utilisation de
mémoire après libération et à des bogues au
comportement indéfini. Note : ces options ne devraient
pas être utilisées pour des constructions en production car
elles peuvent réduire la fiabilité du code, réduire la
sécurité ou même les fonctionnalités.
- address
- Ce paramètre (désactivé par défaut) ajoute
-fsanitize=address à LDFLAGS et -fsanitize=address
-fno-omit-frame-pointer à CFLAGS et
CXXFLAGS.
- thread
- Ce paramètre (désactivé par défaut) ajoute
-fsanitize=thread à CFLAGS, CXXFLAGS et
LDFLAGS.
- leak
- Ce paramètre (désactivé par défaut) ajoute
-fsanitize=leak à LDFLAGS. Il est automatiquement
désactivé si les fonctions address ou thread
sont activées, parce qu'elles l'impliquent.
- undefined
- Ce paramètre (désactivé par défaut) ajoute
-fsanitize=undefined à CFLAGS, CXXFLAGS et
LDFLAGS.
Plusieurs options de compilation (détaillées
ci-dessous) peuvent être utilisées pour accroître la
résistance du binaire compilé face aux attaques par corruption
de la mémoire ou fournir des messages d'avertissement
supplémentaires lors de la compilation. Sauf mention contraire (voir
ci-dessous), ces options sont activées par défaut pour les
architectures qui les gèrent.
- format
- Ce réglage, activé par défaut, ajoute -Wformat
-Werror=format-security à CFLAGS, CXXFLAGS,
OBJCFLAGS et OBJCXXFLAGS. Cela provoquera l'avertissement en
cas d'utilisation de chaînes de formatage incorrectes et
échouera si les fonctions de formatage sont utilisées d'une
façon qui présente des risques pour la
sécurité. Actuellement, ce réglage crée des
avertissements pour les appels des fonctions printf et scanf
lorsque la chaîne de formatage n'est pas une chaîne
littérale et qu'aucun paramètre de formatage n'est
utilisé (par exemple dans printf(foo); au lieu de
printf("%s", foo);. Ce type de syntaxe peut créer
un problème de sécurité si la chaîne de
formatage vient d'une source non sûre et contient
« %n ».
- fortify
- Ce réglage, activé par défaut, ajoute
-D_FORTIFY_SOURCE=2 à CPPFLAGS. Lors de la
création du code, le compilateur connaît un nombre important
d'informations relatives aux tailles de tampons (quand c'est possible) et
tente alors de remplacer des appels de fonctions avec une taille
illimitée de tampons, peu sûrs, par des appels avec des
tampons de taille limitée. Cette fonctionnalité est
particulièrement utile pour du code ancien et mal écrit. De
plus, les chaînes de formatage dans la mémoire accessible en
écriture qui contiennent
« %n » sont
bloquées. Si une application dépend de telles chaînes
de formatage, un contournement devra être mis en place.
Veuillez noter que pour que cette option fasse effet, le
source devra aussi être compilée avec -O1 ou plus.
Si la variable d'environnement DEB_BUILD_OPTIONS contient
noopt, la prise en charge de fortify sera
désactivée du fait des nouveaux avertissements émis
par la glibc version 2.16 et ultérieure.
- stackprotector
- Ce réglage (activé par défaut si stackprotectorstrong
n'est pas employé), ajoute -fstack-protector
--param=ssp-buffer-size=4 à CFLAGS, CXXFLAGS,
OBJCFLAGS, OBJCXXFLAGS, GCJFLAGS, FFLAGS et
FCFLAGS. Il ajoute des contrôles liés aux
réécritures de piles. Cela conduit des tentatives d'attaques
par injection de code à terminer en échec. Dans le meilleur
des cas, cette protection transforme une vulnérabilité
d'injection de code en déni de service ou en non-problème
(selon les applications).
Cette fonctionnalité impose de lier le code à la
glibc (ou toute autre bibliothèque fournissant
__stack_chk_fail) et doit donc être
désactivée lorsque le code est construit avec
-nostdlib, -ffreestanding ou équivalents.
- stackprotectorstrong
- Ce réglage, activé par défaut, ajoute
-fstack-protector-strong à CFLAGS, CXXFLAGS,
OBJCFLAGS, OBJCXXFLAGS, GCJFLAGS, FFLAGS et
FCFLAGS. Il s'agit d'une version renforcée de
stackprotector qui n'affecte pas les performances de manière
importante.
Désactiver stackprotector désactive
également ce paramètre.
Cette fonctionnalité a les même exigences que
stackprotector, en plus de nécessiter gcc 4.9 ou
plus récent.
- relro
- Ce réglage, activé par défaut, ajoute
-Wl,-z,relro à LDFLAGS. Lors du chargement du
programme, plusieurs parties de la mémoire ELF doivent être
écrites par l'éditeur de liens. Ce réglage indique au
chargeur de mettre ces sections en lecture seule avant de rendre le
contrôle au programme. L'utilisation habituelle de ce
réglage est la protection contre les attaques par
réécriture GOT. Si cette option est
désactivée, l'option bindnow sera également
désactivée.
- bindnow
- Ce réglage, désactivé par défaut, ajoute
-Wl,-z,now à LDFLAGS. Lors du chargement du
programme, tous les symboles dynamiques sont résolus, ce qui permet
au PLT (Procedure Linkage Table) entier d'être en lecture seule (du
fait du réglage relro ci-dessus). Cette option ne peut
être activée si relro ne l'est pas.
- pie
- Ce réglage (sans option globale par défaut depuis
dpkg 1.18.23, parce qu'il est maintenant activé par
défaut par gcc dans les architectures Debian amd64, arm64, armel,
armhf, hurd-i386, i386, kfreebsd-amd64, kfreebsd-i386, mips, mipsel,
mips64el, powerpc, ppc64, ppc64el, riscv64, s390x, sparc et sparc64)
ajoute les options requises pour activer ou désactiver PIE
(exécutable indépendant de l'emplacement) au moyen des
fichiers de spécifications de gcc, si nécessaire, selon que
gcc injecte sur cette architecture les drapeaux par lui-même ou
non. Si le réglage est activé et que gcc injecte les
drapeaux, il n'ajoute rien. Si le réglage est activé et que
gcc n'injecte pas les drapeaux, il ajoute -fPIE (au moyen de
/usr/share/dpkg/pie-compiler.specs) à CFLAGS,
CXXFLAGS, OBJCFLAGS, OBJCXXFLAGS, GCJFLAGS,
FFLAGS et FCFLAGS, et -fPIE -pie (au moyen de
/usr/share/dpkg/pie-link.specs) à LDFLAGS. Si le
réglage est désactivé et que gcc injecte les
drapeaux, il ajoute -fno-PIE (au moyen de
/usr/share/dpkg/no-pie-compile.specs) à CFLAGS,
CXXFLAGS, OBJCFLAGS, OBJCXXFLAGS, GCJFLAGS,
FFLAGS et FCFLAGS, et -fno-PIE -no-pie (au moyen de
/usr/share/dpkg/no-pie-link.specs) à LDFLAGS.
Les exécutables à position indépendante
(« Position Independent Executable »)
permettent d'utiliser la randomisation de l'organisation de l'espace
d'adressage (ASLR : « Address Space Layout
Randomization »), qui est gérée par
certaines versions du noyau. Bien que ASLR puisse déjà
être mise en œuvre pour les zones de données dans
la pile et le tampon (brk et mmap), les zones de codes doivent
être compilées comme indépendantes de la position.
Les bibliothèques partagées font déjà cela
(-fPIC) ce qui permet automatiquement d'utiliser ASLR. Par contre
les régions .text binaires doivent être construites en
mode PIE pour mettre en œuvre ASLR. Une fois cela
réalisé, les attaques ROP (« Return Oriented
Programming ») deviennent plus difficiles car il n'existe
pas d'emplacement statique d'où rebondir pendant une attaque par
corruption de la mémoire.
PIE n'est pas compatible avec fPIC, aussi, en
général, des précautions doivent être prises
lors de la construction d'objets partagés. Mais comme les
drapeaux PIE émis sont injectés par des fichiers de
spécifications de gcc, il devrait toujours être sûr
de les définir sans condition indépendamment du type
d'objet en train d'être compilé ou lié.
Les bibliothèques statiques peuvent être
utilisées par des programmes ou d'autres bibliothèques
partagées. Selon les drapeaux utilisés pour compiler tous
les objets d'une bibliothèque statique, ces bibliothèques
seront utilisables par divers ensembles d'objets :
- none
- Ne peut être lié ni à un programme PIE, ni à
une bibliothèque partagée.
- -fPIE
- Peut être lié à tout programme, mais pas à une
bibliothèque partagée (recommandé).
- -fPIC
- Peut être lié à tout programme et toute
bibliothèque partagée.
S'il est nécessaire de régler ces drapeaux
manuellement, en contournant l'injonction des spécifications de gcc,
il y a plusieurs choses à prendre en compte. Le passage sans
condition et de façon explicite de -fPIE, -fpie ou
-pie à un système de construction en utilisant libtool
est sûr dans la mesure où ces drapeaux seront retirés
lors de la construction de bibliothèques partagées. Sinon, sur
les projets qui construisent à la fois des programmes et des
bibliothèques partagées, il faudrait s'assurer que, lors de la
construction des bibliothèques partagées, -fPIC soit
toujours passé en dernier aux drapeaux de compilation tels que
CFLAGS (de sorte qu'il remplace tout -PIE antérieur),
et que -shared soit passé en dernier aux drapeaux de
création de lien tels que LDFLAGS (de sorte qu'il remplace
tout -pie antérieur). Note : Cela ne devrait pas
être nécessaire avec les mécanismes de
spécification de gcc par défaut.
De plus, comme la protection PIE est mise en œuvre à
l'aide d'un registre global, certaines architectures privées de
registre (mais plus i386 depuis les optimisations mises en œuvre dans
gcc >= 5) peuvent souffrir de pertes de performances allant
jusqu'à 15 % sur des charges d'applications utilisant
largement les segments de texte ; le plus souvent, cette perte de
performances n’excédera pas 1 %. Pour des
architectures offrant plus de registres globaux (par exemple amd64), cette
pénalisation n'existe pratiquement pas.
Les options de compilation (détaillées ci-dessous)
peuvent aider à améliorer la reproductibilité de la
construction ou fournir des messages d'avertissement supplémentaires
lors de la compilation. Sauf mention contraire (voir ci-dessous), ces
options sont activées par défaut pour les architectures qui
les gèrent.
- timeless
- Ce paramètre, activé par défaut, ajoute
-Wdate-time à CPPFLAGS. Cela provoquera des
avertissements quand les macros __TIME__, __DATE__ et
__TIMESTAMP__ sont utilisées.
- fixfilepath
- This setting (enabled by default) adds
-ffile-prefix-map=BUILDPATH=. to CFLAGS,
CXXFLAGS, OBJCFLAGS, OBJCXXFLAGS, GCJFLAGS,
FFLAGS and FCFLAGS where BUILDPATH is set to the
top-level directory of the package being built. This has the effect of
removing the build path from any generated file.
Si à la fois fixdebugpath et fixfilepath
sont définis, cette option a la priorité parce c'est un
sur-ensemble du premier.
- fixdebugpath
- Ce réglage, activé par défaut, ajoute
-fdebug-prefix-map=BUILDPATH=. à
CFLAGS, CXXFLAGS, OBJCFLAGS, OBJCXXFLAGS,
GCJFLAGS, FFLAGS et FCFLAGS où
BUILDPATH est fixé sur le répertoire de plus haut
niveau du paquet en construction. Cela a pour effet de retirer le chemin
de construction de tous les symboles de débogage
générés.
Deux jeux de variables d'environnement effectuent les mêmes
opérations. Le premier (DEB_drapeau_opération)
ne devrait jamais être utilisé depuis debian/rules. Il
est destiné aux utilisateurs souhaitant recompiler le paquet source
avec des drapeaux de compilation modifiés. Le second
(DEB_drapeau_MAINT_opération) ne doit être
utilisé que dans debian/rules par les responsables de paquets
pour modifier les drapeaux de compilation concernés.
- DEB_drapeau_SET
- DEB_drapeau_MAINT_SET
- Cette variable permet de forcer la valeur renvoyée pour le
drapeau indiqué.
- DEB_drapeau_STRIP
- DEB_drapeau_MAINT_STRIP
- Cette variable peut être utilisée pour fournir une liste
d'options (séparées par des espaces) qui seront
retirées du jeu de drapeaux renvoyé pour le drapeau
indiqué.
- DEB_drapeau_APPEND
- DEB_drapeau_MAINT_APPEND
- Cette variable permet d'ajouter des options à la valeur
renvoyée pour le drapeau indiqué.
- DEB_drapeau_PREPEND
- DEB_drapeau_MAINT_PREPEND
- Cette variable permet de préfixer la valeur renvoyée pour le
drapeau indiqué par des options supplémentaires.
- DEB_BUILD_OPTIONS
- DEB_BUILD_MAINT_OPTIONS
- Ces variables peuvent être utilisées par un utilisateur ou
un responsable de paquet pour activer ou désactiver
différentes options de zone qui affectent les drapeaux de
construction. La variable DEB_BUILD_MAINT_OPTIONS outrepasse tous
les paramètres de la zone d'options DEB_BUILD_OPTIONS. Voir
la section ZONES D'OPTION pour plus de détails.
- DEB_VENDOR
- Ce réglage définit l'éditeur
(« vendor ») actuel. Si cette valeur est vide,
le contenu du fichier /etc/dpkg/origins/default est
utilisé.
- DEB_BUILD_PATH
- Cette variable configure le chemin de construction (depuis
dpkg 1.18.8) à utiliser avec des fonctions telles que
fixdebugpath de telle sorte qu'elles soient
contrôlées par l'appelant. Cette variable est actuellement
spécifique à Debian et à ses
dérivés.
- DPKG_COLORS
- Définit le mode de couleur (depuis dpkg 1.18.5). Les valeurs
actuellement acceptées sont auto (par défaut),
always et never.
- DPKG_NLS
- Si cette variable est définie, elle sera utilisée pour
décider l'activation de la prise en charge des langues (NLS
– Native Language Support), connu aussi comme la gestion de
l'internationalisation (ou i18n) (depuis dpkg 1.19.0). Les valeurs
permises sont : 0 et 1 (par défaut).
- /etc/dpkg/buildflags.conf
- Fichier de configuration pour l'ensemble du système.
- $XDG_CONFIG_HOME/dpkg/buildflags.conf
or
- $HOME/.config/dpkg/buildflags.conf
- Fichier de configuration propre à l'utilisateur
- /usr/share/dpkg/buildflags.mk
- Fragment de fichier Makefile qui chargera (et facultativement exportera)
dans les variables (depuis dpkg 1.16.1) tous les drapeaux pris en
charge par dpkg-buildflags.
Pour passer des drapeaux de compilation à une commande de
compilation dans un Makefile :
$(MAKE) $(shell dpkg-buildflags --export=cmdline)
./configure $(shell dpkg-buildflags --export=cmdline)
Pour définir les drapeaux de compilation dans un script
shell ou un fragment de shell, on peut utiliser eval pour
interpréter la sortie et exporter les drapeaux dans
l'environnement :
eval "$(dpkg-buildflags --export=sh)" && make
ou définir les paramètres de position à
passer à la commande :
eval "set -- $(dpkg-buildflags --export=cmdline)"
for dir in a b c; do (cd $dir && ./configure "$@" && make); done
Il faut appeler dpkg-buildflags ou inclure
buildflags.mk à partir du fichier debian/rules pour
obtenir les drapeaux de compilation nécessaires à passer au
système de construction. Veuillez noter que les anciennes versions de
dpkg-buildpackage (antérieures à dpkg 1.16.1)
exportaient ces drapeaux automatiquement. Néanmoins, il est
déconseillé de dépendre de ce comportement parce qu'il
casse l'appel manuel de debian/rules.
Pour les paquets avec des systèmes de construction du style
autoconf, il est possible de passer les options appropriées à
configure ou make(1) directement, comme vu ci-dessus.
Pour d'autres systèmes de construction ou si on souhaite un
contrôle extrêmement précis sur le choix et la position
où sont passés les drapeaux, --get peut être
utilisé. Autrement, il est possible d'inclure buildflags.mk
qui s'occupe de l'appel de dpkg-buildflags et du placement des
drapeaux de compilation dans les variables de make.
Si vous voulez exporter tous les drapeaux de compilation dans
l'environnement (où le système de construction peut les
récupérer) :
DPKG_EXPORT_BUILDFLAGS = 1
include /usr/share/dpkg/buildflags.mk
Pour un contrôle supplémentaire sur ce qui est
exporté, vous pouvez exporter manuellement les variables (puisque
aucune n'est exportée par défaut) :
include /usr/share/dpkg/buildflags.mk
export CPPFLAGS CFLAGS LDFLAGS
Et enfin, vous pouvez bien sûr passer manuellement les
drapeaux aux commandes :
include /usr/share/dpkg/buildflags.mk
build-arch:
$(CC) -o hello hello.c $(CPPFLAGS) $(CFLAGS) $(LDFLAGS)
Ariel VARDI <ariel.vardi@freesbee.fr>, 2002. Philippe
Batailler, 2006. Nicolas François, 2006. Veuillez signaler toute
erreur à <debian-l10n-french@lists.debian.org>.