1 /* Cache and manage frames for GDB, the GNU debugger.
3 Copyright (C) 1986-2016 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "inferior.h" /* for inferior_ptid */
26 #include "user-regs.h"
27 #include "gdb_obstack.h"
28 #include "dummy-frame.h"
29 #include "sentinel-frame.h"
33 #include "frame-unwind.h"
34 #include "frame-base.h"
39 #include "gdbthread.h"
41 #include "inline-frame.h"
42 #include "tracepoint.h"
46 static struct frame_info
*get_prev_frame_raw (struct frame_info
*this_frame
);
47 static const char *frame_stop_reason_symbol_string (enum unwind_stop_reason reason
);
49 /* Status of some values cached in the frame_info object. */
51 enum cached_copy_status
53 /* Value is unknown. */
56 /* We have a value. */
59 /* Value was not saved. */
62 /* Value is unavailable. */
66 /* We keep a cache of stack frames, each of which is a "struct
67 frame_info". The innermost one gets allocated (in
68 wait_for_inferior) each time the inferior stops; current_frame
69 points to it. Additional frames get allocated (in get_prev_frame)
70 as needed, and are chained through the next and prev fields. Any
71 time that the frame cache becomes invalid (most notably when we
72 execute something, but also if we change how we interpret the
73 frames (e.g. "set heuristic-fence-post" in mips-tdep.c, or anything
74 which reads new symbols)), we should call reinit_frame_cache. */
78 /* Level of this frame. The inner-most (youngest) frame is at level
79 0. As you move towards the outer-most (oldest) frame, the level
80 increases. This is a cached value. It could just as easily be
81 computed by counting back from the selected frame to the inner
83 /* NOTE: cagney/2002-04-05: Perhaps a level of ``-1'' should be
84 reserved to indicate a bogus frame - one that has been created
85 just to keep GDB happy (GDB always needs a frame). For the
86 moment leave this as speculation. */
89 /* The frame's program space. */
90 struct program_space
*pspace
;
92 /* The frame's address space. */
93 struct address_space
*aspace
;
95 /* The frame's low-level unwinder and corresponding cache. The
96 low-level unwinder is responsible for unwinding register values
97 for the previous frame. The low-level unwind methods are
98 selected based on the presence, or otherwise, of register unwind
99 information such as CFI. */
100 void *prologue_cache
;
101 const struct frame_unwind
*unwind
;
103 /* Cached copy of the previous frame's architecture. */
107 struct gdbarch
*arch
;
110 /* Cached copy of the previous frame's resume address. */
112 enum cached_copy_status status
;
116 /* Cached copy of the previous frame's function address. */
123 /* This frame's ID. */
127 struct frame_id value
;
130 /* The frame's high-level base methods, and corresponding cache.
131 The high level base methods are selected based on the frame's
133 const struct frame_base
*base
;
136 /* Pointers to the next (down, inner, younger) and previous (up,
137 outer, older) frame_info's in the frame cache. */
138 struct frame_info
*next
; /* down, inner, younger */
140 struct frame_info
*prev
; /* up, outer, older */
142 /* The reason why we could not set PREV, or UNWIND_NO_REASON if we
143 could. Only valid when PREV_P is set. */
144 enum unwind_stop_reason stop_reason
;
146 /* A frame specific string describing the STOP_REASON in more detail.
147 Only valid when PREV_P is set, but even then may still be NULL. */
148 const char *stop_string
;
151 /* A frame stash used to speed up frame lookups. Create a hash table
152 to stash frames previously accessed from the frame cache for
153 quicker subsequent retrieval. The hash table is emptied whenever
154 the frame cache is invalidated. */
156 static htab_t frame_stash
;
158 /* Internal function to calculate a hash from the frame_id addresses,
159 using as many valid addresses as possible. Frames below level 0
160 are not stored in the hash table. */
163 frame_addr_hash (const void *ap
)
165 const struct frame_info
*frame
= (const struct frame_info
*) ap
;
166 const struct frame_id f_id
= frame
->this_id
.value
;
169 gdb_assert (f_id
.stack_status
!= FID_STACK_INVALID
171 || f_id
.special_addr_p
);
173 if (f_id
.stack_status
== FID_STACK_VALID
)
174 hash
= iterative_hash (&f_id
.stack_addr
,
175 sizeof (f_id
.stack_addr
), hash
);
176 if (f_id
.code_addr_p
)
177 hash
= iterative_hash (&f_id
.code_addr
,
178 sizeof (f_id
.code_addr
), hash
);
179 if (f_id
.special_addr_p
)
180 hash
= iterative_hash (&f_id
.special_addr
,
181 sizeof (f_id
.special_addr
), hash
);
186 /* Internal equality function for the hash table. This function
187 defers equality operations to frame_id_eq. */
190 frame_addr_hash_eq (const void *a
, const void *b
)
192 const struct frame_info
*f_entry
= (const struct frame_info
*) a
;
193 const struct frame_info
*f_element
= (const struct frame_info
*) b
;
195 return frame_id_eq (f_entry
->this_id
.value
,
196 f_element
->this_id
.value
);
199 /* Internal function to create the frame_stash hash table. 100 seems
200 to be a good compromise to start the hash table at. */
203 frame_stash_create (void)
205 frame_stash
= htab_create (100,
211 /* Internal function to add a frame to the frame_stash hash table.
212 Returns false if a frame with the same ID was already stashed, true
216 frame_stash_add (struct frame_info
*frame
)
218 struct frame_info
**slot
;
220 /* Do not try to stash the sentinel frame. */
221 gdb_assert (frame
->level
>= 0);
223 slot
= (struct frame_info
**) htab_find_slot (frame_stash
,
227 /* If we already have a frame in the stack with the same id, we
228 either have a stack cycle (corrupted stack?), or some bug
229 elsewhere in GDB. In any case, ignore the duplicate and return
230 an indication to the caller. */
238 /* Internal function to search the frame stash for an entry with the
239 given frame ID. If found, return that frame. Otherwise return
242 static struct frame_info
*
243 frame_stash_find (struct frame_id id
)
245 struct frame_info dummy
;
246 struct frame_info
*frame
;
248 dummy
.this_id
.value
= id
;
249 frame
= (struct frame_info
*) htab_find (frame_stash
, &dummy
);
253 /* Internal function to invalidate the frame stash by removing all
254 entries in it. This only occurs when the frame cache is
258 frame_stash_invalidate (void)
260 htab_empty (frame_stash
);
263 /* Flag to control debugging. */
265 unsigned int frame_debug
;
267 show_frame_debug (struct ui_file
*file
, int from_tty
,
268 struct cmd_list_element
*c
, const char *value
)
270 fprintf_filtered (file
, _("Frame debugging is %s.\n"), value
);
273 /* Flag to indicate whether backtraces should stop at main et.al. */
275 static int backtrace_past_main
;
277 show_backtrace_past_main (struct ui_file
*file
, int from_tty
,
278 struct cmd_list_element
*c
, const char *value
)
280 fprintf_filtered (file
,
281 _("Whether backtraces should "
282 "continue past \"main\" is %s.\n"),
286 static int backtrace_past_entry
;
288 show_backtrace_past_entry (struct ui_file
*file
, int from_tty
,
289 struct cmd_list_element
*c
, const char *value
)
291 fprintf_filtered (file
, _("Whether backtraces should continue past the "
292 "entry point of a program is %s.\n"),
296 static unsigned int backtrace_limit
= UINT_MAX
;
298 show_backtrace_limit (struct ui_file
*file
, int from_tty
,
299 struct cmd_list_element
*c
, const char *value
)
301 fprintf_filtered (file
,
302 _("An upper bound on the number "
303 "of backtrace levels is %s.\n"),
309 fprint_field (struct ui_file
*file
, const char *name
, int p
, CORE_ADDR addr
)
312 fprintf_unfiltered (file
, "%s=%s", name
, hex_string (addr
));
314 fprintf_unfiltered (file
, "!%s", name
);
318 fprint_frame_id (struct ui_file
*file
, struct frame_id id
)
320 fprintf_unfiltered (file
, "{");
322 if (id
.stack_status
== FID_STACK_INVALID
)
323 fprintf_unfiltered (file
, "!stack");
324 else if (id
.stack_status
== FID_STACK_UNAVAILABLE
)
325 fprintf_unfiltered (file
, "stack=<unavailable>");
327 fprintf_unfiltered (file
, "stack=%s", hex_string (id
.stack_addr
));
328 fprintf_unfiltered (file
, ",");
330 fprint_field (file
, "code", id
.code_addr_p
, id
.code_addr
);
331 fprintf_unfiltered (file
, ",");
333 fprint_field (file
, "special", id
.special_addr_p
, id
.special_addr
);
335 if (id
.artificial_depth
)
336 fprintf_unfiltered (file
, ",artificial=%d", id
.artificial_depth
);
338 fprintf_unfiltered (file
, "}");
342 fprint_frame_type (struct ui_file
*file
, enum frame_type type
)
347 fprintf_unfiltered (file
, "NORMAL_FRAME");
350 fprintf_unfiltered (file
, "DUMMY_FRAME");
353 fprintf_unfiltered (file
, "INLINE_FRAME");
356 fprintf_unfiltered (file
, "TAILCALL_FRAME");
359 fprintf_unfiltered (file
, "SIGTRAMP_FRAME");
362 fprintf_unfiltered (file
, "ARCH_FRAME");
365 fprintf_unfiltered (file
, "SENTINEL_FRAME");
368 fprintf_unfiltered (file
, "<unknown type>");
374 fprint_frame (struct ui_file
*file
, struct frame_info
*fi
)
378 fprintf_unfiltered (file
, "<NULL frame>");
381 fprintf_unfiltered (file
, "{");
382 fprintf_unfiltered (file
, "level=%d", fi
->level
);
383 fprintf_unfiltered (file
, ",");
384 fprintf_unfiltered (file
, "type=");
385 if (fi
->unwind
!= NULL
)
386 fprint_frame_type (file
, fi
->unwind
->type
);
388 fprintf_unfiltered (file
, "<unknown>");
389 fprintf_unfiltered (file
, ",");
390 fprintf_unfiltered (file
, "unwind=");
391 if (fi
->unwind
!= NULL
)
392 gdb_print_host_address (fi
->unwind
, file
);
394 fprintf_unfiltered (file
, "<unknown>");
395 fprintf_unfiltered (file
, ",");
396 fprintf_unfiltered (file
, "pc=");
397 if (fi
->next
== NULL
|| fi
->next
->prev_pc
.status
== CC_UNKNOWN
)
398 fprintf_unfiltered (file
, "<unknown>");
399 else if (fi
->next
->prev_pc
.status
== CC_VALUE
)
400 fprintf_unfiltered (file
, "%s",
401 hex_string (fi
->next
->prev_pc
.value
));
402 else if (fi
->next
->prev_pc
.status
== CC_NOT_SAVED
)
403 val_print_not_saved (file
);
404 else if (fi
->next
->prev_pc
.status
== CC_UNAVAILABLE
)
405 val_print_unavailable (file
);
406 fprintf_unfiltered (file
, ",");
407 fprintf_unfiltered (file
, "id=");
409 fprint_frame_id (file
, fi
->this_id
.value
);
411 fprintf_unfiltered (file
, "<unknown>");
412 fprintf_unfiltered (file
, ",");
413 fprintf_unfiltered (file
, "func=");
414 if (fi
->next
!= NULL
&& fi
->next
->prev_func
.p
)
415 fprintf_unfiltered (file
, "%s", hex_string (fi
->next
->prev_func
.addr
));
417 fprintf_unfiltered (file
, "<unknown>");
418 fprintf_unfiltered (file
, "}");
421 /* Given FRAME, return the enclosing frame as found in real frames read-in from
422 inferior memory. Skip any previous frames which were made up by GDB.
423 Return FRAME if FRAME is a non-artificial frame.
424 Return NULL if FRAME is the start of an artificial-only chain. */
426 static struct frame_info
*
427 skip_artificial_frames (struct frame_info
*frame
)
429 /* Note we use get_prev_frame_always, and not get_prev_frame. The
430 latter will truncate the frame chain, leading to this function
431 unintentionally returning a null_frame_id (e.g., when the user
432 sets a backtrace limit).
434 Note that for record targets we may get a frame chain that consists
435 of artificial frames only. */
436 while (get_frame_type (frame
) == INLINE_FRAME
437 || get_frame_type (frame
) == TAILCALL_FRAME
)
439 frame
= get_prev_frame_always (frame
);
448 skip_unwritable_frames (struct frame_info
*frame
)
450 while (gdbarch_code_of_frame_writable (get_frame_arch (frame
), frame
) == 0)
452 frame
= get_prev_frame (frame
);
463 skip_tailcall_frames (struct frame_info
*frame
)
465 while (get_frame_type (frame
) == TAILCALL_FRAME
)
467 /* Note that for record targets we may get a frame chain that consists of
468 tailcall frames only. */
469 frame
= get_prev_frame (frame
);
477 /* Compute the frame's uniq ID that can be used to, later, re-find the
481 compute_frame_id (struct frame_info
*fi
)
483 gdb_assert (!fi
->this_id
.p
);
486 fprintf_unfiltered (gdb_stdlog
, "{ compute_frame_id (fi=%d) ",
488 /* Find the unwinder. */
489 if (fi
->unwind
== NULL
)
490 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
491 /* Find THIS frame's ID. */
492 /* Default to outermost if no ID is found. */
493 fi
->this_id
.value
= outer_frame_id
;
494 fi
->unwind
->this_id (fi
, &fi
->prologue_cache
, &fi
->this_id
.value
);
495 gdb_assert (frame_id_p (fi
->this_id
.value
));
499 fprintf_unfiltered (gdb_stdlog
, "-> ");
500 fprint_frame_id (gdb_stdlog
, fi
->this_id
.value
);
501 fprintf_unfiltered (gdb_stdlog
, " }\n");
505 /* Return a frame uniq ID that can be used to, later, re-find the
509 get_frame_id (struct frame_info
*fi
)
512 return null_frame_id
;
518 /* If we haven't computed the frame id yet, then it must be that
519 this is the current frame. Compute it now, and stash the
520 result. The IDs of other frames are computed as soon as
521 they're created, in order to detect cycles. See
522 get_prev_frame_if_no_cycle. */
523 gdb_assert (fi
->level
== 0);
526 compute_frame_id (fi
);
528 /* Since this is the first frame in the chain, this should
530 stashed
= frame_stash_add (fi
);
531 gdb_assert (stashed
);
534 return fi
->this_id
.value
;
538 get_stack_frame_id (struct frame_info
*next_frame
)
540 return get_frame_id (skip_artificial_frames (next_frame
));
544 frame_unwind_caller_id (struct frame_info
*next_frame
)
546 struct frame_info
*this_frame
;
548 /* Use get_prev_frame_always, and not get_prev_frame. The latter
549 will truncate the frame chain, leading to this function
550 unintentionally returning a null_frame_id (e.g., when a caller
551 requests the frame ID of "main()"s caller. */
553 next_frame
= skip_artificial_frames (next_frame
);
554 if (next_frame
== NULL
)
555 return null_frame_id
;
557 this_frame
= get_prev_frame_always (next_frame
);
559 return get_frame_id (skip_artificial_frames (this_frame
));
561 return null_frame_id
;
564 const struct frame_id null_frame_id
= { 0 }; /* All zeros. */
565 const struct frame_id outer_frame_id
= { 0, 0, 0, FID_STACK_INVALID
, 0, 1, 0 };
568 frame_id_build_special (CORE_ADDR stack_addr
, CORE_ADDR code_addr
,
569 CORE_ADDR special_addr
)
571 struct frame_id id
= null_frame_id
;
573 id
.stack_addr
= stack_addr
;
574 id
.stack_status
= FID_STACK_VALID
;
575 id
.code_addr
= code_addr
;
577 id
.special_addr
= special_addr
;
578 id
.special_addr_p
= 1;
585 frame_id_build_unavailable_stack (CORE_ADDR code_addr
)
587 struct frame_id id
= null_frame_id
;
589 id
.stack_status
= FID_STACK_UNAVAILABLE
;
590 id
.code_addr
= code_addr
;
598 frame_id_build_unavailable_stack_special (CORE_ADDR code_addr
,
599 CORE_ADDR special_addr
)
601 struct frame_id id
= null_frame_id
;
603 id
.stack_status
= FID_STACK_UNAVAILABLE
;
604 id
.code_addr
= code_addr
;
606 id
.special_addr
= special_addr
;
607 id
.special_addr_p
= 1;
612 frame_id_build (CORE_ADDR stack_addr
, CORE_ADDR code_addr
)
614 struct frame_id id
= null_frame_id
;
616 id
.stack_addr
= stack_addr
;
617 id
.stack_status
= FID_STACK_VALID
;
618 id
.code_addr
= code_addr
;
624 frame_id_build_wild (CORE_ADDR stack_addr
)
626 struct frame_id id
= null_frame_id
;
628 id
.stack_addr
= stack_addr
;
629 id
.stack_status
= FID_STACK_VALID
;
634 frame_id_p (struct frame_id l
)
638 /* The frame is valid iff it has a valid stack address. */
639 p
= l
.stack_status
!= FID_STACK_INVALID
;
640 /* outer_frame_id is also valid. */
641 if (!p
&& memcmp (&l
, &outer_frame_id
, sizeof (l
)) == 0)
645 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_p (l=");
646 fprint_frame_id (gdb_stdlog
, l
);
647 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", p
);
653 frame_id_artificial_p (struct frame_id l
)
658 return (l
.artificial_depth
!= 0);
662 frame_id_eq (struct frame_id l
, struct frame_id r
)
666 if (l
.stack_status
== FID_STACK_INVALID
&& l
.special_addr_p
667 && r
.stack_status
== FID_STACK_INVALID
&& r
.special_addr_p
)
668 /* The outermost frame marker is equal to itself. This is the
669 dodgy thing about outer_frame_id, since between execution steps
670 we might step into another function - from which we can't
671 unwind either. More thought required to get rid of
674 else if (l
.stack_status
== FID_STACK_INVALID
675 || r
.stack_status
== FID_STACK_INVALID
)
676 /* Like a NaN, if either ID is invalid, the result is false.
677 Note that a frame ID is invalid iff it is the null frame ID. */
679 else if (l
.stack_status
!= r
.stack_status
|| l
.stack_addr
!= r
.stack_addr
)
680 /* If .stack addresses are different, the frames are different. */
682 else if (l
.code_addr_p
&& r
.code_addr_p
&& l
.code_addr
!= r
.code_addr
)
683 /* An invalid code addr is a wild card. If .code addresses are
684 different, the frames are different. */
686 else if (l
.special_addr_p
&& r
.special_addr_p
687 && l
.special_addr
!= r
.special_addr
)
688 /* An invalid special addr is a wild card (or unused). Otherwise
689 if special addresses are different, the frames are different. */
691 else if (l
.artificial_depth
!= r
.artificial_depth
)
692 /* If artifical depths are different, the frames must be different. */
695 /* Frames are equal. */
700 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_eq (l=");
701 fprint_frame_id (gdb_stdlog
, l
);
702 fprintf_unfiltered (gdb_stdlog
, ",r=");
703 fprint_frame_id (gdb_stdlog
, r
);
704 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", eq
);
709 /* Safety net to check whether frame ID L should be inner to
710 frame ID R, according to their stack addresses.
712 This method cannot be used to compare arbitrary frames, as the
713 ranges of valid stack addresses may be discontiguous (e.g. due
716 However, it can be used as safety net to discover invalid frame
717 IDs in certain circumstances. Assuming that NEXT is the immediate
718 inner frame to THIS and that NEXT and THIS are both NORMAL frames:
720 * The stack address of NEXT must be inner-than-or-equal to the stack
723 Therefore, if frame_id_inner (THIS, NEXT) holds, some unwind
726 * If NEXT and THIS have different stack addresses, no other frame
727 in the frame chain may have a stack address in between.
729 Therefore, if frame_id_inner (TEST, THIS) holds, but
730 frame_id_inner (TEST, NEXT) does not hold, TEST cannot refer
731 to a valid frame in the frame chain.
733 The sanity checks above cannot be performed when a SIGTRAMP frame
734 is involved, because signal handlers might be executed on a different
735 stack than the stack used by the routine that caused the signal
736 to be raised. This can happen for instance when a thread exceeds
737 its maximum stack size. In this case, certain compilers implement
738 a stack overflow strategy that cause the handler to be run on a
742 frame_id_inner (struct gdbarch
*gdbarch
, struct frame_id l
, struct frame_id r
)
746 if (l
.stack_status
!= FID_STACK_VALID
|| r
.stack_status
!= FID_STACK_VALID
)
747 /* Like NaN, any operation involving an invalid ID always fails.
748 Likewise if either ID has an unavailable stack address. */
750 else if (l
.artificial_depth
> r
.artificial_depth
751 && l
.stack_addr
== r
.stack_addr
752 && l
.code_addr_p
== r
.code_addr_p
753 && l
.special_addr_p
== r
.special_addr_p
754 && l
.special_addr
== r
.special_addr
)
756 /* Same function, different inlined functions. */
757 const struct block
*lb
, *rb
;
759 gdb_assert (l
.code_addr_p
&& r
.code_addr_p
);
761 lb
= block_for_pc (l
.code_addr
);
762 rb
= block_for_pc (r
.code_addr
);
764 if (lb
== NULL
|| rb
== NULL
)
765 /* Something's gone wrong. */
768 /* This will return true if LB and RB are the same block, or
769 if the block with the smaller depth lexically encloses the
770 block with the greater depth. */
771 inner
= contained_in (lb
, rb
);
774 /* Only return non-zero when strictly inner than. Note that, per
775 comment in "frame.h", there is some fuzz here. Frameless
776 functions are not strictly inner than (same .stack but
777 different .code and/or .special address). */
778 inner
= gdbarch_inner_than (gdbarch
, l
.stack_addr
, r
.stack_addr
);
781 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_inner (l=");
782 fprint_frame_id (gdb_stdlog
, l
);
783 fprintf_unfiltered (gdb_stdlog
, ",r=");
784 fprint_frame_id (gdb_stdlog
, r
);
785 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", inner
);
791 frame_find_by_id (struct frame_id id
)
793 struct frame_info
*frame
, *prev_frame
;
795 /* ZERO denotes the null frame, let the caller decide what to do
796 about it. Should it instead return get_current_frame()? */
797 if (!frame_id_p (id
))
800 /* Try using the frame stash first. Finding it there removes the need
801 to perform the search by looping over all frames, which can be very
802 CPU-intensive if the number of frames is very high (the loop is O(n)
803 and get_prev_frame performs a series of checks that are relatively
804 expensive). This optimization is particularly useful when this function
805 is called from another function (such as value_fetch_lazy, case
806 VALUE_LVAL (val) == lval_register) which already loops over all frames,
807 making the overall behavior O(n^2). */
808 frame
= frame_stash_find (id
);
812 for (frame
= get_current_frame (); ; frame
= prev_frame
)
814 struct frame_id self
= get_frame_id (frame
);
816 if (frame_id_eq (id
, self
))
817 /* An exact match. */
820 prev_frame
= get_prev_frame (frame
);
824 /* As a safety net to avoid unnecessary backtracing while trying
825 to find an invalid ID, we check for a common situation where
826 we can detect from comparing stack addresses that no other
827 frame in the current frame chain can have this ID. See the
828 comment at frame_id_inner for details. */
829 if (get_frame_type (frame
) == NORMAL_FRAME
830 && !frame_id_inner (get_frame_arch (frame
), id
, self
)
831 && frame_id_inner (get_frame_arch (prev_frame
), id
,
832 get_frame_id (prev_frame
)))
839 frame_unwind_pc (struct frame_info
*this_frame
)
841 if (this_frame
->prev_pc
.status
== CC_UNKNOWN
)
843 if (gdbarch_unwind_pc_p (frame_unwind_arch (this_frame
)))
845 struct gdbarch
*prev_gdbarch
;
849 /* The right way. The `pure' way. The one true way. This
850 method depends solely on the register-unwind code to
851 determine the value of registers in THIS frame, and hence
852 the value of this frame's PC (resume address). A typical
853 implementation is no more than:
855 frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
856 return extract_unsigned_integer (buf, size of ISA_PC_REGNUM);
858 Note: this method is very heavily dependent on a correct
859 register-unwind implementation, it pays to fix that
860 method first; this method is frame type agnostic, since
861 it only deals with register values, it works with any
862 frame. This is all in stark contrast to the old
863 FRAME_SAVED_PC which would try to directly handle all the
864 different ways that a PC could be unwound. */
865 prev_gdbarch
= frame_unwind_arch (this_frame
);
869 pc
= gdbarch_unwind_pc (prev_gdbarch
, this_frame
);
872 CATCH (ex
, RETURN_MASK_ERROR
)
874 if (ex
.error
== NOT_AVAILABLE_ERROR
)
876 this_frame
->prev_pc
.status
= CC_UNAVAILABLE
;
879 fprintf_unfiltered (gdb_stdlog
,
880 "{ frame_unwind_pc (this_frame=%d)"
881 " -> <unavailable> }\n",
884 else if (ex
.error
== OPTIMIZED_OUT_ERROR
)
886 this_frame
->prev_pc
.status
= CC_NOT_SAVED
;
889 fprintf_unfiltered (gdb_stdlog
,
890 "{ frame_unwind_pc (this_frame=%d)"
891 " -> <not saved> }\n",
895 throw_exception (ex
);
901 this_frame
->prev_pc
.value
= pc
;
902 this_frame
->prev_pc
.status
= CC_VALUE
;
904 fprintf_unfiltered (gdb_stdlog
,
905 "{ frame_unwind_pc (this_frame=%d) "
908 hex_string (this_frame
->prev_pc
.value
));
912 internal_error (__FILE__
, __LINE__
, _("No unwind_pc method"));
915 if (this_frame
->prev_pc
.status
== CC_VALUE
)
916 return this_frame
->prev_pc
.value
;
917 else if (this_frame
->prev_pc
.status
== CC_UNAVAILABLE
)
918 throw_error (NOT_AVAILABLE_ERROR
, _("PC not available"));
919 else if (this_frame
->prev_pc
.status
== CC_NOT_SAVED
)
920 throw_error (OPTIMIZED_OUT_ERROR
, _("PC not saved"));
922 internal_error (__FILE__
, __LINE__
,
923 "unexpected prev_pc status: %d",
924 (int) this_frame
->prev_pc
.status
);
928 frame_unwind_caller_pc (struct frame_info
*this_frame
)
930 this_frame
= skip_artificial_frames (this_frame
);
932 /* We must have a non-artificial frame. The caller is supposed to check
933 the result of frame_unwind_caller_id (), which returns NULL_FRAME_ID
935 gdb_assert (this_frame
!= NULL
);
937 return frame_unwind_pc (this_frame
);
941 get_frame_func_if_available (struct frame_info
*this_frame
, CORE_ADDR
*pc
)
943 struct frame_info
*next_frame
= this_frame
->next
;
945 if (!next_frame
->prev_func
.p
)
947 CORE_ADDR addr_in_block
;
949 /* Make certain that this, and not the adjacent, function is
951 if (!get_frame_address_in_block_if_available (this_frame
, &addr_in_block
))
953 next_frame
->prev_func
.p
= -1;
955 fprintf_unfiltered (gdb_stdlog
,
956 "{ get_frame_func (this_frame=%d)"
957 " -> unavailable }\n",
962 next_frame
->prev_func
.p
= 1;
963 next_frame
->prev_func
.addr
= get_pc_function_start (addr_in_block
);
965 fprintf_unfiltered (gdb_stdlog
,
966 "{ get_frame_func (this_frame=%d) -> %s }\n",
968 hex_string (next_frame
->prev_func
.addr
));
972 if (next_frame
->prev_func
.p
< 0)
979 *pc
= next_frame
->prev_func
.addr
;
985 get_frame_func (struct frame_info
*this_frame
)
989 if (!get_frame_func_if_available (this_frame
, &pc
))
990 throw_error (NOT_AVAILABLE_ERROR
, _("PC not available"));
995 static enum register_status
996 do_frame_register_read (void *src
, int regnum
, gdb_byte
*buf
)
998 if (!deprecated_frame_register_read ((struct frame_info
*) src
, regnum
, buf
))
999 return REG_UNAVAILABLE
;
1005 frame_save_as_regcache (struct frame_info
*this_frame
)
1007 struct address_space
*aspace
= get_frame_address_space (this_frame
);
1008 struct regcache
*regcache
= regcache_xmalloc (get_frame_arch (this_frame
),
1010 struct cleanup
*cleanups
= make_cleanup_regcache_xfree (regcache
);
1012 regcache_save (regcache
, do_frame_register_read
, this_frame
);
1013 discard_cleanups (cleanups
);
1018 frame_pop (struct frame_info
*this_frame
)
1020 struct frame_info
*prev_frame
;
1021 struct regcache
*scratch
;
1022 struct cleanup
*cleanups
;
1024 if (get_frame_type (this_frame
) == DUMMY_FRAME
)
1026 /* Popping a dummy frame involves restoring more than just registers.
1027 dummy_frame_pop does all the work. */
1028 dummy_frame_pop (get_frame_id (this_frame
), inferior_ptid
);
1032 /* Ensure that we have a frame to pop to. */
1033 prev_frame
= get_prev_frame_always (this_frame
);
1036 error (_("Cannot pop the initial frame."));
1038 /* Ignore TAILCALL_FRAME type frames, they were executed already before
1039 entering THISFRAME. */
1040 prev_frame
= skip_tailcall_frames (prev_frame
);
1042 if (prev_frame
== NULL
)
1043 error (_("Cannot find the caller frame."));
1045 /* Make a copy of all the register values unwound from this frame.
1046 Save them in a scratch buffer so that there isn't a race between
1047 trying to extract the old values from the current regcache while
1048 at the same time writing new values into that same cache. */
1049 scratch
= frame_save_as_regcache (prev_frame
);
1050 cleanups
= make_cleanup_regcache_xfree (scratch
);
1052 /* FIXME: cagney/2003-03-16: It should be possible to tell the
1053 target's register cache that it is about to be hit with a burst
1054 register transfer and that the sequence of register writes should
1055 be batched. The pair target_prepare_to_store() and
1056 target_store_registers() kind of suggest this functionality.
1057 Unfortunately, they don't implement it. Their lack of a formal
1058 definition can lead to targets writing back bogus values
1059 (arguably a bug in the target code mind). */
1060 /* Now copy those saved registers into the current regcache.
1061 Here, regcache_cpy() calls regcache_restore(). */
1062 regcache_cpy (get_current_regcache (), scratch
);
1063 do_cleanups (cleanups
);
1065 /* We've made right mess of GDB's local state, just discard
1067 reinit_frame_cache ();
1071 frame_register_unwind (struct frame_info
*frame
, int regnum
,
1072 int *optimizedp
, int *unavailablep
,
1073 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
1074 int *realnump
, gdb_byte
*bufferp
)
1076 struct value
*value
;
1078 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
1079 that the value proper does not need to be fetched. */
1080 gdb_assert (optimizedp
!= NULL
);
1081 gdb_assert (lvalp
!= NULL
);
1082 gdb_assert (addrp
!= NULL
);
1083 gdb_assert (realnump
!= NULL
);
1084 /* gdb_assert (bufferp != NULL); */
1086 value
= frame_unwind_register_value (frame
, regnum
);
1088 gdb_assert (value
!= NULL
);
1090 *optimizedp
= value_optimized_out (value
);
1091 *unavailablep
= !value_entirely_available (value
);
1092 *lvalp
= VALUE_LVAL (value
);
1093 *addrp
= value_address (value
);
1094 *realnump
= VALUE_REGNUM (value
);
1098 if (!*optimizedp
&& !*unavailablep
)
1099 memcpy (bufferp
, value_contents_all (value
),
1100 TYPE_LENGTH (value_type (value
)));
1102 memset (bufferp
, 0, TYPE_LENGTH (value_type (value
)));
1105 /* Dispose of the new value. This prevents watchpoints from
1106 trying to watch the saved frame pointer. */
1107 release_value (value
);
1112 frame_register (struct frame_info
*frame
, int regnum
,
1113 int *optimizedp
, int *unavailablep
, enum lval_type
*lvalp
,
1114 CORE_ADDR
*addrp
, int *realnump
, gdb_byte
*bufferp
)
1116 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
1117 that the value proper does not need to be fetched. */
1118 gdb_assert (optimizedp
!= NULL
);
1119 gdb_assert (lvalp
!= NULL
);
1120 gdb_assert (addrp
!= NULL
);
1121 gdb_assert (realnump
!= NULL
);
1122 /* gdb_assert (bufferp != NULL); */
1124 /* Obtain the register value by unwinding the register from the next
1125 (more inner frame). */
1126 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
1127 frame_register_unwind (frame
->next
, regnum
, optimizedp
, unavailablep
,
1128 lvalp
, addrp
, realnump
, bufferp
);
1132 frame_unwind_register (struct frame_info
*frame
, int regnum
, gdb_byte
*buf
)
1138 enum lval_type lval
;
1140 frame_register_unwind (frame
, regnum
, &optimized
, &unavailable
,
1141 &lval
, &addr
, &realnum
, buf
);
1144 throw_error (OPTIMIZED_OUT_ERROR
,
1145 _("Register %d was not saved"), regnum
);
1147 throw_error (NOT_AVAILABLE_ERROR
,
1148 _("Register %d is not available"), regnum
);
1152 get_frame_register (struct frame_info
*frame
,
1153 int regnum
, gdb_byte
*buf
)
1155 frame_unwind_register (frame
->next
, regnum
, buf
);
1159 frame_unwind_register_value (struct frame_info
*frame
, int regnum
)
1161 struct gdbarch
*gdbarch
;
1162 struct value
*value
;
1164 gdb_assert (frame
!= NULL
);
1165 gdbarch
= frame_unwind_arch (frame
);
1169 fprintf_unfiltered (gdb_stdlog
,
1170 "{ frame_unwind_register_value "
1171 "(frame=%d,regnum=%d(%s),...) ",
1172 frame
->level
, regnum
,
1173 user_reg_map_regnum_to_name (gdbarch
, regnum
));
1176 /* Find the unwinder. */
1177 if (frame
->unwind
== NULL
)
1178 frame_unwind_find_by_frame (frame
, &frame
->prologue_cache
);
1180 /* Ask this frame to unwind its register. */
1181 value
= frame
->unwind
->prev_register (frame
, &frame
->prologue_cache
, regnum
);
1185 fprintf_unfiltered (gdb_stdlog
, "->");
1186 if (value_optimized_out (value
))
1188 fprintf_unfiltered (gdb_stdlog
, " ");
1189 val_print_optimized_out (value
, gdb_stdlog
);
1193 if (VALUE_LVAL (value
) == lval_register
)
1194 fprintf_unfiltered (gdb_stdlog
, " register=%d",
1195 VALUE_REGNUM (value
));
1196 else if (VALUE_LVAL (value
) == lval_memory
)
1197 fprintf_unfiltered (gdb_stdlog
, " address=%s",
1199 value_address (value
)));
1201 fprintf_unfiltered (gdb_stdlog
, " computed");
1203 if (value_lazy (value
))
1204 fprintf_unfiltered (gdb_stdlog
, " lazy");
1208 const gdb_byte
*buf
= value_contents (value
);
1210 fprintf_unfiltered (gdb_stdlog
, " bytes=");
1211 fprintf_unfiltered (gdb_stdlog
, "[");
1212 for (i
= 0; i
< register_size (gdbarch
, regnum
); i
++)
1213 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1214 fprintf_unfiltered (gdb_stdlog
, "]");
1218 fprintf_unfiltered (gdb_stdlog
, " }\n");
1225 get_frame_register_value (struct frame_info
*frame
, int regnum
)
1227 return frame_unwind_register_value (frame
->next
, regnum
);
1231 frame_unwind_register_signed (struct frame_info
*frame
, int regnum
)
1233 struct gdbarch
*gdbarch
= frame_unwind_arch (frame
);
1234 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1235 int size
= register_size (gdbarch
, regnum
);
1236 gdb_byte buf
[MAX_REGISTER_SIZE
];
1238 frame_unwind_register (frame
, regnum
, buf
);
1239 return extract_signed_integer (buf
, size
, byte_order
);
1243 get_frame_register_signed (struct frame_info
*frame
, int regnum
)
1245 return frame_unwind_register_signed (frame
->next
, regnum
);
1249 frame_unwind_register_unsigned (struct frame_info
*frame
, int regnum
)
1251 struct gdbarch
*gdbarch
= frame_unwind_arch (frame
);
1252 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1253 int size
= register_size (gdbarch
, regnum
);
1254 gdb_byte buf
[MAX_REGISTER_SIZE
];
1256 frame_unwind_register (frame
, regnum
, buf
);
1257 return extract_unsigned_integer (buf
, size
, byte_order
);
1261 get_frame_register_unsigned (struct frame_info
*frame
, int regnum
)
1263 return frame_unwind_register_unsigned (frame
->next
, regnum
);
1267 read_frame_register_unsigned (struct frame_info
*frame
, int regnum
,
1270 struct value
*regval
= get_frame_register_value (frame
, regnum
);
1272 if (!value_optimized_out (regval
)
1273 && value_entirely_available (regval
))
1275 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1276 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1277 int size
= register_size (gdbarch
, VALUE_REGNUM (regval
));
1279 *val
= extract_unsigned_integer (value_contents (regval
), size
, byte_order
);
1287 put_frame_register (struct frame_info
*frame
, int regnum
,
1288 const gdb_byte
*buf
)
1290 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1294 enum lval_type lval
;
1297 frame_register (frame
, regnum
, &optim
, &unavail
,
1298 &lval
, &addr
, &realnum
, NULL
);
1300 error (_("Attempt to assign to a register that was not saved."));
1305 write_memory (addr
, buf
, register_size (gdbarch
, regnum
));
1309 regcache_cooked_write (get_current_regcache (), realnum
, buf
);
1312 error (_("Attempt to assign to an unmodifiable value."));
1316 /* This function is deprecated. Use get_frame_register_value instead,
1317 which provides more accurate information.
1319 Find and return the value of REGNUM for the specified stack frame.
1320 The number of bytes copied is REGISTER_SIZE (REGNUM).
1322 Returns 0 if the register value could not be found. */
1325 deprecated_frame_register_read (struct frame_info
*frame
, int regnum
,
1330 enum lval_type lval
;
1334 frame_register (frame
, regnum
, &optimized
, &unavailable
,
1335 &lval
, &addr
, &realnum
, myaddr
);
1337 return !optimized
&& !unavailable
;
1341 get_frame_register_bytes (struct frame_info
*frame
, int regnum
,
1342 CORE_ADDR offset
, int len
, gdb_byte
*myaddr
,
1343 int *optimizedp
, int *unavailablep
)
1345 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1350 /* Skip registers wholly inside of OFFSET. */
1351 while (offset
>= register_size (gdbarch
, regnum
))
1353 offset
-= register_size (gdbarch
, regnum
);
1357 /* Ensure that we will not read beyond the end of the register file.
1358 This can only ever happen if the debug information is bad. */
1360 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1361 for (i
= regnum
; i
< numregs
; i
++)
1363 int thissize
= register_size (gdbarch
, i
);
1366 break; /* This register is not available on this architecture. */
1367 maxsize
+= thissize
;
1370 error (_("Bad debug information detected: "
1371 "Attempt to read %d bytes from registers."), len
);
1373 /* Copy the data. */
1376 int curr_len
= register_size (gdbarch
, regnum
) - offset
;
1381 if (curr_len
== register_size (gdbarch
, regnum
))
1383 enum lval_type lval
;
1387 frame_register (frame
, regnum
, optimizedp
, unavailablep
,
1388 &lval
, &addr
, &realnum
, myaddr
);
1389 if (*optimizedp
|| *unavailablep
)
1394 gdb_byte buf
[MAX_REGISTER_SIZE
];
1395 enum lval_type lval
;
1399 frame_register (frame
, regnum
, optimizedp
, unavailablep
,
1400 &lval
, &addr
, &realnum
, buf
);
1401 if (*optimizedp
|| *unavailablep
)
1403 memcpy (myaddr
, buf
+ offset
, curr_len
);
1418 put_frame_register_bytes (struct frame_info
*frame
, int regnum
,
1419 CORE_ADDR offset
, int len
, const gdb_byte
*myaddr
)
1421 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1423 /* Skip registers wholly inside of OFFSET. */
1424 while (offset
>= register_size (gdbarch
, regnum
))
1426 offset
-= register_size (gdbarch
, regnum
);
1430 /* Copy the data. */
1433 int curr_len
= register_size (gdbarch
, regnum
) - offset
;
1438 if (curr_len
== register_size (gdbarch
, regnum
))
1440 put_frame_register (frame
, regnum
, myaddr
);
1444 gdb_byte buf
[MAX_REGISTER_SIZE
];
1446 deprecated_frame_register_read (frame
, regnum
, buf
);
1447 memcpy (buf
+ offset
, myaddr
, curr_len
);
1448 put_frame_register (frame
, regnum
, buf
);
1458 /* Create a sentinel frame. */
1460 static struct frame_info
*
1461 create_sentinel_frame (struct program_space
*pspace
, struct regcache
*regcache
)
1463 struct frame_info
*frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1466 frame
->pspace
= pspace
;
1467 frame
->aspace
= get_regcache_aspace (regcache
);
1468 /* Explicitly initialize the sentinel frame's cache. Provide it
1469 with the underlying regcache. In the future additional
1470 information, such as the frame's thread will be added. */
1471 frame
->prologue_cache
= sentinel_frame_cache (regcache
);
1472 /* For the moment there is only one sentinel frame implementation. */
1473 frame
->unwind
= &sentinel_frame_unwind
;
1474 /* Link this frame back to itself. The frame is self referential
1475 (the unwound PC is the same as the pc), so make it so. */
1476 frame
->next
= frame
;
1477 /* Make the sentinel frame's ID valid, but invalid. That way all
1478 comparisons with it should fail. */
1479 frame
->this_id
.p
= 1;
1480 frame
->this_id
.value
= null_frame_id
;
1483 fprintf_unfiltered (gdb_stdlog
, "{ create_sentinel_frame (...) -> ");
1484 fprint_frame (gdb_stdlog
, frame
);
1485 fprintf_unfiltered (gdb_stdlog
, " }\n");
1490 /* Info about the innermost stack frame (contents of FP register). */
1492 static struct frame_info
*current_frame
;
1494 /* Cache for frame addresses already read by gdb. Valid only while
1495 inferior is stopped. Control variables for the frame cache should
1496 be local to this module. */
1498 static struct obstack frame_cache_obstack
;
1501 frame_obstack_zalloc (unsigned long size
)
1503 void *data
= obstack_alloc (&frame_cache_obstack
, size
);
1505 memset (data
, 0, size
);
1509 static struct frame_info
*get_prev_frame_always_1 (struct frame_info
*this_frame
);
1512 get_current_frame (void)
1514 /* First check, and report, the lack of registers. Having GDB
1515 report "No stack!" or "No memory" when the target doesn't even
1516 have registers is very confusing. Besides, "printcmd.exp"
1517 explicitly checks that ``print $pc'' with no registers prints "No
1519 if (!target_has_registers
)
1520 error (_("No registers."));
1521 if (!target_has_stack
)
1522 error (_("No stack."));
1523 if (!target_has_memory
)
1524 error (_("No memory."));
1525 /* Traceframes are effectively a substitute for the live inferior. */
1526 if (get_traceframe_number () < 0)
1527 validate_registers_access ();
1529 if (current_frame
== NULL
)
1532 struct frame_info
*sentinel_frame
=
1533 create_sentinel_frame (current_program_space
, get_current_regcache ());
1535 /* Set the current frame before computing the frame id, to avoid
1536 recursion inside compute_frame_id, in case the frame's
1537 unwinder decides to do a symbol lookup (which depends on the
1538 selected frame's block).
1540 This call must always succeed. In particular, nothing inside
1541 get_prev_frame_always_1 should try to unwind from the
1542 sentinel frame, because that could fail/throw, and we always
1543 want to leave with the current frame created and linked in --
1544 we should never end up with the sentinel frame as outermost
1546 current_frame
= get_prev_frame_always_1 (sentinel_frame
);
1547 gdb_assert (current_frame
!= NULL
);
1549 /* No need to compute the frame id yet. That'll be done lazily
1550 from inside get_frame_id instead. */
1553 return current_frame
;
1556 /* The "selected" stack frame is used by default for local and arg
1557 access. May be zero, for no selected frame. */
1559 static struct frame_info
*selected_frame
;
1562 has_stack_frames (void)
1564 if (!target_has_registers
|| !target_has_stack
|| !target_has_memory
)
1567 /* Traceframes are effectively a substitute for the live inferior. */
1568 if (get_traceframe_number () < 0)
1570 /* No current inferior, no frame. */
1571 if (ptid_equal (inferior_ptid
, null_ptid
))
1574 /* Don't try to read from a dead thread. */
1575 if (is_exited (inferior_ptid
))
1578 /* ... or from a spinning thread. */
1579 if (is_executing (inferior_ptid
))
1586 /* Return the selected frame. Always non-NULL (unless there isn't an
1587 inferior sufficient for creating a frame) in which case an error is
1591 get_selected_frame (const char *message
)
1593 if (selected_frame
== NULL
)
1595 if (message
!= NULL
&& !has_stack_frames ())
1596 error (("%s"), message
);
1597 /* Hey! Don't trust this. It should really be re-finding the
1598 last selected frame of the currently selected thread. This,
1599 though, is better than nothing. */
1600 select_frame (get_current_frame ());
1602 /* There is always a frame. */
1603 gdb_assert (selected_frame
!= NULL
);
1604 return selected_frame
;
1607 /* If there is a selected frame, return it. Otherwise, return NULL. */
1610 get_selected_frame_if_set (void)
1612 return selected_frame
;
1615 /* This is a variant of get_selected_frame() which can be called when
1616 the inferior does not have a frame; in that case it will return
1617 NULL instead of calling error(). */
1620 deprecated_safe_get_selected_frame (void)
1622 if (!has_stack_frames ())
1624 return get_selected_frame (NULL
);
1627 /* Select frame FI (or NULL - to invalidate the current frame). */
1630 select_frame (struct frame_info
*fi
)
1632 selected_frame
= fi
;
1633 /* NOTE: cagney/2002-05-04: FI can be NULL. This occurs when the
1634 frame is being invalidated. */
1636 /* FIXME: kseitz/2002-08-28: It would be nice to call
1637 selected_frame_level_changed_event() right here, but due to limitations
1638 in the current interfaces, we would end up flooding UIs with events
1639 because select_frame() is used extensively internally.
1641 Once we have frame-parameterized frame (and frame-related) commands,
1642 the event notification can be moved here, since this function will only
1643 be called when the user's selected frame is being changed. */
1645 /* Ensure that symbols for this frame are read in. Also, determine the
1646 source language of this frame, and switch to it if desired. */
1651 /* We retrieve the frame's symtab by using the frame PC.
1652 However we cannot use the frame PC as-is, because it usually
1653 points to the instruction following the "call", which is
1654 sometimes the first instruction of another function. So we
1655 rely on get_frame_address_in_block() which provides us with a
1656 PC which is guaranteed to be inside the frame's code
1658 if (get_frame_address_in_block_if_available (fi
, &pc
))
1660 struct compunit_symtab
*cust
= find_pc_compunit_symtab (pc
);
1663 && compunit_language (cust
) != current_language
->la_language
1664 && compunit_language (cust
) != language_unknown
1665 && language_mode
== language_mode_auto
)
1666 set_language (compunit_language (cust
));
1671 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
1672 Always returns a non-NULL value. */
1675 create_new_frame (CORE_ADDR addr
, CORE_ADDR pc
)
1677 struct frame_info
*fi
;
1681 fprintf_unfiltered (gdb_stdlog
,
1682 "{ create_new_frame (addr=%s, pc=%s) ",
1683 hex_string (addr
), hex_string (pc
));
1686 fi
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1688 fi
->next
= create_sentinel_frame (current_program_space
,
1689 get_current_regcache ());
1691 /* Set/update this frame's cached PC value, found in the next frame.
1692 Do this before looking for this frame's unwinder. A sniffer is
1693 very likely to read this, and the corresponding unwinder is
1694 entitled to rely that the PC doesn't magically change. */
1695 fi
->next
->prev_pc
.value
= pc
;
1696 fi
->next
->prev_pc
.status
= CC_VALUE
;
1698 /* We currently assume that frame chain's can't cross spaces. */
1699 fi
->pspace
= fi
->next
->pspace
;
1700 fi
->aspace
= fi
->next
->aspace
;
1702 /* Select/initialize both the unwind function and the frame's type
1704 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
1707 fi
->this_id
.value
= frame_id_build (addr
, pc
);
1711 fprintf_unfiltered (gdb_stdlog
, "-> ");
1712 fprint_frame (gdb_stdlog
, fi
);
1713 fprintf_unfiltered (gdb_stdlog
, " }\n");
1719 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
1720 innermost frame). Be careful to not fall off the bottom of the
1721 frame chain and onto the sentinel frame. */
1724 get_next_frame (struct frame_info
*this_frame
)
1726 if (this_frame
->level
> 0)
1727 return this_frame
->next
;
1732 /* Observer for the target_changed event. */
1735 frame_observer_target_changed (struct target_ops
*target
)
1737 reinit_frame_cache ();
1740 /* Flush the entire frame cache. */
1743 reinit_frame_cache (void)
1745 struct frame_info
*fi
;
1747 /* Tear down all frame caches. */
1748 for (fi
= current_frame
; fi
!= NULL
; fi
= fi
->prev
)
1750 if (fi
->prologue_cache
&& fi
->unwind
->dealloc_cache
)
1751 fi
->unwind
->dealloc_cache (fi
, fi
->prologue_cache
);
1752 if (fi
->base_cache
&& fi
->base
->unwind
->dealloc_cache
)
1753 fi
->base
->unwind
->dealloc_cache (fi
, fi
->base_cache
);
1756 /* Since we can't really be sure what the first object allocated was. */
1757 obstack_free (&frame_cache_obstack
, 0);
1758 obstack_init (&frame_cache_obstack
);
1760 if (current_frame
!= NULL
)
1761 annotate_frames_invalid ();
1763 current_frame
= NULL
; /* Invalidate cache */
1764 select_frame (NULL
);
1765 frame_stash_invalidate ();
1767 fprintf_unfiltered (gdb_stdlog
, "{ reinit_frame_cache () }\n");
1770 /* Find where a register is saved (in memory or another register).
1771 The result of frame_register_unwind is just where it is saved
1772 relative to this particular frame. */
1775 frame_register_unwind_location (struct frame_info
*this_frame
, int regnum
,
1776 int *optimizedp
, enum lval_type
*lvalp
,
1777 CORE_ADDR
*addrp
, int *realnump
)
1779 gdb_assert (this_frame
== NULL
|| this_frame
->level
>= 0);
1781 while (this_frame
!= NULL
)
1785 frame_register_unwind (this_frame
, regnum
, optimizedp
, &unavailable
,
1786 lvalp
, addrp
, realnump
, NULL
);
1791 if (*lvalp
!= lval_register
)
1795 this_frame
= get_next_frame (this_frame
);
1799 /* Called during frame unwinding to remove a previous frame pointer from a
1800 frame passed in ARG. */
1803 remove_prev_frame (void *arg
)
1805 struct frame_info
*this_frame
, *prev_frame
;
1807 this_frame
= (struct frame_info
*) arg
;
1808 prev_frame
= this_frame
->prev
;
1809 gdb_assert (prev_frame
!= NULL
);
1811 prev_frame
->next
= NULL
;
1812 this_frame
->prev
= NULL
;
1815 /* Get the previous raw frame, and check that it is not identical to
1816 same other frame frame already in the chain. If it is, there is
1817 most likely a stack cycle, so we discard it, and mark THIS_FRAME as
1818 outermost, with UNWIND_SAME_ID stop reason. Unlike the other
1819 validity tests, that compare THIS_FRAME and the next frame, we do
1820 this right after creating the previous frame, to avoid ever ending
1821 up with two frames with the same id in the frame chain. */
1823 static struct frame_info
*
1824 get_prev_frame_if_no_cycle (struct frame_info
*this_frame
)
1826 struct frame_info
*prev_frame
;
1827 struct cleanup
*prev_frame_cleanup
;
1829 prev_frame
= get_prev_frame_raw (this_frame
);
1831 /* Don't compute the frame id of the current frame yet. Unwinding
1832 the sentinel frame can fail (e.g., if the thread is gone and we
1833 can't thus read its registers). If we let the cycle detection
1834 code below try to compute a frame ID, then an error thrown from
1835 within the frame ID computation would result in the sentinel
1836 frame as outermost frame, which is bogus. Instead, we'll compute
1837 the current frame's ID lazily in get_frame_id. Note that there's
1838 no point in doing cycle detection when there's only one frame, so
1839 nothing is lost here. */
1840 if (prev_frame
->level
== 0)
1843 /* The cleanup will remove the previous frame that get_prev_frame_raw
1844 linked onto THIS_FRAME. */
1845 prev_frame_cleanup
= make_cleanup (remove_prev_frame
, this_frame
);
1847 compute_frame_id (prev_frame
);
1848 if (!frame_stash_add (prev_frame
))
1850 /* Another frame with the same id was already in the stash. We just
1851 detected a cycle. */
1854 fprintf_unfiltered (gdb_stdlog
, "-> ");
1855 fprint_frame (gdb_stdlog
, NULL
);
1856 fprintf_unfiltered (gdb_stdlog
, " // this frame has same ID }\n");
1858 this_frame
->stop_reason
= UNWIND_SAME_ID
;
1860 prev_frame
->next
= NULL
;
1861 this_frame
->prev
= NULL
;
1865 discard_cleanups (prev_frame_cleanup
);
1869 /* Helper function for get_prev_frame_always, this is called inside a
1870 TRY_CATCH block. Return the frame that called THIS_FRAME or NULL if
1871 there is no such frame. This may throw an exception. */
1873 static struct frame_info
*
1874 get_prev_frame_always_1 (struct frame_info
*this_frame
)
1876 struct gdbarch
*gdbarch
;
1878 gdb_assert (this_frame
!= NULL
);
1879 gdbarch
= get_frame_arch (this_frame
);
1883 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame_always (this_frame=");
1884 if (this_frame
!= NULL
)
1885 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1887 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1888 fprintf_unfiltered (gdb_stdlog
, ") ");
1891 /* Only try to do the unwind once. */
1892 if (this_frame
->prev_p
)
1896 fprintf_unfiltered (gdb_stdlog
, "-> ");
1897 fprint_frame (gdb_stdlog
, this_frame
->prev
);
1898 fprintf_unfiltered (gdb_stdlog
, " // cached \n");
1900 return this_frame
->prev
;
1903 /* If the frame unwinder hasn't been selected yet, we must do so
1904 before setting prev_p; otherwise the check for misbehaved
1905 sniffers will think that this frame's sniffer tried to unwind
1906 further (see frame_cleanup_after_sniffer). */
1907 if (this_frame
->unwind
== NULL
)
1908 frame_unwind_find_by_frame (this_frame
, &this_frame
->prologue_cache
);
1910 this_frame
->prev_p
= 1;
1911 this_frame
->stop_reason
= UNWIND_NO_REASON
;
1913 /* If we are unwinding from an inline frame, all of the below tests
1914 were already performed when we unwound from the next non-inline
1915 frame. We must skip them, since we can not get THIS_FRAME's ID
1916 until we have unwound all the way down to the previous non-inline
1918 if (get_frame_type (this_frame
) == INLINE_FRAME
)
1919 return get_prev_frame_if_no_cycle (this_frame
);
1921 /* Check that this frame is unwindable. If it isn't, don't try to
1922 unwind to the prev frame. */
1923 this_frame
->stop_reason
1924 = this_frame
->unwind
->stop_reason (this_frame
,
1925 &this_frame
->prologue_cache
);
1927 if (this_frame
->stop_reason
!= UNWIND_NO_REASON
)
1931 enum unwind_stop_reason reason
= this_frame
->stop_reason
;
1933 fprintf_unfiltered (gdb_stdlog
, "-> ");
1934 fprint_frame (gdb_stdlog
, NULL
);
1935 fprintf_unfiltered (gdb_stdlog
, " // %s }\n",
1936 frame_stop_reason_symbol_string (reason
));
1941 /* Check that this frame's ID isn't inner to (younger, below, next)
1942 the next frame. This happens when a frame unwind goes backwards.
1943 This check is valid only if this frame and the next frame are NORMAL.
1944 See the comment at frame_id_inner for details. */
1945 if (get_frame_type (this_frame
) == NORMAL_FRAME
1946 && this_frame
->next
->unwind
->type
== NORMAL_FRAME
1947 && frame_id_inner (get_frame_arch (this_frame
->next
),
1948 get_frame_id (this_frame
),
1949 get_frame_id (this_frame
->next
)))
1951 CORE_ADDR this_pc_in_block
;
1952 struct minimal_symbol
*morestack_msym
;
1953 const char *morestack_name
= NULL
;
1955 /* gcc -fsplit-stack __morestack can continue the stack anywhere. */
1956 this_pc_in_block
= get_frame_address_in_block (this_frame
);
1957 morestack_msym
= lookup_minimal_symbol_by_pc (this_pc_in_block
).minsym
;
1959 morestack_name
= MSYMBOL_LINKAGE_NAME (morestack_msym
);
1960 if (!morestack_name
|| strcmp (morestack_name
, "__morestack") != 0)
1964 fprintf_unfiltered (gdb_stdlog
, "-> ");
1965 fprint_frame (gdb_stdlog
, NULL
);
1966 fprintf_unfiltered (gdb_stdlog
,
1967 " // this frame ID is inner }\n");
1969 this_frame
->stop_reason
= UNWIND_INNER_ID
;
1974 /* Check that this and the next frame do not unwind the PC register
1975 to the same memory location. If they do, then even though they
1976 have different frame IDs, the new frame will be bogus; two
1977 functions can't share a register save slot for the PC. This can
1978 happen when the prologue analyzer finds a stack adjustment, but
1981 This check does assume that the "PC register" is roughly a
1982 traditional PC, even if the gdbarch_unwind_pc method adjusts
1983 it (we do not rely on the value, only on the unwound PC being
1984 dependent on this value). A potential improvement would be
1985 to have the frame prev_pc method and the gdbarch unwind_pc
1986 method set the same lval and location information as
1987 frame_register_unwind. */
1988 if (this_frame
->level
> 0
1989 && gdbarch_pc_regnum (gdbarch
) >= 0
1990 && get_frame_type (this_frame
) == NORMAL_FRAME
1991 && (get_frame_type (this_frame
->next
) == NORMAL_FRAME
1992 || get_frame_type (this_frame
->next
) == INLINE_FRAME
))
1994 int optimized
, realnum
, nrealnum
;
1995 enum lval_type lval
, nlval
;
1996 CORE_ADDR addr
, naddr
;
1998 frame_register_unwind_location (this_frame
,
1999 gdbarch_pc_regnum (gdbarch
),
2000 &optimized
, &lval
, &addr
, &realnum
);
2001 frame_register_unwind_location (get_next_frame (this_frame
),
2002 gdbarch_pc_regnum (gdbarch
),
2003 &optimized
, &nlval
, &naddr
, &nrealnum
);
2005 if ((lval
== lval_memory
&& lval
== nlval
&& addr
== naddr
)
2006 || (lval
== lval_register
&& lval
== nlval
&& realnum
== nrealnum
))
2010 fprintf_unfiltered (gdb_stdlog
, "-> ");
2011 fprint_frame (gdb_stdlog
, NULL
);
2012 fprintf_unfiltered (gdb_stdlog
, " // no saved PC }\n");
2015 this_frame
->stop_reason
= UNWIND_NO_SAVED_PC
;
2016 this_frame
->prev
= NULL
;
2021 return get_prev_frame_if_no_cycle (this_frame
);
2024 /* Return a "struct frame_info" corresponding to the frame that called
2025 THIS_FRAME. Returns NULL if there is no such frame.
2027 Unlike get_prev_frame, this function always tries to unwind the
2031 get_prev_frame_always (struct frame_info
*this_frame
)
2033 struct frame_info
*prev_frame
= NULL
;
2037 prev_frame
= get_prev_frame_always_1 (this_frame
);
2039 CATCH (ex
, RETURN_MASK_ERROR
)
2041 if (ex
.error
== MEMORY_ERROR
)
2043 this_frame
->stop_reason
= UNWIND_MEMORY_ERROR
;
2044 if (ex
.message
!= NULL
)
2049 /* The error needs to live as long as the frame does.
2050 Allocate using stack local STOP_STRING then assign the
2051 pointer to the frame, this allows the STOP_STRING on the
2052 frame to be of type 'const char *'. */
2053 size
= strlen (ex
.message
) + 1;
2054 stop_string
= (char *) frame_obstack_zalloc (size
);
2055 memcpy (stop_string
, ex
.message
, size
);
2056 this_frame
->stop_string
= stop_string
;
2061 throw_exception (ex
);
2068 /* Construct a new "struct frame_info" and link it previous to
2071 static struct frame_info
*
2072 get_prev_frame_raw (struct frame_info
*this_frame
)
2074 struct frame_info
*prev_frame
;
2076 /* Allocate the new frame but do not wire it in to the frame chain.
2077 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
2078 frame->next to pull some fancy tricks (of course such code is, by
2079 definition, recursive). Try to prevent it.
2081 There is no reason to worry about memory leaks, should the
2082 remainder of the function fail. The allocated memory will be
2083 quickly reclaimed when the frame cache is flushed, and the `we've
2084 been here before' check above will stop repeated memory
2085 allocation calls. */
2086 prev_frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
2087 prev_frame
->level
= this_frame
->level
+ 1;
2089 /* For now, assume we don't have frame chains crossing address
2091 prev_frame
->pspace
= this_frame
->pspace
;
2092 prev_frame
->aspace
= this_frame
->aspace
;
2094 /* Don't yet compute ->unwind (and hence ->type). It is computed
2095 on-demand in get_frame_type, frame_register_unwind, and
2098 /* Don't yet compute the frame's ID. It is computed on-demand by
2101 /* The unwound frame ID is validate at the start of this function,
2102 as part of the logic to decide if that frame should be further
2103 unwound, and not here while the prev frame is being created.
2104 Doing this makes it possible for the user to examine a frame that
2105 has an invalid frame ID.
2107 Some very old VAX code noted: [...] For the sake of argument,
2108 suppose that the stack is somewhat trashed (which is one reason
2109 that "info frame" exists). So, return 0 (indicating we don't
2110 know the address of the arglist) if we don't know what frame this
2114 this_frame
->prev
= prev_frame
;
2115 prev_frame
->next
= this_frame
;
2119 fprintf_unfiltered (gdb_stdlog
, "-> ");
2120 fprint_frame (gdb_stdlog
, prev_frame
);
2121 fprintf_unfiltered (gdb_stdlog
, " }\n");
2127 /* Debug routine to print a NULL frame being returned. */
2130 frame_debug_got_null_frame (struct frame_info
*this_frame
,
2135 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame (this_frame=");
2136 if (this_frame
!= NULL
)
2137 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
2139 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
2140 fprintf_unfiltered (gdb_stdlog
, ") -> // %s}\n", reason
);
2144 /* Is this (non-sentinel) frame in the "main"() function? */
2147 inside_main_func (struct frame_info
*this_frame
)
2149 struct bound_minimal_symbol msymbol
;
2152 if (symfile_objfile
== 0)
2154 msymbol
= lookup_minimal_symbol (main_name (), NULL
, symfile_objfile
);
2155 if (msymbol
.minsym
== NULL
)
2157 /* Make certain that the code, and not descriptor, address is
2159 maddr
= gdbarch_convert_from_func_ptr_addr (get_frame_arch (this_frame
),
2160 BMSYMBOL_VALUE_ADDRESS (msymbol
),
2162 return maddr
== get_frame_func (this_frame
);
2165 /* Test whether THIS_FRAME is inside the process entry point function. */
2168 inside_entry_func (struct frame_info
*this_frame
)
2170 CORE_ADDR entry_point
;
2172 if (!entry_point_address_query (&entry_point
))
2175 return get_frame_func (this_frame
) == entry_point
;
2178 /* Return a structure containing various interesting information about
2179 the frame that called THIS_FRAME. Returns NULL if there is entier
2180 no such frame or the frame fails any of a set of target-independent
2181 condition that should terminate the frame chain (e.g., as unwinding
2184 This function should not contain target-dependent tests, such as
2185 checking whether the program-counter is zero. */
2188 get_prev_frame (struct frame_info
*this_frame
)
2193 /* There is always a frame. If this assertion fails, suspect that
2194 something should be calling get_selected_frame() or
2195 get_current_frame(). */
2196 gdb_assert (this_frame
!= NULL
);
2197 frame_pc_p
= get_frame_pc_if_available (this_frame
, &frame_pc
);
2199 /* tausq/2004-12-07: Dummy frames are skipped because it doesn't make much
2200 sense to stop unwinding at a dummy frame. One place where a dummy
2201 frame may have an address "inside_main_func" is on HPUX. On HPUX, the
2202 pcsqh register (space register for the instruction at the head of the
2203 instruction queue) cannot be written directly; the only way to set it
2204 is to branch to code that is in the target space. In order to implement
2205 frame dummies on HPUX, the called function is made to jump back to where
2206 the inferior was when the user function was called. If gdb was inside
2207 the main function when we created the dummy frame, the dummy frame will
2208 point inside the main function. */
2209 if (this_frame
->level
>= 0
2210 && get_frame_type (this_frame
) == NORMAL_FRAME
2211 && !backtrace_past_main
2213 && inside_main_func (this_frame
))
2214 /* Don't unwind past main(). Note, this is done _before_ the
2215 frame has been marked as previously unwound. That way if the
2216 user later decides to enable unwinds past main(), that will
2217 automatically happen. */
2219 frame_debug_got_null_frame (this_frame
, "inside main func");
2223 /* If the user's backtrace limit has been exceeded, stop. We must
2224 add two to the current level; one of those accounts for backtrace_limit
2225 being 1-based and the level being 0-based, and the other accounts for
2226 the level of the new frame instead of the level of the current
2228 if (this_frame
->level
+ 2 > backtrace_limit
)
2230 frame_debug_got_null_frame (this_frame
, "backtrace limit exceeded");
2234 /* If we're already inside the entry function for the main objfile,
2235 then it isn't valid. Don't apply this test to a dummy frame -
2236 dummy frame PCs typically land in the entry func. Don't apply
2237 this test to the sentinel frame. Sentinel frames should always
2238 be allowed to unwind. */
2239 /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() -
2240 wasn't checking for "main" in the minimal symbols. With that
2241 fixed asm-source tests now stop in "main" instead of halting the
2242 backtrace in weird and wonderful ways somewhere inside the entry
2243 file. Suspect that tests for inside the entry file/func were
2244 added to work around that (now fixed) case. */
2245 /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
2246 suggested having the inside_entry_func test use the
2247 inside_main_func() msymbol trick (along with entry_point_address()
2248 I guess) to determine the address range of the start function.
2249 That should provide a far better stopper than the current
2251 /* NOTE: tausq/2004-10-09: this is needed if, for example, the compiler
2252 applied tail-call optimizations to main so that a function called
2253 from main returns directly to the caller of main. Since we don't
2254 stop at main, we should at least stop at the entry point of the
2256 if (this_frame
->level
>= 0
2257 && get_frame_type (this_frame
) == NORMAL_FRAME
2258 && !backtrace_past_entry
2260 && inside_entry_func (this_frame
))
2262 frame_debug_got_null_frame (this_frame
, "inside entry func");
2266 /* Assume that the only way to get a zero PC is through something
2267 like a SIGSEGV or a dummy frame, and hence that NORMAL frames
2268 will never unwind a zero PC. */
2269 if (this_frame
->level
> 0
2270 && (get_frame_type (this_frame
) == NORMAL_FRAME
2271 || get_frame_type (this_frame
) == INLINE_FRAME
)
2272 && get_frame_type (get_next_frame (this_frame
)) == NORMAL_FRAME
2273 && frame_pc_p
&& frame_pc
== 0)
2275 frame_debug_got_null_frame (this_frame
, "zero PC");
2279 return get_prev_frame_always (this_frame
);
2283 get_frame_pc (struct frame_info
*frame
)
2285 gdb_assert (frame
->next
!= NULL
);
2286 return frame_unwind_pc (frame
->next
);
2290 get_frame_pc_if_available (struct frame_info
*frame
, CORE_ADDR
*pc
)
2293 gdb_assert (frame
->next
!= NULL
);
2297 *pc
= frame_unwind_pc (frame
->next
);
2299 CATCH (ex
, RETURN_MASK_ERROR
)
2301 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2304 throw_exception (ex
);
2311 /* Return an address that falls within THIS_FRAME's code block. */
2314 get_frame_address_in_block (struct frame_info
*this_frame
)
2316 /* A draft address. */
2317 CORE_ADDR pc
= get_frame_pc (this_frame
);
2319 struct frame_info
*next_frame
= this_frame
->next
;
2321 /* Calling get_frame_pc returns the resume address for THIS_FRAME.
2322 Normally the resume address is inside the body of the function
2323 associated with THIS_FRAME, but there is a special case: when
2324 calling a function which the compiler knows will never return
2325 (for instance abort), the call may be the very last instruction
2326 in the calling function. The resume address will point after the
2327 call and may be at the beginning of a different function
2330 If THIS_FRAME is a signal frame or dummy frame, then we should
2331 not adjust the unwound PC. For a dummy frame, GDB pushed the
2332 resume address manually onto the stack. For a signal frame, the
2333 OS may have pushed the resume address manually and invoked the
2334 handler (e.g. GNU/Linux), or invoked the trampoline which called
2335 the signal handler - but in either case the signal handler is
2336 expected to return to the trampoline. So in both of these
2337 cases we know that the resume address is executable and
2338 related. So we only need to adjust the PC if THIS_FRAME
2339 is a normal function.
2341 If the program has been interrupted while THIS_FRAME is current,
2342 then clearly the resume address is inside the associated
2343 function. There are three kinds of interruption: debugger stop
2344 (next frame will be SENTINEL_FRAME), operating system
2345 signal or exception (next frame will be SIGTRAMP_FRAME),
2346 or debugger-induced function call (next frame will be
2347 DUMMY_FRAME). So we only need to adjust the PC if
2348 NEXT_FRAME is a normal function.
2350 We check the type of NEXT_FRAME first, since it is already
2351 known; frame type is determined by the unwinder, and since
2352 we have THIS_FRAME we've already selected an unwinder for
2355 If the next frame is inlined, we need to keep going until we find
2356 the real function - for instance, if a signal handler is invoked
2357 while in an inlined function, then the code address of the
2358 "calling" normal function should not be adjusted either. */
2360 while (get_frame_type (next_frame
) == INLINE_FRAME
)
2361 next_frame
= next_frame
->next
;
2363 if ((get_frame_type (next_frame
) == NORMAL_FRAME
2364 || get_frame_type (next_frame
) == TAILCALL_FRAME
)
2365 && (get_frame_type (this_frame
) == NORMAL_FRAME
2366 || get_frame_type (this_frame
) == TAILCALL_FRAME
2367 || get_frame_type (this_frame
) == INLINE_FRAME
))
2374 get_frame_address_in_block_if_available (struct frame_info
*this_frame
,
2380 *pc
= get_frame_address_in_block (this_frame
);
2382 CATCH (ex
, RETURN_MASK_ERROR
)
2384 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2386 throw_exception (ex
);
2394 find_frame_sal (struct frame_info
*frame
, struct symtab_and_line
*sal
)
2396 struct frame_info
*next_frame
;
2400 /* If the next frame represents an inlined function call, this frame's
2401 sal is the "call site" of that inlined function, which can not
2402 be inferred from get_frame_pc. */
2403 next_frame
= get_next_frame (frame
);
2404 if (frame_inlined_callees (frame
) > 0)
2409 sym
= get_frame_function (next_frame
);
2411 sym
= inline_skipped_symbol (inferior_ptid
);
2413 /* If frame is inline, it certainly has symbols. */
2416 if (SYMBOL_LINE (sym
) != 0)
2418 sal
->symtab
= symbol_symtab (sym
);
2419 sal
->line
= SYMBOL_LINE (sym
);
2422 /* If the symbol does not have a location, we don't know where
2423 the call site is. Do not pretend to. This is jarring, but
2424 we can't do much better. */
2425 sal
->pc
= get_frame_pc (frame
);
2427 sal
->pspace
= get_frame_program_space (frame
);
2432 /* If FRAME is not the innermost frame, that normally means that
2433 FRAME->pc points at the return instruction (which is *after* the
2434 call instruction), and we want to get the line containing the
2435 call (because the call is where the user thinks the program is).
2436 However, if the next frame is either a SIGTRAMP_FRAME or a
2437 DUMMY_FRAME, then the next frame will contain a saved interrupt
2438 PC and such a PC indicates the current (rather than next)
2439 instruction/line, consequently, for such cases, want to get the
2440 line containing fi->pc. */
2441 if (!get_frame_pc_if_available (frame
, &pc
))
2447 notcurrent
= (pc
!= get_frame_address_in_block (frame
));
2448 (*sal
) = find_pc_line (pc
, notcurrent
);
2451 /* Per "frame.h", return the ``address'' of the frame. Code should
2452 really be using get_frame_id(). */
2454 get_frame_base (struct frame_info
*fi
)
2456 return get_frame_id (fi
).stack_addr
;
2459 /* High-level offsets into the frame. Used by the debug info. */
2462 get_frame_base_address (struct frame_info
*fi
)
2464 if (get_frame_type (fi
) != NORMAL_FRAME
)
2466 if (fi
->base
== NULL
)
2467 fi
->base
= frame_base_find_by_frame (fi
);
2468 /* Sneaky: If the low-level unwind and high-level base code share a
2469 common unwinder, let them share the prologue cache. */
2470 if (fi
->base
->unwind
== fi
->unwind
)
2471 return fi
->base
->this_base (fi
, &fi
->prologue_cache
);
2472 return fi
->base
->this_base (fi
, &fi
->base_cache
);
2476 get_frame_locals_address (struct frame_info
*fi
)
2478 if (get_frame_type (fi
) != NORMAL_FRAME
)
2480 /* If there isn't a frame address method, find it. */
2481 if (fi
->base
== NULL
)
2482 fi
->base
= frame_base_find_by_frame (fi
);
2483 /* Sneaky: If the low-level unwind and high-level base code share a
2484 common unwinder, let them share the prologue cache. */
2485 if (fi
->base
->unwind
== fi
->unwind
)
2486 return fi
->base
->this_locals (fi
, &fi
->prologue_cache
);
2487 return fi
->base
->this_locals (fi
, &fi
->base_cache
);
2491 get_frame_args_address (struct frame_info
*fi
)
2493 if (get_frame_type (fi
) != NORMAL_FRAME
)
2495 /* If there isn't a frame address method, find it. */
2496 if (fi
->base
== NULL
)
2497 fi
->base
= frame_base_find_by_frame (fi
);
2498 /* Sneaky: If the low-level unwind and high-level base code share a
2499 common unwinder, let them share the prologue cache. */
2500 if (fi
->base
->unwind
== fi
->unwind
)
2501 return fi
->base
->this_args (fi
, &fi
->prologue_cache
);
2502 return fi
->base
->this_args (fi
, &fi
->base_cache
);
2505 /* Return true if the frame unwinder for frame FI is UNWINDER; false
2509 frame_unwinder_is (struct frame_info
*fi
, const struct frame_unwind
*unwinder
)
2511 if (fi
->unwind
== NULL
)
2512 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
2513 return fi
->unwind
== unwinder
;
2516 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
2517 or -1 for a NULL frame. */
2520 frame_relative_level (struct frame_info
*fi
)
2529 get_frame_type (struct frame_info
*frame
)
2531 if (frame
->unwind
== NULL
)
2532 /* Initialize the frame's unwinder because that's what
2533 provides the frame's type. */
2534 frame_unwind_find_by_frame (frame
, &frame
->prologue_cache
);
2535 return frame
->unwind
->type
;
2538 struct program_space
*
2539 get_frame_program_space (struct frame_info
*frame
)
2541 return frame
->pspace
;
2544 struct program_space
*
2545 frame_unwind_program_space (struct frame_info
*this_frame
)
2547 gdb_assert (this_frame
);
2549 /* This is really a placeholder to keep the API consistent --- we
2550 assume for now that we don't have frame chains crossing
2552 return this_frame
->pspace
;
2555 struct address_space
*
2556 get_frame_address_space (struct frame_info
*frame
)
2558 return frame
->aspace
;
2561 /* Memory access methods. */
2564 get_frame_memory (struct frame_info
*this_frame
, CORE_ADDR addr
,
2565 gdb_byte
*buf
, int len
)
2567 read_memory (addr
, buf
, len
);
2571 get_frame_memory_signed (struct frame_info
*this_frame
, CORE_ADDR addr
,
2574 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2575 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2577 return read_memory_integer (addr
, len
, byte_order
);
2581 get_frame_memory_unsigned (struct frame_info
*this_frame
, CORE_ADDR addr
,
2584 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2585 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2587 return read_memory_unsigned_integer (addr
, len
, byte_order
);
2591 safe_frame_unwind_memory (struct frame_info
*this_frame
,
2592 CORE_ADDR addr
, gdb_byte
*buf
, int len
)
2594 /* NOTE: target_read_memory returns zero on success! */
2595 return !target_read_memory (addr
, buf
, len
);
2598 /* Architecture methods. */
2601 get_frame_arch (struct frame_info
*this_frame
)
2603 return frame_unwind_arch (this_frame
->next
);
2607 frame_unwind_arch (struct frame_info
*next_frame
)
2609 if (!next_frame
->prev_arch
.p
)
2611 struct gdbarch
*arch
;
2613 if (next_frame
->unwind
== NULL
)
2614 frame_unwind_find_by_frame (next_frame
, &next_frame
->prologue_cache
);
2616 if (next_frame
->unwind
->prev_arch
!= NULL
)
2617 arch
= next_frame
->unwind
->prev_arch (next_frame
,
2618 &next_frame
->prologue_cache
);
2620 arch
= get_frame_arch (next_frame
);
2622 next_frame
->prev_arch
.arch
= arch
;
2623 next_frame
->prev_arch
.p
= 1;
2625 fprintf_unfiltered (gdb_stdlog
,
2626 "{ frame_unwind_arch (next_frame=%d) -> %s }\n",
2628 gdbarch_bfd_arch_info (arch
)->printable_name
);
2631 return next_frame
->prev_arch
.arch
;
2635 frame_unwind_caller_arch (struct frame_info
*next_frame
)
2637 next_frame
= skip_artificial_frames (next_frame
);
2639 /* We must have a non-artificial frame. The caller is supposed to check
2640 the result of frame_unwind_caller_id (), which returns NULL_FRAME_ID
2642 gdb_assert (next_frame
!= NULL
);
2644 return frame_unwind_arch (next_frame
);
2647 /* Gets the language of FRAME. */
2650 get_frame_language (struct frame_info
*frame
)
2655 gdb_assert (frame
!= NULL
);
2657 /* We determine the current frame language by looking up its
2658 associated symtab. To retrieve this symtab, we use the frame
2659 PC. However we cannot use the frame PC as is, because it
2660 usually points to the instruction following the "call", which
2661 is sometimes the first instruction of another function. So
2662 we rely on get_frame_address_in_block(), it provides us with
2663 a PC that is guaranteed to be inside the frame's code
2668 pc
= get_frame_address_in_block (frame
);
2671 CATCH (ex
, RETURN_MASK_ERROR
)
2673 if (ex
.error
!= NOT_AVAILABLE_ERROR
)
2674 throw_exception (ex
);
2680 struct compunit_symtab
*cust
= find_pc_compunit_symtab (pc
);
2683 return compunit_language (cust
);
2686 return language_unknown
;
2689 /* Stack pointer methods. */
2692 get_frame_sp (struct frame_info
*this_frame
)
2694 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2696 /* Normality - an architecture that provides a way of obtaining any
2697 frame inner-most address. */
2698 if (gdbarch_unwind_sp_p (gdbarch
))
2699 /* NOTE drow/2008-06-28: gdbarch_unwind_sp could be converted to
2700 operate on THIS_FRAME now. */
2701 return gdbarch_unwind_sp (gdbarch
, this_frame
->next
);
2702 /* Now things are really are grim. Hope that the value returned by
2703 the gdbarch_sp_regnum register is meaningful. */
2704 if (gdbarch_sp_regnum (gdbarch
) >= 0)
2705 return get_frame_register_unsigned (this_frame
,
2706 gdbarch_sp_regnum (gdbarch
));
2707 internal_error (__FILE__
, __LINE__
, _("Missing unwind SP method"));
2710 /* Return the reason why we can't unwind past FRAME. */
2712 enum unwind_stop_reason
2713 get_frame_unwind_stop_reason (struct frame_info
*frame
)
2715 /* Fill-in STOP_REASON. */
2716 get_prev_frame_always (frame
);
2717 gdb_assert (frame
->prev_p
);
2719 return frame
->stop_reason
;
2722 /* Return a string explaining REASON. */
2725 unwind_stop_reason_to_string (enum unwind_stop_reason reason
)
2729 #define SET(name, description) \
2730 case name: return _(description);
2731 #include "unwind_stop_reasons.def"
2735 internal_error (__FILE__
, __LINE__
,
2736 "Invalid frame stop reason");
2741 frame_stop_reason_string (struct frame_info
*fi
)
2743 gdb_assert (fi
->prev_p
);
2744 gdb_assert (fi
->prev
== NULL
);
2746 /* Return the specific string if we have one. */
2747 if (fi
->stop_string
!= NULL
)
2748 return fi
->stop_string
;
2750 /* Return the generic string if we have nothing better. */
2751 return unwind_stop_reason_to_string (fi
->stop_reason
);
2754 /* Return the enum symbol name of REASON as a string, to use in debug
2758 frame_stop_reason_symbol_string (enum unwind_stop_reason reason
)
2762 #define SET(name, description) \
2763 case name: return #name;
2764 #include "unwind_stop_reasons.def"
2768 internal_error (__FILE__
, __LINE__
,
2769 "Invalid frame stop reason");
2773 /* Clean up after a failed (wrong unwinder) attempt to unwind past
2777 frame_cleanup_after_sniffer (void *arg
)
2779 struct frame_info
*frame
= (struct frame_info
*) arg
;
2781 /* The sniffer should not allocate a prologue cache if it did not
2782 match this frame. */
2783 gdb_assert (frame
->prologue_cache
== NULL
);
2785 /* No sniffer should extend the frame chain; sniff based on what is
2787 gdb_assert (!frame
->prev_p
);
2789 /* The sniffer should not check the frame's ID; that's circular. */
2790 gdb_assert (!frame
->this_id
.p
);
2792 /* Clear cached fields dependent on the unwinder.
2794 The previous PC is independent of the unwinder, but the previous
2795 function is not (see get_frame_address_in_block). */
2796 frame
->prev_func
.p
= 0;
2797 frame
->prev_func
.addr
= 0;
2799 /* Discard the unwinder last, so that we can easily find it if an assertion
2800 in this function triggers. */
2801 frame
->unwind
= NULL
;
2804 /* Set FRAME's unwinder temporarily, so that we can call a sniffer.
2805 Return a cleanup which should be called if unwinding fails, and
2806 discarded if it succeeds. */
2809 frame_prepare_for_sniffer (struct frame_info
*frame
,
2810 const struct frame_unwind
*unwind
)
2812 gdb_assert (frame
->unwind
== NULL
);
2813 frame
->unwind
= unwind
;
2814 return make_cleanup (frame_cleanup_after_sniffer
, frame
);
2817 extern initialize_file_ftype _initialize_frame
; /* -Wmissing-prototypes */
2819 static struct cmd_list_element
*set_backtrace_cmdlist
;
2820 static struct cmd_list_element
*show_backtrace_cmdlist
;
2823 set_backtrace_cmd (char *args
, int from_tty
)
2825 help_list (set_backtrace_cmdlist
, "set backtrace ", all_commands
,
2830 show_backtrace_cmd (char *args
, int from_tty
)
2832 cmd_show_list (show_backtrace_cmdlist
, from_tty
, "");
2836 _initialize_frame (void)
2838 obstack_init (&frame_cache_obstack
);
2840 frame_stash_create ();
2842 observer_attach_target_changed (frame_observer_target_changed
);
2844 add_prefix_cmd ("backtrace", class_maintenance
, set_backtrace_cmd
, _("\
2845 Set backtrace specific variables.\n\
2846 Configure backtrace variables such as the backtrace limit"),
2847 &set_backtrace_cmdlist
, "set backtrace ",
2848 0/*allow-unknown*/, &setlist
);
2849 add_prefix_cmd ("backtrace", class_maintenance
, show_backtrace_cmd
, _("\
2850 Show backtrace specific variables\n\
2851 Show backtrace variables such as the backtrace limit"),
2852 &show_backtrace_cmdlist
, "show backtrace ",
2853 0/*allow-unknown*/, &showlist
);
2855 add_setshow_boolean_cmd ("past-main", class_obscure
,
2856 &backtrace_past_main
, _("\
2857 Set whether backtraces should continue past \"main\"."), _("\
2858 Show whether backtraces should continue past \"main\"."), _("\
2859 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
2860 the backtrace at \"main\". Set this variable if you need to see the rest\n\
2861 of the stack trace."),
2863 show_backtrace_past_main
,
2864 &set_backtrace_cmdlist
,
2865 &show_backtrace_cmdlist
);
2867 add_setshow_boolean_cmd ("past-entry", class_obscure
,
2868 &backtrace_past_entry
, _("\
2869 Set whether backtraces should continue past the entry point of a program."),
2871 Show whether backtraces should continue past the entry point of a program."),
2873 Normally there are no callers beyond the entry point of a program, so GDB\n\
2874 will terminate the backtrace there. Set this variable if you need to see\n\
2875 the rest of the stack trace."),
2877 show_backtrace_past_entry
,
2878 &set_backtrace_cmdlist
,
2879 &show_backtrace_cmdlist
);
2881 add_setshow_uinteger_cmd ("limit", class_obscure
,
2882 &backtrace_limit
, _("\
2883 Set an upper bound on the number of backtrace levels."), _("\
2884 Show the upper bound on the number of backtrace levels."), _("\
2885 No more than the specified number of frames can be displayed or examined.\n\
2886 Literal \"unlimited\" or zero means no limit."),
2888 show_backtrace_limit
,
2889 &set_backtrace_cmdlist
,
2890 &show_backtrace_cmdlist
);
2892 /* Debug this files internals. */
2893 add_setshow_zuinteger_cmd ("frame", class_maintenance
, &frame_debug
, _("\
2894 Set frame debugging."), _("\
2895 Show frame debugging."), _("\
2896 When non-zero, frame specific internal debugging is enabled."),
2899 &setdebuglist
, &showdebuglist
);