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 */
27 #include "user-regs.h"
28 #include "gdb_obstack.h"
29 #include "dummy-frame.h"
30 #include "sentinel-frame.h"
34 #include "frame-unwind.h"
35 #include "frame-base.h"
40 #include "exceptions.h"
41 #include "gdbthread.h"
43 #include "inline-frame.h"
44 #include "tracepoint.h"
48 static struct frame_info
*get_prev_frame_raw (struct frame_info
*this_frame
);
49 static const char *frame_stop_reason_symbol_string (enum unwind_stop_reason reason
);
51 /* Status of some values cached in the frame_info object. */
53 enum cached_copy_status
55 /* Value is unknown. */
58 /* We have a value. */
61 /* Value was not saved. */
64 /* Value is unavailable. */
68 /* We keep a cache of stack frames, each of which is a "struct
69 frame_info". The innermost one gets allocated (in
70 wait_for_inferior) each time the inferior stops; current_frame
71 points to it. Additional frames get allocated (in get_prev_frame)
72 as needed, and are chained through the next and prev fields. Any
73 time that the frame cache becomes invalid (most notably when we
74 execute something, but also if we change how we interpret the
75 frames (e.g. "set heuristic-fence-post" in mips-tdep.c, or anything
76 which reads new symbols)), we should call reinit_frame_cache. */
80 /* Level of this frame. The inner-most (youngest) frame is at level
81 0. As you move towards the outer-most (oldest) frame, the level
82 increases. This is a cached value. It could just as easily be
83 computed by counting back from the selected frame to the inner
85 /* NOTE: cagney/2002-04-05: Perhaps a level of ``-1'' should be
86 reserved to indicate a bogus frame - one that has been created
87 just to keep GDB happy (GDB always needs a frame). For the
88 moment leave this as speculation. */
91 /* The frame's program space. */
92 struct program_space
*pspace
;
94 /* The frame's address space. */
95 struct address_space
*aspace
;
97 /* The frame's low-level unwinder and corresponding cache. The
98 low-level unwinder is responsible for unwinding register values
99 for the previous frame. The low-level unwind methods are
100 selected based on the presence, or otherwise, of register unwind
101 information such as CFI. */
102 void *prologue_cache
;
103 const struct frame_unwind
*unwind
;
105 /* Cached copy of the previous frame's architecture. */
109 struct gdbarch
*arch
;
112 /* Cached copy of the previous frame's resume address. */
114 enum cached_copy_status status
;
118 /* Cached copy of the previous frame's function address. */
125 /* This frame's ID. */
129 struct frame_id value
;
132 /* The frame's high-level base methods, and corresponding cache.
133 The high level base methods are selected based on the frame's
135 const struct frame_base
*base
;
138 /* Pointers to the next (down, inner, younger) and previous (up,
139 outer, older) frame_info's in the frame cache. */
140 struct frame_info
*next
; /* down, inner, younger */
142 struct frame_info
*prev
; /* up, outer, older */
144 /* The reason why we could not set PREV, or UNWIND_NO_REASON if we
145 could. Only valid when PREV_P is set. */
146 enum unwind_stop_reason stop_reason
;
148 /* A frame specific string describing the STOP_REASON in more detail.
149 Only valid when PREV_P is set, but even then may still be NULL. */
150 const char *stop_string
;
153 /* A frame stash used to speed up frame lookups. Create a hash table
154 to stash frames previously accessed from the frame cache for
155 quicker subsequent retrieval. The hash table is emptied whenever
156 the frame cache is invalidated. */
158 static htab_t frame_stash
;
160 /* Internal function to calculate a hash from the frame_id addresses,
161 using as many valid addresses as possible. Frames below level 0
162 are not stored in the hash table. */
165 frame_addr_hash (const void *ap
)
167 const struct frame_info
*frame
= ap
;
168 const struct frame_id f_id
= frame
->this_id
.value
;
171 gdb_assert (f_id
.stack_status
!= FID_STACK_INVALID
173 || f_id
.special_addr_p
);
175 if (f_id
.stack_status
== FID_STACK_VALID
)
176 hash
= iterative_hash (&f_id
.stack_addr
,
177 sizeof (f_id
.stack_addr
), hash
);
178 if (f_id
.code_addr_p
)
179 hash
= iterative_hash (&f_id
.code_addr
,
180 sizeof (f_id
.code_addr
), hash
);
181 if (f_id
.special_addr_p
)
182 hash
= iterative_hash (&f_id
.special_addr
,
183 sizeof (f_id
.special_addr
), hash
);
188 /* Internal equality function for the hash table. This function
189 defers equality operations to frame_id_eq. */
192 frame_addr_hash_eq (const void *a
, const void *b
)
194 const struct frame_info
*f_entry
= a
;
195 const struct frame_info
*f_element
= b
;
197 return frame_id_eq (f_entry
->this_id
.value
,
198 f_element
->this_id
.value
);
201 /* Internal function to create the frame_stash hash table. 100 seems
202 to be a good compromise to start the hash table at. */
205 frame_stash_create (void)
207 frame_stash
= htab_create (100,
213 /* Internal function to add a frame to the frame_stash hash table.
214 Returns false if a frame with the same ID was already stashed, true
218 frame_stash_add (struct frame_info
*frame
)
220 struct frame_info
**slot
;
222 /* Do not try to stash the sentinel frame. */
223 gdb_assert (frame
->level
>= 0);
225 slot
= (struct frame_info
**) htab_find_slot (frame_stash
,
229 /* If we already have a frame in the stack with the same id, we
230 either have a stack cycle (corrupted stack?), or some bug
231 elsewhere in GDB. In any case, ignore the duplicate and return
232 an indication to the caller. */
240 /* Internal function to search the frame stash for an entry with the
241 given frame ID. If found, return that frame. Otherwise return
244 static struct frame_info
*
245 frame_stash_find (struct frame_id id
)
247 struct frame_info dummy
;
248 struct frame_info
*frame
;
250 dummy
.this_id
.value
= id
;
251 frame
= htab_find (frame_stash
, &dummy
);
255 /* Internal function to invalidate the frame stash by removing all
256 entries in it. This only occurs when the frame cache is
260 frame_stash_invalidate (void)
262 htab_empty (frame_stash
);
265 /* Flag to control debugging. */
267 unsigned int frame_debug
;
269 show_frame_debug (struct ui_file
*file
, int from_tty
,
270 struct cmd_list_element
*c
, const char *value
)
272 fprintf_filtered (file
, _("Frame debugging is %s.\n"), value
);
275 /* Flag to indicate whether backtraces should stop at main et.al. */
277 static int backtrace_past_main
;
279 show_backtrace_past_main (struct ui_file
*file
, int from_tty
,
280 struct cmd_list_element
*c
, const char *value
)
282 fprintf_filtered (file
,
283 _("Whether backtraces should "
284 "continue past \"main\" is %s.\n"),
288 static int backtrace_past_entry
;
290 show_backtrace_past_entry (struct ui_file
*file
, int from_tty
,
291 struct cmd_list_element
*c
, const char *value
)
293 fprintf_filtered (file
, _("Whether backtraces should continue past the "
294 "entry point of a program is %s.\n"),
298 static unsigned int backtrace_limit
= UINT_MAX
;
300 show_backtrace_limit (struct ui_file
*file
, int from_tty
,
301 struct cmd_list_element
*c
, const char *value
)
303 fprintf_filtered (file
,
304 _("An upper bound on the number "
305 "of backtrace levels is %s.\n"),
311 fprint_field (struct ui_file
*file
, const char *name
, int p
, CORE_ADDR addr
)
314 fprintf_unfiltered (file
, "%s=%s", name
, hex_string (addr
));
316 fprintf_unfiltered (file
, "!%s", name
);
320 fprint_frame_id (struct ui_file
*file
, struct frame_id id
)
322 fprintf_unfiltered (file
, "{");
324 if (id
.stack_status
== FID_STACK_INVALID
)
325 fprintf_unfiltered (file
, "!stack");
326 else if (id
.stack_status
== FID_STACK_UNAVAILABLE
)
327 fprintf_unfiltered (file
, "stack=<unavailable>");
329 fprintf_unfiltered (file
, "stack=%s", hex_string (id
.stack_addr
));
330 fprintf_unfiltered (file
, ",");
332 fprint_field (file
, "code", id
.code_addr_p
, id
.code_addr
);
333 fprintf_unfiltered (file
, ",");
335 fprint_field (file
, "special", id
.special_addr_p
, id
.special_addr
);
337 if (id
.artificial_depth
)
338 fprintf_unfiltered (file
, ",artificial=%d", id
.artificial_depth
);
340 fprintf_unfiltered (file
, "}");
344 fprint_frame_type (struct ui_file
*file
, enum frame_type type
)
349 fprintf_unfiltered (file
, "NORMAL_FRAME");
352 fprintf_unfiltered (file
, "DUMMY_FRAME");
355 fprintf_unfiltered (file
, "INLINE_FRAME");
358 fprintf_unfiltered (file
, "TAILCALL_FRAME");
361 fprintf_unfiltered (file
, "SIGTRAMP_FRAME");
364 fprintf_unfiltered (file
, "ARCH_FRAME");
367 fprintf_unfiltered (file
, "SENTINEL_FRAME");
370 fprintf_unfiltered (file
, "<unknown type>");
376 fprint_frame (struct ui_file
*file
, struct frame_info
*fi
)
380 fprintf_unfiltered (file
, "<NULL frame>");
383 fprintf_unfiltered (file
, "{");
384 fprintf_unfiltered (file
, "level=%d", fi
->level
);
385 fprintf_unfiltered (file
, ",");
386 fprintf_unfiltered (file
, "type=");
387 if (fi
->unwind
!= NULL
)
388 fprint_frame_type (file
, fi
->unwind
->type
);
390 fprintf_unfiltered (file
, "<unknown>");
391 fprintf_unfiltered (file
, ",");
392 fprintf_unfiltered (file
, "unwind=");
393 if (fi
->unwind
!= NULL
)
394 gdb_print_host_address (fi
->unwind
, file
);
396 fprintf_unfiltered (file
, "<unknown>");
397 fprintf_unfiltered (file
, ",");
398 fprintf_unfiltered (file
, "pc=");
399 if (fi
->next
== NULL
|| fi
->next
->prev_pc
.status
== CC_UNKNOWN
)
400 fprintf_unfiltered (file
, "<unknown>");
401 else if (fi
->next
->prev_pc
.status
== CC_VALUE
)
402 fprintf_unfiltered (file
, "%s",
403 hex_string (fi
->next
->prev_pc
.value
));
404 else if (fi
->next
->prev_pc
.status
== CC_NOT_SAVED
)
405 val_print_not_saved (file
);
406 else if (fi
->next
->prev_pc
.status
== CC_UNAVAILABLE
)
407 val_print_unavailable (file
);
408 fprintf_unfiltered (file
, ",");
409 fprintf_unfiltered (file
, "id=");
411 fprint_frame_id (file
, fi
->this_id
.value
);
413 fprintf_unfiltered (file
, "<unknown>");
414 fprintf_unfiltered (file
, ",");
415 fprintf_unfiltered (file
, "func=");
416 if (fi
->next
!= NULL
&& fi
->next
->prev_func
.p
)
417 fprintf_unfiltered (file
, "%s", hex_string (fi
->next
->prev_func
.addr
));
419 fprintf_unfiltered (file
, "<unknown>");
420 fprintf_unfiltered (file
, "}");
423 /* Given FRAME, return the enclosing frame as found in real frames read-in from
424 inferior memory. Skip any previous frames which were made up by GDB.
425 Return the original frame if no immediate previous frames exist. */
427 static struct frame_info
*
428 skip_artificial_frames (struct frame_info
*frame
)
430 /* Note we use get_prev_frame_always, and not get_prev_frame. The
431 latter will truncate the frame chain, leading to this function
432 unintentionally returning a null_frame_id (e.g., when the user
433 sets a backtrace limit). This is safe, because as these frames
434 are made up by GDB, there must be a real frame in the chain
436 while (get_frame_type (frame
) == INLINE_FRAME
437 || get_frame_type (frame
) == TAILCALL_FRAME
)
438 frame
= get_prev_frame_always (frame
);
443 /* Compute the frame's uniq ID that can be used to, later, re-find the
447 compute_frame_id (struct frame_info
*fi
)
449 gdb_assert (!fi
->this_id
.p
);
452 fprintf_unfiltered (gdb_stdlog
, "{ compute_frame_id (fi=%d) ",
454 /* Find the unwinder. */
455 if (fi
->unwind
== NULL
)
456 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
457 /* Find THIS frame's ID. */
458 /* Default to outermost if no ID is found. */
459 fi
->this_id
.value
= outer_frame_id
;
460 fi
->unwind
->this_id (fi
, &fi
->prologue_cache
, &fi
->this_id
.value
);
461 gdb_assert (frame_id_p (fi
->this_id
.value
));
465 fprintf_unfiltered (gdb_stdlog
, "-> ");
466 fprint_frame_id (gdb_stdlog
, fi
->this_id
.value
);
467 fprintf_unfiltered (gdb_stdlog
, " }\n");
471 /* Return a frame uniq ID that can be used to, later, re-find the
475 get_frame_id (struct frame_info
*fi
)
478 return null_frame_id
;
480 gdb_assert (fi
->this_id
.p
);
481 return fi
->this_id
.value
;
485 get_stack_frame_id (struct frame_info
*next_frame
)
487 return get_frame_id (skip_artificial_frames (next_frame
));
491 frame_unwind_caller_id (struct frame_info
*next_frame
)
493 struct frame_info
*this_frame
;
495 /* Use get_prev_frame_always, and not get_prev_frame. The latter
496 will truncate the frame chain, leading to this function
497 unintentionally returning a null_frame_id (e.g., when a caller
498 requests the frame ID of "main()"s caller. */
500 next_frame
= skip_artificial_frames (next_frame
);
501 this_frame
= get_prev_frame_always (next_frame
);
503 return get_frame_id (skip_artificial_frames (this_frame
));
505 return null_frame_id
;
508 const struct frame_id null_frame_id
; /* All zeros. */
509 const struct frame_id outer_frame_id
= { 0, 0, 0, FID_STACK_INVALID
, 0, 1, 0 };
512 frame_id_build_special (CORE_ADDR stack_addr
, CORE_ADDR code_addr
,
513 CORE_ADDR special_addr
)
515 struct frame_id id
= null_frame_id
;
517 id
.stack_addr
= stack_addr
;
518 id
.stack_status
= FID_STACK_VALID
;
519 id
.code_addr
= code_addr
;
521 id
.special_addr
= special_addr
;
522 id
.special_addr_p
= 1;
529 frame_id_build_unavailable_stack (CORE_ADDR code_addr
)
531 struct frame_id id
= null_frame_id
;
533 id
.stack_status
= FID_STACK_UNAVAILABLE
;
534 id
.code_addr
= code_addr
;
542 frame_id_build_unavailable_stack_special (CORE_ADDR code_addr
,
543 CORE_ADDR special_addr
)
545 struct frame_id id
= null_frame_id
;
547 id
.stack_status
= FID_STACK_UNAVAILABLE
;
548 id
.code_addr
= code_addr
;
550 id
.special_addr
= special_addr
;
551 id
.special_addr_p
= 1;
556 frame_id_build (CORE_ADDR stack_addr
, CORE_ADDR code_addr
)
558 struct frame_id id
= null_frame_id
;
560 id
.stack_addr
= stack_addr
;
561 id
.stack_status
= FID_STACK_VALID
;
562 id
.code_addr
= code_addr
;
568 frame_id_build_wild (CORE_ADDR stack_addr
)
570 struct frame_id id
= null_frame_id
;
572 id
.stack_addr
= stack_addr
;
573 id
.stack_status
= FID_STACK_VALID
;
578 frame_id_p (struct frame_id l
)
582 /* The frame is valid iff it has a valid stack address. */
583 p
= l
.stack_status
!= FID_STACK_INVALID
;
584 /* outer_frame_id is also valid. */
585 if (!p
&& memcmp (&l
, &outer_frame_id
, sizeof (l
)) == 0)
589 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_p (l=");
590 fprint_frame_id (gdb_stdlog
, l
);
591 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", p
);
597 frame_id_artificial_p (struct frame_id l
)
602 return (l
.artificial_depth
!= 0);
606 frame_id_eq (struct frame_id l
, struct frame_id r
)
610 if (l
.stack_status
== FID_STACK_INVALID
&& l
.special_addr_p
611 && r
.stack_status
== FID_STACK_INVALID
&& r
.special_addr_p
)
612 /* The outermost frame marker is equal to itself. This is the
613 dodgy thing about outer_frame_id, since between execution steps
614 we might step into another function - from which we can't
615 unwind either. More thought required to get rid of
618 else if (l
.stack_status
== FID_STACK_INVALID
619 || l
.stack_status
== FID_STACK_INVALID
)
620 /* Like a NaN, if either ID is invalid, the result is false.
621 Note that a frame ID is invalid iff it is the null frame ID. */
623 else if (l
.stack_status
!= r
.stack_status
|| l
.stack_addr
!= r
.stack_addr
)
624 /* If .stack addresses are different, the frames are different. */
626 else if (l
.code_addr_p
&& r
.code_addr_p
&& l
.code_addr
!= r
.code_addr
)
627 /* An invalid code addr is a wild card. If .code addresses are
628 different, the frames are different. */
630 else if (l
.special_addr_p
&& r
.special_addr_p
631 && l
.special_addr
!= r
.special_addr
)
632 /* An invalid special addr is a wild card (or unused). Otherwise
633 if special addresses are different, the frames are different. */
635 else if (l
.artificial_depth
!= r
.artificial_depth
)
636 /* If artifical depths are different, the frames must be different. */
639 /* Frames are equal. */
644 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_eq (l=");
645 fprint_frame_id (gdb_stdlog
, l
);
646 fprintf_unfiltered (gdb_stdlog
, ",r=");
647 fprint_frame_id (gdb_stdlog
, r
);
648 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", eq
);
653 /* Safety net to check whether frame ID L should be inner to
654 frame ID R, according to their stack addresses.
656 This method cannot be used to compare arbitrary frames, as the
657 ranges of valid stack addresses may be discontiguous (e.g. due
660 However, it can be used as safety net to discover invalid frame
661 IDs in certain circumstances. Assuming that NEXT is the immediate
662 inner frame to THIS and that NEXT and THIS are both NORMAL frames:
664 * The stack address of NEXT must be inner-than-or-equal to the stack
667 Therefore, if frame_id_inner (THIS, NEXT) holds, some unwind
670 * If NEXT and THIS have different stack addresses, no other frame
671 in the frame chain may have a stack address in between.
673 Therefore, if frame_id_inner (TEST, THIS) holds, but
674 frame_id_inner (TEST, NEXT) does not hold, TEST cannot refer
675 to a valid frame in the frame chain.
677 The sanity checks above cannot be performed when a SIGTRAMP frame
678 is involved, because signal handlers might be executed on a different
679 stack than the stack used by the routine that caused the signal
680 to be raised. This can happen for instance when a thread exceeds
681 its maximum stack size. In this case, certain compilers implement
682 a stack overflow strategy that cause the handler to be run on a
686 frame_id_inner (struct gdbarch
*gdbarch
, struct frame_id l
, struct frame_id r
)
690 if (l
.stack_status
!= FID_STACK_VALID
|| r
.stack_status
!= FID_STACK_VALID
)
691 /* Like NaN, any operation involving an invalid ID always fails.
692 Likewise if either ID has an unavailable stack address. */
694 else if (l
.artificial_depth
> r
.artificial_depth
695 && l
.stack_addr
== r
.stack_addr
696 && l
.code_addr_p
== r
.code_addr_p
697 && l
.special_addr_p
== r
.special_addr_p
698 && l
.special_addr
== r
.special_addr
)
700 /* Same function, different inlined functions. */
701 const struct block
*lb
, *rb
;
703 gdb_assert (l
.code_addr_p
&& r
.code_addr_p
);
705 lb
= block_for_pc (l
.code_addr
);
706 rb
= block_for_pc (r
.code_addr
);
708 if (lb
== NULL
|| rb
== NULL
)
709 /* Something's gone wrong. */
712 /* This will return true if LB and RB are the same block, or
713 if the block with the smaller depth lexically encloses the
714 block with the greater depth. */
715 inner
= contained_in (lb
, rb
);
718 /* Only return non-zero when strictly inner than. Note that, per
719 comment in "frame.h", there is some fuzz here. Frameless
720 functions are not strictly inner than (same .stack but
721 different .code and/or .special address). */
722 inner
= gdbarch_inner_than (gdbarch
, l
.stack_addr
, r
.stack_addr
);
725 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_inner (l=");
726 fprint_frame_id (gdb_stdlog
, l
);
727 fprintf_unfiltered (gdb_stdlog
, ",r=");
728 fprint_frame_id (gdb_stdlog
, r
);
729 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", inner
);
735 frame_find_by_id (struct frame_id id
)
737 struct frame_info
*frame
, *prev_frame
;
739 /* ZERO denotes the null frame, let the caller decide what to do
740 about it. Should it instead return get_current_frame()? */
741 if (!frame_id_p (id
))
744 /* Try using the frame stash first. Finding it there removes the need
745 to perform the search by looping over all frames, which can be very
746 CPU-intensive if the number of frames is very high (the loop is O(n)
747 and get_prev_frame performs a series of checks that are relatively
748 expensive). This optimization is particularly useful when this function
749 is called from another function (such as value_fetch_lazy, case
750 VALUE_LVAL (val) == lval_register) which already loops over all frames,
751 making the overall behavior O(n^2). */
752 frame
= frame_stash_find (id
);
756 for (frame
= get_current_frame (); ; frame
= prev_frame
)
758 struct frame_id
this = get_frame_id (frame
);
760 if (frame_id_eq (id
, this))
761 /* An exact match. */
764 prev_frame
= get_prev_frame (frame
);
768 /* As a safety net to avoid unnecessary backtracing while trying
769 to find an invalid ID, we check for a common situation where
770 we can detect from comparing stack addresses that no other
771 frame in the current frame chain can have this ID. See the
772 comment at frame_id_inner for details. */
773 if (get_frame_type (frame
) == NORMAL_FRAME
774 && !frame_id_inner (get_frame_arch (frame
), id
, this)
775 && frame_id_inner (get_frame_arch (prev_frame
), id
,
776 get_frame_id (prev_frame
)))
783 frame_unwind_pc (struct frame_info
*this_frame
)
785 if (this_frame
->prev_pc
.status
== CC_UNKNOWN
)
787 if (gdbarch_unwind_pc_p (frame_unwind_arch (this_frame
)))
789 volatile struct gdb_exception ex
;
790 struct gdbarch
*prev_gdbarch
;
793 /* The right way. The `pure' way. The one true way. This
794 method depends solely on the register-unwind code to
795 determine the value of registers in THIS frame, and hence
796 the value of this frame's PC (resume address). A typical
797 implementation is no more than:
799 frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
800 return extract_unsigned_integer (buf, size of ISA_PC_REGNUM);
802 Note: this method is very heavily dependent on a correct
803 register-unwind implementation, it pays to fix that
804 method first; this method is frame type agnostic, since
805 it only deals with register values, it works with any
806 frame. This is all in stark contrast to the old
807 FRAME_SAVED_PC which would try to directly handle all the
808 different ways that a PC could be unwound. */
809 prev_gdbarch
= frame_unwind_arch (this_frame
);
811 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
813 pc
= gdbarch_unwind_pc (prev_gdbarch
, this_frame
);
817 if (ex
.error
== NOT_AVAILABLE_ERROR
)
819 this_frame
->prev_pc
.status
= CC_UNAVAILABLE
;
822 fprintf_unfiltered (gdb_stdlog
,
823 "{ frame_unwind_pc (this_frame=%d)"
824 " -> <unavailable> }\n",
827 else if (ex
.error
== OPTIMIZED_OUT_ERROR
)
829 this_frame
->prev_pc
.status
= CC_NOT_SAVED
;
832 fprintf_unfiltered (gdb_stdlog
,
833 "{ frame_unwind_pc (this_frame=%d)"
834 " -> <not saved> }\n",
838 throw_exception (ex
);
842 this_frame
->prev_pc
.value
= pc
;
843 this_frame
->prev_pc
.status
= CC_VALUE
;
845 fprintf_unfiltered (gdb_stdlog
,
846 "{ frame_unwind_pc (this_frame=%d) "
849 hex_string (this_frame
->prev_pc
.value
));
853 internal_error (__FILE__
, __LINE__
, _("No unwind_pc method"));
856 if (this_frame
->prev_pc
.status
== CC_VALUE
)
857 return this_frame
->prev_pc
.value
;
858 else if (this_frame
->prev_pc
.status
== CC_UNAVAILABLE
)
859 throw_error (NOT_AVAILABLE_ERROR
, _("PC not available"));
860 else if (this_frame
->prev_pc
.status
== CC_NOT_SAVED
)
861 throw_error (OPTIMIZED_OUT_ERROR
, _("PC not saved"));
863 internal_error (__FILE__
, __LINE__
,
864 "unexpected prev_pc status: %d",
865 (int) this_frame
->prev_pc
.status
);
869 frame_unwind_caller_pc (struct frame_info
*this_frame
)
871 return frame_unwind_pc (skip_artificial_frames (this_frame
));
875 get_frame_func_if_available (struct frame_info
*this_frame
, CORE_ADDR
*pc
)
877 struct frame_info
*next_frame
= this_frame
->next
;
879 if (!next_frame
->prev_func
.p
)
881 CORE_ADDR addr_in_block
;
883 /* Make certain that this, and not the adjacent, function is
885 if (!get_frame_address_in_block_if_available (this_frame
, &addr_in_block
))
887 next_frame
->prev_func
.p
= -1;
889 fprintf_unfiltered (gdb_stdlog
,
890 "{ get_frame_func (this_frame=%d)"
891 " -> unavailable }\n",
896 next_frame
->prev_func
.p
= 1;
897 next_frame
->prev_func
.addr
= get_pc_function_start (addr_in_block
);
899 fprintf_unfiltered (gdb_stdlog
,
900 "{ get_frame_func (this_frame=%d) -> %s }\n",
902 hex_string (next_frame
->prev_func
.addr
));
906 if (next_frame
->prev_func
.p
< 0)
913 *pc
= next_frame
->prev_func
.addr
;
919 get_frame_func (struct frame_info
*this_frame
)
923 if (!get_frame_func_if_available (this_frame
, &pc
))
924 throw_error (NOT_AVAILABLE_ERROR
, _("PC not available"));
929 static enum register_status
930 do_frame_register_read (void *src
, int regnum
, gdb_byte
*buf
)
932 if (!deprecated_frame_register_read (src
, regnum
, buf
))
933 return REG_UNAVAILABLE
;
939 frame_save_as_regcache (struct frame_info
*this_frame
)
941 struct address_space
*aspace
= get_frame_address_space (this_frame
);
942 struct regcache
*regcache
= regcache_xmalloc (get_frame_arch (this_frame
),
944 struct cleanup
*cleanups
= make_cleanup_regcache_xfree (regcache
);
946 regcache_save (regcache
, do_frame_register_read
, this_frame
);
947 discard_cleanups (cleanups
);
952 frame_pop (struct frame_info
*this_frame
)
954 struct frame_info
*prev_frame
;
955 struct regcache
*scratch
;
956 struct cleanup
*cleanups
;
958 if (get_frame_type (this_frame
) == DUMMY_FRAME
)
960 /* Popping a dummy frame involves restoring more than just registers.
961 dummy_frame_pop does all the work. */
962 dummy_frame_pop (get_frame_id (this_frame
), inferior_ptid
);
966 /* Ensure that we have a frame to pop to. */
967 prev_frame
= get_prev_frame_always (this_frame
);
970 error (_("Cannot pop the initial frame."));
972 /* Ignore TAILCALL_FRAME type frames, they were executed already before
973 entering THISFRAME. */
974 while (get_frame_type (prev_frame
) == TAILCALL_FRAME
)
975 prev_frame
= get_prev_frame (prev_frame
);
977 /* Make a copy of all the register values unwound from this frame.
978 Save them in a scratch buffer so that there isn't a race between
979 trying to extract the old values from the current regcache while
980 at the same time writing new values into that same cache. */
981 scratch
= frame_save_as_regcache (prev_frame
);
982 cleanups
= make_cleanup_regcache_xfree (scratch
);
984 /* FIXME: cagney/2003-03-16: It should be possible to tell the
985 target's register cache that it is about to be hit with a burst
986 register transfer and that the sequence of register writes should
987 be batched. The pair target_prepare_to_store() and
988 target_store_registers() kind of suggest this functionality.
989 Unfortunately, they don't implement it. Their lack of a formal
990 definition can lead to targets writing back bogus values
991 (arguably a bug in the target code mind). */
992 /* Now copy those saved registers into the current regcache.
993 Here, regcache_cpy() calls regcache_restore(). */
994 regcache_cpy (get_current_regcache (), scratch
);
995 do_cleanups (cleanups
);
997 /* We've made right mess of GDB's local state, just discard
999 reinit_frame_cache ();
1003 frame_register_unwind (struct frame_info
*frame
, int regnum
,
1004 int *optimizedp
, int *unavailablep
,
1005 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
1006 int *realnump
, gdb_byte
*bufferp
)
1008 struct value
*value
;
1010 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
1011 that the value proper does not need to be fetched. */
1012 gdb_assert (optimizedp
!= NULL
);
1013 gdb_assert (lvalp
!= NULL
);
1014 gdb_assert (addrp
!= NULL
);
1015 gdb_assert (realnump
!= NULL
);
1016 /* gdb_assert (bufferp != NULL); */
1018 value
= frame_unwind_register_value (frame
, regnum
);
1020 gdb_assert (value
!= NULL
);
1022 *optimizedp
= value_optimized_out (value
);
1023 *unavailablep
= !value_entirely_available (value
);
1024 *lvalp
= VALUE_LVAL (value
);
1025 *addrp
= value_address (value
);
1026 *realnump
= VALUE_REGNUM (value
);
1030 if (!*optimizedp
&& !*unavailablep
)
1031 memcpy (bufferp
, value_contents_all (value
),
1032 TYPE_LENGTH (value_type (value
)));
1034 memset (bufferp
, 0, TYPE_LENGTH (value_type (value
)));
1037 /* Dispose of the new value. This prevents watchpoints from
1038 trying to watch the saved frame pointer. */
1039 release_value (value
);
1044 frame_register (struct frame_info
*frame
, int regnum
,
1045 int *optimizedp
, int *unavailablep
, enum lval_type
*lvalp
,
1046 CORE_ADDR
*addrp
, int *realnump
, gdb_byte
*bufferp
)
1048 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
1049 that the value proper does not need to be fetched. */
1050 gdb_assert (optimizedp
!= NULL
);
1051 gdb_assert (lvalp
!= NULL
);
1052 gdb_assert (addrp
!= NULL
);
1053 gdb_assert (realnump
!= NULL
);
1054 /* gdb_assert (bufferp != NULL); */
1056 /* Obtain the register value by unwinding the register from the next
1057 (more inner frame). */
1058 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
1059 frame_register_unwind (frame
->next
, regnum
, optimizedp
, unavailablep
,
1060 lvalp
, addrp
, realnump
, bufferp
);
1064 frame_unwind_register (struct frame_info
*frame
, int regnum
, gdb_byte
*buf
)
1070 enum lval_type lval
;
1072 frame_register_unwind (frame
, regnum
, &optimized
, &unavailable
,
1073 &lval
, &addr
, &realnum
, buf
);
1076 throw_error (OPTIMIZED_OUT_ERROR
,
1077 _("Register %d was not saved"), regnum
);
1079 throw_error (NOT_AVAILABLE_ERROR
,
1080 _("Register %d is not available"), regnum
);
1084 get_frame_register (struct frame_info
*frame
,
1085 int regnum
, gdb_byte
*buf
)
1087 frame_unwind_register (frame
->next
, regnum
, buf
);
1091 frame_unwind_register_value (struct frame_info
*frame
, int regnum
)
1093 struct gdbarch
*gdbarch
;
1094 struct value
*value
;
1096 gdb_assert (frame
!= NULL
);
1097 gdbarch
= frame_unwind_arch (frame
);
1101 fprintf_unfiltered (gdb_stdlog
,
1102 "{ frame_unwind_register_value "
1103 "(frame=%d,regnum=%d(%s),...) ",
1104 frame
->level
, regnum
,
1105 user_reg_map_regnum_to_name (gdbarch
, regnum
));
1108 /* Find the unwinder. */
1109 if (frame
->unwind
== NULL
)
1110 frame_unwind_find_by_frame (frame
, &frame
->prologue_cache
);
1112 /* Ask this frame to unwind its register. */
1113 value
= frame
->unwind
->prev_register (frame
, &frame
->prologue_cache
, regnum
);
1117 fprintf_unfiltered (gdb_stdlog
, "->");
1118 if (value_optimized_out (value
))
1120 fprintf_unfiltered (gdb_stdlog
, " ");
1121 val_print_optimized_out (value
, gdb_stdlog
);
1125 if (VALUE_LVAL (value
) == lval_register
)
1126 fprintf_unfiltered (gdb_stdlog
, " register=%d",
1127 VALUE_REGNUM (value
));
1128 else if (VALUE_LVAL (value
) == lval_memory
)
1129 fprintf_unfiltered (gdb_stdlog
, " address=%s",
1131 value_address (value
)));
1133 fprintf_unfiltered (gdb_stdlog
, " computed");
1135 if (value_lazy (value
))
1136 fprintf_unfiltered (gdb_stdlog
, " lazy");
1140 const gdb_byte
*buf
= value_contents (value
);
1142 fprintf_unfiltered (gdb_stdlog
, " bytes=");
1143 fprintf_unfiltered (gdb_stdlog
, "[");
1144 for (i
= 0; i
< register_size (gdbarch
, regnum
); i
++)
1145 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1146 fprintf_unfiltered (gdb_stdlog
, "]");
1150 fprintf_unfiltered (gdb_stdlog
, " }\n");
1157 get_frame_register_value (struct frame_info
*frame
, int regnum
)
1159 return frame_unwind_register_value (frame
->next
, regnum
);
1163 frame_unwind_register_signed (struct frame_info
*frame
, int regnum
)
1165 struct gdbarch
*gdbarch
= frame_unwind_arch (frame
);
1166 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1167 int size
= register_size (gdbarch
, regnum
);
1168 gdb_byte buf
[MAX_REGISTER_SIZE
];
1170 frame_unwind_register (frame
, regnum
, buf
);
1171 return extract_signed_integer (buf
, size
, byte_order
);
1175 get_frame_register_signed (struct frame_info
*frame
, int regnum
)
1177 return frame_unwind_register_signed (frame
->next
, regnum
);
1181 frame_unwind_register_unsigned (struct frame_info
*frame
, int regnum
)
1183 struct gdbarch
*gdbarch
= frame_unwind_arch (frame
);
1184 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1185 int size
= register_size (gdbarch
, regnum
);
1186 gdb_byte buf
[MAX_REGISTER_SIZE
];
1188 frame_unwind_register (frame
, regnum
, buf
);
1189 return extract_unsigned_integer (buf
, size
, byte_order
);
1193 get_frame_register_unsigned (struct frame_info
*frame
, int regnum
)
1195 return frame_unwind_register_unsigned (frame
->next
, regnum
);
1199 read_frame_register_unsigned (struct frame_info
*frame
, int regnum
,
1202 struct value
*regval
= get_frame_register_value (frame
, regnum
);
1204 if (!value_optimized_out (regval
)
1205 && value_entirely_available (regval
))
1207 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1208 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1209 int size
= register_size (gdbarch
, VALUE_REGNUM (regval
));
1211 *val
= extract_unsigned_integer (value_contents (regval
), size
, byte_order
);
1219 put_frame_register (struct frame_info
*frame
, int regnum
,
1220 const gdb_byte
*buf
)
1222 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1226 enum lval_type lval
;
1229 frame_register (frame
, regnum
, &optim
, &unavail
,
1230 &lval
, &addr
, &realnum
, NULL
);
1232 error (_("Attempt to assign to a register that was not saved."));
1237 write_memory (addr
, buf
, register_size (gdbarch
, regnum
));
1241 regcache_cooked_write (get_current_regcache (), realnum
, buf
);
1244 error (_("Attempt to assign to an unmodifiable value."));
1248 /* This function is deprecated. Use get_frame_register_value instead,
1249 which provides more accurate information.
1251 Find and return the value of REGNUM for the specified stack frame.
1252 The number of bytes copied is REGISTER_SIZE (REGNUM).
1254 Returns 0 if the register value could not be found. */
1257 deprecated_frame_register_read (struct frame_info
*frame
, int regnum
,
1262 enum lval_type lval
;
1266 frame_register (frame
, regnum
, &optimized
, &unavailable
,
1267 &lval
, &addr
, &realnum
, myaddr
);
1269 return !optimized
&& !unavailable
;
1273 get_frame_register_bytes (struct frame_info
*frame
, int regnum
,
1274 CORE_ADDR offset
, int len
, gdb_byte
*myaddr
,
1275 int *optimizedp
, int *unavailablep
)
1277 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1282 /* Skip registers wholly inside of OFFSET. */
1283 while (offset
>= register_size (gdbarch
, regnum
))
1285 offset
-= register_size (gdbarch
, regnum
);
1289 /* Ensure that we will not read beyond the end of the register file.
1290 This can only ever happen if the debug information is bad. */
1292 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1293 for (i
= regnum
; i
< numregs
; i
++)
1295 int thissize
= register_size (gdbarch
, i
);
1298 break; /* This register is not available on this architecture. */
1299 maxsize
+= thissize
;
1302 error (_("Bad debug information detected: "
1303 "Attempt to read %d bytes from registers."), len
);
1305 /* Copy the data. */
1308 int curr_len
= register_size (gdbarch
, regnum
) - offset
;
1313 if (curr_len
== register_size (gdbarch
, regnum
))
1315 enum lval_type lval
;
1319 frame_register (frame
, regnum
, optimizedp
, unavailablep
,
1320 &lval
, &addr
, &realnum
, myaddr
);
1321 if (*optimizedp
|| *unavailablep
)
1326 gdb_byte buf
[MAX_REGISTER_SIZE
];
1327 enum lval_type lval
;
1331 frame_register (frame
, regnum
, optimizedp
, unavailablep
,
1332 &lval
, &addr
, &realnum
, buf
);
1333 if (*optimizedp
|| *unavailablep
)
1335 memcpy (myaddr
, buf
+ offset
, curr_len
);
1350 put_frame_register_bytes (struct frame_info
*frame
, int regnum
,
1351 CORE_ADDR offset
, int len
, const gdb_byte
*myaddr
)
1353 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1355 /* Skip registers wholly inside of OFFSET. */
1356 while (offset
>= register_size (gdbarch
, regnum
))
1358 offset
-= register_size (gdbarch
, regnum
);
1362 /* Copy the data. */
1365 int curr_len
= register_size (gdbarch
, regnum
) - offset
;
1370 if (curr_len
== register_size (gdbarch
, regnum
))
1372 put_frame_register (frame
, regnum
, myaddr
);
1376 gdb_byte buf
[MAX_REGISTER_SIZE
];
1378 deprecated_frame_register_read (frame
, regnum
, buf
);
1379 memcpy (buf
+ offset
, myaddr
, curr_len
);
1380 put_frame_register (frame
, regnum
, buf
);
1390 /* Create a sentinel frame. */
1392 static struct frame_info
*
1393 create_sentinel_frame (struct program_space
*pspace
, struct regcache
*regcache
)
1395 struct frame_info
*frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1398 frame
->pspace
= pspace
;
1399 frame
->aspace
= get_regcache_aspace (regcache
);
1400 /* Explicitly initialize the sentinel frame's cache. Provide it
1401 with the underlying regcache. In the future additional
1402 information, such as the frame's thread will be added. */
1403 frame
->prologue_cache
= sentinel_frame_cache (regcache
);
1404 /* For the moment there is only one sentinel frame implementation. */
1405 frame
->unwind
= &sentinel_frame_unwind
;
1406 /* Link this frame back to itself. The frame is self referential
1407 (the unwound PC is the same as the pc), so make it so. */
1408 frame
->next
= frame
;
1409 /* Make the sentinel frame's ID valid, but invalid. That way all
1410 comparisons with it should fail. */
1411 frame
->this_id
.p
= 1;
1412 frame
->this_id
.value
= null_frame_id
;
1415 fprintf_unfiltered (gdb_stdlog
, "{ create_sentinel_frame (...) -> ");
1416 fprint_frame (gdb_stdlog
, frame
);
1417 fprintf_unfiltered (gdb_stdlog
, " }\n");
1422 /* Info about the innermost stack frame (contents of FP register). */
1424 static struct frame_info
*current_frame
;
1426 /* Cache for frame addresses already read by gdb. Valid only while
1427 inferior is stopped. Control variables for the frame cache should
1428 be local to this module. */
1430 static struct obstack frame_cache_obstack
;
1433 frame_obstack_zalloc (unsigned long size
)
1435 void *data
= obstack_alloc (&frame_cache_obstack
, size
);
1437 memset (data
, 0, size
);
1441 /* Return the innermost (currently executing) stack frame. This is
1442 split into two functions. The function unwind_to_current_frame()
1443 is wrapped in catch exceptions so that, even when the unwind of the
1444 sentinel frame fails, the function still returns a stack frame. */
1447 unwind_to_current_frame (struct ui_out
*ui_out
, void *args
)
1449 struct frame_info
*frame
= get_prev_frame (args
);
1451 /* A sentinel frame can fail to unwind, e.g., because its PC value
1452 lands in somewhere like start. */
1455 current_frame
= frame
;
1460 get_current_frame (void)
1462 /* First check, and report, the lack of registers. Having GDB
1463 report "No stack!" or "No memory" when the target doesn't even
1464 have registers is very confusing. Besides, "printcmd.exp"
1465 explicitly checks that ``print $pc'' with no registers prints "No
1467 if (!target_has_registers
)
1468 error (_("No registers."));
1469 if (!target_has_stack
)
1470 error (_("No stack."));
1471 if (!target_has_memory
)
1472 error (_("No memory."));
1473 /* Traceframes are effectively a substitute for the live inferior. */
1474 if (get_traceframe_number () < 0)
1476 if (ptid_equal (inferior_ptid
, null_ptid
))
1477 error (_("No selected thread."));
1478 if (is_exited (inferior_ptid
))
1479 error (_("Invalid selected thread."));
1480 if (is_executing (inferior_ptid
))
1481 error (_("Target is executing."));
1484 if (current_frame
== NULL
)
1486 struct frame_info
*sentinel_frame
=
1487 create_sentinel_frame (current_program_space
, get_current_regcache ());
1488 if (catch_exceptions (current_uiout
, unwind_to_current_frame
,
1489 sentinel_frame
, RETURN_MASK_ERROR
) != 0)
1491 /* Oops! Fake a current frame? Is this useful? It has a PC
1492 of zero, for instance. */
1493 current_frame
= sentinel_frame
;
1496 return current_frame
;
1499 /* The "selected" stack frame is used by default for local and arg
1500 access. May be zero, for no selected frame. */
1502 static struct frame_info
*selected_frame
;
1505 has_stack_frames (void)
1507 if (!target_has_registers
|| !target_has_stack
|| !target_has_memory
)
1510 /* Traceframes are effectively a substitute for the live inferior. */
1511 if (get_traceframe_number () < 0)
1513 /* No current inferior, no frame. */
1514 if (ptid_equal (inferior_ptid
, null_ptid
))
1517 /* Don't try to read from a dead thread. */
1518 if (is_exited (inferior_ptid
))
1521 /* ... or from a spinning thread. */
1522 if (is_executing (inferior_ptid
))
1529 /* Return the selected frame. Always non-NULL (unless there isn't an
1530 inferior sufficient for creating a frame) in which case an error is
1534 get_selected_frame (const char *message
)
1536 if (selected_frame
== NULL
)
1538 if (message
!= NULL
&& !has_stack_frames ())
1539 error (("%s"), message
);
1540 /* Hey! Don't trust this. It should really be re-finding the
1541 last selected frame of the currently selected thread. This,
1542 though, is better than nothing. */
1543 select_frame (get_current_frame ());
1545 /* There is always a frame. */
1546 gdb_assert (selected_frame
!= NULL
);
1547 return selected_frame
;
1550 /* If there is a selected frame, return it. Otherwise, return NULL. */
1553 get_selected_frame_if_set (void)
1555 return selected_frame
;
1558 /* This is a variant of get_selected_frame() which can be called when
1559 the inferior does not have a frame; in that case it will return
1560 NULL instead of calling error(). */
1563 deprecated_safe_get_selected_frame (void)
1565 if (!has_stack_frames ())
1567 return get_selected_frame (NULL
);
1570 /* Select frame FI (or NULL - to invalidate the current frame). */
1573 select_frame (struct frame_info
*fi
)
1575 selected_frame
= fi
;
1576 /* NOTE: cagney/2002-05-04: FI can be NULL. This occurs when the
1577 frame is being invalidated. */
1578 if (deprecated_selected_frame_level_changed_hook
)
1579 deprecated_selected_frame_level_changed_hook (frame_relative_level (fi
));
1581 /* FIXME: kseitz/2002-08-28: It would be nice to call
1582 selected_frame_level_changed_event() right here, but due to limitations
1583 in the current interfaces, we would end up flooding UIs with events
1584 because select_frame() is used extensively internally.
1586 Once we have frame-parameterized frame (and frame-related) commands,
1587 the event notification can be moved here, since this function will only
1588 be called when the user's selected frame is being changed. */
1590 /* Ensure that symbols for this frame are read in. Also, determine the
1591 source language of this frame, and switch to it if desired. */
1596 /* We retrieve the frame's symtab by using the frame PC.
1597 However we cannot use the frame PC as-is, because it usually
1598 points to the instruction following the "call", which is
1599 sometimes the first instruction of another function. So we
1600 rely on get_frame_address_in_block() which provides us with a
1601 PC which is guaranteed to be inside the frame's code
1603 if (get_frame_address_in_block_if_available (fi
, &pc
))
1605 struct symtab
*s
= find_pc_symtab (pc
);
1608 && s
->language
!= current_language
->la_language
1609 && s
->language
!= language_unknown
1610 && language_mode
== language_mode_auto
)
1611 set_language (s
->language
);
1616 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
1617 Always returns a non-NULL value. */
1620 create_new_frame (CORE_ADDR addr
, CORE_ADDR pc
)
1622 struct frame_info
*fi
;
1626 fprintf_unfiltered (gdb_stdlog
,
1627 "{ create_new_frame (addr=%s, pc=%s) ",
1628 hex_string (addr
), hex_string (pc
));
1631 fi
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1633 fi
->next
= create_sentinel_frame (current_program_space
,
1634 get_current_regcache ());
1636 /* Set/update this frame's cached PC value, found in the next frame.
1637 Do this before looking for this frame's unwinder. A sniffer is
1638 very likely to read this, and the corresponding unwinder is
1639 entitled to rely that the PC doesn't magically change. */
1640 fi
->next
->prev_pc
.value
= pc
;
1641 fi
->next
->prev_pc
.status
= CC_VALUE
;
1643 /* We currently assume that frame chain's can't cross spaces. */
1644 fi
->pspace
= fi
->next
->pspace
;
1645 fi
->aspace
= fi
->next
->aspace
;
1647 /* Select/initialize both the unwind function and the frame's type
1649 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
1652 fi
->this_id
.value
= frame_id_build (addr
, pc
);
1656 fprintf_unfiltered (gdb_stdlog
, "-> ");
1657 fprint_frame (gdb_stdlog
, fi
);
1658 fprintf_unfiltered (gdb_stdlog
, " }\n");
1664 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
1665 innermost frame). Be careful to not fall off the bottom of the
1666 frame chain and onto the sentinel frame. */
1669 get_next_frame (struct frame_info
*this_frame
)
1671 if (this_frame
->level
> 0)
1672 return this_frame
->next
;
1677 /* Observer for the target_changed event. */
1680 frame_observer_target_changed (struct target_ops
*target
)
1682 reinit_frame_cache ();
1685 /* Flush the entire frame cache. */
1688 reinit_frame_cache (void)
1690 struct frame_info
*fi
;
1692 /* Tear down all frame caches. */
1693 for (fi
= current_frame
; fi
!= NULL
; fi
= fi
->prev
)
1695 if (fi
->prologue_cache
&& fi
->unwind
->dealloc_cache
)
1696 fi
->unwind
->dealloc_cache (fi
, fi
->prologue_cache
);
1697 if (fi
->base_cache
&& fi
->base
->unwind
->dealloc_cache
)
1698 fi
->base
->unwind
->dealloc_cache (fi
, fi
->base_cache
);
1701 /* Since we can't really be sure what the first object allocated was. */
1702 obstack_free (&frame_cache_obstack
, 0);
1703 obstack_init (&frame_cache_obstack
);
1705 if (current_frame
!= NULL
)
1706 annotate_frames_invalid ();
1708 current_frame
= NULL
; /* Invalidate cache */
1709 select_frame (NULL
);
1710 frame_stash_invalidate ();
1712 fprintf_unfiltered (gdb_stdlog
, "{ reinit_frame_cache () }\n");
1715 /* Find where a register is saved (in memory or another register).
1716 The result of frame_register_unwind is just where it is saved
1717 relative to this particular frame. */
1720 frame_register_unwind_location (struct frame_info
*this_frame
, int regnum
,
1721 int *optimizedp
, enum lval_type
*lvalp
,
1722 CORE_ADDR
*addrp
, int *realnump
)
1724 gdb_assert (this_frame
== NULL
|| this_frame
->level
>= 0);
1726 while (this_frame
!= NULL
)
1730 frame_register_unwind (this_frame
, regnum
, optimizedp
, &unavailable
,
1731 lvalp
, addrp
, realnump
, NULL
);
1736 if (*lvalp
!= lval_register
)
1740 this_frame
= get_next_frame (this_frame
);
1744 /* Called during frame unwinding to remove a previous frame pointer from a
1745 frame passed in ARG. */
1748 remove_prev_frame (void *arg
)
1750 struct frame_info
*this_frame
, *prev_frame
;
1752 this_frame
= (struct frame_info
*) arg
;
1753 prev_frame
= this_frame
->prev
;
1754 gdb_assert (prev_frame
!= NULL
);
1756 prev_frame
->next
= NULL
;
1757 this_frame
->prev
= NULL
;
1760 /* Get the previous raw frame, and check that it is not identical to
1761 same other frame frame already in the chain. If it is, there is
1762 most likely a stack cycle, so we discard it, and mark THIS_FRAME as
1763 outermost, with UNWIND_SAME_ID stop reason. Unlike the other
1764 validity tests, that compare THIS_FRAME and the next frame, we do
1765 this right after creating the previous frame, to avoid ever ending
1766 up with two frames with the same id in the frame chain. */
1768 static struct frame_info
*
1769 get_prev_frame_if_no_cycle (struct frame_info
*this_frame
)
1771 struct frame_info
*prev_frame
;
1772 struct cleanup
*prev_frame_cleanup
;
1774 prev_frame
= get_prev_frame_raw (this_frame
);
1775 if (prev_frame
== NULL
)
1778 /* The cleanup will remove the previous frame that get_prev_frame_raw
1779 linked onto THIS_FRAME. */
1780 prev_frame_cleanup
= make_cleanup (remove_prev_frame
, this_frame
);
1782 compute_frame_id (prev_frame
);
1783 if (!frame_stash_add (prev_frame
))
1785 /* Another frame with the same id was already in the stash. We just
1786 detected a cycle. */
1789 fprintf_unfiltered (gdb_stdlog
, "-> ");
1790 fprint_frame (gdb_stdlog
, NULL
);
1791 fprintf_unfiltered (gdb_stdlog
, " // this frame has same ID }\n");
1793 this_frame
->stop_reason
= UNWIND_SAME_ID
;
1795 prev_frame
->next
= NULL
;
1796 this_frame
->prev
= NULL
;
1800 discard_cleanups (prev_frame_cleanup
);
1804 /* Helper function for get_prev_frame_always, this is called inside a
1805 TRY_CATCH block. Return the frame that called THIS_FRAME or NULL if
1806 there is no such frame. This may throw an exception. */
1808 static struct frame_info
*
1809 get_prev_frame_always_1 (struct frame_info
*this_frame
)
1811 struct gdbarch
*gdbarch
;
1813 gdb_assert (this_frame
!= NULL
);
1814 gdbarch
= get_frame_arch (this_frame
);
1818 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame_always (this_frame=");
1819 if (this_frame
!= NULL
)
1820 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1822 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1823 fprintf_unfiltered (gdb_stdlog
, ") ");
1826 /* Only try to do the unwind once. */
1827 if (this_frame
->prev_p
)
1831 fprintf_unfiltered (gdb_stdlog
, "-> ");
1832 fprint_frame (gdb_stdlog
, this_frame
->prev
);
1833 fprintf_unfiltered (gdb_stdlog
, " // cached \n");
1835 return this_frame
->prev
;
1838 /* If the frame unwinder hasn't been selected yet, we must do so
1839 before setting prev_p; otherwise the check for misbehaved
1840 sniffers will think that this frame's sniffer tried to unwind
1841 further (see frame_cleanup_after_sniffer). */
1842 if (this_frame
->unwind
== NULL
)
1843 frame_unwind_find_by_frame (this_frame
, &this_frame
->prologue_cache
);
1845 this_frame
->prev_p
= 1;
1846 this_frame
->stop_reason
= UNWIND_NO_REASON
;
1848 /* If we are unwinding from an inline frame, all of the below tests
1849 were already performed when we unwound from the next non-inline
1850 frame. We must skip them, since we can not get THIS_FRAME's ID
1851 until we have unwound all the way down to the previous non-inline
1853 if (get_frame_type (this_frame
) == INLINE_FRAME
)
1854 return get_prev_frame_if_no_cycle (this_frame
);
1856 /* Check that this frame is unwindable. If it isn't, don't try to
1857 unwind to the prev frame. */
1858 this_frame
->stop_reason
1859 = this_frame
->unwind
->stop_reason (this_frame
,
1860 &this_frame
->prologue_cache
);
1862 if (this_frame
->stop_reason
!= UNWIND_NO_REASON
)
1866 enum unwind_stop_reason reason
= this_frame
->stop_reason
;
1868 fprintf_unfiltered (gdb_stdlog
, "-> ");
1869 fprint_frame (gdb_stdlog
, NULL
);
1870 fprintf_unfiltered (gdb_stdlog
, " // %s }\n",
1871 frame_stop_reason_symbol_string (reason
));
1876 /* Check that this frame's ID isn't inner to (younger, below, next)
1877 the next frame. This happens when a frame unwind goes backwards.
1878 This check is valid only if this frame and the next frame are NORMAL.
1879 See the comment at frame_id_inner for details. */
1880 if (get_frame_type (this_frame
) == NORMAL_FRAME
1881 && this_frame
->next
->unwind
->type
== NORMAL_FRAME
1882 && frame_id_inner (get_frame_arch (this_frame
->next
),
1883 get_frame_id (this_frame
),
1884 get_frame_id (this_frame
->next
)))
1886 CORE_ADDR this_pc_in_block
;
1887 struct minimal_symbol
*morestack_msym
;
1888 const char *morestack_name
= NULL
;
1890 /* gcc -fsplit-stack __morestack can continue the stack anywhere. */
1891 this_pc_in_block
= get_frame_address_in_block (this_frame
);
1892 morestack_msym
= lookup_minimal_symbol_by_pc (this_pc_in_block
).minsym
;
1894 morestack_name
= MSYMBOL_LINKAGE_NAME (morestack_msym
);
1895 if (!morestack_name
|| strcmp (morestack_name
, "__morestack") != 0)
1899 fprintf_unfiltered (gdb_stdlog
, "-> ");
1900 fprint_frame (gdb_stdlog
, NULL
);
1901 fprintf_unfiltered (gdb_stdlog
,
1902 " // this frame ID is inner }\n");
1904 this_frame
->stop_reason
= UNWIND_INNER_ID
;
1909 /* Check that this and the next frame do not unwind the PC register
1910 to the same memory location. If they do, then even though they
1911 have different frame IDs, the new frame will be bogus; two
1912 functions can't share a register save slot for the PC. This can
1913 happen when the prologue analyzer finds a stack adjustment, but
1916 This check does assume that the "PC register" is roughly a
1917 traditional PC, even if the gdbarch_unwind_pc method adjusts
1918 it (we do not rely on the value, only on the unwound PC being
1919 dependent on this value). A potential improvement would be
1920 to have the frame prev_pc method and the gdbarch unwind_pc
1921 method set the same lval and location information as
1922 frame_register_unwind. */
1923 if (this_frame
->level
> 0
1924 && gdbarch_pc_regnum (gdbarch
) >= 0
1925 && get_frame_type (this_frame
) == NORMAL_FRAME
1926 && (get_frame_type (this_frame
->next
) == NORMAL_FRAME
1927 || get_frame_type (this_frame
->next
) == INLINE_FRAME
))
1929 int optimized
, realnum
, nrealnum
;
1930 enum lval_type lval
, nlval
;
1931 CORE_ADDR addr
, naddr
;
1933 frame_register_unwind_location (this_frame
,
1934 gdbarch_pc_regnum (gdbarch
),
1935 &optimized
, &lval
, &addr
, &realnum
);
1936 frame_register_unwind_location (get_next_frame (this_frame
),
1937 gdbarch_pc_regnum (gdbarch
),
1938 &optimized
, &nlval
, &naddr
, &nrealnum
);
1940 if ((lval
== lval_memory
&& lval
== nlval
&& addr
== naddr
)
1941 || (lval
== lval_register
&& lval
== nlval
&& realnum
== nrealnum
))
1945 fprintf_unfiltered (gdb_stdlog
, "-> ");
1946 fprint_frame (gdb_stdlog
, NULL
);
1947 fprintf_unfiltered (gdb_stdlog
, " // no saved PC }\n");
1950 this_frame
->stop_reason
= UNWIND_NO_SAVED_PC
;
1951 this_frame
->prev
= NULL
;
1956 return get_prev_frame_if_no_cycle (this_frame
);
1959 /* Return a "struct frame_info" corresponding to the frame that called
1960 THIS_FRAME. Returns NULL if there is no such frame.
1962 Unlike get_prev_frame, this function always tries to unwind the
1966 get_prev_frame_always (struct frame_info
*this_frame
)
1968 volatile struct gdb_exception ex
;
1969 struct frame_info
*prev_frame
= NULL
;
1971 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
1973 prev_frame
= get_prev_frame_always_1 (this_frame
);
1977 if (ex
.error
== MEMORY_ERROR
)
1979 this_frame
->stop_reason
= UNWIND_MEMORY_ERROR
;
1980 if (ex
.message
!= NULL
)
1985 /* The error needs to live as long as the frame does.
1986 Allocate using stack local STOP_STRING then assign the
1987 pointer to the frame, this allows the STOP_STRING on the
1988 frame to be of type 'const char *'. */
1989 size
= strlen (ex
.message
) + 1;
1990 stop_string
= frame_obstack_zalloc (size
);
1991 memcpy (stop_string
, ex
.message
, size
);
1992 this_frame
->stop_string
= stop_string
;
1997 throw_exception (ex
);
2003 /* Construct a new "struct frame_info" and link it previous to
2006 static struct frame_info
*
2007 get_prev_frame_raw (struct frame_info
*this_frame
)
2009 struct frame_info
*prev_frame
;
2011 /* Allocate the new frame but do not wire it in to the frame chain.
2012 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
2013 frame->next to pull some fancy tricks (of course such code is, by
2014 definition, recursive). Try to prevent it.
2016 There is no reason to worry about memory leaks, should the
2017 remainder of the function fail. The allocated memory will be
2018 quickly reclaimed when the frame cache is flushed, and the `we've
2019 been here before' check above will stop repeated memory
2020 allocation calls. */
2021 prev_frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
2022 prev_frame
->level
= this_frame
->level
+ 1;
2024 /* For now, assume we don't have frame chains crossing address
2026 prev_frame
->pspace
= this_frame
->pspace
;
2027 prev_frame
->aspace
= this_frame
->aspace
;
2029 /* Don't yet compute ->unwind (and hence ->type). It is computed
2030 on-demand in get_frame_type, frame_register_unwind, and
2033 /* Don't yet compute the frame's ID. It is computed on-demand by
2036 /* The unwound frame ID is validate at the start of this function,
2037 as part of the logic to decide if that frame should be further
2038 unwound, and not here while the prev frame is being created.
2039 Doing this makes it possible for the user to examine a frame that
2040 has an invalid frame ID.
2042 Some very old VAX code noted: [...] For the sake of argument,
2043 suppose that the stack is somewhat trashed (which is one reason
2044 that "info frame" exists). So, return 0 (indicating we don't
2045 know the address of the arglist) if we don't know what frame this
2049 this_frame
->prev
= prev_frame
;
2050 prev_frame
->next
= this_frame
;
2054 fprintf_unfiltered (gdb_stdlog
, "-> ");
2055 fprint_frame (gdb_stdlog
, prev_frame
);
2056 fprintf_unfiltered (gdb_stdlog
, " }\n");
2062 /* Debug routine to print a NULL frame being returned. */
2065 frame_debug_got_null_frame (struct frame_info
*this_frame
,
2070 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame (this_frame=");
2071 if (this_frame
!= NULL
)
2072 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
2074 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
2075 fprintf_unfiltered (gdb_stdlog
, ") -> // %s}\n", reason
);
2079 /* Is this (non-sentinel) frame in the "main"() function? */
2082 inside_main_func (struct frame_info
*this_frame
)
2084 struct bound_minimal_symbol msymbol
;
2087 if (symfile_objfile
== 0)
2089 msymbol
= lookup_minimal_symbol (main_name (), NULL
, symfile_objfile
);
2090 if (msymbol
.minsym
== NULL
)
2092 /* Make certain that the code, and not descriptor, address is
2094 maddr
= gdbarch_convert_from_func_ptr_addr (get_frame_arch (this_frame
),
2095 BMSYMBOL_VALUE_ADDRESS (msymbol
),
2097 return maddr
== get_frame_func (this_frame
);
2100 /* Test whether THIS_FRAME is inside the process entry point function. */
2103 inside_entry_func (struct frame_info
*this_frame
)
2105 CORE_ADDR entry_point
;
2107 if (!entry_point_address_query (&entry_point
))
2110 return get_frame_func (this_frame
) == entry_point
;
2113 /* Return a structure containing various interesting information about
2114 the frame that called THIS_FRAME. Returns NULL if there is entier
2115 no such frame or the frame fails any of a set of target-independent
2116 condition that should terminate the frame chain (e.g., as unwinding
2119 This function should not contain target-dependent tests, such as
2120 checking whether the program-counter is zero. */
2123 get_prev_frame (struct frame_info
*this_frame
)
2128 /* There is always a frame. If this assertion fails, suspect that
2129 something should be calling get_selected_frame() or
2130 get_current_frame(). */
2131 gdb_assert (this_frame
!= NULL
);
2132 frame_pc_p
= get_frame_pc_if_available (this_frame
, &frame_pc
);
2134 /* tausq/2004-12-07: Dummy frames are skipped because it doesn't make much
2135 sense to stop unwinding at a dummy frame. One place where a dummy
2136 frame may have an address "inside_main_func" is on HPUX. On HPUX, the
2137 pcsqh register (space register for the instruction at the head of the
2138 instruction queue) cannot be written directly; the only way to set it
2139 is to branch to code that is in the target space. In order to implement
2140 frame dummies on HPUX, the called function is made to jump back to where
2141 the inferior was when the user function was called. If gdb was inside
2142 the main function when we created the dummy frame, the dummy frame will
2143 point inside the main function. */
2144 if (this_frame
->level
>= 0
2145 && get_frame_type (this_frame
) == NORMAL_FRAME
2146 && !backtrace_past_main
2148 && inside_main_func (this_frame
))
2149 /* Don't unwind past main(). Note, this is done _before_ the
2150 frame has been marked as previously unwound. That way if the
2151 user later decides to enable unwinds past main(), that will
2152 automatically happen. */
2154 frame_debug_got_null_frame (this_frame
, "inside main func");
2158 /* If the user's backtrace limit has been exceeded, stop. We must
2159 add two to the current level; one of those accounts for backtrace_limit
2160 being 1-based and the level being 0-based, and the other accounts for
2161 the level of the new frame instead of the level of the current
2163 if (this_frame
->level
+ 2 > backtrace_limit
)
2165 frame_debug_got_null_frame (this_frame
, "backtrace limit exceeded");
2169 /* If we're already inside the entry function for the main objfile,
2170 then it isn't valid. Don't apply this test to a dummy frame -
2171 dummy frame PCs typically land in the entry func. Don't apply
2172 this test to the sentinel frame. Sentinel frames should always
2173 be allowed to unwind. */
2174 /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() -
2175 wasn't checking for "main" in the minimal symbols. With that
2176 fixed asm-source tests now stop in "main" instead of halting the
2177 backtrace in weird and wonderful ways somewhere inside the entry
2178 file. Suspect that tests for inside the entry file/func were
2179 added to work around that (now fixed) case. */
2180 /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
2181 suggested having the inside_entry_func test use the
2182 inside_main_func() msymbol trick (along with entry_point_address()
2183 I guess) to determine the address range of the start function.
2184 That should provide a far better stopper than the current
2186 /* NOTE: tausq/2004-10-09: this is needed if, for example, the compiler
2187 applied tail-call optimizations to main so that a function called
2188 from main returns directly to the caller of main. Since we don't
2189 stop at main, we should at least stop at the entry point of the
2191 if (this_frame
->level
>= 0
2192 && get_frame_type (this_frame
) == NORMAL_FRAME
2193 && !backtrace_past_entry
2195 && inside_entry_func (this_frame
))
2197 frame_debug_got_null_frame (this_frame
, "inside entry func");
2201 /* Assume that the only way to get a zero PC is through something
2202 like a SIGSEGV or a dummy frame, and hence that NORMAL frames
2203 will never unwind a zero PC. */
2204 if (this_frame
->level
> 0
2205 && (get_frame_type (this_frame
) == NORMAL_FRAME
2206 || get_frame_type (this_frame
) == INLINE_FRAME
)
2207 && get_frame_type (get_next_frame (this_frame
)) == NORMAL_FRAME
2208 && frame_pc_p
&& frame_pc
== 0)
2210 frame_debug_got_null_frame (this_frame
, "zero PC");
2214 return get_prev_frame_always (this_frame
);
2218 get_frame_pc (struct frame_info
*frame
)
2220 gdb_assert (frame
->next
!= NULL
);
2221 return frame_unwind_pc (frame
->next
);
2225 get_frame_pc_if_available (struct frame_info
*frame
, CORE_ADDR
*pc
)
2227 volatile struct gdb_exception ex
;
2229 gdb_assert (frame
->next
!= NULL
);
2231 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2233 *pc
= frame_unwind_pc (frame
->next
);
2237 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2240 throw_exception (ex
);
2246 /* Return an address that falls within THIS_FRAME's code block. */
2249 get_frame_address_in_block (struct frame_info
*this_frame
)
2251 /* A draft address. */
2252 CORE_ADDR pc
= get_frame_pc (this_frame
);
2254 struct frame_info
*next_frame
= this_frame
->next
;
2256 /* Calling get_frame_pc returns the resume address for THIS_FRAME.
2257 Normally the resume address is inside the body of the function
2258 associated with THIS_FRAME, but there is a special case: when
2259 calling a function which the compiler knows will never return
2260 (for instance abort), the call may be the very last instruction
2261 in the calling function. The resume address will point after the
2262 call and may be at the beginning of a different function
2265 If THIS_FRAME is a signal frame or dummy frame, then we should
2266 not adjust the unwound PC. For a dummy frame, GDB pushed the
2267 resume address manually onto the stack. For a signal frame, the
2268 OS may have pushed the resume address manually and invoked the
2269 handler (e.g. GNU/Linux), or invoked the trampoline which called
2270 the signal handler - but in either case the signal handler is
2271 expected to return to the trampoline. So in both of these
2272 cases we know that the resume address is executable and
2273 related. So we only need to adjust the PC if THIS_FRAME
2274 is a normal function.
2276 If the program has been interrupted while THIS_FRAME is current,
2277 then clearly the resume address is inside the associated
2278 function. There are three kinds of interruption: debugger stop
2279 (next frame will be SENTINEL_FRAME), operating system
2280 signal or exception (next frame will be SIGTRAMP_FRAME),
2281 or debugger-induced function call (next frame will be
2282 DUMMY_FRAME). So we only need to adjust the PC if
2283 NEXT_FRAME is a normal function.
2285 We check the type of NEXT_FRAME first, since it is already
2286 known; frame type is determined by the unwinder, and since
2287 we have THIS_FRAME we've already selected an unwinder for
2290 If the next frame is inlined, we need to keep going until we find
2291 the real function - for instance, if a signal handler is invoked
2292 while in an inlined function, then the code address of the
2293 "calling" normal function should not be adjusted either. */
2295 while (get_frame_type (next_frame
) == INLINE_FRAME
)
2296 next_frame
= next_frame
->next
;
2298 if ((get_frame_type (next_frame
) == NORMAL_FRAME
2299 || get_frame_type (next_frame
) == TAILCALL_FRAME
)
2300 && (get_frame_type (this_frame
) == NORMAL_FRAME
2301 || get_frame_type (this_frame
) == TAILCALL_FRAME
2302 || get_frame_type (this_frame
) == INLINE_FRAME
))
2309 get_frame_address_in_block_if_available (struct frame_info
*this_frame
,
2312 volatile struct gdb_exception ex
;
2314 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2316 *pc
= get_frame_address_in_block (this_frame
);
2318 if (ex
.reason
< 0 && ex
.error
== NOT_AVAILABLE_ERROR
)
2320 else if (ex
.reason
< 0)
2321 throw_exception (ex
);
2327 find_frame_sal (struct frame_info
*frame
, struct symtab_and_line
*sal
)
2329 struct frame_info
*next_frame
;
2333 /* If the next frame represents an inlined function call, this frame's
2334 sal is the "call site" of that inlined function, which can not
2335 be inferred from get_frame_pc. */
2336 next_frame
= get_next_frame (frame
);
2337 if (frame_inlined_callees (frame
) > 0)
2342 sym
= get_frame_function (next_frame
);
2344 sym
= inline_skipped_symbol (inferior_ptid
);
2346 /* If frame is inline, it certainly has symbols. */
2349 if (SYMBOL_LINE (sym
) != 0)
2351 sal
->symtab
= SYMBOL_SYMTAB (sym
);
2352 sal
->line
= SYMBOL_LINE (sym
);
2355 /* If the symbol does not have a location, we don't know where
2356 the call site is. Do not pretend to. This is jarring, but
2357 we can't do much better. */
2358 sal
->pc
= get_frame_pc (frame
);
2360 sal
->pspace
= get_frame_program_space (frame
);
2365 /* If FRAME is not the innermost frame, that normally means that
2366 FRAME->pc points at the return instruction (which is *after* the
2367 call instruction), and we want to get the line containing the
2368 call (because the call is where the user thinks the program is).
2369 However, if the next frame is either a SIGTRAMP_FRAME or a
2370 DUMMY_FRAME, then the next frame will contain a saved interrupt
2371 PC and such a PC indicates the current (rather than next)
2372 instruction/line, consequently, for such cases, want to get the
2373 line containing fi->pc. */
2374 if (!get_frame_pc_if_available (frame
, &pc
))
2380 notcurrent
= (pc
!= get_frame_address_in_block (frame
));
2381 (*sal
) = find_pc_line (pc
, notcurrent
);
2384 /* Per "frame.h", return the ``address'' of the frame. Code should
2385 really be using get_frame_id(). */
2387 get_frame_base (struct frame_info
*fi
)
2389 return get_frame_id (fi
).stack_addr
;
2392 /* High-level offsets into the frame. Used by the debug info. */
2395 get_frame_base_address (struct frame_info
*fi
)
2397 if (get_frame_type (fi
) != NORMAL_FRAME
)
2399 if (fi
->base
== NULL
)
2400 fi
->base
= frame_base_find_by_frame (fi
);
2401 /* Sneaky: If the low-level unwind and high-level base code share a
2402 common unwinder, let them share the prologue cache. */
2403 if (fi
->base
->unwind
== fi
->unwind
)
2404 return fi
->base
->this_base (fi
, &fi
->prologue_cache
);
2405 return fi
->base
->this_base (fi
, &fi
->base_cache
);
2409 get_frame_locals_address (struct frame_info
*fi
)
2411 if (get_frame_type (fi
) != NORMAL_FRAME
)
2413 /* If there isn't a frame address method, find it. */
2414 if (fi
->base
== NULL
)
2415 fi
->base
= frame_base_find_by_frame (fi
);
2416 /* Sneaky: If the low-level unwind and high-level base code share a
2417 common unwinder, let them share the prologue cache. */
2418 if (fi
->base
->unwind
== fi
->unwind
)
2419 return fi
->base
->this_locals (fi
, &fi
->prologue_cache
);
2420 return fi
->base
->this_locals (fi
, &fi
->base_cache
);
2424 get_frame_args_address (struct frame_info
*fi
)
2426 if (get_frame_type (fi
) != NORMAL_FRAME
)
2428 /* If there isn't a frame address method, find it. */
2429 if (fi
->base
== NULL
)
2430 fi
->base
= frame_base_find_by_frame (fi
);
2431 /* Sneaky: If the low-level unwind and high-level base code share a
2432 common unwinder, let them share the prologue cache. */
2433 if (fi
->base
->unwind
== fi
->unwind
)
2434 return fi
->base
->this_args (fi
, &fi
->prologue_cache
);
2435 return fi
->base
->this_args (fi
, &fi
->base_cache
);
2438 /* Return true if the frame unwinder for frame FI is UNWINDER; false
2442 frame_unwinder_is (struct frame_info
*fi
, const struct frame_unwind
*unwinder
)
2444 if (fi
->unwind
== NULL
)
2445 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
2446 return fi
->unwind
== unwinder
;
2449 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
2450 or -1 for a NULL frame. */
2453 frame_relative_level (struct frame_info
*fi
)
2462 get_frame_type (struct frame_info
*frame
)
2464 if (frame
->unwind
== NULL
)
2465 /* Initialize the frame's unwinder because that's what
2466 provides the frame's type. */
2467 frame_unwind_find_by_frame (frame
, &frame
->prologue_cache
);
2468 return frame
->unwind
->type
;
2471 struct program_space
*
2472 get_frame_program_space (struct frame_info
*frame
)
2474 return frame
->pspace
;
2477 struct program_space
*
2478 frame_unwind_program_space (struct frame_info
*this_frame
)
2480 gdb_assert (this_frame
);
2482 /* This is really a placeholder to keep the API consistent --- we
2483 assume for now that we don't have frame chains crossing
2485 return this_frame
->pspace
;
2488 struct address_space
*
2489 get_frame_address_space (struct frame_info
*frame
)
2491 return frame
->aspace
;
2494 /* Memory access methods. */
2497 get_frame_memory (struct frame_info
*this_frame
, CORE_ADDR addr
,
2498 gdb_byte
*buf
, int len
)
2500 read_memory (addr
, buf
, len
);
2504 get_frame_memory_signed (struct frame_info
*this_frame
, CORE_ADDR addr
,
2507 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2508 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2510 return read_memory_integer (addr
, len
, byte_order
);
2514 get_frame_memory_unsigned (struct frame_info
*this_frame
, CORE_ADDR addr
,
2517 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2518 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2520 return read_memory_unsigned_integer (addr
, len
, byte_order
);
2524 safe_frame_unwind_memory (struct frame_info
*this_frame
,
2525 CORE_ADDR addr
, gdb_byte
*buf
, int len
)
2527 /* NOTE: target_read_memory returns zero on success! */
2528 return !target_read_memory (addr
, buf
, len
);
2531 /* Architecture methods. */
2534 get_frame_arch (struct frame_info
*this_frame
)
2536 return frame_unwind_arch (this_frame
->next
);
2540 frame_unwind_arch (struct frame_info
*next_frame
)
2542 if (!next_frame
->prev_arch
.p
)
2544 struct gdbarch
*arch
;
2546 if (next_frame
->unwind
== NULL
)
2547 frame_unwind_find_by_frame (next_frame
, &next_frame
->prologue_cache
);
2549 if (next_frame
->unwind
->prev_arch
!= NULL
)
2550 arch
= next_frame
->unwind
->prev_arch (next_frame
,
2551 &next_frame
->prologue_cache
);
2553 arch
= get_frame_arch (next_frame
);
2555 next_frame
->prev_arch
.arch
= arch
;
2556 next_frame
->prev_arch
.p
= 1;
2558 fprintf_unfiltered (gdb_stdlog
,
2559 "{ frame_unwind_arch (next_frame=%d) -> %s }\n",
2561 gdbarch_bfd_arch_info (arch
)->printable_name
);
2564 return next_frame
->prev_arch
.arch
;
2568 frame_unwind_caller_arch (struct frame_info
*next_frame
)
2570 return frame_unwind_arch (skip_artificial_frames (next_frame
));
2573 /* Stack pointer methods. */
2576 get_frame_sp (struct frame_info
*this_frame
)
2578 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2580 /* Normality - an architecture that provides a way of obtaining any
2581 frame inner-most address. */
2582 if (gdbarch_unwind_sp_p (gdbarch
))
2583 /* NOTE drow/2008-06-28: gdbarch_unwind_sp could be converted to
2584 operate on THIS_FRAME now. */
2585 return gdbarch_unwind_sp (gdbarch
, this_frame
->next
);
2586 /* Now things are really are grim. Hope that the value returned by
2587 the gdbarch_sp_regnum register is meaningful. */
2588 if (gdbarch_sp_regnum (gdbarch
) >= 0)
2589 return get_frame_register_unsigned (this_frame
,
2590 gdbarch_sp_regnum (gdbarch
));
2591 internal_error (__FILE__
, __LINE__
, _("Missing unwind SP method"));
2594 /* Return the reason why we can't unwind past FRAME. */
2596 enum unwind_stop_reason
2597 get_frame_unwind_stop_reason (struct frame_info
*frame
)
2599 /* Fill-in STOP_REASON. */
2600 get_prev_frame_always (frame
);
2601 gdb_assert (frame
->prev_p
);
2603 return frame
->stop_reason
;
2606 /* Return a string explaining REASON. */
2609 unwind_stop_reason_to_string (enum unwind_stop_reason reason
)
2613 #define SET(name, description) \
2614 case name: return _(description);
2615 #include "unwind_stop_reasons.def"
2619 internal_error (__FILE__
, __LINE__
,
2620 "Invalid frame stop reason");
2625 frame_stop_reason_string (struct frame_info
*fi
)
2627 gdb_assert (fi
->prev_p
);
2628 gdb_assert (fi
->prev
== NULL
);
2630 /* Return the specific string if we have one. */
2631 if (fi
->stop_string
!= NULL
)
2632 return fi
->stop_string
;
2634 /* Return the generic string if we have nothing better. */
2635 return unwind_stop_reason_to_string (fi
->stop_reason
);
2638 /* Return the enum symbol name of REASON as a string, to use in debug
2642 frame_stop_reason_symbol_string (enum unwind_stop_reason reason
)
2646 #define SET(name, description) \
2647 case name: return #name;
2648 #include "unwind_stop_reasons.def"
2652 internal_error (__FILE__
, __LINE__
,
2653 "Invalid frame stop reason");
2657 /* Clean up after a failed (wrong unwinder) attempt to unwind past
2661 frame_cleanup_after_sniffer (void *arg
)
2663 struct frame_info
*frame
= arg
;
2665 /* The sniffer should not allocate a prologue cache if it did not
2666 match this frame. */
2667 gdb_assert (frame
->prologue_cache
== NULL
);
2669 /* No sniffer should extend the frame chain; sniff based on what is
2671 gdb_assert (!frame
->prev_p
);
2673 /* The sniffer should not check the frame's ID; that's circular. */
2674 gdb_assert (!frame
->this_id
.p
);
2676 /* Clear cached fields dependent on the unwinder.
2678 The previous PC is independent of the unwinder, but the previous
2679 function is not (see get_frame_address_in_block). */
2680 frame
->prev_func
.p
= 0;
2681 frame
->prev_func
.addr
= 0;
2683 /* Discard the unwinder last, so that we can easily find it if an assertion
2684 in this function triggers. */
2685 frame
->unwind
= NULL
;
2688 /* Set FRAME's unwinder temporarily, so that we can call a sniffer.
2689 Return a cleanup which should be called if unwinding fails, and
2690 discarded if it succeeds. */
2693 frame_prepare_for_sniffer (struct frame_info
*frame
,
2694 const struct frame_unwind
*unwind
)
2696 gdb_assert (frame
->unwind
== NULL
);
2697 frame
->unwind
= unwind
;
2698 return make_cleanup (frame_cleanup_after_sniffer
, frame
);
2701 extern initialize_file_ftype _initialize_frame
; /* -Wmissing-prototypes */
2703 static struct cmd_list_element
*set_backtrace_cmdlist
;
2704 static struct cmd_list_element
*show_backtrace_cmdlist
;
2707 set_backtrace_cmd (char *args
, int from_tty
)
2709 help_list (set_backtrace_cmdlist
, "set backtrace ", all_commands
,
2714 show_backtrace_cmd (char *args
, int from_tty
)
2716 cmd_show_list (show_backtrace_cmdlist
, from_tty
, "");
2720 _initialize_frame (void)
2722 obstack_init (&frame_cache_obstack
);
2724 frame_stash_create ();
2726 observer_attach_target_changed (frame_observer_target_changed
);
2728 add_prefix_cmd ("backtrace", class_maintenance
, set_backtrace_cmd
, _("\
2729 Set backtrace specific variables.\n\
2730 Configure backtrace variables such as the backtrace limit"),
2731 &set_backtrace_cmdlist
, "set backtrace ",
2732 0/*allow-unknown*/, &setlist
);
2733 add_prefix_cmd ("backtrace", class_maintenance
, show_backtrace_cmd
, _("\
2734 Show backtrace specific variables\n\
2735 Show backtrace variables such as the backtrace limit"),
2736 &show_backtrace_cmdlist
, "show backtrace ",
2737 0/*allow-unknown*/, &showlist
);
2739 add_setshow_boolean_cmd ("past-main", class_obscure
,
2740 &backtrace_past_main
, _("\
2741 Set whether backtraces should continue past \"main\"."), _("\
2742 Show whether backtraces should continue past \"main\"."), _("\
2743 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
2744 the backtrace at \"main\". Set this variable if you need to see the rest\n\
2745 of the stack trace."),
2747 show_backtrace_past_main
,
2748 &set_backtrace_cmdlist
,
2749 &show_backtrace_cmdlist
);
2751 add_setshow_boolean_cmd ("past-entry", class_obscure
,
2752 &backtrace_past_entry
, _("\
2753 Set whether backtraces should continue past the entry point of a program."),
2755 Show whether backtraces should continue past the entry point of a program."),
2757 Normally there are no callers beyond the entry point of a program, so GDB\n\
2758 will terminate the backtrace there. Set this variable if you need to see\n\
2759 the rest of the stack trace."),
2761 show_backtrace_past_entry
,
2762 &set_backtrace_cmdlist
,
2763 &show_backtrace_cmdlist
);
2765 add_setshow_uinteger_cmd ("limit", class_obscure
,
2766 &backtrace_limit
, _("\
2767 Set an upper bound on the number of backtrace levels."), _("\
2768 Show the upper bound on the number of backtrace levels."), _("\
2769 No more than the specified number of frames can be displayed or examined.\n\
2770 Literal \"unlimited\" or zero means no limit."),
2772 show_backtrace_limit
,
2773 &set_backtrace_cmdlist
,
2774 &show_backtrace_cmdlist
);
2776 /* Debug this files internals. */
2777 add_setshow_zuinteger_cmd ("frame", class_maintenance
, &frame_debug
, _("\
2778 Set frame debugging."), _("\
2779 Show frame debugging."), _("\
2780 When non-zero, frame specific internal debugging is enabled."),
2783 &setdebuglist
, &showdebuglist
);