1 /* Cache and manage frames for GDB, the GNU debugger.
3 Copyright (C) 1986-1987, 1989, 1991, 1994-1996, 1998, 2000-2004,
4 2007-2012 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
25 #include "inferior.h" /* for inferior_ptid */
27 #include "gdb_assert.h"
28 #include "gdb_string.h"
29 #include "user-regs.h"
30 #include "gdb_obstack.h"
31 #include "dummy-frame.h"
32 #include "sentinel-frame.h"
36 #include "frame-unwind.h"
37 #include "frame-base.h"
42 #include "exceptions.h"
43 #include "gdbthread.h"
45 #include "inline-frame.h"
46 #include "tracepoint.h"
48 static struct frame_info
*get_prev_frame_1 (struct frame_info
*this_frame
);
49 static struct frame_info
*get_prev_frame_raw (struct frame_info
*this_frame
);
51 /* We keep a cache of stack frames, each of which is a "struct
52 frame_info". The innermost one gets allocated (in
53 wait_for_inferior) each time the inferior stops; current_frame
54 points to it. Additional frames get allocated (in get_prev_frame)
55 as needed, and are chained through the next and prev fields. Any
56 time that the frame cache becomes invalid (most notably when we
57 execute something, but also if we change how we interpret the
58 frames (e.g. "set heuristic-fence-post" in mips-tdep.c, or anything
59 which reads new symbols)), we should call reinit_frame_cache. */
63 /* Level of this frame. The inner-most (youngest) frame is at level
64 0. As you move towards the outer-most (oldest) frame, the level
65 increases. This is a cached value. It could just as easily be
66 computed by counting back from the selected frame to the inner
68 /* NOTE: cagney/2002-04-05: Perhaps a level of ``-1'' should be
69 reserved to indicate a bogus frame - one that has been created
70 just to keep GDB happy (GDB always needs a frame). For the
71 moment leave this as speculation. */
74 /* The frame's program space. */
75 struct program_space
*pspace
;
77 /* The frame's address space. */
78 struct address_space
*aspace
;
80 /* The frame's low-level unwinder and corresponding cache. The
81 low-level unwinder is responsible for unwinding register values
82 for the previous frame. The low-level unwind methods are
83 selected based on the presence, or otherwise, of register unwind
84 information such as CFI. */
86 const struct frame_unwind
*unwind
;
88 /* Cached copy of the previous frame's architecture. */
95 /* Cached copy of the previous frame's resume address. */
101 /* Cached copy of the previous frame's function address. */
108 /* This frame's ID. */
112 struct frame_id value
;
115 /* The frame's high-level base methods, and corresponding cache.
116 The high level base methods are selected based on the frame's
118 const struct frame_base
*base
;
121 /* Pointers to the next (down, inner, younger) and previous (up,
122 outer, older) frame_info's in the frame cache. */
123 struct frame_info
*next
; /* down, inner, younger */
125 struct frame_info
*prev
; /* up, outer, older */
127 /* The reason why we could not set PREV, or UNWIND_NO_REASON if we
128 could. Only valid when PREV_P is set. */
129 enum unwind_stop_reason stop_reason
;
132 /* A frame stash used to speed up frame lookups. */
134 /* We currently only stash one frame at a time, as this seems to be
135 sufficient for now. */
136 static struct frame_info
*frame_stash
= NULL
;
138 /* Add the following FRAME to the frame stash. */
141 frame_stash_add (struct frame_info
*frame
)
146 /* Search the frame stash for an entry with the given frame ID.
147 If found, return that frame. Otherwise return NULL. */
149 static struct frame_info
*
150 frame_stash_find (struct frame_id id
)
152 if (frame_stash
&& frame_id_eq (frame_stash
->this_id
.value
, id
))
158 /* Invalidate the frame stash by removing all entries in it. */
161 frame_stash_invalidate (void)
166 /* Flag to control debugging. */
168 unsigned int frame_debug
;
170 show_frame_debug (struct ui_file
*file
, int from_tty
,
171 struct cmd_list_element
*c
, const char *value
)
173 fprintf_filtered (file
, _("Frame debugging is %s.\n"), value
);
176 /* Flag to indicate whether backtraces should stop at main et.al. */
178 static int backtrace_past_main
;
180 show_backtrace_past_main (struct ui_file
*file
, int from_tty
,
181 struct cmd_list_element
*c
, const char *value
)
183 fprintf_filtered (file
,
184 _("Whether backtraces should "
185 "continue past \"main\" is %s.\n"),
189 static int backtrace_past_entry
;
191 show_backtrace_past_entry (struct ui_file
*file
, int from_tty
,
192 struct cmd_list_element
*c
, const char *value
)
194 fprintf_filtered (file
, _("Whether backtraces should continue past the "
195 "entry point of a program is %s.\n"),
199 static unsigned int backtrace_limit
= UINT_MAX
;
201 show_backtrace_limit (struct ui_file
*file
, int from_tty
,
202 struct cmd_list_element
*c
, const char *value
)
204 fprintf_filtered (file
,
205 _("An upper bound on the number "
206 "of backtrace levels is %s.\n"),
212 fprint_field (struct ui_file
*file
, const char *name
, int p
, CORE_ADDR addr
)
215 fprintf_unfiltered (file
, "%s=%s", name
, hex_string (addr
));
217 fprintf_unfiltered (file
, "!%s", name
);
221 fprint_frame_id (struct ui_file
*file
, struct frame_id id
)
223 fprintf_unfiltered (file
, "{");
224 fprint_field (file
, "stack", id
.stack_addr_p
, id
.stack_addr
);
225 fprintf_unfiltered (file
, ",");
226 fprint_field (file
, "code", id
.code_addr_p
, id
.code_addr
);
227 fprintf_unfiltered (file
, ",");
228 fprint_field (file
, "special", id
.special_addr_p
, id
.special_addr
);
229 if (id
.artificial_depth
)
230 fprintf_unfiltered (file
, ",artificial=%d", id
.artificial_depth
);
231 fprintf_unfiltered (file
, "}");
235 fprint_frame_type (struct ui_file
*file
, enum frame_type type
)
240 fprintf_unfiltered (file
, "NORMAL_FRAME");
243 fprintf_unfiltered (file
, "DUMMY_FRAME");
246 fprintf_unfiltered (file
, "INLINE_FRAME");
249 fprintf_unfiltered (file
, "SENTINEL_FRAME");
252 fprintf_unfiltered (file
, "SIGTRAMP_FRAME");
255 fprintf_unfiltered (file
, "ARCH_FRAME");
258 fprintf_unfiltered (file
, "<unknown type>");
264 fprint_frame (struct ui_file
*file
, struct frame_info
*fi
)
268 fprintf_unfiltered (file
, "<NULL frame>");
271 fprintf_unfiltered (file
, "{");
272 fprintf_unfiltered (file
, "level=%d", fi
->level
);
273 fprintf_unfiltered (file
, ",");
274 fprintf_unfiltered (file
, "type=");
275 if (fi
->unwind
!= NULL
)
276 fprint_frame_type (file
, fi
->unwind
->type
);
278 fprintf_unfiltered (file
, "<unknown>");
279 fprintf_unfiltered (file
, ",");
280 fprintf_unfiltered (file
, "unwind=");
281 if (fi
->unwind
!= NULL
)
282 gdb_print_host_address (fi
->unwind
, file
);
284 fprintf_unfiltered (file
, "<unknown>");
285 fprintf_unfiltered (file
, ",");
286 fprintf_unfiltered (file
, "pc=");
287 if (fi
->next
!= NULL
&& fi
->next
->prev_pc
.p
)
288 fprintf_unfiltered (file
, "%s", hex_string (fi
->next
->prev_pc
.value
));
290 fprintf_unfiltered (file
, "<unknown>");
291 fprintf_unfiltered (file
, ",");
292 fprintf_unfiltered (file
, "id=");
294 fprint_frame_id (file
, fi
->this_id
.value
);
296 fprintf_unfiltered (file
, "<unknown>");
297 fprintf_unfiltered (file
, ",");
298 fprintf_unfiltered (file
, "func=");
299 if (fi
->next
!= NULL
&& fi
->next
->prev_func
.p
)
300 fprintf_unfiltered (file
, "%s", hex_string (fi
->next
->prev_func
.addr
));
302 fprintf_unfiltered (file
, "<unknown>");
303 fprintf_unfiltered (file
, "}");
306 /* Given FRAME, return the enclosing frame as found in real frames read-in from
307 inferior memory. Skip any previous frames which were made up by GDB.
308 Return the original frame if no immediate previous frames exist. */
310 static struct frame_info
*
311 skip_artificial_frames (struct frame_info
*frame
)
313 while (get_frame_type (frame
) == INLINE_FRAME
)
314 frame
= get_prev_frame (frame
);
319 /* Return a frame uniq ID that can be used to, later, re-find the
323 get_frame_id (struct frame_info
*fi
)
326 return null_frame_id
;
331 fprintf_unfiltered (gdb_stdlog
, "{ get_frame_id (fi=%d) ",
333 /* Find the unwinder. */
334 if (fi
->unwind
== NULL
)
335 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
336 /* Find THIS frame's ID. */
337 /* Default to outermost if no ID is found. */
338 fi
->this_id
.value
= outer_frame_id
;
339 fi
->unwind
->this_id (fi
, &fi
->prologue_cache
, &fi
->this_id
.value
);
340 gdb_assert (frame_id_p (fi
->this_id
.value
));
344 fprintf_unfiltered (gdb_stdlog
, "-> ");
345 fprint_frame_id (gdb_stdlog
, fi
->this_id
.value
);
346 fprintf_unfiltered (gdb_stdlog
, " }\n");
350 frame_stash_add (fi
);
352 return fi
->this_id
.value
;
356 get_stack_frame_id (struct frame_info
*next_frame
)
358 return get_frame_id (skip_artificial_frames (next_frame
));
362 frame_unwind_caller_id (struct frame_info
*next_frame
)
364 struct frame_info
*this_frame
;
366 /* Use get_prev_frame_1, and not get_prev_frame. The latter will truncate
367 the frame chain, leading to this function unintentionally
368 returning a null_frame_id (e.g., when a caller requests the frame
369 ID of "main()"s caller. */
371 next_frame
= skip_artificial_frames (next_frame
);
372 this_frame
= get_prev_frame_1 (next_frame
);
374 return get_frame_id (skip_artificial_frames (this_frame
));
376 return null_frame_id
;
379 const struct frame_id null_frame_id
; /* All zeros. */
380 const struct frame_id outer_frame_id
= { 0, 0, 0, 0, 0, 1, 0 };
383 frame_id_build_special (CORE_ADDR stack_addr
, CORE_ADDR code_addr
,
384 CORE_ADDR special_addr
)
386 struct frame_id id
= null_frame_id
;
388 id
.stack_addr
= stack_addr
;
390 id
.code_addr
= code_addr
;
392 id
.special_addr
= special_addr
;
393 id
.special_addr_p
= 1;
398 frame_id_build (CORE_ADDR stack_addr
, CORE_ADDR code_addr
)
400 struct frame_id id
= null_frame_id
;
402 id
.stack_addr
= stack_addr
;
404 id
.code_addr
= code_addr
;
410 frame_id_build_wild (CORE_ADDR stack_addr
)
412 struct frame_id id
= null_frame_id
;
414 id
.stack_addr
= stack_addr
;
420 frame_id_p (struct frame_id l
)
424 /* The frame is valid iff it has a valid stack address. */
426 /* outer_frame_id is also valid. */
427 if (!p
&& memcmp (&l
, &outer_frame_id
, sizeof (l
)) == 0)
431 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_p (l=");
432 fprint_frame_id (gdb_stdlog
, l
);
433 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", p
);
439 frame_id_artificial_p (struct frame_id l
)
444 return (l
.artificial_depth
!= 0);
448 frame_id_eq (struct frame_id l
, struct frame_id r
)
452 if (!l
.stack_addr_p
&& l
.special_addr_p
453 && !r
.stack_addr_p
&& r
.special_addr_p
)
454 /* The outermost frame marker is equal to itself. This is the
455 dodgy thing about outer_frame_id, since between execution steps
456 we might step into another function - from which we can't
457 unwind either. More thought required to get rid of
460 else if (!l
.stack_addr_p
|| !r
.stack_addr_p
)
461 /* Like a NaN, if either ID is invalid, the result is false.
462 Note that a frame ID is invalid iff it is the null frame ID. */
464 else if (l
.stack_addr
!= r
.stack_addr
)
465 /* If .stack addresses are different, the frames are different. */
467 else if (l
.code_addr_p
&& r
.code_addr_p
&& l
.code_addr
!= r
.code_addr
)
468 /* An invalid code addr is a wild card. If .code addresses are
469 different, the frames are different. */
471 else if (l
.special_addr_p
&& r
.special_addr_p
472 && l
.special_addr
!= r
.special_addr
)
473 /* An invalid special addr is a wild card (or unused). Otherwise
474 if special addresses are different, the frames are different. */
476 else if (l
.artificial_depth
!= r
.artificial_depth
)
477 /* If artifical depths are different, the frames must be different. */
480 /* Frames are equal. */
485 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_eq (l=");
486 fprint_frame_id (gdb_stdlog
, l
);
487 fprintf_unfiltered (gdb_stdlog
, ",r=");
488 fprint_frame_id (gdb_stdlog
, r
);
489 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", eq
);
494 /* Safety net to check whether frame ID L should be inner to
495 frame ID R, according to their stack addresses.
497 This method cannot be used to compare arbitrary frames, as the
498 ranges of valid stack addresses may be discontiguous (e.g. due
501 However, it can be used as safety net to discover invalid frame
502 IDs in certain circumstances. Assuming that NEXT is the immediate
503 inner frame to THIS and that NEXT and THIS are both NORMAL frames:
505 * The stack address of NEXT must be inner-than-or-equal to the stack
508 Therefore, if frame_id_inner (THIS, NEXT) holds, some unwind
511 * If NEXT and THIS have different stack addresses, no other frame
512 in the frame chain may have a stack address in between.
514 Therefore, if frame_id_inner (TEST, THIS) holds, but
515 frame_id_inner (TEST, NEXT) does not hold, TEST cannot refer
516 to a valid frame in the frame chain.
518 The sanity checks above cannot be performed when a SIGTRAMP frame
519 is involved, because signal handlers might be executed on a different
520 stack than the stack used by the routine that caused the signal
521 to be raised. This can happen for instance when a thread exceeds
522 its maximum stack size. In this case, certain compilers implement
523 a stack overflow strategy that cause the handler to be run on a
527 frame_id_inner (struct gdbarch
*gdbarch
, struct frame_id l
, struct frame_id r
)
531 if (!l
.stack_addr_p
|| !r
.stack_addr_p
)
532 /* Like NaN, any operation involving an invalid ID always fails. */
534 else if (l
.artificial_depth
> r
.artificial_depth
535 && l
.stack_addr
== r
.stack_addr
536 && l
.code_addr_p
== r
.code_addr_p
537 && l
.special_addr_p
== r
.special_addr_p
538 && l
.special_addr
== r
.special_addr
)
540 /* Same function, different inlined functions. */
541 struct block
*lb
, *rb
;
543 gdb_assert (l
.code_addr_p
&& r
.code_addr_p
);
545 lb
= block_for_pc (l
.code_addr
);
546 rb
= block_for_pc (r
.code_addr
);
548 if (lb
== NULL
|| rb
== NULL
)
549 /* Something's gone wrong. */
552 /* This will return true if LB and RB are the same block, or
553 if the block with the smaller depth lexically encloses the
554 block with the greater depth. */
555 inner
= contained_in (lb
, rb
);
558 /* Only return non-zero when strictly inner than. Note that, per
559 comment in "frame.h", there is some fuzz here. Frameless
560 functions are not strictly inner than (same .stack but
561 different .code and/or .special address). */
562 inner
= gdbarch_inner_than (gdbarch
, l
.stack_addr
, r
.stack_addr
);
565 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_inner (l=");
566 fprint_frame_id (gdb_stdlog
, l
);
567 fprintf_unfiltered (gdb_stdlog
, ",r=");
568 fprint_frame_id (gdb_stdlog
, r
);
569 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", inner
);
575 frame_find_by_id (struct frame_id id
)
577 struct frame_info
*frame
, *prev_frame
;
579 /* ZERO denotes the null frame, let the caller decide what to do
580 about it. Should it instead return get_current_frame()? */
581 if (!frame_id_p (id
))
584 /* Try using the frame stash first. Finding it there removes the need
585 to perform the search by looping over all frames, which can be very
586 CPU-intensive if the number of frames is very high (the loop is O(n)
587 and get_prev_frame performs a series of checks that are relatively
588 expensive). This optimization is particularly useful when this function
589 is called from another function (such as value_fetch_lazy, case
590 VALUE_LVAL (val) == lval_register) which already loops over all frames,
591 making the overall behavior O(n^2). */
592 frame
= frame_stash_find (id
);
596 for (frame
= get_current_frame (); ; frame
= prev_frame
)
598 struct frame_id
this = get_frame_id (frame
);
600 if (frame_id_eq (id
, this))
601 /* An exact match. */
604 prev_frame
= get_prev_frame (frame
);
608 /* As a safety net to avoid unnecessary backtracing while trying
609 to find an invalid ID, we check for a common situation where
610 we can detect from comparing stack addresses that no other
611 frame in the current frame chain can have this ID. See the
612 comment at frame_id_inner for details. */
613 if (get_frame_type (frame
) == NORMAL_FRAME
614 && !frame_id_inner (get_frame_arch (frame
), id
, this)
615 && frame_id_inner (get_frame_arch (prev_frame
), id
,
616 get_frame_id (prev_frame
)))
623 frame_unwind_pc_if_available (struct frame_info
*this_frame
, CORE_ADDR
*pc
)
625 if (!this_frame
->prev_pc
.p
)
627 if (gdbarch_unwind_pc_p (frame_unwind_arch (this_frame
)))
629 volatile struct gdb_exception ex
;
630 struct gdbarch
*prev_gdbarch
;
633 /* The right way. The `pure' way. The one true way. This
634 method depends solely on the register-unwind code to
635 determine the value of registers in THIS frame, and hence
636 the value of this frame's PC (resume address). A typical
637 implementation is no more than:
639 frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
640 return extract_unsigned_integer (buf, size of ISA_PC_REGNUM);
642 Note: this method is very heavily dependent on a correct
643 register-unwind implementation, it pays to fix that
644 method first; this method is frame type agnostic, since
645 it only deals with register values, it works with any
646 frame. This is all in stark contrast to the old
647 FRAME_SAVED_PC which would try to directly handle all the
648 different ways that a PC could be unwound. */
649 prev_gdbarch
= frame_unwind_arch (this_frame
);
651 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
653 pc
= gdbarch_unwind_pc (prev_gdbarch
, this_frame
);
655 if (ex
.reason
< 0 && ex
.error
== NOT_AVAILABLE_ERROR
)
657 this_frame
->prev_pc
.p
= -1;
660 fprintf_unfiltered (gdb_stdlog
,
661 "{ frame_unwind_pc (this_frame=%d)"
662 " -> <unavailable> }\n",
665 else if (ex
.reason
< 0)
667 throw_exception (ex
);
671 this_frame
->prev_pc
.value
= pc
;
672 this_frame
->prev_pc
.p
= 1;
674 fprintf_unfiltered (gdb_stdlog
,
675 "{ frame_unwind_pc (this_frame=%d) "
678 hex_string (this_frame
->prev_pc
.value
));
682 internal_error (__FILE__
, __LINE__
, _("No unwind_pc method"));
684 if (this_frame
->prev_pc
.p
< 0)
691 *pc
= this_frame
->prev_pc
.value
;
697 frame_unwind_pc (struct frame_info
*this_frame
)
701 if (!frame_unwind_pc_if_available (this_frame
, &pc
))
702 throw_error (NOT_AVAILABLE_ERROR
, _("PC not available"));
708 frame_unwind_caller_pc (struct frame_info
*this_frame
)
710 return frame_unwind_pc (skip_artificial_frames (this_frame
));
714 frame_unwind_caller_pc_if_available (struct frame_info
*this_frame
,
717 return frame_unwind_pc_if_available (skip_artificial_frames (this_frame
), pc
);
721 get_frame_func_if_available (struct frame_info
*this_frame
, CORE_ADDR
*pc
)
723 struct frame_info
*next_frame
= this_frame
->next
;
725 if (!next_frame
->prev_func
.p
)
727 CORE_ADDR addr_in_block
;
729 /* Make certain that this, and not the adjacent, function is
731 if (!get_frame_address_in_block_if_available (this_frame
, &addr_in_block
))
733 next_frame
->prev_func
.p
= -1;
735 fprintf_unfiltered (gdb_stdlog
,
736 "{ get_frame_func (this_frame=%d)"
737 " -> unavailable }\n",
742 next_frame
->prev_func
.p
= 1;
743 next_frame
->prev_func
.addr
= get_pc_function_start (addr_in_block
);
745 fprintf_unfiltered (gdb_stdlog
,
746 "{ get_frame_func (this_frame=%d) -> %s }\n",
748 hex_string (next_frame
->prev_func
.addr
));
752 if (next_frame
->prev_func
.p
< 0)
759 *pc
= next_frame
->prev_func
.addr
;
765 get_frame_func (struct frame_info
*this_frame
)
769 if (!get_frame_func_if_available (this_frame
, &pc
))
770 throw_error (NOT_AVAILABLE_ERROR
, _("PC not available"));
775 static enum register_status
776 do_frame_register_read (void *src
, int regnum
, gdb_byte
*buf
)
778 if (!frame_register_read (src
, regnum
, buf
))
779 return REG_UNAVAILABLE
;
785 frame_save_as_regcache (struct frame_info
*this_frame
)
787 struct address_space
*aspace
= get_frame_address_space (this_frame
);
788 struct regcache
*regcache
= regcache_xmalloc (get_frame_arch (this_frame
),
790 struct cleanup
*cleanups
= make_cleanup_regcache_xfree (regcache
);
792 regcache_save (regcache
, do_frame_register_read
, this_frame
);
793 discard_cleanups (cleanups
);
798 frame_pop (struct frame_info
*this_frame
)
800 struct frame_info
*prev_frame
;
801 struct regcache
*scratch
;
802 struct cleanup
*cleanups
;
804 if (get_frame_type (this_frame
) == DUMMY_FRAME
)
806 /* Popping a dummy frame involves restoring more than just registers.
807 dummy_frame_pop does all the work. */
808 dummy_frame_pop (get_frame_id (this_frame
));
812 /* Ensure that we have a frame to pop to. */
813 prev_frame
= get_prev_frame_1 (this_frame
);
816 error (_("Cannot pop the initial frame."));
818 /* Make a copy of all the register values unwound from this frame.
819 Save them in a scratch buffer so that there isn't a race between
820 trying to extract the old values from the current regcache while
821 at the same time writing new values into that same cache. */
822 scratch
= frame_save_as_regcache (prev_frame
);
823 cleanups
= make_cleanup_regcache_xfree (scratch
);
825 /* FIXME: cagney/2003-03-16: It should be possible to tell the
826 target's register cache that it is about to be hit with a burst
827 register transfer and that the sequence of register writes should
828 be batched. The pair target_prepare_to_store() and
829 target_store_registers() kind of suggest this functionality.
830 Unfortunately, they don't implement it. Their lack of a formal
831 definition can lead to targets writing back bogus values
832 (arguably a bug in the target code mind). */
833 /* Now copy those saved registers into the current regcache.
834 Here, regcache_cpy() calls regcache_restore(). */
835 regcache_cpy (get_current_regcache (), scratch
);
836 do_cleanups (cleanups
);
838 /* We've made right mess of GDB's local state, just discard
840 reinit_frame_cache ();
844 frame_register_unwind (struct frame_info
*frame
, int regnum
,
845 int *optimizedp
, int *unavailablep
,
846 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
847 int *realnump
, gdb_byte
*bufferp
)
851 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
852 that the value proper does not need to be fetched. */
853 gdb_assert (optimizedp
!= NULL
);
854 gdb_assert (lvalp
!= NULL
);
855 gdb_assert (addrp
!= NULL
);
856 gdb_assert (realnump
!= NULL
);
857 /* gdb_assert (bufferp != NULL); */
859 value
= frame_unwind_register_value (frame
, regnum
);
861 gdb_assert (value
!= NULL
);
863 *optimizedp
= value_optimized_out (value
);
864 *unavailablep
= !value_entirely_available (value
);
865 *lvalp
= VALUE_LVAL (value
);
866 *addrp
= value_address (value
);
867 *realnump
= VALUE_REGNUM (value
);
871 if (!*optimizedp
&& !*unavailablep
)
872 memcpy (bufferp
, value_contents_all (value
),
873 TYPE_LENGTH (value_type (value
)));
875 memset (bufferp
, 0, TYPE_LENGTH (value_type (value
)));
878 /* Dispose of the new value. This prevents watchpoints from
879 trying to watch the saved frame pointer. */
880 release_value (value
);
885 frame_register (struct frame_info
*frame
, int regnum
,
886 int *optimizedp
, int *unavailablep
, enum lval_type
*lvalp
,
887 CORE_ADDR
*addrp
, int *realnump
, gdb_byte
*bufferp
)
889 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
890 that the value proper does not need to be fetched. */
891 gdb_assert (optimizedp
!= NULL
);
892 gdb_assert (lvalp
!= NULL
);
893 gdb_assert (addrp
!= NULL
);
894 gdb_assert (realnump
!= NULL
);
895 /* gdb_assert (bufferp != NULL); */
897 /* Obtain the register value by unwinding the register from the next
898 (more inner frame). */
899 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
900 frame_register_unwind (frame
->next
, regnum
, optimizedp
, unavailablep
,
901 lvalp
, addrp
, realnump
, bufferp
);
905 frame_unwind_register (struct frame_info
*frame
, int regnum
, gdb_byte
*buf
)
913 frame_register_unwind (frame
, regnum
, &optimized
, &unavailable
,
914 &lval
, &addr
, &realnum
, buf
);
917 error (_("Register %d was optimized out"), regnum
);
919 throw_error (NOT_AVAILABLE_ERROR
,
920 _("Register %d is not available"), regnum
);
924 get_frame_register (struct frame_info
*frame
,
925 int regnum
, gdb_byte
*buf
)
927 frame_unwind_register (frame
->next
, regnum
, buf
);
931 frame_unwind_register_value (struct frame_info
*frame
, int regnum
)
933 struct gdbarch
*gdbarch
;
936 gdb_assert (frame
!= NULL
);
937 gdbarch
= frame_unwind_arch (frame
);
941 fprintf_unfiltered (gdb_stdlog
,
942 "{ frame_unwind_register_value "
943 "(frame=%d,regnum=%d(%s),...) ",
944 frame
->level
, regnum
,
945 user_reg_map_regnum_to_name (gdbarch
, regnum
));
948 /* Find the unwinder. */
949 if (frame
->unwind
== NULL
)
950 frame_unwind_find_by_frame (frame
, &frame
->prologue_cache
);
952 /* Ask this frame to unwind its register. */
953 value
= frame
->unwind
->prev_register (frame
, &frame
->prologue_cache
, regnum
);
957 fprintf_unfiltered (gdb_stdlog
, "->");
958 if (value_optimized_out (value
))
959 fprintf_unfiltered (gdb_stdlog
, " optimized out");
962 if (VALUE_LVAL (value
) == lval_register
)
963 fprintf_unfiltered (gdb_stdlog
, " register=%d",
964 VALUE_REGNUM (value
));
965 else if (VALUE_LVAL (value
) == lval_memory
)
966 fprintf_unfiltered (gdb_stdlog
, " address=%s",
968 value_address (value
)));
970 fprintf_unfiltered (gdb_stdlog
, " computed");
972 if (value_lazy (value
))
973 fprintf_unfiltered (gdb_stdlog
, " lazy");
977 const gdb_byte
*buf
= value_contents (value
);
979 fprintf_unfiltered (gdb_stdlog
, " bytes=");
980 fprintf_unfiltered (gdb_stdlog
, "[");
981 for (i
= 0; i
< register_size (gdbarch
, regnum
); i
++)
982 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
983 fprintf_unfiltered (gdb_stdlog
, "]");
987 fprintf_unfiltered (gdb_stdlog
, " }\n");
994 get_frame_register_value (struct frame_info
*frame
, int regnum
)
996 return frame_unwind_register_value (frame
->next
, regnum
);
1000 frame_unwind_register_signed (struct frame_info
*frame
, int regnum
)
1002 struct gdbarch
*gdbarch
= frame_unwind_arch (frame
);
1003 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1004 int size
= register_size (gdbarch
, regnum
);
1005 gdb_byte buf
[MAX_REGISTER_SIZE
];
1007 frame_unwind_register (frame
, regnum
, buf
);
1008 return extract_signed_integer (buf
, size
, byte_order
);
1012 get_frame_register_signed (struct frame_info
*frame
, int regnum
)
1014 return frame_unwind_register_signed (frame
->next
, regnum
);
1018 frame_unwind_register_unsigned (struct frame_info
*frame
, int regnum
)
1020 struct gdbarch
*gdbarch
= frame_unwind_arch (frame
);
1021 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1022 int size
= register_size (gdbarch
, regnum
);
1023 gdb_byte buf
[MAX_REGISTER_SIZE
];
1025 frame_unwind_register (frame
, regnum
, buf
);
1026 return extract_unsigned_integer (buf
, size
, byte_order
);
1030 get_frame_register_unsigned (struct frame_info
*frame
, int regnum
)
1032 return frame_unwind_register_unsigned (frame
->next
, regnum
);
1036 read_frame_register_unsigned (struct frame_info
*frame
, int regnum
,
1039 struct value
*regval
= get_frame_register_value (frame
, regnum
);
1041 if (!value_optimized_out (regval
)
1042 && value_entirely_available (regval
))
1044 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1045 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1046 int size
= register_size (gdbarch
, VALUE_REGNUM (regval
));
1048 *val
= extract_unsigned_integer (value_contents (regval
), size
, byte_order
);
1056 put_frame_register (struct frame_info
*frame
, int regnum
,
1057 const gdb_byte
*buf
)
1059 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1063 enum lval_type lval
;
1066 frame_register (frame
, regnum
, &optim
, &unavail
,
1067 &lval
, &addr
, &realnum
, NULL
);
1069 error (_("Attempt to assign to a value that was optimized out."));
1074 /* FIXME: write_memory doesn't yet take constant buffers.
1076 gdb_byte tmp
[MAX_REGISTER_SIZE
];
1078 memcpy (tmp
, buf
, register_size (gdbarch
, regnum
));
1079 write_memory (addr
, tmp
, register_size (gdbarch
, regnum
));
1083 regcache_cooked_write (get_current_regcache (), realnum
, buf
);
1086 error (_("Attempt to assign to an unmodifiable value."));
1090 /* frame_register_read ()
1092 Find and return the value of REGNUM for the specified stack frame.
1093 The number of bytes copied is REGISTER_SIZE (REGNUM).
1095 Returns 0 if the register value could not be found. */
1098 frame_register_read (struct frame_info
*frame
, int regnum
,
1103 enum lval_type lval
;
1107 frame_register (frame
, regnum
, &optimized
, &unavailable
,
1108 &lval
, &addr
, &realnum
, myaddr
);
1110 return !optimized
&& !unavailable
;
1114 get_frame_register_bytes (struct frame_info
*frame
, int regnum
,
1115 CORE_ADDR offset
, int len
, gdb_byte
*myaddr
,
1116 int *optimizedp
, int *unavailablep
)
1118 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1123 /* Skip registers wholly inside of OFFSET. */
1124 while (offset
>= register_size (gdbarch
, regnum
))
1126 offset
-= register_size (gdbarch
, regnum
);
1130 /* Ensure that we will not read beyond the end of the register file.
1131 This can only ever happen if the debug information is bad. */
1133 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1134 for (i
= regnum
; i
< numregs
; i
++)
1136 int thissize
= register_size (gdbarch
, i
);
1139 break; /* This register is not available on this architecture. */
1140 maxsize
+= thissize
;
1143 error (_("Bad debug information detected: "
1144 "Attempt to read %d bytes from registers."), len
);
1146 /* Copy the data. */
1149 int curr_len
= register_size (gdbarch
, regnum
) - offset
;
1154 if (curr_len
== register_size (gdbarch
, regnum
))
1156 enum lval_type lval
;
1160 frame_register (frame
, regnum
, optimizedp
, unavailablep
,
1161 &lval
, &addr
, &realnum
, myaddr
);
1162 if (*optimizedp
|| *unavailablep
)
1167 gdb_byte buf
[MAX_REGISTER_SIZE
];
1168 enum lval_type lval
;
1172 frame_register (frame
, regnum
, optimizedp
, unavailablep
,
1173 &lval
, &addr
, &realnum
, buf
);
1174 if (*optimizedp
|| *unavailablep
)
1176 memcpy (myaddr
, buf
+ offset
, curr_len
);
1191 put_frame_register_bytes (struct frame_info
*frame
, int regnum
,
1192 CORE_ADDR offset
, int len
, const gdb_byte
*myaddr
)
1194 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1196 /* Skip registers wholly inside of OFFSET. */
1197 while (offset
>= register_size (gdbarch
, regnum
))
1199 offset
-= register_size (gdbarch
, regnum
);
1203 /* Copy the data. */
1206 int curr_len
= register_size (gdbarch
, regnum
) - offset
;
1211 if (curr_len
== register_size (gdbarch
, regnum
))
1213 put_frame_register (frame
, regnum
, myaddr
);
1217 gdb_byte buf
[MAX_REGISTER_SIZE
];
1219 frame_register_read (frame
, regnum
, buf
);
1220 memcpy (buf
+ offset
, myaddr
, curr_len
);
1221 put_frame_register (frame
, regnum
, buf
);
1231 /* Create a sentinel frame. */
1233 static struct frame_info
*
1234 create_sentinel_frame (struct program_space
*pspace
, struct regcache
*regcache
)
1236 struct frame_info
*frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1239 frame
->pspace
= pspace
;
1240 frame
->aspace
= get_regcache_aspace (regcache
);
1241 /* Explicitly initialize the sentinel frame's cache. Provide it
1242 with the underlying regcache. In the future additional
1243 information, such as the frame's thread will be added. */
1244 frame
->prologue_cache
= sentinel_frame_cache (regcache
);
1245 /* For the moment there is only one sentinel frame implementation. */
1246 frame
->unwind
= &sentinel_frame_unwind
;
1247 /* Link this frame back to itself. The frame is self referential
1248 (the unwound PC is the same as the pc), so make it so. */
1249 frame
->next
= frame
;
1250 /* Make the sentinel frame's ID valid, but invalid. That way all
1251 comparisons with it should fail. */
1252 frame
->this_id
.p
= 1;
1253 frame
->this_id
.value
= null_frame_id
;
1256 fprintf_unfiltered (gdb_stdlog
, "{ create_sentinel_frame (...) -> ");
1257 fprint_frame (gdb_stdlog
, frame
);
1258 fprintf_unfiltered (gdb_stdlog
, " }\n");
1263 /* Info about the innermost stack frame (contents of FP register). */
1265 static struct frame_info
*current_frame
;
1267 /* Cache for frame addresses already read by gdb. Valid only while
1268 inferior is stopped. Control variables for the frame cache should
1269 be local to this module. */
1271 static struct obstack frame_cache_obstack
;
1274 frame_obstack_zalloc (unsigned long size
)
1276 void *data
= obstack_alloc (&frame_cache_obstack
, size
);
1278 memset (data
, 0, size
);
1282 /* Return the innermost (currently executing) stack frame. This is
1283 split into two functions. The function unwind_to_current_frame()
1284 is wrapped in catch exceptions so that, even when the unwind of the
1285 sentinel frame fails, the function still returns a stack frame. */
1288 unwind_to_current_frame (struct ui_out
*ui_out
, void *args
)
1290 struct frame_info
*frame
= get_prev_frame (args
);
1292 /* A sentinel frame can fail to unwind, e.g., because its PC value
1293 lands in somewhere like start. */
1296 current_frame
= frame
;
1301 get_current_frame (void)
1303 /* First check, and report, the lack of registers. Having GDB
1304 report "No stack!" or "No memory" when the target doesn't even
1305 have registers is very confusing. Besides, "printcmd.exp"
1306 explicitly checks that ``print $pc'' with no registers prints "No
1308 if (!target_has_registers
)
1309 error (_("No registers."));
1310 if (!target_has_stack
)
1311 error (_("No stack."));
1312 if (!target_has_memory
)
1313 error (_("No memory."));
1314 /* Traceframes are effectively a substitute for the live inferior. */
1315 if (get_traceframe_number () < 0)
1317 if (ptid_equal (inferior_ptid
, null_ptid
))
1318 error (_("No selected thread."));
1319 if (is_exited (inferior_ptid
))
1320 error (_("Invalid selected thread."));
1321 if (is_executing (inferior_ptid
))
1322 error (_("Target is executing."));
1325 if (current_frame
== NULL
)
1327 struct frame_info
*sentinel_frame
=
1328 create_sentinel_frame (current_program_space
, get_current_regcache ());
1329 if (catch_exceptions (current_uiout
, unwind_to_current_frame
,
1330 sentinel_frame
, RETURN_MASK_ERROR
) != 0)
1332 /* Oops! Fake a current frame? Is this useful? It has a PC
1333 of zero, for instance. */
1334 current_frame
= sentinel_frame
;
1337 return current_frame
;
1340 /* The "selected" stack frame is used by default for local and arg
1341 access. May be zero, for no selected frame. */
1343 static struct frame_info
*selected_frame
;
1346 has_stack_frames (void)
1348 if (!target_has_registers
|| !target_has_stack
|| !target_has_memory
)
1351 /* Traceframes are effectively a substitute for the live inferior. */
1352 if (get_traceframe_number () < 0)
1354 /* No current inferior, no frame. */
1355 if (ptid_equal (inferior_ptid
, null_ptid
))
1358 /* Don't try to read from a dead thread. */
1359 if (is_exited (inferior_ptid
))
1362 /* ... or from a spinning thread. */
1363 if (is_executing (inferior_ptid
))
1370 /* Return the selected frame. Always non-NULL (unless there isn't an
1371 inferior sufficient for creating a frame) in which case an error is
1375 get_selected_frame (const char *message
)
1377 if (selected_frame
== NULL
)
1379 if (message
!= NULL
&& !has_stack_frames ())
1380 error (("%s"), message
);
1381 /* Hey! Don't trust this. It should really be re-finding the
1382 last selected frame of the currently selected thread. This,
1383 though, is better than nothing. */
1384 select_frame (get_current_frame ());
1386 /* There is always a frame. */
1387 gdb_assert (selected_frame
!= NULL
);
1388 return selected_frame
;
1391 /* If there is a selected frame, return it. Otherwise, return NULL. */
1394 get_selected_frame_if_set (void)
1396 return selected_frame
;
1399 /* This is a variant of get_selected_frame() which can be called when
1400 the inferior does not have a frame; in that case it will return
1401 NULL instead of calling error(). */
1404 deprecated_safe_get_selected_frame (void)
1406 if (!has_stack_frames ())
1408 return get_selected_frame (NULL
);
1411 /* Select frame FI (or NULL - to invalidate the current frame). */
1414 select_frame (struct frame_info
*fi
)
1416 selected_frame
= fi
;
1417 /* NOTE: cagney/2002-05-04: FI can be NULL. This occurs when the
1418 frame is being invalidated. */
1419 if (deprecated_selected_frame_level_changed_hook
)
1420 deprecated_selected_frame_level_changed_hook (frame_relative_level (fi
));
1422 /* FIXME: kseitz/2002-08-28: It would be nice to call
1423 selected_frame_level_changed_event() right here, but due to limitations
1424 in the current interfaces, we would end up flooding UIs with events
1425 because select_frame() is used extensively internally.
1427 Once we have frame-parameterized frame (and frame-related) commands,
1428 the event notification can be moved here, since this function will only
1429 be called when the user's selected frame is being changed. */
1431 /* Ensure that symbols for this frame are read in. Also, determine the
1432 source language of this frame, and switch to it if desired. */
1437 /* We retrieve the frame's symtab by using the frame PC.
1438 However we cannot use the frame PC as-is, because it usually
1439 points to the instruction following the "call", which is
1440 sometimes the first instruction of another function. So we
1441 rely on get_frame_address_in_block() which provides us with a
1442 PC which is guaranteed to be inside the frame's code
1444 if (get_frame_address_in_block_if_available (fi
, &pc
))
1446 struct symtab
*s
= find_pc_symtab (pc
);
1449 && s
->language
!= current_language
->la_language
1450 && s
->language
!= language_unknown
1451 && language_mode
== language_mode_auto
)
1452 set_language (s
->language
);
1457 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
1458 Always returns a non-NULL value. */
1461 create_new_frame (CORE_ADDR addr
, CORE_ADDR pc
)
1463 struct frame_info
*fi
;
1467 fprintf_unfiltered (gdb_stdlog
,
1468 "{ create_new_frame (addr=%s, pc=%s) ",
1469 hex_string (addr
), hex_string (pc
));
1472 fi
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1474 fi
->next
= create_sentinel_frame (current_program_space
,
1475 get_current_regcache ());
1477 /* Set/update this frame's cached PC value, found in the next frame.
1478 Do this before looking for this frame's unwinder. A sniffer is
1479 very likely to read this, and the corresponding unwinder is
1480 entitled to rely that the PC doesn't magically change. */
1481 fi
->next
->prev_pc
.value
= pc
;
1482 fi
->next
->prev_pc
.p
= 1;
1484 /* We currently assume that frame chain's can't cross spaces. */
1485 fi
->pspace
= fi
->next
->pspace
;
1486 fi
->aspace
= fi
->next
->aspace
;
1488 /* Select/initialize both the unwind function and the frame's type
1490 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
1493 fi
->this_id
.value
= frame_id_build (addr
, pc
);
1497 fprintf_unfiltered (gdb_stdlog
, "-> ");
1498 fprint_frame (gdb_stdlog
, fi
);
1499 fprintf_unfiltered (gdb_stdlog
, " }\n");
1505 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
1506 innermost frame). Be careful to not fall off the bottom of the
1507 frame chain and onto the sentinel frame. */
1510 get_next_frame (struct frame_info
*this_frame
)
1512 if (this_frame
->level
> 0)
1513 return this_frame
->next
;
1518 /* Observer for the target_changed event. */
1521 frame_observer_target_changed (struct target_ops
*target
)
1523 reinit_frame_cache ();
1526 /* Flush the entire frame cache. */
1529 reinit_frame_cache (void)
1531 struct frame_info
*fi
;
1533 /* Tear down all frame caches. */
1534 for (fi
= current_frame
; fi
!= NULL
; fi
= fi
->prev
)
1536 if (fi
->prologue_cache
&& fi
->unwind
->dealloc_cache
)
1537 fi
->unwind
->dealloc_cache (fi
, fi
->prologue_cache
);
1538 if (fi
->base_cache
&& fi
->base
->unwind
->dealloc_cache
)
1539 fi
->base
->unwind
->dealloc_cache (fi
, fi
->base_cache
);
1542 /* Since we can't really be sure what the first object allocated was. */
1543 obstack_free (&frame_cache_obstack
, 0);
1544 obstack_init (&frame_cache_obstack
);
1546 if (current_frame
!= NULL
)
1547 annotate_frames_invalid ();
1549 current_frame
= NULL
; /* Invalidate cache */
1550 select_frame (NULL
);
1551 frame_stash_invalidate ();
1553 fprintf_unfiltered (gdb_stdlog
, "{ reinit_frame_cache () }\n");
1556 /* Find where a register is saved (in memory or another register).
1557 The result of frame_register_unwind is just where it is saved
1558 relative to this particular frame. */
1561 frame_register_unwind_location (struct frame_info
*this_frame
, int regnum
,
1562 int *optimizedp
, enum lval_type
*lvalp
,
1563 CORE_ADDR
*addrp
, int *realnump
)
1565 gdb_assert (this_frame
== NULL
|| this_frame
->level
>= 0);
1567 while (this_frame
!= NULL
)
1571 frame_register_unwind (this_frame
, regnum
, optimizedp
, &unavailable
,
1572 lvalp
, addrp
, realnump
, NULL
);
1577 if (*lvalp
!= lval_register
)
1581 this_frame
= get_next_frame (this_frame
);
1585 /* Return a "struct frame_info" corresponding to the frame that called
1586 THIS_FRAME. Returns NULL if there is no such frame.
1588 Unlike get_prev_frame, this function always tries to unwind the
1591 static struct frame_info
*
1592 get_prev_frame_1 (struct frame_info
*this_frame
)
1594 struct frame_id this_id
;
1595 struct gdbarch
*gdbarch
;
1597 gdb_assert (this_frame
!= NULL
);
1598 gdbarch
= get_frame_arch (this_frame
);
1602 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame_1 (this_frame=");
1603 if (this_frame
!= NULL
)
1604 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1606 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1607 fprintf_unfiltered (gdb_stdlog
, ") ");
1610 /* Only try to do the unwind once. */
1611 if (this_frame
->prev_p
)
1615 fprintf_unfiltered (gdb_stdlog
, "-> ");
1616 fprint_frame (gdb_stdlog
, this_frame
->prev
);
1617 fprintf_unfiltered (gdb_stdlog
, " // cached \n");
1619 return this_frame
->prev
;
1622 /* If the frame unwinder hasn't been selected yet, we must do so
1623 before setting prev_p; otherwise the check for misbehaved
1624 sniffers will think that this frame's sniffer tried to unwind
1625 further (see frame_cleanup_after_sniffer). */
1626 if (this_frame
->unwind
== NULL
)
1627 frame_unwind_find_by_frame (this_frame
, &this_frame
->prologue_cache
);
1629 this_frame
->prev_p
= 1;
1630 this_frame
->stop_reason
= UNWIND_NO_REASON
;
1632 /* If we are unwinding from an inline frame, all of the below tests
1633 were already performed when we unwound from the next non-inline
1634 frame. We must skip them, since we can not get THIS_FRAME's ID
1635 until we have unwound all the way down to the previous non-inline
1637 if (get_frame_type (this_frame
) == INLINE_FRAME
)
1638 return get_prev_frame_raw (this_frame
);
1640 /* Check that this frame is unwindable. If it isn't, don't try to
1641 unwind to the prev frame. */
1642 this_frame
->stop_reason
1643 = this_frame
->unwind
->stop_reason (this_frame
,
1644 &this_frame
->prologue_cache
);
1646 if (this_frame
->stop_reason
!= UNWIND_NO_REASON
)
1649 /* Check that this frame's ID was valid. If it wasn't, don't try to
1650 unwind to the prev frame. Be careful to not apply this test to
1651 the sentinel frame. */
1652 this_id
= get_frame_id (this_frame
);
1653 if (this_frame
->level
>= 0 && frame_id_eq (this_id
, outer_frame_id
))
1657 fprintf_unfiltered (gdb_stdlog
, "-> ");
1658 fprint_frame (gdb_stdlog
, NULL
);
1659 fprintf_unfiltered (gdb_stdlog
, " // this ID is NULL }\n");
1661 this_frame
->stop_reason
= UNWIND_NULL_ID
;
1665 /* Check that this frame's ID isn't inner to (younger, below, next)
1666 the next frame. This happens when a frame unwind goes backwards.
1667 This check is valid only if this frame and the next frame are NORMAL.
1668 See the comment at frame_id_inner for details. */
1669 if (get_frame_type (this_frame
) == NORMAL_FRAME
1670 && this_frame
->next
->unwind
->type
== NORMAL_FRAME
1671 && frame_id_inner (get_frame_arch (this_frame
->next
), this_id
,
1672 get_frame_id (this_frame
->next
)))
1674 CORE_ADDR this_pc_in_block
;
1675 struct minimal_symbol
*morestack_msym
;
1676 const char *morestack_name
= NULL
;
1678 /* gcc -fsplit-stack __morestack can continue the stack anywhere. */
1679 this_pc_in_block
= get_frame_address_in_block (this_frame
);
1680 morestack_msym
= lookup_minimal_symbol_by_pc (this_pc_in_block
);
1682 morestack_name
= SYMBOL_LINKAGE_NAME (morestack_msym
);
1683 if (!morestack_name
|| strcmp (morestack_name
, "__morestack") != 0)
1687 fprintf_unfiltered (gdb_stdlog
, "-> ");
1688 fprint_frame (gdb_stdlog
, NULL
);
1689 fprintf_unfiltered (gdb_stdlog
,
1690 " // this frame ID is inner }\n");
1692 this_frame
->stop_reason
= UNWIND_INNER_ID
;
1697 /* Check that this and the next frame are not identical. If they
1698 are, there is most likely a stack cycle. As with the inner-than
1699 test above, avoid comparing the inner-most and sentinel frames. */
1700 if (this_frame
->level
> 0
1701 && frame_id_eq (this_id
, get_frame_id (this_frame
->next
)))
1705 fprintf_unfiltered (gdb_stdlog
, "-> ");
1706 fprint_frame (gdb_stdlog
, NULL
);
1707 fprintf_unfiltered (gdb_stdlog
, " // this frame has same ID }\n");
1709 this_frame
->stop_reason
= UNWIND_SAME_ID
;
1713 /* Check that this and the next frame do not unwind the PC register
1714 to the same memory location. If they do, then even though they
1715 have different frame IDs, the new frame will be bogus; two
1716 functions can't share a register save slot for the PC. This can
1717 happen when the prologue analyzer finds a stack adjustment, but
1720 This check does assume that the "PC register" is roughly a
1721 traditional PC, even if the gdbarch_unwind_pc method adjusts
1722 it (we do not rely on the value, only on the unwound PC being
1723 dependent on this value). A potential improvement would be
1724 to have the frame prev_pc method and the gdbarch unwind_pc
1725 method set the same lval and location information as
1726 frame_register_unwind. */
1727 if (this_frame
->level
> 0
1728 && gdbarch_pc_regnum (gdbarch
) >= 0
1729 && get_frame_type (this_frame
) == NORMAL_FRAME
1730 && (get_frame_type (this_frame
->next
) == NORMAL_FRAME
1731 || get_frame_type (this_frame
->next
) == INLINE_FRAME
))
1733 int optimized
, realnum
, nrealnum
;
1734 enum lval_type lval
, nlval
;
1735 CORE_ADDR addr
, naddr
;
1737 frame_register_unwind_location (this_frame
,
1738 gdbarch_pc_regnum (gdbarch
),
1739 &optimized
, &lval
, &addr
, &realnum
);
1740 frame_register_unwind_location (get_next_frame (this_frame
),
1741 gdbarch_pc_regnum (gdbarch
),
1742 &optimized
, &nlval
, &naddr
, &nrealnum
);
1744 if ((lval
== lval_memory
&& lval
== nlval
&& addr
== naddr
)
1745 || (lval
== lval_register
&& lval
== nlval
&& realnum
== nrealnum
))
1749 fprintf_unfiltered (gdb_stdlog
, "-> ");
1750 fprint_frame (gdb_stdlog
, NULL
);
1751 fprintf_unfiltered (gdb_stdlog
, " // no saved PC }\n");
1754 this_frame
->stop_reason
= UNWIND_NO_SAVED_PC
;
1755 this_frame
->prev
= NULL
;
1760 return get_prev_frame_raw (this_frame
);
1763 /* Construct a new "struct frame_info" and link it previous to
1766 static struct frame_info
*
1767 get_prev_frame_raw (struct frame_info
*this_frame
)
1769 struct frame_info
*prev_frame
;
1771 /* Allocate the new frame but do not wire it in to the frame chain.
1772 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
1773 frame->next to pull some fancy tricks (of course such code is, by
1774 definition, recursive). Try to prevent it.
1776 There is no reason to worry about memory leaks, should the
1777 remainder of the function fail. The allocated memory will be
1778 quickly reclaimed when the frame cache is flushed, and the `we've
1779 been here before' check above will stop repeated memory
1780 allocation calls. */
1781 prev_frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1782 prev_frame
->level
= this_frame
->level
+ 1;
1784 /* For now, assume we don't have frame chains crossing address
1786 prev_frame
->pspace
= this_frame
->pspace
;
1787 prev_frame
->aspace
= this_frame
->aspace
;
1789 /* Don't yet compute ->unwind (and hence ->type). It is computed
1790 on-demand in get_frame_type, frame_register_unwind, and
1793 /* Don't yet compute the frame's ID. It is computed on-demand by
1796 /* The unwound frame ID is validate at the start of this function,
1797 as part of the logic to decide if that frame should be further
1798 unwound, and not here while the prev frame is being created.
1799 Doing this makes it possible for the user to examine a frame that
1800 has an invalid frame ID.
1802 Some very old VAX code noted: [...] For the sake of argument,
1803 suppose that the stack is somewhat trashed (which is one reason
1804 that "info frame" exists). So, return 0 (indicating we don't
1805 know the address of the arglist) if we don't know what frame this
1809 this_frame
->prev
= prev_frame
;
1810 prev_frame
->next
= this_frame
;
1814 fprintf_unfiltered (gdb_stdlog
, "-> ");
1815 fprint_frame (gdb_stdlog
, prev_frame
);
1816 fprintf_unfiltered (gdb_stdlog
, " }\n");
1822 /* Debug routine to print a NULL frame being returned. */
1825 frame_debug_got_null_frame (struct frame_info
*this_frame
,
1830 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame (this_frame=");
1831 if (this_frame
!= NULL
)
1832 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1834 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1835 fprintf_unfiltered (gdb_stdlog
, ") -> // %s}\n", reason
);
1839 /* Is this (non-sentinel) frame in the "main"() function? */
1842 inside_main_func (struct frame_info
*this_frame
)
1844 struct minimal_symbol
*msymbol
;
1847 if (symfile_objfile
== 0)
1849 msymbol
= lookup_minimal_symbol (main_name (), NULL
, symfile_objfile
);
1850 if (msymbol
== NULL
)
1852 /* Make certain that the code, and not descriptor, address is
1854 maddr
= gdbarch_convert_from_func_ptr_addr (get_frame_arch (this_frame
),
1855 SYMBOL_VALUE_ADDRESS (msymbol
),
1857 return maddr
== get_frame_func (this_frame
);
1860 /* Test whether THIS_FRAME is inside the process entry point function. */
1863 inside_entry_func (struct frame_info
*this_frame
)
1865 CORE_ADDR entry_point
;
1867 if (!entry_point_address_query (&entry_point
))
1870 return get_frame_func (this_frame
) == entry_point
;
1873 /* Return a structure containing various interesting information about
1874 the frame that called THIS_FRAME. Returns NULL if there is entier
1875 no such frame or the frame fails any of a set of target-independent
1876 condition that should terminate the frame chain (e.g., as unwinding
1879 This function should not contain target-dependent tests, such as
1880 checking whether the program-counter is zero. */
1883 get_prev_frame (struct frame_info
*this_frame
)
1888 /* There is always a frame. If this assertion fails, suspect that
1889 something should be calling get_selected_frame() or
1890 get_current_frame(). */
1891 gdb_assert (this_frame
!= NULL
);
1892 frame_pc_p
= get_frame_pc_if_available (this_frame
, &frame_pc
);
1894 /* tausq/2004-12-07: Dummy frames are skipped because it doesn't make much
1895 sense to stop unwinding at a dummy frame. One place where a dummy
1896 frame may have an address "inside_main_func" is on HPUX. On HPUX, the
1897 pcsqh register (space register for the instruction at the head of the
1898 instruction queue) cannot be written directly; the only way to set it
1899 is to branch to code that is in the target space. In order to implement
1900 frame dummies on HPUX, the called function is made to jump back to where
1901 the inferior was when the user function was called. If gdb was inside
1902 the main function when we created the dummy frame, the dummy frame will
1903 point inside the main function. */
1904 if (this_frame
->level
>= 0
1905 && get_frame_type (this_frame
) == NORMAL_FRAME
1906 && !backtrace_past_main
1908 && inside_main_func (this_frame
))
1909 /* Don't unwind past main(). Note, this is done _before_ the
1910 frame has been marked as previously unwound. That way if the
1911 user later decides to enable unwinds past main(), that will
1912 automatically happen. */
1914 frame_debug_got_null_frame (this_frame
, "inside main func");
1918 /* If the user's backtrace limit has been exceeded, stop. We must
1919 add two to the current level; one of those accounts for backtrace_limit
1920 being 1-based and the level being 0-based, and the other accounts for
1921 the level of the new frame instead of the level of the current
1923 if (this_frame
->level
+ 2 > backtrace_limit
)
1925 frame_debug_got_null_frame (this_frame
, "backtrace limit exceeded");
1929 /* If we're already inside the entry function for the main objfile,
1930 then it isn't valid. Don't apply this test to a dummy frame -
1931 dummy frame PCs typically land in the entry func. Don't apply
1932 this test to the sentinel frame. Sentinel frames should always
1933 be allowed to unwind. */
1934 /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() -
1935 wasn't checking for "main" in the minimal symbols. With that
1936 fixed asm-source tests now stop in "main" instead of halting the
1937 backtrace in weird and wonderful ways somewhere inside the entry
1938 file. Suspect that tests for inside the entry file/func were
1939 added to work around that (now fixed) case. */
1940 /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
1941 suggested having the inside_entry_func test use the
1942 inside_main_func() msymbol trick (along with entry_point_address()
1943 I guess) to determine the address range of the start function.
1944 That should provide a far better stopper than the current
1946 /* NOTE: tausq/2004-10-09: this is needed if, for example, the compiler
1947 applied tail-call optimizations to main so that a function called
1948 from main returns directly to the caller of main. Since we don't
1949 stop at main, we should at least stop at the entry point of the
1951 if (this_frame
->level
>= 0
1952 && get_frame_type (this_frame
) == NORMAL_FRAME
1953 && !backtrace_past_entry
1955 && inside_entry_func (this_frame
))
1957 frame_debug_got_null_frame (this_frame
, "inside entry func");
1961 /* Assume that the only way to get a zero PC is through something
1962 like a SIGSEGV or a dummy frame, and hence that NORMAL frames
1963 will never unwind a zero PC. */
1964 if (this_frame
->level
> 0
1965 && (get_frame_type (this_frame
) == NORMAL_FRAME
1966 || get_frame_type (this_frame
) == INLINE_FRAME
)
1967 && get_frame_type (get_next_frame (this_frame
)) == NORMAL_FRAME
1968 && frame_pc_p
&& frame_pc
== 0)
1970 frame_debug_got_null_frame (this_frame
, "zero PC");
1974 return get_prev_frame_1 (this_frame
);
1978 get_frame_pc (struct frame_info
*frame
)
1980 gdb_assert (frame
->next
!= NULL
);
1981 return frame_unwind_pc (frame
->next
);
1985 get_frame_pc_if_available (struct frame_info
*frame
, CORE_ADDR
*pc
)
1987 volatile struct gdb_exception ex
;
1989 gdb_assert (frame
->next
!= NULL
);
1991 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
1993 *pc
= frame_unwind_pc (frame
->next
);
1997 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2000 throw_exception (ex
);
2006 /* Return an address that falls within THIS_FRAME's code block. */
2009 get_frame_address_in_block (struct frame_info
*this_frame
)
2011 /* A draft address. */
2012 CORE_ADDR pc
= get_frame_pc (this_frame
);
2014 struct frame_info
*next_frame
= this_frame
->next
;
2016 /* Calling get_frame_pc returns the resume address for THIS_FRAME.
2017 Normally the resume address is inside the body of the function
2018 associated with THIS_FRAME, but there is a special case: when
2019 calling a function which the compiler knows will never return
2020 (for instance abort), the call may be the very last instruction
2021 in the calling function. The resume address will point after the
2022 call and may be at the beginning of a different function
2025 If THIS_FRAME is a signal frame or dummy frame, then we should
2026 not adjust the unwound PC. For a dummy frame, GDB pushed the
2027 resume address manually onto the stack. For a signal frame, the
2028 OS may have pushed the resume address manually and invoked the
2029 handler (e.g. GNU/Linux), or invoked the trampoline which called
2030 the signal handler - but in either case the signal handler is
2031 expected to return to the trampoline. So in both of these
2032 cases we know that the resume address is executable and
2033 related. So we only need to adjust the PC if THIS_FRAME
2034 is a normal function.
2036 If the program has been interrupted while THIS_FRAME is current,
2037 then clearly the resume address is inside the associated
2038 function. There are three kinds of interruption: debugger stop
2039 (next frame will be SENTINEL_FRAME), operating system
2040 signal or exception (next frame will be SIGTRAMP_FRAME),
2041 or debugger-induced function call (next frame will be
2042 DUMMY_FRAME). So we only need to adjust the PC if
2043 NEXT_FRAME is a normal function.
2045 We check the type of NEXT_FRAME first, since it is already
2046 known; frame type is determined by the unwinder, and since
2047 we have THIS_FRAME we've already selected an unwinder for
2050 If the next frame is inlined, we need to keep going until we find
2051 the real function - for instance, if a signal handler is invoked
2052 while in an inlined function, then the code address of the
2053 "calling" normal function should not be adjusted either. */
2055 while (get_frame_type (next_frame
) == INLINE_FRAME
)
2056 next_frame
= next_frame
->next
;
2058 if ((get_frame_type (next_frame
) == NORMAL_FRAME
2059 || get_frame_type (next_frame
) == TAILCALL_FRAME
)
2060 && (get_frame_type (this_frame
) == NORMAL_FRAME
2061 || get_frame_type (this_frame
) == TAILCALL_FRAME
2062 || get_frame_type (this_frame
) == INLINE_FRAME
))
2069 get_frame_address_in_block_if_available (struct frame_info
*this_frame
,
2072 volatile struct gdb_exception ex
;
2074 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2076 *pc
= get_frame_address_in_block (this_frame
);
2078 if (ex
.reason
< 0 && ex
.error
== NOT_AVAILABLE_ERROR
)
2080 else if (ex
.reason
< 0)
2081 throw_exception (ex
);
2087 find_frame_sal (struct frame_info
*frame
, struct symtab_and_line
*sal
)
2089 struct frame_info
*next_frame
;
2093 /* If the next frame represents an inlined function call, this frame's
2094 sal is the "call site" of that inlined function, which can not
2095 be inferred from get_frame_pc. */
2096 next_frame
= get_next_frame (frame
);
2097 if (frame_inlined_callees (frame
) > 0)
2102 sym
= get_frame_function (next_frame
);
2104 sym
= inline_skipped_symbol (inferior_ptid
);
2106 /* If frame is inline, it certainly has symbols. */
2109 if (SYMBOL_LINE (sym
) != 0)
2111 sal
->symtab
= SYMBOL_SYMTAB (sym
);
2112 sal
->line
= SYMBOL_LINE (sym
);
2115 /* If the symbol does not have a location, we don't know where
2116 the call site is. Do not pretend to. This is jarring, but
2117 we can't do much better. */
2118 sal
->pc
= get_frame_pc (frame
);
2120 sal
->pspace
= get_frame_program_space (frame
);
2125 /* If FRAME is not the innermost frame, that normally means that
2126 FRAME->pc points at the return instruction (which is *after* the
2127 call instruction), and we want to get the line containing the
2128 call (because the call is where the user thinks the program is).
2129 However, if the next frame is either a SIGTRAMP_FRAME or a
2130 DUMMY_FRAME, then the next frame will contain a saved interrupt
2131 PC and such a PC indicates the current (rather than next)
2132 instruction/line, consequently, for such cases, want to get the
2133 line containing fi->pc. */
2134 if (!get_frame_pc_if_available (frame
, &pc
))
2140 notcurrent
= (pc
!= get_frame_address_in_block (frame
));
2141 (*sal
) = find_pc_line (pc
, notcurrent
);
2144 /* Per "frame.h", return the ``address'' of the frame. Code should
2145 really be using get_frame_id(). */
2147 get_frame_base (struct frame_info
*fi
)
2149 return get_frame_id (fi
).stack_addr
;
2152 /* High-level offsets into the frame. Used by the debug info. */
2155 get_frame_base_address (struct frame_info
*fi
)
2157 if (get_frame_type (fi
) != NORMAL_FRAME
)
2159 if (fi
->base
== NULL
)
2160 fi
->base
= frame_base_find_by_frame (fi
);
2161 /* Sneaky: If the low-level unwind and high-level base code share a
2162 common unwinder, let them share the prologue cache. */
2163 if (fi
->base
->unwind
== fi
->unwind
)
2164 return fi
->base
->this_base (fi
, &fi
->prologue_cache
);
2165 return fi
->base
->this_base (fi
, &fi
->base_cache
);
2169 get_frame_locals_address (struct frame_info
*fi
)
2171 if (get_frame_type (fi
) != NORMAL_FRAME
)
2173 /* If there isn't a frame address method, find it. */
2174 if (fi
->base
== NULL
)
2175 fi
->base
= frame_base_find_by_frame (fi
);
2176 /* Sneaky: If the low-level unwind and high-level base code share a
2177 common unwinder, let them share the prologue cache. */
2178 if (fi
->base
->unwind
== fi
->unwind
)
2179 return fi
->base
->this_locals (fi
, &fi
->prologue_cache
);
2180 return fi
->base
->this_locals (fi
, &fi
->base_cache
);
2184 get_frame_args_address (struct frame_info
*fi
)
2186 if (get_frame_type (fi
) != NORMAL_FRAME
)
2188 /* If there isn't a frame address method, find it. */
2189 if (fi
->base
== NULL
)
2190 fi
->base
= frame_base_find_by_frame (fi
);
2191 /* Sneaky: If the low-level unwind and high-level base code share a
2192 common unwinder, let them share the prologue cache. */
2193 if (fi
->base
->unwind
== fi
->unwind
)
2194 return fi
->base
->this_args (fi
, &fi
->prologue_cache
);
2195 return fi
->base
->this_args (fi
, &fi
->base_cache
);
2198 /* Return true if the frame unwinder for frame FI is UNWINDER; false
2202 frame_unwinder_is (struct frame_info
*fi
, const struct frame_unwind
*unwinder
)
2204 if (fi
->unwind
== NULL
)
2205 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
2206 return fi
->unwind
== unwinder
;
2209 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
2210 or -1 for a NULL frame. */
2213 frame_relative_level (struct frame_info
*fi
)
2222 get_frame_type (struct frame_info
*frame
)
2224 if (frame
->unwind
== NULL
)
2225 /* Initialize the frame's unwinder because that's what
2226 provides the frame's type. */
2227 frame_unwind_find_by_frame (frame
, &frame
->prologue_cache
);
2228 return frame
->unwind
->type
;
2231 struct program_space
*
2232 get_frame_program_space (struct frame_info
*frame
)
2234 return frame
->pspace
;
2237 struct program_space
*
2238 frame_unwind_program_space (struct frame_info
*this_frame
)
2240 gdb_assert (this_frame
);
2242 /* This is really a placeholder to keep the API consistent --- we
2243 assume for now that we don't have frame chains crossing
2245 return this_frame
->pspace
;
2248 struct address_space
*
2249 get_frame_address_space (struct frame_info
*frame
)
2251 return frame
->aspace
;
2254 /* Memory access methods. */
2257 get_frame_memory (struct frame_info
*this_frame
, CORE_ADDR addr
,
2258 gdb_byte
*buf
, int len
)
2260 read_memory (addr
, buf
, len
);
2264 get_frame_memory_signed (struct frame_info
*this_frame
, CORE_ADDR addr
,
2267 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2268 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2270 return read_memory_integer (addr
, len
, byte_order
);
2274 get_frame_memory_unsigned (struct frame_info
*this_frame
, CORE_ADDR addr
,
2277 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2278 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2280 return read_memory_unsigned_integer (addr
, len
, byte_order
);
2284 safe_frame_unwind_memory (struct frame_info
*this_frame
,
2285 CORE_ADDR addr
, gdb_byte
*buf
, int len
)
2287 /* NOTE: target_read_memory returns zero on success! */
2288 return !target_read_memory (addr
, buf
, len
);
2291 /* Architecture methods. */
2294 get_frame_arch (struct frame_info
*this_frame
)
2296 return frame_unwind_arch (this_frame
->next
);
2300 frame_unwind_arch (struct frame_info
*next_frame
)
2302 if (!next_frame
->prev_arch
.p
)
2304 struct gdbarch
*arch
;
2306 if (next_frame
->unwind
== NULL
)
2307 frame_unwind_find_by_frame (next_frame
, &next_frame
->prologue_cache
);
2309 if (next_frame
->unwind
->prev_arch
!= NULL
)
2310 arch
= next_frame
->unwind
->prev_arch (next_frame
,
2311 &next_frame
->prologue_cache
);
2313 arch
= get_frame_arch (next_frame
);
2315 next_frame
->prev_arch
.arch
= arch
;
2316 next_frame
->prev_arch
.p
= 1;
2318 fprintf_unfiltered (gdb_stdlog
,
2319 "{ frame_unwind_arch (next_frame=%d) -> %s }\n",
2321 gdbarch_bfd_arch_info (arch
)->printable_name
);
2324 return next_frame
->prev_arch
.arch
;
2328 frame_unwind_caller_arch (struct frame_info
*next_frame
)
2330 return frame_unwind_arch (skip_artificial_frames (next_frame
));
2333 /* Stack pointer methods. */
2336 get_frame_sp (struct frame_info
*this_frame
)
2338 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2340 /* Normality - an architecture that provides a way of obtaining any
2341 frame inner-most address. */
2342 if (gdbarch_unwind_sp_p (gdbarch
))
2343 /* NOTE drow/2008-06-28: gdbarch_unwind_sp could be converted to
2344 operate on THIS_FRAME now. */
2345 return gdbarch_unwind_sp (gdbarch
, this_frame
->next
);
2346 /* Now things are really are grim. Hope that the value returned by
2347 the gdbarch_sp_regnum register is meaningful. */
2348 if (gdbarch_sp_regnum (gdbarch
) >= 0)
2349 return get_frame_register_unsigned (this_frame
,
2350 gdbarch_sp_regnum (gdbarch
));
2351 internal_error (__FILE__
, __LINE__
, _("Missing unwind SP method"));
2354 /* Return the reason why we can't unwind past FRAME. */
2356 enum unwind_stop_reason
2357 get_frame_unwind_stop_reason (struct frame_info
*frame
)
2359 /* If we haven't tried to unwind past this point yet, then assume
2360 that unwinding would succeed. */
2361 if (frame
->prev_p
== 0)
2362 return UNWIND_NO_REASON
;
2364 /* Otherwise, we set a reason when we succeeded (or failed) to
2366 return frame
->stop_reason
;
2369 /* Return a string explaining REASON. */
2372 frame_stop_reason_string (enum unwind_stop_reason reason
)
2376 #define SET(name, description) \
2377 case name: return _(description);
2378 #include "unwind_stop_reasons.def"
2382 internal_error (__FILE__
, __LINE__
,
2383 "Invalid frame stop reason");
2387 /* Clean up after a failed (wrong unwinder) attempt to unwind past
2391 frame_cleanup_after_sniffer (void *arg
)
2393 struct frame_info
*frame
= arg
;
2395 /* The sniffer should not allocate a prologue cache if it did not
2396 match this frame. */
2397 gdb_assert (frame
->prologue_cache
== NULL
);
2399 /* No sniffer should extend the frame chain; sniff based on what is
2401 gdb_assert (!frame
->prev_p
);
2403 /* The sniffer should not check the frame's ID; that's circular. */
2404 gdb_assert (!frame
->this_id
.p
);
2406 /* Clear cached fields dependent on the unwinder.
2408 The previous PC is independent of the unwinder, but the previous
2409 function is not (see get_frame_address_in_block). */
2410 frame
->prev_func
.p
= 0;
2411 frame
->prev_func
.addr
= 0;
2413 /* Discard the unwinder last, so that we can easily find it if an assertion
2414 in this function triggers. */
2415 frame
->unwind
= NULL
;
2418 /* Set FRAME's unwinder temporarily, so that we can call a sniffer.
2419 Return a cleanup which should be called if unwinding fails, and
2420 discarded if it succeeds. */
2423 frame_prepare_for_sniffer (struct frame_info
*frame
,
2424 const struct frame_unwind
*unwind
)
2426 gdb_assert (frame
->unwind
== NULL
);
2427 frame
->unwind
= unwind
;
2428 return make_cleanup (frame_cleanup_after_sniffer
, frame
);
2431 extern initialize_file_ftype _initialize_frame
; /* -Wmissing-prototypes */
2433 static struct cmd_list_element
*set_backtrace_cmdlist
;
2434 static struct cmd_list_element
*show_backtrace_cmdlist
;
2437 set_backtrace_cmd (char *args
, int from_tty
)
2439 help_list (set_backtrace_cmdlist
, "set backtrace ", -1, gdb_stdout
);
2443 show_backtrace_cmd (char *args
, int from_tty
)
2445 cmd_show_list (show_backtrace_cmdlist
, from_tty
, "");
2449 _initialize_frame (void)
2451 obstack_init (&frame_cache_obstack
);
2453 observer_attach_target_changed (frame_observer_target_changed
);
2455 add_prefix_cmd ("backtrace", class_maintenance
, set_backtrace_cmd
, _("\
2456 Set backtrace specific variables.\n\
2457 Configure backtrace variables such as the backtrace limit"),
2458 &set_backtrace_cmdlist
, "set backtrace ",
2459 0/*allow-unknown*/, &setlist
);
2460 add_prefix_cmd ("backtrace", class_maintenance
, show_backtrace_cmd
, _("\
2461 Show backtrace specific variables\n\
2462 Show backtrace variables such as the backtrace limit"),
2463 &show_backtrace_cmdlist
, "show backtrace ",
2464 0/*allow-unknown*/, &showlist
);
2466 add_setshow_boolean_cmd ("past-main", class_obscure
,
2467 &backtrace_past_main
, _("\
2468 Set whether backtraces should continue past \"main\"."), _("\
2469 Show whether backtraces should continue past \"main\"."), _("\
2470 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
2471 the backtrace at \"main\". Set this variable if you need to see the rest\n\
2472 of the stack trace."),
2474 show_backtrace_past_main
,
2475 &set_backtrace_cmdlist
,
2476 &show_backtrace_cmdlist
);
2478 add_setshow_boolean_cmd ("past-entry", class_obscure
,
2479 &backtrace_past_entry
, _("\
2480 Set whether backtraces should continue past the entry point of a program."),
2482 Show whether backtraces should continue past the entry point of a program."),
2484 Normally there are no callers beyond the entry point of a program, so GDB\n\
2485 will terminate the backtrace there. Set this variable if you need to see\n\
2486 the rest of the stack trace."),
2488 show_backtrace_past_entry
,
2489 &set_backtrace_cmdlist
,
2490 &show_backtrace_cmdlist
);
2492 add_setshow_uinteger_cmd ("limit", class_obscure
,
2493 &backtrace_limit
, _("\
2494 Set an upper bound on the number of backtrace levels."), _("\
2495 Show the upper bound on the number of backtrace levels."), _("\
2496 No more than the specified number of frames can be displayed or examined.\n\
2497 Zero is unlimited."),
2499 show_backtrace_limit
,
2500 &set_backtrace_cmdlist
,
2501 &show_backtrace_cmdlist
);
2503 /* Debug this files internals. */
2504 add_setshow_zuinteger_cmd ("frame", class_maintenance
, &frame_debug
, _("\
2505 Set frame debugging."), _("\
2506 Show frame debugging."), _("\
2507 When non-zero, frame specific internal debugging is enabled."),
2510 &setdebuglist
, &showdebuglist
);