OpenCores
URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

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

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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