gdb/libunwind-frame.c

   1 /* Frame unwinder for frames using the libunwind library.
   2
   3    Copyright (C) 2003-2004, 2006-2012 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 3 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, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23
  24 #include "inferior.h"
  25 #include "frame.h"
  26 #include "frame-base.h"
  27 #include "frame-unwind.h"
  28 #include "gdbcore.h"
  29 #include "gdbtypes.h"
  30 #include "symtab.h"
  31 #include "objfiles.h"
  32 #include "regcache.h"
  33
  34 #include <dlfcn.h>
  35
  36 #include "gdb_assert.h"
  37 #include "gdb_string.h"
  38
  39 #include "libunwind-frame.h"
  40
  41 #include "complaints.h"
  42
  43 /* The following two macros are normally defined in <endian.h>.
  44    But systems such as ia64-hpux do not provide such header, so
  45    we just define them here if not already defined.  */
  46 #ifndef __LITTLE_ENDIAN
  47 #define __LITTLE_ENDIAN 1234
  48 #endif
  49 #ifndef __BIG_ENDIAN
  50 #define __BIG_ENDIAN    4321
  51 #endif
  52
  53 static int libunwind_initialized;
  54 static struct gdbarch_data *libunwind_descr_handle;
  55
  56 /* Required function pointers from libunwind.  */
  57 static int (*unw_get_reg_p) (unw_cursor_t *, unw_regnum_t, unw_word_t *);
  58 static int (*unw_get_fpreg_p) (unw_cursor_t *, unw_regnum_t, unw_fpreg_t *);
  59 static int (*unw_get_saveloc_p) (unw_cursor_t *, unw_regnum_t,
  60                                  unw_save_loc_t *);
  61 static int (*unw_is_signal_frame_p) (unw_cursor_t *);
  62 static int (*unw_step_p) (unw_cursor_t *);
  63 static int (*unw_init_remote_p) (unw_cursor_t *, unw_addr_space_t, void *);
  64 static unw_addr_space_t (*unw_create_addr_space_p) (unw_accessors_t *, int);
  65 static void (*unw_destroy_addr_space_p) (unw_addr_space_t);
  66 static int (*unw_search_unwind_table_p) (unw_addr_space_t, unw_word_t,
  67                                          unw_dyn_info_t *,
  68                                          unw_proc_info_t *, int, void *);
  69 static unw_word_t (*unw_find_dyn_list_p) (unw_addr_space_t, unw_dyn_info_t *,
  70                                           void *);
  71
  72
  73 struct libunwind_frame_cache
  74 {
  75   CORE_ADDR base;
  76   CORE_ADDR func_addr;
  77   unw_cursor_t cursor;
  78   unw_addr_space_t as;
  79 };
  80
  81 /* We need to qualify the function names with a platform-specific prefix
  82    to match the names used by the libunwind library.  The UNW_OBJ macro is
  83    provided by the libunwind.h header file.  */
  84 #define STRINGIFY2(name)        #name
  85 #define STRINGIFY(name)         STRINGIFY2(name)
  86
  87 #ifndef LIBUNWIND_SO
  88 /* Use the stable ABI major version number.  `libunwind-ia64.so' is a link time
  89    only library, not a runtime one.  */
  90 #define LIBUNWIND_SO "libunwind-" STRINGIFY(UNW_TARGET) ".so.7"
  91 #endif
  92
  93 static char *get_reg_name = STRINGIFY(UNW_OBJ(get_reg));
  94 static char *get_fpreg_name = STRINGIFY(UNW_OBJ(get_fpreg));
  95 static char *get_saveloc_name = STRINGIFY(UNW_OBJ(get_save_loc));
  96 static char *is_signal_frame_name = STRINGIFY(UNW_OBJ(is_signal_frame));
  97 static char *step_name = STRINGIFY(UNW_OBJ(step));
  98 static char *init_remote_name = STRINGIFY(UNW_OBJ(init_remote));
  99 static char *create_addr_space_name = STRINGIFY(UNW_OBJ(create_addr_space));
 100 static char *destroy_addr_space_name = STRINGIFY(UNW_OBJ(destroy_addr_space));
 101 static char *search_unwind_table_name
 102   = STRINGIFY(UNW_OBJ(search_unwind_table));
 103 static char *find_dyn_list_name = STRINGIFY(UNW_OBJ(find_dyn_list));
 104
 105 static struct libunwind_descr *
 106 libunwind_descr (struct gdbarch *gdbarch)
 107 {
 108   return gdbarch_data (gdbarch, libunwind_descr_handle);
 109 }
 110
 111 static void *
 112 libunwind_descr_init (struct gdbarch *gdbarch)
 113 {
 114   struct libunwind_descr *descr
 115     = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct libunwind_descr);
 116
 117   return descr;
 118 }
 119
 120 void
 121 libunwind_frame_set_descr (struct gdbarch *gdbarch,
 122                            struct libunwind_descr *descr)
 123 {
 124   struct libunwind_descr *arch_descr;
 125
 126   gdb_assert (gdbarch != NULL);
 127
 128   arch_descr = gdbarch_data (gdbarch, libunwind_descr_handle);
 129
 130   if (arch_descr == NULL)
 131     {
 132       /* First time here.  Must initialize data area.  */
 133       arch_descr = libunwind_descr_init (gdbarch);
 134       deprecated_set_gdbarch_data (gdbarch,
 135                                    libunwind_descr_handle, arch_descr);
 136     }
 137
 138   /* Copy new descriptor info into arch descriptor.  */
 139   arch_descr->gdb2uw = descr->gdb2uw;
 140   arch_descr->uw2gdb = descr->uw2gdb;
 141   arch_descr->is_fpreg = descr->is_fpreg;
 142   arch_descr->accessors = descr->accessors;
 143   arch_descr->special_accessors = descr->special_accessors;
 144 }
 145
 146 static struct libunwind_frame_cache *
 147 libunwind_frame_cache (struct frame_info *this_frame, void **this_cache)
 148 {
 149   unw_accessors_t *acc;
 150   unw_addr_space_t as;
 151   unw_word_t fp;
 152   unw_regnum_t uw_sp_regnum;
 153   struct libunwind_frame_cache *cache;
 154   struct libunwind_descr *descr;
 155   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 156   int i, ret;
 157
 158   if (*this_cache)
 159     return *this_cache;
 160
 161   /* Allocate a new cache.  */
 162   cache = FRAME_OBSTACK_ZALLOC (struct libunwind_frame_cache);
 163
 164   cache->func_addr = get_frame_func (this_frame);
 165   if (cache->func_addr == 0)
 166     /* This can happen when the frame corresponds to a function for which
 167        there is no debugging information nor any entry in the symbol table.
 168        This is probably a static function for which an entry in the symbol
 169        table was not created when the objfile got linked (observed in
 170        libpthread.so on ia64-hpux).
 171
 172        The best we can do, in that case, is use the frame PC as the function
 173        address.  We don't need to give up since we still have the unwind
 174        record to help us perform the unwinding.  There is also another
 175        compelling to continue, because abandonning now means stopping
 176        the backtrace, which can never be helpful for the user.  */
 177     cache->func_addr = get_frame_pc (this_frame);
 178
 179   /* Get a libunwind cursor to the previous frame.
 180
 181      We do this by initializing a cursor.  Libunwind treats a new cursor
 182      as the top of stack and will get the current register set via the
 183      libunwind register accessor.  Now, we provide the platform-specific
 184      accessors and we set up the register accessor to use the frame
 185      register unwinding interfaces so that we properly get the registers
 186      for the current frame rather than the top.  We then use the unw_step
 187      function to move the libunwind cursor back one frame.  We can later
 188      use this cursor to find previous registers via the unw_get_reg
 189      interface which will invoke libunwind's special logic.  */
 190   descr = libunwind_descr (gdbarch);
 191   acc = descr->accessors;
 192   as =  unw_create_addr_space_p (acc,
 193                                  gdbarch_byte_order (gdbarch)
 194                                  == BFD_ENDIAN_BIG
 195                                  ? __BIG_ENDIAN
 196                                  : __LITTLE_ENDIAN);
 197
 198   unw_init_remote_p (&cache->cursor, as, this_frame);
 199   if (unw_step_p (&cache->cursor) < 0)
 200     {
 201       unw_destroy_addr_space_p (as);
 202       return NULL;
 203     }
 204
 205   /* To get base address, get sp from previous frame.  */
 206   uw_sp_regnum = descr->gdb2uw (gdbarch_sp_regnum (gdbarch));
 207   ret = unw_get_reg_p (&cache->cursor, uw_sp_regnum, &fp);
 208   if (ret < 0)
 209     {
 210       unw_destroy_addr_space_p (as);
 211       error (_("Can't get libunwind sp register."));
 212     }
 213
 214   cache->base = (CORE_ADDR)fp;
 215   cache->as = as;
 216
 217   *this_cache = cache;
 218   return cache;
 219 }
 220
 221 void
 222 libunwind_frame_dealloc_cache (struct frame_info *self, void *this_cache)
 223 {
 224   struct libunwind_frame_cache *cache = this_cache;
 225
 226   if (cache->as)
 227     unw_destroy_addr_space_p (cache->as);
 228 }
 229
 230 unw_word_t
 231 libunwind_find_dyn_list (unw_addr_space_t as, unw_dyn_info_t *di, void *arg)
 232 {
 233   return unw_find_dyn_list_p (as, di, arg);
 234 }
 235
 236 static const struct frame_unwind libunwind_frame_unwind =
 237 {
 238   NORMAL_FRAME,
 239   default_frame_unwind_stop_reason,
 240   libunwind_frame_this_id,
 241   libunwind_frame_prev_register,
 242   NULL,
 243   libunwind_frame_sniffer,
 244   libunwind_frame_dealloc_cache,
 245 };
 246
 247 /* Verify if there is sufficient libunwind information for the frame to use
 248    libunwind frame unwinding.  */
 249 int
 250 libunwind_frame_sniffer (const struct frame_unwind *self,
 251                          struct frame_info *this_frame, void **this_cache)
 252 {
 253   unw_cursor_t cursor;
 254   unw_accessors_t *acc;
 255   unw_addr_space_t as;
 256   struct libunwind_descr *descr;
 257   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 258   int i, ret;
 259
 260   /* To test for libunwind unwind support, initialize a cursor to
 261      the current frame and try to back up.  We use this same method
 262      when setting up the frame cache (see libunwind_frame_cache()).
 263      If libunwind returns success for this operation, it means that
 264      it has found sufficient libunwind unwinding information to do so.  */
 265
 266   descr = libunwind_descr (gdbarch);
 267   acc = descr->accessors;
 268   as =  unw_create_addr_space_p (acc,
 269                                  gdbarch_byte_order (gdbarch)
 270                                  == BFD_ENDIAN_BIG
 271                                  ? __BIG_ENDIAN
 272                                  : __LITTLE_ENDIAN);
 273
 274   ret = unw_init_remote_p (&cursor, as, this_frame);
 275
 276   if (ret < 0)
 277     {
 278       unw_destroy_addr_space_p (as);
 279       return 0;
 280     }
 281
 282
 283   /* Check to see if we have libunwind info by checking if we are in a
 284      signal frame.  If it doesn't return an error, we have libunwind info
 285      and can use libunwind.  */
 286   ret = unw_is_signal_frame_p (&cursor);
 287   unw_destroy_addr_space_p (as);
 288
 289   if (ret < 0)
 290     return 0;
 291
 292   return 1;
 293 }
 294
 295 void
 296 libunwind_frame_this_id (struct frame_info *this_frame, void **this_cache,
 297                          struct frame_id *this_id)
 298 {
 299   struct libunwind_frame_cache *cache =
 300     libunwind_frame_cache (this_frame, this_cache);
 301
 302   if (cache != NULL)
 303     (*this_id) = frame_id_build (cache->base, cache->func_addr);
 304 }
 305
 306 struct value *
 307 libunwind_frame_prev_register (struct frame_info *this_frame,
 308                                void **this_cache, int regnum)
 309 {
 310   struct libunwind_frame_cache *cache =
 311     libunwind_frame_cache (this_frame, this_cache);
 312   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 313
 314   void *ptr;
 315   unw_cursor_t *c;
 316   unw_save_loc_t sl;
 317   int i, ret;
 318   unw_word_t intval;
 319   unw_fpreg_t fpval;
 320   unw_regnum_t uw_regnum;
 321   struct libunwind_descr *descr;
 322   struct value *val = NULL;
 323
 324   if (cache == NULL)
 325     return frame_unwind_got_constant (this_frame, regnum, 0);
 326
 327   /* Convert from gdb register number to libunwind register number.  */
 328   descr = libunwind_descr (get_frame_arch (this_frame));
 329   uw_regnum = descr->gdb2uw (regnum);
 330
 331   gdb_assert (regnum >= 0);
 332
 333   if (!target_has_registers)
 334     error (_("No registers."));
 335
 336   if (uw_regnum < 0)
 337     return frame_unwind_got_constant (this_frame, regnum, 0);
 338
 339   if (unw_get_saveloc_p (&cache->cursor, uw_regnum, &sl) < 0)
 340     return frame_unwind_got_constant (this_frame, regnum, 0);
 341
 342   switch (sl.type)
 343     {
 344     case UNW_SLT_MEMORY:
 345       val = frame_unwind_got_memory (this_frame, regnum, sl.u.addr);
 346       break;
 347
 348     case UNW_SLT_REG:
 349       val = frame_unwind_got_register (this_frame, regnum,
 350                                        descr->uw2gdb (sl.u.regnum));
 351       break;
 352     case UNW_SLT_NONE:
 353       {
 354         /* The register is not stored at a specific memory address nor
 355            inside another register.  So use libunwind to fetch the register
 356            value for us, and create a constant value with the result.  */
 357         if (descr->is_fpreg (uw_regnum))
 358           {
 359             ret = unw_get_fpreg_p (&cache->cursor, uw_regnum, &fpval);
 360             if (ret < 0)
 361               return frame_unwind_got_constant (this_frame, regnum, 0);
 362             val = frame_unwind_got_bytes (this_frame, regnum,
 363                                           (gdb_byte *) &fpval);
 364           }
 365         else
 366           {
 367             ret = unw_get_reg_p (&cache->cursor, uw_regnum, &intval);
 368             if (ret < 0)
 369               return frame_unwind_got_constant (this_frame, regnum, 0);
 370             val = frame_unwind_got_constant (this_frame, regnum, intval);
 371           }
 372         break;
 373       }
 374     }
 375
 376   return val;
 377 }
 378
 379 CORE_ADDR
 380 libunwind_frame_base_address (struct frame_info *this_frame, void **this_cache)
 381 {
 382   struct libunwind_frame_cache *cache =
 383     libunwind_frame_cache (this_frame, this_cache);
 384
 385   if (cache == NULL)
 386     return (CORE_ADDR)NULL;
 387   return cache->base;
 388 }
 389
 390 /* The following is a glue routine to call the libunwind unwind table
 391    search function to get unwind information for a specified ip address.  */
 392 int
 393 libunwind_search_unwind_table (void *as, long ip, void *di,
 394                                void *pi, int need_unwind_info, void *args)
 395 {
 396   return unw_search_unwind_table_p (*(unw_addr_space_t *)as, (unw_word_t )ip,
 397                                     di, pi, need_unwind_info, args);
 398 }
 399
 400 /* Verify if we are in a sigtramp frame and we can use libunwind to unwind.  */
 401 int
 402 libunwind_sigtramp_frame_sniffer (const struct frame_unwind *self,
 403                                   struct frame_info *this_frame,
 404                                   void **this_cache)
 405 {
 406   unw_cursor_t cursor;
 407   unw_accessors_t *acc;
 408   unw_addr_space_t as;
 409   struct libunwind_descr *descr;
 410   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 411   int i, ret;
 412
 413   /* To test for libunwind unwind support, initialize a cursor to the
 414      current frame and try to back up.  We use this same method when
 415      setting up the frame cache (see libunwind_frame_cache()).  If
 416      libunwind returns success for this operation, it means that it
 417      has found sufficient libunwind unwinding information to do
 418      so.  */
 419
 420   descr = libunwind_descr (gdbarch);
 421   acc = descr->accessors;
 422   as =  unw_create_addr_space_p (acc,
 423                                  gdbarch_byte_order (gdbarch)
 424                                  == BFD_ENDIAN_BIG
 425                                  ? __BIG_ENDIAN
 426                                  : __LITTLE_ENDIAN);
 427
 428   ret = unw_init_remote_p (&cursor, as, this_frame);
 429
 430   if (ret < 0)
 431     {
 432       unw_destroy_addr_space_p (as);
 433       return 0;
 434     }
 435
 436   /* Check to see if we are in a signal frame.  */
 437   ret = unw_is_signal_frame_p (&cursor);
 438   unw_destroy_addr_space_p (as);
 439   if (ret > 0)
 440     return 1;
 441
 442   return 0;
 443 }
 444
 445 /* The following routine is for accessing special registers of the top frame.
 446    A special set of accessors must be given that work without frame info.
 447    This is used by ia64 to access the rse registers r32-r127.  While they
 448    are usually located at BOF, this is not always true and only the libunwind
 449    info can decipher where they actually are.  */
 450 int
 451 libunwind_get_reg_special (struct gdbarch *gdbarch, struct regcache *regcache,
 452                            int regnum, void *buf)
 453 {
 454   unw_cursor_t cursor;
 455   unw_accessors_t *acc;
 456   unw_addr_space_t as;
 457   struct libunwind_descr *descr;
 458   int ret;
 459   unw_regnum_t uw_regnum;
 460   unw_word_t intval;
 461   unw_fpreg_t fpval;
 462   void *ptr;
 463
 464
 465   descr = libunwind_descr (gdbarch);
 466   acc = descr->special_accessors;
 467   as =  unw_create_addr_space_p (acc,
 468                                  gdbarch_byte_order (gdbarch)
 469                                  == BFD_ENDIAN_BIG
 470                                  ? __BIG_ENDIAN
 471                                  : __LITTLE_ENDIAN);
 472
 473   ret = unw_init_remote_p (&cursor, as, regcache);
 474   if (ret < 0)
 475     {
 476       unw_destroy_addr_space_p (as);
 477       return -1;
 478     }
 479
 480   uw_regnum = descr->gdb2uw (regnum);
 481
 482   if (descr->is_fpreg (uw_regnum))
 483     {
 484       ret = unw_get_fpreg_p (&cursor, uw_regnum, &fpval);
 485       ptr = &fpval;
 486     }
 487   else
 488     {
 489       ret = unw_get_reg_p (&cursor, uw_regnum, &intval);
 490       ptr = &intval;
 491     }
 492
 493   unw_destroy_addr_space_p (as);
 494
 495   if (ret < 0)
 496     return -1;
 497
 498   if (buf)
 499     memcpy (buf, ptr, register_size (gdbarch, regnum));
 500
 501   return 0;
 502 }
 503
 504 static int
 505 libunwind_load (void)
 506 {
 507   void *handle;
 508
 509   handle = dlopen (LIBUNWIND_SO, RTLD_NOW);
 510   if (handle == NULL)
 511     {
 512       fprintf_unfiltered (gdb_stderr, _("[GDB failed to load %s: %s]\n"),
 513                           LIBUNWIND_SO, dlerror ());
 514       return 0;
 515     }
 516
 517   /* Initialize pointers to the dynamic library functions we will use.  */
 518
 519   unw_get_reg_p = dlsym (handle, get_reg_name);
 520   if (unw_get_reg_p == NULL)
 521     return 0;
 522
 523   unw_get_fpreg_p = dlsym (handle, get_fpreg_name);
 524   if (unw_get_fpreg_p == NULL)
 525     return 0;
 526
 527   unw_get_saveloc_p = dlsym (handle, get_saveloc_name);
 528   if (unw_get_saveloc_p == NULL)
 529     return 0;
 530
 531   unw_is_signal_frame_p = dlsym (handle, is_signal_frame_name);
 532   if (unw_is_signal_frame_p == NULL)
 533     return 0;
 534
 535   unw_step_p = dlsym (handle, step_name);
 536   if (unw_step_p == NULL)
 537     return 0;
 538
 539   unw_init_remote_p = dlsym (handle, init_remote_name);
 540   if (unw_init_remote_p == NULL)
 541     return 0;
 542
 543   unw_create_addr_space_p = dlsym (handle, create_addr_space_name);
 544   if (unw_create_addr_space_p == NULL)
 545     return 0;
 546
 547   unw_destroy_addr_space_p = dlsym (handle, destroy_addr_space_name);
 548   if (unw_destroy_addr_space_p == NULL)
 549     return 0;
 550
 551   unw_search_unwind_table_p = dlsym (handle, search_unwind_table_name);
 552   if (unw_search_unwind_table_p == NULL)
 553     return 0;
 554
 555   unw_find_dyn_list_p = dlsym (handle, find_dyn_list_name);
 556   if (unw_find_dyn_list_p == NULL)
 557     return 0;
 558
 559   return 1;
 560 }
 561
 562 int
 563 libunwind_is_initialized (void)
 564 {
 565   return libunwind_initialized;
 566 }
 567
 568 /* Provide a prototype to silence -Wmissing-prototypes.  */
 569 void _initialize_libunwind_frame (void);
 570
 571 void
 572 _initialize_libunwind_frame (void)
 573 {
 574   libunwind_descr_handle
 575     = gdbarch_data_register_post_init (libunwind_descr_init);
 576
 577   libunwind_initialized = libunwind_load ();
 578 }