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