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