1 /* Print and select stack frames for GDB, the GNU debugger. 2 3 Copyright (C) 1986-2020 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 #include "annotate.h" 51 52 #include "symfile.h" 53 #include "extension.h" 54 #include "observable.h" 55 #include "gdbsupport/def-vector.h" 56 #include "cli/cli-option.h" 57 #include "cli/cli-style.h" 58 59 /* The possible choices of "set print frame-arguments", and the value 60 of this setting. */ 61 62 const char print_frame_arguments_all[] = "all"; 63 const char print_frame_arguments_scalars[] = "scalars"; 64 const char print_frame_arguments_none[] = "none"; 65 const char print_frame_arguments_presence[] = "presence"; 66 67 static const char *const print_frame_arguments_choices[] = 68 { 69 print_frame_arguments_all, 70 print_frame_arguments_scalars, 71 print_frame_arguments_none, 72 print_frame_arguments_presence, 73 NULL 74 }; 75 76 /* The possible choices of "set print frame-info", and the value 77 of this setting. */ 78 79 const char print_frame_info_auto[] = "auto"; 80 const char print_frame_info_source_line[] = "source-line"; 81 const char print_frame_info_location[] = "location"; 82 const char print_frame_info_source_and_location[] = "source-and-location"; 83 const char print_frame_info_location_and_address[] = "location-and-address"; 84 const char print_frame_info_short_location[] = "short-location"; 85 86 static const char *const print_frame_info_choices[] = 87 { 88 print_frame_info_auto, 89 print_frame_info_source_line, 90 print_frame_info_location, 91 print_frame_info_source_and_location, 92 print_frame_info_location_and_address, 93 print_frame_info_short_location, 94 NULL 95 }; 96 97 /* print_frame_info_print_what[i] maps a choice to the corresponding 98 print_what enum. */ 99 static const gdb::optional<enum print_what> print_frame_info_print_what[] = 100 {{}, /* Empty value for "auto". */ 101 SRC_LINE, LOCATION, SRC_AND_LOC, LOC_AND_ADDRESS, SHORT_LOCATION}; 102 103 /* The possible choices of "set print entry-values", and the value 104 of this setting. */ 105 106 const char print_entry_values_no[] = "no"; 107 const char print_entry_values_only[] = "only"; 108 const char print_entry_values_preferred[] = "preferred"; 109 const char print_entry_values_if_needed[] = "if-needed"; 110 const char print_entry_values_both[] = "both"; 111 const char print_entry_values_compact[] = "compact"; 112 const char print_entry_values_default[] = "default"; 113 static const char *const print_entry_values_choices[] = 114 { 115 print_entry_values_no, 116 print_entry_values_only, 117 print_entry_values_preferred, 118 print_entry_values_if_needed, 119 print_entry_values_both, 120 print_entry_values_compact, 121 print_entry_values_default, 122 NULL 123 }; 124 125 /* See frame.h. */ 126 frame_print_options user_frame_print_options; 127 128 /* Option definitions for some frame-related "set print ..." 129 settings. */ 130 131 using boolean_option_def 132 = gdb::option::boolean_option_def<frame_print_options>; 133 using enum_option_def 134 = gdb::option::enum_option_def<frame_print_options>; 135 136 static const gdb::option::option_def frame_print_option_defs[] = { 137 138 enum_option_def { 139 "entry-values", 140 print_entry_values_choices, 141 [] (frame_print_options *opt) { return &opt->print_entry_values; }, 142 NULL, /* show_cmd_cb */ 143 N_("Set printing of function arguments at function entry."), 144 N_("Show printing of function arguments at function entry."), 145 N_("GDB can sometimes determine the values of function arguments at entry,\n\ 146 in addition to their current values. This option tells GDB whether\n\ 147 to print the current value, the value at entry (marked as val@entry),\n\ 148 or both. Note that one or both of these values may be <optimized out>."), 149 }, 150 151 enum_option_def { 152 "frame-arguments", 153 print_frame_arguments_choices, 154 [] (frame_print_options *opt) { return &opt->print_frame_arguments; }, 155 NULL, /* show_cmd_cb */ 156 N_("Set printing of non-scalar frame arguments."), 157 N_("Show printing of non-scalar frame arguments."), 158 NULL /* help_doc */ 159 }, 160 161 boolean_option_def { 162 "raw-frame-arguments", 163 [] (frame_print_options *opt) { return &opt->print_raw_frame_arguments; }, 164 NULL, /* show_cmd_cb */ 165 N_("Set whether to print frame arguments in raw form."), 166 N_("Show whether to print frame arguments in raw form."), 167 N_("If set, frame arguments are printed in raw form, bypassing any\n\ 168 pretty-printers for that value.") 169 }, 170 171 enum_option_def { 172 "frame-info", 173 print_frame_info_choices, 174 [] (frame_print_options *opt) { return &opt->print_frame_info; }, 175 NULL, /* show_cmd_cb */ 176 N_("Set printing of frame information."), 177 N_("Show printing of frame information."), 178 NULL /* help_doc */ 179 } 180 181 }; 182 183 /* Options for the "backtrace" command. */ 184 185 struct backtrace_cmd_options 186 { 187 bool full = false; 188 bool no_filters = false; 189 bool hide = false; 190 }; 191 192 using bt_flag_option_def 193 = gdb::option::flag_option_def<backtrace_cmd_options>; 194 195 static const gdb::option::option_def backtrace_command_option_defs[] = { 196 bt_flag_option_def { 197 "full", 198 [] (backtrace_cmd_options *opt) { return &opt->full; }, 199 N_("Print values of local variables.") 200 }, 201 202 bt_flag_option_def { 203 "no-filters", 204 [] (backtrace_cmd_options *opt) { return &opt->no_filters; }, 205 N_("Prohibit frame filters from executing on a backtrace."), 206 }, 207 208 bt_flag_option_def { 209 "hide", 210 [] (backtrace_cmd_options *opt) { return &opt->hide; }, 211 N_("Causes Python frame filter elided frames to not be printed."), 212 }, 213 }; 214 215 /* Prototypes for local functions. */ 216 217 static void print_frame_local_vars (struct frame_info *frame, 218 bool quiet, 219 const char *regexp, const char *t_regexp, 220 int num_tabs, struct ui_file *stream); 221 222 static void print_frame (const frame_print_options &opts, 223 frame_info *frame, int print_level, 224 enum print_what print_what, int print_args, 225 struct symtab_and_line sal); 226 227 static struct frame_info *find_frame_for_function (const char *); 228 static struct frame_info *find_frame_for_address (CORE_ADDR); 229 230 /* Zero means do things normally; we are interacting directly with the 231 user. One means print the full filename and linenumber when a 232 frame is printed, and do so in a format emacs18/emacs19.22 can 233 parse. Two means print similar annotations, but in many more 234 cases and in a slightly different syntax. */ 235 236 int annotation_level = 0; 237 238 /* Class used to manage tracking the last symtab we displayed. */ 239 240 class last_displayed_symtab_info_type 241 { 242 public: 243 /* True if the cached information is valid. */ 244 bool is_valid () const 245 { return m_valid; } 246 247 /* Return the cached program_space. If the cache is invalid nullptr is 248 returned. */ 249 struct program_space *pspace () const 250 { return m_pspace; } 251 252 /* Return the cached CORE_ADDR address. If the cache is invalid 0 is 253 returned. */ 254 CORE_ADDR address () const 255 { return m_address; } 256 257 /* Return the cached symtab. If the cache is invalid nullptr is 258 returned. */ 259 struct symtab *symtab () const 260 { return m_symtab; } 261 262 /* Return the cached line number. If the cache is invalid 0 is 263 returned. */ 264 int line () const 265 { return m_line; } 266 267 /* Invalidate the cache, reset all the members to their default value. */ 268 void invalidate () 269 { 270 m_valid = false; 271 m_pspace = nullptr; 272 m_address = 0; 273 m_symtab = nullptr; 274 m_line = 0; 275 } 276 277 /* Store a new set of values in the cache. */ 278 void set (struct program_space *pspace, CORE_ADDR address, 279 struct symtab *symtab, int line) 280 { 281 gdb_assert (pspace != nullptr); 282 283 m_valid = true; 284 m_pspace = pspace; 285 m_address = address; 286 m_symtab = symtab; 287 m_line = line; 288 } 289 290 private: 291 /* True when the cache is valid. */ 292 bool m_valid = false; 293 294 /* The last program space displayed. */ 295 struct program_space *m_pspace = nullptr; 296 297 /* The last address displayed. */ 298 CORE_ADDR m_address = 0; 299 300 /* The last symtab displayed. */ 301 struct symtab *m_symtab = nullptr; 302 303 /* The last line number displayed. */ 304 int m_line = 0; 305 }; 306 307 /* An actual instance of the cache, holds information about the last symtab 308 displayed. */ 309 static last_displayed_symtab_info_type last_displayed_symtab_info; 310 311 312 313 /* See stack.h. */ 314 315 bool 316 frame_show_address (struct frame_info *frame, 317 struct symtab_and_line sal) 318 { 319 /* If there is a line number, but no PC, then there is no location 320 information associated with this sal. The only way that should 321 happen is for the call sites of inlined functions (SAL comes from 322 find_frame_sal). Otherwise, we would have some PC range if the 323 SAL came from a line table. */ 324 if (sal.line != 0 && sal.pc == 0 && sal.end == 0) 325 { 326 if (get_next_frame (frame) == NULL) 327 gdb_assert (inline_skipped_frames (inferior_thread ()) > 0); 328 else 329 gdb_assert (get_frame_type (get_next_frame (frame)) == INLINE_FRAME); 330 return false; 331 } 332 333 return get_frame_pc (frame) != sal.pc || !sal.is_stmt; 334 } 335 336 /* See frame.h. */ 337 338 void 339 print_stack_frame_to_uiout (struct ui_out *uiout, struct frame_info *frame, 340 int print_level, enum print_what print_what, 341 int set_current_sal) 342 { 343 scoped_restore save_uiout = make_scoped_restore (¤t_uiout, uiout); 344 345 print_stack_frame (frame, print_level, print_what, set_current_sal); 346 } 347 348 /* Show or print a stack frame FRAME briefly. The output is formatted 349 according to PRINT_LEVEL and PRINT_WHAT printing the frame's 350 relative level, function name, argument list, and file name and 351 line number. If the frame's PC is not at the beginning of the 352 source line, the actual PC is printed at the beginning. */ 353 354 void 355 print_stack_frame (struct frame_info *frame, int print_level, 356 enum print_what print_what, 357 int set_current_sal) 358 { 359 360 /* For mi, always print location and address. */ 361 if (current_uiout->is_mi_like_p ()) 362 print_what = LOC_AND_ADDRESS; 363 364 try 365 { 366 print_frame_info (user_frame_print_options, 367 frame, print_level, print_what, 1 /* print_args */, 368 set_current_sal); 369 if (set_current_sal) 370 set_current_sal_from_frame (frame); 371 } 372 catch (const gdb_exception_error &e) 373 { 374 } 375 } 376 377 /* Print nameless arguments of frame FRAME on STREAM, where START is 378 the offset of the first nameless argument, and NUM is the number of 379 nameless arguments to print. FIRST is nonzero if this is the first 380 argument (not just the first nameless argument). */ 381 382 static void 383 print_frame_nameless_args (struct frame_info *frame, long start, int num, 384 int first, struct ui_file *stream) 385 { 386 struct gdbarch *gdbarch = get_frame_arch (frame); 387 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 388 int i; 389 CORE_ADDR argsaddr; 390 long arg_value; 391 392 for (i = 0; i < num; i++) 393 { 394 QUIT; 395 argsaddr = get_frame_args_address (frame); 396 if (!argsaddr) 397 return; 398 arg_value = read_memory_integer (argsaddr + start, 399 sizeof (int), byte_order); 400 if (!first) 401 fprintf_filtered (stream, ", "); 402 fprintf_filtered (stream, "%ld", arg_value); 403 first = 0; 404 start += sizeof (int); 405 } 406 } 407 408 /* Print single argument of inferior function. ARG must be already 409 read in. 410 411 Errors are printed as if they would be the parameter value. Use zeroed ARG 412 iff it should not be printed according to user settings. */ 413 414 static void 415 print_frame_arg (const frame_print_options &fp_opts, 416 const struct frame_arg *arg) 417 { 418 struct ui_out *uiout = current_uiout; 419 420 string_file stb; 421 422 gdb_assert (!arg->val || !arg->error); 423 gdb_assert (arg->entry_kind == print_entry_values_no 424 || arg->entry_kind == print_entry_values_only 425 || (!uiout->is_mi_like_p () 426 && arg->entry_kind == print_entry_values_compact)); 427 428 annotate_arg_emitter arg_emitter; 429 ui_out_emit_tuple tuple_emitter (uiout, NULL); 430 fprintf_symbol_filtered (&stb, arg->sym->print_name (), 431 arg->sym->language (), DMGL_PARAMS | DMGL_ANSI); 432 if (arg->entry_kind == print_entry_values_compact) 433 { 434 /* It is OK to provide invalid MI-like stream as with 435 PRINT_ENTRY_VALUE_COMPACT we never use MI. */ 436 stb.puts ("="); 437 438 fprintf_symbol_filtered (&stb, arg->sym->print_name (), 439 arg->sym->language (), 440 DMGL_PARAMS | DMGL_ANSI); 441 } 442 if (arg->entry_kind == print_entry_values_only 443 || arg->entry_kind == print_entry_values_compact) 444 stb.puts ("@entry"); 445 uiout->field_stream ("name", stb, variable_name_style.style ()); 446 annotate_arg_name_end (); 447 uiout->text ("="); 448 449 ui_file_style style; 450 if (!arg->val && !arg->error) 451 uiout->text ("..."); 452 else 453 { 454 if (arg->error) 455 { 456 stb.printf (_("<error reading variable: %s>"), arg->error.get ()); 457 style = metadata_style.style (); 458 } 459 else 460 { 461 try 462 { 463 const struct language_defn *language; 464 struct value_print_options vp_opts; 465 466 /* Avoid value_print because it will deref ref parameters. We 467 just want to print their addresses. Print ??? for args whose 468 address we do not know. We pass 2 as "recurse" to val_print 469 because our standard indentation here is 4 spaces, and 470 val_print indents 2 for each recurse. */ 471 472 annotate_arg_value (value_type (arg->val)); 473 474 /* Use the appropriate language to display our symbol, unless the 475 user forced the language to a specific language. */ 476 if (language_mode == language_mode_auto) 477 language = language_def (arg->sym->language ()); 478 else 479 language = current_language; 480 481 get_no_prettyformat_print_options (&vp_opts); 482 vp_opts.deref_ref = 1; 483 vp_opts.raw = fp_opts.print_raw_frame_arguments; 484 485 /* True in "summary" mode, false otherwise. */ 486 vp_opts.summary 487 = fp_opts.print_frame_arguments == print_frame_arguments_scalars; 488 489 common_val_print_checked (arg->val, &stb, 2, &vp_opts, language); 490 } 491 catch (const gdb_exception_error &except) 492 { 493 stb.printf (_("<error reading variable: %s>"), 494 except.what ()); 495 style = metadata_style.style (); 496 } 497 } 498 } 499 500 uiout->field_stream ("value", stb, style); 501 } 502 503 /* Read in inferior function local SYM at FRAME into ARGP. Caller is 504 responsible for xfree of ARGP->ERROR. This function never throws an 505 exception. */ 506 507 void 508 read_frame_local (struct symbol *sym, struct frame_info *frame, 509 struct frame_arg *argp) 510 { 511 argp->sym = sym; 512 argp->val = NULL; 513 argp->error = NULL; 514 515 try 516 { 517 argp->val = read_var_value (sym, NULL, frame); 518 } 519 catch (const gdb_exception_error &except) 520 { 521 argp->error.reset (xstrdup (except.what ())); 522 } 523 } 524 525 /* Read in inferior function parameter SYM at FRAME into ARGP. This 526 function never throws an exception. */ 527 528 void 529 read_frame_arg (const frame_print_options &fp_opts, 530 symbol *sym, frame_info *frame, 531 struct frame_arg *argp, struct frame_arg *entryargp) 532 { 533 struct value *val = NULL, *entryval = NULL; 534 char *val_error = NULL, *entryval_error = NULL; 535 int val_equal = 0; 536 537 if (fp_opts.print_entry_values != print_entry_values_only 538 && fp_opts.print_entry_values != print_entry_values_preferred) 539 { 540 try 541 { 542 val = read_var_value (sym, NULL, frame); 543 } 544 catch (const gdb_exception_error &except) 545 { 546 val_error = (char *) alloca (except.message->size () + 1); 547 strcpy (val_error, except.what ()); 548 } 549 } 550 551 if (SYMBOL_COMPUTED_OPS (sym) != NULL 552 && SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry != NULL 553 && fp_opts.print_entry_values != print_entry_values_no 554 && (fp_opts.print_entry_values != print_entry_values_if_needed 555 || !val || value_optimized_out (val))) 556 { 557 try 558 { 559 const struct symbol_computed_ops *ops; 560 561 ops = SYMBOL_COMPUTED_OPS (sym); 562 entryval = ops->read_variable_at_entry (sym, frame); 563 } 564 catch (const gdb_exception_error &except) 565 { 566 if (except.error != NO_ENTRY_VALUE_ERROR) 567 { 568 entryval_error = (char *) alloca (except.message->size () + 1); 569 strcpy (entryval_error, except.what ()); 570 } 571 } 572 573 if (entryval != NULL && value_optimized_out (entryval)) 574 entryval = NULL; 575 576 if (fp_opts.print_entry_values == print_entry_values_compact 577 || fp_opts.print_entry_values == print_entry_values_default) 578 { 579 /* For MI do not try to use print_entry_values_compact for ARGP. */ 580 581 if (val && entryval && !current_uiout->is_mi_like_p ()) 582 { 583 struct type *type = value_type (val); 584 585 if (value_lazy (val)) 586 value_fetch_lazy (val); 587 if (value_lazy (entryval)) 588 value_fetch_lazy (entryval); 589 590 if (value_contents_eq (val, 0, entryval, 0, TYPE_LENGTH (type))) 591 { 592 /* Initialize it just to avoid a GCC false warning. */ 593 struct value *val_deref = NULL, *entryval_deref; 594 595 /* DW_AT_call_value does match with the current 596 value. If it is a reference still try to verify if 597 dereferenced DW_AT_call_data_value does not differ. */ 598 599 try 600 { 601 struct type *type_deref; 602 603 val_deref = coerce_ref (val); 604 if (value_lazy (val_deref)) 605 value_fetch_lazy (val_deref); 606 type_deref = value_type (val_deref); 607 608 entryval_deref = coerce_ref (entryval); 609 if (value_lazy (entryval_deref)) 610 value_fetch_lazy (entryval_deref); 611 612 /* If the reference addresses match but dereferenced 613 content does not match print them. */ 614 if (val != val_deref 615 && value_contents_eq (val_deref, 0, 616 entryval_deref, 0, 617 TYPE_LENGTH (type_deref))) 618 val_equal = 1; 619 } 620 catch (const gdb_exception_error &except) 621 { 622 /* If the dereferenced content could not be 623 fetched do not display anything. */ 624 if (except.error == NO_ENTRY_VALUE_ERROR) 625 val_equal = 1; 626 else if (except.message != NULL) 627 { 628 entryval_error 629 = (char *) alloca (except.message->size () + 1); 630 strcpy (entryval_error, except.what ()); 631 } 632 } 633 634 /* Value was not a reference; and its content matches. */ 635 if (val == val_deref) 636 val_equal = 1; 637 638 if (val_equal) 639 entryval = NULL; 640 } 641 } 642 643 /* Try to remove possibly duplicate error message for ENTRYARGP even 644 in MI mode. */ 645 646 if (val_error && entryval_error 647 && strcmp (val_error, entryval_error) == 0) 648 { 649 entryval_error = NULL; 650 651 /* Do not se VAL_EQUAL as the same error message may be shown for 652 the entry value even if no entry values are present in the 653 inferior. */ 654 } 655 } 656 } 657 658 if (entryval == NULL) 659 { 660 if (fp_opts.print_entry_values == print_entry_values_preferred) 661 { 662 gdb_assert (val == NULL); 663 664 try 665 { 666 val = read_var_value (sym, NULL, frame); 667 } 668 catch (const gdb_exception_error &except) 669 { 670 val_error = (char *) alloca (except.message->size () + 1); 671 strcpy (val_error, except.what ()); 672 } 673 } 674 if (fp_opts.print_entry_values == print_entry_values_only 675 || fp_opts.print_entry_values == print_entry_values_both 676 || (fp_opts.print_entry_values == print_entry_values_preferred 677 && (!val || value_optimized_out (val)))) 678 { 679 entryval = allocate_optimized_out_value (SYMBOL_TYPE (sym)); 680 entryval_error = NULL; 681 } 682 } 683 if ((fp_opts.print_entry_values == print_entry_values_compact 684 || fp_opts.print_entry_values == print_entry_values_if_needed 685 || fp_opts.print_entry_values == print_entry_values_preferred) 686 && (!val || value_optimized_out (val)) && entryval != NULL) 687 { 688 val = NULL; 689 val_error = NULL; 690 } 691 692 argp->sym = sym; 693 argp->val = val; 694 argp->error.reset (val_error ? xstrdup (val_error) : NULL); 695 if (!val && !val_error) 696 argp->entry_kind = print_entry_values_only; 697 else if ((fp_opts.print_entry_values == print_entry_values_compact 698 || fp_opts.print_entry_values == print_entry_values_default) 699 && val_equal) 700 { 701 argp->entry_kind = print_entry_values_compact; 702 gdb_assert (!current_uiout->is_mi_like_p ()); 703 } 704 else 705 argp->entry_kind = print_entry_values_no; 706 707 entryargp->sym = sym; 708 entryargp->val = entryval; 709 entryargp->error.reset (entryval_error ? xstrdup (entryval_error) : NULL); 710 if (!entryval && !entryval_error) 711 entryargp->entry_kind = print_entry_values_no; 712 else 713 entryargp->entry_kind = print_entry_values_only; 714 } 715 716 /* Print the arguments of frame FRAME on STREAM, given the function 717 FUNC running in that frame (as a symbol), where NUM is the number 718 of arguments according to the stack frame (or -1 if the number of 719 arguments is unknown). */ 720 721 /* Note that currently the "number of arguments according to the 722 stack frame" is only known on VAX where i refers to the "number of 723 ints of arguments according to the stack frame". */ 724 725 static void 726 print_frame_args (const frame_print_options &fp_opts, 727 struct symbol *func, struct frame_info *frame, 728 int num, struct ui_file *stream) 729 { 730 struct ui_out *uiout = current_uiout; 731 int first = 1; 732 /* Offset of next stack argument beyond the one we have seen that is 733 at the highest offset, or -1 if we haven't come to a stack 734 argument yet. */ 735 long highest_offset = -1; 736 /* Number of ints of arguments that we have printed so far. */ 737 int args_printed = 0; 738 /* True if we should print arg names. If false, we only indicate 739 the presence of arguments by printing ellipsis. */ 740 bool print_names 741 = fp_opts.print_frame_arguments != print_frame_arguments_presence; 742 /* True if we should print arguments, false otherwise. */ 743 bool print_args 744 = (print_names 745 && fp_opts.print_frame_arguments != print_frame_arguments_none); 746 747 /* Temporarily change the selected frame to the given FRAME. 748 This allows routines that rely on the selected frame instead 749 of being given a frame as parameter to use the correct frame. */ 750 scoped_restore_selected_frame restore_selected_frame; 751 select_frame (frame); 752 753 if (func) 754 { 755 const struct block *b = SYMBOL_BLOCK_VALUE (func); 756 struct block_iterator iter; 757 struct symbol *sym; 758 759 ALL_BLOCK_SYMBOLS (b, iter, sym) 760 { 761 struct frame_arg arg, entryarg; 762 763 QUIT; 764 765 /* Keep track of the highest stack argument offset seen, and 766 skip over any kinds of symbols we don't care about. */ 767 768 if (!SYMBOL_IS_ARGUMENT (sym)) 769 continue; 770 771 if (!print_names) 772 { 773 uiout->text ("..."); 774 first = 0; 775 break; 776 } 777 778 switch (SYMBOL_CLASS (sym)) 779 { 780 case LOC_ARG: 781 case LOC_REF_ARG: 782 { 783 long current_offset = SYMBOL_VALUE (sym); 784 int arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym)); 785 786 /* Compute address of next argument by adding the size of 787 this argument and rounding to an int boundary. */ 788 current_offset = 789 ((current_offset + arg_size + sizeof (int) - 1) 790 & ~(sizeof (int) - 1)); 791 792 /* If this is the highest offset seen yet, set 793 highest_offset. */ 794 if (highest_offset == -1 795 || (current_offset > highest_offset)) 796 highest_offset = current_offset; 797 798 /* Add the number of ints we're about to print to 799 args_printed. */ 800 args_printed += (arg_size + sizeof (int) - 1) / sizeof (int); 801 } 802 803 /* We care about types of symbols, but don't need to 804 keep track of stack offsets in them. */ 805 case LOC_REGISTER: 806 case LOC_REGPARM_ADDR: 807 case LOC_COMPUTED: 808 case LOC_OPTIMIZED_OUT: 809 default: 810 break; 811 } 812 813 /* We have to look up the symbol because arguments can have 814 two entries (one a parameter, one a local) and the one we 815 want is the local, which lookup_symbol will find for us. 816 This includes gcc1 (not gcc2) on SPARC when passing a 817 small structure and gcc2 when the argument type is float 818 and it is passed as a double and converted to float by 819 the prologue (in the latter case the type of the LOC_ARG 820 symbol is double and the type of the LOC_LOCAL symbol is 821 float). */ 822 /* But if the parameter name is null, don't try it. Null 823 parameter names occur on the RS/6000, for traceback 824 tables. FIXME, should we even print them? */ 825 826 if (*sym->linkage_name ()) 827 { 828 struct symbol *nsym; 829 830 nsym = lookup_symbol_search_name (sym->search_name (), 831 b, VAR_DOMAIN).symbol; 832 gdb_assert (nsym != NULL); 833 if (SYMBOL_CLASS (nsym) == LOC_REGISTER 834 && !SYMBOL_IS_ARGUMENT (nsym)) 835 { 836 /* There is a LOC_ARG/LOC_REGISTER pair. This means 837 that it was passed on the stack and loaded into a 838 register, or passed in a register and stored in a 839 stack slot. GDB 3.x used the LOC_ARG; GDB 840 4.0-4.11 used the LOC_REGISTER. 841 842 Reasons for using the LOC_ARG: 843 844 (1) Because find_saved_registers may be slow for 845 remote debugging. 846 847 (2) Because registers are often re-used and stack 848 slots rarely (never?) are. Therefore using 849 the stack slot is much less likely to print 850 garbage. 851 852 Reasons why we might want to use the LOC_REGISTER: 853 854 (1) So that the backtrace prints the same value 855 as "print foo". I see no compelling reason 856 why this needs to be the case; having the 857 backtrace print the value which was passed 858 in, and "print foo" print the value as 859 modified within the called function, makes 860 perfect sense to me. 861 862 Additional note: It might be nice if "info args" 863 displayed both values. 864 865 One more note: There is a case with SPARC 866 structure passing where we need to use the 867 LOC_REGISTER, but this is dealt with by creating 868 a single LOC_REGPARM in symbol reading. */ 869 870 /* Leave sym (the LOC_ARG) alone. */ 871 ; 872 } 873 else 874 sym = nsym; 875 } 876 877 /* Print the current arg. */ 878 if (!first) 879 uiout->text (", "); 880 uiout->wrap_hint (" "); 881 882 if (!print_args) 883 { 884 arg.sym = sym; 885 arg.entry_kind = print_entry_values_no; 886 entryarg.sym = sym; 887 entryarg.entry_kind = print_entry_values_no; 888 } 889 else 890 read_frame_arg (fp_opts, sym, frame, &arg, &entryarg); 891 892 if (arg.entry_kind != print_entry_values_only) 893 print_frame_arg (fp_opts, &arg); 894 895 if (entryarg.entry_kind != print_entry_values_no) 896 { 897 if (arg.entry_kind != print_entry_values_only) 898 { 899 uiout->text (", "); 900 uiout->wrap_hint (" "); 901 } 902 903 print_frame_arg (fp_opts, &entryarg); 904 } 905 906 first = 0; 907 } 908 } 909 910 /* Don't print nameless args in situations where we don't know 911 enough about the stack to find them. */ 912 if (num != -1) 913 { 914 long start; 915 916 if (highest_offset == -1) 917 start = gdbarch_frame_args_skip (get_frame_arch (frame)); 918 else 919 start = highest_offset; 920 921 if (!print_names && !first && num > 0) 922 uiout->text ("..."); 923 else 924 print_frame_nameless_args (frame, start, num - args_printed, 925 first, stream); 926 } 927 } 928 929 /* Set the current source and line to the location given by frame 930 FRAME, if possible. When CENTER is true, adjust so the relevant 931 line is in the center of the next 'list'. */ 932 933 void 934 set_current_sal_from_frame (struct frame_info *frame) 935 { 936 symtab_and_line sal = find_frame_sal (frame); 937 if (sal.symtab != NULL) 938 set_current_source_symtab_and_line (sal); 939 } 940 941 /* If ON, GDB will display disassembly of the next source line when 942 execution of the program being debugged stops. 943 If AUTO (which is the default), or there's no line info to determine 944 the source line of the next instruction, display disassembly of next 945 instruction instead. */ 946 947 static enum auto_boolean disassemble_next_line; 948 949 static void 950 show_disassemble_next_line (struct ui_file *file, int from_tty, 951 struct cmd_list_element *c, 952 const char *value) 953 { 954 fprintf_filtered (file, 955 _("Debugger's willingness to use " 956 "disassemble-next-line is %s.\n"), 957 value); 958 } 959 960 /* Use TRY_CATCH to catch the exception from the gdb_disassembly 961 because it will be broken by filter sometime. */ 962 963 static void 964 do_gdb_disassembly (struct gdbarch *gdbarch, 965 int how_many, CORE_ADDR low, CORE_ADDR high) 966 { 967 968 try 969 { 970 gdb_disassembly (gdbarch, current_uiout, 971 DISASSEMBLY_RAW_INSN, how_many, 972 low, high); 973 } 974 catch (const gdb_exception_error &exception) 975 { 976 /* If an exception was thrown while doing the disassembly, print 977 the error message, to give the user a clue of what happened. */ 978 exception_print (gdb_stderr, exception); 979 } 980 } 981 982 /* Converts the PRINT_FRAME_INFO choice to an optional enum print_what. 983 Value not present indicates to the caller to use default values 984 specific to the command being executed. */ 985 986 static gdb::optional<enum print_what> 987 print_frame_info_to_print_what (const char *print_frame_info) 988 { 989 for (int i = 0; print_frame_info_choices[i] != NULL; i++) 990 if (print_frame_info == print_frame_info_choices[i]) 991 return print_frame_info_print_what[i]; 992 993 internal_error (__FILE__, __LINE__, 994 "Unexpected print frame-info value `%s'.", 995 print_frame_info); 996 } 997 998 /* Print the PC from FRAME, plus any flags, to UIOUT. */ 999 1000 static void 1001 print_pc (struct ui_out *uiout, struct gdbarch *gdbarch, frame_info *frame, 1002 CORE_ADDR pc) 1003 { 1004 uiout->field_core_addr ("addr", gdbarch, pc); 1005 1006 std::string flags = gdbarch_get_pc_address_flags (gdbarch, frame, pc); 1007 if (!flags.empty ()) 1008 { 1009 uiout->text (" ["); 1010 uiout->field_string ("addr_flags", flags); 1011 uiout->text ("]"); 1012 } 1013 } 1014 1015 /* See stack.h. */ 1016 1017 void 1018 get_user_print_what_frame_info (gdb::optional<enum print_what> *what) 1019 { 1020 *what 1021 = print_frame_info_to_print_what 1022 (user_frame_print_options.print_frame_info); 1023 } 1024 1025 /* Print information about frame FRAME. The output is format according 1026 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. For the meaning of 1027 PRINT_WHAT, see enum print_what comments in frame.h. 1028 Note that PRINT_WHAT is overridden if FP_OPTS.print_frame_info 1029 != print_frame_info_auto. 1030 1031 Used in "where" output, and to emit breakpoint or step 1032 messages. */ 1033 1034 void 1035 print_frame_info (const frame_print_options &fp_opts, 1036 frame_info *frame, int print_level, 1037 enum print_what print_what, int print_args, 1038 int set_current_sal) 1039 { 1040 struct gdbarch *gdbarch = get_frame_arch (frame); 1041 int source_print; 1042 int location_print; 1043 struct ui_out *uiout = current_uiout; 1044 1045 if (!current_uiout->is_mi_like_p () 1046 && fp_opts.print_frame_info != print_frame_info_auto) 1047 { 1048 /* Use the specific frame information desired by the user. */ 1049 print_what = *print_frame_info_to_print_what (fp_opts.print_frame_info); 1050 } 1051 1052 if (get_frame_type (frame) == DUMMY_FRAME 1053 || get_frame_type (frame) == SIGTRAMP_FRAME 1054 || get_frame_type (frame) == ARCH_FRAME) 1055 { 1056 ui_out_emit_tuple tuple_emitter (uiout, "frame"); 1057 1058 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0, 1059 gdbarch, get_frame_pc (frame)); 1060 1061 /* Do this regardless of SOURCE because we don't have any source 1062 to list for this frame. */ 1063 if (print_level) 1064 { 1065 uiout->text ("#"); 1066 uiout->field_fmt_signed (2, ui_left, "level", 1067 frame_relative_level (frame)); 1068 } 1069 if (uiout->is_mi_like_p ()) 1070 { 1071 annotate_frame_address (); 1072 print_pc (uiout, gdbarch, frame, get_frame_pc (frame)); 1073 annotate_frame_address_end (); 1074 } 1075 1076 if (get_frame_type (frame) == DUMMY_FRAME) 1077 { 1078 annotate_function_call (); 1079 uiout->field_string ("func", "<function called from gdb>", 1080 metadata_style.style ()); 1081 } 1082 else if (get_frame_type (frame) == SIGTRAMP_FRAME) 1083 { 1084 annotate_signal_handler_caller (); 1085 uiout->field_string ("func", "<signal handler called>", 1086 metadata_style.style ()); 1087 } 1088 else if (get_frame_type (frame) == ARCH_FRAME) 1089 { 1090 uiout->field_string ("func", "<cross-architecture call>", 1091 metadata_style.style ()); 1092 } 1093 uiout->text ("\n"); 1094 annotate_frame_end (); 1095 1096 /* If disassemble-next-line is set to auto or on output the next 1097 instruction. */ 1098 if (disassemble_next_line == AUTO_BOOLEAN_AUTO 1099 || disassemble_next_line == AUTO_BOOLEAN_TRUE) 1100 do_gdb_disassembly (get_frame_arch (frame), 1, 1101 get_frame_pc (frame), get_frame_pc (frame) + 1); 1102 1103 return; 1104 } 1105 1106 /* If FRAME is not the innermost frame, that normally means that 1107 FRAME->pc points to *after* the call instruction, and we want to 1108 get the line containing the call, never the next line. But if 1109 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the 1110 next frame was not entered as the result of a call, and we want 1111 to get the line containing FRAME->pc. */ 1112 symtab_and_line sal = find_frame_sal (frame); 1113 1114 location_print = (print_what == LOCATION 1115 || print_what == SRC_AND_LOC 1116 || print_what == LOC_AND_ADDRESS 1117 || print_what == SHORT_LOCATION); 1118 if (location_print || !sal.symtab) 1119 print_frame (fp_opts, frame, print_level, print_what, print_args, sal); 1120 1121 source_print = (print_what == SRC_LINE || print_what == SRC_AND_LOC); 1122 1123 /* If disassemble-next-line is set to auto or on and doesn't have 1124 the line debug messages for $pc, output the next instruction. */ 1125 if ((disassemble_next_line == AUTO_BOOLEAN_AUTO 1126 || disassemble_next_line == AUTO_BOOLEAN_TRUE) 1127 && source_print && !sal.symtab) 1128 do_gdb_disassembly (get_frame_arch (frame), 1, 1129 get_frame_pc (frame), get_frame_pc (frame) + 1); 1130 1131 if (source_print && sal.symtab) 1132 { 1133 int mid_statement = ((print_what == SRC_LINE) 1134 && frame_show_address (frame, sal)); 1135 if (annotation_level > 0 1136 && annotate_source_line (sal.symtab, sal.line, mid_statement, 1137 get_frame_pc (frame))) 1138 { 1139 /* The call to ANNOTATE_SOURCE_LINE already printed the 1140 annotation for this source line, so we avoid the two cases 1141 below and do not print the actual source line. The 1142 documentation for annotations makes it clear that the source 1143 line annotation is printed __instead__ of printing the source 1144 line, not as well as. 1145 1146 However, if we fail to print the source line, which usually 1147 means either the source file is missing, or the requested 1148 line is out of range of the file, then we don't print the 1149 source annotation, and will pass through the "normal" print 1150 source line code below, the expectation is that this code 1151 will print an appropriate error. */ 1152 } 1153 else if (deprecated_print_frame_info_listing_hook) 1154 deprecated_print_frame_info_listing_hook (sal.symtab, sal.line, 1155 sal.line + 1, 0); 1156 else 1157 { 1158 struct value_print_options opts; 1159 1160 get_user_print_options (&opts); 1161 /* We used to do this earlier, but that is clearly 1162 wrong. This function is used by many different 1163 parts of gdb, including normal_stop in infrun.c, 1164 which uses this to print out the current PC 1165 when we stepi/nexti into the middle of a source 1166 line. Only the command line really wants this 1167 behavior. Other UIs probably would like the 1168 ability to decide for themselves if it is desired. */ 1169 if (opts.addressprint && mid_statement) 1170 { 1171 print_pc (uiout, gdbarch, frame, get_frame_pc (frame)); 1172 uiout->text ("\t"); 1173 } 1174 1175 print_source_lines (sal.symtab, sal.line, sal.line + 1, 0); 1176 } 1177 1178 /* If disassemble-next-line is set to on and there is line debug 1179 messages, output assembly codes for next line. */ 1180 if (disassemble_next_line == AUTO_BOOLEAN_TRUE) 1181 do_gdb_disassembly (get_frame_arch (frame), -1, sal.pc, sal.end); 1182 } 1183 1184 if (set_current_sal) 1185 { 1186 CORE_ADDR pc; 1187 1188 if (get_frame_pc_if_available (frame, &pc)) 1189 last_displayed_symtab_info.set (sal.pspace, pc, sal.symtab, sal.line); 1190 else 1191 last_displayed_symtab_info.invalidate (); 1192 } 1193 1194 annotate_frame_end (); 1195 1196 gdb_flush (gdb_stdout); 1197 } 1198 1199 /* See stack.h. */ 1200 1201 void 1202 clear_last_displayed_sal (void) 1203 { 1204 last_displayed_symtab_info.invalidate (); 1205 } 1206 1207 /* See stack.h. */ 1208 1209 bool 1210 last_displayed_sal_is_valid (void) 1211 { 1212 return last_displayed_symtab_info.is_valid (); 1213 } 1214 1215 /* See stack.h. */ 1216 1217 struct program_space * 1218 get_last_displayed_pspace (void) 1219 { 1220 return last_displayed_symtab_info.pspace (); 1221 } 1222 1223 /* See stack.h. */ 1224 1225 CORE_ADDR 1226 get_last_displayed_addr (void) 1227 { 1228 return last_displayed_symtab_info.address (); 1229 } 1230 1231 /* See stack.h. */ 1232 1233 struct symtab* 1234 get_last_displayed_symtab (void) 1235 { 1236 return last_displayed_symtab_info.symtab (); 1237 } 1238 1239 /* See stack.h. */ 1240 1241 int 1242 get_last_displayed_line (void) 1243 { 1244 return last_displayed_symtab_info.line (); 1245 } 1246 1247 /* See stack.h. */ 1248 1249 symtab_and_line 1250 get_last_displayed_sal () 1251 { 1252 symtab_and_line sal; 1253 1254 if (last_displayed_symtab_info.is_valid ()) 1255 { 1256 sal.pspace = last_displayed_symtab_info.pspace (); 1257 sal.pc = last_displayed_symtab_info.address (); 1258 sal.symtab = last_displayed_symtab_info.symtab (); 1259 sal.line = last_displayed_symtab_info.line (); 1260 } 1261 1262 return sal; 1263 } 1264 1265 1266 /* Attempt to obtain the name, FUNLANG and optionally FUNCP of the function 1267 corresponding to FRAME. */ 1268 1269 gdb::unique_xmalloc_ptr<char> 1270 find_frame_funname (struct frame_info *frame, enum language *funlang, 1271 struct symbol **funcp) 1272 { 1273 struct symbol *func; 1274 gdb::unique_xmalloc_ptr<char> funname; 1275 1276 *funlang = language_unknown; 1277 if (funcp) 1278 *funcp = NULL; 1279 1280 func = get_frame_function (frame); 1281 if (func) 1282 { 1283 const char *print_name = func->print_name (); 1284 1285 *funlang = func->language (); 1286 if (funcp) 1287 *funcp = func; 1288 if (*funlang == language_cplus) 1289 { 1290 /* It seems appropriate to use print_name() here, 1291 to display the demangled name that we already have 1292 stored in the symbol table, but we stored a version 1293 with DMGL_PARAMS turned on, and here we don't want to 1294 display parameters. So remove the parameters. */ 1295 funname = cp_remove_params (print_name); 1296 } 1297 1298 /* If we didn't hit the C++ case above, set *funname 1299 here. */ 1300 if (funname == NULL) 1301 funname.reset (xstrdup (print_name)); 1302 } 1303 else 1304 { 1305 struct bound_minimal_symbol msymbol; 1306 CORE_ADDR pc; 1307 1308 if (!get_frame_address_in_block_if_available (frame, &pc)) 1309 return funname; 1310 1311 msymbol = lookup_minimal_symbol_by_pc (pc); 1312 if (msymbol.minsym != NULL) 1313 { 1314 funname.reset (xstrdup (msymbol.minsym->print_name ())); 1315 *funlang = msymbol.minsym->language (); 1316 } 1317 } 1318 1319 return funname; 1320 } 1321 1322 static void 1323 print_frame (const frame_print_options &fp_opts, 1324 frame_info *frame, int print_level, 1325 enum print_what print_what, int print_args, 1326 struct symtab_and_line sal) 1327 { 1328 struct gdbarch *gdbarch = get_frame_arch (frame); 1329 struct ui_out *uiout = current_uiout; 1330 enum language funlang = language_unknown; 1331 struct value_print_options opts; 1332 struct symbol *func; 1333 CORE_ADDR pc = 0; 1334 int pc_p; 1335 1336 pc_p = get_frame_pc_if_available (frame, &pc); 1337 1338 gdb::unique_xmalloc_ptr<char> funname 1339 = find_frame_funname (frame, &funlang, &func); 1340 1341 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0, 1342 gdbarch, pc); 1343 1344 { 1345 ui_out_emit_tuple tuple_emitter (uiout, "frame"); 1346 1347 if (print_level) 1348 { 1349 uiout->text ("#"); 1350 uiout->field_fmt_signed (2, ui_left, "level", 1351 frame_relative_level (frame)); 1352 } 1353 get_user_print_options (&opts); 1354 if (opts.addressprint) 1355 if (!sal.symtab 1356 || frame_show_address (frame, sal) 1357 || print_what == LOC_AND_ADDRESS) 1358 { 1359 annotate_frame_address (); 1360 if (pc_p) 1361 print_pc (uiout, gdbarch, frame, pc); 1362 else 1363 uiout->field_string ("addr", "<unavailable>", 1364 metadata_style.style ()); 1365 annotate_frame_address_end (); 1366 uiout->text (" in "); 1367 } 1368 annotate_frame_function_name (); 1369 1370 string_file stb; 1371 fprintf_symbol_filtered (&stb, funname ? funname.get () : "??", 1372 funlang, DMGL_ANSI); 1373 uiout->field_stream ("func", stb, function_name_style.style ()); 1374 uiout->wrap_hint (" "); 1375 annotate_frame_args (); 1376 1377 uiout->text (" ("); 1378 if (print_args) 1379 { 1380 int numargs; 1381 1382 if (gdbarch_frame_num_args_p (gdbarch)) 1383 { 1384 numargs = gdbarch_frame_num_args (gdbarch, frame); 1385 gdb_assert (numargs >= 0); 1386 } 1387 else 1388 numargs = -1; 1389 1390 { 1391 ui_out_emit_list list_emitter (uiout, "args"); 1392 try 1393 { 1394 print_frame_args (fp_opts, func, frame, numargs, gdb_stdout); 1395 } 1396 catch (const gdb_exception_error &e) 1397 { 1398 } 1399 1400 /* FIXME: ARGS must be a list. If one argument is a string it 1401 will have " that will not be properly escaped. */ 1402 } 1403 QUIT; 1404 } 1405 uiout->text (")"); 1406 if (print_what != SHORT_LOCATION && sal.symtab) 1407 { 1408 const char *filename_display; 1409 1410 filename_display = symtab_to_filename_for_display (sal.symtab); 1411 annotate_frame_source_begin (); 1412 uiout->wrap_hint (" "); 1413 uiout->text (" at "); 1414 annotate_frame_source_file (); 1415 uiout->field_string ("file", filename_display, 1416 file_name_style.style ()); 1417 if (uiout->is_mi_like_p ()) 1418 { 1419 const char *fullname = symtab_to_fullname (sal.symtab); 1420 1421 uiout->field_string ("fullname", fullname); 1422 } 1423 annotate_frame_source_file_end (); 1424 uiout->text (":"); 1425 annotate_frame_source_line (); 1426 uiout->field_signed ("line", sal.line); 1427 annotate_frame_source_end (); 1428 } 1429 1430 if (print_what != SHORT_LOCATION 1431 && pc_p && (funname == NULL || sal.symtab == NULL)) 1432 { 1433 char *lib = solib_name_from_address (get_frame_program_space (frame), 1434 get_frame_pc (frame)); 1435 1436 if (lib) 1437 { 1438 annotate_frame_where (); 1439 uiout->wrap_hint (" "); 1440 uiout->text (" from "); 1441 uiout->field_string ("from", lib, file_name_style.style ()); 1442 } 1443 } 1444 if (uiout->is_mi_like_p ()) 1445 uiout->field_string ("arch", 1446 (gdbarch_bfd_arch_info (gdbarch))->printable_name); 1447 } 1448 1449 uiout->text ("\n"); 1450 } 1451 1452 1453 /* Completion function for "frame function", "info frame function", and 1454 "select-frame function" commands. */ 1455 1456 static void 1457 frame_selection_by_function_completer (struct cmd_list_element *ignore, 1458 completion_tracker &tracker, 1459 const char *text, const char *word) 1460 { 1461 /* This is used to complete function names within a stack. It would be 1462 nice if we only offered functions that were actually in the stack. 1463 However, this would mean unwinding the stack to completion, which 1464 could take too long, or on a corrupted stack, possibly not end. 1465 Instead, we offer all symbol names as a safer choice. */ 1466 collect_symbol_completion_matches (tracker, 1467 complete_symbol_mode::EXPRESSION, 1468 symbol_name_match_type::EXPRESSION, 1469 text, word); 1470 } 1471 1472 /* Core of all the "info frame" sub-commands. Print information about a 1473 frame FI. If SELECTED_FRAME_P is true then the user didn't provide a 1474 frame specification, they just entered 'info frame'. If the user did 1475 provide a frame specification (for example 'info frame 0', 'info frame 1476 level 1') then SELECTED_FRAME_P will be false. */ 1477 1478 static void 1479 info_frame_command_core (struct frame_info *fi, bool selected_frame_p) 1480 { 1481 struct symbol *func; 1482 struct symtab *s; 1483 struct frame_info *calling_frame_info; 1484 int numregs; 1485 const char *funname = 0; 1486 enum language funlang = language_unknown; 1487 const char *pc_regname; 1488 struct gdbarch *gdbarch; 1489 CORE_ADDR frame_pc; 1490 int frame_pc_p; 1491 /* Initialize it to avoid "may be used uninitialized" warning. */ 1492 CORE_ADDR caller_pc = 0; 1493 int caller_pc_p = 0; 1494 1495 gdbarch = get_frame_arch (fi); 1496 1497 /* Name of the value returned by get_frame_pc(). Per comments, "pc" 1498 is not a good name. */ 1499 if (gdbarch_pc_regnum (gdbarch) >= 0) 1500 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can 1501 easily not match that of the internal value returned by 1502 get_frame_pc(). */ 1503 pc_regname = gdbarch_register_name (gdbarch, gdbarch_pc_regnum (gdbarch)); 1504 else 1505 /* But then, this is weird to. Even without gdbarch_pc_regnum, an 1506 architectures will often have a hardware register called "pc", 1507 and that register's value, again, can easily not match 1508 get_frame_pc(). */ 1509 pc_regname = "pc"; 1510 1511 frame_pc_p = get_frame_pc_if_available (fi, &frame_pc); 1512 func = get_frame_function (fi); 1513 symtab_and_line sal = find_frame_sal (fi); 1514 s = sal.symtab; 1515 gdb::unique_xmalloc_ptr<char> func_only; 1516 if (func) 1517 { 1518 funname = func->print_name (); 1519 funlang = func->language (); 1520 if (funlang == language_cplus) 1521 { 1522 /* It seems appropriate to use print_name() here, 1523 to display the demangled name that we already have 1524 stored in the symbol table, but we stored a version 1525 with DMGL_PARAMS turned on, and here we don't want to 1526 display parameters. So remove the parameters. */ 1527 func_only = cp_remove_params (funname); 1528 1529 if (func_only) 1530 funname = func_only.get (); 1531 } 1532 } 1533 else if (frame_pc_p) 1534 { 1535 struct bound_minimal_symbol msymbol; 1536 1537 msymbol = lookup_minimal_symbol_by_pc (frame_pc); 1538 if (msymbol.minsym != NULL) 1539 { 1540 funname = msymbol.minsym->print_name (); 1541 funlang = msymbol.minsym->language (); 1542 } 1543 } 1544 calling_frame_info = get_prev_frame (fi); 1545 1546 if (selected_frame_p && frame_relative_level (fi) >= 0) 1547 { 1548 printf_filtered (_("Stack level %d, frame at "), 1549 frame_relative_level (fi)); 1550 } 1551 else 1552 { 1553 printf_filtered (_("Stack frame at ")); 1554 } 1555 fputs_filtered (paddress (gdbarch, get_frame_base (fi)), gdb_stdout); 1556 printf_filtered (":\n"); 1557 printf_filtered (" %s = ", pc_regname); 1558 if (frame_pc_p) 1559 fputs_filtered (paddress (gdbarch, get_frame_pc (fi)), gdb_stdout); 1560 else 1561 fputs_styled ("<unavailable>", metadata_style.style (), gdb_stdout); 1562 1563 wrap_here (" "); 1564 if (funname) 1565 { 1566 printf_filtered (" in "); 1567 fprintf_symbol_filtered (gdb_stdout, funname, funlang, 1568 DMGL_ANSI | DMGL_PARAMS); 1569 } 1570 wrap_here (" "); 1571 if (sal.symtab) 1572 printf_filtered 1573 (" (%ps:%d)", 1574 styled_string (file_name_style.style (), 1575 symtab_to_filename_for_display (sal.symtab)), 1576 sal.line); 1577 puts_filtered ("; "); 1578 wrap_here (" "); 1579 printf_filtered ("saved %s = ", pc_regname); 1580 1581 if (!frame_id_p (frame_unwind_caller_id (fi))) 1582 val_print_not_saved (gdb_stdout); 1583 else 1584 { 1585 try 1586 { 1587 caller_pc = frame_unwind_caller_pc (fi); 1588 caller_pc_p = 1; 1589 } 1590 catch (const gdb_exception_error &ex) 1591 { 1592 switch (ex.error) 1593 { 1594 case NOT_AVAILABLE_ERROR: 1595 val_print_unavailable (gdb_stdout); 1596 break; 1597 case OPTIMIZED_OUT_ERROR: 1598 val_print_not_saved (gdb_stdout); 1599 break; 1600 default: 1601 fprintf_styled (gdb_stdout, metadata_style.style (), 1602 _("<error: %s>"), 1603 ex.what ()); 1604 break; 1605 } 1606 } 1607 } 1608 1609 if (caller_pc_p) 1610 fputs_filtered (paddress (gdbarch, caller_pc), gdb_stdout); 1611 printf_filtered ("\n"); 1612 1613 if (calling_frame_info == NULL) 1614 { 1615 enum unwind_stop_reason reason; 1616 1617 reason = get_frame_unwind_stop_reason (fi); 1618 if (reason != UNWIND_NO_REASON) 1619 printf_filtered (_(" Outermost frame: %s\n"), 1620 frame_stop_reason_string (fi)); 1621 } 1622 else if (get_frame_type (fi) == TAILCALL_FRAME) 1623 puts_filtered (" tail call frame"); 1624 else if (get_frame_type (fi) == INLINE_FRAME) 1625 printf_filtered (" inlined into frame %d", 1626 frame_relative_level (get_prev_frame (fi))); 1627 else 1628 { 1629 printf_filtered (" called by frame at "); 1630 fputs_filtered (paddress (gdbarch, get_frame_base (calling_frame_info)), 1631 gdb_stdout); 1632 } 1633 if (get_next_frame (fi) && calling_frame_info) 1634 puts_filtered (","); 1635 wrap_here (" "); 1636 if (get_next_frame (fi)) 1637 { 1638 printf_filtered (" caller of frame at "); 1639 fputs_filtered (paddress (gdbarch, get_frame_base (get_next_frame (fi))), 1640 gdb_stdout); 1641 } 1642 if (get_next_frame (fi) || calling_frame_info) 1643 puts_filtered ("\n"); 1644 1645 if (s) 1646 printf_filtered (" source language %s.\n", 1647 language_str (s->language)); 1648 1649 { 1650 /* Address of the argument list for this frame, or 0. */ 1651 CORE_ADDR arg_list = get_frame_args_address (fi); 1652 /* Number of args for this frame, or -1 if unknown. */ 1653 int numargs; 1654 1655 if (arg_list == 0) 1656 printf_filtered (" Arglist at unknown address.\n"); 1657 else 1658 { 1659 printf_filtered (" Arglist at "); 1660 fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout); 1661 printf_filtered (","); 1662 1663 if (!gdbarch_frame_num_args_p (gdbarch)) 1664 { 1665 numargs = -1; 1666 puts_filtered (" args: "); 1667 } 1668 else 1669 { 1670 numargs = gdbarch_frame_num_args (gdbarch, fi); 1671 gdb_assert (numargs >= 0); 1672 if (numargs == 0) 1673 puts_filtered (" no args."); 1674 else if (numargs == 1) 1675 puts_filtered (" 1 arg: "); 1676 else 1677 printf_filtered (" %d args: ", numargs); 1678 } 1679 print_frame_args (user_frame_print_options, 1680 func, fi, numargs, gdb_stdout); 1681 puts_filtered ("\n"); 1682 } 1683 } 1684 { 1685 /* Address of the local variables for this frame, or 0. */ 1686 CORE_ADDR arg_list = get_frame_locals_address (fi); 1687 1688 if (arg_list == 0) 1689 printf_filtered (" Locals at unknown address,"); 1690 else 1691 { 1692 printf_filtered (" Locals at "); 1693 fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout); 1694 printf_filtered (","); 1695 } 1696 } 1697 1698 /* Print as much information as possible on the location of all the 1699 registers. */ 1700 { 1701 int count; 1702 int i; 1703 int need_nl = 1; 1704 int sp_regnum = gdbarch_sp_regnum (gdbarch); 1705 1706 /* The sp is special; what's displayed isn't the save address, but 1707 the value of the previous frame's sp. This is a legacy thing, 1708 at one stage the frame cached the previous frame's SP instead 1709 of its address, hence it was easiest to just display the cached 1710 value. */ 1711 if (sp_regnum >= 0) 1712 { 1713 struct value *value = frame_unwind_register_value (fi, sp_regnum); 1714 gdb_assert (value != NULL); 1715 1716 if (!value_optimized_out (value) && value_entirely_available (value)) 1717 { 1718 if (VALUE_LVAL (value) == not_lval) 1719 { 1720 CORE_ADDR sp; 1721 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 1722 int sp_size = register_size (gdbarch, sp_regnum); 1723 1724 sp = extract_unsigned_integer (value_contents_all (value), 1725 sp_size, byte_order); 1726 1727 printf_filtered (" Previous frame's sp is "); 1728 fputs_filtered (paddress (gdbarch, sp), gdb_stdout); 1729 printf_filtered ("\n"); 1730 } 1731 else if (VALUE_LVAL (value) == lval_memory) 1732 { 1733 printf_filtered (" Previous frame's sp at "); 1734 fputs_filtered (paddress (gdbarch, value_address (value)), 1735 gdb_stdout); 1736 printf_filtered ("\n"); 1737 } 1738 else if (VALUE_LVAL (value) == lval_register) 1739 { 1740 printf_filtered (" Previous frame's sp in %s\n", 1741 gdbarch_register_name (gdbarch, 1742 VALUE_REGNUM (value))); 1743 } 1744 1745 release_value (value); 1746 need_nl = 0; 1747 } 1748 /* else keep quiet. */ 1749 } 1750 1751 count = 0; 1752 numregs = gdbarch_num_cooked_regs (gdbarch); 1753 for (i = 0; i < numregs; i++) 1754 if (i != sp_regnum 1755 && gdbarch_register_reggroup_p (gdbarch, i, all_reggroup)) 1756 { 1757 enum lval_type lval; 1758 int optimized; 1759 int unavailable; 1760 CORE_ADDR addr; 1761 int realnum; 1762 1763 /* Find out the location of the saved register without 1764 fetching the corresponding value. */ 1765 frame_register_unwind (fi, i, &optimized, &unavailable, 1766 &lval, &addr, &realnum, NULL); 1767 /* For moment, only display registers that were saved on the 1768 stack. */ 1769 if (!optimized && !unavailable && lval == lval_memory) 1770 { 1771 if (count == 0) 1772 puts_filtered (" Saved registers:\n "); 1773 else 1774 puts_filtered (","); 1775 wrap_here (" "); 1776 printf_filtered (" %s at ", 1777 gdbarch_register_name (gdbarch, i)); 1778 fputs_filtered (paddress (gdbarch, addr), gdb_stdout); 1779 count++; 1780 } 1781 } 1782 if (count || need_nl) 1783 puts_filtered ("\n"); 1784 } 1785 } 1786 1787 /* Return the innermost frame at level LEVEL. */ 1788 1789 static struct frame_info * 1790 leading_innermost_frame (int level) 1791 { 1792 struct frame_info *leading; 1793 1794 leading = get_current_frame (); 1795 1796 gdb_assert (level >= 0); 1797 1798 while (leading != nullptr && level) 1799 { 1800 QUIT; 1801 leading = get_prev_frame (leading); 1802 level--; 1803 } 1804 1805 return leading; 1806 } 1807 1808 /* Return the starting frame needed to handle COUNT outermost frames. */ 1809 1810 static struct frame_info * 1811 trailing_outermost_frame (int count) 1812 { 1813 struct frame_info *current; 1814 struct frame_info *trailing; 1815 1816 trailing = get_current_frame (); 1817 1818 gdb_assert (count > 0); 1819 1820 current = trailing; 1821 while (current != nullptr && count--) 1822 { 1823 QUIT; 1824 current = get_prev_frame (current); 1825 } 1826 1827 /* Will stop when CURRENT reaches the top of the stack. 1828 TRAILING will be COUNT below it. */ 1829 while (current != nullptr) 1830 { 1831 QUIT; 1832 trailing = get_prev_frame (trailing); 1833 current = get_prev_frame (current); 1834 } 1835 1836 return trailing; 1837 } 1838 1839 /* The core of all the "select-frame" sub-commands. Just wraps a call to 1840 SELECT_FRAME. */ 1841 1842 static void 1843 select_frame_command_core (struct frame_info *fi, bool ignored) 1844 { 1845 struct frame_info *prev_frame = get_selected_frame_if_set (); 1846 select_frame (fi); 1847 if (get_selected_frame_if_set () != prev_frame) 1848 gdb::observers::user_selected_context_changed.notify (USER_SELECTED_FRAME); 1849 } 1850 1851 /* See stack.h. */ 1852 1853 void 1854 select_frame_for_mi (struct frame_info *fi) 1855 { 1856 select_frame_command_core (fi, false /* Ignored. */); 1857 } 1858 1859 /* The core of all the "frame" sub-commands. Select frame FI, and if this 1860 means we change frame send out a change notification (otherwise, just 1861 reprint the current frame summary). */ 1862 1863 static void 1864 frame_command_core (struct frame_info *fi, bool ignored) 1865 { 1866 struct frame_info *prev_frame = get_selected_frame_if_set (); 1867 1868 select_frame (fi); 1869 if (get_selected_frame_if_set () != prev_frame) 1870 gdb::observers::user_selected_context_changed.notify (USER_SELECTED_FRAME); 1871 else 1872 print_selected_thread_frame (current_uiout, USER_SELECTED_FRAME); 1873 } 1874 1875 /* The three commands 'frame', 'select-frame', and 'info frame' all have a 1876 common set of sub-commands that allow a specific frame to be selected. 1877 All of the sub-command functions are static methods within this class 1878 template which is then instantiated below. The template parameter is a 1879 callback used to implement the functionality of the base command 1880 ('frame', 'select-frame', or 'info frame'). 1881 1882 In the template parameter FI is the frame being selected. The 1883 SELECTED_FRAME_P flag is true if the frame being selected was done by 1884 default, which happens when the user uses the base command with no 1885 arguments. For example the commands 'info frame', 'select-frame', 1886 'frame' will all cause SELECTED_FRAME_P to be true. In all other cases 1887 SELECTED_FRAME_P is false. */ 1888 1889 template <void (*FPTR) (struct frame_info *fi, bool selected_frame_p)> 1890 class frame_command_helper 1891 { 1892 public: 1893 1894 /* The "frame level" family of commands. The ARG is an integer that is 1895 the frame's level in the stack. */ 1896 static void 1897 level (const char *arg, int from_tty) 1898 { 1899 int level = value_as_long (parse_and_eval (arg)); 1900 struct frame_info *fid 1901 = find_relative_frame (get_current_frame (), &level); 1902 if (level != 0) 1903 error (_("No frame at level %s."), arg); 1904 FPTR (fid, false); 1905 } 1906 1907 /* The "frame address" family of commands. ARG is a stack-pointer 1908 address for an existing frame. This command does not allow new 1909 frames to be created. */ 1910 1911 static void 1912 address (const char *arg, int from_tty) 1913 { 1914 CORE_ADDR addr = value_as_address (parse_and_eval (arg)); 1915 struct frame_info *fid = find_frame_for_address (addr); 1916 if (fid == NULL) 1917 error (_("No frame at address %s."), arg); 1918 FPTR (fid, false); 1919 } 1920 1921 /* The "frame view" family of commands. ARG is one or two addresses and 1922 is used to view a frame that might be outside the current backtrace. 1923 The addresses are stack-pointer address, and (optional) pc-address. */ 1924 1925 static void 1926 view (const char *args, int from_tty) 1927 { 1928 struct frame_info *fid; 1929 1930 if (args == NULL) 1931 error (_("Missing address argument to view a frame")); 1932 1933 gdb_argv argv (args); 1934 1935 if (argv.count () == 2) 1936 { 1937 CORE_ADDR addr[2]; 1938 1939 addr [0] = value_as_address (parse_and_eval (argv[0])); 1940 addr [1] = value_as_address (parse_and_eval (argv[1])); 1941 fid = create_new_frame (addr[0], addr[1]); 1942 } 1943 else 1944 { 1945 CORE_ADDR addr = value_as_address (parse_and_eval (argv[0])); 1946 fid = create_new_frame (addr, false); 1947 } 1948 FPTR (fid, false); 1949 } 1950 1951 /* The "frame function" family of commands. ARG is the name of a 1952 function within the stack, the first function (searching from frame 1953 0) with that name will be selected. */ 1954 1955 static void 1956 function (const char *arg, int from_tty) 1957 { 1958 if (arg == NULL) 1959 error (_("Missing function name argument")); 1960 struct frame_info *fid = find_frame_for_function (arg); 1961 if (fid == NULL) 1962 error (_("No frame for function \"%s\"."), arg); 1963 FPTR (fid, false); 1964 } 1965 1966 /* The "frame" base command, that is, when no sub-command is specified. 1967 If one argument is provided then we assume that this is a frame's 1968 level as historically, this was the supported command syntax that was 1969 used most often. 1970 1971 If no argument is provided, then the current frame is selected. */ 1972 1973 static void 1974 base_command (const char *arg, int from_tty) 1975 { 1976 if (arg == NULL) 1977 FPTR (get_selected_frame (_("No stack.")), true); 1978 else 1979 level (arg, from_tty); 1980 } 1981 }; 1982 1983 /* Instantiate three FRAME_COMMAND_HELPER instances to implement the 1984 sub-commands for 'info frame', 'frame', and 'select-frame' commands. */ 1985 1986 static frame_command_helper <info_frame_command_core> info_frame_cmd; 1987 static frame_command_helper <frame_command_core> frame_cmd; 1988 static frame_command_helper <select_frame_command_core> select_frame_cmd; 1989 1990 /* Print briefly all stack frames or just the innermost COUNT_EXP 1991 frames. */ 1992 1993 static void 1994 backtrace_command_1 (const frame_print_options &fp_opts, 1995 const backtrace_cmd_options &bt_opts, 1996 const char *count_exp, int from_tty) 1997 1998 { 1999 struct frame_info *fi; 2000 int count; 2001 int py_start = 0, py_end = 0; 2002 enum ext_lang_bt_status result = EXT_LANG_BT_ERROR; 2003 2004 if (!target_has_stack) 2005 error (_("No stack.")); 2006 2007 if (count_exp) 2008 { 2009 count = parse_and_eval_long (count_exp); 2010 if (count < 0) 2011 py_start = count; 2012 else 2013 { 2014 py_start = 0; 2015 /* The argument to apply_ext_lang_frame_filter is the number 2016 of the final frame to print, and frames start at 0. */ 2017 py_end = count - 1; 2018 } 2019 } 2020 else 2021 { 2022 py_end = -1; 2023 count = -1; 2024 } 2025 2026 frame_filter_flags flags = 0; 2027 2028 if (bt_opts.full) 2029 flags |= PRINT_LOCALS; 2030 if (bt_opts.hide) 2031 flags |= PRINT_HIDE; 2032 2033 if (!bt_opts.no_filters) 2034 { 2035 enum ext_lang_frame_args arg_type; 2036 2037 flags |= PRINT_LEVEL | PRINT_FRAME_INFO | PRINT_ARGS; 2038 if (from_tty) 2039 flags |= PRINT_MORE_FRAMES; 2040 2041 if (fp_opts.print_frame_arguments == print_frame_arguments_scalars) 2042 arg_type = CLI_SCALAR_VALUES; 2043 else if (fp_opts.print_frame_arguments == print_frame_arguments_all) 2044 arg_type = CLI_ALL_VALUES; 2045 else if (fp_opts.print_frame_arguments == print_frame_arguments_presence) 2046 arg_type = CLI_PRESENCE; 2047 else if (fp_opts.print_frame_arguments == print_frame_arguments_none) 2048 arg_type = NO_VALUES; 2049 else 2050 gdb_assert (0); 2051 2052 result = apply_ext_lang_frame_filter (get_current_frame (), flags, 2053 arg_type, current_uiout, 2054 py_start, py_end); 2055 } 2056 2057 /* Run the inbuilt backtrace if there are no filters registered, or 2058 "-no-filters" has been specified from the command. */ 2059 if (bt_opts.no_filters || result == EXT_LANG_BT_NO_FILTERS) 2060 { 2061 struct frame_info *trailing; 2062 2063 /* The following code must do two things. First, it must set the 2064 variable TRAILING to the frame from which we should start 2065 printing. Second, it must set the variable count to the number 2066 of frames which we should print, or -1 if all of them. */ 2067 2068 if (count_exp != NULL && count < 0) 2069 { 2070 trailing = trailing_outermost_frame (-count); 2071 count = -1; 2072 } 2073 else 2074 trailing = get_current_frame (); 2075 2076 for (fi = trailing; fi && count--; fi = get_prev_frame (fi)) 2077 { 2078 QUIT; 2079 2080 /* Don't use print_stack_frame; if an error() occurs it probably 2081 means further attempts to backtrace would fail (on the other 2082 hand, perhaps the code does or could be fixed to make sure 2083 the frame->prev field gets set to NULL in that case). */ 2084 2085 print_frame_info (fp_opts, fi, 1, LOCATION, 1, 0); 2086 if ((flags & PRINT_LOCALS) != 0) 2087 { 2088 struct frame_id frame_id = get_frame_id (fi); 2089 2090 print_frame_local_vars (fi, false, NULL, NULL, 1, gdb_stdout); 2091 2092 /* print_frame_local_vars invalidates FI. */ 2093 fi = frame_find_by_id (frame_id); 2094 if (fi == NULL) 2095 { 2096 trailing = NULL; 2097 warning (_("Unable to restore previously selected frame.")); 2098 break; 2099 } 2100 } 2101 2102 /* Save the last frame to check for error conditions. */ 2103 trailing = fi; 2104 } 2105 2106 /* If we've stopped before the end, mention that. */ 2107 if (fi && from_tty) 2108 printf_filtered (_("(More stack frames follow...)\n")); 2109 2110 /* If we've run out of frames, and the reason appears to be an error 2111 condition, print it. */ 2112 if (fi == NULL && trailing != NULL) 2113 { 2114 enum unwind_stop_reason reason; 2115 2116 reason = get_frame_unwind_stop_reason (trailing); 2117 if (reason >= UNWIND_FIRST_ERROR) 2118 printf_filtered (_("Backtrace stopped: %s\n"), 2119 frame_stop_reason_string (trailing)); 2120 } 2121 } 2122 } 2123 2124 /* Create an option_def_group array grouping all the "backtrace" 2125 options, with FP_OPTS, BT_CMD_OPT, SET_BT_OPTS as contexts. */ 2126 2127 static inline std::array<gdb::option::option_def_group, 3> 2128 make_backtrace_options_def_group (frame_print_options *fp_opts, 2129 backtrace_cmd_options *bt_cmd_opts, 2130 set_backtrace_options *set_bt_opts) 2131 { 2132 return {{ 2133 { {frame_print_option_defs}, fp_opts }, 2134 { {set_backtrace_option_defs}, set_bt_opts }, 2135 { {backtrace_command_option_defs}, bt_cmd_opts } 2136 }}; 2137 } 2138 2139 /* Parse the backtrace command's qualifiers. Returns ARG advanced 2140 past the qualifiers, if any. BT_CMD_OPTS, if not null, is used to 2141 store the parsed qualifiers. */ 2142 2143 static const char * 2144 parse_backtrace_qualifiers (const char *arg, 2145 backtrace_cmd_options *bt_cmd_opts = nullptr) 2146 { 2147 while (true) 2148 { 2149 const char *save_arg = arg; 2150 std::string this_arg = extract_arg (&arg); 2151 2152 if (this_arg.empty ()) 2153 return arg; 2154 2155 if (subset_compare (this_arg.c_str (), "no-filters")) 2156 { 2157 if (bt_cmd_opts != nullptr) 2158 bt_cmd_opts->no_filters = true; 2159 } 2160 else if (subset_compare (this_arg.c_str (), "full")) 2161 { 2162 if (bt_cmd_opts != nullptr) 2163 bt_cmd_opts->full = true; 2164 } 2165 else if (subset_compare (this_arg.c_str (), "hide")) 2166 { 2167 if (bt_cmd_opts != nullptr) 2168 bt_cmd_opts->hide = true; 2169 } 2170 else 2171 { 2172 /* Not a recognized qualifier, so stop. */ 2173 return save_arg; 2174 } 2175 } 2176 } 2177 2178 static void 2179 backtrace_command (const char *arg, int from_tty) 2180 { 2181 frame_print_options fp_opts = user_frame_print_options; 2182 backtrace_cmd_options bt_cmd_opts; 2183 set_backtrace_options set_bt_opts = user_set_backtrace_options; 2184 2185 auto grp 2186 = make_backtrace_options_def_group (&fp_opts, &bt_cmd_opts, &set_bt_opts); 2187 gdb::option::process_options 2188 (&arg, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, grp); 2189 2190 /* Parse non-'-'-prefixed qualifiers, for backwards 2191 compatibility. */ 2192 if (arg != NULL) 2193 { 2194 arg = parse_backtrace_qualifiers (arg, &bt_cmd_opts); 2195 if (*arg == '\0') 2196 arg = NULL; 2197 } 2198 2199 /* These options are handled quite deep in the unwind machinery, so 2200 we get to pass them down by swapping globals. */ 2201 scoped_restore restore_set_backtrace_options 2202 = make_scoped_restore (&user_set_backtrace_options, set_bt_opts); 2203 2204 backtrace_command_1 (fp_opts, bt_cmd_opts, arg, from_tty); 2205 } 2206 2207 /* Completer for the "backtrace" command. */ 2208 2209 static void 2210 backtrace_command_completer (struct cmd_list_element *ignore, 2211 completion_tracker &tracker, 2212 const char *text, const char */*word*/) 2213 { 2214 const auto group 2215 = make_backtrace_options_def_group (nullptr, nullptr, nullptr); 2216 if (gdb::option::complete_options 2217 (tracker, &text, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, group)) 2218 return; 2219 2220 if (*text != '\0') 2221 { 2222 const char *p = skip_to_space (text); 2223 if (*p == '\0') 2224 { 2225 static const char *const backtrace_cmd_qualifier_choices[] = { 2226 "full", "no-filters", "hide", nullptr, 2227 }; 2228 complete_on_enum (tracker, backtrace_cmd_qualifier_choices, 2229 text, text); 2230 2231 if (tracker.have_completions ()) 2232 return; 2233 } 2234 else 2235 { 2236 const char *cmd = parse_backtrace_qualifiers (text); 2237 tracker.advance_custom_word_point_by (cmd - text); 2238 text = cmd; 2239 } 2240 } 2241 2242 const char *word = advance_to_expression_complete_word_point (tracker, text); 2243 expression_completer (ignore, tracker, text, word); 2244 } 2245 2246 /* Iterate over the local variables of a block B, calling CB with 2247 CB_DATA. */ 2248 2249 static void 2250 iterate_over_block_locals (const struct block *b, 2251 iterate_over_block_arg_local_vars_cb cb, 2252 void *cb_data) 2253 { 2254 struct block_iterator iter; 2255 struct symbol *sym; 2256 2257 ALL_BLOCK_SYMBOLS (b, iter, sym) 2258 { 2259 switch (SYMBOL_CLASS (sym)) 2260 { 2261 case LOC_CONST: 2262 case LOC_LOCAL: 2263 case LOC_REGISTER: 2264 case LOC_STATIC: 2265 case LOC_COMPUTED: 2266 case LOC_OPTIMIZED_OUT: 2267 if (SYMBOL_IS_ARGUMENT (sym)) 2268 break; 2269 if (SYMBOL_DOMAIN (sym) == COMMON_BLOCK_DOMAIN) 2270 break; 2271 (*cb) (sym->print_name (), sym, cb_data); 2272 break; 2273 2274 default: 2275 /* Ignore symbols which are not locals. */ 2276 break; 2277 } 2278 } 2279 } 2280 2281 /* Iterate over all the local variables in block B, including all its 2282 superblocks, stopping when the top-level block is reached. */ 2283 2284 void 2285 iterate_over_block_local_vars (const struct block *block, 2286 iterate_over_block_arg_local_vars_cb cb, 2287 void *cb_data) 2288 { 2289 while (block) 2290 { 2291 iterate_over_block_locals (block, cb, cb_data); 2292 /* After handling the function's top-level block, stop. Don't 2293 continue to its superblock, the block of per-file 2294 symbols. */ 2295 if (BLOCK_FUNCTION (block)) 2296 break; 2297 block = BLOCK_SUPERBLOCK (block); 2298 } 2299 } 2300 2301 /* Data to be passed around in the calls to the locals and args 2302 iterators. */ 2303 2304 struct print_variable_and_value_data 2305 { 2306 gdb::optional<compiled_regex> preg; 2307 gdb::optional<compiled_regex> treg; 2308 struct frame_id frame_id; 2309 int num_tabs; 2310 struct ui_file *stream; 2311 int values_printed; 2312 }; 2313 2314 /* The callback for the locals and args iterators. */ 2315 2316 static void 2317 do_print_variable_and_value (const char *print_name, 2318 struct symbol *sym, 2319 void *cb_data) 2320 { 2321 struct print_variable_and_value_data *p 2322 = (struct print_variable_and_value_data *) cb_data; 2323 struct frame_info *frame; 2324 2325 if (p->preg.has_value () 2326 && p->preg->exec (sym->natural_name (), 0, NULL, 0) != 0) 2327 return; 2328 if (p->treg.has_value () 2329 && !treg_matches_sym_type_name (*p->treg, sym)) 2330 return; 2331 2332 frame = frame_find_by_id (p->frame_id); 2333 if (frame == NULL) 2334 { 2335 warning (_("Unable to restore previously selected frame.")); 2336 return; 2337 } 2338 2339 print_variable_and_value (print_name, sym, frame, p->stream, p->num_tabs); 2340 2341 /* print_variable_and_value invalidates FRAME. */ 2342 frame = NULL; 2343 2344 p->values_printed = 1; 2345 } 2346 2347 /* Prepares the regular expression REG from REGEXP. 2348 If REGEXP is NULL, it results in an empty regular expression. */ 2349 2350 static void 2351 prepare_reg (const char *regexp, gdb::optional<compiled_regex> *reg) 2352 { 2353 if (regexp != NULL) 2354 { 2355 int cflags = REG_NOSUB | (case_sensitivity == case_sensitive_off 2356 ? REG_ICASE : 0); 2357 reg->emplace (regexp, cflags, _("Invalid regexp")); 2358 } 2359 else 2360 reg->reset (); 2361 } 2362 2363 /* Print all variables from the innermost up to the function block of FRAME. 2364 Print them with values to STREAM indented by NUM_TABS. 2365 If REGEXP is not NULL, only print local variables whose name 2366 matches REGEXP. 2367 If T_REGEXP is not NULL, only print local variables whose type 2368 matches T_REGEXP. 2369 If no local variables have been printed and !QUIET, prints a message 2370 explaining why no local variables could be printed. 2371 2372 This function will invalidate FRAME. */ 2373 2374 static void 2375 print_frame_local_vars (struct frame_info *frame, 2376 bool quiet, 2377 const char *regexp, const char *t_regexp, 2378 int num_tabs, struct ui_file *stream) 2379 { 2380 struct print_variable_and_value_data cb_data; 2381 const struct block *block; 2382 CORE_ADDR pc; 2383 2384 if (!get_frame_pc_if_available (frame, &pc)) 2385 { 2386 if (!quiet) 2387 fprintf_filtered (stream, 2388 _("PC unavailable, cannot determine locals.\n")); 2389 return; 2390 } 2391 2392 block = get_frame_block (frame, 0); 2393 if (block == 0) 2394 { 2395 if (!quiet) 2396 fprintf_filtered (stream, "No symbol table info available.\n"); 2397 return; 2398 } 2399 2400 prepare_reg (regexp, &cb_data.preg); 2401 prepare_reg (t_regexp, &cb_data.treg); 2402 cb_data.frame_id = get_frame_id (frame); 2403 cb_data.num_tabs = 4 * num_tabs; 2404 cb_data.stream = stream; 2405 cb_data.values_printed = 0; 2406 2407 /* Temporarily change the selected frame to the given FRAME. 2408 This allows routines that rely on the selected frame instead 2409 of being given a frame as parameter to use the correct frame. */ 2410 scoped_restore_selected_frame restore_selected_frame; 2411 select_frame (frame); 2412 2413 iterate_over_block_local_vars (block, 2414 do_print_variable_and_value, 2415 &cb_data); 2416 2417 if (!cb_data.values_printed && !quiet) 2418 { 2419 if (regexp == NULL && t_regexp == NULL) 2420 fprintf_filtered (stream, _("No locals.\n")); 2421 else 2422 fprintf_filtered (stream, _("No matching locals.\n")); 2423 } 2424 } 2425 2426 /* Structure to hold the values of the options used by the 'info 2427 variables' command and other similar commands. These correspond to the 2428 -q and -t options. */ 2429 2430 struct info_print_options 2431 { 2432 bool quiet = false; 2433 char *type_regexp = nullptr; 2434 2435 ~info_print_options () 2436 { 2437 xfree (type_regexp); 2438 } 2439 }; 2440 2441 /* The options used by the 'info locals' and 'info args' commands. */ 2442 2443 static const gdb::option::option_def info_print_options_defs[] = { 2444 gdb::option::boolean_option_def<info_print_options> { 2445 "q", 2446 [] (info_print_options *opt) { return &opt->quiet; }, 2447 nullptr, /* show_cmd_cb */ 2448 nullptr /* set_doc */ 2449 }, 2450 2451 gdb::option::string_option_def<info_print_options> { 2452 "t", 2453 [] (info_print_options *opt) { return &opt->type_regexp; }, 2454 nullptr, /* show_cmd_cb */ 2455 nullptr /* set_doc */ 2456 } 2457 }; 2458 2459 /* Returns the option group used by 'info locals' and 'info args' 2460 commands. */ 2461 2462 static gdb::option::option_def_group 2463 make_info_print_options_def_group (info_print_options *opts) 2464 { 2465 return {{info_print_options_defs}, opts}; 2466 } 2467 2468 /* Command completer for 'info locals' and 'info args'. */ 2469 2470 static void 2471 info_print_command_completer (struct cmd_list_element *ignore, 2472 completion_tracker &tracker, 2473 const char *text, const char * /* word */) 2474 { 2475 const auto group 2476 = make_info_print_options_def_group (nullptr); 2477 if (gdb::option::complete_options 2478 (tracker, &text, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, group)) 2479 return; 2480 2481 const char *word = advance_to_expression_complete_word_point (tracker, text); 2482 symbol_completer (ignore, tracker, text, word); 2483 } 2484 2485 /* Implement the 'info locals' command. */ 2486 2487 void 2488 info_locals_command (const char *args, int from_tty) 2489 { 2490 info_print_options opts; 2491 auto grp = make_info_print_options_def_group (&opts); 2492 gdb::option::process_options 2493 (&args, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, grp); 2494 if (args != nullptr && *args == '\0') 2495 args = nullptr; 2496 2497 print_frame_local_vars (get_selected_frame (_("No frame selected.")), 2498 opts.quiet, args, opts.type_regexp, 2499 0, gdb_stdout); 2500 } 2501 2502 /* Iterate over all the argument variables in block B. */ 2503 2504 void 2505 iterate_over_block_arg_vars (const struct block *b, 2506 iterate_over_block_arg_local_vars_cb cb, 2507 void *cb_data) 2508 { 2509 struct block_iterator iter; 2510 struct symbol *sym, *sym2; 2511 2512 ALL_BLOCK_SYMBOLS (b, iter, sym) 2513 { 2514 /* Don't worry about things which aren't arguments. */ 2515 if (SYMBOL_IS_ARGUMENT (sym)) 2516 { 2517 /* We have to look up the symbol because arguments can have 2518 two entries (one a parameter, one a local) and the one we 2519 want is the local, which lookup_symbol will find for us. 2520 This includes gcc1 (not gcc2) on the sparc when passing a 2521 small structure and gcc2 when the argument type is float 2522 and it is passed as a double and converted to float by 2523 the prologue (in the latter case the type of the LOC_ARG 2524 symbol is double and the type of the LOC_LOCAL symbol is 2525 float). There are also LOC_ARG/LOC_REGISTER pairs which 2526 are not combined in symbol-reading. */ 2527 2528 sym2 = lookup_symbol_search_name (sym->search_name (), 2529 b, VAR_DOMAIN).symbol; 2530 (*cb) (sym->print_name (), sym2, cb_data); 2531 } 2532 } 2533 } 2534 2535 /* Print all argument variables of the function of FRAME. 2536 Print them with values to STREAM. 2537 If REGEXP is not NULL, only print argument variables whose name 2538 matches REGEXP. 2539 If T_REGEXP is not NULL, only print argument variables whose type 2540 matches T_REGEXP. 2541 If no argument variables have been printed and !QUIET, prints a message 2542 explaining why no argument variables could be printed. 2543 2544 This function will invalidate FRAME. */ 2545 2546 static void 2547 print_frame_arg_vars (struct frame_info *frame, 2548 bool quiet, 2549 const char *regexp, const char *t_regexp, 2550 struct ui_file *stream) 2551 { 2552 struct print_variable_and_value_data cb_data; 2553 struct symbol *func; 2554 CORE_ADDR pc; 2555 gdb::optional<compiled_regex> preg; 2556 gdb::optional<compiled_regex> treg; 2557 2558 if (!get_frame_pc_if_available (frame, &pc)) 2559 { 2560 if (!quiet) 2561 fprintf_filtered (stream, 2562 _("PC unavailable, cannot determine args.\n")); 2563 return; 2564 } 2565 2566 func = get_frame_function (frame); 2567 if (func == NULL) 2568 { 2569 if (!quiet) 2570 fprintf_filtered (stream, _("No symbol table info available.\n")); 2571 return; 2572 } 2573 2574 prepare_reg (regexp, &cb_data.preg); 2575 prepare_reg (t_regexp, &cb_data.treg); 2576 cb_data.frame_id = get_frame_id (frame); 2577 cb_data.num_tabs = 0; 2578 cb_data.stream = stream; 2579 cb_data.values_printed = 0; 2580 2581 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func), 2582 do_print_variable_and_value, &cb_data); 2583 2584 /* do_print_variable_and_value invalidates FRAME. */ 2585 frame = NULL; 2586 2587 if (!cb_data.values_printed && !quiet) 2588 { 2589 if (regexp == NULL && t_regexp == NULL) 2590 fprintf_filtered (stream, _("No arguments.\n")); 2591 else 2592 fprintf_filtered (stream, _("No matching arguments.\n")); 2593 } 2594 } 2595 2596 /* Implement the 'info args' command. */ 2597 2598 void 2599 info_args_command (const char *args, int from_tty) 2600 { 2601 info_print_options opts; 2602 auto grp = make_info_print_options_def_group (&opts); 2603 gdb::option::process_options 2604 (&args, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, grp); 2605 if (args != nullptr && *args == '\0') 2606 args = nullptr; 2607 2608 print_frame_arg_vars (get_selected_frame (_("No frame selected.")), 2609 opts.quiet, args, opts.type_regexp, gdb_stdout); 2610 } 2611 2612 /* Return the symbol-block in which the selected frame is executing. 2613 Can return zero under various legitimate circumstances. 2614 2615 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant 2616 code address within the block returned. We use this to decide 2617 which macros are in scope. */ 2618 2619 const struct block * 2620 get_selected_block (CORE_ADDR *addr_in_block) 2621 { 2622 if (!has_stack_frames ()) 2623 return 0; 2624 2625 return get_frame_block (get_selected_frame (NULL), addr_in_block); 2626 } 2627 2628 /* Find a frame a certain number of levels away from FRAME. 2629 LEVEL_OFFSET_PTR points to an int containing the number of levels. 2630 Positive means go to earlier frames (up); negative, the reverse. 2631 The int that contains the number of levels is counted toward 2632 zero as the frames for those levels are found. 2633 If the top or bottom frame is reached, that frame is returned, 2634 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates 2635 how much farther the original request asked to go. */ 2636 2637 struct frame_info * 2638 find_relative_frame (struct frame_info *frame, int *level_offset_ptr) 2639 { 2640 /* Going up is simple: just call get_prev_frame enough times or 2641 until the initial frame is reached. */ 2642 while (*level_offset_ptr > 0) 2643 { 2644 struct frame_info *prev = get_prev_frame (frame); 2645 2646 if (!prev) 2647 break; 2648 (*level_offset_ptr)--; 2649 frame = prev; 2650 } 2651 2652 /* Going down is just as simple. */ 2653 while (*level_offset_ptr < 0) 2654 { 2655 struct frame_info *next = get_next_frame (frame); 2656 2657 if (!next) 2658 break; 2659 (*level_offset_ptr)++; 2660 frame = next; 2661 } 2662 2663 return frame; 2664 } 2665 2666 /* Select the frame up one or COUNT_EXP stack levels from the 2667 previously selected frame, and print it briefly. */ 2668 2669 static void 2670 up_silently_base (const char *count_exp) 2671 { 2672 struct frame_info *frame; 2673 int count = 1; 2674 2675 if (count_exp) 2676 count = parse_and_eval_long (count_exp); 2677 2678 frame = find_relative_frame (get_selected_frame ("No stack."), &count); 2679 if (count != 0 && count_exp == NULL) 2680 error (_("Initial frame selected; you cannot go up.")); 2681 select_frame (frame); 2682 } 2683 2684 static void 2685 up_silently_command (const char *count_exp, int from_tty) 2686 { 2687 up_silently_base (count_exp); 2688 } 2689 2690 static void 2691 up_command (const char *count_exp, int from_tty) 2692 { 2693 up_silently_base (count_exp); 2694 gdb::observers::user_selected_context_changed.notify (USER_SELECTED_FRAME); 2695 } 2696 2697 /* Select the frame down one or COUNT_EXP stack levels from the previously 2698 selected frame, and print it briefly. */ 2699 2700 static void 2701 down_silently_base (const char *count_exp) 2702 { 2703 struct frame_info *frame; 2704 int count = -1; 2705 2706 if (count_exp) 2707 count = -parse_and_eval_long (count_exp); 2708 2709 frame = find_relative_frame (get_selected_frame ("No stack."), &count); 2710 if (count != 0 && count_exp == NULL) 2711 { 2712 /* We only do this if COUNT_EXP is not specified. That way 2713 "down" means to really go down (and let me know if that is 2714 impossible), but "down 9999" can be used to mean go all the 2715 way down without getting an error. */ 2716 2717 error (_("Bottom (innermost) frame selected; you cannot go down.")); 2718 } 2719 2720 select_frame (frame); 2721 } 2722 2723 static void 2724 down_silently_command (const char *count_exp, int from_tty) 2725 { 2726 down_silently_base (count_exp); 2727 } 2728 2729 static void 2730 down_command (const char *count_exp, int from_tty) 2731 { 2732 down_silently_base (count_exp); 2733 gdb::observers::user_selected_context_changed.notify (USER_SELECTED_FRAME); 2734 } 2735 2736 void 2737 return_command (const char *retval_exp, int from_tty) 2738 { 2739 /* Initialize it just to avoid a GCC false warning. */ 2740 enum return_value_convention rv_conv = RETURN_VALUE_STRUCT_CONVENTION; 2741 struct frame_info *thisframe; 2742 struct gdbarch *gdbarch; 2743 struct symbol *thisfun; 2744 struct value *return_value = NULL; 2745 struct value *function = NULL; 2746 const char *query_prefix = ""; 2747 2748 thisframe = get_selected_frame ("No selected frame."); 2749 thisfun = get_frame_function (thisframe); 2750 gdbarch = get_frame_arch (thisframe); 2751 2752 if (get_frame_type (get_current_frame ()) == INLINE_FRAME) 2753 error (_("Can not force return from an inlined function.")); 2754 2755 /* Compute the return value. If the computation triggers an error, 2756 let it bail. If the return type can't be handled, set 2757 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational 2758 message. */ 2759 if (retval_exp) 2760 { 2761 expression_up retval_expr = parse_expression (retval_exp); 2762 struct type *return_type = NULL; 2763 2764 /* Compute the return value. Should the computation fail, this 2765 call throws an error. */ 2766 return_value = evaluate_expression (retval_expr.get ()); 2767 2768 /* Cast return value to the return type of the function. Should 2769 the cast fail, this call throws an error. */ 2770 if (thisfun != NULL) 2771 return_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun)); 2772 if (return_type == NULL) 2773 { 2774 if (retval_expr->elts[0].opcode != UNOP_CAST 2775 && retval_expr->elts[0].opcode != UNOP_CAST_TYPE) 2776 error (_("Return value type not available for selected " 2777 "stack frame.\n" 2778 "Please use an explicit cast of the value to return.")); 2779 return_type = value_type (return_value); 2780 } 2781 return_type = check_typedef (return_type); 2782 return_value = value_cast (return_type, return_value); 2783 2784 /* Make sure the value is fully evaluated. It may live in the 2785 stack frame we're about to pop. */ 2786 if (value_lazy (return_value)) 2787 value_fetch_lazy (return_value); 2788 2789 if (thisfun != NULL) 2790 function = read_var_value (thisfun, NULL, thisframe); 2791 2792 rv_conv = RETURN_VALUE_REGISTER_CONVENTION; 2793 if (return_type->code () == TYPE_CODE_VOID) 2794 /* If the return-type is "void", don't try to find the 2795 return-value's location. However, do still evaluate the 2796 return expression so that, even when the expression result 2797 is discarded, side effects such as "return i++" still 2798 occur. */ 2799 return_value = NULL; 2800 else if (thisfun != NULL) 2801 { 2802 rv_conv = struct_return_convention (gdbarch, function, return_type); 2803 if (rv_conv == RETURN_VALUE_STRUCT_CONVENTION 2804 || rv_conv == RETURN_VALUE_ABI_RETURNS_ADDRESS) 2805 { 2806 query_prefix = "The location at which to store the " 2807 "function's return value is unknown.\n" 2808 "If you continue, the return value " 2809 "that you specified will be ignored.\n"; 2810 return_value = NULL; 2811 } 2812 } 2813 } 2814 2815 /* Does an interactive user really want to do this? Include 2816 information, such as how well GDB can handle the return value, in 2817 the query message. */ 2818 if (from_tty) 2819 { 2820 int confirmed; 2821 2822 if (thisfun == NULL) 2823 confirmed = query (_("%sMake selected stack frame return now? "), 2824 query_prefix); 2825 else 2826 { 2827 if (TYPE_NO_RETURN (thisfun->type)) 2828 warning (_("Function does not return normally to caller.")); 2829 confirmed = query (_("%sMake %s return now? "), query_prefix, 2830 thisfun->print_name ()); 2831 } 2832 if (!confirmed) 2833 error (_("Not confirmed")); 2834 } 2835 2836 /* Discard the selected frame and all frames inner-to it. */ 2837 frame_pop (get_selected_frame (NULL)); 2838 2839 /* Store RETURN_VALUE in the just-returned register set. */ 2840 if (return_value != NULL) 2841 { 2842 struct type *return_type = value_type (return_value); 2843 struct gdbarch *cache_arch = get_current_regcache ()->arch (); 2844 2845 gdb_assert (rv_conv != RETURN_VALUE_STRUCT_CONVENTION 2846 && rv_conv != RETURN_VALUE_ABI_RETURNS_ADDRESS); 2847 gdbarch_return_value (cache_arch, function, return_type, 2848 get_current_regcache (), NULL /*read*/, 2849 value_contents (return_value) /*write*/); 2850 } 2851 2852 /* If we are at the end of a call dummy now, pop the dummy frame 2853 too. */ 2854 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME) 2855 frame_pop (get_current_frame ()); 2856 2857 select_frame (get_current_frame ()); 2858 /* If interactive, print the frame that is now current. */ 2859 if (from_tty) 2860 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1); 2861 } 2862 2863 /* Find the most inner frame in the current stack for a function called 2864 FUNCTION_NAME. If no matching frame is found return NULL. */ 2865 2866 static struct frame_info * 2867 find_frame_for_function (const char *function_name) 2868 { 2869 /* Used to hold the lower and upper addresses for each of the 2870 SYMTAB_AND_LINEs found for functions matching FUNCTION_NAME. */ 2871 struct function_bounds 2872 { 2873 CORE_ADDR low, high; 2874 }; 2875 struct frame_info *frame; 2876 bool found = false; 2877 int level = 1; 2878 2879 gdb_assert (function_name != NULL); 2880 2881 frame = get_current_frame (); 2882 std::vector<symtab_and_line> sals 2883 = decode_line_with_current_source (function_name, 2884 DECODE_LINE_FUNFIRSTLINE); 2885 gdb::def_vector<function_bounds> func_bounds (sals.size ()); 2886 for (size_t i = 0; i < sals.size (); i++) 2887 { 2888 if (sals[i].pspace != current_program_space) 2889 func_bounds[i].low = func_bounds[i].high = 0; 2890 else if (sals[i].pc == 0 2891 || find_pc_partial_function (sals[i].pc, NULL, 2892 &func_bounds[i].low, 2893 &func_bounds[i].high) == 0) 2894 func_bounds[i].low = func_bounds[i].high = 0; 2895 } 2896 2897 do 2898 { 2899 for (size_t i = 0; (i < sals.size () && !found); i++) 2900 found = (get_frame_pc (frame) >= func_bounds[i].low 2901 && get_frame_pc (frame) < func_bounds[i].high); 2902 if (!found) 2903 { 2904 level = 1; 2905 frame = find_relative_frame (frame, &level); 2906 } 2907 } 2908 while (!found && level == 0); 2909 2910 if (!found) 2911 frame = NULL; 2912 2913 return frame; 2914 } 2915 2916 /* Implements the dbx 'func' command. */ 2917 2918 static void 2919 func_command (const char *arg, int from_tty) 2920 { 2921 if (arg == NULL) 2922 return; 2923 2924 struct frame_info *frame = find_frame_for_function (arg); 2925 if (frame == NULL) 2926 error (_("'%s' not within current stack frame."), arg); 2927 if (frame != get_selected_frame (NULL)) 2928 { 2929 select_frame (frame); 2930 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1); 2931 } 2932 } 2933 2934 /* The qcs command line flags for the "frame apply" commands. Keep 2935 this in sync with the "thread apply" commands. */ 2936 2937 using qcs_flag_option_def 2938 = gdb::option::flag_option_def<qcs_flags>; 2939 2940 static const gdb::option::option_def fr_qcs_flags_option_defs[] = { 2941 qcs_flag_option_def { 2942 "q", [] (qcs_flags *opt) { return &opt->quiet; }, 2943 N_("Disables printing the frame location information."), 2944 }, 2945 2946 qcs_flag_option_def { 2947 "c", [] (qcs_flags *opt) { return &opt->cont; }, 2948 N_("Print any error raised by COMMAND and continue."), 2949 }, 2950 2951 qcs_flag_option_def { 2952 "s", [] (qcs_flags *opt) { return &opt->silent; }, 2953 N_("Silently ignore any errors or empty output produced by COMMAND."), 2954 }, 2955 }; 2956 2957 /* Create an option_def_group array for all the "frame apply" options, 2958 with FLAGS and SET_BT_OPTS as context. */ 2959 2960 static inline std::array<gdb::option::option_def_group, 2> 2961 make_frame_apply_options_def_group (qcs_flags *flags, 2962 set_backtrace_options *set_bt_opts) 2963 { 2964 return {{ 2965 { {fr_qcs_flags_option_defs}, flags }, 2966 { {set_backtrace_option_defs}, set_bt_opts }, 2967 }}; 2968 } 2969 2970 /* Apply a GDB command to all stack frames, or a set of identified frames, 2971 or innermost COUNT frames. 2972 With a negative COUNT, apply command on outermost -COUNT frames. 2973 2974 frame apply 3 info frame Apply 'info frame' to frames 0, 1, 2 2975 frame apply -3 info frame Apply 'info frame' to outermost 3 frames. 2976 frame apply all x/i $pc Apply 'x/i $pc' cmd to all frames. 2977 frame apply all -s p local_var_no_idea_in_which_frame 2978 If a frame has a local variable called 2979 local_var_no_idea_in_which_frame, print frame 2980 and value of local_var_no_idea_in_which_frame. 2981 frame apply all -s -q p local_var_no_idea_in_which_frame 2982 Same as before, but only print the variable value. 2983 frame apply level 2-5 0 4-7 -s p i = i + 1 2984 Adds 1 to the variable i in the specified frames. 2985 Note that i will be incremented twice in 2986 frames 4 and 5. */ 2987 2988 /* Apply a GDB command to COUNT stack frames, starting at TRAILING. 2989 CMD starts with 0 or more qcs flags followed by the GDB command to apply. 2990 COUNT -1 means all frames starting at TRAILING. WHICH_COMMAND is used 2991 for error messages. */ 2992 2993 static void 2994 frame_apply_command_count (const char *which_command, 2995 const char *cmd, int from_tty, 2996 struct frame_info *trailing, int count) 2997 { 2998 qcs_flags flags; 2999 set_backtrace_options set_bt_opts = user_set_backtrace_options; 3000 3001 auto group = make_frame_apply_options_def_group (&flags, &set_bt_opts); 3002 gdb::option::process_options 3003 (&cmd, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, group); 3004 3005 validate_flags_qcs (which_command, &flags); 3006 3007 if (cmd == NULL || *cmd == '\0') 3008 error (_("Please specify a command to apply on the selected frames")); 3009 3010 /* The below will restore the current inferior/thread/frame. 3011 Usually, only the frame is effectively to be restored. 3012 But in case CMD switches of inferior/thread, better restore 3013 these also. */ 3014 scoped_restore_current_thread restore_thread; 3015 3016 /* These options are handled quite deep in the unwind machinery, so 3017 we get to pass them down by swapping globals. */ 3018 scoped_restore restore_set_backtrace_options 3019 = make_scoped_restore (&user_set_backtrace_options, set_bt_opts); 3020 3021 for (frame_info *fi = trailing; fi && count--; fi = get_prev_frame (fi)) 3022 { 3023 QUIT; 3024 3025 select_frame (fi); 3026 try 3027 { 3028 std::string cmd_result; 3029 { 3030 /* In case CMD switches of inferior/thread/frame, the below 3031 restores the inferior/thread/frame. FI can then be 3032 set to the selected frame. */ 3033 scoped_restore_current_thread restore_fi_current_frame; 3034 3035 cmd_result = execute_command_to_string 3036 (cmd, from_tty, gdb_stdout->term_out ()); 3037 } 3038 fi = get_selected_frame (_("frame apply " 3039 "unable to get selected frame.")); 3040 if (!flags.silent || cmd_result.length () > 0) 3041 { 3042 if (!flags.quiet) 3043 print_stack_frame (fi, 1, LOCATION, 0); 3044 printf_filtered ("%s", cmd_result.c_str ()); 3045 } 3046 } 3047 catch (const gdb_exception_error &ex) 3048 { 3049 fi = get_selected_frame (_("frame apply " 3050 "unable to get selected frame.")); 3051 if (!flags.silent) 3052 { 3053 if (!flags.quiet) 3054 print_stack_frame (fi, 1, LOCATION, 0); 3055 if (flags.cont) 3056 printf_filtered ("%s\n", ex.what ()); 3057 else 3058 throw; 3059 } 3060 } 3061 } 3062 } 3063 3064 /* Completer for the "frame apply ..." commands. */ 3065 3066 static void 3067 frame_apply_completer (completion_tracker &tracker, const char *text) 3068 { 3069 const auto group = make_frame_apply_options_def_group (nullptr, nullptr); 3070 if (gdb::option::complete_options 3071 (tracker, &text, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, group)) 3072 return; 3073 3074 complete_nested_command_line (tracker, text); 3075 } 3076 3077 /* Completer for the "frame apply" commands. */ 3078 3079 static void 3080 frame_apply_level_cmd_completer (struct cmd_list_element *ignore, 3081 completion_tracker &tracker, 3082 const char *text, const char */*word*/) 3083 { 3084 /* Do this explicitly because there's an early return below. */ 3085 tracker.set_use_custom_word_point (true); 3086 3087 number_or_range_parser levels (text); 3088 3089 /* Skip the LEVEL list to find the options and command args. */ 3090 try 3091 { 3092 while (!levels.finished ()) 3093 { 3094 /* Call for effect. */ 3095 levels.get_number (); 3096 3097 if (levels.in_range ()) 3098 levels.skip_range (); 3099 } 3100 } 3101 catch (const gdb_exception_error &ex) 3102 { 3103 /* get_number throws if it parses a negative number, for 3104 example. But a seemingly negative number may be the start of 3105 an option instead. */ 3106 } 3107 3108 const char *cmd = levels.cur_tok (); 3109 3110 if (cmd == text) 3111 { 3112 /* No level list yet. */ 3113 return; 3114 } 3115 3116 /* Check if we're past a valid LEVEL already. */ 3117 if (levels.finished () 3118 && cmd > text && !isspace (cmd[-1])) 3119 return; 3120 3121 /* We're past LEVELs, advance word point. */ 3122 tracker.advance_custom_word_point_by (cmd - text); 3123 text = cmd; 3124 3125 frame_apply_completer (tracker, text); 3126 } 3127 3128 /* Completer for the "frame apply all" command. */ 3129 3130 void 3131 frame_apply_all_cmd_completer (struct cmd_list_element *ignore, 3132 completion_tracker &tracker, 3133 const char *text, const char */*word*/) 3134 { 3135 frame_apply_completer (tracker, text); 3136 } 3137 3138 /* Completer for the "frame apply COUNT" command. */ 3139 3140 static void 3141 frame_apply_cmd_completer (struct cmd_list_element *ignore, 3142 completion_tracker &tracker, 3143 const char *text, const char */*word*/) 3144 { 3145 const char *cmd = text; 3146 3147 int count = get_number_trailer (&cmd, 0); 3148 if (count == 0) 3149 return; 3150 3151 /* Check if we're past a valid COUNT already. */ 3152 if (cmd > text && !isspace (cmd[-1])) 3153 return; 3154 3155 /* We're past COUNT, advance word point. */ 3156 tracker.advance_custom_word_point_by (cmd - text); 3157 text = cmd; 3158 3159 frame_apply_completer (tracker, text); 3160 } 3161 3162 /* Implementation of the "frame apply level" command. */ 3163 3164 static void 3165 frame_apply_level_command (const char *cmd, int from_tty) 3166 { 3167 if (!target_has_stack) 3168 error (_("No stack.")); 3169 3170 bool level_found = false; 3171 const char *levels_str = cmd; 3172 number_or_range_parser levels (levels_str); 3173 3174 /* Skip the LEVEL list to find the flags and command args. */ 3175 while (!levels.finished ()) 3176 { 3177 /* Call for effect. */ 3178 levels.get_number (); 3179 3180 level_found = true; 3181 if (levels.in_range ()) 3182 levels.skip_range (); 3183 } 3184 3185 if (!level_found) 3186 error (_("Missing or invalid LEVEL... argument")); 3187 3188 cmd = levels.cur_tok (); 3189 3190 /* Redo the LEVELS parsing, but applying COMMAND. */ 3191 levels.init (levels_str); 3192 while (!levels.finished ()) 3193 { 3194 const int level_beg = levels.get_number (); 3195 int n_frames; 3196 3197 if (levels.in_range ()) 3198 { 3199 n_frames = levels.end_value () - level_beg + 1; 3200 levels.skip_range (); 3201 } 3202 else 3203 n_frames = 1; 3204 3205 frame_apply_command_count ("frame apply level", cmd, from_tty, 3206 leading_innermost_frame (level_beg), n_frames); 3207 } 3208 } 3209 3210 /* Implementation of the "frame apply all" command. */ 3211 3212 static void 3213 frame_apply_all_command (const char *cmd, int from_tty) 3214 { 3215 if (!target_has_stack) 3216 error (_("No stack.")); 3217 3218 frame_apply_command_count ("frame apply all", cmd, from_tty, 3219 get_current_frame (), INT_MAX); 3220 } 3221 3222 /* Implementation of the "frame apply" command. */ 3223 3224 static void 3225 frame_apply_command (const char* cmd, int from_tty) 3226 { 3227 int count; 3228 struct frame_info *trailing; 3229 3230 if (!target_has_stack) 3231 error (_("No stack.")); 3232 3233 if (cmd == NULL) 3234 error (_("Missing COUNT argument.")); 3235 count = get_number_trailer (&cmd, 0); 3236 if (count == 0) 3237 error (_("Invalid COUNT argument.")); 3238 3239 if (count < 0) 3240 { 3241 trailing = trailing_outermost_frame (-count); 3242 count = -1; 3243 } 3244 else 3245 trailing = get_current_frame (); 3246 3247 frame_apply_command_count ("frame apply", cmd, from_tty, 3248 trailing, count); 3249 } 3250 3251 /* Implementation of the "faas" command. */ 3252 3253 static void 3254 faas_command (const char *cmd, int from_tty) 3255 { 3256 if (cmd == NULL || *cmd == '\0') 3257 error (_("Please specify a command to apply on all frames")); 3258 std::string expanded = std::string ("frame apply all -s ") + cmd; 3259 execute_command (expanded.c_str (), from_tty); 3260 } 3261 3262 3263 /* Find inner-mode frame with frame address ADDRESS. Return NULL if no 3264 matching frame can be found. */ 3265 3266 static struct frame_info * 3267 find_frame_for_address (CORE_ADDR address) 3268 { 3269 struct frame_id id; 3270 struct frame_info *fid; 3271 3272 id = frame_id_build_wild (address); 3273 3274 /* If (s)he specifies the frame with an address, he deserves 3275 what (s)he gets. Still, give the highest one that matches. 3276 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't 3277 know). */ 3278 for (fid = get_current_frame (); 3279 fid != NULL; 3280 fid = get_prev_frame (fid)) 3281 { 3282 if (frame_id_eq (id, get_frame_id (fid))) 3283 { 3284 struct frame_info *prev_frame; 3285 3286 while (1) 3287 { 3288 prev_frame = get_prev_frame (fid); 3289 if (!prev_frame 3290 || !frame_id_eq (id, get_frame_id (prev_frame))) 3291 break; 3292 fid = prev_frame; 3293 } 3294 return fid; 3295 } 3296 } 3297 return NULL; 3298 } 3299 3300 3301 3302 /* Commands with a prefix of `frame apply'. */ 3303 static struct cmd_list_element *frame_apply_cmd_list = NULL; 3304 3305 /* Commands with a prefix of `frame'. */ 3306 static struct cmd_list_element *frame_cmd_list = NULL; 3307 3308 /* Commands with a prefix of `select frame'. */ 3309 static struct cmd_list_element *select_frame_cmd_list = NULL; 3310 3311 /* Commands with a prefix of `info frame'. */ 3312 static struct cmd_list_element *info_frame_cmd_list = NULL; 3313 3314 void _initialize_stack (); 3315 void 3316 _initialize_stack () 3317 { 3318 struct cmd_list_element *cmd; 3319 3320 add_com ("return", class_stack, return_command, _("\ 3321 Make selected stack frame return to its caller.\n\ 3322 Control remains in the debugger, but when you continue\n\ 3323 execution will resume in the frame above the one now selected.\n\ 3324 If an argument is given, it is an expression for the value to return.")); 3325 3326 add_com ("up", class_stack, up_command, _("\ 3327 Select and print stack frame that called this one.\n\ 3328 An argument says how many frames up to go.")); 3329 add_com ("up-silently", class_support, up_silently_command, _("\ 3330 Same as the `up' command, but does not print anything.\n\ 3331 This is useful in command scripts.")); 3332 3333 add_com ("down", class_stack, down_command, _("\ 3334 Select and print stack frame called by this one.\n\ 3335 An argument says how many frames down to go.")); 3336 add_com_alias ("do", "down", class_stack, 1); 3337 add_com_alias ("dow", "down", class_stack, 1); 3338 add_com ("down-silently", class_support, down_silently_command, _("\ 3339 Same as the `down' command, but does not print anything.\n\ 3340 This is useful in command scripts.")); 3341 3342 add_prefix_cmd ("frame", class_stack, 3343 &frame_cmd.base_command, _("\ 3344 Select and print a stack frame.\n\ 3345 With no argument, print the selected stack frame. (See also \"info frame\").\n\ 3346 A single numerical argument specifies the frame to select."), 3347 &frame_cmd_list, "frame ", 1, &cmdlist); 3348 add_com_alias ("f", "frame", class_stack, 1); 3349 3350 #define FRAME_APPLY_OPTION_HELP "\ 3351 Prints the frame location information followed by COMMAND output.\n\ 3352 \n\ 3353 By default, an error raised during the execution of COMMAND\n\ 3354 aborts \"frame apply\".\n\ 3355 \n\ 3356 Options:\n\ 3357 %OPTIONS%" 3358 3359 const auto frame_apply_opts 3360 = make_frame_apply_options_def_group (nullptr, nullptr); 3361 3362 static std::string frame_apply_cmd_help = gdb::option::build_help (_("\ 3363 Apply a command to a number of frames.\n\ 3364 Usage: frame apply COUNT [OPTION]... COMMAND\n\ 3365 With a negative COUNT argument, applies the command on outermost -COUNT frames.\n" 3366 FRAME_APPLY_OPTION_HELP), 3367 frame_apply_opts); 3368 3369 cmd = add_prefix_cmd ("apply", class_stack, frame_apply_command, 3370 frame_apply_cmd_help.c_str (), 3371 &frame_apply_cmd_list, "frame apply ", 1, 3372 &frame_cmd_list); 3373 set_cmd_completer_handle_brkchars (cmd, frame_apply_cmd_completer); 3374 3375 static std::string frame_apply_all_cmd_help = gdb::option::build_help (_("\ 3376 Apply a command to all frames.\n\ 3377 \n\ 3378 Usage: frame apply all [OPTION]... COMMAND\n" 3379 FRAME_APPLY_OPTION_HELP), 3380 frame_apply_opts); 3381 3382 cmd = add_cmd ("all", class_stack, frame_apply_all_command, 3383 frame_apply_all_cmd_help.c_str (), 3384 &frame_apply_cmd_list); 3385 set_cmd_completer_handle_brkchars (cmd, frame_apply_all_cmd_completer); 3386 3387 static std::string frame_apply_level_cmd_help = gdb::option::build_help (_("\ 3388 Apply a command to a list of frames.\n\ 3389 \n\ 3390 Usage: frame apply level LEVEL... [OPTION]... COMMAND\n\ 3391 LEVEL is a space-separated list of levels of frames to apply COMMAND on.\n" 3392 FRAME_APPLY_OPTION_HELP), 3393 frame_apply_opts); 3394 3395 cmd = add_cmd ("level", class_stack, frame_apply_level_command, 3396 frame_apply_level_cmd_help.c_str (), 3397 &frame_apply_cmd_list); 3398 set_cmd_completer_handle_brkchars (cmd, frame_apply_level_cmd_completer); 3399 3400 cmd = add_com ("faas", class_stack, faas_command, _("\ 3401 Apply a command to all frames (ignoring errors and empty output).\n\ 3402 Usage: faas [OPTION]... COMMAND\n\ 3403 shortcut for 'frame apply all -s [OPTION]... COMMAND'\n\ 3404 See \"help frame apply all\" for available options.")); 3405 set_cmd_completer_handle_brkchars (cmd, frame_apply_all_cmd_completer); 3406 3407 add_cmd ("address", class_stack, &frame_cmd.address, 3408 _("\ 3409 Select and print a stack frame by stack address.\n\ 3410 \n\ 3411 Usage: frame address STACK-ADDRESS"), 3412 &frame_cmd_list); 3413 3414 add_cmd ("view", class_stack, &frame_cmd.view, 3415 _("\ 3416 View a stack frame that might be outside the current backtrace.\n\ 3417 \n\ 3418 Usage: frame view STACK-ADDRESS\n\ 3419 frame view STACK-ADDRESS PC-ADDRESS"), 3420 &frame_cmd_list); 3421 3422 cmd = add_cmd ("function", class_stack, &frame_cmd.function, 3423 _("\ 3424 Select and print a stack frame by function name.\n\ 3425 \n\ 3426 Usage: frame function NAME\n\ 3427 \n\ 3428 The innermost frame that visited function NAME is selected."), 3429 &frame_cmd_list); 3430 set_cmd_completer (cmd, frame_selection_by_function_completer); 3431 3432 3433 add_cmd ("level", class_stack, &frame_cmd.level, 3434 _("\ 3435 Select and print a stack frame by level.\n\ 3436 \n\ 3437 Usage: frame level LEVEL"), 3438 &frame_cmd_list); 3439 3440 cmd = add_prefix_cmd_suppress_notification ("select-frame", class_stack, 3441 &select_frame_cmd.base_command, _("\ 3442 Select a stack frame without printing anything.\n\ 3443 A single numerical argument specifies the frame to select."), 3444 &select_frame_cmd_list, "select-frame ", 1, &cmdlist, 3445 &cli_suppress_notification.user_selected_context); 3446 3447 add_cmd_suppress_notification ("address", class_stack, 3448 &select_frame_cmd.address, _("\ 3449 Select a stack frame by stack address.\n\ 3450 \n\ 3451 Usage: select-frame address STACK-ADDRESS"), 3452 &select_frame_cmd_list, 3453 &cli_suppress_notification.user_selected_context); 3454 3455 3456 add_cmd_suppress_notification ("view", class_stack, 3457 &select_frame_cmd.view, _("\ 3458 Select a stack frame that might be outside the current backtrace.\n\ 3459 \n\ 3460 Usage: select-frame view STACK-ADDRESS\n\ 3461 select-frame view STACK-ADDRESS PC-ADDRESS"), 3462 &select_frame_cmd_list, 3463 &cli_suppress_notification.user_selected_context); 3464 3465 cmd = add_cmd_suppress_notification ("function", class_stack, 3466 &select_frame_cmd.function, _("\ 3467 Select a stack frame by function name.\n\ 3468 \n\ 3469 Usage: select-frame function NAME"), 3470 &select_frame_cmd_list, 3471 &cli_suppress_notification.user_selected_context); 3472 set_cmd_completer (cmd, frame_selection_by_function_completer); 3473 3474 add_cmd_suppress_notification ("level", class_stack, 3475 &select_frame_cmd.level, _("\ 3476 Select a stack frame by level.\n\ 3477 \n\ 3478 Usage: select-frame level LEVEL"), 3479 &select_frame_cmd_list, 3480 &cli_suppress_notification.user_selected_context); 3481 3482 const auto backtrace_opts 3483 = make_backtrace_options_def_group (nullptr, nullptr, nullptr); 3484 3485 static std::string backtrace_help 3486 = gdb::option::build_help (_("\ 3487 Print backtrace of all stack frames, or innermost COUNT frames.\n\ 3488 Usage: backtrace [OPTION]... [QUALIFIER]... [COUNT | -COUNT]\n\ 3489 \n\ 3490 Options:\n\ 3491 %OPTIONS%\n\ 3492 \n\ 3493 For backward compatibility, the following qualifiers are supported:\n\ 3494 \n\ 3495 full - same as -full option.\n\ 3496 no-filters - same as -no-filters option.\n\ 3497 hide - same as -hide.\n\ 3498 \n\ 3499 With a negative COUNT, print outermost -COUNT frames."), 3500 backtrace_opts); 3501 3502 cmd_list_element *c = add_com ("backtrace", class_stack, 3503 backtrace_command, 3504 backtrace_help.c_str ()); 3505 set_cmd_completer_handle_brkchars (c, backtrace_command_completer); 3506 3507 add_com_alias ("bt", "backtrace", class_stack, 0); 3508 3509 add_com_alias ("where", "backtrace", class_stack, 0); 3510 add_info ("stack", backtrace_command, 3511 _("Backtrace of the stack, or innermost COUNT frames.")); 3512 add_info_alias ("s", "stack", 1); 3513 3514 add_prefix_cmd ("frame", class_info, &info_frame_cmd.base_command, 3515 _("All about the selected stack frame.\n\ 3516 With no arguments, displays information about the currently selected stack\n\ 3517 frame. Alternatively a frame specification may be provided (See \"frame\")\n\ 3518 the information is then printed about the specified frame."), 3519 &info_frame_cmd_list, "info frame ", 1, &infolist); 3520 add_info_alias ("f", "frame", 1); 3521 3522 add_cmd ("address", class_stack, &info_frame_cmd.address, 3523 _("\ 3524 Print information about a stack frame selected by stack address.\n\ 3525 \n\ 3526 Usage: info frame address STACK-ADDRESS"), 3527 &info_frame_cmd_list); 3528 3529 add_cmd ("view", class_stack, &info_frame_cmd.view, 3530 _("\ 3531 Print information about a stack frame outside the current backtrace.\n\ 3532 \n\ 3533 Usage: info frame view STACK-ADDRESS\n\ 3534 info frame view STACK-ADDRESS PC-ADDRESS"), 3535 &info_frame_cmd_list); 3536 3537 cmd = add_cmd ("function", class_stack, &info_frame_cmd.function, 3538 _("\ 3539 Print information about a stack frame selected by function name.\n\ 3540 \n\ 3541 Usage: info frame function NAME"), 3542 &info_frame_cmd_list); 3543 set_cmd_completer (cmd, frame_selection_by_function_completer); 3544 3545 add_cmd ("level", class_stack, &info_frame_cmd.level, 3546 _("\ 3547 Print information about a stack frame selected by level.\n\ 3548 \n\ 3549 Usage: info frame level LEVEL"), 3550 &info_frame_cmd_list); 3551 3552 cmd = add_info ("locals", info_locals_command, 3553 info_print_args_help (_("\ 3554 All local variables of current stack frame or those matching REGEXPs.\n\ 3555 Usage: info locals [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\ 3556 Prints the local variables of the current stack frame.\n"), 3557 _("local variables"), 3558 false)); 3559 set_cmd_completer_handle_brkchars (cmd, info_print_command_completer); 3560 cmd = add_info ("args", info_args_command, 3561 info_print_args_help (_("\ 3562 All argument variables of current stack frame or those matching REGEXPs.\n\ 3563 Usage: info args [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\ 3564 Prints the argument variables of the current stack frame.\n"), 3565 _("argument variables"), 3566 false)); 3567 set_cmd_completer_handle_brkchars (cmd, info_print_command_completer); 3568 3569 if (dbx_commands) 3570 add_com ("func", class_stack, func_command, _("\ 3571 Select the stack frame that contains NAME.\n\ 3572 Usage: func NAME")); 3573 3574 /* Install "set print raw frame-arguments", a deprecated spelling of 3575 "set print raw-frame-arguments". */ 3576 cmd = add_setshow_boolean_cmd 3577 ("frame-arguments", no_class, 3578 &user_frame_print_options.print_raw_frame_arguments, 3579 _("\ 3580 Set whether to print frame arguments in raw form."), _("\ 3581 Show whether to print frame arguments in raw form."), _("\ 3582 If set, frame arguments are printed in raw form, bypassing any\n\ 3583 pretty-printers for that value."), 3584 NULL, NULL, 3585 &setprintrawlist, &showprintrawlist); 3586 deprecate_cmd (cmd, "set print raw-frame-arguments"); 3587 3588 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack, 3589 &disassemble_next_line, _("\ 3590 Set whether to disassemble next source line or insn when execution stops."), 3591 _("\ 3592 Show whether to disassemble next source line or insn when execution stops."), 3593 _("\ 3594 If ON, GDB will display disassembly of the next source line, in addition\n\ 3595 to displaying the source line itself. If the next source line cannot\n\ 3596 be displayed (e.g., source is unavailable or there's no line info), GDB\n\ 3597 will display disassembly of next instruction instead of showing the\n\ 3598 source line.\n\ 3599 If AUTO, display disassembly of next instruction only if the source line\n\ 3600 cannot be displayed.\n\ 3601 If OFF (which is the default), never display the disassembly of the next\n\ 3602 source line."), 3603 NULL, 3604 show_disassemble_next_line, 3605 &setlist, &showlist); 3606 disassemble_next_line = AUTO_BOOLEAN_FALSE; 3607 3608 gdb::option::add_setshow_cmds_for_options 3609 (class_stack, &user_frame_print_options, 3610 frame_print_option_defs, &setprintlist, &showprintlist); 3611 } 3612