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         set_value_optimized_out (val, 1);
 352         break;
 353       }
 354     }
 355
 356   return val;
 357 }
 358
 359 CORE_ADDR
 360 libunwind_frame_base_address (struct frame_info *this_frame, void **this_cache)
 361 {
 362   struct libunwind_frame_cache *cache =
 363     libunwind_frame_cache (this_frame, this_cache);
 364
 365   if (cache == NULL)
 366     return (CORE_ADDR)NULL;
 367   return cache->base;
 368 }
 369
 370 /* The following is a glue routine to call the libunwind unwind table
 371    search function to get unwind information for a specified ip address.  */
 372 int
 373 libunwind_search_unwind_table (void *as, long ip, void *di,
 374                                void *pi, int need_unwind_info, void *args)
 375 {
 376   return unw_search_unwind_table_p (*(unw_addr_space_t *)as, (unw_word_t )ip,
 377                                     di, pi, need_unwind_info, args);
 378 }
 379
 380 /* Verify if we are in a sigtramp frame and we can use libunwind to unwind.  */
 381 int
 382 libunwind_sigtramp_frame_sniffer (const struct frame_unwind *self,
 383                                   struct frame_info *this_frame,
 384                                   void **this_cache)
 385 {
 386   unw_cursor_t cursor;
 387   unw_accessors_t *acc;
 388   unw_addr_space_t as;
 389   struct libunwind_descr *descr;
 390   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 391   int i, ret;
 392
 393   /* To test for libunwind unwind support, initialize a cursor to the
 394      current frame and try to back up.  We use this same method when
 395      setting up the frame cache (see libunwind_frame_cache()).  If
 396      libunwind returns success for this operation, it means that it
 397      has found sufficient libunwind unwinding information to do
 398      so.  */
 399
 400   descr = libunwind_descr (gdbarch);
 401   acc = descr->accessors;
 402   as =  unw_create_addr_space_p (acc,
 403                                  gdbarch_byte_order (gdbarch)
 404                                  == BFD_ENDIAN_BIG
 405                                  ? __BIG_ENDIAN
 406                                  : __LITTLE_ENDIAN);
 407
 408   ret = unw_init_remote_p (&cursor, as, this_frame);
 409
 410   if (ret < 0)
 411     {
 412       unw_destroy_addr_space_p (as);
 413       return 0;
 414     }
 415
 416   /* Check to see if we are in a signal frame.  */
 417   ret = unw_is_signal_frame_p (&cursor);
 418   unw_destroy_addr_space_p (as);
 419   if (ret > 0)
 420     return 1;
 421
 422   return 0;
 423 }
 424
 425 /* The following routine is for accessing special registers of the top frame.
 426    A special set of accessors must be given that work without frame info.
 427    This is used by ia64 to access the rse registers r32-r127.  While they
 428    are usually located at BOF, this is not always true and only the libunwind
 429    info can decipher where they actually are.  */
 430 int
 431 libunwind_get_reg_special (struct gdbarch *gdbarch, struct regcache *regcache,
 432                            int regnum, void *buf)
 433 {
 434   unw_cursor_t cursor;
 435   unw_accessors_t *acc;
 436   unw_addr_space_t as;
 437   struct libunwind_descr *descr;
 438   int ret;
 439   unw_regnum_t uw_regnum;
 440   unw_word_t intval;
 441   unw_fpreg_t fpval;
 442   void *ptr;
 443
 444
 445   descr = libunwind_descr (gdbarch);
 446   acc = descr->special_accessors;
 447   as =  unw_create_addr_space_p (acc,
 448                                  gdbarch_byte_order (gdbarch)
 449                                  == BFD_ENDIAN_BIG
 450                                  ? __BIG_ENDIAN
 451                                  : __LITTLE_ENDIAN);
 452
 453   ret = unw_init_remote_p (&cursor, as, regcache);
 454   if (ret < 0)
 455     {
 456       unw_destroy_addr_space_p (as);
 457       return -1;
 458     }
 459
 460   uw_regnum = descr->gdb2uw (regnum);
 461
 462   if (descr->is_fpreg (uw_regnum))
 463     {
 464       ret = unw_get_fpreg_p (&cursor, uw_regnum, &fpval);
 465       ptr = &fpval;
 466     }
 467   else
 468     {
 469       ret = unw_get_reg_p (&cursor, uw_regnum, &intval);
 470       ptr = &intval;
 471     }
 472
 473   unw_destroy_addr_space_p (as);
 474
 475   if (ret < 0)
 476     return -1;
 477
 478   if (buf)
 479     memcpy (buf, ptr, register_size (gdbarch, regnum));
 480
 481   return 0;
 482 }
 483
 484 static int
 485 libunwind_load (void)
 486 {
 487   void *handle;
 488
 489   handle = dlopen (LIBUNWIND_SO, RTLD_NOW);
 490   if (handle == NULL)
 491     return 0;
 492
 493   /* Initialize pointers to the dynamic library functions we will use.  */
 494
 495   unw_get_reg_p = dlsym (handle, get_reg_name);
 496   if (unw_get_reg_p == NULL)
 497     return 0;
 498
 499   unw_get_fpreg_p = dlsym (handle, get_fpreg_name);
 500   if (unw_get_fpreg_p == NULL)
 501     return 0;
 502
 503   unw_get_saveloc_p = dlsym (handle, get_saveloc_name);
 504   if (unw_get_saveloc_p == NULL)
 505     return 0;
 506
 507   unw_is_signal_frame_p = dlsym (handle, is_signal_frame_name);
 508   if (unw_is_signal_frame_p == NULL)
 509     return 0;
 510
 511   unw_step_p = dlsym (handle, step_name);
 512   if (unw_step_p == NULL)
 513     return 0;
 514
 515   unw_init_remote_p = dlsym (handle, init_remote_name);
 516   if (unw_init_remote_p == NULL)
 517     return 0;
 518
 519   unw_create_addr_space_p = dlsym (handle, create_addr_space_name);
 520   if (unw_create_addr_space_p == NULL)
 521     return 0;
 522
 523   unw_destroy_addr_space_p = dlsym (handle, destroy_addr_space_name);
 524   if (unw_destroy_addr_space_p == NULL)
 525     return 0;
 526
 527   unw_search_unwind_table_p = dlsym (handle, search_unwind_table_name);
 528   if (unw_search_unwind_table_p == NULL)
 529     return 0;
 530
 531   unw_find_dyn_list_p = dlsym (handle, find_dyn_list_name);
 532   if (unw_find_dyn_list_p == NULL)
 533     return 0;
 534
 535   return 1;
 536 }
 537
 538 int
 539 libunwind_is_initialized (void)
 540 {
 541   return libunwind_initialized;
 542 }
 543
 544 /* Provide a prototype to silence -Wmissing-prototypes.  */
 545 void _initialize_libunwind_frame (void);
 546
 547 void
 548 _initialize_libunwind_frame (void)
 549 {
 550   libunwind_descr_handle = gdbarch_data_register_post_init (libunwind_descr_init);
 551
 552   libunwind_initialized = libunwind_load ();
 553 }