1 /* Cache and manage frames for GDB, the GNU debugger.
3 Copyright (C) 1986-2016 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "inferior.h" /* for inferior_ptid */
26 #include "user-regs.h"
27 #include "gdb_obstack.h"
28 #include "dummy-frame.h"
29 #include "sentinel-frame.h"
33 #include "frame-unwind.h"
34 #include "frame-base.h"
39 #include "gdbthread.h"
41 #include "inline-frame.h"
42 #include "tracepoint.h"
46 static struct frame_info *get_prev_frame_raw (struct frame_info *this_frame);
47 static const char *frame_stop_reason_symbol_string (enum unwind_stop_reason reason);
49 /* Status of some values cached in the frame_info object. */
51 enum cached_copy_status
53 /* Value is unknown. */
56 /* We have a value. */
59 /* Value was not saved. */
62 /* Value is unavailable. */
66 /* We keep a cache of stack frames, each of which is a "struct
67 frame_info". The innermost one gets allocated (in
68 wait_for_inferior) each time the inferior stops; current_frame
69 points to it. Additional frames get allocated (in get_prev_frame)
70 as needed, and are chained through the next and prev fields. Any
71 time that the frame cache becomes invalid (most notably when we
72 execute something, but also if we change how we interpret the
73 frames (e.g. "set heuristic-fence-post" in mips-tdep.c, or anything
74 which reads new symbols)), we should call reinit_frame_cache. */
78 /* Level of this frame. The inner-most (youngest) frame is at level
79 0. As you move towards the outer-most (oldest) frame, the level
80 increases. This is a cached value. It could just as easily be
81 computed by counting back from the selected frame to the inner
83 /* NOTE: cagney/2002-04-05: Perhaps a level of ``-1'' should be
84 reserved to indicate a bogus frame - one that has been created
85 just to keep GDB happy (GDB always needs a frame). For the
86 moment leave this as speculation. */
89 /* The frame's program space. */
90 struct program_space *pspace;
92 /* The frame's address space. */
93 struct address_space *aspace;
95 /* The frame's low-level unwinder and corresponding cache. The
96 low-level unwinder is responsible for unwinding register values
97 for the previous frame. The low-level unwind methods are
98 selected based on the presence, or otherwise, of register unwind
99 information such as CFI. */
100 void *prologue_cache;
101 const struct frame_unwind *unwind;
103 /* Cached copy of the previous frame's architecture. */
107 struct gdbarch *arch;
110 /* Cached copy of the previous frame's resume address. */
112 enum cached_copy_status status;
116 /* Cached copy of the previous frame's function address. */
123 /* This frame's ID. */
127 struct frame_id value;
130 /* The frame's high-level base methods, and corresponding cache.
131 The high level base methods are selected based on the frame's
133 const struct frame_base *base;
136 /* Pointers to the next (down, inner, younger) and previous (up,
137 outer, older) frame_info's in the frame cache. */
138 struct frame_info *next; /* down, inner, younger */
140 struct frame_info *prev; /* up, outer, older */
142 /* The reason why we could not set PREV, or UNWIND_NO_REASON if we
143 could. Only valid when PREV_P is set. */
144 enum unwind_stop_reason stop_reason;
146 /* A frame specific string describing the STOP_REASON in more detail.
147 Only valid when PREV_P is set, but even then may still be NULL. */
148 const char *stop_string;
151 /* A frame stash used to speed up frame lookups. Create a hash table
152 to stash frames previously accessed from the frame cache for
153 quicker subsequent retrieval. The hash table is emptied whenever
154 the frame cache is invalidated. */
156 static htab_t frame_stash;
158 /* Internal function to calculate a hash from the frame_id addresses,
159 using as many valid addresses as possible. Frames below level 0
160 are not stored in the hash table. */
163 frame_addr_hash (const void *ap)
165 const struct frame_info *frame = (const struct frame_info *) ap;
166 const struct frame_id f_id = frame->this_id.value;
169 gdb_assert (f_id.stack_status != FID_STACK_INVALID
171 || f_id.special_addr_p);
173 if (f_id.stack_status == FID_STACK_VALID)
174 hash = iterative_hash (&f_id.stack_addr,
175 sizeof (f_id.stack_addr), hash);
176 if (f_id.code_addr_p)
177 hash = iterative_hash (&f_id.code_addr,
178 sizeof (f_id.code_addr), hash);
179 if (f_id.special_addr_p)
180 hash = iterative_hash (&f_id.special_addr,
181 sizeof (f_id.special_addr), hash);
186 /* Internal equality function for the hash table. This function
187 defers equality operations to frame_id_eq. */
190 frame_addr_hash_eq (const void *a, const void *b)
192 const struct frame_info *f_entry = (const struct frame_info *) a;
193 const struct frame_info *f_element = (const struct frame_info *) b;
195 return frame_id_eq (f_entry->this_id.value,
196 f_element->this_id.value);
199 /* Internal function to create the frame_stash hash table. 100 seems
200 to be a good compromise to start the hash table at. */
203 frame_stash_create (void)
205 frame_stash = htab_create (100,
211 /* Internal function to add a frame to the frame_stash hash table.
212 Returns false if a frame with the same ID was already stashed, true
216 frame_stash_add (struct frame_info *frame)
218 struct frame_info **slot;
220 /* Do not try to stash the sentinel frame. */
221 gdb_assert (frame->level >= 0);
223 slot = (struct frame_info **) htab_find_slot (frame_stash,
227 /* If we already have a frame in the stack with the same id, we
228 either have a stack cycle (corrupted stack?), or some bug
229 elsewhere in GDB. In any case, ignore the duplicate and return
230 an indication to the caller. */
238 /* Internal function to search the frame stash for an entry with the
239 given frame ID. If found, return that frame. Otherwise return
242 static struct frame_info *
243 frame_stash_find (struct frame_id id)
245 struct frame_info dummy;
246 struct frame_info *frame;
248 dummy.this_id.value = id;
249 frame = (struct frame_info *) htab_find (frame_stash, &dummy);
253 /* Internal function to invalidate the frame stash by removing all
254 entries in it. This only occurs when the frame cache is
258 frame_stash_invalidate (void)
260 htab_empty (frame_stash);
263 /* Flag to control debugging. */
265 unsigned int frame_debug;
267 show_frame_debug (struct ui_file *file, int from_tty,
268 struct cmd_list_element *c, const char *value)
270 fprintf_filtered (file, _("Frame debugging is %s.\n"), value);
273 /* Flag to indicate whether backtraces should stop at main et.al. */
275 static int backtrace_past_main;
277 show_backtrace_past_main (struct ui_file *file, int from_tty,
278 struct cmd_list_element *c, const char *value)
280 fprintf_filtered (file,
281 _("Whether backtraces should "
282 "continue past \"main\" is %s.\n"),
286 static int backtrace_past_entry;
288 show_backtrace_past_entry (struct ui_file *file, int from_tty,
289 struct cmd_list_element *c, const char *value)
291 fprintf_filtered (file, _("Whether backtraces should continue past the "
292 "entry point of a program is %s.\n"),
296 static unsigned int backtrace_limit = UINT_MAX;
298 show_backtrace_limit (struct ui_file *file, int from_tty,
299 struct cmd_list_element *c, const char *value)
301 fprintf_filtered (file,
302 _("An upper bound on the number "
303 "of backtrace levels is %s.\n"),
309 fprint_field (struct ui_file *file, const char *name, int p, CORE_ADDR addr)
312 fprintf_unfiltered (file, "%s=%s", name, hex_string (addr));
314 fprintf_unfiltered (file, "!%s", name);
318 fprint_frame_id (struct ui_file *file, struct frame_id id)
320 fprintf_unfiltered (file, "{");
322 if (id.stack_status == FID_STACK_INVALID)
323 fprintf_unfiltered (file, "!stack");
324 else if (id.stack_status == FID_STACK_UNAVAILABLE)
325 fprintf_unfiltered (file, "stack=<unavailable>");
327 fprintf_unfiltered (file, "stack=%s", hex_string (id.stack_addr));
328 fprintf_unfiltered (file, ",");
330 fprint_field (file, "code", id.code_addr_p, id.code_addr);
331 fprintf_unfiltered (file, ",");
333 fprint_field (file, "special", id.special_addr_p, id.special_addr);
335 if (id.artificial_depth)
336 fprintf_unfiltered (file, ",artificial=%d", id.artificial_depth);
338 fprintf_unfiltered (file, "}");
342 fprint_frame_type (struct ui_file *file, enum frame_type type)
347 fprintf_unfiltered (file, "NORMAL_FRAME");
350 fprintf_unfiltered (file, "DUMMY_FRAME");
353 fprintf_unfiltered (file, "INLINE_FRAME");
356 fprintf_unfiltered (file, "TAILCALL_FRAME");
359 fprintf_unfiltered (file, "SIGTRAMP_FRAME");
362 fprintf_unfiltered (file, "ARCH_FRAME");
365 fprintf_unfiltered (file, "SENTINEL_FRAME");
368 fprintf_unfiltered (file, "<unknown type>");
374 fprint_frame (struct ui_file *file, struct frame_info *fi)
378 fprintf_unfiltered (file, "<NULL frame>");
381 fprintf_unfiltered (file, "{");
382 fprintf_unfiltered (file, "level=%d", fi->level);
383 fprintf_unfiltered (file, ",");
384 fprintf_unfiltered (file, "type=");
385 if (fi->unwind != NULL)
386 fprint_frame_type (file, fi->unwind->type);
388 fprintf_unfiltered (file, "<unknown>");
389 fprintf_unfiltered (file, ",");
390 fprintf_unfiltered (file, "unwind=");
391 if (fi->unwind != NULL)
392 gdb_print_host_address (fi->unwind, file);
394 fprintf_unfiltered (file, "<unknown>");
395 fprintf_unfiltered (file, ",");
396 fprintf_unfiltered (file, "pc=");
397 if (fi->next == NULL || fi->next->prev_pc.status == CC_UNKNOWN)
398 fprintf_unfiltered (file, "<unknown>");
399 else if (fi->next->prev_pc.status == CC_VALUE)
400 fprintf_unfiltered (file, "%s",
401 hex_string (fi->next->prev_pc.value));
402 else if (fi->next->prev_pc.status == CC_NOT_SAVED)
403 val_print_not_saved (file);
404 else if (fi->next->prev_pc.status == CC_UNAVAILABLE)
405 val_print_unavailable (file);
406 fprintf_unfiltered (file, ",");
407 fprintf_unfiltered (file, "id=");
409 fprint_frame_id (file, fi->this_id.value);
411 fprintf_unfiltered (file, "<unknown>");
412 fprintf_unfiltered (file, ",");
413 fprintf_unfiltered (file, "func=");
414 if (fi->next != NULL && fi->next->prev_func.p)
415 fprintf_unfiltered (file, "%s", hex_string (fi->next->prev_func.addr));
417 fprintf_unfiltered (file, "<unknown>");
418 fprintf_unfiltered (file, "}");
421 /* Given FRAME, return the enclosing frame as found in real frames read-in from
422 inferior memory. Skip any previous frames which were made up by GDB.
423 Return FRAME if FRAME is a non-artificial frame.
424 Return NULL if FRAME is the start of an artificial-only chain. */
426 static struct frame_info *
427 skip_artificial_frames (struct frame_info *frame)
429 /* Note we use get_prev_frame_always, and not get_prev_frame. The
430 latter will truncate the frame chain, leading to this function
431 unintentionally returning a null_frame_id (e.g., when the user
432 sets a backtrace limit).
434 Note that for record targets we may get a frame chain that consists
435 of artificial frames only. */
436 while (get_frame_type (frame) == INLINE_FRAME
437 || get_frame_type (frame) == TAILCALL_FRAME)
439 frame = get_prev_frame_always (frame);
448 skip_unwritable_frames (struct frame_info *frame)
450 while (gdbarch_code_of_frame_writable (get_frame_arch (frame), frame) == 0)
452 frame = get_prev_frame (frame);
463 skip_tailcall_frames (struct frame_info *frame)
465 while (get_frame_type (frame) == TAILCALL_FRAME)
467 /* Note that for record targets we may get a frame chain that consists of
468 tailcall frames only. */
469 frame = get_prev_frame (frame);
477 /* Compute the frame's uniq ID that can be used to, later, re-find the
481 compute_frame_id (struct frame_info *fi)
483 gdb_assert (!fi->this_id.p);
486 fprintf_unfiltered (gdb_stdlog, "{ compute_frame_id (fi=%d) ",
488 /* Find the unwinder. */
489 if (fi->unwind == NULL)
490 frame_unwind_find_by_frame (fi, &fi->prologue_cache);
491 /* Find THIS frame's ID. */
492 /* Default to outermost if no ID is found. */
493 fi->this_id.value = outer_frame_id;
494 fi->unwind->this_id (fi, &fi->prologue_cache, &fi->this_id.value);
495 gdb_assert (frame_id_p (fi->this_id.value));
499 fprintf_unfiltered (gdb_stdlog, "-> ");
500 fprint_frame_id (gdb_stdlog, fi->this_id.value);
501 fprintf_unfiltered (gdb_stdlog, " }\n");
505 /* Return a frame uniq ID that can be used to, later, re-find the
509 get_frame_id (struct frame_info *fi)
512 return null_frame_id;
514 gdb_assert (fi->this_id.p);
515 return fi->this_id.value;
519 get_stack_frame_id (struct frame_info *next_frame)
521 return get_frame_id (skip_artificial_frames (next_frame));
525 frame_unwind_caller_id (struct frame_info *next_frame)
527 struct frame_info *this_frame;
529 /* Use get_prev_frame_always, and not get_prev_frame. The latter
530 will truncate the frame chain, leading to this function
531 unintentionally returning a null_frame_id (e.g., when a caller
532 requests the frame ID of "main()"s caller. */
534 next_frame = skip_artificial_frames (next_frame);
535 if (next_frame == NULL)
536 return null_frame_id;
538 this_frame = get_prev_frame_always (next_frame);
540 return get_frame_id (skip_artificial_frames (this_frame));
542 return null_frame_id;
545 const struct frame_id null_frame_id = { 0 }; /* All zeros. */
546 const struct frame_id outer_frame_id = { 0, 0, 0, FID_STACK_INVALID, 0, 1, 0 };
549 frame_id_build_special (CORE_ADDR stack_addr, CORE_ADDR code_addr,
550 CORE_ADDR special_addr)
552 struct frame_id id = null_frame_id;
554 id.stack_addr = stack_addr;
555 id.stack_status = FID_STACK_VALID;
556 id.code_addr = code_addr;
558 id.special_addr = special_addr;
559 id.special_addr_p = 1;
566 frame_id_build_unavailable_stack (CORE_ADDR code_addr)
568 struct frame_id id = null_frame_id;
570 id.stack_status = FID_STACK_UNAVAILABLE;
571 id.code_addr = code_addr;
579 frame_id_build_unavailable_stack_special (CORE_ADDR code_addr,
580 CORE_ADDR special_addr)
582 struct frame_id id = null_frame_id;
584 id.stack_status = FID_STACK_UNAVAILABLE;
585 id.code_addr = code_addr;
587 id.special_addr = special_addr;
588 id.special_addr_p = 1;
593 frame_id_build (CORE_ADDR stack_addr, CORE_ADDR code_addr)
595 struct frame_id id = null_frame_id;
597 id.stack_addr = stack_addr;
598 id.stack_status = FID_STACK_VALID;
599 id.code_addr = code_addr;
605 frame_id_build_wild (CORE_ADDR stack_addr)
607 struct frame_id id = null_frame_id;
609 id.stack_addr = stack_addr;
610 id.stack_status = FID_STACK_VALID;
615 frame_id_p (struct frame_id l)
619 /* The frame is valid iff it has a valid stack address. */
620 p = l.stack_status != FID_STACK_INVALID;
621 /* outer_frame_id is also valid. */
622 if (!p && memcmp (&l, &outer_frame_id, sizeof (l)) == 0)
626 fprintf_unfiltered (gdb_stdlog, "{ frame_id_p (l=");
627 fprint_frame_id (gdb_stdlog, l);
628 fprintf_unfiltered (gdb_stdlog, ") -> %d }\n", p);
634 frame_id_artificial_p (struct frame_id l)
639 return (l.artificial_depth != 0);
643 frame_id_eq (struct frame_id l, struct frame_id r)
647 if (l.stack_status == FID_STACK_INVALID && l.special_addr_p
648 && r.stack_status == FID_STACK_INVALID && r.special_addr_p)
649 /* The outermost frame marker is equal to itself. This is the
650 dodgy thing about outer_frame_id, since between execution steps
651 we might step into another function - from which we can't
652 unwind either. More thought required to get rid of
655 else if (l.stack_status == FID_STACK_INVALID
656 || r.stack_status == FID_STACK_INVALID)
657 /* Like a NaN, if either ID is invalid, the result is false.
658 Note that a frame ID is invalid iff it is the null frame ID. */
660 else if (l.stack_status != r.stack_status || l.stack_addr != r.stack_addr)
661 /* If .stack addresses are different, the frames are different. */
663 else if (l.code_addr_p && r.code_addr_p && l.code_addr != r.code_addr)
664 /* An invalid code addr is a wild card. If .code addresses are
665 different, the frames are different. */
667 else if (l.special_addr_p && r.special_addr_p
668 && l.special_addr != r.special_addr)
669 /* An invalid special addr is a wild card (or unused). Otherwise
670 if special addresses are different, the frames are different. */
672 else if (l.artificial_depth != r.artificial_depth)
673 /* If artifical depths are different, the frames must be different. */
676 /* Frames are equal. */
681 fprintf_unfiltered (gdb_stdlog, "{ frame_id_eq (l=");
682 fprint_frame_id (gdb_stdlog, l);
683 fprintf_unfiltered (gdb_stdlog, ",r=");
684 fprint_frame_id (gdb_stdlog, r);
685 fprintf_unfiltered (gdb_stdlog, ") -> %d }\n", eq);
690 /* Safety net to check whether frame ID L should be inner to
691 frame ID R, according to their stack addresses.
693 This method cannot be used to compare arbitrary frames, as the
694 ranges of valid stack addresses may be discontiguous (e.g. due
697 However, it can be used as safety net to discover invalid frame
698 IDs in certain circumstances. Assuming that NEXT is the immediate
699 inner frame to THIS and that NEXT and THIS are both NORMAL frames:
701 * The stack address of NEXT must be inner-than-or-equal to the stack
704 Therefore, if frame_id_inner (THIS, NEXT) holds, some unwind
707 * If NEXT and THIS have different stack addresses, no other frame
708 in the frame chain may have a stack address in between.
710 Therefore, if frame_id_inner (TEST, THIS) holds, but
711 frame_id_inner (TEST, NEXT) does not hold, TEST cannot refer
712 to a valid frame in the frame chain.
714 The sanity checks above cannot be performed when a SIGTRAMP frame
715 is involved, because signal handlers might be executed on a different
716 stack than the stack used by the routine that caused the signal
717 to be raised. This can happen for instance when a thread exceeds
718 its maximum stack size. In this case, certain compilers implement
719 a stack overflow strategy that cause the handler to be run on a
723 frame_id_inner (struct gdbarch *gdbarch, struct frame_id l, struct frame_id r)
727 if (l.stack_status != FID_STACK_VALID || r.stack_status != FID_STACK_VALID)
728 /* Like NaN, any operation involving an invalid ID always fails.
729 Likewise if either ID has an unavailable stack address. */
731 else if (l.artificial_depth > r.artificial_depth
732 && l.stack_addr == r.stack_addr
733 && l.code_addr_p == r.code_addr_p
734 && l.special_addr_p == r.special_addr_p
735 && l.special_addr == r.special_addr)
737 /* Same function, different inlined functions. */
738 const struct block *lb, *rb;
740 gdb_assert (l.code_addr_p && r.code_addr_p);
742 lb = block_for_pc (l.code_addr);
743 rb = block_for_pc (r.code_addr);
745 if (lb == NULL || rb == NULL)
746 /* Something's gone wrong. */
749 /* This will return true if LB and RB are the same block, or
750 if the block with the smaller depth lexically encloses the
751 block with the greater depth. */
752 inner = contained_in (lb, rb);
755 /* Only return non-zero when strictly inner than. Note that, per
756 comment in "frame.h", there is some fuzz here. Frameless
757 functions are not strictly inner than (same .stack but
758 different .code and/or .special address). */
759 inner = gdbarch_inner_than (gdbarch, l.stack_addr, r.stack_addr);
762 fprintf_unfiltered (gdb_stdlog, "{ frame_id_inner (l=");
763 fprint_frame_id (gdb_stdlog, l);
764 fprintf_unfiltered (gdb_stdlog, ",r=");
765 fprint_frame_id (gdb_stdlog, r);
766 fprintf_unfiltered (gdb_stdlog, ") -> %d }\n", inner);
772 frame_find_by_id (struct frame_id id)
774 struct frame_info *frame, *prev_frame;
776 /* ZERO denotes the null frame, let the caller decide what to do
777 about it. Should it instead return get_current_frame()? */
778 if (!frame_id_p (id))
781 /* Try using the frame stash first. Finding it there removes the need
782 to perform the search by looping over all frames, which can be very
783 CPU-intensive if the number of frames is very high (the loop is O(n)
784 and get_prev_frame performs a series of checks that are relatively
785 expensive). This optimization is particularly useful when this function
786 is called from another function (such as value_fetch_lazy, case
787 VALUE_LVAL (val) == lval_register) which already loops over all frames,
788 making the overall behavior O(n^2). */
789 frame = frame_stash_find (id);
793 for (frame = get_current_frame (); ; frame = prev_frame)
795 struct frame_id self = get_frame_id (frame);
797 if (frame_id_eq (id, self))
798 /* An exact match. */
801 prev_frame = get_prev_frame (frame);
805 /* As a safety net to avoid unnecessary backtracing while trying
806 to find an invalid ID, we check for a common situation where
807 we can detect from comparing stack addresses that no other
808 frame in the current frame chain can have this ID. See the
809 comment at frame_id_inner for details. */
810 if (get_frame_type (frame) == NORMAL_FRAME
811 && !frame_id_inner (get_frame_arch (frame), id, self)
812 && frame_id_inner (get_frame_arch (prev_frame), id,
813 get_frame_id (prev_frame)))
820 frame_unwind_pc (struct frame_info *this_frame)
822 if (this_frame->prev_pc.status == CC_UNKNOWN)
824 if (gdbarch_unwind_pc_p (frame_unwind_arch (this_frame)))
826 struct gdbarch *prev_gdbarch;
830 /* The right way. The `pure' way. The one true way. This
831 method depends solely on the register-unwind code to
832 determine the value of registers in THIS frame, and hence
833 the value of this frame's PC (resume address). A typical
834 implementation is no more than:
836 frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
837 return extract_unsigned_integer (buf, size of ISA_PC_REGNUM);
839 Note: this method is very heavily dependent on a correct
840 register-unwind implementation, it pays to fix that
841 method first; this method is frame type agnostic, since
842 it only deals with register values, it works with any
843 frame. This is all in stark contrast to the old
844 FRAME_SAVED_PC which would try to directly handle all the
845 different ways that a PC could be unwound. */
846 prev_gdbarch = frame_unwind_arch (this_frame);
850 pc = gdbarch_unwind_pc (prev_gdbarch, this_frame);
853 CATCH (ex, RETURN_MASK_ERROR)
855 if (ex.error == NOT_AVAILABLE_ERROR)
857 this_frame->prev_pc.status = CC_UNAVAILABLE;
860 fprintf_unfiltered (gdb_stdlog,
861 "{ frame_unwind_pc (this_frame=%d)"
862 " -> <unavailable> }\n",
865 else if (ex.error == OPTIMIZED_OUT_ERROR)
867 this_frame->prev_pc.status = CC_NOT_SAVED;
870 fprintf_unfiltered (gdb_stdlog,
871 "{ frame_unwind_pc (this_frame=%d)"
872 " -> <not saved> }\n",
876 throw_exception (ex);
882 this_frame->prev_pc.value = pc;
883 this_frame->prev_pc.status = CC_VALUE;
885 fprintf_unfiltered (gdb_stdlog,
886 "{ frame_unwind_pc (this_frame=%d) "
889 hex_string (this_frame->prev_pc.value));
893 internal_error (__FILE__, __LINE__, _("No unwind_pc method"));
896 if (this_frame->prev_pc.status == CC_VALUE)
897 return this_frame->prev_pc.value;
898 else if (this_frame->prev_pc.status == CC_UNAVAILABLE)
899 throw_error (NOT_AVAILABLE_ERROR, _("PC not available"));
900 else if (this_frame->prev_pc.status == CC_NOT_SAVED)
901 throw_error (OPTIMIZED_OUT_ERROR, _("PC not saved"));
903 internal_error (__FILE__, __LINE__,
904 "unexpected prev_pc status: %d",
905 (int) this_frame->prev_pc.status);
909 frame_unwind_caller_pc (struct frame_info *this_frame)
911 this_frame = skip_artificial_frames (this_frame);
913 /* We must have a non-artificial frame. The caller is supposed to check
914 the result of frame_unwind_caller_id (), which returns NULL_FRAME_ID
916 gdb_assert (this_frame != NULL);
918 return frame_unwind_pc (this_frame);
922 get_frame_func_if_available (struct frame_info *this_frame, CORE_ADDR *pc)
924 struct frame_info *next_frame = this_frame->next;
926 if (!next_frame->prev_func.p)
928 CORE_ADDR addr_in_block;
930 /* Make certain that this, and not the adjacent, function is
932 if (!get_frame_address_in_block_if_available (this_frame, &addr_in_block))
934 next_frame->prev_func.p = -1;
936 fprintf_unfiltered (gdb_stdlog,
937 "{ get_frame_func (this_frame=%d)"
938 " -> unavailable }\n",
943 next_frame->prev_func.p = 1;
944 next_frame->prev_func.addr = get_pc_function_start (addr_in_block);
946 fprintf_unfiltered (gdb_stdlog,
947 "{ get_frame_func (this_frame=%d) -> %s }\n",
949 hex_string (next_frame->prev_func.addr));
953 if (next_frame->prev_func.p < 0)
960 *pc = next_frame->prev_func.addr;
966 get_frame_func (struct frame_info *this_frame)
970 if (!get_frame_func_if_available (this_frame, &pc))
971 throw_error (NOT_AVAILABLE_ERROR, _("PC not available"));
976 static enum register_status
977 do_frame_register_read (void *src, int regnum, gdb_byte *buf)
979 if (!deprecated_frame_register_read ((struct frame_info *) src, regnum, buf))
980 return REG_UNAVAILABLE;
986 frame_save_as_regcache (struct frame_info *this_frame)
988 struct address_space *aspace = get_frame_address_space (this_frame);
989 struct regcache *regcache = regcache_xmalloc (get_frame_arch (this_frame),
991 struct cleanup *cleanups = make_cleanup_regcache_xfree (regcache);
993 regcache_save (regcache, do_frame_register_read, this_frame);
994 discard_cleanups (cleanups);
999 frame_pop (struct frame_info *this_frame)
1001 struct frame_info *prev_frame;
1002 struct regcache *scratch;
1003 struct cleanup *cleanups;
1005 if (get_frame_type (this_frame) == DUMMY_FRAME)
1007 /* Popping a dummy frame involves restoring more than just registers.
1008 dummy_frame_pop does all the work. */
1009 dummy_frame_pop (get_frame_id (this_frame), inferior_ptid);
1013 /* Ensure that we have a frame to pop to. */
1014 prev_frame = get_prev_frame_always (this_frame);
1017 error (_("Cannot pop the initial frame."));
1019 /* Ignore TAILCALL_FRAME type frames, they were executed already before
1020 entering THISFRAME. */
1021 prev_frame = skip_tailcall_frames (prev_frame);
1023 if (prev_frame == NULL)
1024 error (_("Cannot find the caller frame."));
1026 /* Make a copy of all the register values unwound from this frame.
1027 Save them in a scratch buffer so that there isn't a race between
1028 trying to extract the old values from the current regcache while
1029 at the same time writing new values into that same cache. */
1030 scratch = frame_save_as_regcache (prev_frame);
1031 cleanups = make_cleanup_regcache_xfree (scratch);
1033 /* FIXME: cagney/2003-03-16: It should be possible to tell the
1034 target's register cache that it is about to be hit with a burst
1035 register transfer and that the sequence of register writes should
1036 be batched. The pair target_prepare_to_store() and
1037 target_store_registers() kind of suggest this functionality.
1038 Unfortunately, they don't implement it. Their lack of a formal
1039 definition can lead to targets writing back bogus values
1040 (arguably a bug in the target code mind). */
1041 /* Now copy those saved registers into the current regcache.
1042 Here, regcache_cpy() calls regcache_restore(). */
1043 regcache_cpy (get_current_regcache (), scratch);
1044 do_cleanups (cleanups);
1046 /* We've made right mess of GDB's local state, just discard
1048 reinit_frame_cache ();
1052 frame_register_unwind (struct frame_info *frame, int regnum,
1053 int *optimizedp, int *unavailablep,
1054 enum lval_type *lvalp, CORE_ADDR *addrp,
1055 int *realnump, gdb_byte *bufferp)
1057 struct value *value;
1059 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
1060 that the value proper does not need to be fetched. */
1061 gdb_assert (optimizedp != NULL);
1062 gdb_assert (lvalp != NULL);
1063 gdb_assert (addrp != NULL);
1064 gdb_assert (realnump != NULL);
1065 /* gdb_assert (bufferp != NULL); */
1067 value = frame_unwind_register_value (frame, regnum);
1069 gdb_assert (value != NULL);
1071 *optimizedp = value_optimized_out (value);
1072 *unavailablep = !value_entirely_available (value);
1073 *lvalp = VALUE_LVAL (value);
1074 *addrp = value_address (value);
1075 *realnump = VALUE_REGNUM (value);
1079 if (!*optimizedp && !*unavailablep)
1080 memcpy (bufferp, value_contents_all (value),
1081 TYPE_LENGTH (value_type (value)));
1083 memset (bufferp, 0, TYPE_LENGTH (value_type (value)));
1086 /* Dispose of the new value. This prevents watchpoints from
1087 trying to watch the saved frame pointer. */
1088 release_value (value);
1093 frame_register (struct frame_info *frame, int regnum,
1094 int *optimizedp, int *unavailablep, enum lval_type *lvalp,
1095 CORE_ADDR *addrp, int *realnump, gdb_byte *bufferp)
1097 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
1098 that the value proper does not need to be fetched. */
1099 gdb_assert (optimizedp != NULL);
1100 gdb_assert (lvalp != NULL);
1101 gdb_assert (addrp != NULL);
1102 gdb_assert (realnump != NULL);
1103 /* gdb_assert (bufferp != NULL); */
1105 /* Obtain the register value by unwinding the register from the next
1106 (more inner frame). */
1107 gdb_assert (frame != NULL && frame->next != NULL);
1108 frame_register_unwind (frame->next, regnum, optimizedp, unavailablep,
1109 lvalp, addrp, realnump, bufferp);
1113 frame_unwind_register (struct frame_info *frame, int regnum, gdb_byte *buf)
1119 enum lval_type lval;
1121 frame_register_unwind (frame, regnum, &optimized, &unavailable,
1122 &lval, &addr, &realnum, buf);
1125 throw_error (OPTIMIZED_OUT_ERROR,
1126 _("Register %d was not saved"), regnum);
1128 throw_error (NOT_AVAILABLE_ERROR,
1129 _("Register %d is not available"), regnum);
1133 get_frame_register (struct frame_info *frame,
1134 int regnum, gdb_byte *buf)
1136 frame_unwind_register (frame->next, regnum, buf);
1140 frame_unwind_register_value (struct frame_info *frame, int regnum)
1142 struct gdbarch *gdbarch;
1143 struct value *value;
1145 gdb_assert (frame != NULL);
1146 gdbarch = frame_unwind_arch (frame);
1150 fprintf_unfiltered (gdb_stdlog,
1151 "{ frame_unwind_register_value "
1152 "(frame=%d,regnum=%d(%s),...) ",
1153 frame->level, regnum,
1154 user_reg_map_regnum_to_name (gdbarch, regnum));
1157 /* Find the unwinder. */
1158 if (frame->unwind == NULL)
1159 frame_unwind_find_by_frame (frame, &frame->prologue_cache);
1161 /* Ask this frame to unwind its register. */
1162 value = frame->unwind->prev_register (frame, &frame->prologue_cache, regnum);
1166 fprintf_unfiltered (gdb_stdlog, "->");
1167 if (value_optimized_out (value))
1169 fprintf_unfiltered (gdb_stdlog, " ");
1170 val_print_optimized_out (value, gdb_stdlog);
1174 if (VALUE_LVAL (value) == lval_register)
1175 fprintf_unfiltered (gdb_stdlog, " register=%d",
1176 VALUE_REGNUM (value));
1177 else if (VALUE_LVAL (value) == lval_memory)
1178 fprintf_unfiltered (gdb_stdlog, " address=%s",
1180 value_address (value)));
1182 fprintf_unfiltered (gdb_stdlog, " computed");
1184 if (value_lazy (value))
1185 fprintf_unfiltered (gdb_stdlog, " lazy");
1189 const gdb_byte *buf = value_contents (value);
1191 fprintf_unfiltered (gdb_stdlog, " bytes=");
1192 fprintf_unfiltered (gdb_stdlog, "[");
1193 for (i = 0; i < register_size (gdbarch, regnum); i++)
1194 fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
1195 fprintf_unfiltered (gdb_stdlog, "]");
1199 fprintf_unfiltered (gdb_stdlog, " }\n");
1206 get_frame_register_value (struct frame_info *frame, int regnum)
1208 return frame_unwind_register_value (frame->next, regnum);
1212 frame_unwind_register_signed (struct frame_info *frame, int regnum)
1214 struct gdbarch *gdbarch = frame_unwind_arch (frame);
1215 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1216 int size = register_size (gdbarch, regnum);
1217 gdb_byte buf[MAX_REGISTER_SIZE];
1219 frame_unwind_register (frame, regnum, buf);
1220 return extract_signed_integer (buf, size, byte_order);
1224 get_frame_register_signed (struct frame_info *frame, int regnum)
1226 return frame_unwind_register_signed (frame->next, regnum);
1230 frame_unwind_register_unsigned (struct frame_info *frame, int regnum)
1232 struct gdbarch *gdbarch = frame_unwind_arch (frame);
1233 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1234 int size = register_size (gdbarch, regnum);
1235 gdb_byte buf[MAX_REGISTER_SIZE];
1237 frame_unwind_register (frame, regnum, buf);
1238 return extract_unsigned_integer (buf, size, byte_order);
1242 get_frame_register_unsigned (struct frame_info *frame, int regnum)
1244 return frame_unwind_register_unsigned (frame->next, regnum);
1248 read_frame_register_unsigned (struct frame_info *frame, int regnum,
1251 struct value *regval = get_frame_register_value (frame, regnum);
1253 if (!value_optimized_out (regval)
1254 && value_entirely_available (regval))
1256 struct gdbarch *gdbarch = get_frame_arch (frame);
1257 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1258 int size = register_size (gdbarch, VALUE_REGNUM (regval));
1260 *val = extract_unsigned_integer (value_contents (regval), size, byte_order);
1268 put_frame_register (struct frame_info *frame, int regnum,
1269 const gdb_byte *buf)
1271 struct gdbarch *gdbarch = get_frame_arch (frame);
1275 enum lval_type lval;
1278 frame_register (frame, regnum, &optim, &unavail,
1279 &lval, &addr, &realnum, NULL);
1281 error (_("Attempt to assign to a register that was not saved."));
1286 write_memory (addr, buf, register_size (gdbarch, regnum));
1290 regcache_cooked_write (get_current_regcache (), realnum, buf);
1293 error (_("Attempt to assign to an unmodifiable value."));
1297 /* This function is deprecated. Use get_frame_register_value instead,
1298 which provides more accurate information.
1300 Find and return the value of REGNUM for the specified stack frame.
1301 The number of bytes copied is REGISTER_SIZE (REGNUM).
1303 Returns 0 if the register value could not be found. */
1306 deprecated_frame_register_read (struct frame_info *frame, int regnum,
1311 enum lval_type lval;
1315 frame_register (frame, regnum, &optimized, &unavailable,
1316 &lval, &addr, &realnum, myaddr);
1318 return !optimized && !unavailable;
1322 get_frame_register_bytes (struct frame_info *frame, int regnum,
1323 CORE_ADDR offset, int len, gdb_byte *myaddr,
1324 int *optimizedp, int *unavailablep)
1326 struct gdbarch *gdbarch = get_frame_arch (frame);
1331 /* Skip registers wholly inside of OFFSET. */
1332 while (offset >= register_size (gdbarch, regnum))
1334 offset -= register_size (gdbarch, regnum);
1338 /* Ensure that we will not read beyond the end of the register file.
1339 This can only ever happen if the debug information is bad. */
1341 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1342 for (i = regnum; i < numregs; i++)
1344 int thissize = register_size (gdbarch, i);
1347 break; /* This register is not available on this architecture. */
1348 maxsize += thissize;
1351 error (_("Bad debug information detected: "
1352 "Attempt to read %d bytes from registers."), len);
1354 /* Copy the data. */
1357 int curr_len = register_size (gdbarch, regnum) - offset;
1362 if (curr_len == register_size (gdbarch, regnum))
1364 enum lval_type lval;
1368 frame_register (frame, regnum, optimizedp, unavailablep,
1369 &lval, &addr, &realnum, myaddr);
1370 if (*optimizedp || *unavailablep)
1375 gdb_byte buf[MAX_REGISTER_SIZE];
1376 enum lval_type lval;
1380 frame_register (frame, regnum, optimizedp, unavailablep,
1381 &lval, &addr, &realnum, buf);
1382 if (*optimizedp || *unavailablep)
1384 memcpy (myaddr, buf + offset, curr_len);
1399 put_frame_register_bytes (struct frame_info *frame, int regnum,
1400 CORE_ADDR offset, int len, const gdb_byte *myaddr)
1402 struct gdbarch *gdbarch = get_frame_arch (frame);
1404 /* Skip registers wholly inside of OFFSET. */
1405 while (offset >= register_size (gdbarch, regnum))
1407 offset -= register_size (gdbarch, regnum);
1411 /* Copy the data. */
1414 int curr_len = register_size (gdbarch, regnum) - offset;
1419 if (curr_len == register_size (gdbarch, regnum))
1421 put_frame_register (frame, regnum, myaddr);
1425 gdb_byte buf[MAX_REGISTER_SIZE];
1427 deprecated_frame_register_read (frame, regnum, buf);
1428 memcpy (buf + offset, myaddr, curr_len);
1429 put_frame_register (frame, regnum, buf);
1439 /* Create a sentinel frame. */
1441 static struct frame_info *
1442 create_sentinel_frame (struct program_space *pspace, struct regcache *regcache)
1444 struct frame_info *frame = FRAME_OBSTACK_ZALLOC (struct frame_info);
1447 frame->pspace = pspace;
1448 frame->aspace = get_regcache_aspace (regcache);
1449 /* Explicitly initialize the sentinel frame's cache. Provide it
1450 with the underlying regcache. In the future additional
1451 information, such as the frame's thread will be added. */
1452 frame->prologue_cache = sentinel_frame_cache (regcache);
1453 /* For the moment there is only one sentinel frame implementation. */
1454 frame->unwind = &sentinel_frame_unwind;
1455 /* Link this frame back to itself. The frame is self referential
1456 (the unwound PC is the same as the pc), so make it so. */
1457 frame->next = frame;
1458 /* Make the sentinel frame's ID valid, but invalid. That way all
1459 comparisons with it should fail. */
1460 frame->this_id.p = 1;
1461 frame->this_id.value = null_frame_id;
1464 fprintf_unfiltered (gdb_stdlog, "{ create_sentinel_frame (...) -> ");
1465 fprint_frame (gdb_stdlog, frame);
1466 fprintf_unfiltered (gdb_stdlog, " }\n");
1471 /* Info about the innermost stack frame (contents of FP register). */
1473 static struct frame_info *current_frame;
1475 /* Cache for frame addresses already read by gdb. Valid only while
1476 inferior is stopped. Control variables for the frame cache should
1477 be local to this module. */
1479 static struct obstack frame_cache_obstack;
1482 frame_obstack_zalloc (unsigned long size)
1484 void *data = obstack_alloc (&frame_cache_obstack, size);
1486 memset (data, 0, size);
1490 /* Return the innermost (currently executing) stack frame. This is
1491 split into two functions. The function unwind_to_current_frame()
1492 is wrapped in catch exceptions so that, even when the unwind of the
1493 sentinel frame fails, the function still returns a stack frame. */
1496 unwind_to_current_frame (struct ui_out *ui_out, void *args)
1498 struct frame_info *frame = get_prev_frame ((struct frame_info *) args);
1500 /* A sentinel frame can fail to unwind, e.g., because its PC value
1501 lands in somewhere like start. */
1504 current_frame = frame;
1509 get_current_frame (void)
1511 /* First check, and report, the lack of registers. Having GDB
1512 report "No stack!" or "No memory" when the target doesn't even
1513 have registers is very confusing. Besides, "printcmd.exp"
1514 explicitly checks that ``print $pc'' with no registers prints "No
1516 if (!target_has_registers)
1517 error (_("No registers."));
1518 if (!target_has_stack)
1519 error (_("No stack."));
1520 if (!target_has_memory)
1521 error (_("No memory."));
1522 /* Traceframes are effectively a substitute for the live inferior. */
1523 if (get_traceframe_number () < 0)
1524 validate_registers_access ();
1526 if (current_frame == NULL)
1528 struct frame_info *sentinel_frame =
1529 create_sentinel_frame (current_program_space, get_current_regcache ());
1530 if (catch_exceptions (current_uiout, unwind_to_current_frame,
1531 sentinel_frame, RETURN_MASK_ERROR) != 0)
1533 /* Oops! Fake a current frame? Is this useful? It has a PC
1534 of zero, for instance. */
1535 current_frame = sentinel_frame;
1538 return current_frame;
1541 /* The "selected" stack frame is used by default for local and arg
1542 access. May be zero, for no selected frame. */
1544 static struct frame_info *selected_frame;
1547 has_stack_frames (void)
1549 if (!target_has_registers || !target_has_stack || !target_has_memory)
1552 /* Traceframes are effectively a substitute for the live inferior. */
1553 if (get_traceframe_number () < 0)
1555 /* No current inferior, no frame. */
1556 if (ptid_equal (inferior_ptid, null_ptid))
1559 /* Don't try to read from a dead thread. */
1560 if (is_exited (inferior_ptid))
1563 /* ... or from a spinning thread. */
1564 if (is_executing (inferior_ptid))
1571 /* Return the selected frame. Always non-NULL (unless there isn't an
1572 inferior sufficient for creating a frame) in which case an error is
1576 get_selected_frame (const char *message)
1578 if (selected_frame == NULL)
1580 if (message != NULL && !has_stack_frames ())
1581 error (("%s"), message);
1582 /* Hey! Don't trust this. It should really be re-finding the
1583 last selected frame of the currently selected thread. This,
1584 though, is better than nothing. */
1585 select_frame (get_current_frame ());
1587 /* There is always a frame. */
1588 gdb_assert (selected_frame != NULL);
1589 return selected_frame;
1592 /* If there is a selected frame, return it. Otherwise, return NULL. */
1595 get_selected_frame_if_set (void)
1597 return selected_frame;
1600 /* This is a variant of get_selected_frame() which can be called when
1601 the inferior does not have a frame; in that case it will return
1602 NULL instead of calling error(). */
1605 deprecated_safe_get_selected_frame (void)
1607 if (!has_stack_frames ())
1609 return get_selected_frame (NULL);
1612 /* Select frame FI (or NULL - to invalidate the current frame). */
1615 select_frame (struct frame_info *fi)
1617 selected_frame = fi;
1618 /* NOTE: cagney/2002-05-04: FI can be NULL. This occurs when the
1619 frame is being invalidated. */
1621 /* FIXME: kseitz/2002-08-28: It would be nice to call
1622 selected_frame_level_changed_event() right here, but due to limitations
1623 in the current interfaces, we would end up flooding UIs with events
1624 because select_frame() is used extensively internally.
1626 Once we have frame-parameterized frame (and frame-related) commands,
1627 the event notification can be moved here, since this function will only
1628 be called when the user's selected frame is being changed. */
1630 /* Ensure that symbols for this frame are read in. Also, determine the
1631 source language of this frame, and switch to it if desired. */
1636 /* We retrieve the frame's symtab by using the frame PC.
1637 However we cannot use the frame PC as-is, because it usually
1638 points to the instruction following the "call", which is
1639 sometimes the first instruction of another function. So we
1640 rely on get_frame_address_in_block() which provides us with a
1641 PC which is guaranteed to be inside the frame's code
1643 if (get_frame_address_in_block_if_available (fi, &pc))
1645 struct compunit_symtab *cust = find_pc_compunit_symtab (pc);
1648 && compunit_language (cust) != current_language->la_language
1649 && compunit_language (cust) != language_unknown
1650 && language_mode == language_mode_auto)
1651 set_language (compunit_language (cust));
1656 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
1657 Always returns a non-NULL value. */
1660 create_new_frame (CORE_ADDR addr, CORE_ADDR pc)
1662 struct frame_info *fi;
1666 fprintf_unfiltered (gdb_stdlog,
1667 "{ create_new_frame (addr=%s, pc=%s) ",
1668 hex_string (addr), hex_string (pc));
1671 fi = FRAME_OBSTACK_ZALLOC (struct frame_info);
1673 fi->next = create_sentinel_frame (current_program_space,
1674 get_current_regcache ());
1676 /* Set/update this frame's cached PC value, found in the next frame.
1677 Do this before looking for this frame's unwinder. A sniffer is
1678 very likely to read this, and the corresponding unwinder is
1679 entitled to rely that the PC doesn't magically change. */
1680 fi->next->prev_pc.value = pc;
1681 fi->next->prev_pc.status = CC_VALUE;
1683 /* We currently assume that frame chain's can't cross spaces. */
1684 fi->pspace = fi->next->pspace;
1685 fi->aspace = fi->next->aspace;
1687 /* Select/initialize both the unwind function and the frame's type
1689 frame_unwind_find_by_frame (fi, &fi->prologue_cache);
1692 fi->this_id.value = frame_id_build (addr, pc);
1696 fprintf_unfiltered (gdb_stdlog, "-> ");
1697 fprint_frame (gdb_stdlog, fi);
1698 fprintf_unfiltered (gdb_stdlog, " }\n");
1704 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
1705 innermost frame). Be careful to not fall off the bottom of the
1706 frame chain and onto the sentinel frame. */
1709 get_next_frame (struct frame_info *this_frame)
1711 if (this_frame->level > 0)
1712 return this_frame->next;
1717 /* Observer for the target_changed event. */
1720 frame_observer_target_changed (struct target_ops *target)
1722 reinit_frame_cache ();
1725 /* Flush the entire frame cache. */
1728 reinit_frame_cache (void)
1730 struct frame_info *fi;
1732 /* Tear down all frame caches. */
1733 for (fi = current_frame; fi != NULL; fi = fi->prev)
1735 if (fi->prologue_cache && fi->unwind->dealloc_cache)
1736 fi->unwind->dealloc_cache (fi, fi->prologue_cache);
1737 if (fi->base_cache && fi->base->unwind->dealloc_cache)
1738 fi->base->unwind->dealloc_cache (fi, fi->base_cache);
1741 /* Since we can't really be sure what the first object allocated was. */
1742 obstack_free (&frame_cache_obstack, 0);
1743 obstack_init (&frame_cache_obstack);
1745 if (current_frame != NULL)
1746 annotate_frames_invalid ();
1748 current_frame = NULL; /* Invalidate cache */
1749 select_frame (NULL);
1750 frame_stash_invalidate ();
1752 fprintf_unfiltered (gdb_stdlog, "{ reinit_frame_cache () }\n");
1755 /* Find where a register is saved (in memory or another register).
1756 The result of frame_register_unwind is just where it is saved
1757 relative to this particular frame. */
1760 frame_register_unwind_location (struct frame_info *this_frame, int regnum,
1761 int *optimizedp, enum lval_type *lvalp,
1762 CORE_ADDR *addrp, int *realnump)
1764 gdb_assert (this_frame == NULL || this_frame->level >= 0);
1766 while (this_frame != NULL)
1770 frame_register_unwind (this_frame, regnum, optimizedp, &unavailable,
1771 lvalp, addrp, realnump, NULL);
1776 if (*lvalp != lval_register)
1780 this_frame = get_next_frame (this_frame);
1784 /* Called during frame unwinding to remove a previous frame pointer from a
1785 frame passed in ARG. */
1788 remove_prev_frame (void *arg)
1790 struct frame_info *this_frame, *prev_frame;
1792 this_frame = (struct frame_info *) arg;
1793 prev_frame = this_frame->prev;
1794 gdb_assert (prev_frame != NULL);
1796 prev_frame->next = NULL;
1797 this_frame->prev = NULL;
1800 /* Get the previous raw frame, and check that it is not identical to
1801 same other frame frame already in the chain. If it is, there is
1802 most likely a stack cycle, so we discard it, and mark THIS_FRAME as
1803 outermost, with UNWIND_SAME_ID stop reason. Unlike the other
1804 validity tests, that compare THIS_FRAME and the next frame, we do
1805 this right after creating the previous frame, to avoid ever ending
1806 up with two frames with the same id in the frame chain. */
1808 static struct frame_info *
1809 get_prev_frame_if_no_cycle (struct frame_info *this_frame)
1811 struct frame_info *prev_frame;
1812 struct cleanup *prev_frame_cleanup;
1814 prev_frame = get_prev_frame_raw (this_frame);
1815 if (prev_frame == NULL)
1818 /* The cleanup will remove the previous frame that get_prev_frame_raw
1819 linked onto THIS_FRAME. */
1820 prev_frame_cleanup = make_cleanup (remove_prev_frame, this_frame);
1822 compute_frame_id (prev_frame);
1823 if (!frame_stash_add (prev_frame))
1825 /* Another frame with the same id was already in the stash. We just
1826 detected a cycle. */
1829 fprintf_unfiltered (gdb_stdlog, "-> ");
1830 fprint_frame (gdb_stdlog, NULL);
1831 fprintf_unfiltered (gdb_stdlog, " // this frame has same ID }\n");
1833 this_frame->stop_reason = UNWIND_SAME_ID;
1835 prev_frame->next = NULL;
1836 this_frame->prev = NULL;
1840 discard_cleanups (prev_frame_cleanup);
1844 /* Helper function for get_prev_frame_always, this is called inside a
1845 TRY_CATCH block. Return the frame that called THIS_FRAME or NULL if
1846 there is no such frame. This may throw an exception. */
1848 static struct frame_info *
1849 get_prev_frame_always_1 (struct frame_info *this_frame)
1851 struct gdbarch *gdbarch;
1853 gdb_assert (this_frame != NULL);
1854 gdbarch = get_frame_arch (this_frame);
1858 fprintf_unfiltered (gdb_stdlog, "{ get_prev_frame_always (this_frame=");
1859 if (this_frame != NULL)
1860 fprintf_unfiltered (gdb_stdlog, "%d", this_frame->level);
1862 fprintf_unfiltered (gdb_stdlog, "<NULL>");
1863 fprintf_unfiltered (gdb_stdlog, ") ");
1866 /* Only try to do the unwind once. */
1867 if (this_frame->prev_p)
1871 fprintf_unfiltered (gdb_stdlog, "-> ");
1872 fprint_frame (gdb_stdlog, this_frame->prev);
1873 fprintf_unfiltered (gdb_stdlog, " // cached \n");
1875 return this_frame->prev;
1878 /* If the frame unwinder hasn't been selected yet, we must do so
1879 before setting prev_p; otherwise the check for misbehaved
1880 sniffers will think that this frame's sniffer tried to unwind
1881 further (see frame_cleanup_after_sniffer). */
1882 if (this_frame->unwind == NULL)
1883 frame_unwind_find_by_frame (this_frame, &this_frame->prologue_cache);
1885 this_frame->prev_p = 1;
1886 this_frame->stop_reason = UNWIND_NO_REASON;
1888 /* If we are unwinding from an inline frame, all of the below tests
1889 were already performed when we unwound from the next non-inline
1890 frame. We must skip them, since we can not get THIS_FRAME's ID
1891 until we have unwound all the way down to the previous non-inline
1893 if (get_frame_type (this_frame) == INLINE_FRAME)
1894 return get_prev_frame_if_no_cycle (this_frame);
1896 /* Check that this frame is unwindable. If it isn't, don't try to
1897 unwind to the prev frame. */
1898 this_frame->stop_reason
1899 = this_frame->unwind->stop_reason (this_frame,
1900 &this_frame->prologue_cache);
1902 if (this_frame->stop_reason != UNWIND_NO_REASON)
1906 enum unwind_stop_reason reason = this_frame->stop_reason;
1908 fprintf_unfiltered (gdb_stdlog, "-> ");
1909 fprint_frame (gdb_stdlog, NULL);
1910 fprintf_unfiltered (gdb_stdlog, " // %s }\n",
1911 frame_stop_reason_symbol_string (reason));
1916 /* Check that this frame's ID isn't inner to (younger, below, next)
1917 the next frame. This happens when a frame unwind goes backwards.
1918 This check is valid only if this frame and the next frame are NORMAL.
1919 See the comment at frame_id_inner for details. */
1920 if (get_frame_type (this_frame) == NORMAL_FRAME
1921 && this_frame->next->unwind->type == NORMAL_FRAME
1922 && frame_id_inner (get_frame_arch (this_frame->next),
1923 get_frame_id (this_frame),
1924 get_frame_id (this_frame->next)))
1926 CORE_ADDR this_pc_in_block;
1927 struct minimal_symbol *morestack_msym;
1928 const char *morestack_name = NULL;
1930 /* gcc -fsplit-stack __morestack can continue the stack anywhere. */
1931 this_pc_in_block = get_frame_address_in_block (this_frame);
1932 morestack_msym = lookup_minimal_symbol_by_pc (this_pc_in_block).minsym;
1934 morestack_name = MSYMBOL_LINKAGE_NAME (morestack_msym);
1935 if (!morestack_name || strcmp (morestack_name, "__morestack") != 0)
1939 fprintf_unfiltered (gdb_stdlog, "-> ");
1940 fprint_frame (gdb_stdlog, NULL);
1941 fprintf_unfiltered (gdb_stdlog,
1942 " // this frame ID is inner }\n");
1944 this_frame->stop_reason = UNWIND_INNER_ID;
1949 /* Check that this and the next frame do not unwind the PC register
1950 to the same memory location. If they do, then even though they
1951 have different frame IDs, the new frame will be bogus; two
1952 functions can't share a register save slot for the PC. This can
1953 happen when the prologue analyzer finds a stack adjustment, but
1956 This check does assume that the "PC register" is roughly a
1957 traditional PC, even if the gdbarch_unwind_pc method adjusts
1958 it (we do not rely on the value, only on the unwound PC being
1959 dependent on this value). A potential improvement would be
1960 to have the frame prev_pc method and the gdbarch unwind_pc
1961 method set the same lval and location information as
1962 frame_register_unwind. */
1963 if (this_frame->level > 0
1964 && gdbarch_pc_regnum (gdbarch) >= 0
1965 && get_frame_type (this_frame) == NORMAL_FRAME
1966 && (get_frame_type (this_frame->next) == NORMAL_FRAME
1967 || get_frame_type (this_frame->next) == INLINE_FRAME))
1969 int optimized, realnum, nrealnum;
1970 enum lval_type lval, nlval;
1971 CORE_ADDR addr, naddr;
1973 frame_register_unwind_location (this_frame,
1974 gdbarch_pc_regnum (gdbarch),
1975 &optimized, &lval, &addr, &realnum);
1976 frame_register_unwind_location (get_next_frame (this_frame),
1977 gdbarch_pc_regnum (gdbarch),
1978 &optimized, &nlval, &naddr, &nrealnum);
1980 if ((lval == lval_memory && lval == nlval && addr == naddr)
1981 || (lval == lval_register && lval == nlval && realnum == nrealnum))
1985 fprintf_unfiltered (gdb_stdlog, "-> ");
1986 fprint_frame (gdb_stdlog, NULL);
1987 fprintf_unfiltered (gdb_stdlog, " // no saved PC }\n");
1990 this_frame->stop_reason = UNWIND_NO_SAVED_PC;
1991 this_frame->prev = NULL;
1996 return get_prev_frame_if_no_cycle (this_frame);
1999 /* Return a "struct frame_info" corresponding to the frame that called
2000 THIS_FRAME. Returns NULL if there is no such frame.
2002 Unlike get_prev_frame, this function always tries to unwind the
2006 get_prev_frame_always (struct frame_info *this_frame)
2008 struct frame_info *prev_frame = NULL;
2012 prev_frame = get_prev_frame_always_1 (this_frame);
2014 CATCH (ex, RETURN_MASK_ERROR)
2016 if (ex.error == MEMORY_ERROR)
2018 this_frame->stop_reason = UNWIND_MEMORY_ERROR;
2019 if (ex.message != NULL)
2024 /* The error needs to live as long as the frame does.
2025 Allocate using stack local STOP_STRING then assign the
2026 pointer to the frame, this allows the STOP_STRING on the
2027 frame to be of type 'const char *'. */
2028 size = strlen (ex.message) + 1;
2029 stop_string = (char *) frame_obstack_zalloc (size);
2030 memcpy (stop_string, ex.message, size);
2031 this_frame->stop_string = stop_string;
2036 throw_exception (ex);
2043 /* Construct a new "struct frame_info" and link it previous to
2046 static struct frame_info *
2047 get_prev_frame_raw (struct frame_info *this_frame)
2049 struct frame_info *prev_frame;
2051 /* Allocate the new frame but do not wire it in to the frame chain.
2052 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
2053 frame->next to pull some fancy tricks (of course such code is, by
2054 definition, recursive). Try to prevent it.
2056 There is no reason to worry about memory leaks, should the
2057 remainder of the function fail. The allocated memory will be
2058 quickly reclaimed when the frame cache is flushed, and the `we've
2059 been here before' check above will stop repeated memory
2060 allocation calls. */
2061 prev_frame = FRAME_OBSTACK_ZALLOC (struct frame_info);
2062 prev_frame->level = this_frame->level + 1;
2064 /* For now, assume we don't have frame chains crossing address
2066 prev_frame->pspace = this_frame->pspace;
2067 prev_frame->aspace = this_frame->aspace;
2069 /* Don't yet compute ->unwind (and hence ->type). It is computed
2070 on-demand in get_frame_type, frame_register_unwind, and
2073 /* Don't yet compute the frame's ID. It is computed on-demand by
2076 /* The unwound frame ID is validate at the start of this function,
2077 as part of the logic to decide if that frame should be further
2078 unwound, and not here while the prev frame is being created.
2079 Doing this makes it possible for the user to examine a frame that
2080 has an invalid frame ID.
2082 Some very old VAX code noted: [...] For the sake of argument,
2083 suppose that the stack is somewhat trashed (which is one reason
2084 that "info frame" exists). So, return 0 (indicating we don't
2085 know the address of the arglist) if we don't know what frame this
2089 this_frame->prev = prev_frame;
2090 prev_frame->next = this_frame;
2094 fprintf_unfiltered (gdb_stdlog, "-> ");
2095 fprint_frame (gdb_stdlog, prev_frame);
2096 fprintf_unfiltered (gdb_stdlog, " }\n");
2102 /* Debug routine to print a NULL frame being returned. */
2105 frame_debug_got_null_frame (struct frame_info *this_frame,
2110 fprintf_unfiltered (gdb_stdlog, "{ get_prev_frame (this_frame=");
2111 if (this_frame != NULL)
2112 fprintf_unfiltered (gdb_stdlog, "%d", this_frame->level);
2114 fprintf_unfiltered (gdb_stdlog, "<NULL>");
2115 fprintf_unfiltered (gdb_stdlog, ") -> // %s}\n", reason);
2119 /* Is this (non-sentinel) frame in the "main"() function? */
2122 inside_main_func (struct frame_info *this_frame)
2124 struct bound_minimal_symbol msymbol;
2127 if (symfile_objfile == 0)
2129 msymbol = lookup_minimal_symbol (main_name (), NULL, symfile_objfile);
2130 if (msymbol.minsym == NULL)
2132 /* Make certain that the code, and not descriptor, address is
2134 maddr = gdbarch_convert_from_func_ptr_addr (get_frame_arch (this_frame),
2135 BMSYMBOL_VALUE_ADDRESS (msymbol),
2137 return maddr == get_frame_func (this_frame);
2140 /* Test whether THIS_FRAME is inside the process entry point function. */
2143 inside_entry_func (struct frame_info *this_frame)
2145 CORE_ADDR entry_point;
2147 if (!entry_point_address_query (&entry_point))
2150 return get_frame_func (this_frame) == entry_point;
2153 /* Return a structure containing various interesting information about
2154 the frame that called THIS_FRAME. Returns NULL if there is entier
2155 no such frame or the frame fails any of a set of target-independent
2156 condition that should terminate the frame chain (e.g., as unwinding
2159 This function should not contain target-dependent tests, such as
2160 checking whether the program-counter is zero. */
2163 get_prev_frame (struct frame_info *this_frame)
2168 /* There is always a frame. If this assertion fails, suspect that
2169 something should be calling get_selected_frame() or
2170 get_current_frame(). */
2171 gdb_assert (this_frame != NULL);
2172 frame_pc_p = get_frame_pc_if_available (this_frame, &frame_pc);
2174 /* tausq/2004-12-07: Dummy frames are skipped because it doesn't make much
2175 sense to stop unwinding at a dummy frame. One place where a dummy
2176 frame may have an address "inside_main_func" is on HPUX. On HPUX, the
2177 pcsqh register (space register for the instruction at the head of the
2178 instruction queue) cannot be written directly; the only way to set it
2179 is to branch to code that is in the target space. In order to implement
2180 frame dummies on HPUX, the called function is made to jump back to where
2181 the inferior was when the user function was called. If gdb was inside
2182 the main function when we created the dummy frame, the dummy frame will
2183 point inside the main function. */
2184 if (this_frame->level >= 0
2185 && get_frame_type (this_frame) == NORMAL_FRAME
2186 && !backtrace_past_main
2188 && inside_main_func (this_frame))
2189 /* Don't unwind past main(). Note, this is done _before_ the
2190 frame has been marked as previously unwound. That way if the
2191 user later decides to enable unwinds past main(), that will
2192 automatically happen. */
2194 frame_debug_got_null_frame (this_frame, "inside main func");
2198 /* If the user's backtrace limit has been exceeded, stop. We must
2199 add two to the current level; one of those accounts for backtrace_limit
2200 being 1-based and the level being 0-based, and the other accounts for
2201 the level of the new frame instead of the level of the current
2203 if (this_frame->level + 2 > backtrace_limit)
2205 frame_debug_got_null_frame (this_frame, "backtrace limit exceeded");
2209 /* If we're already inside the entry function for the main objfile,
2210 then it isn't valid. Don't apply this test to a dummy frame -
2211 dummy frame PCs typically land in the entry func. Don't apply
2212 this test to the sentinel frame. Sentinel frames should always
2213 be allowed to unwind. */
2214 /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() -
2215 wasn't checking for "main" in the minimal symbols. With that
2216 fixed asm-source tests now stop in "main" instead of halting the
2217 backtrace in weird and wonderful ways somewhere inside the entry
2218 file. Suspect that tests for inside the entry file/func were
2219 added to work around that (now fixed) case. */
2220 /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
2221 suggested having the inside_entry_func test use the
2222 inside_main_func() msymbol trick (along with entry_point_address()
2223 I guess) to determine the address range of the start function.
2224 That should provide a far better stopper than the current
2226 /* NOTE: tausq/2004-10-09: this is needed if, for example, the compiler
2227 applied tail-call optimizations to main so that a function called
2228 from main returns directly to the caller of main. Since we don't
2229 stop at main, we should at least stop at the entry point of the
2231 if (this_frame->level >= 0
2232 && get_frame_type (this_frame) == NORMAL_FRAME
2233 && !backtrace_past_entry
2235 && inside_entry_func (this_frame))
2237 frame_debug_got_null_frame (this_frame, "inside entry func");
2241 /* Assume that the only way to get a zero PC is through something
2242 like a SIGSEGV or a dummy frame, and hence that NORMAL frames
2243 will never unwind a zero PC. */
2244 if (this_frame->level > 0
2245 && (get_frame_type (this_frame) == NORMAL_FRAME
2246 || get_frame_type (this_frame) == INLINE_FRAME)
2247 && get_frame_type (get_next_frame (this_frame)) == NORMAL_FRAME
2248 && frame_pc_p && frame_pc == 0)
2250 frame_debug_got_null_frame (this_frame, "zero PC");
2254 return get_prev_frame_always (this_frame);
2258 get_frame_pc (struct frame_info *frame)
2260 gdb_assert (frame->next != NULL);
2261 return frame_unwind_pc (frame->next);
2265 get_frame_pc_if_available (struct frame_info *frame, CORE_ADDR *pc)
2268 gdb_assert (frame->next != NULL);
2272 *pc = frame_unwind_pc (frame->next);
2274 CATCH (ex, RETURN_MASK_ERROR)
2276 if (ex.error == NOT_AVAILABLE_ERROR)
2279 throw_exception (ex);
2286 /* Return an address that falls within THIS_FRAME's code block. */
2289 get_frame_address_in_block (struct frame_info *this_frame)
2291 /* A draft address. */
2292 CORE_ADDR pc = get_frame_pc (this_frame);
2294 struct frame_info *next_frame = this_frame->next;
2296 /* Calling get_frame_pc returns the resume address for THIS_FRAME.
2297 Normally the resume address is inside the body of the function
2298 associated with THIS_FRAME, but there is a special case: when
2299 calling a function which the compiler knows will never return
2300 (for instance abort), the call may be the very last instruction
2301 in the calling function. The resume address will point after the
2302 call and may be at the beginning of a different function
2305 If THIS_FRAME is a signal frame or dummy frame, then we should
2306 not adjust the unwound PC. For a dummy frame, GDB pushed the
2307 resume address manually onto the stack. For a signal frame, the
2308 OS may have pushed the resume address manually and invoked the
2309 handler (e.g. GNU/Linux), or invoked the trampoline which called
2310 the signal handler - but in either case the signal handler is
2311 expected to return to the trampoline. So in both of these
2312 cases we know that the resume address is executable and
2313 related. So we only need to adjust the PC if THIS_FRAME
2314 is a normal function.
2316 If the program has been interrupted while THIS_FRAME is current,
2317 then clearly the resume address is inside the associated
2318 function. There are three kinds of interruption: debugger stop
2319 (next frame will be SENTINEL_FRAME), operating system
2320 signal or exception (next frame will be SIGTRAMP_FRAME),
2321 or debugger-induced function call (next frame will be
2322 DUMMY_FRAME). So we only need to adjust the PC if
2323 NEXT_FRAME is a normal function.
2325 We check the type of NEXT_FRAME first, since it is already
2326 known; frame type is determined by the unwinder, and since
2327 we have THIS_FRAME we've already selected an unwinder for
2330 If the next frame is inlined, we need to keep going until we find
2331 the real function - for instance, if a signal handler is invoked
2332 while in an inlined function, then the code address of the
2333 "calling" normal function should not be adjusted either. */
2335 while (get_frame_type (next_frame) == INLINE_FRAME)
2336 next_frame = next_frame->next;
2338 if ((get_frame_type (next_frame) == NORMAL_FRAME
2339 || get_frame_type (next_frame) == TAILCALL_FRAME)
2340 && (get_frame_type (this_frame) == NORMAL_FRAME
2341 || get_frame_type (this_frame) == TAILCALL_FRAME
2342 || get_frame_type (this_frame) == INLINE_FRAME))
2349 get_frame_address_in_block_if_available (struct frame_info *this_frame,
2355 *pc = get_frame_address_in_block (this_frame);
2357 CATCH (ex, RETURN_MASK_ERROR)
2359 if (ex.error == NOT_AVAILABLE_ERROR)
2361 throw_exception (ex);
2369 find_frame_sal (struct frame_info *frame, struct symtab_and_line *sal)
2371 struct frame_info *next_frame;
2375 /* If the next frame represents an inlined function call, this frame's
2376 sal is the "call site" of that inlined function, which can not
2377 be inferred from get_frame_pc. */
2378 next_frame = get_next_frame (frame);
2379 if (frame_inlined_callees (frame) > 0)
2384 sym = get_frame_function (next_frame);
2386 sym = inline_skipped_symbol (inferior_ptid);
2388 /* If frame is inline, it certainly has symbols. */
2391 if (SYMBOL_LINE (sym) != 0)
2393 sal->symtab = symbol_symtab (sym);
2394 sal->line = SYMBOL_LINE (sym);
2397 /* If the symbol does not have a location, we don't know where
2398 the call site is. Do not pretend to. This is jarring, but
2399 we can't do much better. */
2400 sal->pc = get_frame_pc (frame);
2402 sal->pspace = get_frame_program_space (frame);
2407 /* If FRAME is not the innermost frame, that normally means that
2408 FRAME->pc points at the return instruction (which is *after* the
2409 call instruction), and we want to get the line containing the
2410 call (because the call is where the user thinks the program is).
2411 However, if the next frame is either a SIGTRAMP_FRAME or a
2412 DUMMY_FRAME, then the next frame will contain a saved interrupt
2413 PC and such a PC indicates the current (rather than next)
2414 instruction/line, consequently, for such cases, want to get the
2415 line containing fi->pc. */
2416 if (!get_frame_pc_if_available (frame, &pc))
2422 notcurrent = (pc != get_frame_address_in_block (frame));
2423 (*sal) = find_pc_line (pc, notcurrent);
2426 /* Per "frame.h", return the ``address'' of the frame. Code should
2427 really be using get_frame_id(). */
2429 get_frame_base (struct frame_info *fi)
2431 return get_frame_id (fi).stack_addr;
2434 /* High-level offsets into the frame. Used by the debug info. */
2437 get_frame_base_address (struct frame_info *fi)
2439 if (get_frame_type (fi) != NORMAL_FRAME)
2441 if (fi->base == NULL)
2442 fi->base = frame_base_find_by_frame (fi);
2443 /* Sneaky: If the low-level unwind and high-level base code share a
2444 common unwinder, let them share the prologue cache. */
2445 if (fi->base->unwind == fi->unwind)
2446 return fi->base->this_base (fi, &fi->prologue_cache);
2447 return fi->base->this_base (fi, &fi->base_cache);
2451 get_frame_locals_address (struct frame_info *fi)
2453 if (get_frame_type (fi) != NORMAL_FRAME)
2455 /* If there isn't a frame address method, find it. */
2456 if (fi->base == NULL)
2457 fi->base = frame_base_find_by_frame (fi);
2458 /* Sneaky: If the low-level unwind and high-level base code share a
2459 common unwinder, let them share the prologue cache. */
2460 if (fi->base->unwind == fi->unwind)
2461 return fi->base->this_locals (fi, &fi->prologue_cache);
2462 return fi->base->this_locals (fi, &fi->base_cache);
2466 get_frame_args_address (struct frame_info *fi)
2468 if (get_frame_type (fi) != NORMAL_FRAME)
2470 /* If there isn't a frame address method, find it. */
2471 if (fi->base == NULL)
2472 fi->base = frame_base_find_by_frame (fi);
2473 /* Sneaky: If the low-level unwind and high-level base code share a
2474 common unwinder, let them share the prologue cache. */
2475 if (fi->base->unwind == fi->unwind)
2476 return fi->base->this_args (fi, &fi->prologue_cache);
2477 return fi->base->this_args (fi, &fi->base_cache);
2480 /* Return true if the frame unwinder for frame FI is UNWINDER; false
2484 frame_unwinder_is (struct frame_info *fi, const struct frame_unwind *unwinder)
2486 if (fi->unwind == NULL)
2487 frame_unwind_find_by_frame (fi, &fi->prologue_cache);
2488 return fi->unwind == unwinder;
2491 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
2492 or -1 for a NULL frame. */
2495 frame_relative_level (struct frame_info *fi)
2504 get_frame_type (struct frame_info *frame)
2506 if (frame->unwind == NULL)
2507 /* Initialize the frame's unwinder because that's what
2508 provides the frame's type. */
2509 frame_unwind_find_by_frame (frame, &frame->prologue_cache);
2510 return frame->unwind->type;
2513 struct program_space *
2514 get_frame_program_space (struct frame_info *frame)
2516 return frame->pspace;
2519 struct program_space *
2520 frame_unwind_program_space (struct frame_info *this_frame)
2522 gdb_assert (this_frame);
2524 /* This is really a placeholder to keep the API consistent --- we
2525 assume for now that we don't have frame chains crossing
2527 return this_frame->pspace;
2530 struct address_space *
2531 get_frame_address_space (struct frame_info *frame)
2533 return frame->aspace;
2536 /* Memory access methods. */
2539 get_frame_memory (struct frame_info *this_frame, CORE_ADDR addr,
2540 gdb_byte *buf, int len)
2542 read_memory (addr, buf, len);
2546 get_frame_memory_signed (struct frame_info *this_frame, CORE_ADDR addr,
2549 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2550 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2552 return read_memory_integer (addr, len, byte_order);
2556 get_frame_memory_unsigned (struct frame_info *this_frame, CORE_ADDR addr,
2559 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2560 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2562 return read_memory_unsigned_integer (addr, len, byte_order);
2566 safe_frame_unwind_memory (struct frame_info *this_frame,
2567 CORE_ADDR addr, gdb_byte *buf, int len)
2569 /* NOTE: target_read_memory returns zero on success! */
2570 return !target_read_memory (addr, buf, len);
2573 /* Architecture methods. */
2576 get_frame_arch (struct frame_info *this_frame)
2578 return frame_unwind_arch (this_frame->next);
2582 frame_unwind_arch (struct frame_info *next_frame)
2584 if (!next_frame->prev_arch.p)
2586 struct gdbarch *arch;
2588 if (next_frame->unwind == NULL)
2589 frame_unwind_find_by_frame (next_frame, &next_frame->prologue_cache);
2591 if (next_frame->unwind->prev_arch != NULL)
2592 arch = next_frame->unwind->prev_arch (next_frame,
2593 &next_frame->prologue_cache);
2595 arch = get_frame_arch (next_frame);
2597 next_frame->prev_arch.arch = arch;
2598 next_frame->prev_arch.p = 1;
2600 fprintf_unfiltered (gdb_stdlog,
2601 "{ frame_unwind_arch (next_frame=%d) -> %s }\n",
2603 gdbarch_bfd_arch_info (arch)->printable_name);
2606 return next_frame->prev_arch.arch;
2610 frame_unwind_caller_arch (struct frame_info *next_frame)
2612 next_frame = skip_artificial_frames (next_frame);
2614 /* We must have a non-artificial frame. The caller is supposed to check
2615 the result of frame_unwind_caller_id (), which returns NULL_FRAME_ID
2617 gdb_assert (next_frame != NULL);
2619 return frame_unwind_arch (next_frame);
2622 /* Gets the language of FRAME. */
2625 get_frame_language (struct frame_info *frame)
2630 gdb_assert (frame!= NULL);
2632 /* We determine the current frame language by looking up its
2633 associated symtab. To retrieve this symtab, we use the frame
2634 PC. However we cannot use the frame PC as is, because it
2635 usually points to the instruction following the "call", which
2636 is sometimes the first instruction of another function. So
2637 we rely on get_frame_address_in_block(), it provides us with
2638 a PC that is guaranteed to be inside the frame's code
2643 pc = get_frame_address_in_block (frame);
2646 CATCH (ex, RETURN_MASK_ERROR)
2648 if (ex.error != NOT_AVAILABLE_ERROR)
2649 throw_exception (ex);
2655 struct compunit_symtab *cust = find_pc_compunit_symtab (pc);
2658 return compunit_language (cust);
2661 return language_unknown;
2664 /* Stack pointer methods. */
2667 get_frame_sp (struct frame_info *this_frame)
2669 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2671 /* Normality - an architecture that provides a way of obtaining any
2672 frame inner-most address. */
2673 if (gdbarch_unwind_sp_p (gdbarch))
2674 /* NOTE drow/2008-06-28: gdbarch_unwind_sp could be converted to
2675 operate on THIS_FRAME now. */
2676 return gdbarch_unwind_sp (gdbarch, this_frame->next);
2677 /* Now things are really are grim. Hope that the value returned by
2678 the gdbarch_sp_regnum register is meaningful. */
2679 if (gdbarch_sp_regnum (gdbarch) >= 0)
2680 return get_frame_register_unsigned (this_frame,
2681 gdbarch_sp_regnum (gdbarch));
2682 internal_error (__FILE__, __LINE__, _("Missing unwind SP method"));
2685 /* Return the reason why we can't unwind past FRAME. */
2687 enum unwind_stop_reason
2688 get_frame_unwind_stop_reason (struct frame_info *frame)
2690 /* Fill-in STOP_REASON. */
2691 get_prev_frame_always (frame);
2692 gdb_assert (frame->prev_p);
2694 return frame->stop_reason;
2697 /* Return a string explaining REASON. */
2700 unwind_stop_reason_to_string (enum unwind_stop_reason reason)
2704 #define SET(name, description) \
2705 case name: return _(description);
2706 #include "unwind_stop_reasons.def"
2710 internal_error (__FILE__, __LINE__,
2711 "Invalid frame stop reason");
2716 frame_stop_reason_string (struct frame_info *fi)
2718 gdb_assert (fi->prev_p);
2719 gdb_assert (fi->prev == NULL);
2721 /* Return the specific string if we have one. */
2722 if (fi->stop_string != NULL)
2723 return fi->stop_string;
2725 /* Return the generic string if we have nothing better. */
2726 return unwind_stop_reason_to_string (fi->stop_reason);
2729 /* Return the enum symbol name of REASON as a string, to use in debug
2733 frame_stop_reason_symbol_string (enum unwind_stop_reason reason)
2737 #define SET(name, description) \
2738 case name: return #name;
2739 #include "unwind_stop_reasons.def"
2743 internal_error (__FILE__, __LINE__,
2744 "Invalid frame stop reason");
2748 /* Clean up after a failed (wrong unwinder) attempt to unwind past
2752 frame_cleanup_after_sniffer (void *arg)
2754 struct frame_info *frame = (struct frame_info *) arg;
2756 /* The sniffer should not allocate a prologue cache if it did not
2757 match this frame. */
2758 gdb_assert (frame->prologue_cache == NULL);
2760 /* No sniffer should extend the frame chain; sniff based on what is
2762 gdb_assert (!frame->prev_p);
2764 /* The sniffer should not check the frame's ID; that's circular. */
2765 gdb_assert (!frame->this_id.p);
2767 /* Clear cached fields dependent on the unwinder.
2769 The previous PC is independent of the unwinder, but the previous
2770 function is not (see get_frame_address_in_block). */
2771 frame->prev_func.p = 0;
2772 frame->prev_func.addr = 0;
2774 /* Discard the unwinder last, so that we can easily find it if an assertion
2775 in this function triggers. */
2776 frame->unwind = NULL;
2779 /* Set FRAME's unwinder temporarily, so that we can call a sniffer.
2780 Return a cleanup which should be called if unwinding fails, and
2781 discarded if it succeeds. */
2784 frame_prepare_for_sniffer (struct frame_info *frame,
2785 const struct frame_unwind *unwind)
2787 gdb_assert (frame->unwind == NULL);
2788 frame->unwind = unwind;
2789 return make_cleanup (frame_cleanup_after_sniffer, frame);
2792 extern initialize_file_ftype _initialize_frame; /* -Wmissing-prototypes */
2794 static struct cmd_list_element *set_backtrace_cmdlist;
2795 static struct cmd_list_element *show_backtrace_cmdlist;
2798 set_backtrace_cmd (char *args, int from_tty)
2800 help_list (set_backtrace_cmdlist, "set backtrace ", all_commands,
2805 show_backtrace_cmd (char *args, int from_tty)
2807 cmd_show_list (show_backtrace_cmdlist, from_tty, "");
2811 _initialize_frame (void)
2813 obstack_init (&frame_cache_obstack);
2815 frame_stash_create ();
2817 observer_attach_target_changed (frame_observer_target_changed);
2819 add_prefix_cmd ("backtrace", class_maintenance, set_backtrace_cmd, _("\
2820 Set backtrace specific variables.\n\
2821 Configure backtrace variables such as the backtrace limit"),
2822 &set_backtrace_cmdlist, "set backtrace ",
2823 0/*allow-unknown*/, &setlist);
2824 add_prefix_cmd ("backtrace", class_maintenance, show_backtrace_cmd, _("\
2825 Show backtrace specific variables\n\
2826 Show backtrace variables such as the backtrace limit"),
2827 &show_backtrace_cmdlist, "show backtrace ",
2828 0/*allow-unknown*/, &showlist);
2830 add_setshow_boolean_cmd ("past-main", class_obscure,
2831 &backtrace_past_main, _("\
2832 Set whether backtraces should continue past \"main\"."), _("\
2833 Show whether backtraces should continue past \"main\"."), _("\
2834 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
2835 the backtrace at \"main\". Set this variable if you need to see the rest\n\
2836 of the stack trace."),
2838 show_backtrace_past_main,
2839 &set_backtrace_cmdlist,
2840 &show_backtrace_cmdlist);
2842 add_setshow_boolean_cmd ("past-entry", class_obscure,
2843 &backtrace_past_entry, _("\
2844 Set whether backtraces should continue past the entry point of a program."),
2846 Show whether backtraces should continue past the entry point of a program."),
2848 Normally there are no callers beyond the entry point of a program, so GDB\n\
2849 will terminate the backtrace there. Set this variable if you need to see\n\
2850 the rest of the stack trace."),
2852 show_backtrace_past_entry,
2853 &set_backtrace_cmdlist,
2854 &show_backtrace_cmdlist);
2856 add_setshow_uinteger_cmd ("limit", class_obscure,
2857 &backtrace_limit, _("\
2858 Set an upper bound on the number of backtrace levels."), _("\
2859 Show the upper bound on the number of backtrace levels."), _("\
2860 No more than the specified number of frames can be displayed or examined.\n\
2861 Literal \"unlimited\" or zero means no limit."),
2863 show_backtrace_limit,
2864 &set_backtrace_cmdlist,
2865 &show_backtrace_cmdlist);
2867 /* Debug this files internals. */
2868 add_setshow_zuinteger_cmd ("frame", class_maintenance, &frame_debug, _("\
2869 Set frame debugging."), _("\
2870 Show frame debugging."), _("\
2871 When non-zero, frame specific internal debugging is enabled."),
2874 &setdebuglist, &showdebuglist);