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