src/libs/libunwind/arm/Gex_tables.c

   1 /* libunwind - a platform-independent unwind library
   2    Copyright 2011 Linaro Limited
   3
   4 This file is part of libunwind.
   5
   6 Permission is hereby granted, free of charge, to any person obtaining
   7 a copy of this software and associated documentation files (the
   8 "Software"), to deal in the Software without restriction, including
   9 without limitation the rights to use, copy, modify, merge, publish,
  10 distribute, sublicense, and/or sell copies of the Software, and to
  11 permit persons to whom the Software is furnished to do so, subject to
  12 the following conditions:
  13
  14 The above copyright notice and this permission notice shall be
  15 included in all copies or substantial portions of the Software.
  16
  17 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  18 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  19 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  20 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  21 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  22 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  23 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  */
  24
  25 /* This file contains functionality for parsing and interpreting the ARM
  26 specific unwind information.  Documentation about the exception handling
  27 ABI for the ARM architecture can be found at:
  28 http://infocenter.arm.com/help/topic/com.arm.doc.ihi0038a/IHI0038A_ehabi.pdf
  29 */
  30
  31 #include "libunwind_i.h"
  32
  33 #define ARM_EXBUF_START(x)      (((x) >> 4) & 0x0f)
  34 #define ARM_EXBUF_COUNT(x)      ((x) & 0x0f)
  35 #define ARM_EXBUF_END(x)        (ARM_EXBUF_START(x) + ARM_EXBUF_COUNT(x))
  36
  37 #define ARM_EXIDX_CANT_UNWIND   0x00000001
  38 #define ARM_EXIDX_COMPACT       0x80000000
  39
  40 #define ARM_EXTBL_OP_FINISH     0xb0
  41
  42 enum arm_exbuf_cmd_flags {
  43   ARM_EXIDX_VFP_SHIFT_16 = 1 << 16,
  44   ARM_EXIDX_VFP_DOUBLE = 1 << 17,
  45 };
  46
  47 struct arm_cb_data
  48   {
  49     /* in: */
  50     unw_word_t ip;             /* instruction-pointer we're looking for */
  51     unw_proc_info_t *pi;       /* proc-info pointer */
  52     /* out: */
  53     unw_dyn_info_t di;         /* info about the ARM exidx segment */
  54   };
  55
  56 static inline uint32_t CONST_ATTR
  57 prel31_read (uint32_t prel31)
  58 {
  59   return ((int32_t)prel31 << 1) >> 1;
  60 }
  61
  62 static inline int
  63 prel31_to_addr (unw_addr_space_t as, void *arg, unw_word_t prel31,
  64                 unw_word_t *val)
  65 {
  66   unw_word_t offset;
  67
  68   if ((*as->acc.access_mem)(as, prel31, &offset, 0, arg) < 0)
  69     return -UNW_EINVAL;
  70
  71   offset = ((long)offset << 1) >> 1;
  72   *val = prel31 + offset;
  73
  74   return 0;
  75 }
  76
  77 /**
  78  * Applies the given command onto the new state to the given dwarf_cursor.
  79  */
  80 HIDDEN int
  81 arm_exidx_apply_cmd (struct arm_exbuf_data *edata, struct dwarf_cursor *c)
  82 {
  83   int ret = 0;
  84   unsigned i;
  85
  86   switch (edata->cmd)
  87     {
  88     case ARM_EXIDX_CMD_FINISH:
  89       /* Set LR to PC if not set already.  */
  90       if (DWARF_IS_NULL_LOC (c->loc[UNW_ARM_R15]))
  91         c->loc[UNW_ARM_R15] = c->loc[UNW_ARM_R14];
  92       /* Set IP.  */
  93       dwarf_get (c, c->loc[UNW_ARM_R15], &c->ip);
  94       break;
  95     case ARM_EXIDX_CMD_DATA_PUSH:
  96       Debug (2, "vsp = vsp - %d\n", edata->data);
  97       c->cfa -= edata->data;
  98       break;
  99     case ARM_EXIDX_CMD_DATA_POP:
 100       Debug (2, "vsp = vsp + %d\n", edata->data);
 101       c->cfa += edata->data;
 102       break;
 103     case ARM_EXIDX_CMD_REG_POP:
 104       for (i = 0; i < 16; i++)
 105         if (edata->data & (1 << i))
 106           {
 107             Debug (2, "pop {r%d}\n", i);
 108             c->loc[UNW_ARM_R0 + i] = DWARF_LOC (c->cfa, 0);
 109             c->cfa += 4;
 110           }
 111       /* Set cfa in case the SP got popped. */
 112       if (edata->data & (1 << 13))
 113         dwarf_get (c, c->loc[UNW_ARM_R13], &c->cfa);
 114       break;
 115     case ARM_EXIDX_CMD_REG_TO_SP:
 116       assert (edata->data < 16);
 117       Debug (2, "vsp = r%d\n", edata->data);
 118       c->loc[UNW_ARM_R13] = c->loc[UNW_ARM_R0 + edata->data];
 119       dwarf_get (c, c->loc[UNW_ARM_R13], &c->cfa);
 120       break;
 121     case ARM_EXIDX_CMD_VFP_POP:
 122       /* Skip VFP registers, but be sure to adjust stack */
 123       for (i = ARM_EXBUF_START (edata->data); i <= ARM_EXBUF_END (edata->data);
 124            i++)
 125         c->cfa += 8;
 126       if (!(edata->data & ARM_EXIDX_VFP_DOUBLE))
 127         c->cfa += 4;
 128       break;
 129     case ARM_EXIDX_CMD_WREG_POP:
 130       for (i = ARM_EXBUF_START (edata->data); i <= ARM_EXBUF_END (edata->data);
 131            i++)
 132         c->cfa += 8;
 133       break;
 134     case ARM_EXIDX_CMD_WCGR_POP:
 135       for (i = 0; i < 4; i++)
 136         if (edata->data & (1 << i))
 137           c->cfa += 4;
 138       break;
 139     case ARM_EXIDX_CMD_REFUSED:
 140     case ARM_EXIDX_CMD_RESERVED:
 141       ret = -1;
 142       break;
 143     }
 144   return ret;
 145 }
 146
 147 /**
 148  * Decodes the given unwind instructions into arm_exbuf_data and calls
 149  * arm_exidx_apply_cmd that applies the command onto the dwarf_cursor.
 150  */
 151 HIDDEN int
 152 arm_exidx_decode (const uint8_t *buf, uint8_t len, struct dwarf_cursor *c)
 153 {
 154 #define READ_OP() *buf++
 155   const uint8_t *end = buf + len;
 156   int ret;
 157   struct arm_exbuf_data edata;
 158
 159   assert(buf != NULL);
 160   assert(len > 0);
 161
 162   while (buf < end)
 163     {
 164       uint8_t op = READ_OP ();
 165       if ((op & 0xc0) == 0x00)
 166         {
 167           edata.cmd = ARM_EXIDX_CMD_DATA_POP;
 168           edata.data = (((int)op & 0x3f) << 2) + 4;
 169         }
 170       else if ((op & 0xc0) == 0x40)
 171         {
 172           edata.cmd = ARM_EXIDX_CMD_DATA_PUSH;
 173           edata.data = (((int)op & 0x3f) << 2) + 4;
 174         }
 175       else if ((op & 0xf0) == 0x80)
 176         {
 177           uint8_t op2 = READ_OP ();
 178           if (op == 0x80 && op2 == 0x00)
 179             edata.cmd = ARM_EXIDX_CMD_REFUSED;
 180           else
 181             {
 182               edata.cmd = ARM_EXIDX_CMD_REG_POP;
 183               edata.data = ((op & 0xf) << 8) | op2;
 184               edata.data = edata.data << 4;
 185             }
 186         }
 187       else if ((op & 0xf0) == 0x90)
 188         {
 189           if (op == 0x9d || op == 0x9f)
 190             edata.cmd = ARM_EXIDX_CMD_RESERVED;
 191           else
 192             {
 193               edata.cmd = ARM_EXIDX_CMD_REG_TO_SP;
 194               edata.data = op & 0x0f;
 195             }
 196         }
 197       else if ((op & 0xf0) == 0xa0)
 198         {
 199           unsigned end = (op & 0x07);
 200           edata.data = (1 << (end + 1)) - 1;
 201           edata.data = edata.data << 4;
 202           if (op & 0x08)
 203             edata.data |= 1 << 14;
 204           edata.cmd = ARM_EXIDX_CMD_REG_POP;
 205         }
 206       else if (op == ARM_EXTBL_OP_FINISH)
 207         {
 208           edata.cmd = ARM_EXIDX_CMD_FINISH;
 209           buf = end;
 210         }
 211       else if (op == 0xb1)
 212         {
 213           uint8_t op2 = READ_OP ();
 214           if (op2 == 0 || (op2 & 0xf0))
 215             edata.cmd = ARM_EXIDX_CMD_RESERVED;
 216           else
 217             {
 218               edata.cmd = ARM_EXIDX_CMD_REG_POP;
 219               edata.data = op2 & 0x0f;
 220             }
 221         }
 222       else if (op == 0xb2)
 223         {
 224           uint32_t offset = 0;
 225           uint8_t byte, shift = 0;
 226           do
 227             {
 228               byte = READ_OP ();
 229               offset |= (byte & 0x7f) << shift;
 230               shift += 7;
 231             }
 232           while (byte & 0x80);
 233           edata.data = offset * 4 + 0x204;
 234           edata.cmd = ARM_EXIDX_CMD_DATA_POP;
 235         }
 236       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
 237         {
 238           edata.cmd = ARM_EXIDX_CMD_VFP_POP;
 239           edata.data = READ_OP ();
 240           if (op == 0xc8)
 241             edata.data |= ARM_EXIDX_VFP_SHIFT_16;
 242           if (op != 0xb3)
 243             edata.data |= ARM_EXIDX_VFP_DOUBLE;
 244         }
 245       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
 246         {
 247           edata.cmd = ARM_EXIDX_CMD_VFP_POP;
 248           edata.data = 0x80 | (op & 0x07);
 249           if ((op & 0xf8) == 0xd0)
 250             edata.data |= ARM_EXIDX_VFP_DOUBLE;
 251         }
 252       else if (op >= 0xc0 && op <= 0xc5)
 253         {
 254           edata.cmd = ARM_EXIDX_CMD_WREG_POP;
 255           edata.data = 0xa0 | (op & 0x07);
 256         }
 257       else if (op == 0xc6)
 258         {
 259           edata.cmd = ARM_EXIDX_CMD_WREG_POP;
 260           edata.data = READ_OP ();
 261         }
 262       else if (op == 0xc7)
 263         {
 264           uint8_t op2 = READ_OP ();
 265           if (op2 == 0 || (op2 & 0xf0))
 266             edata.cmd = ARM_EXIDX_CMD_RESERVED;
 267           else
 268             {
 269               edata.cmd = ARM_EXIDX_CMD_WCGR_POP;
 270               edata.data = op2 & 0x0f;
 271             }
 272         }
 273       else
 274         edata.cmd = ARM_EXIDX_CMD_RESERVED;
 275
 276       ret = arm_exidx_apply_cmd (&edata, c);
 277       if (ret < 0)
 278         return ret;
 279     }
 280   return 0;
 281 }
 282
 283 /**
 284  * Reads the entry from the given cursor and extracts the unwind instructions
 285  * into buf.  Returns the number of the extracted unwind insns or
 286  * -UNW_ESTOPUNWIND if the special bit pattern ARM_EXIDX_CANT_UNWIND (0x1) was
 287  * found.
 288  */
 289 HIDDEN int
 290 arm_exidx_extract (struct dwarf_cursor *c, uint8_t *buf)
 291 {
 292   int nbuf = 0;
 293   unw_word_t entry = (unw_word_t) c->pi.unwind_info;
 294   unw_word_t addr;
 295   uint32_t data;
 296
 297   /* An ARM unwind entry consists of a prel31 offset to the start of a
 298      function followed by 31bits of data:
 299        * if set to 0x1: the function cannot be unwound (EXIDX_CANTUNWIND)
 300        * if bit 31 is one: this is a table entry itself (ARM_EXIDX_COMPACT)
 301        * if bit 31 is zero: this is a prel31 offset of the start of the
 302          table entry for this function  */
 303   if (prel31_to_addr(c->as, c->as_arg, entry, &addr) < 0)
 304     return -UNW_EINVAL;
 305
 306   if ((*c->as->acc.access_mem)(c->as, entry + 4, &data, 0, c->as_arg) < 0)
 307     return -UNW_EINVAL;
 308
 309   if (data == ARM_EXIDX_CANT_UNWIND)
 310     {
 311       Debug (2, "0x1 [can't unwind]\n");
 312       nbuf = -UNW_ESTOPUNWIND;
 313     }
 314   else if (data & ARM_EXIDX_COMPACT)
 315     {
 316       Debug (2, "%p compact model %d [%8.8x]\n", (void *)addr,
 317              (data >> 24) & 0x7f, data);
 318       buf[nbuf++] = data >> 16;
 319       buf[nbuf++] = data >> 8;
 320       buf[nbuf++] = data;
 321     }
 322   else
 323     {
 324       unw_word_t extbl_data;
 325       unsigned int n_table_words = 0;
 326
 327       if (prel31_to_addr(c->as, c->as_arg, entry + 4, &extbl_data) < 0)
 328         return -UNW_EINVAL;
 329
 330       if ((*c->as->acc.access_mem)(c->as, extbl_data, &data, 0, c->as_arg) < 0)
 331         return -UNW_EINVAL;
 332
 333       if (data & ARM_EXIDX_COMPACT)
 334         {
 335           int pers = (data >> 24) & 0x0f;
 336           Debug (2, "%p compact model %d [%8.8x]\n", (void *)addr, pers, data);
 337           if (pers == 1 || pers == 2)
 338             {
 339               n_table_words = (data >> 16) & 0xff;
 340               extbl_data += 4;
 341             }
 342           else
 343             buf[nbuf++] = data >> 16;
 344           buf[nbuf++] = data >> 8;
 345           buf[nbuf++] = data;
 346         }
 347       else
 348         {
 349           unw_word_t pers;
 350           if (prel31_to_addr (c->as, c->as_arg, extbl_data, &pers) < 0)
 351             return -UNW_EINVAL;
 352           Debug (2, "%p Personality routine: %8p\n", (void *)addr,
 353                  (void *)pers);
 354           if ((*c->as->acc.access_mem)(c->as, extbl_data + 4, &data, 0,
 355                                        c->as_arg) < 0)
 356             return -UNW_EINVAL;
 357           n_table_words = data >> 24;
 358           buf[nbuf++] = data >> 16;
 359           buf[nbuf++] = data >> 8;
 360           buf[nbuf++] = data;
 361           extbl_data += 8;
 362         }
 363       assert (n_table_words <= 5);
 364       unsigned j;
 365       for (j = 0; j < n_table_words; j++)
 366         {
 367           if ((*c->as->acc.access_mem)(c->as, extbl_data, &data, 0,
 368                                        c->as_arg) < 0)
 369             return -UNW_EINVAL;
 370           extbl_data += 4;
 371           buf[nbuf++] = data >> 24;
 372           buf[nbuf++] = data >> 16;
 373           buf[nbuf++] = data >> 8;
 374           buf[nbuf++] = data >> 0;
 375         }
 376     }
 377
 378   if (nbuf > 0 && buf[nbuf - 1] != ARM_EXTBL_OP_FINISH)
 379     buf[nbuf++] = ARM_EXTBL_OP_FINISH;
 380
 381   return nbuf;
 382 }
 383
 384 PROTECTED int
 385 tdep_search_unwind_table (unw_addr_space_t as, unw_word_t ip,
 386                              unw_dyn_info_t *di, unw_proc_info_t *pi,
 387                              int need_unwind_info, void *arg)
 388 {
 389   if (UNW_TRY_METHOD (UNW_ARM_METHOD_EXIDX)
 390       && di->format == UNW_INFO_FORMAT_ARM_EXIDX)
 391     {
 392       /* The .ARM.exidx section contains a sorted list of key-value pairs -
 393          the unwind entries.  The 'key' is a prel31 offset to the start of a
 394          function.  We binary search this section in order to find the
 395          appropriate unwind entry.  */
 396       unw_word_t first = di->u.rti.table_data;
 397       unw_word_t last = di->u.rti.table_data + di->u.rti.table_len - 8;
 398       unw_word_t entry, val;
 399
 400       if (prel31_to_addr (as, arg, first, &val) < 0 || ip < val)
 401         return -UNW_ENOINFO;
 402
 403       if (prel31_to_addr (as, arg, last, &val) < 0)
 404         return -UNW_EINVAL;
 405
 406       if (ip >= val)
 407         {
 408           entry = last;
 409
 410           if (prel31_to_addr (as, arg, last, &pi->start_ip) < 0)
 411             return -UNW_EINVAL;
 412
 413           pi->end_ip = di->end_ip -1;
 414         }
 415       else
 416         {
 417           while (first < last - 8)
 418             {
 419               entry = first + (((last - first) / 8 + 1) >> 1) * 8;
 420
 421               if (prel31_to_addr (as, arg, entry, &val) < 0)
 422                 return -UNW_EINVAL;
 423
 424               if (ip < val)
 425                 last = entry;
 426               else
 427                 first = entry;
 428             }
 429
 430           entry = first;
 431
 432           if (prel31_to_addr (as, arg, entry, &pi->start_ip) < 0)
 433             return -UNW_EINVAL;
 434
 435           if (prel31_to_addr (as, arg, entry + 8, &pi->end_ip) < 0)
 436             return -UNW_EINVAL;
 437
 438           pi->end_ip--;
 439         }
 440
 441       if (need_unwind_info)
 442         {
 443           pi->unwind_info_size = 8;
 444           pi->unwind_info = (void *) entry;
 445           pi->format = UNW_INFO_FORMAT_ARM_EXIDX;
 446         }
 447       return 0;
 448     }
 449   else if (UNW_TRY_METHOD(UNW_ARM_METHOD_DWARF)
 450            && di->format != UNW_INFO_FORMAT_ARM_EXIDX)
 451     return dwarf_search_unwind_table (as, ip, di, pi, need_unwind_info, arg);
 452
 453   return -UNW_ENOINFO;
 454 }
 455
 456 #ifndef UNW_REMOTE_ONLY
 457 /**
 458  * Callback to dl_iterate_phdr to find infos about the ARM exidx segment.
 459  */
 460 static int
 461 arm_phdr_cb (struct dl_phdr_info *info, size_t size, void *data)
 462 {
 463   struct arm_cb_data *cb_data = data;
 464   const Elf_W(Phdr) *p_text = NULL;
 465   const Elf_W(Phdr) *p_arm_exidx = NULL;
 466   const Elf_W(Phdr) *phdr = info->dlpi_phdr;
 467   long n;
 468
 469   for (n = info->dlpi_phnum; --n >= 0; phdr++)
 470     {
 471       switch (phdr->p_type)
 472         {
 473         case PT_LOAD:
 474           if (cb_data->ip >= phdr->p_vaddr + info->dlpi_addr &&
 475               cb_data->ip < phdr->p_vaddr + info->dlpi_addr + phdr->p_memsz)
 476             p_text = phdr;
 477           break;
 478
 479         case PT_ARM_EXIDX:
 480           p_arm_exidx = phdr;
 481           break;
 482
 483         default:
 484           break;
 485         }
 486     }
 487
 488   if (p_text && p_arm_exidx)
 489     {
 490       cb_data->di.format = UNW_INFO_FORMAT_ARM_EXIDX;
 491       cb_data->di.start_ip = p_text->p_vaddr + info->dlpi_addr;
 492       cb_data->di.end_ip = cb_data->di.start_ip + p_text->p_memsz;
 493       cb_data->di.u.rti.name_ptr = (unw_word_t) info->dlpi_name;
 494       cb_data->di.u.rti.table_data = p_arm_exidx->p_vaddr + info->dlpi_addr;
 495       cb_data->di.u.rti.table_len = p_arm_exidx->p_memsz;
 496       return 1;
 497     }
 498
 499   return 0;
 500 }
 501
 502 HIDDEN int
 503 arm_find_proc_info (unw_addr_space_t as, unw_word_t ip,
 504                     unw_proc_info_t *pi, int need_unwind_info, void *arg)
 505 {
 506   int ret = -1;
 507   intrmask_t saved_mask;
 508
 509   Debug (14, "looking for IP=0x%lx\n", (long) ip);
 510
 511   if (UNW_TRY_METHOD(UNW_ARM_METHOD_DWARF))
 512     {
 513       struct dwarf_callback_data cb_data;
 514
 515       memset (&cb_data, 0, sizeof (cb_data));
 516       cb_data.ip = ip;
 517       cb_data.pi = pi;
 518       cb_data.need_unwind_info = need_unwind_info;
 519       cb_data.di.format = -1;
 520       cb_data.di_debug.format = -1;
 521
 522       SIGPROCMASK (SIG_SETMASK, &unwi_full_mask, &saved_mask);
 523       ret = dl_iterate_phdr (dwarf_callback, &cb_data);
 524       SIGPROCMASK (SIG_SETMASK, &saved_mask, NULL);
 525
 526       if (cb_data.single_fde)
 527         /* already got the result in *pi */
 528         return 0;
 529
 530       if (cb_data.di_debug.format != -1)
 531         ret = tdep_search_unwind_table (as, ip, &cb_data.di_debug, pi,
 532                                         need_unwind_info, arg);
 533       else
 534         ret = -UNW_ENOINFO;
 535     }
 536
 537   if (ret < 0 && UNW_TRY_METHOD (UNW_ARM_METHOD_EXIDX))
 538     {
 539       struct arm_cb_data cb_data;
 540
 541       memset (&cb_data, 0, sizeof (cb_data));
 542       cb_data.ip = ip;
 543       cb_data.pi = pi;
 544       cb_data.di.format = -1;
 545
 546       SIGPROCMASK (SIG_SETMASK, &unwi_full_mask, &saved_mask);
 547       ret = dl_iterate_phdr (arm_phdr_cb, &cb_data);
 548       SIGPROCMASK (SIG_SETMASK, &saved_mask, NULL);
 549
 550       if (cb_data.di.format != -1)
 551         ret = tdep_search_unwind_table (as, ip, &cb_data.di, pi,
 552                                         need_unwind_info, arg);
 553       else
 554         ret = -UNW_ENOINFO;
 555     }
 556
 557   if (ret < 0)
 558     Debug (14, "IP=0x%lx not found\n", (long) ip);
 559
 560   return ret;
 561 }
 562
 563 HIDDEN void
 564 arm_put_unwind_info (unw_addr_space_t as, unw_proc_info_t *proc_info, void *arg)
 565 {
 566   /* it's a no-op */
 567 }
 568 #endif /* !UNW_REMOTE_ONLY */
 569