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 }
 282
 283 struct value *
 284 libunwind_frame_prev_register (struct frame_info *this_frame,
 285                                void **this_cache, int regnum)
 286 {
 287   struct libunwind_frame_cache *cache =
 288     libunwind_frame_cache (this_frame, this_cache);
 289   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 290
 291   void *ptr;
 292   unw_cursor_t *c;
 293   unw_save_loc_t sl;
 294   int i, ret;
 295   unw_word_t intval;
 296   unw_fpreg_t fpval;
 297   unw_regnum_t uw_regnum;
 298   struct libunwind_descr *descr;
 299   struct value *val = NULL;
 300
 301   if (cache == NULL)
 302     return frame_unwind_got_constant (this_frame, regnum, 0);
 303
 304   /* Convert from gdb register number to libunwind register number.  */
 305   descr = libunwind_descr (get_frame_arch (this_frame));
 306   uw_regnum = descr->gdb2uw (regnum);
 307
 308   gdb_assert (regnum >= 0);
 309
 310   if (!target_has_registers)
 311     error (_("No registers."));
 312
 313   if (uw_regnum < 0)
 314     return frame_unwind_got_constant (this_frame, regnum, 0);
 315
 316   if (unw_get_saveloc_p (&cache->cursor, uw_regnum, &sl) < 0)
 317     return frame_unwind_got_constant (this_frame, regnum, 0);
 318
 319   switch (sl.type)
 320     {
 321     case UNW_SLT_MEMORY:
 322       val = frame_unwind_got_memory (this_frame, regnum, sl.u.addr);
 323       break;
 324
 325     case UNW_SLT_REG:
 326       val = frame_unwind_got_register (this_frame, regnum,
 327                                        descr->uw2gdb (sl.u.regnum));
 328       break;
 329     case UNW_SLT_NONE:
 330       {
 331         /* The register is not stored at a specific memory address nor
 332            inside another register.  So use libunwind to fetch the register
 333            value for us, and create a constant value with the result.  */
 334         if (descr->is_fpreg (uw_regnum))
 335           {
 336             ret = unw_get_fpreg_p (&cache->cursor, uw_regnum, &fpval);
 337             if (ret < 0)
 338               return frame_unwind_got_constant (this_frame, regnum, 0);
 339             val = frame_unwind_got_bytes (this_frame, regnum,
 340                                           (gdb_byte *) &fpval);
 341           }
 342         else
 343           {
 344             ret = unw_get_reg_p (&cache->cursor, uw_regnum, &intval);
 345             if (ret < 0)
 346               return frame_unwind_got_constant (this_frame, regnum, 0);
 347             val = frame_unwind_got_constant (this_frame, regnum, intval);
 348           }
 349         set_value_optimized_out (val, 1);
 350         break;
 351       }
 352     }
 353
 354   return val;
 355 }
 356
 357 CORE_ADDR
 358 libunwind_frame_base_address (struct frame_info *this_frame, void **this_cache)
 359 {
 360   struct libunwind_frame_cache *cache =
 361     libunwind_frame_cache (this_frame, this_cache);
 362
 363   if (cache == NULL)
 364     return (CORE_ADDR)NULL;
 365   return cache->base;
 366 }
 367
 368 /* The following is a glue routine to call the libunwind unwind table
 369    search function to get unwind information for a specified ip address.  */
 370 int
 371 libunwind_search_unwind_table (void *as, long ip, void *di,
 372                                void *pi, int need_unwind_info, void *args)
 373 {
 374   return unw_search_unwind_table_p (*(unw_addr_space_t *)as, (unw_word_t )ip,
 375                                     di, pi, need_unwind_info, args);
 376 }
 377
 378 /* Verify if we are in a sigtramp frame and we can use libunwind to unwind.  */
 379 int
 380 libunwind_sigtramp_frame_sniffer (const struct frame_unwind *self,
 381                                   struct frame_info *this_frame,
 382                                   void **this_cache)
 383 {
 384   unw_cursor_t cursor;
 385   unw_accessors_t *acc;
 386   unw_addr_space_t as;
 387   struct libunwind_descr *descr;
 388   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 389   int i, ret;
 390
 391   /* To test for libunwind unwind support, initialize a cursor to the
 392      current frame and try to back up.  We use this same method when
 393      setting up the frame cache (see libunwind_frame_cache()).  If
 394      libunwind returns success for this operation, it means that it
 395      has found sufficient libunwind unwinding information to do
 396      so.  */
 397
 398   descr = libunwind_descr (gdbarch);
 399   acc = descr->accessors;
 400   as =  unw_create_addr_space_p (acc,
 401                                  gdbarch_byte_order (gdbarch)
 402                                  == BFD_ENDIAN_BIG
 403                                  ? __BIG_ENDIAN
 404                                  : __LITTLE_ENDIAN);
 405
 406   ret = unw_init_remote_p (&cursor, as, this_frame);
 407
 408   if (ret < 0)
 409     {
 410       unw_destroy_addr_space_p (as);
 411       return 0;
 412     }
 413
 414   /* Check to see if we are in a signal frame.  */
 415   ret = unw_is_signal_frame_p (&cursor);
 416   unw_destroy_addr_space_p (as);
 417   if (ret > 0)
 418     return 1;
 419
 420   return 0;
 421 }
 422
 423 /* The following routine is for accessing special registers of the top frame.
 424    A special set of accessors must be given that work without frame info.
 425    This is used by ia64 to access the rse registers r32-r127.  While they
 426    are usually located at BOF, this is not always true and only the libunwind
 427    info can decipher where they actually are.  */
 428 int
 429 libunwind_get_reg_special (struct gdbarch *gdbarch, struct regcache *regcache,
 430                            int regnum, void *buf)
 431 {
 432   unw_cursor_t cursor;
 433   unw_accessors_t *acc;
 434   unw_addr_space_t as;
 435   struct libunwind_descr *descr;
 436   int ret;
 437   unw_regnum_t uw_regnum;
 438   unw_word_t intval;
 439   unw_fpreg_t fpval;
 440   void *ptr;
 441
 442
 443   descr = libunwind_descr (gdbarch);
 444   acc = descr->special_accessors;
 445   as =  unw_create_addr_space_p (acc,
 446                                  gdbarch_byte_order (gdbarch)
 447                                  == BFD_ENDIAN_BIG
 448                                  ? __BIG_ENDIAN
 449                                  : __LITTLE_ENDIAN);
 450
 451   ret = unw_init_remote_p (&cursor, as, regcache);
 452   if (ret < 0)
 453     {
 454       unw_destroy_addr_space_p (as);
 455       return -1;
 456     }
 457
 458   uw_regnum = descr->gdb2uw (regnum);
 459
 460   if (descr->is_fpreg (uw_regnum))
 461     {
 462       ret = unw_get_fpreg_p (&cursor, uw_regnum, &fpval);
 463       ptr = &fpval;
 464     }
 465   else
 466     {
 467       ret = unw_get_reg_p (&cursor, uw_regnum, &intval);
 468       ptr = &intval;
 469     }
 470
 471   unw_destroy_addr_space_p (as);
 472
 473   if (ret < 0)
 474     return -1;
 475
 476   if (buf)
 477     memcpy (buf, ptr, register_size (gdbarch, regnum));
 478
 479   return 0;
 480 }
 481
 482 static int
 483 libunwind_load (void)
 484 {
 485   void *handle;
 486
 487   handle = dlopen (LIBUNWIND_SO, RTLD_NOW);
 488   if (handle == NULL)
 489     return 0;
 490
 491   /* Initialize pointers to the dynamic library functions we will use.  */
 492
 493   unw_get_reg_p = dlsym (handle, get_reg_name);
 494   if (unw_get_reg_p == NULL)
 495     return 0;
 496
 497   unw_get_fpreg_p = dlsym (handle, get_fpreg_name);
 498   if (unw_get_fpreg_p == NULL)
 499     return 0;
 500
 501   unw_get_saveloc_p = dlsym (handle, get_saveloc_name);
 502   if (unw_get_saveloc_p == NULL)
 503     return 0;
 504
 505   unw_is_signal_frame_p = dlsym (handle, is_signal_frame_name);
 506   if (unw_is_signal_frame_p == NULL)
 507     return 0;
 508
 509   unw_step_p = dlsym (handle, step_name);
 510   if (unw_step_p == NULL)
 511     return 0;
 512
 513   unw_init_remote_p = dlsym (handle, init_remote_name);
 514   if (unw_init_remote_p == NULL)
 515     return 0;
 516
 517   unw_create_addr_space_p = dlsym (handle, create_addr_space_name);
 518   if (unw_create_addr_space_p == NULL)
 519     return 0;
 520
 521   unw_destroy_addr_space_p = dlsym (handle, destroy_addr_space_name);
 522   if (unw_destroy_addr_space_p == NULL)
 523     return 0;
 524
 525   unw_search_unwind_table_p = dlsym (handle, search_unwind_table_name);
 526   if (unw_search_unwind_table_p == NULL)
 527     return 0;
 528
 529   unw_find_dyn_list_p = dlsym (handle, find_dyn_list_name);
 530   if (unw_find_dyn_list_p == NULL)
 531     return 0;
 532
 533   return 1;
 534 }
 535
 536 int
 537 libunwind_is_initialized (void)
 538 {
 539   return libunwind_initialized;
 540 }
 541
 542 /* Provide a prototype to silence -Wmissing-prototypes.  */
 543 void _initialize_libunwind_frame (void);
 544
 545 void
 546 _initialize_libunwind_frame (void)
 547 {
 548   libunwind_descr_handle = gdbarch_data_register_post_init (libunwind_descr_init);
 549
 550   libunwind_initialized = libunwind_load ();
 551 }