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 /* Required function pointers from libunwind. */ 49 static int (*unw_get_reg_p) (unw_cursor_t *, unw_regnum_t, unw_word_t *); 50 static int (*unw_get_fpreg_p) (unw_cursor_t *, unw_regnum_t, unw_fpreg_t *); 51 static int (*unw_get_saveloc_p) (unw_cursor_t *, unw_regnum_t, unw_save_loc_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 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 }; 67 68 /* We need to qualify the function names with a platform-specific prefix to match 69 the names used by the libunwind library. The UNW_OBJ macro is provided by the 70 libunwind.h header file. */ 71 #define STRINGIFY2(name) #name 72 #define STRINGIFY(name) STRINGIFY2(name) 73 74 #ifndef LIBUNWIND_SO 75 #define LIBUNWIND_SO "libunwind-" STRINGIFY(UNW_TARGET) ".so" 76 #endif 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 } 390