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