LCOV - code coverage report
Current view: top level - libdwelf - dwelf_elf_gnu_build_id.c (source / functions) Hit Total Coverage
Test: elfutils-0.189 Lines: 51 59 86.4 %
Date: 2023-06-17 01:14:47 Functions: 4 4 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 34 48 70.8 %

           Branch data     Line data    Source code
       1                 :            : /* Returns the build id if found in a NT_GNU_BUILD_ID note.
       2                 :            :    Copyright (C) 2014 Red Hat, Inc.
       3                 :            :    This file is part of elfutils.
       4                 :            : 
       5                 :            :    This file is free software; you can redistribute it and/or modify
       6                 :            :    it under the terms of either
       7                 :            : 
       8                 :            :      * the GNU Lesser General Public License as published by the Free
       9                 :            :        Software Foundation; either version 3 of the License, or (at
      10                 :            :        your option) any later version
      11                 :            : 
      12                 :            :    or
      13                 :            : 
      14                 :            :      * the GNU General Public License as published by the Free
      15                 :            :        Software Foundation; either version 2 of the License, or (at
      16                 :            :        your option) any later version
      17                 :            : 
      18                 :            :    or both in parallel, as here.
      19                 :            : 
      20                 :            :    elfutils is distributed in the hope that it will be useful, but
      21                 :            :    WITHOUT ANY WARRANTY; without even the implied warranty of
      22                 :            :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      23                 :            :    General Public License for more details.
      24                 :            : 
      25                 :            :    You should have received copies of the GNU General Public License and
      26                 :            :    the GNU Lesser General Public License along with this program.  If
      27                 :            :    not, see <http://www.gnu.org/licenses/>.  */
      28                 :            : 
      29                 :            : #ifdef HAVE_CONFIG_H
      30                 :            : # include <config.h>
      31                 :            : #endif
      32                 :            : 
      33                 :            : #include "libdwelfP.h"
      34                 :            : #include "libdwflP.h"
      35                 :            : 
      36                 :            : #define NO_VADDR        ((GElf_Addr) -1l)
      37                 :            : 
      38                 :            : static int
      39                 :        732 : check_notes (Elf_Data *data, GElf_Addr data_elfaddr,
      40                 :            :              const void **build_id_bits, GElf_Addr *build_id_elfaddr,
      41                 :            :              int *build_id_len)
      42                 :            : {
      43                 :        732 :   size_t pos = 0;
      44                 :        732 :   GElf_Nhdr nhdr;
      45                 :        732 :   size_t name_pos;
      46                 :        732 :   size_t desc_pos;
      47         [ +  + ]:       1026 :   while ((pos = gelf_getnote (data, pos, &nhdr, &name_pos, &desc_pos)) > 0)
      48         [ +  + ]:        742 :     if (nhdr.n_type == NT_GNU_BUILD_ID
      49         [ +  - ]:        448 :         && nhdr.n_namesz == sizeof "GNU"
      50         [ +  - ]:        448 :         && !memcmp (data->d_buf + name_pos, "GNU", sizeof "GNU"))
      51                 :            :         {
      52                 :        448 :           *build_id_bits = data->d_buf + desc_pos;
      53                 :        896 :           *build_id_elfaddr = (data_elfaddr == NO_VADDR
      54         [ +  + ]:        448 :                               ? 0 : data_elfaddr + desc_pos);
      55                 :        448 :           *build_id_len = nhdr.n_descsz;
      56                 :        448 :           return 1;
      57                 :            :         }
      58                 :            :   return 0;
      59                 :            : }
      60                 :            : 
      61                 :            : /* Defined here for reuse. The dwelf interface doesn't care about the
      62                 :            :    address of the note, but libdwfl does.  */
      63                 :            : static int
      64                 :        462 : find_elf_build_id (Dwfl_Module *mod, int e_type, Elf *elf,
      65                 :            :                    const void **build_id_bits, GElf_Addr *build_id_elfaddr,
      66                 :            :                    int *build_id_len)
      67                 :            : {
      68                 :        462 :   size_t shstrndx = SHN_UNDEF;
      69                 :        462 :   int result = 0;
      70                 :            : 
      71                 :        462 :   Elf_Scn *scn = elf_nextscn (elf, NULL);
      72                 :            : 
      73         [ +  + ]:        463 :   if (scn == NULL)
      74                 :            :     {
      75                 :            :       /* No sections, have to look for phdrs.  */
      76                 :          9 :       size_t phnum;
      77         [ -  + ]:          9 :       if (unlikely (elf_getphdrnum (elf, &phnum) != 0))
      78                 :            :         {
      79         [ #  # ]:          0 :           if (mod != NULL)
      80                 :          0 :             __libdwfl_seterrno (DWFL_E_LIBELF);
      81                 :          0 :           return -1;
      82                 :            :         }
      83   [ +  +  +  - ]:         46 :       for (size_t i = 0; result == 0 && i < phnum; ++i)
      84                 :            :         {
      85                 :         37 :           GElf_Phdr phdr_mem;
      86                 :         37 :           GElf_Phdr *phdr = gelf_getphdr (elf, i, &phdr_mem);
      87   [ +  -  +  + ]:         37 :           if (likely (phdr != NULL) && phdr->p_type == PT_NOTE)
      88                 :          9 :             result = check_notes (elf_getdata_rawchunk (elf,
      89                 :          9 :                                                         phdr->p_offset,
      90                 :            :                                                         phdr->p_filesz,
      91         [ +  - ]:          9 :                                                         (phdr->p_align == 8
      92                 :            :                                                          ? ELF_T_NHDR8
      93                 :            :                                                          : ELF_T_NHDR)),
      94                 :            :                                   phdr->p_vaddr,
      95                 :            :                                   build_id_bits,
      96                 :            :                                   build_id_elfaddr,
      97                 :            :                                   build_id_len);
      98                 :            :         }
      99                 :            :     }
     100                 :            :   else
     101                 :       1309 :     do
     102                 :            :       {
     103                 :       1309 :         GElf_Shdr shdr_mem;
     104                 :       1309 :         GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
     105   [ +  -  +  + ]:       1308 :         if (likely (shdr != NULL) && shdr->sh_type == SHT_NOTE)
     106                 :            :           {
     107                 :            :             /* Determine the right sh_addr in this module.  */
     108                 :        723 :             GElf_Addr vaddr = 0;
     109         [ +  + ]:        723 :             if (!(shdr->sh_flags & SHF_ALLOC))
     110                 :         41 :               vaddr = NO_VADDR;
     111         [ +  - ]:        682 :             else if (mod == NULL || e_type != ET_REL)
     112                 :        682 :               vaddr = shdr->sh_addr;
     113         [ #  # ]:          0 :             else if (__libdwfl_relocate_value (mod, elf, &shstrndx,
     114                 :          0 :                                                elf_ndxscn (scn), &vaddr))
     115                 :          0 :               vaddr = NO_VADDR;
     116                 :        723 :             result = check_notes (elf_getdata (scn, NULL), vaddr,
     117                 :            :                                   build_id_bits,
     118                 :            :                                   build_id_elfaddr,
     119                 :            :                                   build_id_len);
     120                 :            :           }
     121                 :            :       }
     122   [ +  +  +  + ]:       1309 :     while (result == 0 && (scn = elf_nextscn (elf, scn)) != NULL);
     123                 :            : 
     124                 :            :   return result;
     125                 :            : }
     126                 :            : 
     127                 :            : int
     128                 :            : internal_function
     129                 :        175 : __libdwfl_find_elf_build_id (Dwfl_Module *mod, Elf *elf,
     130                 :            :                              const void **build_id_bits,
     131                 :            :                              GElf_Addr *build_id_elfaddr, int *build_id_len)
     132                 :            : {
     133                 :        175 :   GElf_Ehdr ehdr_mem, *ehdr = gelf_getehdr (elf, &ehdr_mem);
     134         [ -  + ]:        175 :   if (unlikely (ehdr == NULL))
     135                 :            :     {
     136                 :          0 :       __libdwfl_seterrno (DWFL_E_LIBELF);
     137                 :          0 :       return -1;
     138                 :            :     }
     139                 :            :   // MOD->E_TYPE is zero here.
     140   [ +  +  -  + ]:        175 :   assert (ehdr->e_type != ET_REL || mod != NULL);
     141                 :            : 
     142                 :        175 :   return find_elf_build_id (mod, ehdr->e_type, elf,
     143                 :            :                             build_id_bits, build_id_elfaddr, build_id_len);
     144                 :            : }
     145                 :            : 
     146                 :            : ssize_t
     147                 :        288 : dwelf_elf_gnu_build_id (Elf *elf, const void **build_idp)
     148                 :            : {
     149                 :        288 :   GElf_Addr build_id_elfaddr;
     150                 :        288 :   int build_id_len;
     151                 :        288 :   int result = find_elf_build_id (NULL, ET_NONE, elf, build_idp,
     152                 :            :                                   &build_id_elfaddr, &build_id_len);
     153         [ +  + ]:        288 :   if (result > 0)
     154                 :        287 :     return build_id_len;
     155                 :            : 
     156                 :          1 :   return result;
     157                 :            : }
     158                 :            : INTDEF(dwelf_elf_gnu_build_id)

Generated by: LCOV version 1.16