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 the original frame if no immediate previous frames exist. */
425 static struct frame_info
*
426 skip_artificial_frames (struct frame_info
*frame
)
428 /* Note we use get_prev_frame_always, and not get_prev_frame. The
429 latter will truncate the frame chain, leading to this function
430 unintentionally returning a null_frame_id (e.g., when the user
431 sets a backtrace limit). This is safe, because as these frames
432 are made up by GDB, there must be a real frame in the chain
434 while (get_frame_type (frame
) == INLINE_FRAME
435 || get_frame_type (frame
) == TAILCALL_FRAME
)
436 frame
= get_prev_frame_always (frame
);
441 /* Compute the frame's uniq ID that can be used to, later, re-find the
445 compute_frame_id (struct frame_info
*fi
)
447 gdb_assert (!fi
->this_id
.p
);
450 fprintf_unfiltered (gdb_stdlog
, "{ compute_frame_id (fi=%d) ",
452 /* Find the unwinder. */
453 if (fi
->unwind
== NULL
)
454 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
455 /* Find THIS frame's ID. */
456 /* Default to outermost if no ID is found. */
457 fi
->this_id
.value
= outer_frame_id
;
458 fi
->unwind
->this_id (fi
, &fi
->prologue_cache
, &fi
->this_id
.value
);
459 gdb_assert (frame_id_p (fi
->this_id
.value
));
463 fprintf_unfiltered (gdb_stdlog
, "-> ");
464 fprint_frame_id (gdb_stdlog
, fi
->this_id
.value
);
465 fprintf_unfiltered (gdb_stdlog
, " }\n");
469 /* Return a frame uniq ID that can be used to, later, re-find the
473 get_frame_id (struct frame_info
*fi
)
476 return null_frame_id
;
478 gdb_assert (fi
->this_id
.p
);
479 return fi
->this_id
.value
;
483 get_stack_frame_id (struct frame_info
*next_frame
)
485 return get_frame_id (skip_artificial_frames (next_frame
));
489 frame_unwind_caller_id (struct frame_info
*next_frame
)
491 struct frame_info
*this_frame
;
493 /* Use get_prev_frame_always, and not get_prev_frame. The latter
494 will truncate the frame chain, leading to this function
495 unintentionally returning a null_frame_id (e.g., when a caller
496 requests the frame ID of "main()"s caller. */
498 next_frame
= skip_artificial_frames (next_frame
);
499 this_frame
= get_prev_frame_always (next_frame
);
501 return get_frame_id (skip_artificial_frames (this_frame
));
503 return null_frame_id
;
506 const struct frame_id null_frame_id
= { 0 }; /* All zeros. */
507 const struct frame_id outer_frame_id
= { 0, 0, 0, FID_STACK_INVALID
, 0, 1, 0 };
510 frame_id_build_special (CORE_ADDR stack_addr
, CORE_ADDR code_addr
,
511 CORE_ADDR special_addr
)
513 struct frame_id id
= null_frame_id
;
515 id
.stack_addr
= stack_addr
;
516 id
.stack_status
= FID_STACK_VALID
;
517 id
.code_addr
= code_addr
;
519 id
.special_addr
= special_addr
;
520 id
.special_addr_p
= 1;
527 frame_id_build_unavailable_stack (CORE_ADDR code_addr
)
529 struct frame_id id
= null_frame_id
;
531 id
.stack_status
= FID_STACK_UNAVAILABLE
;
532 id
.code_addr
= code_addr
;
540 frame_id_build_unavailable_stack_special (CORE_ADDR code_addr
,
541 CORE_ADDR special_addr
)
543 struct frame_id id
= null_frame_id
;
545 id
.stack_status
= FID_STACK_UNAVAILABLE
;
546 id
.code_addr
= code_addr
;
548 id
.special_addr
= special_addr
;
549 id
.special_addr_p
= 1;
554 frame_id_build (CORE_ADDR stack_addr
, CORE_ADDR code_addr
)
556 struct frame_id id
= null_frame_id
;
558 id
.stack_addr
= stack_addr
;
559 id
.stack_status
= FID_STACK_VALID
;
560 id
.code_addr
= code_addr
;
566 frame_id_build_wild (CORE_ADDR stack_addr
)
568 struct frame_id id
= null_frame_id
;
570 id
.stack_addr
= stack_addr
;
571 id
.stack_status
= FID_STACK_VALID
;
576 frame_id_p (struct frame_id l
)
580 /* The frame is valid iff it has a valid stack address. */
581 p
= l
.stack_status
!= FID_STACK_INVALID
;
582 /* outer_frame_id is also valid. */
583 if (!p
&& memcmp (&l
, &outer_frame_id
, sizeof (l
)) == 0)
587 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_p (l=");
588 fprint_frame_id (gdb_stdlog
, l
);
589 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", p
);
595 frame_id_artificial_p (struct frame_id l
)
600 return (l
.artificial_depth
!= 0);
604 frame_id_eq (struct frame_id l
, struct frame_id r
)
608 if (l
.stack_status
== FID_STACK_INVALID
&& l
.special_addr_p
609 && r
.stack_status
== FID_STACK_INVALID
&& r
.special_addr_p
)
610 /* The outermost frame marker is equal to itself. This is the
611 dodgy thing about outer_frame_id, since between execution steps
612 we might step into another function - from which we can't
613 unwind either. More thought required to get rid of
616 else if (l
.stack_status
== FID_STACK_INVALID
617 || r
.stack_status
== FID_STACK_INVALID
)
618 /* Like a NaN, if either ID is invalid, the result is false.
619 Note that a frame ID is invalid iff it is the null frame ID. */
621 else if (l
.stack_status
!= r
.stack_status
|| l
.stack_addr
!= r
.stack_addr
)
622 /* If .stack addresses are different, the frames are different. */
624 else if (l
.code_addr_p
&& r
.code_addr_p
&& l
.code_addr
!= r
.code_addr
)
625 /* An invalid code addr is a wild card. If .code addresses are
626 different, the frames are different. */
628 else if (l
.special_addr_p
&& r
.special_addr_p
629 && l
.special_addr
!= r
.special_addr
)
630 /* An invalid special addr is a wild card (or unused). Otherwise
631 if special addresses are different, the frames are different. */
633 else if (l
.artificial_depth
!= r
.artificial_depth
)
634 /* If artifical depths are different, the frames must be different. */
637 /* Frames are equal. */
642 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_eq (l=");
643 fprint_frame_id (gdb_stdlog
, l
);
644 fprintf_unfiltered (gdb_stdlog
, ",r=");
645 fprint_frame_id (gdb_stdlog
, r
);
646 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", eq
);
651 /* Safety net to check whether frame ID L should be inner to
652 frame ID R, according to their stack addresses.
654 This method cannot be used to compare arbitrary frames, as the
655 ranges of valid stack addresses may be discontiguous (e.g. due
658 However, it can be used as safety net to discover invalid frame
659 IDs in certain circumstances. Assuming that NEXT is the immediate
660 inner frame to THIS and that NEXT and THIS are both NORMAL frames:
662 * The stack address of NEXT must be inner-than-or-equal to the stack
665 Therefore, if frame_id_inner (THIS, NEXT) holds, some unwind
668 * If NEXT and THIS have different stack addresses, no other frame
669 in the frame chain may have a stack address in between.
671 Therefore, if frame_id_inner (TEST, THIS) holds, but
672 frame_id_inner (TEST, NEXT) does not hold, TEST cannot refer
673 to a valid frame in the frame chain.
675 The sanity checks above cannot be performed when a SIGTRAMP frame
676 is involved, because signal handlers might be executed on a different
677 stack than the stack used by the routine that caused the signal
678 to be raised. This can happen for instance when a thread exceeds
679 its maximum stack size. In this case, certain compilers implement
680 a stack overflow strategy that cause the handler to be run on a
684 frame_id_inner (struct gdbarch
*gdbarch
, struct frame_id l
, struct frame_id r
)
688 if (l
.stack_status
!= FID_STACK_VALID
|| r
.stack_status
!= FID_STACK_VALID
)
689 /* Like NaN, any operation involving an invalid ID always fails.
690 Likewise if either ID has an unavailable stack address. */
692 else if (l
.artificial_depth
> r
.artificial_depth
693 && l
.stack_addr
== r
.stack_addr
694 && l
.code_addr_p
== r
.code_addr_p
695 && l
.special_addr_p
== r
.special_addr_p
696 && l
.special_addr
== r
.special_addr
)
698 /* Same function, different inlined functions. */
699 const struct block
*lb
, *rb
;
701 gdb_assert (l
.code_addr_p
&& r
.code_addr_p
);
703 lb
= block_for_pc (l
.code_addr
);
704 rb
= block_for_pc (r
.code_addr
);
706 if (lb
== NULL
|| rb
== NULL
)
707 /* Something's gone wrong. */
710 /* This will return true if LB and RB are the same block, or
711 if the block with the smaller depth lexically encloses the
712 block with the greater depth. */
713 inner
= contained_in (lb
, rb
);
716 /* Only return non-zero when strictly inner than. Note that, per
717 comment in "frame.h", there is some fuzz here. Frameless
718 functions are not strictly inner than (same .stack but
719 different .code and/or .special address). */
720 inner
= gdbarch_inner_than (gdbarch
, l
.stack_addr
, r
.stack_addr
);
723 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_inner (l=");
724 fprint_frame_id (gdb_stdlog
, l
);
725 fprintf_unfiltered (gdb_stdlog
, ",r=");
726 fprint_frame_id (gdb_stdlog
, r
);
727 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", inner
);
733 frame_find_by_id (struct frame_id id
)
735 struct frame_info
*frame
, *prev_frame
;
737 /* ZERO denotes the null frame, let the caller decide what to do
738 about it. Should it instead return get_current_frame()? */
739 if (!frame_id_p (id
))
742 /* Try using the frame stash first. Finding it there removes the need
743 to perform the search by looping over all frames, which can be very
744 CPU-intensive if the number of frames is very high (the loop is O(n)
745 and get_prev_frame performs a series of checks that are relatively
746 expensive). This optimization is particularly useful when this function
747 is called from another function (such as value_fetch_lazy, case
748 VALUE_LVAL (val) == lval_register) which already loops over all frames,
749 making the overall behavior O(n^2). */
750 frame
= frame_stash_find (id
);
754 for (frame
= get_current_frame (); ; frame
= prev_frame
)
756 struct frame_id self
= get_frame_id (frame
);
758 if (frame_id_eq (id
, self
))
759 /* An exact match. */
762 prev_frame
= get_prev_frame (frame
);
766 /* As a safety net to avoid unnecessary backtracing while trying
767 to find an invalid ID, we check for a common situation where
768 we can detect from comparing stack addresses that no other
769 frame in the current frame chain can have this ID. See the
770 comment at frame_id_inner for details. */
771 if (get_frame_type (frame
) == NORMAL_FRAME
772 && !frame_id_inner (get_frame_arch (frame
), id
, self
)
773 && frame_id_inner (get_frame_arch (prev_frame
), id
,
774 get_frame_id (prev_frame
)))
781 frame_unwind_pc (struct frame_info
*this_frame
)
783 if (this_frame
->prev_pc
.status
== CC_UNKNOWN
)
785 if (gdbarch_unwind_pc_p (frame_unwind_arch (this_frame
)))
787 struct gdbarch
*prev_gdbarch
;
791 /* The right way. The `pure' way. The one true way. This
792 method depends solely on the register-unwind code to
793 determine the value of registers in THIS frame, and hence
794 the value of this frame's PC (resume address). A typical
795 implementation is no more than:
797 frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
798 return extract_unsigned_integer (buf, size of ISA_PC_REGNUM);
800 Note: this method is very heavily dependent on a correct
801 register-unwind implementation, it pays to fix that
802 method first; this method is frame type agnostic, since
803 it only deals with register values, it works with any
804 frame. This is all in stark contrast to the old
805 FRAME_SAVED_PC which would try to directly handle all the
806 different ways that a PC could be unwound. */
807 prev_gdbarch
= frame_unwind_arch (this_frame
);
811 pc
= gdbarch_unwind_pc (prev_gdbarch
, this_frame
);
814 CATCH (ex
, RETURN_MASK_ERROR
)
816 if (ex
.error
== NOT_AVAILABLE_ERROR
)
818 this_frame
->prev_pc
.status
= CC_UNAVAILABLE
;
821 fprintf_unfiltered (gdb_stdlog
,
822 "{ frame_unwind_pc (this_frame=%d)"
823 " -> <unavailable> }\n",
826 else if (ex
.error
== OPTIMIZED_OUT_ERROR
)
828 this_frame
->prev_pc
.status
= CC_NOT_SAVED
;
831 fprintf_unfiltered (gdb_stdlog
,
832 "{ frame_unwind_pc (this_frame=%d)"
833 " -> <not saved> }\n",
837 throw_exception (ex
);
843 this_frame
->prev_pc
.value
= pc
;
844 this_frame
->prev_pc
.status
= CC_VALUE
;
846 fprintf_unfiltered (gdb_stdlog
,
847 "{ frame_unwind_pc (this_frame=%d) "
850 hex_string (this_frame
->prev_pc
.value
));
854 internal_error (__FILE__
, __LINE__
, _("No unwind_pc method"));
857 if (this_frame
->prev_pc
.status
== CC_VALUE
)
858 return this_frame
->prev_pc
.value
;
859 else if (this_frame
->prev_pc
.status
== CC_UNAVAILABLE
)
860 throw_error (NOT_AVAILABLE_ERROR
, _("PC not available"));
861 else if (this_frame
->prev_pc
.status
== CC_NOT_SAVED
)
862 throw_error (OPTIMIZED_OUT_ERROR
, _("PC not saved"));
864 internal_error (__FILE__
, __LINE__
,
865 "unexpected prev_pc status: %d",
866 (int) this_frame
->prev_pc
.status
);
870 frame_unwind_caller_pc (struct frame_info
*this_frame
)
872 return frame_unwind_pc (skip_artificial_frames (this_frame
));
876 get_frame_func_if_available (struct frame_info
*this_frame
, CORE_ADDR
*pc
)
878 struct frame_info
*next_frame
= this_frame
->next
;
880 if (!next_frame
->prev_func
.p
)
882 CORE_ADDR addr_in_block
;
884 /* Make certain that this, and not the adjacent, function is
886 if (!get_frame_address_in_block_if_available (this_frame
, &addr_in_block
))
888 next_frame
->prev_func
.p
= -1;
890 fprintf_unfiltered (gdb_stdlog
,
891 "{ get_frame_func (this_frame=%d)"
892 " -> unavailable }\n",
897 next_frame
->prev_func
.p
= 1;
898 next_frame
->prev_func
.addr
= get_pc_function_start (addr_in_block
);
900 fprintf_unfiltered (gdb_stdlog
,
901 "{ get_frame_func (this_frame=%d) -> %s }\n",
903 hex_string (next_frame
->prev_func
.addr
));
907 if (next_frame
->prev_func
.p
< 0)
914 *pc
= next_frame
->prev_func
.addr
;
920 get_frame_func (struct frame_info
*this_frame
)
924 if (!get_frame_func_if_available (this_frame
, &pc
))
925 throw_error (NOT_AVAILABLE_ERROR
, _("PC not available"));
930 static enum register_status
931 do_frame_register_read (void *src
, int regnum
, gdb_byte
*buf
)
933 if (!deprecated_frame_register_read ((struct frame_info
*) src
, regnum
, buf
))
934 return REG_UNAVAILABLE
;
940 frame_save_as_regcache (struct frame_info
*this_frame
)
942 struct address_space
*aspace
= get_frame_address_space (this_frame
);
943 struct regcache
*regcache
= regcache_xmalloc (get_frame_arch (this_frame
),
945 struct cleanup
*cleanups
= make_cleanup_regcache_xfree (regcache
);
947 regcache_save (regcache
, do_frame_register_read
, this_frame
);
948 discard_cleanups (cleanups
);
953 frame_pop (struct frame_info
*this_frame
)
955 struct frame_info
*prev_frame
;
956 struct regcache
*scratch
;
957 struct cleanup
*cleanups
;
959 if (get_frame_type (this_frame
) == DUMMY_FRAME
)
961 /* Popping a dummy frame involves restoring more than just registers.
962 dummy_frame_pop does all the work. */
963 dummy_frame_pop (get_frame_id (this_frame
), inferior_ptid
);
967 /* Ensure that we have a frame to pop to. */
968 prev_frame
= get_prev_frame_always (this_frame
);
971 error (_("Cannot pop the initial frame."));
973 /* Ignore TAILCALL_FRAME type frames, they were executed already before
974 entering THISFRAME. */
975 while (get_frame_type (prev_frame
) == TAILCALL_FRAME
)
976 prev_frame
= get_prev_frame (prev_frame
);
978 /* Make a copy of all the register values unwound from this frame.
979 Save them in a scratch buffer so that there isn't a race between
980 trying to extract the old values from the current regcache while
981 at the same time writing new values into that same cache. */
982 scratch
= frame_save_as_regcache (prev_frame
);
983 cleanups
= make_cleanup_regcache_xfree (scratch
);
985 /* FIXME: cagney/2003-03-16: It should be possible to tell the
986 target's register cache that it is about to be hit with a burst
987 register transfer and that the sequence of register writes should
988 be batched. The pair target_prepare_to_store() and
989 target_store_registers() kind of suggest this functionality.
990 Unfortunately, they don't implement it. Their lack of a formal
991 definition can lead to targets writing back bogus values
992 (arguably a bug in the target code mind). */
993 /* Now copy those saved registers into the current regcache.
994 Here, regcache_cpy() calls regcache_restore(). */
995 regcache_cpy (get_current_regcache (), scratch
);
996 do_cleanups (cleanups
);
998 /* We've made right mess of GDB's local state, just discard
1000 reinit_frame_cache ();
1004 frame_register_unwind (struct frame_info
*frame
, int regnum
,
1005 int *optimizedp
, int *unavailablep
,
1006 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
1007 int *realnump
, gdb_byte
*bufferp
)
1009 struct value
*value
;
1011 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
1012 that the value proper does not need to be fetched. */
1013 gdb_assert (optimizedp
!= NULL
);
1014 gdb_assert (lvalp
!= NULL
);
1015 gdb_assert (addrp
!= NULL
);
1016 gdb_assert (realnump
!= NULL
);
1017 /* gdb_assert (bufferp != NULL); */
1019 value
= frame_unwind_register_value (frame
, regnum
);
1021 gdb_assert (value
!= NULL
);
1023 *optimizedp
= value_optimized_out (value
);
1024 *unavailablep
= !value_entirely_available (value
);
1025 *lvalp
= VALUE_LVAL (value
);
1026 *addrp
= value_address (value
);
1027 *realnump
= VALUE_REGNUM (value
);
1031 if (!*optimizedp
&& !*unavailablep
)
1032 memcpy (bufferp
, value_contents_all (value
),
1033 TYPE_LENGTH (value_type (value
)));
1035 memset (bufferp
, 0, TYPE_LENGTH (value_type (value
)));
1038 /* Dispose of the new value. This prevents watchpoints from
1039 trying to watch the saved frame pointer. */
1040 release_value (value
);
1045 frame_register (struct frame_info
*frame
, int regnum
,
1046 int *optimizedp
, int *unavailablep
, enum lval_type
*lvalp
,
1047 CORE_ADDR
*addrp
, int *realnump
, gdb_byte
*bufferp
)
1049 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
1050 that the value proper does not need to be fetched. */
1051 gdb_assert (optimizedp
!= NULL
);
1052 gdb_assert (lvalp
!= NULL
);
1053 gdb_assert (addrp
!= NULL
);
1054 gdb_assert (realnump
!= NULL
);
1055 /* gdb_assert (bufferp != NULL); */
1057 /* Obtain the register value by unwinding the register from the next
1058 (more inner frame). */
1059 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
1060 frame_register_unwind (frame
->next
, regnum
, optimizedp
, unavailablep
,
1061 lvalp
, addrp
, realnump
, bufferp
);
1065 frame_unwind_register (struct frame_info
*frame
, int regnum
, gdb_byte
*buf
)
1071 enum lval_type lval
;
1073 frame_register_unwind (frame
, regnum
, &optimized
, &unavailable
,
1074 &lval
, &addr
, &realnum
, buf
);
1077 throw_error (OPTIMIZED_OUT_ERROR
,
1078 _("Register %d was not saved"), regnum
);
1080 throw_error (NOT_AVAILABLE_ERROR
,
1081 _("Register %d is not available"), regnum
);
1085 get_frame_register (struct frame_info
*frame
,
1086 int regnum
, gdb_byte
*buf
)
1088 frame_unwind_register (frame
->next
, regnum
, buf
);
1092 frame_unwind_register_value (struct frame_info
*frame
, int regnum
)
1094 struct gdbarch
*gdbarch
;
1095 struct value
*value
;
1097 gdb_assert (frame
!= NULL
);
1098 gdbarch
= frame_unwind_arch (frame
);
1102 fprintf_unfiltered (gdb_stdlog
,
1103 "{ frame_unwind_register_value "
1104 "(frame=%d,regnum=%d(%s),...) ",
1105 frame
->level
, regnum
,
1106 user_reg_map_regnum_to_name (gdbarch
, regnum
));
1109 /* Find the unwinder. */
1110 if (frame
->unwind
== NULL
)
1111 frame_unwind_find_by_frame (frame
, &frame
->prologue_cache
);
1113 /* Ask this frame to unwind its register. */
1114 value
= frame
->unwind
->prev_register (frame
, &frame
->prologue_cache
, regnum
);
1118 fprintf_unfiltered (gdb_stdlog
, "->");
1119 if (value_optimized_out (value
))
1121 fprintf_unfiltered (gdb_stdlog
, " ");
1122 val_print_optimized_out (value
, gdb_stdlog
);
1126 if (VALUE_LVAL (value
) == lval_register
)
1127 fprintf_unfiltered (gdb_stdlog
, " register=%d",
1128 VALUE_REGNUM (value
));
1129 else if (VALUE_LVAL (value
) == lval_memory
)
1130 fprintf_unfiltered (gdb_stdlog
, " address=%s",
1132 value_address (value
)));
1134 fprintf_unfiltered (gdb_stdlog
, " computed");
1136 if (value_lazy (value
))
1137 fprintf_unfiltered (gdb_stdlog
, " lazy");
1141 const gdb_byte
*buf
= value_contents (value
);
1143 fprintf_unfiltered (gdb_stdlog
, " bytes=");
1144 fprintf_unfiltered (gdb_stdlog
, "[");
1145 for (i
= 0; i
< register_size (gdbarch
, regnum
); i
++)
1146 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1147 fprintf_unfiltered (gdb_stdlog
, "]");
1151 fprintf_unfiltered (gdb_stdlog
, " }\n");
1158 get_frame_register_value (struct frame_info
*frame
, int regnum
)
1160 return frame_unwind_register_value (frame
->next
, regnum
);
1164 frame_unwind_register_signed (struct frame_info
*frame
, int regnum
)
1166 struct gdbarch
*gdbarch
= frame_unwind_arch (frame
);
1167 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1168 int size
= register_size (gdbarch
, regnum
);
1169 gdb_byte buf
[MAX_REGISTER_SIZE
];
1171 frame_unwind_register (frame
, regnum
, buf
);
1172 return extract_signed_integer (buf
, size
, byte_order
);
1176 get_frame_register_signed (struct frame_info
*frame
, int regnum
)
1178 return frame_unwind_register_signed (frame
->next
, regnum
);
1182 frame_unwind_register_unsigned (struct frame_info
*frame
, int regnum
)
1184 struct gdbarch
*gdbarch
= frame_unwind_arch (frame
);
1185 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1186 int size
= register_size (gdbarch
, regnum
);
1187 gdb_byte buf
[MAX_REGISTER_SIZE
];
1189 frame_unwind_register (frame
, regnum
, buf
);
1190 return extract_unsigned_integer (buf
, size
, byte_order
);
1194 get_frame_register_unsigned (struct frame_info
*frame
, int regnum
)
1196 return frame_unwind_register_unsigned (frame
->next
, regnum
);
1200 read_frame_register_unsigned (struct frame_info
*frame
, int regnum
,
1203 struct value
*regval
= get_frame_register_value (frame
, regnum
);
1205 if (!value_optimized_out (regval
)
1206 && value_entirely_available (regval
))
1208 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1209 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1210 int size
= register_size (gdbarch
, VALUE_REGNUM (regval
));
1212 *val
= extract_unsigned_integer (value_contents (regval
), size
, byte_order
);
1220 put_frame_register (struct frame_info
*frame
, int regnum
,
1221 const gdb_byte
*buf
)
1223 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1227 enum lval_type lval
;
1230 frame_register (frame
, regnum
, &optim
, &unavail
,
1231 &lval
, &addr
, &realnum
, NULL
);
1233 error (_("Attempt to assign to a register that was not saved."));
1238 write_memory (addr
, buf
, register_size (gdbarch
, regnum
));
1242 regcache_cooked_write (get_current_regcache (), realnum
, buf
);
1245 error (_("Attempt to assign to an unmodifiable value."));
1249 /* This function is deprecated. Use get_frame_register_value instead,
1250 which provides more accurate information.
1252 Find and return the value of REGNUM for the specified stack frame.
1253 The number of bytes copied is REGISTER_SIZE (REGNUM).
1255 Returns 0 if the register value could not be found. */
1258 deprecated_frame_register_read (struct frame_info
*frame
, int regnum
,
1263 enum lval_type lval
;
1267 frame_register (frame
, regnum
, &optimized
, &unavailable
,
1268 &lval
, &addr
, &realnum
, myaddr
);
1270 return !optimized
&& !unavailable
;
1274 get_frame_register_bytes (struct frame_info
*frame
, int regnum
,
1275 CORE_ADDR offset
, int len
, gdb_byte
*myaddr
,
1276 int *optimizedp
, int *unavailablep
)
1278 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1283 /* Skip registers wholly inside of OFFSET. */
1284 while (offset
>= register_size (gdbarch
, regnum
))
1286 offset
-= register_size (gdbarch
, regnum
);
1290 /* Ensure that we will not read beyond the end of the register file.
1291 This can only ever happen if the debug information is bad. */
1293 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1294 for (i
= regnum
; i
< numregs
; i
++)
1296 int thissize
= register_size (gdbarch
, i
);
1299 break; /* This register is not available on this architecture. */
1300 maxsize
+= thissize
;
1303 error (_("Bad debug information detected: "
1304 "Attempt to read %d bytes from registers."), len
);
1306 /* Copy the data. */
1309 int curr_len
= register_size (gdbarch
, regnum
) - offset
;
1314 if (curr_len
== register_size (gdbarch
, regnum
))
1316 enum lval_type lval
;
1320 frame_register (frame
, regnum
, optimizedp
, unavailablep
,
1321 &lval
, &addr
, &realnum
, myaddr
);
1322 if (*optimizedp
|| *unavailablep
)
1327 gdb_byte buf
[MAX_REGISTER_SIZE
];
1328 enum lval_type lval
;
1332 frame_register (frame
, regnum
, optimizedp
, unavailablep
,
1333 &lval
, &addr
, &realnum
, buf
);
1334 if (*optimizedp
|| *unavailablep
)
1336 memcpy (myaddr
, buf
+ offset
, curr_len
);
1351 put_frame_register_bytes (struct frame_info
*frame
, int regnum
,
1352 CORE_ADDR offset
, int len
, const gdb_byte
*myaddr
)
1354 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1356 /* Skip registers wholly inside of OFFSET. */
1357 while (offset
>= register_size (gdbarch
, regnum
))
1359 offset
-= register_size (gdbarch
, regnum
);
1363 /* Copy the data. */
1366 int curr_len
= register_size (gdbarch
, regnum
) - offset
;
1371 if (curr_len
== register_size (gdbarch
, regnum
))
1373 put_frame_register (frame
, regnum
, myaddr
);
1377 gdb_byte buf
[MAX_REGISTER_SIZE
];
1379 deprecated_frame_register_read (frame
, regnum
, buf
);
1380 memcpy (buf
+ offset
, myaddr
, curr_len
);
1381 put_frame_register (frame
, regnum
, buf
);
1391 /* Create a sentinel frame. */
1393 static struct frame_info
*
1394 create_sentinel_frame (struct program_space
*pspace
, struct regcache
*regcache
)
1396 struct frame_info
*frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1399 frame
->pspace
= pspace
;
1400 frame
->aspace
= get_regcache_aspace (regcache
);
1401 /* Explicitly initialize the sentinel frame's cache. Provide it
1402 with the underlying regcache. In the future additional
1403 information, such as the frame's thread will be added. */
1404 frame
->prologue_cache
= sentinel_frame_cache (regcache
);
1405 /* For the moment there is only one sentinel frame implementation. */
1406 frame
->unwind
= &sentinel_frame_unwind
;
1407 /* Link this frame back to itself. The frame is self referential
1408 (the unwound PC is the same as the pc), so make it so. */
1409 frame
->next
= frame
;
1410 /* Make the sentinel frame's ID valid, but invalid. That way all
1411 comparisons with it should fail. */
1412 frame
->this_id
.p
= 1;
1413 frame
->this_id
.value
= null_frame_id
;
1416 fprintf_unfiltered (gdb_stdlog
, "{ create_sentinel_frame (...) -> ");
1417 fprint_frame (gdb_stdlog
, frame
);
1418 fprintf_unfiltered (gdb_stdlog
, " }\n");
1423 /* Info about the innermost stack frame (contents of FP register). */
1425 static struct frame_info
*current_frame
;
1427 /* Cache for frame addresses already read by gdb. Valid only while
1428 inferior is stopped. Control variables for the frame cache should
1429 be local to this module. */
1431 static struct obstack frame_cache_obstack
;
1434 frame_obstack_zalloc (unsigned long size
)
1436 void *data
= obstack_alloc (&frame_cache_obstack
, size
);
1438 memset (data
, 0, size
);
1442 /* Return the innermost (currently executing) stack frame. This is
1443 split into two functions. The function unwind_to_current_frame()
1444 is wrapped in catch exceptions so that, even when the unwind of the
1445 sentinel frame fails, the function still returns a stack frame. */
1448 unwind_to_current_frame (struct ui_out
*ui_out
, void *args
)
1450 struct frame_info
*frame
= get_prev_frame ((struct frame_info
*) args
);
1452 /* A sentinel frame can fail to unwind, e.g., because its PC value
1453 lands in somewhere like start. */
1456 current_frame
= frame
;
1461 get_current_frame (void)
1463 /* First check, and report, the lack of registers. Having GDB
1464 report "No stack!" or "No memory" when the target doesn't even
1465 have registers is very confusing. Besides, "printcmd.exp"
1466 explicitly checks that ``print $pc'' with no registers prints "No
1468 if (!target_has_registers
)
1469 error (_("No registers."));
1470 if (!target_has_stack
)
1471 error (_("No stack."));
1472 if (!target_has_memory
)
1473 error (_("No memory."));
1474 /* Traceframes are effectively a substitute for the live inferior. */
1475 if (get_traceframe_number () < 0)
1476 validate_registers_access ();
1478 if (current_frame
== NULL
)
1480 struct frame_info
*sentinel_frame
=
1481 create_sentinel_frame (current_program_space
, get_current_regcache ());
1482 if (catch_exceptions (current_uiout
, unwind_to_current_frame
,
1483 sentinel_frame
, RETURN_MASK_ERROR
) != 0)
1485 /* Oops! Fake a current frame? Is this useful? It has a PC
1486 of zero, for instance. */
1487 current_frame
= sentinel_frame
;
1490 return current_frame
;
1493 /* The "selected" stack frame is used by default for local and arg
1494 access. May be zero, for no selected frame. */
1496 static struct frame_info
*selected_frame
;
1499 has_stack_frames (void)
1501 if (!target_has_registers
|| !target_has_stack
|| !target_has_memory
)
1504 /* Traceframes are effectively a substitute for the live inferior. */
1505 if (get_traceframe_number () < 0)
1507 /* No current inferior, no frame. */
1508 if (ptid_equal (inferior_ptid
, null_ptid
))
1511 /* Don't try to read from a dead thread. */
1512 if (is_exited (inferior_ptid
))
1515 /* ... or from a spinning thread. */
1516 if (is_executing (inferior_ptid
))
1523 /* Return the selected frame. Always non-NULL (unless there isn't an
1524 inferior sufficient for creating a frame) in which case an error is
1528 get_selected_frame (const char *message
)
1530 if (selected_frame
== NULL
)
1532 if (message
!= NULL
&& !has_stack_frames ())
1533 error (("%s"), message
);
1534 /* Hey! Don't trust this. It should really be re-finding the
1535 last selected frame of the currently selected thread. This,
1536 though, is better than nothing. */
1537 select_frame (get_current_frame ());
1539 /* There is always a frame. */
1540 gdb_assert (selected_frame
!= NULL
);
1541 return selected_frame
;
1544 /* If there is a selected frame, return it. Otherwise, return NULL. */
1547 get_selected_frame_if_set (void)
1549 return selected_frame
;
1552 /* This is a variant of get_selected_frame() which can be called when
1553 the inferior does not have a frame; in that case it will return
1554 NULL instead of calling error(). */
1557 deprecated_safe_get_selected_frame (void)
1559 if (!has_stack_frames ())
1561 return get_selected_frame (NULL
);
1564 /* Select frame FI (or NULL - to invalidate the current frame). */
1567 select_frame (struct frame_info
*fi
)
1569 selected_frame
= fi
;
1570 /* NOTE: cagney/2002-05-04: FI can be NULL. This occurs when the
1571 frame is being invalidated. */
1573 /* FIXME: kseitz/2002-08-28: It would be nice to call
1574 selected_frame_level_changed_event() right here, but due to limitations
1575 in the current interfaces, we would end up flooding UIs with events
1576 because select_frame() is used extensively internally.
1578 Once we have frame-parameterized frame (and frame-related) commands,
1579 the event notification can be moved here, since this function will only
1580 be called when the user's selected frame is being changed. */
1582 /* Ensure that symbols for this frame are read in. Also, determine the
1583 source language of this frame, and switch to it if desired. */
1588 /* We retrieve the frame's symtab by using the frame PC.
1589 However we cannot use the frame PC as-is, because it usually
1590 points to the instruction following the "call", which is
1591 sometimes the first instruction of another function. So we
1592 rely on get_frame_address_in_block() which provides us with a
1593 PC which is guaranteed to be inside the frame's code
1595 if (get_frame_address_in_block_if_available (fi
, &pc
))
1597 struct compunit_symtab
*cust
= find_pc_compunit_symtab (pc
);
1600 && compunit_language (cust
) != current_language
->la_language
1601 && compunit_language (cust
) != language_unknown
1602 && language_mode
== language_mode_auto
)
1603 set_language (compunit_language (cust
));
1608 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
1609 Always returns a non-NULL value. */
1612 create_new_frame (CORE_ADDR addr
, CORE_ADDR pc
)
1614 struct frame_info
*fi
;
1618 fprintf_unfiltered (gdb_stdlog
,
1619 "{ create_new_frame (addr=%s, pc=%s) ",
1620 hex_string (addr
), hex_string (pc
));
1623 fi
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1625 fi
->next
= create_sentinel_frame (current_program_space
,
1626 get_current_regcache ());
1628 /* Set/update this frame's cached PC value, found in the next frame.
1629 Do this before looking for this frame's unwinder. A sniffer is
1630 very likely to read this, and the corresponding unwinder is
1631 entitled to rely that the PC doesn't magically change. */
1632 fi
->next
->prev_pc
.value
= pc
;
1633 fi
->next
->prev_pc
.status
= CC_VALUE
;
1635 /* We currently assume that frame chain's can't cross spaces. */
1636 fi
->pspace
= fi
->next
->pspace
;
1637 fi
->aspace
= fi
->next
->aspace
;
1639 /* Select/initialize both the unwind function and the frame's type
1641 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
1644 fi
->this_id
.value
= frame_id_build (addr
, pc
);
1648 fprintf_unfiltered (gdb_stdlog
, "-> ");
1649 fprint_frame (gdb_stdlog
, fi
);
1650 fprintf_unfiltered (gdb_stdlog
, " }\n");
1656 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
1657 innermost frame). Be careful to not fall off the bottom of the
1658 frame chain and onto the sentinel frame. */
1661 get_next_frame (struct frame_info
*this_frame
)
1663 if (this_frame
->level
> 0)
1664 return this_frame
->next
;
1669 /* Observer for the target_changed event. */
1672 frame_observer_target_changed (struct target_ops
*target
)
1674 reinit_frame_cache ();
1677 /* Flush the entire frame cache. */
1680 reinit_frame_cache (void)
1682 struct frame_info
*fi
;
1684 /* Tear down all frame caches. */
1685 for (fi
= current_frame
; fi
!= NULL
; fi
= fi
->prev
)
1687 if (fi
->prologue_cache
&& fi
->unwind
->dealloc_cache
)
1688 fi
->unwind
->dealloc_cache (fi
, fi
->prologue_cache
);
1689 if (fi
->base_cache
&& fi
->base
->unwind
->dealloc_cache
)
1690 fi
->base
->unwind
->dealloc_cache (fi
, fi
->base_cache
);
1693 /* Since we can't really be sure what the first object allocated was. */
1694 obstack_free (&frame_cache_obstack
, 0);
1695 obstack_init (&frame_cache_obstack
);
1697 if (current_frame
!= NULL
)
1698 annotate_frames_invalid ();
1700 current_frame
= NULL
; /* Invalidate cache */
1701 select_frame (NULL
);
1702 frame_stash_invalidate ();
1704 fprintf_unfiltered (gdb_stdlog
, "{ reinit_frame_cache () }\n");
1707 /* Find where a register is saved (in memory or another register).
1708 The result of frame_register_unwind is just where it is saved
1709 relative to this particular frame. */
1712 frame_register_unwind_location (struct frame_info
*this_frame
, int regnum
,
1713 int *optimizedp
, enum lval_type
*lvalp
,
1714 CORE_ADDR
*addrp
, int *realnump
)
1716 gdb_assert (this_frame
== NULL
|| this_frame
->level
>= 0);
1718 while (this_frame
!= NULL
)
1722 frame_register_unwind (this_frame
, regnum
, optimizedp
, &unavailable
,
1723 lvalp
, addrp
, realnump
, NULL
);
1728 if (*lvalp
!= lval_register
)
1732 this_frame
= get_next_frame (this_frame
);
1736 /* Called during frame unwinding to remove a previous frame pointer from a
1737 frame passed in ARG. */
1740 remove_prev_frame (void *arg
)
1742 struct frame_info
*this_frame
, *prev_frame
;
1744 this_frame
= (struct frame_info
*) arg
;
1745 prev_frame
= this_frame
->prev
;
1746 gdb_assert (prev_frame
!= NULL
);
1748 prev_frame
->next
= NULL
;
1749 this_frame
->prev
= NULL
;
1752 /* Get the previous raw frame, and check that it is not identical to
1753 same other frame frame already in the chain. If it is, there is
1754 most likely a stack cycle, so we discard it, and mark THIS_FRAME as
1755 outermost, with UNWIND_SAME_ID stop reason. Unlike the other
1756 validity tests, that compare THIS_FRAME and the next frame, we do
1757 this right after creating the previous frame, to avoid ever ending
1758 up with two frames with the same id in the frame chain. */
1760 static struct frame_info
*
1761 get_prev_frame_if_no_cycle (struct frame_info
*this_frame
)
1763 struct frame_info
*prev_frame
;
1764 struct cleanup
*prev_frame_cleanup
;
1766 prev_frame
= get_prev_frame_raw (this_frame
);
1767 if (prev_frame
== NULL
)
1770 /* The cleanup will remove the previous frame that get_prev_frame_raw
1771 linked onto THIS_FRAME. */
1772 prev_frame_cleanup
= make_cleanup (remove_prev_frame
, this_frame
);
1774 compute_frame_id (prev_frame
);
1775 if (!frame_stash_add (prev_frame
))
1777 /* Another frame with the same id was already in the stash. We just
1778 detected a cycle. */
1781 fprintf_unfiltered (gdb_stdlog
, "-> ");
1782 fprint_frame (gdb_stdlog
, NULL
);
1783 fprintf_unfiltered (gdb_stdlog
, " // this frame has same ID }\n");
1785 this_frame
->stop_reason
= UNWIND_SAME_ID
;
1787 prev_frame
->next
= NULL
;
1788 this_frame
->prev
= NULL
;
1792 discard_cleanups (prev_frame_cleanup
);
1796 /* Helper function for get_prev_frame_always, this is called inside a
1797 TRY_CATCH block. Return the frame that called THIS_FRAME or NULL if
1798 there is no such frame. This may throw an exception. */
1800 static struct frame_info
*
1801 get_prev_frame_always_1 (struct frame_info
*this_frame
)
1803 struct gdbarch
*gdbarch
;
1805 gdb_assert (this_frame
!= NULL
);
1806 gdbarch
= get_frame_arch (this_frame
);
1810 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame_always (this_frame=");
1811 if (this_frame
!= NULL
)
1812 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1814 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1815 fprintf_unfiltered (gdb_stdlog
, ") ");
1818 /* Only try to do the unwind once. */
1819 if (this_frame
->prev_p
)
1823 fprintf_unfiltered (gdb_stdlog
, "-> ");
1824 fprint_frame (gdb_stdlog
, this_frame
->prev
);
1825 fprintf_unfiltered (gdb_stdlog
, " // cached \n");
1827 return this_frame
->prev
;
1830 /* If the frame unwinder hasn't been selected yet, we must do so
1831 before setting prev_p; otherwise the check for misbehaved
1832 sniffers will think that this frame's sniffer tried to unwind
1833 further (see frame_cleanup_after_sniffer). */
1834 if (this_frame
->unwind
== NULL
)
1835 frame_unwind_find_by_frame (this_frame
, &this_frame
->prologue_cache
);
1837 this_frame
->prev_p
= 1;
1838 this_frame
->stop_reason
= UNWIND_NO_REASON
;
1840 /* If we are unwinding from an inline frame, all of the below tests
1841 were already performed when we unwound from the next non-inline
1842 frame. We must skip them, since we can not get THIS_FRAME's ID
1843 until we have unwound all the way down to the previous non-inline
1845 if (get_frame_type (this_frame
) == INLINE_FRAME
)
1846 return get_prev_frame_if_no_cycle (this_frame
);
1848 /* Check that this frame is unwindable. If it isn't, don't try to
1849 unwind to the prev frame. */
1850 this_frame
->stop_reason
1851 = this_frame
->unwind
->stop_reason (this_frame
,
1852 &this_frame
->prologue_cache
);
1854 if (this_frame
->stop_reason
!= UNWIND_NO_REASON
)
1858 enum unwind_stop_reason reason
= this_frame
->stop_reason
;
1860 fprintf_unfiltered (gdb_stdlog
, "-> ");
1861 fprint_frame (gdb_stdlog
, NULL
);
1862 fprintf_unfiltered (gdb_stdlog
, " // %s }\n",
1863 frame_stop_reason_symbol_string (reason
));
1868 /* Check that this frame's ID isn't inner to (younger, below, next)
1869 the next frame. This happens when a frame unwind goes backwards.
1870 This check is valid only if this frame and the next frame are NORMAL.
1871 See the comment at frame_id_inner for details. */
1872 if (get_frame_type (this_frame
) == NORMAL_FRAME
1873 && this_frame
->next
->unwind
->type
== NORMAL_FRAME
1874 && frame_id_inner (get_frame_arch (this_frame
->next
),
1875 get_frame_id (this_frame
),
1876 get_frame_id (this_frame
->next
)))
1878 CORE_ADDR this_pc_in_block
;
1879 struct minimal_symbol
*morestack_msym
;
1880 const char *morestack_name
= NULL
;
1882 /* gcc -fsplit-stack __morestack can continue the stack anywhere. */
1883 this_pc_in_block
= get_frame_address_in_block (this_frame
);
1884 morestack_msym
= lookup_minimal_symbol_by_pc (this_pc_in_block
).minsym
;
1886 morestack_name
= MSYMBOL_LINKAGE_NAME (morestack_msym
);
1887 if (!morestack_name
|| strcmp (morestack_name
, "__morestack") != 0)
1891 fprintf_unfiltered (gdb_stdlog
, "-> ");
1892 fprint_frame (gdb_stdlog
, NULL
);
1893 fprintf_unfiltered (gdb_stdlog
,
1894 " // this frame ID is inner }\n");
1896 this_frame
->stop_reason
= UNWIND_INNER_ID
;
1901 /* Check that this and the next frame do not unwind the PC register
1902 to the same memory location. If they do, then even though they
1903 have different frame IDs, the new frame will be bogus; two
1904 functions can't share a register save slot for the PC. This can
1905 happen when the prologue analyzer finds a stack adjustment, but
1908 This check does assume that the "PC register" is roughly a
1909 traditional PC, even if the gdbarch_unwind_pc method adjusts
1910 it (we do not rely on the value, only on the unwound PC being
1911 dependent on this value). A potential improvement would be
1912 to have the frame prev_pc method and the gdbarch unwind_pc
1913 method set the same lval and location information as
1914 frame_register_unwind. */
1915 if (this_frame
->level
> 0
1916 && gdbarch_pc_regnum (gdbarch
) >= 0
1917 && get_frame_type (this_frame
) == NORMAL_FRAME
1918 && (get_frame_type (this_frame
->next
) == NORMAL_FRAME
1919 || get_frame_type (this_frame
->next
) == INLINE_FRAME
))
1921 int optimized
, realnum
, nrealnum
;
1922 enum lval_type lval
, nlval
;
1923 CORE_ADDR addr
, naddr
;
1925 frame_register_unwind_location (this_frame
,
1926 gdbarch_pc_regnum (gdbarch
),
1927 &optimized
, &lval
, &addr
, &realnum
);
1928 frame_register_unwind_location (get_next_frame (this_frame
),
1929 gdbarch_pc_regnum (gdbarch
),
1930 &optimized
, &nlval
, &naddr
, &nrealnum
);
1932 if ((lval
== lval_memory
&& lval
== nlval
&& addr
== naddr
)
1933 || (lval
== lval_register
&& lval
== nlval
&& realnum
== nrealnum
))
1937 fprintf_unfiltered (gdb_stdlog
, "-> ");
1938 fprint_frame (gdb_stdlog
, NULL
);
1939 fprintf_unfiltered (gdb_stdlog
, " // no saved PC }\n");
1942 this_frame
->stop_reason
= UNWIND_NO_SAVED_PC
;
1943 this_frame
->prev
= NULL
;
1948 return get_prev_frame_if_no_cycle (this_frame
);
1951 /* Return a "struct frame_info" corresponding to the frame that called
1952 THIS_FRAME. Returns NULL if there is no such frame.
1954 Unlike get_prev_frame, this function always tries to unwind the
1958 get_prev_frame_always (struct frame_info
*this_frame
)
1960 struct frame_info
*prev_frame
= NULL
;
1964 prev_frame
= get_prev_frame_always_1 (this_frame
);
1966 CATCH (ex
, RETURN_MASK_ERROR
)
1968 if (ex
.error
== MEMORY_ERROR
)
1970 this_frame
->stop_reason
= UNWIND_MEMORY_ERROR
;
1971 if (ex
.message
!= NULL
)
1976 /* The error needs to live as long as the frame does.
1977 Allocate using stack local STOP_STRING then assign the
1978 pointer to the frame, this allows the STOP_STRING on the
1979 frame to be of type 'const char *'. */
1980 size
= strlen (ex
.message
) + 1;
1981 stop_string
= (char *) frame_obstack_zalloc (size
);
1982 memcpy (stop_string
, ex
.message
, size
);
1983 this_frame
->stop_string
= stop_string
;
1988 throw_exception (ex
);
1995 /* Construct a new "struct frame_info" and link it previous to
1998 static struct frame_info
*
1999 get_prev_frame_raw (struct frame_info
*this_frame
)
2001 struct frame_info
*prev_frame
;
2003 /* Allocate the new frame but do not wire it in to the frame chain.
2004 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
2005 frame->next to pull some fancy tricks (of course such code is, by
2006 definition, recursive). Try to prevent it.
2008 There is no reason to worry about memory leaks, should the
2009 remainder of the function fail. The allocated memory will be
2010 quickly reclaimed when the frame cache is flushed, and the `we've
2011 been here before' check above will stop repeated memory
2012 allocation calls. */
2013 prev_frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
2014 prev_frame
->level
= this_frame
->level
+ 1;
2016 /* For now, assume we don't have frame chains crossing address
2018 prev_frame
->pspace
= this_frame
->pspace
;
2019 prev_frame
->aspace
= this_frame
->aspace
;
2021 /* Don't yet compute ->unwind (and hence ->type). It is computed
2022 on-demand in get_frame_type, frame_register_unwind, and
2025 /* Don't yet compute the frame's ID. It is computed on-demand by
2028 /* The unwound frame ID is validate at the start of this function,
2029 as part of the logic to decide if that frame should be further
2030 unwound, and not here while the prev frame is being created.
2031 Doing this makes it possible for the user to examine a frame that
2032 has an invalid frame ID.
2034 Some very old VAX code noted: [...] For the sake of argument,
2035 suppose that the stack is somewhat trashed (which is one reason
2036 that "info frame" exists). So, return 0 (indicating we don't
2037 know the address of the arglist) if we don't know what frame this
2041 this_frame
->prev
= prev_frame
;
2042 prev_frame
->next
= this_frame
;
2046 fprintf_unfiltered (gdb_stdlog
, "-> ");
2047 fprint_frame (gdb_stdlog
, prev_frame
);
2048 fprintf_unfiltered (gdb_stdlog
, " }\n");
2054 /* Debug routine to print a NULL frame being returned. */
2057 frame_debug_got_null_frame (struct frame_info
*this_frame
,
2062 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame (this_frame=");
2063 if (this_frame
!= NULL
)
2064 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
2066 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
2067 fprintf_unfiltered (gdb_stdlog
, ") -> // %s}\n", reason
);
2071 /* Is this (non-sentinel) frame in the "main"() function? */
2074 inside_main_func (struct frame_info
*this_frame
)
2076 struct bound_minimal_symbol msymbol
;
2079 if (symfile_objfile
== 0)
2081 msymbol
= lookup_minimal_symbol (main_name (), NULL
, symfile_objfile
);
2082 if (msymbol
.minsym
== NULL
)
2084 /* Make certain that the code, and not descriptor, address is
2086 maddr
= gdbarch_convert_from_func_ptr_addr (get_frame_arch (this_frame
),
2087 BMSYMBOL_VALUE_ADDRESS (msymbol
),
2089 return maddr
== get_frame_func (this_frame
);
2092 /* Test whether THIS_FRAME is inside the process entry point function. */
2095 inside_entry_func (struct frame_info
*this_frame
)
2097 CORE_ADDR entry_point
;
2099 if (!entry_point_address_query (&entry_point
))
2102 return get_frame_func (this_frame
) == entry_point
;
2105 /* Return a structure containing various interesting information about
2106 the frame that called THIS_FRAME. Returns NULL if there is entier
2107 no such frame or the frame fails any of a set of target-independent
2108 condition that should terminate the frame chain (e.g., as unwinding
2111 This function should not contain target-dependent tests, such as
2112 checking whether the program-counter is zero. */
2115 get_prev_frame (struct frame_info
*this_frame
)
2120 /* There is always a frame. If this assertion fails, suspect that
2121 something should be calling get_selected_frame() or
2122 get_current_frame(). */
2123 gdb_assert (this_frame
!= NULL
);
2124 frame_pc_p
= get_frame_pc_if_available (this_frame
, &frame_pc
);
2126 /* tausq/2004-12-07: Dummy frames are skipped because it doesn't make much
2127 sense to stop unwinding at a dummy frame. One place where a dummy
2128 frame may have an address "inside_main_func" is on HPUX. On HPUX, the
2129 pcsqh register (space register for the instruction at the head of the
2130 instruction queue) cannot be written directly; the only way to set it
2131 is to branch to code that is in the target space. In order to implement
2132 frame dummies on HPUX, the called function is made to jump back to where
2133 the inferior was when the user function was called. If gdb was inside
2134 the main function when we created the dummy frame, the dummy frame will
2135 point inside the main function. */
2136 if (this_frame
->level
>= 0
2137 && get_frame_type (this_frame
) == NORMAL_FRAME
2138 && !backtrace_past_main
2140 && inside_main_func (this_frame
))
2141 /* Don't unwind past main(). Note, this is done _before_ the
2142 frame has been marked as previously unwound. That way if the
2143 user later decides to enable unwinds past main(), that will
2144 automatically happen. */
2146 frame_debug_got_null_frame (this_frame
, "inside main func");
2150 /* If the user's backtrace limit has been exceeded, stop. We must
2151 add two to the current level; one of those accounts for backtrace_limit
2152 being 1-based and the level being 0-based, and the other accounts for
2153 the level of the new frame instead of the level of the current
2155 if (this_frame
->level
+ 2 > backtrace_limit
)
2157 frame_debug_got_null_frame (this_frame
, "backtrace limit exceeded");
2161 /* If we're already inside the entry function for the main objfile,
2162 then it isn't valid. Don't apply this test to a dummy frame -
2163 dummy frame PCs typically land in the entry func. Don't apply
2164 this test to the sentinel frame. Sentinel frames should always
2165 be allowed to unwind. */
2166 /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() -
2167 wasn't checking for "main" in the minimal symbols. With that
2168 fixed asm-source tests now stop in "main" instead of halting the
2169 backtrace in weird and wonderful ways somewhere inside the entry
2170 file. Suspect that tests for inside the entry file/func were
2171 added to work around that (now fixed) case. */
2172 /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
2173 suggested having the inside_entry_func test use the
2174 inside_main_func() msymbol trick (along with entry_point_address()
2175 I guess) to determine the address range of the start function.
2176 That should provide a far better stopper than the current
2178 /* NOTE: tausq/2004-10-09: this is needed if, for example, the compiler
2179 applied tail-call optimizations to main so that a function called
2180 from main returns directly to the caller of main. Since we don't
2181 stop at main, we should at least stop at the entry point of the
2183 if (this_frame
->level
>= 0
2184 && get_frame_type (this_frame
) == NORMAL_FRAME
2185 && !backtrace_past_entry
2187 && inside_entry_func (this_frame
))
2189 frame_debug_got_null_frame (this_frame
, "inside entry func");
2193 /* Assume that the only way to get a zero PC is through something
2194 like a SIGSEGV or a dummy frame, and hence that NORMAL frames
2195 will never unwind a zero PC. */
2196 if (this_frame
->level
> 0
2197 && (get_frame_type (this_frame
) == NORMAL_FRAME
2198 || get_frame_type (this_frame
) == INLINE_FRAME
)
2199 && get_frame_type (get_next_frame (this_frame
)) == NORMAL_FRAME
2200 && frame_pc_p
&& frame_pc
== 0)
2202 frame_debug_got_null_frame (this_frame
, "zero PC");
2206 return get_prev_frame_always (this_frame
);
2210 get_frame_pc (struct frame_info
*frame
)
2212 gdb_assert (frame
->next
!= NULL
);
2213 return frame_unwind_pc (frame
->next
);
2217 get_frame_pc_if_available (struct frame_info
*frame
, CORE_ADDR
*pc
)
2220 gdb_assert (frame
->next
!= NULL
);
2224 *pc
= frame_unwind_pc (frame
->next
);
2226 CATCH (ex
, RETURN_MASK_ERROR
)
2228 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2231 throw_exception (ex
);
2238 /* Return an address that falls within THIS_FRAME's code block. */
2241 get_frame_address_in_block (struct frame_info
*this_frame
)
2243 /* A draft address. */
2244 CORE_ADDR pc
= get_frame_pc (this_frame
);
2246 struct frame_info
*next_frame
= this_frame
->next
;
2248 /* Calling get_frame_pc returns the resume address for THIS_FRAME.
2249 Normally the resume address is inside the body of the function
2250 associated with THIS_FRAME, but there is a special case: when
2251 calling a function which the compiler knows will never return
2252 (for instance abort), the call may be the very last instruction
2253 in the calling function. The resume address will point after the
2254 call and may be at the beginning of a different function
2257 If THIS_FRAME is a signal frame or dummy frame, then we should
2258 not adjust the unwound PC. For a dummy frame, GDB pushed the
2259 resume address manually onto the stack. For a signal frame, the
2260 OS may have pushed the resume address manually and invoked the
2261 handler (e.g. GNU/Linux), or invoked the trampoline which called
2262 the signal handler - but in either case the signal handler is
2263 expected to return to the trampoline. So in both of these
2264 cases we know that the resume address is executable and
2265 related. So we only need to adjust the PC if THIS_FRAME
2266 is a normal function.
2268 If the program has been interrupted while THIS_FRAME is current,
2269 then clearly the resume address is inside the associated
2270 function. There are three kinds of interruption: debugger stop
2271 (next frame will be SENTINEL_FRAME), operating system
2272 signal or exception (next frame will be SIGTRAMP_FRAME),
2273 or debugger-induced function call (next frame will be
2274 DUMMY_FRAME). So we only need to adjust the PC if
2275 NEXT_FRAME is a normal function.
2277 We check the type of NEXT_FRAME first, since it is already
2278 known; frame type is determined by the unwinder, and since
2279 we have THIS_FRAME we've already selected an unwinder for
2282 If the next frame is inlined, we need to keep going until we find
2283 the real function - for instance, if a signal handler is invoked
2284 while in an inlined function, then the code address of the
2285 "calling" normal function should not be adjusted either. */
2287 while (get_frame_type (next_frame
) == INLINE_FRAME
)
2288 next_frame
= next_frame
->next
;
2290 if ((get_frame_type (next_frame
) == NORMAL_FRAME
2291 || get_frame_type (next_frame
) == TAILCALL_FRAME
)
2292 && (get_frame_type (this_frame
) == NORMAL_FRAME
2293 || get_frame_type (this_frame
) == TAILCALL_FRAME
2294 || get_frame_type (this_frame
) == INLINE_FRAME
))
2301 get_frame_address_in_block_if_available (struct frame_info
*this_frame
,
2307 *pc
= get_frame_address_in_block (this_frame
);
2309 CATCH (ex
, RETURN_MASK_ERROR
)
2311 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2313 throw_exception (ex
);
2321 find_frame_sal (struct frame_info
*frame
, struct symtab_and_line
*sal
)
2323 struct frame_info
*next_frame
;
2327 /* If the next frame represents an inlined function call, this frame's
2328 sal is the "call site" of that inlined function, which can not
2329 be inferred from get_frame_pc. */
2330 next_frame
= get_next_frame (frame
);
2331 if (frame_inlined_callees (frame
) > 0)
2336 sym
= get_frame_function (next_frame
);
2338 sym
= inline_skipped_symbol (inferior_ptid
);
2340 /* If frame is inline, it certainly has symbols. */
2343 if (SYMBOL_LINE (sym
) != 0)
2345 sal
->symtab
= symbol_symtab (sym
);
2346 sal
->line
= SYMBOL_LINE (sym
);
2349 /* If the symbol does not have a location, we don't know where
2350 the call site is. Do not pretend to. This is jarring, but
2351 we can't do much better. */
2352 sal
->pc
= get_frame_pc (frame
);
2354 sal
->pspace
= get_frame_program_space (frame
);
2359 /* If FRAME is not the innermost frame, that normally means that
2360 FRAME->pc points at the return instruction (which is *after* the
2361 call instruction), and we want to get the line containing the
2362 call (because the call is where the user thinks the program is).
2363 However, if the next frame is either a SIGTRAMP_FRAME or a
2364 DUMMY_FRAME, then the next frame will contain a saved interrupt
2365 PC and such a PC indicates the current (rather than next)
2366 instruction/line, consequently, for such cases, want to get the
2367 line containing fi->pc. */
2368 if (!get_frame_pc_if_available (frame
, &pc
))
2374 notcurrent
= (pc
!= get_frame_address_in_block (frame
));
2375 (*sal
) = find_pc_line (pc
, notcurrent
);
2378 /* Per "frame.h", return the ``address'' of the frame. Code should
2379 really be using get_frame_id(). */
2381 get_frame_base (struct frame_info
*fi
)
2383 return get_frame_id (fi
).stack_addr
;
2386 /* High-level offsets into the frame. Used by the debug info. */
2389 get_frame_base_address (struct frame_info
*fi
)
2391 if (get_frame_type (fi
) != NORMAL_FRAME
)
2393 if (fi
->base
== NULL
)
2394 fi
->base
= frame_base_find_by_frame (fi
);
2395 /* Sneaky: If the low-level unwind and high-level base code share a
2396 common unwinder, let them share the prologue cache. */
2397 if (fi
->base
->unwind
== fi
->unwind
)
2398 return fi
->base
->this_base (fi
, &fi
->prologue_cache
);
2399 return fi
->base
->this_base (fi
, &fi
->base_cache
);
2403 get_frame_locals_address (struct frame_info
*fi
)
2405 if (get_frame_type (fi
) != NORMAL_FRAME
)
2407 /* If there isn't a frame address method, find it. */
2408 if (fi
->base
== NULL
)
2409 fi
->base
= frame_base_find_by_frame (fi
);
2410 /* Sneaky: If the low-level unwind and high-level base code share a
2411 common unwinder, let them share the prologue cache. */
2412 if (fi
->base
->unwind
== fi
->unwind
)
2413 return fi
->base
->this_locals (fi
, &fi
->prologue_cache
);
2414 return fi
->base
->this_locals (fi
, &fi
->base_cache
);
2418 get_frame_args_address (struct frame_info
*fi
)
2420 if (get_frame_type (fi
) != NORMAL_FRAME
)
2422 /* If there isn't a frame address method, find it. */
2423 if (fi
->base
== NULL
)
2424 fi
->base
= frame_base_find_by_frame (fi
);
2425 /* Sneaky: If the low-level unwind and high-level base code share a
2426 common unwinder, let them share the prologue cache. */
2427 if (fi
->base
->unwind
== fi
->unwind
)
2428 return fi
->base
->this_args (fi
, &fi
->prologue_cache
);
2429 return fi
->base
->this_args (fi
, &fi
->base_cache
);
2432 /* Return true if the frame unwinder for frame FI is UNWINDER; false
2436 frame_unwinder_is (struct frame_info
*fi
, const struct frame_unwind
*unwinder
)
2438 if (fi
->unwind
== NULL
)
2439 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
2440 return fi
->unwind
== unwinder
;
2443 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
2444 or -1 for a NULL frame. */
2447 frame_relative_level (struct frame_info
*fi
)
2456 get_frame_type (struct frame_info
*frame
)
2458 if (frame
->unwind
== NULL
)
2459 /* Initialize the frame's unwinder because that's what
2460 provides the frame's type. */
2461 frame_unwind_find_by_frame (frame
, &frame
->prologue_cache
);
2462 return frame
->unwind
->type
;
2465 struct program_space
*
2466 get_frame_program_space (struct frame_info
*frame
)
2468 return frame
->pspace
;
2471 struct program_space
*
2472 frame_unwind_program_space (struct frame_info
*this_frame
)
2474 gdb_assert (this_frame
);
2476 /* This is really a placeholder to keep the API consistent --- we
2477 assume for now that we don't have frame chains crossing
2479 return this_frame
->pspace
;
2482 struct address_space
*
2483 get_frame_address_space (struct frame_info
*frame
)
2485 return frame
->aspace
;
2488 /* Memory access methods. */
2491 get_frame_memory (struct frame_info
*this_frame
, CORE_ADDR addr
,
2492 gdb_byte
*buf
, int len
)
2494 read_memory (addr
, buf
, len
);
2498 get_frame_memory_signed (struct frame_info
*this_frame
, CORE_ADDR addr
,
2501 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2502 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2504 return read_memory_integer (addr
, len
, byte_order
);
2508 get_frame_memory_unsigned (struct frame_info
*this_frame
, CORE_ADDR addr
,
2511 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2512 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2514 return read_memory_unsigned_integer (addr
, len
, byte_order
);
2518 safe_frame_unwind_memory (struct frame_info
*this_frame
,
2519 CORE_ADDR addr
, gdb_byte
*buf
, int len
)
2521 /* NOTE: target_read_memory returns zero on success! */
2522 return !target_read_memory (addr
, buf
, len
);
2525 /* Architecture methods. */
2528 get_frame_arch (struct frame_info
*this_frame
)
2530 return frame_unwind_arch (this_frame
->next
);
2534 frame_unwind_arch (struct frame_info
*next_frame
)
2536 if (!next_frame
->prev_arch
.p
)
2538 struct gdbarch
*arch
;
2540 if (next_frame
->unwind
== NULL
)
2541 frame_unwind_find_by_frame (next_frame
, &next_frame
->prologue_cache
);
2543 if (next_frame
->unwind
->prev_arch
!= NULL
)
2544 arch
= next_frame
->unwind
->prev_arch (next_frame
,
2545 &next_frame
->prologue_cache
);
2547 arch
= get_frame_arch (next_frame
);
2549 next_frame
->prev_arch
.arch
= arch
;
2550 next_frame
->prev_arch
.p
= 1;
2552 fprintf_unfiltered (gdb_stdlog
,
2553 "{ frame_unwind_arch (next_frame=%d) -> %s }\n",
2555 gdbarch_bfd_arch_info (arch
)->printable_name
);
2558 return next_frame
->prev_arch
.arch
;
2562 frame_unwind_caller_arch (struct frame_info
*next_frame
)
2564 return frame_unwind_arch (skip_artificial_frames (next_frame
));
2567 /* Gets the language of FRAME. */
2570 get_frame_language (struct frame_info
*frame
)
2575 gdb_assert (frame
!= NULL
);
2577 /* We determine the current frame language by looking up its
2578 associated symtab. To retrieve this symtab, we use the frame
2579 PC. However we cannot use the frame PC as is, because it
2580 usually points to the instruction following the "call", which
2581 is sometimes the first instruction of another function. So
2582 we rely on get_frame_address_in_block(), it provides us with
2583 a PC that is guaranteed to be inside the frame's code
2588 pc
= get_frame_address_in_block (frame
);
2591 CATCH (ex
, RETURN_MASK_ERROR
)
2593 if (ex
.error
!= NOT_AVAILABLE_ERROR
)
2594 throw_exception (ex
);
2600 struct compunit_symtab
*cust
= find_pc_compunit_symtab (pc
);
2603 return compunit_language (cust
);
2606 return language_unknown
;
2609 /* Stack pointer methods. */
2612 get_frame_sp (struct frame_info
*this_frame
)
2614 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2616 /* Normality - an architecture that provides a way of obtaining any
2617 frame inner-most address. */
2618 if (gdbarch_unwind_sp_p (gdbarch
))
2619 /* NOTE drow/2008-06-28: gdbarch_unwind_sp could be converted to
2620 operate on THIS_FRAME now. */
2621 return gdbarch_unwind_sp (gdbarch
, this_frame
->next
);
2622 /* Now things are really are grim. Hope that the value returned by
2623 the gdbarch_sp_regnum register is meaningful. */
2624 if (gdbarch_sp_regnum (gdbarch
) >= 0)
2625 return get_frame_register_unsigned (this_frame
,
2626 gdbarch_sp_regnum (gdbarch
));
2627 internal_error (__FILE__
, __LINE__
, _("Missing unwind SP method"));
2630 /* Return the reason why we can't unwind past FRAME. */
2632 enum unwind_stop_reason
2633 get_frame_unwind_stop_reason (struct frame_info
*frame
)
2635 /* Fill-in STOP_REASON. */
2636 get_prev_frame_always (frame
);
2637 gdb_assert (frame
->prev_p
);
2639 return frame
->stop_reason
;
2642 /* Return a string explaining REASON. */
2645 unwind_stop_reason_to_string (enum unwind_stop_reason reason
)
2649 #define SET(name, description) \
2650 case name: return _(description);
2651 #include "unwind_stop_reasons.def"
2655 internal_error (__FILE__
, __LINE__
,
2656 "Invalid frame stop reason");
2661 frame_stop_reason_string (struct frame_info
*fi
)
2663 gdb_assert (fi
->prev_p
);
2664 gdb_assert (fi
->prev
== NULL
);
2666 /* Return the specific string if we have one. */
2667 if (fi
->stop_string
!= NULL
)
2668 return fi
->stop_string
;
2670 /* Return the generic string if we have nothing better. */
2671 return unwind_stop_reason_to_string (fi
->stop_reason
);
2674 /* Return the enum symbol name of REASON as a string, to use in debug
2678 frame_stop_reason_symbol_string (enum unwind_stop_reason reason
)
2682 #define SET(name, description) \
2683 case name: return #name;
2684 #include "unwind_stop_reasons.def"
2688 internal_error (__FILE__
, __LINE__
,
2689 "Invalid frame stop reason");
2693 /* Clean up after a failed (wrong unwinder) attempt to unwind past
2697 frame_cleanup_after_sniffer (void *arg
)
2699 struct frame_info
*frame
= (struct frame_info
*) arg
;
2701 /* The sniffer should not allocate a prologue cache if it did not
2702 match this frame. */
2703 gdb_assert (frame
->prologue_cache
== NULL
);
2705 /* No sniffer should extend the frame chain; sniff based on what is
2707 gdb_assert (!frame
->prev_p
);
2709 /* The sniffer should not check the frame's ID; that's circular. */
2710 gdb_assert (!frame
->this_id
.p
);
2712 /* Clear cached fields dependent on the unwinder.
2714 The previous PC is independent of the unwinder, but the previous
2715 function is not (see get_frame_address_in_block). */
2716 frame
->prev_func
.p
= 0;
2717 frame
->prev_func
.addr
= 0;
2719 /* Discard the unwinder last, so that we can easily find it if an assertion
2720 in this function triggers. */
2721 frame
->unwind
= NULL
;
2724 /* Set FRAME's unwinder temporarily, so that we can call a sniffer.
2725 Return a cleanup which should be called if unwinding fails, and
2726 discarded if it succeeds. */
2729 frame_prepare_for_sniffer (struct frame_info
*frame
,
2730 const struct frame_unwind
*unwind
)
2732 gdb_assert (frame
->unwind
== NULL
);
2733 frame
->unwind
= unwind
;
2734 return make_cleanup (frame_cleanup_after_sniffer
, frame
);
2737 extern initialize_file_ftype _initialize_frame
; /* -Wmissing-prototypes */
2739 static struct cmd_list_element
*set_backtrace_cmdlist
;
2740 static struct cmd_list_element
*show_backtrace_cmdlist
;
2743 set_backtrace_cmd (char *args
, int from_tty
)
2745 help_list (set_backtrace_cmdlist
, "set backtrace ", all_commands
,
2750 show_backtrace_cmd (char *args
, int from_tty
)
2752 cmd_show_list (show_backtrace_cmdlist
, from_tty
, "");
2756 _initialize_frame (void)
2758 obstack_init (&frame_cache_obstack
);
2760 frame_stash_create ();
2762 observer_attach_target_changed (frame_observer_target_changed
);
2764 add_prefix_cmd ("backtrace", class_maintenance
, set_backtrace_cmd
, _("\
2765 Set backtrace specific variables.\n\
2766 Configure backtrace variables such as the backtrace limit"),
2767 &set_backtrace_cmdlist
, "set backtrace ",
2768 0/*allow-unknown*/, &setlist
);
2769 add_prefix_cmd ("backtrace", class_maintenance
, show_backtrace_cmd
, _("\
2770 Show backtrace specific variables\n\
2771 Show backtrace variables such as the backtrace limit"),
2772 &show_backtrace_cmdlist
, "show backtrace ",
2773 0/*allow-unknown*/, &showlist
);
2775 add_setshow_boolean_cmd ("past-main", class_obscure
,
2776 &backtrace_past_main
, _("\
2777 Set whether backtraces should continue past \"main\"."), _("\
2778 Show whether backtraces should continue past \"main\"."), _("\
2779 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
2780 the backtrace at \"main\". Set this variable if you need to see the rest\n\
2781 of the stack trace."),
2783 show_backtrace_past_main
,
2784 &set_backtrace_cmdlist
,
2785 &show_backtrace_cmdlist
);
2787 add_setshow_boolean_cmd ("past-entry", class_obscure
,
2788 &backtrace_past_entry
, _("\
2789 Set whether backtraces should continue past the entry point of a program."),
2791 Show whether backtraces should continue past the entry point of a program."),
2793 Normally there are no callers beyond the entry point of a program, so GDB\n\
2794 will terminate the backtrace there. Set this variable if you need to see\n\
2795 the rest of the stack trace."),
2797 show_backtrace_past_entry
,
2798 &set_backtrace_cmdlist
,
2799 &show_backtrace_cmdlist
);
2801 add_setshow_uinteger_cmd ("limit", class_obscure
,
2802 &backtrace_limit
, _("\
2803 Set an upper bound on the number of backtrace levels."), _("\
2804 Show the upper bound on the number of backtrace levels."), _("\
2805 No more than the specified number of frames can be displayed or examined.\n\
2806 Literal \"unlimited\" or zero means no limit."),
2808 show_backtrace_limit
,
2809 &set_backtrace_cmdlist
,
2810 &show_backtrace_cmdlist
);
2812 /* Debug this files internals. */
2813 add_setshow_zuinteger_cmd ("frame", class_maintenance
, &frame_debug
, _("\
2814 Set frame debugging."), _("\
2815 Show frame debugging."), _("\
2816 When non-zero, frame specific internal debugging is enabled."),
2819 &setdebuglist
, &showdebuglist
);