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