1 /* Frame unwinder for ia64 frames using the libunwind library.
3 Copyright (C) 2003-2018 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 "ia64-libunwind-tdep.h"
38 #include "complaints.h"
39 #include "common/preprocessor.h"
41 /* IA-64 is the only target that currently uses ia64-libunwind-tdep.
42 Note how UNW_TARGET, UNW_OBJ, etc. are compile time constants below.
43 Those come from libunwind's headers, and are target dependent.
44 Also, some of libunwind's typedefs are target dependent, as e.g.,
45 unw_word_t. If some other target wants to use this, we will need
46 to do some abstracting in order to make it possible to select which
47 libunwind we're talking to at runtime (and have one per arch). */
49 /* The following two macros are normally defined in <endian.h>.
50 But systems such as ia64-hpux do not provide such header, so
51 we just define them here if not already defined. */
52 #ifndef __LITTLE_ENDIAN
53 #define __LITTLE_ENDIAN 1234
56 #define __BIG_ENDIAN 4321
59 static int libunwind_initialized
;
60 static struct gdbarch_data
*libunwind_descr_handle
;
62 /* Required function pointers from libunwind. */
63 typedef int (unw_get_reg_p_ftype
) (unw_cursor_t
*, unw_regnum_t
, unw_word_t
*);
64 static unw_get_reg_p_ftype
*unw_get_reg_p
;
65 typedef int (unw_get_fpreg_p_ftype
) (unw_cursor_t
*, unw_regnum_t
,
67 static unw_get_fpreg_p_ftype
*unw_get_fpreg_p
;
68 typedef int (unw_get_saveloc_p_ftype
) (unw_cursor_t
*, unw_regnum_t
,
70 static unw_get_saveloc_p_ftype
*unw_get_saveloc_p
;
71 typedef int (unw_is_signal_frame_p_ftype
) (unw_cursor_t
*);
72 static unw_is_signal_frame_p_ftype
*unw_is_signal_frame_p
;
73 typedef int (unw_step_p_ftype
) (unw_cursor_t
*);
74 static unw_step_p_ftype
*unw_step_p
;
75 typedef int (unw_init_remote_p_ftype
) (unw_cursor_t
*, unw_addr_space_t
,
77 static unw_init_remote_p_ftype
*unw_init_remote_p
;
78 typedef unw_addr_space_t (unw_create_addr_space_p_ftype
) (unw_accessors_t
*,
80 static unw_create_addr_space_p_ftype
*unw_create_addr_space_p
;
81 typedef void (unw_destroy_addr_space_p_ftype
) (unw_addr_space_t
);
82 static unw_destroy_addr_space_p_ftype
*unw_destroy_addr_space_p
;
83 typedef int (unw_search_unwind_table_p_ftype
) (unw_addr_space_t
, unw_word_t
,
85 unw_proc_info_t
*, int, void *);
86 static unw_search_unwind_table_p_ftype
*unw_search_unwind_table_p
;
87 typedef unw_word_t (unw_find_dyn_list_p_ftype
) (unw_addr_space_t
,
88 unw_dyn_info_t
*, void *);
89 static unw_find_dyn_list_p_ftype
*unw_find_dyn_list_p
;
92 struct libunwind_frame_cache
100 /* We need to qualify the function names with a platform-specific prefix
101 to match the names used by the libunwind library. The UNW_OBJ macro is
102 provided by the libunwind.h header file. */
105 /* Use the stable ABI major version number. `libunwind-ia64.so' is a link time
106 only library, not a runtime one. */
107 #define LIBUNWIND_SO "libunwind-" STRINGIFY(UNW_TARGET) ".so.8"
109 /* Provide also compatibility with older .so. The two APIs are compatible, .8
110 is only extended a bit, GDB does not use the extended API at all. */
111 #define LIBUNWIND_SO_7 "libunwind-" STRINGIFY(UNW_TARGET) ".so.7"
114 static const char *get_reg_name
= STRINGIFY(UNW_OBJ(get_reg
));
115 static const char *get_fpreg_name
= STRINGIFY(UNW_OBJ(get_fpreg
));
116 static const char *get_saveloc_name
= STRINGIFY(UNW_OBJ(get_save_loc
));
117 static const char *is_signal_frame_name
= STRINGIFY(UNW_OBJ(is_signal_frame
));
118 static const char *step_name
= STRINGIFY(UNW_OBJ(step
));
119 static const char *init_remote_name
= STRINGIFY(UNW_OBJ(init_remote
));
120 static const char *create_addr_space_name
121 = STRINGIFY(UNW_OBJ(create_addr_space
));
122 static const char *destroy_addr_space_name
123 = STRINGIFY(UNW_OBJ(destroy_addr_space
));
124 static const char *search_unwind_table_name
125 = STRINGIFY(UNW_OBJ(search_unwind_table
));
126 static const char *find_dyn_list_name
= STRINGIFY(UNW_OBJ(find_dyn_list
));
128 static struct libunwind_descr
*
129 libunwind_descr (struct gdbarch
*gdbarch
)
131 return ((struct libunwind_descr
*)
132 gdbarch_data (gdbarch
, libunwind_descr_handle
));
136 libunwind_descr_init (struct gdbarch
*gdbarch
)
138 struct libunwind_descr
*descr
139 = GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct libunwind_descr
);
145 libunwind_frame_set_descr (struct gdbarch
*gdbarch
,
146 struct libunwind_descr
*descr
)
148 struct libunwind_descr
*arch_descr
;
150 gdb_assert (gdbarch
!= NULL
);
152 arch_descr
= ((struct libunwind_descr
*)
153 gdbarch_data (gdbarch
, libunwind_descr_handle
));
155 if (arch_descr
== NULL
)
157 /* First time here. Must initialize data area. */
158 arch_descr
= (struct libunwind_descr
*) libunwind_descr_init (gdbarch
);
159 deprecated_set_gdbarch_data (gdbarch
,
160 libunwind_descr_handle
, arch_descr
);
163 /* Copy new descriptor info into arch descriptor. */
164 arch_descr
->gdb2uw
= descr
->gdb2uw
;
165 arch_descr
->uw2gdb
= descr
->uw2gdb
;
166 arch_descr
->is_fpreg
= descr
->is_fpreg
;
167 arch_descr
->accessors
= descr
->accessors
;
168 arch_descr
->special_accessors
= descr
->special_accessors
;
171 static struct libunwind_frame_cache
*
172 libunwind_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
174 unw_accessors_t
*acc
;
177 unw_regnum_t uw_sp_regnum
;
178 struct libunwind_frame_cache
*cache
;
179 struct libunwind_descr
*descr
;
180 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
184 return (struct libunwind_frame_cache
*) *this_cache
;
186 /* Allocate a new cache. */
187 cache
= FRAME_OBSTACK_ZALLOC (struct libunwind_frame_cache
);
189 cache
->func_addr
= get_frame_func (this_frame
);
190 if (cache
->func_addr
== 0)
191 /* This can happen when the frame corresponds to a function for which
192 there is no debugging information nor any entry in the symbol table.
193 This is probably a static function for which an entry in the symbol
194 table was not created when the objfile got linked (observed in
195 libpthread.so on ia64-hpux).
197 The best we can do, in that case, is use the frame PC as the function
198 address. We don't need to give up since we still have the unwind
199 record to help us perform the unwinding. There is also another
200 compelling to continue, because abandonning now means stopping
201 the backtrace, which can never be helpful for the user. */
202 cache
->func_addr
= get_frame_pc (this_frame
);
204 /* Get a libunwind cursor to the previous frame.
206 We do this by initializing a cursor. Libunwind treats a new cursor
207 as the top of stack and will get the current register set via the
208 libunwind register accessor. Now, we provide the platform-specific
209 accessors and we set up the register accessor to use the frame
210 register unwinding interfaces so that we properly get the registers
211 for the current frame rather than the top. We then use the unw_step
212 function to move the libunwind cursor back one frame. We can later
213 use this cursor to find previous registers via the unw_get_reg
214 interface which will invoke libunwind's special logic. */
215 descr
= libunwind_descr (gdbarch
);
216 acc
= (unw_accessors_t
*) descr
->accessors
;
217 as
= unw_create_addr_space_p (acc
,
218 gdbarch_byte_order (gdbarch
)
223 unw_init_remote_p (&cache
->cursor
, as
, this_frame
);
224 if (unw_step_p (&cache
->cursor
) < 0)
226 unw_destroy_addr_space_p (as
);
230 /* To get base address, get sp from previous frame. */
231 uw_sp_regnum
= descr
->gdb2uw (gdbarch_sp_regnum (gdbarch
));
232 ret
= unw_get_reg_p (&cache
->cursor
, uw_sp_regnum
, &fp
);
235 unw_destroy_addr_space_p (as
);
236 error (_("Can't get libunwind sp register."));
239 cache
->base
= (CORE_ADDR
)fp
;
247 libunwind_frame_dealloc_cache (struct frame_info
*self
, void *this_cache
)
249 struct libunwind_frame_cache
*cache
250 = (struct libunwind_frame_cache
*) this_cache
;
253 unw_destroy_addr_space_p (cache
->as
);
257 libunwind_find_dyn_list (unw_addr_space_t as
, unw_dyn_info_t
*di
, void *arg
)
259 return unw_find_dyn_list_p (as
, di
, arg
);
262 /* Verify if there is sufficient libunwind information for the frame to use
263 libunwind frame unwinding. */
265 libunwind_frame_sniffer (const struct frame_unwind
*self
,
266 struct frame_info
*this_frame
, void **this_cache
)
269 unw_accessors_t
*acc
;
271 struct libunwind_descr
*descr
;
272 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
275 /* To test for libunwind unwind support, initialize a cursor to
276 the current frame and try to back up. We use this same method
277 when setting up the frame cache (see libunwind_frame_cache()).
278 If libunwind returns success for this operation, it means that
279 it has found sufficient libunwind unwinding information to do so. */
281 descr
= libunwind_descr (gdbarch
);
282 acc
= (unw_accessors_t
*) descr
->accessors
;
283 as
= unw_create_addr_space_p (acc
,
284 gdbarch_byte_order (gdbarch
)
289 ret
= unw_init_remote_p (&cursor
, as
, this_frame
);
293 unw_destroy_addr_space_p (as
);
298 /* Check to see if we have libunwind info by checking if we are in a
299 signal frame. If it doesn't return an error, we have libunwind info
300 and can use libunwind. */
301 ret
= unw_is_signal_frame_p (&cursor
);
302 unw_destroy_addr_space_p (as
);
311 libunwind_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
312 struct frame_id
*this_id
)
314 struct libunwind_frame_cache
*cache
=
315 libunwind_frame_cache (this_frame
, this_cache
);
318 (*this_id
) = frame_id_build (cache
->base
, cache
->func_addr
);
322 libunwind_frame_prev_register (struct frame_info
*this_frame
,
323 void **this_cache
, int regnum
)
325 struct libunwind_frame_cache
*cache
=
326 libunwind_frame_cache (this_frame
, this_cache
);
327 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
335 unw_regnum_t uw_regnum
;
336 struct libunwind_descr
*descr
;
337 struct value
*val
= NULL
;
340 return frame_unwind_got_constant (this_frame
, regnum
, 0);
342 /* Convert from gdb register number to libunwind register number. */
343 descr
= libunwind_descr (get_frame_arch (this_frame
));
344 uw_regnum
= descr
->gdb2uw (regnum
);
346 gdb_assert (regnum
>= 0);
348 if (!target_has_registers
)
349 error (_("No registers."));
352 return frame_unwind_got_constant (this_frame
, regnum
, 0);
354 if (unw_get_saveloc_p (&cache
->cursor
, uw_regnum
, &sl
) < 0)
355 return frame_unwind_got_constant (this_frame
, regnum
, 0);
360 val
= frame_unwind_got_memory (this_frame
, regnum
, sl
.u
.addr
);
364 val
= frame_unwind_got_register (this_frame
, regnum
,
365 descr
->uw2gdb (sl
.u
.regnum
));
369 /* The register is not stored at a specific memory address nor
370 inside another register. So use libunwind to fetch the register
371 value for us, and create a constant value with the result. */
372 if (descr
->is_fpreg (uw_regnum
))
374 ret
= unw_get_fpreg_p (&cache
->cursor
, uw_regnum
, &fpval
);
376 return frame_unwind_got_constant (this_frame
, regnum
, 0);
377 val
= frame_unwind_got_bytes (this_frame
, regnum
,
378 (gdb_byte
*) &fpval
);
382 ret
= unw_get_reg_p (&cache
->cursor
, uw_regnum
, &intval
);
384 return frame_unwind_got_constant (this_frame
, regnum
, 0);
385 val
= frame_unwind_got_constant (this_frame
, regnum
, intval
);
394 /* The following is a glue routine to call the libunwind unwind table
395 search function to get unwind information for a specified ip address. */
397 libunwind_search_unwind_table (void *as
, long ip
, void *di
,
398 void *pi
, int need_unwind_info
, void *args
)
400 return unw_search_unwind_table_p (*(unw_addr_space_t
*) as
, (unw_word_t
) ip
,
401 (unw_dyn_info_t
*) di
,
402 (unw_proc_info_t
*) pi
, need_unwind_info
,
406 /* Verify if we are in a sigtramp frame and we can use libunwind to unwind. */
408 libunwind_sigtramp_frame_sniffer (const struct frame_unwind
*self
,
409 struct frame_info
*this_frame
,
413 unw_accessors_t
*acc
;
415 struct libunwind_descr
*descr
;
416 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
419 /* To test for libunwind unwind support, initialize a cursor to the
420 current frame and try to back up. We use this same method when
421 setting up the frame cache (see libunwind_frame_cache()). If
422 libunwind returns success for this operation, it means that it
423 has found sufficient libunwind unwinding information to do
426 descr
= libunwind_descr (gdbarch
);
427 acc
= (unw_accessors_t
*) descr
->accessors
;
428 as
= unw_create_addr_space_p (acc
,
429 gdbarch_byte_order (gdbarch
)
434 ret
= unw_init_remote_p (&cursor
, as
, this_frame
);
438 unw_destroy_addr_space_p (as
);
442 /* Check to see if we are in a signal frame. */
443 ret
= unw_is_signal_frame_p (&cursor
);
444 unw_destroy_addr_space_p (as
);
451 /* The following routine is for accessing special registers of the top frame.
452 A special set of accessors must be given that work without frame info.
453 This is used by ia64 to access the rse registers r32-r127. While they
454 are usually located at BOF, this is not always true and only the libunwind
455 info can decipher where they actually are. */
457 libunwind_get_reg_special (struct gdbarch
*gdbarch
, readable_regcache
*regcache
,
458 int regnum
, void *buf
)
461 unw_accessors_t
*acc
;
463 struct libunwind_descr
*descr
;
465 unw_regnum_t uw_regnum
;
471 descr
= libunwind_descr (gdbarch
);
472 acc
= (unw_accessors_t
*) descr
->special_accessors
;
473 as
= unw_create_addr_space_p (acc
,
474 gdbarch_byte_order (gdbarch
)
479 ret
= unw_init_remote_p (&cursor
, as
, regcache
);
482 unw_destroy_addr_space_p (as
);
486 uw_regnum
= descr
->gdb2uw (regnum
);
488 if (descr
->is_fpreg (uw_regnum
))
490 ret
= unw_get_fpreg_p (&cursor
, uw_regnum
, &fpval
);
495 ret
= unw_get_reg_p (&cursor
, uw_regnum
, &intval
);
499 unw_destroy_addr_space_p (as
);
505 memcpy (buf
, ptr
, register_size (gdbarch
, regnum
));
511 libunwind_load (void)
514 char *so_error
= NULL
;
516 handle
= dlopen (LIBUNWIND_SO
, RTLD_NOW
);
519 so_error
= xstrdup (dlerror ());
520 #ifdef LIBUNWIND_SO_7
521 handle
= dlopen (LIBUNWIND_SO_7
, RTLD_NOW
);
522 #endif /* LIBUNWIND_SO_7 */
526 fprintf_unfiltered (gdb_stderr
, _("[GDB failed to load %s: %s]\n"),
527 LIBUNWIND_SO
, so_error
);
528 #ifdef LIBUNWIND_SO_7
529 fprintf_unfiltered (gdb_stderr
, _("[GDB failed to load %s: %s]\n"),
530 LIBUNWIND_SO_7
, dlerror ());
531 #endif /* LIBUNWIND_SO_7 */
537 /* Initialize pointers to the dynamic library functions we will use. */
539 unw_get_reg_p
= (unw_get_reg_p_ftype
*) dlsym (handle
, get_reg_name
);
540 if (unw_get_reg_p
== NULL
)
543 unw_get_fpreg_p
= (unw_get_fpreg_p_ftype
*) dlsym (handle
, get_fpreg_name
);
544 if (unw_get_fpreg_p
== NULL
)
548 = (unw_get_saveloc_p_ftype
*) dlsym (handle
, get_saveloc_name
);
549 if (unw_get_saveloc_p
== NULL
)
552 unw_is_signal_frame_p
553 = (unw_is_signal_frame_p_ftype
*) dlsym (handle
, is_signal_frame_name
);
554 if (unw_is_signal_frame_p
== NULL
)
557 unw_step_p
= (unw_step_p_ftype
*) dlsym (handle
, step_name
);
558 if (unw_step_p
== NULL
)
562 = (unw_init_remote_p_ftype
*) dlsym (handle
, init_remote_name
);
563 if (unw_init_remote_p
== NULL
)
566 unw_create_addr_space_p
567 = (unw_create_addr_space_p_ftype
*) dlsym (handle
, create_addr_space_name
);
568 if (unw_create_addr_space_p
== NULL
)
571 unw_destroy_addr_space_p
572 = (unw_destroy_addr_space_p_ftype
*) dlsym (handle
,
573 destroy_addr_space_name
);
574 if (unw_destroy_addr_space_p
== NULL
)
577 unw_search_unwind_table_p
578 = (unw_search_unwind_table_p_ftype
*) dlsym (handle
,
579 search_unwind_table_name
);
580 if (unw_search_unwind_table_p
== NULL
)
584 = (unw_find_dyn_list_p_ftype
*) dlsym (handle
, find_dyn_list_name
);
585 if (unw_find_dyn_list_p
== NULL
)
592 libunwind_is_initialized (void)
594 return libunwind_initialized
;
598 _initialize_libunwind_frame (void)
600 libunwind_descr_handle
601 = gdbarch_data_register_post_init (libunwind_descr_init
);
603 libunwind_initialized
= libunwind_load ();