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