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