gdb/libunwind-frame.c

   1 /* Frame unwinder for frames using the libunwind library.
   2
   3    Copyright (C) 2003, 2004, 2006, 2007, 2008, 2009
   4    Free Software Foundation, Inc.
   5
   6    Written by Jeff Johnston, contributed by Red Hat Inc.
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  22
  23 #include "defs.h"
  24
  25 #include "inferior.h"
  26 #include "frame.h"
  27 #include "frame-base.h"
  28 #include "frame-unwind.h"
  29 #include "gdbcore.h"
  30 #include "gdbtypes.h"
  31 #include "symtab.h"
  32 #include "objfiles.h"
  33 #include "regcache.h"
  34
  35 #include <dlfcn.h>
  36
  37 #include "gdb_assert.h"
  38 #include "gdb_string.h"
  39
  40 #include "libunwind-frame.h"
  41
  42 #include "complaints.h"
  43
  44 static int libunwind_initialized;
  45 static struct gdbarch_data *libunwind_descr_handle;
  46
  47 /* Required function pointers from libunwind.  */
  48 static int (*unw_get_reg_p) (unw_cursor_t *, unw_regnum_t, unw_word_t *);
  49 static int (*unw_get_fpreg_p) (unw_cursor_t *, unw_regnum_t, unw_fpreg_t *);
  50 static int (*unw_get_saveloc_p) (unw_cursor_t *, unw_regnum_t, unw_save_loc_t *);
  51 static int (*unw_is_signal_frame_p) (unw_cursor_t *);
  52 static int (*unw_step_p) (unw_cursor_t *);
  53 static int (*unw_init_remote_p) (unw_cursor_t *, unw_addr_space_t, void *);
  54 static unw_addr_space_t (*unw_create_addr_space_p) (unw_accessors_t *, int);
  55 static void (*unw_destroy_addr_space_p) (unw_addr_space_t);
  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   unw_addr_space_t as;
  68 };
  69
  70 /* We need to qualify the function names with a platform-specific prefix
  71    to match the names used by the libunwind library.  The UNW_OBJ macro is
  72    provided by the 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 *this_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   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 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 = get_frame_func (this_frame);
 153   if (cache->func_addr == 0
 154       && get_next_frame (this_frame)
 155       && get_frame_type (get_next_frame (this_frame)) == NORMAL_FRAME)
 156     return NULL;
 157
 158   /* Get a libunwind cursor to the previous frame.
 159
 160      We do this by initializing a cursor.  Libunwind treats a new cursor
 161      as the top of stack and will get the current register set via the
 162      libunwind register accessor.  Now, we provide the platform-specific
 163      accessors and we set up the register accessor to use the frame
 164      register unwinding interfaces so that we properly get the registers
 165      for the current frame rather than the top.  We then use the unw_step
 166      function to move the libunwind cursor back one frame.  We can later
 167      use this cursor to find previous registers via the unw_get_reg
 168      interface which will invoke libunwind's special logic.  */
 169   descr = libunwind_descr (gdbarch);
 170   acc = descr->accessors;
 171   as =  unw_create_addr_space_p (acc,
 172                                  gdbarch_byte_order (gdbarch)
 173                                  == BFD_ENDIAN_BIG
 174                                  ? __BIG_ENDIAN
 175                                  : __LITTLE_ENDIAN);
 176
 177   unw_init_remote_p (&cache->cursor, as, this_frame);
 178   if (unw_step_p (&cache->cursor) < 0)
 179     {
 180       unw_destroy_addr_space_p (as);
 181       return NULL;
 182     }
 183
 184   /* To get base address, get sp from previous frame.  */
 185   uw_sp_regnum = descr->gdb2uw (gdbarch_sp_regnum (gdbarch));
 186   ret = unw_get_reg_p (&cache->cursor, uw_sp_regnum, &fp);
 187   if (ret < 0)
 188     {
 189       unw_destroy_addr_space_p (as);
 190       error (_("Can't get libunwind sp register."));
 191     }
 192
 193   cache->base = (CORE_ADDR)fp;
 194   cache->as = as;
 195
 196   *this_cache = cache;
 197   return cache;
 198 }
 199
 200 void
 201 libunwind_frame_dealloc_cache (struct frame_info *self, void *this_cache)
 202 {
 203   struct libunwind_frame_cache *cache = this_cache;
 204   if (cache->as)
 205     unw_destroy_addr_space_p (cache->as);
 206 }
 207
 208 unw_word_t
 209 libunwind_find_dyn_list (unw_addr_space_t as, unw_dyn_info_t *di, void *arg)
 210 {
 211   return unw_find_dyn_list_p (as, di, arg);
 212 }
 213
 214 static const struct frame_unwind libunwind_frame_unwind =
 215 {
 216   NORMAL_FRAME,
 217   libunwind_frame_this_id,
 218   libunwind_frame_prev_register,
 219   NULL,
 220   libunwind_frame_sniffer,
 221   libunwind_frame_dealloc_cache,
 222 };
 223
 224 /* Verify if there is sufficient libunwind information for the frame to use
 225    libunwind frame unwinding.  */
 226 int
 227 libunwind_frame_sniffer (const struct frame_unwind *self,
 228                          struct frame_info *this_frame, void **this_cache)
 229 {
 230   unw_cursor_t cursor;
 231   unw_accessors_t *acc;
 232   unw_addr_space_t as;
 233   struct libunwind_descr *descr;
 234   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 235   int i, ret;
 236
 237   /* To test for libunwind unwind support, initialize a cursor to
 238      the current frame and try to back up.  We use this same method
 239      when setting up the frame cache (see libunwind_frame_cache()).
 240      If libunwind returns success for this operation, it means that
 241      it has found sufficient libunwind unwinding information to do so.  */
 242
 243   descr = libunwind_descr (gdbarch);
 244   acc = descr->accessors;
 245   as =  unw_create_addr_space_p (acc,
 246                                  gdbarch_byte_order (gdbarch)
 247                                  == BFD_ENDIAN_BIG
 248                                  ? __BIG_ENDIAN
 249                                  : __LITTLE_ENDIAN);
 250
 251   ret = unw_init_remote_p (&cursor, as, this_frame);
 252
 253   if (ret < 0)
 254     {
 255       unw_destroy_addr_space_p (as);
 256       return 0;
 257     }
 258
 259
 260   /* Check to see if we have libunwind info by checking if we are in a
 261      signal frame.  If it doesn't return an error, we have libunwind info
 262      and can use libunwind.  */
 263   ret = unw_is_signal_frame_p (&cursor);
 264   unw_destroy_addr_space_p (as);
 265
 266   if (ret < 0)
 267     return 0;
 268
 269   return 1;
 270 }
 271
 272 void
 273 libunwind_frame_this_id (struct frame_info *this_frame, void **this_cache,
 274                          struct frame_id *this_id)
 275 {
 276   struct libunwind_frame_cache *cache =
 277     libunwind_frame_cache (this_frame, this_cache);
 278
 279   if (cache != NULL)
 280     (*this_id) = frame_id_build (cache->base, cache->func_addr);
 281   else
 282     (*this_id) = null_frame_id;
 283 }
 284
 285 struct value *
 286 libunwind_frame_prev_register (struct frame_info *this_frame,
 287                                void **this_cache, int regnum)
 288 {
 289   struct libunwind_frame_cache *cache =
 290     libunwind_frame_cache (this_frame, this_cache);
 291   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 292
 293   void *ptr;
 294   unw_cursor_t *c;
 295   unw_save_loc_t sl;
 296   int i, ret;
 297   unw_word_t intval;
 298   unw_fpreg_t fpval;
 299   unw_regnum_t uw_regnum;
 300   struct libunwind_descr *descr;
 301   struct value *val = NULL;
 302
 303   if (cache == NULL)
 304     return frame_unwind_got_constant (this_frame, regnum, 0);
 305
 306   /* Convert from gdb register number to libunwind register number.  */
 307   descr = libunwind_descr (get_frame_arch (this_frame));
 308   uw_regnum = descr->gdb2uw (regnum);
 309
 310   gdb_assert (regnum >= 0);
 311
 312   if (!target_has_registers)
 313     error (_("No registers."));
 314
 315   if (uw_regnum < 0)
 316     return frame_unwind_got_constant (this_frame, regnum, 0);
 317
 318   if (unw_get_saveloc_p (&cache->cursor, uw_regnum, &sl) < 0)
 319     return frame_unwind_got_constant (this_frame, regnum, 0);
 320
 321   switch (sl.type)
 322     {
 323     case UNW_SLT_MEMORY:
 324       val = frame_unwind_got_memory (this_frame, regnum, sl.u.addr);
 325       break;
 326
 327     case UNW_SLT_REG:
 328       val = frame_unwind_got_register (this_frame, regnum,
 329                                        descr->uw2gdb (sl.u.regnum));
 330       break;
 331     case UNW_SLT_NONE:
 332       {
 333         /* The register is not stored at a specific memory address nor
 334            inside another register.  So use libunwind to fetch the register
 335            value for us, and create a constant value with the result.  */
 336         if (descr->is_fpreg (uw_regnum))
 337           {
 338             ret = unw_get_fpreg_p (&cache->cursor, uw_regnum, &fpval);
 339             if (ret < 0)
 340               return frame_unwind_got_constant (this_frame, regnum, 0);
 341             val = frame_unwind_got_bytes (this_frame, regnum,
 342                                           (gdb_byte *) &fpval);
 343           }
 344         else
 345           {
 346             ret = unw_get_reg_p (&cache->cursor, uw_regnum, &intval);
 347             if (ret < 0)
 348               return frame_unwind_got_constant (this_frame, regnum, 0);
 349             val = frame_unwind_got_constant (this_frame, regnum, intval);
 350           }
 351         set_value_optimized_out (val, 1);
 352         break;
 353       }
 354     }
 355
 356   return val;
 357 }
 358
 359 CORE_ADDR
 360 libunwind_frame_base_address (struct frame_info *this_frame, void **this_cache)
 361 {
 362   struct libunwind_frame_cache *cache =
 363     libunwind_frame_cache (this_frame, this_cache);
 364
 365   if (cache == NULL)
 366     return (CORE_ADDR)NULL;
 367   return cache->base;
 368 }
 369
 370 /* The following is a glue routine to call the libunwind unwind table
 371    search function to get unwind information for a specified ip address.  */
 372 int
 373 libunwind_search_unwind_table (void *as, long ip, void *di,
 374                                void *pi, int need_unwind_info, void *args)
 375 {
 376   return unw_search_unwind_table_p (*(unw_addr_space_t *)as, (unw_word_t )ip,
 377                                     di, pi, need_unwind_info, args);
 378 }
 379
 380 /* Verify if we are in a sigtramp frame and we can use libunwind to unwind.  */
 381 int
 382 libunwind_sigtramp_frame_sniffer (const struct frame_unwind *self,
 383                                   struct frame_info *this_frame,
 384                                   void **this_cache)
 385 {
 386   unw_cursor_t cursor;
 387   unw_accessors_t *acc;
 388   unw_addr_space_t as;
 389   struct libunwind_descr *descr;
 390   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 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 (gdbarch);
 401   acc = descr->accessors;
 402   as =  unw_create_addr_space_p (acc,
 403                                  gdbarch_byte_order (gdbarch)
 404                                  == BFD_ENDIAN_BIG
 405                                  ? __BIG_ENDIAN
 406                                  : __LITTLE_ENDIAN);
 407
 408   ret = unw_init_remote_p (&cursor, as, this_frame);
 409
 410   if (ret < 0)
 411     {
 412       unw_destroy_addr_space_p (as);
 413       return 0;
 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 1;
 421
 422   return 0;
 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 (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 (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 }