LCOV - code coverage report
Current view: top level - libdw - dwarf_next_cfi.c (source / functions) Hit Total Coverage
Test: elfutils-0.173 Lines: 62 88 70.5 %
Date: 2018-06-29 23:49:12 Functions: 1 1 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* Advance to next CFI entry.
       2             :    Copyright (C) 2009-2010, 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 "cfi.h"
      34             : #include "encoded-value.h"
      35             : 
      36             : #include <string.h>
      37             : 
      38             : 
      39             : int
      40       25058 : dwarf_next_cfi (const unsigned char e_ident[],
      41             :                 Elf_Data *data,
      42             :                 bool eh_frame_p,
      43             :                 Dwarf_Off off,
      44             :                 Dwarf_Off *next_off,
      45             :                 Dwarf_CFI_Entry *entry)
      46             : {
      47             :   /* Dummy struct for memory-access.h macros.  */
      48       25058 :   BYTE_ORDER_DUMMY (dw, e_ident);
      49             : 
      50             :   /* If we reached the end before don't do anything.  */
      51       25058 :   if (off == (Dwarf_Off) -1l
      52             :       /* Make sure there is enough space in the .debug_frame section
      53             :          for at least the initial word.  We cannot test the rest since
      54             :          we don't know yet whether this is a 64-bit object or not.  */
      55       24953 :       || unlikely (off + 4 >= data->d_size))
      56             :     {
      57             :     done:
      58         147 :       *next_off = (Dwarf_Off) -1l;
      59         147 :       return 1;
      60             :     }
      61             : 
      62             :   /* This points into the .debug_frame section at the start of the entry.  */
      63       24912 :   const uint8_t *bytes = data->d_buf + off;
      64       24912 :   const uint8_t *limit = data->d_buf + data->d_size;
      65             : 
      66             :   /* The format of a CFI entry is described in DWARF3 6.4.1:
      67             :    */
      68             : 
      69       45341 :   uint64_t length = read_4ubyte_unaligned_inc (&dw, bytes);
      70       24912 :   size_t offset_size = 4;
      71       24912 :   if (length == DWARF3_LENGTH_64_BIT)
      72             :     {
      73             :       /* This is the 64-bit DWARF format.  */
      74           0 :       offset_size = 8;
      75           0 :       if (unlikely (limit - bytes < 8))
      76             :         {
      77             :         invalid:
      78           0 :           __libdw_seterrno (DWARF_E_INVALID_DWARF);
      79           0 :           return -1;
      80             :         }
      81           0 :       length = read_8ubyte_unaligned_inc (&dw, bytes);
      82             :     }
      83             : 
      84             :   /* Not explicitly in the DWARF spec, but mentioned in the LSB exception
      85             :      frames (.eh_frame) spec. If Length contains the value 0, then this
      86             :      CIE shall be considered a terminator and processing shall end.  */
      87       24912 :   if (length == 0)
      88             :     goto done;
      89             : 
      90       24911 :   if (unlikely ((uint64_t) (limit - bytes) < length)
      91       24911 :       || unlikely (length < offset_size + 1))
      92             :     goto invalid;
      93             : 
      94             :   /* Now we know how large the entry is.  Note the trick in the
      95             :      computation.  If the offset_size is 4 the '- 4' term undoes the
      96             :      '2 *'.  If offset_size is 8 this term computes the size of the
      97             :      escape value plus the 8 byte offset.  */
      98       24911 :   *next_off = off + (2 * offset_size - 4) + length;
      99             : 
     100       24911 :   limit = bytes + length;
     101             : 
     102       24911 :   const uint8_t *const cie_pointer_start = bytes;
     103       24911 :   if (offset_size == 8)
     104           0 :     entry->cie.CIE_id = read_8ubyte_unaligned_inc (&dw, bytes);
     105             :   else
     106             :     {
     107       45339 :       entry->cie.CIE_id = read_4ubyte_unaligned_inc (&dw, bytes);
     108             :       /* Canonicalize the 32-bit CIE_ID value to 64 bits.  */
     109       24911 :       if (!eh_frame_p && entry->cie.CIE_id == DW_CIE_ID_32)
     110          68 :         entry->cie.CIE_id = DW_CIE_ID_64;
     111             :     }
     112       24911 :   if (eh_frame_p)
     113             :     {
     114             :       /* Canonicalize the .eh_frame CIE pointer to .debug_frame format.  */
     115       24732 :       if (entry->cie.CIE_id == 0)
     116        3206 :         entry->cie.CIE_id = DW_CIE_ID_64;
     117             :       else
     118             :         {
     119             :           /* In .eh_frame format, a CIE pointer is the distance from where
     120             :              it appears back to the beginning of the CIE.  */
     121       21526 :           ptrdiff_t pos = cie_pointer_start - (const uint8_t *) data->d_buf;
     122       21526 :           if (unlikely (entry->cie.CIE_id > (Dwarf_Off) pos)
     123       21526 :               || unlikely (pos <= (ptrdiff_t) offset_size))
     124             :             goto invalid;
     125       21526 :           entry->cie.CIE_id = pos - entry->cie.CIE_id;
     126             :         }
     127             :     }
     128             : 
     129       24911 :   if (entry->cie.CIE_id == DW_CIE_ID_64)
     130             :     {
     131             :       /* Read the version stamp.  Always an 8-bit value.  */
     132        3274 :       uint8_t version = *bytes++;
     133             : 
     134        3274 :       if (version != 1 && (unlikely (version < 3) || unlikely (version > 4)))
     135             :         goto invalid;
     136             : 
     137        3274 :       entry->cie.augmentation = (const char *) bytes;
     138             : 
     139        3274 :       bytes = memchr (bytes, '\0', limit - bytes);
     140        3274 :       if (unlikely (bytes == NULL))
     141             :         goto invalid;
     142        3274 :       ++bytes;
     143             : 
     144             :       /* The address size for CFI is implicit in the ELF class.  */
     145        3274 :       uint_fast8_t address_size = e_ident[EI_CLASS] == ELFCLASS32 ? 4 : 8;
     146        3274 :       uint_fast8_t segment_size = 0;
     147        3274 :       if (version >= 4)
     148             :         {
     149           0 :           if (unlikely (limit - bytes < 5))
     150             :             goto invalid;
     151             :           /* XXX We don't actually support address_size not matching the class.
     152             :              To do so, we'd have to return it here so that intern_new_cie
     153             :              could use it choose a specific fde_encoding.  */
     154           0 :           if (unlikely (*bytes != address_size))
     155             :             {
     156           0 :               __libdw_seterrno (DWARF_E_VERSION);
     157           0 :               return -1;
     158             :             }
     159           0 :           address_size = *bytes++;
     160           0 :           segment_size = *bytes++;
     161             :           /* We don't actually support segment selectors.  We'd have to
     162             :              roll this into the fde_encoding bits or something.  */
     163           0 :           if (unlikely (segment_size != 0))
     164             :             {
     165           0 :               __libdw_seterrno (DWARF_E_VERSION);
     166           0 :               return -1;
     167             :             }
     168             :         }
     169             : 
     170        3274 :       const char *ap = entry->cie.augmentation;
     171             : 
     172             :       /* g++ v2 "eh" has pointer immediately following augmentation string,
     173             :          so it must be handled first.  */
     174        3274 :       if (unlikely (ap[0] == 'e' && ap[1] == 'h'))
     175             :         {
     176           0 :           ap += 2;
     177           0 :           bytes += address_size;
     178             :         }
     179             : 
     180        3274 :       if (bytes >= limit)
     181             :         goto invalid;
     182        3274 :       get_uleb128 (entry->cie.code_alignment_factor, bytes, limit);
     183             : 
     184        3274 :       if (bytes >= limit)
     185             :         goto invalid;
     186        3274 :       get_sleb128 (entry->cie.data_alignment_factor, bytes, limit);
     187             : 
     188        3274 :       if (bytes >= limit)
     189             :         goto invalid;
     190             : 
     191        3274 :       if (version >= 3)              /* DWARF 3+ */
     192           0 :         get_uleb128 (entry->cie.return_address_register, bytes, limit);
     193             :       else                      /* DWARF 2 */
     194        3274 :         entry->cie.return_address_register = *bytes++;
     195             : 
     196             :       /* If we have sized augmentation data,
     197             :          we don't need to grok it all.  */
     198        3274 :       entry->cie.fde_augmentation_data_size = 0;
     199        3274 :       bool sized_augmentation = *ap == 'z';
     200        3274 :       if (sized_augmentation)
     201             :         {
     202        3205 :           if (bytes >= limit)
     203             :             goto invalid;
     204        3205 :           get_uleb128 (entry->cie.augmentation_data_size, bytes, limit);
     205        3205 :           if ((Dwarf_Word) (limit - bytes) < entry->cie.augmentation_data_size)
     206             :             goto invalid;
     207        3205 :           entry->cie.augmentation_data = bytes;
     208        3205 :           bytes += entry->cie.augmentation_data_size;
     209             :         }
     210             :       else
     211             :         {
     212          69 :           entry->cie.augmentation_data = bytes;
     213             : 
     214          69 :           for (; *ap != '\0'; ++ap)
     215             :             {
     216             :               uint8_t encoding;
     217           0 :               switch (*ap)
     218             :                 {
     219             :                 case 'L':               /* Skip LSDA pointer encoding byte.  */
     220             :                 case 'R':               /* Skip FDE address encoding byte.  */
     221           0 :                   encoding = *bytes++;
     222             :                   entry->cie.fde_augmentation_data_size
     223           0 :                     += encoded_value_size (data, e_ident, encoding, NULL);
     224           0 :                   continue;
     225             :                 case 'P':   /* Skip encoded personality routine pointer. */
     226           0 :                   encoding = *bytes++;
     227           0 :                   bytes += encoded_value_size (data, e_ident, encoding, bytes);
     228           0 :                   continue;
     229             :                 case 'S':               /* Skip signal-frame flag.  */
     230           0 :                   continue;
     231             :                 default:
     232             :                   /* Unknown augmentation string.  initial_instructions might
     233             :                      actually start with some augmentation data.  */
     234             :                   break;
     235             :                 }
     236             :               break;
     237             :             }
     238             :           entry->cie.augmentation_data_size
     239          69 :             = bytes - entry->cie.augmentation_data;
     240             :         }
     241             : 
     242        3274 :       entry->cie.initial_instructions = bytes;
     243        3274 :       entry->cie.initial_instructions_end = limit;
     244             :     }
     245             :   else
     246             :     {
     247       21637 :       entry->fde.start = bytes;
     248       21637 :       entry->fde.end = limit;
     249             :     }
     250             : 
     251             :   return 0;
     252             : }
     253             : INTDEF (dwarf_next_cfi)

Generated by: LCOV version 1.13