gdb/libunwind-frame.c

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