LCOV - code coverage report
Current view: top level - elfutils/libdw - dwarf_nextcu.c (source / functions) Hit Total Coverage
Test: lcov.out Lines: 39 42 92.9 %
Date: 2013-03-08 Functions: 2 2 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                 :            : /* Advance to next CU header.
       2                 :            :    Copyright (C) 2002-2010 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 <libdwP.h>
      35                 :            : #include <dwarf.h>
      36                 :            : 
      37                 :            : 
      38                 :            : int
      39                 :     111580 : dwarf_next_unit (dwarf, off, next_off, header_sizep, versionp, abbrev_offsetp,
      40                 :            :                  address_sizep, offset_sizep, type_signaturep, type_offsetp)
      41                 :            :      Dwarf *dwarf;
      42                 :            :      Dwarf_Off off;
      43                 :            :      Dwarf_Off *next_off;
      44                 :            :      size_t *header_sizep;
      45                 :            :      Dwarf_Half *versionp;
      46                 :            :      Dwarf_Off *abbrev_offsetp;
      47                 :            :      uint8_t *address_sizep;
      48                 :            :      uint8_t *offset_sizep;
      49                 :            :      uint64_t *type_signaturep;
      50                 :            :      Dwarf_Off *type_offsetp;
      51                 :            : {
      52                 :     111580 :   const bool debug_types = type_signaturep != NULL;
      53                 :     111580 :   const size_t sec_idx = debug_types ? IDX_debug_types : IDX_debug_info;
      54                 :            : 
      55                 :            :   /* Maybe there has been an error before.  */
      56         [ +  - ]:     111580 :   if (dwarf == NULL)
      57                 :            :     return -1;
      58                 :            : 
      59                 :            :   /* If we reached the end before don't do anything.  */
      60         [ +  - ]:     111580 :   if (off == (Dwarf_Off) -1l
      61         [ +  - ]:     111580 :       || unlikely (dwarf->sectiondata[sec_idx] == NULL)
      62                 :            :       /* Make sure there is enough space in the .debug_info section
      63                 :            :          for at least the initial word.  We cannot test the rest since
      64                 :            :          we don't know yet whether this is a 64-bit object or not.  */
      65         [ +  + ]:     111580 :       || unlikely (off + 4 >= dwarf->sectiondata[sec_idx]->d_size))
      66                 :            :     {
      67                 :        384 :       *next_off = (Dwarf_Off) -1l;
      68                 :            :       return 1;
      69                 :            :     }
      70                 :            : 
      71                 :            :   /* This points into the .debug_info section to the beginning of the
      72                 :            :      CU entry.  */
      73                 :     111196 :   const unsigned char *data = dwarf->sectiondata[sec_idx]->d_buf;
      74                 :     111196 :   const unsigned char *bytes = data + off;
      75                 :            : 
      76                 :            :   /* The format of the CU header is described in dwarf2p1 7.5.1:
      77                 :            : 
      78                 :            :      1.  A 4-byte or 12-byte unsigned integer representing the length
      79                 :            :          of the .debug_info contribution for that compilation unit, not
      80                 :            :          including the length field itself. In the 32-bit DWARF format,
      81                 :            :          this is a 4-byte unsigned integer (which must be less than
      82                 :            :          0xfffffff0); in the 64-bit DWARF format, this consists of the
      83                 :            :          4-byte value 0xffffffff followed by an 8-byte unsigned integer
      84                 :            :          that gives the actual length (see Section 7.2.2).
      85                 :            : 
      86                 :            :       2. A 2-byte unsigned integer representing the version of the
      87                 :            :          DWARF information for that compilation unit. For DWARF Version
      88                 :            :          2.1, the value in this field is 2.
      89                 :            : 
      90                 :            :       3. A 4-byte or 8-byte unsigned offset into the .debug_abbrev
      91                 :            :          section. This offset associates the compilation unit with a
      92                 :            :          particular set of debugging information entry abbreviations. In
      93                 :            :          the 32-bit DWARF format, this is a 4-byte unsigned length; in
      94                 :            :          the 64-bit DWARF format, this is an 8-byte unsigned length (see
      95                 :            :          Section 7.4).
      96                 :            : 
      97                 :            :       4. A 1-byte unsigned integer representing the size in bytes of
      98                 :            :          an address on the target architecture. If the system uses
      99                 :            :          segmented addressing, this value represents the size of the
     100                 :            :          offset portion of an address.  */
     101         [ +  + ]:     111196 :   uint64_t length = read_4ubyte_unaligned_inc (dwarf, bytes);
     102                 :     111196 :   size_t offset_size = 4;
     103                 :            :   /* Lengths of 0xfffffff0 - 0xffffffff are escape codes.  Oxffffffff is
     104                 :            :      used to indicate that 64-bit dwarf information is being used, the
     105                 :            :      other values are currently reserved.  */
     106         [ +  - ]:     111196 :   if (length == DWARF3_LENGTH_64_BIT)
     107                 :            :     offset_size = 8;
     108         [ -  + ]:     111196 :   else if (unlikely (length >= DWARF3_LENGTH_MIN_ESCAPE_CODE
     109                 :            :                      && length <= DWARF3_LENGTH_MAX_ESCAPE_CODE))
     110                 :            :     {
     111                 :            :     invalid:
     112                 :          0 :       __libdw_seterrno (DWARF_E_INVALID_DWARF);
     113                 :            :       return -1;
     114                 :            :     }
     115                 :            : 
     116                 :            :   /* Now we know how large the header is.  */
     117 [ +  + ][ -  + ]:     111196 :   if (unlikely (DIE_OFFSET_FROM_CU_OFFSET (off, offset_size, debug_types)
     118                 :            :                 >= dwarf->sectiondata[sec_idx]->d_size))
     119                 :            :     {
     120                 :          0 :       *next_off = -1;
     121                 :            :       return 1;
     122                 :            :     }
     123                 :            : 
     124         [ -  + ]:     111196 :   if (length == DWARF3_LENGTH_64_BIT)
     125                 :            :     /* This is a 64-bit DWARF format.  */
     126         [ #  # ]:          0 :     length = read_8ubyte_unaligned_inc (dwarf, bytes);
     127                 :            : 
     128                 :            :   /* Read the version stamp.  Always a 16-bit value.  */
     129 [ +  + ][ -  + ]:     111196 :   uint_fast16_t version = read_2ubyte_unaligned_inc (dwarf, bytes);
     130                 :            : 
     131                 :            :   /* Get offset in .debug_abbrev.  Note that the size of the entry
     132                 :            :      depends on whether this is a 32-bit or 64-bit DWARF definition.  */
     133                 :            :   uint64_t abbrev_offset;
     134         [ +  - ]:     111196 :   if (__libdw_read_offset_inc (dwarf, sec_idx, &bytes, offset_size,
     135                 :            :                                &abbrev_offset, IDX_debug_abbrev, 0))
     136                 :            :     return -1;
     137                 :            : 
     138                 :            :   /* The address size.  Always an 8-bit value.  */
     139                 :     111196 :   uint8_t address_size = *bytes++;
     140                 :            : 
     141         [ +  + ]:     111196 :   if (debug_types)
     142                 :            :     {
     143         [ -  + ]:          2 :       uint64_t type_sig8 = read_8ubyte_unaligned_inc (dwarf, bytes);
     144                 :            : 
     145                 :            :       Dwarf_Off type_offset;
     146         [ -  + ]:          2 :       if (__libdw_read_offset_inc (dwarf, sec_idx, &bytes, offset_size,
     147                 :            :                                    &type_offset, sec_idx, 0))
     148                 :            :         return -1;
     149                 :            : 
     150                 :            :       /* Validate that the TYPE_OFFSET points past the header.  */
     151         [ +  - ]:          2 :       if (unlikely (type_offset < (size_t) (bytes - (data + off))))
     152                 :            :         goto invalid;
     153                 :            : 
     154                 :          2 :       *type_signaturep = type_sig8;
     155         [ +  + ]:          2 :       if (type_offsetp != NULL)
     156                 :          2 :         *type_offsetp = type_offset;
     157                 :            :     }
     158                 :            : 
     159                 :            :   /* Store the header length.  */
     160         [ +  + ]:     111196 :   if (header_sizep != NULL)
     161                 :      91295 :     *header_sizep = bytes - (data + off);
     162                 :            : 
     163         [ +  + ]:     111196 :   if (versionp != NULL)
     164                 :      21256 :     *versionp = version;
     165                 :            : 
     166         [ +  + ]:     111196 :   if (abbrev_offsetp != NULL)
     167                 :      21274 :     *abbrev_offsetp = abbrev_offset;
     168                 :            : 
     169         [ +  + ]:     111196 :   if (address_sizep != NULL)
     170                 :      21274 :     *address_sizep = address_size;
     171                 :            : 
     172                 :            :   /* Store the offset size.  */
     173         [ +  + ]:     111196 :   if (offset_sizep != NULL)
     174                 :      21274 :     *offset_sizep = offset_size;
     175                 :            : 
     176                 :            :   /* See definition of DIE_OFFSET_FROM_CU_OFFSET macro
     177                 :            :      for an explanation of the trick in this expression.  */
     178                 :     111580 :   *next_off = off + 2 * offset_size - 4 + length;
     179                 :            : 
     180                 :            :   return 0;
     181                 :            : }
     182                 :            : INTDEF(dwarf_next_unit)
     183                 :            : 
     184                 :            : int
     185                 :      90276 : dwarf_nextcu (dwarf, off, next_off, header_sizep, abbrev_offsetp,
     186                 :            :               address_sizep, offset_sizep)
     187                 :            :      Dwarf *dwarf;
     188                 :            :      Dwarf_Off off;
     189                 :            :      Dwarf_Off *next_off;
     190                 :            :      size_t *header_sizep;
     191                 :            :      Dwarf_Off *abbrev_offsetp;
     192                 :            :      uint8_t *address_sizep;
     193                 :            :      uint8_t *offset_sizep;
     194                 :            : {
     195                 :      90276 :   return INTUSE(dwarf_next_unit) (dwarf, off, next_off, header_sizep, NULL,
     196                 :            :                                   abbrev_offsetp, address_sizep, offset_sizep,
     197                 :            :                                   NULL, NULL);
     198                 :            : }
     199                 :            : INTDEF(dwarf_nextcu)

Generated by: LCOV version 1.9