Provided by: abigail-tools_1.6-1_amd64 bug

NAME

       abidiff - compare ABIs of ELF files

       abidiff  compares  the  Application Binary Interfaces (ABI) of two shared libraries in ELF
       format.  It emits a meaningful report describing the differences between the two ABIs.

       This tool can also compare the textual representations of the ABI of two ELF binaries  (as
       emitted by abidw) or an ELF binary against a textual representation of another ELF binary.

       For  a  comprehensive  ABI change report that includes changes about function and variable
       sub-types, the two input shared libraries must be accompanied with their debug information
       in DWARF format.  Otherwise, only ELF symbols that were added or removed are reported.

INVOCATION

          abidiff [options] <first-shared-library> <second-shared-library>

ENVIRONMENT

       abidiff  loads  two default suppression specifications files, merges their content and use
       it to filter out ABI change reports that might be considered as false positives to users.

       · Default system-wide suppression specification file

         It’s       located       by       the        optional        environment        variable
         LIBABIGAIL_DEFAULT_SYSTEM_SUPPRESSION_FILE.   If  that  environment variable is not set,
         then      abidiff       tries       to       load       the       suppression       file
         $libdir/libabigail/libabigail-default.abignore.   If  that  file is not present, then no
         default system-wide suppression specification file is loaded.

       · Default user suppression specification file.

         It’s located by the optional environment  LIBABIGAIL_DEFAULT_USER_SUPPRESSION_FILE.   If
         that  environment  variable  is not set, then abidiff tries to load the suppression file
         $HOME/.abignore.  If that  file  is  not  present,  then  no  default  user  suppression
         specification is loaded.

OPTIONS

          · --help | -h

            Display a short help about the command and exit.

          · --version | -v

            Display the version of the program and exit.

          · --debug-info-dir1 | --d1 <di-path1>

            For  cases  where  the debug information for first-shared-library is split out into a
            separate file, tells abidiff where to find that separate debug information file.

            Note that di-path must point to the root directory under which the debug  information
            is  arranged  in  a tree-like manner.  Under Red Hat based systems, that directory is
            usually <root>/usr/lib/debug.

            This option can be provided several times with different root directories.   In  that
            case, abidiff will potentially look into all those root directories to find the split
            debug info for first-shared-library.

            Note also that this option is not mandatory for split debug information installed  by
            your system’s package manager because then abidiff knows where to find it.

          · --debug-info-dir2 | --d2 <di-path2>

            Like  --debug-info-dir1,  this  options  tells  abidiff where to find the split debug
            information for the second-shared-library file.

            This option can be provided several times with different root directories.   In  that
            case, abidiff will potentially look into all those root directories to find the split
            debug info for second-shared-library.

          · --headers-dir1 | --hd1 <headers-directory-path-1>

            Specifies where to find the public headers of the first shared library that the  tool
            has  to  consider.   The  tool will thus filter out ABI changes on types that are not
            defined in public headers.

          · --headers-dir2 | --hd2 <headers-directory-path-1>

            Specifies where to find the public headers of the second shared library that the tool
            has  to  consider.   The  tool will thus filter out ABI changes on types that are not
            defined in public headers.

          · --no-linux-kernel-mode

            Without this option, if abidiff detects that the binaries it is looking at are  Linux
            Kernel  binaries  (either  vmlinux  or  modules) then it only considers functions and
            variables which ELF symbols are listed in the __ksymtab and __ksymtab_gpl sections.

            With this option, abidiff considers the binary as a non-special ELF binary.  It  thus
            considers functions and variables which are defined and exported in the ELF sense.

          · --kmi-whitelist | -kaw <path-to-whitelist>

            When  analyzing  a Linux kernel binary, this option points to the white list of names
            of ELF symbols of functions and variables which ABI must be considered.   That  white
            list  is  called  a  “Kernel  Module  Interface white list”.  This is because for the
            Kernel, we don’t talk about ABI; we rather  talk  about  the  interface  between  the
            Kernel and its module. Hence the term KMI rather than ABI.

            Any  other  function  or variable which ELF symbol are not present in that white list
            will not be considered by this tool.

            If this option is not provided – thus if no white list is provided – then the  entire
            KMI,  that  is,  the  set  of  all publicly defined and exported functions and global
            variables by the Linux Kernel binaries, is considered.

          · --drop-private-types

            This option is to be used with the --headers-dir1 and --headers-dir2  options.   With
            this  option, types that are NOT defined in the headers are entirely dropped from the
            internal representation build by Libabigail to represent the ABI.   They  thus  don’t
            have  to  be  filtered out from the final ABI change report because they are not even
            present in Libabigail’s representation.

            Without  this  option  however,  those  private  types  are  kept  in  the   internal
            representation and later filtered out from the report.

            This options thus potentially makes Libabigail consume less memory.  It’s meant to be
            mainly used to optimize the memory consumption of the tool on binaries with a lot  of
            publicly defined and exported types.

          · --stat

            Rather  than displaying the detailed ABI differences between first-shared-library and
            second-shared-library, just display some summary statistics about these differences.

          · --symtabs

            Only display the symbol tables of the first-shared-library and second-shared-library.

          · --deleted-fns

            In the resulting  report  about  the  differences  between  first-shared-library  and
            second-shared-library,  only  display the globally defined functions that got deleted
            from first-shared-library.

          · --changed-fns

            In the resulting  report  about  the  differences  between  first-shared-library  and
            second-shared-library,  only display the changes in sub-types of the global functions
            defined in first-shared-library.

          · --added-fns

            In the resulting  report  about  the  differences  between  first-shared-library  and
            second-shared-library, only display the globally defined functions that were added to
            second-shared-library.

          · --deleted-vars

            In the resulting  report  about  the  differences  between  first-shared-library  and
            second-shared-library,  only display the globally defined variables that were deleted
            from first-shared-library.

          · --changed-vars

            In the resulting  report  about  the  differences  between  first-shared-library  and
            second-shared-library,  only  display  the  changes  in  the  sub-types of the global
            variables defined in first-shared-library

          · --added-vars

            In the resulting  report  about  the  differences  between  first-shared-library  and
            second-shared-library, only display the global variables that were added (defined) to
            second-shared-library.

          · --no-added-syms

            In the resulting  report  about  the  differences  between  first-shared-library  and
            second-shared-library,  do  not display added functions or variables.  Do not display
            added functions or variables ELF symbols either.  All  other  kinds  of  changes  are
            displayed unless they are explicitely forbidden by other options on the command line.

          · --no-linkage-name

            In  the  resulting report, do not display the linkage names of the added, removed, or
            changed functions or variables.

          · --no-show-locs
              Do not show information about where in the second  shared  library  the  respective
              type was changed.

          · --show-bytes

            Show  sizes  and offsets in bytes, not bits.  By default, sizes and offsets are shown
            in bits.

          · --show-bits

            Show sizes and offsets in bits, not bytes.  This option is activated by default.

          · --show-hex

            Show sizes and offsets in hexadecimal base.

          · --show-dec

            Show sizes and offsets in decimal base.  This option is activated by default.

          · --no-show-relative-offset-changes

            Without this option, when the offset of a data member changes, the change report  not
            only  mentions  the older and newer offset, but it also mentions by how many bits the
            data member changes.  With this option, the latter is not shown.

          · --no-unreferenced-symbols

            In the resulting report,  do  not  display  change  information  about  function  and
            variable  symbols  that  are  not referenced by any debug information.  Note that for
            these symbols not  referenced  by  any  debug  information,  the  change  information
            displayed is either added or removed symbols.

          · --no-default-suppression

            Do not load the default suppression specification files.

          · --suppressions | --suppr <path-to-suppressions>

            Use a suppression specification file located at path-to-suppressions.  Note that this
            option can appear multiple times on the command line.   In  that  case,  all  of  the
            provided suppression specification files are taken into account.

            Please  note  that,  by  default,  if  this  option is not provided, then the default
            suppression specification files are loaded .

          · --drop <regex>

            When reading the first-shared-library and second-shared-library ELF input files, drop
            the  globally defined functions and variables which name match the regular expression
            regex.  As a result, no change involving these functions or variables will be emitted
            in the diff report.

          · --drop-fn <regex>

            When reading the first-shared-library and second-shared-library ELF input files, drop
            the globally defined functions which name match the regular expression regex.   As  a
            result, no change involving these functions will be emitted in the diff report.

          · --drop-var <regex>

            When reading the first-shared-library and second-shared-library ELF input files, drop
            the globally defined variables matching a the regular expression regex.

          · --keep <regex>

            When reading the first-shared-library and second-shared-library ELF input files, keep
            the globally defined functions and variables which names match the regular expression
            regex.  All other functions and variables are dropped on the floor and will thus  not
            appear in the resulting diff report.

          · --keep-fn <regex>

            When reading the first-shared-library and second-shared-library ELF input files, keep
            the globally defined functions which name match the regular  expression  regex.   All
            other  functions  are  dropped on the floor and will thus not appear in the resulting
            diff report.

          · --keep-var <regex>

            When reading the first-shared-library and second-shared-library ELF input files, keep
            the  globally  defined  which  names  match  the regular expression regex.  All other
            variables are dropped on the floor and will thus not appear  in  the  resulting  diff
            report.

          · --harmless

            In  the  diff  report,  display  only the harmless changes.  By default, the harmless
            changes are filtered out of the diff report keep the clutter to a minimum and have  a
            greater chance to spot real ABI issues.

          · --no-harmful

            In the diff report, do not display the harmful changes.  By default, only the harmful
            changes are displayed in diff report.

          · --redundant

            In the diff report, do display redundant changes.  A redundant  change  is  a  change
            that has been displayed elsewhere in the report.

          · --no-redundant

            In the diff report, do NOT display redundant changes.  A redundant change is a change
            that has been displayed elsewhere in the report.   This  option  is  switched  on  by
            default.

          · --no-architecture

            Do not take architecture in account when comparing ABIs.

          · --no-corpus-path

            Do not emit the path attribute for the ABI corpus.

          · --fail-no-debug-info

            If  no  debug info was found, then this option makes the program to fail.  Otherwise,
            without this option, the program will attempt to compare properties of  the  binaries
            that are not related to debug info, like pure ELF properties.

          · --leaf-changes-only|-l only show leaf changes, so don’t show impact analysis report.

            The typical output of abidiff when comparing two binaries looks like this

                $ abidiff libtest-v0.so libtest-v1.so
                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 fn(C&)' at test-v1.cc:13:1 has some indirect sub-type changes:
                    parameter 1 of type 'C&' has sub-type changes:
                      in referenced type 'struct C' at test-v1.cc:7:1:
                        type size hasn't changed
                        1 data member change:
                         type of 'leaf* C::m0' changed:
                           in pointed to type 'struct leaf' at test-v1.cc:1:1:
                             type size changed from 32 to 64 bits
                             1 data member insertion:
                               'char leaf::m1', at offset 32 (in bits) at test-v1.cc:4:1

                $

            So  in  that example the report emits information about how the data member insertion
            change of “struct leaf” is reachable from function “void fn(C&)”.   In  other  words,
            the  report not only shows the data member change on “struct leaf”, but it also shows
            the impact of that change on the function “void fn(C&)”.

            In abidiff parlance, the change on “struct leaf” is called a  leaf  change.   So  the
            --leaf-changes-only  --impacted-interfaces  options show, well, only the leaf change.
            And it goes like this:

                $ abidiff -l libtest-v0.so libtest-v1.so
                'struct leaf' changed:
                  type size changed from 32 to 64 bits
                  1 data member insertion:
                    'char leaf::m1', at offset 32 (in bits) at test-v1.cc:4:1

                  one impacted interface:
                    function void fn(C&)
                $

            Note how the report ends by showing the list  of  interfaces  impacted  by  the  leaf
            change.

            Now  if  you  don’t  want  to see that list of impacted interfaces, then you can just
            avoid using the --impacted-interface option.  You can learn about that option  below,
            in any case.

          · --impacted-interfaces

            When showing leaf changes, this option instructs abidiff to show the list of impacted
            interfaces.  This option is thus to  be  used  in  addition  the  --leaf-changes-only
            option, otherwise, it’s ignored.

          · --dump-diff-tree
              After the diff report, emit a textual representation of the diff nodes tree used by
              the comparison engine to represent  the  changed  functions  and  variables.   That
              representation  is  emitted  to the error output for debugging purposes.  Note that
              this diff tree is relevant only to functions and variables that have some  sub-type
              changes.   Added or removed functions and variables do not have any diff nodes tree
              associated to them.

          · --stats

            Emit statistics about various internal things.

          · --verbose

            Emit verbose logs about the progress of miscellaneous internal things.

RETURN VALUES

       The exit code of the abidiff command is either 0 if the ABI of the binaries being compared
       are equal, or non-zero if they differ or if the tool encountered an error.

       In  the  later  case,  the  exit  code  is a 8-bits-wide bit field in which each bit has a
       specific meaning.

       The first bit, of value 1, named ABIDIFF_ERROR means there was an error.

       The second bit, of value 2, named ABIDIFF_USAGE_ERROR means there was an error in the  way
       the  user  invoked  the tool.  It might be set, for instance, if the user invoked the tool
       with an unknown command line switch, with a wrong number or argument, etc.  If this bit is
       set, then the ABIDIFF_ERROR bit must be set as well.

       The  third  bit,  of value 4, named ABIDIFF_ABI_CHANGE means the ABI of the binaries being
       compared are different.

       The fourth bit, of value 8, named ABIDIFF_ABI_INCOMPATIBLE_CHANGE means  the  ABI  of  the
       binaries  compared  are  different  in  an incompatible way.  If this bit is set, then the
       ABIDIFF_ABI_CHANGE bit must be set as well.  If the  ABIDIFF_ABI_CHANGE  is  set  and  the
       ABIDIFF_INCOMPATIBLE_CHANGE  is  NOT set, then it means that the ABIs being compared might
       or might not be compatible.  In that case, a human being needs to review the  ABI  changes
       to decide if they are compatible or not.

       Note  that,  at the moment, there are only a few kinds of ABI changes that would result in
       setting the flag ABIDIFF_ABI_INCOMPATIBLE_CHANGE.  Those ABI changes are either:

          · the removal of the symbol of a  function  or  variable  that  has  been  defined  and
            exported.

          · the  modification  of  the  index  of  a  member of a virtual function table (for C++
            programs and libraries).

       With time, when more ABI change patterns are found to always constitute  incompatible  ABI
       changes,   we   will   adapt   the   code   to   recognize   those   cases   and  set  the
       ABIDIFF_ABI_INCOMPATIBLE_CHANGE accordingly.  So, if you find such patterns, please let us
       know.

       The remaining bits are not used for the moment.

USAGE EXAMPLES

          1. Detecting a change in a sub-type of a function:

                 $ 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
                 $
                 $ ../build/tools/abidiff libtest-v0.so libtest-v1.so
                 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
                 $

          2. Detecting another change in a sub-type of a function:

                 $ 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
                 $
                 $ ../build/tools/abidiff libtest-v0.so libtest-v1.so
                 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

                 $

          3. Detecting that functions got removed or added to a library:

                 $ 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
                 $
                 $ ../build/tools/abidiff libtest-v0.so libtest-v1.so
                 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}

                 $

AUTHOR

       Dodji Seketeli

COPYRIGHT

       2014-2019, Red Hat, Inc.

                                           Apr 10, 2019                                ABIDIFF(1)