1 /* Frame unwinder for frames using the libunwind library.
3 Copyright (C) 2003-2004, 2006-2012 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 /* IA-64 is the only target that currently uses libunwind-frame. Note
44 how UNW_TARGET, UNW_OBJ, etc. are compile time constants below.
45 Those come from libunwind's headers, and are target dependent.
46 Also, some of libunwind's typedefs are target dependent, as e.g.,
47 unw_word_t. If some other target wants to use this, we will need
48 to do some abstracting in order to make it possible to select which
49 libunwind we're talking to at runtime (and have one per arch). */
51 /* The following two macros are normally defined in <endian.h>.
52 But systems such as ia64-hpux do not provide such header, so
53 we just define them here if not already defined. */
54 #ifndef __LITTLE_ENDIAN
55 #define __LITTLE_ENDIAN 1234
58 #define __BIG_ENDIAN 4321
61 static int libunwind_initialized
;
62 static struct gdbarch_data
*libunwind_descr_handle
;
64 /* Required function pointers from libunwind. */
65 static int (*unw_get_reg_p
) (unw_cursor_t
*, unw_regnum_t
, unw_word_t
*);
66 static int (*unw_get_fpreg_p
) (unw_cursor_t
*, unw_regnum_t
, unw_fpreg_t
*);
67 static int (*unw_get_saveloc_p
) (unw_cursor_t
*, unw_regnum_t
,
69 static int (*unw_is_signal_frame_p
) (unw_cursor_t
*);
70 static int (*unw_step_p
) (unw_cursor_t
*);
71 static int (*unw_init_remote_p
) (unw_cursor_t
*, unw_addr_space_t
, void *);
72 static unw_addr_space_t (*unw_create_addr_space_p
) (unw_accessors_t
*, int);
73 static void (*unw_destroy_addr_space_p
) (unw_addr_space_t
);
74 static int (*unw_search_unwind_table_p
) (unw_addr_space_t
, unw_word_t
,
76 unw_proc_info_t
*, int, void *);
77 static unw_word_t (*unw_find_dyn_list_p
) (unw_addr_space_t
, unw_dyn_info_t
*,
81 struct libunwind_frame_cache
89 /* We need to qualify the function names with a platform-specific prefix
90 to match the names used by the libunwind library. The UNW_OBJ macro is
91 provided by the libunwind.h header file. */
92 #define STRINGIFY2(name) #name
93 #define STRINGIFY(name) STRINGIFY2(name)
96 /* Use the stable ABI major version number. `libunwind-ia64.so' is a link time
97 only library, not a runtime one. */
98 #define LIBUNWIND_SO "libunwind-" STRINGIFY(UNW_TARGET) ".so.7"
101 static char *get_reg_name
= STRINGIFY(UNW_OBJ(get_reg
));
102 static char *get_fpreg_name
= STRINGIFY(UNW_OBJ(get_fpreg
));
103 static char *get_saveloc_name
= STRINGIFY(UNW_OBJ(get_save_loc
));
104 static char *is_signal_frame_name
= STRINGIFY(UNW_OBJ(is_signal_frame
));
105 static char *step_name
= STRINGIFY(UNW_OBJ(step
));
106 static char *init_remote_name
= STRINGIFY(UNW_OBJ(init_remote
));
107 static char *create_addr_space_name
= STRINGIFY(UNW_OBJ(create_addr_space
));
108 static char *destroy_addr_space_name
= STRINGIFY(UNW_OBJ(destroy_addr_space
));
109 static char *search_unwind_table_name
110 = STRINGIFY(UNW_OBJ(search_unwind_table
));
111 static char *find_dyn_list_name
= STRINGIFY(UNW_OBJ(find_dyn_list
));
113 static struct libunwind_descr
*
114 libunwind_descr (struct gdbarch
*gdbarch
)
116 return gdbarch_data (gdbarch
, libunwind_descr_handle
);
120 libunwind_descr_init (struct gdbarch
*gdbarch
)
122 struct libunwind_descr
*descr
123 = GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct libunwind_descr
);
129 libunwind_frame_set_descr (struct gdbarch
*gdbarch
,
130 struct libunwind_descr
*descr
)
132 struct libunwind_descr
*arch_descr
;
134 gdb_assert (gdbarch
!= NULL
);
136 arch_descr
= gdbarch_data (gdbarch
, libunwind_descr_handle
);
138 if (arch_descr
== NULL
)
140 /* First time here. Must initialize data area. */
141 arch_descr
= libunwind_descr_init (gdbarch
);
142 deprecated_set_gdbarch_data (gdbarch
,
143 libunwind_descr_handle
, arch_descr
);
146 /* Copy new descriptor info into arch descriptor. */
147 arch_descr
->gdb2uw
= descr
->gdb2uw
;
148 arch_descr
->uw2gdb
= descr
->uw2gdb
;
149 arch_descr
->is_fpreg
= descr
->is_fpreg
;
150 arch_descr
->accessors
= descr
->accessors
;
151 arch_descr
->special_accessors
= descr
->special_accessors
;
154 static struct libunwind_frame_cache
*
155 libunwind_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
157 unw_accessors_t
*acc
;
160 unw_regnum_t uw_sp_regnum
;
161 struct libunwind_frame_cache
*cache
;
162 struct libunwind_descr
*descr
;
163 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
169 /* Allocate a new cache. */
170 cache
= FRAME_OBSTACK_ZALLOC (struct libunwind_frame_cache
);
172 cache
->func_addr
= get_frame_func (this_frame
);
173 if (cache
->func_addr
== 0)
174 /* This can happen when the frame corresponds to a function for which
175 there is no debugging information nor any entry in the symbol table.
176 This is probably a static function for which an entry in the symbol
177 table was not created when the objfile got linked (observed in
178 libpthread.so on ia64-hpux).
180 The best we can do, in that case, is use the frame PC as the function
181 address. We don't need to give up since we still have the unwind
182 record to help us perform the unwinding. There is also another
183 compelling to continue, because abandonning now means stopping
184 the backtrace, which can never be helpful for the user. */
185 cache
->func_addr
= get_frame_pc (this_frame
);
187 /* Get a libunwind cursor to the previous frame.
189 We do this by initializing a cursor. Libunwind treats a new cursor
190 as the top of stack and will get the current register set via the
191 libunwind register accessor. Now, we provide the platform-specific
192 accessors and we set up the register accessor to use the frame
193 register unwinding interfaces so that we properly get the registers
194 for the current frame rather than the top. We then use the unw_step
195 function to move the libunwind cursor back one frame. We can later
196 use this cursor to find previous registers via the unw_get_reg
197 interface which will invoke libunwind's special logic. */
198 descr
= libunwind_descr (gdbarch
);
199 acc
= descr
->accessors
;
200 as
= unw_create_addr_space_p (acc
,
201 gdbarch_byte_order (gdbarch
)
206 unw_init_remote_p (&cache
->cursor
, as
, this_frame
);
207 if (unw_step_p (&cache
->cursor
) < 0)
209 unw_destroy_addr_space_p (as
);
213 /* To get base address, get sp from previous frame. */
214 uw_sp_regnum
= descr
->gdb2uw (gdbarch_sp_regnum (gdbarch
));
215 ret
= unw_get_reg_p (&cache
->cursor
, uw_sp_regnum
, &fp
);
218 unw_destroy_addr_space_p (as
);
219 error (_("Can't get libunwind sp register."));
222 cache
->base
= (CORE_ADDR
)fp
;
230 libunwind_frame_dealloc_cache (struct frame_info
*self
, void *this_cache
)
232 struct libunwind_frame_cache
*cache
= this_cache
;
235 unw_destroy_addr_space_p (cache
->as
);
239 libunwind_find_dyn_list (unw_addr_space_t as
, unw_dyn_info_t
*di
, void *arg
)
241 return unw_find_dyn_list_p (as
, di
, arg
);
244 static const struct frame_unwind libunwind_frame_unwind
=
247 default_frame_unwind_stop_reason
,
248 libunwind_frame_this_id
,
249 libunwind_frame_prev_register
,
251 libunwind_frame_sniffer
,
252 libunwind_frame_dealloc_cache
,
255 /* Verify if there is sufficient libunwind information for the frame to use
256 libunwind frame unwinding. */
258 libunwind_frame_sniffer (const struct frame_unwind
*self
,
259 struct frame_info
*this_frame
, void **this_cache
)
262 unw_accessors_t
*acc
;
264 struct libunwind_descr
*descr
;
265 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
268 /* To test for libunwind unwind support, initialize a cursor to
269 the current frame and try to back up. We use this same method
270 when setting up the frame cache (see libunwind_frame_cache()).
271 If libunwind returns success for this operation, it means that
272 it has found sufficient libunwind unwinding information to do so. */
274 descr
= libunwind_descr (gdbarch
);
275 acc
= descr
->accessors
;
276 as
= unw_create_addr_space_p (acc
,
277 gdbarch_byte_order (gdbarch
)
282 ret
= unw_init_remote_p (&cursor
, as
, this_frame
);
286 unw_destroy_addr_space_p (as
);
291 /* Check to see if we have libunwind info by checking if we are in a
292 signal frame. If it doesn't return an error, we have libunwind info
293 and can use libunwind. */
294 ret
= unw_is_signal_frame_p (&cursor
);
295 unw_destroy_addr_space_p (as
);
304 libunwind_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
305 struct frame_id
*this_id
)
307 struct libunwind_frame_cache
*cache
=
308 libunwind_frame_cache (this_frame
, this_cache
);
311 (*this_id
) = frame_id_build (cache
->base
, cache
->func_addr
);
315 libunwind_frame_prev_register (struct frame_info
*this_frame
,
316 void **this_cache
, int regnum
)
318 struct libunwind_frame_cache
*cache
=
319 libunwind_frame_cache (this_frame
, this_cache
);
320 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
328 unw_regnum_t uw_regnum
;
329 struct libunwind_descr
*descr
;
330 struct value
*val
= NULL
;
333 return frame_unwind_got_constant (this_frame
, regnum
, 0);
335 /* Convert from gdb register number to libunwind register number. */
336 descr
= libunwind_descr (get_frame_arch (this_frame
));
337 uw_regnum
= descr
->gdb2uw (regnum
);
339 gdb_assert (regnum
>= 0);
341 if (!target_has_registers
)
342 error (_("No registers."));
345 return frame_unwind_got_constant (this_frame
, regnum
, 0);
347 if (unw_get_saveloc_p (&cache
->cursor
, uw_regnum
, &sl
) < 0)
348 return frame_unwind_got_constant (this_frame
, regnum
, 0);
353 val
= frame_unwind_got_memory (this_frame
, regnum
, sl
.u
.addr
);
357 val
= frame_unwind_got_register (this_frame
, regnum
,
358 descr
->uw2gdb (sl
.u
.regnum
));
362 /* The register is not stored at a specific memory address nor
363 inside another register. So use libunwind to fetch the register
364 value for us, and create a constant value with the result. */
365 if (descr
->is_fpreg (uw_regnum
))
367 ret
= unw_get_fpreg_p (&cache
->cursor
, uw_regnum
, &fpval
);
369 return frame_unwind_got_constant (this_frame
, regnum
, 0);
370 val
= frame_unwind_got_bytes (this_frame
, regnum
,
371 (gdb_byte
*) &fpval
);
375 ret
= unw_get_reg_p (&cache
->cursor
, uw_regnum
, &intval
);
377 return frame_unwind_got_constant (this_frame
, regnum
, 0);
378 val
= frame_unwind_got_constant (this_frame
, regnum
, intval
);
388 libunwind_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
390 struct libunwind_frame_cache
*cache
=
391 libunwind_frame_cache (this_frame
, this_cache
);
394 return (CORE_ADDR
)NULL
;
398 /* The following is a glue routine to call the libunwind unwind table
399 search function to get unwind information for a specified ip address. */
401 libunwind_search_unwind_table (void *as
, long ip
, void *di
,
402 void *pi
, int need_unwind_info
, void *args
)
404 return unw_search_unwind_table_p (*(unw_addr_space_t
*)as
, (unw_word_t
)ip
,
405 di
, pi
, need_unwind_info
, args
);
408 /* Verify if we are in a sigtramp frame and we can use libunwind to unwind. */
410 libunwind_sigtramp_frame_sniffer (const struct frame_unwind
*self
,
411 struct frame_info
*this_frame
,
415 unw_accessors_t
*acc
;
417 struct libunwind_descr
*descr
;
418 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
421 /* To test for libunwind unwind support, initialize a cursor to the
422 current frame and try to back up. We use this same method when
423 setting up the frame cache (see libunwind_frame_cache()). If
424 libunwind returns success for this operation, it means that it
425 has found sufficient libunwind unwinding information to do
428 descr
= libunwind_descr (gdbarch
);
429 acc
= descr
->accessors
;
430 as
= unw_create_addr_space_p (acc
,
431 gdbarch_byte_order (gdbarch
)
436 ret
= unw_init_remote_p (&cursor
, as
, this_frame
);
440 unw_destroy_addr_space_p (as
);
444 /* Check to see if we are in a signal frame. */
445 ret
= unw_is_signal_frame_p (&cursor
);
446 unw_destroy_addr_space_p (as
);
453 /* The following routine is for accessing special registers of the top frame.
454 A special set of accessors must be given that work without frame info.
455 This is used by ia64 to access the rse registers r32-r127. While they
456 are usually located at BOF, this is not always true and only the libunwind
457 info can decipher where they actually are. */
459 libunwind_get_reg_special (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
460 int regnum
, void *buf
)
463 unw_accessors_t
*acc
;
465 struct libunwind_descr
*descr
;
467 unw_regnum_t uw_regnum
;
473 descr
= libunwind_descr (gdbarch
);
474 acc
= descr
->special_accessors
;
475 as
= unw_create_addr_space_p (acc
,
476 gdbarch_byte_order (gdbarch
)
481 ret
= unw_init_remote_p (&cursor
, as
, regcache
);
484 unw_destroy_addr_space_p (as
);
488 uw_regnum
= descr
->gdb2uw (regnum
);
490 if (descr
->is_fpreg (uw_regnum
))
492 ret
= unw_get_fpreg_p (&cursor
, uw_regnum
, &fpval
);
497 ret
= unw_get_reg_p (&cursor
, uw_regnum
, &intval
);
501 unw_destroy_addr_space_p (as
);
507 memcpy (buf
, ptr
, register_size (gdbarch
, regnum
));
513 libunwind_load (void)
517 handle
= dlopen (LIBUNWIND_SO
, RTLD_NOW
);
520 fprintf_unfiltered (gdb_stderr
, _("[GDB failed to load %s: %s]\n"),
521 LIBUNWIND_SO
, dlerror ());
525 /* Initialize pointers to the dynamic library functions we will use. */
527 unw_get_reg_p
= dlsym (handle
, get_reg_name
);
528 if (unw_get_reg_p
== NULL
)
531 unw_get_fpreg_p
= dlsym (handle
, get_fpreg_name
);
532 if (unw_get_fpreg_p
== NULL
)
535 unw_get_saveloc_p
= dlsym (handle
, get_saveloc_name
);
536 if (unw_get_saveloc_p
== NULL
)
539 unw_is_signal_frame_p
= dlsym (handle
, is_signal_frame_name
);
540 if (unw_is_signal_frame_p
== NULL
)
543 unw_step_p
= dlsym (handle
, step_name
);
544 if (unw_step_p
== NULL
)
547 unw_init_remote_p
= dlsym (handle
, init_remote_name
);
548 if (unw_init_remote_p
== NULL
)
551 unw_create_addr_space_p
= dlsym (handle
, create_addr_space_name
);
552 if (unw_create_addr_space_p
== NULL
)
555 unw_destroy_addr_space_p
= dlsym (handle
, destroy_addr_space_name
);
556 if (unw_destroy_addr_space_p
== NULL
)
559 unw_search_unwind_table_p
= dlsym (handle
, search_unwind_table_name
);
560 if (unw_search_unwind_table_p
== NULL
)
563 unw_find_dyn_list_p
= dlsym (handle
, find_dyn_list_name
);
564 if (unw_find_dyn_list_p
== NULL
)
571 libunwind_is_initialized (void)
573 return libunwind_initialized
;
576 /* Provide a prototype to silence -Wmissing-prototypes. */
577 void _initialize_libunwind_frame (void);
580 _initialize_libunwind_frame (void)
582 libunwind_descr_handle
583 = gdbarch_data_register_post_init (libunwind_descr_init
);
585 libunwind_initialized
= libunwind_load ();