1 /* Cache and manage frames for GDB, the GNU debugger.
3 Copyright (C) 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000, 2001,
4 2002, 2003, 2004, 2007, 2008, 2009, 2010, 2011
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "inferior.h" /* for inferior_ptid */
28 #include "gdb_assert.h"
29 #include "gdb_string.h"
30 #include "user-regs.h"
31 #include "gdb_obstack.h"
32 #include "dummy-frame.h"
33 #include "sentinel-frame.h"
37 #include "frame-unwind.h"
38 #include "frame-base.h"
43 #include "exceptions.h"
44 #include "gdbthread.h"
46 #include "inline-frame.h"
47 #include "tracepoint.h"
49 static struct frame_info
*get_prev_frame_1 (struct frame_info
*this_frame
);
50 static struct frame_info
*get_prev_frame_raw (struct frame_info
*this_frame
);
52 /* We keep a cache of stack frames, each of which is a "struct
53 frame_info". The innermost one gets allocated (in
54 wait_for_inferior) each time the inferior stops; current_frame
55 points to it. Additional frames get allocated (in get_prev_frame)
56 as needed, and are chained through the next and prev fields. Any
57 time that the frame cache becomes invalid (most notably when we
58 execute something, but also if we change how we interpret the
59 frames (e.g. "set heuristic-fence-post" in mips-tdep.c, or anything
60 which reads new symbols)), we should call reinit_frame_cache. */
64 /* Level of this frame. The inner-most (youngest) frame is at level
65 0. As you move towards the outer-most (oldest) frame, the level
66 increases. This is a cached value. It could just as easily be
67 computed by counting back from the selected frame to the inner
69 /* NOTE: cagney/2002-04-05: Perhaps a level of ``-1'' should be
70 reserved to indicate a bogus frame - one that has been created
71 just to keep GDB happy (GDB always needs a frame). For the
72 moment leave this as speculation. */
75 /* The frame's program space. */
76 struct program_space
*pspace
;
78 /* The frame's address space. */
79 struct address_space
*aspace
;
81 /* The frame's low-level unwinder and corresponding cache. The
82 low-level unwinder is responsible for unwinding register values
83 for the previous frame. The low-level unwind methods are
84 selected based on the presence, or otherwise, of register unwind
85 information such as CFI. */
87 const struct frame_unwind
*unwind
;
89 /* Cached copy of the previous frame's architecture. */
96 /* Cached copy of the previous frame's resume address. */
102 /* Cached copy of the previous frame's function address. */
109 /* This frame's ID. */
113 struct frame_id value
;
116 /* The frame's high-level base methods, and corresponding cache.
117 The high level base methods are selected based on the frame's
119 const struct frame_base
*base
;
122 /* Pointers to the next (down, inner, younger) and previous (up,
123 outer, older) frame_info's in the frame cache. */
124 struct frame_info
*next
; /* down, inner, younger */
126 struct frame_info
*prev
; /* up, outer, older */
128 /* The reason why we could not set PREV, or UNWIND_NO_REASON if we
129 could. Only valid when PREV_P is set. */
130 enum unwind_stop_reason stop_reason
;
133 /* A frame stash used to speed up frame lookups. */
135 /* We currently only stash one frame at a time, as this seems to be
136 sufficient for now. */
137 static struct frame_info
*frame_stash
= NULL
;
139 /* Add the following FRAME to the frame stash. */
142 frame_stash_add (struct frame_info
*frame
)
147 /* Search the frame stash for an entry with the given frame ID.
148 If found, return that frame. Otherwise return NULL. */
150 static struct frame_info
*
151 frame_stash_find (struct frame_id id
)
153 if (frame_stash
&& frame_id_eq (frame_stash
->this_id
.value
, id
))
159 /* Invalidate the frame stash by removing all entries in it. */
162 frame_stash_invalidate (void)
167 /* Flag to control debugging. */
171 show_frame_debug (struct ui_file
*file
, int from_tty
,
172 struct cmd_list_element
*c
, const char *value
)
174 fprintf_filtered (file
, _("Frame debugging is %s.\n"), value
);
177 /* Flag to indicate whether backtraces should stop at main et.al. */
179 static int backtrace_past_main
;
181 show_backtrace_past_main (struct ui_file
*file
, int from_tty
,
182 struct cmd_list_element
*c
, const char *value
)
184 fprintf_filtered (file
,
185 _("Whether backtraces should "
186 "continue past \"main\" is %s.\n"),
190 static int backtrace_past_entry
;
192 show_backtrace_past_entry (struct ui_file
*file
, int from_tty
,
193 struct cmd_list_element
*c
, const char *value
)
195 fprintf_filtered (file
, _("Whether backtraces should continue past the "
196 "entry point of a program is %s.\n"),
200 static int backtrace_limit
= INT_MAX
;
202 show_backtrace_limit (struct ui_file
*file
, int from_tty
,
203 struct cmd_list_element
*c
, const char *value
)
205 fprintf_filtered (file
,
206 _("An upper bound on the number "
207 "of backtrace levels is %s.\n"),
213 fprint_field (struct ui_file
*file
, const char *name
, int p
, CORE_ADDR addr
)
216 fprintf_unfiltered (file
, "%s=%s", name
, hex_string (addr
));
218 fprintf_unfiltered (file
, "!%s", name
);
222 fprint_frame_id (struct ui_file
*file
, struct frame_id id
)
224 fprintf_unfiltered (file
, "{");
225 fprint_field (file
, "stack", id
.stack_addr_p
, id
.stack_addr
);
226 fprintf_unfiltered (file
, ",");
227 fprint_field (file
, "code", id
.code_addr_p
, id
.code_addr
);
228 fprintf_unfiltered (file
, ",");
229 fprint_field (file
, "special", id
.special_addr_p
, id
.special_addr
);
231 fprintf_unfiltered (file
, ",inlined=%d", id
.inline_depth
);
232 fprintf_unfiltered (file
, "}");
236 fprint_frame_type (struct ui_file
*file
, enum frame_type type
)
241 fprintf_unfiltered (file
, "NORMAL_FRAME");
244 fprintf_unfiltered (file
, "DUMMY_FRAME");
247 fprintf_unfiltered (file
, "INLINE_FRAME");
250 fprintf_unfiltered (file
, "SENTINEL_FRAME");
253 fprintf_unfiltered (file
, "SIGTRAMP_FRAME");
256 fprintf_unfiltered (file
, "ARCH_FRAME");
259 fprintf_unfiltered (file
, "<unknown type>");
265 fprint_frame (struct ui_file
*file
, struct frame_info
*fi
)
269 fprintf_unfiltered (file
, "<NULL frame>");
272 fprintf_unfiltered (file
, "{");
273 fprintf_unfiltered (file
, "level=%d", fi
->level
);
274 fprintf_unfiltered (file
, ",");
275 fprintf_unfiltered (file
, "type=");
276 if (fi
->unwind
!= NULL
)
277 fprint_frame_type (file
, fi
->unwind
->type
);
279 fprintf_unfiltered (file
, "<unknown>");
280 fprintf_unfiltered (file
, ",");
281 fprintf_unfiltered (file
, "unwind=");
282 if (fi
->unwind
!= NULL
)
283 gdb_print_host_address (fi
->unwind
, file
);
285 fprintf_unfiltered (file
, "<unknown>");
286 fprintf_unfiltered (file
, ",");
287 fprintf_unfiltered (file
, "pc=");
288 if (fi
->next
!= NULL
&& fi
->next
->prev_pc
.p
)
289 fprintf_unfiltered (file
, "%s", hex_string (fi
->next
->prev_pc
.value
));
291 fprintf_unfiltered (file
, "<unknown>");
292 fprintf_unfiltered (file
, ",");
293 fprintf_unfiltered (file
, "id=");
295 fprint_frame_id (file
, fi
->this_id
.value
);
297 fprintf_unfiltered (file
, "<unknown>");
298 fprintf_unfiltered (file
, ",");
299 fprintf_unfiltered (file
, "func=");
300 if (fi
->next
!= NULL
&& fi
->next
->prev_func
.p
)
301 fprintf_unfiltered (file
, "%s", hex_string (fi
->next
->prev_func
.addr
));
303 fprintf_unfiltered (file
, "<unknown>");
304 fprintf_unfiltered (file
, "}");
307 /* Given FRAME, return the enclosing normal frame for inlined
308 function frames. Otherwise return the original frame. */
310 static struct frame_info
*
311 skip_inlined_frames (struct frame_info
*frame
)
313 while (get_frame_type (frame
) == INLINE_FRAME
)
314 frame
= get_prev_frame (frame
);
319 /* Return a frame uniq ID that can be used to, later, re-find the
323 get_frame_id (struct frame_info
*fi
)
326 return null_frame_id
;
331 fprintf_unfiltered (gdb_stdlog
, "{ get_frame_id (fi=%d) ",
333 /* Find the unwinder. */
334 if (fi
->unwind
== NULL
)
335 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
336 /* Find THIS frame's ID. */
337 /* Default to outermost if no ID is found. */
338 fi
->this_id
.value
= outer_frame_id
;
339 fi
->unwind
->this_id (fi
, &fi
->prologue_cache
, &fi
->this_id
.value
);
340 gdb_assert (frame_id_p (fi
->this_id
.value
));
344 fprintf_unfiltered (gdb_stdlog
, "-> ");
345 fprint_frame_id (gdb_stdlog
, fi
->this_id
.value
);
346 fprintf_unfiltered (gdb_stdlog
, " }\n");
350 frame_stash_add (fi
);
352 return fi
->this_id
.value
;
356 get_stack_frame_id (struct frame_info
*next_frame
)
358 return get_frame_id (skip_inlined_frames (next_frame
));
362 frame_unwind_caller_id (struct frame_info
*next_frame
)
364 struct frame_info
*this_frame
;
366 /* Use get_prev_frame_1, and not get_prev_frame. The latter will truncate
367 the frame chain, leading to this function unintentionally
368 returning a null_frame_id (e.g., when a caller requests the frame
369 ID of "main()"s caller. */
371 next_frame
= skip_inlined_frames (next_frame
);
372 this_frame
= get_prev_frame_1 (next_frame
);
374 return get_frame_id (skip_inlined_frames (this_frame
));
376 return null_frame_id
;
379 const struct frame_id null_frame_id
; /* All zeros. */
380 const struct frame_id outer_frame_id
= { 0, 0, 0, 0, 0, 1, 0 };
383 frame_id_build_special (CORE_ADDR stack_addr
, CORE_ADDR code_addr
,
384 CORE_ADDR special_addr
)
386 struct frame_id id
= null_frame_id
;
388 id
.stack_addr
= stack_addr
;
390 id
.code_addr
= code_addr
;
392 id
.special_addr
= special_addr
;
393 id
.special_addr_p
= 1;
398 frame_id_build (CORE_ADDR stack_addr
, CORE_ADDR code_addr
)
400 struct frame_id id
= null_frame_id
;
402 id
.stack_addr
= stack_addr
;
404 id
.code_addr
= code_addr
;
410 frame_id_build_wild (CORE_ADDR stack_addr
)
412 struct frame_id id
= null_frame_id
;
414 id
.stack_addr
= stack_addr
;
420 frame_id_p (struct frame_id l
)
424 /* The frame is valid iff it has a valid stack address. */
426 /* outer_frame_id is also valid. */
427 if (!p
&& memcmp (&l
, &outer_frame_id
, sizeof (l
)) == 0)
431 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_p (l=");
432 fprint_frame_id (gdb_stdlog
, l
);
433 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", p
);
439 frame_id_inlined_p (struct frame_id l
)
444 return (l
.inline_depth
!= 0);
448 frame_id_eq (struct frame_id l
, struct frame_id r
)
452 if (!l
.stack_addr_p
&& l
.special_addr_p
453 && !r
.stack_addr_p
&& r
.special_addr_p
)
454 /* The outermost frame marker is equal to itself. This is the
455 dodgy thing about outer_frame_id, since between execution steps
456 we might step into another function - from which we can't
457 unwind either. More thought required to get rid of
460 else if (!l
.stack_addr_p
|| !r
.stack_addr_p
)
461 /* Like a NaN, if either ID is invalid, the result is false.
462 Note that a frame ID is invalid iff it is the null frame ID. */
464 else if (l
.stack_addr
!= r
.stack_addr
)
465 /* If .stack addresses are different, the frames are different. */
467 else if (l
.code_addr_p
&& r
.code_addr_p
&& l
.code_addr
!= r
.code_addr
)
468 /* An invalid code addr is a wild card. If .code addresses are
469 different, the frames are different. */
471 else if (l
.special_addr_p
&& r
.special_addr_p
472 && l
.special_addr
!= r
.special_addr
)
473 /* An invalid special addr is a wild card (or unused). Otherwise
474 if special addresses are different, the frames are different. */
476 else if (l
.inline_depth
!= r
.inline_depth
)
477 /* If inline depths are different, the frames must be different. */
480 /* Frames are equal. */
485 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_eq (l=");
486 fprint_frame_id (gdb_stdlog
, l
);
487 fprintf_unfiltered (gdb_stdlog
, ",r=");
488 fprint_frame_id (gdb_stdlog
, r
);
489 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", eq
);
494 /* Safety net to check whether frame ID L should be inner to
495 frame ID R, according to their stack addresses.
497 This method cannot be used to compare arbitrary frames, as the
498 ranges of valid stack addresses may be discontiguous (e.g. due
501 However, it can be used as safety net to discover invalid frame
502 IDs in certain circumstances. Assuming that NEXT is the immediate
503 inner frame to THIS and that NEXT and THIS are both NORMAL frames:
505 * The stack address of NEXT must be inner-than-or-equal to the stack
508 Therefore, if frame_id_inner (THIS, NEXT) holds, some unwind
511 * If NEXT and THIS have different stack addresses, no other frame
512 in the frame chain may have a stack address in between.
514 Therefore, if frame_id_inner (TEST, THIS) holds, but
515 frame_id_inner (TEST, NEXT) does not hold, TEST cannot refer
516 to a valid frame in the frame chain.
518 The sanity checks above cannot be performed when a SIGTRAMP frame
519 is involved, because signal handlers might be executed on a different
520 stack than the stack used by the routine that caused the signal
521 to be raised. This can happen for instance when a thread exceeds
522 its maximum stack size. In this case, certain compilers implement
523 a stack overflow strategy that cause the handler to be run on a
527 frame_id_inner (struct gdbarch
*gdbarch
, struct frame_id l
, struct frame_id r
)
531 if (!l
.stack_addr_p
|| !r
.stack_addr_p
)
532 /* Like NaN, any operation involving an invalid ID always fails. */
534 else if (l
.inline_depth
> r
.inline_depth
535 && l
.stack_addr
== r
.stack_addr
536 && l
.code_addr_p
== r
.code_addr_p
537 && l
.special_addr_p
== r
.special_addr_p
538 && l
.special_addr
== r
.special_addr
)
540 /* Same function, different inlined functions. */
541 struct block
*lb
, *rb
;
543 gdb_assert (l
.code_addr_p
&& r
.code_addr_p
);
545 lb
= block_for_pc (l
.code_addr
);
546 rb
= block_for_pc (r
.code_addr
);
548 if (lb
== NULL
|| rb
== NULL
)
549 /* Something's gone wrong. */
552 /* This will return true if LB and RB are the same block, or
553 if the block with the smaller depth lexically encloses the
554 block with the greater depth. */
555 inner
= contained_in (lb
, rb
);
558 /* Only return non-zero when strictly inner than. Note that, per
559 comment in "frame.h", there is some fuzz here. Frameless
560 functions are not strictly inner than (same .stack but
561 different .code and/or .special address). */
562 inner
= gdbarch_inner_than (gdbarch
, l
.stack_addr
, r
.stack_addr
);
565 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_inner (l=");
566 fprint_frame_id (gdb_stdlog
, l
);
567 fprintf_unfiltered (gdb_stdlog
, ",r=");
568 fprint_frame_id (gdb_stdlog
, r
);
569 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", inner
);
575 frame_find_by_id (struct frame_id id
)
577 struct frame_info
*frame
, *prev_frame
;
579 /* ZERO denotes the null frame, let the caller decide what to do
580 about it. Should it instead return get_current_frame()? */
581 if (!frame_id_p (id
))
584 /* Try using the frame stash first. Finding it there removes the need
585 to perform the search by looping over all frames, which can be very
586 CPU-intensive if the number of frames is very high (the loop is O(n)
587 and get_prev_frame performs a series of checks that are relatively
588 expensive). This optimization is particularly useful when this function
589 is called from another function (such as value_fetch_lazy, case
590 VALUE_LVAL (val) == lval_register) which already loops over all frames,
591 making the overall behavior O(n^2). */
592 frame
= frame_stash_find (id
);
596 for (frame
= get_current_frame (); ; frame
= prev_frame
)
598 struct frame_id
this = get_frame_id (frame
);
600 if (frame_id_eq (id
, this))
601 /* An exact match. */
604 prev_frame
= get_prev_frame (frame
);
608 /* As a safety net to avoid unnecessary backtracing while trying
609 to find an invalid ID, we check for a common situation where
610 we can detect from comparing stack addresses that no other
611 frame in the current frame chain can have this ID. See the
612 comment at frame_id_inner for details. */
613 if (get_frame_type (frame
) == NORMAL_FRAME
614 && !frame_id_inner (get_frame_arch (frame
), id
, this)
615 && frame_id_inner (get_frame_arch (prev_frame
), id
,
616 get_frame_id (prev_frame
)))
623 frame_unwind_pc (struct frame_info
*this_frame
)
625 if (!this_frame
->prev_pc
.p
)
629 if (gdbarch_unwind_pc_p (frame_unwind_arch (this_frame
)))
631 /* The right way. The `pure' way. The one true way. This
632 method depends solely on the register-unwind code to
633 determine the value of registers in THIS frame, and hence
634 the value of this frame's PC (resume address). A typical
635 implementation is no more than:
637 frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
638 return extract_unsigned_integer (buf, size of ISA_PC_REGNUM);
640 Note: this method is very heavily dependent on a correct
641 register-unwind implementation, it pays to fix that
642 method first; this method is frame type agnostic, since
643 it only deals with register values, it works with any
644 frame. This is all in stark contrast to the old
645 FRAME_SAVED_PC which would try to directly handle all the
646 different ways that a PC could be unwound. */
647 pc
= gdbarch_unwind_pc (frame_unwind_arch (this_frame
), this_frame
);
650 internal_error (__FILE__
, __LINE__
, _("No unwind_pc method"));
651 this_frame
->prev_pc
.value
= pc
;
652 this_frame
->prev_pc
.p
= 1;
654 fprintf_unfiltered (gdb_stdlog
,
655 "{ frame_unwind_caller_pc "
656 "(this_frame=%d) -> %s }\n",
658 hex_string (this_frame
->prev_pc
.value
));
660 return this_frame
->prev_pc
.value
;
664 frame_unwind_caller_pc (struct frame_info
*this_frame
)
666 return frame_unwind_pc (skip_inlined_frames (this_frame
));
670 get_frame_func (struct frame_info
*this_frame
)
672 struct frame_info
*next_frame
= this_frame
->next
;
674 if (!next_frame
->prev_func
.p
)
676 /* Make certain that this, and not the adjacent, function is
678 CORE_ADDR addr_in_block
= get_frame_address_in_block (this_frame
);
679 next_frame
->prev_func
.p
= 1;
680 next_frame
->prev_func
.addr
= get_pc_function_start (addr_in_block
);
682 fprintf_unfiltered (gdb_stdlog
,
683 "{ get_frame_func (this_frame=%d) -> %s }\n",
685 hex_string (next_frame
->prev_func
.addr
));
687 return next_frame
->prev_func
.addr
;
690 static enum register_status
691 do_frame_register_read (void *src
, int regnum
, gdb_byte
*buf
)
693 if (!frame_register_read (src
, regnum
, buf
))
694 return REG_UNAVAILABLE
;
700 frame_save_as_regcache (struct frame_info
*this_frame
)
702 struct address_space
*aspace
= get_frame_address_space (this_frame
);
703 struct regcache
*regcache
= regcache_xmalloc (get_frame_arch (this_frame
),
705 struct cleanup
*cleanups
= make_cleanup_regcache_xfree (regcache
);
707 regcache_save (regcache
, do_frame_register_read
, this_frame
);
708 discard_cleanups (cleanups
);
713 frame_pop (struct frame_info
*this_frame
)
715 struct frame_info
*prev_frame
;
716 struct regcache
*scratch
;
717 struct cleanup
*cleanups
;
719 if (get_frame_type (this_frame
) == DUMMY_FRAME
)
721 /* Popping a dummy frame involves restoring more than just registers.
722 dummy_frame_pop does all the work. */
723 dummy_frame_pop (get_frame_id (this_frame
));
727 /* Ensure that we have a frame to pop to. */
728 prev_frame
= get_prev_frame_1 (this_frame
);
731 error (_("Cannot pop the initial frame."));
733 /* Make a copy of all the register values unwound from this frame.
734 Save them in a scratch buffer so that there isn't a race between
735 trying to extract the old values from the current regcache while
736 at the same time writing new values into that same cache. */
737 scratch
= frame_save_as_regcache (prev_frame
);
738 cleanups
= make_cleanup_regcache_xfree (scratch
);
740 /* FIXME: cagney/2003-03-16: It should be possible to tell the
741 target's register cache that it is about to be hit with a burst
742 register transfer and that the sequence of register writes should
743 be batched. The pair target_prepare_to_store() and
744 target_store_registers() kind of suggest this functionality.
745 Unfortunately, they don't implement it. Their lack of a formal
746 definition can lead to targets writing back bogus values
747 (arguably a bug in the target code mind). */
748 /* Now copy those saved registers into the current regcache.
749 Here, regcache_cpy() calls regcache_restore(). */
750 regcache_cpy (get_current_regcache (), scratch
);
751 do_cleanups (cleanups
);
753 /* We've made right mess of GDB's local state, just discard
755 reinit_frame_cache ();
759 frame_register_unwind (struct frame_info
*frame
, int regnum
,
760 int *optimizedp
, int *unavailablep
,
761 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
762 int *realnump
, gdb_byte
*bufferp
)
766 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
767 that the value proper does not need to be fetched. */
768 gdb_assert (optimizedp
!= NULL
);
769 gdb_assert (lvalp
!= NULL
);
770 gdb_assert (addrp
!= NULL
);
771 gdb_assert (realnump
!= NULL
);
772 /* gdb_assert (bufferp != NULL); */
774 value
= frame_unwind_register_value (frame
, regnum
);
776 gdb_assert (value
!= NULL
);
778 *optimizedp
= value_optimized_out (value
);
779 *unavailablep
= !value_entirely_available (value
);
780 *lvalp
= VALUE_LVAL (value
);
781 *addrp
= value_address (value
);
782 *realnump
= VALUE_REGNUM (value
);
786 if (!*optimizedp
&& !*unavailablep
)
787 memcpy (bufferp
, value_contents_all (value
),
788 TYPE_LENGTH (value_type (value
)));
790 memset (bufferp
, 0, TYPE_LENGTH (value_type (value
)));
793 /* Dispose of the new value. This prevents watchpoints from
794 trying to watch the saved frame pointer. */
795 release_value (value
);
800 frame_register (struct frame_info
*frame
, int regnum
,
801 int *optimizedp
, int *unavailablep
, enum lval_type
*lvalp
,
802 CORE_ADDR
*addrp
, int *realnump
, gdb_byte
*bufferp
)
804 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
805 that the value proper does not need to be fetched. */
806 gdb_assert (optimizedp
!= NULL
);
807 gdb_assert (lvalp
!= NULL
);
808 gdb_assert (addrp
!= NULL
);
809 gdb_assert (realnump
!= NULL
);
810 /* gdb_assert (bufferp != NULL); */
812 /* Obtain the register value by unwinding the register from the next
813 (more inner frame). */
814 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
815 frame_register_unwind (frame
->next
, regnum
, optimizedp
, unavailablep
,
816 lvalp
, addrp
, realnump
, bufferp
);
820 frame_unwind_register (struct frame_info
*frame
, int regnum
, gdb_byte
*buf
)
828 frame_register_unwind (frame
, regnum
, &optimized
, &unavailable
,
829 &lval
, &addr
, &realnum
, buf
);
833 get_frame_register (struct frame_info
*frame
,
834 int regnum
, gdb_byte
*buf
)
836 frame_unwind_register (frame
->next
, regnum
, buf
);
840 frame_unwind_register_value (struct frame_info
*frame
, int regnum
)
842 struct gdbarch
*gdbarch
;
845 gdb_assert (frame
!= NULL
);
846 gdbarch
= frame_unwind_arch (frame
);
850 fprintf_unfiltered (gdb_stdlog
,
851 "{ frame_unwind_register_value "
852 "(frame=%d,regnum=%d(%s),...) ",
853 frame
->level
, regnum
,
854 user_reg_map_regnum_to_name (gdbarch
, regnum
));
857 /* Find the unwinder. */
858 if (frame
->unwind
== NULL
)
859 frame_unwind_find_by_frame (frame
, &frame
->prologue_cache
);
861 /* Ask this frame to unwind its register. */
862 value
= frame
->unwind
->prev_register (frame
, &frame
->prologue_cache
, regnum
);
866 fprintf_unfiltered (gdb_stdlog
, "->");
867 if (value_optimized_out (value
))
868 fprintf_unfiltered (gdb_stdlog
, " optimized out");
871 if (VALUE_LVAL (value
) == lval_register
)
872 fprintf_unfiltered (gdb_stdlog
, " register=%d",
873 VALUE_REGNUM (value
));
874 else if (VALUE_LVAL (value
) == lval_memory
)
875 fprintf_unfiltered (gdb_stdlog
, " address=%s",
877 value_address (value
)));
879 fprintf_unfiltered (gdb_stdlog
, " computed");
881 if (value_lazy (value
))
882 fprintf_unfiltered (gdb_stdlog
, " lazy");
886 const gdb_byte
*buf
= value_contents (value
);
888 fprintf_unfiltered (gdb_stdlog
, " bytes=");
889 fprintf_unfiltered (gdb_stdlog
, "[");
890 for (i
= 0; i
< register_size (gdbarch
, regnum
); i
++)
891 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
892 fprintf_unfiltered (gdb_stdlog
, "]");
896 fprintf_unfiltered (gdb_stdlog
, " }\n");
903 get_frame_register_value (struct frame_info
*frame
, int regnum
)
905 return frame_unwind_register_value (frame
->next
, regnum
);
909 frame_unwind_register_signed (struct frame_info
*frame
, int regnum
)
911 struct gdbarch
*gdbarch
= frame_unwind_arch (frame
);
912 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
913 int size
= register_size (gdbarch
, regnum
);
914 gdb_byte buf
[MAX_REGISTER_SIZE
];
916 frame_unwind_register (frame
, regnum
, buf
);
917 return extract_signed_integer (buf
, size
, byte_order
);
921 get_frame_register_signed (struct frame_info
*frame
, int regnum
)
923 return frame_unwind_register_signed (frame
->next
, regnum
);
927 frame_unwind_register_unsigned (struct frame_info
*frame
, int regnum
)
929 struct gdbarch
*gdbarch
= frame_unwind_arch (frame
);
930 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
931 int size
= register_size (gdbarch
, regnum
);
932 gdb_byte buf
[MAX_REGISTER_SIZE
];
934 frame_unwind_register (frame
, regnum
, buf
);
935 return extract_unsigned_integer (buf
, size
, byte_order
);
939 get_frame_register_unsigned (struct frame_info
*frame
, int regnum
)
941 return frame_unwind_register_unsigned (frame
->next
, regnum
);
945 put_frame_register (struct frame_info
*frame
, int regnum
,
948 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
955 frame_register (frame
, regnum
, &optim
, &unavail
,
956 &lval
, &addr
, &realnum
, NULL
);
958 error (_("Attempt to assign to a value that was optimized out."));
963 /* FIXME: write_memory doesn't yet take constant buffers.
965 gdb_byte tmp
[MAX_REGISTER_SIZE
];
967 memcpy (tmp
, buf
, register_size (gdbarch
, regnum
));
968 write_memory (addr
, tmp
, register_size (gdbarch
, regnum
));
972 regcache_cooked_write (get_current_regcache (), realnum
, buf
);
975 error (_("Attempt to assign to an unmodifiable value."));
979 /* frame_register_read ()
981 Find and return the value of REGNUM for the specified stack frame.
982 The number of bytes copied is REGISTER_SIZE (REGNUM).
984 Returns 0 if the register value could not be found. */
987 frame_register_read (struct frame_info
*frame
, int regnum
,
996 frame_register (frame
, regnum
, &optimized
, &unavailable
,
997 &lval
, &addr
, &realnum
, myaddr
);
999 return !optimized
&& !unavailable
;
1003 get_frame_register_bytes (struct frame_info
*frame
, int regnum
,
1004 CORE_ADDR offset
, int len
, gdb_byte
*myaddr
)
1006 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1011 /* Skip registers wholly inside of OFFSET. */
1012 while (offset
>= register_size (gdbarch
, regnum
))
1014 offset
-= register_size (gdbarch
, regnum
);
1018 /* Ensure that we will not read beyond the end of the register file.
1019 This can only ever happen if the debug information is bad. */
1021 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1022 for (i
= regnum
; i
< numregs
; i
++)
1024 int thissize
= register_size (gdbarch
, i
);
1027 break; /* This register is not available on this architecture. */
1028 maxsize
+= thissize
;
1032 warning (_("Bad debug information detected: "
1033 "Attempt to read %d bytes from registers."), len
);
1037 /* Copy the data. */
1040 int curr_len
= register_size (gdbarch
, regnum
) - offset
;
1045 if (curr_len
== register_size (gdbarch
, regnum
))
1047 if (!frame_register_read (frame
, regnum
, myaddr
))
1052 gdb_byte buf
[MAX_REGISTER_SIZE
];
1054 if (!frame_register_read (frame
, regnum
, buf
))
1056 memcpy (myaddr
, buf
+ offset
, curr_len
);
1069 put_frame_register_bytes (struct frame_info
*frame
, int regnum
,
1070 CORE_ADDR offset
, int len
, const gdb_byte
*myaddr
)
1072 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1074 /* Skip registers wholly inside of OFFSET. */
1075 while (offset
>= register_size (gdbarch
, regnum
))
1077 offset
-= register_size (gdbarch
, regnum
);
1081 /* Copy the data. */
1084 int curr_len
= register_size (gdbarch
, regnum
) - offset
;
1089 if (curr_len
== register_size (gdbarch
, regnum
))
1091 put_frame_register (frame
, regnum
, myaddr
);
1095 gdb_byte buf
[MAX_REGISTER_SIZE
];
1097 frame_register_read (frame
, regnum
, buf
);
1098 memcpy (buf
+ offset
, myaddr
, curr_len
);
1099 put_frame_register (frame
, regnum
, buf
);
1109 /* Create a sentinel frame. */
1111 static struct frame_info
*
1112 create_sentinel_frame (struct program_space
*pspace
, struct regcache
*regcache
)
1114 struct frame_info
*frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1117 frame
->pspace
= pspace
;
1118 frame
->aspace
= get_regcache_aspace (regcache
);
1119 /* Explicitly initialize the sentinel frame's cache. Provide it
1120 with the underlying regcache. In the future additional
1121 information, such as the frame's thread will be added. */
1122 frame
->prologue_cache
= sentinel_frame_cache (regcache
);
1123 /* For the moment there is only one sentinel frame implementation. */
1124 frame
->unwind
= &sentinel_frame_unwind
;
1125 /* Link this frame back to itself. The frame is self referential
1126 (the unwound PC is the same as the pc), so make it so. */
1127 frame
->next
= frame
;
1128 /* Make the sentinel frame's ID valid, but invalid. That way all
1129 comparisons with it should fail. */
1130 frame
->this_id
.p
= 1;
1131 frame
->this_id
.value
= null_frame_id
;
1134 fprintf_unfiltered (gdb_stdlog
, "{ create_sentinel_frame (...) -> ");
1135 fprint_frame (gdb_stdlog
, frame
);
1136 fprintf_unfiltered (gdb_stdlog
, " }\n");
1141 /* Info about the innermost stack frame (contents of FP register). */
1143 static struct frame_info
*current_frame
;
1145 /* Cache for frame addresses already read by gdb. Valid only while
1146 inferior is stopped. Control variables for the frame cache should
1147 be local to this module. */
1149 static struct obstack frame_cache_obstack
;
1152 frame_obstack_zalloc (unsigned long size
)
1154 void *data
= obstack_alloc (&frame_cache_obstack
, size
);
1156 memset (data
, 0, size
);
1160 /* Return the innermost (currently executing) stack frame. This is
1161 split into two functions. The function unwind_to_current_frame()
1162 is wrapped in catch exceptions so that, even when the unwind of the
1163 sentinel frame fails, the function still returns a stack frame. */
1166 unwind_to_current_frame (struct ui_out
*ui_out
, void *args
)
1168 struct frame_info
*frame
= get_prev_frame (args
);
1170 /* A sentinel frame can fail to unwind, e.g., because its PC value
1171 lands in somewhere like start. */
1174 current_frame
= frame
;
1179 get_current_frame (void)
1181 /* First check, and report, the lack of registers. Having GDB
1182 report "No stack!" or "No memory" when the target doesn't even
1183 have registers is very confusing. Besides, "printcmd.exp"
1184 explicitly checks that ``print $pc'' with no registers prints "No
1186 if (!target_has_registers
)
1187 error (_("No registers."));
1188 if (!target_has_stack
)
1189 error (_("No stack."));
1190 if (!target_has_memory
)
1191 error (_("No memory."));
1192 /* Traceframes are effectively a substitute for the live inferior. */
1193 if (get_traceframe_number () < 0)
1195 if (ptid_equal (inferior_ptid
, null_ptid
))
1196 error (_("No selected thread."));
1197 if (is_exited (inferior_ptid
))
1198 error (_("Invalid selected thread."));
1199 if (is_executing (inferior_ptid
))
1200 error (_("Target is executing."));
1203 if (current_frame
== NULL
)
1205 struct frame_info
*sentinel_frame
=
1206 create_sentinel_frame (current_program_space
, get_current_regcache ());
1207 if (catch_exceptions (uiout
, unwind_to_current_frame
, sentinel_frame
,
1208 RETURN_MASK_ERROR
) != 0)
1210 /* Oops! Fake a current frame? Is this useful? It has a PC
1211 of zero, for instance. */
1212 current_frame
= sentinel_frame
;
1215 return current_frame
;
1218 /* The "selected" stack frame is used by default for local and arg
1219 access. May be zero, for no selected frame. */
1221 static struct frame_info
*selected_frame
;
1224 has_stack_frames (void)
1226 if (!target_has_registers
|| !target_has_stack
|| !target_has_memory
)
1229 /* No current inferior, no frame. */
1230 if (ptid_equal (inferior_ptid
, null_ptid
))
1233 /* Don't try to read from a dead thread. */
1234 if (is_exited (inferior_ptid
))
1237 /* ... or from a spinning thread. */
1238 if (is_executing (inferior_ptid
))
1244 /* Return the selected frame. Always non-NULL (unless there isn't an
1245 inferior sufficient for creating a frame) in which case an error is
1249 get_selected_frame (const char *message
)
1251 if (selected_frame
== NULL
)
1253 if (message
!= NULL
&& !has_stack_frames ())
1254 error (("%s"), message
);
1255 /* Hey! Don't trust this. It should really be re-finding the
1256 last selected frame of the currently selected thread. This,
1257 though, is better than nothing. */
1258 select_frame (get_current_frame ());
1260 /* There is always a frame. */
1261 gdb_assert (selected_frame
!= NULL
);
1262 return selected_frame
;
1265 /* If there is a selected frame, return it. Otherwise, return NULL. */
1268 get_selected_frame_if_set (void)
1270 return selected_frame
;
1273 /* This is a variant of get_selected_frame() which can be called when
1274 the inferior does not have a frame; in that case it will return
1275 NULL instead of calling error(). */
1278 deprecated_safe_get_selected_frame (void)
1280 if (!has_stack_frames ())
1282 return get_selected_frame (NULL
);
1285 /* Select frame FI (or NULL - to invalidate the current frame). */
1288 select_frame (struct frame_info
*fi
)
1292 selected_frame
= fi
;
1293 /* NOTE: cagney/2002-05-04: FI can be NULL. This occurs when the
1294 frame is being invalidated. */
1295 if (deprecated_selected_frame_level_changed_hook
)
1296 deprecated_selected_frame_level_changed_hook (frame_relative_level (fi
));
1298 /* FIXME: kseitz/2002-08-28: It would be nice to call
1299 selected_frame_level_changed_event() right here, but due to limitations
1300 in the current interfaces, we would end up flooding UIs with events
1301 because select_frame() is used extensively internally.
1303 Once we have frame-parameterized frame (and frame-related) commands,
1304 the event notification can be moved here, since this function will only
1305 be called when the user's selected frame is being changed. */
1307 /* Ensure that symbols for this frame are read in. Also, determine the
1308 source language of this frame, and switch to it if desired. */
1311 /* We retrieve the frame's symtab by using the frame PC. However
1312 we cannot use the frame PC as-is, because it usually points to
1313 the instruction following the "call", which is sometimes the
1314 first instruction of another function. So we rely on
1315 get_frame_address_in_block() which provides us with a PC which
1316 is guaranteed to be inside the frame's code block. */
1317 s
= find_pc_symtab (get_frame_address_in_block (fi
));
1319 && s
->language
!= current_language
->la_language
1320 && s
->language
!= language_unknown
1321 && language_mode
== language_mode_auto
)
1323 set_language (s
->language
);
1328 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
1329 Always returns a non-NULL value. */
1332 create_new_frame (CORE_ADDR addr
, CORE_ADDR pc
)
1334 struct frame_info
*fi
;
1338 fprintf_unfiltered (gdb_stdlog
,
1339 "{ create_new_frame (addr=%s, pc=%s) ",
1340 hex_string (addr
), hex_string (pc
));
1343 fi
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1345 fi
->next
= create_sentinel_frame (current_program_space
,
1346 get_current_regcache ());
1348 /* Set/update this frame's cached PC value, found in the next frame.
1349 Do this before looking for this frame's unwinder. A sniffer is
1350 very likely to read this, and the corresponding unwinder is
1351 entitled to rely that the PC doesn't magically change. */
1352 fi
->next
->prev_pc
.value
= pc
;
1353 fi
->next
->prev_pc
.p
= 1;
1355 /* We currently assume that frame chain's can't cross spaces. */
1356 fi
->pspace
= fi
->next
->pspace
;
1357 fi
->aspace
= fi
->next
->aspace
;
1359 /* Select/initialize both the unwind function and the frame's type
1361 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
1364 fi
->this_id
.value
= frame_id_build (addr
, pc
);
1368 fprintf_unfiltered (gdb_stdlog
, "-> ");
1369 fprint_frame (gdb_stdlog
, fi
);
1370 fprintf_unfiltered (gdb_stdlog
, " }\n");
1376 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
1377 innermost frame). Be careful to not fall off the bottom of the
1378 frame chain and onto the sentinel frame. */
1381 get_next_frame (struct frame_info
*this_frame
)
1383 if (this_frame
->level
> 0)
1384 return this_frame
->next
;
1389 /* Observer for the target_changed event. */
1392 frame_observer_target_changed (struct target_ops
*target
)
1394 reinit_frame_cache ();
1397 /* Flush the entire frame cache. */
1400 reinit_frame_cache (void)
1402 struct frame_info
*fi
;
1404 /* Tear down all frame caches. */
1405 for (fi
= current_frame
; fi
!= NULL
; fi
= fi
->prev
)
1407 if (fi
->prologue_cache
&& fi
->unwind
->dealloc_cache
)
1408 fi
->unwind
->dealloc_cache (fi
, fi
->prologue_cache
);
1409 if (fi
->base_cache
&& fi
->base
->unwind
->dealloc_cache
)
1410 fi
->base
->unwind
->dealloc_cache (fi
, fi
->base_cache
);
1413 /* Since we can't really be sure what the first object allocated was. */
1414 obstack_free (&frame_cache_obstack
, 0);
1415 obstack_init (&frame_cache_obstack
);
1417 if (current_frame
!= NULL
)
1418 annotate_frames_invalid ();
1420 current_frame
= NULL
; /* Invalidate cache */
1421 select_frame (NULL
);
1422 frame_stash_invalidate ();
1424 fprintf_unfiltered (gdb_stdlog
, "{ reinit_frame_cache () }\n");
1427 /* Find where a register is saved (in memory or another register).
1428 The result of frame_register_unwind is just where it is saved
1429 relative to this particular frame. */
1432 frame_register_unwind_location (struct frame_info
*this_frame
, int regnum
,
1433 int *optimizedp
, enum lval_type
*lvalp
,
1434 CORE_ADDR
*addrp
, int *realnump
)
1436 gdb_assert (this_frame
== NULL
|| this_frame
->level
>= 0);
1438 while (this_frame
!= NULL
)
1442 frame_register_unwind (this_frame
, regnum
, optimizedp
, &unavailable
,
1443 lvalp
, addrp
, realnump
, NULL
);
1448 if (*lvalp
!= lval_register
)
1452 this_frame
= get_next_frame (this_frame
);
1456 /* Return a "struct frame_info" corresponding to the frame that called
1457 THIS_FRAME. Returns NULL if there is no such frame.
1459 Unlike get_prev_frame, this function always tries to unwind the
1462 static struct frame_info
*
1463 get_prev_frame_1 (struct frame_info
*this_frame
)
1465 struct frame_id this_id
;
1466 struct gdbarch
*gdbarch
;
1468 gdb_assert (this_frame
!= NULL
);
1469 gdbarch
= get_frame_arch (this_frame
);
1473 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame_1 (this_frame=");
1474 if (this_frame
!= NULL
)
1475 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1477 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1478 fprintf_unfiltered (gdb_stdlog
, ") ");
1481 /* Only try to do the unwind once. */
1482 if (this_frame
->prev_p
)
1486 fprintf_unfiltered (gdb_stdlog
, "-> ");
1487 fprint_frame (gdb_stdlog
, this_frame
->prev
);
1488 fprintf_unfiltered (gdb_stdlog
, " // cached \n");
1490 return this_frame
->prev
;
1493 /* If the frame unwinder hasn't been selected yet, we must do so
1494 before setting prev_p; otherwise the check for misbehaved
1495 sniffers will think that this frame's sniffer tried to unwind
1496 further (see frame_cleanup_after_sniffer). */
1497 if (this_frame
->unwind
== NULL
)
1498 frame_unwind_find_by_frame (this_frame
, &this_frame
->prologue_cache
);
1500 this_frame
->prev_p
= 1;
1501 this_frame
->stop_reason
= UNWIND_NO_REASON
;
1503 /* If we are unwinding from an inline frame, all of the below tests
1504 were already performed when we unwound from the next non-inline
1505 frame. We must skip them, since we can not get THIS_FRAME's ID
1506 until we have unwound all the way down to the previous non-inline
1508 if (get_frame_type (this_frame
) == INLINE_FRAME
)
1509 return get_prev_frame_raw (this_frame
);
1511 /* Check that this frame's ID was valid. If it wasn't, don't try to
1512 unwind to the prev frame. Be careful to not apply this test to
1513 the sentinel frame. */
1514 this_id
= get_frame_id (this_frame
);
1515 if (this_frame
->level
>= 0 && frame_id_eq (this_id
, outer_frame_id
))
1519 fprintf_unfiltered (gdb_stdlog
, "-> ");
1520 fprint_frame (gdb_stdlog
, NULL
);
1521 fprintf_unfiltered (gdb_stdlog
, " // this ID is NULL }\n");
1523 this_frame
->stop_reason
= UNWIND_NULL_ID
;
1527 /* Check that this frame's ID isn't inner to (younger, below, next)
1528 the next frame. This happens when a frame unwind goes backwards.
1529 This check is valid only if this frame and the next frame are NORMAL.
1530 See the comment at frame_id_inner for details. */
1531 if (get_frame_type (this_frame
) == NORMAL_FRAME
1532 && this_frame
->next
->unwind
->type
== NORMAL_FRAME
1533 && frame_id_inner (get_frame_arch (this_frame
->next
), this_id
,
1534 get_frame_id (this_frame
->next
)))
1536 CORE_ADDR this_pc_in_block
;
1537 struct minimal_symbol
*morestack_msym
;
1538 const char *morestack_name
= NULL
;
1540 /* gcc -fsplit-stack __morestack can continue the stack anywhere. */
1541 this_pc_in_block
= get_frame_address_in_block (this_frame
);
1542 morestack_msym
= lookup_minimal_symbol_by_pc (this_pc_in_block
);
1544 morestack_name
= SYMBOL_LINKAGE_NAME (morestack_msym
);
1545 if (!morestack_name
|| strcmp (morestack_name
, "__morestack") != 0)
1549 fprintf_unfiltered (gdb_stdlog
, "-> ");
1550 fprint_frame (gdb_stdlog
, NULL
);
1551 fprintf_unfiltered (gdb_stdlog
,
1552 " // this frame ID is inner }\n");
1554 this_frame
->stop_reason
= UNWIND_INNER_ID
;
1559 /* Check that this and the next frame are not identical. If they
1560 are, there is most likely a stack cycle. As with the inner-than
1561 test above, avoid comparing the inner-most and sentinel frames. */
1562 if (this_frame
->level
> 0
1563 && frame_id_eq (this_id
, get_frame_id (this_frame
->next
)))
1567 fprintf_unfiltered (gdb_stdlog
, "-> ");
1568 fprint_frame (gdb_stdlog
, NULL
);
1569 fprintf_unfiltered (gdb_stdlog
, " // this frame has same ID }\n");
1571 this_frame
->stop_reason
= UNWIND_SAME_ID
;
1575 /* Check that this and the next frame do not unwind the PC register
1576 to the same memory location. If they do, then even though they
1577 have different frame IDs, the new frame will be bogus; two
1578 functions can't share a register save slot for the PC. This can
1579 happen when the prologue analyzer finds a stack adjustment, but
1582 This check does assume that the "PC register" is roughly a
1583 traditional PC, even if the gdbarch_unwind_pc method adjusts
1584 it (we do not rely on the value, only on the unwound PC being
1585 dependent on this value). A potential improvement would be
1586 to have the frame prev_pc method and the gdbarch unwind_pc
1587 method set the same lval and location information as
1588 frame_register_unwind. */
1589 if (this_frame
->level
> 0
1590 && gdbarch_pc_regnum (gdbarch
) >= 0
1591 && get_frame_type (this_frame
) == NORMAL_FRAME
1592 && (get_frame_type (this_frame
->next
) == NORMAL_FRAME
1593 || get_frame_type (this_frame
->next
) == INLINE_FRAME
))
1595 int optimized
, realnum
, nrealnum
;
1596 enum lval_type lval
, nlval
;
1597 CORE_ADDR addr
, naddr
;
1599 frame_register_unwind_location (this_frame
,
1600 gdbarch_pc_regnum (gdbarch
),
1601 &optimized
, &lval
, &addr
, &realnum
);
1602 frame_register_unwind_location (get_next_frame (this_frame
),
1603 gdbarch_pc_regnum (gdbarch
),
1604 &optimized
, &nlval
, &naddr
, &nrealnum
);
1606 if ((lval
== lval_memory
&& lval
== nlval
&& addr
== naddr
)
1607 || (lval
== lval_register
&& lval
== nlval
&& realnum
== nrealnum
))
1611 fprintf_unfiltered (gdb_stdlog
, "-> ");
1612 fprint_frame (gdb_stdlog
, NULL
);
1613 fprintf_unfiltered (gdb_stdlog
, " // no saved PC }\n");
1616 this_frame
->stop_reason
= UNWIND_NO_SAVED_PC
;
1617 this_frame
->prev
= NULL
;
1622 return get_prev_frame_raw (this_frame
);
1625 /* Construct a new "struct frame_info" and link it previous to
1628 static struct frame_info
*
1629 get_prev_frame_raw (struct frame_info
*this_frame
)
1631 struct frame_info
*prev_frame
;
1633 /* Allocate the new frame but do not wire it in to the frame chain.
1634 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
1635 frame->next to pull some fancy tricks (of course such code is, by
1636 definition, recursive). Try to prevent it.
1638 There is no reason to worry about memory leaks, should the
1639 remainder of the function fail. The allocated memory will be
1640 quickly reclaimed when the frame cache is flushed, and the `we've
1641 been here before' check above will stop repeated memory
1642 allocation calls. */
1643 prev_frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1644 prev_frame
->level
= this_frame
->level
+ 1;
1646 /* For now, assume we don't have frame chains crossing address
1648 prev_frame
->pspace
= this_frame
->pspace
;
1649 prev_frame
->aspace
= this_frame
->aspace
;
1651 /* Don't yet compute ->unwind (and hence ->type). It is computed
1652 on-demand in get_frame_type, frame_register_unwind, and
1655 /* Don't yet compute the frame's ID. It is computed on-demand by
1658 /* The unwound frame ID is validate at the start of this function,
1659 as part of the logic to decide if that frame should be further
1660 unwound, and not here while the prev frame is being created.
1661 Doing this makes it possible for the user to examine a frame that
1662 has an invalid frame ID.
1664 Some very old VAX code noted: [...] For the sake of argument,
1665 suppose that the stack is somewhat trashed (which is one reason
1666 that "info frame" exists). So, return 0 (indicating we don't
1667 know the address of the arglist) if we don't know what frame this
1671 this_frame
->prev
= prev_frame
;
1672 prev_frame
->next
= this_frame
;
1676 fprintf_unfiltered (gdb_stdlog
, "-> ");
1677 fprint_frame (gdb_stdlog
, prev_frame
);
1678 fprintf_unfiltered (gdb_stdlog
, " }\n");
1684 /* Debug routine to print a NULL frame being returned. */
1687 frame_debug_got_null_frame (struct frame_info
*this_frame
,
1692 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame (this_frame=");
1693 if (this_frame
!= NULL
)
1694 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1696 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1697 fprintf_unfiltered (gdb_stdlog
, ") -> // %s}\n", reason
);
1701 /* Is this (non-sentinel) frame in the "main"() function? */
1704 inside_main_func (struct frame_info
*this_frame
)
1706 struct minimal_symbol
*msymbol
;
1709 if (symfile_objfile
== 0)
1711 msymbol
= lookup_minimal_symbol (main_name (), NULL
, symfile_objfile
);
1712 if (msymbol
== NULL
)
1714 /* Make certain that the code, and not descriptor, address is
1716 maddr
= gdbarch_convert_from_func_ptr_addr (get_frame_arch (this_frame
),
1717 SYMBOL_VALUE_ADDRESS (msymbol
),
1719 return maddr
== get_frame_func (this_frame
);
1722 /* Test whether THIS_FRAME is inside the process entry point function. */
1725 inside_entry_func (struct frame_info
*this_frame
)
1727 CORE_ADDR entry_point
;
1729 if (!entry_point_address_query (&entry_point
))
1732 return get_frame_func (this_frame
) == entry_point
;
1735 /* Return a structure containing various interesting information about
1736 the frame that called THIS_FRAME. Returns NULL if there is entier
1737 no such frame or the frame fails any of a set of target-independent
1738 condition that should terminate the frame chain (e.g., as unwinding
1741 This function should not contain target-dependent tests, such as
1742 checking whether the program-counter is zero. */
1745 get_prev_frame (struct frame_info
*this_frame
)
1747 /* There is always a frame. If this assertion fails, suspect that
1748 something should be calling get_selected_frame() or
1749 get_current_frame(). */
1750 gdb_assert (this_frame
!= NULL
);
1752 /* tausq/2004-12-07: Dummy frames are skipped because it doesn't make much
1753 sense to stop unwinding at a dummy frame. One place where a dummy
1754 frame may have an address "inside_main_func" is on HPUX. On HPUX, the
1755 pcsqh register (space register for the instruction at the head of the
1756 instruction queue) cannot be written directly; the only way to set it
1757 is to branch to code that is in the target space. In order to implement
1758 frame dummies on HPUX, the called function is made to jump back to where
1759 the inferior was when the user function was called. If gdb was inside
1760 the main function when we created the dummy frame, the dummy frame will
1761 point inside the main function. */
1762 if (this_frame
->level
>= 0
1763 && get_frame_type (this_frame
) == NORMAL_FRAME
1764 && !backtrace_past_main
1765 && inside_main_func (this_frame
))
1766 /* Don't unwind past main(). Note, this is done _before_ the
1767 frame has been marked as previously unwound. That way if the
1768 user later decides to enable unwinds past main(), that will
1769 automatically happen. */
1771 frame_debug_got_null_frame (this_frame
, "inside main func");
1775 /* If the user's backtrace limit has been exceeded, stop. We must
1776 add two to the current level; one of those accounts for backtrace_limit
1777 being 1-based and the level being 0-based, and the other accounts for
1778 the level of the new frame instead of the level of the current
1780 if (this_frame
->level
+ 2 > backtrace_limit
)
1782 frame_debug_got_null_frame (this_frame
, "backtrace limit exceeded");
1786 /* If we're already inside the entry function for the main objfile,
1787 then it isn't valid. Don't apply this test to a dummy frame -
1788 dummy frame PCs typically land in the entry func. Don't apply
1789 this test to the sentinel frame. Sentinel frames should always
1790 be allowed to unwind. */
1791 /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() -
1792 wasn't checking for "main" in the minimal symbols. With that
1793 fixed asm-source tests now stop in "main" instead of halting the
1794 backtrace in weird and wonderful ways somewhere inside the entry
1795 file. Suspect that tests for inside the entry file/func were
1796 added to work around that (now fixed) case. */
1797 /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
1798 suggested having the inside_entry_func test use the
1799 inside_main_func() msymbol trick (along with entry_point_address()
1800 I guess) to determine the address range of the start function.
1801 That should provide a far better stopper than the current
1803 /* NOTE: tausq/2004-10-09: this is needed if, for example, the compiler
1804 applied tail-call optimizations to main so that a function called
1805 from main returns directly to the caller of main. Since we don't
1806 stop at main, we should at least stop at the entry point of the
1808 if (this_frame
->level
>= 0
1809 && get_frame_type (this_frame
) == NORMAL_FRAME
1810 && !backtrace_past_entry
1811 && inside_entry_func (this_frame
))
1813 frame_debug_got_null_frame (this_frame
, "inside entry func");
1817 /* Assume that the only way to get a zero PC is through something
1818 like a SIGSEGV or a dummy frame, and hence that NORMAL frames
1819 will never unwind a zero PC. */
1820 if (this_frame
->level
> 0
1821 && (get_frame_type (this_frame
) == NORMAL_FRAME
1822 || get_frame_type (this_frame
) == INLINE_FRAME
)
1823 && get_frame_type (get_next_frame (this_frame
)) == NORMAL_FRAME
1824 && get_frame_pc (this_frame
) == 0)
1826 frame_debug_got_null_frame (this_frame
, "zero PC");
1830 return get_prev_frame_1 (this_frame
);
1834 get_frame_pc (struct frame_info
*frame
)
1836 gdb_assert (frame
->next
!= NULL
);
1837 return frame_unwind_pc (frame
->next
);
1840 /* Return an address that falls within THIS_FRAME's code block. */
1843 get_frame_address_in_block (struct frame_info
*this_frame
)
1845 /* A draft address. */
1846 CORE_ADDR pc
= get_frame_pc (this_frame
);
1848 struct frame_info
*next_frame
= this_frame
->next
;
1850 /* Calling get_frame_pc returns the resume address for THIS_FRAME.
1851 Normally the resume address is inside the body of the function
1852 associated with THIS_FRAME, but there is a special case: when
1853 calling a function which the compiler knows will never return
1854 (for instance abort), the call may be the very last instruction
1855 in the calling function. The resume address will point after the
1856 call and may be at the beginning of a different function
1859 If THIS_FRAME is a signal frame or dummy frame, then we should
1860 not adjust the unwound PC. For a dummy frame, GDB pushed the
1861 resume address manually onto the stack. For a signal frame, the
1862 OS may have pushed the resume address manually and invoked the
1863 handler (e.g. GNU/Linux), or invoked the trampoline which called
1864 the signal handler - but in either case the signal handler is
1865 expected to return to the trampoline. So in both of these
1866 cases we know that the resume address is executable and
1867 related. So we only need to adjust the PC if THIS_FRAME
1868 is a normal function.
1870 If the program has been interrupted while THIS_FRAME is current,
1871 then clearly the resume address is inside the associated
1872 function. There are three kinds of interruption: debugger stop
1873 (next frame will be SENTINEL_FRAME), operating system
1874 signal or exception (next frame will be SIGTRAMP_FRAME),
1875 or debugger-induced function call (next frame will be
1876 DUMMY_FRAME). So we only need to adjust the PC if
1877 NEXT_FRAME is a normal function.
1879 We check the type of NEXT_FRAME first, since it is already
1880 known; frame type is determined by the unwinder, and since
1881 we have THIS_FRAME we've already selected an unwinder for
1884 If the next frame is inlined, we need to keep going until we find
1885 the real function - for instance, if a signal handler is invoked
1886 while in an inlined function, then the code address of the
1887 "calling" normal function should not be adjusted either. */
1889 while (get_frame_type (next_frame
) == INLINE_FRAME
)
1890 next_frame
= next_frame
->next
;
1892 if (get_frame_type (next_frame
) == NORMAL_FRAME
1893 && (get_frame_type (this_frame
) == NORMAL_FRAME
1894 || get_frame_type (this_frame
) == INLINE_FRAME
))
1901 find_frame_sal (struct frame_info
*frame
, struct symtab_and_line
*sal
)
1903 struct frame_info
*next_frame
;
1906 /* If the next frame represents an inlined function call, this frame's
1907 sal is the "call site" of that inlined function, which can not
1908 be inferred from get_frame_pc. */
1909 next_frame
= get_next_frame (frame
);
1910 if (frame_inlined_callees (frame
) > 0)
1915 sym
= get_frame_function (next_frame
);
1917 sym
= inline_skipped_symbol (inferior_ptid
);
1919 /* If frame is inline, it certainly has symbols. */
1922 if (SYMBOL_LINE (sym
) != 0)
1924 sal
->symtab
= SYMBOL_SYMTAB (sym
);
1925 sal
->line
= SYMBOL_LINE (sym
);
1928 /* If the symbol does not have a location, we don't know where
1929 the call site is. Do not pretend to. This is jarring, but
1930 we can't do much better. */
1931 sal
->pc
= get_frame_pc (frame
);
1936 /* If FRAME is not the innermost frame, that normally means that
1937 FRAME->pc points at the return instruction (which is *after* the
1938 call instruction), and we want to get the line containing the
1939 call (because the call is where the user thinks the program is).
1940 However, if the next frame is either a SIGTRAMP_FRAME or a
1941 DUMMY_FRAME, then the next frame will contain a saved interrupt
1942 PC and such a PC indicates the current (rather than next)
1943 instruction/line, consequently, for such cases, want to get the
1944 line containing fi->pc. */
1945 notcurrent
= (get_frame_pc (frame
) != get_frame_address_in_block (frame
));
1946 (*sal
) = find_pc_line (get_frame_pc (frame
), notcurrent
);
1949 /* Per "frame.h", return the ``address'' of the frame. Code should
1950 really be using get_frame_id(). */
1952 get_frame_base (struct frame_info
*fi
)
1954 return get_frame_id (fi
).stack_addr
;
1957 /* High-level offsets into the frame. Used by the debug info. */
1960 get_frame_base_address (struct frame_info
*fi
)
1962 if (get_frame_type (fi
) != NORMAL_FRAME
)
1964 if (fi
->base
== NULL
)
1965 fi
->base
= frame_base_find_by_frame (fi
);
1966 /* Sneaky: If the low-level unwind and high-level base code share a
1967 common unwinder, let them share the prologue cache. */
1968 if (fi
->base
->unwind
== fi
->unwind
)
1969 return fi
->base
->this_base (fi
, &fi
->prologue_cache
);
1970 return fi
->base
->this_base (fi
, &fi
->base_cache
);
1974 get_frame_locals_address (struct frame_info
*fi
)
1976 if (get_frame_type (fi
) != NORMAL_FRAME
)
1978 /* If there isn't a frame address method, find it. */
1979 if (fi
->base
== NULL
)
1980 fi
->base
= frame_base_find_by_frame (fi
);
1981 /* Sneaky: If the low-level unwind and high-level base code share a
1982 common unwinder, let them share the prologue cache. */
1983 if (fi
->base
->unwind
== fi
->unwind
)
1984 return fi
->base
->this_locals (fi
, &fi
->prologue_cache
);
1985 return fi
->base
->this_locals (fi
, &fi
->base_cache
);
1989 get_frame_args_address (struct frame_info
*fi
)
1991 if (get_frame_type (fi
) != NORMAL_FRAME
)
1993 /* If there isn't a frame address method, find it. */
1994 if (fi
->base
== NULL
)
1995 fi
->base
= frame_base_find_by_frame (fi
);
1996 /* Sneaky: If the low-level unwind and high-level base code share a
1997 common unwinder, let them share the prologue cache. */
1998 if (fi
->base
->unwind
== fi
->unwind
)
1999 return fi
->base
->this_args (fi
, &fi
->prologue_cache
);
2000 return fi
->base
->this_args (fi
, &fi
->base_cache
);
2003 /* Return true if the frame unwinder for frame FI is UNWINDER; false
2007 frame_unwinder_is (struct frame_info
*fi
, const struct frame_unwind
*unwinder
)
2009 if (fi
->unwind
== NULL
)
2010 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
2011 return fi
->unwind
== unwinder
;
2014 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
2015 or -1 for a NULL frame. */
2018 frame_relative_level (struct frame_info
*fi
)
2027 get_frame_type (struct frame_info
*frame
)
2029 if (frame
->unwind
== NULL
)
2030 /* Initialize the frame's unwinder because that's what
2031 provides the frame's type. */
2032 frame_unwind_find_by_frame (frame
, &frame
->prologue_cache
);
2033 return frame
->unwind
->type
;
2036 struct program_space
*
2037 get_frame_program_space (struct frame_info
*frame
)
2039 return frame
->pspace
;
2042 struct program_space
*
2043 frame_unwind_program_space (struct frame_info
*this_frame
)
2045 gdb_assert (this_frame
);
2047 /* This is really a placeholder to keep the API consistent --- we
2048 assume for now that we don't have frame chains crossing
2050 return this_frame
->pspace
;
2053 struct address_space
*
2054 get_frame_address_space (struct frame_info
*frame
)
2056 return frame
->aspace
;
2059 /* Memory access methods. */
2062 get_frame_memory (struct frame_info
*this_frame
, CORE_ADDR addr
,
2063 gdb_byte
*buf
, int len
)
2065 read_memory (addr
, buf
, len
);
2069 get_frame_memory_signed (struct frame_info
*this_frame
, CORE_ADDR addr
,
2072 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2073 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2075 return read_memory_integer (addr
, len
, byte_order
);
2079 get_frame_memory_unsigned (struct frame_info
*this_frame
, CORE_ADDR addr
,
2082 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2083 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2085 return read_memory_unsigned_integer (addr
, len
, byte_order
);
2089 safe_frame_unwind_memory (struct frame_info
*this_frame
,
2090 CORE_ADDR addr
, gdb_byte
*buf
, int len
)
2092 /* NOTE: target_read_memory returns zero on success! */
2093 return !target_read_memory (addr
, buf
, len
);
2096 /* Architecture methods. */
2099 get_frame_arch (struct frame_info
*this_frame
)
2101 return frame_unwind_arch (this_frame
->next
);
2105 frame_unwind_arch (struct frame_info
*next_frame
)
2107 if (!next_frame
->prev_arch
.p
)
2109 struct gdbarch
*arch
;
2111 if (next_frame
->unwind
== NULL
)
2112 frame_unwind_find_by_frame (next_frame
, &next_frame
->prologue_cache
);
2114 if (next_frame
->unwind
->prev_arch
!= NULL
)
2115 arch
= next_frame
->unwind
->prev_arch (next_frame
,
2116 &next_frame
->prologue_cache
);
2118 arch
= get_frame_arch (next_frame
);
2120 next_frame
->prev_arch
.arch
= arch
;
2121 next_frame
->prev_arch
.p
= 1;
2123 fprintf_unfiltered (gdb_stdlog
,
2124 "{ frame_unwind_arch (next_frame=%d) -> %s }\n",
2126 gdbarch_bfd_arch_info (arch
)->printable_name
);
2129 return next_frame
->prev_arch
.arch
;
2133 frame_unwind_caller_arch (struct frame_info
*next_frame
)
2135 return frame_unwind_arch (skip_inlined_frames (next_frame
));
2138 /* Stack pointer methods. */
2141 get_frame_sp (struct frame_info
*this_frame
)
2143 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2145 /* Normality - an architecture that provides a way of obtaining any
2146 frame inner-most address. */
2147 if (gdbarch_unwind_sp_p (gdbarch
))
2148 /* NOTE drow/2008-06-28: gdbarch_unwind_sp could be converted to
2149 operate on THIS_FRAME now. */
2150 return gdbarch_unwind_sp (gdbarch
, this_frame
->next
);
2151 /* Now things are really are grim. Hope that the value returned by
2152 the gdbarch_sp_regnum register is meaningful. */
2153 if (gdbarch_sp_regnum (gdbarch
) >= 0)
2154 return get_frame_register_unsigned (this_frame
,
2155 gdbarch_sp_regnum (gdbarch
));
2156 internal_error (__FILE__
, __LINE__
, _("Missing unwind SP method"));
2159 /* Return the reason why we can't unwind past FRAME. */
2161 enum unwind_stop_reason
2162 get_frame_unwind_stop_reason (struct frame_info
*frame
)
2164 /* If we haven't tried to unwind past this point yet, then assume
2165 that unwinding would succeed. */
2166 if (frame
->prev_p
== 0)
2167 return UNWIND_NO_REASON
;
2169 /* Otherwise, we set a reason when we succeeded (or failed) to
2171 return frame
->stop_reason
;
2174 /* Return a string explaining REASON. */
2177 frame_stop_reason_string (enum unwind_stop_reason reason
)
2181 case UNWIND_NULL_ID
:
2182 return _("unwinder did not report frame ID");
2184 case UNWIND_INNER_ID
:
2185 return _("previous frame inner to this frame (corrupt stack?)");
2187 case UNWIND_SAME_ID
:
2188 return _("previous frame identical to this frame (corrupt stack?)");
2190 case UNWIND_NO_SAVED_PC
:
2191 return _("frame did not save the PC");
2193 case UNWIND_NO_REASON
:
2194 case UNWIND_FIRST_ERROR
:
2196 internal_error (__FILE__
, __LINE__
,
2197 "Invalid frame stop reason");
2201 /* Clean up after a failed (wrong unwinder) attempt to unwind past
2205 frame_cleanup_after_sniffer (void *arg
)
2207 struct frame_info
*frame
= arg
;
2209 /* The sniffer should not allocate a prologue cache if it did not
2210 match this frame. */
2211 gdb_assert (frame
->prologue_cache
== NULL
);
2213 /* No sniffer should extend the frame chain; sniff based on what is
2215 gdb_assert (!frame
->prev_p
);
2217 /* The sniffer should not check the frame's ID; that's circular. */
2218 gdb_assert (!frame
->this_id
.p
);
2220 /* Clear cached fields dependent on the unwinder.
2222 The previous PC is independent of the unwinder, but the previous
2223 function is not (see get_frame_address_in_block). */
2224 frame
->prev_func
.p
= 0;
2225 frame
->prev_func
.addr
= 0;
2227 /* Discard the unwinder last, so that we can easily find it if an assertion
2228 in this function triggers. */
2229 frame
->unwind
= NULL
;
2232 /* Set FRAME's unwinder temporarily, so that we can call a sniffer.
2233 Return a cleanup which should be called if unwinding fails, and
2234 discarded if it succeeds. */
2237 frame_prepare_for_sniffer (struct frame_info
*frame
,
2238 const struct frame_unwind
*unwind
)
2240 gdb_assert (frame
->unwind
== NULL
);
2241 frame
->unwind
= unwind
;
2242 return make_cleanup (frame_cleanup_after_sniffer
, frame
);
2245 extern initialize_file_ftype _initialize_frame
; /* -Wmissing-prototypes */
2247 static struct cmd_list_element
*set_backtrace_cmdlist
;
2248 static struct cmd_list_element
*show_backtrace_cmdlist
;
2251 set_backtrace_cmd (char *args
, int from_tty
)
2253 help_list (set_backtrace_cmdlist
, "set backtrace ", -1, gdb_stdout
);
2257 show_backtrace_cmd (char *args
, int from_tty
)
2259 cmd_show_list (show_backtrace_cmdlist
, from_tty
, "");
2263 _initialize_frame (void)
2265 obstack_init (&frame_cache_obstack
);
2267 observer_attach_target_changed (frame_observer_target_changed
);
2269 add_prefix_cmd ("backtrace", class_maintenance
, set_backtrace_cmd
, _("\
2270 Set backtrace specific variables.\n\
2271 Configure backtrace variables such as the backtrace limit"),
2272 &set_backtrace_cmdlist
, "set backtrace ",
2273 0/*allow-unknown*/, &setlist
);
2274 add_prefix_cmd ("backtrace", class_maintenance
, show_backtrace_cmd
, _("\
2275 Show backtrace specific variables\n\
2276 Show backtrace variables such as the backtrace limit"),
2277 &show_backtrace_cmdlist
, "show backtrace ",
2278 0/*allow-unknown*/, &showlist
);
2280 add_setshow_boolean_cmd ("past-main", class_obscure
,
2281 &backtrace_past_main
, _("\
2282 Set whether backtraces should continue past \"main\"."), _("\
2283 Show whether backtraces should continue past \"main\"."), _("\
2284 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
2285 the backtrace at \"main\". Set this variable if you need to see the rest\n\
2286 of the stack trace."),
2288 show_backtrace_past_main
,
2289 &set_backtrace_cmdlist
,
2290 &show_backtrace_cmdlist
);
2292 add_setshow_boolean_cmd ("past-entry", class_obscure
,
2293 &backtrace_past_entry
, _("\
2294 Set whether backtraces should continue past the entry point of a program."),
2296 Show whether backtraces should continue past the entry point of a program."),
2298 Normally there are no callers beyond the entry point of a program, so GDB\n\
2299 will terminate the backtrace there. Set this variable if you need to see\n\
2300 the rest of the stack trace."),
2302 show_backtrace_past_entry
,
2303 &set_backtrace_cmdlist
,
2304 &show_backtrace_cmdlist
);
2306 add_setshow_integer_cmd ("limit", class_obscure
,
2307 &backtrace_limit
, _("\
2308 Set an upper bound on the number of backtrace levels."), _("\
2309 Show the upper bound on the number of backtrace levels."), _("\
2310 No more than the specified number of frames can be displayed or examined.\n\
2311 Zero is unlimited."),
2313 show_backtrace_limit
,
2314 &set_backtrace_cmdlist
,
2315 &show_backtrace_cmdlist
);
2317 /* Debug this files internals. */
2318 add_setshow_zinteger_cmd ("frame", class_maintenance
, &frame_debug
, _("\
2319 Set frame debugging."), _("\
2320 Show frame debugging."), _("\
2321 When non-zero, frame specific internal debugging is enabled."),
2324 &setdebuglist
, &showdebuglist
);