1 /* Cache and manage frames for GDB, the GNU debugger. 2 3 Copyright (C) 1986-2019 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 #include "defs.h" 21 #include "frame.h" 22 #include "target.h" 23 #include "value.h" 24 #include "inferior.h" /* for inferior_ptid */ 25 #include "regcache.h" 26 #include "user-regs.h" 27 #include "gdb_obstack.h" 28 #include "dummy-frame.h" 29 #include "sentinel-frame.h" 30 #include "gdbcore.h" 31 #include "annotate.h" 32 #include "language.h" 33 #include "frame-unwind.h" 34 #include "frame-base.h" 35 #include "command.h" 36 #include "gdbcmd.h" 37 #include "observable.h" 38 #include "objfiles.h" 39 #include "gdbthread.h" 40 #include "block.h" 41 #include "inline-frame.h" 42 #include "tracepoint.h" 43 #include "hashtab.h" 44 #include "valprint.h" 45 46 /* The sentinel frame terminates the innermost end of the frame chain. 47 If unwound, it returns the information needed to construct an 48 innermost frame. 49 50 The current frame, which is the innermost frame, can be found at 51 sentinel_frame->prev. */ 52 53 static struct frame_info *sentinel_frame; 54 55 static struct frame_info *get_prev_frame_raw (struct frame_info *this_frame); 56 static const char *frame_stop_reason_symbol_string (enum unwind_stop_reason reason); 57 58 /* Status of some values cached in the frame_info object. */ 59 60 enum cached_copy_status 61 { 62 /* Value is unknown. */ 63 CC_UNKNOWN, 64 65 /* We have a value. */ 66 CC_VALUE, 67 68 /* Value was not saved. */ 69 CC_NOT_SAVED, 70 71 /* Value is unavailable. */ 72 CC_UNAVAILABLE 73 }; 74 75 /* We keep a cache of stack frames, each of which is a "struct 76 frame_info". The innermost one gets allocated (in 77 wait_for_inferior) each time the inferior stops; sentinel_frame 78 points to it. Additional frames get allocated (in get_prev_frame) 79 as needed, and are chained through the next and prev fields. Any 80 time that the frame cache becomes invalid (most notably when we 81 execute something, but also if we change how we interpret the 82 frames (e.g. "set heuristic-fence-post" in mips-tdep.c, or anything 83 which reads new symbols)), we should call reinit_frame_cache. */ 84 85 struct frame_info 86 { 87 /* Level of this frame. The inner-most (youngest) frame is at level 88 0. As you move towards the outer-most (oldest) frame, the level 89 increases. This is a cached value. It could just as easily be 90 computed by counting back from the selected frame to the inner 91 most frame. */ 92 /* NOTE: cagney/2002-04-05: Perhaps a level of ``-1'' should be 93 reserved to indicate a bogus frame - one that has been created 94 just to keep GDB happy (GDB always needs a frame). For the 95 moment leave this as speculation. */ 96 int level; 97 98 /* The frame's program space. */ 99 struct program_space *pspace; 100 101 /* The frame's address space. */ 102 const address_space *aspace; 103 104 /* The frame's low-level unwinder and corresponding cache. The 105 low-level unwinder is responsible for unwinding register values 106 for the previous frame. The low-level unwind methods are 107 selected based on the presence, or otherwise, of register unwind 108 information such as CFI. */ 109 void *prologue_cache; 110 const struct frame_unwind *unwind; 111 112 /* Cached copy of the previous frame's architecture. */ 113 struct 114 { 115 int p; 116 struct gdbarch *arch; 117 } prev_arch; 118 119 /* Cached copy of the previous frame's resume address. */ 120 struct { 121 enum cached_copy_status status; 122 CORE_ADDR value; 123 } prev_pc; 124 125 /* Cached copy of the previous frame's function address. */ 126 struct 127 { 128 CORE_ADDR addr; 129 int p; 130 } prev_func; 131 132 /* This frame's ID. */ 133 struct 134 { 135 int p; 136 struct frame_id value; 137 } this_id; 138 139 /* The frame's high-level base methods, and corresponding cache. 140 The high level base methods are selected based on the frame's 141 debug info. */ 142 const struct frame_base *base; 143 void *base_cache; 144 145 /* Pointers to the next (down, inner, younger) and previous (up, 146 outer, older) frame_info's in the frame cache. */ 147 struct frame_info *next; /* down, inner, younger */ 148 int prev_p; 149 struct frame_info *prev; /* up, outer, older */ 150 151 /* The reason why we could not set PREV, or UNWIND_NO_REASON if we 152 could. Only valid when PREV_P is set. */ 153 enum unwind_stop_reason stop_reason; 154 155 /* A frame specific string describing the STOP_REASON in more detail. 156 Only valid when PREV_P is set, but even then may still be NULL. */ 157 const char *stop_string; 158 }; 159 160 /* A frame stash used to speed up frame lookups. Create a hash table 161 to stash frames previously accessed from the frame cache for 162 quicker subsequent retrieval. The hash table is emptied whenever 163 the frame cache is invalidated. */ 164 165 static htab_t frame_stash; 166 167 /* Internal function to calculate a hash from the frame_id addresses, 168 using as many valid addresses as possible. Frames below level 0 169 are not stored in the hash table. */ 170 171 static hashval_t 172 frame_addr_hash (const void *ap) 173 { 174 const struct frame_info *frame = (const struct frame_info *) ap; 175 const struct frame_id f_id = frame->this_id.value; 176 hashval_t hash = 0; 177 178 gdb_assert (f_id.stack_status != FID_STACK_INVALID 179 || f_id.code_addr_p 180 || f_id.special_addr_p); 181 182 if (f_id.stack_status == FID_STACK_VALID) 183 hash = iterative_hash (&f_id.stack_addr, 184 sizeof (f_id.stack_addr), hash); 185 if (f_id.code_addr_p) 186 hash = iterative_hash (&f_id.code_addr, 187 sizeof (f_id.code_addr), hash); 188 if (f_id.special_addr_p) 189 hash = iterative_hash (&f_id.special_addr, 190 sizeof (f_id.special_addr), hash); 191 192 return hash; 193 } 194 195 /* Internal equality function for the hash table. This function 196 defers equality operations to frame_id_eq. */ 197 198 static int 199 frame_addr_hash_eq (const void *a, const void *b) 200 { 201 const struct frame_info *f_entry = (const struct frame_info *) a; 202 const struct frame_info *f_element = (const struct frame_info *) b; 203 204 return frame_id_eq (f_entry->this_id.value, 205 f_element->this_id.value); 206 } 207 208 /* Internal function to create the frame_stash hash table. 100 seems 209 to be a good compromise to start the hash table at. */ 210 211 static void 212 frame_stash_create (void) 213 { 214 frame_stash = htab_create (100, 215 frame_addr_hash, 216 frame_addr_hash_eq, 217 NULL); 218 } 219 220 /* Internal function to add a frame to the frame_stash hash table. 221 Returns false if a frame with the same ID was already stashed, true 222 otherwise. */ 223 224 static int 225 frame_stash_add (struct frame_info *frame) 226 { 227 struct frame_info **slot; 228 229 /* Do not try to stash the sentinel frame. */ 230 gdb_assert (frame->level >= 0); 231 232 slot = (struct frame_info **) htab_find_slot (frame_stash, 233 frame, 234 INSERT); 235 236 /* If we already have a frame in the stack with the same id, we 237 either have a stack cycle (corrupted stack?), or some bug 238 elsewhere in GDB. In any case, ignore the duplicate and return 239 an indication to the caller. */ 240 if (*slot != NULL) 241 return 0; 242 243 *slot = frame; 244 return 1; 245 } 246 247 /* Internal function to search the frame stash for an entry with the 248 given frame ID. If found, return that frame. Otherwise return 249 NULL. */ 250 251 static struct frame_info * 252 frame_stash_find (struct frame_id id) 253 { 254 struct frame_info dummy; 255 struct frame_info *frame; 256 257 dummy.this_id.value = id; 258 frame = (struct frame_info *) htab_find (frame_stash, &dummy); 259 return frame; 260 } 261 262 /* Internal function to invalidate the frame stash by removing all 263 entries in it. This only occurs when the frame cache is 264 invalidated. */ 265 266 static void 267 frame_stash_invalidate (void) 268 { 269 htab_empty (frame_stash); 270 } 271 272 /* See frame.h */ 273 scoped_restore_selected_frame::scoped_restore_selected_frame () 274 { 275 m_fid = get_frame_id (get_selected_frame (NULL)); 276 } 277 278 /* See frame.h */ 279 scoped_restore_selected_frame::~scoped_restore_selected_frame () 280 { 281 frame_info *frame = frame_find_by_id (m_fid); 282 if (frame == NULL) 283 warning (_("Unable to restore previously selected frame.")); 284 else 285 select_frame (frame); 286 } 287 288 /* Flag to control debugging. */ 289 290 unsigned int frame_debug; 291 static void 292 show_frame_debug (struct ui_file *file, int from_tty, 293 struct cmd_list_element *c, const char *value) 294 { 295 fprintf_filtered (file, _("Frame debugging is %s.\n"), value); 296 } 297 298 /* Flag to indicate whether backtraces should stop at main et.al. */ 299 300 static int backtrace_past_main; 301 static void 302 show_backtrace_past_main (struct ui_file *file, int from_tty, 303 struct cmd_list_element *c, const char *value) 304 { 305 fprintf_filtered (file, 306 _("Whether backtraces should " 307 "continue past \"main\" is %s.\n"), 308 value); 309 } 310 311 static int backtrace_past_entry; 312 static void 313 show_backtrace_past_entry (struct ui_file *file, int from_tty, 314 struct cmd_list_element *c, const char *value) 315 { 316 fprintf_filtered (file, _("Whether backtraces should continue past the " 317 "entry point of a program is %s.\n"), 318 value); 319 } 320 321 static unsigned int backtrace_limit = UINT_MAX; 322 static void 323 show_backtrace_limit (struct ui_file *file, int from_tty, 324 struct cmd_list_element *c, const char *value) 325 { 326 fprintf_filtered (file, 327 _("An upper bound on the number " 328 "of backtrace levels is %s.\n"), 329 value); 330 } 331 332 333 static void 334 fprint_field (struct ui_file *file, const char *name, int p, CORE_ADDR addr) 335 { 336 if (p) 337 fprintf_unfiltered (file, "%s=%s", name, hex_string (addr)); 338 else 339 fprintf_unfiltered (file, "!%s", name); 340 } 341 342 void 343 fprint_frame_id (struct ui_file *file, struct frame_id id) 344 { 345 fprintf_unfiltered (file, "{"); 346 347 if (id.stack_status == FID_STACK_INVALID) 348 fprintf_unfiltered (file, "!stack"); 349 else if (id.stack_status == FID_STACK_UNAVAILABLE) 350 fprintf_unfiltered (file, "stack=<unavailable>"); 351 else if (id.stack_status == FID_STACK_SENTINEL) 352 fprintf_unfiltered (file, "stack=<sentinel>"); 353 else 354 fprintf_unfiltered (file, "stack=%s", hex_string (id.stack_addr)); 355 fprintf_unfiltered (file, ","); 356 357 fprint_field (file, "code", id.code_addr_p, id.code_addr); 358 fprintf_unfiltered (file, ","); 359 360 fprint_field (file, "special", id.special_addr_p, id.special_addr); 361 362 if (id.artificial_depth) 363 fprintf_unfiltered (file, ",artificial=%d", id.artificial_depth); 364 365 fprintf_unfiltered (file, "}"); 366 } 367 368 static void 369 fprint_frame_type (struct ui_file *file, enum frame_type type) 370 { 371 switch (type) 372 { 373 case NORMAL_FRAME: 374 fprintf_unfiltered (file, "NORMAL_FRAME"); 375 return; 376 case DUMMY_FRAME: 377 fprintf_unfiltered (file, "DUMMY_FRAME"); 378 return; 379 case INLINE_FRAME: 380 fprintf_unfiltered (file, "INLINE_FRAME"); 381 return; 382 case TAILCALL_FRAME: 383 fprintf_unfiltered (file, "TAILCALL_FRAME"); 384 return; 385 case SIGTRAMP_FRAME: 386 fprintf_unfiltered (file, "SIGTRAMP_FRAME"); 387 return; 388 case ARCH_FRAME: 389 fprintf_unfiltered (file, "ARCH_FRAME"); 390 return; 391 case SENTINEL_FRAME: 392 fprintf_unfiltered (file, "SENTINEL_FRAME"); 393 return; 394 default: 395 fprintf_unfiltered (file, "<unknown type>"); 396 return; 397 }; 398 } 399 400 static void 401 fprint_frame (struct ui_file *file, struct frame_info *fi) 402 { 403 if (fi == NULL) 404 { 405 fprintf_unfiltered (file, "<NULL frame>"); 406 return; 407 } 408 fprintf_unfiltered (file, "{"); 409 fprintf_unfiltered (file, "level=%d", fi->level); 410 fprintf_unfiltered (file, ","); 411 fprintf_unfiltered (file, "type="); 412 if (fi->unwind != NULL) 413 fprint_frame_type (file, fi->unwind->type); 414 else 415 fprintf_unfiltered (file, "<unknown>"); 416 fprintf_unfiltered (file, ","); 417 fprintf_unfiltered (file, "unwind="); 418 if (fi->unwind != NULL) 419 gdb_print_host_address (fi->unwind, file); 420 else 421 fprintf_unfiltered (file, "<unknown>"); 422 fprintf_unfiltered (file, ","); 423 fprintf_unfiltered (file, "pc="); 424 if (fi->next == NULL || fi->next->prev_pc.status == CC_UNKNOWN) 425 fprintf_unfiltered (file, "<unknown>"); 426 else if (fi->next->prev_pc.status == CC_VALUE) 427 fprintf_unfiltered (file, "%s", 428 hex_string (fi->next->prev_pc.value)); 429 else if (fi->next->prev_pc.status == CC_NOT_SAVED) 430 val_print_not_saved (file); 431 else if (fi->next->prev_pc.status == CC_UNAVAILABLE) 432 val_print_unavailable (file); 433 fprintf_unfiltered (file, ","); 434 fprintf_unfiltered (file, "id="); 435 if (fi->this_id.p) 436 fprint_frame_id (file, fi->this_id.value); 437 else 438 fprintf_unfiltered (file, "<unknown>"); 439 fprintf_unfiltered (file, ","); 440 fprintf_unfiltered (file, "func="); 441 if (fi->next != NULL && fi->next->prev_func.p) 442 fprintf_unfiltered (file, "%s", hex_string (fi->next->prev_func.addr)); 443 else 444 fprintf_unfiltered (file, "<unknown>"); 445 fprintf_unfiltered (file, "}"); 446 } 447 448 /* Given FRAME, return the enclosing frame as found in real frames read-in from 449 inferior memory. Skip any previous frames which were made up by GDB. 450 Return FRAME if FRAME is a non-artificial frame. 451 Return NULL if FRAME is the start of an artificial-only chain. */ 452 453 static struct frame_info * 454 skip_artificial_frames (struct frame_info *frame) 455 { 456 /* Note we use get_prev_frame_always, and not get_prev_frame. The 457 latter will truncate the frame chain, leading to this function 458 unintentionally returning a null_frame_id (e.g., when the user 459 sets a backtrace limit). 460 461 Note that for record targets we may get a frame chain that consists 462 of artificial frames only. */ 463 while (get_frame_type (frame) == INLINE_FRAME 464 || get_frame_type (frame) == TAILCALL_FRAME) 465 { 466 frame = get_prev_frame_always (frame); 467 if (frame == NULL) 468 break; 469 } 470 471 return frame; 472 } 473 474 struct frame_info * 475 skip_unwritable_frames (struct frame_info *frame) 476 { 477 while (gdbarch_code_of_frame_writable (get_frame_arch (frame), frame) == 0) 478 { 479 frame = get_prev_frame (frame); 480 if (frame == NULL) 481 break; 482 } 483 484 return frame; 485 } 486 487 /* See frame.h. */ 488 489 struct frame_info * 490 skip_tailcall_frames (struct frame_info *frame) 491 { 492 while (get_frame_type (frame) == TAILCALL_FRAME) 493 { 494 /* Note that for record targets we may get a frame chain that consists of 495 tailcall frames only. */ 496 frame = get_prev_frame (frame); 497 if (frame == NULL) 498 break; 499 } 500 501 return frame; 502 } 503 504 /* Compute the frame's uniq ID that can be used to, later, re-find the 505 frame. */ 506 507 static void 508 compute_frame_id (struct frame_info *fi) 509 { 510 gdb_assert (!fi->this_id.p); 511 512 if (frame_debug) 513 fprintf_unfiltered (gdb_stdlog, "{ compute_frame_id (fi=%d) ", 514 fi->level); 515 /* Find the unwinder. */ 516 if (fi->unwind == NULL) 517 frame_unwind_find_by_frame (fi, &fi->prologue_cache); 518 /* Find THIS frame's ID. */ 519 /* Default to outermost if no ID is found. */ 520 fi->this_id.value = outer_frame_id; 521 fi->unwind->this_id (fi, &fi->prologue_cache, &fi->this_id.value); 522 gdb_assert (frame_id_p (fi->this_id.value)); 523 fi->this_id.p = 1; 524 if (frame_debug) 525 { 526 fprintf_unfiltered (gdb_stdlog, "-> "); 527 fprint_frame_id (gdb_stdlog, fi->this_id.value); 528 fprintf_unfiltered (gdb_stdlog, " }\n"); 529 } 530 } 531 532 /* Return a frame uniq ID that can be used to, later, re-find the 533 frame. */ 534 535 struct frame_id 536 get_frame_id (struct frame_info *fi) 537 { 538 if (fi == NULL) 539 return null_frame_id; 540 541 if (!fi->this_id.p) 542 { 543 int stashed; 544 545 /* If we haven't computed the frame id yet, then it must be that 546 this is the current frame. Compute it now, and stash the 547 result. The IDs of other frames are computed as soon as 548 they're created, in order to detect cycles. See 549 get_prev_frame_if_no_cycle. */ 550 gdb_assert (fi->level == 0); 551 552 /* Compute. */ 553 compute_frame_id (fi); 554 555 /* Since this is the first frame in the chain, this should 556 always succeed. */ 557 stashed = frame_stash_add (fi); 558 gdb_assert (stashed); 559 } 560 561 return fi->this_id.value; 562 } 563 564 struct frame_id 565 get_stack_frame_id (struct frame_info *next_frame) 566 { 567 return get_frame_id (skip_artificial_frames (next_frame)); 568 } 569 570 struct frame_id 571 frame_unwind_caller_id (struct frame_info *next_frame) 572 { 573 struct frame_info *this_frame; 574 575 /* Use get_prev_frame_always, and not get_prev_frame. The latter 576 will truncate the frame chain, leading to this function 577 unintentionally returning a null_frame_id (e.g., when a caller 578 requests the frame ID of "main()"s caller. */ 579 580 next_frame = skip_artificial_frames (next_frame); 581 if (next_frame == NULL) 582 return null_frame_id; 583 584 this_frame = get_prev_frame_always (next_frame); 585 if (this_frame) 586 return get_frame_id (skip_artificial_frames (this_frame)); 587 else 588 return null_frame_id; 589 } 590 591 const struct frame_id null_frame_id = { 0 }; /* All zeros. */ 592 const struct frame_id sentinel_frame_id = { 0, 0, 0, FID_STACK_SENTINEL, 0, 1, 0 }; 593 const struct frame_id outer_frame_id = { 0, 0, 0, FID_STACK_INVALID, 0, 1, 0 }; 594 595 struct frame_id 596 frame_id_build_special (CORE_ADDR stack_addr, CORE_ADDR code_addr, 597 CORE_ADDR special_addr) 598 { 599 struct frame_id id = null_frame_id; 600 601 id.stack_addr = stack_addr; 602 id.stack_status = FID_STACK_VALID; 603 id.code_addr = code_addr; 604 id.code_addr_p = 1; 605 id.special_addr = special_addr; 606 id.special_addr_p = 1; 607 return id; 608 } 609 610 /* See frame.h. */ 611 612 struct frame_id 613 frame_id_build_unavailable_stack (CORE_ADDR code_addr) 614 { 615 struct frame_id id = null_frame_id; 616 617 id.stack_status = FID_STACK_UNAVAILABLE; 618 id.code_addr = code_addr; 619 id.code_addr_p = 1; 620 return id; 621 } 622 623 /* See frame.h. */ 624 625 struct frame_id 626 frame_id_build_unavailable_stack_special (CORE_ADDR code_addr, 627 CORE_ADDR special_addr) 628 { 629 struct frame_id id = null_frame_id; 630 631 id.stack_status = FID_STACK_UNAVAILABLE; 632 id.code_addr = code_addr; 633 id.code_addr_p = 1; 634 id.special_addr = special_addr; 635 id.special_addr_p = 1; 636 return id; 637 } 638 639 struct frame_id 640 frame_id_build (CORE_ADDR stack_addr, CORE_ADDR code_addr) 641 { 642 struct frame_id id = null_frame_id; 643 644 id.stack_addr = stack_addr; 645 id.stack_status = FID_STACK_VALID; 646 id.code_addr = code_addr; 647 id.code_addr_p = 1; 648 return id; 649 } 650 651 struct frame_id 652 frame_id_build_wild (CORE_ADDR stack_addr) 653 { 654 struct frame_id id = null_frame_id; 655 656 id.stack_addr = stack_addr; 657 id.stack_status = FID_STACK_VALID; 658 return id; 659 } 660 661 int 662 frame_id_p (struct frame_id l) 663 { 664 int p; 665 666 /* The frame is valid iff it has a valid stack address. */ 667 p = l.stack_status != FID_STACK_INVALID; 668 /* outer_frame_id is also valid. */ 669 if (!p && memcmp (&l, &outer_frame_id, sizeof (l)) == 0) 670 p = 1; 671 if (frame_debug) 672 { 673 fprintf_unfiltered (gdb_stdlog, "{ frame_id_p (l="); 674 fprint_frame_id (gdb_stdlog, l); 675 fprintf_unfiltered (gdb_stdlog, ") -> %d }\n", p); 676 } 677 return p; 678 } 679 680 int 681 frame_id_artificial_p (struct frame_id l) 682 { 683 if (!frame_id_p (l)) 684 return 0; 685 686 return (l.artificial_depth != 0); 687 } 688 689 int 690 frame_id_eq (struct frame_id l, struct frame_id r) 691 { 692 int eq; 693 694 if (l.stack_status == FID_STACK_INVALID && l.special_addr_p 695 && r.stack_status == FID_STACK_INVALID && r.special_addr_p) 696 /* The outermost frame marker is equal to itself. This is the 697 dodgy thing about outer_frame_id, since between execution steps 698 we might step into another function - from which we can't 699 unwind either. More thought required to get rid of 700 outer_frame_id. */ 701 eq = 1; 702 else if (l.stack_status == FID_STACK_INVALID 703 || r.stack_status == FID_STACK_INVALID) 704 /* Like a NaN, if either ID is invalid, the result is false. 705 Note that a frame ID is invalid iff it is the null frame ID. */ 706 eq = 0; 707 else if (l.stack_status != r.stack_status || l.stack_addr != r.stack_addr) 708 /* If .stack addresses are different, the frames are different. */ 709 eq = 0; 710 else if (l.code_addr_p && r.code_addr_p && l.code_addr != r.code_addr) 711 /* An invalid code addr is a wild card. If .code addresses are 712 different, the frames are different. */ 713 eq = 0; 714 else if (l.special_addr_p && r.special_addr_p 715 && l.special_addr != r.special_addr) 716 /* An invalid special addr is a wild card (or unused). Otherwise 717 if special addresses are different, the frames are different. */ 718 eq = 0; 719 else if (l.artificial_depth != r.artificial_depth) 720 /* If artifical depths are different, the frames must be different. */ 721 eq = 0; 722 else 723 /* Frames are equal. */ 724 eq = 1; 725 726 if (frame_debug) 727 { 728 fprintf_unfiltered (gdb_stdlog, "{ frame_id_eq (l="); 729 fprint_frame_id (gdb_stdlog, l); 730 fprintf_unfiltered (gdb_stdlog, ",r="); 731 fprint_frame_id (gdb_stdlog, r); 732 fprintf_unfiltered (gdb_stdlog, ") -> %d }\n", eq); 733 } 734 return eq; 735 } 736 737 /* Safety net to check whether frame ID L should be inner to 738 frame ID R, according to their stack addresses. 739 740 This method cannot be used to compare arbitrary frames, as the 741 ranges of valid stack addresses may be discontiguous (e.g. due 742 to sigaltstack). 743 744 However, it can be used as safety net to discover invalid frame 745 IDs in certain circumstances. Assuming that NEXT is the immediate 746 inner frame to THIS and that NEXT and THIS are both NORMAL frames: 747 748 * The stack address of NEXT must be inner-than-or-equal to the stack 749 address of THIS. 750 751 Therefore, if frame_id_inner (THIS, NEXT) holds, some unwind 752 error has occurred. 753 754 * If NEXT and THIS have different stack addresses, no other frame 755 in the frame chain may have a stack address in between. 756 757 Therefore, if frame_id_inner (TEST, THIS) holds, but 758 frame_id_inner (TEST, NEXT) does not hold, TEST cannot refer 759 to a valid frame in the frame chain. 760 761 The sanity checks above cannot be performed when a SIGTRAMP frame 762 is involved, because signal handlers might be executed on a different 763 stack than the stack used by the routine that caused the signal 764 to be raised. This can happen for instance when a thread exceeds 765 its maximum stack size. In this case, certain compilers implement 766 a stack overflow strategy that cause the handler to be run on a 767 different stack. */ 768 769 static int 770 frame_id_inner (struct gdbarch *gdbarch, struct frame_id l, struct frame_id r) 771 { 772 int inner; 773 774 if (l.stack_status != FID_STACK_VALID || r.stack_status != FID_STACK_VALID) 775 /* Like NaN, any operation involving an invalid ID always fails. 776 Likewise if either ID has an unavailable stack address. */ 777 inner = 0; 778 else if (l.artificial_depth > r.artificial_depth 779 && l.stack_addr == r.stack_addr 780 && l.code_addr_p == r.code_addr_p 781 && l.special_addr_p == r.special_addr_p 782 && l.special_addr == r.special_addr) 783 { 784 /* Same function, different inlined functions. */ 785 const struct block *lb, *rb; 786 787 gdb_assert (l.code_addr_p && r.code_addr_p); 788 789 lb = block_for_pc (l.code_addr); 790 rb = block_for_pc (r.code_addr); 791 792 if (lb == NULL || rb == NULL) 793 /* Something's gone wrong. */ 794 inner = 0; 795 else 796 /* This will return true if LB and RB are the same block, or 797 if the block with the smaller depth lexically encloses the 798 block with the greater depth. */ 799 inner = contained_in (lb, rb); 800 } 801 else 802 /* Only return non-zero when strictly inner than. Note that, per 803 comment in "frame.h", there is some fuzz here. Frameless 804 functions are not strictly inner than (same .stack but 805 different .code and/or .special address). */ 806 inner = gdbarch_inner_than (gdbarch, l.stack_addr, r.stack_addr); 807 if (frame_debug) 808 { 809 fprintf_unfiltered (gdb_stdlog, "{ frame_id_inner (l="); 810 fprint_frame_id (gdb_stdlog, l); 811 fprintf_unfiltered (gdb_stdlog, ",r="); 812 fprint_frame_id (gdb_stdlog, r); 813 fprintf_unfiltered (gdb_stdlog, ") -> %d }\n", inner); 814 } 815 return inner; 816 } 817 818 struct frame_info * 819 frame_find_by_id (struct frame_id id) 820 { 821 struct frame_info *frame, *prev_frame; 822 823 /* ZERO denotes the null frame, let the caller decide what to do 824 about it. Should it instead return get_current_frame()? */ 825 if (!frame_id_p (id)) 826 return NULL; 827 828 /* Check for the sentinel frame. */ 829 if (frame_id_eq (id, sentinel_frame_id)) 830 return sentinel_frame; 831 832 /* Try using the frame stash first. Finding it there removes the need 833 to perform the search by looping over all frames, which can be very 834 CPU-intensive if the number of frames is very high (the loop is O(n) 835 and get_prev_frame performs a series of checks that are relatively 836 expensive). This optimization is particularly useful when this function 837 is called from another function (such as value_fetch_lazy, case 838 VALUE_LVAL (val) == lval_register) which already loops over all frames, 839 making the overall behavior O(n^2). */ 840 frame = frame_stash_find (id); 841 if (frame) 842 return frame; 843 844 for (frame = get_current_frame (); ; frame = prev_frame) 845 { 846 struct frame_id self = get_frame_id (frame); 847 848 if (frame_id_eq (id, self)) 849 /* An exact match. */ 850 return frame; 851 852 prev_frame = get_prev_frame (frame); 853 if (!prev_frame) 854 return NULL; 855 856 /* As a safety net to avoid unnecessary backtracing while trying 857 to find an invalid ID, we check for a common situation where 858 we can detect from comparing stack addresses that no other 859 frame in the current frame chain can have this ID. See the 860 comment at frame_id_inner for details. */ 861 if (get_frame_type (frame) == NORMAL_FRAME 862 && !frame_id_inner (get_frame_arch (frame), id, self) 863 && frame_id_inner (get_frame_arch (prev_frame), id, 864 get_frame_id (prev_frame))) 865 return NULL; 866 } 867 return NULL; 868 } 869 870 static CORE_ADDR 871 frame_unwind_pc (struct frame_info *this_frame) 872 { 873 if (this_frame->prev_pc.status == CC_UNKNOWN) 874 { 875 struct gdbarch *prev_gdbarch; 876 CORE_ADDR pc = 0; 877 int pc_p = 0; 878 879 /* The right way. The `pure' way. The one true way. This 880 method depends solely on the register-unwind code to 881 determine the value of registers in THIS frame, and hence 882 the value of this frame's PC (resume address). A typical 883 implementation is no more than: 884 885 frame_unwind_register (this_frame, ISA_PC_REGNUM, buf); 886 return extract_unsigned_integer (buf, size of ISA_PC_REGNUM); 887 888 Note: this method is very heavily dependent on a correct 889 register-unwind implementation, it pays to fix that 890 method first; this method is frame type agnostic, since 891 it only deals with register values, it works with any 892 frame. This is all in stark contrast to the old 893 FRAME_SAVED_PC which would try to directly handle all the 894 different ways that a PC could be unwound. */ 895 prev_gdbarch = frame_unwind_arch (this_frame); 896 897 TRY 898 { 899 pc = gdbarch_unwind_pc (prev_gdbarch, this_frame); 900 pc_p = 1; 901 } 902 CATCH (ex, RETURN_MASK_ERROR) 903 { 904 if (ex.error == NOT_AVAILABLE_ERROR) 905 { 906 this_frame->prev_pc.status = CC_UNAVAILABLE; 907 908 if (frame_debug) 909 fprintf_unfiltered (gdb_stdlog, 910 "{ frame_unwind_pc (this_frame=%d)" 911 " -> <unavailable> }\n", 912 this_frame->level); 913 } 914 else if (ex.error == OPTIMIZED_OUT_ERROR) 915 { 916 this_frame->prev_pc.status = CC_NOT_SAVED; 917 918 if (frame_debug) 919 fprintf_unfiltered (gdb_stdlog, 920 "{ frame_unwind_pc (this_frame=%d)" 921 " -> <not saved> }\n", 922 this_frame->level); 923 } 924 else 925 throw_exception (ex); 926 } 927 END_CATCH 928 929 if (pc_p) 930 { 931 this_frame->prev_pc.value = pc; 932 this_frame->prev_pc.status = CC_VALUE; 933 if (frame_debug) 934 fprintf_unfiltered (gdb_stdlog, 935 "{ frame_unwind_pc (this_frame=%d) " 936 "-> %s }\n", 937 this_frame->level, 938 hex_string (this_frame->prev_pc.value)); 939 } 940 } 941 942 if (this_frame->prev_pc.status == CC_VALUE) 943 return this_frame->prev_pc.value; 944 else if (this_frame->prev_pc.status == CC_UNAVAILABLE) 945 throw_error (NOT_AVAILABLE_ERROR, _("PC not available")); 946 else if (this_frame->prev_pc.status == CC_NOT_SAVED) 947 throw_error (OPTIMIZED_OUT_ERROR, _("PC not saved")); 948 else 949 internal_error (__FILE__, __LINE__, 950 "unexpected prev_pc status: %d", 951 (int) this_frame->prev_pc.status); 952 } 953 954 CORE_ADDR 955 frame_unwind_caller_pc (struct frame_info *this_frame) 956 { 957 this_frame = skip_artificial_frames (this_frame); 958 959 /* We must have a non-artificial frame. The caller is supposed to check 960 the result of frame_unwind_caller_id (), which returns NULL_FRAME_ID 961 in this case. */ 962 gdb_assert (this_frame != NULL); 963 964 return frame_unwind_pc (this_frame); 965 } 966 967 int 968 get_frame_func_if_available (struct frame_info *this_frame, CORE_ADDR *pc) 969 { 970 struct frame_info *next_frame = this_frame->next; 971 972 if (!next_frame->prev_func.p) 973 { 974 CORE_ADDR addr_in_block; 975 976 /* Make certain that this, and not the adjacent, function is 977 found. */ 978 if (!get_frame_address_in_block_if_available (this_frame, &addr_in_block)) 979 { 980 next_frame->prev_func.p = -1; 981 if (frame_debug) 982 fprintf_unfiltered (gdb_stdlog, 983 "{ get_frame_func (this_frame=%d)" 984 " -> unavailable }\n", 985 this_frame->level); 986 } 987 else 988 { 989 next_frame->prev_func.p = 1; 990 next_frame->prev_func.addr = get_pc_function_start (addr_in_block); 991 if (frame_debug) 992 fprintf_unfiltered (gdb_stdlog, 993 "{ get_frame_func (this_frame=%d) -> %s }\n", 994 this_frame->level, 995 hex_string (next_frame->prev_func.addr)); 996 } 997 } 998 999 if (next_frame->prev_func.p < 0) 1000 { 1001 *pc = -1; 1002 return 0; 1003 } 1004 else 1005 { 1006 *pc = next_frame->prev_func.addr; 1007 return 1; 1008 } 1009 } 1010 1011 CORE_ADDR 1012 get_frame_func (struct frame_info *this_frame) 1013 { 1014 CORE_ADDR pc; 1015 1016 if (!get_frame_func_if_available (this_frame, &pc)) 1017 throw_error (NOT_AVAILABLE_ERROR, _("PC not available")); 1018 1019 return pc; 1020 } 1021 1022 std::unique_ptr<readonly_detached_regcache> 1023 frame_save_as_regcache (struct frame_info *this_frame) 1024 { 1025 auto cooked_read = [this_frame] (int regnum, gdb_byte *buf) 1026 { 1027 if (!deprecated_frame_register_read (this_frame, regnum, buf)) 1028 return REG_UNAVAILABLE; 1029 else 1030 return REG_VALID; 1031 }; 1032 1033 std::unique_ptr<readonly_detached_regcache> regcache 1034 (new readonly_detached_regcache (get_frame_arch (this_frame), cooked_read)); 1035 1036 return regcache; 1037 } 1038 1039 void 1040 frame_pop (struct frame_info *this_frame) 1041 { 1042 struct frame_info *prev_frame; 1043 1044 if (get_frame_type (this_frame) == DUMMY_FRAME) 1045 { 1046 /* Popping a dummy frame involves restoring more than just registers. 1047 dummy_frame_pop does all the work. */ 1048 dummy_frame_pop (get_frame_id (this_frame), inferior_thread ()); 1049 return; 1050 } 1051 1052 /* Ensure that we have a frame to pop to. */ 1053 prev_frame = get_prev_frame_always (this_frame); 1054 1055 if (!prev_frame) 1056 error (_("Cannot pop the initial frame.")); 1057 1058 /* Ignore TAILCALL_FRAME type frames, they were executed already before 1059 entering THISFRAME. */ 1060 prev_frame = skip_tailcall_frames (prev_frame); 1061 1062 if (prev_frame == NULL) 1063 error (_("Cannot find the caller frame.")); 1064 1065 /* Make a copy of all the register values unwound from this frame. 1066 Save them in a scratch buffer so that there isn't a race between 1067 trying to extract the old values from the current regcache while 1068 at the same time writing new values into that same cache. */ 1069 std::unique_ptr<readonly_detached_regcache> scratch 1070 = frame_save_as_regcache (prev_frame); 1071 1072 /* FIXME: cagney/2003-03-16: It should be possible to tell the 1073 target's register cache that it is about to be hit with a burst 1074 register transfer and that the sequence of register writes should 1075 be batched. The pair target_prepare_to_store() and 1076 target_store_registers() kind of suggest this functionality. 1077 Unfortunately, they don't implement it. Their lack of a formal 1078 definition can lead to targets writing back bogus values 1079 (arguably a bug in the target code mind). */ 1080 /* Now copy those saved registers into the current regcache. */ 1081 get_current_regcache ()->restore (scratch.get ()); 1082 1083 /* We've made right mess of GDB's local state, just discard 1084 everything. */ 1085 reinit_frame_cache (); 1086 } 1087 1088 void 1089 frame_register_unwind (frame_info *next_frame, int regnum, 1090 int *optimizedp, int *unavailablep, 1091 enum lval_type *lvalp, CORE_ADDR *addrp, 1092 int *realnump, gdb_byte *bufferp) 1093 { 1094 struct value *value; 1095 1096 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates 1097 that the value proper does not need to be fetched. */ 1098 gdb_assert (optimizedp != NULL); 1099 gdb_assert (lvalp != NULL); 1100 gdb_assert (addrp != NULL); 1101 gdb_assert (realnump != NULL); 1102 /* gdb_assert (bufferp != NULL); */ 1103 1104 value = frame_unwind_register_value (next_frame, regnum); 1105 1106 gdb_assert (value != NULL); 1107 1108 *optimizedp = value_optimized_out (value); 1109 *unavailablep = !value_entirely_available (value); 1110 *lvalp = VALUE_LVAL (value); 1111 *addrp = value_address (value); 1112 if (*lvalp == lval_register) 1113 *realnump = VALUE_REGNUM (value); 1114 else 1115 *realnump = -1; 1116 1117 if (bufferp) 1118 { 1119 if (!*optimizedp && !*unavailablep) 1120 memcpy (bufferp, value_contents_all (value), 1121 TYPE_LENGTH (value_type (value))); 1122 else 1123 memset (bufferp, 0, TYPE_LENGTH (value_type (value))); 1124 } 1125 1126 /* Dispose of the new value. This prevents watchpoints from 1127 trying to watch the saved frame pointer. */ 1128 release_value (value); 1129 } 1130 1131 void 1132 frame_register (struct frame_info *frame, int regnum, 1133 int *optimizedp, int *unavailablep, enum lval_type *lvalp, 1134 CORE_ADDR *addrp, int *realnump, gdb_byte *bufferp) 1135 { 1136 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates 1137 that the value proper does not need to be fetched. */ 1138 gdb_assert (optimizedp != NULL); 1139 gdb_assert (lvalp != NULL); 1140 gdb_assert (addrp != NULL); 1141 gdb_assert (realnump != NULL); 1142 /* gdb_assert (bufferp != NULL); */ 1143 1144 /* Obtain the register value by unwinding the register from the next 1145 (more inner frame). */ 1146 gdb_assert (frame != NULL && frame->next != NULL); 1147 frame_register_unwind (frame->next, regnum, optimizedp, unavailablep, 1148 lvalp, addrp, realnump, bufferp); 1149 } 1150 1151 void 1152 frame_unwind_register (frame_info *next_frame, int regnum, gdb_byte *buf) 1153 { 1154 int optimized; 1155 int unavailable; 1156 CORE_ADDR addr; 1157 int realnum; 1158 enum lval_type lval; 1159 1160 frame_register_unwind (next_frame, regnum, &optimized, &unavailable, 1161 &lval, &addr, &realnum, buf); 1162 1163 if (optimized) 1164 throw_error (OPTIMIZED_OUT_ERROR, 1165 _("Register %d was not saved"), regnum); 1166 if (unavailable) 1167 throw_error (NOT_AVAILABLE_ERROR, 1168 _("Register %d is not available"), regnum); 1169 } 1170 1171 void 1172 get_frame_register (struct frame_info *frame, 1173 int regnum, gdb_byte *buf) 1174 { 1175 frame_unwind_register (frame->next, regnum, buf); 1176 } 1177 1178 struct value * 1179 frame_unwind_register_value (frame_info *next_frame, int regnum) 1180 { 1181 struct gdbarch *gdbarch; 1182 struct value *value; 1183 1184 gdb_assert (next_frame != NULL); 1185 gdbarch = frame_unwind_arch (next_frame); 1186 1187 if (frame_debug) 1188 { 1189 fprintf_unfiltered (gdb_stdlog, 1190 "{ frame_unwind_register_value " 1191 "(frame=%d,regnum=%d(%s),...) ", 1192 next_frame->level, regnum, 1193 user_reg_map_regnum_to_name (gdbarch, regnum)); 1194 } 1195 1196 /* Find the unwinder. */ 1197 if (next_frame->unwind == NULL) 1198 frame_unwind_find_by_frame (next_frame, &next_frame->prologue_cache); 1199 1200 /* Ask this frame to unwind its register. */ 1201 value = next_frame->unwind->prev_register (next_frame, 1202 &next_frame->prologue_cache, 1203 regnum); 1204 1205 if (frame_debug) 1206 { 1207 fprintf_unfiltered (gdb_stdlog, "->"); 1208 if (value_optimized_out (value)) 1209 { 1210 fprintf_unfiltered (gdb_stdlog, " "); 1211 val_print_optimized_out (value, gdb_stdlog); 1212 } 1213 else 1214 { 1215 if (VALUE_LVAL (value) == lval_register) 1216 fprintf_unfiltered (gdb_stdlog, " register=%d", 1217 VALUE_REGNUM (value)); 1218 else if (VALUE_LVAL (value) == lval_memory) 1219 fprintf_unfiltered (gdb_stdlog, " address=%s", 1220 paddress (gdbarch, 1221 value_address (value))); 1222 else 1223 fprintf_unfiltered (gdb_stdlog, " computed"); 1224 1225 if (value_lazy (value)) 1226 fprintf_unfiltered (gdb_stdlog, " lazy"); 1227 else 1228 { 1229 int i; 1230 const gdb_byte *buf = value_contents (value); 1231 1232 fprintf_unfiltered (gdb_stdlog, " bytes="); 1233 fprintf_unfiltered (gdb_stdlog, "["); 1234 for (i = 0; i < register_size (gdbarch, regnum); i++) 1235 fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]); 1236 fprintf_unfiltered (gdb_stdlog, "]"); 1237 } 1238 } 1239 1240 fprintf_unfiltered (gdb_stdlog, " }\n"); 1241 } 1242 1243 return value; 1244 } 1245 1246 struct value * 1247 get_frame_register_value (struct frame_info *frame, int regnum) 1248 { 1249 return frame_unwind_register_value (frame->next, regnum); 1250 } 1251 1252 LONGEST 1253 frame_unwind_register_signed (frame_info *next_frame, int regnum) 1254 { 1255 struct gdbarch *gdbarch = frame_unwind_arch (next_frame); 1256 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 1257 int size = register_size (gdbarch, regnum); 1258 struct value *value = frame_unwind_register_value (next_frame, regnum); 1259 1260 gdb_assert (value != NULL); 1261 1262 if (value_optimized_out (value)) 1263 { 1264 throw_error (OPTIMIZED_OUT_ERROR, 1265 _("Register %d was not saved"), regnum); 1266 } 1267 if (!value_entirely_available (value)) 1268 { 1269 throw_error (NOT_AVAILABLE_ERROR, 1270 _("Register %d is not available"), regnum); 1271 } 1272 1273 LONGEST r = extract_signed_integer (value_contents_all (value), size, 1274 byte_order); 1275 1276 release_value (value); 1277 return r; 1278 } 1279 1280 LONGEST 1281 get_frame_register_signed (struct frame_info *frame, int regnum) 1282 { 1283 return frame_unwind_register_signed (frame->next, regnum); 1284 } 1285 1286 ULONGEST 1287 frame_unwind_register_unsigned (frame_info *next_frame, int regnum) 1288 { 1289 struct gdbarch *gdbarch = frame_unwind_arch (next_frame); 1290 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 1291 int size = register_size (gdbarch, regnum); 1292 struct value *value = frame_unwind_register_value (next_frame, regnum); 1293 1294 gdb_assert (value != NULL); 1295 1296 if (value_optimized_out (value)) 1297 { 1298 throw_error (OPTIMIZED_OUT_ERROR, 1299 _("Register %d was not saved"), regnum); 1300 } 1301 if (!value_entirely_available (value)) 1302 { 1303 throw_error (NOT_AVAILABLE_ERROR, 1304 _("Register %d is not available"), regnum); 1305 } 1306 1307 ULONGEST r = extract_unsigned_integer (value_contents_all (value), size, 1308 byte_order); 1309 1310 release_value (value); 1311 return r; 1312 } 1313 1314 ULONGEST 1315 get_frame_register_unsigned (struct frame_info *frame, int regnum) 1316 { 1317 return frame_unwind_register_unsigned (frame->next, regnum); 1318 } 1319 1320 int 1321 read_frame_register_unsigned (struct frame_info *frame, int regnum, 1322 ULONGEST *val) 1323 { 1324 struct value *regval = get_frame_register_value (frame, regnum); 1325 1326 if (!value_optimized_out (regval) 1327 && value_entirely_available (regval)) 1328 { 1329 struct gdbarch *gdbarch = get_frame_arch (frame); 1330 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 1331 int size = register_size (gdbarch, VALUE_REGNUM (regval)); 1332 1333 *val = extract_unsigned_integer (value_contents (regval), size, byte_order); 1334 return 1; 1335 } 1336 1337 return 0; 1338 } 1339 1340 void 1341 put_frame_register (struct frame_info *frame, int regnum, 1342 const gdb_byte *buf) 1343 { 1344 struct gdbarch *gdbarch = get_frame_arch (frame); 1345 int realnum; 1346 int optim; 1347 int unavail; 1348 enum lval_type lval; 1349 CORE_ADDR addr; 1350 1351 frame_register (frame, regnum, &optim, &unavail, 1352 &lval, &addr, &realnum, NULL); 1353 if (optim) 1354 error (_("Attempt to assign to a register that was not saved.")); 1355 switch (lval) 1356 { 1357 case lval_memory: 1358 { 1359 write_memory (addr, buf, register_size (gdbarch, regnum)); 1360 break; 1361 } 1362 case lval_register: 1363 get_current_regcache ()->cooked_write (realnum, buf); 1364 break; 1365 default: 1366 error (_("Attempt to assign to an unmodifiable value.")); 1367 } 1368 } 1369 1370 /* This function is deprecated. Use get_frame_register_value instead, 1371 which provides more accurate information. 1372 1373 Find and return the value of REGNUM for the specified stack frame. 1374 The number of bytes copied is REGISTER_SIZE (REGNUM). 1375 1376 Returns 0 if the register value could not be found. */ 1377 1378 int 1379 deprecated_frame_register_read (struct frame_info *frame, int regnum, 1380 gdb_byte *myaddr) 1381 { 1382 int optimized; 1383 int unavailable; 1384 enum lval_type lval; 1385 CORE_ADDR addr; 1386 int realnum; 1387 1388 frame_register (frame, regnum, &optimized, &unavailable, 1389 &lval, &addr, &realnum, myaddr); 1390 1391 return !optimized && !unavailable; 1392 } 1393 1394 int 1395 get_frame_register_bytes (struct frame_info *frame, int regnum, 1396 CORE_ADDR offset, int len, gdb_byte *myaddr, 1397 int *optimizedp, int *unavailablep) 1398 { 1399 struct gdbarch *gdbarch = get_frame_arch (frame); 1400 int i; 1401 int maxsize; 1402 int numregs; 1403 1404 /* Skip registers wholly inside of OFFSET. */ 1405 while (offset >= register_size (gdbarch, regnum)) 1406 { 1407 offset -= register_size (gdbarch, regnum); 1408 regnum++; 1409 } 1410 1411 /* Ensure that we will not read beyond the end of the register file. 1412 This can only ever happen if the debug information is bad. */ 1413 maxsize = -offset; 1414 numregs = gdbarch_num_cooked_regs (gdbarch); 1415 for (i = regnum; i < numregs; i++) 1416 { 1417 int thissize = register_size (gdbarch, i); 1418 1419 if (thissize == 0) 1420 break; /* This register is not available on this architecture. */ 1421 maxsize += thissize; 1422 } 1423 if (len > maxsize) 1424 error (_("Bad debug information detected: " 1425 "Attempt to read %d bytes from registers."), len); 1426 1427 /* Copy the data. */ 1428 while (len > 0) 1429 { 1430 int curr_len = register_size (gdbarch, regnum) - offset; 1431 1432 if (curr_len > len) 1433 curr_len = len; 1434 1435 if (curr_len == register_size (gdbarch, regnum)) 1436 { 1437 enum lval_type lval; 1438 CORE_ADDR addr; 1439 int realnum; 1440 1441 frame_register (frame, regnum, optimizedp, unavailablep, 1442 &lval, &addr, &realnum, myaddr); 1443 if (*optimizedp || *unavailablep) 1444 return 0; 1445 } 1446 else 1447 { 1448 struct value *value = frame_unwind_register_value (frame->next, 1449 regnum); 1450 gdb_assert (value != NULL); 1451 *optimizedp = value_optimized_out (value); 1452 *unavailablep = !value_entirely_available (value); 1453 1454 if (*optimizedp || *unavailablep) 1455 { 1456 release_value (value); 1457 return 0; 1458 } 1459 memcpy (myaddr, value_contents_all (value) + offset, curr_len); 1460 release_value (value); 1461 } 1462 1463 myaddr += curr_len; 1464 len -= curr_len; 1465 offset = 0; 1466 regnum++; 1467 } 1468 1469 *optimizedp = 0; 1470 *unavailablep = 0; 1471 return 1; 1472 } 1473 1474 void 1475 put_frame_register_bytes (struct frame_info *frame, int regnum, 1476 CORE_ADDR offset, int len, const gdb_byte *myaddr) 1477 { 1478 struct gdbarch *gdbarch = get_frame_arch (frame); 1479 1480 /* Skip registers wholly inside of OFFSET. */ 1481 while (offset >= register_size (gdbarch, regnum)) 1482 { 1483 offset -= register_size (gdbarch, regnum); 1484 regnum++; 1485 } 1486 1487 /* Copy the data. */ 1488 while (len > 0) 1489 { 1490 int curr_len = register_size (gdbarch, regnum) - offset; 1491 1492 if (curr_len > len) 1493 curr_len = len; 1494 1495 if (curr_len == register_size (gdbarch, regnum)) 1496 { 1497 put_frame_register (frame, regnum, myaddr); 1498 } 1499 else 1500 { 1501 struct value *value = frame_unwind_register_value (frame->next, 1502 regnum); 1503 gdb_assert (value != NULL); 1504 1505 memcpy ((char *) value_contents_writeable (value) + offset, myaddr, 1506 curr_len); 1507 put_frame_register (frame, regnum, value_contents_raw (value)); 1508 release_value (value); 1509 } 1510 1511 myaddr += curr_len; 1512 len -= curr_len; 1513 offset = 0; 1514 regnum++; 1515 } 1516 } 1517 1518 /* Create a sentinel frame. */ 1519 1520 static struct frame_info * 1521 create_sentinel_frame (struct program_space *pspace, struct regcache *regcache) 1522 { 1523 struct frame_info *frame = FRAME_OBSTACK_ZALLOC (struct frame_info); 1524 1525 frame->level = -1; 1526 frame->pspace = pspace; 1527 frame->aspace = regcache->aspace (); 1528 /* Explicitly initialize the sentinel frame's cache. Provide it 1529 with the underlying regcache. In the future additional 1530 information, such as the frame's thread will be added. */ 1531 frame->prologue_cache = sentinel_frame_cache (regcache); 1532 /* For the moment there is only one sentinel frame implementation. */ 1533 frame->unwind = &sentinel_frame_unwind; 1534 /* Link this frame back to itself. The frame is self referential 1535 (the unwound PC is the same as the pc), so make it so. */ 1536 frame->next = frame; 1537 /* The sentinel frame has a special ID. */ 1538 frame->this_id.p = 1; 1539 frame->this_id.value = sentinel_frame_id; 1540 if (frame_debug) 1541 { 1542 fprintf_unfiltered (gdb_stdlog, "{ create_sentinel_frame (...) -> "); 1543 fprint_frame (gdb_stdlog, frame); 1544 fprintf_unfiltered (gdb_stdlog, " }\n"); 1545 } 1546 return frame; 1547 } 1548 1549 /* Cache for frame addresses already read by gdb. Valid only while 1550 inferior is stopped. Control variables for the frame cache should 1551 be local to this module. */ 1552 1553 static struct obstack frame_cache_obstack; 1554 1555 void * 1556 frame_obstack_zalloc (unsigned long size) 1557 { 1558 void *data = obstack_alloc (&frame_cache_obstack, size); 1559 1560 memset (data, 0, size); 1561 return data; 1562 } 1563 1564 static struct frame_info *get_prev_frame_always_1 (struct frame_info *this_frame); 1565 1566 struct frame_info * 1567 get_current_frame (void) 1568 { 1569 struct frame_info *current_frame; 1570 1571 /* First check, and report, the lack of registers. Having GDB 1572 report "No stack!" or "No memory" when the target doesn't even 1573 have registers is very confusing. Besides, "printcmd.exp" 1574 explicitly checks that ``print $pc'' with no registers prints "No 1575 registers". */ 1576 if (!target_has_registers) 1577 error (_("No registers.")); 1578 if (!target_has_stack) 1579 error (_("No stack.")); 1580 if (!target_has_memory) 1581 error (_("No memory.")); 1582 /* Traceframes are effectively a substitute for the live inferior. */ 1583 if (get_traceframe_number () < 0) 1584 validate_registers_access (); 1585 1586 if (sentinel_frame == NULL) 1587 sentinel_frame = 1588 create_sentinel_frame (current_program_space, get_current_regcache ()); 1589 1590 /* Set the current frame before computing the frame id, to avoid 1591 recursion inside compute_frame_id, in case the frame's 1592 unwinder decides to do a symbol lookup (which depends on the 1593 selected frame's block). 1594 1595 This call must always succeed. In particular, nothing inside 1596 get_prev_frame_always_1 should try to unwind from the 1597 sentinel frame, because that could fail/throw, and we always 1598 want to leave with the current frame created and linked in -- 1599 we should never end up with the sentinel frame as outermost 1600 frame. */ 1601 current_frame = get_prev_frame_always_1 (sentinel_frame); 1602 gdb_assert (current_frame != NULL); 1603 1604 return current_frame; 1605 } 1606 1607 /* The "selected" stack frame is used by default for local and arg 1608 access. May be zero, for no selected frame. */ 1609 1610 static struct frame_info *selected_frame; 1611 1612 int 1613 has_stack_frames (void) 1614 { 1615 if (!target_has_registers || !target_has_stack || !target_has_memory) 1616 return 0; 1617 1618 /* Traceframes are effectively a substitute for the live inferior. */ 1619 if (get_traceframe_number () < 0) 1620 { 1621 /* No current inferior, no frame. */ 1622 if (inferior_ptid == null_ptid) 1623 return 0; 1624 1625 thread_info *tp = inferior_thread (); 1626 /* Don't try to read from a dead thread. */ 1627 if (tp->state == THREAD_EXITED) 1628 return 0; 1629 1630 /* ... or from a spinning thread. */ 1631 if (tp->executing) 1632 return 0; 1633 } 1634 1635 return 1; 1636 } 1637 1638 /* Return the selected frame. Always non-NULL (unless there isn't an 1639 inferior sufficient for creating a frame) in which case an error is 1640 thrown. */ 1641 1642 struct frame_info * 1643 get_selected_frame (const char *message) 1644 { 1645 if (selected_frame == NULL) 1646 { 1647 if (message != NULL && !has_stack_frames ()) 1648 error (("%s"), message); 1649 /* Hey! Don't trust this. It should really be re-finding the 1650 last selected frame of the currently selected thread. This, 1651 though, is better than nothing. */ 1652 select_frame (get_current_frame ()); 1653 } 1654 /* There is always a frame. */ 1655 gdb_assert (selected_frame != NULL); 1656 return selected_frame; 1657 } 1658 1659 /* If there is a selected frame, return it. Otherwise, return NULL. */ 1660 1661 struct frame_info * 1662 get_selected_frame_if_set (void) 1663 { 1664 return selected_frame; 1665 } 1666 1667 /* This is a variant of get_selected_frame() which can be called when 1668 the inferior does not have a frame; in that case it will return 1669 NULL instead of calling error(). */ 1670 1671 struct frame_info * 1672 deprecated_safe_get_selected_frame (void) 1673 { 1674 if (!has_stack_frames ()) 1675 return NULL; 1676 return get_selected_frame (NULL); 1677 } 1678 1679 /* Select frame FI (or NULL - to invalidate the current frame). */ 1680 1681 void 1682 select_frame (struct frame_info *fi) 1683 { 1684 selected_frame = fi; 1685 /* NOTE: cagney/2002-05-04: FI can be NULL. This occurs when the 1686 frame is being invalidated. */ 1687 1688 /* FIXME: kseitz/2002-08-28: It would be nice to call 1689 selected_frame_level_changed_event() right here, but due to limitations 1690 in the current interfaces, we would end up flooding UIs with events 1691 because select_frame() is used extensively internally. 1692 1693 Once we have frame-parameterized frame (and frame-related) commands, 1694 the event notification can be moved here, since this function will only 1695 be called when the user's selected frame is being changed. */ 1696 1697 /* Ensure that symbols for this frame are read in. Also, determine the 1698 source language of this frame, and switch to it if desired. */ 1699 if (fi) 1700 { 1701 CORE_ADDR pc; 1702 1703 /* We retrieve the frame's symtab by using the frame PC. 1704 However we cannot use the frame PC as-is, because it usually 1705 points to the instruction following the "call", which is 1706 sometimes the first instruction of another function. So we 1707 rely on get_frame_address_in_block() which provides us with a 1708 PC which is guaranteed to be inside the frame's code 1709 block. */ 1710 if (get_frame_address_in_block_if_available (fi, &pc)) 1711 { 1712 struct compunit_symtab *cust = find_pc_compunit_symtab (pc); 1713 1714 if (cust != NULL 1715 && compunit_language (cust) != current_language->la_language 1716 && compunit_language (cust) != language_unknown 1717 && language_mode == language_mode_auto) 1718 set_language (compunit_language (cust)); 1719 } 1720 } 1721 } 1722 1723 /* Create an arbitrary (i.e. address specified by user) or innermost frame. 1724 Always returns a non-NULL value. */ 1725 1726 struct frame_info * 1727 create_new_frame (CORE_ADDR addr, CORE_ADDR pc) 1728 { 1729 struct frame_info *fi; 1730 1731 if (frame_debug) 1732 { 1733 fprintf_unfiltered (gdb_stdlog, 1734 "{ create_new_frame (addr=%s, pc=%s) ", 1735 hex_string (addr), hex_string (pc)); 1736 } 1737 1738 fi = FRAME_OBSTACK_ZALLOC (struct frame_info); 1739 1740 fi->next = create_sentinel_frame (current_program_space, 1741 get_current_regcache ()); 1742 1743 /* Set/update this frame's cached PC value, found in the next frame. 1744 Do this before looking for this frame's unwinder. A sniffer is 1745 very likely to read this, and the corresponding unwinder is 1746 entitled to rely that the PC doesn't magically change. */ 1747 fi->next->prev_pc.value = pc; 1748 fi->next->prev_pc.status = CC_VALUE; 1749 1750 /* We currently assume that frame chain's can't cross spaces. */ 1751 fi->pspace = fi->next->pspace; 1752 fi->aspace = fi->next->aspace; 1753 1754 /* Select/initialize both the unwind function and the frame's type 1755 based on the PC. */ 1756 frame_unwind_find_by_frame (fi, &fi->prologue_cache); 1757 1758 fi->this_id.p = 1; 1759 fi->this_id.value = frame_id_build (addr, pc); 1760 1761 if (frame_debug) 1762 { 1763 fprintf_unfiltered (gdb_stdlog, "-> "); 1764 fprint_frame (gdb_stdlog, fi); 1765 fprintf_unfiltered (gdb_stdlog, " }\n"); 1766 } 1767 1768 return fi; 1769 } 1770 1771 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the 1772 innermost frame). Be careful to not fall off the bottom of the 1773 frame chain and onto the sentinel frame. */ 1774 1775 struct frame_info * 1776 get_next_frame (struct frame_info *this_frame) 1777 { 1778 if (this_frame->level > 0) 1779 return this_frame->next; 1780 else 1781 return NULL; 1782 } 1783 1784 /* Return the frame that THIS_FRAME calls. If THIS_FRAME is the 1785 innermost (i.e. current) frame, return the sentinel frame. Thus, 1786 unlike get_next_frame(), NULL will never be returned. */ 1787 1788 struct frame_info * 1789 get_next_frame_sentinel_okay (struct frame_info *this_frame) 1790 { 1791 gdb_assert (this_frame != NULL); 1792 1793 /* Note that, due to the manner in which the sentinel frame is 1794 constructed, this_frame->next still works even when this_frame 1795 is the sentinel frame. But we disallow it here anyway because 1796 calling get_next_frame_sentinel_okay() on the sentinel frame 1797 is likely a coding error. */ 1798 gdb_assert (this_frame != sentinel_frame); 1799 1800 return this_frame->next; 1801 } 1802 1803 /* Observer for the target_changed event. */ 1804 1805 static void 1806 frame_observer_target_changed (struct target_ops *target) 1807 { 1808 reinit_frame_cache (); 1809 } 1810 1811 /* Flush the entire frame cache. */ 1812 1813 void 1814 reinit_frame_cache (void) 1815 { 1816 struct frame_info *fi; 1817 1818 /* Tear down all frame caches. */ 1819 for (fi = sentinel_frame; fi != NULL; fi = fi->prev) 1820 { 1821 if (fi->prologue_cache && fi->unwind->dealloc_cache) 1822 fi->unwind->dealloc_cache (fi, fi->prologue_cache); 1823 if (fi->base_cache && fi->base->unwind->dealloc_cache) 1824 fi->base->unwind->dealloc_cache (fi, fi->base_cache); 1825 } 1826 1827 /* Since we can't really be sure what the first object allocated was. */ 1828 obstack_free (&frame_cache_obstack, 0); 1829 obstack_init (&frame_cache_obstack); 1830 1831 if (sentinel_frame != NULL) 1832 annotate_frames_invalid (); 1833 1834 sentinel_frame = NULL; /* Invalidate cache */ 1835 select_frame (NULL); 1836 frame_stash_invalidate (); 1837 if (frame_debug) 1838 fprintf_unfiltered (gdb_stdlog, "{ reinit_frame_cache () }\n"); 1839 } 1840 1841 /* Find where a register is saved (in memory or another register). 1842 The result of frame_register_unwind is just where it is saved 1843 relative to this particular frame. */ 1844 1845 static void 1846 frame_register_unwind_location (struct frame_info *this_frame, int regnum, 1847 int *optimizedp, enum lval_type *lvalp, 1848 CORE_ADDR *addrp, int *realnump) 1849 { 1850 gdb_assert (this_frame == NULL || this_frame->level >= 0); 1851 1852 while (this_frame != NULL) 1853 { 1854 int unavailable; 1855 1856 frame_register_unwind (this_frame, regnum, optimizedp, &unavailable, 1857 lvalp, addrp, realnump, NULL); 1858 1859 if (*optimizedp) 1860 break; 1861 1862 if (*lvalp != lval_register) 1863 break; 1864 1865 regnum = *realnump; 1866 this_frame = get_next_frame (this_frame); 1867 } 1868 } 1869 1870 /* Get the previous raw frame, and check that it is not identical to 1871 same other frame frame already in the chain. If it is, there is 1872 most likely a stack cycle, so we discard it, and mark THIS_FRAME as 1873 outermost, with UNWIND_SAME_ID stop reason. Unlike the other 1874 validity tests, that compare THIS_FRAME and the next frame, we do 1875 this right after creating the previous frame, to avoid ever ending 1876 up with two frames with the same id in the frame chain. */ 1877 1878 static struct frame_info * 1879 get_prev_frame_if_no_cycle (struct frame_info *this_frame) 1880 { 1881 struct frame_info *prev_frame; 1882 1883 prev_frame = get_prev_frame_raw (this_frame); 1884 1885 /* Don't compute the frame id of the current frame yet. Unwinding 1886 the sentinel frame can fail (e.g., if the thread is gone and we 1887 can't thus read its registers). If we let the cycle detection 1888 code below try to compute a frame ID, then an error thrown from 1889 within the frame ID computation would result in the sentinel 1890 frame as outermost frame, which is bogus. Instead, we'll compute 1891 the current frame's ID lazily in get_frame_id. Note that there's 1892 no point in doing cycle detection when there's only one frame, so 1893 nothing is lost here. */ 1894 if (prev_frame->level == 0) 1895 return prev_frame; 1896 1897 TRY 1898 { 1899 compute_frame_id (prev_frame); 1900 if (!frame_stash_add (prev_frame)) 1901 { 1902 /* Another frame with the same id was already in the stash. We just 1903 detected a cycle. */ 1904 if (frame_debug) 1905 { 1906 fprintf_unfiltered (gdb_stdlog, "-> "); 1907 fprint_frame (gdb_stdlog, NULL); 1908 fprintf_unfiltered (gdb_stdlog, " // this frame has same ID }\n"); 1909 } 1910 this_frame->stop_reason = UNWIND_SAME_ID; 1911 /* Unlink. */ 1912 prev_frame->next = NULL; 1913 this_frame->prev = NULL; 1914 prev_frame = NULL; 1915 } 1916 } 1917 CATCH (ex, RETURN_MASK_ALL) 1918 { 1919 prev_frame->next = NULL; 1920 this_frame->prev = NULL; 1921 1922 throw_exception (ex); 1923 } 1924 END_CATCH 1925 1926 return prev_frame; 1927 } 1928 1929 /* Helper function for get_prev_frame_always, this is called inside a 1930 TRY_CATCH block. Return the frame that called THIS_FRAME or NULL if 1931 there is no such frame. This may throw an exception. */ 1932 1933 static struct frame_info * 1934 get_prev_frame_always_1 (struct frame_info *this_frame) 1935 { 1936 struct gdbarch *gdbarch; 1937 1938 gdb_assert (this_frame != NULL); 1939 gdbarch = get_frame_arch (this_frame); 1940 1941 if (frame_debug) 1942 { 1943 fprintf_unfiltered (gdb_stdlog, "{ get_prev_frame_always (this_frame="); 1944 if (this_frame != NULL) 1945 fprintf_unfiltered (gdb_stdlog, "%d", this_frame->level); 1946 else 1947 fprintf_unfiltered (gdb_stdlog, "<NULL>"); 1948 fprintf_unfiltered (gdb_stdlog, ") "); 1949 } 1950 1951 /* Only try to do the unwind once. */ 1952 if (this_frame->prev_p) 1953 { 1954 if (frame_debug) 1955 { 1956 fprintf_unfiltered (gdb_stdlog, "-> "); 1957 fprint_frame (gdb_stdlog, this_frame->prev); 1958 fprintf_unfiltered (gdb_stdlog, " // cached \n"); 1959 } 1960 return this_frame->prev; 1961 } 1962 1963 /* If the frame unwinder hasn't been selected yet, we must do so 1964 before setting prev_p; otherwise the check for misbehaved 1965 sniffers will think that this frame's sniffer tried to unwind 1966 further (see frame_cleanup_after_sniffer). */ 1967 if (this_frame->unwind == NULL) 1968 frame_unwind_find_by_frame (this_frame, &this_frame->prologue_cache); 1969 1970 this_frame->prev_p = 1; 1971 this_frame->stop_reason = UNWIND_NO_REASON; 1972 1973 /* If we are unwinding from an inline frame, all of the below tests 1974 were already performed when we unwound from the next non-inline 1975 frame. We must skip them, since we can not get THIS_FRAME's ID 1976 until we have unwound all the way down to the previous non-inline 1977 frame. */ 1978 if (get_frame_type (this_frame) == INLINE_FRAME) 1979 return get_prev_frame_if_no_cycle (this_frame); 1980 1981 /* Check that this frame is unwindable. If it isn't, don't try to 1982 unwind to the prev frame. */ 1983 this_frame->stop_reason 1984 = this_frame->unwind->stop_reason (this_frame, 1985 &this_frame->prologue_cache); 1986 1987 if (this_frame->stop_reason != UNWIND_NO_REASON) 1988 { 1989 if (frame_debug) 1990 { 1991 enum unwind_stop_reason reason = this_frame->stop_reason; 1992 1993 fprintf_unfiltered (gdb_stdlog, "-> "); 1994 fprint_frame (gdb_stdlog, NULL); 1995 fprintf_unfiltered (gdb_stdlog, " // %s }\n", 1996 frame_stop_reason_symbol_string (reason)); 1997 } 1998 return NULL; 1999 } 2000 2001 /* Check that this frame's ID isn't inner to (younger, below, next) 2002 the next frame. This happens when a frame unwind goes backwards. 2003 This check is valid only if this frame and the next frame are NORMAL. 2004 See the comment at frame_id_inner for details. */ 2005 if (get_frame_type (this_frame) == NORMAL_FRAME 2006 && this_frame->next->unwind->type == NORMAL_FRAME 2007 && frame_id_inner (get_frame_arch (this_frame->next), 2008 get_frame_id (this_frame), 2009 get_frame_id (this_frame->next))) 2010 { 2011 CORE_ADDR this_pc_in_block; 2012 struct minimal_symbol *morestack_msym; 2013 const char *morestack_name = NULL; 2014 2015 /* gcc -fsplit-stack __morestack can continue the stack anywhere. */ 2016 this_pc_in_block = get_frame_address_in_block (this_frame); 2017 morestack_msym = lookup_minimal_symbol_by_pc (this_pc_in_block).minsym; 2018 if (morestack_msym) 2019 morestack_name = MSYMBOL_LINKAGE_NAME (morestack_msym); 2020 if (!morestack_name || strcmp (morestack_name, "__morestack") != 0) 2021 { 2022 if (frame_debug) 2023 { 2024 fprintf_unfiltered (gdb_stdlog, "-> "); 2025 fprint_frame (gdb_stdlog, NULL); 2026 fprintf_unfiltered (gdb_stdlog, 2027 " // this frame ID is inner }\n"); 2028 } 2029 this_frame->stop_reason = UNWIND_INNER_ID; 2030 return NULL; 2031 } 2032 } 2033 2034 /* Check that this and the next frame do not unwind the PC register 2035 to the same memory location. If they do, then even though they 2036 have different frame IDs, the new frame will be bogus; two 2037 functions can't share a register save slot for the PC. This can 2038 happen when the prologue analyzer finds a stack adjustment, but 2039 no PC save. 2040 2041 This check does assume that the "PC register" is roughly a 2042 traditional PC, even if the gdbarch_unwind_pc method adjusts 2043 it (we do not rely on the value, only on the unwound PC being 2044 dependent on this value). A potential improvement would be 2045 to have the frame prev_pc method and the gdbarch unwind_pc 2046 method set the same lval and location information as 2047 frame_register_unwind. */ 2048 if (this_frame->level > 0 2049 && gdbarch_pc_regnum (gdbarch) >= 0 2050 && get_frame_type (this_frame) == NORMAL_FRAME 2051 && (get_frame_type (this_frame->next) == NORMAL_FRAME 2052 || get_frame_type (this_frame->next) == INLINE_FRAME)) 2053 { 2054 int optimized, realnum, nrealnum; 2055 enum lval_type lval, nlval; 2056 CORE_ADDR addr, naddr; 2057 2058 frame_register_unwind_location (this_frame, 2059 gdbarch_pc_regnum (gdbarch), 2060 &optimized, &lval, &addr, &realnum); 2061 frame_register_unwind_location (get_next_frame (this_frame), 2062 gdbarch_pc_regnum (gdbarch), 2063 &optimized, &nlval, &naddr, &nrealnum); 2064 2065 if ((lval == lval_memory && lval == nlval && addr == naddr) 2066 || (lval == lval_register && lval == nlval && realnum == nrealnum)) 2067 { 2068 if (frame_debug) 2069 { 2070 fprintf_unfiltered (gdb_stdlog, "-> "); 2071 fprint_frame (gdb_stdlog, NULL); 2072 fprintf_unfiltered (gdb_stdlog, " // no saved PC }\n"); 2073 } 2074 2075 this_frame->stop_reason = UNWIND_NO_SAVED_PC; 2076 this_frame->prev = NULL; 2077 return NULL; 2078 } 2079 } 2080 2081 return get_prev_frame_if_no_cycle (this_frame); 2082 } 2083 2084 /* Return a "struct frame_info" corresponding to the frame that called 2085 THIS_FRAME. Returns NULL if there is no such frame. 2086 2087 Unlike get_prev_frame, this function always tries to unwind the 2088 frame. */ 2089 2090 struct frame_info * 2091 get_prev_frame_always (struct frame_info *this_frame) 2092 { 2093 struct frame_info *prev_frame = NULL; 2094 2095 TRY 2096 { 2097 prev_frame = get_prev_frame_always_1 (this_frame); 2098 } 2099 CATCH (ex, RETURN_MASK_ERROR) 2100 { 2101 if (ex.error == MEMORY_ERROR) 2102 { 2103 this_frame->stop_reason = UNWIND_MEMORY_ERROR; 2104 if (ex.message != NULL) 2105 { 2106 char *stop_string; 2107 size_t size; 2108 2109 /* The error needs to live as long as the frame does. 2110 Allocate using stack local STOP_STRING then assign the 2111 pointer to the frame, this allows the STOP_STRING on the 2112 frame to be of type 'const char *'. */ 2113 size = strlen (ex.message) + 1; 2114 stop_string = (char *) frame_obstack_zalloc (size); 2115 memcpy (stop_string, ex.message, size); 2116 this_frame->stop_string = stop_string; 2117 } 2118 prev_frame = NULL; 2119 } 2120 else 2121 throw_exception (ex); 2122 } 2123 END_CATCH 2124 2125 return prev_frame; 2126 } 2127 2128 /* Construct a new "struct frame_info" and link it previous to 2129 this_frame. */ 2130 2131 static struct frame_info * 2132 get_prev_frame_raw (struct frame_info *this_frame) 2133 { 2134 struct frame_info *prev_frame; 2135 2136 /* Allocate the new frame but do not wire it in to the frame chain. 2137 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along 2138 frame->next to pull some fancy tricks (of course such code is, by 2139 definition, recursive). Try to prevent it. 2140 2141 There is no reason to worry about memory leaks, should the 2142 remainder of the function fail. The allocated memory will be 2143 quickly reclaimed when the frame cache is flushed, and the `we've 2144 been here before' check above will stop repeated memory 2145 allocation calls. */ 2146 prev_frame = FRAME_OBSTACK_ZALLOC (struct frame_info); 2147 prev_frame->level = this_frame->level + 1; 2148 2149 /* For now, assume we don't have frame chains crossing address 2150 spaces. */ 2151 prev_frame->pspace = this_frame->pspace; 2152 prev_frame->aspace = this_frame->aspace; 2153 2154 /* Don't yet compute ->unwind (and hence ->type). It is computed 2155 on-demand in get_frame_type, frame_register_unwind, and 2156 get_frame_id. */ 2157 2158 /* Don't yet compute the frame's ID. It is computed on-demand by 2159 get_frame_id(). */ 2160 2161 /* The unwound frame ID is validate at the start of this function, 2162 as part of the logic to decide if that frame should be further 2163 unwound, and not here while the prev frame is being created. 2164 Doing this makes it possible for the user to examine a frame that 2165 has an invalid frame ID. 2166 2167 Some very old VAX code noted: [...] For the sake of argument, 2168 suppose that the stack is somewhat trashed (which is one reason 2169 that "info frame" exists). So, return 0 (indicating we don't 2170 know the address of the arglist) if we don't know what frame this 2171 frame calls. */ 2172 2173 /* Link it in. */ 2174 this_frame->prev = prev_frame; 2175 prev_frame->next = this_frame; 2176 2177 if (frame_debug) 2178 { 2179 fprintf_unfiltered (gdb_stdlog, "-> "); 2180 fprint_frame (gdb_stdlog, prev_frame); 2181 fprintf_unfiltered (gdb_stdlog, " }\n"); 2182 } 2183 2184 return prev_frame; 2185 } 2186 2187 /* Debug routine to print a NULL frame being returned. */ 2188 2189 static void 2190 frame_debug_got_null_frame (struct frame_info *this_frame, 2191 const char *reason) 2192 { 2193 if (frame_debug) 2194 { 2195 fprintf_unfiltered (gdb_stdlog, "{ get_prev_frame (this_frame="); 2196 if (this_frame != NULL) 2197 fprintf_unfiltered (gdb_stdlog, "%d", this_frame->level); 2198 else 2199 fprintf_unfiltered (gdb_stdlog, "<NULL>"); 2200 fprintf_unfiltered (gdb_stdlog, ") -> // %s}\n", reason); 2201 } 2202 } 2203 2204 /* Is this (non-sentinel) frame in the "main"() function? */ 2205 2206 static int 2207 inside_main_func (struct frame_info *this_frame) 2208 { 2209 struct bound_minimal_symbol msymbol; 2210 CORE_ADDR maddr; 2211 2212 if (symfile_objfile == 0) 2213 return 0; 2214 msymbol = lookup_minimal_symbol (main_name (), NULL, symfile_objfile); 2215 if (msymbol.minsym == NULL) 2216 return 0; 2217 /* Make certain that the code, and not descriptor, address is 2218 returned. */ 2219 maddr = gdbarch_convert_from_func_ptr_addr (get_frame_arch (this_frame), 2220 BMSYMBOL_VALUE_ADDRESS (msymbol), 2221 current_top_target ()); 2222 return maddr == get_frame_func (this_frame); 2223 } 2224 2225 /* Test whether THIS_FRAME is inside the process entry point function. */ 2226 2227 static int 2228 inside_entry_func (struct frame_info *this_frame) 2229 { 2230 CORE_ADDR entry_point; 2231 2232 if (!entry_point_address_query (&entry_point)) 2233 return 0; 2234 2235 return get_frame_func (this_frame) == entry_point; 2236 } 2237 2238 /* Return a structure containing various interesting information about 2239 the frame that called THIS_FRAME. Returns NULL if there is entier 2240 no such frame or the frame fails any of a set of target-independent 2241 condition that should terminate the frame chain (e.g., as unwinding 2242 past main()). 2243 2244 This function should not contain target-dependent tests, such as 2245 checking whether the program-counter is zero. */ 2246 2247 struct frame_info * 2248 get_prev_frame (struct frame_info *this_frame) 2249 { 2250 CORE_ADDR frame_pc; 2251 int frame_pc_p; 2252 2253 /* There is always a frame. If this assertion fails, suspect that 2254 something should be calling get_selected_frame() or 2255 get_current_frame(). */ 2256 gdb_assert (this_frame != NULL); 2257 2258 /* If this_frame is the current frame, then compute and stash 2259 its frame id prior to fetching and computing the frame id of the 2260 previous frame. Otherwise, the cycle detection code in 2261 get_prev_frame_if_no_cycle() will not work correctly. When 2262 get_frame_id() is called later on, an assertion error will 2263 be triggered in the event of a cycle between the current 2264 frame and its previous frame. */ 2265 if (this_frame->level == 0) 2266 get_frame_id (this_frame); 2267 2268 frame_pc_p = get_frame_pc_if_available (this_frame, &frame_pc); 2269 2270 /* tausq/2004-12-07: Dummy frames are skipped because it doesn't make much 2271 sense to stop unwinding at a dummy frame. One place where a dummy 2272 frame may have an address "inside_main_func" is on HPUX. On HPUX, the 2273 pcsqh register (space register for the instruction at the head of the 2274 instruction queue) cannot be written directly; the only way to set it 2275 is to branch to code that is in the target space. In order to implement 2276 frame dummies on HPUX, the called function is made to jump back to where 2277 the inferior was when the user function was called. If gdb was inside 2278 the main function when we created the dummy frame, the dummy frame will 2279 point inside the main function. */ 2280 if (this_frame->level >= 0 2281 && get_frame_type (this_frame) == NORMAL_FRAME 2282 && !backtrace_past_main 2283 && frame_pc_p 2284 && inside_main_func (this_frame)) 2285 /* Don't unwind past main(). Note, this is done _before_ the 2286 frame has been marked as previously unwound. That way if the 2287 user later decides to enable unwinds past main(), that will 2288 automatically happen. */ 2289 { 2290 frame_debug_got_null_frame (this_frame, "inside main func"); 2291 return NULL; 2292 } 2293 2294 /* If the user's backtrace limit has been exceeded, stop. We must 2295 add two to the current level; one of those accounts for backtrace_limit 2296 being 1-based and the level being 0-based, and the other accounts for 2297 the level of the new frame instead of the level of the current 2298 frame. */ 2299 if (this_frame->level + 2 > backtrace_limit) 2300 { 2301 frame_debug_got_null_frame (this_frame, "backtrace limit exceeded"); 2302 return NULL; 2303 } 2304 2305 /* If we're already inside the entry function for the main objfile, 2306 then it isn't valid. Don't apply this test to a dummy frame - 2307 dummy frame PCs typically land in the entry func. Don't apply 2308 this test to the sentinel frame. Sentinel frames should always 2309 be allowed to unwind. */ 2310 /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() - 2311 wasn't checking for "main" in the minimal symbols. With that 2312 fixed asm-source tests now stop in "main" instead of halting the 2313 backtrace in weird and wonderful ways somewhere inside the entry 2314 file. Suspect that tests for inside the entry file/func were 2315 added to work around that (now fixed) case. */ 2316 /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right) 2317 suggested having the inside_entry_func test use the 2318 inside_main_func() msymbol trick (along with entry_point_address() 2319 I guess) to determine the address range of the start function. 2320 That should provide a far better stopper than the current 2321 heuristics. */ 2322 /* NOTE: tausq/2004-10-09: this is needed if, for example, the compiler 2323 applied tail-call optimizations to main so that a function called 2324 from main returns directly to the caller of main. Since we don't 2325 stop at main, we should at least stop at the entry point of the 2326 application. */ 2327 if (this_frame->level >= 0 2328 && get_frame_type (this_frame) == NORMAL_FRAME 2329 && !backtrace_past_entry 2330 && frame_pc_p 2331 && inside_entry_func (this_frame)) 2332 { 2333 frame_debug_got_null_frame (this_frame, "inside entry func"); 2334 return NULL; 2335 } 2336 2337 /* Assume that the only way to get a zero PC is through something 2338 like a SIGSEGV or a dummy frame, and hence that NORMAL frames 2339 will never unwind a zero PC. */ 2340 if (this_frame->level > 0 2341 && (get_frame_type (this_frame) == NORMAL_FRAME 2342 || get_frame_type (this_frame) == INLINE_FRAME) 2343 && get_frame_type (get_next_frame (this_frame)) == NORMAL_FRAME 2344 && frame_pc_p && frame_pc == 0) 2345 { 2346 frame_debug_got_null_frame (this_frame, "zero PC"); 2347 return NULL; 2348 } 2349 2350 return get_prev_frame_always (this_frame); 2351 } 2352 2353 struct frame_id 2354 get_prev_frame_id_by_id (struct frame_id id) 2355 { 2356 struct frame_id prev_id; 2357 struct frame_info *frame; 2358 2359 frame = frame_find_by_id (id); 2360 2361 if (frame != NULL) 2362 prev_id = get_frame_id (get_prev_frame (frame)); 2363 else 2364 prev_id = null_frame_id; 2365 2366 return prev_id; 2367 } 2368 2369 CORE_ADDR 2370 get_frame_pc (struct frame_info *frame) 2371 { 2372 gdb_assert (frame->next != NULL); 2373 return frame_unwind_pc (frame->next); 2374 } 2375 2376 int 2377 get_frame_pc_if_available (struct frame_info *frame, CORE_ADDR *pc) 2378 { 2379 2380 gdb_assert (frame->next != NULL); 2381 2382 TRY 2383 { 2384 *pc = frame_unwind_pc (frame->next); 2385 } 2386 CATCH (ex, RETURN_MASK_ERROR) 2387 { 2388 if (ex.error == NOT_AVAILABLE_ERROR) 2389 return 0; 2390 else 2391 throw_exception (ex); 2392 } 2393 END_CATCH 2394 2395 return 1; 2396 } 2397 2398 /* Return an address that falls within THIS_FRAME's code block. */ 2399 2400 CORE_ADDR 2401 get_frame_address_in_block (struct frame_info *this_frame) 2402 { 2403 /* A draft address. */ 2404 CORE_ADDR pc = get_frame_pc (this_frame); 2405 2406 struct frame_info *next_frame = this_frame->next; 2407 2408 /* Calling get_frame_pc returns the resume address for THIS_FRAME. 2409 Normally the resume address is inside the body of the function 2410 associated with THIS_FRAME, but there is a special case: when 2411 calling a function which the compiler knows will never return 2412 (for instance abort), the call may be the very last instruction 2413 in the calling function. The resume address will point after the 2414 call and may be at the beginning of a different function 2415 entirely. 2416 2417 If THIS_FRAME is a signal frame or dummy frame, then we should 2418 not adjust the unwound PC. For a dummy frame, GDB pushed the 2419 resume address manually onto the stack. For a signal frame, the 2420 OS may have pushed the resume address manually and invoked the 2421 handler (e.g. GNU/Linux), or invoked the trampoline which called 2422 the signal handler - but in either case the signal handler is 2423 expected to return to the trampoline. So in both of these 2424 cases we know that the resume address is executable and 2425 related. So we only need to adjust the PC if THIS_FRAME 2426 is a normal function. 2427 2428 If the program has been interrupted while THIS_FRAME is current, 2429 then clearly the resume address is inside the associated 2430 function. There are three kinds of interruption: debugger stop 2431 (next frame will be SENTINEL_FRAME), operating system 2432 signal or exception (next frame will be SIGTRAMP_FRAME), 2433 or debugger-induced function call (next frame will be 2434 DUMMY_FRAME). So we only need to adjust the PC if 2435 NEXT_FRAME is a normal function. 2436 2437 We check the type of NEXT_FRAME first, since it is already 2438 known; frame type is determined by the unwinder, and since 2439 we have THIS_FRAME we've already selected an unwinder for 2440 NEXT_FRAME. 2441 2442 If the next frame is inlined, we need to keep going until we find 2443 the real function - for instance, if a signal handler is invoked 2444 while in an inlined function, then the code address of the 2445 "calling" normal function should not be adjusted either. */ 2446 2447 while (get_frame_type (next_frame) == INLINE_FRAME) 2448 next_frame = next_frame->next; 2449 2450 if ((get_frame_type (next_frame) == NORMAL_FRAME 2451 || get_frame_type (next_frame) == TAILCALL_FRAME) 2452 && (get_frame_type (this_frame) == NORMAL_FRAME 2453 || get_frame_type (this_frame) == TAILCALL_FRAME 2454 || get_frame_type (this_frame) == INLINE_FRAME)) 2455 return pc - 1; 2456 2457 return pc; 2458 } 2459 2460 int 2461 get_frame_address_in_block_if_available (struct frame_info *this_frame, 2462 CORE_ADDR *pc) 2463 { 2464 2465 TRY 2466 { 2467 *pc = get_frame_address_in_block (this_frame); 2468 } 2469 CATCH (ex, RETURN_MASK_ERROR) 2470 { 2471 if (ex.error == NOT_AVAILABLE_ERROR) 2472 return 0; 2473 throw_exception (ex); 2474 } 2475 END_CATCH 2476 2477 return 1; 2478 } 2479 2480 symtab_and_line 2481 find_frame_sal (frame_info *frame) 2482 { 2483 struct frame_info *next_frame; 2484 int notcurrent; 2485 CORE_ADDR pc; 2486 2487 /* If the next frame represents an inlined function call, this frame's 2488 sal is the "call site" of that inlined function, which can not 2489 be inferred from get_frame_pc. */ 2490 next_frame = get_next_frame (frame); 2491 if (frame_inlined_callees (frame) > 0) 2492 { 2493 struct symbol *sym; 2494 2495 if (next_frame) 2496 sym = get_frame_function (next_frame); 2497 else 2498 sym = inline_skipped_symbol (inferior_thread ()); 2499 2500 /* If frame is inline, it certainly has symbols. */ 2501 gdb_assert (sym); 2502 2503 symtab_and_line sal; 2504 if (SYMBOL_LINE (sym) != 0) 2505 { 2506 sal.symtab = symbol_symtab (sym); 2507 sal.line = SYMBOL_LINE (sym); 2508 } 2509 else 2510 /* If the symbol does not have a location, we don't know where 2511 the call site is. Do not pretend to. This is jarring, but 2512 we can't do much better. */ 2513 sal.pc = get_frame_pc (frame); 2514 2515 sal.pspace = get_frame_program_space (frame); 2516 return sal; 2517 } 2518 2519 /* If FRAME is not the innermost frame, that normally means that 2520 FRAME->pc points at the return instruction (which is *after* the 2521 call instruction), and we want to get the line containing the 2522 call (because the call is where the user thinks the program is). 2523 However, if the next frame is either a SIGTRAMP_FRAME or a 2524 DUMMY_FRAME, then the next frame will contain a saved interrupt 2525 PC and such a PC indicates the current (rather than next) 2526 instruction/line, consequently, for such cases, want to get the 2527 line containing fi->pc. */ 2528 if (!get_frame_pc_if_available (frame, &pc)) 2529 return {}; 2530 2531 notcurrent = (pc != get_frame_address_in_block (frame)); 2532 return find_pc_line (pc, notcurrent); 2533 } 2534 2535 /* Per "frame.h", return the ``address'' of the frame. Code should 2536 really be using get_frame_id(). */ 2537 CORE_ADDR 2538 get_frame_base (struct frame_info *fi) 2539 { 2540 return get_frame_id (fi).stack_addr; 2541 } 2542 2543 /* High-level offsets into the frame. Used by the debug info. */ 2544 2545 CORE_ADDR 2546 get_frame_base_address (struct frame_info *fi) 2547 { 2548 if (get_frame_type (fi) != NORMAL_FRAME) 2549 return 0; 2550 if (fi->base == NULL) 2551 fi->base = frame_base_find_by_frame (fi); 2552 /* Sneaky: If the low-level unwind and high-level base code share a 2553 common unwinder, let them share the prologue cache. */ 2554 if (fi->base->unwind == fi->unwind) 2555 return fi->base->this_base (fi, &fi->prologue_cache); 2556 return fi->base->this_base (fi, &fi->base_cache); 2557 } 2558 2559 CORE_ADDR 2560 get_frame_locals_address (struct frame_info *fi) 2561 { 2562 if (get_frame_type (fi) != NORMAL_FRAME) 2563 return 0; 2564 /* If there isn't a frame address method, find it. */ 2565 if (fi->base == NULL) 2566 fi->base = frame_base_find_by_frame (fi); 2567 /* Sneaky: If the low-level unwind and high-level base code share a 2568 common unwinder, let them share the prologue cache. */ 2569 if (fi->base->unwind == fi->unwind) 2570 return fi->base->this_locals (fi, &fi->prologue_cache); 2571 return fi->base->this_locals (fi, &fi->base_cache); 2572 } 2573 2574 CORE_ADDR 2575 get_frame_args_address (struct frame_info *fi) 2576 { 2577 if (get_frame_type (fi) != NORMAL_FRAME) 2578 return 0; 2579 /* If there isn't a frame address method, find it. */ 2580 if (fi->base == NULL) 2581 fi->base = frame_base_find_by_frame (fi); 2582 /* Sneaky: If the low-level unwind and high-level base code share a 2583 common unwinder, let them share the prologue cache. */ 2584 if (fi->base->unwind == fi->unwind) 2585 return fi->base->this_args (fi, &fi->prologue_cache); 2586 return fi->base->this_args (fi, &fi->base_cache); 2587 } 2588 2589 /* Return true if the frame unwinder for frame FI is UNWINDER; false 2590 otherwise. */ 2591 2592 int 2593 frame_unwinder_is (struct frame_info *fi, const struct frame_unwind *unwinder) 2594 { 2595 if (fi->unwind == NULL) 2596 frame_unwind_find_by_frame (fi, &fi->prologue_cache); 2597 return fi->unwind == unwinder; 2598 } 2599 2600 /* Level of the selected frame: 0 for innermost, 1 for its caller, ... 2601 or -1 for a NULL frame. */ 2602 2603 int 2604 frame_relative_level (struct frame_info *fi) 2605 { 2606 if (fi == NULL) 2607 return -1; 2608 else 2609 return fi->level; 2610 } 2611 2612 enum frame_type 2613 get_frame_type (struct frame_info *frame) 2614 { 2615 if (frame->unwind == NULL) 2616 /* Initialize the frame's unwinder because that's what 2617 provides the frame's type. */ 2618 frame_unwind_find_by_frame (frame, &frame->prologue_cache); 2619 return frame->unwind->type; 2620 } 2621 2622 struct program_space * 2623 get_frame_program_space (struct frame_info *frame) 2624 { 2625 return frame->pspace; 2626 } 2627 2628 struct program_space * 2629 frame_unwind_program_space (struct frame_info *this_frame) 2630 { 2631 gdb_assert (this_frame); 2632 2633 /* This is really a placeholder to keep the API consistent --- we 2634 assume for now that we don't have frame chains crossing 2635 spaces. */ 2636 return this_frame->pspace; 2637 } 2638 2639 const address_space * 2640 get_frame_address_space (struct frame_info *frame) 2641 { 2642 return frame->aspace; 2643 } 2644 2645 /* Memory access methods. */ 2646 2647 void 2648 get_frame_memory (struct frame_info *this_frame, CORE_ADDR addr, 2649 gdb_byte *buf, int len) 2650 { 2651 read_memory (addr, buf, len); 2652 } 2653 2654 LONGEST 2655 get_frame_memory_signed (struct frame_info *this_frame, CORE_ADDR addr, 2656 int len) 2657 { 2658 struct gdbarch *gdbarch = get_frame_arch (this_frame); 2659 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 2660 2661 return read_memory_integer (addr, len, byte_order); 2662 } 2663 2664 ULONGEST 2665 get_frame_memory_unsigned (struct frame_info *this_frame, CORE_ADDR addr, 2666 int len) 2667 { 2668 struct gdbarch *gdbarch = get_frame_arch (this_frame); 2669 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 2670 2671 return read_memory_unsigned_integer (addr, len, byte_order); 2672 } 2673 2674 int 2675 safe_frame_unwind_memory (struct frame_info *this_frame, 2676 CORE_ADDR addr, gdb_byte *buf, int len) 2677 { 2678 /* NOTE: target_read_memory returns zero on success! */ 2679 return !target_read_memory (addr, buf, len); 2680 } 2681 2682 /* Architecture methods. */ 2683 2684 struct gdbarch * 2685 get_frame_arch (struct frame_info *this_frame) 2686 { 2687 return frame_unwind_arch (this_frame->next); 2688 } 2689 2690 struct gdbarch * 2691 frame_unwind_arch (struct frame_info *next_frame) 2692 { 2693 if (!next_frame->prev_arch.p) 2694 { 2695 struct gdbarch *arch; 2696 2697 if (next_frame->unwind == NULL) 2698 frame_unwind_find_by_frame (next_frame, &next_frame->prologue_cache); 2699 2700 if (next_frame->unwind->prev_arch != NULL) 2701 arch = next_frame->unwind->prev_arch (next_frame, 2702 &next_frame->prologue_cache); 2703 else 2704 arch = get_frame_arch (next_frame); 2705 2706 next_frame->prev_arch.arch = arch; 2707 next_frame->prev_arch.p = 1; 2708 if (frame_debug) 2709 fprintf_unfiltered (gdb_stdlog, 2710 "{ frame_unwind_arch (next_frame=%d) -> %s }\n", 2711 next_frame->level, 2712 gdbarch_bfd_arch_info (arch)->printable_name); 2713 } 2714 2715 return next_frame->prev_arch.arch; 2716 } 2717 2718 struct gdbarch * 2719 frame_unwind_caller_arch (struct frame_info *next_frame) 2720 { 2721 next_frame = skip_artificial_frames (next_frame); 2722 2723 /* We must have a non-artificial frame. The caller is supposed to check 2724 the result of frame_unwind_caller_id (), which returns NULL_FRAME_ID 2725 in this case. */ 2726 gdb_assert (next_frame != NULL); 2727 2728 return frame_unwind_arch (next_frame); 2729 } 2730 2731 /* Gets the language of FRAME. */ 2732 2733 enum language 2734 get_frame_language (struct frame_info *frame) 2735 { 2736 CORE_ADDR pc = 0; 2737 int pc_p = 0; 2738 2739 gdb_assert (frame!= NULL); 2740 2741 /* We determine the current frame language by looking up its 2742 associated symtab. To retrieve this symtab, we use the frame 2743 PC. However we cannot use the frame PC as is, because it 2744 usually points to the instruction following the "call", which 2745 is sometimes the first instruction of another function. So 2746 we rely on get_frame_address_in_block(), it provides us with 2747 a PC that is guaranteed to be inside the frame's code 2748 block. */ 2749 2750 TRY 2751 { 2752 pc = get_frame_address_in_block (frame); 2753 pc_p = 1; 2754 } 2755 CATCH (ex, RETURN_MASK_ERROR) 2756 { 2757 if (ex.error != NOT_AVAILABLE_ERROR) 2758 throw_exception (ex); 2759 } 2760 END_CATCH 2761 2762 if (pc_p) 2763 { 2764 struct compunit_symtab *cust = find_pc_compunit_symtab (pc); 2765 2766 if (cust != NULL) 2767 return compunit_language (cust); 2768 } 2769 2770 return language_unknown; 2771 } 2772 2773 /* Stack pointer methods. */ 2774 2775 CORE_ADDR 2776 get_frame_sp (struct frame_info *this_frame) 2777 { 2778 struct gdbarch *gdbarch = get_frame_arch (this_frame); 2779 2780 /* NOTE drow/2008-06-28: gdbarch_unwind_sp could be converted to 2781 operate on THIS_FRAME now. */ 2782 return gdbarch_unwind_sp (gdbarch, this_frame->next); 2783 } 2784 2785 /* Return the reason why we can't unwind past FRAME. */ 2786 2787 enum unwind_stop_reason 2788 get_frame_unwind_stop_reason (struct frame_info *frame) 2789 { 2790 /* Fill-in STOP_REASON. */ 2791 get_prev_frame_always (frame); 2792 gdb_assert (frame->prev_p); 2793 2794 return frame->stop_reason; 2795 } 2796 2797 /* Return a string explaining REASON. */ 2798 2799 const char * 2800 unwind_stop_reason_to_string (enum unwind_stop_reason reason) 2801 { 2802 switch (reason) 2803 { 2804 #define SET(name, description) \ 2805 case name: return _(description); 2806 #include "unwind_stop_reasons.def" 2807 #undef SET 2808 2809 default: 2810 internal_error (__FILE__, __LINE__, 2811 "Invalid frame stop reason"); 2812 } 2813 } 2814 2815 const char * 2816 frame_stop_reason_string (struct frame_info *fi) 2817 { 2818 gdb_assert (fi->prev_p); 2819 gdb_assert (fi->prev == NULL); 2820 2821 /* Return the specific string if we have one. */ 2822 if (fi->stop_string != NULL) 2823 return fi->stop_string; 2824 2825 /* Return the generic string if we have nothing better. */ 2826 return unwind_stop_reason_to_string (fi->stop_reason); 2827 } 2828 2829 /* Return the enum symbol name of REASON as a string, to use in debug 2830 output. */ 2831 2832 static const char * 2833 frame_stop_reason_symbol_string (enum unwind_stop_reason reason) 2834 { 2835 switch (reason) 2836 { 2837 #define SET(name, description) \ 2838 case name: return #name; 2839 #include "unwind_stop_reasons.def" 2840 #undef SET 2841 2842 default: 2843 internal_error (__FILE__, __LINE__, 2844 "Invalid frame stop reason"); 2845 } 2846 } 2847 2848 /* Clean up after a failed (wrong unwinder) attempt to unwind past 2849 FRAME. */ 2850 2851 void 2852 frame_cleanup_after_sniffer (struct frame_info *frame) 2853 { 2854 /* The sniffer should not allocate a prologue cache if it did not 2855 match this frame. */ 2856 gdb_assert (frame->prologue_cache == NULL); 2857 2858 /* No sniffer should extend the frame chain; sniff based on what is 2859 already certain. */ 2860 gdb_assert (!frame->prev_p); 2861 2862 /* The sniffer should not check the frame's ID; that's circular. */ 2863 gdb_assert (!frame->this_id.p); 2864 2865 /* Clear cached fields dependent on the unwinder. 2866 2867 The previous PC is independent of the unwinder, but the previous 2868 function is not (see get_frame_address_in_block). */ 2869 frame->prev_func.p = 0; 2870 frame->prev_func.addr = 0; 2871 2872 /* Discard the unwinder last, so that we can easily find it if an assertion 2873 in this function triggers. */ 2874 frame->unwind = NULL; 2875 } 2876 2877 /* Set FRAME's unwinder temporarily, so that we can call a sniffer. 2878 If sniffing fails, the caller should be sure to call 2879 frame_cleanup_after_sniffer. */ 2880 2881 void 2882 frame_prepare_for_sniffer (struct frame_info *frame, 2883 const struct frame_unwind *unwind) 2884 { 2885 gdb_assert (frame->unwind == NULL); 2886 frame->unwind = unwind; 2887 } 2888 2889 static struct cmd_list_element *set_backtrace_cmdlist; 2890 static struct cmd_list_element *show_backtrace_cmdlist; 2891 2892 static void 2893 set_backtrace_cmd (const char *args, int from_tty) 2894 { 2895 help_list (set_backtrace_cmdlist, "set backtrace ", all_commands, 2896 gdb_stdout); 2897 } 2898 2899 static void 2900 show_backtrace_cmd (const char *args, int from_tty) 2901 { 2902 cmd_show_list (show_backtrace_cmdlist, from_tty, ""); 2903 } 2904 2905 void 2906 _initialize_frame (void) 2907 { 2908 obstack_init (&frame_cache_obstack); 2909 2910 frame_stash_create (); 2911 2912 gdb::observers::target_changed.attach (frame_observer_target_changed); 2913 2914 add_prefix_cmd ("backtrace", class_maintenance, set_backtrace_cmd, _("\ 2915 Set backtrace specific variables.\n\ 2916 Configure backtrace variables such as the backtrace limit"), 2917 &set_backtrace_cmdlist, "set backtrace ", 2918 0/*allow-unknown*/, &setlist); 2919 add_prefix_cmd ("backtrace", class_maintenance, show_backtrace_cmd, _("\ 2920 Show backtrace specific variables\n\ 2921 Show backtrace variables such as the backtrace limit"), 2922 &show_backtrace_cmdlist, "show backtrace ", 2923 0/*allow-unknown*/, &showlist); 2924 2925 add_setshow_boolean_cmd ("past-main", class_obscure, 2926 &backtrace_past_main, _("\ 2927 Set whether backtraces should continue past \"main\"."), _("\ 2928 Show whether backtraces should continue past \"main\"."), _("\ 2929 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\ 2930 the backtrace at \"main\". Set this variable if you need to see the rest\n\ 2931 of the stack trace."), 2932 NULL, 2933 show_backtrace_past_main, 2934 &set_backtrace_cmdlist, 2935 &show_backtrace_cmdlist); 2936 2937 add_setshow_boolean_cmd ("past-entry", class_obscure, 2938 &backtrace_past_entry, _("\ 2939 Set whether backtraces should continue past the entry point of a program."), 2940 _("\ 2941 Show whether backtraces should continue past the entry point of a program."), 2942 _("\ 2943 Normally there are no callers beyond the entry point of a program, so GDB\n\ 2944 will terminate the backtrace there. Set this variable if you need to see\n\ 2945 the rest of the stack trace."), 2946 NULL, 2947 show_backtrace_past_entry, 2948 &set_backtrace_cmdlist, 2949 &show_backtrace_cmdlist); 2950 2951 add_setshow_uinteger_cmd ("limit", class_obscure, 2952 &backtrace_limit, _("\ 2953 Set an upper bound on the number of backtrace levels."), _("\ 2954 Show the upper bound on the number of backtrace levels."), _("\ 2955 No more than the specified number of frames can be displayed or examined.\n\ 2956 Literal \"unlimited\" or zero means no limit."), 2957 NULL, 2958 show_backtrace_limit, 2959 &set_backtrace_cmdlist, 2960 &show_backtrace_cmdlist); 2961 2962 /* Debug this files internals. */ 2963 add_setshow_zuinteger_cmd ("frame", class_maintenance, &frame_debug, _("\ 2964 Set frame debugging."), _("\ 2965 Show frame debugging."), _("\ 2966 When non-zero, frame specific internal debugging is enabled."), 2967 NULL, 2968 show_frame_debug, 2969 &setdebuglist, &showdebuglist); 2970 } 2971