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 static int libunwind_initialized
;
45 static struct gdbarch_data
*libunwind_descr_handle
;
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
,
52 static int (*unw_is_signal_frame_p
) (unw_cursor_t
*);
53 static int (*unw_step_p
) (unw_cursor_t
*);
54 static int (*unw_init_remote_p
) (unw_cursor_t
*, unw_addr_space_t
, void *);
55 static unw_addr_space_t (*unw_create_addr_space_p
) (unw_accessors_t
*, int);
56 static void (*unw_destroy_addr_space_p
) (unw_addr_space_t
);
57 static int (*unw_search_unwind_table_p
) (unw_addr_space_t
, unw_word_t
,
59 unw_proc_info_t
*, int, void *);
60 static unw_word_t (*unw_find_dyn_list_p
) (unw_addr_space_t
, unw_dyn_info_t
*,
64 struct libunwind_frame_cache
72 /* We need to qualify the function names with a platform-specific prefix
73 to match the names used by the libunwind library. The UNW_OBJ macro is
74 provided by the libunwind.h header file. */
75 #define STRINGIFY2(name) #name
76 #define STRINGIFY(name) STRINGIFY2(name)
79 /* Use the stable ABI major version number. `libunwind-ia64.so' is a link time
80 only library, not a runtime one. */
81 #define LIBUNWIND_SO "libunwind-" STRINGIFY(UNW_TARGET) ".so.7"
84 static char *get_reg_name
= STRINGIFY(UNW_OBJ(get_reg
));
85 static char *get_fpreg_name
= STRINGIFY(UNW_OBJ(get_fpreg
));
86 static char *get_saveloc_name
= STRINGIFY(UNW_OBJ(get_save_loc
));
87 static char *is_signal_frame_name
= STRINGIFY(UNW_OBJ(is_signal_frame
));
88 static char *step_name
= STRINGIFY(UNW_OBJ(step
));
89 static char *init_remote_name
= STRINGIFY(UNW_OBJ(init_remote
));
90 static char *create_addr_space_name
= STRINGIFY(UNW_OBJ(create_addr_space
));
91 static char *destroy_addr_space_name
= STRINGIFY(UNW_OBJ(destroy_addr_space
));
92 static char *search_unwind_table_name
93 = STRINGIFY(UNW_OBJ(search_unwind_table
));
94 static char *find_dyn_list_name
= STRINGIFY(UNW_OBJ(find_dyn_list
));
96 static struct libunwind_descr
*
97 libunwind_descr (struct gdbarch
*gdbarch
)
99 return gdbarch_data (gdbarch
, libunwind_descr_handle
);
103 libunwind_descr_init (struct gdbarch
*gdbarch
)
105 struct libunwind_descr
*descr
106 = GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct libunwind_descr
);
112 libunwind_frame_set_descr (struct gdbarch
*gdbarch
,
113 struct libunwind_descr
*descr
)
115 struct libunwind_descr
*arch_descr
;
117 gdb_assert (gdbarch
!= NULL
);
119 arch_descr
= gdbarch_data (gdbarch
, libunwind_descr_handle
);
121 if (arch_descr
== NULL
)
123 /* First time here. Must initialize data area. */
124 arch_descr
= libunwind_descr_init (gdbarch
);
125 deprecated_set_gdbarch_data (gdbarch
,
126 libunwind_descr_handle
, arch_descr
);
129 /* Copy new descriptor info into arch descriptor. */
130 arch_descr
->gdb2uw
= descr
->gdb2uw
;
131 arch_descr
->uw2gdb
= descr
->uw2gdb
;
132 arch_descr
->is_fpreg
= descr
->is_fpreg
;
133 arch_descr
->accessors
= descr
->accessors
;
134 arch_descr
->special_accessors
= descr
->special_accessors
;
137 static struct libunwind_frame_cache
*
138 libunwind_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
140 unw_accessors_t
*acc
;
143 unw_regnum_t uw_sp_regnum
;
144 struct libunwind_frame_cache
*cache
;
145 struct libunwind_descr
*descr
;
146 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
152 /* Allocate a new cache. */
153 cache
= FRAME_OBSTACK_ZALLOC (struct libunwind_frame_cache
);
155 /* We can assume we are unwinding a normal frame. Even if this is
156 for a signal trampoline, ia64 signal "trampolines" use a normal
157 subroutine call to start the signal handler. */
158 cache
->func_addr
= get_frame_func (this_frame
);
159 if (cache
->func_addr
== 0
160 && get_next_frame (this_frame
)
161 && get_frame_type (get_next_frame (this_frame
)) == NORMAL_FRAME
)
164 /* Get a libunwind cursor to the previous frame.
166 We do this by initializing a cursor. Libunwind treats a new cursor
167 as the top of stack and will get the current register set via the
168 libunwind register accessor. Now, we provide the platform-specific
169 accessors and we set up the register accessor to use the frame
170 register unwinding interfaces so that we properly get the registers
171 for the current frame rather than the top. We then use the unw_step
172 function to move the libunwind cursor back one frame. We can later
173 use this cursor to find previous registers via the unw_get_reg
174 interface which will invoke libunwind's special logic. */
175 descr
= libunwind_descr (gdbarch
);
176 acc
= descr
->accessors
;
177 as
= unw_create_addr_space_p (acc
,
178 gdbarch_byte_order (gdbarch
)
183 unw_init_remote_p (&cache
->cursor
, as
, this_frame
);
184 if (unw_step_p (&cache
->cursor
) < 0)
186 unw_destroy_addr_space_p (as
);
190 /* To get base address, get sp from previous frame. */
191 uw_sp_regnum
= descr
->gdb2uw (gdbarch_sp_regnum (gdbarch
));
192 ret
= unw_get_reg_p (&cache
->cursor
, uw_sp_regnum
, &fp
);
195 unw_destroy_addr_space_p (as
);
196 error (_("Can't get libunwind sp register."));
199 cache
->base
= (CORE_ADDR
)fp
;
207 libunwind_frame_dealloc_cache (struct frame_info
*self
, void *this_cache
)
209 struct libunwind_frame_cache
*cache
= this_cache
;
212 unw_destroy_addr_space_p (cache
->as
);
216 libunwind_find_dyn_list (unw_addr_space_t as
, unw_dyn_info_t
*di
, void *arg
)
218 return unw_find_dyn_list_p (as
, di
, arg
);
221 static const struct frame_unwind libunwind_frame_unwind
=
224 libunwind_frame_this_id
,
225 libunwind_frame_prev_register
,
227 libunwind_frame_sniffer
,
228 libunwind_frame_dealloc_cache
,
231 /* Verify if there is sufficient libunwind information for the frame to use
232 libunwind frame unwinding. */
234 libunwind_frame_sniffer (const struct frame_unwind
*self
,
235 struct frame_info
*this_frame
, void **this_cache
)
238 unw_accessors_t
*acc
;
240 struct libunwind_descr
*descr
;
241 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
244 /* To test for libunwind unwind support, initialize a cursor to
245 the current frame and try to back up. We use this same method
246 when setting up the frame cache (see libunwind_frame_cache()).
247 If libunwind returns success for this operation, it means that
248 it has found sufficient libunwind unwinding information to do so. */
250 descr
= libunwind_descr (gdbarch
);
251 acc
= descr
->accessors
;
252 as
= unw_create_addr_space_p (acc
,
253 gdbarch_byte_order (gdbarch
)
258 ret
= unw_init_remote_p (&cursor
, as
, this_frame
);
262 unw_destroy_addr_space_p (as
);
267 /* Check to see if we have libunwind info by checking if we are in a
268 signal frame. If it doesn't return an error, we have libunwind info
269 and can use libunwind. */
270 ret
= unw_is_signal_frame_p (&cursor
);
271 unw_destroy_addr_space_p (as
);
280 libunwind_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
281 struct frame_id
*this_id
)
283 struct libunwind_frame_cache
*cache
=
284 libunwind_frame_cache (this_frame
, this_cache
);
287 (*this_id
) = frame_id_build (cache
->base
, cache
->func_addr
);
291 libunwind_frame_prev_register (struct frame_info
*this_frame
,
292 void **this_cache
, int regnum
)
294 struct libunwind_frame_cache
*cache
=
295 libunwind_frame_cache (this_frame
, this_cache
);
296 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
304 unw_regnum_t uw_regnum
;
305 struct libunwind_descr
*descr
;
306 struct value
*val
= NULL
;
309 return frame_unwind_got_constant (this_frame
, regnum
, 0);
311 /* Convert from gdb register number to libunwind register number. */
312 descr
= libunwind_descr (get_frame_arch (this_frame
));
313 uw_regnum
= descr
->gdb2uw (regnum
);
315 gdb_assert (regnum
>= 0);
317 if (!target_has_registers
)
318 error (_("No registers."));
321 return frame_unwind_got_constant (this_frame
, regnum
, 0);
323 if (unw_get_saveloc_p (&cache
->cursor
, uw_regnum
, &sl
) < 0)
324 return frame_unwind_got_constant (this_frame
, regnum
, 0);
329 val
= frame_unwind_got_memory (this_frame
, regnum
, sl
.u
.addr
);
333 val
= frame_unwind_got_register (this_frame
, regnum
,
334 descr
->uw2gdb (sl
.u
.regnum
));
338 /* The register is not stored at a specific memory address nor
339 inside another register. So use libunwind to fetch the register
340 value for us, and create a constant value with the result. */
341 if (descr
->is_fpreg (uw_regnum
))
343 ret
= unw_get_fpreg_p (&cache
->cursor
, uw_regnum
, &fpval
);
345 return frame_unwind_got_constant (this_frame
, regnum
, 0);
346 val
= frame_unwind_got_bytes (this_frame
, regnum
,
347 (gdb_byte
*) &fpval
);
351 ret
= unw_get_reg_p (&cache
->cursor
, uw_regnum
, &intval
);
353 return frame_unwind_got_constant (this_frame
, regnum
, 0);
354 val
= frame_unwind_got_constant (this_frame
, regnum
, intval
);
364 libunwind_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
366 struct libunwind_frame_cache
*cache
=
367 libunwind_frame_cache (this_frame
, this_cache
);
370 return (CORE_ADDR
)NULL
;
374 /* The following is a glue routine to call the libunwind unwind table
375 search function to get unwind information for a specified ip address. */
377 libunwind_search_unwind_table (void *as
, long ip
, void *di
,
378 void *pi
, int need_unwind_info
, void *args
)
380 return unw_search_unwind_table_p (*(unw_addr_space_t
*)as
, (unw_word_t
)ip
,
381 di
, pi
, need_unwind_info
, args
);
384 /* Verify if we are in a sigtramp frame and we can use libunwind to unwind. */
386 libunwind_sigtramp_frame_sniffer (const struct frame_unwind
*self
,
387 struct frame_info
*this_frame
,
391 unw_accessors_t
*acc
;
393 struct libunwind_descr
*descr
;
394 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
397 /* To test for libunwind unwind support, initialize a cursor to the
398 current frame and try to back up. We use this same method when
399 setting up the frame cache (see libunwind_frame_cache()). If
400 libunwind returns success for this operation, it means that it
401 has found sufficient libunwind unwinding information to do
404 descr
= libunwind_descr (gdbarch
);
405 acc
= descr
->accessors
;
406 as
= unw_create_addr_space_p (acc
,
407 gdbarch_byte_order (gdbarch
)
412 ret
= unw_init_remote_p (&cursor
, as
, this_frame
);
416 unw_destroy_addr_space_p (as
);
420 /* Check to see if we are in a signal frame. */
421 ret
= unw_is_signal_frame_p (&cursor
);
422 unw_destroy_addr_space_p (as
);
429 /* The following routine is for accessing special registers of the top frame.
430 A special set of accessors must be given that work without frame info.
431 This is used by ia64 to access the rse registers r32-r127. While they
432 are usually located at BOF, this is not always true and only the libunwind
433 info can decipher where they actually are. */
435 libunwind_get_reg_special (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
436 int regnum
, void *buf
)
439 unw_accessors_t
*acc
;
441 struct libunwind_descr
*descr
;
443 unw_regnum_t uw_regnum
;
449 descr
= libunwind_descr (gdbarch
);
450 acc
= descr
->special_accessors
;
451 as
= unw_create_addr_space_p (acc
,
452 gdbarch_byte_order (gdbarch
)
457 ret
= unw_init_remote_p (&cursor
, as
, regcache
);
460 unw_destroy_addr_space_p (as
);
464 uw_regnum
= descr
->gdb2uw (regnum
);
466 if (descr
->is_fpreg (uw_regnum
))
468 ret
= unw_get_fpreg_p (&cursor
, uw_regnum
, &fpval
);
473 ret
= unw_get_reg_p (&cursor
, uw_regnum
, &intval
);
477 unw_destroy_addr_space_p (as
);
483 memcpy (buf
, ptr
, register_size (gdbarch
, regnum
));
489 libunwind_load (void)
493 handle
= dlopen (LIBUNWIND_SO
, RTLD_NOW
);
497 /* Initialize pointers to the dynamic library functions we will use. */
499 unw_get_reg_p
= dlsym (handle
, get_reg_name
);
500 if (unw_get_reg_p
== NULL
)
503 unw_get_fpreg_p
= dlsym (handle
, get_fpreg_name
);
504 if (unw_get_fpreg_p
== NULL
)
507 unw_get_saveloc_p
= dlsym (handle
, get_saveloc_name
);
508 if (unw_get_saveloc_p
== NULL
)
511 unw_is_signal_frame_p
= dlsym (handle
, is_signal_frame_name
);
512 if (unw_is_signal_frame_p
== NULL
)
515 unw_step_p
= dlsym (handle
, step_name
);
516 if (unw_step_p
== NULL
)
519 unw_init_remote_p
= dlsym (handle
, init_remote_name
);
520 if (unw_init_remote_p
== NULL
)
523 unw_create_addr_space_p
= dlsym (handle
, create_addr_space_name
);
524 if (unw_create_addr_space_p
== NULL
)
527 unw_destroy_addr_space_p
= dlsym (handle
, destroy_addr_space_name
);
528 if (unw_destroy_addr_space_p
== NULL
)
531 unw_search_unwind_table_p
= dlsym (handle
, search_unwind_table_name
);
532 if (unw_search_unwind_table_p
== NULL
)
535 unw_find_dyn_list_p
= dlsym (handle
, find_dyn_list_name
);
536 if (unw_find_dyn_list_p
== NULL
)
543 libunwind_is_initialized (void)
545 return libunwind_initialized
;
548 /* Provide a prototype to silence -Wmissing-prototypes. */
549 void _initialize_libunwind_frame (void);
552 _initialize_libunwind_frame (void)
554 libunwind_descr_handle
555 = gdbarch_data_register_post_init (libunwind_descr_init
);
557 libunwind_initialized
= libunwind_load ();