GDB (xrefs)
mi-cmd-stack.c
Go to the documentation of this file.
1 /* MI Command Set - stack commands.
2  Copyright (C) 2000-2015 Free Software Foundation, Inc.
3  Contributed by Cygnus Solutions (a Red Hat company).
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 "target.h"
22 #include "frame.h"
23 #include "value.h"
24 #include "mi-cmds.h"
25 #include "ui-out.h"
26 #include "symtab.h"
27 #include "block.h"
28 #include "stack.h"
29 #include "dictionary.h"
30 #include "language.h"
31 #include "valprint.h"
32 #include "utils.h"
33 #include "mi-getopt.h"
34 #include "extension.h"
35 #include <ctype.h>
36 #include "mi-parse.h"
37 
39 
40 static void list_args_or_locals (enum what_to_list what,
41  enum print_values values,
42  struct frame_info *fi,
43  int skip_unavailable);
44 
45 /* True if we want to allow Python-based frame filters. */
46 static int frame_filters = 0;
47 
48 void
49 mi_cmd_enable_frame_filters (char *command, char **argv, int argc)
50 {
51  if (argc != 0)
52  error (_("-enable-frame-filters: no arguments allowed"));
53  frame_filters = 1;
54 }
55 
56 /* Like apply_ext_lang_frame_filter, but take a print_values */
57 
58 static enum ext_lang_bt_status
61  struct ui_out *out,
62  int frame_low, int frame_high)
63 {
64  /* ext_lang_frame_args's MI options are compatible with MI print
65  values. */
66  return apply_ext_lang_frame_filter (frame, flags,
67  (enum ext_lang_frame_args) print_values,
68  out,
69  frame_low, frame_high);
70 }
71 
72 /* Print a list of the stack frames. Args can be none, in which case
73  we want to print the whole backtrace, or a pair of numbers
74  specifying the frame numbers at which to start and stop the
75  display. If the two numbers are equal, a single frame will be
76  displayed. */
77 
78 void
79 mi_cmd_stack_list_frames (char *command, char **argv, int argc)
80 {
81  int frame_low;
82  int frame_high;
83  int i;
84  struct cleanup *cleanup_stack;
85  struct frame_info *fi;
87  int raw_arg = 0;
88  int oind = 0;
89  enum opt
90  {
91  NO_FRAME_FILTERS
92  };
93  static const struct mi_opt opts[] =
94  {
95  {"-no-frame-filters", NO_FRAME_FILTERS, 0},
96  { 0, 0, 0 }
97  };
98 
99  /* Parse arguments. In this instance we are just looking for
100  --no-frame-filters. */
101  while (1)
102  {
103  char *oarg;
104  int opt = mi_getopt ("-stack-list-frames", argc, argv,
105  opts, &oind, &oarg);
106  if (opt < 0)
107  break;
108  switch ((enum opt) opt)
109  {
110  case NO_FRAME_FILTERS:
111  raw_arg = oind;
112  break;
113  }
114  }
115 
116  /* After the last option is parsed, there should either be low -
117  high range, or no further arguments. */
118  if ((argc - oind != 0) && (argc - oind != 2))
119  error (_("-stack-list-frames: Usage: [--no-frame-filters] [FRAME_LOW FRAME_HIGH]"));
120 
121  /* If there is a range, set it. */
122  if (argc - oind == 2)
123  {
124  frame_low = atoi (argv[0 + oind]);
125  frame_high = atoi (argv[1 + oind]);
126  }
127  else
128  {
129  /* Called with no arguments, it means we want the whole
130  backtrace. */
131  frame_low = -1;
132  frame_high = -1;
133  }
134 
135  /* Let's position fi on the frame at which to start the
136  display. Could be the innermost frame if the whole stack needs
137  displaying, or if frame_low is 0. */
138  for (i = 0, fi = get_current_frame ();
139  fi && i < frame_low;
140  i++, fi = get_prev_frame (fi));
141 
142  if (fi == NULL)
143  error (_("-stack-list-frames: Not enough frames in stack."));
144 
145  cleanup_stack = make_cleanup_ui_out_list_begin_end (current_uiout, "stack");
146 
147  if (! raw_arg && frame_filters)
148  {
150  int py_frame_low = frame_low;
151 
152  /* We cannot pass -1 to frame_low, as that would signify a
153  relative backtrace from the tail of the stack. So, in the case
154  of frame_low == -1, assign and increment it. */
155  if (py_frame_low == -1)
156  py_frame_low++;
157 
160  py_frame_low, frame_high);
161  }
162 
163  /* Run the inbuilt backtrace if there are no filters registered, or
164  if "--no-frame-filters" has been specified from the command. */
165  if (! frame_filters || raw_arg || result == EXT_LANG_BT_NO_FILTERS)
166  {
167  /* Now let's print the frames up to frame_high, or until there are
168  frames in the stack. */
169  for (;
170  fi && (i <= frame_high || frame_high == -1);
171  i++, fi = get_prev_frame (fi))
172  {
173  QUIT;
174  /* Print the location and the address always, even for level 0.
175  If args is 0, don't print the arguments. */
176  print_frame_info (fi, 1, LOC_AND_ADDRESS, 0 /* args */, 0);
177  }
178  }
179 
180  do_cleanups (cleanup_stack);
181 }
182 
183 void
184 mi_cmd_stack_info_depth (char *command, char **argv, int argc)
185 {
186  int frame_high;
187  int i;
188  struct frame_info *fi;
189 
190  if (argc > 1)
191  error (_("-stack-info-depth: Usage: [MAX_DEPTH]"));
192 
193  if (argc == 1)
194  frame_high = atoi (argv[0]);
195  else
196  /* Called with no arguments, it means we want the real depth of
197  the stack. */
198  frame_high = -1;
199 
200  for (i = 0, fi = get_current_frame ();
201  fi && (i < frame_high || frame_high == -1);
202  i++, fi = get_prev_frame (fi))
203  QUIT;
204 
205  ui_out_field_int (current_uiout, "depth", i);
206 }
207 
208 /* Print a list of the locals for the current frame. With argument of
209  0, print only the names, with argument of 1 print also the
210  values. */
211 
212 void
213 mi_cmd_stack_list_locals (char *command, char **argv, int argc)
214 {
215  struct frame_info *frame;
216  int raw_arg = 0;
218  int print_value;
219  int oind = 0;
220  int skip_unavailable = 0;
221  int i;
222 
223  if (argc > 1)
224  {
225  int i;
226  enum opt
227  {
228  NO_FRAME_FILTERS,
229  SKIP_UNAVAILABLE,
230  };
231  static const struct mi_opt opts[] =
232  {
233  {"-no-frame-filters", NO_FRAME_FILTERS, 0},
234  {"-skip-unavailable", SKIP_UNAVAILABLE, 0},
235  { 0, 0, 0 }
236  };
237 
238  while (1)
239  {
240  char *oarg;
241  /* Don't parse 'print-values' as an option. */
242  int opt = mi_getopt ("-stack-list-locals", argc - 1, argv,
243  opts, &oind, &oarg);
244 
245  if (opt < 0)
246  break;
247  switch ((enum opt) opt)
248  {
249  case NO_FRAME_FILTERS:
250  raw_arg = oind;
251  case SKIP_UNAVAILABLE:
252  skip_unavailable = 1;
253  break;
254  }
255  }
256  }
257 
258  /* After the last option is parsed, there should be only
259  'print-values'. */
260  if (argc - oind != 1)
261  error (_("-stack-list-locals: Usage: [--no-frame-filters] "
262  "[--skip-unavailable] PRINT_VALUES"));
263 
264  frame = get_selected_frame (NULL);
265  print_value = mi_parse_print_values (argv[oind]);
266 
267  if (! raw_arg && frame_filters)
268  {
270 
271  result = mi_apply_ext_lang_frame_filter (frame, flags, print_value,
272  current_uiout, 0, 0);
273  }
274 
275  /* Run the inbuilt backtrace if there are no filters registered, or
276  if "--no-frame-filters" has been specified from the command. */
277  if (! frame_filters || raw_arg || result == EXT_LANG_BT_NO_FILTERS)
278  {
279  list_args_or_locals (locals, print_value, frame,
280  skip_unavailable);
281  }
282 }
283 
284 /* Print a list of the arguments for the current frame. With argument
285  of 0, print only the names, with argument of 1 print also the
286  values. */
287 
288 void
289 mi_cmd_stack_list_args (char *command, char **argv, int argc)
290 {
291  int frame_low;
292  int frame_high;
293  int i;
294  struct frame_info *fi;
295  struct cleanup *cleanup_stack_args;
297  struct ui_out *uiout = current_uiout;
298  int raw_arg = 0;
299  int oind = 0;
300  int skip_unavailable = 0;
302  enum opt
303  {
304  NO_FRAME_FILTERS,
305  SKIP_UNAVAILABLE,
306  };
307  static const struct mi_opt opts[] =
308  {
309  {"-no-frame-filters", NO_FRAME_FILTERS, 0},
310  {"-skip-unavailable", SKIP_UNAVAILABLE, 0},
311  { 0, 0, 0 }
312  };
313 
314  while (1)
315  {
316  char *oarg;
317  int opt = mi_getopt_allow_unknown ("-stack-list-args", argc, argv,
318  opts, &oind, &oarg);
319 
320  if (opt < 0)
321  break;
322  switch ((enum opt) opt)
323  {
324  case NO_FRAME_FILTERS:
325  raw_arg = oind;
326  break;
327  case SKIP_UNAVAILABLE:
328  skip_unavailable = 1;
329  break;
330  }
331  }
332 
333  if (argc - oind != 1 && argc - oind != 3)
334  error (_("-stack-list-arguments: Usage: " \
335  "[--no-frame-filters] [--skip-unavailable] "
336  "PRINT_VALUES [FRAME_LOW FRAME_HIGH]"));
337 
338  if (argc - oind == 3)
339  {
340  frame_low = atoi (argv[1 + oind]);
341  frame_high = atoi (argv[2 + oind]);
342  }
343  else
344  {
345  /* Called with no arguments, it means we want args for the whole
346  backtrace. */
347  frame_low = -1;
348  frame_high = -1;
349  }
350 
351  print_values = mi_parse_print_values (argv[oind]);
352 
353  /* Let's position fi on the frame at which to start the
354  display. Could be the innermost frame if the whole stack needs
355  displaying, or if frame_low is 0. */
356  for (i = 0, fi = get_current_frame ();
357  fi && i < frame_low;
358  i++, fi = get_prev_frame (fi));
359 
360  if (fi == NULL)
361  error (_("-stack-list-arguments: Not enough frames in stack."));
362 
363  cleanup_stack_args
364  = make_cleanup_ui_out_list_begin_end (uiout, "stack-args");
365 
366  if (! raw_arg && frame_filters)
367  {
368  int flags = PRINT_LEVEL | PRINT_ARGS;
369  int py_frame_low = frame_low;
370 
371  /* We cannot pass -1 to frame_low, as that would signify a
372  relative backtrace from the tail of the stack. So, in the case
373  of frame_low == -1, assign and increment it. */
374  if (py_frame_low == -1)
375  py_frame_low++;
376 
378  print_values, current_uiout,
379  py_frame_low, frame_high);
380  }
381 
382  /* Run the inbuilt backtrace if there are no filters registered, or
383  if "--no-frame-filters" has been specified from the command. */
384  if (! frame_filters || raw_arg || result == EXT_LANG_BT_NO_FILTERS)
385  {
386  /* Now let's print the frames up to frame_high, or until there are
387  frames in the stack. */
388  for (;
389  fi && (i <= frame_high || frame_high == -1);
390  i++, fi = get_prev_frame (fi))
391  {
392  struct cleanup *cleanup_frame;
393 
394  QUIT;
395  cleanup_frame = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
396  ui_out_field_int (uiout, "level", i);
397  list_args_or_locals (arguments, print_values, fi, skip_unavailable);
398  do_cleanups (cleanup_frame);
399  }
400  }
401  do_cleanups (cleanup_stack_args);
402 }
403 
404 /* Print a list of the local variables (including arguments) for the
405  current frame. ARGC must be 1 and ARGV[0] specify if only the names,
406  or both names and values of the variables must be printed. See
407  parse_print_value for possible values. */
408 
409 void
410 mi_cmd_stack_list_variables (char *command, char **argv, int argc)
411 {
412  struct frame_info *frame;
413  int raw_arg = 0;
415  int print_value;
416  int oind = 0;
417  int skip_unavailable = 0;
418 
419  if (argc > 1)
420  {
421  int i;
422  enum opt
423  {
424  NO_FRAME_FILTERS,
425  SKIP_UNAVAILABLE,
426  };
427  static const struct mi_opt opts[] =
428  {
429  {"-no-frame-filters", NO_FRAME_FILTERS, 0},
430  {"-skip-unavailable", SKIP_UNAVAILABLE, 0},
431  { 0, 0, 0 }
432  };
433 
434  while (1)
435  {
436  char *oarg;
437  /* Don't parse 'print-values' as an option. */
438  int opt = mi_getopt ("-stack-list-variables", argc - 1,
439  argv, opts, &oind, &oarg);
440  if (opt < 0)
441  break;
442  switch ((enum opt) opt)
443  {
444  case NO_FRAME_FILTERS:
445  raw_arg = oind;
446  break;
447  case SKIP_UNAVAILABLE:
448  skip_unavailable = 1;
449  break;
450  }
451  }
452  }
453 
454  /* After the last option is parsed, there should be only
455  'print-values'. */
456  if (argc - oind != 1)
457  error (_("-stack-list-variables: Usage: [--no-frame-filters] " \
458  "[--skip-unavailable] PRINT_VALUES"));
459 
460  frame = get_selected_frame (NULL);
461  print_value = mi_parse_print_values (argv[oind]);
462 
463  if (! raw_arg && frame_filters)
464  {
466 
467  result = mi_apply_ext_lang_frame_filter (frame, flags,
468  print_value,
469  current_uiout, 0, 0);
470  }
471 
472  /* Run the inbuilt backtrace if there are no filters registered, or
473  if "--no-frame-filters" has been specified from the command. */
474  if (! frame_filters || raw_arg || result == EXT_LANG_BT_NO_FILTERS)
475  {
476  list_args_or_locals (all, print_value, frame,
477  skip_unavailable);
478  }
479 }
480 
481 /* Print single local or argument. ARG must be already read in. For
482  WHAT and VALUES see list_args_or_locals.
483 
484  Errors are printed as if they would be the parameter value. Use
485  zeroed ARG iff it should not be printed according to VALUES. If
486  SKIP_UNAVAILABLE is true, only print ARG if it is available. */
487 
488 static void
489 list_arg_or_local (const struct frame_arg *arg, enum what_to_list what,
490  enum print_values values, int skip_unavailable)
491 {
492  struct cleanup *old_chain;
493  struct ui_out *uiout = current_uiout;
494  struct ui_file *stb;
495 
496  gdb_assert (!arg->val || !arg->error);
497  gdb_assert ((values == PRINT_NO_VALUES && arg->val == NULL
498  && arg->error == NULL)
499  || values == PRINT_SIMPLE_VALUES
500  || (values == PRINT_ALL_VALUES
501  && (arg->val != NULL || arg->error != NULL)));
504  && (arg->val || arg->error)));
505 
506  if (skip_unavailable && arg->val != NULL
508  /* A scalar object that does not have all bits available is
509  also considered unavailable, because all bits contribute
510  to its representation. */
512  && !value_bytes_available (arg->val,
513  value_embedded_offset (arg->val),
514  TYPE_LENGTH (value_type (arg->val))))))
515  return;
516 
517  stb = mem_fileopen ();
518  old_chain = make_cleanup_ui_file_delete (stb);
519 
520  if (values != PRINT_NO_VALUES || what == all)
522 
523  fputs_filtered (SYMBOL_PRINT_NAME (arg->sym), stb);
525  fputs_filtered ("@entry", stb);
526  ui_out_field_stream (uiout, "name", stb);
527 
528  if (what == all && SYMBOL_IS_ARGUMENT (arg->sym))
529  ui_out_field_int (uiout, "arg", 1);
530 
531  if (values == PRINT_SIMPLE_VALUES)
532  {
533  check_typedef (arg->sym->type);
534  type_print (arg->sym->type, "", stb, -1);
535  ui_out_field_stream (uiout, "type", stb);
536  }
537 
538  if (arg->val || arg->error)
539  {
540  const char *error_message = NULL;
541 
542  if (arg->error)
543  error_message = arg->error;
544  else
545  {
546  TRY
547  {
548  struct value_print_options opts;
549 
551  opts.deref_ref = 1;
552  common_val_print (arg->val, stb, 0, &opts,
553  language_def (SYMBOL_LANGUAGE (arg->sym)));
554  }
555  CATCH (except, RETURN_MASK_ERROR)
556  {
557  error_message = except.message;
558  }
559  END_CATCH
560  }
561  if (error_message != NULL)
562  fprintf_filtered (stb, _("<error reading variable: %s>"),
563  error_message);
564  ui_out_field_stream (uiout, "value", stb);
565  }
566 
567  do_cleanups (old_chain);
568 }
569 
570 /* Print a list of the objects for the frame FI in a certain form,
571  which is determined by VALUES. The objects can be locals,
572  arguments or both, which is determined by WHAT. If SKIP_UNAVAILABLE
573  is true, only print the arguments or local variables whose values
574  are available. */
575 
576 static void
578  struct frame_info *fi, int skip_unavailable)
579 {
580  const struct block *block;
581  struct symbol *sym;
582  struct block_iterator iter;
583  struct cleanup *cleanup_list;
584  struct type *type;
585  char *name_of_result;
586  struct ui_out *uiout = current_uiout;
587 
588  block = get_frame_block (fi, 0);
589 
590  switch (what)
591  {
592  case locals:
593  name_of_result = "locals";
594  break;
595  case arguments:
596  name_of_result = "args";
597  break;
598  case all:
599  name_of_result = "variables";
600  break;
601  default:
602  internal_error (__FILE__, __LINE__,
603  "unexpected what_to_list: %d", (int) what);
604  }
605 
606  cleanup_list = make_cleanup_ui_out_list_begin_end (uiout, name_of_result);
607 
608  while (block != 0)
609  {
610  ALL_BLOCK_SYMBOLS (block, iter, sym)
611  {
612  int print_me = 0;
613 
614  switch (SYMBOL_CLASS (sym))
615  {
616  default:
617  case LOC_UNDEF: /* catches errors */
618  case LOC_CONST: /* constant */
619  case LOC_TYPEDEF: /* local typedef */
620  case LOC_LABEL: /* local label */
621  case LOC_BLOCK: /* local function */
622  case LOC_CONST_BYTES: /* loc. byte seq. */
623  case LOC_UNRESOLVED: /* unresolved static */
624  case LOC_OPTIMIZED_OUT: /* optimized out */
625  print_me = 0;
626  break;
627 
628  case LOC_ARG: /* argument */
629  case LOC_REF_ARG: /* reference arg */
630  case LOC_REGPARM_ADDR: /* indirect register arg */
631  case LOC_LOCAL: /* stack local */
632  case LOC_STATIC: /* static */
633  case LOC_REGISTER: /* register */
634  case LOC_COMPUTED: /* computed location */
635  if (what == all)
636  print_me = 1;
637  else if (what == locals)
638  print_me = !SYMBOL_IS_ARGUMENT (sym);
639  else
640  print_me = SYMBOL_IS_ARGUMENT (sym);
641  break;
642  }
643  if (print_me)
644  {
645  struct symbol *sym2;
646  struct frame_arg arg, entryarg;
647 
648  if (SYMBOL_IS_ARGUMENT (sym))
649  sym2 = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),
650  block, VAR_DOMAIN,
651  NULL);
652  else
653  sym2 = sym;
654  gdb_assert (sym2 != NULL);
655 
656  memset (&arg, 0, sizeof (arg));
657  arg.sym = sym2;
659  memset (&entryarg, 0, sizeof (entryarg));
660  entryarg.sym = sym2;
662 
663  switch (values)
664  {
665  case PRINT_SIMPLE_VALUES:
666  type = check_typedef (sym2->type);
667  if (TYPE_CODE (type) != TYPE_CODE_ARRAY
668  && TYPE_CODE (type) != TYPE_CODE_STRUCT
669  && TYPE_CODE (type) != TYPE_CODE_UNION)
670  {
671  case PRINT_ALL_VALUES:
672  if (SYMBOL_IS_ARGUMENT (sym))
673  read_frame_arg (sym2, fi, &arg, &entryarg);
674  else
675  read_frame_local (sym2, fi, &arg);
676  }
677  break;
678  }
679 
681  list_arg_or_local (&arg, what, values, skip_unavailable);
682  if (entryarg.entry_kind != print_entry_values_no)
683  list_arg_or_local (&entryarg, what, values, skip_unavailable);
684  xfree (arg.error);
685  xfree (entryarg.error);
686  }
687  }
688 
689  if (BLOCK_FUNCTION (block))
690  break;
691  else
692  block = BLOCK_SUPERBLOCK (block);
693  }
694  do_cleanups (cleanup_list);
695 }
696 
697 void
698 mi_cmd_stack_select_frame (char *command, char **argv, int argc)
699 {
700  if (argc == 0 || argc > 1)
701  error (_("-stack-select-frame: Usage: FRAME_SPEC"));
702 
703  select_frame_command (argv[0], 1 /* not used */ );
704 }
705 
706 void
707 mi_cmd_stack_info_frame (char *command, char **argv, int argc)
708 {
709  if (argc > 0)
710  error (_("-stack-info-frame: No arguments allowed"));
711 
713 }
struct frame_info * get_selected_frame(const char *message)
Definition: frame.c:1535
#define SYMBOL_PRINT_NAME(symbol)
Definition: symtab.h:260
static void list_args_or_locals(enum what_to_list what, enum print_values values, struct frame_info *fi, int skip_unavailable)
Definition: mi-cmd-stack.c:577
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
struct frame_info * get_current_frame(void)
Definition: frame.c:1461
struct symbol * sym
Definition: frame.h:734
void mi_cmd_stack_list_args(char *command, char **argv, int argc)
Definition: mi-cmd-stack.c:289
struct value * val
Definition: frame.h:738
void xfree(void *)
Definition: common-utils.c:97
what_to_list
Definition: mi-cmd-stack.c:38
const char * entry_kind
Definition: frame.h:753
struct frame_info * get_prev_frame(struct frame_info *this_frame)
Definition: frame.c:2122
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
#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
void type_print(struct type *type, const char *varstring, struct ui_file *stream, int show)
Definition: typeprint.c:360
void get_no_prettyformat_print_options(struct value_print_options *opts)
Definition: valprint.c:137
#define _(String)
Definition: gdb_locale.h:40
void mi_cmd_stack_list_frames(char *command, char **argv, int argc)
Definition: mi-cmd-stack.c:79
#define END_CATCH
Definition: ui-out.c:99
ext_lang_bt_status
Definition: extension.h:69
#define BLOCK_FUNCTION(bl)
Definition: block.h:118
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
#define TRY
static void list_arg_or_local(const struct frame_arg *arg, enum what_to_list what, enum print_values values, int skip_unavailable)
Definition: mi-cmd-stack.c:489
const char print_entry_values_no[]
Definition: stack.c:68
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2217
int mi_getopt(const char *prefix, int argc, char **argv, const struct mi_opt *opts, int *oind, char **oarg)
Definition: mi-getopt.c:83
#define CATCH(EXCEPTION, MASK)
void print_value(struct value *val, const struct format_data *fmtp)
Definition: printcmd.c:962
void mi_cmd_stack_info_frame(char *command, char **argv, int argc)
Definition: mi-cmd-stack.c:707
struct cleanup * make_cleanup_ui_out_list_begin_end(struct ui_out *uiout, const char *id)
Definition: ui-out.c:459
struct cleanup * make_cleanup_ui_out_tuple_begin_end(struct ui_out *uiout, const char *id)
Definition: ui-out.c:451
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
const struct block * get_frame_block(struct frame_info *frame, CORE_ADDR *addr_in_block)
Definition: blockframe.c:55
ext_lang_frame_args
Definition: extension.h:108
void mi_cmd_stack_info_depth(char *command, char **argv, int argc)
Definition: mi-cmd-stack.c:184
void fputs_filtered(const char *linebuffer, struct ui_file *stream)
Definition: utils.c:2145
void mi_cmd_stack_list_variables(char *command, char **argv, int argc)
Definition: mi-cmd-stack.c:410
Definition: gdbtypes.h:749
#define BLOCK_SUPERBLOCK(bl)
Definition: block.h:119
static const char * type
Definition: language.c:103
#define gdb_assert(expr)
Definition: gdb_assert.h:33
#define SYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:241
void mi_cmd_stack_select_frame(char *command, char **argv, int argc)
Definition: mi-cmd-stack.c:698
struct ui_file * mem_fileopen(void)
Definition: ui-file.c:427
void read_frame_local(struct symbol *sym, struct frame_info *frame, struct frame_arg *argp)
Definition: stack.c:310
int val_print_scalar_type_p(struct type *type)
Definition: valprint.c:275
char * error
Definition: frame.h:742
Definition: block.h:60
void read_frame_arg(struct symbol *sym, struct frame_info *frame, struct frame_arg *argp, struct frame_arg *entryargp)
Definition: stack.c:335
void mi_cmd_enable_frame_filters(char *command, char **argv, int argc)
Definition: mi-cmd-stack.c:49
int mi_getopt_allow_unknown(const char *prefix, int argc, char **argv, const struct mi_opt *opts, int *oind, char **oarg)
Definition: mi-getopt.c:92
struct type * type
Definition: symtab.h:712
const char print_entry_values_only[]
Definition: stack.c:69
struct cleanup * make_cleanup_ui_file_delete(struct ui_file *arg)
Definition: utils.c:237
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1240
static int frame_filters
Definition: mi-cmd-stack.c:46
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
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
#define SYMBOL_LANGUAGE(symbol)
Definition: symtab.h:187
int value_bytes_available(const struct value *value, int offset, int length)
Definition: value.c:352
int value_embedded_offset(struct value *value)
Definition: value.c:1388
struct type * value_type(const struct value *value)
Definition: value.c:1021
static enum ext_lang_bt_status mi_apply_ext_lang_frame_filter(struct frame_info *frame, int flags, enum print_values print_values, struct ui_out *out, int frame_low, int frame_high)
Definition: mi-cmd-stack.c:59
Definition: symtab.h:703
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1237
struct ui_out * current_uiout
Definition: ui-out.c:233
void print_frame_info(struct frame_info *, int print_level, enum print_what print_what, int args, int set_current_sal)
Definition: stack.c:794
#define QUIT
Definition: defs.h:160
enum print_values mi_parse_print_values(const char *name)
Definition: mi-parse.c:405
int value_entirely_unavailable(struct value *value)
Definition: value.c:407
void error(const char *fmt,...)
Definition: errors.c:38
print_values
Definition: mi-cmds.h:25
#define ALL_BLOCK_SYMBOLS(block, iter, sym)
Definition: block.h:333
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
#define SYMBOL_IS_ARGUMENT(symbol)
Definition: symtab.h:795
void mi_cmd_stack_list_locals(char *command, char **argv, int argc)
Definition: mi-cmd-stack.c:213