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