1 /* Print and select stack frames for GDB, the GNU debugger. 2 3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 5 2009, 2010 Free Software 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 3 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, see <http://www.gnu.org/licenses/>. */ 21 22 #include "defs.h" 23 #include "value.h" 24 #include "symtab.h" 25 #include "gdbtypes.h" 26 #include "expression.h" 27 #include "language.h" 28 #include "frame.h" 29 #include "gdbcmd.h" 30 #include "gdbcore.h" 31 #include "target.h" 32 #include "source.h" 33 #include "breakpoint.h" 34 #include "demangle.h" 35 #include "inferior.h" 36 #include "annotate.h" 37 #include "ui-out.h" 38 #include "block.h" 39 #include "stack.h" 40 #include "dictionary.h" 41 #include "exceptions.h" 42 #include "reggroups.h" 43 #include "regcache.h" 44 #include "solib.h" 45 #include "valprint.h" 46 #include "gdbthread.h" 47 #include "cp-support.h" 48 #include "disasm.h" 49 #include "inline-frame.h" 50 51 #include "gdb_assert.h" 52 #include <ctype.h> 53 #include "gdb_string.h" 54 55 #include "psymtab.h" 56 #include "symfile.h" 57 58 void (*deprecated_selected_frame_level_changed_hook) (int); 59 60 /* The possible choices of "set print frame-arguments, and the value 61 of this setting. */ 62 63 static const char *print_frame_arguments_choices[] = 64 {"all", "scalars", "none", NULL}; 65 static const char *print_frame_arguments = "scalars"; 66 67 /* Prototypes for local functions. */ 68 69 static void print_frame_local_vars (struct frame_info *, int, 70 struct ui_file *); 71 72 static void print_frame (struct frame_info *frame, int print_level, 73 enum print_what print_what, int print_args, 74 struct symtab_and_line sal); 75 76 /* Zero means do things normally; we are interacting directly with the 77 user. One means print the full filename and linenumber when a 78 frame is printed, and do so in a format emacs18/emacs19.22 can 79 parse. Two means print similar annotations, but in many more 80 cases and in a slightly different syntax. */ 81 82 int annotation_level = 0; 83 84 85 struct print_stack_frame_args 86 { 87 struct frame_info *frame; 88 int print_level; 89 enum print_what print_what; 90 int print_args; 91 }; 92 93 /* Show or print the frame arguments; stub for catch_errors. */ 94 95 static int 96 print_stack_frame_stub (void *args) 97 { 98 struct print_stack_frame_args *p = args; 99 int center = (p->print_what == SRC_LINE || p->print_what == SRC_AND_LOC); 100 101 print_frame_info (p->frame, p->print_level, p->print_what, p->print_args); 102 set_current_sal_from_frame (p->frame, center); 103 return 0; 104 } 105 106 /* Return 1 if we should display the address in addition to the location, 107 because we are in the middle of a statement. */ 108 109 static int 110 frame_show_address (struct frame_info *frame, 111 struct symtab_and_line sal) 112 { 113 /* If there is a line number, but no PC, then there is no location 114 information associated with this sal. The only way that should 115 happen is for the call sites of inlined functions (SAL comes from 116 find_frame_sal). Otherwise, we would have some PC range if the 117 SAL came from a line table. */ 118 if (sal.line != 0 && sal.pc == 0 && sal.end == 0) 119 { 120 if (get_next_frame (frame) == NULL) 121 gdb_assert (inline_skipped_frames (inferior_ptid) > 0); 122 else 123 gdb_assert (get_frame_type (get_next_frame (frame)) == INLINE_FRAME); 124 return 0; 125 } 126 127 return get_frame_pc (frame) != sal.pc; 128 } 129 130 /* Show or print a stack frame FRAME briefly. The output is format 131 according to PRINT_LEVEL and PRINT_WHAT printing the frame's 132 relative level, function name, argument list, and file name and 133 line number. If the frame's PC is not at the beginning of the 134 source line, the actual PC is printed at the beginning. */ 135 136 void 137 print_stack_frame (struct frame_info *frame, int print_level, 138 enum print_what print_what) 139 { 140 struct print_stack_frame_args args; 141 142 args.frame = frame; 143 args.print_level = print_level; 144 args.print_what = print_what; 145 /* For mi, alway print location and address. */ 146 args.print_what = ui_out_is_mi_like_p (uiout) ? LOC_AND_ADDRESS : print_what; 147 args.print_args = 1; 148 149 catch_errors (print_stack_frame_stub, &args, "", RETURN_MASK_ERROR); 150 } 151 152 struct print_args_args 153 { 154 struct symbol *func; 155 struct frame_info *frame; 156 struct ui_file *stream; 157 }; 158 159 static int print_args_stub (void *args); 160 161 /* Print nameless arguments of frame FRAME on STREAM, where START is 162 the offset of the first nameless argument, and NUM is the number of 163 nameless arguments to print. FIRST is nonzero if this is the first 164 argument (not just the first nameless argument). */ 165 166 static void 167 print_frame_nameless_args (struct frame_info *frame, long start, int num, 168 int first, struct ui_file *stream) 169 { 170 struct gdbarch *gdbarch = get_frame_arch (frame); 171 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 172 int i; 173 CORE_ADDR argsaddr; 174 long arg_value; 175 176 for (i = 0; i < num; i++) 177 { 178 QUIT; 179 argsaddr = get_frame_args_address (frame); 180 if (!argsaddr) 181 return; 182 arg_value = read_memory_integer (argsaddr + start, 183 sizeof (int), byte_order); 184 if (!first) 185 fprintf_filtered (stream, ", "); 186 fprintf_filtered (stream, "%ld", arg_value); 187 first = 0; 188 start += sizeof (int); 189 } 190 } 191 192 /* Print the arguments of frame FRAME on STREAM, given the function 193 FUNC running in that frame (as a symbol), where NUM is the number 194 of arguments according to the stack frame (or -1 if the number of 195 arguments is unknown). */ 196 197 /* Note that currently the "number of arguments according to the 198 stack frame" is only known on VAX where i refers to the "number of 199 ints of arguments according to the stack frame". */ 200 201 static void 202 print_frame_args (struct symbol *func, struct frame_info *frame, 203 int num, struct ui_file *stream) 204 { 205 int first = 1; 206 /* Offset of next stack argument beyond the one we have seen that is 207 at the highest offset, or -1 if we haven't come to a stack 208 argument yet. */ 209 long highest_offset = -1; 210 /* Number of ints of arguments that we have printed so far. */ 211 int args_printed = 0; 212 struct cleanup *old_chain, *list_chain; 213 struct ui_stream *stb; 214 /* True if we should print arguments, false otherwise. */ 215 int print_args = strcmp (print_frame_arguments, "none"); 216 /* True in "summary" mode, false otherwise. */ 217 int summary = !strcmp (print_frame_arguments, "scalars"); 218 219 stb = ui_out_stream_new (uiout); 220 old_chain = make_cleanup_ui_out_stream_delete (stb); 221 222 if (func) 223 { 224 struct block *b = SYMBOL_BLOCK_VALUE (func); 225 struct dict_iterator iter; 226 struct symbol *sym; 227 struct value *val; 228 229 ALL_BLOCK_SYMBOLS (b, iter, sym) 230 { 231 QUIT; 232 233 /* Keep track of the highest stack argument offset seen, and 234 skip over any kinds of symbols we don't care about. */ 235 236 if (!SYMBOL_IS_ARGUMENT (sym)) 237 continue; 238 239 switch (SYMBOL_CLASS (sym)) 240 { 241 case LOC_ARG: 242 case LOC_REF_ARG: 243 { 244 long current_offset = SYMBOL_VALUE (sym); 245 int arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym)); 246 247 /* Compute address of next argument by adding the size of 248 this argument and rounding to an int boundary. */ 249 current_offset = 250 ((current_offset + arg_size + sizeof (int) - 1) 251 & ~(sizeof (int) - 1)); 252 253 /* If this is the highest offset seen yet, set 254 highest_offset. */ 255 if (highest_offset == -1 256 || (current_offset > highest_offset)) 257 highest_offset = current_offset; 258 259 /* Add the number of ints we're about to print to 260 args_printed. */ 261 args_printed += (arg_size + sizeof (int) - 1) / sizeof (int); 262 } 263 264 /* We care about types of symbols, but don't need to 265 keep track of stack offsets in them. */ 266 case LOC_REGISTER: 267 case LOC_REGPARM_ADDR: 268 case LOC_COMPUTED: 269 case LOC_OPTIMIZED_OUT: 270 default: 271 break; 272 } 273 274 /* We have to look up the symbol because arguments can have 275 two entries (one a parameter, one a local) and the one we 276 want is the local, which lookup_symbol will find for us. 277 This includes gcc1 (not gcc2) on SPARC when passing a 278 small structure and gcc2 when the argument type is float 279 and it is passed as a double and converted to float by 280 the prologue (in the latter case the type of the LOC_ARG 281 symbol is double and the type of the LOC_LOCAL symbol is 282 float). */ 283 /* But if the parameter name is null, don't try it. Null 284 parameter names occur on the RS/6000, for traceback 285 tables. FIXME, should we even print them? */ 286 287 if (*SYMBOL_LINKAGE_NAME (sym)) 288 { 289 struct symbol *nsym; 290 291 nsym = lookup_symbol (SYMBOL_LINKAGE_NAME (sym), 292 b, VAR_DOMAIN, NULL); 293 gdb_assert (nsym != NULL); 294 if (SYMBOL_CLASS (nsym) == LOC_REGISTER 295 && !SYMBOL_IS_ARGUMENT (nsym)) 296 { 297 /* There is a LOC_ARG/LOC_REGISTER pair. This means 298 that it was passed on the stack and loaded into a 299 register, or passed in a register and stored in a 300 stack slot. GDB 3.x used the LOC_ARG; GDB 301 4.0-4.11 used the LOC_REGISTER. 302 303 Reasons for using the LOC_ARG: 304 305 (1) Because find_saved_registers may be slow for 306 remote debugging. 307 308 (2) Because registers are often re-used and stack 309 slots rarely (never?) are. Therefore using 310 the stack slot is much less likely to print 311 garbage. 312 313 Reasons why we might want to use the LOC_REGISTER: 314 315 (1) So that the backtrace prints the same value 316 as "print foo". I see no compelling reason 317 why this needs to be the case; having the 318 backtrace print the value which was passed 319 in, and "print foo" print the value as 320 modified within the called function, makes 321 perfect sense to me. 322 323 Additional note: It might be nice if "info args" 324 displayed both values. 325 326 One more note: There is a case with SPARC 327 structure passing where we need to use the 328 LOC_REGISTER, but this is dealt with by creating 329 a single LOC_REGPARM in symbol reading. */ 330 331 /* Leave sym (the LOC_ARG) alone. */ 332 ; 333 } 334 else 335 sym = nsym; 336 } 337 338 /* Print the current arg. */ 339 if (!first) 340 ui_out_text (uiout, ", "); 341 ui_out_wrap_hint (uiout, " "); 342 343 annotate_arg_begin (); 344 345 list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); 346 fprintf_symbol_filtered (stb->stream, SYMBOL_PRINT_NAME (sym), 347 SYMBOL_LANGUAGE (sym), 348 DMGL_PARAMS | DMGL_ANSI); 349 ui_out_field_stream (uiout, "name", stb); 350 annotate_arg_name_end (); 351 ui_out_text (uiout, "="); 352 353 if (print_args) 354 { 355 /* Avoid value_print because it will deref ref parameters. 356 We just want to print their addresses. Print ??? for 357 args whose address we do not know. We pass 2 as 358 "recurse" to val_print because our standard indentation 359 here is 4 spaces, and val_print indents 2 for each 360 recurse. */ 361 val = read_var_value (sym, frame); 362 363 annotate_arg_value (val == NULL ? NULL : value_type (val)); 364 365 if (val) 366 { 367 const struct language_defn *language; 368 struct value_print_options opts; 369 370 /* Use the appropriate language to display our symbol, 371 unless the user forced the language to a specific 372 language. */ 373 if (language_mode == language_mode_auto) 374 language = language_def (SYMBOL_LANGUAGE (sym)); 375 else 376 language = current_language; 377 378 get_raw_print_options (&opts); 379 opts.deref_ref = 0; 380 opts.summary = summary; 381 common_val_print (val, stb->stream, 2, &opts, language); 382 ui_out_field_stream (uiout, "value", stb); 383 } 384 else 385 ui_out_text (uiout, "???"); 386 } 387 else 388 ui_out_text (uiout, "..."); 389 390 391 /* Invoke ui_out_tuple_end. */ 392 do_cleanups (list_chain); 393 394 annotate_arg_end (); 395 396 first = 0; 397 } 398 } 399 400 /* Don't print nameless args in situations where we don't know 401 enough about the stack to find them. */ 402 if (num != -1) 403 { 404 long start; 405 406 if (highest_offset == -1) 407 start = gdbarch_frame_args_skip (get_frame_arch (frame)); 408 else 409 start = highest_offset; 410 411 print_frame_nameless_args (frame, start, num - args_printed, 412 first, stream); 413 } 414 415 do_cleanups (old_chain); 416 } 417 418 /* Stub for catch_errors. */ 419 420 static int 421 print_args_stub (void *args) 422 { 423 struct print_args_args *p = args; 424 struct gdbarch *gdbarch = get_frame_arch (p->frame); 425 int numargs; 426 427 if (gdbarch_frame_num_args_p (gdbarch)) 428 { 429 numargs = gdbarch_frame_num_args (gdbarch, p->frame); 430 gdb_assert (numargs >= 0); 431 } 432 else 433 numargs = -1; 434 print_frame_args (p->func, p->frame, numargs, p->stream); 435 return 0; 436 } 437 438 /* Set the current source and line to the location given by frame 439 FRAME, if possible. When CENTER is true, adjust so the relevant 440 line is in the center of the next 'list'. */ 441 442 void 443 set_current_sal_from_frame (struct frame_info *frame, int center) 444 { 445 struct symtab_and_line sal; 446 447 find_frame_sal (frame, &sal); 448 if (sal.symtab) 449 { 450 if (center) 451 sal.line = max (sal.line - get_lines_to_list () / 2, 1); 452 set_current_source_symtab_and_line (&sal); 453 } 454 } 455 456 /* If ON, GDB will display disassembly of the next source line when 457 execution of the program being debugged stops. 458 If AUTO (which is the default), or there's no line info to determine 459 the source line of the next instruction, display disassembly of next 460 instruction instead. */ 461 462 static enum auto_boolean disassemble_next_line; 463 464 static void 465 show_disassemble_next_line (struct ui_file *file, int from_tty, 466 struct cmd_list_element *c, 467 const char *value) 468 { 469 fprintf_filtered (file, _("\ 470 Debugger's willingness to use disassemble-next-line is %s.\n"), 471 value); 472 } 473 474 /* Show assembly codes; stub for catch_errors. */ 475 476 struct gdb_disassembly_stub_args 477 { 478 struct gdbarch *gdbarch; 479 int how_many; 480 CORE_ADDR low; 481 CORE_ADDR high; 482 }; 483 484 static void 485 gdb_disassembly_stub (void *args) 486 { 487 struct gdb_disassembly_stub_args *p = args; 488 489 gdb_disassembly (p->gdbarch, uiout, 0, 490 DISASSEMBLY_RAW_INSN, p->how_many, 491 p->low, p->high); 492 } 493 494 /* Use TRY_CATCH to catch the exception from the gdb_disassembly 495 because it will be broken by filter sometime. */ 496 497 static void 498 do_gdb_disassembly (struct gdbarch *gdbarch, 499 int how_many, CORE_ADDR low, CORE_ADDR high) 500 { 501 volatile struct gdb_exception exception; 502 struct gdb_disassembly_stub_args args; 503 504 args.gdbarch = gdbarch; 505 args.how_many = how_many; 506 args.low = low; 507 args.high = high; 508 TRY_CATCH (exception, RETURN_MASK_ALL) 509 { 510 gdb_disassembly_stub (&args); 511 } 512 /* If an exception was thrown while doing the disassembly, print 513 the error message, to give the user a clue of what happened. */ 514 if (exception.reason == RETURN_ERROR) 515 exception_print (gdb_stderr, exception); 516 } 517 518 /* Print information about frame FRAME. The output is format according 519 to PRINT_LEVEL and PRINT_WHAT and PRINT ARGS. The meaning of 520 PRINT_WHAT is: 521 522 SRC_LINE: Print only source line. 523 LOCATION: Print only location. 524 LOC_AND_SRC: Print location and source line. 525 526 Used in "where" output, and to emit breakpoint or step 527 messages. */ 528 529 void 530 print_frame_info (struct frame_info *frame, int print_level, 531 enum print_what print_what, int print_args) 532 { 533 struct gdbarch *gdbarch = get_frame_arch (frame); 534 struct symtab_and_line sal; 535 int source_print; 536 int location_print; 537 538 if (get_frame_type (frame) == DUMMY_FRAME 539 || get_frame_type (frame) == SIGTRAMP_FRAME 540 || get_frame_type (frame) == ARCH_FRAME) 541 { 542 struct cleanup *uiout_cleanup 543 = make_cleanup_ui_out_tuple_begin_end (uiout, "frame"); 544 545 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0, 546 gdbarch, get_frame_pc (frame)); 547 548 /* Do this regardless of SOURCE because we don't have any source 549 to list for this frame. */ 550 if (print_level) 551 { 552 ui_out_text (uiout, "#"); 553 ui_out_field_fmt_int (uiout, 2, ui_left, "level", 554 frame_relative_level (frame)); 555 } 556 if (ui_out_is_mi_like_p (uiout)) 557 { 558 annotate_frame_address (); 559 ui_out_field_core_addr (uiout, "addr", 560 gdbarch, get_frame_pc (frame)); 561 annotate_frame_address_end (); 562 } 563 564 if (get_frame_type (frame) == DUMMY_FRAME) 565 { 566 annotate_function_call (); 567 ui_out_field_string (uiout, "func", "<function called from gdb>"); 568 } 569 else if (get_frame_type (frame) == SIGTRAMP_FRAME) 570 { 571 annotate_signal_handler_caller (); 572 ui_out_field_string (uiout, "func", "<signal handler called>"); 573 } 574 else if (get_frame_type (frame) == ARCH_FRAME) 575 { 576 ui_out_field_string (uiout, "func", "<cross-architecture call>"); 577 } 578 ui_out_text (uiout, "\n"); 579 annotate_frame_end (); 580 581 do_cleanups (uiout_cleanup); 582 return; 583 } 584 585 /* If FRAME is not the innermost frame, that normally means that 586 FRAME->pc points to *after* the call instruction, and we want to 587 get the line containing the call, never the next line. But if 588 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the 589 next frame was not entered as the result of a call, and we want 590 to get the line containing FRAME->pc. */ 591 find_frame_sal (frame, &sal); 592 593 location_print = (print_what == LOCATION 594 || print_what == LOC_AND_ADDRESS 595 || print_what == SRC_AND_LOC); 596 597 if (location_print || !sal.symtab) 598 print_frame (frame, print_level, print_what, print_args, sal); 599 600 source_print = (print_what == SRC_LINE || print_what == SRC_AND_LOC); 601 602 /* If disassemble-next-line is set to auto or on and doesn't have 603 the line debug messages for $pc, output the next instruction. */ 604 if ((disassemble_next_line == AUTO_BOOLEAN_AUTO 605 || disassemble_next_line == AUTO_BOOLEAN_TRUE) 606 && source_print && !sal.symtab) 607 do_gdb_disassembly (get_frame_arch (frame), 1, 608 get_frame_pc (frame), get_frame_pc (frame) + 1); 609 610 if (source_print && sal.symtab) 611 { 612 int done = 0; 613 int mid_statement = ((print_what == SRC_LINE) 614 && frame_show_address (frame, sal)); 615 616 if (annotation_level) 617 done = identify_source_line (sal.symtab, sal.line, mid_statement, 618 get_frame_pc (frame)); 619 if (!done) 620 { 621 if (deprecated_print_frame_info_listing_hook) 622 deprecated_print_frame_info_listing_hook (sal.symtab, 623 sal.line, 624 sal.line + 1, 0); 625 else 626 { 627 struct value_print_options opts; 628 629 get_user_print_options (&opts); 630 /* We used to do this earlier, but that is clearly 631 wrong. This function is used by many different 632 parts of gdb, including normal_stop in infrun.c, 633 which uses this to print out the current PC 634 when we stepi/nexti into the middle of a source 635 line. Only the command line really wants this 636 behavior. Other UIs probably would like the 637 ability to decide for themselves if it is desired. */ 638 if (opts.addressprint && mid_statement) 639 { 640 ui_out_field_core_addr (uiout, "addr", 641 gdbarch, get_frame_pc (frame)); 642 ui_out_text (uiout, "\t"); 643 } 644 645 print_source_lines (sal.symtab, sal.line, sal.line + 1, 0); 646 } 647 } 648 649 /* If disassemble-next-line is set to on and there is line debug 650 messages, output assembly codes for next line. */ 651 if (disassemble_next_line == AUTO_BOOLEAN_TRUE) 652 do_gdb_disassembly (get_frame_arch (frame), -1, sal.pc, sal.end); 653 } 654 655 if (print_what != LOCATION) 656 set_default_breakpoint (1, sal.pspace, 657 get_frame_pc (frame), sal.symtab, sal.line); 658 659 annotate_frame_end (); 660 661 gdb_flush (gdb_stdout); 662 } 663 664 /* Attempt to obtain the FUNNAME and FUNLANG of the function corresponding 665 to FRAME. */ 666 void 667 find_frame_funname (struct frame_info *frame, char **funname, 668 enum language *funlang) 669 { 670 struct symbol *func; 671 672 *funname = NULL; 673 *funlang = language_unknown; 674 675 func = get_frame_function (frame); 676 if (func) 677 { 678 /* In certain pathological cases, the symtabs give the wrong 679 function (when we are in the first function in a file which 680 is compiled without debugging symbols, the previous function 681 is compiled with debugging symbols, and the "foo.o" symbol 682 that is supposed to tell us where the file with debugging 683 symbols ends has been truncated by ar because it is longer 684 than 15 characters). This also occurs if the user uses asm() 685 to create a function but not stabs for it (in a file compiled 686 with -g). 687 688 So look in the minimal symbol tables as well, and if it comes 689 up with a larger address for the function use that instead. 690 I don't think this can ever cause any problems; there 691 shouldn't be any minimal symbols in the middle of a function; 692 if this is ever changed many parts of GDB will need to be 693 changed (and we'll create a find_pc_minimal_function or some 694 such). */ 695 696 struct minimal_symbol *msymbol = NULL; 697 698 /* Don't attempt to do this for inlined functions, which do not 699 have a corresponding minimal symbol. */ 700 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func))) 701 msymbol 702 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame)); 703 704 if (msymbol != NULL 705 && (SYMBOL_VALUE_ADDRESS (msymbol) 706 > BLOCK_START (SYMBOL_BLOCK_VALUE (func)))) 707 { 708 /* We also don't know anything about the function besides 709 its address and name. */ 710 func = 0; 711 *funname = SYMBOL_PRINT_NAME (msymbol); 712 *funlang = SYMBOL_LANGUAGE (msymbol); 713 } 714 else 715 { 716 *funname = SYMBOL_PRINT_NAME (func); 717 *funlang = SYMBOL_LANGUAGE (func); 718 if (*funlang == language_cplus) 719 { 720 /* It seems appropriate to use SYMBOL_PRINT_NAME() here, 721 to display the demangled name that we already have 722 stored in the symbol table, but we stored a version 723 with DMGL_PARAMS turned on, and here we don't want to 724 display parameters. So remove the parameters. */ 725 char *func_only = cp_remove_params (*funname); 726 727 if (func_only) 728 { 729 *funname = func_only; 730 make_cleanup (xfree, func_only); 731 } 732 } 733 } 734 } 735 else 736 { 737 struct minimal_symbol *msymbol = 738 lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame)); 739 740 if (msymbol != NULL) 741 { 742 *funname = SYMBOL_PRINT_NAME (msymbol); 743 *funlang = SYMBOL_LANGUAGE (msymbol); 744 } 745 } 746 } 747 748 static void 749 print_frame (struct frame_info *frame, int print_level, 750 enum print_what print_what, int print_args, 751 struct symtab_and_line sal) 752 { 753 struct gdbarch *gdbarch = get_frame_arch (frame); 754 char *funname = NULL; 755 enum language funlang = language_unknown; 756 struct ui_stream *stb; 757 struct cleanup *old_chain, *list_chain; 758 struct value_print_options opts; 759 760 stb = ui_out_stream_new (uiout); 761 old_chain = make_cleanup_ui_out_stream_delete (stb); 762 763 find_frame_funname (frame, &funname, &funlang); 764 765 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0, 766 gdbarch, get_frame_pc (frame)); 767 768 list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "frame"); 769 770 if (print_level) 771 { 772 ui_out_text (uiout, "#"); 773 ui_out_field_fmt_int (uiout, 2, ui_left, "level", 774 frame_relative_level (frame)); 775 } 776 get_user_print_options (&opts); 777 if (opts.addressprint) 778 if (frame_show_address (frame, sal) || !sal.symtab 779 || print_what == LOC_AND_ADDRESS) 780 { 781 annotate_frame_address (); 782 ui_out_field_core_addr (uiout, "addr", gdbarch, get_frame_pc (frame)); 783 annotate_frame_address_end (); 784 ui_out_text (uiout, " in "); 785 } 786 annotate_frame_function_name (); 787 fprintf_symbol_filtered (stb->stream, funname ? funname : "??", 788 funlang, DMGL_ANSI); 789 ui_out_field_stream (uiout, "func", stb); 790 ui_out_wrap_hint (uiout, " "); 791 annotate_frame_args (); 792 793 ui_out_text (uiout, " ("); 794 if (print_args) 795 { 796 struct print_args_args args; 797 struct cleanup *args_list_chain; 798 799 args.frame = frame; 800 args.func = find_pc_function (get_frame_address_in_block (frame)); 801 args.stream = gdb_stdout; 802 args_list_chain = make_cleanup_ui_out_list_begin_end (uiout, "args"); 803 catch_errors (print_args_stub, &args, "", RETURN_MASK_ERROR); 804 /* FIXME: ARGS must be a list. If one argument is a string it 805 will have " that will not be properly escaped. */ 806 /* Invoke ui_out_tuple_end. */ 807 do_cleanups (args_list_chain); 808 QUIT; 809 } 810 ui_out_text (uiout, ")"); 811 if (sal.symtab && sal.symtab->filename) 812 { 813 annotate_frame_source_begin (); 814 ui_out_wrap_hint (uiout, " "); 815 ui_out_text (uiout, " at "); 816 annotate_frame_source_file (); 817 ui_out_field_string (uiout, "file", sal.symtab->filename); 818 if (ui_out_is_mi_like_p (uiout)) 819 { 820 const char *fullname = symtab_to_fullname (sal.symtab); 821 822 if (fullname != NULL) 823 ui_out_field_string (uiout, "fullname", fullname); 824 } 825 annotate_frame_source_file_end (); 826 ui_out_text (uiout, ":"); 827 annotate_frame_source_line (); 828 ui_out_field_int (uiout, "line", sal.line); 829 annotate_frame_source_end (); 830 } 831 832 if (!funname || (!sal.symtab || !sal.symtab->filename)) 833 { 834 #ifdef PC_SOLIB 835 char *lib = PC_SOLIB (get_frame_pc (frame)); 836 #else 837 char *lib = solib_name_from_address (get_frame_program_space (frame), 838 get_frame_pc (frame)); 839 #endif 840 if (lib) 841 { 842 annotate_frame_where (); 843 ui_out_wrap_hint (uiout, " "); 844 ui_out_text (uiout, " from "); 845 ui_out_field_string (uiout, "from", lib); 846 } 847 } 848 849 /* do_cleanups will call ui_out_tuple_end() for us. */ 850 do_cleanups (list_chain); 851 ui_out_text (uiout, "\n"); 852 do_cleanups (old_chain); 853 } 854 855 856 /* Read a frame specification in whatever the appropriate format is 857 from FRAME_EXP. Call error(), printing MESSAGE, if the 858 specification is in any way invalid (so this function never returns 859 NULL). When SEPECTED_P is non-NULL set its target to indicate that 860 the default selected frame was used. */ 861 862 static struct frame_info * 863 parse_frame_specification_1 (const char *frame_exp, const char *message, 864 int *selected_frame_p) 865 { 866 int numargs; 867 struct value *args[4]; 868 CORE_ADDR addrs[ARRAY_SIZE (args)]; 869 870 if (frame_exp == NULL) 871 numargs = 0; 872 else 873 { 874 numargs = 0; 875 while (1) 876 { 877 char *addr_string; 878 struct cleanup *cleanup; 879 const char *p; 880 881 /* Skip leading white space, bail of EOL. */ 882 while (isspace (*frame_exp)) 883 frame_exp++; 884 if (!*frame_exp) 885 break; 886 887 /* Parse the argument, extract it, save it. */ 888 for (p = frame_exp; 889 *p && !isspace (*p); 890 p++); 891 addr_string = savestring (frame_exp, p - frame_exp); 892 frame_exp = p; 893 cleanup = make_cleanup (xfree, addr_string); 894 895 /* NOTE: Parse and evaluate expression, but do not use 896 functions such as parse_and_eval_long or 897 parse_and_eval_address to also extract the value. 898 Instead value_as_long and value_as_address are used. 899 This avoids problems with expressions that contain 900 side-effects. */ 901 if (numargs >= ARRAY_SIZE (args)) 902 error (_("Too many args in frame specification")); 903 args[numargs++] = parse_and_eval (addr_string); 904 905 do_cleanups (cleanup); 906 } 907 } 908 909 /* If no args, default to the selected frame. */ 910 if (numargs == 0) 911 { 912 if (selected_frame_p != NULL) 913 (*selected_frame_p) = 1; 914 return get_selected_frame (message); 915 } 916 917 /* None of the remaining use the selected frame. */ 918 if (selected_frame_p != NULL) 919 (*selected_frame_p) = 0; 920 921 /* Assume the single arg[0] is an integer, and try using that to 922 select a frame relative to current. */ 923 if (numargs == 1) 924 { 925 struct frame_info *fid; 926 int level = value_as_long (args[0]); 927 928 fid = find_relative_frame (get_current_frame (), &level); 929 if (level == 0) 930 /* find_relative_frame was successful */ 931 return fid; 932 } 933 934 /* Convert each value into a corresponding address. */ 935 { 936 int i; 937 938 for (i = 0; i < numargs; i++) 939 addrs[i] = value_as_address (args[i]); 940 } 941 942 /* Assume that the single arg[0] is an address, use that to identify 943 a frame with a matching ID. Should this also accept stack/pc or 944 stack/pc/special. */ 945 if (numargs == 1) 946 { 947 struct frame_id id = frame_id_build_wild (addrs[0]); 948 struct frame_info *fid; 949 950 /* If (s)he specifies the frame with an address, he deserves 951 what (s)he gets. Still, give the highest one that matches. 952 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't 953 know). */ 954 for (fid = get_current_frame (); 955 fid != NULL; 956 fid = get_prev_frame (fid)) 957 { 958 if (frame_id_eq (id, get_frame_id (fid))) 959 { 960 struct frame_info *prev_frame; 961 962 while (1) 963 { 964 prev_frame = get_prev_frame (fid); 965 if (!prev_frame 966 || !frame_id_eq (id, get_frame_id (prev_frame))) 967 break; 968 fid = prev_frame; 969 } 970 return fid; 971 } 972 } 973 } 974 975 /* We couldn't identify the frame as an existing frame, but 976 perhaps we can create one with a single argument. */ 977 if (numargs == 1) 978 return create_new_frame (addrs[0], 0); 979 else if (numargs == 2) 980 return create_new_frame (addrs[0], addrs[1]); 981 else 982 error (_("Too many args in frame specification")); 983 } 984 985 static struct frame_info * 986 parse_frame_specification (char *frame_exp) 987 { 988 return parse_frame_specification_1 (frame_exp, NULL, NULL); 989 } 990 991 /* Print verbosely the selected frame or the frame at address 992 ADDR_EXP. Absolutely all information in the frame is printed. */ 993 994 static void 995 frame_info (char *addr_exp, int from_tty) 996 { 997 struct frame_info *fi; 998 struct symtab_and_line sal; 999 struct symbol *func; 1000 struct symtab *s; 1001 struct frame_info *calling_frame_info; 1002 int numregs; 1003 char *funname = 0; 1004 enum language funlang = language_unknown; 1005 const char *pc_regname; 1006 int selected_frame_p; 1007 struct gdbarch *gdbarch; 1008 struct cleanup *back_to = make_cleanup (null_cleanup, NULL); 1009 1010 fi = parse_frame_specification_1 (addr_exp, "No stack.", &selected_frame_p); 1011 gdbarch = get_frame_arch (fi); 1012 1013 /* Name of the value returned by get_frame_pc(). Per comments, "pc" 1014 is not a good name. */ 1015 if (gdbarch_pc_regnum (gdbarch) >= 0) 1016 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can 1017 easily not match that of the internal value returned by 1018 get_frame_pc(). */ 1019 pc_regname = gdbarch_register_name (gdbarch, gdbarch_pc_regnum (gdbarch)); 1020 else 1021 /* But then, this is weird to. Even without gdbarch_pc_regnum, an 1022 architectures will often have a hardware register called "pc", 1023 and that register's value, again, can easily not match 1024 get_frame_pc(). */ 1025 pc_regname = "pc"; 1026 1027 find_frame_sal (fi, &sal); 1028 func = get_frame_function (fi); 1029 /* FIXME: cagney/2002-11-28: Why bother? Won't sal.symtab contain 1030 the same value? */ 1031 s = find_pc_symtab (get_frame_pc (fi)); 1032 if (func) 1033 { 1034 funname = SYMBOL_PRINT_NAME (func); 1035 funlang = SYMBOL_LANGUAGE (func); 1036 if (funlang == language_cplus) 1037 { 1038 /* It seems appropriate to use SYMBOL_PRINT_NAME() here, 1039 to display the demangled name that we already have 1040 stored in the symbol table, but we stored a version 1041 with DMGL_PARAMS turned on, and here we don't want to 1042 display parameters. So remove the parameters. */ 1043 char *func_only = cp_remove_params (funname); 1044 1045 if (func_only) 1046 { 1047 funname = func_only; 1048 make_cleanup (xfree, func_only); 1049 } 1050 } 1051 } 1052 else 1053 { 1054 struct minimal_symbol *msymbol; 1055 1056 msymbol = lookup_minimal_symbol_by_pc (get_frame_pc (fi)); 1057 if (msymbol != NULL) 1058 { 1059 funname = SYMBOL_PRINT_NAME (msymbol); 1060 funlang = SYMBOL_LANGUAGE (msymbol); 1061 } 1062 } 1063 calling_frame_info = get_prev_frame (fi); 1064 1065 if (selected_frame_p && frame_relative_level (fi) >= 0) 1066 { 1067 printf_filtered (_("Stack level %d, frame at "), 1068 frame_relative_level (fi)); 1069 } 1070 else 1071 { 1072 printf_filtered (_("Stack frame at ")); 1073 } 1074 fputs_filtered (paddress (gdbarch, get_frame_base (fi)), gdb_stdout); 1075 printf_filtered (":\n"); 1076 printf_filtered (" %s = ", pc_regname); 1077 fputs_filtered (paddress (gdbarch, get_frame_pc (fi)), gdb_stdout); 1078 1079 wrap_here (" "); 1080 if (funname) 1081 { 1082 printf_filtered (" in "); 1083 fprintf_symbol_filtered (gdb_stdout, funname, funlang, 1084 DMGL_ANSI | DMGL_PARAMS); 1085 } 1086 wrap_here (" "); 1087 if (sal.symtab) 1088 printf_filtered (" (%s:%d)", sal.symtab->filename, sal.line); 1089 puts_filtered ("; "); 1090 wrap_here (" "); 1091 printf_filtered ("saved %s ", pc_regname); 1092 fputs_filtered (paddress (gdbarch, frame_unwind_caller_pc (fi)), gdb_stdout); 1093 printf_filtered ("\n"); 1094 1095 if (calling_frame_info == NULL) 1096 { 1097 enum unwind_stop_reason reason; 1098 1099 reason = get_frame_unwind_stop_reason (fi); 1100 if (reason != UNWIND_NO_REASON) 1101 printf_filtered (_(" Outermost frame: %s\n"), 1102 frame_stop_reason_string (reason)); 1103 } 1104 else if (get_frame_type (fi) == INLINE_FRAME) 1105 printf_filtered (" inlined into frame %d", 1106 frame_relative_level (get_prev_frame (fi))); 1107 else 1108 { 1109 printf_filtered (" called by frame at "); 1110 fputs_filtered (paddress (gdbarch, get_frame_base (calling_frame_info)), 1111 gdb_stdout); 1112 } 1113 if (get_next_frame (fi) && calling_frame_info) 1114 puts_filtered (","); 1115 wrap_here (" "); 1116 if (get_next_frame (fi)) 1117 { 1118 printf_filtered (" caller of frame at "); 1119 fputs_filtered (paddress (gdbarch, get_frame_base (get_next_frame (fi))), 1120 gdb_stdout); 1121 } 1122 if (get_next_frame (fi) || calling_frame_info) 1123 puts_filtered ("\n"); 1124 1125 if (s) 1126 printf_filtered (" source language %s.\n", 1127 language_str (s->language)); 1128 1129 { 1130 /* Address of the argument list for this frame, or 0. */ 1131 CORE_ADDR arg_list = get_frame_args_address (fi); 1132 /* Number of args for this frame, or -1 if unknown. */ 1133 int numargs; 1134 1135 if (arg_list == 0) 1136 printf_filtered (" Arglist at unknown address.\n"); 1137 else 1138 { 1139 printf_filtered (" Arglist at "); 1140 fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout); 1141 printf_filtered (","); 1142 1143 if (!gdbarch_frame_num_args_p (gdbarch)) 1144 { 1145 numargs = -1; 1146 puts_filtered (" args: "); 1147 } 1148 else 1149 { 1150 numargs = gdbarch_frame_num_args (gdbarch, fi); 1151 gdb_assert (numargs >= 0); 1152 if (numargs == 0) 1153 puts_filtered (" no args."); 1154 else if (numargs == 1) 1155 puts_filtered (" 1 arg: "); 1156 else 1157 printf_filtered (" %d args: ", numargs); 1158 } 1159 print_frame_args (func, fi, numargs, gdb_stdout); 1160 puts_filtered ("\n"); 1161 } 1162 } 1163 { 1164 /* Address of the local variables for this frame, or 0. */ 1165 CORE_ADDR arg_list = get_frame_locals_address (fi); 1166 1167 if (arg_list == 0) 1168 printf_filtered (" Locals at unknown address,"); 1169 else 1170 { 1171 printf_filtered (" Locals at "); 1172 fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout); 1173 printf_filtered (","); 1174 } 1175 } 1176 1177 /* Print as much information as possible on the location of all the 1178 registers. */ 1179 { 1180 enum lval_type lval; 1181 int optimized; 1182 CORE_ADDR addr; 1183 int realnum; 1184 int count; 1185 int i; 1186 int need_nl = 1; 1187 1188 /* The sp is special; what's displayed isn't the save address, but 1189 the value of the previous frame's sp. This is a legacy thing, 1190 at one stage the frame cached the previous frame's SP instead 1191 of its address, hence it was easiest to just display the cached 1192 value. */ 1193 if (gdbarch_sp_regnum (gdbarch) >= 0) 1194 { 1195 /* Find out the location of the saved stack pointer with out 1196 actually evaluating it. */ 1197 frame_register_unwind (fi, gdbarch_sp_regnum (gdbarch), 1198 &optimized, &lval, &addr, 1199 &realnum, NULL); 1200 if (!optimized && lval == not_lval) 1201 { 1202 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 1203 int sp_size = register_size (gdbarch, gdbarch_sp_regnum (gdbarch)); 1204 gdb_byte value[MAX_REGISTER_SIZE]; 1205 CORE_ADDR sp; 1206 1207 frame_register_unwind (fi, gdbarch_sp_regnum (gdbarch), 1208 &optimized, &lval, &addr, 1209 &realnum, value); 1210 /* NOTE: cagney/2003-05-22: This is assuming that the 1211 stack pointer was packed as an unsigned integer. That 1212 may or may not be valid. */ 1213 sp = extract_unsigned_integer (value, sp_size, byte_order); 1214 printf_filtered (" Previous frame's sp is "); 1215 fputs_filtered (paddress (gdbarch, sp), gdb_stdout); 1216 printf_filtered ("\n"); 1217 need_nl = 0; 1218 } 1219 else if (!optimized && lval == lval_memory) 1220 { 1221 printf_filtered (" Previous frame's sp at "); 1222 fputs_filtered (paddress (gdbarch, addr), gdb_stdout); 1223 printf_filtered ("\n"); 1224 need_nl = 0; 1225 } 1226 else if (!optimized && lval == lval_register) 1227 { 1228 printf_filtered (" Previous frame's sp in %s\n", 1229 gdbarch_register_name (gdbarch, realnum)); 1230 need_nl = 0; 1231 } 1232 /* else keep quiet. */ 1233 } 1234 1235 count = 0; 1236 numregs = gdbarch_num_regs (gdbarch) 1237 + gdbarch_num_pseudo_regs (gdbarch); 1238 for (i = 0; i < numregs; i++) 1239 if (i != gdbarch_sp_regnum (gdbarch) 1240 && gdbarch_register_reggroup_p (gdbarch, i, all_reggroup)) 1241 { 1242 /* Find out the location of the saved register without 1243 fetching the corresponding value. */ 1244 frame_register_unwind (fi, i, &optimized, &lval, &addr, &realnum, 1245 NULL); 1246 /* For moment, only display registers that were saved on the 1247 stack. */ 1248 if (!optimized && lval == lval_memory) 1249 { 1250 if (count == 0) 1251 puts_filtered (" Saved registers:\n "); 1252 else 1253 puts_filtered (","); 1254 wrap_here (" "); 1255 printf_filtered (" %s at ", 1256 gdbarch_register_name (gdbarch, i)); 1257 fputs_filtered (paddress (gdbarch, addr), gdb_stdout); 1258 count++; 1259 } 1260 } 1261 if (count || need_nl) 1262 puts_filtered ("\n"); 1263 } 1264 1265 do_cleanups (back_to); 1266 } 1267 1268 /* Print briefly all stack frames or just the innermost COUNT_EXP 1269 frames. */ 1270 1271 static void 1272 backtrace_command_1 (char *count_exp, int show_locals, int from_tty) 1273 { 1274 struct frame_info *fi; 1275 int count; 1276 int i; 1277 struct frame_info *trailing; 1278 int trailing_level; 1279 1280 if (!target_has_stack) 1281 error (_("No stack.")); 1282 1283 /* The following code must do two things. First, it must set the 1284 variable TRAILING to the frame from which we should start 1285 printing. Second, it must set the variable count to the number 1286 of frames which we should print, or -1 if all of them. */ 1287 trailing = get_current_frame (); 1288 1289 trailing_level = 0; 1290 if (count_exp) 1291 { 1292 count = parse_and_eval_long (count_exp); 1293 if (count < 0) 1294 { 1295 struct frame_info *current; 1296 1297 count = -count; 1298 1299 current = trailing; 1300 while (current && count--) 1301 { 1302 QUIT; 1303 current = get_prev_frame (current); 1304 } 1305 1306 /* Will stop when CURRENT reaches the top of the stack. 1307 TRAILING will be COUNT below it. */ 1308 while (current) 1309 { 1310 QUIT; 1311 trailing = get_prev_frame (trailing); 1312 current = get_prev_frame (current); 1313 trailing_level++; 1314 } 1315 1316 count = -1; 1317 } 1318 } 1319 else 1320 count = -1; 1321 1322 if (info_verbose) 1323 { 1324 /* Read in symbols for all of the frames. Need to do this in a 1325 separate pass so that "Reading in symbols for xxx" messages 1326 don't screw up the appearance of the backtrace. Also if 1327 people have strong opinions against reading symbols for 1328 backtrace this may have to be an option. */ 1329 i = count; 1330 for (fi = trailing; fi != NULL && i--; fi = get_prev_frame (fi)) 1331 { 1332 CORE_ADDR pc; 1333 1334 QUIT; 1335 pc = get_frame_address_in_block (fi); 1336 find_pc_sect_symtab_via_partial (pc, find_pc_mapped_section (pc)); 1337 } 1338 } 1339 1340 for (i = 0, fi = trailing; fi && count--; i++, fi = get_prev_frame (fi)) 1341 { 1342 QUIT; 1343 1344 /* Don't use print_stack_frame; if an error() occurs it probably 1345 means further attempts to backtrace would fail (on the other 1346 hand, perhaps the code does or could be fixed to make sure 1347 the frame->prev field gets set to NULL in that case). */ 1348 print_frame_info (fi, 1, LOCATION, 1); 1349 if (show_locals) 1350 print_frame_local_vars (fi, 1, gdb_stdout); 1351 1352 /* Save the last frame to check for error conditions. */ 1353 trailing = fi; 1354 } 1355 1356 /* If we've stopped before the end, mention that. */ 1357 if (fi && from_tty) 1358 printf_filtered (_("(More stack frames follow...)\n")); 1359 1360 /* If we've run out of frames, and the reason appears to be an error 1361 condition, print it. */ 1362 if (fi == NULL && trailing != NULL) 1363 { 1364 enum unwind_stop_reason reason; 1365 1366 reason = get_frame_unwind_stop_reason (trailing); 1367 if (reason > UNWIND_FIRST_ERROR) 1368 printf_filtered (_("Backtrace stopped: %s\n"), 1369 frame_stop_reason_string (reason)); 1370 } 1371 } 1372 1373 struct backtrace_command_args 1374 { 1375 char *count_exp; 1376 int show_locals; 1377 int from_tty; 1378 }; 1379 1380 /* Stub for catch_errors. */ 1381 1382 static int 1383 backtrace_command_stub (void *data) 1384 { 1385 struct backtrace_command_args *args = data; 1386 1387 backtrace_command_1 (args->count_exp, args->show_locals, args->from_tty); 1388 return 0; 1389 } 1390 1391 static void 1392 backtrace_command (char *arg, int from_tty) 1393 { 1394 struct cleanup *old_chain = NULL; 1395 int fulltrace_arg = -1, arglen = 0, argc = 0; 1396 struct backtrace_command_args btargs; 1397 1398 if (arg) 1399 { 1400 char **argv; 1401 int i; 1402 1403 argv = gdb_buildargv (arg); 1404 old_chain = make_cleanup_freeargv (argv); 1405 argc = 0; 1406 for (i = 0; argv[i]; i++) 1407 { 1408 unsigned int j; 1409 1410 for (j = 0; j < strlen (argv[i]); j++) 1411 argv[i][j] = tolower (argv[i][j]); 1412 1413 if (fulltrace_arg < 0 && subset_compare (argv[i], "full")) 1414 fulltrace_arg = argc; 1415 else 1416 { 1417 arglen += strlen (argv[i]); 1418 argc++; 1419 } 1420 } 1421 arglen += argc; 1422 if (fulltrace_arg >= 0) 1423 { 1424 if (arglen > 0) 1425 { 1426 arg = xmalloc (arglen + 1); 1427 memset (arg, 0, arglen + 1); 1428 for (i = 0; i < (argc + 1); i++) 1429 { 1430 if (i != fulltrace_arg) 1431 { 1432 strcat (arg, argv[i]); 1433 strcat (arg, " "); 1434 } 1435 } 1436 } 1437 else 1438 arg = NULL; 1439 } 1440 } 1441 1442 btargs.count_exp = arg; 1443 btargs.show_locals = (fulltrace_arg >= 0); 1444 btargs.from_tty = from_tty; 1445 catch_errors (backtrace_command_stub, &btargs, "", RETURN_MASK_ERROR); 1446 1447 if (fulltrace_arg >= 0 && arglen > 0) 1448 xfree (arg); 1449 1450 if (old_chain) 1451 do_cleanups (old_chain); 1452 } 1453 1454 static void 1455 backtrace_full_command (char *arg, int from_tty) 1456 { 1457 struct backtrace_command_args btargs; 1458 1459 btargs.count_exp = arg; 1460 btargs.show_locals = 1; 1461 btargs.from_tty = from_tty; 1462 catch_errors (backtrace_command_stub, &btargs, "", RETURN_MASK_ERROR); 1463 } 1464 1465 1466 /* Iterate over the local variables of a block B, calling CB with 1467 CB_DATA. */ 1468 1469 static void 1470 iterate_over_block_locals (struct block *b, 1471 iterate_over_block_arg_local_vars_cb cb, 1472 void *cb_data) 1473 { 1474 struct dict_iterator iter; 1475 struct symbol *sym; 1476 1477 ALL_BLOCK_SYMBOLS (b, iter, sym) 1478 { 1479 switch (SYMBOL_CLASS (sym)) 1480 { 1481 case LOC_LOCAL: 1482 case LOC_REGISTER: 1483 case LOC_STATIC: 1484 case LOC_COMPUTED: 1485 if (SYMBOL_IS_ARGUMENT (sym)) 1486 break; 1487 (*cb) (SYMBOL_PRINT_NAME (sym), sym, cb_data); 1488 break; 1489 1490 default: 1491 /* Ignore symbols which are not locals. */ 1492 break; 1493 } 1494 } 1495 } 1496 1497 1498 /* Same, but print labels. */ 1499 1500 #if 0 1501 /* Commented out, as the code using this function has also been 1502 commented out. FIXME:brobecker/2009-01-13: Find out why the code 1503 was commented out in the first place. The discussion introducing 1504 this change (2007-12-04: Support lexical blocks and function bodies 1505 that occupy non-contiguous address ranges) did not explain why 1506 this change was made. */ 1507 static int 1508 print_block_frame_labels (struct gdbarch *gdbarch, struct block *b, 1509 int *have_default, struct ui_file *stream) 1510 { 1511 struct dict_iterator iter; 1512 struct symbol *sym; 1513 int values_printed = 0; 1514 1515 ALL_BLOCK_SYMBOLS (b, iter, sym) 1516 { 1517 if (strcmp (SYMBOL_LINKAGE_NAME (sym), "default") == 0) 1518 { 1519 if (*have_default) 1520 continue; 1521 *have_default = 1; 1522 } 1523 if (SYMBOL_CLASS (sym) == LOC_LABEL) 1524 { 1525 struct symtab_and_line sal; 1526 struct value_print_options opts; 1527 1528 sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0); 1529 values_printed = 1; 1530 fputs_filtered (SYMBOL_PRINT_NAME (sym), stream); 1531 get_user_print_options (&opts); 1532 if (opts.addressprint) 1533 { 1534 fprintf_filtered (stream, " "); 1535 fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (sym)), 1536 stream); 1537 } 1538 fprintf_filtered (stream, " in file %s, line %d\n", 1539 sal.symtab->filename, sal.line); 1540 } 1541 } 1542 1543 return values_printed; 1544 } 1545 #endif 1546 1547 /* Iterate over all the local variables in block B, including all its 1548 superblocks, stopping when the top-level block is reached. */ 1549 1550 void 1551 iterate_over_block_local_vars (struct block *block, 1552 iterate_over_block_arg_local_vars_cb cb, 1553 void *cb_data) 1554 { 1555 while (block) 1556 { 1557 iterate_over_block_locals (block, cb, cb_data); 1558 /* After handling the function's top-level block, stop. Don't 1559 continue to its superblock, the block of per-file 1560 symbols. */ 1561 if (BLOCK_FUNCTION (block)) 1562 break; 1563 block = BLOCK_SUPERBLOCK (block); 1564 } 1565 } 1566 1567 /* Data to be passed around in the calls to the locals and args 1568 iterators. */ 1569 1570 struct print_variable_and_value_data 1571 { 1572 struct frame_info *frame; 1573 int num_tabs; 1574 struct ui_file *stream; 1575 int values_printed; 1576 }; 1577 1578 /* The callback for the locals and args iterators */ 1579 1580 static void 1581 do_print_variable_and_value (const char *print_name, 1582 struct symbol *sym, 1583 void *cb_data) 1584 { 1585 struct print_variable_and_value_data *p = cb_data; 1586 1587 print_variable_and_value (print_name, sym, 1588 p->frame, p->stream, p->num_tabs); 1589 p->values_printed = 1; 1590 } 1591 1592 static void 1593 print_frame_local_vars (struct frame_info *frame, int num_tabs, 1594 struct ui_file *stream) 1595 { 1596 struct print_variable_and_value_data cb_data; 1597 struct block *block; 1598 1599 block = get_frame_block (frame, 0); 1600 if (block == 0) 1601 { 1602 fprintf_filtered (stream, "No symbol table info available.\n"); 1603 return; 1604 } 1605 1606 cb_data.frame = frame; 1607 cb_data.num_tabs = 4 * num_tabs; 1608 cb_data.stream = stream; 1609 cb_data.values_printed = 0; 1610 1611 iterate_over_block_local_vars (block, 1612 do_print_variable_and_value, 1613 &cb_data); 1614 1615 if (!cb_data.values_printed) 1616 fprintf_filtered (stream, _("No locals.\n")); 1617 } 1618 1619 /* Same, but print labels. */ 1620 1621 static void 1622 print_frame_label_vars (struct frame_info *frame, int this_level_only, 1623 struct ui_file *stream) 1624 { 1625 #if 1 1626 fprintf_filtered (stream, "print_frame_label_vars disabled.\n"); 1627 #else 1628 struct blockvector *bl; 1629 struct block *block = get_frame_block (frame, 0); 1630 struct gdbarch *gdbarch = get_frame_arch (frame); 1631 int values_printed = 0; 1632 int index, have_default = 0; 1633 char *blocks_printed; 1634 CORE_ADDR pc = get_frame_pc (frame); 1635 1636 if (block == 0) 1637 { 1638 fprintf_filtered (stream, "No symbol table info available.\n"); 1639 return; 1640 } 1641 1642 bl = blockvector_for_pc (BLOCK_END (block) - 4, &index); 1643 blocks_printed = alloca (BLOCKVECTOR_NBLOCKS (bl) * sizeof (char)); 1644 memset (blocks_printed, 0, BLOCKVECTOR_NBLOCKS (bl) * sizeof (char)); 1645 1646 while (block != 0) 1647 { 1648 CORE_ADDR end = BLOCK_END (block) - 4; 1649 int last_index; 1650 1651 if (bl != blockvector_for_pc (end, &index)) 1652 error (_("blockvector blotch")); 1653 if (BLOCKVECTOR_BLOCK (bl, index) != block) 1654 error (_("blockvector botch")); 1655 last_index = BLOCKVECTOR_NBLOCKS (bl); 1656 index += 1; 1657 1658 /* Don't print out blocks that have gone by. */ 1659 while (index < last_index 1660 && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < pc) 1661 index++; 1662 1663 while (index < last_index 1664 && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < end) 1665 { 1666 if (blocks_printed[index] == 0) 1667 { 1668 if (print_block_frame_labels (gdbarch, 1669 BLOCKVECTOR_BLOCK (bl, index), 1670 &have_default, stream)) 1671 values_printed = 1; 1672 blocks_printed[index] = 1; 1673 } 1674 index++; 1675 } 1676 if (have_default) 1677 return; 1678 if (values_printed && this_level_only) 1679 return; 1680 1681 /* After handling the function's top-level block, stop. Don't 1682 continue to its superblock, the block of per-file symbols. 1683 Also do not continue to the containing function of an inlined 1684 function. */ 1685 if (BLOCK_FUNCTION (block)) 1686 break; 1687 block = BLOCK_SUPERBLOCK (block); 1688 } 1689 1690 if (!values_printed && !this_level_only) 1691 fprintf_filtered (stream, _("No catches.\n")); 1692 #endif 1693 } 1694 1695 void 1696 locals_info (char *args, int from_tty) 1697 { 1698 print_frame_local_vars (get_selected_frame (_("No frame selected.")), 1699 0, gdb_stdout); 1700 } 1701 1702 static void 1703 catch_info (char *ignore, int from_tty) 1704 { 1705 /* Assume g++ compiled code; old GDB 4.16 behaviour. */ 1706 print_frame_label_vars (get_selected_frame (_("No frame selected.")), 1707 0, gdb_stdout); 1708 } 1709 1710 /* Iterate over all the argument variables in block B. 1711 1712 Returns 1 if any argument was walked; 0 otherwise. */ 1713 1714 void 1715 iterate_over_block_arg_vars (struct block *b, 1716 iterate_over_block_arg_local_vars_cb cb, 1717 void *cb_data) 1718 { 1719 struct dict_iterator iter; 1720 struct symbol *sym, *sym2; 1721 1722 ALL_BLOCK_SYMBOLS (b, iter, sym) 1723 { 1724 /* Don't worry about things which aren't arguments. */ 1725 if (SYMBOL_IS_ARGUMENT (sym)) 1726 { 1727 /* We have to look up the symbol because arguments can have 1728 two entries (one a parameter, one a local) and the one we 1729 want is the local, which lookup_symbol will find for us. 1730 This includes gcc1 (not gcc2) on the sparc when passing a 1731 small structure and gcc2 when the argument type is float 1732 and it is passed as a double and converted to float by 1733 the prologue (in the latter case the type of the LOC_ARG 1734 symbol is double and the type of the LOC_LOCAL symbol is 1735 float). There are also LOC_ARG/LOC_REGISTER pairs which 1736 are not combined in symbol-reading. */ 1737 1738 sym2 = lookup_symbol (SYMBOL_LINKAGE_NAME (sym), 1739 b, VAR_DOMAIN, NULL); 1740 (*cb) (SYMBOL_PRINT_NAME (sym), sym2, cb_data); 1741 } 1742 } 1743 } 1744 1745 static void 1746 print_frame_arg_vars (struct frame_info *frame, struct ui_file *stream) 1747 { 1748 struct print_variable_and_value_data cb_data; 1749 struct symbol *func; 1750 1751 func = get_frame_function (frame); 1752 if (func == NULL) 1753 { 1754 fprintf_filtered (stream, _("No symbol table info available.\n")); 1755 return; 1756 } 1757 1758 cb_data.frame = frame; 1759 cb_data.num_tabs = 0; 1760 cb_data.stream = gdb_stdout; 1761 cb_data.values_printed = 0; 1762 1763 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func), 1764 do_print_variable_and_value, &cb_data); 1765 1766 if (!cb_data.values_printed) 1767 fprintf_filtered (stream, _("No arguments.\n")); 1768 } 1769 1770 void 1771 args_info (char *ignore, int from_tty) 1772 { 1773 print_frame_arg_vars (get_selected_frame (_("No frame selected.")), 1774 gdb_stdout); 1775 } 1776 1777 1778 static void 1779 args_plus_locals_info (char *ignore, int from_tty) 1780 { 1781 args_info (ignore, from_tty); 1782 locals_info (ignore, from_tty); 1783 } 1784 1785 1786 /* Select frame FRAME. Also print the stack frame and show the source 1787 if this is the tui version. */ 1788 static void 1789 select_and_print_frame (struct frame_info *frame) 1790 { 1791 select_frame (frame); 1792 if (frame) 1793 print_stack_frame (frame, 1, SRC_AND_LOC); 1794 } 1795 1796 /* Return the symbol-block in which the selected frame is executing. 1797 Can return zero under various legitimate circumstances. 1798 1799 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant 1800 code address within the block returned. We use this to decide 1801 which macros are in scope. */ 1802 1803 struct block * 1804 get_selected_block (CORE_ADDR *addr_in_block) 1805 { 1806 if (!has_stack_frames ()) 1807 return 0; 1808 1809 return get_frame_block (get_selected_frame (NULL), addr_in_block); 1810 } 1811 1812 /* Find a frame a certain number of levels away from FRAME. 1813 LEVEL_OFFSET_PTR points to an int containing the number of levels. 1814 Positive means go to earlier frames (up); negative, the reverse. 1815 The int that contains the number of levels is counted toward 1816 zero as the frames for those levels are found. 1817 If the top or bottom frame is reached, that frame is returned, 1818 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates 1819 how much farther the original request asked to go. */ 1820 1821 struct frame_info * 1822 find_relative_frame (struct frame_info *frame, int *level_offset_ptr) 1823 { 1824 /* Going up is simple: just call get_prev_frame enough times or 1825 until the initial frame is reached. */ 1826 while (*level_offset_ptr > 0) 1827 { 1828 struct frame_info *prev = get_prev_frame (frame); 1829 1830 if (!prev) 1831 break; 1832 (*level_offset_ptr)--; 1833 frame = prev; 1834 } 1835 1836 /* Going down is just as simple. */ 1837 while (*level_offset_ptr < 0) 1838 { 1839 struct frame_info *next = get_next_frame (frame); 1840 1841 if (!next) 1842 break; 1843 (*level_offset_ptr)++; 1844 frame = next; 1845 } 1846 1847 return frame; 1848 } 1849 1850 /* The "select_frame" command. With no argument this is a NOP. 1851 Select the frame at level LEVEL_EXP if it is a valid level. 1852 Otherwise, treat LEVEL_EXP as an address expression and select it. 1853 1854 See parse_frame_specification for more info on proper frame 1855 expressions. */ 1856 1857 void 1858 select_frame_command (char *level_exp, int from_tty) 1859 { 1860 select_frame (parse_frame_specification_1 (level_exp, "No stack.", NULL)); 1861 } 1862 1863 /* The "frame" command. With no argument, print the selected frame 1864 briefly. With an argument, behave like select_frame and then print 1865 the selected frame. */ 1866 1867 static void 1868 frame_command (char *level_exp, int from_tty) 1869 { 1870 select_frame_command (level_exp, from_tty); 1871 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC); 1872 } 1873 1874 /* The XDB Compatibility command to print the current frame. */ 1875 1876 static void 1877 current_frame_command (char *level_exp, int from_tty) 1878 { 1879 print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC); 1880 } 1881 1882 /* Select the frame up one or COUNT_EXP stack levels from the 1883 previously selected frame, and print it briefly. */ 1884 1885 static void 1886 up_silently_base (char *count_exp) 1887 { 1888 struct frame_info *frame; 1889 int count = 1; 1890 1891 if (count_exp) 1892 count = parse_and_eval_long (count_exp); 1893 1894 frame = find_relative_frame (get_selected_frame ("No stack."), &count); 1895 if (count != 0 && count_exp == NULL) 1896 error (_("Initial frame selected; you cannot go up.")); 1897 select_frame (frame); 1898 } 1899 1900 static void 1901 up_silently_command (char *count_exp, int from_tty) 1902 { 1903 up_silently_base (count_exp); 1904 } 1905 1906 static void 1907 up_command (char *count_exp, int from_tty) 1908 { 1909 up_silently_base (count_exp); 1910 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC); 1911 } 1912 1913 /* Select the frame down one or COUNT_EXP stack levels from the previously 1914 selected frame, and print it briefly. */ 1915 1916 static void 1917 down_silently_base (char *count_exp) 1918 { 1919 struct frame_info *frame; 1920 int count = -1; 1921 1922 if (count_exp) 1923 count = -parse_and_eval_long (count_exp); 1924 1925 frame = find_relative_frame (get_selected_frame ("No stack."), &count); 1926 if (count != 0 && count_exp == NULL) 1927 { 1928 /* We only do this if COUNT_EXP is not specified. That way 1929 "down" means to really go down (and let me know if that is 1930 impossible), but "down 9999" can be used to mean go all the 1931 way down without getting an error. */ 1932 1933 error (_("Bottom (innermost) frame selected; you cannot go down.")); 1934 } 1935 1936 select_frame (frame); 1937 } 1938 1939 static void 1940 down_silently_command (char *count_exp, int from_tty) 1941 { 1942 down_silently_base (count_exp); 1943 } 1944 1945 static void 1946 down_command (char *count_exp, int from_tty) 1947 { 1948 down_silently_base (count_exp); 1949 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC); 1950 } 1951 1952 1953 void 1954 return_command (char *retval_exp, int from_tty) 1955 { 1956 struct frame_info *thisframe; 1957 struct gdbarch *gdbarch; 1958 struct symbol *thisfun; 1959 struct value *return_value = NULL; 1960 const char *query_prefix = ""; 1961 1962 thisframe = get_selected_frame ("No selected frame."); 1963 thisfun = get_frame_function (thisframe); 1964 gdbarch = get_frame_arch (thisframe); 1965 1966 if (get_frame_type (get_current_frame ()) == INLINE_FRAME) 1967 error (_("Can not force return from an inlined function.")); 1968 1969 /* Compute the return value. If the computation triggers an error, 1970 let it bail. If the return type can't be handled, set 1971 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational 1972 message. */ 1973 if (retval_exp) 1974 { 1975 struct expression *retval_expr = parse_expression (retval_exp); 1976 struct cleanup *old_chain = make_cleanup (xfree, retval_expr); 1977 struct type *return_type = NULL; 1978 1979 /* Compute the return value. Should the computation fail, this 1980 call throws an error. */ 1981 return_value = evaluate_expression (retval_expr); 1982 1983 /* Cast return value to the return type of the function. Should 1984 the cast fail, this call throws an error. */ 1985 if (thisfun != NULL) 1986 return_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun)); 1987 if (return_type == NULL) 1988 { 1989 if (retval_expr->elts[0].opcode != UNOP_CAST) 1990 error (_("Return value type not available for selected " 1991 "stack frame.\n" 1992 "Please use an explicit cast of the value to return.")); 1993 return_type = value_type (return_value); 1994 } 1995 do_cleanups (old_chain); 1996 CHECK_TYPEDEF (return_type); 1997 return_value = value_cast (return_type, return_value); 1998 1999 /* Make sure the value is fully evaluated. It may live in the 2000 stack frame we're about to pop. */ 2001 if (value_lazy (return_value)) 2002 value_fetch_lazy (return_value); 2003 2004 if (TYPE_CODE (return_type) == TYPE_CODE_VOID) 2005 /* If the return-type is "void", don't try to find the 2006 return-value's location. However, do still evaluate the 2007 return expression so that, even when the expression result 2008 is discarded, side effects such as "return i++" still 2009 occur. */ 2010 return_value = NULL; 2011 else if (thisfun != NULL 2012 && using_struct_return (gdbarch, 2013 SYMBOL_TYPE (thisfun), return_type)) 2014 { 2015 query_prefix = "\ 2016 The location at which to store the function's return value is unknown.\n\ 2017 If you continue, the return value that you specified will be ignored.\n"; 2018 return_value = NULL; 2019 } 2020 } 2021 2022 /* Does an interactive user really want to do this? Include 2023 information, such as how well GDB can handle the return value, in 2024 the query message. */ 2025 if (from_tty) 2026 { 2027 int confirmed; 2028 2029 if (thisfun == NULL) 2030 confirmed = query (_("%sMake selected stack frame return now? "), 2031 query_prefix); 2032 else 2033 confirmed = query (_("%sMake %s return now? "), query_prefix, 2034 SYMBOL_PRINT_NAME (thisfun)); 2035 if (!confirmed) 2036 error (_("Not confirmed")); 2037 } 2038 2039 /* Discard the selected frame and all frames inner-to it. */ 2040 frame_pop (get_selected_frame (NULL)); 2041 2042 /* Store RETURN_VALUE in the just-returned register set. */ 2043 if (return_value != NULL) 2044 { 2045 struct type *return_type = value_type (return_value); 2046 struct gdbarch *gdbarch = get_regcache_arch (get_current_regcache ()); 2047 struct type *func_type = thisfun == NULL ? NULL : SYMBOL_TYPE (thisfun); 2048 2049 gdb_assert (gdbarch_return_value (gdbarch, func_type, return_type, NULL, 2050 NULL, NULL) 2051 == RETURN_VALUE_REGISTER_CONVENTION); 2052 gdbarch_return_value (gdbarch, func_type, return_type, 2053 get_current_regcache (), NULL /*read*/, 2054 value_contents (return_value) /*write*/); 2055 } 2056 2057 /* If we are at the end of a call dummy now, pop the dummy frame 2058 too. */ 2059 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME) 2060 frame_pop (get_current_frame ()); 2061 2062 /* If interactive, print the frame that is now current. */ 2063 if (from_tty) 2064 frame_command ("0", 1); 2065 else 2066 select_frame_command ("0", 0); 2067 } 2068 2069 /* Sets the scope to input function name, provided that the function 2070 is within the current stack frame */ 2071 2072 struct function_bounds 2073 { 2074 CORE_ADDR low, high; 2075 }; 2076 2077 static void 2078 func_command (char *arg, int from_tty) 2079 { 2080 struct frame_info *frame; 2081 int found = 0; 2082 struct symtabs_and_lines sals; 2083 int i; 2084 int level = 1; 2085 struct function_bounds *func_bounds = NULL; 2086 2087 if (arg != NULL) 2088 return; 2089 2090 frame = parse_frame_specification ("0"); 2091 sals = decode_line_spec (arg, 1); 2092 func_bounds = (struct function_bounds *) xmalloc ( 2093 sizeof (struct function_bounds) * sals.nelts); 2094 for (i = 0; (i < sals.nelts && !found); i++) 2095 { 2096 if (sals.sals[i].pc == 0 2097 || find_pc_partial_function (sals.sals[i].pc, NULL, 2098 &func_bounds[i].low, 2099 &func_bounds[i].high) == 0) 2100 { 2101 func_bounds[i].low = func_bounds[i].high = 0; 2102 } 2103 } 2104 2105 do 2106 { 2107 for (i = 0; (i < sals.nelts && !found); i++) 2108 found = (get_frame_pc (frame) >= func_bounds[i].low 2109 && get_frame_pc (frame) < func_bounds[i].high); 2110 if (!found) 2111 { 2112 level = 1; 2113 frame = find_relative_frame (frame, &level); 2114 } 2115 } 2116 while (!found && level == 0); 2117 2118 if (func_bounds) 2119 xfree (func_bounds); 2120 2121 if (!found) 2122 printf_filtered (_("'%s' not within current stack frame.\n"), arg); 2123 else if (frame != get_selected_frame (NULL)) 2124 select_and_print_frame (frame); 2125 } 2126 2127 /* Gets the language of the current frame. */ 2128 2129 enum language 2130 get_frame_language (void) 2131 { 2132 struct frame_info *frame = deprecated_safe_get_selected_frame (); 2133 2134 if (frame) 2135 { 2136 /* We determine the current frame language by looking up its 2137 associated symtab. To retrieve this symtab, we use the frame 2138 PC. However we cannot use the frame PC as is, because it 2139 usually points to the instruction following the "call", which 2140 is sometimes the first instruction of another function. So 2141 we rely on get_frame_address_in_block(), it provides us with 2142 a PC that is guaranteed to be inside the frame's code 2143 block. */ 2144 CORE_ADDR pc = get_frame_address_in_block (frame); 2145 struct symtab *s = find_pc_symtab (pc); 2146 2147 if (s) 2148 return s->language; 2149 } 2150 2151 return language_unknown; 2152 } 2153 2154 2155 /* Provide a prototype to silence -Wmissing-prototypes. */ 2156 void _initialize_stack (void); 2157 2158 void 2159 _initialize_stack (void) 2160 { 2161 add_com ("return", class_stack, return_command, _("\ 2162 Make selected stack frame return to its caller.\n\ 2163 Control remains in the debugger, but when you continue\n\ 2164 execution will resume in the frame above the one now selected.\n\ 2165 If an argument is given, it is an expression for the value to return.")); 2166 2167 add_com ("up", class_stack, up_command, _("\ 2168 Select and print stack frame that called this one.\n\ 2169 An argument says how many frames up to go.")); 2170 add_com ("up-silently", class_support, up_silently_command, _("\ 2171 Same as the `up' command, but does not print anything.\n\ 2172 This is useful in command scripts.")); 2173 2174 add_com ("down", class_stack, down_command, _("\ 2175 Select and print stack frame called by this one.\n\ 2176 An argument says how many frames down to go.")); 2177 add_com_alias ("do", "down", class_stack, 1); 2178 add_com_alias ("dow", "down", class_stack, 1); 2179 add_com ("down-silently", class_support, down_silently_command, _("\ 2180 Same as the `down' command, but does not print anything.\n\ 2181 This is useful in command scripts.")); 2182 2183 add_com ("frame", class_stack, frame_command, _("\ 2184 Select and print a stack frame.\n\ 2185 With no argument, print the selected stack frame. (See also \"info frame\").\n\ 2186 An argument specifies the frame to select.\n\ 2187 It can be a stack frame number or the address of the frame.\n\ 2188 With argument, nothing is printed if input is coming from\n\ 2189 a command file or a user-defined command.")); 2190 2191 add_com_alias ("f", "frame", class_stack, 1); 2192 2193 if (xdb_commands) 2194 { 2195 add_com ("L", class_stack, current_frame_command, 2196 _("Print the current stack frame.\n")); 2197 add_com_alias ("V", "frame", class_stack, 1); 2198 } 2199 add_com ("select-frame", class_stack, select_frame_command, _("\ 2200 Select a stack frame without printing anything.\n\ 2201 An argument specifies the frame to select.\n\ 2202 It can be a stack frame number or the address of the frame.\n")); 2203 2204 add_com ("backtrace", class_stack, backtrace_command, _("\ 2205 Print backtrace of all stack frames, or innermost COUNT frames.\n\ 2206 With a negative argument, print outermost -COUNT frames.\n\ 2207 Use of the 'full' qualifier also prints the values of the local variables.\n")); 2208 add_com_alias ("bt", "backtrace", class_stack, 0); 2209 if (xdb_commands) 2210 { 2211 add_com_alias ("t", "backtrace", class_stack, 0); 2212 add_com ("T", class_stack, backtrace_full_command, _("\ 2213 Print backtrace of all stack frames, or innermost COUNT frames\n\ 2214 and the values of the local variables.\n\ 2215 With a negative argument, print outermost -COUNT frames.\n\ 2216 Usage: T <count>\n")); 2217 } 2218 2219 add_com_alias ("where", "backtrace", class_alias, 0); 2220 add_info ("stack", backtrace_command, 2221 _("Backtrace of the stack, or innermost COUNT frames.")); 2222 add_info_alias ("s", "stack", 1); 2223 add_info ("frame", frame_info, 2224 _("All about selected stack frame, or frame at ADDR.")); 2225 add_info_alias ("f", "frame", 1); 2226 add_info ("locals", locals_info, 2227 _("Local variables of current stack frame.")); 2228 add_info ("args", args_info, 2229 _("Argument variables of current stack frame.")); 2230 if (xdb_commands) 2231 add_com ("l", class_info, args_plus_locals_info, 2232 _("Argument and local variables of current stack frame.")); 2233 2234 if (dbx_commands) 2235 add_com ("func", class_stack, func_command, _("\ 2236 Select the stack frame that contains <func>.\n\ 2237 Usage: func <name>\n")); 2238 2239 add_info ("catch", catch_info, 2240 _("Exceptions that can be caught in the current stack frame.")); 2241 2242 add_setshow_enum_cmd ("frame-arguments", class_stack, 2243 print_frame_arguments_choices, &print_frame_arguments, 2244 _("Set printing of non-scalar frame arguments"), 2245 _("Show printing of non-scalar frame arguments"), 2246 NULL, NULL, NULL, &setprintlist, &showprintlist); 2247 2248 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack, 2249 &disassemble_next_line, _("\ 2250 Set whether to disassemble next source line or insn when execution stops."), _("\ 2251 Show whether to disassemble next source line or insn when execution stops."), _("\ 2252 If ON, GDB will display disassembly of the next source line, in addition\n\ 2253 to displaying the source line itself. If the next source line cannot\n\ 2254 be displayed (e.g., source is unavailable or there's no line info), GDB\n\ 2255 will display disassembly of next instruction instead of showing the\n\ 2256 source line.\n\ 2257 If AUTO, display disassembly of next instruction only if the source line\n\ 2258 cannot be displayed.\n\ 2259 If OFF (which is the default), never display the disassembly of the next\n\ 2260 source line."), 2261 NULL, 2262 show_disassemble_next_line, 2263 &setlist, &showlist); 2264 disassemble_next_line = AUTO_BOOLEAN_FALSE; 2265 } 2266