gdb/libunwind-frame.c

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