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"
49 static struct frame_info
*get_prev_frame_1 (struct frame_info
*this_frame
);
50 static struct frame_info
*get_prev_frame_raw (struct frame_info
*this_frame
);
51 static const char *frame_stop_reason_symbol_string (enum unwind_stop_reason reason
);
53 /* We keep a cache of stack frames, each of which is a "struct
54 frame_info". The innermost one gets allocated (in
55 wait_for_inferior) each time the inferior stops; current_frame
56 points to it. Additional frames get allocated (in get_prev_frame)
57 as needed, and are chained through the next and prev fields. Any
58 time that the frame cache becomes invalid (most notably when we
59 execute something, but also if we change how we interpret the
60 frames (e.g. "set heuristic-fence-post" in mips-tdep.c, or anything
61 which reads new symbols)), we should call reinit_frame_cache. */
65 /* Level of this frame. The inner-most (youngest) frame is at level
66 0. As you move towards the outer-most (oldest) frame, the level
67 increases. This is a cached value. It could just as easily be
68 computed by counting back from the selected frame to the inner
70 /* NOTE: cagney/2002-04-05: Perhaps a level of ``-1'' should be
71 reserved to indicate a bogus frame - one that has been created
72 just to keep GDB happy (GDB always needs a frame). For the
73 moment leave this as speculation. */
76 /* The frame's program space. */
77 struct program_space
*pspace
;
79 /* The frame's address space. */
80 struct address_space
*aspace
;
82 /* The frame's low-level unwinder and corresponding cache. The
83 low-level unwinder is responsible for unwinding register values
84 for the previous frame. The low-level unwind methods are
85 selected based on the presence, or otherwise, of register unwind
86 information such as CFI. */
88 const struct frame_unwind
*unwind
;
90 /* Cached copy of the previous frame's architecture. */
97 /* Cached copy of the previous frame's resume address. */
103 /* Cached copy of the previous frame's function address. */
110 /* This frame's ID. */
114 struct frame_id value
;
117 /* The frame's high-level base methods, and corresponding cache.
118 The high level base methods are selected based on the frame's
120 const struct frame_base
*base
;
123 /* Pointers to the next (down, inner, younger) and previous (up,
124 outer, older) frame_info's in the frame cache. */
125 struct frame_info
*next
; /* down, inner, younger */
127 struct frame_info
*prev
; /* up, outer, older */
129 /* The reason why we could not set PREV, or UNWIND_NO_REASON if we
130 could. Only valid when PREV_P is set. */
131 enum unwind_stop_reason stop_reason
;
134 /* A frame stash used to speed up frame lookups. Create a hash table
135 to stash frames previously accessed from the frame cache for
136 quicker subsequent retrieval. The hash table is emptied whenever
137 the frame cache is invalidated. */
139 static htab_t frame_stash
;
141 /* Internal function to calculate a hash from the frame_id addresses,
142 using as many valid addresses as possible. Frames below level 0
143 are not stored in the hash table. */
146 frame_addr_hash (const void *ap
)
148 const struct frame_info
*frame
= ap
;
149 const struct frame_id f_id
= frame
->this_id
.value
;
152 gdb_assert (f_id
.stack_addr_p
|| f_id
.code_addr_p
153 || f_id
.special_addr_p
);
155 if (f_id
.stack_addr_p
)
156 hash
= iterative_hash (&f_id
.stack_addr
,
157 sizeof (f_id
.stack_addr
), hash
);
158 if (f_id
.code_addr_p
)
159 hash
= iterative_hash (&f_id
.code_addr
,
160 sizeof (f_id
.code_addr
), hash
);
161 if (f_id
.special_addr_p
)
162 hash
= iterative_hash (&f_id
.special_addr
,
163 sizeof (f_id
.special_addr
), hash
);
168 /* Internal equality function for the hash table. This function
169 defers equality operations to frame_id_eq. */
172 frame_addr_hash_eq (const void *a
, const void *b
)
174 const struct frame_info
*f_entry
= a
;
175 const struct frame_info
*f_element
= b
;
177 return frame_id_eq (f_entry
->this_id
.value
,
178 f_element
->this_id
.value
);
181 /* Internal function to create the frame_stash hash table. 100 seems
182 to be a good compromise to start the hash table at. */
185 frame_stash_create (void)
187 frame_stash
= htab_create (100,
193 /* Internal function to add a frame to the frame_stash hash table.
194 Returns false if a frame with the same ID was already stashed, true
198 frame_stash_add (struct frame_info
*frame
)
200 struct frame_info
**slot
;
202 /* Do not try to stash the sentinel frame. */
203 gdb_assert (frame
->level
>= 0);
205 slot
= (struct frame_info
**) htab_find_slot (frame_stash
,
209 /* If we already have a frame in the stack with the same id, we
210 either have a stack cycle (corrupted stack?), or some bug
211 elsewhere in GDB. In any case, ignore the duplicate and return
212 an indication to the caller. */
220 /* Internal function to search the frame stash for an entry with the
221 given frame ID. If found, return that frame. Otherwise return
224 static struct frame_info
*
225 frame_stash_find (struct frame_id id
)
227 struct frame_info dummy
;
228 struct frame_info
*frame
;
230 dummy
.this_id
.value
= id
;
231 frame
= htab_find (frame_stash
, &dummy
);
235 /* Internal function to invalidate the frame stash by removing all
236 entries in it. This only occurs when the frame cache is
240 frame_stash_invalidate (void)
242 htab_empty (frame_stash
);
245 /* Flag to control debugging. */
247 unsigned int frame_debug
;
249 show_frame_debug (struct ui_file
*file
, int from_tty
,
250 struct cmd_list_element
*c
, const char *value
)
252 fprintf_filtered (file
, _("Frame debugging is %s.\n"), value
);
255 /* Flag to indicate whether backtraces should stop at main et.al. */
257 static int backtrace_past_main
;
259 show_backtrace_past_main (struct ui_file
*file
, int from_tty
,
260 struct cmd_list_element
*c
, const char *value
)
262 fprintf_filtered (file
,
263 _("Whether backtraces should "
264 "continue past \"main\" is %s.\n"),
268 static int backtrace_past_entry
;
270 show_backtrace_past_entry (struct ui_file
*file
, int from_tty
,
271 struct cmd_list_element
*c
, const char *value
)
273 fprintf_filtered (file
, _("Whether backtraces should continue past the "
274 "entry point of a program is %s.\n"),
278 static unsigned int backtrace_limit
= UINT_MAX
;
280 show_backtrace_limit (struct ui_file
*file
, int from_tty
,
281 struct cmd_list_element
*c
, const char *value
)
283 fprintf_filtered (file
,
284 _("An upper bound on the number "
285 "of backtrace levels is %s.\n"),
291 fprint_field (struct ui_file
*file
, const char *name
, int p
, CORE_ADDR addr
)
294 fprintf_unfiltered (file
, "%s=%s", name
, hex_string (addr
));
296 fprintf_unfiltered (file
, "!%s", name
);
300 fprint_frame_id (struct ui_file
*file
, struct frame_id id
)
302 fprintf_unfiltered (file
, "{");
303 fprint_field (file
, "stack", id
.stack_addr_p
, id
.stack_addr
);
304 fprintf_unfiltered (file
, ",");
305 fprint_field (file
, "code", id
.code_addr_p
, id
.code_addr
);
306 fprintf_unfiltered (file
, ",");
307 fprint_field (file
, "special", id
.special_addr_p
, id
.special_addr
);
308 if (id
.artificial_depth
)
309 fprintf_unfiltered (file
, ",artificial=%d", id
.artificial_depth
);
310 fprintf_unfiltered (file
, "}");
314 fprint_frame_type (struct ui_file
*file
, enum frame_type type
)
319 fprintf_unfiltered (file
, "NORMAL_FRAME");
322 fprintf_unfiltered (file
, "DUMMY_FRAME");
325 fprintf_unfiltered (file
, "INLINE_FRAME");
328 fprintf_unfiltered (file
, "TAILCALL_FRAME");
331 fprintf_unfiltered (file
, "SIGTRAMP_FRAME");
334 fprintf_unfiltered (file
, "ARCH_FRAME");
337 fprintf_unfiltered (file
, "SENTINEL_FRAME");
340 fprintf_unfiltered (file
, "<unknown type>");
346 fprint_frame (struct ui_file
*file
, struct frame_info
*fi
)
350 fprintf_unfiltered (file
, "<NULL frame>");
353 fprintf_unfiltered (file
, "{");
354 fprintf_unfiltered (file
, "level=%d", fi
->level
);
355 fprintf_unfiltered (file
, ",");
356 fprintf_unfiltered (file
, "type=");
357 if (fi
->unwind
!= NULL
)
358 fprint_frame_type (file
, fi
->unwind
->type
);
360 fprintf_unfiltered (file
, "<unknown>");
361 fprintf_unfiltered (file
, ",");
362 fprintf_unfiltered (file
, "unwind=");
363 if (fi
->unwind
!= NULL
)
364 gdb_print_host_address (fi
->unwind
, file
);
366 fprintf_unfiltered (file
, "<unknown>");
367 fprintf_unfiltered (file
, ",");
368 fprintf_unfiltered (file
, "pc=");
369 if (fi
->next
!= NULL
&& fi
->next
->prev_pc
.p
)
370 fprintf_unfiltered (file
, "%s", hex_string (fi
->next
->prev_pc
.value
));
372 fprintf_unfiltered (file
, "<unknown>");
373 fprintf_unfiltered (file
, ",");
374 fprintf_unfiltered (file
, "id=");
376 fprint_frame_id (file
, fi
->this_id
.value
);
378 fprintf_unfiltered (file
, "<unknown>");
379 fprintf_unfiltered (file
, ",");
380 fprintf_unfiltered (file
, "func=");
381 if (fi
->next
!= NULL
&& fi
->next
->prev_func
.p
)
382 fprintf_unfiltered (file
, "%s", hex_string (fi
->next
->prev_func
.addr
));
384 fprintf_unfiltered (file
, "<unknown>");
385 fprintf_unfiltered (file
, "}");
388 /* Given FRAME, return the enclosing frame as found in real frames read-in from
389 inferior memory. Skip any previous frames which were made up by GDB.
390 Return the original frame if no immediate previous frames exist. */
392 static struct frame_info
*
393 skip_artificial_frames (struct frame_info
*frame
)
395 while (get_frame_type (frame
) == INLINE_FRAME
396 || get_frame_type (frame
) == TAILCALL_FRAME
)
397 frame
= get_prev_frame (frame
);
402 /* Compute the frame's uniq ID that can be used to, later, re-find the
406 compute_frame_id (struct frame_info
*fi
)
408 gdb_assert (!fi
->this_id
.p
);
411 fprintf_unfiltered (gdb_stdlog
, "{ compute_frame_id (fi=%d) ",
413 /* Find the unwinder. */
414 if (fi
->unwind
== NULL
)
415 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
416 /* Find THIS frame's ID. */
417 /* Default to outermost if no ID is found. */
418 fi
->this_id
.value
= outer_frame_id
;
419 fi
->unwind
->this_id (fi
, &fi
->prologue_cache
, &fi
->this_id
.value
);
420 gdb_assert (frame_id_p (fi
->this_id
.value
));
424 fprintf_unfiltered (gdb_stdlog
, "-> ");
425 fprint_frame_id (gdb_stdlog
, fi
->this_id
.value
);
426 fprintf_unfiltered (gdb_stdlog
, " }\n");
430 /* Return a frame uniq ID that can be used to, later, re-find the
434 get_frame_id (struct frame_info
*fi
)
437 return null_frame_id
;
439 gdb_assert (fi
->this_id
.p
);
440 return fi
->this_id
.value
;
444 get_stack_frame_id (struct frame_info
*next_frame
)
446 return get_frame_id (skip_artificial_frames (next_frame
));
450 frame_unwind_caller_id (struct frame_info
*next_frame
)
452 struct frame_info
*this_frame
;
454 /* Use get_prev_frame_1, and not get_prev_frame. The latter will truncate
455 the frame chain, leading to this function unintentionally
456 returning a null_frame_id (e.g., when a caller requests the frame
457 ID of "main()"s caller. */
459 next_frame
= skip_artificial_frames (next_frame
);
460 this_frame
= get_prev_frame_1 (next_frame
);
462 return get_frame_id (skip_artificial_frames (this_frame
));
464 return null_frame_id
;
467 const struct frame_id null_frame_id
; /* All zeros. */
468 const struct frame_id outer_frame_id
= { 0, 0, 0, 0, 0, 1, 0 };
471 frame_id_build_special (CORE_ADDR stack_addr
, CORE_ADDR code_addr
,
472 CORE_ADDR special_addr
)
474 struct frame_id id
= null_frame_id
;
476 id
.stack_addr
= stack_addr
;
478 id
.code_addr
= code_addr
;
480 id
.special_addr
= special_addr
;
481 id
.special_addr_p
= 1;
486 frame_id_build (CORE_ADDR stack_addr
, CORE_ADDR code_addr
)
488 struct frame_id id
= null_frame_id
;
490 id
.stack_addr
= stack_addr
;
492 id
.code_addr
= code_addr
;
498 frame_id_build_wild (CORE_ADDR stack_addr
)
500 struct frame_id id
= null_frame_id
;
502 id
.stack_addr
= stack_addr
;
508 frame_id_p (struct frame_id l
)
512 /* The frame is valid iff it has a valid stack address. */
514 /* outer_frame_id is also valid. */
515 if (!p
&& memcmp (&l
, &outer_frame_id
, sizeof (l
)) == 0)
519 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_p (l=");
520 fprint_frame_id (gdb_stdlog
, l
);
521 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", p
);
527 frame_id_artificial_p (struct frame_id l
)
532 return (l
.artificial_depth
!= 0);
536 frame_id_eq (struct frame_id l
, struct frame_id r
)
540 if (!l
.stack_addr_p
&& l
.special_addr_p
541 && !r
.stack_addr_p
&& r
.special_addr_p
)
542 /* The outermost frame marker is equal to itself. This is the
543 dodgy thing about outer_frame_id, since between execution steps
544 we might step into another function - from which we can't
545 unwind either. More thought required to get rid of
548 else if (!l
.stack_addr_p
|| !r
.stack_addr_p
)
549 /* Like a NaN, if either ID is invalid, the result is false.
550 Note that a frame ID is invalid iff it is the null frame ID. */
552 else if (l
.stack_addr
!= r
.stack_addr
)
553 /* If .stack addresses are different, the frames are different. */
555 else if (l
.code_addr_p
&& r
.code_addr_p
&& l
.code_addr
!= r
.code_addr
)
556 /* An invalid code addr is a wild card. If .code addresses are
557 different, the frames are different. */
559 else if (l
.special_addr_p
&& r
.special_addr_p
560 && l
.special_addr
!= r
.special_addr
)
561 /* An invalid special addr is a wild card (or unused). Otherwise
562 if special addresses are different, the frames are different. */
564 else if (l
.artificial_depth
!= r
.artificial_depth
)
565 /* If artifical depths are different, the frames must be different. */
568 /* Frames are equal. */
573 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_eq (l=");
574 fprint_frame_id (gdb_stdlog
, l
);
575 fprintf_unfiltered (gdb_stdlog
, ",r=");
576 fprint_frame_id (gdb_stdlog
, r
);
577 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", eq
);
582 /* Safety net to check whether frame ID L should be inner to
583 frame ID R, according to their stack addresses.
585 This method cannot be used to compare arbitrary frames, as the
586 ranges of valid stack addresses may be discontiguous (e.g. due
589 However, it can be used as safety net to discover invalid frame
590 IDs in certain circumstances. Assuming that NEXT is the immediate
591 inner frame to THIS and that NEXT and THIS are both NORMAL frames:
593 * The stack address of NEXT must be inner-than-or-equal to the stack
596 Therefore, if frame_id_inner (THIS, NEXT) holds, some unwind
599 * If NEXT and THIS have different stack addresses, no other frame
600 in the frame chain may have a stack address in between.
602 Therefore, if frame_id_inner (TEST, THIS) holds, but
603 frame_id_inner (TEST, NEXT) does not hold, TEST cannot refer
604 to a valid frame in the frame chain.
606 The sanity checks above cannot be performed when a SIGTRAMP frame
607 is involved, because signal handlers might be executed on a different
608 stack than the stack used by the routine that caused the signal
609 to be raised. This can happen for instance when a thread exceeds
610 its maximum stack size. In this case, certain compilers implement
611 a stack overflow strategy that cause the handler to be run on a
615 frame_id_inner (struct gdbarch
*gdbarch
, struct frame_id l
, struct frame_id r
)
619 if (!l
.stack_addr_p
|| !r
.stack_addr_p
)
620 /* Like NaN, any operation involving an invalid ID always fails. */
622 else if (l
.artificial_depth
> r
.artificial_depth
623 && l
.stack_addr
== r
.stack_addr
624 && l
.code_addr_p
== r
.code_addr_p
625 && l
.special_addr_p
== r
.special_addr_p
626 && l
.special_addr
== r
.special_addr
)
628 /* Same function, different inlined functions. */
629 struct block
*lb
, *rb
;
631 gdb_assert (l
.code_addr_p
&& r
.code_addr_p
);
633 lb
= block_for_pc (l
.code_addr
);
634 rb
= block_for_pc (r
.code_addr
);
636 if (lb
== NULL
|| rb
== NULL
)
637 /* Something's gone wrong. */
640 /* This will return true if LB and RB are the same block, or
641 if the block with the smaller depth lexically encloses the
642 block with the greater depth. */
643 inner
= contained_in (lb
, rb
);
646 /* Only return non-zero when strictly inner than. Note that, per
647 comment in "frame.h", there is some fuzz here. Frameless
648 functions are not strictly inner than (same .stack but
649 different .code and/or .special address). */
650 inner
= gdbarch_inner_than (gdbarch
, l
.stack_addr
, r
.stack_addr
);
653 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_inner (l=");
654 fprint_frame_id (gdb_stdlog
, l
);
655 fprintf_unfiltered (gdb_stdlog
, ",r=");
656 fprint_frame_id (gdb_stdlog
, r
);
657 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", inner
);
663 frame_find_by_id (struct frame_id id
)
665 struct frame_info
*frame
, *prev_frame
;
667 /* ZERO denotes the null frame, let the caller decide what to do
668 about it. Should it instead return get_current_frame()? */
669 if (!frame_id_p (id
))
672 /* Try using the frame stash first. Finding it there removes the need
673 to perform the search by looping over all frames, which can be very
674 CPU-intensive if the number of frames is very high (the loop is O(n)
675 and get_prev_frame performs a series of checks that are relatively
676 expensive). This optimization is particularly useful when this function
677 is called from another function (such as value_fetch_lazy, case
678 VALUE_LVAL (val) == lval_register) which already loops over all frames,
679 making the overall behavior O(n^2). */
680 frame
= frame_stash_find (id
);
684 for (frame
= get_current_frame (); ; frame
= prev_frame
)
686 struct frame_id
this = get_frame_id (frame
);
688 if (frame_id_eq (id
, this))
689 /* An exact match. */
692 prev_frame
= get_prev_frame (frame
);
696 /* As a safety net to avoid unnecessary backtracing while trying
697 to find an invalid ID, we check for a common situation where
698 we can detect from comparing stack addresses that no other
699 frame in the current frame chain can have this ID. See the
700 comment at frame_id_inner for details. */
701 if (get_frame_type (frame
) == NORMAL_FRAME
702 && !frame_id_inner (get_frame_arch (frame
), id
, this)
703 && frame_id_inner (get_frame_arch (prev_frame
), id
,
704 get_frame_id (prev_frame
)))
711 frame_unwind_pc_if_available (struct frame_info
*this_frame
, CORE_ADDR
*pc
)
713 if (!this_frame
->prev_pc
.p
)
715 if (gdbarch_unwind_pc_p (frame_unwind_arch (this_frame
)))
717 volatile struct gdb_exception ex
;
718 struct gdbarch
*prev_gdbarch
;
721 /* The right way. The `pure' way. The one true way. This
722 method depends solely on the register-unwind code to
723 determine the value of registers in THIS frame, and hence
724 the value of this frame's PC (resume address). A typical
725 implementation is no more than:
727 frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
728 return extract_unsigned_integer (buf, size of ISA_PC_REGNUM);
730 Note: this method is very heavily dependent on a correct
731 register-unwind implementation, it pays to fix that
732 method first; this method is frame type agnostic, since
733 it only deals with register values, it works with any
734 frame. This is all in stark contrast to the old
735 FRAME_SAVED_PC which would try to directly handle all the
736 different ways that a PC could be unwound. */
737 prev_gdbarch
= frame_unwind_arch (this_frame
);
739 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
741 pc
= gdbarch_unwind_pc (prev_gdbarch
, this_frame
);
743 if (ex
.reason
< 0 && ex
.error
== NOT_AVAILABLE_ERROR
)
745 this_frame
->prev_pc
.p
= -1;
748 fprintf_unfiltered (gdb_stdlog
,
749 "{ frame_unwind_pc (this_frame=%d)"
750 " -> <unavailable> }\n",
753 else if (ex
.reason
< 0)
755 throw_exception (ex
);
759 this_frame
->prev_pc
.value
= pc
;
760 this_frame
->prev_pc
.p
= 1;
762 fprintf_unfiltered (gdb_stdlog
,
763 "{ frame_unwind_pc (this_frame=%d) "
766 hex_string (this_frame
->prev_pc
.value
));
770 internal_error (__FILE__
, __LINE__
, _("No unwind_pc method"));
772 if (this_frame
->prev_pc
.p
< 0)
779 *pc
= this_frame
->prev_pc
.value
;
785 frame_unwind_pc (struct frame_info
*this_frame
)
789 if (!frame_unwind_pc_if_available (this_frame
, &pc
))
790 throw_error (NOT_AVAILABLE_ERROR
, _("PC not available"));
796 frame_unwind_caller_pc (struct frame_info
*this_frame
)
798 return frame_unwind_pc (skip_artificial_frames (this_frame
));
802 frame_unwind_caller_pc_if_available (struct frame_info
*this_frame
,
805 return frame_unwind_pc_if_available (skip_artificial_frames (this_frame
), pc
);
809 get_frame_func_if_available (struct frame_info
*this_frame
, CORE_ADDR
*pc
)
811 struct frame_info
*next_frame
= this_frame
->next
;
813 if (!next_frame
->prev_func
.p
)
815 CORE_ADDR addr_in_block
;
817 /* Make certain that this, and not the adjacent, function is
819 if (!get_frame_address_in_block_if_available (this_frame
, &addr_in_block
))
821 next_frame
->prev_func
.p
= -1;
823 fprintf_unfiltered (gdb_stdlog
,
824 "{ get_frame_func (this_frame=%d)"
825 " -> unavailable }\n",
830 next_frame
->prev_func
.p
= 1;
831 next_frame
->prev_func
.addr
= get_pc_function_start (addr_in_block
);
833 fprintf_unfiltered (gdb_stdlog
,
834 "{ get_frame_func (this_frame=%d) -> %s }\n",
836 hex_string (next_frame
->prev_func
.addr
));
840 if (next_frame
->prev_func
.p
< 0)
847 *pc
= next_frame
->prev_func
.addr
;
853 get_frame_func (struct frame_info
*this_frame
)
857 if (!get_frame_func_if_available (this_frame
, &pc
))
858 throw_error (NOT_AVAILABLE_ERROR
, _("PC not available"));
863 static enum register_status
864 do_frame_register_read (void *src
, int regnum
, gdb_byte
*buf
)
866 if (!deprecated_frame_register_read (src
, regnum
, buf
))
867 return REG_UNAVAILABLE
;
873 frame_save_as_regcache (struct frame_info
*this_frame
)
875 struct address_space
*aspace
= get_frame_address_space (this_frame
);
876 struct regcache
*regcache
= regcache_xmalloc (get_frame_arch (this_frame
),
878 struct cleanup
*cleanups
= make_cleanup_regcache_xfree (regcache
);
880 regcache_save (regcache
, do_frame_register_read
, this_frame
);
881 discard_cleanups (cleanups
);
886 frame_pop (struct frame_info
*this_frame
)
888 struct frame_info
*prev_frame
;
889 struct regcache
*scratch
;
890 struct cleanup
*cleanups
;
892 if (get_frame_type (this_frame
) == DUMMY_FRAME
)
894 /* Popping a dummy frame involves restoring more than just registers.
895 dummy_frame_pop does all the work. */
896 dummy_frame_pop (get_frame_id (this_frame
));
900 /* Ensure that we have a frame to pop to. */
901 prev_frame
= get_prev_frame_1 (this_frame
);
904 error (_("Cannot pop the initial frame."));
906 /* Ignore TAILCALL_FRAME type frames, they were executed already before
907 entering THISFRAME. */
908 while (get_frame_type (prev_frame
) == TAILCALL_FRAME
)
909 prev_frame
= get_prev_frame (prev_frame
);
911 /* Make a copy of all the register values unwound from this frame.
912 Save them in a scratch buffer so that there isn't a race between
913 trying to extract the old values from the current regcache while
914 at the same time writing new values into that same cache. */
915 scratch
= frame_save_as_regcache (prev_frame
);
916 cleanups
= make_cleanup_regcache_xfree (scratch
);
918 /* FIXME: cagney/2003-03-16: It should be possible to tell the
919 target's register cache that it is about to be hit with a burst
920 register transfer and that the sequence of register writes should
921 be batched. The pair target_prepare_to_store() and
922 target_store_registers() kind of suggest this functionality.
923 Unfortunately, they don't implement it. Their lack of a formal
924 definition can lead to targets writing back bogus values
925 (arguably a bug in the target code mind). */
926 /* Now copy those saved registers into the current regcache.
927 Here, regcache_cpy() calls regcache_restore(). */
928 regcache_cpy (get_current_regcache (), scratch
);
929 do_cleanups (cleanups
);
931 /* We've made right mess of GDB's local state, just discard
933 reinit_frame_cache ();
937 frame_register_unwind (struct frame_info
*frame
, int regnum
,
938 int *optimizedp
, int *unavailablep
,
939 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
940 int *realnump
, gdb_byte
*bufferp
)
944 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
945 that the value proper does not need to be fetched. */
946 gdb_assert (optimizedp
!= NULL
);
947 gdb_assert (lvalp
!= NULL
);
948 gdb_assert (addrp
!= NULL
);
949 gdb_assert (realnump
!= NULL
);
950 /* gdb_assert (bufferp != NULL); */
952 value
= frame_unwind_register_value (frame
, regnum
);
954 gdb_assert (value
!= NULL
);
956 *optimizedp
= value_optimized_out (value
);
957 *unavailablep
= !value_entirely_available (value
);
958 *lvalp
= VALUE_LVAL (value
);
959 *addrp
= value_address (value
);
960 *realnump
= VALUE_REGNUM (value
);
964 if (!*optimizedp
&& !*unavailablep
)
965 memcpy (bufferp
, value_contents_all (value
),
966 TYPE_LENGTH (value_type (value
)));
968 memset (bufferp
, 0, TYPE_LENGTH (value_type (value
)));
971 /* Dispose of the new value. This prevents watchpoints from
972 trying to watch the saved frame pointer. */
973 release_value (value
);
978 frame_register (struct frame_info
*frame
, int regnum
,
979 int *optimizedp
, int *unavailablep
, enum lval_type
*lvalp
,
980 CORE_ADDR
*addrp
, int *realnump
, gdb_byte
*bufferp
)
982 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
983 that the value proper does not need to be fetched. */
984 gdb_assert (optimizedp
!= NULL
);
985 gdb_assert (lvalp
!= NULL
);
986 gdb_assert (addrp
!= NULL
);
987 gdb_assert (realnump
!= NULL
);
988 /* gdb_assert (bufferp != NULL); */
990 /* Obtain the register value by unwinding the register from the next
991 (more inner frame). */
992 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
993 frame_register_unwind (frame
->next
, regnum
, optimizedp
, unavailablep
,
994 lvalp
, addrp
, realnump
, bufferp
);
998 frame_unwind_register (struct frame_info
*frame
, int regnum
, gdb_byte
*buf
)
1004 enum lval_type lval
;
1006 frame_register_unwind (frame
, regnum
, &optimized
, &unavailable
,
1007 &lval
, &addr
, &realnum
, buf
);
1010 throw_error (OPTIMIZED_OUT_ERROR
,
1011 _("Register %d was not saved"), regnum
);
1013 throw_error (NOT_AVAILABLE_ERROR
,
1014 _("Register %d is not available"), regnum
);
1018 get_frame_register (struct frame_info
*frame
,
1019 int regnum
, gdb_byte
*buf
)
1021 frame_unwind_register (frame
->next
, regnum
, buf
);
1025 frame_unwind_register_value (struct frame_info
*frame
, int regnum
)
1027 struct gdbarch
*gdbarch
;
1028 struct value
*value
;
1030 gdb_assert (frame
!= NULL
);
1031 gdbarch
= frame_unwind_arch (frame
);
1035 fprintf_unfiltered (gdb_stdlog
,
1036 "{ frame_unwind_register_value "
1037 "(frame=%d,regnum=%d(%s),...) ",
1038 frame
->level
, regnum
,
1039 user_reg_map_regnum_to_name (gdbarch
, regnum
));
1042 /* Find the unwinder. */
1043 if (frame
->unwind
== NULL
)
1044 frame_unwind_find_by_frame (frame
, &frame
->prologue_cache
);
1046 /* Ask this frame to unwind its register. */
1047 value
= frame
->unwind
->prev_register (frame
, &frame
->prologue_cache
, regnum
);
1051 fprintf_unfiltered (gdb_stdlog
, "->");
1052 if (value_optimized_out (value
))
1054 fprintf_unfiltered (gdb_stdlog
, " ");
1055 val_print_optimized_out (value
, gdb_stdlog
);
1059 if (VALUE_LVAL (value
) == lval_register
)
1060 fprintf_unfiltered (gdb_stdlog
, " register=%d",
1061 VALUE_REGNUM (value
));
1062 else if (VALUE_LVAL (value
) == lval_memory
)
1063 fprintf_unfiltered (gdb_stdlog
, " address=%s",
1065 value_address (value
)));
1067 fprintf_unfiltered (gdb_stdlog
, " computed");
1069 if (value_lazy (value
))
1070 fprintf_unfiltered (gdb_stdlog
, " lazy");
1074 const gdb_byte
*buf
= value_contents (value
);
1076 fprintf_unfiltered (gdb_stdlog
, " bytes=");
1077 fprintf_unfiltered (gdb_stdlog
, "[");
1078 for (i
= 0; i
< register_size (gdbarch
, regnum
); i
++)
1079 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1080 fprintf_unfiltered (gdb_stdlog
, "]");
1084 fprintf_unfiltered (gdb_stdlog
, " }\n");
1091 get_frame_register_value (struct frame_info
*frame
, int regnum
)
1093 return frame_unwind_register_value (frame
->next
, regnum
);
1097 frame_unwind_register_signed (struct frame_info
*frame
, int regnum
)
1099 struct gdbarch
*gdbarch
= frame_unwind_arch (frame
);
1100 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1101 int size
= register_size (gdbarch
, regnum
);
1102 gdb_byte buf
[MAX_REGISTER_SIZE
];
1104 frame_unwind_register (frame
, regnum
, buf
);
1105 return extract_signed_integer (buf
, size
, byte_order
);
1109 get_frame_register_signed (struct frame_info
*frame
, int regnum
)
1111 return frame_unwind_register_signed (frame
->next
, regnum
);
1115 frame_unwind_register_unsigned (struct frame_info
*frame
, int regnum
)
1117 struct gdbarch
*gdbarch
= frame_unwind_arch (frame
);
1118 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1119 int size
= register_size (gdbarch
, regnum
);
1120 gdb_byte buf
[MAX_REGISTER_SIZE
];
1122 frame_unwind_register (frame
, regnum
, buf
);
1123 return extract_unsigned_integer (buf
, size
, byte_order
);
1127 get_frame_register_unsigned (struct frame_info
*frame
, int regnum
)
1129 return frame_unwind_register_unsigned (frame
->next
, regnum
);
1133 read_frame_register_unsigned (struct frame_info
*frame
, int regnum
,
1136 struct value
*regval
= get_frame_register_value (frame
, regnum
);
1138 if (!value_optimized_out (regval
)
1139 && value_entirely_available (regval
))
1141 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1142 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1143 int size
= register_size (gdbarch
, VALUE_REGNUM (regval
));
1145 *val
= extract_unsigned_integer (value_contents (regval
), size
, byte_order
);
1153 put_frame_register (struct frame_info
*frame
, int regnum
,
1154 const gdb_byte
*buf
)
1156 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1160 enum lval_type lval
;
1163 frame_register (frame
, regnum
, &optim
, &unavail
,
1164 &lval
, &addr
, &realnum
, NULL
);
1166 error (_("Attempt to assign to a register that was not saved."));
1171 write_memory (addr
, buf
, register_size (gdbarch
, regnum
));
1175 regcache_cooked_write (get_current_regcache (), realnum
, buf
);
1178 error (_("Attempt to assign to an unmodifiable value."));
1182 /* This function is deprecated. Use get_frame_register_value instead,
1183 which provides more accurate information.
1185 Find and return the value of REGNUM for the specified stack frame.
1186 The number of bytes copied is REGISTER_SIZE (REGNUM).
1188 Returns 0 if the register value could not be found. */
1191 deprecated_frame_register_read (struct frame_info
*frame
, int regnum
,
1196 enum lval_type lval
;
1200 frame_register (frame
, regnum
, &optimized
, &unavailable
,
1201 &lval
, &addr
, &realnum
, myaddr
);
1203 return !optimized
&& !unavailable
;
1207 get_frame_register_bytes (struct frame_info
*frame
, int regnum
,
1208 CORE_ADDR offset
, int len
, gdb_byte
*myaddr
,
1209 int *optimizedp
, int *unavailablep
)
1211 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1216 /* Skip registers wholly inside of OFFSET. */
1217 while (offset
>= register_size (gdbarch
, regnum
))
1219 offset
-= register_size (gdbarch
, regnum
);
1223 /* Ensure that we will not read beyond the end of the register file.
1224 This can only ever happen if the debug information is bad. */
1226 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1227 for (i
= regnum
; i
< numregs
; i
++)
1229 int thissize
= register_size (gdbarch
, i
);
1232 break; /* This register is not available on this architecture. */
1233 maxsize
+= thissize
;
1236 error (_("Bad debug information detected: "
1237 "Attempt to read %d bytes from registers."), len
);
1239 /* Copy the data. */
1242 int curr_len
= register_size (gdbarch
, regnum
) - offset
;
1247 if (curr_len
== register_size (gdbarch
, regnum
))
1249 enum lval_type lval
;
1253 frame_register (frame
, regnum
, optimizedp
, unavailablep
,
1254 &lval
, &addr
, &realnum
, myaddr
);
1255 if (*optimizedp
|| *unavailablep
)
1260 gdb_byte buf
[MAX_REGISTER_SIZE
];
1261 enum lval_type lval
;
1265 frame_register (frame
, regnum
, optimizedp
, unavailablep
,
1266 &lval
, &addr
, &realnum
, buf
);
1267 if (*optimizedp
|| *unavailablep
)
1269 memcpy (myaddr
, buf
+ offset
, curr_len
);
1284 put_frame_register_bytes (struct frame_info
*frame
, int regnum
,
1285 CORE_ADDR offset
, int len
, const gdb_byte
*myaddr
)
1287 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1289 /* Skip registers wholly inside of OFFSET. */
1290 while (offset
>= register_size (gdbarch
, regnum
))
1292 offset
-= register_size (gdbarch
, regnum
);
1296 /* Copy the data. */
1299 int curr_len
= register_size (gdbarch
, regnum
) - offset
;
1304 if (curr_len
== register_size (gdbarch
, regnum
))
1306 put_frame_register (frame
, regnum
, myaddr
);
1310 gdb_byte buf
[MAX_REGISTER_SIZE
];
1312 deprecated_frame_register_read (frame
, regnum
, buf
);
1313 memcpy (buf
+ offset
, myaddr
, curr_len
);
1314 put_frame_register (frame
, regnum
, buf
);
1324 /* Create a sentinel frame. */
1326 static struct frame_info
*
1327 create_sentinel_frame (struct program_space
*pspace
, struct regcache
*regcache
)
1329 struct frame_info
*frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1332 frame
->pspace
= pspace
;
1333 frame
->aspace
= get_regcache_aspace (regcache
);
1334 /* Explicitly initialize the sentinel frame's cache. Provide it
1335 with the underlying regcache. In the future additional
1336 information, such as the frame's thread will be added. */
1337 frame
->prologue_cache
= sentinel_frame_cache (regcache
);
1338 /* For the moment there is only one sentinel frame implementation. */
1339 frame
->unwind
= &sentinel_frame_unwind
;
1340 /* Link this frame back to itself. The frame is self referential
1341 (the unwound PC is the same as the pc), so make it so. */
1342 frame
->next
= frame
;
1343 /* Make the sentinel frame's ID valid, but invalid. That way all
1344 comparisons with it should fail. */
1345 frame
->this_id
.p
= 1;
1346 frame
->this_id
.value
= null_frame_id
;
1349 fprintf_unfiltered (gdb_stdlog
, "{ create_sentinel_frame (...) -> ");
1350 fprint_frame (gdb_stdlog
, frame
);
1351 fprintf_unfiltered (gdb_stdlog
, " }\n");
1356 /* Info about the innermost stack frame (contents of FP register). */
1358 static struct frame_info
*current_frame
;
1360 /* Cache for frame addresses already read by gdb. Valid only while
1361 inferior is stopped. Control variables for the frame cache should
1362 be local to this module. */
1364 static struct obstack frame_cache_obstack
;
1367 frame_obstack_zalloc (unsigned long size
)
1369 void *data
= obstack_alloc (&frame_cache_obstack
, size
);
1371 memset (data
, 0, size
);
1375 /* Return the innermost (currently executing) stack frame. This is
1376 split into two functions. The function unwind_to_current_frame()
1377 is wrapped in catch exceptions so that, even when the unwind of the
1378 sentinel frame fails, the function still returns a stack frame. */
1381 unwind_to_current_frame (struct ui_out
*ui_out
, void *args
)
1383 struct frame_info
*frame
= get_prev_frame (args
);
1385 /* A sentinel frame can fail to unwind, e.g., because its PC value
1386 lands in somewhere like start. */
1389 current_frame
= frame
;
1394 get_current_frame (void)
1396 /* First check, and report, the lack of registers. Having GDB
1397 report "No stack!" or "No memory" when the target doesn't even
1398 have registers is very confusing. Besides, "printcmd.exp"
1399 explicitly checks that ``print $pc'' with no registers prints "No
1401 if (!target_has_registers
)
1402 error (_("No registers."));
1403 if (!target_has_stack
)
1404 error (_("No stack."));
1405 if (!target_has_memory
)
1406 error (_("No memory."));
1407 /* Traceframes are effectively a substitute for the live inferior. */
1408 if (get_traceframe_number () < 0)
1410 if (ptid_equal (inferior_ptid
, null_ptid
))
1411 error (_("No selected thread."));
1412 if (is_exited (inferior_ptid
))
1413 error (_("Invalid selected thread."));
1414 if (is_executing (inferior_ptid
))
1415 error (_("Target is executing."));
1418 if (current_frame
== NULL
)
1420 struct frame_info
*sentinel_frame
=
1421 create_sentinel_frame (current_program_space
, get_current_regcache ());
1422 if (catch_exceptions (current_uiout
, unwind_to_current_frame
,
1423 sentinel_frame
, RETURN_MASK_ERROR
) != 0)
1425 /* Oops! Fake a current frame? Is this useful? It has a PC
1426 of zero, for instance. */
1427 current_frame
= sentinel_frame
;
1430 return current_frame
;
1433 /* The "selected" stack frame is used by default for local and arg
1434 access. May be zero, for no selected frame. */
1436 static struct frame_info
*selected_frame
;
1439 has_stack_frames (void)
1441 if (!target_has_registers
|| !target_has_stack
|| !target_has_memory
)
1444 /* Traceframes are effectively a substitute for the live inferior. */
1445 if (get_traceframe_number () < 0)
1447 /* No current inferior, no frame. */
1448 if (ptid_equal (inferior_ptid
, null_ptid
))
1451 /* Don't try to read from a dead thread. */
1452 if (is_exited (inferior_ptid
))
1455 /* ... or from a spinning thread. */
1456 if (is_executing (inferior_ptid
))
1463 /* Return the selected frame. Always non-NULL (unless there isn't an
1464 inferior sufficient for creating a frame) in which case an error is
1468 get_selected_frame (const char *message
)
1470 if (selected_frame
== NULL
)
1472 if (message
!= NULL
&& !has_stack_frames ())
1473 error (("%s"), message
);
1474 /* Hey! Don't trust this. It should really be re-finding the
1475 last selected frame of the currently selected thread. This,
1476 though, is better than nothing. */
1477 select_frame (get_current_frame ());
1479 /* There is always a frame. */
1480 gdb_assert (selected_frame
!= NULL
);
1481 return selected_frame
;
1484 /* If there is a selected frame, return it. Otherwise, return NULL. */
1487 get_selected_frame_if_set (void)
1489 return selected_frame
;
1492 /* This is a variant of get_selected_frame() which can be called when
1493 the inferior does not have a frame; in that case it will return
1494 NULL instead of calling error(). */
1497 deprecated_safe_get_selected_frame (void)
1499 if (!has_stack_frames ())
1501 return get_selected_frame (NULL
);
1504 /* Select frame FI (or NULL - to invalidate the current frame). */
1507 select_frame (struct frame_info
*fi
)
1509 selected_frame
= fi
;
1510 /* NOTE: cagney/2002-05-04: FI can be NULL. This occurs when the
1511 frame is being invalidated. */
1512 if (deprecated_selected_frame_level_changed_hook
)
1513 deprecated_selected_frame_level_changed_hook (frame_relative_level (fi
));
1515 /* FIXME: kseitz/2002-08-28: It would be nice to call
1516 selected_frame_level_changed_event() right here, but due to limitations
1517 in the current interfaces, we would end up flooding UIs with events
1518 because select_frame() is used extensively internally.
1520 Once we have frame-parameterized frame (and frame-related) commands,
1521 the event notification can be moved here, since this function will only
1522 be called when the user's selected frame is being changed. */
1524 /* Ensure that symbols for this frame are read in. Also, determine the
1525 source language of this frame, and switch to it if desired. */
1530 /* We retrieve the frame's symtab by using the frame PC.
1531 However we cannot use the frame PC as-is, because it usually
1532 points to the instruction following the "call", which is
1533 sometimes the first instruction of another function. So we
1534 rely on get_frame_address_in_block() which provides us with a
1535 PC which is guaranteed to be inside the frame's code
1537 if (get_frame_address_in_block_if_available (fi
, &pc
))
1539 struct symtab
*s
= find_pc_symtab (pc
);
1542 && s
->language
!= current_language
->la_language
1543 && s
->language
!= language_unknown
1544 && language_mode
== language_mode_auto
)
1545 set_language (s
->language
);
1550 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
1551 Always returns a non-NULL value. */
1554 create_new_frame (CORE_ADDR addr
, CORE_ADDR pc
)
1556 struct frame_info
*fi
;
1560 fprintf_unfiltered (gdb_stdlog
,
1561 "{ create_new_frame (addr=%s, pc=%s) ",
1562 hex_string (addr
), hex_string (pc
));
1565 fi
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1567 fi
->next
= create_sentinel_frame (current_program_space
,
1568 get_current_regcache ());
1570 /* Set/update this frame's cached PC value, found in the next frame.
1571 Do this before looking for this frame's unwinder. A sniffer is
1572 very likely to read this, and the corresponding unwinder is
1573 entitled to rely that the PC doesn't magically change. */
1574 fi
->next
->prev_pc
.value
= pc
;
1575 fi
->next
->prev_pc
.p
= 1;
1577 /* We currently assume that frame chain's can't cross spaces. */
1578 fi
->pspace
= fi
->next
->pspace
;
1579 fi
->aspace
= fi
->next
->aspace
;
1581 /* Select/initialize both the unwind function and the frame's type
1583 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
1586 fi
->this_id
.value
= frame_id_build (addr
, pc
);
1590 fprintf_unfiltered (gdb_stdlog
, "-> ");
1591 fprint_frame (gdb_stdlog
, fi
);
1592 fprintf_unfiltered (gdb_stdlog
, " }\n");
1598 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
1599 innermost frame). Be careful to not fall off the bottom of the
1600 frame chain and onto the sentinel frame. */
1603 get_next_frame (struct frame_info
*this_frame
)
1605 if (this_frame
->level
> 0)
1606 return this_frame
->next
;
1611 /* Observer for the target_changed event. */
1614 frame_observer_target_changed (struct target_ops
*target
)
1616 reinit_frame_cache ();
1619 /* Flush the entire frame cache. */
1622 reinit_frame_cache (void)
1624 struct frame_info
*fi
;
1626 /* Tear down all frame caches. */
1627 for (fi
= current_frame
; fi
!= NULL
; fi
= fi
->prev
)
1629 if (fi
->prologue_cache
&& fi
->unwind
->dealloc_cache
)
1630 fi
->unwind
->dealloc_cache (fi
, fi
->prologue_cache
);
1631 if (fi
->base_cache
&& fi
->base
->unwind
->dealloc_cache
)
1632 fi
->base
->unwind
->dealloc_cache (fi
, fi
->base_cache
);
1635 /* Since we can't really be sure what the first object allocated was. */
1636 obstack_free (&frame_cache_obstack
, 0);
1637 obstack_init (&frame_cache_obstack
);
1639 if (current_frame
!= NULL
)
1640 annotate_frames_invalid ();
1642 current_frame
= NULL
; /* Invalidate cache */
1643 select_frame (NULL
);
1644 frame_stash_invalidate ();
1646 fprintf_unfiltered (gdb_stdlog
, "{ reinit_frame_cache () }\n");
1649 /* Find where a register is saved (in memory or another register).
1650 The result of frame_register_unwind is just where it is saved
1651 relative to this particular frame. */
1654 frame_register_unwind_location (struct frame_info
*this_frame
, int regnum
,
1655 int *optimizedp
, enum lval_type
*lvalp
,
1656 CORE_ADDR
*addrp
, int *realnump
)
1658 gdb_assert (this_frame
== NULL
|| this_frame
->level
>= 0);
1660 while (this_frame
!= NULL
)
1664 frame_register_unwind (this_frame
, regnum
, optimizedp
, &unavailable
,
1665 lvalp
, addrp
, realnump
, NULL
);
1670 if (*lvalp
!= lval_register
)
1674 this_frame
= get_next_frame (this_frame
);
1678 /* Get the previous raw frame, and check that it is not identical to
1679 same other frame frame already in the chain. If it is, there is
1680 most likely a stack cycle, so we discard it, and mark THIS_FRAME as
1681 outermost, with UNWIND_SAME_ID stop reason. Unlike the other
1682 validity tests, that compare THIS_FRAME and the next frame, we do
1683 this right after creating the previous frame, to avoid ever ending
1684 up with two frames with the same id in the frame chain. */
1686 static struct frame_info
*
1687 get_prev_frame_if_no_cycle (struct frame_info
*this_frame
)
1689 struct frame_info
*prev_frame
;
1691 prev_frame
= get_prev_frame_raw (this_frame
);
1692 if (prev_frame
== NULL
)
1695 compute_frame_id (prev_frame
);
1696 if (frame_stash_add (prev_frame
))
1699 /* Another frame with the same id was already in the stash. We just
1700 detected a cycle. */
1703 fprintf_unfiltered (gdb_stdlog
, "-> ");
1704 fprint_frame (gdb_stdlog
, NULL
);
1705 fprintf_unfiltered (gdb_stdlog
, " // this frame has same ID }\n");
1707 this_frame
->stop_reason
= UNWIND_SAME_ID
;
1709 prev_frame
->next
= NULL
;
1710 this_frame
->prev
= NULL
;
1714 /* Return a "struct frame_info" corresponding to the frame that called
1715 THIS_FRAME. Returns NULL if there is no such frame.
1717 Unlike get_prev_frame, this function always tries to unwind the
1720 static struct frame_info
*
1721 get_prev_frame_1 (struct frame_info
*this_frame
)
1723 struct gdbarch
*gdbarch
;
1725 gdb_assert (this_frame
!= NULL
);
1726 gdbarch
= get_frame_arch (this_frame
);
1730 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame_1 (this_frame=");
1731 if (this_frame
!= NULL
)
1732 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1734 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1735 fprintf_unfiltered (gdb_stdlog
, ") ");
1738 /* Only try to do the unwind once. */
1739 if (this_frame
->prev_p
)
1743 fprintf_unfiltered (gdb_stdlog
, "-> ");
1744 fprint_frame (gdb_stdlog
, this_frame
->prev
);
1745 fprintf_unfiltered (gdb_stdlog
, " // cached \n");
1747 return this_frame
->prev
;
1750 /* If the frame unwinder hasn't been selected yet, we must do so
1751 before setting prev_p; otherwise the check for misbehaved
1752 sniffers will think that this frame's sniffer tried to unwind
1753 further (see frame_cleanup_after_sniffer). */
1754 if (this_frame
->unwind
== NULL
)
1755 frame_unwind_find_by_frame (this_frame
, &this_frame
->prologue_cache
);
1757 this_frame
->prev_p
= 1;
1758 this_frame
->stop_reason
= UNWIND_NO_REASON
;
1760 /* If we are unwinding from an inline frame, all of the below tests
1761 were already performed when we unwound from the next non-inline
1762 frame. We must skip them, since we can not get THIS_FRAME's ID
1763 until we have unwound all the way down to the previous non-inline
1765 if (get_frame_type (this_frame
) == INLINE_FRAME
)
1766 return get_prev_frame_if_no_cycle (this_frame
);
1768 /* Check that this frame is unwindable. If it isn't, don't try to
1769 unwind to the prev frame. */
1770 this_frame
->stop_reason
1771 = this_frame
->unwind
->stop_reason (this_frame
,
1772 &this_frame
->prologue_cache
);
1774 if (this_frame
->stop_reason
!= UNWIND_NO_REASON
)
1778 enum unwind_stop_reason reason
= this_frame
->stop_reason
;
1780 fprintf_unfiltered (gdb_stdlog
, "-> ");
1781 fprint_frame (gdb_stdlog
, NULL
);
1782 fprintf_unfiltered (gdb_stdlog
, " // %s }\n",
1783 frame_stop_reason_symbol_string (reason
));
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
),
1795 get_frame_id (this_frame
),
1796 get_frame_id (this_frame
->next
)))
1798 CORE_ADDR this_pc_in_block
;
1799 struct minimal_symbol
*morestack_msym
;
1800 const char *morestack_name
= NULL
;
1802 /* gcc -fsplit-stack __morestack can continue the stack anywhere. */
1803 this_pc_in_block
= get_frame_address_in_block (this_frame
);
1804 morestack_msym
= lookup_minimal_symbol_by_pc (this_pc_in_block
).minsym
;
1806 morestack_name
= SYMBOL_LINKAGE_NAME (morestack_msym
);
1807 if (!morestack_name
|| strcmp (morestack_name
, "__morestack") != 0)
1811 fprintf_unfiltered (gdb_stdlog
, "-> ");
1812 fprint_frame (gdb_stdlog
, NULL
);
1813 fprintf_unfiltered (gdb_stdlog
,
1814 " // this frame ID is inner }\n");
1816 this_frame
->stop_reason
= UNWIND_INNER_ID
;
1821 /* Check that this and the next frame do not unwind the PC register
1822 to the same memory location. If they do, then even though they
1823 have different frame IDs, the new frame will be bogus; two
1824 functions can't share a register save slot for the PC. This can
1825 happen when the prologue analyzer finds a stack adjustment, but
1828 This check does assume that the "PC register" is roughly a
1829 traditional PC, even if the gdbarch_unwind_pc method adjusts
1830 it (we do not rely on the value, only on the unwound PC being
1831 dependent on this value). A potential improvement would be
1832 to have the frame prev_pc method and the gdbarch unwind_pc
1833 method set the same lval and location information as
1834 frame_register_unwind. */
1835 if (this_frame
->level
> 0
1836 && gdbarch_pc_regnum (gdbarch
) >= 0
1837 && get_frame_type (this_frame
) == NORMAL_FRAME
1838 && (get_frame_type (this_frame
->next
) == NORMAL_FRAME
1839 || get_frame_type (this_frame
->next
) == INLINE_FRAME
))
1841 int optimized
, realnum
, nrealnum
;
1842 enum lval_type lval
, nlval
;
1843 CORE_ADDR addr
, naddr
;
1845 frame_register_unwind_location (this_frame
,
1846 gdbarch_pc_regnum (gdbarch
),
1847 &optimized
, &lval
, &addr
, &realnum
);
1848 frame_register_unwind_location (get_next_frame (this_frame
),
1849 gdbarch_pc_regnum (gdbarch
),
1850 &optimized
, &nlval
, &naddr
, &nrealnum
);
1852 if ((lval
== lval_memory
&& lval
== nlval
&& addr
== naddr
)
1853 || (lval
== lval_register
&& lval
== nlval
&& realnum
== nrealnum
))
1857 fprintf_unfiltered (gdb_stdlog
, "-> ");
1858 fprint_frame (gdb_stdlog
, NULL
);
1859 fprintf_unfiltered (gdb_stdlog
, " // no saved PC }\n");
1862 this_frame
->stop_reason
= UNWIND_NO_SAVED_PC
;
1863 this_frame
->prev
= NULL
;
1868 return get_prev_frame_if_no_cycle (this_frame
);
1871 /* Construct a new "struct frame_info" and link it previous to
1874 static struct frame_info
*
1875 get_prev_frame_raw (struct frame_info
*this_frame
)
1877 struct frame_info
*prev_frame
;
1879 /* Allocate the new frame but do not wire it in to the frame chain.
1880 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
1881 frame->next to pull some fancy tricks (of course such code is, by
1882 definition, recursive). Try to prevent it.
1884 There is no reason to worry about memory leaks, should the
1885 remainder of the function fail. The allocated memory will be
1886 quickly reclaimed when the frame cache is flushed, and the `we've
1887 been here before' check above will stop repeated memory
1888 allocation calls. */
1889 prev_frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1890 prev_frame
->level
= this_frame
->level
+ 1;
1892 /* For now, assume we don't have frame chains crossing address
1894 prev_frame
->pspace
= this_frame
->pspace
;
1895 prev_frame
->aspace
= this_frame
->aspace
;
1897 /* Don't yet compute ->unwind (and hence ->type). It is computed
1898 on-demand in get_frame_type, frame_register_unwind, and
1901 /* Don't yet compute the frame's ID. It is computed on-demand by
1904 /* The unwound frame ID is validate at the start of this function,
1905 as part of the logic to decide if that frame should be further
1906 unwound, and not here while the prev frame is being created.
1907 Doing this makes it possible for the user to examine a frame that
1908 has an invalid frame ID.
1910 Some very old VAX code noted: [...] For the sake of argument,
1911 suppose that the stack is somewhat trashed (which is one reason
1912 that "info frame" exists). So, return 0 (indicating we don't
1913 know the address of the arglist) if we don't know what frame this
1917 this_frame
->prev
= prev_frame
;
1918 prev_frame
->next
= this_frame
;
1922 fprintf_unfiltered (gdb_stdlog
, "-> ");
1923 fprint_frame (gdb_stdlog
, prev_frame
);
1924 fprintf_unfiltered (gdb_stdlog
, " }\n");
1930 /* Debug routine to print a NULL frame being returned. */
1933 frame_debug_got_null_frame (struct frame_info
*this_frame
,
1938 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame (this_frame=");
1939 if (this_frame
!= NULL
)
1940 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1942 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1943 fprintf_unfiltered (gdb_stdlog
, ") -> // %s}\n", reason
);
1947 /* Is this (non-sentinel) frame in the "main"() function? */
1950 inside_main_func (struct frame_info
*this_frame
)
1952 struct minimal_symbol
*msymbol
;
1955 if (symfile_objfile
== 0)
1957 msymbol
= lookup_minimal_symbol (main_name (), NULL
, symfile_objfile
);
1958 if (msymbol
== NULL
)
1960 /* Make certain that the code, and not descriptor, address is
1962 maddr
= gdbarch_convert_from_func_ptr_addr (get_frame_arch (this_frame
),
1963 SYMBOL_VALUE_ADDRESS (msymbol
),
1965 return maddr
== get_frame_func (this_frame
);
1968 /* Test whether THIS_FRAME is inside the process entry point function. */
1971 inside_entry_func (struct frame_info
*this_frame
)
1973 CORE_ADDR entry_point
;
1975 if (!entry_point_address_query (&entry_point
))
1978 return get_frame_func (this_frame
) == entry_point
;
1981 /* Return a structure containing various interesting information about
1982 the frame that called THIS_FRAME. Returns NULL if there is entier
1983 no such frame or the frame fails any of a set of target-independent
1984 condition that should terminate the frame chain (e.g., as unwinding
1987 This function should not contain target-dependent tests, such as
1988 checking whether the program-counter is zero. */
1991 get_prev_frame (struct frame_info
*this_frame
)
1996 /* There is always a frame. If this assertion fails, suspect that
1997 something should be calling get_selected_frame() or
1998 get_current_frame(). */
1999 gdb_assert (this_frame
!= NULL
);
2000 frame_pc_p
= get_frame_pc_if_available (this_frame
, &frame_pc
);
2002 /* tausq/2004-12-07: Dummy frames are skipped because it doesn't make much
2003 sense to stop unwinding at a dummy frame. One place where a dummy
2004 frame may have an address "inside_main_func" is on HPUX. On HPUX, the
2005 pcsqh register (space register for the instruction at the head of the
2006 instruction queue) cannot be written directly; the only way to set it
2007 is to branch to code that is in the target space. In order to implement
2008 frame dummies on HPUX, the called function is made to jump back to where
2009 the inferior was when the user function was called. If gdb was inside
2010 the main function when we created the dummy frame, the dummy frame will
2011 point inside the main function. */
2012 if (this_frame
->level
>= 0
2013 && get_frame_type (this_frame
) == NORMAL_FRAME
2014 && !backtrace_past_main
2016 && inside_main_func (this_frame
))
2017 /* Don't unwind past main(). Note, this is done _before_ the
2018 frame has been marked as previously unwound. That way if the
2019 user later decides to enable unwinds past main(), that will
2020 automatically happen. */
2022 frame_debug_got_null_frame (this_frame
, "inside main func");
2026 /* If the user's backtrace limit has been exceeded, stop. We must
2027 add two to the current level; one of those accounts for backtrace_limit
2028 being 1-based and the level being 0-based, and the other accounts for
2029 the level of the new frame instead of the level of the current
2031 if (this_frame
->level
+ 2 > backtrace_limit
)
2033 frame_debug_got_null_frame (this_frame
, "backtrace limit exceeded");
2037 /* If we're already inside the entry function for the main objfile,
2038 then it isn't valid. Don't apply this test to a dummy frame -
2039 dummy frame PCs typically land in the entry func. Don't apply
2040 this test to the sentinel frame. Sentinel frames should always
2041 be allowed to unwind. */
2042 /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() -
2043 wasn't checking for "main" in the minimal symbols. With that
2044 fixed asm-source tests now stop in "main" instead of halting the
2045 backtrace in weird and wonderful ways somewhere inside the entry
2046 file. Suspect that tests for inside the entry file/func were
2047 added to work around that (now fixed) case. */
2048 /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
2049 suggested having the inside_entry_func test use the
2050 inside_main_func() msymbol trick (along with entry_point_address()
2051 I guess) to determine the address range of the start function.
2052 That should provide a far better stopper than the current
2054 /* NOTE: tausq/2004-10-09: this is needed if, for example, the compiler
2055 applied tail-call optimizations to main so that a function called
2056 from main returns directly to the caller of main. Since we don't
2057 stop at main, we should at least stop at the entry point of the
2059 if (this_frame
->level
>= 0
2060 && get_frame_type (this_frame
) == NORMAL_FRAME
2061 && !backtrace_past_entry
2063 && inside_entry_func (this_frame
))
2065 frame_debug_got_null_frame (this_frame
, "inside entry func");
2069 /* Assume that the only way to get a zero PC is through something
2070 like a SIGSEGV or a dummy frame, and hence that NORMAL frames
2071 will never unwind a zero PC. */
2072 if (this_frame
->level
> 0
2073 && (get_frame_type (this_frame
) == NORMAL_FRAME
2074 || get_frame_type (this_frame
) == INLINE_FRAME
)
2075 && get_frame_type (get_next_frame (this_frame
)) == NORMAL_FRAME
2076 && frame_pc_p
&& frame_pc
== 0)
2078 frame_debug_got_null_frame (this_frame
, "zero PC");
2082 return get_prev_frame_1 (this_frame
);
2086 get_frame_pc (struct frame_info
*frame
)
2088 gdb_assert (frame
->next
!= NULL
);
2089 return frame_unwind_pc (frame
->next
);
2093 get_frame_pc_if_available (struct frame_info
*frame
, CORE_ADDR
*pc
)
2095 volatile struct gdb_exception ex
;
2097 gdb_assert (frame
->next
!= NULL
);
2099 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2101 *pc
= frame_unwind_pc (frame
->next
);
2105 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2108 throw_exception (ex
);
2114 /* Return an address that falls within THIS_FRAME's code block. */
2117 get_frame_address_in_block (struct frame_info
*this_frame
)
2119 /* A draft address. */
2120 CORE_ADDR pc
= get_frame_pc (this_frame
);
2122 struct frame_info
*next_frame
= this_frame
->next
;
2124 /* Calling get_frame_pc returns the resume address for THIS_FRAME.
2125 Normally the resume address is inside the body of the function
2126 associated with THIS_FRAME, but there is a special case: when
2127 calling a function which the compiler knows will never return
2128 (for instance abort), the call may be the very last instruction
2129 in the calling function. The resume address will point after the
2130 call and may be at the beginning of a different function
2133 If THIS_FRAME is a signal frame or dummy frame, then we should
2134 not adjust the unwound PC. For a dummy frame, GDB pushed the
2135 resume address manually onto the stack. For a signal frame, the
2136 OS may have pushed the resume address manually and invoked the
2137 handler (e.g. GNU/Linux), or invoked the trampoline which called
2138 the signal handler - but in either case the signal handler is
2139 expected to return to the trampoline. So in both of these
2140 cases we know that the resume address is executable and
2141 related. So we only need to adjust the PC if THIS_FRAME
2142 is a normal function.
2144 If the program has been interrupted while THIS_FRAME is current,
2145 then clearly the resume address is inside the associated
2146 function. There are three kinds of interruption: debugger stop
2147 (next frame will be SENTINEL_FRAME), operating system
2148 signal or exception (next frame will be SIGTRAMP_FRAME),
2149 or debugger-induced function call (next frame will be
2150 DUMMY_FRAME). So we only need to adjust the PC if
2151 NEXT_FRAME is a normal function.
2153 We check the type of NEXT_FRAME first, since it is already
2154 known; frame type is determined by the unwinder, and since
2155 we have THIS_FRAME we've already selected an unwinder for
2158 If the next frame is inlined, we need to keep going until we find
2159 the real function - for instance, if a signal handler is invoked
2160 while in an inlined function, then the code address of the
2161 "calling" normal function should not be adjusted either. */
2163 while (get_frame_type (next_frame
) == INLINE_FRAME
)
2164 next_frame
= next_frame
->next
;
2166 if ((get_frame_type (next_frame
) == NORMAL_FRAME
2167 || get_frame_type (next_frame
) == TAILCALL_FRAME
)
2168 && (get_frame_type (this_frame
) == NORMAL_FRAME
2169 || get_frame_type (this_frame
) == TAILCALL_FRAME
2170 || get_frame_type (this_frame
) == INLINE_FRAME
))
2177 get_frame_address_in_block_if_available (struct frame_info
*this_frame
,
2180 volatile struct gdb_exception ex
;
2182 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2184 *pc
= get_frame_address_in_block (this_frame
);
2186 if (ex
.reason
< 0 && ex
.error
== NOT_AVAILABLE_ERROR
)
2188 else if (ex
.reason
< 0)
2189 throw_exception (ex
);
2195 find_frame_sal (struct frame_info
*frame
, struct symtab_and_line
*sal
)
2197 struct frame_info
*next_frame
;
2201 /* If the next frame represents an inlined function call, this frame's
2202 sal is the "call site" of that inlined function, which can not
2203 be inferred from get_frame_pc. */
2204 next_frame
= get_next_frame (frame
);
2205 if (frame_inlined_callees (frame
) > 0)
2210 sym
= get_frame_function (next_frame
);
2212 sym
= inline_skipped_symbol (inferior_ptid
);
2214 /* If frame is inline, it certainly has symbols. */
2217 if (SYMBOL_LINE (sym
) != 0)
2219 sal
->symtab
= SYMBOL_SYMTAB (sym
);
2220 sal
->line
= SYMBOL_LINE (sym
);
2223 /* If the symbol does not have a location, we don't know where
2224 the call site is. Do not pretend to. This is jarring, but
2225 we can't do much better. */
2226 sal
->pc
= get_frame_pc (frame
);
2228 sal
->pspace
= get_frame_program_space (frame
);
2233 /* If FRAME is not the innermost frame, that normally means that
2234 FRAME->pc points at the return instruction (which is *after* the
2235 call instruction), and we want to get the line containing the
2236 call (because the call is where the user thinks the program is).
2237 However, if the next frame is either a SIGTRAMP_FRAME or a
2238 DUMMY_FRAME, then the next frame will contain a saved interrupt
2239 PC and such a PC indicates the current (rather than next)
2240 instruction/line, consequently, for such cases, want to get the
2241 line containing fi->pc. */
2242 if (!get_frame_pc_if_available (frame
, &pc
))
2248 notcurrent
= (pc
!= get_frame_address_in_block (frame
));
2249 (*sal
) = find_pc_line (pc
, notcurrent
);
2252 /* Per "frame.h", return the ``address'' of the frame. Code should
2253 really be using get_frame_id(). */
2255 get_frame_base (struct frame_info
*fi
)
2257 return get_frame_id (fi
).stack_addr
;
2260 /* High-level offsets into the frame. Used by the debug info. */
2263 get_frame_base_address (struct frame_info
*fi
)
2265 if (get_frame_type (fi
) != NORMAL_FRAME
)
2267 if (fi
->base
== NULL
)
2268 fi
->base
= frame_base_find_by_frame (fi
);
2269 /* Sneaky: If the low-level unwind and high-level base code share a
2270 common unwinder, let them share the prologue cache. */
2271 if (fi
->base
->unwind
== fi
->unwind
)
2272 return fi
->base
->this_base (fi
, &fi
->prologue_cache
);
2273 return fi
->base
->this_base (fi
, &fi
->base_cache
);
2277 get_frame_locals_address (struct frame_info
*fi
)
2279 if (get_frame_type (fi
) != NORMAL_FRAME
)
2281 /* If there isn't a frame address method, find it. */
2282 if (fi
->base
== NULL
)
2283 fi
->base
= frame_base_find_by_frame (fi
);
2284 /* Sneaky: If the low-level unwind and high-level base code share a
2285 common unwinder, let them share the prologue cache. */
2286 if (fi
->base
->unwind
== fi
->unwind
)
2287 return fi
->base
->this_locals (fi
, &fi
->prologue_cache
);
2288 return fi
->base
->this_locals (fi
, &fi
->base_cache
);
2292 get_frame_args_address (struct frame_info
*fi
)
2294 if (get_frame_type (fi
) != NORMAL_FRAME
)
2296 /* If there isn't a frame address method, find it. */
2297 if (fi
->base
== NULL
)
2298 fi
->base
= frame_base_find_by_frame (fi
);
2299 /* Sneaky: If the low-level unwind and high-level base code share a
2300 common unwinder, let them share the prologue cache. */
2301 if (fi
->base
->unwind
== fi
->unwind
)
2302 return fi
->base
->this_args (fi
, &fi
->prologue_cache
);
2303 return fi
->base
->this_args (fi
, &fi
->base_cache
);
2306 /* Return true if the frame unwinder for frame FI is UNWINDER; false
2310 frame_unwinder_is (struct frame_info
*fi
, const struct frame_unwind
*unwinder
)
2312 if (fi
->unwind
== NULL
)
2313 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
2314 return fi
->unwind
== unwinder
;
2317 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
2318 or -1 for a NULL frame. */
2321 frame_relative_level (struct frame_info
*fi
)
2330 get_frame_type (struct frame_info
*frame
)
2332 if (frame
->unwind
== NULL
)
2333 /* Initialize the frame's unwinder because that's what
2334 provides the frame's type. */
2335 frame_unwind_find_by_frame (frame
, &frame
->prologue_cache
);
2336 return frame
->unwind
->type
;
2339 struct program_space
*
2340 get_frame_program_space (struct frame_info
*frame
)
2342 return frame
->pspace
;
2345 struct program_space
*
2346 frame_unwind_program_space (struct frame_info
*this_frame
)
2348 gdb_assert (this_frame
);
2350 /* This is really a placeholder to keep the API consistent --- we
2351 assume for now that we don't have frame chains crossing
2353 return this_frame
->pspace
;
2356 struct address_space
*
2357 get_frame_address_space (struct frame_info
*frame
)
2359 return frame
->aspace
;
2362 /* Memory access methods. */
2365 get_frame_memory (struct frame_info
*this_frame
, CORE_ADDR addr
,
2366 gdb_byte
*buf
, int len
)
2368 read_memory (addr
, buf
, len
);
2372 get_frame_memory_signed (struct frame_info
*this_frame
, CORE_ADDR addr
,
2375 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2376 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2378 return read_memory_integer (addr
, len
, byte_order
);
2382 get_frame_memory_unsigned (struct frame_info
*this_frame
, CORE_ADDR addr
,
2385 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2386 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2388 return read_memory_unsigned_integer (addr
, len
, byte_order
);
2392 safe_frame_unwind_memory (struct frame_info
*this_frame
,
2393 CORE_ADDR addr
, gdb_byte
*buf
, int len
)
2395 /* NOTE: target_read_memory returns zero on success! */
2396 return !target_read_memory (addr
, buf
, len
);
2399 /* Architecture methods. */
2402 get_frame_arch (struct frame_info
*this_frame
)
2404 return frame_unwind_arch (this_frame
->next
);
2408 frame_unwind_arch (struct frame_info
*next_frame
)
2410 if (!next_frame
->prev_arch
.p
)
2412 struct gdbarch
*arch
;
2414 if (next_frame
->unwind
== NULL
)
2415 frame_unwind_find_by_frame (next_frame
, &next_frame
->prologue_cache
);
2417 if (next_frame
->unwind
->prev_arch
!= NULL
)
2418 arch
= next_frame
->unwind
->prev_arch (next_frame
,
2419 &next_frame
->prologue_cache
);
2421 arch
= get_frame_arch (next_frame
);
2423 next_frame
->prev_arch
.arch
= arch
;
2424 next_frame
->prev_arch
.p
= 1;
2426 fprintf_unfiltered (gdb_stdlog
,
2427 "{ frame_unwind_arch (next_frame=%d) -> %s }\n",
2429 gdbarch_bfd_arch_info (arch
)->printable_name
);
2432 return next_frame
->prev_arch
.arch
;
2436 frame_unwind_caller_arch (struct frame_info
*next_frame
)
2438 return frame_unwind_arch (skip_artificial_frames (next_frame
));
2441 /* Stack pointer methods. */
2444 get_frame_sp (struct frame_info
*this_frame
)
2446 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2448 /* Normality - an architecture that provides a way of obtaining any
2449 frame inner-most address. */
2450 if (gdbarch_unwind_sp_p (gdbarch
))
2451 /* NOTE drow/2008-06-28: gdbarch_unwind_sp could be converted to
2452 operate on THIS_FRAME now. */
2453 return gdbarch_unwind_sp (gdbarch
, this_frame
->next
);
2454 /* Now things are really are grim. Hope that the value returned by
2455 the gdbarch_sp_regnum register is meaningful. */
2456 if (gdbarch_sp_regnum (gdbarch
) >= 0)
2457 return get_frame_register_unsigned (this_frame
,
2458 gdbarch_sp_regnum (gdbarch
));
2459 internal_error (__FILE__
, __LINE__
, _("Missing unwind SP method"));
2462 /* Return the reason why we can't unwind past FRAME. */
2464 enum unwind_stop_reason
2465 get_frame_unwind_stop_reason (struct frame_info
*frame
)
2467 /* If we haven't tried to unwind past this point yet, then assume
2468 that unwinding would succeed. */
2469 if (frame
->prev_p
== 0)
2470 return UNWIND_NO_REASON
;
2472 /* Otherwise, we set a reason when we succeeded (or failed) to
2474 return frame
->stop_reason
;
2477 /* Return a string explaining REASON. */
2480 frame_stop_reason_string (enum unwind_stop_reason reason
)
2484 #define SET(name, description) \
2485 case name: return _(description);
2486 #include "unwind_stop_reasons.def"
2490 internal_error (__FILE__
, __LINE__
,
2491 "Invalid frame stop reason");
2495 /* Return the enum symbol name of REASON as a string, to use in debug
2499 frame_stop_reason_symbol_string (enum unwind_stop_reason reason
)
2503 #define SET(name, description) \
2504 case name: return #name;
2505 #include "unwind_stop_reasons.def"
2509 internal_error (__FILE__
, __LINE__
,
2510 "Invalid frame stop reason");
2514 /* Clean up after a failed (wrong unwinder) attempt to unwind past
2518 frame_cleanup_after_sniffer (void *arg
)
2520 struct frame_info
*frame
= arg
;
2522 /* The sniffer should not allocate a prologue cache if it did not
2523 match this frame. */
2524 gdb_assert (frame
->prologue_cache
== NULL
);
2526 /* No sniffer should extend the frame chain; sniff based on what is
2528 gdb_assert (!frame
->prev_p
);
2530 /* The sniffer should not check the frame's ID; that's circular. */
2531 gdb_assert (!frame
->this_id
.p
);
2533 /* Clear cached fields dependent on the unwinder.
2535 The previous PC is independent of the unwinder, but the previous
2536 function is not (see get_frame_address_in_block). */
2537 frame
->prev_func
.p
= 0;
2538 frame
->prev_func
.addr
= 0;
2540 /* Discard the unwinder last, so that we can easily find it if an assertion
2541 in this function triggers. */
2542 frame
->unwind
= NULL
;
2545 /* Set FRAME's unwinder temporarily, so that we can call a sniffer.
2546 Return a cleanup which should be called if unwinding fails, and
2547 discarded if it succeeds. */
2550 frame_prepare_for_sniffer (struct frame_info
*frame
,
2551 const struct frame_unwind
*unwind
)
2553 gdb_assert (frame
->unwind
== NULL
);
2554 frame
->unwind
= unwind
;
2555 return make_cleanup (frame_cleanup_after_sniffer
, frame
);
2558 extern initialize_file_ftype _initialize_frame
; /* -Wmissing-prototypes */
2560 static struct cmd_list_element
*set_backtrace_cmdlist
;
2561 static struct cmd_list_element
*show_backtrace_cmdlist
;
2564 set_backtrace_cmd (char *args
, int from_tty
)
2566 help_list (set_backtrace_cmdlist
, "set backtrace ", -1, gdb_stdout
);
2570 show_backtrace_cmd (char *args
, int from_tty
)
2572 cmd_show_list (show_backtrace_cmdlist
, from_tty
, "");
2576 _initialize_frame (void)
2578 obstack_init (&frame_cache_obstack
);
2580 frame_stash_create ();
2582 observer_attach_target_changed (frame_observer_target_changed
);
2584 add_prefix_cmd ("backtrace", class_maintenance
, set_backtrace_cmd
, _("\
2585 Set backtrace specific variables.\n\
2586 Configure backtrace variables such as the backtrace limit"),
2587 &set_backtrace_cmdlist
, "set backtrace ",
2588 0/*allow-unknown*/, &setlist
);
2589 add_prefix_cmd ("backtrace", class_maintenance
, show_backtrace_cmd
, _("\
2590 Show backtrace specific variables\n\
2591 Show backtrace variables such as the backtrace limit"),
2592 &show_backtrace_cmdlist
, "show backtrace ",
2593 0/*allow-unknown*/, &showlist
);
2595 add_setshow_boolean_cmd ("past-main", class_obscure
,
2596 &backtrace_past_main
, _("\
2597 Set whether backtraces should continue past \"main\"."), _("\
2598 Show whether backtraces should continue past \"main\"."), _("\
2599 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
2600 the backtrace at \"main\". Set this variable if you need to see the rest\n\
2601 of the stack trace."),
2603 show_backtrace_past_main
,
2604 &set_backtrace_cmdlist
,
2605 &show_backtrace_cmdlist
);
2607 add_setshow_boolean_cmd ("past-entry", class_obscure
,
2608 &backtrace_past_entry
, _("\
2609 Set whether backtraces should continue past the entry point of a program."),
2611 Show whether backtraces should continue past the entry point of a program."),
2613 Normally there are no callers beyond the entry point of a program, so GDB\n\
2614 will terminate the backtrace there. Set this variable if you need to see\n\
2615 the rest of the stack trace."),
2617 show_backtrace_past_entry
,
2618 &set_backtrace_cmdlist
,
2619 &show_backtrace_cmdlist
);
2621 add_setshow_uinteger_cmd ("limit", class_obscure
,
2622 &backtrace_limit
, _("\
2623 Set an upper bound on the number of backtrace levels."), _("\
2624 Show the upper bound on the number of backtrace levels."), _("\
2625 No more than the specified number of frames can be displayed or examined.\n\
2626 Literal \"unlimited\" or zero means no limit."),
2628 show_backtrace_limit
,
2629 &set_backtrace_cmdlist
,
2630 &show_backtrace_cmdlist
);
2632 /* Debug this files internals. */
2633 add_setshow_zuinteger_cmd ("frame", class_maintenance
, &frame_debug
, _("\
2634 Set frame debugging."), _("\
2635 Show frame debugging."), _("\
2636 When non-zero, frame specific internal debugging is enabled."),
2639 &setdebuglist
, &showdebuglist
);