contrib/gdb-6.2.1/gdb/libunwind-frame.c

   1 /* Frame unwinder for frames using the libunwind library.
   2
   3    Copyright 2003, 2004 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 2 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, write to the Free Software
  21    Foundation, Inc., 59 Temple Place - Suite 330,
  22    Boston, MA 02111-1307, USA.  */
  23
  24 #include "defs.h"
  25
  26 #include "inferior.h"
  27 #include "frame.h"
  28 #include "frame-base.h"
  29 #include "frame-unwind.h"
  30 #include "gdbcore.h"
  31 #include "gdbtypes.h"
  32 #include "symtab.h"
  33 #include "objfiles.h"
  34 #include "regcache.h"
  35
  36 #include <dlfcn.h>
  37
  38 #include "gdb_assert.h"
  39 #include "gdb_string.h"
  40
  41 #include "libunwind-frame.h"
  42
  43 #include "complaints.h"
  44
  45 static int libunwind_initialized;
  46 static struct gdbarch_data *libunwind_descr_handle;
  47
  48 #ifndef LIBUNWIND_SO
  49 #define LIBUNWIND_SO "libunwind.so"
  50 #endif
  51
  52 /* Required function pointers from libunwind.  */
  53 static int (*unw_get_reg_p) (unw_cursor_t *, unw_regnum_t, unw_word_t *);
  54 static int (*unw_get_fpreg_p) (unw_cursor_t *, unw_regnum_t, unw_fpreg_t *);
  55 static int (*unw_get_saveloc_p) (unw_cursor_t *, unw_regnum_t, unw_save_loc_t *);
  56 static int (*unw_step_p) (unw_cursor_t *);
  57 static int (*unw_init_remote_p) (unw_cursor_t *, unw_addr_space_t, void *);
  58 static unw_addr_space_t (*unw_create_addr_space_p) (unw_accessors_t *, int);
  59 static int (*unw_search_unwind_table_p) (unw_addr_space_t, unw_word_t, unw_dyn_info_t *,
  60                                          unw_proc_info_t *, int, void *);
  61 static unw_word_t (*unw_find_dyn_list_p) (unw_addr_space_t, unw_dyn_info_t *,
  62                                           void *);
  63
  64
  65 struct libunwind_frame_cache
  66 {
  67   CORE_ADDR base;
  68   CORE_ADDR func_addr;
  69   unw_cursor_t cursor;
  70 };
  71
  72 /* We need to qualify the function names with a platform-specific prefix to match
  73    the names used by the libunwind library.  The UNW_OBJ macro is provided by the
  74    libunwind.h header file.  */
  75 #define STRINGIFY2(name)        #name
  76 #define STRINGIFY(name)         STRINGIFY2(name)
  77
  78 static char *get_reg_name = STRINGIFY(UNW_OBJ(get_reg));
  79 static char *get_fpreg_name = STRINGIFY(UNW_OBJ(get_fpreg));
  80 static char *get_saveloc_name = STRINGIFY(UNW_OBJ(get_save_loc));
  81 static char *step_name = STRINGIFY(UNW_OBJ(step));
  82 static char *init_remote_name = STRINGIFY(UNW_OBJ(init_remote));
  83 static char *create_addr_space_name = STRINGIFY(UNW_OBJ(create_addr_space));
  84 static char *search_unwind_table_name = STRINGIFY(UNW_OBJ(search_unwind_table));
  85 static char *find_dyn_list_name = STRINGIFY(UNW_OBJ(find_dyn_list));
  86
  87 static struct libunwind_descr *
  88 libunwind_descr (struct gdbarch *gdbarch)
  89 {
  90   return gdbarch_data (gdbarch, libunwind_descr_handle);
  91 }
  92
  93 static void *
  94 libunwind_descr_init (struct gdbarch *gdbarch)
  95 {
  96   struct libunwind_descr *descr = GDBARCH_OBSTACK_ZALLOC (gdbarch,
  97                                                           struct libunwind_descr);
  98   return descr;
  99 }
 100
 101 void
 102 libunwind_frame_set_descr (struct gdbarch *gdbarch, struct libunwind_descr *descr)
 103 {
 104   struct libunwind_descr *arch_descr;
 105
 106   gdb_assert (gdbarch != NULL);
 107
 108   arch_descr = gdbarch_data (gdbarch, libunwind_descr_handle);
 109
 110   if (arch_descr == NULL)
 111     {
 112       /* First time here.  Must initialize data area.  */
 113       arch_descr = libunwind_descr_init (gdbarch);
 114       deprecated_set_gdbarch_data (gdbarch, libunwind_descr_handle, arch_descr);
 115     }
 116
 117   /* Copy new descriptor info into arch descriptor.  */
 118   arch_descr->gdb2uw = descr->gdb2uw;
 119   arch_descr->uw2gdb = descr->uw2gdb;
 120   arch_descr->is_fpreg = descr->is_fpreg;
 121   arch_descr->accessors = descr->accessors;
 122 }
 123
 124 static struct libunwind_frame_cache *
 125 libunwind_frame_cache (struct frame_info *next_frame, void **this_cache)
 126 {
 127   unw_accessors_t *acc;
 128   unw_addr_space_t as;
 129   unw_word_t fp;
 130   unw_regnum_t uw_sp_regnum;
 131   struct libunwind_frame_cache *cache;
 132   struct libunwind_descr *descr;
 133   int i, ret;
 134
 135   if (*this_cache)
 136     return *this_cache;
 137
 138   /* Allocate a new cache.  */
 139   cache = FRAME_OBSTACK_ZALLOC (struct libunwind_frame_cache);
 140
 141   cache->func_addr = frame_func_unwind (next_frame);
 142
 143   /* Get a libunwind cursor to the previous frame.  We do this by initializing
 144      a cursor.  Libunwind treats a new cursor as the top of stack and will get
 145      the current register set via the libunwind register accessor.  Now, we
 146      provide the platform-specific accessors and we set up the register accessor to use
 147      the frame register unwinding interfaces so that we properly get the registers for
 148      the current frame rather than the top.  We then use the  unw_step function to
 149      move the libunwind cursor back one frame.  We can later use this cursor to find previous
 150      registers via the unw_get_reg interface which will invoke libunwind's special logic.  */
 151   descr = libunwind_descr (get_frame_arch (next_frame));
 152   acc = descr->accessors;
 153   as =  unw_create_addr_space_p (acc,
 154                                  TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
 155                                  ? __BIG_ENDIAN
 156                                  : __LITTLE_ENDIAN);
 157
 158   unw_init_remote_p (&cache->cursor, as, next_frame);
 159   unw_step_p (&cache->cursor);
 160
 161   /* To get base address, get sp from previous frame.  */
 162   uw_sp_regnum = descr->gdb2uw (SP_REGNUM);
 163   ret = unw_get_reg_p (&cache->cursor, uw_sp_regnum, &fp);
 164   if (ret < 0)
 165     error ("Can't get libunwind sp register.");
 166
 167   cache->base = (CORE_ADDR)fp;
 168
 169   *this_cache = cache;
 170   return cache;
 171 }
 172
 173 unw_word_t
 174 libunwind_find_dyn_list (unw_addr_space_t as, unw_dyn_info_t *di, void *arg)
 175 {
 176   return unw_find_dyn_list_p (as, di, arg);
 177 }
 178
 179 static const struct frame_unwind libunwind_frame_unwind =
 180 {
 181   NORMAL_FRAME,
 182   libunwind_frame_this_id,
 183   libunwind_frame_prev_register
 184 };
 185
 186 /* Verify if there is sufficient libunwind information for the frame to use
 187    libunwind frame unwinding.  */
 188 const struct frame_unwind *
 189 libunwind_frame_sniffer (struct frame_info *next_frame)
 190 {
 191   unw_cursor_t cursor;
 192   unw_accessors_t *acc;
 193   unw_addr_space_t as;
 194   struct libunwind_descr *descr;
 195   int i, ret;
 196
 197   /* To test for libunwind unwind support, initialize a cursor to the current frame and try to back
 198      up.  We use this same method when setting up the frame cache (see libunwind_frame_cache()).
 199      If libunwind returns success for this operation, it means that it has found sufficient
 200      libunwind unwinding information to do so.  */
 201
 202   descr = libunwind_descr (get_frame_arch (next_frame));
 203   acc = descr->accessors;
 204   as =  unw_create_addr_space_p (acc,
 205                                  TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
 206                                  ? __BIG_ENDIAN
 207                                  : __LITTLE_ENDIAN);
 208
 209   ret = unw_init_remote_p (&cursor, as, next_frame);
 210
 211   if (ret >= 0)
 212     ret = unw_step_p (&cursor);
 213
 214   if (ret < 0)
 215     return NULL;
 216
 217   return &libunwind_frame_unwind;
 218 }
 219
 220 void
 221 libunwind_frame_this_id (struct frame_info *next_frame, void **this_cache,
 222                       struct frame_id *this_id)
 223 {
 224   struct libunwind_frame_cache *cache =
 225     libunwind_frame_cache (next_frame, this_cache);
 226
 227   (*this_id) = frame_id_build (cache->base, cache->func_addr);
 228 }
 229
 230 void
 231 libunwind_frame_prev_register (struct frame_info *next_frame, void **this_cache,
 232                                int regnum, int *optimizedp,
 233                                enum lval_type *lvalp, CORE_ADDR *addrp,
 234                                int *realnump, void *valuep)
 235 {
 236   struct libunwind_frame_cache *cache =
 237     libunwind_frame_cache (next_frame, this_cache);
 238
 239   void *ptr;
 240   unw_cursor_t *c;
 241   unw_save_loc_t sl;
 242   int i, ret;
 243   unw_word_t intval;
 244   unw_fpreg_t fpval;
 245   unw_regnum_t uw_regnum;
 246   struct libunwind_descr *descr;
 247
 248   /* Convert from gdb register number to libunwind register number.  */
 249   descr = libunwind_descr (get_frame_arch (next_frame));
 250   uw_regnum = descr->gdb2uw (regnum);
 251
 252   gdb_assert (regnum >= 0);
 253
 254   if (!target_has_registers)
 255     error ("No registers.");
 256
 257   *optimizedp = 0;
 258   *addrp = 0;
 259   *lvalp = not_lval;
 260   *realnump = -1;
 261
 262   if (valuep)
 263     memset (valuep, 0, register_size (current_gdbarch, regnum));
 264
 265   if (uw_regnum < 0)
 266     return;
 267
 268   /* To get the previous register, we use the libunwind register APIs with
 269      the cursor we have already pushed back to the previous frame.  */
 270
 271   if (descr->is_fpreg (uw_regnum))
 272     {
 273       ret = unw_get_fpreg_p (&cache->cursor, uw_regnum, &fpval);
 274       ptr = &fpval;
 275     }
 276   else
 277     {
 278       ret = unw_get_reg_p (&cache->cursor, uw_regnum, &intval);
 279       ptr = &intval;
 280     }
 281
 282   if (ret < 0)
 283     return;
 284
 285   if (valuep)
 286     memcpy (valuep, ptr, register_size (current_gdbarch, regnum));
 287
 288   if (unw_get_saveloc_p (&cache->cursor, uw_regnum, &sl) < 0)
 289     return;
 290
 291   switch (sl.type)
 292     {
 293     case UNW_SLT_NONE:
 294       *optimizedp = 1;
 295       break;
 296
 297     case UNW_SLT_MEMORY:
 298       *lvalp = lval_memory;
 299       *addrp = sl.u.addr;
 300       break;
 301
 302     case UNW_SLT_REG:
 303       *lvalp = lval_register;
 304       *realnump = regnum;
 305       break;
 306     }
 307 }
 308
 309 CORE_ADDR
 310 libunwind_frame_base_address (struct frame_info *next_frame, void **this_cache)
 311 {
 312   struct libunwind_frame_cache *cache =
 313     libunwind_frame_cache (next_frame, this_cache);
 314
 315   return cache->base;
 316 }
 317
 318 /* The following is a glue routine to call the libunwind unwind table
 319    search function to get unwind information for a specified ip address.  */
 320 int
 321 libunwind_search_unwind_table (void *as, long ip, void *di,
 322                                void *pi, int need_unwind_info, void *args)
 323 {
 324   return unw_search_unwind_table_p (*(unw_addr_space_t *)as, (unw_word_t )ip,
 325                                     di, pi, need_unwind_info, args);
 326 }
 327
 328 static int
 329 libunwind_load (void)
 330 {
 331   void *handle;
 332
 333   handle = dlopen (LIBUNWIND_SO, RTLD_NOW);
 334   if (handle == NULL)
 335     return 0;
 336
 337   /* Initialize pointers to the dynamic library functions we will use.  */
 338
 339   unw_get_reg_p = dlsym (handle, get_reg_name);
 340   if (unw_get_reg_p == NULL)
 341     return 0;
 342
 343   unw_get_fpreg_p = dlsym (handle, get_fpreg_name);
 344   if (unw_get_fpreg_p == NULL)
 345     return 0;
 346
 347   unw_get_saveloc_p = dlsym (handle, get_saveloc_name);
 348   if (unw_get_saveloc_p == NULL)
 349     return 0;
 350
 351   unw_step_p = dlsym (handle, step_name);
 352   if (unw_step_p == NULL)
 353     return 0;
 354
 355   unw_init_remote_p = dlsym (handle, init_remote_name);
 356   if (unw_init_remote_p == NULL)
 357     return 0;
 358
 359   unw_create_addr_space_p = dlsym (handle, create_addr_space_name);
 360   if (unw_create_addr_space_p == NULL)
 361     return 0;
 362
 363   unw_search_unwind_table_p = dlsym (handle, search_unwind_table_name);
 364   if (unw_search_unwind_table_p == NULL)
 365     return 0;
 366
 367   unw_find_dyn_list_p = dlsym (handle, find_dyn_list_name);
 368   if (unw_find_dyn_list_p == NULL)
 369     return 0;
 370
 371   return 1;
 372 }
 373
 374 int
 375 libunwind_is_initialized (void)
 376 {
 377   return libunwind_initialized;
 378 }
 379
 380 /* Provide a prototype to silence -Wmissing-prototypes.  */
 381 void _initialize_libunwind_frame (void);
 382
 383 void
 384 _initialize_libunwind_frame (void)
 385 {
 386   libunwind_descr_handle = gdbarch_data_register_post_init (libunwind_descr_init);
 387
 388   libunwind_initialized = libunwind_load ();
 389 }