GDB (xrefs)

/tmp/gdb-8.1/gdb/stack.c
Go to the documentation of this file.
1 /* Print and select stack frames for GDB, the GNU debugger.
2
3 Copyright (C) 1986-2018 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20 #include "defs.h"
21 #include "value.h"
22 #include "symtab.h"
23 #include "gdbtypes.h"
24 #include "expression.h"
25 #include "language.h"
26 #include "frame.h"
27 #include "gdbcmd.h"
28 #include "gdbcore.h"
29 #include "target.h"
30 #include "source.h"
31 #include "breakpoint.h"
32 #include "demangle.h"
33 #include "inferior.h"
34 #include "annotate.h"
35 #include "ui-out.h"
36 #include "block.h"
37 #include "stack.h"
38 #include "dictionary.h"
39 #include "reggroups.h"
40 #include "regcache.h"
41 #include "solib.h"
42 #include "valprint.h"
43 #include "gdbthread.h"
44 #include "cp-support.h"
45 #include "disasm.h"
46 #include "inline-frame.h"
47 #include "linespec.h"
48 #include "cli/cli-utils.h"
49 #include "objfiles.h"
50
51 #include "safe-ctype.h"
52 #include "symfile.h"
53 #include "extension.h"
54 #include "observer.h"
55 #include "common/def-vector.h"
56
57 /* The possible choices of "set print frame-arguments", and the value
58 of this setting. */
59
60 static const char *const print_frame_arguments_choices[] =
61 {"all", "scalars", "none", NULL};
62 static const char *print_frame_arguments = "scalars";
63
64 /* If non-zero, don't invoke pretty-printers for frame arguments. */
65 static int print_raw_frame_arguments;
66
67 /* The possible choices of "set print entry-values", and the value
68 of this setting. */
69
70 const char print_entry_values_no[] = "no";
71 const char print_entry_values_only[] = "only";
72 const char print_entry_values_preferred[] = "preferred";
73 const char print_entry_values_if_needed[] = "if-needed";
74 const char print_entry_values_both[] = "both";
75 const char print_entry_values_compact[] = "compact";
76 const char print_entry_values_default[] = "default";
77 static const char *const print_entry_values_choices[] =
78 {
79 print_entry_values_no,
80 print_entry_values_only,
81 print_entry_values_preferred,
82 print_entry_values_if_needed,
83 print_entry_values_both,
84 print_entry_values_compact,
85 print_entry_values_default,
86 NULL
87 };
88 const char *print_entry_values = print_entry_values_default;
89
90 /* Prototypes for local functions. */
91
92 static void print_frame_local_vars (struct frame_info *, int,
93 struct ui_file *);
94
95 static void print_frame (struct frame_info *frame, int print_level,
96 enum print_what print_what, int print_args,
97 struct symtab_and_line sal);
98
99 static void set_last_displayed_sal (int valid,
100 struct program_space *pspace,
101 CORE_ADDR addr,
102 struct symtab *symtab,
103 int line);
104
105 /* Zero means do things normally; we are interacting directly with the
106 user. One means print the full filename and linenumber when a
107 frame is printed, and do so in a format emacs18/emacs19.22 can
108 parse. Two means print similar annotations, but in many more
109 cases and in a slightly different syntax. */
110
111 int annotation_level = 0;
112
113 /* These variables hold the last symtab and line we displayed to the user.
114 * This is where we insert a breakpoint or a skiplist entry by default. */
115 static int last_displayed_sal_valid = 0;
116 static struct program_space *last_displayed_pspace = 0;
117 static CORE_ADDR last_displayed_addr = 0;
118 static struct symtab *last_displayed_symtab = 0;
119 static int last_displayed_line = 0;
120
121
122 /* Return 1 if we should display the address in addition to the location,
123 because we are in the middle of a statement. */
124
125 static int
126 frame_show_address (struct frame_info *frame,
127 struct symtab_and_line sal)
128 {
129 /* If there is a line number, but no PC, then there is no location
130 information associated with this sal. The only way that should
131 happen is for the call sites of inlined functions (SAL comes from
132 find_frame_sal). Otherwise, we would have some PC range if the
133 SAL came from a line table. */
134 if (sal.line != 0 && sal.pc == 0 && sal.end == 0)
135 {
136 if (get_next_frame (frame) == NULL)
137 gdb_assert (inline_skipped_frames (inferior_ptid) > 0);
138 else
139 gdb_assert (get_frame_type (get_next_frame (frame)) == INLINE_FRAME);
140 return 0;
141 }
142
143 return get_frame_pc (frame) != sal.pc;
144 }
145
146 /* See frame.h. */
147
148 void
149 print_stack_frame_to_uiout (struct ui_out *uiout, struct frame_info *frame,
150 int print_level, enum print_what print_what,
151 int set_current_sal)
152 {
153 scoped_restore save_uiout = make_scoped_restore (&current_uiout, uiout);
154
155 print_stack_frame (frame, print_level, print_what, set_current_sal);
156 }
157
158 /* Show or print a stack frame FRAME briefly. The output is formatted
159 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
160 relative level, function name, argument list, and file name and
161 line number. If the frame's PC is not at the beginning of the
162 source line, the actual PC is printed at the beginning. */
163
164 void
165 print_stack_frame (struct frame_info *frame, int print_level,
166 enum print_what print_what,
167 int set_current_sal)
168 {
169
170 /* For mi, alway print location and address. */
171 if (current_uiout->is_mi_like_p ())
172 print_what = LOC_AND_ADDRESS;
173
174 TRY
175 {
176 print_frame_info (frame, print_level, print_what, 1 /* print_args */,
177 set_current_sal);
178 if (set_current_sal)
179 set_current_sal_from_frame (frame);
180 }
181 CATCH (e, RETURN_MASK_ERROR)
182 {
183 }
184 END_CATCH
185 }
186
187 /* Print nameless arguments of frame FRAME on STREAM, where START is
188 the offset of the first nameless argument, and NUM is the number of
189 nameless arguments to print. FIRST is nonzero if this is the first
190 argument (not just the first nameless argument). */
191
192 static void
193 print_frame_nameless_args (struct frame_info *frame, long start, int num,
194 int first, struct ui_file *stream)
195 {
196 struct gdbarch *gdbarch = get_frame_arch (frame);
197 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
198 int i;
199 CORE_ADDR argsaddr;
200 long arg_value;
201
202 for (i = 0; i < num; i++)
203 {
204 QUIT;
205 argsaddr = get_frame_args_address (frame);
206 if (!argsaddr)
207 return;
208 arg_value = read_memory_integer (argsaddr + start,
209 sizeof (int), byte_order);
210 if (!first)
211 fprintf_filtered (stream, ", ");
212 fprintf_filtered (stream, "%ld", arg_value);
213 first = 0;
214 start += sizeof (int);
215 }
216 }
217
218 /* Print single argument of inferior function. ARG must be already
219 read in.
220
221 Errors are printed as if they would be the parameter value. Use zeroed ARG
222 iff it should not be printed accoring to user settings. */
223
224 static void
225 print_frame_arg (const struct frame_arg *arg)
226 {
227 struct ui_out *uiout = current_uiout;
228 const char *error_message = NULL;
229
230 string_file stb;
231
232 gdb_assert (!arg->val || !arg->error);
233 gdb_assert (arg->entry_kind == print_entry_values_no
234 || arg->entry_kind == print_entry_values_only
235 || (!uiout->is_mi_like_p ()
236 && arg->entry_kind == print_entry_values_compact));
237
238 annotate_arg_emitter arg_emitter;
239 ui_out_emit_tuple tuple_emitter (uiout, NULL);
240 fprintf_symbol_filtered (&stb, SYMBOL_PRINT_NAME (arg->sym),
241 SYMBOL_LANGUAGE (arg->sym), DMGL_PARAMS | DMGL_ANSI);
242 if (arg->entry_kind == print_entry_values_compact)
243 {
244 /* It is OK to provide invalid MI-like stream as with
245 PRINT_ENTRY_VALUE_COMPACT we never use MI. */
246 stb.puts ("=");
247
248 fprintf_symbol_filtered (&stb, SYMBOL_PRINT_NAME (arg->sym),
249 SYMBOL_LANGUAGE (arg->sym),
250 DMGL_PARAMS | DMGL_ANSI);
251 }
252 if (arg->entry_kind == print_entry_values_only
253 || arg->entry_kind == print_entry_values_compact)
254 stb.puts ("@entry");
255 uiout->field_stream ("name", stb);
256 annotate_arg_name_end ();
257 uiout->text ("=");
258
259 if (!arg->val && !arg->error)
260 uiout->text ("...");
261 else
262 {
263 if (arg->error)
264 error_message = arg->error;
265 else
266 {
267 TRY
268 {
269 const struct language_defn *language;
270 struct value_print_options opts;
271
272 /* Avoid value_print because it will deref ref parameters. We
273 just want to print their addresses. Print ??? for args whose
274 address we do not know. We pass 2 as "recurse" to val_print
275 because our standard indentation here is 4 spaces, and
276 val_print indents 2 for each recurse. */
277
278 annotate_arg_value (value_type (arg->val));
279
280 /* Use the appropriate language to display our symbol, unless the
281 user forced the language to a specific language. */
282 if (language_mode == language_mode_auto)
283 language = language_def (SYMBOL_LANGUAGE (arg->sym));
284 else
285 language = current_language;
286
287 get_no_prettyformat_print_options (&opts);
288 opts.deref_ref = 1;
289 opts.raw = print_raw_frame_arguments;
290
291 /* True in "summary" mode, false otherwise. */
292 opts.summary = !strcmp (print_frame_arguments, "scalars");
293
294 common_val_print (arg->val, &stb, 2, &opts, language);
295 }
296 CATCH (except, RETURN_MASK_ERROR)
297 {
298 error_message = except.message;
299 }
300 END_CATCH
301 }
302 if (error_message != NULL)
303 stb.printf (_("<error reading variable: %s>"), error_message);
304 }
305
306 uiout->field_stream ("value", stb);
307 }
308
309 /* Read in inferior function local SYM at FRAME into ARGP. Caller is
310 responsible for xfree of ARGP->ERROR. This function never throws an
311 exception. */
312
313 void
314 read_frame_local (struct symbol *sym, struct frame_info *frame,
315 struct frame_arg *argp)
316 {
317 argp->sym = sym;
318 argp->val = NULL;
319 argp->error = NULL;
320
321 TRY
322 {
323 argp->val = read_var_value (sym, NULL, frame);
324 }
325 CATCH (except, RETURN_MASK_ERROR)
326 {
327 argp->error = xstrdup (except.message);
328 }
329 END_CATCH
330 }
331
332 /* Read in inferior function parameter SYM at FRAME into ARGP. Caller is
333 responsible for xfree of ARGP->ERROR. This function never throws an
334 exception. */
335
336 void
337 read_frame_arg (struct symbol *sym, struct frame_info *frame,
338 struct frame_arg *argp, struct frame_arg *entryargp)
339 {
340 struct value *val = NULL, *entryval = NULL;
341 char *val_error = NULL, *entryval_error = NULL;
342 int val_equal = 0;
343
344 if (print_entry_values != print_entry_values_only
345 && print_entry_values != print_entry_values_preferred)
346 {
347 TRY
348 {
349 val = read_var_value (sym, NULL, frame);
350 }
351 CATCH (except, RETURN_MASK_ERROR)
352 {
353 val_error = (char *) alloca (strlen (except.message) + 1);
354 strcpy (val_error, except.message);
355 }
356 END_CATCH
357 }
358
359 if (SYMBOL_COMPUTED_OPS (sym) != NULL
360 && SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry != NULL
361 && print_entry_values != print_entry_values_no
362 && (print_entry_values != print_entry_values_if_needed
363 || !val || value_optimized_out (val)))
364 {
365 TRY
366 {
367 const struct symbol_computed_ops *ops;
368
369 ops = SYMBOL_COMPUTED_OPS (sym);
370 entryval = ops->read_variable_at_entry (sym, frame);
371 }
372 CATCH (except, RETURN_MASK_ERROR)
373 {
374 if (except.error != NO_ENTRY_VALUE_ERROR)
375 {
376 entryval_error = (char *) alloca (strlen (except.message) + 1);
377 strcpy (entryval_error, except.message);
378 }
379 }
380 END_CATCH
381
382 if (entryval != NULL && value_optimized_out (entryval))
383 entryval = NULL;
384
385 if (print_entry_values == print_entry_values_compact
386 || print_entry_values == print_entry_values_default)
387 {
388 /* For MI do not try to use print_entry_values_compact for ARGP. */
389
390 if (val && entryval && !current_uiout->is_mi_like_p ())
391 {
392 struct type *type = value_type (val);
393
394 if (value_lazy (val))
395 value_fetch_lazy (val);
396 if (value_lazy (entryval))
397 value_fetch_lazy (entryval);
398
399 if (value_contents_eq (val, 0, entryval, 0, TYPE_LENGTH (type)))
400 {
401 /* Initialize it just to avoid a GCC false warning. */
402 struct value *val_deref = NULL, *entryval_deref;
403
404 /* DW_AT_call_value does match with the current
405 value. If it is a reference still try to verify if
406 dereferenced DW_AT_call_data_value does not differ. */
407
408 TRY
409 {
410 struct type *type_deref;
411
412 val_deref = coerce_ref (val);
413 if (value_lazy (val_deref))
414 value_fetch_lazy (val_deref);
415 type_deref = value_type (val_deref);
416
417 entryval_deref = coerce_ref (entryval);
418 if (value_lazy (entryval_deref))
419 value_fetch_lazy (entryval_deref);
420
421 /* If the reference addresses match but dereferenced
422 content does not match print them. */
423 if (val != val_deref
424 && value_contents_eq (val_deref, 0,
425 entryval_deref, 0,
426 TYPE_LENGTH (type_deref)))
427 val_equal = 1;
428 }
429 CATCH (except, RETURN_MASK_ERROR)
430 {
431 /* If the dereferenced content could not be
432 fetched do not display anything. */
433 if (except.error == NO_ENTRY_VALUE_ERROR)
434 val_equal = 1;
435 else if (except.message != NULL)
436 {
437 entryval_error = (char *) alloca (strlen (except.message) + 1);
438 strcpy (entryval_error, except.message);
439 }
440 }
441 END_CATCH
442
443 /* Value was not a reference; and its content matches. */
444 if (val == val_deref)
445 val_equal = 1;
446
447 if (val_equal)
448 entryval = NULL;
449 }
450 }
451
452 /* Try to remove possibly duplicate error message for ENTRYARGP even
453 in MI mode. */
454
455 if (val_error && entryval_error
456 && strcmp (val_error, entryval_error) == 0)
457 {
458 entryval_error = NULL;
459
460 /* Do not se VAL_EQUAL as the same error message may be shown for
461 the entry value even if no entry values are present in the
462 inferior. */
463 }
464 }
465 }
466
467 if (entryval == NULL)
468 {
469 if (print_entry_values == print_entry_values_preferred)
470 {
471 gdb_assert (val == NULL);
472
473 TRY
474 {
475 val = read_var_value (sym, NULL, frame);
476 }
477 CATCH (except, RETURN_MASK_ERROR)
478 {
479 val_error = (char *) alloca (strlen (except.message) + 1);
480 strcpy (val_error, except.message);
481 }
482 END_CATCH
483 }
484 if (print_entry_values == print_entry_values_only
485 || print_entry_values == print_entry_values_both
486 || (print_entry_values == print_entry_values_preferred
487 && (!val || value_optimized_out (val))))
488 {
489 entryval = allocate_optimized_out_value (SYMBOL_TYPE (sym));
490 entryval_error = NULL;
491 }
492 }
493 if ((print_entry_values == print_entry_values_compact
494 || print_entry_values == print_entry_values_if_needed
495 || print_entry_values == print_entry_values_preferred)
496 && (!val || value_optimized_out (val)) && entryval != NULL)
497 {
498 val = NULL;
499 val_error = NULL;
500 }
501
502 argp->sym = sym;
503 argp->val = val;
504 argp->error = val_error ? xstrdup (val_error) : NULL;
505 if (!val && !val_error)
506 argp->entry_kind = print_entry_values_only;
507 else if ((print_entry_values == print_entry_values_compact
508 || print_entry_values == print_entry_values_default) && val_equal)
509 {
510 argp->entry_kind = print_entry_values_compact;
511 gdb_assert (!current_uiout->is_mi_like_p ());
512 }
513 else
514 argp->entry_kind = print_entry_values_no;
515
516 entryargp->sym = sym;
517 entryargp->val = entryval;
518 entryargp->error = entryval_error ? xstrdup (entryval_error) : NULL;
519 if (!entryval && !entryval_error)
520 entryargp->entry_kind = print_entry_values_no;
521 else
522 entryargp->entry_kind = print_entry_values_only;
523 }
524
525 /* Print the arguments of frame FRAME on STREAM, given the function
526 FUNC running in that frame (as a symbol), where NUM is the number
527 of arguments according to the stack frame (or -1 if the number of
528 arguments is unknown). */
529
530 /* Note that currently the "number of arguments according to the
531 stack frame" is only known on VAX where i refers to the "number of
532 ints of arguments according to the stack frame". */
533
534 static void
535 print_frame_args (struct symbol *func, struct frame_info *frame,
536 int num, struct ui_file *stream)
537 {
538 struct ui_out *uiout = current_uiout;
539 int first = 1;
540 /* Offset of next stack argument beyond the one we have seen that is
541 at the highest offset, or -1 if we haven't come to a stack
542 argument yet. */
543 long highest_offset = -1;
544 /* Number of ints of arguments that we have printed so far. */
545 int args_printed = 0;
546 /* True if we should print arguments, false otherwise. */
547 int print_args = strcmp (print_frame_arguments, "none");
548
549 if (func)
550 {
551 const struct block *b = SYMBOL_BLOCK_VALUE (func);
552 struct block_iterator iter;
553 struct symbol *sym;
554
555 ALL_BLOCK_SYMBOLS (b, iter, sym)
556 {
557 struct frame_arg arg, entryarg;
558
559 QUIT;
560
561 /* Keep track of the highest stack argument offset seen, and
562 skip over any kinds of symbols we don't care about. */
563
564 if (!SYMBOL_IS_ARGUMENT (sym))
565 continue;
566
567 switch (SYMBOL_CLASS (sym))
568 {
569 case LOC_ARG:
570 case LOC_REF_ARG:
571 {
572 long current_offset = SYMBOL_VALUE (sym);
573 int arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym));
574
575 /* Compute address of next argument by adding the size of
576 this argument and rounding to an int boundary. */
577 current_offset =
578 ((current_offset + arg_size + sizeof (int) - 1)
579 & ~(sizeof (int) - 1));
580
581 /* If this is the highest offset seen yet, set
582 highest_offset. */
583 if (highest_offset == -1
584 || (current_offset > highest_offset))
585 highest_offset = current_offset;
586
587 /* Add the number of ints we're about to print to
588 args_printed. */
589 args_printed += (arg_size + sizeof (int) - 1) / sizeof (int);
590 }
591
592 /* We care about types of symbols, but don't need to
593 keep track of stack offsets in them. */
594 case LOC_REGISTER:
595 case LOC_REGPARM_ADDR:
596 case LOC_COMPUTED:
597 case LOC_OPTIMIZED_OUT:
598 default:
599 break;
600 }
601
602 /* We have to look up the symbol because arguments can have
603 two entries (one a parameter, one a local) and the one we
604 want is the local, which lookup_symbol will find for us.
605 This includes gcc1 (not gcc2) on SPARC when passing a
606 small structure and gcc2 when the argument type is float
607 and it is passed as a double and converted to float by
608 the prologue (in the latter case the type of the LOC_ARG
609 symbol is double and the type of the LOC_LOCAL symbol is
610 float). */
611 /* But if the parameter name is null, don't try it. Null
612 parameter names occur on the RS/6000, for traceback
613 tables. FIXME, should we even print them? */
614
615 if (*SYMBOL_LINKAGE_NAME (sym))
616 {
617 struct symbol *nsym;
618
619 nsym = lookup_symbol_search_name (SYMBOL_SEARCH_NAME (sym),
620 b, VAR_DOMAIN).symbol;
621 gdb_assert (nsym != NULL);
622 if (SYMBOL_CLASS (nsym) == LOC_REGISTER
623 && !SYMBOL_IS_ARGUMENT (nsym))
624 {
625 /* There is a LOC_ARG/LOC_REGISTER pair. This means
626 that it was passed on the stack and loaded into a
627 register, or passed in a register and stored in a
628 stack slot. GDB 3.x used the LOC_ARG; GDB
629 4.0-4.11 used the LOC_REGISTER.
630
631 Reasons for using the LOC_ARG:
632
633 (1) Because find_saved_registers may be slow for
634 remote debugging.
635
636 (2) Because registers are often re-used and stack
637 slots rarely (never?) are. Therefore using
638 the stack slot is much less likely to print
639 garbage.
640
641 Reasons why we might want to use the LOC_REGISTER:
642
643 (1) So that the backtrace prints the same value
644 as "print foo". I see no compelling reason
645 why this needs to be the case; having the
646 backtrace print the value which was passed
647 in, and "print foo" print the value as
648 modified within the called function, makes
649 perfect sense to me.
650
651 Additional note: It might be nice if "info args"
652 displayed both values.
653
654 One more note: There is a case with SPARC
655 structure passing where we need to use the
656 LOC_REGISTER, but this is dealt with by creating
657 a single LOC_REGPARM in symbol reading. */
658
659 /* Leave sym (the LOC_ARG) alone. */
660 ;
661 }
662 else
663 sym = nsym;
664 }
665
666 /* Print the current arg. */
667 if (!first)
668 uiout->text (", ");
669 uiout->wrap_hint (" ");
670
671 if (!print_args)
672 {
673 memset (&arg, 0, sizeof (arg));
674 arg.sym = sym;
675 arg.entry_kind = print_entry_values_no;
676 memset (&entryarg, 0, sizeof (entryarg));
677 entryarg.sym = sym;
678 entryarg.entry_kind = print_entry_values_no;
679 }
680 else
681 read_frame_arg (sym, frame, &arg, &entryarg);
682
683 if (arg.entry_kind != print_entry_values_only)
684 print_frame_arg (&arg);
685
686 if (entryarg.entry_kind != print_entry_values_no)
687 {
688 if (arg.entry_kind != print_entry_values_only)
689 {
690 uiout->text (", ");
691 uiout->wrap_hint (" ");
692 }
693
694 print_frame_arg (&entryarg);
695 }
696
697 xfree (arg.error);
698 xfree (entryarg.error);
699
700 first = 0;
701 }
702 }
703
704 /* Don't print nameless args in situations where we don't know
705 enough about the stack to find them. */
706 if (num != -1)
707 {
708 long start;
709
710 if (highest_offset == -1)
711 start = gdbarch_frame_args_skip (get_frame_arch (frame));
712 else
713 start = highest_offset;
714
715 print_frame_nameless_args (frame, start, num - args_printed,
716 first, stream);
717 }
718 }
719
720 /* Set the current source and line to the location given by frame
721 FRAME, if possible. When CENTER is true, adjust so the relevant
722 line is in the center of the next 'list'. */
723
724 void
725 set_current_sal_from_frame (struct frame_info *frame)
726 {
727 symtab_and_line sal = find_frame_sal (frame);
728 if (sal.symtab != NULL)
729 set_current_source_symtab_and_line (sal);
730 }
731
732 /* If ON, GDB will display disassembly of the next source line when
733 execution of the program being debugged stops.
734 If AUTO (which is the default), or there's no line info to determine
735 the source line of the next instruction, display disassembly of next
736 instruction instead. */
737
738 static enum auto_boolean disassemble_next_line;
739
740 static void
741 show_disassemble_next_line (struct ui_file *file, int from_tty,
742 struct cmd_list_element *c,
743 const char *value)
744 {
745 fprintf_filtered (file,
746 _("Debugger's willingness to use "
747 "disassemble-next-line is %s.\n"),
748 value);
749 }
750
751 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
752 because it will be broken by filter sometime. */
753
754 static void
755 do_gdb_disassembly (struct gdbarch *gdbarch,
756 int how_many, CORE_ADDR low, CORE_ADDR high)
757 {
758
759 TRY
760 {
761 gdb_disassembly (gdbarch, current_uiout,
762 DISASSEMBLY_RAW_INSN, how_many,
763 low, high);
764 }
765 CATCH (exception, RETURN_MASK_ERROR)
766 {
767 /* If an exception was thrown while doing the disassembly, print
768 the error message, to give the user a clue of what happened. */
769 exception_print (gdb_stderr, exception);
770 }
771 END_CATCH
772 }
773
774 /* Print information about frame FRAME. The output is format according
775 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. The meaning of
776 PRINT_WHAT is:
777
778 SRC_LINE: Print only source line.
779 LOCATION: Print only location.
780 LOC_AND_SRC: Print location and source line.
781
782 Used in "where" output, and to emit breakpoint or step
783 messages. */
784
785 void
786 print_frame_info (struct frame_info *frame, int print_level,
787 enum print_what print_what, int print_args,
788 int set_current_sal)
789 {
790 struct gdbarch *gdbarch = get_frame_arch (frame);
791 int source_print;
792 int location_print;
793 struct ui_out *uiout = current_uiout;
794
795 if (get_frame_type (frame) == DUMMY_FRAME
796 || get_frame_type (frame) == SIGTRAMP_FRAME
797 || get_frame_type (frame) == ARCH_FRAME)
798 {
799 ui_out_emit_tuple tuple_emitter (uiout, "frame");
800
801 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
802 gdbarch, get_frame_pc (frame));
803
804 /* Do this regardless of SOURCE because we don't have any source
805 to list for this frame. */
806 if (print_level)
807 {
808 uiout->text ("#");
809 uiout->field_fmt_int (2, ui_left, "level",
810 frame_relative_level (frame));
811 }
812 if (uiout->is_mi_like_p ())
813 {
814 annotate_frame_address ();
815 uiout->field_core_addr ("addr",
816 gdbarch, get_frame_pc (frame));
817 annotate_frame_address_end ();
818 }
819
820 if (get_frame_type (frame) == DUMMY_FRAME)
821 {
822 annotate_function_call ();
823 uiout->field_string ("func", "<function called from gdb>");
824 }
825 else if (get_frame_type (frame) == SIGTRAMP_FRAME)
826 {
827 annotate_signal_handler_caller ();
828 uiout->field_string ("func", "<signal handler called>");
829 }
830 else if (get_frame_type (frame) == ARCH_FRAME)
831 {
832 uiout->field_string ("func", "<cross-architecture call>");
833 }
834 uiout->text ("\n");
835 annotate_frame_end ();
836
837 /* If disassemble-next-line is set to auto or on output the next
838 instruction. */
839 if (disassemble_next_line == AUTO_BOOLEAN_AUTO
840 || disassemble_next_line == AUTO_BOOLEAN_TRUE)
841 do_gdb_disassembly (get_frame_arch (frame), 1,
842 get_frame_pc (frame), get_frame_pc (frame) + 1);
843
844 return;
845 }
846
847 /* If FRAME is not the innermost frame, that normally means that
848 FRAME->pc points to *after* the call instruction, and we want to
849 get the line containing the call, never the next line. But if
850 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
851 next frame was not entered as the result of a call, and we want
852 to get the line containing FRAME->pc. */
853 symtab_and_line sal = find_frame_sal (frame);
854
855 location_print = (print_what == LOCATION
856 || print_what == LOC_AND_ADDRESS
857 || print_what == SRC_AND_LOC);
858
859 if (location_print || !sal.symtab)
860 print_frame (frame, print_level, print_what, print_args, sal);
861
862 source_print = (print_what == SRC_LINE || print_what == SRC_AND_LOC);
863
864 /* If disassemble-next-line is set to auto or on and doesn't have
865 the line debug messages for $pc, output the next instruction. */
866 if ((disassemble_next_line == AUTO_BOOLEAN_AUTO
867 || disassemble_next_line == AUTO_BOOLEAN_TRUE)
868 && source_print && !sal.symtab)
869 do_gdb_disassembly (get_frame_arch (frame), 1,
870 get_frame_pc (frame), get_frame_pc (frame) + 1);
871
872 if (source_print && sal.symtab)
873 {
874 int done = 0;
875 int mid_statement = ((print_what == SRC_LINE)
876 && frame_show_address (frame, sal));
877
878 if (annotation_level)
879 done = identify_source_line (sal.symtab, sal.line, mid_statement,
880 get_frame_pc (frame));
881 if (!done)
882 {
883 if (deprecated_print_frame_info_listing_hook)
884 deprecated_print_frame_info_listing_hook (sal.symtab,
885 sal.line,
886 sal.line + 1, 0);
887 else
888 {
889 struct value_print_options opts;
890
891 get_user_print_options (&opts);
892 /* We used to do this earlier, but that is clearly
893 wrong. This function is used by many different
894 parts of gdb, including normal_stop in infrun.c,
895 which uses this to print out the current PC
896 when we stepi/nexti into the middle of a source
897 line. Only the command line really wants this
898 behavior. Other UIs probably would like the
899 ability to decide for themselves if it is desired. */
900 if (opts.addressprint && mid_statement)
901 {
902 uiout->field_core_addr ("addr",
903 gdbarch, get_frame_pc (frame));
904 uiout->text ("\t");
905 }
906
907 print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);
908 }
909 }
910
911 /* If disassemble-next-line is set to on and there is line debug
912 messages, output assembly codes for next line. */
913 if (disassemble_next_line == AUTO_BOOLEAN_TRUE)
914 do_gdb_disassembly (get_frame_arch (frame), -1, sal.pc, sal.end);
915 }
916
917 if (set_current_sal)
918 {
919 CORE_ADDR pc;
920
921 if (get_frame_pc_if_available (frame, &pc))
922 set_last_displayed_sal (1, sal.pspace, pc, sal.symtab, sal.line);
923 else
924 set_last_displayed_sal (0, 0, 0, 0, 0);
925 }
926
927 annotate_frame_end ();
928
929 gdb_flush (gdb_stdout);
930 }
931
932 /* Remember the last symtab and line we displayed, which we use e.g.
933 * as the place to put a breakpoint when the `break' command is
934 * invoked with no arguments. */
935
936 static void
937 set_last_displayed_sal (int valid, struct program_space *pspace,
938 CORE_ADDR addr, struct symtab *symtab,
939 int line)
940 {
941 last_displayed_sal_valid = valid;
942 last_displayed_pspace = pspace;
943 last_displayed_addr = addr;
944 last_displayed_symtab = symtab;
945 last_displayed_line = line;
946 if (valid && pspace == NULL)
947 {
948 clear_last_displayed_sal ();
949 internal_error (__FILE__, __LINE__,
950 _("Trying to set NULL pspace."));
951 }
952 }
953
954 /* Forget the last sal we displayed. */
955
956 void
957 clear_last_displayed_sal (void)
958 {
959 last_displayed_sal_valid = 0;
960 last_displayed_pspace = 0;
961 last_displayed_addr = 0;
962 last_displayed_symtab = 0;
963 last_displayed_line = 0;
964 }
965
966 /* Is our record of the last sal we displayed valid? If not,
967 * the get_last_displayed_* functions will return NULL or 0, as
968 * appropriate. */
969
970 int
971 last_displayed_sal_is_valid (void)
972 {
973 return last_displayed_sal_valid;
974 }
975
976 /* Get the pspace of the last sal we displayed, if it's valid. */
977
978 struct program_space *
979 get_last_displayed_pspace (void)
980 {
981 if (last_displayed_sal_valid)
982 return last_displayed_pspace;
983 return 0;
984 }
985
986 /* Get the address of the last sal we displayed, if it's valid. */
987
988 CORE_ADDR
989 get_last_displayed_addr (void)
990 {
991 if (last_displayed_sal_valid)
992 return last_displayed_addr;
993 return 0;
994 }
995
996 /* Get the symtab of the last sal we displayed, if it's valid. */
997
998 struct symtab*
999 get_last_displayed_symtab (void)
1000 {
1001 if (last_displayed_sal_valid)
1002 return last_displayed_symtab;
1003 return 0;
1004 }
1005
1006 /* Get the line of the last sal we displayed, if it's valid. */
1007
1008 int
1009 get_last_displayed_line (void)
1010 {
1011 if (last_displayed_sal_valid)
1012 return last_displayed_line;
1013 return 0;
1014 }
1015
1016 /* Get the last sal we displayed, if it's valid. */
1017
1018 symtab_and_line
1019 get_last_displayed_sal ()
1020 {
1021 symtab_and_line sal;
1022
1023 if (last_displayed_sal_valid)
1024 {
1025 sal.pspace = last_displayed_pspace;
1026 sal.pc = last_displayed_addr;
1027 sal.symtab = last_displayed_symtab;
1028 sal.line = last_displayed_line;
1029 }
1030
1031 return sal;
1032 }
1033
1034
1035 /* Attempt to obtain the name, FUNLANG and optionally FUNCP of the function
1036 corresponding to FRAME. */
1037
1038 gdb::unique_xmalloc_ptr<char>
1039 find_frame_funname (struct frame_info *frame, enum language *funlang,
1040 struct symbol **funcp)
1041 {
1042 struct symbol *func;
1043 gdb::unique_xmalloc_ptr<char> funname;
1044
1045 *funlang = language_unknown;
1046 if (funcp)
1047 *funcp = NULL;
1048
1049 func = get_frame_function (frame);
1050 if (func)
1051 {
1052 /* In certain pathological cases, the symtabs give the wrong
1053 function (when we are in the first function in a file which
1054 is compiled without debugging symbols, the previous function
1055 is compiled with debugging symbols, and the "foo.o" symbol
1056 that is supposed to tell us where the file with debugging
1057 symbols ends has been truncated by ar because it is longer
1058 than 15 characters). This also occurs if the user uses asm()
1059 to create a function but not stabs for it (in a file compiled
1060 with -g).
1061
1062 So look in the minimal symbol tables as well, and if it comes
1063 up with a larger address for the function use that instead.
1064 I don't think this can ever cause any problems; there
1065 shouldn't be any minimal symbols in the middle of a function;
1066 if this is ever changed many parts of GDB will need to be
1067 changed (and we'll create a find_pc_minimal_function or some
1068 such). */
1069
1070 struct bound_minimal_symbol msymbol;
1071
1072 /* Don't attempt to do this for inlined functions, which do not
1073 have a corresponding minimal symbol. */
1074 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func)))
1075 msymbol
1076 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame));
1077 else
1078 memset (&msymbol, 0, sizeof (msymbol));
1079
1080 if (msymbol.minsym != NULL
1081 && (BMSYMBOL_VALUE_ADDRESS (msymbol)
1082 > BLOCK_START (SYMBOL_BLOCK_VALUE (func))))
1083 {
1084 /* We also don't know anything about the function besides
1085 its address and name. */
1086 func = 0;
1087 funname.reset (xstrdup (MSYMBOL_PRINT_NAME (msymbol.minsym)));
1088 *funlang = MSYMBOL_LANGUAGE (msymbol.minsym);
1089 }
1090 else
1091 {
1092 const char *print_name = SYMBOL_PRINT_NAME (func);
1093
1094 *funlang = SYMBOL_LANGUAGE (func);
1095 if (funcp)
1096 *funcp = func;
1097 if (*funlang == language_cplus)
1098 {
1099 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1100 to display the demangled name that we already have
1101 stored in the symbol table, but we stored a version
1102 with DMGL_PARAMS turned on, and here we don't want to
1103 display parameters. So remove the parameters. */
1104 funname = cp_remove_params (print_name);
1105 }
1106
1107 /* If we didn't hit the C++ case above, set *funname
1108 here. */
1109 if (funname == NULL)
1110 funname.reset (xstrdup (print_name));
1111 }
1112 }
1113 else
1114 {
1115 struct bound_minimal_symbol msymbol;
1116 CORE_ADDR pc;
1117
1118 if (!get_frame_address_in_block_if_available (frame, &pc))
1119 return funname;
1120
1121 msymbol = lookup_minimal_symbol_by_pc (pc);
1122 if (msymbol.minsym != NULL)
1123 {
1124 funname.reset (xstrdup (MSYMBOL_PRINT_NAME (msymbol.minsym)));
1125 *funlang = MSYMBOL_LANGUAGE (msymbol.minsym);
1126 }
1127 }
1128
1129 return funname;
1130 }
1131
1132 static void
1133 print_frame (struct frame_info *frame, int print_level,
1134 enum print_what print_what, int print_args,
1135 struct symtab_and_line sal)
1136 {
1137 struct gdbarch *gdbarch = get_frame_arch (frame);
1138 struct ui_out *uiout = current_uiout;
1139 enum language funlang = language_unknown;
1140 struct value_print_options opts;
1141 struct symbol *func;
1142 CORE_ADDR pc = 0;
1143 int pc_p;
1144
1145 pc_p = get_frame_pc_if_available (frame, &pc);
1146
1147 gdb::unique_xmalloc_ptr<char> funname
1148 = find_frame_funname (frame, &funlang, &func);
1149
1150 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
1151 gdbarch, pc);
1152
1153 {
1154 ui_out_emit_tuple tuple_emitter (uiout, "frame");
1155
1156 if (print_level)
1157 {
1158 uiout->text ("#");
1159 uiout->field_fmt_int (2, ui_left, "level",
1160 frame_relative_level (frame));
1161 }
1162 get_user_print_options (&opts);
1163 if (opts.addressprint)
1164 if (!sal.symtab
1165 || frame_show_address (frame, sal)
1166 || print_what == LOC_AND_ADDRESS)
1167 {
1168 annotate_frame_address ();
1169 if (pc_p)
1170 uiout->field_core_addr ("addr", gdbarch, pc);
1171 else
1172 uiout->field_string ("addr", "<unavailable>");
1173 annotate_frame_address_end ();
1174 uiout->text (" in ");
1175 }
1176 annotate_frame_function_name ();
1177
1178 string_file stb;
1179 fprintf_symbol_filtered (&stb, funname ? funname.get () : "??",
1180 funlang, DMGL_ANSI);
1181 uiout->field_stream ("func", stb);
1182 uiout->wrap_hint (" ");
1183 annotate_frame_args ();
1184
1185 uiout->text (" (");
1186 if (print_args)
1187 {
1188 struct gdbarch *gdbarch = get_frame_arch (frame);
1189 int numargs;
1190
1191 if (gdbarch_frame_num_args_p (gdbarch))
1192 {
1193 numargs = gdbarch_frame_num_args (gdbarch, frame);
1194 gdb_assert (numargs >= 0);
1195 }
1196 else
1197 numargs = -1;
1198
1199 {
1200 ui_out_emit_list list_emitter (uiout, "args");
1201 TRY
1202 {
1203 print_frame_args (func, frame, numargs, gdb_stdout);
1204 }
1205 CATCH (e, RETURN_MASK_ERROR)
1206 {
1207 }
1208 END_CATCH
1209
1210 /* FIXME: ARGS must be a list. If one argument is a string it
1211 will have " that will not be properly escaped. */
1212 }
1213 QUIT;
1214 }
1215 uiout->text (")");
1216 if (sal.symtab)
1217 {
1218 const char *filename_display;
1219
1220 filename_display = symtab_to_filename_for_display (sal.symtab);
1221 annotate_frame_source_begin ();
1222 uiout->wrap_hint (" ");
1223 uiout->text (" at ");
1224 annotate_frame_source_file ();
1225 uiout->field_string ("file", filename_display);
1226 if (uiout->is_mi_like_p ())
1227 {
1228 const char *fullname = symtab_to_fullname (sal.symtab);
1229
1230 uiout->field_string ("fullname", fullname);
1231 }
1232 annotate_frame_source_file_end ();
1233 uiout->text (":");
1234 annotate_frame_source_line ();
1235 uiout->field_int ("line", sal.line);
1236 annotate_frame_source_end ();
1237 }
1238
1239 if (pc_p && (funname == NULL || sal.symtab == NULL))
1240 {
1241 char *lib = solib_name_from_address (get_frame_program_space (frame),
1242 get_frame_pc (frame));
1243
1244 if (lib)
1245 {
1246 annotate_frame_where ();
1247 uiout->wrap_hint (" ");
1248 uiout->text (" from ");
1249 uiout->field_string ("from", lib);
1250 }
1251 }
1252 }
1253
1254 uiout->text ("\n");
1255 }
1256
1257
1258 /* Read a frame specification in whatever the appropriate format is from
1259 FRAME_EXP. Call error() if the specification is in any way invalid (so
1260 this function never returns NULL). When SELECTED_FRAME_P is non-NULL
1261 set its target to indicate that the default selected frame was used. */
1262
1263 static struct frame_info *
1264 parse_frame_specification (const char *frame_exp, int *selected_frame_p)
1265 {
1266 int numargs;
1267 struct value *args[4];
1268 CORE_ADDR addrs[ARRAY_SIZE (args)];
1269
1270 if (frame_exp == NULL)
1271 numargs = 0;
1272 else
1273 {
1274 numargs = 0;
1275 while (1)
1276 {
1277 const char *p;
1278
1279 /* Skip leading white space, bail of EOL. */
1280 frame_exp = skip_spaces (frame_exp);
1281 if (!*frame_exp)
1282 break;
1283
1284 /* Parse the argument, extract it, save it. */
1285 for (p = frame_exp;
1286 *p && !ISSPACE (*p);
1287 p++);
1288 std::string addr_string (frame_exp, p - frame_exp);
1289 frame_exp = p;
1290
1291 /* NOTE: Parse and evaluate expression, but do not use
1292 functions such as parse_and_eval_long or
1293 parse_and_eval_address to also extract the value.
1294 Instead value_as_long and value_as_address are used.
1295 This avoids problems with expressions that contain
1296 side-effects. */
1297 if (numargs >= ARRAY_SIZE (args))
1298 error (_("Too many args in frame specification"));
1299 args[numargs++] = parse_and_eval (addr_string.c_str ());
1300 }
1301 }
1302
1303 /* If no args, default to the selected frame. */
1304 if (numargs == 0)
1305 {
1306 if (selected_frame_p != NULL)
1307 (*selected_frame_p) = 1;
1308 return get_selected_frame (_("No stack."));
1309 }
1310
1311 /* None of the remaining use the selected frame. */
1312 if (selected_frame_p != NULL)
1313 (*selected_frame_p) = 0;
1314
1315 /* Assume the single arg[0] is an integer, and try using that to
1316 select a frame relative to current. */
1317 if (numargs == 1)
1318 {
1319 struct frame_info *fid;
1320 int level = value_as_long (args[0]);
1321
1322 fid = find_relative_frame (get_current_frame (), &level);
1323 if (level == 0)
1324 /* find_relative_frame was successful. */
1325 return fid;
1326 }
1327
1328 /* Convert each value into a corresponding address. */
1329 {
1330 int i;
1331
1332 for (i = 0; i < numargs; i++)
1333 addrs[i] = value_as_address (args[i]);
1334 }
1335
1336 /* Assume that the single arg[0] is an address, use that to identify
1337 a frame with a matching ID. Should this also accept stack/pc or
1338 stack/pc/special. */
1339 if (numargs == 1)
1340 {
1341 struct frame_id id = frame_id_build_wild (addrs[0]);
1342 struct frame_info *fid;
1343
1344 /* If (s)he specifies the frame with an address, he deserves
1345 what (s)he gets. Still, give the highest one that matches.
1346 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
1347 know). */
1348 for (fid = get_current_frame ();
1349 fid != NULL;
1350 fid = get_prev_frame (fid))
1351 {
1352 if (frame_id_eq (id, get_frame_id (fid)))
1353 {
1354 struct frame_info *prev_frame;
1355
1356 while (1)
1357 {
1358 prev_frame = get_prev_frame (fid);
1359 if (!prev_frame
1360 || !frame_id_eq (id, get_frame_id (prev_frame)))
1361 break;
1362 fid = prev_frame;
1363 }
1364 return fid;
1365 }
1366 }
1367 }
1368
1369 /* We couldn't identify the frame as an existing frame, but
1370 perhaps we can create one with a single argument. */
1371 if (numargs == 1)
1372 return create_new_frame (addrs[0], 0);
1373 else if (numargs == 2)
1374 return create_new_frame (addrs[0], addrs[1]);
1375 else
1376 error (_("Too many args in frame specification"));
1377 }
1378
1379 /* Print verbosely the selected frame or the frame at address
1380 ADDR_EXP. Absolutely all information in the frame is printed. */
1381
1382 static void
1383 info_frame_command (const char *addr_exp, int from_tty)
1384 {
1385 struct frame_info *fi;
1386 struct symbol *func;
1387 struct symtab *s;
1388 struct frame_info *calling_frame_info;
1389 int numregs;
1390 const char *funname = 0;
1391 enum language funlang = language_unknown;
1392 const char *pc_regname;
1393 int selected_frame_p;
1394 struct gdbarch *gdbarch;
1395 CORE_ADDR frame_pc;
1396 int frame_pc_p;
1397 /* Initialize it to avoid "may be used uninitialized" warning. */
1398 CORE_ADDR caller_pc = 0;
1399 int caller_pc_p = 0;
1400
1401 fi = parse_frame_specification (addr_exp, &selected_frame_p);
1402 gdbarch = get_frame_arch (fi);
1403
1404 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1405 is not a good name. */
1406 if (gdbarch_pc_regnum (gdbarch) >= 0)
1407 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1408 easily not match that of the internal value returned by
1409 get_frame_pc(). */
1410 pc_regname = gdbarch_register_name (gdbarch, gdbarch_pc_regnum (gdbarch));
1411 else
1412 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1413 architectures will often have a hardware register called "pc",
1414 and that register's value, again, can easily not match
1415 get_frame_pc(). */
1416 pc_regname = "pc";
1417
1418 frame_pc_p = get_frame_pc_if_available (fi, &frame_pc);
1419 func = get_frame_function (fi);
1420 symtab_and_line sal = find_frame_sal (fi);
1421 s = sal.symtab;
1422 gdb::unique_xmalloc_ptr<char> func_only;
1423 if (func)
1424 {
1425 funname = SYMBOL_PRINT_NAME (func);
1426 funlang = SYMBOL_LANGUAGE (func);
1427 if (funlang == language_cplus)
1428 {
1429 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1430 to display the demangled name that we already have
1431 stored in the symbol table, but we stored a version
1432 with DMGL_PARAMS turned on, and here we don't want to
1433 display parameters. So remove the parameters. */
1434 func_only = cp_remove_params (funname);
1435
1436 if (func_only)
1437 funname = func_only.get ();
1438 }
1439 }
1440 else if (frame_pc_p)
1441 {
1442 struct bound_minimal_symbol msymbol;
1443
1444 msymbol = lookup_minimal_symbol_by_pc (frame_pc);
1445 if (msymbol.minsym != NULL)
1446 {
1447 funname = MSYMBOL_PRINT_NAME (msymbol.minsym);
1448 funlang = MSYMBOL_LANGUAGE (msymbol.minsym);
1449 }
1450 }
1451 calling_frame_info = get_prev_frame (fi);
1452
1453 if (selected_frame_p && frame_relative_level (fi) >= 0)
1454 {
1455 printf_filtered (_("Stack level %d, frame at "),
1456 frame_relative_level (fi));
1457 }
1458 else
1459 {
1460 printf_filtered (_("Stack frame at "));
1461 }
1462 fputs_filtered (paddress (gdbarch, get_frame_base (fi)), gdb_stdout);
1463 printf_filtered (":\n");
1464 printf_filtered (" %s = ", pc_regname);
1465 if (frame_pc_p)
1466 fputs_filtered (paddress (gdbarch, get_frame_pc (fi)), gdb_stdout);
1467 else
1468 fputs_filtered ("<unavailable>", gdb_stdout);
1469
1470 wrap_here (" ");
1471 if (funname)
1472 {
1473 printf_filtered (" in ");
1474 fprintf_symbol_filtered (gdb_stdout, funname, funlang,
1475 DMGL_ANSI | DMGL_PARAMS);
1476 }
1477 wrap_here (" ");
1478 if (sal.symtab)
1479 printf_filtered (" (%s:%d)", symtab_to_filename_for_display (sal.symtab),
1480 sal.line);
1481 puts_filtered ("; ");
1482 wrap_here (" ");
1483 printf_filtered ("saved %s = ", pc_regname);
1484
1485 if (!frame_id_p (frame_unwind_caller_id (fi)))
1486 val_print_not_saved (gdb_stdout);
1487 else
1488 {
1489 TRY
1490 {
1491 caller_pc = frame_unwind_caller_pc (fi);
1492 caller_pc_p = 1;
1493 }
1494 CATCH (ex, RETURN_MASK_ERROR)
1495 {
1496 switch (ex.error)
1497 {
1498 case NOT_AVAILABLE_ERROR:
1499 val_print_unavailable (gdb_stdout);
1500 break;
1501 case OPTIMIZED_OUT_ERROR:
1502 val_print_not_saved (gdb_stdout);
1503 break;
1504 default:
1505 fprintf_filtered (gdb_stdout, _("<error: %s>"), ex.message);
1506 break;
1507 }
1508 }
1509 END_CATCH
1510 }
1511
1512 if (caller_pc_p)
1513 fputs_filtered (paddress (gdbarch, caller_pc), gdb_stdout);
1514 printf_filtered ("\n");
1515
1516 if (calling_frame_info == NULL)
1517 {
1518 enum unwind_stop_reason reason;
1519
1520 reason = get_frame_unwind_stop_reason (fi);
1521 if (reason != UNWIND_NO_REASON)
1522 printf_filtered (_(" Outermost frame: %s\n"),
1523 frame_stop_reason_string (fi));
1524 }
1525 else if (get_frame_type (fi) == TAILCALL_FRAME)
1526 puts_filtered (" tail call frame");
1527 else if (get_frame_type (fi) == INLINE_FRAME)
1528 printf_filtered (" inlined into frame %d",
1529 frame_relative_level (get_prev_frame (fi)));
1530 else
1531 {
1532 printf_filtered (" called by frame at ");
1533 fputs_filtered (paddress (gdbarch, get_frame_base (calling_frame_info)),
1534 gdb_stdout);
1535 }
1536 if (get_next_frame (fi) && calling_frame_info)
1537 puts_filtered (",");
1538 wrap_here (" ");
1539 if (get_next_frame (fi))
1540 {
1541 printf_filtered (" caller of frame at ");
1542 fputs_filtered (paddress (gdbarch, get_frame_base (get_next_frame (fi))),
1543 gdb_stdout);
1544 }
1545 if (get_next_frame (fi) || calling_frame_info)
1546 puts_filtered ("\n");
1547
1548 if (s)
1549 printf_filtered (" source language %s.\n",
1550 language_str (s->language));
1551
1552 {
1553 /* Address of the argument list for this frame, or 0. */
1554 CORE_ADDR arg_list = get_frame_args_address (fi);
1555 /* Number of args for this frame, or -1 if unknown. */
1556 int numargs;
1557
1558 if (arg_list == 0)
1559 printf_filtered (" Arglist at unknown address.\n");
1560 else
1561 {
1562 printf_filtered (" Arglist at ");
1563 fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout);
1564 printf_filtered (",");
1565
1566 if (!gdbarch_frame_num_args_p (gdbarch))
1567 {
1568 numargs = -1;
1569 puts_filtered (" args: ");
1570 }
1571 else
1572 {
1573 numargs = gdbarch_frame_num_args (gdbarch, fi);
1574 gdb_assert (numargs >= 0);
1575 if (numargs == 0)
1576 puts_filtered (" no args.");
1577 else if (numargs == 1)
1578 puts_filtered (" 1 arg: ");
1579 else
1580 printf_filtered (" %d args: ", numargs);
1581 }
1582 print_frame_args (func, fi, numargs, gdb_stdout);
1583 puts_filtered ("\n");
1584 }
1585 }
1586 {
1587 /* Address of the local variables for this frame, or 0. */
1588 CORE_ADDR arg_list = get_frame_locals_address (fi);
1589
1590 if (arg_list == 0)
1591 printf_filtered (" Locals at unknown address,");
1592 else
1593 {
1594 printf_filtered (" Locals at ");
1595 fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout);
1596 printf_filtered (",");
1597 }
1598 }
1599
1600 /* Print as much information as possible on the location of all the
1601 registers. */
1602 {
1603 int count;
1604 int i;
1605 int need_nl = 1;
1606 int sp_regnum = gdbarch_sp_regnum (gdbarch);
1607
1608 /* The sp is special; what's displayed isn't the save address, but
1609 the value of the previous frame's sp. This is a legacy thing,
1610 at one stage the frame cached the previous frame's SP instead
1611 of its address, hence it was easiest to just display the cached
1612 value. */
1613 if (sp_regnum >= 0)
1614 {
1615 struct value *value = frame_unwind_register_value (fi, sp_regnum);
1616 gdb_assert (value != NULL);
1617
1618 if (!value_optimized_out (value) && value_entirely_available (value))
1619 {
1620 if (VALUE_LVAL (value) == not_lval)
1621 {
1622 CORE_ADDR sp;
1623 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1624 int sp_size = register_size (gdbarch, sp_regnum);
1625
1626 sp = extract_unsigned_integer (value_contents_all (value),
1627 sp_size, byte_order);
1628
1629 printf_filtered (" Previous frame's sp is ");
1630 fputs_filtered (paddress (gdbarch, sp), gdb_stdout);
1631 printf_filtered ("\n");
1632 }
1633 else if (VALUE_LVAL (value) == lval_memory)
1634 {
1635 printf_filtered (" Previous frame's sp at ");
1636 fputs_filtered (paddress (gdbarch, value_address (value)),
1637 gdb_stdout);
1638 printf_filtered ("\n");
1639 }
1640 else if (VALUE_LVAL (value) == lval_register)
1641 {
1642 printf_filtered (" Previous frame's sp in %s\n",
1643 gdbarch_register_name (gdbarch,
1644 VALUE_REGNUM (value)));
1645 }
1646
1647 release_value (value);
1648 value_free (value);
1649 need_nl = 0;
1650 }
1651 /* else keep quiet. */
1652 }
1653
1654 count = 0;
1655 numregs = gdbarch_num_regs (gdbarch)
1656 + gdbarch_num_pseudo_regs (gdbarch);
1657 for (i = 0; i < numregs; i++)
1658 if (i != sp_regnum
1659 && gdbarch_register_reggroup_p (gdbarch, i, all_reggroup))
1660 {
1661 enum lval_type lval;
1662 int optimized;
1663 int unavailable;
1664 CORE_ADDR addr;
1665 int realnum;
1666
1667 /* Find out the location of the saved register without
1668 fetching the corresponding value. */
1669 frame_register_unwind (fi, i, &optimized, &unavailable,
1670 &lval, &addr, &realnum, NULL);
1671 /* For moment, only display registers that were saved on the
1672 stack. */
1673 if (!optimized && !unavailable && lval == lval_memory)
1674 {
1675 if (count == 0)
1676 puts_filtered (" Saved registers:\n ");
1677 else
1678 puts_filtered (",");
1679 wrap_here (" ");
1680 printf_filtered (" %s at ",
1681 gdbarch_register_name (gdbarch, i));
1682 fputs_filtered (paddress (gdbarch, addr), gdb_stdout);
1683 count++;
1684 }
1685 }
1686 if (count || need_nl)
1687 puts_filtered ("\n");
1688 }
1689 }
1690
1691 /* Print briefly all stack frames or just the innermost COUNT_EXP
1692 frames. */
1693
1694 static void
1695 backtrace_command_1 (const char *count_exp, int show_locals, int no_filters,
1696 int from_tty)
1697 {
1698 struct frame_info *fi;
1699 int count;
1700 int i;
1701 struct frame_info *trailing;
1702 int trailing_level, py_start = 0, py_end = 0;
1703 enum ext_lang_bt_status result = EXT_LANG_BT_ERROR;
1704
1705 if (!target_has_stack)
1706 error (_("No stack."));
1707
1708 /* The following code must do two things. First, it must set the
1709 variable TRAILING to the frame from which we should start
1710 printing. Second, it must set the variable count to the number
1711 of frames which we should print, or -1 if all of them. */
1712 trailing = get_current_frame ();
1713
1714 trailing_level = 0;
1715 if (count_exp)
1716 {
1717 count = parse_and_eval_long (count_exp);
1718 if (count < 0)
1719 {
1720 struct frame_info *current;
1721
1722 py_start = count;
1723 count = -count;
1724
1725 current = trailing;
1726 while (current && count--)
1727 {
1728 QUIT;
1729 current = get_prev_frame (current);
1730 }
1731
1732 /* Will stop when CURRENT reaches the top of the stack.
1733 TRAILING will be COUNT below it. */
1734 while (current)
1735 {
1736 QUIT;
1737 trailing = get_prev_frame (trailing);
1738 current = get_prev_frame (current);
1739 trailing_level++;
1740 }
1741
1742 count = -1;
1743 }
1744 else
1745 {
1746 py_start = 0;
1747 py_end = count;
1748 }
1749 }
1750 else
1751 {
1752 py_end = -1;
1753 count = -1;
1754 }
1755
1756 if (info_verbose)
1757 {
1758 /* Read in symbols for all of the frames. Need to do this in a
1759 separate pass so that "Reading in symbols for xxx" messages
1760 don't screw up the appearance of the backtrace. Also if
1761 people have strong opinions against reading symbols for
1762 backtrace this may have to be an option. */
1763 i = count;
1764 for (fi = trailing; fi != NULL && i--; fi = get_prev_frame (fi))
1765 {
1766 CORE_ADDR pc;
1767
1768 QUIT;
1769 pc = get_frame_address_in_block (fi);
1770 expand_symtab_containing_pc (pc, find_pc_mapped_section (pc));
1771 }
1772 }
1773
1774 if (! no_filters)
1775 {
1776 int flags = PRINT_LEVEL | PRINT_FRAME_INFO | PRINT_ARGS;
1777 enum ext_lang_frame_args arg_type;
1778
1779 if (show_locals)
1780 flags |= PRINT_LOCALS;
1781
1782 if (!strcmp (print_frame_arguments, "scalars"))
1783 arg_type = CLI_SCALAR_VALUES;
1784 else if (!strcmp (print_frame_arguments, "all"))
1785 arg_type = CLI_ALL_VALUES;
1786 else
1787 arg_type = NO_VALUES;
1788
1789 result = apply_ext_lang_frame_filter (get_current_frame (), flags,
1790 arg_type, current_uiout,
1791 py_start, py_end);
1792 }
1793
1794 /* Run the inbuilt backtrace if there are no filters registered, or
1795 "no-filters" has been specified from the command. */
1796 if (no_filters || result == EXT_LANG_BT_NO_FILTERS)
1797 {
1798 for (i = 0, fi = trailing; fi && count--; i++, fi = get_prev_frame (fi))
1799 {
1800 QUIT;
1801
1802 /* Don't use print_stack_frame; if an error() occurs it probably
1803 means further attempts to backtrace would fail (on the other
1804 hand, perhaps the code does or could be fixed to make sure
1805 the frame->prev field gets set to NULL in that case). */
1806
1807 print_frame_info (fi, 1, LOCATION, 1, 0);
1808 if (show_locals)
1809 {
1810 struct frame_id frame_id = get_frame_id (fi);
1811
1812 print_frame_local_vars (fi, 1, gdb_stdout);
1813
1814 /* print_frame_local_vars invalidates FI. */
1815 fi = frame_find_by_id (frame_id);
1816 if (fi == NULL)
1817 {
1818 trailing = NULL;
1819 warning (_("Unable to restore previously selected frame."));
1820 break;
1821 }
1822 }
1823
1824 /* Save the last frame to check for error conditions. */
1825 trailing = fi;
1826 }
1827
1828 /* If we've stopped before the end, mention that. */
1829 if (fi && from_tty)
1830 printf_filtered (_("(More stack frames follow...)\n"));
1831
1832 /* If we've run out of frames, and the reason appears to be an error
1833 condition, print it. */
1834 if (fi == NULL && trailing != NULL)
1835 {
1836 enum unwind_stop_reason reason;
1837
1838 reason = get_frame_unwind_stop_reason (trailing);
1839 if (reason >= UNWIND_FIRST_ERROR)
1840 printf_filtered (_("Backtrace stopped: %s\n"),
1841 frame_stop_reason_string (trailing));
1842 }
1843 }
1844 }
1845
1846 static void
1847 backtrace_command (const char *arg, int from_tty)
1848 {
1849 int fulltrace_arg = -1, arglen = 0, argc = 0, no_filters = -1;
1850 int user_arg = 0;
1851
1852 std::string reconstructed_arg;
1853 if (arg)
1854 {
1855 char **argv;
1856 int i;
1857
1858 gdb_argv built_argv (arg);
1859 argv = built_argv.get ();
1860 argc = 0;
1861 for (i = 0; argv[i]; i++)
1862 {
1863 unsigned int j;
1864
1865 for (j = 0; j < strlen (argv[i]); j++)
1866 argv[i][j] = TOLOWER (argv[i][j]);
1867
1868 if (no_filters < 0 && subset_compare (argv[i], "no-filters"))
1869 no_filters = argc;
1870 else
1871 {
1872 if (fulltrace_arg < 0 && subset_compare (argv[i], "full"))
1873 fulltrace_arg = argc;
1874 else
1875 {
1876 user_arg++;
1877 arglen += strlen (argv[i]);
1878 }
1879 }
1880 argc++;
1881 }
1882 arglen += user_arg;
1883 if (fulltrace_arg >= 0 || no_filters >= 0)
1884 {
1885 if (arglen > 0)
1886 {
1887 for (i = 0; i < argc; i++)
1888 {
1889 if (i != fulltrace_arg && i != no_filters)
1890 {
1891 reconstructed_arg += argv[i];
1892 reconstructed_arg += " ";
1893 }
1894 }
1895 arg = reconstructed_arg.c_str ();
1896 }
1897 else
1898 arg = NULL;
1899 }
1900 }
1901
1902 backtrace_command_1 (arg, fulltrace_arg >= 0 /* show_locals */,
1903 no_filters >= 0 /* no frame-filters */, from_tty);
1904 }
1905
1906 /* Iterate over the local variables of a block B, calling CB with
1907 CB_DATA. */
1908
1909 static void
1910 iterate_over_block_locals (const struct block *b,
1911 iterate_over_block_arg_local_vars_cb cb,
1912 void *cb_data)
1913 {
1914 struct block_iterator iter;
1915 struct symbol *sym;
1916
1917 ALL_BLOCK_SYMBOLS (b, iter, sym)
1918 {
1919 switch (SYMBOL_CLASS (sym))
1920 {
1921 case LOC_LOCAL:
1922 case LOC_REGISTER:
1923 case LOC_STATIC:
1924 case LOC_COMPUTED:
1925 case LOC_OPTIMIZED_OUT:
1926 if (SYMBOL_IS_ARGUMENT (sym))
1927 break;
1928 if (SYMBOL_DOMAIN (sym) == COMMON_BLOCK_DOMAIN)
1929 break;
1930 (*cb) (SYMBOL_PRINT_NAME (sym), sym, cb_data);
1931 break;
1932
1933 default:
1934 /* Ignore symbols which are not locals. */
1935 break;
1936 }
1937 }
1938 }
1939
1940
1941 /* Same, but print labels. */
1942
1943 #if 0
1944 /* Commented out, as the code using this function has also been
1945 commented out. FIXME:brobecker/2009-01-13: Find out why the code
1946 was commented out in the first place. The discussion introducing
1947 this change (2007-12-04: Support lexical blocks and function bodies
1948 that occupy non-contiguous address ranges) did not explain why
1949 this change was made. */
1950 static int
1951 print_block_frame_labels (struct gdbarch *gdbarch, struct block *b,
1952 int *have_default, struct ui_file *stream)
1953 {
1954 struct block_iterator iter;
1955 struct symbol *sym;
1956 int values_printed = 0;
1957
1958 ALL_BLOCK_SYMBOLS (b, iter, sym)
1959 {
1960 if (strcmp (SYMBOL_LINKAGE_NAME (sym), "default") == 0)
1961 {
1962 if (*have_default)
1963 continue;
1964 *have_default = 1;
1965 }
1966 if (SYMBOL_CLASS (sym) == LOC_LABEL)
1967 {
1968 struct symtab_and_line sal;
1969 struct value_print_options opts;
1970
1971 sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0);
1972 values_printed = 1;
1973 fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
1974 get_user_print_options (&opts);
1975 if (opts.addressprint)
1976 {
1977 fprintf_filtered (stream, " ");
1978 fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (sym)),
1979 stream);
1980 }
1981 fprintf_filtered (stream, " in file %s, line %d\n",
1982 sal.symtab->filename, sal.line);
1983 }
1984 }
1985
1986 return values_printed;
1987 }
1988 #endif
1989
1990 /* Iterate over all the local variables in block B, including all its
1991 superblocks, stopping when the top-level block is reached. */
1992
1993 void
1994 iterate_over_block_local_vars (const struct block *block,
1995 iterate_over_block_arg_local_vars_cb cb,
1996 void *cb_data)
1997 {
1998 while (block)
1999 {
2000 iterate_over_block_locals (block, cb, cb_data);
2001 /* After handling the function's top-level block, stop. Don't
2002 continue to its superblock, the block of per-file
2003 symbols. */
2004 if (BLOCK_FUNCTION (block))
2005 break;
2006 block = BLOCK_SUPERBLOCK (block);
2007 }
2008 }
2009
2010 /* Data to be passed around in the calls to the locals and args
2011 iterators. */
2012
2013 struct print_variable_and_value_data
2014 {
2015 struct frame_id frame_id;
2016 int num_tabs;
2017 struct ui_file *stream;
2018 int values_printed;
2019 };
2020
2021 /* The callback for the locals and args iterators. */
2022
2023 static void
2024 do_print_variable_and_value (const char *print_name,
2025 struct symbol *sym,
2026 void *cb_data)
2027 {
2028 struct print_variable_and_value_data *p
2029 = (struct print_variable_and_value_data *) cb_data;
2030 struct frame_info *frame;
2031
2032 frame = frame_find_by_id (p->frame_id);
2033 if (frame == NULL)
2034 {
2035 warning (_("Unable to restore previously selected frame."));
2036 return;
2037 }
2038
2039 print_variable_and_value (print_name, sym, frame, p->stream, p->num_tabs);
2040
2041 /* print_variable_and_value invalidates FRAME. */
2042 frame = NULL;
2043
2044 p->values_printed = 1;
2045 }
2046
2047 /* Print all variables from the innermost up to the function block of FRAME.
2048 Print them with values to STREAM indented by NUM_TABS.
2049
2050 This function will invalidate FRAME. */
2051
2052 static void
2053 print_frame_local_vars (struct frame_info *frame, int num_tabs,
2054 struct ui_file *stream)
2055 {
2056 struct print_variable_and_value_data cb_data;
2057 const struct block *block;
2058 CORE_ADDR pc;
2059 struct gdb_exception except = exception_none;
2060
2061 if (!get_frame_pc_if_available (frame, &pc))
2062 {
2063 fprintf_filtered (stream,
2064 _("PC unavailable, cannot determine locals.\n"));
2065 return;
2066 }
2067
2068 block = get_frame_block (frame, 0);
2069 if (block == 0)
2070 {
2071 fprintf_filtered (stream, "No symbol table info available.\n");
2072 return;
2073 }
2074
2075 cb_data.frame_id = get_frame_id (frame);
2076 cb_data.num_tabs = 4 * num_tabs;
2077 cb_data.stream = stream;
2078 cb_data.values_printed = 0;
2079
2080 /* Temporarily change the selected frame to the given FRAME.
2081 This allows routines that rely on the selected frame instead
2082 of being given a frame as parameter to use the correct frame. */
2083 select_frame (frame);
2084
2085 TRY
2086 {
2087 iterate_over_block_local_vars (block,
2088 do_print_variable_and_value,
2089 &cb_data);
2090 }
2091 CATCH (ex, RETURN_MASK_ALL)
2092 {
2093 except = ex;
2094 }
2095 END_CATCH
2096
2097 /* Restore the selected frame, and then rethrow if there was a problem. */
2098 select_frame (frame_find_by_id (cb_data.frame_id));
2099 if (except.reason < 0)
2100 throw_exception (except);
2101
2102 /* do_print_variable_and_value invalidates FRAME. */
2103 frame = NULL;
2104
2105 if (!cb_data.values_printed)
2106 fprintf_filtered (stream, _("No locals.\n"));
2107 }
2108
2109 void
2110 info_locals_command (const char *args, int from_tty)
2111 {
2112 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
2113 0, gdb_stdout);
2114 }
2115
2116 /* Iterate over all the argument variables in block B.
2117
2118 Returns 1 if any argument was walked; 0 otherwise. */
2119
2120 void
2121 iterate_over_block_arg_vars (const struct block *b,
2122 iterate_over_block_arg_local_vars_cb cb,
2123 void *cb_data)
2124 {
2125 struct block_iterator iter;
2126 struct symbol *sym, *sym2;
2127
2128 ALL_BLOCK_SYMBOLS (b, iter, sym)
2129 {
2130 /* Don't worry about things which aren't arguments. */
2131 if (SYMBOL_IS_ARGUMENT (sym))
2132 {
2133 /* We have to look up the symbol because arguments can have
2134 two entries (one a parameter, one a local) and the one we
2135 want is the local, which lookup_symbol will find for us.
2136 This includes gcc1 (not gcc2) on the sparc when passing a
2137 small structure and gcc2 when the argument type is float
2138 and it is passed as a double and converted to float by
2139 the prologue (in the latter case the type of the LOC_ARG
2140 symbol is double and the type of the LOC_LOCAL symbol is
2141 float). There are also LOC_ARG/LOC_REGISTER pairs which
2142 are not combined in symbol-reading. */
2143
2144 sym2 = lookup_symbol_search_name (SYMBOL_SEARCH_NAME (sym),
2145 b, VAR_DOMAIN).symbol;
2146 (*cb) (SYMBOL_PRINT_NAME (sym), sym2, cb_data);
2147 }
2148 }
2149 }
2150
2151 /* Print all argument variables of the function of FRAME.
2152 Print them with values to STREAM.
2153
2154 This function will invalidate FRAME. */
2155
2156 static void
2157 print_frame_arg_vars (struct frame_info *frame, struct ui_file *stream)
2158 {
2159 struct print_variable_and_value_data cb_data;
2160 struct symbol *func;
2161 CORE_ADDR pc;
2162
2163 if (!get_frame_pc_if_available (frame, &pc))
2164 {
2165 fprintf_filtered (stream, _("PC unavailable, cannot determine args.\n"));
2166 return;
2167 }
2168
2169 func = get_frame_function (frame);
2170 if (func == NULL)
2171 {
2172 fprintf_filtered (stream, _("No symbol table info available.\n"));
2173 return;
2174 }
2175
2176 cb_data.frame_id = get_frame_id (frame);
2177 cb_data.num_tabs = 0;
2178 cb_data.stream = gdb_stdout;
2179 cb_data.values_printed = 0;
2180
2181 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func),
2182 do_print_variable_and_value, &cb_data);
2183
2184 /* do_print_variable_and_value invalidates FRAME. */
2185 frame = NULL;
2186
2187 if (!cb_data.values_printed)
2188 fprintf_filtered (stream, _("No arguments.\n"));
2189 }
2190
2191 void
2192 info_args_command (const char *ignore, int from_tty)
2193 {
2194 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2195 gdb_stdout);
2196 }
2197
2198 /* Select frame FRAME. Also print the stack frame and show the source
2199 if this is the tui version. */
2200 static void
2201 select_and_print_frame (struct frame_info *frame)
2202 {
2203 select_frame (frame);
2204 if (frame)
2205 print_stack_frame (frame, 1, SRC_AND_LOC, 1);
2206 }
2207
2208 /* Return the symbol-block in which the selected frame is executing.
2209 Can return zero under various legitimate circumstances.
2210
2211 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2212 code address within the block returned. We use this to decide
2213 which macros are in scope. */
2214
2215 const struct block *
2216 get_selected_block (CORE_ADDR *addr_in_block)
2217 {
2218 if (!has_stack_frames ())
2219 return 0;
2220
2221 return get_frame_block (get_selected_frame (NULL), addr_in_block);
2222 }
2223
2224 /* Find a frame a certain number of levels away from FRAME.
2225 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2226 Positive means go to earlier frames (up); negative, the reverse.
2227 The int that contains the number of levels is counted toward
2228 zero as the frames for those levels are found.
2229 If the top or bottom frame is reached, that frame is returned,
2230 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2231 how much farther the original request asked to go. */
2232
2233 struct frame_info *
2234 find_relative_frame (struct frame_info *frame, int *level_offset_ptr)
2235 {
2236 /* Going up is simple: just call get_prev_frame enough times or
2237 until the initial frame is reached. */
2238 while (*level_offset_ptr > 0)
2239 {
2240 struct frame_info *prev = get_prev_frame (frame);
2241
2242 if (!prev)
2243 break;
2244 (*level_offset_ptr)--;
2245 frame = prev;
2246 }
2247
2248 /* Going down is just as simple. */
2249 while (*level_offset_ptr < 0)
2250 {
2251 struct frame_info *next = get_next_frame (frame);
2252
2253 if (!next)
2254 break;
2255 (*level_offset_ptr)++;
2256 frame = next;
2257 }
2258
2259 return frame;
2260 }
2261
2262 /* The "select_frame" command. With no argument this is a NOP.
2263 Select the frame at level LEVEL_EXP if it is a valid level.
2264 Otherwise, treat LEVEL_EXP as an address expression and select it.
2265
2266 See parse_frame_specification for more info on proper frame
2267 expressions. */
2268
2269 void
2270 select_frame_command (const char *level_exp, int from_tty)
2271 {
2272 struct frame_info *prev_frame = get_selected_frame_if_set ();
2273
2274 select_frame (parse_frame_specification (level_exp, NULL));
2275 if (get_selected_frame_if_set () != prev_frame)
2276 observer_notify_user_selected_context_changed (USER_SELECTED_FRAME);
2277 }
2278
2279 /* The "frame" command. With no argument, print the selected frame
2280 briefly. With an argument, behave like select_frame and then print
2281 the selected frame. */
2282
2283 static void
2284 frame_command (const char *level_exp, int from_tty)
2285 {
2286 struct frame_info *prev_frame = get_selected_frame_if_set ();
2287
2288 select_frame (parse_frame_specification (level_exp, NULL));
2289 if (get_selected_frame_if_set () != prev_frame)
2290 observer_notify_user_selected_context_changed (USER_SELECTED_FRAME);
2291 else
2292 print_selected_thread_frame (current_uiout, USER_SELECTED_FRAME);
2293 }
2294
2295 /* Select the frame up one or COUNT_EXP stack levels from the
2296 previously selected frame, and print it briefly. */
2297
2298 static void
2299 up_silently_base (const char *count_exp)
2300 {
2301 struct frame_info *frame;
2302 int count = 1;
2303
2304 if (count_exp)
2305 count = parse_and_eval_long (count_exp);
2306
2307 frame = find_relative_frame (get_selected_frame ("No stack."), &count);
2308 if (count != 0 && count_exp == NULL)
2309 error (_("Initial frame selected; you cannot go up."));
2310 select_frame (frame);
2311 }
2312
2313 static void
2314 up_silently_command (const char *count_exp, int from_tty)
2315 {
2316 up_silently_base (count_exp);
2317 }
2318
2319 static void
2320 up_command (const char *count_exp, int from_tty)
2321 {
2322 up_silently_base (count_exp);
2323 observer_notify_user_selected_context_changed (USER_SELECTED_FRAME);
2324 }
2325
2326 /* Select the frame down one or COUNT_EXP stack levels from the previously
2327 selected frame, and print it briefly. */
2328
2329 static void
2330 down_silently_base (const char *count_exp)
2331 {
2332 struct frame_info *frame;
2333 int count = -1;
2334
2335 if (count_exp)
2336 count = -parse_and_eval_long (count_exp);
2337
2338 frame = find_relative_frame (get_selected_frame ("No stack."), &count);
2339 if (count != 0 && count_exp == NULL)
2340 {
2341 /* We only do this if COUNT_EXP is not specified. That way
2342 "down" means to really go down (and let me know if that is
2343 impossible), but "down 9999" can be used to mean go all the
2344 way down without getting an error. */
2345
2346 error (_("Bottom (innermost) frame selected; you cannot go down."));
2347 }
2348
2349 select_frame (frame);
2350 }
2351
2352 static void
2353 down_silently_command (const char *count_exp, int from_tty)
2354 {
2355 down_silently_base (count_exp);
2356 }
2357
2358 static void
2359 down_command (const char *count_exp, int from_tty)
2360 {
2361 down_silently_base (count_exp);
2362 observer_notify_user_selected_context_changed (USER_SELECTED_FRAME);
2363 }
2364
2365 void
2366 return_command (const char *retval_exp, int from_tty)
2367 {
2368 /* Initialize it just to avoid a GCC false warning. */
2369 enum return_value_convention rv_conv = RETURN_VALUE_STRUCT_CONVENTION;
2370 struct frame_info *thisframe;
2371 struct gdbarch *gdbarch;
2372 struct symbol *thisfun;
2373 struct value *return_value = NULL;
2374 struct value *function = NULL;
2375 const char *query_prefix = "";
2376
2377 thisframe = get_selected_frame ("No selected frame.");
2378 thisfun = get_frame_function (thisframe);
2379 gdbarch = get_frame_arch (thisframe);
2380
2381 if (get_frame_type (get_current_frame ()) == INLINE_FRAME)
2382 error (_("Can not force return from an inlined function."));
2383
2384 /* Compute the return value. If the computation triggers an error,
2385 let it bail. If the return type can't be handled, set
2386 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2387 message. */
2388 if (retval_exp)
2389 {
2390 expression_up retval_expr = parse_expression (retval_exp);
2391 struct type *return_type = NULL;
2392
2393 /* Compute the return value. Should the computation fail, this
2394 call throws an error. */
2395 return_value = evaluate_expression (retval_expr.get ());
2396
2397 /* Cast return value to the return type of the function. Should
2398 the cast fail, this call throws an error. */
2399 if (thisfun != NULL)
2400 return_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun));
2401 if (return_type == NULL)
2402 {
2403 if (retval_expr->elts[0].opcode != UNOP_CAST
2404 && retval_expr->elts[0].opcode != UNOP_CAST_TYPE)
2405 error (_("Return value type not available for selected "
2406 "stack frame.\n"
2407 "Please use an explicit cast of the value to return."));
2408 return_type = value_type (return_value);
2409 }
2410 return_type = check_typedef (return_type);
2411 return_value = value_cast (return_type, return_value);
2412
2413 /* Make sure the value is fully evaluated. It may live in the
2414 stack frame we're about to pop. */
2415 if (value_lazy (return_value))
2416 value_fetch_lazy (return_value);
2417
2418 if (thisfun != NULL)
2419 function = read_var_value (thisfun, NULL, thisframe);
2420
2421 rv_conv = RETURN_VALUE_REGISTER_CONVENTION;
2422 if (TYPE_CODE (return_type) == TYPE_CODE_VOID)
2423 /* If the return-type is "void", don't try to find the
2424 return-value's location. However, do still evaluate the
2425 return expression so that, even when the expression result
2426 is discarded, side effects such as "return i++" still
2427 occur. */
2428 return_value = NULL;
2429 else if (thisfun != NULL)
2430 {
2431 rv_conv = struct_return_convention (gdbarch, function, return_type);
2432 if (rv_conv == RETURN_VALUE_STRUCT_CONVENTION
2433 || rv_conv == RETURN_VALUE_ABI_RETURNS_ADDRESS)
2434 {
2435 query_prefix = "The location at which to store the "
2436 "function's return value is unknown.\n"
2437 "If you continue, the return value "
2438 "that you specified will be ignored.\n";
2439 return_value = NULL;
2440 }
2441 }
2442 }
2443
2444 /* Does an interactive user really want to do this? Include
2445 information, such as how well GDB can handle the return value, in
2446 the query message. */
2447 if (from_tty)
2448 {
2449 int confirmed;
2450
2451 if (thisfun == NULL)
2452 confirmed = query (_("%sMake selected stack frame return now? "),
2453 query_prefix);
2454 else
2455 {
2456 if (TYPE_NO_RETURN (thisfun->type))
2457 warning (_("Function does not return normally to caller."));
2458 confirmed = query (_("%sMake %s return now? "), query_prefix,
2459 SYMBOL_PRINT_NAME (thisfun));
2460 }
2461 if (!confirmed)
2462 error (_("Not confirmed"));
2463 }
2464
2465 /* Discard the selected frame and all frames inner-to it. */
2466 frame_pop (get_selected_frame (NULL));
2467
2468 /* Store RETURN_VALUE in the just-returned register set. */
2469 if (return_value != NULL)
2470 {
2471 struct type *return_type = value_type (return_value);
2472 struct gdbarch *gdbarch = get_current_regcache ()->arch ();
2473
2474 gdb_assert (rv_conv != RETURN_VALUE_STRUCT_CONVENTION
2475 && rv_conv != RETURN_VALUE_ABI_RETURNS_ADDRESS);
2476 gdbarch_return_value (gdbarch, function, return_type,
2477 get_current_regcache (), NULL /*read*/,
2478 value_contents (return_value) /*write*/);
2479 }
2480
2481 /* If we are at the end of a call dummy now, pop the dummy frame
2482 too. */
2483 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME)
2484 frame_pop (get_current_frame ());
2485
2486 select_frame (get_current_frame ());
2487 /* If interactive, print the frame that is now current. */
2488 if (from_tty)
2489 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
2490 }
2491
2492 /* Sets the scope to input function name, provided that the function
2493 is within the current stack frame. */
2494
2495 struct function_bounds
2496 {
2497 CORE_ADDR low, high;
2498 };
2499
2500 static void
2501 func_command (const char *arg, int from_tty)
2502 {
2503 struct frame_info *frame;
2504 int found = 0;
2505 int level = 1;
2506
2507 if (arg == NULL)
2508 return;
2509
2510 frame = get_current_frame ();
2511 std::vector<symtab_and_line> sals
2512 = decode_line_with_current_source (arg, DECODE_LINE_FUNFIRSTLINE);
2513 gdb::def_vector<function_bounds> func_bounds (sals.size ());
2514 for (size_t i = 0; (i < sals.size () && !found); i++)
2515 {
2516 if (sals[i].pspace != current_program_space)
2517 func_bounds[i].low = func_bounds[i].high = 0;
2518 else if (sals[i].pc == 0
2519 || find_pc_partial_function (sals[i].pc, NULL,
2520 &func_bounds[i].low,
2521 &func_bounds[i].high) == 0)
2522 {
2523 func_bounds[i].low = func_bounds[i].high = 0;
2524 }
2525 }
2526
2527 do
2528 {
2529 for (size_t i = 0; (i < sals.size () && !found); i++)
2530 found = (get_frame_pc (frame) >= func_bounds[i].low
2531 && get_frame_pc (frame) < func_bounds[i].high);
2532 if (!found)
2533 {
2534 level = 1;
2535 frame = find_relative_frame (frame, &level);
2536 }
2537 }
2538 while (!found && level == 0);
2539
2540 if (!found)
2541 printf_filtered (_("'%s' not within current stack frame.\n"), arg);
2542 else if (frame != get_selected_frame (NULL))
2543 select_and_print_frame (frame);
2544 }
2545
2546 void
2547 _initialize_stack (void)
2548 {
2549 add_com ("return", class_stack, return_command, _("\
2550 Make selected stack frame return to its caller.\n\
2551 Control remains in the debugger, but when you continue\n\
2552 execution will resume in the frame above the one now selected.\n\
2553 If an argument is given, it is an expression for the value to return."));
2554
2555 add_com ("up", class_stack, up_command, _("\
2556 Select and print stack frame that called this one.\n\
2557 An argument says how many frames up to go."));
2558 add_com ("up-silently", class_support, up_silently_command, _("\
2559 Same as the `up' command, but does not print anything.\n\
2560 This is useful in command scripts."));
2561
2562 add_com ("down", class_stack, down_command, _("\
2563 Select and print stack frame called by this one.\n\
2564 An argument says how many frames down to go."));
2565 add_com_alias ("do", "down", class_stack, 1);
2566 add_com_alias ("dow", "down", class_stack, 1);
2567 add_com ("down-silently", class_support, down_silently_command, _("\
2568 Same as the `down' command, but does not print anything.\n\
2569 This is useful in command scripts."));
2570
2571 add_com ("frame", class_stack, frame_command, _("\
2572 Select and print a stack frame.\nWith no argument, \
2573 print the selected stack frame. (See also \"info frame\").\n\
2574 An argument specifies the frame to select.\n\
2575 It can be a stack frame number or the address of the frame.\n"));
2576
2577 add_com_alias ("f", "frame", class_stack, 1);
2578
2579 add_com_suppress_notification ("select-frame", class_stack, select_frame_command, _("\
2580 Select a stack frame without printing anything.\n\
2581 An argument specifies the frame to select.\n\
2582 It can be a stack frame number or the address of the frame.\n"),
2583 &cli_suppress_notification.user_selected_context);
2584
2585 add_com ("backtrace", class_stack, backtrace_command, _("\
2586 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2587 With a negative argument, print outermost -COUNT frames.\nUse of the \
2588 'full' qualifier also prints the values of the local variables.\n\
2589 Use of the 'no-filters' qualifier prohibits frame filters from executing\n\
2590 on this backtrace.\n"));
2591 add_com_alias ("bt", "backtrace", class_stack, 0);
2592
2593 add_com_alias ("where", "backtrace", class_alias, 0);
2594 add_info ("stack", backtrace_command,
2595 _("Backtrace of the stack, or innermost COUNT frames."));
2596 add_info_alias ("s", "stack", 1);
2597 add_info ("frame", info_frame_command,
2598 _("All about selected stack frame, or frame at ADDR."));
2599 add_info_alias ("f", "frame", 1);
2600 add_info ("locals", info_locals_command,
2601 _("Local variables of current stack frame."));
2602 add_info ("args", info_args_command,
2603 _("Argument variables of current stack frame."));
2604
2605 if (dbx_commands)
2606 add_com ("func", class_stack, func_command, _("\
2607 Select the stack frame that contains <func>.\n\
2608 Usage: func <name>\n"));
2609
2610 add_setshow_enum_cmd ("frame-arguments", class_stack,
2611 print_frame_arguments_choices, &print_frame_arguments,
2612 _("Set printing of non-scalar frame arguments"),
2613 _("Show printing of non-scalar frame arguments"),
2614 NULL, NULL, NULL, &setprintlist, &showprintlist);
2615
2616 add_setshow_boolean_cmd ("frame-arguments", no_class,
2617 &print_raw_frame_arguments, _("\
2618 Set whether to print frame arguments in raw form."), _("\
2619 Show whether to print frame arguments in raw form."), _("\
2620 If set, frame arguments are printed in raw form, bypassing any\n\
2621 pretty-printers for that value."),
2622 NULL, NULL,
2623 &setprintrawlist, &showprintrawlist);
2624
2625 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack,
2626 &disassemble_next_line, _("\
2627 Set whether to disassemble next source line or insn when execution stops."),
2628 _("\
2629 Show whether to disassemble next source line or insn when execution stops."),
2630 _("\
2631 If ON, GDB will display disassembly of the next source line, in addition\n\
2632 to displaying the source line itself. If the next source line cannot\n\
2633 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2634 will display disassembly of next instruction instead of showing the\n\
2635 source line.\n\
2636 If AUTO, display disassembly of next instruction only if the source line\n\
2637 cannot be displayed.\n\
2638 If OFF (which is the default), never display the disassembly of the next\n\
2639 source line."),
2640 NULL,
2641 show_disassemble_next_line,
2642 &setlist, &showlist);
2643 disassemble_next_line = AUTO_BOOLEAN_FALSE;
2644
2645 add_setshow_enum_cmd ("entry-values", class_stack,
2646 print_entry_values_choices, &print_entry_values,
2647 _("Set printing of function arguments at function "
2648 "entry"),
2649 _("Show printing of function arguments at function "
2650 "entry"),
2651 _("\
2652 GDB can sometimes determine the values of function arguments at entry,\n\
2653 in addition to their current values. This option tells GDB whether\n\
2654 to print the current value, the value at entry (marked as val@entry),\n\
2655 or both. Note that one or both of these values may be <optimized out>."),
2656 NULL, NULL, &setprintlist, &showprintlist);
2657 }
frame_id_p
int frame_id_p(struct frame_id l)
Definition: frame.c:646
gdbarch
Definition: gdbarch.c:127
sp_regnum
Definition: frv-tdep.h:32
frame_find_by_id
struct frame_info * frame_find_by_id(struct frame_id id)
Definition: frame.c:803
get_last_displayed_addr
CORE_ADDR get_last_displayed_addr(void)
Definition: stack.c:989
get_frame_address_in_block_if_available
int get_frame_address_in_block_if_available(struct frame_info *this_frame, CORE_ADDR *pc)
Definition: frame.c:2467
string
const char * string
Definition: signals.c:50
lookup_symbol_search_name
struct block_symbol lookup_symbol_search_name(const char *search_name, const struct block *block, domain_enum domain)
Definition: symtab.c:1905
annotate_frame_function_name
void annotate_frame_function_name(void)
Definition: annotate.c:471
get_last_displayed_sal
symtab_and_line get_last_displayed_sal()
Definition: stack.c:1019
show_disassemble_next_line
static void show_disassemble_next_line(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: stack.c:741
symtab_to_filename_for_display
const char * symtab_to_filename_for_display(struct symtab *symtab)
Definition: source.c:1168
fprintf_symbol_filtered
void fprintf_symbol_filtered(struct ui_file *stream, const char *name, enum language lang, int arg_mode)
Definition: utils.c:2134
iterate_over_block_arg_local_vars_cb
void(* iterate_over_block_arg_local_vars_cb)(const char *print_name, struct symbol *sym, void *cb_data)
Definition: stack.h:29
get_frame_address_in_block
CORE_ADDR get_frame_address_in_block(struct frame_info *this_frame)
Definition: frame.c:2407
annotate_frame_source_file_end
void annotate_frame_source_file_end(void)
Definition: annotate.c:499
down_silently_base
static void down_silently_base(const char *count_exp)
Definition: stack.c:2330
dbx_commands
int dbx_commands
Definition: main.c:56
get_selected_frame
struct frame_info * get_selected_frame(const char *message)
Definition: frame.c:1638
read_frame_arg
void read_frame_arg(struct symbol *sym, struct frame_info *frame, struct frame_arg *argp, struct frame_arg *entryargp)
Definition: stack.c:337
ui_out::field_core_addr
void field_core_addr(const char *fldname, struct gdbarch *gdbarch, CORE_ADDR address)
Definition: ui-out.c:513
value_print_options::deref_ref
int deref_ref
Definition: valprint.h:75
get_frame_pc
CORE_ADDR get_frame_pc(struct frame_info *frame)
Definition: frame.c:2376
SYMBOL_PRINT_NAME
#define SYMBOL_PRINT_NAME(symbol)
Definition: symtab.h:542
print_frame_arguments
static const char * print_frame_arguments
Definition: stack.c:62
MSYMBOL_LANGUAGE
#define MSYMBOL_LANGUAGE(symbol)
Definition: symtab.h:698
get_current_frame
struct frame_info * get_current_frame(void)
Definition: frame.c:1563
ui_out::field_string
void field_string(const char *fldname, const char *string)
Definition: ui-out.c:544
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
ui_out_emit_type
Definition: ui-out.h:192
RETURN_MASK_ALL
Definition: common-exceptions.h:44
frame_arg::sym
struct symbol * sym
Definition: frame.h:761
expression_up
gdb::unique_xmalloc_ptr< expression > expression_up
Definition: expression.h:87
iterate_over_block_locals
static void iterate_over_block_locals(const struct block *b, iterate_over_block_arg_local_vars_cb cb, void *cb_data)
Definition: stack.c:1910
frame_arg::val
struct value * val
Definition: frame.h:765
xfree
void xfree(void *)
ARCH_FRAME
Definition: frame.h:257
frame_arg::entry_kind
const char * entry_kind
Definition: frame.h:780
no_class
Definition: command.h:41
add_setshow_auto_boolean_cmd
void add_setshow_auto_boolean_cmd(const char *name, enum command_class theclass, enum auto_boolean *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:544
class_support
Definition: command.h:42
get_prev_frame
struct frame_info * get_prev_frame(struct frame_info *this_frame)
Definition: frame.c:2254
value_as_long
LONGEST value_as_long(struct value *val)
Definition: value.c:2749
frame_pop
void frame_pop(struct frame_info *this_frame)
Definition: frame.c:1031
cmd_list_element
Definition: cli-decode.h:46
frame_unwind_caller_pc
CORE_ADDR frame_unwind_caller_pc(struct frame_info *this_frame)
Definition: frame.c:944
func
void(* func)(char *)
Definition: remote-fileio.c:1104
BMSYMBOL_VALUE_ADDRESS
#define BMSYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:691
print_frame_args
static void print_frame_args(struct symbol *func, struct frame_info *frame, int num, struct ui_file *stream)
Definition: stack.c:535
warning
void warning(const char *fmt,...)
Definition: errors.c:26
ui_out::wrap_hint
void void wrap_hint(const char *identstring)
Definition: ui-out.c:597
symtab_and_line::end
CORE_ADDR end
Definition: symtab.h:1760
function_bounds::high
CORE_ADDR high
Definition: stack.c:2497
annotate_signal_handler_caller
void annotate_signal_handler_caller(void)
Definition: annotate.c:450
query
int query(const char *ctlstr,...)
Definition: utils.c:1063
SRC_LINE
Definition: frame.h:663
frame_stop_reason_string
const char * frame_stop_reason_string(struct frame_info *fi)
Definition: frame.c:2831
USER_SELECTED_FRAME
Definition: defs.h:702
RETURN_VALUE_STRUCT_CONVENTION
Definition: defs.h:258
lval_register
Definition: defs.h:385
gdb::def_vector
std::vector< T, gdb::default_init_allocator< T > > def_vector
Definition: def-vector.h:32
reggroups.h
val_print_unavailable
void val_print_unavailable(struct ui_file *stream)
Definition: valprint.c:368
common_val_print
void common_val_print(struct value *val, struct ui_file *stream, int recurse, const struct value_print_options *options, const struct language_defn *language)
Definition: valprint.c:1136
add_info
struct cmd_list_element * add_info(const char *name, cmd_const_cfunc_ftype *fun, const char *doc)
Definition: cli-decode.c:886
RETURN_MASK_ERROR
Definition: common-exceptions.h:43
print_entry_values_choices
static const char *const print_entry_values_choices[]
Definition: stack.c:77
frame_info::p
int p
Definition: frame.c:115
select_frame
void select_frame(struct frame_info *fi)
Definition: frame.c:1677
SYMBOL_CLASS
#define SYMBOL_CLASS(symbol)
Definition: symtab.h:1155
memset
void * memset(T *s, int c, size_t n)=delete
internal_error
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
language_def
const struct language_defn * language_def(enum language lang)
Definition: language.c:494
info_verbose
int info_verbose
Definition: top.c:1791
return_value_convention
return_value_convention
Definition: defs.h:247
get_frame_pc_if_available
int get_frame_pc_if_available(struct frame_info *frame, CORE_ADDR *pc)
Definition: frame.c:2383
identify_source_line
int identify_source_line(struct symtab *s, int line, int mid_statement, CORE_ADDR pc)
Definition: source.c:1295
disassemble_next_line
static enum auto_boolean disassemble_next_line
Definition: stack.c:738
CLI_ALL_VALUES
Definition: extension.h:123
add_setshow_enum_cmd
void add_setshow_enum_cmd(const char *name, enum command_class theclass, const char *const *enumlist, const char **var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:515
observer_notify_user_selected_context_changed
void observer_notify_user_selected_context_changed(user_selected_what selection)
AUTO_BOOLEAN_AUTO
Definition: defs.h:241
exception_none
const struct gdb_exception exception_none
Definition: common-exceptions.c:23
print_entry_values_only
const char print_entry_values_only[]
Definition: stack.c:71
value_lazy
int value_lazy(const struct value *value)
Definition: value.c:1383
disasm.h
coerce_ref
struct value * coerce_ref(struct value *arg)
Definition: value.c:3755
value_free
void value_free(struct value *val)
Definition: value.c:1608
SIGTRAMP_FRAME
Definition: frame.h:255
read_frame_local
void read_frame_local(struct symbol *sym, struct frame_info *frame, struct frame_arg *argp)
Definition: stack.c:314
frame_info
Definition: frame.c:85
unwind_stop_reason
unwind_stop_reason
Definition: frame.h:504
TYPE_NO_RETURN
#define TYPE_NO_RETURN(thistype)
Definition: gdbtypes.h:1328
cp-support.h
deprecated_print_frame_info_listing_hook
void(* deprecated_print_frame_info_listing_hook)(struct symtab *s, int line, int stopline, int noerror)
Definition: top.c:190
get_no_prettyformat_print_options
void get_no_prettyformat_print_options(struct value_print_options *opts)
Definition: valprint.c:128
frame_arg
Definition: frame.h:758
gdbarch_num_regs
int gdbarch_num_regs(struct gdbarch *gdbarch)
Definition: gdbarch.c:2039
print_variable_and_value
void print_variable_and_value(const char *name, struct symbol *var, struct frame_info *frame, struct ui_file *stream, int indent)
Definition: printcmd.c:2173
skip_spaces
char * skip_spaces(char *chp)
Definition: common-utils.c:337
all_reggroup
struct reggroup *const all_reggroup
Definition: reggroups.c:318
_
#define _(String)
Definition: gdb_locale.h:35
ui_file
Definition: ui-file.h:26
print_stack_frame_to_uiout
void print_stack_frame_to_uiout(struct ui_out *uiout, struct frame_info *frame, int print_level, enum print_what print_what, int set_current_sal)
Definition: stack.c:149
ui_left
Definition: ui-out.h:44
defs.h
lval_type
lval_type
Definition: defs.h:378
select_frame_command
void select_frame_command(const char *level_exp, int from_tty)
Definition: stack.c:2270
BLOCK_START
#define BLOCK_START(bl)
Definition: block.h:105
annotate_arg_value
void annotate_arg_value(struct type *type)
Definition: annotate.c:404
LOC_ARG
Definition: symtab.h:823
frame_info::pspace
struct program_space * pspace
Definition: frame.c:99
DECODE_LINE_FUNFIRSTLINE
Definition: linespec.h:31
END_CATCH
#define END_CATCH
Definition: common-exceptions.h:259
print_raw_frame_arguments
static int print_raw_frame_arguments
Definition: stack.c:65
annotate_arg_emitter
Definition: annotate.h:79
VALUE_LVAL
#define VALUE_LVAL(val)
Definition: value.h:414
ui_out::text
void text(const char *string)
Definition: ui-out.c:581
get_frame_locals_address
CORE_ADDR get_frame_locals_address(struct frame_info *fi)
Definition: frame.c:2566
get_current_regcache
struct regcache * get_current_regcache(void)
Definition: regcache.c:446
LOC_LOCAL
Definition: symtab.h:839
printf_filtered
void printf_filtered(const char *format,...)
Definition: utils.c:2045
paddress
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2745
objfiles.h
ext_lang_bt_status
ext_lang_bt_status
Definition: extension.h:69
language_defn
Definition: language.h:132
BLOCK_FUNCTION
#define BLOCK_FUNCTION(bl)
Definition: block.h:107
showprintrawlist
struct cmd_list_element * showprintrawlist
Definition: valprint.c:78
LOC_REGISTER
Definition: symtab.h:819
observer.h
symtab_to_fullname
const char * symtab_to_fullname(struct symtab *s)
Definition: source.c:1131
cli_suppress_notification::user_selected_context
int user_selected_context
Definition: command.h:127
frame_command
static void frame_command(const char *level_exp, int from_tty)
Definition: stack.c:2284
make_scoped_restore
scoped_restore_tmpl< T > make_scoped_restore(T *var)
Definition: scoped_restore.h:105
DUMMY_FRAME
Definition: frame.h:247
print_frame_local_vars
static void print_frame_local_vars(struct frame_info *, int, struct ui_file *)
Definition: stack.c:2053
info_args_command
void info_args_command(const char *ignore, int from_tty)
Definition: stack.c:2192
value::lval
enum lval_type lval
Definition: value.c:173
flags
mach_port_t kern_return_t mach_port_t msgports mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
Definition: gnu-nat.c:1891
NOT_AVAILABLE_ERROR
Definition: common-exceptions.h:82
gdbarch_num_pseudo_regs
int gdbarch_num_pseudo_regs(struct gdbarch *gdbarch)
Definition: gdbarch.c:2057
evaluate_expression
struct value * evaluate_expression(struct expression *exp)
Definition: eval.c:144
TRY
#define TRY
Definition: common-exceptions.h:246
TYPE_CODE_VOID
Definition: gdbtypes.h:124
symtab.h
MSYMBOL_PRINT_NAME
#define MSYMBOL_PRINT_NAME(symbol)
Definition: symtab.h:708
frame_id_eq
int frame_id_eq(struct frame_id l, struct frame_id r)
Definition: frame.c:674
gdb_argv
Definition: utils.h:128
lval_memory
Definition: defs.h:383
setlist
struct cmd_list_element * setlist
Definition: cli-cmds.c:111
print_frame_arg_vars
static void print_frame_arg_vars(struct frame_info *frame, struct ui_file *stream)
Definition: stack.c:2157
annotate_frame_address
void annotate_frame_address(void)
Definition: annotate.c:457
value_contents_eq
bool value_contents_eq(const struct value *val1, LONGEST offset1, const struct value *val2, LONGEST offset2, LONGEST length)
Definition: value.c:874
get_frame_type
enum frame_type get_frame_type(struct frame_info *frame)
Definition: frame.c:2619
add_com_suppress_notification
struct cmd_list_element * add_com_suppress_notification(const char *name, enum command_class theclass, cmd_const_cfunc_ftype *fun, const char *doc, int *suppress_notification)
Definition: cli-decode.c:921
EXT_LANG_BT_ERROR
Definition: extension.h:73
annotate_frame_args
void annotate_frame_args(void)
Definition: annotate.c:478
inline-frame.h
annotate_frame_source_file
void annotate_frame_source_file(void)
Definition: annotate.c:492
get_frame_id
struct frame_id get_frame_id(struct frame_info *fi)
Definition: frame.c:520
check_typedef
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2421
read_memory_integer
LONGEST read_memory_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition: corefile.c:316
SYMBOL_VALUE_ADDRESS
#define SYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:464
frame_info::level
int level
Definition: frame.c:96
print_variable_and_value_data::stream
struct ui_file * stream
Definition: stack.c:2017
value_contents
const gdb_byte * value_contents(struct value *value)
Definition: value.c:1407
PRINT_ARGS
Definition: extension.h:99
CATCH
#define CATCH(EXCEPTION, MASK)
Definition: common-exceptions.h:254
LOC_COMPUTED
Definition: symtab.h:892
value_print_options
Definition: valprint.h:25
gdb::unique_xmalloc_ptr
std::unique_ptr< T, xfree_deleter< T > > unique_xmalloc_ptr
Definition: gdb_unique_ptr.h:48
expand_symtab_containing_pc
void expand_symtab_containing_pc(CORE_ADDR pc, struct obj_section *section)
Definition: symtab.c:1032
SYMBOL_DOMAIN
#define SYMBOL_DOMAIN(symbol)
Definition: symtab.h:1152
find_pc_line
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
Definition: symtab.c:3288
gdbarch_sp_regnum
int gdbarch_sp_regnum(struct gdbarch *gdbarch)
Definition: gdbarch.c:2146
inline_skipped_frames
int inline_skipped_frames(ptid_t ptid)
Definition: inline-frame.c:369
last_displayed_addr
static CORE_ADDR last_displayed_addr
Definition: stack.c:117
print_entry_values_if_needed
const char print_entry_values_if_needed[]
Definition: stack.c:73
print_selected_thread_frame
void print_selected_thread_frame(struct ui_out *uiout, user_selected_what selection)
Definition: thread.c:1942
get_frame_unwind_stop_reason
enum unwind_stop_reason get_frame_unwind_stop_reason(struct frame_info *frame)
Definition: frame.c:2803
fprintf_filtered
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2008
COMMON_BLOCK_DOMAIN
Definition: symtab.h:757
annotate_frame_source_end
void annotate_frame_source_end(void)
Definition: annotate.c:513
read_var_value
struct value * read_var_value(struct symbol *var, const struct block *var_block, struct frame_info *frame)
Definition: findvar.c:807
return_command
void return_command(const char *retval_exp, int from_tty)
Definition: stack.c:2366
LOCATION
Definition: frame.h:666
extract_unsigned_integer
static ULONGEST extract_unsigned_integer(const gdb_byte *addr, int len, enum bfd_endian byte_order)
Definition: defs.h:577
setprintrawlist
struct cmd_list_element * setprintrawlist
Definition: valprint.c:77
NO_ENTRY_VALUE_ERROR
Definition: common-exceptions.h:89
regcache.h
get_frame_block
const struct block * get_frame_block(struct frame_info *frame, CORE_ADDR *addr_in_block)
Definition: blockframe.c:55
bound_minimal_symbol
Definition: minsyms.h:29
get_selected_block
const struct block * get_selected_block(CORE_ADDR *addr_in_block)
Definition: stack.c:2216
up_silently_base
static void up_silently_base(const char *count_exp)
Definition: stack.c:2299
down_silently_command
static void down_silently_command(const char *count_exp, int from_tty)
Definition: stack.c:2353
ext_lang_frame_args
ext_lang_frame_args
Definition: extension.h:108
showlist
struct cmd_list_element * showlist
Definition: cli-cmds.c:119
exception_print
void exception_print(struct ui_file *file, struct gdb_exception e)
Definition: exceptions.c:109
frame_info::prev
struct frame_info * prev
Definition: frame.c:149
func_command
static void func_command(const char *arg, int from_tty)
Definition: stack.c:2501
add_com_alias
struct cmd_list_element * add_com_alias(const char *name, const char *oldname, enum command_class theclass, int abbrev_flag)
Definition: cli-decode.c:912
value_contents_all
const gdb_byte * value_contents_all(struct value *value)
Definition: value.c:1265
cli-utils.h
fputs_filtered
void fputs_filtered(const char *linebuffer, struct ui_file *stream)
Definition: utils.c:1811
frame.h
expression.h
puts_filtered
void puts_filtered(const char *string)
Definition: utils.c:2085
print_frame_info
void print_frame_info(struct frame_info *frame, int print_level, enum print_what print_what, int print_args, int set_current_sal)
Definition: stack.c:786
select_and_print_frame
static void select_and_print_frame(struct frame_info *frame)
Definition: stack.c:2201
get_frame_function
struct symbol * get_frame_function(struct frame_info *frame)
Definition: blockframe.c:118
SYMBOL_COMPUTED_OPS
#define SYMBOL_COMPUTED_OPS(symbol)
Definition: symtab.h:1163
gdbarch_byte_order
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1509
gdbthread.h
current_uiout
#define current_uiout
Definition: ui-out.h:39
get_selected_frame_if_set
struct frame_info * get_selected_frame_if_set(void)
Definition: frame.c:1657
iterate_over_block_local_vars
void iterate_over_block_local_vars(const struct block *block, iterate_over_block_arg_local_vars_cb cb, void *cb_data)
Definition: stack.c:1994
inferior.h
solib_name_from_address
char * solib_name_from_address(struct program_space *pspace, CORE_ADDR address)
Definition: solib.c:1172
scoped_restore_base
Definition: scoped_restore.h:24
language_str
const char * language_str(enum language lang)
Definition: language.c:502
type
Definition: gdbtypes.h:749
find_pc_partial_function
int find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr)
Definition: blockframe.c:320
VALUE_REGNUM
#define VALUE_REGNUM(val)
Definition: value.h:451
class_alias
Definition: command.h:43
language.h
SRC_AND_LOC
Definition: frame.h:668
BLOCK_SUPERBLOCK
#define BLOCK_SUPERBLOCK(bl)
Definition: block.h:108
value_print_options::summary
int summary
Definition: valprint.h:90
symtab::language
enum language language
Definition: symtab.h:1323
gdbarch_return_value
enum return_value_convention gdbarch_return_value(struct gdbarch *gdbarch, struct value *function, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
Definition: gdbarch.c:2728
get_last_displayed_pspace
struct program_space * get_last_displayed_pspace(void)
Definition: stack.c:979
ui_out::field_stream
void field_stream(const char *fldname, string_file &stream)
Definition: ui-out.c:520
find_relative_frame
struct frame_info * find_relative_frame(struct frame_info *frame, int *level_offset_ptr)
Definition: stack.c:2234
SYMBOL_LINKAGE_NAME
#define SYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:523
solib.h
function_bounds
Definition: stack.c:2495
gdbarch_register_name
const char * gdbarch_register_name(struct gdbarch *gdbarch, int regnr)
Definition: gdbarch.c:2282
last_displayed_line
static int last_displayed_line
Definition: stack.c:119
linespec.h
value_cast
struct value * value_cast(struct type *type, struct value *arg2)
Definition: valops.c:351
LOC_STATIC
Definition: symtab.h:805
language_mode
language_mode
Definition: language.h:468
create_new_frame
struct frame_info * create_new_frame(CORE_ADDR addr, CORE_ADDR pc)
Definition: frame.c:1722
PRINT_LOCALS
Definition: extension.h:102
print_frame_nameless_args
static void print_frame_nameless_args(struct frame_info *frame, long start, int num, int first, struct ui_file *stream)
Definition: stack.c:193
get_frame_args_address
CORE_ADDR get_frame_args_address(struct frame_info *fi)
Definition: frame.c:2581
print_what
print_what
Definition: frame.h:660
setprintlist
struct cmd_list_element * setprintlist
Definition: cli-cmds.c:149
class_stack
Definition: command.h:41
breakpoint.h
info_locals_command
void info_locals_command(const char *args, int from_tty)
Definition: stack.c:2110
print_entry_values_preferred
const char print_entry_values_preferred[]
Definition: stack.c:72
struct_return_convention
enum return_value_convention struct_return_convention(struct gdbarch *gdbarch, struct value *function, struct type *value_type)
Definition: value.c:3805
get_last_displayed_line
int get_last_displayed_line(void)
Definition: stack.c:1009
frame_unwind_caller_id
struct frame_id frame_unwind_caller_id(struct frame_info *next_frame)
Definition: frame.c:555
value_print_options::addressprint
int addressprint
Definition: valprint.h:43
print_frame_arg
static void print_frame_arg(const struct frame_arg *arg)
Definition: stack.c:225
ui_file::puts
virtual void puts(const char *str)
Definition: ui-file.h:63
symtab
Definition: symtab.h:1291
_initialize_stack
void _initialize_stack(void)
Definition: stack.c:2547
frame_unwind_register_value
struct value * frame_unwind_register_value(struct frame_info *frame, int regnum)
Definition: frame.c:1172
LOC_REGPARM_ADDR
Definition: symtab.h:835
DISASSEMBLY_RAW_INSN
Definition: disasm.h:28
print_variable_and_value_data::frame_id
struct frame_id frame_id
Definition: stack.c:2015
PRINT_FRAME_INFO
Definition: extension.h:96
symtab_and_line::symtab
struct symtab * symtab
Definition: symtab.h:1751
cli_suppress_notification
Definition: command.h:124
last_displayed_pspace
static struct program_space * last_displayed_pspace
Definition: stack.c:116
extension.h
block_symbol::symbol
struct symbol * symbol
Definition: symtab.h:1136
SYMBOL_VALUE
#define SYMBOL_VALUE(symbol)
Definition: symtab.h:463
frame_arg::error
char * error
Definition: frame.h:769
LOC_REF_ARG
Definition: symtab.h:827
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
block
Definition: block.h:60
get_last_displayed_symtab
struct symtab * get_last_displayed_symtab(void)
Definition: stack.c:999
value
Definition: value.c:169
find_frame_sal
symtab_and_line find_frame_sal(frame_info *frame)
Definition: frame.c:2487
gdbarch_frame_args_skip
CORE_ADDR gdbarch_frame_args_skip(struct gdbarch *gdbarch)
Definition: gdbarch.c:3045
wrap_here
void wrap_here(const char *indent)
Definition: utils.c:1596
ui_out
Definition: ui-out.h:77
last_displayed_sal_valid
static int last_displayed_sal_valid
Definition: stack.c:115
annotate_frame_begin
void annotate_frame_begin(int level, struct gdbarch *gdbarch, CORE_ADDR pc)
Definition: annotate.c:435
annotation_level
int annotation_level
Definition: stack.c:111
symtab_and_line
Definition: symtab.h:1746
print_variable_and_value_data::values_printed
int values_printed
Definition: stack.c:2018
ui_file::printf
void printf(const char *,...) ATTRIBUTE_PRINTF(2
Definition: ui-file.c:37
print_args
static void print_args(struct field *args, int nargs, int spaces)
Definition: gdbtypes.c:4208
throw_exception
void throw_exception(struct gdb_exception exception)
Definition: common-exceptions.c:312
gdbarch::return_value
gdbarch_return_value_ftype * return_value
Definition: gdbarch.c:236
get_next_frame
struct frame_info * get_next_frame(struct frame_info *this_frame)
Definition: frame.c:1771
block_inlined_p
int block_inlined_p(const struct block *bl)
Definition: block.c:126
value_entirely_available
int value_entirely_available(struct value *value)
Definition: value.c:374
language_mode_auto
Definition: language.h:470
print_frame
static void print_frame(struct frame_info *frame, int print_level, enum print_what print_what, int print_args, struct symtab_and_line sal)
parse_frame_specification
static struct frame_info * parse_frame_specification(const char *frame_exp, int *selected_frame_p)
Definition: stack.c:1264
RETURN_VALUE_ABI_RETURNS_ADDRESS
Definition: defs.h:264
current_language
const struct language_defn * current_language
Definition: language.c:81
value_optimized_out
int value_optimized_out(struct value *value)
Definition: value.c:1424
find_pc_mapped_section
struct obj_section * find_pc_mapped_section(CORE_ADDR pc)
Definition: symfile.c:3202
target_has_stack
#define target_has_stack
Definition: target.h:1735
last_displayed_sal_is_valid
int last_displayed_sal_is_valid(void)
Definition: stack.c:971
TYPE_TARGET_TYPE
#define TYPE_TARGET_TYPE(thistype)
Definition: gdbtypes.h:1226
symbol::type
struct type * type
Definition: symtab.h:1058
source.h
value_fetch_lazy
void value_fetch_lazy(struct value *val)
Definition: value.c:3860
gdb_disassembly
void gdb_disassembly(struct gdbarch *gdbarch, struct ui_out *uiout, gdb_disassembly_flags flags, int how_many, CORE_ADDR low, CORE_ADDR high)
Definition: disasm.c:780
lookup_minimal_symbol_by_pc
struct bound_minimal_symbol lookup_minimal_symbol_by_pc(CORE_ADDR pc)
Definition: minsyms.c:928
gdbarch_register_reggroup_p
int gdbarch_register_reggroup_p(struct gdbarch *gdbarch, int regnum, struct reggroup *reggroup)
Definition: gdbarch.c:3589
INLINE_FRAME
Definition: frame.h:250
gdb_stderr
#define gdb_stderr
Definition: utils.h:344
annotate_frame_end
void annotate_frame_end(void)
Definition: annotate.c:527
gdbcore.h
frame_relative_level
int frame_relative_level(struct frame_info *fi)
Definition: frame.c:2610
SYMBOL_BLOCK_VALUE
#define SYMBOL_BLOCK_VALUE(symbol)
Definition: symtab.h:467
TYPE_CODE
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1238
get_frame_base
CORE_ADDR get_frame_base(struct frame_info *fi)
Definition: frame.c:2544
annotate_frame_source_begin
void annotate_frame_source_begin(void)
Definition: annotate.c:485
up_command
static void up_command(const char *count_exp, int from_tty)
Definition: stack.c:2320
ui_out::field_int
void field_int(const char *fldname, int value)
Definition: ui-out.c:486
annotate_frame_address_end
void annotate_frame_address_end(void)
Definition: annotate.c:464
apply_ext_lang_frame_filter
enum ext_lang_bt_status apply_ext_lang_frame_filter(struct frame_info *frame, int flags, enum ext_lang_frame_args args_type, struct ui_out *out, int frame_low, int frame_high)
Definition: extension.c:556
last_displayed_symtab
static struct symtab * last_displayed_symtab
Definition: stack.c:118
inferior_ptid
ptid_t inferior_ptid
Definition: infcmd.c:94
print_source_lines
void print_source_lines(struct symtab *s, int line, int stopline, print_source_lines_flags flags)
Definition: source.c:1471
OPTIMIZED_OUT_ERROR
Definition: common-exceptions.h:86
bound_minimal_symbol::minsym
struct minimal_symbol * minsym
Definition: minsyms.h:34
down_command
static void down_command(const char *count_exp, int from_tty)
Definition: stack.c:2359
PRINT_LEVEL
Definition: extension.h:93
decode_line_with_current_source
std::vector< symtab_and_line > decode_line_with_current_source(const char *string, int flags)
Definition: linespec.c:3371
symtab_and_line::pspace
struct program_space * pspace
Definition: symtab.h:1749
get_user_print_options
void get_user_print_options(struct value_print_options *opts)
Definition: valprint.c:120
add_setshow_boolean_cmd
void add_setshow_boolean_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:569
AUTO_BOOLEAN_TRUE
Definition: defs.h:239
CLI_SCALAR_VALUES
Definition: extension.h:120
regcache::arch
gdbarch * arch() const
Definition: regcache.c:221
SYMBOL_LANGUAGE
#define SYMBOL_LANGUAGE(symbol)
Definition: symtab.h:469
LOC_LABEL
Definition: symtab.h:848
annotate_frame_source_line
void annotate_frame_source_line(void)
Definition: annotate.c:506
symtab_and_line::pc
CORE_ADDR pc
Definition: symtab.h:1759
target.h
find_frame_funname
gdb::unique_xmalloc_ptr< char > find_frame_funname(struct frame_info *frame, enum language *funlang, struct symbol **funcp)
Definition: stack.c:1039
VAR_DOMAIN
Definition: symtab.h:739
value.h
block_iterator
Definition: block.h:197
showprintlist
struct cmd_list_element * showprintlist
Definition: cli-cmds.c:151
print_entry_values_default
const char print_entry_values_default[]
Definition: stack.c:76
print_entry_values_no
const char print_entry_values_no[]
Definition: stack.c:70
backtrace_command
static void backtrace_command(const char *arg, int from_tty)
Definition: stack.c:1847
frame_register_unwind
void frame_register_unwind(struct frame_info *frame, int regnum, int *optimizedp, int *unavailablep, enum lval_type *lvalp, CORE_ADDR *addrp, int *realnump, gdb_byte *bufferp)
Definition: frame.c:1081
print_frame_arguments_choices
static const char *const print_frame_arguments_choices[]
Definition: stack.c:60
add_info_alias
struct cmd_list_element * add_info_alias(const char *name, const char *oldname, int abbrev_flag)
Definition: cli-decode.c:894
print_entry_values
const char * print_entry_values
Definition: stack.c:88
auto_boolean
auto_boolean
Definition: defs.h:237
set_last_displayed_sal
static void set_last_displayed_sal(int valid, struct program_space *pspace, CORE_ADDR addr, struct symtab *symtab, int line)
Definition: stack.c:937
current_program_space
struct program_space * current_program_space
Definition: progspace.c:35
gdbtypes.h
annotate_frame_where
void annotate_frame_where(void)
Definition: annotate.c:520
backtrace_command_1
static void backtrace_command_1(const char *count_exp, int show_locals, int no_filters, int from_tty)
Definition: stack.c:1695
parse_and_eval
struct value * parse_and_eval(const char *exp)
Definition: eval.c:119
gdb_exception
Definition: common-exceptions.h:111
ignore
static int ignore(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: corelow.c:879
symbol_computed_ops::read_variable_at_entry
struct value *(* read_variable_at_entry)(struct symbol *symbol, struct frame_info *frame)
Definition: symtab.h:932
SYMBOL_SEARCH_NAME
#define SYMBOL_SEARCH_NAME(symbol)
Definition: symtab.h:551
language
language
Definition: defs.h:203
parse_expression
expression_up parse_expression(const char *)
Definition: parse.c:1237
release_value
void release_value(struct value *val)
Definition: value.c:1693
gdb_argv::get
char ** get()
Definition: utils.h:177
register_size
int register_size(struct gdbarch *gdbarch, int regnum)
Definition: regcache.c:164
function_bounds::low
CORE_ADDR low
Definition: stack.c:2497
frame_show_address
static int frame_show_address(struct frame_info *frame, struct symtab_and_line sal)
Definition: stack.c:126
iterate_over_block_arg_vars
void iterate_over_block_arg_vars(const struct block *b, iterate_over_block_arg_local_vars_cb cb, void *cb_data)
Definition: stack.c:2121
annotate_function_call
void annotate_function_call(void)
Definition: annotate.c:443
NO_VALUES
Definition: extension.h:111
value_type
struct type * value_type(const struct value *value)
Definition: value.c:1095
frame_info::addr
CORE_ADDR addr
Definition: frame.c:128
SYMBOL_TYPE
#define SYMBOL_TYPE(symbol)
Definition: symtab.h:1161
symbol
Definition: symtab.h:1049
annotate_arg_name_end
void annotate_arg_name_end(void)
Definition: annotate.c:397
ui_out::field_fmt_int
void field_fmt_int(int width, ui_align align, const char *fldname, int value)
Definition: ui-out.c:498
frame_info::next
struct frame_info * next
Definition: frame.c:147
gdbarch_pc_regnum
int gdbarch_pc_regnum(struct gdbarch *gdbarch)
Definition: gdbarch.c:2163
value_print_options::raw
int raw
Definition: valprint.h:85
value_as_address
CORE_ADDR value_as_address(struct value *val)
Definition: value.c:2762
LOC_OPTIMIZED_OUT
Definition: symtab.h:888
frame_id_build_wild
struct frame_id frame_id_build_wild(CORE_ADDR stack_addr)
Definition: frame.c:636
set_current_source_symtab_and_line
struct symtab_and_line set_current_source_symtab_and_line(const symtab_and_line &sal)
Definition: source.c:209
TAILCALL_FRAME
Definition: frame.h:252
def-vector.h
symtab_and_line::line
int line
Definition: symtab.h:1757
LOC_AND_ADDRESS
Definition: frame.h:670
gdb.argv
argv
Definition: __init__.py:63
TYPE_LENGTH
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1235
up_silently_command
static void up_silently_command(const char *count_exp, int from_tty)
Definition: stack.c:2314
do_gdb_disassembly
static void do_gdb_disassembly(struct gdbarch *gdbarch, int how_many, CORE_ADDR low, CORE_ADDR high)
Definition: stack.c:755
EXT_LANG_BT_NO_FILTERS
Definition: extension.h:85
annotate.h
gdb_flush
void gdb_flush(struct ui_file *file)
Definition: ui-file.c:93
allocate_optimized_out_value
struct value * allocate_optimized_out_value(struct type *type)
Definition: value.c:1077
print_variable_and_value_data
Definition: stack.c:2013
language_unknown
Definition: defs.h:205
QUIT
#define QUIT
Definition: defs.h:179
print_entry_values_compact
const char print_entry_values_compact[]
Definition: stack.c:75
add_com
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_const_cfunc_ftype *fun, const char *doc)
Definition: cli-decode.c:902
valprint.h
value_address
CORE_ADDR value_address(const struct value *value)
Definition: value.c:1529
not_lval
Definition: defs.h:381
RETURN_VALUE_REGISTER_CONVENTION
Definition: defs.h:251
stack.h
gdbarch::byte_order
enum bfd_endian byte_order
Definition: gdbarch.c:137
set_current_sal_from_frame
void set_current_sal_from_frame(struct frame_info *frame)
Definition: stack.c:725
print_variable_and_value_data::num_tabs
int num_tabs
Definition: stack.c:2016
gdbcmd.h
has_stack_frames
int has_stack_frames(void)
Definition: frame.c:1609
get_frame_program_space
struct program_space * get_frame_program_space(struct frame_info *frame)
Definition: frame.c:2629
gdbarch_frame_num_args_p
int gdbarch_frame_num_args_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:3110
symbol_computed_ops
Definition: symtab.h:916
language_cplus
Definition: defs.h:209
error
void error(const char *fmt,...)
Definition: errors.c:38
print_stack_frame
void print_stack_frame(struct frame_info *frame, int print_level, enum print_what print_what, int set_current_sal)
Definition: stack.c:165
do_print_variable_and_value
static void do_print_variable_and_value(const char *print_name, struct symbol *sym, void *cb_data)
Definition: stack.c:2024
ALL_BLOCK_SYMBOLS
#define ALL_BLOCK_SYMBOLS(block, iter, sym)
Definition: block.h:310
frame_id
Definition: frame.h:111
dictionary.h
val_print_not_saved
void val_print_not_saved(struct ui_file *stream)
Definition: valprint.c:362
get_frame_arch
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2691
block.h
print_entry_values_both
const char print_entry_values_both[]
Definition: stack.c:74
gdbarch_frame_num_args
int gdbarch_frame_num_args(struct gdbarch *gdbarch, struct frame_info *frame)
Definition: gdbarch.c:3117
program_space
Definition: progspace.h:137
ui_out::is_mi_like_p
bool is_mi_like_p()
Definition: ui-out.c:622
SYMBOL_IS_ARGUMENT
#define SYMBOL_IS_ARGUMENT(symbol)
Definition: symtab.h:1157
symfile.h
AUTO_BOOLEAN_FALSE
Definition: defs.h:240
gdb_exception::reason
enum return_reason reason
Definition: common-exceptions.h:113
ui-out.h
subset_compare
int subset_compare(const char *string_to_compare, const char *template_string)
Definition: utils.c:2654
gdb_stdout
#define gdb_stdout
Definition: utils.h:340
info_frame_command
static void info_frame_command(const char *addr_exp, int from_tty)
Definition: stack.c:1383
clear_last_displayed_sal
void clear_last_displayed_sal(void)
Definition: stack.c:957
cp_remove_params
gdb::unique_xmalloc_ptr< char > cp_remove_params(const char *demangled_name)
Definition: cp-support.c:892
string_file
Definition: ui-file.h:106
parse_and_eval_long
LONGEST parse_and_eval_long(const char *exp)
Definition: eval.c:111