Provided by: dpkg-dev_1.22.6ubuntu6_all bug

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.  temporärt av användaren med miljövariabler (se stycket "MILJÖ").

       4.  dynamiskt av paketansvariga med miljövariabler som sätts via debian/rules (se stycket
           "MILJÖ").

       Konfigurationsfilerna kan innehålla fyra sorters direktiv:

       SET flagga värde
           Överstyr flaggan flagga till att ha värdet värde.

       STRIP flagga värde
           Ta bort alla flaggor som listas i värde från flaggan som anges i flagga. Sedan dpkg
           1.16.1.

       APPEND flagga värde
           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.

       PREPEND flagga värde
           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

       --dump
           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.

       --list
           Skriv ut listan över flaggor som stöds av den aktuella leverantören (en per rad). Se
           stycket "FLAGGOR SOM STÖDS" för mer information om dem.

       --status
           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.

       --export=format
           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:

           sh  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.

           cmdline
               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.

           configure
               Detta är ett gammalt alias för cmdline.

           make
               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.

       --get flagga
           Skriv ut värdet på flaggan på standard ut. Avslutar med 0 om flaggan är känd, om inte
           avslutar den med 1.

       --origin flagga
           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:

           vendor
               originalflagga satt av leverantören returneras;

           system
               flaggan är satt/modifierad av systemkonfigurationen;

           user
               flaggan är satt/modifierad av användarkonfigurationen;

           env flaggan är satt/modifierad av en miljöspecifik konfiguration.

       --query
           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=3
            Origin: vendor

       --query-features område
           Print the features enabled for a given area (since dpkg 1.16.2). If the feature is
           handled (even if only on some architectures) as a builtin default by the compiler,
           then a Builtin field is printed (since dpkg 1.21.14). See the "FEATURE AREAS" section
           for more details about the currently recognized areas. Exits with 0 if the area is
           known otherwise exits with 1.

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

            Feature: pie
            Enabled: yes
            Builtin: yes

            Feature: stackprotector
            Enabled: yes

       --help
           Visar hjälpskärm och avslutar.

       --version
           Visar version och avslutar.

FLAGGOR SOM STÖDS

       ASFLAGS
           Flaggor för värdassemblern. Förvalt värde: tomt. Sedan dpkg 1.21.0.

       CFLAGS
           Flaggor för värd-C-kompilatorn. Standardvärdet som satts av leverantören innehåller -g
           och den förvalda optimeringsnivån (vanligtvis -O2, eller -O0 om miljövariabeln
           DEB_BUILD_OPTIONS definierar noopt).

       CPPFLAGS
           Flaggor för värd-C-förprocesseraren. Förvalt värde: tomt.

       CXXFLAGS
           Flaggor för värd-C++-kompilatorn. Samma som CFLAGS.

       OBJCFLAGS
           Flaggor för värd-Objective C-kompilatorn. Samma som CFLAGS. Sedan dpkg 1.17.7.

       OBJCXXFLAGS
           Flaggor för värd-Objective C++-kompilatorn. Samma som CXXFLAGS. Sedan dpkg 1.17.7.

       DFLAGS
           Flaggor för värd-D-kompilatorn (ldc eller gdc). Sedan dpkg 1.20.6.

       FFLAGS
           Flaggor för värd-Fortran 77-kompilatorn. En delmängd av CFLAGS.

       FCFLAGS
           Flaggor för värd-Fortran 9x-kompilatorn. Samma som FFLAGS. Sedan dpkg 1.17.7.

       LDFLAGS
           Flaggor som sänds till värdkompilatorn vid länkning av binärer eller delade objekt (om
           länkaren anropas direkt måste -Wl och , tas bort från dessa flaggor). Standardvärde:
           tomt.

       ASFLAGS_FOR_BUILD
           Flaggor för bygg-assemblern. Förvalt värde: tomt. Sedan dpkg 1.22.1.

       CFLAGS_FOR_BUILD
           Flaggor för bygg-C-kompilatorn. Standardvärdet som satts av leverantören innehåller -g
           och den förvalda optimeringsnivån (vanligtvis -O2, eller -O0 om miljövariabeln
           DEB_BUILD_OPTIONS definierar noopt). Sedan dpkg 1.22.1.

       CPPFLAGS_FOR_BUILD
           Flaggor för bygg-C-förprocesseraren. Förvalt värde: tomt. Sedan dpkg 1.22.1.

       CXXFLAGS_FOR_BUILD
           Flaggor för bygg-C++-kompilatorn. Samma som CFLAGS_FOR_BUILD. Sedan dpkg 1.22.1.

       OBJCFLAGS_FOR_BUILD
           Flaggor för bygg-Objective C-kompilatorn. Samma som CFLAGS_FOR_BUILD. Sedan dpkg
           1.22.1.

       OBJCXXFLAGS_FOR_BUILD
           Flaggor för bygg-Objective C++-kompilatorn. Samma som CXXFLAGS_FOR_BUILD. Sedan dpkg
           1.22.1.

       DFLAGS_FOR_BUILD
           Flaggor för bygg-D-kompilatorn (ldc eller gdc). Sedan dpkg 1.22.1.

       FFLAGS_FOR_BUILD
           Flaggor för bygg-Fortran 77-kompilatorn. En delmängd av CFLAGS_FOR_BUILD. Sedan dpkg
           1.22.1.

       FCFLAGS_FOR_BUILD
           Flaggor för bygg-Fortran 9x-kompilatorn. Samma som FFLAGS_FOR_BUIDL. Sedan dpkg
           1.22.1.

       LDFLAGS_FOR_BUILD
           Flaggor som sänds till bygg-kompilatorn vid länkning av binärer eller delade objekt
           (om länkaren anropas direkt måste -Wl och , tas bort från dessa flaggor).
           Standardvärde: tomt. Sedan 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

       Feature areas are currently vendor specific, and the ones described below are only
       recognized on Debian and derivatives.

       Each area feature can be enabled and disabled in the DEB_BUILD_OPTIONS and
       DEB_BUILD_MAINT_OPTIONS environment variable's area value with the ‘+’ and ‘-’ modifier.
       Following the general syntax of these variables (described in dpkg-buildpackage(1)),
       multiple feature areas can be specified separated by spaces, where each get feature
       specifiers as mandatory parameters after an equal sign (‘=’). The feature specifiers are
       comma-separated and parsed from left to right, where the settings within the same feature
       specifier override previous ones, even if the feature specifiers are split across multiple
       space-separated feature area settings for the same area.

       For example, to enable the hardening “pie” feature and disable the “fortify” feature you
       can do this in 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

       Multiple feature areas can be set:

           export DEB_BUILD_MAINT_OPTIONS = hardening=+pie abi=+lfs

       The override behavior applies as much to the all special feature, as to specific features,
       which should allow for composition. Thus to enable “lfs” in the abi area, and only “pie”
       and “fortify” in the hardening area, but “format” only when CONDITION is defined, this
       could be done with:

           export DEB_BUILD_MAINT_OPTIONS = hardening=-all,+pie,+format abi=+lfs
           …
           DEB_BUILD_MAINT_OPTIONS += hardening=+fortify
           ifdef CONDITION
           DEB_BUILD_MAINT_OPTIONS += hardening=-format
           endif

   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.

       lfs 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.

       time64
           This setting (since dpkg 1.22.0; enabled by default except for i386, hurd-i386 and
           kfreebsd-i386 since dpkg 1.22.5) enables 64-bit time_t support on 32-bit architectures
           where their ABI does not include it by default, by adding -D_TIME_BITS=64 to CPPFLAGS.
           This setting automatically enables the lfs feature from the abi feature area.

           If the setting is enabled explicitly then it gets enabled on all architectures
           including i386 but not hurd-i386 nor kfreebsd-i386 (where the kernel does not have
           time64 interfaces), ignoring the binary backwards compatibility default.

           It is also enabled by default by gcc on the armel, armhf, hppa, m68k, mips, mipsel,
           powerpc and sh4 Debian architectures, where disabling the feature will add instead
           -U_LARGEFILE_SOURCE -U_FILE_OFFSET_BITS -U_TIME_BITS to CPPFLAGS.

   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.

       lfs 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.

       bug-implicit-func
           This setting (since dpkg 1.22.3; enabled by default since dpkg 1.22.6) adds
           -Werror=implicit-function-declaration to CFLAGS.

       bug 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.

           This feature handles -Werror=implicit-function-declaration via the bug-implicit-func
           feature, if that has not been specified.

       canary
           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.

       lto Inställningen (sedan dpkg 1.2.0; inaktiverad som förval) aktiverar Link Time
           Optimization (optimering vid länkning) genom att lägga till -flto=auto
           -ffat-lto-objects till CFLAGS, CXXFLAGS, OBJCXXFLAGS, FFLAGS, FCFLAGS och 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.

       address
           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.

       thread
           Den här inställningen (sedan dpkg 1.18.0; inaktiverad som förval) lägger till
           -fsanitize=thread till CFLAGS, CXXFLAGS och LDFLAGS.

       leak
           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.

       undefined
           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.

       format
           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”.

       fortify
           Inställningen (sedan dpkg 1.16.1; aktiverad som förval) lägger till
           -D_FORTIFY_SOURCE=3 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.

       stackprotector
           Inställningen (sedan dpkg 1.16.1; aktiverad som förval om stackprotectorstrong inte
           används) lägger till -fstack-protector --param=ssp-buffer-size=4 till CFLAGS,
           CXXFLAGS, OBJCFLAGS, OBJCXXFLAGS, FFLAGS och FCFLAGS. Detta lägger till
           säkerhetskontroller mot stacköverskrivningar, vilket gör att många möjliga
           kodinjiceringsangrepp istället avbryter programmet. I det bästa fallet gör det
           kodinjiceringsangrepp till överbelastnignsangrepp eller icke-problem (beroende på
           programmet).

           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.

       stackprotectorstrong
           Inställningen (sedan dpkg 1.17.11; aktiverad som förval) lägger till
           -fstack-protector-strong till CFLAGS, CXXFLAGS, OBJCFLAGS, OBJCXXFLAGS, FFLAGS och
           FCFLAGS. Detta är en starkare variant av stackprotector, men utan markanta
           prestandaminskningar.

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

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

       stackclash
           Inställningen (sedan dpkg 1.22.0; aktiverad som förval) lägger till
           -fstack-clash-protectionamd64, arm64, armhf och armel till CFLAGS, CXXFLAGS,
           OBJCFLAGS, OBJCXXFLAGS, FFLAGS och FCFLAGS. Detta lägger till kod som förhindrar
           attacker av typen stackkrock.

       btacnh
           Inställningen (sedan dpkg 1.122.0; aktiverad som förval) lägger till -fcf-protectionamd64 och -mbranch-protection=standardarm64 till CFLAGS, CXXFLAGS, OBJCFLAGS,
           OBJCXXFLAGS, FFLAGS and FCFLAGS och FCFLAGS. Detta lägger till förgreningsskydd till
           indirekta anrop, hopp och returer för att under körning kontrollera att de är giltiga.

       relro
           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.

       bindnow
           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.

       pie Den här inställningen (sedan dpkg 1.16.1; utan globalt förval sedan dpkg 1.18.23,
           eftersom den aktiveras som förval numera av gcc på Debianarkitekturerna amd64, arm64,
           armel, armhf, hurd-i386, i386, kfreebsd-amd64, kfreebsd-i386, mips, mipsel, mips64el,
           powerpc, ppc64, ppc64el, riscv64, s390x, sparc och sparc64) lägger till de flaggor som
           krävs för att aktivera eller inaktivera PIE via gcc-specifikationsfiler, om det
           behövs, beroende på om gcc lägger till flaggorna själv på arkitekturen eller inte. Om
           inställningen aktiveras och gcc injicerar flaggorna lägger den inte till Någonting. Om
           inställningen är aktiverad och gcc inte injicerar flaggorna, lägger den till -fPIE
           (via /usr/share/dpkg/pie-compiler.specs) till CFLAGS, CXXFLAGS, OBJCFLAGS,
           OBJCXXFLAGS, FFLAGS och FCFLAGS, samt -fPIE -pie (via /usr/share/dpkg/pie-link.specs)
           till LDFLAGS. När inställningen är inaktiverad och gcc injicerar flaggorna, lägger den
           till -fno-PIE (via /usr/share/dpkg/no-pie-compile.specs) till CFLAGS, CXXFLAGS,
           OBJCFLAGS, OBJCXXFLAGS, FFLAGS och FCFLAGS, samt -fno-PIE -no-pie (via
           /usr/share/dpkg/no-pie-link.specs) till 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:

           inget
               Kan varken länkas till ett PIE-program eller ett delat bibliotek.

           -fPIE
               Kan länkas till alla program, men inte ett delat bibliotek (rekommenderas).

           -fPIC
               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.

       timeless
           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.

       fixfilepath
           Inställningen (sedan dpkg 1.19.1; aktiverad som förval) lägger till
           -ffile-prefix-map=BYGGSÖKVÄG=. till CFLAGS, CXXFLAGS, OBJCFLAGS, OBJCXXFLAGS, FFLAGS
           och FCFLAGS där BYGGSÖKVÄG sätts till toppnivåkatalogen för paketet som byggs. Detta
           får till effekt att byggsökvägen försvinner från alla genererade filer.

           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.

       fixdebugpath
           Inställningen (sedan dpkg 1.18.5; aktiverad som förval) lägger till
           -fdebug-prefix-map=BYGGSÖKVÄG=. till CFLAGS, CXXFLAGS, OBJCFLAGS, OBJCXXFLAGS, FFLAGS
           och FCFLAGS där BYGGSÖKVÄG sätts till toppnivåkatalogen för paketet som byggs. Detta
           får till effekt att byggsökvägen försvinner från alla genererade felsökningssymboler.

           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.

       DEB_flagga_SET
       DEB_flagga_MAINT_SET (Sedan dpkg 1.16.1)
           Denna variabel kan användas för att tvinga fram värdet som returneras för given
           flagga.

       DEB_flagga_STRIP (sedan dpkg 1.16.1)
       DEB_flagga_MAINT_STRIP (sedan dpkg 1.16.1)
           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.

       DEB_flagga_APPEND
       DEB_flagga_MAINT_APPEND (sedan dpkg 1.16.1)
           Denna variabel kan användas för att lägga till ytterligare flaggor till värdet som
           returneras för given flagga.

       DEB_flagga_PREPEND (sedan dpkg 1.16.1)
       DEB_flagga_MAINT_PREPEND (sedan dpkg 1.16.1)
           Denna variabel kan användas för att lägga till ytterligare flaggor först i värdet som
           returneras för given flagga.

       DEB_BUILD_OPTIONS
       DEB_BUILD_MAINT_OPTIONS (sedan dpkg 1.16.1)
           De här variablerna kan användas av en användare eller utvecklare för att slå av/på
           olika områdesfunktioner som påverkar byggflaggorna. Variabeln
           DEB_BUILD_MAINT_OPTIONS-variabeln överstyr alla inställningar i funktionsområden i
           DEB_BUILD_OPTIONS. Se avsnittet "FUNKTIONSOMRÅDEN" för mer information.

       DEB_VENDOR
           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.

       DEB_BUILD_PATH
           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.

       DPKG_COLORS
           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.

       DPKG_NLS
           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.

       För paket med autoconf-liknande byggsystem kan du sända relevanta flaggor direkt till
       configure eller make(1), som visas ovan.

       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.