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_raw (struct frame_info
*this_frame
);
50 static const char *frame_stop_reason_symbol_string (enum unwind_stop_reason reason
);
52 /* Status of some values cached in the frame_info object. */
54 enum cached_copy_status
56 /* Value is unknown. */
59 /* We have a value. */
62 /* Value was not saved. */
65 /* Value is unavailable. */
69 /* We keep a cache of stack frames, each of which is a "struct
70 frame_info". The innermost one gets allocated (in
71 wait_for_inferior) each time the inferior stops; current_frame
72 points to it. Additional frames get allocated (in get_prev_frame)
73 as needed, and are chained through the next and prev fields. Any
74 time that the frame cache becomes invalid (most notably when we
75 execute something, but also if we change how we interpret the
76 frames (e.g. "set heuristic-fence-post" in mips-tdep.c, or anything
77 which reads new symbols)), we should call reinit_frame_cache. */
81 /* Level of this frame. The inner-most (youngest) frame is at level
82 0. As you move towards the outer-most (oldest) frame, the level
83 increases. This is a cached value. It could just as easily be
84 computed by counting back from the selected frame to the inner
86 /* NOTE: cagney/2002-04-05: Perhaps a level of ``-1'' should be
87 reserved to indicate a bogus frame - one that has been created
88 just to keep GDB happy (GDB always needs a frame). For the
89 moment leave this as speculation. */
92 /* The frame's program space. */
93 struct program_space
*pspace
;
95 /* The frame's address space. */
96 struct address_space
*aspace
;
98 /* The frame's low-level unwinder and corresponding cache. The
99 low-level unwinder is responsible for unwinding register values
100 for the previous frame. The low-level unwind methods are
101 selected based on the presence, or otherwise, of register unwind
102 information such as CFI. */
103 void *prologue_cache
;
104 const struct frame_unwind
*unwind
;
106 /* Cached copy of the previous frame's architecture. */
110 struct gdbarch
*arch
;
113 /* Cached copy of the previous frame's resume address. */
115 enum cached_copy_status status
;
119 /* Cached copy of the previous frame's function address. */
126 /* This frame's ID. */
130 struct frame_id value
;
133 /* The frame's high-level base methods, and corresponding cache.
134 The high level base methods are selected based on the frame's
136 const struct frame_base
*base
;
139 /* Pointers to the next (down, inner, younger) and previous (up,
140 outer, older) frame_info's in the frame cache. */
141 struct frame_info
*next
; /* down, inner, younger */
143 struct frame_info
*prev
; /* up, outer, older */
145 /* The reason why we could not set PREV, or UNWIND_NO_REASON if we
146 could. Only valid when PREV_P is set. */
147 enum unwind_stop_reason stop_reason
;
150 /* A frame stash used to speed up frame lookups. Create a hash table
151 to stash frames previously accessed from the frame cache for
152 quicker subsequent retrieval. The hash table is emptied whenever
153 the frame cache is invalidated. */
155 static htab_t frame_stash
;
157 /* Internal function to calculate a hash from the frame_id addresses,
158 using as many valid addresses as possible. Frames below level 0
159 are not stored in the hash table. */
162 frame_addr_hash (const void *ap
)
164 const struct frame_info
*frame
= ap
;
165 const struct frame_id f_id
= frame
->this_id
.value
;
168 gdb_assert (f_id
.stack_status
!= FID_STACK_INVALID
170 || f_id
.special_addr_p
);
172 if (f_id
.stack_status
== FID_STACK_VALID
)
173 hash
= iterative_hash (&f_id
.stack_addr
,
174 sizeof (f_id
.stack_addr
), hash
);
175 if (f_id
.code_addr_p
)
176 hash
= iterative_hash (&f_id
.code_addr
,
177 sizeof (f_id
.code_addr
), hash
);
178 if (f_id
.special_addr_p
)
179 hash
= iterative_hash (&f_id
.special_addr
,
180 sizeof (f_id
.special_addr
), hash
);
185 /* Internal equality function for the hash table. This function
186 defers equality operations to frame_id_eq. */
189 frame_addr_hash_eq (const void *a
, const void *b
)
191 const struct frame_info
*f_entry
= a
;
192 const struct frame_info
*f_element
= b
;
194 return frame_id_eq (f_entry
->this_id
.value
,
195 f_element
->this_id
.value
);
198 /* Internal function to create the frame_stash hash table. 100 seems
199 to be a good compromise to start the hash table at. */
202 frame_stash_create (void)
204 frame_stash
= htab_create (100,
210 /* Internal function to add a frame to the frame_stash hash table.
211 Returns false if a frame with the same ID was already stashed, true
215 frame_stash_add (struct frame_info
*frame
)
217 struct frame_info
**slot
;
219 /* Do not try to stash the sentinel frame. */
220 gdb_assert (frame
->level
>= 0);
222 slot
= (struct frame_info
**) htab_find_slot (frame_stash
,
226 /* If we already have a frame in the stack with the same id, we
227 either have a stack cycle (corrupted stack?), or some bug
228 elsewhere in GDB. In any case, ignore the duplicate and return
229 an indication to the caller. */
237 /* Internal function to search the frame stash for an entry with the
238 given frame ID. If found, return that frame. Otherwise return
241 static struct frame_info
*
242 frame_stash_find (struct frame_id id
)
244 struct frame_info dummy
;
245 struct frame_info
*frame
;
247 dummy
.this_id
.value
= id
;
248 frame
= htab_find (frame_stash
, &dummy
);
252 /* Internal function to invalidate the frame stash by removing all
253 entries in it. This only occurs when the frame cache is
257 frame_stash_invalidate (void)
259 htab_empty (frame_stash
);
262 /* Flag to control debugging. */
264 unsigned int frame_debug
;
266 show_frame_debug (struct ui_file
*file
, int from_tty
,
267 struct cmd_list_element
*c
, const char *value
)
269 fprintf_filtered (file
, _("Frame debugging is %s.\n"), value
);
272 /* Flag to indicate whether backtraces should stop at main et.al. */
274 static int backtrace_past_main
;
276 show_backtrace_past_main (struct ui_file
*file
, int from_tty
,
277 struct cmd_list_element
*c
, const char *value
)
279 fprintf_filtered (file
,
280 _("Whether backtraces should "
281 "continue past \"main\" is %s.\n"),
285 static int backtrace_past_entry
;
287 show_backtrace_past_entry (struct ui_file
*file
, int from_tty
,
288 struct cmd_list_element
*c
, const char *value
)
290 fprintf_filtered (file
, _("Whether backtraces should continue past the "
291 "entry point of a program is %s.\n"),
295 static unsigned int backtrace_limit
= UINT_MAX
;
297 show_backtrace_limit (struct ui_file
*file
, int from_tty
,
298 struct cmd_list_element
*c
, const char *value
)
300 fprintf_filtered (file
,
301 _("An upper bound on the number "
302 "of backtrace levels is %s.\n"),
308 fprint_field (struct ui_file
*file
, const char *name
, int p
, CORE_ADDR addr
)
311 fprintf_unfiltered (file
, "%s=%s", name
, hex_string (addr
));
313 fprintf_unfiltered (file
, "!%s", name
);
317 fprint_frame_id (struct ui_file
*file
, struct frame_id id
)
319 fprintf_unfiltered (file
, "{");
321 if (id
.stack_status
== FID_STACK_INVALID
)
322 fprintf_unfiltered (file
, "!stack");
323 else if (id
.stack_status
== FID_STACK_UNAVAILABLE
)
324 fprintf_unfiltered (file
, "stack=<unavailable>");
326 fprintf_unfiltered (file
, "stack=%s", hex_string (id
.stack_addr
));
327 fprintf_unfiltered (file
, ",");
329 fprint_field (file
, "code", id
.code_addr_p
, id
.code_addr
);
330 fprintf_unfiltered (file
, ",");
332 fprint_field (file
, "special", id
.special_addr_p
, id
.special_addr
);
334 if (id
.artificial_depth
)
335 fprintf_unfiltered (file
, ",artificial=%d", id
.artificial_depth
);
337 fprintf_unfiltered (file
, "}");
341 fprint_frame_type (struct ui_file
*file
, enum frame_type type
)
346 fprintf_unfiltered (file
, "NORMAL_FRAME");
349 fprintf_unfiltered (file
, "DUMMY_FRAME");
352 fprintf_unfiltered (file
, "INLINE_FRAME");
355 fprintf_unfiltered (file
, "TAILCALL_FRAME");
358 fprintf_unfiltered (file
, "SIGTRAMP_FRAME");
361 fprintf_unfiltered (file
, "ARCH_FRAME");
364 fprintf_unfiltered (file
, "SENTINEL_FRAME");
367 fprintf_unfiltered (file
, "<unknown type>");
373 fprint_frame (struct ui_file
*file
, struct frame_info
*fi
)
377 fprintf_unfiltered (file
, "<NULL frame>");
380 fprintf_unfiltered (file
, "{");
381 fprintf_unfiltered (file
, "level=%d", fi
->level
);
382 fprintf_unfiltered (file
, ",");
383 fprintf_unfiltered (file
, "type=");
384 if (fi
->unwind
!= NULL
)
385 fprint_frame_type (file
, fi
->unwind
->type
);
387 fprintf_unfiltered (file
, "<unknown>");
388 fprintf_unfiltered (file
, ",");
389 fprintf_unfiltered (file
, "unwind=");
390 if (fi
->unwind
!= NULL
)
391 gdb_print_host_address (fi
->unwind
, file
);
393 fprintf_unfiltered (file
, "<unknown>");
394 fprintf_unfiltered (file
, ",");
395 fprintf_unfiltered (file
, "pc=");
396 if (fi
->next
== NULL
|| fi
->next
->prev_pc
.status
== CC_UNKNOWN
)
397 fprintf_unfiltered (file
, "<unknown>");
398 else if (fi
->next
->prev_pc
.status
== CC_VALUE
)
399 fprintf_unfiltered (file
, "%s",
400 hex_string (fi
->next
->prev_pc
.value
));
401 else if (fi
->next
->prev_pc
.status
== CC_NOT_SAVED
)
402 val_print_not_saved (file
);
403 else if (fi
->next
->prev_pc
.status
== CC_UNAVAILABLE
)
404 val_print_unavailable (file
);
405 fprintf_unfiltered (file
, ",");
406 fprintf_unfiltered (file
, "id=");
408 fprint_frame_id (file
, fi
->this_id
.value
);
410 fprintf_unfiltered (file
, "<unknown>");
411 fprintf_unfiltered (file
, ",");
412 fprintf_unfiltered (file
, "func=");
413 if (fi
->next
!= NULL
&& fi
->next
->prev_func
.p
)
414 fprintf_unfiltered (file
, "%s", hex_string (fi
->next
->prev_func
.addr
));
416 fprintf_unfiltered (file
, "<unknown>");
417 fprintf_unfiltered (file
, "}");
420 /* Given FRAME, return the enclosing frame as found in real frames read-in from
421 inferior memory. Skip any previous frames which were made up by GDB.
422 Return the original frame if no immediate previous frames exist. */
424 static struct frame_info
*
425 skip_artificial_frames (struct frame_info
*frame
)
427 /* Note we use get_prev_frame_always, and not get_prev_frame. The
428 latter will truncate the frame chain, leading to this function
429 unintentionally returning a null_frame_id (e.g., when the user
430 sets a backtrace limit). This is safe, because as these frames
431 are made up by GDB, there must be a real frame in the chain
433 while (get_frame_type (frame
) == INLINE_FRAME
434 || get_frame_type (frame
) == TAILCALL_FRAME
)
435 frame
= get_prev_frame_always (frame
);
440 /* Compute the frame's uniq ID that can be used to, later, re-find the
444 compute_frame_id (struct frame_info
*fi
)
446 gdb_assert (!fi
->this_id
.p
);
449 fprintf_unfiltered (gdb_stdlog
, "{ compute_frame_id (fi=%d) ",
451 /* Find the unwinder. */
452 if (fi
->unwind
== NULL
)
453 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
454 /* Find THIS frame's ID. */
455 /* Default to outermost if no ID is found. */
456 fi
->this_id
.value
= outer_frame_id
;
457 fi
->unwind
->this_id (fi
, &fi
->prologue_cache
, &fi
->this_id
.value
);
458 gdb_assert (frame_id_p (fi
->this_id
.value
));
462 fprintf_unfiltered (gdb_stdlog
, "-> ");
463 fprint_frame_id (gdb_stdlog
, fi
->this_id
.value
);
464 fprintf_unfiltered (gdb_stdlog
, " }\n");
468 /* Return a frame uniq ID that can be used to, later, re-find the
472 get_frame_id (struct frame_info
*fi
)
475 return null_frame_id
;
477 gdb_assert (fi
->this_id
.p
);
478 return fi
->this_id
.value
;
482 get_stack_frame_id (struct frame_info
*next_frame
)
484 return get_frame_id (skip_artificial_frames (next_frame
));
488 frame_unwind_caller_id (struct frame_info
*next_frame
)
490 struct frame_info
*this_frame
;
492 /* Use get_prev_frame_always, and not get_prev_frame. The latter
493 will truncate the frame chain, leading to this function
494 unintentionally returning a null_frame_id (e.g., when a caller
495 requests the frame ID of "main()"s caller. */
497 next_frame
= skip_artificial_frames (next_frame
);
498 this_frame
= get_prev_frame_always (next_frame
);
500 return get_frame_id (skip_artificial_frames (this_frame
));
502 return null_frame_id
;
505 const struct frame_id null_frame_id
; /* All zeros. */
506 const struct frame_id outer_frame_id
= { 0, 0, 0, FID_STACK_INVALID
, 0, 1, 0 };
509 frame_id_build_special (CORE_ADDR stack_addr
, CORE_ADDR code_addr
,
510 CORE_ADDR special_addr
)
512 struct frame_id id
= null_frame_id
;
514 id
.stack_addr
= stack_addr
;
515 id
.stack_status
= FID_STACK_VALID
;
516 id
.code_addr
= code_addr
;
518 id
.special_addr
= special_addr
;
519 id
.special_addr_p
= 1;
526 frame_id_build_unavailable_stack (CORE_ADDR code_addr
)
528 struct frame_id id
= null_frame_id
;
530 id
.stack_status
= FID_STACK_UNAVAILABLE
;
531 id
.code_addr
= code_addr
;
539 frame_id_build_unavailable_stack_special (CORE_ADDR code_addr
,
540 CORE_ADDR special_addr
)
542 struct frame_id id
= null_frame_id
;
544 id
.stack_status
= FID_STACK_UNAVAILABLE
;
545 id
.code_addr
= code_addr
;
547 id
.special_addr
= special_addr
;
548 id
.special_addr_p
= 1;
553 frame_id_build (CORE_ADDR stack_addr
, CORE_ADDR code_addr
)
555 struct frame_id id
= null_frame_id
;
557 id
.stack_addr
= stack_addr
;
558 id
.stack_status
= FID_STACK_VALID
;
559 id
.code_addr
= code_addr
;
565 frame_id_build_wild (CORE_ADDR stack_addr
)
567 struct frame_id id
= null_frame_id
;
569 id
.stack_addr
= stack_addr
;
570 id
.stack_status
= FID_STACK_VALID
;
575 frame_id_p (struct frame_id l
)
579 /* The frame is valid iff it has a valid stack address. */
580 p
= l
.stack_status
!= FID_STACK_INVALID
;
581 /* outer_frame_id is also valid. */
582 if (!p
&& memcmp (&l
, &outer_frame_id
, sizeof (l
)) == 0)
586 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_p (l=");
587 fprint_frame_id (gdb_stdlog
, l
);
588 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", p
);
594 frame_id_artificial_p (struct frame_id l
)
599 return (l
.artificial_depth
!= 0);
603 frame_id_eq (struct frame_id l
, struct frame_id r
)
607 if (l
.stack_status
== FID_STACK_INVALID
&& l
.special_addr_p
608 && r
.stack_status
== FID_STACK_INVALID
&& r
.special_addr_p
)
609 /* The outermost frame marker is equal to itself. This is the
610 dodgy thing about outer_frame_id, since between execution steps
611 we might step into another function - from which we can't
612 unwind either. More thought required to get rid of
615 else if (l
.stack_status
== FID_STACK_INVALID
616 || l
.stack_status
== FID_STACK_INVALID
)
617 /* Like a NaN, if either ID is invalid, the result is false.
618 Note that a frame ID is invalid iff it is the null frame ID. */
620 else if (l
.stack_status
!= r
.stack_status
|| l
.stack_addr
!= r
.stack_addr
)
621 /* If .stack addresses are different, the frames are different. */
623 else if (l
.code_addr_p
&& r
.code_addr_p
&& l
.code_addr
!= r
.code_addr
)
624 /* An invalid code addr is a wild card. If .code addresses are
625 different, the frames are different. */
627 else if (l
.special_addr_p
&& r
.special_addr_p
628 && l
.special_addr
!= r
.special_addr
)
629 /* An invalid special addr is a wild card (or unused). Otherwise
630 if special addresses are different, the frames are different. */
632 else if (l
.artificial_depth
!= r
.artificial_depth
)
633 /* If artifical depths are different, the frames must be different. */
636 /* Frames are equal. */
641 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_eq (l=");
642 fprint_frame_id (gdb_stdlog
, l
);
643 fprintf_unfiltered (gdb_stdlog
, ",r=");
644 fprint_frame_id (gdb_stdlog
, r
);
645 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", eq
);
650 /* Safety net to check whether frame ID L should be inner to
651 frame ID R, according to their stack addresses.
653 This method cannot be used to compare arbitrary frames, as the
654 ranges of valid stack addresses may be discontiguous (e.g. due
657 However, it can be used as safety net to discover invalid frame
658 IDs in certain circumstances. Assuming that NEXT is the immediate
659 inner frame to THIS and that NEXT and THIS are both NORMAL frames:
661 * The stack address of NEXT must be inner-than-or-equal to the stack
664 Therefore, if frame_id_inner (THIS, NEXT) holds, some unwind
667 * If NEXT and THIS have different stack addresses, no other frame
668 in the frame chain may have a stack address in between.
670 Therefore, if frame_id_inner (TEST, THIS) holds, but
671 frame_id_inner (TEST, NEXT) does not hold, TEST cannot refer
672 to a valid frame in the frame chain.
674 The sanity checks above cannot be performed when a SIGTRAMP frame
675 is involved, because signal handlers might be executed on a different
676 stack than the stack used by the routine that caused the signal
677 to be raised. This can happen for instance when a thread exceeds
678 its maximum stack size. In this case, certain compilers implement
679 a stack overflow strategy that cause the handler to be run on a
683 frame_id_inner (struct gdbarch
*gdbarch
, struct frame_id l
, struct frame_id r
)
687 if (l
.stack_status
!= FID_STACK_VALID
|| r
.stack_status
!= FID_STACK_VALID
)
688 /* Like NaN, any operation involving an invalid ID always fails.
689 Likewise if either ID has an unavailable stack address. */
691 else if (l
.artificial_depth
> r
.artificial_depth
692 && l
.stack_addr
== r
.stack_addr
693 && l
.code_addr_p
== r
.code_addr_p
694 && l
.special_addr_p
== r
.special_addr_p
695 && l
.special_addr
== r
.special_addr
)
697 /* Same function, different inlined functions. */
698 struct block
*lb
, *rb
;
700 gdb_assert (l
.code_addr_p
&& r
.code_addr_p
);
702 lb
= block_for_pc (l
.code_addr
);
703 rb
= block_for_pc (r
.code_addr
);
705 if (lb
== NULL
|| rb
== NULL
)
706 /* Something's gone wrong. */
709 /* This will return true if LB and RB are the same block, or
710 if the block with the smaller depth lexically encloses the
711 block with the greater depth. */
712 inner
= contained_in (lb
, rb
);
715 /* Only return non-zero when strictly inner than. Note that, per
716 comment in "frame.h", there is some fuzz here. Frameless
717 functions are not strictly inner than (same .stack but
718 different .code and/or .special address). */
719 inner
= gdbarch_inner_than (gdbarch
, l
.stack_addr
, r
.stack_addr
);
722 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_inner (l=");
723 fprint_frame_id (gdb_stdlog
, l
);
724 fprintf_unfiltered (gdb_stdlog
, ",r=");
725 fprint_frame_id (gdb_stdlog
, r
);
726 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", inner
);
732 frame_find_by_id (struct frame_id id
)
734 struct frame_info
*frame
, *prev_frame
;
736 /* ZERO denotes the null frame, let the caller decide what to do
737 about it. Should it instead return get_current_frame()? */
738 if (!frame_id_p (id
))
741 /* Try using the frame stash first. Finding it there removes the need
742 to perform the search by looping over all frames, which can be very
743 CPU-intensive if the number of frames is very high (the loop is O(n)
744 and get_prev_frame performs a series of checks that are relatively
745 expensive). This optimization is particularly useful when this function
746 is called from another function (such as value_fetch_lazy, case
747 VALUE_LVAL (val) == lval_register) which already loops over all frames,
748 making the overall behavior O(n^2). */
749 frame
= frame_stash_find (id
);
753 for (frame
= get_current_frame (); ; frame
= prev_frame
)
755 struct frame_id
this = get_frame_id (frame
);
757 if (frame_id_eq (id
, this))
758 /* An exact match. */
761 prev_frame
= get_prev_frame (frame
);
765 /* As a safety net to avoid unnecessary backtracing while trying
766 to find an invalid ID, we check for a common situation where
767 we can detect from comparing stack addresses that no other
768 frame in the current frame chain can have this ID. See the
769 comment at frame_id_inner for details. */
770 if (get_frame_type (frame
) == NORMAL_FRAME
771 && !frame_id_inner (get_frame_arch (frame
), id
, this)
772 && frame_id_inner (get_frame_arch (prev_frame
), id
,
773 get_frame_id (prev_frame
)))
780 frame_unwind_pc (struct frame_info
*this_frame
)
782 if (this_frame
->prev_pc
.status
== CC_UNKNOWN
)
784 if (gdbarch_unwind_pc_p (frame_unwind_arch (this_frame
)))
786 volatile struct gdb_exception ex
;
787 struct gdbarch
*prev_gdbarch
;
790 /* The right way. The `pure' way. The one true way. This
791 method depends solely on the register-unwind code to
792 determine the value of registers in THIS frame, and hence
793 the value of this frame's PC (resume address). A typical
794 implementation is no more than:
796 frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
797 return extract_unsigned_integer (buf, size of ISA_PC_REGNUM);
799 Note: this method is very heavily dependent on a correct
800 register-unwind implementation, it pays to fix that
801 method first; this method is frame type agnostic, since
802 it only deals with register values, it works with any
803 frame. This is all in stark contrast to the old
804 FRAME_SAVED_PC which would try to directly handle all the
805 different ways that a PC could be unwound. */
806 prev_gdbarch
= frame_unwind_arch (this_frame
);
808 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
810 pc
= gdbarch_unwind_pc (prev_gdbarch
, this_frame
);
814 if (ex
.error
== NOT_AVAILABLE_ERROR
)
816 this_frame
->prev_pc
.status
= CC_UNAVAILABLE
;
819 fprintf_unfiltered (gdb_stdlog
,
820 "{ frame_unwind_pc (this_frame=%d)"
821 " -> <unavailable> }\n",
824 else if (ex
.error
== OPTIMIZED_OUT_ERROR
)
826 this_frame
->prev_pc
.status
= CC_NOT_SAVED
;
829 fprintf_unfiltered (gdb_stdlog
,
830 "{ frame_unwind_pc (this_frame=%d)"
831 " -> <not saved> }\n",
835 throw_exception (ex
);
839 this_frame
->prev_pc
.value
= pc
;
840 this_frame
->prev_pc
.status
= CC_VALUE
;
842 fprintf_unfiltered (gdb_stdlog
,
843 "{ frame_unwind_pc (this_frame=%d) "
846 hex_string (this_frame
->prev_pc
.value
));
850 internal_error (__FILE__
, __LINE__
, _("No unwind_pc method"));
853 if (this_frame
->prev_pc
.status
== CC_VALUE
)
854 return this_frame
->prev_pc
.value
;
855 else if (this_frame
->prev_pc
.status
== CC_UNAVAILABLE
)
856 throw_error (NOT_AVAILABLE_ERROR
, _("PC not available"));
857 else if (this_frame
->prev_pc
.status
== CC_NOT_SAVED
)
858 throw_error (OPTIMIZED_OUT_ERROR
, _("PC not saved"));
860 internal_error (__FILE__
, __LINE__
,
861 "unexpected prev_pc status: %d",
862 (int) this_frame
->prev_pc
.status
);
866 frame_unwind_caller_pc (struct frame_info
*this_frame
)
868 return frame_unwind_pc (skip_artificial_frames (this_frame
));
872 get_frame_func_if_available (struct frame_info
*this_frame
, CORE_ADDR
*pc
)
874 struct frame_info
*next_frame
= this_frame
->next
;
876 if (!next_frame
->prev_func
.p
)
878 CORE_ADDR addr_in_block
;
880 /* Make certain that this, and not the adjacent, function is
882 if (!get_frame_address_in_block_if_available (this_frame
, &addr_in_block
))
884 next_frame
->prev_func
.p
= -1;
886 fprintf_unfiltered (gdb_stdlog
,
887 "{ get_frame_func (this_frame=%d)"
888 " -> unavailable }\n",
893 next_frame
->prev_func
.p
= 1;
894 next_frame
->prev_func
.addr
= get_pc_function_start (addr_in_block
);
896 fprintf_unfiltered (gdb_stdlog
,
897 "{ get_frame_func (this_frame=%d) -> %s }\n",
899 hex_string (next_frame
->prev_func
.addr
));
903 if (next_frame
->prev_func
.p
< 0)
910 *pc
= next_frame
->prev_func
.addr
;
916 get_frame_func (struct frame_info
*this_frame
)
920 if (!get_frame_func_if_available (this_frame
, &pc
))
921 throw_error (NOT_AVAILABLE_ERROR
, _("PC not available"));
926 static enum register_status
927 do_frame_register_read (void *src
, int regnum
, gdb_byte
*buf
)
929 if (!deprecated_frame_register_read (src
, regnum
, buf
))
930 return REG_UNAVAILABLE
;
936 frame_save_as_regcache (struct frame_info
*this_frame
)
938 struct address_space
*aspace
= get_frame_address_space (this_frame
);
939 struct regcache
*regcache
= regcache_xmalloc (get_frame_arch (this_frame
),
941 struct cleanup
*cleanups
= make_cleanup_regcache_xfree (regcache
);
943 regcache_save (regcache
, do_frame_register_read
, this_frame
);
944 discard_cleanups (cleanups
);
949 frame_pop (struct frame_info
*this_frame
)
951 struct frame_info
*prev_frame
;
952 struct regcache
*scratch
;
953 struct cleanup
*cleanups
;
955 if (get_frame_type (this_frame
) == DUMMY_FRAME
)
957 /* Popping a dummy frame involves restoring more than just registers.
958 dummy_frame_pop does all the work. */
959 dummy_frame_pop (get_frame_id (this_frame
));
963 /* Ensure that we have a frame to pop to. */
964 prev_frame
= get_prev_frame_always (this_frame
);
967 error (_("Cannot pop the initial frame."));
969 /* Ignore TAILCALL_FRAME type frames, they were executed already before
970 entering THISFRAME. */
971 while (get_frame_type (prev_frame
) == TAILCALL_FRAME
)
972 prev_frame
= get_prev_frame (prev_frame
);
974 /* Make a copy of all the register values unwound from this frame.
975 Save them in a scratch buffer so that there isn't a race between
976 trying to extract the old values from the current regcache while
977 at the same time writing new values into that same cache. */
978 scratch
= frame_save_as_regcache (prev_frame
);
979 cleanups
= make_cleanup_regcache_xfree (scratch
);
981 /* FIXME: cagney/2003-03-16: It should be possible to tell the
982 target's register cache that it is about to be hit with a burst
983 register transfer and that the sequence of register writes should
984 be batched. The pair target_prepare_to_store() and
985 target_store_registers() kind of suggest this functionality.
986 Unfortunately, they don't implement it. Their lack of a formal
987 definition can lead to targets writing back bogus values
988 (arguably a bug in the target code mind). */
989 /* Now copy those saved registers into the current regcache.
990 Here, regcache_cpy() calls regcache_restore(). */
991 regcache_cpy (get_current_regcache (), scratch
);
992 do_cleanups (cleanups
);
994 /* We've made right mess of GDB's local state, just discard
996 reinit_frame_cache ();
1000 frame_register_unwind (struct frame_info
*frame
, int regnum
,
1001 int *optimizedp
, int *unavailablep
,
1002 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
1003 int *realnump
, gdb_byte
*bufferp
)
1005 struct value
*value
;
1007 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
1008 that the value proper does not need to be fetched. */
1009 gdb_assert (optimizedp
!= NULL
);
1010 gdb_assert (lvalp
!= NULL
);
1011 gdb_assert (addrp
!= NULL
);
1012 gdb_assert (realnump
!= NULL
);
1013 /* gdb_assert (bufferp != NULL); */
1015 value
= frame_unwind_register_value (frame
, regnum
);
1017 gdb_assert (value
!= NULL
);
1019 *optimizedp
= value_optimized_out (value
);
1020 *unavailablep
= !value_entirely_available (value
);
1021 *lvalp
= VALUE_LVAL (value
);
1022 *addrp
= value_address (value
);
1023 *realnump
= VALUE_REGNUM (value
);
1027 if (!*optimizedp
&& !*unavailablep
)
1028 memcpy (bufferp
, value_contents_all (value
),
1029 TYPE_LENGTH (value_type (value
)));
1031 memset (bufferp
, 0, TYPE_LENGTH (value_type (value
)));
1034 /* Dispose of the new value. This prevents watchpoints from
1035 trying to watch the saved frame pointer. */
1036 release_value (value
);
1041 frame_register (struct frame_info
*frame
, int regnum
,
1042 int *optimizedp
, int *unavailablep
, enum lval_type
*lvalp
,
1043 CORE_ADDR
*addrp
, int *realnump
, gdb_byte
*bufferp
)
1045 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
1046 that the value proper does not need to be fetched. */
1047 gdb_assert (optimizedp
!= NULL
);
1048 gdb_assert (lvalp
!= NULL
);
1049 gdb_assert (addrp
!= NULL
);
1050 gdb_assert (realnump
!= NULL
);
1051 /* gdb_assert (bufferp != NULL); */
1053 /* Obtain the register value by unwinding the register from the next
1054 (more inner frame). */
1055 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
1056 frame_register_unwind (frame
->next
, regnum
, optimizedp
, unavailablep
,
1057 lvalp
, addrp
, realnump
, bufferp
);
1061 frame_unwind_register (struct frame_info
*frame
, int regnum
, gdb_byte
*buf
)
1067 enum lval_type lval
;
1069 frame_register_unwind (frame
, regnum
, &optimized
, &unavailable
,
1070 &lval
, &addr
, &realnum
, buf
);
1073 throw_error (OPTIMIZED_OUT_ERROR
,
1074 _("Register %d was not saved"), regnum
);
1076 throw_error (NOT_AVAILABLE_ERROR
,
1077 _("Register %d is not available"), regnum
);
1081 get_frame_register (struct frame_info
*frame
,
1082 int regnum
, gdb_byte
*buf
)
1084 frame_unwind_register (frame
->next
, regnum
, buf
);
1088 frame_unwind_register_value (struct frame_info
*frame
, int regnum
)
1090 struct gdbarch
*gdbarch
;
1091 struct value
*value
;
1093 gdb_assert (frame
!= NULL
);
1094 gdbarch
= frame_unwind_arch (frame
);
1098 fprintf_unfiltered (gdb_stdlog
,
1099 "{ frame_unwind_register_value "
1100 "(frame=%d,regnum=%d(%s),...) ",
1101 frame
->level
, regnum
,
1102 user_reg_map_regnum_to_name (gdbarch
, regnum
));
1105 /* Find the unwinder. */
1106 if (frame
->unwind
== NULL
)
1107 frame_unwind_find_by_frame (frame
, &frame
->prologue_cache
);
1109 /* Ask this frame to unwind its register. */
1110 value
= frame
->unwind
->prev_register (frame
, &frame
->prologue_cache
, regnum
);
1114 fprintf_unfiltered (gdb_stdlog
, "->");
1115 if (value_optimized_out (value
))
1117 fprintf_unfiltered (gdb_stdlog
, " ");
1118 val_print_optimized_out (value
, gdb_stdlog
);
1122 if (VALUE_LVAL (value
) == lval_register
)
1123 fprintf_unfiltered (gdb_stdlog
, " register=%d",
1124 VALUE_REGNUM (value
));
1125 else if (VALUE_LVAL (value
) == lval_memory
)
1126 fprintf_unfiltered (gdb_stdlog
, " address=%s",
1128 value_address (value
)));
1130 fprintf_unfiltered (gdb_stdlog
, " computed");
1132 if (value_lazy (value
))
1133 fprintf_unfiltered (gdb_stdlog
, " lazy");
1137 const gdb_byte
*buf
= value_contents (value
);
1139 fprintf_unfiltered (gdb_stdlog
, " bytes=");
1140 fprintf_unfiltered (gdb_stdlog
, "[");
1141 for (i
= 0; i
< register_size (gdbarch
, regnum
); i
++)
1142 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1143 fprintf_unfiltered (gdb_stdlog
, "]");
1147 fprintf_unfiltered (gdb_stdlog
, " }\n");
1154 get_frame_register_value (struct frame_info
*frame
, int regnum
)
1156 return frame_unwind_register_value (frame
->next
, regnum
);
1160 frame_unwind_register_signed (struct frame_info
*frame
, int regnum
)
1162 struct gdbarch
*gdbarch
= frame_unwind_arch (frame
);
1163 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1164 int size
= register_size (gdbarch
, regnum
);
1165 gdb_byte buf
[MAX_REGISTER_SIZE
];
1167 frame_unwind_register (frame
, regnum
, buf
);
1168 return extract_signed_integer (buf
, size
, byte_order
);
1172 get_frame_register_signed (struct frame_info
*frame
, int regnum
)
1174 return frame_unwind_register_signed (frame
->next
, regnum
);
1178 frame_unwind_register_unsigned (struct frame_info
*frame
, int regnum
)
1180 struct gdbarch
*gdbarch
= frame_unwind_arch (frame
);
1181 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1182 int size
= register_size (gdbarch
, regnum
);
1183 gdb_byte buf
[MAX_REGISTER_SIZE
];
1185 frame_unwind_register (frame
, regnum
, buf
);
1186 return extract_unsigned_integer (buf
, size
, byte_order
);
1190 get_frame_register_unsigned (struct frame_info
*frame
, int regnum
)
1192 return frame_unwind_register_unsigned (frame
->next
, regnum
);
1196 read_frame_register_unsigned (struct frame_info
*frame
, int regnum
,
1199 struct value
*regval
= get_frame_register_value (frame
, regnum
);
1201 if (!value_optimized_out (regval
)
1202 && value_entirely_available (regval
))
1204 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1205 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1206 int size
= register_size (gdbarch
, VALUE_REGNUM (regval
));
1208 *val
= extract_unsigned_integer (value_contents (regval
), size
, byte_order
);
1216 put_frame_register (struct frame_info
*frame
, int regnum
,
1217 const gdb_byte
*buf
)
1219 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1223 enum lval_type lval
;
1226 frame_register (frame
, regnum
, &optim
, &unavail
,
1227 &lval
, &addr
, &realnum
, NULL
);
1229 error (_("Attempt to assign to a register that was not saved."));
1234 write_memory (addr
, buf
, register_size (gdbarch
, regnum
));
1238 regcache_cooked_write (get_current_regcache (), realnum
, buf
);
1241 error (_("Attempt to assign to an unmodifiable value."));
1245 /* This function is deprecated. Use get_frame_register_value instead,
1246 which provides more accurate information.
1248 Find and return the value of REGNUM for the specified stack frame.
1249 The number of bytes copied is REGISTER_SIZE (REGNUM).
1251 Returns 0 if the register value could not be found. */
1254 deprecated_frame_register_read (struct frame_info
*frame
, int regnum
,
1259 enum lval_type lval
;
1263 frame_register (frame
, regnum
, &optimized
, &unavailable
,
1264 &lval
, &addr
, &realnum
, myaddr
);
1266 return !optimized
&& !unavailable
;
1270 get_frame_register_bytes (struct frame_info
*frame
, int regnum
,
1271 CORE_ADDR offset
, int len
, gdb_byte
*myaddr
,
1272 int *optimizedp
, int *unavailablep
)
1274 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1279 /* Skip registers wholly inside of OFFSET. */
1280 while (offset
>= register_size (gdbarch
, regnum
))
1282 offset
-= register_size (gdbarch
, regnum
);
1286 /* Ensure that we will not read beyond the end of the register file.
1287 This can only ever happen if the debug information is bad. */
1289 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1290 for (i
= regnum
; i
< numregs
; i
++)
1292 int thissize
= register_size (gdbarch
, i
);
1295 break; /* This register is not available on this architecture. */
1296 maxsize
+= thissize
;
1299 error (_("Bad debug information detected: "
1300 "Attempt to read %d bytes from registers."), len
);
1302 /* Copy the data. */
1305 int curr_len
= register_size (gdbarch
, regnum
) - offset
;
1310 if (curr_len
== register_size (gdbarch
, regnum
))
1312 enum lval_type lval
;
1316 frame_register (frame
, regnum
, optimizedp
, unavailablep
,
1317 &lval
, &addr
, &realnum
, myaddr
);
1318 if (*optimizedp
|| *unavailablep
)
1323 gdb_byte buf
[MAX_REGISTER_SIZE
];
1324 enum lval_type lval
;
1328 frame_register (frame
, regnum
, optimizedp
, unavailablep
,
1329 &lval
, &addr
, &realnum
, buf
);
1330 if (*optimizedp
|| *unavailablep
)
1332 memcpy (myaddr
, buf
+ offset
, curr_len
);
1347 put_frame_register_bytes (struct frame_info
*frame
, int regnum
,
1348 CORE_ADDR offset
, int len
, const gdb_byte
*myaddr
)
1350 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1352 /* Skip registers wholly inside of OFFSET. */
1353 while (offset
>= register_size (gdbarch
, regnum
))
1355 offset
-= register_size (gdbarch
, regnum
);
1359 /* Copy the data. */
1362 int curr_len
= register_size (gdbarch
, regnum
) - offset
;
1367 if (curr_len
== register_size (gdbarch
, regnum
))
1369 put_frame_register (frame
, regnum
, myaddr
);
1373 gdb_byte buf
[MAX_REGISTER_SIZE
];
1375 deprecated_frame_register_read (frame
, regnum
, buf
);
1376 memcpy (buf
+ offset
, myaddr
, curr_len
);
1377 put_frame_register (frame
, regnum
, buf
);
1387 /* Create a sentinel frame. */
1389 static struct frame_info
*
1390 create_sentinel_frame (struct program_space
*pspace
, struct regcache
*regcache
)
1392 struct frame_info
*frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1395 frame
->pspace
= pspace
;
1396 frame
->aspace
= get_regcache_aspace (regcache
);
1397 /* Explicitly initialize the sentinel frame's cache. Provide it
1398 with the underlying regcache. In the future additional
1399 information, such as the frame's thread will be added. */
1400 frame
->prologue_cache
= sentinel_frame_cache (regcache
);
1401 /* For the moment there is only one sentinel frame implementation. */
1402 frame
->unwind
= &sentinel_frame_unwind
;
1403 /* Link this frame back to itself. The frame is self referential
1404 (the unwound PC is the same as the pc), so make it so. */
1405 frame
->next
= frame
;
1406 /* Make the sentinel frame's ID valid, but invalid. That way all
1407 comparisons with it should fail. */
1408 frame
->this_id
.p
= 1;
1409 frame
->this_id
.value
= null_frame_id
;
1412 fprintf_unfiltered (gdb_stdlog
, "{ create_sentinel_frame (...) -> ");
1413 fprint_frame (gdb_stdlog
, frame
);
1414 fprintf_unfiltered (gdb_stdlog
, " }\n");
1419 /* Info about the innermost stack frame (contents of FP register). */
1421 static struct frame_info
*current_frame
;
1423 /* Cache for frame addresses already read by gdb. Valid only while
1424 inferior is stopped. Control variables for the frame cache should
1425 be local to this module. */
1427 static struct obstack frame_cache_obstack
;
1430 frame_obstack_zalloc (unsigned long size
)
1432 void *data
= obstack_alloc (&frame_cache_obstack
, size
);
1434 memset (data
, 0, size
);
1438 /* Return the innermost (currently executing) stack frame. This is
1439 split into two functions. The function unwind_to_current_frame()
1440 is wrapped in catch exceptions so that, even when the unwind of the
1441 sentinel frame fails, the function still returns a stack frame. */
1444 unwind_to_current_frame (struct ui_out
*ui_out
, void *args
)
1446 struct frame_info
*frame
= get_prev_frame (args
);
1448 /* A sentinel frame can fail to unwind, e.g., because its PC value
1449 lands in somewhere like start. */
1452 current_frame
= frame
;
1457 get_current_frame (void)
1459 /* First check, and report, the lack of registers. Having GDB
1460 report "No stack!" or "No memory" when the target doesn't even
1461 have registers is very confusing. Besides, "printcmd.exp"
1462 explicitly checks that ``print $pc'' with no registers prints "No
1464 if (!target_has_registers
)
1465 error (_("No registers."));
1466 if (!target_has_stack
)
1467 error (_("No stack."));
1468 if (!target_has_memory
)
1469 error (_("No memory."));
1470 /* Traceframes are effectively a substitute for the live inferior. */
1471 if (get_traceframe_number () < 0)
1473 if (ptid_equal (inferior_ptid
, null_ptid
))
1474 error (_("No selected thread."));
1475 if (is_exited (inferior_ptid
))
1476 error (_("Invalid selected thread."));
1477 if (is_executing (inferior_ptid
))
1478 error (_("Target is executing."));
1481 if (current_frame
== NULL
)
1483 struct frame_info
*sentinel_frame
=
1484 create_sentinel_frame (current_program_space
, get_current_regcache ());
1485 if (catch_exceptions (current_uiout
, unwind_to_current_frame
,
1486 sentinel_frame
, RETURN_MASK_ERROR
) != 0)
1488 /* Oops! Fake a current frame? Is this useful? It has a PC
1489 of zero, for instance. */
1490 current_frame
= sentinel_frame
;
1493 return current_frame
;
1496 /* The "selected" stack frame is used by default for local and arg
1497 access. May be zero, for no selected frame. */
1499 static struct frame_info
*selected_frame
;
1502 has_stack_frames (void)
1504 if (!target_has_registers
|| !target_has_stack
|| !target_has_memory
)
1507 /* Traceframes are effectively a substitute for the live inferior. */
1508 if (get_traceframe_number () < 0)
1510 /* No current inferior, no frame. */
1511 if (ptid_equal (inferior_ptid
, null_ptid
))
1514 /* Don't try to read from a dead thread. */
1515 if (is_exited (inferior_ptid
))
1518 /* ... or from a spinning thread. */
1519 if (is_executing (inferior_ptid
))
1526 /* Return the selected frame. Always non-NULL (unless there isn't an
1527 inferior sufficient for creating a frame) in which case an error is
1531 get_selected_frame (const char *message
)
1533 if (selected_frame
== NULL
)
1535 if (message
!= NULL
&& !has_stack_frames ())
1536 error (("%s"), message
);
1537 /* Hey! Don't trust this. It should really be re-finding the
1538 last selected frame of the currently selected thread. This,
1539 though, is better than nothing. */
1540 select_frame (get_current_frame ());
1542 /* There is always a frame. */
1543 gdb_assert (selected_frame
!= NULL
);
1544 return selected_frame
;
1547 /* If there is a selected frame, return it. Otherwise, return NULL. */
1550 get_selected_frame_if_set (void)
1552 return selected_frame
;
1555 /* This is a variant of get_selected_frame() which can be called when
1556 the inferior does not have a frame; in that case it will return
1557 NULL instead of calling error(). */
1560 deprecated_safe_get_selected_frame (void)
1562 if (!has_stack_frames ())
1564 return get_selected_frame (NULL
);
1567 /* Select frame FI (or NULL - to invalidate the current frame). */
1570 select_frame (struct frame_info
*fi
)
1572 selected_frame
= fi
;
1573 /* NOTE: cagney/2002-05-04: FI can be NULL. This occurs when the
1574 frame is being invalidated. */
1575 if (deprecated_selected_frame_level_changed_hook
)
1576 deprecated_selected_frame_level_changed_hook (frame_relative_level (fi
));
1578 /* FIXME: kseitz/2002-08-28: It would be nice to call
1579 selected_frame_level_changed_event() right here, but due to limitations
1580 in the current interfaces, we would end up flooding UIs with events
1581 because select_frame() is used extensively internally.
1583 Once we have frame-parameterized frame (and frame-related) commands,
1584 the event notification can be moved here, since this function will only
1585 be called when the user's selected frame is being changed. */
1587 /* Ensure that symbols for this frame are read in. Also, determine the
1588 source language of this frame, and switch to it if desired. */
1593 /* We retrieve the frame's symtab by using the frame PC.
1594 However we cannot use the frame PC as-is, because it usually
1595 points to the instruction following the "call", which is
1596 sometimes the first instruction of another function. So we
1597 rely on get_frame_address_in_block() which provides us with a
1598 PC which is guaranteed to be inside the frame's code
1600 if (get_frame_address_in_block_if_available (fi
, &pc
))
1602 struct symtab
*s
= find_pc_symtab (pc
);
1605 && s
->language
!= current_language
->la_language
1606 && s
->language
!= language_unknown
1607 && language_mode
== language_mode_auto
)
1608 set_language (s
->language
);
1613 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
1614 Always returns a non-NULL value. */
1617 create_new_frame (CORE_ADDR addr
, CORE_ADDR pc
)
1619 struct frame_info
*fi
;
1623 fprintf_unfiltered (gdb_stdlog
,
1624 "{ create_new_frame (addr=%s, pc=%s) ",
1625 hex_string (addr
), hex_string (pc
));
1628 fi
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1630 fi
->next
= create_sentinel_frame (current_program_space
,
1631 get_current_regcache ());
1633 /* Set/update this frame's cached PC value, found in the next frame.
1634 Do this before looking for this frame's unwinder. A sniffer is
1635 very likely to read this, and the corresponding unwinder is
1636 entitled to rely that the PC doesn't magically change. */
1637 fi
->next
->prev_pc
.value
= pc
;
1638 fi
->next
->prev_pc
.status
= CC_VALUE
;
1640 /* We currently assume that frame chain's can't cross spaces. */
1641 fi
->pspace
= fi
->next
->pspace
;
1642 fi
->aspace
= fi
->next
->aspace
;
1644 /* Select/initialize both the unwind function and the frame's type
1646 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
1649 fi
->this_id
.value
= frame_id_build (addr
, pc
);
1653 fprintf_unfiltered (gdb_stdlog
, "-> ");
1654 fprint_frame (gdb_stdlog
, fi
);
1655 fprintf_unfiltered (gdb_stdlog
, " }\n");
1661 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
1662 innermost frame). Be careful to not fall off the bottom of the
1663 frame chain and onto the sentinel frame. */
1666 get_next_frame (struct frame_info
*this_frame
)
1668 if (this_frame
->level
> 0)
1669 return this_frame
->next
;
1674 /* Observer for the target_changed event. */
1677 frame_observer_target_changed (struct target_ops
*target
)
1679 reinit_frame_cache ();
1682 /* Flush the entire frame cache. */
1685 reinit_frame_cache (void)
1687 struct frame_info
*fi
;
1689 /* Tear down all frame caches. */
1690 for (fi
= current_frame
; fi
!= NULL
; fi
= fi
->prev
)
1692 if (fi
->prologue_cache
&& fi
->unwind
->dealloc_cache
)
1693 fi
->unwind
->dealloc_cache (fi
, fi
->prologue_cache
);
1694 if (fi
->base_cache
&& fi
->base
->unwind
->dealloc_cache
)
1695 fi
->base
->unwind
->dealloc_cache (fi
, fi
->base_cache
);
1698 /* Since we can't really be sure what the first object allocated was. */
1699 obstack_free (&frame_cache_obstack
, 0);
1700 obstack_init (&frame_cache_obstack
);
1702 if (current_frame
!= NULL
)
1703 annotate_frames_invalid ();
1705 current_frame
= NULL
; /* Invalidate cache */
1706 select_frame (NULL
);
1707 frame_stash_invalidate ();
1709 fprintf_unfiltered (gdb_stdlog
, "{ reinit_frame_cache () }\n");
1712 /* Find where a register is saved (in memory or another register).
1713 The result of frame_register_unwind is just where it is saved
1714 relative to this particular frame. */
1717 frame_register_unwind_location (struct frame_info
*this_frame
, int regnum
,
1718 int *optimizedp
, enum lval_type
*lvalp
,
1719 CORE_ADDR
*addrp
, int *realnump
)
1721 gdb_assert (this_frame
== NULL
|| this_frame
->level
>= 0);
1723 while (this_frame
!= NULL
)
1727 frame_register_unwind (this_frame
, regnum
, optimizedp
, &unavailable
,
1728 lvalp
, addrp
, realnump
, NULL
);
1733 if (*lvalp
!= lval_register
)
1737 this_frame
= get_next_frame (this_frame
);
1741 /* Called during frame unwinding to remove a previous frame pointer from a
1742 frame passed in ARG. */
1745 remove_prev_frame (void *arg
)
1747 struct frame_info
*this_frame
, *prev_frame
;
1749 this_frame
= (struct frame_info
*) arg
;
1750 prev_frame
= this_frame
->prev
;
1751 gdb_assert (prev_frame
!= NULL
);
1753 prev_frame
->next
= NULL
;
1754 this_frame
->prev
= NULL
;
1757 /* Get the previous raw frame, and check that it is not identical to
1758 same other frame frame already in the chain. If it is, there is
1759 most likely a stack cycle, so we discard it, and mark THIS_FRAME as
1760 outermost, with UNWIND_SAME_ID stop reason. Unlike the other
1761 validity tests, that compare THIS_FRAME and the next frame, we do
1762 this right after creating the previous frame, to avoid ever ending
1763 up with two frames with the same id in the frame chain. */
1765 static struct frame_info
*
1766 get_prev_frame_if_no_cycle (struct frame_info
*this_frame
)
1768 struct frame_info
*prev_frame
;
1769 struct cleanup
*prev_frame_cleanup
;
1771 prev_frame
= get_prev_frame_raw (this_frame
);
1772 if (prev_frame
== NULL
)
1775 /* The cleanup will remove the previous frame that get_prev_frame_raw
1776 linked onto THIS_FRAME. */
1777 prev_frame_cleanup
= make_cleanup (remove_prev_frame
, this_frame
);
1779 compute_frame_id (prev_frame
);
1780 if (!frame_stash_add (prev_frame
))
1782 /* Another frame with the same id was already in the stash. We just
1783 detected a cycle. */
1786 fprintf_unfiltered (gdb_stdlog
, "-> ");
1787 fprint_frame (gdb_stdlog
, NULL
);
1788 fprintf_unfiltered (gdb_stdlog
, " // this frame has same ID }\n");
1790 this_frame
->stop_reason
= UNWIND_SAME_ID
;
1792 prev_frame
->next
= NULL
;
1793 this_frame
->prev
= NULL
;
1797 discard_cleanups (prev_frame_cleanup
);
1801 /* Return a "struct frame_info" corresponding to the frame that called
1802 THIS_FRAME. Returns NULL if there is no such frame.
1804 Unlike get_prev_frame, this function always tries to unwind the
1808 get_prev_frame_always (struct frame_info
*this_frame
)
1810 struct gdbarch
*gdbarch
;
1812 gdb_assert (this_frame
!= NULL
);
1813 gdbarch
= get_frame_arch (this_frame
);
1817 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame_always (this_frame=");
1818 if (this_frame
!= NULL
)
1819 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1821 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1822 fprintf_unfiltered (gdb_stdlog
, ") ");
1825 /* Only try to do the unwind once. */
1826 if (this_frame
->prev_p
)
1830 fprintf_unfiltered (gdb_stdlog
, "-> ");
1831 fprint_frame (gdb_stdlog
, this_frame
->prev
);
1832 fprintf_unfiltered (gdb_stdlog
, " // cached \n");
1834 return this_frame
->prev
;
1837 /* If the frame unwinder hasn't been selected yet, we must do so
1838 before setting prev_p; otherwise the check for misbehaved
1839 sniffers will think that this frame's sniffer tried to unwind
1840 further (see frame_cleanup_after_sniffer). */
1841 if (this_frame
->unwind
== NULL
)
1842 frame_unwind_find_by_frame (this_frame
, &this_frame
->prologue_cache
);
1844 this_frame
->prev_p
= 1;
1845 this_frame
->stop_reason
= UNWIND_NO_REASON
;
1847 /* If we are unwinding from an inline frame, all of the below tests
1848 were already performed when we unwound from the next non-inline
1849 frame. We must skip them, since we can not get THIS_FRAME's ID
1850 until we have unwound all the way down to the previous non-inline
1852 if (get_frame_type (this_frame
) == INLINE_FRAME
)
1853 return get_prev_frame_if_no_cycle (this_frame
);
1855 /* Check that this frame is unwindable. If it isn't, don't try to
1856 unwind to the prev frame. */
1857 this_frame
->stop_reason
1858 = this_frame
->unwind
->stop_reason (this_frame
,
1859 &this_frame
->prologue_cache
);
1861 if (this_frame
->stop_reason
!= UNWIND_NO_REASON
)
1865 enum unwind_stop_reason reason
= this_frame
->stop_reason
;
1867 fprintf_unfiltered (gdb_stdlog
, "-> ");
1868 fprint_frame (gdb_stdlog
, NULL
);
1869 fprintf_unfiltered (gdb_stdlog
, " // %s }\n",
1870 frame_stop_reason_symbol_string (reason
));
1875 /* Check that this frame's ID isn't inner to (younger, below, next)
1876 the next frame. This happens when a frame unwind goes backwards.
1877 This check is valid only if this frame and the next frame are NORMAL.
1878 See the comment at frame_id_inner for details. */
1879 if (get_frame_type (this_frame
) == NORMAL_FRAME
1880 && this_frame
->next
->unwind
->type
== NORMAL_FRAME
1881 && frame_id_inner (get_frame_arch (this_frame
->next
),
1882 get_frame_id (this_frame
),
1883 get_frame_id (this_frame
->next
)))
1885 CORE_ADDR this_pc_in_block
;
1886 struct minimal_symbol
*morestack_msym
;
1887 const char *morestack_name
= NULL
;
1889 /* gcc -fsplit-stack __morestack can continue the stack anywhere. */
1890 this_pc_in_block
= get_frame_address_in_block (this_frame
);
1891 morestack_msym
= lookup_minimal_symbol_by_pc (this_pc_in_block
).minsym
;
1893 morestack_name
= MSYMBOL_LINKAGE_NAME (morestack_msym
);
1894 if (!morestack_name
|| strcmp (morestack_name
, "__morestack") != 0)
1898 fprintf_unfiltered (gdb_stdlog
, "-> ");
1899 fprint_frame (gdb_stdlog
, NULL
);
1900 fprintf_unfiltered (gdb_stdlog
,
1901 " // this frame ID is inner }\n");
1903 this_frame
->stop_reason
= UNWIND_INNER_ID
;
1908 /* Check that this and the next frame do not unwind the PC register
1909 to the same memory location. If they do, then even though they
1910 have different frame IDs, the new frame will be bogus; two
1911 functions can't share a register save slot for the PC. This can
1912 happen when the prologue analyzer finds a stack adjustment, but
1915 This check does assume that the "PC register" is roughly a
1916 traditional PC, even if the gdbarch_unwind_pc method adjusts
1917 it (we do not rely on the value, only on the unwound PC being
1918 dependent on this value). A potential improvement would be
1919 to have the frame prev_pc method and the gdbarch unwind_pc
1920 method set the same lval and location information as
1921 frame_register_unwind. */
1922 if (this_frame
->level
> 0
1923 && gdbarch_pc_regnum (gdbarch
) >= 0
1924 && get_frame_type (this_frame
) == NORMAL_FRAME
1925 && (get_frame_type (this_frame
->next
) == NORMAL_FRAME
1926 || get_frame_type (this_frame
->next
) == INLINE_FRAME
))
1928 int optimized
, realnum
, nrealnum
;
1929 enum lval_type lval
, nlval
;
1930 CORE_ADDR addr
, naddr
;
1932 frame_register_unwind_location (this_frame
,
1933 gdbarch_pc_regnum (gdbarch
),
1934 &optimized
, &lval
, &addr
, &realnum
);
1935 frame_register_unwind_location (get_next_frame (this_frame
),
1936 gdbarch_pc_regnum (gdbarch
),
1937 &optimized
, &nlval
, &naddr
, &nrealnum
);
1939 if ((lval
== lval_memory
&& lval
== nlval
&& addr
== naddr
)
1940 || (lval
== lval_register
&& lval
== nlval
&& realnum
== nrealnum
))
1944 fprintf_unfiltered (gdb_stdlog
, "-> ");
1945 fprint_frame (gdb_stdlog
, NULL
);
1946 fprintf_unfiltered (gdb_stdlog
, " // no saved PC }\n");
1949 this_frame
->stop_reason
= UNWIND_NO_SAVED_PC
;
1950 this_frame
->prev
= NULL
;
1955 return get_prev_frame_if_no_cycle (this_frame
);
1958 /* Construct a new "struct frame_info" and link it previous to
1961 static struct frame_info
*
1962 get_prev_frame_raw (struct frame_info
*this_frame
)
1964 struct frame_info
*prev_frame
;
1966 /* Allocate the new frame but do not wire it in to the frame chain.
1967 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
1968 frame->next to pull some fancy tricks (of course such code is, by
1969 definition, recursive). Try to prevent it.
1971 There is no reason to worry about memory leaks, should the
1972 remainder of the function fail. The allocated memory will be
1973 quickly reclaimed when the frame cache is flushed, and the `we've
1974 been here before' check above will stop repeated memory
1975 allocation calls. */
1976 prev_frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1977 prev_frame
->level
= this_frame
->level
+ 1;
1979 /* For now, assume we don't have frame chains crossing address
1981 prev_frame
->pspace
= this_frame
->pspace
;
1982 prev_frame
->aspace
= this_frame
->aspace
;
1984 /* Don't yet compute ->unwind (and hence ->type). It is computed
1985 on-demand in get_frame_type, frame_register_unwind, and
1988 /* Don't yet compute the frame's ID. It is computed on-demand by
1991 /* The unwound frame ID is validate at the start of this function,
1992 as part of the logic to decide if that frame should be further
1993 unwound, and not here while the prev frame is being created.
1994 Doing this makes it possible for the user to examine a frame that
1995 has an invalid frame ID.
1997 Some very old VAX code noted: [...] For the sake of argument,
1998 suppose that the stack is somewhat trashed (which is one reason
1999 that "info frame" exists). So, return 0 (indicating we don't
2000 know the address of the arglist) if we don't know what frame this
2004 this_frame
->prev
= prev_frame
;
2005 prev_frame
->next
= this_frame
;
2009 fprintf_unfiltered (gdb_stdlog
, "-> ");
2010 fprint_frame (gdb_stdlog
, prev_frame
);
2011 fprintf_unfiltered (gdb_stdlog
, " }\n");
2017 /* Debug routine to print a NULL frame being returned. */
2020 frame_debug_got_null_frame (struct frame_info
*this_frame
,
2025 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame (this_frame=");
2026 if (this_frame
!= NULL
)
2027 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
2029 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
2030 fprintf_unfiltered (gdb_stdlog
, ") -> // %s}\n", reason
);
2034 /* Is this (non-sentinel) frame in the "main"() function? */
2037 inside_main_func (struct frame_info
*this_frame
)
2039 struct bound_minimal_symbol msymbol
;
2042 if (symfile_objfile
== 0)
2044 msymbol
= lookup_minimal_symbol (main_name (), NULL
, symfile_objfile
);
2045 if (msymbol
.minsym
== NULL
)
2047 /* Make certain that the code, and not descriptor, address is
2049 maddr
= gdbarch_convert_from_func_ptr_addr (get_frame_arch (this_frame
),
2050 BMSYMBOL_VALUE_ADDRESS (msymbol
),
2052 return maddr
== get_frame_func (this_frame
);
2055 /* Test whether THIS_FRAME is inside the process entry point function. */
2058 inside_entry_func (struct frame_info
*this_frame
)
2060 CORE_ADDR entry_point
;
2062 if (!entry_point_address_query (&entry_point
))
2065 return get_frame_func (this_frame
) == entry_point
;
2068 /* Return a structure containing various interesting information about
2069 the frame that called THIS_FRAME. Returns NULL if there is entier
2070 no such frame or the frame fails any of a set of target-independent
2071 condition that should terminate the frame chain (e.g., as unwinding
2074 This function should not contain target-dependent tests, such as
2075 checking whether the program-counter is zero. */
2078 get_prev_frame (struct frame_info
*this_frame
)
2083 /* There is always a frame. If this assertion fails, suspect that
2084 something should be calling get_selected_frame() or
2085 get_current_frame(). */
2086 gdb_assert (this_frame
!= NULL
);
2087 frame_pc_p
= get_frame_pc_if_available (this_frame
, &frame_pc
);
2089 /* tausq/2004-12-07: Dummy frames are skipped because it doesn't make much
2090 sense to stop unwinding at a dummy frame. One place where a dummy
2091 frame may have an address "inside_main_func" is on HPUX. On HPUX, the
2092 pcsqh register (space register for the instruction at the head of the
2093 instruction queue) cannot be written directly; the only way to set it
2094 is to branch to code that is in the target space. In order to implement
2095 frame dummies on HPUX, the called function is made to jump back to where
2096 the inferior was when the user function was called. If gdb was inside
2097 the main function when we created the dummy frame, the dummy frame will
2098 point inside the main function. */
2099 if (this_frame
->level
>= 0
2100 && get_frame_type (this_frame
) == NORMAL_FRAME
2101 && !backtrace_past_main
2103 && inside_main_func (this_frame
))
2104 /* Don't unwind past main(). Note, this is done _before_ the
2105 frame has been marked as previously unwound. That way if the
2106 user later decides to enable unwinds past main(), that will
2107 automatically happen. */
2109 frame_debug_got_null_frame (this_frame
, "inside main func");
2113 /* If the user's backtrace limit has been exceeded, stop. We must
2114 add two to the current level; one of those accounts for backtrace_limit
2115 being 1-based and the level being 0-based, and the other accounts for
2116 the level of the new frame instead of the level of the current
2118 if (this_frame
->level
+ 2 > backtrace_limit
)
2120 frame_debug_got_null_frame (this_frame
, "backtrace limit exceeded");
2124 /* If we're already inside the entry function for the main objfile,
2125 then it isn't valid. Don't apply this test to a dummy frame -
2126 dummy frame PCs typically land in the entry func. Don't apply
2127 this test to the sentinel frame. Sentinel frames should always
2128 be allowed to unwind. */
2129 /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() -
2130 wasn't checking for "main" in the minimal symbols. With that
2131 fixed asm-source tests now stop in "main" instead of halting the
2132 backtrace in weird and wonderful ways somewhere inside the entry
2133 file. Suspect that tests for inside the entry file/func were
2134 added to work around that (now fixed) case. */
2135 /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
2136 suggested having the inside_entry_func test use the
2137 inside_main_func() msymbol trick (along with entry_point_address()
2138 I guess) to determine the address range of the start function.
2139 That should provide a far better stopper than the current
2141 /* NOTE: tausq/2004-10-09: this is needed if, for example, the compiler
2142 applied tail-call optimizations to main so that a function called
2143 from main returns directly to the caller of main. Since we don't
2144 stop at main, we should at least stop at the entry point of the
2146 if (this_frame
->level
>= 0
2147 && get_frame_type (this_frame
) == NORMAL_FRAME
2148 && !backtrace_past_entry
2150 && inside_entry_func (this_frame
))
2152 frame_debug_got_null_frame (this_frame
, "inside entry func");
2156 /* Assume that the only way to get a zero PC is through something
2157 like a SIGSEGV or a dummy frame, and hence that NORMAL frames
2158 will never unwind a zero PC. */
2159 if (this_frame
->level
> 0
2160 && (get_frame_type (this_frame
) == NORMAL_FRAME
2161 || get_frame_type (this_frame
) == INLINE_FRAME
)
2162 && get_frame_type (get_next_frame (this_frame
)) == NORMAL_FRAME
2163 && frame_pc_p
&& frame_pc
== 0)
2165 frame_debug_got_null_frame (this_frame
, "zero PC");
2169 return get_prev_frame_always (this_frame
);
2173 get_frame_pc (struct frame_info
*frame
)
2175 gdb_assert (frame
->next
!= NULL
);
2176 return frame_unwind_pc (frame
->next
);
2180 get_frame_pc_if_available (struct frame_info
*frame
, CORE_ADDR
*pc
)
2182 volatile struct gdb_exception ex
;
2184 gdb_assert (frame
->next
!= NULL
);
2186 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2188 *pc
= frame_unwind_pc (frame
->next
);
2192 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2195 throw_exception (ex
);
2201 /* Return an address that falls within THIS_FRAME's code block. */
2204 get_frame_address_in_block (struct frame_info
*this_frame
)
2206 /* A draft address. */
2207 CORE_ADDR pc
= get_frame_pc (this_frame
);
2209 struct frame_info
*next_frame
= this_frame
->next
;
2211 /* Calling get_frame_pc returns the resume address for THIS_FRAME.
2212 Normally the resume address is inside the body of the function
2213 associated with THIS_FRAME, but there is a special case: when
2214 calling a function which the compiler knows will never return
2215 (for instance abort), the call may be the very last instruction
2216 in the calling function. The resume address will point after the
2217 call and may be at the beginning of a different function
2220 If THIS_FRAME is a signal frame or dummy frame, then we should
2221 not adjust the unwound PC. For a dummy frame, GDB pushed the
2222 resume address manually onto the stack. For a signal frame, the
2223 OS may have pushed the resume address manually and invoked the
2224 handler (e.g. GNU/Linux), or invoked the trampoline which called
2225 the signal handler - but in either case the signal handler is
2226 expected to return to the trampoline. So in both of these
2227 cases we know that the resume address is executable and
2228 related. So we only need to adjust the PC if THIS_FRAME
2229 is a normal function.
2231 If the program has been interrupted while THIS_FRAME is current,
2232 then clearly the resume address is inside the associated
2233 function. There are three kinds of interruption: debugger stop
2234 (next frame will be SENTINEL_FRAME), operating system
2235 signal or exception (next frame will be SIGTRAMP_FRAME),
2236 or debugger-induced function call (next frame will be
2237 DUMMY_FRAME). So we only need to adjust the PC if
2238 NEXT_FRAME is a normal function.
2240 We check the type of NEXT_FRAME first, since it is already
2241 known; frame type is determined by the unwinder, and since
2242 we have THIS_FRAME we've already selected an unwinder for
2245 If the next frame is inlined, we need to keep going until we find
2246 the real function - for instance, if a signal handler is invoked
2247 while in an inlined function, then the code address of the
2248 "calling" normal function should not be adjusted either. */
2250 while (get_frame_type (next_frame
) == INLINE_FRAME
)
2251 next_frame
= next_frame
->next
;
2253 if ((get_frame_type (next_frame
) == NORMAL_FRAME
2254 || get_frame_type (next_frame
) == TAILCALL_FRAME
)
2255 && (get_frame_type (this_frame
) == NORMAL_FRAME
2256 || get_frame_type (this_frame
) == TAILCALL_FRAME
2257 || get_frame_type (this_frame
) == INLINE_FRAME
))
2264 get_frame_address_in_block_if_available (struct frame_info
*this_frame
,
2267 volatile struct gdb_exception ex
;
2269 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2271 *pc
= get_frame_address_in_block (this_frame
);
2273 if (ex
.reason
< 0 && ex
.error
== NOT_AVAILABLE_ERROR
)
2275 else if (ex
.reason
< 0)
2276 throw_exception (ex
);
2282 find_frame_sal (struct frame_info
*frame
, struct symtab_and_line
*sal
)
2284 struct frame_info
*next_frame
;
2288 /* If the next frame represents an inlined function call, this frame's
2289 sal is the "call site" of that inlined function, which can not
2290 be inferred from get_frame_pc. */
2291 next_frame
= get_next_frame (frame
);
2292 if (frame_inlined_callees (frame
) > 0)
2297 sym
= get_frame_function (next_frame
);
2299 sym
= inline_skipped_symbol (inferior_ptid
);
2301 /* If frame is inline, it certainly has symbols. */
2304 if (SYMBOL_LINE (sym
) != 0)
2306 sal
->symtab
= SYMBOL_SYMTAB (sym
);
2307 sal
->line
= SYMBOL_LINE (sym
);
2310 /* If the symbol does not have a location, we don't know where
2311 the call site is. Do not pretend to. This is jarring, but
2312 we can't do much better. */
2313 sal
->pc
= get_frame_pc (frame
);
2315 sal
->pspace
= get_frame_program_space (frame
);
2320 /* If FRAME is not the innermost frame, that normally means that
2321 FRAME->pc points at the return instruction (which is *after* the
2322 call instruction), and we want to get the line containing the
2323 call (because the call is where the user thinks the program is).
2324 However, if the next frame is either a SIGTRAMP_FRAME or a
2325 DUMMY_FRAME, then the next frame will contain a saved interrupt
2326 PC and such a PC indicates the current (rather than next)
2327 instruction/line, consequently, for such cases, want to get the
2328 line containing fi->pc. */
2329 if (!get_frame_pc_if_available (frame
, &pc
))
2335 notcurrent
= (pc
!= get_frame_address_in_block (frame
));
2336 (*sal
) = find_pc_line (pc
, notcurrent
);
2339 /* Per "frame.h", return the ``address'' of the frame. Code should
2340 really be using get_frame_id(). */
2342 get_frame_base (struct frame_info
*fi
)
2344 return get_frame_id (fi
).stack_addr
;
2347 /* High-level offsets into the frame. Used by the debug info. */
2350 get_frame_base_address (struct frame_info
*fi
)
2352 if (get_frame_type (fi
) != NORMAL_FRAME
)
2354 if (fi
->base
== NULL
)
2355 fi
->base
= frame_base_find_by_frame (fi
);
2356 /* Sneaky: If the low-level unwind and high-level base code share a
2357 common unwinder, let them share the prologue cache. */
2358 if (fi
->base
->unwind
== fi
->unwind
)
2359 return fi
->base
->this_base (fi
, &fi
->prologue_cache
);
2360 return fi
->base
->this_base (fi
, &fi
->base_cache
);
2364 get_frame_locals_address (struct frame_info
*fi
)
2366 if (get_frame_type (fi
) != NORMAL_FRAME
)
2368 /* If there isn't a frame address method, find it. */
2369 if (fi
->base
== NULL
)
2370 fi
->base
= frame_base_find_by_frame (fi
);
2371 /* Sneaky: If the low-level unwind and high-level base code share a
2372 common unwinder, let them share the prologue cache. */
2373 if (fi
->base
->unwind
== fi
->unwind
)
2374 return fi
->base
->this_locals (fi
, &fi
->prologue_cache
);
2375 return fi
->base
->this_locals (fi
, &fi
->base_cache
);
2379 get_frame_args_address (struct frame_info
*fi
)
2381 if (get_frame_type (fi
) != NORMAL_FRAME
)
2383 /* If there isn't a frame address method, find it. */
2384 if (fi
->base
== NULL
)
2385 fi
->base
= frame_base_find_by_frame (fi
);
2386 /* Sneaky: If the low-level unwind and high-level base code share a
2387 common unwinder, let them share the prologue cache. */
2388 if (fi
->base
->unwind
== fi
->unwind
)
2389 return fi
->base
->this_args (fi
, &fi
->prologue_cache
);
2390 return fi
->base
->this_args (fi
, &fi
->base_cache
);
2393 /* Return true if the frame unwinder for frame FI is UNWINDER; false
2397 frame_unwinder_is (struct frame_info
*fi
, const struct frame_unwind
*unwinder
)
2399 if (fi
->unwind
== NULL
)
2400 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
2401 return fi
->unwind
== unwinder
;
2404 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
2405 or -1 for a NULL frame. */
2408 frame_relative_level (struct frame_info
*fi
)
2417 get_frame_type (struct frame_info
*frame
)
2419 if (frame
->unwind
== NULL
)
2420 /* Initialize the frame's unwinder because that's what
2421 provides the frame's type. */
2422 frame_unwind_find_by_frame (frame
, &frame
->prologue_cache
);
2423 return frame
->unwind
->type
;
2426 struct program_space
*
2427 get_frame_program_space (struct frame_info
*frame
)
2429 return frame
->pspace
;
2432 struct program_space
*
2433 frame_unwind_program_space (struct frame_info
*this_frame
)
2435 gdb_assert (this_frame
);
2437 /* This is really a placeholder to keep the API consistent --- we
2438 assume for now that we don't have frame chains crossing
2440 return this_frame
->pspace
;
2443 struct address_space
*
2444 get_frame_address_space (struct frame_info
*frame
)
2446 return frame
->aspace
;
2449 /* Memory access methods. */
2452 get_frame_memory (struct frame_info
*this_frame
, CORE_ADDR addr
,
2453 gdb_byte
*buf
, int len
)
2455 read_memory (addr
, buf
, len
);
2459 get_frame_memory_signed (struct frame_info
*this_frame
, CORE_ADDR addr
,
2462 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2463 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2465 return read_memory_integer (addr
, len
, byte_order
);
2469 get_frame_memory_unsigned (struct frame_info
*this_frame
, CORE_ADDR addr
,
2472 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2473 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2475 return read_memory_unsigned_integer (addr
, len
, byte_order
);
2479 safe_frame_unwind_memory (struct frame_info
*this_frame
,
2480 CORE_ADDR addr
, gdb_byte
*buf
, int len
)
2482 /* NOTE: target_read_memory returns zero on success! */
2483 return !target_read_memory (addr
, buf
, len
);
2486 /* Architecture methods. */
2489 get_frame_arch (struct frame_info
*this_frame
)
2491 return frame_unwind_arch (this_frame
->next
);
2495 frame_unwind_arch (struct frame_info
*next_frame
)
2497 if (!next_frame
->prev_arch
.p
)
2499 struct gdbarch
*arch
;
2501 if (next_frame
->unwind
== NULL
)
2502 frame_unwind_find_by_frame (next_frame
, &next_frame
->prologue_cache
);
2504 if (next_frame
->unwind
->prev_arch
!= NULL
)
2505 arch
= next_frame
->unwind
->prev_arch (next_frame
,
2506 &next_frame
->prologue_cache
);
2508 arch
= get_frame_arch (next_frame
);
2510 next_frame
->prev_arch
.arch
= arch
;
2511 next_frame
->prev_arch
.p
= 1;
2513 fprintf_unfiltered (gdb_stdlog
,
2514 "{ frame_unwind_arch (next_frame=%d) -> %s }\n",
2516 gdbarch_bfd_arch_info (arch
)->printable_name
);
2519 return next_frame
->prev_arch
.arch
;
2523 frame_unwind_caller_arch (struct frame_info
*next_frame
)
2525 return frame_unwind_arch (skip_artificial_frames (next_frame
));
2528 /* Stack pointer methods. */
2531 get_frame_sp (struct frame_info
*this_frame
)
2533 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2535 /* Normality - an architecture that provides a way of obtaining any
2536 frame inner-most address. */
2537 if (gdbarch_unwind_sp_p (gdbarch
))
2538 /* NOTE drow/2008-06-28: gdbarch_unwind_sp could be converted to
2539 operate on THIS_FRAME now. */
2540 return gdbarch_unwind_sp (gdbarch
, this_frame
->next
);
2541 /* Now things are really are grim. Hope that the value returned by
2542 the gdbarch_sp_regnum register is meaningful. */
2543 if (gdbarch_sp_regnum (gdbarch
) >= 0)
2544 return get_frame_register_unsigned (this_frame
,
2545 gdbarch_sp_regnum (gdbarch
));
2546 internal_error (__FILE__
, __LINE__
, _("Missing unwind SP method"));
2549 /* Return the reason why we can't unwind past FRAME. */
2551 enum unwind_stop_reason
2552 get_frame_unwind_stop_reason (struct frame_info
*frame
)
2554 /* Fill-in STOP_REASON. */
2555 get_prev_frame_always (frame
);
2556 gdb_assert (frame
->prev_p
);
2558 return frame
->stop_reason
;
2561 /* Return a string explaining REASON. */
2564 unwind_stop_reason_to_string (enum unwind_stop_reason reason
)
2568 #define SET(name, description) \
2569 case name: return _(description);
2570 #include "unwind_stop_reasons.def"
2574 internal_error (__FILE__
, __LINE__
,
2575 "Invalid frame stop reason");
2579 /* Return the enum symbol name of REASON as a string, to use in debug
2583 frame_stop_reason_symbol_string (enum unwind_stop_reason reason
)
2587 #define SET(name, description) \
2588 case name: return #name;
2589 #include "unwind_stop_reasons.def"
2593 internal_error (__FILE__
, __LINE__
,
2594 "Invalid frame stop reason");
2598 /* Clean up after a failed (wrong unwinder) attempt to unwind past
2602 frame_cleanup_after_sniffer (void *arg
)
2604 struct frame_info
*frame
= arg
;
2606 /* The sniffer should not allocate a prologue cache if it did not
2607 match this frame. */
2608 gdb_assert (frame
->prologue_cache
== NULL
);
2610 /* No sniffer should extend the frame chain; sniff based on what is
2612 gdb_assert (!frame
->prev_p
);
2614 /* The sniffer should not check the frame's ID; that's circular. */
2615 gdb_assert (!frame
->this_id
.p
);
2617 /* Clear cached fields dependent on the unwinder.
2619 The previous PC is independent of the unwinder, but the previous
2620 function is not (see get_frame_address_in_block). */
2621 frame
->prev_func
.p
= 0;
2622 frame
->prev_func
.addr
= 0;
2624 /* Discard the unwinder last, so that we can easily find it if an assertion
2625 in this function triggers. */
2626 frame
->unwind
= NULL
;
2629 /* Set FRAME's unwinder temporarily, so that we can call a sniffer.
2630 Return a cleanup which should be called if unwinding fails, and
2631 discarded if it succeeds. */
2634 frame_prepare_for_sniffer (struct frame_info
*frame
,
2635 const struct frame_unwind
*unwind
)
2637 gdb_assert (frame
->unwind
== NULL
);
2638 frame
->unwind
= unwind
;
2639 return make_cleanup (frame_cleanup_after_sniffer
, frame
);
2642 extern initialize_file_ftype _initialize_frame
; /* -Wmissing-prototypes */
2644 static struct cmd_list_element
*set_backtrace_cmdlist
;
2645 static struct cmd_list_element
*show_backtrace_cmdlist
;
2648 set_backtrace_cmd (char *args
, int from_tty
)
2650 help_list (set_backtrace_cmdlist
, "set backtrace ", -1, gdb_stdout
);
2654 show_backtrace_cmd (char *args
, int from_tty
)
2656 cmd_show_list (show_backtrace_cmdlist
, from_tty
, "");
2660 _initialize_frame (void)
2662 obstack_init (&frame_cache_obstack
);
2664 frame_stash_create ();
2666 observer_attach_target_changed (frame_observer_target_changed
);
2668 add_prefix_cmd ("backtrace", class_maintenance
, set_backtrace_cmd
, _("\
2669 Set backtrace specific variables.\n\
2670 Configure backtrace variables such as the backtrace limit"),
2671 &set_backtrace_cmdlist
, "set backtrace ",
2672 0/*allow-unknown*/, &setlist
);
2673 add_prefix_cmd ("backtrace", class_maintenance
, show_backtrace_cmd
, _("\
2674 Show backtrace specific variables\n\
2675 Show backtrace variables such as the backtrace limit"),
2676 &show_backtrace_cmdlist
, "show backtrace ",
2677 0/*allow-unknown*/, &showlist
);
2679 add_setshow_boolean_cmd ("past-main", class_obscure
,
2680 &backtrace_past_main
, _("\
2681 Set whether backtraces should continue past \"main\"."), _("\
2682 Show whether backtraces should continue past \"main\"."), _("\
2683 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
2684 the backtrace at \"main\". Set this variable if you need to see the rest\n\
2685 of the stack trace."),
2687 show_backtrace_past_main
,
2688 &set_backtrace_cmdlist
,
2689 &show_backtrace_cmdlist
);
2691 add_setshow_boolean_cmd ("past-entry", class_obscure
,
2692 &backtrace_past_entry
, _("\
2693 Set whether backtraces should continue past the entry point of a program."),
2695 Show whether backtraces should continue past the entry point of a program."),
2697 Normally there are no callers beyond the entry point of a program, so GDB\n\
2698 will terminate the backtrace there. Set this variable if you need to see\n\
2699 the rest of the stack trace."),
2701 show_backtrace_past_entry
,
2702 &set_backtrace_cmdlist
,
2703 &show_backtrace_cmdlist
);
2705 add_setshow_uinteger_cmd ("limit", class_obscure
,
2706 &backtrace_limit
, _("\
2707 Set an upper bound on the number of backtrace levels."), _("\
2708 Show the upper bound on the number of backtrace levels."), _("\
2709 No more than the specified number of frames can be displayed or examined.\n\
2710 Literal \"unlimited\" or zero means no limit."),
2712 show_backtrace_limit
,
2713 &set_backtrace_cmdlist
,
2714 &show_backtrace_cmdlist
);
2716 /* Debug this files internals. */
2717 add_setshow_zuinteger_cmd ("frame", class_maintenance
, &frame_debug
, _("\
2718 Set frame debugging."), _("\
2719 Show frame debugging."), _("\
2720 When non-zero, frame specific internal debugging is enabled."),
2723 &setdebuglist
, &showdebuglist
);