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