1 /* Cache and manage frames for GDB, the GNU debugger.
3 Copyright (C) 1986-2013 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"
48 static struct frame_info
*get_prev_frame_1 (struct frame_info
*this_frame
);
49 static struct frame_info
*get_prev_frame_raw (struct frame_info
*this_frame
);
51 /* We keep a cache of stack frames, each of which is a "struct
52 frame_info". The innermost one gets allocated (in
53 wait_for_inferior) each time the inferior stops; current_frame
54 points to it. Additional frames get allocated (in get_prev_frame)
55 as needed, and are chained through the next and prev fields. Any
56 time that the frame cache becomes invalid (most notably when we
57 execute something, but also if we change how we interpret the
58 frames (e.g. "set heuristic-fence-post" in mips-tdep.c, or anything
59 which reads new symbols)), we should call reinit_frame_cache. */
63 /* Level of this frame. The inner-most (youngest) frame is at level
64 0. As you move towards the outer-most (oldest) frame, the level
65 increases. This is a cached value. It could just as easily be
66 computed by counting back from the selected frame to the inner
68 /* NOTE: cagney/2002-04-05: Perhaps a level of ``-1'' should be
69 reserved to indicate a bogus frame - one that has been created
70 just to keep GDB happy (GDB always needs a frame). For the
71 moment leave this as speculation. */
74 /* The frame's program space. */
75 struct program_space
*pspace
;
77 /* The frame's address space. */
78 struct address_space
*aspace
;
80 /* The frame's low-level unwinder and corresponding cache. The
81 low-level unwinder is responsible for unwinding register values
82 for the previous frame. The low-level unwind methods are
83 selected based on the presence, or otherwise, of register unwind
84 information such as CFI. */
86 const struct frame_unwind
*unwind
;
88 /* Cached copy of the previous frame's architecture. */
95 /* Cached copy of the previous frame's resume address. */
101 /* Cached copy of the previous frame's function address. */
108 /* This frame's ID. */
112 struct frame_id value
;
115 /* The frame's high-level base methods, and corresponding cache.
116 The high level base methods are selected based on the frame's
118 const struct frame_base
*base
;
121 /* Pointers to the next (down, inner, younger) and previous (up,
122 outer, older) frame_info's in the frame cache. */
123 struct frame_info
*next
; /* down, inner, younger */
125 struct frame_info
*prev
; /* up, outer, older */
127 /* The reason why we could not set PREV, or UNWIND_NO_REASON if we
128 could. Only valid when PREV_P is set. */
129 enum unwind_stop_reason stop_reason
;
132 /* A frame stash used to speed up frame lookups. Create a hash table
133 to stash frames previously accessed from the frame cache for
134 quicker subsequent retrieval. The hash table is emptied whenever
135 the frame cache is invalidated. */
137 static htab_t frame_stash
;
139 /* Internal function to calculate a hash from the frame_id addresses,
140 using as many valid addresses as possible. Frames below level 0
141 are not stored in the hash table. */
144 frame_addr_hash (const void *ap
)
146 const struct frame_info
*frame
= ap
;
147 const struct frame_id f_id
= frame
->this_id
.value
;
150 gdb_assert (f_id
.stack_addr_p
|| f_id
.code_addr_p
151 || f_id
.special_addr_p
);
153 if (f_id
.stack_addr_p
)
154 hash
= iterative_hash (&f_id
.stack_addr
,
155 sizeof (f_id
.stack_addr
), hash
);
156 if (f_id
.code_addr_p
)
157 hash
= iterative_hash (&f_id
.code_addr
,
158 sizeof (f_id
.code_addr
), hash
);
159 if (f_id
.special_addr_p
)
160 hash
= iterative_hash (&f_id
.special_addr
,
161 sizeof (f_id
.special_addr
), hash
);
166 /* Internal equality function for the hash table. This function
167 defers equality operations to frame_id_eq. */
170 frame_addr_hash_eq (const void *a
, const void *b
)
172 const struct frame_info
*f_entry
= a
;
173 const struct frame_info
*f_element
= b
;
175 return frame_id_eq (f_entry
->this_id
.value
,
176 f_element
->this_id
.value
);
179 /* Internal function to create the frame_stash hash table. 100 seems
180 to be a good compromise to start the hash table at. */
183 frame_stash_create (void)
185 frame_stash
= htab_create (100,
191 /* Internal function to add a frame to the frame_stash hash table.
192 Returns false if a frame with the same ID was already stashed, true
196 frame_stash_add (struct frame_info
*frame
)
198 struct frame_info
**slot
;
200 /* Do not try to stash the sentinel frame. */
201 gdb_assert (frame
->level
>= 0);
203 slot
= (struct frame_info
**) htab_find_slot (frame_stash
,
207 /* If we already have a frame in the stack with the same id, we
208 either have a stack cycle (corrupted stack?), or some bug
209 elsewhere in GDB. In any case, ignore the duplicate and return
210 an indication to the caller. */
218 /* Internal function to search the frame stash for an entry with the
219 given frame ID. If found, return that frame. Otherwise return
222 static struct frame_info
*
223 frame_stash_find (struct frame_id id
)
225 struct frame_info dummy
;
226 struct frame_info
*frame
;
228 dummy
.this_id
.value
= id
;
229 frame
= htab_find (frame_stash
, &dummy
);
233 /* Internal function to invalidate the frame stash by removing all
234 entries in it. This only occurs when the frame cache is
238 frame_stash_invalidate (void)
240 htab_empty (frame_stash
);
243 /* Flag to control debugging. */
245 unsigned int frame_debug
;
247 show_frame_debug (struct ui_file
*file
, int from_tty
,
248 struct cmd_list_element
*c
, const char *value
)
250 fprintf_filtered (file
, _("Frame debugging is %s.\n"), value
);
253 /* Flag to indicate whether backtraces should stop at main et.al. */
255 static int backtrace_past_main
;
257 show_backtrace_past_main (struct ui_file
*file
, int from_tty
,
258 struct cmd_list_element
*c
, const char *value
)
260 fprintf_filtered (file
,
261 _("Whether backtraces should "
262 "continue past \"main\" is %s.\n"),
266 static int backtrace_past_entry
;
268 show_backtrace_past_entry (struct ui_file
*file
, int from_tty
,
269 struct cmd_list_element
*c
, const char *value
)
271 fprintf_filtered (file
, _("Whether backtraces should continue past the "
272 "entry point of a program is %s.\n"),
276 static unsigned int backtrace_limit
= UINT_MAX
;
278 show_backtrace_limit (struct ui_file
*file
, int from_tty
,
279 struct cmd_list_element
*c
, const char *value
)
281 fprintf_filtered (file
,
282 _("An upper bound on the number "
283 "of backtrace levels is %s.\n"),
289 fprint_field (struct ui_file
*file
, const char *name
, int p
, CORE_ADDR addr
)
292 fprintf_unfiltered (file
, "%s=%s", name
, hex_string (addr
));
294 fprintf_unfiltered (file
, "!%s", name
);
298 fprint_frame_id (struct ui_file
*file
, struct frame_id id
)
300 fprintf_unfiltered (file
, "{");
301 fprint_field (file
, "stack", id
.stack_addr_p
, id
.stack_addr
);
302 fprintf_unfiltered (file
, ",");
303 fprint_field (file
, "code", id
.code_addr_p
, id
.code_addr
);
304 fprintf_unfiltered (file
, ",");
305 fprint_field (file
, "special", id
.special_addr_p
, id
.special_addr
);
306 if (id
.artificial_depth
)
307 fprintf_unfiltered (file
, ",artificial=%d", id
.artificial_depth
);
308 fprintf_unfiltered (file
, "}");
312 fprint_frame_type (struct ui_file
*file
, enum frame_type type
)
317 fprintf_unfiltered (file
, "NORMAL_FRAME");
320 fprintf_unfiltered (file
, "DUMMY_FRAME");
323 fprintf_unfiltered (file
, "INLINE_FRAME");
326 fprintf_unfiltered (file
, "TAILCALL_FRAME");
329 fprintf_unfiltered (file
, "SIGTRAMP_FRAME");
332 fprintf_unfiltered (file
, "ARCH_FRAME");
335 fprintf_unfiltered (file
, "SENTINEL_FRAME");
338 fprintf_unfiltered (file
, "<unknown type>");
344 fprint_frame (struct ui_file
*file
, struct frame_info
*fi
)
348 fprintf_unfiltered (file
, "<NULL frame>");
351 fprintf_unfiltered (file
, "{");
352 fprintf_unfiltered (file
, "level=%d", fi
->level
);
353 fprintf_unfiltered (file
, ",");
354 fprintf_unfiltered (file
, "type=");
355 if (fi
->unwind
!= NULL
)
356 fprint_frame_type (file
, fi
->unwind
->type
);
358 fprintf_unfiltered (file
, "<unknown>");
359 fprintf_unfiltered (file
, ",");
360 fprintf_unfiltered (file
, "unwind=");
361 if (fi
->unwind
!= NULL
)
362 gdb_print_host_address (fi
->unwind
, file
);
364 fprintf_unfiltered (file
, "<unknown>");
365 fprintf_unfiltered (file
, ",");
366 fprintf_unfiltered (file
, "pc=");
367 if (fi
->next
!= NULL
&& fi
->next
->prev_pc
.p
)
368 fprintf_unfiltered (file
, "%s", hex_string (fi
->next
->prev_pc
.value
));
370 fprintf_unfiltered (file
, "<unknown>");
371 fprintf_unfiltered (file
, ",");
372 fprintf_unfiltered (file
, "id=");
374 fprint_frame_id (file
, fi
->this_id
.value
);
376 fprintf_unfiltered (file
, "<unknown>");
377 fprintf_unfiltered (file
, ",");
378 fprintf_unfiltered (file
, "func=");
379 if (fi
->next
!= NULL
&& fi
->next
->prev_func
.p
)
380 fprintf_unfiltered (file
, "%s", hex_string (fi
->next
->prev_func
.addr
));
382 fprintf_unfiltered (file
, "<unknown>");
383 fprintf_unfiltered (file
, "}");
386 /* Given FRAME, return the enclosing frame as found in real frames read-in from
387 inferior memory. Skip any previous frames which were made up by GDB.
388 Return the original frame if no immediate previous frames exist. */
390 static struct frame_info
*
391 skip_artificial_frames (struct frame_info
*frame
)
393 while (get_frame_type (frame
) == INLINE_FRAME
394 || get_frame_type (frame
) == TAILCALL_FRAME
)
395 frame
= get_prev_frame (frame
);
400 /* Compute the frame's uniq ID that can be used to, later, re-find the
404 compute_frame_id (struct frame_info
*fi
)
406 gdb_assert (!fi
->this_id
.p
);
409 fprintf_unfiltered (gdb_stdlog
, "{ compute_frame_id (fi=%d) ",
411 /* Find the unwinder. */
412 if (fi
->unwind
== NULL
)
413 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
414 /* Find THIS frame's ID. */
415 /* Default to outermost if no ID is found. */
416 fi
->this_id
.value
= outer_frame_id
;
417 fi
->unwind
->this_id (fi
, &fi
->prologue_cache
, &fi
->this_id
.value
);
418 gdb_assert (frame_id_p (fi
->this_id
.value
));
422 fprintf_unfiltered (gdb_stdlog
, "-> ");
423 fprint_frame_id (gdb_stdlog
, fi
->this_id
.value
);
424 fprintf_unfiltered (gdb_stdlog
, " }\n");
428 /* Return a frame uniq ID that can be used to, later, re-find the
432 get_frame_id (struct frame_info
*fi
)
435 return null_frame_id
;
437 gdb_assert (fi
->this_id
.p
);
438 return fi
->this_id
.value
;
442 get_stack_frame_id (struct frame_info
*next_frame
)
444 return get_frame_id (skip_artificial_frames (next_frame
));
448 frame_unwind_caller_id (struct frame_info
*next_frame
)
450 struct frame_info
*this_frame
;
452 /* Use get_prev_frame_1, and not get_prev_frame. The latter will truncate
453 the frame chain, leading to this function unintentionally
454 returning a null_frame_id (e.g., when a caller requests the frame
455 ID of "main()"s caller. */
457 next_frame
= skip_artificial_frames (next_frame
);
458 this_frame
= get_prev_frame_1 (next_frame
);
460 return get_frame_id (skip_artificial_frames (this_frame
));
462 return null_frame_id
;
465 const struct frame_id null_frame_id
; /* All zeros. */
466 const struct frame_id outer_frame_id
= { 0, 0, 0, 0, 0, 1, 0 };
469 frame_id_build_special (CORE_ADDR stack_addr
, CORE_ADDR code_addr
,
470 CORE_ADDR special_addr
)
472 struct frame_id id
= null_frame_id
;
474 id
.stack_addr
= stack_addr
;
476 id
.code_addr
= code_addr
;
478 id
.special_addr
= special_addr
;
479 id
.special_addr_p
= 1;
484 frame_id_build (CORE_ADDR stack_addr
, CORE_ADDR code_addr
)
486 struct frame_id id
= null_frame_id
;
488 id
.stack_addr
= stack_addr
;
490 id
.code_addr
= code_addr
;
496 frame_id_build_wild (CORE_ADDR stack_addr
)
498 struct frame_id id
= null_frame_id
;
500 id
.stack_addr
= stack_addr
;
506 frame_id_p (struct frame_id l
)
510 /* The frame is valid iff it has a valid stack address. */
512 /* outer_frame_id is also valid. */
513 if (!p
&& memcmp (&l
, &outer_frame_id
, sizeof (l
)) == 0)
517 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_p (l=");
518 fprint_frame_id (gdb_stdlog
, l
);
519 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", p
);
525 frame_id_artificial_p (struct frame_id l
)
530 return (l
.artificial_depth
!= 0);
534 frame_id_eq (struct frame_id l
, struct frame_id r
)
538 if (!l
.stack_addr_p
&& l
.special_addr_p
539 && !r
.stack_addr_p
&& r
.special_addr_p
)
540 /* The outermost frame marker is equal to itself. This is the
541 dodgy thing about outer_frame_id, since between execution steps
542 we might step into another function - from which we can't
543 unwind either. More thought required to get rid of
546 else if (!l
.stack_addr_p
|| !r
.stack_addr_p
)
547 /* Like a NaN, if either ID is invalid, the result is false.
548 Note that a frame ID is invalid iff it is the null frame ID. */
550 else if (l
.stack_addr
!= r
.stack_addr
)
551 /* If .stack addresses are different, the frames are different. */
553 else if (l
.code_addr_p
&& r
.code_addr_p
&& l
.code_addr
!= r
.code_addr
)
554 /* An invalid code addr is a wild card. If .code addresses are
555 different, the frames are different. */
557 else if (l
.special_addr_p
&& r
.special_addr_p
558 && l
.special_addr
!= r
.special_addr
)
559 /* An invalid special addr is a wild card (or unused). Otherwise
560 if special addresses are different, the frames are different. */
562 else if (l
.artificial_depth
!= r
.artificial_depth
)
563 /* If artifical depths are different, the frames must be different. */
566 /* Frames are equal. */
571 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_eq (l=");
572 fprint_frame_id (gdb_stdlog
, l
);
573 fprintf_unfiltered (gdb_stdlog
, ",r=");
574 fprint_frame_id (gdb_stdlog
, r
);
575 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", eq
);
580 /* Safety net to check whether frame ID L should be inner to
581 frame ID R, according to their stack addresses.
583 This method cannot be used to compare arbitrary frames, as the
584 ranges of valid stack addresses may be discontiguous (e.g. due
587 However, it can be used as safety net to discover invalid frame
588 IDs in certain circumstances. Assuming that NEXT is the immediate
589 inner frame to THIS and that NEXT and THIS are both NORMAL frames:
591 * The stack address of NEXT must be inner-than-or-equal to the stack
594 Therefore, if frame_id_inner (THIS, NEXT) holds, some unwind
597 * If NEXT and THIS have different stack addresses, no other frame
598 in the frame chain may have a stack address in between.
600 Therefore, if frame_id_inner (TEST, THIS) holds, but
601 frame_id_inner (TEST, NEXT) does not hold, TEST cannot refer
602 to a valid frame in the frame chain.
604 The sanity checks above cannot be performed when a SIGTRAMP frame
605 is involved, because signal handlers might be executed on a different
606 stack than the stack used by the routine that caused the signal
607 to be raised. This can happen for instance when a thread exceeds
608 its maximum stack size. In this case, certain compilers implement
609 a stack overflow strategy that cause the handler to be run on a
613 frame_id_inner (struct gdbarch
*gdbarch
, struct frame_id l
, struct frame_id r
)
617 if (!l
.stack_addr_p
|| !r
.stack_addr_p
)
618 /* Like NaN, any operation involving an invalid ID always fails. */
620 else if (l
.artificial_depth
> r
.artificial_depth
621 && l
.stack_addr
== r
.stack_addr
622 && l
.code_addr_p
== r
.code_addr_p
623 && l
.special_addr_p
== r
.special_addr_p
624 && l
.special_addr
== r
.special_addr
)
626 /* Same function, different inlined functions. */
627 struct block
*lb
, *rb
;
629 gdb_assert (l
.code_addr_p
&& r
.code_addr_p
);
631 lb
= block_for_pc (l
.code_addr
);
632 rb
= block_for_pc (r
.code_addr
);
634 if (lb
== NULL
|| rb
== NULL
)
635 /* Something's gone wrong. */
638 /* This will return true if LB and RB are the same block, or
639 if the block with the smaller depth lexically encloses the
640 block with the greater depth. */
641 inner
= contained_in (lb
, rb
);
644 /* Only return non-zero when strictly inner than. Note that, per
645 comment in "frame.h", there is some fuzz here. Frameless
646 functions are not strictly inner than (same .stack but
647 different .code and/or .special address). */
648 inner
= gdbarch_inner_than (gdbarch
, l
.stack_addr
, r
.stack_addr
);
651 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_inner (l=");
652 fprint_frame_id (gdb_stdlog
, l
);
653 fprintf_unfiltered (gdb_stdlog
, ",r=");
654 fprint_frame_id (gdb_stdlog
, r
);
655 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", inner
);
661 frame_find_by_id (struct frame_id id
)
663 struct frame_info
*frame
, *prev_frame
;
665 /* ZERO denotes the null frame, let the caller decide what to do
666 about it. Should it instead return get_current_frame()? */
667 if (!frame_id_p (id
))
670 /* Try using the frame stash first. Finding it there removes the need
671 to perform the search by looping over all frames, which can be very
672 CPU-intensive if the number of frames is very high (the loop is O(n)
673 and get_prev_frame performs a series of checks that are relatively
674 expensive). This optimization is particularly useful when this function
675 is called from another function (such as value_fetch_lazy, case
676 VALUE_LVAL (val) == lval_register) which already loops over all frames,
677 making the overall behavior O(n^2). */
678 frame
= frame_stash_find (id
);
682 for (frame
= get_current_frame (); ; frame
= prev_frame
)
684 struct frame_id
this = get_frame_id (frame
);
686 if (frame_id_eq (id
, this))
687 /* An exact match. */
690 prev_frame
= get_prev_frame (frame
);
694 /* As a safety net to avoid unnecessary backtracing while trying
695 to find an invalid ID, we check for a common situation where
696 we can detect from comparing stack addresses that no other
697 frame in the current frame chain can have this ID. See the
698 comment at frame_id_inner for details. */
699 if (get_frame_type (frame
) == NORMAL_FRAME
700 && !frame_id_inner (get_frame_arch (frame
), id
, this)
701 && frame_id_inner (get_frame_arch (prev_frame
), id
,
702 get_frame_id (prev_frame
)))
709 frame_unwind_pc_if_available (struct frame_info
*this_frame
, CORE_ADDR
*pc
)
711 if (!this_frame
->prev_pc
.p
)
713 if (gdbarch_unwind_pc_p (frame_unwind_arch (this_frame
)))
715 volatile struct gdb_exception ex
;
716 struct gdbarch
*prev_gdbarch
;
719 /* The right way. The `pure' way. The one true way. This
720 method depends solely on the register-unwind code to
721 determine the value of registers in THIS frame, and hence
722 the value of this frame's PC (resume address). A typical
723 implementation is no more than:
725 frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
726 return extract_unsigned_integer (buf, size of ISA_PC_REGNUM);
728 Note: this method is very heavily dependent on a correct
729 register-unwind implementation, it pays to fix that
730 method first; this method is frame type agnostic, since
731 it only deals with register values, it works with any
732 frame. This is all in stark contrast to the old
733 FRAME_SAVED_PC which would try to directly handle all the
734 different ways that a PC could be unwound. */
735 prev_gdbarch
= frame_unwind_arch (this_frame
);
737 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
739 pc
= gdbarch_unwind_pc (prev_gdbarch
, this_frame
);
741 if (ex
.reason
< 0 && ex
.error
== NOT_AVAILABLE_ERROR
)
743 this_frame
->prev_pc
.p
= -1;
746 fprintf_unfiltered (gdb_stdlog
,
747 "{ frame_unwind_pc (this_frame=%d)"
748 " -> <unavailable> }\n",
751 else if (ex
.reason
< 0)
753 throw_exception (ex
);
757 this_frame
->prev_pc
.value
= pc
;
758 this_frame
->prev_pc
.p
= 1;
760 fprintf_unfiltered (gdb_stdlog
,
761 "{ frame_unwind_pc (this_frame=%d) "
764 hex_string (this_frame
->prev_pc
.value
));
768 internal_error (__FILE__
, __LINE__
, _("No unwind_pc method"));
770 if (this_frame
->prev_pc
.p
< 0)
777 *pc
= this_frame
->prev_pc
.value
;
783 frame_unwind_pc (struct frame_info
*this_frame
)
787 if (!frame_unwind_pc_if_available (this_frame
, &pc
))
788 throw_error (NOT_AVAILABLE_ERROR
, _("PC not available"));
794 frame_unwind_caller_pc (struct frame_info
*this_frame
)
796 return frame_unwind_pc (skip_artificial_frames (this_frame
));
800 frame_unwind_caller_pc_if_available (struct frame_info
*this_frame
,
803 return frame_unwind_pc_if_available (skip_artificial_frames (this_frame
), pc
);
807 get_frame_func_if_available (struct frame_info
*this_frame
, CORE_ADDR
*pc
)
809 struct frame_info
*next_frame
= this_frame
->next
;
811 if (!next_frame
->prev_func
.p
)
813 CORE_ADDR addr_in_block
;
815 /* Make certain that this, and not the adjacent, function is
817 if (!get_frame_address_in_block_if_available (this_frame
, &addr_in_block
))
819 next_frame
->prev_func
.p
= -1;
821 fprintf_unfiltered (gdb_stdlog
,
822 "{ get_frame_func (this_frame=%d)"
823 " -> unavailable }\n",
828 next_frame
->prev_func
.p
= 1;
829 next_frame
->prev_func
.addr
= get_pc_function_start (addr_in_block
);
831 fprintf_unfiltered (gdb_stdlog
,
832 "{ get_frame_func (this_frame=%d) -> %s }\n",
834 hex_string (next_frame
->prev_func
.addr
));
838 if (next_frame
->prev_func
.p
< 0)
845 *pc
= next_frame
->prev_func
.addr
;
851 get_frame_func (struct frame_info
*this_frame
)
855 if (!get_frame_func_if_available (this_frame
, &pc
))
856 throw_error (NOT_AVAILABLE_ERROR
, _("PC not available"));
861 static enum register_status
862 do_frame_register_read (void *src
, int regnum
, gdb_byte
*buf
)
864 if (!deprecated_frame_register_read (src
, regnum
, buf
))
865 return REG_UNAVAILABLE
;
871 frame_save_as_regcache (struct frame_info
*this_frame
)
873 struct address_space
*aspace
= get_frame_address_space (this_frame
);
874 struct regcache
*regcache
= regcache_xmalloc (get_frame_arch (this_frame
),
876 struct cleanup
*cleanups
= make_cleanup_regcache_xfree (regcache
);
878 regcache_save (regcache
, do_frame_register_read
, this_frame
);
879 discard_cleanups (cleanups
);
884 frame_pop (struct frame_info
*this_frame
)
886 struct frame_info
*prev_frame
;
887 struct regcache
*scratch
;
888 struct cleanup
*cleanups
;
890 if (get_frame_type (this_frame
) == DUMMY_FRAME
)
892 /* Popping a dummy frame involves restoring more than just registers.
893 dummy_frame_pop does all the work. */
894 dummy_frame_pop (get_frame_id (this_frame
));
898 /* Ensure that we have a frame to pop to. */
899 prev_frame
= get_prev_frame_1 (this_frame
);
902 error (_("Cannot pop the initial frame."));
904 /* Ignore TAILCALL_FRAME type frames, they were executed already before
905 entering THISFRAME. */
906 while (get_frame_type (prev_frame
) == TAILCALL_FRAME
)
907 prev_frame
= get_prev_frame (prev_frame
);
909 /* Make a copy of all the register values unwound from this frame.
910 Save them in a scratch buffer so that there isn't a race between
911 trying to extract the old values from the current regcache while
912 at the same time writing new values into that same cache. */
913 scratch
= frame_save_as_regcache (prev_frame
);
914 cleanups
= make_cleanup_regcache_xfree (scratch
);
916 /* FIXME: cagney/2003-03-16: It should be possible to tell the
917 target's register cache that it is about to be hit with a burst
918 register transfer and that the sequence of register writes should
919 be batched. The pair target_prepare_to_store() and
920 target_store_registers() kind of suggest this functionality.
921 Unfortunately, they don't implement it. Their lack of a formal
922 definition can lead to targets writing back bogus values
923 (arguably a bug in the target code mind). */
924 /* Now copy those saved registers into the current regcache.
925 Here, regcache_cpy() calls regcache_restore(). */
926 regcache_cpy (get_current_regcache (), scratch
);
927 do_cleanups (cleanups
);
929 /* We've made right mess of GDB's local state, just discard
931 reinit_frame_cache ();
935 frame_register_unwind (struct frame_info
*frame
, int regnum
,
936 int *optimizedp
, int *unavailablep
,
937 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
938 int *realnump
, gdb_byte
*bufferp
)
942 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
943 that the value proper does not need to be fetched. */
944 gdb_assert (optimizedp
!= NULL
);
945 gdb_assert (lvalp
!= NULL
);
946 gdb_assert (addrp
!= NULL
);
947 gdb_assert (realnump
!= NULL
);
948 /* gdb_assert (bufferp != NULL); */
950 value
= frame_unwind_register_value (frame
, regnum
);
952 gdb_assert (value
!= NULL
);
954 *optimizedp
= value_optimized_out (value
);
955 *unavailablep
= !value_entirely_available (value
);
956 *lvalp
= VALUE_LVAL (value
);
957 *addrp
= value_address (value
);
958 *realnump
= VALUE_REGNUM (value
);
962 if (!*optimizedp
&& !*unavailablep
)
963 memcpy (bufferp
, value_contents_all (value
),
964 TYPE_LENGTH (value_type (value
)));
966 memset (bufferp
, 0, TYPE_LENGTH (value_type (value
)));
969 /* Dispose of the new value. This prevents watchpoints from
970 trying to watch the saved frame pointer. */
971 release_value (value
);
976 frame_register (struct frame_info
*frame
, int regnum
,
977 int *optimizedp
, int *unavailablep
, enum lval_type
*lvalp
,
978 CORE_ADDR
*addrp
, int *realnump
, gdb_byte
*bufferp
)
980 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
981 that the value proper does not need to be fetched. */
982 gdb_assert (optimizedp
!= NULL
);
983 gdb_assert (lvalp
!= NULL
);
984 gdb_assert (addrp
!= NULL
);
985 gdb_assert (realnump
!= NULL
);
986 /* gdb_assert (bufferp != NULL); */
988 /* Obtain the register value by unwinding the register from the next
989 (more inner frame). */
990 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
991 frame_register_unwind (frame
->next
, regnum
, optimizedp
, unavailablep
,
992 lvalp
, addrp
, realnump
, bufferp
);
996 frame_unwind_register (struct frame_info
*frame
, int regnum
, gdb_byte
*buf
)
1002 enum lval_type lval
;
1004 frame_register_unwind (frame
, regnum
, &optimized
, &unavailable
,
1005 &lval
, &addr
, &realnum
, buf
);
1008 error (_("Register %d was optimized out"), regnum
);
1010 throw_error (NOT_AVAILABLE_ERROR
,
1011 _("Register %d is not available"), regnum
);
1015 get_frame_register (struct frame_info
*frame
,
1016 int regnum
, gdb_byte
*buf
)
1018 frame_unwind_register (frame
->next
, regnum
, buf
);
1022 frame_unwind_register_value (struct frame_info
*frame
, int regnum
)
1024 struct gdbarch
*gdbarch
;
1025 struct value
*value
;
1027 gdb_assert (frame
!= NULL
);
1028 gdbarch
= frame_unwind_arch (frame
);
1032 fprintf_unfiltered (gdb_stdlog
,
1033 "{ frame_unwind_register_value "
1034 "(frame=%d,regnum=%d(%s),...) ",
1035 frame
->level
, regnum
,
1036 user_reg_map_regnum_to_name (gdbarch
, regnum
));
1039 /* Find the unwinder. */
1040 if (frame
->unwind
== NULL
)
1041 frame_unwind_find_by_frame (frame
, &frame
->prologue_cache
);
1043 /* Ask this frame to unwind its register. */
1044 value
= frame
->unwind
->prev_register (frame
, &frame
->prologue_cache
, regnum
);
1048 fprintf_unfiltered (gdb_stdlog
, "->");
1049 if (value_optimized_out (value
))
1050 fprintf_unfiltered (gdb_stdlog
, " optimized out");
1053 if (VALUE_LVAL (value
) == lval_register
)
1054 fprintf_unfiltered (gdb_stdlog
, " register=%d",
1055 VALUE_REGNUM (value
));
1056 else if (VALUE_LVAL (value
) == lval_memory
)
1057 fprintf_unfiltered (gdb_stdlog
, " address=%s",
1059 value_address (value
)));
1061 fprintf_unfiltered (gdb_stdlog
, " computed");
1063 if (value_lazy (value
))
1064 fprintf_unfiltered (gdb_stdlog
, " lazy");
1068 const gdb_byte
*buf
= value_contents (value
);
1070 fprintf_unfiltered (gdb_stdlog
, " bytes=");
1071 fprintf_unfiltered (gdb_stdlog
, "[");
1072 for (i
= 0; i
< register_size (gdbarch
, regnum
); i
++)
1073 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1074 fprintf_unfiltered (gdb_stdlog
, "]");
1078 fprintf_unfiltered (gdb_stdlog
, " }\n");
1085 get_frame_register_value (struct frame_info
*frame
, int regnum
)
1087 return frame_unwind_register_value (frame
->next
, regnum
);
1091 frame_unwind_register_signed (struct frame_info
*frame
, int regnum
)
1093 struct gdbarch
*gdbarch
= frame_unwind_arch (frame
);
1094 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1095 int size
= register_size (gdbarch
, regnum
);
1096 gdb_byte buf
[MAX_REGISTER_SIZE
];
1098 frame_unwind_register (frame
, regnum
, buf
);
1099 return extract_signed_integer (buf
, size
, byte_order
);
1103 get_frame_register_signed (struct frame_info
*frame
, int regnum
)
1105 return frame_unwind_register_signed (frame
->next
, regnum
);
1109 frame_unwind_register_unsigned (struct frame_info
*frame
, int regnum
)
1111 struct gdbarch
*gdbarch
= frame_unwind_arch (frame
);
1112 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1113 int size
= register_size (gdbarch
, regnum
);
1114 gdb_byte buf
[MAX_REGISTER_SIZE
];
1116 frame_unwind_register (frame
, regnum
, buf
);
1117 return extract_unsigned_integer (buf
, size
, byte_order
);
1121 get_frame_register_unsigned (struct frame_info
*frame
, int regnum
)
1123 return frame_unwind_register_unsigned (frame
->next
, regnum
);
1127 read_frame_register_unsigned (struct frame_info
*frame
, int regnum
,
1130 struct value
*regval
= get_frame_register_value (frame
, regnum
);
1132 if (!value_optimized_out (regval
)
1133 && value_entirely_available (regval
))
1135 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1136 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1137 int size
= register_size (gdbarch
, VALUE_REGNUM (regval
));
1139 *val
= extract_unsigned_integer (value_contents (regval
), size
, byte_order
);
1147 put_frame_register (struct frame_info
*frame
, int regnum
,
1148 const gdb_byte
*buf
)
1150 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1154 enum lval_type lval
;
1157 frame_register (frame
, regnum
, &optim
, &unavail
,
1158 &lval
, &addr
, &realnum
, NULL
);
1160 error (_("Attempt to assign to a register that was not saved."));
1165 write_memory (addr
, buf
, register_size (gdbarch
, regnum
));
1169 regcache_cooked_write (get_current_regcache (), realnum
, buf
);
1172 error (_("Attempt to assign to an unmodifiable value."));
1176 /* This function is deprecated. Use get_frame_register_value instead,
1177 which provides more accurate information.
1179 Find and return the value of REGNUM for the specified stack frame.
1180 The number of bytes copied is REGISTER_SIZE (REGNUM).
1182 Returns 0 if the register value could not be found. */
1185 deprecated_frame_register_read (struct frame_info
*frame
, int regnum
,
1190 enum lval_type lval
;
1194 frame_register (frame
, regnum
, &optimized
, &unavailable
,
1195 &lval
, &addr
, &realnum
, myaddr
);
1197 return !optimized
&& !unavailable
;
1201 get_frame_register_bytes (struct frame_info
*frame
, int regnum
,
1202 CORE_ADDR offset
, int len
, gdb_byte
*myaddr
,
1203 int *optimizedp
, int *unavailablep
)
1205 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1210 /* Skip registers wholly inside of OFFSET. */
1211 while (offset
>= register_size (gdbarch
, regnum
))
1213 offset
-= register_size (gdbarch
, regnum
);
1217 /* Ensure that we will not read beyond the end of the register file.
1218 This can only ever happen if the debug information is bad. */
1220 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1221 for (i
= regnum
; i
< numregs
; i
++)
1223 int thissize
= register_size (gdbarch
, i
);
1226 break; /* This register is not available on this architecture. */
1227 maxsize
+= thissize
;
1230 error (_("Bad debug information detected: "
1231 "Attempt to read %d bytes from registers."), len
);
1233 /* Copy the data. */
1236 int curr_len
= register_size (gdbarch
, regnum
) - offset
;
1241 if (curr_len
== register_size (gdbarch
, regnum
))
1243 enum lval_type lval
;
1247 frame_register (frame
, regnum
, optimizedp
, unavailablep
,
1248 &lval
, &addr
, &realnum
, myaddr
);
1249 if (*optimizedp
|| *unavailablep
)
1254 gdb_byte buf
[MAX_REGISTER_SIZE
];
1255 enum lval_type lval
;
1259 frame_register (frame
, regnum
, optimizedp
, unavailablep
,
1260 &lval
, &addr
, &realnum
, buf
);
1261 if (*optimizedp
|| *unavailablep
)
1263 memcpy (myaddr
, buf
+ offset
, curr_len
);
1278 put_frame_register_bytes (struct frame_info
*frame
, int regnum
,
1279 CORE_ADDR offset
, int len
, const gdb_byte
*myaddr
)
1281 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1283 /* Skip registers wholly inside of OFFSET. */
1284 while (offset
>= register_size (gdbarch
, regnum
))
1286 offset
-= register_size (gdbarch
, regnum
);
1290 /* Copy the data. */
1293 int curr_len
= register_size (gdbarch
, regnum
) - offset
;
1298 if (curr_len
== register_size (gdbarch
, regnum
))
1300 put_frame_register (frame
, regnum
, myaddr
);
1304 gdb_byte buf
[MAX_REGISTER_SIZE
];
1306 deprecated_frame_register_read (frame
, regnum
, buf
);
1307 memcpy (buf
+ offset
, myaddr
, curr_len
);
1308 put_frame_register (frame
, regnum
, buf
);
1318 /* Create a sentinel frame. */
1320 static struct frame_info
*
1321 create_sentinel_frame (struct program_space
*pspace
, struct regcache
*regcache
)
1323 struct frame_info
*frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1326 frame
->pspace
= pspace
;
1327 frame
->aspace
= get_regcache_aspace (regcache
);
1328 /* Explicitly initialize the sentinel frame's cache. Provide it
1329 with the underlying regcache. In the future additional
1330 information, such as the frame's thread will be added. */
1331 frame
->prologue_cache
= sentinel_frame_cache (regcache
);
1332 /* For the moment there is only one sentinel frame implementation. */
1333 frame
->unwind
= &sentinel_frame_unwind
;
1334 /* Link this frame back to itself. The frame is self referential
1335 (the unwound PC is the same as the pc), so make it so. */
1336 frame
->next
= frame
;
1337 /* Make the sentinel frame's ID valid, but invalid. That way all
1338 comparisons with it should fail. */
1339 frame
->this_id
.p
= 1;
1340 frame
->this_id
.value
= null_frame_id
;
1343 fprintf_unfiltered (gdb_stdlog
, "{ create_sentinel_frame (...) -> ");
1344 fprint_frame (gdb_stdlog
, frame
);
1345 fprintf_unfiltered (gdb_stdlog
, " }\n");
1350 /* Info about the innermost stack frame (contents of FP register). */
1352 static struct frame_info
*current_frame
;
1354 /* Cache for frame addresses already read by gdb. Valid only while
1355 inferior is stopped. Control variables for the frame cache should
1356 be local to this module. */
1358 static struct obstack frame_cache_obstack
;
1361 frame_obstack_zalloc (unsigned long size
)
1363 void *data
= obstack_alloc (&frame_cache_obstack
, size
);
1365 memset (data
, 0, size
);
1369 /* Return the innermost (currently executing) stack frame. This is
1370 split into two functions. The function unwind_to_current_frame()
1371 is wrapped in catch exceptions so that, even when the unwind of the
1372 sentinel frame fails, the function still returns a stack frame. */
1375 unwind_to_current_frame (struct ui_out
*ui_out
, void *args
)
1377 struct frame_info
*frame
= get_prev_frame (args
);
1379 /* A sentinel frame can fail to unwind, e.g., because its PC value
1380 lands in somewhere like start. */
1383 current_frame
= frame
;
1388 get_current_frame (void)
1390 /* First check, and report, the lack of registers. Having GDB
1391 report "No stack!" or "No memory" when the target doesn't even
1392 have registers is very confusing. Besides, "printcmd.exp"
1393 explicitly checks that ``print $pc'' with no registers prints "No
1395 if (!target_has_registers
)
1396 error (_("No registers."));
1397 if (!target_has_stack
)
1398 error (_("No stack."));
1399 if (!target_has_memory
)
1400 error (_("No memory."));
1401 /* Traceframes are effectively a substitute for the live inferior. */
1402 if (get_traceframe_number () < 0)
1404 if (ptid_equal (inferior_ptid
, null_ptid
))
1405 error (_("No selected thread."));
1406 if (is_exited (inferior_ptid
))
1407 error (_("Invalid selected thread."));
1408 if (is_executing (inferior_ptid
))
1409 error (_("Target is executing."));
1412 if (current_frame
== NULL
)
1414 struct frame_info
*sentinel_frame
=
1415 create_sentinel_frame (current_program_space
, get_current_regcache ());
1416 if (catch_exceptions (current_uiout
, unwind_to_current_frame
,
1417 sentinel_frame
, RETURN_MASK_ERROR
) != 0)
1419 /* Oops! Fake a current frame? Is this useful? It has a PC
1420 of zero, for instance. */
1421 current_frame
= sentinel_frame
;
1424 return current_frame
;
1427 /* The "selected" stack frame is used by default for local and arg
1428 access. May be zero, for no selected frame. */
1430 static struct frame_info
*selected_frame
;
1433 has_stack_frames (void)
1435 if (!target_has_registers
|| !target_has_stack
|| !target_has_memory
)
1438 /* Traceframes are effectively a substitute for the live inferior. */
1439 if (get_traceframe_number () < 0)
1441 /* No current inferior, no frame. */
1442 if (ptid_equal (inferior_ptid
, null_ptid
))
1445 /* Don't try to read from a dead thread. */
1446 if (is_exited (inferior_ptid
))
1449 /* ... or from a spinning thread. */
1450 if (is_executing (inferior_ptid
))
1457 /* Return the selected frame. Always non-NULL (unless there isn't an
1458 inferior sufficient for creating a frame) in which case an error is
1462 get_selected_frame (const char *message
)
1464 if (selected_frame
== NULL
)
1466 if (message
!= NULL
&& !has_stack_frames ())
1467 error (("%s"), message
);
1468 /* Hey! Don't trust this. It should really be re-finding the
1469 last selected frame of the currently selected thread. This,
1470 though, is better than nothing. */
1471 select_frame (get_current_frame ());
1473 /* There is always a frame. */
1474 gdb_assert (selected_frame
!= NULL
);
1475 return selected_frame
;
1478 /* If there is a selected frame, return it. Otherwise, return NULL. */
1481 get_selected_frame_if_set (void)
1483 return selected_frame
;
1486 /* This is a variant of get_selected_frame() which can be called when
1487 the inferior does not have a frame; in that case it will return
1488 NULL instead of calling error(). */
1491 deprecated_safe_get_selected_frame (void)
1493 if (!has_stack_frames ())
1495 return get_selected_frame (NULL
);
1498 /* Select frame FI (or NULL - to invalidate the current frame). */
1501 select_frame (struct frame_info
*fi
)
1503 selected_frame
= fi
;
1504 /* NOTE: cagney/2002-05-04: FI can be NULL. This occurs when the
1505 frame is being invalidated. */
1506 if (deprecated_selected_frame_level_changed_hook
)
1507 deprecated_selected_frame_level_changed_hook (frame_relative_level (fi
));
1509 /* FIXME: kseitz/2002-08-28: It would be nice to call
1510 selected_frame_level_changed_event() right here, but due to limitations
1511 in the current interfaces, we would end up flooding UIs with events
1512 because select_frame() is used extensively internally.
1514 Once we have frame-parameterized frame (and frame-related) commands,
1515 the event notification can be moved here, since this function will only
1516 be called when the user's selected frame is being changed. */
1518 /* Ensure that symbols for this frame are read in. Also, determine the
1519 source language of this frame, and switch to it if desired. */
1524 /* We retrieve the frame's symtab by using the frame PC.
1525 However we cannot use the frame PC as-is, because it usually
1526 points to the instruction following the "call", which is
1527 sometimes the first instruction of another function. So we
1528 rely on get_frame_address_in_block() which provides us with a
1529 PC which is guaranteed to be inside the frame's code
1531 if (get_frame_address_in_block_if_available (fi
, &pc
))
1533 struct symtab
*s
= find_pc_symtab (pc
);
1536 && s
->language
!= current_language
->la_language
1537 && s
->language
!= language_unknown
1538 && language_mode
== language_mode_auto
)
1539 set_language (s
->language
);
1544 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
1545 Always returns a non-NULL value. */
1548 create_new_frame (CORE_ADDR addr
, CORE_ADDR pc
)
1550 struct frame_info
*fi
;
1554 fprintf_unfiltered (gdb_stdlog
,
1555 "{ create_new_frame (addr=%s, pc=%s) ",
1556 hex_string (addr
), hex_string (pc
));
1559 fi
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1561 fi
->next
= create_sentinel_frame (current_program_space
,
1562 get_current_regcache ());
1564 /* Set/update this frame's cached PC value, found in the next frame.
1565 Do this before looking for this frame's unwinder. A sniffer is
1566 very likely to read this, and the corresponding unwinder is
1567 entitled to rely that the PC doesn't magically change. */
1568 fi
->next
->prev_pc
.value
= pc
;
1569 fi
->next
->prev_pc
.p
= 1;
1571 /* We currently assume that frame chain's can't cross spaces. */
1572 fi
->pspace
= fi
->next
->pspace
;
1573 fi
->aspace
= fi
->next
->aspace
;
1575 /* Select/initialize both the unwind function and the frame's type
1577 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
1580 fi
->this_id
.value
= frame_id_build (addr
, pc
);
1584 fprintf_unfiltered (gdb_stdlog
, "-> ");
1585 fprint_frame (gdb_stdlog
, fi
);
1586 fprintf_unfiltered (gdb_stdlog
, " }\n");
1592 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
1593 innermost frame). Be careful to not fall off the bottom of the
1594 frame chain and onto the sentinel frame. */
1597 get_next_frame (struct frame_info
*this_frame
)
1599 if (this_frame
->level
> 0)
1600 return this_frame
->next
;
1605 /* Observer for the target_changed event. */
1608 frame_observer_target_changed (struct target_ops
*target
)
1610 reinit_frame_cache ();
1613 /* Flush the entire frame cache. */
1616 reinit_frame_cache (void)
1618 struct frame_info
*fi
;
1620 /* Tear down all frame caches. */
1621 for (fi
= current_frame
; fi
!= NULL
; fi
= fi
->prev
)
1623 if (fi
->prologue_cache
&& fi
->unwind
->dealloc_cache
)
1624 fi
->unwind
->dealloc_cache (fi
, fi
->prologue_cache
);
1625 if (fi
->base_cache
&& fi
->base
->unwind
->dealloc_cache
)
1626 fi
->base
->unwind
->dealloc_cache (fi
, fi
->base_cache
);
1629 /* Since we can't really be sure what the first object allocated was. */
1630 obstack_free (&frame_cache_obstack
, 0);
1631 obstack_init (&frame_cache_obstack
);
1633 if (current_frame
!= NULL
)
1634 annotate_frames_invalid ();
1636 current_frame
= NULL
; /* Invalidate cache */
1637 select_frame (NULL
);
1638 frame_stash_invalidate ();
1640 fprintf_unfiltered (gdb_stdlog
, "{ reinit_frame_cache () }\n");
1643 /* Find where a register is saved (in memory or another register).
1644 The result of frame_register_unwind is just where it is saved
1645 relative to this particular frame. */
1648 frame_register_unwind_location (struct frame_info
*this_frame
, int regnum
,
1649 int *optimizedp
, enum lval_type
*lvalp
,
1650 CORE_ADDR
*addrp
, int *realnump
)
1652 gdb_assert (this_frame
== NULL
|| this_frame
->level
>= 0);
1654 while (this_frame
!= NULL
)
1658 frame_register_unwind (this_frame
, regnum
, optimizedp
, &unavailable
,
1659 lvalp
, addrp
, realnump
, NULL
);
1664 if (*lvalp
!= lval_register
)
1668 this_frame
= get_next_frame (this_frame
);
1672 /* Get the previous raw frame, and check that it is not identical to
1673 same other frame frame already in the chain. If it is, there is
1674 most likely a stack cycle, so we discard it, and mark THIS_FRAME as
1675 outermost, with UNWIND_SAME_ID stop reason. Unlike the other
1676 validity tests, that compare THIS_FRAME and the next frame, we do
1677 this right after creating the previous frame, to avoid ever ending
1678 up with two frames with the same id in the frame chain. */
1680 static struct frame_info
*
1681 get_prev_frame_if_no_cycle (struct frame_info
*this_frame
)
1683 struct frame_info
*prev_frame
;
1685 prev_frame
= get_prev_frame_raw (this_frame
);
1686 if (prev_frame
== NULL
)
1689 compute_frame_id (prev_frame
);
1690 if (frame_stash_add (prev_frame
))
1693 /* Another frame with the same id was already in the stash. We just
1694 detected a cycle. */
1697 fprintf_unfiltered (gdb_stdlog
, "-> ");
1698 fprint_frame (gdb_stdlog
, NULL
);
1699 fprintf_unfiltered (gdb_stdlog
, " // this frame has same ID }\n");
1701 this_frame
->stop_reason
= UNWIND_SAME_ID
;
1703 prev_frame
->next
= NULL
;
1704 this_frame
->prev
= NULL
;
1708 /* Return a "struct frame_info" corresponding to the frame that called
1709 THIS_FRAME. Returns NULL if there is no such frame.
1711 Unlike get_prev_frame, this function always tries to unwind the
1714 static struct frame_info
*
1715 get_prev_frame_1 (struct frame_info
*this_frame
)
1717 struct frame_id this_id
;
1718 struct gdbarch
*gdbarch
;
1720 gdb_assert (this_frame
!= NULL
);
1721 gdbarch
= get_frame_arch (this_frame
);
1725 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame_1 (this_frame=");
1726 if (this_frame
!= NULL
)
1727 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1729 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1730 fprintf_unfiltered (gdb_stdlog
, ") ");
1733 /* Only try to do the unwind once. */
1734 if (this_frame
->prev_p
)
1738 fprintf_unfiltered (gdb_stdlog
, "-> ");
1739 fprint_frame (gdb_stdlog
, this_frame
->prev
);
1740 fprintf_unfiltered (gdb_stdlog
, " // cached \n");
1742 return this_frame
->prev
;
1745 /* If the frame unwinder hasn't been selected yet, we must do so
1746 before setting prev_p; otherwise the check for misbehaved
1747 sniffers will think that this frame's sniffer tried to unwind
1748 further (see frame_cleanup_after_sniffer). */
1749 if (this_frame
->unwind
== NULL
)
1750 frame_unwind_find_by_frame (this_frame
, &this_frame
->prologue_cache
);
1752 this_frame
->prev_p
= 1;
1753 this_frame
->stop_reason
= UNWIND_NO_REASON
;
1755 /* If we are unwinding from an inline frame, all of the below tests
1756 were already performed when we unwound from the next non-inline
1757 frame. We must skip them, since we can not get THIS_FRAME's ID
1758 until we have unwound all the way down to the previous non-inline
1760 if (get_frame_type (this_frame
) == INLINE_FRAME
)
1761 return get_prev_frame_if_no_cycle (this_frame
);
1763 /* Check that this frame is unwindable. If it isn't, don't try to
1764 unwind to the prev frame. */
1765 this_frame
->stop_reason
1766 = this_frame
->unwind
->stop_reason (this_frame
,
1767 &this_frame
->prologue_cache
);
1769 if (this_frame
->stop_reason
!= UNWIND_NO_REASON
)
1772 /* Check that this frame's ID was valid. If it wasn't, don't try to
1773 unwind to the prev frame. Be careful to not apply this test to
1774 the sentinel frame. */
1775 this_id
= get_frame_id (this_frame
);
1776 if (this_frame
->level
>= 0 && frame_id_eq (this_id
, outer_frame_id
))
1780 fprintf_unfiltered (gdb_stdlog
, "-> ");
1781 fprint_frame (gdb_stdlog
, NULL
);
1782 fprintf_unfiltered (gdb_stdlog
, " // this ID is NULL }\n");
1784 this_frame
->stop_reason
= UNWIND_NULL_ID
;
1788 /* Check that this frame's ID isn't inner to (younger, below, next)
1789 the next frame. This happens when a frame unwind goes backwards.
1790 This check is valid only if this frame and the next frame are NORMAL.
1791 See the comment at frame_id_inner for details. */
1792 if (get_frame_type (this_frame
) == NORMAL_FRAME
1793 && this_frame
->next
->unwind
->type
== NORMAL_FRAME
1794 && frame_id_inner (get_frame_arch (this_frame
->next
), this_id
,
1795 get_frame_id (this_frame
->next
)))
1797 CORE_ADDR this_pc_in_block
;
1798 struct minimal_symbol
*morestack_msym
;
1799 const char *morestack_name
= NULL
;
1801 /* gcc -fsplit-stack __morestack can continue the stack anywhere. */
1802 this_pc_in_block
= get_frame_address_in_block (this_frame
);
1803 morestack_msym
= lookup_minimal_symbol_by_pc (this_pc_in_block
).minsym
;
1805 morestack_name
= SYMBOL_LINKAGE_NAME (morestack_msym
);
1806 if (!morestack_name
|| strcmp (morestack_name
, "__morestack") != 0)
1810 fprintf_unfiltered (gdb_stdlog
, "-> ");
1811 fprint_frame (gdb_stdlog
, NULL
);
1812 fprintf_unfiltered (gdb_stdlog
,
1813 " // this frame ID is inner }\n");
1815 this_frame
->stop_reason
= UNWIND_INNER_ID
;
1820 /* Check that this and the next frame do not unwind the PC register
1821 to the same memory location. If they do, then even though they
1822 have different frame IDs, the new frame will be bogus; two
1823 functions can't share a register save slot for the PC. This can
1824 happen when the prologue analyzer finds a stack adjustment, but
1827 This check does assume that the "PC register" is roughly a
1828 traditional PC, even if the gdbarch_unwind_pc method adjusts
1829 it (we do not rely on the value, only on the unwound PC being
1830 dependent on this value). A potential improvement would be
1831 to have the frame prev_pc method and the gdbarch unwind_pc
1832 method set the same lval and location information as
1833 frame_register_unwind. */
1834 if (this_frame
->level
> 0
1835 && gdbarch_pc_regnum (gdbarch
) >= 0
1836 && get_frame_type (this_frame
) == NORMAL_FRAME
1837 && (get_frame_type (this_frame
->next
) == NORMAL_FRAME
1838 || get_frame_type (this_frame
->next
) == INLINE_FRAME
))
1840 int optimized
, realnum
, nrealnum
;
1841 enum lval_type lval
, nlval
;
1842 CORE_ADDR addr
, naddr
;
1844 frame_register_unwind_location (this_frame
,
1845 gdbarch_pc_regnum (gdbarch
),
1846 &optimized
, &lval
, &addr
, &realnum
);
1847 frame_register_unwind_location (get_next_frame (this_frame
),
1848 gdbarch_pc_regnum (gdbarch
),
1849 &optimized
, &nlval
, &naddr
, &nrealnum
);
1851 if ((lval
== lval_memory
&& lval
== nlval
&& addr
== naddr
)
1852 || (lval
== lval_register
&& lval
== nlval
&& realnum
== nrealnum
))
1856 fprintf_unfiltered (gdb_stdlog
, "-> ");
1857 fprint_frame (gdb_stdlog
, NULL
);
1858 fprintf_unfiltered (gdb_stdlog
, " // no saved PC }\n");
1861 this_frame
->stop_reason
= UNWIND_NO_SAVED_PC
;
1862 this_frame
->prev
= NULL
;
1867 return get_prev_frame_if_no_cycle (this_frame
);
1870 /* Construct a new "struct frame_info" and link it previous to
1873 static struct frame_info
*
1874 get_prev_frame_raw (struct frame_info
*this_frame
)
1876 struct frame_info
*prev_frame
;
1878 /* Allocate the new frame but do not wire it in to the frame chain.
1879 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
1880 frame->next to pull some fancy tricks (of course such code is, by
1881 definition, recursive). Try to prevent it.
1883 There is no reason to worry about memory leaks, should the
1884 remainder of the function fail. The allocated memory will be
1885 quickly reclaimed when the frame cache is flushed, and the `we've
1886 been here before' check above will stop repeated memory
1887 allocation calls. */
1888 prev_frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1889 prev_frame
->level
= this_frame
->level
+ 1;
1891 /* For now, assume we don't have frame chains crossing address
1893 prev_frame
->pspace
= this_frame
->pspace
;
1894 prev_frame
->aspace
= this_frame
->aspace
;
1896 /* Don't yet compute ->unwind (and hence ->type). It is computed
1897 on-demand in get_frame_type, frame_register_unwind, and
1900 /* Don't yet compute the frame's ID. It is computed on-demand by
1903 /* The unwound frame ID is validate at the start of this function,
1904 as part of the logic to decide if that frame should be further
1905 unwound, and not here while the prev frame is being created.
1906 Doing this makes it possible for the user to examine a frame that
1907 has an invalid frame ID.
1909 Some very old VAX code noted: [...] For the sake of argument,
1910 suppose that the stack is somewhat trashed (which is one reason
1911 that "info frame" exists). So, return 0 (indicating we don't
1912 know the address of the arglist) if we don't know what frame this
1916 this_frame
->prev
= prev_frame
;
1917 prev_frame
->next
= this_frame
;
1921 fprintf_unfiltered (gdb_stdlog
, "-> ");
1922 fprint_frame (gdb_stdlog
, prev_frame
);
1923 fprintf_unfiltered (gdb_stdlog
, " }\n");
1929 /* Debug routine to print a NULL frame being returned. */
1932 frame_debug_got_null_frame (struct frame_info
*this_frame
,
1937 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame (this_frame=");
1938 if (this_frame
!= NULL
)
1939 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1941 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1942 fprintf_unfiltered (gdb_stdlog
, ") -> // %s}\n", reason
);
1946 /* Is this (non-sentinel) frame in the "main"() function? */
1949 inside_main_func (struct frame_info
*this_frame
)
1951 struct minimal_symbol
*msymbol
;
1954 if (symfile_objfile
== 0)
1956 msymbol
= lookup_minimal_symbol (main_name (), NULL
, symfile_objfile
);
1957 if (msymbol
== NULL
)
1959 /* Make certain that the code, and not descriptor, address is
1961 maddr
= gdbarch_convert_from_func_ptr_addr (get_frame_arch (this_frame
),
1962 SYMBOL_VALUE_ADDRESS (msymbol
),
1964 return maddr
== get_frame_func (this_frame
);
1967 /* Test whether THIS_FRAME is inside the process entry point function. */
1970 inside_entry_func (struct frame_info
*this_frame
)
1972 CORE_ADDR entry_point
;
1974 if (!entry_point_address_query (&entry_point
))
1977 return get_frame_func (this_frame
) == entry_point
;
1980 /* Return a structure containing various interesting information about
1981 the frame that called THIS_FRAME. Returns NULL if there is entier
1982 no such frame or the frame fails any of a set of target-independent
1983 condition that should terminate the frame chain (e.g., as unwinding
1986 This function should not contain target-dependent tests, such as
1987 checking whether the program-counter is zero. */
1990 get_prev_frame (struct frame_info
*this_frame
)
1995 /* There is always a frame. If this assertion fails, suspect that
1996 something should be calling get_selected_frame() or
1997 get_current_frame(). */
1998 gdb_assert (this_frame
!= NULL
);
1999 frame_pc_p
= get_frame_pc_if_available (this_frame
, &frame_pc
);
2001 /* tausq/2004-12-07: Dummy frames are skipped because it doesn't make much
2002 sense to stop unwinding at a dummy frame. One place where a dummy
2003 frame may have an address "inside_main_func" is on HPUX. On HPUX, the
2004 pcsqh register (space register for the instruction at the head of the
2005 instruction queue) cannot be written directly; the only way to set it
2006 is to branch to code that is in the target space. In order to implement
2007 frame dummies on HPUX, the called function is made to jump back to where
2008 the inferior was when the user function was called. If gdb was inside
2009 the main function when we created the dummy frame, the dummy frame will
2010 point inside the main function. */
2011 if (this_frame
->level
>= 0
2012 && get_frame_type (this_frame
) == NORMAL_FRAME
2013 && !backtrace_past_main
2015 && inside_main_func (this_frame
))
2016 /* Don't unwind past main(). Note, this is done _before_ the
2017 frame has been marked as previously unwound. That way if the
2018 user later decides to enable unwinds past main(), that will
2019 automatically happen. */
2021 frame_debug_got_null_frame (this_frame
, "inside main func");
2025 /* If the user's backtrace limit has been exceeded, stop. We must
2026 add two to the current level; one of those accounts for backtrace_limit
2027 being 1-based and the level being 0-based, and the other accounts for
2028 the level of the new frame instead of the level of the current
2030 if (this_frame
->level
+ 2 > backtrace_limit
)
2032 frame_debug_got_null_frame (this_frame
, "backtrace limit exceeded");
2036 /* If we're already inside the entry function for the main objfile,
2037 then it isn't valid. Don't apply this test to a dummy frame -
2038 dummy frame PCs typically land in the entry func. Don't apply
2039 this test to the sentinel frame. Sentinel frames should always
2040 be allowed to unwind. */
2041 /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() -
2042 wasn't checking for "main" in the minimal symbols. With that
2043 fixed asm-source tests now stop in "main" instead of halting the
2044 backtrace in weird and wonderful ways somewhere inside the entry
2045 file. Suspect that tests for inside the entry file/func were
2046 added to work around that (now fixed) case. */
2047 /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
2048 suggested having the inside_entry_func test use the
2049 inside_main_func() msymbol trick (along with entry_point_address()
2050 I guess) to determine the address range of the start function.
2051 That should provide a far better stopper than the current
2053 /* NOTE: tausq/2004-10-09: this is needed if, for example, the compiler
2054 applied tail-call optimizations to main so that a function called
2055 from main returns directly to the caller of main. Since we don't
2056 stop at main, we should at least stop at the entry point of the
2058 if (this_frame
->level
>= 0
2059 && get_frame_type (this_frame
) == NORMAL_FRAME
2060 && !backtrace_past_entry
2062 && inside_entry_func (this_frame
))
2064 frame_debug_got_null_frame (this_frame
, "inside entry func");
2068 /* Assume that the only way to get a zero PC is through something
2069 like a SIGSEGV or a dummy frame, and hence that NORMAL frames
2070 will never unwind a zero PC. */
2071 if (this_frame
->level
> 0
2072 && (get_frame_type (this_frame
) == NORMAL_FRAME
2073 || get_frame_type (this_frame
) == INLINE_FRAME
)
2074 && get_frame_type (get_next_frame (this_frame
)) == NORMAL_FRAME
2075 && frame_pc_p
&& frame_pc
== 0)
2077 frame_debug_got_null_frame (this_frame
, "zero PC");
2081 return get_prev_frame_1 (this_frame
);
2085 get_frame_pc (struct frame_info
*frame
)
2087 gdb_assert (frame
->next
!= NULL
);
2088 return frame_unwind_pc (frame
->next
);
2092 get_frame_pc_if_available (struct frame_info
*frame
, CORE_ADDR
*pc
)
2094 volatile struct gdb_exception ex
;
2096 gdb_assert (frame
->next
!= NULL
);
2098 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2100 *pc
= frame_unwind_pc (frame
->next
);
2104 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2107 throw_exception (ex
);
2113 /* Return an address that falls within THIS_FRAME's code block. */
2116 get_frame_address_in_block (struct frame_info
*this_frame
)
2118 /* A draft address. */
2119 CORE_ADDR pc
= get_frame_pc (this_frame
);
2121 struct frame_info
*next_frame
= this_frame
->next
;
2123 /* Calling get_frame_pc returns the resume address for THIS_FRAME.
2124 Normally the resume address is inside the body of the function
2125 associated with THIS_FRAME, but there is a special case: when
2126 calling a function which the compiler knows will never return
2127 (for instance abort), the call may be the very last instruction
2128 in the calling function. The resume address will point after the
2129 call and may be at the beginning of a different function
2132 If THIS_FRAME is a signal frame or dummy frame, then we should
2133 not adjust the unwound PC. For a dummy frame, GDB pushed the
2134 resume address manually onto the stack. For a signal frame, the
2135 OS may have pushed the resume address manually and invoked the
2136 handler (e.g. GNU/Linux), or invoked the trampoline which called
2137 the signal handler - but in either case the signal handler is
2138 expected to return to the trampoline. So in both of these
2139 cases we know that the resume address is executable and
2140 related. So we only need to adjust the PC if THIS_FRAME
2141 is a normal function.
2143 If the program has been interrupted while THIS_FRAME is current,
2144 then clearly the resume address is inside the associated
2145 function. There are three kinds of interruption: debugger stop
2146 (next frame will be SENTINEL_FRAME), operating system
2147 signal or exception (next frame will be SIGTRAMP_FRAME),
2148 or debugger-induced function call (next frame will be
2149 DUMMY_FRAME). So we only need to adjust the PC if
2150 NEXT_FRAME is a normal function.
2152 We check the type of NEXT_FRAME first, since it is already
2153 known; frame type is determined by the unwinder, and since
2154 we have THIS_FRAME we've already selected an unwinder for
2157 If the next frame is inlined, we need to keep going until we find
2158 the real function - for instance, if a signal handler is invoked
2159 while in an inlined function, then the code address of the
2160 "calling" normal function should not be adjusted either. */
2162 while (get_frame_type (next_frame
) == INLINE_FRAME
)
2163 next_frame
= next_frame
->next
;
2165 if ((get_frame_type (next_frame
) == NORMAL_FRAME
2166 || get_frame_type (next_frame
) == TAILCALL_FRAME
)
2167 && (get_frame_type (this_frame
) == NORMAL_FRAME
2168 || get_frame_type (this_frame
) == TAILCALL_FRAME
2169 || get_frame_type (this_frame
) == INLINE_FRAME
))
2176 get_frame_address_in_block_if_available (struct frame_info
*this_frame
,
2179 volatile struct gdb_exception ex
;
2181 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2183 *pc
= get_frame_address_in_block (this_frame
);
2185 if (ex
.reason
< 0 && ex
.error
== NOT_AVAILABLE_ERROR
)
2187 else if (ex
.reason
< 0)
2188 throw_exception (ex
);
2194 find_frame_sal (struct frame_info
*frame
, struct symtab_and_line
*sal
)
2196 struct frame_info
*next_frame
;
2200 /* If the next frame represents an inlined function call, this frame's
2201 sal is the "call site" of that inlined function, which can not
2202 be inferred from get_frame_pc. */
2203 next_frame
= get_next_frame (frame
);
2204 if (frame_inlined_callees (frame
) > 0)
2209 sym
= get_frame_function (next_frame
);
2211 sym
= inline_skipped_symbol (inferior_ptid
);
2213 /* If frame is inline, it certainly has symbols. */
2216 if (SYMBOL_LINE (sym
) != 0)
2218 sal
->symtab
= SYMBOL_SYMTAB (sym
);
2219 sal
->line
= SYMBOL_LINE (sym
);
2222 /* If the symbol does not have a location, we don't know where
2223 the call site is. Do not pretend to. This is jarring, but
2224 we can't do much better. */
2225 sal
->pc
= get_frame_pc (frame
);
2227 sal
->pspace
= get_frame_program_space (frame
);
2232 /* If FRAME is not the innermost frame, that normally means that
2233 FRAME->pc points at the return instruction (which is *after* the
2234 call instruction), and we want to get the line containing the
2235 call (because the call is where the user thinks the program is).
2236 However, if the next frame is either a SIGTRAMP_FRAME or a
2237 DUMMY_FRAME, then the next frame will contain a saved interrupt
2238 PC and such a PC indicates the current (rather than next)
2239 instruction/line, consequently, for such cases, want to get the
2240 line containing fi->pc. */
2241 if (!get_frame_pc_if_available (frame
, &pc
))
2247 notcurrent
= (pc
!= get_frame_address_in_block (frame
));
2248 (*sal
) = find_pc_line (pc
, notcurrent
);
2251 /* Per "frame.h", return the ``address'' of the frame. Code should
2252 really be using get_frame_id(). */
2254 get_frame_base (struct frame_info
*fi
)
2256 return get_frame_id (fi
).stack_addr
;
2259 /* High-level offsets into the frame. Used by the debug info. */
2262 get_frame_base_address (struct frame_info
*fi
)
2264 if (get_frame_type (fi
) != NORMAL_FRAME
)
2266 if (fi
->base
== NULL
)
2267 fi
->base
= frame_base_find_by_frame (fi
);
2268 /* Sneaky: If the low-level unwind and high-level base code share a
2269 common unwinder, let them share the prologue cache. */
2270 if (fi
->base
->unwind
== fi
->unwind
)
2271 return fi
->base
->this_base (fi
, &fi
->prologue_cache
);
2272 return fi
->base
->this_base (fi
, &fi
->base_cache
);
2276 get_frame_locals_address (struct frame_info
*fi
)
2278 if (get_frame_type (fi
) != NORMAL_FRAME
)
2280 /* If there isn't a frame address method, find it. */
2281 if (fi
->base
== NULL
)
2282 fi
->base
= frame_base_find_by_frame (fi
);
2283 /* Sneaky: If the low-level unwind and high-level base code share a
2284 common unwinder, let them share the prologue cache. */
2285 if (fi
->base
->unwind
== fi
->unwind
)
2286 return fi
->base
->this_locals (fi
, &fi
->prologue_cache
);
2287 return fi
->base
->this_locals (fi
, &fi
->base_cache
);
2291 get_frame_args_address (struct frame_info
*fi
)
2293 if (get_frame_type (fi
) != NORMAL_FRAME
)
2295 /* If there isn't a frame address method, find it. */
2296 if (fi
->base
== NULL
)
2297 fi
->base
= frame_base_find_by_frame (fi
);
2298 /* Sneaky: If the low-level unwind and high-level base code share a
2299 common unwinder, let them share the prologue cache. */
2300 if (fi
->base
->unwind
== fi
->unwind
)
2301 return fi
->base
->this_args (fi
, &fi
->prologue_cache
);
2302 return fi
->base
->this_args (fi
, &fi
->base_cache
);
2305 /* Return true if the frame unwinder for frame FI is UNWINDER; false
2309 frame_unwinder_is (struct frame_info
*fi
, const struct frame_unwind
*unwinder
)
2311 if (fi
->unwind
== NULL
)
2312 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
2313 return fi
->unwind
== unwinder
;
2316 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
2317 or -1 for a NULL frame. */
2320 frame_relative_level (struct frame_info
*fi
)
2329 get_frame_type (struct frame_info
*frame
)
2331 if (frame
->unwind
== NULL
)
2332 /* Initialize the frame's unwinder because that's what
2333 provides the frame's type. */
2334 frame_unwind_find_by_frame (frame
, &frame
->prologue_cache
);
2335 return frame
->unwind
->type
;
2338 struct program_space
*
2339 get_frame_program_space (struct frame_info
*frame
)
2341 return frame
->pspace
;
2344 struct program_space
*
2345 frame_unwind_program_space (struct frame_info
*this_frame
)
2347 gdb_assert (this_frame
);
2349 /* This is really a placeholder to keep the API consistent --- we
2350 assume for now that we don't have frame chains crossing
2352 return this_frame
->pspace
;
2355 struct address_space
*
2356 get_frame_address_space (struct frame_info
*frame
)
2358 return frame
->aspace
;
2361 /* Memory access methods. */
2364 get_frame_memory (struct frame_info
*this_frame
, CORE_ADDR addr
,
2365 gdb_byte
*buf
, int len
)
2367 read_memory (addr
, buf
, len
);
2371 get_frame_memory_signed (struct frame_info
*this_frame
, CORE_ADDR addr
,
2374 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2375 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2377 return read_memory_integer (addr
, len
, byte_order
);
2381 get_frame_memory_unsigned (struct frame_info
*this_frame
, CORE_ADDR addr
,
2384 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2385 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2387 return read_memory_unsigned_integer (addr
, len
, byte_order
);
2391 safe_frame_unwind_memory (struct frame_info
*this_frame
,
2392 CORE_ADDR addr
, gdb_byte
*buf
, int len
)
2394 /* NOTE: target_read_memory returns zero on success! */
2395 return !target_read_memory (addr
, buf
, len
);
2398 /* Architecture methods. */
2401 get_frame_arch (struct frame_info
*this_frame
)
2403 return frame_unwind_arch (this_frame
->next
);
2407 frame_unwind_arch (struct frame_info
*next_frame
)
2409 if (!next_frame
->prev_arch
.p
)
2411 struct gdbarch
*arch
;
2413 if (next_frame
->unwind
== NULL
)
2414 frame_unwind_find_by_frame (next_frame
, &next_frame
->prologue_cache
);
2416 if (next_frame
->unwind
->prev_arch
!= NULL
)
2417 arch
= next_frame
->unwind
->prev_arch (next_frame
,
2418 &next_frame
->prologue_cache
);
2420 arch
= get_frame_arch (next_frame
);
2422 next_frame
->prev_arch
.arch
= arch
;
2423 next_frame
->prev_arch
.p
= 1;
2425 fprintf_unfiltered (gdb_stdlog
,
2426 "{ frame_unwind_arch (next_frame=%d) -> %s }\n",
2428 gdbarch_bfd_arch_info (arch
)->printable_name
);
2431 return next_frame
->prev_arch
.arch
;
2435 frame_unwind_caller_arch (struct frame_info
*next_frame
)
2437 return frame_unwind_arch (skip_artificial_frames (next_frame
));
2440 /* Stack pointer methods. */
2443 get_frame_sp (struct frame_info
*this_frame
)
2445 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2447 /* Normality - an architecture that provides a way of obtaining any
2448 frame inner-most address. */
2449 if (gdbarch_unwind_sp_p (gdbarch
))
2450 /* NOTE drow/2008-06-28: gdbarch_unwind_sp could be converted to
2451 operate on THIS_FRAME now. */
2452 return gdbarch_unwind_sp (gdbarch
, this_frame
->next
);
2453 /* Now things are really are grim. Hope that the value returned by
2454 the gdbarch_sp_regnum register is meaningful. */
2455 if (gdbarch_sp_regnum (gdbarch
) >= 0)
2456 return get_frame_register_unsigned (this_frame
,
2457 gdbarch_sp_regnum (gdbarch
));
2458 internal_error (__FILE__
, __LINE__
, _("Missing unwind SP method"));
2461 /* Return the reason why we can't unwind past FRAME. */
2463 enum unwind_stop_reason
2464 get_frame_unwind_stop_reason (struct frame_info
*frame
)
2466 /* If we haven't tried to unwind past this point yet, then assume
2467 that unwinding would succeed. */
2468 if (frame
->prev_p
== 0)
2469 return UNWIND_NO_REASON
;
2471 /* Otherwise, we set a reason when we succeeded (or failed) to
2473 return frame
->stop_reason
;
2476 /* Return a string explaining REASON. */
2479 frame_stop_reason_string (enum unwind_stop_reason reason
)
2483 #define SET(name, description) \
2484 case name: return _(description);
2485 #include "unwind_stop_reasons.def"
2489 internal_error (__FILE__
, __LINE__
,
2490 "Invalid frame stop reason");
2494 /* Clean up after a failed (wrong unwinder) attempt to unwind past
2498 frame_cleanup_after_sniffer (void *arg
)
2500 struct frame_info
*frame
= arg
;
2502 /* The sniffer should not allocate a prologue cache if it did not
2503 match this frame. */
2504 gdb_assert (frame
->prologue_cache
== NULL
);
2506 /* No sniffer should extend the frame chain; sniff based on what is
2508 gdb_assert (!frame
->prev_p
);
2510 /* The sniffer should not check the frame's ID; that's circular. */
2511 gdb_assert (!frame
->this_id
.p
);
2513 /* Clear cached fields dependent on the unwinder.
2515 The previous PC is independent of the unwinder, but the previous
2516 function is not (see get_frame_address_in_block). */
2517 frame
->prev_func
.p
= 0;
2518 frame
->prev_func
.addr
= 0;
2520 /* Discard the unwinder last, so that we can easily find it if an assertion
2521 in this function triggers. */
2522 frame
->unwind
= NULL
;
2525 /* Set FRAME's unwinder temporarily, so that we can call a sniffer.
2526 Return a cleanup which should be called if unwinding fails, and
2527 discarded if it succeeds. */
2530 frame_prepare_for_sniffer (struct frame_info
*frame
,
2531 const struct frame_unwind
*unwind
)
2533 gdb_assert (frame
->unwind
== NULL
);
2534 frame
->unwind
= unwind
;
2535 return make_cleanup (frame_cleanup_after_sniffer
, frame
);
2538 extern initialize_file_ftype _initialize_frame
; /* -Wmissing-prototypes */
2540 static struct cmd_list_element
*set_backtrace_cmdlist
;
2541 static struct cmd_list_element
*show_backtrace_cmdlist
;
2544 set_backtrace_cmd (char *args
, int from_tty
)
2546 help_list (set_backtrace_cmdlist
, "set backtrace ", -1, gdb_stdout
);
2550 show_backtrace_cmd (char *args
, int from_tty
)
2552 cmd_show_list (show_backtrace_cmdlist
, from_tty
, "");
2556 _initialize_frame (void)
2558 obstack_init (&frame_cache_obstack
);
2560 frame_stash_create ();
2562 observer_attach_target_changed (frame_observer_target_changed
);
2564 add_prefix_cmd ("backtrace", class_maintenance
, set_backtrace_cmd
, _("\
2565 Set backtrace specific variables.\n\
2566 Configure backtrace variables such as the backtrace limit"),
2567 &set_backtrace_cmdlist
, "set backtrace ",
2568 0/*allow-unknown*/, &setlist
);
2569 add_prefix_cmd ("backtrace", class_maintenance
, show_backtrace_cmd
, _("\
2570 Show backtrace specific variables\n\
2571 Show backtrace variables such as the backtrace limit"),
2572 &show_backtrace_cmdlist
, "show backtrace ",
2573 0/*allow-unknown*/, &showlist
);
2575 add_setshow_boolean_cmd ("past-main", class_obscure
,
2576 &backtrace_past_main
, _("\
2577 Set whether backtraces should continue past \"main\"."), _("\
2578 Show whether backtraces should continue past \"main\"."), _("\
2579 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
2580 the backtrace at \"main\". Set this variable if you need to see the rest\n\
2581 of the stack trace."),
2583 show_backtrace_past_main
,
2584 &set_backtrace_cmdlist
,
2585 &show_backtrace_cmdlist
);
2587 add_setshow_boolean_cmd ("past-entry", class_obscure
,
2588 &backtrace_past_entry
, _("\
2589 Set whether backtraces should continue past the entry point of a program."),
2591 Show whether backtraces should continue past the entry point of a program."),
2593 Normally there are no callers beyond the entry point of a program, so GDB\n\
2594 will terminate the backtrace there. Set this variable if you need to see\n\
2595 the rest of the stack trace."),
2597 show_backtrace_past_entry
,
2598 &set_backtrace_cmdlist
,
2599 &show_backtrace_cmdlist
);
2601 add_setshow_uinteger_cmd ("limit", class_obscure
,
2602 &backtrace_limit
, _("\
2603 Set an upper bound on the number of backtrace levels."), _("\
2604 Show the upper bound on the number of backtrace levels."), _("\
2605 No more than the specified number of frames can be displayed or examined.\n\
2606 Literal \"unlimited\" or zero means no limit."),
2608 show_backtrace_limit
,
2609 &set_backtrace_cmdlist
,
2610 &show_backtrace_cmdlist
);
2612 /* Debug this files internals. */
2613 add_setshow_zuinteger_cmd ("frame", class_maintenance
, &frame_debug
, _("\
2614 Set frame debugging."), _("\
2615 Show frame debugging."), _("\
2616 When non-zero, frame specific internal debugging is enabled."),
2619 &setdebuglist
, &showdebuglist
);