gdb/libunwind-frame.c

   1 /* Frame unwinder for frames using the libunwind library.
   2
   3    Copyright (C) 2003-2004, 2006-2012 Free Software Foundation, Inc.
   4
   5    Written by Jeff Johnston, contributed by Red Hat Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23
  24 #include "inferior.h"
  25 #include "frame.h"
  26 #include "frame-base.h"
  27 #include "frame-unwind.h"
  28 #include "gdbcore.h"
  29 #include "gdbtypes.h"
  30 #include "symtab.h"
  31 #include "objfiles.h"
  32 #include "regcache.h"
  33
  34 #include <dlfcn.h>
  35
  36 #include "gdb_assert.h"
  37 #include "gdb_string.h"
  38
  39 #include "libunwind-frame.h"
  40
  41 #include "complaints.h"
  42
  43 /* IA-64 is the only target that currently uses libunwind-frame.  Note
  44    how UNW_TARGET, UNW_OBJ, etc. are compile time constants below.
  45    Those come from libunwind's headers, and are target dependent.
  46    Also, some of libunwind's typedefs are target dependent, as e.g.,
  47    unw_word_t.  If some other target wants to use this, we will need
  48    to do some abstracting in order to make it possible to select which
  49    libunwind we're talking to at runtime (and have one per arch).  */
  50
  51 /* The following two macros are normally defined in <endian.h>.
  52    But systems such as ia64-hpux do not provide such header, so
  53    we just define them here if not already defined.  */
  54 #ifndef __LITTLE_ENDIAN
  55 #define __LITTLE_ENDIAN 1234
  56 #endif
  57 #ifndef __BIG_ENDIAN
  58 #define __BIG_ENDIAN    4321
  59 #endif
  60
  61 static int libunwind_initialized;
  62 static struct gdbarch_data *libunwind_descr_handle;
  63
  64 /* Required function pointers from libunwind.  */
  65 static int (*unw_get_reg_p) (unw_cursor_t *, unw_regnum_t, unw_word_t *);
  66 static int (*unw_get_fpreg_p) (unw_cursor_t *, unw_regnum_t, unw_fpreg_t *);
  67 static int (*unw_get_saveloc_p) (unw_cursor_t *, unw_regnum_t,
  68                                  unw_save_loc_t *);
  69 static int (*unw_is_signal_frame_p) (unw_cursor_t *);
  70 static int (*unw_step_p) (unw_cursor_t *);
  71 static int (*unw_init_remote_p) (unw_cursor_t *, unw_addr_space_t, void *);
  72 static unw_addr_space_t (*unw_create_addr_space_p) (unw_accessors_t *, int);
  73 static void (*unw_destroy_addr_space_p) (unw_addr_space_t);
  74 static int (*unw_search_unwind_table_p) (unw_addr_space_t, unw_word_t,
  75                                          unw_dyn_info_t *,
  76                                          unw_proc_info_t *, int, void *);
  77 static unw_word_t (*unw_find_dyn_list_p) (unw_addr_space_t, unw_dyn_info_t *,
  78                                           void *);
  79
  80
  81 struct libunwind_frame_cache
  82 {
  83   CORE_ADDR base;
  84   CORE_ADDR func_addr;
  85   unw_cursor_t cursor;
  86   unw_addr_space_t as;
  87 };
  88
  89 /* We need to qualify the function names with a platform-specific prefix
  90    to match the names used by the libunwind library.  The UNW_OBJ macro is
  91    provided by the libunwind.h header file.  */
  92 #define STRINGIFY2(name)        #name
  93 #define STRINGIFY(name)         STRINGIFY2(name)
  94
  95 #ifndef LIBUNWIND_SO
  96 /* Use the stable ABI major version number.  `libunwind-ia64.so' is a link time
  97    only library, not a runtime one.  */
  98 #define LIBUNWIND_SO "libunwind-" STRINGIFY(UNW_TARGET) ".so.8"
  99
 100 /* Provide also compatibility with older .so.  The two APIs are compatible, .8
 101    is only extended a bit, GDB does not use the extended API at all.  */
 102 #define LIBUNWIND_SO_7 "libunwind-" STRINGIFY(UNW_TARGET) ".so.7"
 103 #endif
 104
 105 static char *get_reg_name = STRINGIFY(UNW_OBJ(get_reg));
 106 static char *get_fpreg_name = STRINGIFY(UNW_OBJ(get_fpreg));
 107 static char *get_saveloc_name = STRINGIFY(UNW_OBJ(get_save_loc));
 108 static char *is_signal_frame_name = STRINGIFY(UNW_OBJ(is_signal_frame));
 109 static char *step_name = STRINGIFY(UNW_OBJ(step));
 110 static char *init_remote_name = STRINGIFY(UNW_OBJ(init_remote));
 111 static char *create_addr_space_name = STRINGIFY(UNW_OBJ(create_addr_space));
 112 static char *destroy_addr_space_name = STRINGIFY(UNW_OBJ(destroy_addr_space));
 113 static char *search_unwind_table_name
 114   = STRINGIFY(UNW_OBJ(search_unwind_table));
 115 static char *find_dyn_list_name = STRINGIFY(UNW_OBJ(find_dyn_list));
 116
 117 static struct libunwind_descr *
 118 libunwind_descr (struct gdbarch *gdbarch)
 119 {
 120   return gdbarch_data (gdbarch, libunwind_descr_handle);
 121 }
 122
 123 static void *
 124 libunwind_descr_init (struct gdbarch *gdbarch)
 125 {
 126   struct libunwind_descr *descr
 127     = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct libunwind_descr);
 128
 129   return descr;
 130 }
 131
 132 void
 133 libunwind_frame_set_descr (struct gdbarch *gdbarch,
 134                            struct libunwind_descr *descr)
 135 {
 136   struct libunwind_descr *arch_descr;
 137
 138   gdb_assert (gdbarch != NULL);
 139
 140   arch_descr = gdbarch_data (gdbarch, libunwind_descr_handle);
 141
 142   if (arch_descr == NULL)
 143     {
 144       /* First time here.  Must initialize data area.  */
 145       arch_descr = libunwind_descr_init (gdbarch);
 146       deprecated_set_gdbarch_data (gdbarch,
 147                                    libunwind_descr_handle, arch_descr);
 148     }
 149
 150   /* Copy new descriptor info into arch descriptor.  */
 151   arch_descr->gdb2uw = descr->gdb2uw;
 152   arch_descr->uw2gdb = descr->uw2gdb;
 153   arch_descr->is_fpreg = descr->is_fpreg;
 154   arch_descr->accessors = descr->accessors;
 155   arch_descr->special_accessors = descr->special_accessors;
 156 }
 157
 158 static struct libunwind_frame_cache *
 159 libunwind_frame_cache (struct frame_info *this_frame, void **this_cache)
 160 {
 161   unw_accessors_t *acc;
 162   unw_addr_space_t as;
 163   unw_word_t fp;
 164   unw_regnum_t uw_sp_regnum;
 165   struct libunwind_frame_cache *cache;
 166   struct libunwind_descr *descr;
 167   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 168   int i, ret;
 169
 170   if (*this_cache)
 171     return *this_cache;
 172
 173   /* Allocate a new cache.  */
 174   cache = FRAME_OBSTACK_ZALLOC (struct libunwind_frame_cache);
 175
 176   cache->func_addr = get_frame_func (this_frame);
 177   if (cache->func_addr == 0)
 178     /* This can happen when the frame corresponds to a function for which
 179        there is no debugging information nor any entry in the symbol table.
 180        This is probably a static function for which an entry in the symbol
 181        table was not created when the objfile got linked (observed in
 182        libpthread.so on ia64-hpux).
 183
 184        The best we can do, in that case, is use the frame PC as the function
 185        address.  We don't need to give up since we still have the unwind
 186        record to help us perform the unwinding.  There is also another
 187        compelling to continue, because abandonning now means stopping
 188        the backtrace, which can never be helpful for the user.  */
 189     cache->func_addr = get_frame_pc (this_frame);
 190
 191   /* Get a libunwind cursor to the previous frame.
 192
 193      We do this by initializing a cursor.  Libunwind treats a new cursor
 194      as the top of stack and will get the current register set via the
 195      libunwind register accessor.  Now, we provide the platform-specific
 196      accessors and we set up the register accessor to use the frame
 197      register unwinding interfaces so that we properly get the registers
 198      for the current frame rather than the top.  We then use the unw_step
 199      function to move the libunwind cursor back one frame.  We can later
 200      use this cursor to find previous registers via the unw_get_reg
 201      interface which will invoke libunwind's special logic.  */
 202   descr = libunwind_descr (gdbarch);
 203   acc = descr->accessors;
 204   as =  unw_create_addr_space_p (acc,
 205                                  gdbarch_byte_order (gdbarch)
 206                                  == BFD_ENDIAN_BIG
 207                                  ? __BIG_ENDIAN
 208                                  : __LITTLE_ENDIAN);
 209
 210   unw_init_remote_p (&cache->cursor, as, this_frame);
 211   if (unw_step_p (&cache->cursor) < 0)
 212     {
 213       unw_destroy_addr_space_p (as);
 214       return NULL;
 215     }
 216
 217   /* To get base address, get sp from previous frame.  */
 218   uw_sp_regnum = descr->gdb2uw (gdbarch_sp_regnum (gdbarch));
 219   ret = unw_get_reg_p (&cache->cursor, uw_sp_regnum, &fp);
 220   if (ret < 0)
 221     {
 222       unw_destroy_addr_space_p (as);
 223       error (_("Can't get libunwind sp register."));
 224     }
 225
 226   cache->base = (CORE_ADDR)fp;
 227   cache->as = as;
 228
 229   *this_cache = cache;
 230   return cache;
 231 }
 232
 233 void
 234 libunwind_frame_dealloc_cache (struct frame_info *self, void *this_cache)
 235 {
 236   struct libunwind_frame_cache *cache = this_cache;
 237
 238   if (cache->as)
 239     unw_destroy_addr_space_p (cache->as);
 240 }
 241
 242 unw_word_t
 243 libunwind_find_dyn_list (unw_addr_space_t as, unw_dyn_info_t *di, void *arg)
 244 {
 245   return unw_find_dyn_list_p (as, di, arg);
 246 }
 247
 248 /* Verify if there is sufficient libunwind information for the frame to use
 249    libunwind frame unwinding.  */
 250 int
 251 libunwind_frame_sniffer (const struct frame_unwind *self,
 252                          struct frame_info *this_frame, void **this_cache)
 253 {
 254   unw_cursor_t cursor;
 255   unw_accessors_t *acc;
 256   unw_addr_space_t as;
 257   struct libunwind_descr *descr;
 258   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 259   int i, ret;
 260
 261   /* To test for libunwind unwind support, initialize a cursor to
 262      the current frame and try to back up.  We use this same method
 263      when setting up the frame cache (see libunwind_frame_cache()).
 264      If libunwind returns success for this operation, it means that
 265      it has found sufficient libunwind unwinding information to do so.  */
 266
 267   descr = libunwind_descr (gdbarch);
 268   acc = descr->accessors;
 269   as =  unw_create_addr_space_p (acc,
 270                                  gdbarch_byte_order (gdbarch)
 271                                  == BFD_ENDIAN_BIG
 272                                  ? __BIG_ENDIAN
 273                                  : __LITTLE_ENDIAN);
 274
 275   ret = unw_init_remote_p (&cursor, as, this_frame);
 276
 277   if (ret < 0)
 278     {
 279       unw_destroy_addr_space_p (as);
 280       return 0;
 281     }
 282
 283
 284   /* Check to see if we have libunwind info by checking if we are in a
 285      signal frame.  If it doesn't return an error, we have libunwind info
 286      and can use libunwind.  */
 287   ret = unw_is_signal_frame_p (&cursor);
 288   unw_destroy_addr_space_p (as);
 289
 290   if (ret < 0)
 291     return 0;
 292
 293   return 1;
 294 }
 295
 296 void
 297 libunwind_frame_this_id (struct frame_info *this_frame, void **this_cache,
 298                          struct frame_id *this_id)
 299 {
 300   struct libunwind_frame_cache *cache =
 301     libunwind_frame_cache (this_frame, this_cache);
 302
 303   if (cache != NULL)
 304     (*this_id) = frame_id_build (cache->base, cache->func_addr);
 305 }
 306
 307 struct value *
 308 libunwind_frame_prev_register (struct frame_info *this_frame,
 309                                void **this_cache, int regnum)
 310 {
 311   struct libunwind_frame_cache *cache =
 312     libunwind_frame_cache (this_frame, this_cache);
 313   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 314
 315   void *ptr;
 316   unw_cursor_t *c;
 317   unw_save_loc_t sl;
 318   int i, ret;
 319   unw_word_t intval;
 320   unw_fpreg_t fpval;
 321   unw_regnum_t uw_regnum;
 322   struct libunwind_descr *descr;
 323   struct value *val = NULL;
 324
 325   if (cache == NULL)
 326     return frame_unwind_got_constant (this_frame, regnum, 0);
 327
 328   /* Convert from gdb register number to libunwind register number.  */
 329   descr = libunwind_descr (get_frame_arch (this_frame));
 330   uw_regnum = descr->gdb2uw (regnum);
 331
 332   gdb_assert (regnum >= 0);
 333
 334   if (!target_has_registers)
 335     error (_("No registers."));
 336
 337   if (uw_regnum < 0)
 338     return frame_unwind_got_constant (this_frame, regnum, 0);
 339
 340   if (unw_get_saveloc_p (&cache->cursor, uw_regnum, &sl) < 0)
 341     return frame_unwind_got_constant (this_frame, regnum, 0);
 342
 343   switch (sl.type)
 344     {
 345     case UNW_SLT_MEMORY:
 346       val = frame_unwind_got_memory (this_frame, regnum, sl.u.addr);
 347       break;
 348
 349     case UNW_SLT_REG:
 350       val = frame_unwind_got_register (this_frame, regnum,
 351                                        descr->uw2gdb (sl.u.regnum));
 352       break;
 353     case UNW_SLT_NONE:
 354       {
 355         /* The register is not stored at a specific memory address nor
 356            inside another register.  So use libunwind to fetch the register
 357            value for us, and create a constant value with the result.  */
 358         if (descr->is_fpreg (uw_regnum))
 359           {
 360             ret = unw_get_fpreg_p (&cache->cursor, uw_regnum, &fpval);
 361             if (ret < 0)
 362               return frame_unwind_got_constant (this_frame, regnum, 0);
 363             val = frame_unwind_got_bytes (this_frame, regnum,
 364                                           (gdb_byte *) &fpval);
 365           }
 366         else
 367           {
 368             ret = unw_get_reg_p (&cache->cursor, uw_regnum, &intval);
 369             if (ret < 0)
 370               return frame_unwind_got_constant (this_frame, regnum, 0);
 371             val = frame_unwind_got_constant (this_frame, regnum, intval);
 372           }
 373         break;
 374       }
 375     }
 376
 377   return val;
 378 }
 379
 380 /* The following is a glue routine to call the libunwind unwind table
 381    search function to get unwind information for a specified ip address.  */
 382 int
 383 libunwind_search_unwind_table (void *as, long ip, void *di,
 384                                void *pi, int need_unwind_info, void *args)
 385 {
 386   return unw_search_unwind_table_p (*(unw_addr_space_t *)as, (unw_word_t )ip,
 387                                     di, pi, need_unwind_info, args);
 388 }
 389
 390 /* Verify if we are in a sigtramp frame and we can use libunwind to unwind.  */
 391 int
 392 libunwind_sigtramp_frame_sniffer (const struct frame_unwind *self,
 393                                   struct frame_info *this_frame,
 394                                   void **this_cache)
 395 {
 396   unw_cursor_t cursor;
 397   unw_accessors_t *acc;
 398   unw_addr_space_t as;
 399   struct libunwind_descr *descr;
 400   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 401   int i, ret;
 402
 403   /* To test for libunwind unwind support, initialize a cursor to the
 404      current frame and try to back up.  We use this same method when
 405      setting up the frame cache (see libunwind_frame_cache()).  If
 406      libunwind returns success for this operation, it means that it
 407      has found sufficient libunwind unwinding information to do
 408      so.  */
 409
 410   descr = libunwind_descr (gdbarch);
 411   acc = descr->accessors;
 412   as =  unw_create_addr_space_p (acc,
 413                                  gdbarch_byte_order (gdbarch)
 414                                  == BFD_ENDIAN_BIG
 415                                  ? __BIG_ENDIAN
 416                                  : __LITTLE_ENDIAN);
 417
 418   ret = unw_init_remote_p (&cursor, as, this_frame);
 419
 420   if (ret < 0)
 421     {
 422       unw_destroy_addr_space_p (as);
 423       return 0;
 424     }
 425
 426   /* Check to see if we are in a signal frame.  */
 427   ret = unw_is_signal_frame_p (&cursor);
 428   unw_destroy_addr_space_p (as);
 429   if (ret > 0)
 430     return 1;
 431
 432   return 0;
 433 }
 434
 435 /* The following routine is for accessing special registers of the top frame.
 436    A special set of accessors must be given that work without frame info.
 437    This is used by ia64 to access the rse registers r32-r127.  While they
 438    are usually located at BOF, this is not always true and only the libunwind
 439    info can decipher where they actually are.  */
 440 int
 441 libunwind_get_reg_special (struct gdbarch *gdbarch, struct regcache *regcache,
 442                            int regnum, void *buf)
 443 {
 444   unw_cursor_t cursor;
 445   unw_accessors_t *acc;
 446   unw_addr_space_t as;
 447   struct libunwind_descr *descr;
 448   int ret;
 449   unw_regnum_t uw_regnum;
 450   unw_word_t intval;
 451   unw_fpreg_t fpval;
 452   void *ptr;
 453
 454
 455   descr = libunwind_descr (gdbarch);
 456   acc = descr->special_accessors;
 457   as =  unw_create_addr_space_p (acc,
 458                                  gdbarch_byte_order (gdbarch)
 459                                  == BFD_ENDIAN_BIG
 460                                  ? __BIG_ENDIAN
 461                                  : __LITTLE_ENDIAN);
 462
 463   ret = unw_init_remote_p (&cursor, as, regcache);
 464   if (ret < 0)
 465     {
 466       unw_destroy_addr_space_p (as);
 467       return -1;
 468     }
 469
 470   uw_regnum = descr->gdb2uw (regnum);
 471
 472   if (descr->is_fpreg (uw_regnum))
 473     {
 474       ret = unw_get_fpreg_p (&cursor, uw_regnum, &fpval);
 475       ptr = &fpval;
 476     }
 477   else
 478     {
 479       ret = unw_get_reg_p (&cursor, uw_regnum, &intval);
 480       ptr = &intval;
 481     }
 482
 483   unw_destroy_addr_space_p (as);
 484
 485   if (ret < 0)
 486     return -1;
 487
 488   if (buf)
 489     memcpy (buf, ptr, register_size (gdbarch, regnum));
 490
 491   return 0;
 492 }
 493
 494 static int
 495 libunwind_load (void)
 496 {
 497   void *handle;
 498   char *so_error = NULL;
 499
 500   handle = dlopen (LIBUNWIND_SO, RTLD_NOW);
 501   if (handle == NULL)
 502     {
 503       so_error = xstrdup (dlerror ());
 504 #ifdef LIBUNWIND_SO_7
 505       handle = dlopen (LIBUNWIND_SO_7, RTLD_NOW);
 506 #endif /* LIBUNWIND_SO_7 */
 507     }
 508   if (handle == NULL)
 509     {
 510       fprintf_unfiltered (gdb_stderr, _("[GDB failed to load %s: %s]\n"),
 511                           LIBUNWIND_SO, so_error);
 512 #ifdef LIBUNWIND_SO_7
 513       fprintf_unfiltered (gdb_stderr, _("[GDB failed to load %s: %s]\n"),
 514                           LIBUNWIND_SO_7, dlerror ());
 515 #endif /* LIBUNWIND_SO_7 */
 516     }
 517   xfree (so_error);
 518   if (handle == NULL)
 519     return 0;
 520
 521   /* Initialize pointers to the dynamic library functions we will use.  */
 522
 523   unw_get_reg_p = dlsym (handle, get_reg_name);
 524   if (unw_get_reg_p == NULL)
 525     return 0;
 526
 527   unw_get_fpreg_p = dlsym (handle, get_fpreg_name);
 528   if (unw_get_fpreg_p == NULL)
 529     return 0;
 530
 531   unw_get_saveloc_p = dlsym (handle, get_saveloc_name);
 532   if (unw_get_saveloc_p == NULL)
 533     return 0;
 534
 535   unw_is_signal_frame_p = dlsym (handle, is_signal_frame_name);
 536   if (unw_is_signal_frame_p == NULL)
 537     return 0;
 538
 539   unw_step_p = dlsym (handle, step_name);
 540   if (unw_step_p == NULL)
 541     return 0;
 542
 543   unw_init_remote_p = dlsym (handle, init_remote_name);
 544   if (unw_init_remote_p == NULL)
 545     return 0;
 546
 547   unw_create_addr_space_p = dlsym (handle, create_addr_space_name);
 548   if (unw_create_addr_space_p == NULL)
 549     return 0;
 550
 551   unw_destroy_addr_space_p = dlsym (handle, destroy_addr_space_name);
 552   if (unw_destroy_addr_space_p == NULL)
 553     return 0;
 554
 555   unw_search_unwind_table_p = dlsym (handle, search_unwind_table_name);
 556   if (unw_search_unwind_table_p == NULL)
 557     return 0;
 558
 559   unw_find_dyn_list_p = dlsym (handle, find_dyn_list_name);
 560   if (unw_find_dyn_list_p == NULL)
 561     return 0;
 562
 563   return 1;
 564 }
 565
 566 int
 567 libunwind_is_initialized (void)
 568 {
 569   return libunwind_initialized;
 570 }
 571
 572 /* Provide a prototype to silence -Wmissing-prototypes.  */
 573 void _initialize_libunwind_frame (void);
 574
 575 void
 576 _initialize_libunwind_frame (void)
 577 {
 578   libunwind_descr_handle
 579     = gdbarch_data_register_post_init (libunwind_descr_init);
 580
 581   libunwind_initialized = libunwind_load ();
 582 }