LCOV - code coverage report
Current view: top level - elfutils/libdw - dwarf_getaranges.c (source / functions) Hit Total Coverage
Test: lcov.out Lines: 70 85 82.4 %
Date: 2013-03-08 Functions: 2 2 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 39 64 60.9 %

           Branch data     Line data    Source code
       1                 :            : /* Return list address ranges.
       2                 :            :    Copyright (C) 2000-2010 Red Hat, Inc.
       3                 :            :    This file is part of elfutils.
       4                 :            :    Written by Ulrich Drepper <drepper@redhat.com>, 2000.
       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 <stdlib.h>
      35                 :            : #include <assert.h>
      36                 :            : #include "libdwP.h"
      37                 :            : #include <dwarf.h>
      38                 :            : 
      39                 :            : struct arangelist
      40                 :            : {
      41                 :            :   Dwarf_Arange arange;
      42                 :            :   struct arangelist *next;
      43                 :            : };
      44                 :            : 
      45                 :            : /* Compare by Dwarf_Arange.addr, given pointers into an array of pointeers.  */
      46                 :            : static int
      47                 :      11246 : compare_aranges (const void *a, const void *b)
      48                 :            : {
      49                 :      11246 :   struct arangelist *const *p1 = a, *const *p2 = b;
      50                 :      11246 :   struct arangelist *l1 = *p1, *l2 = *p2;
      51                 :      11246 :   return l1->arange.addr - l2->arange.addr;
      52                 :            : }
      53                 :            : 
      54                 :            : int
      55                 :         63 : dwarf_getaranges (dbg, aranges, naranges)
      56                 :            :      Dwarf *dbg;
      57                 :            :      Dwarf_Aranges **aranges;
      58                 :            :      size_t *naranges;
      59                 :            : {
      60         [ +  - ]:         63 :   if (dbg == NULL)
      61                 :            :     return -1;
      62                 :            : 
      63         [ -  + ]:         63 :   if (dbg->aranges != NULL)
      64                 :            :     {
      65                 :          0 :       *aranges = dbg->aranges;
      66         [ #  # ]:          0 :       if (naranges != NULL)
      67                 :          0 :         *naranges = dbg->aranges->naranges;
      68                 :            :       return 0;
      69                 :            :     }
      70                 :            : 
      71         [ +  + ]:         63 :   if (dbg->sectiondata[IDX_debug_aranges] == NULL)
      72                 :            :     {
      73                 :            :       /* No such section.  */
      74                 :          4 :       *aranges = NULL;
      75         [ +  - ]:          4 :       if (naranges != NULL)
      76                 :          4 :         *naranges = 0;
      77                 :            :       return 0;
      78                 :            :     }
      79                 :            : 
      80         [ +  - ]:         59 :   if (dbg->sectiondata[IDX_debug_aranges]->d_buf == NULL)
      81                 :            :     return -1;
      82                 :            : 
      83                 :         59 :   struct arangelist *arangelist = NULL;
      84                 :         59 :   unsigned int narangelist = 0;
      85                 :            : 
      86                 :         59 :   const unsigned char *readp = dbg->sectiondata[IDX_debug_aranges]->d_buf;
      87                 :         59 :   const unsigned char *readendp
      88                 :         59 :     = readp + dbg->sectiondata[IDX_debug_aranges]->d_size;
      89                 :            : 
      90         [ +  + ]:       1422 :   while (readp < readendp)
      91                 :            :     {
      92                 :       1363 :       const unsigned char *hdrstart = readp;
      93                 :            : 
      94                 :            :       /* Each entry starts with a header:
      95                 :            : 
      96                 :            :          1. A 4-byte or 12-byte length containing the length of the
      97                 :            :          set of entries for this compilation unit, not including the
      98                 :            :          length field itself. [...]
      99                 :            : 
     100                 :            :          2. A 2-byte version identifier containing the value 2 for
     101                 :            :          DWARF Version 2.1.
     102                 :            : 
     103                 :            :          3. A 4-byte or 8-byte offset into the .debug_info section. [...]
     104                 :            : 
     105                 :            :          4. A 1-byte unsigned integer containing the size in bytes of
     106                 :            :          an address (or the offset portion of an address for segmented
     107                 :            :          addressing) on the target system.
     108                 :            : 
     109                 :            :          5. A 1-byte unsigned integer containing the size in bytes of
     110                 :            :          a segment descriptor on the target system.  */
     111         [ +  + ]:       1363 :       Dwarf_Word length = read_4ubyte_unaligned_inc (dbg, readp);
     112                 :       1363 :       unsigned int length_bytes = 4;
     113         [ -  + ]:       1363 :       if (length == DWARF3_LENGTH_64_BIT)
     114                 :            :         {
     115                 :          0 :           length = read_8ubyte_unaligned_inc (dbg, readp);
     116                 :          0 :           length_bytes = 8;
     117                 :            :         }
     118         [ +  - ]:       1363 :       else if (unlikely (length >= DWARF3_LENGTH_MIN_ESCAPE_CODE
     119                 :            :                          && length <= DWARF3_LENGTH_MAX_ESCAPE_CODE))
     120                 :            :         goto invalid;
     121                 :            : 
     122 [ +  + ][ -  + ]:       1363 :       unsigned int version = read_2ubyte_unaligned_inc (dbg, readp);
     123         [ -  + ]:       1363 :       if (version != 2)
     124                 :            :         {
     125                 :            :         invalid:
     126                 :          0 :           __libdw_seterrno (DWARF_E_INVALID_DWARF);
     127                 :            :         fail:
     128         [ #  # ]:          0 :           while (arangelist != NULL)
     129                 :            :             {
     130                 :          0 :               struct arangelist *next = arangelist->next;
     131                 :          0 :               free (arangelist);
     132                 :          0 :               arangelist = next;
     133                 :            :             }
     134                 :            :           return -1;
     135                 :            :         }
     136                 :            : 
     137                 :            :       Dwarf_Word offset;
     138         [ +  - ]:       1363 :       if (__libdw_read_offset_inc (dbg,
     139                 :            :                                    IDX_debug_aranges, &readp,
     140                 :            :                                    length_bytes, &offset, IDX_debug_info, 4))
     141                 :            :         goto fail;
     142                 :            : 
     143                 :       1363 :       unsigned int address_size = *readp++;
     144         [ -  + ]:       1363 :       if (address_size != 4 && address_size != 8)
     145                 :            :         goto invalid;
     146                 :            : 
     147                 :            :       /* Ignore the segment size value.  */
     148                 :            :       // XXX Really?
     149                 :       1363 :       (void) *readp++;
     150                 :            : 
     151                 :            :       /* Round the address to the next multiple of 2*address_size.  */
     152                 :       1363 :       readp += ((2 * address_size - ((readp - hdrstart) % (2 * address_size)))
     153                 :       1363 :                 % (2 * address_size));
     154                 :            : 
     155                 :            :       while (1)
     156                 :            :         {
     157                 :            :           Dwarf_Word range_address;
     158                 :            :           Dwarf_Word range_length;
     159                 :            : 
     160         [ +  - ]:       3707 :           if (__libdw_read_address_inc (dbg, IDX_debug_aranges, &readp,
     161                 :            :                                         address_size, &range_address))
     162                 :            :             goto fail;
     163                 :            : 
     164         [ +  + ]:       3707 :           if (address_size == 4)
     165         [ +  + ]:         46 :             range_length = read_4ubyte_unaligned_inc (dbg, readp);
     166                 :            :           else
     167         [ +  + ]:       3683 :             range_length = read_8ubyte_unaligned_inc (dbg, readp);
     168                 :            : 
     169                 :            :           /* Two zero values mark the end.  */
     170         [ +  + ]:       3707 :           if (range_address == 0 && range_length == 0)
     171                 :            :             break;
     172                 :            : 
     173                 :            :           /* We don't use alloca for these temporary structures because
     174                 :            :              the total number of them can be quite large.  */
     175                 :       2344 :           struct arangelist *new_arange = malloc (sizeof *new_arange);
     176         [ -  + ]:       2344 :           if (unlikely (new_arange == NULL))
     177                 :            :             {
     178                 :          0 :               __libdw_seterrno (DWARF_E_NOMEM);
     179                 :            :               goto fail;
     180                 :            :             }
     181                 :            : 
     182                 :       2344 :           new_arange->arange.addr = range_address;
     183                 :       2344 :           new_arange->arange.length = range_length;
     184                 :            : 
     185                 :            :           /* We store the actual CU DIE offset, not the CU header offset.  */
     186                 :       4688 :           const char *cu_header = (dbg->sectiondata[IDX_debug_info]->d_buf
     187                 :       2344 :                                    + offset);
     188                 :            :           unsigned int offset_size;
     189         [ +  - ]:       2344 :           if (read_4ubyte_unaligned_noncvt (cu_header) == DWARF3_LENGTH_64_BIT)
     190                 :            :             offset_size = 8;
     191                 :            :           else
     192                 :       2344 :             offset_size = 4;
     193                 :       2344 :           new_arange->arange.offset = DIE_OFFSET_FROM_CU_OFFSET (offset,
     194                 :            :                                                                  offset_size,
     195                 :            :                                                                  false);
     196                 :            : 
     197                 :       2344 :           new_arange->next = arangelist;
     198                 :       2344 :           arangelist = new_arange;
     199                 :       2344 :           ++narangelist;
     200                 :            : 
     201                 :            :           /* Sanity-check the data.  */
     202         [ +  - ]:       2344 :           if (unlikely (new_arange->arange.offset
     203                 :            :                         >= dbg->sectiondata[IDX_debug_info]->d_size))
     204                 :            :             goto invalid;
     205                 :       3707 :         }
     206                 :            :     }
     207                 :            : 
     208         [ -  + ]:         59 :   if (narangelist == 0)
     209                 :            :     {
     210         [ #  # ]:          0 :       assert (arangelist == NULL);
     211         [ #  # ]:          0 :       if (naranges != NULL)
     212                 :          0 :         *naranges = 0;
     213                 :          0 :       *aranges = NULL;
     214                 :            :       return 0;
     215                 :            :     }
     216                 :            : 
     217                 :            :   /* Allocate the array for the result.  */
     218         [ +  + ]:         59 :   void *buf = libdw_alloc (dbg, Dwarf_Aranges,
     219                 :            :                            sizeof (Dwarf_Aranges)
     220                 :            :                            + narangelist * sizeof (Dwarf_Arange), 1);
     221                 :            : 
     222                 :            :   /* First use the buffer for the pointers, and sort the entries.
     223                 :            :      We'll write the pointers in the end of the buffer, and then
     224                 :            :      copy into the buffer from the beginning so the overlap works.  */
     225                 :            :   assert (sizeof (Dwarf_Arange) >= sizeof (Dwarf_Arange *));
     226                 :         59 :   struct arangelist **sortaranges
     227                 :            :     = (buf + sizeof (Dwarf_Aranges)
     228                 :         59 :        + ((sizeof (Dwarf_Arange) - sizeof sortaranges[0]) * narangelist));
     229                 :            : 
     230                 :            :   /* The list is in LIFO order and usually they come in clumps with
     231                 :            :      ascending addresses.  So fill from the back to probably start with
     232                 :            :      runs already in order before we sort.  */
     233                 :         59 :   unsigned int i = narangelist;
     234         [ +  + ]:       2403 :   while (i-- > 0)
     235                 :            :     {
     236                 :       2344 :       sortaranges[i] = arangelist;
     237                 :       2344 :       arangelist = arangelist->next;
     238                 :            :     }
     239         [ -  + ]:         59 :   assert (arangelist == NULL);
     240                 :            : 
     241                 :            :   /* Sort by ascending address.  */
     242                 :         59 :   qsort (sortaranges, narangelist, sizeof sortaranges[0], &compare_aranges);
     243                 :            : 
     244                 :            :   /* Now that they are sorted, put them in the final array.
     245                 :            :      The buffers overlap, so we've clobbered the early elements
     246                 :            :      of SORTARANGES by the time we're reading the later ones.  */
     247                 :         59 :   *aranges = buf;
     248                 :         59 :   (*aranges)->dbg = dbg;
     249                 :         59 :   (*aranges)->naranges = narangelist;
     250                 :         59 :   dbg->aranges = *aranges;
     251         [ +  - ]:         59 :   if (naranges != NULL)
     252                 :         59 :     *naranges = narangelist;
     253         [ +  + ]:       2407 :   for (i = 0; i < narangelist; ++i)
     254                 :            :     {
     255                 :       2344 :       struct arangelist *elt = sortaranges[i];
     256                 :       2344 :       (*aranges)->info[i] = elt->arange;
     257                 :       2344 :       free (elt);
     258                 :            :     }
     259                 :            : 
     260                 :            :   return 0;
     261                 :            : }
     262                 :            : INTDEF(dwarf_getaranges)

Generated by: LCOV version 1.9