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 /* The frame's low-level unwinder and corresponding cache. The
70 low-level unwinder is responsible for unwinding register values
71 for the previous frame. The low-level unwind methods are
72 selected based on the presence, or otherwise, of register unwind
73 information such as CFI. */
75 const struct frame_unwind
*unwind
;
77 /* Cached copy of the previous frame's resume address. */
83 /* Cached copy of the previous frame's function address. */
90 /* This frame's ID. */
94 struct frame_id value
;
97 /* The frame's high-level base methods, and corresponding cache.
98 The high level base methods are selected based on the frame's
100 const struct frame_base
*base
;
103 /* Pointers to the next (down, inner, younger) and previous (up,
104 outer, older) frame_info's in the frame cache. */
105 struct frame_info
*next
; /* down, inner, younger */
107 struct frame_info
*prev
; /* up, outer, older */
110 /* Flag to control debugging. */
112 static int frame_debug
;
114 /* Flag to indicate whether backtraces should stop at main et.al. */
116 static int backtrace_past_main
;
117 static unsigned int backtrace_limit
= UINT_MAX
;
120 fprint_field (struct ui_file
*file
, const char *name
, int p
, CORE_ADDR addr
)
123 fprintf_unfiltered (file
, "%s=0x%s", name
, paddr_nz (addr
));
125 fprintf_unfiltered (file
, "!%s", name
);
129 fprint_frame_id (struct ui_file
*file
, struct frame_id id
)
131 fprintf_unfiltered (file
, "{");
132 fprint_field (file
, "stack", id
.stack_addr_p
, id
.stack_addr
);
133 fprintf_unfiltered (file
, ",");
134 fprint_field (file
, "code", id
.code_addr_p
, id
.code_addr
);
135 fprintf_unfiltered (file
, ",");
136 fprint_field (file
, "special", id
.special_addr_p
, id
.special_addr
);
137 fprintf_unfiltered (file
, "}");
141 fprint_frame_type (struct ui_file
*file
, enum frame_type type
)
146 fprintf_unfiltered (file
, "NORMAL_FRAME");
149 fprintf_unfiltered (file
, "DUMMY_FRAME");
152 fprintf_unfiltered (file
, "SIGTRAMP_FRAME");
155 fprintf_unfiltered (file
, "<unknown type>");
161 fprint_frame (struct ui_file
*file
, struct frame_info
*fi
)
165 fprintf_unfiltered (file
, "<NULL frame>");
168 fprintf_unfiltered (file
, "{");
169 fprintf_unfiltered (file
, "level=%d", fi
->level
);
170 fprintf_unfiltered (file
, ",");
171 fprintf_unfiltered (file
, "type=");
172 if (fi
->unwind
!= NULL
)
173 fprint_frame_type (file
, fi
->unwind
->type
);
175 fprintf_unfiltered (file
, "<unknown>");
176 fprintf_unfiltered (file
, ",");
177 fprintf_unfiltered (file
, "unwind=");
178 if (fi
->unwind
!= NULL
)
179 gdb_print_host_address (fi
->unwind
, file
);
181 fprintf_unfiltered (file
, "<unknown>");
182 fprintf_unfiltered (file
, ",");
183 fprintf_unfiltered (file
, "pc=");
184 if (fi
->next
!= NULL
&& fi
->next
->prev_pc
.p
)
185 fprintf_unfiltered (file
, "0x%s", paddr_nz (fi
->next
->prev_pc
.value
));
187 fprintf_unfiltered (file
, "<unknown>");
188 fprintf_unfiltered (file
, ",");
189 fprintf_unfiltered (file
, "id=");
191 fprint_frame_id (file
, fi
->this_id
.value
);
193 fprintf_unfiltered (file
, "<unknown>");
194 fprintf_unfiltered (file
, ",");
195 fprintf_unfiltered (file
, "func=");
196 if (fi
->next
!= NULL
&& fi
->next
->prev_func
.p
)
197 fprintf_unfiltered (file
, "0x%s", paddr_nz (fi
->next
->prev_func
.addr
));
199 fprintf_unfiltered (file
, "<unknown>");
200 fprintf_unfiltered (file
, "}");
203 /* Return a frame uniq ID that can be used to, later, re-find the
207 get_frame_id (struct frame_info
*fi
)
211 return null_frame_id
;
216 fprintf_unfiltered (gdb_stdlog
, "{ get_frame_id (fi=%d) ",
218 /* Find the unwinder. */
219 if (fi
->unwind
== NULL
)
220 fi
->unwind
= frame_unwind_find_by_frame (fi
->next
,
221 &fi
->prologue_cache
);
222 /* Find THIS frame's ID. */
223 fi
->unwind
->this_id (fi
->next
, &fi
->prologue_cache
, &fi
->this_id
.value
);
227 fprintf_unfiltered (gdb_stdlog
, "-> ");
228 fprint_frame_id (gdb_stdlog
, fi
->this_id
.value
);
229 fprintf_unfiltered (gdb_stdlog
, " }\n");
232 return fi
->this_id
.value
;
236 frame_unwind_id (struct frame_info
*next_frame
)
238 /* Use prev_frame, and not get_prev_frame. The latter will truncate
239 the frame chain, leading to this function unintentionally
240 returning a null_frame_id (e.g., when a caller requests the frame
241 ID of "main()"s caller. */
242 return get_frame_id (get_prev_frame_1 (next_frame
));
245 const struct frame_id null_frame_id
; /* All zeros. */
248 frame_id_build_special (CORE_ADDR stack_addr
, CORE_ADDR code_addr
,
249 CORE_ADDR special_addr
)
251 struct frame_id id
= null_frame_id
;
252 id
.stack_addr
= stack_addr
;
254 id
.code_addr
= code_addr
;
256 id
.special_addr
= special_addr
;
257 id
.special_addr_p
= 1;
262 frame_id_build (CORE_ADDR stack_addr
, CORE_ADDR code_addr
)
264 struct frame_id id
= null_frame_id
;
265 id
.stack_addr
= stack_addr
;
267 id
.code_addr
= code_addr
;
273 frame_id_build_wild (CORE_ADDR stack_addr
)
275 struct frame_id id
= null_frame_id
;
276 id
.stack_addr
= stack_addr
;
282 frame_id_p (struct frame_id l
)
285 /* The frame is valid iff it has a valid stack address. */
289 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_p (l=");
290 fprint_frame_id (gdb_stdlog
, l
);
291 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", p
);
297 frame_id_eq (struct frame_id l
, struct frame_id r
)
300 if (!l
.stack_addr_p
|| !r
.stack_addr_p
)
301 /* Like a NaN, if either ID is invalid, the result is false.
302 Note that a frame ID is invalid iff it is the null frame ID. */
304 else if (l
.stack_addr
!= r
.stack_addr
)
305 /* If .stack addresses are different, the frames are different. */
307 else if (!l
.code_addr_p
|| !r
.code_addr_p
)
308 /* An invalid code addr is a wild card, always succeed. */
310 else if (l
.code_addr
!= r
.code_addr
)
311 /* If .code addresses are different, the frames are different. */
313 else if (!l
.special_addr_p
|| !r
.special_addr_p
)
314 /* An invalid special addr is a wild card (or unused), always succeed. */
316 else if (l
.special_addr
== r
.special_addr
)
317 /* Frames are equal. */
324 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_eq (l=");
325 fprint_frame_id (gdb_stdlog
, l
);
326 fprintf_unfiltered (gdb_stdlog
, ",r=");
327 fprint_frame_id (gdb_stdlog
, r
);
328 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", eq
);
334 frame_id_inner (struct frame_id l
, struct frame_id r
)
337 if (!l
.stack_addr_p
|| !r
.stack_addr_p
)
338 /* Like NaN, any operation involving an invalid ID always fails. */
341 /* Only return non-zero when strictly inner than. Note that, per
342 comment in "frame.h", there is some fuzz here. Frameless
343 functions are not strictly inner than (same .stack but
344 different .code and/or .special address). */
345 inner
= INNER_THAN (l
.stack_addr
, r
.stack_addr
);
348 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_inner (l=");
349 fprint_frame_id (gdb_stdlog
, l
);
350 fprintf_unfiltered (gdb_stdlog
, ",r=");
351 fprint_frame_id (gdb_stdlog
, r
);
352 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", inner
);
358 frame_find_by_id (struct frame_id id
)
360 struct frame_info
*frame
;
362 /* ZERO denotes the null frame, let the caller decide what to do
363 about it. Should it instead return get_current_frame()? */
364 if (!frame_id_p (id
))
367 for (frame
= get_current_frame ();
369 frame
= get_prev_frame (frame
))
371 struct frame_id
this = get_frame_id (frame
);
372 if (frame_id_eq (id
, this))
373 /* An exact match. */
375 if (frame_id_inner (id
, this))
378 /* Either we're not yet gone far enough out along the frame
379 chain (inner(this,id)), or we're comparing frameless functions
380 (same .base, different .func, no test available). Struggle
381 on until we've definitly gone to far. */
387 frame_pc_unwind (struct frame_info
*this_frame
)
389 if (!this_frame
->prev_pc
.p
)
392 if (gdbarch_unwind_pc_p (current_gdbarch
))
394 /* The right way. The `pure' way. The one true way. This
395 method depends solely on the register-unwind code to
396 determine the value of registers in THIS frame, and hence
397 the value of this frame's PC (resume address). A typical
398 implementation is no more than:
400 frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
401 return extract_unsigned_integer (buf, size of ISA_PC_REGNUM);
403 Note: this method is very heavily dependent on a correct
404 register-unwind implementation, it pays to fix that
405 method first; this method is frame type agnostic, since
406 it only deals with register values, it works with any
407 frame. This is all in stark contrast to the old
408 FRAME_SAVED_PC which would try to directly handle all the
409 different ways that a PC could be unwound. */
410 pc
= gdbarch_unwind_pc (current_gdbarch
, this_frame
);
412 else if (this_frame
->level
< 0)
414 /* FIXME: cagney/2003-03-06: Old code and a sentinel
415 frame. Do like was always done. Fetch the PC's value
416 directly from the global registers array (via read_pc).
417 This assumes that this frame belongs to the current
418 global register cache. The assumption is dangerous. */
422 internal_error (__FILE__
, __LINE__
, "No gdbarch_unwind_pc method");
423 this_frame
->prev_pc
.value
= pc
;
424 this_frame
->prev_pc
.p
= 1;
426 fprintf_unfiltered (gdb_stdlog
,
427 "{ frame_pc_unwind (this_frame=%d) -> 0x%s }\n",
429 paddr_nz (this_frame
->prev_pc
.value
));
431 return this_frame
->prev_pc
.value
;
435 frame_func_unwind (struct frame_info
*fi
)
437 if (!fi
->prev_func
.p
)
439 /* Make certain that this, and not the adjacent, function is
441 CORE_ADDR addr_in_block
= frame_unwind_address_in_block (fi
);
443 fi
->prev_func
.addr
= get_pc_function_start (addr_in_block
);
445 fprintf_unfiltered (gdb_stdlog
,
446 "{ frame_func_unwind (fi=%d) -> 0x%s }\n",
447 fi
->level
, paddr_nz (fi
->prev_func
.addr
));
449 return fi
->prev_func
.addr
;
453 get_frame_func (struct frame_info
*fi
)
455 return frame_func_unwind (fi
->next
);
459 do_frame_register_read (void *src
, int regnum
, void *buf
)
461 frame_register_read (src
, regnum
, buf
);
466 frame_save_as_regcache (struct frame_info
*this_frame
)
468 struct regcache
*regcache
= regcache_xmalloc (current_gdbarch
);
469 struct cleanup
*cleanups
= make_cleanup_regcache_xfree (regcache
);
470 regcache_save (regcache
, do_frame_register_read
, this_frame
);
471 discard_cleanups (cleanups
);
476 frame_pop (struct frame_info
*this_frame
)
478 /* Make a copy of all the register values unwound from this frame.
479 Save them in a scratch buffer so that there isn't a race between
480 trying to extract the old values from the current_regcache while
481 at the same time writing new values into that same cache. */
482 struct regcache
*scratch
483 = frame_save_as_regcache (get_prev_frame_1 (this_frame
));
484 struct cleanup
*cleanups
= make_cleanup_regcache_xfree (scratch
);
486 /* FIXME: cagney/2003-03-16: It should be possible to tell the
487 target's register cache that it is about to be hit with a burst
488 register transfer and that the sequence of register writes should
489 be batched. The pair target_prepare_to_store() and
490 target_store_registers() kind of suggest this functionality.
491 Unfortunately, they don't implement it. Their lack of a formal
492 definition can lead to targets writing back bogus values
493 (arguably a bug in the target code mind). */
494 /* Now copy those saved registers into the current regcache.
495 Here, regcache_cpy() calls regcache_restore(). */
496 regcache_cpy (current_regcache
, scratch
);
497 do_cleanups (cleanups
);
499 /* We've made right mess of GDB's local state, just discard
501 flush_cached_frames ();
505 frame_register_unwind (struct frame_info
*frame
, int regnum
,
506 int *optimizedp
, enum lval_type
*lvalp
,
507 CORE_ADDR
*addrp
, int *realnump
, void *bufferp
)
509 struct frame_unwind_cache
*cache
;
513 fprintf_unfiltered (gdb_stdlog
, "\
514 { frame_register_unwind (frame=%d,regnum=%d(%s),...) ",
515 frame
->level
, regnum
,
516 frame_map_regnum_to_name (frame
, regnum
));
519 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
520 that the value proper does not need to be fetched. */
521 gdb_assert (optimizedp
!= NULL
);
522 gdb_assert (lvalp
!= NULL
);
523 gdb_assert (addrp
!= NULL
);
524 gdb_assert (realnump
!= NULL
);
525 /* gdb_assert (bufferp != NULL); */
527 /* NOTE: cagney/2002-11-27: A program trying to unwind a NULL frame
528 is broken. There is always a frame. If there, for some reason,
529 isn't a frame, there is some pretty busted code as it should have
530 detected the problem before calling here. */
531 gdb_assert (frame
!= NULL
);
533 /* Find the unwinder. */
534 if (frame
->unwind
== NULL
)
535 frame
->unwind
= frame_unwind_find_by_frame (frame
->next
,
536 &frame
->prologue_cache
);
538 /* Ask this frame to unwind its register. See comment in
539 "frame-unwind.h" for why NEXT frame and this unwind cache are
541 frame
->unwind
->prev_register (frame
->next
, &frame
->prologue_cache
, regnum
,
542 optimizedp
, lvalp
, addrp
, realnump
, bufferp
);
546 fprintf_unfiltered (gdb_stdlog
, "->");
547 fprintf_unfiltered (gdb_stdlog
, " *optimizedp=%d", (*optimizedp
));
548 fprintf_unfiltered (gdb_stdlog
, " *lvalp=%d", (int) (*lvalp
));
549 fprintf_unfiltered (gdb_stdlog
, " *addrp=0x%s", paddr_nz ((*addrp
)));
550 fprintf_unfiltered (gdb_stdlog
, " *bufferp=");
552 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
556 const unsigned char *buf
= bufferp
;
557 fprintf_unfiltered (gdb_stdlog
, "[");
558 for (i
= 0; i
< register_size (current_gdbarch
, regnum
); i
++)
559 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
560 fprintf_unfiltered (gdb_stdlog
, "]");
562 fprintf_unfiltered (gdb_stdlog
, " }\n");
567 frame_register (struct frame_info
*frame
, int regnum
,
568 int *optimizedp
, enum lval_type
*lvalp
,
569 CORE_ADDR
*addrp
, int *realnump
, void *bufferp
)
571 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
572 that the value proper does not need to be fetched. */
573 gdb_assert (optimizedp
!= NULL
);
574 gdb_assert (lvalp
!= NULL
);
575 gdb_assert (addrp
!= NULL
);
576 gdb_assert (realnump
!= NULL
);
577 /* gdb_assert (bufferp != NULL); */
579 /* Obtain the register value by unwinding the register from the next
580 (more inner frame). */
581 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
582 frame_register_unwind (frame
->next
, regnum
, optimizedp
, lvalp
, addrp
,
587 frame_unwind_register (struct frame_info
*frame
, int regnum
, void *buf
)
593 frame_register_unwind (frame
, regnum
, &optimized
, &lval
, &addr
,
598 get_frame_register (struct frame_info
*frame
,
599 int regnum
, void *buf
)
601 frame_unwind_register (frame
->next
, regnum
, buf
);
605 frame_unwind_register_signed (struct frame_info
*frame
, int regnum
)
607 char buf
[MAX_REGISTER_SIZE
];
608 frame_unwind_register (frame
, regnum
, buf
);
609 return extract_signed_integer (buf
, register_size (get_frame_arch (frame
),
614 get_frame_register_signed (struct frame_info
*frame
, int regnum
)
616 return frame_unwind_register_signed (frame
->next
, regnum
);
620 frame_unwind_register_unsigned (struct frame_info
*frame
, int regnum
)
622 char buf
[MAX_REGISTER_SIZE
];
623 frame_unwind_register (frame
, regnum
, buf
);
624 return extract_unsigned_integer (buf
, register_size (get_frame_arch (frame
),
629 get_frame_register_unsigned (struct frame_info
*frame
, int regnum
)
631 return frame_unwind_register_unsigned (frame
->next
, regnum
);
635 frame_unwind_unsigned_register (struct frame_info
*frame
, int regnum
,
638 char buf
[MAX_REGISTER_SIZE
];
639 frame_unwind_register (frame
, regnum
, buf
);
640 (*val
) = extract_unsigned_integer (buf
,
641 register_size (get_frame_arch (frame
),
646 put_frame_register (struct frame_info
*frame
, int regnum
, const void *buf
)
648 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
653 frame_register (frame
, regnum
, &optim
, &lval
, &addr
, &realnum
, NULL
);
655 error ("Attempt to assign to a value that was optimized out.");
660 /* FIXME: write_memory doesn't yet take constant buffers.
662 char tmp
[MAX_REGISTER_SIZE
];
663 memcpy (tmp
, buf
, register_size (gdbarch
, regnum
));
664 write_memory (addr
, tmp
, register_size (gdbarch
, regnum
));
668 regcache_cooked_write (current_regcache
, realnum
, buf
);
671 error ("Attempt to assign to an unmodifiable value.");
675 /* frame_register_read ()
677 Find and return the value of REGNUM for the specified stack frame.
678 The number of bytes copied is REGISTER_SIZE (REGNUM).
680 Returns 0 if the register value could not be found. */
683 frame_register_read (struct frame_info
*frame
, int regnum
, void *myaddr
)
689 frame_register (frame
, regnum
, &optimized
, &lval
, &addr
, &realnum
, myaddr
);
691 /* FIXME: cagney/2002-05-15: This test is just bogus.
693 It indicates that the target failed to supply a value for a
694 register because it was "not available" at this time. Problem
695 is, the target still has the register and so get saved_register()
696 may be returning a value saved on the stack. */
698 if (register_cached (regnum
) < 0)
699 return 0; /* register value not available */
705 /* Map between a frame register number and its name. A frame register
706 space is a superset of the cooked register space --- it also
707 includes builtin registers. */
710 frame_map_name_to_regnum (struct frame_info
*frame
, const char *name
, int len
)
712 return user_reg_map_name_to_regnum (get_frame_arch (frame
), name
, len
);
716 frame_map_regnum_to_name (struct frame_info
*frame
, int regnum
)
718 return user_reg_map_regnum_to_name (get_frame_arch (frame
), regnum
);
721 /* Create a sentinel frame. */
723 static struct frame_info
*
724 create_sentinel_frame (struct regcache
*regcache
)
726 struct frame_info
*frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
728 /* Explicitly initialize the sentinel frame's cache. Provide it
729 with the underlying regcache. In the future additional
730 information, such as the frame's thread will be added. */
731 frame
->prologue_cache
= sentinel_frame_cache (regcache
);
732 /* For the moment there is only one sentinel frame implementation. */
733 frame
->unwind
= sentinel_frame_unwind
;
734 /* Link this frame back to itself. The frame is self referential
735 (the unwound PC is the same as the pc), so make it so. */
737 /* Make the sentinel frame's ID valid, but invalid. That way all
738 comparisons with it should fail. */
739 frame
->this_id
.p
= 1;
740 frame
->this_id
.value
= null_frame_id
;
743 fprintf_unfiltered (gdb_stdlog
, "{ create_sentinel_frame (...) -> ");
744 fprint_frame (gdb_stdlog
, frame
);
745 fprintf_unfiltered (gdb_stdlog
, " }\n");
750 /* Info about the innermost stack frame (contents of FP register) */
752 static struct frame_info
*current_frame
;
754 /* Cache for frame addresses already read by gdb. Valid only while
755 inferior is stopped. Control variables for the frame cache should
756 be local to this module. */
758 static struct obstack frame_cache_obstack
;
761 frame_obstack_zalloc (unsigned long size
)
763 void *data
= obstack_alloc (&frame_cache_obstack
, size
);
764 memset (data
, 0, size
);
768 /* Return the innermost (currently executing) stack frame. This is
769 split into two functions. The function unwind_to_current_frame()
770 is wrapped in catch exceptions so that, even when the unwind of the
771 sentinel frame fails, the function still returns a stack frame. */
774 unwind_to_current_frame (struct ui_out
*ui_out
, void *args
)
776 struct frame_info
*frame
= get_prev_frame (args
);
777 /* A sentinel frame can fail to unwind, e.g., because its PC value
778 lands in somewhere like start. */
781 current_frame
= frame
;
786 get_current_frame (void)
788 /* First check, and report, the lack of registers. Having GDB
789 report "No stack!" or "No memory" when the target doesn't even
790 have registers is very confusing. Besides, "printcmd.exp"
791 explicitly checks that ``print $pc'' with no registers prints "No
793 if (!target_has_registers
)
794 error ("No registers.");
795 if (!target_has_stack
)
797 if (!target_has_memory
)
798 error ("No memory.");
799 if (current_frame
== NULL
)
801 struct frame_info
*sentinel_frame
=
802 create_sentinel_frame (current_regcache
);
803 if (catch_exceptions (uiout
, unwind_to_current_frame
, sentinel_frame
,
804 NULL
, RETURN_MASK_ERROR
) != 0)
806 /* Oops! Fake a current frame? Is this useful? It has a PC
807 of zero, for instance. */
808 current_frame
= sentinel_frame
;
811 return current_frame
;
814 /* The "selected" stack frame is used by default for local and arg
815 access. May be zero, for no selected frame. */
817 struct frame_info
*deprecated_selected_frame
;
819 /* Return the selected frame. Always non-NULL (unless there isn't an
820 inferior sufficient for creating a frame) in which case an error is
824 get_selected_frame (void)
826 if (deprecated_selected_frame
== NULL
)
827 /* Hey! Don't trust this. It should really be re-finding the
828 last selected frame of the currently selected thread. This,
829 though, is better than nothing. */
830 select_frame (get_current_frame ());
831 /* There is always a frame. */
832 gdb_assert (deprecated_selected_frame
!= NULL
);
833 return deprecated_selected_frame
;
836 /* This is a variant of get_selected_frame() which can be called when
837 the inferior does not have a frame; in that case it will return
838 NULL instead of calling error(). */
841 deprecated_safe_get_selected_frame (void)
843 if (!target_has_registers
|| !target_has_stack
|| !target_has_memory
)
845 return get_selected_frame ();
848 /* Select frame FI (or NULL - to invalidate the current frame). */
851 select_frame (struct frame_info
*fi
)
855 deprecated_selected_frame
= fi
;
856 /* NOTE: cagney/2002-05-04: FI can be NULL. This occurs when the
857 frame is being invalidated. */
858 if (deprecated_selected_frame_level_changed_hook
)
859 deprecated_selected_frame_level_changed_hook (frame_relative_level (fi
));
861 /* FIXME: kseitz/2002-08-28: It would be nice to call
862 selected_frame_level_changed_event() right here, but due to limitations
863 in the current interfaces, we would end up flooding UIs with events
864 because select_frame() is used extensively internally.
866 Once we have frame-parameterized frame (and frame-related) commands,
867 the event notification can be moved here, since this function will only
868 be called when the user's selected frame is being changed. */
870 /* Ensure that symbols for this frame are read in. Also, determine the
871 source language of this frame, and switch to it if desired. */
874 /* We retrieve the frame's symtab by using the frame PC. However
875 we cannot use the frame PC as-is, because it usually points to
876 the instruction following the "call", which is sometimes the
877 first instruction of another function. So we rely on
878 get_frame_address_in_block() which provides us with a PC which
879 is guaranteed to be inside the frame's code block. */
880 s
= find_pc_symtab (get_frame_address_in_block (fi
));
882 && s
->language
!= current_language
->la_language
883 && s
->language
!= language_unknown
884 && language_mode
== language_mode_auto
)
886 set_language (s
->language
);
891 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
892 Always returns a non-NULL value. */
895 create_new_frame (CORE_ADDR addr
, CORE_ADDR pc
)
897 struct frame_info
*fi
;
901 fprintf_unfiltered (gdb_stdlog
,
902 "{ create_new_frame (addr=0x%s, pc=0x%s) ",
903 paddr_nz (addr
), paddr_nz (pc
));
906 fi
= frame_obstack_zalloc (sizeof (struct frame_info
));
908 fi
->next
= create_sentinel_frame (current_regcache
);
910 /* Select/initialize both the unwind function and the frame's type
912 fi
->unwind
= frame_unwind_find_by_frame (fi
->next
, &fi
->prologue_cache
);
915 deprecated_update_frame_base_hack (fi
, addr
);
916 deprecated_update_frame_pc_hack (fi
, pc
);
920 fprintf_unfiltered (gdb_stdlog
, "-> ");
921 fprint_frame (gdb_stdlog
, fi
);
922 fprintf_unfiltered (gdb_stdlog
, " }\n");
928 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
929 innermost frame). Be careful to not fall off the bottom of the
930 frame chain and onto the sentinel frame. */
933 get_next_frame (struct frame_info
*this_frame
)
935 if (this_frame
->level
> 0)
936 return this_frame
->next
;
941 /* Observer for the target_changed event. */
944 frame_observer_target_changed (struct target_ops
*target
)
946 flush_cached_frames ();
949 /* Flush the entire frame cache. */
952 flush_cached_frames (void)
954 /* Since we can't really be sure what the first object allocated was */
955 obstack_free (&frame_cache_obstack
, 0);
956 obstack_init (&frame_cache_obstack
);
958 current_frame
= NULL
; /* Invalidate cache */
960 annotate_frames_invalid ();
962 fprintf_unfiltered (gdb_stdlog
, "{ flush_cached_frames () }\n");
965 /* Flush the frame cache, and start a new one if necessary. */
968 reinit_frame_cache (void)
970 flush_cached_frames ();
972 /* FIXME: The inferior_ptid test is wrong if there is a corefile. */
973 if (PIDGET (inferior_ptid
) != 0)
975 select_frame (get_current_frame ());
979 /* Return a "struct frame_info" corresponding to the frame that called
980 THIS_FRAME. Returns NULL if there is no such frame.
982 Unlike get_prev_frame, this function always tries to unwind the
985 static struct frame_info
*
986 get_prev_frame_1 (struct frame_info
*this_frame
)
988 struct frame_info
*prev_frame
;
989 struct frame_id this_id
;
991 gdb_assert (this_frame
!= NULL
);
995 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame_1 (this_frame=");
996 if (this_frame
!= NULL
)
997 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
999 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1000 fprintf_unfiltered (gdb_stdlog
, ") ");
1003 /* Only try to do the unwind once. */
1004 if (this_frame
->prev_p
)
1008 fprintf_unfiltered (gdb_stdlog
, "-> ");
1009 fprint_frame (gdb_stdlog
, this_frame
->prev
);
1010 fprintf_unfiltered (gdb_stdlog
, " // cached \n");
1012 return this_frame
->prev
;
1014 this_frame
->prev_p
= 1;
1016 /* Check that this frame's ID was valid. If it wasn't, don't try to
1017 unwind to the prev frame. Be careful to not apply this test to
1018 the sentinel frame. */
1019 this_id
= get_frame_id (this_frame
);
1020 if (this_frame
->level
>= 0 && !frame_id_p (this_id
))
1024 fprintf_unfiltered (gdb_stdlog
, "-> ");
1025 fprint_frame (gdb_stdlog
, NULL
);
1026 fprintf_unfiltered (gdb_stdlog
, " // this ID is NULL }\n");
1031 /* Check that this frame's ID isn't inner to (younger, below, next)
1032 the next frame. This happens when a frame unwind goes backwards.
1033 Exclude signal trampolines (due to sigaltstack the frame ID can
1034 go backwards) and sentinel frames (the test is meaningless). */
1035 if (this_frame
->next
->level
>= 0
1036 && this_frame
->next
->unwind
->type
!= SIGTRAMP_FRAME
1037 && frame_id_inner (this_id
, get_frame_id (this_frame
->next
)))
1038 error ("Previous frame inner to this frame (corrupt stack?)");
1040 /* Check that this and the next frame are not identical. If they
1041 are, there is most likely a stack cycle. As with the inner-than
1042 test above, avoid comparing the inner-most and sentinel frames. */
1043 if (this_frame
->level
> 0
1044 && frame_id_eq (this_id
, get_frame_id (this_frame
->next
)))
1045 error ("Previous frame identical to this frame (corrupt stack?)");
1047 /* Allocate the new frame but do not wire it in to the frame chain.
1048 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
1049 frame->next to pull some fancy tricks (of course such code is, by
1050 definition, recursive). Try to prevent it.
1052 There is no reason to worry about memory leaks, should the
1053 remainder of the function fail. The allocated memory will be
1054 quickly reclaimed when the frame cache is flushed, and the `we've
1055 been here before' check above will stop repeated memory
1056 allocation calls. */
1057 prev_frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1058 prev_frame
->level
= this_frame
->level
+ 1;
1060 /* Don't yet compute ->unwind (and hence ->type). It is computed
1061 on-demand in get_frame_type, frame_register_unwind, and
1064 /* Don't yet compute the frame's ID. It is computed on-demand by
1067 /* The unwound frame ID is validate at the start of this function,
1068 as part of the logic to decide if that frame should be further
1069 unwound, and not here while the prev frame is being created.
1070 Doing this makes it possible for the user to examine a frame that
1071 has an invalid frame ID.
1073 Some very old VAX code noted: [...] For the sake of argument,
1074 suppose that the stack is somewhat trashed (which is one reason
1075 that "info frame" exists). So, return 0 (indicating we don't
1076 know the address of the arglist) if we don't know what frame this
1080 this_frame
->prev
= prev_frame
;
1081 prev_frame
->next
= this_frame
;
1085 fprintf_unfiltered (gdb_stdlog
, "-> ");
1086 fprint_frame (gdb_stdlog
, prev_frame
);
1087 fprintf_unfiltered (gdb_stdlog
, " }\n");
1093 /* Debug routine to print a NULL frame being returned. */
1096 frame_debug_got_null_frame (struct ui_file
*file
,
1097 struct frame_info
*this_frame
,
1102 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame (this_frame=");
1103 if (this_frame
!= NULL
)
1104 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1106 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1107 fprintf_unfiltered (gdb_stdlog
, ") -> // %s}\n", reason
);
1111 /* Return a structure containing various interesting information about
1112 the frame that called THIS_FRAME. Returns NULL if there is entier
1113 no such frame or the frame fails any of a set of target-independent
1114 condition that should terminate the frame chain (e.g., as unwinding
1117 This function should not contain target-dependent tests, such as
1118 checking whether the program-counter is zero. */
1121 get_prev_frame (struct frame_info
*this_frame
)
1123 struct frame_info
*prev_frame
;
1125 /* Return the inner-most frame, when the caller passes in NULL. */
1126 /* NOTE: cagney/2002-11-09: Not sure how this would happen. The
1127 caller should have previously obtained a valid frame using
1128 get_selected_frame() and then called this code - only possibility
1129 I can think of is code behaving badly.
1131 NOTE: cagney/2003-01-10: Talk about code behaving badly. Check
1132 block_innermost_frame(). It does the sequence: frame = NULL;
1133 while (1) { frame = get_prev_frame (frame); .... }. Ulgh! Why
1134 it couldn't be written better, I don't know.
1136 NOTE: cagney/2003-01-11: I suspect what is happening in
1137 block_innermost_frame() is, when the target has no state
1138 (registers, memory, ...), it is still calling this function. The
1139 assumption being that this function will return NULL indicating
1140 that a frame isn't possible, rather than checking that the target
1141 has state and then calling get_current_frame() and
1142 get_prev_frame(). This is a guess mind. */
1143 if (this_frame
== NULL
)
1145 /* NOTE: cagney/2002-11-09: There was a code segment here that
1146 would error out when CURRENT_FRAME was NULL. The comment
1147 that went with it made the claim ...
1149 ``This screws value_of_variable, which just wants a nice
1150 clean NULL return from block_innermost_frame if there are no
1151 frames. I don't think I've ever seen this message happen
1152 otherwise. And returning NULL here is a perfectly legitimate
1155 Per the above, this code shouldn't even be called with a NULL
1157 frame_debug_got_null_frame (gdb_stdlog
, this_frame
, "this_frame NULL");
1158 return current_frame
;
1161 /* There is always a frame. If this assertion fails, suspect that
1162 something should be calling get_selected_frame() or
1163 get_current_frame(). */
1164 gdb_assert (this_frame
!= NULL
);
1166 /* Make sure we pass an address within THIS_FRAME's code block to
1167 inside_main_func(). Otherwise, we might stop unwinding at a
1168 function which has a call instruction as its last instruction if
1169 that function immediately precedes main(). */
1170 if (this_frame
->level
>= 0
1171 && !backtrace_past_main
1172 && inside_main_func (get_frame_address_in_block (this_frame
)))
1173 /* Don't unwind past main(), but always unwind the sentinel frame.
1174 Note, this is done _before_ the frame has been marked as
1175 previously unwound. That way if the user later decides to
1176 allow unwinds past main(), that just happens. */
1178 frame_debug_got_null_frame (gdb_stdlog
, this_frame
, "inside main func");
1182 if (this_frame
->level
> backtrace_limit
)
1184 error ("Backtrace limit of %d exceeded", backtrace_limit
);
1187 /* If we're already inside the entry function for the main objfile,
1188 then it isn't valid. Don't apply this test to a dummy frame -
1189 dummy frame PCs typically land in the entry func. Don't apply
1190 this test to the sentinel frame. Sentinel frames should always
1191 be allowed to unwind. */
1192 /* NOTE: cagney/2003-02-25: Don't enable until someone has found
1193 hard evidence that this is needed. */
1194 /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() -
1195 wasn't checking for "main" in the minimal symbols. With that
1196 fixed asm-source tests now stop in "main" instead of halting the
1197 backtrace in weird and wonderful ways somewhere inside the entry
1198 file. Suspect that tests for inside the entry file/func were
1199 added to work around that (now fixed) case. */
1200 /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
1201 suggested having the inside_entry_func test use the
1202 inside_main_func() msymbol trick (along with entry_point_address()
1203 I guess) to determine the address range of the start function.
1204 That should provide a far better stopper than the current
1206 /* NOTE: cagney/2003-07-15: Need to add a "set backtrace
1207 beyond-entry-func" command so that this can be selectively
1211 && backtrace_beyond_entry_func
1213 && this_frame
->unwind
->type
!= DUMMY_FRAME
&& this_frame
->level
>= 0
1214 && inside_entry_func (this_frame
))
1216 frame_debug_got_null_frame (gdb_stdlog
, this_frame
, "inside entry func");
1220 return get_prev_frame_1 (this_frame
);
1224 get_frame_pc (struct frame_info
*frame
)
1226 gdb_assert (frame
->next
!= NULL
);
1227 return frame_pc_unwind (frame
->next
);
1230 /* Return an address of that falls within the frame's code block. */
1233 frame_unwind_address_in_block (struct frame_info
*next_frame
)
1235 /* A draft address. */
1236 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
1238 /* If THIS frame is not inner most (i.e., NEXT isn't the sentinel),
1239 and NEXT is `normal' (i.e., not a sigtramp, dummy, ....) THIS
1240 frame's PC ends up pointing at the instruction fallowing the
1241 "call". Adjust that PC value so that it falls on the call
1242 instruction (which, hopefully, falls within THIS frame's code
1243 block. So far it's proved to be a very good approximation. See
1244 get_frame_type() for why ->type can't be used. */
1245 if (next_frame
->level
>= 0
1246 && get_frame_type (next_frame
) == NORMAL_FRAME
)
1252 get_frame_address_in_block (struct frame_info
*this_frame
)
1254 return frame_unwind_address_in_block (this_frame
->next
);
1258 pc_notcurrent (struct frame_info
*frame
)
1260 /* If FRAME is not the innermost frame, that normally means that
1261 FRAME->pc points at the return instruction (which is *after* the
1262 call instruction), and we want to get the line containing the
1263 call (because the call is where the user thinks the program is).
1264 However, if the next frame is either a SIGTRAMP_FRAME or a
1265 DUMMY_FRAME, then the next frame will contain a saved interrupt
1266 PC and such a PC indicates the current (rather than next)
1267 instruction/line, consequently, for such cases, want to get the
1268 line containing fi->pc. */
1269 struct frame_info
*next
= get_next_frame (frame
);
1270 int notcurrent
= (next
!= NULL
&& get_frame_type (next
) == NORMAL_FRAME
);
1275 find_frame_sal (struct frame_info
*frame
, struct symtab_and_line
*sal
)
1277 (*sal
) = find_pc_line (get_frame_pc (frame
), pc_notcurrent (frame
));
1280 /* Per "frame.h", return the ``address'' of the frame. Code should
1281 really be using get_frame_id(). */
1283 get_frame_base (struct frame_info
*fi
)
1285 return get_frame_id (fi
).stack_addr
;
1288 /* High-level offsets into the frame. Used by the debug info. */
1291 get_frame_base_address (struct frame_info
*fi
)
1293 if (get_frame_type (fi
) != NORMAL_FRAME
)
1295 if (fi
->base
== NULL
)
1296 fi
->base
= frame_base_find_by_frame (fi
->next
);
1297 /* Sneaky: If the low-level unwind and high-level base code share a
1298 common unwinder, let them share the prologue cache. */
1299 if (fi
->base
->unwind
== fi
->unwind
)
1300 return fi
->base
->this_base (fi
->next
, &fi
->prologue_cache
);
1301 return fi
->base
->this_base (fi
->next
, &fi
->base_cache
);
1305 get_frame_locals_address (struct frame_info
*fi
)
1308 if (get_frame_type (fi
) != NORMAL_FRAME
)
1310 /* If there isn't a frame address method, find it. */
1311 if (fi
->base
== NULL
)
1312 fi
->base
= frame_base_find_by_frame (fi
->next
);
1313 /* Sneaky: If the low-level unwind and high-level base code share a
1314 common unwinder, let them share the prologue cache. */
1315 if (fi
->base
->unwind
== fi
->unwind
)
1316 cache
= &fi
->prologue_cache
;
1318 cache
= &fi
->base_cache
;
1319 return fi
->base
->this_locals (fi
->next
, cache
);
1323 get_frame_args_address (struct frame_info
*fi
)
1326 if (get_frame_type (fi
) != NORMAL_FRAME
)
1328 /* If there isn't a frame address method, find it. */
1329 if (fi
->base
== NULL
)
1330 fi
->base
= frame_base_find_by_frame (fi
->next
);
1331 /* Sneaky: If the low-level unwind and high-level base code share a
1332 common unwinder, let them share the prologue cache. */
1333 if (fi
->base
->unwind
== fi
->unwind
)
1334 cache
= &fi
->prologue_cache
;
1336 cache
= &fi
->base_cache
;
1337 return fi
->base
->this_args (fi
->next
, cache
);
1340 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
1341 or -1 for a NULL frame. */
1344 frame_relative_level (struct frame_info
*fi
)
1353 get_frame_type (struct frame_info
*frame
)
1355 if (frame
->unwind
== NULL
)
1356 /* Initialize the frame's unwinder because that's what
1357 provides the frame's type. */
1358 frame
->unwind
= frame_unwind_find_by_frame (frame
->next
,
1359 &frame
->prologue_cache
);
1360 return frame
->unwind
->type
;
1364 deprecated_update_frame_pc_hack (struct frame_info
*frame
, CORE_ADDR pc
)
1367 fprintf_unfiltered (gdb_stdlog
,
1368 "{ deprecated_update_frame_pc_hack (frame=%d,pc=0x%s) }\n",
1369 frame
->level
, paddr_nz (pc
));
1370 /* NOTE: cagney/2003-03-11: Some architectures (e.g., Arm) are
1371 maintaining a locally allocated frame object. Since such frames
1372 are not in the frame chain, it isn't possible to assume that the
1373 frame has a next. Sigh. */
1374 if (frame
->next
!= NULL
)
1376 /* While we're at it, update this frame's cached PC value, found
1377 in the next frame. Oh for the day when "struct frame_info"
1378 is opaque and this hack on hack can just go away. */
1379 frame
->next
->prev_pc
.value
= pc
;
1380 frame
->next
->prev_pc
.p
= 1;
1385 deprecated_update_frame_base_hack (struct frame_info
*frame
, CORE_ADDR base
)
1388 fprintf_unfiltered (gdb_stdlog
,
1389 "{ deprecated_update_frame_base_hack (frame=%d,base=0x%s) }\n",
1390 frame
->level
, paddr_nz (base
));
1391 /* See comment in "frame.h". */
1392 frame
->this_id
.value
.stack_addr
= base
;
1395 /* Memory access methods. */
1398 get_frame_memory (struct frame_info
*this_frame
, CORE_ADDR addr
, void *buf
,
1401 read_memory (addr
, buf
, len
);
1405 get_frame_memory_signed (struct frame_info
*this_frame
, CORE_ADDR addr
,
1408 return read_memory_integer (addr
, len
);
1412 get_frame_memory_unsigned (struct frame_info
*this_frame
, CORE_ADDR addr
,
1415 return read_memory_unsigned_integer (addr
, len
);
1419 safe_frame_unwind_memory (struct frame_info
*this_frame
,
1420 CORE_ADDR addr
, void *buf
, int len
)
1422 /* NOTE: deprecated_read_memory_nobpt returns zero on success! */
1423 return !deprecated_read_memory_nobpt (addr
, buf
, len
);
1426 /* Architecture method. */
1429 get_frame_arch (struct frame_info
*this_frame
)
1431 return current_gdbarch
;
1434 /* Stack pointer methods. */
1437 get_frame_sp (struct frame_info
*this_frame
)
1439 return frame_sp_unwind (this_frame
->next
);
1443 frame_sp_unwind (struct frame_info
*next_frame
)
1445 /* Normality - an architecture that provides a way of obtaining any
1446 frame inner-most address. */
1447 if (gdbarch_unwind_sp_p (current_gdbarch
))
1448 return gdbarch_unwind_sp (current_gdbarch
, next_frame
);
1449 /* Things are looking grim. If it's the inner-most frame and there
1450 is a TARGET_READ_SP, then that can be used. */
1451 if (next_frame
->level
< 0 && TARGET_READ_SP_P ())
1452 return TARGET_READ_SP ();
1453 /* Now things are really are grim. Hope that the value returned by
1454 the SP_REGNUM register is meaningful. */
1458 frame_unwind_unsigned_register (next_frame
, SP_REGNUM
, &sp
);
1461 internal_error (__FILE__
, __LINE__
, "Missing unwind SP method");
1464 extern initialize_file_ftype _initialize_frame
; /* -Wmissing-prototypes */
1466 static struct cmd_list_element
*set_backtrace_cmdlist
;
1467 static struct cmd_list_element
*show_backtrace_cmdlist
;
1470 set_backtrace_cmd (char *args
, int from_tty
)
1472 help_list (set_backtrace_cmdlist
, "set backtrace ", -1, gdb_stdout
);
1476 show_backtrace_cmd (char *args
, int from_tty
)
1478 cmd_show_list (show_backtrace_cmdlist
, from_tty
, "");
1482 _initialize_frame (void)
1484 obstack_init (&frame_cache_obstack
);
1486 observer_attach_target_changed (frame_observer_target_changed
);
1488 add_prefix_cmd ("backtrace", class_maintenance
, set_backtrace_cmd
, "\
1489 Set backtrace specific variables.\n\
1490 Configure backtrace variables such as the backtrace limit",
1491 &set_backtrace_cmdlist
, "set backtrace ",
1492 0/*allow-unknown*/, &setlist
);
1493 add_prefix_cmd ("backtrace", class_maintenance
, show_backtrace_cmd
, "\
1494 Show backtrace specific variables\n\
1495 Show backtrace variables such as the backtrace limit",
1496 &show_backtrace_cmdlist
, "show backtrace ",
1497 0/*allow-unknown*/, &showlist
);
1499 add_setshow_boolean_cmd ("past-main", class_obscure
,
1500 &backtrace_past_main
, "\
1501 Set whether backtraces should continue past \"main\".", "\
1502 Show whether backtraces should continue past \"main\".", "\
1503 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
1504 the backtrace at \"main\". Set this variable if you need to see the rest\n\
1505 of the stack trace.", "\
1506 Whether backtraces should continue past \"main\" is %s.",
1507 NULL
, NULL
, &set_backtrace_cmdlist
,
1508 &show_backtrace_cmdlist
);
1510 add_setshow_uinteger_cmd ("limit", class_obscure
,
1511 &backtrace_limit
, "\
1512 Set an upper bound on the number of backtrace levels.", "\
1513 Show the upper bound on the number of backtrace levels.", "\
1514 No more than the specified number of frames can be displayed or examined.\n\
1515 Zero is unlimited.", "\
1516 An upper bound on the number of backtrace levels is %s.",
1517 NULL
, NULL
, &set_backtrace_cmdlist
,
1518 &show_backtrace_cmdlist
);
1520 /* Debug this files internals. */
1521 deprecated_add_show_from_set
1522 (add_set_cmd ("frame", class_maintenance
, var_zinteger
,
1523 &frame_debug
, "Set frame debugging.\n\
1524 When non-zero, frame specific internal debugging is enabled.", &setdebuglist
),