1 /* Cache and manage frames for GDB, the GNU debugger.
3 Copyright 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000,
4 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
27 #include "inferior.h" /* for inferior_ptid */
29 #include "gdb_assert.h"
30 #include "gdb_string.h"
31 #include "user-regs.h"
32 #include "gdb_obstack.h"
33 #include "dummy-frame.h"
34 #include "sentinel-frame.h"
38 #include "frame-unwind.h"
39 #include "frame-base.h"
45 static struct frame_info
*get_prev_frame_1 (struct frame_info
*this_frame
);
47 /* We keep a cache of stack frames, each of which is a "struct
48 frame_info". The innermost one gets allocated (in
49 wait_for_inferior) each time the inferior stops; current_frame
50 points to it. Additional frames get allocated (in get_prev_frame)
51 as needed, and are chained through the next and prev fields. Any
52 time that the frame cache becomes invalid (most notably when we
53 execute something, but also if we change how we interpret the
54 frames (e.g. "set heuristic-fence-post" in mips-tdep.c, or anything
55 which reads new symbols)), we should call reinit_frame_cache. */
59 /* Level of this frame. The inner-most (youngest) frame is at level
60 0. As you move towards the outer-most (oldest) frame, the level
61 increases. This is a cached value. It could just as easily be
62 computed by counting back from the selected frame to the inner
64 /* NOTE: cagney/2002-04-05: Perhaps a level of ``-1'' should be
65 reserved to indicate a bogus frame - one that has been created
66 just to keep GDB happy (GDB always needs a frame). For the
67 moment leave this as speculation. */
70 /* The frame's low-level unwinder and corresponding cache. The
71 low-level unwinder is responsible for unwinding register values
72 for the previous frame. The low-level unwind methods are
73 selected based on the presence, or otherwise, of register unwind
74 information such as CFI. */
76 const struct frame_unwind
*unwind
;
78 /* Cached copy of the previous frame's resume address. */
84 /* Cached copy of the previous frame's function address. */
91 /* This frame's ID. */
95 struct frame_id value
;
98 /* The frame's high-level base methods, and corresponding cache.
99 The high level base methods are selected based on the frame's
101 const struct frame_base
*base
;
104 /* Pointers to the next (down, inner, younger) and previous (up,
105 outer, older) frame_info's in the frame cache. */
106 struct frame_info
*next
; /* down, inner, younger */
108 struct frame_info
*prev
; /* up, outer, older */
111 /* Flag to control debugging. */
113 static int frame_debug
;
115 /* Flag to indicate whether backtraces should stop at main et.al. */
117 static int backtrace_past_main
;
118 static unsigned int backtrace_limit
= UINT_MAX
;
121 fprint_field (struct ui_file
*file
, const char *name
, int p
, CORE_ADDR addr
)
124 fprintf_unfiltered (file
, "%s=0x%s", name
, paddr_nz (addr
));
126 fprintf_unfiltered (file
, "!%s", name
);
130 fprint_frame_id (struct ui_file
*file
, struct frame_id id
)
132 fprintf_unfiltered (file
, "{");
133 fprint_field (file
, "stack", id
.stack_addr_p
, id
.stack_addr
);
134 fprintf_unfiltered (file
, ",");
135 fprint_field (file
, "code", id
.code_addr_p
, id
.code_addr
);
136 fprintf_unfiltered (file
, ",");
137 fprint_field (file
, "special", id
.special_addr_p
, id
.special_addr
);
138 fprintf_unfiltered (file
, "}");
142 fprint_frame_type (struct ui_file
*file
, enum frame_type type
)
147 fprintf_unfiltered (file
, "NORMAL_FRAME");
150 fprintf_unfiltered (file
, "DUMMY_FRAME");
153 fprintf_unfiltered (file
, "SIGTRAMP_FRAME");
156 fprintf_unfiltered (file
, "<unknown type>");
162 fprint_frame (struct ui_file
*file
, struct frame_info
*fi
)
166 fprintf_unfiltered (file
, "<NULL frame>");
169 fprintf_unfiltered (file
, "{");
170 fprintf_unfiltered (file
, "level=%d", fi
->level
);
171 fprintf_unfiltered (file
, ",");
172 fprintf_unfiltered (file
, "type=");
173 if (fi
->unwind
!= NULL
)
174 fprint_frame_type (file
, fi
->unwind
->type
);
176 fprintf_unfiltered (file
, "<unknown>");
177 fprintf_unfiltered (file
, ",");
178 fprintf_unfiltered (file
, "unwind=");
179 if (fi
->unwind
!= NULL
)
180 gdb_print_host_address (fi
->unwind
, file
);
182 fprintf_unfiltered (file
, "<unknown>");
183 fprintf_unfiltered (file
, ",");
184 fprintf_unfiltered (file
, "pc=");
185 if (fi
->next
!= NULL
&& fi
->next
->prev_pc
.p
)
186 fprintf_unfiltered (file
, "0x%s", paddr_nz (fi
->next
->prev_pc
.value
));
188 fprintf_unfiltered (file
, "<unknown>");
189 fprintf_unfiltered (file
, ",");
190 fprintf_unfiltered (file
, "id=");
192 fprint_frame_id (file
, fi
->this_id
.value
);
194 fprintf_unfiltered (file
, "<unknown>");
195 fprintf_unfiltered (file
, ",");
196 fprintf_unfiltered (file
, "func=");
197 if (fi
->next
!= NULL
&& fi
->next
->prev_func
.p
)
198 fprintf_unfiltered (file
, "0x%s", paddr_nz (fi
->next
->prev_func
.addr
));
200 fprintf_unfiltered (file
, "<unknown>");
201 fprintf_unfiltered (file
, "}");
204 /* Return a frame uniq ID that can be used to, later, re-find the
208 get_frame_id (struct frame_info
*fi
)
212 return null_frame_id
;
217 fprintf_unfiltered (gdb_stdlog
, "{ get_frame_id (fi=%d) ",
219 /* Find the unwinder. */
220 if (fi
->unwind
== NULL
)
221 fi
->unwind
= frame_unwind_find_by_frame (fi
->next
,
222 &fi
->prologue_cache
);
223 /* Find THIS frame's ID. */
224 fi
->unwind
->this_id (fi
->next
, &fi
->prologue_cache
, &fi
->this_id
.value
);
228 fprintf_unfiltered (gdb_stdlog
, "-> ");
229 fprint_frame_id (gdb_stdlog
, fi
->this_id
.value
);
230 fprintf_unfiltered (gdb_stdlog
, " }\n");
233 return fi
->this_id
.value
;
237 frame_unwind_id (struct frame_info
*next_frame
)
239 /* Use prev_frame, and not get_prev_frame. The latter will truncate
240 the frame chain, leading to this function unintentionally
241 returning a null_frame_id (e.g., when a caller requests the frame
242 ID of "main()"s caller. */
243 return get_frame_id (get_prev_frame_1 (next_frame
));
246 const struct frame_id null_frame_id
; /* All zeros. */
249 frame_id_build_special (CORE_ADDR stack_addr
, CORE_ADDR code_addr
,
250 CORE_ADDR special_addr
)
252 struct frame_id id
= null_frame_id
;
253 id
.stack_addr
= stack_addr
;
255 id
.code_addr
= code_addr
;
257 id
.special_addr
= special_addr
;
258 id
.special_addr_p
= 1;
263 frame_id_build (CORE_ADDR stack_addr
, CORE_ADDR code_addr
)
265 struct frame_id id
= null_frame_id
;
266 id
.stack_addr
= stack_addr
;
268 id
.code_addr
= code_addr
;
274 frame_id_build_wild (CORE_ADDR stack_addr
)
276 struct frame_id id
= null_frame_id
;
277 id
.stack_addr
= stack_addr
;
283 frame_id_p (struct frame_id l
)
286 /* The frame is valid iff it has a valid stack address. */
290 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_p (l=");
291 fprint_frame_id (gdb_stdlog
, l
);
292 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", p
);
298 frame_id_eq (struct frame_id l
, struct frame_id r
)
301 if (!l
.stack_addr_p
|| !r
.stack_addr_p
)
302 /* Like a NaN, if either ID is invalid, the result is false.
303 Note that a frame ID is invalid iff it is the null frame ID. */
305 else if (l
.stack_addr
!= r
.stack_addr
)
306 /* If .stack addresses are different, the frames are different. */
308 else if (!l
.code_addr_p
|| !r
.code_addr_p
)
309 /* An invalid code addr is a wild card, always succeed. */
311 else if (l
.code_addr
!= r
.code_addr
)
312 /* If .code addresses are different, the frames are different. */
314 else if (!l
.special_addr_p
|| !r
.special_addr_p
)
315 /* An invalid special addr is a wild card (or unused), always succeed. */
317 else if (l
.special_addr
== r
.special_addr
)
318 /* Frames are equal. */
325 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_eq (l=");
326 fprint_frame_id (gdb_stdlog
, l
);
327 fprintf_unfiltered (gdb_stdlog
, ",r=");
328 fprint_frame_id (gdb_stdlog
, r
);
329 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", eq
);
335 frame_id_inner (struct frame_id l
, struct frame_id r
)
338 if (!l
.stack_addr_p
|| !r
.stack_addr_p
)
339 /* Like NaN, any operation involving an invalid ID always fails. */
342 /* Only return non-zero when strictly inner than. Note that, per
343 comment in "frame.h", there is some fuzz here. Frameless
344 functions are not strictly inner than (same .stack but
345 different .code and/or .special address). */
346 inner
= INNER_THAN (l
.stack_addr
, r
.stack_addr
);
349 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_inner (l=");
350 fprint_frame_id (gdb_stdlog
, l
);
351 fprintf_unfiltered (gdb_stdlog
, ",r=");
352 fprint_frame_id (gdb_stdlog
, r
);
353 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", inner
);
359 frame_find_by_id (struct frame_id id
)
361 struct frame_info
*frame
;
363 /* ZERO denotes the null frame, let the caller decide what to do
364 about it. Should it instead return get_current_frame()? */
365 if (!frame_id_p (id
))
368 for (frame
= get_current_frame ();
370 frame
= get_prev_frame (frame
))
372 struct frame_id
this = get_frame_id (frame
);
373 if (frame_id_eq (id
, this))
374 /* An exact match. */
376 if (frame_id_inner (id
, this))
379 /* Either we're not yet gone far enough out along the frame
380 chain (inner(this,id)), or we're comparing frameless functions
381 (same .base, different .func, no test available). Struggle
382 on until we've definitly gone to far. */
388 frame_pc_unwind (struct frame_info
*this_frame
)
390 if (!this_frame
->prev_pc
.p
)
393 if (this_frame
->unwind
== NULL
)
395 = frame_unwind_find_by_frame (this_frame
->next
,
396 &this_frame
->prologue_cache
);
397 if (this_frame
->unwind
->prev_pc
!= NULL
)
398 /* A per-frame unwinder, prefer it. */
399 pc
= this_frame
->unwind
->prev_pc (this_frame
->next
,
400 &this_frame
->prologue_cache
);
401 else if (gdbarch_unwind_pc_p (current_gdbarch
))
403 /* The right way. The `pure' way. The one true way. This
404 method depends solely on the register-unwind code to
405 determine the value of registers in THIS frame, and hence
406 the value of this frame's PC (resume address). A typical
407 implementation is no more than:
409 frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
410 return extract_unsigned_integer (buf, size of ISA_PC_REGNUM);
412 Note: this method is very heavily dependent on a correct
413 register-unwind implementation, it pays to fix that
414 method first; this method is frame type agnostic, since
415 it only deals with register values, it works with any
416 frame. This is all in stark contrast to the old
417 FRAME_SAVED_PC which would try to directly handle all the
418 different ways that a PC could be unwound. */
419 pc
= gdbarch_unwind_pc (current_gdbarch
, this_frame
);
422 internal_error (__FILE__
, __LINE__
, "No unwind_pc method");
423 this_frame
->prev_pc
.value
= pc
;
424 this_frame
->prev_pc
.p
= 1;
426 fprintf_unfiltered (gdb_stdlog
,
427 "{ frame_pc_unwind (this_frame=%d) -> 0x%s }\n",
429 paddr_nz (this_frame
->prev_pc
.value
));
431 return this_frame
->prev_pc
.value
;
435 frame_func_unwind (struct frame_info
*fi
)
437 if (!fi
->prev_func
.p
)
439 /* Make certain that this, and not the adjacent, function is
441 CORE_ADDR addr_in_block
= frame_unwind_address_in_block (fi
);
443 fi
->prev_func
.addr
= get_pc_function_start (addr_in_block
);
445 fprintf_unfiltered (gdb_stdlog
,
446 "{ frame_func_unwind (fi=%d) -> 0x%s }\n",
447 fi
->level
, paddr_nz (fi
->prev_func
.addr
));
449 return fi
->prev_func
.addr
;
453 get_frame_func (struct frame_info
*fi
)
455 return frame_func_unwind (fi
->next
);
459 do_frame_register_read (void *src
, int regnum
, void *buf
)
461 frame_register_read (src
, regnum
, buf
);
466 frame_save_as_regcache (struct frame_info
*this_frame
)
468 struct regcache
*regcache
= regcache_xmalloc (current_gdbarch
);
469 struct cleanup
*cleanups
= make_cleanup_regcache_xfree (regcache
);
470 regcache_save (regcache
, do_frame_register_read
, this_frame
);
471 discard_cleanups (cleanups
);
476 frame_pop (struct frame_info
*this_frame
)
478 /* Make a copy of all the register values unwound from this frame.
479 Save them in a scratch buffer so that there isn't a race between
480 trying to extract the old values from the current_regcache while
481 at the same time writing new values into that same cache. */
482 struct regcache
*scratch
483 = frame_save_as_regcache (get_prev_frame_1 (this_frame
));
484 struct cleanup
*cleanups
= make_cleanup_regcache_xfree (scratch
);
486 /* FIXME: cagney/2003-03-16: It should be possible to tell the
487 target's register cache that it is about to be hit with a burst
488 register transfer and that the sequence of register writes should
489 be batched. The pair target_prepare_to_store() and
490 target_store_registers() kind of suggest this functionality.
491 Unfortunately, they don't implement it. Their lack of a formal
492 definition can lead to targets writing back bogus values
493 (arguably a bug in the target code mind). */
494 /* Now copy those saved registers into the current regcache.
495 Here, regcache_cpy() calls regcache_restore(). */
496 regcache_cpy (current_regcache
, scratch
);
497 do_cleanups (cleanups
);
499 /* We've made right mess of GDB's local state, just discard
501 flush_cached_frames ();
505 frame_register_unwind (struct frame_info
*frame
, int regnum
,
506 int *optimizedp
, enum lval_type
*lvalp
,
507 CORE_ADDR
*addrp
, int *realnump
, void *bufferp
)
509 struct frame_unwind_cache
*cache
;
513 fprintf_unfiltered (gdb_stdlog
, "\
514 { frame_register_unwind (frame=%d,regnum=%d(%s),...) ",
515 frame
->level
, regnum
,
516 frame_map_regnum_to_name (frame
, regnum
));
519 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
520 that the value proper does not need to be fetched. */
521 gdb_assert (optimizedp
!= NULL
);
522 gdb_assert (lvalp
!= NULL
);
523 gdb_assert (addrp
!= NULL
);
524 gdb_assert (realnump
!= NULL
);
525 /* gdb_assert (bufferp != NULL); */
527 /* NOTE: cagney/2002-11-27: A program trying to unwind a NULL frame
528 is broken. There is always a frame. If there, for some reason,
529 isn't a frame, there is some pretty busted code as it should have
530 detected the problem before calling here. */
531 gdb_assert (frame
!= NULL
);
533 /* Find the unwinder. */
534 if (frame
->unwind
== NULL
)
535 frame
->unwind
= frame_unwind_find_by_frame (frame
->next
,
536 &frame
->prologue_cache
);
538 /* Ask this frame to unwind its register. See comment in
539 "frame-unwind.h" for why NEXT frame and this unwind cache are
541 frame
->unwind
->prev_register (frame
->next
, &frame
->prologue_cache
, regnum
,
542 optimizedp
, lvalp
, addrp
, realnump
, bufferp
);
546 fprintf_unfiltered (gdb_stdlog
, "->");
547 fprintf_unfiltered (gdb_stdlog
, " *optimizedp=%d", (*optimizedp
));
548 fprintf_unfiltered (gdb_stdlog
, " *lvalp=%d", (int) (*lvalp
));
549 fprintf_unfiltered (gdb_stdlog
, " *addrp=0x%s", paddr_nz ((*addrp
)));
550 fprintf_unfiltered (gdb_stdlog
, " *bufferp=");
552 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
556 const unsigned char *buf
= bufferp
;
557 fprintf_unfiltered (gdb_stdlog
, "[");
558 for (i
= 0; i
< register_size (current_gdbarch
, regnum
); i
++)
559 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
560 fprintf_unfiltered (gdb_stdlog
, "]");
562 fprintf_unfiltered (gdb_stdlog
, " }\n");
567 frame_register (struct frame_info
*frame
, int regnum
,
568 int *optimizedp
, enum lval_type
*lvalp
,
569 CORE_ADDR
*addrp
, int *realnump
, void *bufferp
)
571 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
572 that the value proper does not need to be fetched. */
573 gdb_assert (optimizedp
!= NULL
);
574 gdb_assert (lvalp
!= NULL
);
575 gdb_assert (addrp
!= NULL
);
576 gdb_assert (realnump
!= NULL
);
577 /* gdb_assert (bufferp != NULL); */
579 /* Obtain the register value by unwinding the register from the next
580 (more inner frame). */
581 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
582 frame_register_unwind (frame
->next
, regnum
, optimizedp
, lvalp
, addrp
,
587 frame_unwind_register (struct frame_info
*frame
, int regnum
, void *buf
)
593 frame_register_unwind (frame
, regnum
, &optimized
, &lval
, &addr
,
598 get_frame_register (struct frame_info
*frame
,
599 int regnum
, void *buf
)
601 frame_unwind_register (frame
->next
, regnum
, buf
);
605 frame_unwind_register_signed (struct frame_info
*frame
, int regnum
)
607 char buf
[MAX_REGISTER_SIZE
];
608 frame_unwind_register (frame
, regnum
, buf
);
609 return extract_signed_integer (buf
, register_size (get_frame_arch (frame
),
614 get_frame_register_signed (struct frame_info
*frame
, int regnum
)
616 return frame_unwind_register_signed (frame
->next
, regnum
);
620 frame_unwind_register_unsigned (struct frame_info
*frame
, int regnum
)
622 char buf
[MAX_REGISTER_SIZE
];
623 frame_unwind_register (frame
, regnum
, buf
);
624 return extract_unsigned_integer (buf
, register_size (get_frame_arch (frame
),
629 get_frame_register_unsigned (struct frame_info
*frame
, int regnum
)
631 return frame_unwind_register_unsigned (frame
->next
, regnum
);
635 frame_unwind_unsigned_register (struct frame_info
*frame
, int regnum
,
638 char buf
[MAX_REGISTER_SIZE
];
639 frame_unwind_register (frame
, regnum
, buf
);
640 (*val
) = extract_unsigned_integer (buf
,
641 register_size (get_frame_arch (frame
),
646 put_frame_register (struct frame_info
*frame
, int regnum
, const void *buf
)
648 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
653 frame_register (frame
, regnum
, &optim
, &lval
, &addr
, &realnum
, NULL
);
655 error ("Attempt to assign to a value that was optimized out.");
660 /* FIXME: write_memory doesn't yet take constant buffers.
662 char tmp
[MAX_REGISTER_SIZE
];
663 memcpy (tmp
, buf
, register_size (gdbarch
, regnum
));
664 write_memory (addr
, tmp
, register_size (gdbarch
, regnum
));
668 regcache_cooked_write (current_regcache
, realnum
, buf
);
671 error ("Attempt to assign to an unmodifiable value.");
675 /* frame_register_read ()
677 Find and return the value of REGNUM for the specified stack frame.
678 The number of bytes copied is REGISTER_SIZE (REGNUM).
680 Returns 0 if the register value could not be found. */
683 frame_register_read (struct frame_info
*frame
, int regnum
, void *myaddr
)
689 frame_register (frame
, regnum
, &optimized
, &lval
, &addr
, &realnum
, myaddr
);
691 /* FIXME: cagney/2002-05-15: This test is just bogus.
693 It indicates that the target failed to supply a value for a
694 register because it was "not available" at this time. Problem
695 is, the target still has the register and so get saved_register()
696 may be returning a value saved on the stack. */
698 if (register_cached (regnum
) < 0)
699 return 0; /* register value not available */
705 /* Map between a frame register number and its name. A frame register
706 space is a superset of the cooked register space --- it also
707 includes builtin registers. */
710 frame_map_name_to_regnum (struct frame_info
*frame
, const char *name
, int len
)
712 return user_reg_map_name_to_regnum (get_frame_arch (frame
), name
, len
);
716 frame_map_regnum_to_name (struct frame_info
*frame
, int regnum
)
718 return user_reg_map_regnum_to_name (get_frame_arch (frame
), regnum
);
721 /* Create a sentinel frame. */
723 static struct frame_info
*
724 create_sentinel_frame (struct regcache
*regcache
)
726 struct frame_info
*frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
728 /* Explicitly initialize the sentinel frame's cache. Provide it
729 with the underlying regcache. In the future additional
730 information, such as the frame's thread will be added. */
731 frame
->prologue_cache
= sentinel_frame_cache (regcache
);
732 /* For the moment there is only one sentinel frame implementation. */
733 frame
->unwind
= sentinel_frame_unwind
;
734 /* Link this frame back to itself. The frame is self referential
735 (the unwound PC is the same as the pc), so make it so. */
737 /* Make the sentinel frame's ID valid, but invalid. That way all
738 comparisons with it should fail. */
739 frame
->this_id
.p
= 1;
740 frame
->this_id
.value
= null_frame_id
;
743 fprintf_unfiltered (gdb_stdlog
, "{ create_sentinel_frame (...) -> ");
744 fprint_frame (gdb_stdlog
, frame
);
745 fprintf_unfiltered (gdb_stdlog
, " }\n");
750 /* Info about the innermost stack frame (contents of FP register) */
752 static struct frame_info
*current_frame
;
754 /* Cache for frame addresses already read by gdb. Valid only while
755 inferior is stopped. Control variables for the frame cache should
756 be local to this module. */
758 static struct obstack frame_cache_obstack
;
761 frame_obstack_zalloc (unsigned long size
)
763 void *data
= obstack_alloc (&frame_cache_obstack
, size
);
764 memset (data
, 0, size
);
768 /* Return the innermost (currently executing) stack frame. This is
769 split into two functions. The function unwind_to_current_frame()
770 is wrapped in catch exceptions so that, even when the unwind of the
771 sentinel frame fails, the function still returns a stack frame. */
774 unwind_to_current_frame (struct ui_out
*ui_out
, void *args
)
776 struct frame_info
*frame
= get_prev_frame (args
);
777 /* A sentinel frame can fail to unwind, e.g., because its PC value
778 lands in somewhere like start. */
781 current_frame
= frame
;
786 get_current_frame (void)
788 /* First check, and report, the lack of registers. Having GDB
789 report "No stack!" or "No memory" when the target doesn't even
790 have registers is very confusing. Besides, "printcmd.exp"
791 explicitly checks that ``print $pc'' with no registers prints "No
793 if (!target_has_registers
)
794 error ("No registers.");
795 if (!target_has_stack
)
797 if (!target_has_memory
)
798 error ("No memory.");
799 if (current_frame
== NULL
)
801 struct frame_info
*sentinel_frame
=
802 create_sentinel_frame (current_regcache
);
803 if (catch_exceptions (uiout
, unwind_to_current_frame
, sentinel_frame
,
804 NULL
, RETURN_MASK_ERROR
) != 0)
806 /* Oops! Fake a current frame? Is this useful? It has a PC
807 of zero, for instance. */
808 current_frame
= sentinel_frame
;
811 return current_frame
;
814 /* The "selected" stack frame is used by default for local and arg
815 access. May be zero, for no selected frame. */
817 struct frame_info
*deprecated_selected_frame
;
819 /* Return the selected frame. Always non-NULL (unless there isn't an
820 inferior sufficient for creating a frame) in which case an error is
824 get_selected_frame (const char *message
)
826 if (deprecated_selected_frame
== NULL
)
828 if (message
!= NULL
&& (!target_has_registers
830 || !target_has_memory
))
831 error ("%s", message
);
832 /* Hey! Don't trust this. It should really be re-finding the
833 last selected frame of the currently selected thread. This,
834 though, is better than nothing. */
835 select_frame (get_current_frame ());
837 /* There is always a frame. */
838 gdb_assert (deprecated_selected_frame
!= NULL
);
839 return deprecated_selected_frame
;
842 /* This is a variant of get_selected_frame() which can be called when
843 the inferior does not have a frame; in that case it will return
844 NULL instead of calling error(). */
847 deprecated_safe_get_selected_frame (void)
849 if (!target_has_registers
|| !target_has_stack
|| !target_has_memory
)
851 return get_selected_frame (NULL
);
854 /* Select frame FI (or NULL - to invalidate the current frame). */
857 select_frame (struct frame_info
*fi
)
861 deprecated_selected_frame
= fi
;
862 /* NOTE: cagney/2002-05-04: FI can be NULL. This occurs when the
863 frame is being invalidated. */
864 if (deprecated_selected_frame_level_changed_hook
)
865 deprecated_selected_frame_level_changed_hook (frame_relative_level (fi
));
867 /* FIXME: kseitz/2002-08-28: It would be nice to call
868 selected_frame_level_changed_event() right here, but due to limitations
869 in the current interfaces, we would end up flooding UIs with events
870 because select_frame() is used extensively internally.
872 Once we have frame-parameterized frame (and frame-related) commands,
873 the event notification can be moved here, since this function will only
874 be called when the user's selected frame is being changed. */
876 /* Ensure that symbols for this frame are read in. Also, determine the
877 source language of this frame, and switch to it if desired. */
880 /* We retrieve the frame's symtab by using the frame PC. However
881 we cannot use the frame PC as-is, because it usually points to
882 the instruction following the "call", which is sometimes the
883 first instruction of another function. So we rely on
884 get_frame_address_in_block() which provides us with a PC which
885 is guaranteed to be inside the frame's code block. */
886 s
= find_pc_symtab (get_frame_address_in_block (fi
));
888 && s
->language
!= current_language
->la_language
889 && s
->language
!= language_unknown
890 && language_mode
== language_mode_auto
)
892 set_language (s
->language
);
897 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
898 Always returns a non-NULL value. */
901 create_new_frame (CORE_ADDR addr
, CORE_ADDR pc
)
903 struct frame_info
*fi
;
907 fprintf_unfiltered (gdb_stdlog
,
908 "{ create_new_frame (addr=0x%s, pc=0x%s) ",
909 paddr_nz (addr
), paddr_nz (pc
));
912 fi
= frame_obstack_zalloc (sizeof (struct frame_info
));
914 fi
->next
= create_sentinel_frame (current_regcache
);
916 /* Select/initialize both the unwind function and the frame's type
918 fi
->unwind
= frame_unwind_find_by_frame (fi
->next
, &fi
->prologue_cache
);
921 deprecated_update_frame_base_hack (fi
, addr
);
922 deprecated_update_frame_pc_hack (fi
, pc
);
926 fprintf_unfiltered (gdb_stdlog
, "-> ");
927 fprint_frame (gdb_stdlog
, fi
);
928 fprintf_unfiltered (gdb_stdlog
, " }\n");
934 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
935 innermost frame). Be careful to not fall off the bottom of the
936 frame chain and onto the sentinel frame. */
939 get_next_frame (struct frame_info
*this_frame
)
941 if (this_frame
->level
> 0)
942 return this_frame
->next
;
947 /* Observer for the target_changed event. */
950 frame_observer_target_changed (struct target_ops
*target
)
952 flush_cached_frames ();
955 /* Flush the entire frame cache. */
958 flush_cached_frames (void)
960 /* Since we can't really be sure what the first object allocated was */
961 obstack_free (&frame_cache_obstack
, 0);
962 obstack_init (&frame_cache_obstack
);
964 current_frame
= NULL
; /* Invalidate cache */
966 annotate_frames_invalid ();
968 fprintf_unfiltered (gdb_stdlog
, "{ flush_cached_frames () }\n");
971 /* Flush the frame cache, and start a new one if necessary. */
974 reinit_frame_cache (void)
976 flush_cached_frames ();
978 /* FIXME: The inferior_ptid test is wrong if there is a corefile. */
979 if (PIDGET (inferior_ptid
) != 0)
981 select_frame (get_current_frame ());
985 /* Return a "struct frame_info" corresponding to the frame that called
986 THIS_FRAME. Returns NULL if there is no such frame.
988 Unlike get_prev_frame, this function always tries to unwind the
991 static struct frame_info
*
992 get_prev_frame_1 (struct frame_info
*this_frame
)
994 struct frame_info
*prev_frame
;
995 struct frame_id this_id
;
997 gdb_assert (this_frame
!= NULL
);
1001 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame_1 (this_frame=");
1002 if (this_frame
!= NULL
)
1003 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1005 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1006 fprintf_unfiltered (gdb_stdlog
, ") ");
1009 /* Only try to do the unwind once. */
1010 if (this_frame
->prev_p
)
1014 fprintf_unfiltered (gdb_stdlog
, "-> ");
1015 fprint_frame (gdb_stdlog
, this_frame
->prev
);
1016 fprintf_unfiltered (gdb_stdlog
, " // cached \n");
1018 return this_frame
->prev
;
1020 this_frame
->prev_p
= 1;
1022 /* Check that this frame's ID was valid. If it wasn't, don't try to
1023 unwind to the prev frame. Be careful to not apply this test to
1024 the sentinel frame. */
1025 this_id
= get_frame_id (this_frame
);
1026 if (this_frame
->level
>= 0 && !frame_id_p (this_id
))
1030 fprintf_unfiltered (gdb_stdlog
, "-> ");
1031 fprint_frame (gdb_stdlog
, NULL
);
1032 fprintf_unfiltered (gdb_stdlog
, " // this ID is NULL }\n");
1037 /* Check that this frame's ID isn't inner to (younger, below, next)
1038 the next frame. This happens when a frame unwind goes backwards.
1039 Exclude signal trampolines (due to sigaltstack the frame ID can
1040 go backwards) and sentinel frames (the test is meaningless). */
1041 if (this_frame
->next
->level
>= 0
1042 && this_frame
->next
->unwind
->type
!= SIGTRAMP_FRAME
1043 && frame_id_inner (this_id
, get_frame_id (this_frame
->next
)))
1044 error ("Previous frame inner to this frame (corrupt stack?)");
1046 /* Check that this and the next frame are not identical. If they
1047 are, there is most likely a stack cycle. As with the inner-than
1048 test above, avoid comparing the inner-most and sentinel frames. */
1049 if (this_frame
->level
> 0
1050 && frame_id_eq (this_id
, get_frame_id (this_frame
->next
)))
1051 error ("Previous frame identical to this frame (corrupt stack?)");
1053 /* Allocate the new frame but do not wire it in to the frame chain.
1054 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
1055 frame->next to pull some fancy tricks (of course such code is, by
1056 definition, recursive). Try to prevent it.
1058 There is no reason to worry about memory leaks, should the
1059 remainder of the function fail. The allocated memory will be
1060 quickly reclaimed when the frame cache is flushed, and the `we've
1061 been here before' check above will stop repeated memory
1062 allocation calls. */
1063 prev_frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1064 prev_frame
->level
= this_frame
->level
+ 1;
1066 /* Don't yet compute ->unwind (and hence ->type). It is computed
1067 on-demand in get_frame_type, frame_register_unwind, and
1070 /* Don't yet compute the frame's ID. It is computed on-demand by
1073 /* The unwound frame ID is validate at the start of this function,
1074 as part of the logic to decide if that frame should be further
1075 unwound, and not here while the prev frame is being created.
1076 Doing this makes it possible for the user to examine a frame that
1077 has an invalid frame ID.
1079 Some very old VAX code noted: [...] For the sake of argument,
1080 suppose that the stack is somewhat trashed (which is one reason
1081 that "info frame" exists). So, return 0 (indicating we don't
1082 know the address of the arglist) if we don't know what frame this
1086 this_frame
->prev
= prev_frame
;
1087 prev_frame
->next
= this_frame
;
1091 fprintf_unfiltered (gdb_stdlog
, "-> ");
1092 fprint_frame (gdb_stdlog
, prev_frame
);
1093 fprintf_unfiltered (gdb_stdlog
, " }\n");
1099 /* Debug routine to print a NULL frame being returned. */
1102 frame_debug_got_null_frame (struct ui_file
*file
,
1103 struct frame_info
*this_frame
,
1108 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame (this_frame=");
1109 if (this_frame
!= NULL
)
1110 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1112 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1113 fprintf_unfiltered (gdb_stdlog
, ") -> // %s}\n", reason
);
1117 /* Is this (non-sentinel) frame in the "main"() function? */
1120 inside_main_func (struct frame_info
*this_frame
)
1122 struct minimal_symbol
*msymbol
;
1125 if (symfile_objfile
== 0)
1127 msymbol
= lookup_minimal_symbol (main_name (), NULL
, symfile_objfile
);
1128 if (msymbol
== NULL
)
1130 /* Make certain that the code, and not descriptor, address is
1132 maddr
= gdbarch_convert_from_func_ptr_addr (current_gdbarch
,
1133 SYMBOL_VALUE_ADDRESS (msymbol
),
1135 return maddr
== get_frame_func (this_frame
);
1138 /* Return a structure containing various interesting information about
1139 the frame that called THIS_FRAME. Returns NULL if there is entier
1140 no such frame or the frame fails any of a set of target-independent
1141 condition that should terminate the frame chain (e.g., as unwinding
1144 This function should not contain target-dependent tests, such as
1145 checking whether the program-counter is zero. */
1148 get_prev_frame (struct frame_info
*this_frame
)
1150 struct frame_info
*prev_frame
;
1152 /* Return the inner-most frame, when the caller passes in NULL. */
1153 /* NOTE: cagney/2002-11-09: Not sure how this would happen. The
1154 caller should have previously obtained a valid frame using
1155 get_selected_frame() and then called this code - only possibility
1156 I can think of is code behaving badly.
1158 NOTE: cagney/2003-01-10: Talk about code behaving badly. Check
1159 block_innermost_frame(). It does the sequence: frame = NULL;
1160 while (1) { frame = get_prev_frame (frame); .... }. Ulgh! Why
1161 it couldn't be written better, I don't know.
1163 NOTE: cagney/2003-01-11: I suspect what is happening in
1164 block_innermost_frame() is, when the target has no state
1165 (registers, memory, ...), it is still calling this function. The
1166 assumption being that this function will return NULL indicating
1167 that a frame isn't possible, rather than checking that the target
1168 has state and then calling get_current_frame() and
1169 get_prev_frame(). This is a guess mind. */
1170 if (this_frame
== NULL
)
1172 /* NOTE: cagney/2002-11-09: There was a code segment here that
1173 would error out when CURRENT_FRAME was NULL. The comment
1174 that went with it made the claim ...
1176 ``This screws value_of_variable, which just wants a nice
1177 clean NULL return from block_innermost_frame if there are no
1178 frames. I don't think I've ever seen this message happen
1179 otherwise. And returning NULL here is a perfectly legitimate
1182 Per the above, this code shouldn't even be called with a NULL
1184 frame_debug_got_null_frame (gdb_stdlog
, this_frame
, "this_frame NULL");
1185 return current_frame
;
1188 /* There is always a frame. If this assertion fails, suspect that
1189 something should be calling get_selected_frame() or
1190 get_current_frame(). */
1191 gdb_assert (this_frame
!= NULL
);
1193 if (this_frame
->level
>= 0
1194 && !backtrace_past_main
1195 && inside_main_func (this_frame
))
1196 /* Don't unwind past main(). Note, this is done _before_ the
1197 frame has been marked as previously unwound. That way if the
1198 user later decides to enable unwinds past main(), that will
1199 automatically happen. */
1201 frame_debug_got_null_frame (gdb_stdlog
, this_frame
, "inside main func");
1205 if (this_frame
->level
> backtrace_limit
)
1207 error ("Backtrace limit of %d exceeded", backtrace_limit
);
1210 /* If we're already inside the entry function for the main objfile,
1211 then it isn't valid. Don't apply this test to a dummy frame -
1212 dummy frame PCs typically land in the entry func. Don't apply
1213 this test to the sentinel frame. Sentinel frames should always
1214 be allowed to unwind. */
1215 /* NOTE: cagney/2003-02-25: Don't enable until someone has found
1216 hard evidence that this is needed. */
1217 /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() -
1218 wasn't checking for "main" in the minimal symbols. With that
1219 fixed asm-source tests now stop in "main" instead of halting the
1220 backtrace in weird and wonderful ways somewhere inside the entry
1221 file. Suspect that tests for inside the entry file/func were
1222 added to work around that (now fixed) case. */
1223 /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
1224 suggested having the inside_entry_func test use the
1225 inside_main_func() msymbol trick (along with entry_point_address()
1226 I guess) to determine the address range of the start function.
1227 That should provide a far better stopper than the current
1229 /* NOTE: cagney/2003-07-15: Need to add a "set backtrace
1230 beyond-entry-func" command so that this can be selectively
1234 && backtrace_beyond_entry_func
1236 && this_frame
->unwind
->type
!= DUMMY_FRAME
&& this_frame
->level
>= 0
1237 && inside_entry_func (this_frame
))
1239 frame_debug_got_null_frame (gdb_stdlog
, this_frame
, "inside entry func");
1243 return get_prev_frame_1 (this_frame
);
1247 get_frame_pc (struct frame_info
*frame
)
1249 gdb_assert (frame
->next
!= NULL
);
1250 return frame_pc_unwind (frame
->next
);
1253 /* Return an address of that falls within the frame's code block. */
1256 frame_unwind_address_in_block (struct frame_info
*next_frame
)
1258 /* A draft address. */
1259 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
1261 /* If THIS frame is not inner most (i.e., NEXT isn't the sentinel),
1262 and NEXT is `normal' (i.e., not a sigtramp, dummy, ....) THIS
1263 frame's PC ends up pointing at the instruction fallowing the
1264 "call". Adjust that PC value so that it falls on the call
1265 instruction (which, hopefully, falls within THIS frame's code
1266 block. So far it's proved to be a very good approximation. See
1267 get_frame_type() for why ->type can't be used. */
1268 if (next_frame
->level
>= 0
1269 && get_frame_type (next_frame
) == NORMAL_FRAME
)
1275 get_frame_address_in_block (struct frame_info
*this_frame
)
1277 return frame_unwind_address_in_block (this_frame
->next
);
1281 pc_notcurrent (struct frame_info
*frame
)
1283 /* If FRAME is not the innermost frame, that normally means that
1284 FRAME->pc points at the return instruction (which is *after* the
1285 call instruction), and we want to get the line containing the
1286 call (because the call is where the user thinks the program is).
1287 However, if the next frame is either a SIGTRAMP_FRAME or a
1288 DUMMY_FRAME, then the next frame will contain a saved interrupt
1289 PC and such a PC indicates the current (rather than next)
1290 instruction/line, consequently, for such cases, want to get the
1291 line containing fi->pc. */
1292 struct frame_info
*next
= get_next_frame (frame
);
1293 int notcurrent
= (next
!= NULL
&& get_frame_type (next
) == NORMAL_FRAME
);
1298 find_frame_sal (struct frame_info
*frame
, struct symtab_and_line
*sal
)
1300 (*sal
) = find_pc_line (get_frame_pc (frame
), pc_notcurrent (frame
));
1303 /* Per "frame.h", return the ``address'' of the frame. Code should
1304 really be using get_frame_id(). */
1306 get_frame_base (struct frame_info
*fi
)
1308 return get_frame_id (fi
).stack_addr
;
1311 /* High-level offsets into the frame. Used by the debug info. */
1314 get_frame_base_address (struct frame_info
*fi
)
1316 if (get_frame_type (fi
) != NORMAL_FRAME
)
1318 if (fi
->base
== NULL
)
1319 fi
->base
= frame_base_find_by_frame (fi
->next
);
1320 /* Sneaky: If the low-level unwind and high-level base code share a
1321 common unwinder, let them share the prologue cache. */
1322 if (fi
->base
->unwind
== fi
->unwind
)
1323 return fi
->base
->this_base (fi
->next
, &fi
->prologue_cache
);
1324 return fi
->base
->this_base (fi
->next
, &fi
->base_cache
);
1328 get_frame_locals_address (struct frame_info
*fi
)
1331 if (get_frame_type (fi
) != NORMAL_FRAME
)
1333 /* If there isn't a frame address method, find it. */
1334 if (fi
->base
== NULL
)
1335 fi
->base
= frame_base_find_by_frame (fi
->next
);
1336 /* Sneaky: If the low-level unwind and high-level base code share a
1337 common unwinder, let them share the prologue cache. */
1338 if (fi
->base
->unwind
== fi
->unwind
)
1339 cache
= &fi
->prologue_cache
;
1341 cache
= &fi
->base_cache
;
1342 return fi
->base
->this_locals (fi
->next
, cache
);
1346 get_frame_args_address (struct frame_info
*fi
)
1349 if (get_frame_type (fi
) != NORMAL_FRAME
)
1351 /* If there isn't a frame address method, find it. */
1352 if (fi
->base
== NULL
)
1353 fi
->base
= frame_base_find_by_frame (fi
->next
);
1354 /* Sneaky: If the low-level unwind and high-level base code share a
1355 common unwinder, let them share the prologue cache. */
1356 if (fi
->base
->unwind
== fi
->unwind
)
1357 cache
= &fi
->prologue_cache
;
1359 cache
= &fi
->base_cache
;
1360 return fi
->base
->this_args (fi
->next
, cache
);
1363 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
1364 or -1 for a NULL frame. */
1367 frame_relative_level (struct frame_info
*fi
)
1376 get_frame_type (struct frame_info
*frame
)
1378 if (frame
->unwind
== NULL
)
1379 /* Initialize the frame's unwinder because that's what
1380 provides the frame's type. */
1381 frame
->unwind
= frame_unwind_find_by_frame (frame
->next
,
1382 &frame
->prologue_cache
);
1383 return frame
->unwind
->type
;
1387 deprecated_update_frame_pc_hack (struct frame_info
*frame
, CORE_ADDR pc
)
1390 fprintf_unfiltered (gdb_stdlog
,
1391 "{ deprecated_update_frame_pc_hack (frame=%d,pc=0x%s) }\n",
1392 frame
->level
, paddr_nz (pc
));
1393 /* NOTE: cagney/2003-03-11: Some architectures (e.g., Arm) are
1394 maintaining a locally allocated frame object. Since such frames
1395 are not in the frame chain, it isn't possible to assume that the
1396 frame has a next. Sigh. */
1397 if (frame
->next
!= NULL
)
1399 /* While we're at it, update this frame's cached PC value, found
1400 in the next frame. Oh for the day when "struct frame_info"
1401 is opaque and this hack on hack can just go away. */
1402 frame
->next
->prev_pc
.value
= pc
;
1403 frame
->next
->prev_pc
.p
= 1;
1408 deprecated_update_frame_base_hack (struct frame_info
*frame
, CORE_ADDR base
)
1411 fprintf_unfiltered (gdb_stdlog
,
1412 "{ deprecated_update_frame_base_hack (frame=%d,base=0x%s) }\n",
1413 frame
->level
, paddr_nz (base
));
1414 /* See comment in "frame.h". */
1415 frame
->this_id
.value
.stack_addr
= base
;
1418 /* Memory access methods. */
1421 get_frame_memory (struct frame_info
*this_frame
, CORE_ADDR addr
, void *buf
,
1424 read_memory (addr
, buf
, len
);
1428 get_frame_memory_signed (struct frame_info
*this_frame
, CORE_ADDR addr
,
1431 return read_memory_integer (addr
, len
);
1435 get_frame_memory_unsigned (struct frame_info
*this_frame
, CORE_ADDR addr
,
1438 return read_memory_unsigned_integer (addr
, len
);
1442 safe_frame_unwind_memory (struct frame_info
*this_frame
,
1443 CORE_ADDR addr
, void *buf
, int len
)
1445 /* NOTE: deprecated_read_memory_nobpt returns zero on success! */
1446 return !deprecated_read_memory_nobpt (addr
, buf
, len
);
1449 /* Architecture method. */
1452 get_frame_arch (struct frame_info
*this_frame
)
1454 return current_gdbarch
;
1457 /* Stack pointer methods. */
1460 get_frame_sp (struct frame_info
*this_frame
)
1462 return frame_sp_unwind (this_frame
->next
);
1466 frame_sp_unwind (struct frame_info
*next_frame
)
1468 /* Normality - an architecture that provides a way of obtaining any
1469 frame inner-most address. */
1470 if (gdbarch_unwind_sp_p (current_gdbarch
))
1471 return gdbarch_unwind_sp (current_gdbarch
, next_frame
);
1472 /* Things are looking grim. If it's the inner-most frame and there
1473 is a TARGET_READ_SP, then that can be used. */
1474 if (next_frame
->level
< 0 && TARGET_READ_SP_P ())
1475 return TARGET_READ_SP ();
1476 /* Now things are really are grim. Hope that the value returned by
1477 the SP_REGNUM register is meaningful. */
1481 frame_unwind_unsigned_register (next_frame
, SP_REGNUM
, &sp
);
1484 internal_error (__FILE__
, __LINE__
, "Missing unwind SP method");
1487 extern initialize_file_ftype _initialize_frame
; /* -Wmissing-prototypes */
1489 static struct cmd_list_element
*set_backtrace_cmdlist
;
1490 static struct cmd_list_element
*show_backtrace_cmdlist
;
1493 set_backtrace_cmd (char *args
, int from_tty
)
1495 help_list (set_backtrace_cmdlist
, "set backtrace ", -1, gdb_stdout
);
1499 show_backtrace_cmd (char *args
, int from_tty
)
1501 cmd_show_list (show_backtrace_cmdlist
, from_tty
, "");
1505 _initialize_frame (void)
1507 obstack_init (&frame_cache_obstack
);
1509 observer_attach_target_changed (frame_observer_target_changed
);
1511 add_prefix_cmd ("backtrace", class_maintenance
, set_backtrace_cmd
, "\
1512 Set backtrace specific variables.\n\
1513 Configure backtrace variables such as the backtrace limit",
1514 &set_backtrace_cmdlist
, "set backtrace ",
1515 0/*allow-unknown*/, &setlist
);
1516 add_prefix_cmd ("backtrace", class_maintenance
, show_backtrace_cmd
, "\
1517 Show backtrace specific variables\n\
1518 Show backtrace variables such as the backtrace limit",
1519 &show_backtrace_cmdlist
, "show backtrace ",
1520 0/*allow-unknown*/, &showlist
);
1522 add_setshow_boolean_cmd ("past-main", class_obscure
,
1523 &backtrace_past_main
, "\
1524 Set whether backtraces should continue past \"main\".", "\
1525 Show whether backtraces should continue past \"main\".", "\
1526 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
1527 the backtrace at \"main\". Set this variable if you need to see the rest\n\
1528 of the stack trace.", "\
1529 Whether backtraces should continue past \"main\" is %s.",
1530 NULL
, NULL
, &set_backtrace_cmdlist
,
1531 &show_backtrace_cmdlist
);
1533 add_setshow_uinteger_cmd ("limit", class_obscure
,
1534 &backtrace_limit
, "\
1535 Set an upper bound on the number of backtrace levels.", "\
1536 Show the upper bound on the number of backtrace levels.", "\
1537 No more than the specified number of frames can be displayed or examined.\n\
1538 Zero is unlimited.", "\
1539 An upper bound on the number of backtrace levels is %s.",
1540 NULL
, NULL
, &set_backtrace_cmdlist
,
1541 &show_backtrace_cmdlist
);
1543 /* Debug this files internals. */
1544 deprecated_add_show_from_set
1545 (add_set_cmd ("frame", class_maintenance
, var_zinteger
,
1546 &frame_debug
, "Set frame debugging.\n\
1547 When non-zero, frame specific internal debugging is enabled.", &setdebuglist
),