libdw/encoded-value.h

   1 /* DW_EH_PE_* support for libdw unwinder.
   2    Copyright (C) 2009-2010 Red Hat, Inc.
   3    This file is part of Red Hat elfutils.
   4
   5    Red Hat elfutils is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by the
   7    Free Software Foundation; version 2 of the License.
   8
   9    Red Hat elfutils is distributed in the hope that it will be useful, but
  10    WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12    General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License along
  15    with Red Hat elfutils; if not, write to the Free Software Foundation,
  16    Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA.
  17
  18    In addition, as a special exception, Red Hat, Inc. gives You the
  19    additional right to link the code of Red Hat elfutils with code licensed
  20    under any Open Source Initiative certified open source license
  21    (http://www.opensource.org/licenses/index.php) which requires the
  22    distribution of source code with any binary distribution and to
  23    distribute linked combinations of the two.  Non-GPL Code permitted under
  24    this exception must only link to the code of Red Hat elfutils through
  25    those well defined interfaces identified in the file named EXCEPTION
  26    found in the source code files (the "Approved Interfaces").  The files
  27    of Non-GPL Code may instantiate templates or use macros or inline
  28    functions from the Approved Interfaces without causing the resulting
  29    work to be covered by the GNU General Public License.  Only Red Hat,
  30    Inc. may make changes or additions to the list of Approved Interfaces.
  31    Red Hat's grant of this exception is conditioned upon your not adding
  32    any new exceptions.  If you wish to add a new Approved Interface or
  33    exception, please contact Red Hat.  You must obey the GNU General Public
  34    License in all respects for all of the Red Hat elfutils code and other
  35    code used in conjunction with Red Hat elfutils except the Non-GPL Code
  36    covered by this exception.  If you modify this file, you may extend this
  37    exception to your version of the file, but you are not obligated to do
  38    so.  If you do not wish to provide this exception without modification,
  39    you must delete this exception statement from your version and license
  40    this file solely under the GPL without exception.
  41
  42    Red Hat elfutils is an included package of the Open Invention Network.
  43    An included package of the Open Invention Network is a package for which
  44    Open Invention Network licensees cross-license their patents.  No patent
  45    license is granted, either expressly or impliedly, by designation as an
  46    included package.  Should you wish to participate in the Open Invention
  47    Network licensing program, please visit www.openinventionnetwork.com
  48    <http://www.openinventionnetwork.com>.  */
  49
  50 #ifndef _ENCODED_VALUE_H
  51 #define _ENCODED_VALUE_H 1
  52
  53 #include <dwarf.h>
  54 #include <stdlib.h>
  55 #include "libdwP.h"
  56
  57
  58 static size_t __attribute__ ((unused))
  59 encoded_value_size (const Elf_Data *data, const unsigned char e_ident[],
  60                     uint8_t encoding, const uint8_t *p)
  61 {
  62   if (encoding == DW_EH_PE_omit)
  63     return 0;
  64
  65   switch (encoding & 0x07)
  66     {
  67     case DW_EH_PE_udata2:
  68       return 2;
  69     case DW_EH_PE_udata4:
  70       return 4;
  71     case DW_EH_PE_udata8:
  72       return 8;
  73
  74     case DW_EH_PE_absptr:
  75       return e_ident[EI_CLASS] == ELFCLASS32 ? 4 : 8;
  76
  77     case DW_EH_PE_uleb128:
  78       if (p != NULL)
  79         {
  80           const uint8_t *end = p;
  81           while (end < (uint8_t *) data->d_buf + data->d_size)
  82             if (*end++ & 0x80u)
  83               return end - p;
  84         }
  85
  86     default:
  87       abort ();
  88       return 0;
  89     }
  90 }
  91
  92 static inline int __attribute__ ((unused))
  93 __libdw_cfi_read_address_inc (const Dwarf_CFI *cache,
  94                               const unsigned char **addrp,
  95                               int width, Dwarf_Addr *ret)
  96 {
  97   width = width ?: cache->e_ident[EI_CLASS] == ELFCLASS32 ? 4 : 8;
  98
  99   if (cache->dbg != NULL)
 100     return __libdw_read_address_inc (cache->dbg, IDX_debug_frame,
 101                                      addrp, width, ret);
 102
 103   /* Only .debug_frame might have relocation to consider.
 104      Read plain values from .eh_frame data.  */
 105
 106   if (width == 4)
 107     *ret = read_4ubyte_unaligned_inc (cache, *addrp);
 108   else
 109     *ret = read_8ubyte_unaligned_inc (cache, *addrp);
 110   return 0;
 111 }
 112
 113 static bool __attribute__ ((unused))
 114 read_encoded_value (const Dwarf_CFI *cache, uint8_t encoding, const uint8_t **p,
 115                     Dwarf_Addr *result)
 116 {
 117   *result = 0;
 118   switch (encoding & 0x70)
 119     {
 120     case DW_EH_PE_absptr:
 121       break;
 122     case DW_EH_PE_pcrel:
 123       *result = (cache->frame_vaddr
 124                  + (*p - (const uint8_t *) cache->data->d.d_buf));
 125       break;
 126     case DW_EH_PE_textrel:
 127       // ia64: segrel
 128       *result = cache->textrel;
 129       break;
 130     case DW_EH_PE_datarel:
 131       // i386: GOTOFF
 132       // ia64: gprel
 133       *result = cache->datarel;
 134       break;
 135     case DW_EH_PE_funcrel:      /* XXX */
 136       break;
 137     case DW_EH_PE_aligned:
 138       {
 139         const size_t size = encoded_value_size (&cache->data->d, cache->e_ident,
 140                                                 encoding, *p);
 141         size_t align = ((cache->frame_vaddr
 142                          + (*p - (const uint8_t *) cache->data->d.d_buf))
 143                         & (size - 1));
 144         if (align != 0)
 145           *p += size - align;
 146         break;
 147       }
 148
 149     default:
 150       abort ();
 151     }
 152
 153   Dwarf_Addr value;
 154   switch (encoding & 0x0f)
 155     {
 156     case DW_EH_PE_udata2:
 157       value = read_2ubyte_unaligned_inc (cache, *p);
 158       break;
 159
 160     case DW_EH_PE_sdata2:
 161       value = read_2sbyte_unaligned_inc (cache, *p);
 162       break;
 163
 164     case DW_EH_PE_udata4:
 165       if (__libdw_cfi_read_address_inc (cache, p, 4, &value))
 166         return true;
 167       break;
 168
 169     case DW_EH_PE_sdata4:
 170       if (__libdw_cfi_read_address_inc (cache, p, 4, &value))
 171         return true;
 172       value = (Dwarf_Sword) (Elf32_Sword) value; /* Sign-extend.  */
 173       break;
 174
 175     case DW_EH_PE_udata8:
 176     case DW_EH_PE_sdata8:
 177       if (__libdw_cfi_read_address_inc (cache, p, 8, &value))
 178         return true;
 179       break;
 180
 181     case DW_EH_PE_absptr:
 182       if (__libdw_cfi_read_address_inc (cache, p, 0, &value))
 183         return true;
 184       break;
 185
 186     case DW_EH_PE_uleb128:
 187       get_uleb128 (value, *p);
 188       break;
 189
 190     case DW_EH_PE_sleb128:
 191       get_sleb128 (value, *p);
 192       break;
 193
 194     default:
 195       abort ();
 196     }
 197
 198   *result += value;
 199
 200   if (encoding & DW_EH_PE_indirect)
 201     {
 202       if (unlikely (*result < cache->frame_vaddr))
 203         return true;
 204       *result -= cache->frame_vaddr;
 205       if (unlikely (*result > (cache->data->d.d_size
 206                                - encoded_value_size (NULL, cache->e_ident,
 207                                                      DW_EH_PE_absptr, NULL))))
 208         return true;
 209       const uint8_t *ptr = cache->data->d.d_buf + *result;
 210       return __libdw_cfi_read_address_inc (cache, &ptr, 0, result);
 211     }
 212
 213   return false;
 214 }
 215
 216 #endif  /* encoded-value.h */