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 precedê-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, estada das
bandeiras de funcionalidades, e 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
Area: reproducible
Features:
timeless=no
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). 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
Feature: stackprotector
Enabled: yes
- --help
- Mostra a mensagem de utilização e termina.
- --version
- Mostra a versão e termina.
- 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).
ÁREAS DE CARACTERÍSTICAS
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
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 é necessário
para tirar vantagem de Address Space Layout Randomization, 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 com 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 qo 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
<a_monteiro@gmx.com>.