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