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
);
444 skip_tailcall_frames (struct frame_info
*frame
)
446 while (get_frame_type (frame
) == TAILCALL_FRAME
)
447 frame
= get_prev_frame (frame
);
452 /* Compute the frame's uniq ID that can be used to, later, re-find the
456 compute_frame_id (struct frame_info
*fi
)
458 gdb_assert (!fi
->this_id
.p
);
461 fprintf_unfiltered (gdb_stdlog
, "{ compute_frame_id (fi=%d) ",
463 /* Find the unwinder. */
464 if (fi
->unwind
== NULL
)
465 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
466 /* Find THIS frame's ID. */
467 /* Default to outermost if no ID is found. */
468 fi
->this_id
.value
= outer_frame_id
;
469 fi
->unwind
->this_id (fi
, &fi
->prologue_cache
, &fi
->this_id
.value
);
470 gdb_assert (frame_id_p (fi
->this_id
.value
));
474 fprintf_unfiltered (gdb_stdlog
, "-> ");
475 fprint_frame_id (gdb_stdlog
, fi
->this_id
.value
);
476 fprintf_unfiltered (gdb_stdlog
, " }\n");
480 /* Return a frame uniq ID that can be used to, later, re-find the
484 get_frame_id (struct frame_info
*fi
)
487 return null_frame_id
;
489 gdb_assert (fi
->this_id
.p
);
490 return fi
->this_id
.value
;
494 get_stack_frame_id (struct frame_info
*next_frame
)
496 return get_frame_id (skip_artificial_frames (next_frame
));
500 frame_unwind_caller_id (struct frame_info
*next_frame
)
502 struct frame_info
*this_frame
;
504 /* Use get_prev_frame_always, and not get_prev_frame. The latter
505 will truncate the frame chain, leading to this function
506 unintentionally returning a null_frame_id (e.g., when a caller
507 requests the frame ID of "main()"s caller. */
509 next_frame
= skip_artificial_frames (next_frame
);
510 this_frame
= get_prev_frame_always (next_frame
);
512 return get_frame_id (skip_artificial_frames (this_frame
));
514 return null_frame_id
;
517 const struct frame_id null_frame_id
= { 0 }; /* All zeros. */
518 const struct frame_id outer_frame_id
= { 0, 0, 0, FID_STACK_INVALID
, 0, 1, 0 };
521 frame_id_build_special (CORE_ADDR stack_addr
, CORE_ADDR code_addr
,
522 CORE_ADDR special_addr
)
524 struct frame_id id
= null_frame_id
;
526 id
.stack_addr
= stack_addr
;
527 id
.stack_status
= FID_STACK_VALID
;
528 id
.code_addr
= code_addr
;
530 id
.special_addr
= special_addr
;
531 id
.special_addr_p
= 1;
538 frame_id_build_unavailable_stack (CORE_ADDR code_addr
)
540 struct frame_id id
= null_frame_id
;
542 id
.stack_status
= FID_STACK_UNAVAILABLE
;
543 id
.code_addr
= code_addr
;
551 frame_id_build_unavailable_stack_special (CORE_ADDR code_addr
,
552 CORE_ADDR special_addr
)
554 struct frame_id id
= null_frame_id
;
556 id
.stack_status
= FID_STACK_UNAVAILABLE
;
557 id
.code_addr
= code_addr
;
559 id
.special_addr
= special_addr
;
560 id
.special_addr_p
= 1;
565 frame_id_build (CORE_ADDR stack_addr
, CORE_ADDR code_addr
)
567 struct frame_id id
= null_frame_id
;
569 id
.stack_addr
= stack_addr
;
570 id
.stack_status
= FID_STACK_VALID
;
571 id
.code_addr
= code_addr
;
577 frame_id_build_wild (CORE_ADDR stack_addr
)
579 struct frame_id id
= null_frame_id
;
581 id
.stack_addr
= stack_addr
;
582 id
.stack_status
= FID_STACK_VALID
;
587 frame_id_p (struct frame_id l
)
591 /* The frame is valid iff it has a valid stack address. */
592 p
= l
.stack_status
!= FID_STACK_INVALID
;
593 /* outer_frame_id is also valid. */
594 if (!p
&& memcmp (&l
, &outer_frame_id
, sizeof (l
)) == 0)
598 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_p (l=");
599 fprint_frame_id (gdb_stdlog
, l
);
600 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", p
);
606 frame_id_artificial_p (struct frame_id l
)
611 return (l
.artificial_depth
!= 0);
615 frame_id_eq (struct frame_id l
, struct frame_id r
)
619 if (l
.stack_status
== FID_STACK_INVALID
&& l
.special_addr_p
620 && r
.stack_status
== FID_STACK_INVALID
&& r
.special_addr_p
)
621 /* The outermost frame marker is equal to itself. This is the
622 dodgy thing about outer_frame_id, since between execution steps
623 we might step into another function - from which we can't
624 unwind either. More thought required to get rid of
627 else if (l
.stack_status
== FID_STACK_INVALID
628 || r
.stack_status
== FID_STACK_INVALID
)
629 /* Like a NaN, if either ID is invalid, the result is false.
630 Note that a frame ID is invalid iff it is the null frame ID. */
632 else if (l
.stack_status
!= r
.stack_status
|| l
.stack_addr
!= r
.stack_addr
)
633 /* If .stack addresses are different, the frames are different. */
635 else if (l
.code_addr_p
&& r
.code_addr_p
&& l
.code_addr
!= r
.code_addr
)
636 /* An invalid code addr is a wild card. If .code addresses are
637 different, the frames are different. */
639 else if (l
.special_addr_p
&& r
.special_addr_p
640 && l
.special_addr
!= r
.special_addr
)
641 /* An invalid special addr is a wild card (or unused). Otherwise
642 if special addresses are different, the frames are different. */
644 else if (l
.artificial_depth
!= r
.artificial_depth
)
645 /* If artifical depths are different, the frames must be different. */
648 /* Frames are equal. */
653 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_eq (l=");
654 fprint_frame_id (gdb_stdlog
, l
);
655 fprintf_unfiltered (gdb_stdlog
, ",r=");
656 fprint_frame_id (gdb_stdlog
, r
);
657 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", eq
);
662 /* Safety net to check whether frame ID L should be inner to
663 frame ID R, according to their stack addresses.
665 This method cannot be used to compare arbitrary frames, as the
666 ranges of valid stack addresses may be discontiguous (e.g. due
669 However, it can be used as safety net to discover invalid frame
670 IDs in certain circumstances. Assuming that NEXT is the immediate
671 inner frame to THIS and that NEXT and THIS are both NORMAL frames:
673 * The stack address of NEXT must be inner-than-or-equal to the stack
676 Therefore, if frame_id_inner (THIS, NEXT) holds, some unwind
679 * If NEXT and THIS have different stack addresses, no other frame
680 in the frame chain may have a stack address in between.
682 Therefore, if frame_id_inner (TEST, THIS) holds, but
683 frame_id_inner (TEST, NEXT) does not hold, TEST cannot refer
684 to a valid frame in the frame chain.
686 The sanity checks above cannot be performed when a SIGTRAMP frame
687 is involved, because signal handlers might be executed on a different
688 stack than the stack used by the routine that caused the signal
689 to be raised. This can happen for instance when a thread exceeds
690 its maximum stack size. In this case, certain compilers implement
691 a stack overflow strategy that cause the handler to be run on a
695 frame_id_inner (struct gdbarch
*gdbarch
, struct frame_id l
, struct frame_id r
)
699 if (l
.stack_status
!= FID_STACK_VALID
|| r
.stack_status
!= FID_STACK_VALID
)
700 /* Like NaN, any operation involving an invalid ID always fails.
701 Likewise if either ID has an unavailable stack address. */
703 else if (l
.artificial_depth
> r
.artificial_depth
704 && l
.stack_addr
== r
.stack_addr
705 && l
.code_addr_p
== r
.code_addr_p
706 && l
.special_addr_p
== r
.special_addr_p
707 && l
.special_addr
== r
.special_addr
)
709 /* Same function, different inlined functions. */
710 const struct block
*lb
, *rb
;
712 gdb_assert (l
.code_addr_p
&& r
.code_addr_p
);
714 lb
= block_for_pc (l
.code_addr
);
715 rb
= block_for_pc (r
.code_addr
);
717 if (lb
== NULL
|| rb
== NULL
)
718 /* Something's gone wrong. */
721 /* This will return true if LB and RB are the same block, or
722 if the block with the smaller depth lexically encloses the
723 block with the greater depth. */
724 inner
= contained_in (lb
, rb
);
727 /* Only return non-zero when strictly inner than. Note that, per
728 comment in "frame.h", there is some fuzz here. Frameless
729 functions are not strictly inner than (same .stack but
730 different .code and/or .special address). */
731 inner
= gdbarch_inner_than (gdbarch
, l
.stack_addr
, r
.stack_addr
);
734 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_inner (l=");
735 fprint_frame_id (gdb_stdlog
, l
);
736 fprintf_unfiltered (gdb_stdlog
, ",r=");
737 fprint_frame_id (gdb_stdlog
, r
);
738 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", inner
);
744 frame_find_by_id (struct frame_id id
)
746 struct frame_info
*frame
, *prev_frame
;
748 /* ZERO denotes the null frame, let the caller decide what to do
749 about it. Should it instead return get_current_frame()? */
750 if (!frame_id_p (id
))
753 /* Try using the frame stash first. Finding it there removes the need
754 to perform the search by looping over all frames, which can be very
755 CPU-intensive if the number of frames is very high (the loop is O(n)
756 and get_prev_frame performs a series of checks that are relatively
757 expensive). This optimization is particularly useful when this function
758 is called from another function (such as value_fetch_lazy, case
759 VALUE_LVAL (val) == lval_register) which already loops over all frames,
760 making the overall behavior O(n^2). */
761 frame
= frame_stash_find (id
);
765 for (frame
= get_current_frame (); ; frame
= prev_frame
)
767 struct frame_id self
= get_frame_id (frame
);
769 if (frame_id_eq (id
, self
))
770 /* An exact match. */
773 prev_frame
= get_prev_frame (frame
);
777 /* As a safety net to avoid unnecessary backtracing while trying
778 to find an invalid ID, we check for a common situation where
779 we can detect from comparing stack addresses that no other
780 frame in the current frame chain can have this ID. See the
781 comment at frame_id_inner for details. */
782 if (get_frame_type (frame
) == NORMAL_FRAME
783 && !frame_id_inner (get_frame_arch (frame
), id
, self
)
784 && frame_id_inner (get_frame_arch (prev_frame
), id
,
785 get_frame_id (prev_frame
)))
792 frame_unwind_pc (struct frame_info
*this_frame
)
794 if (this_frame
->prev_pc
.status
== CC_UNKNOWN
)
796 if (gdbarch_unwind_pc_p (frame_unwind_arch (this_frame
)))
798 struct gdbarch
*prev_gdbarch
;
802 /* The right way. The `pure' way. The one true way. This
803 method depends solely on the register-unwind code to
804 determine the value of registers in THIS frame, and hence
805 the value of this frame's PC (resume address). A typical
806 implementation is no more than:
808 frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
809 return extract_unsigned_integer (buf, size of ISA_PC_REGNUM);
811 Note: this method is very heavily dependent on a correct
812 register-unwind implementation, it pays to fix that
813 method first; this method is frame type agnostic, since
814 it only deals with register values, it works with any
815 frame. This is all in stark contrast to the old
816 FRAME_SAVED_PC which would try to directly handle all the
817 different ways that a PC could be unwound. */
818 prev_gdbarch
= frame_unwind_arch (this_frame
);
822 pc
= gdbarch_unwind_pc (prev_gdbarch
, this_frame
);
825 CATCH (ex
, RETURN_MASK_ERROR
)
827 if (ex
.error
== NOT_AVAILABLE_ERROR
)
829 this_frame
->prev_pc
.status
= CC_UNAVAILABLE
;
832 fprintf_unfiltered (gdb_stdlog
,
833 "{ frame_unwind_pc (this_frame=%d)"
834 " -> <unavailable> }\n",
837 else if (ex
.error
== OPTIMIZED_OUT_ERROR
)
839 this_frame
->prev_pc
.status
= CC_NOT_SAVED
;
842 fprintf_unfiltered (gdb_stdlog
,
843 "{ frame_unwind_pc (this_frame=%d)"
844 " -> <not saved> }\n",
848 throw_exception (ex
);
854 this_frame
->prev_pc
.value
= pc
;
855 this_frame
->prev_pc
.status
= CC_VALUE
;
857 fprintf_unfiltered (gdb_stdlog
,
858 "{ frame_unwind_pc (this_frame=%d) "
861 hex_string (this_frame
->prev_pc
.value
));
865 internal_error (__FILE__
, __LINE__
, _("No unwind_pc method"));
868 if (this_frame
->prev_pc
.status
== CC_VALUE
)
869 return this_frame
->prev_pc
.value
;
870 else if (this_frame
->prev_pc
.status
== CC_UNAVAILABLE
)
871 throw_error (NOT_AVAILABLE_ERROR
, _("PC not available"));
872 else if (this_frame
->prev_pc
.status
== CC_NOT_SAVED
)
873 throw_error (OPTIMIZED_OUT_ERROR
, _("PC not saved"));
875 internal_error (__FILE__
, __LINE__
,
876 "unexpected prev_pc status: %d",
877 (int) this_frame
->prev_pc
.status
);
881 frame_unwind_caller_pc (struct frame_info
*this_frame
)
883 return frame_unwind_pc (skip_artificial_frames (this_frame
));
887 get_frame_func_if_available (struct frame_info
*this_frame
, CORE_ADDR
*pc
)
889 struct frame_info
*next_frame
= this_frame
->next
;
891 if (!next_frame
->prev_func
.p
)
893 CORE_ADDR addr_in_block
;
895 /* Make certain that this, and not the adjacent, function is
897 if (!get_frame_address_in_block_if_available (this_frame
, &addr_in_block
))
899 next_frame
->prev_func
.p
= -1;
901 fprintf_unfiltered (gdb_stdlog
,
902 "{ get_frame_func (this_frame=%d)"
903 " -> unavailable }\n",
908 next_frame
->prev_func
.p
= 1;
909 next_frame
->prev_func
.addr
= get_pc_function_start (addr_in_block
);
911 fprintf_unfiltered (gdb_stdlog
,
912 "{ get_frame_func (this_frame=%d) -> %s }\n",
914 hex_string (next_frame
->prev_func
.addr
));
918 if (next_frame
->prev_func
.p
< 0)
925 *pc
= next_frame
->prev_func
.addr
;
931 get_frame_func (struct frame_info
*this_frame
)
935 if (!get_frame_func_if_available (this_frame
, &pc
))
936 throw_error (NOT_AVAILABLE_ERROR
, _("PC not available"));
941 static enum register_status
942 do_frame_register_read (void *src
, int regnum
, gdb_byte
*buf
)
944 if (!deprecated_frame_register_read ((struct frame_info
*) src
, regnum
, buf
))
945 return REG_UNAVAILABLE
;
951 frame_save_as_regcache (struct frame_info
*this_frame
)
953 struct address_space
*aspace
= get_frame_address_space (this_frame
);
954 struct regcache
*regcache
= regcache_xmalloc (get_frame_arch (this_frame
),
956 struct cleanup
*cleanups
= make_cleanup_regcache_xfree (regcache
);
958 regcache_save (regcache
, do_frame_register_read
, this_frame
);
959 discard_cleanups (cleanups
);
964 frame_pop (struct frame_info
*this_frame
)
966 struct frame_info
*prev_frame
;
967 struct regcache
*scratch
;
968 struct cleanup
*cleanups
;
970 if (get_frame_type (this_frame
) == DUMMY_FRAME
)
972 /* Popping a dummy frame involves restoring more than just registers.
973 dummy_frame_pop does all the work. */
974 dummy_frame_pop (get_frame_id (this_frame
), inferior_ptid
);
978 /* Ensure that we have a frame to pop to. */
979 prev_frame
= get_prev_frame_always (this_frame
);
982 error (_("Cannot pop the initial frame."));
984 /* Ignore TAILCALL_FRAME type frames, they were executed already before
985 entering THISFRAME. */
986 prev_frame
= skip_tailcall_frames (prev_frame
);
988 /* Make a copy of all the register values unwound from this frame.
989 Save them in a scratch buffer so that there isn't a race between
990 trying to extract the old values from the current regcache while
991 at the same time writing new values into that same cache. */
992 scratch
= frame_save_as_regcache (prev_frame
);
993 cleanups
= make_cleanup_regcache_xfree (scratch
);
995 /* FIXME: cagney/2003-03-16: It should be possible to tell the
996 target's register cache that it is about to be hit with a burst
997 register transfer and that the sequence of register writes should
998 be batched. The pair target_prepare_to_store() and
999 target_store_registers() kind of suggest this functionality.
1000 Unfortunately, they don't implement it. Their lack of a formal
1001 definition can lead to targets writing back bogus values
1002 (arguably a bug in the target code mind). */
1003 /* Now copy those saved registers into the current regcache.
1004 Here, regcache_cpy() calls regcache_restore(). */
1005 regcache_cpy (get_current_regcache (), scratch
);
1006 do_cleanups (cleanups
);
1008 /* We've made right mess of GDB's local state, just discard
1010 reinit_frame_cache ();
1014 frame_register_unwind (struct frame_info
*frame
, int regnum
,
1015 int *optimizedp
, int *unavailablep
,
1016 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
1017 int *realnump
, gdb_byte
*bufferp
)
1019 struct value
*value
;
1021 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
1022 that the value proper does not need to be fetched. */
1023 gdb_assert (optimizedp
!= NULL
);
1024 gdb_assert (lvalp
!= NULL
);
1025 gdb_assert (addrp
!= NULL
);
1026 gdb_assert (realnump
!= NULL
);
1027 /* gdb_assert (bufferp != NULL); */
1029 value
= frame_unwind_register_value (frame
, regnum
);
1031 gdb_assert (value
!= NULL
);
1033 *optimizedp
= value_optimized_out (value
);
1034 *unavailablep
= !value_entirely_available (value
);
1035 *lvalp
= VALUE_LVAL (value
);
1036 *addrp
= value_address (value
);
1037 *realnump
= VALUE_REGNUM (value
);
1041 if (!*optimizedp
&& !*unavailablep
)
1042 memcpy (bufferp
, value_contents_all (value
),
1043 TYPE_LENGTH (value_type (value
)));
1045 memset (bufferp
, 0, TYPE_LENGTH (value_type (value
)));
1048 /* Dispose of the new value. This prevents watchpoints from
1049 trying to watch the saved frame pointer. */
1050 release_value (value
);
1055 frame_register (struct frame_info
*frame
, int regnum
,
1056 int *optimizedp
, int *unavailablep
, enum lval_type
*lvalp
,
1057 CORE_ADDR
*addrp
, int *realnump
, gdb_byte
*bufferp
)
1059 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
1060 that the value proper does not need to be fetched. */
1061 gdb_assert (optimizedp
!= NULL
);
1062 gdb_assert (lvalp
!= NULL
);
1063 gdb_assert (addrp
!= NULL
);
1064 gdb_assert (realnump
!= NULL
);
1065 /* gdb_assert (bufferp != NULL); */
1067 /* Obtain the register value by unwinding the register from the next
1068 (more inner frame). */
1069 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
1070 frame_register_unwind (frame
->next
, regnum
, optimizedp
, unavailablep
,
1071 lvalp
, addrp
, realnump
, bufferp
);
1075 frame_unwind_register (struct frame_info
*frame
, int regnum
, gdb_byte
*buf
)
1081 enum lval_type lval
;
1083 frame_register_unwind (frame
, regnum
, &optimized
, &unavailable
,
1084 &lval
, &addr
, &realnum
, buf
);
1087 throw_error (OPTIMIZED_OUT_ERROR
,
1088 _("Register %d was not saved"), regnum
);
1090 throw_error (NOT_AVAILABLE_ERROR
,
1091 _("Register %d is not available"), regnum
);
1095 get_frame_register (struct frame_info
*frame
,
1096 int regnum
, gdb_byte
*buf
)
1098 frame_unwind_register (frame
->next
, regnum
, buf
);
1102 frame_unwind_register_value (struct frame_info
*frame
, int regnum
)
1104 struct gdbarch
*gdbarch
;
1105 struct value
*value
;
1107 gdb_assert (frame
!= NULL
);
1108 gdbarch
= frame_unwind_arch (frame
);
1112 fprintf_unfiltered (gdb_stdlog
,
1113 "{ frame_unwind_register_value "
1114 "(frame=%d,regnum=%d(%s),...) ",
1115 frame
->level
, regnum
,
1116 user_reg_map_regnum_to_name (gdbarch
, regnum
));
1119 /* Find the unwinder. */
1120 if (frame
->unwind
== NULL
)
1121 frame_unwind_find_by_frame (frame
, &frame
->prologue_cache
);
1123 /* Ask this frame to unwind its register. */
1124 value
= frame
->unwind
->prev_register (frame
, &frame
->prologue_cache
, regnum
);
1128 fprintf_unfiltered (gdb_stdlog
, "->");
1129 if (value_optimized_out (value
))
1131 fprintf_unfiltered (gdb_stdlog
, " ");
1132 val_print_optimized_out (value
, gdb_stdlog
);
1136 if (VALUE_LVAL (value
) == lval_register
)
1137 fprintf_unfiltered (gdb_stdlog
, " register=%d",
1138 VALUE_REGNUM (value
));
1139 else if (VALUE_LVAL (value
) == lval_memory
)
1140 fprintf_unfiltered (gdb_stdlog
, " address=%s",
1142 value_address (value
)));
1144 fprintf_unfiltered (gdb_stdlog
, " computed");
1146 if (value_lazy (value
))
1147 fprintf_unfiltered (gdb_stdlog
, " lazy");
1151 const gdb_byte
*buf
= value_contents (value
);
1153 fprintf_unfiltered (gdb_stdlog
, " bytes=");
1154 fprintf_unfiltered (gdb_stdlog
, "[");
1155 for (i
= 0; i
< register_size (gdbarch
, regnum
); i
++)
1156 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1157 fprintf_unfiltered (gdb_stdlog
, "]");
1161 fprintf_unfiltered (gdb_stdlog
, " }\n");
1168 get_frame_register_value (struct frame_info
*frame
, int regnum
)
1170 return frame_unwind_register_value (frame
->next
, regnum
);
1174 frame_unwind_register_signed (struct frame_info
*frame
, int regnum
)
1176 struct gdbarch
*gdbarch
= frame_unwind_arch (frame
);
1177 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1178 int size
= register_size (gdbarch
, regnum
);
1179 gdb_byte buf
[MAX_REGISTER_SIZE
];
1181 frame_unwind_register (frame
, regnum
, buf
);
1182 return extract_signed_integer (buf
, size
, byte_order
);
1186 get_frame_register_signed (struct frame_info
*frame
, int regnum
)
1188 return frame_unwind_register_signed (frame
->next
, regnum
);
1192 frame_unwind_register_unsigned (struct frame_info
*frame
, int regnum
)
1194 struct gdbarch
*gdbarch
= frame_unwind_arch (frame
);
1195 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1196 int size
= register_size (gdbarch
, regnum
);
1197 gdb_byte buf
[MAX_REGISTER_SIZE
];
1199 frame_unwind_register (frame
, regnum
, buf
);
1200 return extract_unsigned_integer (buf
, size
, byte_order
);
1204 get_frame_register_unsigned (struct frame_info
*frame
, int regnum
)
1206 return frame_unwind_register_unsigned (frame
->next
, regnum
);
1210 read_frame_register_unsigned (struct frame_info
*frame
, int regnum
,
1213 struct value
*regval
= get_frame_register_value (frame
, regnum
);
1215 if (!value_optimized_out (regval
)
1216 && value_entirely_available (regval
))
1218 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1219 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1220 int size
= register_size (gdbarch
, VALUE_REGNUM (regval
));
1222 *val
= extract_unsigned_integer (value_contents (regval
), size
, byte_order
);
1230 put_frame_register (struct frame_info
*frame
, int regnum
,
1231 const gdb_byte
*buf
)
1233 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1237 enum lval_type lval
;
1240 frame_register (frame
, regnum
, &optim
, &unavail
,
1241 &lval
, &addr
, &realnum
, NULL
);
1243 error (_("Attempt to assign to a register that was not saved."));
1248 write_memory (addr
, buf
, register_size (gdbarch
, regnum
));
1252 regcache_cooked_write (get_current_regcache (), realnum
, buf
);
1255 error (_("Attempt to assign to an unmodifiable value."));
1259 /* This function is deprecated. Use get_frame_register_value instead,
1260 which provides more accurate information.
1262 Find and return the value of REGNUM for the specified stack frame.
1263 The number of bytes copied is REGISTER_SIZE (REGNUM).
1265 Returns 0 if the register value could not be found. */
1268 deprecated_frame_register_read (struct frame_info
*frame
, int regnum
,
1273 enum lval_type lval
;
1277 frame_register (frame
, regnum
, &optimized
, &unavailable
,
1278 &lval
, &addr
, &realnum
, myaddr
);
1280 return !optimized
&& !unavailable
;
1284 get_frame_register_bytes (struct frame_info
*frame
, int regnum
,
1285 CORE_ADDR offset
, int len
, gdb_byte
*myaddr
,
1286 int *optimizedp
, int *unavailablep
)
1288 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1293 /* Skip registers wholly inside of OFFSET. */
1294 while (offset
>= register_size (gdbarch
, regnum
))
1296 offset
-= register_size (gdbarch
, regnum
);
1300 /* Ensure that we will not read beyond the end of the register file.
1301 This can only ever happen if the debug information is bad. */
1303 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1304 for (i
= regnum
; i
< numregs
; i
++)
1306 int thissize
= register_size (gdbarch
, i
);
1309 break; /* This register is not available on this architecture. */
1310 maxsize
+= thissize
;
1313 error (_("Bad debug information detected: "
1314 "Attempt to read %d bytes from registers."), len
);
1316 /* Copy the data. */
1319 int curr_len
= register_size (gdbarch
, regnum
) - offset
;
1324 if (curr_len
== register_size (gdbarch
, regnum
))
1326 enum lval_type lval
;
1330 frame_register (frame
, regnum
, optimizedp
, unavailablep
,
1331 &lval
, &addr
, &realnum
, myaddr
);
1332 if (*optimizedp
|| *unavailablep
)
1337 gdb_byte buf
[MAX_REGISTER_SIZE
];
1338 enum lval_type lval
;
1342 frame_register (frame
, regnum
, optimizedp
, unavailablep
,
1343 &lval
, &addr
, &realnum
, buf
);
1344 if (*optimizedp
|| *unavailablep
)
1346 memcpy (myaddr
, buf
+ offset
, curr_len
);
1361 put_frame_register_bytes (struct frame_info
*frame
, int regnum
,
1362 CORE_ADDR offset
, int len
, const gdb_byte
*myaddr
)
1364 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1366 /* Skip registers wholly inside of OFFSET. */
1367 while (offset
>= register_size (gdbarch
, regnum
))
1369 offset
-= register_size (gdbarch
, regnum
);
1373 /* Copy the data. */
1376 int curr_len
= register_size (gdbarch
, regnum
) - offset
;
1381 if (curr_len
== register_size (gdbarch
, regnum
))
1383 put_frame_register (frame
, regnum
, myaddr
);
1387 gdb_byte buf
[MAX_REGISTER_SIZE
];
1389 deprecated_frame_register_read (frame
, regnum
, buf
);
1390 memcpy (buf
+ offset
, myaddr
, curr_len
);
1391 put_frame_register (frame
, regnum
, buf
);
1401 /* Create a sentinel frame. */
1403 static struct frame_info
*
1404 create_sentinel_frame (struct program_space
*pspace
, struct regcache
*regcache
)
1406 struct frame_info
*frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1409 frame
->pspace
= pspace
;
1410 frame
->aspace
= get_regcache_aspace (regcache
);
1411 /* Explicitly initialize the sentinel frame's cache. Provide it
1412 with the underlying regcache. In the future additional
1413 information, such as the frame's thread will be added. */
1414 frame
->prologue_cache
= sentinel_frame_cache (regcache
);
1415 /* For the moment there is only one sentinel frame implementation. */
1416 frame
->unwind
= &sentinel_frame_unwind
;
1417 /* Link this frame back to itself. The frame is self referential
1418 (the unwound PC is the same as the pc), so make it so. */
1419 frame
->next
= frame
;
1420 /* Make the sentinel frame's ID valid, but invalid. That way all
1421 comparisons with it should fail. */
1422 frame
->this_id
.p
= 1;
1423 frame
->this_id
.value
= null_frame_id
;
1426 fprintf_unfiltered (gdb_stdlog
, "{ create_sentinel_frame (...) -> ");
1427 fprint_frame (gdb_stdlog
, frame
);
1428 fprintf_unfiltered (gdb_stdlog
, " }\n");
1433 /* Info about the innermost stack frame (contents of FP register). */
1435 static struct frame_info
*current_frame
;
1437 /* Cache for frame addresses already read by gdb. Valid only while
1438 inferior is stopped. Control variables for the frame cache should
1439 be local to this module. */
1441 static struct obstack frame_cache_obstack
;
1444 frame_obstack_zalloc (unsigned long size
)
1446 void *data
= obstack_alloc (&frame_cache_obstack
, size
);
1448 memset (data
, 0, size
);
1452 /* Return the innermost (currently executing) stack frame. This is
1453 split into two functions. The function unwind_to_current_frame()
1454 is wrapped in catch exceptions so that, even when the unwind of the
1455 sentinel frame fails, the function still returns a stack frame. */
1458 unwind_to_current_frame (struct ui_out
*ui_out
, void *args
)
1460 struct frame_info
*frame
= get_prev_frame ((struct frame_info
*) args
);
1462 /* A sentinel frame can fail to unwind, e.g., because its PC value
1463 lands in somewhere like start. */
1466 current_frame
= frame
;
1471 get_current_frame (void)
1473 /* First check, and report, the lack of registers. Having GDB
1474 report "No stack!" or "No memory" when the target doesn't even
1475 have registers is very confusing. Besides, "printcmd.exp"
1476 explicitly checks that ``print $pc'' with no registers prints "No
1478 if (!target_has_registers
)
1479 error (_("No registers."));
1480 if (!target_has_stack
)
1481 error (_("No stack."));
1482 if (!target_has_memory
)
1483 error (_("No memory."));
1484 /* Traceframes are effectively a substitute for the live inferior. */
1485 if (get_traceframe_number () < 0)
1486 validate_registers_access ();
1488 if (current_frame
== NULL
)
1490 struct frame_info
*sentinel_frame
=
1491 create_sentinel_frame (current_program_space
, get_current_regcache ());
1492 if (catch_exceptions (current_uiout
, unwind_to_current_frame
,
1493 sentinel_frame
, RETURN_MASK_ERROR
) != 0)
1495 /* Oops! Fake a current frame? Is this useful? It has a PC
1496 of zero, for instance. */
1497 current_frame
= sentinel_frame
;
1500 return current_frame
;
1503 /* The "selected" stack frame is used by default for local and arg
1504 access. May be zero, for no selected frame. */
1506 static struct frame_info
*selected_frame
;
1509 has_stack_frames (void)
1511 if (!target_has_registers
|| !target_has_stack
|| !target_has_memory
)
1514 /* Traceframes are effectively a substitute for the live inferior. */
1515 if (get_traceframe_number () < 0)
1517 /* No current inferior, no frame. */
1518 if (ptid_equal (inferior_ptid
, null_ptid
))
1521 /* Don't try to read from a dead thread. */
1522 if (is_exited (inferior_ptid
))
1525 /* ... or from a spinning thread. */
1526 if (is_executing (inferior_ptid
))
1533 /* Return the selected frame. Always non-NULL (unless there isn't an
1534 inferior sufficient for creating a frame) in which case an error is
1538 get_selected_frame (const char *message
)
1540 if (selected_frame
== NULL
)
1542 if (message
!= NULL
&& !has_stack_frames ())
1543 error (("%s"), message
);
1544 /* Hey! Don't trust this. It should really be re-finding the
1545 last selected frame of the currently selected thread. This,
1546 though, is better than nothing. */
1547 select_frame (get_current_frame ());
1549 /* There is always a frame. */
1550 gdb_assert (selected_frame
!= NULL
);
1551 return selected_frame
;
1554 /* If there is a selected frame, return it. Otherwise, return NULL. */
1557 get_selected_frame_if_set (void)
1559 return selected_frame
;
1562 /* This is a variant of get_selected_frame() which can be called when
1563 the inferior does not have a frame; in that case it will return
1564 NULL instead of calling error(). */
1567 deprecated_safe_get_selected_frame (void)
1569 if (!has_stack_frames ())
1571 return get_selected_frame (NULL
);
1574 /* Select frame FI (or NULL - to invalidate the current frame). */
1577 select_frame (struct frame_info
*fi
)
1579 selected_frame
= fi
;
1580 /* NOTE: cagney/2002-05-04: FI can be NULL. This occurs when the
1581 frame is being invalidated. */
1583 /* FIXME: kseitz/2002-08-28: It would be nice to call
1584 selected_frame_level_changed_event() right here, but due to limitations
1585 in the current interfaces, we would end up flooding UIs with events
1586 because select_frame() is used extensively internally.
1588 Once we have frame-parameterized frame (and frame-related) commands,
1589 the event notification can be moved here, since this function will only
1590 be called when the user's selected frame is being changed. */
1592 /* Ensure that symbols for this frame are read in. Also, determine the
1593 source language of this frame, and switch to it if desired. */
1598 /* We retrieve the frame's symtab by using the frame PC.
1599 However we cannot use the frame PC as-is, because it usually
1600 points to the instruction following the "call", which is
1601 sometimes the first instruction of another function. So we
1602 rely on get_frame_address_in_block() which provides us with a
1603 PC which is guaranteed to be inside the frame's code
1605 if (get_frame_address_in_block_if_available (fi
, &pc
))
1607 struct compunit_symtab
*cust
= find_pc_compunit_symtab (pc
);
1610 && compunit_language (cust
) != current_language
->la_language
1611 && compunit_language (cust
) != language_unknown
1612 && language_mode
== language_mode_auto
)
1613 set_language (compunit_language (cust
));
1618 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
1619 Always returns a non-NULL value. */
1622 create_new_frame (CORE_ADDR addr
, CORE_ADDR pc
)
1624 struct frame_info
*fi
;
1628 fprintf_unfiltered (gdb_stdlog
,
1629 "{ create_new_frame (addr=%s, pc=%s) ",
1630 hex_string (addr
), hex_string (pc
));
1633 fi
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1635 fi
->next
= create_sentinel_frame (current_program_space
,
1636 get_current_regcache ());
1638 /* Set/update this frame's cached PC value, found in the next frame.
1639 Do this before looking for this frame's unwinder. A sniffer is
1640 very likely to read this, and the corresponding unwinder is
1641 entitled to rely that the PC doesn't magically change. */
1642 fi
->next
->prev_pc
.value
= pc
;
1643 fi
->next
->prev_pc
.status
= CC_VALUE
;
1645 /* We currently assume that frame chain's can't cross spaces. */
1646 fi
->pspace
= fi
->next
->pspace
;
1647 fi
->aspace
= fi
->next
->aspace
;
1649 /* Select/initialize both the unwind function and the frame's type
1651 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
1654 fi
->this_id
.value
= frame_id_build (addr
, pc
);
1658 fprintf_unfiltered (gdb_stdlog
, "-> ");
1659 fprint_frame (gdb_stdlog
, fi
);
1660 fprintf_unfiltered (gdb_stdlog
, " }\n");
1666 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
1667 innermost frame). Be careful to not fall off the bottom of the
1668 frame chain and onto the sentinel frame. */
1671 get_next_frame (struct frame_info
*this_frame
)
1673 if (this_frame
->level
> 0)
1674 return this_frame
->next
;
1679 /* Observer for the target_changed event. */
1682 frame_observer_target_changed (struct target_ops
*target
)
1684 reinit_frame_cache ();
1687 /* Flush the entire frame cache. */
1690 reinit_frame_cache (void)
1692 struct frame_info
*fi
;
1694 /* Tear down all frame caches. */
1695 for (fi
= current_frame
; fi
!= NULL
; fi
= fi
->prev
)
1697 if (fi
->prologue_cache
&& fi
->unwind
->dealloc_cache
)
1698 fi
->unwind
->dealloc_cache (fi
, fi
->prologue_cache
);
1699 if (fi
->base_cache
&& fi
->base
->unwind
->dealloc_cache
)
1700 fi
->base
->unwind
->dealloc_cache (fi
, fi
->base_cache
);
1703 /* Since we can't really be sure what the first object allocated was. */
1704 obstack_free (&frame_cache_obstack
, 0);
1705 obstack_init (&frame_cache_obstack
);
1707 if (current_frame
!= NULL
)
1708 annotate_frames_invalid ();
1710 current_frame
= NULL
; /* Invalidate cache */
1711 select_frame (NULL
);
1712 frame_stash_invalidate ();
1714 fprintf_unfiltered (gdb_stdlog
, "{ reinit_frame_cache () }\n");
1717 /* Find where a register is saved (in memory or another register).
1718 The result of frame_register_unwind is just where it is saved
1719 relative to this particular frame. */
1722 frame_register_unwind_location (struct frame_info
*this_frame
, int regnum
,
1723 int *optimizedp
, enum lval_type
*lvalp
,
1724 CORE_ADDR
*addrp
, int *realnump
)
1726 gdb_assert (this_frame
== NULL
|| this_frame
->level
>= 0);
1728 while (this_frame
!= NULL
)
1732 frame_register_unwind (this_frame
, regnum
, optimizedp
, &unavailable
,
1733 lvalp
, addrp
, realnump
, NULL
);
1738 if (*lvalp
!= lval_register
)
1742 this_frame
= get_next_frame (this_frame
);
1746 /* Called during frame unwinding to remove a previous frame pointer from a
1747 frame passed in ARG. */
1750 remove_prev_frame (void *arg
)
1752 struct frame_info
*this_frame
, *prev_frame
;
1754 this_frame
= (struct frame_info
*) arg
;
1755 prev_frame
= this_frame
->prev
;
1756 gdb_assert (prev_frame
!= NULL
);
1758 prev_frame
->next
= NULL
;
1759 this_frame
->prev
= NULL
;
1762 /* Get the previous raw frame, and check that it is not identical to
1763 same other frame frame already in the chain. If it is, there is
1764 most likely a stack cycle, so we discard it, and mark THIS_FRAME as
1765 outermost, with UNWIND_SAME_ID stop reason. Unlike the other
1766 validity tests, that compare THIS_FRAME and the next frame, we do
1767 this right after creating the previous frame, to avoid ever ending
1768 up with two frames with the same id in the frame chain. */
1770 static struct frame_info
*
1771 get_prev_frame_if_no_cycle (struct frame_info
*this_frame
)
1773 struct frame_info
*prev_frame
;
1774 struct cleanup
*prev_frame_cleanup
;
1776 prev_frame
= get_prev_frame_raw (this_frame
);
1777 if (prev_frame
== NULL
)
1780 /* The cleanup will remove the previous frame that get_prev_frame_raw
1781 linked onto THIS_FRAME. */
1782 prev_frame_cleanup
= make_cleanup (remove_prev_frame
, this_frame
);
1784 compute_frame_id (prev_frame
);
1785 if (!frame_stash_add (prev_frame
))
1787 /* Another frame with the same id was already in the stash. We just
1788 detected a cycle. */
1791 fprintf_unfiltered (gdb_stdlog
, "-> ");
1792 fprint_frame (gdb_stdlog
, NULL
);
1793 fprintf_unfiltered (gdb_stdlog
, " // this frame has same ID }\n");
1795 this_frame
->stop_reason
= UNWIND_SAME_ID
;
1797 prev_frame
->next
= NULL
;
1798 this_frame
->prev
= NULL
;
1802 discard_cleanups (prev_frame_cleanup
);
1806 /* Helper function for get_prev_frame_always, this is called inside a
1807 TRY_CATCH block. Return the frame that called THIS_FRAME or NULL if
1808 there is no such frame. This may throw an exception. */
1810 static struct frame_info
*
1811 get_prev_frame_always_1 (struct frame_info
*this_frame
)
1813 struct gdbarch
*gdbarch
;
1815 gdb_assert (this_frame
!= NULL
);
1816 gdbarch
= get_frame_arch (this_frame
);
1820 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame_always (this_frame=");
1821 if (this_frame
!= NULL
)
1822 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1824 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1825 fprintf_unfiltered (gdb_stdlog
, ") ");
1828 /* Only try to do the unwind once. */
1829 if (this_frame
->prev_p
)
1833 fprintf_unfiltered (gdb_stdlog
, "-> ");
1834 fprint_frame (gdb_stdlog
, this_frame
->prev
);
1835 fprintf_unfiltered (gdb_stdlog
, " // cached \n");
1837 return this_frame
->prev
;
1840 /* If the frame unwinder hasn't been selected yet, we must do so
1841 before setting prev_p; otherwise the check for misbehaved
1842 sniffers will think that this frame's sniffer tried to unwind
1843 further (see frame_cleanup_after_sniffer). */
1844 if (this_frame
->unwind
== NULL
)
1845 frame_unwind_find_by_frame (this_frame
, &this_frame
->prologue_cache
);
1847 this_frame
->prev_p
= 1;
1848 this_frame
->stop_reason
= UNWIND_NO_REASON
;
1850 /* If we are unwinding from an inline frame, all of the below tests
1851 were already performed when we unwound from the next non-inline
1852 frame. We must skip them, since we can not get THIS_FRAME's ID
1853 until we have unwound all the way down to the previous non-inline
1855 if (get_frame_type (this_frame
) == INLINE_FRAME
)
1856 return get_prev_frame_if_no_cycle (this_frame
);
1858 /* Check that this frame is unwindable. If it isn't, don't try to
1859 unwind to the prev frame. */
1860 this_frame
->stop_reason
1861 = this_frame
->unwind
->stop_reason (this_frame
,
1862 &this_frame
->prologue_cache
);
1864 if (this_frame
->stop_reason
!= UNWIND_NO_REASON
)
1868 enum unwind_stop_reason reason
= this_frame
->stop_reason
;
1870 fprintf_unfiltered (gdb_stdlog
, "-> ");
1871 fprint_frame (gdb_stdlog
, NULL
);
1872 fprintf_unfiltered (gdb_stdlog
, " // %s }\n",
1873 frame_stop_reason_symbol_string (reason
));
1878 /* Check that this frame's ID isn't inner to (younger, below, next)
1879 the next frame. This happens when a frame unwind goes backwards.
1880 This check is valid only if this frame and the next frame are NORMAL.
1881 See the comment at frame_id_inner for details. */
1882 if (get_frame_type (this_frame
) == NORMAL_FRAME
1883 && this_frame
->next
->unwind
->type
== NORMAL_FRAME
1884 && frame_id_inner (get_frame_arch (this_frame
->next
),
1885 get_frame_id (this_frame
),
1886 get_frame_id (this_frame
->next
)))
1888 CORE_ADDR this_pc_in_block
;
1889 struct minimal_symbol
*morestack_msym
;
1890 const char *morestack_name
= NULL
;
1892 /* gcc -fsplit-stack __morestack can continue the stack anywhere. */
1893 this_pc_in_block
= get_frame_address_in_block (this_frame
);
1894 morestack_msym
= lookup_minimal_symbol_by_pc (this_pc_in_block
).minsym
;
1896 morestack_name
= MSYMBOL_LINKAGE_NAME (morestack_msym
);
1897 if (!morestack_name
|| strcmp (morestack_name
, "__morestack") != 0)
1901 fprintf_unfiltered (gdb_stdlog
, "-> ");
1902 fprint_frame (gdb_stdlog
, NULL
);
1903 fprintf_unfiltered (gdb_stdlog
,
1904 " // this frame ID is inner }\n");
1906 this_frame
->stop_reason
= UNWIND_INNER_ID
;
1911 /* Check that this and the next frame do not unwind the PC register
1912 to the same memory location. If they do, then even though they
1913 have different frame IDs, the new frame will be bogus; two
1914 functions can't share a register save slot for the PC. This can
1915 happen when the prologue analyzer finds a stack adjustment, but
1918 This check does assume that the "PC register" is roughly a
1919 traditional PC, even if the gdbarch_unwind_pc method adjusts
1920 it (we do not rely on the value, only on the unwound PC being
1921 dependent on this value). A potential improvement would be
1922 to have the frame prev_pc method and the gdbarch unwind_pc
1923 method set the same lval and location information as
1924 frame_register_unwind. */
1925 if (this_frame
->level
> 0
1926 && gdbarch_pc_regnum (gdbarch
) >= 0
1927 && get_frame_type (this_frame
) == NORMAL_FRAME
1928 && (get_frame_type (this_frame
->next
) == NORMAL_FRAME
1929 || get_frame_type (this_frame
->next
) == INLINE_FRAME
))
1931 int optimized
, realnum
, nrealnum
;
1932 enum lval_type lval
, nlval
;
1933 CORE_ADDR addr
, naddr
;
1935 frame_register_unwind_location (this_frame
,
1936 gdbarch_pc_regnum (gdbarch
),
1937 &optimized
, &lval
, &addr
, &realnum
);
1938 frame_register_unwind_location (get_next_frame (this_frame
),
1939 gdbarch_pc_regnum (gdbarch
),
1940 &optimized
, &nlval
, &naddr
, &nrealnum
);
1942 if ((lval
== lval_memory
&& lval
== nlval
&& addr
== naddr
)
1943 || (lval
== lval_register
&& lval
== nlval
&& realnum
== nrealnum
))
1947 fprintf_unfiltered (gdb_stdlog
, "-> ");
1948 fprint_frame (gdb_stdlog
, NULL
);
1949 fprintf_unfiltered (gdb_stdlog
, " // no saved PC }\n");
1952 this_frame
->stop_reason
= UNWIND_NO_SAVED_PC
;
1953 this_frame
->prev
= NULL
;
1958 return get_prev_frame_if_no_cycle (this_frame
);
1961 /* Return a "struct frame_info" corresponding to the frame that called
1962 THIS_FRAME. Returns NULL if there is no such frame.
1964 Unlike get_prev_frame, this function always tries to unwind the
1968 get_prev_frame_always (struct frame_info
*this_frame
)
1970 struct frame_info
*prev_frame
= NULL
;
1974 prev_frame
= get_prev_frame_always_1 (this_frame
);
1976 CATCH (ex
, RETURN_MASK_ERROR
)
1978 if (ex
.error
== MEMORY_ERROR
)
1980 this_frame
->stop_reason
= UNWIND_MEMORY_ERROR
;
1981 if (ex
.message
!= NULL
)
1986 /* The error needs to live as long as the frame does.
1987 Allocate using stack local STOP_STRING then assign the
1988 pointer to the frame, this allows the STOP_STRING on the
1989 frame to be of type 'const char *'. */
1990 size
= strlen (ex
.message
) + 1;
1991 stop_string
= (char *) frame_obstack_zalloc (size
);
1992 memcpy (stop_string
, ex
.message
, size
);
1993 this_frame
->stop_string
= stop_string
;
1998 throw_exception (ex
);
2005 /* Construct a new "struct frame_info" and link it previous to
2008 static struct frame_info
*
2009 get_prev_frame_raw (struct frame_info
*this_frame
)
2011 struct frame_info
*prev_frame
;
2013 /* Allocate the new frame but do not wire it in to the frame chain.
2014 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
2015 frame->next to pull some fancy tricks (of course such code is, by
2016 definition, recursive). Try to prevent it.
2018 There is no reason to worry about memory leaks, should the
2019 remainder of the function fail. The allocated memory will be
2020 quickly reclaimed when the frame cache is flushed, and the `we've
2021 been here before' check above will stop repeated memory
2022 allocation calls. */
2023 prev_frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
2024 prev_frame
->level
= this_frame
->level
+ 1;
2026 /* For now, assume we don't have frame chains crossing address
2028 prev_frame
->pspace
= this_frame
->pspace
;
2029 prev_frame
->aspace
= this_frame
->aspace
;
2031 /* Don't yet compute ->unwind (and hence ->type). It is computed
2032 on-demand in get_frame_type, frame_register_unwind, and
2035 /* Don't yet compute the frame's ID. It is computed on-demand by
2038 /* The unwound frame ID is validate at the start of this function,
2039 as part of the logic to decide if that frame should be further
2040 unwound, and not here while the prev frame is being created.
2041 Doing this makes it possible for the user to examine a frame that
2042 has an invalid frame ID.
2044 Some very old VAX code noted: [...] For the sake of argument,
2045 suppose that the stack is somewhat trashed (which is one reason
2046 that "info frame" exists). So, return 0 (indicating we don't
2047 know the address of the arglist) if we don't know what frame this
2051 this_frame
->prev
= prev_frame
;
2052 prev_frame
->next
= this_frame
;
2056 fprintf_unfiltered (gdb_stdlog
, "-> ");
2057 fprint_frame (gdb_stdlog
, prev_frame
);
2058 fprintf_unfiltered (gdb_stdlog
, " }\n");
2064 /* Debug routine to print a NULL frame being returned. */
2067 frame_debug_got_null_frame (struct frame_info
*this_frame
,
2072 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame (this_frame=");
2073 if (this_frame
!= NULL
)
2074 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
2076 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
2077 fprintf_unfiltered (gdb_stdlog
, ") -> // %s}\n", reason
);
2081 /* Is this (non-sentinel) frame in the "main"() function? */
2084 inside_main_func (struct frame_info
*this_frame
)
2086 struct bound_minimal_symbol msymbol
;
2089 if (symfile_objfile
== 0)
2091 msymbol
= lookup_minimal_symbol (main_name (), NULL
, symfile_objfile
);
2092 if (msymbol
.minsym
== NULL
)
2094 /* Make certain that the code, and not descriptor, address is
2096 maddr
= gdbarch_convert_from_func_ptr_addr (get_frame_arch (this_frame
),
2097 BMSYMBOL_VALUE_ADDRESS (msymbol
),
2099 return maddr
== get_frame_func (this_frame
);
2102 /* Test whether THIS_FRAME is inside the process entry point function. */
2105 inside_entry_func (struct frame_info
*this_frame
)
2107 CORE_ADDR entry_point
;
2109 if (!entry_point_address_query (&entry_point
))
2112 return get_frame_func (this_frame
) == entry_point
;
2115 /* Return a structure containing various interesting information about
2116 the frame that called THIS_FRAME. Returns NULL if there is entier
2117 no such frame or the frame fails any of a set of target-independent
2118 condition that should terminate the frame chain (e.g., as unwinding
2121 This function should not contain target-dependent tests, such as
2122 checking whether the program-counter is zero. */
2125 get_prev_frame (struct frame_info
*this_frame
)
2130 /* There is always a frame. If this assertion fails, suspect that
2131 something should be calling get_selected_frame() or
2132 get_current_frame(). */
2133 gdb_assert (this_frame
!= NULL
);
2134 frame_pc_p
= get_frame_pc_if_available (this_frame
, &frame_pc
);
2136 /* tausq/2004-12-07: Dummy frames are skipped because it doesn't make much
2137 sense to stop unwinding at a dummy frame. One place where a dummy
2138 frame may have an address "inside_main_func" is on HPUX. On HPUX, the
2139 pcsqh register (space register for the instruction at the head of the
2140 instruction queue) cannot be written directly; the only way to set it
2141 is to branch to code that is in the target space. In order to implement
2142 frame dummies on HPUX, the called function is made to jump back to where
2143 the inferior was when the user function was called. If gdb was inside
2144 the main function when we created the dummy frame, the dummy frame will
2145 point inside the main function. */
2146 if (this_frame
->level
>= 0
2147 && get_frame_type (this_frame
) == NORMAL_FRAME
2148 && !backtrace_past_main
2150 && inside_main_func (this_frame
))
2151 /* Don't unwind past main(). Note, this is done _before_ the
2152 frame has been marked as previously unwound. That way if the
2153 user later decides to enable unwinds past main(), that will
2154 automatically happen. */
2156 frame_debug_got_null_frame (this_frame
, "inside main func");
2160 /* If the user's backtrace limit has been exceeded, stop. We must
2161 add two to the current level; one of those accounts for backtrace_limit
2162 being 1-based and the level being 0-based, and the other accounts for
2163 the level of the new frame instead of the level of the current
2165 if (this_frame
->level
+ 2 > backtrace_limit
)
2167 frame_debug_got_null_frame (this_frame
, "backtrace limit exceeded");
2171 /* If we're already inside the entry function for the main objfile,
2172 then it isn't valid. Don't apply this test to a dummy frame -
2173 dummy frame PCs typically land in the entry func. Don't apply
2174 this test to the sentinel frame. Sentinel frames should always
2175 be allowed to unwind. */
2176 /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() -
2177 wasn't checking for "main" in the minimal symbols. With that
2178 fixed asm-source tests now stop in "main" instead of halting the
2179 backtrace in weird and wonderful ways somewhere inside the entry
2180 file. Suspect that tests for inside the entry file/func were
2181 added to work around that (now fixed) case. */
2182 /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
2183 suggested having the inside_entry_func test use the
2184 inside_main_func() msymbol trick (along with entry_point_address()
2185 I guess) to determine the address range of the start function.
2186 That should provide a far better stopper than the current
2188 /* NOTE: tausq/2004-10-09: this is needed if, for example, the compiler
2189 applied tail-call optimizations to main so that a function called
2190 from main returns directly to the caller of main. Since we don't
2191 stop at main, we should at least stop at the entry point of the
2193 if (this_frame
->level
>= 0
2194 && get_frame_type (this_frame
) == NORMAL_FRAME
2195 && !backtrace_past_entry
2197 && inside_entry_func (this_frame
))
2199 frame_debug_got_null_frame (this_frame
, "inside entry func");
2203 /* Assume that the only way to get a zero PC is through something
2204 like a SIGSEGV or a dummy frame, and hence that NORMAL frames
2205 will never unwind a zero PC. */
2206 if (this_frame
->level
> 0
2207 && (get_frame_type (this_frame
) == NORMAL_FRAME
2208 || get_frame_type (this_frame
) == INLINE_FRAME
)
2209 && get_frame_type (get_next_frame (this_frame
)) == NORMAL_FRAME
2210 && frame_pc_p
&& frame_pc
== 0)
2212 frame_debug_got_null_frame (this_frame
, "zero PC");
2216 return get_prev_frame_always (this_frame
);
2220 get_frame_pc (struct frame_info
*frame
)
2222 gdb_assert (frame
->next
!= NULL
);
2223 return frame_unwind_pc (frame
->next
);
2227 get_frame_pc_if_available (struct frame_info
*frame
, CORE_ADDR
*pc
)
2230 gdb_assert (frame
->next
!= NULL
);
2234 *pc
= frame_unwind_pc (frame
->next
);
2236 CATCH (ex
, RETURN_MASK_ERROR
)
2238 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2241 throw_exception (ex
);
2248 /* Return an address that falls within THIS_FRAME's code block. */
2251 get_frame_address_in_block (struct frame_info
*this_frame
)
2253 /* A draft address. */
2254 CORE_ADDR pc
= get_frame_pc (this_frame
);
2256 struct frame_info
*next_frame
= this_frame
->next
;
2258 /* Calling get_frame_pc returns the resume address for THIS_FRAME.
2259 Normally the resume address is inside the body of the function
2260 associated with THIS_FRAME, but there is a special case: when
2261 calling a function which the compiler knows will never return
2262 (for instance abort), the call may be the very last instruction
2263 in the calling function. The resume address will point after the
2264 call and may be at the beginning of a different function
2267 If THIS_FRAME is a signal frame or dummy frame, then we should
2268 not adjust the unwound PC. For a dummy frame, GDB pushed the
2269 resume address manually onto the stack. For a signal frame, the
2270 OS may have pushed the resume address manually and invoked the
2271 handler (e.g. GNU/Linux), or invoked the trampoline which called
2272 the signal handler - but in either case the signal handler is
2273 expected to return to the trampoline. So in both of these
2274 cases we know that the resume address is executable and
2275 related. So we only need to adjust the PC if THIS_FRAME
2276 is a normal function.
2278 If the program has been interrupted while THIS_FRAME is current,
2279 then clearly the resume address is inside the associated
2280 function. There are three kinds of interruption: debugger stop
2281 (next frame will be SENTINEL_FRAME), operating system
2282 signal or exception (next frame will be SIGTRAMP_FRAME),
2283 or debugger-induced function call (next frame will be
2284 DUMMY_FRAME). So we only need to adjust the PC if
2285 NEXT_FRAME is a normal function.
2287 We check the type of NEXT_FRAME first, since it is already
2288 known; frame type is determined by the unwinder, and since
2289 we have THIS_FRAME we've already selected an unwinder for
2292 If the next frame is inlined, we need to keep going until we find
2293 the real function - for instance, if a signal handler is invoked
2294 while in an inlined function, then the code address of the
2295 "calling" normal function should not be adjusted either. */
2297 while (get_frame_type (next_frame
) == INLINE_FRAME
)
2298 next_frame
= next_frame
->next
;
2300 if ((get_frame_type (next_frame
) == NORMAL_FRAME
2301 || get_frame_type (next_frame
) == TAILCALL_FRAME
)
2302 && (get_frame_type (this_frame
) == NORMAL_FRAME
2303 || get_frame_type (this_frame
) == TAILCALL_FRAME
2304 || get_frame_type (this_frame
) == INLINE_FRAME
))
2311 get_frame_address_in_block_if_available (struct frame_info
*this_frame
,
2317 *pc
= get_frame_address_in_block (this_frame
);
2319 CATCH (ex
, RETURN_MASK_ERROR
)
2321 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2323 throw_exception (ex
);
2331 find_frame_sal (struct frame_info
*frame
, struct symtab_and_line
*sal
)
2333 struct frame_info
*next_frame
;
2337 /* If the next frame represents an inlined function call, this frame's
2338 sal is the "call site" of that inlined function, which can not
2339 be inferred from get_frame_pc. */
2340 next_frame
= get_next_frame (frame
);
2341 if (frame_inlined_callees (frame
) > 0)
2346 sym
= get_frame_function (next_frame
);
2348 sym
= inline_skipped_symbol (inferior_ptid
);
2350 /* If frame is inline, it certainly has symbols. */
2353 if (SYMBOL_LINE (sym
) != 0)
2355 sal
->symtab
= symbol_symtab (sym
);
2356 sal
->line
= SYMBOL_LINE (sym
);
2359 /* If the symbol does not have a location, we don't know where
2360 the call site is. Do not pretend to. This is jarring, but
2361 we can't do much better. */
2362 sal
->pc
= get_frame_pc (frame
);
2364 sal
->pspace
= get_frame_program_space (frame
);
2369 /* If FRAME is not the innermost frame, that normally means that
2370 FRAME->pc points at the return instruction (which is *after* the
2371 call instruction), and we want to get the line containing the
2372 call (because the call is where the user thinks the program is).
2373 However, if the next frame is either a SIGTRAMP_FRAME or a
2374 DUMMY_FRAME, then the next frame will contain a saved interrupt
2375 PC and such a PC indicates the current (rather than next)
2376 instruction/line, consequently, for such cases, want to get the
2377 line containing fi->pc. */
2378 if (!get_frame_pc_if_available (frame
, &pc
))
2384 notcurrent
= (pc
!= get_frame_address_in_block (frame
));
2385 (*sal
) = find_pc_line (pc
, notcurrent
);
2388 /* Per "frame.h", return the ``address'' of the frame. Code should
2389 really be using get_frame_id(). */
2391 get_frame_base (struct frame_info
*fi
)
2393 return get_frame_id (fi
).stack_addr
;
2396 /* High-level offsets into the frame. Used by the debug info. */
2399 get_frame_base_address (struct frame_info
*fi
)
2401 if (get_frame_type (fi
) != NORMAL_FRAME
)
2403 if (fi
->base
== NULL
)
2404 fi
->base
= frame_base_find_by_frame (fi
);
2405 /* Sneaky: If the low-level unwind and high-level base code share a
2406 common unwinder, let them share the prologue cache. */
2407 if (fi
->base
->unwind
== fi
->unwind
)
2408 return fi
->base
->this_base (fi
, &fi
->prologue_cache
);
2409 return fi
->base
->this_base (fi
, &fi
->base_cache
);
2413 get_frame_locals_address (struct frame_info
*fi
)
2415 if (get_frame_type (fi
) != NORMAL_FRAME
)
2417 /* If there isn't a frame address method, find it. */
2418 if (fi
->base
== NULL
)
2419 fi
->base
= frame_base_find_by_frame (fi
);
2420 /* Sneaky: If the low-level unwind and high-level base code share a
2421 common unwinder, let them share the prologue cache. */
2422 if (fi
->base
->unwind
== fi
->unwind
)
2423 return fi
->base
->this_locals (fi
, &fi
->prologue_cache
);
2424 return fi
->base
->this_locals (fi
, &fi
->base_cache
);
2428 get_frame_args_address (struct frame_info
*fi
)
2430 if (get_frame_type (fi
) != NORMAL_FRAME
)
2432 /* If there isn't a frame address method, find it. */
2433 if (fi
->base
== NULL
)
2434 fi
->base
= frame_base_find_by_frame (fi
);
2435 /* Sneaky: If the low-level unwind and high-level base code share a
2436 common unwinder, let them share the prologue cache. */
2437 if (fi
->base
->unwind
== fi
->unwind
)
2438 return fi
->base
->this_args (fi
, &fi
->prologue_cache
);
2439 return fi
->base
->this_args (fi
, &fi
->base_cache
);
2442 /* Return true if the frame unwinder for frame FI is UNWINDER; false
2446 frame_unwinder_is (struct frame_info
*fi
, const struct frame_unwind
*unwinder
)
2448 if (fi
->unwind
== NULL
)
2449 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
2450 return fi
->unwind
== unwinder
;
2453 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
2454 or -1 for a NULL frame. */
2457 frame_relative_level (struct frame_info
*fi
)
2466 get_frame_type (struct frame_info
*frame
)
2468 if (frame
->unwind
== NULL
)
2469 /* Initialize the frame's unwinder because that's what
2470 provides the frame's type. */
2471 frame_unwind_find_by_frame (frame
, &frame
->prologue_cache
);
2472 return frame
->unwind
->type
;
2475 struct program_space
*
2476 get_frame_program_space (struct frame_info
*frame
)
2478 return frame
->pspace
;
2481 struct program_space
*
2482 frame_unwind_program_space (struct frame_info
*this_frame
)
2484 gdb_assert (this_frame
);
2486 /* This is really a placeholder to keep the API consistent --- we
2487 assume for now that we don't have frame chains crossing
2489 return this_frame
->pspace
;
2492 struct address_space
*
2493 get_frame_address_space (struct frame_info
*frame
)
2495 return frame
->aspace
;
2498 /* Memory access methods. */
2501 get_frame_memory (struct frame_info
*this_frame
, CORE_ADDR addr
,
2502 gdb_byte
*buf
, int len
)
2504 read_memory (addr
, buf
, len
);
2508 get_frame_memory_signed (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_integer (addr
, len
, byte_order
);
2518 get_frame_memory_unsigned (struct frame_info
*this_frame
, CORE_ADDR addr
,
2521 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2522 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2524 return read_memory_unsigned_integer (addr
, len
, byte_order
);
2528 safe_frame_unwind_memory (struct frame_info
*this_frame
,
2529 CORE_ADDR addr
, gdb_byte
*buf
, int len
)
2531 /* NOTE: target_read_memory returns zero on success! */
2532 return !target_read_memory (addr
, buf
, len
);
2535 /* Architecture methods. */
2538 get_frame_arch (struct frame_info
*this_frame
)
2540 return frame_unwind_arch (this_frame
->next
);
2544 frame_unwind_arch (struct frame_info
*next_frame
)
2546 if (!next_frame
->prev_arch
.p
)
2548 struct gdbarch
*arch
;
2550 if (next_frame
->unwind
== NULL
)
2551 frame_unwind_find_by_frame (next_frame
, &next_frame
->prologue_cache
);
2553 if (next_frame
->unwind
->prev_arch
!= NULL
)
2554 arch
= next_frame
->unwind
->prev_arch (next_frame
,
2555 &next_frame
->prologue_cache
);
2557 arch
= get_frame_arch (next_frame
);
2559 next_frame
->prev_arch
.arch
= arch
;
2560 next_frame
->prev_arch
.p
= 1;
2562 fprintf_unfiltered (gdb_stdlog
,
2563 "{ frame_unwind_arch (next_frame=%d) -> %s }\n",
2565 gdbarch_bfd_arch_info (arch
)->printable_name
);
2568 return next_frame
->prev_arch
.arch
;
2572 frame_unwind_caller_arch (struct frame_info
*next_frame
)
2574 return frame_unwind_arch (skip_artificial_frames (next_frame
));
2577 /* Gets the language of FRAME. */
2580 get_frame_language (struct frame_info
*frame
)
2585 gdb_assert (frame
!= NULL
);
2587 /* We determine the current frame language by looking up its
2588 associated symtab. To retrieve this symtab, we use the frame
2589 PC. However we cannot use the frame PC as is, because it
2590 usually points to the instruction following the "call", which
2591 is sometimes the first instruction of another function. So
2592 we rely on get_frame_address_in_block(), it provides us with
2593 a PC that is guaranteed to be inside the frame's code
2598 pc
= get_frame_address_in_block (frame
);
2601 CATCH (ex
, RETURN_MASK_ERROR
)
2603 if (ex
.error
!= NOT_AVAILABLE_ERROR
)
2604 throw_exception (ex
);
2610 struct compunit_symtab
*cust
= find_pc_compunit_symtab (pc
);
2613 return compunit_language (cust
);
2616 return language_unknown
;
2619 /* Stack pointer methods. */
2622 get_frame_sp (struct frame_info
*this_frame
)
2624 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2626 /* Normality - an architecture that provides a way of obtaining any
2627 frame inner-most address. */
2628 if (gdbarch_unwind_sp_p (gdbarch
))
2629 /* NOTE drow/2008-06-28: gdbarch_unwind_sp could be converted to
2630 operate on THIS_FRAME now. */
2631 return gdbarch_unwind_sp (gdbarch
, this_frame
->next
);
2632 /* Now things are really are grim. Hope that the value returned by
2633 the gdbarch_sp_regnum register is meaningful. */
2634 if (gdbarch_sp_regnum (gdbarch
) >= 0)
2635 return get_frame_register_unsigned (this_frame
,
2636 gdbarch_sp_regnum (gdbarch
));
2637 internal_error (__FILE__
, __LINE__
, _("Missing unwind SP method"));
2640 /* Return the reason why we can't unwind past FRAME. */
2642 enum unwind_stop_reason
2643 get_frame_unwind_stop_reason (struct frame_info
*frame
)
2645 /* Fill-in STOP_REASON. */
2646 get_prev_frame_always (frame
);
2647 gdb_assert (frame
->prev_p
);
2649 return frame
->stop_reason
;
2652 /* Return a string explaining REASON. */
2655 unwind_stop_reason_to_string (enum unwind_stop_reason reason
)
2659 #define SET(name, description) \
2660 case name: return _(description);
2661 #include "unwind_stop_reasons.def"
2665 internal_error (__FILE__
, __LINE__
,
2666 "Invalid frame stop reason");
2671 frame_stop_reason_string (struct frame_info
*fi
)
2673 gdb_assert (fi
->prev_p
);
2674 gdb_assert (fi
->prev
== NULL
);
2676 /* Return the specific string if we have one. */
2677 if (fi
->stop_string
!= NULL
)
2678 return fi
->stop_string
;
2680 /* Return the generic string if we have nothing better. */
2681 return unwind_stop_reason_to_string (fi
->stop_reason
);
2684 /* Return the enum symbol name of REASON as a string, to use in debug
2688 frame_stop_reason_symbol_string (enum unwind_stop_reason reason
)
2692 #define SET(name, description) \
2693 case name: return #name;
2694 #include "unwind_stop_reasons.def"
2698 internal_error (__FILE__
, __LINE__
,
2699 "Invalid frame stop reason");
2703 /* Clean up after a failed (wrong unwinder) attempt to unwind past
2707 frame_cleanup_after_sniffer (void *arg
)
2709 struct frame_info
*frame
= (struct frame_info
*) arg
;
2711 /* The sniffer should not allocate a prologue cache if it did not
2712 match this frame. */
2713 gdb_assert (frame
->prologue_cache
== NULL
);
2715 /* No sniffer should extend the frame chain; sniff based on what is
2717 gdb_assert (!frame
->prev_p
);
2719 /* The sniffer should not check the frame's ID; that's circular. */
2720 gdb_assert (!frame
->this_id
.p
);
2722 /* Clear cached fields dependent on the unwinder.
2724 The previous PC is independent of the unwinder, but the previous
2725 function is not (see get_frame_address_in_block). */
2726 frame
->prev_func
.p
= 0;
2727 frame
->prev_func
.addr
= 0;
2729 /* Discard the unwinder last, so that we can easily find it if an assertion
2730 in this function triggers. */
2731 frame
->unwind
= NULL
;
2734 /* Set FRAME's unwinder temporarily, so that we can call a sniffer.
2735 Return a cleanup which should be called if unwinding fails, and
2736 discarded if it succeeds. */
2739 frame_prepare_for_sniffer (struct frame_info
*frame
,
2740 const struct frame_unwind
*unwind
)
2742 gdb_assert (frame
->unwind
== NULL
);
2743 frame
->unwind
= unwind
;
2744 return make_cleanup (frame_cleanup_after_sniffer
, frame
);
2747 extern initialize_file_ftype _initialize_frame
; /* -Wmissing-prototypes */
2749 static struct cmd_list_element
*set_backtrace_cmdlist
;
2750 static struct cmd_list_element
*show_backtrace_cmdlist
;
2753 set_backtrace_cmd (char *args
, int from_tty
)
2755 help_list (set_backtrace_cmdlist
, "set backtrace ", all_commands
,
2760 show_backtrace_cmd (char *args
, int from_tty
)
2762 cmd_show_list (show_backtrace_cmdlist
, from_tty
, "");
2766 _initialize_frame (void)
2768 obstack_init (&frame_cache_obstack
);
2770 frame_stash_create ();
2772 observer_attach_target_changed (frame_observer_target_changed
);
2774 add_prefix_cmd ("backtrace", class_maintenance
, set_backtrace_cmd
, _("\
2775 Set backtrace specific variables.\n\
2776 Configure backtrace variables such as the backtrace limit"),
2777 &set_backtrace_cmdlist
, "set backtrace ",
2778 0/*allow-unknown*/, &setlist
);
2779 add_prefix_cmd ("backtrace", class_maintenance
, show_backtrace_cmd
, _("\
2780 Show backtrace specific variables\n\
2781 Show backtrace variables such as the backtrace limit"),
2782 &show_backtrace_cmdlist
, "show backtrace ",
2783 0/*allow-unknown*/, &showlist
);
2785 add_setshow_boolean_cmd ("past-main", class_obscure
,
2786 &backtrace_past_main
, _("\
2787 Set whether backtraces should continue past \"main\"."), _("\
2788 Show whether backtraces should continue past \"main\"."), _("\
2789 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
2790 the backtrace at \"main\". Set this variable if you need to see the rest\n\
2791 of the stack trace."),
2793 show_backtrace_past_main
,
2794 &set_backtrace_cmdlist
,
2795 &show_backtrace_cmdlist
);
2797 add_setshow_boolean_cmd ("past-entry", class_obscure
,
2798 &backtrace_past_entry
, _("\
2799 Set whether backtraces should continue past the entry point of a program."),
2801 Show whether backtraces should continue past the entry point of a program."),
2803 Normally there are no callers beyond the entry point of a program, so GDB\n\
2804 will terminate the backtrace there. Set this variable if you need to see\n\
2805 the rest of the stack trace."),
2807 show_backtrace_past_entry
,
2808 &set_backtrace_cmdlist
,
2809 &show_backtrace_cmdlist
);
2811 add_setshow_uinteger_cmd ("limit", class_obscure
,
2812 &backtrace_limit
, _("\
2813 Set an upper bound on the number of backtrace levels."), _("\
2814 Show the upper bound on the number of backtrace levels."), _("\
2815 No more than the specified number of frames can be displayed or examined.\n\
2816 Literal \"unlimited\" or zero means no limit."),
2818 show_backtrace_limit
,
2819 &set_backtrace_cmdlist
,
2820 &show_backtrace_cmdlist
);
2822 /* Debug this files internals. */
2823 add_setshow_zuinteger_cmd ("frame", class_maintenance
, &frame_debug
, _("\
2824 Set frame debugging."), _("\
2825 Show frame debugging."), _("\
2826 When non-zero, frame specific internal debugging is enabled."),
2829 &setdebuglist
, &showdebuglist
);