1 /* Cache and manage frames for GDB, the GNU debugger.
3 Copyright (C) 1986-1987, 1989, 1991, 1994-1996, 1998, 2000-2004,
4 2007-2012 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
25 #include "inferior.h" /* for inferior_ptid */
27 #include "gdb_assert.h"
28 #include "gdb_string.h"
29 #include "user-regs.h"
30 #include "gdb_obstack.h"
31 #include "dummy-frame.h"
32 #include "sentinel-frame.h"
36 #include "frame-unwind.h"
37 #include "frame-base.h"
42 #include "exceptions.h"
43 #include "gdbthread.h"
45 #include "inline-frame.h"
46 #include "tracepoint.h"
48 static struct frame_info
*get_prev_frame_1 (struct frame_info
*this_frame
);
49 static struct frame_info
*get_prev_frame_raw (struct frame_info
*this_frame
);
51 /* We keep a cache of stack frames, each of which is a "struct
52 frame_info". The innermost one gets allocated (in
53 wait_for_inferior) each time the inferior stops; current_frame
54 points to it. Additional frames get allocated (in get_prev_frame)
55 as needed, and are chained through the next and prev fields. Any
56 time that the frame cache becomes invalid (most notably when we
57 execute something, but also if we change how we interpret the
58 frames (e.g. "set heuristic-fence-post" in mips-tdep.c, or anything
59 which reads new symbols)), we should call reinit_frame_cache. */
63 /* Level of this frame. The inner-most (youngest) frame is at level
64 0. As you move towards the outer-most (oldest) frame, the level
65 increases. This is a cached value. It could just as easily be
66 computed by counting back from the selected frame to the inner
68 /* NOTE: cagney/2002-04-05: Perhaps a level of ``-1'' should be
69 reserved to indicate a bogus frame - one that has been created
70 just to keep GDB happy (GDB always needs a frame). For the
71 moment leave this as speculation. */
74 /* The frame's program space. */
75 struct program_space
*pspace
;
77 /* The frame's address space. */
78 struct address_space
*aspace
;
80 /* The frame's low-level unwinder and corresponding cache. The
81 low-level unwinder is responsible for unwinding register values
82 for the previous frame. The low-level unwind methods are
83 selected based on the presence, or otherwise, of register unwind
84 information such as CFI. */
86 const struct frame_unwind
*unwind
;
88 /* Cached copy of the previous frame's architecture. */
95 /* Cached copy of the previous frame's resume address. */
101 /* Cached copy of the previous frame's function address. */
108 /* This frame's ID. */
112 struct frame_id value
;
115 /* The frame's high-level base methods, and corresponding cache.
116 The high level base methods are selected based on the frame's
118 const struct frame_base
*base
;
121 /* Pointers to the next (down, inner, younger) and previous (up,
122 outer, older) frame_info's in the frame cache. */
123 struct frame_info
*next
; /* down, inner, younger */
125 struct frame_info
*prev
; /* up, outer, older */
127 /* The reason why we could not set PREV, or UNWIND_NO_REASON if we
128 could. Only valid when PREV_P is set. */
129 enum unwind_stop_reason stop_reason
;
132 /* A frame stash used to speed up frame lookups. */
134 /* We currently only stash one frame at a time, as this seems to be
135 sufficient for now. */
136 static struct frame_info
*frame_stash
= NULL
;
138 /* Add the following FRAME to the frame stash. */
141 frame_stash_add (struct frame_info
*frame
)
146 /* Search the frame stash for an entry with the given frame ID.
147 If found, return that frame. Otherwise return NULL. */
149 static struct frame_info
*
150 frame_stash_find (struct frame_id id
)
152 if (frame_stash
&& frame_id_eq (frame_stash
->this_id
.value
, id
))
158 /* Invalidate the frame stash by removing all entries in it. */
161 frame_stash_invalidate (void)
166 /* Flag to control debugging. */
170 show_frame_debug (struct ui_file
*file
, int from_tty
,
171 struct cmd_list_element
*c
, const char *value
)
173 fprintf_filtered (file
, _("Frame debugging is %s.\n"), value
);
176 /* Flag to indicate whether backtraces should stop at main et.al. */
178 static int backtrace_past_main
;
180 show_backtrace_past_main (struct ui_file
*file
, int from_tty
,
181 struct cmd_list_element
*c
, const char *value
)
183 fprintf_filtered (file
,
184 _("Whether backtraces should "
185 "continue past \"main\" is %s.\n"),
189 static int backtrace_past_entry
;
191 show_backtrace_past_entry (struct ui_file
*file
, int from_tty
,
192 struct cmd_list_element
*c
, const char *value
)
194 fprintf_filtered (file
, _("Whether backtraces should continue past the "
195 "entry point of a program is %s.\n"),
199 static int backtrace_limit
= INT_MAX
;
201 show_backtrace_limit (struct ui_file
*file
, int from_tty
,
202 struct cmd_list_element
*c
, const char *value
)
204 fprintf_filtered (file
,
205 _("An upper bound on the number "
206 "of backtrace levels is %s.\n"),
212 fprint_field (struct ui_file
*file
, const char *name
, int p
, CORE_ADDR addr
)
215 fprintf_unfiltered (file
, "%s=%s", name
, hex_string (addr
));
217 fprintf_unfiltered (file
, "!%s", name
);
221 fprint_frame_id (struct ui_file
*file
, struct frame_id id
)
223 fprintf_unfiltered (file
, "{");
224 fprint_field (file
, "stack", id
.stack_addr_p
, id
.stack_addr
);
225 fprintf_unfiltered (file
, ",");
226 fprint_field (file
, "code", id
.code_addr_p
, id
.code_addr
);
227 fprintf_unfiltered (file
, ",");
228 fprint_field (file
, "special", id
.special_addr_p
, id
.special_addr
);
230 fprintf_unfiltered (file
, ",inlined=%d", id
.inline_depth
);
231 fprintf_unfiltered (file
, "}");
235 fprint_frame_type (struct ui_file
*file
, enum frame_type type
)
240 fprintf_unfiltered (file
, "NORMAL_FRAME");
243 fprintf_unfiltered (file
, "DUMMY_FRAME");
246 fprintf_unfiltered (file
, "INLINE_FRAME");
249 fprintf_unfiltered (file
, "SENTINEL_FRAME");
252 fprintf_unfiltered (file
, "SIGTRAMP_FRAME");
255 fprintf_unfiltered (file
, "ARCH_FRAME");
258 fprintf_unfiltered (file
, "<unknown type>");
264 fprint_frame (struct ui_file
*file
, struct frame_info
*fi
)
268 fprintf_unfiltered (file
, "<NULL frame>");
271 fprintf_unfiltered (file
, "{");
272 fprintf_unfiltered (file
, "level=%d", fi
->level
);
273 fprintf_unfiltered (file
, ",");
274 fprintf_unfiltered (file
, "type=");
275 if (fi
->unwind
!= NULL
)
276 fprint_frame_type (file
, fi
->unwind
->type
);
278 fprintf_unfiltered (file
, "<unknown>");
279 fprintf_unfiltered (file
, ",");
280 fprintf_unfiltered (file
, "unwind=");
281 if (fi
->unwind
!= NULL
)
282 gdb_print_host_address (fi
->unwind
, file
);
284 fprintf_unfiltered (file
, "<unknown>");
285 fprintf_unfiltered (file
, ",");
286 fprintf_unfiltered (file
, "pc=");
287 if (fi
->next
!= NULL
&& fi
->next
->prev_pc
.p
)
288 fprintf_unfiltered (file
, "%s", hex_string (fi
->next
->prev_pc
.value
));
290 fprintf_unfiltered (file
, "<unknown>");
291 fprintf_unfiltered (file
, ",");
292 fprintf_unfiltered (file
, "id=");
294 fprint_frame_id (file
, fi
->this_id
.value
);
296 fprintf_unfiltered (file
, "<unknown>");
297 fprintf_unfiltered (file
, ",");
298 fprintf_unfiltered (file
, "func=");
299 if (fi
->next
!= NULL
&& fi
->next
->prev_func
.p
)
300 fprintf_unfiltered (file
, "%s", hex_string (fi
->next
->prev_func
.addr
));
302 fprintf_unfiltered (file
, "<unknown>");
303 fprintf_unfiltered (file
, "}");
306 /* Given FRAME, return the enclosing normal frame for inlined
307 function frames. Otherwise return the original frame. */
309 static struct frame_info
*
310 skip_inlined_frames (struct frame_info
*frame
)
312 while (get_frame_type (frame
) == INLINE_FRAME
)
313 frame
= get_prev_frame (frame
);
318 /* Return a frame uniq ID that can be used to, later, re-find the
322 get_frame_id (struct frame_info
*fi
)
325 return null_frame_id
;
330 fprintf_unfiltered (gdb_stdlog
, "{ get_frame_id (fi=%d) ",
332 /* Find the unwinder. */
333 if (fi
->unwind
== NULL
)
334 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
335 /* Find THIS frame's ID. */
336 /* Default to outermost if no ID is found. */
337 fi
->this_id
.value
= outer_frame_id
;
338 fi
->unwind
->this_id (fi
, &fi
->prologue_cache
, &fi
->this_id
.value
);
339 gdb_assert (frame_id_p (fi
->this_id
.value
));
343 fprintf_unfiltered (gdb_stdlog
, "-> ");
344 fprint_frame_id (gdb_stdlog
, fi
->this_id
.value
);
345 fprintf_unfiltered (gdb_stdlog
, " }\n");
349 frame_stash_add (fi
);
351 return fi
->this_id
.value
;
355 get_stack_frame_id (struct frame_info
*next_frame
)
357 return get_frame_id (skip_inlined_frames (next_frame
));
361 frame_unwind_caller_id (struct frame_info
*next_frame
)
363 struct frame_info
*this_frame
;
365 /* Use get_prev_frame_1, and not get_prev_frame. The latter will truncate
366 the frame chain, leading to this function unintentionally
367 returning a null_frame_id (e.g., when a caller requests the frame
368 ID of "main()"s caller. */
370 next_frame
= skip_inlined_frames (next_frame
);
371 this_frame
= get_prev_frame_1 (next_frame
);
373 return get_frame_id (skip_inlined_frames (this_frame
));
375 return null_frame_id
;
378 const struct frame_id null_frame_id
; /* All zeros. */
379 const struct frame_id outer_frame_id
= { 0, 0, 0, 0, 0, 1, 0 };
382 frame_id_build_special (CORE_ADDR stack_addr
, CORE_ADDR code_addr
,
383 CORE_ADDR special_addr
)
385 struct frame_id id
= null_frame_id
;
387 id
.stack_addr
= stack_addr
;
389 id
.code_addr
= code_addr
;
391 id
.special_addr
= special_addr
;
392 id
.special_addr_p
= 1;
397 frame_id_build (CORE_ADDR stack_addr
, CORE_ADDR code_addr
)
399 struct frame_id id
= null_frame_id
;
401 id
.stack_addr
= stack_addr
;
403 id
.code_addr
= code_addr
;
409 frame_id_build_wild (CORE_ADDR stack_addr
)
411 struct frame_id id
= null_frame_id
;
413 id
.stack_addr
= stack_addr
;
419 frame_id_p (struct frame_id l
)
423 /* The frame is valid iff it has a valid stack address. */
425 /* outer_frame_id is also valid. */
426 if (!p
&& memcmp (&l
, &outer_frame_id
, sizeof (l
)) == 0)
430 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_p (l=");
431 fprint_frame_id (gdb_stdlog
, l
);
432 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", p
);
438 frame_id_inlined_p (struct frame_id l
)
443 return (l
.inline_depth
!= 0);
447 frame_id_eq (struct frame_id l
, struct frame_id r
)
451 if (!l
.stack_addr_p
&& l
.special_addr_p
452 && !r
.stack_addr_p
&& r
.special_addr_p
)
453 /* The outermost frame marker is equal to itself. This is the
454 dodgy thing about outer_frame_id, since between execution steps
455 we might step into another function - from which we can't
456 unwind either. More thought required to get rid of
459 else if (!l
.stack_addr_p
|| !r
.stack_addr_p
)
460 /* Like a NaN, if either ID is invalid, the result is false.
461 Note that a frame ID is invalid iff it is the null frame ID. */
463 else if (l
.stack_addr
!= r
.stack_addr
)
464 /* If .stack addresses are different, the frames are different. */
466 else if (l
.code_addr_p
&& r
.code_addr_p
&& l
.code_addr
!= r
.code_addr
)
467 /* An invalid code addr is a wild card. If .code addresses are
468 different, the frames are different. */
470 else if (l
.special_addr_p
&& r
.special_addr_p
471 && l
.special_addr
!= r
.special_addr
)
472 /* An invalid special addr is a wild card (or unused). Otherwise
473 if special addresses are different, the frames are different. */
475 else if (l
.inline_depth
!= r
.inline_depth
)
476 /* If inline depths are different, the frames must be different. */
479 /* Frames are equal. */
484 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_eq (l=");
485 fprint_frame_id (gdb_stdlog
, l
);
486 fprintf_unfiltered (gdb_stdlog
, ",r=");
487 fprint_frame_id (gdb_stdlog
, r
);
488 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", eq
);
493 /* Safety net to check whether frame ID L should be inner to
494 frame ID R, according to their stack addresses.
496 This method cannot be used to compare arbitrary frames, as the
497 ranges of valid stack addresses may be discontiguous (e.g. due
500 However, it can be used as safety net to discover invalid frame
501 IDs in certain circumstances. Assuming that NEXT is the immediate
502 inner frame to THIS and that NEXT and THIS are both NORMAL frames:
504 * The stack address of NEXT must be inner-than-or-equal to the stack
507 Therefore, if frame_id_inner (THIS, NEXT) holds, some unwind
510 * If NEXT and THIS have different stack addresses, no other frame
511 in the frame chain may have a stack address in between.
513 Therefore, if frame_id_inner (TEST, THIS) holds, but
514 frame_id_inner (TEST, NEXT) does not hold, TEST cannot refer
515 to a valid frame in the frame chain.
517 The sanity checks above cannot be performed when a SIGTRAMP frame
518 is involved, because signal handlers might be executed on a different
519 stack than the stack used by the routine that caused the signal
520 to be raised. This can happen for instance when a thread exceeds
521 its maximum stack size. In this case, certain compilers implement
522 a stack overflow strategy that cause the handler to be run on a
526 frame_id_inner (struct gdbarch
*gdbarch
, struct frame_id l
, struct frame_id r
)
530 if (!l
.stack_addr_p
|| !r
.stack_addr_p
)
531 /* Like NaN, any operation involving an invalid ID always fails. */
533 else if (l
.inline_depth
> r
.inline_depth
534 && l
.stack_addr
== r
.stack_addr
535 && l
.code_addr_p
== r
.code_addr_p
536 && l
.special_addr_p
== r
.special_addr_p
537 && l
.special_addr
== r
.special_addr
)
539 /* Same function, different inlined functions. */
540 struct block
*lb
, *rb
;
542 gdb_assert (l
.code_addr_p
&& r
.code_addr_p
);
544 lb
= block_for_pc (l
.code_addr
);
545 rb
= block_for_pc (r
.code_addr
);
547 if (lb
== NULL
|| rb
== NULL
)
548 /* Something's gone wrong. */
551 /* This will return true if LB and RB are the same block, or
552 if the block with the smaller depth lexically encloses the
553 block with the greater depth. */
554 inner
= contained_in (lb
, rb
);
557 /* Only return non-zero when strictly inner than. Note that, per
558 comment in "frame.h", there is some fuzz here. Frameless
559 functions are not strictly inner than (same .stack but
560 different .code and/or .special address). */
561 inner
= gdbarch_inner_than (gdbarch
, l
.stack_addr
, r
.stack_addr
);
564 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_inner (l=");
565 fprint_frame_id (gdb_stdlog
, l
);
566 fprintf_unfiltered (gdb_stdlog
, ",r=");
567 fprint_frame_id (gdb_stdlog
, r
);
568 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", inner
);
574 frame_find_by_id (struct frame_id id
)
576 struct frame_info
*frame
, *prev_frame
;
578 /* ZERO denotes the null frame, let the caller decide what to do
579 about it. Should it instead return get_current_frame()? */
580 if (!frame_id_p (id
))
583 /* Try using the frame stash first. Finding it there removes the need
584 to perform the search by looping over all frames, which can be very
585 CPU-intensive if the number of frames is very high (the loop is O(n)
586 and get_prev_frame performs a series of checks that are relatively
587 expensive). This optimization is particularly useful when this function
588 is called from another function (such as value_fetch_lazy, case
589 VALUE_LVAL (val) == lval_register) which already loops over all frames,
590 making the overall behavior O(n^2). */
591 frame
= frame_stash_find (id
);
595 for (frame
= get_current_frame (); ; frame
= prev_frame
)
597 struct frame_id
this = get_frame_id (frame
);
599 if (frame_id_eq (id
, this))
600 /* An exact match. */
603 prev_frame
= get_prev_frame (frame
);
607 /* As a safety net to avoid unnecessary backtracing while trying
608 to find an invalid ID, we check for a common situation where
609 we can detect from comparing stack addresses that no other
610 frame in the current frame chain can have this ID. See the
611 comment at frame_id_inner for details. */
612 if (get_frame_type (frame
) == NORMAL_FRAME
613 && !frame_id_inner (get_frame_arch (frame
), id
, this)
614 && frame_id_inner (get_frame_arch (prev_frame
), id
,
615 get_frame_id (prev_frame
)))
622 frame_unwind_pc_if_available (struct frame_info
*this_frame
, CORE_ADDR
*pc
)
624 if (!this_frame
->prev_pc
.p
)
626 if (gdbarch_unwind_pc_p (frame_unwind_arch (this_frame
)))
628 volatile struct gdb_exception ex
;
629 struct gdbarch
*prev_gdbarch
;
632 /* The right way. The `pure' way. The one true way. This
633 method depends solely on the register-unwind code to
634 determine the value of registers in THIS frame, and hence
635 the value of this frame's PC (resume address). A typical
636 implementation is no more than:
638 frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
639 return extract_unsigned_integer (buf, size of ISA_PC_REGNUM);
641 Note: this method is very heavily dependent on a correct
642 register-unwind implementation, it pays to fix that
643 method first; this method is frame type agnostic, since
644 it only deals with register values, it works with any
645 frame. This is all in stark contrast to the old
646 FRAME_SAVED_PC which would try to directly handle all the
647 different ways that a PC could be unwound. */
648 prev_gdbarch
= frame_unwind_arch (this_frame
);
650 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
652 pc
= gdbarch_unwind_pc (prev_gdbarch
, this_frame
);
654 if (ex
.reason
< 0 && ex
.error
== NOT_AVAILABLE_ERROR
)
656 this_frame
->prev_pc
.p
= -1;
659 fprintf_unfiltered (gdb_stdlog
,
660 "{ frame_unwind_pc (this_frame=%d)"
661 " -> <unavailable> }\n",
664 else if (ex
.reason
< 0)
666 throw_exception (ex
);
670 this_frame
->prev_pc
.value
= pc
;
671 this_frame
->prev_pc
.p
= 1;
673 fprintf_unfiltered (gdb_stdlog
,
674 "{ frame_unwind_pc (this_frame=%d) "
677 hex_string (this_frame
->prev_pc
.value
));
681 internal_error (__FILE__
, __LINE__
, _("No unwind_pc method"));
683 if (this_frame
->prev_pc
.p
< 0)
690 *pc
= this_frame
->prev_pc
.value
;
696 frame_unwind_pc (struct frame_info
*this_frame
)
700 if (!frame_unwind_pc_if_available (this_frame
, &pc
))
701 throw_error (NOT_AVAILABLE_ERROR
, _("PC not available"));
707 frame_unwind_caller_pc (struct frame_info
*this_frame
)
709 return frame_unwind_pc (skip_inlined_frames (this_frame
));
713 frame_unwind_caller_pc_if_available (struct frame_info
*this_frame
,
716 return frame_unwind_pc_if_available (skip_inlined_frames (this_frame
), pc
);
720 get_frame_func_if_available (struct frame_info
*this_frame
, CORE_ADDR
*pc
)
722 struct frame_info
*next_frame
= this_frame
->next
;
724 if (!next_frame
->prev_func
.p
)
726 CORE_ADDR addr_in_block
;
728 /* Make certain that this, and not the adjacent, function is
730 if (!get_frame_address_in_block_if_available (this_frame
, &addr_in_block
))
732 next_frame
->prev_func
.p
= -1;
734 fprintf_unfiltered (gdb_stdlog
,
735 "{ get_frame_func (this_frame=%d)"
736 " -> unavailable }\n",
741 next_frame
->prev_func
.p
= 1;
742 next_frame
->prev_func
.addr
= get_pc_function_start (addr_in_block
);
744 fprintf_unfiltered (gdb_stdlog
,
745 "{ get_frame_func (this_frame=%d) -> %s }\n",
747 hex_string (next_frame
->prev_func
.addr
));
751 if (next_frame
->prev_func
.p
< 0)
758 *pc
= next_frame
->prev_func
.addr
;
764 get_frame_func (struct frame_info
*this_frame
)
768 if (!get_frame_func_if_available (this_frame
, &pc
))
769 throw_error (NOT_AVAILABLE_ERROR
, _("PC not available"));
774 static enum register_status
775 do_frame_register_read (void *src
, int regnum
, gdb_byte
*buf
)
777 if (!frame_register_read (src
, regnum
, buf
))
778 return REG_UNAVAILABLE
;
784 frame_save_as_regcache (struct frame_info
*this_frame
)
786 struct address_space
*aspace
= get_frame_address_space (this_frame
);
787 struct regcache
*regcache
= regcache_xmalloc (get_frame_arch (this_frame
),
789 struct cleanup
*cleanups
= make_cleanup_regcache_xfree (regcache
);
791 regcache_save (regcache
, do_frame_register_read
, this_frame
);
792 discard_cleanups (cleanups
);
797 frame_pop (struct frame_info
*this_frame
)
799 struct frame_info
*prev_frame
;
800 struct regcache
*scratch
;
801 struct cleanup
*cleanups
;
803 if (get_frame_type (this_frame
) == DUMMY_FRAME
)
805 /* Popping a dummy frame involves restoring more than just registers.
806 dummy_frame_pop does all the work. */
807 dummy_frame_pop (get_frame_id (this_frame
));
811 /* Ensure that we have a frame to pop to. */
812 prev_frame
= get_prev_frame_1 (this_frame
);
815 error (_("Cannot pop the initial frame."));
817 /* Make a copy of all the register values unwound from this frame.
818 Save them in a scratch buffer so that there isn't a race between
819 trying to extract the old values from the current regcache while
820 at the same time writing new values into that same cache. */
821 scratch
= frame_save_as_regcache (prev_frame
);
822 cleanups
= make_cleanup_regcache_xfree (scratch
);
824 /* FIXME: cagney/2003-03-16: It should be possible to tell the
825 target's register cache that it is about to be hit with a burst
826 register transfer and that the sequence of register writes should
827 be batched. The pair target_prepare_to_store() and
828 target_store_registers() kind of suggest this functionality.
829 Unfortunately, they don't implement it. Their lack of a formal
830 definition can lead to targets writing back bogus values
831 (arguably a bug in the target code mind). */
832 /* Now copy those saved registers into the current regcache.
833 Here, regcache_cpy() calls regcache_restore(). */
834 regcache_cpy (get_current_regcache (), scratch
);
835 do_cleanups (cleanups
);
837 /* We've made right mess of GDB's local state, just discard
839 reinit_frame_cache ();
843 frame_register_unwind (struct frame_info
*frame
, int regnum
,
844 int *optimizedp
, int *unavailablep
,
845 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
846 int *realnump
, gdb_byte
*bufferp
)
850 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
851 that the value proper does not need to be fetched. */
852 gdb_assert (optimizedp
!= NULL
);
853 gdb_assert (lvalp
!= NULL
);
854 gdb_assert (addrp
!= NULL
);
855 gdb_assert (realnump
!= NULL
);
856 /* gdb_assert (bufferp != NULL); */
858 value
= frame_unwind_register_value (frame
, regnum
);
860 gdb_assert (value
!= NULL
);
862 *optimizedp
= value_optimized_out (value
);
863 *unavailablep
= !value_entirely_available (value
);
864 *lvalp
= VALUE_LVAL (value
);
865 *addrp
= value_address (value
);
866 *realnump
= VALUE_REGNUM (value
);
870 if (!*optimizedp
&& !*unavailablep
)
871 memcpy (bufferp
, value_contents_all (value
),
872 TYPE_LENGTH (value_type (value
)));
874 memset (bufferp
, 0, TYPE_LENGTH (value_type (value
)));
877 /* Dispose of the new value. This prevents watchpoints from
878 trying to watch the saved frame pointer. */
879 release_value (value
);
884 frame_register (struct frame_info
*frame
, int regnum
,
885 int *optimizedp
, int *unavailablep
, enum lval_type
*lvalp
,
886 CORE_ADDR
*addrp
, int *realnump
, gdb_byte
*bufferp
)
888 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
889 that the value proper does not need to be fetched. */
890 gdb_assert (optimizedp
!= NULL
);
891 gdb_assert (lvalp
!= NULL
);
892 gdb_assert (addrp
!= NULL
);
893 gdb_assert (realnump
!= NULL
);
894 /* gdb_assert (bufferp != NULL); */
896 /* Obtain the register value by unwinding the register from the next
897 (more inner frame). */
898 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
899 frame_register_unwind (frame
->next
, regnum
, optimizedp
, unavailablep
,
900 lvalp
, addrp
, realnump
, bufferp
);
904 frame_unwind_register (struct frame_info
*frame
, int regnum
, gdb_byte
*buf
)
912 frame_register_unwind (frame
, regnum
, &optimized
, &unavailable
,
913 &lval
, &addr
, &realnum
, buf
);
916 error (_("Register %d was optimized out"), regnum
);
918 throw_error (NOT_AVAILABLE_ERROR
,
919 _("Register %d is not available"), regnum
);
923 get_frame_register (struct frame_info
*frame
,
924 int regnum
, gdb_byte
*buf
)
926 frame_unwind_register (frame
->next
, regnum
, buf
);
930 frame_unwind_register_value (struct frame_info
*frame
, int regnum
)
932 struct gdbarch
*gdbarch
;
935 gdb_assert (frame
!= NULL
);
936 gdbarch
= frame_unwind_arch (frame
);
940 fprintf_unfiltered (gdb_stdlog
,
941 "{ frame_unwind_register_value "
942 "(frame=%d,regnum=%d(%s),...) ",
943 frame
->level
, regnum
,
944 user_reg_map_regnum_to_name (gdbarch
, regnum
));
947 /* Find the unwinder. */
948 if (frame
->unwind
== NULL
)
949 frame_unwind_find_by_frame (frame
, &frame
->prologue_cache
);
951 /* Ask this frame to unwind its register. */
952 value
= frame
->unwind
->prev_register (frame
, &frame
->prologue_cache
, regnum
);
956 fprintf_unfiltered (gdb_stdlog
, "->");
957 if (value_optimized_out (value
))
958 fprintf_unfiltered (gdb_stdlog
, " optimized out");
961 if (VALUE_LVAL (value
) == lval_register
)
962 fprintf_unfiltered (gdb_stdlog
, " register=%d",
963 VALUE_REGNUM (value
));
964 else if (VALUE_LVAL (value
) == lval_memory
)
965 fprintf_unfiltered (gdb_stdlog
, " address=%s",
967 value_address (value
)));
969 fprintf_unfiltered (gdb_stdlog
, " computed");
971 if (value_lazy (value
))
972 fprintf_unfiltered (gdb_stdlog
, " lazy");
976 const gdb_byte
*buf
= value_contents (value
);
978 fprintf_unfiltered (gdb_stdlog
, " bytes=");
979 fprintf_unfiltered (gdb_stdlog
, "[");
980 for (i
= 0; i
< register_size (gdbarch
, regnum
); i
++)
981 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
982 fprintf_unfiltered (gdb_stdlog
, "]");
986 fprintf_unfiltered (gdb_stdlog
, " }\n");
993 get_frame_register_value (struct frame_info
*frame
, int regnum
)
995 return frame_unwind_register_value (frame
->next
, regnum
);
999 frame_unwind_register_signed (struct frame_info
*frame
, int regnum
)
1001 struct gdbarch
*gdbarch
= frame_unwind_arch (frame
);
1002 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1003 int size
= register_size (gdbarch
, regnum
);
1004 gdb_byte buf
[MAX_REGISTER_SIZE
];
1006 frame_unwind_register (frame
, regnum
, buf
);
1007 return extract_signed_integer (buf
, size
, byte_order
);
1011 get_frame_register_signed (struct frame_info
*frame
, int regnum
)
1013 return frame_unwind_register_signed (frame
->next
, regnum
);
1017 frame_unwind_register_unsigned (struct frame_info
*frame
, int regnum
)
1019 struct gdbarch
*gdbarch
= frame_unwind_arch (frame
);
1020 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1021 int size
= register_size (gdbarch
, regnum
);
1022 gdb_byte buf
[MAX_REGISTER_SIZE
];
1024 frame_unwind_register (frame
, regnum
, buf
);
1025 return extract_unsigned_integer (buf
, size
, byte_order
);
1029 get_frame_register_unsigned (struct frame_info
*frame
, int regnum
)
1031 return frame_unwind_register_unsigned (frame
->next
, regnum
);
1035 put_frame_register (struct frame_info
*frame
, int regnum
,
1036 const gdb_byte
*buf
)
1038 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1042 enum lval_type lval
;
1045 frame_register (frame
, regnum
, &optim
, &unavail
,
1046 &lval
, &addr
, &realnum
, NULL
);
1048 error (_("Attempt to assign to a value that was optimized out."));
1053 /* FIXME: write_memory doesn't yet take constant buffers.
1055 gdb_byte tmp
[MAX_REGISTER_SIZE
];
1057 memcpy (tmp
, buf
, register_size (gdbarch
, regnum
));
1058 write_memory (addr
, tmp
, register_size (gdbarch
, regnum
));
1062 regcache_cooked_write (get_current_regcache (), realnum
, buf
);
1065 error (_("Attempt to assign to an unmodifiable value."));
1069 /* frame_register_read ()
1071 Find and return the value of REGNUM for the specified stack frame.
1072 The number of bytes copied is REGISTER_SIZE (REGNUM).
1074 Returns 0 if the register value could not be found. */
1077 frame_register_read (struct frame_info
*frame
, int regnum
,
1082 enum lval_type lval
;
1086 frame_register (frame
, regnum
, &optimized
, &unavailable
,
1087 &lval
, &addr
, &realnum
, myaddr
);
1089 return !optimized
&& !unavailable
;
1093 get_frame_register_bytes (struct frame_info
*frame
, int regnum
,
1094 CORE_ADDR offset
, int len
, gdb_byte
*myaddr
,
1095 int *optimizedp
, int *unavailablep
)
1097 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1102 /* Skip registers wholly inside of OFFSET. */
1103 while (offset
>= register_size (gdbarch
, regnum
))
1105 offset
-= register_size (gdbarch
, regnum
);
1109 /* Ensure that we will not read beyond the end of the register file.
1110 This can only ever happen if the debug information is bad. */
1112 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1113 for (i
= regnum
; i
< numregs
; i
++)
1115 int thissize
= register_size (gdbarch
, i
);
1118 break; /* This register is not available on this architecture. */
1119 maxsize
+= thissize
;
1122 error (_("Bad debug information detected: "
1123 "Attempt to read %d bytes from registers."), len
);
1125 /* Copy the data. */
1128 int curr_len
= register_size (gdbarch
, regnum
) - offset
;
1133 if (curr_len
== register_size (gdbarch
, regnum
))
1135 enum lval_type lval
;
1139 frame_register (frame
, regnum
, optimizedp
, unavailablep
,
1140 &lval
, &addr
, &realnum
, myaddr
);
1141 if (*optimizedp
|| *unavailablep
)
1146 gdb_byte buf
[MAX_REGISTER_SIZE
];
1147 enum lval_type lval
;
1151 frame_register (frame
, regnum
, optimizedp
, unavailablep
,
1152 &lval
, &addr
, &realnum
, buf
);
1153 if (*optimizedp
|| *unavailablep
)
1155 memcpy (myaddr
, buf
+ offset
, curr_len
);
1170 put_frame_register_bytes (struct frame_info
*frame
, int regnum
,
1171 CORE_ADDR offset
, int len
, const gdb_byte
*myaddr
)
1173 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1175 /* Skip registers wholly inside of OFFSET. */
1176 while (offset
>= register_size (gdbarch
, regnum
))
1178 offset
-= register_size (gdbarch
, regnum
);
1182 /* Copy the data. */
1185 int curr_len
= register_size (gdbarch
, regnum
) - offset
;
1190 if (curr_len
== register_size (gdbarch
, regnum
))
1192 put_frame_register (frame
, regnum
, myaddr
);
1196 gdb_byte buf
[MAX_REGISTER_SIZE
];
1198 frame_register_read (frame
, regnum
, buf
);
1199 memcpy (buf
+ offset
, myaddr
, curr_len
);
1200 put_frame_register (frame
, regnum
, buf
);
1210 /* Create a sentinel frame. */
1212 static struct frame_info
*
1213 create_sentinel_frame (struct program_space
*pspace
, struct regcache
*regcache
)
1215 struct frame_info
*frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1218 frame
->pspace
= pspace
;
1219 frame
->aspace
= get_regcache_aspace (regcache
);
1220 /* Explicitly initialize the sentinel frame's cache. Provide it
1221 with the underlying regcache. In the future additional
1222 information, such as the frame's thread will be added. */
1223 frame
->prologue_cache
= sentinel_frame_cache (regcache
);
1224 /* For the moment there is only one sentinel frame implementation. */
1225 frame
->unwind
= &sentinel_frame_unwind
;
1226 /* Link this frame back to itself. The frame is self referential
1227 (the unwound PC is the same as the pc), so make it so. */
1228 frame
->next
= frame
;
1229 /* Make the sentinel frame's ID valid, but invalid. That way all
1230 comparisons with it should fail. */
1231 frame
->this_id
.p
= 1;
1232 frame
->this_id
.value
= null_frame_id
;
1235 fprintf_unfiltered (gdb_stdlog
, "{ create_sentinel_frame (...) -> ");
1236 fprint_frame (gdb_stdlog
, frame
);
1237 fprintf_unfiltered (gdb_stdlog
, " }\n");
1242 /* Info about the innermost stack frame (contents of FP register). */
1244 static struct frame_info
*current_frame
;
1246 /* Cache for frame addresses already read by gdb. Valid only while
1247 inferior is stopped. Control variables for the frame cache should
1248 be local to this module. */
1250 static struct obstack frame_cache_obstack
;
1253 frame_obstack_zalloc (unsigned long size
)
1255 void *data
= obstack_alloc (&frame_cache_obstack
, size
);
1257 memset (data
, 0, size
);
1261 /* Return the innermost (currently executing) stack frame. This is
1262 split into two functions. The function unwind_to_current_frame()
1263 is wrapped in catch exceptions so that, even when the unwind of the
1264 sentinel frame fails, the function still returns a stack frame. */
1267 unwind_to_current_frame (struct ui_out
*ui_out
, void *args
)
1269 struct frame_info
*frame
= get_prev_frame (args
);
1271 /* A sentinel frame can fail to unwind, e.g., because its PC value
1272 lands in somewhere like start. */
1275 current_frame
= frame
;
1280 get_current_frame (void)
1282 /* First check, and report, the lack of registers. Having GDB
1283 report "No stack!" or "No memory" when the target doesn't even
1284 have registers is very confusing. Besides, "printcmd.exp"
1285 explicitly checks that ``print $pc'' with no registers prints "No
1287 if (!target_has_registers
)
1288 error (_("No registers."));
1289 if (!target_has_stack
)
1290 error (_("No stack."));
1291 if (!target_has_memory
)
1292 error (_("No memory."));
1293 /* Traceframes are effectively a substitute for the live inferior. */
1294 if (get_traceframe_number () < 0)
1296 if (ptid_equal (inferior_ptid
, null_ptid
))
1297 error (_("No selected thread."));
1298 if (is_exited (inferior_ptid
))
1299 error (_("Invalid selected thread."));
1300 if (is_executing (inferior_ptid
))
1301 error (_("Target is executing."));
1304 if (current_frame
== NULL
)
1306 struct frame_info
*sentinel_frame
=
1307 create_sentinel_frame (current_program_space
, get_current_regcache ());
1308 if (catch_exceptions (current_uiout
, unwind_to_current_frame
,
1309 sentinel_frame
, RETURN_MASK_ERROR
) != 0)
1311 /* Oops! Fake a current frame? Is this useful? It has a PC
1312 of zero, for instance. */
1313 current_frame
= sentinel_frame
;
1316 return current_frame
;
1319 /* The "selected" stack frame is used by default for local and arg
1320 access. May be zero, for no selected frame. */
1322 static struct frame_info
*selected_frame
;
1325 has_stack_frames (void)
1327 if (!target_has_registers
|| !target_has_stack
|| !target_has_memory
)
1330 /* Traceframes are effectively a substitute for the live inferior. */
1331 if (get_traceframe_number () < 0)
1333 /* No current inferior, no frame. */
1334 if (ptid_equal (inferior_ptid
, null_ptid
))
1337 /* Don't try to read from a dead thread. */
1338 if (is_exited (inferior_ptid
))
1341 /* ... or from a spinning thread. */
1342 if (is_executing (inferior_ptid
))
1349 /* Return the selected frame. Always non-NULL (unless there isn't an
1350 inferior sufficient for creating a frame) in which case an error is
1354 get_selected_frame (const char *message
)
1356 if (selected_frame
== NULL
)
1358 if (message
!= NULL
&& !has_stack_frames ())
1359 error (("%s"), message
);
1360 /* Hey! Don't trust this. It should really be re-finding the
1361 last selected frame of the currently selected thread. This,
1362 though, is better than nothing. */
1363 select_frame (get_current_frame ());
1365 /* There is always a frame. */
1366 gdb_assert (selected_frame
!= NULL
);
1367 return selected_frame
;
1370 /* If there is a selected frame, return it. Otherwise, return NULL. */
1373 get_selected_frame_if_set (void)
1375 return selected_frame
;
1378 /* This is a variant of get_selected_frame() which can be called when
1379 the inferior does not have a frame; in that case it will return
1380 NULL instead of calling error(). */
1383 deprecated_safe_get_selected_frame (void)
1385 if (!has_stack_frames ())
1387 return get_selected_frame (NULL
);
1390 /* Select frame FI (or NULL - to invalidate the current frame). */
1393 select_frame (struct frame_info
*fi
)
1395 selected_frame
= fi
;
1396 /* NOTE: cagney/2002-05-04: FI can be NULL. This occurs when the
1397 frame is being invalidated. */
1398 if (deprecated_selected_frame_level_changed_hook
)
1399 deprecated_selected_frame_level_changed_hook (frame_relative_level (fi
));
1401 /* FIXME: kseitz/2002-08-28: It would be nice to call
1402 selected_frame_level_changed_event() right here, but due to limitations
1403 in the current interfaces, we would end up flooding UIs with events
1404 because select_frame() is used extensively internally.
1406 Once we have frame-parameterized frame (and frame-related) commands,
1407 the event notification can be moved here, since this function will only
1408 be called when the user's selected frame is being changed. */
1410 /* Ensure that symbols for this frame are read in. Also, determine the
1411 source language of this frame, and switch to it if desired. */
1416 /* We retrieve the frame's symtab by using the frame PC.
1417 However we cannot use the frame PC as-is, because it usually
1418 points to the instruction following the "call", which is
1419 sometimes the first instruction of another function. So we
1420 rely on get_frame_address_in_block() which provides us with a
1421 PC which is guaranteed to be inside the frame's code
1423 if (get_frame_address_in_block_if_available (fi
, &pc
))
1425 struct symtab
*s
= find_pc_symtab (pc
);
1428 && s
->language
!= current_language
->la_language
1429 && s
->language
!= language_unknown
1430 && language_mode
== language_mode_auto
)
1431 set_language (s
->language
);
1436 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
1437 Always returns a non-NULL value. */
1440 create_new_frame (CORE_ADDR addr
, CORE_ADDR pc
)
1442 struct frame_info
*fi
;
1446 fprintf_unfiltered (gdb_stdlog
,
1447 "{ create_new_frame (addr=%s, pc=%s) ",
1448 hex_string (addr
), hex_string (pc
));
1451 fi
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1453 fi
->next
= create_sentinel_frame (current_program_space
,
1454 get_current_regcache ());
1456 /* Set/update this frame's cached PC value, found in the next frame.
1457 Do this before looking for this frame's unwinder. A sniffer is
1458 very likely to read this, and the corresponding unwinder is
1459 entitled to rely that the PC doesn't magically change. */
1460 fi
->next
->prev_pc
.value
= pc
;
1461 fi
->next
->prev_pc
.p
= 1;
1463 /* We currently assume that frame chain's can't cross spaces. */
1464 fi
->pspace
= fi
->next
->pspace
;
1465 fi
->aspace
= fi
->next
->aspace
;
1467 /* Select/initialize both the unwind function and the frame's type
1469 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
1472 fi
->this_id
.value
= frame_id_build (addr
, pc
);
1476 fprintf_unfiltered (gdb_stdlog
, "-> ");
1477 fprint_frame (gdb_stdlog
, fi
);
1478 fprintf_unfiltered (gdb_stdlog
, " }\n");
1484 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
1485 innermost frame). Be careful to not fall off the bottom of the
1486 frame chain and onto the sentinel frame. */
1489 get_next_frame (struct frame_info
*this_frame
)
1491 if (this_frame
->level
> 0)
1492 return this_frame
->next
;
1497 /* Observer for the target_changed event. */
1500 frame_observer_target_changed (struct target_ops
*target
)
1502 reinit_frame_cache ();
1505 /* Flush the entire frame cache. */
1508 reinit_frame_cache (void)
1510 struct frame_info
*fi
;
1512 /* Tear down all frame caches. */
1513 for (fi
= current_frame
; fi
!= NULL
; fi
= fi
->prev
)
1515 if (fi
->prologue_cache
&& fi
->unwind
->dealloc_cache
)
1516 fi
->unwind
->dealloc_cache (fi
, fi
->prologue_cache
);
1517 if (fi
->base_cache
&& fi
->base
->unwind
->dealloc_cache
)
1518 fi
->base
->unwind
->dealloc_cache (fi
, fi
->base_cache
);
1521 /* Since we can't really be sure what the first object allocated was. */
1522 obstack_free (&frame_cache_obstack
, 0);
1523 obstack_init (&frame_cache_obstack
);
1525 if (current_frame
!= NULL
)
1526 annotate_frames_invalid ();
1528 current_frame
= NULL
; /* Invalidate cache */
1529 select_frame (NULL
);
1530 frame_stash_invalidate ();
1532 fprintf_unfiltered (gdb_stdlog
, "{ reinit_frame_cache () }\n");
1535 /* Find where a register is saved (in memory or another register).
1536 The result of frame_register_unwind is just where it is saved
1537 relative to this particular frame. */
1540 frame_register_unwind_location (struct frame_info
*this_frame
, int regnum
,
1541 int *optimizedp
, enum lval_type
*lvalp
,
1542 CORE_ADDR
*addrp
, int *realnump
)
1544 gdb_assert (this_frame
== NULL
|| this_frame
->level
>= 0);
1546 while (this_frame
!= NULL
)
1550 frame_register_unwind (this_frame
, regnum
, optimizedp
, &unavailable
,
1551 lvalp
, addrp
, realnump
, NULL
);
1556 if (*lvalp
!= lval_register
)
1560 this_frame
= get_next_frame (this_frame
);
1564 /* Return a "struct frame_info" corresponding to the frame that called
1565 THIS_FRAME. Returns NULL if there is no such frame.
1567 Unlike get_prev_frame, this function always tries to unwind the
1570 static struct frame_info
*
1571 get_prev_frame_1 (struct frame_info
*this_frame
)
1573 struct frame_id this_id
;
1574 struct gdbarch
*gdbarch
;
1576 gdb_assert (this_frame
!= NULL
);
1577 gdbarch
= get_frame_arch (this_frame
);
1581 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame_1 (this_frame=");
1582 if (this_frame
!= NULL
)
1583 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1585 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1586 fprintf_unfiltered (gdb_stdlog
, ") ");
1589 /* Only try to do the unwind once. */
1590 if (this_frame
->prev_p
)
1594 fprintf_unfiltered (gdb_stdlog
, "-> ");
1595 fprint_frame (gdb_stdlog
, this_frame
->prev
);
1596 fprintf_unfiltered (gdb_stdlog
, " // cached \n");
1598 return this_frame
->prev
;
1601 /* If the frame unwinder hasn't been selected yet, we must do so
1602 before setting prev_p; otherwise the check for misbehaved
1603 sniffers will think that this frame's sniffer tried to unwind
1604 further (see frame_cleanup_after_sniffer). */
1605 if (this_frame
->unwind
== NULL
)
1606 frame_unwind_find_by_frame (this_frame
, &this_frame
->prologue_cache
);
1608 this_frame
->prev_p
= 1;
1609 this_frame
->stop_reason
= UNWIND_NO_REASON
;
1611 /* If we are unwinding from an inline frame, all of the below tests
1612 were already performed when we unwound from the next non-inline
1613 frame. We must skip them, since we can not get THIS_FRAME's ID
1614 until we have unwound all the way down to the previous non-inline
1616 if (get_frame_type (this_frame
) == INLINE_FRAME
)
1617 return get_prev_frame_raw (this_frame
);
1619 /* Check that this frame is unwindable. If it isn't, don't try to
1620 unwind to the prev frame. */
1621 this_frame
->stop_reason
1622 = this_frame
->unwind
->stop_reason (this_frame
,
1623 &this_frame
->prologue_cache
);
1625 if (this_frame
->stop_reason
!= UNWIND_NO_REASON
)
1628 /* Check that this frame's ID was valid. If it wasn't, don't try to
1629 unwind to the prev frame. Be careful to not apply this test to
1630 the sentinel frame. */
1631 this_id
= get_frame_id (this_frame
);
1632 if (this_frame
->level
>= 0 && frame_id_eq (this_id
, outer_frame_id
))
1636 fprintf_unfiltered (gdb_stdlog
, "-> ");
1637 fprint_frame (gdb_stdlog
, NULL
);
1638 fprintf_unfiltered (gdb_stdlog
, " // this ID is NULL }\n");
1640 this_frame
->stop_reason
= UNWIND_NULL_ID
;
1644 /* Check that this frame's ID isn't inner to (younger, below, next)
1645 the next frame. This happens when a frame unwind goes backwards.
1646 This check is valid only if this frame and the next frame are NORMAL.
1647 See the comment at frame_id_inner for details. */
1648 if (get_frame_type (this_frame
) == NORMAL_FRAME
1649 && this_frame
->next
->unwind
->type
== NORMAL_FRAME
1650 && frame_id_inner (get_frame_arch (this_frame
->next
), this_id
,
1651 get_frame_id (this_frame
->next
)))
1653 CORE_ADDR this_pc_in_block
;
1654 struct minimal_symbol
*morestack_msym
;
1655 const char *morestack_name
= NULL
;
1657 /* gcc -fsplit-stack __morestack can continue the stack anywhere. */
1658 this_pc_in_block
= get_frame_address_in_block (this_frame
);
1659 morestack_msym
= lookup_minimal_symbol_by_pc (this_pc_in_block
);
1661 morestack_name
= SYMBOL_LINKAGE_NAME (morestack_msym
);
1662 if (!morestack_name
|| strcmp (morestack_name
, "__morestack") != 0)
1666 fprintf_unfiltered (gdb_stdlog
, "-> ");
1667 fprint_frame (gdb_stdlog
, NULL
);
1668 fprintf_unfiltered (gdb_stdlog
,
1669 " // this frame ID is inner }\n");
1671 this_frame
->stop_reason
= UNWIND_INNER_ID
;
1676 /* Check that this and the next frame are not identical. If they
1677 are, there is most likely a stack cycle. As with the inner-than
1678 test above, avoid comparing the inner-most and sentinel frames. */
1679 if (this_frame
->level
> 0
1680 && frame_id_eq (this_id
, get_frame_id (this_frame
->next
)))
1684 fprintf_unfiltered (gdb_stdlog
, "-> ");
1685 fprint_frame (gdb_stdlog
, NULL
);
1686 fprintf_unfiltered (gdb_stdlog
, " // this frame has same ID }\n");
1688 this_frame
->stop_reason
= UNWIND_SAME_ID
;
1692 /* Check that this and the next frame do not unwind the PC register
1693 to the same memory location. If they do, then even though they
1694 have different frame IDs, the new frame will be bogus; two
1695 functions can't share a register save slot for the PC. This can
1696 happen when the prologue analyzer finds a stack adjustment, but
1699 This check does assume that the "PC register" is roughly a
1700 traditional PC, even if the gdbarch_unwind_pc method adjusts
1701 it (we do not rely on the value, only on the unwound PC being
1702 dependent on this value). A potential improvement would be
1703 to have the frame prev_pc method and the gdbarch unwind_pc
1704 method set the same lval and location information as
1705 frame_register_unwind. */
1706 if (this_frame
->level
> 0
1707 && gdbarch_pc_regnum (gdbarch
) >= 0
1708 && get_frame_type (this_frame
) == NORMAL_FRAME
1709 && (get_frame_type (this_frame
->next
) == NORMAL_FRAME
1710 || get_frame_type (this_frame
->next
) == INLINE_FRAME
))
1712 int optimized
, realnum
, nrealnum
;
1713 enum lval_type lval
, nlval
;
1714 CORE_ADDR addr
, naddr
;
1716 frame_register_unwind_location (this_frame
,
1717 gdbarch_pc_regnum (gdbarch
),
1718 &optimized
, &lval
, &addr
, &realnum
);
1719 frame_register_unwind_location (get_next_frame (this_frame
),
1720 gdbarch_pc_regnum (gdbarch
),
1721 &optimized
, &nlval
, &naddr
, &nrealnum
);
1723 if ((lval
== lval_memory
&& lval
== nlval
&& addr
== naddr
)
1724 || (lval
== lval_register
&& lval
== nlval
&& realnum
== nrealnum
))
1728 fprintf_unfiltered (gdb_stdlog
, "-> ");
1729 fprint_frame (gdb_stdlog
, NULL
);
1730 fprintf_unfiltered (gdb_stdlog
, " // no saved PC }\n");
1733 this_frame
->stop_reason
= UNWIND_NO_SAVED_PC
;
1734 this_frame
->prev
= NULL
;
1739 return get_prev_frame_raw (this_frame
);
1742 /* Construct a new "struct frame_info" and link it previous to
1745 static struct frame_info
*
1746 get_prev_frame_raw (struct frame_info
*this_frame
)
1748 struct frame_info
*prev_frame
;
1750 /* Allocate the new frame but do not wire it in to the frame chain.
1751 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
1752 frame->next to pull some fancy tricks (of course such code is, by
1753 definition, recursive). Try to prevent it.
1755 There is no reason to worry about memory leaks, should the
1756 remainder of the function fail. The allocated memory will be
1757 quickly reclaimed when the frame cache is flushed, and the `we've
1758 been here before' check above will stop repeated memory
1759 allocation calls. */
1760 prev_frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1761 prev_frame
->level
= this_frame
->level
+ 1;
1763 /* For now, assume we don't have frame chains crossing address
1765 prev_frame
->pspace
= this_frame
->pspace
;
1766 prev_frame
->aspace
= this_frame
->aspace
;
1768 /* Don't yet compute ->unwind (and hence ->type). It is computed
1769 on-demand in get_frame_type, frame_register_unwind, and
1772 /* Don't yet compute the frame's ID. It is computed on-demand by
1775 /* The unwound frame ID is validate at the start of this function,
1776 as part of the logic to decide if that frame should be further
1777 unwound, and not here while the prev frame is being created.
1778 Doing this makes it possible for the user to examine a frame that
1779 has an invalid frame ID.
1781 Some very old VAX code noted: [...] For the sake of argument,
1782 suppose that the stack is somewhat trashed (which is one reason
1783 that "info frame" exists). So, return 0 (indicating we don't
1784 know the address of the arglist) if we don't know what frame this
1788 this_frame
->prev
= prev_frame
;
1789 prev_frame
->next
= this_frame
;
1793 fprintf_unfiltered (gdb_stdlog
, "-> ");
1794 fprint_frame (gdb_stdlog
, prev_frame
);
1795 fprintf_unfiltered (gdb_stdlog
, " }\n");
1801 /* Debug routine to print a NULL frame being returned. */
1804 frame_debug_got_null_frame (struct frame_info
*this_frame
,
1809 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame (this_frame=");
1810 if (this_frame
!= NULL
)
1811 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1813 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1814 fprintf_unfiltered (gdb_stdlog
, ") -> // %s}\n", reason
);
1818 /* Is this (non-sentinel) frame in the "main"() function? */
1821 inside_main_func (struct frame_info
*this_frame
)
1823 struct minimal_symbol
*msymbol
;
1826 if (symfile_objfile
== 0)
1828 msymbol
= lookup_minimal_symbol (main_name (), NULL
, symfile_objfile
);
1829 if (msymbol
== NULL
)
1831 /* Make certain that the code, and not descriptor, address is
1833 maddr
= gdbarch_convert_from_func_ptr_addr (get_frame_arch (this_frame
),
1834 SYMBOL_VALUE_ADDRESS (msymbol
),
1836 return maddr
== get_frame_func (this_frame
);
1839 /* Test whether THIS_FRAME is inside the process entry point function. */
1842 inside_entry_func (struct frame_info
*this_frame
)
1844 CORE_ADDR entry_point
;
1846 if (!entry_point_address_query (&entry_point
))
1849 return get_frame_func (this_frame
) == entry_point
;
1852 /* Return a structure containing various interesting information about
1853 the frame that called THIS_FRAME. Returns NULL if there is entier
1854 no such frame or the frame fails any of a set of target-independent
1855 condition that should terminate the frame chain (e.g., as unwinding
1858 This function should not contain target-dependent tests, such as
1859 checking whether the program-counter is zero. */
1862 get_prev_frame (struct frame_info
*this_frame
)
1867 /* There is always a frame. If this assertion fails, suspect that
1868 something should be calling get_selected_frame() or
1869 get_current_frame(). */
1870 gdb_assert (this_frame
!= NULL
);
1871 frame_pc_p
= get_frame_pc_if_available (this_frame
, &frame_pc
);
1873 /* tausq/2004-12-07: Dummy frames are skipped because it doesn't make much
1874 sense to stop unwinding at a dummy frame. One place where a dummy
1875 frame may have an address "inside_main_func" is on HPUX. On HPUX, the
1876 pcsqh register (space register for the instruction at the head of the
1877 instruction queue) cannot be written directly; the only way to set it
1878 is to branch to code that is in the target space. In order to implement
1879 frame dummies on HPUX, the called function is made to jump back to where
1880 the inferior was when the user function was called. If gdb was inside
1881 the main function when we created the dummy frame, the dummy frame will
1882 point inside the main function. */
1883 if (this_frame
->level
>= 0
1884 && get_frame_type (this_frame
) == NORMAL_FRAME
1885 && !backtrace_past_main
1887 && inside_main_func (this_frame
))
1888 /* Don't unwind past main(). Note, this is done _before_ the
1889 frame has been marked as previously unwound. That way if the
1890 user later decides to enable unwinds past main(), that will
1891 automatically happen. */
1893 frame_debug_got_null_frame (this_frame
, "inside main func");
1897 /* If the user's backtrace limit has been exceeded, stop. We must
1898 add two to the current level; one of those accounts for backtrace_limit
1899 being 1-based and the level being 0-based, and the other accounts for
1900 the level of the new frame instead of the level of the current
1902 if (this_frame
->level
+ 2 > backtrace_limit
)
1904 frame_debug_got_null_frame (this_frame
, "backtrace limit exceeded");
1908 /* If we're already inside the entry function for the main objfile,
1909 then it isn't valid. Don't apply this test to a dummy frame -
1910 dummy frame PCs typically land in the entry func. Don't apply
1911 this test to the sentinel frame. Sentinel frames should always
1912 be allowed to unwind. */
1913 /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() -
1914 wasn't checking for "main" in the minimal symbols. With that
1915 fixed asm-source tests now stop in "main" instead of halting the
1916 backtrace in weird and wonderful ways somewhere inside the entry
1917 file. Suspect that tests for inside the entry file/func were
1918 added to work around that (now fixed) case. */
1919 /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
1920 suggested having the inside_entry_func test use the
1921 inside_main_func() msymbol trick (along with entry_point_address()
1922 I guess) to determine the address range of the start function.
1923 That should provide a far better stopper than the current
1925 /* NOTE: tausq/2004-10-09: this is needed if, for example, the compiler
1926 applied tail-call optimizations to main so that a function called
1927 from main returns directly to the caller of main. Since we don't
1928 stop at main, we should at least stop at the entry point of the
1930 if (this_frame
->level
>= 0
1931 && get_frame_type (this_frame
) == NORMAL_FRAME
1932 && !backtrace_past_entry
1934 && inside_entry_func (this_frame
))
1936 frame_debug_got_null_frame (this_frame
, "inside entry func");
1940 /* Assume that the only way to get a zero PC is through something
1941 like a SIGSEGV or a dummy frame, and hence that NORMAL frames
1942 will never unwind a zero PC. */
1943 if (this_frame
->level
> 0
1944 && (get_frame_type (this_frame
) == NORMAL_FRAME
1945 || get_frame_type (this_frame
) == INLINE_FRAME
)
1946 && get_frame_type (get_next_frame (this_frame
)) == NORMAL_FRAME
1947 && frame_pc_p
&& frame_pc
== 0)
1949 frame_debug_got_null_frame (this_frame
, "zero PC");
1953 return get_prev_frame_1 (this_frame
);
1957 get_frame_pc (struct frame_info
*frame
)
1959 gdb_assert (frame
->next
!= NULL
);
1960 return frame_unwind_pc (frame
->next
);
1964 get_frame_pc_if_available (struct frame_info
*frame
, CORE_ADDR
*pc
)
1966 volatile struct gdb_exception ex
;
1968 gdb_assert (frame
->next
!= NULL
);
1970 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
1972 *pc
= frame_unwind_pc (frame
->next
);
1976 if (ex
.error
== NOT_AVAILABLE_ERROR
)
1979 throw_exception (ex
);
1985 /* Return an address that falls within THIS_FRAME's code block. */
1988 get_frame_address_in_block (struct frame_info
*this_frame
)
1990 /* A draft address. */
1991 CORE_ADDR pc
= get_frame_pc (this_frame
);
1993 struct frame_info
*next_frame
= this_frame
->next
;
1995 /* Calling get_frame_pc returns the resume address for THIS_FRAME.
1996 Normally the resume address is inside the body of the function
1997 associated with THIS_FRAME, but there is a special case: when
1998 calling a function which the compiler knows will never return
1999 (for instance abort), the call may be the very last instruction
2000 in the calling function. The resume address will point after the
2001 call and may be at the beginning of a different function
2004 If THIS_FRAME is a signal frame or dummy frame, then we should
2005 not adjust the unwound PC. For a dummy frame, GDB pushed the
2006 resume address manually onto the stack. For a signal frame, the
2007 OS may have pushed the resume address manually and invoked the
2008 handler (e.g. GNU/Linux), or invoked the trampoline which called
2009 the signal handler - but in either case the signal handler is
2010 expected to return to the trampoline. So in both of these
2011 cases we know that the resume address is executable and
2012 related. So we only need to adjust the PC if THIS_FRAME
2013 is a normal function.
2015 If the program has been interrupted while THIS_FRAME is current,
2016 then clearly the resume address is inside the associated
2017 function. There are three kinds of interruption: debugger stop
2018 (next frame will be SENTINEL_FRAME), operating system
2019 signal or exception (next frame will be SIGTRAMP_FRAME),
2020 or debugger-induced function call (next frame will be
2021 DUMMY_FRAME). So we only need to adjust the PC if
2022 NEXT_FRAME is a normal function.
2024 We check the type of NEXT_FRAME first, since it is already
2025 known; frame type is determined by the unwinder, and since
2026 we have THIS_FRAME we've already selected an unwinder for
2029 If the next frame is inlined, we need to keep going until we find
2030 the real function - for instance, if a signal handler is invoked
2031 while in an inlined function, then the code address of the
2032 "calling" normal function should not be adjusted either. */
2034 while (get_frame_type (next_frame
) == INLINE_FRAME
)
2035 next_frame
= next_frame
->next
;
2037 if ((get_frame_type (next_frame
) == NORMAL_FRAME
2038 || get_frame_type (next_frame
) == TAILCALL_FRAME
)
2039 && (get_frame_type (this_frame
) == NORMAL_FRAME
2040 || get_frame_type (this_frame
) == TAILCALL_FRAME
2041 || get_frame_type (this_frame
) == INLINE_FRAME
))
2048 get_frame_address_in_block_if_available (struct frame_info
*this_frame
,
2051 volatile struct gdb_exception ex
;
2053 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2055 *pc
= get_frame_address_in_block (this_frame
);
2057 if (ex
.reason
< 0 && ex
.error
== NOT_AVAILABLE_ERROR
)
2059 else if (ex
.reason
< 0)
2060 throw_exception (ex
);
2066 find_frame_sal (struct frame_info
*frame
, struct symtab_and_line
*sal
)
2068 struct frame_info
*next_frame
;
2072 /* If the next frame represents an inlined function call, this frame's
2073 sal is the "call site" of that inlined function, which can not
2074 be inferred from get_frame_pc. */
2075 next_frame
= get_next_frame (frame
);
2076 if (frame_inlined_callees (frame
) > 0)
2081 sym
= get_frame_function (next_frame
);
2083 sym
= inline_skipped_symbol (inferior_ptid
);
2085 /* If frame is inline, it certainly has symbols. */
2088 if (SYMBOL_LINE (sym
) != 0)
2090 sal
->symtab
= SYMBOL_SYMTAB (sym
);
2091 sal
->line
= SYMBOL_LINE (sym
);
2094 /* If the symbol does not have a location, we don't know where
2095 the call site is. Do not pretend to. This is jarring, but
2096 we can't do much better. */
2097 sal
->pc
= get_frame_pc (frame
);
2102 /* If FRAME is not the innermost frame, that normally means that
2103 FRAME->pc points at the return instruction (which is *after* the
2104 call instruction), and we want to get the line containing the
2105 call (because the call is where the user thinks the program is).
2106 However, if the next frame is either a SIGTRAMP_FRAME or a
2107 DUMMY_FRAME, then the next frame will contain a saved interrupt
2108 PC and such a PC indicates the current (rather than next)
2109 instruction/line, consequently, for such cases, want to get the
2110 line containing fi->pc. */
2111 if (!get_frame_pc_if_available (frame
, &pc
))
2117 notcurrent
= (pc
!= get_frame_address_in_block (frame
));
2118 (*sal
) = find_pc_line (pc
, notcurrent
);
2121 /* Per "frame.h", return the ``address'' of the frame. Code should
2122 really be using get_frame_id(). */
2124 get_frame_base (struct frame_info
*fi
)
2126 return get_frame_id (fi
).stack_addr
;
2129 /* High-level offsets into the frame. Used by the debug info. */
2132 get_frame_base_address (struct frame_info
*fi
)
2134 if (get_frame_type (fi
) != NORMAL_FRAME
)
2136 if (fi
->base
== NULL
)
2137 fi
->base
= frame_base_find_by_frame (fi
);
2138 /* Sneaky: If the low-level unwind and high-level base code share a
2139 common unwinder, let them share the prologue cache. */
2140 if (fi
->base
->unwind
== fi
->unwind
)
2141 return fi
->base
->this_base (fi
, &fi
->prologue_cache
);
2142 return fi
->base
->this_base (fi
, &fi
->base_cache
);
2146 get_frame_locals_address (struct frame_info
*fi
)
2148 if (get_frame_type (fi
) != NORMAL_FRAME
)
2150 /* If there isn't a frame address method, find it. */
2151 if (fi
->base
== NULL
)
2152 fi
->base
= frame_base_find_by_frame (fi
);
2153 /* Sneaky: If the low-level unwind and high-level base code share a
2154 common unwinder, let them share the prologue cache. */
2155 if (fi
->base
->unwind
== fi
->unwind
)
2156 return fi
->base
->this_locals (fi
, &fi
->prologue_cache
);
2157 return fi
->base
->this_locals (fi
, &fi
->base_cache
);
2161 get_frame_args_address (struct frame_info
*fi
)
2163 if (get_frame_type (fi
) != NORMAL_FRAME
)
2165 /* If there isn't a frame address method, find it. */
2166 if (fi
->base
== NULL
)
2167 fi
->base
= frame_base_find_by_frame (fi
);
2168 /* Sneaky: If the low-level unwind and high-level base code share a
2169 common unwinder, let them share the prologue cache. */
2170 if (fi
->base
->unwind
== fi
->unwind
)
2171 return fi
->base
->this_args (fi
, &fi
->prologue_cache
);
2172 return fi
->base
->this_args (fi
, &fi
->base_cache
);
2175 /* Return true if the frame unwinder for frame FI is UNWINDER; false
2179 frame_unwinder_is (struct frame_info
*fi
, const struct frame_unwind
*unwinder
)
2181 if (fi
->unwind
== NULL
)
2182 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
2183 return fi
->unwind
== unwinder
;
2186 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
2187 or -1 for a NULL frame. */
2190 frame_relative_level (struct frame_info
*fi
)
2199 get_frame_type (struct frame_info
*frame
)
2201 if (frame
->unwind
== NULL
)
2202 /* Initialize the frame's unwinder because that's what
2203 provides the frame's type. */
2204 frame_unwind_find_by_frame (frame
, &frame
->prologue_cache
);
2205 return frame
->unwind
->type
;
2208 struct program_space
*
2209 get_frame_program_space (struct frame_info
*frame
)
2211 return frame
->pspace
;
2214 struct program_space
*
2215 frame_unwind_program_space (struct frame_info
*this_frame
)
2217 gdb_assert (this_frame
);
2219 /* This is really a placeholder to keep the API consistent --- we
2220 assume for now that we don't have frame chains crossing
2222 return this_frame
->pspace
;
2225 struct address_space
*
2226 get_frame_address_space (struct frame_info
*frame
)
2228 return frame
->aspace
;
2231 /* Memory access methods. */
2234 get_frame_memory (struct frame_info
*this_frame
, CORE_ADDR addr
,
2235 gdb_byte
*buf
, int len
)
2237 read_memory (addr
, buf
, len
);
2241 get_frame_memory_signed (struct frame_info
*this_frame
, CORE_ADDR addr
,
2244 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2245 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2247 return read_memory_integer (addr
, len
, byte_order
);
2251 get_frame_memory_unsigned (struct frame_info
*this_frame
, CORE_ADDR addr
,
2254 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2255 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2257 return read_memory_unsigned_integer (addr
, len
, byte_order
);
2261 safe_frame_unwind_memory (struct frame_info
*this_frame
,
2262 CORE_ADDR addr
, gdb_byte
*buf
, int len
)
2264 /* NOTE: target_read_memory returns zero on success! */
2265 return !target_read_memory (addr
, buf
, len
);
2268 /* Architecture methods. */
2271 get_frame_arch (struct frame_info
*this_frame
)
2273 return frame_unwind_arch (this_frame
->next
);
2277 frame_unwind_arch (struct frame_info
*next_frame
)
2279 if (!next_frame
->prev_arch
.p
)
2281 struct gdbarch
*arch
;
2283 if (next_frame
->unwind
== NULL
)
2284 frame_unwind_find_by_frame (next_frame
, &next_frame
->prologue_cache
);
2286 if (next_frame
->unwind
->prev_arch
!= NULL
)
2287 arch
= next_frame
->unwind
->prev_arch (next_frame
,
2288 &next_frame
->prologue_cache
);
2290 arch
= get_frame_arch (next_frame
);
2292 next_frame
->prev_arch
.arch
= arch
;
2293 next_frame
->prev_arch
.p
= 1;
2295 fprintf_unfiltered (gdb_stdlog
,
2296 "{ frame_unwind_arch (next_frame=%d) -> %s }\n",
2298 gdbarch_bfd_arch_info (arch
)->printable_name
);
2301 return next_frame
->prev_arch
.arch
;
2305 frame_unwind_caller_arch (struct frame_info
*next_frame
)
2307 return frame_unwind_arch (skip_inlined_frames (next_frame
));
2310 /* Stack pointer methods. */
2313 get_frame_sp (struct frame_info
*this_frame
)
2315 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2317 /* Normality - an architecture that provides a way of obtaining any
2318 frame inner-most address. */
2319 if (gdbarch_unwind_sp_p (gdbarch
))
2320 /* NOTE drow/2008-06-28: gdbarch_unwind_sp could be converted to
2321 operate on THIS_FRAME now. */
2322 return gdbarch_unwind_sp (gdbarch
, this_frame
->next
);
2323 /* Now things are really are grim. Hope that the value returned by
2324 the gdbarch_sp_regnum register is meaningful. */
2325 if (gdbarch_sp_regnum (gdbarch
) >= 0)
2326 return get_frame_register_unsigned (this_frame
,
2327 gdbarch_sp_regnum (gdbarch
));
2328 internal_error (__FILE__
, __LINE__
, _("Missing unwind SP method"));
2331 /* Return the reason why we can't unwind past FRAME. */
2333 enum unwind_stop_reason
2334 get_frame_unwind_stop_reason (struct frame_info
*frame
)
2336 /* If we haven't tried to unwind past this point yet, then assume
2337 that unwinding would succeed. */
2338 if (frame
->prev_p
== 0)
2339 return UNWIND_NO_REASON
;
2341 /* Otherwise, we set a reason when we succeeded (or failed) to
2343 return frame
->stop_reason
;
2346 /* Return a string explaining REASON. */
2349 frame_stop_reason_string (enum unwind_stop_reason reason
)
2353 #define SET(name, description) \
2354 case name: return _(description);
2355 #include "unwind_stop_reasons.def"
2359 internal_error (__FILE__
, __LINE__
,
2360 "Invalid frame stop reason");
2364 /* Clean up after a failed (wrong unwinder) attempt to unwind past
2368 frame_cleanup_after_sniffer (void *arg
)
2370 struct frame_info
*frame
= arg
;
2372 /* The sniffer should not allocate a prologue cache if it did not
2373 match this frame. */
2374 gdb_assert (frame
->prologue_cache
== NULL
);
2376 /* No sniffer should extend the frame chain; sniff based on what is
2378 gdb_assert (!frame
->prev_p
);
2380 /* The sniffer should not check the frame's ID; that's circular. */
2381 gdb_assert (!frame
->this_id
.p
);
2383 /* Clear cached fields dependent on the unwinder.
2385 The previous PC is independent of the unwinder, but the previous
2386 function is not (see get_frame_address_in_block). */
2387 frame
->prev_func
.p
= 0;
2388 frame
->prev_func
.addr
= 0;
2390 /* Discard the unwinder last, so that we can easily find it if an assertion
2391 in this function triggers. */
2392 frame
->unwind
= NULL
;
2395 /* Set FRAME's unwinder temporarily, so that we can call a sniffer.
2396 Return a cleanup which should be called if unwinding fails, and
2397 discarded if it succeeds. */
2400 frame_prepare_for_sniffer (struct frame_info
*frame
,
2401 const struct frame_unwind
*unwind
)
2403 gdb_assert (frame
->unwind
== NULL
);
2404 frame
->unwind
= unwind
;
2405 return make_cleanup (frame_cleanup_after_sniffer
, frame
);
2408 extern initialize_file_ftype _initialize_frame
; /* -Wmissing-prototypes */
2410 static struct cmd_list_element
*set_backtrace_cmdlist
;
2411 static struct cmd_list_element
*show_backtrace_cmdlist
;
2414 set_backtrace_cmd (char *args
, int from_tty
)
2416 help_list (set_backtrace_cmdlist
, "set backtrace ", -1, gdb_stdout
);
2420 show_backtrace_cmd (char *args
, int from_tty
)
2422 cmd_show_list (show_backtrace_cmdlist
, from_tty
, "");
2426 _initialize_frame (void)
2428 obstack_init (&frame_cache_obstack
);
2430 observer_attach_target_changed (frame_observer_target_changed
);
2432 add_prefix_cmd ("backtrace", class_maintenance
, set_backtrace_cmd
, _("\
2433 Set backtrace specific variables.\n\
2434 Configure backtrace variables such as the backtrace limit"),
2435 &set_backtrace_cmdlist
, "set backtrace ",
2436 0/*allow-unknown*/, &setlist
);
2437 add_prefix_cmd ("backtrace", class_maintenance
, show_backtrace_cmd
, _("\
2438 Show backtrace specific variables\n\
2439 Show backtrace variables such as the backtrace limit"),
2440 &show_backtrace_cmdlist
, "show backtrace ",
2441 0/*allow-unknown*/, &showlist
);
2443 add_setshow_boolean_cmd ("past-main", class_obscure
,
2444 &backtrace_past_main
, _("\
2445 Set whether backtraces should continue past \"main\"."), _("\
2446 Show whether backtraces should continue past \"main\"."), _("\
2447 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
2448 the backtrace at \"main\". Set this variable if you need to see the rest\n\
2449 of the stack trace."),
2451 show_backtrace_past_main
,
2452 &set_backtrace_cmdlist
,
2453 &show_backtrace_cmdlist
);
2455 add_setshow_boolean_cmd ("past-entry", class_obscure
,
2456 &backtrace_past_entry
, _("\
2457 Set whether backtraces should continue past the entry point of a program."),
2459 Show whether backtraces should continue past the entry point of a program."),
2461 Normally there are no callers beyond the entry point of a program, so GDB\n\
2462 will terminate the backtrace there. Set this variable if you need to see\n\
2463 the rest of the stack trace."),
2465 show_backtrace_past_entry
,
2466 &set_backtrace_cmdlist
,
2467 &show_backtrace_cmdlist
);
2469 add_setshow_integer_cmd ("limit", class_obscure
,
2470 &backtrace_limit
, _("\
2471 Set an upper bound on the number of backtrace levels."), _("\
2472 Show the upper bound on the number of backtrace levels."), _("\
2473 No more than the specified number of frames can be displayed or examined.\n\
2474 Zero is unlimited."),
2476 show_backtrace_limit
,
2477 &set_backtrace_cmdlist
,
2478 &show_backtrace_cmdlist
);
2480 /* Debug this files internals. */
2481 add_setshow_zinteger_cmd ("frame", class_maintenance
, &frame_debug
, _("\
2482 Set frame debugging."), _("\
2483 Show frame debugging."), _("\
2484 When non-zero, frame specific internal debugging is enabled."),
2487 &setdebuglist
, &showdebuglist
);