LCOV - code coverage report
Current view: top level - libdwelf - dwelf_elf_gnu_build_id.c (source / functions) Coverage Total Hit
Test: elfutils-0.193 Lines: 86.2 % 58 50
Test Date: 2025-08-30 14:31:09 Functions: 100.0 % 4 4
Legend: Lines:     hit not hit
Branches: + taken - not taken # not executed
Branches: 70.8 % 48 34

             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                 :        2434 : 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                 :        2434 :   size_t pos = 0;
      44                 :        2434 :   GElf_Nhdr nhdr;
      45                 :        2434 :   size_t name_pos;
      46                 :        2434 :   size_t desc_pos;
      47         [ +  + ]:        3478 :   while ((pos = gelf_getnote (data, pos, &nhdr, &name_pos, &desc_pos)) > 0)
      48         [ +  + ]:        2464 :     if (nhdr.n_type == NT_GNU_BUILD_ID
      49         [ +  - ]:        1420 :         && nhdr.n_namesz == sizeof "GNU"
      50         [ +  - ]:        1420 :         && !memcmp (data->d_buf + name_pos, "GNU", sizeof "GNU"))
      51                 :             :         {
      52                 :        1420 :           *build_id_bits = data->d_buf + desc_pos;
      53                 :        2840 :           *build_id_elfaddr = (data_elfaddr == NO_VADDR
      54         [ +  + ]:        1420 :                               ? 0 : data_elfaddr + desc_pos);
      55                 :        1420 :           *build_id_len = nhdr.n_descsz;
      56                 :        1420 :           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                 :        1490 : 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                 :        1490 :   size_t shstrndx = SHN_UNDEF;
      69                 :        1490 :   int result = 0;
      70                 :             : 
      71                 :        1490 :   Elf_Scn *scn = elf_nextscn (elf, NULL);
      72                 :             : 
      73         [ +  + ]:        1490 :   if (scn == NULL)
      74                 :             :     {
      75                 :             :       /* No sections, have to look for phdrs.  */
      76                 :          12 :       size_t phnum;
      77         [ -  + ]:          12 :       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   [ +  +  +  - ]:          68 :       for (size_t i = 0; result == 0 && i < phnum; ++i)
      84                 :             :         {
      85                 :          56 :           GElf_Phdr phdr_mem;
      86                 :          56 :           GElf_Phdr *phdr = gelf_getphdr (elf, i, &phdr_mem);
      87   [ +  -  +  + ]:          56 :           if (likely (phdr != NULL) && phdr->p_type == PT_NOTE)
      88                 :          12 :             result = check_notes (elf_getdata_rawchunk (elf,
      89                 :          12 :                                                         phdr->p_offset,
      90                 :             :                                                         phdr->p_filesz,
      91         [ +  - ]:          12 :                                                         (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                 :        5789 :     do
     102                 :             :       {
     103                 :        5789 :         GElf_Shdr shdr_mem;
     104                 :        5789 :         GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
     105   [ +  -  +  + ]:        5789 :         if (likely (shdr != NULL) && shdr->sh_type == SHT_NOTE)
     106                 :             :           {
     107                 :             :             /* Determine the right sh_addr in this module.  */
     108                 :        2421 :             GElf_Addr vaddr = 0;
     109         [ +  + ]:        2421 :             if (!(shdr->sh_flags & SHF_ALLOC))
     110                 :         126 :               vaddr = NO_VADDR;
     111         [ +  - ]:        2295 :             else if (mod == NULL || e_type != ET_REL)
     112                 :        2295 :               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                 :        2421 :             result = check_notes (elf_getdata (scn, NULL), vaddr,
     117                 :             :                                   build_id_bits,
     118                 :             :                                   build_id_elfaddr,
     119                 :             :                                   build_id_len);
     120                 :             :           }
     121                 :             :       }
     122   [ +  +  +  + ]:        5790 :     while (result == 0 && (scn = elf_nextscn (elf, scn)) != NULL);
     123                 :             : 
     124                 :             :   return result;
     125                 :             : }
     126                 :             : 
     127                 :             : int
     128                 :             : internal_function
     129                 :         456 : __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                 :         456 :   GElf_Ehdr ehdr_mem, *ehdr = gelf_getehdr (elf, &ehdr_mem);
     134         [ -  + ]:         456 :   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   [ +  +  -  + ]:         456 :   assert (ehdr->e_type != ET_REL || mod != NULL);
     141                 :             : 
     142                 :         456 :   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                 :        1034 : dwelf_elf_gnu_build_id (Elf *elf, const void **build_idp)
     148                 :             : {
     149                 :        1034 :   GElf_Addr build_id_elfaddr;
     150                 :        1034 :   int build_id_len;
     151                 :        1034 :   int result = find_elf_build_id (NULL, ET_NONE, elf, build_idp,
     152                 :             :                                   &build_id_elfaddr, &build_id_len);
     153         [ +  + ]:        1034 :   if (result > 0)
     154                 :         992 :     return build_id_len;
     155                 :             : 
     156                 :             :   return result;
     157                 :             : }
     158                 :             : INTDEF(dwelf_elf_gnu_build_id)
        

Generated by: LCOV version 2.0-1