1 /* Frame unwinder for frames using the libunwind library.
3 Copyright (C) 2003, 2004, 2006, 2007, 2008 Free Software Foundation, Inc.
5 Written by Jeff Johnston, contributed by Red Hat Inc.
7 This file is part of GDB.
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 3 of the License, or
12 (at your option) any later version.
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.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "frame-base.h"
27 #include "frame-unwind.h"
36 #include "gdb_assert.h"
37 #include "gdb_string.h"
39 #include "libunwind-frame.h"
41 #include "complaints.h"
43 static int libunwind_initialized
;
44 static struct gdbarch_data
*libunwind_descr_handle
;
46 /* Required function pointers from libunwind. */
47 static int (*unw_get_reg_p
) (unw_cursor_t
*, unw_regnum_t
, unw_word_t
*);
48 static int (*unw_get_fpreg_p
) (unw_cursor_t
*, unw_regnum_t
, unw_fpreg_t
*);
49 static int (*unw_get_saveloc_p
) (unw_cursor_t
*, unw_regnum_t
, unw_save_loc_t
*);
50 static int (*unw_is_signal_frame_p
) (unw_cursor_t
*);
51 static int (*unw_step_p
) (unw_cursor_t
*);
52 static int (*unw_init_remote_p
) (unw_cursor_t
*, unw_addr_space_t
, void *);
53 static unw_addr_space_t (*unw_create_addr_space_p
) (unw_accessors_t
*, int);
54 static void (*unw_destroy_addr_space_p
) (unw_addr_space_t
);
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
*,
61 struct libunwind_frame_cache
69 /* We need to qualify the function names with a platform-specific prefix
70 to match the names used by the libunwind library. The UNW_OBJ macro is
71 provided by the libunwind.h header file. */
72 #define STRINGIFY2(name) #name
73 #define STRINGIFY(name) STRINGIFY2(name)
76 /* Use the stable ABI major version number. `libunwind-ia64.so' is a link time
77 only library, not a runtime one. */
78 #define LIBUNWIND_SO "libunwind-" STRINGIFY(UNW_TARGET) ".so.7"
81 static char *get_reg_name
= STRINGIFY(UNW_OBJ(get_reg
));
82 static char *get_fpreg_name
= STRINGIFY(UNW_OBJ(get_fpreg
));
83 static char *get_saveloc_name
= STRINGIFY(UNW_OBJ(get_save_loc
));
84 static char *is_signal_frame_name
= STRINGIFY(UNW_OBJ(is_signal_frame
));
85 static char *step_name
= STRINGIFY(UNW_OBJ(step
));
86 static char *init_remote_name
= STRINGIFY(UNW_OBJ(init_remote
));
87 static char *create_addr_space_name
= STRINGIFY(UNW_OBJ(create_addr_space
));
88 static char *destroy_addr_space_name
= STRINGIFY(UNW_OBJ(destroy_addr_space
));
89 static char *search_unwind_table_name
= STRINGIFY(UNW_OBJ(search_unwind_table
));
90 static char *find_dyn_list_name
= STRINGIFY(UNW_OBJ(find_dyn_list
));
92 static struct libunwind_descr
*
93 libunwind_descr (struct gdbarch
*gdbarch
)
95 return gdbarch_data (gdbarch
, libunwind_descr_handle
);
99 libunwind_descr_init (struct gdbarch
*gdbarch
)
101 struct libunwind_descr
*descr
= GDBARCH_OBSTACK_ZALLOC (gdbarch
,
102 struct libunwind_descr
);
107 libunwind_frame_set_descr (struct gdbarch
*gdbarch
, struct libunwind_descr
*descr
)
109 struct libunwind_descr
*arch_descr
;
111 gdb_assert (gdbarch
!= NULL
);
113 arch_descr
= gdbarch_data (gdbarch
, libunwind_descr_handle
);
115 if (arch_descr
== NULL
)
117 /* First time here. Must initialize data area. */
118 arch_descr
= libunwind_descr_init (gdbarch
);
119 deprecated_set_gdbarch_data (gdbarch
, libunwind_descr_handle
, arch_descr
);
122 /* Copy new descriptor info into arch descriptor. */
123 arch_descr
->gdb2uw
= descr
->gdb2uw
;
124 arch_descr
->uw2gdb
= descr
->uw2gdb
;
125 arch_descr
->is_fpreg
= descr
->is_fpreg
;
126 arch_descr
->accessors
= descr
->accessors
;
127 arch_descr
->special_accessors
= descr
->special_accessors
;
130 static struct libunwind_frame_cache
*
131 libunwind_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
133 unw_accessors_t
*acc
;
136 unw_regnum_t uw_sp_regnum
;
137 struct libunwind_frame_cache
*cache
;
138 struct libunwind_descr
*descr
;
139 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
145 /* Allocate a new cache. */
146 cache
= FRAME_OBSTACK_ZALLOC (struct libunwind_frame_cache
);
148 /* We can assume we are unwinding a normal frame. Even if this is
149 for a signal trampoline, ia64 signal "trampolines" use a normal
150 subroutine call to start the signal handler. */
151 cache
->func_addr
= get_frame_func (this_frame
);
152 if (cache
->func_addr
== 0
153 && get_next_frame (this_frame
)
154 && get_frame_type (get_next_frame (this_frame
)) == NORMAL_FRAME
)
157 /* Get a libunwind cursor to the previous frame.
159 We do this by initializing a cursor. Libunwind treats a new cursor
160 as the top of stack and will get the current register set via the
161 libunwind register accessor. Now, we provide the platform-specific
162 accessors and we set up the register accessor to use the frame
163 register unwinding interfaces so that we properly get the registers
164 for the current frame rather than the top. We then use the unw_step
165 function to move the libunwind cursor back one frame. We can later
166 use this cursor to find previous registers via the unw_get_reg
167 interface which will invoke libunwind's special logic. */
168 descr
= libunwind_descr (gdbarch
);
169 acc
= descr
->accessors
;
170 as
= unw_create_addr_space_p (acc
,
171 gdbarch_byte_order (gdbarch
)
176 unw_init_remote_p (&cache
->cursor
, as
, this_frame
);
177 if (unw_step_p (&cache
->cursor
) < 0)
179 unw_destroy_addr_space_p (as
);
183 /* To get base address, get sp from previous frame. */
184 uw_sp_regnum
= descr
->gdb2uw (gdbarch_sp_regnum (gdbarch
));
185 ret
= unw_get_reg_p (&cache
->cursor
, uw_sp_regnum
, &fp
);
188 unw_destroy_addr_space_p (as
);
189 error (_("Can't get libunwind sp register."));
192 cache
->base
= (CORE_ADDR
)fp
;
200 libunwind_frame_dealloc_cache (struct frame_info
*self
, void *this_cache
)
202 struct libunwind_frame_cache
*cache
= this_cache
;
204 unw_destroy_addr_space_p (cache
->as
);
208 libunwind_find_dyn_list (unw_addr_space_t as
, unw_dyn_info_t
*di
, void *arg
)
210 return unw_find_dyn_list_p (as
, di
, arg
);
213 static const struct frame_unwind libunwind_frame_unwind
=
216 libunwind_frame_this_id
,
217 libunwind_frame_prev_register
,
219 libunwind_frame_sniffer
,
220 libunwind_frame_dealloc_cache
,
223 /* Verify if there is sufficient libunwind information for the frame to use
224 libunwind frame unwinding. */
226 libunwind_frame_sniffer (const struct frame_unwind
*self
,
227 struct frame_info
*this_frame
, void **this_cache
)
230 unw_accessors_t
*acc
;
232 struct libunwind_descr
*descr
;
233 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
236 /* To test for libunwind unwind support, initialize a cursor to
237 the current frame and try to back up. We use this same method
238 when setting up the frame cache (see libunwind_frame_cache()).
239 If libunwind returns success for this operation, it means that
240 it has found sufficient libunwind unwinding information to do so. */
242 descr
= libunwind_descr (gdbarch
);
243 acc
= descr
->accessors
;
244 as
= unw_create_addr_space_p (acc
,
245 gdbarch_byte_order (gdbarch
)
250 ret
= unw_init_remote_p (&cursor
, as
, this_frame
);
254 unw_destroy_addr_space_p (as
);
259 /* Check to see if we have libunwind info by checking if we are in a
260 signal frame. If it doesn't return an error, we have libunwind info
261 and can use libunwind. */
262 ret
= unw_is_signal_frame_p (&cursor
);
263 unw_destroy_addr_space_p (as
);
272 libunwind_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
273 struct frame_id
*this_id
)
275 struct libunwind_frame_cache
*cache
=
276 libunwind_frame_cache (this_frame
, this_cache
);
279 (*this_id
) = frame_id_build (cache
->base
, cache
->func_addr
);
281 (*this_id
) = null_frame_id
;
285 libunwind_frame_prev_register (struct frame_info
*this_frame
,
286 void **this_cache
, int regnum
)
288 struct libunwind_frame_cache
*cache
=
289 libunwind_frame_cache (this_frame
, this_cache
);
290 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
298 unw_regnum_t uw_regnum
;
299 struct libunwind_descr
*descr
;
300 struct value
*val
= NULL
;
303 return frame_unwind_got_constant (this_frame
, regnum
, 0);
305 /* Convert from gdb register number to libunwind register number. */
306 descr
= libunwind_descr (get_frame_arch (this_frame
));
307 uw_regnum
= descr
->gdb2uw (regnum
);
309 gdb_assert (regnum
>= 0);
311 if (!target_has_registers
)
312 error (_("No registers."));
315 return frame_unwind_got_constant (this_frame
, regnum
, 0);
317 if (unw_get_saveloc_p (&cache
->cursor
, uw_regnum
, &sl
) < 0)
318 return frame_unwind_got_constant (this_frame
, regnum
, 0);
323 val
= frame_unwind_got_memory (this_frame
, regnum
, sl
.u
.addr
);
327 val
= frame_unwind_got_register (this_frame
, regnum
,
328 descr
->uw2gdb (sl
.u
.regnum
));
332 /* The register is not stored at a specific memory address nor
333 inside another register. So use libunwind to fetch the register
334 value for us, and create a constant value with the result. */
335 if (descr
->is_fpreg (uw_regnum
))
337 ret
= unw_get_fpreg_p (&cache
->cursor
, uw_regnum
, &fpval
);
339 return frame_unwind_got_constant (this_frame
, regnum
, 0);
340 val
= frame_unwind_got_bytes (this_frame
, regnum
,
341 (gdb_byte
*) &fpval
);
345 ret
= unw_get_reg_p (&cache
->cursor
, uw_regnum
, &intval
);
347 return frame_unwind_got_constant (this_frame
, regnum
, 0);
348 val
= frame_unwind_got_constant (this_frame
, regnum
, intval
);
350 set_value_optimized_out (val
, 1);
359 libunwind_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
361 struct libunwind_frame_cache
*cache
=
362 libunwind_frame_cache (this_frame
, this_cache
);
365 return (CORE_ADDR
)NULL
;
369 /* The following is a glue routine to call the libunwind unwind table
370 search function to get unwind information for a specified ip address. */
372 libunwind_search_unwind_table (void *as
, long ip
, void *di
,
373 void *pi
, int need_unwind_info
, void *args
)
375 return unw_search_unwind_table_p (*(unw_addr_space_t
*)as
, (unw_word_t
)ip
,
376 di
, pi
, need_unwind_info
, args
);
379 /* Verify if we are in a sigtramp frame and we can use libunwind to unwind. */
381 libunwind_sigtramp_frame_sniffer (const struct frame_unwind
*self
,
382 struct frame_info
*this_frame
,
386 unw_accessors_t
*acc
;
388 struct libunwind_descr
*descr
;
389 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
392 /* To test for libunwind unwind support, initialize a cursor to the
393 current frame and try to back up. We use this same method when
394 setting up the frame cache (see libunwind_frame_cache()). If
395 libunwind returns success for this operation, it means that it
396 has found sufficient libunwind unwinding information to do
399 descr
= libunwind_descr (gdbarch
);
400 acc
= descr
->accessors
;
401 as
= unw_create_addr_space_p (acc
,
402 gdbarch_byte_order (gdbarch
)
407 ret
= unw_init_remote_p (&cursor
, as
, this_frame
);
411 unw_destroy_addr_space_p (as
);
415 /* Check to see if we are in a signal frame. */
416 ret
= unw_is_signal_frame_p (&cursor
);
417 unw_destroy_addr_space_p (as
);
424 /* The following routine is for accessing special registers of the top frame.
425 A special set of accessors must be given that work without frame info.
426 This is used by ia64 to access the rse registers r32-r127. While they
427 are usually located at BOF, this is not always true and only the libunwind
428 info can decipher where they actually are. */
430 libunwind_get_reg_special (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
431 int regnum
, void *buf
)
434 unw_accessors_t
*acc
;
436 struct libunwind_descr
*descr
;
438 unw_regnum_t uw_regnum
;
444 descr
= libunwind_descr (gdbarch
);
445 acc
= descr
->special_accessors
;
446 as
= unw_create_addr_space_p (acc
,
447 gdbarch_byte_order (gdbarch
)
452 ret
= unw_init_remote_p (&cursor
, as
, regcache
);
455 unw_destroy_addr_space_p (as
);
459 uw_regnum
= descr
->gdb2uw (regnum
);
461 if (descr
->is_fpreg (uw_regnum
))
463 ret
= unw_get_fpreg_p (&cursor
, uw_regnum
, &fpval
);
468 ret
= unw_get_reg_p (&cursor
, uw_regnum
, &intval
);
472 unw_destroy_addr_space_p (as
);
478 memcpy (buf
, ptr
, register_size (gdbarch
, regnum
));
484 libunwind_load (void)
488 handle
= dlopen (LIBUNWIND_SO
, RTLD_NOW
);
492 /* Initialize pointers to the dynamic library functions we will use. */
494 unw_get_reg_p
= dlsym (handle
, get_reg_name
);
495 if (unw_get_reg_p
== NULL
)
498 unw_get_fpreg_p
= dlsym (handle
, get_fpreg_name
);
499 if (unw_get_fpreg_p
== NULL
)
502 unw_get_saveloc_p
= dlsym (handle
, get_saveloc_name
);
503 if (unw_get_saveloc_p
== NULL
)
506 unw_is_signal_frame_p
= dlsym (handle
, is_signal_frame_name
);
507 if (unw_is_signal_frame_p
== NULL
)
510 unw_step_p
= dlsym (handle
, step_name
);
511 if (unw_step_p
== NULL
)
514 unw_init_remote_p
= dlsym (handle
, init_remote_name
);
515 if (unw_init_remote_p
== NULL
)
518 unw_create_addr_space_p
= dlsym (handle
, create_addr_space_name
);
519 if (unw_create_addr_space_p
== NULL
)
522 unw_destroy_addr_space_p
= dlsym (handle
, destroy_addr_space_name
);
523 if (unw_destroy_addr_space_p
== NULL
)
526 unw_search_unwind_table_p
= dlsym (handle
, search_unwind_table_name
);
527 if (unw_search_unwind_table_p
== NULL
)
530 unw_find_dyn_list_p
= dlsym (handle
, find_dyn_list_name
);
531 if (unw_find_dyn_list_p
== NULL
)
538 libunwind_is_initialized (void)
540 return libunwind_initialized
;
543 /* Provide a prototype to silence -Wmissing-prototypes. */
544 void _initialize_libunwind_frame (void);
547 _initialize_libunwind_frame (void)
549 libunwind_descr_handle
= gdbarch_data_register_post_init (libunwind_descr_init
);
551 libunwind_initialized
= libunwind_load ();