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