1 /* Cache and manage frames for GDB, the GNU debugger.
3 Copyright (C) 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000, 2001,
4 2002, 2003, 2004, 2007, 2008, 2009, 2010, 2011
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "inferior.h" /* for inferior_ptid */
28 #include "gdb_assert.h"
29 #include "gdb_string.h"
30 #include "user-regs.h"
31 #include "gdb_obstack.h"
32 #include "dummy-frame.h"
33 #include "sentinel-frame.h"
37 #include "frame-unwind.h"
38 #include "frame-base.h"
43 #include "exceptions.h"
44 #include "gdbthread.h"
46 #include "inline-frame.h"
47 #include "tracepoint.h"
49 static struct frame_info *get_prev_frame_1 (struct frame_info *this_frame);
50 static struct frame_info *get_prev_frame_raw (struct frame_info *this_frame);
52 /* We keep a cache of stack frames, each of which is a "struct
53 frame_info". The innermost one gets allocated (in
54 wait_for_inferior) each time the inferior stops; current_frame
55 points to it. Additional frames get allocated (in get_prev_frame)
56 as needed, and are chained through the next and prev fields. Any
57 time that the frame cache becomes invalid (most notably when we
58 execute something, but also if we change how we interpret the
59 frames (e.g. "set heuristic-fence-post" in mips-tdep.c, or anything
60 which reads new symbols)), we should call reinit_frame_cache. */
64 /* Level of this frame. The inner-most (youngest) frame is at level
65 0. As you move towards the outer-most (oldest) frame, the level
66 increases. This is a cached value. It could just as easily be
67 computed by counting back from the selected frame to the inner
69 /* NOTE: cagney/2002-04-05: Perhaps a level of ``-1'' should be
70 reserved to indicate a bogus frame - one that has been created
71 just to keep GDB happy (GDB always needs a frame). For the
72 moment leave this as speculation. */
75 /* The frame's program space. */
76 struct program_space *pspace;
78 /* The frame's address space. */
79 struct address_space *aspace;
81 /* The frame's low-level unwinder and corresponding cache. The
82 low-level unwinder is responsible for unwinding register values
83 for the previous frame. The low-level unwind methods are
84 selected based on the presence, or otherwise, of register unwind
85 information such as CFI. */
87 const struct frame_unwind *unwind;
89 /* Cached copy of the previous frame's architecture. */
96 /* Cached copy of the previous frame's resume address. */
102 /* Cached copy of the previous frame's function address. */
109 /* This frame's ID. */
113 struct frame_id value;
116 /* The frame's high-level base methods, and corresponding cache.
117 The high level base methods are selected based on the frame's
119 const struct frame_base *base;
122 /* Pointers to the next (down, inner, younger) and previous (up,
123 outer, older) frame_info's in the frame cache. */
124 struct frame_info *next; /* down, inner, younger */
126 struct frame_info *prev; /* up, outer, older */
128 /* The reason why we could not set PREV, or UNWIND_NO_REASON if we
129 could. Only valid when PREV_P is set. */
130 enum unwind_stop_reason stop_reason;
133 /* A frame stash used to speed up frame lookups. */
135 /* We currently only stash one frame at a time, as this seems to be
136 sufficient for now. */
137 static struct frame_info *frame_stash = NULL;
139 /* Add the following FRAME to the frame stash. */
142 frame_stash_add (struct frame_info *frame)
147 /* Search the frame stash for an entry with the given frame ID.
148 If found, return that frame. Otherwise return NULL. */
150 static struct frame_info *
151 frame_stash_find (struct frame_id id)
153 if (frame_stash && frame_id_eq (frame_stash->this_id.value, id))
159 /* Invalidate the frame stash by removing all entries in it. */
162 frame_stash_invalidate (void)
167 /* Flag to control debugging. */
171 show_frame_debug (struct ui_file *file, int from_tty,
172 struct cmd_list_element *c, const char *value)
174 fprintf_filtered (file, _("Frame debugging is %s.\n"), value);
177 /* Flag to indicate whether backtraces should stop at main et.al. */
179 static int backtrace_past_main;
181 show_backtrace_past_main (struct ui_file *file, int from_tty,
182 struct cmd_list_element *c, const char *value)
184 fprintf_filtered (file, _("\
185 Whether backtraces should 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, _("\
195 Whether backtraces should continue past the 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 of backtrace levels is %s.\n"),
211 fprint_field (struct ui_file *file, const char *name, int p, CORE_ADDR addr)
214 fprintf_unfiltered (file, "%s=%s", name, hex_string (addr));
216 fprintf_unfiltered (file, "!%s", name);
220 fprint_frame_id (struct ui_file *file, struct frame_id id)
222 fprintf_unfiltered (file, "{");
223 fprint_field (file, "stack", id.stack_addr_p, id.stack_addr);
224 fprintf_unfiltered (file, ",");
225 fprint_field (file, "code", id.code_addr_p, id.code_addr);
226 fprintf_unfiltered (file, ",");
227 fprint_field (file, "special", id.special_addr_p, id.special_addr);
229 fprintf_unfiltered (file, ",inlined=%d", id.inline_depth);
230 fprintf_unfiltered (file, "}");
234 fprint_frame_type (struct ui_file *file, enum frame_type type)
239 fprintf_unfiltered (file, "NORMAL_FRAME");
242 fprintf_unfiltered (file, "DUMMY_FRAME");
245 fprintf_unfiltered (file, "INLINE_FRAME");
248 fprintf_unfiltered (file, "SENTINEL_FRAME");
251 fprintf_unfiltered (file, "SIGTRAMP_FRAME");
254 fprintf_unfiltered (file, "ARCH_FRAME");
257 fprintf_unfiltered (file, "<unknown type>");
263 fprint_frame (struct ui_file *file, struct frame_info *fi)
267 fprintf_unfiltered (file, "<NULL frame>");
270 fprintf_unfiltered (file, "{");
271 fprintf_unfiltered (file, "level=%d", fi->level);
272 fprintf_unfiltered (file, ",");
273 fprintf_unfiltered (file, "type=");
274 if (fi->unwind != NULL)
275 fprint_frame_type (file, fi->unwind->type);
277 fprintf_unfiltered (file, "<unknown>");
278 fprintf_unfiltered (file, ",");
279 fprintf_unfiltered (file, "unwind=");
280 if (fi->unwind != NULL)
281 gdb_print_host_address (fi->unwind, file);
283 fprintf_unfiltered (file, "<unknown>");
284 fprintf_unfiltered (file, ",");
285 fprintf_unfiltered (file, "pc=");
286 if (fi->next != NULL && fi->next->prev_pc.p)
287 fprintf_unfiltered (file, "%s", hex_string (fi->next->prev_pc.value));
289 fprintf_unfiltered (file, "<unknown>");
290 fprintf_unfiltered (file, ",");
291 fprintf_unfiltered (file, "id=");
293 fprint_frame_id (file, fi->this_id.value);
295 fprintf_unfiltered (file, "<unknown>");
296 fprintf_unfiltered (file, ",");
297 fprintf_unfiltered (file, "func=");
298 if (fi->next != NULL && fi->next->prev_func.p)
299 fprintf_unfiltered (file, "%s", hex_string (fi->next->prev_func.addr));
301 fprintf_unfiltered (file, "<unknown>");
302 fprintf_unfiltered (file, "}");
305 /* Given FRAME, return the enclosing normal frame for inlined
306 function frames. Otherwise return the original frame. */
308 static struct frame_info *
309 skip_inlined_frames (struct frame_info *frame)
311 while (get_frame_type (frame) == INLINE_FRAME)
312 frame = get_prev_frame (frame);
317 /* Return a frame uniq ID that can be used to, later, re-find the
321 get_frame_id (struct frame_info *fi)
324 return null_frame_id;
329 fprintf_unfiltered (gdb_stdlog, "{ get_frame_id (fi=%d) ",
331 /* Find the unwinder. */
332 if (fi->unwind == NULL)
333 frame_unwind_find_by_frame (fi, &fi->prologue_cache);
334 /* Find THIS frame's ID. */
335 /* Default to outermost if no ID is found. */
336 fi->this_id.value = outer_frame_id;
337 fi->unwind->this_id (fi, &fi->prologue_cache, &fi->this_id.value);
338 gdb_assert (frame_id_p (fi->this_id.value));
342 fprintf_unfiltered (gdb_stdlog, "-> ");
343 fprint_frame_id (gdb_stdlog, fi->this_id.value);
344 fprintf_unfiltered (gdb_stdlog, " }\n");
348 frame_stash_add (fi);
350 return fi->this_id.value;
354 get_stack_frame_id (struct frame_info *next_frame)
356 return get_frame_id (skip_inlined_frames (next_frame));
360 frame_unwind_caller_id (struct frame_info *next_frame)
362 struct frame_info *this_frame;
364 /* Use get_prev_frame_1, and not get_prev_frame. The latter will truncate
365 the frame chain, leading to this function unintentionally
366 returning a null_frame_id (e.g., when a caller requests the frame
367 ID of "main()"s caller. */
369 next_frame = skip_inlined_frames (next_frame);
370 this_frame = get_prev_frame_1 (next_frame);
372 return get_frame_id (skip_inlined_frames (this_frame));
374 return null_frame_id;
377 const struct frame_id null_frame_id; /* All zeros. */
378 const struct frame_id outer_frame_id = { 0, 0, 0, 0, 0, 1, 0 };
381 frame_id_build_special (CORE_ADDR stack_addr, CORE_ADDR code_addr,
382 CORE_ADDR special_addr)
384 struct frame_id id = null_frame_id;
386 id.stack_addr = stack_addr;
388 id.code_addr = code_addr;
390 id.special_addr = special_addr;
391 id.special_addr_p = 1;
396 frame_id_build (CORE_ADDR stack_addr, CORE_ADDR code_addr)
398 struct frame_id id = null_frame_id;
400 id.stack_addr = stack_addr;
402 id.code_addr = code_addr;
408 frame_id_build_wild (CORE_ADDR stack_addr)
410 struct frame_id id = null_frame_id;
412 id.stack_addr = stack_addr;
418 frame_id_p (struct frame_id l)
422 /* The frame is valid iff it has a valid stack address. */
424 /* outer_frame_id is also valid. */
425 if (!p && memcmp (&l, &outer_frame_id, sizeof (l)) == 0)
429 fprintf_unfiltered (gdb_stdlog, "{ frame_id_p (l=");
430 fprint_frame_id (gdb_stdlog, l);
431 fprintf_unfiltered (gdb_stdlog, ") -> %d }\n", p);
437 frame_id_inlined_p (struct frame_id l)
442 return (l.inline_depth != 0);
446 frame_id_eq (struct frame_id l, struct frame_id r)
450 if (!l.stack_addr_p && l.special_addr_p && !r.stack_addr_p && r.special_addr_p)
451 /* The outermost frame marker is equal to itself. This is the
452 dodgy thing about outer_frame_id, since between execution steps
453 we might step into another function - from which we can't
454 unwind either. More thought required to get rid of
457 else if (!l.stack_addr_p || !r.stack_addr_p)
458 /* Like a NaN, if either ID is invalid, the result is false.
459 Note that a frame ID is invalid iff it is the null frame ID. */
461 else if (l.stack_addr != r.stack_addr)
462 /* If .stack addresses are different, the frames are different. */
464 else if (l.code_addr_p && r.code_addr_p && l.code_addr != r.code_addr)
465 /* An invalid code addr is a wild card. If .code addresses are
466 different, the frames are different. */
468 else if (l.special_addr_p && r.special_addr_p
469 && l.special_addr != r.special_addr)
470 /* An invalid special addr is a wild card (or unused). Otherwise
471 if special addresses are different, the frames are different. */
473 else if (l.inline_depth != r.inline_depth)
474 /* If inline depths are different, the frames must be different. */
477 /* Frames are equal. */
482 fprintf_unfiltered (gdb_stdlog, "{ frame_id_eq (l=");
483 fprint_frame_id (gdb_stdlog, l);
484 fprintf_unfiltered (gdb_stdlog, ",r=");
485 fprint_frame_id (gdb_stdlog, r);
486 fprintf_unfiltered (gdb_stdlog, ") -> %d }\n", eq);
491 /* Safety net to check whether frame ID L should be inner to
492 frame ID R, according to their stack addresses.
494 This method cannot be used to compare arbitrary frames, as the
495 ranges of valid stack addresses may be discontiguous (e.g. due
498 However, it can be used as safety net to discover invalid frame
499 IDs in certain circumstances. Assuming that NEXT is the immediate
500 inner frame to THIS and that NEXT and THIS are both NORMAL frames:
502 * The stack address of NEXT must be inner-than-or-equal to the stack
505 Therefore, if frame_id_inner (THIS, NEXT) holds, some unwind
508 * If NEXT and THIS have different stack addresses, no other frame
509 in the frame chain may have a stack address in between.
511 Therefore, if frame_id_inner (TEST, THIS) holds, but
512 frame_id_inner (TEST, NEXT) does not hold, TEST cannot refer
513 to a valid frame in the frame chain.
515 The sanity checks above cannot be performed when a SIGTRAMP frame
516 is involved, because signal handlers might be executed on a different
517 stack than the stack used by the routine that caused the signal
518 to be raised. This can happen for instance when a thread exceeds
519 its maximum stack size. In this case, certain compilers implement
520 a stack overflow strategy that cause the handler to be run on a
524 frame_id_inner (struct gdbarch *gdbarch, struct frame_id l, struct frame_id r)
528 if (!l.stack_addr_p || !r.stack_addr_p)
529 /* Like NaN, any operation involving an invalid ID always fails. */
531 else if (l.inline_depth > r.inline_depth
532 && l.stack_addr == r.stack_addr
533 && l.code_addr_p == r.code_addr_p
534 && l.special_addr_p == r.special_addr_p
535 && l.special_addr == r.special_addr)
537 /* Same function, different inlined functions. */
538 struct block *lb, *rb;
540 gdb_assert (l.code_addr_p && r.code_addr_p);
542 lb = block_for_pc (l.code_addr);
543 rb = block_for_pc (r.code_addr);
545 if (lb == NULL || rb == NULL)
546 /* Something's gone wrong. */
549 /* This will return true if LB and RB are the same block, or
550 if the block with the smaller depth lexically encloses the
551 block with the greater depth. */
552 inner = contained_in (lb, rb);
555 /* Only return non-zero when strictly inner than. Note that, per
556 comment in "frame.h", there is some fuzz here. Frameless
557 functions are not strictly inner than (same .stack but
558 different .code and/or .special address). */
559 inner = gdbarch_inner_than (gdbarch, l.stack_addr, r.stack_addr);
562 fprintf_unfiltered (gdb_stdlog, "{ frame_id_inner (l=");
563 fprint_frame_id (gdb_stdlog, l);
564 fprintf_unfiltered (gdb_stdlog, ",r=");
565 fprint_frame_id (gdb_stdlog, r);
566 fprintf_unfiltered (gdb_stdlog, ") -> %d }\n", inner);
572 frame_find_by_id (struct frame_id id)
574 struct frame_info *frame, *prev_frame;
576 /* ZERO denotes the null frame, let the caller decide what to do
577 about it. Should it instead return get_current_frame()? */
578 if (!frame_id_p (id))
581 /* Try using the frame stash first. Finding it there removes the need
582 to perform the search by looping over all frames, which can be very
583 CPU-intensive if the number of frames is very high (the loop is O(n)
584 and get_prev_frame performs a series of checks that are relatively
585 expensive). This optimization is particularly useful when this function
586 is called from another function (such as value_fetch_lazy, case
587 VALUE_LVAL (val) == lval_register) which already loops over all frames,
588 making the overall behavior O(n^2). */
589 frame = frame_stash_find (id);
593 for (frame = get_current_frame (); ; frame = prev_frame)
595 struct frame_id this = get_frame_id (frame);
597 if (frame_id_eq (id, this))
598 /* An exact match. */
601 prev_frame = get_prev_frame (frame);
605 /* As a safety net to avoid unnecessary backtracing while trying
606 to find an invalid ID, we check for a common situation where
607 we can detect from comparing stack addresses that no other
608 frame in the current frame chain can have this ID. See the
609 comment at frame_id_inner for details. */
610 if (get_frame_type (frame) == NORMAL_FRAME
611 && !frame_id_inner (get_frame_arch (frame), id, this)
612 && frame_id_inner (get_frame_arch (prev_frame), id,
613 get_frame_id (prev_frame)))
620 frame_unwind_pc (struct frame_info *this_frame)
622 if (!this_frame->prev_pc.p)
626 if (gdbarch_unwind_pc_p (frame_unwind_arch (this_frame)))
628 /* The right way. The `pure' way. The one true way. This
629 method depends solely on the register-unwind code to
630 determine the value of registers in THIS frame, and hence
631 the value of this frame's PC (resume address). A typical
632 implementation is no more than:
634 frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
635 return extract_unsigned_integer (buf, size of ISA_PC_REGNUM);
637 Note: this method is very heavily dependent on a correct
638 register-unwind implementation, it pays to fix that
639 method first; this method is frame type agnostic, since
640 it only deals with register values, it works with any
641 frame. This is all in stark contrast to the old
642 FRAME_SAVED_PC which would try to directly handle all the
643 different ways that a PC could be unwound. */
644 pc = gdbarch_unwind_pc (frame_unwind_arch (this_frame), this_frame);
647 internal_error (__FILE__, __LINE__, _("No unwind_pc method"));
648 this_frame->prev_pc.value = pc;
649 this_frame->prev_pc.p = 1;
651 fprintf_unfiltered (gdb_stdlog,
652 "{ frame_unwind_caller_pc (this_frame=%d) -> %s }\n",
654 hex_string (this_frame->prev_pc.value));
656 return this_frame->prev_pc.value;
660 frame_unwind_caller_pc (struct frame_info *this_frame)
662 return frame_unwind_pc (skip_inlined_frames (this_frame));
666 get_frame_func (struct frame_info *this_frame)
668 struct frame_info *next_frame = this_frame->next;
670 if (!next_frame->prev_func.p)
672 /* Make certain that this, and not the adjacent, function is
674 CORE_ADDR addr_in_block = get_frame_address_in_block (this_frame);
675 next_frame->prev_func.p = 1;
676 next_frame->prev_func.addr = get_pc_function_start (addr_in_block);
678 fprintf_unfiltered (gdb_stdlog,
679 "{ get_frame_func (this_frame=%d) -> %s }\n",
681 hex_string (next_frame->prev_func.addr));
683 return next_frame->prev_func.addr;
687 do_frame_register_read (void *src, int regnum, gdb_byte *buf)
689 return frame_register_read (src, regnum, buf);
693 frame_save_as_regcache (struct frame_info *this_frame)
695 struct address_space *aspace = get_frame_address_space (this_frame);
696 struct regcache *regcache = regcache_xmalloc (get_frame_arch (this_frame),
698 struct cleanup *cleanups = make_cleanup_regcache_xfree (regcache);
700 regcache_save (regcache, do_frame_register_read, this_frame);
701 discard_cleanups (cleanups);
706 frame_pop (struct frame_info *this_frame)
708 struct frame_info *prev_frame;
709 struct regcache *scratch;
710 struct cleanup *cleanups;
712 if (get_frame_type (this_frame) == DUMMY_FRAME)
714 /* Popping a dummy frame involves restoring more than just registers.
715 dummy_frame_pop does all the work. */
716 dummy_frame_pop (get_frame_id (this_frame));
720 /* Ensure that we have a frame to pop to. */
721 prev_frame = get_prev_frame_1 (this_frame);
724 error (_("Cannot pop the initial frame."));
726 /* Make a copy of all the register values unwound from this frame.
727 Save them in a scratch buffer so that there isn't a race between
728 trying to extract the old values from the current regcache while
729 at the same time writing new values into that same cache. */
730 scratch = frame_save_as_regcache (prev_frame);
731 cleanups = make_cleanup_regcache_xfree (scratch);
733 /* FIXME: cagney/2003-03-16: It should be possible to tell the
734 target's register cache that it is about to be hit with a burst
735 register transfer and that the sequence of register writes should
736 be batched. The pair target_prepare_to_store() and
737 target_store_registers() kind of suggest this functionality.
738 Unfortunately, they don't implement it. Their lack of a formal
739 definition can lead to targets writing back bogus values
740 (arguably a bug in the target code mind). */
741 /* Now copy those saved registers into the current regcache.
742 Here, regcache_cpy() calls regcache_restore(). */
743 regcache_cpy (get_current_regcache (), scratch);
744 do_cleanups (cleanups);
746 /* We've made right mess of GDB's local state, just discard
748 reinit_frame_cache ();
752 frame_register_unwind (struct frame_info *frame, int regnum,
753 int *optimizedp, enum lval_type *lvalp,
754 CORE_ADDR *addrp, int *realnump, gdb_byte *bufferp)
758 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
759 that the value proper does not need to be fetched. */
760 gdb_assert (optimizedp != NULL);
761 gdb_assert (lvalp != NULL);
762 gdb_assert (addrp != NULL);
763 gdb_assert (realnump != NULL);
764 /* gdb_assert (bufferp != NULL); */
766 value = frame_unwind_register_value (frame, regnum);
768 gdb_assert (value != NULL);
770 *optimizedp = value_optimized_out (value);
771 *lvalp = VALUE_LVAL (value);
772 *addrp = value_address (value);
773 *realnump = VALUE_REGNUM (value);
775 if (bufferp && !*optimizedp)
776 memcpy (bufferp, value_contents_all (value),
777 TYPE_LENGTH (value_type (value)));
779 /* Dispose of the new value. This prevents watchpoints from
780 trying to watch the saved frame pointer. */
781 release_value (value);
786 frame_register (struct frame_info *frame, int regnum,
787 int *optimizedp, enum lval_type *lvalp,
788 CORE_ADDR *addrp, int *realnump, gdb_byte *bufferp)
790 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
791 that the value proper does not need to be fetched. */
792 gdb_assert (optimizedp != NULL);
793 gdb_assert (lvalp != NULL);
794 gdb_assert (addrp != NULL);
795 gdb_assert (realnump != NULL);
796 /* gdb_assert (bufferp != NULL); */
798 /* Obtain the register value by unwinding the register from the next
799 (more inner frame). */
800 gdb_assert (frame != NULL && frame->next != NULL);
801 frame_register_unwind (frame->next, regnum, optimizedp, lvalp, addrp,
806 frame_unwind_register (struct frame_info *frame, int regnum, gdb_byte *buf)
813 frame_register_unwind (frame, regnum, &optimized, &lval, &addr,
818 get_frame_register (struct frame_info *frame,
819 int regnum, gdb_byte *buf)
821 frame_unwind_register (frame->next, regnum, buf);
825 frame_unwind_register_value (struct frame_info *frame, int regnum)
827 struct gdbarch *gdbarch;
830 gdb_assert (frame != NULL);
831 gdbarch = frame_unwind_arch (frame);
835 fprintf_unfiltered (gdb_stdlog, "\
836 { frame_unwind_register_value (frame=%d,regnum=%d(%s),...) ",
837 frame->level, regnum,
838 user_reg_map_regnum_to_name (gdbarch, regnum));
841 /* Find the unwinder. */
842 if (frame->unwind == NULL)
843 frame_unwind_find_by_frame (frame, &frame->prologue_cache);
845 /* Ask this frame to unwind its register. */
846 value = frame->unwind->prev_register (frame, &frame->prologue_cache, regnum);
850 fprintf_unfiltered (gdb_stdlog, "->");
851 if (value_optimized_out (value))
852 fprintf_unfiltered (gdb_stdlog, " optimized out");
855 if (VALUE_LVAL (value) == lval_register)
856 fprintf_unfiltered (gdb_stdlog, " register=%d",
857 VALUE_REGNUM (value));
858 else if (VALUE_LVAL (value) == lval_memory)
859 fprintf_unfiltered (gdb_stdlog, " address=%s",
861 value_address (value)));
863 fprintf_unfiltered (gdb_stdlog, " computed");
865 if (value_lazy (value))
866 fprintf_unfiltered (gdb_stdlog, " lazy");
870 const gdb_byte *buf = value_contents (value);
872 fprintf_unfiltered (gdb_stdlog, " bytes=");
873 fprintf_unfiltered (gdb_stdlog, "[");
874 for (i = 0; i < register_size (gdbarch, regnum); i++)
875 fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
876 fprintf_unfiltered (gdb_stdlog, "]");
880 fprintf_unfiltered (gdb_stdlog, " }\n");
887 get_frame_register_value (struct frame_info *frame, int regnum)
889 return frame_unwind_register_value (frame->next, regnum);
893 frame_unwind_register_signed (struct frame_info *frame, int regnum)
895 struct gdbarch *gdbarch = frame_unwind_arch (frame);
896 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
897 int size = register_size (gdbarch, regnum);
898 gdb_byte buf[MAX_REGISTER_SIZE];
900 frame_unwind_register (frame, regnum, buf);
901 return extract_signed_integer (buf, size, byte_order);
905 get_frame_register_signed (struct frame_info *frame, int regnum)
907 return frame_unwind_register_signed (frame->next, regnum);
911 frame_unwind_register_unsigned (struct frame_info *frame, int regnum)
913 struct gdbarch *gdbarch = frame_unwind_arch (frame);
914 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
915 int size = register_size (gdbarch, regnum);
916 gdb_byte buf[MAX_REGISTER_SIZE];
918 frame_unwind_register (frame, regnum, buf);
919 return extract_unsigned_integer (buf, size, byte_order);
923 get_frame_register_unsigned (struct frame_info *frame, int regnum)
925 return frame_unwind_register_unsigned (frame->next, regnum);
929 put_frame_register (struct frame_info *frame, int regnum,
932 struct gdbarch *gdbarch = get_frame_arch (frame);
938 frame_register (frame, regnum, &optim, &lval, &addr, &realnum, NULL);
940 error (_("Attempt to assign to a value that was optimized out."));
945 /* FIXME: write_memory doesn't yet take constant buffers.
947 gdb_byte tmp[MAX_REGISTER_SIZE];
949 memcpy (tmp, buf, register_size (gdbarch, regnum));
950 write_memory (addr, tmp, register_size (gdbarch, regnum));
954 regcache_cooked_write (get_current_regcache (), realnum, buf);
957 error (_("Attempt to assign to an unmodifiable value."));
961 /* frame_register_read ()
963 Find and return the value of REGNUM for the specified stack frame.
964 The number of bytes copied is REGISTER_SIZE (REGNUM).
966 Returns 0 if the register value could not be found. */
969 frame_register_read (struct frame_info *frame, int regnum,
977 frame_register (frame, regnum, &optimized, &lval, &addr, &realnum, myaddr);
983 get_frame_register_bytes (struct frame_info *frame, int regnum,
984 CORE_ADDR offset, int len, gdb_byte *myaddr)
986 struct gdbarch *gdbarch = get_frame_arch (frame);
991 /* Skip registers wholly inside of OFFSET. */
992 while (offset >= register_size (gdbarch, regnum))
994 offset -= register_size (gdbarch, regnum);
998 /* Ensure that we will not read beyond the end of the register file.
999 This can only ever happen if the debug information is bad. */
1001 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1002 for (i = regnum; i < numregs; i++)
1004 int thissize = register_size (gdbarch, i);
1007 break; /* This register is not available on this architecture. */
1008 maxsize += thissize;
1012 warning (_("Bad debug information detected: "
1013 "Attempt to read %d bytes from registers."), len);
1017 /* Copy the data. */
1020 int curr_len = register_size (gdbarch, regnum) - offset;
1025 if (curr_len == register_size (gdbarch, regnum))
1027 if (!frame_register_read (frame, regnum, myaddr))
1032 gdb_byte buf[MAX_REGISTER_SIZE];
1034 if (!frame_register_read (frame, regnum, buf))
1036 memcpy (myaddr, buf + offset, curr_len);
1049 put_frame_register_bytes (struct frame_info *frame, int regnum,
1050 CORE_ADDR offset, int len, const gdb_byte *myaddr)
1052 struct gdbarch *gdbarch = get_frame_arch (frame);
1054 /* Skip registers wholly inside of OFFSET. */
1055 while (offset >= register_size (gdbarch, regnum))
1057 offset -= register_size (gdbarch, regnum);
1061 /* Copy the data. */
1064 int curr_len = register_size (gdbarch, regnum) - offset;
1069 if (curr_len == register_size (gdbarch, regnum))
1071 put_frame_register (frame, regnum, myaddr);
1075 gdb_byte buf[MAX_REGISTER_SIZE];
1077 frame_register_read (frame, regnum, buf);
1078 memcpy (buf + offset, myaddr, curr_len);
1079 put_frame_register (frame, regnum, buf);
1089 /* Create a sentinel frame. */
1091 static struct frame_info *
1092 create_sentinel_frame (struct program_space *pspace, struct regcache *regcache)
1094 struct frame_info *frame = FRAME_OBSTACK_ZALLOC (struct frame_info);
1097 frame->pspace = pspace;
1098 frame->aspace = get_regcache_aspace (regcache);
1099 /* Explicitly initialize the sentinel frame's cache. Provide it
1100 with the underlying regcache. In the future additional
1101 information, such as the frame's thread will be added. */
1102 frame->prologue_cache = sentinel_frame_cache (regcache);
1103 /* For the moment there is only one sentinel frame implementation. */
1104 frame->unwind = &sentinel_frame_unwind;
1105 /* Link this frame back to itself. The frame is self referential
1106 (the unwound PC is the same as the pc), so make it so. */
1107 frame->next = frame;
1108 /* Make the sentinel frame's ID valid, but invalid. That way all
1109 comparisons with it should fail. */
1110 frame->this_id.p = 1;
1111 frame->this_id.value = null_frame_id;
1114 fprintf_unfiltered (gdb_stdlog, "{ create_sentinel_frame (...) -> ");
1115 fprint_frame (gdb_stdlog, frame);
1116 fprintf_unfiltered (gdb_stdlog, " }\n");
1121 /* Info about the innermost stack frame (contents of FP register) */
1123 static struct frame_info *current_frame;
1125 /* Cache for frame addresses already read by gdb. Valid only while
1126 inferior is stopped. Control variables for the frame cache should
1127 be local to this module. */
1129 static struct obstack frame_cache_obstack;
1132 frame_obstack_zalloc (unsigned long size)
1134 void *data = obstack_alloc (&frame_cache_obstack, size);
1136 memset (data, 0, size);
1140 /* Return the innermost (currently executing) stack frame. This is
1141 split into two functions. The function unwind_to_current_frame()
1142 is wrapped in catch exceptions so that, even when the unwind of the
1143 sentinel frame fails, the function still returns a stack frame. */
1146 unwind_to_current_frame (struct ui_out *ui_out, void *args)
1148 struct frame_info *frame = get_prev_frame (args);
1150 /* A sentinel frame can fail to unwind, e.g., because its PC value
1151 lands in somewhere like start. */
1154 current_frame = frame;
1159 get_current_frame (void)
1161 /* First check, and report, the lack of registers. Having GDB
1162 report "No stack!" or "No memory" when the target doesn't even
1163 have registers is very confusing. Besides, "printcmd.exp"
1164 explicitly checks that ``print $pc'' with no registers prints "No
1166 if (!target_has_registers)
1167 error (_("No registers."));
1168 if (!target_has_stack)
1169 error (_("No stack."));
1170 if (!target_has_memory)
1171 error (_("No memory."));
1172 /* Traceframes are effectively a substitute for the live inferior. */
1173 if (get_traceframe_number () < 0)
1175 if (ptid_equal (inferior_ptid, null_ptid))
1176 error (_("No selected thread."));
1177 if (is_exited (inferior_ptid))
1178 error (_("Invalid selected thread."));
1179 if (is_executing (inferior_ptid))
1180 error (_("Target is executing."));
1183 if (current_frame == NULL)
1185 struct frame_info *sentinel_frame =
1186 create_sentinel_frame (current_program_space, get_current_regcache ());
1187 if (catch_exceptions (uiout, unwind_to_current_frame, sentinel_frame,
1188 RETURN_MASK_ERROR) != 0)
1190 /* Oops! Fake a current frame? Is this useful? It has a PC
1191 of zero, for instance. */
1192 current_frame = sentinel_frame;
1195 return current_frame;
1198 /* The "selected" stack frame is used by default for local and arg
1199 access. May be zero, for no selected frame. */
1201 static struct frame_info *selected_frame;
1204 has_stack_frames (void)
1206 if (!target_has_registers || !target_has_stack || !target_has_memory)
1209 /* No current inferior, no frame. */
1210 if (ptid_equal (inferior_ptid, null_ptid))
1213 /* Don't try to read from a dead thread. */
1214 if (is_exited (inferior_ptid))
1217 /* ... or from a spinning thread. */
1218 if (is_executing (inferior_ptid))
1224 /* Return the selected frame. Always non-NULL (unless there isn't an
1225 inferior sufficient for creating a frame) in which case an error is
1229 get_selected_frame (const char *message)
1231 if (selected_frame == NULL)
1233 if (message != NULL && !has_stack_frames ())
1234 error (("%s"), message);
1235 /* Hey! Don't trust this. It should really be re-finding the
1236 last selected frame of the currently selected thread. This,
1237 though, is better than nothing. */
1238 select_frame (get_current_frame ());
1240 /* There is always a frame. */
1241 gdb_assert (selected_frame != NULL);
1242 return selected_frame;
1245 /* This is a variant of get_selected_frame() which can be called when
1246 the inferior does not have a frame; in that case it will return
1247 NULL instead of calling error(). */
1250 deprecated_safe_get_selected_frame (void)
1252 if (!has_stack_frames ())
1254 return get_selected_frame (NULL);
1257 /* Select frame FI (or NULL - to invalidate the current frame). */
1260 select_frame (struct frame_info *fi)
1264 selected_frame = fi;
1265 /* NOTE: cagney/2002-05-04: FI can be NULL. This occurs when the
1266 frame is being invalidated. */
1267 if (deprecated_selected_frame_level_changed_hook)
1268 deprecated_selected_frame_level_changed_hook (frame_relative_level (fi));
1270 /* FIXME: kseitz/2002-08-28: It would be nice to call
1271 selected_frame_level_changed_event() right here, but due to limitations
1272 in the current interfaces, we would end up flooding UIs with events
1273 because select_frame() is used extensively internally.
1275 Once we have frame-parameterized frame (and frame-related) commands,
1276 the event notification can be moved here, since this function will only
1277 be called when the user's selected frame is being changed. */
1279 /* Ensure that symbols for this frame are read in. Also, determine the
1280 source language of this frame, and switch to it if desired. */
1283 /* We retrieve the frame's symtab by using the frame PC. However
1284 we cannot use the frame PC as-is, because it usually points to
1285 the instruction following the "call", which is sometimes the
1286 first instruction of another function. So we rely on
1287 get_frame_address_in_block() which provides us with a PC which
1288 is guaranteed to be inside the frame's code block. */
1289 s = find_pc_symtab (get_frame_address_in_block (fi));
1291 && s->language != current_language->la_language
1292 && s->language != language_unknown
1293 && language_mode == language_mode_auto)
1295 set_language (s->language);
1300 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
1301 Always returns a non-NULL value. */
1304 create_new_frame (CORE_ADDR addr, CORE_ADDR pc)
1306 struct frame_info *fi;
1310 fprintf_unfiltered (gdb_stdlog,
1311 "{ create_new_frame (addr=%s, pc=%s) ",
1312 hex_string (addr), hex_string (pc));
1315 fi = FRAME_OBSTACK_ZALLOC (struct frame_info);
1317 fi->next = create_sentinel_frame (current_program_space, get_current_regcache ());
1319 /* Set/update this frame's cached PC value, found in the next frame.
1320 Do this before looking for this frame's unwinder. A sniffer is
1321 very likely to read this, and the corresponding unwinder is
1322 entitled to rely that the PC doesn't magically change. */
1323 fi->next->prev_pc.value = pc;
1324 fi->next->prev_pc.p = 1;
1326 /* We currently assume that frame chain's can't cross spaces. */
1327 fi->pspace = fi->next->pspace;
1328 fi->aspace = fi->next->aspace;
1330 /* Select/initialize both the unwind function and the frame's type
1332 frame_unwind_find_by_frame (fi, &fi->prologue_cache);
1335 fi->this_id.value = frame_id_build (addr, pc);
1339 fprintf_unfiltered (gdb_stdlog, "-> ");
1340 fprint_frame (gdb_stdlog, fi);
1341 fprintf_unfiltered (gdb_stdlog, " }\n");
1347 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
1348 innermost frame). Be careful to not fall off the bottom of the
1349 frame chain and onto the sentinel frame. */
1352 get_next_frame (struct frame_info *this_frame)
1354 if (this_frame->level > 0)
1355 return this_frame->next;
1360 /* Observer for the target_changed event. */
1363 frame_observer_target_changed (struct target_ops *target)
1365 reinit_frame_cache ();
1368 /* Flush the entire frame cache. */
1371 reinit_frame_cache (void)
1373 struct frame_info *fi;
1375 /* Tear down all frame caches. */
1376 for (fi = current_frame; fi != NULL; fi = fi->prev)
1378 if (fi->prologue_cache && fi->unwind->dealloc_cache)
1379 fi->unwind->dealloc_cache (fi, fi->prologue_cache);
1380 if (fi->base_cache && fi->base->unwind->dealloc_cache)
1381 fi->base->unwind->dealloc_cache (fi, fi->base_cache);
1384 /* Since we can't really be sure what the first object allocated was */
1385 obstack_free (&frame_cache_obstack, 0);
1386 obstack_init (&frame_cache_obstack);
1388 if (current_frame != NULL)
1389 annotate_frames_invalid ();
1391 current_frame = NULL; /* Invalidate cache */
1392 select_frame (NULL);
1393 frame_stash_invalidate ();
1395 fprintf_unfiltered (gdb_stdlog, "{ reinit_frame_cache () }\n");
1398 /* Find where a register is saved (in memory or another register).
1399 The result of frame_register_unwind is just where it is saved
1400 relative to this particular frame. */
1403 frame_register_unwind_location (struct frame_info *this_frame, int regnum,
1404 int *optimizedp, enum lval_type *lvalp,
1405 CORE_ADDR *addrp, int *realnump)
1407 gdb_assert (this_frame == NULL || this_frame->level >= 0);
1409 while (this_frame != NULL)
1411 frame_register_unwind (this_frame, regnum, optimizedp, lvalp,
1412 addrp, realnump, NULL);
1417 if (*lvalp != lval_register)
1421 this_frame = get_next_frame (this_frame);
1425 /* Return a "struct frame_info" corresponding to the frame that called
1426 THIS_FRAME. Returns NULL if there is no such frame.
1428 Unlike get_prev_frame, this function always tries to unwind the
1431 static struct frame_info *
1432 get_prev_frame_1 (struct frame_info *this_frame)
1434 struct frame_id this_id;
1435 struct gdbarch *gdbarch;
1437 gdb_assert (this_frame != NULL);
1438 gdbarch = get_frame_arch (this_frame);
1442 fprintf_unfiltered (gdb_stdlog, "{ get_prev_frame_1 (this_frame=");
1443 if (this_frame != NULL)
1444 fprintf_unfiltered (gdb_stdlog, "%d", this_frame->level);
1446 fprintf_unfiltered (gdb_stdlog, "<NULL>");
1447 fprintf_unfiltered (gdb_stdlog, ") ");
1450 /* Only try to do the unwind once. */
1451 if (this_frame->prev_p)
1455 fprintf_unfiltered (gdb_stdlog, "-> ");
1456 fprint_frame (gdb_stdlog, this_frame->prev);
1457 fprintf_unfiltered (gdb_stdlog, " // cached \n");
1459 return this_frame->prev;
1462 /* If the frame unwinder hasn't been selected yet, we must do so
1463 before setting prev_p; otherwise the check for misbehaved
1464 sniffers will think that this frame's sniffer tried to unwind
1465 further (see frame_cleanup_after_sniffer). */
1466 if (this_frame->unwind == NULL)
1467 frame_unwind_find_by_frame (this_frame, &this_frame->prologue_cache);
1469 this_frame->prev_p = 1;
1470 this_frame->stop_reason = UNWIND_NO_REASON;
1472 /* If we are unwinding from an inline frame, all of the below tests
1473 were already performed when we unwound from the next non-inline
1474 frame. We must skip them, since we can not get THIS_FRAME's ID
1475 until we have unwound all the way down to the previous non-inline
1477 if (get_frame_type (this_frame) == INLINE_FRAME)
1478 return get_prev_frame_raw (this_frame);
1480 /* Check that this frame's ID was valid. If it wasn't, don't try to
1481 unwind to the prev frame. Be careful to not apply this test to
1482 the sentinel frame. */
1483 this_id = get_frame_id (this_frame);
1484 if (this_frame->level >= 0 && frame_id_eq (this_id, outer_frame_id))
1488 fprintf_unfiltered (gdb_stdlog, "-> ");
1489 fprint_frame (gdb_stdlog, NULL);
1490 fprintf_unfiltered (gdb_stdlog, " // this ID is NULL }\n");
1492 this_frame->stop_reason = UNWIND_NULL_ID;
1496 /* Check that this frame's ID isn't inner to (younger, below, next)
1497 the next frame. This happens when a frame unwind goes backwards.
1498 This check is valid only if this frame and the next frame are NORMAL.
1499 See the comment at frame_id_inner for details. */
1500 if (get_frame_type (this_frame) == NORMAL_FRAME
1501 && this_frame->next->unwind->type == NORMAL_FRAME
1502 && frame_id_inner (get_frame_arch (this_frame->next), this_id,
1503 get_frame_id (this_frame->next)))
1505 CORE_ADDR this_pc_in_block;
1506 struct minimal_symbol *morestack_msym;
1507 const char *morestack_name = NULL;
1509 /* gcc -fsplit-stack __morestack can continue the stack anywhere. */
1510 this_pc_in_block = get_frame_address_in_block (this_frame);
1511 morestack_msym = lookup_minimal_symbol_by_pc (this_pc_in_block);
1513 morestack_name = SYMBOL_LINKAGE_NAME (morestack_msym);
1514 if (!morestack_name || strcmp (morestack_name, "__morestack") != 0)
1518 fprintf_unfiltered (gdb_stdlog, "-> ");
1519 fprint_frame (gdb_stdlog, NULL);
1520 fprintf_unfiltered (gdb_stdlog, " // this frame ID is inner }\n");
1522 this_frame->stop_reason = UNWIND_INNER_ID;
1527 /* Check that this and the next frame are not identical. If they
1528 are, there is most likely a stack cycle. As with the inner-than
1529 test above, avoid comparing the inner-most and sentinel frames. */
1530 if (this_frame->level > 0
1531 && frame_id_eq (this_id, get_frame_id (this_frame->next)))
1535 fprintf_unfiltered (gdb_stdlog, "-> ");
1536 fprint_frame (gdb_stdlog, NULL);
1537 fprintf_unfiltered (gdb_stdlog, " // this frame has same ID }\n");
1539 this_frame->stop_reason = UNWIND_SAME_ID;
1543 /* Check that this and the next frame do not unwind the PC register
1544 to the same memory location. If they do, then even though they
1545 have different frame IDs, the new frame will be bogus; two
1546 functions can't share a register save slot for the PC. This can
1547 happen when the prologue analyzer finds a stack adjustment, but
1550 This check does assume that the "PC register" is roughly a
1551 traditional PC, even if the gdbarch_unwind_pc method adjusts
1552 it (we do not rely on the value, only on the unwound PC being
1553 dependent on this value). A potential improvement would be
1554 to have the frame prev_pc method and the gdbarch unwind_pc
1555 method set the same lval and location information as
1556 frame_register_unwind. */
1557 if (this_frame->level > 0
1558 && gdbarch_pc_regnum (gdbarch) >= 0
1559 && get_frame_type (this_frame) == NORMAL_FRAME
1560 && (get_frame_type (this_frame->next) == NORMAL_FRAME
1561 || get_frame_type (this_frame->next) == INLINE_FRAME))
1563 int optimized, realnum, nrealnum;
1564 enum lval_type lval, nlval;
1565 CORE_ADDR addr, naddr;
1567 frame_register_unwind_location (this_frame,
1568 gdbarch_pc_regnum (gdbarch),
1569 &optimized, &lval, &addr, &realnum);
1570 frame_register_unwind_location (get_next_frame (this_frame),
1571 gdbarch_pc_regnum (gdbarch),
1572 &optimized, &nlval, &naddr, &nrealnum);
1574 if ((lval == lval_memory && lval == nlval && addr == naddr)
1575 || (lval == lval_register && lval == nlval && realnum == nrealnum))
1579 fprintf_unfiltered (gdb_stdlog, "-> ");
1580 fprint_frame (gdb_stdlog, NULL);
1581 fprintf_unfiltered (gdb_stdlog, " // no saved PC }\n");
1584 this_frame->stop_reason = UNWIND_NO_SAVED_PC;
1585 this_frame->prev = NULL;
1590 return get_prev_frame_raw (this_frame);
1593 /* Construct a new "struct frame_info" and link it previous to
1596 static struct frame_info *
1597 get_prev_frame_raw (struct frame_info *this_frame)
1599 struct frame_info *prev_frame;
1601 /* Allocate the new frame but do not wire it in to the frame chain.
1602 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
1603 frame->next to pull some fancy tricks (of course such code is, by
1604 definition, recursive). Try to prevent it.
1606 There is no reason to worry about memory leaks, should the
1607 remainder of the function fail. The allocated memory will be
1608 quickly reclaimed when the frame cache is flushed, and the `we've
1609 been here before' check above will stop repeated memory
1610 allocation calls. */
1611 prev_frame = FRAME_OBSTACK_ZALLOC (struct frame_info);
1612 prev_frame->level = this_frame->level + 1;
1614 /* For now, assume we don't have frame chains crossing address
1616 prev_frame->pspace = this_frame->pspace;
1617 prev_frame->aspace = this_frame->aspace;
1619 /* Don't yet compute ->unwind (and hence ->type). It is computed
1620 on-demand in get_frame_type, frame_register_unwind, and
1623 /* Don't yet compute the frame's ID. It is computed on-demand by
1626 /* The unwound frame ID is validate at the start of this function,
1627 as part of the logic to decide if that frame should be further
1628 unwound, and not here while the prev frame is being created.
1629 Doing this makes it possible for the user to examine a frame that
1630 has an invalid frame ID.
1632 Some very old VAX code noted: [...] For the sake of argument,
1633 suppose that the stack is somewhat trashed (which is one reason
1634 that "info frame" exists). So, return 0 (indicating we don't
1635 know the address of the arglist) if we don't know what frame this
1639 this_frame->prev = prev_frame;
1640 prev_frame->next = this_frame;
1644 fprintf_unfiltered (gdb_stdlog, "-> ");
1645 fprint_frame (gdb_stdlog, prev_frame);
1646 fprintf_unfiltered (gdb_stdlog, " }\n");
1652 /* Debug routine to print a NULL frame being returned. */
1655 frame_debug_got_null_frame (struct frame_info *this_frame,
1660 fprintf_unfiltered (gdb_stdlog, "{ get_prev_frame (this_frame=");
1661 if (this_frame != NULL)
1662 fprintf_unfiltered (gdb_stdlog, "%d", this_frame->level);
1664 fprintf_unfiltered (gdb_stdlog, "<NULL>");
1665 fprintf_unfiltered (gdb_stdlog, ") -> // %s}\n", reason);
1669 /* Is this (non-sentinel) frame in the "main"() function? */
1672 inside_main_func (struct frame_info *this_frame)
1674 struct minimal_symbol *msymbol;
1677 if (symfile_objfile == 0)
1679 msymbol = lookup_minimal_symbol (main_name (), NULL, symfile_objfile);
1680 if (msymbol == NULL)
1682 /* Make certain that the code, and not descriptor, address is
1684 maddr = gdbarch_convert_from_func_ptr_addr (get_frame_arch (this_frame),
1685 SYMBOL_VALUE_ADDRESS (msymbol),
1687 return maddr == get_frame_func (this_frame);
1690 /* Test whether THIS_FRAME is inside the process entry point function. */
1693 inside_entry_func (struct frame_info *this_frame)
1695 CORE_ADDR entry_point;
1697 if (!entry_point_address_query (&entry_point))
1700 return get_frame_func (this_frame) == entry_point;
1703 /* Return a structure containing various interesting information about
1704 the frame that called THIS_FRAME. Returns NULL if there is entier
1705 no such frame or the frame fails any of a set of target-independent
1706 condition that should terminate the frame chain (e.g., as unwinding
1709 This function should not contain target-dependent tests, such as
1710 checking whether the program-counter is zero. */
1713 get_prev_frame (struct frame_info *this_frame)
1715 /* There is always a frame. If this assertion fails, suspect that
1716 something should be calling get_selected_frame() or
1717 get_current_frame(). */
1718 gdb_assert (this_frame != NULL);
1720 /* tausq/2004-12-07: Dummy frames are skipped because it doesn't make much
1721 sense to stop unwinding at a dummy frame. One place where a dummy
1722 frame may have an address "inside_main_func" is on HPUX. On HPUX, the
1723 pcsqh register (space register for the instruction at the head of the
1724 instruction queue) cannot be written directly; the only way to set it
1725 is to branch to code that is in the target space. In order to implement
1726 frame dummies on HPUX, the called function is made to jump back to where
1727 the inferior was when the user function was called. If gdb was inside
1728 the main function when we created the dummy frame, the dummy frame will
1729 point inside the main function. */
1730 if (this_frame->level >= 0
1731 && get_frame_type (this_frame) == NORMAL_FRAME
1732 && !backtrace_past_main
1733 && inside_main_func (this_frame))
1734 /* Don't unwind past main(). Note, this is done _before_ the
1735 frame has been marked as previously unwound. That way if the
1736 user later decides to enable unwinds past main(), that will
1737 automatically happen. */
1739 frame_debug_got_null_frame (this_frame, "inside main func");
1743 /* If the user's backtrace limit has been exceeded, stop. We must
1744 add two to the current level; one of those accounts for backtrace_limit
1745 being 1-based and the level being 0-based, and the other accounts for
1746 the level of the new frame instead of the level of the current
1748 if (this_frame->level + 2 > backtrace_limit)
1750 frame_debug_got_null_frame (this_frame, "backtrace limit exceeded");
1754 /* If we're already inside the entry function for the main objfile,
1755 then it isn't valid. Don't apply this test to a dummy frame -
1756 dummy frame PCs typically land in the entry func. Don't apply
1757 this test to the sentinel frame. Sentinel frames should always
1758 be allowed to unwind. */
1759 /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() -
1760 wasn't checking for "main" in the minimal symbols. With that
1761 fixed asm-source tests now stop in "main" instead of halting the
1762 backtrace in weird and wonderful ways somewhere inside the entry
1763 file. Suspect that tests for inside the entry file/func were
1764 added to work around that (now fixed) case. */
1765 /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
1766 suggested having the inside_entry_func test use the
1767 inside_main_func() msymbol trick (along with entry_point_address()
1768 I guess) to determine the address range of the start function.
1769 That should provide a far better stopper than the current
1771 /* NOTE: tausq/2004-10-09: this is needed if, for example, the compiler
1772 applied tail-call optimizations to main so that a function called
1773 from main returns directly to the caller of main. Since we don't
1774 stop at main, we should at least stop at the entry point of the
1776 if (this_frame->level >= 0
1777 && get_frame_type (this_frame) == NORMAL_FRAME
1778 && !backtrace_past_entry
1779 && inside_entry_func (this_frame))
1781 frame_debug_got_null_frame (this_frame, "inside entry func");
1785 /* Assume that the only way to get a zero PC is through something
1786 like a SIGSEGV or a dummy frame, and hence that NORMAL frames
1787 will never unwind a zero PC. */
1788 if (this_frame->level > 0
1789 && (get_frame_type (this_frame) == NORMAL_FRAME
1790 || get_frame_type (this_frame) == INLINE_FRAME)
1791 && get_frame_type (get_next_frame (this_frame)) == NORMAL_FRAME
1792 && get_frame_pc (this_frame) == 0)
1794 frame_debug_got_null_frame (this_frame, "zero PC");
1798 return get_prev_frame_1 (this_frame);
1802 get_frame_pc (struct frame_info *frame)
1804 gdb_assert (frame->next != NULL);
1805 return frame_unwind_pc (frame->next);
1808 /* Return an address that falls within THIS_FRAME's code block. */
1811 get_frame_address_in_block (struct frame_info *this_frame)
1813 /* A draft address. */
1814 CORE_ADDR pc = get_frame_pc (this_frame);
1816 struct frame_info *next_frame = this_frame->next;
1818 /* Calling get_frame_pc returns the resume address for THIS_FRAME.
1819 Normally the resume address is inside the body of the function
1820 associated with THIS_FRAME, but there is a special case: when
1821 calling a function which the compiler knows will never return
1822 (for instance abort), the call may be the very last instruction
1823 in the calling function. The resume address will point after the
1824 call and may be at the beginning of a different function
1827 If THIS_FRAME is a signal frame or dummy frame, then we should
1828 not adjust the unwound PC. For a dummy frame, GDB pushed the
1829 resume address manually onto the stack. For a signal frame, the
1830 OS may have pushed the resume address manually and invoked the
1831 handler (e.g. GNU/Linux), or invoked the trampoline which called
1832 the signal handler - but in either case the signal handler is
1833 expected to return to the trampoline. So in both of these
1834 cases we know that the resume address is executable and
1835 related. So we only need to adjust the PC if THIS_FRAME
1836 is a normal function.
1838 If the program has been interrupted while THIS_FRAME is current,
1839 then clearly the resume address is inside the associated
1840 function. There are three kinds of interruption: debugger stop
1841 (next frame will be SENTINEL_FRAME), operating system
1842 signal or exception (next frame will be SIGTRAMP_FRAME),
1843 or debugger-induced function call (next frame will be
1844 DUMMY_FRAME). So we only need to adjust the PC if
1845 NEXT_FRAME is a normal function.
1847 We check the type of NEXT_FRAME first, since it is already
1848 known; frame type is determined by the unwinder, and since
1849 we have THIS_FRAME we've already selected an unwinder for
1852 If the next frame is inlined, we need to keep going until we find
1853 the real function - for instance, if a signal handler is invoked
1854 while in an inlined function, then the code address of the
1855 "calling" normal function should not be adjusted either. */
1857 while (get_frame_type (next_frame) == INLINE_FRAME)
1858 next_frame = next_frame->next;
1860 if (get_frame_type (next_frame) == NORMAL_FRAME
1861 && (get_frame_type (this_frame) == NORMAL_FRAME
1862 || get_frame_type (this_frame) == INLINE_FRAME))
1869 find_frame_sal (struct frame_info *frame, struct symtab_and_line *sal)
1871 struct frame_info *next_frame;
1874 /* If the next frame represents an inlined function call, this frame's
1875 sal is the "call site" of that inlined function, which can not
1876 be inferred from get_frame_pc. */
1877 next_frame = get_next_frame (frame);
1878 if (frame_inlined_callees (frame) > 0)
1883 sym = get_frame_function (next_frame);
1885 sym = inline_skipped_symbol (inferior_ptid);
1888 if (SYMBOL_LINE (sym) != 0)
1890 sal->symtab = SYMBOL_SYMTAB (sym);
1891 sal->line = SYMBOL_LINE (sym);
1894 /* If the symbol does not have a location, we don't know where
1895 the call site is. Do not pretend to. This is jarring, but
1896 we can't do much better. */
1897 sal->pc = get_frame_pc (frame);
1902 /* If FRAME is not the innermost frame, that normally means that
1903 FRAME->pc points at the return instruction (which is *after* the
1904 call instruction), and we want to get the line containing the
1905 call (because the call is where the user thinks the program is).
1906 However, if the next frame is either a SIGTRAMP_FRAME or a
1907 DUMMY_FRAME, then the next frame will contain a saved interrupt
1908 PC and such a PC indicates the current (rather than next)
1909 instruction/line, consequently, for such cases, want to get the
1910 line containing fi->pc. */
1911 notcurrent = (get_frame_pc (frame) != get_frame_address_in_block (frame));
1912 (*sal) = find_pc_line (get_frame_pc (frame), notcurrent);
1915 /* Per "frame.h", return the ``address'' of the frame. Code should
1916 really be using get_frame_id(). */
1918 get_frame_base (struct frame_info *fi)
1920 return get_frame_id (fi).stack_addr;
1923 /* High-level offsets into the frame. Used by the debug info. */
1926 get_frame_base_address (struct frame_info *fi)
1928 if (get_frame_type (fi) != NORMAL_FRAME)
1930 if (fi->base == NULL)
1931 fi->base = frame_base_find_by_frame (fi);
1932 /* Sneaky: If the low-level unwind and high-level base code share a
1933 common unwinder, let them share the prologue cache. */
1934 if (fi->base->unwind == fi->unwind)
1935 return fi->base->this_base (fi, &fi->prologue_cache);
1936 return fi->base->this_base (fi, &fi->base_cache);
1940 get_frame_locals_address (struct frame_info *fi)
1942 if (get_frame_type (fi) != NORMAL_FRAME)
1944 /* If there isn't a frame address method, find it. */
1945 if (fi->base == NULL)
1946 fi->base = frame_base_find_by_frame (fi);
1947 /* Sneaky: If the low-level unwind and high-level base code share a
1948 common unwinder, let them share the prologue cache. */
1949 if (fi->base->unwind == fi->unwind)
1950 return fi->base->this_locals (fi, &fi->prologue_cache);
1951 return fi->base->this_locals (fi, &fi->base_cache);
1955 get_frame_args_address (struct frame_info *fi)
1957 if (get_frame_type (fi) != NORMAL_FRAME)
1959 /* If there isn't a frame address method, find it. */
1960 if (fi->base == NULL)
1961 fi->base = frame_base_find_by_frame (fi);
1962 /* Sneaky: If the low-level unwind and high-level base code share a
1963 common unwinder, let them share the prologue cache. */
1964 if (fi->base->unwind == fi->unwind)
1965 return fi->base->this_args (fi, &fi->prologue_cache);
1966 return fi->base->this_args (fi, &fi->base_cache);
1969 /* Return true if the frame unwinder for frame FI is UNWINDER; false
1973 frame_unwinder_is (struct frame_info *fi, const struct frame_unwind *unwinder)
1975 if (fi->unwind == NULL)
1976 frame_unwind_find_by_frame (fi, &fi->prologue_cache);
1977 return fi->unwind == unwinder;
1980 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
1981 or -1 for a NULL frame. */
1984 frame_relative_level (struct frame_info *fi)
1993 get_frame_type (struct frame_info *frame)
1995 if (frame->unwind == NULL)
1996 /* Initialize the frame's unwinder because that's what
1997 provides the frame's type. */
1998 frame_unwind_find_by_frame (frame, &frame->prologue_cache);
1999 return frame->unwind->type;
2002 struct program_space *
2003 get_frame_program_space (struct frame_info *frame)
2005 return frame->pspace;
2008 struct program_space *
2009 frame_unwind_program_space (struct frame_info *this_frame)
2011 gdb_assert (this_frame);
2013 /* This is really a placeholder to keep the API consistent --- we
2014 assume for now that we don't have frame chains crossing
2016 return this_frame->pspace;
2019 struct address_space *
2020 get_frame_address_space (struct frame_info *frame)
2022 return frame->aspace;
2025 /* Memory access methods. */
2028 get_frame_memory (struct frame_info *this_frame, CORE_ADDR addr,
2029 gdb_byte *buf, int len)
2031 read_memory (addr, buf, len);
2035 get_frame_memory_signed (struct frame_info *this_frame, CORE_ADDR addr,
2038 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2039 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2041 return read_memory_integer (addr, len, byte_order);
2045 get_frame_memory_unsigned (struct frame_info *this_frame, CORE_ADDR addr,
2048 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2049 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2051 return read_memory_unsigned_integer (addr, len, byte_order);
2055 safe_frame_unwind_memory (struct frame_info *this_frame,
2056 CORE_ADDR addr, gdb_byte *buf, int len)
2058 /* NOTE: target_read_memory returns zero on success! */
2059 return !target_read_memory (addr, buf, len);
2062 /* Architecture methods. */
2065 get_frame_arch (struct frame_info *this_frame)
2067 return frame_unwind_arch (this_frame->next);
2071 frame_unwind_arch (struct frame_info *next_frame)
2073 if (!next_frame->prev_arch.p)
2075 struct gdbarch *arch;
2077 if (next_frame->unwind == NULL)
2078 frame_unwind_find_by_frame (next_frame, &next_frame->prologue_cache);
2080 if (next_frame->unwind->prev_arch != NULL)
2081 arch = next_frame->unwind->prev_arch (next_frame,
2082 &next_frame->prologue_cache);
2084 arch = get_frame_arch (next_frame);
2086 next_frame->prev_arch.arch = arch;
2087 next_frame->prev_arch.p = 1;
2089 fprintf_unfiltered (gdb_stdlog,
2090 "{ frame_unwind_arch (next_frame=%d) -> %s }\n",
2092 gdbarch_bfd_arch_info (arch)->printable_name);
2095 return next_frame->prev_arch.arch;
2099 frame_unwind_caller_arch (struct frame_info *next_frame)
2101 return frame_unwind_arch (skip_inlined_frames (next_frame));
2104 /* Stack pointer methods. */
2107 get_frame_sp (struct frame_info *this_frame)
2109 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2111 /* Normality - an architecture that provides a way of obtaining any
2112 frame inner-most address. */
2113 if (gdbarch_unwind_sp_p (gdbarch))
2114 /* NOTE drow/2008-06-28: gdbarch_unwind_sp could be converted to
2115 operate on THIS_FRAME now. */
2116 return gdbarch_unwind_sp (gdbarch, this_frame->next);
2117 /* Now things are really are grim. Hope that the value returned by
2118 the gdbarch_sp_regnum register is meaningful. */
2119 if (gdbarch_sp_regnum (gdbarch) >= 0)
2120 return get_frame_register_unsigned (this_frame,
2121 gdbarch_sp_regnum (gdbarch));
2122 internal_error (__FILE__, __LINE__, _("Missing unwind SP method"));
2125 /* Return the reason why we can't unwind past FRAME. */
2127 enum unwind_stop_reason
2128 get_frame_unwind_stop_reason (struct frame_info *frame)
2130 /* If we haven't tried to unwind past this point yet, then assume
2131 that unwinding would succeed. */
2132 if (frame->prev_p == 0)
2133 return UNWIND_NO_REASON;
2135 /* Otherwise, we set a reason when we succeeded (or failed) to
2137 return frame->stop_reason;
2140 /* Return a string explaining REASON. */
2143 frame_stop_reason_string (enum unwind_stop_reason reason)
2147 case UNWIND_NULL_ID:
2148 return _("unwinder did not report frame ID");
2150 case UNWIND_INNER_ID:
2151 return _("previous frame inner to this frame (corrupt stack?)");
2153 case UNWIND_SAME_ID:
2154 return _("previous frame identical to this frame (corrupt stack?)");
2156 case UNWIND_NO_SAVED_PC:
2157 return _("frame did not save the PC");
2159 case UNWIND_NO_REASON:
2160 case UNWIND_FIRST_ERROR:
2162 internal_error (__FILE__, __LINE__,
2163 "Invalid frame stop reason");
2167 /* Clean up after a failed (wrong unwinder) attempt to unwind past
2171 frame_cleanup_after_sniffer (void *arg)
2173 struct frame_info *frame = arg;
2175 /* The sniffer should not allocate a prologue cache if it did not
2176 match this frame. */
2177 gdb_assert (frame->prologue_cache == NULL);
2179 /* No sniffer should extend the frame chain; sniff based on what is
2181 gdb_assert (!frame->prev_p);
2183 /* The sniffer should not check the frame's ID; that's circular. */
2184 gdb_assert (!frame->this_id.p);
2186 /* Clear cached fields dependent on the unwinder.
2188 The previous PC is independent of the unwinder, but the previous
2189 function is not (see get_frame_address_in_block). */
2190 frame->prev_func.p = 0;
2191 frame->prev_func.addr = 0;
2193 /* Discard the unwinder last, so that we can easily find it if an assertion
2194 in this function triggers. */
2195 frame->unwind = NULL;
2198 /* Set FRAME's unwinder temporarily, so that we can call a sniffer.
2199 Return a cleanup which should be called if unwinding fails, and
2200 discarded if it succeeds. */
2203 frame_prepare_for_sniffer (struct frame_info *frame,
2204 const struct frame_unwind *unwind)
2206 gdb_assert (frame->unwind == NULL);
2207 frame->unwind = unwind;
2208 return make_cleanup (frame_cleanup_after_sniffer, frame);
2211 extern initialize_file_ftype _initialize_frame; /* -Wmissing-prototypes */
2213 static struct cmd_list_element *set_backtrace_cmdlist;
2214 static struct cmd_list_element *show_backtrace_cmdlist;
2217 set_backtrace_cmd (char *args, int from_tty)
2219 help_list (set_backtrace_cmdlist, "set backtrace ", -1, gdb_stdout);
2223 show_backtrace_cmd (char *args, int from_tty)
2225 cmd_show_list (show_backtrace_cmdlist, from_tty, "");
2229 _initialize_frame (void)
2231 obstack_init (&frame_cache_obstack);
2233 observer_attach_target_changed (frame_observer_target_changed);
2235 add_prefix_cmd ("backtrace", class_maintenance, set_backtrace_cmd, _("\
2236 Set backtrace specific variables.\n\
2237 Configure backtrace variables such as the backtrace limit"),
2238 &set_backtrace_cmdlist, "set backtrace ",
2239 0/*allow-unknown*/, &setlist);
2240 add_prefix_cmd ("backtrace", class_maintenance, show_backtrace_cmd, _("\
2241 Show backtrace specific variables\n\
2242 Show backtrace variables such as the backtrace limit"),
2243 &show_backtrace_cmdlist, "show backtrace ",
2244 0/*allow-unknown*/, &showlist);
2246 add_setshow_boolean_cmd ("past-main", class_obscure,
2247 &backtrace_past_main, _("\
2248 Set whether backtraces should continue past \"main\"."), _("\
2249 Show whether backtraces should continue past \"main\"."), _("\
2250 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
2251 the backtrace at \"main\". Set this variable if you need to see the rest\n\
2252 of the stack trace."),
2254 show_backtrace_past_main,
2255 &set_backtrace_cmdlist,
2256 &show_backtrace_cmdlist);
2258 add_setshow_boolean_cmd ("past-entry", class_obscure,
2259 &backtrace_past_entry, _("\
2260 Set whether backtraces should continue past the entry point of a program."),
2262 Show whether backtraces should continue past the entry point of a program."),
2264 Normally there are no callers beyond the entry point of a program, so GDB\n\
2265 will terminate the backtrace there. Set this variable if you need to see\n\
2266 the rest of the stack trace."),
2268 show_backtrace_past_entry,
2269 &set_backtrace_cmdlist,
2270 &show_backtrace_cmdlist);
2272 add_setshow_integer_cmd ("limit", class_obscure,
2273 &backtrace_limit, _("\
2274 Set an upper bound on the number of backtrace levels."), _("\
2275 Show the upper bound on the number of backtrace levels."), _("\
2276 No more than the specified number of frames can be displayed or examined.\n\
2277 Zero is unlimited."),
2279 show_backtrace_limit,
2280 &set_backtrace_cmdlist,
2281 &show_backtrace_cmdlist);
2283 /* Debug this files internals. */
2284 add_setshow_zinteger_cmd ("frame", class_maintenance, &frame_debug, _("\
2285 Set frame debugging."), _("\
2286 Show frame debugging."), _("\
2287 When non-zero, frame specific internal debugging is enabled."),
2290 &setdebuglist, &showdebuglist);