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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [stack.c] - Blame information for rev 157

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* Print and select stack frames for GDB, the GNU debugger.
2
 
3
   Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4
   1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008
5
   Free Software Foundation, Inc.
6
 
7
   This file is part of GDB.
8
 
9
   This program is free software; you can redistribute it and/or modify
10
   it under the terms of the GNU General Public License as published by
11
   the Free Software Foundation; either version 3 of the License, or
12
   (at your option) any later version.
13
 
14
   This program is distributed in the hope that it will be useful,
15
   but WITHOUT ANY WARRANTY; without even the implied warranty of
16
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
   GNU General Public License for more details.
18
 
19
   You should have received a copy of the GNU General Public License
20
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
21
 
22
#include "defs.h"
23
#include "value.h"
24
#include "symtab.h"
25
#include "gdbtypes.h"
26
#include "expression.h"
27
#include "language.h"
28
#include "frame.h"
29
#include "gdbcmd.h"
30
#include "gdbcore.h"
31
#include "target.h"
32
#include "source.h"
33
#include "breakpoint.h"
34
#include "demangle.h"
35
#include "inferior.h"
36
#include "annotate.h"
37
#include "ui-out.h"
38
#include "block.h"
39
#include "stack.h"
40
#include "dictionary.h"
41
#include "exceptions.h"
42
#include "reggroups.h"
43
#include "regcache.h"
44
#include "solib.h"
45
#include "valprint.h"
46
 
47
#include "gdb_assert.h"
48
#include <ctype.h>
49
#include "gdb_string.h"
50
 
51
void (*deprecated_selected_frame_level_changed_hook) (int);
52
 
53
/* The possible choices of "set print frame-arguments, and the value
54
   of this setting.  */
55
 
56
static const char *print_frame_arguments_choices[] =
57
  {"all", "scalars", "none", NULL};
58
static const char *print_frame_arguments = "all";
59
 
60
/* Prototypes for local functions. */
61
 
62
static void print_frame_local_vars (struct frame_info *, int,
63
                                    struct ui_file *);
64
 
65
static void print_frame (struct frame_info *frame, int print_level,
66
                         enum print_what print_what,  int print_args,
67
                         struct symtab_and_line sal);
68
 
69
/* Zero means do things normally; we are interacting directly with the
70
   user.  One means print the full filename and linenumber when a
71
   frame is printed, and do so in a format emacs18/emacs19.22 can
72
   parse.  Two means print similar annotations, but in many more
73
   cases and in a slightly different syntax.  */
74
 
75
int annotation_level = 0;
76
 
77
 
78
struct print_stack_frame_args
79
{
80
  struct frame_info *frame;
81
  int print_level;
82
  enum print_what print_what;
83
  int print_args;
84
};
85
 
86
/* Show or print the frame arguments; stub for catch_errors.  */
87
 
88
static int
89
print_stack_frame_stub (void *args)
90
{
91
  struct print_stack_frame_args *p = args;
92
  int center = (p->print_what == SRC_LINE || p->print_what == SRC_AND_LOC);
93
 
94
  print_frame_info (p->frame, p->print_level, p->print_what, p->print_args);
95
  set_current_sal_from_frame (p->frame, center);
96
  return 0;
97
}
98
 
99
/* Show or print a stack frame FRAME briefly.  The output is format
100
   according to PRINT_LEVEL and PRINT_WHAT printing the frame's
101
   relative level, function name, argument list, and file name and
102
   line number.  If the frame's PC is not at the beginning of the
103
   source line, the actual PC is printed at the beginning.  */
104
 
105
void
106
print_stack_frame (struct frame_info *frame, int print_level,
107
                   enum print_what print_what)
108
{
109
  struct print_stack_frame_args args;
110
 
111
  args.frame = frame;
112
  args.print_level = print_level;
113
  args.print_what = print_what;
114
  /* For mi, alway print location and address.  */
115
  args.print_what = ui_out_is_mi_like_p (uiout) ? LOC_AND_ADDRESS : print_what;
116
  args.print_args = 1;
117
 
118
  catch_errors (print_stack_frame_stub, &args, "", RETURN_MASK_ERROR);
119
}
120
 
121
struct print_args_args
122
{
123
  struct symbol *func;
124
  struct frame_info *frame;
125
  struct ui_file *stream;
126
};
127
 
128
static int print_args_stub (void *args);
129
 
130
/* Print nameless arguments of frame FRAME on STREAM, where START is
131
   the offset of the first nameless argument, and NUM is the number of
132
   nameless arguments to print.  FIRST is nonzero if this is the first
133
   argument (not just the first nameless argument).  */
134
 
135
static void
136
print_frame_nameless_args (struct frame_info *frame, long start, int num,
137
                           int first, struct ui_file *stream)
138
{
139
  int i;
140
  CORE_ADDR argsaddr;
141
  long arg_value;
142
 
143
  for (i = 0; i < num; i++)
144
    {
145
      QUIT;
146
      argsaddr = get_frame_args_address (frame);
147
      if (!argsaddr)
148
        return;
149
      arg_value = read_memory_integer (argsaddr + start, sizeof (int));
150
      if (!first)
151
        fprintf_filtered (stream, ", ");
152
      fprintf_filtered (stream, "%ld", arg_value);
153
      first = 0;
154
      start += sizeof (int);
155
    }
156
}
157
 
158
/* Return non-zero if the debugger should print the value of the provided
159
   symbol parameter (SYM).  */
160
 
161
static int
162
print_this_frame_argument_p (struct symbol *sym)
163
{
164
  struct type *type;
165
 
166
  /* If the user asked to print no argument at all, then obviously
167
     do not print this argument.  */
168
 
169
  if (strcmp (print_frame_arguments, "none") == 0)
170
    return 0;
171
 
172
  /* If the user asked to print all arguments, then we should print
173
     that one.  */
174
 
175
  if (strcmp (print_frame_arguments, "all") == 0)
176
    return 1;
177
 
178
  /* The user asked to print only the scalar arguments, so do not
179
     print the non-scalar ones.  */
180
 
181
  type = CHECK_TYPEDEF (SYMBOL_TYPE (sym));
182
  while (TYPE_CODE (type) == TYPE_CODE_REF)
183
    type = CHECK_TYPEDEF (TYPE_TARGET_TYPE (type));
184
  switch (TYPE_CODE (type))
185
    {
186
      case TYPE_CODE_ARRAY:
187
      case TYPE_CODE_STRUCT:
188
      case TYPE_CODE_UNION:
189
      case TYPE_CODE_SET:
190
      case TYPE_CODE_STRING:
191
      case TYPE_CODE_BITSTRING:
192
        return 0;
193
      default:
194
        return 1;
195
    }
196
}
197
 
198
/* Print the arguments of frame FRAME on STREAM, given the function
199
   FUNC running in that frame (as a symbol), where NUM is the number
200
   of arguments according to the stack frame (or -1 if the number of
201
   arguments is unknown).  */
202
 
203
/* Note that currently the "number of argumentss according to the
204
   stack frame" is only known on VAX where i refers to the "number of
205
   ints of argumentss according to the stack frame".  */
206
 
207
static void
208
print_frame_args (struct symbol *func, struct frame_info *frame,
209
                  int num, struct ui_file *stream)
210
{
211
  int first = 1;
212
  /* Offset of next stack argument beyond the one we have seen that is
213
     at the highest offset, or -1 if we haven't come to a stack
214
     argument yet.  */
215
  long highest_offset = -1;
216
  /* Number of ints of arguments that we have printed so far.  */
217
  int args_printed = 0;
218
  struct cleanup *old_chain, *list_chain;
219
  struct ui_stream *stb;
220
 
221
  stb = ui_out_stream_new (uiout);
222
  old_chain = make_cleanup_ui_out_stream_delete (stb);
223
 
224
  if (func)
225
    {
226
      struct block *b = SYMBOL_BLOCK_VALUE (func);
227
      struct dict_iterator iter;
228
      struct symbol *sym;
229
      struct value *val;
230
 
231
      ALL_BLOCK_SYMBOLS (b, iter, sym)
232
        {
233
          QUIT;
234
 
235
          /* Keep track of the highest stack argument offset seen, and
236
             skip over any kinds of symbols we don't care about.  */
237
 
238
          switch (SYMBOL_CLASS (sym))
239
            {
240
            case LOC_ARG:
241
            case LOC_REF_ARG:
242
              {
243
                long current_offset = SYMBOL_VALUE (sym);
244
                int arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym));
245
 
246
                /* Compute address of next argument by adding the size of
247
                   this argument and rounding to an int boundary.  */
248
                current_offset =
249
                  ((current_offset + arg_size + sizeof (int) - 1)
250
                   & ~(sizeof (int) - 1));
251
 
252
                /* If this is the highest offset seen yet, set
253
                   highest_offset.  */
254
                if (highest_offset == -1
255
                    || (current_offset > highest_offset))
256
                  highest_offset = current_offset;
257
 
258
                /* Add the number of ints we're about to print to
259
                   args_printed.  */
260
                args_printed += (arg_size + sizeof (int) - 1) / sizeof (int);
261
              }
262
 
263
              /* We care about types of symbols, but don't need to
264
                 keep track of stack offsets in them.  */
265
            case LOC_REGPARM:
266
            case LOC_REGPARM_ADDR:
267
            case LOC_LOCAL_ARG:
268
            case LOC_BASEREG_ARG:
269
            case LOC_COMPUTED_ARG:
270
              break;
271
 
272
            /* Other types of symbols we just skip over.  */
273
            default:
274
              continue;
275
            }
276
 
277
          /* We have to look up the symbol because arguments can have
278
             two entries (one a parameter, one a local) and the one we
279
             want is the local, which lookup_symbol will find for us.
280
             This includes gcc1 (not gcc2) on SPARC when passing a
281
             small structure and gcc2 when the argument type is float
282
             and it is passed as a double and converted to float by
283
             the prologue (in the latter case the type of the LOC_ARG
284
             symbol is double and the type of the LOC_LOCAL symbol is
285
             float).  */
286
          /* But if the parameter name is null, don't try it.  Null
287
             parameter names occur on the RS/6000, for traceback
288
             tables.  FIXME, should we even print them?  */
289
 
290
          if (*DEPRECATED_SYMBOL_NAME (sym))
291
            {
292
              struct symbol *nsym;
293
              nsym = lookup_symbol (DEPRECATED_SYMBOL_NAME (sym),
294
                                    b, VAR_DOMAIN, NULL, NULL);
295
              gdb_assert (nsym != NULL);
296
              if (SYMBOL_CLASS (nsym) == LOC_REGISTER)
297
                {
298
                  /* There is a LOC_ARG/LOC_REGISTER pair.  This means
299
                     that it was passed on the stack and loaded into a
300
                     register, or passed in a register and stored in a
301
                     stack slot.  GDB 3.x used the LOC_ARG; GDB
302
                     4.0-4.11 used the LOC_REGISTER.
303
 
304
                     Reasons for using the LOC_ARG:
305
 
306
                     (1) Because find_saved_registers may be slow for
307
                         remote debugging.
308
 
309
                     (2) Because registers are often re-used and stack
310
                         slots rarely (never?) are.  Therefore using
311
                         the stack slot is much less likely to print
312
                         garbage.
313
 
314
                     Reasons why we might want to use the LOC_REGISTER:
315
 
316
                     (1) So that the backtrace prints the same value
317
                         as "print foo".  I see no compelling reason
318
                         why this needs to be the case; having the
319
                         backtrace print the value which was passed
320
                         in, and "print foo" print the value as
321
                         modified within the called function, makes
322
                         perfect sense to me.
323
 
324
                     Additional note: It might be nice if "info args"
325
                     displayed both values.
326
 
327
                     One more note: There is a case with SPARC
328
                     structure passing where we need to use the
329
                     LOC_REGISTER, but this is dealt with by creating
330
                     a single LOC_REGPARM in symbol reading.  */
331
 
332
                  /* Leave sym (the LOC_ARG) alone.  */
333
                  ;
334
                }
335
              else
336
                sym = nsym;
337
            }
338
 
339
          /* Print the current arg.  */
340
          if (!first)
341
            ui_out_text (uiout, ", ");
342
          ui_out_wrap_hint (uiout, "    ");
343
 
344
          annotate_arg_begin ();
345
 
346
          list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
347
          fprintf_symbol_filtered (stb->stream, SYMBOL_PRINT_NAME (sym),
348
                                   SYMBOL_LANGUAGE (sym),
349
                                   DMGL_PARAMS | DMGL_ANSI);
350
          ui_out_field_stream (uiout, "name", stb);
351
          annotate_arg_name_end ();
352
          ui_out_text (uiout, "=");
353
 
354
          if (print_this_frame_argument_p (sym))
355
            {
356
              /* Avoid value_print because it will deref ref parameters.
357
                 We just want to print their addresses.  Print ??? for
358
                 args whose address we do not know.  We pass 2 as
359
                 "recurse" to val_print because our standard indentation
360
                 here is 4 spaces, and val_print indents 2 for each
361
                 recurse.  */
362
              val = read_var_value (sym, frame);
363
 
364
              annotate_arg_value (val == NULL ? NULL : value_type (val));
365
 
366
              if (val)
367
                {
368
                  common_val_print (val, stb->stream, 0, 0, 2,
369
                                    Val_no_prettyprint);
370
                  ui_out_field_stream (uiout, "value", stb);
371
                }
372
              else
373
                ui_out_text (uiout, "???");
374
            }
375
          else
376
            ui_out_text (uiout, "...");
377
 
378
 
379
          /* Invoke ui_out_tuple_end.  */
380
          do_cleanups (list_chain);
381
 
382
          annotate_arg_end ();
383
 
384
          first = 0;
385
        }
386
    }
387
 
388
  /* Don't print nameless args in situations where we don't know
389
     enough about the stack to find them.  */
390
  if (num != -1)
391
    {
392
      long start;
393
 
394
      if (highest_offset == -1)
395
        start = gdbarch_frame_args_skip (get_frame_arch (frame));
396
      else
397
        start = highest_offset;
398
 
399
      print_frame_nameless_args (frame, start, num - args_printed,
400
                                 first, stream);
401
    }
402
 
403
  do_cleanups (old_chain);
404
}
405
 
406
/* Stub for catch_errors.  */
407
 
408
static int
409
print_args_stub (void *args)
410
{
411
  struct print_args_args *p = args;
412
  struct gdbarch *gdbarch = get_frame_arch (p->frame);
413
  int numargs;
414
 
415
  if (gdbarch_frame_num_args_p (gdbarch))
416
    {
417
      numargs = gdbarch_frame_num_args (gdbarch, p->frame);
418
      gdb_assert (numargs >= 0);
419
    }
420
  else
421
    numargs = -1;
422
  print_frame_args (p->func, p->frame, numargs, p->stream);
423
  return 0;
424
}
425
 
426
/* Set the current source and line to the location given by frame
427
   FRAME, if possible.  When CENTER is true, adjust so the relevant
428
   line is in the center of the next 'list'.  */
429
 
430
void
431
set_current_sal_from_frame (struct frame_info *frame, int center)
432
{
433
  struct symtab_and_line sal;
434
 
435
  find_frame_sal (frame, &sal);
436
  if (sal.symtab)
437
    {
438
      if (center)
439
        sal.line = max (sal.line - get_lines_to_list () / 2, 1);
440
      set_current_source_symtab_and_line (&sal);
441
    }
442
}
443
 
444
/* Print information about frame FRAME.  The output is format according
445
   to PRINT_LEVEL and PRINT_WHAT and PRINT ARGS.  The meaning of
446
   PRINT_WHAT is:
447
 
448
   SRC_LINE: Print only source line.
449
   LOCATION: Print only location.
450
   LOC_AND_SRC: Print location and source line.
451
 
452
   Used in "where" output, and to emit breakpoint or step
453
   messages.  */
454
 
455
void
456
print_frame_info (struct frame_info *frame, int print_level,
457
                  enum print_what print_what, int print_args)
458
{
459
  struct symtab_and_line sal;
460
  int source_print;
461
  int location_print;
462
 
463
  if (get_frame_type (frame) == DUMMY_FRAME
464
      || get_frame_type (frame) == SIGTRAMP_FRAME)
465
    {
466
      struct cleanup *uiout_cleanup
467
        = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
468
 
469
      annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
470
                            get_frame_pc (frame));
471
 
472
      /* Do this regardless of SOURCE because we don't have any source
473
         to list for this frame.  */
474
      if (print_level)
475
        {
476
          ui_out_text (uiout, "#");
477
          ui_out_field_fmt_int (uiout, 2, ui_left, "level",
478
                                frame_relative_level (frame));
479
        }
480
      if (ui_out_is_mi_like_p (uiout))
481
        {
482
          annotate_frame_address ();
483
          ui_out_field_core_addr (uiout, "addr", get_frame_pc (frame));
484
          annotate_frame_address_end ();
485
        }
486
 
487
      if (get_frame_type (frame) == DUMMY_FRAME)
488
        {
489
          annotate_function_call ();
490
          ui_out_field_string (uiout, "func", "<function called from gdb>");
491
        }
492
      else if (get_frame_type (frame) == SIGTRAMP_FRAME)
493
        {
494
          annotate_signal_handler_caller ();
495
          ui_out_field_string (uiout, "func", "<signal handler called>");
496
        }
497
      ui_out_text (uiout, "\n");
498
      annotate_frame_end ();
499
 
500
      do_cleanups (uiout_cleanup);
501
      return;
502
    }
503
 
504
  /* If FRAME is not the innermost frame, that normally means that
505
     FRAME->pc points to *after* the call instruction, and we want to
506
     get the line containing the call, never the next line.  But if
507
     the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
508
     next frame was not entered as the result of a call, and we want
509
     to get the line containing FRAME->pc.  */
510
  find_frame_sal (frame, &sal);
511
 
512
  location_print = (print_what == LOCATION
513
                    || print_what == LOC_AND_ADDRESS
514
                    || print_what == SRC_AND_LOC);
515
 
516
  if (location_print || !sal.symtab)
517
    print_frame (frame, print_level, print_what, print_args, sal);
518
 
519
  source_print = (print_what == SRC_LINE || print_what == SRC_AND_LOC);
520
 
521
  if (source_print && sal.symtab)
522
    {
523
      int done = 0;
524
      int mid_statement = ((print_what == SRC_LINE)
525
                           && (get_frame_pc (frame) != sal.pc));
526
 
527
      if (annotation_level)
528
        done = identify_source_line (sal.symtab, sal.line, mid_statement,
529
                                     get_frame_pc (frame));
530
      if (!done)
531
        {
532
          if (deprecated_print_frame_info_listing_hook)
533
            deprecated_print_frame_info_listing_hook (sal.symtab,
534
                                                      sal.line,
535
                                                      sal.line + 1, 0);
536
          else
537
            {
538
              /* We used to do this earlier, but that is clearly
539
                 wrong. This function is used by many different
540
                 parts of gdb, including normal_stop in infrun.c,
541
                 which uses this to print out the current PC
542
                 when we stepi/nexti into the middle of a source
543
                 line. Only the command line really wants this
544
                 behavior. Other UIs probably would like the
545
                 ability to decide for themselves if it is desired.  */
546
              if (addressprint && mid_statement)
547
                {
548
                  ui_out_field_core_addr (uiout, "addr", get_frame_pc (frame));
549
                  ui_out_text (uiout, "\t");
550
                }
551
 
552
              print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);
553
            }
554
        }
555
    }
556
 
557
  if (print_what != LOCATION)
558
    set_default_breakpoint (1, get_frame_pc (frame), sal.symtab, sal.line);
559
 
560
  annotate_frame_end ();
561
 
562
  gdb_flush (gdb_stdout);
563
}
564
 
565
static void
566
print_frame (struct frame_info *frame, int print_level,
567
             enum print_what print_what, int print_args,
568
             struct symtab_and_line sal)
569
{
570
  struct symbol *func;
571
  char *funname = NULL;
572
  enum language funlang = language_unknown;
573
  struct ui_stream *stb;
574
  struct cleanup *old_chain, *list_chain;
575
 
576
  stb = ui_out_stream_new (uiout);
577
  old_chain = make_cleanup_ui_out_stream_delete (stb);
578
 
579
  func = find_pc_function (get_frame_address_in_block (frame));
580
  if (func)
581
    {
582
      /* In certain pathological cases, the symtabs give the wrong
583
         function (when we are in the first function in a file which
584
         is compiled without debugging symbols, the previous function
585
         is compiled with debugging symbols, and the "foo.o" symbol
586
         that is supposed to tell us where the file with debugging
587
         symbols ends has been truncated by ar because it is longer
588
         than 15 characters).  This also occurs if the user uses asm()
589
         to create a function but not stabs for it (in a file compiled
590
         with -g).
591
 
592
         So look in the minimal symbol tables as well, and if it comes
593
         up with a larger address for the function use that instead.
594
         I don't think this can ever cause any problems; there
595
         shouldn't be any minimal symbols in the middle of a function;
596
         if this is ever changed many parts of GDB will need to be
597
         changed (and we'll create a find_pc_minimal_function or some
598
         such).  */
599
 
600
      struct minimal_symbol *msymbol =
601
        lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame));
602
 
603
      if (msymbol != NULL
604
          && (SYMBOL_VALUE_ADDRESS (msymbol)
605
              > BLOCK_START (SYMBOL_BLOCK_VALUE (func))))
606
        {
607
          /* We also don't know anything about the function besides
608
             its address and name.  */
609
          func = 0;
610
          funname = DEPRECATED_SYMBOL_NAME (msymbol);
611
          funlang = SYMBOL_LANGUAGE (msymbol);
612
        }
613
      else
614
        {
615
          funname = DEPRECATED_SYMBOL_NAME (func);
616
          funlang = SYMBOL_LANGUAGE (func);
617
          if (funlang == language_cplus)
618
            {
619
              /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
620
                 to display the demangled name that we already have
621
                 stored in the symbol table, but we stored a version
622
                 with DMGL_PARAMS turned on, and here we don't want to
623
                 display parameters. So call the demangler again, with
624
                 DMGL_ANSI only.
625
 
626
                 Yes, printf_symbol_filtered() will again try to
627
                 demangle the name on the fly, but the issue is that
628
                 if cplus_demangle() fails here, it will fail there
629
                 too. So we want to catch the failure (where DEMANGLED
630
                 is NULL below) here, while we still have our hands on
631
                 the function symbol.)  */
632
              char *demangled = cplus_demangle (funname, DMGL_ANSI);
633
              if (demangled == NULL)
634
                /* If the demangler fails, try the demangled name from
635
                   the symbol table. That'll have parameters, but
636
                   that's preferable to displaying a mangled name.  */
637
                funname = SYMBOL_PRINT_NAME (func);
638
              else
639
                xfree (demangled);
640
            }
641
        }
642
    }
643
  else
644
    {
645
      struct minimal_symbol *msymbol =
646
        lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame));
647
 
648
      if (msymbol != NULL)
649
        {
650
          funname = DEPRECATED_SYMBOL_NAME (msymbol);
651
          funlang = SYMBOL_LANGUAGE (msymbol);
652
        }
653
    }
654
 
655
  annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
656
                        get_frame_pc (frame));
657
 
658
  list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
659
 
660
  if (print_level)
661
    {
662
      ui_out_text (uiout, "#");
663
      ui_out_field_fmt_int (uiout, 2, ui_left, "level",
664
                            frame_relative_level (frame));
665
    }
666
  if (addressprint)
667
    if (get_frame_pc (frame) != sal.pc || !sal.symtab
668
        || print_what == LOC_AND_ADDRESS)
669
      {
670
        annotate_frame_address ();
671
        ui_out_field_core_addr (uiout, "addr", get_frame_pc (frame));
672
        annotate_frame_address_end ();
673
        ui_out_text (uiout, " in ");
674
      }
675
  annotate_frame_function_name ();
676
  fprintf_symbol_filtered (stb->stream, funname ? funname : "??",
677
                           funlang, DMGL_ANSI);
678
  ui_out_field_stream (uiout, "func", stb);
679
  ui_out_wrap_hint (uiout, "   ");
680
  annotate_frame_args ();
681
 
682
  ui_out_text (uiout, " (");
683
  if (print_args)
684
    {
685
      struct print_args_args args;
686
      struct cleanup *args_list_chain;
687
      args.frame = frame;
688
      args.func = func;
689
      args.stream = gdb_stdout;
690
      args_list_chain = make_cleanup_ui_out_list_begin_end (uiout, "args");
691
      catch_errors (print_args_stub, &args, "", RETURN_MASK_ERROR);
692
      /* FIXME: ARGS must be a list. If one argument is a string it
693
          will have " that will not be properly escaped.  */
694
      /* Invoke ui_out_tuple_end.  */
695
      do_cleanups (args_list_chain);
696
      QUIT;
697
    }
698
  ui_out_text (uiout, ")");
699
  if (sal.symtab && sal.symtab->filename)
700
    {
701
      annotate_frame_source_begin ();
702
      ui_out_wrap_hint (uiout, "   ");
703
      ui_out_text (uiout, " at ");
704
      annotate_frame_source_file ();
705
      ui_out_field_string (uiout, "file", sal.symtab->filename);
706
      if (ui_out_is_mi_like_p (uiout))
707
        {
708
          const char *fullname = symtab_to_fullname (sal.symtab);
709
          if (fullname != NULL)
710
            ui_out_field_string (uiout, "fullname", fullname);
711
        }
712
      annotate_frame_source_file_end ();
713
      ui_out_text (uiout, ":");
714
      annotate_frame_source_line ();
715
      ui_out_field_int (uiout, "line", sal.line);
716
      annotate_frame_source_end ();
717
    }
718
 
719
  if (!funname || (!sal.symtab || !sal.symtab->filename))
720
    {
721
#ifdef PC_SOLIB
722
      char *lib = PC_SOLIB (get_frame_pc (frame));
723
#else
724
      char *lib = solib_address (get_frame_pc (frame));
725
#endif
726
      if (lib)
727
        {
728
          annotate_frame_where ();
729
          ui_out_wrap_hint (uiout, "  ");
730
          ui_out_text (uiout, " from ");
731
          ui_out_field_string (uiout, "from", lib);
732
        }
733
    }
734
 
735
  /* do_cleanups will call ui_out_tuple_end() for us.  */
736
  do_cleanups (list_chain);
737
  ui_out_text (uiout, "\n");
738
  do_cleanups (old_chain);
739
}
740
 
741
/* Show the frame info.  If this is the tui, it will be shown in the
742
   source display otherwise, nothing is done.  */
743
 
744
void
745
show_stack_frame (struct frame_info *frame)
746
{
747
}
748
 
749
 
750
/* Read a frame specification in whatever the appropriate format is
751
   from FRAME_EXP.  Call error(), printing MESSAGE, if the
752
   specification is in any way invalid (so this function never returns
753
   NULL).  When SEPECTED_P is non-NULL set its target to indicate that
754
   the default selected frame was used.  */
755
 
756
static struct frame_info *
757
parse_frame_specification_1 (const char *frame_exp, const char *message,
758
                             int *selected_frame_p)
759
{
760
  int numargs;
761
  struct value *args[4];
762
  CORE_ADDR addrs[ARRAY_SIZE (args)];
763
 
764
  if (frame_exp == NULL)
765
    numargs = 0;
766
  else
767
    {
768
      char *addr_string;
769
      struct cleanup *tmp_cleanup;
770
 
771
      numargs = 0;
772
      while (1)
773
        {
774
          char *addr_string;
775
          struct cleanup *cleanup;
776
          const char *p;
777
 
778
          /* Skip leading white space, bail of EOL.  */
779
          while (isspace (*frame_exp))
780
            frame_exp++;
781
          if (!*frame_exp)
782
            break;
783
 
784
          /* Parse the argument, extract it, save it.  */
785
          for (p = frame_exp;
786
               *p && !isspace (*p);
787
               p++);
788
          addr_string = savestring (frame_exp, p - frame_exp);
789
          frame_exp = p;
790
          cleanup = make_cleanup (xfree, addr_string);
791
 
792
          /* NOTE: Parse and evaluate expression, but do not use
793
             functions such as parse_and_eval_long or
794
             parse_and_eval_address to also extract the value.
795
             Instead value_as_long and value_as_address are used.
796
             This avoids problems with expressions that contain
797
             side-effects.  */
798
          if (numargs >= ARRAY_SIZE (args))
799
            error (_("Too many args in frame specification"));
800
          args[numargs++] = parse_and_eval (addr_string);
801
 
802
          do_cleanups (cleanup);
803
        }
804
    }
805
 
806
  /* If no args, default to the selected frame.  */
807
  if (numargs == 0)
808
    {
809
      if (selected_frame_p != NULL)
810
        (*selected_frame_p) = 1;
811
      return get_selected_frame (message);
812
    }
813
 
814
  /* None of the remaining use the selected frame.  */
815
  if (selected_frame_p != NULL)
816
    (*selected_frame_p) = 0;
817
 
818
  /* Assume the single arg[0] is an integer, and try using that to
819
     select a frame relative to current.  */
820
  if (numargs == 1)
821
    {
822
      struct frame_info *fid;
823
      int level = value_as_long (args[0]);
824
      fid = find_relative_frame (get_current_frame (), &level);
825
      if (level == 0)
826
        /* find_relative_frame was successful */
827
        return fid;
828
    }
829
 
830
  /* Convert each value into a corresponding address.  */
831
  {
832
    int i;
833
    for (i = 0; i < numargs; i++)
834
      addrs[i] = value_as_address (args[0]);
835
  }
836
 
837
  /* Assume that the single arg[0] is an address, use that to identify
838
     a frame with a matching ID.  Should this also accept stack/pc or
839
     stack/pc/special.  */
840
  if (numargs == 1)
841
    {
842
      struct frame_id id = frame_id_build_wild (addrs[0]);
843
      struct frame_info *fid;
844
 
845
      /* If (s)he specifies the frame with an address, he deserves
846
         what (s)he gets.  Still, give the highest one that matches.
847
         (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
848
         know).  */
849
      for (fid = get_current_frame ();
850
           fid != NULL;
851
           fid = get_prev_frame (fid))
852
        {
853
          if (frame_id_eq (id, get_frame_id (fid)))
854
            {
855
              while (frame_id_eq (id, frame_unwind_id (fid)))
856
                fid = get_prev_frame (fid);
857
              return fid;
858
            }
859
        }
860
      }
861
 
862
  /* We couldn't identify the frame as an existing frame, but
863
     perhaps we can create one with a single argument.  */
864
  if (numargs == 1)
865
    return create_new_frame (addrs[0], 0);
866
  else if (numargs == 2)
867
    return create_new_frame (addrs[0], addrs[1]);
868
  else
869
    error (_("Too many args in frame specification"));
870
}
871
 
872
static struct frame_info *
873
parse_frame_specification (char *frame_exp)
874
{
875
  return parse_frame_specification_1 (frame_exp, NULL, NULL);
876
}
877
 
878
/* Print verbosely the selected frame or the frame at address
879
   ADDR_EXP.  Absolutely all information in the frame is printed.  */
880
 
881
static void
882
frame_info (char *addr_exp, int from_tty)
883
{
884
  struct frame_info *fi;
885
  struct symtab_and_line sal;
886
  struct symbol *func;
887
  struct symtab *s;
888
  struct frame_info *calling_frame_info;
889
  int i, count, numregs;
890
  char *funname = 0;
891
  enum language funlang = language_unknown;
892
  const char *pc_regname;
893
  int selected_frame_p;
894
  struct gdbarch *gdbarch;
895
 
896
  fi = parse_frame_specification_1 (addr_exp, "No stack.", &selected_frame_p);
897
  gdbarch = get_frame_arch (fi);
898
 
899
  /* Name of the value returned by get_frame_pc().  Per comments, "pc"
900
     is not a good name.  */
901
  if (gdbarch_pc_regnum (gdbarch) >= 0)
902
    /* OK, this is weird.  The gdbarch_pc_regnum hardware register's value can
903
       easily not match that of the internal value returned by
904
       get_frame_pc().  */
905
    pc_regname = gdbarch_register_name (gdbarch, gdbarch_pc_regnum (gdbarch));
906
  else
907
    /* But then, this is weird to.  Even without gdbarch_pc_regnum, an
908
       architectures will often have a hardware register called "pc",
909
       and that register's value, again, can easily not match
910
       get_frame_pc().  */
911
    pc_regname = "pc";
912
 
913
  find_frame_sal (fi, &sal);
914
  func = get_frame_function (fi);
915
  /* FIXME: cagney/2002-11-28: Why bother?  Won't sal.symtab contain
916
     the same value?  */
917
  s = find_pc_symtab (get_frame_pc (fi));
918
  if (func)
919
    {
920
      /* It seems appropriate to use SYMBOL_PRINT_NAME() here, to
921
         display the demangled name that we already have stored in the
922
         symbol table, but we stored a version with DMGL_PARAMS turned
923
         on, and here we don't want to display parameters. So call the
924
         demangler again, with DMGL_ANSI only.
925
 
926
         Yes, printf_symbol_filtered() will again try to demangle the
927
         name on the fly, but the issue is that if cplus_demangle()
928
         fails here, it will fail there too. So we want to catch the
929
         failure (where DEMANGLED is NULL below) here, while we still
930
         have our hands on the function symbol.)  */
931
      funname = DEPRECATED_SYMBOL_NAME (func);
932
      funlang = SYMBOL_LANGUAGE (func);
933
      if (funlang == language_cplus)
934
        {
935
          char *demangled = cplus_demangle (funname, DMGL_ANSI);
936
          /* If the demangler fails, try the demangled name from the
937
             symbol table. That'll have parameters, but that's
938
             preferable to displaying a mangled name.  */
939
          if (demangled == NULL)
940
            funname = SYMBOL_PRINT_NAME (func);
941
          else
942
            xfree (demangled);
943
        }
944
    }
945
  else
946
    {
947
      struct minimal_symbol *msymbol;
948
 
949
      msymbol = lookup_minimal_symbol_by_pc (get_frame_pc (fi));
950
      if (msymbol != NULL)
951
        {
952
          funname = DEPRECATED_SYMBOL_NAME (msymbol);
953
          funlang = SYMBOL_LANGUAGE (msymbol);
954
        }
955
    }
956
  calling_frame_info = get_prev_frame (fi);
957
 
958
  if (selected_frame_p && frame_relative_level (fi) >= 0)
959
    {
960
      printf_filtered (_("Stack level %d, frame at "),
961
                       frame_relative_level (fi));
962
    }
963
  else
964
    {
965
      printf_filtered (_("Stack frame at "));
966
    }
967
  fputs_filtered (paddress (get_frame_base (fi)), gdb_stdout);
968
  printf_filtered (":\n");
969
  printf_filtered (" %s = ", pc_regname);
970
  fputs_filtered (paddress (get_frame_pc (fi)), gdb_stdout);
971
 
972
  wrap_here ("   ");
973
  if (funname)
974
    {
975
      printf_filtered (" in ");
976
      fprintf_symbol_filtered (gdb_stdout, funname, funlang,
977
                               DMGL_ANSI | DMGL_PARAMS);
978
    }
979
  wrap_here ("   ");
980
  if (sal.symtab)
981
    printf_filtered (" (%s:%d)", sal.symtab->filename, sal.line);
982
  puts_filtered ("; ");
983
  wrap_here ("    ");
984
  printf_filtered ("saved %s ", pc_regname);
985
  fputs_filtered (paddress (frame_pc_unwind (fi)), gdb_stdout);
986
  printf_filtered ("\n");
987
 
988
  if (calling_frame_info == NULL)
989
    {
990
      enum unwind_stop_reason reason;
991
 
992
      reason = get_frame_unwind_stop_reason (fi);
993
      if (reason != UNWIND_NO_REASON)
994
        printf_filtered (_(" Outermost frame: %s\n"),
995
                         frame_stop_reason_string (reason));
996
    }
997
 
998
  if (calling_frame_info)
999
    {
1000
      printf_filtered (" called by frame at ");
1001
      fputs_filtered (paddress (get_frame_base (calling_frame_info)),
1002
                      gdb_stdout);
1003
    }
1004
  if (get_next_frame (fi) && calling_frame_info)
1005
    puts_filtered (",");
1006
  wrap_here ("   ");
1007
  if (get_next_frame (fi))
1008
    {
1009
      printf_filtered (" caller of frame at ");
1010
      fputs_filtered (paddress (get_frame_base (get_next_frame (fi))),
1011
                      gdb_stdout);
1012
    }
1013
  if (get_next_frame (fi) || calling_frame_info)
1014
    puts_filtered ("\n");
1015
 
1016
  if (s)
1017
    printf_filtered (" source language %s.\n",
1018
                     language_str (s->language));
1019
 
1020
  {
1021
    /* Address of the argument list for this frame, or 0.  */
1022
    CORE_ADDR arg_list = get_frame_args_address (fi);
1023
    /* Number of args for this frame, or -1 if unknown.  */
1024
    int numargs;
1025
 
1026
    if (arg_list == 0)
1027
      printf_filtered (" Arglist at unknown address.\n");
1028
    else
1029
      {
1030
        printf_filtered (" Arglist at ");
1031
        fputs_filtered (paddress (arg_list), gdb_stdout);
1032
        printf_filtered (",");
1033
 
1034
        if (!gdbarch_frame_num_args_p (gdbarch))
1035
          {
1036
            numargs = -1;
1037
            puts_filtered (" args: ");
1038
          }
1039
        else
1040
          {
1041
            numargs = gdbarch_frame_num_args (gdbarch, fi);
1042
            gdb_assert (numargs >= 0);
1043
            if (numargs == 0)
1044
              puts_filtered (" no args.");
1045
            else if (numargs == 1)
1046
              puts_filtered (" 1 arg: ");
1047
            else
1048
              printf_filtered (" %d args: ", numargs);
1049
          }
1050
        print_frame_args (func, fi, numargs, gdb_stdout);
1051
        puts_filtered ("\n");
1052
      }
1053
  }
1054
  {
1055
    /* Address of the local variables for this frame, or 0.  */
1056
    CORE_ADDR arg_list = get_frame_locals_address (fi);
1057
 
1058
    if (arg_list == 0)
1059
      printf_filtered (" Locals at unknown address,");
1060
    else
1061
      {
1062
        printf_filtered (" Locals at ");
1063
        fputs_filtered (paddress (arg_list), gdb_stdout);
1064
        printf_filtered (",");
1065
      }
1066
  }
1067
 
1068
  /* Print as much information as possible on the location of all the
1069
     registers.  */
1070
  {
1071
    enum lval_type lval;
1072
    int optimized;
1073
    CORE_ADDR addr;
1074
    int realnum;
1075
    int count;
1076
    int i;
1077
    int need_nl = 1;
1078
 
1079
    /* The sp is special; what's displayed isn't the save address, but
1080
       the value of the previous frame's sp.  This is a legacy thing,
1081
       at one stage the frame cached the previous frame's SP instead
1082
       of its address, hence it was easiest to just display the cached
1083
       value.  */
1084
    if (gdbarch_sp_regnum (gdbarch) >= 0)
1085
      {
1086
        /* Find out the location of the saved stack pointer with out
1087
           actually evaluating it.  */
1088
        frame_register_unwind (fi, gdbarch_sp_regnum (gdbarch),
1089
                               &optimized, &lval, &addr,
1090
                               &realnum, NULL);
1091
        if (!optimized && lval == not_lval)
1092
          {
1093
            gdb_byte value[MAX_REGISTER_SIZE];
1094
            CORE_ADDR sp;
1095
            frame_register_unwind (fi, gdbarch_sp_regnum (gdbarch),
1096
                                   &optimized, &lval, &addr,
1097
                                   &realnum, value);
1098
            /* NOTE: cagney/2003-05-22: This is assuming that the
1099
               stack pointer was packed as an unsigned integer.  That
1100
               may or may not be valid.  */
1101
            sp = extract_unsigned_integer (value,
1102
                                           register_size (gdbarch,
1103
                                           gdbarch_sp_regnum (gdbarch)));
1104
            printf_filtered (" Previous frame's sp is ");
1105
            fputs_filtered (paddress (sp), gdb_stdout);
1106
            printf_filtered ("\n");
1107
            need_nl = 0;
1108
          }
1109
        else if (!optimized && lval == lval_memory)
1110
          {
1111
            printf_filtered (" Previous frame's sp at ");
1112
            fputs_filtered (paddress (addr), gdb_stdout);
1113
            printf_filtered ("\n");
1114
            need_nl = 0;
1115
          }
1116
        else if (!optimized && lval == lval_register)
1117
          {
1118
            printf_filtered (" Previous frame's sp in %s\n",
1119
                             gdbarch_register_name (gdbarch, realnum));
1120
            need_nl = 0;
1121
          }
1122
        /* else keep quiet.  */
1123
      }
1124
 
1125
    count = 0;
1126
    numregs = gdbarch_num_regs (gdbarch)
1127
              + gdbarch_num_pseudo_regs (gdbarch);
1128
    for (i = 0; i < numregs; i++)
1129
      if (i != gdbarch_sp_regnum (gdbarch)
1130
          && gdbarch_register_reggroup_p (gdbarch, i, all_reggroup))
1131
        {
1132
          /* Find out the location of the saved register without
1133
             fetching the corresponding value.  */
1134
          frame_register_unwind (fi, i, &optimized, &lval, &addr, &realnum,
1135
                                 NULL);
1136
          /* For moment, only display registers that were saved on the
1137
             stack.  */
1138
          if (!optimized && lval == lval_memory)
1139
            {
1140
              if (count == 0)
1141
                puts_filtered (" Saved registers:\n ");
1142
              else
1143
                puts_filtered (",");
1144
              wrap_here (" ");
1145
              printf_filtered (" %s at ",
1146
                               gdbarch_register_name (gdbarch, i));
1147
              fputs_filtered (paddress (addr), gdb_stdout);
1148
              count++;
1149
            }
1150
        }
1151
    if (count || need_nl)
1152
      puts_filtered ("\n");
1153
  }
1154
}
1155
 
1156
/* Print briefly all stack frames or just the innermost COUNT_EXP
1157
   frames.  */
1158
 
1159
static void
1160
backtrace_command_1 (char *count_exp, int show_locals, int from_tty)
1161
{
1162
  struct frame_info *fi;
1163
  int count;
1164
  int i;
1165
  struct frame_info *trailing;
1166
  int trailing_level;
1167
 
1168
  if (!target_has_stack)
1169
    error (_("No stack."));
1170
 
1171
  /* The following code must do two things.  First, it must set the
1172
     variable TRAILING to the frame from which we should start
1173
     printing.  Second, it must set the variable count to the number
1174
     of frames which we should print, or -1 if all of them.  */
1175
  trailing = get_current_frame ();
1176
 
1177
  /* The target can be in a state where there is no valid frames
1178
     (e.g., just connected). */
1179
  if (trailing == NULL)
1180
    error (_("No stack."));
1181
 
1182
  trailing_level = 0;
1183
  if (count_exp)
1184
    {
1185
      count = parse_and_eval_long (count_exp);
1186
      if (count < 0)
1187
        {
1188
          struct frame_info *current;
1189
 
1190
          count = -count;
1191
 
1192
          current = trailing;
1193
          while (current && count--)
1194
            {
1195
              QUIT;
1196
              current = get_prev_frame (current);
1197
            }
1198
 
1199
          /* Will stop when CURRENT reaches the top of the stack.
1200
             TRAILING will be COUNT below it.  */
1201
          while (current)
1202
            {
1203
              QUIT;
1204
              trailing = get_prev_frame (trailing);
1205
              current = get_prev_frame (current);
1206
              trailing_level++;
1207
            }
1208
 
1209
          count = -1;
1210
        }
1211
    }
1212
  else
1213
    count = -1;
1214
 
1215
  if (info_verbose)
1216
    {
1217
      struct partial_symtab *ps;
1218
 
1219
      /* Read in symbols for all of the frames.  Need to do this in a
1220
         separate pass so that "Reading in symbols for xxx" messages
1221
         don't screw up the appearance of the backtrace.  Also if
1222
         people have strong opinions against reading symbols for
1223
         backtrace this may have to be an option.  */
1224
      i = count;
1225
      for (fi = trailing; fi != NULL && i--; fi = get_prev_frame (fi))
1226
        {
1227
          QUIT;
1228
          ps = find_pc_psymtab (get_frame_address_in_block (fi));
1229
          if (ps)
1230
            PSYMTAB_TO_SYMTAB (ps); /* Force syms to come in.  */
1231
        }
1232
    }
1233
 
1234
  for (i = 0, fi = trailing; fi && count--; i++, fi = get_prev_frame (fi))
1235
    {
1236
      QUIT;
1237
 
1238
      /* Don't use print_stack_frame; if an error() occurs it probably
1239
         means further attempts to backtrace would fail (on the other
1240
         hand, perhaps the code does or could be fixed to make sure
1241
         the frame->prev field gets set to NULL in that case).  */
1242
      print_frame_info (fi, 1, LOCATION, 1);
1243
      if (show_locals)
1244
        print_frame_local_vars (fi, 1, gdb_stdout);
1245
 
1246
      /* Save the last frame to check for error conditions.  */
1247
      trailing = fi;
1248
    }
1249
 
1250
  /* If we've stopped before the end, mention that.  */
1251
  if (fi && from_tty)
1252
    printf_filtered (_("(More stack frames follow...)\n"));
1253
 
1254
  /* If we've run out of frames, and the reason appears to be an error
1255
     condition, print it.  */
1256
  if (fi == NULL && trailing != NULL)
1257
    {
1258
      enum unwind_stop_reason reason;
1259
 
1260
      reason = get_frame_unwind_stop_reason (trailing);
1261
      if (reason > UNWIND_FIRST_ERROR)
1262
        printf_filtered (_("Backtrace stopped: %s\n"),
1263
                         frame_stop_reason_string (reason));
1264
    }
1265
}
1266
 
1267
struct backtrace_command_args
1268
{
1269
  char *count_exp;
1270
  int show_locals;
1271
  int from_tty;
1272
};
1273
 
1274
/* Stub for catch_errors.  */
1275
 
1276
static int
1277
backtrace_command_stub (void *data)
1278
{
1279
  struct backtrace_command_args *args = data;
1280
  backtrace_command_1 (args->count_exp, args->show_locals, args->from_tty);
1281
  return 0;
1282
}
1283
 
1284
static void
1285
backtrace_command (char *arg, int from_tty)
1286
{
1287
  struct cleanup *old_chain = NULL;
1288
  int fulltrace_arg = -1, arglen = 0, argc = 0;
1289
  struct backtrace_command_args btargs;
1290
 
1291
  if (arg)
1292
    {
1293
      char **argv;
1294
      int i;
1295
 
1296
      argv = buildargv (arg);
1297
      old_chain = make_cleanup_freeargv (argv);
1298
      argc = 0;
1299
      for (i = 0; argv[i]; i++)
1300
        {
1301
          unsigned int j;
1302
 
1303
          for (j = 0; j < strlen (argv[i]); j++)
1304
            argv[i][j] = tolower (argv[i][j]);
1305
 
1306
          if (fulltrace_arg < 0 && subset_compare (argv[i], "full"))
1307
            fulltrace_arg = argc;
1308
          else
1309
            {
1310
              arglen += strlen (argv[i]);
1311
              argc++;
1312
            }
1313
        }
1314
      arglen += argc;
1315
      if (fulltrace_arg >= 0)
1316
        {
1317
          if (arglen > 0)
1318
            {
1319
              arg = xmalloc (arglen + 1);
1320
              memset (arg, 0, arglen + 1);
1321
              for (i = 0; i < (argc + 1); i++)
1322
                {
1323
                  if (i != fulltrace_arg)
1324
                    {
1325
                      strcat (arg, argv[i]);
1326
                      strcat (arg, " ");
1327
                    }
1328
                }
1329
            }
1330
          else
1331
            arg = NULL;
1332
        }
1333
    }
1334
 
1335
  btargs.count_exp = arg;
1336
  btargs.show_locals = (fulltrace_arg >= 0);
1337
  btargs.from_tty = from_tty;
1338
  catch_errors (backtrace_command_stub, &btargs, "", RETURN_MASK_ERROR);
1339
 
1340
  if (fulltrace_arg >= 0 && arglen > 0)
1341
    xfree (arg);
1342
 
1343
  if (old_chain)
1344
    do_cleanups (old_chain);
1345
}
1346
 
1347
static void
1348
backtrace_full_command (char *arg, int from_tty)
1349
{
1350
  struct backtrace_command_args btargs;
1351
  btargs.count_exp = arg;
1352
  btargs.show_locals = 1;
1353
  btargs.from_tty = from_tty;
1354
  catch_errors (backtrace_command_stub, &btargs, "", RETURN_MASK_ERROR);
1355
}
1356
 
1357
 
1358
/* Print the local variables of a block B active in FRAME on STREAM.
1359
   Return 1 if any variables were printed; 0 otherwise.  */
1360
 
1361
static int
1362
print_block_frame_locals (struct block *b, struct frame_info *frame,
1363
                          int num_tabs, struct ui_file *stream)
1364
{
1365
  struct dict_iterator iter;
1366
  struct symbol *sym;
1367
  int values_printed = 0;
1368
  int j;
1369
 
1370
  ALL_BLOCK_SYMBOLS (b, iter, sym)
1371
    {
1372
      switch (SYMBOL_CLASS (sym))
1373
        {
1374
        case LOC_LOCAL:
1375
        case LOC_REGISTER:
1376
        case LOC_STATIC:
1377
        case LOC_BASEREG:
1378
        case LOC_COMPUTED:
1379
          values_printed = 1;
1380
          for (j = 0; j < num_tabs; j++)
1381
            fputs_filtered ("\t", stream);
1382
          fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
1383
          fputs_filtered (" = ", stream);
1384
          print_variable_value (sym, frame, stream);
1385
          fprintf_filtered (stream, "\n");
1386
          break;
1387
 
1388
        default:
1389
          /* Ignore symbols which are not locals.  */
1390
          break;
1391
        }
1392
    }
1393
 
1394
  return values_printed;
1395
}
1396
 
1397
/* Same, but print labels.  */
1398
 
1399
static int
1400
print_block_frame_labels (struct block *b, int *have_default,
1401
                          struct ui_file *stream)
1402
{
1403
  struct dict_iterator iter;
1404
  struct symbol *sym;
1405
  int values_printed = 0;
1406
 
1407
  ALL_BLOCK_SYMBOLS (b, iter, sym)
1408
    {
1409
      if (strcmp (DEPRECATED_SYMBOL_NAME (sym), "default") == 0)
1410
        {
1411
          if (*have_default)
1412
            continue;
1413
          *have_default = 1;
1414
        }
1415
      if (SYMBOL_CLASS (sym) == LOC_LABEL)
1416
        {
1417
          struct symtab_and_line sal;
1418
          sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0);
1419
          values_printed = 1;
1420
          fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
1421
          if (addressprint)
1422
            {
1423
              fprintf_filtered (stream, " ");
1424
              fputs_filtered (paddress (SYMBOL_VALUE_ADDRESS (sym)), stream);
1425
            }
1426
          fprintf_filtered (stream, " in file %s, line %d\n",
1427
                            sal.symtab->filename, sal.line);
1428
        }
1429
    }
1430
 
1431
  return values_printed;
1432
}
1433
 
1434
/* Print on STREAM all the local variables in frame FRAME, including
1435
   all the blocks active in that frame at its current PC.
1436
 
1437
   Returns 1 if the job was done, or 0 if nothing was printed because
1438
   we have no info on the function running in FRAME.  */
1439
 
1440
static void
1441
print_frame_local_vars (struct frame_info *frame, int num_tabs,
1442
                        struct ui_file *stream)
1443
{
1444
  struct block *block = get_frame_block (frame, 0);
1445
  int values_printed = 0;
1446
 
1447
  if (block == 0)
1448
    {
1449
      fprintf_filtered (stream, "No symbol table info available.\n");
1450
      return;
1451
    }
1452
 
1453
  while (block)
1454
    {
1455
      if (print_block_frame_locals (block, frame, num_tabs, stream))
1456
        values_printed = 1;
1457
      /* After handling the function's top-level block, stop.  Don't
1458
         continue to its superblock, the block of per-file symbols.  */
1459
      if (BLOCK_FUNCTION (block))
1460
        break;
1461
      block = BLOCK_SUPERBLOCK (block);
1462
    }
1463
 
1464
  if (!values_printed)
1465
    fprintf_filtered (stream, _("No locals.\n"));
1466
}
1467
 
1468
/* Same, but print labels.  */
1469
 
1470
static void
1471
print_frame_label_vars (struct frame_info *frame, int this_level_only,
1472
                        struct ui_file *stream)
1473
{
1474
#if 1
1475
  fprintf_filtered (stream, "print_frame_label_vars disabled.\n");
1476
#else
1477
  struct blockvector *bl;
1478
  struct block *block = get_frame_block (frame, 0);
1479
  int values_printed = 0;
1480
  int index, have_default = 0;
1481
  char *blocks_printed;
1482
  CORE_ADDR pc = get_frame_pc (frame);
1483
 
1484
  if (block == 0)
1485
    {
1486
      fprintf_filtered (stream, "No symbol table info available.\n");
1487
      return;
1488
    }
1489
 
1490
  bl = blockvector_for_pc (BLOCK_END (block) - 4, &index);
1491
  blocks_printed = alloca (BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
1492
  memset (blocks_printed, 0, BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
1493
 
1494
  while (block != 0)
1495
    {
1496
      CORE_ADDR end = BLOCK_END (block) - 4;
1497
      int last_index;
1498
 
1499
      if (bl != blockvector_for_pc (end, &index))
1500
        error (_("blockvector blotch"));
1501
      if (BLOCKVECTOR_BLOCK (bl, index) != block)
1502
        error (_("blockvector botch"));
1503
      last_index = BLOCKVECTOR_NBLOCKS (bl);
1504
      index += 1;
1505
 
1506
      /* Don't print out blocks that have gone by.  */
1507
      while (index < last_index
1508
             && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < pc)
1509
        index++;
1510
 
1511
      while (index < last_index
1512
             && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < end)
1513
        {
1514
          if (blocks_printed[index] == 0)
1515
            {
1516
              if (print_block_frame_labels (BLOCKVECTOR_BLOCK (bl, index),
1517
                                            &have_default, stream))
1518
                values_printed = 1;
1519
              blocks_printed[index] = 1;
1520
            }
1521
          index++;
1522
        }
1523
      if (have_default)
1524
        return;
1525
      if (values_printed && this_level_only)
1526
        return;
1527
 
1528
      /* After handling the function's top-level block, stop.  Don't
1529
         continue to its superblock, the block of per-file symbols.  */
1530
      if (BLOCK_FUNCTION (block))
1531
        break;
1532
      block = BLOCK_SUPERBLOCK (block);
1533
    }
1534
 
1535
  if (!values_printed && !this_level_only)
1536
    fprintf_filtered (stream, _("No catches.\n"));
1537
#endif
1538
}
1539
 
1540
void
1541
locals_info (char *args, int from_tty)
1542
{
1543
  print_frame_local_vars (get_selected_frame (_("No frame selected.")),
1544
                          0, gdb_stdout);
1545
}
1546
 
1547
static void
1548
catch_info (char *ignore, int from_tty)
1549
{
1550
  struct symtab_and_line *sal;
1551
 
1552
  /* Assume g++ compiled code; old GDB 4.16 behaviour.  */
1553
  print_frame_label_vars (get_selected_frame (_("No frame selected.")),
1554
                          0, gdb_stdout);
1555
}
1556
 
1557
static void
1558
print_frame_arg_vars (struct frame_info *frame, struct ui_file *stream)
1559
{
1560
  struct symbol *func = get_frame_function (frame);
1561
  struct block *b;
1562
  struct dict_iterator iter;
1563
  struct symbol *sym, *sym2;
1564
  int values_printed = 0;
1565
 
1566
  if (func == 0)
1567
    {
1568
      fprintf_filtered (stream, _("No symbol table info available.\n"));
1569
      return;
1570
    }
1571
 
1572
  b = SYMBOL_BLOCK_VALUE (func);
1573
  ALL_BLOCK_SYMBOLS (b, iter, sym)
1574
    {
1575
      switch (SYMBOL_CLASS (sym))
1576
        {
1577
        case LOC_ARG:
1578
        case LOC_LOCAL_ARG:
1579
        case LOC_REF_ARG:
1580
        case LOC_REGPARM:
1581
        case LOC_REGPARM_ADDR:
1582
        case LOC_BASEREG_ARG:
1583
        case LOC_COMPUTED_ARG:
1584
          values_printed = 1;
1585
          fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
1586
          fputs_filtered (" = ", stream);
1587
 
1588
          /* We have to look up the symbol because arguments can have
1589
             two entries (one a parameter, one a local) and the one we
1590
             want is the local, which lookup_symbol will find for us.
1591
             This includes gcc1 (not gcc2) on the sparc when passing a
1592
             small structure and gcc2 when the argument type is float
1593
             and it is passed as a double and converted to float by
1594
             the prologue (in the latter case the type of the LOC_ARG
1595
             symbol is double and the type of the LOC_LOCAL symbol is
1596
             float).  There are also LOC_ARG/LOC_REGISTER pairs which
1597
             are not combined in symbol-reading.  */
1598
 
1599
          sym2 = lookup_symbol (DEPRECATED_SYMBOL_NAME (sym),
1600
                                b, VAR_DOMAIN, NULL, NULL);
1601
          print_variable_value (sym2, frame, stream);
1602
          fprintf_filtered (stream, "\n");
1603
          break;
1604
 
1605
        default:
1606
          /* Don't worry about things which aren't arguments.  */
1607
          break;
1608
        }
1609
    }
1610
 
1611
  if (!values_printed)
1612
    fprintf_filtered (stream, _("No arguments.\n"));
1613
}
1614
 
1615
void
1616
args_info (char *ignore, int from_tty)
1617
{
1618
  print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
1619
                        gdb_stdout);
1620
}
1621
 
1622
 
1623
static void
1624
args_plus_locals_info (char *ignore, int from_tty)
1625
{
1626
  args_info (ignore, from_tty);
1627
  locals_info (ignore, from_tty);
1628
}
1629
 
1630
 
1631
/* Select frame FRAME.  Also print the stack frame and show the source
1632
   if this is the tui version.  */
1633
static void
1634
select_and_print_frame (struct frame_info *frame)
1635
{
1636
  select_frame (frame);
1637
  if (frame)
1638
    print_stack_frame (frame, 1, SRC_AND_LOC);
1639
}
1640
 
1641
/* Return the symbol-block in which the selected frame is executing.
1642
   Can return zero under various legitimate circumstances.
1643
 
1644
   If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
1645
   code address within the block returned.  We use this to decide
1646
   which macros are in scope.  */
1647
 
1648
struct block *
1649
get_selected_block (CORE_ADDR *addr_in_block)
1650
{
1651
  if (!target_has_stack)
1652
    return 0;
1653
 
1654
  return get_frame_block (get_selected_frame (NULL), addr_in_block);
1655
}
1656
 
1657
/* Find a frame a certain number of levels away from FRAME.
1658
   LEVEL_OFFSET_PTR points to an int containing the number of levels.
1659
   Positive means go to earlier frames (up); negative, the reverse.
1660
   The int that contains the number of levels is counted toward
1661
   zero as the frames for those levels are found.
1662
   If the top or bottom frame is reached, that frame is returned,
1663
   but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
1664
   how much farther the original request asked to go.  */
1665
 
1666
struct frame_info *
1667
find_relative_frame (struct frame_info *frame, int *level_offset_ptr)
1668
{
1669
  /* Going up is simple: just call get_prev_frame enough times or
1670
     until the initial frame is reached.  */
1671
  while (*level_offset_ptr > 0)
1672
    {
1673
      struct frame_info *prev = get_prev_frame (frame);
1674
      if (!prev)
1675
        break;
1676
      (*level_offset_ptr)--;
1677
      frame = prev;
1678
    }
1679
 
1680
  /* Going down is just as simple.  */
1681
  while (*level_offset_ptr < 0)
1682
    {
1683
      struct frame_info *next = get_next_frame (frame);
1684
      if (!next)
1685
        break;
1686
      (*level_offset_ptr)++;
1687
      frame = next;
1688
    }
1689
 
1690
  return frame;
1691
}
1692
 
1693
/* The "select_frame" command.  With no argument this is a NOP.
1694
   Select the frame at level LEVEL_EXP if it is a valid level.
1695
   Otherwise, treat LEVEL_EXP as an address expression and select it.
1696
 
1697
   See parse_frame_specification for more info on proper frame
1698
   expressions.  */
1699
 
1700
void
1701
select_frame_command (char *level_exp, int from_tty)
1702
{
1703
  select_frame (parse_frame_specification_1 (level_exp, "No stack.", NULL));
1704
}
1705
 
1706
/* The "frame" command.  With no argument, print the selected frame
1707
   briefly.  With an argument, behave like select_frame and then print
1708
   the selected frame.  */
1709
 
1710
static void
1711
frame_command (char *level_exp, int from_tty)
1712
{
1713
  select_frame_command (level_exp, from_tty);
1714
  print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
1715
}
1716
 
1717
/* The XDB Compatibility command to print the current frame.  */
1718
 
1719
static void
1720
current_frame_command (char *level_exp, int from_tty)
1721
{
1722
  print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC);
1723
}
1724
 
1725
/* Select the frame up one or COUNT_EXP stack levels from the
1726
   previously selected frame, and print it briefly.  */
1727
 
1728
static void
1729
up_silently_base (char *count_exp)
1730
{
1731
  struct frame_info *frame;
1732
  int count = 1;
1733
 
1734
  if (count_exp)
1735
    count = parse_and_eval_long (count_exp);
1736
 
1737
  frame = find_relative_frame (get_selected_frame ("No stack."), &count);
1738
  if (count != 0 && count_exp == NULL)
1739
    error (_("Initial frame selected; you cannot go up."));
1740
  select_frame (frame);
1741
}
1742
 
1743
static void
1744
up_silently_command (char *count_exp, int from_tty)
1745
{
1746
  up_silently_base (count_exp);
1747
}
1748
 
1749
static void
1750
up_command (char *count_exp, int from_tty)
1751
{
1752
  up_silently_base (count_exp);
1753
  print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
1754
}
1755
 
1756
/* Select the frame down one or COUNT_EXP stack levels from the previously
1757
   selected frame, and print it briefly.  */
1758
 
1759
static void
1760
down_silently_base (char *count_exp)
1761
{
1762
  struct frame_info *frame;
1763
  int count = -1;
1764
  if (count_exp)
1765
    count = -parse_and_eval_long (count_exp);
1766
 
1767
  frame = find_relative_frame (get_selected_frame ("No stack."), &count);
1768
  if (count != 0 && count_exp == NULL)
1769
    {
1770
      /* We only do this if COUNT_EXP is not specified.  That way
1771
         "down" means to really go down (and let me know if that is
1772
         impossible), but "down 9999" can be used to mean go all the
1773
         way down without getting an error.  */
1774
 
1775
      error (_("Bottom (innermost) frame selected; you cannot go down."));
1776
    }
1777
 
1778
  select_frame (frame);
1779
}
1780
 
1781
static void
1782
down_silently_command (char *count_exp, int from_tty)
1783
{
1784
  down_silently_base (count_exp);
1785
}
1786
 
1787
static void
1788
down_command (char *count_exp, int from_tty)
1789
{
1790
  down_silently_base (count_exp);
1791
  print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
1792
}
1793
 
1794
 
1795
void
1796
return_command (char *retval_exp, int from_tty)
1797
{
1798
  struct symbol *thisfun;
1799
  struct value *return_value = NULL;
1800
  const char *query_prefix = "";
1801
 
1802
  thisfun = get_frame_function (get_selected_frame ("No selected frame."));
1803
 
1804
  /* Compute the return value.  If the computation triggers an error,
1805
     let it bail.  If the return type can't be handled, set
1806
     RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
1807
     message.  */
1808
  if (retval_exp)
1809
    {
1810
      struct type *return_type = NULL;
1811
 
1812
      /* Compute the return value.  Should the computation fail, this
1813
         call throws an error.  */
1814
      return_value = parse_and_eval (retval_exp);
1815
 
1816
      /* Cast return value to the return type of the function.  Should
1817
         the cast fail, this call throws an error.  */
1818
      if (thisfun != NULL)
1819
        return_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun));
1820
      if (return_type == NULL)
1821
        return_type = builtin_type_int;
1822
      CHECK_TYPEDEF (return_type);
1823
      return_value = value_cast (return_type, return_value);
1824
 
1825
      /* Make sure the value is fully evaluated.  It may live in the
1826
         stack frame we're about to pop.  */
1827
      if (value_lazy (return_value))
1828
        value_fetch_lazy (return_value);
1829
 
1830
      if (TYPE_CODE (return_type) == TYPE_CODE_VOID)
1831
        /* If the return-type is "void", don't try to find the
1832
           return-value's location.  However, do still evaluate the
1833
           return expression so that, even when the expression result
1834
           is discarded, side effects such as "return i++" still
1835
           occur.  */
1836
        return_value = NULL;
1837
      else if (using_struct_return (return_type))
1838
        {
1839
          query_prefix = "\
1840
The location at which to store the function's return value is unknown.\n\
1841
If you continue, the return value that you specified will be ignored.\n";
1842
          return_value = NULL;
1843
        }
1844
    }
1845
 
1846
  /* Does an interactive user really want to do this?  Include
1847
     information, such as how well GDB can handle the return value, in
1848
     the query message.  */
1849
  if (from_tty)
1850
    {
1851
      int confirmed;
1852
      if (thisfun == NULL)
1853
        confirmed = query (_("%sMake selected stack frame return now? "),
1854
                           query_prefix);
1855
      else
1856
        confirmed = query (_("%sMake %s return now? "), query_prefix,
1857
                           SYMBOL_PRINT_NAME (thisfun));
1858
      if (!confirmed)
1859
        error (_("Not confirmed"));
1860
    }
1861
 
1862
  /* NOTE: cagney/2003-01-18: Is this silly?  Rather than pop each
1863
     frame in turn, should this code just go straight to the relevant
1864
     frame and pop that?  */
1865
 
1866
  /* First discard all frames inner-to the selected frame (making the
1867
     selected frame current).  */
1868
  {
1869
    struct frame_id selected_id = get_frame_id (get_selected_frame (NULL));
1870
    while (!frame_id_eq (selected_id, get_frame_id (get_current_frame ())))
1871
      {
1872
        struct frame_info *frame = get_current_frame ();
1873
        if (frame_id_inner (get_frame_arch (frame), selected_id,
1874
                            get_frame_id (frame)))
1875
          /* Caught in the safety net, oops!  We've gone way past the
1876
             selected frame.  */
1877
          error (_("Problem while popping stack frames (corrupt stack?)"));
1878
        frame_pop (get_current_frame ());
1879
      }
1880
  }
1881
 
1882
  /* Second discard the selected frame (which is now also the current
1883
     frame).  */
1884
  frame_pop (get_current_frame ());
1885
 
1886
  /* Store RETURN_VALUE in the just-returned register set.  */
1887
  if (return_value != NULL)
1888
    {
1889
      struct type *return_type = value_type (return_value);
1890
      struct gdbarch *gdbarch = get_regcache_arch (get_current_regcache ());
1891
      gdb_assert (gdbarch_return_value (gdbarch, return_type, NULL, NULL, NULL)
1892
                  == RETURN_VALUE_REGISTER_CONVENTION);
1893
      gdbarch_return_value (gdbarch, return_type,
1894
                            get_current_regcache (), NULL /*read*/,
1895
                            value_contents (return_value) /*write*/);
1896
    }
1897
 
1898
  /* If we are at the end of a call dummy now, pop the dummy frame
1899
     too.  */
1900
  if (get_frame_type (get_current_frame ()) == DUMMY_FRAME)
1901
    frame_pop (get_current_frame ());
1902
 
1903
  /* If interactive, print the frame that is now current.  */
1904
  if (from_tty)
1905
    frame_command ("0", 1);
1906
  else
1907
    select_frame_command ("0", 0);
1908
}
1909
 
1910
/* Sets the scope to input function name, provided that the function
1911
   is within the current stack frame */
1912
 
1913
struct function_bounds
1914
{
1915
  CORE_ADDR low, high;
1916
};
1917
 
1918
static void
1919
func_command (char *arg, int from_tty)
1920
{
1921
  struct frame_info *frame;
1922
  int found = 0;
1923
  struct symtabs_and_lines sals;
1924
  int i;
1925
  int level = 1;
1926
  struct function_bounds *func_bounds = NULL;
1927
 
1928
  if (arg != NULL)
1929
    return;
1930
 
1931
  frame = parse_frame_specification ("0");
1932
  sals = decode_line_spec (arg, 1);
1933
  func_bounds = (struct function_bounds *) xmalloc (
1934
                              sizeof (struct function_bounds) * sals.nelts);
1935
  for (i = 0; (i < sals.nelts && !found); i++)
1936
    {
1937
      if (sals.sals[i].pc == 0
1938
          || find_pc_partial_function (sals.sals[i].pc, NULL,
1939
                                       &func_bounds[i].low,
1940
                                       &func_bounds[i].high) == 0)
1941
        {
1942
          func_bounds[i].low = func_bounds[i].high = 0;
1943
        }
1944
    }
1945
 
1946
  do
1947
    {
1948
      for (i = 0; (i < sals.nelts && !found); i++)
1949
        found = (get_frame_pc (frame) >= func_bounds[i].low
1950
                 && get_frame_pc (frame) < func_bounds[i].high);
1951
      if (!found)
1952
        {
1953
          level = 1;
1954
          frame = find_relative_frame (frame, &level);
1955
        }
1956
    }
1957
  while (!found && level == 0);
1958
 
1959
  if (func_bounds)
1960
    xfree (func_bounds);
1961
 
1962
  if (!found)
1963
    printf_filtered (_("'%s' not within current stack frame.\n"), arg);
1964
  else if (frame != get_selected_frame (NULL))
1965
    select_and_print_frame (frame);
1966
}
1967
 
1968
/* Gets the language of the current frame.  */
1969
 
1970
enum language
1971
get_frame_language (void)
1972
{
1973
  struct frame_info *frame = deprecated_safe_get_selected_frame ();
1974
 
1975
  if (frame)
1976
    {
1977
      /* We determine the current frame language by looking up its
1978
         associated symtab.  To retrieve this symtab, we use the frame
1979
         PC.  However we cannot use the frame PC as is, because it
1980
         usually points to the instruction following the "call", which
1981
         is sometimes the first instruction of another function.  So
1982
         we rely on get_frame_address_in_block(), it provides us with
1983
         a PC that is guaranteed to be inside the frame's code
1984
         block.  */
1985
      CORE_ADDR pc = get_frame_address_in_block (frame);
1986
      struct symtab *s = find_pc_symtab (pc);
1987
 
1988
      if (s)
1989
        return s->language;
1990
    }
1991
 
1992
  return language_unknown;
1993
}
1994
 
1995
 
1996
/* Provide a prototype to silence -Wmissing-prototypes.  */
1997
void _initialize_stack (void);
1998
 
1999
void
2000
_initialize_stack (void)
2001
{
2002
#if 0
2003
  backtrace_limit = 30;
2004
#endif
2005
 
2006
  add_com ("return", class_stack, return_command, _("\
2007
Make selected stack frame return to its caller.\n\
2008
Control remains in the debugger, but when you continue\n\
2009
execution will resume in the frame above the one now selected.\n\
2010
If an argument is given, it is an expression for the value to return."));
2011
 
2012
  add_com ("up", class_stack, up_command, _("\
2013
Select and print stack frame that called this one.\n\
2014
An argument says how many frames up to go."));
2015
  add_com ("up-silently", class_support, up_silently_command, _("\
2016
Same as the `up' command, but does not print anything.\n\
2017
This is useful in command scripts."));
2018
 
2019
  add_com ("down", class_stack, down_command, _("\
2020
Select and print stack frame called by this one.\n\
2021
An argument says how many frames down to go."));
2022
  add_com_alias ("do", "down", class_stack, 1);
2023
  add_com_alias ("dow", "down", class_stack, 1);
2024
  add_com ("down-silently", class_support, down_silently_command, _("\
2025
Same as the `down' command, but does not print anything.\n\
2026
This is useful in command scripts."));
2027
 
2028
  add_com ("frame", class_stack, frame_command, _("\
2029
Select and print a stack frame.\n\
2030
With no argument, print the selected stack frame.  (See also \"info frame\").\n\
2031
An argument specifies the frame to select.\n\
2032
It can be a stack frame number or the address of the frame.\n\
2033
With argument, nothing is printed if input is coming from\n\
2034
a command file or a user-defined command."));
2035
 
2036
  add_com_alias ("f", "frame", class_stack, 1);
2037
 
2038
  if (xdb_commands)
2039
    {
2040
      add_com ("L", class_stack, current_frame_command,
2041
               _("Print the current stack frame.\n"));
2042
      add_com_alias ("V", "frame", class_stack, 1);
2043
    }
2044
  add_com ("select-frame", class_stack, select_frame_command, _("\
2045
Select a stack frame without printing anything.\n\
2046
An argument specifies the frame to select.\n\
2047
It can be a stack frame number or the address of the frame.\n"));
2048
 
2049
  add_com ("backtrace", class_stack, backtrace_command, _("\
2050
Print backtrace of all stack frames, or innermost COUNT frames.\n\
2051
With a negative argument, print outermost -COUNT frames.\n\
2052
Use of the 'full' qualifier also prints the values of the local variables.\n"));
2053
  add_com_alias ("bt", "backtrace", class_stack, 0);
2054
  if (xdb_commands)
2055
    {
2056
      add_com_alias ("t", "backtrace", class_stack, 0);
2057
      add_com ("T", class_stack, backtrace_full_command, _("\
2058
Print backtrace of all stack frames, or innermost COUNT frames \n\
2059
and the values of the local variables.\n\
2060
With a negative argument, print outermost -COUNT frames.\n\
2061
Usage: T <count>\n"));
2062
    }
2063
 
2064
  add_com_alias ("where", "backtrace", class_alias, 0);
2065
  add_info ("stack", backtrace_command,
2066
            _("Backtrace of the stack, or innermost COUNT frames."));
2067
  add_info_alias ("s", "stack", 1);
2068
  add_info ("frame", frame_info,
2069
            _("All about selected stack frame, or frame at ADDR."));
2070
  add_info_alias ("f", "frame", 1);
2071
  add_info ("locals", locals_info,
2072
            _("Local variables of current stack frame."));
2073
  add_info ("args", args_info,
2074
            _("Argument variables of current stack frame."));
2075
  if (xdb_commands)
2076
    add_com ("l", class_info, args_plus_locals_info,
2077
             _("Argument and local variables of current stack frame."));
2078
 
2079
  if (dbx_commands)
2080
    add_com ("func", class_stack, func_command, _("\
2081
Select the stack frame that contains <func>.\n\
2082
Usage: func <name>\n"));
2083
 
2084
  add_info ("catch", catch_info,
2085
            _("Exceptions that can be caught in the current stack frame."));
2086
 
2087
  add_setshow_enum_cmd ("frame-arguments", class_stack,
2088
                        print_frame_arguments_choices, &print_frame_arguments,
2089
                        _("Set printing of non-scalar frame arguments"),
2090
                        _("Show printing of non-scalar frame arguments"),
2091
                        NULL, NULL, NULL, &setprintlist, &showprintlist);
2092
 
2093
#if 0
2094
  add_cmd ("backtrace-limit", class_stack, set_backtrace_limit_command, _(\
2095
"Specify maximum number of frames for \"backtrace\" to print by default."),
2096
           &setlist);
2097
  add_info ("backtrace-limit", backtrace_limit_info, _("\
2098
The maximum number of frames for \"backtrace\" to print by default."));
2099
#endif
2100
}

powered by: WebSVN 2.1.0

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