gdb/
[deliverable/binutils-gdb.git] / gdb / mi / mi-cmd-stack.c
CommitLineData
fb40c209 1/* MI Command Set - stack commands.
7b6bb8da 2 Copyright (C) 2000, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011
6aba47ca 3 Free Software Foundation, Inc.
ab91fdd5 4 Contributed by Cygnus Solutions (a Red Hat company).
fb40c209
AC
5
6 This file is part of GDB.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
a9762ec7 10 the Free Software Foundation; either version 3 of the License, or
fb40c209
AC
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
a9762ec7 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
fb40c209
AC
20
21#include "defs.h"
22#include "target.h"
23#include "frame.h"
24#include "value.h"
25#include "mi-cmds.h"
26#include "ui-out.h"
e88c90f2 27#include "symtab.h"
fe898f56 28#include "block.h"
b9362cc7 29#include "stack.h"
de4f826b 30#include "dictionary.h"
f5ec2042 31#include "gdb_string.h"
d8ca156b 32#include "language.h"
79a45b7d 33#include "valprint.h"
875b4ff5 34#include "exceptions.h"
daf3c977
VP
35
36enum what_to_list { locals, arguments, all };
37
38static void list_args_or_locals (enum what_to_list what,
bdaf8d4a
JK
39 enum print_values values,
40 struct frame_info *fi);
fb40c209
AC
41
42/* Print a list of the stack frames. Args can be none, in which case
43 we want to print the whole backtrace, or a pair of numbers
44 specifying the frame numbers at which to start and stop the
45 display. If the two numbers are equal, a single frame will be
46 displayed. */
ce8f13f8 47void
fb40c209
AC
48mi_cmd_stack_list_frames (char *command, char **argv, int argc)
49{
50 int frame_low;
51 int frame_high;
52 int i;
6ad4a2cf 53 struct cleanup *cleanup_stack;
fb40c209
AC
54 struct frame_info *fi;
55
fb40c209 56 if (argc > 2 || argc == 1)
1b05df00 57 error (_("-stack-list-frames: Usage: [FRAME_LOW FRAME_HIGH]"));
fb40c209
AC
58
59 if (argc == 2)
60 {
61 frame_low = atoi (argv[0]);
62 frame_high = atoi (argv[1]);
63 }
64 else
65 {
66 /* Called with no arguments, it means we want the whole
67 backtrace. */
68 frame_low = -1;
69 frame_high = -1;
70 }
71
72 /* Let's position fi on the frame at which to start the
73 display. Could be the innermost frame if the whole stack needs
74 displaying, or if frame_low is 0. */
75 for (i = 0, fi = get_current_frame ();
76 fi && i < frame_low;
77 i++, fi = get_prev_frame (fi));
78
79 if (fi == NULL)
1b05df00 80 error (_("-stack-list-frames: Not enough frames in stack."));
fb40c209 81
79a45e25 82 cleanup_stack = make_cleanup_ui_out_list_begin_end (current_uiout, "stack");
fb40c209
AC
83
84 /* Now let;s print the frames up to frame_high, or until there are
85 frames in the stack. */
86 for (;
87 fi && (i <= frame_high || frame_high == -1);
88 i++, fi = get_prev_frame (fi))
89 {
90 QUIT;
0faf0076 91 /* Print the location and the address always, even for level 0.
fb40c209 92 args == 0: don't print the arguments. */
0faf0076 93 print_frame_info (fi, 1, LOC_AND_ADDRESS, 0 /* args */ );
fb40c209
AC
94 }
95
6ad4a2cf 96 do_cleanups (cleanup_stack);
fb40c209
AC
97}
98
ce8f13f8 99void
fb40c209
AC
100mi_cmd_stack_info_depth (char *command, char **argv, int argc)
101{
102 int frame_high;
103 int i;
104 struct frame_info *fi;
105
fb40c209 106 if (argc > 1)
1b05df00 107 error (_("-stack-info-depth: Usage: [MAX_DEPTH]"));
fb40c209
AC
108
109 if (argc == 1)
110 frame_high = atoi (argv[0]);
111 else
112 /* Called with no arguments, it means we want the real depth of
113 the stack. */
114 frame_high = -1;
115
116 for (i = 0, fi = get_current_frame ();
117 fi && (i < frame_high || frame_high == -1);
118 i++, fi = get_prev_frame (fi))
119 QUIT;
120
79a45e25 121 ui_out_field_int (current_uiout, "depth", i);
fb40c209
AC
122}
123
8b777f02
VP
124static enum print_values
125parse_print_values (char *name)
126{
127 if (strcmp (name, "0") == 0
128 || strcmp (name, mi_no_values) == 0)
129 return PRINT_NO_VALUES;
130 else if (strcmp (name, "1") == 0
131 || strcmp (name, mi_all_values) == 0)
132 return PRINT_ALL_VALUES;
133 else if (strcmp (name, "2") == 0
134 || strcmp (name, mi_simple_values) == 0)
135 return PRINT_SIMPLE_VALUES;
136 else
137 error (_("Unknown value for PRINT_VALUES: must be: \
1380 or \"%s\", 1 or \"%s\", 2 or \"%s\""),
139 mi_no_values, mi_all_values, mi_simple_values);
140}
141
7a93fb82 142/* Print a list of the locals for the current frame. With argument of
fb40c209
AC
143 0, print only the names, with argument of 1 print also the
144 values. */
ce8f13f8 145void
fb40c209
AC
146mi_cmd_stack_list_locals (char *command, char **argv, int argc)
147{
f5ec2042 148 struct frame_info *frame;
f5ec2042 149
fb40c209 150 if (argc != 1)
1b05df00 151 error (_("-stack-list-locals: Usage: PRINT_VALUES"));
fb40c209 152
b04f3ab4 153 frame = get_selected_frame (NULL);
f5ec2042 154
daf3c977 155 list_args_or_locals (locals, parse_print_values (argv[0]), frame);
fb40c209
AC
156}
157
7a93fb82 158/* Print a list of the arguments for the current frame. With argument
fb40c209
AC
159 of 0, print only the names, with argument of 1 print also the
160 values. */
ce8f13f8 161void
fb40c209
AC
162mi_cmd_stack_list_args (char *command, char **argv, int argc)
163{
164 int frame_low;
165 int frame_high;
166 int i;
167 struct frame_info *fi;
6ad4a2cf 168 struct cleanup *cleanup_stack_args;
8b777f02 169 enum print_values print_values;
79a45e25 170 struct ui_out *uiout = current_uiout;
fb40c209
AC
171
172 if (argc < 1 || argc > 3 || argc == 2)
1b05df00 173 error (_("-stack-list-arguments: Usage: "
9a2b4c1b 174 "PRINT_VALUES [FRAME_LOW FRAME_HIGH]"));
fb40c209
AC
175
176 if (argc == 3)
177 {
178 frame_low = atoi (argv[1]);
179 frame_high = atoi (argv[2]);
180 }
181 else
182 {
183 /* Called with no arguments, it means we want args for the whole
184 backtrace. */
185 frame_low = -1;
186 frame_high = -1;
187 }
188
8b777f02
VP
189 print_values = parse_print_values (argv[0]);
190
fb40c209
AC
191 /* Let's position fi on the frame at which to start the
192 display. Could be the innermost frame if the whole stack needs
193 displaying, or if frame_low is 0. */
194 for (i = 0, fi = get_current_frame ();
195 fi && i < frame_low;
196 i++, fi = get_prev_frame (fi));
197
198 if (fi == NULL)
1b05df00 199 error (_("-stack-list-arguments: Not enough frames in stack."));
fb40c209 200
9a2b4c1b
MS
201 cleanup_stack_args
202 = make_cleanup_ui_out_list_begin_end (uiout, "stack-args");
fb40c209
AC
203
204 /* Now let's print the frames up to frame_high, or until there are
205 frames in the stack. */
206 for (;
207 fi && (i <= frame_high || frame_high == -1);
208 i++, fi = get_prev_frame (fi))
209 {
6ad4a2cf 210 struct cleanup *cleanup_frame;
102040f0 211
fb40c209 212 QUIT;
6ad4a2cf 213 cleanup_frame = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
fb40c209 214 ui_out_field_int (uiout, "level", i);
daf3c977 215 list_args_or_locals (arguments, print_values, fi);
6ad4a2cf 216 do_cleanups (cleanup_frame);
fb40c209
AC
217 }
218
6ad4a2cf 219 do_cleanups (cleanup_stack_args);
fb40c209
AC
220}
221
daf3c977 222/* Print a list of the local variables (including arguments) for the
7a93fb82
VP
223 current frame. ARGC must be 1 and ARGV[0] specify if only the names,
224 or both names and values of the variables must be printed. See
225 parse_print_value for possible values. */
daf3c977
VP
226void
227mi_cmd_stack_list_variables (char *command, char **argv, int argc)
228{
229 struct frame_info *frame;
daf3c977
VP
230
231 if (argc != 1)
232 error (_("Usage: PRINT_VALUES"));
233
7a93fb82 234 frame = get_selected_frame (NULL);
daf3c977 235
7a93fb82 236 list_args_or_locals (all, parse_print_values (argv[0]), frame);
daf3c977
VP
237}
238
239
fb40c209
AC
240/* Print a list of the locals or the arguments for the currently
241 selected frame. If the argument passed is 0, printonly the names
242 of the variables, if an argument of 1 is passed, print the values
243 as well. */
244static void
bdaf8d4a
JK
245list_args_or_locals (enum what_to_list what, enum print_values values,
246 struct frame_info *fi)
fb40c209
AC
247{
248 struct block *block;
249 struct symbol *sym;
de4f826b 250 struct dict_iterator iter;
6ad4a2cf 251 struct cleanup *cleanup_list;
cb0fd152 252 struct ui_stream *stb;
f5ec2042 253 struct type *type;
daf3c977 254 char *name_of_result;
79a45e25 255 struct ui_out *uiout = current_uiout;
fb40c209
AC
256
257 stb = ui_out_stream_new (uiout);
258
ae767bfb 259 block = get_frame_block (fi, 0);
fb40c209 260
daf3c977
VP
261 switch (what)
262 {
263 case locals:
d6fd4674
PA
264 name_of_result = "locals";
265 break;
daf3c977 266 case arguments:
d6fd4674
PA
267 name_of_result = "args";
268 break;
daf3c977 269 case all:
d6fd4674
PA
270 name_of_result = "variables";
271 break;
654e7c1f 272 default:
d6fd4674
PA
273 internal_error (__FILE__, __LINE__,
274 "unexpected what_to_list: %d", (int) what);
daf3c977
VP
275 }
276
277 cleanup_list = make_cleanup_ui_out_list_begin_end (uiout, name_of_result);
fb40c209
AC
278
279 while (block != 0)
280 {
de4f826b 281 ALL_BLOCK_SYMBOLS (block, iter, sym)
fb40c209 282 {
39bf4652
JB
283 int print_me = 0;
284
fb40c209
AC
285 switch (SYMBOL_CLASS (sym))
286 {
287 default:
288 case LOC_UNDEF: /* catches errors */
289 case LOC_CONST: /* constant */
290 case LOC_TYPEDEF: /* local typedef */
291 case LOC_LABEL: /* local label */
292 case LOC_BLOCK: /* local function */
293 case LOC_CONST_BYTES: /* loc. byte seq. */
294 case LOC_UNRESOLVED: /* unresolved static */
295 case LOC_OPTIMIZED_OUT: /* optimized out */
296 print_me = 0;
297 break;
298
299 case LOC_ARG: /* argument */
300 case LOC_REF_ARG: /* reference arg */
fb40c209 301 case LOC_REGPARM_ADDR: /* indirect register arg */
fb40c209 302 case LOC_LOCAL: /* stack local */
fb40c209
AC
303 case LOC_STATIC: /* static */
304 case LOC_REGISTER: /* register */
4cf623b6 305 case LOC_COMPUTED: /* computed location */
daf3c977 306 if (what == all)
fb40c209 307 print_me = 1;
daf3c977
VP
308 else if (what == locals)
309 print_me = !SYMBOL_IS_ARGUMENT (sym);
310 else
311 print_me = SYMBOL_IS_ARGUMENT (sym);
fb40c209
AC
312 break;
313 }
314 if (print_me)
315 {
6ad4a2cf 316 struct cleanup *cleanup_tuple = NULL;
6bb0384f 317 struct symbol *sym2;
9fbcbb40 318 struct value *val;
102040f0 319
7a93fb82 320 if (values != PRINT_NO_VALUES || what == all)
f5ec2042 321 cleanup_tuple =
6ad4a2cf 322 make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
f5ec2042 323 ui_out_field_string (uiout, "name", SYMBOL_PRINT_NAME (sym));
7a93fb82
VP
324 if (what == all && SYMBOL_IS_ARGUMENT (sym))
325 ui_out_field_int (uiout, "arg", 1);
fb40c209 326
daf3c977 327 if (SYMBOL_IS_ARGUMENT (sym))
f5ec2042
NR
328 sym2 = lookup_symbol (SYMBOL_NATURAL_NAME (sym),
329 block, VAR_DOMAIN,
2570f2b7 330 (int *) NULL);
f5ec2042 331 else
2a2d4dc3 332 sym2 = sym;
f5ec2042
NR
333 switch (values)
334 {
335 case PRINT_SIMPLE_VALUES:
336 type = check_typedef (sym2->type);
337 type_print (sym2->type, "", stb->stream, -1);
338 ui_out_field_stream (uiout, "type", stb);
339 if (TYPE_CODE (type) != TYPE_CODE_ARRAY
340 && TYPE_CODE (type) != TYPE_CODE_STRUCT
341 && TYPE_CODE (type) != TYPE_CODE_UNION)
342 {
875b4ff5
PM
343 volatile struct gdb_exception except;
344
345 TRY_CATCH (except, RETURN_MASK_ERROR)
346 {
347 struct value_print_options opts;
348
349 val = read_var_value (sym2, fi);
350 get_raw_print_options (&opts);
351 opts.deref_ref = 1;
352 common_val_print
353 (val, stb->stream, 0, &opts,
354 language_def (SYMBOL_LANGUAGE (sym2)));
355 }
356 if (except.reason < 0)
357 fprintf_filtered (stb->stream,
358 _("<error reading variable: %s>"),
359 except.message);
360
f5ec2042
NR
361 ui_out_field_stream (uiout, "value", stb);
362 }
f5ec2042
NR
363 break;
364 case PRINT_ALL_VALUES:
79a45b7d 365 {
875b4ff5
PM
366 volatile struct gdb_exception except;
367
368 TRY_CATCH (except, RETURN_MASK_ERROR)
369 {
370 struct value_print_options opts;
371
372 val = read_var_value (sym2, fi);
373 get_raw_print_options (&opts);
374 opts.deref_ref = 1;
375 common_val_print
376 (val, stb->stream, 0, &opts,
377 language_def (SYMBOL_LANGUAGE (sym2)));
378 }
379 if (except.reason < 0)
380 fprintf_filtered (stb->stream,
381 _("<error reading variable: %s>"),
382 except.message);
383
79a45b7d 384 ui_out_field_stream (uiout, "value", stb);
79a45b7d 385 }
f5ec2042 386 break;
fb40c209 387 }
7a93fb82
VP
388
389 if (values != PRINT_NO_VALUES || what == all)
390 do_cleanups (cleanup_tuple);
fb40c209
AC
391 }
392 }
393 if (BLOCK_FUNCTION (block))
394 break;
395 else
396 block = BLOCK_SUPERBLOCK (block);
397 }
6ad4a2cf 398 do_cleanups (cleanup_list);
fb40c209
AC
399 ui_out_stream_delete (stb);
400}
401
ce8f13f8 402void
fb40c209
AC
403mi_cmd_stack_select_frame (char *command, char **argv, int argc)
404{
fcf43932 405 if (argc == 0 || argc > 1)
1b05df00 406 error (_("-stack-select-frame: Usage: FRAME_SPEC"));
fb40c209 407
fcf43932 408 select_frame_command (argv[0], 1 /* not used */ );
fb40c209 409}
64fd8944 410
ce8f13f8 411void
64fd8944
NR
412mi_cmd_stack_info_frame (char *command, char **argv, int argc)
413{
414 if (argc > 0)
1b05df00 415 error (_("-stack-info-frame: No arguments required"));
ce8f13f8 416
64fd8944 417 print_frame_info (get_selected_frame (NULL), 1, LOC_AND_ADDRESS, 0);
64fd8944 418}
This page took 0.956262 seconds and 4 git commands to generate.