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 void (*unw_destroy_addr_space_p) (unw_addr_space_t);
  57 static int (*unw_search_unwind_table_p) (unw_addr_space_t, unw_word_t, unw_dyn_info_t *,
  58                                          unw_proc_info_t *, int, void *);
  59 static unw_word_t (*unw_find_dyn_list_p) (unw_addr_space_t, unw_dyn_info_t *,
  60                                           void *);
  61
  62
  63 struct libunwind_frame_cache
  64 {
  65   CORE_ADDR base;
  66   CORE_ADDR func_addr;
  67   unw_cursor_t cursor;
  68   unw_addr_space_t as;
  69 };
  70
  71 /* We need to qualify the function names with a platform-specific prefix to match
  72    the names used by the libunwind library.  The UNW_OBJ macro is provided by the
  73    libunwind.h header file.  */
  74 #define STRINGIFY2(name)        #name
  75 #define STRINGIFY(name)         STRINGIFY2(name)
  76
  77 #ifndef LIBUNWIND_SO
  78 /* Use the stable ABI major version number.  `libunwind-ia64.so' is a link time
  79    only library, not a runtime one.  */
  80 #define LIBUNWIND_SO "libunwind-" STRINGIFY(UNW_TARGET) ".so.7"
  81 #endif
  82
  83 static char *get_reg_name = STRINGIFY(UNW_OBJ(get_reg));
  84 static char *get_fpreg_name = STRINGIFY(UNW_OBJ(get_fpreg));
  85 static char *get_saveloc_name = STRINGIFY(UNW_OBJ(get_save_loc));
  86 static char *is_signal_frame_name = STRINGIFY(UNW_OBJ(is_signal_frame));
  87 static char *step_name = STRINGIFY(UNW_OBJ(step));
  88 static char *init_remote_name = STRINGIFY(UNW_OBJ(init_remote));
  89 static char *create_addr_space_name = STRINGIFY(UNW_OBJ(create_addr_space));
  90 static char *destroy_addr_space_name = STRINGIFY(UNW_OBJ(destroy_addr_space));
  91 static char *search_unwind_table_name = STRINGIFY(UNW_OBJ(search_unwind_table));
  92 static char *find_dyn_list_name = STRINGIFY(UNW_OBJ(find_dyn_list));
  93
  94 static struct libunwind_descr *
  95 libunwind_descr (struct gdbarch *gdbarch)
  96 {
  97   return gdbarch_data (gdbarch, libunwind_descr_handle);
  98 }
  99
 100 static void *
 101 libunwind_descr_init (struct gdbarch *gdbarch)
 102 {
 103   struct libunwind_descr *descr = GDBARCH_OBSTACK_ZALLOC (gdbarch,
 104                                                           struct libunwind_descr);
 105   return descr;
 106 }
 107
 108 void
 109 libunwind_frame_set_descr (struct gdbarch *gdbarch, struct libunwind_descr *descr)
 110 {
 111   struct libunwind_descr *arch_descr;
 112
 113   gdb_assert (gdbarch != NULL);
 114
 115   arch_descr = gdbarch_data (gdbarch, libunwind_descr_handle);
 116
 117   if (arch_descr == NULL)
 118     {
 119       /* First time here.  Must initialize data area.  */
 120       arch_descr = libunwind_descr_init (gdbarch);
 121       deprecated_set_gdbarch_data (gdbarch, libunwind_descr_handle, arch_descr);
 122     }
 123
 124   /* Copy new descriptor info into arch descriptor.  */
 125   arch_descr->gdb2uw = descr->gdb2uw;
 126   arch_descr->uw2gdb = descr->uw2gdb;
 127   arch_descr->is_fpreg = descr->is_fpreg;
 128   arch_descr->accessors = descr->accessors;
 129   arch_descr->special_accessors = descr->special_accessors;
 130 }
 131
 132 static struct libunwind_frame_cache *
 133 libunwind_frame_cache (struct frame_info *next_frame, void **this_cache)
 134 {
 135   unw_accessors_t *acc;
 136   unw_addr_space_t as;
 137   unw_word_t fp;
 138   unw_regnum_t uw_sp_regnum;
 139   struct libunwind_frame_cache *cache;
 140   struct libunwind_descr *descr;
 141   int i, ret;
 142
 143   if (*this_cache)
 144     return *this_cache;
 145
 146   /* Allocate a new cache.  */
 147   cache = FRAME_OBSTACK_ZALLOC (struct libunwind_frame_cache);
 148
 149   /* We can assume we are unwinding a normal frame.  Even if this is
 150      for a signal trampoline, ia64 signal "trampolines" use a normal
 151      subroutine call to start the signal handler.  */
 152   cache->func_addr = frame_func_unwind (next_frame, NORMAL_FRAME);
 153   if (cache->func_addr == 0
 154       && frame_relative_level (next_frame) > 0
 155       && get_frame_type (next_frame) != SIGTRAMP_FRAME)
 156     return NULL;
 157
 158   /* Get a libunwind cursor to the previous frame.  We do this by initializing
 159      a cursor.  Libunwind treats a new cursor as the top of stack and will get
 160      the current register set via the libunwind register accessor.  Now, we
 161      provide the platform-specific accessors and we set up the register accessor to use
 162      the frame register unwinding interfaces so that we properly get the registers for
 163      the current frame rather than the top.  We then use the  unw_step function to
 164      move the libunwind cursor back one frame.  We can later use this cursor to find previous
 165      registers via the unw_get_reg interface which will invoke libunwind's special logic.  */
 166   descr = libunwind_descr (get_frame_arch (next_frame));
 167   acc = descr->accessors;
 168   as =  unw_create_addr_space_p (acc,
 169                                  gdbarch_byte_order (current_gdbarch)
 170                                  == BFD_ENDIAN_BIG
 171                                  ? __BIG_ENDIAN
 172                                  : __LITTLE_ENDIAN);
 173
 174   unw_init_remote_p (&cache->cursor, as, next_frame);
 175   if (unw_step_p (&cache->cursor) < 0)
 176     {
 177       unw_destroy_addr_space_p (as);
 178       return NULL;
 179     }
 180
 181   /* To get base address, get sp from previous frame.  */
 182   uw_sp_regnum = descr->gdb2uw (gdbarch_sp_regnum (current_gdbarch));
 183   ret = unw_get_reg_p (&cache->cursor, uw_sp_regnum, &fp);
 184   if (ret < 0)
 185     {
 186       unw_destroy_addr_space_p (as);
 187       error (_("Can't get libunwind sp register."));
 188     }
 189
 190   cache->base = (CORE_ADDR)fp;
 191   cache->as = as;
 192
 193   *this_cache = cache;
 194   return cache;
 195 }
 196
 197 void
 198 libunwind_frame_dealloc_cache (struct frame_info *self, void *this_cache)
 199 {
 200   struct libunwind_frame_cache *cache = this_cache;
 201   if (cache->as)
 202     unw_destroy_addr_space_p (cache->as);
 203 }
 204
 205 unw_word_t
 206 libunwind_find_dyn_list (unw_addr_space_t as, unw_dyn_info_t *di, void *arg)
 207 {
 208   return unw_find_dyn_list_p (as, di, arg);
 209 }
 210
 211 static const struct frame_unwind libunwind_frame_unwind =
 212 {
 213   NORMAL_FRAME,
 214   libunwind_frame_this_id,
 215   libunwind_frame_prev_register,
 216   NULL,
 217   NULL,
 218   NULL,
 219   libunwind_frame_dealloc_cache
 220 };
 221
 222 /* Verify if there is sufficient libunwind information for the frame to use
 223    libunwind frame unwinding.  */
 224 const struct frame_unwind *
 225 libunwind_frame_sniffer (struct frame_info *next_frame)
 226 {
 227   unw_cursor_t cursor;
 228   unw_accessors_t *acc;
 229   unw_addr_space_t as;
 230   struct libunwind_descr *descr;
 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 (get_frame_arch (next_frame));
 239   acc = descr->accessors;
 240   as =  unw_create_addr_space_p (acc,
 241                                  gdbarch_byte_order (current_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
 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 (current_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 (current_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   int i, ret;
 392
 393   /* To test for libunwind unwind support, initialize a cursor to the
 394      current frame and try to back up.  We use this same method when
 395      setting up the frame cache (see libunwind_frame_cache()).  If
 396      libunwind returns success for this operation, it means that it
 397      has found sufficient libunwind unwinding information to do
 398      so.  */
 399
 400   descr = libunwind_descr (get_frame_arch (next_frame));
 401   acc = descr->accessors;
 402   as =  unw_create_addr_space_p (acc,
 403                                  gdbarch_byte_order (current_gdbarch)
 404                                  == BFD_ENDIAN_BIG
 405                                  ? __BIG_ENDIAN
 406                                  : __LITTLE_ENDIAN);
 407
 408   ret = unw_init_remote_p (&cursor, as, next_frame);
 409
 410   if (ret < 0)
 411     {
 412       unw_destroy_addr_space_p (as);
 413       return NULL;
 414     }
 415
 416   /* Check to see if we are in a signal frame.  */
 417   ret = unw_is_signal_frame_p (&cursor);
 418   unw_destroy_addr_space_p (as);
 419   if (ret > 0)
 420     return &libunwind_frame_unwind;
 421
 422   return NULL;
 423 }
 424
 425 /* The following routine is for accessing special registers of the top frame.
 426    A special set of accessors must be given that work without frame info.
 427    This is used by ia64 to access the rse registers r32-r127.  While they
 428    are usually located at BOF, this is not always true and only the libunwind
 429    info can decipher where they actually are.  */
 430 int
 431 libunwind_get_reg_special (struct gdbarch *gdbarch, struct regcache *regcache,
 432                            int regnum, void *buf)
 433 {
 434   unw_cursor_t cursor;
 435   unw_accessors_t *acc;
 436   unw_addr_space_t as;
 437   struct libunwind_descr *descr;
 438   int ret;
 439   unw_regnum_t uw_regnum;
 440   unw_word_t intval;
 441   unw_fpreg_t fpval;
 442   void *ptr;
 443
 444
 445   descr = libunwind_descr (gdbarch);
 446   acc = descr->special_accessors;
 447   as =  unw_create_addr_space_p (acc,
 448                                  gdbarch_byte_order (current_gdbarch)
 449                                  == BFD_ENDIAN_BIG
 450                                  ? __BIG_ENDIAN
 451                                  : __LITTLE_ENDIAN);
 452
 453   ret = unw_init_remote_p (&cursor, as, regcache);
 454   if (ret < 0)
 455     {
 456       unw_destroy_addr_space_p (as);
 457       return -1;
 458     }
 459
 460   uw_regnum = descr->gdb2uw (regnum);
 461
 462   if (descr->is_fpreg (uw_regnum))
 463     {
 464       ret = unw_get_fpreg_p (&cursor, uw_regnum, &fpval);
 465       ptr = &fpval;
 466     }
 467   else
 468     {
 469       ret = unw_get_reg_p (&cursor, uw_regnum, &intval);
 470       ptr = &intval;
 471     }
 472
 473   unw_destroy_addr_space_p (as);
 474
 475   if (ret < 0)
 476     return -1;
 477
 478   if (buf)
 479     memcpy (buf, ptr, register_size (current_gdbarch, regnum));
 480
 481   return 0;
 482 }
 483
 484 static int
 485 libunwind_load (void)
 486 {
 487   void *handle;
 488
 489   handle = dlopen (LIBUNWIND_SO, RTLD_NOW);
 490   if (handle == NULL)
 491     return 0;
 492
 493   /* Initialize pointers to the dynamic library functions we will use.  */
 494
 495   unw_get_reg_p = dlsym (handle, get_reg_name);
 496   if (unw_get_reg_p == NULL)
 497     return 0;
 498
 499   unw_get_fpreg_p = dlsym (handle, get_fpreg_name);
 500   if (unw_get_fpreg_p == NULL)
 501     return 0;
 502
 503   unw_get_saveloc_p = dlsym (handle, get_saveloc_name);
 504   if (unw_get_saveloc_p == NULL)
 505     return 0;
 506
 507   unw_is_signal_frame_p = dlsym (handle, is_signal_frame_name);
 508   if (unw_is_signal_frame_p == NULL)
 509     return 0;
 510
 511   unw_step_p = dlsym (handle, step_name);
 512   if (unw_step_p == NULL)
 513     return 0;
 514
 515   unw_init_remote_p = dlsym (handle, init_remote_name);
 516   if (unw_init_remote_p == NULL)
 517     return 0;
 518
 519   unw_create_addr_space_p = dlsym (handle, create_addr_space_name);
 520   if (unw_create_addr_space_p == NULL)
 521     return 0;
 522
 523   unw_destroy_addr_space_p = dlsym (handle, destroy_addr_space_name);
 524   if (unw_destroy_addr_space_p == NULL)
 525     return 0;
 526
 527   unw_search_unwind_table_p = dlsym (handle, search_unwind_table_name);
 528   if (unw_search_unwind_table_p == NULL)
 529     return 0;
 530
 531   unw_find_dyn_list_p = dlsym (handle, find_dyn_list_name);
 532   if (unw_find_dyn_list_p == NULL)
 533     return 0;
 534
 535   return 1;
 536 }
 537
 538 int
 539 libunwind_is_initialized (void)
 540 {
 541   return libunwind_initialized;
 542 }
 543
 544 /* Provide a prototype to silence -Wmissing-prototypes.  */
 545 void _initialize_libunwind_frame (void);
 546
 547 void
 548 _initialize_libunwind_frame (void)
 549 {
 550   libunwind_descr_handle = gdbarch_data_register_post_init (libunwind_descr_init);
 551
 552   libunwind_initialized = libunwind_load ();
 553 }