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 /* The following two macros are normally defined in <endian.h>.
44 But systems such as ia64-hpux do not provide such header, so
45 we just define them here if not already defined. */
46 #ifndef __LITTLE_ENDIAN
47 #define __LITTLE_ENDIAN 1234
50 #define __BIG_ENDIAN 4321
53 static int libunwind_initialized
;
54 static struct gdbarch_data
*libunwind_descr_handle
;
56 /* Required function pointers from libunwind. */
57 static int (*unw_get_reg_p
) (unw_cursor_t
*, unw_regnum_t
, unw_word_t
*);
58 static int (*unw_get_fpreg_p
) (unw_cursor_t
*, unw_regnum_t
, unw_fpreg_t
*);
59 static int (*unw_get_saveloc_p
) (unw_cursor_t
*, unw_regnum_t
,
61 static int (*unw_is_signal_frame_p
) (unw_cursor_t
*);
62 static int (*unw_step_p
) (unw_cursor_t
*);
63 static int (*unw_init_remote_p
) (unw_cursor_t
*, unw_addr_space_t
, void *);
64 static unw_addr_space_t (*unw_create_addr_space_p
) (unw_accessors_t
*, int);
65 static void (*unw_destroy_addr_space_p
) (unw_addr_space_t
);
66 static int (*unw_search_unwind_table_p
) (unw_addr_space_t
, unw_word_t
,
68 unw_proc_info_t
*, int, void *);
69 static unw_word_t (*unw_find_dyn_list_p
) (unw_addr_space_t
, unw_dyn_info_t
*,
73 struct libunwind_frame_cache
81 /* We need to qualify the function names with a platform-specific prefix
82 to match the names used by the libunwind library. The UNW_OBJ macro is
83 provided by the libunwind.h header file. */
84 #define STRINGIFY2(name) #name
85 #define STRINGIFY(name) STRINGIFY2(name)
88 /* Use the stable ABI major version number. `libunwind-ia64.so' is a link time
89 only library, not a runtime one. */
90 #define LIBUNWIND_SO "libunwind-" STRINGIFY(UNW_TARGET) ".so.7"
93 static char *get_reg_name
= STRINGIFY(UNW_OBJ(get_reg
));
94 static char *get_fpreg_name
= STRINGIFY(UNW_OBJ(get_fpreg
));
95 static char *get_saveloc_name
= STRINGIFY(UNW_OBJ(get_save_loc
));
96 static char *is_signal_frame_name
= STRINGIFY(UNW_OBJ(is_signal_frame
));
97 static char *step_name
= STRINGIFY(UNW_OBJ(step
));
98 static char *init_remote_name
= STRINGIFY(UNW_OBJ(init_remote
));
99 static char *create_addr_space_name
= STRINGIFY(UNW_OBJ(create_addr_space
));
100 static char *destroy_addr_space_name
= STRINGIFY(UNW_OBJ(destroy_addr_space
));
101 static char *search_unwind_table_name
102 = STRINGIFY(UNW_OBJ(search_unwind_table
));
103 static char *find_dyn_list_name
= STRINGIFY(UNW_OBJ(find_dyn_list
));
105 static struct libunwind_descr
*
106 libunwind_descr (struct gdbarch
*gdbarch
)
108 return gdbarch_data (gdbarch
, libunwind_descr_handle
);
112 libunwind_descr_init (struct gdbarch
*gdbarch
)
114 struct libunwind_descr
*descr
115 = GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct libunwind_descr
);
121 libunwind_frame_set_descr (struct gdbarch
*gdbarch
,
122 struct libunwind_descr
*descr
)
124 struct libunwind_descr
*arch_descr
;
126 gdb_assert (gdbarch
!= NULL
);
128 arch_descr
= gdbarch_data (gdbarch
, libunwind_descr_handle
);
130 if (arch_descr
== NULL
)
132 /* First time here. Must initialize data area. */
133 arch_descr
= libunwind_descr_init (gdbarch
);
134 deprecated_set_gdbarch_data (gdbarch
,
135 libunwind_descr_handle
, arch_descr
);
138 /* Copy new descriptor info into arch descriptor. */
139 arch_descr
->gdb2uw
= descr
->gdb2uw
;
140 arch_descr
->uw2gdb
= descr
->uw2gdb
;
141 arch_descr
->is_fpreg
= descr
->is_fpreg
;
142 arch_descr
->accessors
= descr
->accessors
;
143 arch_descr
->special_accessors
= descr
->special_accessors
;
146 static struct libunwind_frame_cache
*
147 libunwind_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
149 unw_accessors_t
*acc
;
152 unw_regnum_t uw_sp_regnum
;
153 struct libunwind_frame_cache
*cache
;
154 struct libunwind_descr
*descr
;
155 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
161 /* Allocate a new cache. */
162 cache
= FRAME_OBSTACK_ZALLOC (struct libunwind_frame_cache
);
164 cache
->func_addr
= get_frame_func (this_frame
);
165 if (cache
->func_addr
== 0)
166 /* This can happen when the frame corresponds to a function for which
167 there is no debugging information nor any entry in the symbol table.
168 This is probably a static function for which an entry in the symbol
169 table was not created when the objfile got linked (observed in
170 libpthread.so on ia64-hpux).
172 The best we can do, in that case, is use the frame PC as the function
173 address. We don't need to give up since we still have the unwind
174 record to help us perform the unwinding. There is also another
175 compelling to continue, because abandonning now means stopping
176 the backtrace, which can never be helpful for the user. */
177 cache
->func_addr
= get_frame_pc (this_frame
);
179 /* Get a libunwind cursor to the previous frame.
181 We do this by initializing a cursor. Libunwind treats a new cursor
182 as the top of stack and will get the current register set via the
183 libunwind register accessor. Now, we provide the platform-specific
184 accessors and we set up the register accessor to use the frame
185 register unwinding interfaces so that we properly get the registers
186 for the current frame rather than the top. We then use the unw_step
187 function to move the libunwind cursor back one frame. We can later
188 use this cursor to find previous registers via the unw_get_reg
189 interface which will invoke libunwind's special logic. */
190 descr
= libunwind_descr (gdbarch
);
191 acc
= descr
->accessors
;
192 as
= unw_create_addr_space_p (acc
,
193 gdbarch_byte_order (gdbarch
)
198 unw_init_remote_p (&cache
->cursor
, as
, this_frame
);
199 if (unw_step_p (&cache
->cursor
) < 0)
201 unw_destroy_addr_space_p (as
);
205 /* To get base address, get sp from previous frame. */
206 uw_sp_regnum
= descr
->gdb2uw (gdbarch_sp_regnum (gdbarch
));
207 ret
= unw_get_reg_p (&cache
->cursor
, uw_sp_regnum
, &fp
);
210 unw_destroy_addr_space_p (as
);
211 error (_("Can't get libunwind sp register."));
214 cache
->base
= (CORE_ADDR
)fp
;
222 libunwind_frame_dealloc_cache (struct frame_info
*self
, void *this_cache
)
224 struct libunwind_frame_cache
*cache
= this_cache
;
227 unw_destroy_addr_space_p (cache
->as
);
231 libunwind_find_dyn_list (unw_addr_space_t as
, unw_dyn_info_t
*di
, void *arg
)
233 return unw_find_dyn_list_p (as
, di
, arg
);
236 static const struct frame_unwind libunwind_frame_unwind
=
239 default_frame_unwind_stop_reason
,
240 libunwind_frame_this_id
,
241 libunwind_frame_prev_register
,
243 libunwind_frame_sniffer
,
244 libunwind_frame_dealloc_cache
,
247 /* Verify if there is sufficient libunwind information for the frame to use
248 libunwind frame unwinding. */
250 libunwind_frame_sniffer (const struct frame_unwind
*self
,
251 struct frame_info
*this_frame
, void **this_cache
)
254 unw_accessors_t
*acc
;
256 struct libunwind_descr
*descr
;
257 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
260 /* To test for libunwind unwind support, initialize a cursor to
261 the current frame and try to back up. We use this same method
262 when setting up the frame cache (see libunwind_frame_cache()).
263 If libunwind returns success for this operation, it means that
264 it has found sufficient libunwind unwinding information to do so. */
266 descr
= libunwind_descr (gdbarch
);
267 acc
= descr
->accessors
;
268 as
= unw_create_addr_space_p (acc
,
269 gdbarch_byte_order (gdbarch
)
274 ret
= unw_init_remote_p (&cursor
, as
, this_frame
);
278 unw_destroy_addr_space_p (as
);
283 /* Check to see if we have libunwind info by checking if we are in a
284 signal frame. If it doesn't return an error, we have libunwind info
285 and can use libunwind. */
286 ret
= unw_is_signal_frame_p (&cursor
);
287 unw_destroy_addr_space_p (as
);
296 libunwind_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
297 struct frame_id
*this_id
)
299 struct libunwind_frame_cache
*cache
=
300 libunwind_frame_cache (this_frame
, this_cache
);
303 (*this_id
) = frame_id_build (cache
->base
, cache
->func_addr
);
307 libunwind_frame_prev_register (struct frame_info
*this_frame
,
308 void **this_cache
, int regnum
)
310 struct libunwind_frame_cache
*cache
=
311 libunwind_frame_cache (this_frame
, this_cache
);
312 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
320 unw_regnum_t uw_regnum
;
321 struct libunwind_descr
*descr
;
322 struct value
*val
= NULL
;
325 return frame_unwind_got_constant (this_frame
, regnum
, 0);
327 /* Convert from gdb register number to libunwind register number. */
328 descr
= libunwind_descr (get_frame_arch (this_frame
));
329 uw_regnum
= descr
->gdb2uw (regnum
);
331 gdb_assert (regnum
>= 0);
333 if (!target_has_registers
)
334 error (_("No registers."));
337 return frame_unwind_got_constant (this_frame
, regnum
, 0);
339 if (unw_get_saveloc_p (&cache
->cursor
, uw_regnum
, &sl
) < 0)
340 return frame_unwind_got_constant (this_frame
, regnum
, 0);
345 val
= frame_unwind_got_memory (this_frame
, regnum
, sl
.u
.addr
);
349 val
= frame_unwind_got_register (this_frame
, regnum
,
350 descr
->uw2gdb (sl
.u
.regnum
));
354 /* The register is not stored at a specific memory address nor
355 inside another register. So use libunwind to fetch the register
356 value for us, and create a constant value with the result. */
357 if (descr
->is_fpreg (uw_regnum
))
359 ret
= unw_get_fpreg_p (&cache
->cursor
, uw_regnum
, &fpval
);
361 return frame_unwind_got_constant (this_frame
, regnum
, 0);
362 val
= frame_unwind_got_bytes (this_frame
, regnum
,
363 (gdb_byte
*) &fpval
);
367 ret
= unw_get_reg_p (&cache
->cursor
, uw_regnum
, &intval
);
369 return frame_unwind_got_constant (this_frame
, regnum
, 0);
370 val
= frame_unwind_got_constant (this_frame
, regnum
, intval
);
380 libunwind_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
382 struct libunwind_frame_cache
*cache
=
383 libunwind_frame_cache (this_frame
, this_cache
);
386 return (CORE_ADDR
)NULL
;
390 /* The following is a glue routine to call the libunwind unwind table
391 search function to get unwind information for a specified ip address. */
393 libunwind_search_unwind_table (void *as
, long ip
, void *di
,
394 void *pi
, int need_unwind_info
, void *args
)
396 return unw_search_unwind_table_p (*(unw_addr_space_t
*)as
, (unw_word_t
)ip
,
397 di
, pi
, need_unwind_info
, args
);
400 /* Verify if we are in a sigtramp frame and we can use libunwind to unwind. */
402 libunwind_sigtramp_frame_sniffer (const struct frame_unwind
*self
,
403 struct frame_info
*this_frame
,
407 unw_accessors_t
*acc
;
409 struct libunwind_descr
*descr
;
410 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
413 /* To test for libunwind unwind support, initialize a cursor to the
414 current frame and try to back up. We use this same method when
415 setting up the frame cache (see libunwind_frame_cache()). If
416 libunwind returns success for this operation, it means that it
417 has found sufficient libunwind unwinding information to do
420 descr
= libunwind_descr (gdbarch
);
421 acc
= descr
->accessors
;
422 as
= unw_create_addr_space_p (acc
,
423 gdbarch_byte_order (gdbarch
)
428 ret
= unw_init_remote_p (&cursor
, as
, this_frame
);
432 unw_destroy_addr_space_p (as
);
436 /* Check to see if we are in a signal frame. */
437 ret
= unw_is_signal_frame_p (&cursor
);
438 unw_destroy_addr_space_p (as
);
445 /* The following routine is for accessing special registers of the top frame.
446 A special set of accessors must be given that work without frame info.
447 This is used by ia64 to access the rse registers r32-r127. While they
448 are usually located at BOF, this is not always true and only the libunwind
449 info can decipher where they actually are. */
451 libunwind_get_reg_special (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
452 int regnum
, void *buf
)
455 unw_accessors_t
*acc
;
457 struct libunwind_descr
*descr
;
459 unw_regnum_t uw_regnum
;
465 descr
= libunwind_descr (gdbarch
);
466 acc
= descr
->special_accessors
;
467 as
= unw_create_addr_space_p (acc
,
468 gdbarch_byte_order (gdbarch
)
473 ret
= unw_init_remote_p (&cursor
, as
, regcache
);
476 unw_destroy_addr_space_p (as
);
480 uw_regnum
= descr
->gdb2uw (regnum
);
482 if (descr
->is_fpreg (uw_regnum
))
484 ret
= unw_get_fpreg_p (&cursor
, uw_regnum
, &fpval
);
489 ret
= unw_get_reg_p (&cursor
, uw_regnum
, &intval
);
493 unw_destroy_addr_space_p (as
);
499 memcpy (buf
, ptr
, register_size (gdbarch
, regnum
));
505 libunwind_load (void)
509 handle
= dlopen (LIBUNWIND_SO
, RTLD_NOW
);
513 /* Initialize pointers to the dynamic library functions we will use. */
515 unw_get_reg_p
= dlsym (handle
, get_reg_name
);
516 if (unw_get_reg_p
== NULL
)
519 unw_get_fpreg_p
= dlsym (handle
, get_fpreg_name
);
520 if (unw_get_fpreg_p
== NULL
)
523 unw_get_saveloc_p
= dlsym (handle
, get_saveloc_name
);
524 if (unw_get_saveloc_p
== NULL
)
527 unw_is_signal_frame_p
= dlsym (handle
, is_signal_frame_name
);
528 if (unw_is_signal_frame_p
== NULL
)
531 unw_step_p
= dlsym (handle
, step_name
);
532 if (unw_step_p
== NULL
)
535 unw_init_remote_p
= dlsym (handle
, init_remote_name
);
536 if (unw_init_remote_p
== NULL
)
539 unw_create_addr_space_p
= dlsym (handle
, create_addr_space_name
);
540 if (unw_create_addr_space_p
== NULL
)
543 unw_destroy_addr_space_p
= dlsym (handle
, destroy_addr_space_name
);
544 if (unw_destroy_addr_space_p
== NULL
)
547 unw_search_unwind_table_p
= dlsym (handle
, search_unwind_table_name
);
548 if (unw_search_unwind_table_p
== NULL
)
551 unw_find_dyn_list_p
= dlsym (handle
, find_dyn_list_name
);
552 if (unw_find_dyn_list_p
== NULL
)
559 libunwind_is_initialized (void)
561 return libunwind_initialized
;
564 /* Provide a prototype to silence -Wmissing-prototypes. */
565 void _initialize_libunwind_frame (void);
568 _initialize_libunwind_frame (void)
570 libunwind_descr_handle
571 = gdbarch_data_register_post_init (libunwind_descr_init
);
573 libunwind_initialized
= libunwind_load ();