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