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 fi
->unwind
= 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
;
384 id
.stack_addr
= stack_addr
;
386 id
.code_addr
= code_addr
;
388 id
.special_addr
= special_addr
;
389 id
.special_addr_p
= 1;
394 frame_id_build (CORE_ADDR stack_addr
, CORE_ADDR code_addr
)
396 struct frame_id id
= null_frame_id
;
397 id
.stack_addr
= stack_addr
;
399 id
.code_addr
= code_addr
;
405 frame_id_build_wild (CORE_ADDR stack_addr
)
407 struct frame_id id
= null_frame_id
;
408 id
.stack_addr
= stack_addr
;
414 frame_id_p (struct frame_id l
)
417 /* The frame is valid iff it has a valid stack address. */
419 /* outer_frame_id is also valid. */
420 if (!p
&& memcmp (&l
, &outer_frame_id
, sizeof (l
)) == 0)
424 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_p (l=");
425 fprint_frame_id (gdb_stdlog
, l
);
426 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", p
);
432 frame_id_inlined_p (struct frame_id l
)
437 return (l
.inline_depth
!= 0);
441 frame_id_eq (struct frame_id l
, struct frame_id r
)
444 if (!l
.stack_addr_p
&& l
.special_addr_p
&& !r
.stack_addr_p
&& r
.special_addr_p
)
445 /* The outermost frame marker is equal to itself. This is the
446 dodgy thing about outer_frame_id, since between execution steps
447 we might step into another function - from which we can't
448 unwind either. More thought required to get rid of
451 else if (!l
.stack_addr_p
|| !r
.stack_addr_p
)
452 /* Like a NaN, if either ID is invalid, the result is false.
453 Note that a frame ID is invalid iff it is the null frame ID. */
455 else if (l
.stack_addr
!= r
.stack_addr
)
456 /* If .stack addresses are different, the frames are different. */
458 else if (l
.code_addr_p
&& r
.code_addr_p
&& l
.code_addr
!= r
.code_addr
)
459 /* An invalid code addr is a wild card. If .code addresses are
460 different, the frames are different. */
462 else if (l
.special_addr_p
&& r
.special_addr_p
463 && l
.special_addr
!= r
.special_addr
)
464 /* An invalid special addr is a wild card (or unused). Otherwise
465 if special addresses are different, the frames are different. */
467 else if (l
.inline_depth
!= r
.inline_depth
)
468 /* If inline depths are different, the frames must be different. */
471 /* Frames are equal. */
476 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_eq (l=");
477 fprint_frame_id (gdb_stdlog
, l
);
478 fprintf_unfiltered (gdb_stdlog
, ",r=");
479 fprint_frame_id (gdb_stdlog
, r
);
480 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", eq
);
485 /* Safety net to check whether frame ID L should be inner to
486 frame ID R, according to their stack addresses.
488 This method cannot be used to compare arbitrary frames, as the
489 ranges of valid stack addresses may be discontiguous (e.g. due
492 However, it can be used as safety net to discover invalid frame
493 IDs in certain circumstances. Assuming that NEXT is the immediate
494 inner frame to THIS and that NEXT and THIS are both NORMAL frames:
496 * The stack address of NEXT must be inner-than-or-equal to the stack
499 Therefore, if frame_id_inner (THIS, NEXT) holds, some unwind
502 * If NEXT and THIS have different stack addresses, no other frame
503 in the frame chain may have a stack address in between.
505 Therefore, if frame_id_inner (TEST, THIS) holds, but
506 frame_id_inner (TEST, NEXT) does not hold, TEST cannot refer
507 to a valid frame in the frame chain.
509 The sanity checks above cannot be performed when a SIGTRAMP frame
510 is involved, because signal handlers might be executed on a different
511 stack than the stack used by the routine that caused the signal
512 to be raised. This can happen for instance when a thread exceeds
513 its maximum stack size. In this case, certain compilers implement
514 a stack overflow strategy that cause the handler to be run on a
518 frame_id_inner (struct gdbarch
*gdbarch
, struct frame_id l
, struct frame_id r
)
521 if (!l
.stack_addr_p
|| !r
.stack_addr_p
)
522 /* Like NaN, any operation involving an invalid ID always fails. */
524 else if (l
.inline_depth
> r
.inline_depth
525 && l
.stack_addr
== r
.stack_addr
526 && l
.code_addr_p
== r
.code_addr_p
527 && l
.special_addr_p
== r
.special_addr_p
528 && l
.special_addr
== r
.special_addr
)
530 /* Same function, different inlined functions. */
531 struct block
*lb
, *rb
;
533 gdb_assert (l
.code_addr_p
&& r
.code_addr_p
);
535 lb
= block_for_pc (l
.code_addr
);
536 rb
= block_for_pc (r
.code_addr
);
538 if (lb
== NULL
|| rb
== NULL
)
539 /* Something's gone wrong. */
542 /* This will return true if LB and RB are the same block, or
543 if the block with the smaller depth lexically encloses the
544 block with the greater depth. */
545 inner
= contained_in (lb
, rb
);
548 /* Only return non-zero when strictly inner than. Note that, per
549 comment in "frame.h", there is some fuzz here. Frameless
550 functions are not strictly inner than (same .stack but
551 different .code and/or .special address). */
552 inner
= gdbarch_inner_than (gdbarch
, l
.stack_addr
, r
.stack_addr
);
555 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_inner (l=");
556 fprint_frame_id (gdb_stdlog
, l
);
557 fprintf_unfiltered (gdb_stdlog
, ",r=");
558 fprint_frame_id (gdb_stdlog
, r
);
559 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", inner
);
565 frame_find_by_id (struct frame_id id
)
567 struct frame_info
*frame
, *prev_frame
;
569 /* ZERO denotes the null frame, let the caller decide what to do
570 about it. Should it instead return get_current_frame()? */
571 if (!frame_id_p (id
))
574 /* Try using the frame stash first. Finding it there removes the need
575 to perform the search by looping over all frames, which can be very
576 CPU-intensive if the number of frames is very high (the loop is O(n)
577 and get_prev_frame performs a series of checks that are relatively
578 expensive). This optimization is particularly useful when this function
579 is called from another function (such as value_fetch_lazy, case
580 VALUE_LVAL (val) == lval_register) which already loops over all frames,
581 making the overall behavior O(n^2). */
582 frame
= frame_stash_find (id
);
586 for (frame
= get_current_frame (); ; frame
= prev_frame
)
588 struct frame_id
this = get_frame_id (frame
);
589 if (frame_id_eq (id
, this))
590 /* An exact match. */
593 prev_frame
= get_prev_frame (frame
);
597 /* As a safety net to avoid unnecessary backtracing while trying
598 to find an invalid ID, we check for a common situation where
599 we can detect from comparing stack addresses that no other
600 frame in the current frame chain can have this ID. See the
601 comment at frame_id_inner for details. */
602 if (get_frame_type (frame
) == NORMAL_FRAME
603 && !frame_id_inner (get_frame_arch (frame
), id
, this)
604 && frame_id_inner (get_frame_arch (prev_frame
), id
,
605 get_frame_id (prev_frame
)))
612 frame_unwind_pc (struct frame_info
*this_frame
)
614 if (!this_frame
->prev_pc
.p
)
617 if (gdbarch_unwind_pc_p (frame_unwind_arch (this_frame
)))
619 /* The right way. The `pure' way. The one true way. This
620 method depends solely on the register-unwind code to
621 determine the value of registers in THIS frame, and hence
622 the value of this frame's PC (resume address). A typical
623 implementation is no more than:
625 frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
626 return extract_unsigned_integer (buf, size of ISA_PC_REGNUM);
628 Note: this method is very heavily dependent on a correct
629 register-unwind implementation, it pays to fix that
630 method first; this method is frame type agnostic, since
631 it only deals with register values, it works with any
632 frame. This is all in stark contrast to the old
633 FRAME_SAVED_PC which would try to directly handle all the
634 different ways that a PC could be unwound. */
635 pc
= gdbarch_unwind_pc (frame_unwind_arch (this_frame
), this_frame
);
638 internal_error (__FILE__
, __LINE__
, _("No unwind_pc method"));
639 this_frame
->prev_pc
.value
= pc
;
640 this_frame
->prev_pc
.p
= 1;
642 fprintf_unfiltered (gdb_stdlog
,
643 "{ frame_unwind_caller_pc (this_frame=%d) -> %s }\n",
645 hex_string (this_frame
->prev_pc
.value
));
647 return this_frame
->prev_pc
.value
;
651 frame_unwind_caller_pc (struct frame_info
*this_frame
)
653 return frame_unwind_pc (skip_inlined_frames (this_frame
));
657 get_frame_func (struct frame_info
*this_frame
)
659 struct frame_info
*next_frame
= this_frame
->next
;
661 if (!next_frame
->prev_func
.p
)
663 /* Make certain that this, and not the adjacent, function is
665 CORE_ADDR addr_in_block
= get_frame_address_in_block (this_frame
);
666 next_frame
->prev_func
.p
= 1;
667 next_frame
->prev_func
.addr
= get_pc_function_start (addr_in_block
);
669 fprintf_unfiltered (gdb_stdlog
,
670 "{ get_frame_func (this_frame=%d) -> %s }\n",
672 hex_string (next_frame
->prev_func
.addr
));
674 return next_frame
->prev_func
.addr
;
678 do_frame_register_read (void *src
, int regnum
, gdb_byte
*buf
)
680 return frame_register_read (src
, regnum
, buf
);
684 frame_save_as_regcache (struct frame_info
*this_frame
)
686 struct address_space
*aspace
= get_frame_address_space (this_frame
);
687 struct regcache
*regcache
= regcache_xmalloc (get_frame_arch (this_frame
),
689 struct cleanup
*cleanups
= make_cleanup_regcache_xfree (regcache
);
690 regcache_save (regcache
, do_frame_register_read
, this_frame
);
691 discard_cleanups (cleanups
);
696 frame_pop (struct frame_info
*this_frame
)
698 struct frame_info
*prev_frame
;
699 struct regcache
*scratch
;
700 struct cleanup
*cleanups
;
702 if (get_frame_type (this_frame
) == DUMMY_FRAME
)
704 /* Popping a dummy frame involves restoring more than just registers.
705 dummy_frame_pop does all the work. */
706 dummy_frame_pop (get_frame_id (this_frame
));
710 /* Ensure that we have a frame to pop to. */
711 prev_frame
= get_prev_frame_1 (this_frame
);
714 error (_("Cannot pop the initial frame."));
716 /* Make a copy of all the register values unwound from this frame.
717 Save them in a scratch buffer so that there isn't a race between
718 trying to extract the old values from the current regcache while
719 at the same time writing new values into that same cache. */
720 scratch
= frame_save_as_regcache (prev_frame
);
721 cleanups
= make_cleanup_regcache_xfree (scratch
);
723 /* FIXME: cagney/2003-03-16: It should be possible to tell the
724 target's register cache that it is about to be hit with a burst
725 register transfer and that the sequence of register writes should
726 be batched. The pair target_prepare_to_store() and
727 target_store_registers() kind of suggest this functionality.
728 Unfortunately, they don't implement it. Their lack of a formal
729 definition can lead to targets writing back bogus values
730 (arguably a bug in the target code mind). */
731 /* Now copy those saved registers into the current regcache.
732 Here, regcache_cpy() calls regcache_restore(). */
733 regcache_cpy (get_current_regcache (), scratch
);
734 do_cleanups (cleanups
);
736 /* We've made right mess of GDB's local state, just discard
738 reinit_frame_cache ();
742 frame_register_unwind (struct frame_info
*frame
, int regnum
,
743 int *optimizedp
, enum lval_type
*lvalp
,
744 CORE_ADDR
*addrp
, int *realnump
, gdb_byte
*bufferp
)
748 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
749 that the value proper does not need to be fetched. */
750 gdb_assert (optimizedp
!= NULL
);
751 gdb_assert (lvalp
!= NULL
);
752 gdb_assert (addrp
!= NULL
);
753 gdb_assert (realnump
!= NULL
);
754 /* gdb_assert (bufferp != NULL); */
756 value
= frame_unwind_register_value (frame
, regnum
);
758 gdb_assert (value
!= NULL
);
760 *optimizedp
= value_optimized_out (value
);
761 *lvalp
= VALUE_LVAL (value
);
762 *addrp
= value_address (value
);
763 *realnump
= VALUE_REGNUM (value
);
766 memcpy (bufferp
, value_contents_all (value
),
767 TYPE_LENGTH (value_type (value
)));
769 /* Dispose of the new value. This prevents watchpoints from
770 trying to watch the saved frame pointer. */
771 release_value (value
);
776 frame_register (struct frame_info
*frame
, int regnum
,
777 int *optimizedp
, enum lval_type
*lvalp
,
778 CORE_ADDR
*addrp
, int *realnump
, gdb_byte
*bufferp
)
780 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
781 that the value proper does not need to be fetched. */
782 gdb_assert (optimizedp
!= NULL
);
783 gdb_assert (lvalp
!= NULL
);
784 gdb_assert (addrp
!= NULL
);
785 gdb_assert (realnump
!= NULL
);
786 /* gdb_assert (bufferp != NULL); */
788 /* Obtain the register value by unwinding the register from the next
789 (more inner frame). */
790 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
791 frame_register_unwind (frame
->next
, regnum
, optimizedp
, lvalp
, addrp
,
796 frame_unwind_register (struct frame_info
*frame
, int regnum
, gdb_byte
*buf
)
802 frame_register_unwind (frame
, regnum
, &optimized
, &lval
, &addr
,
807 get_frame_register (struct frame_info
*frame
,
808 int regnum
, gdb_byte
*buf
)
810 frame_unwind_register (frame
->next
, regnum
, buf
);
814 frame_unwind_register_value (struct frame_info
*frame
, int regnum
)
816 struct gdbarch
*gdbarch
;
819 gdb_assert (frame
!= NULL
);
820 gdbarch
= frame_unwind_arch (frame
);
824 fprintf_unfiltered (gdb_stdlog
, "\
825 { frame_unwind_register_value (frame=%d,regnum=%d(%s),...) ",
826 frame
->level
, regnum
,
827 user_reg_map_regnum_to_name (gdbarch
, regnum
));
830 /* Find the unwinder. */
831 if (frame
->unwind
== NULL
)
832 frame
->unwind
= frame_unwind_find_by_frame (frame
, &frame
->prologue_cache
);
834 /* Ask this frame to unwind its register. */
835 value
= frame
->unwind
->prev_register (frame
, &frame
->prologue_cache
, regnum
);
839 fprintf_unfiltered (gdb_stdlog
, "->");
840 if (value_optimized_out (value
))
841 fprintf_unfiltered (gdb_stdlog
, " optimized out");
844 if (VALUE_LVAL (value
) == lval_register
)
845 fprintf_unfiltered (gdb_stdlog
, " register=%d",
846 VALUE_REGNUM (value
));
847 else if (VALUE_LVAL (value
) == lval_memory
)
848 fprintf_unfiltered (gdb_stdlog
, " address=%s",
850 value_address (value
)));
852 fprintf_unfiltered (gdb_stdlog
, " computed");
854 if (value_lazy (value
))
855 fprintf_unfiltered (gdb_stdlog
, " lazy");
859 const gdb_byte
*buf
= value_contents (value
);
861 fprintf_unfiltered (gdb_stdlog
, " bytes=");
862 fprintf_unfiltered (gdb_stdlog
, "[");
863 for (i
= 0; i
< register_size (gdbarch
, regnum
); i
++)
864 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
865 fprintf_unfiltered (gdb_stdlog
, "]");
869 fprintf_unfiltered (gdb_stdlog
, " }\n");
876 get_frame_register_value (struct frame_info
*frame
, int regnum
)
878 return frame_unwind_register_value (frame
->next
, regnum
);
882 frame_unwind_register_signed (struct frame_info
*frame
, int regnum
)
884 struct gdbarch
*gdbarch
= frame_unwind_arch (frame
);
885 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
886 int size
= register_size (gdbarch
, regnum
);
887 gdb_byte buf
[MAX_REGISTER_SIZE
];
888 frame_unwind_register (frame
, regnum
, buf
);
889 return extract_signed_integer (buf
, size
, byte_order
);
893 get_frame_register_signed (struct frame_info
*frame
, int regnum
)
895 return frame_unwind_register_signed (frame
->next
, regnum
);
899 frame_unwind_register_unsigned (struct frame_info
*frame
, int regnum
)
901 struct gdbarch
*gdbarch
= frame_unwind_arch (frame
);
902 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
903 int size
= register_size (gdbarch
, regnum
);
904 gdb_byte buf
[MAX_REGISTER_SIZE
];
905 frame_unwind_register (frame
, regnum
, buf
);
906 return extract_unsigned_integer (buf
, size
, byte_order
);
910 get_frame_register_unsigned (struct frame_info
*frame
, int regnum
)
912 return frame_unwind_register_unsigned (frame
->next
, regnum
);
916 put_frame_register (struct frame_info
*frame
, int regnum
,
919 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
924 frame_register (frame
, regnum
, &optim
, &lval
, &addr
, &realnum
, NULL
);
926 error (_("Attempt to assign to a value that was optimized out."));
931 /* FIXME: write_memory doesn't yet take constant buffers.
933 gdb_byte tmp
[MAX_REGISTER_SIZE
];
934 memcpy (tmp
, buf
, register_size (gdbarch
, regnum
));
935 write_memory (addr
, tmp
, register_size (gdbarch
, regnum
));
939 regcache_cooked_write (get_current_regcache (), realnum
, buf
);
942 error (_("Attempt to assign to an unmodifiable value."));
946 /* frame_register_read ()
948 Find and return the value of REGNUM for the specified stack frame.
949 The number of bytes copied is REGISTER_SIZE (REGNUM).
951 Returns 0 if the register value could not be found. */
954 frame_register_read (struct frame_info
*frame
, int regnum
,
961 frame_register (frame
, regnum
, &optimized
, &lval
, &addr
, &realnum
, myaddr
);
967 get_frame_register_bytes (struct frame_info
*frame
, int regnum
,
968 CORE_ADDR offset
, int len
, gdb_byte
*myaddr
)
970 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
975 /* Skip registers wholly inside of OFFSET. */
976 while (offset
>= register_size (gdbarch
, regnum
))
978 offset
-= register_size (gdbarch
, regnum
);
982 /* Ensure that we will not read beyond the end of the register file.
983 This can only ever happen if the debug information is bad. */
985 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
986 for (i
= regnum
; i
< numregs
; i
++)
988 int thissize
= register_size (gdbarch
, i
);
990 break; /* This register is not available on this architecture. */
995 warning (_("Bad debug information detected: "
996 "Attempt to read %d bytes from registers."), len
);
1000 /* Copy the data. */
1003 int curr_len
= register_size (gdbarch
, regnum
) - offset
;
1007 if (curr_len
== register_size (gdbarch
, regnum
))
1009 if (!frame_register_read (frame
, regnum
, myaddr
))
1014 gdb_byte buf
[MAX_REGISTER_SIZE
];
1015 if (!frame_register_read (frame
, regnum
, buf
))
1017 memcpy (myaddr
, buf
+ offset
, curr_len
);
1030 put_frame_register_bytes (struct frame_info
*frame
, int regnum
,
1031 CORE_ADDR offset
, int len
, const gdb_byte
*myaddr
)
1033 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1035 /* Skip registers wholly inside of OFFSET. */
1036 while (offset
>= register_size (gdbarch
, regnum
))
1038 offset
-= register_size (gdbarch
, regnum
);
1042 /* Copy the data. */
1045 int curr_len
= register_size (gdbarch
, regnum
) - offset
;
1049 if (curr_len
== register_size (gdbarch
, regnum
))
1051 put_frame_register (frame
, regnum
, myaddr
);
1055 gdb_byte buf
[MAX_REGISTER_SIZE
];
1056 frame_register_read (frame
, regnum
, buf
);
1057 memcpy (buf
+ offset
, myaddr
, curr_len
);
1058 put_frame_register (frame
, regnum
, buf
);
1068 /* Create a sentinel frame. */
1070 static struct frame_info
*
1071 create_sentinel_frame (struct program_space
*pspace
, struct regcache
*regcache
)
1073 struct frame_info
*frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1075 frame
->pspace
= pspace
;
1076 frame
->aspace
= get_regcache_aspace (regcache
);
1077 /* Explicitly initialize the sentinel frame's cache. Provide it
1078 with the underlying regcache. In the future additional
1079 information, such as the frame's thread will be added. */
1080 frame
->prologue_cache
= sentinel_frame_cache (regcache
);
1081 /* For the moment there is only one sentinel frame implementation. */
1082 frame
->unwind
= sentinel_frame_unwind
;
1083 /* Link this frame back to itself. The frame is self referential
1084 (the unwound PC is the same as the pc), so make it so. */
1085 frame
->next
= frame
;
1086 /* Make the sentinel frame's ID valid, but invalid. That way all
1087 comparisons with it should fail. */
1088 frame
->this_id
.p
= 1;
1089 frame
->this_id
.value
= null_frame_id
;
1092 fprintf_unfiltered (gdb_stdlog
, "{ create_sentinel_frame (...) -> ");
1093 fprint_frame (gdb_stdlog
, frame
);
1094 fprintf_unfiltered (gdb_stdlog
, " }\n");
1099 /* Info about the innermost stack frame (contents of FP register) */
1101 static struct frame_info
*current_frame
;
1103 /* Cache for frame addresses already read by gdb. Valid only while
1104 inferior is stopped. Control variables for the frame cache should
1105 be local to this module. */
1107 static struct obstack frame_cache_obstack
;
1110 frame_obstack_zalloc (unsigned long size
)
1112 void *data
= obstack_alloc (&frame_cache_obstack
, size
);
1113 memset (data
, 0, size
);
1117 /* Return the innermost (currently executing) stack frame. This is
1118 split into two functions. The function unwind_to_current_frame()
1119 is wrapped in catch exceptions so that, even when the unwind of the
1120 sentinel frame fails, the function still returns a stack frame. */
1123 unwind_to_current_frame (struct ui_out
*ui_out
, void *args
)
1125 struct frame_info
*frame
= get_prev_frame (args
);
1126 /* A sentinel frame can fail to unwind, e.g., because its PC value
1127 lands in somewhere like start. */
1130 current_frame
= frame
;
1135 get_current_frame (void)
1137 /* First check, and report, the lack of registers. Having GDB
1138 report "No stack!" or "No memory" when the target doesn't even
1139 have registers is very confusing. Besides, "printcmd.exp"
1140 explicitly checks that ``print $pc'' with no registers prints "No
1142 if (!target_has_registers
)
1143 error (_("No registers."));
1144 if (!target_has_stack
)
1145 error (_("No stack."));
1146 if (!target_has_memory
)
1147 error (_("No memory."));
1148 /* Traceframes are effectively a substitute for the live inferior. */
1149 if (get_traceframe_number () < 0)
1151 if (ptid_equal (inferior_ptid
, null_ptid
))
1152 error (_("No selected thread."));
1153 if (is_exited (inferior_ptid
))
1154 error (_("Invalid selected thread."));
1155 if (is_executing (inferior_ptid
))
1156 error (_("Target is executing."));
1159 if (current_frame
== NULL
)
1161 struct frame_info
*sentinel_frame
=
1162 create_sentinel_frame (current_program_space
, get_current_regcache ());
1163 if (catch_exceptions (uiout
, unwind_to_current_frame
, sentinel_frame
,
1164 RETURN_MASK_ERROR
) != 0)
1166 /* Oops! Fake a current frame? Is this useful? It has a PC
1167 of zero, for instance. */
1168 current_frame
= sentinel_frame
;
1171 return current_frame
;
1174 /* The "selected" stack frame is used by default for local and arg
1175 access. May be zero, for no selected frame. */
1177 static struct frame_info
*selected_frame
;
1180 has_stack_frames (void)
1182 if (!target_has_registers
|| !target_has_stack
|| !target_has_memory
)
1185 /* No current inferior, no frame. */
1186 if (ptid_equal (inferior_ptid
, null_ptid
))
1189 /* Don't try to read from a dead thread. */
1190 if (is_exited (inferior_ptid
))
1193 /* ... or from a spinning thread. */
1194 if (is_executing (inferior_ptid
))
1200 /* Return the selected frame. Always non-NULL (unless there isn't an
1201 inferior sufficient for creating a frame) in which case an error is
1205 get_selected_frame (const char *message
)
1207 if (selected_frame
== NULL
)
1209 if (message
!= NULL
&& !has_stack_frames ())
1210 error (("%s"), message
);
1211 /* Hey! Don't trust this. It should really be re-finding the
1212 last selected frame of the currently selected thread. This,
1213 though, is better than nothing. */
1214 select_frame (get_current_frame ());
1216 /* There is always a frame. */
1217 gdb_assert (selected_frame
!= NULL
);
1218 return selected_frame
;
1221 /* This is a variant of get_selected_frame() which can be called when
1222 the inferior does not have a frame; in that case it will return
1223 NULL instead of calling error(). */
1226 deprecated_safe_get_selected_frame (void)
1228 if (!has_stack_frames ())
1230 return get_selected_frame (NULL
);
1233 /* Select frame FI (or NULL - to invalidate the current frame). */
1236 select_frame (struct frame_info
*fi
)
1240 selected_frame
= fi
;
1241 /* NOTE: cagney/2002-05-04: FI can be NULL. This occurs when the
1242 frame is being invalidated. */
1243 if (deprecated_selected_frame_level_changed_hook
)
1244 deprecated_selected_frame_level_changed_hook (frame_relative_level (fi
));
1246 /* FIXME: kseitz/2002-08-28: It would be nice to call
1247 selected_frame_level_changed_event() right here, but due to limitations
1248 in the current interfaces, we would end up flooding UIs with events
1249 because select_frame() is used extensively internally.
1251 Once we have frame-parameterized frame (and frame-related) commands,
1252 the event notification can be moved here, since this function will only
1253 be called when the user's selected frame is being changed. */
1255 /* Ensure that symbols for this frame are read in. Also, determine the
1256 source language of this frame, and switch to it if desired. */
1259 /* We retrieve the frame's symtab by using the frame PC. However
1260 we cannot use the frame PC as-is, because it usually points to
1261 the instruction following the "call", which is sometimes the
1262 first instruction of another function. So we rely on
1263 get_frame_address_in_block() which provides us with a PC which
1264 is guaranteed to be inside the frame's code block. */
1265 s
= find_pc_symtab (get_frame_address_in_block (fi
));
1267 && s
->language
!= current_language
->la_language
1268 && s
->language
!= language_unknown
1269 && language_mode
== language_mode_auto
)
1271 set_language (s
->language
);
1276 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
1277 Always returns a non-NULL value. */
1280 create_new_frame (CORE_ADDR addr
, CORE_ADDR pc
)
1282 struct frame_info
*fi
;
1286 fprintf_unfiltered (gdb_stdlog
,
1287 "{ create_new_frame (addr=%s, pc=%s) ",
1288 hex_string (addr
), hex_string (pc
));
1291 fi
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1293 fi
->next
= create_sentinel_frame (current_program_space
, get_current_regcache ());
1295 /* Set/update this frame's cached PC value, found in the next frame.
1296 Do this before looking for this frame's unwinder. A sniffer is
1297 very likely to read this, and the corresponding unwinder is
1298 entitled to rely that the PC doesn't magically change. */
1299 fi
->next
->prev_pc
.value
= pc
;
1300 fi
->next
->prev_pc
.p
= 1;
1302 /* We currently assume that frame chain's can't cross spaces. */
1303 fi
->pspace
= fi
->next
->pspace
;
1304 fi
->aspace
= fi
->next
->aspace
;
1306 /* Select/initialize both the unwind function and the frame's type
1308 fi
->unwind
= frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
1311 fi
->this_id
.value
= frame_id_build (addr
, pc
);
1315 fprintf_unfiltered (gdb_stdlog
, "-> ");
1316 fprint_frame (gdb_stdlog
, fi
);
1317 fprintf_unfiltered (gdb_stdlog
, " }\n");
1323 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
1324 innermost frame). Be careful to not fall off the bottom of the
1325 frame chain and onto the sentinel frame. */
1328 get_next_frame (struct frame_info
*this_frame
)
1330 if (this_frame
->level
> 0)
1331 return this_frame
->next
;
1336 /* Observer for the target_changed event. */
1339 frame_observer_target_changed (struct target_ops
*target
)
1341 reinit_frame_cache ();
1344 /* Flush the entire frame cache. */
1347 reinit_frame_cache (void)
1349 struct frame_info
*fi
;
1351 /* Tear down all frame caches. */
1352 for (fi
= current_frame
; fi
!= NULL
; fi
= fi
->prev
)
1354 if (fi
->prologue_cache
&& fi
->unwind
->dealloc_cache
)
1355 fi
->unwind
->dealloc_cache (fi
, fi
->prologue_cache
);
1356 if (fi
->base_cache
&& fi
->base
->unwind
->dealloc_cache
)
1357 fi
->base
->unwind
->dealloc_cache (fi
, fi
->base_cache
);
1360 /* Since we can't really be sure what the first object allocated was */
1361 obstack_free (&frame_cache_obstack
, 0);
1362 obstack_init (&frame_cache_obstack
);
1364 if (current_frame
!= NULL
)
1365 annotate_frames_invalid ();
1367 current_frame
= NULL
; /* Invalidate cache */
1368 select_frame (NULL
);
1369 frame_stash_invalidate ();
1371 fprintf_unfiltered (gdb_stdlog
, "{ reinit_frame_cache () }\n");
1374 /* Find where a register is saved (in memory or another register).
1375 The result of frame_register_unwind is just where it is saved
1376 relative to this particular frame. */
1379 frame_register_unwind_location (struct frame_info
*this_frame
, int regnum
,
1380 int *optimizedp
, enum lval_type
*lvalp
,
1381 CORE_ADDR
*addrp
, int *realnump
)
1383 gdb_assert (this_frame
== NULL
|| this_frame
->level
>= 0);
1385 while (this_frame
!= NULL
)
1387 frame_register_unwind (this_frame
, regnum
, optimizedp
, lvalp
,
1388 addrp
, realnump
, NULL
);
1393 if (*lvalp
!= lval_register
)
1397 this_frame
= get_next_frame (this_frame
);
1401 /* Return a "struct frame_info" corresponding to the frame that called
1402 THIS_FRAME. Returns NULL if there is no such frame.
1404 Unlike get_prev_frame, this function always tries to unwind the
1407 static struct frame_info
*
1408 get_prev_frame_1 (struct frame_info
*this_frame
)
1410 struct frame_id this_id
;
1411 struct gdbarch
*gdbarch
;
1413 gdb_assert (this_frame
!= NULL
);
1414 gdbarch
= get_frame_arch (this_frame
);
1418 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame_1 (this_frame=");
1419 if (this_frame
!= NULL
)
1420 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1422 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1423 fprintf_unfiltered (gdb_stdlog
, ") ");
1426 /* Only try to do the unwind once. */
1427 if (this_frame
->prev_p
)
1431 fprintf_unfiltered (gdb_stdlog
, "-> ");
1432 fprint_frame (gdb_stdlog
, this_frame
->prev
);
1433 fprintf_unfiltered (gdb_stdlog
, " // cached \n");
1435 return this_frame
->prev
;
1438 /* If the frame unwinder hasn't been selected yet, we must do so
1439 before setting prev_p; otherwise the check for misbehaved
1440 sniffers will think that this frame's sniffer tried to unwind
1441 further (see frame_cleanup_after_sniffer). */
1442 if (this_frame
->unwind
== NULL
)
1444 = frame_unwind_find_by_frame (this_frame
, &this_frame
->prologue_cache
);
1446 this_frame
->prev_p
= 1;
1447 this_frame
->stop_reason
= UNWIND_NO_REASON
;
1449 /* If we are unwinding from an inline frame, all of the below tests
1450 were already performed when we unwound from the next non-inline
1451 frame. We must skip them, since we can not get THIS_FRAME's ID
1452 until we have unwound all the way down to the previous non-inline
1454 if (get_frame_type (this_frame
) == INLINE_FRAME
)
1455 return get_prev_frame_raw (this_frame
);
1457 /* Check that this frame's ID was valid. If it wasn't, don't try to
1458 unwind to the prev frame. Be careful to not apply this test to
1459 the sentinel frame. */
1460 this_id
= get_frame_id (this_frame
);
1461 if (this_frame
->level
>= 0 && frame_id_eq (this_id
, outer_frame_id
))
1465 fprintf_unfiltered (gdb_stdlog
, "-> ");
1466 fprint_frame (gdb_stdlog
, NULL
);
1467 fprintf_unfiltered (gdb_stdlog
, " // this ID is NULL }\n");
1469 this_frame
->stop_reason
= UNWIND_NULL_ID
;
1473 /* Check that this frame's ID isn't inner to (younger, below, next)
1474 the next frame. This happens when a frame unwind goes backwards.
1475 This check is valid only if this frame and the next frame are NORMAL.
1476 See the comment at frame_id_inner for details. */
1477 if (get_frame_type (this_frame
) == NORMAL_FRAME
1478 && this_frame
->next
->unwind
->type
== NORMAL_FRAME
1479 && frame_id_inner (get_frame_arch (this_frame
->next
), this_id
,
1480 get_frame_id (this_frame
->next
)))
1484 fprintf_unfiltered (gdb_stdlog
, "-> ");
1485 fprint_frame (gdb_stdlog
, NULL
);
1486 fprintf_unfiltered (gdb_stdlog
, " // this frame ID is inner }\n");
1488 this_frame
->stop_reason
= UNWIND_INNER_ID
;
1492 /* Check that this and the next frame are not identical. If they
1493 are, there is most likely a stack cycle. As with the inner-than
1494 test above, avoid comparing the inner-most and sentinel frames. */
1495 if (this_frame
->level
> 0
1496 && frame_id_eq (this_id
, get_frame_id (this_frame
->next
)))
1500 fprintf_unfiltered (gdb_stdlog
, "-> ");
1501 fprint_frame (gdb_stdlog
, NULL
);
1502 fprintf_unfiltered (gdb_stdlog
, " // this frame has same ID }\n");
1504 this_frame
->stop_reason
= UNWIND_SAME_ID
;
1508 /* Check that this and the next frame do not unwind the PC register
1509 to the same memory location. If they do, then even though they
1510 have different frame IDs, the new frame will be bogus; two
1511 functions can't share a register save slot for the PC. This can
1512 happen when the prologue analyzer finds a stack adjustment, but
1515 This check does assume that the "PC register" is roughly a
1516 traditional PC, even if the gdbarch_unwind_pc method adjusts
1517 it (we do not rely on the value, only on the unwound PC being
1518 dependent on this value). A potential improvement would be
1519 to have the frame prev_pc method and the gdbarch unwind_pc
1520 method set the same lval and location information as
1521 frame_register_unwind. */
1522 if (this_frame
->level
> 0
1523 && gdbarch_pc_regnum (gdbarch
) >= 0
1524 && get_frame_type (this_frame
) == NORMAL_FRAME
1525 && (get_frame_type (this_frame
->next
) == NORMAL_FRAME
1526 || get_frame_type (this_frame
->next
) == INLINE_FRAME
))
1528 int optimized
, realnum
, nrealnum
;
1529 enum lval_type lval
, nlval
;
1530 CORE_ADDR addr
, naddr
;
1532 frame_register_unwind_location (this_frame
,
1533 gdbarch_pc_regnum (gdbarch
),
1534 &optimized
, &lval
, &addr
, &realnum
);
1535 frame_register_unwind_location (get_next_frame (this_frame
),
1536 gdbarch_pc_regnum (gdbarch
),
1537 &optimized
, &nlval
, &naddr
, &nrealnum
);
1539 if ((lval
== lval_memory
&& lval
== nlval
&& addr
== naddr
)
1540 || (lval
== lval_register
&& lval
== nlval
&& realnum
== nrealnum
))
1544 fprintf_unfiltered (gdb_stdlog
, "-> ");
1545 fprint_frame (gdb_stdlog
, NULL
);
1546 fprintf_unfiltered (gdb_stdlog
, " // no saved PC }\n");
1549 this_frame
->stop_reason
= UNWIND_NO_SAVED_PC
;
1550 this_frame
->prev
= NULL
;
1555 return get_prev_frame_raw (this_frame
);
1558 /* Construct a new "struct frame_info" and link it previous to
1561 static struct frame_info
*
1562 get_prev_frame_raw (struct frame_info
*this_frame
)
1564 struct frame_info
*prev_frame
;
1566 /* Allocate the new frame but do not wire it in to the frame chain.
1567 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
1568 frame->next to pull some fancy tricks (of course such code is, by
1569 definition, recursive). Try to prevent it.
1571 There is no reason to worry about memory leaks, should the
1572 remainder of the function fail. The allocated memory will be
1573 quickly reclaimed when the frame cache is flushed, and the `we've
1574 been here before' check above will stop repeated memory
1575 allocation calls. */
1576 prev_frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1577 prev_frame
->level
= this_frame
->level
+ 1;
1579 /* For now, assume we don't have frame chains crossing address
1581 prev_frame
->pspace
= this_frame
->pspace
;
1582 prev_frame
->aspace
= this_frame
->aspace
;
1584 /* Don't yet compute ->unwind (and hence ->type). It is computed
1585 on-demand in get_frame_type, frame_register_unwind, and
1588 /* Don't yet compute the frame's ID. It is computed on-demand by
1591 /* The unwound frame ID is validate at the start of this function,
1592 as part of the logic to decide if that frame should be further
1593 unwound, and not here while the prev frame is being created.
1594 Doing this makes it possible for the user to examine a frame that
1595 has an invalid frame ID.
1597 Some very old VAX code noted: [...] For the sake of argument,
1598 suppose that the stack is somewhat trashed (which is one reason
1599 that "info frame" exists). So, return 0 (indicating we don't
1600 know the address of the arglist) if we don't know what frame this
1604 this_frame
->prev
= prev_frame
;
1605 prev_frame
->next
= this_frame
;
1609 fprintf_unfiltered (gdb_stdlog
, "-> ");
1610 fprint_frame (gdb_stdlog
, prev_frame
);
1611 fprintf_unfiltered (gdb_stdlog
, " }\n");
1617 /* Debug routine to print a NULL frame being returned. */
1620 frame_debug_got_null_frame (struct frame_info
*this_frame
,
1625 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame (this_frame=");
1626 if (this_frame
!= NULL
)
1627 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1629 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1630 fprintf_unfiltered (gdb_stdlog
, ") -> // %s}\n", reason
);
1634 /* Is this (non-sentinel) frame in the "main"() function? */
1637 inside_main_func (struct frame_info
*this_frame
)
1639 struct minimal_symbol
*msymbol
;
1642 if (symfile_objfile
== 0)
1644 msymbol
= lookup_minimal_symbol (main_name (), NULL
, symfile_objfile
);
1645 if (msymbol
== NULL
)
1647 /* Make certain that the code, and not descriptor, address is
1649 maddr
= gdbarch_convert_from_func_ptr_addr (get_frame_arch (this_frame
),
1650 SYMBOL_VALUE_ADDRESS (msymbol
),
1652 return maddr
== get_frame_func (this_frame
);
1655 /* Test whether THIS_FRAME is inside the process entry point function. */
1658 inside_entry_func (struct frame_info
*this_frame
)
1660 CORE_ADDR entry_point
;
1662 if (!entry_point_address_query (&entry_point
))
1665 return get_frame_func (this_frame
) == entry_point
;
1668 /* Return a structure containing various interesting information about
1669 the frame that called THIS_FRAME. Returns NULL if there is entier
1670 no such frame or the frame fails any of a set of target-independent
1671 condition that should terminate the frame chain (e.g., as unwinding
1674 This function should not contain target-dependent tests, such as
1675 checking whether the program-counter is zero. */
1678 get_prev_frame (struct frame_info
*this_frame
)
1680 struct frame_info
*prev_frame
;
1682 /* There is always a frame. If this assertion fails, suspect that
1683 something should be calling get_selected_frame() or
1684 get_current_frame(). */
1685 gdb_assert (this_frame
!= NULL
);
1687 /* tausq/2004-12-07: Dummy frames are skipped because it doesn't make much
1688 sense to stop unwinding at a dummy frame. One place where a dummy
1689 frame may have an address "inside_main_func" is on HPUX. On HPUX, the
1690 pcsqh register (space register for the instruction at the head of the
1691 instruction queue) cannot be written directly; the only way to set it
1692 is to branch to code that is in the target space. In order to implement
1693 frame dummies on HPUX, the called function is made to jump back to where
1694 the inferior was when the user function was called. If gdb was inside
1695 the main function when we created the dummy frame, the dummy frame will
1696 point inside the main function. */
1697 if (this_frame
->level
>= 0
1698 && get_frame_type (this_frame
) == NORMAL_FRAME
1699 && !backtrace_past_main
1700 && inside_main_func (this_frame
))
1701 /* Don't unwind past main(). Note, this is done _before_ the
1702 frame has been marked as previously unwound. That way if the
1703 user later decides to enable unwinds past main(), that will
1704 automatically happen. */
1706 frame_debug_got_null_frame (this_frame
, "inside main func");
1710 /* If the user's backtrace limit has been exceeded, stop. We must
1711 add two to the current level; one of those accounts for backtrace_limit
1712 being 1-based and the level being 0-based, and the other accounts for
1713 the level of the new frame instead of the level of the current
1715 if (this_frame
->level
+ 2 > backtrace_limit
)
1717 frame_debug_got_null_frame (this_frame
, "backtrace limit exceeded");
1721 /* If we're already inside the entry function for the main objfile,
1722 then it isn't valid. Don't apply this test to a dummy frame -
1723 dummy frame PCs typically land in the entry func. Don't apply
1724 this test to the sentinel frame. Sentinel frames should always
1725 be allowed to unwind. */
1726 /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() -
1727 wasn't checking for "main" in the minimal symbols. With that
1728 fixed asm-source tests now stop in "main" instead of halting the
1729 backtrace in weird and wonderful ways somewhere inside the entry
1730 file. Suspect that tests for inside the entry file/func were
1731 added to work around that (now fixed) case. */
1732 /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
1733 suggested having the inside_entry_func test use the
1734 inside_main_func() msymbol trick (along with entry_point_address()
1735 I guess) to determine the address range of the start function.
1736 That should provide a far better stopper than the current
1738 /* NOTE: tausq/2004-10-09: this is needed if, for example, the compiler
1739 applied tail-call optimizations to main so that a function called
1740 from main returns directly to the caller of main. Since we don't
1741 stop at main, we should at least stop at the entry point of the
1743 if (this_frame
->level
>= 0
1744 && get_frame_type (this_frame
) == NORMAL_FRAME
1745 && !backtrace_past_entry
1746 && inside_entry_func (this_frame
))
1748 frame_debug_got_null_frame (this_frame
, "inside entry func");
1752 /* Assume that the only way to get a zero PC is through something
1753 like a SIGSEGV or a dummy frame, and hence that NORMAL frames
1754 will never unwind a zero PC. */
1755 if (this_frame
->level
> 0
1756 && (get_frame_type (this_frame
) == NORMAL_FRAME
1757 || get_frame_type (this_frame
) == INLINE_FRAME
)
1758 && get_frame_type (get_next_frame (this_frame
)) == NORMAL_FRAME
1759 && get_frame_pc (this_frame
) == 0)
1761 frame_debug_got_null_frame (this_frame
, "zero PC");
1765 return get_prev_frame_1 (this_frame
);
1769 get_frame_pc (struct frame_info
*frame
)
1771 gdb_assert (frame
->next
!= NULL
);
1772 return frame_unwind_pc (frame
->next
);
1775 /* Return an address that falls within THIS_FRAME's code block. */
1778 get_frame_address_in_block (struct frame_info
*this_frame
)
1780 /* A draft address. */
1781 CORE_ADDR pc
= get_frame_pc (this_frame
);
1783 struct frame_info
*next_frame
= this_frame
->next
;
1785 /* Calling get_frame_pc returns the resume address for THIS_FRAME.
1786 Normally the resume address is inside the body of the function
1787 associated with THIS_FRAME, but there is a special case: when
1788 calling a function which the compiler knows will never return
1789 (for instance abort), the call may be the very last instruction
1790 in the calling function. The resume address will point after the
1791 call and may be at the beginning of a different function
1794 If THIS_FRAME is a signal frame or dummy frame, then we should
1795 not adjust the unwound PC. For a dummy frame, GDB pushed the
1796 resume address manually onto the stack. For a signal frame, the
1797 OS may have pushed the resume address manually and invoked the
1798 handler (e.g. GNU/Linux), or invoked the trampoline which called
1799 the signal handler - but in either case the signal handler is
1800 expected to return to the trampoline. So in both of these
1801 cases we know that the resume address is executable and
1802 related. So we only need to adjust the PC if THIS_FRAME
1803 is a normal function.
1805 If the program has been interrupted while THIS_FRAME is current,
1806 then clearly the resume address is inside the associated
1807 function. There are three kinds of interruption: debugger stop
1808 (next frame will be SENTINEL_FRAME), operating system
1809 signal or exception (next frame will be SIGTRAMP_FRAME),
1810 or debugger-induced function call (next frame will be
1811 DUMMY_FRAME). So we only need to adjust the PC if
1812 NEXT_FRAME is a normal function.
1814 We check the type of NEXT_FRAME first, since it is already
1815 known; frame type is determined by the unwinder, and since
1816 we have THIS_FRAME we've already selected an unwinder for
1819 If the next frame is inlined, we need to keep going until we find
1820 the real function - for instance, if a signal handler is invoked
1821 while in an inlined function, then the code address of the
1822 "calling" normal function should not be adjusted either. */
1824 while (get_frame_type (next_frame
) == INLINE_FRAME
)
1825 next_frame
= next_frame
->next
;
1827 if (get_frame_type (next_frame
) == NORMAL_FRAME
1828 && (get_frame_type (this_frame
) == NORMAL_FRAME
1829 || get_frame_type (this_frame
) == INLINE_FRAME
))
1836 find_frame_sal (struct frame_info
*frame
, struct symtab_and_line
*sal
)
1838 struct frame_info
*next_frame
;
1841 /* If the next frame represents an inlined function call, this frame's
1842 sal is the "call site" of that inlined function, which can not
1843 be inferred from get_frame_pc. */
1844 next_frame
= get_next_frame (frame
);
1845 if (frame_inlined_callees (frame
) > 0)
1850 sym
= get_frame_function (next_frame
);
1852 sym
= inline_skipped_symbol (inferior_ptid
);
1855 if (SYMBOL_LINE (sym
) != 0)
1857 sal
->symtab
= SYMBOL_SYMTAB (sym
);
1858 sal
->line
= SYMBOL_LINE (sym
);
1861 /* If the symbol does not have a location, we don't know where
1862 the call site is. Do not pretend to. This is jarring, but
1863 we can't do much better. */
1864 sal
->pc
= get_frame_pc (frame
);
1869 /* If FRAME is not the innermost frame, that normally means that
1870 FRAME->pc points at the return instruction (which is *after* the
1871 call instruction), and we want to get the line containing the
1872 call (because the call is where the user thinks the program is).
1873 However, if the next frame is either a SIGTRAMP_FRAME or a
1874 DUMMY_FRAME, then the next frame will contain a saved interrupt
1875 PC and such a PC indicates the current (rather than next)
1876 instruction/line, consequently, for such cases, want to get the
1877 line containing fi->pc. */
1878 notcurrent
= (get_frame_pc (frame
) != get_frame_address_in_block (frame
));
1879 (*sal
) = find_pc_line (get_frame_pc (frame
), notcurrent
);
1882 /* Per "frame.h", return the ``address'' of the frame. Code should
1883 really be using get_frame_id(). */
1885 get_frame_base (struct frame_info
*fi
)
1887 return get_frame_id (fi
).stack_addr
;
1890 /* High-level offsets into the frame. Used by the debug info. */
1893 get_frame_base_address (struct frame_info
*fi
)
1895 if (get_frame_type (fi
) != NORMAL_FRAME
)
1897 if (fi
->base
== NULL
)
1898 fi
->base
= frame_base_find_by_frame (fi
);
1899 /* Sneaky: If the low-level unwind and high-level base code share a
1900 common unwinder, let them share the prologue cache. */
1901 if (fi
->base
->unwind
== fi
->unwind
)
1902 return fi
->base
->this_base (fi
, &fi
->prologue_cache
);
1903 return fi
->base
->this_base (fi
, &fi
->base_cache
);
1907 get_frame_locals_address (struct frame_info
*fi
)
1910 if (get_frame_type (fi
) != NORMAL_FRAME
)
1912 /* If there isn't a frame address method, find it. */
1913 if (fi
->base
== NULL
)
1914 fi
->base
= frame_base_find_by_frame (fi
);
1915 /* Sneaky: If the low-level unwind and high-level base code share a
1916 common unwinder, let them share the prologue cache. */
1917 if (fi
->base
->unwind
== fi
->unwind
)
1918 return fi
->base
->this_locals (fi
, &fi
->prologue_cache
);
1919 return fi
->base
->this_locals (fi
, &fi
->base_cache
);
1923 get_frame_args_address (struct frame_info
*fi
)
1926 if (get_frame_type (fi
) != NORMAL_FRAME
)
1928 /* If there isn't a frame address method, find it. */
1929 if (fi
->base
== NULL
)
1930 fi
->base
= frame_base_find_by_frame (fi
);
1931 /* Sneaky: If the low-level unwind and high-level base code share a
1932 common unwinder, let them share the prologue cache. */
1933 if (fi
->base
->unwind
== fi
->unwind
)
1934 return fi
->base
->this_args (fi
, &fi
->prologue_cache
);
1935 return fi
->base
->this_args (fi
, &fi
->base_cache
);
1938 /* Return true if the frame unwinder for frame FI is UNWINDER; false
1942 frame_unwinder_is (struct frame_info
*fi
, const struct frame_unwind
*unwinder
)
1944 if (fi
->unwind
== NULL
)
1945 fi
->unwind
= frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
1946 return fi
->unwind
== unwinder
;
1949 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
1950 or -1 for a NULL frame. */
1953 frame_relative_level (struct frame_info
*fi
)
1962 get_frame_type (struct frame_info
*frame
)
1964 if (frame
->unwind
== NULL
)
1965 /* Initialize the frame's unwinder because that's what
1966 provides the frame's type. */
1967 frame
->unwind
= frame_unwind_find_by_frame (frame
, &frame
->prologue_cache
);
1968 return frame
->unwind
->type
;
1971 struct program_space
*
1972 get_frame_program_space (struct frame_info
*frame
)
1974 return frame
->pspace
;
1977 struct program_space
*
1978 frame_unwind_program_space (struct frame_info
*this_frame
)
1980 gdb_assert (this_frame
);
1982 /* This is really a placeholder to keep the API consistent --- we
1983 assume for now that we don't have frame chains crossing
1985 return this_frame
->pspace
;
1988 struct address_space
*
1989 get_frame_address_space (struct frame_info
*frame
)
1991 return frame
->aspace
;
1994 /* Memory access methods. */
1997 get_frame_memory (struct frame_info
*this_frame
, CORE_ADDR addr
,
1998 gdb_byte
*buf
, int len
)
2000 read_memory (addr
, buf
, len
);
2004 get_frame_memory_signed (struct frame_info
*this_frame
, CORE_ADDR addr
,
2007 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2008 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2009 return read_memory_integer (addr
, len
, byte_order
);
2013 get_frame_memory_unsigned (struct frame_info
*this_frame
, CORE_ADDR addr
,
2016 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2017 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2018 return read_memory_unsigned_integer (addr
, len
, byte_order
);
2022 safe_frame_unwind_memory (struct frame_info
*this_frame
,
2023 CORE_ADDR addr
, gdb_byte
*buf
, int len
)
2025 /* NOTE: target_read_memory returns zero on success! */
2026 return !target_read_memory (addr
, buf
, len
);
2029 /* Architecture methods. */
2032 get_frame_arch (struct frame_info
*this_frame
)
2034 return frame_unwind_arch (this_frame
->next
);
2038 frame_unwind_arch (struct frame_info
*next_frame
)
2040 if (!next_frame
->prev_arch
.p
)
2042 struct gdbarch
*arch
;
2044 if (next_frame
->unwind
== NULL
)
2046 = frame_unwind_find_by_frame (next_frame
,
2047 &next_frame
->prologue_cache
);
2049 if (next_frame
->unwind
->prev_arch
!= NULL
)
2050 arch
= next_frame
->unwind
->prev_arch (next_frame
,
2051 &next_frame
->prologue_cache
);
2053 arch
= get_frame_arch (next_frame
);
2055 next_frame
->prev_arch
.arch
= arch
;
2056 next_frame
->prev_arch
.p
= 1;
2058 fprintf_unfiltered (gdb_stdlog
,
2059 "{ frame_unwind_arch (next_frame=%d) -> %s }\n",
2061 gdbarch_bfd_arch_info (arch
)->printable_name
);
2064 return next_frame
->prev_arch
.arch
;
2068 frame_unwind_caller_arch (struct frame_info
*next_frame
)
2070 return frame_unwind_arch (skip_inlined_frames (next_frame
));
2073 /* Stack pointer methods. */
2076 get_frame_sp (struct frame_info
*this_frame
)
2078 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2079 /* Normality - an architecture that provides a way of obtaining any
2080 frame inner-most address. */
2081 if (gdbarch_unwind_sp_p (gdbarch
))
2082 /* NOTE drow/2008-06-28: gdbarch_unwind_sp could be converted to
2083 operate on THIS_FRAME now. */
2084 return gdbarch_unwind_sp (gdbarch
, this_frame
->next
);
2085 /* Now things are really are grim. Hope that the value returned by
2086 the gdbarch_sp_regnum register is meaningful. */
2087 if (gdbarch_sp_regnum (gdbarch
) >= 0)
2088 return get_frame_register_unsigned (this_frame
,
2089 gdbarch_sp_regnum (gdbarch
));
2090 internal_error (__FILE__
, __LINE__
, _("Missing unwind SP method"));
2093 /* Return the reason why we can't unwind past FRAME. */
2095 enum unwind_stop_reason
2096 get_frame_unwind_stop_reason (struct frame_info
*frame
)
2098 /* If we haven't tried to unwind past this point yet, then assume
2099 that unwinding would succeed. */
2100 if (frame
->prev_p
== 0)
2101 return UNWIND_NO_REASON
;
2103 /* Otherwise, we set a reason when we succeeded (or failed) to
2105 return frame
->stop_reason
;
2108 /* Return a string explaining REASON. */
2111 frame_stop_reason_string (enum unwind_stop_reason reason
)
2115 case UNWIND_NULL_ID
:
2116 return _("unwinder did not report frame ID");
2118 case UNWIND_INNER_ID
:
2119 return _("previous frame inner to this frame (corrupt stack?)");
2121 case UNWIND_SAME_ID
:
2122 return _("previous frame identical to this frame (corrupt stack?)");
2124 case UNWIND_NO_SAVED_PC
:
2125 return _("frame did not save the PC");
2127 case UNWIND_NO_REASON
:
2128 case UNWIND_FIRST_ERROR
:
2130 internal_error (__FILE__
, __LINE__
,
2131 "Invalid frame stop reason");
2135 /* Clean up after a failed (wrong unwinder) attempt to unwind past
2139 frame_cleanup_after_sniffer (void *arg
)
2141 struct frame_info
*frame
= arg
;
2143 /* The sniffer should not allocate a prologue cache if it did not
2144 match this frame. */
2145 gdb_assert (frame
->prologue_cache
== NULL
);
2147 /* No sniffer should extend the frame chain; sniff based on what is
2149 gdb_assert (!frame
->prev_p
);
2151 /* The sniffer should not check the frame's ID; that's circular. */
2152 gdb_assert (!frame
->this_id
.p
);
2154 /* Clear cached fields dependent on the unwinder.
2156 The previous PC is independent of the unwinder, but the previous
2157 function is not (see get_frame_address_in_block). */
2158 frame
->prev_func
.p
= 0;
2159 frame
->prev_func
.addr
= 0;
2161 /* Discard the unwinder last, so that we can easily find it if an assertion
2162 in this function triggers. */
2163 frame
->unwind
= NULL
;
2166 /* Set FRAME's unwinder temporarily, so that we can call a sniffer.
2167 Return a cleanup which should be called if unwinding fails, and
2168 discarded if it succeeds. */
2171 frame_prepare_for_sniffer (struct frame_info
*frame
,
2172 const struct frame_unwind
*unwind
)
2174 gdb_assert (frame
->unwind
== NULL
);
2175 frame
->unwind
= unwind
;
2176 return make_cleanup (frame_cleanup_after_sniffer
, frame
);
2179 extern initialize_file_ftype _initialize_frame
; /* -Wmissing-prototypes */
2181 static struct cmd_list_element
*set_backtrace_cmdlist
;
2182 static struct cmd_list_element
*show_backtrace_cmdlist
;
2185 set_backtrace_cmd (char *args
, int from_tty
)
2187 help_list (set_backtrace_cmdlist
, "set backtrace ", -1, gdb_stdout
);
2191 show_backtrace_cmd (char *args
, int from_tty
)
2193 cmd_show_list (show_backtrace_cmdlist
, from_tty
, "");
2197 _initialize_frame (void)
2199 obstack_init (&frame_cache_obstack
);
2201 observer_attach_target_changed (frame_observer_target_changed
);
2203 add_prefix_cmd ("backtrace", class_maintenance
, set_backtrace_cmd
, _("\
2204 Set backtrace specific variables.\n\
2205 Configure backtrace variables such as the backtrace limit"),
2206 &set_backtrace_cmdlist
, "set backtrace ",
2207 0/*allow-unknown*/, &setlist
);
2208 add_prefix_cmd ("backtrace", class_maintenance
, show_backtrace_cmd
, _("\
2209 Show backtrace specific variables\n\
2210 Show backtrace variables such as the backtrace limit"),
2211 &show_backtrace_cmdlist
, "show backtrace ",
2212 0/*allow-unknown*/, &showlist
);
2214 add_setshow_boolean_cmd ("past-main", class_obscure
,
2215 &backtrace_past_main
, _("\
2216 Set whether backtraces should continue past \"main\"."), _("\
2217 Show whether backtraces should continue past \"main\"."), _("\
2218 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
2219 the backtrace at \"main\". Set this variable if you need to see the rest\n\
2220 of the stack trace."),
2222 show_backtrace_past_main
,
2223 &set_backtrace_cmdlist
,
2224 &show_backtrace_cmdlist
);
2226 add_setshow_boolean_cmd ("past-entry", class_obscure
,
2227 &backtrace_past_entry
, _("\
2228 Set whether backtraces should continue past the entry point of a program."),
2230 Show whether backtraces should continue past the entry point of a program."),
2232 Normally there are no callers beyond the entry point of a program, so GDB\n\
2233 will terminate the backtrace there. Set this variable if you need to see \n\
2234 the rest of the stack trace."),
2236 show_backtrace_past_entry
,
2237 &set_backtrace_cmdlist
,
2238 &show_backtrace_cmdlist
);
2240 add_setshow_integer_cmd ("limit", class_obscure
,
2241 &backtrace_limit
, _("\
2242 Set an upper bound on the number of backtrace levels."), _("\
2243 Show the upper bound on the number of backtrace levels."), _("\
2244 No more than the specified number of frames can be displayed or examined.\n\
2245 Zero is unlimited."),
2247 show_backtrace_limit
,
2248 &set_backtrace_cmdlist
,
2249 &show_backtrace_cmdlist
);
2251 /* Debug this files internals. */
2252 add_setshow_zinteger_cmd ("frame", class_maintenance
, &frame_debug
, _("\
2253 Set frame debugging."), _("\
2254 Show frame debugging."), _("\
2255 When non-zero, frame specific internal debugging is enabled."),
2258 &setdebuglist
, &showdebuglist
);