1 /* Cache and manage frames for GDB, the GNU debugger.
3 Copyright (C) 1986-2017 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "inferior.h" /* for inferior_ptid */
26 #include "user-regs.h"
27 #include "gdb_obstack.h"
28 #include "dummy-frame.h"
29 #include "sentinel-frame.h"
33 #include "frame-unwind.h"
34 #include "frame-base.h"
39 #include "gdbthread.h"
41 #include "inline-frame.h"
42 #include "tracepoint.h"
46 /* The sentinel frame terminates the innermost end of the frame chain.
47 If unwound, it returns the information needed to construct an
50 The current frame, which is the innermost frame, can be found at
51 sentinel_frame->prev. */
53 static struct frame_info
*sentinel_frame
;
55 static struct frame_info
*get_prev_frame_raw (struct frame_info
*this_frame
);
56 static const char *frame_stop_reason_symbol_string (enum unwind_stop_reason reason
);
58 /* Status of some values cached in the frame_info object. */
60 enum cached_copy_status
62 /* Value is unknown. */
65 /* We have a value. */
68 /* Value was not saved. */
71 /* Value is unavailable. */
75 /* We keep a cache of stack frames, each of which is a "struct
76 frame_info". The innermost one gets allocated (in
77 wait_for_inferior) each time the inferior stops; sentinel_frame
78 points to it. Additional frames get allocated (in get_prev_frame)
79 as needed, and are chained through the next and prev fields. Any
80 time that the frame cache becomes invalid (most notably when we
81 execute something, but also if we change how we interpret the
82 frames (e.g. "set heuristic-fence-post" in mips-tdep.c, or anything
83 which reads new symbols)), we should call reinit_frame_cache. */
87 /* Level of this frame. The inner-most (youngest) frame is at level
88 0. As you move towards the outer-most (oldest) frame, the level
89 increases. This is a cached value. It could just as easily be
90 computed by counting back from the selected frame to the inner
92 /* NOTE: cagney/2002-04-05: Perhaps a level of ``-1'' should be
93 reserved to indicate a bogus frame - one that has been created
94 just to keep GDB happy (GDB always needs a frame). For the
95 moment leave this as speculation. */
98 /* The frame's program space. */
99 struct program_space
*pspace
;
101 /* The frame's address space. */
102 struct address_space
*aspace
;
104 /* The frame's low-level unwinder and corresponding cache. The
105 low-level unwinder is responsible for unwinding register values
106 for the previous frame. The low-level unwind methods are
107 selected based on the presence, or otherwise, of register unwind
108 information such as CFI. */
109 void *prologue_cache
;
110 const struct frame_unwind
*unwind
;
112 /* Cached copy of the previous frame's architecture. */
116 struct gdbarch
*arch
;
119 /* Cached copy of the previous frame's resume address. */
121 enum cached_copy_status status
;
125 /* Cached copy of the previous frame's function address. */
132 /* This frame's ID. */
136 struct frame_id value
;
139 /* The frame's high-level base methods, and corresponding cache.
140 The high level base methods are selected based on the frame's
142 const struct frame_base
*base
;
145 /* Pointers to the next (down, inner, younger) and previous (up,
146 outer, older) frame_info's in the frame cache. */
147 struct frame_info
*next
; /* down, inner, younger */
149 struct frame_info
*prev
; /* up, outer, older */
151 /* The reason why we could not set PREV, or UNWIND_NO_REASON if we
152 could. Only valid when PREV_P is set. */
153 enum unwind_stop_reason stop_reason
;
155 /* A frame specific string describing the STOP_REASON in more detail.
156 Only valid when PREV_P is set, but even then may still be NULL. */
157 const char *stop_string
;
160 /* A frame stash used to speed up frame lookups. Create a hash table
161 to stash frames previously accessed from the frame cache for
162 quicker subsequent retrieval. The hash table is emptied whenever
163 the frame cache is invalidated. */
165 static htab_t frame_stash
;
167 /* Internal function to calculate a hash from the frame_id addresses,
168 using as many valid addresses as possible. Frames below level 0
169 are not stored in the hash table. */
172 frame_addr_hash (const void *ap
)
174 const struct frame_info
*frame
= (const struct frame_info
*) ap
;
175 const struct frame_id f_id
= frame
->this_id
.value
;
178 gdb_assert (f_id
.stack_status
!= FID_STACK_INVALID
180 || f_id
.special_addr_p
);
182 if (f_id
.stack_status
== FID_STACK_VALID
)
183 hash
= iterative_hash (&f_id
.stack_addr
,
184 sizeof (f_id
.stack_addr
), hash
);
185 if (f_id
.code_addr_p
)
186 hash
= iterative_hash (&f_id
.code_addr
,
187 sizeof (f_id
.code_addr
), hash
);
188 if (f_id
.special_addr_p
)
189 hash
= iterative_hash (&f_id
.special_addr
,
190 sizeof (f_id
.special_addr
), hash
);
195 /* Internal equality function for the hash table. This function
196 defers equality operations to frame_id_eq. */
199 frame_addr_hash_eq (const void *a
, const void *b
)
201 const struct frame_info
*f_entry
= (const struct frame_info
*) a
;
202 const struct frame_info
*f_element
= (const struct frame_info
*) b
;
204 return frame_id_eq (f_entry
->this_id
.value
,
205 f_element
->this_id
.value
);
208 /* Internal function to create the frame_stash hash table. 100 seems
209 to be a good compromise to start the hash table at. */
212 frame_stash_create (void)
214 frame_stash
= htab_create (100,
220 /* Internal function to add a frame to the frame_stash hash table.
221 Returns false if a frame with the same ID was already stashed, true
225 frame_stash_add (struct frame_info
*frame
)
227 struct frame_info
**slot
;
229 /* Do not try to stash the sentinel frame. */
230 gdb_assert (frame
->level
>= 0);
232 slot
= (struct frame_info
**) htab_find_slot (frame_stash
,
236 /* If we already have a frame in the stack with the same id, we
237 either have a stack cycle (corrupted stack?), or some bug
238 elsewhere in GDB. In any case, ignore the duplicate and return
239 an indication to the caller. */
247 /* Internal function to search the frame stash for an entry with the
248 given frame ID. If found, return that frame. Otherwise return
251 static struct frame_info
*
252 frame_stash_find (struct frame_id id
)
254 struct frame_info dummy
;
255 struct frame_info
*frame
;
257 dummy
.this_id
.value
= id
;
258 frame
= (struct frame_info
*) htab_find (frame_stash
, &dummy
);
262 /* Internal function to invalidate the frame stash by removing all
263 entries in it. This only occurs when the frame cache is
267 frame_stash_invalidate (void)
269 htab_empty (frame_stash
);
272 /* Flag to control debugging. */
274 unsigned int frame_debug
;
276 show_frame_debug (struct ui_file
*file
, int from_tty
,
277 struct cmd_list_element
*c
, const char *value
)
279 fprintf_filtered (file
, _("Frame debugging is %s.\n"), value
);
282 /* Flag to indicate whether backtraces should stop at main et.al. */
284 static int backtrace_past_main
;
286 show_backtrace_past_main (struct ui_file
*file
, int from_tty
,
287 struct cmd_list_element
*c
, const char *value
)
289 fprintf_filtered (file
,
290 _("Whether backtraces should "
291 "continue past \"main\" is %s.\n"),
295 static int backtrace_past_entry
;
297 show_backtrace_past_entry (struct ui_file
*file
, int from_tty
,
298 struct cmd_list_element
*c
, const char *value
)
300 fprintf_filtered (file
, _("Whether backtraces should continue past the "
301 "entry point of a program is %s.\n"),
305 static unsigned int backtrace_limit
= UINT_MAX
;
307 show_backtrace_limit (struct ui_file
*file
, int from_tty
,
308 struct cmd_list_element
*c
, const char *value
)
310 fprintf_filtered (file
,
311 _("An upper bound on the number "
312 "of backtrace levels is %s.\n"),
318 fprint_field (struct ui_file
*file
, const char *name
, int p
, CORE_ADDR addr
)
321 fprintf_unfiltered (file
, "%s=%s", name
, hex_string (addr
));
323 fprintf_unfiltered (file
, "!%s", name
);
327 fprint_frame_id (struct ui_file
*file
, struct frame_id id
)
329 fprintf_unfiltered (file
, "{");
331 if (id
.stack_status
== FID_STACK_INVALID
)
332 fprintf_unfiltered (file
, "!stack");
333 else if (id
.stack_status
== FID_STACK_UNAVAILABLE
)
334 fprintf_unfiltered (file
, "stack=<unavailable>");
335 else if (id
.stack_status
== FID_STACK_SENTINEL
)
336 fprintf_unfiltered (file
, "stack=<sentinel>");
338 fprintf_unfiltered (file
, "stack=%s", hex_string (id
.stack_addr
));
339 fprintf_unfiltered (file
, ",");
341 fprint_field (file
, "code", id
.code_addr_p
, id
.code_addr
);
342 fprintf_unfiltered (file
, ",");
344 fprint_field (file
, "special", id
.special_addr_p
, id
.special_addr
);
346 if (id
.artificial_depth
)
347 fprintf_unfiltered (file
, ",artificial=%d", id
.artificial_depth
);
349 fprintf_unfiltered (file
, "}");
353 fprint_frame_type (struct ui_file
*file
, enum frame_type type
)
358 fprintf_unfiltered (file
, "NORMAL_FRAME");
361 fprintf_unfiltered (file
, "DUMMY_FRAME");
364 fprintf_unfiltered (file
, "INLINE_FRAME");
367 fprintf_unfiltered (file
, "TAILCALL_FRAME");
370 fprintf_unfiltered (file
, "SIGTRAMP_FRAME");
373 fprintf_unfiltered (file
, "ARCH_FRAME");
376 fprintf_unfiltered (file
, "SENTINEL_FRAME");
379 fprintf_unfiltered (file
, "<unknown type>");
385 fprint_frame (struct ui_file
*file
, struct frame_info
*fi
)
389 fprintf_unfiltered (file
, "<NULL frame>");
392 fprintf_unfiltered (file
, "{");
393 fprintf_unfiltered (file
, "level=%d", fi
->level
);
394 fprintf_unfiltered (file
, ",");
395 fprintf_unfiltered (file
, "type=");
396 if (fi
->unwind
!= NULL
)
397 fprint_frame_type (file
, fi
->unwind
->type
);
399 fprintf_unfiltered (file
, "<unknown>");
400 fprintf_unfiltered (file
, ",");
401 fprintf_unfiltered (file
, "unwind=");
402 if (fi
->unwind
!= NULL
)
403 gdb_print_host_address (fi
->unwind
, file
);
405 fprintf_unfiltered (file
, "<unknown>");
406 fprintf_unfiltered (file
, ",");
407 fprintf_unfiltered (file
, "pc=");
408 if (fi
->next
== NULL
|| fi
->next
->prev_pc
.status
== CC_UNKNOWN
)
409 fprintf_unfiltered (file
, "<unknown>");
410 else if (fi
->next
->prev_pc
.status
== CC_VALUE
)
411 fprintf_unfiltered (file
, "%s",
412 hex_string (fi
->next
->prev_pc
.value
));
413 else if (fi
->next
->prev_pc
.status
== CC_NOT_SAVED
)
414 val_print_not_saved (file
);
415 else if (fi
->next
->prev_pc
.status
== CC_UNAVAILABLE
)
416 val_print_unavailable (file
);
417 fprintf_unfiltered (file
, ",");
418 fprintf_unfiltered (file
, "id=");
420 fprint_frame_id (file
, fi
->this_id
.value
);
422 fprintf_unfiltered (file
, "<unknown>");
423 fprintf_unfiltered (file
, ",");
424 fprintf_unfiltered (file
, "func=");
425 if (fi
->next
!= NULL
&& fi
->next
->prev_func
.p
)
426 fprintf_unfiltered (file
, "%s", hex_string (fi
->next
->prev_func
.addr
));
428 fprintf_unfiltered (file
, "<unknown>");
429 fprintf_unfiltered (file
, "}");
432 /* Given FRAME, return the enclosing frame as found in real frames read-in from
433 inferior memory. Skip any previous frames which were made up by GDB.
434 Return FRAME if FRAME is a non-artificial frame.
435 Return NULL if FRAME is the start of an artificial-only chain. */
437 static struct frame_info
*
438 skip_artificial_frames (struct frame_info
*frame
)
440 /* Note we use get_prev_frame_always, and not get_prev_frame. The
441 latter will truncate the frame chain, leading to this function
442 unintentionally returning a null_frame_id (e.g., when the user
443 sets a backtrace limit).
445 Note that for record targets we may get a frame chain that consists
446 of artificial frames only. */
447 while (get_frame_type (frame
) == INLINE_FRAME
448 || get_frame_type (frame
) == TAILCALL_FRAME
)
450 frame
= get_prev_frame_always (frame
);
459 skip_unwritable_frames (struct frame_info
*frame
)
461 while (gdbarch_code_of_frame_writable (get_frame_arch (frame
), frame
) == 0)
463 frame
= get_prev_frame (frame
);
474 skip_tailcall_frames (struct frame_info
*frame
)
476 while (get_frame_type (frame
) == TAILCALL_FRAME
)
478 /* Note that for record targets we may get a frame chain that consists of
479 tailcall frames only. */
480 frame
= get_prev_frame (frame
);
488 /* Compute the frame's uniq ID that can be used to, later, re-find the
492 compute_frame_id (struct frame_info
*fi
)
494 gdb_assert (!fi
->this_id
.p
);
497 fprintf_unfiltered (gdb_stdlog
, "{ compute_frame_id (fi=%d) ",
499 /* Find the unwinder. */
500 if (fi
->unwind
== NULL
)
501 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
502 /* Find THIS frame's ID. */
503 /* Default to outermost if no ID is found. */
504 fi
->this_id
.value
= outer_frame_id
;
505 fi
->unwind
->this_id (fi
, &fi
->prologue_cache
, &fi
->this_id
.value
);
506 gdb_assert (frame_id_p (fi
->this_id
.value
));
510 fprintf_unfiltered (gdb_stdlog
, "-> ");
511 fprint_frame_id (gdb_stdlog
, fi
->this_id
.value
);
512 fprintf_unfiltered (gdb_stdlog
, " }\n");
516 /* Return a frame uniq ID that can be used to, later, re-find the
520 get_frame_id (struct frame_info
*fi
)
523 return null_frame_id
;
529 /* If we haven't computed the frame id yet, then it must be that
530 this is the current frame. Compute it now, and stash the
531 result. The IDs of other frames are computed as soon as
532 they're created, in order to detect cycles. See
533 get_prev_frame_if_no_cycle. */
534 gdb_assert (fi
->level
== 0);
537 compute_frame_id (fi
);
539 /* Since this is the first frame in the chain, this should
541 stashed
= frame_stash_add (fi
);
542 gdb_assert (stashed
);
545 return fi
->this_id
.value
;
549 get_stack_frame_id (struct frame_info
*next_frame
)
551 return get_frame_id (skip_artificial_frames (next_frame
));
555 frame_unwind_caller_id (struct frame_info
*next_frame
)
557 struct frame_info
*this_frame
;
559 /* Use get_prev_frame_always, and not get_prev_frame. The latter
560 will truncate the frame chain, leading to this function
561 unintentionally returning a null_frame_id (e.g., when a caller
562 requests the frame ID of "main()"s caller. */
564 next_frame
= skip_artificial_frames (next_frame
);
565 if (next_frame
== NULL
)
566 return null_frame_id
;
568 this_frame
= get_prev_frame_always (next_frame
);
570 return get_frame_id (skip_artificial_frames (this_frame
));
572 return null_frame_id
;
575 const struct frame_id null_frame_id
= { 0 }; /* All zeros. */
576 const struct frame_id sentinel_frame_id
= { 0, 0, 0, FID_STACK_SENTINEL
, 0, 1, 0 };
577 const struct frame_id outer_frame_id
= { 0, 0, 0, FID_STACK_INVALID
, 0, 1, 0 };
580 frame_id_build_special (CORE_ADDR stack_addr
, CORE_ADDR code_addr
,
581 CORE_ADDR special_addr
)
583 struct frame_id id
= null_frame_id
;
585 id
.stack_addr
= stack_addr
;
586 id
.stack_status
= FID_STACK_VALID
;
587 id
.code_addr
= code_addr
;
589 id
.special_addr
= special_addr
;
590 id
.special_addr_p
= 1;
597 frame_id_build_unavailable_stack (CORE_ADDR code_addr
)
599 struct frame_id id
= null_frame_id
;
601 id
.stack_status
= FID_STACK_UNAVAILABLE
;
602 id
.code_addr
= code_addr
;
610 frame_id_build_unavailable_stack_special (CORE_ADDR code_addr
,
611 CORE_ADDR special_addr
)
613 struct frame_id id
= null_frame_id
;
615 id
.stack_status
= FID_STACK_UNAVAILABLE
;
616 id
.code_addr
= code_addr
;
618 id
.special_addr
= special_addr
;
619 id
.special_addr_p
= 1;
624 frame_id_build (CORE_ADDR stack_addr
, CORE_ADDR code_addr
)
626 struct frame_id id
= null_frame_id
;
628 id
.stack_addr
= stack_addr
;
629 id
.stack_status
= FID_STACK_VALID
;
630 id
.code_addr
= code_addr
;
636 frame_id_build_wild (CORE_ADDR stack_addr
)
638 struct frame_id id
= null_frame_id
;
640 id
.stack_addr
= stack_addr
;
641 id
.stack_status
= FID_STACK_VALID
;
646 frame_id_p (struct frame_id l
)
650 /* The frame is valid iff it has a valid stack address. */
651 p
= l
.stack_status
!= FID_STACK_INVALID
;
652 /* outer_frame_id is also valid. */
653 if (!p
&& memcmp (&l
, &outer_frame_id
, sizeof (l
)) == 0)
657 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_p (l=");
658 fprint_frame_id (gdb_stdlog
, l
);
659 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", p
);
665 frame_id_artificial_p (struct frame_id l
)
670 return (l
.artificial_depth
!= 0);
674 frame_id_eq (struct frame_id l
, struct frame_id r
)
678 if (l
.stack_status
== FID_STACK_INVALID
&& l
.special_addr_p
679 && r
.stack_status
== FID_STACK_INVALID
&& r
.special_addr_p
)
680 /* The outermost frame marker is equal to itself. This is the
681 dodgy thing about outer_frame_id, since between execution steps
682 we might step into another function - from which we can't
683 unwind either. More thought required to get rid of
686 else if (l
.stack_status
== FID_STACK_INVALID
687 || r
.stack_status
== FID_STACK_INVALID
)
688 /* Like a NaN, if either ID is invalid, the result is false.
689 Note that a frame ID is invalid iff it is the null frame ID. */
691 else if (l
.stack_status
!= r
.stack_status
|| l
.stack_addr
!= r
.stack_addr
)
692 /* If .stack addresses are different, the frames are different. */
694 else if (l
.code_addr_p
&& r
.code_addr_p
&& l
.code_addr
!= r
.code_addr
)
695 /* An invalid code addr is a wild card. If .code addresses are
696 different, the frames are different. */
698 else if (l
.special_addr_p
&& r
.special_addr_p
699 && l
.special_addr
!= r
.special_addr
)
700 /* An invalid special addr is a wild card (or unused). Otherwise
701 if special addresses are different, the frames are different. */
703 else if (l
.artificial_depth
!= r
.artificial_depth
)
704 /* If artifical depths are different, the frames must be different. */
707 /* Frames are equal. */
712 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_eq (l=");
713 fprint_frame_id (gdb_stdlog
, l
);
714 fprintf_unfiltered (gdb_stdlog
, ",r=");
715 fprint_frame_id (gdb_stdlog
, r
);
716 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", eq
);
721 /* Safety net to check whether frame ID L should be inner to
722 frame ID R, according to their stack addresses.
724 This method cannot be used to compare arbitrary frames, as the
725 ranges of valid stack addresses may be discontiguous (e.g. due
728 However, it can be used as safety net to discover invalid frame
729 IDs in certain circumstances. Assuming that NEXT is the immediate
730 inner frame to THIS and that NEXT and THIS are both NORMAL frames:
732 * The stack address of NEXT must be inner-than-or-equal to the stack
735 Therefore, if frame_id_inner (THIS, NEXT) holds, some unwind
738 * If NEXT and THIS have different stack addresses, no other frame
739 in the frame chain may have a stack address in between.
741 Therefore, if frame_id_inner (TEST, THIS) holds, but
742 frame_id_inner (TEST, NEXT) does not hold, TEST cannot refer
743 to a valid frame in the frame chain.
745 The sanity checks above cannot be performed when a SIGTRAMP frame
746 is involved, because signal handlers might be executed on a different
747 stack than the stack used by the routine that caused the signal
748 to be raised. This can happen for instance when a thread exceeds
749 its maximum stack size. In this case, certain compilers implement
750 a stack overflow strategy that cause the handler to be run on a
754 frame_id_inner (struct gdbarch
*gdbarch
, struct frame_id l
, struct frame_id r
)
758 if (l
.stack_status
!= FID_STACK_VALID
|| r
.stack_status
!= FID_STACK_VALID
)
759 /* Like NaN, any operation involving an invalid ID always fails.
760 Likewise if either ID has an unavailable stack address. */
762 else if (l
.artificial_depth
> r
.artificial_depth
763 && l
.stack_addr
== r
.stack_addr
764 && l
.code_addr_p
== r
.code_addr_p
765 && l
.special_addr_p
== r
.special_addr_p
766 && l
.special_addr
== r
.special_addr
)
768 /* Same function, different inlined functions. */
769 const struct block
*lb
, *rb
;
771 gdb_assert (l
.code_addr_p
&& r
.code_addr_p
);
773 lb
= block_for_pc (l
.code_addr
);
774 rb
= block_for_pc (r
.code_addr
);
776 if (lb
== NULL
|| rb
== NULL
)
777 /* Something's gone wrong. */
780 /* This will return true if LB and RB are the same block, or
781 if the block with the smaller depth lexically encloses the
782 block with the greater depth. */
783 inner
= contained_in (lb
, rb
);
786 /* Only return non-zero when strictly inner than. Note that, per
787 comment in "frame.h", there is some fuzz here. Frameless
788 functions are not strictly inner than (same .stack but
789 different .code and/or .special address). */
790 inner
= gdbarch_inner_than (gdbarch
, l
.stack_addr
, r
.stack_addr
);
793 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_inner (l=");
794 fprint_frame_id (gdb_stdlog
, l
);
795 fprintf_unfiltered (gdb_stdlog
, ",r=");
796 fprint_frame_id (gdb_stdlog
, r
);
797 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", inner
);
803 frame_find_by_id (struct frame_id id
)
805 struct frame_info
*frame
, *prev_frame
;
807 /* ZERO denotes the null frame, let the caller decide what to do
808 about it. Should it instead return get_current_frame()? */
809 if (!frame_id_p (id
))
812 /* Check for the sentinel frame. */
813 if (frame_id_eq (id
, sentinel_frame_id
))
814 return sentinel_frame
;
816 /* Try using the frame stash first. Finding it there removes the need
817 to perform the search by looping over all frames, which can be very
818 CPU-intensive if the number of frames is very high (the loop is O(n)
819 and get_prev_frame performs a series of checks that are relatively
820 expensive). This optimization is particularly useful when this function
821 is called from another function (such as value_fetch_lazy, case
822 VALUE_LVAL (val) == lval_register) which already loops over all frames,
823 making the overall behavior O(n^2). */
824 frame
= frame_stash_find (id
);
828 for (frame
= get_current_frame (); ; frame
= prev_frame
)
830 struct frame_id self
= get_frame_id (frame
);
832 if (frame_id_eq (id
, self
))
833 /* An exact match. */
836 prev_frame
= get_prev_frame (frame
);
840 /* As a safety net to avoid unnecessary backtracing while trying
841 to find an invalid ID, we check for a common situation where
842 we can detect from comparing stack addresses that no other
843 frame in the current frame chain can have this ID. See the
844 comment at frame_id_inner for details. */
845 if (get_frame_type (frame
) == NORMAL_FRAME
846 && !frame_id_inner (get_frame_arch (frame
), id
, self
)
847 && frame_id_inner (get_frame_arch (prev_frame
), id
,
848 get_frame_id (prev_frame
)))
855 frame_unwind_pc (struct frame_info
*this_frame
)
857 if (this_frame
->prev_pc
.status
== CC_UNKNOWN
)
859 if (gdbarch_unwind_pc_p (frame_unwind_arch (this_frame
)))
861 struct gdbarch
*prev_gdbarch
;
865 /* The right way. The `pure' way. The one true way. This
866 method depends solely on the register-unwind code to
867 determine the value of registers in THIS frame, and hence
868 the value of this frame's PC (resume address). A typical
869 implementation is no more than:
871 frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
872 return extract_unsigned_integer (buf, size of ISA_PC_REGNUM);
874 Note: this method is very heavily dependent on a correct
875 register-unwind implementation, it pays to fix that
876 method first; this method is frame type agnostic, since
877 it only deals with register values, it works with any
878 frame. This is all in stark contrast to the old
879 FRAME_SAVED_PC which would try to directly handle all the
880 different ways that a PC could be unwound. */
881 prev_gdbarch
= frame_unwind_arch (this_frame
);
885 pc
= gdbarch_unwind_pc (prev_gdbarch
, this_frame
);
888 CATCH (ex
, RETURN_MASK_ERROR
)
890 if (ex
.error
== NOT_AVAILABLE_ERROR
)
892 this_frame
->prev_pc
.status
= CC_UNAVAILABLE
;
895 fprintf_unfiltered (gdb_stdlog
,
896 "{ frame_unwind_pc (this_frame=%d)"
897 " -> <unavailable> }\n",
900 else if (ex
.error
== OPTIMIZED_OUT_ERROR
)
902 this_frame
->prev_pc
.status
= CC_NOT_SAVED
;
905 fprintf_unfiltered (gdb_stdlog
,
906 "{ frame_unwind_pc (this_frame=%d)"
907 " -> <not saved> }\n",
911 throw_exception (ex
);
917 this_frame
->prev_pc
.value
= pc
;
918 this_frame
->prev_pc
.status
= CC_VALUE
;
920 fprintf_unfiltered (gdb_stdlog
,
921 "{ frame_unwind_pc (this_frame=%d) "
924 hex_string (this_frame
->prev_pc
.value
));
928 internal_error (__FILE__
, __LINE__
, _("No unwind_pc method"));
931 if (this_frame
->prev_pc
.status
== CC_VALUE
)
932 return this_frame
->prev_pc
.value
;
933 else if (this_frame
->prev_pc
.status
== CC_UNAVAILABLE
)
934 throw_error (NOT_AVAILABLE_ERROR
, _("PC not available"));
935 else if (this_frame
->prev_pc
.status
== CC_NOT_SAVED
)
936 throw_error (OPTIMIZED_OUT_ERROR
, _("PC not saved"));
938 internal_error (__FILE__
, __LINE__
,
939 "unexpected prev_pc status: %d",
940 (int) this_frame
->prev_pc
.status
);
944 frame_unwind_caller_pc (struct frame_info
*this_frame
)
946 this_frame
= skip_artificial_frames (this_frame
);
948 /* We must have a non-artificial frame. The caller is supposed to check
949 the result of frame_unwind_caller_id (), which returns NULL_FRAME_ID
951 gdb_assert (this_frame
!= NULL
);
953 return frame_unwind_pc (this_frame
);
957 get_frame_func_if_available (struct frame_info
*this_frame
, CORE_ADDR
*pc
)
959 struct frame_info
*next_frame
= this_frame
->next
;
961 if (!next_frame
->prev_func
.p
)
963 CORE_ADDR addr_in_block
;
965 /* Make certain that this, and not the adjacent, function is
967 if (!get_frame_address_in_block_if_available (this_frame
, &addr_in_block
))
969 next_frame
->prev_func
.p
= -1;
971 fprintf_unfiltered (gdb_stdlog
,
972 "{ get_frame_func (this_frame=%d)"
973 " -> unavailable }\n",
978 next_frame
->prev_func
.p
= 1;
979 next_frame
->prev_func
.addr
= get_pc_function_start (addr_in_block
);
981 fprintf_unfiltered (gdb_stdlog
,
982 "{ get_frame_func (this_frame=%d) -> %s }\n",
984 hex_string (next_frame
->prev_func
.addr
));
988 if (next_frame
->prev_func
.p
< 0)
995 *pc
= next_frame
->prev_func
.addr
;
1001 get_frame_func (struct frame_info
*this_frame
)
1005 if (!get_frame_func_if_available (this_frame
, &pc
))
1006 throw_error (NOT_AVAILABLE_ERROR
, _("PC not available"));
1011 static enum register_status
1012 do_frame_register_read (void *src
, int regnum
, gdb_byte
*buf
)
1014 if (!deprecated_frame_register_read ((struct frame_info
*) src
, regnum
, buf
))
1015 return REG_UNAVAILABLE
;
1021 frame_save_as_regcache (struct frame_info
*this_frame
)
1023 struct address_space
*aspace
= get_frame_address_space (this_frame
);
1024 struct regcache
*regcache
= regcache_xmalloc (get_frame_arch (this_frame
),
1026 struct cleanup
*cleanups
= make_cleanup_regcache_xfree (regcache
);
1028 regcache_save (regcache
, do_frame_register_read
, this_frame
);
1029 discard_cleanups (cleanups
);
1034 frame_pop (struct frame_info
*this_frame
)
1036 struct frame_info
*prev_frame
;
1037 struct regcache
*scratch
;
1038 struct cleanup
*cleanups
;
1040 if (get_frame_type (this_frame
) == DUMMY_FRAME
)
1042 /* Popping a dummy frame involves restoring more than just registers.
1043 dummy_frame_pop does all the work. */
1044 dummy_frame_pop (get_frame_id (this_frame
), inferior_ptid
);
1048 /* Ensure that we have a frame to pop to. */
1049 prev_frame
= get_prev_frame_always (this_frame
);
1052 error (_("Cannot pop the initial frame."));
1054 /* Ignore TAILCALL_FRAME type frames, they were executed already before
1055 entering THISFRAME. */
1056 prev_frame
= skip_tailcall_frames (prev_frame
);
1058 if (prev_frame
== NULL
)
1059 error (_("Cannot find the caller frame."));
1061 /* Make a copy of all the register values unwound from this frame.
1062 Save them in a scratch buffer so that there isn't a race between
1063 trying to extract the old values from the current regcache while
1064 at the same time writing new values into that same cache. */
1065 scratch
= frame_save_as_regcache (prev_frame
);
1066 cleanups
= make_cleanup_regcache_xfree (scratch
);
1068 /* FIXME: cagney/2003-03-16: It should be possible to tell the
1069 target's register cache that it is about to be hit with a burst
1070 register transfer and that the sequence of register writes should
1071 be batched. The pair target_prepare_to_store() and
1072 target_store_registers() kind of suggest this functionality.
1073 Unfortunately, they don't implement it. Their lack of a formal
1074 definition can lead to targets writing back bogus values
1075 (arguably a bug in the target code mind). */
1076 /* Now copy those saved registers into the current regcache.
1077 Here, regcache_cpy() calls regcache_restore(). */
1078 regcache_cpy (get_current_regcache (), scratch
);
1079 do_cleanups (cleanups
);
1081 /* We've made right mess of GDB's local state, just discard
1083 reinit_frame_cache ();
1087 frame_register_unwind (struct frame_info
*frame
, int regnum
,
1088 int *optimizedp
, int *unavailablep
,
1089 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
1090 int *realnump
, gdb_byte
*bufferp
)
1092 struct value
*value
;
1094 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
1095 that the value proper does not need to be fetched. */
1096 gdb_assert (optimizedp
!= NULL
);
1097 gdb_assert (lvalp
!= NULL
);
1098 gdb_assert (addrp
!= NULL
);
1099 gdb_assert (realnump
!= NULL
);
1100 /* gdb_assert (bufferp != NULL); */
1102 value
= frame_unwind_register_value (frame
, regnum
);
1104 gdb_assert (value
!= NULL
);
1106 *optimizedp
= value_optimized_out (value
);
1107 *unavailablep
= !value_entirely_available (value
);
1108 *lvalp
= VALUE_LVAL (value
);
1109 *addrp
= value_address (value
);
1110 if (*lvalp
== lval_register
)
1111 *realnump
= VALUE_REGNUM (value
);
1117 if (!*optimizedp
&& !*unavailablep
)
1118 memcpy (bufferp
, value_contents_all (value
),
1119 TYPE_LENGTH (value_type (value
)));
1121 memset (bufferp
, 0, TYPE_LENGTH (value_type (value
)));
1124 /* Dispose of the new value. This prevents watchpoints from
1125 trying to watch the saved frame pointer. */
1126 release_value (value
);
1131 frame_register (struct frame_info
*frame
, int regnum
,
1132 int *optimizedp
, int *unavailablep
, enum lval_type
*lvalp
,
1133 CORE_ADDR
*addrp
, int *realnump
, gdb_byte
*bufferp
)
1135 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
1136 that the value proper does not need to be fetched. */
1137 gdb_assert (optimizedp
!= NULL
);
1138 gdb_assert (lvalp
!= NULL
);
1139 gdb_assert (addrp
!= NULL
);
1140 gdb_assert (realnump
!= NULL
);
1141 /* gdb_assert (bufferp != NULL); */
1143 /* Obtain the register value by unwinding the register from the next
1144 (more inner frame). */
1145 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
1146 frame_register_unwind (frame
->next
, regnum
, optimizedp
, unavailablep
,
1147 lvalp
, addrp
, realnump
, bufferp
);
1151 frame_unwind_register (struct frame_info
*frame
, int regnum
, gdb_byte
*buf
)
1157 enum lval_type lval
;
1159 frame_register_unwind (frame
, regnum
, &optimized
, &unavailable
,
1160 &lval
, &addr
, &realnum
, buf
);
1163 throw_error (OPTIMIZED_OUT_ERROR
,
1164 _("Register %d was not saved"), regnum
);
1166 throw_error (NOT_AVAILABLE_ERROR
,
1167 _("Register %d is not available"), regnum
);
1171 get_frame_register (struct frame_info
*frame
,
1172 int regnum
, gdb_byte
*buf
)
1174 frame_unwind_register (frame
->next
, regnum
, buf
);
1178 frame_unwind_register_value (struct frame_info
*frame
, int regnum
)
1180 struct gdbarch
*gdbarch
;
1181 struct value
*value
;
1183 gdb_assert (frame
!= NULL
);
1184 gdbarch
= frame_unwind_arch (frame
);
1188 fprintf_unfiltered (gdb_stdlog
,
1189 "{ frame_unwind_register_value "
1190 "(frame=%d,regnum=%d(%s),...) ",
1191 frame
->level
, regnum
,
1192 user_reg_map_regnum_to_name (gdbarch
, regnum
));
1195 /* Find the unwinder. */
1196 if (frame
->unwind
== NULL
)
1197 frame_unwind_find_by_frame (frame
, &frame
->prologue_cache
);
1199 /* Ask this frame to unwind its register. */
1200 value
= frame
->unwind
->prev_register (frame
, &frame
->prologue_cache
, regnum
);
1204 fprintf_unfiltered (gdb_stdlog
, "->");
1205 if (value_optimized_out (value
))
1207 fprintf_unfiltered (gdb_stdlog
, " ");
1208 val_print_optimized_out (value
, gdb_stdlog
);
1212 if (VALUE_LVAL (value
) == lval_register
)
1213 fprintf_unfiltered (gdb_stdlog
, " register=%d",
1214 VALUE_REGNUM (value
));
1215 else if (VALUE_LVAL (value
) == lval_memory
)
1216 fprintf_unfiltered (gdb_stdlog
, " address=%s",
1218 value_address (value
)));
1220 fprintf_unfiltered (gdb_stdlog
, " computed");
1222 if (value_lazy (value
))
1223 fprintf_unfiltered (gdb_stdlog
, " lazy");
1227 const gdb_byte
*buf
= value_contents (value
);
1229 fprintf_unfiltered (gdb_stdlog
, " bytes=");
1230 fprintf_unfiltered (gdb_stdlog
, "[");
1231 for (i
= 0; i
< register_size (gdbarch
, regnum
); i
++)
1232 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1233 fprintf_unfiltered (gdb_stdlog
, "]");
1237 fprintf_unfiltered (gdb_stdlog
, " }\n");
1244 get_frame_register_value (struct frame_info
*frame
, int regnum
)
1246 return frame_unwind_register_value (frame
->next
, regnum
);
1250 frame_unwind_register_signed (struct frame_info
*frame
, int regnum
)
1252 struct gdbarch
*gdbarch
= frame_unwind_arch (frame
);
1253 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1254 int size
= register_size (gdbarch
, regnum
);
1255 struct value
*value
= frame_unwind_register_value (frame
, regnum
);
1257 gdb_assert (value
!= NULL
);
1259 if (value_optimized_out (value
))
1261 throw_error (OPTIMIZED_OUT_ERROR
,
1262 _("Register %d was not saved"), regnum
);
1264 if (!value_entirely_available (value
))
1266 throw_error (NOT_AVAILABLE_ERROR
,
1267 _("Register %d is not available"), regnum
);
1270 LONGEST r
= extract_signed_integer (value_contents_all (value
), size
,
1273 release_value (value
);
1279 get_frame_register_signed (struct frame_info
*frame
, int regnum
)
1281 return frame_unwind_register_signed (frame
->next
, regnum
);
1285 frame_unwind_register_unsigned (struct frame_info
*frame
, int regnum
)
1287 struct gdbarch
*gdbarch
= frame_unwind_arch (frame
);
1288 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1289 int size
= register_size (gdbarch
, regnum
);
1290 struct value
*value
= frame_unwind_register_value (frame
, regnum
);
1292 gdb_assert (value
!= NULL
);
1294 if (value_optimized_out (value
))
1296 throw_error (OPTIMIZED_OUT_ERROR
,
1297 _("Register %d was not saved"), regnum
);
1299 if (!value_entirely_available (value
))
1301 throw_error (NOT_AVAILABLE_ERROR
,
1302 _("Register %d is not available"), regnum
);
1305 ULONGEST r
= extract_unsigned_integer (value_contents_all (value
), size
,
1308 release_value (value
);
1314 get_frame_register_unsigned (struct frame_info
*frame
, int regnum
)
1316 return frame_unwind_register_unsigned (frame
->next
, regnum
);
1320 read_frame_register_unsigned (struct frame_info
*frame
, int regnum
,
1323 struct value
*regval
= get_frame_register_value (frame
, regnum
);
1325 if (!value_optimized_out (regval
)
1326 && value_entirely_available (regval
))
1328 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1329 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1330 int size
= register_size (gdbarch
, VALUE_REGNUM (regval
));
1332 *val
= extract_unsigned_integer (value_contents (regval
), size
, byte_order
);
1340 put_frame_register (struct frame_info
*frame
, int regnum
,
1341 const gdb_byte
*buf
)
1343 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1347 enum lval_type lval
;
1350 frame_register (frame
, regnum
, &optim
, &unavail
,
1351 &lval
, &addr
, &realnum
, NULL
);
1353 error (_("Attempt to assign to a register that was not saved."));
1358 write_memory (addr
, buf
, register_size (gdbarch
, regnum
));
1362 regcache_cooked_write (get_current_regcache (), realnum
, buf
);
1365 error (_("Attempt to assign to an unmodifiable value."));
1369 /* This function is deprecated. Use get_frame_register_value instead,
1370 which provides more accurate information.
1372 Find and return the value of REGNUM for the specified stack frame.
1373 The number of bytes copied is REGISTER_SIZE (REGNUM).
1375 Returns 0 if the register value could not be found. */
1378 deprecated_frame_register_read (struct frame_info
*frame
, int regnum
,
1383 enum lval_type lval
;
1387 frame_register (frame
, regnum
, &optimized
, &unavailable
,
1388 &lval
, &addr
, &realnum
, myaddr
);
1390 return !optimized
&& !unavailable
;
1394 get_frame_register_bytes (struct frame_info
*frame
, int regnum
,
1395 CORE_ADDR offset
, int len
, gdb_byte
*myaddr
,
1396 int *optimizedp
, int *unavailablep
)
1398 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1403 /* Skip registers wholly inside of OFFSET. */
1404 while (offset
>= register_size (gdbarch
, regnum
))
1406 offset
-= register_size (gdbarch
, regnum
);
1410 /* Ensure that we will not read beyond the end of the register file.
1411 This can only ever happen if the debug information is bad. */
1413 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1414 for (i
= regnum
; i
< numregs
; i
++)
1416 int thissize
= register_size (gdbarch
, i
);
1419 break; /* This register is not available on this architecture. */
1420 maxsize
+= thissize
;
1423 error (_("Bad debug information detected: "
1424 "Attempt to read %d bytes from registers."), len
);
1426 /* Copy the data. */
1429 int curr_len
= register_size (gdbarch
, regnum
) - offset
;
1434 if (curr_len
== register_size (gdbarch
, regnum
))
1436 enum lval_type lval
;
1440 frame_register (frame
, regnum
, optimizedp
, unavailablep
,
1441 &lval
, &addr
, &realnum
, myaddr
);
1442 if (*optimizedp
|| *unavailablep
)
1447 struct value
*value
= frame_unwind_register_value (frame
->next
,
1449 gdb_assert (value
!= NULL
);
1450 *optimizedp
= value_optimized_out (value
);
1451 *unavailablep
= !value_entirely_available (value
);
1453 if (*optimizedp
|| *unavailablep
)
1455 release_value (value
);
1459 memcpy (myaddr
, value_contents_all (value
) + offset
, curr_len
);
1460 release_value (value
);
1476 put_frame_register_bytes (struct frame_info
*frame
, int regnum
,
1477 CORE_ADDR offset
, int len
, const gdb_byte
*myaddr
)
1479 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1481 /* Skip registers wholly inside of OFFSET. */
1482 while (offset
>= register_size (gdbarch
, regnum
))
1484 offset
-= register_size (gdbarch
, regnum
);
1488 /* Copy the data. */
1491 int curr_len
= register_size (gdbarch
, regnum
) - offset
;
1496 if (curr_len
== register_size (gdbarch
, regnum
))
1498 put_frame_register (frame
, regnum
, myaddr
);
1502 struct value
*value
= frame_unwind_register_value (frame
->next
,
1504 gdb_assert (value
!= NULL
);
1506 memcpy ((char *) value_contents_writeable (value
) + offset
, myaddr
,
1508 put_frame_register (frame
, regnum
, value_contents_raw (value
));
1509 release_value (value
);
1520 /* Create a sentinel frame. */
1522 static struct frame_info
*
1523 create_sentinel_frame (struct program_space
*pspace
, struct regcache
*regcache
)
1525 struct frame_info
*frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1528 frame
->pspace
= pspace
;
1529 frame
->aspace
= get_regcache_aspace (regcache
);
1530 /* Explicitly initialize the sentinel frame's cache. Provide it
1531 with the underlying regcache. In the future additional
1532 information, such as the frame's thread will be added. */
1533 frame
->prologue_cache
= sentinel_frame_cache (regcache
);
1534 /* For the moment there is only one sentinel frame implementation. */
1535 frame
->unwind
= &sentinel_frame_unwind
;
1536 /* Link this frame back to itself. The frame is self referential
1537 (the unwound PC is the same as the pc), so make it so. */
1538 frame
->next
= frame
;
1539 /* The sentinel frame has a special ID. */
1540 frame
->this_id
.p
= 1;
1541 frame
->this_id
.value
= sentinel_frame_id
;
1544 fprintf_unfiltered (gdb_stdlog
, "{ create_sentinel_frame (...) -> ");
1545 fprint_frame (gdb_stdlog
, frame
);
1546 fprintf_unfiltered (gdb_stdlog
, " }\n");
1551 /* Cache for frame addresses already read by gdb. Valid only while
1552 inferior is stopped. Control variables for the frame cache should
1553 be local to this module. */
1555 static struct obstack frame_cache_obstack
;
1558 frame_obstack_zalloc (unsigned long size
)
1560 void *data
= obstack_alloc (&frame_cache_obstack
, size
);
1562 memset (data
, 0, size
);
1566 static struct frame_info
*get_prev_frame_always_1 (struct frame_info
*this_frame
);
1569 get_current_frame (void)
1571 struct frame_info
*current_frame
;
1573 /* First check, and report, the lack of registers. Having GDB
1574 report "No stack!" or "No memory" when the target doesn't even
1575 have registers is very confusing. Besides, "printcmd.exp"
1576 explicitly checks that ``print $pc'' with no registers prints "No
1578 if (!target_has_registers
)
1579 error (_("No registers."));
1580 if (!target_has_stack
)
1581 error (_("No stack."));
1582 if (!target_has_memory
)
1583 error (_("No memory."));
1584 /* Traceframes are effectively a substitute for the live inferior. */
1585 if (get_traceframe_number () < 0)
1586 validate_registers_access ();
1588 if (sentinel_frame
== NULL
)
1590 create_sentinel_frame (current_program_space
, get_current_regcache ());
1592 /* Set the current frame before computing the frame id, to avoid
1593 recursion inside compute_frame_id, in case the frame's
1594 unwinder decides to do a symbol lookup (which depends on the
1595 selected frame's block).
1597 This call must always succeed. In particular, nothing inside
1598 get_prev_frame_always_1 should try to unwind from the
1599 sentinel frame, because that could fail/throw, and we always
1600 want to leave with the current frame created and linked in --
1601 we should never end up with the sentinel frame as outermost
1603 current_frame
= get_prev_frame_always_1 (sentinel_frame
);
1604 gdb_assert (current_frame
!= NULL
);
1606 return current_frame
;
1609 /* The "selected" stack frame is used by default for local and arg
1610 access. May be zero, for no selected frame. */
1612 static struct frame_info
*selected_frame
;
1615 has_stack_frames (void)
1617 if (!target_has_registers
|| !target_has_stack
|| !target_has_memory
)
1620 /* Traceframes are effectively a substitute for the live inferior. */
1621 if (get_traceframe_number () < 0)
1623 /* No current inferior, no frame. */
1624 if (ptid_equal (inferior_ptid
, null_ptid
))
1627 /* Don't try to read from a dead thread. */
1628 if (is_exited (inferior_ptid
))
1631 /* ... or from a spinning thread. */
1632 if (is_executing (inferior_ptid
))
1639 /* Return the selected frame. Always non-NULL (unless there isn't an
1640 inferior sufficient for creating a frame) in which case an error is
1644 get_selected_frame (const char *message
)
1646 if (selected_frame
== NULL
)
1648 if (message
!= NULL
&& !has_stack_frames ())
1649 error (("%s"), message
);
1650 /* Hey! Don't trust this. It should really be re-finding the
1651 last selected frame of the currently selected thread. This,
1652 though, is better than nothing. */
1653 select_frame (get_current_frame ());
1655 /* There is always a frame. */
1656 gdb_assert (selected_frame
!= NULL
);
1657 return selected_frame
;
1660 /* If there is a selected frame, return it. Otherwise, return NULL. */
1663 get_selected_frame_if_set (void)
1665 return selected_frame
;
1668 /* This is a variant of get_selected_frame() which can be called when
1669 the inferior does not have a frame; in that case it will return
1670 NULL instead of calling error(). */
1673 deprecated_safe_get_selected_frame (void)
1675 if (!has_stack_frames ())
1677 return get_selected_frame (NULL
);
1680 /* Select frame FI (or NULL - to invalidate the current frame). */
1683 select_frame (struct frame_info
*fi
)
1685 selected_frame
= fi
;
1686 /* NOTE: cagney/2002-05-04: FI can be NULL. This occurs when the
1687 frame is being invalidated. */
1689 /* FIXME: kseitz/2002-08-28: It would be nice to call
1690 selected_frame_level_changed_event() right here, but due to limitations
1691 in the current interfaces, we would end up flooding UIs with events
1692 because select_frame() is used extensively internally.
1694 Once we have frame-parameterized frame (and frame-related) commands,
1695 the event notification can be moved here, since this function will only
1696 be called when the user's selected frame is being changed. */
1698 /* Ensure that symbols for this frame are read in. Also, determine the
1699 source language of this frame, and switch to it if desired. */
1704 /* We retrieve the frame's symtab by using the frame PC.
1705 However we cannot use the frame PC as-is, because it usually
1706 points to the instruction following the "call", which is
1707 sometimes the first instruction of another function. So we
1708 rely on get_frame_address_in_block() which provides us with a
1709 PC which is guaranteed to be inside the frame's code
1711 if (get_frame_address_in_block_if_available (fi
, &pc
))
1713 struct compunit_symtab
*cust
= find_pc_compunit_symtab (pc
);
1716 && compunit_language (cust
) != current_language
->la_language
1717 && compunit_language (cust
) != language_unknown
1718 && language_mode
== language_mode_auto
)
1719 set_language (compunit_language (cust
));
1726 create_test_frame (struct regcache
*regcache
)
1728 struct frame_info
*this_frame
= XCNEW (struct frame_info
);
1730 sentinel_frame
= create_sentinel_frame (NULL
, regcache
);
1731 sentinel_frame
->prev
= this_frame
;
1732 sentinel_frame
->prev_p
= 1;;
1733 this_frame
->prev_arch
.p
= 1;
1734 this_frame
->prev_arch
.arch
= get_regcache_arch (regcache
);
1735 this_frame
->next
= sentinel_frame
;
1741 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
1742 Always returns a non-NULL value. */
1745 create_new_frame (CORE_ADDR addr
, CORE_ADDR pc
)
1747 struct frame_info
*fi
;
1751 fprintf_unfiltered (gdb_stdlog
,
1752 "{ create_new_frame (addr=%s, pc=%s) ",
1753 hex_string (addr
), hex_string (pc
));
1756 fi
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1758 fi
->next
= create_sentinel_frame (current_program_space
,
1759 get_current_regcache ());
1761 /* Set/update this frame's cached PC value, found in the next frame.
1762 Do this before looking for this frame's unwinder. A sniffer is
1763 very likely to read this, and the corresponding unwinder is
1764 entitled to rely that the PC doesn't magically change. */
1765 fi
->next
->prev_pc
.value
= pc
;
1766 fi
->next
->prev_pc
.status
= CC_VALUE
;
1768 /* We currently assume that frame chain's can't cross spaces. */
1769 fi
->pspace
= fi
->next
->pspace
;
1770 fi
->aspace
= fi
->next
->aspace
;
1772 /* Select/initialize both the unwind function and the frame's type
1774 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
1777 fi
->this_id
.value
= frame_id_build (addr
, pc
);
1781 fprintf_unfiltered (gdb_stdlog
, "-> ");
1782 fprint_frame (gdb_stdlog
, fi
);
1783 fprintf_unfiltered (gdb_stdlog
, " }\n");
1789 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
1790 innermost frame). Be careful to not fall off the bottom of the
1791 frame chain and onto the sentinel frame. */
1794 get_next_frame (struct frame_info
*this_frame
)
1796 if (this_frame
->level
> 0)
1797 return this_frame
->next
;
1802 /* Return the frame that THIS_FRAME calls. If THIS_FRAME is the
1803 innermost (i.e. current) frame, return the sentinel frame. Thus,
1804 unlike get_next_frame(), NULL will never be returned. */
1807 get_next_frame_sentinel_okay (struct frame_info
*this_frame
)
1809 gdb_assert (this_frame
!= NULL
);
1811 /* Note that, due to the manner in which the sentinel frame is
1812 constructed, this_frame->next still works even when this_frame
1813 is the sentinel frame. But we disallow it here anyway because
1814 calling get_next_frame_sentinel_okay() on the sentinel frame
1815 is likely a coding error. */
1816 gdb_assert (this_frame
!= sentinel_frame
);
1818 return this_frame
->next
;
1821 /* Observer for the target_changed event. */
1824 frame_observer_target_changed (struct target_ops
*target
)
1826 reinit_frame_cache ();
1829 /* Flush the entire frame cache. */
1832 reinit_frame_cache (void)
1834 struct frame_info
*fi
;
1836 /* Tear down all frame caches. */
1837 for (fi
= sentinel_frame
; fi
!= NULL
; fi
= fi
->prev
)
1839 if (fi
->prologue_cache
&& fi
->unwind
->dealloc_cache
)
1840 fi
->unwind
->dealloc_cache (fi
, fi
->prologue_cache
);
1841 if (fi
->base_cache
&& fi
->base
->unwind
->dealloc_cache
)
1842 fi
->base
->unwind
->dealloc_cache (fi
, fi
->base_cache
);
1845 /* Since we can't really be sure what the first object allocated was. */
1846 obstack_free (&frame_cache_obstack
, 0);
1847 obstack_init (&frame_cache_obstack
);
1849 if (sentinel_frame
!= NULL
)
1850 annotate_frames_invalid ();
1852 sentinel_frame
= NULL
; /* Invalidate cache */
1853 select_frame (NULL
);
1854 frame_stash_invalidate ();
1856 fprintf_unfiltered (gdb_stdlog
, "{ reinit_frame_cache () }\n");
1859 /* Find where a register is saved (in memory or another register).
1860 The result of frame_register_unwind is just where it is saved
1861 relative to this particular frame. */
1864 frame_register_unwind_location (struct frame_info
*this_frame
, int regnum
,
1865 int *optimizedp
, enum lval_type
*lvalp
,
1866 CORE_ADDR
*addrp
, int *realnump
)
1868 gdb_assert (this_frame
== NULL
|| this_frame
->level
>= 0);
1870 while (this_frame
!= NULL
)
1874 frame_register_unwind (this_frame
, regnum
, optimizedp
, &unavailable
,
1875 lvalp
, addrp
, realnump
, NULL
);
1880 if (*lvalp
!= lval_register
)
1884 this_frame
= get_next_frame (this_frame
);
1888 /* Called during frame unwinding to remove a previous frame pointer from a
1889 frame passed in ARG. */
1892 remove_prev_frame (void *arg
)
1894 struct frame_info
*this_frame
, *prev_frame
;
1896 this_frame
= (struct frame_info
*) arg
;
1897 prev_frame
= this_frame
->prev
;
1898 gdb_assert (prev_frame
!= NULL
);
1900 prev_frame
->next
= NULL
;
1901 this_frame
->prev
= NULL
;
1904 /* Get the previous raw frame, and check that it is not identical to
1905 same other frame frame already in the chain. If it is, there is
1906 most likely a stack cycle, so we discard it, and mark THIS_FRAME as
1907 outermost, with UNWIND_SAME_ID stop reason. Unlike the other
1908 validity tests, that compare THIS_FRAME and the next frame, we do
1909 this right after creating the previous frame, to avoid ever ending
1910 up with two frames with the same id in the frame chain. */
1912 static struct frame_info
*
1913 get_prev_frame_if_no_cycle (struct frame_info
*this_frame
)
1915 struct frame_info
*prev_frame
;
1916 struct cleanup
*prev_frame_cleanup
;
1918 prev_frame
= get_prev_frame_raw (this_frame
);
1920 /* Don't compute the frame id of the current frame yet. Unwinding
1921 the sentinel frame can fail (e.g., if the thread is gone and we
1922 can't thus read its registers). If we let the cycle detection
1923 code below try to compute a frame ID, then an error thrown from
1924 within the frame ID computation would result in the sentinel
1925 frame as outermost frame, which is bogus. Instead, we'll compute
1926 the current frame's ID lazily in get_frame_id. Note that there's
1927 no point in doing cycle detection when there's only one frame, so
1928 nothing is lost here. */
1929 if (prev_frame
->level
== 0)
1932 /* The cleanup will remove the previous frame that get_prev_frame_raw
1933 linked onto THIS_FRAME. */
1934 prev_frame_cleanup
= make_cleanup (remove_prev_frame
, this_frame
);
1936 compute_frame_id (prev_frame
);
1937 if (!frame_stash_add (prev_frame
))
1939 /* Another frame with the same id was already in the stash. We just
1940 detected a cycle. */
1943 fprintf_unfiltered (gdb_stdlog
, "-> ");
1944 fprint_frame (gdb_stdlog
, NULL
);
1945 fprintf_unfiltered (gdb_stdlog
, " // this frame has same ID }\n");
1947 this_frame
->stop_reason
= UNWIND_SAME_ID
;
1949 prev_frame
->next
= NULL
;
1950 this_frame
->prev
= NULL
;
1954 discard_cleanups (prev_frame_cleanup
);
1958 /* Helper function for get_prev_frame_always, this is called inside a
1959 TRY_CATCH block. Return the frame that called THIS_FRAME or NULL if
1960 there is no such frame. This may throw an exception. */
1962 static struct frame_info
*
1963 get_prev_frame_always_1 (struct frame_info
*this_frame
)
1965 struct gdbarch
*gdbarch
;
1967 gdb_assert (this_frame
!= NULL
);
1968 gdbarch
= get_frame_arch (this_frame
);
1972 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame_always (this_frame=");
1973 if (this_frame
!= NULL
)
1974 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1976 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1977 fprintf_unfiltered (gdb_stdlog
, ") ");
1980 /* Only try to do the unwind once. */
1981 if (this_frame
->prev_p
)
1985 fprintf_unfiltered (gdb_stdlog
, "-> ");
1986 fprint_frame (gdb_stdlog
, this_frame
->prev
);
1987 fprintf_unfiltered (gdb_stdlog
, " // cached \n");
1989 return this_frame
->prev
;
1992 /* If the frame unwinder hasn't been selected yet, we must do so
1993 before setting prev_p; otherwise the check for misbehaved
1994 sniffers will think that this frame's sniffer tried to unwind
1995 further (see frame_cleanup_after_sniffer). */
1996 if (this_frame
->unwind
== NULL
)
1997 frame_unwind_find_by_frame (this_frame
, &this_frame
->prologue_cache
);
1999 this_frame
->prev_p
= 1;
2000 this_frame
->stop_reason
= UNWIND_NO_REASON
;
2002 /* If we are unwinding from an inline frame, all of the below tests
2003 were already performed when we unwound from the next non-inline
2004 frame. We must skip them, since we can not get THIS_FRAME's ID
2005 until we have unwound all the way down to the previous non-inline
2007 if (get_frame_type (this_frame
) == INLINE_FRAME
)
2008 return get_prev_frame_if_no_cycle (this_frame
);
2010 /* Check that this frame is unwindable. If it isn't, don't try to
2011 unwind to the prev frame. */
2012 this_frame
->stop_reason
2013 = this_frame
->unwind
->stop_reason (this_frame
,
2014 &this_frame
->prologue_cache
);
2016 if (this_frame
->stop_reason
!= UNWIND_NO_REASON
)
2020 enum unwind_stop_reason reason
= this_frame
->stop_reason
;
2022 fprintf_unfiltered (gdb_stdlog
, "-> ");
2023 fprint_frame (gdb_stdlog
, NULL
);
2024 fprintf_unfiltered (gdb_stdlog
, " // %s }\n",
2025 frame_stop_reason_symbol_string (reason
));
2030 /* Check that this frame's ID isn't inner to (younger, below, next)
2031 the next frame. This happens when a frame unwind goes backwards.
2032 This check is valid only if this frame and the next frame are NORMAL.
2033 See the comment at frame_id_inner for details. */
2034 if (get_frame_type (this_frame
) == NORMAL_FRAME
2035 && this_frame
->next
->unwind
->type
== NORMAL_FRAME
2036 && frame_id_inner (get_frame_arch (this_frame
->next
),
2037 get_frame_id (this_frame
),
2038 get_frame_id (this_frame
->next
)))
2040 CORE_ADDR this_pc_in_block
;
2041 struct minimal_symbol
*morestack_msym
;
2042 const char *morestack_name
= NULL
;
2044 /* gcc -fsplit-stack __morestack can continue the stack anywhere. */
2045 this_pc_in_block
= get_frame_address_in_block (this_frame
);
2046 morestack_msym
= lookup_minimal_symbol_by_pc (this_pc_in_block
).minsym
;
2048 morestack_name
= MSYMBOL_LINKAGE_NAME (morestack_msym
);
2049 if (!morestack_name
|| strcmp (morestack_name
, "__morestack") != 0)
2053 fprintf_unfiltered (gdb_stdlog
, "-> ");
2054 fprint_frame (gdb_stdlog
, NULL
);
2055 fprintf_unfiltered (gdb_stdlog
,
2056 " // this frame ID is inner }\n");
2058 this_frame
->stop_reason
= UNWIND_INNER_ID
;
2063 /* Check that this and the next frame do not unwind the PC register
2064 to the same memory location. If they do, then even though they
2065 have different frame IDs, the new frame will be bogus; two
2066 functions can't share a register save slot for the PC. This can
2067 happen when the prologue analyzer finds a stack adjustment, but
2070 This check does assume that the "PC register" is roughly a
2071 traditional PC, even if the gdbarch_unwind_pc method adjusts
2072 it (we do not rely on the value, only on the unwound PC being
2073 dependent on this value). A potential improvement would be
2074 to have the frame prev_pc method and the gdbarch unwind_pc
2075 method set the same lval and location information as
2076 frame_register_unwind. */
2077 if (this_frame
->level
> 0
2078 && gdbarch_pc_regnum (gdbarch
) >= 0
2079 && get_frame_type (this_frame
) == NORMAL_FRAME
2080 && (get_frame_type (this_frame
->next
) == NORMAL_FRAME
2081 || get_frame_type (this_frame
->next
) == INLINE_FRAME
))
2083 int optimized
, realnum
, nrealnum
;
2084 enum lval_type lval
, nlval
;
2085 CORE_ADDR addr
, naddr
;
2087 frame_register_unwind_location (this_frame
,
2088 gdbarch_pc_regnum (gdbarch
),
2089 &optimized
, &lval
, &addr
, &realnum
);
2090 frame_register_unwind_location (get_next_frame (this_frame
),
2091 gdbarch_pc_regnum (gdbarch
),
2092 &optimized
, &nlval
, &naddr
, &nrealnum
);
2094 if ((lval
== lval_memory
&& lval
== nlval
&& addr
== naddr
)
2095 || (lval
== lval_register
&& lval
== nlval
&& realnum
== nrealnum
))
2099 fprintf_unfiltered (gdb_stdlog
, "-> ");
2100 fprint_frame (gdb_stdlog
, NULL
);
2101 fprintf_unfiltered (gdb_stdlog
, " // no saved PC }\n");
2104 this_frame
->stop_reason
= UNWIND_NO_SAVED_PC
;
2105 this_frame
->prev
= NULL
;
2110 return get_prev_frame_if_no_cycle (this_frame
);
2113 /* Return a "struct frame_info" corresponding to the frame that called
2114 THIS_FRAME. Returns NULL if there is no such frame.
2116 Unlike get_prev_frame, this function always tries to unwind the
2120 get_prev_frame_always (struct frame_info
*this_frame
)
2122 struct frame_info
*prev_frame
= NULL
;
2126 prev_frame
= get_prev_frame_always_1 (this_frame
);
2128 CATCH (ex
, RETURN_MASK_ERROR
)
2130 if (ex
.error
== MEMORY_ERROR
)
2132 this_frame
->stop_reason
= UNWIND_MEMORY_ERROR
;
2133 if (ex
.message
!= NULL
)
2138 /* The error needs to live as long as the frame does.
2139 Allocate using stack local STOP_STRING then assign the
2140 pointer to the frame, this allows the STOP_STRING on the
2141 frame to be of type 'const char *'. */
2142 size
= strlen (ex
.message
) + 1;
2143 stop_string
= (char *) frame_obstack_zalloc (size
);
2144 memcpy (stop_string
, ex
.message
, size
);
2145 this_frame
->stop_string
= stop_string
;
2150 throw_exception (ex
);
2157 /* Construct a new "struct frame_info" and link it previous to
2160 static struct frame_info
*
2161 get_prev_frame_raw (struct frame_info
*this_frame
)
2163 struct frame_info
*prev_frame
;
2165 /* Allocate the new frame but do not wire it in to the frame chain.
2166 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
2167 frame->next to pull some fancy tricks (of course such code is, by
2168 definition, recursive). Try to prevent it.
2170 There is no reason to worry about memory leaks, should the
2171 remainder of the function fail. The allocated memory will be
2172 quickly reclaimed when the frame cache is flushed, and the `we've
2173 been here before' check above will stop repeated memory
2174 allocation calls. */
2175 prev_frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
2176 prev_frame
->level
= this_frame
->level
+ 1;
2178 /* For now, assume we don't have frame chains crossing address
2180 prev_frame
->pspace
= this_frame
->pspace
;
2181 prev_frame
->aspace
= this_frame
->aspace
;
2183 /* Don't yet compute ->unwind (and hence ->type). It is computed
2184 on-demand in get_frame_type, frame_register_unwind, and
2187 /* Don't yet compute the frame's ID. It is computed on-demand by
2190 /* The unwound frame ID is validate at the start of this function,
2191 as part of the logic to decide if that frame should be further
2192 unwound, and not here while the prev frame is being created.
2193 Doing this makes it possible for the user to examine a frame that
2194 has an invalid frame ID.
2196 Some very old VAX code noted: [...] For the sake of argument,
2197 suppose that the stack is somewhat trashed (which is one reason
2198 that "info frame" exists). So, return 0 (indicating we don't
2199 know the address of the arglist) if we don't know what frame this
2203 this_frame
->prev
= prev_frame
;
2204 prev_frame
->next
= this_frame
;
2208 fprintf_unfiltered (gdb_stdlog
, "-> ");
2209 fprint_frame (gdb_stdlog
, prev_frame
);
2210 fprintf_unfiltered (gdb_stdlog
, " }\n");
2216 /* Debug routine to print a NULL frame being returned. */
2219 frame_debug_got_null_frame (struct frame_info
*this_frame
,
2224 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame (this_frame=");
2225 if (this_frame
!= NULL
)
2226 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
2228 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
2229 fprintf_unfiltered (gdb_stdlog
, ") -> // %s}\n", reason
);
2233 /* Is this (non-sentinel) frame in the "main"() function? */
2236 inside_main_func (struct frame_info
*this_frame
)
2238 struct bound_minimal_symbol msymbol
;
2241 if (symfile_objfile
== 0)
2243 msymbol
= lookup_minimal_symbol (main_name (), NULL
, symfile_objfile
);
2244 if (msymbol
.minsym
== NULL
)
2246 /* Make certain that the code, and not descriptor, address is
2248 maddr
= gdbarch_convert_from_func_ptr_addr (get_frame_arch (this_frame
),
2249 BMSYMBOL_VALUE_ADDRESS (msymbol
),
2251 return maddr
== get_frame_func (this_frame
);
2254 /* Test whether THIS_FRAME is inside the process entry point function. */
2257 inside_entry_func (struct frame_info
*this_frame
)
2259 CORE_ADDR entry_point
;
2261 if (!entry_point_address_query (&entry_point
))
2264 return get_frame_func (this_frame
) == entry_point
;
2267 /* Return a structure containing various interesting information about
2268 the frame that called THIS_FRAME. Returns NULL if there is entier
2269 no such frame or the frame fails any of a set of target-independent
2270 condition that should terminate the frame chain (e.g., as unwinding
2273 This function should not contain target-dependent tests, such as
2274 checking whether the program-counter is zero. */
2277 get_prev_frame (struct frame_info
*this_frame
)
2282 /* There is always a frame. If this assertion fails, suspect that
2283 something should be calling get_selected_frame() or
2284 get_current_frame(). */
2285 gdb_assert (this_frame
!= NULL
);
2287 /* If this_frame is the current frame, then compute and stash
2288 its frame id prior to fetching and computing the frame id of the
2289 previous frame. Otherwise, the cycle detection code in
2290 get_prev_frame_if_no_cycle() will not work correctly. When
2291 get_frame_id() is called later on, an assertion error will
2292 be triggered in the event of a cycle between the current
2293 frame and its previous frame. */
2294 if (this_frame
->level
== 0)
2295 get_frame_id (this_frame
);
2297 frame_pc_p
= get_frame_pc_if_available (this_frame
, &frame_pc
);
2299 /* tausq/2004-12-07: Dummy frames are skipped because it doesn't make much
2300 sense to stop unwinding at a dummy frame. One place where a dummy
2301 frame may have an address "inside_main_func" is on HPUX. On HPUX, the
2302 pcsqh register (space register for the instruction at the head of the
2303 instruction queue) cannot be written directly; the only way to set it
2304 is to branch to code that is in the target space. In order to implement
2305 frame dummies on HPUX, the called function is made to jump back to where
2306 the inferior was when the user function was called. If gdb was inside
2307 the main function when we created the dummy frame, the dummy frame will
2308 point inside the main function. */
2309 if (this_frame
->level
>= 0
2310 && get_frame_type (this_frame
) == NORMAL_FRAME
2311 && !backtrace_past_main
2313 && inside_main_func (this_frame
))
2314 /* Don't unwind past main(). Note, this is done _before_ the
2315 frame has been marked as previously unwound. That way if the
2316 user later decides to enable unwinds past main(), that will
2317 automatically happen. */
2319 frame_debug_got_null_frame (this_frame
, "inside main func");
2323 /* If the user's backtrace limit has been exceeded, stop. We must
2324 add two to the current level; one of those accounts for backtrace_limit
2325 being 1-based and the level being 0-based, and the other accounts for
2326 the level of the new frame instead of the level of the current
2328 if (this_frame
->level
+ 2 > backtrace_limit
)
2330 frame_debug_got_null_frame (this_frame
, "backtrace limit exceeded");
2334 /* If we're already inside the entry function for the main objfile,
2335 then it isn't valid. Don't apply this test to a dummy frame -
2336 dummy frame PCs typically land in the entry func. Don't apply
2337 this test to the sentinel frame. Sentinel frames should always
2338 be allowed to unwind. */
2339 /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() -
2340 wasn't checking for "main" in the minimal symbols. With that
2341 fixed asm-source tests now stop in "main" instead of halting the
2342 backtrace in weird and wonderful ways somewhere inside the entry
2343 file. Suspect that tests for inside the entry file/func were
2344 added to work around that (now fixed) case. */
2345 /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
2346 suggested having the inside_entry_func test use the
2347 inside_main_func() msymbol trick (along with entry_point_address()
2348 I guess) to determine the address range of the start function.
2349 That should provide a far better stopper than the current
2351 /* NOTE: tausq/2004-10-09: this is needed if, for example, the compiler
2352 applied tail-call optimizations to main so that a function called
2353 from main returns directly to the caller of main. Since we don't
2354 stop at main, we should at least stop at the entry point of the
2356 if (this_frame
->level
>= 0
2357 && get_frame_type (this_frame
) == NORMAL_FRAME
2358 && !backtrace_past_entry
2360 && inside_entry_func (this_frame
))
2362 frame_debug_got_null_frame (this_frame
, "inside entry func");
2366 /* Assume that the only way to get a zero PC is through something
2367 like a SIGSEGV or a dummy frame, and hence that NORMAL frames
2368 will never unwind a zero PC. */
2369 if (this_frame
->level
> 0
2370 && (get_frame_type (this_frame
) == NORMAL_FRAME
2371 || get_frame_type (this_frame
) == INLINE_FRAME
)
2372 && get_frame_type (get_next_frame (this_frame
)) == NORMAL_FRAME
2373 && frame_pc_p
&& frame_pc
== 0)
2375 frame_debug_got_null_frame (this_frame
, "zero PC");
2379 return get_prev_frame_always (this_frame
);
2383 get_prev_frame_id_by_id (struct frame_id id
)
2385 struct frame_id prev_id
;
2386 struct frame_info
*frame
;
2388 frame
= frame_find_by_id (id
);
2391 prev_id
= get_frame_id (get_prev_frame (frame
));
2393 prev_id
= null_frame_id
;
2399 get_frame_pc (struct frame_info
*frame
)
2401 gdb_assert (frame
->next
!= NULL
);
2402 return frame_unwind_pc (frame
->next
);
2406 get_frame_pc_if_available (struct frame_info
*frame
, CORE_ADDR
*pc
)
2409 gdb_assert (frame
->next
!= NULL
);
2413 *pc
= frame_unwind_pc (frame
->next
);
2415 CATCH (ex
, RETURN_MASK_ERROR
)
2417 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2420 throw_exception (ex
);
2427 /* Return an address that falls within THIS_FRAME's code block. */
2430 get_frame_address_in_block (struct frame_info
*this_frame
)
2432 /* A draft address. */
2433 CORE_ADDR pc
= get_frame_pc (this_frame
);
2435 struct frame_info
*next_frame
= this_frame
->next
;
2437 /* Calling get_frame_pc returns the resume address for THIS_FRAME.
2438 Normally the resume address is inside the body of the function
2439 associated with THIS_FRAME, but there is a special case: when
2440 calling a function which the compiler knows will never return
2441 (for instance abort), the call may be the very last instruction
2442 in the calling function. The resume address will point after the
2443 call and may be at the beginning of a different function
2446 If THIS_FRAME is a signal frame or dummy frame, then we should
2447 not adjust the unwound PC. For a dummy frame, GDB pushed the
2448 resume address manually onto the stack. For a signal frame, the
2449 OS may have pushed the resume address manually and invoked the
2450 handler (e.g. GNU/Linux), or invoked the trampoline which called
2451 the signal handler - but in either case the signal handler is
2452 expected to return to the trampoline. So in both of these
2453 cases we know that the resume address is executable and
2454 related. So we only need to adjust the PC if THIS_FRAME
2455 is a normal function.
2457 If the program has been interrupted while THIS_FRAME is current,
2458 then clearly the resume address is inside the associated
2459 function. There are three kinds of interruption: debugger stop
2460 (next frame will be SENTINEL_FRAME), operating system
2461 signal or exception (next frame will be SIGTRAMP_FRAME),
2462 or debugger-induced function call (next frame will be
2463 DUMMY_FRAME). So we only need to adjust the PC if
2464 NEXT_FRAME is a normal function.
2466 We check the type of NEXT_FRAME first, since it is already
2467 known; frame type is determined by the unwinder, and since
2468 we have THIS_FRAME we've already selected an unwinder for
2471 If the next frame is inlined, we need to keep going until we find
2472 the real function - for instance, if a signal handler is invoked
2473 while in an inlined function, then the code address of the
2474 "calling" normal function should not be adjusted either. */
2476 while (get_frame_type (next_frame
) == INLINE_FRAME
)
2477 next_frame
= next_frame
->next
;
2479 if ((get_frame_type (next_frame
) == NORMAL_FRAME
2480 || get_frame_type (next_frame
) == TAILCALL_FRAME
)
2481 && (get_frame_type (this_frame
) == NORMAL_FRAME
2482 || get_frame_type (this_frame
) == TAILCALL_FRAME
2483 || get_frame_type (this_frame
) == INLINE_FRAME
))
2490 get_frame_address_in_block_if_available (struct frame_info
*this_frame
,
2496 *pc
= get_frame_address_in_block (this_frame
);
2498 CATCH (ex
, RETURN_MASK_ERROR
)
2500 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2502 throw_exception (ex
);
2510 find_frame_sal (struct frame_info
*frame
, struct symtab_and_line
*sal
)
2512 struct frame_info
*next_frame
;
2516 /* If the next frame represents an inlined function call, this frame's
2517 sal is the "call site" of that inlined function, which can not
2518 be inferred from get_frame_pc. */
2519 next_frame
= get_next_frame (frame
);
2520 if (frame_inlined_callees (frame
) > 0)
2525 sym
= get_frame_function (next_frame
);
2527 sym
= inline_skipped_symbol (inferior_ptid
);
2529 /* If frame is inline, it certainly has symbols. */
2532 if (SYMBOL_LINE (sym
) != 0)
2534 sal
->symtab
= symbol_symtab (sym
);
2535 sal
->line
= SYMBOL_LINE (sym
);
2538 /* If the symbol does not have a location, we don't know where
2539 the call site is. Do not pretend to. This is jarring, but
2540 we can't do much better. */
2541 sal
->pc
= get_frame_pc (frame
);
2543 sal
->pspace
= get_frame_program_space (frame
);
2548 /* If FRAME is not the innermost frame, that normally means that
2549 FRAME->pc points at the return instruction (which is *after* the
2550 call instruction), and we want to get the line containing the
2551 call (because the call is where the user thinks the program is).
2552 However, if the next frame is either a SIGTRAMP_FRAME or a
2553 DUMMY_FRAME, then the next frame will contain a saved interrupt
2554 PC and such a PC indicates the current (rather than next)
2555 instruction/line, consequently, for such cases, want to get the
2556 line containing fi->pc. */
2557 if (!get_frame_pc_if_available (frame
, &pc
))
2563 notcurrent
= (pc
!= get_frame_address_in_block (frame
));
2564 (*sal
) = find_pc_line (pc
, notcurrent
);
2567 /* Per "frame.h", return the ``address'' of the frame. Code should
2568 really be using get_frame_id(). */
2570 get_frame_base (struct frame_info
*fi
)
2572 return get_frame_id (fi
).stack_addr
;
2575 /* High-level offsets into the frame. Used by the debug info. */
2578 get_frame_base_address (struct frame_info
*fi
)
2580 if (get_frame_type (fi
) != NORMAL_FRAME
)
2582 if (fi
->base
== NULL
)
2583 fi
->base
= frame_base_find_by_frame (fi
);
2584 /* Sneaky: If the low-level unwind and high-level base code share a
2585 common unwinder, let them share the prologue cache. */
2586 if (fi
->base
->unwind
== fi
->unwind
)
2587 return fi
->base
->this_base (fi
, &fi
->prologue_cache
);
2588 return fi
->base
->this_base (fi
, &fi
->base_cache
);
2592 get_frame_locals_address (struct frame_info
*fi
)
2594 if (get_frame_type (fi
) != NORMAL_FRAME
)
2596 /* If there isn't a frame address method, find it. */
2597 if (fi
->base
== NULL
)
2598 fi
->base
= frame_base_find_by_frame (fi
);
2599 /* Sneaky: If the low-level unwind and high-level base code share a
2600 common unwinder, let them share the prologue cache. */
2601 if (fi
->base
->unwind
== fi
->unwind
)
2602 return fi
->base
->this_locals (fi
, &fi
->prologue_cache
);
2603 return fi
->base
->this_locals (fi
, &fi
->base_cache
);
2607 get_frame_args_address (struct frame_info
*fi
)
2609 if (get_frame_type (fi
) != NORMAL_FRAME
)
2611 /* If there isn't a frame address method, find it. */
2612 if (fi
->base
== NULL
)
2613 fi
->base
= frame_base_find_by_frame (fi
);
2614 /* Sneaky: If the low-level unwind and high-level base code share a
2615 common unwinder, let them share the prologue cache. */
2616 if (fi
->base
->unwind
== fi
->unwind
)
2617 return fi
->base
->this_args (fi
, &fi
->prologue_cache
);
2618 return fi
->base
->this_args (fi
, &fi
->base_cache
);
2621 /* Return true if the frame unwinder for frame FI is UNWINDER; false
2625 frame_unwinder_is (struct frame_info
*fi
, const struct frame_unwind
*unwinder
)
2627 if (fi
->unwind
== NULL
)
2628 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
2629 return fi
->unwind
== unwinder
;
2632 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
2633 or -1 for a NULL frame. */
2636 frame_relative_level (struct frame_info
*fi
)
2645 get_frame_type (struct frame_info
*frame
)
2647 if (frame
->unwind
== NULL
)
2648 /* Initialize the frame's unwinder because that's what
2649 provides the frame's type. */
2650 frame_unwind_find_by_frame (frame
, &frame
->prologue_cache
);
2651 return frame
->unwind
->type
;
2654 struct program_space
*
2655 get_frame_program_space (struct frame_info
*frame
)
2657 return frame
->pspace
;
2660 struct program_space
*
2661 frame_unwind_program_space (struct frame_info
*this_frame
)
2663 gdb_assert (this_frame
);
2665 /* This is really a placeholder to keep the API consistent --- we
2666 assume for now that we don't have frame chains crossing
2668 return this_frame
->pspace
;
2671 struct address_space
*
2672 get_frame_address_space (struct frame_info
*frame
)
2674 return frame
->aspace
;
2677 /* Memory access methods. */
2680 get_frame_memory (struct frame_info
*this_frame
, CORE_ADDR addr
,
2681 gdb_byte
*buf
, int len
)
2683 read_memory (addr
, buf
, len
);
2687 get_frame_memory_signed (struct frame_info
*this_frame
, CORE_ADDR addr
,
2690 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2691 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2693 return read_memory_integer (addr
, len
, byte_order
);
2697 get_frame_memory_unsigned (struct frame_info
*this_frame
, CORE_ADDR addr
,
2700 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2701 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2703 return read_memory_unsigned_integer (addr
, len
, byte_order
);
2707 safe_frame_unwind_memory (struct frame_info
*this_frame
,
2708 CORE_ADDR addr
, gdb_byte
*buf
, int len
)
2710 /* NOTE: target_read_memory returns zero on success! */
2711 return !target_read_memory (addr
, buf
, len
);
2714 /* Architecture methods. */
2717 get_frame_arch (struct frame_info
*this_frame
)
2719 return frame_unwind_arch (this_frame
->next
);
2723 frame_unwind_arch (struct frame_info
*next_frame
)
2725 if (!next_frame
->prev_arch
.p
)
2727 struct gdbarch
*arch
;
2729 if (next_frame
->unwind
== NULL
)
2730 frame_unwind_find_by_frame (next_frame
, &next_frame
->prologue_cache
);
2732 if (next_frame
->unwind
->prev_arch
!= NULL
)
2733 arch
= next_frame
->unwind
->prev_arch (next_frame
,
2734 &next_frame
->prologue_cache
);
2736 arch
= get_frame_arch (next_frame
);
2738 next_frame
->prev_arch
.arch
= arch
;
2739 next_frame
->prev_arch
.p
= 1;
2741 fprintf_unfiltered (gdb_stdlog
,
2742 "{ frame_unwind_arch (next_frame=%d) -> %s }\n",
2744 gdbarch_bfd_arch_info (arch
)->printable_name
);
2747 return next_frame
->prev_arch
.arch
;
2751 frame_unwind_caller_arch (struct frame_info
*next_frame
)
2753 next_frame
= skip_artificial_frames (next_frame
);
2755 /* We must have a non-artificial frame. The caller is supposed to check
2756 the result of frame_unwind_caller_id (), which returns NULL_FRAME_ID
2758 gdb_assert (next_frame
!= NULL
);
2760 return frame_unwind_arch (next_frame
);
2763 /* Gets the language of FRAME. */
2766 get_frame_language (struct frame_info
*frame
)
2771 gdb_assert (frame
!= NULL
);
2773 /* We determine the current frame language by looking up its
2774 associated symtab. To retrieve this symtab, we use the frame
2775 PC. However we cannot use the frame PC as is, because it
2776 usually points to the instruction following the "call", which
2777 is sometimes the first instruction of another function. So
2778 we rely on get_frame_address_in_block(), it provides us with
2779 a PC that is guaranteed to be inside the frame's code
2784 pc
= get_frame_address_in_block (frame
);
2787 CATCH (ex
, RETURN_MASK_ERROR
)
2789 if (ex
.error
!= NOT_AVAILABLE_ERROR
)
2790 throw_exception (ex
);
2796 struct compunit_symtab
*cust
= find_pc_compunit_symtab (pc
);
2799 return compunit_language (cust
);
2802 return language_unknown
;
2805 /* Stack pointer methods. */
2808 get_frame_sp (struct frame_info
*this_frame
)
2810 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2812 /* Normality - an architecture that provides a way of obtaining any
2813 frame inner-most address. */
2814 if (gdbarch_unwind_sp_p (gdbarch
))
2815 /* NOTE drow/2008-06-28: gdbarch_unwind_sp could be converted to
2816 operate on THIS_FRAME now. */
2817 return gdbarch_unwind_sp (gdbarch
, this_frame
->next
);
2818 /* Now things are really are grim. Hope that the value returned by
2819 the gdbarch_sp_regnum register is meaningful. */
2820 if (gdbarch_sp_regnum (gdbarch
) >= 0)
2821 return get_frame_register_unsigned (this_frame
,
2822 gdbarch_sp_regnum (gdbarch
));
2823 internal_error (__FILE__
, __LINE__
, _("Missing unwind SP method"));
2826 /* Return the reason why we can't unwind past FRAME. */
2828 enum unwind_stop_reason
2829 get_frame_unwind_stop_reason (struct frame_info
*frame
)
2831 /* Fill-in STOP_REASON. */
2832 get_prev_frame_always (frame
);
2833 gdb_assert (frame
->prev_p
);
2835 return frame
->stop_reason
;
2838 /* Return a string explaining REASON. */
2841 unwind_stop_reason_to_string (enum unwind_stop_reason reason
)
2845 #define SET(name, description) \
2846 case name: return _(description);
2847 #include "unwind_stop_reasons.def"
2851 internal_error (__FILE__
, __LINE__
,
2852 "Invalid frame stop reason");
2857 frame_stop_reason_string (struct frame_info
*fi
)
2859 gdb_assert (fi
->prev_p
);
2860 gdb_assert (fi
->prev
== NULL
);
2862 /* Return the specific string if we have one. */
2863 if (fi
->stop_string
!= NULL
)
2864 return fi
->stop_string
;
2866 /* Return the generic string if we have nothing better. */
2867 return unwind_stop_reason_to_string (fi
->stop_reason
);
2870 /* Return the enum symbol name of REASON as a string, to use in debug
2874 frame_stop_reason_symbol_string (enum unwind_stop_reason reason
)
2878 #define SET(name, description) \
2879 case name: return #name;
2880 #include "unwind_stop_reasons.def"
2884 internal_error (__FILE__
, __LINE__
,
2885 "Invalid frame stop reason");
2889 /* Clean up after a failed (wrong unwinder) attempt to unwind past
2893 frame_cleanup_after_sniffer (void *arg
)
2895 struct frame_info
*frame
= (struct frame_info
*) arg
;
2897 /* The sniffer should not allocate a prologue cache if it did not
2898 match this frame. */
2899 gdb_assert (frame
->prologue_cache
== NULL
);
2901 /* No sniffer should extend the frame chain; sniff based on what is
2903 gdb_assert (!frame
->prev_p
);
2905 /* The sniffer should not check the frame's ID; that's circular. */
2906 gdb_assert (!frame
->this_id
.p
);
2908 /* Clear cached fields dependent on the unwinder.
2910 The previous PC is independent of the unwinder, but the previous
2911 function is not (see get_frame_address_in_block). */
2912 frame
->prev_func
.p
= 0;
2913 frame
->prev_func
.addr
= 0;
2915 /* Discard the unwinder last, so that we can easily find it if an assertion
2916 in this function triggers. */
2917 frame
->unwind
= NULL
;
2920 /* Set FRAME's unwinder temporarily, so that we can call a sniffer.
2921 Return a cleanup which should be called if unwinding fails, and
2922 discarded if it succeeds. */
2925 frame_prepare_for_sniffer (struct frame_info
*frame
,
2926 const struct frame_unwind
*unwind
)
2928 gdb_assert (frame
->unwind
== NULL
);
2929 frame
->unwind
= unwind
;
2930 return make_cleanup (frame_cleanup_after_sniffer
, frame
);
2933 extern initialize_file_ftype _initialize_frame
; /* -Wmissing-prototypes */
2935 static struct cmd_list_element
*set_backtrace_cmdlist
;
2936 static struct cmd_list_element
*show_backtrace_cmdlist
;
2939 set_backtrace_cmd (char *args
, int from_tty
)
2941 help_list (set_backtrace_cmdlist
, "set backtrace ", all_commands
,
2946 show_backtrace_cmd (char *args
, int from_tty
)
2948 cmd_show_list (show_backtrace_cmdlist
, from_tty
, "");
2952 _initialize_frame (void)
2954 obstack_init (&frame_cache_obstack
);
2956 frame_stash_create ();
2958 observer_attach_target_changed (frame_observer_target_changed
);
2960 add_prefix_cmd ("backtrace", class_maintenance
, set_backtrace_cmd
, _("\
2961 Set backtrace specific variables.\n\
2962 Configure backtrace variables such as the backtrace limit"),
2963 &set_backtrace_cmdlist
, "set backtrace ",
2964 0/*allow-unknown*/, &setlist
);
2965 add_prefix_cmd ("backtrace", class_maintenance
, show_backtrace_cmd
, _("\
2966 Show backtrace specific variables\n\
2967 Show backtrace variables such as the backtrace limit"),
2968 &show_backtrace_cmdlist
, "show backtrace ",
2969 0/*allow-unknown*/, &showlist
);
2971 add_setshow_boolean_cmd ("past-main", class_obscure
,
2972 &backtrace_past_main
, _("\
2973 Set whether backtraces should continue past \"main\"."), _("\
2974 Show whether backtraces should continue past \"main\"."), _("\
2975 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
2976 the backtrace at \"main\". Set this variable if you need to see the rest\n\
2977 of the stack trace."),
2979 show_backtrace_past_main
,
2980 &set_backtrace_cmdlist
,
2981 &show_backtrace_cmdlist
);
2983 add_setshow_boolean_cmd ("past-entry", class_obscure
,
2984 &backtrace_past_entry
, _("\
2985 Set whether backtraces should continue past the entry point of a program."),
2987 Show whether backtraces should continue past the entry point of a program."),
2989 Normally there are no callers beyond the entry point of a program, so GDB\n\
2990 will terminate the backtrace there. Set this variable if you need to see\n\
2991 the rest of the stack trace."),
2993 show_backtrace_past_entry
,
2994 &set_backtrace_cmdlist
,
2995 &show_backtrace_cmdlist
);
2997 add_setshow_uinteger_cmd ("limit", class_obscure
,
2998 &backtrace_limit
, _("\
2999 Set an upper bound on the number of backtrace levels."), _("\
3000 Show the upper bound on the number of backtrace levels."), _("\
3001 No more than the specified number of frames can be displayed or examined.\n\
3002 Literal \"unlimited\" or zero means no limit."),
3004 show_backtrace_limit
,
3005 &set_backtrace_cmdlist
,
3006 &show_backtrace_cmdlist
);
3008 /* Debug this files internals. */
3009 add_setshow_zuinteger_cmd ("frame", class_maintenance
, &frame_debug
, _("\
3010 Set frame debugging."), _("\
3011 Show frame debugging."), _("\
3012 When non-zero, frame specific internal debugging is enabled."),
3015 &setdebuglist
, &showdebuglist
);