LCOV - code coverage report
Current view: top level - src - elfcmp.c (source / functions) Hit Total Coverage
Test: elfutils-0.189 Lines: 176 378 46.6 %
Date: 2023-04-18 20:09:22 Functions: 5 8 62.5 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 146 428 34.1 %

           Branch data     Line data    Source code
       1                 :            : /* Compare relevant content of two ELF files.
       2                 :            :    Copyright (C) 2005-2012, 2014, 2015 Red Hat, Inc.
       3                 :            :    This file is part of elfutils.
       4                 :            :    Written by Ulrich Drepper <drepper@redhat.com>, 2005.
       5                 :            : 
       6                 :            :    This file is free software; you can redistribute it and/or modify
       7                 :            :    it under the terms of the GNU General Public License as published by
       8                 :            :    the Free Software Foundation; either version 3 of the License, or
       9                 :            :    (at your option) any later version.
      10                 :            : 
      11                 :            :    elfutils is distributed in the hope that it will be useful, but
      12                 :            :    WITHOUT ANY WARRANTY; without even the implied warranty of
      13                 :            :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14                 :            :    GNU General Public License for more details.
      15                 :            : 
      16                 :            :    You should have received a copy of the GNU General Public License
      17                 :            :    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
      18                 :            : 
      19                 :            : #ifdef HAVE_CONFIG_H
      20                 :            : # include <config.h>
      21                 :            : #endif
      22                 :            : 
      23                 :            : #include <argp.h>
      24                 :            : #include <assert.h>
      25                 :            : #include <errno.h>
      26                 :            : #include <fcntl.h>
      27                 :            : #include <locale.h>
      28                 :            : #include <stdbool.h>
      29                 :            : #include <stdio.h>
      30                 :            : #include <stdlib.h>
      31                 :            : #include <string.h>
      32                 :            : #include <unistd.h>
      33                 :            : 
      34                 :            : #include <printversion.h>
      35                 :            : #include "../libelf/elf-knowledge.h"
      36                 :            : #include "../libebl/libeblP.h"
      37                 :            : #include "system.h"
      38                 :            : 
      39                 :            : /* Prototypes of local functions.  */
      40                 :            : static Elf *open_file (const char *fname, int *fdp, Ebl **eblp);
      41                 :            : static bool search_for_copy_reloc (Ebl *ebl, size_t scnndx, int symndx);
      42                 :            : static  int regioncompare (const void *p1, const void *p2);
      43                 :            : 
      44                 :            : 
      45                 :            : /* Name and version of program.  */
      46                 :            : ARGP_PROGRAM_VERSION_HOOK_DEF = print_version;
      47                 :            : 
      48                 :            : /* Bug report address.  */
      49                 :            : ARGP_PROGRAM_BUG_ADDRESS_DEF = PACKAGE_BUGREPORT;
      50                 :            : 
      51                 :            : /* Values for the parameters which have no short form.  */
      52                 :            : #define OPT_GAPS                0x100
      53                 :            : #define OPT_HASH_INEXACT        0x101
      54                 :            : #define OPT_IGNORE_BUILD_ID     0x102
      55                 :            : 
      56                 :            : /* Definitions of arguments for argp functions.  */
      57                 :            : static const struct argp_option options[] =
      58                 :            : {
      59                 :            :   { NULL, 0, NULL, 0, N_("Control options:"), 0 },
      60                 :            :   { "verbose", 'l', NULL, 0,
      61                 :            :     N_("Output all differences, not just the first"), 0 },
      62                 :            :   { "gaps", OPT_GAPS, "ACTION", 0, N_("Control treatment of gaps in loadable segments [ignore|match] (default: ignore)"), 0 },
      63                 :            :   { "hash-inexact", OPT_HASH_INEXACT, NULL, 0,
      64                 :            :     N_("Ignore permutation of buckets in SHT_HASH section"), 0 },
      65                 :            :   { "ignore-build-id", OPT_IGNORE_BUILD_ID, NULL, 0,
      66                 :            :     N_("Ignore differences in build ID"), 0 },
      67                 :            :   { "quiet", 'q', NULL, 0, N_("Output nothing; yield exit status only"), 0 },
      68                 :            : 
      69                 :            :   { NULL, 0, NULL, 0, N_("Miscellaneous:"), 0 },
      70                 :            :   { NULL, 0, NULL, 0, NULL, 0 }
      71                 :            : };
      72                 :            : 
      73                 :            : /* Short description of program.  */
      74                 :            : static const char doc[] = N_("\
      75                 :            : Compare relevant parts of two ELF files for equality.");
      76                 :            : 
      77                 :            : /* Strings for arguments in help texts.  */
      78                 :            : static const char args_doc[] = N_("FILE1 FILE2");
      79                 :            : 
      80                 :            : /* Prototype for option handler.  */
      81                 :            : static error_t parse_opt (int key, char *arg, struct argp_state *state);
      82                 :            : 
      83                 :            : /* Data structure to communicate with argp functions.  */
      84                 :            : static struct argp argp =
      85                 :            : {
      86                 :            :   options, parse_opt, args_doc, doc, NULL, NULL, NULL
      87                 :            : };
      88                 :            : 
      89                 :            : 
      90                 :            : /* How to treat gaps in loadable segments.  */
      91                 :            : static enum
      92                 :            :   {
      93                 :            :     gaps_ignore = 0,
      94                 :            :     gaps_match
      95                 :            :   }
      96                 :            :   gaps;
      97                 :            : 
      98                 :            : /* Structure to hold information about used regions.  */
      99                 :            : struct region
     100                 :            : {
     101                 :            :   GElf_Addr from;
     102                 :            :   GElf_Addr to;
     103                 :            :   struct region *next;
     104                 :            : };
     105                 :            : 
     106                 :            : /* Nonzero if only exit status is wanted.  */
     107                 :            : static bool quiet;
     108                 :            : 
     109                 :            : /* True iff multiple differences should be output.  */
     110                 :            : static bool verbose;
     111                 :            : 
     112                 :            : /* True iff SHT_HASH treatment should be generous.  */
     113                 :            : static bool hash_inexact;
     114                 :            : 
     115                 :            : /* True iff build ID notes should be ignored.  */
     116                 :            : static bool ignore_build_id;
     117                 :            : 
     118                 :            : static bool hash_content_equivalent (size_t entsize, Elf_Data *, Elf_Data *);
     119                 :            : 
     120                 :            : 
     121                 :            : int
     122                 :        226 : main (int argc, char *argv[])
     123                 :            : {
     124                 :            :   /* Set locale.  */
     125                 :        226 :   (void) setlocale (LC_ALL, "");
     126                 :            : 
     127                 :            :   /* Make sure the message catalog can be found.  */
     128                 :        226 :   (void) bindtextdomain (PACKAGE_TARNAME, LOCALEDIR);
     129                 :            : 
     130                 :            :   /* Initialize the message catalog.  */
     131                 :        226 :   (void) textdomain (PACKAGE_TARNAME);
     132                 :            : 
     133                 :            :   /* Parse and process arguments.  */
     134                 :        226 :   int remaining;
     135                 :        226 :   (void) argp_parse (&argp, argc, argv, 0, &remaining, NULL);
     136                 :            : 
     137                 :            :   /* We expect exactly two non-option parameters.  */
     138         [ -  + ]:        226 :   if (unlikely (remaining + 2 != argc))
     139                 :            :     {
     140                 :          0 :       fputs (_("Invalid number of parameters.\n"), stderr);
     141                 :          0 :       argp_help (&argp, stderr, ARGP_HELP_SEE, program_invocation_short_name);
     142                 :          0 :       exit (1);
     143                 :            :     }
     144                 :            : 
     145         [ -  + ]:        226 :   if (quiet)
     146                 :          0 :     verbose = false;
     147                 :            : 
     148                 :            :   /* Comparing the files is done in two phases:
     149                 :            :      1. compare all sections.  Sections which are irrelevant (i.e., if
     150                 :            :         strip would remove them) are ignored.  Some section types are
     151                 :            :         handled special.
     152                 :            :      2. all parts of the loadable segments which are not parts of any
     153                 :            :         section is compared according to the rules of the --gaps option.
     154                 :            :   */
     155                 :        226 :   int result = 0;
     156                 :        226 :   elf_version (EV_CURRENT);
     157                 :            : 
     158                 :        226 :   const char *const fname1 = argv[remaining];
     159                 :        226 :   int fd1;
     160                 :        226 :   Ebl *ebl1;
     161                 :        226 :   Elf *elf1 = open_file (fname1, &fd1, &ebl1);
     162                 :            : 
     163                 :        226 :   const char *const fname2 = argv[remaining + 1];
     164                 :        226 :   int fd2;
     165                 :        226 :   Ebl *ebl2;
     166                 :        226 :   Elf *elf2 = open_file (fname2, &fd2, &ebl2);
     167                 :            : 
     168                 :        226 :   GElf_Ehdr ehdr1_mem;
     169                 :        226 :   GElf_Ehdr *ehdr1 = gelf_getehdr (elf1, &ehdr1_mem);
     170         [ -  + ]:        226 :   if (ehdr1 == NULL)
     171                 :          0 :     error (2, 0, _("cannot get ELF header of '%s': %s"),
     172                 :            :            fname1, elf_errmsg (-1));
     173                 :        226 :   GElf_Ehdr ehdr2_mem;
     174                 :        226 :   GElf_Ehdr *ehdr2 = gelf_getehdr (elf2, &ehdr2_mem);
     175         [ -  + ]:        226 :   if (ehdr2 == NULL)
     176                 :          0 :     error (2, 0, _("cannot get ELF header of '%s': %s"),
     177                 :            :            fname2, elf_errmsg (-1));
     178                 :            : 
     179                 :            : #define DIFFERENCE                                                            \
     180                 :            :   do                                                                          \
     181                 :            :     {                                                                         \
     182                 :            :       result = 1;                                                             \
     183                 :            :       if (! verbose)                                                          \
     184                 :            :         goto out;                                                             \
     185                 :            :     }                                                                         \
     186                 :            :   while (0)
     187                 :            : 
     188                 :            :   /* Compare the ELF headers.  */
     189   [ +  -  +  -  :        226 :   if (unlikely (memcmp (ehdr1->e_ident, ehdr2->e_ident, EI_NIDENT) != 0
          +  -  +  -  +  
                -  -  + ]
     190                 :            :                 || ehdr1->e_type != ehdr2->e_type
     191                 :            :                 || ehdr1->e_machine != ehdr2->e_machine
     192                 :            :                 || ehdr1->e_version != ehdr2->e_version
     193                 :            :                 || ehdr1->e_entry != ehdr2->e_entry
     194                 :            :                 || ehdr1->e_phoff != ehdr2->e_phoff
     195                 :            :                 || ehdr1->e_flags != ehdr2->e_flags
     196                 :            :                 || ehdr1->e_ehsize != ehdr2->e_ehsize
     197                 :            :                 || ehdr1->e_phentsize != ehdr2->e_phentsize
     198                 :            :                 || ehdr1->e_phnum != ehdr2->e_phnum
     199                 :            :                 || ehdr1->e_shentsize != ehdr2->e_shentsize))
     200                 :            :     {
     201         [ #  # ]:          0 :       if (! quiet)
     202                 :          0 :         error (0, 0, _("%s %s diff: ELF header"), fname1, fname2);
     203         [ #  # ]:          0 :       DIFFERENCE;
     204                 :            :     }
     205                 :            : 
     206                 :        226 :   size_t shnum1;
     207                 :        226 :   size_t shnum2;
     208         [ -  + ]:        226 :   if (unlikely (elf_getshdrnum (elf1, &shnum1) != 0))
     209                 :          0 :     error (2, 0, _("cannot get section count of '%s': %s"),
     210                 :            :            fname1, elf_errmsg (-1));
     211         [ -  + ]:        226 :   if (unlikely (elf_getshdrnum (elf2, &shnum2) != 0))
     212                 :          0 :     error (2, 0, _("cannot get section count of '%s': %s"),
     213                 :            :            fname2, elf_errmsg (-1));
     214         [ -  + ]:        226 :   if (unlikely (shnum1 != shnum2))
     215                 :            :     {
     216         [ #  # ]:          0 :       if (! quiet)
     217                 :          0 :         error (0, 0, _("%s %s diff: section count"), fname1, fname2);
     218         [ #  # ]:          0 :       DIFFERENCE;
     219                 :            :     }
     220                 :            : 
     221                 :        226 :   size_t phnum1;
     222                 :        226 :   size_t phnum2;
     223         [ -  + ]:        226 :   if (unlikely (elf_getphdrnum (elf1, &phnum1) != 0))
     224                 :          0 :     error (2, 0, _("cannot get program header count of '%s': %s"),
     225                 :            :            fname1, elf_errmsg (-1));
     226         [ -  + ]:        226 :   if (unlikely (elf_getphdrnum (elf2, &phnum2) != 0))
     227                 :          0 :     error (2, 0, _("cannot get program header count of '%s': %s"),
     228                 :            :            fname2, elf_errmsg (-1));
     229         [ -  + ]:        226 :   if (unlikely (phnum1 != phnum2))
     230                 :            :     {
     231         [ #  # ]:          0 :       if (! quiet)
     232                 :          0 :         error (0, 0, _("%s %s diff: program header count"),
     233                 :            :                fname1, fname2);
     234         [ #  # ]:          0 :       DIFFERENCE;
     235                 :            :     }
     236                 :            : 
     237                 :        226 :   size_t shstrndx1;
     238                 :        226 :   size_t shstrndx2;
     239         [ -  + ]:        226 :   if (elf_getshdrstrndx (elf1, &shstrndx1) != 0)
     240                 :          0 :     error (2, 0, _("cannot get hdrstrndx of '%s': %s"),
     241                 :            :            fname1, elf_errmsg (-1));
     242         [ -  + ]:        226 :   if (elf_getshdrstrndx (elf2, &shstrndx2) != 0)
     243                 :          0 :     error (2, 0, _("cannot get hdrstrndx of '%s': %s"),
     244                 :            :            fname2, elf_errmsg (-1));
     245         [ +  - ]:        226 :   if (shstrndx1 != shstrndx2)
     246                 :            :     {
     247         [ #  # ]:          0 :       if (! quiet)
     248                 :          0 :         error (0, 0, _("%s %s diff: shdr string index"),
     249                 :            :                fname1, fname2);
     250         [ #  # ]:          0 :       DIFFERENCE;
     251                 :            :     }
     252                 :            : 
     253                 :            :   /* Iterate over all sections.  We expect the sections in the two
     254                 :            :      files to match exactly.  */
     255                 :            :   Elf_Scn *scn1 = NULL;
     256                 :            :   Elf_Scn *scn2 = NULL;
     257                 :            :   struct region *regions = NULL;
     258                 :            :   size_t nregions = 0;
     259                 :       3003 :   while (1)
     260                 :            :     {
     261                 :       3003 :       GElf_Shdr shdr1_mem;
     262                 :       3003 :       GElf_Shdr *shdr1;
     263                 :       3003 :       const char *sname1 = NULL;
     264                 :    1119156 :       do
     265                 :            :         {
     266                 :    1119156 :           scn1 = elf_nextscn (elf1, scn1);
     267                 :    1119156 :           shdr1 = gelf_getshdr (scn1, &shdr1_mem);
     268         [ +  + ]:    1119156 :           if (shdr1 != NULL)
     269                 :    1118930 :             sname1 = elf_strptr (elf1, shstrndx1, shdr1->sh_name);
     270                 :            :         }
     271                 :    1119156 :       while (scn1 != NULL && shdr1 != NULL
     272   [ +  +  +  + ]:    1119156 :              && ebl_section_strip_p (ebl1, shdr1, sname1, true, false));
     273                 :            : 
     274                 :       3003 :       GElf_Shdr shdr2_mem;
     275                 :       3003 :       GElf_Shdr *shdr2;
     276                 :       3003 :       const char *sname2 = NULL;
     277                 :    1119156 :       do
     278                 :            :         {
     279                 :    1119156 :           scn2 = elf_nextscn (elf2, scn2);
     280                 :    1119156 :           shdr2 = gelf_getshdr (scn2, &shdr2_mem);
     281         [ +  + ]:    1119156 :           if (shdr2 != NULL)
     282                 :    1118930 :             sname2 = elf_strptr (elf2, shstrndx2, shdr2->sh_name);
     283                 :            :         }
     284                 :    1119156 :       while (scn2 != NULL && shdr2 != NULL
     285   [ +  +  +  + ]:    1119156 :              && ebl_section_strip_p (ebl2, shdr2, sname2, true, false));
     286                 :            : 
     287   [ +  +  +  - ]:       3003 :       if (scn1 == NULL || scn2 == NULL || shdr1 == NULL || shdr2 == NULL)
     288                 :            :         break;
     289                 :            : 
     290   [ -  +  -  - ]:       2777 :       if (gaps != gaps_ignore && (shdr1->sh_flags & SHF_ALLOC) != 0)
     291                 :            :         {
     292                 :          0 :           struct region *newp = (struct region *) alloca (sizeof (*newp));
     293                 :          0 :           newp->from = shdr1->sh_offset;
     294                 :          0 :           newp->to = shdr1->sh_offset + shdr1->sh_size;
     295                 :          0 :           newp->next = regions;
     296                 :          0 :           regions = newp;
     297                 :            : 
     298                 :          0 :           ++nregions;
     299                 :            :         }
     300                 :            : 
     301                 :            :       /* Compare the headers.  We allow the name to be at a different
     302                 :            :          location.  */
     303   [ +  -  -  + ]:       2777 :       if (unlikely (sname1 == NULL || sname2 == NULL
     304                 :            :                     || strcmp (sname1, sname2) != 0))
     305                 :            :         {
     306                 :          0 :           error (0, 0, _("%s %s differ: section [%zu], [%zu] name"),
     307                 :            :                  fname1, fname2, elf_ndxscn (scn1), elf_ndxscn (scn2));
     308         [ #  # ]:          0 :           DIFFERENCE;
     309                 :            :         }
     310                 :            : 
     311                 :            :       /* We ignore certain sections.  */
     312         [ +  - ]:       2777 :       if ((sname1 != NULL && strcmp (sname1, ".gnu_debuglink") == 0)
     313   [ +  -  -  + ]:       2777 :           || (sname1 != NULL && strcmp (sname1, ".gnu.prelink_undo") == 0))
     314                 :          0 :         continue;
     315                 :            : 
     316         [ +  - ]:       2777 :       if (shdr1->sh_type != shdr2->sh_type
     317                 :            :           // XXX Any flags which should be ignored?
     318         [ +  - ]:       2777 :           || shdr1->sh_flags != shdr2->sh_flags
     319         [ +  - ]:       2777 :           || shdr1->sh_addr != shdr2->sh_addr
     320         [ +  + ]:       2777 :           || (shdr1->sh_offset != shdr2->sh_offset
     321         [ +  + ]:         65 :               && (shdr1->sh_flags & SHF_ALLOC)
     322         [ +  - ]:         57 :               && ehdr1->e_type != ET_REL)
     323         [ +  - ]:       2777 :           || shdr1->sh_size != shdr2->sh_size
     324                 :            :           || shdr1->sh_link != shdr2->sh_link
     325         [ +  - ]:       2777 :           || shdr1->sh_info != shdr2->sh_info
     326         [ +  - ]:       2777 :           || shdr1->sh_addralign != shdr2->sh_addralign
     327         [ -  + ]:       2777 :           || shdr1->sh_entsize != shdr2->sh_entsize)
     328                 :            :         {
     329                 :          0 :           error (0, 0, _("%s %s differ: section [%zu] '%s' header"),
     330                 :            :                  fname1, fname2, elf_ndxscn (scn1), sname1);
     331         [ #  # ]:          0 :           DIFFERENCE;
     332                 :            :         }
     333                 :            : 
     334                 :       2777 :       Elf_Data *data1 = elf_getdata (scn1, NULL);
     335         [ -  + ]:       2777 :       if (data1 == NULL)
     336                 :          0 :         error (2, 0,
     337                 :          0 :                _("cannot get content of section %zu in '%s': %s"),
     338                 :            :                elf_ndxscn (scn1), fname1, elf_errmsg (-1));
     339                 :            : 
     340                 :       2777 :       Elf_Data *data2 = elf_getdata (scn2, NULL);
     341         [ -  + ]:       2777 :       if (data2 == NULL)
     342                 :          0 :         error (2, 0,
     343                 :          0 :                _("cannot get content of section %zu in '%s': %s"),
     344                 :            :                elf_ndxscn (scn2), fname2, elf_errmsg (-1));
     345                 :            : 
     346      [ +  +  + ]:       2777 :       switch (shdr1->sh_type)
     347                 :            :         {
     348                 :        101 :         case SHT_DYNSYM:
     349                 :            :         case SHT_SYMTAB:
     350         [ -  + ]:        101 :           if (shdr1->sh_entsize == 0)
     351                 :          0 :             error (2, 0,
     352                 :          0 :                    _("symbol table [%zu] in '%s' has zero sh_entsize"),
     353                 :            :                    elf_ndxscn (scn1), fname1);
     354                 :            : 
     355                 :            :           /* Iterate over the symbol table.  We ignore the st_size
     356                 :            :              value of undefined symbols.  */
     357         [ +  + ]:       3912 :           for (int ndx = 0; ndx < (int) (shdr1->sh_size / shdr1->sh_entsize);
     358                 :       3811 :                ++ndx)
     359                 :            :             {
     360                 :       3811 :               GElf_Sym sym1_mem;
     361                 :       3811 :               GElf_Sym *sym1 = gelf_getsym (data1, ndx, &sym1_mem);
     362         [ -  + ]:       3811 :               if (sym1 == NULL)
     363                 :          0 :                 error (2, 0,
     364                 :          0 :                        _("cannot get symbol in '%s': %s"),
     365                 :            :                        fname1, elf_errmsg (-1));
     366                 :       3811 :               GElf_Sym sym2_mem;
     367                 :       3811 :               GElf_Sym *sym2 = gelf_getsym (data2, ndx, &sym2_mem);
     368         [ -  + ]:       3811 :               if (sym2 == NULL)
     369                 :          0 :                 error (2, 0,
     370                 :          0 :                        _("cannot get symbol in '%s': %s"),
     371                 :            :                        fname2, elf_errmsg (-1));
     372                 :            : 
     373                 :       7622 :               const char *name1 = elf_strptr (elf1, shdr1->sh_link,
     374                 :       3811 :                                               sym1->st_name);
     375                 :       7622 :               const char *name2 = elf_strptr (elf2, shdr2->sh_link,
     376                 :       3811 :                                               sym2->st_name);
     377   [ +  -  +  -  :       3811 :               if (unlikely (name1 == NULL || name2 == NULL
          +  -  -  +  -  
             -  +  -  -  
                      + ]
     378                 :            :                             || strcmp (name1, name2) != 0
     379                 :            :                             || sym1->st_value != sym2->st_value
     380                 :            :                             || (sym1->st_size != sym2->st_size
     381                 :            :                                 && sym1->st_shndx != SHN_UNDEF)
     382                 :            :                             || sym1->st_info != sym2->st_info
     383                 :            :                             || sym1->st_other != sym2->st_other
     384                 :            :                             || sym1->st_shndx != sym2->st_shndx))
     385                 :            :                 {
     386                 :            :                   // XXX Do we want to allow reordered symbol tables?
     387                 :          0 :                 symtab_mismatch:
     388         [ #  # ]:          0 :                   if (! quiet)
     389                 :            :                     {
     390         [ #  # ]:          0 :                       if (elf_ndxscn (scn1) == elf_ndxscn (scn2))
     391                 :          0 :                         error (0, 0,
     392                 :          0 :                                _("%s %s differ: symbol table [%zu]"),
     393                 :            :                                fname1, fname2, elf_ndxscn (scn1));
     394                 :            :                       else
     395                 :          0 :                         error (0, 0, _("\
     396                 :            : %s %s differ: symbol table [%zu,%zu]"),
     397                 :            :                                fname1, fname2, elf_ndxscn (scn1),
     398                 :            :                                elf_ndxscn (scn2));
     399                 :            :                     }
     400         [ #  # ]:          0 :                   DIFFERENCE;
     401                 :          0 :                   break;
     402                 :            :                 }
     403                 :            : 
     404         [ +  + ]:       3811 :               if (sym1->st_shndx == SHN_UNDEF
     405         [ -  + ]:       1966 :                   && sym1->st_size != sym2->st_size)
     406                 :            :                 {
     407                 :            :                   /* The size of the symbol in the object defining it
     408                 :            :                      might have changed.  That is OK unless the symbol
     409                 :            :                      is used in a copy relocation.  Look over the
     410                 :            :                      sections in both files and determine which
     411                 :            :                      relocation section uses this symbol table
     412                 :            :                      section.  Then look through the relocations to
     413                 :            :                      see whether any copy relocation references this
     414                 :            :                      symbol.  */
     415         [ #  # ]:          0 :                   if (search_for_copy_reloc (ebl1, elf_ndxscn (scn1), ndx)
     416         [ #  # ]:          0 :                       || search_for_copy_reloc (ebl2, elf_ndxscn (scn2), ndx))
     417                 :          0 :                     goto symtab_mismatch;
     418                 :            :                 }
     419                 :            :             }
     420                 :            :           break;
     421                 :            : 
     422                 :            :         case SHT_NOTE:
     423                 :            :           /* Parse the note format and compare the notes themselves.  */
     424                 :            :           {
     425                 :            :             GElf_Nhdr note1;
     426                 :            :             GElf_Nhdr note2;
     427                 :            : 
     428                 :            :             size_t off1 = 0;
     429                 :            :             size_t off2 = 0;
     430                 :            :             size_t name_offset;
     431                 :            :             size_t desc_offset;
     432                 :        523 :             while (off1 < data1->d_size
     433         [ +  - ]:        373 :                    && (off1 = gelf_getnote (data1, off1, &note1,
     434                 :            :                                             &name_offset, &desc_offset)) > 0)
     435                 :            :               {
     436                 :        746 :                 const char *name1 = (note1.n_namesz == 0
     437         [ +  - ]:        373 :                                      ? "" : data1->d_buf + name_offset);
     438                 :        373 :                 const void *desc1 = data1->d_buf + desc_offset;
     439         [ -  + ]:        373 :                 if (off2 >= data2->d_size)
     440                 :            :                   {
     441         [ #  # ]:          0 :                     if (! quiet)
     442                 :          0 :                       error (0, 0, _("\
     443                 :            : %s %s differ: section [%zu] '%s' number of notes"),
     444                 :            :                              fname1, fname2, elf_ndxscn (scn1), sname1);
     445         [ #  # ]:          0 :                     DIFFERENCE;
     446                 :            :                   }
     447                 :        373 :                 off2 = gelf_getnote (data2, off2, &note2,
     448                 :            :                                      &name_offset, &desc_offset);
     449         [ -  + ]:        373 :                 if (off2 == 0)
     450                 :          0 :                   error (2, 0, _("\
     451                 :            : cannot read note section [%zu] '%s' in '%s': %s"),
     452                 :            :                          elf_ndxscn (scn2), sname2, fname2, elf_errmsg (-1));
     453                 :        746 :                 const char *name2 = (note2.n_namesz == 0
     454         [ +  - ]:        373 :                                      ? "" : data2->d_buf + name_offset);
     455                 :        373 :                 const void *desc2 = data2->d_buf + desc_offset;
     456                 :            : 
     457         [ +  - ]:        373 :                 if (note1.n_namesz != note2.n_namesz
     458         [ -  + ]:        373 :                     || memcmp (name1, name2, note1.n_namesz))
     459                 :            :                   {
     460         [ #  # ]:          0 :                     if (! quiet)
     461                 :          0 :                       error (0, 0, _("\
     462                 :            : %s %s differ: section [%zu] '%s' note name"),
     463                 :            :                              fname1, fname2, elf_ndxscn (scn1), sname1);
     464         [ #  # ]:          0 :                     DIFFERENCE;
     465                 :            :                   }
     466         [ -  + ]:        373 :                 if (note1.n_type != note2.n_type)
     467                 :            :                   {
     468         [ #  # ]:          0 :                     if (! quiet)
     469                 :          0 :                       error (0, 0, _("\
     470                 :            : %s %s differ: section [%zu] '%s' note '%s' type"),
     471                 :            :                              fname1, fname2, elf_ndxscn (scn1), sname1, name1);
     472         [ #  # ]:          0 :                     DIFFERENCE;
     473                 :            :                   }
     474         [ +  - ]:        373 :                 if (note1.n_descsz != note2.n_descsz
     475         [ -  + ]:        373 :                     || memcmp (desc1, desc2, note1.n_descsz))
     476                 :            :                   {
     477         [ #  # ]:          0 :                     if (note1.n_type == NT_GNU_BUILD_ID
     478         [ #  # ]:          0 :                         && note1.n_namesz == sizeof "GNU"
     479         [ #  # ]:          0 :                         && !memcmp (name1, "GNU", sizeof "GNU"))
     480                 :            :                       {
     481         [ #  # ]:          0 :                         if (note1.n_descsz != note2.n_descsz)
     482                 :            :                           {
     483         [ #  # ]:          0 :                             if (! quiet)
     484                 :          0 :                               error (0, 0, _("\
     485                 :            : %s %s differ: build ID length"),
     486                 :            :                                      fname1, fname2);
     487         [ #  # ]:          0 :                             DIFFERENCE;
     488                 :            :                           }
     489         [ #  # ]:          0 :                         else if (! ignore_build_id)
     490                 :            :                           {
     491         [ #  # ]:          0 :                             if (! quiet)
     492                 :          0 :                               error (0, 0, _("\
     493                 :            : %s %s differ: build ID content"),
     494                 :            :                                      fname1, fname2);
     495         [ #  # ]:          0 :                             DIFFERENCE;
     496                 :            :                           }
     497                 :            :                       }
     498                 :            :                     else
     499                 :            :                       {
     500         [ #  # ]:          0 :                         if (! quiet)
     501                 :          0 :                           error (0, 0, _("\
     502                 :            : %s %s differ: section [%zu] '%s' note '%s' content"),
     503                 :            :                                  fname1, fname2, elf_ndxscn (scn1), sname1,
     504                 :            :                                  name1);
     505   [ -  -  +  + ]:        523 :                         DIFFERENCE;
     506                 :            :                       }
     507                 :            :                   }
     508                 :            :               }
     509         [ -  + ]:        150 :             if (off2 < data2->d_size)
     510                 :            :               {
     511         [ #  # ]:          0 :                 if (! quiet)
     512                 :          0 :                   error (0, 0, _("\
     513                 :            : %s %s differ: section [%zu] '%s' number of notes"),
     514                 :            :                          fname1, fname2, elf_ndxscn (scn1), sname1);
     515         [ #  # ]:          0 :                 DIFFERENCE;
     516                 :            :               }
     517                 :            :           }
     518                 :        150 :           break;
     519                 :            : 
     520                 :       2526 :         default:
     521                 :            :           /* Compare the section content byte for byte.  */
     522   [ +  +  +  +  :       2526 :           assert (shdr1->sh_type == SHT_NOBITS
                   -  + ]
     523                 :            :                   || (data1->d_buf != NULL || data1->d_size == 0));
     524   [ +  +  +  +  :       2526 :           assert (shdr2->sh_type == SHT_NOBITS
                   -  + ]
     525                 :            :                   || (data2->d_buf != NULL || data1->d_size == 0));
     526                 :            : 
     527   [ +  -  +  +  :       2526 :           if (unlikely (data1->d_size != data2->d_size
             +  +  +  + ]
     528                 :            :                         || (shdr1->sh_type != SHT_NOBITS
     529                 :            :                             && data1->d_size != 0
     530                 :            :                             && memcmp (data1->d_buf, data2->d_buf,
     531                 :            :                                        data1->d_size) != 0)))
     532                 :            :             {
     533         [ +  - ]:          3 :               if (hash_inexact
     534         [ +  - ]:          3 :                   && shdr1->sh_type == SHT_HASH
     535         [ +  - ]:          3 :                   && data1->d_size == data2->d_size
     536         [ -  + ]:          3 :                   && hash_content_equivalent (shdr1->sh_entsize, data1, data2))
     537                 :            :                 break;
     538                 :            : 
     539         [ #  # ]:          0 :               if (! quiet)
     540                 :            :                 {
     541         [ #  # ]:          0 :                   if (elf_ndxscn (scn1) == elf_ndxscn (scn2))
     542                 :          0 :                     error (0, 0, _("\
     543                 :            : %s %s differ: section [%zu] '%s' content"),
     544                 :            :                            fname1, fname2, elf_ndxscn (scn1), sname1);
     545                 :            :                   else
     546                 :          0 :                     error (0, 0, _("\
     547                 :            : %s %s differ: section [%zu,%zu] '%s' content"),
     548                 :            :                            fname1, fname2, elf_ndxscn (scn1),
     549                 :            :                            elf_ndxscn (scn2), sname1);
     550                 :            :                 }
     551         [ #  # ]:          0 :               DIFFERENCE;
     552                 :            :             }
     553                 :            :           break;
     554                 :            :         }
     555                 :          3 :     }
     556                 :            : 
     557         [ -  + ]:        226 :   if (unlikely (scn1 != scn2))
     558                 :            :     {
     559         [ #  # ]:          0 :       if (! quiet)
     560                 :          0 :         error (0, 0,
     561                 :          0 :                _("%s %s differ: unequal amount of important sections"),
     562                 :            :                fname1, fname2);
     563         [ #  # ]:          0 :       DIFFERENCE;
     564                 :            :     }
     565                 :            : 
     566                 :            :   /* We we look at gaps, create artificial ones for the parts of the
     567                 :            :      program which we are not in sections.  */
     568                 :        226 :   struct region ehdr_region;
     569                 :        226 :   struct region phdr_region;
     570         [ -  + ]:        226 :   if (gaps != gaps_ignore)
     571                 :            :     {
     572                 :          0 :       ehdr_region.from = 0;
     573                 :          0 :       ehdr_region.to = ehdr1->e_ehsize;
     574                 :          0 :       ehdr_region.next = &phdr_region;
     575                 :            : 
     576                 :          0 :       phdr_region.from = ehdr1->e_phoff;
     577                 :          0 :       phdr_region.to = ehdr1->e_phoff + phnum1 * ehdr1->e_phentsize;
     578                 :          0 :       phdr_region.next = regions;
     579                 :            : 
     580                 :          0 :       regions = &ehdr_region;
     581                 :          0 :       nregions += 2;
     582                 :            :     }
     583                 :            : 
     584                 :            :   /* If we need to look at the gaps we need access to the file data.  */
     585                 :        226 :   char *raw1 = NULL;
     586                 :        226 :   size_t size1 = 0;
     587                 :        226 :   char *raw2 = NULL;
     588                 :        226 :   size_t size2 = 0;
     589                 :        226 :   struct region *regionsarr = alloca (nregions * sizeof (struct region));
     590         [ -  + ]:        226 :   if (gaps != gaps_ignore)
     591                 :            :     {
     592                 :          0 :       raw1 = elf_rawfile (elf1, &size1);
     593         [ #  # ]:          0 :       if (raw1 == NULL )
     594                 :          0 :         error (2, 0, _("cannot load data of '%s': %s"),
     595                 :            :                fname1, elf_errmsg (-1));
     596                 :            : 
     597                 :          0 :       raw2 = elf_rawfile (elf2, &size2);
     598         [ #  # ]:          0 :       if (raw2 == NULL )
     599                 :          0 :         error (2, 0, _("cannot load data of '%s': %s"),
     600                 :            :                fname2, elf_errmsg (-1));
     601                 :            : 
     602         [ #  # ]:          0 :       for (size_t cnt = 0; cnt < nregions; ++cnt)
     603                 :            :         {
     604                 :          0 :           regionsarr[cnt] = *regions;
     605                 :          0 :           regions = regions->next;
     606                 :            :         }
     607                 :            : 
     608                 :          0 :       qsort (regionsarr, nregions, sizeof (regionsarr[0]), regioncompare);
     609                 :            :     }
     610                 :            : 
     611                 :            :   /* Compare the program header tables.  */
     612         [ +  + ]:       1072 :   for (unsigned int ndx = 0; ndx < phnum1; ++ndx)
     613                 :            :     {
     614                 :        846 :       GElf_Phdr phdr1_mem;
     615                 :        846 :       GElf_Phdr *phdr1 = gelf_getphdr (elf1, ndx, &phdr1_mem);
     616         [ -  + ]:        846 :       if (phdr1 == NULL)
     617                 :          0 :         error (2, 0,
     618                 :          0 :                _("cannot get program header entry %d of '%s': %s"),
     619                 :            :                ndx, fname1, elf_errmsg (-1));
     620                 :        846 :       GElf_Phdr phdr2_mem;
     621                 :        846 :       GElf_Phdr *phdr2 = gelf_getphdr (elf2, ndx, &phdr2_mem);
     622         [ -  + ]:        846 :       if (phdr2 == NULL)
     623                 :          0 :         error (2, 0,
     624                 :          0 :                _("cannot get program header entry %d of '%s': %s"),
     625                 :            :                ndx, fname2, elf_errmsg (-1));
     626                 :            : 
     627         [ -  + ]:        846 :       if (unlikely (memcmp (phdr1, phdr2, sizeof (GElf_Phdr)) != 0))
     628                 :            :         {
     629         [ #  # ]:          0 :           if (! quiet)
     630                 :          0 :             error (0, 0, _("%s %s differ: program header %d"),
     631                 :            :                    fname1, fname2, ndx);
     632         [ #  # ]:          0 :           DIFFERENCE;
     633                 :            :         }
     634                 :            : 
     635   [ -  +  -  - ]:        846 :       if (gaps != gaps_ignore && phdr1->p_type == PT_LOAD)
     636                 :            :         {
     637                 :            :           size_t cnt = 0;
     638   [ #  #  #  # ]:          0 :           while (cnt < nregions && regionsarr[cnt].to < phdr1->p_offset)
     639                 :          0 :             ++cnt;
     640                 :            : 
     641                 :          0 :           GElf_Off last = phdr1->p_offset;
     642                 :          0 :           GElf_Off end = phdr1->p_offset + phdr1->p_filesz;
     643   [ #  #  #  # ]:          0 :           while (cnt < nregions && regionsarr[cnt].from < end)
     644                 :            :             {
     645         [ #  # ]:          0 :               if (last < regionsarr[cnt].from)
     646                 :            :                 {
     647                 :            :                   /* Compare the [LAST,FROM) region.  */
     648         [ #  # ]:          0 :                   assert (gaps == gaps_match);
     649         [ #  # ]:          0 :                   if (unlikely (memcmp (raw1 + last, raw2 + last,
     650                 :            :                                         regionsarr[cnt].from - last) != 0))
     651                 :            :                     {
     652                 :          0 :                     gapmismatch:
     653         [ #  # ]:          0 :                       if (!quiet)
     654                 :          0 :                         error (0, 0, _("%s %s differ: gap"),
     655                 :            :                                fname1, fname2);
     656         [ #  # ]:          0 :                       DIFFERENCE;
     657                 :            :                       break;
     658                 :            :                     }
     659                 :            : 
     660                 :            :                 }
     661                 :          0 :               last = regionsarr[cnt].to;
     662                 :          0 :               ++cnt;
     663                 :            :             }
     664                 :            : 
     665         [ #  # ]:          0 :           if (cnt == nregions && last < end)
     666                 :          0 :             goto gapmismatch;
     667                 :            :         }
     668                 :            :     }
     669                 :            : 
     670                 :        226 :  out:
     671                 :        226 :   elf_end (elf1);
     672                 :        226 :   elf_end (elf2);
     673                 :        226 :   ebl_closebackend (ebl1);
     674                 :        226 :   ebl_closebackend (ebl2);
     675                 :        226 :   close (fd1);
     676                 :        226 :   close (fd2);
     677                 :            : 
     678                 :        226 :   return result;
     679                 :            : }
     680                 :            : 
     681                 :            : 
     682                 :            : /* Handle program arguments.  */
     683                 :            : static error_t
     684                 :       1144 : parse_opt (int key, char *arg,
     685                 :            :            struct argp_state *state __attribute__ ((unused)))
     686                 :            : {
     687   [ -  -  -  +  :       1144 :   switch (key)
                   -  + ]
     688                 :            :     {
     689                 :          0 :     case 'q':
     690                 :          0 :       quiet = true;
     691                 :          0 :       break;
     692                 :            : 
     693                 :          0 :     case 'l':
     694                 :          0 :       verbose = true;
     695                 :          0 :       break;
     696                 :            : 
     697                 :          0 :     case OPT_GAPS:
     698         [ #  # ]:          0 :       if (strcasecmp (arg, "ignore") == 0)
     699                 :          0 :         gaps = gaps_ignore;
     700         [ #  # ]:          0 :       else if (likely (strcasecmp (arg, "match") == 0))
     701                 :          0 :         gaps = gaps_match;
     702                 :            :       else
     703                 :            :         {
     704                 :          0 :           fprintf (stderr,
     705                 :          0 :                    _("Invalid value '%s' for --gaps parameter."),
     706                 :            :                    arg);
     707                 :          0 :           argp_help (&argp, stderr, ARGP_HELP_SEE,
     708                 :            :                      program_invocation_short_name);
     709                 :          0 :           exit (1);
     710                 :            :         }
     711                 :            :       break;
     712                 :            : 
     713                 :         14 :     case OPT_HASH_INEXACT:
     714                 :         14 :       hash_inexact = true;
     715                 :         14 :       break;
     716                 :            : 
     717                 :          0 :     case OPT_IGNORE_BUILD_ID:
     718                 :          0 :       ignore_build_id = true;
     719                 :          0 :       break;
     720                 :            : 
     721                 :            :     default:
     722                 :            :       return ARGP_ERR_UNKNOWN;
     723                 :            :     }
     724                 :            :   return 0;
     725                 :            : }
     726                 :            : 
     727                 :            : 
     728                 :            : static Elf *
     729                 :        452 : open_file (const char *fname, int *fdp, Ebl **eblp)
     730                 :            : {
     731                 :        452 :   int fd = open (fname, O_RDONLY);
     732         [ -  + ]:        452 :   if (unlikely (fd == -1))
     733                 :          0 :     error (2, errno, _("cannot open '%s'"), fname);
     734                 :        452 :   Elf *elf = elf_begin (fd, ELF_C_READ_MMAP, NULL);
     735         [ -  + ]:        452 :   if (elf == NULL)
     736                 :          0 :     error (2, 0,
     737                 :          0 :            _("cannot create ELF descriptor for '%s': %s"),
     738                 :            :            fname, elf_errmsg (-1));
     739                 :        452 :   Ebl *ebl = ebl_openbackend (elf);
     740         [ -  + ]:        452 :   if (ebl == NULL)
     741                 :          0 :     error (2, 0,
     742                 :          0 :            _("cannot create EBL descriptor for '%s'"), fname);
     743                 :            : 
     744                 :        452 :   *fdp = fd;
     745                 :        452 :   *eblp = ebl;
     746                 :        452 :   return elf;
     747                 :            : }
     748                 :            : 
     749                 :            : 
     750                 :            : static bool
     751                 :          0 : search_for_copy_reloc (Ebl *ebl, size_t scnndx, int symndx)
     752                 :            : {
     753                 :          0 :   Elf_Scn *scn = NULL;
     754         [ #  # ]:          0 :   while ((scn = elf_nextscn (ebl->elf, scn)) != NULL)
     755                 :            :     {
     756                 :          0 :       GElf_Shdr shdr_mem;
     757                 :          0 :       GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
     758         [ #  # ]:          0 :       if (shdr == NULL)
     759                 :          0 :         error (2, 0,
     760                 :          0 :                _("cannot get section header of section %zu: %s"),
     761                 :            :                elf_ndxscn (scn), elf_errmsg (-1));
     762                 :            : 
     763         [ #  # ]:          0 :       if ((shdr->sh_type != SHT_REL && shdr->sh_type != SHT_RELA)
     764         [ #  # ]:          0 :           || shdr->sh_link != scnndx)
     765                 :          0 :         continue;
     766                 :            : 
     767                 :          0 :       Elf_Data *data = elf_getdata (scn, NULL);
     768         [ #  # ]:          0 :       if (data == NULL)
     769                 :          0 :         error (2, 0,
     770                 :          0 :                _("cannot get content of section %zu: %s"),
     771                 :            :                elf_ndxscn (scn), elf_errmsg (-1));
     772                 :            : 
     773   [ #  #  #  # ]:          0 :       if (shdr->sh_type == SHT_REL && shdr->sh_entsize != 0)
     774         [ #  # ]:          0 :         for (int ndx = 0; ndx < (int) (shdr->sh_size / shdr->sh_entsize);
     775                 :          0 :              ++ndx)
     776                 :            :           {
     777                 :          0 :             GElf_Rel rel_mem;
     778                 :          0 :             GElf_Rel *rel = gelf_getrel (data, ndx, &rel_mem);
     779         [ #  # ]:          0 :             if (rel == NULL)
     780                 :          0 :               error (2, 0, _("cannot get relocation: %s"),
     781                 :            :                      elf_errmsg (-1));
     782                 :            : 
     783         [ #  # ]:          0 :             if ((int) GELF_R_SYM (rel->r_info) == symndx
     784         [ #  # ]:          0 :                 && ebl_copy_reloc_p (ebl, GELF_R_TYPE (rel->r_info)))
     785                 :          0 :               return true;
     786                 :            :           }
     787         [ #  # ]:          0 :       else if (shdr->sh_entsize != 0)
     788         [ #  # ]:          0 :         for (int ndx = 0; ndx < (int) (shdr->sh_size / shdr->sh_entsize);
     789                 :          0 :              ++ndx)
     790                 :            :           {
     791                 :          0 :             GElf_Rela rela_mem;
     792                 :          0 :             GElf_Rela *rela = gelf_getrela (data, ndx, &rela_mem);
     793         [ #  # ]:          0 :             if (rela == NULL)
     794                 :          0 :               error (2, 0, _("cannot get relocation: %s"),
     795                 :            :                      elf_errmsg (-1));
     796                 :            : 
     797         [ #  # ]:          0 :             if ((int) GELF_R_SYM (rela->r_info) == symndx
     798         [ #  # ]:          0 :                 && ebl_copy_reloc_p (ebl, GELF_R_TYPE (rela->r_info)))
     799                 :          0 :               return true;
     800                 :            :           }
     801                 :            :     }
     802                 :            : 
     803                 :            :   return false;
     804                 :            : }
     805                 :            : 
     806                 :            : 
     807                 :            : static int
     808                 :          0 : regioncompare (const void *p1, const void *p2)
     809                 :            : {
     810                 :          0 :   const struct region *r1 = (const struct region *) p1;
     811                 :          0 :   const struct region *r2 = (const struct region *) p2;
     812                 :            : 
     813         [ #  # ]:          0 :   if (r1->from < r2->from)
     814                 :          0 :     return -1;
     815                 :            :   return 1;
     816                 :            : }
     817                 :            : 
     818                 :            : 
     819                 :            : static int
     820                 :         12 : compare_Elf32_Word (const void *p1, const void *p2)
     821                 :            : {
     822                 :         12 :   const Elf32_Word *w1 = p1;
     823                 :         12 :   const Elf32_Word *w2 = p2;
     824         [ +  + ]:         12 :   return *w1 < *w2 ? -1 : *w1 > *w2 ? 1 : 0;
     825                 :            : }
     826                 :            : 
     827                 :            : static int
     828                 :          0 : compare_Elf64_Xword (const void *p1, const void *p2)
     829                 :            : {
     830                 :          0 :   const Elf64_Xword *w1 = p1;
     831                 :          0 :   const Elf64_Xword *w2 = p2;
     832         [ #  # ]:          0 :   return *w1 < *w2 ? -1 : *w1 > *w2 ? 1 : 0;
     833                 :            : }
     834                 :            : 
     835                 :            : static bool
     836                 :          3 : hash_content_equivalent (size_t entsize, Elf_Data *data1, Elf_Data *data2)
     837                 :            : {
     838                 :            : #define CHECK_HASH(Hash_Word)                                                 \
     839                 :            :   {                                                                           \
     840                 :            :     const Hash_Word *const hash1 = data1->d_buf;                           \
     841                 :            :     const Hash_Word *const hash2 = data2->d_buf;                           \
     842                 :            :     const size_t nbucket = hash1[0];                                          \
     843                 :            :     const size_t nchain = hash1[1];                                           \
     844                 :            :     if (data1->d_size != (2 + nbucket + nchain) * sizeof hash1[0]          \
     845                 :            :         || hash2[0] != nbucket || hash2[1] != nchain)                         \
     846                 :            :       return false;                                                           \
     847                 :            :                                                                               \
     848                 :            :     const Hash_Word *const bucket1 = &hash1[2];                                   \
     849                 :            :     const Hash_Word *const chain1 = &bucket1[nbucket];                            \
     850                 :            :     const Hash_Word *const bucket2 = &hash2[2];                                   \
     851                 :            :     const Hash_Word *const chain2 = &bucket2[nbucket];                            \
     852                 :            :                                                                               \
     853                 :            :     bool chain_ok[nchain];                                                    \
     854                 :            :     Hash_Word temp1[nchain - 1];                                              \
     855                 :            :     Hash_Word temp2[nchain - 1];                                              \
     856                 :            :     memset (chain_ok, 0, sizeof chain_ok);                                    \
     857                 :            :     for (size_t i = 0; i < nbucket; ++i)                                   \
     858                 :            :       {                                                                       \
     859                 :            :         if (bucket1[i] >= nchain || bucket2[i] >= nchain)               \
     860                 :            :           return false;                                                       \
     861                 :            :                                                                               \
     862                 :            :         size_t b1 = 0;                                                        \
     863                 :            :         for (size_t p = bucket1[i]; p != STN_UNDEF; p = chain1[p])            \
     864                 :            :           if (p >= nchain || b1 >= nchain - 1)                                  \
     865                 :            :             return false;                                                     \
     866                 :            :           else                                                                \
     867                 :            :             temp1[b1++] = p;                                                  \
     868                 :            :                                                                               \
     869                 :            :         size_t b2 = 0;                                                        \
     870                 :            :         for (size_t p = bucket2[i]; p != STN_UNDEF; p = chain2[p])            \
     871                 :            :           if (p >= nchain || b2 >= nchain - 1)                                  \
     872                 :            :             return false;                                                     \
     873                 :            :           else                                                                \
     874                 :            :             temp2[b2++] = p;                                                  \
     875                 :            :                                                                               \
     876                 :            :         if (b1 != b2)                                                         \
     877                 :            :           return false;                                                       \
     878                 :            :                                                                               \
     879                 :            :         qsort (temp1, b1, sizeof temp1[0], compare_##Hash_Word);              \
     880                 :            :         qsort (temp2, b2, sizeof temp2[0], compare_##Hash_Word);              \
     881                 :            :                                                                               \
     882                 :            :         for (b1 = 0; b1 < b2; ++b1)                                        \
     883                 :            :           if (temp1[b1] != temp2[b1])                                         \
     884                 :            :             return false;                                                     \
     885                 :            :           else                                                                \
     886                 :            :             chain_ok[temp1[b1]] = true;                                       \
     887                 :            :       }                                                                       \
     888                 :            :                                                                               \
     889                 :            :     for (size_t i = 0; i < nchain; ++i)                                            \
     890                 :            :       if (!chain_ok[i] && chain1[i] != chain2[i])                             \
     891                 :            :         return false;                                                         \
     892                 :            :                                                                               \
     893                 :            :     return true;                                                              \
     894                 :            :   }
     895                 :            : 
     896      [ +  -  - ]:          3 :   switch (entsize)
     897                 :            :     {
     898                 :          3 :     case 4:
     899   [ +  -  +  -  :        351 :       CHECK_HASH (Elf32_Word);
          +  -  +  -  +  
          -  +  -  +  -  
          +  +  +  -  +  
          -  +  +  +  -  
          +  -  +  +  +  
          +  +  +  +  -  
                   +  + ]
     900                 :          0 :       break;
     901                 :          0 :     case 8:
     902   [ #  #  #  #  :          0 :       CHECK_HASH (Elf64_Xword);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
     903                 :            :       break;
     904                 :            :     }
     905                 :            : 
     906                 :            :   return false;
     907                 :            : }
     908                 :            : 
     909                 :            : 
     910                 :            : #include "debugpred.h"

Generated by: LCOV version 1.14