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   libunwind_frame_dealloc_cache
 218 };
 219
 220 /* Verify if there is sufficient libunwind information for the frame to use
 221    libunwind frame unwinding.  */
 222 const struct frame_unwind *
 223 libunwind_frame_sniffer (struct frame_info *next_frame)
 224 {
 225   unw_cursor_t cursor;
 226   unw_accessors_t *acc;
 227   unw_addr_space_t as;
 228   struct libunwind_descr *descr;
 229   struct gdbarch *gdbarch = get_frame_arch (next_frame);
 230   int i, ret;
 231
 232   /* To test for libunwind unwind support, initialize a cursor to the current frame and try to back
 233      up.  We use this same method when setting up the frame cache (see libunwind_frame_cache()).
 234      If libunwind returns success for this operation, it means that it has found sufficient
 235      libunwind unwinding information to do so.  */
 236
 237   descr = libunwind_descr (gdbarch);
 238   acc = descr->accessors;
 239   as =  unw_create_addr_space_p (acc,
 240                                  gdbarch_byte_order (gdbarch)
 241                                  == BFD_ENDIAN_BIG
 242                                  ? __BIG_ENDIAN
 243                                  : __LITTLE_ENDIAN);
 244
 245   ret = unw_init_remote_p (&cursor, as, next_frame);
 246
 247   if (ret < 0)
 248     {
 249       unw_destroy_addr_space_p (as);
 250       return NULL;
 251     }
 252
 253
 254   /* Check to see if we have libunwind info by checking if we are in a
 255      signal frame.  If it doesn't return an error, we have libunwind info
 256      and can use libunwind.  */
 257   ret = unw_is_signal_frame_p (&cursor);
 258   unw_destroy_addr_space_p (as);
 259
 260   if (ret < 0)
 261     return NULL;
 262
 263   return &libunwind_frame_unwind;
 264 }
 265
 266 void
 267 libunwind_frame_this_id (struct frame_info *next_frame, void **this_cache,
 268                       struct frame_id *this_id)
 269 {
 270   struct libunwind_frame_cache *cache =
 271     libunwind_frame_cache (next_frame, this_cache);
 272
 273   if (cache != NULL)
 274     (*this_id) = frame_id_build (cache->base, cache->func_addr);
 275   else
 276     (*this_id) = null_frame_id;
 277 }
 278
 279 void
 280 libunwind_frame_prev_register (struct frame_info *next_frame, void **this_cache,
 281                                int regnum, int *optimizedp,
 282                                enum lval_type *lvalp, CORE_ADDR *addrp,
 283                                int *realnump, gdb_byte *valuep)
 284 {
 285   struct libunwind_frame_cache *cache =
 286     libunwind_frame_cache (next_frame, this_cache);
 287   struct gdbarch *gdbarch = get_frame_arch (next_frame);
 288
 289   void *ptr;
 290   unw_cursor_t *c;
 291   unw_save_loc_t sl;
 292   int i, ret;
 293   unw_word_t intval;
 294   unw_fpreg_t fpval;
 295   unw_regnum_t uw_regnum;
 296   struct libunwind_descr *descr;
 297
 298   if (cache == NULL)
 299     return;
 300
 301   /* Convert from gdb register number to libunwind register number.  */
 302   descr = libunwind_descr (get_frame_arch (next_frame));
 303   uw_regnum = descr->gdb2uw (regnum);
 304
 305   gdb_assert (regnum >= 0);
 306
 307   if (!target_has_registers)
 308     error (_("No registers."));
 309
 310   *optimizedp = 0;
 311   *addrp = 0;
 312   *lvalp = not_lval;
 313   *realnump = -1;
 314
 315   if (valuep)
 316     memset (valuep, 0, register_size (gdbarch, regnum));
 317
 318   if (uw_regnum < 0)
 319     return;
 320
 321   /* To get the previous register, we use the libunwind register APIs with
 322      the cursor we have already pushed back to the previous frame.  */
 323
 324   if (descr->is_fpreg (uw_regnum))
 325     {
 326       ret = unw_get_fpreg_p (&cache->cursor, uw_regnum, &fpval);
 327       ptr = &fpval;
 328     }
 329   else
 330     {
 331       ret = unw_get_reg_p (&cache->cursor, uw_regnum, &intval);
 332       ptr = &intval;
 333     }
 334
 335   if (ret < 0)
 336     return;
 337
 338   if (valuep)
 339     memcpy (valuep, ptr, register_size (gdbarch, regnum));
 340
 341   if (unw_get_saveloc_p (&cache->cursor, uw_regnum, &sl) < 0)
 342     return;
 343
 344   switch (sl.type)
 345     {
 346     case UNW_SLT_NONE:
 347       *optimizedp = 1;
 348       break;
 349
 350     case UNW_SLT_MEMORY:
 351       *lvalp = lval_memory;
 352       *addrp = sl.u.addr;
 353       break;
 354
 355     case UNW_SLT_REG:
 356       *lvalp = lval_register;
 357       *realnump = regnum;
 358       break;
 359     }
 360 }
 361
 362 CORE_ADDR
 363 libunwind_frame_base_address (struct frame_info *next_frame, void **this_cache)
 364 {
 365   struct libunwind_frame_cache *cache =
 366     libunwind_frame_cache (next_frame, this_cache);
 367
 368   if (cache == NULL)
 369     return (CORE_ADDR)NULL;
 370   return cache->base;
 371 }
 372
 373 /* The following is a glue routine to call the libunwind unwind table
 374    search function to get unwind information for a specified ip address.  */
 375 int
 376 libunwind_search_unwind_table (void *as, long ip, void *di,
 377                                void *pi, int need_unwind_info, void *args)
 378 {
 379   return unw_search_unwind_table_p (*(unw_addr_space_t *)as, (unw_word_t )ip,
 380                                     di, pi, need_unwind_info, args);
 381 }
 382
 383 /* Verify if we are in a sigtramp frame and we can use libunwind to unwind.  */
 384 const struct frame_unwind *
 385 libunwind_sigtramp_frame_sniffer (struct frame_info *next_frame)
 386 {
 387   unw_cursor_t cursor;
 388   unw_accessors_t *acc;
 389   unw_addr_space_t as;
 390   struct libunwind_descr *descr;
 391   struct gdbarch *gdbarch = get_frame_arch (next_frame);
 392   int i, ret;
 393
 394   /* To test for libunwind unwind support, initialize a cursor to the
 395      current frame and try to back up.  We use this same method when
 396      setting up the frame cache (see libunwind_frame_cache()).  If
 397      libunwind returns success for this operation, it means that it
 398      has found sufficient libunwind unwinding information to do
 399      so.  */
 400
 401   descr = libunwind_descr (gdbarch);
 402   acc = descr->accessors;
 403   as =  unw_create_addr_space_p (acc,
 404                                  gdbarch_byte_order (gdbarch)
 405                                  == BFD_ENDIAN_BIG
 406                                  ? __BIG_ENDIAN
 407                                  : __LITTLE_ENDIAN);
 408
 409   ret = unw_init_remote_p (&cursor, as, next_frame);
 410
 411   if (ret < 0)
 412     {
 413       unw_destroy_addr_space_p (as);
 414       return NULL;
 415     }
 416
 417   /* Check to see if we are in a signal frame.  */
 418   ret = unw_is_signal_frame_p (&cursor);
 419   unw_destroy_addr_space_p (as);
 420   if (ret > 0)
 421     return &libunwind_frame_unwind;
 422
 423   return NULL;
 424 }
 425
 426 /* The following routine is for accessing special registers of the top frame.
 427    A special set of accessors must be given that work without frame info.
 428    This is used by ia64 to access the rse registers r32-r127.  While they
 429    are usually located at BOF, this is not always true and only the libunwind
 430    info can decipher where they actually are.  */
 431 int
 432 libunwind_get_reg_special (struct gdbarch *gdbarch, struct regcache *regcache,
 433                            int regnum, void *buf)
 434 {
 435   unw_cursor_t cursor;
 436   unw_accessors_t *acc;
 437   unw_addr_space_t as;
 438   struct libunwind_descr *descr;
 439   int ret;
 440   unw_regnum_t uw_regnum;
 441   unw_word_t intval;
 442   unw_fpreg_t fpval;
 443   void *ptr;
 444
 445
 446   descr = libunwind_descr (gdbarch);
 447   acc = descr->special_accessors;
 448   as =  unw_create_addr_space_p (acc,
 449                                  gdbarch_byte_order (gdbarch)
 450                                  == BFD_ENDIAN_BIG
 451                                  ? __BIG_ENDIAN
 452                                  : __LITTLE_ENDIAN);
 453
 454   ret = unw_init_remote_p (&cursor, as, regcache);
 455   if (ret < 0)
 456     {
 457       unw_destroy_addr_space_p (as);
 458       return -1;
 459     }
 460
 461   uw_regnum = descr->gdb2uw (regnum);
 462
 463   if (descr->is_fpreg (uw_regnum))
 464     {
 465       ret = unw_get_fpreg_p (&cursor, uw_regnum, &fpval);
 466       ptr = &fpval;
 467     }
 468   else
 469     {
 470       ret = unw_get_reg_p (&cursor, uw_regnum, &intval);
 471       ptr = &intval;
 472     }
 473
 474   unw_destroy_addr_space_p (as);
 475
 476   if (ret < 0)
 477     return -1;
 478
 479   if (buf)
 480     memcpy (buf, ptr, register_size (gdbarch, regnum));
 481
 482   return 0;
 483 }
 484
 485 static int
 486 libunwind_load (void)
 487 {
 488   void *handle;
 489
 490   handle = dlopen (LIBUNWIND_SO, RTLD_NOW);
 491   if (handle == NULL)
 492     return 0;
 493
 494   /* Initialize pointers to the dynamic library functions we will use.  */
 495
 496   unw_get_reg_p = dlsym (handle, get_reg_name);
 497   if (unw_get_reg_p == NULL)
 498     return 0;
 499
 500   unw_get_fpreg_p = dlsym (handle, get_fpreg_name);
 501   if (unw_get_fpreg_p == NULL)
 502     return 0;
 503
 504   unw_get_saveloc_p = dlsym (handle, get_saveloc_name);
 505   if (unw_get_saveloc_p == NULL)
 506     return 0;
 507
 508   unw_is_signal_frame_p = dlsym (handle, is_signal_frame_name);
 509   if (unw_is_signal_frame_p == NULL)
 510     return 0;
 511
 512   unw_step_p = dlsym (handle, step_name);
 513   if (unw_step_p == NULL)
 514     return 0;
 515
 516   unw_init_remote_p = dlsym (handle, init_remote_name);
 517   if (unw_init_remote_p == NULL)
 518     return 0;
 519
 520   unw_create_addr_space_p = dlsym (handle, create_addr_space_name);
 521   if (unw_create_addr_space_p == NULL)
 522     return 0;
 523
 524   unw_destroy_addr_space_p = dlsym (handle, destroy_addr_space_name);
 525   if (unw_destroy_addr_space_p == NULL)
 526     return 0;
 527
 528   unw_search_unwind_table_p = dlsym (handle, search_unwind_table_name);
 529   if (unw_search_unwind_table_p == NULL)
 530     return 0;
 531
 532   unw_find_dyn_list_p = dlsym (handle, find_dyn_list_name);
 533   if (unw_find_dyn_list_p == NULL)
 534     return 0;
 535
 536   return 1;
 537 }
 538
 539 int
 540 libunwind_is_initialized (void)
 541 {
 542   return libunwind_initialized;
 543 }
 544
 545 /* Provide a prototype to silence -Wmissing-prototypes.  */
 546 void _initialize_libunwind_frame (void);
 547
 548 void
 549 _initialize_libunwind_frame (void)
 550 {
 551   libunwind_descr_handle = gdbarch_data_register_post_init (libunwind_descr_init);
 552
 553   libunwind_initialized = libunwind_load ();
 554 }