1 /* Frame unwinder for frames using the libunwind library.
3 Copyright (C) 2003, 2004, 2006, 2007, 2008, 2009
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
, unw_save_loc_t
*);
51 static int (*unw_is_signal_frame_p
) (unw_cursor_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 void (*unw_destroy_addr_space_p
) (unw_addr_space_t
);
56 static int (*unw_search_unwind_table_p
) (unw_addr_space_t
, unw_word_t
, unw_dyn_info_t
*,
57 unw_proc_info_t
*, int, void *);
58 static unw_word_t (*unw_find_dyn_list_p
) (unw_addr_space_t
, unw_dyn_info_t
*,
62 struct libunwind_frame_cache
70 /* We need to qualify the function names with a platform-specific prefix
71 to match the names used by the libunwind library. The UNW_OBJ macro is
72 provided by the libunwind.h header file. */
73 #define STRINGIFY2(name) #name
74 #define STRINGIFY(name) STRINGIFY2(name)
77 /* Use the stable ABI major version number. `libunwind-ia64.so' is a link time
78 only library, not a runtime one. */
79 #define LIBUNWIND_SO "libunwind-" STRINGIFY(UNW_TARGET) ".so.7"
82 static char *get_reg_name
= STRINGIFY(UNW_OBJ(get_reg
));
83 static char *get_fpreg_name
= STRINGIFY(UNW_OBJ(get_fpreg
));
84 static char *get_saveloc_name
= STRINGIFY(UNW_OBJ(get_save_loc
));
85 static char *is_signal_frame_name
= STRINGIFY(UNW_OBJ(is_signal_frame
));
86 static char *step_name
= STRINGIFY(UNW_OBJ(step
));
87 static char *init_remote_name
= STRINGIFY(UNW_OBJ(init_remote
));
88 static char *create_addr_space_name
= STRINGIFY(UNW_OBJ(create_addr_space
));
89 static char *destroy_addr_space_name
= STRINGIFY(UNW_OBJ(destroy_addr_space
));
90 static char *search_unwind_table_name
= STRINGIFY(UNW_OBJ(search_unwind_table
));
91 static char *find_dyn_list_name
= STRINGIFY(UNW_OBJ(find_dyn_list
));
93 static struct libunwind_descr
*
94 libunwind_descr (struct gdbarch
*gdbarch
)
96 return gdbarch_data (gdbarch
, libunwind_descr_handle
);
100 libunwind_descr_init (struct gdbarch
*gdbarch
)
102 struct libunwind_descr
*descr
= GDBARCH_OBSTACK_ZALLOC (gdbarch
,
103 struct libunwind_descr
);
108 libunwind_frame_set_descr (struct gdbarch
*gdbarch
, struct libunwind_descr
*descr
)
110 struct libunwind_descr
*arch_descr
;
112 gdb_assert (gdbarch
!= NULL
);
114 arch_descr
= gdbarch_data (gdbarch
, libunwind_descr_handle
);
116 if (arch_descr
== NULL
)
118 /* First time here. Must initialize data area. */
119 arch_descr
= libunwind_descr_init (gdbarch
);
120 deprecated_set_gdbarch_data (gdbarch
, libunwind_descr_handle
, arch_descr
);
123 /* Copy new descriptor info into arch descriptor. */
124 arch_descr
->gdb2uw
= descr
->gdb2uw
;
125 arch_descr
->uw2gdb
= descr
->uw2gdb
;
126 arch_descr
->is_fpreg
= descr
->is_fpreg
;
127 arch_descr
->accessors
= descr
->accessors
;
128 arch_descr
->special_accessors
= descr
->special_accessors
;
131 static struct libunwind_frame_cache
*
132 libunwind_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
134 unw_accessors_t
*acc
;
137 unw_regnum_t uw_sp_regnum
;
138 struct libunwind_frame_cache
*cache
;
139 struct libunwind_descr
*descr
;
140 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
146 /* Allocate a new cache. */
147 cache
= FRAME_OBSTACK_ZALLOC (struct libunwind_frame_cache
);
149 /* We can assume we are unwinding a normal frame. Even if this is
150 for a signal trampoline, ia64 signal "trampolines" use a normal
151 subroutine call to start the signal handler. */
152 cache
->func_addr
= get_frame_func (this_frame
);
153 if (cache
->func_addr
== 0
154 && get_next_frame (this_frame
)
155 && get_frame_type (get_next_frame (this_frame
)) == NORMAL_FRAME
)
158 /* Get a libunwind cursor to the previous frame.
160 We do this by initializing a cursor. Libunwind treats a new cursor
161 as the top of stack and will get the current register set via the
162 libunwind register accessor. Now, we provide the platform-specific
163 accessors and we set up the register accessor to use the frame
164 register unwinding interfaces so that we properly get the registers
165 for the current frame rather than the top. We then use the unw_step
166 function to move the libunwind cursor back one frame. We can later
167 use this cursor to find previous registers via the unw_get_reg
168 interface which will invoke libunwind's special logic. */
169 descr
= libunwind_descr (gdbarch
);
170 acc
= descr
->accessors
;
171 as
= unw_create_addr_space_p (acc
,
172 gdbarch_byte_order (gdbarch
)
177 unw_init_remote_p (&cache
->cursor
, as
, this_frame
);
178 if (unw_step_p (&cache
->cursor
) < 0)
180 unw_destroy_addr_space_p (as
);
184 /* To get base address, get sp from previous frame. */
185 uw_sp_regnum
= descr
->gdb2uw (gdbarch_sp_regnum (gdbarch
));
186 ret
= unw_get_reg_p (&cache
->cursor
, uw_sp_regnum
, &fp
);
189 unw_destroy_addr_space_p (as
);
190 error (_("Can't get libunwind sp register."));
193 cache
->base
= (CORE_ADDR
)fp
;
201 libunwind_frame_dealloc_cache (struct frame_info
*self
, void *this_cache
)
203 struct libunwind_frame_cache
*cache
= this_cache
;
205 unw_destroy_addr_space_p (cache
->as
);
209 libunwind_find_dyn_list (unw_addr_space_t as
, unw_dyn_info_t
*di
, void *arg
)
211 return unw_find_dyn_list_p (as
, di
, arg
);
214 static const struct frame_unwind libunwind_frame_unwind
=
217 libunwind_frame_this_id
,
218 libunwind_frame_prev_register
,
220 libunwind_frame_sniffer
,
221 libunwind_frame_dealloc_cache
,
224 /* Verify if there is sufficient libunwind information for the frame to use
225 libunwind frame unwinding. */
227 libunwind_frame_sniffer (const struct frame_unwind
*self
,
228 struct frame_info
*this_frame
, void **this_cache
)
231 unw_accessors_t
*acc
;
233 struct libunwind_descr
*descr
;
234 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
237 /* To test for libunwind unwind support, initialize a cursor to
238 the current frame and try to back up. We use this same method
239 when setting up the frame cache (see libunwind_frame_cache()).
240 If libunwind returns success for this operation, it means that
241 it has found sufficient libunwind unwinding information to do so. */
243 descr
= libunwind_descr (gdbarch
);
244 acc
= descr
->accessors
;
245 as
= unw_create_addr_space_p (acc
,
246 gdbarch_byte_order (gdbarch
)
251 ret
= unw_init_remote_p (&cursor
, as
, this_frame
);
255 unw_destroy_addr_space_p (as
);
260 /* Check to see if we have libunwind info by checking if we are in a
261 signal frame. If it doesn't return an error, we have libunwind info
262 and can use libunwind. */
263 ret
= unw_is_signal_frame_p (&cursor
);
264 unw_destroy_addr_space_p (as
);
273 libunwind_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
274 struct frame_id
*this_id
)
276 struct libunwind_frame_cache
*cache
=
277 libunwind_frame_cache (this_frame
, this_cache
);
280 (*this_id
) = frame_id_build (cache
->base
, cache
->func_addr
);
282 (*this_id
) = null_frame_id
;
286 libunwind_frame_prev_register (struct frame_info
*this_frame
,
287 void **this_cache
, int regnum
)
289 struct libunwind_frame_cache
*cache
=
290 libunwind_frame_cache (this_frame
, this_cache
);
291 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
299 unw_regnum_t uw_regnum
;
300 struct libunwind_descr
*descr
;
301 struct value
*val
= NULL
;
304 return frame_unwind_got_constant (this_frame
, regnum
, 0);
306 /* Convert from gdb register number to libunwind register number. */
307 descr
= libunwind_descr (get_frame_arch (this_frame
));
308 uw_regnum
= descr
->gdb2uw (regnum
);
310 gdb_assert (regnum
>= 0);
312 if (!target_has_registers
)
313 error (_("No registers."));
316 return frame_unwind_got_constant (this_frame
, regnum
, 0);
318 if (unw_get_saveloc_p (&cache
->cursor
, uw_regnum
, &sl
) < 0)
319 return frame_unwind_got_constant (this_frame
, regnum
, 0);
324 val
= frame_unwind_got_memory (this_frame
, regnum
, sl
.u
.addr
);
328 val
= frame_unwind_got_register (this_frame
, regnum
,
329 descr
->uw2gdb (sl
.u
.regnum
));
333 /* The register is not stored at a specific memory address nor
334 inside another register. So use libunwind to fetch the register
335 value for us, and create a constant value with the result. */
336 if (descr
->is_fpreg (uw_regnum
))
338 ret
= unw_get_fpreg_p (&cache
->cursor
, uw_regnum
, &fpval
);
340 return frame_unwind_got_constant (this_frame
, regnum
, 0);
341 val
= frame_unwind_got_bytes (this_frame
, regnum
,
342 (gdb_byte
*) &fpval
);
346 ret
= unw_get_reg_p (&cache
->cursor
, uw_regnum
, &intval
);
348 return frame_unwind_got_constant (this_frame
, regnum
, 0);
349 val
= frame_unwind_got_constant (this_frame
, regnum
, intval
);
351 set_value_optimized_out (val
, 1);
360 libunwind_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
362 struct libunwind_frame_cache
*cache
=
363 libunwind_frame_cache (this_frame
, this_cache
);
366 return (CORE_ADDR
)NULL
;
370 /* The following is a glue routine to call the libunwind unwind table
371 search function to get unwind information for a specified ip address. */
373 libunwind_search_unwind_table (void *as
, long ip
, void *di
,
374 void *pi
, int need_unwind_info
, void *args
)
376 return unw_search_unwind_table_p (*(unw_addr_space_t
*)as
, (unw_word_t
)ip
,
377 di
, pi
, need_unwind_info
, args
);
380 /* Verify if we are in a sigtramp frame and we can use libunwind to unwind. */
382 libunwind_sigtramp_frame_sniffer (const struct frame_unwind
*self
,
383 struct frame_info
*this_frame
,
387 unw_accessors_t
*acc
;
389 struct libunwind_descr
*descr
;
390 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
393 /* To test for libunwind unwind support, initialize a cursor to the
394 current frame and try to back up. We use this same method when
395 setting up the frame cache (see libunwind_frame_cache()). If
396 libunwind returns success for this operation, it means that it
397 has found sufficient libunwind unwinding information to do
400 descr
= libunwind_descr (gdbarch
);
401 acc
= descr
->accessors
;
402 as
= unw_create_addr_space_p (acc
,
403 gdbarch_byte_order (gdbarch
)
408 ret
= unw_init_remote_p (&cursor
, as
, this_frame
);
412 unw_destroy_addr_space_p (as
);
416 /* Check to see if we are in a signal frame. */
417 ret
= unw_is_signal_frame_p (&cursor
);
418 unw_destroy_addr_space_p (as
);
425 /* The following routine is for accessing special registers of the top frame.
426 A special set of accessors must be given that work without frame info.
427 This is used by ia64 to access the rse registers r32-r127. While they
428 are usually located at BOF, this is not always true and only the libunwind
429 info can decipher where they actually are. */
431 libunwind_get_reg_special (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
432 int regnum
, void *buf
)
435 unw_accessors_t
*acc
;
437 struct libunwind_descr
*descr
;
439 unw_regnum_t uw_regnum
;
445 descr
= libunwind_descr (gdbarch
);
446 acc
= descr
->special_accessors
;
447 as
= unw_create_addr_space_p (acc
,
448 gdbarch_byte_order (gdbarch
)
453 ret
= unw_init_remote_p (&cursor
, as
, regcache
);
456 unw_destroy_addr_space_p (as
);
460 uw_regnum
= descr
->gdb2uw (regnum
);
462 if (descr
->is_fpreg (uw_regnum
))
464 ret
= unw_get_fpreg_p (&cursor
, uw_regnum
, &fpval
);
469 ret
= unw_get_reg_p (&cursor
, uw_regnum
, &intval
);
473 unw_destroy_addr_space_p (as
);
479 memcpy (buf
, ptr
, register_size (gdbarch
, regnum
));
485 libunwind_load (void)
489 handle
= dlopen (LIBUNWIND_SO
, RTLD_NOW
);
493 /* Initialize pointers to the dynamic library functions we will use. */
495 unw_get_reg_p
= dlsym (handle
, get_reg_name
);
496 if (unw_get_reg_p
== NULL
)
499 unw_get_fpreg_p
= dlsym (handle
, get_fpreg_name
);
500 if (unw_get_fpreg_p
== NULL
)
503 unw_get_saveloc_p
= dlsym (handle
, get_saveloc_name
);
504 if (unw_get_saveloc_p
== NULL
)
507 unw_is_signal_frame_p
= dlsym (handle
, is_signal_frame_name
);
508 if (unw_is_signal_frame_p
== NULL
)
511 unw_step_p
= dlsym (handle
, step_name
);
512 if (unw_step_p
== NULL
)
515 unw_init_remote_p
= dlsym (handle
, init_remote_name
);
516 if (unw_init_remote_p
== NULL
)
519 unw_create_addr_space_p
= dlsym (handle
, create_addr_space_name
);
520 if (unw_create_addr_space_p
== NULL
)
523 unw_destroy_addr_space_p
= dlsym (handle
, destroy_addr_space_name
);
524 if (unw_destroy_addr_space_p
== NULL
)
527 unw_search_unwind_table_p
= dlsym (handle
, search_unwind_table_name
);
528 if (unw_search_unwind_table_p
== NULL
)
531 unw_find_dyn_list_p
= dlsym (handle
, find_dyn_list_name
);
532 if (unw_find_dyn_list_p
== NULL
)
539 libunwind_is_initialized (void)
541 return libunwind_initialized
;
544 /* Provide a prototype to silence -Wmissing-prototypes. */
545 void _initialize_libunwind_frame (void);
548 _initialize_libunwind_frame (void)
550 libunwind_descr_handle
= gdbarch_data_register_post_init (libunwind_descr_init
);
552 libunwind_initialized
= libunwind_load ();