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"
44 static struct frame_info *get_prev_frame_1 (struct frame_info *this_frame);
46 /* We keep a cache of stack frames, each of which is a "struct
47 frame_info". The innermost one gets allocated (in
48 wait_for_inferior) each time the inferior stops; current_frame
49 points to it. Additional frames get allocated (in get_prev_frame)
50 as needed, and are chained through the next and prev fields. Any
51 time that the frame cache becomes invalid (most notably when we
52 execute something, but also if we change how we interpret the
53 frames (e.g. "set heuristic-fence-post" in mips-tdep.c, or anything
54 which reads new symbols)), we should call reinit_frame_cache. */
58 /* Level of this frame. The inner-most (youngest) frame is at level
59 0. As you move towards the outer-most (oldest) frame, the level
60 increases. This is a cached value. It could just as easily be
61 computed by counting back from the selected frame to the inner
63 /* NOTE: cagney/2002-04-05: Perhaps a level of ``-1'' should be
64 reserved to indicate a bogus frame - one that has been created
65 just to keep GDB happy (GDB always needs a frame). For the
66 moment leave this as speculation. */
69 /* For each register, address of where it was saved on entry to the
70 frame, or zero if it was not saved on entry to this frame. This
71 includes special registers such as pc and fp saved in special
72 ways in the stack frame. The SP_REGNUM is even more special, the
73 address here is the sp for the previous frame, not the address
74 where the sp was saved. */
75 /* Allocated by frame_saved_regs_zalloc () which is called /
76 initialized by DEPRECATED_FRAME_INIT_SAVED_REGS(). */
77 CORE_ADDR *saved_regs; /*NUM_REGS + NUM_PSEUDO_REGS*/
79 /* Anything extra for this structure that may have been defined in
80 the machine dependent files. */
81 /* Allocated by frame_extra_info_zalloc () which is called /
82 initialized by DEPRECATED_INIT_EXTRA_FRAME_INFO */
83 struct frame_extra_info *extra_info;
85 /* The frame's low-level unwinder and corresponding cache. The
86 low-level unwinder is responsible for unwinding register values
87 for the previous frame. The low-level unwind methods are
88 selected based on the presence, or otherwise, of register unwind
89 information such as CFI. */
91 const struct frame_unwind *unwind;
93 /* Cached copy of the previous frame's resume address. */
99 /* Cached copy of the previous frame's function address. */
106 /* This frame's ID. */
110 struct frame_id value;
113 /* The frame's high-level base methods, and corresponding cache.
114 The high level base methods are selected based on the frame's
116 const struct frame_base *base;
119 /* Pointers to the next (down, inner, younger) and previous (up,
120 outer, older) frame_info's in the frame cache. */
121 struct frame_info *next; /* down, inner, younger */
123 struct frame_info *prev; /* up, outer, older */
126 /* Flag to control debugging. */
128 static int frame_debug;
130 /* Flag to indicate whether backtraces should stop at main et.al. */
132 static int backtrace_past_main;
133 static unsigned int backtrace_limit = UINT_MAX;
136 fprint_field (struct ui_file *file, const char *name, int p, CORE_ADDR addr)
139 fprintf_unfiltered (file, "%s=0x%s", name, paddr_nz (addr));
141 fprintf_unfiltered (file, "!%s", name);
145 fprint_frame_id (struct ui_file *file, struct frame_id id)
147 fprintf_unfiltered (file, "{");
148 fprint_field (file, "stack", id.stack_addr_p, id.stack_addr);
149 fprintf_unfiltered (file, ",");
150 fprint_field (file, "code", id.code_addr_p, id.code_addr);
151 fprintf_unfiltered (file, ",");
152 fprint_field (file, "special", id.special_addr_p, id.special_addr);
153 fprintf_unfiltered (file, "}");
157 fprint_frame_type (struct ui_file *file, enum frame_type type)
162 fprintf_unfiltered (file, "NORMAL_FRAME");
165 fprintf_unfiltered (file, "DUMMY_FRAME");
168 fprintf_unfiltered (file, "SIGTRAMP_FRAME");
171 fprintf_unfiltered (file, "<unknown type>");
177 fprint_frame (struct ui_file *file, struct frame_info *fi)
181 fprintf_unfiltered (file, "<NULL frame>");
184 fprintf_unfiltered (file, "{");
185 fprintf_unfiltered (file, "level=%d", fi->level);
186 fprintf_unfiltered (file, ",");
187 fprintf_unfiltered (file, "type=");
188 if (fi->unwind != NULL)
189 fprint_frame_type (file, fi->unwind->type);
191 fprintf_unfiltered (file, "<unknown>");
192 fprintf_unfiltered (file, ",");
193 fprintf_unfiltered (file, "unwind=");
194 if (fi->unwind != NULL)
195 gdb_print_host_address (fi->unwind, file);
197 fprintf_unfiltered (file, "<unknown>");
198 fprintf_unfiltered (file, ",");
199 fprintf_unfiltered (file, "pc=");
200 if (fi->next != NULL && fi->next->prev_pc.p)
201 fprintf_unfiltered (file, "0x%s", paddr_nz (fi->next->prev_pc.value));
203 fprintf_unfiltered (file, "<unknown>");
204 fprintf_unfiltered (file, ",");
205 fprintf_unfiltered (file, "id=");
207 fprint_frame_id (file, fi->this_id.value);
209 fprintf_unfiltered (file, "<unknown>");
210 fprintf_unfiltered (file, ",");
211 fprintf_unfiltered (file, "func=");
212 if (fi->next != NULL && fi->next->prev_func.p)
213 fprintf_unfiltered (file, "0x%s", paddr_nz (fi->next->prev_func.addr));
215 fprintf_unfiltered (file, "<unknown>");
216 fprintf_unfiltered (file, "}");
219 /* Return a frame uniq ID that can be used to, later, re-find the
223 get_frame_id (struct frame_info *fi)
227 return null_frame_id;
232 fprintf_unfiltered (gdb_stdlog, "{ get_frame_id (fi=%d) ",
234 /* Find the unwinder. */
235 if (fi->unwind == NULL)
236 fi->unwind = frame_unwind_find_by_frame (fi->next,
237 &fi->prologue_cache);
238 /* Find THIS frame's ID. */
239 fi->unwind->this_id (fi->next, &fi->prologue_cache, &fi->this_id.value);
243 fprintf_unfiltered (gdb_stdlog, "-> ");
244 fprint_frame_id (gdb_stdlog, fi->this_id.value);
245 fprintf_unfiltered (gdb_stdlog, " }\n");
248 return fi->this_id.value;
252 frame_unwind_id (struct frame_info *next_frame)
254 /* Use prev_frame, and not get_prev_frame. The latter will truncate
255 the frame chain, leading to this function unintentionally
256 returning a null_frame_id (e.g., when a caller requests the frame
257 ID of "main()"s caller. */
258 return get_frame_id (get_prev_frame_1 (next_frame));
261 const struct frame_id null_frame_id; /* All zeros. */
264 frame_id_build_special (CORE_ADDR stack_addr, CORE_ADDR code_addr,
265 CORE_ADDR special_addr)
267 struct frame_id id = null_frame_id;
268 id.stack_addr = stack_addr;
270 id.code_addr = code_addr;
272 id.special_addr = special_addr;
273 id.special_addr_p = 1;
278 frame_id_build (CORE_ADDR stack_addr, CORE_ADDR code_addr)
280 struct frame_id id = null_frame_id;
281 id.stack_addr = stack_addr;
283 id.code_addr = code_addr;
289 frame_id_build_wild (CORE_ADDR stack_addr)
291 struct frame_id id = null_frame_id;
292 id.stack_addr = stack_addr;
298 frame_id_p (struct frame_id l)
301 /* The frame is valid iff it has a valid stack address. */
305 fprintf_unfiltered (gdb_stdlog, "{ frame_id_p (l=");
306 fprint_frame_id (gdb_stdlog, l);
307 fprintf_unfiltered (gdb_stdlog, ") -> %d }\n", p);
313 frame_id_eq (struct frame_id l, struct frame_id r)
316 if (!l.stack_addr_p || !r.stack_addr_p)
317 /* Like a NaN, if either ID is invalid, the result is false.
318 Note that a frame ID is invalid iff it is the null frame ID. */
320 else if (l.stack_addr != r.stack_addr)
321 /* If .stack addresses are different, the frames are different. */
323 else if (!l.code_addr_p || !r.code_addr_p)
324 /* An invalid code addr is a wild card, always succeed. */
326 else if (l.code_addr != r.code_addr)
327 /* If .code addresses are different, the frames are different. */
329 else if (!l.special_addr_p || !r.special_addr_p)
330 /* An invalid special addr is a wild card (or unused), always succeed. */
332 else if (l.special_addr == r.special_addr)
333 /* Frames are equal. */
340 fprintf_unfiltered (gdb_stdlog, "{ frame_id_eq (l=");
341 fprint_frame_id (gdb_stdlog, l);
342 fprintf_unfiltered (gdb_stdlog, ",r=");
343 fprint_frame_id (gdb_stdlog, r);
344 fprintf_unfiltered (gdb_stdlog, ") -> %d }\n", eq);
350 frame_id_inner (struct frame_id l, struct frame_id r)
353 if (!l.stack_addr_p || !r.stack_addr_p)
354 /* Like NaN, any operation involving an invalid ID always fails. */
357 /* Only return non-zero when strictly inner than. Note that, per
358 comment in "frame.h", there is some fuzz here. Frameless
359 functions are not strictly inner than (same .stack but
360 different .code and/or .special address). */
361 inner = INNER_THAN (l.stack_addr, r.stack_addr);
364 fprintf_unfiltered (gdb_stdlog, "{ frame_id_inner (l=");
365 fprint_frame_id (gdb_stdlog, l);
366 fprintf_unfiltered (gdb_stdlog, ",r=");
367 fprint_frame_id (gdb_stdlog, r);
368 fprintf_unfiltered (gdb_stdlog, ") -> %d }\n", inner);
374 frame_find_by_id (struct frame_id id)
376 struct frame_info *frame;
378 /* ZERO denotes the null frame, let the caller decide what to do
379 about it. Should it instead return get_current_frame()? */
380 if (!frame_id_p (id))
383 for (frame = get_current_frame ();
385 frame = get_prev_frame (frame))
387 struct frame_id this = get_frame_id (frame);
388 if (frame_id_eq (id, this))
389 /* An exact match. */
391 if (frame_id_inner (id, this))
394 /* Either we're not yet gone far enough out along the frame
395 chain (inner(this,id)), or we're comparing frameless functions
396 (same .base, different .func, no test available). Struggle
397 on until we've definitly gone to far. */
403 frame_pc_unwind (struct frame_info *this_frame)
405 if (!this_frame->prev_pc.p)
408 if (gdbarch_unwind_pc_p (current_gdbarch))
410 /* The right way. The `pure' way. The one true way. This
411 method depends solely on the register-unwind code to
412 determine the value of registers in THIS frame, and hence
413 the value of this frame's PC (resume address). A typical
414 implementation is no more than:
416 frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
417 return extract_unsigned_integer (buf, size of ISA_PC_REGNUM);
419 Note: this method is very heavily dependent on a correct
420 register-unwind implementation, it pays to fix that
421 method first; this method is frame type agnostic, since
422 it only deals with register values, it works with any
423 frame. This is all in stark contrast to the old
424 FRAME_SAVED_PC which would try to directly handle all the
425 different ways that a PC could be unwound. */
426 pc = gdbarch_unwind_pc (current_gdbarch, this_frame);
428 else if (this_frame->level < 0)
430 /* FIXME: cagney/2003-03-06: Old code and a sentinel
431 frame. Do like was always done. Fetch the PC's value
432 directly from the global registers array (via read_pc).
433 This assumes that this frame belongs to the current
434 global register cache. The assumption is dangerous. */
437 else if (DEPRECATED_FRAME_SAVED_PC_P ())
439 /* FIXME: cagney/2003-03-06: Old code, but not a sentinel
440 frame. Do like was always done. Note that this method,
441 unlike unwind_pc(), tries to handle all the different
442 frame cases directly. It fails. */
443 pc = DEPRECATED_FRAME_SAVED_PC (this_frame);
446 internal_error (__FILE__, __LINE__, "No gdbarch_unwind_pc method");
447 this_frame->prev_pc.value = pc;
448 this_frame->prev_pc.p = 1;
450 fprintf_unfiltered (gdb_stdlog,
451 "{ frame_pc_unwind (this_frame=%d) -> 0x%s }\n",
453 paddr_nz (this_frame->prev_pc.value));
455 return this_frame->prev_pc.value;
459 frame_func_unwind (struct frame_info *fi)
461 if (!fi->prev_func.p)
463 /* Make certain that this, and not the adjacent, function is
465 CORE_ADDR addr_in_block = frame_unwind_address_in_block (fi);
467 fi->prev_func.addr = get_pc_function_start (addr_in_block);
469 fprintf_unfiltered (gdb_stdlog,
470 "{ frame_func_unwind (fi=%d) -> 0x%s }\n",
471 fi->level, paddr_nz (fi->prev_func.addr));
473 return fi->prev_func.addr;
477 get_frame_func (struct frame_info *fi)
479 return frame_func_unwind (fi->next);
483 do_frame_unwind_register (void *src, int regnum, void *buf)
485 frame_unwind_register (src, regnum, buf);
490 frame_pop (struct frame_info *this_frame)
492 /* Make a copy of all the register values unwound from this frame.
493 Save them in a scratch buffer so that there isn't a race between
494 trying to extract the old values from the current_regcache while
495 at the same time writing new values into that same cache. */
496 struct regcache *scratch = regcache_xmalloc (current_gdbarch);
497 struct cleanup *cleanups = make_cleanup_regcache_xfree (scratch);
498 regcache_save (scratch, do_frame_unwind_register, this_frame);
500 /* FIXME: cagney/2003-03-16: It should be possible to tell the
501 target's register cache that it is about to be hit with a burst
502 register transfer and that the sequence of register writes should
503 be batched. The pair target_prepare_to_store() and
504 target_store_registers() kind of suggest this functionality.
505 Unfortunately, they don't implement it. Their lack of a formal
506 definition can lead to targets writing back bogus values
507 (arguably a bug in the target code mind). */
508 /* Now copy those saved registers into the current regcache.
509 Here, regcache_cpy() calls regcache_restore(). */
510 regcache_cpy (current_regcache, scratch);
511 do_cleanups (cleanups);
513 /* We've made right mess of GDB's local state, just discard
515 flush_cached_frames ();
519 frame_register_unwind (struct frame_info *frame, int regnum,
520 int *optimizedp, enum lval_type *lvalp,
521 CORE_ADDR *addrp, int *realnump, void *bufferp)
523 struct frame_unwind_cache *cache;
527 fprintf_unfiltered (gdb_stdlog, "\
528 { frame_register_unwind (frame=%d,regnum=%d(%s),...) ",
529 frame->level, regnum,
530 frame_map_regnum_to_name (frame, regnum));
533 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
534 that the value proper does not need to be fetched. */
535 gdb_assert (optimizedp != NULL);
536 gdb_assert (lvalp != NULL);
537 gdb_assert (addrp != NULL);
538 gdb_assert (realnump != NULL);
539 /* gdb_assert (bufferp != NULL); */
541 /* NOTE: cagney/2002-11-27: A program trying to unwind a NULL frame
542 is broken. There is always a frame. If there, for some reason,
543 isn't a frame, there is some pretty busted code as it should have
544 detected the problem before calling here. */
545 gdb_assert (frame != NULL);
547 /* Find the unwinder. */
548 if (frame->unwind == NULL)
549 frame->unwind = frame_unwind_find_by_frame (frame->next,
550 &frame->prologue_cache);
552 /* Ask this frame to unwind its register. See comment in
553 "frame-unwind.h" for why NEXT frame and this unwind cache are
555 frame->unwind->prev_register (frame->next, &frame->prologue_cache, regnum,
556 optimizedp, lvalp, addrp, realnump, bufferp);
560 fprintf_unfiltered (gdb_stdlog, "->");
561 fprintf_unfiltered (gdb_stdlog, " *optimizedp=%d", (*optimizedp));
562 fprintf_unfiltered (gdb_stdlog, " *lvalp=%d", (int) (*lvalp));
563 fprintf_unfiltered (gdb_stdlog, " *addrp=0x%s", paddr_nz ((*addrp)));
564 fprintf_unfiltered (gdb_stdlog, " *bufferp=");
566 fprintf_unfiltered (gdb_stdlog, "<NULL>");
570 const unsigned char *buf = bufferp;
571 fprintf_unfiltered (gdb_stdlog, "[");
572 for (i = 0; i < register_size (current_gdbarch, regnum); i++)
573 fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
574 fprintf_unfiltered (gdb_stdlog, "]");
576 fprintf_unfiltered (gdb_stdlog, " }\n");
581 frame_register (struct frame_info *frame, int regnum,
582 int *optimizedp, enum lval_type *lvalp,
583 CORE_ADDR *addrp, int *realnump, void *bufferp)
585 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
586 that the value proper does not need to be fetched. */
587 gdb_assert (optimizedp != NULL);
588 gdb_assert (lvalp != NULL);
589 gdb_assert (addrp != NULL);
590 gdb_assert (realnump != NULL);
591 /* gdb_assert (bufferp != NULL); */
593 /* Ulgh! Old code that, for lval_register, sets ADDRP to the offset
594 of the register in the register cache. It should instead return
595 the REGNUM corresponding to that register. Translate the . */
596 if (DEPRECATED_GET_SAVED_REGISTER_P ())
598 DEPRECATED_GET_SAVED_REGISTER (bufferp, optimizedp, addrp, frame,
600 /* Compute the REALNUM if the caller wants it. */
601 if (*lvalp == lval_register)
604 for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++)
606 if (*addrp == register_offset_hack (current_gdbarch, regnum))
612 internal_error (__FILE__, __LINE__,
613 "Failed to compute the register number corresponding"
614 " to 0x%s", paddr_d (*addrp));
620 /* Obtain the register value by unwinding the register from the next
621 (more inner frame). */
622 gdb_assert (frame != NULL && frame->next != NULL);
623 frame_register_unwind (frame->next, regnum, optimizedp, lvalp, addrp,
628 frame_unwind_register (struct frame_info *frame, int regnum, void *buf)
634 frame_register_unwind (frame, regnum, &optimized, &lval, &addr,
639 get_frame_register (struct frame_info *frame,
640 int regnum, void *buf)
642 frame_unwind_register (frame->next, regnum, buf);
646 frame_unwind_register_signed (struct frame_info *frame, int regnum)
648 char buf[MAX_REGISTER_SIZE];
649 frame_unwind_register (frame, regnum, buf);
650 return extract_signed_integer (buf, DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum));
654 get_frame_register_signed (struct frame_info *frame, int regnum)
656 return frame_unwind_register_signed (frame->next, regnum);
660 frame_unwind_register_unsigned (struct frame_info *frame, int regnum)
662 char buf[MAX_REGISTER_SIZE];
663 frame_unwind_register (frame, regnum, buf);
664 return extract_unsigned_integer (buf, DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum));
668 get_frame_register_unsigned (struct frame_info *frame, int regnum)
670 return frame_unwind_register_unsigned (frame->next, regnum);
674 frame_unwind_unsigned_register (struct frame_info *frame, int regnum,
677 char buf[MAX_REGISTER_SIZE];
678 frame_unwind_register (frame, regnum, buf);
679 (*val) = extract_unsigned_integer (buf, DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum));
683 put_frame_register (struct frame_info *frame, int regnum, const void *buf)
685 struct gdbarch *gdbarch = get_frame_arch (frame);
690 frame_register (frame, regnum, &optim, &lval, &addr, &realnum, NULL);
692 error ("Attempt to assign to a value that was optimized out.");
697 /* FIXME: write_memory doesn't yet take constant buffers.
699 char tmp[MAX_REGISTER_SIZE];
700 memcpy (tmp, buf, register_size (gdbarch, regnum));
701 write_memory (addr, tmp, register_size (gdbarch, regnum));
705 regcache_cooked_write (current_regcache, realnum, buf);
708 error ("Attempt to assign to an unmodifiable value.");
712 /* frame_register_read ()
714 Find and return the value of REGNUM for the specified stack frame.
715 The number of bytes copied is DEPRECATED_REGISTER_RAW_SIZE
718 Returns 0 if the register value could not be found. */
721 frame_register_read (struct frame_info *frame, int regnum, void *myaddr)
727 frame_register (frame, regnum, &optimized, &lval, &addr, &realnum, myaddr);
729 /* FIXME: cagney/2002-05-15: This test is just bogus.
731 It indicates that the target failed to supply a value for a
732 register because it was "not available" at this time. Problem
733 is, the target still has the register and so get saved_register()
734 may be returning a value saved on the stack. */
736 if (register_cached (regnum) < 0)
737 return 0; /* register value not available */
743 /* Map between a frame register number and its name. A frame register
744 space is a superset of the cooked register space --- it also
745 includes builtin registers. */
748 frame_map_name_to_regnum (struct frame_info *frame, const char *name, int len)
750 return user_reg_map_name_to_regnum (get_frame_arch (frame), name, len);
754 frame_map_regnum_to_name (struct frame_info *frame, int regnum)
756 return user_reg_map_regnum_to_name (get_frame_arch (frame), regnum);
759 /* Create a sentinel frame. */
761 static struct frame_info *
762 create_sentinel_frame (struct regcache *regcache)
764 struct frame_info *frame = FRAME_OBSTACK_ZALLOC (struct frame_info);
766 /* Explicitly initialize the sentinel frame's cache. Provide it
767 with the underlying regcache. In the future additional
768 information, such as the frame's thread will be added. */
769 frame->prologue_cache = sentinel_frame_cache (regcache);
770 /* For the moment there is only one sentinel frame implementation. */
771 frame->unwind = sentinel_frame_unwind;
772 /* Link this frame back to itself. The frame is self referential
773 (the unwound PC is the same as the pc), so make it so. */
775 /* Make the sentinel frame's ID valid, but invalid. That way all
776 comparisons with it should fail. */
777 frame->this_id.p = 1;
778 frame->this_id.value = null_frame_id;
781 fprintf_unfiltered (gdb_stdlog, "{ create_sentinel_frame (...) -> ");
782 fprint_frame (gdb_stdlog, frame);
783 fprintf_unfiltered (gdb_stdlog, " }\n");
788 /* Info about the innermost stack frame (contents of FP register) */
790 static struct frame_info *current_frame;
792 /* Cache for frame addresses already read by gdb. Valid only while
793 inferior is stopped. Control variables for the frame cache should
794 be local to this module. */
796 static struct obstack frame_cache_obstack;
799 frame_obstack_zalloc (unsigned long size)
801 void *data = obstack_alloc (&frame_cache_obstack, size);
802 memset (data, 0, size);
807 frame_saved_regs_zalloc (struct frame_info *fi)
809 fi->saved_regs = (CORE_ADDR *)
810 frame_obstack_zalloc (SIZEOF_FRAME_SAVED_REGS);
811 return fi->saved_regs;
815 deprecated_get_frame_saved_regs (struct frame_info *fi)
817 return fi->saved_regs;
820 /* Return the innermost (currently executing) stack frame. This is
821 split into two functions. The function unwind_to_current_frame()
822 is wrapped in catch exceptions so that, even when the unwind of the
823 sentinel frame fails, the function still returns a stack frame. */
826 unwind_to_current_frame (struct ui_out *ui_out, void *args)
828 struct frame_info *frame = get_prev_frame (args);
829 /* A sentinel frame can fail to unwind, e.g., because its PC value
830 lands in somewhere like start. */
833 current_frame = frame;
838 get_current_frame (void)
840 /* First check, and report, the lack of registers. Having GDB
841 report "No stack!" or "No memory" when the target doesn't even
842 have registers is very confusing. Besides, "printcmd.exp"
843 explicitly checks that ``print $pc'' with no registers prints "No
845 if (!target_has_registers)
846 error ("No registers.");
847 if (!target_has_stack)
849 if (!target_has_memory)
850 error ("No memory.");
851 if (current_frame == NULL)
853 struct frame_info *sentinel_frame =
854 create_sentinel_frame (current_regcache);
855 if (catch_exceptions (uiout, unwind_to_current_frame, sentinel_frame,
856 NULL, RETURN_MASK_ERROR) != 0)
858 /* Oops! Fake a current frame? Is this useful? It has a PC
859 of zero, for instance. */
860 current_frame = sentinel_frame;
863 return current_frame;
866 /* The "selected" stack frame is used by default for local and arg
867 access. May be zero, for no selected frame. */
869 struct frame_info *deprecated_selected_frame;
871 /* Return the selected frame. Always non-NULL (unless there isn't an
872 inferior sufficient for creating a frame) in which case an error is
876 get_selected_frame (void)
878 if (deprecated_selected_frame == NULL)
879 /* Hey! Don't trust this. It should really be re-finding the
880 last selected frame of the currently selected thread. This,
881 though, is better than nothing. */
882 select_frame (get_current_frame ());
883 /* There is always a frame. */
884 gdb_assert (deprecated_selected_frame != NULL);
885 return deprecated_selected_frame;
888 /* This is a variant of get_selected_frame() which can be called when
889 the inferior does not have a frame; in that case it will return
890 NULL instead of calling error(). */
893 deprecated_safe_get_selected_frame (void)
895 if (!target_has_registers || !target_has_stack || !target_has_memory)
897 return get_selected_frame ();
900 /* Select frame FI (or NULL - to invalidate the current frame). */
903 select_frame (struct frame_info *fi)
907 deprecated_selected_frame = fi;
908 /* NOTE: cagney/2002-05-04: FI can be NULL. This occurs when the
909 frame is being invalidated. */
910 if (deprecated_selected_frame_level_changed_hook)
911 deprecated_selected_frame_level_changed_hook (frame_relative_level (fi));
913 /* FIXME: kseitz/2002-08-28: It would be nice to call
914 selected_frame_level_changed_event() right here, but due to limitations
915 in the current interfaces, we would end up flooding UIs with events
916 because select_frame() is used extensively internally.
918 Once we have frame-parameterized frame (and frame-related) commands,
919 the event notification can be moved here, since this function will only
920 be called when the user's selected frame is being changed. */
922 /* Ensure that symbols for this frame are read in. Also, determine the
923 source language of this frame, and switch to it if desired. */
926 /* We retrieve the frame's symtab by using the frame PC. However
927 we cannot use the frame PC as-is, because it usually points to
928 the instruction following the "call", which is sometimes the
929 first instruction of another function. So we rely on
930 get_frame_address_in_block() which provides us with a PC which
931 is guaranteed to be inside the frame's code block. */
932 s = find_pc_symtab (get_frame_address_in_block (fi));
934 && s->language != current_language->la_language
935 && s->language != language_unknown
936 && language_mode == language_mode_auto)
938 set_language (s->language);
943 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
944 Always returns a non-NULL value. */
947 create_new_frame (CORE_ADDR addr, CORE_ADDR pc)
949 struct frame_info *fi;
953 fprintf_unfiltered (gdb_stdlog,
954 "{ create_new_frame (addr=0x%s, pc=0x%s) ",
955 paddr_nz (addr), paddr_nz (pc));
958 fi = frame_obstack_zalloc (sizeof (struct frame_info));
960 fi->next = create_sentinel_frame (current_regcache);
962 /* Select/initialize both the unwind function and the frame's type
964 fi->unwind = frame_unwind_find_by_frame (fi->next, &fi->prologue_cache);
967 deprecated_update_frame_base_hack (fi, addr);
968 deprecated_update_frame_pc_hack (fi, pc);
970 if (DEPRECATED_INIT_EXTRA_FRAME_INFO_P ())
971 DEPRECATED_INIT_EXTRA_FRAME_INFO (0, fi);
975 fprintf_unfiltered (gdb_stdlog, "-> ");
976 fprint_frame (gdb_stdlog, fi);
977 fprintf_unfiltered (gdb_stdlog, " }\n");
983 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
984 innermost frame). Be careful to not fall off the bottom of the
985 frame chain and onto the sentinel frame. */
988 get_next_frame (struct frame_info *this_frame)
990 if (this_frame->level > 0)
991 return this_frame->next;
996 /* Observer for the target_changed event. */
999 frame_observer_target_changed (struct target_ops *target)
1001 flush_cached_frames ();
1004 /* Flush the entire frame cache. */
1007 flush_cached_frames (void)
1009 /* Since we can't really be sure what the first object allocated was */
1010 obstack_free (&frame_cache_obstack, 0);
1011 obstack_init (&frame_cache_obstack);
1013 current_frame = NULL; /* Invalidate cache */
1014 select_frame (NULL);
1015 annotate_frames_invalid ();
1017 fprintf_unfiltered (gdb_stdlog, "{ flush_cached_frames () }\n");
1020 /* Flush the frame cache, and start a new one if necessary. */
1023 reinit_frame_cache (void)
1025 flush_cached_frames ();
1027 /* FIXME: The inferior_ptid test is wrong if there is a corefile. */
1028 if (PIDGET (inferior_ptid) != 0)
1030 select_frame (get_current_frame ());
1034 /* Return a "struct frame_info" corresponding to the frame that called
1035 THIS_FRAME. Returns NULL if there is no such frame.
1037 Unlike get_prev_frame, this function always tries to unwind the
1040 static struct frame_info *
1041 get_prev_frame_1 (struct frame_info *this_frame)
1043 struct frame_info *prev_frame;
1044 struct frame_id this_id;
1046 gdb_assert (this_frame != NULL);
1050 fprintf_unfiltered (gdb_stdlog, "{ get_prev_frame_1 (this_frame=");
1051 if (this_frame != NULL)
1052 fprintf_unfiltered (gdb_stdlog, "%d", this_frame->level);
1054 fprintf_unfiltered (gdb_stdlog, "<NULL>");
1055 fprintf_unfiltered (gdb_stdlog, ") ");
1058 /* Only try to do the unwind once. */
1059 if (this_frame->prev_p)
1063 fprintf_unfiltered (gdb_stdlog, "-> ");
1064 fprint_frame (gdb_stdlog, this_frame->prev);
1065 fprintf_unfiltered (gdb_stdlog, " // cached \n");
1067 return this_frame->prev;
1069 this_frame->prev_p = 1;
1071 /* Check that this frame's ID was valid. If it wasn't, don't try to
1072 unwind to the prev frame. Be careful to not apply this test to
1073 the sentinel frame. */
1074 this_id = get_frame_id (this_frame);
1075 if (this_frame->level >= 0 && !frame_id_p (this_id))
1079 fprintf_unfiltered (gdb_stdlog, "-> ");
1080 fprint_frame (gdb_stdlog, NULL);
1081 fprintf_unfiltered (gdb_stdlog, " // this ID is NULL }\n");
1086 /* Check that this frame's ID isn't inner to (younger, below, next)
1087 the next frame. This happens when a frame unwind goes backwards.
1088 Exclude signal trampolines (due to sigaltstack the frame ID can
1089 go backwards) and sentinel frames (the test is meaningless). */
1090 if (this_frame->next->level >= 0
1091 && this_frame->next->unwind->type != SIGTRAMP_FRAME
1092 && frame_id_inner (this_id, get_frame_id (this_frame->next)))
1093 error ("Previous frame inner to this frame (corrupt stack?)");
1095 /* Check that this and the next frame are not identical. If they
1096 are, there is most likely a stack cycle. As with the inner-than
1097 test above, avoid comparing the inner-most and sentinel frames. */
1098 if (this_frame->level > 0
1099 && frame_id_eq (this_id, get_frame_id (this_frame->next)))
1100 error ("Previous frame identical to this frame (corrupt stack?)");
1102 /* Allocate the new frame but do not wire it in to the frame chain.
1103 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
1104 frame->next to pull some fancy tricks (of course such code is, by
1105 definition, recursive). Try to prevent it.
1107 There is no reason to worry about memory leaks, should the
1108 remainder of the function fail. The allocated memory will be
1109 quickly reclaimed when the frame cache is flushed, and the `we've
1110 been here before' check above will stop repeated memory
1111 allocation calls. */
1112 prev_frame = FRAME_OBSTACK_ZALLOC (struct frame_info);
1113 prev_frame->level = this_frame->level + 1;
1115 /* Don't yet compute ->unwind (and hence ->type). It is computed
1116 on-demand in get_frame_type, frame_register_unwind, and
1119 /* Don't yet compute the frame's ID. It is computed on-demand by
1122 /* The unwound frame ID is validate at the start of this function,
1123 as part of the logic to decide if that frame should be further
1124 unwound, and not here while the prev frame is being created.
1125 Doing this makes it possible for the user to examine a frame that
1126 has an invalid frame ID.
1128 Some very old VAX code noted: [...] For the sake of argument,
1129 suppose that the stack is somewhat trashed (which is one reason
1130 that "info frame" exists). So, return 0 (indicating we don't
1131 know the address of the arglist) if we don't know what frame this
1135 this_frame->prev = prev_frame;
1136 prev_frame->next = this_frame;
1140 fprintf_unfiltered (gdb_stdlog, "-> ");
1141 fprint_frame (gdb_stdlog, prev_frame);
1142 fprintf_unfiltered (gdb_stdlog, " }\n");
1148 /* Debug routine to print a NULL frame being returned. */
1151 frame_debug_got_null_frame (struct ui_file *file,
1152 struct frame_info *this_frame,
1157 fprintf_unfiltered (gdb_stdlog, "{ get_prev_frame (this_frame=");
1158 if (this_frame != NULL)
1159 fprintf_unfiltered (gdb_stdlog, "%d", this_frame->level);
1161 fprintf_unfiltered (gdb_stdlog, "<NULL>");
1162 fprintf_unfiltered (gdb_stdlog, ") -> // %s}\n", reason);
1166 /* Return a structure containing various interesting information about
1167 the frame that called THIS_FRAME. Returns NULL if there is entier
1168 no such frame or the frame fails any of a set of target-independent
1169 condition that should terminate the frame chain (e.g., as unwinding
1172 This function should not contain target-dependent tests, such as
1173 checking whether the program-counter is zero. */
1176 get_prev_frame (struct frame_info *this_frame)
1178 struct frame_info *prev_frame;
1180 /* Return the inner-most frame, when the caller passes in NULL. */
1181 /* NOTE: cagney/2002-11-09: Not sure how this would happen. The
1182 caller should have previously obtained a valid frame using
1183 get_selected_frame() and then called this code - only possibility
1184 I can think of is code behaving badly.
1186 NOTE: cagney/2003-01-10: Talk about code behaving badly. Check
1187 block_innermost_frame(). It does the sequence: frame = NULL;
1188 while (1) { frame = get_prev_frame (frame); .... }. Ulgh! Why
1189 it couldn't be written better, I don't know.
1191 NOTE: cagney/2003-01-11: I suspect what is happening in
1192 block_innermost_frame() is, when the target has no state
1193 (registers, memory, ...), it is still calling this function. The
1194 assumption being that this function will return NULL indicating
1195 that a frame isn't possible, rather than checking that the target
1196 has state and then calling get_current_frame() and
1197 get_prev_frame(). This is a guess mind. */
1198 if (this_frame == NULL)
1200 /* NOTE: cagney/2002-11-09: There was a code segment here that
1201 would error out when CURRENT_FRAME was NULL. The comment
1202 that went with it made the claim ...
1204 ``This screws value_of_variable, which just wants a nice
1205 clean NULL return from block_innermost_frame if there are no
1206 frames. I don't think I've ever seen this message happen
1207 otherwise. And returning NULL here is a perfectly legitimate
1210 Per the above, this code shouldn't even be called with a NULL
1212 frame_debug_got_null_frame (gdb_stdlog, this_frame, "this_frame NULL");
1213 return current_frame;
1216 /* There is always a frame. If this assertion fails, suspect that
1217 something should be calling get_selected_frame() or
1218 get_current_frame(). */
1219 gdb_assert (this_frame != NULL);
1221 /* Make sure we pass an address within THIS_FRAME's code block to
1222 inside_main_func(). Otherwise, we might stop unwinding at a
1223 function which has a call instruction as its last instruction if
1224 that function immediately precedes main(). */
1225 if (this_frame->level >= 0
1226 && !backtrace_past_main
1227 && inside_main_func (get_frame_address_in_block (this_frame)))
1228 /* Don't unwind past main(), but always unwind the sentinel frame.
1229 Note, this is done _before_ the frame has been marked as
1230 previously unwound. That way if the user later decides to
1231 allow unwinds past main(), that just happens. */
1233 frame_debug_got_null_frame (gdb_stdlog, this_frame, "inside main func");
1237 if (this_frame->level > backtrace_limit)
1239 error ("Backtrace limit of %d exceeded", backtrace_limit);
1242 /* If we're already inside the entry function for the main objfile,
1243 then it isn't valid. Don't apply this test to a dummy frame -
1244 dummy frame PCs typically land in the entry func. Don't apply
1245 this test to the sentinel frame. Sentinel frames should always
1246 be allowed to unwind. */
1247 /* NOTE: cagney/2003-02-25: Don't enable until someone has found
1248 hard evidence that this is needed. */
1249 /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() -
1250 wasn't checking for "main" in the minimal symbols. With that
1251 fixed asm-source tests now stop in "main" instead of halting the
1252 backtrace in weird and wonderful ways somewhere inside the entry
1253 file. Suspect that tests for inside the entry file/func were
1254 added to work around that (now fixed) case. */
1255 /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
1256 suggested having the inside_entry_func test use the
1257 inside_main_func() msymbol trick (along with entry_point_address()
1258 I guess) to determine the address range of the start function.
1259 That should provide a far better stopper than the current
1261 /* NOTE: cagney/2003-07-15: Need to add a "set backtrace
1262 beyond-entry-func" command so that this can be selectively
1266 && backtrace_beyond_entry_func
1268 && this_frame->unwind->type != DUMMY_FRAME && this_frame->level >= 0
1269 && inside_entry_func (this_frame))
1271 frame_debug_got_null_frame (gdb_stdlog, this_frame, "inside entry func");
1275 return get_prev_frame_1 (this_frame);
1279 get_frame_pc (struct frame_info *frame)
1281 gdb_assert (frame->next != NULL);
1282 return frame_pc_unwind (frame->next);
1285 /* Return an address of that falls within the frame's code block. */
1288 frame_unwind_address_in_block (struct frame_info *next_frame)
1290 /* A draft address. */
1291 CORE_ADDR pc = frame_pc_unwind (next_frame);
1293 /* If THIS frame is not inner most (i.e., NEXT isn't the sentinel),
1294 and NEXT is `normal' (i.e., not a sigtramp, dummy, ....) THIS
1295 frame's PC ends up pointing at the instruction fallowing the
1296 "call". Adjust that PC value so that it falls on the call
1297 instruction (which, hopefully, falls within THIS frame's code
1298 block. So far it's proved to be a very good approximation. See
1299 get_frame_type() for why ->type can't be used. */
1300 if (next_frame->level >= 0
1301 && get_frame_type (next_frame) == NORMAL_FRAME)
1307 get_frame_address_in_block (struct frame_info *this_frame)
1309 return frame_unwind_address_in_block (this_frame->next);
1313 pc_notcurrent (struct frame_info *frame)
1315 /* If FRAME is not the innermost frame, that normally means that
1316 FRAME->pc points at the return instruction (which is *after* the
1317 call instruction), and we want to get the line containing the
1318 call (because the call is where the user thinks the program is).
1319 However, if the next frame is either a SIGTRAMP_FRAME or a
1320 DUMMY_FRAME, then the next frame will contain a saved interrupt
1321 PC and such a PC indicates the current (rather than next)
1322 instruction/line, consequently, for such cases, want to get the
1323 line containing fi->pc. */
1324 struct frame_info *next = get_next_frame (frame);
1325 int notcurrent = (next != NULL && get_frame_type (next) == NORMAL_FRAME);
1330 find_frame_sal (struct frame_info *frame, struct symtab_and_line *sal)
1332 (*sal) = find_pc_line (get_frame_pc (frame), pc_notcurrent (frame));
1335 /* Per "frame.h", return the ``address'' of the frame. Code should
1336 really be using get_frame_id(). */
1338 get_frame_base (struct frame_info *fi)
1340 return get_frame_id (fi).stack_addr;
1343 /* High-level offsets into the frame. Used by the debug info. */
1346 get_frame_base_address (struct frame_info *fi)
1348 if (get_frame_type (fi) != NORMAL_FRAME)
1350 if (fi->base == NULL)
1351 fi->base = frame_base_find_by_frame (fi->next);
1352 /* Sneaky: If the low-level unwind and high-level base code share a
1353 common unwinder, let them share the prologue cache. */
1354 if (fi->base->unwind == fi->unwind)
1355 return fi->base->this_base (fi->next, &fi->prologue_cache);
1356 return fi->base->this_base (fi->next, &fi->base_cache);
1360 get_frame_locals_address (struct frame_info *fi)
1363 if (get_frame_type (fi) != NORMAL_FRAME)
1365 /* If there isn't a frame address method, find it. */
1366 if (fi->base == NULL)
1367 fi->base = frame_base_find_by_frame (fi->next);
1368 /* Sneaky: If the low-level unwind and high-level base code share a
1369 common unwinder, let them share the prologue cache. */
1370 if (fi->base->unwind == fi->unwind)
1371 cache = &fi->prologue_cache;
1373 cache = &fi->base_cache;
1374 return fi->base->this_locals (fi->next, cache);
1378 get_frame_args_address (struct frame_info *fi)
1381 if (get_frame_type (fi) != NORMAL_FRAME)
1383 /* If there isn't a frame address method, find it. */
1384 if (fi->base == NULL)
1385 fi->base = frame_base_find_by_frame (fi->next);
1386 /* Sneaky: If the low-level unwind and high-level base code share a
1387 common unwinder, let them share the prologue cache. */
1388 if (fi->base->unwind == fi->unwind)
1389 cache = &fi->prologue_cache;
1391 cache = &fi->base_cache;
1392 return fi->base->this_args (fi->next, cache);
1395 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
1396 or -1 for a NULL frame. */
1399 frame_relative_level (struct frame_info *fi)
1408 get_frame_type (struct frame_info *frame)
1410 if (frame->unwind == NULL)
1411 /* Initialize the frame's unwinder because that's what
1412 provides the frame's type. */
1413 frame->unwind = frame_unwind_find_by_frame (frame->next,
1414 &frame->prologue_cache);
1415 return frame->unwind->type;
1418 struct frame_extra_info *
1419 get_frame_extra_info (struct frame_info *fi)
1421 return fi->extra_info;
1424 struct frame_extra_info *
1425 frame_extra_info_zalloc (struct frame_info *fi, long size)
1427 fi->extra_info = frame_obstack_zalloc (size);
1428 return fi->extra_info;
1432 deprecated_update_frame_pc_hack (struct frame_info *frame, CORE_ADDR pc)
1435 fprintf_unfiltered (gdb_stdlog,
1436 "{ deprecated_update_frame_pc_hack (frame=%d,pc=0x%s) }\n",
1437 frame->level, paddr_nz (pc));
1438 /* NOTE: cagney/2003-03-11: Some architectures (e.g., Arm) are
1439 maintaining a locally allocated frame object. Since such frames
1440 are not in the frame chain, it isn't possible to assume that the
1441 frame has a next. Sigh. */
1442 if (frame->next != NULL)
1444 /* While we're at it, update this frame's cached PC value, found
1445 in the next frame. Oh for the day when "struct frame_info"
1446 is opaque and this hack on hack can just go away. */
1447 frame->next->prev_pc.value = pc;
1448 frame->next->prev_pc.p = 1;
1453 deprecated_update_frame_base_hack (struct frame_info *frame, CORE_ADDR base)
1456 fprintf_unfiltered (gdb_stdlog,
1457 "{ deprecated_update_frame_base_hack (frame=%d,base=0x%s) }\n",
1458 frame->level, paddr_nz (base));
1459 /* See comment in "frame.h". */
1460 frame->this_id.value.stack_addr = base;
1464 deprecated_frame_xmalloc_with_cleanup (long sizeof_saved_regs,
1465 long sizeof_extra_info)
1467 struct frame_info *frame = XMALLOC (struct frame_info);
1468 memset (frame, 0, sizeof (*frame));
1469 frame->this_id.p = 1;
1470 make_cleanup (xfree, frame);
1471 if (sizeof_saved_regs > 0)
1473 frame->saved_regs = xcalloc (1, sizeof_saved_regs);
1474 make_cleanup (xfree, frame->saved_regs);
1476 if (sizeof_extra_info > 0)
1478 frame->extra_info = xcalloc (1, sizeof_extra_info);
1479 make_cleanup (xfree, frame->extra_info);
1484 /* Memory access methods. */
1487 get_frame_memory (struct frame_info *this_frame, CORE_ADDR addr, void *buf,
1490 read_memory (addr, buf, len);
1494 get_frame_memory_signed (struct frame_info *this_frame, CORE_ADDR addr,
1497 return read_memory_integer (addr, len);
1501 get_frame_memory_unsigned (struct frame_info *this_frame, CORE_ADDR addr,
1504 return read_memory_unsigned_integer (addr, len);
1508 safe_frame_unwind_memory (struct frame_info *this_frame,
1509 CORE_ADDR addr, void *buf, int len)
1511 /* NOTE: deprecated_read_memory_nobpt returns zero on success! */
1512 return !deprecated_read_memory_nobpt (addr, buf, len);
1515 /* Architecture method. */
1518 get_frame_arch (struct frame_info *this_frame)
1520 return current_gdbarch;
1523 /* Stack pointer methods. */
1526 get_frame_sp (struct frame_info *this_frame)
1528 return frame_sp_unwind (this_frame->next);
1532 frame_sp_unwind (struct frame_info *next_frame)
1534 /* Normality - an architecture that provides a way of obtaining any
1535 frame inner-most address. */
1536 if (gdbarch_unwind_sp_p (current_gdbarch))
1537 return gdbarch_unwind_sp (current_gdbarch, next_frame);
1538 /* Things are looking grim. If it's the inner-most frame and there
1539 is a TARGET_READ_SP, then that can be used. */
1540 if (next_frame->level < 0 && TARGET_READ_SP_P ())
1541 return TARGET_READ_SP ();
1542 /* Now things are really are grim. Hope that the value returned by
1543 the SP_REGNUM register is meaningful. */
1547 frame_unwind_unsigned_register (next_frame, SP_REGNUM, &sp);
1550 internal_error (__FILE__, __LINE__, "Missing unwind SP method");
1553 extern initialize_file_ftype _initialize_frame; /* -Wmissing-prototypes */
1555 static struct cmd_list_element *set_backtrace_cmdlist;
1556 static struct cmd_list_element *show_backtrace_cmdlist;
1559 set_backtrace_cmd (char *args, int from_tty)
1561 help_list (set_backtrace_cmdlist, "set backtrace ", -1, gdb_stdout);
1565 show_backtrace_cmd (char *args, int from_tty)
1567 cmd_show_list (show_backtrace_cmdlist, from_tty, "");
1571 _initialize_frame (void)
1573 obstack_init (&frame_cache_obstack);
1575 observer_attach_target_changed (frame_observer_target_changed);
1577 add_prefix_cmd ("backtrace", class_maintenance, set_backtrace_cmd, "\
1578 Set backtrace specific variables.\n\
1579 Configure backtrace variables such as the backtrace limit",
1580 &set_backtrace_cmdlist, "set backtrace ",
1581 0/*allow-unknown*/, &setlist);
1582 add_prefix_cmd ("backtrace", class_maintenance, show_backtrace_cmd, "\
1583 Show backtrace specific variables\n\
1584 Show backtrace variables such as the backtrace limit",
1585 &show_backtrace_cmdlist, "show backtrace ",
1586 0/*allow-unknown*/, &showlist);
1588 add_setshow_boolean_cmd ("past-main", class_obscure,
1589 &backtrace_past_main, "\
1590 Set whether backtraces should continue past \"main\".", "\
1591 Show whether backtraces should continue past \"main\".", "\
1592 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
1593 the backtrace at \"main\". Set this variable if you need to see the rest\n\
1594 of the stack trace.", "\
1595 Whether backtraces should continue past \"main\" is %s.",
1596 NULL, NULL, &set_backtrace_cmdlist,
1597 &show_backtrace_cmdlist);
1599 add_setshow_uinteger_cmd ("limit", class_obscure,
1600 &backtrace_limit, "\
1601 Set an upper bound on the number of backtrace levels.", "\
1602 Show the upper bound on the number of backtrace levels.", "\
1603 No more than the specified number of frames can be displayed or examined.\n\
1604 Zero is unlimited.", "\
1605 An upper bound on the number of backtrace levels is %s.",
1606 NULL, NULL, &set_backtrace_cmdlist,
1607 &show_backtrace_cmdlist);
1609 /* Debug this files internals. */
1610 deprecated_add_show_from_set
1611 (add_set_cmd ("frame", class_maintenance, var_zinteger,
1612 &frame_debug, "Set frame debugging.\n\
1613 When non-zero, frame specific internal debugging is enabled.", &setdebuglist),