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 (void)
827 if (deprecated_selected_frame
== NULL
)
828 /* Hey! Don't trust this. It should really be re-finding the
829 last selected frame of the currently selected thread. This,
830 though, is better than nothing. */
831 select_frame (get_current_frame ());
832 /* There is always a frame. */
833 gdb_assert (deprecated_selected_frame
!= NULL
);
834 return deprecated_selected_frame
;
837 /* This is a variant of get_selected_frame() which can be called when
838 the inferior does not have a frame; in that case it will return
839 NULL instead of calling error(). */
842 deprecated_safe_get_selected_frame (void)
844 if (!target_has_registers
|| !target_has_stack
|| !target_has_memory
)
846 return get_selected_frame ();
849 /* Select frame FI (or NULL - to invalidate the current frame). */
852 select_frame (struct frame_info
*fi
)
856 deprecated_selected_frame
= fi
;
857 /* NOTE: cagney/2002-05-04: FI can be NULL. This occurs when the
858 frame is being invalidated. */
859 if (deprecated_selected_frame_level_changed_hook
)
860 deprecated_selected_frame_level_changed_hook (frame_relative_level (fi
));
862 /* FIXME: kseitz/2002-08-28: It would be nice to call
863 selected_frame_level_changed_event() right here, but due to limitations
864 in the current interfaces, we would end up flooding UIs with events
865 because select_frame() is used extensively internally.
867 Once we have frame-parameterized frame (and frame-related) commands,
868 the event notification can be moved here, since this function will only
869 be called when the user's selected frame is being changed. */
871 /* Ensure that symbols for this frame are read in. Also, determine the
872 source language of this frame, and switch to it if desired. */
875 /* We retrieve the frame's symtab by using the frame PC. However
876 we cannot use the frame PC as-is, because it usually points to
877 the instruction following the "call", which is sometimes the
878 first instruction of another function. So we rely on
879 get_frame_address_in_block() which provides us with a PC which
880 is guaranteed to be inside the frame's code block. */
881 s
= find_pc_symtab (get_frame_address_in_block (fi
));
883 && s
->language
!= current_language
->la_language
884 && s
->language
!= language_unknown
885 && language_mode
== language_mode_auto
)
887 set_language (s
->language
);
892 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
893 Always returns a non-NULL value. */
896 create_new_frame (CORE_ADDR addr
, CORE_ADDR pc
)
898 struct frame_info
*fi
;
902 fprintf_unfiltered (gdb_stdlog
,
903 "{ create_new_frame (addr=0x%s, pc=0x%s) ",
904 paddr_nz (addr
), paddr_nz (pc
));
907 fi
= frame_obstack_zalloc (sizeof (struct frame_info
));
909 fi
->next
= create_sentinel_frame (current_regcache
);
911 /* Select/initialize both the unwind function and the frame's type
913 fi
->unwind
= frame_unwind_find_by_frame (fi
->next
, &fi
->prologue_cache
);
916 deprecated_update_frame_base_hack (fi
, addr
);
917 deprecated_update_frame_pc_hack (fi
, pc
);
921 fprintf_unfiltered (gdb_stdlog
, "-> ");
922 fprint_frame (gdb_stdlog
, fi
);
923 fprintf_unfiltered (gdb_stdlog
, " }\n");
929 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
930 innermost frame). Be careful to not fall off the bottom of the
931 frame chain and onto the sentinel frame. */
934 get_next_frame (struct frame_info
*this_frame
)
936 if (this_frame
->level
> 0)
937 return this_frame
->next
;
942 /* Observer for the target_changed event. */
945 frame_observer_target_changed (struct target_ops
*target
)
947 flush_cached_frames ();
950 /* Flush the entire frame cache. */
953 flush_cached_frames (void)
955 /* Since we can't really be sure what the first object allocated was */
956 obstack_free (&frame_cache_obstack
, 0);
957 obstack_init (&frame_cache_obstack
);
959 current_frame
= NULL
; /* Invalidate cache */
961 annotate_frames_invalid ();
963 fprintf_unfiltered (gdb_stdlog
, "{ flush_cached_frames () }\n");
966 /* Flush the frame cache, and start a new one if necessary. */
969 reinit_frame_cache (void)
971 flush_cached_frames ();
973 /* FIXME: The inferior_ptid test is wrong if there is a corefile. */
974 if (PIDGET (inferior_ptid
) != 0)
976 select_frame (get_current_frame ());
980 /* Return a "struct frame_info" corresponding to the frame that called
981 THIS_FRAME. Returns NULL if there is no such frame.
983 Unlike get_prev_frame, this function always tries to unwind the
986 static struct frame_info
*
987 get_prev_frame_1 (struct frame_info
*this_frame
)
989 struct frame_info
*prev_frame
;
990 struct frame_id this_id
;
992 gdb_assert (this_frame
!= NULL
);
996 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame_1 (this_frame=");
997 if (this_frame
!= NULL
)
998 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1000 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1001 fprintf_unfiltered (gdb_stdlog
, ") ");
1004 /* Only try to do the unwind once. */
1005 if (this_frame
->prev_p
)
1009 fprintf_unfiltered (gdb_stdlog
, "-> ");
1010 fprint_frame (gdb_stdlog
, this_frame
->prev
);
1011 fprintf_unfiltered (gdb_stdlog
, " // cached \n");
1013 return this_frame
->prev
;
1015 this_frame
->prev_p
= 1;
1017 /* Check that this frame's ID was valid. If it wasn't, don't try to
1018 unwind to the prev frame. Be careful to not apply this test to
1019 the sentinel frame. */
1020 this_id
= get_frame_id (this_frame
);
1021 if (this_frame
->level
>= 0 && !frame_id_p (this_id
))
1025 fprintf_unfiltered (gdb_stdlog
, "-> ");
1026 fprint_frame (gdb_stdlog
, NULL
);
1027 fprintf_unfiltered (gdb_stdlog
, " // this ID is NULL }\n");
1032 /* Check that this frame's ID isn't inner to (younger, below, next)
1033 the next frame. This happens when a frame unwind goes backwards.
1034 Exclude signal trampolines (due to sigaltstack the frame ID can
1035 go backwards) and sentinel frames (the test is meaningless). */
1036 if (this_frame
->next
->level
>= 0
1037 && this_frame
->next
->unwind
->type
!= SIGTRAMP_FRAME
1038 && frame_id_inner (this_id
, get_frame_id (this_frame
->next
)))
1039 error ("Previous frame inner to this frame (corrupt stack?)");
1041 /* Check that this and the next frame are not identical. If they
1042 are, there is most likely a stack cycle. As with the inner-than
1043 test above, avoid comparing the inner-most and sentinel frames. */
1044 if (this_frame
->level
> 0
1045 && frame_id_eq (this_id
, get_frame_id (this_frame
->next
)))
1046 error ("Previous frame identical to this frame (corrupt stack?)");
1048 /* Allocate the new frame but do not wire it in to the frame chain.
1049 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
1050 frame->next to pull some fancy tricks (of course such code is, by
1051 definition, recursive). Try to prevent it.
1053 There is no reason to worry about memory leaks, should the
1054 remainder of the function fail. The allocated memory will be
1055 quickly reclaimed when the frame cache is flushed, and the `we've
1056 been here before' check above will stop repeated memory
1057 allocation calls. */
1058 prev_frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1059 prev_frame
->level
= this_frame
->level
+ 1;
1061 /* Don't yet compute ->unwind (and hence ->type). It is computed
1062 on-demand in get_frame_type, frame_register_unwind, and
1065 /* Don't yet compute the frame's ID. It is computed on-demand by
1068 /* The unwound frame ID is validate at the start of this function,
1069 as part of the logic to decide if that frame should be further
1070 unwound, and not here while the prev frame is being created.
1071 Doing this makes it possible for the user to examine a frame that
1072 has an invalid frame ID.
1074 Some very old VAX code noted: [...] For the sake of argument,
1075 suppose that the stack is somewhat trashed (which is one reason
1076 that "info frame" exists). So, return 0 (indicating we don't
1077 know the address of the arglist) if we don't know what frame this
1081 this_frame
->prev
= prev_frame
;
1082 prev_frame
->next
= this_frame
;
1086 fprintf_unfiltered (gdb_stdlog
, "-> ");
1087 fprint_frame (gdb_stdlog
, prev_frame
);
1088 fprintf_unfiltered (gdb_stdlog
, " }\n");
1094 /* Debug routine to print a NULL frame being returned. */
1097 frame_debug_got_null_frame (struct ui_file
*file
,
1098 struct frame_info
*this_frame
,
1103 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame (this_frame=");
1104 if (this_frame
!= NULL
)
1105 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1107 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1108 fprintf_unfiltered (gdb_stdlog
, ") -> // %s}\n", reason
);
1112 /* Is this (non-sentinel) frame in the "main"() function? */
1115 inside_main_func (struct frame_info
*this_frame
)
1117 struct minimal_symbol
*msymbol
;
1120 if (symfile_objfile
== 0)
1122 msymbol
= lookup_minimal_symbol (main_name (), NULL
, symfile_objfile
);
1123 if (msymbol
== NULL
)
1125 /* Make certain that the code, and not descriptor, address is
1127 maddr
= gdbarch_convert_from_func_ptr_addr (current_gdbarch
,
1128 SYMBOL_VALUE_ADDRESS (msymbol
),
1130 return maddr
== get_frame_func (this_frame
);
1133 /* Return a structure containing various interesting information about
1134 the frame that called THIS_FRAME. Returns NULL if there is entier
1135 no such frame or the frame fails any of a set of target-independent
1136 condition that should terminate the frame chain (e.g., as unwinding
1139 This function should not contain target-dependent tests, such as
1140 checking whether the program-counter is zero. */
1143 get_prev_frame (struct frame_info
*this_frame
)
1145 struct frame_info
*prev_frame
;
1147 /* Return the inner-most frame, when the caller passes in NULL. */
1148 /* NOTE: cagney/2002-11-09: Not sure how this would happen. The
1149 caller should have previously obtained a valid frame using
1150 get_selected_frame() and then called this code - only possibility
1151 I can think of is code behaving badly.
1153 NOTE: cagney/2003-01-10: Talk about code behaving badly. Check
1154 block_innermost_frame(). It does the sequence: frame = NULL;
1155 while (1) { frame = get_prev_frame (frame); .... }. Ulgh! Why
1156 it couldn't be written better, I don't know.
1158 NOTE: cagney/2003-01-11: I suspect what is happening in
1159 block_innermost_frame() is, when the target has no state
1160 (registers, memory, ...), it is still calling this function. The
1161 assumption being that this function will return NULL indicating
1162 that a frame isn't possible, rather than checking that the target
1163 has state and then calling get_current_frame() and
1164 get_prev_frame(). This is a guess mind. */
1165 if (this_frame
== NULL
)
1167 /* NOTE: cagney/2002-11-09: There was a code segment here that
1168 would error out when CURRENT_FRAME was NULL. The comment
1169 that went with it made the claim ...
1171 ``This screws value_of_variable, which just wants a nice
1172 clean NULL return from block_innermost_frame if there are no
1173 frames. I don't think I've ever seen this message happen
1174 otherwise. And returning NULL here is a perfectly legitimate
1177 Per the above, this code shouldn't even be called with a NULL
1179 frame_debug_got_null_frame (gdb_stdlog
, this_frame
, "this_frame NULL");
1180 return current_frame
;
1183 /* There is always a frame. If this assertion fails, suspect that
1184 something should be calling get_selected_frame() or
1185 get_current_frame(). */
1186 gdb_assert (this_frame
!= NULL
);
1188 if (this_frame
->level
>= 0
1189 && !backtrace_past_main
1190 && inside_main_func (this_frame
))
1191 /* Don't unwind past main(). Note, this is done _before_ the
1192 frame has been marked as previously unwound. That way if the
1193 user later decides to enable unwinds past main(), that will
1194 automatically happen. */
1196 frame_debug_got_null_frame (gdb_stdlog
, this_frame
, "inside main func");
1200 if (this_frame
->level
> backtrace_limit
)
1202 error ("Backtrace limit of %d exceeded", backtrace_limit
);
1205 /* If we're already inside the entry function for the main objfile,
1206 then it isn't valid. Don't apply this test to a dummy frame -
1207 dummy frame PCs typically land in the entry func. Don't apply
1208 this test to the sentinel frame. Sentinel frames should always
1209 be allowed to unwind. */
1210 /* NOTE: cagney/2003-02-25: Don't enable until someone has found
1211 hard evidence that this is needed. */
1212 /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() -
1213 wasn't checking for "main" in the minimal symbols. With that
1214 fixed asm-source tests now stop in "main" instead of halting the
1215 backtrace in weird and wonderful ways somewhere inside the entry
1216 file. Suspect that tests for inside the entry file/func were
1217 added to work around that (now fixed) case. */
1218 /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
1219 suggested having the inside_entry_func test use the
1220 inside_main_func() msymbol trick (along with entry_point_address()
1221 I guess) to determine the address range of the start function.
1222 That should provide a far better stopper than the current
1224 /* NOTE: cagney/2003-07-15: Need to add a "set backtrace
1225 beyond-entry-func" command so that this can be selectively
1229 && backtrace_beyond_entry_func
1231 && this_frame
->unwind
->type
!= DUMMY_FRAME
&& this_frame
->level
>= 0
1232 && inside_entry_func (this_frame
))
1234 frame_debug_got_null_frame (gdb_stdlog
, this_frame
, "inside entry func");
1238 return get_prev_frame_1 (this_frame
);
1242 get_frame_pc (struct frame_info
*frame
)
1244 gdb_assert (frame
->next
!= NULL
);
1245 return frame_pc_unwind (frame
->next
);
1248 /* Return an address of that falls within the frame's code block. */
1251 frame_unwind_address_in_block (struct frame_info
*next_frame
)
1253 /* A draft address. */
1254 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
1256 /* If THIS frame is not inner most (i.e., NEXT isn't the sentinel),
1257 and NEXT is `normal' (i.e., not a sigtramp, dummy, ....) THIS
1258 frame's PC ends up pointing at the instruction fallowing the
1259 "call". Adjust that PC value so that it falls on the call
1260 instruction (which, hopefully, falls within THIS frame's code
1261 block. So far it's proved to be a very good approximation. See
1262 get_frame_type() for why ->type can't be used. */
1263 if (next_frame
->level
>= 0
1264 && get_frame_type (next_frame
) == NORMAL_FRAME
)
1270 get_frame_address_in_block (struct frame_info
*this_frame
)
1272 return frame_unwind_address_in_block (this_frame
->next
);
1276 pc_notcurrent (struct frame_info
*frame
)
1278 /* If FRAME is not the innermost frame, that normally means that
1279 FRAME->pc points at the return instruction (which is *after* the
1280 call instruction), and we want to get the line containing the
1281 call (because the call is where the user thinks the program is).
1282 However, if the next frame is either a SIGTRAMP_FRAME or a
1283 DUMMY_FRAME, then the next frame will contain a saved interrupt
1284 PC and such a PC indicates the current (rather than next)
1285 instruction/line, consequently, for such cases, want to get the
1286 line containing fi->pc. */
1287 struct frame_info
*next
= get_next_frame (frame
);
1288 int notcurrent
= (next
!= NULL
&& get_frame_type (next
) == NORMAL_FRAME
);
1293 find_frame_sal (struct frame_info
*frame
, struct symtab_and_line
*sal
)
1295 (*sal
) = find_pc_line (get_frame_pc (frame
), pc_notcurrent (frame
));
1298 /* Per "frame.h", return the ``address'' of the frame. Code should
1299 really be using get_frame_id(). */
1301 get_frame_base (struct frame_info
*fi
)
1303 return get_frame_id (fi
).stack_addr
;
1306 /* High-level offsets into the frame. Used by the debug info. */
1309 get_frame_base_address (struct frame_info
*fi
)
1311 if (get_frame_type (fi
) != NORMAL_FRAME
)
1313 if (fi
->base
== NULL
)
1314 fi
->base
= frame_base_find_by_frame (fi
->next
);
1315 /* Sneaky: If the low-level unwind and high-level base code share a
1316 common unwinder, let them share the prologue cache. */
1317 if (fi
->base
->unwind
== fi
->unwind
)
1318 return fi
->base
->this_base (fi
->next
, &fi
->prologue_cache
);
1319 return fi
->base
->this_base (fi
->next
, &fi
->base_cache
);
1323 get_frame_locals_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_locals (fi
->next
, cache
);
1341 get_frame_args_address (struct frame_info
*fi
)
1344 if (get_frame_type (fi
) != NORMAL_FRAME
)
1346 /* If there isn't a frame address method, find it. */
1347 if (fi
->base
== NULL
)
1348 fi
->base
= frame_base_find_by_frame (fi
->next
);
1349 /* Sneaky: If the low-level unwind and high-level base code share a
1350 common unwinder, let them share the prologue cache. */
1351 if (fi
->base
->unwind
== fi
->unwind
)
1352 cache
= &fi
->prologue_cache
;
1354 cache
= &fi
->base_cache
;
1355 return fi
->base
->this_args (fi
->next
, cache
);
1358 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
1359 or -1 for a NULL frame. */
1362 frame_relative_level (struct frame_info
*fi
)
1371 get_frame_type (struct frame_info
*frame
)
1373 if (frame
->unwind
== NULL
)
1374 /* Initialize the frame's unwinder because that's what
1375 provides the frame's type. */
1376 frame
->unwind
= frame_unwind_find_by_frame (frame
->next
,
1377 &frame
->prologue_cache
);
1378 return frame
->unwind
->type
;
1382 deprecated_update_frame_pc_hack (struct frame_info
*frame
, CORE_ADDR pc
)
1385 fprintf_unfiltered (gdb_stdlog
,
1386 "{ deprecated_update_frame_pc_hack (frame=%d,pc=0x%s) }\n",
1387 frame
->level
, paddr_nz (pc
));
1388 /* NOTE: cagney/2003-03-11: Some architectures (e.g., Arm) are
1389 maintaining a locally allocated frame object. Since such frames
1390 are not in the frame chain, it isn't possible to assume that the
1391 frame has a next. Sigh. */
1392 if (frame
->next
!= NULL
)
1394 /* While we're at it, update this frame's cached PC value, found
1395 in the next frame. Oh for the day when "struct frame_info"
1396 is opaque and this hack on hack can just go away. */
1397 frame
->next
->prev_pc
.value
= pc
;
1398 frame
->next
->prev_pc
.p
= 1;
1403 deprecated_update_frame_base_hack (struct frame_info
*frame
, CORE_ADDR base
)
1406 fprintf_unfiltered (gdb_stdlog
,
1407 "{ deprecated_update_frame_base_hack (frame=%d,base=0x%s) }\n",
1408 frame
->level
, paddr_nz (base
));
1409 /* See comment in "frame.h". */
1410 frame
->this_id
.value
.stack_addr
= base
;
1413 /* Memory access methods. */
1416 get_frame_memory (struct frame_info
*this_frame
, CORE_ADDR addr
, void *buf
,
1419 read_memory (addr
, buf
, len
);
1423 get_frame_memory_signed (struct frame_info
*this_frame
, CORE_ADDR addr
,
1426 return read_memory_integer (addr
, len
);
1430 get_frame_memory_unsigned (struct frame_info
*this_frame
, CORE_ADDR addr
,
1433 return read_memory_unsigned_integer (addr
, len
);
1437 safe_frame_unwind_memory (struct frame_info
*this_frame
,
1438 CORE_ADDR addr
, void *buf
, int len
)
1440 /* NOTE: deprecated_read_memory_nobpt returns zero on success! */
1441 return !deprecated_read_memory_nobpt (addr
, buf
, len
);
1444 /* Architecture method. */
1447 get_frame_arch (struct frame_info
*this_frame
)
1449 return current_gdbarch
;
1452 /* Stack pointer methods. */
1455 get_frame_sp (struct frame_info
*this_frame
)
1457 return frame_sp_unwind (this_frame
->next
);
1461 frame_sp_unwind (struct frame_info
*next_frame
)
1463 /* Normality - an architecture that provides a way of obtaining any
1464 frame inner-most address. */
1465 if (gdbarch_unwind_sp_p (current_gdbarch
))
1466 return gdbarch_unwind_sp (current_gdbarch
, next_frame
);
1467 /* Things are looking grim. If it's the inner-most frame and there
1468 is a TARGET_READ_SP, then that can be used. */
1469 if (next_frame
->level
< 0 && TARGET_READ_SP_P ())
1470 return TARGET_READ_SP ();
1471 /* Now things are really are grim. Hope that the value returned by
1472 the SP_REGNUM register is meaningful. */
1476 frame_unwind_unsigned_register (next_frame
, SP_REGNUM
, &sp
);
1479 internal_error (__FILE__
, __LINE__
, "Missing unwind SP method");
1482 extern initialize_file_ftype _initialize_frame
; /* -Wmissing-prototypes */
1484 static struct cmd_list_element
*set_backtrace_cmdlist
;
1485 static struct cmd_list_element
*show_backtrace_cmdlist
;
1488 set_backtrace_cmd (char *args
, int from_tty
)
1490 help_list (set_backtrace_cmdlist
, "set backtrace ", -1, gdb_stdout
);
1494 show_backtrace_cmd (char *args
, int from_tty
)
1496 cmd_show_list (show_backtrace_cmdlist
, from_tty
, "");
1500 _initialize_frame (void)
1502 obstack_init (&frame_cache_obstack
);
1504 observer_attach_target_changed (frame_observer_target_changed
);
1506 add_prefix_cmd ("backtrace", class_maintenance
, set_backtrace_cmd
, "\
1507 Set backtrace specific variables.\n\
1508 Configure backtrace variables such as the backtrace limit",
1509 &set_backtrace_cmdlist
, "set backtrace ",
1510 0/*allow-unknown*/, &setlist
);
1511 add_prefix_cmd ("backtrace", class_maintenance
, show_backtrace_cmd
, "\
1512 Show backtrace specific variables\n\
1513 Show backtrace variables such as the backtrace limit",
1514 &show_backtrace_cmdlist
, "show backtrace ",
1515 0/*allow-unknown*/, &showlist
);
1517 add_setshow_boolean_cmd ("past-main", class_obscure
,
1518 &backtrace_past_main
, "\
1519 Set whether backtraces should continue past \"main\".", "\
1520 Show whether backtraces should continue past \"main\".", "\
1521 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
1522 the backtrace at \"main\". Set this variable if you need to see the rest\n\
1523 of the stack trace.", "\
1524 Whether backtraces should continue past \"main\" is %s.",
1525 NULL
, NULL
, &set_backtrace_cmdlist
,
1526 &show_backtrace_cmdlist
);
1528 add_setshow_uinteger_cmd ("limit", class_obscure
,
1529 &backtrace_limit
, "\
1530 Set an upper bound on the number of backtrace levels.", "\
1531 Show the upper bound on the number of backtrace levels.", "\
1532 No more than the specified number of frames can be displayed or examined.\n\
1533 Zero is unlimited.", "\
1534 An upper bound on the number of backtrace levels is %s.",
1535 NULL
, NULL
, &set_backtrace_cmdlist
,
1536 &show_backtrace_cmdlist
);
1538 /* Debug this files internals. */
1539 deprecated_add_show_from_set
1540 (add_set_cmd ("frame", class_maintenance
, var_zinteger
,
1541 &frame_debug
, "Set frame debugging.\n\
1542 When non-zero, frame specific internal debugging is enabled.", &setdebuglist
),