gdb/libunwind-frame.c

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