1 /* Cache and manage frames for GDB, the GNU debugger.
3 Copyright (C) 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000, 2001,
4 2002, 2003, 2004, 2007, 2008 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
25 #include "inferior.h" /* for inferior_ptid */
27 #include "gdb_assert.h"
28 #include "gdb_string.h"
29 #include "user-regs.h"
30 #include "gdb_obstack.h"
31 #include "dummy-frame.h"
32 #include "sentinel-frame.h"
36 #include "frame-unwind.h"
37 #include "frame-base.h"
42 #include "exceptions.h"
43 #include "gdbthread.h"
45 static struct frame_info
*get_prev_frame_1 (struct frame_info
*this_frame
);
47 /* We keep a cache of stack frames, each of which is a "struct
48 frame_info". The innermost one gets allocated (in
49 wait_for_inferior) each time the inferior stops; current_frame
50 points to it. Additional frames get allocated (in get_prev_frame)
51 as needed, and are chained through the next and prev fields. Any
52 time that the frame cache becomes invalid (most notably when we
53 execute something, but also if we change how we interpret the
54 frames (e.g. "set heuristic-fence-post" in mips-tdep.c, or anything
55 which reads new symbols)), we should call reinit_frame_cache. */
59 /* Level of this frame. The inner-most (youngest) frame is at level
60 0. As you move towards the outer-most (oldest) frame, the level
61 increases. This is a cached value. It could just as easily be
62 computed by counting back from the selected frame to the inner
64 /* NOTE: cagney/2002-04-05: Perhaps a level of ``-1'' should be
65 reserved to indicate a bogus frame - one that has been created
66 just to keep GDB happy (GDB always needs a frame). For the
67 moment leave this as speculation. */
70 /* The frame's low-level unwinder and corresponding cache. The
71 low-level unwinder is responsible for unwinding register values
72 for the previous frame. The low-level unwind methods are
73 selected based on the presence, or otherwise, of register unwind
74 information such as CFI. */
76 const struct frame_unwind
*unwind
;
78 /* Cached copy of the previous frame's resume address. */
84 /* Cached copy of the previous frame's function address. */
91 /* This frame's ID. */
95 struct frame_id value
;
98 /* The frame's high-level base methods, and corresponding cache.
99 The high level base methods are selected based on the frame's
101 const struct frame_base
*base
;
104 /* Pointers to the next (down, inner, younger) and previous (up,
105 outer, older) frame_info's in the frame cache. */
106 struct frame_info
*next
; /* down, inner, younger */
108 struct frame_info
*prev
; /* up, outer, older */
110 /* The reason why we could not set PREV, or UNWIND_NO_REASON if we
111 could. Only valid when PREV_P is set. */
112 enum unwind_stop_reason stop_reason
;
115 /* Flag to control debugging. */
119 show_frame_debug (struct ui_file
*file
, int from_tty
,
120 struct cmd_list_element
*c
, const char *value
)
122 fprintf_filtered (file
, _("Frame debugging is %s.\n"), value
);
125 /* Flag to indicate whether backtraces should stop at main et.al. */
127 static int backtrace_past_main
;
129 show_backtrace_past_main (struct ui_file
*file
, int from_tty
,
130 struct cmd_list_element
*c
, const char *value
)
132 fprintf_filtered (file
, _("\
133 Whether backtraces should continue past \"main\" is %s.\n"),
137 static int backtrace_past_entry
;
139 show_backtrace_past_entry (struct ui_file
*file
, int from_tty
,
140 struct cmd_list_element
*c
, const char *value
)
142 fprintf_filtered (file
, _("\
143 Whether backtraces should continue past the entry point of a program is %s.\n"),
147 static int backtrace_limit
= INT_MAX
;
149 show_backtrace_limit (struct ui_file
*file
, int from_tty
,
150 struct cmd_list_element
*c
, const char *value
)
152 fprintf_filtered (file
, _("\
153 An upper bound on the number of backtrace levels is %s.\n"),
159 fprint_field (struct ui_file
*file
, const char *name
, int p
, CORE_ADDR addr
)
162 fprintf_unfiltered (file
, "%s=0x%s", name
, paddr_nz (addr
));
164 fprintf_unfiltered (file
, "!%s", name
);
168 fprint_frame_id (struct ui_file
*file
, struct frame_id id
)
170 fprintf_unfiltered (file
, "{");
171 fprint_field (file
, "stack", id
.stack_addr_p
, id
.stack_addr
);
172 fprintf_unfiltered (file
, ",");
173 fprint_field (file
, "code", id
.code_addr_p
, id
.code_addr
);
174 fprintf_unfiltered (file
, ",");
175 fprint_field (file
, "special", id
.special_addr_p
, id
.special_addr
);
176 fprintf_unfiltered (file
, "}");
180 fprint_frame_type (struct ui_file
*file
, enum frame_type type
)
185 fprintf_unfiltered (file
, "NORMAL_FRAME");
188 fprintf_unfiltered (file
, "DUMMY_FRAME");
191 fprintf_unfiltered (file
, "SIGTRAMP_FRAME");
194 fprintf_unfiltered (file
, "<unknown type>");
200 fprint_frame (struct ui_file
*file
, struct frame_info
*fi
)
204 fprintf_unfiltered (file
, "<NULL frame>");
207 fprintf_unfiltered (file
, "{");
208 fprintf_unfiltered (file
, "level=%d", fi
->level
);
209 fprintf_unfiltered (file
, ",");
210 fprintf_unfiltered (file
, "type=");
211 if (fi
->unwind
!= NULL
)
212 fprint_frame_type (file
, fi
->unwind
->type
);
214 fprintf_unfiltered (file
, "<unknown>");
215 fprintf_unfiltered (file
, ",");
216 fprintf_unfiltered (file
, "unwind=");
217 if (fi
->unwind
!= NULL
)
218 gdb_print_host_address (fi
->unwind
, file
);
220 fprintf_unfiltered (file
, "<unknown>");
221 fprintf_unfiltered (file
, ",");
222 fprintf_unfiltered (file
, "pc=");
223 if (fi
->next
!= NULL
&& fi
->next
->prev_pc
.p
)
224 fprintf_unfiltered (file
, "0x%s", paddr_nz (fi
->next
->prev_pc
.value
));
226 fprintf_unfiltered (file
, "<unknown>");
227 fprintf_unfiltered (file
, ",");
228 fprintf_unfiltered (file
, "id=");
230 fprint_frame_id (file
, fi
->this_id
.value
);
232 fprintf_unfiltered (file
, "<unknown>");
233 fprintf_unfiltered (file
, ",");
234 fprintf_unfiltered (file
, "func=");
235 if (fi
->next
!= NULL
&& fi
->next
->prev_func
.p
)
236 fprintf_unfiltered (file
, "0x%s", paddr_nz (fi
->next
->prev_func
.addr
));
238 fprintf_unfiltered (file
, "<unknown>");
239 fprintf_unfiltered (file
, "}");
242 /* Return a frame uniq ID that can be used to, later, re-find the
246 get_frame_id (struct frame_info
*fi
)
250 return null_frame_id
;
255 fprintf_unfiltered (gdb_stdlog
, "{ get_frame_id (fi=%d) ",
257 /* Find the unwinder. */
258 if (fi
->unwind
== NULL
)
259 fi
->unwind
= frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
260 /* Find THIS frame's ID. */
261 fi
->unwind
->this_id (fi
, &fi
->prologue_cache
, &fi
->this_id
.value
);
265 fprintf_unfiltered (gdb_stdlog
, "-> ");
266 fprint_frame_id (gdb_stdlog
, fi
->this_id
.value
);
267 fprintf_unfiltered (gdb_stdlog
, " }\n");
270 return fi
->this_id
.value
;
274 frame_unwind_id (struct frame_info
*next_frame
)
276 /* Use prev_frame, and not get_prev_frame. The latter will truncate
277 the frame chain, leading to this function unintentionally
278 returning a null_frame_id (e.g., when a caller requests the frame
279 ID of "main()"s caller. */
280 return get_frame_id (get_prev_frame_1 (next_frame
));
283 const struct frame_id null_frame_id
; /* All zeros. */
286 frame_id_build_special (CORE_ADDR stack_addr
, CORE_ADDR code_addr
,
287 CORE_ADDR special_addr
)
289 struct frame_id id
= null_frame_id
;
290 id
.stack_addr
= stack_addr
;
292 id
.code_addr
= code_addr
;
294 id
.special_addr
= special_addr
;
295 id
.special_addr_p
= 1;
300 frame_id_build (CORE_ADDR stack_addr
, CORE_ADDR code_addr
)
302 struct frame_id id
= null_frame_id
;
303 id
.stack_addr
= stack_addr
;
305 id
.code_addr
= code_addr
;
311 frame_id_build_wild (CORE_ADDR stack_addr
)
313 struct frame_id id
= null_frame_id
;
314 id
.stack_addr
= stack_addr
;
320 frame_id_p (struct frame_id l
)
323 /* The frame is valid iff it has a valid stack address. */
327 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_p (l=");
328 fprint_frame_id (gdb_stdlog
, l
);
329 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", p
);
335 frame_id_eq (struct frame_id l
, struct frame_id r
)
338 if (!l
.stack_addr_p
|| !r
.stack_addr_p
)
339 /* Like a NaN, if either ID is invalid, the result is false.
340 Note that a frame ID is invalid iff it is the null frame ID. */
342 else if (l
.stack_addr
!= r
.stack_addr
)
343 /* If .stack addresses are different, the frames are different. */
345 else if (!l
.code_addr_p
|| !r
.code_addr_p
)
346 /* An invalid code addr is a wild card, always succeed. */
348 else if (l
.code_addr
!= r
.code_addr
)
349 /* If .code addresses are different, the frames are different. */
351 else if (!l
.special_addr_p
|| !r
.special_addr_p
)
352 /* An invalid special addr is a wild card (or unused), always succeed. */
354 else if (l
.special_addr
== r
.special_addr
)
355 /* Frames are equal. */
362 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_eq (l=");
363 fprint_frame_id (gdb_stdlog
, l
);
364 fprintf_unfiltered (gdb_stdlog
, ",r=");
365 fprint_frame_id (gdb_stdlog
, r
);
366 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", eq
);
372 frame_id_inner (struct gdbarch
*gdbarch
, struct frame_id l
, struct frame_id r
)
375 if (!l
.stack_addr_p
|| !r
.stack_addr_p
)
376 /* Like NaN, any operation involving an invalid ID always fails. */
379 /* Only return non-zero when strictly inner than. Note that, per
380 comment in "frame.h", there is some fuzz here. Frameless
381 functions are not strictly inner than (same .stack but
382 different .code and/or .special address). */
383 inner
= gdbarch_inner_than (gdbarch
, l
.stack_addr
, r
.stack_addr
);
386 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_inner (l=");
387 fprint_frame_id (gdb_stdlog
, l
);
388 fprintf_unfiltered (gdb_stdlog
, ",r=");
389 fprint_frame_id (gdb_stdlog
, r
);
390 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", inner
);
396 frame_find_by_id (struct frame_id id
)
398 struct frame_info
*frame
;
400 /* ZERO denotes the null frame, let the caller decide what to do
401 about it. Should it instead return get_current_frame()? */
402 if (!frame_id_p (id
))
405 for (frame
= get_current_frame ();
407 frame
= get_prev_frame (frame
))
409 struct frame_id
this = get_frame_id (frame
);
410 if (frame_id_eq (id
, this))
411 /* An exact match. */
413 if (frame_id_inner (get_frame_arch (frame
), id
, this))
416 /* Either we're not yet gone far enough out along the frame
417 chain (inner(this,id)), or we're comparing frameless functions
418 (same .base, different .func, no test available). Struggle
419 on until we've definitly gone to far. */
425 frame_pc_unwind (struct frame_info
*this_frame
)
427 if (!this_frame
->prev_pc
.p
)
430 if (gdbarch_unwind_pc_p (get_frame_arch (this_frame
)))
432 /* The right way. The `pure' way. The one true way. This
433 method depends solely on the register-unwind code to
434 determine the value of registers in THIS frame, and hence
435 the value of this frame's PC (resume address). A typical
436 implementation is no more than:
438 frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
439 return extract_unsigned_integer (buf, size of ISA_PC_REGNUM);
441 Note: this method is very heavily dependent on a correct
442 register-unwind implementation, it pays to fix that
443 method first; this method is frame type agnostic, since
444 it only deals with register values, it works with any
445 frame. This is all in stark contrast to the old
446 FRAME_SAVED_PC which would try to directly handle all the
447 different ways that a PC could be unwound. */
448 pc
= gdbarch_unwind_pc (get_frame_arch (this_frame
), this_frame
);
451 internal_error (__FILE__
, __LINE__
, _("No unwind_pc method"));
452 this_frame
->prev_pc
.value
= pc
;
453 this_frame
->prev_pc
.p
= 1;
455 fprintf_unfiltered (gdb_stdlog
,
456 "{ frame_pc_unwind (this_frame=%d) -> 0x%s }\n",
458 paddr_nz (this_frame
->prev_pc
.value
));
460 return this_frame
->prev_pc
.value
;
464 frame_func_unwind (struct frame_info
*fi
, enum frame_type this_type
)
466 if (!fi
->prev_func
.p
)
468 /* Make certain that this, and not the adjacent, function is
470 CORE_ADDR addr_in_block
= frame_unwind_address_in_block (fi
, this_type
);
472 fi
->prev_func
.addr
= get_pc_function_start (addr_in_block
);
474 fprintf_unfiltered (gdb_stdlog
,
475 "{ frame_func_unwind (fi=%d) -> 0x%s }\n",
476 fi
->level
, paddr_nz (fi
->prev_func
.addr
));
478 return fi
->prev_func
.addr
;
482 get_frame_func (struct frame_info
*fi
)
484 return frame_func_unwind (fi
->next
, get_frame_type (fi
));
488 do_frame_register_read (void *src
, int regnum
, gdb_byte
*buf
)
490 return frame_register_read (src
, regnum
, buf
);
494 frame_save_as_regcache (struct frame_info
*this_frame
)
496 struct regcache
*regcache
= regcache_xmalloc (get_frame_arch (this_frame
));
497 struct cleanup
*cleanups
= make_cleanup_regcache_xfree (regcache
);
498 regcache_save (regcache
, do_frame_register_read
, this_frame
);
499 discard_cleanups (cleanups
);
504 frame_pop (struct frame_info
*this_frame
)
506 struct frame_info
*prev_frame
;
507 struct regcache
*scratch
;
508 struct cleanup
*cleanups
;
510 /* Ensure that we have a frame to pop to. */
511 prev_frame
= get_prev_frame_1 (this_frame
);
514 error (_("Cannot pop the initial frame."));
516 /* Make a copy of all the register values unwound from this frame.
517 Save them in a scratch buffer so that there isn't a race between
518 trying to extract the old values from the current regcache while
519 at the same time writing new values into that same cache. */
520 scratch
= frame_save_as_regcache (prev_frame
);
521 cleanups
= make_cleanup_regcache_xfree (scratch
);
523 /* FIXME: cagney/2003-03-16: It should be possible to tell the
524 target's register cache that it is about to be hit with a burst
525 register transfer and that the sequence of register writes should
526 be batched. The pair target_prepare_to_store() and
527 target_store_registers() kind of suggest this functionality.
528 Unfortunately, they don't implement it. Their lack of a formal
529 definition can lead to targets writing back bogus values
530 (arguably a bug in the target code mind). */
531 /* Now copy those saved registers into the current regcache.
532 Here, regcache_cpy() calls regcache_restore(). */
533 regcache_cpy (get_current_regcache (), scratch
);
534 do_cleanups (cleanups
);
536 /* We've made right mess of GDB's local state, just discard
538 reinit_frame_cache ();
542 frame_register_unwind (struct frame_info
*frame
, int regnum
,
543 int *optimizedp
, enum lval_type
*lvalp
,
544 CORE_ADDR
*addrp
, int *realnump
, gdb_byte
*bufferp
)
548 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
549 that the value proper does not need to be fetched. */
550 gdb_assert (optimizedp
!= NULL
);
551 gdb_assert (lvalp
!= NULL
);
552 gdb_assert (addrp
!= NULL
);
553 gdb_assert (realnump
!= NULL
);
554 /* gdb_assert (bufferp != NULL); */
556 value
= frame_unwind_register_value (frame
, regnum
);
558 gdb_assert (value
!= NULL
);
560 *optimizedp
= value_optimized_out (value
);
561 *lvalp
= VALUE_LVAL (value
);
562 *addrp
= VALUE_ADDRESS (value
);
563 *realnump
= VALUE_REGNUM (value
);
566 memcpy (bufferp
, value_contents_all (value
),
567 TYPE_LENGTH (value_type (value
)));
569 /* Dispose of the new value. This prevents watchpoints from
570 trying to watch the saved frame pointer. */
571 release_value (value
);
576 frame_register (struct frame_info
*frame
, int regnum
,
577 int *optimizedp
, enum lval_type
*lvalp
,
578 CORE_ADDR
*addrp
, int *realnump
, gdb_byte
*bufferp
)
580 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
581 that the value proper does not need to be fetched. */
582 gdb_assert (optimizedp
!= NULL
);
583 gdb_assert (lvalp
!= NULL
);
584 gdb_assert (addrp
!= NULL
);
585 gdb_assert (realnump
!= NULL
);
586 /* gdb_assert (bufferp != NULL); */
588 /* Obtain the register value by unwinding the register from the next
589 (more inner frame). */
590 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
591 frame_register_unwind (frame
->next
, regnum
, optimizedp
, lvalp
, addrp
,
596 frame_unwind_register (struct frame_info
*frame
, int regnum
, gdb_byte
*buf
)
602 frame_register_unwind (frame
, regnum
, &optimized
, &lval
, &addr
,
607 get_frame_register (struct frame_info
*frame
,
608 int regnum
, gdb_byte
*buf
)
610 frame_unwind_register (frame
->next
, regnum
, buf
);
614 frame_unwind_register_value (struct frame_info
*frame
, int regnum
)
618 gdb_assert (frame
!= NULL
);
622 fprintf_unfiltered (gdb_stdlog
, "\
623 { frame_unwind_register_value (frame=%d,regnum=%d(%s),...) ",
624 frame
->level
, regnum
,
625 frame_map_regnum_to_name (frame
, regnum
));
628 /* Find the unwinder. */
629 if (frame
->unwind
== NULL
)
630 frame
->unwind
= frame_unwind_find_by_frame (frame
, &frame
->prologue_cache
);
632 /* Ask this frame to unwind its register. */
633 value
= frame
->unwind
->prev_register (frame
, &frame
->prologue_cache
, regnum
);
637 fprintf_unfiltered (gdb_stdlog
, "->");
638 if (value_optimized_out (value
))
639 fprintf_unfiltered (gdb_stdlog
, " optimized out");
642 if (VALUE_LVAL (value
) == lval_register
)
643 fprintf_unfiltered (gdb_stdlog
, " register=%d",
644 VALUE_REGNUM (value
));
645 else if (VALUE_LVAL (value
) == lval_memory
)
646 fprintf_unfiltered (gdb_stdlog
, " address=0x%s",
647 paddr_nz (VALUE_ADDRESS (value
)));
649 fprintf_unfiltered (gdb_stdlog
, " computed");
651 if (value_lazy (value
))
652 fprintf_unfiltered (gdb_stdlog
, " lazy");
656 const gdb_byte
*buf
= value_contents (value
);
658 fprintf_unfiltered (gdb_stdlog
, " bytes=");
659 fprintf_unfiltered (gdb_stdlog
, "[");
660 for (i
= 0; i
< register_size (get_frame_arch (frame
), regnum
); i
++)
661 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
662 fprintf_unfiltered (gdb_stdlog
, "]");
666 fprintf_unfiltered (gdb_stdlog
, " }\n");
673 get_frame_register_value (struct frame_info
*frame
, int regnum
)
675 return frame_unwind_register_value (frame
->next
, regnum
);
679 frame_unwind_register_signed (struct frame_info
*frame
, int regnum
)
681 gdb_byte buf
[MAX_REGISTER_SIZE
];
682 frame_unwind_register (frame
, regnum
, buf
);
683 return extract_signed_integer (buf
, register_size (get_frame_arch (frame
),
688 get_frame_register_signed (struct frame_info
*frame
, int regnum
)
690 return frame_unwind_register_signed (frame
->next
, regnum
);
694 frame_unwind_register_unsigned (struct frame_info
*frame
, int regnum
)
696 gdb_byte buf
[MAX_REGISTER_SIZE
];
697 frame_unwind_register (frame
, regnum
, buf
);
698 return extract_unsigned_integer (buf
, register_size (get_frame_arch (frame
),
703 get_frame_register_unsigned (struct frame_info
*frame
, int regnum
)
705 return frame_unwind_register_unsigned (frame
->next
, regnum
);
709 put_frame_register (struct frame_info
*frame
, int regnum
,
712 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
717 frame_register (frame
, regnum
, &optim
, &lval
, &addr
, &realnum
, NULL
);
719 error (_("Attempt to assign to a value that was optimized out."));
724 /* FIXME: write_memory doesn't yet take constant buffers.
726 gdb_byte tmp
[MAX_REGISTER_SIZE
];
727 memcpy (tmp
, buf
, register_size (gdbarch
, regnum
));
728 write_memory (addr
, tmp
, register_size (gdbarch
, regnum
));
732 regcache_cooked_write (get_current_regcache (), realnum
, buf
);
735 error (_("Attempt to assign to an unmodifiable value."));
739 /* frame_register_read ()
741 Find and return the value of REGNUM for the specified stack frame.
742 The number of bytes copied is REGISTER_SIZE (REGNUM).
744 Returns 0 if the register value could not be found. */
747 frame_register_read (struct frame_info
*frame
, int regnum
,
754 frame_register (frame
, regnum
, &optimized
, &lval
, &addr
, &realnum
, myaddr
);
760 get_frame_register_bytes (struct frame_info
*frame
, int regnum
,
761 CORE_ADDR offset
, int len
, gdb_byte
*myaddr
)
763 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
765 /* Skip registers wholly inside of OFFSET. */
766 while (offset
>= register_size (gdbarch
, regnum
))
768 offset
-= register_size (gdbarch
, regnum
);
775 int curr_len
= register_size (gdbarch
, regnum
) - offset
;
779 if (curr_len
== register_size (gdbarch
, regnum
))
781 if (!frame_register_read (frame
, regnum
, myaddr
))
786 gdb_byte buf
[MAX_REGISTER_SIZE
];
787 if (!frame_register_read (frame
, regnum
, buf
))
789 memcpy (myaddr
, buf
+ offset
, curr_len
);
802 put_frame_register_bytes (struct frame_info
*frame
, int regnum
,
803 CORE_ADDR offset
, int len
, const gdb_byte
*myaddr
)
805 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
807 /* Skip registers wholly inside of OFFSET. */
808 while (offset
>= register_size (gdbarch
, regnum
))
810 offset
-= register_size (gdbarch
, regnum
);
817 int curr_len
= register_size (gdbarch
, regnum
) - offset
;
821 if (curr_len
== register_size (gdbarch
, regnum
))
823 put_frame_register (frame
, regnum
, myaddr
);
827 gdb_byte buf
[MAX_REGISTER_SIZE
];
828 frame_register_read (frame
, regnum
, buf
);
829 memcpy (buf
+ offset
, myaddr
, curr_len
);
830 put_frame_register (frame
, regnum
, buf
);
840 /* Map between a frame register number and its name. A frame register
841 space is a superset of the cooked register space --- it also
842 includes builtin registers. */
845 frame_map_name_to_regnum (struct frame_info
*frame
, const char *name
, int len
)
847 return user_reg_map_name_to_regnum (get_frame_arch (frame
), name
, len
);
851 frame_map_regnum_to_name (struct frame_info
*frame
, int regnum
)
853 return user_reg_map_regnum_to_name (get_frame_arch (frame
), regnum
);
856 /* Create a sentinel frame. */
858 static struct frame_info
*
859 create_sentinel_frame (struct regcache
*regcache
)
861 struct frame_info
*frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
863 /* Explicitly initialize the sentinel frame's cache. Provide it
864 with the underlying regcache. In the future additional
865 information, such as the frame's thread will be added. */
866 frame
->prologue_cache
= sentinel_frame_cache (regcache
);
867 /* For the moment there is only one sentinel frame implementation. */
868 frame
->unwind
= sentinel_frame_unwind
;
869 /* Link this frame back to itself. The frame is self referential
870 (the unwound PC is the same as the pc), so make it so. */
872 /* Make the sentinel frame's ID valid, but invalid. That way all
873 comparisons with it should fail. */
874 frame
->this_id
.p
= 1;
875 frame
->this_id
.value
= null_frame_id
;
878 fprintf_unfiltered (gdb_stdlog
, "{ create_sentinel_frame (...) -> ");
879 fprint_frame (gdb_stdlog
, frame
);
880 fprintf_unfiltered (gdb_stdlog
, " }\n");
885 /* Info about the innermost stack frame (contents of FP register) */
887 static struct frame_info
*current_frame
;
889 /* Cache for frame addresses already read by gdb. Valid only while
890 inferior is stopped. Control variables for the frame cache should
891 be local to this module. */
893 static struct obstack frame_cache_obstack
;
896 frame_obstack_zalloc (unsigned long size
)
898 void *data
= obstack_alloc (&frame_cache_obstack
, size
);
899 memset (data
, 0, size
);
903 /* Return the innermost (currently executing) stack frame. This is
904 split into two functions. The function unwind_to_current_frame()
905 is wrapped in catch exceptions so that, even when the unwind of the
906 sentinel frame fails, the function still returns a stack frame. */
909 unwind_to_current_frame (struct ui_out
*ui_out
, void *args
)
911 struct frame_info
*frame
= get_prev_frame (args
);
912 /* A sentinel frame can fail to unwind, e.g., because its PC value
913 lands in somewhere like start. */
916 current_frame
= frame
;
921 get_current_frame (void)
923 /* First check, and report, the lack of registers. Having GDB
924 report "No stack!" or "No memory" when the target doesn't even
925 have registers is very confusing. Besides, "printcmd.exp"
926 explicitly checks that ``print $pc'' with no registers prints "No
928 if (!target_has_registers
)
929 error (_("No registers."));
930 if (!target_has_stack
)
931 error (_("No stack."));
932 if (!target_has_memory
)
933 error (_("No memory."));
934 if (is_executing (inferior_ptid
))
935 error (_("Target is executing."));
937 if (current_frame
== NULL
)
939 struct frame_info
*sentinel_frame
=
940 create_sentinel_frame (get_current_regcache ());
941 if (catch_exceptions (uiout
, unwind_to_current_frame
, sentinel_frame
,
942 RETURN_MASK_ERROR
) != 0)
944 /* Oops! Fake a current frame? Is this useful? It has a PC
945 of zero, for instance. */
946 current_frame
= sentinel_frame
;
949 return current_frame
;
952 /* The "selected" stack frame is used by default for local and arg
953 access. May be zero, for no selected frame. */
955 static struct frame_info
*selected_frame
;
958 has_stack_frames (void)
960 if (!target_has_registers
|| !target_has_stack
|| !target_has_memory
)
963 /* If the current thread is executing, don't try to read from
965 if (is_executing (inferior_ptid
))
971 /* Return the selected frame. Always non-NULL (unless there isn't an
972 inferior sufficient for creating a frame) in which case an error is
976 get_selected_frame (const char *message
)
978 if (selected_frame
== NULL
)
980 if (message
!= NULL
&& !has_stack_frames ())
981 error (("%s"), message
);
982 /* Hey! Don't trust this. It should really be re-finding the
983 last selected frame of the currently selected thread. This,
984 though, is better than nothing. */
985 select_frame (get_current_frame ());
987 /* There is always a frame. */
988 gdb_assert (selected_frame
!= NULL
);
989 return selected_frame
;
992 /* This is a variant of get_selected_frame() which can be called when
993 the inferior does not have a frame; in that case it will return
994 NULL instead of calling error(). */
997 deprecated_safe_get_selected_frame (void)
999 if (!has_stack_frames ())
1001 return get_selected_frame (NULL
);
1004 /* Select frame FI (or NULL - to invalidate the current frame). */
1007 select_frame (struct frame_info
*fi
)
1011 selected_frame
= fi
;
1012 /* NOTE: cagney/2002-05-04: FI can be NULL. This occurs when the
1013 frame is being invalidated. */
1014 if (deprecated_selected_frame_level_changed_hook
)
1015 deprecated_selected_frame_level_changed_hook (frame_relative_level (fi
));
1017 /* FIXME: kseitz/2002-08-28: It would be nice to call
1018 selected_frame_level_changed_event() right here, but due to limitations
1019 in the current interfaces, we would end up flooding UIs with events
1020 because select_frame() is used extensively internally.
1022 Once we have frame-parameterized frame (and frame-related) commands,
1023 the event notification can be moved here, since this function will only
1024 be called when the user's selected frame is being changed. */
1026 /* Ensure that symbols for this frame are read in. Also, determine the
1027 source language of this frame, and switch to it if desired. */
1030 /* We retrieve the frame's symtab by using the frame PC. However
1031 we cannot use the frame PC as-is, because it usually points to
1032 the instruction following the "call", which is sometimes the
1033 first instruction of another function. So we rely on
1034 get_frame_address_in_block() which provides us with a PC which
1035 is guaranteed to be inside the frame's code block. */
1036 s
= find_pc_symtab (get_frame_address_in_block (fi
));
1038 && s
->language
!= current_language
->la_language
1039 && s
->language
!= language_unknown
1040 && language_mode
== language_mode_auto
)
1042 set_language (s
->language
);
1047 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
1048 Always returns a non-NULL value. */
1051 create_new_frame (CORE_ADDR addr
, CORE_ADDR pc
)
1053 struct frame_info
*fi
;
1057 fprintf_unfiltered (gdb_stdlog
,
1058 "{ create_new_frame (addr=0x%s, pc=0x%s) ",
1059 paddr_nz (addr
), paddr_nz (pc
));
1062 fi
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1064 fi
->next
= create_sentinel_frame (get_current_regcache ());
1066 /* Select/initialize both the unwind function and the frame's type
1068 fi
->unwind
= frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
1071 deprecated_update_frame_base_hack (fi
, addr
);
1072 deprecated_update_frame_pc_hack (fi
, pc
);
1076 fprintf_unfiltered (gdb_stdlog
, "-> ");
1077 fprint_frame (gdb_stdlog
, fi
);
1078 fprintf_unfiltered (gdb_stdlog
, " }\n");
1084 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
1085 innermost frame). Be careful to not fall off the bottom of the
1086 frame chain and onto the sentinel frame. */
1089 get_next_frame (struct frame_info
*this_frame
)
1091 if (this_frame
->level
> 0)
1092 return this_frame
->next
;
1097 /* Observer for the target_changed event. */
1100 frame_observer_target_changed (struct target_ops
*target
)
1102 reinit_frame_cache ();
1105 /* Flush the entire frame cache. */
1108 reinit_frame_cache (void)
1110 struct frame_info
*fi
;
1112 /* Tear down all frame caches. */
1113 for (fi
= current_frame
; fi
!= NULL
; fi
= fi
->prev
)
1115 if (fi
->prologue_cache
&& fi
->unwind
->dealloc_cache
)
1116 fi
->unwind
->dealloc_cache (fi
, fi
->prologue_cache
);
1117 if (fi
->base_cache
&& fi
->base
->unwind
->dealloc_cache
)
1118 fi
->base
->unwind
->dealloc_cache (fi
, fi
->base_cache
);
1121 /* Since we can't really be sure what the first object allocated was */
1122 obstack_free (&frame_cache_obstack
, 0);
1123 obstack_init (&frame_cache_obstack
);
1125 if (current_frame
!= NULL
)
1126 annotate_frames_invalid ();
1128 current_frame
= NULL
; /* Invalidate cache */
1129 select_frame (NULL
);
1131 fprintf_unfiltered (gdb_stdlog
, "{ reinit_frame_cache () }\n");
1134 /* Find where a register is saved (in memory or another register).
1135 The result of frame_register_unwind is just where it is saved
1136 relative to this particular frame. */
1139 frame_register_unwind_location (struct frame_info
*this_frame
, int regnum
,
1140 int *optimizedp
, enum lval_type
*lvalp
,
1141 CORE_ADDR
*addrp
, int *realnump
)
1143 gdb_assert (this_frame
== NULL
|| this_frame
->level
>= 0);
1145 while (this_frame
!= NULL
)
1147 frame_register_unwind (this_frame
, regnum
, optimizedp
, lvalp
,
1148 addrp
, realnump
, NULL
);
1153 if (*lvalp
!= lval_register
)
1157 this_frame
= get_next_frame (this_frame
);
1161 /* Return a "struct frame_info" corresponding to the frame that called
1162 THIS_FRAME. Returns NULL if there is no such frame.
1164 Unlike get_prev_frame, this function always tries to unwind the
1167 static struct frame_info
*
1168 get_prev_frame_1 (struct frame_info
*this_frame
)
1170 struct frame_info
*prev_frame
;
1171 struct frame_id this_id
;
1172 struct gdbarch
*gdbarch
;
1174 gdb_assert (this_frame
!= NULL
);
1175 gdbarch
= get_frame_arch (this_frame
);
1179 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame_1 (this_frame=");
1180 if (this_frame
!= NULL
)
1181 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1183 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1184 fprintf_unfiltered (gdb_stdlog
, ") ");
1187 /* Only try to do the unwind once. */
1188 if (this_frame
->prev_p
)
1192 fprintf_unfiltered (gdb_stdlog
, "-> ");
1193 fprint_frame (gdb_stdlog
, this_frame
->prev
);
1194 fprintf_unfiltered (gdb_stdlog
, " // cached \n");
1196 return this_frame
->prev
;
1199 /* If the frame unwinder hasn't been selected yet, we must do so
1200 before setting prev_p; otherwise the check for misbehaved
1201 sniffers will think that this frame's sniffer tried to unwind
1202 further (see frame_cleanup_after_sniffer). */
1203 if (this_frame
->unwind
== NULL
)
1205 = frame_unwind_find_by_frame (this_frame
, &this_frame
->prologue_cache
);
1207 this_frame
->prev_p
= 1;
1208 this_frame
->stop_reason
= UNWIND_NO_REASON
;
1210 /* Check that this frame's ID was valid. If it wasn't, don't try to
1211 unwind to the prev frame. Be careful to not apply this test to
1212 the sentinel frame. */
1213 this_id
= get_frame_id (this_frame
);
1214 if (this_frame
->level
>= 0 && !frame_id_p (this_id
))
1218 fprintf_unfiltered (gdb_stdlog
, "-> ");
1219 fprint_frame (gdb_stdlog
, NULL
);
1220 fprintf_unfiltered (gdb_stdlog
, " // this ID is NULL }\n");
1222 this_frame
->stop_reason
= UNWIND_NULL_ID
;
1226 /* Check that this frame's ID isn't inner to (younger, below, next)
1227 the next frame. This happens when a frame unwind goes backwards.
1228 Exclude signal trampolines (due to sigaltstack the frame ID can
1229 go backwards) and sentinel frames (the test is meaningless). */
1230 if (this_frame
->next
->level
>= 0
1231 && this_frame
->next
->unwind
->type
!= SIGTRAMP_FRAME
1232 && frame_id_inner (get_frame_arch (this_frame
), this_id
,
1233 get_frame_id (this_frame
->next
)))
1237 fprintf_unfiltered (gdb_stdlog
, "-> ");
1238 fprint_frame (gdb_stdlog
, NULL
);
1239 fprintf_unfiltered (gdb_stdlog
, " // this frame ID is inner }\n");
1241 this_frame
->stop_reason
= UNWIND_INNER_ID
;
1245 /* Check that this and the next frame are not identical. If they
1246 are, there is most likely a stack cycle. As with the inner-than
1247 test above, avoid comparing the inner-most and sentinel frames. */
1248 if (this_frame
->level
> 0
1249 && frame_id_eq (this_id
, get_frame_id (this_frame
->next
)))
1253 fprintf_unfiltered (gdb_stdlog
, "-> ");
1254 fprint_frame (gdb_stdlog
, NULL
);
1255 fprintf_unfiltered (gdb_stdlog
, " // this frame has same ID }\n");
1257 this_frame
->stop_reason
= UNWIND_SAME_ID
;
1261 /* Check that this and the next frame do not unwind the PC register
1262 to the same memory location. If they do, then even though they
1263 have different frame IDs, the new frame will be bogus; two
1264 functions can't share a register save slot for the PC. This can
1265 happen when the prologue analyzer finds a stack adjustment, but
1268 This check does assume that the "PC register" is roughly a
1269 traditional PC, even if the gdbarch_unwind_pc method adjusts
1270 it (we do not rely on the value, only on the unwound PC being
1271 dependent on this value). A potential improvement would be
1272 to have the frame prev_pc method and the gdbarch unwind_pc
1273 method set the same lval and location information as
1274 frame_register_unwind. */
1275 if (this_frame
->level
> 0
1276 && gdbarch_pc_regnum (gdbarch
) >= 0
1277 && get_frame_type (this_frame
) == NORMAL_FRAME
1278 && get_frame_type (this_frame
->next
) == NORMAL_FRAME
)
1280 int optimized
, realnum
, nrealnum
;
1281 enum lval_type lval
, nlval
;
1282 CORE_ADDR addr
, naddr
;
1284 frame_register_unwind_location (this_frame
,
1285 gdbarch_pc_regnum (gdbarch
),
1286 &optimized
, &lval
, &addr
, &realnum
);
1287 frame_register_unwind_location (get_next_frame (this_frame
),
1288 gdbarch_pc_regnum (gdbarch
),
1289 &optimized
, &nlval
, &naddr
, &nrealnum
);
1291 if ((lval
== lval_memory
&& lval
== nlval
&& addr
== naddr
)
1292 || (lval
== lval_register
&& lval
== nlval
&& realnum
== nrealnum
))
1296 fprintf_unfiltered (gdb_stdlog
, "-> ");
1297 fprint_frame (gdb_stdlog
, NULL
);
1298 fprintf_unfiltered (gdb_stdlog
, " // no saved PC }\n");
1301 this_frame
->stop_reason
= UNWIND_NO_SAVED_PC
;
1302 this_frame
->prev
= NULL
;
1307 /* Allocate the new frame but do not wire it in to the frame chain.
1308 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
1309 frame->next to pull some fancy tricks (of course such code is, by
1310 definition, recursive). Try to prevent it.
1312 There is no reason to worry about memory leaks, should the
1313 remainder of the function fail. The allocated memory will be
1314 quickly reclaimed when the frame cache is flushed, and the `we've
1315 been here before' check above will stop repeated memory
1316 allocation calls. */
1317 prev_frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1318 prev_frame
->level
= this_frame
->level
+ 1;
1320 /* Don't yet compute ->unwind (and hence ->type). It is computed
1321 on-demand in get_frame_type, frame_register_unwind, and
1324 /* Don't yet compute the frame's ID. It is computed on-demand by
1327 /* The unwound frame ID is validate at the start of this function,
1328 as part of the logic to decide if that frame should be further
1329 unwound, and not here while the prev frame is being created.
1330 Doing this makes it possible for the user to examine a frame that
1331 has an invalid frame ID.
1333 Some very old VAX code noted: [...] For the sake of argument,
1334 suppose that the stack is somewhat trashed (which is one reason
1335 that "info frame" exists). So, return 0 (indicating we don't
1336 know the address of the arglist) if we don't know what frame this
1340 this_frame
->prev
= prev_frame
;
1341 prev_frame
->next
= this_frame
;
1345 fprintf_unfiltered (gdb_stdlog
, "-> ");
1346 fprint_frame (gdb_stdlog
, prev_frame
);
1347 fprintf_unfiltered (gdb_stdlog
, " }\n");
1353 /* Debug routine to print a NULL frame being returned. */
1356 frame_debug_got_null_frame (struct ui_file
*file
,
1357 struct frame_info
*this_frame
,
1362 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame (this_frame=");
1363 if (this_frame
!= NULL
)
1364 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1366 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1367 fprintf_unfiltered (gdb_stdlog
, ") -> // %s}\n", reason
);
1371 /* Is this (non-sentinel) frame in the "main"() function? */
1374 inside_main_func (struct frame_info
*this_frame
)
1376 struct minimal_symbol
*msymbol
;
1379 if (symfile_objfile
== 0)
1381 msymbol
= lookup_minimal_symbol (main_name (), NULL
, symfile_objfile
);
1382 if (msymbol
== NULL
)
1384 /* Make certain that the code, and not descriptor, address is
1386 maddr
= gdbarch_convert_from_func_ptr_addr (get_frame_arch (this_frame
),
1387 SYMBOL_VALUE_ADDRESS (msymbol
),
1389 return maddr
== get_frame_func (this_frame
);
1392 /* Test whether THIS_FRAME is inside the process entry point function. */
1395 inside_entry_func (struct frame_info
*this_frame
)
1397 return (get_frame_func (this_frame
) == entry_point_address ());
1400 /* Return a structure containing various interesting information about
1401 the frame that called THIS_FRAME. Returns NULL if there is entier
1402 no such frame or the frame fails any of a set of target-independent
1403 condition that should terminate the frame chain (e.g., as unwinding
1406 This function should not contain target-dependent tests, such as
1407 checking whether the program-counter is zero. */
1410 get_prev_frame (struct frame_info
*this_frame
)
1412 struct frame_info
*prev_frame
;
1414 /* Return the inner-most frame, when the caller passes in NULL. */
1415 /* NOTE: cagney/2002-11-09: Not sure how this would happen. The
1416 caller should have previously obtained a valid frame using
1417 get_selected_frame() and then called this code - only possibility
1418 I can think of is code behaving badly.
1420 NOTE: cagney/2003-01-10: Talk about code behaving badly. Check
1421 block_innermost_frame(). It does the sequence: frame = NULL;
1422 while (1) { frame = get_prev_frame (frame); .... }. Ulgh! Why
1423 it couldn't be written better, I don't know.
1425 NOTE: cagney/2003-01-11: I suspect what is happening in
1426 block_innermost_frame() is, when the target has no state
1427 (registers, memory, ...), it is still calling this function. The
1428 assumption being that this function will return NULL indicating
1429 that a frame isn't possible, rather than checking that the target
1430 has state and then calling get_current_frame() and
1431 get_prev_frame(). This is a guess mind. */
1432 if (this_frame
== NULL
)
1434 /* NOTE: cagney/2002-11-09: There was a code segment here that
1435 would error out when CURRENT_FRAME was NULL. The comment
1436 that went with it made the claim ...
1438 ``This screws value_of_variable, which just wants a nice
1439 clean NULL return from block_innermost_frame if there are no
1440 frames. I don't think I've ever seen this message happen
1441 otherwise. And returning NULL here is a perfectly legitimate
1444 Per the above, this code shouldn't even be called with a NULL
1446 frame_debug_got_null_frame (gdb_stdlog
, this_frame
, "this_frame NULL");
1447 return current_frame
;
1450 /* There is always a frame. If this assertion fails, suspect that
1451 something should be calling get_selected_frame() or
1452 get_current_frame(). */
1453 gdb_assert (this_frame
!= NULL
);
1455 /* tausq/2004-12-07: Dummy frames are skipped because it doesn't make much
1456 sense to stop unwinding at a dummy frame. One place where a dummy
1457 frame may have an address "inside_main_func" is on HPUX. On HPUX, the
1458 pcsqh register (space register for the instruction at the head of the
1459 instruction queue) cannot be written directly; the only way to set it
1460 is to branch to code that is in the target space. In order to implement
1461 frame dummies on HPUX, the called function is made to jump back to where
1462 the inferior was when the user function was called. If gdb was inside
1463 the main function when we created the dummy frame, the dummy frame will
1464 point inside the main function. */
1465 if (this_frame
->level
>= 0
1466 && get_frame_type (this_frame
) != DUMMY_FRAME
1467 && !backtrace_past_main
1468 && inside_main_func (this_frame
))
1469 /* Don't unwind past main(). Note, this is done _before_ the
1470 frame has been marked as previously unwound. That way if the
1471 user later decides to enable unwinds past main(), that will
1472 automatically happen. */
1474 frame_debug_got_null_frame (gdb_stdlog
, this_frame
, "inside main func");
1478 /* If the user's backtrace limit has been exceeded, stop. We must
1479 add two to the current level; one of those accounts for backtrace_limit
1480 being 1-based and the level being 0-based, and the other accounts for
1481 the level of the new frame instead of the level of the current
1483 if (this_frame
->level
+ 2 > backtrace_limit
)
1485 frame_debug_got_null_frame (gdb_stdlog
, this_frame
,
1486 "backtrace limit exceeded");
1490 /* If we're already inside the entry function for the main objfile,
1491 then it isn't valid. Don't apply this test to a dummy frame -
1492 dummy frame PCs typically land in the entry func. Don't apply
1493 this test to the sentinel frame. Sentinel frames should always
1494 be allowed to unwind. */
1495 /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() -
1496 wasn't checking for "main" in the minimal symbols. With that
1497 fixed asm-source tests now stop in "main" instead of halting the
1498 backtrace in weird and wonderful ways somewhere inside the entry
1499 file. Suspect that tests for inside the entry file/func were
1500 added to work around that (now fixed) case. */
1501 /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
1502 suggested having the inside_entry_func test use the
1503 inside_main_func() msymbol trick (along with entry_point_address()
1504 I guess) to determine the address range of the start function.
1505 That should provide a far better stopper than the current
1507 /* NOTE: tausq/2004-10-09: this is needed if, for example, the compiler
1508 applied tail-call optimizations to main so that a function called
1509 from main returns directly to the caller of main. Since we don't
1510 stop at main, we should at least stop at the entry point of the
1512 if (!backtrace_past_entry
1513 && get_frame_type (this_frame
) != DUMMY_FRAME
&& this_frame
->level
>= 0
1514 && inside_entry_func (this_frame
))
1516 frame_debug_got_null_frame (gdb_stdlog
, this_frame
, "inside entry func");
1520 /* Assume that the only way to get a zero PC is through something
1521 like a SIGSEGV or a dummy frame, and hence that NORMAL frames
1522 will never unwind a zero PC. */
1523 if (this_frame
->level
> 0
1524 && get_frame_type (this_frame
) == NORMAL_FRAME
1525 && get_frame_type (get_next_frame (this_frame
)) == NORMAL_FRAME
1526 && get_frame_pc (this_frame
) == 0)
1528 frame_debug_got_null_frame (gdb_stdlog
, this_frame
, "zero PC");
1532 return get_prev_frame_1 (this_frame
);
1536 get_frame_pc (struct frame_info
*frame
)
1538 gdb_assert (frame
->next
!= NULL
);
1539 return frame_pc_unwind (frame
->next
);
1542 /* Return an address that falls within NEXT_FRAME's caller's code
1543 block, assuming that the caller is a THIS_TYPE frame. */
1546 frame_unwind_address_in_block (struct frame_info
*next_frame
,
1547 enum frame_type this_type
)
1549 /* A draft address. */
1550 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
1552 /* If NEXT_FRAME was called by a signal frame or dummy frame, then
1553 we shold not adjust the unwound PC. These frames may not call
1554 their next frame in the normal way; the operating system or GDB
1555 may have pushed their resume address manually onto the stack, so
1556 it may be the very first instruction. Even if the resume address
1557 was not manually pushed, they expect to be returned to. */
1558 if (this_type
!= NORMAL_FRAME
)
1561 /* If THIS frame is not inner most (i.e., NEXT isn't the sentinel),
1562 and NEXT is `normal' (i.e., not a sigtramp, dummy, ....) THIS
1563 frame's PC ends up pointing at the instruction following the
1564 "call". Adjust that PC value so that it falls on the call
1565 instruction (which, hopefully, falls within THIS frame's code
1566 block). So far it's proved to be a very good approximation. See
1567 get_frame_type() for why ->type can't be used. */
1568 if (next_frame
->level
>= 0
1569 && get_frame_type (next_frame
) == NORMAL_FRAME
)
1575 get_frame_address_in_block (struct frame_info
*this_frame
)
1577 return frame_unwind_address_in_block (this_frame
->next
,
1578 get_frame_type (this_frame
));
1582 pc_notcurrent (struct frame_info
*frame
)
1584 /* If FRAME is not the innermost frame, that normally means that
1585 FRAME->pc points at the return instruction (which is *after* the
1586 call instruction), and we want to get the line containing the
1587 call (because the call is where the user thinks the program is).
1588 However, if the next frame is either a SIGTRAMP_FRAME or a
1589 DUMMY_FRAME, then the next frame will contain a saved interrupt
1590 PC and such a PC indicates the current (rather than next)
1591 instruction/line, consequently, for such cases, want to get the
1592 line containing fi->pc. */
1593 struct frame_info
*next
= get_next_frame (frame
);
1594 int notcurrent
= (next
!= NULL
&& get_frame_type (next
) == NORMAL_FRAME
);
1599 find_frame_sal (struct frame_info
*frame
, struct symtab_and_line
*sal
)
1601 (*sal
) = find_pc_line (get_frame_pc (frame
), pc_notcurrent (frame
));
1604 /* Per "frame.h", return the ``address'' of the frame. Code should
1605 really be using get_frame_id(). */
1607 get_frame_base (struct frame_info
*fi
)
1609 return get_frame_id (fi
).stack_addr
;
1612 /* High-level offsets into the frame. Used by the debug info. */
1615 get_frame_base_address (struct frame_info
*fi
)
1617 if (get_frame_type (fi
) != NORMAL_FRAME
)
1619 if (fi
->base
== NULL
)
1620 fi
->base
= frame_base_find_by_frame (fi
);
1621 /* Sneaky: If the low-level unwind and high-level base code share a
1622 common unwinder, let them share the prologue cache. */
1623 if (fi
->base
->unwind
== fi
->unwind
)
1624 return fi
->base
->this_base (fi
, &fi
->prologue_cache
);
1625 return fi
->base
->this_base (fi
, &fi
->base_cache
);
1629 get_frame_locals_address (struct frame_info
*fi
)
1632 if (get_frame_type (fi
) != NORMAL_FRAME
)
1634 /* If there isn't a frame address method, find it. */
1635 if (fi
->base
== NULL
)
1636 fi
->base
= frame_base_find_by_frame (fi
);
1637 /* Sneaky: If the low-level unwind and high-level base code share a
1638 common unwinder, let them share the prologue cache. */
1639 if (fi
->base
->unwind
== fi
->unwind
)
1640 return fi
->base
->this_locals (fi
, &fi
->prologue_cache
);
1641 return fi
->base
->this_locals (fi
, &fi
->base_cache
);
1645 get_frame_args_address (struct frame_info
*fi
)
1648 if (get_frame_type (fi
) != NORMAL_FRAME
)
1650 /* If there isn't a frame address method, find it. */
1651 if (fi
->base
== NULL
)
1652 fi
->base
= frame_base_find_by_frame (fi
);
1653 /* Sneaky: If the low-level unwind and high-level base code share a
1654 common unwinder, let them share the prologue cache. */
1655 if (fi
->base
->unwind
== fi
->unwind
)
1656 return fi
->base
->this_args (fi
, &fi
->prologue_cache
);
1657 return fi
->base
->this_args (fi
, &fi
->base_cache
);
1660 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
1661 or -1 for a NULL frame. */
1664 frame_relative_level (struct frame_info
*fi
)
1673 get_frame_type (struct frame_info
*frame
)
1675 if (frame
->unwind
== NULL
)
1676 /* Initialize the frame's unwinder because that's what
1677 provides the frame's type. */
1678 frame
->unwind
= frame_unwind_find_by_frame (frame
, &frame
->prologue_cache
);
1679 return frame
->unwind
->type
;
1683 deprecated_update_frame_pc_hack (struct frame_info
*frame
, CORE_ADDR pc
)
1686 fprintf_unfiltered (gdb_stdlog
,
1687 "{ deprecated_update_frame_pc_hack (frame=%d,pc=0x%s) }\n",
1688 frame
->level
, paddr_nz (pc
));
1689 /* NOTE: cagney/2003-03-11: Some architectures (e.g., Arm) are
1690 maintaining a locally allocated frame object. Since such frames
1691 are not in the frame chain, it isn't possible to assume that the
1692 frame has a next. Sigh. */
1693 if (frame
->next
!= NULL
)
1695 /* While we're at it, update this frame's cached PC value, found
1696 in the next frame. Oh for the day when "struct frame_info"
1697 is opaque and this hack on hack can just go away. */
1698 frame
->next
->prev_pc
.value
= pc
;
1699 frame
->next
->prev_pc
.p
= 1;
1704 deprecated_update_frame_base_hack (struct frame_info
*frame
, CORE_ADDR base
)
1707 fprintf_unfiltered (gdb_stdlog
,
1708 "{ deprecated_update_frame_base_hack (frame=%d,base=0x%s) }\n",
1709 frame
->level
, paddr_nz (base
));
1710 /* See comment in "frame.h". */
1711 frame
->this_id
.value
.stack_addr
= base
;
1714 /* Memory access methods. */
1717 get_frame_memory (struct frame_info
*this_frame
, CORE_ADDR addr
,
1718 gdb_byte
*buf
, int len
)
1720 read_memory (addr
, buf
, len
);
1724 get_frame_memory_signed (struct frame_info
*this_frame
, CORE_ADDR addr
,
1727 return read_memory_integer (addr
, len
);
1731 get_frame_memory_unsigned (struct frame_info
*this_frame
, CORE_ADDR addr
,
1734 return read_memory_unsigned_integer (addr
, len
);
1738 safe_frame_unwind_memory (struct frame_info
*this_frame
,
1739 CORE_ADDR addr
, gdb_byte
*buf
, int len
)
1741 /* NOTE: target_read_memory returns zero on success! */
1742 return !target_read_memory (addr
, buf
, len
);
1745 /* Architecture method. */
1748 get_frame_arch (struct frame_info
*this_frame
)
1750 return current_gdbarch
;
1753 /* Stack pointer methods. */
1756 get_frame_sp (struct frame_info
*this_frame
)
1758 return frame_sp_unwind (this_frame
->next
);
1762 frame_sp_unwind (struct frame_info
*next_frame
)
1764 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
1765 /* Normality - an architecture that provides a way of obtaining any
1766 frame inner-most address. */
1767 if (gdbarch_unwind_sp_p (gdbarch
))
1768 return gdbarch_unwind_sp (gdbarch
, next_frame
);
1769 /* Now things are really are grim. Hope that the value returned by
1770 the gdbarch_sp_regnum register is meaningful. */
1771 if (gdbarch_sp_regnum (gdbarch
) >= 0)
1772 return frame_unwind_register_unsigned (next_frame
,
1773 gdbarch_sp_regnum (gdbarch
));
1774 internal_error (__FILE__
, __LINE__
, _("Missing unwind SP method"));
1777 /* Return the reason why we can't unwind past FRAME. */
1779 enum unwind_stop_reason
1780 get_frame_unwind_stop_reason (struct frame_info
*frame
)
1782 /* If we haven't tried to unwind past this point yet, then assume
1783 that unwinding would succeed. */
1784 if (frame
->prev_p
== 0)
1785 return UNWIND_NO_REASON
;
1787 /* Otherwise, we set a reason when we succeeded (or failed) to
1789 return frame
->stop_reason
;
1792 /* Return a string explaining REASON. */
1795 frame_stop_reason_string (enum unwind_stop_reason reason
)
1799 case UNWIND_NULL_ID
:
1800 return _("unwinder did not report frame ID");
1802 case UNWIND_INNER_ID
:
1803 return _("previous frame inner to this frame (corrupt stack?)");
1805 case UNWIND_SAME_ID
:
1806 return _("previous frame identical to this frame (corrupt stack?)");
1808 case UNWIND_NO_SAVED_PC
:
1809 return _("frame did not save the PC");
1811 case UNWIND_NO_REASON
:
1812 case UNWIND_FIRST_ERROR
:
1814 internal_error (__FILE__
, __LINE__
,
1815 "Invalid frame stop reason");
1819 /* Clean up after a failed (wrong unwinder) attempt to unwind past
1823 frame_cleanup_after_sniffer (void *arg
)
1825 struct frame_info
*frame
= arg
;
1827 /* The sniffer should not allocate a prologue cache if it did not
1828 match this frame. */
1829 gdb_assert (frame
->prologue_cache
== NULL
);
1831 /* No sniffer should extend the frame chain; sniff based on what is
1833 gdb_assert (!frame
->prev_p
);
1835 /* The sniffer should not check the frame's ID; that's circular. */
1836 gdb_assert (!frame
->this_id
.p
);
1838 /* Clear cached fields dependent on the unwinder.
1840 The previous PC is independent of the unwinder, but the previous
1841 function is not (see frame_unwind_address_in_block). */
1842 frame
->prev_func
.p
= 0;
1843 frame
->prev_func
.addr
= 0;
1845 /* Discard the unwinder last, so that we can easily find it if an assertion
1846 in this function triggers. */
1847 frame
->unwind
= NULL
;
1850 /* Set FRAME's unwinder temporarily, so that we can call a sniffer.
1851 Return a cleanup which should be called if unwinding fails, and
1852 discarded if it succeeds. */
1855 frame_prepare_for_sniffer (struct frame_info
*frame
,
1856 const struct frame_unwind
*unwind
)
1858 gdb_assert (frame
->unwind
== NULL
);
1859 frame
->unwind
= unwind
;
1860 return make_cleanup (frame_cleanup_after_sniffer
, frame
);
1863 extern initialize_file_ftype _initialize_frame
; /* -Wmissing-prototypes */
1865 static struct cmd_list_element
*set_backtrace_cmdlist
;
1866 static struct cmd_list_element
*show_backtrace_cmdlist
;
1869 set_backtrace_cmd (char *args
, int from_tty
)
1871 help_list (set_backtrace_cmdlist
, "set backtrace ", -1, gdb_stdout
);
1875 show_backtrace_cmd (char *args
, int from_tty
)
1877 cmd_show_list (show_backtrace_cmdlist
, from_tty
, "");
1881 _initialize_frame (void)
1883 obstack_init (&frame_cache_obstack
);
1885 observer_attach_target_changed (frame_observer_target_changed
);
1887 add_prefix_cmd ("backtrace", class_maintenance
, set_backtrace_cmd
, _("\
1888 Set backtrace specific variables.\n\
1889 Configure backtrace variables such as the backtrace limit"),
1890 &set_backtrace_cmdlist
, "set backtrace ",
1891 0/*allow-unknown*/, &setlist
);
1892 add_prefix_cmd ("backtrace", class_maintenance
, show_backtrace_cmd
, _("\
1893 Show backtrace specific variables\n\
1894 Show backtrace variables such as the backtrace limit"),
1895 &show_backtrace_cmdlist
, "show backtrace ",
1896 0/*allow-unknown*/, &showlist
);
1898 add_setshow_boolean_cmd ("past-main", class_obscure
,
1899 &backtrace_past_main
, _("\
1900 Set whether backtraces should continue past \"main\"."), _("\
1901 Show whether backtraces should continue past \"main\"."), _("\
1902 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
1903 the backtrace at \"main\". Set this variable if you need to see the rest\n\
1904 of the stack trace."),
1906 show_backtrace_past_main
,
1907 &set_backtrace_cmdlist
,
1908 &show_backtrace_cmdlist
);
1910 add_setshow_boolean_cmd ("past-entry", class_obscure
,
1911 &backtrace_past_entry
, _("\
1912 Set whether backtraces should continue past the entry point of a program."),
1914 Show whether backtraces should continue past the entry point of a program."),
1916 Normally there are no callers beyond the entry point of a program, so GDB\n\
1917 will terminate the backtrace there. Set this variable if you need to see \n\
1918 the rest of the stack trace."),
1920 show_backtrace_past_entry
,
1921 &set_backtrace_cmdlist
,
1922 &show_backtrace_cmdlist
);
1924 add_setshow_integer_cmd ("limit", class_obscure
,
1925 &backtrace_limit
, _("\
1926 Set an upper bound on the number of backtrace levels."), _("\
1927 Show the upper bound on the number of backtrace levels."), _("\
1928 No more than the specified number of frames can be displayed or examined.\n\
1929 Zero is unlimited."),
1931 show_backtrace_limit
,
1932 &set_backtrace_cmdlist
,
1933 &show_backtrace_cmdlist
);
1935 /* Debug this files internals. */
1936 add_setshow_zinteger_cmd ("frame", class_maintenance
, &frame_debug
, _("\
1937 Set frame debugging."), _("\
1938 Show frame debugging."), _("\
1939 When non-zero, frame specific internal debugging is enabled."),
1942 &setdebuglist
, &showdebuglist
);