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