gdb/libunwind-frame.c

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