Scroll to navigation

dpkg-buildflags(1) dpkg suite dpkg-buildflags(1)

NAMN

dpkg-buildflags - returnerar byggflaggor att använda för att bygga paket

SYNOPS

dpkg-buildflags [flagga...] kommando

BESKRIVNING

dpkg-buildflags är ett verktyg för att hämta kompileringsflaggor att använda för att bygga Debianpaket.

De förvalda flaggorna anges av leverantören, men de kan utökas/överstyras på flera sätt:

1.
på hela systemet med /etc/dpkg/buildflags.conf;
2.
för den nuvarande användaren med $XDG_CONFIG_HOME/dpkg/buildflags.conf där $XDG_CONFIG_HOME har standardvärdet $HOME/.config;
3.
temporarily by the user with environment variables (see section "ENVIRONMENT");
4.
dynamically by the package maintainer with environment variables set via debian/rules (see section "ENVIRONMENT").

Konfigurationsfilerna kan innehålla fyra sorters direktiv:

Överstyr flaggan flagga till att ha värdet värde.
Ta bort alla flaggor som listas i värde från flaggan som anges i flagga. Sedan dpkg 1.16.1.
Utöka flaggan flagga genom att lägga till alternativen som anges i värde. Ett blanksteg läggs till före värdet om flaggans nuvarande värde inte är tomt.
Utöka flaggan flagga genom att lägga till alternativen som anges i värde först. Ett blanksteg läggs till efter värdet om flaggans nuvarande värde inte är tomt. Sedan dpkg 1.16.1.

Konfigurationsfilerna kan innehålla kommentarer på rader som börjar med ett nummertecken (#). Även tomma rader ignoreras.

Kommandot introducerades i dpkg 1.15.7..

KOMMANDON

Skriv alla kompileringsflaggor och deras värde på standard ut. En flagga skrivs per rad, avdelade från sitt värde med ett likamedtecken (”flagga=värde”). Detta är standardåtgärden.
Print the list of flags supported by the current vendor (one per line). See the "SUPPORTED FLAGS" section for more information about them.
Visa information som kan vara användbar för att förklara dpkg-buildflags beteende (sedan dpkg 1.16.5): relevanta miljövariabler, aktuell återförsäljare, status för alla funktionsflaggor. Skriv även ut slutgiltiga kompilatorflaggor och deras källa.

Detta är tänkt att köras från debian/rules så att byggloggen innehåller ett tydligt spår över de använda byggflaggorna. Det kan vara användbart för att diagnostisera problem rörande dessa.

Skriv kommandon som kan användas för att exportera alla kompileringsflaggor för något specifikt verktyg. Om format inte anges antas sh. Endast kompileringsflaggor som börjar med en stor bokstav tas med, andra antas att inte vara lämpliga för miljön. Format som stöds:
Skalkommandon för att sätta och exportera alla kompileringsflaggor i miljön. Flaggvärdena citeras så att utdata är redo att utvärderas av ett skal.
Argument att sända till byggprogrammets kommandorad för att använda alla kompileringsflaggor (sedan dpkg 1.17.0). Flaggornas värde citeras enligt skalsyntax.
Detta är ett gammalt alias för cmdline.
Make-direktiv för att sätta och exportera alla kompileringsflaggor i miljön. Utdata kan skrivas till ett makefil-fragment och utvärderas med ett include-direktiv.
Skriv ut värdet på flaggan på standard ut. Avslutar med 0 om flaggan är känd, om inte avslutar den med 1.
Anger ursprunget till flaggan som returneras av --get. Avslutar med 0 om flaggan är känd, om inte avslutar med 1. Ursprunget kan vara ett av följande värden:
originalflagga satt av leverantören returneras;
flaggan är satt/modifierad av systemkonfigurationen;
flaggan är satt/modifierad av användarkonfigurationen;
flaggan är satt/modifierad av en miljöspecifik konfiguration.
Srkiv ut information som kan vara användbar för att förklara programmets beteende: aktuell återförsäljare, relevanta miljövariabler, funktionsområden, status för alla funktionsflaggor, huruvida en funktion hanteras av ett inbyggt förval av kompilatorn (sedan dpkg 1.21.14) och kompilatorflaggorna med sina ursprung (sedan dpkg 1.19.0).

Till exempel:

 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
Skriv ut funktioner aktiverade för ett givet område (sedan dpkg 1.16.2). Om funktionen hanteras (även om bara av några arkitekturer) som ett inbyggt förval av kompilatorn visas fältet Bultin (sedan dpkg 1.21.14). De enda för närvarande kända områdena på Debian och dess derivat är future, qa, reproducible, sanitize och hardening, se avsnittet FUNKTIONSOMRÅDEN för fler detaljer. Avslutar med 0 om området är känt, avslutar annars med 1.

Utdata är på RFC822-headerformat, med en sektion per funktion. Till exempel:

 Feature: pie
 Enabled: yes
 Builtin: yes
 Feature: stackprotector
 Enabled: yes
Visar hjälpskärm och avslutar.
Visar version och avslutar.

FLAGGOR SOM STÖDS

Options for the host assembler. Default value: empty. Since dpkg 1.21.0.
Options for the host C compiler. The default value set by the vendor includes -g and the default optimization level (-O2 usually, or -O0 if the DEB_BUILD_OPTIONS environment variable defines noopt).
Options for the host C preprocessor. Default value: empty.
Options for the host C++ compiler. Same as CFLAGS.
Options for the host Objective C compiler. Same as CFLAGS. Since dpkg 1.17.7.
Options for the host Objective C++ compiler. Same as CXXFLAGS. Since dpkg 1.17.7.
Options for the host D compiler (ldc or gdc). Since dpkg 1.20.6.
Options for the host Fortran 77 compiler. A subset of CFLAGS.
Options for the host Fortran 9x compiler. Same as FFLAGS. Since dpkg 1.17.7.
Options passed to the host compiler when linking executables or shared objects (if the linker is called directly, then -Wl and , have to be stripped from these options). Default value: empty.
Options for the build assembler. Default value: empty. Since dpkg 1.22.1.
Options for the build C compiler. The default value set by the vendor includes -g and the default optimization level (-O2 usually, or -O0 if the DEB_BUILD_OPTIONS environment variable defines noopt). Since dpkg 1.22.1.
Options for the build C preprocessor. Default value: empty. Since dpkg 1.22.1.
Options for the build C++ compiler. Same as CFLAGS_FOR_BUILD. Since dpkg 1.22.1.
Options for the build Objective C compiler. Same as CFLAGS_FOR_BUILD. Since dpkg 1.22.1.
Options for the build Objective C++ compiler. Same as CXXFLAGS_FOR_BUILD. Since dpkg 1.22.1.
Options for the build D compiler (ldc or gdc). Since dpkg 1.22.1.
Options for the build Fortran 77 compiler. A subset of CFLAGS_FOR_BUILD. Since dpkg 1.22.1.
Options for the build Fortran 9x compiler. Same as FFLAGS_FOR_BUILD. Since dpkg 1.22.1.
Options passed to the build compiler when linking executables or shared objects (if the linker is called directly, then -Wl and , have to be stripped from these options). Default value: empty. Since dpkg 1.22.1.

Nya flaggor kan komma att läggas till i framtiden om behovet uppstår (till exempel för att stöda andra språk).

FUNKTIONSOMRÅDEN

Varje områdesfunktion kan aktiveras och inaktiveras i områdesvärdet i miljövariablerna DEB_BUILD_OPTIONS och DEB_BUILD_MAINT_OPTIONS modifierarna ”+” och ”-”. Till exempel, för att aktivera hardening-funktionen ”pie” och inaktivera funktionen ”fortify” genom att ange detta i debian/rules:

    export DEB_BUILD_MAINT_OPTIONS=hardening=+pie,-fortify

Den speciella funktionen all kan användas för att aktivera eller inaktivera alla områdesfunktioner samtidigt. Du kan till exempel inaktivera allt i området hardening och endast aktivera ”format” och ”fortify” med:

    export DEB_BUILD_MAINT_OPTIONS=hardening=-all,+format,+fortify

abi

Flera kommandoradsflaggor (beskrivna nedan) kan användas för att aktivera funktioner som kan ändra ABI:et för ett paket, men som inte kan aktiveras som standard på grund av bakåtkompatibilitetsorsaker såvida de inte samordnas eller kontrolleras var för sig.

Den här inställningen (sedan dpkg 1.22.0; inaktiverad som förval) aktiverar stöd för stora filer på 32-bitars-arkitekturer där deras ABI inte som förval inkluderar LFS, genom att lägga till -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 till CPPFLAGS.

När funktionen är aktiverad kommer den överstyra värdet från samma funktion i funktionsområdet future.

Den här inställningen (sedan dpkg 1.22.0; inaktiverad som förval) aktiverar stöd för 64-bitars time_t på 32-bitars-arkitekturer där deras ABI inte som förval inkluderar det, genom att lägga till -D_TIME_BITS=64 till CPPFLAGS. Inställningen aktiverar automatiskt lfs-funktionerna eftersom den behövs för att den ska fungera.

future

Flera kommandoradsflaggor (beskrivna nedan) kan användas för att aktivera funktioner som borde vara aktiverade som standard, men som inte kan vara det på grund av bakåtkompatibilitetsorsaker.

Den här inställningen (sedan dpkg 1.19.0; inaktiverad som förval) är nu ett alias för funktionen lfs i abi-området, använd den istället. Funktionen från abi-området överstyr den här inställningen.

qa

Flera kommandoradsflaggor (beskrivna nedan) kan användas för att göra det lättare att hitta problem i källkoden eller byggsystemet.

Inställningen (sedan dpkg 1.17.4; inaktiverad som förval) lägger till ytterligare varningar som pålitligt upptäcket problematisk källkod. Varningarna är ödesdigra. De enda flaggor som för närvarande stöds är CFLAGS och CXXFLAGS med flaggorna satt till -Werror=array-bounds, -Werror=clobbered, -Werror=implicit-function-declaration och -Werror=volatile-register-var.
Den här inställningen (sedan dpkg 1.17.14; inaktiverad som förval) lägger till overksamma tjallarflaggor till byggflaggorna, så att byggloggarna kan kontrolleras för att se hur byggflaggor vidarebefordras för att göra det enklare att hitta när vanliga byggflagor utesluts. De enda flaggor som stöds är för närvarande CPPFLAGS, CFLAGS, OBJCFLAGS, CXXFLAGS och OBJCXXFLAGS med flaggorna satta till -D__DEB_CANARY_flag_slumpmässigt-id__, och LDFLAGS satt till -Wl,-z,deb-canary-slumpmässigt-id.

optimize

Flera kommandoradsflaggor (beskrivna nedan) kan användas för att hjälpa till att optimera den skapade binären (sedan dpkg 1.21.0). Observera: om all aktiveras kan dessa flaggor leda till binärartifakter som inte kan reproduceras.

This setting (since dpkg 1.21.0; disabled by default) enables Link Time Optimization by adding -flto=auto -ffat-lto-objects to CFLAGS, CXXFLAGS, OBJCFLAGS, OBJCXXFLAGS, FFLAGS, FCFLAGS and LDFLAGS.

sanitize

Du kan använda flera kompileringsflaggor (se detaljer nedan) för att sanera den färdiga binären mot minnesfördärvningsar, minnesläckor, användning efter frigivning, datakapplöpningsfel i trådar och fel i förbindels med odefinierat beteende. Observera: dessa flaggor bör inte användas för produktionsbygg eftersom de kan minska pålitligheten för korrekt kod, minska säkerheten eller till och med funktionsrikedomen.

Den här inställningen (sedan dpkg 1.18.0; inaktiverad som förval) lägger till -fsanitize=address till LDFLAGS och -fsanitize=address -fno-omit-frame-pointer till CFLAGS och CXXFLAGS.
Den här inställningen (sedan dpkg 1.18.0; inaktiverad som förval) lägger till -fsanitize=thread till CFLAGS, CXXFLAGS och LDFLAGS.
Den här inställningen (sedan dpkg 1.18.0; inaktiverad som förval) lägger till -fsanitize=leak till LDFLAGS. Den inaktiveras automatiskt om antingen funktionen address eller thread aktiveras, eftersom de implicerar den.
Den här inställningen (sedan dpkg 1.18.0; inaktiverad som förval) lägger till -fsanitize=undefined till CFLAGS, CXXFLAGS och LDFLAGS.

hardening

Du kan använda flera kompileringsflaggor (se detaljer nedan) för att härda den färdiga binären mot minnesfördärvningsangrepp, eller för att ge ytterligare varningsmeddelanden under kompileringen. Förutom det som anges nedan aktiveras dessa som standard för arkitekturer som stöder dem.

Inställningen (sedan dpkg 1.16.1; aktiverad som förval) lägger till -Wformat -Werror=format-security till CFLAGS, CXXFLAGS, OBJCFLAGS och OBJCXXFLAGS. Detta kommer att varna om olämplig användning av formatsträngar, och att misslyckas när formatfunktionerna används på ett sätt som representerar möjliga säkerhetsproblem. För närvarande varnar detta om anrop till funktionerna printf och scanf där formatsträngen inte är en fast sträng och när det inte finns några formatargument, som i printf(foo); istället för printf("%s", foo); Detta kan vara ett säkerhetshål om formatsträngen kommer från en obetrodd källa och innehåller ”%n”.
Inställningen (sedan dpkg 1.16.1; aktiverad som förval) lägger till -D_FORTIFY_SOURCE=2 till CPPFLAGS. Kompilatorn har under kodgenereringen kännedom om en hel del information om buffertstorlekar (där tillämpligt) och försöker ersätta osäkra funktionsanrop med obegränsade buffertlängder med längdbegränsade dito. Det här är speciellt användbart för gammal, skräpig kod. Dessutom blockeras formatsträngar i skrivbart minne som innehåller ”%n”. Om ett program är beroende av en sådan formatsträng måste det gås runt i kod.

Observera att för att den här flaggan ska ha någon funktion måste källkoden också kompileras med -O1 eller högre. Om miljövariabeln DEB_BUILD_OPTIONS innehåller noopt kommer stödet för fortify att inaktiverats, på grund av nya varningar som ges av glibc 2.16 och senare.

This setting (since dpkg 1.16.1; enabled by default if stackprotectorstrong is not in use) adds -fstack-protector --param=ssp-buffer-size=4 to CFLAGS, CXXFLAGS, OBJCFLAGS, OBJCXXFLAGS, FFLAGS and FCFLAGS. This adds safety checks against stack overwrites. This renders many potential code injection attacks into aborting situations. In the best case this turns code injection vulnerabilities into denial of service or into non-issues (depending on the application).

Den här funktionen kräver länkning mot glibc (eller ett annat bibliotek som tillhandahåller __stack_chk_fail), så det måste inaktiveras när du bygger med -nostdlib eller -ffreestanding eller liknande.

This setting (since dpkg 1.17.11; enabled by default) adds -fstack-protector-strong to CFLAGS, CXXFLAGS, OBJCFLAGS, OBJCXXFLAGS, FFLAGS and FCFLAGS. This is a stronger variant of stackprotector, but without significant performance penalties.

Om du inaktiverar stackprotector inaktiveras även denna inställning.

Funktionen har samma krav som stackprotector, och kräver dessutom gcc 4.9 eller senare.

This setting (since dpkg 1.22.0; enabled by default) adds -fstack-clash-protection on amd64, arm64, armhf and armel to CFLAGS, CXXFLAGS, OBJCFLAGS, OBJCXXFLAGS, FFLAGS and FCFLAGS. This adds code to prevent stack clash style attacks.
This setting (since dpkg 1.22.0; enabled by default) adds -fcf-protection on amd64 and -mbranch-protection=standard on arm64 to CFLAGS, CXXFLAGS, OBJCFLAGS, OBJCXXFLAGS, FFLAGS and FCFLAGS. This adds branch protection to indirect calls, jumps and returns to check whether these are valid at run-time.
Inställningen (sedan dpkg 1.16.1; aktiverad som förval) lägger till -Wl,-z,relro till LDFLAGS. Vid inläsning av programmet måste länkaren skriva till flera ELF-minnessektioner. Den här inställningen flaggar till inläsaren att dessa sektioner ska göras skrivskyddade innan programmet får kontroll. Detta skyddar huvudsaklingen mot GOT-överskrivningsangrepp. Om inställningen inaktiveras kommer även bindnow att inaktiveras.
Inställningen (sedan dpkg 1.16.1; inaktiverad som förval) lägger till -Wl,-z,now till LDFLAGS. Vid inläsning av programmet löses alla dynamiska symboler, vilket gör att hela PLT kan markeras som skrivskyddad (på grund av relro ovan). Inställningen kan inte aktiveras om relro inte är aktiverad.
This setting (since dpkg 1.16.1; with no global default since dpkg 1.18.23, as it is enabled by default now by gcc on the amd64, arm64, armel, armhf, hurd-i386, i386, kfreebsd-amd64, kfreebsd-i386, mips, mipsel, mips64el, powerpc, ppc64, ppc64el, riscv64, s390x, sparc and sparc64 Debian architectures) adds the required options to enable or disable PIE via gcc specs files, if needed, depending on whether gcc injects on that architecture the flags by itself or not. When the setting is enabled and gcc injects the flags, it adds nothing. When the setting is enabled and gcc does not inject the flags, it adds -fPIE (via /usr/share/dpkg/pie-compiler.specs) to CFLAGS, CXXFLAGS, OBJCFLAGS, OBJCXXFLAGS, FFLAGS and FCFLAGS, and -fPIE -pie (via /usr/share/dpkg/pie-link.specs) to LDFLAGS. When the setting is disabled and gcc injects the flags, it adds -fno-PIE (via /usr/share/dpkg/no-pie-compile.specs) to CFLAGS, CXXFLAGS, OBJCFLAGS, OBJCXXFLAGS, FFLAGS and FCFLAGS, and -fno-PIE -no-pie (via /usr/share/dpkg/no-pie-link.specs) to LDFLAGS.

Positionsoberoende exekverbara program (PIE) behövs för att dra fördel av slumpmässig adressrymd (ASLR), vilket stöds av vissa versioner av kärnan. Medan ASLR redan kan användas för datautrymmen i stacken och heap:en (brk och mmap), måste kodområden först kompileras som positionsoberoende. Delade bibliotek gör redan detta (-fPIC), så de drar automatiskt fördel av ASLR medan binära .text-regioner måste byggas med PIE för att uppnå ASLR. När detta sker är ROP-angrepp (Return Oriented Programming) mycket svårare eftersom det inte finns några statiska platser att studsa från i ett minnesfördärvningsangrepp.

PIE är inte kompatibelt med -fPIC, så allmän försiktighet måste tas vid bygge av delade objekt. Men eftersom PIE-flaggorna som skapas injiceras via gcc-specifikationsfiler bör det alltid vara säkert att ovillkorligen sätta dem oberoende av typen av objekt som kompileras eller länkas.

Statiska bibliotek kan användas av program eller andra delade bibliotek. Beroende på vilka flaggor som används för att kompilera objekten inuti ett statisk bibliotek kan dessa vara användas av olika uppsättningar objekt:

Kan varken länkas till ett PIE-program eller ett delat bibliotek.
Kan länkas till alla program, men inte ett delat bibliotek (rekommenderas).
Kan länkas till alla program och delade bibliotek.

Om flaggorna behöver sättas manuellt och gcc:s spec-injektion förbigås, finns det flera saker man behöver tänka på. Att ovillkorligen och explicit sända -fPIE, -fpie eller -pie till ett byggsystem som använder libtool är säkert eftersom flaggorna kommer skalas av när delade bibliotek byggs. På projekt som bygger både program och delade bibliotek kan du annars behöva se till att -fPIC alltid sänds sist i kompileringsflaggor såsom CFLAGS när delade bibliotek byggs (så att den överstyre en tidigare angiven -PIE), och att -shared sänds sist till länkflaggor såsom LDFLAGS (så att den överstyr en tidigare angiven -pie). Observera: Detta behöver inte göras med standard-gcc-specifikationsmaskineriet.

Eftersom PIE i tillägg implementeras med ett generellt register kan vissa arkitekturer med få register (men inte längre i386 eftersom optimeringar implementerats i gcc >= 5) se prestandaförluster upp till 15% i väldigt textsegment-tunga programs körning; de flesta körningar ser mindre än 1%. Arkitekturer med många generella register (t.ex amd64) ser inte en lika stor värsta falls-förlust.

reproducible

Kompileringsflaggorna som anges nedan kan användas för att göra det lättare att reproducera byggbarhet eller tillhandahålla ytterligare varningsflaggor under kompileringen. Förutom det som anges nedan aktiveras dessa som standard för arkitekturer som stöder dem.

Inställningen (sedan dpkg 1.17.14; aktiverad som förval) lägger till -Wdate-time till CPPFLAGS. Detta ger varningar när makrona __TIME__, __DATE__ eller __TIMESTAMP__ används.
This setting (since dpkg 1.19.1; enabled by default) adds -ffile-prefix-map=BUILDPATH=. to CFLAGS, CXXFLAGS, OBJCFLAGS, OBJCXXFLAGS, 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.

Om både fixdebugpath och fixfilepath anges tar denna flagga företräde, eftersom den är en övermängd av den förstnämnda.

Observera: Om byggprocessen fångar byggflaggorna i de slutliga byggobjekten kommer det att göra paketet oreproducerbart. Och även om några av objekten återigen kan göras reproducerbara genom att inaktivera den här flaggan igen kräver det samtidigt att fixdebugpath inaktiveras, vilket kan göra de genererade felsökningssymbolobjekten oreproducerbara. Den bästa lösningen är att sluta fånga byggflaggor.

This setting (since dpkg 1.18.5; enabled by default) adds -fdebug-prefix-map=BUILDPATH=. to CFLAGS, CXXFLAGS, OBJCFLAGS, OBJCXXFLAGS, 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 debug symbols.

Observera: Funktionen har liknande reproduktionsegenskaper som fixfilepath.

MILJÖVARIABLER

Det finns två uppsättningar miljövariabler som utför samma operationer, den första (DEB_flagga_op) bör aldrig användas inuti debian/rules). Den är tänkt för användare som vill bygga om källkodspaketet med andra byggflaggor. Den andra uppsättningen (DEB_flagga_MAINT_op) bör endast användas i debian/rules av paketansvariga för att ändra de slutgiltiga byggflaggorna.

Denna variabel kan användas för att tvinga fram värdet som returneras för given flagga.
Denna variabel kan användas för att tillhandahålla en blankstegsavdelad lista med flaggor som kommer att tas bort från uppsättningen flaggor som ges för given flagga.
Denna variabel kan användas för att lägga till ytterligare flaggor till värdet som returneras för given flagga.
Denna variabel kan användas för att lägga till ytterligare flaggor först i värdet som returneras för given flagga.
These variables can be used by a user or maintainer to disable/enable various area features that affect build flags. The DEB_BUILD_MAINT_OPTIONS variable overrides any setting in the DEB_BUILD_OPTIONS feature areas. See the "FEATURE AREAS" section for details.
Inställningen anger den aktuella återförsäljaren. Om den inte är satt kommer återförsäljaren att identifieras genom att läsa /etc/dpkg/origins/default.
Den här variabeln anger byggsökvägen (sedan dpkg 1.18.8) att använda i funktioner såsom fixdebugpath så att de kan styras av anroparen. Variabeln är för närvarande specifik för Debian och dess derivat.
Väljer färgläge (sedan dpkg 1.18.5). För närvarande godtas följande värden: auto (förval), always och never.
Om satt, används för att bestämma om lokalt språkstöd ska aktiveras, även känt som internationaliseringsstöd (eller i18n) (sedan dpkg 1.19.0). Tillåtna värden är: 0 och 1 (förval).

FILER

Konfigurationsfiler

/etc/dpkg/buildflags.conf
Konfigurationsfil för hela systemet.
$XDG_CONFIG_HOME/dpkg/buildflags.conf eller
$HOME/.config/dpkg-buildflags.conf
Användarens konfigurationsfil.

Paketeringsstöd

/usr/share/dpkg/buildflags.mk
Makefile-klipp som läser in (och eventuellt exporterar) alla flaggor som stöd av dpkg-buildflags till variabler (sedan dpkg 1.16.1).

EXEMPEL

För att sända byggflaggor till en byggkommandorad i en makefil:

 $(MAKE) $(shell dpkg-buildflags --export=cmdline)
 ./configure $(shell dpkg-buildflags --export=cmdline)

För att sätta byggflaggor i ett skalskript eller skalfragment kan eval användas för att tolka utdata och exportera flaggorna i miljön:

 eval "$(dpkg-buildflags --export=sh)" && make

eller för att sätta positionsparametrarna för att sända till ett kommando:

 eval "set -- $(dpkg-buildflags --export=cmdline)"
 for dir in a b c; do (cd $dir && ./configure "$@" && make); done

Använda i debian/rules

Du bör anropa dpkg-buildflags eller inkludera buildflags.mk från filen debian/rules för att hämta de byggflaggor det är nödvändigt att sända till byggsystemet. Observera att äldre versioner av dpkg-buildpackages (före dpkg 1.16.1) exporterade dessa flaggor automatiskt. Du bör dock inte bero på detta, eftersom detta förhindrar körning av debian/rules manuellt.

For packages with autoconf-like build systems, you can pass the relevant options to configure or make(1) directly, as shown above.

I andra byggsystem, eller om du vill ha mer finkorning styrning av vilka flaggor som sänds vart, kan du använda --get. Eller så kan du istället inkludera buildflags.mk, som tar hand om anropet till dpkg-buildflags och lagringen av byggflaggorna i make-variabler.

Om du vill exportera alla byggflaggor till miljön (där de kan fångas upp av ditt byggsystem):

 DPKG_EXPORT_BUILDFLAGS = 1
 include /usr/share/dpkg/buildflags.mk

För extra styrning av vad som expoteras kan du manuellt exportera variablerna (eftersom inga av dem exporteras som standard):

 include /usr/share/dpkg/buildflags.mk
 export CPPFLAGS CFLAGS LDFLAGS

Du kan naturligtvis dessutom manuellt sända flaggorna till kommandon:

 include /usr/share/dpkg/buildflags.mk
 build-arch:
        $(CC) -o hello hello.c $(CPPFLAGS) $(CFLAGS) $(LDFLAGS)

ÖVERSÄTTNING

Peter Krefting och Daniel Nylander.

2023-10-30 1.22.1