abidiff(1)

ABIDIFF(1) — Libabigail

NAMN

abidiff – jämför ABI:er för ELF-filer

abidiff jämför applikationsbinärgränssnitt (ABI, Application Binary Interface) för två delade bibliotek i ELF-format (Executable and Linkable Format). Programmet skriver en meningsfull rapport som beskriver skillnaderna mellan de två ABI:erna.

Det här verktyget kan också jämföra textuella representationer av ABI:t för två ELF-binärer (som skrivs ut av abidw) eller en ELF-binär mot en textuell representation av en annan ELF-binär.

För en omfattande ABI-ändringsrapport mellan två indata-delade bibliotek som inkluderar ändringar om funktions- och variabelundertyp(er), använder abidiff som standard felsökningsinformation i DWARF-format om den finns; annars jämför den gränssnitt med debug-info i CTF- eller BTF-format, om det finns. Till sist, om ingen debug-info i dessa format hittas, beaktas endast ELF-symboler och rapportering sker om att symboler lagts till eller tagits bort.

Det här verktyget använder biblioteket libabigail för att analysera binären samt tillhörande debug-information. Här är dess allmänna arbetssätt.

När verktyget instrueras att göra det läses och analyseras en binär och dess associerade debug-information. För detta analyserar libabigail som standard beskrivningar av de typer som är nåbara från gränssnitt (funktioner och variabler) som är synliga utanför sin översättningsenhet. När analysen är klar byggs ett ABI-korpus (ABI Corpus) genom att bara beakta den delmängd av typer som är nåbara från gränssnitt associerade med ELF-symboler som är definierade och exporterade av binären. Det är detta slutliga ABI-korpus som libabigail ser som representerande ABI:t för den analyserade binären.

Libabigail kan sedan generera textuella representationer av ABI-korpora, jämföra dem, analysera förändringar och rapportera om dem.

ANROP

abidiff [alternativ] <första-delade-biblioteket> <andra-delade-biblioteket>

MILJÖ

abidiff laddar två standardfiler för suppression specifications (undertryckningsspecifikationer), slår ihop deras innehåll och använder dem för att filtrera bort ABI-ändringsrapporter som kan betraktas som falska positiva.

Standard systemomfattande undertryckningsfil

Den hittas via den valfria miljövariabeln LIBABIGAIL_DEFAULT_SYSTEM_SUPPRESSION_FILE. Om den variabeln inte är satt försöker abidiff ladda filen

$libdir/libabigail/libabigail-default.abignore

. Om filen inte finns laddas ingen systemomfattande standardfil.

Standard undertryckningsfil för användaren

Den hittas via den valfria miljövariabeln LIBABIGAIL_DEFAULT_USER_SUPPRESSION_FILE. Om den variabeln inte är satt försöker abidiff ladda filen

$HOME/.abignore

. Om filen inte finns laddas ingen användarstandardfil.

ALTERNATIV

--add-binaries1 <bin1,bin2,bin3,..>

För varje kommaseparerad binär i argumentet: om binären hittas i katalogen som anges av --added-binaries-dir1, laddar abidiff ABI-korpuset för binären och lägger till det i en uppsättning korpora (en ”ABI Corpus Group”) som inkluderar första argumentet till abidiff.

Denna ABI-korpusgrupp jämförs sedan mot den andra korpusgruppen som ges som andra argument till abidiff.

--add-binaries2 <bin1,bin2,bin3,..>

För varje kommaseparerad binär i argumentet: om binären hittas i katalogen som anges av --added-binaries-dir2, laddar abidiff ABI-korpuset för binären och lägger till det i en uppsättning korpora (en ”ABI Corpus Group”) som inkluderar andra argumentet till abidiff.

Denna ABI-korpusgrupp jämförs sedan mot den första korpusgruppen som ges som första argument till abidiff.

--added-binaries-dir1 | --abd1 <katalog-1>

Används tillsammans med --add-binaries1, --follow-dependencies och --list-dependencies. Binärer som refereras av dessa alternativ laddas som ABI-korpus om de finns i katalog-1, och läggs till i den första ABI-korpusgruppen som används i jämförelsen.

--added-binaries-dir2 | --abd2 <katalog-2>

Används tillsammans med --add-binaries2, --follow-dependencies och --list-dependencies. Binärer som refereras av dessa alternativ laddas som ABI-korpus om de finns i katalog-2, och läggs till i den andra ABI-korpusgruppen som används i jämförelsen.

--added-fns

I rapporten, visa endast globalt definierade funktioner som lades till i andra-delade-biblioteket.

--added-vars

I rapporten, visa endast globala variabler som lades till (definierades) i andra-delade-biblioteket.

--allow-non-exported-interfaces

När verktyget läser debug-info analyseras typer nåbara från gränssnitt synliga utanför sin översättningsenhet. Därefter byggs ABI-korpus normalt bara från typer nåbara från gränssnitt associerade med definierade och exporterade ELF-symboler, och det är de ABI-korpora som jämförs.

Nackdelen är att analys av ”alla synliga gränssnitt” kan bli enorm, särskilt för applikationer (t.ex. Linux-kärnan), vilket kan bli mycket långsamt.

Med ”lagom stora” binärer kan man dock ha råd att analysera alla sådana gränssnitt med detta alternativ.

Obs: detta alternativ är aktiverat som standard, om man inte är i närvaro av Linux-kärnan.

--btf

Vid jämförelse av binärer, extrahera ABI-information från BTF-debug-info, om den finns.

--changed-fns

I rapporten, visa endast ändringar i undertyper för globala funktioner definierade i första-delade-biblioteket.

--changed-vars

I rapporten, visa endast ändringar i undertyper för globala variabler definierade i första-delade-biblioteket.

--ctf

Vid jämförelse av binärer, extrahera ABI-information från CTF-debug-info, om den finns.

--debug-info-dir1 | --d1 <di-sökväg1>

För fall där debug-information för första-delade-biblioteket är uppdelad i en separat fil anger detta var den separata debug-filen finns.

di-sökväg1 måste peka på rotkatalogen där debug-info ligger i en trädstruktur; på Red Hat-baserade system brukar det vara

<rot>/usr/lib/debug

.

Kan anges flera gånger med olika rotkataloger; då letar abidiff i alla.

Alternativet är normalt inte nödvändigt om split debug-info installerats via paket­hanteraren, eftersom abidiff då vet var den finns.

--debug-info-dir2 | --d2 <di-sökväg2>

Som --debug-info-dir1, men för andra-delade-biblioteket. Kan också anges flera gånger.

--debug-self-comparison

I detta läge skrivs felmeddelanden för typer som misslyckas med typkanonisering när en binär jämförs med sig själv. Vid diskrepanser skickas abort-signal och körningen stoppas. Avsett för felsökning i debugger.

Kräver att libabigail byggts med configure-alternativet

--enable-debug-self-comparison

.

--debug-tc

Skärper granskningen av typkanonisering: varje typjämförelse görs två gånger (strukturellt och kanoniskt). Om resultaten skiljer aborteras processen. Avsett för felsökning.

Kräver att libabigail byggts med

--enable-debug-type-canonicalization

.

--deleted-fns

I rapporten, visa endast globalt definierade funktioner som togs bort från första-delade-biblioteket.

--deleted-vars

I rapporten, visa endast globalt definierade variabler som togs bort från första-delade-biblioteket.

--drop <regex>

När ELF-indata läses: droppa globalt definierade funktioner och variabler vars namn matchar regex. Då rapporteras inga ändringar som rör dem.

--drop-fn <regex>

Som --drop, men endast funktioner.

--drop-var <regex>

Som --drop, men endast variabler.

--drop-private-types

Används med --headers-dir1, --header-file1, --header-file2 och --headers-dir2. Med detta alternativ droppas typer som inte definieras i headers helt från libabigails interna representation. Utan alternativet behålls de internt och filtreras senare ur rapporten.

Kan minska minnesåtgången och är främst tänkt att optimera minnesförbrukning för binärer med många publika exporterade typer.

--dump-diff-tree

Efter diff-rapporten, skriv en textuell representation av diff-nodträdet som används för att representera ändrade funktioner och variabler. Skickas till felutmatningen (stderr) för felsökning. Gäller endast ändringar med undertypförändringar; tillagda/borttagna symboler har inget sådant träd.

--exported-interfaces-only

Som standard analyseras typer nåbara från gränssnitt synliga utanför sin översättningsenhet, men ABI-korpus byggs från typer nåbara från gränssnitt associerade med definierade och exporterade ELF-symboler – och det är dessa ABI-korpora som jämförs.

Att analysera alla ”extern-synliga gränssnitt” kan vara mycket datatungt för applikationer (t.ex. Linux-kärnan) och långsamt.

Detta alternativ gör att libabigail endast analyserar typer nåbara från gränssnitt associerade med definierade och exporterade ELF-symboler, för bättre prestanda.

Obs: detta alternativ är på som standard när Linux-kärnan analyseras; annars av som standard.

--fail-no-debug-info

Om ingen debug-info hittas, gör detta att programmet misslyckas. Utan alternativet försöker programmet annars jämföra icke-debug-relaterade egenskaper (t.ex. rena ELF-egenskaper).

--follow-dependencies | --fdeps

För varje beroende till första argumentet: om det hittas i katalogen från --added-binaries-dir1, bygg ett ABI-korpus för beroendet och lägg till det i en ABI-korpusgrupp som inkluderar första argumentet.

Motsvarande görs för andra argumentet med --added-binaries-dir2.

Dessa två ABI-korpusgrupper jämförs sedan. Dvs: jämför ”indata + beroenden” för båda sidor.

--harmless

I diff-rapporten, visa endast harmlösa ändringar. Som standard filtreras harmlösa ändringar bort för mindre brus och större chans att se riktiga ABI-problem.

--headers-dir1 | --hd1 <headers-katalog-1>

Anger var publika headers för första biblioteket/binären finns. Verktyget filtrerar då bort ABI-ändringar på typer som inte är definierade i publika headers.

Kan anges flera gånger för flera kataloger. Exempel:

abidiff --headers-dir1 /some/path       \
       --headers-dir1 /some/other/path \
       binary-version-1 binary-version-2

--headers-dir2 | --hd2 <headers-katalog-2>

Som --headers-dir1, men för andra biblioteket. Kan anges flera gånger.

--header-file1 | --hf1 <header-fil-1>

Anger en publik headerfil för första biblioteket som ska beaktas, för filtrering till publika typer.

--header-file2 | --hf2 <header-fil-2>

Anger en publik headerfil för andra biblioteket som ska beaktas.

--help | -h

Visa kort hjälp och avsluta.

--ignore-soname

Ignorera skillnader i SONAME vid jämförelse.

--impacted-interfaces

När ”leaf changes” visas instruerar detta att listan över påverkade gränssnitt ska visas. Ska användas tillsammans med --leaf-changes-only, annars ignoreras det.

--keep <regex>

När ELF-indata läses: behåll globalt definierade funktioner och variabler vars namn matchar regex. Alla andra droppas och syns inte i rapporten.

--keep-fn <regex>

Som --keep, men endast funktioner.

--keep-var <regex>

Som --keep, men endast variabler.

--kmi-whitelist | -w <sökväg-till-whitelist>

Vid analys av Linux-kärna: pekar på en vitlista över ELF-symbolnamn (funktioner/variabler) vars ABI ska beaktas. Kallas ”Kernel Module Interface white list” (KMI), eftersom man för kärnan talar om gränssnittet mellan kärna och moduler.

Symboler som inte finns i vitlistan beaktas inte.

Om alternativet inte ges beaktas hela KMI (alla publikt definierade och exporterade funktioner samt globala variabler i Linux-kärnan).

--leaf-changes-only | -l

Visa endast leaf changes (visa inte impact analysis-rapport). Detta innebär --redundant.

Typisk utmatning kan visa hur en leaf change nås från ett gränssnitt; med detta alternativ visas endast leaf change, och (om --impacted-interfaces används) en lista över påverkade gränssnitt.

--list-dependencies | --ldeps

Lista alla beroenden till indataargumenten som hittas i katalogerna från --added-binaries-dir1 och --added-binaries-dir2.

--no-added-syms

I rapporten, visa inte tillagda funktioner eller variabler. Visa inte heller deras ELF-symboler. Alla andra typer av ändringar visas om de inte förbjuds av andra alternativ.

--no-assume-odr-for-cplusplus

Vid analys av C++-binärer med DWARF antar libabigail One Definition Rule för att snabba upp: flera typer med samma namn antas lika. Detta alternativ stänger av antagandet och tvingar verklig jämförelse.

--no-architecture

Ta inte hänsyn till arkitektur vid ABI-jämförelse.

--no-change-categorization | -x

Stäng av kategorisering i harmlösa/skadliga ändringar. Eftersom kategorisering krävs för filtrering stängs även filtrering av. Syftet är att snabba upp när förändringsgrafen är enorm och man bara vill titta på t.ex. leaf changes utan att bry sig om impact. Används då ofta med --leaf-changes-only.

--no-corpus-path

Skriv inte ut path-attributet för ABI-korpuset.

--no-default-suppression

Ladda inte standardfilerna för undertryckningsspecifikationer.

--no-harmful

Visa inte skadliga ändringar. Som standard är det normalt skadliga ändringar som visas.

--no-leverage-dwarf-factorization

När DWARF-debug-info bearbetats av verktyget DWZ antas typinformationen redan vara faktoriserad och libabigail kan optimera. Detta alternativ stänger av de optimeringarna.

--no-linkage-name

Visa inte länk-namnen (linkage names) för tillagda, borttagna eller ändrade funktioner/variabler.

--no-linux-kernel-mode

Utan detta alternativ, om abidiff upptäcker Linux-kärn-binärer (vmlinux eller moduler), beaktas bara funktioner/variabler vars ELF-symboler listas i sektionerna __ksymtab och __ksymtab_gpl.

Med detta alternativ behandlas binären som en vanlig ELF och då beaktas ELF-definierade och exporterade symboler.

--no-redundant

Visa inte redundanta ändringar (ändringar som redan visats någon annanstans i rapporten). Detta är på som standard.

--no-show-locs

Visa inte information om var i andra biblioteket respektive typ ändrades.

--no-show-relative-offset-changes

Utan detta alternativ, när offset för en datamedlem ändras, visas både gammal/ny offset och med hur många bitar den flyttades. Med detta alternativ visas inte den senare delen.

--no-unreferenced-symbols

Visa inte ändringsinfo om funktions- och variabelsymboler som inte refereras av någon debug-info. För sådana symboler är den info som annars visas endast tillagda eller borttagna symboler.

--non-reachable-types | -t

Analysera och rapportera ändringar för alla typer i binären, inklusive de som inte är nåbara från globala funktioner och variabler.

Kan ge stor prestandasmäll. Om det paras med --headers-dir{1,2} och/eller --header-file{1,2} begränsas extra typer till de som definieras i publika headers, vilket kan göra det mer acceptabelt.

Tillsammans med undertryckningsspecifikationer (--suppressions) kan man hålla mängden analyserade typer under kontroll.

Utan detta alternativ analyseras bara typer nåbara från globala funktioner och variabler.

--redundant

Visa redundanta ändringar (ändringar som redan visats någon annanstans i rapporten).

--show-bits

Visa storlekar och offset i bitar, inte bytes. Detta är aktivt som standard.

--show-bytes

Visa storlekar och offset i bytes, inte bitar.

--show-dec

Visa storlekar och offset i decimal bas. Detta är aktivt som standard.

--show-hex

Visa storlekar och offset i hexadecimal bas.

--stat

Visa endast sammanfattande statistik över skillnader, i stället för detaljerad diff.

--stats

Skriv statistik om olika interna saker.

--suppressions | --suppr <sökväg-till-suppressions>

Använd en undertryckningsspecifikationsfil vid sökväg-till-suppressions. Kan anges flera gånger; då beaktas alla angivna filer.

Om alternativet inte anges laddas standard-undertryckningsfiler som standard.

--symtabs

Visa endast symboltabellerna för första-delade-biblioteket och andra-delade-biblioteket.

--verbose

Skriv utförliga loggar om framsteg och interna saker.

--version | -v

Visa programversion och avsluta.

RETURVÄRDEN

Returkoden från kommandot abidiff är antingen 0 om ABI:t för binärerna som jämförs är lika, eller icke-noll om de skiljer sig eller om verktyget stötte på ett fel.

I det senare fallet är returkoden ett 8-bitars bitfält där varje bit har en särskild betydelse.

Första biten (värde 1), ABIDIFF_ERROR, betyder att ett fel inträffade.

Andra biten (värde 2), ABIDIFF_USAGE_ERROR, betyder att användaren anropade verktyget felaktigt (t.ex. okänd flagga, fel antal argument, osv). Om denna bit är satt måste även ABIDIFF_ERROR vara satt.

Tredje biten (värde 4), ABIDIFF_ABI_CHANGE, betyder att ABI:t för de jämförda binärerna skiljer sig.

Fjärde biten (värde 8), ABIDIFF_ABI_INCOMPATIBLE_CHANGE, betyder att ABI:t skiljer sig på ett inkompatibelt sätt. Om denna bit är satt måste även ABIDIFF_ABI_CHANGE vara satt. Om ABIDIFF_ABI_CHANGE är satt och ABIDIFF_INCOMPATIBLE_CHANGE inte är satt innebär det att ABI:erna kan vara kompatibla eller inte – en människa måste granska ändringarna.

Obs: just nu finns bara några få typer av ABI-ändringar som leder till att ABIDIFF_ABI_INCOMPATIBLE_CHANGE sätts:

• borttagning av symbolen för en funktion eller variabel som är definierad och exporterad
• ändring av index för en medlem i en virtuell funktionstabell (för C++-program och -bibliotek)

Med tiden, när fler mönster hittas som alltid innebär inkompatibla ABI-ändringar, kommer koden att anpassas för att känna igen dem och sätta ABIDIFF_ABI_INCOMPATIBLE_CHANGE i dessa fall. Om du hittar sådana mönster, tala om det.

Övriga bitar används inte för tillfället.

ANVÄNDNINGSEXEMPEL

1. Upptäcka en ABI-ändring i en undertyp till en funktion:

$ cat -n test-v0.cc
         1      // Compile this with:
         2      //   g++ -g -Wall -shared -o libtest-v0.so test-v0.cc
         3
         4      struct S0
         5      {
         6        int m0;
         7      };
         8
         9      void
        10      foo(S0* /*parameter_name*/)
        11      {
        12        // do something with parameter_name.
        13      }
$
$ cat -n test-v1.cc
         1      // Compile this with:
         2      //   g++ -g -Wall -shared -o libtest-v1.so test-v1.cc
         3
         4      struct type_base
         5      {
         6        int inserted;
         7      };
         8
         9      struct S0 : public type_base
        10      {
        11        int m0;
        12      };
        13
        14      void
        15      foo(S0* /*parameter_name*/)
        16      {
        17        // do something with parameter_name.
        18      }
$
$ g++ -g -Wall -shared -o libtest-v0.so test-v0.cc
$ g++ -g -Wall -shared -o libtest-v1.so test-v1.cc
$
$ abidiff libtest-v0.so libtest-v1.so; echo "exit code: $?"
Functions changes summary: 0 Removed, 1 Changed, 0 Added function
Variables changes summary: 0 Removed, 0 Changed, 0 Added variable

1 function with some indirect sub-type change:

  [C]'function void foo(S0*)' has some indirect sub-type changes:
        parameter 0 of type 'S0*' has sub-type changes:
          in pointed to type 'struct S0':
            size changed from 32 to 64 bits
            1 base class insertion:
              struct type_base
            1 data member change:
             'int S0::m0' offset changed from 0 to 32
exit code: 4
$

Notera att returkoden är 4, vilket betyder att tredje biten ABIDIFF_ABI_CHANGE med värde 4 är satt. Det betyder att verktyget kategoriserar ABI-ändringen som skadlig och att användaren behöver granska.

2. Upptäcka en inkompatibel ABI-ändring i typen för en funktion:

$ cat -n test-v0.cc
     1  // Compile this with:
     2  //   g++ -g -Wall -shared -o libtest-v0.so test-v0.cc
     3
     4  struct S0
     5  {
     6    int m0;
     7  };
     8
     9  S0
    10  foo()
    11  {
    12    S0 s = {};
    13    return s;
    14  }
$
$ cat -n test-v1.cc
     1  // Compile this with:
     2  //   g++ -g -Wall -shared -o libtest-v1.so test-v1.cc
     3
     4  struct type_base
     5  {
     6    int inserted;
     7  };
     8
     9  struct S0 : public type_base
    10  {
    11    int m0;
    12  };
    13
    14  S0
    15  foo()
    16  {
    17    S0 s = {};
    18    return s;
    19  }
$
$ g++ -g -Wall -shared -o libtest-v0.so test-v0.cc
$ g++ -g -Wall -shared -o libtest-v1.so test-v1.cc
$
$ abidiff libtest-v0.so libtest-v1.so; echo "exit code: $?"
Functions changes summary: 0 Removed, 1 Changed, 0 Added function
Variables changes summary: 0 Removed, 0 Changed, 0 Added variable

1 function with incompatible sub-type changes:

  [C] 'function S0 foo(void)' at test-v0.cc:10:1 has some sub-type changes:
    return type changed:
      type size changed from 32 to 64 (in bits)
      1 base class insertion:
        struct type_base at test-v1.cc:4:1
      1 data member change:
        'int m0' offset changed from 0 to 32 (in bits) (by +32 bits)

exit code: 12
$

Notera att returkoden är 12, vilket betyder att både tredje biten ABIDIFF_ABI_CHANGE (värde 4) och fjärde biten ABIDIFF_ABI_INCOMPATIBLE_CHANGE (värde 8) är satta. Det betyder att verktyget klassar ändringen som inkompatibel – ett ABI-brott.

3. Upptäcka en annan ändring i en undertyp av en funktion:

$ cat -n test-v0.cc
         1      // Compile this with:
         2      //   g++ -g -Wall -shared -o libtest-v0.so test-v0.cc
         3
         4      struct S0
         5      {
         6        int m0;
         7      };
         8
         9      void
        10      foo(S0& /*parameter_name*/)
        11      {
        12        // do something with parameter_name.
        13      }
$
$ cat -n test-v1.cc
         1      // Compile this with:
         2      //   g++ -g -Wall -shared -o libtest-v1.so test-v1.cc
         3
         4      struct S0
         5      {
         6        char inserted_member;
         7        int m0;
         8      };
         9
        10      void
        11      foo(S0& /*parameter_name*/)
        12      {
        13        // do something with parameter_name.
        14      }
$
$ g++ -g -Wall -shared -o libtest-v0.so test-v0.cc
$ g++ -g -Wall -shared -o libtest-v1.so test-v1.cc
$
$ abidiff libtest-v0.so libtest-v1.so; echo "exit code: $?"
Functions changes summary: 0 Removed, 1 Changed, 0 Added function
Variables changes summary: 0 Removed, 0 Changed, 0 Added variable

1 function with some indirect sub-type change:

  [C]'function void foo(S0&)' has some indirect sub-type changes:
        parameter 0 of type 'S0&' has sub-type changes:
          in referenced type 'struct S0':
            size changed from 32 to 64 bits
            1 data member insertion:
              'char S0::inserted_member', at offset 0 (in bits)
            1 data member change:
             'int S0::m0' offset changed from 0 to 32

exit code: 4
$

4. Upptäcka att funktioner tagits bort eller lagts till i ett bibliotek:

$ cat -n test-v0.cc
         1      // Compile this with:
         2      //   g++ -g -Wall -shared -o libtest-v0.so test-v0.cc
         3
         4      struct S0
         5      {
         6        int m0;
         7      };
         8
         9      void
        10      foo(S0& /*parameter_name*/)
        11      {
        12        // do something with parameter_name.
        13      }
$
$ cat -n test-v1.cc
         1      // Compile this with:
         2      //   g++ -g -Wall -shared -o libtest-v1.so test-v1.cc
         3
         4      struct S0
         5      {
         6        char inserted_member;
         7        int m0;
         8      };
         9
        10      void
        11      bar(S0& /*parameter_name*/)
        12      {
        13        // do something with parameter_name.
        14      }
$
$ g++ -g -Wall -shared -o libtest-v0.so test-v0.cc
$ g++ -g -Wall -shared -o libtest-v1.so test-v1.cc
$
$ abidiff libtest-v0.so libtest-v1.so; echo "exit code: $?"
Functions changes summary: 1 Removed, 0 Changed, 1 Added functions
Variables changes summary: 0 Removed, 0 Changed, 0 Added variable

1 Removed function:
  'function void foo(S0&)'    {_Z3fooR2S0}

1 Added function:
  'function void bar(S0&)'    {_Z3barR2S0}

exit code: 12
$

5. Jämföra två uppsättningar binärer som anges på kommandoraden:

$ abidiff --add-binaries1=file2-v1              \
          --add-binaries2=file2-v2,file2-v1     \
          --added-binaries-dir1 dir1            \
          --added-binaries-dir2 dir2            \
          file1-v1 file1-v2

Observera att filerna file2-v1 och file2-v2 ska finnas i dir1 respektive dir2 eller i den aktuella katalogen.

6. Jämföra två bibliotek och deras beroenden:

$ abidiff --follow-dependencies                      \
          --added-binaries-dir1 /some/where          \
          --added-binaries-dir2 /some/where/else     \
          foo bar

Detta jämför uppsättningen binärer som består av foo och dess beroenden mot uppsättningen som består av bar och dess beroenden.

FÖRFATTARE

Dodji Seketeli

UPPHOVSRÄTT

2014–2025, Red Hat, Inc.

KOLOFON

Den här sidan är en del av projektet libabigail (ABI Generic Analysis and Instrumentation Library). Information om projektet finns på ⟨[1](https://sourceware.org/libabigail/⟩). Om du har en felrapport för den här manualsidan, se ⟨[2](http://sourceware.org/bugzilla/enter_bug.cgi?product=libabigail⟩).

Sidslut

Orginalhemsidan på Engelska :https://man7.org/linux/man-pages/man1/abidiff.1.html

---

Det här är en maskinöversättning av Linux man sidor till svenska. Om du hittar fel är vi tacksamma om du rapporterar dem via formuläret som finns på https://www.linux.se/kontaka-linux-se/

Tack till PC-Service som har sponsrat Linux.se med webbhotell.