OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [gdb/] [mi/] [mi-cmd-stack.c] - Blame information for rev 833

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* MI Command Set - stack commands.
2
   Copyright (C) 2000, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
3
   Free Software Foundation, Inc.
4
   Contributed by Cygnus Solutions (a Red Hat company).
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
10
   the Free Software Foundation; either version 3 of the License, or
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
19
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
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"
27
#include "symtab.h"
28
#include "block.h"
29
#include "stack.h"
30
#include "dictionary.h"
31
#include "gdb_string.h"
32
#include "language.h"
33
#include "valprint.h"
34
 
35
 
36
enum what_to_list { locals, arguments, all };
37
 
38
static void list_args_or_locals (enum what_to_list what,
39
                                 int values, struct frame_info *fi);
40
 
41
/* Print a list of the stack frames. Args can be none, in which case
42
   we want to print the whole backtrace, or a pair of numbers
43
   specifying the frame numbers at which to start and stop the
44
   display. If the two numbers are equal, a single frame will be
45
   displayed. */
46
void
47
mi_cmd_stack_list_frames (char *command, char **argv, int argc)
48
{
49
  int frame_low;
50
  int frame_high;
51
  int i;
52
  struct cleanup *cleanup_stack;
53
  struct frame_info *fi;
54
 
55
  if (argc > 2 || argc == 1)
56
    error (_("mi_cmd_stack_list_frames: Usage: [FRAME_LOW FRAME_HIGH]"));
57
 
58
  if (argc == 2)
59
    {
60
      frame_low = atoi (argv[0]);
61
      frame_high = atoi (argv[1]);
62
    }
63
  else
64
    {
65
      /* Called with no arguments, it means we want the whole
66
         backtrace. */
67
      frame_low = -1;
68
      frame_high = -1;
69
    }
70
 
71
  /* Let's position fi on the frame at which to start the
72
     display. Could be the innermost frame if the whole stack needs
73
     displaying, or if frame_low is 0. */
74
  for (i = 0, fi = get_current_frame ();
75
       fi && i < frame_low;
76
       i++, fi = get_prev_frame (fi));
77
 
78
  if (fi == NULL)
79
    error (_("mi_cmd_stack_list_frames: Not enough frames in stack."));
80
 
81
  cleanup_stack = make_cleanup_ui_out_list_begin_end (uiout, "stack");
82
 
83
  /* Now let;s print the frames up to frame_high, or until there are
84
     frames in the stack. */
85
  for (;
86
       fi && (i <= frame_high || frame_high == -1);
87
       i++, fi = get_prev_frame (fi))
88
    {
89
      QUIT;
90
      /* Print the location and the address always, even for level 0.
91
         args == 0: don't print the arguments. */
92
      print_frame_info (fi, 1, LOC_AND_ADDRESS, 0 /* args */ );
93
    }
94
 
95
  do_cleanups (cleanup_stack);
96
}
97
 
98
void
99
mi_cmd_stack_info_depth (char *command, char **argv, int argc)
100
{
101
  int frame_high;
102
  int i;
103
  struct frame_info *fi;
104
 
105
  if (argc > 1)
106
    error (_("mi_cmd_stack_info_depth: Usage: [MAX_DEPTH]"));
107
 
108
  if (argc == 1)
109
    frame_high = atoi (argv[0]);
110
  else
111
    /* Called with no arguments, it means we want the real depth of
112
       the stack. */
113
    frame_high = -1;
114
 
115
  for (i = 0, fi = get_current_frame ();
116
       fi && (i < frame_high || frame_high == -1);
117
       i++, fi = get_prev_frame (fi))
118
    QUIT;
119
 
120
  ui_out_field_int (uiout, "depth", i);
121
}
122
 
123
static enum print_values
124
parse_print_values (char *name)
125
{
126
   if (strcmp (name, "0") == 0
127
       || strcmp (name, mi_no_values) == 0)
128
     return PRINT_NO_VALUES;
129
   else if (strcmp (name, "1") == 0
130
            || strcmp (name, mi_all_values) == 0)
131
     return PRINT_ALL_VALUES;
132
   else if (strcmp (name, "2") == 0
133
            || strcmp (name, mi_simple_values) == 0)
134
     return PRINT_SIMPLE_VALUES;
135
   else
136
     error (_("Unknown value for PRINT_VALUES: must be: \
137
 
138
            mi_no_values, mi_all_values, mi_simple_values);
139
}
140
 
141
/* Print a list of the locals for the current frame.  With argument of
142
   0, print only the names, with argument of 1 print also the
143
   values. */
144
void
145
mi_cmd_stack_list_locals (char *command, char **argv, int argc)
146
{
147
  struct frame_info *frame;
148
  enum print_values print_values;
149
 
150
  if (argc != 1)
151
    error (_("mi_cmd_stack_list_locals: Usage: PRINT_VALUES"));
152
 
153
   frame = get_selected_frame (NULL);
154
 
155
   list_args_or_locals (locals, parse_print_values (argv[0]), frame);
156
}
157
 
158
/* Print a list of the arguments for the current frame.  With argument
159
   of 0, print only the names, with argument of 1 print also the
160
   values. */
161
void
162
mi_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;
168
  struct cleanup *cleanup_stack_args;
169
  enum print_values print_values;
170
 
171
  if (argc < 1 || argc > 3 || argc == 2)
172
    error (_("mi_cmd_stack_list_args: Usage: PRINT_VALUES [FRAME_LOW FRAME_HIGH]"));
173
 
174
  if (argc == 3)
175
    {
176
      frame_low = atoi (argv[1]);
177
      frame_high = atoi (argv[2]);
178
    }
179
  else
180
    {
181
      /* Called with no arguments, it means we want args for the whole
182
         backtrace. */
183
      frame_low = -1;
184
      frame_high = -1;
185
    }
186
 
187
  print_values = parse_print_values (argv[0]);
188
 
189
  /* Let's position fi on the frame at which to start the
190
     display. Could be the innermost frame if the whole stack needs
191
     displaying, or if frame_low is 0. */
192
  for (i = 0, fi = get_current_frame ();
193
       fi && i < frame_low;
194
       i++, fi = get_prev_frame (fi));
195
 
196
  if (fi == NULL)
197
    error (_("mi_cmd_stack_list_args: Not enough frames in stack."));
198
 
199
  cleanup_stack_args = make_cleanup_ui_out_list_begin_end (uiout, "stack-args");
200
 
201
  /* Now let's print the frames up to frame_high, or until there are
202
     frames in the stack. */
203
  for (;
204
       fi && (i <= frame_high || frame_high == -1);
205
       i++, fi = get_prev_frame (fi))
206
    {
207
      struct cleanup *cleanup_frame;
208
      QUIT;
209
      cleanup_frame = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
210
      ui_out_field_int (uiout, "level", i);
211
      list_args_or_locals (arguments, print_values, fi);
212
      do_cleanups (cleanup_frame);
213
    }
214
 
215
  do_cleanups (cleanup_stack_args);
216
}
217
 
218
/* Print a list of the local variables (including arguments) for the
219
   current frame.  ARGC must be 1 and ARGV[0] specify if only the names,
220
   or both names and values of the variables must be printed.  See
221
   parse_print_value for possible values.  */
222
void
223
mi_cmd_stack_list_variables (char *command, char **argv, int argc)
224
{
225
  struct frame_info *frame;
226
  enum print_values print_values;
227
 
228
  if (argc != 1)
229
    error (_("Usage: PRINT_VALUES"));
230
 
231
  frame = get_selected_frame (NULL);
232
 
233
  list_args_or_locals (all, parse_print_values (argv[0]), frame);
234
}
235
 
236
 
237
/* Print a list of the locals or the arguments for the currently
238
   selected frame.  If the argument passed is 0, printonly the names
239
   of the variables, if an argument of 1 is passed, print the values
240
   as well. */
241
static void
242
list_args_or_locals (enum what_to_list what, int values, struct frame_info *fi)
243
{
244
  struct block *block;
245
  struct symbol *sym;
246
  struct dict_iterator iter;
247
  int nsyms;
248
  struct cleanup *cleanup_list;
249
  static struct ui_stream *stb = NULL;
250
  struct type *type;
251
  char *name_of_result;
252
 
253
  stb = ui_out_stream_new (uiout);
254
 
255
  block = get_frame_block (fi, 0);
256
 
257
  switch (what)
258
    {
259
    case locals:
260
      name_of_result = "locals";
261
      break;
262
    case arguments:
263
      name_of_result = "args";
264
      break;
265
    case all:
266
      name_of_result = "variables";
267
      break;
268
    default:
269
      internal_error (__FILE__, __LINE__,
270
                      "unexpected what_to_list: %d", (int) what);
271
    }
272
 
273
  cleanup_list = make_cleanup_ui_out_list_begin_end (uiout, name_of_result);
274
 
275
  while (block != 0)
276
    {
277
      ALL_BLOCK_SYMBOLS (block, iter, sym)
278
        {
279
          int print_me = 0;
280
 
281
          switch (SYMBOL_CLASS (sym))
282
            {
283
            default:
284
            case LOC_UNDEF:     /* catches errors        */
285
            case LOC_CONST:     /* constant              */
286
            case LOC_TYPEDEF:   /* local typedef         */
287
            case LOC_LABEL:     /* local label           */
288
            case LOC_BLOCK:     /* local function        */
289
            case LOC_CONST_BYTES:       /* loc. byte seq.        */
290
            case LOC_UNRESOLVED:        /* unresolved static     */
291
            case LOC_OPTIMIZED_OUT:     /* optimized out         */
292
              print_me = 0;
293
              break;
294
 
295
            case LOC_ARG:       /* argument              */
296
            case LOC_REF_ARG:   /* reference arg         */
297
            case LOC_REGPARM_ADDR:      /* indirect register arg */
298
            case LOC_LOCAL:     /* stack local           */
299
            case LOC_STATIC:    /* static                */
300
            case LOC_REGISTER:  /* register              */
301
            case LOC_COMPUTED:  /* computed location     */
302
              if (what == all)
303
                print_me = 1;
304
              else if (what == locals)
305
                print_me = !SYMBOL_IS_ARGUMENT (sym);
306
              else
307
                print_me = SYMBOL_IS_ARGUMENT (sym);
308
              break;
309
            }
310
          if (print_me)
311
            {
312
              struct cleanup *cleanup_tuple = NULL;
313
              struct symbol *sym2;
314
              struct value *val;
315
              if (values != PRINT_NO_VALUES || what == all)
316
                cleanup_tuple =
317
                  make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
318
              ui_out_field_string (uiout, "name", SYMBOL_PRINT_NAME (sym));
319
              if (what == all && SYMBOL_IS_ARGUMENT (sym))
320
                ui_out_field_int (uiout, "arg", 1);
321
 
322
              if (SYMBOL_IS_ARGUMENT (sym))
323
                sym2 = lookup_symbol (SYMBOL_NATURAL_NAME (sym),
324
                                      block, VAR_DOMAIN,
325
                                      (int *) NULL);
326
              else
327
                sym2 = sym;
328
              switch (values)
329
                {
330
                case PRINT_SIMPLE_VALUES:
331
                  type = check_typedef (sym2->type);
332
                  type_print (sym2->type, "", stb->stream, -1);
333
                  ui_out_field_stream (uiout, "type", stb);
334
                  if (TYPE_CODE (type) != TYPE_CODE_ARRAY
335
                      && TYPE_CODE (type) != TYPE_CODE_STRUCT
336
                      && TYPE_CODE (type) != TYPE_CODE_UNION)
337
                    {
338
                      struct value_print_options opts;
339
                      val = read_var_value (sym2, fi);
340
                      get_raw_print_options (&opts);
341
                      opts.deref_ref = 1;
342
                      common_val_print
343
                        (val, stb->stream, 0, &opts,
344
                         language_def (SYMBOL_LANGUAGE (sym2)));
345
                      ui_out_field_stream (uiout, "value", stb);
346
                    }
347
                  break;
348
                case PRINT_ALL_VALUES:
349
                  {
350
                    struct value_print_options opts;
351
                    val = read_var_value (sym2, fi);
352
                    get_raw_print_options (&opts);
353
                    opts.deref_ref = 1;
354
                    common_val_print
355
                      (val, stb->stream, 0, &opts,
356
                       language_def (SYMBOL_LANGUAGE (sym2)));
357
                    ui_out_field_stream (uiout, "value", stb);
358
                  }
359
                  break;
360
                }
361
 
362
              if (values != PRINT_NO_VALUES || what == all)
363
                do_cleanups (cleanup_tuple);
364
            }
365
        }
366
      if (BLOCK_FUNCTION (block))
367
        break;
368
      else
369
        block = BLOCK_SUPERBLOCK (block);
370
    }
371
  do_cleanups (cleanup_list);
372
  ui_out_stream_delete (stb);
373
}
374
 
375
void
376
mi_cmd_stack_select_frame (char *command, char **argv, int argc)
377
{
378
  if (argc == 0 || argc > 1)
379
    error (_("mi_cmd_stack_select_frame: Usage: FRAME_SPEC"));
380
 
381
  select_frame_command (argv[0], 1 /* not used */ );
382
}
383
 
384
void
385
mi_cmd_stack_info_frame (char *command, char **argv, int argc)
386
{
387
  if (argc > 0)
388
    error (_("mi_cmd_stack_info_frame: No arguments required"));
389
 
390
  print_frame_info (get_selected_frame (NULL), 1, LOC_AND_ADDRESS, 0);
391
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.