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