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 (gdbarch_unwind_pc_p (current_gdbarch
))
395 /* The right way. The `pure' way. The one true way. This
396 method depends solely on the register-unwind code to
397 determine the value of registers in THIS frame, and hence
398 the value of this frame's PC (resume address). A typical
399 implementation is no more than:
401 frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
402 return extract_unsigned_integer (buf, size of ISA_PC_REGNUM);
404 Note: this method is very heavily dependent on a correct
405 register-unwind implementation, it pays to fix that
406 method first; this method is frame type agnostic, since
407 it only deals with register values, it works with any
408 frame. This is all in stark contrast to the old
409 FRAME_SAVED_PC which would try to directly handle all the
410 different ways that a PC could be unwound. */
411 pc
= gdbarch_unwind_pc (current_gdbarch
, this_frame
);
413 else if (this_frame
->level
< 0)
415 /* FIXME: cagney/2003-03-06: Old code and a sentinel
416 frame. Do like was always done. Fetch the PC's value
417 directly from the global registers array (via read_pc).
418 This assumes that this frame belongs to the current
419 global register cache. The assumption is dangerous. */
423 internal_error (__FILE__
, __LINE__
, "No gdbarch_unwind_pc method");
424 this_frame
->prev_pc
.value
= pc
;
425 this_frame
->prev_pc
.p
= 1;
427 fprintf_unfiltered (gdb_stdlog
,
428 "{ frame_pc_unwind (this_frame=%d) -> 0x%s }\n",
430 paddr_nz (this_frame
->prev_pc
.value
));
432 return this_frame
->prev_pc
.value
;
436 frame_func_unwind (struct frame_info
*fi
)
438 if (!fi
->prev_func
.p
)
440 /* Make certain that this, and not the adjacent, function is
442 CORE_ADDR addr_in_block
= frame_unwind_address_in_block (fi
);
444 fi
->prev_func
.addr
= get_pc_function_start (addr_in_block
);
446 fprintf_unfiltered (gdb_stdlog
,
447 "{ frame_func_unwind (fi=%d) -> 0x%s }\n",
448 fi
->level
, paddr_nz (fi
->prev_func
.addr
));
450 return fi
->prev_func
.addr
;
454 get_frame_func (struct frame_info
*fi
)
456 return frame_func_unwind (fi
->next
);
460 do_frame_register_read (void *src
, int regnum
, void *buf
)
462 frame_register_read (src
, regnum
, buf
);
467 frame_save_as_regcache (struct frame_info
*this_frame
)
469 struct regcache
*regcache
= regcache_xmalloc (current_gdbarch
);
470 struct cleanup
*cleanups
= make_cleanup_regcache_xfree (regcache
);
471 regcache_save (regcache
, do_frame_register_read
, this_frame
);
472 discard_cleanups (cleanups
);
477 frame_pop (struct frame_info
*this_frame
)
479 /* Make a copy of all the register values unwound from this frame.
480 Save them in a scratch buffer so that there isn't a race between
481 trying to extract the old values from the current_regcache while
482 at the same time writing new values into that same cache. */
483 struct regcache
*scratch
484 = frame_save_as_regcache (get_prev_frame_1 (this_frame
));
485 struct cleanup
*cleanups
= make_cleanup_regcache_xfree (scratch
);
487 /* FIXME: cagney/2003-03-16: It should be possible to tell the
488 target's register cache that it is about to be hit with a burst
489 register transfer and that the sequence of register writes should
490 be batched. The pair target_prepare_to_store() and
491 target_store_registers() kind of suggest this functionality.
492 Unfortunately, they don't implement it. Their lack of a formal
493 definition can lead to targets writing back bogus values
494 (arguably a bug in the target code mind). */
495 /* Now copy those saved registers into the current regcache.
496 Here, regcache_cpy() calls regcache_restore(). */
497 regcache_cpy (current_regcache
, scratch
);
498 do_cleanups (cleanups
);
500 /* We've made right mess of GDB's local state, just discard
502 flush_cached_frames ();
506 frame_register_unwind (struct frame_info
*frame
, int regnum
,
507 int *optimizedp
, enum lval_type
*lvalp
,
508 CORE_ADDR
*addrp
, int *realnump
, void *bufferp
)
510 struct frame_unwind_cache
*cache
;
514 fprintf_unfiltered (gdb_stdlog
, "\
515 { frame_register_unwind (frame=%d,regnum=%d(%s),...) ",
516 frame
->level
, regnum
,
517 frame_map_regnum_to_name (frame
, regnum
));
520 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
521 that the value proper does not need to be fetched. */
522 gdb_assert (optimizedp
!= NULL
);
523 gdb_assert (lvalp
!= NULL
);
524 gdb_assert (addrp
!= NULL
);
525 gdb_assert (realnump
!= NULL
);
526 /* gdb_assert (bufferp != NULL); */
528 /* NOTE: cagney/2002-11-27: A program trying to unwind a NULL frame
529 is broken. There is always a frame. If there, for some reason,
530 isn't a frame, there is some pretty busted code as it should have
531 detected the problem before calling here. */
532 gdb_assert (frame
!= NULL
);
534 /* Find the unwinder. */
535 if (frame
->unwind
== NULL
)
536 frame
->unwind
= frame_unwind_find_by_frame (frame
->next
,
537 &frame
->prologue_cache
);
539 /* Ask this frame to unwind its register. See comment in
540 "frame-unwind.h" for why NEXT frame and this unwind cache are
542 frame
->unwind
->prev_register (frame
->next
, &frame
->prologue_cache
, regnum
,
543 optimizedp
, lvalp
, addrp
, realnump
, bufferp
);
547 fprintf_unfiltered (gdb_stdlog
, "->");
548 fprintf_unfiltered (gdb_stdlog
, " *optimizedp=%d", (*optimizedp
));
549 fprintf_unfiltered (gdb_stdlog
, " *lvalp=%d", (int) (*lvalp
));
550 fprintf_unfiltered (gdb_stdlog
, " *addrp=0x%s", paddr_nz ((*addrp
)));
551 fprintf_unfiltered (gdb_stdlog
, " *bufferp=");
553 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
557 const unsigned char *buf
= bufferp
;
558 fprintf_unfiltered (gdb_stdlog
, "[");
559 for (i
= 0; i
< register_size (current_gdbarch
, regnum
); i
++)
560 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
561 fprintf_unfiltered (gdb_stdlog
, "]");
563 fprintf_unfiltered (gdb_stdlog
, " }\n");
568 frame_register (struct frame_info
*frame
, int regnum
,
569 int *optimizedp
, enum lval_type
*lvalp
,
570 CORE_ADDR
*addrp
, int *realnump
, void *bufferp
)
572 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
573 that the value proper does not need to be fetched. */
574 gdb_assert (optimizedp
!= NULL
);
575 gdb_assert (lvalp
!= NULL
);
576 gdb_assert (addrp
!= NULL
);
577 gdb_assert (realnump
!= NULL
);
578 /* gdb_assert (bufferp != NULL); */
580 /* Obtain the register value by unwinding the register from the next
581 (more inner frame). */
582 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
583 frame_register_unwind (frame
->next
, regnum
, optimizedp
, lvalp
, addrp
,
588 frame_unwind_register (struct frame_info
*frame
, int regnum
, void *buf
)
594 frame_register_unwind (frame
, regnum
, &optimized
, &lval
, &addr
,
599 get_frame_register (struct frame_info
*frame
,
600 int regnum
, void *buf
)
602 frame_unwind_register (frame
->next
, regnum
, buf
);
606 frame_unwind_register_signed (struct frame_info
*frame
, int regnum
)
608 char buf
[MAX_REGISTER_SIZE
];
609 frame_unwind_register (frame
, regnum
, buf
);
610 return extract_signed_integer (buf
, register_size (get_frame_arch (frame
),
615 get_frame_register_signed (struct frame_info
*frame
, int regnum
)
617 return frame_unwind_register_signed (frame
->next
, regnum
);
621 frame_unwind_register_unsigned (struct frame_info
*frame
, int regnum
)
623 char buf
[MAX_REGISTER_SIZE
];
624 frame_unwind_register (frame
, regnum
, buf
);
625 return extract_unsigned_integer (buf
, register_size (get_frame_arch (frame
),
630 get_frame_register_unsigned (struct frame_info
*frame
, int regnum
)
632 return frame_unwind_register_unsigned (frame
->next
, regnum
);
636 frame_unwind_unsigned_register (struct frame_info
*frame
, int regnum
,
639 char buf
[MAX_REGISTER_SIZE
];
640 frame_unwind_register (frame
, regnum
, buf
);
641 (*val
) = extract_unsigned_integer (buf
,
642 register_size (get_frame_arch (frame
),
647 put_frame_register (struct frame_info
*frame
, int regnum
, const void *buf
)
649 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
654 frame_register (frame
, regnum
, &optim
, &lval
, &addr
, &realnum
, NULL
);
656 error ("Attempt to assign to a value that was optimized out.");
661 /* FIXME: write_memory doesn't yet take constant buffers.
663 char tmp
[MAX_REGISTER_SIZE
];
664 memcpy (tmp
, buf
, register_size (gdbarch
, regnum
));
665 write_memory (addr
, tmp
, register_size (gdbarch
, regnum
));
669 regcache_cooked_write (current_regcache
, realnum
, buf
);
672 error ("Attempt to assign to an unmodifiable value.");
676 /* frame_register_read ()
678 Find and return the value of REGNUM for the specified stack frame.
679 The number of bytes copied is REGISTER_SIZE (REGNUM).
681 Returns 0 if the register value could not be found. */
684 frame_register_read (struct frame_info
*frame
, int regnum
, void *myaddr
)
690 frame_register (frame
, regnum
, &optimized
, &lval
, &addr
, &realnum
, myaddr
);
692 /* FIXME: cagney/2002-05-15: This test is just bogus.
694 It indicates that the target failed to supply a value for a
695 register because it was "not available" at this time. Problem
696 is, the target still has the register and so get saved_register()
697 may be returning a value saved on the stack. */
699 if (register_cached (regnum
) < 0)
700 return 0; /* register value not available */
706 /* Map between a frame register number and its name. A frame register
707 space is a superset of the cooked register space --- it also
708 includes builtin registers. */
711 frame_map_name_to_regnum (struct frame_info
*frame
, const char *name
, int len
)
713 return user_reg_map_name_to_regnum (get_frame_arch (frame
), name
, len
);
717 frame_map_regnum_to_name (struct frame_info
*frame
, int regnum
)
719 return user_reg_map_regnum_to_name (get_frame_arch (frame
), regnum
);
722 /* Create a sentinel frame. */
724 static struct frame_info
*
725 create_sentinel_frame (struct regcache
*regcache
)
727 struct frame_info
*frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
729 /* Explicitly initialize the sentinel frame's cache. Provide it
730 with the underlying regcache. In the future additional
731 information, such as the frame's thread will be added. */
732 frame
->prologue_cache
= sentinel_frame_cache (regcache
);
733 /* For the moment there is only one sentinel frame implementation. */
734 frame
->unwind
= sentinel_frame_unwind
;
735 /* Link this frame back to itself. The frame is self referential
736 (the unwound PC is the same as the pc), so make it so. */
738 /* Make the sentinel frame's ID valid, but invalid. That way all
739 comparisons with it should fail. */
740 frame
->this_id
.p
= 1;
741 frame
->this_id
.value
= null_frame_id
;
744 fprintf_unfiltered (gdb_stdlog
, "{ create_sentinel_frame (...) -> ");
745 fprint_frame (gdb_stdlog
, frame
);
746 fprintf_unfiltered (gdb_stdlog
, " }\n");
751 /* Info about the innermost stack frame (contents of FP register) */
753 static struct frame_info
*current_frame
;
755 /* Cache for frame addresses already read by gdb. Valid only while
756 inferior is stopped. Control variables for the frame cache should
757 be local to this module. */
759 static struct obstack frame_cache_obstack
;
762 frame_obstack_zalloc (unsigned long size
)
764 void *data
= obstack_alloc (&frame_cache_obstack
, size
);
765 memset (data
, 0, size
);
769 /* Return the innermost (currently executing) stack frame. This is
770 split into two functions. The function unwind_to_current_frame()
771 is wrapped in catch exceptions so that, even when the unwind of the
772 sentinel frame fails, the function still returns a stack frame. */
775 unwind_to_current_frame (struct ui_out
*ui_out
, void *args
)
777 struct frame_info
*frame
= get_prev_frame (args
);
778 /* A sentinel frame can fail to unwind, e.g., because its PC value
779 lands in somewhere like start. */
782 current_frame
= frame
;
787 get_current_frame (void)
789 /* First check, and report, the lack of registers. Having GDB
790 report "No stack!" or "No memory" when the target doesn't even
791 have registers is very confusing. Besides, "printcmd.exp"
792 explicitly checks that ``print $pc'' with no registers prints "No
794 if (!target_has_registers
)
795 error ("No registers.");
796 if (!target_has_stack
)
798 if (!target_has_memory
)
799 error ("No memory.");
800 if (current_frame
== NULL
)
802 struct frame_info
*sentinel_frame
=
803 create_sentinel_frame (current_regcache
);
804 if (catch_exceptions (uiout
, unwind_to_current_frame
, sentinel_frame
,
805 NULL
, RETURN_MASK_ERROR
) != 0)
807 /* Oops! Fake a current frame? Is this useful? It has a PC
808 of zero, for instance. */
809 current_frame
= sentinel_frame
;
812 return current_frame
;
815 /* The "selected" stack frame is used by default for local and arg
816 access. May be zero, for no selected frame. */
818 struct frame_info
*deprecated_selected_frame
;
820 /* Return the selected frame. Always non-NULL (unless there isn't an
821 inferior sufficient for creating a frame) in which case an error is
825 get_selected_frame (const char *message
)
827 if (deprecated_selected_frame
== NULL
)
829 if (message
!= NULL
&& (!target_has_registers
831 || !target_has_memory
))
832 error ("%s", message
);
833 /* Hey! Don't trust this. It should really be re-finding the
834 last selected frame of the currently selected thread. This,
835 though, is better than nothing. */
836 select_frame (get_current_frame ());
838 /* There is always a frame. */
839 gdb_assert (deprecated_selected_frame
!= NULL
);
840 return deprecated_selected_frame
;
843 /* This is a variant of get_selected_frame() which can be called when
844 the inferior does not have a frame; in that case it will return
845 NULL instead of calling error(). */
848 deprecated_safe_get_selected_frame (void)
850 if (!target_has_registers
|| !target_has_stack
|| !target_has_memory
)
852 return get_selected_frame (NULL
);
855 /* Select frame FI (or NULL - to invalidate the current frame). */
858 select_frame (struct frame_info
*fi
)
862 deprecated_selected_frame
= fi
;
863 /* NOTE: cagney/2002-05-04: FI can be NULL. This occurs when the
864 frame is being invalidated. */
865 if (deprecated_selected_frame_level_changed_hook
)
866 deprecated_selected_frame_level_changed_hook (frame_relative_level (fi
));
868 /* FIXME: kseitz/2002-08-28: It would be nice to call
869 selected_frame_level_changed_event() right here, but due to limitations
870 in the current interfaces, we would end up flooding UIs with events
871 because select_frame() is used extensively internally.
873 Once we have frame-parameterized frame (and frame-related) commands,
874 the event notification can be moved here, since this function will only
875 be called when the user's selected frame is being changed. */
877 /* Ensure that symbols for this frame are read in. Also, determine the
878 source language of this frame, and switch to it if desired. */
881 /* We retrieve the frame's symtab by using the frame PC. However
882 we cannot use the frame PC as-is, because it usually points to
883 the instruction following the "call", which is sometimes the
884 first instruction of another function. So we rely on
885 get_frame_address_in_block() which provides us with a PC which
886 is guaranteed to be inside the frame's code block. */
887 s
= find_pc_symtab (get_frame_address_in_block (fi
));
889 && s
->language
!= current_language
->la_language
890 && s
->language
!= language_unknown
891 && language_mode
== language_mode_auto
)
893 set_language (s
->language
);
898 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
899 Always returns a non-NULL value. */
902 create_new_frame (CORE_ADDR addr
, CORE_ADDR pc
)
904 struct frame_info
*fi
;
908 fprintf_unfiltered (gdb_stdlog
,
909 "{ create_new_frame (addr=0x%s, pc=0x%s) ",
910 paddr_nz (addr
), paddr_nz (pc
));
913 fi
= frame_obstack_zalloc (sizeof (struct frame_info
));
915 fi
->next
= create_sentinel_frame (current_regcache
);
917 /* Select/initialize both the unwind function and the frame's type
919 fi
->unwind
= frame_unwind_find_by_frame (fi
->next
, &fi
->prologue_cache
);
922 deprecated_update_frame_base_hack (fi
, addr
);
923 deprecated_update_frame_pc_hack (fi
, pc
);
927 fprintf_unfiltered (gdb_stdlog
, "-> ");
928 fprint_frame (gdb_stdlog
, fi
);
929 fprintf_unfiltered (gdb_stdlog
, " }\n");
935 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
936 innermost frame). Be careful to not fall off the bottom of the
937 frame chain and onto the sentinel frame. */
940 get_next_frame (struct frame_info
*this_frame
)
942 if (this_frame
->level
> 0)
943 return this_frame
->next
;
948 /* Observer for the target_changed event. */
951 frame_observer_target_changed (struct target_ops
*target
)
953 flush_cached_frames ();
956 /* Flush the entire frame cache. */
959 flush_cached_frames (void)
961 /* Since we can't really be sure what the first object allocated was */
962 obstack_free (&frame_cache_obstack
, 0);
963 obstack_init (&frame_cache_obstack
);
965 current_frame
= NULL
; /* Invalidate cache */
967 annotate_frames_invalid ();
969 fprintf_unfiltered (gdb_stdlog
, "{ flush_cached_frames () }\n");
972 /* Flush the frame cache, and start a new one if necessary. */
975 reinit_frame_cache (void)
977 flush_cached_frames ();
979 /* FIXME: The inferior_ptid test is wrong if there is a corefile. */
980 if (PIDGET (inferior_ptid
) != 0)
982 select_frame (get_current_frame ());
986 /* Return a "struct frame_info" corresponding to the frame that called
987 THIS_FRAME. Returns NULL if there is no such frame.
989 Unlike get_prev_frame, this function always tries to unwind the
992 static struct frame_info
*
993 get_prev_frame_1 (struct frame_info
*this_frame
)
995 struct frame_info
*prev_frame
;
996 struct frame_id this_id
;
998 gdb_assert (this_frame
!= NULL
);
1002 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame_1 (this_frame=");
1003 if (this_frame
!= NULL
)
1004 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1006 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1007 fprintf_unfiltered (gdb_stdlog
, ") ");
1010 /* Only try to do the unwind once. */
1011 if (this_frame
->prev_p
)
1015 fprintf_unfiltered (gdb_stdlog
, "-> ");
1016 fprint_frame (gdb_stdlog
, this_frame
->prev
);
1017 fprintf_unfiltered (gdb_stdlog
, " // cached \n");
1019 return this_frame
->prev
;
1021 this_frame
->prev_p
= 1;
1023 /* Check that this frame's ID was valid. If it wasn't, don't try to
1024 unwind to the prev frame. Be careful to not apply this test to
1025 the sentinel frame. */
1026 this_id
= get_frame_id (this_frame
);
1027 if (this_frame
->level
>= 0 && !frame_id_p (this_id
))
1031 fprintf_unfiltered (gdb_stdlog
, "-> ");
1032 fprint_frame (gdb_stdlog
, NULL
);
1033 fprintf_unfiltered (gdb_stdlog
, " // this ID is NULL }\n");
1038 /* Check that this frame's ID isn't inner to (younger, below, next)
1039 the next frame. This happens when a frame unwind goes backwards.
1040 Exclude signal trampolines (due to sigaltstack the frame ID can
1041 go backwards) and sentinel frames (the test is meaningless). */
1042 if (this_frame
->next
->level
>= 0
1043 && this_frame
->next
->unwind
->type
!= SIGTRAMP_FRAME
1044 && frame_id_inner (this_id
, get_frame_id (this_frame
->next
)))
1045 error ("Previous frame inner to this frame (corrupt stack?)");
1047 /* Check that this and the next frame are not identical. If they
1048 are, there is most likely a stack cycle. As with the inner-than
1049 test above, avoid comparing the inner-most and sentinel frames. */
1050 if (this_frame
->level
> 0
1051 && frame_id_eq (this_id
, get_frame_id (this_frame
->next
)))
1052 error ("Previous frame identical to this frame (corrupt stack?)");
1054 /* Allocate the new frame but do not wire it in to the frame chain.
1055 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
1056 frame->next to pull some fancy tricks (of course such code is, by
1057 definition, recursive). Try to prevent it.
1059 There is no reason to worry about memory leaks, should the
1060 remainder of the function fail. The allocated memory will be
1061 quickly reclaimed when the frame cache is flushed, and the `we've
1062 been here before' check above will stop repeated memory
1063 allocation calls. */
1064 prev_frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1065 prev_frame
->level
= this_frame
->level
+ 1;
1067 /* Don't yet compute ->unwind (and hence ->type). It is computed
1068 on-demand in get_frame_type, frame_register_unwind, and
1071 /* Don't yet compute the frame's ID. It is computed on-demand by
1074 /* The unwound frame ID is validate at the start of this function,
1075 as part of the logic to decide if that frame should be further
1076 unwound, and not here while the prev frame is being created.
1077 Doing this makes it possible for the user to examine a frame that
1078 has an invalid frame ID.
1080 Some very old VAX code noted: [...] For the sake of argument,
1081 suppose that the stack is somewhat trashed (which is one reason
1082 that "info frame" exists). So, return 0 (indicating we don't
1083 know the address of the arglist) if we don't know what frame this
1087 this_frame
->prev
= prev_frame
;
1088 prev_frame
->next
= this_frame
;
1092 fprintf_unfiltered (gdb_stdlog
, "-> ");
1093 fprint_frame (gdb_stdlog
, prev_frame
);
1094 fprintf_unfiltered (gdb_stdlog
, " }\n");
1100 /* Debug routine to print a NULL frame being returned. */
1103 frame_debug_got_null_frame (struct ui_file
*file
,
1104 struct frame_info
*this_frame
,
1109 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame (this_frame=");
1110 if (this_frame
!= NULL
)
1111 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1113 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1114 fprintf_unfiltered (gdb_stdlog
, ") -> // %s}\n", reason
);
1118 /* Is this (non-sentinel) frame in the "main"() function? */
1121 inside_main_func (struct frame_info
*this_frame
)
1123 struct minimal_symbol
*msymbol
;
1126 if (symfile_objfile
== 0)
1128 msymbol
= lookup_minimal_symbol (main_name (), NULL
, symfile_objfile
);
1129 if (msymbol
== NULL
)
1131 /* Make certain that the code, and not descriptor, address is
1133 maddr
= gdbarch_convert_from_func_ptr_addr (current_gdbarch
,
1134 SYMBOL_VALUE_ADDRESS (msymbol
),
1136 return maddr
== get_frame_func (this_frame
);
1139 /* Return a structure containing various interesting information about
1140 the frame that called THIS_FRAME. Returns NULL if there is entier
1141 no such frame or the frame fails any of a set of target-independent
1142 condition that should terminate the frame chain (e.g., as unwinding
1145 This function should not contain target-dependent tests, such as
1146 checking whether the program-counter is zero. */
1149 get_prev_frame (struct frame_info
*this_frame
)
1151 struct frame_info
*prev_frame
;
1153 /* Return the inner-most frame, when the caller passes in NULL. */
1154 /* NOTE: cagney/2002-11-09: Not sure how this would happen. The
1155 caller should have previously obtained a valid frame using
1156 get_selected_frame() and then called this code - only possibility
1157 I can think of is code behaving badly.
1159 NOTE: cagney/2003-01-10: Talk about code behaving badly. Check
1160 block_innermost_frame(). It does the sequence: frame = NULL;
1161 while (1) { frame = get_prev_frame (frame); .... }. Ulgh! Why
1162 it couldn't be written better, I don't know.
1164 NOTE: cagney/2003-01-11: I suspect what is happening in
1165 block_innermost_frame() is, when the target has no state
1166 (registers, memory, ...), it is still calling this function. The
1167 assumption being that this function will return NULL indicating
1168 that a frame isn't possible, rather than checking that the target
1169 has state and then calling get_current_frame() and
1170 get_prev_frame(). This is a guess mind. */
1171 if (this_frame
== NULL
)
1173 /* NOTE: cagney/2002-11-09: There was a code segment here that
1174 would error out when CURRENT_FRAME was NULL. The comment
1175 that went with it made the claim ...
1177 ``This screws value_of_variable, which just wants a nice
1178 clean NULL return from block_innermost_frame if there are no
1179 frames. I don't think I've ever seen this message happen
1180 otherwise. And returning NULL here is a perfectly legitimate
1183 Per the above, this code shouldn't even be called with a NULL
1185 frame_debug_got_null_frame (gdb_stdlog
, this_frame
, "this_frame NULL");
1186 return current_frame
;
1189 /* There is always a frame. If this assertion fails, suspect that
1190 something should be calling get_selected_frame() or
1191 get_current_frame(). */
1192 gdb_assert (this_frame
!= NULL
);
1194 if (this_frame
->level
>= 0
1195 && !backtrace_past_main
1196 && inside_main_func (this_frame
))
1197 /* Don't unwind past main(). Note, this is done _before_ the
1198 frame has been marked as previously unwound. That way if the
1199 user later decides to enable unwinds past main(), that will
1200 automatically happen. */
1202 frame_debug_got_null_frame (gdb_stdlog
, this_frame
, "inside main func");
1206 if (this_frame
->level
> backtrace_limit
)
1208 error ("Backtrace limit of %d exceeded", backtrace_limit
);
1211 /* If we're already inside the entry function for the main objfile,
1212 then it isn't valid. Don't apply this test to a dummy frame -
1213 dummy frame PCs typically land in the entry func. Don't apply
1214 this test to the sentinel frame. Sentinel frames should always
1215 be allowed to unwind. */
1216 /* NOTE: cagney/2003-02-25: Don't enable until someone has found
1217 hard evidence that this is needed. */
1218 /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() -
1219 wasn't checking for "main" in the minimal symbols. With that
1220 fixed asm-source tests now stop in "main" instead of halting the
1221 backtrace in weird and wonderful ways somewhere inside the entry
1222 file. Suspect that tests for inside the entry file/func were
1223 added to work around that (now fixed) case. */
1224 /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
1225 suggested having the inside_entry_func test use the
1226 inside_main_func() msymbol trick (along with entry_point_address()
1227 I guess) to determine the address range of the start function.
1228 That should provide a far better stopper than the current
1230 /* NOTE: cagney/2003-07-15: Need to add a "set backtrace
1231 beyond-entry-func" command so that this can be selectively
1235 && backtrace_beyond_entry_func
1237 && this_frame
->unwind
->type
!= DUMMY_FRAME
&& this_frame
->level
>= 0
1238 && inside_entry_func (this_frame
))
1240 frame_debug_got_null_frame (gdb_stdlog
, this_frame
, "inside entry func");
1244 return get_prev_frame_1 (this_frame
);
1248 get_frame_pc (struct frame_info
*frame
)
1250 gdb_assert (frame
->next
!= NULL
);
1251 return frame_pc_unwind (frame
->next
);
1254 /* Return an address of that falls within the frame's code block. */
1257 frame_unwind_address_in_block (struct frame_info
*next_frame
)
1259 /* A draft address. */
1260 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
1262 /* If THIS frame is not inner most (i.e., NEXT isn't the sentinel),
1263 and NEXT is `normal' (i.e., not a sigtramp, dummy, ....) THIS
1264 frame's PC ends up pointing at the instruction fallowing the
1265 "call". Adjust that PC value so that it falls on the call
1266 instruction (which, hopefully, falls within THIS frame's code
1267 block. So far it's proved to be a very good approximation. See
1268 get_frame_type() for why ->type can't be used. */
1269 if (next_frame
->level
>= 0
1270 && get_frame_type (next_frame
) == NORMAL_FRAME
)
1276 get_frame_address_in_block (struct frame_info
*this_frame
)
1278 return frame_unwind_address_in_block (this_frame
->next
);
1282 pc_notcurrent (struct frame_info
*frame
)
1284 /* If FRAME is not the innermost frame, that normally means that
1285 FRAME->pc points at the return instruction (which is *after* the
1286 call instruction), and we want to get the line containing the
1287 call (because the call is where the user thinks the program is).
1288 However, if the next frame is either a SIGTRAMP_FRAME or a
1289 DUMMY_FRAME, then the next frame will contain a saved interrupt
1290 PC and such a PC indicates the current (rather than next)
1291 instruction/line, consequently, for such cases, want to get the
1292 line containing fi->pc. */
1293 struct frame_info
*next
= get_next_frame (frame
);
1294 int notcurrent
= (next
!= NULL
&& get_frame_type (next
) == NORMAL_FRAME
);
1299 find_frame_sal (struct frame_info
*frame
, struct symtab_and_line
*sal
)
1301 (*sal
) = find_pc_line (get_frame_pc (frame
), pc_notcurrent (frame
));
1304 /* Per "frame.h", return the ``address'' of the frame. Code should
1305 really be using get_frame_id(). */
1307 get_frame_base (struct frame_info
*fi
)
1309 return get_frame_id (fi
).stack_addr
;
1312 /* High-level offsets into the frame. Used by the debug info. */
1315 get_frame_base_address (struct frame_info
*fi
)
1317 if (get_frame_type (fi
) != NORMAL_FRAME
)
1319 if (fi
->base
== NULL
)
1320 fi
->base
= frame_base_find_by_frame (fi
->next
);
1321 /* Sneaky: If the low-level unwind and high-level base code share a
1322 common unwinder, let them share the prologue cache. */
1323 if (fi
->base
->unwind
== fi
->unwind
)
1324 return fi
->base
->this_base (fi
->next
, &fi
->prologue_cache
);
1325 return fi
->base
->this_base (fi
->next
, &fi
->base_cache
);
1329 get_frame_locals_address (struct frame_info
*fi
)
1332 if (get_frame_type (fi
) != NORMAL_FRAME
)
1334 /* If there isn't a frame address method, find it. */
1335 if (fi
->base
== NULL
)
1336 fi
->base
= frame_base_find_by_frame (fi
->next
);
1337 /* Sneaky: If the low-level unwind and high-level base code share a
1338 common unwinder, let them share the prologue cache. */
1339 if (fi
->base
->unwind
== fi
->unwind
)
1340 cache
= &fi
->prologue_cache
;
1342 cache
= &fi
->base_cache
;
1343 return fi
->base
->this_locals (fi
->next
, cache
);
1347 get_frame_args_address (struct frame_info
*fi
)
1350 if (get_frame_type (fi
) != NORMAL_FRAME
)
1352 /* If there isn't a frame address method, find it. */
1353 if (fi
->base
== NULL
)
1354 fi
->base
= frame_base_find_by_frame (fi
->next
);
1355 /* Sneaky: If the low-level unwind and high-level base code share a
1356 common unwinder, let them share the prologue cache. */
1357 if (fi
->base
->unwind
== fi
->unwind
)
1358 cache
= &fi
->prologue_cache
;
1360 cache
= &fi
->base_cache
;
1361 return fi
->base
->this_args (fi
->next
, cache
);
1364 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
1365 or -1 for a NULL frame. */
1368 frame_relative_level (struct frame_info
*fi
)
1377 get_frame_type (struct frame_info
*frame
)
1379 if (frame
->unwind
== NULL
)
1380 /* Initialize the frame's unwinder because that's what
1381 provides the frame's type. */
1382 frame
->unwind
= frame_unwind_find_by_frame (frame
->next
,
1383 &frame
->prologue_cache
);
1384 return frame
->unwind
->type
;
1388 deprecated_update_frame_pc_hack (struct frame_info
*frame
, CORE_ADDR pc
)
1391 fprintf_unfiltered (gdb_stdlog
,
1392 "{ deprecated_update_frame_pc_hack (frame=%d,pc=0x%s) }\n",
1393 frame
->level
, paddr_nz (pc
));
1394 /* NOTE: cagney/2003-03-11: Some architectures (e.g., Arm) are
1395 maintaining a locally allocated frame object. Since such frames
1396 are not in the frame chain, it isn't possible to assume that the
1397 frame has a next. Sigh. */
1398 if (frame
->next
!= NULL
)
1400 /* While we're at it, update this frame's cached PC value, found
1401 in the next frame. Oh for the day when "struct frame_info"
1402 is opaque and this hack on hack can just go away. */
1403 frame
->next
->prev_pc
.value
= pc
;
1404 frame
->next
->prev_pc
.p
= 1;
1409 deprecated_update_frame_base_hack (struct frame_info
*frame
, CORE_ADDR base
)
1412 fprintf_unfiltered (gdb_stdlog
,
1413 "{ deprecated_update_frame_base_hack (frame=%d,base=0x%s) }\n",
1414 frame
->level
, paddr_nz (base
));
1415 /* See comment in "frame.h". */
1416 frame
->this_id
.value
.stack_addr
= base
;
1419 /* Memory access methods. */
1422 get_frame_memory (struct frame_info
*this_frame
, CORE_ADDR addr
, void *buf
,
1425 read_memory (addr
, buf
, len
);
1429 get_frame_memory_signed (struct frame_info
*this_frame
, CORE_ADDR addr
,
1432 return read_memory_integer (addr
, len
);
1436 get_frame_memory_unsigned (struct frame_info
*this_frame
, CORE_ADDR addr
,
1439 return read_memory_unsigned_integer (addr
, len
);
1443 safe_frame_unwind_memory (struct frame_info
*this_frame
,
1444 CORE_ADDR addr
, void *buf
, int len
)
1446 /* NOTE: deprecated_read_memory_nobpt returns zero on success! */
1447 return !deprecated_read_memory_nobpt (addr
, buf
, len
);
1450 /* Architecture method. */
1453 get_frame_arch (struct frame_info
*this_frame
)
1455 return current_gdbarch
;
1458 /* Stack pointer methods. */
1461 get_frame_sp (struct frame_info
*this_frame
)
1463 return frame_sp_unwind (this_frame
->next
);
1467 frame_sp_unwind (struct frame_info
*next_frame
)
1469 /* Normality - an architecture that provides a way of obtaining any
1470 frame inner-most address. */
1471 if (gdbarch_unwind_sp_p (current_gdbarch
))
1472 return gdbarch_unwind_sp (current_gdbarch
, next_frame
);
1473 /* Things are looking grim. If it's the inner-most frame and there
1474 is a TARGET_READ_SP, then that can be used. */
1475 if (next_frame
->level
< 0 && TARGET_READ_SP_P ())
1476 return TARGET_READ_SP ();
1477 /* Now things are really are grim. Hope that the value returned by
1478 the SP_REGNUM register is meaningful. */
1482 frame_unwind_unsigned_register (next_frame
, SP_REGNUM
, &sp
);
1485 internal_error (__FILE__
, __LINE__
, "Missing unwind SP method");
1488 extern initialize_file_ftype _initialize_frame
; /* -Wmissing-prototypes */
1490 static struct cmd_list_element
*set_backtrace_cmdlist
;
1491 static struct cmd_list_element
*show_backtrace_cmdlist
;
1494 set_backtrace_cmd (char *args
, int from_tty
)
1496 help_list (set_backtrace_cmdlist
, "set backtrace ", -1, gdb_stdout
);
1500 show_backtrace_cmd (char *args
, int from_tty
)
1502 cmd_show_list (show_backtrace_cmdlist
, from_tty
, "");
1506 _initialize_frame (void)
1508 obstack_init (&frame_cache_obstack
);
1510 observer_attach_target_changed (frame_observer_target_changed
);
1512 add_prefix_cmd ("backtrace", class_maintenance
, set_backtrace_cmd
, "\
1513 Set backtrace specific variables.\n\
1514 Configure backtrace variables such as the backtrace limit",
1515 &set_backtrace_cmdlist
, "set backtrace ",
1516 0/*allow-unknown*/, &setlist
);
1517 add_prefix_cmd ("backtrace", class_maintenance
, show_backtrace_cmd
, "\
1518 Show backtrace specific variables\n\
1519 Show backtrace variables such as the backtrace limit",
1520 &show_backtrace_cmdlist
, "show backtrace ",
1521 0/*allow-unknown*/, &showlist
);
1523 add_setshow_boolean_cmd ("past-main", class_obscure
,
1524 &backtrace_past_main
, "\
1525 Set whether backtraces should continue past \"main\".", "\
1526 Show whether backtraces should continue past \"main\".", "\
1527 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
1528 the backtrace at \"main\". Set this variable if you need to see the rest\n\
1529 of the stack trace.", "\
1530 Whether backtraces should continue past \"main\" is %s.",
1531 NULL
, NULL
, &set_backtrace_cmdlist
,
1532 &show_backtrace_cmdlist
);
1534 add_setshow_uinteger_cmd ("limit", class_obscure
,
1535 &backtrace_limit
, "\
1536 Set an upper bound on the number of backtrace levels.", "\
1537 Show the upper bound on the number of backtrace levels.", "\
1538 No more than the specified number of frames can be displayed or examined.\n\
1539 Zero is unlimited.", "\
1540 An upper bound on the number of backtrace levels is %s.",
1541 NULL
, NULL
, &set_backtrace_cmdlist
,
1542 &show_backtrace_cmdlist
);
1544 /* Debug this files internals. */
1545 deprecated_add_show_from_set
1546 (add_set_cmd ("frame", class_maintenance
, var_zinteger
,
1547 &frame_debug
, "Set frame debugging.\n\
1548 When non-zero, frame specific internal debugging is enabled.", &setdebuglist
),