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_if_available (struct frame_info
*this_frame
, CORE_ADDR
*pc
)
625 if (!this_frame
->prev_pc
.p
)
627 if (gdbarch_unwind_pc_p (frame_unwind_arch (this_frame
)))
629 volatile struct gdb_exception ex
;
630 struct gdbarch
*prev_gdbarch
;
633 /* The right way. The `pure' way. The one true way. This
634 method depends solely on the register-unwind code to
635 determine the value of registers in THIS frame, and hence
636 the value of this frame's PC (resume address). A typical
637 implementation is no more than:
639 frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
640 return extract_unsigned_integer (buf, size of ISA_PC_REGNUM);
642 Note: this method is very heavily dependent on a correct
643 register-unwind implementation, it pays to fix that
644 method first; this method is frame type agnostic, since
645 it only deals with register values, it works with any
646 frame. This is all in stark contrast to the old
647 FRAME_SAVED_PC which would try to directly handle all the
648 different ways that a PC could be unwound. */
649 prev_gdbarch
= frame_unwind_arch (this_frame
);
651 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
653 pc
= gdbarch_unwind_pc (prev_gdbarch
, this_frame
);
655 if (ex
.reason
< 0 && ex
.error
== NOT_AVAILABLE_ERROR
)
657 this_frame
->prev_pc
.p
= -1;
660 fprintf_unfiltered (gdb_stdlog
,
661 "{ frame_unwind_pc (this_frame=%d)"
662 " -> <unavailable> }\n",
665 else if (ex
.reason
< 0)
667 throw_exception (ex
);
671 this_frame
->prev_pc
.value
= pc
;
672 this_frame
->prev_pc
.p
= 1;
674 fprintf_unfiltered (gdb_stdlog
,
675 "{ frame_unwind_pc (this_frame=%d) "
678 hex_string (this_frame
->prev_pc
.value
));
682 internal_error (__FILE__
, __LINE__
, _("No unwind_pc method"));
684 if (this_frame
->prev_pc
.p
< 0)
691 *pc
= this_frame
->prev_pc
.value
;
697 frame_unwind_pc (struct frame_info
*this_frame
)
701 if (!frame_unwind_pc_if_available (this_frame
, &pc
))
702 throw_error (NOT_AVAILABLE_ERROR
, _("PC not available"));
708 frame_unwind_caller_pc (struct frame_info
*this_frame
)
710 return frame_unwind_pc (skip_inlined_frames (this_frame
));
714 frame_unwind_caller_pc_if_available (struct frame_info
*this_frame
,
717 return frame_unwind_pc_if_available (skip_inlined_frames (this_frame
), pc
);
721 get_frame_func_if_available (struct frame_info
*this_frame
, CORE_ADDR
*pc
)
723 struct frame_info
*next_frame
= this_frame
->next
;
725 if (!next_frame
->prev_func
.p
)
727 CORE_ADDR addr_in_block
;
729 /* Make certain that this, and not the adjacent, function is
731 if (!get_frame_address_in_block_if_available (this_frame
, &addr_in_block
))
733 next_frame
->prev_func
.p
= -1;
735 fprintf_unfiltered (gdb_stdlog
,
736 "{ get_frame_func (this_frame=%d)"
737 " -> unavailable }\n",
742 next_frame
->prev_func
.p
= 1;
743 next_frame
->prev_func
.addr
= get_pc_function_start (addr_in_block
);
745 fprintf_unfiltered (gdb_stdlog
,
746 "{ get_frame_func (this_frame=%d) -> %s }\n",
748 hex_string (next_frame
->prev_func
.addr
));
752 if (next_frame
->prev_func
.p
< 0)
759 *pc
= next_frame
->prev_func
.addr
;
765 get_frame_func (struct frame_info
*this_frame
)
769 if (!get_frame_func_if_available (this_frame
, &pc
))
770 throw_error (NOT_AVAILABLE_ERROR
, _("PC not available"));
775 static enum register_status
776 do_frame_register_read (void *src
, int regnum
, gdb_byte
*buf
)
778 if (!frame_register_read (src
, regnum
, buf
))
779 return REG_UNAVAILABLE
;
785 frame_save_as_regcache (struct frame_info
*this_frame
)
787 struct address_space
*aspace
= get_frame_address_space (this_frame
);
788 struct regcache
*regcache
= regcache_xmalloc (get_frame_arch (this_frame
),
790 struct cleanup
*cleanups
= make_cleanup_regcache_xfree (regcache
);
792 regcache_save (regcache
, do_frame_register_read
, this_frame
);
793 discard_cleanups (cleanups
);
798 frame_pop (struct frame_info
*this_frame
)
800 struct frame_info
*prev_frame
;
801 struct regcache
*scratch
;
802 struct cleanup
*cleanups
;
804 if (get_frame_type (this_frame
) == DUMMY_FRAME
)
806 /* Popping a dummy frame involves restoring more than just registers.
807 dummy_frame_pop does all the work. */
808 dummy_frame_pop (get_frame_id (this_frame
));
812 /* Ensure that we have a frame to pop to. */
813 prev_frame
= get_prev_frame_1 (this_frame
);
816 error (_("Cannot pop the initial frame."));
818 /* Make a copy of all the register values unwound from this frame.
819 Save them in a scratch buffer so that there isn't a race between
820 trying to extract the old values from the current regcache while
821 at the same time writing new values into that same cache. */
822 scratch
= frame_save_as_regcache (prev_frame
);
823 cleanups
= make_cleanup_regcache_xfree (scratch
);
825 /* FIXME: cagney/2003-03-16: It should be possible to tell the
826 target's register cache that it is about to be hit with a burst
827 register transfer and that the sequence of register writes should
828 be batched. The pair target_prepare_to_store() and
829 target_store_registers() kind of suggest this functionality.
830 Unfortunately, they don't implement it. Their lack of a formal
831 definition can lead to targets writing back bogus values
832 (arguably a bug in the target code mind). */
833 /* Now copy those saved registers into the current regcache.
834 Here, regcache_cpy() calls regcache_restore(). */
835 regcache_cpy (get_current_regcache (), scratch
);
836 do_cleanups (cleanups
);
838 /* We've made right mess of GDB's local state, just discard
840 reinit_frame_cache ();
844 frame_register_unwind (struct frame_info
*frame
, int regnum
,
845 int *optimizedp
, int *unavailablep
,
846 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
847 int *realnump
, gdb_byte
*bufferp
)
851 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
852 that the value proper does not need to be fetched. */
853 gdb_assert (optimizedp
!= NULL
);
854 gdb_assert (lvalp
!= NULL
);
855 gdb_assert (addrp
!= NULL
);
856 gdb_assert (realnump
!= NULL
);
857 /* gdb_assert (bufferp != NULL); */
859 value
= frame_unwind_register_value (frame
, regnum
);
861 gdb_assert (value
!= NULL
);
863 *optimizedp
= value_optimized_out (value
);
864 *unavailablep
= !value_entirely_available (value
);
865 *lvalp
= VALUE_LVAL (value
);
866 *addrp
= value_address (value
);
867 *realnump
= VALUE_REGNUM (value
);
871 if (!*optimizedp
&& !*unavailablep
)
872 memcpy (bufferp
, value_contents_all (value
),
873 TYPE_LENGTH (value_type (value
)));
875 memset (bufferp
, 0, TYPE_LENGTH (value_type (value
)));
878 /* Dispose of the new value. This prevents watchpoints from
879 trying to watch the saved frame pointer. */
880 release_value (value
);
885 frame_register (struct frame_info
*frame
, int regnum
,
886 int *optimizedp
, int *unavailablep
, enum lval_type
*lvalp
,
887 CORE_ADDR
*addrp
, int *realnump
, gdb_byte
*bufferp
)
889 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
890 that the value proper does not need to be fetched. */
891 gdb_assert (optimizedp
!= NULL
);
892 gdb_assert (lvalp
!= NULL
);
893 gdb_assert (addrp
!= NULL
);
894 gdb_assert (realnump
!= NULL
);
895 /* gdb_assert (bufferp != NULL); */
897 /* Obtain the register value by unwinding the register from the next
898 (more inner frame). */
899 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
900 frame_register_unwind (frame
->next
, regnum
, optimizedp
, unavailablep
,
901 lvalp
, addrp
, realnump
, bufferp
);
905 frame_unwind_register (struct frame_info
*frame
, int regnum
, gdb_byte
*buf
)
913 frame_register_unwind (frame
, regnum
, &optimized
, &unavailable
,
914 &lval
, &addr
, &realnum
, buf
);
918 get_frame_register (struct frame_info
*frame
,
919 int regnum
, gdb_byte
*buf
)
921 frame_unwind_register (frame
->next
, regnum
, buf
);
925 frame_unwind_register_value (struct frame_info
*frame
, int regnum
)
927 struct gdbarch
*gdbarch
;
930 gdb_assert (frame
!= NULL
);
931 gdbarch
= frame_unwind_arch (frame
);
935 fprintf_unfiltered (gdb_stdlog
,
936 "{ frame_unwind_register_value "
937 "(frame=%d,regnum=%d(%s),...) ",
938 frame
->level
, regnum
,
939 user_reg_map_regnum_to_name (gdbarch
, regnum
));
942 /* Find the unwinder. */
943 if (frame
->unwind
== NULL
)
944 frame_unwind_find_by_frame (frame
, &frame
->prologue_cache
);
946 /* Ask this frame to unwind its register. */
947 value
= frame
->unwind
->prev_register (frame
, &frame
->prologue_cache
, regnum
);
951 fprintf_unfiltered (gdb_stdlog
, "->");
952 if (value_optimized_out (value
))
953 fprintf_unfiltered (gdb_stdlog
, " optimized out");
956 if (VALUE_LVAL (value
) == lval_register
)
957 fprintf_unfiltered (gdb_stdlog
, " register=%d",
958 VALUE_REGNUM (value
));
959 else if (VALUE_LVAL (value
) == lval_memory
)
960 fprintf_unfiltered (gdb_stdlog
, " address=%s",
962 value_address (value
)));
964 fprintf_unfiltered (gdb_stdlog
, " computed");
966 if (value_lazy (value
))
967 fprintf_unfiltered (gdb_stdlog
, " lazy");
971 const gdb_byte
*buf
= value_contents (value
);
973 fprintf_unfiltered (gdb_stdlog
, " bytes=");
974 fprintf_unfiltered (gdb_stdlog
, "[");
975 for (i
= 0; i
< register_size (gdbarch
, regnum
); i
++)
976 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
977 fprintf_unfiltered (gdb_stdlog
, "]");
981 fprintf_unfiltered (gdb_stdlog
, " }\n");
988 get_frame_register_value (struct frame_info
*frame
, int regnum
)
990 return frame_unwind_register_value (frame
->next
, regnum
);
994 frame_unwind_register_signed (struct frame_info
*frame
, int regnum
)
996 struct gdbarch
*gdbarch
= frame_unwind_arch (frame
);
997 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
998 int size
= register_size (gdbarch
, regnum
);
999 gdb_byte buf
[MAX_REGISTER_SIZE
];
1001 frame_unwind_register (frame
, regnum
, buf
);
1002 return extract_signed_integer (buf
, size
, byte_order
);
1006 get_frame_register_signed (struct frame_info
*frame
, int regnum
)
1008 return frame_unwind_register_signed (frame
->next
, regnum
);
1012 frame_unwind_register_unsigned (struct frame_info
*frame
, int regnum
)
1014 struct gdbarch
*gdbarch
= frame_unwind_arch (frame
);
1015 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1016 int size
= register_size (gdbarch
, regnum
);
1017 gdb_byte buf
[MAX_REGISTER_SIZE
];
1019 frame_unwind_register (frame
, regnum
, buf
);
1020 return extract_unsigned_integer (buf
, size
, byte_order
);
1024 get_frame_register_unsigned (struct frame_info
*frame
, int regnum
)
1026 return frame_unwind_register_unsigned (frame
->next
, regnum
);
1030 put_frame_register (struct frame_info
*frame
, int regnum
,
1031 const gdb_byte
*buf
)
1033 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1037 enum lval_type lval
;
1040 frame_register (frame
, regnum
, &optim
, &unavail
,
1041 &lval
, &addr
, &realnum
, NULL
);
1043 error (_("Attempt to assign to a value that was optimized out."));
1048 /* FIXME: write_memory doesn't yet take constant buffers.
1050 gdb_byte tmp
[MAX_REGISTER_SIZE
];
1052 memcpy (tmp
, buf
, register_size (gdbarch
, regnum
));
1053 write_memory (addr
, tmp
, register_size (gdbarch
, regnum
));
1057 regcache_cooked_write (get_current_regcache (), realnum
, buf
);
1060 error (_("Attempt to assign to an unmodifiable value."));
1064 /* frame_register_read ()
1066 Find and return the value of REGNUM for the specified stack frame.
1067 The number of bytes copied is REGISTER_SIZE (REGNUM).
1069 Returns 0 if the register value could not be found. */
1072 frame_register_read (struct frame_info
*frame
, int regnum
,
1077 enum lval_type lval
;
1081 frame_register (frame
, regnum
, &optimized
, &unavailable
,
1082 &lval
, &addr
, &realnum
, myaddr
);
1084 return !optimized
&& !unavailable
;
1088 get_frame_register_bytes (struct frame_info
*frame
, int regnum
,
1089 CORE_ADDR offset
, int len
, gdb_byte
*myaddr
,
1090 int *optimizedp
, int *unavailablep
)
1092 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1097 /* Skip registers wholly inside of OFFSET. */
1098 while (offset
>= register_size (gdbarch
, regnum
))
1100 offset
-= register_size (gdbarch
, regnum
);
1104 /* Ensure that we will not read beyond the end of the register file.
1105 This can only ever happen if the debug information is bad. */
1107 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1108 for (i
= regnum
; i
< numregs
; i
++)
1110 int thissize
= register_size (gdbarch
, i
);
1113 break; /* This register is not available on this architecture. */
1114 maxsize
+= thissize
;
1117 error (_("Bad debug information detected: "
1118 "Attempt to read %d bytes from registers."), len
);
1120 /* Copy the data. */
1123 int curr_len
= register_size (gdbarch
, regnum
) - offset
;
1128 if (curr_len
== register_size (gdbarch
, regnum
))
1130 enum lval_type lval
;
1134 frame_register (frame
, regnum
, optimizedp
, unavailablep
,
1135 &lval
, &addr
, &realnum
, myaddr
);
1136 if (*optimizedp
|| *unavailablep
)
1141 gdb_byte buf
[MAX_REGISTER_SIZE
];
1142 enum lval_type lval
;
1146 frame_register (frame
, regnum
, optimizedp
, unavailablep
,
1147 &lval
, &addr
, &realnum
, buf
);
1148 if (*optimizedp
|| *unavailablep
)
1150 memcpy (myaddr
, buf
+ offset
, curr_len
);
1165 put_frame_register_bytes (struct frame_info
*frame
, int regnum
,
1166 CORE_ADDR offset
, int len
, const gdb_byte
*myaddr
)
1168 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1170 /* Skip registers wholly inside of OFFSET. */
1171 while (offset
>= register_size (gdbarch
, regnum
))
1173 offset
-= register_size (gdbarch
, regnum
);
1177 /* Copy the data. */
1180 int curr_len
= register_size (gdbarch
, regnum
) - offset
;
1185 if (curr_len
== register_size (gdbarch
, regnum
))
1187 put_frame_register (frame
, regnum
, myaddr
);
1191 gdb_byte buf
[MAX_REGISTER_SIZE
];
1193 frame_register_read (frame
, regnum
, buf
);
1194 memcpy (buf
+ offset
, myaddr
, curr_len
);
1195 put_frame_register (frame
, regnum
, buf
);
1205 /* Create a sentinel frame. */
1207 static struct frame_info
*
1208 create_sentinel_frame (struct program_space
*pspace
, struct regcache
*regcache
)
1210 struct frame_info
*frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1213 frame
->pspace
= pspace
;
1214 frame
->aspace
= get_regcache_aspace (regcache
);
1215 /* Explicitly initialize the sentinel frame's cache. Provide it
1216 with the underlying regcache. In the future additional
1217 information, such as the frame's thread will be added. */
1218 frame
->prologue_cache
= sentinel_frame_cache (regcache
);
1219 /* For the moment there is only one sentinel frame implementation. */
1220 frame
->unwind
= &sentinel_frame_unwind
;
1221 /* Link this frame back to itself. The frame is self referential
1222 (the unwound PC is the same as the pc), so make it so. */
1223 frame
->next
= frame
;
1224 /* Make the sentinel frame's ID valid, but invalid. That way all
1225 comparisons with it should fail. */
1226 frame
->this_id
.p
= 1;
1227 frame
->this_id
.value
= null_frame_id
;
1230 fprintf_unfiltered (gdb_stdlog
, "{ create_sentinel_frame (...) -> ");
1231 fprint_frame (gdb_stdlog
, frame
);
1232 fprintf_unfiltered (gdb_stdlog
, " }\n");
1237 /* Info about the innermost stack frame (contents of FP register). */
1239 static struct frame_info
*current_frame
;
1241 /* Cache for frame addresses already read by gdb. Valid only while
1242 inferior is stopped. Control variables for the frame cache should
1243 be local to this module. */
1245 static struct obstack frame_cache_obstack
;
1248 frame_obstack_zalloc (unsigned long size
)
1250 void *data
= obstack_alloc (&frame_cache_obstack
, size
);
1252 memset (data
, 0, size
);
1256 /* Return the innermost (currently executing) stack frame. This is
1257 split into two functions. The function unwind_to_current_frame()
1258 is wrapped in catch exceptions so that, even when the unwind of the
1259 sentinel frame fails, the function still returns a stack frame. */
1262 unwind_to_current_frame (struct ui_out
*ui_out
, void *args
)
1264 struct frame_info
*frame
= get_prev_frame (args
);
1266 /* A sentinel frame can fail to unwind, e.g., because its PC value
1267 lands in somewhere like start. */
1270 current_frame
= frame
;
1275 get_current_frame (void)
1277 /* First check, and report, the lack of registers. Having GDB
1278 report "No stack!" or "No memory" when the target doesn't even
1279 have registers is very confusing. Besides, "printcmd.exp"
1280 explicitly checks that ``print $pc'' with no registers prints "No
1282 if (!target_has_registers
)
1283 error (_("No registers."));
1284 if (!target_has_stack
)
1285 error (_("No stack."));
1286 if (!target_has_memory
)
1287 error (_("No memory."));
1288 /* Traceframes are effectively a substitute for the live inferior. */
1289 if (get_traceframe_number () < 0)
1291 if (ptid_equal (inferior_ptid
, null_ptid
))
1292 error (_("No selected thread."));
1293 if (is_exited (inferior_ptid
))
1294 error (_("Invalid selected thread."));
1295 if (is_executing (inferior_ptid
))
1296 error (_("Target is executing."));
1299 if (current_frame
== NULL
)
1301 struct frame_info
*sentinel_frame
=
1302 create_sentinel_frame (current_program_space
, get_current_regcache ());
1303 if (catch_exceptions (uiout
, unwind_to_current_frame
, sentinel_frame
,
1304 RETURN_MASK_ERROR
) != 0)
1306 /* Oops! Fake a current frame? Is this useful? It has a PC
1307 of zero, for instance. */
1308 current_frame
= sentinel_frame
;
1311 return current_frame
;
1314 /* The "selected" stack frame is used by default for local and arg
1315 access. May be zero, for no selected frame. */
1317 static struct frame_info
*selected_frame
;
1320 has_stack_frames (void)
1322 if (!target_has_registers
|| !target_has_stack
|| !target_has_memory
)
1325 /* No current inferior, no frame. */
1326 if (ptid_equal (inferior_ptid
, null_ptid
))
1329 /* Don't try to read from a dead thread. */
1330 if (is_exited (inferior_ptid
))
1333 /* ... or from a spinning thread. */
1334 if (is_executing (inferior_ptid
))
1340 /* Return the selected frame. Always non-NULL (unless there isn't an
1341 inferior sufficient for creating a frame) in which case an error is
1345 get_selected_frame (const char *message
)
1347 if (selected_frame
== NULL
)
1349 if (message
!= NULL
&& !has_stack_frames ())
1350 error (("%s"), message
);
1351 /* Hey! Don't trust this. It should really be re-finding the
1352 last selected frame of the currently selected thread. This,
1353 though, is better than nothing. */
1354 select_frame (get_current_frame ());
1356 /* There is always a frame. */
1357 gdb_assert (selected_frame
!= NULL
);
1358 return selected_frame
;
1361 /* If there is a selected frame, return it. Otherwise, return NULL. */
1364 get_selected_frame_if_set (void)
1366 return selected_frame
;
1369 /* This is a variant of get_selected_frame() which can be called when
1370 the inferior does not have a frame; in that case it will return
1371 NULL instead of calling error(). */
1374 deprecated_safe_get_selected_frame (void)
1376 if (!has_stack_frames ())
1378 return get_selected_frame (NULL
);
1381 /* Select frame FI (or NULL - to invalidate the current frame). */
1384 select_frame (struct frame_info
*fi
)
1386 selected_frame
= fi
;
1387 /* NOTE: cagney/2002-05-04: FI can be NULL. This occurs when the
1388 frame is being invalidated. */
1389 if (deprecated_selected_frame_level_changed_hook
)
1390 deprecated_selected_frame_level_changed_hook (frame_relative_level (fi
));
1392 /* FIXME: kseitz/2002-08-28: It would be nice to call
1393 selected_frame_level_changed_event() right here, but due to limitations
1394 in the current interfaces, we would end up flooding UIs with events
1395 because select_frame() is used extensively internally.
1397 Once we have frame-parameterized frame (and frame-related) commands,
1398 the event notification can be moved here, since this function will only
1399 be called when the user's selected frame is being changed. */
1401 /* Ensure that symbols for this frame are read in. Also, determine the
1402 source language of this frame, and switch to it if desired. */
1407 /* We retrieve the frame's symtab by using the frame PC.
1408 However we cannot use the frame PC as-is, because it usually
1409 points to the instruction following the "call", which is
1410 sometimes the first instruction of another function. So we
1411 rely on get_frame_address_in_block() which provides us with a
1412 PC which is guaranteed to be inside the frame's code
1414 if (get_frame_address_in_block_if_available (fi
, &pc
))
1416 struct symtab
*s
= find_pc_symtab (pc
);
1419 && s
->language
!= current_language
->la_language
1420 && s
->language
!= language_unknown
1421 && language_mode
== language_mode_auto
)
1422 set_language (s
->language
);
1427 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
1428 Always returns a non-NULL value. */
1431 create_new_frame (CORE_ADDR addr
, CORE_ADDR pc
)
1433 struct frame_info
*fi
;
1437 fprintf_unfiltered (gdb_stdlog
,
1438 "{ create_new_frame (addr=%s, pc=%s) ",
1439 hex_string (addr
), hex_string (pc
));
1442 fi
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1444 fi
->next
= create_sentinel_frame (current_program_space
,
1445 get_current_regcache ());
1447 /* Set/update this frame's cached PC value, found in the next frame.
1448 Do this before looking for this frame's unwinder. A sniffer is
1449 very likely to read this, and the corresponding unwinder is
1450 entitled to rely that the PC doesn't magically change. */
1451 fi
->next
->prev_pc
.value
= pc
;
1452 fi
->next
->prev_pc
.p
= 1;
1454 /* We currently assume that frame chain's can't cross spaces. */
1455 fi
->pspace
= fi
->next
->pspace
;
1456 fi
->aspace
= fi
->next
->aspace
;
1458 /* Select/initialize both the unwind function and the frame's type
1460 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
1463 fi
->this_id
.value
= frame_id_build (addr
, pc
);
1467 fprintf_unfiltered (gdb_stdlog
, "-> ");
1468 fprint_frame (gdb_stdlog
, fi
);
1469 fprintf_unfiltered (gdb_stdlog
, " }\n");
1475 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
1476 innermost frame). Be careful to not fall off the bottom of the
1477 frame chain and onto the sentinel frame. */
1480 get_next_frame (struct frame_info
*this_frame
)
1482 if (this_frame
->level
> 0)
1483 return this_frame
->next
;
1488 /* Observer for the target_changed event. */
1491 frame_observer_target_changed (struct target_ops
*target
)
1493 reinit_frame_cache ();
1496 /* Flush the entire frame cache. */
1499 reinit_frame_cache (void)
1501 struct frame_info
*fi
;
1503 /* Tear down all frame caches. */
1504 for (fi
= current_frame
; fi
!= NULL
; fi
= fi
->prev
)
1506 if (fi
->prologue_cache
&& fi
->unwind
->dealloc_cache
)
1507 fi
->unwind
->dealloc_cache (fi
, fi
->prologue_cache
);
1508 if (fi
->base_cache
&& fi
->base
->unwind
->dealloc_cache
)
1509 fi
->base
->unwind
->dealloc_cache (fi
, fi
->base_cache
);
1512 /* Since we can't really be sure what the first object allocated was. */
1513 obstack_free (&frame_cache_obstack
, 0);
1514 obstack_init (&frame_cache_obstack
);
1516 if (current_frame
!= NULL
)
1517 annotate_frames_invalid ();
1519 current_frame
= NULL
; /* Invalidate cache */
1520 select_frame (NULL
);
1521 frame_stash_invalidate ();
1523 fprintf_unfiltered (gdb_stdlog
, "{ reinit_frame_cache () }\n");
1526 /* Find where a register is saved (in memory or another register).
1527 The result of frame_register_unwind is just where it is saved
1528 relative to this particular frame. */
1531 frame_register_unwind_location (struct frame_info
*this_frame
, int regnum
,
1532 int *optimizedp
, enum lval_type
*lvalp
,
1533 CORE_ADDR
*addrp
, int *realnump
)
1535 gdb_assert (this_frame
== NULL
|| this_frame
->level
>= 0);
1537 while (this_frame
!= NULL
)
1541 frame_register_unwind (this_frame
, regnum
, optimizedp
, &unavailable
,
1542 lvalp
, addrp
, realnump
, NULL
);
1547 if (*lvalp
!= lval_register
)
1551 this_frame
= get_next_frame (this_frame
);
1555 /* Return a "struct frame_info" corresponding to the frame that called
1556 THIS_FRAME. Returns NULL if there is no such frame.
1558 Unlike get_prev_frame, this function always tries to unwind the
1561 static struct frame_info
*
1562 get_prev_frame_1 (struct frame_info
*this_frame
)
1564 struct frame_id this_id
;
1565 struct gdbarch
*gdbarch
;
1567 gdb_assert (this_frame
!= NULL
);
1568 gdbarch
= get_frame_arch (this_frame
);
1572 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame_1 (this_frame=");
1573 if (this_frame
!= NULL
)
1574 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1576 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1577 fprintf_unfiltered (gdb_stdlog
, ") ");
1580 /* Only try to do the unwind once. */
1581 if (this_frame
->prev_p
)
1585 fprintf_unfiltered (gdb_stdlog
, "-> ");
1586 fprint_frame (gdb_stdlog
, this_frame
->prev
);
1587 fprintf_unfiltered (gdb_stdlog
, " // cached \n");
1589 return this_frame
->prev
;
1592 /* If the frame unwinder hasn't been selected yet, we must do so
1593 before setting prev_p; otherwise the check for misbehaved
1594 sniffers will think that this frame's sniffer tried to unwind
1595 further (see frame_cleanup_after_sniffer). */
1596 if (this_frame
->unwind
== NULL
)
1597 frame_unwind_find_by_frame (this_frame
, &this_frame
->prologue_cache
);
1599 this_frame
->prev_p
= 1;
1600 this_frame
->stop_reason
= UNWIND_NO_REASON
;
1602 /* If we are unwinding from an inline frame, all of the below tests
1603 were already performed when we unwound from the next non-inline
1604 frame. We must skip them, since we can not get THIS_FRAME's ID
1605 until we have unwound all the way down to the previous non-inline
1607 if (get_frame_type (this_frame
) == INLINE_FRAME
)
1608 return get_prev_frame_raw (this_frame
);
1610 /* Check that this frame's ID was valid. If it wasn't, don't try to
1611 unwind to the prev frame. Be careful to not apply this test to
1612 the sentinel frame. */
1613 this_id
= get_frame_id (this_frame
);
1614 if (this_frame
->level
>= 0 && frame_id_eq (this_id
, outer_frame_id
))
1618 fprintf_unfiltered (gdb_stdlog
, "-> ");
1619 fprint_frame (gdb_stdlog
, NULL
);
1620 fprintf_unfiltered (gdb_stdlog
, " // this ID is NULL }\n");
1622 this_frame
->stop_reason
= UNWIND_NULL_ID
;
1626 /* Check that this frame's ID isn't inner to (younger, below, next)
1627 the next frame. This happens when a frame unwind goes backwards.
1628 This check is valid only if this frame and the next frame are NORMAL.
1629 See the comment at frame_id_inner for details. */
1630 if (get_frame_type (this_frame
) == NORMAL_FRAME
1631 && this_frame
->next
->unwind
->type
== NORMAL_FRAME
1632 && frame_id_inner (get_frame_arch (this_frame
->next
), this_id
,
1633 get_frame_id (this_frame
->next
)))
1635 CORE_ADDR this_pc_in_block
;
1636 struct minimal_symbol
*morestack_msym
;
1637 const char *morestack_name
= NULL
;
1639 /* gcc -fsplit-stack __morestack can continue the stack anywhere. */
1640 this_pc_in_block
= get_frame_address_in_block (this_frame
);
1641 morestack_msym
= lookup_minimal_symbol_by_pc (this_pc_in_block
);
1643 morestack_name
= SYMBOL_LINKAGE_NAME (morestack_msym
);
1644 if (!morestack_name
|| strcmp (morestack_name
, "__morestack") != 0)
1648 fprintf_unfiltered (gdb_stdlog
, "-> ");
1649 fprint_frame (gdb_stdlog
, NULL
);
1650 fprintf_unfiltered (gdb_stdlog
,
1651 " // this frame ID is inner }\n");
1653 this_frame
->stop_reason
= UNWIND_INNER_ID
;
1658 /* Check that this and the next frame are not identical. If they
1659 are, there is most likely a stack cycle. As with the inner-than
1660 test above, avoid comparing the inner-most and sentinel frames. */
1661 if (this_frame
->level
> 0
1662 && frame_id_eq (this_id
, get_frame_id (this_frame
->next
)))
1666 fprintf_unfiltered (gdb_stdlog
, "-> ");
1667 fprint_frame (gdb_stdlog
, NULL
);
1668 fprintf_unfiltered (gdb_stdlog
, " // this frame has same ID }\n");
1670 this_frame
->stop_reason
= UNWIND_SAME_ID
;
1674 /* Check that this and the next frame do not unwind the PC register
1675 to the same memory location. If they do, then even though they
1676 have different frame IDs, the new frame will be bogus; two
1677 functions can't share a register save slot for the PC. This can
1678 happen when the prologue analyzer finds a stack adjustment, but
1681 This check does assume that the "PC register" is roughly a
1682 traditional PC, even if the gdbarch_unwind_pc method adjusts
1683 it (we do not rely on the value, only on the unwound PC being
1684 dependent on this value). A potential improvement would be
1685 to have the frame prev_pc method and the gdbarch unwind_pc
1686 method set the same lval and location information as
1687 frame_register_unwind. */
1688 if (this_frame
->level
> 0
1689 && gdbarch_pc_regnum (gdbarch
) >= 0
1690 && get_frame_type (this_frame
) == NORMAL_FRAME
1691 && (get_frame_type (this_frame
->next
) == NORMAL_FRAME
1692 || get_frame_type (this_frame
->next
) == INLINE_FRAME
))
1694 int optimized
, realnum
, nrealnum
;
1695 enum lval_type lval
, nlval
;
1696 CORE_ADDR addr
, naddr
;
1698 frame_register_unwind_location (this_frame
,
1699 gdbarch_pc_regnum (gdbarch
),
1700 &optimized
, &lval
, &addr
, &realnum
);
1701 frame_register_unwind_location (get_next_frame (this_frame
),
1702 gdbarch_pc_regnum (gdbarch
),
1703 &optimized
, &nlval
, &naddr
, &nrealnum
);
1705 if ((lval
== lval_memory
&& lval
== nlval
&& addr
== naddr
)
1706 || (lval
== lval_register
&& lval
== nlval
&& realnum
== nrealnum
))
1710 fprintf_unfiltered (gdb_stdlog
, "-> ");
1711 fprint_frame (gdb_stdlog
, NULL
);
1712 fprintf_unfiltered (gdb_stdlog
, " // no saved PC }\n");
1715 this_frame
->stop_reason
= UNWIND_NO_SAVED_PC
;
1716 this_frame
->prev
= NULL
;
1721 return get_prev_frame_raw (this_frame
);
1724 /* Construct a new "struct frame_info" and link it previous to
1727 static struct frame_info
*
1728 get_prev_frame_raw (struct frame_info
*this_frame
)
1730 struct frame_info
*prev_frame
;
1732 /* Allocate the new frame but do not wire it in to the frame chain.
1733 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
1734 frame->next to pull some fancy tricks (of course such code is, by
1735 definition, recursive). Try to prevent it.
1737 There is no reason to worry about memory leaks, should the
1738 remainder of the function fail. The allocated memory will be
1739 quickly reclaimed when the frame cache is flushed, and the `we've
1740 been here before' check above will stop repeated memory
1741 allocation calls. */
1742 prev_frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1743 prev_frame
->level
= this_frame
->level
+ 1;
1745 /* For now, assume we don't have frame chains crossing address
1747 prev_frame
->pspace
= this_frame
->pspace
;
1748 prev_frame
->aspace
= this_frame
->aspace
;
1750 /* Don't yet compute ->unwind (and hence ->type). It is computed
1751 on-demand in get_frame_type, frame_register_unwind, and
1754 /* Don't yet compute the frame's ID. It is computed on-demand by
1757 /* The unwound frame ID is validate at the start of this function,
1758 as part of the logic to decide if that frame should be further
1759 unwound, and not here while the prev frame is being created.
1760 Doing this makes it possible for the user to examine a frame that
1761 has an invalid frame ID.
1763 Some very old VAX code noted: [...] For the sake of argument,
1764 suppose that the stack is somewhat trashed (which is one reason
1765 that "info frame" exists). So, return 0 (indicating we don't
1766 know the address of the arglist) if we don't know what frame this
1770 this_frame
->prev
= prev_frame
;
1771 prev_frame
->next
= this_frame
;
1775 fprintf_unfiltered (gdb_stdlog
, "-> ");
1776 fprint_frame (gdb_stdlog
, prev_frame
);
1777 fprintf_unfiltered (gdb_stdlog
, " }\n");
1783 /* Debug routine to print a NULL frame being returned. */
1786 frame_debug_got_null_frame (struct frame_info
*this_frame
,
1791 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame (this_frame=");
1792 if (this_frame
!= NULL
)
1793 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1795 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1796 fprintf_unfiltered (gdb_stdlog
, ") -> // %s}\n", reason
);
1800 /* Is this (non-sentinel) frame in the "main"() function? */
1803 inside_main_func (struct frame_info
*this_frame
)
1805 struct minimal_symbol
*msymbol
;
1808 if (symfile_objfile
== 0)
1810 msymbol
= lookup_minimal_symbol (main_name (), NULL
, symfile_objfile
);
1811 if (msymbol
== NULL
)
1813 /* Make certain that the code, and not descriptor, address is
1815 maddr
= gdbarch_convert_from_func_ptr_addr (get_frame_arch (this_frame
),
1816 SYMBOL_VALUE_ADDRESS (msymbol
),
1818 return maddr
== get_frame_func (this_frame
);
1821 /* Test whether THIS_FRAME is inside the process entry point function. */
1824 inside_entry_func (struct frame_info
*this_frame
)
1826 CORE_ADDR entry_point
;
1828 if (!entry_point_address_query (&entry_point
))
1831 return get_frame_func (this_frame
) == entry_point
;
1834 /* Return a structure containing various interesting information about
1835 the frame that called THIS_FRAME. Returns NULL if there is entier
1836 no such frame or the frame fails any of a set of target-independent
1837 condition that should terminate the frame chain (e.g., as unwinding
1840 This function should not contain target-dependent tests, such as
1841 checking whether the program-counter is zero. */
1844 get_prev_frame (struct frame_info
*this_frame
)
1849 /* There is always a frame. If this assertion fails, suspect that
1850 something should be calling get_selected_frame() or
1851 get_current_frame(). */
1852 gdb_assert (this_frame
!= NULL
);
1853 frame_pc_p
= get_frame_pc_if_available (this_frame
, &frame_pc
);
1855 /* tausq/2004-12-07: Dummy frames are skipped because it doesn't make much
1856 sense to stop unwinding at a dummy frame. One place where a dummy
1857 frame may have an address "inside_main_func" is on HPUX. On HPUX, the
1858 pcsqh register (space register for the instruction at the head of the
1859 instruction queue) cannot be written directly; the only way to set it
1860 is to branch to code that is in the target space. In order to implement
1861 frame dummies on HPUX, the called function is made to jump back to where
1862 the inferior was when the user function was called. If gdb was inside
1863 the main function when we created the dummy frame, the dummy frame will
1864 point inside the main function. */
1865 if (this_frame
->level
>= 0
1866 && get_frame_type (this_frame
) == NORMAL_FRAME
1867 && !backtrace_past_main
1869 && inside_main_func (this_frame
))
1870 /* Don't unwind past main(). Note, this is done _before_ the
1871 frame has been marked as previously unwound. That way if the
1872 user later decides to enable unwinds past main(), that will
1873 automatically happen. */
1875 frame_debug_got_null_frame (this_frame
, "inside main func");
1879 /* If the user's backtrace limit has been exceeded, stop. We must
1880 add two to the current level; one of those accounts for backtrace_limit
1881 being 1-based and the level being 0-based, and the other accounts for
1882 the level of the new frame instead of the level of the current
1884 if (this_frame
->level
+ 2 > backtrace_limit
)
1886 frame_debug_got_null_frame (this_frame
, "backtrace limit exceeded");
1890 /* If we're already inside the entry function for the main objfile,
1891 then it isn't valid. Don't apply this test to a dummy frame -
1892 dummy frame PCs typically land in the entry func. Don't apply
1893 this test to the sentinel frame. Sentinel frames should always
1894 be allowed to unwind. */
1895 /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() -
1896 wasn't checking for "main" in the minimal symbols. With that
1897 fixed asm-source tests now stop in "main" instead of halting the
1898 backtrace in weird and wonderful ways somewhere inside the entry
1899 file. Suspect that tests for inside the entry file/func were
1900 added to work around that (now fixed) case. */
1901 /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
1902 suggested having the inside_entry_func test use the
1903 inside_main_func() msymbol trick (along with entry_point_address()
1904 I guess) to determine the address range of the start function.
1905 That should provide a far better stopper than the current
1907 /* NOTE: tausq/2004-10-09: this is needed if, for example, the compiler
1908 applied tail-call optimizations to main so that a function called
1909 from main returns directly to the caller of main. Since we don't
1910 stop at main, we should at least stop at the entry point of the
1912 if (this_frame
->level
>= 0
1913 && get_frame_type (this_frame
) == NORMAL_FRAME
1914 && !backtrace_past_entry
1916 && inside_entry_func (this_frame
))
1918 frame_debug_got_null_frame (this_frame
, "inside entry func");
1922 /* Assume that the only way to get a zero PC is through something
1923 like a SIGSEGV or a dummy frame, and hence that NORMAL frames
1924 will never unwind a zero PC. */
1925 if (this_frame
->level
> 0
1926 && (get_frame_type (this_frame
) == NORMAL_FRAME
1927 || get_frame_type (this_frame
) == INLINE_FRAME
)
1928 && get_frame_type (get_next_frame (this_frame
)) == NORMAL_FRAME
1929 && frame_pc_p
&& frame_pc
== 0)
1931 frame_debug_got_null_frame (this_frame
, "zero PC");
1935 return get_prev_frame_1 (this_frame
);
1939 get_frame_pc (struct frame_info
*frame
)
1941 gdb_assert (frame
->next
!= NULL
);
1942 return frame_unwind_pc (frame
->next
);
1946 get_frame_pc_if_available (struct frame_info
*frame
, CORE_ADDR
*pc
)
1948 volatile struct gdb_exception ex
;
1950 gdb_assert (frame
->next
!= NULL
);
1952 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
1954 *pc
= frame_unwind_pc (frame
->next
);
1958 if (ex
.error
== NOT_AVAILABLE_ERROR
)
1961 throw_exception (ex
);
1967 /* Return an address that falls within THIS_FRAME's code block. */
1970 get_frame_address_in_block (struct frame_info
*this_frame
)
1972 /* A draft address. */
1973 CORE_ADDR pc
= get_frame_pc (this_frame
);
1975 struct frame_info
*next_frame
= this_frame
->next
;
1977 /* Calling get_frame_pc returns the resume address for THIS_FRAME.
1978 Normally the resume address is inside the body of the function
1979 associated with THIS_FRAME, but there is a special case: when
1980 calling a function which the compiler knows will never return
1981 (for instance abort), the call may be the very last instruction
1982 in the calling function. The resume address will point after the
1983 call and may be at the beginning of a different function
1986 If THIS_FRAME is a signal frame or dummy frame, then we should
1987 not adjust the unwound PC. For a dummy frame, GDB pushed the
1988 resume address manually onto the stack. For a signal frame, the
1989 OS may have pushed the resume address manually and invoked the
1990 handler (e.g. GNU/Linux), or invoked the trampoline which called
1991 the signal handler - but in either case the signal handler is
1992 expected to return to the trampoline. So in both of these
1993 cases we know that the resume address is executable and
1994 related. So we only need to adjust the PC if THIS_FRAME
1995 is a normal function.
1997 If the program has been interrupted while THIS_FRAME is current,
1998 then clearly the resume address is inside the associated
1999 function. There are three kinds of interruption: debugger stop
2000 (next frame will be SENTINEL_FRAME), operating system
2001 signal or exception (next frame will be SIGTRAMP_FRAME),
2002 or debugger-induced function call (next frame will be
2003 DUMMY_FRAME). So we only need to adjust the PC if
2004 NEXT_FRAME is a normal function.
2006 We check the type of NEXT_FRAME first, since it is already
2007 known; frame type is determined by the unwinder, and since
2008 we have THIS_FRAME we've already selected an unwinder for
2011 If the next frame is inlined, we need to keep going until we find
2012 the real function - for instance, if a signal handler is invoked
2013 while in an inlined function, then the code address of the
2014 "calling" normal function should not be adjusted either. */
2016 while (get_frame_type (next_frame
) == INLINE_FRAME
)
2017 next_frame
= next_frame
->next
;
2019 if (get_frame_type (next_frame
) == NORMAL_FRAME
2020 && (get_frame_type (this_frame
) == NORMAL_FRAME
2021 || get_frame_type (this_frame
) == INLINE_FRAME
))
2028 get_frame_address_in_block_if_available (struct frame_info
*this_frame
,
2031 volatile struct gdb_exception ex
;
2033 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2035 *pc
= get_frame_address_in_block (this_frame
);
2037 if (ex
.reason
< 0 && ex
.error
== NOT_AVAILABLE_ERROR
)
2039 else if (ex
.reason
< 0)
2040 throw_exception (ex
);
2046 find_frame_sal (struct frame_info
*frame
, struct symtab_and_line
*sal
)
2048 struct frame_info
*next_frame
;
2052 /* If the next frame represents an inlined function call, this frame's
2053 sal is the "call site" of that inlined function, which can not
2054 be inferred from get_frame_pc. */
2055 next_frame
= get_next_frame (frame
);
2056 if (frame_inlined_callees (frame
) > 0)
2061 sym
= get_frame_function (next_frame
);
2063 sym
= inline_skipped_symbol (inferior_ptid
);
2065 /* If frame is inline, it certainly has symbols. */
2068 if (SYMBOL_LINE (sym
) != 0)
2070 sal
->symtab
= SYMBOL_SYMTAB (sym
);
2071 sal
->line
= SYMBOL_LINE (sym
);
2074 /* If the symbol does not have a location, we don't know where
2075 the call site is. Do not pretend to. This is jarring, but
2076 we can't do much better. */
2077 sal
->pc
= get_frame_pc (frame
);
2082 /* If FRAME is not the innermost frame, that normally means that
2083 FRAME->pc points at the return instruction (which is *after* the
2084 call instruction), and we want to get the line containing the
2085 call (because the call is where the user thinks the program is).
2086 However, if the next frame is either a SIGTRAMP_FRAME or a
2087 DUMMY_FRAME, then the next frame will contain a saved interrupt
2088 PC and such a PC indicates the current (rather than next)
2089 instruction/line, consequently, for such cases, want to get the
2090 line containing fi->pc. */
2091 if (!get_frame_pc_if_available (frame
, &pc
))
2097 notcurrent
= (pc
!= get_frame_address_in_block (frame
));
2098 (*sal
) = find_pc_line (pc
, notcurrent
);
2101 /* Per "frame.h", return the ``address'' of the frame. Code should
2102 really be using get_frame_id(). */
2104 get_frame_base (struct frame_info
*fi
)
2106 return get_frame_id (fi
).stack_addr
;
2109 /* High-level offsets into the frame. Used by the debug info. */
2112 get_frame_base_address (struct frame_info
*fi
)
2114 if (get_frame_type (fi
) != NORMAL_FRAME
)
2116 if (fi
->base
== NULL
)
2117 fi
->base
= frame_base_find_by_frame (fi
);
2118 /* Sneaky: If the low-level unwind and high-level base code share a
2119 common unwinder, let them share the prologue cache. */
2120 if (fi
->base
->unwind
== fi
->unwind
)
2121 return fi
->base
->this_base (fi
, &fi
->prologue_cache
);
2122 return fi
->base
->this_base (fi
, &fi
->base_cache
);
2126 get_frame_locals_address (struct frame_info
*fi
)
2128 if (get_frame_type (fi
) != NORMAL_FRAME
)
2130 /* If there isn't a frame address method, find it. */
2131 if (fi
->base
== NULL
)
2132 fi
->base
= frame_base_find_by_frame (fi
);
2133 /* Sneaky: If the low-level unwind and high-level base code share a
2134 common unwinder, let them share the prologue cache. */
2135 if (fi
->base
->unwind
== fi
->unwind
)
2136 return fi
->base
->this_locals (fi
, &fi
->prologue_cache
);
2137 return fi
->base
->this_locals (fi
, &fi
->base_cache
);
2141 get_frame_args_address (struct frame_info
*fi
)
2143 if (get_frame_type (fi
) != NORMAL_FRAME
)
2145 /* If there isn't a frame address method, find it. */
2146 if (fi
->base
== NULL
)
2147 fi
->base
= frame_base_find_by_frame (fi
);
2148 /* Sneaky: If the low-level unwind and high-level base code share a
2149 common unwinder, let them share the prologue cache. */
2150 if (fi
->base
->unwind
== fi
->unwind
)
2151 return fi
->base
->this_args (fi
, &fi
->prologue_cache
);
2152 return fi
->base
->this_args (fi
, &fi
->base_cache
);
2155 /* Return true if the frame unwinder for frame FI is UNWINDER; false
2159 frame_unwinder_is (struct frame_info
*fi
, const struct frame_unwind
*unwinder
)
2161 if (fi
->unwind
== NULL
)
2162 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
2163 return fi
->unwind
== unwinder
;
2166 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
2167 or -1 for a NULL frame. */
2170 frame_relative_level (struct frame_info
*fi
)
2179 get_frame_type (struct frame_info
*frame
)
2181 if (frame
->unwind
== NULL
)
2182 /* Initialize the frame's unwinder because that's what
2183 provides the frame's type. */
2184 frame_unwind_find_by_frame (frame
, &frame
->prologue_cache
);
2185 return frame
->unwind
->type
;
2188 struct program_space
*
2189 get_frame_program_space (struct frame_info
*frame
)
2191 return frame
->pspace
;
2194 struct program_space
*
2195 frame_unwind_program_space (struct frame_info
*this_frame
)
2197 gdb_assert (this_frame
);
2199 /* This is really a placeholder to keep the API consistent --- we
2200 assume for now that we don't have frame chains crossing
2202 return this_frame
->pspace
;
2205 struct address_space
*
2206 get_frame_address_space (struct frame_info
*frame
)
2208 return frame
->aspace
;
2211 /* Memory access methods. */
2214 get_frame_memory (struct frame_info
*this_frame
, CORE_ADDR addr
,
2215 gdb_byte
*buf
, int len
)
2217 read_memory (addr
, buf
, len
);
2221 get_frame_memory_signed (struct frame_info
*this_frame
, CORE_ADDR addr
,
2224 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2225 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2227 return read_memory_integer (addr
, len
, byte_order
);
2231 get_frame_memory_unsigned (struct frame_info
*this_frame
, CORE_ADDR addr
,
2234 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2235 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2237 return read_memory_unsigned_integer (addr
, len
, byte_order
);
2241 safe_frame_unwind_memory (struct frame_info
*this_frame
,
2242 CORE_ADDR addr
, gdb_byte
*buf
, int len
)
2244 /* NOTE: target_read_memory returns zero on success! */
2245 return !target_read_memory (addr
, buf
, len
);
2248 /* Architecture methods. */
2251 get_frame_arch (struct frame_info
*this_frame
)
2253 return frame_unwind_arch (this_frame
->next
);
2257 frame_unwind_arch (struct frame_info
*next_frame
)
2259 if (!next_frame
->prev_arch
.p
)
2261 struct gdbarch
*arch
;
2263 if (next_frame
->unwind
== NULL
)
2264 frame_unwind_find_by_frame (next_frame
, &next_frame
->prologue_cache
);
2266 if (next_frame
->unwind
->prev_arch
!= NULL
)
2267 arch
= next_frame
->unwind
->prev_arch (next_frame
,
2268 &next_frame
->prologue_cache
);
2270 arch
= get_frame_arch (next_frame
);
2272 next_frame
->prev_arch
.arch
= arch
;
2273 next_frame
->prev_arch
.p
= 1;
2275 fprintf_unfiltered (gdb_stdlog
,
2276 "{ frame_unwind_arch (next_frame=%d) -> %s }\n",
2278 gdbarch_bfd_arch_info (arch
)->printable_name
);
2281 return next_frame
->prev_arch
.arch
;
2285 frame_unwind_caller_arch (struct frame_info
*next_frame
)
2287 return frame_unwind_arch (skip_inlined_frames (next_frame
));
2290 /* Stack pointer methods. */
2293 get_frame_sp (struct frame_info
*this_frame
)
2295 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2297 /* Normality - an architecture that provides a way of obtaining any
2298 frame inner-most address. */
2299 if (gdbarch_unwind_sp_p (gdbarch
))
2300 /* NOTE drow/2008-06-28: gdbarch_unwind_sp could be converted to
2301 operate on THIS_FRAME now. */
2302 return gdbarch_unwind_sp (gdbarch
, this_frame
->next
);
2303 /* Now things are really are grim. Hope that the value returned by
2304 the gdbarch_sp_regnum register is meaningful. */
2305 if (gdbarch_sp_regnum (gdbarch
) >= 0)
2306 return get_frame_register_unsigned (this_frame
,
2307 gdbarch_sp_regnum (gdbarch
));
2308 internal_error (__FILE__
, __LINE__
, _("Missing unwind SP method"));
2311 /* Return the reason why we can't unwind past FRAME. */
2313 enum unwind_stop_reason
2314 get_frame_unwind_stop_reason (struct frame_info
*frame
)
2316 /* If we haven't tried to unwind past this point yet, then assume
2317 that unwinding would succeed. */
2318 if (frame
->prev_p
== 0)
2319 return UNWIND_NO_REASON
;
2321 /* Otherwise, we set a reason when we succeeded (or failed) to
2323 return frame
->stop_reason
;
2326 /* Return a string explaining REASON. */
2329 frame_stop_reason_string (enum unwind_stop_reason reason
)
2333 case UNWIND_NULL_ID
:
2334 return _("unwinder did not report frame ID");
2336 case UNWIND_INNER_ID
:
2337 return _("previous frame inner to this frame (corrupt stack?)");
2339 case UNWIND_SAME_ID
:
2340 return _("previous frame identical to this frame (corrupt stack?)");
2342 case UNWIND_NO_SAVED_PC
:
2343 return _("frame did not save the PC");
2345 case UNWIND_NO_REASON
:
2346 case UNWIND_FIRST_ERROR
:
2348 internal_error (__FILE__
, __LINE__
,
2349 "Invalid frame stop reason");
2353 /* Clean up after a failed (wrong unwinder) attempt to unwind past
2357 frame_cleanup_after_sniffer (void *arg
)
2359 struct frame_info
*frame
= arg
;
2361 /* The sniffer should not allocate a prologue cache if it did not
2362 match this frame. */
2363 gdb_assert (frame
->prologue_cache
== NULL
);
2365 /* No sniffer should extend the frame chain; sniff based on what is
2367 gdb_assert (!frame
->prev_p
);
2369 /* The sniffer should not check the frame's ID; that's circular. */
2370 gdb_assert (!frame
->this_id
.p
);
2372 /* Clear cached fields dependent on the unwinder.
2374 The previous PC is independent of the unwinder, but the previous
2375 function is not (see get_frame_address_in_block). */
2376 frame
->prev_func
.p
= 0;
2377 frame
->prev_func
.addr
= 0;
2379 /* Discard the unwinder last, so that we can easily find it if an assertion
2380 in this function triggers. */
2381 frame
->unwind
= NULL
;
2384 /* Set FRAME's unwinder temporarily, so that we can call a sniffer.
2385 Return a cleanup which should be called if unwinding fails, and
2386 discarded if it succeeds. */
2389 frame_prepare_for_sniffer (struct frame_info
*frame
,
2390 const struct frame_unwind
*unwind
)
2392 gdb_assert (frame
->unwind
== NULL
);
2393 frame
->unwind
= unwind
;
2394 return make_cleanup (frame_cleanup_after_sniffer
, frame
);
2397 extern initialize_file_ftype _initialize_frame
; /* -Wmissing-prototypes */
2399 static struct cmd_list_element
*set_backtrace_cmdlist
;
2400 static struct cmd_list_element
*show_backtrace_cmdlist
;
2403 set_backtrace_cmd (char *args
, int from_tty
)
2405 help_list (set_backtrace_cmdlist
, "set backtrace ", -1, gdb_stdout
);
2409 show_backtrace_cmd (char *args
, int from_tty
)
2411 cmd_show_list (show_backtrace_cmdlist
, from_tty
, "");
2415 _initialize_frame (void)
2417 obstack_init (&frame_cache_obstack
);
2419 observer_attach_target_changed (frame_observer_target_changed
);
2421 add_prefix_cmd ("backtrace", class_maintenance
, set_backtrace_cmd
, _("\
2422 Set backtrace specific variables.\n\
2423 Configure backtrace variables such as the backtrace limit"),
2424 &set_backtrace_cmdlist
, "set backtrace ",
2425 0/*allow-unknown*/, &setlist
);
2426 add_prefix_cmd ("backtrace", class_maintenance
, show_backtrace_cmd
, _("\
2427 Show backtrace specific variables\n\
2428 Show backtrace variables such as the backtrace limit"),
2429 &show_backtrace_cmdlist
, "show backtrace ",
2430 0/*allow-unknown*/, &showlist
);
2432 add_setshow_boolean_cmd ("past-main", class_obscure
,
2433 &backtrace_past_main
, _("\
2434 Set whether backtraces should continue past \"main\"."), _("\
2435 Show whether backtraces should continue past \"main\"."), _("\
2436 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
2437 the backtrace at \"main\". Set this variable if you need to see the rest\n\
2438 of the stack trace."),
2440 show_backtrace_past_main
,
2441 &set_backtrace_cmdlist
,
2442 &show_backtrace_cmdlist
);
2444 add_setshow_boolean_cmd ("past-entry", class_obscure
,
2445 &backtrace_past_entry
, _("\
2446 Set whether backtraces should continue past the entry point of a program."),
2448 Show whether backtraces should continue past the entry point of a program."),
2450 Normally there are no callers beyond the entry point of a program, so GDB\n\
2451 will terminate the backtrace there. Set this variable if you need to see\n\
2452 the rest of the stack trace."),
2454 show_backtrace_past_entry
,
2455 &set_backtrace_cmdlist
,
2456 &show_backtrace_cmdlist
);
2458 add_setshow_integer_cmd ("limit", class_obscure
,
2459 &backtrace_limit
, _("\
2460 Set an upper bound on the number of backtrace levels."), _("\
2461 Show the upper bound on the number of backtrace levels."), _("\
2462 No more than the specified number of frames can be displayed or examined.\n\
2463 Zero is unlimited."),
2465 show_backtrace_limit
,
2466 &set_backtrace_cmdlist
,
2467 &show_backtrace_cmdlist
);
2469 /* Debug this files internals. */
2470 add_setshow_zinteger_cmd ("frame", class_maintenance
, &frame_debug
, _("\
2471 Set frame debugging."), _("\
2472 Show frame debugging."), _("\
2473 When non-zero, frame specific internal debugging is enabled."),
2476 &setdebuglist
, &showdebuglist
);