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