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