1/* Frame unwinder for ia64 frames using the libunwind library. 2 3 Copyright (C) 2003-2020 Free Software Foundation, Inc. 4 5 Written by Jeff Johnston, contributed by Red Hat Inc. 6 7 This file is part of GDB. 8 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. 13 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. 18 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/>. */ 21 22#include "defs.h" 23 24#include "inferior.h" 25#include "frame.h" 26#include "frame-base.h" 27#include "frame-unwind.h" 28#include "gdbcore.h" 29#include "gdbtypes.h" 30#include "symtab.h" 31#include "objfiles.h" 32#include "regcache.h" 33 34#include <dlfcn.h> 35 36#include "ia64-libunwind-tdep.h" 37 38#include "complaints.h" 39#include "gdbsupport/preprocessor.h" 40 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). */ 48 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 54#endif 55#ifndef __BIG_ENDIAN 56#define __BIG_ENDIAN 4321 57#endif 58 59static int libunwind_initialized; 60static struct gdbarch_data *libunwind_descr_handle; 61 62/* Required function pointers from libunwind. */ 63typedef int (unw_get_reg_p_ftype) (unw_cursor_t *, unw_regnum_t, unw_word_t *); 64static unw_get_reg_p_ftype *unw_get_reg_p; 65typedef int (unw_get_fpreg_p_ftype) (unw_cursor_t *, unw_regnum_t, 66 unw_fpreg_t *); 67static unw_get_fpreg_p_ftype *unw_get_fpreg_p; 68typedef int (unw_get_saveloc_p_ftype) (unw_cursor_t *, unw_regnum_t, 69 unw_save_loc_t *); 70static unw_get_saveloc_p_ftype *unw_get_saveloc_p; 71typedef int (unw_is_signal_frame_p_ftype) (unw_cursor_t *); 72static unw_is_signal_frame_p_ftype *unw_is_signal_frame_p; 73typedef int (unw_step_p_ftype) (unw_cursor_t *); 74static unw_step_p_ftype *unw_step_p; 75typedef int (unw_init_remote_p_ftype) (unw_cursor_t *, unw_addr_space_t, 76 void *); 77static unw_init_remote_p_ftype *unw_init_remote_p; 78typedef unw_addr_space_t (unw_create_addr_space_p_ftype) (unw_accessors_t *, 79 int); 80static unw_create_addr_space_p_ftype *unw_create_addr_space_p; 81typedef void (unw_destroy_addr_space_p_ftype) (unw_addr_space_t); 82static unw_destroy_addr_space_p_ftype *unw_destroy_addr_space_p; 83typedef int (unw_search_unwind_table_p_ftype) (unw_addr_space_t, unw_word_t, 84 unw_dyn_info_t *, 85 unw_proc_info_t *, int, void *); 86static unw_search_unwind_table_p_ftype *unw_search_unwind_table_p; 87typedef unw_word_t (unw_find_dyn_list_p_ftype) (unw_addr_space_t, 88 unw_dyn_info_t *, void *); 89static unw_find_dyn_list_p_ftype *unw_find_dyn_list_p; 90 91 92struct libunwind_frame_cache 93{ 94 CORE_ADDR base; 95 CORE_ADDR func_addr; 96 unw_cursor_t cursor; 97 unw_addr_space_t as; 98}; 99 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. */ 103 104#ifndef LIBUNWIND_SO 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" 108 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" 112#endif 113 114static const char *get_reg_name = STRINGIFY(UNW_OBJ(get_reg)); 115static const char *get_fpreg_name = STRINGIFY(UNW_OBJ(get_fpreg)); 116static const char *get_saveloc_name = STRINGIFY(UNW_OBJ(get_save_loc)); 117static const char *is_signal_frame_name = STRINGIFY(UNW_OBJ(is_signal_frame)); 118static const char *step_name = STRINGIFY(UNW_OBJ(step)); 119static const char *init_remote_name = STRINGIFY(UNW_OBJ(init_remote)); 120static const char *create_addr_space_name 121 = STRINGIFY(UNW_OBJ(create_addr_space)); 122static const char *destroy_addr_space_name 123 = STRINGIFY(UNW_OBJ(destroy_addr_space)); 124static const char *search_unwind_table_name 125 = STRINGIFY(UNW_OBJ(search_unwind_table)); 126static const char *find_dyn_list_name = STRINGIFY(UNW_OBJ(find_dyn_list)); 127 128static struct libunwind_descr * 129libunwind_descr (struct gdbarch *gdbarch) 130{ 131 return ((struct libunwind_descr *) 132 gdbarch_data (gdbarch, libunwind_descr_handle)); 133} 134 135static void * 136libunwind_descr_init (struct obstack *obstack) 137{ 138 struct libunwind_descr *descr 139 = OBSTACK_ZALLOC (obstack, struct libunwind_descr); 140 141 return descr; 142} 143 144void 145libunwind_frame_set_descr (struct gdbarch *gdbarch, 146 struct libunwind_descr *descr) 147{ 148 struct libunwind_descr *arch_descr; 149 150 gdb_assert (gdbarch != NULL); 151 152 arch_descr = ((struct libunwind_descr *) 153 gdbarch_data (gdbarch, libunwind_descr_handle)); 154 gdb_assert (arch_descr != NULL); 155 156 /* Copy new descriptor info into arch descriptor. */ 157 arch_descr->gdb2uw = descr->gdb2uw; 158 arch_descr->uw2gdb = descr->uw2gdb; 159 arch_descr->is_fpreg = descr->is_fpreg; 160 arch_descr->accessors = descr->accessors; 161 arch_descr->special_accessors = descr->special_accessors; 162} 163 164static struct libunwind_frame_cache * 165libunwind_frame_cache (struct frame_info *this_frame, void **this_cache) 166{ 167 unw_accessors_t *acc; 168 unw_addr_space_t as; 169 unw_word_t fp; 170 unw_regnum_t uw_sp_regnum; 171 struct libunwind_frame_cache *cache; 172 struct libunwind_descr *descr; 173 struct gdbarch *gdbarch = get_frame_arch (this_frame); 174 int ret; 175 176 if (*this_cache) 177 return (struct libunwind_frame_cache *) *this_cache; 178 179 /* Allocate a new cache. */ 180 cache = FRAME_OBSTACK_ZALLOC (struct libunwind_frame_cache); 181 182 cache->func_addr = get_frame_func (this_frame); 183 if (cache->func_addr == 0) 184 /* This can happen when the frame corresponds to a function for which 185 there is no debugging information nor any entry in the symbol table. 186 This is probably a static function for which an entry in the symbol 187 table was not created when the objfile got linked (observed in 188 libpthread.so on ia64-hpux). 189 190 The best we can do, in that case, is use the frame PC as the function 191 address. We don't need to give up since we still have the unwind 192 record to help us perform the unwinding. There is also another 193 compelling to continue, because abandoning now means stopping 194 the backtrace, which can never be helpful for the user. */ 195 cache->func_addr = get_frame_pc (this_frame); 196 197 /* Get a libunwind cursor to the previous frame. 198 199 We do this by initializing a cursor. Libunwind treats a new cursor 200 as the top of stack and will get the current register set via the 201 libunwind register accessor. Now, we provide the platform-specific 202 accessors and we set up the register accessor to use the frame 203 register unwinding interfaces so that we properly get the registers 204 for the current frame rather than the top. We then use the unw_step 205 function to move the libunwind cursor back one frame. We can later 206 use this cursor to find previous registers via the unw_get_reg 207 interface which will invoke libunwind's special logic. */ 208 descr = libunwind_descr (gdbarch); 209 acc = (unw_accessors_t *) descr->accessors; 210 as = unw_create_addr_space_p (acc, 211 gdbarch_byte_order (gdbarch) 212 == BFD_ENDIAN_BIG 213 ? __BIG_ENDIAN 214 : __LITTLE_ENDIAN); 215 216 unw_init_remote_p (&cache->cursor, as, this_frame); 217 if (unw_step_p (&cache->cursor) < 0) 218 { 219 unw_destroy_addr_space_p (as); 220 return NULL; 221 } 222 223 /* To get base address, get sp from previous frame. */ 224 uw_sp_regnum = descr->gdb2uw (gdbarch_sp_regnum (gdbarch)); 225 ret = unw_get_reg_p (&cache->cursor, uw_sp_regnum, &fp); 226 if (ret < 0) 227 { 228 unw_destroy_addr_space_p (as); 229 error (_("Can't get libunwind sp register.")); 230 } 231 232 cache->base = (CORE_ADDR)fp; 233 cache->as = as; 234 235 *this_cache = cache; 236 return cache; 237} 238 239void 240libunwind_frame_dealloc_cache (struct frame_info *self, void *this_cache) 241{ 242 struct libunwind_frame_cache *cache 243 = (struct libunwind_frame_cache *) this_cache; 244 245 if (cache->as) 246 unw_destroy_addr_space_p (cache->as); 247} 248 249unw_word_t 250libunwind_find_dyn_list (unw_addr_space_t as, unw_dyn_info_t *di, void *arg) 251{ 252 return unw_find_dyn_list_p (as, di, arg); 253} 254 255/* Verify if there is sufficient libunwind information for the frame to use 256 libunwind frame unwinding. */ 257int 258libunwind_frame_sniffer (const struct frame_unwind *self, 259 struct frame_info *this_frame, void **this_cache) 260{ 261 unw_cursor_t cursor; 262 unw_accessors_t *acc; 263 unw_addr_space_t as; 264 struct libunwind_descr *descr; 265 struct gdbarch *gdbarch = get_frame_arch (this_frame); 266 int ret; 267 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. */ 273 274 descr = libunwind_descr (gdbarch); 275 acc = (unw_accessors_t *) descr->accessors; 276 as = unw_create_addr_space_p (acc, 277 gdbarch_byte_order (gdbarch) 278 == BFD_ENDIAN_BIG 279 ? __BIG_ENDIAN 280 : __LITTLE_ENDIAN); 281 282 ret = unw_init_remote_p (&cursor, as, this_frame); 283 284 if (ret < 0) 285 { 286 unw_destroy_addr_space_p (as); 287 return 0; 288 } 289 290 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); 296 297 if (ret < 0) 298 return 0; 299 300 return 1; 301} 302 303void 304libunwind_frame_this_id (struct frame_info *this_frame, void **this_cache, 305 struct frame_id *this_id) 306{ 307 struct libunwind_frame_cache *cache = 308 libunwind_frame_cache (this_frame, this_cache); 309 310 if (cache != NULL) 311 (*this_id) = frame_id_build (cache->base, cache->func_addr); 312} 313 314struct value * 315libunwind_frame_prev_register (struct frame_info *this_frame, 316 void **this_cache, int regnum) 317{ 318 struct libunwind_frame_cache *cache = 319 libunwind_frame_cache (this_frame, this_cache); 320 321 unw_save_loc_t sl; 322 int ret; 323 unw_word_t intval; 324 unw_fpreg_t fpval; 325 unw_regnum_t uw_regnum; 326 struct libunwind_descr *descr; 327 struct value *val = NULL; 328 329 if (cache == NULL) 330 return frame_unwind_got_constant (this_frame, regnum, 0); 331 332 /* Convert from gdb register number to libunwind register number. */ 333 descr = libunwind_descr (get_frame_arch (this_frame)); 334 uw_regnum = descr->gdb2uw (regnum); 335 336 gdb_assert (regnum >= 0); 337 338 if (!target_has_registers) 339 error (_("No registers.")); 340 341 if (uw_regnum < 0) 342 return frame_unwind_got_constant (this_frame, regnum, 0); 343 344 if (unw_get_saveloc_p (&cache->cursor, uw_regnum, &sl) < 0) 345 return frame_unwind_got_constant (this_frame, regnum, 0); 346 347 switch (sl.type) 348 { 349 case UNW_SLT_MEMORY: 350 val = frame_unwind_got_memory (this_frame, regnum, sl.u.addr); 351 break; 352 353 case UNW_SLT_REG: 354 val = frame_unwind_got_register (this_frame, regnum, 355 descr->uw2gdb (sl.u.regnum)); 356 break; 357 case UNW_SLT_NONE: 358 { 359 /* The register is not stored at a specific memory address nor 360 inside another register. So use libunwind to fetch the register 361 value for us, and create a constant value with the result. */ 362 if (descr->is_fpreg (uw_regnum)) 363 { 364 ret = unw_get_fpreg_p (&cache->cursor, uw_regnum, &fpval); 365 if (ret < 0) 366 return frame_unwind_got_constant (this_frame, regnum, 0); 367 val = frame_unwind_got_bytes (this_frame, regnum, 368 (gdb_byte *) &fpval); 369 } 370 else 371 { 372 ret = unw_get_reg_p (&cache->cursor, uw_regnum, &intval); 373 if (ret < 0) 374 return frame_unwind_got_constant (this_frame, regnum, 0); 375 val = frame_unwind_got_constant (this_frame, regnum, intval); 376 } 377 break; 378 } 379 } 380 381 return val; 382} 383 384/* The following is a glue routine to call the libunwind unwind table 385 search function to get unwind information for a specified ip address. */ 386int 387libunwind_search_unwind_table (void *as, long ip, void *di, 388 void *pi, int need_unwind_info, void *args) 389{ 390 return unw_search_unwind_table_p (*(unw_addr_space_t *) as, (unw_word_t) ip, 391 (unw_dyn_info_t *) di, 392 (unw_proc_info_t *) pi, need_unwind_info, 393 args); 394} 395 396/* Verify if we are in a sigtramp frame and we can use libunwind to unwind. */ 397int 398libunwind_sigtramp_frame_sniffer (const struct frame_unwind *self, 399 struct frame_info *this_frame, 400 void **this_cache) 401{ 402 unw_cursor_t cursor; 403 unw_accessors_t *acc; 404 unw_addr_space_t as; 405 struct libunwind_descr *descr; 406 struct gdbarch *gdbarch = get_frame_arch (this_frame); 407 int ret; 408 409 /* To test for libunwind unwind support, initialize a cursor to the 410 current frame and try to back up. We use this same method when 411 setting up the frame cache (see libunwind_frame_cache()). If 412 libunwind returns success for this operation, it means that it 413 has found sufficient libunwind unwinding information to do 414 so. */ 415 416 descr = libunwind_descr (gdbarch); 417 acc = (unw_accessors_t *) descr->accessors; 418 as = unw_create_addr_space_p (acc, 419 gdbarch_byte_order (gdbarch) 420 == BFD_ENDIAN_BIG 421 ? __BIG_ENDIAN 422 : __LITTLE_ENDIAN); 423 424 ret = unw_init_remote_p (&cursor, as, this_frame); 425 426 if (ret < 0) 427 { 428 unw_destroy_addr_space_p (as); 429 return 0; 430 } 431 432 /* Check to see if we are in a signal frame. */ 433 ret = unw_is_signal_frame_p (&cursor); 434 unw_destroy_addr_space_p (as); 435 if (ret > 0) 436 return 1; 437 438 return 0; 439} 440 441/* The following routine is for accessing special registers of the top frame. 442 A special set of accessors must be given that work without frame info. 443 This is used by ia64 to access the rse registers r32-r127. While they 444 are usually located at BOF, this is not always true and only the libunwind 445 info can decipher where they actually are. */ 446int 447libunwind_get_reg_special (struct gdbarch *gdbarch, readable_regcache *regcache, 448 int regnum, void *buf) 449{ 450 unw_cursor_t cursor; 451 unw_accessors_t *acc; 452 unw_addr_space_t as; 453 struct libunwind_descr *descr; 454 int ret; 455 unw_regnum_t uw_regnum; 456 unw_word_t intval; 457 unw_fpreg_t fpval; 458 void *ptr; 459 460 461 descr = libunwind_descr (gdbarch); 462 acc = (unw_accessors_t *) descr->special_accessors; 463 as = unw_create_addr_space_p (acc, 464 gdbarch_byte_order (gdbarch) 465 == BFD_ENDIAN_BIG 466 ? __BIG_ENDIAN 467 : __LITTLE_ENDIAN); 468 469 ret = unw_init_remote_p (&cursor, as, regcache); 470 if (ret < 0) 471 { 472 unw_destroy_addr_space_p (as); 473 return -1; 474 } 475 476 uw_regnum = descr->gdb2uw (regnum); 477 478 if (descr->is_fpreg (uw_regnum)) 479 { 480 ret = unw_get_fpreg_p (&cursor, uw_regnum, &fpval); 481 ptr = &fpval; 482 } 483 else 484 { 485 ret = unw_get_reg_p (&cursor, uw_regnum, &intval); 486 ptr = &intval; 487 } 488 489 unw_destroy_addr_space_p (as); 490 491 if (ret < 0) 492 return -1; 493 494 if (buf) 495 memcpy (buf, ptr, register_size (gdbarch, regnum)); 496 497 return 0; 498} 499 500static int 501libunwind_load (void) 502{ 503 void *handle; 504 char *so_error = NULL; 505 506 handle = dlopen (LIBUNWIND_SO, RTLD_NOW); 507 if (handle == NULL) 508 { 509 so_error = xstrdup (dlerror ()); 510#ifdef LIBUNWIND_SO_7 511 handle = dlopen (LIBUNWIND_SO_7, RTLD_NOW); 512#endif /* LIBUNWIND_SO_7 */ 513 } 514 if (handle == NULL) 515 { 516 fprintf_unfiltered (gdb_stderr, _("[GDB failed to load %s: %s]\n"), 517 LIBUNWIND_SO, so_error); 518#ifdef LIBUNWIND_SO_7 519 fprintf_unfiltered (gdb_stderr, _("[GDB failed to load %s: %s]\n"), 520 LIBUNWIND_SO_7, dlerror ()); 521#endif /* LIBUNWIND_SO_7 */ 522 } 523 xfree (so_error); 524 if (handle == NULL) 525 return 0; 526 527 /* Initialize pointers to the dynamic library functions we will use. */ 528 529 unw_get_reg_p = (unw_get_reg_p_ftype *) dlsym (handle, get_reg_name); 530 if (unw_get_reg_p == NULL) 531 return 0; 532 533 unw_get_fpreg_p = (unw_get_fpreg_p_ftype *) dlsym (handle, get_fpreg_name); 534 if (unw_get_fpreg_p == NULL) 535 return 0; 536 537 unw_get_saveloc_p 538 = (unw_get_saveloc_p_ftype *) dlsym (handle, get_saveloc_name); 539 if (unw_get_saveloc_p == NULL) 540 return 0; 541 542 unw_is_signal_frame_p 543 = (unw_is_signal_frame_p_ftype *) dlsym (handle, is_signal_frame_name); 544 if (unw_is_signal_frame_p == NULL) 545 return 0; 546 547 unw_step_p = (unw_step_p_ftype *) dlsym (handle, step_name); 548 if (unw_step_p == NULL) 549 return 0; 550 551 unw_init_remote_p 552 = (unw_init_remote_p_ftype *) dlsym (handle, init_remote_name); 553 if (unw_init_remote_p == NULL) 554 return 0; 555 556 unw_create_addr_space_p 557 = (unw_create_addr_space_p_ftype *) dlsym (handle, create_addr_space_name); 558 if (unw_create_addr_space_p == NULL) 559 return 0; 560 561 unw_destroy_addr_space_p 562 = (unw_destroy_addr_space_p_ftype *) dlsym (handle, 563 destroy_addr_space_name); 564 if (unw_destroy_addr_space_p == NULL) 565 return 0; 566 567 unw_search_unwind_table_p 568 = (unw_search_unwind_table_p_ftype *) dlsym (handle, 569 search_unwind_table_name); 570 if (unw_search_unwind_table_p == NULL) 571 return 0; 572 573 unw_find_dyn_list_p 574 = (unw_find_dyn_list_p_ftype *) dlsym (handle, find_dyn_list_name); 575 if (unw_find_dyn_list_p == NULL) 576 return 0; 577 578 return 1; 579} 580 581int 582libunwind_is_initialized (void) 583{ 584 return libunwind_initialized; 585} 586 587void _initialize_libunwind_frame (); 588void 589_initialize_libunwind_frame () 590{ 591 libunwind_descr_handle 592 = gdbarch_data_register_pre_init (libunwind_descr_init); 593 594 libunwind_initialized = libunwind_load (); 595} 596