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