gdb/libunwind-frame.c

   1 /* Frame unwinder for frames using the libunwind library.
   2
   3    Copyright (C) 2003, 2004, 2006, 2007, 2008 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 static int libunwind_initialized;
  44 static struct gdbarch_data *libunwind_descr_handle;
  45
  46 /* Required function pointers from libunwind.  */
  47 static int (*unw_get_reg_p) (unw_cursor_t *, unw_regnum_t, unw_word_t *);
  48 static int (*unw_get_fpreg_p) (unw_cursor_t *, unw_regnum_t, unw_fpreg_t *);
  49 static int (*unw_get_saveloc_p) (unw_cursor_t *, unw_regnum_t, unw_save_loc_t *);
  50 static int (*unw_is_signal_frame_p) (unw_cursor_t *);
  51 static int (*unw_step_p) (unw_cursor_t *);
  52 static int (*unw_init_remote_p) (unw_cursor_t *, unw_addr_space_t, void *);
  53 static unw_addr_space_t (*unw_create_addr_space_p) (unw_accessors_t *, int);
  54 static void (*unw_destroy_addr_space_p) (unw_addr_space_t);
  55 static int (*unw_search_unwind_table_p) (unw_addr_space_t, unw_word_t, unw_dyn_info_t *,
  56                                          unw_proc_info_t *, int, void *);
  57 static unw_word_t (*unw_find_dyn_list_p) (unw_addr_space_t, unw_dyn_info_t *,
  58                                           void *);
  59
  60
  61 struct libunwind_frame_cache
  62 {
  63   CORE_ADDR base;
  64   CORE_ADDR func_addr;
  65   unw_cursor_t cursor;
  66   unw_addr_space_t as;
  67 };
  68
  69 /* We need to qualify the function names with a platform-specific prefix to match
  70    the names used by the libunwind library.  The UNW_OBJ macro is provided by the
  71    libunwind.h header file.  */
  72 #define STRINGIFY2(name)        #name
  73 #define STRINGIFY(name)         STRINGIFY2(name)
  74
  75 #ifndef LIBUNWIND_SO
  76 /* Use the stable ABI major version number.  `libunwind-ia64.so' is a link time
  77    only library, not a runtime one.  */
  78 #define LIBUNWIND_SO "libunwind-" STRINGIFY(UNW_TARGET) ".so.7"
  79 #endif
  80
  81 static char *get_reg_name = STRINGIFY(UNW_OBJ(get_reg));
  82 static char *get_fpreg_name = STRINGIFY(UNW_OBJ(get_fpreg));
  83 static char *get_saveloc_name = STRINGIFY(UNW_OBJ(get_save_loc));
  84 static char *is_signal_frame_name = STRINGIFY(UNW_OBJ(is_signal_frame));
  85 static char *step_name = STRINGIFY(UNW_OBJ(step));
  86 static char *init_remote_name = STRINGIFY(UNW_OBJ(init_remote));
  87 static char *create_addr_space_name = STRINGIFY(UNW_OBJ(create_addr_space));
  88 static char *destroy_addr_space_name = STRINGIFY(UNW_OBJ(destroy_addr_space));
  89 static char *search_unwind_table_name = STRINGIFY(UNW_OBJ(search_unwind_table));
  90 static char *find_dyn_list_name = STRINGIFY(UNW_OBJ(find_dyn_list));
  91
  92 static struct libunwind_descr *
  93 libunwind_descr (struct gdbarch *gdbarch)
  94 {
  95   return gdbarch_data (gdbarch, libunwind_descr_handle);
  96 }
  97
  98 static void *
  99 libunwind_descr_init (struct gdbarch *gdbarch)
 100 {
 101   struct libunwind_descr *descr = GDBARCH_OBSTACK_ZALLOC (gdbarch,
 102                                                           struct libunwind_descr);
 103   return descr;
 104 }
 105
 106 void
 107 libunwind_frame_set_descr (struct gdbarch *gdbarch, struct libunwind_descr *descr)
 108 {
 109   struct libunwind_descr *arch_descr;
 110
 111   gdb_assert (gdbarch != NULL);
 112
 113   arch_descr = gdbarch_data (gdbarch, libunwind_descr_handle);
 114
 115   if (arch_descr == NULL)
 116     {
 117       /* First time here.  Must initialize data area.  */
 118       arch_descr = libunwind_descr_init (gdbarch);
 119       deprecated_set_gdbarch_data (gdbarch, libunwind_descr_handle, arch_descr);
 120     }
 121
 122   /* Copy new descriptor info into arch descriptor.  */
 123   arch_descr->gdb2uw = descr->gdb2uw;
 124   arch_descr->uw2gdb = descr->uw2gdb;
 125   arch_descr->is_fpreg = descr->is_fpreg;
 126   arch_descr->accessors = descr->accessors;
 127   arch_descr->special_accessors = descr->special_accessors;
 128 }
 129
 130 static struct libunwind_frame_cache *
 131 libunwind_frame_cache (struct frame_info *next_frame, void **this_cache)
 132 {
 133   unw_accessors_t *acc;
 134   unw_addr_space_t as;
 135   unw_word_t fp;
 136   unw_regnum_t uw_sp_regnum;
 137   struct libunwind_frame_cache *cache;
 138   struct libunwind_descr *descr;
 139   struct gdbarch *gdbarch = get_frame_arch (next_frame);
 140   int i, ret;
 141
 142   if (*this_cache)
 143     return *this_cache;
 144
 145   /* Allocate a new cache.  */
 146   cache = FRAME_OBSTACK_ZALLOC (struct libunwind_frame_cache);
 147
 148   /* We can assume we are unwinding a normal frame.  Even if this is
 149      for a signal trampoline, ia64 signal "trampolines" use a normal
 150      subroutine call to start the signal handler.  */
 151   cache->func_addr = frame_func_unwind (next_frame, NORMAL_FRAME);
 152   if (cache->func_addr == 0
 153       && frame_relative_level (next_frame) > 0
 154       && get_frame_type (next_frame) != SIGTRAMP_FRAME)
 155     return NULL;
 156
 157   /* Get a libunwind cursor to the previous frame.  We do this by initializing
 158      a cursor.  Libunwind treats a new cursor as the top of stack and will get
 159      the current register set via the libunwind register accessor.  Now, we
 160      provide the platform-specific accessors and we set up the register accessor to use
 161      the frame register unwinding interfaces so that we properly get the registers for
 162      the current frame rather than the top.  We then use the  unw_step function to
 163      move the libunwind cursor back one frame.  We can later use this cursor to find previous
 164      registers via the unw_get_reg interface which will invoke libunwind's special logic.  */
 165   descr = libunwind_descr (gdbarch);
 166   acc = descr->accessors;
 167   as =  unw_create_addr_space_p (acc,
 168                                  gdbarch_byte_order (gdbarch)
 169                                  == BFD_ENDIAN_BIG
 170                                  ? __BIG_ENDIAN
 171                                  : __LITTLE_ENDIAN);
 172
 173   unw_init_remote_p (&cache->cursor, as, next_frame);
 174   if (unw_step_p (&cache->cursor) < 0)
 175     {
 176       unw_destroy_addr_space_p (as);
 177       return NULL;
 178     }
 179
 180   /* To get base address, get sp from previous frame.  */
 181   uw_sp_regnum = descr->gdb2uw (gdbarch_sp_regnum (gdbarch));
 182   ret = unw_get_reg_p (&cache->cursor, uw_sp_regnum, &fp);
 183   if (ret < 0)
 184     {
 185       unw_destroy_addr_space_p (as);
 186       error (_("Can't get libunwind sp register."));
 187     }
 188
 189   cache->base = (CORE_ADDR)fp;
 190   cache->as = as;
 191
 192   *this_cache = cache;
 193   return cache;
 194 }
 195
 196 void
 197 libunwind_frame_dealloc_cache (struct frame_info *self, void *this_cache)
 198 {
 199   struct libunwind_frame_cache *cache = this_cache;
 200   if (cache->as)
 201     unw_destroy_addr_space_p (cache->as);
 202 }
 203
 204 unw_word_t
 205 libunwind_find_dyn_list (unw_addr_space_t as, unw_dyn_info_t *di, void *arg)
 206 {
 207   return unw_find_dyn_list_p (as, di, arg);
 208 }
 209
 210 static const struct frame_unwind libunwind_frame_unwind =
 211 {
 212   NORMAL_FRAME,
 213   libunwind_frame_this_id,
 214   libunwind_frame_prev_register,
 215   NULL,
 216   NULL,
 217   NULL,
 218   libunwind_frame_dealloc_cache
 219 };
 220
 221 /* Verify if there is sufficient libunwind information for the frame to use
 222    libunwind frame unwinding.  */
 223 const struct frame_unwind *
 224 libunwind_frame_sniffer (struct frame_info *next_frame)
 225 {
 226   unw_cursor_t cursor;
 227   unw_accessors_t *acc;
 228   unw_addr_space_t as;
 229   struct libunwind_descr *descr;
 230   struct gdbarch *gdbarch = get_frame_arch (next_frame);
 231   int i, ret;
 232
 233   /* To test for libunwind unwind support, initialize a cursor to the current frame and try to back
 234      up.  We use this same method when setting up the frame cache (see libunwind_frame_cache()).
 235      If libunwind returns success for this operation, it means that it has found sufficient
 236      libunwind unwinding information to do so.  */
 237
 238   descr = libunwind_descr (gdbarch);
 239   acc = descr->accessors;
 240   as =  unw_create_addr_space_p (acc,
 241                                  gdbarch_byte_order (gdbarch)
 242                                  == BFD_ENDIAN_BIG
 243                                  ? __BIG_ENDIAN
 244                                  : __LITTLE_ENDIAN);
 245
 246   ret = unw_init_remote_p (&cursor, as, next_frame);
 247
 248   if (ret < 0)
 249     {
 250       unw_destroy_addr_space_p (as);
 251       return NULL;
 252     }
 253
 254
 255   /* Check to see if we have libunwind info by checking if we are in a
 256      signal frame.  If it doesn't return an error, we have libunwind info
 257      and can use libunwind.  */
 258   ret = unw_is_signal_frame_p (&cursor);
 259   unw_destroy_addr_space_p (as);
 260
 261   if (ret < 0)
 262     return NULL;
 263
 264   return &libunwind_frame_unwind;
 265 }
 266
 267 void
 268 libunwind_frame_this_id (struct frame_info *next_frame, void **this_cache,
 269                       struct frame_id *this_id)
 270 {
 271   struct libunwind_frame_cache *cache =
 272     libunwind_frame_cache (next_frame, this_cache);
 273
 274   if (cache != NULL)
 275     (*this_id) = frame_id_build (cache->base, cache->func_addr);
 276   else
 277     (*this_id) = null_frame_id;
 278 }
 279
 280 void
 281 libunwind_frame_prev_register (struct frame_info *next_frame, void **this_cache,
 282                                int regnum, int *optimizedp,
 283                                enum lval_type *lvalp, CORE_ADDR *addrp,
 284                                int *realnump, gdb_byte *valuep)
 285 {
 286   struct libunwind_frame_cache *cache =
 287     libunwind_frame_cache (next_frame, this_cache);
 288   struct gdbarch *gdbarch = get_frame_arch (next_frame);
 289
 290   void *ptr;
 291   unw_cursor_t *c;
 292   unw_save_loc_t sl;
 293   int i, ret;
 294   unw_word_t intval;
 295   unw_fpreg_t fpval;
 296   unw_regnum_t uw_regnum;
 297   struct libunwind_descr *descr;
 298
 299   if (cache == NULL)
 300     return;
 301
 302   /* Convert from gdb register number to libunwind register number.  */
 303   descr = libunwind_descr (get_frame_arch (next_frame));
 304   uw_regnum = descr->gdb2uw (regnum);
 305
 306   gdb_assert (regnum >= 0);
 307
 308   if (!target_has_registers)
 309     error (_("No registers."));
 310
 311   *optimizedp = 0;
 312   *addrp = 0;
 313   *lvalp = not_lval;
 314   *realnump = -1;
 315
 316   if (valuep)
 317     memset (valuep, 0, register_size (gdbarch, regnum));
 318
 319   if (uw_regnum < 0)
 320     return;
 321
 322   /* To get the previous register, we use the libunwind register APIs with
 323      the cursor we have already pushed back to the previous frame.  */
 324
 325   if (descr->is_fpreg (uw_regnum))
 326     {
 327       ret = unw_get_fpreg_p (&cache->cursor, uw_regnum, &fpval);
 328       ptr = &fpval;
 329     }
 330   else
 331     {
 332       ret = unw_get_reg_p (&cache->cursor, uw_regnum, &intval);
 333       ptr = &intval;
 334     }
 335
 336   if (ret < 0)
 337     return;
 338
 339   if (valuep)
 340     memcpy (valuep, ptr, register_size (gdbarch, regnum));
 341
 342   if (unw_get_saveloc_p (&cache->cursor, uw_regnum, &sl) < 0)
 343     return;
 344
 345   switch (sl.type)
 346     {
 347     case UNW_SLT_NONE:
 348       *optimizedp = 1;
 349       break;
 350
 351     case UNW_SLT_MEMORY:
 352       *lvalp = lval_memory;
 353       *addrp = sl.u.addr;
 354       break;
 355
 356     case UNW_SLT_REG:
 357       *lvalp = lval_register;
 358       *realnump = regnum;
 359       break;
 360     }
 361 }
 362
 363 CORE_ADDR
 364 libunwind_frame_base_address (struct frame_info *next_frame, void **this_cache)
 365 {
 366   struct libunwind_frame_cache *cache =
 367     libunwind_frame_cache (next_frame, this_cache);
 368
 369   if (cache == NULL)
 370     return (CORE_ADDR)NULL;
 371   return cache->base;
 372 }
 373
 374 /* The following is a glue routine to call the libunwind unwind table
 375    search function to get unwind information for a specified ip address.  */
 376 int
 377 libunwind_search_unwind_table (void *as, long ip, void *di,
 378                                void *pi, int need_unwind_info, void *args)
 379 {
 380   return unw_search_unwind_table_p (*(unw_addr_space_t *)as, (unw_word_t )ip,
 381                                     di, pi, need_unwind_info, args);
 382 }
 383
 384 /* Verify if we are in a sigtramp frame and we can use libunwind to unwind.  */
 385 const struct frame_unwind *
 386 libunwind_sigtramp_frame_sniffer (struct frame_info *next_frame)
 387 {
 388   unw_cursor_t cursor;
 389   unw_accessors_t *acc;
 390   unw_addr_space_t as;
 391   struct libunwind_descr *descr;
 392   struct gdbarch *gdbarch = get_frame_arch (next_frame);
 393   int i, ret;
 394
 395   /* To test for libunwind unwind support, initialize a cursor to the
 396      current frame and try to back up.  We use this same method when
 397      setting up the frame cache (see libunwind_frame_cache()).  If
 398      libunwind returns success for this operation, it means that it
 399      has found sufficient libunwind unwinding information to do
 400      so.  */
 401
 402   descr = libunwind_descr (gdbarch);
 403   acc = descr->accessors;
 404   as =  unw_create_addr_space_p (acc,
 405                                  gdbarch_byte_order (gdbarch)
 406                                  == BFD_ENDIAN_BIG
 407                                  ? __BIG_ENDIAN
 408                                  : __LITTLE_ENDIAN);
 409
 410   ret = unw_init_remote_p (&cursor, as, next_frame);
 411
 412   if (ret < 0)
 413     {
 414       unw_destroy_addr_space_p (as);
 415       return NULL;
 416     }
 417
 418   /* Check to see if we are in a signal frame.  */
 419   ret = unw_is_signal_frame_p (&cursor);
 420   unw_destroy_addr_space_p (as);
 421   if (ret > 0)
 422     return &libunwind_frame_unwind;
 423
 424   return NULL;
 425 }
 426
 427 /* The following routine is for accessing special registers of the top frame.
 428    A special set of accessors must be given that work without frame info.
 429    This is used by ia64 to access the rse registers r32-r127.  While they
 430    are usually located at BOF, this is not always true and only the libunwind
 431    info can decipher where they actually are.  */
 432 int
 433 libunwind_get_reg_special (struct gdbarch *gdbarch, struct regcache *regcache,
 434                            int regnum, void *buf)
 435 {
 436   unw_cursor_t cursor;
 437   unw_accessors_t *acc;
 438   unw_addr_space_t as;
 439   struct libunwind_descr *descr;
 440   int ret;
 441   unw_regnum_t uw_regnum;
 442   unw_word_t intval;
 443   unw_fpreg_t fpval;
 444   void *ptr;
 445
 446
 447   descr = libunwind_descr (gdbarch);
 448   acc = descr->special_accessors;
 449   as =  unw_create_addr_space_p (acc,
 450                                  gdbarch_byte_order (gdbarch)
 451                                  == BFD_ENDIAN_BIG
 452                                  ? __BIG_ENDIAN
 453                                  : __LITTLE_ENDIAN);
 454
 455   ret = unw_init_remote_p (&cursor, as, regcache);
 456   if (ret < 0)
 457     {
 458       unw_destroy_addr_space_p (as);
 459       return -1;
 460     }
 461
 462   uw_regnum = descr->gdb2uw (regnum);
 463
 464   if (descr->is_fpreg (uw_regnum))
 465     {
 466       ret = unw_get_fpreg_p (&cursor, uw_regnum, &fpval);
 467       ptr = &fpval;
 468     }
 469   else
 470     {
 471       ret = unw_get_reg_p (&cursor, uw_regnum, &intval);
 472       ptr = &intval;
 473     }
 474
 475   unw_destroy_addr_space_p (as);
 476
 477   if (ret < 0)
 478     return -1;
 479
 480   if (buf)
 481     memcpy (buf, ptr, register_size (gdbarch, regnum));
 482
 483   return 0;
 484 }
 485
 486 static int
 487 libunwind_load (void)
 488 {
 489   void *handle;
 490
 491   handle = dlopen (LIBUNWIND_SO, RTLD_NOW);
 492   if (handle == NULL)
 493     return 0;
 494
 495   /* Initialize pointers to the dynamic library functions we will use.  */
 496
 497   unw_get_reg_p = dlsym (handle, get_reg_name);
 498   if (unw_get_reg_p == NULL)
 499     return 0;
 500
 501   unw_get_fpreg_p = dlsym (handle, get_fpreg_name);
 502   if (unw_get_fpreg_p == NULL)
 503     return 0;
 504
 505   unw_get_saveloc_p = dlsym (handle, get_saveloc_name);
 506   if (unw_get_saveloc_p == NULL)
 507     return 0;
 508
 509   unw_is_signal_frame_p = dlsym (handle, is_signal_frame_name);
 510   if (unw_is_signal_frame_p == NULL)
 511     return 0;
 512
 513   unw_step_p = dlsym (handle, step_name);
 514   if (unw_step_p == NULL)
 515     return 0;
 516
 517   unw_init_remote_p = dlsym (handle, init_remote_name);
 518   if (unw_init_remote_p == NULL)
 519     return 0;
 520
 521   unw_create_addr_space_p = dlsym (handle, create_addr_space_name);
 522   if (unw_create_addr_space_p == NULL)
 523     return 0;
 524
 525   unw_destroy_addr_space_p = dlsym (handle, destroy_addr_space_name);
 526   if (unw_destroy_addr_space_p == NULL)
 527     return 0;
 528
 529   unw_search_unwind_table_p = dlsym (handle, search_unwind_table_name);
 530   if (unw_search_unwind_table_p == NULL)
 531     return 0;
 532
 533   unw_find_dyn_list_p = dlsym (handle, find_dyn_list_name);
 534   if (unw_find_dyn_list_p == NULL)
 535     return 0;
 536
 537   return 1;
 538 }
 539
 540 int
 541 libunwind_is_initialized (void)
 542 {
 543   return libunwind_initialized;
 544 }
 545
 546 /* Provide a prototype to silence -Wmissing-prototypes.  */
 547 void _initialize_libunwind_frame (void);
 548
 549 void
 550 _initialize_libunwind_frame (void)
 551 {
 552   libunwind_descr_handle = gdbarch_data_register_post_init (libunwind_descr_init);
 553
 554   libunwind_initialized = libunwind_load ();
 555 }