gdb/libunwind-frame.c

   1 /* Frame unwinder for frames using the libunwind library.
   2
   3    Copyright (C) 2003, 2004, 2006, 2007, 2008 Free Software Foundation, Inc.
   4
   5    Written by Jeff Johnston, contributed by Red Hat Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23
  24 #include "inferior.h"
  25 #include "frame.h"
  26 #include "frame-base.h"
  27 #include "frame-unwind.h"
  28 #include "gdbcore.h"
  29 #include "gdbtypes.h"
  30 #include "symtab.h"
  31 #include "objfiles.h"
  32 #include "regcache.h"
  33
  34 #include <dlfcn.h>
  35
  36 #include "gdb_assert.h"
  37 #include "gdb_string.h"
  38
  39 #include "libunwind-frame.h"
  40
  41 #include "complaints.h"
  42
  43 static int libunwind_initialized;
  44 static struct gdbarch_data *libunwind_descr_handle;
  45
  46 /* Required function pointers from libunwind.  */
  47 static int (*unw_get_reg_p) (unw_cursor_t *, unw_regnum_t, unw_word_t *);
  48 static int (*unw_get_fpreg_p) (unw_cursor_t *, unw_regnum_t, unw_fpreg_t *);
  49 static int (*unw_get_saveloc_p) (unw_cursor_t *, unw_regnum_t, unw_save_loc_t *);
  50 static int (*unw_is_signal_frame_p) (unw_cursor_t *);
  51 static int (*unw_step_p) (unw_cursor_t *);
  52 static int (*unw_init_remote_p) (unw_cursor_t *, unw_addr_space_t, void *);
  53 static unw_addr_space_t (*unw_create_addr_space_p) (unw_accessors_t *, int);
  54 static void (*unw_destroy_addr_space_p) (unw_addr_space_t);
  55 static int (*unw_search_unwind_table_p) (unw_addr_space_t, unw_word_t, unw_dyn_info_t *,
  56                                          unw_proc_info_t *, int, void *);
  57 static unw_word_t (*unw_find_dyn_list_p) (unw_addr_space_t, unw_dyn_info_t *,
  58                                           void *);
  59
  60
  61 struct libunwind_frame_cache
  62 {
  63   CORE_ADDR base;
  64   CORE_ADDR func_addr;
  65   unw_cursor_t cursor;
  66   unw_addr_space_t as;
  67 };
  68
  69 /* We need to qualify the function names with a platform-specific prefix
  70    to match the names used by the libunwind library.  The UNW_OBJ macro is
  71    provided by the libunwind.h header file.  */
  72 #define STRINGIFY2(name)        #name
  73 #define STRINGIFY(name)         STRINGIFY2(name)
  74
  75 #ifndef LIBUNWIND_SO
  76 /* Use the stable ABI major version number.  `libunwind-ia64.so' is a link time
  77    only library, not a runtime one.  */
  78 #define LIBUNWIND_SO "libunwind-" STRINGIFY(UNW_TARGET) ".so.7"
  79 #endif
  80
  81 static char *get_reg_name = STRINGIFY(UNW_OBJ(get_reg));
  82 static char *get_fpreg_name = STRINGIFY(UNW_OBJ(get_fpreg));
  83 static char *get_saveloc_name = STRINGIFY(UNW_OBJ(get_save_loc));
  84 static char *is_signal_frame_name = STRINGIFY(UNW_OBJ(is_signal_frame));
  85 static char *step_name = STRINGIFY(UNW_OBJ(step));
  86 static char *init_remote_name = STRINGIFY(UNW_OBJ(init_remote));
  87 static char *create_addr_space_name = STRINGIFY(UNW_OBJ(create_addr_space));
  88 static char *destroy_addr_space_name = STRINGIFY(UNW_OBJ(destroy_addr_space));
  89 static char *search_unwind_table_name = STRINGIFY(UNW_OBJ(search_unwind_table));
  90 static char *find_dyn_list_name = STRINGIFY(UNW_OBJ(find_dyn_list));
  91
  92 static struct libunwind_descr *
  93 libunwind_descr (struct gdbarch *gdbarch)
  94 {
  95   return gdbarch_data (gdbarch, libunwind_descr_handle);
  96 }
  97
  98 static void *
  99 libunwind_descr_init (struct gdbarch *gdbarch)
 100 {
 101   struct libunwind_descr *descr = GDBARCH_OBSTACK_ZALLOC (gdbarch,
 102                                                           struct libunwind_descr);
 103   return descr;
 104 }
 105
 106 void
 107 libunwind_frame_set_descr (struct gdbarch *gdbarch, struct libunwind_descr *descr)
 108 {
 109   struct libunwind_descr *arch_descr;
 110
 111   gdb_assert (gdbarch != NULL);
 112
 113   arch_descr = gdbarch_data (gdbarch, libunwind_descr_handle);
 114
 115   if (arch_descr == NULL)
 116     {
 117       /* First time here.  Must initialize data area.  */
 118       arch_descr = libunwind_descr_init (gdbarch);
 119       deprecated_set_gdbarch_data (gdbarch, libunwind_descr_handle, arch_descr);
 120     }
 121
 122   /* Copy new descriptor info into arch descriptor.  */
 123   arch_descr->gdb2uw = descr->gdb2uw;
 124   arch_descr->uw2gdb = descr->uw2gdb;
 125   arch_descr->is_fpreg = descr->is_fpreg;
 126   arch_descr->accessors = descr->accessors;
 127   arch_descr->special_accessors = descr->special_accessors;
 128 }
 129
 130 static struct libunwind_frame_cache *
 131 libunwind_frame_cache (struct frame_info *this_frame, void **this_cache)
 132 {
 133   unw_accessors_t *acc;
 134   unw_addr_space_t as;
 135   unw_word_t fp;
 136   unw_regnum_t uw_sp_regnum;
 137   struct libunwind_frame_cache *cache;
 138   struct libunwind_descr *descr;
 139   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 140   int i, ret;
 141
 142   if (*this_cache)
 143     return *this_cache;
 144
 145   /* Allocate a new cache.  */
 146   cache = FRAME_OBSTACK_ZALLOC (struct libunwind_frame_cache);
 147
 148   /* We can assume we are unwinding a normal frame.  Even if this is
 149      for a signal trampoline, ia64 signal "trampolines" use a normal
 150      subroutine call to start the signal handler.  */
 151   cache->func_addr = get_frame_func (this_frame);
 152   if (cache->func_addr == 0
 153       && get_next_frame (this_frame)
 154       && get_frame_type (get_next_frame (this_frame)) == NORMAL_FRAME)
 155     return NULL;
 156
 157   /* Get a libunwind cursor to the previous frame.
 158
 159      We do this by initializing a cursor.  Libunwind treats a new cursor
 160      as the top of stack and will get the current register set via the
 161      libunwind register accessor.  Now, we provide the platform-specific
 162      accessors and we set up the register accessor to use the frame
 163      register unwinding interfaces so that we properly get the registers
 164      for the current frame rather than the top.  We then use the unw_step
 165      function to move the libunwind cursor back one frame.  We can later
 166      use this cursor to find previous registers via the unw_get_reg
 167      interface which will invoke libunwind's special logic.  */
 168   descr = libunwind_descr (gdbarch);
 169   acc = descr->accessors;
 170   as =  unw_create_addr_space_p (acc,
 171                                  gdbarch_byte_order (gdbarch)
 172                                  == BFD_ENDIAN_BIG
 173                                  ? __BIG_ENDIAN
 174                                  : __LITTLE_ENDIAN);
 175
 176   unw_init_remote_p (&cache->cursor, as, this_frame);
 177   if (unw_step_p (&cache->cursor) < 0)
 178     {
 179       unw_destroy_addr_space_p (as);
 180       return NULL;
 181     }
 182
 183   /* To get base address, get sp from previous frame.  */
 184   uw_sp_regnum = descr->gdb2uw (gdbarch_sp_regnum (gdbarch));
 185   ret = unw_get_reg_p (&cache->cursor, uw_sp_regnum, &fp);
 186   if (ret < 0)
 187     {
 188       unw_destroy_addr_space_p (as);
 189       error (_("Can't get libunwind sp register."));
 190     }
 191
 192   cache->base = (CORE_ADDR)fp;
 193   cache->as = as;
 194
 195   *this_cache = cache;
 196   return cache;
 197 }
 198
 199 void
 200 libunwind_frame_dealloc_cache (struct frame_info *self, void *this_cache)
 201 {
 202   struct libunwind_frame_cache *cache = this_cache;
 203   if (cache->as)
 204     unw_destroy_addr_space_p (cache->as);
 205 }
 206
 207 unw_word_t
 208 libunwind_find_dyn_list (unw_addr_space_t as, unw_dyn_info_t *di, void *arg)
 209 {
 210   return unw_find_dyn_list_p (as, di, arg);
 211 }
 212
 213 static const struct frame_unwind libunwind_frame_unwind =
 214 {
 215   NORMAL_FRAME,
 216   libunwind_frame_this_id,
 217   libunwind_frame_prev_register,
 218   NULL,
 219   libunwind_frame_sniffer,
 220   libunwind_frame_dealloc_cache,
 221 };
 222
 223 /* Verify if there is sufficient libunwind information for the frame to use
 224    libunwind frame unwinding.  */
 225 int
 226 libunwind_frame_sniffer (const struct frame_unwind *self,
 227                          struct frame_info *this_frame, void **this_cache)
 228 {
 229   unw_cursor_t cursor;
 230   unw_accessors_t *acc;
 231   unw_addr_space_t as;
 232   struct libunwind_descr *descr;
 233   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 234   int i, ret;
 235
 236   /* To test for libunwind unwind support, initialize a cursor to
 237      the current frame and try to back up.  We use this same method
 238      when setting up the frame cache (see libunwind_frame_cache()).
 239      If libunwind returns success for this operation, it means that
 240      it has found sufficient libunwind unwinding information to do so.  */
 241
 242   descr = libunwind_descr (gdbarch);
 243   acc = descr->accessors;
 244   as =  unw_create_addr_space_p (acc,
 245                                  gdbarch_byte_order (gdbarch)
 246                                  == BFD_ENDIAN_BIG
 247                                  ? __BIG_ENDIAN
 248                                  : __LITTLE_ENDIAN);
 249
 250   ret = unw_init_remote_p (&cursor, as, this_frame);
 251
 252   if (ret < 0)
 253     {
 254       unw_destroy_addr_space_p (as);
 255       return 0;
 256     }
 257
 258
 259   /* Check to see if we have libunwind info by checking if we are in a
 260      signal frame.  If it doesn't return an error, we have libunwind info
 261      and can use libunwind.  */
 262   ret = unw_is_signal_frame_p (&cursor);
 263   unw_destroy_addr_space_p (as);
 264
 265   if (ret < 0)
 266     return 0;
 267
 268   return 1;
 269 }
 270
 271 void
 272 libunwind_frame_this_id (struct frame_info *this_frame, void **this_cache,
 273                          struct frame_id *this_id)
 274 {
 275   struct libunwind_frame_cache *cache =
 276     libunwind_frame_cache (this_frame, this_cache);
 277
 278   if (cache != NULL)
 279     (*this_id) = frame_id_build (cache->base, cache->func_addr);
 280   else
 281     (*this_id) = null_frame_id;
 282 }
 283
 284 struct value *
 285 libunwind_frame_prev_register (struct frame_info *this_frame,
 286                                void **this_cache, int regnum)
 287 {
 288   struct libunwind_frame_cache *cache =
 289     libunwind_frame_cache (this_frame, this_cache);
 290   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 291
 292   void *ptr;
 293   unw_cursor_t *c;
 294   unw_save_loc_t sl;
 295   int i, ret;
 296   unw_word_t intval;
 297   unw_fpreg_t fpval;
 298   unw_regnum_t uw_regnum;
 299   struct libunwind_descr *descr;
 300   struct value *val = NULL;
 301
 302   if (cache == NULL)
 303     return frame_unwind_got_constant (this_frame, regnum, 0);
 304
 305   /* Convert from gdb register number to libunwind register number.  */
 306   descr = libunwind_descr (get_frame_arch (this_frame));
 307   uw_regnum = descr->gdb2uw (regnum);
 308
 309   gdb_assert (regnum >= 0);
 310
 311   if (!target_has_registers)
 312     error (_("No registers."));
 313
 314   if (uw_regnum < 0)
 315     return frame_unwind_got_constant (this_frame, regnum, 0);
 316
 317   if (unw_get_saveloc_p (&cache->cursor, uw_regnum, &sl) < 0)
 318     return frame_unwind_got_constant (this_frame, regnum, 0);
 319
 320   switch (sl.type)
 321     {
 322     case UNW_SLT_MEMORY:
 323       val = frame_unwind_got_memory (this_frame, regnum, sl.u.addr);
 324       break;
 325
 326     case UNW_SLT_REG:
 327       val = frame_unwind_got_register (this_frame, regnum,
 328                                        descr->uw2gdb (sl.u.regnum));
 329       break;
 330     case UNW_SLT_NONE:
 331       {
 332         /* The register is not stored at a specific memory address nor
 333            inside another register.  So use libunwind to fetch the register
 334            value for us, and create a constant value with the result.  */
 335         if (descr->is_fpreg (uw_regnum))
 336           {
 337             ret = unw_get_fpreg_p (&cache->cursor, uw_regnum, &fpval);
 338             if (ret < 0)
 339               return frame_unwind_got_constant (this_frame, regnum, 0);
 340             val = frame_unwind_got_bytes (this_frame, regnum,
 341                                           (gdb_byte *) &fpval);
 342           }
 343         else
 344           {
 345             ret = unw_get_reg_p (&cache->cursor, uw_regnum, &intval);
 346             if (ret < 0)
 347               return frame_unwind_got_constant (this_frame, regnum, 0);
 348             val = frame_unwind_got_constant (this_frame, regnum, intval);
 349           }
 350         set_value_optimized_out (val, 1);
 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 }