dpkg-buildflags - retorna flags de compilação para usar durante a
compilação de pacotes
dpkg-buildflags [
option...] [
command]
dpkg-buildflags é uma ferramenta para obter flags de
compilação para usar durante a compilação de
pacotes Debian.
As flags predefinidas são definidas pelo fornecedor mas podem ser
estendidas/sobrepostas de várias maneiras:
- 1.
- de todo o sistema com
/etc/dpkg/buildflags.conf;
- 2.
- para o utilizador actual com
$XDG_CONFIG_HOME/dpkg/buildflags.conf onde
$XDG_CONFIG_HOME usa por predefinição
$HOME/.config;
- 3.
- temporariamente pelo utilizador com variáveis de
ambiente (veja a secção AMBIENTE);
- 4.
- dinamicamente pelo maintainer do pacote com
variáveis de ambiente definidas via debian/rules (veja a
secção AMBIENTE).
Os ficheiros de configuração podem conter quatro tipos de
directivas:
-
SET flag value
- Sobrescreve a flag chamada flag para ter o valor
valor.
-
STRIP flag value
- Despoja da flag chamada flag todas as flags de
compilação listadas em valor.
-
APPEND flag value
- Estende a flag chamada flag ao acrescentar as
opções dadas em valor. É usado um
espaço a preceder o valor acrescentado se o valor da flag actual
não estiver vazio.
-
PREPEND flag value
- Estende a flag chamada flag ao precede-la com as
opções dadas em valor. É acrescentado um
espaço ao valor precedido se o valor da flag actual não
estiver vazio.
Os ficheiros de configuração podem conter comentários nas
linhas que começam com um cardinal (#). As linhas vazias também
são ignoradas.
- --dump
- Escreve na saída standard todas as bandeiras de
compilação e os seus valores. Escreve uma bandeira por linha
separada do seu valor por um sinal de igual ("
flag=value"). Esta é a acção
predefinida.
- --list
- Escreve a lista das flags suportadas pelo fornecedor actual
(uma por cada linha). Veja a secção FLAGS SUPORTADAS
para mais informação sobre elas.
- --status
- Mostra qualquer informação que possa ser
útil para explicar o comportamento de dpkg-buildflags (desde
dpkg 1.16.5): variáveis de ambiente relevantes, fornecedor actual,
estado de todas as bandeiras de funcionalidades. Também escreve as
bandeira de compilação resultantes com as suas origens.
Isto destina-se a ser corrido a partir de debian/rules, para que os
relatórios de compilação mantenham um rasto claro das
bandeiras de compilação usadas. Isto pode ser útil
para diagnosticar problemas relacionados com elas.
-
--export=format
- Escreve na saída standard comandos que podem ser
usados para exportar todas as bandeiras de compilação para
alguma ferramenta particular. Se o valor format não for
fornecido, é assumido sh. Apenas são incluídas
bandeiras que comecem com um caractere maiúsculo, as outras
são assumidas como não apropriadas para o ambiente. Formatos
suportados:
- sh
- Comandos de shell para definir e exportar todas as
bandeiras de compilação no ambiente. Os valores das
bandeiras são citados para que o resultado esteja pronto para
avaliação pela shell.
- cmdline
- Argumentos a passar para a linha de comandos dos programas
de compilação para se usar todas as bandeiras de
compilação (desde dpkg 1.17.0). Os valores das bandeiras
são citados na sintaxe da shell.
- configure
- Este é um nome alternativo antigo para
cmdline.
- make
- Faz as directivas definir e exportar todas as bandeiras de
compilação no ambiente. O resultado pode ser escrito para o
fragmento do Makefile e avaliado usando uma directiva include.
-
--get flag
- Escreve o valor da flag na saída standard. Termina
com 0 se a flag for conhecida, caso contrário termina com 1.
-
--origin flag
- Escreve a origem do valor que é devolvido por
--get. Termina com 0 se a flag for conhecida, caso contrário
termina com 1. A origem pode ser um dos seguintes valores:
- vendor
- é devolvida a flag origina definida pelo
fornecedor;
- system
- a flag é definida/modifica por uma
configuração de todo o sistema;
- user
- a flag é definida/modifica por uma
configuração específica do utilizador;
- env
- a flag é definida/modifica por uma
configuração específica do ambiente;
- --query
- Escreve qualquer informação que possa ser
útil para explicar o comportamento do programa: fornecedor actual,
variáveis de ambiente relevantes, áreas de funcionalidades,
estado de todas as bandeiras de funcionalidades, se uma funcionalidade
é lidada como uma predefinição de
compilação pelo compilador (desde dpkg 1.21.14), a as
bandeiras de compilação com as suas origens (desde dpkg
1.19.0).
Por exemplo:
Vendor: Debian
Environment:
DEB_CFLAGS_SET=-O0 -Wall
Area: qa
Features:
bug=no
canary=no
Builtins:
Area: hardening
Features:
pie=no
Builtins:
pie=yes
Area: reproducible
Features:
timeless=no
Builtins:
Flag: CFLAGS
Value: -O0 -Wall
Origin: env
Flag: CPPFLAGS
Value: -D_FORTIFY_SOURCE=2
Origin: vendor
-
--query-features area
- Escreve as funcionalidades activadas para uma dada
área (desde dpkg 1.16.2). Se a funcionalidade é lidada
(mesmo que apenas em algumas arquitecturas) como
predefinição de compilação pelo compilador,
então é escrito um campo Builtin (desde dpkg
1.21.14). As únicas áreas actualmente reconhecidas em Debian
e derivados são future, qa, reproducible,
sanitize e hardening, veja a secção
ÁREAS DE CARACTERÍSTICAS para mais detalhes. Termina
com 0 se a área é conhecida caso contrário termina
com 1.
O resultado está em formato RFC822, com uma secção por
característica. Por exemplo:
Feature: pie
Enabled: yes
Builtin: yes
Feature: stackprotector
Enabled: yes
- --help
- Mostra a mensagem de utilização e
termina.
- --version
- Mostra a versão e termina.
- ASFLAGS
- Opções para o assemblador. Valor predefinido:
vazio. Desde dpkg 1.21.0.
- CFLAGS
- Opções para o compilador de C. O valor
predefinido regulado pelo fornecedor inclui -g e o nível de
optimização predefinido (geralmente -O2, ou
-O0 se a variável de ambiente DEB_BUILD_OPTIONS
definir noopt).
- CPPFLAGS
- Opções para o pré-processador de C.
Valor predefinido: vazio.
- CXXFLAGS
- Opções para o compilador de C++. O mesmo que
CFLAGS.
- OBJCFLAGS
- Opções para o compilador Objective C. O mesmo
que CFLAGS.
- OBJCXXFLAGS
- Opções para o compilador Objective C++. O
mesmo que CXXFLAGS.
- GCJFLAGS
- Opções para o compilador de Java do GNU
(gcj). Um subconjunto de CFLAGS.
- DFLAGS
- Opções para o compilador D (ldc ou gdc).
Desde dpkg 1.20.6.
- FFLAGS
- Opções para o compilador Fortran 77. Um
subconjunto de CFLAGS.
- FCFLAGS
- Opções para o compilador Fortran 9x. O mesmo
que FFLAGS.
- LDFLAGS
- Opções passadas ao compilador quando faz link
a executáveis ou objetos partilhados (se o vinculador (linker) for
chamado directamente, então -Wl e , têm de ser
cortados destas opções). Valor predefinido: empty.
Podem ser adicionadas novas bandeiras no futuro se a necessidade surgir (por
exemplo para suportar outras linguagens).
Cada funcionalidade de área pode ser activada ou desactivada no valor da
área das variáveis de ambiente
DEB_BUILD_OPTIONS e
DEB_BUILD_MAINT_OPTIONS com o modificador ‘
+’ e
‘
-’. Por exemplo, par activar a funcionalidade
"pie" de
hardening e desactivar a funcionalidade
“fortify” você pode fazer isto em
debian/rules:
export DEB_BUILD_MAINT_OPTIONS=hardening=+pie,-fortify
A funcionalidade especial
all (válida em qualquer área)
pode ser usada para activar ou desactivar todas as funcionalidades de
área ao mesmo tempo. Assim desactivar tudo na área
hardening e activar apenas apenas “format” e
“fortify” pode ser obtido com:
export DEB_BUILD_MAINT_OPTIONS=hardening=-all,+format,+fortify
Várias opções de tempo de compilação
(detalhado em baixo) podem ser usadas para activar funcionalidades que deveria
estar activadas por predefinição, mas não podem estar por
razões de compatibilidade com versões anteriores.
- lfs
- Esta definição (desactivada por
predefinição) activa Suporte Ficheiros Longos em
arquitecturas de 32-bit onde o seu ABI não inclui LFS (Large File
Support) por predefinição, ao adicionar
-D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 a CPPFLAGS.
Várias opções de tempo de compilação
(detalhado em baixo) podem ser usadas para ajudar a detectar no código
fonte ou no sistema de compilação.
- bug
- Esta definição (desactivada por
predefinição) adiciona qualquer opção de aviso
de detecção de fiabilidade problemática no
código fonte. Os avisos são fatais. As únicas
bandeiras presentemente suportadas são CFLAGS e
CXXFLAGS com bandeiras definidas para -Werror=array-bounds,
-Werror=clobbered, -Werror=implicit-function-declaration e
-Werror=volatile-register-var.
- canary
- Esta definição (desactivada por
predefinição) adiciona opções canary fantoches
às bandeiras de compilação, para que os
relatórios de compilação possam ser verificados em
como as bandeiras de compilação de propagam e para permitir
encontrar qualquer omissão de definições normais de
bandeiras de compilação. As únicas bandeiras
actualmente suportadas são CPPFLAGS, CFLAGS,
OBJCFLAGS, CXXFLAGS e OBJCXXFLAGS com bandeiras
definidas para
-D__DEB_CANARY_flag_random-id__, e
LDFLAGS definida para
-Wl,-z,deb-canary-random-id.
Várias opções de tempo de compilação
(detalhado em baixo) podem ser usadas para ajudar a optimizar um
binário resultante (desde dpkg 1.21.0).
Nota: ativador
todas estas opções pode resultar em artefactos
binários não reproduzíveis.
- lto
- Esta definição (desde dpkg 1.21.0;
desactivada por predefinição) activa Link Time Optimization
ao adicionar -flto=auto -ffat-lto-objects a CFLAGS,
CXXFLAGS, OBJCFLAGS, OBJCXXFLAGS, GCJFLAGS,
FFLAGS, FCFLAGS e LDFLAGS.
Várias opções de tempo de compilação
(detalhado em baixo) podem ser usadas para ajudar a higienizar um
binário resultante contra corrupções de memória,
fugas de memória, utilização após livre,
segmentação de dados e bugs de comportamento indefinido.
Nota: estas opções
não devem ser usadas
para compilações de produção pois elas podem
reduzir a confiança na conformidade do código, reduzir a
segurança ou mesmo a funcionalidade.
- address
- Esta definição (desactivada por
predefinição) adiciona -fsanitize=address a
LDFLAGS e -fsanitize=address -fno-omit-frame-pointer a
CFLAGS e CXXFLAGS.
- thread
- Esta definição (desactivada por
predefinição) adiciona -fsanitize=thread a
CFLAGS, CXXFLAGS e LDFLAGS.
- leak
- Esta definição (desactivada por
predefinição) adiciona -fsanitize=leak a
LDFLAGS. fica automaticamente desactivada se as funcionalidades
address ou thread estiverem activas, pois elas já
implicam isto.
- undefined
- Esta definição (desactivada por
predefinição) adiciona -fsanitize=undefined a
CFLAGS, CXXFLAGS e LDFLAGS.
Várias opções de tempo de compilação
(detalhado em baixo) podem ser usadas para ajudar a endurecer um
binário resultante contra ataques de corrupção de
memória, ou disponibilizar mensagens de aviso adicionais durante a
compilação. Excepto como notado em baixo, estas estão
activadas por predefinição para as arquitecturas que as
suportam.
- format
- Esta definição (activada por
predefinição) adiciona -Wformat
-Werror=format-security a CFLAGS, CXXFLAGS,
OBJCFLAGS e OBJCXXFLAGS. Isto irá avisar sobre uso de
strings de formato impróprias, e irá falhar quando
funções de formato forem usadas em modo que representem
possíveis problemas de segurança. Presentemente, isto avisa
sobre chamadas a funções printf e scanf onde a
string de formato não é uma string literal e não
existem argumentos de formato, como em printf(foo); em vez de
printf("%s", foo); Isto pode ser um buraco de
segurança se a string de formato vier de uma entrada não
confiável e conter ‘%n’.
- fortify
- Esta definição (activada por
predefinição) adiciona -D_FORTIFY_SOURCE=2 a
CPPFLAGS. Durante a geração de código o
compilador sabe muita informação sobre tamanhos de buffer
(onde possível), e tenta substituir chamadas de
função buffer de comprimento ilimitadas e inseguras por umas
limitadas em comprimento. Isto é especialmente útil para
código antigo, desnecessariamente complicado. Adicionalmente, as
strings de formato em memória gravável que contêm
‘%n’ são bloqueadas. Se uma aplicação
depender de tal string de formato, isso terá que ser contornado.
Note que para esta opção ter algum efeito, a fonte tem de
também ser compilada com -O1 ou superior. Se a
variável de ambiente DEB_BUILD_OPTIONS conter noopt,
então o suporte a fortify será desactivado, devido a
novos avisos serem emitidos pelo glibc 2.16 e posterior.
- stackprotector
- Esta definição (activada por
predefinição se stackprotectorstrong não estiver em
uso) adiciona -fstack-protector --param=ssp-buffer-size=4 a
CFLAGS, CXXFLAGS, OBJCFLAGS, OBJCXXFLAGS,
GCJFLAGS, FFLAGS e FCFLAGS. Isto adiciona
verificações de segurança contra
sobreposições de empilhamento. Isto renderiza muitos
potenciais ataques de injeções de código em
situações de abortar. No melhor caso, isto transforma
vulnerabilidades de injeção de código em
negação de serviço ou em não-problemas
(dependendo da aplicação).
Esta funcionalidade requer ligação (link) a glibc (ou outro
fornecedor de __stack_chk_fail), portanto precisa de ser
desactivada quando se compila com -nostdlib ou
-ffreestanding ou semelhante.
- stackprotectorstrong
- Esta definição (activada por
predefinição) adiciona -fstack-protector-strong a
CFLAGS, CXXFLAGS, OBJCFLAGS, OBJCXXFLAGS,
GCJFLAGS, FFLAGS e FCFLAGS. Esta é uma
variante mais forte de stackprotector, mas sem penalidades de
performance significativas.
Desactivar stackprotector irá também desactivar esta
definição.
Esta funcionalidade tem os mesmos requerimentos que stackprotector, e
adicionalmente também requer gcc 4.9 e posterior.
- relro
- Esta definição (activada por
predefinição) adiciona -Wl,-z,relro a LDFLAGS.
Durante o carregamento do programa, várias secções de
memória ELF precisam de ser escritas pelo vinculador. Isto sinaliza
ao carregador para tornar estas secções só-leitura
antes de entregar o controlo ao programa. Mais notavelmente isto previne
ataques de sobrescrita GOT. Se esta opção for desactivada,
bindnow irá ficar também desactivado.
- bindnow
- Esta definição (desactivada por
predefinição) adiciona -Wl,-z,now a LDFLAGS.
Durante o carregamento do programa, todos os símbolos
dinâmicos são resolvidos, permitindo que todo o PLT seja
marcado só-leitura (devido ao relro em cima). A
opção pode ser activada se relro não for
activado.
- pie
- Esta definição (sem uma
predefinição global desde dpkg 1.18.23, pois é agora
activa por predefinição pelo gcc nas arquitecturas Debian
amd64, arm64, armel, armhf, hurd-i386, i386, kfreebsd-amd64,
kfreebsd-i386, mips, mipsel, mips64el, powerpc, ppc64, ppc64el, riscv64,
s390x, sparc e sparc64) adiciona as opções requeridas para
activar ou desactivar PIE via ficheiros de especificações do
gcc, Se necessário, dependendo de se o gcc injeta nessa
arquitectura as bandeiras por ele próprio ou não. Quando a
definição está activa e o gcc injeta as bandeiras,
não adiciona nada. Quando a definição está
activa e o gcc não injeta as bandeiras, adiciona -fPIE (via
/usr/share/dpkg/pie-compiler.specs) to CFLAGS,
CXXFLAGS, OBJCFLAGS, OBJCXXFLAGS, GCJFLAGS,
FFLAGS e FCFLAGS, e -fPIE -pie (via
/usr/share/dpkg/pie-link.specs) a LDFLAGS. Quando a
definição está desactivada e o gcc injeta as
bandeiras, adiciona -fno-PIE (via
/usr/share/dpkg/no-pie-compile.specs) a CFLAGS,
CXXFLAGS, OBJCFLAGS, OBJCXXFLAGS, GCJFLAGS,
FFLAGS e FCFLAGS, e -fno-PIE -no-pie (via
/usr/share/dpkg/no-pie-link.specs) a LDFLAGS.
Position Independent Executable (PIE) é necessário para tirar
vantagem de Address Space Layout Randomization (ASLR), suportado por
algumas versões de kernel. Enquanto ASLR já pode ser
aplicada para áreas de dados na stack e heap (brk e mmap), as
áreas de código têm de ser compiladas como
independente-de-posição. As bibliotecas partilhadas
já fazem isto ( -fPIC), assim elas ganham ASLR
automaticamente, mas as regiões de texto binários precisam
de ser compiladas como PIE para ganhar ASLR. Quando isto acontece, os
ataques ROP (Return Oriented Programming) são mais difíceis
pois não são localizações estáticas
para ressaltar durante um ataque de corrupção de
memória.
PIE não é compatível com -fPIC, assim em geral
é preciso cuidado ao compilar objectos partilhados. Mas porque as
bandeiras PIE emitidas são injetadas via ficheiros specs de gcc,
deverá ser sempre seguro defini-las incondicionalmente
independentemente do tipo de objecto a ser compilado ou ligado em link.
Bibliotecas estáticas pode ser usadas por programas ou outras
bibliotecas partilhadas. Dependendo das bandeiras usadas para compilar
todos os objectos dentro de uma biblioteca estática, estas
bibliotecas serão utilizáveis por conjuntos diferentes de
objectos:
- none
- Não pode ser vinculado a um programa PIE, não
é uma biblioteca partilhada.
- -fPIE
- Pode ser vinculado a qualquer programa, mas não a
uma biblioteca partilhada (recomendado).
- -fPIC
- Pode ser vinculado a qualquer programa e biblioteca
partilhada.
Se existir a necessidade de definir estas bandeiras manualmente, fazendo bypass
à injeção de spec gcc, há varias coisas a ter em
conta. Passar incondicionalmente e explicitamente
-fPIE,
-fpie
ou
-pie a um sistema de compilação usando libtool
é seguro pois estas bandeiras irão ser despojadas quando se
compila bibliotecas partilhadas. Caso contrário em projetos que
compilam ambos programas e bibliotecas partilhadas você pode precisar
de certificar que quando compila as bibliotecas partilhadas,
-fPIC seja
sempre passado em último (para que sobreponha qualquer
-PIE
anterior) às bandeiras de compilação tais como
CFLAGS, e
-shared é passado em último (para que
sobreponha qualquer
-pie anterior) para ligar em link bandeiras tais
como
LDFLAGS.
Nota: Isto não deve ser necessário
com a maquinaria de specs gcc predefinida.
Adicionalmente, como PIE é implementado via registo geral, algumas
arquitecturas com falta de registo (mas não incluindo mais a i386 desde
as optimizações implementadas no gcc >= 5) podem ver perdas
de performance até aos 15% em grandes cargas de
aplicações de segmentos de texto pesados; a maioria das cargas
vêm menos de 1%. Arquitecturas com registos mais gerais (ex. amd64)
não vêm mais alto que uma penalidade de pior caso.
As opções de tempo de compilação detalhadas em baixo
podem ser usadas para ajudar a melhorar a reprodutibilidade de
compilação ou fornecer mensagens de aviso adicionais durante a
compilação. Excepto como notado em baixo, estas estão
activadas por predefinição para as arquitecturas que as
suportam.
- timeless
- Esta definição (activada por
predefinição) adiciona -Wdate-time a CPPFLAGS.
Isto irá causar avisos quando as macros __TIME__,
__DATE__ e __TIMESTAMP__ são usadas.
- fixfilepath
- Esta definição (activada por
predefinição) adiciona
-ffile-prefix-map=BUILDPATH =. a CFLAGS,
CXXFLAGS, OBJCFLAGS, OBJCXXFLAGS, GCJFLAGS,
FFLAGS e FCFLAGS quando BUILDPATH está
definido para o directório de nível de topo do pacote a ser
compilado. Isto tem o efeito de remover o caminho de
compilação de qualquer ficheiro gerado.
Se ambas fixdebugpath e fixfilepath forem definidas, esta
opção toma precedência, porque é um
superconjunto do anterior.
- fixdebugpath
- Esta definição (activada por
predefinição) adiciona
-fdebug-prefix-map=BUILDPATH =. a CFLAGS,
CXXFLAGS, OBJCFLAGS, OBJCXXFLAGS, GCJFLAGS,
FFLAGS e FCFLAGS quando BUILDPATH está
definido para o directório de nível de topo do pacote a ser
compilado. Isto tem o efeito de remover o caminho de
compilação de qualquer símbolo de
depuração ficheiro gerado.
Existem 2 conjuntos de variáveis de ambiente a fazer as mesmas
operações, O primeiro (DEB_
flag_
op) nunca deve
ser usada dentro de
debian/rules. Destina-se a qualquer utilizador que
queria recompilar o pacote fonte com bandeiras de compilação
diferentes. O segundo conjunto (DEB_
flag_MAINT_
op) só
deve ser usado em
debian/rules pelos maintainers de pacotes para
alterar as bandeiras de compilação resultantes.
-
DEB_flag_SET
-
DEB_flag_MAINT_SET
- Esta variável pode ser usada para forçar o
valor retornado para a <flag> fornecida.
-
DEB_flag_STRIP
-
DEB_flag_MAINT_STRIP
- Esta variável pode ser usada para disponibilizar uma
lista separada por espaços das opções que irão
ser despojadas do conjunto de flags retornado para a flag
fornecida.
-
DEB_flag_APPEND
-
DEB_flag_MAINT_APPEND
- Esta variável pode ser usada para acrescentar
opções suplementares ao valor retornado para a flag
fornecida.
-
DEB_flag_PREPEND
-
DEB_flag_MAINT_PREPEND
- Esta variável pode ser usada para adicionar
opções suplementares ao inicio do valor retornado para a
flag fornecida.
- DEB_BUILD_OPTIONS
- DEB_BUILD_MAINT_OPTIONS
- Estas variáveis podem ser usadas por um utilizador
ou maintainer para desactivar/activar várias funcionalidades de
área que afectam bandeiras de compilação. A
variável DEB_BUILD_MAINT_OPTIONS sobrepõe qualquer
definição nas áreas de funcionalidade de
DEB_BUILD_OPTIONS. Veja a secção ÁREAS DE
CARACTERÍSTICAS para detalhes.
- DEB_VENDOR
- Esta definição define o fornecedor actual. Se
não definida, irá descobrir o fornecedor actual ao ler
/etc/dpkg/origins/default.
- DEB_BUILD_PATH
- Esta variável define o caminho de
compilação (desde dpkg 1.18.8) a usar em funcionalidades
como fixdebugpath para que possam ser controladas pelo chamador.
Esta variável é actualmente específica de Debian e
derivados.
- DPKG_COLORS
- Define o modo de cor (desde dpkg 1.18.5). Os valores
actualmente aceites são: auto (predefinido), always e
never.
- DPKG_NLS
- Se definida, será usada para decidir se deve activar
o Suporte a Linguagem Nativa. Também como conhecido como suporte de
internacionalização (ou i18n) (desde dpkg 1.19.0). Os
valores aceites são 0 e 1
(predefinição).
- /etc/dpkg/buildflags.conf
- Ficheiro de configuração geral do
sistema.
-
$XDG_CONFIG_HOME/dpkg/buildflags.conf
ou
-
$HOME/.config/dpkg/buildflags.conf
- Ficheiro de configuração do utilizador.
- /usr/share/dpkg/buildflags.mk
- trecho do Makefile que irá carregar (e opcionalmente
exportar) todas as bandeiras suportadas pelo dpkg-buildflags em
variáveis (desde dpkg 1.16.1).
Para passar flags de compilação a um comando de
compilação dentro de um Makefile:
$(MAKE) $(shell dpkg-buildflags --export=cmdline)
./configure $(shell dpkg-buildflags --export=cmdline)
Para definir bandeiras de compilação num script de shell ou num
fragmento de shell, por ser usado o
eval para interpretar o resultado e
para exportar as bandeiras no ambiente:
eval "$(dpkg-buildflags --export=sh)" && make
ou para definir os parâmetros posicionais a passar a um comando:
eval "set -- $(dpkg-buildflags --export=cmdline)"
for dir in a b c; do (cd $dir && ./configure "$@" && make); done
Você deve chamar
dpkg-buildflags ou incluir
buildflags.mk
do ficheiro
debian/rules para obter as bandeiras de
compilação necessárias para passar ao sistema de
compilação. Note que versões antigas do
dpkg-buildpackage (antes do dpkg 1.16.1) exportavam estas bandeiras
automaticamente. No entanto, você não deve confiar nisto, pois
isto quebra a invocação manual de
debian/rules.
Para pacotes com sistemas de compilação tipo autoconf, você
pode passar as opções relevantes ao configure ou
make(1)
directamente, como mostrado em cima.
Para outros sistemas de compilação, ou quando precisa de um
controle mais afinado acerca de quais bandeiras são passadas para onde,
você pode usar
--get. Ou você pode incluir
buildflags.mk em vez disto, o que toma conta de chamar
dpkg-buildflags e guardar as bandeiras de compilação em
variáveis do make.
Se você quiser exportar todas as bandeiras de compilação
para o ambiente (onde elas pode ser colhidas pelo seu sistema de
compilação):
DPKG_EXPORT_BUILDFLAGS = 1
include /usr/share/dpkg/buildflags.mk
Para algum controle extra sobre o que é exportado, você pode
exportar manualmente as variáveis (pois nenhuma é exportada por
predefinição).
include /usr/share/dpkg/buildflags.mk
export CPPFLAGS CFLAGS LDFLAGS
E claro que você pode passar as bandeiras aos comandos manualmente:
include /usr/share/dpkg/buildflags.mk
build-arch:
$(CC) -o hello hello.c $(CPPFLAGS) $(CFLAGS) $(LDFLAGS)
Américo Monteiro
Se encontrar algum erro na tradução deste documento, por favor
comunique para Américo Monteiro <
[email protected]>.