1 /* Cache and manage frames for GDB, the GNU debugger.
3 Copyright (C) 1986-2014 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 "gdb_assert.h"
28 #include "user-regs.h"
29 #include "gdb_obstack.h"
30 #include "dummy-frame.h"
31 #include "sentinel-frame.h"
35 #include "frame-unwind.h"
36 #include "frame-base.h"
41 #include "exceptions.h"
42 #include "gdbthread.h"
44 #include "inline-frame.h"
45 #include "tracepoint.h"
49 static struct frame_info *get_prev_frame_raw (struct frame_info *this_frame);
50 static const char *frame_stop_reason_symbol_string (enum unwind_stop_reason reason);
52 /* Status of some values cached in the frame_info object. */
54 enum cached_copy_status
56 /* Value is unknown. */
59 /* We have a value. */
62 /* Value was not saved. */
65 /* Value is unavailable. */
69 /* We keep a cache of stack frames, each of which is a "struct
70 frame_info". The innermost one gets allocated (in
71 wait_for_inferior) each time the inferior stops; current_frame
72 points to it. Additional frames get allocated (in get_prev_frame)
73 as needed, and are chained through the next and prev fields. Any
74 time that the frame cache becomes invalid (most notably when we
75 execute something, but also if we change how we interpret the
76 frames (e.g. "set heuristic-fence-post" in mips-tdep.c, or anything
77 which reads new symbols)), we should call reinit_frame_cache. */
81 /* Level of this frame. The inner-most (youngest) frame is at level
82 0. As you move towards the outer-most (oldest) frame, the level
83 increases. This is a cached value. It could just as easily be
84 computed by counting back from the selected frame to the inner
86 /* NOTE: cagney/2002-04-05: Perhaps a level of ``-1'' should be
87 reserved to indicate a bogus frame - one that has been created
88 just to keep GDB happy (GDB always needs a frame). For the
89 moment leave this as speculation. */
92 /* The frame's program space. */
93 struct program_space *pspace;
95 /* The frame's address space. */
96 struct address_space *aspace;
98 /* The frame's low-level unwinder and corresponding cache. The
99 low-level unwinder is responsible for unwinding register values
100 for the previous frame. The low-level unwind methods are
101 selected based on the presence, or otherwise, of register unwind
102 information such as CFI. */
103 void *prologue_cache;
104 const struct frame_unwind *unwind;
106 /* Cached copy of the previous frame's architecture. */
110 struct gdbarch *arch;
113 /* Cached copy of the previous frame's resume address. */
115 enum cached_copy_status status;
119 /* Cached copy of the previous frame's function address. */
126 /* This frame's ID. */
130 struct frame_id value;
133 /* The frame's high-level base methods, and corresponding cache.
134 The high level base methods are selected based on the frame's
136 const struct frame_base *base;
139 /* Pointers to the next (down, inner, younger) and previous (up,
140 outer, older) frame_info's in the frame cache. */
141 struct frame_info *next; /* down, inner, younger */
143 struct frame_info *prev; /* up, outer, older */
145 /* The reason why we could not set PREV, or UNWIND_NO_REASON if we
146 could. Only valid when PREV_P is set. */
147 enum unwind_stop_reason stop_reason;
149 /* A frame specific string describing the STOP_REASON in more detail.
150 Only valid when PREV_P is set, but even then may still be NULL. */
151 const char *stop_string;
154 /* A frame stash used to speed up frame lookups. Create a hash table
155 to stash frames previously accessed from the frame cache for
156 quicker subsequent retrieval. The hash table is emptied whenever
157 the frame cache is invalidated. */
159 static htab_t frame_stash;
161 /* Internal function to calculate a hash from the frame_id addresses,
162 using as many valid addresses as possible. Frames below level 0
163 are not stored in the hash table. */
166 frame_addr_hash (const void *ap)
168 const struct frame_info *frame = ap;
169 const struct frame_id f_id = frame->this_id.value;
172 gdb_assert (f_id.stack_status != FID_STACK_INVALID
174 || f_id.special_addr_p);
176 if (f_id.stack_status == FID_STACK_VALID)
177 hash = iterative_hash (&f_id.stack_addr,
178 sizeof (f_id.stack_addr), hash);
179 if (f_id.code_addr_p)
180 hash = iterative_hash (&f_id.code_addr,
181 sizeof (f_id.code_addr), hash);
182 if (f_id.special_addr_p)
183 hash = iterative_hash (&f_id.special_addr,
184 sizeof (f_id.special_addr), hash);
189 /* Internal equality function for the hash table. This function
190 defers equality operations to frame_id_eq. */
193 frame_addr_hash_eq (const void *a, const void *b)
195 const struct frame_info *f_entry = a;
196 const struct frame_info *f_element = b;
198 return frame_id_eq (f_entry->this_id.value,
199 f_element->this_id.value);
202 /* Internal function to create the frame_stash hash table. 100 seems
203 to be a good compromise to start the hash table at. */
206 frame_stash_create (void)
208 frame_stash = htab_create (100,
214 /* Internal function to add a frame to the frame_stash hash table.
215 Returns false if a frame with the same ID was already stashed, true
219 frame_stash_add (struct frame_info *frame)
221 struct frame_info **slot;
223 /* Do not try to stash the sentinel frame. */
224 gdb_assert (frame->level >= 0);
226 slot = (struct frame_info **) htab_find_slot (frame_stash,
230 /* If we already have a frame in the stack with the same id, we
231 either have a stack cycle (corrupted stack?), or some bug
232 elsewhere in GDB. In any case, ignore the duplicate and return
233 an indication to the caller. */
241 /* Internal function to search the frame stash for an entry with the
242 given frame ID. If found, return that frame. Otherwise return
245 static struct frame_info *
246 frame_stash_find (struct frame_id id)
248 struct frame_info dummy;
249 struct frame_info *frame;
251 dummy.this_id.value = id;
252 frame = htab_find (frame_stash, &dummy);
256 /* Internal function to invalidate the frame stash by removing all
257 entries in it. This only occurs when the frame cache is
261 frame_stash_invalidate (void)
263 htab_empty (frame_stash);
266 /* Flag to control debugging. */
268 unsigned int frame_debug;
270 show_frame_debug (struct ui_file *file, int from_tty,
271 struct cmd_list_element *c, const char *value)
273 fprintf_filtered (file, _("Frame debugging is %s.\n"), value);
276 /* Flag to indicate whether backtraces should stop at main et.al. */
278 static int backtrace_past_main;
280 show_backtrace_past_main (struct ui_file *file, int from_tty,
281 struct cmd_list_element *c, const char *value)
283 fprintf_filtered (file,
284 _("Whether backtraces should "
285 "continue past \"main\" is %s.\n"),
289 static int backtrace_past_entry;
291 show_backtrace_past_entry (struct ui_file *file, int from_tty,
292 struct cmd_list_element *c, const char *value)
294 fprintf_filtered (file, _("Whether backtraces should continue past the "
295 "entry point of a program is %s.\n"),
299 static unsigned int backtrace_limit = UINT_MAX;
301 show_backtrace_limit (struct ui_file *file, int from_tty,
302 struct cmd_list_element *c, const char *value)
304 fprintf_filtered (file,
305 _("An upper bound on the number "
306 "of backtrace levels is %s.\n"),
312 fprint_field (struct ui_file *file, const char *name, int p, CORE_ADDR addr)
315 fprintf_unfiltered (file, "%s=%s", name, hex_string (addr));
317 fprintf_unfiltered (file, "!%s", name);
321 fprint_frame_id (struct ui_file *file, struct frame_id id)
323 fprintf_unfiltered (file, "{");
325 if (id.stack_status == FID_STACK_INVALID)
326 fprintf_unfiltered (file, "!stack");
327 else if (id.stack_status == FID_STACK_UNAVAILABLE)
328 fprintf_unfiltered (file, "stack=<unavailable>");
330 fprintf_unfiltered (file, "stack=%s", hex_string (id.stack_addr));
331 fprintf_unfiltered (file, ",");
333 fprint_field (file, "code", id.code_addr_p, id.code_addr);
334 fprintf_unfiltered (file, ",");
336 fprint_field (file, "special", id.special_addr_p, id.special_addr);
338 if (id.artificial_depth)
339 fprintf_unfiltered (file, ",artificial=%d", id.artificial_depth);
341 fprintf_unfiltered (file, "}");
345 fprint_frame_type (struct ui_file *file, enum frame_type type)
350 fprintf_unfiltered (file, "NORMAL_FRAME");
353 fprintf_unfiltered (file, "DUMMY_FRAME");
356 fprintf_unfiltered (file, "INLINE_FRAME");
359 fprintf_unfiltered (file, "TAILCALL_FRAME");
362 fprintf_unfiltered (file, "SIGTRAMP_FRAME");
365 fprintf_unfiltered (file, "ARCH_FRAME");
368 fprintf_unfiltered (file, "SENTINEL_FRAME");
371 fprintf_unfiltered (file, "<unknown type>");
377 fprint_frame (struct ui_file *file, struct frame_info *fi)
381 fprintf_unfiltered (file, "<NULL frame>");
384 fprintf_unfiltered (file, "{");
385 fprintf_unfiltered (file, "level=%d", fi->level);
386 fprintf_unfiltered (file, ",");
387 fprintf_unfiltered (file, "type=");
388 if (fi->unwind != NULL)
389 fprint_frame_type (file, fi->unwind->type);
391 fprintf_unfiltered (file, "<unknown>");
392 fprintf_unfiltered (file, ",");
393 fprintf_unfiltered (file, "unwind=");
394 if (fi->unwind != NULL)
395 gdb_print_host_address (fi->unwind, file);
397 fprintf_unfiltered (file, "<unknown>");
398 fprintf_unfiltered (file, ",");
399 fprintf_unfiltered (file, "pc=");
400 if (fi->next == NULL || fi->next->prev_pc.status == CC_UNKNOWN)
401 fprintf_unfiltered (file, "<unknown>");
402 else if (fi->next->prev_pc.status == CC_VALUE)
403 fprintf_unfiltered (file, "%s",
404 hex_string (fi->next->prev_pc.value));
405 else if (fi->next->prev_pc.status == CC_NOT_SAVED)
406 val_print_not_saved (file);
407 else if (fi->next->prev_pc.status == CC_UNAVAILABLE)
408 val_print_unavailable (file);
409 fprintf_unfiltered (file, ",");
410 fprintf_unfiltered (file, "id=");
412 fprint_frame_id (file, fi->this_id.value);
414 fprintf_unfiltered (file, "<unknown>");
415 fprintf_unfiltered (file, ",");
416 fprintf_unfiltered (file, "func=");
417 if (fi->next != NULL && fi->next->prev_func.p)
418 fprintf_unfiltered (file, "%s", hex_string (fi->next->prev_func.addr));
420 fprintf_unfiltered (file, "<unknown>");
421 fprintf_unfiltered (file, "}");
424 /* Given FRAME, return the enclosing frame as found in real frames read-in from
425 inferior memory. Skip any previous frames which were made up by GDB.
426 Return the original frame if no immediate previous frames exist. */
428 static struct frame_info *
429 skip_artificial_frames (struct frame_info *frame)
431 /* Note we use get_prev_frame_always, and not get_prev_frame. The
432 latter will truncate the frame chain, leading to this function
433 unintentionally returning a null_frame_id (e.g., when the user
434 sets a backtrace limit). This is safe, because as these frames
435 are made up by GDB, there must be a real frame in the chain
437 while (get_frame_type (frame) == INLINE_FRAME
438 || get_frame_type (frame) == TAILCALL_FRAME)
439 frame = get_prev_frame_always (frame);
444 /* Compute the frame's uniq ID that can be used to, later, re-find the
448 compute_frame_id (struct frame_info *fi)
450 gdb_assert (!fi->this_id.p);
453 fprintf_unfiltered (gdb_stdlog, "{ compute_frame_id (fi=%d) ",
455 /* Find the unwinder. */
456 if (fi->unwind == NULL)
457 frame_unwind_find_by_frame (fi, &fi->prologue_cache);
458 /* Find THIS frame's ID. */
459 /* Default to outermost if no ID is found. */
460 fi->this_id.value = outer_frame_id;
461 fi->unwind->this_id (fi, &fi->prologue_cache, &fi->this_id.value);
462 gdb_assert (frame_id_p (fi->this_id.value));
466 fprintf_unfiltered (gdb_stdlog, "-> ");
467 fprint_frame_id (gdb_stdlog, fi->this_id.value);
468 fprintf_unfiltered (gdb_stdlog, " }\n");
472 /* Return a frame uniq ID that can be used to, later, re-find the
476 get_frame_id (struct frame_info *fi)
479 return null_frame_id;
481 gdb_assert (fi->this_id.p);
482 return fi->this_id.value;
486 get_stack_frame_id (struct frame_info *next_frame)
488 return get_frame_id (skip_artificial_frames (next_frame));
492 frame_unwind_caller_id (struct frame_info *next_frame)
494 struct frame_info *this_frame;
496 /* Use get_prev_frame_always, and not get_prev_frame. The latter
497 will truncate the frame chain, leading to this function
498 unintentionally returning a null_frame_id (e.g., when a caller
499 requests the frame ID of "main()"s caller. */
501 next_frame = skip_artificial_frames (next_frame);
502 this_frame = get_prev_frame_always (next_frame);
504 return get_frame_id (skip_artificial_frames (this_frame));
506 return null_frame_id;
509 const struct frame_id null_frame_id; /* All zeros. */
510 const struct frame_id outer_frame_id = { 0, 0, 0, FID_STACK_INVALID, 0, 1, 0 };
513 frame_id_build_special (CORE_ADDR stack_addr, CORE_ADDR code_addr,
514 CORE_ADDR special_addr)
516 struct frame_id id = null_frame_id;
518 id.stack_addr = stack_addr;
519 id.stack_status = FID_STACK_VALID;
520 id.code_addr = code_addr;
522 id.special_addr = special_addr;
523 id.special_addr_p = 1;
530 frame_id_build_unavailable_stack (CORE_ADDR code_addr)
532 struct frame_id id = null_frame_id;
534 id.stack_status = FID_STACK_UNAVAILABLE;
535 id.code_addr = code_addr;
543 frame_id_build_unavailable_stack_special (CORE_ADDR code_addr,
544 CORE_ADDR special_addr)
546 struct frame_id id = null_frame_id;
548 id.stack_status = FID_STACK_UNAVAILABLE;
549 id.code_addr = code_addr;
551 id.special_addr = special_addr;
552 id.special_addr_p = 1;
557 frame_id_build (CORE_ADDR stack_addr, CORE_ADDR code_addr)
559 struct frame_id id = null_frame_id;
561 id.stack_addr = stack_addr;
562 id.stack_status = FID_STACK_VALID;
563 id.code_addr = code_addr;
569 frame_id_build_wild (CORE_ADDR stack_addr)
571 struct frame_id id = null_frame_id;
573 id.stack_addr = stack_addr;
574 id.stack_status = FID_STACK_VALID;
579 frame_id_p (struct frame_id l)
583 /* The frame is valid iff it has a valid stack address. */
584 p = l.stack_status != FID_STACK_INVALID;
585 /* outer_frame_id is also valid. */
586 if (!p && memcmp (&l, &outer_frame_id, sizeof (l)) == 0)
590 fprintf_unfiltered (gdb_stdlog, "{ frame_id_p (l=");
591 fprint_frame_id (gdb_stdlog, l);
592 fprintf_unfiltered (gdb_stdlog, ") -> %d }\n", p);
598 frame_id_artificial_p (struct frame_id l)
603 return (l.artificial_depth != 0);
607 frame_id_eq (struct frame_id l, struct frame_id r)
611 if (l.stack_status == FID_STACK_INVALID && l.special_addr_p
612 && r.stack_status == FID_STACK_INVALID && r.special_addr_p)
613 /* The outermost frame marker is equal to itself. This is the
614 dodgy thing about outer_frame_id, since between execution steps
615 we might step into another function - from which we can't
616 unwind either. More thought required to get rid of
619 else if (l.stack_status == FID_STACK_INVALID
620 || l.stack_status == FID_STACK_INVALID)
621 /* Like a NaN, if either ID is invalid, the result is false.
622 Note that a frame ID is invalid iff it is the null frame ID. */
624 else if (l.stack_status != r.stack_status || l.stack_addr != r.stack_addr)
625 /* If .stack addresses are different, the frames are different. */
627 else if (l.code_addr_p && r.code_addr_p && l.code_addr != r.code_addr)
628 /* An invalid code addr is a wild card. If .code addresses are
629 different, the frames are different. */
631 else if (l.special_addr_p && r.special_addr_p
632 && l.special_addr != r.special_addr)
633 /* An invalid special addr is a wild card (or unused). Otherwise
634 if special addresses are different, the frames are different. */
636 else if (l.artificial_depth != r.artificial_depth)
637 /* If artifical depths are different, the frames must be different. */
640 /* Frames are equal. */
645 fprintf_unfiltered (gdb_stdlog, "{ frame_id_eq (l=");
646 fprint_frame_id (gdb_stdlog, l);
647 fprintf_unfiltered (gdb_stdlog, ",r=");
648 fprint_frame_id (gdb_stdlog, r);
649 fprintf_unfiltered (gdb_stdlog, ") -> %d }\n", eq);
654 /* Safety net to check whether frame ID L should be inner to
655 frame ID R, according to their stack addresses.
657 This method cannot be used to compare arbitrary frames, as the
658 ranges of valid stack addresses may be discontiguous (e.g. due
661 However, it can be used as safety net to discover invalid frame
662 IDs in certain circumstances. Assuming that NEXT is the immediate
663 inner frame to THIS and that NEXT and THIS are both NORMAL frames:
665 * The stack address of NEXT must be inner-than-or-equal to the stack
668 Therefore, if frame_id_inner (THIS, NEXT) holds, some unwind
671 * If NEXT and THIS have different stack addresses, no other frame
672 in the frame chain may have a stack address in between.
674 Therefore, if frame_id_inner (TEST, THIS) holds, but
675 frame_id_inner (TEST, NEXT) does not hold, TEST cannot refer
676 to a valid frame in the frame chain.
678 The sanity checks above cannot be performed when a SIGTRAMP frame
679 is involved, because signal handlers might be executed on a different
680 stack than the stack used by the routine that caused the signal
681 to be raised. This can happen for instance when a thread exceeds
682 its maximum stack size. In this case, certain compilers implement
683 a stack overflow strategy that cause the handler to be run on a
687 frame_id_inner (struct gdbarch *gdbarch, struct frame_id l, struct frame_id r)
691 if (l.stack_status != FID_STACK_VALID || r.stack_status != FID_STACK_VALID)
692 /* Like NaN, any operation involving an invalid ID always fails.
693 Likewise if either ID has an unavailable stack address. */
695 else if (l.artificial_depth > r.artificial_depth
696 && l.stack_addr == r.stack_addr
697 && l.code_addr_p == r.code_addr_p
698 && l.special_addr_p == r.special_addr_p
699 && l.special_addr == r.special_addr)
701 /* Same function, different inlined functions. */
702 const struct block *lb, *rb;
704 gdb_assert (l.code_addr_p && r.code_addr_p);
706 lb = block_for_pc (l.code_addr);
707 rb = block_for_pc (r.code_addr);
709 if (lb == NULL || rb == NULL)
710 /* Something's gone wrong. */
713 /* This will return true if LB and RB are the same block, or
714 if the block with the smaller depth lexically encloses the
715 block with the greater depth. */
716 inner = contained_in (lb, rb);
719 /* Only return non-zero when strictly inner than. Note that, per
720 comment in "frame.h", there is some fuzz here. Frameless
721 functions are not strictly inner than (same .stack but
722 different .code and/or .special address). */
723 inner = gdbarch_inner_than (gdbarch, l.stack_addr, r.stack_addr);
726 fprintf_unfiltered (gdb_stdlog, "{ frame_id_inner (l=");
727 fprint_frame_id (gdb_stdlog, l);
728 fprintf_unfiltered (gdb_stdlog, ",r=");
729 fprint_frame_id (gdb_stdlog, r);
730 fprintf_unfiltered (gdb_stdlog, ") -> %d }\n", inner);
736 frame_find_by_id (struct frame_id id)
738 struct frame_info *frame, *prev_frame;
740 /* ZERO denotes the null frame, let the caller decide what to do
741 about it. Should it instead return get_current_frame()? */
742 if (!frame_id_p (id))
745 /* Try using the frame stash first. Finding it there removes the need
746 to perform the search by looping over all frames, which can be very
747 CPU-intensive if the number of frames is very high (the loop is O(n)
748 and get_prev_frame performs a series of checks that are relatively
749 expensive). This optimization is particularly useful when this function
750 is called from another function (such as value_fetch_lazy, case
751 VALUE_LVAL (val) == lval_register) which already loops over all frames,
752 making the overall behavior O(n^2). */
753 frame = frame_stash_find (id);
757 for (frame = get_current_frame (); ; frame = prev_frame)
759 struct frame_id this = get_frame_id (frame);
761 if (frame_id_eq (id, this))
762 /* An exact match. */
765 prev_frame = get_prev_frame (frame);
769 /* As a safety net to avoid unnecessary backtracing while trying
770 to find an invalid ID, we check for a common situation where
771 we can detect from comparing stack addresses that no other
772 frame in the current frame chain can have this ID. See the
773 comment at frame_id_inner for details. */
774 if (get_frame_type (frame) == NORMAL_FRAME
775 && !frame_id_inner (get_frame_arch (frame), id, this)
776 && frame_id_inner (get_frame_arch (prev_frame), id,
777 get_frame_id (prev_frame)))
784 frame_unwind_pc (struct frame_info *this_frame)
786 if (this_frame->prev_pc.status == CC_UNKNOWN)
788 if (gdbarch_unwind_pc_p (frame_unwind_arch (this_frame)))
790 volatile struct gdb_exception ex;
791 struct gdbarch *prev_gdbarch;
794 /* The right way. The `pure' way. The one true way. This
795 method depends solely on the register-unwind code to
796 determine the value of registers in THIS frame, and hence
797 the value of this frame's PC (resume address). A typical
798 implementation is no more than:
800 frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
801 return extract_unsigned_integer (buf, size of ISA_PC_REGNUM);
803 Note: this method is very heavily dependent on a correct
804 register-unwind implementation, it pays to fix that
805 method first; this method is frame type agnostic, since
806 it only deals with register values, it works with any
807 frame. This is all in stark contrast to the old
808 FRAME_SAVED_PC which would try to directly handle all the
809 different ways that a PC could be unwound. */
810 prev_gdbarch = frame_unwind_arch (this_frame);
812 TRY_CATCH (ex, RETURN_MASK_ERROR)
814 pc = gdbarch_unwind_pc (prev_gdbarch, this_frame);
818 if (ex.error == NOT_AVAILABLE_ERROR)
820 this_frame->prev_pc.status = CC_UNAVAILABLE;
823 fprintf_unfiltered (gdb_stdlog,
824 "{ frame_unwind_pc (this_frame=%d)"
825 " -> <unavailable> }\n",
828 else if (ex.error == OPTIMIZED_OUT_ERROR)
830 this_frame->prev_pc.status = CC_NOT_SAVED;
833 fprintf_unfiltered (gdb_stdlog,
834 "{ frame_unwind_pc (this_frame=%d)"
835 " -> <not saved> }\n",
839 throw_exception (ex);
843 this_frame->prev_pc.value = pc;
844 this_frame->prev_pc.status = CC_VALUE;
846 fprintf_unfiltered (gdb_stdlog,
847 "{ frame_unwind_pc (this_frame=%d) "
850 hex_string (this_frame->prev_pc.value));
854 internal_error (__FILE__, __LINE__, _("No unwind_pc method"));
857 if (this_frame->prev_pc.status == CC_VALUE)
858 return this_frame->prev_pc.value;
859 else if (this_frame->prev_pc.status == CC_UNAVAILABLE)
860 throw_error (NOT_AVAILABLE_ERROR, _("PC not available"));
861 else if (this_frame->prev_pc.status == CC_NOT_SAVED)
862 throw_error (OPTIMIZED_OUT_ERROR, _("PC not saved"));
864 internal_error (__FILE__, __LINE__,
865 "unexpected prev_pc status: %d",
866 (int) this_frame->prev_pc.status);
870 frame_unwind_caller_pc (struct frame_info *this_frame)
872 return frame_unwind_pc (skip_artificial_frames (this_frame));
876 get_frame_func_if_available (struct frame_info *this_frame, CORE_ADDR *pc)
878 struct frame_info *next_frame = this_frame->next;
880 if (!next_frame->prev_func.p)
882 CORE_ADDR addr_in_block;
884 /* Make certain that this, and not the adjacent, function is
886 if (!get_frame_address_in_block_if_available (this_frame, &addr_in_block))
888 next_frame->prev_func.p = -1;
890 fprintf_unfiltered (gdb_stdlog,
891 "{ get_frame_func (this_frame=%d)"
892 " -> unavailable }\n",
897 next_frame->prev_func.p = 1;
898 next_frame->prev_func.addr = get_pc_function_start (addr_in_block);
900 fprintf_unfiltered (gdb_stdlog,
901 "{ get_frame_func (this_frame=%d) -> %s }\n",
903 hex_string (next_frame->prev_func.addr));
907 if (next_frame->prev_func.p < 0)
914 *pc = next_frame->prev_func.addr;
920 get_frame_func (struct frame_info *this_frame)
924 if (!get_frame_func_if_available (this_frame, &pc))
925 throw_error (NOT_AVAILABLE_ERROR, _("PC not available"));
930 static enum register_status
931 do_frame_register_read (void *src, int regnum, gdb_byte *buf)
933 if (!deprecated_frame_register_read (src, regnum, buf))
934 return REG_UNAVAILABLE;
940 frame_save_as_regcache (struct frame_info *this_frame)
942 struct address_space *aspace = get_frame_address_space (this_frame);
943 struct regcache *regcache = regcache_xmalloc (get_frame_arch (this_frame),
945 struct cleanup *cleanups = make_cleanup_regcache_xfree (regcache);
947 regcache_save (regcache, do_frame_register_read, this_frame);
948 discard_cleanups (cleanups);
953 frame_pop (struct frame_info *this_frame)
955 struct frame_info *prev_frame;
956 struct regcache *scratch;
957 struct cleanup *cleanups;
959 if (get_frame_type (this_frame) == DUMMY_FRAME)
961 /* Popping a dummy frame involves restoring more than just registers.
962 dummy_frame_pop does all the work. */
963 dummy_frame_pop (get_frame_id (this_frame));
967 /* Ensure that we have a frame to pop to. */
968 prev_frame = get_prev_frame_always (this_frame);
971 error (_("Cannot pop the initial frame."));
973 /* Ignore TAILCALL_FRAME type frames, they were executed already before
974 entering THISFRAME. */
975 while (get_frame_type (prev_frame) == TAILCALL_FRAME)
976 prev_frame = get_prev_frame (prev_frame);
978 /* Make a copy of all the register values unwound from this frame.
979 Save them in a scratch buffer so that there isn't a race between
980 trying to extract the old values from the current regcache while
981 at the same time writing new values into that same cache. */
982 scratch = frame_save_as_regcache (prev_frame);
983 cleanups = make_cleanup_regcache_xfree (scratch);
985 /* FIXME: cagney/2003-03-16: It should be possible to tell the
986 target's register cache that it is about to be hit with a burst
987 register transfer and that the sequence of register writes should
988 be batched. The pair target_prepare_to_store() and
989 target_store_registers() kind of suggest this functionality.
990 Unfortunately, they don't implement it. Their lack of a formal
991 definition can lead to targets writing back bogus values
992 (arguably a bug in the target code mind). */
993 /* Now copy those saved registers into the current regcache.
994 Here, regcache_cpy() calls regcache_restore(). */
995 regcache_cpy (get_current_regcache (), scratch);
996 do_cleanups (cleanups);
998 /* We've made right mess of GDB's local state, just discard
1000 reinit_frame_cache ();
1004 frame_register_unwind (struct frame_info *frame, int regnum,
1005 int *optimizedp, int *unavailablep,
1006 enum lval_type *lvalp, CORE_ADDR *addrp,
1007 int *realnump, gdb_byte *bufferp)
1009 struct value *value;
1011 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
1012 that the value proper does not need to be fetched. */
1013 gdb_assert (optimizedp != NULL);
1014 gdb_assert (lvalp != NULL);
1015 gdb_assert (addrp != NULL);
1016 gdb_assert (realnump != NULL);
1017 /* gdb_assert (bufferp != NULL); */
1019 value = frame_unwind_register_value (frame, regnum);
1021 gdb_assert (value != NULL);
1023 *optimizedp = value_optimized_out (value);
1024 *unavailablep = !value_entirely_available (value);
1025 *lvalp = VALUE_LVAL (value);
1026 *addrp = value_address (value);
1027 *realnump = VALUE_REGNUM (value);
1031 if (!*optimizedp && !*unavailablep)
1032 memcpy (bufferp, value_contents_all (value),
1033 TYPE_LENGTH (value_type (value)));
1035 memset (bufferp, 0, TYPE_LENGTH (value_type (value)));
1038 /* Dispose of the new value. This prevents watchpoints from
1039 trying to watch the saved frame pointer. */
1040 release_value (value);
1045 frame_register (struct frame_info *frame, int regnum,
1046 int *optimizedp, int *unavailablep, enum lval_type *lvalp,
1047 CORE_ADDR *addrp, int *realnump, gdb_byte *bufferp)
1049 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
1050 that the value proper does not need to be fetched. */
1051 gdb_assert (optimizedp != NULL);
1052 gdb_assert (lvalp != NULL);
1053 gdb_assert (addrp != NULL);
1054 gdb_assert (realnump != NULL);
1055 /* gdb_assert (bufferp != NULL); */
1057 /* Obtain the register value by unwinding the register from the next
1058 (more inner frame). */
1059 gdb_assert (frame != NULL && frame->next != NULL);
1060 frame_register_unwind (frame->next, regnum, optimizedp, unavailablep,
1061 lvalp, addrp, realnump, bufferp);
1065 frame_unwind_register (struct frame_info *frame, int regnum, gdb_byte *buf)
1071 enum lval_type lval;
1073 frame_register_unwind (frame, regnum, &optimized, &unavailable,
1074 &lval, &addr, &realnum, buf);
1077 throw_error (OPTIMIZED_OUT_ERROR,
1078 _("Register %d was not saved"), regnum);
1080 throw_error (NOT_AVAILABLE_ERROR,
1081 _("Register %d is not available"), regnum);
1085 get_frame_register (struct frame_info *frame,
1086 int regnum, gdb_byte *buf)
1088 frame_unwind_register (frame->next, regnum, buf);
1092 frame_unwind_register_value (struct frame_info *frame, int regnum)
1094 struct gdbarch *gdbarch;
1095 struct value *value;
1097 gdb_assert (frame != NULL);
1098 gdbarch = frame_unwind_arch (frame);
1102 fprintf_unfiltered (gdb_stdlog,
1103 "{ frame_unwind_register_value "
1104 "(frame=%d,regnum=%d(%s),...) ",
1105 frame->level, regnum,
1106 user_reg_map_regnum_to_name (gdbarch, regnum));
1109 /* Find the unwinder. */
1110 if (frame->unwind == NULL)
1111 frame_unwind_find_by_frame (frame, &frame->prologue_cache);
1113 /* Ask this frame to unwind its register. */
1114 value = frame->unwind->prev_register (frame, &frame->prologue_cache, regnum);
1118 fprintf_unfiltered (gdb_stdlog, "->");
1119 if (value_optimized_out (value))
1121 fprintf_unfiltered (gdb_stdlog, " ");
1122 val_print_optimized_out (value, gdb_stdlog);
1126 if (VALUE_LVAL (value) == lval_register)
1127 fprintf_unfiltered (gdb_stdlog, " register=%d",
1128 VALUE_REGNUM (value));
1129 else if (VALUE_LVAL (value) == lval_memory)
1130 fprintf_unfiltered (gdb_stdlog, " address=%s",
1132 value_address (value)));
1134 fprintf_unfiltered (gdb_stdlog, " computed");
1136 if (value_lazy (value))
1137 fprintf_unfiltered (gdb_stdlog, " lazy");
1141 const gdb_byte *buf = value_contents (value);
1143 fprintf_unfiltered (gdb_stdlog, " bytes=");
1144 fprintf_unfiltered (gdb_stdlog, "[");
1145 for (i = 0; i < register_size (gdbarch, regnum); i++)
1146 fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
1147 fprintf_unfiltered (gdb_stdlog, "]");
1151 fprintf_unfiltered (gdb_stdlog, " }\n");
1158 get_frame_register_value (struct frame_info *frame, int regnum)
1160 return frame_unwind_register_value (frame->next, regnum);
1164 frame_unwind_register_signed (struct frame_info *frame, int regnum)
1166 struct gdbarch *gdbarch = frame_unwind_arch (frame);
1167 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1168 int size = register_size (gdbarch, regnum);
1169 gdb_byte buf[MAX_REGISTER_SIZE];
1171 frame_unwind_register (frame, regnum, buf);
1172 return extract_signed_integer (buf, size, byte_order);
1176 get_frame_register_signed (struct frame_info *frame, int regnum)
1178 return frame_unwind_register_signed (frame->next, regnum);
1182 frame_unwind_register_unsigned (struct frame_info *frame, int regnum)
1184 struct gdbarch *gdbarch = frame_unwind_arch (frame);
1185 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1186 int size = register_size (gdbarch, regnum);
1187 gdb_byte buf[MAX_REGISTER_SIZE];
1189 frame_unwind_register (frame, regnum, buf);
1190 return extract_unsigned_integer (buf, size, byte_order);
1194 get_frame_register_unsigned (struct frame_info *frame, int regnum)
1196 return frame_unwind_register_unsigned (frame->next, regnum);
1200 read_frame_register_unsigned (struct frame_info *frame, int regnum,
1203 struct value *regval = get_frame_register_value (frame, regnum);
1205 if (!value_optimized_out (regval)
1206 && value_entirely_available (regval))
1208 struct gdbarch *gdbarch = get_frame_arch (frame);
1209 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1210 int size = register_size (gdbarch, VALUE_REGNUM (regval));
1212 *val = extract_unsigned_integer (value_contents (regval), size, byte_order);
1220 put_frame_register (struct frame_info *frame, int regnum,
1221 const gdb_byte *buf)
1223 struct gdbarch *gdbarch = get_frame_arch (frame);
1227 enum lval_type lval;
1230 frame_register (frame, regnum, &optim, &unavail,
1231 &lval, &addr, &realnum, NULL);
1233 error (_("Attempt to assign to a register that was not saved."));
1238 write_memory (addr, buf, register_size (gdbarch, regnum));
1242 regcache_cooked_write (get_current_regcache (), realnum, buf);
1245 error (_("Attempt to assign to an unmodifiable value."));
1249 /* This function is deprecated. Use get_frame_register_value instead,
1250 which provides more accurate information.
1252 Find and return the value of REGNUM for the specified stack frame.
1253 The number of bytes copied is REGISTER_SIZE (REGNUM).
1255 Returns 0 if the register value could not be found. */
1258 deprecated_frame_register_read (struct frame_info *frame, int regnum,
1263 enum lval_type lval;
1267 frame_register (frame, regnum, &optimized, &unavailable,
1268 &lval, &addr, &realnum, myaddr);
1270 return !optimized && !unavailable;
1274 get_frame_register_bytes (struct frame_info *frame, int regnum,
1275 CORE_ADDR offset, int len, gdb_byte *myaddr,
1276 int *optimizedp, int *unavailablep)
1278 struct gdbarch *gdbarch = get_frame_arch (frame);
1283 /* Skip registers wholly inside of OFFSET. */
1284 while (offset >= register_size (gdbarch, regnum))
1286 offset -= register_size (gdbarch, regnum);
1290 /* Ensure that we will not read beyond the end of the register file.
1291 This can only ever happen if the debug information is bad. */
1293 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1294 for (i = regnum; i < numregs; i++)
1296 int thissize = register_size (gdbarch, i);
1299 break; /* This register is not available on this architecture. */
1300 maxsize += thissize;
1303 error (_("Bad debug information detected: "
1304 "Attempt to read %d bytes from registers."), len);
1306 /* Copy the data. */
1309 int curr_len = register_size (gdbarch, regnum) - offset;
1314 if (curr_len == register_size (gdbarch, regnum))
1316 enum lval_type lval;
1320 frame_register (frame, regnum, optimizedp, unavailablep,
1321 &lval, &addr, &realnum, myaddr);
1322 if (*optimizedp || *unavailablep)
1327 gdb_byte buf[MAX_REGISTER_SIZE];
1328 enum lval_type lval;
1332 frame_register (frame, regnum, optimizedp, unavailablep,
1333 &lval, &addr, &realnum, buf);
1334 if (*optimizedp || *unavailablep)
1336 memcpy (myaddr, buf + offset, curr_len);
1351 put_frame_register_bytes (struct frame_info *frame, int regnum,
1352 CORE_ADDR offset, int len, const gdb_byte *myaddr)
1354 struct gdbarch *gdbarch = get_frame_arch (frame);
1356 /* Skip registers wholly inside of OFFSET. */
1357 while (offset >= register_size (gdbarch, regnum))
1359 offset -= register_size (gdbarch, regnum);
1363 /* Copy the data. */
1366 int curr_len = register_size (gdbarch, regnum) - offset;
1371 if (curr_len == register_size (gdbarch, regnum))
1373 put_frame_register (frame, regnum, myaddr);
1377 gdb_byte buf[MAX_REGISTER_SIZE];
1379 deprecated_frame_register_read (frame, regnum, buf);
1380 memcpy (buf + offset, myaddr, curr_len);
1381 put_frame_register (frame, regnum, buf);
1391 /* Create a sentinel frame. */
1393 static struct frame_info *
1394 create_sentinel_frame (struct program_space *pspace, struct regcache *regcache)
1396 struct frame_info *frame = FRAME_OBSTACK_ZALLOC (struct frame_info);
1399 frame->pspace = pspace;
1400 frame->aspace = get_regcache_aspace (regcache);
1401 /* Explicitly initialize the sentinel frame's cache. Provide it
1402 with the underlying regcache. In the future additional
1403 information, such as the frame's thread will be added. */
1404 frame->prologue_cache = sentinel_frame_cache (regcache);
1405 /* For the moment there is only one sentinel frame implementation. */
1406 frame->unwind = &sentinel_frame_unwind;
1407 /* Link this frame back to itself. The frame is self referential
1408 (the unwound PC is the same as the pc), so make it so. */
1409 frame->next = frame;
1410 /* Make the sentinel frame's ID valid, but invalid. That way all
1411 comparisons with it should fail. */
1412 frame->this_id.p = 1;
1413 frame->this_id.value = null_frame_id;
1416 fprintf_unfiltered (gdb_stdlog, "{ create_sentinel_frame (...) -> ");
1417 fprint_frame (gdb_stdlog, frame);
1418 fprintf_unfiltered (gdb_stdlog, " }\n");
1423 /* Info about the innermost stack frame (contents of FP register). */
1425 static struct frame_info *current_frame;
1427 /* Cache for frame addresses already read by gdb. Valid only while
1428 inferior is stopped. Control variables for the frame cache should
1429 be local to this module. */
1431 static struct obstack frame_cache_obstack;
1434 frame_obstack_zalloc (unsigned long size)
1436 void *data = obstack_alloc (&frame_cache_obstack, size);
1438 memset (data, 0, size);
1442 /* Return the innermost (currently executing) stack frame. This is
1443 split into two functions. The function unwind_to_current_frame()
1444 is wrapped in catch exceptions so that, even when the unwind of the
1445 sentinel frame fails, the function still returns a stack frame. */
1448 unwind_to_current_frame (struct ui_out *ui_out, void *args)
1450 struct frame_info *frame = get_prev_frame (args);
1452 /* A sentinel frame can fail to unwind, e.g., because its PC value
1453 lands in somewhere like start. */
1456 current_frame = frame;
1461 get_current_frame (void)
1463 /* First check, and report, the lack of registers. Having GDB
1464 report "No stack!" or "No memory" when the target doesn't even
1465 have registers is very confusing. Besides, "printcmd.exp"
1466 explicitly checks that ``print $pc'' with no registers prints "No
1468 if (!target_has_registers)
1469 error (_("No registers."));
1470 if (!target_has_stack)
1471 error (_("No stack."));
1472 if (!target_has_memory)
1473 error (_("No memory."));
1474 /* Traceframes are effectively a substitute for the live inferior. */
1475 if (get_traceframe_number () < 0)
1477 if (ptid_equal (inferior_ptid, null_ptid))
1478 error (_("No selected thread."));
1479 if (is_exited (inferior_ptid))
1480 error (_("Invalid selected thread."));
1481 if (is_executing (inferior_ptid))
1482 error (_("Target is executing."));
1485 if (current_frame == NULL)
1487 struct frame_info *sentinel_frame =
1488 create_sentinel_frame (current_program_space, get_current_regcache ());
1489 if (catch_exceptions (current_uiout, unwind_to_current_frame,
1490 sentinel_frame, RETURN_MASK_ERROR) != 0)
1492 /* Oops! Fake a current frame? Is this useful? It has a PC
1493 of zero, for instance. */
1494 current_frame = sentinel_frame;
1497 return current_frame;
1500 /* The "selected" stack frame is used by default for local and arg
1501 access. May be zero, for no selected frame. */
1503 static struct frame_info *selected_frame;
1506 has_stack_frames (void)
1508 if (!target_has_registers || !target_has_stack || !target_has_memory)
1511 /* Traceframes are effectively a substitute for the live inferior. */
1512 if (get_traceframe_number () < 0)
1514 /* No current inferior, no frame. */
1515 if (ptid_equal (inferior_ptid, null_ptid))
1518 /* Don't try to read from a dead thread. */
1519 if (is_exited (inferior_ptid))
1522 /* ... or from a spinning thread. */
1523 if (is_executing (inferior_ptid))
1530 /* Return the selected frame. Always non-NULL (unless there isn't an
1531 inferior sufficient for creating a frame) in which case an error is
1535 get_selected_frame (const char *message)
1537 if (selected_frame == NULL)
1539 if (message != NULL && !has_stack_frames ())
1540 error (("%s"), message);
1541 /* Hey! Don't trust this. It should really be re-finding the
1542 last selected frame of the currently selected thread. This,
1543 though, is better than nothing. */
1544 select_frame (get_current_frame ());
1546 /* There is always a frame. */
1547 gdb_assert (selected_frame != NULL);
1548 return selected_frame;
1551 /* If there is a selected frame, return it. Otherwise, return NULL. */
1554 get_selected_frame_if_set (void)
1556 return selected_frame;
1559 /* This is a variant of get_selected_frame() which can be called when
1560 the inferior does not have a frame; in that case it will return
1561 NULL instead of calling error(). */
1564 deprecated_safe_get_selected_frame (void)
1566 if (!has_stack_frames ())
1568 return get_selected_frame (NULL);
1571 /* Select frame FI (or NULL - to invalidate the current frame). */
1574 select_frame (struct frame_info *fi)
1576 selected_frame = fi;
1577 /* NOTE: cagney/2002-05-04: FI can be NULL. This occurs when the
1578 frame is being invalidated. */
1579 if (deprecated_selected_frame_level_changed_hook)
1580 deprecated_selected_frame_level_changed_hook (frame_relative_level (fi));
1582 /* FIXME: kseitz/2002-08-28: It would be nice to call
1583 selected_frame_level_changed_event() right here, but due to limitations
1584 in the current interfaces, we would end up flooding UIs with events
1585 because select_frame() is used extensively internally.
1587 Once we have frame-parameterized frame (and frame-related) commands,
1588 the event notification can be moved here, since this function will only
1589 be called when the user's selected frame is being changed. */
1591 /* Ensure that symbols for this frame are read in. Also, determine the
1592 source language of this frame, and switch to it if desired. */
1597 /* We retrieve the frame's symtab by using the frame PC.
1598 However we cannot use the frame PC as-is, because it usually
1599 points to the instruction following the "call", which is
1600 sometimes the first instruction of another function. So we
1601 rely on get_frame_address_in_block() which provides us with a
1602 PC which is guaranteed to be inside the frame's code
1604 if (get_frame_address_in_block_if_available (fi, &pc))
1606 struct symtab *s = find_pc_symtab (pc);
1609 && s->language != current_language->la_language
1610 && s->language != language_unknown
1611 && language_mode == language_mode_auto)
1612 set_language (s->language);
1617 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
1618 Always returns a non-NULL value. */
1621 create_new_frame (CORE_ADDR addr, CORE_ADDR pc)
1623 struct frame_info *fi;
1627 fprintf_unfiltered (gdb_stdlog,
1628 "{ create_new_frame (addr=%s, pc=%s) ",
1629 hex_string (addr), hex_string (pc));
1632 fi = FRAME_OBSTACK_ZALLOC (struct frame_info);
1634 fi->next = create_sentinel_frame (current_program_space,
1635 get_current_regcache ());
1637 /* Set/update this frame's cached PC value, found in the next frame.
1638 Do this before looking for this frame's unwinder. A sniffer is
1639 very likely to read this, and the corresponding unwinder is
1640 entitled to rely that the PC doesn't magically change. */
1641 fi->next->prev_pc.value = pc;
1642 fi->next->prev_pc.status = CC_VALUE;
1644 /* We currently assume that frame chain's can't cross spaces. */
1645 fi->pspace = fi->next->pspace;
1646 fi->aspace = fi->next->aspace;
1648 /* Select/initialize both the unwind function and the frame's type
1650 frame_unwind_find_by_frame (fi, &fi->prologue_cache);
1653 fi->this_id.value = frame_id_build (addr, pc);
1657 fprintf_unfiltered (gdb_stdlog, "-> ");
1658 fprint_frame (gdb_stdlog, fi);
1659 fprintf_unfiltered (gdb_stdlog, " }\n");
1665 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
1666 innermost frame). Be careful to not fall off the bottom of the
1667 frame chain and onto the sentinel frame. */
1670 get_next_frame (struct frame_info *this_frame)
1672 if (this_frame->level > 0)
1673 return this_frame->next;
1678 /* Observer for the target_changed event. */
1681 frame_observer_target_changed (struct target_ops *target)
1683 reinit_frame_cache ();
1686 /* Flush the entire frame cache. */
1689 reinit_frame_cache (void)
1691 struct frame_info *fi;
1693 /* Tear down all frame caches. */
1694 for (fi = current_frame; fi != NULL; fi = fi->prev)
1696 if (fi->prologue_cache && fi->unwind->dealloc_cache)
1697 fi->unwind->dealloc_cache (fi, fi->prologue_cache);
1698 if (fi->base_cache && fi->base->unwind->dealloc_cache)
1699 fi->base->unwind->dealloc_cache (fi, fi->base_cache);
1702 /* Since we can't really be sure what the first object allocated was. */
1703 obstack_free (&frame_cache_obstack, 0);
1704 obstack_init (&frame_cache_obstack);
1706 if (current_frame != NULL)
1707 annotate_frames_invalid ();
1709 current_frame = NULL; /* Invalidate cache */
1710 select_frame (NULL);
1711 frame_stash_invalidate ();
1713 fprintf_unfiltered (gdb_stdlog, "{ reinit_frame_cache () }\n");
1716 /* Find where a register is saved (in memory or another register).
1717 The result of frame_register_unwind is just where it is saved
1718 relative to this particular frame. */
1721 frame_register_unwind_location (struct frame_info *this_frame, int regnum,
1722 int *optimizedp, enum lval_type *lvalp,
1723 CORE_ADDR *addrp, int *realnump)
1725 gdb_assert (this_frame == NULL || this_frame->level >= 0);
1727 while (this_frame != NULL)
1731 frame_register_unwind (this_frame, regnum, optimizedp, &unavailable,
1732 lvalp, addrp, realnump, NULL);
1737 if (*lvalp != lval_register)
1741 this_frame = get_next_frame (this_frame);
1745 /* Called during frame unwinding to remove a previous frame pointer from a
1746 frame passed in ARG. */
1749 remove_prev_frame (void *arg)
1751 struct frame_info *this_frame, *prev_frame;
1753 this_frame = (struct frame_info *) arg;
1754 prev_frame = this_frame->prev;
1755 gdb_assert (prev_frame != NULL);
1757 prev_frame->next = NULL;
1758 this_frame->prev = NULL;
1761 /* Get the previous raw frame, and check that it is not identical to
1762 same other frame frame already in the chain. If it is, there is
1763 most likely a stack cycle, so we discard it, and mark THIS_FRAME as
1764 outermost, with UNWIND_SAME_ID stop reason. Unlike the other
1765 validity tests, that compare THIS_FRAME and the next frame, we do
1766 this right after creating the previous frame, to avoid ever ending
1767 up with two frames with the same id in the frame chain. */
1769 static struct frame_info *
1770 get_prev_frame_if_no_cycle (struct frame_info *this_frame)
1772 struct frame_info *prev_frame;
1773 struct cleanup *prev_frame_cleanup;
1775 prev_frame = get_prev_frame_raw (this_frame);
1776 if (prev_frame == NULL)
1779 /* The cleanup will remove the previous frame that get_prev_frame_raw
1780 linked onto THIS_FRAME. */
1781 prev_frame_cleanup = make_cleanup (remove_prev_frame, this_frame);
1783 compute_frame_id (prev_frame);
1784 if (!frame_stash_add (prev_frame))
1786 /* Another frame with the same id was already in the stash. We just
1787 detected a cycle. */
1790 fprintf_unfiltered (gdb_stdlog, "-> ");
1791 fprint_frame (gdb_stdlog, NULL);
1792 fprintf_unfiltered (gdb_stdlog, " // this frame has same ID }\n");
1794 this_frame->stop_reason = UNWIND_SAME_ID;
1796 prev_frame->next = NULL;
1797 this_frame->prev = NULL;
1801 discard_cleanups (prev_frame_cleanup);
1805 /* Helper function for get_prev_frame_always, this is called inside a
1806 TRY_CATCH block. Return the frame that called THIS_FRAME or NULL if
1807 there is no such frame. This may throw an exception. */
1809 static struct frame_info *
1810 get_prev_frame_always_1 (struct frame_info *this_frame)
1812 struct gdbarch *gdbarch;
1814 gdb_assert (this_frame != NULL);
1815 gdbarch = get_frame_arch (this_frame);
1819 fprintf_unfiltered (gdb_stdlog, "{ get_prev_frame_always (this_frame=");
1820 if (this_frame != NULL)
1821 fprintf_unfiltered (gdb_stdlog, "%d", this_frame->level);
1823 fprintf_unfiltered (gdb_stdlog, "<NULL>");
1824 fprintf_unfiltered (gdb_stdlog, ") ");
1827 /* Only try to do the unwind once. */
1828 if (this_frame->prev_p)
1832 fprintf_unfiltered (gdb_stdlog, "-> ");
1833 fprint_frame (gdb_stdlog, this_frame->prev);
1834 fprintf_unfiltered (gdb_stdlog, " // cached \n");
1836 return this_frame->prev;
1839 /* If the frame unwinder hasn't been selected yet, we must do so
1840 before setting prev_p; otherwise the check for misbehaved
1841 sniffers will think that this frame's sniffer tried to unwind
1842 further (see frame_cleanup_after_sniffer). */
1843 if (this_frame->unwind == NULL)
1844 frame_unwind_find_by_frame (this_frame, &this_frame->prologue_cache);
1846 this_frame->prev_p = 1;
1847 this_frame->stop_reason = UNWIND_NO_REASON;
1849 /* If we are unwinding from an inline frame, all of the below tests
1850 were already performed when we unwound from the next non-inline
1851 frame. We must skip them, since we can not get THIS_FRAME's ID
1852 until we have unwound all the way down to the previous non-inline
1854 if (get_frame_type (this_frame) == INLINE_FRAME)
1855 return get_prev_frame_if_no_cycle (this_frame);
1857 /* Check that this frame is unwindable. If it isn't, don't try to
1858 unwind to the prev frame. */
1859 this_frame->stop_reason
1860 = this_frame->unwind->stop_reason (this_frame,
1861 &this_frame->prologue_cache);
1863 if (this_frame->stop_reason != UNWIND_NO_REASON)
1867 enum unwind_stop_reason reason = this_frame->stop_reason;
1869 fprintf_unfiltered (gdb_stdlog, "-> ");
1870 fprint_frame (gdb_stdlog, NULL);
1871 fprintf_unfiltered (gdb_stdlog, " // %s }\n",
1872 frame_stop_reason_symbol_string (reason));
1877 /* Check that this frame's ID isn't inner to (younger, below, next)
1878 the next frame. This happens when a frame unwind goes backwards.
1879 This check is valid only if this frame and the next frame are NORMAL.
1880 See the comment at frame_id_inner for details. */
1881 if (get_frame_type (this_frame) == NORMAL_FRAME
1882 && this_frame->next->unwind->type == NORMAL_FRAME
1883 && frame_id_inner (get_frame_arch (this_frame->next),
1884 get_frame_id (this_frame),
1885 get_frame_id (this_frame->next)))
1887 CORE_ADDR this_pc_in_block;
1888 struct minimal_symbol *morestack_msym;
1889 const char *morestack_name = NULL;
1891 /* gcc -fsplit-stack __morestack can continue the stack anywhere. */
1892 this_pc_in_block = get_frame_address_in_block (this_frame);
1893 morestack_msym = lookup_minimal_symbol_by_pc (this_pc_in_block).minsym;
1895 morestack_name = MSYMBOL_LINKAGE_NAME (morestack_msym);
1896 if (!morestack_name || strcmp (morestack_name, "__morestack") != 0)
1900 fprintf_unfiltered (gdb_stdlog, "-> ");
1901 fprint_frame (gdb_stdlog, NULL);
1902 fprintf_unfiltered (gdb_stdlog,
1903 " // this frame ID is inner }\n");
1905 this_frame->stop_reason = UNWIND_INNER_ID;
1910 /* Check that this and the next frame do not unwind the PC register
1911 to the same memory location. If they do, then even though they
1912 have different frame IDs, the new frame will be bogus; two
1913 functions can't share a register save slot for the PC. This can
1914 happen when the prologue analyzer finds a stack adjustment, but
1917 This check does assume that the "PC register" is roughly a
1918 traditional PC, even if the gdbarch_unwind_pc method adjusts
1919 it (we do not rely on the value, only on the unwound PC being
1920 dependent on this value). A potential improvement would be
1921 to have the frame prev_pc method and the gdbarch unwind_pc
1922 method set the same lval and location information as
1923 frame_register_unwind. */
1924 if (this_frame->level > 0
1925 && gdbarch_pc_regnum (gdbarch) >= 0
1926 && get_frame_type (this_frame) == NORMAL_FRAME
1927 && (get_frame_type (this_frame->next) == NORMAL_FRAME
1928 || get_frame_type (this_frame->next) == INLINE_FRAME))
1930 int optimized, realnum, nrealnum;
1931 enum lval_type lval, nlval;
1932 CORE_ADDR addr, naddr;
1934 frame_register_unwind_location (this_frame,
1935 gdbarch_pc_regnum (gdbarch),
1936 &optimized, &lval, &addr, &realnum);
1937 frame_register_unwind_location (get_next_frame (this_frame),
1938 gdbarch_pc_regnum (gdbarch),
1939 &optimized, &nlval, &naddr, &nrealnum);
1941 if ((lval == lval_memory && lval == nlval && addr == naddr)
1942 || (lval == lval_register && lval == nlval && realnum == nrealnum))
1946 fprintf_unfiltered (gdb_stdlog, "-> ");
1947 fprint_frame (gdb_stdlog, NULL);
1948 fprintf_unfiltered (gdb_stdlog, " // no saved PC }\n");
1951 this_frame->stop_reason = UNWIND_NO_SAVED_PC;
1952 this_frame->prev = NULL;
1957 return get_prev_frame_if_no_cycle (this_frame);
1960 /* Return a "struct frame_info" corresponding to the frame that called
1961 THIS_FRAME. Returns NULL if there is no such frame.
1963 Unlike get_prev_frame, this function always tries to unwind the
1967 get_prev_frame_always (struct frame_info *this_frame)
1969 volatile struct gdb_exception ex;
1970 struct frame_info *prev_frame = NULL;
1972 TRY_CATCH (ex, RETURN_MASK_ERROR)
1974 prev_frame = get_prev_frame_always_1 (this_frame);
1978 if (ex.error == MEMORY_ERROR)
1980 this_frame->stop_reason = UNWIND_MEMORY_ERROR;
1981 if (ex.message != NULL)
1986 /* The error needs to live as long as the frame does.
1987 Allocate using stack local STOP_STRING then assign the
1988 pointer to the frame, this allows the STOP_STRING on the
1989 frame to be of type 'const char *'. */
1990 size = strlen (ex.message) + 1;
1991 stop_string = frame_obstack_zalloc (size);
1992 memcpy (stop_string, ex.message, size);
1993 this_frame->stop_string = stop_string;
1998 throw_exception (ex);
2004 /* Construct a new "struct frame_info" and link it previous to
2007 static struct frame_info *
2008 get_prev_frame_raw (struct frame_info *this_frame)
2010 struct frame_info *prev_frame;
2012 /* Allocate the new frame but do not wire it in to the frame chain.
2013 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
2014 frame->next to pull some fancy tricks (of course such code is, by
2015 definition, recursive). Try to prevent it.
2017 There is no reason to worry about memory leaks, should the
2018 remainder of the function fail. The allocated memory will be
2019 quickly reclaimed when the frame cache is flushed, and the `we've
2020 been here before' check above will stop repeated memory
2021 allocation calls. */
2022 prev_frame = FRAME_OBSTACK_ZALLOC (struct frame_info);
2023 prev_frame->level = this_frame->level + 1;
2025 /* For now, assume we don't have frame chains crossing address
2027 prev_frame->pspace = this_frame->pspace;
2028 prev_frame->aspace = this_frame->aspace;
2030 /* Don't yet compute ->unwind (and hence ->type). It is computed
2031 on-demand in get_frame_type, frame_register_unwind, and
2034 /* Don't yet compute the frame's ID. It is computed on-demand by
2037 /* The unwound frame ID is validate at the start of this function,
2038 as part of the logic to decide if that frame should be further
2039 unwound, and not here while the prev frame is being created.
2040 Doing this makes it possible for the user to examine a frame that
2041 has an invalid frame ID.
2043 Some very old VAX code noted: [...] For the sake of argument,
2044 suppose that the stack is somewhat trashed (which is one reason
2045 that "info frame" exists). So, return 0 (indicating we don't
2046 know the address of the arglist) if we don't know what frame this
2050 this_frame->prev = prev_frame;
2051 prev_frame->next = this_frame;
2055 fprintf_unfiltered (gdb_stdlog, "-> ");
2056 fprint_frame (gdb_stdlog, prev_frame);
2057 fprintf_unfiltered (gdb_stdlog, " }\n");
2063 /* Debug routine to print a NULL frame being returned. */
2066 frame_debug_got_null_frame (struct frame_info *this_frame,
2071 fprintf_unfiltered (gdb_stdlog, "{ get_prev_frame (this_frame=");
2072 if (this_frame != NULL)
2073 fprintf_unfiltered (gdb_stdlog, "%d", this_frame->level);
2075 fprintf_unfiltered (gdb_stdlog, "<NULL>");
2076 fprintf_unfiltered (gdb_stdlog, ") -> // %s}\n", reason);
2080 /* Is this (non-sentinel) frame in the "main"() function? */
2083 inside_main_func (struct frame_info *this_frame)
2085 struct bound_minimal_symbol msymbol;
2088 if (symfile_objfile == 0)
2090 msymbol = lookup_minimal_symbol (main_name (), NULL, symfile_objfile);
2091 if (msymbol.minsym == NULL)
2093 /* Make certain that the code, and not descriptor, address is
2095 maddr = gdbarch_convert_from_func_ptr_addr (get_frame_arch (this_frame),
2096 BMSYMBOL_VALUE_ADDRESS (msymbol),
2098 return maddr == get_frame_func (this_frame);
2101 /* Test whether THIS_FRAME is inside the process entry point function. */
2104 inside_entry_func (struct frame_info *this_frame)
2106 CORE_ADDR entry_point;
2108 if (!entry_point_address_query (&entry_point))
2111 return get_frame_func (this_frame) == entry_point;
2114 /* Return a structure containing various interesting information about
2115 the frame that called THIS_FRAME. Returns NULL if there is entier
2116 no such frame or the frame fails any of a set of target-independent
2117 condition that should terminate the frame chain (e.g., as unwinding
2120 This function should not contain target-dependent tests, such as
2121 checking whether the program-counter is zero. */
2124 get_prev_frame (struct frame_info *this_frame)
2129 /* There is always a frame. If this assertion fails, suspect that
2130 something should be calling get_selected_frame() or
2131 get_current_frame(). */
2132 gdb_assert (this_frame != NULL);
2133 frame_pc_p = get_frame_pc_if_available (this_frame, &frame_pc);
2135 /* tausq/2004-12-07: Dummy frames are skipped because it doesn't make much
2136 sense to stop unwinding at a dummy frame. One place where a dummy
2137 frame may have an address "inside_main_func" is on HPUX. On HPUX, the
2138 pcsqh register (space register for the instruction at the head of the
2139 instruction queue) cannot be written directly; the only way to set it
2140 is to branch to code that is in the target space. In order to implement
2141 frame dummies on HPUX, the called function is made to jump back to where
2142 the inferior was when the user function was called. If gdb was inside
2143 the main function when we created the dummy frame, the dummy frame will
2144 point inside the main function. */
2145 if (this_frame->level >= 0
2146 && get_frame_type (this_frame) == NORMAL_FRAME
2147 && !backtrace_past_main
2149 && inside_main_func (this_frame))
2150 /* Don't unwind past main(). Note, this is done _before_ the
2151 frame has been marked as previously unwound. That way if the
2152 user later decides to enable unwinds past main(), that will
2153 automatically happen. */
2155 frame_debug_got_null_frame (this_frame, "inside main func");
2159 /* If the user's backtrace limit has been exceeded, stop. We must
2160 add two to the current level; one of those accounts for backtrace_limit
2161 being 1-based and the level being 0-based, and the other accounts for
2162 the level of the new frame instead of the level of the current
2164 if (this_frame->level + 2 > backtrace_limit)
2166 frame_debug_got_null_frame (this_frame, "backtrace limit exceeded");
2170 /* If we're already inside the entry function for the main objfile,
2171 then it isn't valid. Don't apply this test to a dummy frame -
2172 dummy frame PCs typically land in the entry func. Don't apply
2173 this test to the sentinel frame. Sentinel frames should always
2174 be allowed to unwind. */
2175 /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() -
2176 wasn't checking for "main" in the minimal symbols. With that
2177 fixed asm-source tests now stop in "main" instead of halting the
2178 backtrace in weird and wonderful ways somewhere inside the entry
2179 file. Suspect that tests for inside the entry file/func were
2180 added to work around that (now fixed) case. */
2181 /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
2182 suggested having the inside_entry_func test use the
2183 inside_main_func() msymbol trick (along with entry_point_address()
2184 I guess) to determine the address range of the start function.
2185 That should provide a far better stopper than the current
2187 /* NOTE: tausq/2004-10-09: this is needed if, for example, the compiler
2188 applied tail-call optimizations to main so that a function called
2189 from main returns directly to the caller of main. Since we don't
2190 stop at main, we should at least stop at the entry point of the
2192 if (this_frame->level >= 0
2193 && get_frame_type (this_frame) == NORMAL_FRAME
2194 && !backtrace_past_entry
2196 && inside_entry_func (this_frame))
2198 frame_debug_got_null_frame (this_frame, "inside entry func");
2202 /* Assume that the only way to get a zero PC is through something
2203 like a SIGSEGV or a dummy frame, and hence that NORMAL frames
2204 will never unwind a zero PC. */
2205 if (this_frame->level > 0
2206 && (get_frame_type (this_frame) == NORMAL_FRAME
2207 || get_frame_type (this_frame) == INLINE_FRAME)
2208 && get_frame_type (get_next_frame (this_frame)) == NORMAL_FRAME
2209 && frame_pc_p && frame_pc == 0)
2211 frame_debug_got_null_frame (this_frame, "zero PC");
2215 return get_prev_frame_always (this_frame);
2219 get_frame_pc (struct frame_info *frame)
2221 gdb_assert (frame->next != NULL);
2222 return frame_unwind_pc (frame->next);
2226 get_frame_pc_if_available (struct frame_info *frame, CORE_ADDR *pc)
2228 volatile struct gdb_exception ex;
2230 gdb_assert (frame->next != NULL);
2232 TRY_CATCH (ex, RETURN_MASK_ERROR)
2234 *pc = frame_unwind_pc (frame->next);
2238 if (ex.error == NOT_AVAILABLE_ERROR)
2241 throw_exception (ex);
2247 /* Return an address that falls within THIS_FRAME's code block. */
2250 get_frame_address_in_block (struct frame_info *this_frame)
2252 /* A draft address. */
2253 CORE_ADDR pc = get_frame_pc (this_frame);
2255 struct frame_info *next_frame = this_frame->next;
2257 /* Calling get_frame_pc returns the resume address for THIS_FRAME.
2258 Normally the resume address is inside the body of the function
2259 associated with THIS_FRAME, but there is a special case: when
2260 calling a function which the compiler knows will never return
2261 (for instance abort), the call may be the very last instruction
2262 in the calling function. The resume address will point after the
2263 call and may be at the beginning of a different function
2266 If THIS_FRAME is a signal frame or dummy frame, then we should
2267 not adjust the unwound PC. For a dummy frame, GDB pushed the
2268 resume address manually onto the stack. For a signal frame, the
2269 OS may have pushed the resume address manually and invoked the
2270 handler (e.g. GNU/Linux), or invoked the trampoline which called
2271 the signal handler - but in either case the signal handler is
2272 expected to return to the trampoline. So in both of these
2273 cases we know that the resume address is executable and
2274 related. So we only need to adjust the PC if THIS_FRAME
2275 is a normal function.
2277 If the program has been interrupted while THIS_FRAME is current,
2278 then clearly the resume address is inside the associated
2279 function. There are three kinds of interruption: debugger stop
2280 (next frame will be SENTINEL_FRAME), operating system
2281 signal or exception (next frame will be SIGTRAMP_FRAME),
2282 or debugger-induced function call (next frame will be
2283 DUMMY_FRAME). So we only need to adjust the PC if
2284 NEXT_FRAME is a normal function.
2286 We check the type of NEXT_FRAME first, since it is already
2287 known; frame type is determined by the unwinder, and since
2288 we have THIS_FRAME we've already selected an unwinder for
2291 If the next frame is inlined, we need to keep going until we find
2292 the real function - for instance, if a signal handler is invoked
2293 while in an inlined function, then the code address of the
2294 "calling" normal function should not be adjusted either. */
2296 while (get_frame_type (next_frame) == INLINE_FRAME)
2297 next_frame = next_frame->next;
2299 if ((get_frame_type (next_frame) == NORMAL_FRAME
2300 || get_frame_type (next_frame) == TAILCALL_FRAME)
2301 && (get_frame_type (this_frame) == NORMAL_FRAME
2302 || get_frame_type (this_frame) == TAILCALL_FRAME
2303 || get_frame_type (this_frame) == INLINE_FRAME))
2310 get_frame_address_in_block_if_available (struct frame_info *this_frame,
2313 volatile struct gdb_exception ex;
2315 TRY_CATCH (ex, RETURN_MASK_ERROR)
2317 *pc = get_frame_address_in_block (this_frame);
2319 if (ex.reason < 0 && ex.error == NOT_AVAILABLE_ERROR)
2321 else if (ex.reason < 0)
2322 throw_exception (ex);
2328 find_frame_sal (struct frame_info *frame, struct symtab_and_line *sal)
2330 struct frame_info *next_frame;
2334 /* If the next frame represents an inlined function call, this frame's
2335 sal is the "call site" of that inlined function, which can not
2336 be inferred from get_frame_pc. */
2337 next_frame = get_next_frame (frame);
2338 if (frame_inlined_callees (frame) > 0)
2343 sym = get_frame_function (next_frame);
2345 sym = inline_skipped_symbol (inferior_ptid);
2347 /* If frame is inline, it certainly has symbols. */
2350 if (SYMBOL_LINE (sym) != 0)
2352 sal->symtab = SYMBOL_SYMTAB (sym);
2353 sal->line = SYMBOL_LINE (sym);
2356 /* If the symbol does not have a location, we don't know where
2357 the call site is. Do not pretend to. This is jarring, but
2358 we can't do much better. */
2359 sal->pc = get_frame_pc (frame);
2361 sal->pspace = get_frame_program_space (frame);
2366 /* If FRAME is not the innermost frame, that normally means that
2367 FRAME->pc points at the return instruction (which is *after* the
2368 call instruction), and we want to get the line containing the
2369 call (because the call is where the user thinks the program is).
2370 However, if the next frame is either a SIGTRAMP_FRAME or a
2371 DUMMY_FRAME, then the next frame will contain a saved interrupt
2372 PC and such a PC indicates the current (rather than next)
2373 instruction/line, consequently, for such cases, want to get the
2374 line containing fi->pc. */
2375 if (!get_frame_pc_if_available (frame, &pc))
2381 notcurrent = (pc != get_frame_address_in_block (frame));
2382 (*sal) = find_pc_line (pc, notcurrent);
2385 /* Per "frame.h", return the ``address'' of the frame. Code should
2386 really be using get_frame_id(). */
2388 get_frame_base (struct frame_info *fi)
2390 return get_frame_id (fi).stack_addr;
2393 /* High-level offsets into the frame. Used by the debug info. */
2396 get_frame_base_address (struct frame_info *fi)
2398 if (get_frame_type (fi) != NORMAL_FRAME)
2400 if (fi->base == NULL)
2401 fi->base = frame_base_find_by_frame (fi);
2402 /* Sneaky: If the low-level unwind and high-level base code share a
2403 common unwinder, let them share the prologue cache. */
2404 if (fi->base->unwind == fi->unwind)
2405 return fi->base->this_base (fi, &fi->prologue_cache);
2406 return fi->base->this_base (fi, &fi->base_cache);
2410 get_frame_locals_address (struct frame_info *fi)
2412 if (get_frame_type (fi) != NORMAL_FRAME)
2414 /* If there isn't a frame address method, find it. */
2415 if (fi->base == NULL)
2416 fi->base = frame_base_find_by_frame (fi);
2417 /* Sneaky: If the low-level unwind and high-level base code share a
2418 common unwinder, let them share the prologue cache. */
2419 if (fi->base->unwind == fi->unwind)
2420 return fi->base->this_locals (fi, &fi->prologue_cache);
2421 return fi->base->this_locals (fi, &fi->base_cache);
2425 get_frame_args_address (struct frame_info *fi)
2427 if (get_frame_type (fi) != NORMAL_FRAME)
2429 /* If there isn't a frame address method, find it. */
2430 if (fi->base == NULL)
2431 fi->base = frame_base_find_by_frame (fi);
2432 /* Sneaky: If the low-level unwind and high-level base code share a
2433 common unwinder, let them share the prologue cache. */
2434 if (fi->base->unwind == fi->unwind)
2435 return fi->base->this_args (fi, &fi->prologue_cache);
2436 return fi->base->this_args (fi, &fi->base_cache);
2439 /* Return true if the frame unwinder for frame FI is UNWINDER; false
2443 frame_unwinder_is (struct frame_info *fi, const struct frame_unwind *unwinder)
2445 if (fi->unwind == NULL)
2446 frame_unwind_find_by_frame (fi, &fi->prologue_cache);
2447 return fi->unwind == unwinder;
2450 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
2451 or -1 for a NULL frame. */
2454 frame_relative_level (struct frame_info *fi)
2463 get_frame_type (struct frame_info *frame)
2465 if (frame->unwind == NULL)
2466 /* Initialize the frame's unwinder because that's what
2467 provides the frame's type. */
2468 frame_unwind_find_by_frame (frame, &frame->prologue_cache);
2469 return frame->unwind->type;
2472 struct program_space *
2473 get_frame_program_space (struct frame_info *frame)
2475 return frame->pspace;
2478 struct program_space *
2479 frame_unwind_program_space (struct frame_info *this_frame)
2481 gdb_assert (this_frame);
2483 /* This is really a placeholder to keep the API consistent --- we
2484 assume for now that we don't have frame chains crossing
2486 return this_frame->pspace;
2489 struct address_space *
2490 get_frame_address_space (struct frame_info *frame)
2492 return frame->aspace;
2495 /* Memory access methods. */
2498 get_frame_memory (struct frame_info *this_frame, CORE_ADDR addr,
2499 gdb_byte *buf, int len)
2501 read_memory (addr, buf, len);
2505 get_frame_memory_signed (struct frame_info *this_frame, CORE_ADDR addr,
2508 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2509 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2511 return read_memory_integer (addr, len, byte_order);
2515 get_frame_memory_unsigned (struct frame_info *this_frame, CORE_ADDR addr,
2518 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2519 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2521 return read_memory_unsigned_integer (addr, len, byte_order);
2525 safe_frame_unwind_memory (struct frame_info *this_frame,
2526 CORE_ADDR addr, gdb_byte *buf, int len)
2528 /* NOTE: target_read_memory returns zero on success! */
2529 return !target_read_memory (addr, buf, len);
2532 /* Architecture methods. */
2535 get_frame_arch (struct frame_info *this_frame)
2537 return frame_unwind_arch (this_frame->next);
2541 frame_unwind_arch (struct frame_info *next_frame)
2543 if (!next_frame->prev_arch.p)
2545 struct gdbarch *arch;
2547 if (next_frame->unwind == NULL)
2548 frame_unwind_find_by_frame (next_frame, &next_frame->prologue_cache);
2550 if (next_frame->unwind->prev_arch != NULL)
2551 arch = next_frame->unwind->prev_arch (next_frame,
2552 &next_frame->prologue_cache);
2554 arch = get_frame_arch (next_frame);
2556 next_frame->prev_arch.arch = arch;
2557 next_frame->prev_arch.p = 1;
2559 fprintf_unfiltered (gdb_stdlog,
2560 "{ frame_unwind_arch (next_frame=%d) -> %s }\n",
2562 gdbarch_bfd_arch_info (arch)->printable_name);
2565 return next_frame->prev_arch.arch;
2569 frame_unwind_caller_arch (struct frame_info *next_frame)
2571 return frame_unwind_arch (skip_artificial_frames (next_frame));
2574 /* Stack pointer methods. */
2577 get_frame_sp (struct frame_info *this_frame)
2579 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2581 /* Normality - an architecture that provides a way of obtaining any
2582 frame inner-most address. */
2583 if (gdbarch_unwind_sp_p (gdbarch))
2584 /* NOTE drow/2008-06-28: gdbarch_unwind_sp could be converted to
2585 operate on THIS_FRAME now. */
2586 return gdbarch_unwind_sp (gdbarch, this_frame->next);
2587 /* Now things are really are grim. Hope that the value returned by
2588 the gdbarch_sp_regnum register is meaningful. */
2589 if (gdbarch_sp_regnum (gdbarch) >= 0)
2590 return get_frame_register_unsigned (this_frame,
2591 gdbarch_sp_regnum (gdbarch));
2592 internal_error (__FILE__, __LINE__, _("Missing unwind SP method"));
2595 /* Return the reason why we can't unwind past FRAME. */
2597 enum unwind_stop_reason
2598 get_frame_unwind_stop_reason (struct frame_info *frame)
2600 /* Fill-in STOP_REASON. */
2601 get_prev_frame_always (frame);
2602 gdb_assert (frame->prev_p);
2604 return frame->stop_reason;
2607 /* Return a string explaining REASON. */
2610 unwind_stop_reason_to_string (enum unwind_stop_reason reason)
2614 #define SET(name, description) \
2615 case name: return _(description);
2616 #include "unwind_stop_reasons.def"
2620 internal_error (__FILE__, __LINE__,
2621 "Invalid frame stop reason");
2626 frame_stop_reason_string (struct frame_info *fi)
2628 gdb_assert (fi->prev_p);
2629 gdb_assert (fi->prev == NULL);
2631 /* Return the specific string if we have one. */
2632 if (fi->stop_string != NULL)
2633 return fi->stop_string;
2635 /* Return the generic string if we have nothing better. */
2636 return unwind_stop_reason_to_string (fi->stop_reason);
2639 /* Return the enum symbol name of REASON as a string, to use in debug
2643 frame_stop_reason_symbol_string (enum unwind_stop_reason reason)
2647 #define SET(name, description) \
2648 case name: return #name;
2649 #include "unwind_stop_reasons.def"
2653 internal_error (__FILE__, __LINE__,
2654 "Invalid frame stop reason");
2658 /* Clean up after a failed (wrong unwinder) attempt to unwind past
2662 frame_cleanup_after_sniffer (void *arg)
2664 struct frame_info *frame = arg;
2666 /* The sniffer should not allocate a prologue cache if it did not
2667 match this frame. */
2668 gdb_assert (frame->prologue_cache == NULL);
2670 /* No sniffer should extend the frame chain; sniff based on what is
2672 gdb_assert (!frame->prev_p);
2674 /* The sniffer should not check the frame's ID; that's circular. */
2675 gdb_assert (!frame->this_id.p);
2677 /* Clear cached fields dependent on the unwinder.
2679 The previous PC is independent of the unwinder, but the previous
2680 function is not (see get_frame_address_in_block). */
2681 frame->prev_func.p = 0;
2682 frame->prev_func.addr = 0;
2684 /* Discard the unwinder last, so that we can easily find it if an assertion
2685 in this function triggers. */
2686 frame->unwind = NULL;
2689 /* Set FRAME's unwinder temporarily, so that we can call a sniffer.
2690 Return a cleanup which should be called if unwinding fails, and
2691 discarded if it succeeds. */
2694 frame_prepare_for_sniffer (struct frame_info *frame,
2695 const struct frame_unwind *unwind)
2697 gdb_assert (frame->unwind == NULL);
2698 frame->unwind = unwind;
2699 return make_cleanup (frame_cleanup_after_sniffer, frame);
2702 extern initialize_file_ftype _initialize_frame; /* -Wmissing-prototypes */
2704 static struct cmd_list_element *set_backtrace_cmdlist;
2705 static struct cmd_list_element *show_backtrace_cmdlist;
2708 set_backtrace_cmd (char *args, int from_tty)
2710 help_list (set_backtrace_cmdlist, "set backtrace ", all_commands,
2715 show_backtrace_cmd (char *args, int from_tty)
2717 cmd_show_list (show_backtrace_cmdlist, from_tty, "");
2721 _initialize_frame (void)
2723 obstack_init (&frame_cache_obstack);
2725 frame_stash_create ();
2727 observer_attach_target_changed (frame_observer_target_changed);
2729 add_prefix_cmd ("backtrace", class_maintenance, set_backtrace_cmd, _("\
2730 Set backtrace specific variables.\n\
2731 Configure backtrace variables such as the backtrace limit"),
2732 &set_backtrace_cmdlist, "set backtrace ",
2733 0/*allow-unknown*/, &setlist);
2734 add_prefix_cmd ("backtrace", class_maintenance, show_backtrace_cmd, _("\
2735 Show backtrace specific variables\n\
2736 Show backtrace variables such as the backtrace limit"),
2737 &show_backtrace_cmdlist, "show backtrace ",
2738 0/*allow-unknown*/, &showlist);
2740 add_setshow_boolean_cmd ("past-main", class_obscure,
2741 &backtrace_past_main, _("\
2742 Set whether backtraces should continue past \"main\"."), _("\
2743 Show whether backtraces should continue past \"main\"."), _("\
2744 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
2745 the backtrace at \"main\". Set this variable if you need to see the rest\n\
2746 of the stack trace."),
2748 show_backtrace_past_main,
2749 &set_backtrace_cmdlist,
2750 &show_backtrace_cmdlist);
2752 add_setshow_boolean_cmd ("past-entry", class_obscure,
2753 &backtrace_past_entry, _("\
2754 Set whether backtraces should continue past the entry point of a program."),
2756 Show whether backtraces should continue past the entry point of a program."),
2758 Normally there are no callers beyond the entry point of a program, so GDB\n\
2759 will terminate the backtrace there. Set this variable if you need to see\n\
2760 the rest of the stack trace."),
2762 show_backtrace_past_entry,
2763 &set_backtrace_cmdlist,
2764 &show_backtrace_cmdlist);
2766 add_setshow_uinteger_cmd ("limit", class_obscure,
2767 &backtrace_limit, _("\
2768 Set an upper bound on the number of backtrace levels."), _("\
2769 Show the upper bound on the number of backtrace levels."), _("\
2770 No more than the specified number of frames can be displayed or examined.\n\
2771 Literal \"unlimited\" or zero means no limit."),
2773 show_backtrace_limit,
2774 &set_backtrace_cmdlist,
2775 &show_backtrace_cmdlist);
2777 /* Debug this files internals. */
2778 add_setshow_zuinteger_cmd ("frame", class_maintenance, &frame_debug, _("\
2779 Set frame debugging."), _("\
2780 Show frame debugging."), _("\
2781 When non-zero, frame specific internal debugging is enabled."),
2784 &setdebuglist, &showdebuglist);