1 /* Frame unwinder for frames using the libunwind library.
3 Copyright (C) 2003, 2004, 2006, 2007, 2008, 2009, 2010, 2011
4 Free Software Foundation, Inc.
6 Written by Jeff Johnston, contributed by Red Hat Inc.
8 This file is part of GDB.
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.
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.
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/>. */
27 #include "frame-base.h"
28 #include "frame-unwind.h"
37 #include "gdb_assert.h"
38 #include "gdb_string.h"
40 #include "libunwind-frame.h"
42 #include "complaints.h"
44 /* The following two macros are normally defined in <endian.h>.
45 But systems such as ia64-hpux do not provide such header, so
46 we just define them here if not already defined. */
47 #ifndef __LITTLE_ENDIAN
48 #define __LITTLE_ENDIAN 1234
51 #define __BIG_ENDIAN 4321
54 static int libunwind_initialized;
55 static struct gdbarch_data *libunwind_descr_handle;
57 /* Required function pointers from libunwind. */
58 static int (*unw_get_reg_p) (unw_cursor_t *, unw_regnum_t, unw_word_t *);
59 static int (*unw_get_fpreg_p) (unw_cursor_t *, unw_regnum_t, unw_fpreg_t *);
60 static int (*unw_get_saveloc_p) (unw_cursor_t *, unw_regnum_t,
62 static int (*unw_is_signal_frame_p) (unw_cursor_t *);
63 static int (*unw_step_p) (unw_cursor_t *);
64 static int (*unw_init_remote_p) (unw_cursor_t *, unw_addr_space_t, void *);
65 static unw_addr_space_t (*unw_create_addr_space_p) (unw_accessors_t *, int);
66 static void (*unw_destroy_addr_space_p) (unw_addr_space_t);
67 static int (*unw_search_unwind_table_p) (unw_addr_space_t, unw_word_t,
69 unw_proc_info_t *, int, void *);
70 static unw_word_t (*unw_find_dyn_list_p) (unw_addr_space_t, unw_dyn_info_t *,
74 struct libunwind_frame_cache
82 /* We need to qualify the function names with a platform-specific prefix
83 to match the names used by the libunwind library. The UNW_OBJ macro is
84 provided by the libunwind.h header file. */
85 #define STRINGIFY2(name) #name
86 #define STRINGIFY(name) STRINGIFY2(name)
89 /* Use the stable ABI major version number. `libunwind-ia64.so' is a link time
90 only library, not a runtime one. */
91 #define LIBUNWIND_SO "libunwind-" STRINGIFY(UNW_TARGET) ".so.7"
94 static char *get_reg_name = STRINGIFY(UNW_OBJ(get_reg));
95 static char *get_fpreg_name = STRINGIFY(UNW_OBJ(get_fpreg));
96 static char *get_saveloc_name = STRINGIFY(UNW_OBJ(get_save_loc));
97 static char *is_signal_frame_name = STRINGIFY(UNW_OBJ(is_signal_frame));
98 static char *step_name = STRINGIFY(UNW_OBJ(step));
99 static char *init_remote_name = STRINGIFY(UNW_OBJ(init_remote));
100 static char *create_addr_space_name = STRINGIFY(UNW_OBJ(create_addr_space));
101 static char *destroy_addr_space_name = STRINGIFY(UNW_OBJ(destroy_addr_space));
102 static char *search_unwind_table_name
103 = STRINGIFY(UNW_OBJ(search_unwind_table));
104 static char *find_dyn_list_name = STRINGIFY(UNW_OBJ(find_dyn_list));
106 static struct libunwind_descr *
107 libunwind_descr (struct gdbarch *gdbarch)
109 return gdbarch_data (gdbarch, libunwind_descr_handle);
113 libunwind_descr_init (struct gdbarch *gdbarch)
115 struct libunwind_descr *descr
116 = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct libunwind_descr);
122 libunwind_frame_set_descr (struct gdbarch *gdbarch,
123 struct libunwind_descr *descr)
125 struct libunwind_descr *arch_descr;
127 gdb_assert (gdbarch != NULL);
129 arch_descr = gdbarch_data (gdbarch, libunwind_descr_handle);
131 if (arch_descr == NULL)
133 /* First time here. Must initialize data area. */
134 arch_descr = libunwind_descr_init (gdbarch);
135 deprecated_set_gdbarch_data (gdbarch,
136 libunwind_descr_handle, arch_descr);
139 /* Copy new descriptor info into arch descriptor. */
140 arch_descr->gdb2uw = descr->gdb2uw;
141 arch_descr->uw2gdb = descr->uw2gdb;
142 arch_descr->is_fpreg = descr->is_fpreg;
143 arch_descr->accessors = descr->accessors;
144 arch_descr->special_accessors = descr->special_accessors;
147 static struct libunwind_frame_cache *
148 libunwind_frame_cache (struct frame_info *this_frame, void **this_cache)
150 unw_accessors_t *acc;
153 unw_regnum_t uw_sp_regnum;
154 struct libunwind_frame_cache *cache;
155 struct libunwind_descr *descr;
156 struct gdbarch *gdbarch = get_frame_arch (this_frame);
162 /* Allocate a new cache. */
163 cache = FRAME_OBSTACK_ZALLOC (struct libunwind_frame_cache);
165 /* We can assume we are unwinding a normal frame. Even if this is
166 for a signal trampoline, ia64 signal "trampolines" use a normal
167 subroutine call to start the signal handler. */
168 cache->func_addr = get_frame_func (this_frame);
169 if (cache->func_addr == 0
170 && get_next_frame (this_frame)
171 && get_frame_type (get_next_frame (this_frame)) == NORMAL_FRAME)
174 /* Get a libunwind cursor to the previous frame.
176 We do this by initializing a cursor. Libunwind treats a new cursor
177 as the top of stack and will get the current register set via the
178 libunwind register accessor. Now, we provide the platform-specific
179 accessors and we set up the register accessor to use the frame
180 register unwinding interfaces so that we properly get the registers
181 for the current frame rather than the top. We then use the unw_step
182 function to move the libunwind cursor back one frame. We can later
183 use this cursor to find previous registers via the unw_get_reg
184 interface which will invoke libunwind's special logic. */
185 descr = libunwind_descr (gdbarch);
186 acc = descr->accessors;
187 as = unw_create_addr_space_p (acc,
188 gdbarch_byte_order (gdbarch)
193 unw_init_remote_p (&cache->cursor, as, this_frame);
194 if (unw_step_p (&cache->cursor) < 0)
196 unw_destroy_addr_space_p (as);
200 /* To get base address, get sp from previous frame. */
201 uw_sp_regnum = descr->gdb2uw (gdbarch_sp_regnum (gdbarch));
202 ret = unw_get_reg_p (&cache->cursor, uw_sp_regnum, &fp);
205 unw_destroy_addr_space_p (as);
206 error (_("Can't get libunwind sp register."));
209 cache->base = (CORE_ADDR)fp;
217 libunwind_frame_dealloc_cache (struct frame_info *self, void *this_cache)
219 struct libunwind_frame_cache *cache = this_cache;
222 unw_destroy_addr_space_p (cache->as);
226 libunwind_find_dyn_list (unw_addr_space_t as, unw_dyn_info_t *di, void *arg)
228 return unw_find_dyn_list_p (as, di, arg);
231 static const struct frame_unwind libunwind_frame_unwind =
234 libunwind_frame_this_id,
235 libunwind_frame_prev_register,
237 libunwind_frame_sniffer,
238 libunwind_frame_dealloc_cache,
241 /* Verify if there is sufficient libunwind information for the frame to use
242 libunwind frame unwinding. */
244 libunwind_frame_sniffer (const struct frame_unwind *self,
245 struct frame_info *this_frame, void **this_cache)
248 unw_accessors_t *acc;
250 struct libunwind_descr *descr;
251 struct gdbarch *gdbarch = get_frame_arch (this_frame);
254 /* To test for libunwind unwind support, initialize a cursor to
255 the current frame and try to back up. We use this same method
256 when setting up the frame cache (see libunwind_frame_cache()).
257 If libunwind returns success for this operation, it means that
258 it has found sufficient libunwind unwinding information to do so. */
260 descr = libunwind_descr (gdbarch);
261 acc = descr->accessors;
262 as = unw_create_addr_space_p (acc,
263 gdbarch_byte_order (gdbarch)
268 ret = unw_init_remote_p (&cursor, as, this_frame);
272 unw_destroy_addr_space_p (as);
277 /* Check to see if we have libunwind info by checking if we are in a
278 signal frame. If it doesn't return an error, we have libunwind info
279 and can use libunwind. */
280 ret = unw_is_signal_frame_p (&cursor);
281 unw_destroy_addr_space_p (as);
290 libunwind_frame_this_id (struct frame_info *this_frame, void **this_cache,
291 struct frame_id *this_id)
293 struct libunwind_frame_cache *cache =
294 libunwind_frame_cache (this_frame, this_cache);
297 (*this_id) = frame_id_build (cache->base, cache->func_addr);
301 libunwind_frame_prev_register (struct frame_info *this_frame,
302 void **this_cache, int regnum)
304 struct libunwind_frame_cache *cache =
305 libunwind_frame_cache (this_frame, this_cache);
306 struct gdbarch *gdbarch = get_frame_arch (this_frame);
314 unw_regnum_t uw_regnum;
315 struct libunwind_descr *descr;
316 struct value *val = NULL;
319 return frame_unwind_got_constant (this_frame, regnum, 0);
321 /* Convert from gdb register number to libunwind register number. */
322 descr = libunwind_descr (get_frame_arch (this_frame));
323 uw_regnum = descr->gdb2uw (regnum);
325 gdb_assert (regnum >= 0);
327 if (!target_has_registers)
328 error (_("No registers."));
331 return frame_unwind_got_constant (this_frame, regnum, 0);
333 if (unw_get_saveloc_p (&cache->cursor, uw_regnum, &sl) < 0)
334 return frame_unwind_got_constant (this_frame, regnum, 0);
339 val = frame_unwind_got_memory (this_frame, regnum, sl.u.addr);
343 val = frame_unwind_got_register (this_frame, regnum,
344 descr->uw2gdb (sl.u.regnum));
348 /* The register is not stored at a specific memory address nor
349 inside another register. So use libunwind to fetch the register
350 value for us, and create a constant value with the result. */
351 if (descr->is_fpreg (uw_regnum))
353 ret = unw_get_fpreg_p (&cache->cursor, uw_regnum, &fpval);
355 return frame_unwind_got_constant (this_frame, regnum, 0);
356 val = frame_unwind_got_bytes (this_frame, regnum,
357 (gdb_byte *) &fpval);
361 ret = unw_get_reg_p (&cache->cursor, uw_regnum, &intval);
363 return frame_unwind_got_constant (this_frame, regnum, 0);
364 val = frame_unwind_got_constant (this_frame, regnum, intval);
374 libunwind_frame_base_address (struct frame_info *this_frame, void **this_cache)
376 struct libunwind_frame_cache *cache =
377 libunwind_frame_cache (this_frame, this_cache);
380 return (CORE_ADDR)NULL;
384 /* The following is a glue routine to call the libunwind unwind table
385 search function to get unwind information for a specified ip address. */
387 libunwind_search_unwind_table (void *as, long ip, void *di,
388 void *pi, int need_unwind_info, void *args)
390 return unw_search_unwind_table_p (*(unw_addr_space_t *)as, (unw_word_t )ip,
391 di, pi, need_unwind_info, args);
394 /* Verify if we are in a sigtramp frame and we can use libunwind to unwind. */
396 libunwind_sigtramp_frame_sniffer (const struct frame_unwind *self,
397 struct frame_info *this_frame,
401 unw_accessors_t *acc;
403 struct libunwind_descr *descr;
404 struct gdbarch *gdbarch = get_frame_arch (this_frame);
407 /* To test for libunwind unwind support, initialize a cursor to the
408 current frame and try to back up. We use this same method when
409 setting up the frame cache (see libunwind_frame_cache()). If
410 libunwind returns success for this operation, it means that it
411 has found sufficient libunwind unwinding information to do
414 descr = libunwind_descr (gdbarch);
415 acc = descr->accessors;
416 as = unw_create_addr_space_p (acc,
417 gdbarch_byte_order (gdbarch)
422 ret = unw_init_remote_p (&cursor, as, this_frame);
426 unw_destroy_addr_space_p (as);
430 /* Check to see if we are in a signal frame. */
431 ret = unw_is_signal_frame_p (&cursor);
432 unw_destroy_addr_space_p (as);
439 /* The following routine is for accessing special registers of the top frame.
440 A special set of accessors must be given that work without frame info.
441 This is used by ia64 to access the rse registers r32-r127. While they
442 are usually located at BOF, this is not always true and only the libunwind
443 info can decipher where they actually are. */
445 libunwind_get_reg_special (struct gdbarch *gdbarch, struct regcache *regcache,
446 int regnum, void *buf)
449 unw_accessors_t *acc;
451 struct libunwind_descr *descr;
453 unw_regnum_t uw_regnum;
459 descr = libunwind_descr (gdbarch);
460 acc = descr->special_accessors;
461 as = unw_create_addr_space_p (acc,
462 gdbarch_byte_order (gdbarch)
467 ret = unw_init_remote_p (&cursor, as, regcache);
470 unw_destroy_addr_space_p (as);
474 uw_regnum = descr->gdb2uw (regnum);
476 if (descr->is_fpreg (uw_regnum))
478 ret = unw_get_fpreg_p (&cursor, uw_regnum, &fpval);
483 ret = unw_get_reg_p (&cursor, uw_regnum, &intval);
487 unw_destroy_addr_space_p (as);
493 memcpy (buf, ptr, register_size (gdbarch, regnum));
499 libunwind_load (void)
503 handle = dlopen (LIBUNWIND_SO, RTLD_NOW);
507 /* Initialize pointers to the dynamic library functions we will use. */
509 unw_get_reg_p = dlsym (handle, get_reg_name);
510 if (unw_get_reg_p == NULL)
513 unw_get_fpreg_p = dlsym (handle, get_fpreg_name);
514 if (unw_get_fpreg_p == NULL)
517 unw_get_saveloc_p = dlsym (handle, get_saveloc_name);
518 if (unw_get_saveloc_p == NULL)
521 unw_is_signal_frame_p = dlsym (handle, is_signal_frame_name);
522 if (unw_is_signal_frame_p == NULL)
525 unw_step_p = dlsym (handle, step_name);
526 if (unw_step_p == NULL)
529 unw_init_remote_p = dlsym (handle, init_remote_name);
530 if (unw_init_remote_p == NULL)
533 unw_create_addr_space_p = dlsym (handle, create_addr_space_name);
534 if (unw_create_addr_space_p == NULL)
537 unw_destroy_addr_space_p = dlsym (handle, destroy_addr_space_name);
538 if (unw_destroy_addr_space_p == NULL)
541 unw_search_unwind_table_p = dlsym (handle, search_unwind_table_name);
542 if (unw_search_unwind_table_p == NULL)
545 unw_find_dyn_list_p = dlsym (handle, find_dyn_list_name);
546 if (unw_find_dyn_list_p == NULL)
553 libunwind_is_initialized (void)
555 return libunwind_initialized;
558 /* Provide a prototype to silence -Wmissing-prototypes. */
559 void _initialize_libunwind_frame (void);
562 _initialize_libunwind_frame (void)
564 libunwind_descr_handle
565 = gdbarch_data_register_post_init (libunwind_descr_init);
567 libunwind_initialized = libunwind_load ();