Home | History | Annotate | Download | only in dwarf
      1 /* libunwind - a platform-independent unwind library
      2    Copyright (c) 2003-2005 Hewlett-Packard Development Company, L.P.
      3 	Contributed by David Mosberger-Tang <davidm (at) hpl.hp.com>
      4 
      5 This file is part of libunwind.
      6 
      7 Permission is hereby granted, free of charge, to any person obtaining
      8 a copy of this software and associated documentation files (the
      9 "Software"), to deal in the Software without restriction, including
     10 without limitation the rights to use, copy, modify, merge, publish,
     11 distribute, sublicense, and/or sell copies of the Software, and to
     12 permit persons to whom the Software is furnished to do so, subject to
     13 the following conditions:
     14 
     15 The above copyright notice and this permission notice shall be
     16 included in all copies or substantial portions of the Software.
     17 
     18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
     19 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
     20 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
     21 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
     22 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
     23 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
     24 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  */
     25 
     26 #include "dwarf_i.h"
     27 
     28 static inline int
     29 is_cie_id (unw_word_t val, int is_debug_frame)
     30 {
     31   /* The CIE ID is normally 0xffffffff (for 32-bit ELF) or
     32      0xffffffffffffffff (for 64-bit ELF).  However, .eh_frame
     33      uses 0.  */
     34   if (is_debug_frame)
     35     /* ANDROID support update. */
     36     return (val == (uint32_t) -1 || val == (unw_word_t) (uint64_t) -1);
     37     /* End of ANDROID update. */
     38   else
     39     return (val == 0);
     40 }
     41 
     42 /* Note: we don't need to keep track of more than the first four
     43    characters of the augmentation string, because we (a) ignore any
     44    augmentation string contents once we find an unrecognized character
     45    and (b) those characters that we do recognize, can't be
     46    repeated.  */
     47 static inline int
     48 parse_cie (unw_addr_space_t as, unw_accessors_t *a, unw_word_t addr,
     49 	   const unw_proc_info_t *pi, struct dwarf_cie_info *dci,
     50 	   unw_word_t base, void *arg)
     51 {
     52   uint8_t version, ch, augstr[5], fde_encoding, handler_encoding;
     53   unw_word_t len, cie_end_addr, aug_size;
     54   uint32_t u32val;
     55   uint64_t u64val;
     56   size_t i;
     57   int ret;
     58 # define STR2(x)	#x
     59 # define STR(x)		STR2(x)
     60 
     61   /* Pick appropriate default for FDE-encoding.  DWARF spec says
     62      start-IP (initial_location) and the code-size (address_range) are
     63      "address-unit sized constants".  The `R' augmentation can be used
     64      to override this, but by default, we pick an address-sized unit
     65      for fde_encoding.  */
     66   switch (dwarf_addr_size (as))
     67     {
     68     case 4:	fde_encoding = DW_EH_PE_udata4; break;
     69     case 8:	fde_encoding = DW_EH_PE_udata8; break;
     70     default:	fde_encoding = DW_EH_PE_omit; break;
     71     }
     72 
     73   dci->lsda_encoding = DW_EH_PE_omit;
     74   dci->handler = 0;
     75 
     76   if ((ret = dwarf_readu32 (as, a, &addr, &u32val, arg)) < 0)
     77     return ret;
     78 
     79   if (u32val != 0xffffffff)
     80     {
     81       /* the CIE is in the 32-bit DWARF format */
     82       uint32_t cie_id;
     83       /* DWARF says CIE id should be 0xffffffff, but in .eh_frame, it's 0 */
     84       const uint32_t expected_id = (base) ? 0xffffffff : 0;
     85 
     86       len = u32val;
     87       cie_end_addr = addr + len;
     88       if ((ret = dwarf_readu32 (as, a, &addr, &cie_id, arg)) < 0)
     89 	return ret;
     90       if (cie_id != expected_id)
     91 	{
     92 	  Debug (1, "Unexpected CIE id %x\n", cie_id);
     93 	  return -UNW_EINVAL;
     94 	}
     95     }
     96   else
     97     {
     98       /* the CIE is in the 64-bit DWARF format */
     99       uint64_t cie_id;
    100       /* DWARF says CIE id should be 0xffffffffffffffff, but in
    101 	 .eh_frame, it's 0 */
    102       const uint64_t expected_id = (base) ? 0xffffffffffffffffull : 0;
    103 
    104       if ((ret = dwarf_readu64 (as, a, &addr, &u64val, arg)) < 0)
    105 	return ret;
    106       len = u64val;
    107       cie_end_addr = addr + len;
    108       if ((ret = dwarf_readu64 (as, a, &addr, &cie_id, arg)) < 0)
    109 	return ret;
    110       if (cie_id != expected_id)
    111 	{
    112 	  Debug (1, "Unexpected CIE id %llx\n", (long long) cie_id);
    113 	  return -UNW_EINVAL;
    114 	}
    115     }
    116   dci->cie_instr_end = cie_end_addr;
    117 
    118   if ((ret = dwarf_readu8 (as, a, &addr, &version, arg)) < 0)
    119     return ret;
    120 
    121   if (version != 1 && version != DWARF_CIE_VERSION)
    122     {
    123       Debug (1, "Got CIE version %u, expected version 1 or "
    124 	     STR (DWARF_CIE_VERSION) "\n", version);
    125       return -UNW_EBADVERSION;
    126     }
    127 
    128   /* read and parse the augmentation string: */
    129   memset (augstr, 0, sizeof (augstr));
    130   for (i = 0;;)
    131     {
    132       if ((ret = dwarf_readu8 (as, a, &addr, &ch, arg)) < 0)
    133 	return ret;
    134 
    135       if (!ch)
    136 	break;	/* end of augmentation string */
    137 
    138       if (i < sizeof (augstr) - 1)
    139 	augstr[i++] = ch;
    140     }
    141 
    142   if ((ret = dwarf_read_uleb128 (as, a, &addr, &dci->code_align, arg)) < 0
    143       || (ret = dwarf_read_sleb128 (as, a, &addr, &dci->data_align, arg)) < 0)
    144     return ret;
    145 
    146   /* Read the return-address column either as a u8 or as a uleb128.  */
    147   if (version == 1)
    148     {
    149       if ((ret = dwarf_readu8 (as, a, &addr, &ch, arg)) < 0)
    150 	return ret;
    151       dci->ret_addr_column = ch;
    152     }
    153   else if ((ret = dwarf_read_uleb128 (as, a, &addr, &dci->ret_addr_column,
    154 				      arg)) < 0)
    155     return ret;
    156 
    157   i = 0;
    158   if (augstr[0] == 'z')
    159     {
    160       dci->sized_augmentation = 1;
    161       if ((ret = dwarf_read_uleb128 (as, a, &addr, &aug_size, arg)) < 0)
    162 	return ret;
    163       i++;
    164     }
    165 
    166   for (; i < sizeof (augstr) && augstr[i]; ++i)
    167     switch (augstr[i])
    168       {
    169       case 'L':
    170 	/* read the LSDA pointer-encoding format.  */
    171 	if ((ret = dwarf_readu8 (as, a, &addr, &ch, arg)) < 0)
    172 	  return ret;
    173 	dci->lsda_encoding = ch;
    174 	break;
    175 
    176       case 'R':
    177 	/* read the FDE pointer-encoding format.  */
    178 	if ((ret = dwarf_readu8 (as, a, &addr, &fde_encoding, arg)) < 0)
    179 	  return ret;
    180 	break;
    181 
    182       case 'P':
    183 	/* read the personality-routine pointer-encoding format.  */
    184 	if ((ret = dwarf_readu8 (as, a, &addr, &handler_encoding, arg)) < 0)
    185 	  return ret;
    186 	if ((ret = dwarf_read_encoded_pointer (as, a, &addr, handler_encoding,
    187 					       pi, &dci->handler, arg)) < 0)
    188 	  return ret;
    189 	break;
    190 
    191       case 'S':
    192 	/* This is a signal frame. */
    193 	dci->signal_frame = 1;
    194 
    195 	/* Temporarily set it to one so dwarf_parse_fde() knows that
    196 	   it should fetch the actual ABI/TAG pair from the FDE.  */
    197 	dci->have_abi_marker = 1;
    198 	break;
    199 
    200       default:
    201 	Debug (1, "Unexpected augmentation string `%s'\n", augstr);
    202 	if (dci->sized_augmentation)
    203 	  /* If we have the size of the augmentation body, we can skip
    204 	     over the parts that we don't understand, so we're OK. */
    205 	  goto done;
    206 	else
    207 	  return -UNW_EINVAL;
    208       }
    209  done:
    210   dci->fde_encoding = fde_encoding;
    211   dci->cie_instr_start = addr;
    212   Debug (15, "CIE parsed OK, augmentation = \"%s\", handler=0x%lx\n",
    213 	 augstr, (long) dci->handler);
    214   return 0;
    215 }
    216 
    217 /* Extract proc-info from the FDE starting at adress ADDR.
    218 
    219    Pass BASE as zero for eh_frame behaviour, or a pointer to
    220    debug_frame base for debug_frame behaviour.  */
    221 
    222 HIDDEN int
    223 dwarf_extract_proc_info_from_fde (unw_addr_space_t as, unw_accessors_t *a,
    224 				  unw_word_t *addrp, unw_proc_info_t *pi,
    225 				  int need_unwind_info, unw_word_t base,
    226 				  void *arg)
    227 {
    228   unw_word_t fde_end_addr, cie_addr, cie_offset_addr, aug_end_addr = 0;
    229   unw_word_t start_ip, ip_range, aug_size, addr = *addrp;
    230   int ret, ip_range_encoding;
    231   struct dwarf_cie_info dci;
    232   uint64_t u64val;
    233   uint32_t u32val;
    234 
    235   Debug (12, "FDE @ 0x%lx\n", (long) addr);
    236 
    237   memset (&dci, 0, sizeof (dci));
    238 
    239   if ((ret = dwarf_readu32 (as, a, &addr, &u32val, arg)) < 0)
    240     return ret;
    241 
    242   if (u32val != 0xffffffff)
    243     {
    244       int32_t cie_offset;
    245 
    246       /* In some configurations, an FDE with a 0 length indicates the
    247 	 end of the FDE-table.  */
    248       if (u32val == 0)
    249 	return -UNW_ENOINFO;
    250 
    251       /* the FDE is in the 32-bit DWARF format */
    252 
    253       *addrp = fde_end_addr = addr + u32val;
    254       cie_offset_addr = addr;
    255 
    256       if ((ret = dwarf_reads32 (as, a, &addr, &cie_offset, arg)) < 0)
    257 	return ret;
    258 
    259       if (is_cie_id (cie_offset, base != 0))
    260 	/* ignore CIEs (happens during linear searches) */
    261 	return 0;
    262 
    263       if (base != 0)
    264         cie_addr = base + cie_offset;
    265       else
    266 	/* DWARF says that the CIE_pointer in the FDE is a
    267 	   .debug_frame-relative offset, but the GCC-generated .eh_frame
    268 	   sections instead store a "pcrelative" offset, which is just
    269 	   as fine as it's self-contained.  */
    270 	cie_addr = cie_offset_addr - cie_offset;
    271     }
    272   else
    273     {
    274       int64_t cie_offset;
    275 
    276       /* the FDE is in the 64-bit DWARF format */
    277 
    278       if ((ret = dwarf_readu64 (as, a, &addr, &u64val, arg)) < 0)
    279 	return ret;
    280 
    281       *addrp = fde_end_addr = addr + u64val;
    282       cie_offset_addr = addr;
    283 
    284       if ((ret = dwarf_reads64 (as, a, &addr, &cie_offset, arg)) < 0)
    285 	return ret;
    286 
    287       if (is_cie_id (cie_offset, base != 0))
    288 	/* ignore CIEs (happens during linear searches) */
    289 	return 0;
    290 
    291       if (base != 0)
    292 	cie_addr = base + cie_offset;
    293       else
    294 	/* DWARF says that the CIE_pointer in the FDE is a
    295 	   .debug_frame-relative offset, but the GCC-generated .eh_frame
    296 	   sections instead store a "pcrelative" offset, which is just
    297 	   as fine as it's self-contained.  */
    298 	cie_addr = (unw_word_t) ((uint64_t) cie_offset_addr - cie_offset);
    299     }
    300 
    301   Debug (15, "looking for CIE at address %lx\n", (long) cie_addr);
    302 
    303   if ((ret = parse_cie (as, a, cie_addr, pi, &dci, base, arg)) < 0)
    304     return ret;
    305 
    306   /* IP-range has same encoding as FDE pointers, except that it's
    307      always an absolute value: */
    308   ip_range_encoding = dci.fde_encoding & DW_EH_PE_FORMAT_MASK;
    309 
    310   if ((ret = dwarf_read_encoded_pointer (as, a, &addr, dci.fde_encoding,
    311 					 pi, &start_ip, arg)) < 0
    312       || (ret = dwarf_read_encoded_pointer (as, a, &addr, ip_range_encoding,
    313 					    pi, &ip_range, arg)) < 0)
    314     return ret;
    315   pi->start_ip = start_ip;
    316   pi->end_ip = start_ip + ip_range;
    317   pi->handler = dci.handler;
    318 
    319   if (dci.sized_augmentation)
    320     {
    321       if ((ret = dwarf_read_uleb128 (as, a, &addr, &aug_size, arg)) < 0)
    322 	return ret;
    323       aug_end_addr = addr + aug_size;
    324     }
    325 
    326   if ((ret = dwarf_read_encoded_pointer (as, a, &addr, dci.lsda_encoding,
    327 					 pi, &pi->lsda, arg)) < 0)
    328     return ret;
    329 
    330   Debug (15, "FDE covers IP 0x%lx-0x%lx, LSDA=0x%lx\n",
    331 	 (long) pi->start_ip, (long) pi->end_ip, (long) pi->lsda);
    332 
    333   if (need_unwind_info)
    334     {
    335       pi->format = UNW_INFO_FORMAT_TABLE;
    336       pi->unwind_info_size = sizeof (dci);
    337       pi->unwind_info = mempool_alloc (&dwarf_cie_info_pool);
    338       if (!pi->unwind_info)
    339 	return -UNW_ENOMEM;
    340 
    341       if (dci.have_abi_marker)
    342 	{
    343 	  if ((ret = dwarf_readu16 (as, a, &addr, &dci.abi, arg)) < 0
    344 	      || (ret = dwarf_readu16 (as, a, &addr, &dci.tag, arg)) < 0)
    345 	    return ret;
    346 	  Debug (13, "Found ABI marker = (abi=%u, tag=%u)\n",
    347 		 dci.abi, dci.tag);
    348 	}
    349 
    350       if (dci.sized_augmentation)
    351 	dci.fde_instr_start = aug_end_addr;
    352       else
    353 	dci.fde_instr_start = addr;
    354       dci.fde_instr_end = fde_end_addr;
    355 
    356       memcpy (pi->unwind_info, &dci, sizeof (dci));
    357     }
    358   return 0;
    359 }
    360