stack.c revision 98944
1/* Print and select stack frames for GDB, the GNU debugger. 2 3 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 4 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free Software 5 Foundation, Inc. 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 2 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program; if not, write to the Free Software 21 Foundation, Inc., 59 Temple Place - Suite 330, 22 Boston, MA 02111-1307, USA. */ 23 24#include <ctype.h> 25#include "defs.h" 26#include "gdb_string.h" 27#include "value.h" 28#include "symtab.h" 29#include "gdbtypes.h" 30#include "expression.h" 31#include "language.h" 32#include "frame.h" 33#include "gdbcmd.h" 34#include "gdbcore.h" 35#include "target.h" 36#include "breakpoint.h" 37#include "demangle.h" 38#include "inferior.h" 39#include "annotate.h" 40#include "ui-out.h" 41 42/* Prototypes for exported functions. */ 43 44void args_info (char *, int); 45 46void locals_info (char *, int); 47 48void (*selected_frame_level_changed_hook) (int); 49 50void _initialize_stack (void); 51 52/* Prototypes for local functions. */ 53 54static void return_command (char *, int); 55 56static void down_command (char *, int); 57 58static void down_silently_base (char *); 59 60static void down_silently_command (char *, int); 61 62static void up_command (char *, int); 63 64static void up_silently_base (char *); 65 66static void up_silently_command (char *, int); 67 68void frame_command (char *, int); 69 70static void current_frame_command (char *, int); 71 72static void select_frame_command (char *, int); 73 74static void print_frame_arg_vars (struct frame_info *, struct ui_file *); 75 76static void catch_info (char *, int); 77 78static void args_plus_locals_info (char *, int); 79 80static void print_frame_label_vars (struct frame_info *, int, 81 struct ui_file *); 82 83static void print_frame_local_vars (struct frame_info *, int, 84 struct ui_file *); 85 86static int print_block_frame_labels (struct block *, int *, 87 struct ui_file *); 88 89static int print_block_frame_locals (struct block *, 90 struct frame_info *, 91 int, 92 struct ui_file *); 93 94static void print_frame (struct frame_info *fi, 95 int level, 96 int source, 97 int args, 98 struct symtab_and_line sal); 99 100static void print_frame_info_base (struct frame_info *, int, int, int); 101 102static void print_stack_frame_base (struct frame_info *, int, int); 103 104static void backtrace_command (char *, int); 105 106struct frame_info *parse_frame_specification (char *); 107 108static void frame_info (char *, int); 109 110extern int addressprint; /* Print addresses, or stay symbolic only? */ 111extern int lines_to_list; /* # of lines "list" command shows by default */ 112 113/* The "selected" stack frame is used by default for local and arg access. 114 May be zero, for no selected frame. */ 115 116struct frame_info *selected_frame; 117 118/* Level of the selected frame: 119 0 for innermost, 1 for its caller, ... 120 or -1 for frame specified by address with no defined level. */ 121 122int selected_frame_level; 123 124/* Zero means do things normally; we are interacting directly with the 125 user. One means print the full filename and linenumber when a 126 frame is printed, and do so in a format emacs18/emacs19.22 can 127 parse. Two means print similar annotations, but in many more 128 cases and in a slightly different syntax. */ 129 130int annotation_level = 0; 131 132 133struct print_stack_frame_args 134 { 135 struct frame_info *fi; 136 int level; 137 int source; 138 int args; 139 }; 140 141static int print_stack_frame_base_stub (char *); 142 143/* Show and print the frame arguments. 144 Pass the args the way catch_errors wants them. */ 145static int show_and_print_stack_frame_stub (void *args); 146static int 147show_and_print_stack_frame_stub (void *args) 148{ 149 struct print_stack_frame_args *p = (struct print_stack_frame_args *) args; 150 151 print_frame_info (p->fi, p->level, p->source, p->args); 152 153 return 0; 154} 155 156/* Show or print the frame arguments. 157 Pass the args the way catch_errors wants them. */ 158static int print_stack_frame_stub (void *args); 159static int 160print_stack_frame_stub (void *args) 161{ 162 struct print_stack_frame_args *p = (struct print_stack_frame_args *) args; 163 164 print_frame_info_base (p->fi, p->level, p->source, p->args); 165 return 0; 166} 167 168/* Print a stack frame briefly. FRAME_INFI should be the frame info 169 and LEVEL should be its level in the stack (or -1 for level not 170 defined). */ 171 172/* Pass the args the way catch_errors wants them. */ 173static int 174print_stack_frame_base_stub (char *args) 175{ 176 struct print_stack_frame_args *p = (struct print_stack_frame_args *) args; 177 178 print_frame_info_base (p->fi, p->level, p->source, p->args); 179 return 0; 180} 181 182/* print the frame arguments to the terminal. 183 Pass the args the way catch_errors wants them. */ 184static int print_only_stack_frame_stub (void *); 185static int 186print_only_stack_frame_stub (void *args) 187{ 188 struct print_stack_frame_args *p = (struct print_stack_frame_args *) args; 189 190 print_frame_info_base (p->fi, p->level, p->source, p->args); 191 return 0; 192} 193 194/* Print a stack frame briefly. FRAME_INFI should be the frame info 195 and LEVEL should be its level in the stack (or -1 for level not defined). 196 This prints the level, the function executing, the arguments, 197 and the file name and line number. 198 If the pc is not at the beginning of the source line, 199 the actual pc is printed at the beginning. 200 201 If SOURCE is 1, print the source line as well. 202 If SOURCE is -1, print ONLY the source line. */ 203 204static void 205print_stack_frame_base (struct frame_info *fi, int level, int source) 206{ 207 struct print_stack_frame_args args; 208 209 args.fi = fi; 210 args.level = level; 211 args.source = source; 212 args.args = 1; 213 214 catch_errors (print_stack_frame_stub, &args, "", RETURN_MASK_ALL); 215} 216 217/* Show and print a stack frame briefly. FRAME_INFI should be the frame info 218 and LEVEL should be its level in the stack (or -1 for level not defined). 219 This prints the level, the function executing, the arguments, 220 and the file name and line number. 221 If the pc is not at the beginning of the source line, 222 the actual pc is printed at the beginning. 223 224 If SOURCE is 1, print the source line as well. 225 If SOURCE is -1, print ONLY the source line. */ 226 227void 228show_and_print_stack_frame (struct frame_info *fi, int level, int source) 229{ 230 struct print_stack_frame_args args; 231 232 args.fi = fi; 233 args.level = level; 234 args.source = source; 235 args.args = 1; 236 237 catch_errors (show_and_print_stack_frame_stub, &args, "", RETURN_MASK_ALL); 238} 239 240 241/* Show or print a stack frame briefly. FRAME_INFI should be the frame info 242 and LEVEL should be its level in the stack (or -1 for level not defined). 243 This prints the level, the function executing, the arguments, 244 and the file name and line number. 245 If the pc is not at the beginning of the source line, 246 the actual pc is printed at the beginning. 247 248 If SOURCE is 1, print the source line as well. 249 If SOURCE is -1, print ONLY the source line. */ 250 251void 252print_stack_frame (struct frame_info *fi, int level, int source) 253{ 254 struct print_stack_frame_args args; 255 256 args.fi = fi; 257 args.level = level; 258 args.source = source; 259 args.args = 1; 260 261 catch_errors (print_stack_frame_stub, (char *) &args, "", RETURN_MASK_ALL); 262} 263 264/* Print a stack frame briefly. FRAME_INFI should be the frame info 265 and LEVEL should be its level in the stack (or -1 for level not defined). 266 This prints the level, the function executing, the arguments, 267 and the file name and line number. 268 If the pc is not at the beginning of the source line, 269 the actual pc is printed at the beginning. 270 271 If SOURCE is 1, print the source line as well. 272 If SOURCE is -1, print ONLY the source line. */ 273 274void 275print_only_stack_frame (struct frame_info *fi, int level, int source) 276{ 277 struct print_stack_frame_args args; 278 279 args.fi = fi; 280 args.level = level; 281 args.source = source; 282 args.args = 1; 283 284 catch_errors (print_only_stack_frame_stub, &args, "", RETURN_MASK_ALL); 285} 286 287struct print_args_args 288{ 289 struct symbol *func; 290 struct frame_info *fi; 291 struct ui_file *stream; 292}; 293 294static int print_args_stub (PTR); 295 296/* Pass the args the way catch_errors wants them. */ 297 298static int 299print_args_stub (PTR args) 300{ 301 int numargs; 302 struct print_args_args *p = (struct print_args_args *) args; 303 304 numargs = FRAME_NUM_ARGS (p->fi); 305 print_frame_args (p->func, p->fi, numargs, p->stream); 306 return 0; 307} 308 309/* Print information about a frame for frame "fi" at level "level". 310 Used in "where" output, also used to emit breakpoint or step 311 messages. 312 LEVEL is the level of the frame, or -1 if it is the 313 innermost frame but we don't want to print the level. 314 The meaning of the SOURCE argument is: 315 SRC_LINE: Print only source line 316 LOCATION: Print only location 317 LOC_AND_SRC: Print location and source line. */ 318 319static void 320print_frame_info_base (struct frame_info *fi, int level, int source, int args) 321{ 322 struct symtab_and_line sal; 323 int source_print; 324 int location_print; 325 326#if 0 327 char buf[MAX_REGISTER_RAW_SIZE]; 328 CORE_ADDR sp; 329 330 /* On the 68k, this spends too much time in m68k_find_saved_regs. */ 331 332 /* Get the value of SP_REGNUM relative to the frame. */ 333 get_saved_register (buf, (int *) NULL, (CORE_ADDR *) NULL, 334 FRAME_INFO_ID (fi), SP_REGNUM, (enum lval_type *) NULL); 335 sp = extract_address (buf, REGISTER_RAW_SIZE (SP_REGNUM)); 336 337 /* This is not a perfect test, because if a function alloca's some 338 memory, puts some code there, and then jumps into it, then the test 339 will succeed even though there is no call dummy. Probably best is 340 to check for a bp_call_dummy breakpoint. */ 341 if (PC_IN_CALL_DUMMY (fi->pc, sp, fi->frame)) 342#else 343 if (frame_in_dummy (fi)) 344#endif 345 { 346 annotate_frame_begin (level == -1 ? 0 : level, fi->pc); 347 348 /* Do this regardless of SOURCE because we don't have any source 349 to list for this frame. */ 350 if (level >= 0) 351 printf_filtered ("#%-2d ", level); 352 annotate_function_call (); 353 printf_filtered ("<function called from gdb>\n"); 354 annotate_frame_end (); 355 return; 356 } 357 if (fi->signal_handler_caller) 358 { 359 annotate_frame_begin (level == -1 ? 0 : level, fi->pc); 360 361 /* Do this regardless of SOURCE because we don't have any source 362 to list for this frame. */ 363 if (level >= 0) 364 printf_filtered ("#%-2d ", level); 365 annotate_signal_handler_caller (); 366 printf_filtered ("<signal handler called>\n"); 367 annotate_frame_end (); 368 return; 369 } 370 371 /* If fi is not the innermost frame, that normally means that fi->pc 372 points to *after* the call instruction, and we want to get the line 373 containing the call, never the next line. But if the next frame is 374 a signal_handler_caller or a dummy frame, then the next frame was 375 not entered as the result of a call, and we want to get the line 376 containing fi->pc. */ 377 sal = 378 find_pc_line (fi->pc, 379 fi->next != NULL 380 && !fi->next->signal_handler_caller 381 && !frame_in_dummy (fi->next)); 382 383 location_print = (source == LOCATION 384 || source == LOC_AND_ADDRESS 385 || source == SRC_AND_LOC); 386 387 if (location_print || !sal.symtab) 388 print_frame (fi, level, source, args, sal); 389 390 source_print = (source == SRC_LINE || source == SRC_AND_LOC); 391 392 if (source_print && sal.symtab) 393 { 394 int done = 0; 395 int mid_statement = (source == SRC_LINE) && (fi->pc != sal.pc); 396 397 if (annotation_level) 398 done = identify_source_line (sal.symtab, sal.line, mid_statement, 399 fi->pc); 400 if (!done) 401 { 402 if (print_frame_info_listing_hook) 403 { 404 print_frame_info_listing_hook (sal.symtab, sal.line, sal.line + 1, 0); 405 current_source_symtab = sal.symtab; 406 } 407 else 408 { 409 /* We used to do this earlier, but that is clearly 410 wrong. This function is used by many different 411 parts of gdb, including normal_stop in infrun.c, 412 which uses this to print out the current PC 413 when we stepi/nexti into the middle of a source 414 line. Only the command line really wants this 415 behavior. Other UIs probably would like the 416 ability to decide for themselves if it is desired. */ 417 if (addressprint && mid_statement) 418 { 419 ui_out_field_core_addr (uiout, "addr", fi->pc); 420 ui_out_text (uiout, "\t"); 421 } 422 423 print_source_lines (sal.symtab, sal.line, sal.line + 1, 0); 424 } 425 } 426 current_source_line = max (sal.line - lines_to_list / 2, 1); 427 } 428 429 if (source != 0) 430 set_default_breakpoint (1, fi->pc, sal.symtab, sal.line); 431 432 annotate_frame_end (); 433 434 gdb_flush (gdb_stdout); 435} 436 437static void 438print_frame (struct frame_info *fi, 439 int level, 440 int source, 441 int args, 442 struct symtab_and_line sal) 443{ 444 struct symbol *func; 445 register char *funname = 0; 446 enum language funlang = language_unknown; 447 struct ui_stream *stb; 448 struct cleanup *old_chain; 449 struct cleanup *list_chain; 450 451 stb = ui_out_stream_new (uiout); 452 old_chain = make_cleanup_ui_out_stream_delete (stb); 453 454 func = find_pc_function (fi->pc); 455 if (func) 456 { 457 /* In certain pathological cases, the symtabs give the wrong 458 function (when we are in the first function in a file which 459 is compiled without debugging symbols, the previous function 460 is compiled with debugging symbols, and the "foo.o" symbol 461 that is supposed to tell us where the file with debugging symbols 462 ends has been truncated by ar because it is longer than 15 463 characters). This also occurs if the user uses asm() to create 464 a function but not stabs for it (in a file compiled -g). 465 466 So look in the minimal symbol tables as well, and if it comes 467 up with a larger address for the function use that instead. 468 I don't think this can ever cause any problems; there shouldn't 469 be any minimal symbols in the middle of a function; if this is 470 ever changed many parts of GDB will need to be changed (and we'll 471 create a find_pc_minimal_function or some such). */ 472 473 struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (fi->pc); 474 if (msymbol != NULL 475 && (SYMBOL_VALUE_ADDRESS (msymbol) 476 > BLOCK_START (SYMBOL_BLOCK_VALUE (func)))) 477 { 478#if 0 479 /* There is no particular reason to think the line number 480 information is wrong. Someone might have just put in 481 a label with asm() but left the line numbers alone. */ 482 /* In this case we have no way of knowing the source file 483 and line number, so don't print them. */ 484 sal.symtab = 0; 485#endif 486 /* We also don't know anything about the function besides 487 its address and name. */ 488 func = 0; 489 funname = SYMBOL_NAME (msymbol); 490 funlang = SYMBOL_LANGUAGE (msymbol); 491 } 492 else 493 { 494 /* I'd like to use SYMBOL_SOURCE_NAME() here, to display the 495 demangled name that we already have stored in the symbol 496 table, but we stored a version with DMGL_PARAMS turned 497 on, and here we don't want to display parameters. So call 498 the demangler again, with DMGL_ANSI only. (Yes, I know 499 that printf_symbol_filtered() will again try to demangle 500 the name on the fly, but the issue is that if 501 cplus_demangle() fails here, it'll fail there too. So we 502 want to catch the failure ("demangled==NULL" case below) 503 here, while we still have our hands on the function 504 symbol.) */ 505 char *demangled; 506 funname = SYMBOL_NAME (func); 507 funlang = SYMBOL_LANGUAGE (func); 508 if (funlang == language_cplus) 509 { 510 demangled = cplus_demangle (funname, DMGL_ANSI); 511 if (demangled == NULL) 512 /* If the demangler fails, try the demangled name from 513 the symbol table. This'll have parameters, but 514 that's preferable to diplaying a mangled name. */ 515 funname = SYMBOL_SOURCE_NAME (func); 516 } 517 } 518 } 519 else 520 { 521 struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (fi->pc); 522 if (msymbol != NULL) 523 { 524 funname = SYMBOL_NAME (msymbol); 525 funlang = SYMBOL_LANGUAGE (msymbol); 526 } 527 } 528 529 annotate_frame_begin (level == -1 ? 0 : level, fi->pc); 530 531 list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "frame"); 532 533 if (level >= 0) 534 { 535 ui_out_text (uiout, "#"); 536 ui_out_field_fmt (uiout, "level", "%-2d", level); 537 ui_out_spaces (uiout, 1); 538 } 539 if (addressprint) 540 if (fi->pc != sal.pc || !sal.symtab || source == LOC_AND_ADDRESS) 541 { 542 annotate_frame_address (); 543 ui_out_field_core_addr (uiout, "addr", fi->pc); 544 annotate_frame_address_end (); 545 ui_out_text (uiout, " in "); 546 } 547 annotate_frame_function_name (); 548 fprintf_symbol_filtered (stb->stream, funname ? funname : "??", funlang, 549 DMGL_ANSI); 550 ui_out_field_stream (uiout, "func", stb); 551 ui_out_wrap_hint (uiout, " "); 552 annotate_frame_args (); 553 554 ui_out_text (uiout, " ("); 555 if (args) 556 { 557 struct print_args_args args; 558 struct cleanup *args_list_chain; 559 args.fi = fi; 560 args.func = func; 561 args.stream = gdb_stdout; 562 args_list_chain = make_cleanup_ui_out_list_begin_end (uiout, "args"); 563 catch_errors (print_args_stub, &args, "", RETURN_MASK_ALL); 564 /* FIXME: args must be a list. If one argument is a string it will 565 have " that will not be properly escaped. */ 566 /* Invoke ui_out_tuple_end. */ 567 do_cleanups (args_list_chain); 568 QUIT; 569 } 570 ui_out_text (uiout, ")"); 571 if (sal.symtab && sal.symtab->filename) 572 { 573 annotate_frame_source_begin (); 574 ui_out_wrap_hint (uiout, " "); 575 ui_out_text (uiout, " at "); 576 annotate_frame_source_file (); 577 ui_out_field_string (uiout, "file", sal.symtab->filename); 578 annotate_frame_source_file_end (); 579 ui_out_text (uiout, ":"); 580 annotate_frame_source_line (); 581 ui_out_field_int (uiout, "line", sal.line); 582 annotate_frame_source_end (); 583 } 584 585#ifdef PC_SOLIB 586 if (!funname || (!sal.symtab || !sal.symtab->filename)) 587 { 588 char *lib = PC_SOLIB (fi->pc); 589 if (lib) 590 { 591 annotate_frame_where (); 592 ui_out_wrap_hint (uiout, " "); 593 ui_out_text (uiout, " from "); 594 ui_out_field_string (uiout, "from", lib); 595 } 596 } 597#endif /* PC_SOLIB */ 598 599 /* do_cleanups will call ui_out_tuple_end() for us. */ 600 do_cleanups (list_chain); 601 ui_out_text (uiout, "\n"); 602 do_cleanups (old_chain); 603} 604 605 606/* Show or print the frame info. If this is the tui, it will be shown in 607 the source display */ 608void 609print_frame_info (struct frame_info *fi, register int level, int source, 610 int args) 611{ 612 print_frame_info_base (fi, level, source, args); 613} 614 615/* Show the frame info. If this is the tui, it will be shown in 616 the source display otherwise, nothing is done */ 617void 618show_stack_frame (struct frame_info *fi) 619{ 620} 621 622 623/* Read a frame specification in whatever the appropriate format is. 624 Call error() if the specification is in any way invalid (i.e. 625 this function never returns NULL). */ 626 627struct frame_info * 628parse_frame_specification (char *frame_exp) 629{ 630 int numargs = 0; 631#define MAXARGS 4 632 CORE_ADDR args[MAXARGS]; 633 int level; 634 635 if (frame_exp) 636 { 637 char *addr_string, *p; 638 struct cleanup *tmp_cleanup; 639 640 while (*frame_exp == ' ') 641 frame_exp++; 642 643 while (*frame_exp) 644 { 645 if (numargs > MAXARGS) 646 error ("Too many args in frame specification"); 647 /* Parse an argument. */ 648 for (p = frame_exp; *p && *p != ' '; p++) 649 ; 650 addr_string = savestring (frame_exp, p - frame_exp); 651 652 { 653 struct value *vp; 654 655 tmp_cleanup = make_cleanup (xfree, addr_string); 656 657 /* NOTE: we call parse_and_eval and then both 658 value_as_long and value_as_address rather than calling 659 parse_and_eval_long and parse_and_eval_address because 660 of the issue of potential side effects from evaluating 661 the expression. */ 662 vp = parse_and_eval (addr_string); 663 if (numargs == 0) 664 level = value_as_long (vp); 665 666 args[numargs++] = value_as_address (vp); 667 do_cleanups (tmp_cleanup); 668 } 669 670 /* Skip spaces, move to possible next arg. */ 671 while (*p == ' ') 672 p++; 673 frame_exp = p; 674 } 675 } 676 677 switch (numargs) 678 { 679 case 0: 680 if (selected_frame == NULL) 681 error ("No selected frame."); 682 return selected_frame; 683 /* NOTREACHED */ 684 case 1: 685 { 686 struct frame_info *fid = 687 find_relative_frame (get_current_frame (), &level); 688 struct frame_info *tfid; 689 690 if (level == 0) 691 /* find_relative_frame was successful */ 692 return fid; 693 694 /* If SETUP_ARBITRARY_FRAME is defined, then frame specifications 695 take at least 2 addresses. It is important to detect this case 696 here so that "frame 100" does not give a confusing error message 697 like "frame specification requires two addresses". This of course 698 does not solve the "frame 100" problem for machines on which 699 a frame specification can be made with one address. To solve 700 that, we need a new syntax for a specifying a frame by address. 701 I think the cleanest syntax is $frame(0x45) ($frame(0x23,0x45) for 702 two args, etc.), but people might think that is too much typing, 703 so I guess *0x23,0x45 would be a possible alternative (commas 704 really should be used instead of spaces to delimit; using spaces 705 normally works in an expression). */ 706#ifdef SETUP_ARBITRARY_FRAME 707 error ("No frame %d", args[0]); 708#endif 709 710 /* If (s)he specifies the frame with an address, he deserves what 711 (s)he gets. Still, give the highest one that matches. */ 712 713 for (fid = get_current_frame (); 714 fid && fid->frame != args[0]; 715 fid = get_prev_frame (fid)) 716 ; 717 718 if (fid) 719 while ((tfid = get_prev_frame (fid)) && 720 (tfid->frame == args[0])) 721 fid = tfid; 722 723 /* We couldn't identify the frame as an existing frame, but 724 perhaps we can create one with a single argument. */ 725 } 726 727 default: 728#ifdef SETUP_ARBITRARY_FRAME 729 return SETUP_ARBITRARY_FRAME (numargs, args); 730#else 731 /* Usual case. Do it here rather than have everyone supply 732 a SETUP_ARBITRARY_FRAME that does this. */ 733 if (numargs == 1) 734 return create_new_frame (args[0], 0); 735 error ("Too many args in frame specification"); 736#endif 737 /* NOTREACHED */ 738 } 739 /* NOTREACHED */ 740} 741 742/* FRAME_ARGS_ADDRESS_CORRECT is just like FRAME_ARGS_ADDRESS except 743 that if it is unsure about the answer, it returns 0 744 instead of guessing (this happens on the VAX and i960, for example). 745 746 On most machines, we never have to guess about the args address, 747 so FRAME_ARGS_ADDRESS{,_CORRECT} are the same. */ 748#if !defined (FRAME_ARGS_ADDRESS_CORRECT) 749#define FRAME_ARGS_ADDRESS_CORRECT FRAME_ARGS_ADDRESS 750#endif 751 752/* Print verbosely the selected frame or the frame at address ADDR. 753 This means absolutely all information in the frame is printed. */ 754 755static void 756frame_info (char *addr_exp, int from_tty) 757{ 758 struct frame_info *fi; 759 struct symtab_and_line sal; 760 struct symbol *func; 761 struct symtab *s; 762 struct frame_info *calling_frame_info; 763 int i, count, numregs; 764 char *funname = 0; 765 enum language funlang = language_unknown; 766 767 if (!target_has_stack) 768 error ("No stack."); 769 770 fi = parse_frame_specification (addr_exp); 771 if (fi == NULL) 772 error ("Invalid frame specified."); 773 774 sal = find_pc_line (fi->pc, 775 fi->next != NULL 776 && !fi->next->signal_handler_caller 777 && !frame_in_dummy (fi->next)); 778 func = get_frame_function (fi); 779 s = find_pc_symtab (fi->pc); 780 if (func) 781 { 782 /* I'd like to use SYMBOL_SOURCE_NAME() here, to display 783 * the demangled name that we already have stored in 784 * the symbol table, but we stored a version with 785 * DMGL_PARAMS turned on, and here we don't want 786 * to display parameters. So call the demangler again, 787 * with DMGL_ANSI only. RT 788 * (Yes, I know that printf_symbol_filtered() will 789 * again try to demangle the name on the fly, but 790 * the issue is that if cplus_demangle() fails here, 791 * it'll fail there too. So we want to catch the failure 792 * ("demangled==NULL" case below) here, while we still 793 * have our hands on the function symbol.) 794 */ 795 char *demangled; 796 funname = SYMBOL_NAME (func); 797 funlang = SYMBOL_LANGUAGE (func); 798 if (funlang == language_cplus) 799 { 800 demangled = cplus_demangle (funname, DMGL_ANSI); 801 /* If the demangler fails, try the demangled name 802 * from the symbol table. This'll have parameters, 803 * but that's preferable to diplaying a mangled name. 804 */ 805 if (demangled == NULL) 806 funname = SYMBOL_SOURCE_NAME (func); 807 } 808 } 809 else 810 { 811 register struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (fi->pc); 812 if (msymbol != NULL) 813 { 814 funname = SYMBOL_NAME (msymbol); 815 funlang = SYMBOL_LANGUAGE (msymbol); 816 } 817 } 818 calling_frame_info = get_prev_frame (fi); 819 820 if (!addr_exp && selected_frame_level >= 0) 821 { 822 printf_filtered ("Stack level %d, frame at ", selected_frame_level); 823 print_address_numeric (fi->frame, 1, gdb_stdout); 824 printf_filtered (":\n"); 825 } 826 else 827 { 828 printf_filtered ("Stack frame at "); 829 print_address_numeric (fi->frame, 1, gdb_stdout); 830 printf_filtered (":\n"); 831 } 832 printf_filtered (" %s = ", REGISTER_NAME (PC_REGNUM)); 833 print_address_numeric (fi->pc, 1, gdb_stdout); 834 835 wrap_here (" "); 836 if (funname) 837 { 838 printf_filtered (" in "); 839 fprintf_symbol_filtered (gdb_stdout, funname, funlang, 840 DMGL_ANSI | DMGL_PARAMS); 841 } 842 wrap_here (" "); 843 if (sal.symtab) 844 printf_filtered (" (%s:%d)", sal.symtab->filename, sal.line); 845 puts_filtered ("; "); 846 wrap_here (" "); 847 printf_filtered ("saved %s ", REGISTER_NAME (PC_REGNUM)); 848 print_address_numeric (FRAME_SAVED_PC (fi), 1, gdb_stdout); 849 printf_filtered ("\n"); 850 851 { 852 int frameless; 853 frameless = FRAMELESS_FUNCTION_INVOCATION (fi); 854 if (frameless) 855 printf_filtered (" (FRAMELESS),"); 856 } 857 858 if (calling_frame_info) 859 { 860 printf_filtered (" called by frame at "); 861 print_address_numeric (calling_frame_info->frame, 1, gdb_stdout); 862 } 863 if (fi->next && calling_frame_info) 864 puts_filtered (","); 865 wrap_here (" "); 866 if (fi->next) 867 { 868 printf_filtered (" caller of frame at "); 869 print_address_numeric (fi->next->frame, 1, gdb_stdout); 870 } 871 if (fi->next || calling_frame_info) 872 puts_filtered ("\n"); 873 if (s) 874 printf_filtered (" source language %s.\n", language_str (s->language)); 875 876#ifdef PRINT_EXTRA_FRAME_INFO 877 PRINT_EXTRA_FRAME_INFO (fi); 878#endif 879 880 { 881 /* Address of the argument list for this frame, or 0. */ 882 CORE_ADDR arg_list = FRAME_ARGS_ADDRESS_CORRECT (fi); 883 /* Number of args for this frame, or -1 if unknown. */ 884 int numargs; 885 886 if (arg_list == 0) 887 printf_filtered (" Arglist at unknown address.\n"); 888 else 889 { 890 printf_filtered (" Arglist at "); 891 print_address_numeric (arg_list, 1, gdb_stdout); 892 printf_filtered (","); 893 894 numargs = FRAME_NUM_ARGS (fi); 895 if (numargs < 0) 896 puts_filtered (" args: "); 897 else if (numargs == 0) 898 puts_filtered (" no args."); 899 else if (numargs == 1) 900 puts_filtered (" 1 arg: "); 901 else 902 printf_filtered (" %d args: ", numargs); 903 print_frame_args (func, fi, numargs, gdb_stdout); 904 puts_filtered ("\n"); 905 } 906 } 907 { 908 /* Address of the local variables for this frame, or 0. */ 909 CORE_ADDR arg_list = FRAME_LOCALS_ADDRESS (fi); 910 911 if (arg_list == 0) 912 printf_filtered (" Locals at unknown address,"); 913 else 914 { 915 printf_filtered (" Locals at "); 916 print_address_numeric (arg_list, 1, gdb_stdout); 917 printf_filtered (","); 918 } 919 } 920 921 FRAME_INIT_SAVED_REGS (fi); 922 if (fi->saved_regs != NULL) 923 { 924 /* The sp is special; what's returned isn't the save address, but 925 actually the value of the previous frame's sp. */ 926 printf_filtered (" Previous frame's sp is "); 927 print_address_numeric (fi->saved_regs[SP_REGNUM], 1, gdb_stdout); 928 printf_filtered ("\n"); 929 count = 0; 930 numregs = NUM_REGS + NUM_PSEUDO_REGS; 931 for (i = 0; i < numregs; i++) 932 if (fi->saved_regs[i] && i != SP_REGNUM) 933 { 934 if (count == 0) 935 puts_filtered (" Saved registers:\n "); 936 else 937 puts_filtered (","); 938 wrap_here (" "); 939 printf_filtered (" %s at ", REGISTER_NAME (i)); 940 print_address_numeric (fi->saved_regs[i], 1, gdb_stdout); 941 count++; 942 } 943 if (count) 944 puts_filtered ("\n"); 945 } 946 else 947 { 948 /* We could get some information about saved registers by 949 calling get_saved_register on each register. Which info goes 950 with which frame is necessarily lost, however, and I suspect 951 that the users don't care whether they get the info. */ 952 puts_filtered ("\n"); 953 } 954} 955 956#if 0 957/* Set a limit on the number of frames printed by default in a 958 backtrace. */ 959 960static int backtrace_limit; 961 962static void 963set_backtrace_limit_command (char *count_exp, int from_tty) 964{ 965 int count = parse_and_eval_long (count_exp); 966 967 if (count < 0) 968 error ("Negative argument not meaningful as backtrace limit."); 969 970 backtrace_limit = count; 971} 972 973static void 974backtrace_limit_info (char *arg, int from_tty) 975{ 976 if (arg) 977 error ("\"Info backtrace-limit\" takes no arguments."); 978 979 printf_unfiltered ("Backtrace limit: %d.\n", backtrace_limit); 980} 981#endif 982 983/* Print briefly all stack frames or just the innermost COUNT frames. */ 984 985static void backtrace_command_1 (char *count_exp, int show_locals, 986 int from_tty); 987static void 988backtrace_command_1 (char *count_exp, int show_locals, int from_tty) 989{ 990 struct frame_info *fi; 991 register int count; 992 register int i; 993 register struct frame_info *trailing; 994 register int trailing_level; 995 996 if (!target_has_stack) 997 error ("No stack."); 998 999 /* The following code must do two things. First, it must 1000 set the variable TRAILING to the frame from which we should start 1001 printing. Second, it must set the variable count to the number 1002 of frames which we should print, or -1 if all of them. */ 1003 trailing = get_current_frame (); 1004 1005 /* The target can be in a state where there is no valid frames 1006 (e.g., just connected). */ 1007 if (trailing == NULL) 1008 error ("No stack."); 1009 1010 trailing_level = 0; 1011 if (count_exp) 1012 { 1013 count = parse_and_eval_long (count_exp); 1014 if (count < 0) 1015 { 1016 struct frame_info *current; 1017 1018 count = -count; 1019 1020 current = trailing; 1021 while (current && count--) 1022 { 1023 QUIT; 1024 current = get_prev_frame (current); 1025 } 1026 1027 /* Will stop when CURRENT reaches the top of the stack. TRAILING 1028 will be COUNT below it. */ 1029 while (current) 1030 { 1031 QUIT; 1032 trailing = get_prev_frame (trailing); 1033 current = get_prev_frame (current); 1034 trailing_level++; 1035 } 1036 1037 count = -1; 1038 } 1039 } 1040 else 1041 count = -1; 1042 1043 if (info_verbose) 1044 { 1045 struct partial_symtab *ps; 1046 1047 /* Read in symbols for all of the frames. Need to do this in 1048 a separate pass so that "Reading in symbols for xxx" messages 1049 don't screw up the appearance of the backtrace. Also 1050 if people have strong opinions against reading symbols for 1051 backtrace this may have to be an option. */ 1052 i = count; 1053 for (fi = trailing; 1054 fi != NULL && i--; 1055 fi = get_prev_frame (fi)) 1056 { 1057 QUIT; 1058 ps = find_pc_psymtab (fi->pc); 1059 if (ps) 1060 PSYMTAB_TO_SYMTAB (ps); /* Force syms to come in */ 1061 } 1062 } 1063 1064 for (i = 0, fi = trailing; 1065 fi && count--; 1066 i++, fi = get_prev_frame (fi)) 1067 { 1068 QUIT; 1069 1070 /* Don't use print_stack_frame; if an error() occurs it probably 1071 means further attempts to backtrace would fail (on the other 1072 hand, perhaps the code does or could be fixed to make sure 1073 the frame->prev field gets set to NULL in that case). */ 1074 print_frame_info_base (fi, trailing_level + i, 0, 1); 1075 if (show_locals) 1076 print_frame_local_vars (fi, 1, gdb_stdout); 1077 } 1078 1079 /* If we've stopped before the end, mention that. */ 1080 if (fi && from_tty) 1081 printf_filtered ("(More stack frames follow...)\n"); 1082} 1083 1084static void 1085backtrace_command (char *arg, int from_tty) 1086{ 1087 struct cleanup *old_chain = (struct cleanup *) NULL; 1088 char **argv = (char **) NULL; 1089 int argIndicatingFullTrace = (-1), totArgLen = 0, argc = 0; 1090 char *argPtr = arg; 1091 1092 if (arg != (char *) NULL) 1093 { 1094 int i; 1095 1096 argv = buildargv (arg); 1097 old_chain = make_cleanup_freeargv (argv); 1098 argc = 0; 1099 for (i = 0; (argv[i] != (char *) NULL); i++) 1100 { 1101 unsigned int j; 1102 1103 for (j = 0; (j < strlen (argv[i])); j++) 1104 argv[i][j] = tolower (argv[i][j]); 1105 1106 if (argIndicatingFullTrace < 0 && subset_compare (argv[i], "full")) 1107 argIndicatingFullTrace = argc; 1108 else 1109 { 1110 argc++; 1111 totArgLen += strlen (argv[i]); 1112 } 1113 } 1114 totArgLen += argc; 1115 if (argIndicatingFullTrace >= 0) 1116 { 1117 if (totArgLen > 0) 1118 { 1119 argPtr = (char *) xmalloc (totArgLen + 1); 1120 if (!argPtr) 1121 nomem (0); 1122 else 1123 { 1124 memset (argPtr, 0, totArgLen + 1); 1125 for (i = 0; (i < (argc + 1)); i++) 1126 { 1127 if (i != argIndicatingFullTrace) 1128 { 1129 strcat (argPtr, argv[i]); 1130 strcat (argPtr, " "); 1131 } 1132 } 1133 } 1134 } 1135 else 1136 argPtr = (char *) NULL; 1137 } 1138 } 1139 1140 backtrace_command_1 (argPtr, (argIndicatingFullTrace >= 0), from_tty); 1141 1142 if (argIndicatingFullTrace >= 0 && totArgLen > 0) 1143 xfree (argPtr); 1144 1145 if (old_chain) 1146 do_cleanups (old_chain); 1147} 1148 1149static void backtrace_full_command (char *arg, int from_tty); 1150static void 1151backtrace_full_command (char *arg, int from_tty) 1152{ 1153 backtrace_command_1 (arg, 1, from_tty); 1154} 1155 1156 1157/* Print the local variables of a block B active in FRAME. 1158 Return 1 if any variables were printed; 0 otherwise. */ 1159 1160static int 1161print_block_frame_locals (struct block *b, register struct frame_info *fi, 1162 int num_tabs, register struct ui_file *stream) 1163{ 1164 register int i, j; 1165 register struct symbol *sym; 1166 register int values_printed = 0; 1167 1168 ALL_BLOCK_SYMBOLS (b, i, sym) 1169 { 1170 switch (SYMBOL_CLASS (sym)) 1171 { 1172 case LOC_LOCAL: 1173 case LOC_REGISTER: 1174 case LOC_STATIC: 1175 case LOC_BASEREG: 1176 values_printed = 1; 1177 for (j = 0; j < num_tabs; j++) 1178 fputs_filtered ("\t", stream); 1179 fputs_filtered (SYMBOL_SOURCE_NAME (sym), stream); 1180 fputs_filtered (" = ", stream); 1181 print_variable_value (sym, fi, stream); 1182 fprintf_filtered (stream, "\n"); 1183 break; 1184 1185 default: 1186 /* Ignore symbols which are not locals. */ 1187 break; 1188 } 1189 } 1190 return values_printed; 1191} 1192 1193/* Same, but print labels. */ 1194 1195static int 1196print_block_frame_labels (struct block *b, int *have_default, 1197 register struct ui_file *stream) 1198{ 1199 register int i; 1200 register struct symbol *sym; 1201 register int values_printed = 0; 1202 1203 ALL_BLOCK_SYMBOLS (b, i, sym) 1204 { 1205 if (STREQ (SYMBOL_NAME (sym), "default")) 1206 { 1207 if (*have_default) 1208 continue; 1209 *have_default = 1; 1210 } 1211 if (SYMBOL_CLASS (sym) == LOC_LABEL) 1212 { 1213 struct symtab_and_line sal; 1214 sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0); 1215 values_printed = 1; 1216 fputs_filtered (SYMBOL_SOURCE_NAME (sym), stream); 1217 if (addressprint) 1218 { 1219 fprintf_filtered (stream, " "); 1220 print_address_numeric (SYMBOL_VALUE_ADDRESS (sym), 1, stream); 1221 } 1222 fprintf_filtered (stream, " in file %s, line %d\n", 1223 sal.symtab->filename, sal.line); 1224 } 1225 } 1226 return values_printed; 1227} 1228 1229/* Print on STREAM all the local variables in frame FRAME, 1230 including all the blocks active in that frame 1231 at its current pc. 1232 1233 Returns 1 if the job was done, 1234 or 0 if nothing was printed because we have no info 1235 on the function running in FRAME. */ 1236 1237static void 1238print_frame_local_vars (register struct frame_info *fi, register int num_tabs, 1239 register struct ui_file *stream) 1240{ 1241 register struct block *block = get_frame_block (fi); 1242 register int values_printed = 0; 1243 1244 if (block == 0) 1245 { 1246 fprintf_filtered (stream, "No symbol table info available.\n"); 1247 return; 1248 } 1249 1250 while (block != 0) 1251 { 1252 if (print_block_frame_locals (block, fi, num_tabs, stream)) 1253 values_printed = 1; 1254 /* After handling the function's top-level block, stop. 1255 Don't continue to its superblock, the block of 1256 per-file symbols. */ 1257 if (BLOCK_FUNCTION (block)) 1258 break; 1259 block = BLOCK_SUPERBLOCK (block); 1260 } 1261 1262 if (!values_printed) 1263 { 1264 fprintf_filtered (stream, "No locals.\n"); 1265 } 1266} 1267 1268/* Same, but print labels. */ 1269 1270static void 1271print_frame_label_vars (register struct frame_info *fi, int this_level_only, 1272 register struct ui_file *stream) 1273{ 1274 register struct blockvector *bl; 1275 register struct block *block = get_frame_block (fi); 1276 register int values_printed = 0; 1277 int index, have_default = 0; 1278 char *blocks_printed; 1279 CORE_ADDR pc = fi->pc; 1280 1281 if (block == 0) 1282 { 1283 fprintf_filtered (stream, "No symbol table info available.\n"); 1284 return; 1285 } 1286 1287 bl = blockvector_for_pc (BLOCK_END (block) - 4, &index); 1288 blocks_printed = (char *) alloca (BLOCKVECTOR_NBLOCKS (bl) * sizeof (char)); 1289 memset (blocks_printed, 0, BLOCKVECTOR_NBLOCKS (bl) * sizeof (char)); 1290 1291 while (block != 0) 1292 { 1293 CORE_ADDR end = BLOCK_END (block) - 4; 1294 int last_index; 1295 1296 if (bl != blockvector_for_pc (end, &index)) 1297 error ("blockvector blotch"); 1298 if (BLOCKVECTOR_BLOCK (bl, index) != block) 1299 error ("blockvector botch"); 1300 last_index = BLOCKVECTOR_NBLOCKS (bl); 1301 index += 1; 1302 1303 /* Don't print out blocks that have gone by. */ 1304 while (index < last_index 1305 && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < pc) 1306 index++; 1307 1308 while (index < last_index 1309 && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < end) 1310 { 1311 if (blocks_printed[index] == 0) 1312 { 1313 if (print_block_frame_labels (BLOCKVECTOR_BLOCK (bl, index), &have_default, stream)) 1314 values_printed = 1; 1315 blocks_printed[index] = 1; 1316 } 1317 index++; 1318 } 1319 if (have_default) 1320 return; 1321 if (values_printed && this_level_only) 1322 return; 1323 1324 /* After handling the function's top-level block, stop. 1325 Don't continue to its superblock, the block of 1326 per-file symbols. */ 1327 if (BLOCK_FUNCTION (block)) 1328 break; 1329 block = BLOCK_SUPERBLOCK (block); 1330 } 1331 1332 if (!values_printed && !this_level_only) 1333 { 1334 fprintf_filtered (stream, "No catches.\n"); 1335 } 1336} 1337 1338/* ARGSUSED */ 1339void 1340locals_info (char *args, int from_tty) 1341{ 1342 if (!selected_frame) 1343 error ("No frame selected."); 1344 print_frame_local_vars (selected_frame, 0, gdb_stdout); 1345} 1346 1347static void 1348catch_info (char *ignore, int from_tty) 1349{ 1350 struct symtab_and_line *sal; 1351 1352 /* Check for target support for exception handling */ 1353 sal = target_enable_exception_callback (EX_EVENT_CATCH, 1); 1354 if (sal) 1355 { 1356 /* Currently not handling this */ 1357 /* Ideally, here we should interact with the C++ runtime 1358 system to find the list of active handlers, etc. */ 1359 fprintf_filtered (gdb_stdout, "Info catch not supported with this target/compiler combination.\n"); 1360#if 0 1361 if (!selected_frame) 1362 error ("No frame selected."); 1363#endif 1364 } 1365 else 1366 { 1367 /* Assume g++ compiled code -- old v 4.16 behaviour */ 1368 if (!selected_frame) 1369 error ("No frame selected."); 1370 1371 print_frame_label_vars (selected_frame, 0, gdb_stdout); 1372 } 1373} 1374 1375static void 1376print_frame_arg_vars (register struct frame_info *fi, 1377 register struct ui_file *stream) 1378{ 1379 struct symbol *func = get_frame_function (fi); 1380 register struct block *b; 1381 register int i; 1382 register struct symbol *sym, *sym2; 1383 register int values_printed = 0; 1384 1385 if (func == 0) 1386 { 1387 fprintf_filtered (stream, "No symbol table info available.\n"); 1388 return; 1389 } 1390 1391 b = SYMBOL_BLOCK_VALUE (func); 1392 ALL_BLOCK_SYMBOLS (b, i, sym) 1393 { 1394 switch (SYMBOL_CLASS (sym)) 1395 { 1396 case LOC_ARG: 1397 case LOC_LOCAL_ARG: 1398 case LOC_REF_ARG: 1399 case LOC_REGPARM: 1400 case LOC_REGPARM_ADDR: 1401 case LOC_BASEREG_ARG: 1402 values_printed = 1; 1403 fputs_filtered (SYMBOL_SOURCE_NAME (sym), stream); 1404 fputs_filtered (" = ", stream); 1405 1406 /* We have to look up the symbol because arguments can have 1407 two entries (one a parameter, one a local) and the one we 1408 want is the local, which lookup_symbol will find for us. 1409 This includes gcc1 (not gcc2) on the sparc when passing a 1410 small structure and gcc2 when the argument type is float 1411 and it is passed as a double and converted to float by 1412 the prologue (in the latter case the type of the LOC_ARG 1413 symbol is double and the type of the LOC_LOCAL symbol is 1414 float). There are also LOC_ARG/LOC_REGISTER pairs which 1415 are not combined in symbol-reading. */ 1416 1417 sym2 = lookup_symbol (SYMBOL_NAME (sym), 1418 b, VAR_NAMESPACE, (int *) NULL, (struct symtab **) NULL); 1419 print_variable_value (sym2, fi, stream); 1420 fprintf_filtered (stream, "\n"); 1421 break; 1422 1423 default: 1424 /* Don't worry about things which aren't arguments. */ 1425 break; 1426 } 1427 } 1428 if (!values_printed) 1429 { 1430 fprintf_filtered (stream, "No arguments.\n"); 1431 } 1432} 1433 1434void 1435args_info (char *ignore, int from_tty) 1436{ 1437 if (!selected_frame) 1438 error ("No frame selected."); 1439 print_frame_arg_vars (selected_frame, gdb_stdout); 1440} 1441 1442 1443static void 1444args_plus_locals_info (char *ignore, int from_tty) 1445{ 1446 args_info (ignore, from_tty); 1447 locals_info (ignore, from_tty); 1448} 1449 1450 1451/* Select frame FI, and note that its stack level is LEVEL. 1452 LEVEL may be -1 if an actual level number is not known. */ 1453 1454void 1455select_frame (struct frame_info *fi, int level) 1456{ 1457 register struct symtab *s; 1458 1459 selected_frame = fi; 1460 selected_frame_level = level; 1461 if (selected_frame_level_changed_hook) 1462 selected_frame_level_changed_hook (level); 1463 1464 /* Ensure that symbols for this frame are read in. Also, determine the 1465 source language of this frame, and switch to it if desired. */ 1466 if (fi) 1467 { 1468 s = find_pc_symtab (fi->pc); 1469 if (s 1470 && s->language != current_language->la_language 1471 && s->language != language_unknown 1472 && language_mode == language_mode_auto) 1473 { 1474 set_language (s->language); 1475 } 1476 } 1477} 1478 1479 1480/* Select frame FI, noting that its stack level is LEVEL. Also print 1481 the stack frame and show the source if this is the tui version. */ 1482void 1483select_and_print_frame (struct frame_info *fi, int level) 1484{ 1485 select_frame (fi, level); 1486 if (fi) 1487 { 1488 print_stack_frame (fi, level, 1); 1489 } 1490} 1491 1492 1493/* Store the selected frame and its level into *FRAMEP and *LEVELP. 1494 If there is no selected frame, *FRAMEP is set to NULL. */ 1495 1496void 1497record_selected_frame (CORE_ADDR *frameaddrp, int *levelp) 1498{ 1499 *frameaddrp = selected_frame ? selected_frame->frame : 0; 1500 *levelp = selected_frame_level; 1501} 1502 1503/* Return the symbol-block in which the selected frame is executing. 1504 Can return zero under various legitimate circumstances. */ 1505 1506struct block * 1507get_selected_block (void) 1508{ 1509 if (!target_has_stack) 1510 return 0; 1511 1512 if (!selected_frame) 1513 return get_current_block (); 1514 return get_frame_block (selected_frame); 1515} 1516 1517/* Find a frame a certain number of levels away from FRAME. 1518 LEVEL_OFFSET_PTR points to an int containing the number of levels. 1519 Positive means go to earlier frames (up); negative, the reverse. 1520 The int that contains the number of levels is counted toward 1521 zero as the frames for those levels are found. 1522 If the top or bottom frame is reached, that frame is returned, 1523 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates 1524 how much farther the original request asked to go. */ 1525 1526struct frame_info * 1527find_relative_frame (register struct frame_info *frame, 1528 register int *level_offset_ptr) 1529{ 1530 register struct frame_info *prev; 1531 register struct frame_info *frame1; 1532 1533 /* Going up is simple: just do get_prev_frame enough times 1534 or until initial frame is reached. */ 1535 while (*level_offset_ptr > 0) 1536 { 1537 prev = get_prev_frame (frame); 1538 if (prev == 0) 1539 break; 1540 (*level_offset_ptr)--; 1541 frame = prev; 1542 } 1543 /* Going down is just as simple. */ 1544 if (*level_offset_ptr < 0) 1545 { 1546 while (*level_offset_ptr < 0) 1547 { 1548 frame1 = get_next_frame (frame); 1549 if (!frame1) 1550 break; 1551 frame = frame1; 1552 (*level_offset_ptr)++; 1553 } 1554 } 1555 return frame; 1556} 1557 1558/* The "select_frame" command. With no arg, NOP. 1559 With arg LEVEL_EXP, select the frame at level LEVEL if it is a 1560 valid level. Otherwise, treat level_exp as an address expression 1561 and select it. See parse_frame_specification for more info on proper 1562 frame expressions. */ 1563 1564/* ARGSUSED */ 1565void 1566select_frame_command_wrapper (char *level_exp, int from_tty) 1567{ 1568 select_frame_command (level_exp, from_tty); 1569} 1570 1571static void 1572select_frame_command (char *level_exp, int from_tty) 1573{ 1574 register struct frame_info *frame, *frame1; 1575 unsigned int level = 0; 1576 1577 if (!target_has_stack) 1578 error ("No stack."); 1579 1580 frame = parse_frame_specification (level_exp); 1581 1582 /* Try to figure out what level this frame is. But if there is 1583 no current stack, don't error out -- let the user set one. */ 1584 frame1 = 0; 1585 if (get_current_frame ()) 1586 { 1587 for (frame1 = get_prev_frame (0); 1588 frame1 && frame1 != frame; 1589 frame1 = get_prev_frame (frame1)) 1590 level++; 1591 } 1592 1593 if (!frame1) 1594 level = 0; 1595 1596 select_frame (frame, level); 1597} 1598 1599/* The "frame" command. With no arg, print selected frame briefly. 1600 With arg, behaves like select_frame and then prints the selected 1601 frame. */ 1602 1603void 1604frame_command (char *level_exp, int from_tty) 1605{ 1606 select_frame_command (level_exp, from_tty); 1607 show_and_print_stack_frame (selected_frame, selected_frame_level, 1); 1608} 1609 1610/* The XDB Compatibility command to print the current frame. */ 1611 1612static void 1613current_frame_command (char *level_exp, int from_tty) 1614{ 1615 if (target_has_stack == 0 || selected_frame == 0) 1616 error ("No stack."); 1617 print_only_stack_frame (selected_frame, selected_frame_level, 1); 1618} 1619 1620/* Select the frame up one or COUNT stack levels 1621 from the previously selected frame, and print it briefly. */ 1622 1623/* ARGSUSED */ 1624static void 1625up_silently_base (char *count_exp) 1626{ 1627 register struct frame_info *fi; 1628 int count = 1, count1; 1629 if (count_exp) 1630 count = parse_and_eval_long (count_exp); 1631 count1 = count; 1632 1633 if (target_has_stack == 0 || selected_frame == 0) 1634 error ("No stack."); 1635 1636 fi = find_relative_frame (selected_frame, &count1); 1637 if (count1 != 0 && count_exp == 0) 1638 error ("Initial frame selected; you cannot go up."); 1639 select_frame (fi, selected_frame_level + count - count1); 1640} 1641 1642static void 1643up_silently_command (char *count_exp, int from_tty) 1644{ 1645 up_silently_base (count_exp); 1646} 1647 1648static void 1649up_command (char *count_exp, int from_tty) 1650{ 1651 up_silently_base (count_exp); 1652 show_and_print_stack_frame (selected_frame, selected_frame_level, 1); 1653} 1654 1655/* Select the frame down one or COUNT stack levels 1656 from the previously selected frame, and print it briefly. */ 1657 1658/* ARGSUSED */ 1659static void 1660down_silently_base (char *count_exp) 1661{ 1662 register struct frame_info *frame; 1663 int count = -1, count1; 1664 if (count_exp) 1665 count = -parse_and_eval_long (count_exp); 1666 count1 = count; 1667 1668 if (target_has_stack == 0 || selected_frame == 0) 1669 error ("No stack."); 1670 1671 frame = find_relative_frame (selected_frame, &count1); 1672 if (count1 != 0 && count_exp == 0) 1673 { 1674 1675 /* We only do this if count_exp is not specified. That way "down" 1676 means to really go down (and let me know if that is 1677 impossible), but "down 9999" can be used to mean go all the way 1678 down without getting an error. */ 1679 1680 error ("Bottom (i.e., innermost) frame selected; you cannot go down."); 1681 } 1682 1683 select_frame (frame, selected_frame_level + count - count1); 1684} 1685 1686/* ARGSUSED */ 1687static void 1688down_silently_command (char *count_exp, int from_tty) 1689{ 1690 down_silently_base (count_exp); 1691} 1692 1693static void 1694down_command (char *count_exp, int from_tty) 1695{ 1696 down_silently_base (count_exp); 1697 show_and_print_stack_frame (selected_frame, selected_frame_level, 1); 1698} 1699 1700void 1701return_command_wrapper (char *retval_exp, int from_tty) 1702{ 1703 return_command (retval_exp, from_tty); 1704} 1705 1706static void 1707return_command (char *retval_exp, int from_tty) 1708{ 1709 struct symbol *thisfun; 1710 CORE_ADDR selected_frame_addr; 1711 CORE_ADDR selected_frame_pc; 1712 struct frame_info *frame; 1713 struct value *return_value = NULL; 1714 1715 if (selected_frame == NULL) 1716 error ("No selected frame."); 1717 thisfun = get_frame_function (selected_frame); 1718 selected_frame_addr = FRAME_FP (selected_frame); 1719 selected_frame_pc = selected_frame->pc; 1720 1721 /* Compute the return value (if any -- possibly getting errors here). */ 1722 1723 if (retval_exp) 1724 { 1725 struct type *return_type = NULL; 1726 1727 return_value = parse_and_eval (retval_exp); 1728 1729 /* Cast return value to the return type of the function. */ 1730 if (thisfun != NULL) 1731 return_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun)); 1732 if (return_type == NULL) 1733 return_type = builtin_type_int; 1734 return_value = value_cast (return_type, return_value); 1735 1736 /* Make sure we have fully evaluated it, since 1737 it might live in the stack frame we're about to pop. */ 1738 if (VALUE_LAZY (return_value)) 1739 value_fetch_lazy (return_value); 1740 } 1741 1742 /* If interactive, require confirmation. */ 1743 1744 if (from_tty) 1745 { 1746 if (thisfun != 0) 1747 { 1748 if (!query ("Make %s return now? ", SYMBOL_SOURCE_NAME (thisfun))) 1749 { 1750 error ("Not confirmed."); 1751 /* NOTREACHED */ 1752 } 1753 } 1754 else if (!query ("Make selected stack frame return now? ")) 1755 error ("Not confirmed."); 1756 } 1757 1758 /* Do the real work. Pop until the specified frame is current. We 1759 use this method because the selected_frame is not valid after 1760 a POP_FRAME. The pc comparison makes this work even if the 1761 selected frame shares its fp with another frame. */ 1762 1763 while (selected_frame_addr != (frame = get_current_frame ())->frame 1764 || selected_frame_pc != frame->pc) 1765 POP_FRAME; 1766 1767 /* Then pop that frame. */ 1768 1769 POP_FRAME; 1770 1771 /* Compute the return value (if any) and store in the place 1772 for return values. */ 1773 1774 if (retval_exp) 1775 set_return_value (return_value); 1776 1777 /* If we are at the end of a call dummy now, pop the dummy frame too. */ 1778 1779 if (CALL_DUMMY_HAS_COMPLETED (read_pc(), read_sp (), 1780 FRAME_FP (get_current_frame ()))) 1781 POP_FRAME; 1782 1783 /* If interactive, print the frame that is now current. */ 1784 1785 if (from_tty) 1786 frame_command ("0", 1); 1787 else 1788 select_frame_command ("0", 0); 1789} 1790 1791/* Sets the scope to input function name, provided that the 1792 function is within the current stack frame */ 1793 1794struct function_bounds 1795{ 1796 CORE_ADDR low, high; 1797}; 1798 1799static void func_command (char *arg, int from_tty); 1800static void 1801func_command (char *arg, int from_tty) 1802{ 1803 struct frame_info *fp; 1804 int found = 0; 1805 struct symtabs_and_lines sals; 1806 int i; 1807 int level = 1; 1808 struct function_bounds *func_bounds = (struct function_bounds *) NULL; 1809 1810 if (arg != (char *) NULL) 1811 return; 1812 1813 fp = parse_frame_specification ("0"); 1814 sals = decode_line_spec (arg, 1); 1815 func_bounds = (struct function_bounds *) xmalloc ( 1816 sizeof (struct function_bounds) * sals.nelts); 1817 for (i = 0; (i < sals.nelts && !found); i++) 1818 { 1819 if (sals.sals[i].pc == (CORE_ADDR) 0 || 1820 find_pc_partial_function (sals.sals[i].pc, 1821 (char **) NULL, 1822 &func_bounds[i].low, 1823 &func_bounds[i].high) == 0) 1824 { 1825 func_bounds[i].low = 1826 func_bounds[i].high = (CORE_ADDR) NULL; 1827 } 1828 } 1829 1830 do 1831 { 1832 for (i = 0; (i < sals.nelts && !found); i++) 1833 found = (fp->pc >= func_bounds[i].low && 1834 fp->pc < func_bounds[i].high); 1835 if (!found) 1836 { 1837 level = 1; 1838 fp = find_relative_frame (fp, &level); 1839 } 1840 } 1841 while (!found && level == 0); 1842 1843 if (func_bounds) 1844 xfree (func_bounds); 1845 1846 if (!found) 1847 printf_filtered ("'%s' not within current stack frame.\n", arg); 1848 else if (fp != selected_frame) 1849 select_and_print_frame (fp, level); 1850} 1851 1852/* Gets the language of the current frame. */ 1853 1854enum language 1855get_frame_language (void) 1856{ 1857 register struct symtab *s; 1858 enum language flang; /* The language of the current frame */ 1859 1860 if (selected_frame) 1861 { 1862 s = find_pc_symtab (selected_frame->pc); 1863 if (s) 1864 flang = s->language; 1865 else 1866 flang = language_unknown; 1867 } 1868 else 1869 flang = language_unknown; 1870 1871 return flang; 1872} 1873 1874void 1875_initialize_stack (void) 1876{ 1877#if 0 1878 backtrace_limit = 30; 1879#endif 1880 1881 add_com ("return", class_stack, return_command, 1882 "Make selected stack frame return to its caller.\n\ 1883Control remains in the debugger, but when you continue\n\ 1884execution will resume in the frame above the one now selected.\n\ 1885If an argument is given, it is an expression for the value to return."); 1886 1887 add_com ("up", class_stack, up_command, 1888 "Select and print stack frame that called this one.\n\ 1889An argument says how many frames up to go."); 1890 add_com ("up-silently", class_support, up_silently_command, 1891 "Same as the `up' command, but does not print anything.\n\ 1892This is useful in command scripts."); 1893 1894 add_com ("down", class_stack, down_command, 1895 "Select and print stack frame called by this one.\n\ 1896An argument says how many frames down to go."); 1897 add_com_alias ("do", "down", class_stack, 1); 1898 add_com_alias ("dow", "down", class_stack, 1); 1899 add_com ("down-silently", class_support, down_silently_command, 1900 "Same as the `down' command, but does not print anything.\n\ 1901This is useful in command scripts."); 1902 1903 add_com ("frame", class_stack, frame_command, 1904 "Select and print a stack frame.\n\ 1905With no argument, print the selected stack frame. (See also \"info frame\").\n\ 1906An argument specifies the frame to select.\n\ 1907It can be a stack frame number or the address of the frame.\n\ 1908With argument, nothing is printed if input is coming from\n\ 1909a command file or a user-defined command."); 1910 1911 add_com_alias ("f", "frame", class_stack, 1); 1912 1913 if (xdb_commands) 1914 { 1915 add_com ("L", class_stack, current_frame_command, 1916 "Print the current stack frame.\n"); 1917 add_com_alias ("V", "frame", class_stack, 1); 1918 } 1919 add_com ("select-frame", class_stack, select_frame_command, 1920 "Select a stack frame without printing anything.\n\ 1921An argument specifies the frame to select.\n\ 1922It can be a stack frame number or the address of the frame.\n"); 1923 1924 add_com ("backtrace", class_stack, backtrace_command, 1925 "Print backtrace of all stack frames, or innermost COUNT frames.\n\ 1926With a negative argument, print outermost -COUNT frames.\n\ 1927Use of the 'full' qualifier also prints the values of the local variables.\n"); 1928 add_com_alias ("bt", "backtrace", class_stack, 0); 1929 if (xdb_commands) 1930 { 1931 add_com_alias ("t", "backtrace", class_stack, 0); 1932 add_com ("T", class_stack, backtrace_full_command, 1933 "Print backtrace of all stack frames, or innermost COUNT frames \n\ 1934and the values of the local variables.\n\ 1935With a negative argument, print outermost -COUNT frames.\n\ 1936Usage: T <count>\n"); 1937 } 1938 1939 add_com_alias ("where", "backtrace", class_alias, 0); 1940 add_info ("stack", backtrace_command, 1941 "Backtrace of the stack, or innermost COUNT frames."); 1942 add_info_alias ("s", "stack", 1); 1943 add_info ("frame", frame_info, 1944 "All about selected stack frame, or frame at ADDR."); 1945 add_info_alias ("f", "frame", 1); 1946 add_info ("locals", locals_info, 1947 "Local variables of current stack frame."); 1948 add_info ("args", args_info, 1949 "Argument variables of current stack frame."); 1950 if (xdb_commands) 1951 add_com ("l", class_info, args_plus_locals_info, 1952 "Argument and local variables of current stack frame."); 1953 1954 if (dbx_commands) 1955 add_com ("func", class_stack, func_command, 1956 "Select the stack frame that contains <func>.\nUsage: func <name>\n"); 1957 1958 add_info ("catch", catch_info, 1959 "Exceptions that can be caught in the current stack frame."); 1960 1961#if 0 1962 add_cmd ("backtrace-limit", class_stack, set_backtrace_limit_command, 1963 "Specify maximum number of frames for \"backtrace\" to print by default.", 1964 &setlist); 1965 add_info ("backtrace-limit", backtrace_limit_info, 1966 "The maximum number of frames for \"backtrace\" to print by default."); 1967#endif 1968} 1969