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