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 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 continue past \"main\" is %s.\n"),
188 static int backtrace_past_entry;
190 show_backtrace_past_entry (struct ui_file *file, int from_tty,
191 struct cmd_list_element *c, const char *value)
193 fprintf_filtered (file, _("\
194 Whether backtraces should continue past the entry point of a program is %s.\n"),
198 static int backtrace_limit = INT_MAX;
200 show_backtrace_limit (struct ui_file *file, int from_tty,
201 struct cmd_list_element *c, const char *value)
203 fprintf_filtered (file, _("\
204 An upper bound on the number of backtrace levels is %s.\n"),
210 fprint_field (struct ui_file *file, const char *name, int p, CORE_ADDR addr)
213 fprintf_unfiltered (file, "%s=%s", name, hex_string (addr));
215 fprintf_unfiltered (file, "!%s", name);
219 fprint_frame_id (struct ui_file *file, struct frame_id id)
221 fprintf_unfiltered (file, "{");
222 fprint_field (file, "stack", id.stack_addr_p, id.stack_addr);
223 fprintf_unfiltered (file, ",");
224 fprint_field (file, "code", id.code_addr_p, id.code_addr);
225 fprintf_unfiltered (file, ",");
226 fprint_field (file, "special", id.special_addr_p, id.special_addr);
228 fprintf_unfiltered (file, ",inlined=%d", id.inline_depth);
229 fprintf_unfiltered (file, "}");
233 fprint_frame_type (struct ui_file *file, enum frame_type type)
238 fprintf_unfiltered (file, "NORMAL_FRAME");
241 fprintf_unfiltered (file, "DUMMY_FRAME");
244 fprintf_unfiltered (file, "INLINE_FRAME");
247 fprintf_unfiltered (file, "SENTINEL_FRAME");
250 fprintf_unfiltered (file, "SIGTRAMP_FRAME");
253 fprintf_unfiltered (file, "ARCH_FRAME");
256 fprintf_unfiltered (file, "<unknown type>");
262 fprint_frame (struct ui_file *file, struct frame_info *fi)
266 fprintf_unfiltered (file, "<NULL frame>");
269 fprintf_unfiltered (file, "{");
270 fprintf_unfiltered (file, "level=%d", fi->level);
271 fprintf_unfiltered (file, ",");
272 fprintf_unfiltered (file, "type=");
273 if (fi->unwind != NULL)
274 fprint_frame_type (file, fi->unwind->type);
276 fprintf_unfiltered (file, "<unknown>");
277 fprintf_unfiltered (file, ",");
278 fprintf_unfiltered (file, "unwind=");
279 if (fi->unwind != NULL)
280 gdb_print_host_address (fi->unwind, file);
282 fprintf_unfiltered (file, "<unknown>");
283 fprintf_unfiltered (file, ",");
284 fprintf_unfiltered (file, "pc=");
285 if (fi->next != NULL && fi->next->prev_pc.p)
286 fprintf_unfiltered (file, "%s", hex_string (fi->next->prev_pc.value));
288 fprintf_unfiltered (file, "<unknown>");
289 fprintf_unfiltered (file, ",");
290 fprintf_unfiltered (file, "id=");
292 fprint_frame_id (file, fi->this_id.value);
294 fprintf_unfiltered (file, "<unknown>");
295 fprintf_unfiltered (file, ",");
296 fprintf_unfiltered (file, "func=");
297 if (fi->next != NULL && fi->next->prev_func.p)
298 fprintf_unfiltered (file, "%s", hex_string (fi->next->prev_func.addr));
300 fprintf_unfiltered (file, "<unknown>");
301 fprintf_unfiltered (file, "}");
304 /* Given FRAME, return the enclosing normal frame for inlined
305 function frames. Otherwise return the original frame. */
307 static struct frame_info *
308 skip_inlined_frames (struct frame_info *frame)
310 while (get_frame_type (frame) == INLINE_FRAME)
311 frame = get_prev_frame (frame);
316 /* Return a frame uniq ID that can be used to, later, re-find the
320 get_frame_id (struct frame_info *fi)
323 return null_frame_id;
328 fprintf_unfiltered (gdb_stdlog, "{ get_frame_id (fi=%d) ",
330 /* Find the unwinder. */
331 if (fi->unwind == NULL)
332 frame_unwind_find_by_frame (fi, &fi->prologue_cache);
333 /* Find THIS frame's ID. */
334 /* Default to outermost if no ID is found. */
335 fi->this_id.value = outer_frame_id;
336 fi->unwind->this_id (fi, &fi->prologue_cache, &fi->this_id.value);
337 gdb_assert (frame_id_p (fi->this_id.value));
341 fprintf_unfiltered (gdb_stdlog, "-> ");
342 fprint_frame_id (gdb_stdlog, fi->this_id.value);
343 fprintf_unfiltered (gdb_stdlog, " }\n");
347 frame_stash_add (fi);
349 return fi->this_id.value;
353 get_stack_frame_id (struct frame_info *next_frame)
355 return get_frame_id (skip_inlined_frames (next_frame));
359 frame_unwind_caller_id (struct frame_info *next_frame)
361 struct frame_info *this_frame;
363 /* Use get_prev_frame_1, and not get_prev_frame. The latter will truncate
364 the frame chain, leading to this function unintentionally
365 returning a null_frame_id (e.g., when a caller requests the frame
366 ID of "main()"s caller. */
368 next_frame = skip_inlined_frames (next_frame);
369 this_frame = get_prev_frame_1 (next_frame);
371 return get_frame_id (skip_inlined_frames (this_frame));
373 return null_frame_id;
376 const struct frame_id null_frame_id; /* All zeros. */
377 const struct frame_id outer_frame_id = { 0, 0, 0, 0, 0, 1, 0 };
380 frame_id_build_special (CORE_ADDR stack_addr, CORE_ADDR code_addr,
381 CORE_ADDR special_addr)
383 struct frame_id id = null_frame_id;
385 id.stack_addr = stack_addr;
387 id.code_addr = code_addr;
389 id.special_addr = special_addr;
390 id.special_addr_p = 1;
395 frame_id_build (CORE_ADDR stack_addr, CORE_ADDR code_addr)
397 struct frame_id id = null_frame_id;
399 id.stack_addr = stack_addr;
401 id.code_addr = code_addr;
407 frame_id_build_wild (CORE_ADDR stack_addr)
409 struct frame_id id = null_frame_id;
411 id.stack_addr = stack_addr;
417 frame_id_p (struct frame_id l)
421 /* The frame is valid iff it has a valid stack address. */
423 /* outer_frame_id is also valid. */
424 if (!p && memcmp (&l, &outer_frame_id, sizeof (l)) == 0)
428 fprintf_unfiltered (gdb_stdlog, "{ frame_id_p (l=");
429 fprint_frame_id (gdb_stdlog, l);
430 fprintf_unfiltered (gdb_stdlog, ") -> %d }\n", p);
436 frame_id_inlined_p (struct frame_id l)
441 return (l.inline_depth != 0);
445 frame_id_eq (struct frame_id l, struct frame_id r)
449 if (!l.stack_addr_p && l.special_addr_p && !r.stack_addr_p && r.special_addr_p)
450 /* The outermost frame marker is equal to itself. This is the
451 dodgy thing about outer_frame_id, since between execution steps
452 we might step into another function - from which we can't
453 unwind either. More thought required to get rid of
456 else if (!l.stack_addr_p || !r.stack_addr_p)
457 /* Like a NaN, if either ID is invalid, the result is false.
458 Note that a frame ID is invalid iff it is the null frame ID. */
460 else if (l.stack_addr != r.stack_addr)
461 /* If .stack addresses are different, the frames are different. */
463 else if (l.code_addr_p && r.code_addr_p && l.code_addr != r.code_addr)
464 /* An invalid code addr is a wild card. If .code addresses are
465 different, the frames are different. */
467 else if (l.special_addr_p && r.special_addr_p
468 && l.special_addr != r.special_addr)
469 /* An invalid special addr is a wild card (or unused). Otherwise
470 if special addresses are different, the frames are different. */
472 else if (l.inline_depth != r.inline_depth)
473 /* If inline depths are different, the frames must be different. */
476 /* Frames are equal. */
481 fprintf_unfiltered (gdb_stdlog, "{ frame_id_eq (l=");
482 fprint_frame_id (gdb_stdlog, l);
483 fprintf_unfiltered (gdb_stdlog, ",r=");
484 fprint_frame_id (gdb_stdlog, r);
485 fprintf_unfiltered (gdb_stdlog, ") -> %d }\n", eq);
490 /* Safety net to check whether frame ID L should be inner to
491 frame ID R, according to their stack addresses.
493 This method cannot be used to compare arbitrary frames, as the
494 ranges of valid stack addresses may be discontiguous (e.g. due
497 However, it can be used as safety net to discover invalid frame
498 IDs in certain circumstances. Assuming that NEXT is the immediate
499 inner frame to THIS and that NEXT and THIS are both NORMAL frames:
501 * The stack address of NEXT must be inner-than-or-equal to the stack
504 Therefore, if frame_id_inner (THIS, NEXT) holds, some unwind
507 * If NEXT and THIS have different stack addresses, no other frame
508 in the frame chain may have a stack address in between.
510 Therefore, if frame_id_inner (TEST, THIS) holds, but
511 frame_id_inner (TEST, NEXT) does not hold, TEST cannot refer
512 to a valid frame in the frame chain.
514 The sanity checks above cannot be performed when a SIGTRAMP frame
515 is involved, because signal handlers might be executed on a different
516 stack than the stack used by the routine that caused the signal
517 to be raised. This can happen for instance when a thread exceeds
518 its maximum stack size. In this case, certain compilers implement
519 a stack overflow strategy that cause the handler to be run on a
523 frame_id_inner (struct gdbarch *gdbarch, struct frame_id l, struct frame_id r)
527 if (!l.stack_addr_p || !r.stack_addr_p)
528 /* Like NaN, any operation involving an invalid ID always fails. */
530 else if (l.inline_depth > r.inline_depth
531 && l.stack_addr == r.stack_addr
532 && l.code_addr_p == r.code_addr_p
533 && l.special_addr_p == r.special_addr_p
534 && l.special_addr == r.special_addr)
536 /* Same function, different inlined functions. */
537 struct block *lb, *rb;
539 gdb_assert (l.code_addr_p && r.code_addr_p);
541 lb = block_for_pc (l.code_addr);
542 rb = block_for_pc (r.code_addr);
544 if (lb == NULL || rb == NULL)
545 /* Something's gone wrong. */
548 /* This will return true if LB and RB are the same block, or
549 if the block with the smaller depth lexically encloses the
550 block with the greater depth. */
551 inner = contained_in (lb, rb);
554 /* Only return non-zero when strictly inner than. Note that, per
555 comment in "frame.h", there is some fuzz here. Frameless
556 functions are not strictly inner than (same .stack but
557 different .code and/or .special address). */
558 inner = gdbarch_inner_than (gdbarch, l.stack_addr, r.stack_addr);
561 fprintf_unfiltered (gdb_stdlog, "{ frame_id_inner (l=");
562 fprint_frame_id (gdb_stdlog, l);
563 fprintf_unfiltered (gdb_stdlog, ",r=");
564 fprint_frame_id (gdb_stdlog, r);
565 fprintf_unfiltered (gdb_stdlog, ") -> %d }\n", inner);
571 frame_find_by_id (struct frame_id id)
573 struct frame_info *frame, *prev_frame;
575 /* ZERO denotes the null frame, let the caller decide what to do
576 about it. Should it instead return get_current_frame()? */
577 if (!frame_id_p (id))
580 /* Try using the frame stash first. Finding it there removes the need
581 to perform the search by looping over all frames, which can be very
582 CPU-intensive if the number of frames is very high (the loop is O(n)
583 and get_prev_frame performs a series of checks that are relatively
584 expensive). This optimization is particularly useful when this function
585 is called from another function (such as value_fetch_lazy, case
586 VALUE_LVAL (val) == lval_register) which already loops over all frames,
587 making the overall behavior O(n^2). */
588 frame = frame_stash_find (id);
592 for (frame = get_current_frame (); ; frame = prev_frame)
594 struct frame_id this = get_frame_id (frame);
596 if (frame_id_eq (id, this))
597 /* An exact match. */
600 prev_frame = get_prev_frame (frame);
604 /* As a safety net to avoid unnecessary backtracing while trying
605 to find an invalid ID, we check for a common situation where
606 we can detect from comparing stack addresses that no other
607 frame in the current frame chain can have this ID. See the
608 comment at frame_id_inner for details. */
609 if (get_frame_type (frame) == NORMAL_FRAME
610 && !frame_id_inner (get_frame_arch (frame), id, this)
611 && frame_id_inner (get_frame_arch (prev_frame), id,
612 get_frame_id (prev_frame)))
619 frame_unwind_pc (struct frame_info *this_frame)
621 if (!this_frame->prev_pc.p)
625 if (gdbarch_unwind_pc_p (frame_unwind_arch (this_frame)))
627 /* The right way. The `pure' way. The one true way. This
628 method depends solely on the register-unwind code to
629 determine the value of registers in THIS frame, and hence
630 the value of this frame's PC (resume address). A typical
631 implementation is no more than:
633 frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
634 return extract_unsigned_integer (buf, size of ISA_PC_REGNUM);
636 Note: this method is very heavily dependent on a correct
637 register-unwind implementation, it pays to fix that
638 method first; this method is frame type agnostic, since
639 it only deals with register values, it works with any
640 frame. This is all in stark contrast to the old
641 FRAME_SAVED_PC which would try to directly handle all the
642 different ways that a PC could be unwound. */
643 pc = gdbarch_unwind_pc (frame_unwind_arch (this_frame), this_frame);
646 internal_error (__FILE__, __LINE__, _("No unwind_pc method"));
647 this_frame->prev_pc.value = pc;
648 this_frame->prev_pc.p = 1;
650 fprintf_unfiltered (gdb_stdlog,
651 "{ frame_unwind_caller_pc (this_frame=%d) -> %s }\n",
653 hex_string (this_frame->prev_pc.value));
655 return this_frame->prev_pc.value;
659 frame_unwind_caller_pc (struct frame_info *this_frame)
661 return frame_unwind_pc (skip_inlined_frames (this_frame));
665 get_frame_func (struct frame_info *this_frame)
667 struct frame_info *next_frame = this_frame->next;
669 if (!next_frame->prev_func.p)
671 /* Make certain that this, and not the adjacent, function is
673 CORE_ADDR addr_in_block = get_frame_address_in_block (this_frame);
674 next_frame->prev_func.p = 1;
675 next_frame->prev_func.addr = get_pc_function_start (addr_in_block);
677 fprintf_unfiltered (gdb_stdlog,
678 "{ get_frame_func (this_frame=%d) -> %s }\n",
680 hex_string (next_frame->prev_func.addr));
682 return next_frame->prev_func.addr;
686 do_frame_register_read (void *src, int regnum, gdb_byte *buf)
688 return frame_register_read (src, regnum, buf);
692 frame_save_as_regcache (struct frame_info *this_frame)
694 struct address_space *aspace = get_frame_address_space (this_frame);
695 struct regcache *regcache = regcache_xmalloc (get_frame_arch (this_frame),
697 struct cleanup *cleanups = make_cleanup_regcache_xfree (regcache);
699 regcache_save (regcache, do_frame_register_read, this_frame);
700 discard_cleanups (cleanups);
705 frame_pop (struct frame_info *this_frame)
707 struct frame_info *prev_frame;
708 struct regcache *scratch;
709 struct cleanup *cleanups;
711 if (get_frame_type (this_frame) == DUMMY_FRAME)
713 /* Popping a dummy frame involves restoring more than just registers.
714 dummy_frame_pop does all the work. */
715 dummy_frame_pop (get_frame_id (this_frame));
719 /* Ensure that we have a frame to pop to. */
720 prev_frame = get_prev_frame_1 (this_frame);
723 error (_("Cannot pop the initial frame."));
725 /* Make a copy of all the register values unwound from this frame.
726 Save them in a scratch buffer so that there isn't a race between
727 trying to extract the old values from the current regcache while
728 at the same time writing new values into that same cache. */
729 scratch = frame_save_as_regcache (prev_frame);
730 cleanups = make_cleanup_regcache_xfree (scratch);
732 /* FIXME: cagney/2003-03-16: It should be possible to tell the
733 target's register cache that it is about to be hit with a burst
734 register transfer and that the sequence of register writes should
735 be batched. The pair target_prepare_to_store() and
736 target_store_registers() kind of suggest this functionality.
737 Unfortunately, they don't implement it. Their lack of a formal
738 definition can lead to targets writing back bogus values
739 (arguably a bug in the target code mind). */
740 /* Now copy those saved registers into the current regcache.
741 Here, regcache_cpy() calls regcache_restore(). */
742 regcache_cpy (get_current_regcache (), scratch);
743 do_cleanups (cleanups);
745 /* We've made right mess of GDB's local state, just discard
747 reinit_frame_cache ();
751 frame_register_unwind (struct frame_info *frame, int regnum,
752 int *optimizedp, enum lval_type *lvalp,
753 CORE_ADDR *addrp, int *realnump, gdb_byte *bufferp)
757 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
758 that the value proper does not need to be fetched. */
759 gdb_assert (optimizedp != NULL);
760 gdb_assert (lvalp != NULL);
761 gdb_assert (addrp != NULL);
762 gdb_assert (realnump != NULL);
763 /* gdb_assert (bufferp != NULL); */
765 value = frame_unwind_register_value (frame, regnum);
767 gdb_assert (value != NULL);
769 *optimizedp = value_optimized_out (value);
770 *lvalp = VALUE_LVAL (value);
771 *addrp = value_address (value);
772 *realnump = VALUE_REGNUM (value);
774 if (bufferp && !*optimizedp)
775 memcpy (bufferp, value_contents_all (value),
776 TYPE_LENGTH (value_type (value)));
778 /* Dispose of the new value. This prevents watchpoints from
779 trying to watch the saved frame pointer. */
780 release_value (value);
785 frame_register (struct frame_info *frame, int regnum,
786 int *optimizedp, enum lval_type *lvalp,
787 CORE_ADDR *addrp, int *realnump, gdb_byte *bufferp)
789 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
790 that the value proper does not need to be fetched. */
791 gdb_assert (optimizedp != NULL);
792 gdb_assert (lvalp != NULL);
793 gdb_assert (addrp != NULL);
794 gdb_assert (realnump != NULL);
795 /* gdb_assert (bufferp != NULL); */
797 /* Obtain the register value by unwinding the register from the next
798 (more inner frame). */
799 gdb_assert (frame != NULL && frame->next != NULL);
800 frame_register_unwind (frame->next, regnum, optimizedp, lvalp, addrp,
805 frame_unwind_register (struct frame_info *frame, int regnum, gdb_byte *buf)
812 frame_register_unwind (frame, regnum, &optimized, &lval, &addr,
817 get_frame_register (struct frame_info *frame,
818 int regnum, gdb_byte *buf)
820 frame_unwind_register (frame->next, regnum, buf);
824 frame_unwind_register_value (struct frame_info *frame, int regnum)
826 struct gdbarch *gdbarch;
829 gdb_assert (frame != NULL);
830 gdbarch = frame_unwind_arch (frame);
834 fprintf_unfiltered (gdb_stdlog, "\
835 { frame_unwind_register_value (frame=%d,regnum=%d(%s),...) ",
836 frame->level, regnum,
837 user_reg_map_regnum_to_name (gdbarch, regnum));
840 /* Find the unwinder. */
841 if (frame->unwind == NULL)
842 frame_unwind_find_by_frame (frame, &frame->prologue_cache);
844 /* Ask this frame to unwind its register. */
845 value = frame->unwind->prev_register (frame, &frame->prologue_cache, regnum);
849 fprintf_unfiltered (gdb_stdlog, "->");
850 if (value_optimized_out (value))
851 fprintf_unfiltered (gdb_stdlog, " optimized out");
854 if (VALUE_LVAL (value) == lval_register)
855 fprintf_unfiltered (gdb_stdlog, " register=%d",
856 VALUE_REGNUM (value));
857 else if (VALUE_LVAL (value) == lval_memory)
858 fprintf_unfiltered (gdb_stdlog, " address=%s",
860 value_address (value)));
862 fprintf_unfiltered (gdb_stdlog, " computed");
864 if (value_lazy (value))
865 fprintf_unfiltered (gdb_stdlog, " lazy");
869 const gdb_byte *buf = value_contents (value);
871 fprintf_unfiltered (gdb_stdlog, " bytes=");
872 fprintf_unfiltered (gdb_stdlog, "[");
873 for (i = 0; i < register_size (gdbarch, regnum); i++)
874 fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
875 fprintf_unfiltered (gdb_stdlog, "]");
879 fprintf_unfiltered (gdb_stdlog, " }\n");
886 get_frame_register_value (struct frame_info *frame, int regnum)
888 return frame_unwind_register_value (frame->next, regnum);
892 frame_unwind_register_signed (struct frame_info *frame, int regnum)
894 struct gdbarch *gdbarch = frame_unwind_arch (frame);
895 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
896 int size = register_size (gdbarch, regnum);
897 gdb_byte buf[MAX_REGISTER_SIZE];
899 frame_unwind_register (frame, regnum, buf);
900 return extract_signed_integer (buf, size, byte_order);
904 get_frame_register_signed (struct frame_info *frame, int regnum)
906 return frame_unwind_register_signed (frame->next, regnum);
910 frame_unwind_register_unsigned (struct frame_info *frame, int regnum)
912 struct gdbarch *gdbarch = frame_unwind_arch (frame);
913 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
914 int size = register_size (gdbarch, regnum);
915 gdb_byte buf[MAX_REGISTER_SIZE];
917 frame_unwind_register (frame, regnum, buf);
918 return extract_unsigned_integer (buf, size, byte_order);
922 get_frame_register_unsigned (struct frame_info *frame, int regnum)
924 return frame_unwind_register_unsigned (frame->next, regnum);
928 put_frame_register (struct frame_info *frame, int regnum,
931 struct gdbarch *gdbarch = get_frame_arch (frame);
937 frame_register (frame, regnum, &optim, &lval, &addr, &realnum, NULL);
939 error (_("Attempt to assign to a value that was optimized out."));
944 /* FIXME: write_memory doesn't yet take constant buffers.
946 gdb_byte tmp[MAX_REGISTER_SIZE];
948 memcpy (tmp, buf, register_size (gdbarch, regnum));
949 write_memory (addr, tmp, register_size (gdbarch, regnum));
953 regcache_cooked_write (get_current_regcache (), realnum, buf);
956 error (_("Attempt to assign to an unmodifiable value."));
960 /* frame_register_read ()
962 Find and return the value of REGNUM for the specified stack frame.
963 The number of bytes copied is REGISTER_SIZE (REGNUM).
965 Returns 0 if the register value could not be found. */
968 frame_register_read (struct frame_info *frame, int regnum,
976 frame_register (frame, regnum, &optimized, &lval, &addr, &realnum, myaddr);
982 get_frame_register_bytes (struct frame_info *frame, int regnum,
983 CORE_ADDR offset, int len, gdb_byte *myaddr)
985 struct gdbarch *gdbarch = get_frame_arch (frame);
990 /* Skip registers wholly inside of OFFSET. */
991 while (offset >= register_size (gdbarch, regnum))
993 offset -= register_size (gdbarch, regnum);
997 /* Ensure that we will not read beyond the end of the register file.
998 This can only ever happen if the debug information is bad. */
1000 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1001 for (i = regnum; i < numregs; i++)
1003 int thissize = register_size (gdbarch, i);
1006 break; /* This register is not available on this architecture. */
1007 maxsize += thissize;
1011 warning (_("Bad debug information detected: "
1012 "Attempt to read %d bytes from registers."), len);
1016 /* Copy the data. */
1019 int curr_len = register_size (gdbarch, regnum) - offset;
1024 if (curr_len == register_size (gdbarch, regnum))
1026 if (!frame_register_read (frame, regnum, myaddr))
1031 gdb_byte buf[MAX_REGISTER_SIZE];
1033 if (!frame_register_read (frame, regnum, buf))
1035 memcpy (myaddr, buf + offset, curr_len);
1048 put_frame_register_bytes (struct frame_info *frame, int regnum,
1049 CORE_ADDR offset, int len, const gdb_byte *myaddr)
1051 struct gdbarch *gdbarch = get_frame_arch (frame);
1053 /* Skip registers wholly inside of OFFSET. */
1054 while (offset >= register_size (gdbarch, regnum))
1056 offset -= register_size (gdbarch, regnum);
1060 /* Copy the data. */
1063 int curr_len = register_size (gdbarch, regnum) - offset;
1068 if (curr_len == register_size (gdbarch, regnum))
1070 put_frame_register (frame, regnum, myaddr);
1074 gdb_byte buf[MAX_REGISTER_SIZE];
1076 frame_register_read (frame, regnum, buf);
1077 memcpy (buf + offset, myaddr, curr_len);
1078 put_frame_register (frame, regnum, buf);
1088 /* Create a sentinel frame. */
1090 static struct frame_info *
1091 create_sentinel_frame (struct program_space *pspace, struct regcache *regcache)
1093 struct frame_info *frame = FRAME_OBSTACK_ZALLOC (struct frame_info);
1096 frame->pspace = pspace;
1097 frame->aspace = get_regcache_aspace (regcache);
1098 /* Explicitly initialize the sentinel frame's cache. Provide it
1099 with the underlying regcache. In the future additional
1100 information, such as the frame's thread will be added. */
1101 frame->prologue_cache = sentinel_frame_cache (regcache);
1102 /* For the moment there is only one sentinel frame implementation. */
1103 frame->unwind = sentinel_frame_unwind;
1104 /* Link this frame back to itself. The frame is self referential
1105 (the unwound PC is the same as the pc), so make it so. */
1106 frame->next = frame;
1107 /* Make the sentinel frame's ID valid, but invalid. That way all
1108 comparisons with it should fail. */
1109 frame->this_id.p = 1;
1110 frame->this_id.value = null_frame_id;
1113 fprintf_unfiltered (gdb_stdlog, "{ create_sentinel_frame (...) -> ");
1114 fprint_frame (gdb_stdlog, frame);
1115 fprintf_unfiltered (gdb_stdlog, " }\n");
1120 /* Info about the innermost stack frame (contents of FP register) */
1122 static struct frame_info *current_frame;
1124 /* Cache for frame addresses already read by gdb. Valid only while
1125 inferior is stopped. Control variables for the frame cache should
1126 be local to this module. */
1128 static struct obstack frame_cache_obstack;
1131 frame_obstack_zalloc (unsigned long size)
1133 void *data = obstack_alloc (&frame_cache_obstack, size);
1135 memset (data, 0, size);
1139 /* Return the innermost (currently executing) stack frame. This is
1140 split into two functions. The function unwind_to_current_frame()
1141 is wrapped in catch exceptions so that, even when the unwind of the
1142 sentinel frame fails, the function still returns a stack frame. */
1145 unwind_to_current_frame (struct ui_out *ui_out, void *args)
1147 struct frame_info *frame = get_prev_frame (args);
1149 /* A sentinel frame can fail to unwind, e.g., because its PC value
1150 lands in somewhere like start. */
1153 current_frame = frame;
1158 get_current_frame (void)
1160 /* First check, and report, the lack of registers. Having GDB
1161 report "No stack!" or "No memory" when the target doesn't even
1162 have registers is very confusing. Besides, "printcmd.exp"
1163 explicitly checks that ``print $pc'' with no registers prints "No
1165 if (!target_has_registers)
1166 error (_("No registers."));
1167 if (!target_has_stack)
1168 error (_("No stack."));
1169 if (!target_has_memory)
1170 error (_("No memory."));
1171 /* Traceframes are effectively a substitute for the live inferior. */
1172 if (get_traceframe_number () < 0)
1174 if (ptid_equal (inferior_ptid, null_ptid))
1175 error (_("No selected thread."));
1176 if (is_exited (inferior_ptid))
1177 error (_("Invalid selected thread."));
1178 if (is_executing (inferior_ptid))
1179 error (_("Target is executing."));
1182 if (current_frame == NULL)
1184 struct frame_info *sentinel_frame =
1185 create_sentinel_frame (current_program_space, get_current_regcache ());
1186 if (catch_exceptions (uiout, unwind_to_current_frame, sentinel_frame,
1187 RETURN_MASK_ERROR) != 0)
1189 /* Oops! Fake a current frame? Is this useful? It has a PC
1190 of zero, for instance. */
1191 current_frame = sentinel_frame;
1194 return current_frame;
1197 /* The "selected" stack frame is used by default for local and arg
1198 access. May be zero, for no selected frame. */
1200 static struct frame_info *selected_frame;
1203 has_stack_frames (void)
1205 if (!target_has_registers || !target_has_stack || !target_has_memory)
1208 /* No current inferior, no frame. */
1209 if (ptid_equal (inferior_ptid, null_ptid))
1212 /* Don't try to read from a dead thread. */
1213 if (is_exited (inferior_ptid))
1216 /* ... or from a spinning thread. */
1217 if (is_executing (inferior_ptid))
1223 /* Return the selected frame. Always non-NULL (unless there isn't an
1224 inferior sufficient for creating a frame) in which case an error is
1228 get_selected_frame (const char *message)
1230 if (selected_frame == NULL)
1232 if (message != NULL && !has_stack_frames ())
1233 error (("%s"), message);
1234 /* Hey! Don't trust this. It should really be re-finding the
1235 last selected frame of the currently selected thread. This,
1236 though, is better than nothing. */
1237 select_frame (get_current_frame ());
1239 /* There is always a frame. */
1240 gdb_assert (selected_frame != NULL);
1241 return selected_frame;
1244 /* This is a variant of get_selected_frame() which can be called when
1245 the inferior does not have a frame; in that case it will return
1246 NULL instead of calling error(). */
1249 deprecated_safe_get_selected_frame (void)
1251 if (!has_stack_frames ())
1253 return get_selected_frame (NULL);
1256 /* Select frame FI (or NULL - to invalidate the current frame). */
1259 select_frame (struct frame_info *fi)
1263 selected_frame = fi;
1264 /* NOTE: cagney/2002-05-04: FI can be NULL. This occurs when the
1265 frame is being invalidated. */
1266 if (deprecated_selected_frame_level_changed_hook)
1267 deprecated_selected_frame_level_changed_hook (frame_relative_level (fi));
1269 /* FIXME: kseitz/2002-08-28: It would be nice to call
1270 selected_frame_level_changed_event() right here, but due to limitations
1271 in the current interfaces, we would end up flooding UIs with events
1272 because select_frame() is used extensively internally.
1274 Once we have frame-parameterized frame (and frame-related) commands,
1275 the event notification can be moved here, since this function will only
1276 be called when the user's selected frame is being changed. */
1278 /* Ensure that symbols for this frame are read in. Also, determine the
1279 source language of this frame, and switch to it if desired. */
1282 /* We retrieve the frame's symtab by using the frame PC. However
1283 we cannot use the frame PC as-is, because it usually points to
1284 the instruction following the "call", which is sometimes the
1285 first instruction of another function. So we rely on
1286 get_frame_address_in_block() which provides us with a PC which
1287 is guaranteed to be inside the frame's code block. */
1288 s = find_pc_symtab (get_frame_address_in_block (fi));
1290 && s->language != current_language->la_language
1291 && s->language != language_unknown
1292 && language_mode == language_mode_auto)
1294 set_language (s->language);
1299 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
1300 Always returns a non-NULL value. */
1303 create_new_frame (CORE_ADDR addr, CORE_ADDR pc)
1305 struct frame_info *fi;
1309 fprintf_unfiltered (gdb_stdlog,
1310 "{ create_new_frame (addr=%s, pc=%s) ",
1311 hex_string (addr), hex_string (pc));
1314 fi = FRAME_OBSTACK_ZALLOC (struct frame_info);
1316 fi->next = create_sentinel_frame (current_program_space, get_current_regcache ());
1318 /* Set/update this frame's cached PC value, found in the next frame.
1319 Do this before looking for this frame's unwinder. A sniffer is
1320 very likely to read this, and the corresponding unwinder is
1321 entitled to rely that the PC doesn't magically change. */
1322 fi->next->prev_pc.value = pc;
1323 fi->next->prev_pc.p = 1;
1325 /* We currently assume that frame chain's can't cross spaces. */
1326 fi->pspace = fi->next->pspace;
1327 fi->aspace = fi->next->aspace;
1329 /* Select/initialize both the unwind function and the frame's type
1331 frame_unwind_find_by_frame (fi, &fi->prologue_cache);
1334 fi->this_id.value = frame_id_build (addr, pc);
1338 fprintf_unfiltered (gdb_stdlog, "-> ");
1339 fprint_frame (gdb_stdlog, fi);
1340 fprintf_unfiltered (gdb_stdlog, " }\n");
1346 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
1347 innermost frame). Be careful to not fall off the bottom of the
1348 frame chain and onto the sentinel frame. */
1351 get_next_frame (struct frame_info *this_frame)
1353 if (this_frame->level > 0)
1354 return this_frame->next;
1359 /* Observer for the target_changed event. */
1362 frame_observer_target_changed (struct target_ops *target)
1364 reinit_frame_cache ();
1367 /* Flush the entire frame cache. */
1370 reinit_frame_cache (void)
1372 struct frame_info *fi;
1374 /* Tear down all frame caches. */
1375 for (fi = current_frame; fi != NULL; fi = fi->prev)
1377 if (fi->prologue_cache && fi->unwind->dealloc_cache)
1378 fi->unwind->dealloc_cache (fi, fi->prologue_cache);
1379 if (fi->base_cache && fi->base->unwind->dealloc_cache)
1380 fi->base->unwind->dealloc_cache (fi, fi->base_cache);
1383 /* Since we can't really be sure what the first object allocated was */
1384 obstack_free (&frame_cache_obstack, 0);
1385 obstack_init (&frame_cache_obstack);
1387 if (current_frame != NULL)
1388 annotate_frames_invalid ();
1390 current_frame = NULL; /* Invalidate cache */
1391 select_frame (NULL);
1392 frame_stash_invalidate ();
1394 fprintf_unfiltered (gdb_stdlog, "{ reinit_frame_cache () }\n");
1397 /* Find where a register is saved (in memory or another register).
1398 The result of frame_register_unwind is just where it is saved
1399 relative to this particular frame. */
1402 frame_register_unwind_location (struct frame_info *this_frame, int regnum,
1403 int *optimizedp, enum lval_type *lvalp,
1404 CORE_ADDR *addrp, int *realnump)
1406 gdb_assert (this_frame == NULL || this_frame->level >= 0);
1408 while (this_frame != NULL)
1410 frame_register_unwind (this_frame, regnum, optimizedp, lvalp,
1411 addrp, realnump, NULL);
1416 if (*lvalp != lval_register)
1420 this_frame = get_next_frame (this_frame);
1424 /* Return a "struct frame_info" corresponding to the frame that called
1425 THIS_FRAME. Returns NULL if there is no such frame.
1427 Unlike get_prev_frame, this function always tries to unwind the
1430 static struct frame_info *
1431 get_prev_frame_1 (struct frame_info *this_frame)
1433 struct frame_id this_id;
1434 struct gdbarch *gdbarch;
1436 gdb_assert (this_frame != NULL);
1437 gdbarch = get_frame_arch (this_frame);
1441 fprintf_unfiltered (gdb_stdlog, "{ get_prev_frame_1 (this_frame=");
1442 if (this_frame != NULL)
1443 fprintf_unfiltered (gdb_stdlog, "%d", this_frame->level);
1445 fprintf_unfiltered (gdb_stdlog, "<NULL>");
1446 fprintf_unfiltered (gdb_stdlog, ") ");
1449 /* Only try to do the unwind once. */
1450 if (this_frame->prev_p)
1454 fprintf_unfiltered (gdb_stdlog, "-> ");
1455 fprint_frame (gdb_stdlog, this_frame->prev);
1456 fprintf_unfiltered (gdb_stdlog, " // cached \n");
1458 return this_frame->prev;
1461 /* If the frame unwinder hasn't been selected yet, we must do so
1462 before setting prev_p; otherwise the check for misbehaved
1463 sniffers will think that this frame's sniffer tried to unwind
1464 further (see frame_cleanup_after_sniffer). */
1465 if (this_frame->unwind == NULL)
1466 frame_unwind_find_by_frame (this_frame, &this_frame->prologue_cache);
1468 this_frame->prev_p = 1;
1469 this_frame->stop_reason = UNWIND_NO_REASON;
1471 /* If we are unwinding from an inline frame, all of the below tests
1472 were already performed when we unwound from the next non-inline
1473 frame. We must skip them, since we can not get THIS_FRAME's ID
1474 until we have unwound all the way down to the previous non-inline
1476 if (get_frame_type (this_frame) == INLINE_FRAME)
1477 return get_prev_frame_raw (this_frame);
1479 /* Check that this frame's ID was valid. If it wasn't, don't try to
1480 unwind to the prev frame. Be careful to not apply this test to
1481 the sentinel frame. */
1482 this_id = get_frame_id (this_frame);
1483 if (this_frame->level >= 0 && frame_id_eq (this_id, outer_frame_id))
1487 fprintf_unfiltered (gdb_stdlog, "-> ");
1488 fprint_frame (gdb_stdlog, NULL);
1489 fprintf_unfiltered (gdb_stdlog, " // this ID is NULL }\n");
1491 this_frame->stop_reason = UNWIND_NULL_ID;
1495 /* Check that this frame's ID isn't inner to (younger, below, next)
1496 the next frame. This happens when a frame unwind goes backwards.
1497 This check is valid only if this frame and the next frame are NORMAL.
1498 See the comment at frame_id_inner for details. */
1499 if (get_frame_type (this_frame) == NORMAL_FRAME
1500 && this_frame->next->unwind->type == NORMAL_FRAME
1501 && frame_id_inner (get_frame_arch (this_frame->next), this_id,
1502 get_frame_id (this_frame->next)))
1506 fprintf_unfiltered (gdb_stdlog, "-> ");
1507 fprint_frame (gdb_stdlog, NULL);
1508 fprintf_unfiltered (gdb_stdlog, " // this frame ID is inner }\n");
1510 this_frame->stop_reason = UNWIND_INNER_ID;
1514 /* Check that this and the next frame are not identical. If they
1515 are, there is most likely a stack cycle. As with the inner-than
1516 test above, avoid comparing the inner-most and sentinel frames. */
1517 if (this_frame->level > 0
1518 && frame_id_eq (this_id, get_frame_id (this_frame->next)))
1522 fprintf_unfiltered (gdb_stdlog, "-> ");
1523 fprint_frame (gdb_stdlog, NULL);
1524 fprintf_unfiltered (gdb_stdlog, " // this frame has same ID }\n");
1526 this_frame->stop_reason = UNWIND_SAME_ID;
1530 /* Check that this and the next frame do not unwind the PC register
1531 to the same memory location. If they do, then even though they
1532 have different frame IDs, the new frame will be bogus; two
1533 functions can't share a register save slot for the PC. This can
1534 happen when the prologue analyzer finds a stack adjustment, but
1537 This check does assume that the "PC register" is roughly a
1538 traditional PC, even if the gdbarch_unwind_pc method adjusts
1539 it (we do not rely on the value, only on the unwound PC being
1540 dependent on this value). A potential improvement would be
1541 to have the frame prev_pc method and the gdbarch unwind_pc
1542 method set the same lval and location information as
1543 frame_register_unwind. */
1544 if (this_frame->level > 0
1545 && gdbarch_pc_regnum (gdbarch) >= 0
1546 && get_frame_type (this_frame) == NORMAL_FRAME
1547 && (get_frame_type (this_frame->next) == NORMAL_FRAME
1548 || get_frame_type (this_frame->next) == INLINE_FRAME))
1550 int optimized, realnum, nrealnum;
1551 enum lval_type lval, nlval;
1552 CORE_ADDR addr, naddr;
1554 frame_register_unwind_location (this_frame,
1555 gdbarch_pc_regnum (gdbarch),
1556 &optimized, &lval, &addr, &realnum);
1557 frame_register_unwind_location (get_next_frame (this_frame),
1558 gdbarch_pc_regnum (gdbarch),
1559 &optimized, &nlval, &naddr, &nrealnum);
1561 if ((lval == lval_memory && lval == nlval && addr == naddr)
1562 || (lval == lval_register && lval == nlval && realnum == nrealnum))
1566 fprintf_unfiltered (gdb_stdlog, "-> ");
1567 fprint_frame (gdb_stdlog, NULL);
1568 fprintf_unfiltered (gdb_stdlog, " // no saved PC }\n");
1571 this_frame->stop_reason = UNWIND_NO_SAVED_PC;
1572 this_frame->prev = NULL;
1577 return get_prev_frame_raw (this_frame);
1580 /* Construct a new "struct frame_info" and link it previous to
1583 static struct frame_info *
1584 get_prev_frame_raw (struct frame_info *this_frame)
1586 struct frame_info *prev_frame;
1588 /* Allocate the new frame but do not wire it in to the frame chain.
1589 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
1590 frame->next to pull some fancy tricks (of course such code is, by
1591 definition, recursive). Try to prevent it.
1593 There is no reason to worry about memory leaks, should the
1594 remainder of the function fail. The allocated memory will be
1595 quickly reclaimed when the frame cache is flushed, and the `we've
1596 been here before' check above will stop repeated memory
1597 allocation calls. */
1598 prev_frame = FRAME_OBSTACK_ZALLOC (struct frame_info);
1599 prev_frame->level = this_frame->level + 1;
1601 /* For now, assume we don't have frame chains crossing address
1603 prev_frame->pspace = this_frame->pspace;
1604 prev_frame->aspace = this_frame->aspace;
1606 /* Don't yet compute ->unwind (and hence ->type). It is computed
1607 on-demand in get_frame_type, frame_register_unwind, and
1610 /* Don't yet compute the frame's ID. It is computed on-demand by
1613 /* The unwound frame ID is validate at the start of this function,
1614 as part of the logic to decide if that frame should be further
1615 unwound, and not here while the prev frame is being created.
1616 Doing this makes it possible for the user to examine a frame that
1617 has an invalid frame ID.
1619 Some very old VAX code noted: [...] For the sake of argument,
1620 suppose that the stack is somewhat trashed (which is one reason
1621 that "info frame" exists). So, return 0 (indicating we don't
1622 know the address of the arglist) if we don't know what frame this
1626 this_frame->prev = prev_frame;
1627 prev_frame->next = this_frame;
1631 fprintf_unfiltered (gdb_stdlog, "-> ");
1632 fprint_frame (gdb_stdlog, prev_frame);
1633 fprintf_unfiltered (gdb_stdlog, " }\n");
1639 /* Debug routine to print a NULL frame being returned. */
1642 frame_debug_got_null_frame (struct frame_info *this_frame,
1647 fprintf_unfiltered (gdb_stdlog, "{ get_prev_frame (this_frame=");
1648 if (this_frame != NULL)
1649 fprintf_unfiltered (gdb_stdlog, "%d", this_frame->level);
1651 fprintf_unfiltered (gdb_stdlog, "<NULL>");
1652 fprintf_unfiltered (gdb_stdlog, ") -> // %s}\n", reason);
1656 /* Is this (non-sentinel) frame in the "main"() function? */
1659 inside_main_func (struct frame_info *this_frame)
1661 struct minimal_symbol *msymbol;
1664 if (symfile_objfile == 0)
1666 msymbol = lookup_minimal_symbol (main_name (), NULL, symfile_objfile);
1667 if (msymbol == NULL)
1669 /* Make certain that the code, and not descriptor, address is
1671 maddr = gdbarch_convert_from_func_ptr_addr (get_frame_arch (this_frame),
1672 SYMBOL_VALUE_ADDRESS (msymbol),
1674 return maddr == get_frame_func (this_frame);
1677 /* Test whether THIS_FRAME is inside the process entry point function. */
1680 inside_entry_func (struct frame_info *this_frame)
1682 CORE_ADDR entry_point;
1684 if (!entry_point_address_query (&entry_point))
1687 return get_frame_func (this_frame) == entry_point;
1690 /* Return a structure containing various interesting information about
1691 the frame that called THIS_FRAME. Returns NULL if there is entier
1692 no such frame or the frame fails any of a set of target-independent
1693 condition that should terminate the frame chain (e.g., as unwinding
1696 This function should not contain target-dependent tests, such as
1697 checking whether the program-counter is zero. */
1700 get_prev_frame (struct frame_info *this_frame)
1702 /* There is always a frame. If this assertion fails, suspect that
1703 something should be calling get_selected_frame() or
1704 get_current_frame(). */
1705 gdb_assert (this_frame != NULL);
1707 /* tausq/2004-12-07: Dummy frames are skipped because it doesn't make much
1708 sense to stop unwinding at a dummy frame. One place where a dummy
1709 frame may have an address "inside_main_func" is on HPUX. On HPUX, the
1710 pcsqh register (space register for the instruction at the head of the
1711 instruction queue) cannot be written directly; the only way to set it
1712 is to branch to code that is in the target space. In order to implement
1713 frame dummies on HPUX, the called function is made to jump back to where
1714 the inferior was when the user function was called. If gdb was inside
1715 the main function when we created the dummy frame, the dummy frame will
1716 point inside the main function. */
1717 if (this_frame->level >= 0
1718 && get_frame_type (this_frame) == NORMAL_FRAME
1719 && !backtrace_past_main
1720 && inside_main_func (this_frame))
1721 /* Don't unwind past main(). Note, this is done _before_ the
1722 frame has been marked as previously unwound. That way if the
1723 user later decides to enable unwinds past main(), that will
1724 automatically happen. */
1726 frame_debug_got_null_frame (this_frame, "inside main func");
1730 /* If the user's backtrace limit has been exceeded, stop. We must
1731 add two to the current level; one of those accounts for backtrace_limit
1732 being 1-based and the level being 0-based, and the other accounts for
1733 the level of the new frame instead of the level of the current
1735 if (this_frame->level + 2 > backtrace_limit)
1737 frame_debug_got_null_frame (this_frame, "backtrace limit exceeded");
1741 /* If we're already inside the entry function for the main objfile,
1742 then it isn't valid. Don't apply this test to a dummy frame -
1743 dummy frame PCs typically land in the entry func. Don't apply
1744 this test to the sentinel frame. Sentinel frames should always
1745 be allowed to unwind. */
1746 /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() -
1747 wasn't checking for "main" in the minimal symbols. With that
1748 fixed asm-source tests now stop in "main" instead of halting the
1749 backtrace in weird and wonderful ways somewhere inside the entry
1750 file. Suspect that tests for inside the entry file/func were
1751 added to work around that (now fixed) case. */
1752 /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
1753 suggested having the inside_entry_func test use the
1754 inside_main_func() msymbol trick (along with entry_point_address()
1755 I guess) to determine the address range of the start function.
1756 That should provide a far better stopper than the current
1758 /* NOTE: tausq/2004-10-09: this is needed if, for example, the compiler
1759 applied tail-call optimizations to main so that a function called
1760 from main returns directly to the caller of main. Since we don't
1761 stop at main, we should at least stop at the entry point of the
1763 if (this_frame->level >= 0
1764 && get_frame_type (this_frame) == NORMAL_FRAME
1765 && !backtrace_past_entry
1766 && inside_entry_func (this_frame))
1768 frame_debug_got_null_frame (this_frame, "inside entry func");
1772 /* Assume that the only way to get a zero PC is through something
1773 like a SIGSEGV or a dummy frame, and hence that NORMAL frames
1774 will never unwind a zero PC. */
1775 if (this_frame->level > 0
1776 && (get_frame_type (this_frame) == NORMAL_FRAME
1777 || get_frame_type (this_frame) == INLINE_FRAME)
1778 && get_frame_type (get_next_frame (this_frame)) == NORMAL_FRAME
1779 && get_frame_pc (this_frame) == 0)
1781 frame_debug_got_null_frame (this_frame, "zero PC");
1785 return get_prev_frame_1 (this_frame);
1789 get_frame_pc (struct frame_info *frame)
1791 gdb_assert (frame->next != NULL);
1792 return frame_unwind_pc (frame->next);
1795 /* Return an address that falls within THIS_FRAME's code block. */
1798 get_frame_address_in_block (struct frame_info *this_frame)
1800 /* A draft address. */
1801 CORE_ADDR pc = get_frame_pc (this_frame);
1803 struct frame_info *next_frame = this_frame->next;
1805 /* Calling get_frame_pc returns the resume address for THIS_FRAME.
1806 Normally the resume address is inside the body of the function
1807 associated with THIS_FRAME, but there is a special case: when
1808 calling a function which the compiler knows will never return
1809 (for instance abort), the call may be the very last instruction
1810 in the calling function. The resume address will point after the
1811 call and may be at the beginning of a different function
1814 If THIS_FRAME is a signal frame or dummy frame, then we should
1815 not adjust the unwound PC. For a dummy frame, GDB pushed the
1816 resume address manually onto the stack. For a signal frame, the
1817 OS may have pushed the resume address manually and invoked the
1818 handler (e.g. GNU/Linux), or invoked the trampoline which called
1819 the signal handler - but in either case the signal handler is
1820 expected to return to the trampoline. So in both of these
1821 cases we know that the resume address is executable and
1822 related. So we only need to adjust the PC if THIS_FRAME
1823 is a normal function.
1825 If the program has been interrupted while THIS_FRAME is current,
1826 then clearly the resume address is inside the associated
1827 function. There are three kinds of interruption: debugger stop
1828 (next frame will be SENTINEL_FRAME), operating system
1829 signal or exception (next frame will be SIGTRAMP_FRAME),
1830 or debugger-induced function call (next frame will be
1831 DUMMY_FRAME). So we only need to adjust the PC if
1832 NEXT_FRAME is a normal function.
1834 We check the type of NEXT_FRAME first, since it is already
1835 known; frame type is determined by the unwinder, and since
1836 we have THIS_FRAME we've already selected an unwinder for
1839 If the next frame is inlined, we need to keep going until we find
1840 the real function - for instance, if a signal handler is invoked
1841 while in an inlined function, then the code address of the
1842 "calling" normal function should not be adjusted either. */
1844 while (get_frame_type (next_frame) == INLINE_FRAME)
1845 next_frame = next_frame->next;
1847 if (get_frame_type (next_frame) == NORMAL_FRAME
1848 && (get_frame_type (this_frame) == NORMAL_FRAME
1849 || get_frame_type (this_frame) == INLINE_FRAME))
1856 find_frame_sal (struct frame_info *frame, struct symtab_and_line *sal)
1858 struct frame_info *next_frame;
1861 /* If the next frame represents an inlined function call, this frame's
1862 sal is the "call site" of that inlined function, which can not
1863 be inferred from get_frame_pc. */
1864 next_frame = get_next_frame (frame);
1865 if (frame_inlined_callees (frame) > 0)
1870 sym = get_frame_function (next_frame);
1872 sym = inline_skipped_symbol (inferior_ptid);
1875 if (SYMBOL_LINE (sym) != 0)
1877 sal->symtab = SYMBOL_SYMTAB (sym);
1878 sal->line = SYMBOL_LINE (sym);
1881 /* If the symbol does not have a location, we don't know where
1882 the call site is. Do not pretend to. This is jarring, but
1883 we can't do much better. */
1884 sal->pc = get_frame_pc (frame);
1889 /* If FRAME is not the innermost frame, that normally means that
1890 FRAME->pc points at the return instruction (which is *after* the
1891 call instruction), and we want to get the line containing the
1892 call (because the call is where the user thinks the program is).
1893 However, if the next frame is either a SIGTRAMP_FRAME or a
1894 DUMMY_FRAME, then the next frame will contain a saved interrupt
1895 PC and such a PC indicates the current (rather than next)
1896 instruction/line, consequently, for such cases, want to get the
1897 line containing fi->pc. */
1898 notcurrent = (get_frame_pc (frame) != get_frame_address_in_block (frame));
1899 (*sal) = find_pc_line (get_frame_pc (frame), notcurrent);
1902 /* Per "frame.h", return the ``address'' of the frame. Code should
1903 really be using get_frame_id(). */
1905 get_frame_base (struct frame_info *fi)
1907 return get_frame_id (fi).stack_addr;
1910 /* High-level offsets into the frame. Used by the debug info. */
1913 get_frame_base_address (struct frame_info *fi)
1915 if (get_frame_type (fi) != NORMAL_FRAME)
1917 if (fi->base == NULL)
1918 fi->base = frame_base_find_by_frame (fi);
1919 /* Sneaky: If the low-level unwind and high-level base code share a
1920 common unwinder, let them share the prologue cache. */
1921 if (fi->base->unwind == fi->unwind)
1922 return fi->base->this_base (fi, &fi->prologue_cache);
1923 return fi->base->this_base (fi, &fi->base_cache);
1927 get_frame_locals_address (struct frame_info *fi)
1929 if (get_frame_type (fi) != NORMAL_FRAME)
1931 /* If there isn't a frame address method, find it. */
1932 if (fi->base == NULL)
1933 fi->base = frame_base_find_by_frame (fi);
1934 /* Sneaky: If the low-level unwind and high-level base code share a
1935 common unwinder, let them share the prologue cache. */
1936 if (fi->base->unwind == fi->unwind)
1937 return fi->base->this_locals (fi, &fi->prologue_cache);
1938 return fi->base->this_locals (fi, &fi->base_cache);
1942 get_frame_args_address (struct frame_info *fi)
1944 if (get_frame_type (fi) != NORMAL_FRAME)
1946 /* If there isn't a frame address method, find it. */
1947 if (fi->base == NULL)
1948 fi->base = frame_base_find_by_frame (fi);
1949 /* Sneaky: If the low-level unwind and high-level base code share a
1950 common unwinder, let them share the prologue cache. */
1951 if (fi->base->unwind == fi->unwind)
1952 return fi->base->this_args (fi, &fi->prologue_cache);
1953 return fi->base->this_args (fi, &fi->base_cache);
1956 /* Return true if the frame unwinder for frame FI is UNWINDER; false
1960 frame_unwinder_is (struct frame_info *fi, const struct frame_unwind *unwinder)
1962 if (fi->unwind == NULL)
1963 frame_unwind_find_by_frame (fi, &fi->prologue_cache);
1964 return fi->unwind == unwinder;
1967 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
1968 or -1 for a NULL frame. */
1971 frame_relative_level (struct frame_info *fi)
1980 get_frame_type (struct frame_info *frame)
1982 if (frame->unwind == NULL)
1983 /* Initialize the frame's unwinder because that's what
1984 provides the frame's type. */
1985 frame_unwind_find_by_frame (frame, &frame->prologue_cache);
1986 return frame->unwind->type;
1989 struct program_space *
1990 get_frame_program_space (struct frame_info *frame)
1992 return frame->pspace;
1995 struct program_space *
1996 frame_unwind_program_space (struct frame_info *this_frame)
1998 gdb_assert (this_frame);
2000 /* This is really a placeholder to keep the API consistent --- we
2001 assume for now that we don't have frame chains crossing
2003 return this_frame->pspace;
2006 struct address_space *
2007 get_frame_address_space (struct frame_info *frame)
2009 return frame->aspace;
2012 /* Memory access methods. */
2015 get_frame_memory (struct frame_info *this_frame, CORE_ADDR addr,
2016 gdb_byte *buf, int len)
2018 read_memory (addr, buf, len);
2022 get_frame_memory_signed (struct frame_info *this_frame, CORE_ADDR addr,
2025 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2026 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2028 return read_memory_integer (addr, len, byte_order);
2032 get_frame_memory_unsigned (struct frame_info *this_frame, CORE_ADDR addr,
2035 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2036 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2038 return read_memory_unsigned_integer (addr, len, byte_order);
2042 safe_frame_unwind_memory (struct frame_info *this_frame,
2043 CORE_ADDR addr, gdb_byte *buf, int len)
2045 /* NOTE: target_read_memory returns zero on success! */
2046 return !target_read_memory (addr, buf, len);
2049 /* Architecture methods. */
2052 get_frame_arch (struct frame_info *this_frame)
2054 return frame_unwind_arch (this_frame->next);
2058 frame_unwind_arch (struct frame_info *next_frame)
2060 if (!next_frame->prev_arch.p)
2062 struct gdbarch *arch;
2064 if (next_frame->unwind == NULL)
2065 frame_unwind_find_by_frame (next_frame, &next_frame->prologue_cache);
2067 if (next_frame->unwind->prev_arch != NULL)
2068 arch = next_frame->unwind->prev_arch (next_frame,
2069 &next_frame->prologue_cache);
2071 arch = get_frame_arch (next_frame);
2073 next_frame->prev_arch.arch = arch;
2074 next_frame->prev_arch.p = 1;
2076 fprintf_unfiltered (gdb_stdlog,
2077 "{ frame_unwind_arch (next_frame=%d) -> %s }\n",
2079 gdbarch_bfd_arch_info (arch)->printable_name);
2082 return next_frame->prev_arch.arch;
2086 frame_unwind_caller_arch (struct frame_info *next_frame)
2088 return frame_unwind_arch (skip_inlined_frames (next_frame));
2091 /* Stack pointer methods. */
2094 get_frame_sp (struct frame_info *this_frame)
2096 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2098 /* Normality - an architecture that provides a way of obtaining any
2099 frame inner-most address. */
2100 if (gdbarch_unwind_sp_p (gdbarch))
2101 /* NOTE drow/2008-06-28: gdbarch_unwind_sp could be converted to
2102 operate on THIS_FRAME now. */
2103 return gdbarch_unwind_sp (gdbarch, this_frame->next);
2104 /* Now things are really are grim. Hope that the value returned by
2105 the gdbarch_sp_regnum register is meaningful. */
2106 if (gdbarch_sp_regnum (gdbarch) >= 0)
2107 return get_frame_register_unsigned (this_frame,
2108 gdbarch_sp_regnum (gdbarch));
2109 internal_error (__FILE__, __LINE__, _("Missing unwind SP method"));
2112 /* Return the reason why we can't unwind past FRAME. */
2114 enum unwind_stop_reason
2115 get_frame_unwind_stop_reason (struct frame_info *frame)
2117 /* If we haven't tried to unwind past this point yet, then assume
2118 that unwinding would succeed. */
2119 if (frame->prev_p == 0)
2120 return UNWIND_NO_REASON;
2122 /* Otherwise, we set a reason when we succeeded (or failed) to
2124 return frame->stop_reason;
2127 /* Return a string explaining REASON. */
2130 frame_stop_reason_string (enum unwind_stop_reason reason)
2134 case UNWIND_NULL_ID:
2135 return _("unwinder did not report frame ID");
2137 case UNWIND_INNER_ID:
2138 return _("previous frame inner to this frame (corrupt stack?)");
2140 case UNWIND_SAME_ID:
2141 return _("previous frame identical to this frame (corrupt stack?)");
2143 case UNWIND_NO_SAVED_PC:
2144 return _("frame did not save the PC");
2146 case UNWIND_NO_REASON:
2147 case UNWIND_FIRST_ERROR:
2149 internal_error (__FILE__, __LINE__,
2150 "Invalid frame stop reason");
2154 /* Clean up after a failed (wrong unwinder) attempt to unwind past
2158 frame_cleanup_after_sniffer (void *arg)
2160 struct frame_info *frame = arg;
2162 /* The sniffer should not allocate a prologue cache if it did not
2163 match this frame. */
2164 gdb_assert (frame->prologue_cache == NULL);
2166 /* No sniffer should extend the frame chain; sniff based on what is
2168 gdb_assert (!frame->prev_p);
2170 /* The sniffer should not check the frame's ID; that's circular. */
2171 gdb_assert (!frame->this_id.p);
2173 /* Clear cached fields dependent on the unwinder.
2175 The previous PC is independent of the unwinder, but the previous
2176 function is not (see get_frame_address_in_block). */
2177 frame->prev_func.p = 0;
2178 frame->prev_func.addr = 0;
2180 /* Discard the unwinder last, so that we can easily find it if an assertion
2181 in this function triggers. */
2182 frame->unwind = NULL;
2185 /* Set FRAME's unwinder temporarily, so that we can call a sniffer.
2186 Return a cleanup which should be called if unwinding fails, and
2187 discarded if it succeeds. */
2190 frame_prepare_for_sniffer (struct frame_info *frame,
2191 const struct frame_unwind *unwind)
2193 gdb_assert (frame->unwind == NULL);
2194 frame->unwind = unwind;
2195 return make_cleanup (frame_cleanup_after_sniffer, frame);
2198 extern initialize_file_ftype _initialize_frame; /* -Wmissing-prototypes */
2200 static struct cmd_list_element *set_backtrace_cmdlist;
2201 static struct cmd_list_element *show_backtrace_cmdlist;
2204 set_backtrace_cmd (char *args, int from_tty)
2206 help_list (set_backtrace_cmdlist, "set backtrace ", -1, gdb_stdout);
2210 show_backtrace_cmd (char *args, int from_tty)
2212 cmd_show_list (show_backtrace_cmdlist, from_tty, "");
2216 _initialize_frame (void)
2218 obstack_init (&frame_cache_obstack);
2220 observer_attach_target_changed (frame_observer_target_changed);
2222 add_prefix_cmd ("backtrace", class_maintenance, set_backtrace_cmd, _("\
2223 Set backtrace specific variables.\n\
2224 Configure backtrace variables such as the backtrace limit"),
2225 &set_backtrace_cmdlist, "set backtrace ",
2226 0/*allow-unknown*/, &setlist);
2227 add_prefix_cmd ("backtrace", class_maintenance, show_backtrace_cmd, _("\
2228 Show backtrace specific variables\n\
2229 Show backtrace variables such as the backtrace limit"),
2230 &show_backtrace_cmdlist, "show backtrace ",
2231 0/*allow-unknown*/, &showlist);
2233 add_setshow_boolean_cmd ("past-main", class_obscure,
2234 &backtrace_past_main, _("\
2235 Set whether backtraces should continue past \"main\"."), _("\
2236 Show whether backtraces should continue past \"main\"."), _("\
2237 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
2238 the backtrace at \"main\". Set this variable if you need to see the rest\n\
2239 of the stack trace."),
2241 show_backtrace_past_main,
2242 &set_backtrace_cmdlist,
2243 &show_backtrace_cmdlist);
2245 add_setshow_boolean_cmd ("past-entry", class_obscure,
2246 &backtrace_past_entry, _("\
2247 Set whether backtraces should continue past the entry point of a program."),
2249 Show whether backtraces should continue past the entry point of a program."),
2251 Normally there are no callers beyond the entry point of a program, so GDB\n\
2252 will terminate the backtrace there. Set this variable if you need to see\n\
2253 the rest of the stack trace."),
2255 show_backtrace_past_entry,
2256 &set_backtrace_cmdlist,
2257 &show_backtrace_cmdlist);
2259 add_setshow_integer_cmd ("limit", class_obscure,
2260 &backtrace_limit, _("\
2261 Set an upper bound on the number of backtrace levels."), _("\
2262 Show the upper bound on the number of backtrace levels."), _("\
2263 No more than the specified number of frames can be displayed or examined.\n\
2264 Zero is unlimited."),
2266 show_backtrace_limit,
2267 &set_backtrace_cmdlist,
2268 &show_backtrace_cmdlist);
2270 /* Debug this files internals. */
2271 add_setshow_zinteger_cmd ("frame", class_maintenance, &frame_debug, _("\
2272 Set frame debugging."), _("\
2273 Show frame debugging."), _("\
2274 When non-zero, frame specific internal debugging is enabled."),
2277 &setdebuglist, &showdebuglist);