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