LCOV - code coverage report
Current view: top level - elfutils/libdw - dwarf_getpubnames.c (source / functions) Hit Total Coverage
Test: lcov.out Lines: 60 80 75.0 %
Date: 2013-03-08 Functions: 2 2 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 33 62 53.2 %

           Branch data     Line data    Source code
       1                 :            : /* Get public symbol information.
       2                 :            :    Copyright (C) 2002, 2003, 2004, 2005, 2008 Red Hat, Inc.
       3                 :            :    This file is part of elfutils.
       4                 :            :    Written by Ulrich Drepper <drepper@redhat.com>, 2002.
       5                 :            : 
       6                 :            :    This file is free software; you can redistribute it and/or modify
       7                 :            :    it under the terms of either
       8                 :            : 
       9                 :            :      * the GNU Lesser General Public License as published by the Free
      10                 :            :        Software Foundation; either version 3 of the License, or (at
      11                 :            :        your option) any later version
      12                 :            : 
      13                 :            :    or
      14                 :            : 
      15                 :            :      * the GNU General Public License as published by the Free
      16                 :            :        Software Foundation; either version 2 of the License, or (at
      17                 :            :        your option) any later version
      18                 :            : 
      19                 :            :    or both in parallel, as here.
      20                 :            : 
      21                 :            :    elfutils is distributed in the hope that it will be useful, but
      22                 :            :    WITHOUT ANY WARRANTY; without even the implied warranty of
      23                 :            :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      24                 :            :    General Public License for more details.
      25                 :            : 
      26                 :            :    You should have received copies of the GNU General Public License and
      27                 :            :    the GNU Lesser General Public License along with this program.  If
      28                 :            :    not, see <http://www.gnu.org/licenses/>.  */
      29                 :            : 
      30                 :            : #ifdef HAVE_CONFIG_H
      31                 :            : # include <config.h>
      32                 :            : #endif
      33                 :            : 
      34                 :            : #include <assert.h>
      35                 :            : #include <stdlib.h>
      36                 :            : #include <string.h>
      37                 :            : #include <sys/param.h>
      38                 :            : 
      39                 :            : #include <libdwP.h>
      40                 :            : #include <dwarf.h>
      41                 :            : 
      42                 :            : 
      43                 :            : static int
      44                 :         10 : get_offsets (Dwarf *dbg)
      45                 :            : {
      46                 :         10 :   size_t allocated = 0;
      47                 :         10 :   size_t cnt = 0;
      48                 :         10 :   struct pubnames_s *mem = NULL;
      49                 :         10 :   const size_t entsize = sizeof (struct pubnames_s);
      50                 :         10 :   unsigned char *const startp = dbg->sectiondata[IDX_debug_pubnames]->d_buf;
      51                 :         10 :   unsigned char *readp = startp;
      52                 :         10 :   unsigned char *endp = readp + dbg->sectiondata[IDX_debug_pubnames]->d_size;
      53                 :            : 
      54         [ +  + ]:         36 :   while (readp + 14 < endp)
      55                 :            :     {
      56                 :            :       /* If necessary, allocate more entries.  */
      57         [ +  + ]:         26 :       if (cnt >= allocated)
      58                 :            :         {
      59                 :         10 :           allocated = MAX (10, 2 * allocated);
      60                 :         10 :           struct pubnames_s *newmem
      61                 :         10 :             = (struct pubnames_s *) realloc (mem, allocated * entsize);
      62         [ -  + ]:         10 :           if (newmem == NULL)
      63                 :            :             {
      64                 :          0 :               __libdw_seterrno (DWARF_E_NOMEM);
      65                 :            :             err_return:
      66                 :          0 :               free (mem);
      67                 :          0 :               return -1;
      68                 :            :             }
      69                 :            : 
      70                 :            :           mem = newmem;
      71                 :            :         }
      72                 :            : 
      73                 :            :       /* Read the set header.  */
      74                 :         26 :       int len_bytes = 4;
      75         [ +  + ]:         26 :       Dwarf_Off len = read_4ubyte_unaligned_inc (dbg, readp);
      76         [ -  + ]:         26 :       if (len == DWARF3_LENGTH_64_BIT)
      77                 :            :         {
      78         [ #  # ]:          0 :           len = read_8ubyte_unaligned_inc (dbg, readp);
      79                 :          0 :           len_bytes = 8;
      80                 :            :         }
      81         [ -  + ]:         26 :       else if (unlikely (len >= DWARF3_LENGTH_MIN_ESCAPE_CODE
      82                 :            :                          && len <= DWARF3_LENGTH_MAX_ESCAPE_CODE))
      83                 :            :         {
      84                 :          0 :           __libdw_seterrno (DWARF_E_INVALID_DWARF);
      85                 :          0 :           goto err_return;
      86                 :            :         }
      87                 :            : 
      88                 :            :       /* Now we know the offset of the first offset/name pair.  */
      89                 :         26 :       mem[cnt].set_start = readp + 2 + 2 * len_bytes - startp;
      90                 :         26 :       mem[cnt].address_len = len_bytes;
      91         [ +  - ]:         26 :       if (mem[cnt].set_start >= dbg->sectiondata[IDX_debug_pubnames]->d_size)
      92                 :            :         /* Something wrong, the first entry is beyond the end of
      93                 :            :            the section.  */
      94                 :            :         break;
      95                 :            : 
      96                 :            :       /* Read the version.  It better be two for now.  */
      97 [ +  + ][ -  + ]:         26 :       uint16_t version = read_2ubyte_unaligned (dbg, readp);
      98         [ -  + ]:         26 :       if (unlikely (version != 2))
      99                 :            :         {
     100                 :          0 :           __libdw_seterrno (DWARF_E_INVALID_VERSION);
     101                 :          0 :           goto err_return;
     102                 :            :         }
     103                 :            : 
     104                 :            :       /* Get the CU offset.  */
     105         [ -  + ]:         26 :       if (__libdw_read_offset (dbg, dbg, IDX_debug_pubnames,
     106                 :            :                                readp + 2, len_bytes,
     107                 :            :                                &mem[cnt].cu_offset, IDX_debug_info, 3))
     108                 :            :         /* Error has been already set in reader.  */
     109                 :            :         goto err_return;
     110                 :            : 
     111                 :            :       /* Determine the size of the CU header.  */
     112                 :         26 :       unsigned char *infop
     113                 :         26 :         = ((unsigned char *) dbg->sectiondata[IDX_debug_info]->d_buf
     114                 :         26 :            + mem[cnt].cu_offset);
     115         [ -  + ]:         26 :       if (read_4ubyte_unaligned_noncvt (infop) == DWARF3_LENGTH_64_BIT)
     116                 :          0 :         mem[cnt].cu_header_size = 23;
     117                 :            :       else
     118                 :         26 :         mem[cnt].cu_header_size = 11;
     119                 :            : 
     120                 :         26 :       ++cnt;
     121                 :            : 
     122                 :            :       /* Advance to the next set.  */
     123                 :         26 :       readp += len;
     124                 :            :     }
     125                 :            : 
     126         [ -  + ]:         10 :   if (mem == NULL)
     127                 :            :     {
     128                 :          0 :       __libdw_seterrno (DWARF_E_NO_ENTRY);
     129                 :          0 :       return -1;
     130                 :            :     }
     131                 :            : 
     132                 :         10 :   dbg->pubnames_sets = (struct pubnames_s *) realloc (mem, cnt * entsize);
     133                 :         10 :   dbg->pubnames_nsets = cnt;
     134                 :            : 
     135                 :         10 :   return 0;
     136                 :            : }
     137                 :            : 
     138                 :            : 
     139                 :            : ptrdiff_t
     140                 :        298 : dwarf_getpubnames (dbg, callback, arg, offset)
     141                 :            :      Dwarf *dbg;
     142                 :            :      int (*callback) (Dwarf *, Dwarf_Global *, void *);
     143                 :            :      void *arg;
     144                 :            :      ptrdiff_t offset;
     145                 :            : {
     146         [ +  - ]:        298 :   if (dbg == NULL)
     147                 :            :     return -1l;
     148                 :            : 
     149         [ -  + ]:        298 :   if (unlikely (offset < 0))
     150                 :            :     {
     151                 :          0 :       __libdw_seterrno (DWARF_E_INVALID_OFFSET);
     152                 :          0 :       return -1l;
     153                 :            :     }
     154                 :            : 
     155                 :            :   /* Make sure it is a valid offset.  */
     156 [ +  + ][ +  - ]:        298 :   if (unlikely (dbg->sectiondata[IDX_debug_pubnames] == NULL
     157                 :            :                 || ((size_t) offset
     158                 :            :                     >= dbg->sectiondata[IDX_debug_pubnames]->d_size)))
     159                 :            :     /* No (more) entry.  */
     160                 :            :     return 0;
     161                 :            : 
     162                 :            :   /* If necessary read the set information.  */
     163 [ +  - ][ +  - ]:         10 :   if (dbg->pubnames_nsets == 0 && unlikely (get_offsets (dbg) != 0))
     164                 :            :     return -1l;
     165                 :            : 
     166                 :            :   /* Find the place where to start.  */
     167                 :            :   size_t cnt;
     168         [ -  + ]:         10 :   if (offset == 0)
     169                 :            :     {
     170                 :         10 :       cnt = 0;
     171                 :         10 :       offset = dbg->pubnames_sets[0].set_start;
     172                 :            :     }
     173                 :            :   else
     174                 :            :     {
     175         [ #  # ]:          0 :       for (cnt = 0; cnt + 1 < dbg->pubnames_nsets; ++cnt)
     176         [ #  # ]:          0 :         if ((Dwarf_Off) offset >= dbg->pubnames_sets[cnt].set_start)
     177                 :            :           {
     178         [ #  # ]:          0 :             assert ((Dwarf_Off) offset
     179                 :            :                     < dbg->pubnames_sets[cnt + 1].set_start);
     180                 :            :             break;
     181                 :            :           }
     182         [ #  # ]:          0 :       assert (cnt + 1 < dbg->pubnames_nsets);
     183                 :            :     }
     184                 :            : 
     185                 :         10 :   unsigned char *startp
     186                 :         10 :     = (unsigned char *) dbg->sectiondata[IDX_debug_pubnames]->d_buf;
     187                 :         10 :   unsigned char *readp = startp + offset;
     188                 :            :   while (1)
     189                 :            :     {
     190                 :            :       Dwarf_Global gl;
     191                 :            : 
     192                 :         26 :       gl.cu_offset = (dbg->pubnames_sets[cnt].cu_offset
     193                 :         26 :                       + dbg->pubnames_sets[cnt].cu_header_size);
     194                 :            : 
     195                 :            :       while (1)
     196                 :            :         {
     197                 :            :           /* READP points to the next offset/name pair.  */
     198         [ +  - ]:         68 :           if (dbg->pubnames_sets[cnt].address_len == 4)
     199         [ +  + ]:        105 :             gl.die_offset = read_4ubyte_unaligned_inc (dbg, readp);
     200                 :            :           else
     201         [ #  # ]:          0 :             gl.die_offset = read_8ubyte_unaligned_inc (dbg, readp);
     202                 :            : 
     203                 :            :           /* If the offset is zero we reached the end of the set.  */
     204         [ +  + ]:         68 :           if (gl.die_offset == 0)
     205                 :            :             break;
     206                 :            : 
     207                 :            :           /* Add the CU offset.  */
     208                 :         42 :           gl.die_offset += dbg->pubnames_sets[cnt].cu_offset;
     209                 :            : 
     210                 :         42 :           gl.name = (char *) readp;
     211                 :         42 :           readp = (unsigned char *) rawmemchr (gl.name, '\0') + 1;
     212                 :            : 
     213                 :            :           /* We found name and DIE offset.  Report it.  */
     214         [ +  - ]:         42 :           if (callback (dbg, &gl, arg) != DWARF_CB_OK)
     215                 :            :             {
     216                 :            :               /* The user wants us to stop.  Return the offset of the
     217                 :            :                  next entry.  */
     218                 :          0 :               return readp - startp;
     219                 :            :             }
     220                 :            :         }
     221                 :            : 
     222         [ +  + ]:         26 :       if (++cnt == dbg->pubnames_nsets)
     223                 :            :         /* This was the last set.  */
     224                 :            :         break;
     225                 :            : 
     226                 :         16 :       startp = (unsigned char *) dbg->sectiondata[IDX_debug_pubnames]->d_buf;
     227                 :         16 :       readp = startp + dbg->pubnames_sets[cnt].set_start;
     228                 :         16 :     }
     229                 :            : 
     230                 :            :   /* We are done.  No more entries.  */
     231                 :        298 :   return 0;
     232                 :            : }

Generated by: LCOV version 1.9