1 /* Cache and manage frames for GDB, the GNU debugger.
3 Copyright (C) 1986-2014 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 "gdb_assert.h"
28 #include "user-regs.h"
29 #include "gdb_obstack.h"
30 #include "dummy-frame.h"
31 #include "sentinel-frame.h"
35 #include "frame-unwind.h"
36 #include "frame-base.h"
41 #include "exceptions.h"
42 #include "gdbthread.h"
44 #include "inline-frame.h"
45 #include "tracepoint.h"
49 static struct frame_info
*get_prev_frame_1 (struct frame_info
*this_frame
);
50 static struct frame_info
*get_prev_frame_raw (struct frame_info
*this_frame
);
51 static const char *frame_stop_reason_symbol_string (enum unwind_stop_reason reason
);
53 /* Status of some values cached in the frame_info object. */
55 enum cached_copy_status
57 /* Value is unknown. */
60 /* We have a value. */
63 /* Value was not saved. */
66 /* Value is unavailable. */
70 /* We keep a cache of stack frames, each of which is a "struct
71 frame_info". The innermost one gets allocated (in
72 wait_for_inferior) each time the inferior stops; current_frame
73 points to it. Additional frames get allocated (in get_prev_frame)
74 as needed, and are chained through the next and prev fields. Any
75 time that the frame cache becomes invalid (most notably when we
76 execute something, but also if we change how we interpret the
77 frames (e.g. "set heuristic-fence-post" in mips-tdep.c, or anything
78 which reads new symbols)), we should call reinit_frame_cache. */
82 /* Level of this frame. The inner-most (youngest) frame is at level
83 0. As you move towards the outer-most (oldest) frame, the level
84 increases. This is a cached value. It could just as easily be
85 computed by counting back from the selected frame to the inner
87 /* NOTE: cagney/2002-04-05: Perhaps a level of ``-1'' should be
88 reserved to indicate a bogus frame - one that has been created
89 just to keep GDB happy (GDB always needs a frame). For the
90 moment leave this as speculation. */
93 /* The frame's program space. */
94 struct program_space
*pspace
;
96 /* The frame's address space. */
97 struct address_space
*aspace
;
99 /* The frame's low-level unwinder and corresponding cache. The
100 low-level unwinder is responsible for unwinding register values
101 for the previous frame. The low-level unwind methods are
102 selected based on the presence, or otherwise, of register unwind
103 information such as CFI. */
104 void *prologue_cache
;
105 const struct frame_unwind
*unwind
;
107 /* Cached copy of the previous frame's architecture. */
111 struct gdbarch
*arch
;
114 /* Cached copy of the previous frame's resume address. */
116 enum cached_copy_status status
;
120 /* Cached copy of the previous frame's function address. */
127 /* This frame's ID. */
131 struct frame_id value
;
134 /* The frame's high-level base methods, and corresponding cache.
135 The high level base methods are selected based on the frame's
137 const struct frame_base
*base
;
140 /* Pointers to the next (down, inner, younger) and previous (up,
141 outer, older) frame_info's in the frame cache. */
142 struct frame_info
*next
; /* down, inner, younger */
144 struct frame_info
*prev
; /* up, outer, older */
146 /* The reason why we could not set PREV, or UNWIND_NO_REASON if we
147 could. Only valid when PREV_P is set. */
148 enum unwind_stop_reason stop_reason
;
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
= 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
= a
;
193 const struct frame_info
*f_element
= 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
= 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 while (get_frame_type (frame
) == INLINE_FRAME
429 || get_frame_type (frame
) == TAILCALL_FRAME
)
430 frame
= get_prev_frame (frame
);
435 /* Compute the frame's uniq ID that can be used to, later, re-find the
439 compute_frame_id (struct frame_info
*fi
)
441 gdb_assert (!fi
->this_id
.p
);
444 fprintf_unfiltered (gdb_stdlog
, "{ compute_frame_id (fi=%d) ",
446 /* Find the unwinder. */
447 if (fi
->unwind
== NULL
)
448 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
449 /* Find THIS frame's ID. */
450 /* Default to outermost if no ID is found. */
451 fi
->this_id
.value
= outer_frame_id
;
452 fi
->unwind
->this_id (fi
, &fi
->prologue_cache
, &fi
->this_id
.value
);
453 gdb_assert (frame_id_p (fi
->this_id
.value
));
457 fprintf_unfiltered (gdb_stdlog
, "-> ");
458 fprint_frame_id (gdb_stdlog
, fi
->this_id
.value
);
459 fprintf_unfiltered (gdb_stdlog
, " }\n");
463 /* Return a frame uniq ID that can be used to, later, re-find the
467 get_frame_id (struct frame_info
*fi
)
470 return null_frame_id
;
472 gdb_assert (fi
->this_id
.p
);
473 return fi
->this_id
.value
;
477 get_stack_frame_id (struct frame_info
*next_frame
)
479 return get_frame_id (skip_artificial_frames (next_frame
));
483 frame_unwind_caller_id (struct frame_info
*next_frame
)
485 struct frame_info
*this_frame
;
487 /* Use get_prev_frame_1, and not get_prev_frame. The latter will truncate
488 the frame chain, leading to this function unintentionally
489 returning a null_frame_id (e.g., when a caller requests the frame
490 ID of "main()"s caller. */
492 next_frame
= skip_artificial_frames (next_frame
);
493 this_frame
= get_prev_frame_1 (next_frame
);
495 return get_frame_id (skip_artificial_frames (this_frame
));
497 return null_frame_id
;
500 const struct frame_id null_frame_id
; /* All zeros. */
501 const struct frame_id outer_frame_id
= { 0, 0, 0, FID_STACK_INVALID
, 0, 1, 0 };
504 frame_id_build_special (CORE_ADDR stack_addr
, CORE_ADDR code_addr
,
505 CORE_ADDR special_addr
)
507 struct frame_id id
= null_frame_id
;
509 id
.stack_addr
= stack_addr
;
510 id
.stack_status
= FID_STACK_VALID
;
511 id
.code_addr
= code_addr
;
513 id
.special_addr
= special_addr
;
514 id
.special_addr_p
= 1;
521 frame_id_build_unavailable_stack (CORE_ADDR code_addr
)
523 struct frame_id id
= null_frame_id
;
525 id
.stack_status
= FID_STACK_UNAVAILABLE
;
526 id
.code_addr
= code_addr
;
534 frame_id_build_unavailable_stack_special (CORE_ADDR code_addr
,
535 CORE_ADDR special_addr
)
537 struct frame_id id
= null_frame_id
;
539 id
.stack_status
= FID_STACK_UNAVAILABLE
;
540 id
.code_addr
= code_addr
;
542 id
.special_addr
= special_addr
;
543 id
.special_addr_p
= 1;
548 frame_id_build (CORE_ADDR stack_addr
, CORE_ADDR code_addr
)
550 struct frame_id id
= null_frame_id
;
552 id
.stack_addr
= stack_addr
;
553 id
.stack_status
= FID_STACK_VALID
;
554 id
.code_addr
= code_addr
;
560 frame_id_build_wild (CORE_ADDR stack_addr
)
562 struct frame_id id
= null_frame_id
;
564 id
.stack_addr
= stack_addr
;
565 id
.stack_status
= FID_STACK_VALID
;
570 frame_id_p (struct frame_id l
)
574 /* The frame is valid iff it has a valid stack address. */
575 p
= l
.stack_status
!= FID_STACK_INVALID
;
576 /* outer_frame_id is also valid. */
577 if (!p
&& memcmp (&l
, &outer_frame_id
, sizeof (l
)) == 0)
581 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_p (l=");
582 fprint_frame_id (gdb_stdlog
, l
);
583 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", p
);
589 frame_id_artificial_p (struct frame_id l
)
594 return (l
.artificial_depth
!= 0);
598 frame_id_eq (struct frame_id l
, struct frame_id r
)
602 if (l
.stack_status
== FID_STACK_INVALID
&& l
.special_addr_p
603 && r
.stack_status
== FID_STACK_INVALID
&& r
.special_addr_p
)
604 /* The outermost frame marker is equal to itself. This is the
605 dodgy thing about outer_frame_id, since between execution steps
606 we might step into another function - from which we can't
607 unwind either. More thought required to get rid of
610 else if (l
.stack_status
== FID_STACK_INVALID
611 || l
.stack_status
== FID_STACK_INVALID
)
612 /* Like a NaN, if either ID is invalid, the result is false.
613 Note that a frame ID is invalid iff it is the null frame ID. */
615 else if (l
.stack_status
!= r
.stack_status
|| l
.stack_addr
!= r
.stack_addr
)
616 /* If .stack addresses are different, the frames are different. */
618 else if (l
.code_addr_p
&& r
.code_addr_p
&& l
.code_addr
!= r
.code_addr
)
619 /* An invalid code addr is a wild card. If .code addresses are
620 different, the frames are different. */
622 else if (l
.special_addr_p
&& r
.special_addr_p
623 && l
.special_addr
!= r
.special_addr
)
624 /* An invalid special addr is a wild card (or unused). Otherwise
625 if special addresses are different, the frames are different. */
627 else if (l
.artificial_depth
!= r
.artificial_depth
)
628 /* If artifical depths are different, the frames must be different. */
631 /* Frames are equal. */
636 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_eq (l=");
637 fprint_frame_id (gdb_stdlog
, l
);
638 fprintf_unfiltered (gdb_stdlog
, ",r=");
639 fprint_frame_id (gdb_stdlog
, r
);
640 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", eq
);
645 /* Safety net to check whether frame ID L should be inner to
646 frame ID R, according to their stack addresses.
648 This method cannot be used to compare arbitrary frames, as the
649 ranges of valid stack addresses may be discontiguous (e.g. due
652 However, it can be used as safety net to discover invalid frame
653 IDs in certain circumstances. Assuming that NEXT is the immediate
654 inner frame to THIS and that NEXT and THIS are both NORMAL frames:
656 * The stack address of NEXT must be inner-than-or-equal to the stack
659 Therefore, if frame_id_inner (THIS, NEXT) holds, some unwind
662 * If NEXT and THIS have different stack addresses, no other frame
663 in the frame chain may have a stack address in between.
665 Therefore, if frame_id_inner (TEST, THIS) holds, but
666 frame_id_inner (TEST, NEXT) does not hold, TEST cannot refer
667 to a valid frame in the frame chain.
669 The sanity checks above cannot be performed when a SIGTRAMP frame
670 is involved, because signal handlers might be executed on a different
671 stack than the stack used by the routine that caused the signal
672 to be raised. This can happen for instance when a thread exceeds
673 its maximum stack size. In this case, certain compilers implement
674 a stack overflow strategy that cause the handler to be run on a
678 frame_id_inner (struct gdbarch
*gdbarch
, struct frame_id l
, struct frame_id r
)
682 if (l
.stack_status
!= FID_STACK_VALID
|| r
.stack_status
!= FID_STACK_VALID
)
683 /* Like NaN, any operation involving an invalid ID always fails.
684 Likewise if either ID has an unavailable stack address. */
686 else if (l
.artificial_depth
> r
.artificial_depth
687 && l
.stack_addr
== r
.stack_addr
688 && l
.code_addr_p
== r
.code_addr_p
689 && l
.special_addr_p
== r
.special_addr_p
690 && l
.special_addr
== r
.special_addr
)
692 /* Same function, different inlined functions. */
693 struct block
*lb
, *rb
;
695 gdb_assert (l
.code_addr_p
&& r
.code_addr_p
);
697 lb
= block_for_pc (l
.code_addr
);
698 rb
= block_for_pc (r
.code_addr
);
700 if (lb
== NULL
|| rb
== NULL
)
701 /* Something's gone wrong. */
704 /* This will return true if LB and RB are the same block, or
705 if the block with the smaller depth lexically encloses the
706 block with the greater depth. */
707 inner
= contained_in (lb
, rb
);
710 /* Only return non-zero when strictly inner than. Note that, per
711 comment in "frame.h", there is some fuzz here. Frameless
712 functions are not strictly inner than (same .stack but
713 different .code and/or .special address). */
714 inner
= gdbarch_inner_than (gdbarch
, l
.stack_addr
, r
.stack_addr
);
717 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_inner (l=");
718 fprint_frame_id (gdb_stdlog
, l
);
719 fprintf_unfiltered (gdb_stdlog
, ",r=");
720 fprint_frame_id (gdb_stdlog
, r
);
721 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", inner
);
727 frame_find_by_id (struct frame_id id
)
729 struct frame_info
*frame
, *prev_frame
;
731 /* ZERO denotes the null frame, let the caller decide what to do
732 about it. Should it instead return get_current_frame()? */
733 if (!frame_id_p (id
))
736 /* Try using the frame stash first. Finding it there removes the need
737 to perform the search by looping over all frames, which can be very
738 CPU-intensive if the number of frames is very high (the loop is O(n)
739 and get_prev_frame performs a series of checks that are relatively
740 expensive). This optimization is particularly useful when this function
741 is called from another function (such as value_fetch_lazy, case
742 VALUE_LVAL (val) == lval_register) which already loops over all frames,
743 making the overall behavior O(n^2). */
744 frame
= frame_stash_find (id
);
748 for (frame
= get_current_frame (); ; frame
= prev_frame
)
750 struct frame_id
this = get_frame_id (frame
);
752 if (frame_id_eq (id
, this))
753 /* An exact match. */
756 prev_frame
= get_prev_frame (frame
);
760 /* As a safety net to avoid unnecessary backtracing while trying
761 to find an invalid ID, we check for a common situation where
762 we can detect from comparing stack addresses that no other
763 frame in the current frame chain can have this ID. See the
764 comment at frame_id_inner for details. */
765 if (get_frame_type (frame
) == NORMAL_FRAME
766 && !frame_id_inner (get_frame_arch (frame
), id
, this)
767 && frame_id_inner (get_frame_arch (prev_frame
), id
,
768 get_frame_id (prev_frame
)))
775 frame_unwind_pc (struct frame_info
*this_frame
)
777 if (this_frame
->prev_pc
.status
== CC_UNKNOWN
)
779 if (gdbarch_unwind_pc_p (frame_unwind_arch (this_frame
)))
781 volatile struct gdb_exception ex
;
782 struct gdbarch
*prev_gdbarch
;
785 /* The right way. The `pure' way. The one true way. This
786 method depends solely on the register-unwind code to
787 determine the value of registers in THIS frame, and hence
788 the value of this frame's PC (resume address). A typical
789 implementation is no more than:
791 frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
792 return extract_unsigned_integer (buf, size of ISA_PC_REGNUM);
794 Note: this method is very heavily dependent on a correct
795 register-unwind implementation, it pays to fix that
796 method first; this method is frame type agnostic, since
797 it only deals with register values, it works with any
798 frame. This is all in stark contrast to the old
799 FRAME_SAVED_PC which would try to directly handle all the
800 different ways that a PC could be unwound. */
801 prev_gdbarch
= frame_unwind_arch (this_frame
);
803 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
805 pc
= gdbarch_unwind_pc (prev_gdbarch
, this_frame
);
809 if (ex
.error
== NOT_AVAILABLE_ERROR
)
811 this_frame
->prev_pc
.status
= CC_UNAVAILABLE
;
814 fprintf_unfiltered (gdb_stdlog
,
815 "{ frame_unwind_pc (this_frame=%d)"
816 " -> <unavailable> }\n",
819 else if (ex
.error
== OPTIMIZED_OUT_ERROR
)
821 this_frame
->prev_pc
.status
= CC_NOT_SAVED
;
824 fprintf_unfiltered (gdb_stdlog
,
825 "{ frame_unwind_pc (this_frame=%d)"
826 " -> <not saved> }\n",
830 throw_exception (ex
);
834 this_frame
->prev_pc
.value
= pc
;
835 this_frame
->prev_pc
.status
= CC_VALUE
;
837 fprintf_unfiltered (gdb_stdlog
,
838 "{ frame_unwind_pc (this_frame=%d) "
841 hex_string (this_frame
->prev_pc
.value
));
845 internal_error (__FILE__
, __LINE__
, _("No unwind_pc method"));
848 if (this_frame
->prev_pc
.status
== CC_VALUE
)
849 return this_frame
->prev_pc
.value
;
850 else if (this_frame
->prev_pc
.status
== CC_UNAVAILABLE
)
851 throw_error (NOT_AVAILABLE_ERROR
, _("PC not available"));
852 else if (this_frame
->prev_pc
.status
== CC_NOT_SAVED
)
853 throw_error (OPTIMIZED_OUT_ERROR
, _("PC not saved"));
855 internal_error (__FILE__
, __LINE__
,
856 "unexpected prev_pc status: %d",
857 (int) this_frame
->prev_pc
.status
);
861 frame_unwind_caller_pc (struct frame_info
*this_frame
)
863 return frame_unwind_pc (skip_artificial_frames (this_frame
));
867 get_frame_func_if_available (struct frame_info
*this_frame
, CORE_ADDR
*pc
)
869 struct frame_info
*next_frame
= this_frame
->next
;
871 if (!next_frame
->prev_func
.p
)
873 CORE_ADDR addr_in_block
;
875 /* Make certain that this, and not the adjacent, function is
877 if (!get_frame_address_in_block_if_available (this_frame
, &addr_in_block
))
879 next_frame
->prev_func
.p
= -1;
881 fprintf_unfiltered (gdb_stdlog
,
882 "{ get_frame_func (this_frame=%d)"
883 " -> unavailable }\n",
888 next_frame
->prev_func
.p
= 1;
889 next_frame
->prev_func
.addr
= get_pc_function_start (addr_in_block
);
891 fprintf_unfiltered (gdb_stdlog
,
892 "{ get_frame_func (this_frame=%d) -> %s }\n",
894 hex_string (next_frame
->prev_func
.addr
));
898 if (next_frame
->prev_func
.p
< 0)
905 *pc
= next_frame
->prev_func
.addr
;
911 get_frame_func (struct frame_info
*this_frame
)
915 if (!get_frame_func_if_available (this_frame
, &pc
))
916 throw_error (NOT_AVAILABLE_ERROR
, _("PC not available"));
921 static enum register_status
922 do_frame_register_read (void *src
, int regnum
, gdb_byte
*buf
)
924 if (!deprecated_frame_register_read (src
, regnum
, buf
))
925 return REG_UNAVAILABLE
;
931 frame_save_as_regcache (struct frame_info
*this_frame
)
933 struct address_space
*aspace
= get_frame_address_space (this_frame
);
934 struct regcache
*regcache
= regcache_xmalloc (get_frame_arch (this_frame
),
936 struct cleanup
*cleanups
= make_cleanup_regcache_xfree (regcache
);
938 regcache_save (regcache
, do_frame_register_read
, this_frame
);
939 discard_cleanups (cleanups
);
944 frame_pop (struct frame_info
*this_frame
)
946 struct frame_info
*prev_frame
;
947 struct regcache
*scratch
;
948 struct cleanup
*cleanups
;
950 if (get_frame_type (this_frame
) == DUMMY_FRAME
)
952 /* Popping a dummy frame involves restoring more than just registers.
953 dummy_frame_pop does all the work. */
954 dummy_frame_pop (get_frame_id (this_frame
));
958 /* Ensure that we have a frame to pop to. */
959 prev_frame
= get_prev_frame_1 (this_frame
);
962 error (_("Cannot pop the initial frame."));
964 /* Ignore TAILCALL_FRAME type frames, they were executed already before
965 entering THISFRAME. */
966 while (get_frame_type (prev_frame
) == TAILCALL_FRAME
)
967 prev_frame
= get_prev_frame (prev_frame
);
969 /* Make a copy of all the register values unwound from this frame.
970 Save them in a scratch buffer so that there isn't a race between
971 trying to extract the old values from the current regcache while
972 at the same time writing new values into that same cache. */
973 scratch
= frame_save_as_regcache (prev_frame
);
974 cleanups
= make_cleanup_regcache_xfree (scratch
);
976 /* FIXME: cagney/2003-03-16: It should be possible to tell the
977 target's register cache that it is about to be hit with a burst
978 register transfer and that the sequence of register writes should
979 be batched. The pair target_prepare_to_store() and
980 target_store_registers() kind of suggest this functionality.
981 Unfortunately, they don't implement it. Their lack of a formal
982 definition can lead to targets writing back bogus values
983 (arguably a bug in the target code mind). */
984 /* Now copy those saved registers into the current regcache.
985 Here, regcache_cpy() calls regcache_restore(). */
986 regcache_cpy (get_current_regcache (), scratch
);
987 do_cleanups (cleanups
);
989 /* We've made right mess of GDB's local state, just discard
991 reinit_frame_cache ();
995 frame_register_unwind (struct frame_info
*frame
, int regnum
,
996 int *optimizedp
, int *unavailablep
,
997 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
998 int *realnump
, gdb_byte
*bufferp
)
1000 struct value
*value
;
1002 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
1003 that the value proper does not need to be fetched. */
1004 gdb_assert (optimizedp
!= NULL
);
1005 gdb_assert (lvalp
!= NULL
);
1006 gdb_assert (addrp
!= NULL
);
1007 gdb_assert (realnump
!= NULL
);
1008 /* gdb_assert (bufferp != NULL); */
1010 value
= frame_unwind_register_value (frame
, regnum
);
1012 gdb_assert (value
!= NULL
);
1014 *optimizedp
= value_optimized_out (value
);
1015 *unavailablep
= !value_entirely_available (value
);
1016 *lvalp
= VALUE_LVAL (value
);
1017 *addrp
= value_address (value
);
1018 *realnump
= VALUE_REGNUM (value
);
1022 if (!*optimizedp
&& !*unavailablep
)
1023 memcpy (bufferp
, value_contents_all (value
),
1024 TYPE_LENGTH (value_type (value
)));
1026 memset (bufferp
, 0, TYPE_LENGTH (value_type (value
)));
1029 /* Dispose of the new value. This prevents watchpoints from
1030 trying to watch the saved frame pointer. */
1031 release_value (value
);
1036 frame_register (struct frame_info
*frame
, int regnum
,
1037 int *optimizedp
, int *unavailablep
, enum lval_type
*lvalp
,
1038 CORE_ADDR
*addrp
, int *realnump
, gdb_byte
*bufferp
)
1040 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
1041 that the value proper does not need to be fetched. */
1042 gdb_assert (optimizedp
!= NULL
);
1043 gdb_assert (lvalp
!= NULL
);
1044 gdb_assert (addrp
!= NULL
);
1045 gdb_assert (realnump
!= NULL
);
1046 /* gdb_assert (bufferp != NULL); */
1048 /* Obtain the register value by unwinding the register from the next
1049 (more inner frame). */
1050 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
1051 frame_register_unwind (frame
->next
, regnum
, optimizedp
, unavailablep
,
1052 lvalp
, addrp
, realnump
, bufferp
);
1056 frame_unwind_register (struct frame_info
*frame
, int regnum
, gdb_byte
*buf
)
1062 enum lval_type lval
;
1064 frame_register_unwind (frame
, regnum
, &optimized
, &unavailable
,
1065 &lval
, &addr
, &realnum
, buf
);
1068 throw_error (OPTIMIZED_OUT_ERROR
,
1069 _("Register %d was not saved"), regnum
);
1071 throw_error (NOT_AVAILABLE_ERROR
,
1072 _("Register %d is not available"), regnum
);
1076 get_frame_register (struct frame_info
*frame
,
1077 int regnum
, gdb_byte
*buf
)
1079 frame_unwind_register (frame
->next
, regnum
, buf
);
1083 frame_unwind_register_value (struct frame_info
*frame
, int regnum
)
1085 struct gdbarch
*gdbarch
;
1086 struct value
*value
;
1088 gdb_assert (frame
!= NULL
);
1089 gdbarch
= frame_unwind_arch (frame
);
1093 fprintf_unfiltered (gdb_stdlog
,
1094 "{ frame_unwind_register_value "
1095 "(frame=%d,regnum=%d(%s),...) ",
1096 frame
->level
, regnum
,
1097 user_reg_map_regnum_to_name (gdbarch
, regnum
));
1100 /* Find the unwinder. */
1101 if (frame
->unwind
== NULL
)
1102 frame_unwind_find_by_frame (frame
, &frame
->prologue_cache
);
1104 /* Ask this frame to unwind its register. */
1105 value
= frame
->unwind
->prev_register (frame
, &frame
->prologue_cache
, regnum
);
1109 fprintf_unfiltered (gdb_stdlog
, "->");
1110 if (value_optimized_out (value
))
1112 fprintf_unfiltered (gdb_stdlog
, " ");
1113 val_print_optimized_out (value
, gdb_stdlog
);
1117 if (VALUE_LVAL (value
) == lval_register
)
1118 fprintf_unfiltered (gdb_stdlog
, " register=%d",
1119 VALUE_REGNUM (value
));
1120 else if (VALUE_LVAL (value
) == lval_memory
)
1121 fprintf_unfiltered (gdb_stdlog
, " address=%s",
1123 value_address (value
)));
1125 fprintf_unfiltered (gdb_stdlog
, " computed");
1127 if (value_lazy (value
))
1128 fprintf_unfiltered (gdb_stdlog
, " lazy");
1132 const gdb_byte
*buf
= value_contents (value
);
1134 fprintf_unfiltered (gdb_stdlog
, " bytes=");
1135 fprintf_unfiltered (gdb_stdlog
, "[");
1136 for (i
= 0; i
< register_size (gdbarch
, regnum
); i
++)
1137 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1138 fprintf_unfiltered (gdb_stdlog
, "]");
1142 fprintf_unfiltered (gdb_stdlog
, " }\n");
1149 get_frame_register_value (struct frame_info
*frame
, int regnum
)
1151 return frame_unwind_register_value (frame
->next
, regnum
);
1155 frame_unwind_register_signed (struct frame_info
*frame
, int regnum
)
1157 struct gdbarch
*gdbarch
= frame_unwind_arch (frame
);
1158 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1159 int size
= register_size (gdbarch
, regnum
);
1160 gdb_byte buf
[MAX_REGISTER_SIZE
];
1162 frame_unwind_register (frame
, regnum
, buf
);
1163 return extract_signed_integer (buf
, size
, byte_order
);
1167 get_frame_register_signed (struct frame_info
*frame
, int regnum
)
1169 return frame_unwind_register_signed (frame
->next
, regnum
);
1173 frame_unwind_register_unsigned (struct frame_info
*frame
, int regnum
)
1175 struct gdbarch
*gdbarch
= frame_unwind_arch (frame
);
1176 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1177 int size
= register_size (gdbarch
, regnum
);
1178 gdb_byte buf
[MAX_REGISTER_SIZE
];
1180 frame_unwind_register (frame
, regnum
, buf
);
1181 return extract_unsigned_integer (buf
, size
, byte_order
);
1185 get_frame_register_unsigned (struct frame_info
*frame
, int regnum
)
1187 return frame_unwind_register_unsigned (frame
->next
, regnum
);
1191 read_frame_register_unsigned (struct frame_info
*frame
, int regnum
,
1194 struct value
*regval
= get_frame_register_value (frame
, regnum
);
1196 if (!value_optimized_out (regval
)
1197 && value_entirely_available (regval
))
1199 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1200 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1201 int size
= register_size (gdbarch
, VALUE_REGNUM (regval
));
1203 *val
= extract_unsigned_integer (value_contents (regval
), size
, byte_order
);
1211 put_frame_register (struct frame_info
*frame
, int regnum
,
1212 const gdb_byte
*buf
)
1214 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1218 enum lval_type lval
;
1221 frame_register (frame
, regnum
, &optim
, &unavail
,
1222 &lval
, &addr
, &realnum
, NULL
);
1224 error (_("Attempt to assign to a register that was not saved."));
1229 write_memory (addr
, buf
, register_size (gdbarch
, regnum
));
1233 regcache_cooked_write (get_current_regcache (), realnum
, buf
);
1236 error (_("Attempt to assign to an unmodifiable value."));
1240 /* This function is deprecated. Use get_frame_register_value instead,
1241 which provides more accurate information.
1243 Find and return the value of REGNUM for the specified stack frame.
1244 The number of bytes copied is REGISTER_SIZE (REGNUM).
1246 Returns 0 if the register value could not be found. */
1249 deprecated_frame_register_read (struct frame_info
*frame
, int regnum
,
1254 enum lval_type lval
;
1258 frame_register (frame
, regnum
, &optimized
, &unavailable
,
1259 &lval
, &addr
, &realnum
, myaddr
);
1261 return !optimized
&& !unavailable
;
1265 get_frame_register_bytes (struct frame_info
*frame
, int regnum
,
1266 CORE_ADDR offset
, int len
, gdb_byte
*myaddr
,
1267 int *optimizedp
, int *unavailablep
)
1269 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1274 /* Skip registers wholly inside of OFFSET. */
1275 while (offset
>= register_size (gdbarch
, regnum
))
1277 offset
-= register_size (gdbarch
, regnum
);
1281 /* Ensure that we will not read beyond the end of the register file.
1282 This can only ever happen if the debug information is bad. */
1284 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1285 for (i
= regnum
; i
< numregs
; i
++)
1287 int thissize
= register_size (gdbarch
, i
);
1290 break; /* This register is not available on this architecture. */
1291 maxsize
+= thissize
;
1294 error (_("Bad debug information detected: "
1295 "Attempt to read %d bytes from registers."), len
);
1297 /* Copy the data. */
1300 int curr_len
= register_size (gdbarch
, regnum
) - offset
;
1305 if (curr_len
== register_size (gdbarch
, regnum
))
1307 enum lval_type lval
;
1311 frame_register (frame
, regnum
, optimizedp
, unavailablep
,
1312 &lval
, &addr
, &realnum
, myaddr
);
1313 if (*optimizedp
|| *unavailablep
)
1318 gdb_byte buf
[MAX_REGISTER_SIZE
];
1319 enum lval_type lval
;
1323 frame_register (frame
, regnum
, optimizedp
, unavailablep
,
1324 &lval
, &addr
, &realnum
, buf
);
1325 if (*optimizedp
|| *unavailablep
)
1327 memcpy (myaddr
, buf
+ offset
, curr_len
);
1342 put_frame_register_bytes (struct frame_info
*frame
, int regnum
,
1343 CORE_ADDR offset
, int len
, const gdb_byte
*myaddr
)
1345 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1347 /* Skip registers wholly inside of OFFSET. */
1348 while (offset
>= register_size (gdbarch
, regnum
))
1350 offset
-= register_size (gdbarch
, regnum
);
1354 /* Copy the data. */
1357 int curr_len
= register_size (gdbarch
, regnum
) - offset
;
1362 if (curr_len
== register_size (gdbarch
, regnum
))
1364 put_frame_register (frame
, regnum
, myaddr
);
1368 gdb_byte buf
[MAX_REGISTER_SIZE
];
1370 deprecated_frame_register_read (frame
, regnum
, buf
);
1371 memcpy (buf
+ offset
, myaddr
, curr_len
);
1372 put_frame_register (frame
, regnum
, buf
);
1382 /* Create a sentinel frame. */
1384 static struct frame_info
*
1385 create_sentinel_frame (struct program_space
*pspace
, struct regcache
*regcache
)
1387 struct frame_info
*frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1390 frame
->pspace
= pspace
;
1391 frame
->aspace
= get_regcache_aspace (regcache
);
1392 /* Explicitly initialize the sentinel frame's cache. Provide it
1393 with the underlying regcache. In the future additional
1394 information, such as the frame's thread will be added. */
1395 frame
->prologue_cache
= sentinel_frame_cache (regcache
);
1396 /* For the moment there is only one sentinel frame implementation. */
1397 frame
->unwind
= &sentinel_frame_unwind
;
1398 /* Link this frame back to itself. The frame is self referential
1399 (the unwound PC is the same as the pc), so make it so. */
1400 frame
->next
= frame
;
1401 /* Make the sentinel frame's ID valid, but invalid. That way all
1402 comparisons with it should fail. */
1403 frame
->this_id
.p
= 1;
1404 frame
->this_id
.value
= null_frame_id
;
1407 fprintf_unfiltered (gdb_stdlog
, "{ create_sentinel_frame (...) -> ");
1408 fprint_frame (gdb_stdlog
, frame
);
1409 fprintf_unfiltered (gdb_stdlog
, " }\n");
1414 /* Info about the innermost stack frame (contents of FP register). */
1416 static struct frame_info
*current_frame
;
1418 /* Cache for frame addresses already read by gdb. Valid only while
1419 inferior is stopped. Control variables for the frame cache should
1420 be local to this module. */
1422 static struct obstack frame_cache_obstack
;
1425 frame_obstack_zalloc (unsigned long size
)
1427 void *data
= obstack_alloc (&frame_cache_obstack
, size
);
1429 memset (data
, 0, size
);
1433 /* Return the innermost (currently executing) stack frame. This is
1434 split into two functions. The function unwind_to_current_frame()
1435 is wrapped in catch exceptions so that, even when the unwind of the
1436 sentinel frame fails, the function still returns a stack frame. */
1439 unwind_to_current_frame (struct ui_out
*ui_out
, void *args
)
1441 struct frame_info
*frame
= get_prev_frame (args
);
1443 /* A sentinel frame can fail to unwind, e.g., because its PC value
1444 lands in somewhere like start. */
1447 current_frame
= frame
;
1452 get_current_frame (void)
1454 /* First check, and report, the lack of registers. Having GDB
1455 report "No stack!" or "No memory" when the target doesn't even
1456 have registers is very confusing. Besides, "printcmd.exp"
1457 explicitly checks that ``print $pc'' with no registers prints "No
1459 if (!target_has_registers
)
1460 error (_("No registers."));
1461 if (!target_has_stack
)
1462 error (_("No stack."));
1463 if (!target_has_memory
)
1464 error (_("No memory."));
1465 /* Traceframes are effectively a substitute for the live inferior. */
1466 if (get_traceframe_number () < 0)
1468 if (ptid_equal (inferior_ptid
, null_ptid
))
1469 error (_("No selected thread."));
1470 if (is_exited (inferior_ptid
))
1471 error (_("Invalid selected thread."));
1472 if (is_executing (inferior_ptid
))
1473 error (_("Target is executing."));
1476 if (current_frame
== NULL
)
1478 struct frame_info
*sentinel_frame
=
1479 create_sentinel_frame (current_program_space
, get_current_regcache ());
1480 if (catch_exceptions (current_uiout
, unwind_to_current_frame
,
1481 sentinel_frame
, RETURN_MASK_ERROR
) != 0)
1483 /* Oops! Fake a current frame? Is this useful? It has a PC
1484 of zero, for instance. */
1485 current_frame
= sentinel_frame
;
1488 return current_frame
;
1491 /* The "selected" stack frame is used by default for local and arg
1492 access. May be zero, for no selected frame. */
1494 static struct frame_info
*selected_frame
;
1497 has_stack_frames (void)
1499 if (!target_has_registers
|| !target_has_stack
|| !target_has_memory
)
1502 /* Traceframes are effectively a substitute for the live inferior. */
1503 if (get_traceframe_number () < 0)
1505 /* No current inferior, no frame. */
1506 if (ptid_equal (inferior_ptid
, null_ptid
))
1509 /* Don't try to read from a dead thread. */
1510 if (is_exited (inferior_ptid
))
1513 /* ... or from a spinning thread. */
1514 if (is_executing (inferior_ptid
))
1521 /* Return the selected frame. Always non-NULL (unless there isn't an
1522 inferior sufficient for creating a frame) in which case an error is
1526 get_selected_frame (const char *message
)
1528 if (selected_frame
== NULL
)
1530 if (message
!= NULL
&& !has_stack_frames ())
1531 error (("%s"), message
);
1532 /* Hey! Don't trust this. It should really be re-finding the
1533 last selected frame of the currently selected thread. This,
1534 though, is better than nothing. */
1535 select_frame (get_current_frame ());
1537 /* There is always a frame. */
1538 gdb_assert (selected_frame
!= NULL
);
1539 return selected_frame
;
1542 /* If there is a selected frame, return it. Otherwise, return NULL. */
1545 get_selected_frame_if_set (void)
1547 return selected_frame
;
1550 /* This is a variant of get_selected_frame() which can be called when
1551 the inferior does not have a frame; in that case it will return
1552 NULL instead of calling error(). */
1555 deprecated_safe_get_selected_frame (void)
1557 if (!has_stack_frames ())
1559 return get_selected_frame (NULL
);
1562 /* Select frame FI (or NULL - to invalidate the current frame). */
1565 select_frame (struct frame_info
*fi
)
1567 selected_frame
= fi
;
1568 /* NOTE: cagney/2002-05-04: FI can be NULL. This occurs when the
1569 frame is being invalidated. */
1570 if (deprecated_selected_frame_level_changed_hook
)
1571 deprecated_selected_frame_level_changed_hook (frame_relative_level (fi
));
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 symtab
*s
= find_pc_symtab (pc
);
1600 && s
->language
!= current_language
->la_language
1601 && s
->language
!= language_unknown
1602 && language_mode
== language_mode_auto
)
1603 set_language (s
->language
);
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 /* Get the previous raw frame, and check that it is not identical to
1737 same other frame frame already in the chain. If it is, there is
1738 most likely a stack cycle, so we discard it, and mark THIS_FRAME as
1739 outermost, with UNWIND_SAME_ID stop reason. Unlike the other
1740 validity tests, that compare THIS_FRAME and the next frame, we do
1741 this right after creating the previous frame, to avoid ever ending
1742 up with two frames with the same id in the frame chain. */
1744 static struct frame_info
*
1745 get_prev_frame_if_no_cycle (struct frame_info
*this_frame
)
1747 struct frame_info
*prev_frame
;
1749 prev_frame
= get_prev_frame_raw (this_frame
);
1750 if (prev_frame
== NULL
)
1753 compute_frame_id (prev_frame
);
1754 if (frame_stash_add (prev_frame
))
1757 /* Another frame with the same id was already in the stash. We just
1758 detected a cycle. */
1761 fprintf_unfiltered (gdb_stdlog
, "-> ");
1762 fprint_frame (gdb_stdlog
, NULL
);
1763 fprintf_unfiltered (gdb_stdlog
, " // this frame has same ID }\n");
1765 this_frame
->stop_reason
= UNWIND_SAME_ID
;
1767 prev_frame
->next
= NULL
;
1768 this_frame
->prev
= NULL
;
1772 /* Return a "struct frame_info" corresponding to the frame that called
1773 THIS_FRAME. Returns NULL if there is no such frame.
1775 Unlike get_prev_frame, this function always tries to unwind the
1778 static struct frame_info
*
1779 get_prev_frame_1 (struct frame_info
*this_frame
)
1781 struct gdbarch
*gdbarch
;
1783 gdb_assert (this_frame
!= NULL
);
1784 gdbarch
= get_frame_arch (this_frame
);
1788 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame_1 (this_frame=");
1789 if (this_frame
!= NULL
)
1790 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1792 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1793 fprintf_unfiltered (gdb_stdlog
, ") ");
1796 /* Only try to do the unwind once. */
1797 if (this_frame
->prev_p
)
1801 fprintf_unfiltered (gdb_stdlog
, "-> ");
1802 fprint_frame (gdb_stdlog
, this_frame
->prev
);
1803 fprintf_unfiltered (gdb_stdlog
, " // cached \n");
1805 return this_frame
->prev
;
1808 /* If the frame unwinder hasn't been selected yet, we must do so
1809 before setting prev_p; otherwise the check for misbehaved
1810 sniffers will think that this frame's sniffer tried to unwind
1811 further (see frame_cleanup_after_sniffer). */
1812 if (this_frame
->unwind
== NULL
)
1813 frame_unwind_find_by_frame (this_frame
, &this_frame
->prologue_cache
);
1815 this_frame
->prev_p
= 1;
1816 this_frame
->stop_reason
= UNWIND_NO_REASON
;
1818 /* If we are unwinding from an inline frame, all of the below tests
1819 were already performed when we unwound from the next non-inline
1820 frame. We must skip them, since we can not get THIS_FRAME's ID
1821 until we have unwound all the way down to the previous non-inline
1823 if (get_frame_type (this_frame
) == INLINE_FRAME
)
1824 return get_prev_frame_if_no_cycle (this_frame
);
1826 /* Check that this frame is unwindable. If it isn't, don't try to
1827 unwind to the prev frame. */
1828 this_frame
->stop_reason
1829 = this_frame
->unwind
->stop_reason (this_frame
,
1830 &this_frame
->prologue_cache
);
1832 if (this_frame
->stop_reason
!= UNWIND_NO_REASON
)
1836 enum unwind_stop_reason reason
= this_frame
->stop_reason
;
1838 fprintf_unfiltered (gdb_stdlog
, "-> ");
1839 fprint_frame (gdb_stdlog
, NULL
);
1840 fprintf_unfiltered (gdb_stdlog
, " // %s }\n",
1841 frame_stop_reason_symbol_string (reason
));
1846 /* Check that this frame's ID isn't inner to (younger, below, next)
1847 the next frame. This happens when a frame unwind goes backwards.
1848 This check is valid only if this frame and the next frame are NORMAL.
1849 See the comment at frame_id_inner for details. */
1850 if (get_frame_type (this_frame
) == NORMAL_FRAME
1851 && this_frame
->next
->unwind
->type
== NORMAL_FRAME
1852 && frame_id_inner (get_frame_arch (this_frame
->next
),
1853 get_frame_id (this_frame
),
1854 get_frame_id (this_frame
->next
)))
1856 CORE_ADDR this_pc_in_block
;
1857 struct minimal_symbol
*morestack_msym
;
1858 const char *morestack_name
= NULL
;
1860 /* gcc -fsplit-stack __morestack can continue the stack anywhere. */
1861 this_pc_in_block
= get_frame_address_in_block (this_frame
);
1862 morestack_msym
= lookup_minimal_symbol_by_pc (this_pc_in_block
).minsym
;
1864 morestack_name
= MSYMBOL_LINKAGE_NAME (morestack_msym
);
1865 if (!morestack_name
|| strcmp (morestack_name
, "__morestack") != 0)
1869 fprintf_unfiltered (gdb_stdlog
, "-> ");
1870 fprint_frame (gdb_stdlog
, NULL
);
1871 fprintf_unfiltered (gdb_stdlog
,
1872 " // this frame ID is inner }\n");
1874 this_frame
->stop_reason
= UNWIND_INNER_ID
;
1879 /* Check that this and the next frame do not unwind the PC register
1880 to the same memory location. If they do, then even though they
1881 have different frame IDs, the new frame will be bogus; two
1882 functions can't share a register save slot for the PC. This can
1883 happen when the prologue analyzer finds a stack adjustment, but
1886 This check does assume that the "PC register" is roughly a
1887 traditional PC, even if the gdbarch_unwind_pc method adjusts
1888 it (we do not rely on the value, only on the unwound PC being
1889 dependent on this value). A potential improvement would be
1890 to have the frame prev_pc method and the gdbarch unwind_pc
1891 method set the same lval and location information as
1892 frame_register_unwind. */
1893 if (this_frame
->level
> 0
1894 && gdbarch_pc_regnum (gdbarch
) >= 0
1895 && get_frame_type (this_frame
) == NORMAL_FRAME
1896 && (get_frame_type (this_frame
->next
) == NORMAL_FRAME
1897 || get_frame_type (this_frame
->next
) == INLINE_FRAME
))
1899 int optimized
, realnum
, nrealnum
;
1900 enum lval_type lval
, nlval
;
1901 CORE_ADDR addr
, naddr
;
1903 frame_register_unwind_location (this_frame
,
1904 gdbarch_pc_regnum (gdbarch
),
1905 &optimized
, &lval
, &addr
, &realnum
);
1906 frame_register_unwind_location (get_next_frame (this_frame
),
1907 gdbarch_pc_regnum (gdbarch
),
1908 &optimized
, &nlval
, &naddr
, &nrealnum
);
1910 if ((lval
== lval_memory
&& lval
== nlval
&& addr
== naddr
)
1911 || (lval
== lval_register
&& lval
== nlval
&& realnum
== nrealnum
))
1915 fprintf_unfiltered (gdb_stdlog
, "-> ");
1916 fprint_frame (gdb_stdlog
, NULL
);
1917 fprintf_unfiltered (gdb_stdlog
, " // no saved PC }\n");
1920 this_frame
->stop_reason
= UNWIND_NO_SAVED_PC
;
1921 this_frame
->prev
= NULL
;
1926 return get_prev_frame_if_no_cycle (this_frame
);
1929 /* Construct a new "struct frame_info" and link it previous to
1932 static struct frame_info
*
1933 get_prev_frame_raw (struct frame_info
*this_frame
)
1935 struct frame_info
*prev_frame
;
1937 /* Allocate the new frame but do not wire it in to the frame chain.
1938 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
1939 frame->next to pull some fancy tricks (of course such code is, by
1940 definition, recursive). Try to prevent it.
1942 There is no reason to worry about memory leaks, should the
1943 remainder of the function fail. The allocated memory will be
1944 quickly reclaimed when the frame cache is flushed, and the `we've
1945 been here before' check above will stop repeated memory
1946 allocation calls. */
1947 prev_frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1948 prev_frame
->level
= this_frame
->level
+ 1;
1950 /* For now, assume we don't have frame chains crossing address
1952 prev_frame
->pspace
= this_frame
->pspace
;
1953 prev_frame
->aspace
= this_frame
->aspace
;
1955 /* Don't yet compute ->unwind (and hence ->type). It is computed
1956 on-demand in get_frame_type, frame_register_unwind, and
1959 /* Don't yet compute the frame's ID. It is computed on-demand by
1962 /* The unwound frame ID is validate at the start of this function,
1963 as part of the logic to decide if that frame should be further
1964 unwound, and not here while the prev frame is being created.
1965 Doing this makes it possible for the user to examine a frame that
1966 has an invalid frame ID.
1968 Some very old VAX code noted: [...] For the sake of argument,
1969 suppose that the stack is somewhat trashed (which is one reason
1970 that "info frame" exists). So, return 0 (indicating we don't
1971 know the address of the arglist) if we don't know what frame this
1975 this_frame
->prev
= prev_frame
;
1976 prev_frame
->next
= this_frame
;
1980 fprintf_unfiltered (gdb_stdlog
, "-> ");
1981 fprint_frame (gdb_stdlog
, prev_frame
);
1982 fprintf_unfiltered (gdb_stdlog
, " }\n");
1988 /* Debug routine to print a NULL frame being returned. */
1991 frame_debug_got_null_frame (struct frame_info
*this_frame
,
1996 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame (this_frame=");
1997 if (this_frame
!= NULL
)
1998 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
2000 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
2001 fprintf_unfiltered (gdb_stdlog
, ") -> // %s}\n", reason
);
2005 /* Is this (non-sentinel) frame in the "main"() function? */
2008 inside_main_func (struct frame_info
*this_frame
)
2010 struct bound_minimal_symbol msymbol
;
2013 if (symfile_objfile
== 0)
2015 msymbol
= lookup_minimal_symbol (main_name (), NULL
, symfile_objfile
);
2016 if (msymbol
.minsym
== NULL
)
2018 /* Make certain that the code, and not descriptor, address is
2020 maddr
= gdbarch_convert_from_func_ptr_addr (get_frame_arch (this_frame
),
2021 BMSYMBOL_VALUE_ADDRESS (msymbol
),
2023 return maddr
== get_frame_func (this_frame
);
2026 /* Test whether THIS_FRAME is inside the process entry point function. */
2029 inside_entry_func (struct frame_info
*this_frame
)
2031 CORE_ADDR entry_point
;
2033 if (!entry_point_address_query (&entry_point
))
2036 return get_frame_func (this_frame
) == entry_point
;
2039 /* Return a structure containing various interesting information about
2040 the frame that called THIS_FRAME. Returns NULL if there is entier
2041 no such frame or the frame fails any of a set of target-independent
2042 condition that should terminate the frame chain (e.g., as unwinding
2045 This function should not contain target-dependent tests, such as
2046 checking whether the program-counter is zero. */
2049 get_prev_frame (struct frame_info
*this_frame
)
2054 /* There is always a frame. If this assertion fails, suspect that
2055 something should be calling get_selected_frame() or
2056 get_current_frame(). */
2057 gdb_assert (this_frame
!= NULL
);
2058 frame_pc_p
= get_frame_pc_if_available (this_frame
, &frame_pc
);
2060 /* tausq/2004-12-07: Dummy frames are skipped because it doesn't make much
2061 sense to stop unwinding at a dummy frame. One place where a dummy
2062 frame may have an address "inside_main_func" is on HPUX. On HPUX, the
2063 pcsqh register (space register for the instruction at the head of the
2064 instruction queue) cannot be written directly; the only way to set it
2065 is to branch to code that is in the target space. In order to implement
2066 frame dummies on HPUX, the called function is made to jump back to where
2067 the inferior was when the user function was called. If gdb was inside
2068 the main function when we created the dummy frame, the dummy frame will
2069 point inside the main function. */
2070 if (this_frame
->level
>= 0
2071 && get_frame_type (this_frame
) == NORMAL_FRAME
2072 && !backtrace_past_main
2074 && inside_main_func (this_frame
))
2075 /* Don't unwind past main(). Note, this is done _before_ the
2076 frame has been marked as previously unwound. That way if the
2077 user later decides to enable unwinds past main(), that will
2078 automatically happen. */
2080 frame_debug_got_null_frame (this_frame
, "inside main func");
2084 /* If the user's backtrace limit has been exceeded, stop. We must
2085 add two to the current level; one of those accounts for backtrace_limit
2086 being 1-based and the level being 0-based, and the other accounts for
2087 the level of the new frame instead of the level of the current
2089 if (this_frame
->level
+ 2 > backtrace_limit
)
2091 frame_debug_got_null_frame (this_frame
, "backtrace limit exceeded");
2095 /* If we're already inside the entry function for the main objfile,
2096 then it isn't valid. Don't apply this test to a dummy frame -
2097 dummy frame PCs typically land in the entry func. Don't apply
2098 this test to the sentinel frame. Sentinel frames should always
2099 be allowed to unwind. */
2100 /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() -
2101 wasn't checking for "main" in the minimal symbols. With that
2102 fixed asm-source tests now stop in "main" instead of halting the
2103 backtrace in weird and wonderful ways somewhere inside the entry
2104 file. Suspect that tests for inside the entry file/func were
2105 added to work around that (now fixed) case. */
2106 /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
2107 suggested having the inside_entry_func test use the
2108 inside_main_func() msymbol trick (along with entry_point_address()
2109 I guess) to determine the address range of the start function.
2110 That should provide a far better stopper than the current
2112 /* NOTE: tausq/2004-10-09: this is needed if, for example, the compiler
2113 applied tail-call optimizations to main so that a function called
2114 from main returns directly to the caller of main. Since we don't
2115 stop at main, we should at least stop at the entry point of the
2117 if (this_frame
->level
>= 0
2118 && get_frame_type (this_frame
) == NORMAL_FRAME
2119 && !backtrace_past_entry
2121 && inside_entry_func (this_frame
))
2123 frame_debug_got_null_frame (this_frame
, "inside entry func");
2127 /* Assume that the only way to get a zero PC is through something
2128 like a SIGSEGV or a dummy frame, and hence that NORMAL frames
2129 will never unwind a zero PC. */
2130 if (this_frame
->level
> 0
2131 && (get_frame_type (this_frame
) == NORMAL_FRAME
2132 || get_frame_type (this_frame
) == INLINE_FRAME
)
2133 && get_frame_type (get_next_frame (this_frame
)) == NORMAL_FRAME
2134 && frame_pc_p
&& frame_pc
== 0)
2136 frame_debug_got_null_frame (this_frame
, "zero PC");
2140 return get_prev_frame_1 (this_frame
);
2144 get_frame_pc (struct frame_info
*frame
)
2146 gdb_assert (frame
->next
!= NULL
);
2147 return frame_unwind_pc (frame
->next
);
2151 get_frame_pc_if_available (struct frame_info
*frame
, CORE_ADDR
*pc
)
2153 volatile struct gdb_exception ex
;
2155 gdb_assert (frame
->next
!= NULL
);
2157 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2159 *pc
= frame_unwind_pc (frame
->next
);
2163 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2166 throw_exception (ex
);
2172 /* Return an address that falls within THIS_FRAME's code block. */
2175 get_frame_address_in_block (struct frame_info
*this_frame
)
2177 /* A draft address. */
2178 CORE_ADDR pc
= get_frame_pc (this_frame
);
2180 struct frame_info
*next_frame
= this_frame
->next
;
2182 /* Calling get_frame_pc returns the resume address for THIS_FRAME.
2183 Normally the resume address is inside the body of the function
2184 associated with THIS_FRAME, but there is a special case: when
2185 calling a function which the compiler knows will never return
2186 (for instance abort), the call may be the very last instruction
2187 in the calling function. The resume address will point after the
2188 call and may be at the beginning of a different function
2191 If THIS_FRAME is a signal frame or dummy frame, then we should
2192 not adjust the unwound PC. For a dummy frame, GDB pushed the
2193 resume address manually onto the stack. For a signal frame, the
2194 OS may have pushed the resume address manually and invoked the
2195 handler (e.g. GNU/Linux), or invoked the trampoline which called
2196 the signal handler - but in either case the signal handler is
2197 expected to return to the trampoline. So in both of these
2198 cases we know that the resume address is executable and
2199 related. So we only need to adjust the PC if THIS_FRAME
2200 is a normal function.
2202 If the program has been interrupted while THIS_FRAME is current,
2203 then clearly the resume address is inside the associated
2204 function. There are three kinds of interruption: debugger stop
2205 (next frame will be SENTINEL_FRAME), operating system
2206 signal or exception (next frame will be SIGTRAMP_FRAME),
2207 or debugger-induced function call (next frame will be
2208 DUMMY_FRAME). So we only need to adjust the PC if
2209 NEXT_FRAME is a normal function.
2211 We check the type of NEXT_FRAME first, since it is already
2212 known; frame type is determined by the unwinder, and since
2213 we have THIS_FRAME we've already selected an unwinder for
2216 If the next frame is inlined, we need to keep going until we find
2217 the real function - for instance, if a signal handler is invoked
2218 while in an inlined function, then the code address of the
2219 "calling" normal function should not be adjusted either. */
2221 while (get_frame_type (next_frame
) == INLINE_FRAME
)
2222 next_frame
= next_frame
->next
;
2224 if ((get_frame_type (next_frame
) == NORMAL_FRAME
2225 || get_frame_type (next_frame
) == TAILCALL_FRAME
)
2226 && (get_frame_type (this_frame
) == NORMAL_FRAME
2227 || get_frame_type (this_frame
) == TAILCALL_FRAME
2228 || get_frame_type (this_frame
) == INLINE_FRAME
))
2235 get_frame_address_in_block_if_available (struct frame_info
*this_frame
,
2238 volatile struct gdb_exception ex
;
2240 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2242 *pc
= get_frame_address_in_block (this_frame
);
2244 if (ex
.reason
< 0 && ex
.error
== NOT_AVAILABLE_ERROR
)
2246 else if (ex
.reason
< 0)
2247 throw_exception (ex
);
2253 find_frame_sal (struct frame_info
*frame
, struct symtab_and_line
*sal
)
2255 struct frame_info
*next_frame
;
2259 /* If the next frame represents an inlined function call, this frame's
2260 sal is the "call site" of that inlined function, which can not
2261 be inferred from get_frame_pc. */
2262 next_frame
= get_next_frame (frame
);
2263 if (frame_inlined_callees (frame
) > 0)
2268 sym
= get_frame_function (next_frame
);
2270 sym
= inline_skipped_symbol (inferior_ptid
);
2272 /* If frame is inline, it certainly has symbols. */
2275 if (SYMBOL_LINE (sym
) != 0)
2277 sal
->symtab
= SYMBOL_SYMTAB (sym
);
2278 sal
->line
= SYMBOL_LINE (sym
);
2281 /* If the symbol does not have a location, we don't know where
2282 the call site is. Do not pretend to. This is jarring, but
2283 we can't do much better. */
2284 sal
->pc
= get_frame_pc (frame
);
2286 sal
->pspace
= get_frame_program_space (frame
);
2291 /* If FRAME is not the innermost frame, that normally means that
2292 FRAME->pc points at the return instruction (which is *after* the
2293 call instruction), and we want to get the line containing the
2294 call (because the call is where the user thinks the program is).
2295 However, if the next frame is either a SIGTRAMP_FRAME or a
2296 DUMMY_FRAME, then the next frame will contain a saved interrupt
2297 PC and such a PC indicates the current (rather than next)
2298 instruction/line, consequently, for such cases, want to get the
2299 line containing fi->pc. */
2300 if (!get_frame_pc_if_available (frame
, &pc
))
2306 notcurrent
= (pc
!= get_frame_address_in_block (frame
));
2307 (*sal
) = find_pc_line (pc
, notcurrent
);
2310 /* Per "frame.h", return the ``address'' of the frame. Code should
2311 really be using get_frame_id(). */
2313 get_frame_base (struct frame_info
*fi
)
2315 return get_frame_id (fi
).stack_addr
;
2318 /* High-level offsets into the frame. Used by the debug info. */
2321 get_frame_base_address (struct frame_info
*fi
)
2323 if (get_frame_type (fi
) != NORMAL_FRAME
)
2325 if (fi
->base
== NULL
)
2326 fi
->base
= frame_base_find_by_frame (fi
);
2327 /* Sneaky: If the low-level unwind and high-level base code share a
2328 common unwinder, let them share the prologue cache. */
2329 if (fi
->base
->unwind
== fi
->unwind
)
2330 return fi
->base
->this_base (fi
, &fi
->prologue_cache
);
2331 return fi
->base
->this_base (fi
, &fi
->base_cache
);
2335 get_frame_locals_address (struct frame_info
*fi
)
2337 if (get_frame_type (fi
) != NORMAL_FRAME
)
2339 /* If there isn't a frame address method, find it. */
2340 if (fi
->base
== NULL
)
2341 fi
->base
= frame_base_find_by_frame (fi
);
2342 /* Sneaky: If the low-level unwind and high-level base code share a
2343 common unwinder, let them share the prologue cache. */
2344 if (fi
->base
->unwind
== fi
->unwind
)
2345 return fi
->base
->this_locals (fi
, &fi
->prologue_cache
);
2346 return fi
->base
->this_locals (fi
, &fi
->base_cache
);
2350 get_frame_args_address (struct frame_info
*fi
)
2352 if (get_frame_type (fi
) != NORMAL_FRAME
)
2354 /* If there isn't a frame address method, find it. */
2355 if (fi
->base
== NULL
)
2356 fi
->base
= frame_base_find_by_frame (fi
);
2357 /* Sneaky: If the low-level unwind and high-level base code share a
2358 common unwinder, let them share the prologue cache. */
2359 if (fi
->base
->unwind
== fi
->unwind
)
2360 return fi
->base
->this_args (fi
, &fi
->prologue_cache
);
2361 return fi
->base
->this_args (fi
, &fi
->base_cache
);
2364 /* Return true if the frame unwinder for frame FI is UNWINDER; false
2368 frame_unwinder_is (struct frame_info
*fi
, const struct frame_unwind
*unwinder
)
2370 if (fi
->unwind
== NULL
)
2371 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
2372 return fi
->unwind
== unwinder
;
2375 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
2376 or -1 for a NULL frame. */
2379 frame_relative_level (struct frame_info
*fi
)
2388 get_frame_type (struct frame_info
*frame
)
2390 if (frame
->unwind
== NULL
)
2391 /* Initialize the frame's unwinder because that's what
2392 provides the frame's type. */
2393 frame_unwind_find_by_frame (frame
, &frame
->prologue_cache
);
2394 return frame
->unwind
->type
;
2397 struct program_space
*
2398 get_frame_program_space (struct frame_info
*frame
)
2400 return frame
->pspace
;
2403 struct program_space
*
2404 frame_unwind_program_space (struct frame_info
*this_frame
)
2406 gdb_assert (this_frame
);
2408 /* This is really a placeholder to keep the API consistent --- we
2409 assume for now that we don't have frame chains crossing
2411 return this_frame
->pspace
;
2414 struct address_space
*
2415 get_frame_address_space (struct frame_info
*frame
)
2417 return frame
->aspace
;
2420 /* Memory access methods. */
2423 get_frame_memory (struct frame_info
*this_frame
, CORE_ADDR addr
,
2424 gdb_byte
*buf
, int len
)
2426 read_memory (addr
, buf
, len
);
2430 get_frame_memory_signed (struct frame_info
*this_frame
, CORE_ADDR addr
,
2433 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2434 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2436 return read_memory_integer (addr
, len
, byte_order
);
2440 get_frame_memory_unsigned (struct frame_info
*this_frame
, CORE_ADDR addr
,
2443 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2444 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2446 return read_memory_unsigned_integer (addr
, len
, byte_order
);
2450 safe_frame_unwind_memory (struct frame_info
*this_frame
,
2451 CORE_ADDR addr
, gdb_byte
*buf
, int len
)
2453 /* NOTE: target_read_memory returns zero on success! */
2454 return !target_read_memory (addr
, buf
, len
);
2457 /* Architecture methods. */
2460 get_frame_arch (struct frame_info
*this_frame
)
2462 return frame_unwind_arch (this_frame
->next
);
2466 frame_unwind_arch (struct frame_info
*next_frame
)
2468 if (!next_frame
->prev_arch
.p
)
2470 struct gdbarch
*arch
;
2472 if (next_frame
->unwind
== NULL
)
2473 frame_unwind_find_by_frame (next_frame
, &next_frame
->prologue_cache
);
2475 if (next_frame
->unwind
->prev_arch
!= NULL
)
2476 arch
= next_frame
->unwind
->prev_arch (next_frame
,
2477 &next_frame
->prologue_cache
);
2479 arch
= get_frame_arch (next_frame
);
2481 next_frame
->prev_arch
.arch
= arch
;
2482 next_frame
->prev_arch
.p
= 1;
2484 fprintf_unfiltered (gdb_stdlog
,
2485 "{ frame_unwind_arch (next_frame=%d) -> %s }\n",
2487 gdbarch_bfd_arch_info (arch
)->printable_name
);
2490 return next_frame
->prev_arch
.arch
;
2494 frame_unwind_caller_arch (struct frame_info
*next_frame
)
2496 return frame_unwind_arch (skip_artificial_frames (next_frame
));
2499 /* Stack pointer methods. */
2502 get_frame_sp (struct frame_info
*this_frame
)
2504 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2506 /* Normality - an architecture that provides a way of obtaining any
2507 frame inner-most address. */
2508 if (gdbarch_unwind_sp_p (gdbarch
))
2509 /* NOTE drow/2008-06-28: gdbarch_unwind_sp could be converted to
2510 operate on THIS_FRAME now. */
2511 return gdbarch_unwind_sp (gdbarch
, this_frame
->next
);
2512 /* Now things are really are grim. Hope that the value returned by
2513 the gdbarch_sp_regnum register is meaningful. */
2514 if (gdbarch_sp_regnum (gdbarch
) >= 0)
2515 return get_frame_register_unsigned (this_frame
,
2516 gdbarch_sp_regnum (gdbarch
));
2517 internal_error (__FILE__
, __LINE__
, _("Missing unwind SP method"));
2520 /* Return the reason why we can't unwind past FRAME. */
2522 enum unwind_stop_reason
2523 get_frame_unwind_stop_reason (struct frame_info
*frame
)
2525 /* Fill-in STOP_REASON. */
2526 get_prev_frame_1 (frame
);
2527 gdb_assert (frame
->prev_p
);
2529 return frame
->stop_reason
;
2532 /* Return a string explaining REASON. */
2535 frame_stop_reason_string (enum unwind_stop_reason reason
)
2539 #define SET(name, description) \
2540 case name: return _(description);
2541 #include "unwind_stop_reasons.def"
2545 internal_error (__FILE__
, __LINE__
,
2546 "Invalid frame stop reason");
2550 /* Return the enum symbol name of REASON as a string, to use in debug
2554 frame_stop_reason_symbol_string (enum unwind_stop_reason reason
)
2558 #define SET(name, description) \
2559 case name: return #name;
2560 #include "unwind_stop_reasons.def"
2564 internal_error (__FILE__
, __LINE__
,
2565 "Invalid frame stop reason");
2569 /* Clean up after a failed (wrong unwinder) attempt to unwind past
2573 frame_cleanup_after_sniffer (void *arg
)
2575 struct frame_info
*frame
= arg
;
2577 /* The sniffer should not allocate a prologue cache if it did not
2578 match this frame. */
2579 gdb_assert (frame
->prologue_cache
== NULL
);
2581 /* No sniffer should extend the frame chain; sniff based on what is
2583 gdb_assert (!frame
->prev_p
);
2585 /* The sniffer should not check the frame's ID; that's circular. */
2586 gdb_assert (!frame
->this_id
.p
);
2588 /* Clear cached fields dependent on the unwinder.
2590 The previous PC is independent of the unwinder, but the previous
2591 function is not (see get_frame_address_in_block). */
2592 frame
->prev_func
.p
= 0;
2593 frame
->prev_func
.addr
= 0;
2595 /* Discard the unwinder last, so that we can easily find it if an assertion
2596 in this function triggers. */
2597 frame
->unwind
= NULL
;
2600 /* Set FRAME's unwinder temporarily, so that we can call a sniffer.
2601 Return a cleanup which should be called if unwinding fails, and
2602 discarded if it succeeds. */
2605 frame_prepare_for_sniffer (struct frame_info
*frame
,
2606 const struct frame_unwind
*unwind
)
2608 gdb_assert (frame
->unwind
== NULL
);
2609 frame
->unwind
= unwind
;
2610 return make_cleanup (frame_cleanup_after_sniffer
, frame
);
2613 extern initialize_file_ftype _initialize_frame
; /* -Wmissing-prototypes */
2615 static struct cmd_list_element
*set_backtrace_cmdlist
;
2616 static struct cmd_list_element
*show_backtrace_cmdlist
;
2619 set_backtrace_cmd (char *args
, int from_tty
)
2621 help_list (set_backtrace_cmdlist
, "set backtrace ", -1, gdb_stdout
);
2625 show_backtrace_cmd (char *args
, int from_tty
)
2627 cmd_show_list (show_backtrace_cmdlist
, from_tty
, "");
2631 _initialize_frame (void)
2633 obstack_init (&frame_cache_obstack
);
2635 frame_stash_create ();
2637 observer_attach_target_changed (frame_observer_target_changed
);
2639 add_prefix_cmd ("backtrace", class_maintenance
, set_backtrace_cmd
, _("\
2640 Set backtrace specific variables.\n\
2641 Configure backtrace variables such as the backtrace limit"),
2642 &set_backtrace_cmdlist
, "set backtrace ",
2643 0/*allow-unknown*/, &setlist
);
2644 add_prefix_cmd ("backtrace", class_maintenance
, show_backtrace_cmd
, _("\
2645 Show backtrace specific variables\n\
2646 Show backtrace variables such as the backtrace limit"),
2647 &show_backtrace_cmdlist
, "show backtrace ",
2648 0/*allow-unknown*/, &showlist
);
2650 add_setshow_boolean_cmd ("past-main", class_obscure
,
2651 &backtrace_past_main
, _("\
2652 Set whether backtraces should continue past \"main\"."), _("\
2653 Show whether backtraces should continue past \"main\"."), _("\
2654 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
2655 the backtrace at \"main\". Set this variable if you need to see the rest\n\
2656 of the stack trace."),
2658 show_backtrace_past_main
,
2659 &set_backtrace_cmdlist
,
2660 &show_backtrace_cmdlist
);
2662 add_setshow_boolean_cmd ("past-entry", class_obscure
,
2663 &backtrace_past_entry
, _("\
2664 Set whether backtraces should continue past the entry point of a program."),
2666 Show whether backtraces should continue past the entry point of a program."),
2668 Normally there are no callers beyond the entry point of a program, so GDB\n\
2669 will terminate the backtrace there. Set this variable if you need to see\n\
2670 the rest of the stack trace."),
2672 show_backtrace_past_entry
,
2673 &set_backtrace_cmdlist
,
2674 &show_backtrace_cmdlist
);
2676 add_setshow_uinteger_cmd ("limit", class_obscure
,
2677 &backtrace_limit
, _("\
2678 Set an upper bound on the number of backtrace levels."), _("\
2679 Show the upper bound on the number of backtrace levels."), _("\
2680 No more than the specified number of frames can be displayed or examined.\n\
2681 Literal \"unlimited\" or zero means no limit."),
2683 show_backtrace_limit
,
2684 &set_backtrace_cmdlist
,
2685 &show_backtrace_cmdlist
);
2687 /* Debug this files internals. */
2688 add_setshow_zuinteger_cmd ("frame", class_maintenance
, &frame_debug
, _("\
2689 Set frame debugging."), _("\
2690 Show frame debugging."), _("\
2691 When non-zero, frame specific internal debugging is enabled."),
2694 &setdebuglist
, &showdebuglist
);