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
);
371 /* Safety net to check whether frame ID L should be inner to
372 frame ID R, according to their stack addresses.
374 This method cannot be used to compare arbitrary frames, as the
375 ranges of valid stack addresses may be discontiguous (e.g. due
378 However, it can be used as safety net to discover invalid frame
379 IDs in certain circumstances.
381 * If frame NEXT is the immediate inner frame to THIS, and NEXT
382 is a NORMAL frame, then the stack address of NEXT must be
383 inner-than-or-equal to the stack address of THIS.
385 Therefore, if frame_id_inner (THIS, NEXT) holds, some unwind
388 * If frame NEXT is the immediate inner frame to THIS, and NEXT
389 is a NORMAL frame, and NEXT and THIS have different stack
390 addresses, no other frame in the frame chain may have a stack
393 Therefore, if frame_id_inner (TEST, THIS) holds, but
394 frame_id_inner (TEST, NEXT) does not hold, TEST cannot refer
395 to a valid frame in the frame chain. */
398 frame_id_inner (struct gdbarch
*gdbarch
, struct frame_id l
, struct frame_id r
)
401 if (!l
.stack_addr_p
|| !r
.stack_addr_p
)
402 /* Like NaN, any operation involving an invalid ID always fails. */
405 /* Only return non-zero when strictly inner than. Note that, per
406 comment in "frame.h", there is some fuzz here. Frameless
407 functions are not strictly inner than (same .stack but
408 different .code and/or .special address). */
409 inner
= gdbarch_inner_than (gdbarch
, l
.stack_addr
, r
.stack_addr
);
412 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_inner (l=");
413 fprint_frame_id (gdb_stdlog
, l
);
414 fprintf_unfiltered (gdb_stdlog
, ",r=");
415 fprint_frame_id (gdb_stdlog
, r
);
416 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", inner
);
422 frame_find_by_id (struct frame_id id
)
424 struct frame_info
*frame
, *prev_frame
;
426 /* ZERO denotes the null frame, let the caller decide what to do
427 about it. Should it instead return get_current_frame()? */
428 if (!frame_id_p (id
))
431 for (frame
= get_current_frame (); ; frame
= prev_frame
)
433 struct frame_id
this = get_frame_id (frame
);
434 if (frame_id_eq (id
, this))
435 /* An exact match. */
438 prev_frame
= get_prev_frame (frame
);
442 /* As a safety net to avoid unnecessary backtracing while trying
443 to find an invalid ID, we check for a common situation where
444 we can detect from comparing stack addresses that no other
445 frame in the current frame chain can have this ID. See the
446 comment at frame_id_inner for details. */
447 if (get_frame_type (frame
) == NORMAL_FRAME
448 && !frame_id_inner (get_frame_arch (frame
), id
, this)
449 && frame_id_inner (get_frame_arch (prev_frame
), id
,
450 get_frame_id (prev_frame
)))
457 frame_pc_unwind (struct frame_info
*this_frame
)
459 if (!this_frame
->prev_pc
.p
)
462 if (gdbarch_unwind_pc_p (get_frame_arch (this_frame
)))
464 /* The right way. The `pure' way. The one true way. This
465 method depends solely on the register-unwind code to
466 determine the value of registers in THIS frame, and hence
467 the value of this frame's PC (resume address). A typical
468 implementation is no more than:
470 frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
471 return extract_unsigned_integer (buf, size of ISA_PC_REGNUM);
473 Note: this method is very heavily dependent on a correct
474 register-unwind implementation, it pays to fix that
475 method first; this method is frame type agnostic, since
476 it only deals with register values, it works with any
477 frame. This is all in stark contrast to the old
478 FRAME_SAVED_PC which would try to directly handle all the
479 different ways that a PC could be unwound. */
480 pc
= gdbarch_unwind_pc (get_frame_arch (this_frame
), this_frame
);
483 internal_error (__FILE__
, __LINE__
, _("No unwind_pc method"));
484 this_frame
->prev_pc
.value
= pc
;
485 this_frame
->prev_pc
.p
= 1;
487 fprintf_unfiltered (gdb_stdlog
,
488 "{ frame_pc_unwind (this_frame=%d) -> 0x%s }\n",
490 paddr_nz (this_frame
->prev_pc
.value
));
492 return this_frame
->prev_pc
.value
;
496 get_frame_func (struct frame_info
*this_frame
)
498 struct frame_info
*next_frame
= this_frame
->next
;
500 if (!next_frame
->prev_func
.p
)
502 /* Make certain that this, and not the adjacent, function is
504 CORE_ADDR addr_in_block
= get_frame_address_in_block (this_frame
);
505 next_frame
->prev_func
.p
= 1;
506 next_frame
->prev_func
.addr
= get_pc_function_start (addr_in_block
);
508 fprintf_unfiltered (gdb_stdlog
,
509 "{ get_frame_func (this_frame=%d) -> 0x%s }\n",
511 paddr_nz (next_frame
->prev_func
.addr
));
513 return next_frame
->prev_func
.addr
;
517 do_frame_register_read (void *src
, int regnum
, gdb_byte
*buf
)
519 return frame_register_read (src
, regnum
, buf
);
523 frame_save_as_regcache (struct frame_info
*this_frame
)
525 struct regcache
*regcache
= regcache_xmalloc (get_frame_arch (this_frame
));
526 struct cleanup
*cleanups
= make_cleanup_regcache_xfree (regcache
);
527 regcache_save (regcache
, do_frame_register_read
, this_frame
);
528 discard_cleanups (cleanups
);
533 frame_pop (struct frame_info
*this_frame
)
535 struct frame_info
*prev_frame
;
536 struct regcache
*scratch
;
537 struct cleanup
*cleanups
;
539 /* Ensure that we have a frame to pop to. */
540 prev_frame
= get_prev_frame_1 (this_frame
);
543 error (_("Cannot pop the initial frame."));
545 /* Make a copy of all the register values unwound from this frame.
546 Save them in a scratch buffer so that there isn't a race between
547 trying to extract the old values from the current regcache while
548 at the same time writing new values into that same cache. */
549 scratch
= frame_save_as_regcache (prev_frame
);
550 cleanups
= make_cleanup_regcache_xfree (scratch
);
552 /* If we are popping a dummy frame, clean up the associated
554 if (get_frame_type (this_frame
) == DUMMY_FRAME
)
555 dummy_frame_pop (get_frame_id (this_frame
));
557 /* FIXME: cagney/2003-03-16: It should be possible to tell the
558 target's register cache that it is about to be hit with a burst
559 register transfer and that the sequence of register writes should
560 be batched. The pair target_prepare_to_store() and
561 target_store_registers() kind of suggest this functionality.
562 Unfortunately, they don't implement it. Their lack of a formal
563 definition can lead to targets writing back bogus values
564 (arguably a bug in the target code mind). */
565 /* Now copy those saved registers into the current regcache.
566 Here, regcache_cpy() calls regcache_restore(). */
567 regcache_cpy (get_current_regcache (), scratch
);
568 do_cleanups (cleanups
);
570 /* We've made right mess of GDB's local state, just discard
572 reinit_frame_cache ();
576 frame_register_unwind (struct frame_info
*frame
, int regnum
,
577 int *optimizedp
, enum lval_type
*lvalp
,
578 CORE_ADDR
*addrp
, int *realnump
, gdb_byte
*bufferp
)
582 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
583 that the value proper does not need to be fetched. */
584 gdb_assert (optimizedp
!= NULL
);
585 gdb_assert (lvalp
!= NULL
);
586 gdb_assert (addrp
!= NULL
);
587 gdb_assert (realnump
!= NULL
);
588 /* gdb_assert (bufferp != NULL); */
590 value
= frame_unwind_register_value (frame
, regnum
);
592 gdb_assert (value
!= NULL
);
594 *optimizedp
= value_optimized_out (value
);
595 *lvalp
= VALUE_LVAL (value
);
596 *addrp
= VALUE_ADDRESS (value
);
597 *realnump
= VALUE_REGNUM (value
);
600 memcpy (bufferp
, value_contents_all (value
),
601 TYPE_LENGTH (value_type (value
)));
603 /* Dispose of the new value. This prevents watchpoints from
604 trying to watch the saved frame pointer. */
605 release_value (value
);
610 frame_register (struct frame_info
*frame
, int regnum
,
611 int *optimizedp
, enum lval_type
*lvalp
,
612 CORE_ADDR
*addrp
, int *realnump
, gdb_byte
*bufferp
)
614 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
615 that the value proper does not need to be fetched. */
616 gdb_assert (optimizedp
!= NULL
);
617 gdb_assert (lvalp
!= NULL
);
618 gdb_assert (addrp
!= NULL
);
619 gdb_assert (realnump
!= NULL
);
620 /* gdb_assert (bufferp != NULL); */
622 /* Obtain the register value by unwinding the register from the next
623 (more inner frame). */
624 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
625 frame_register_unwind (frame
->next
, regnum
, optimizedp
, lvalp
, addrp
,
630 frame_unwind_register (struct frame_info
*frame
, int regnum
, gdb_byte
*buf
)
636 frame_register_unwind (frame
, regnum
, &optimized
, &lval
, &addr
,
641 get_frame_register (struct frame_info
*frame
,
642 int regnum
, gdb_byte
*buf
)
644 frame_unwind_register (frame
->next
, regnum
, buf
);
648 frame_unwind_register_value (struct frame_info
*frame
, int regnum
)
652 gdb_assert (frame
!= NULL
);
656 fprintf_unfiltered (gdb_stdlog
, "\
657 { frame_unwind_register_value (frame=%d,regnum=%d(%s),...) ",
658 frame
->level
, regnum
,
659 user_reg_map_regnum_to_name
660 (get_frame_arch (frame
), regnum
));
663 /* Find the unwinder. */
664 if (frame
->unwind
== NULL
)
665 frame
->unwind
= frame_unwind_find_by_frame (frame
, &frame
->prologue_cache
);
667 /* Ask this frame to unwind its register. */
668 value
= frame
->unwind
->prev_register (frame
, &frame
->prologue_cache
, regnum
);
672 fprintf_unfiltered (gdb_stdlog
, "->");
673 if (value_optimized_out (value
))
674 fprintf_unfiltered (gdb_stdlog
, " optimized out");
677 if (VALUE_LVAL (value
) == lval_register
)
678 fprintf_unfiltered (gdb_stdlog
, " register=%d",
679 VALUE_REGNUM (value
));
680 else if (VALUE_LVAL (value
) == lval_memory
)
681 fprintf_unfiltered (gdb_stdlog
, " address=0x%s",
682 paddr_nz (VALUE_ADDRESS (value
)));
684 fprintf_unfiltered (gdb_stdlog
, " computed");
686 if (value_lazy (value
))
687 fprintf_unfiltered (gdb_stdlog
, " lazy");
691 const gdb_byte
*buf
= value_contents (value
);
693 fprintf_unfiltered (gdb_stdlog
, " bytes=");
694 fprintf_unfiltered (gdb_stdlog
, "[");
695 for (i
= 0; i
< register_size (get_frame_arch (frame
), regnum
); i
++)
696 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
697 fprintf_unfiltered (gdb_stdlog
, "]");
701 fprintf_unfiltered (gdb_stdlog
, " }\n");
708 get_frame_register_value (struct frame_info
*frame
, int regnum
)
710 return frame_unwind_register_value (frame
->next
, regnum
);
714 frame_unwind_register_signed (struct frame_info
*frame
, int regnum
)
716 gdb_byte buf
[MAX_REGISTER_SIZE
];
717 frame_unwind_register (frame
, regnum
, buf
);
718 return extract_signed_integer (buf
, register_size (get_frame_arch (frame
),
723 get_frame_register_signed (struct frame_info
*frame
, int regnum
)
725 return frame_unwind_register_signed (frame
->next
, regnum
);
729 frame_unwind_register_unsigned (struct frame_info
*frame
, int regnum
)
731 gdb_byte buf
[MAX_REGISTER_SIZE
];
732 frame_unwind_register (frame
, regnum
, buf
);
733 return extract_unsigned_integer (buf
, register_size (get_frame_arch (frame
),
738 get_frame_register_unsigned (struct frame_info
*frame
, int regnum
)
740 return frame_unwind_register_unsigned (frame
->next
, regnum
);
744 put_frame_register (struct frame_info
*frame
, int regnum
,
747 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
752 frame_register (frame
, regnum
, &optim
, &lval
, &addr
, &realnum
, NULL
);
754 error (_("Attempt to assign to a value that was optimized out."));
759 /* FIXME: write_memory doesn't yet take constant buffers.
761 gdb_byte tmp
[MAX_REGISTER_SIZE
];
762 memcpy (tmp
, buf
, register_size (gdbarch
, regnum
));
763 write_memory (addr
, tmp
, register_size (gdbarch
, regnum
));
767 regcache_cooked_write (get_current_regcache (), realnum
, buf
);
770 error (_("Attempt to assign to an unmodifiable value."));
774 /* frame_register_read ()
776 Find and return the value of REGNUM for the specified stack frame.
777 The number of bytes copied is REGISTER_SIZE (REGNUM).
779 Returns 0 if the register value could not be found. */
782 frame_register_read (struct frame_info
*frame
, int regnum
,
789 frame_register (frame
, regnum
, &optimized
, &lval
, &addr
, &realnum
, myaddr
);
795 get_frame_register_bytes (struct frame_info
*frame
, int regnum
,
796 CORE_ADDR offset
, int len
, gdb_byte
*myaddr
)
798 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
802 /* Skip registers wholly inside of OFFSET. */
803 while (offset
>= register_size (gdbarch
, regnum
))
805 offset
-= register_size (gdbarch
, regnum
);
809 /* Ensure that we will not read beyond the end of the register file.
810 This can only ever happen if the debug information is bad. */
812 for (i
= regnum
; i
< gdbarch_num_regs (gdbarch
); i
++)
814 int thissize
= register_size (gdbarch
, i
);
816 break; /* This register is not available on this architecture. */
821 warning (_("Bad debug information detected: "
822 "Attempt to read %d bytes from registers."), len
);
829 int curr_len
= register_size (gdbarch
, regnum
) - offset
;
833 if (curr_len
== register_size (gdbarch
, regnum
))
835 if (!frame_register_read (frame
, regnum
, myaddr
))
840 gdb_byte buf
[MAX_REGISTER_SIZE
];
841 if (!frame_register_read (frame
, regnum
, buf
))
843 memcpy (myaddr
, buf
+ offset
, curr_len
);
856 put_frame_register_bytes (struct frame_info
*frame
, int regnum
,
857 CORE_ADDR offset
, int len
, const gdb_byte
*myaddr
)
859 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
861 /* Skip registers wholly inside of OFFSET. */
862 while (offset
>= register_size (gdbarch
, regnum
))
864 offset
-= register_size (gdbarch
, regnum
);
871 int curr_len
= register_size (gdbarch
, regnum
) - offset
;
875 if (curr_len
== register_size (gdbarch
, regnum
))
877 put_frame_register (frame
, regnum
, myaddr
);
881 gdb_byte buf
[MAX_REGISTER_SIZE
];
882 frame_register_read (frame
, regnum
, buf
);
883 memcpy (buf
+ offset
, myaddr
, curr_len
);
884 put_frame_register (frame
, regnum
, buf
);
894 /* Create a sentinel frame. */
896 static struct frame_info
*
897 create_sentinel_frame (struct regcache
*regcache
)
899 struct frame_info
*frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
901 /* Explicitly initialize the sentinel frame's cache. Provide it
902 with the underlying regcache. In the future additional
903 information, such as the frame's thread will be added. */
904 frame
->prologue_cache
= sentinel_frame_cache (regcache
);
905 /* For the moment there is only one sentinel frame implementation. */
906 frame
->unwind
= sentinel_frame_unwind
;
907 /* Link this frame back to itself. The frame is self referential
908 (the unwound PC is the same as the pc), so make it so. */
910 /* Make the sentinel frame's ID valid, but invalid. That way all
911 comparisons with it should fail. */
912 frame
->this_id
.p
= 1;
913 frame
->this_id
.value
= null_frame_id
;
916 fprintf_unfiltered (gdb_stdlog
, "{ create_sentinel_frame (...) -> ");
917 fprint_frame (gdb_stdlog
, frame
);
918 fprintf_unfiltered (gdb_stdlog
, " }\n");
923 /* Info about the innermost stack frame (contents of FP register) */
925 static struct frame_info
*current_frame
;
927 /* Cache for frame addresses already read by gdb. Valid only while
928 inferior is stopped. Control variables for the frame cache should
929 be local to this module. */
931 static struct obstack frame_cache_obstack
;
934 frame_obstack_zalloc (unsigned long size
)
936 void *data
= obstack_alloc (&frame_cache_obstack
, size
);
937 memset (data
, 0, size
);
941 /* Return the innermost (currently executing) stack frame. This is
942 split into two functions. The function unwind_to_current_frame()
943 is wrapped in catch exceptions so that, even when the unwind of the
944 sentinel frame fails, the function still returns a stack frame. */
947 unwind_to_current_frame (struct ui_out
*ui_out
, void *args
)
949 struct frame_info
*frame
= get_prev_frame (args
);
950 /* A sentinel frame can fail to unwind, e.g., because its PC value
951 lands in somewhere like start. */
954 current_frame
= frame
;
959 get_current_frame (void)
961 /* First check, and report, the lack of registers. Having GDB
962 report "No stack!" or "No memory" when the target doesn't even
963 have registers is very confusing. Besides, "printcmd.exp"
964 explicitly checks that ``print $pc'' with no registers prints "No
966 if (!target_has_registers
)
967 error (_("No registers."));
968 if (!target_has_stack
)
969 error (_("No stack."));
970 if (!target_has_memory
)
971 error (_("No memory."));
972 if (is_executing (inferior_ptid
))
973 error (_("Target is executing."));
975 if (current_frame
== NULL
)
977 struct frame_info
*sentinel_frame
=
978 create_sentinel_frame (get_current_regcache ());
979 if (catch_exceptions (uiout
, unwind_to_current_frame
, sentinel_frame
,
980 RETURN_MASK_ERROR
) != 0)
982 /* Oops! Fake a current frame? Is this useful? It has a PC
983 of zero, for instance. */
984 current_frame
= sentinel_frame
;
987 return current_frame
;
990 /* The "selected" stack frame is used by default for local and arg
991 access. May be zero, for no selected frame. */
993 static struct frame_info
*selected_frame
;
996 has_stack_frames (void)
998 if (!target_has_registers
|| !target_has_stack
|| !target_has_memory
)
1001 /* If the current thread is executing, don't try to read from
1003 if (is_executing (inferior_ptid
))
1009 /* Return the selected frame. Always non-NULL (unless there isn't an
1010 inferior sufficient for creating a frame) in which case an error is
1014 get_selected_frame (const char *message
)
1016 if (selected_frame
== NULL
)
1018 if (message
!= NULL
&& !has_stack_frames ())
1019 error (("%s"), message
);
1020 /* Hey! Don't trust this. It should really be re-finding the
1021 last selected frame of the currently selected thread. This,
1022 though, is better than nothing. */
1023 select_frame (get_current_frame ());
1025 /* There is always a frame. */
1026 gdb_assert (selected_frame
!= NULL
);
1027 return selected_frame
;
1030 /* This is a variant of get_selected_frame() which can be called when
1031 the inferior does not have a frame; in that case it will return
1032 NULL instead of calling error(). */
1035 deprecated_safe_get_selected_frame (void)
1037 if (!has_stack_frames ())
1039 return get_selected_frame (NULL
);
1042 /* Select frame FI (or NULL - to invalidate the current frame). */
1045 select_frame (struct frame_info
*fi
)
1049 selected_frame
= fi
;
1050 /* NOTE: cagney/2002-05-04: FI can be NULL. This occurs when the
1051 frame is being invalidated. */
1052 if (deprecated_selected_frame_level_changed_hook
)
1053 deprecated_selected_frame_level_changed_hook (frame_relative_level (fi
));
1055 /* FIXME: kseitz/2002-08-28: It would be nice to call
1056 selected_frame_level_changed_event() right here, but due to limitations
1057 in the current interfaces, we would end up flooding UIs with events
1058 because select_frame() is used extensively internally.
1060 Once we have frame-parameterized frame (and frame-related) commands,
1061 the event notification can be moved here, since this function will only
1062 be called when the user's selected frame is being changed. */
1064 /* Ensure that symbols for this frame are read in. Also, determine the
1065 source language of this frame, and switch to it if desired. */
1068 /* We retrieve the frame's symtab by using the frame PC. However
1069 we cannot use the frame PC as-is, because it usually points to
1070 the instruction following the "call", which is sometimes the
1071 first instruction of another function. So we rely on
1072 get_frame_address_in_block() which provides us with a PC which
1073 is guaranteed to be inside the frame's code block. */
1074 s
= find_pc_symtab (get_frame_address_in_block (fi
));
1076 && s
->language
!= current_language
->la_language
1077 && s
->language
!= language_unknown
1078 && language_mode
== language_mode_auto
)
1080 set_language (s
->language
);
1085 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
1086 Always returns a non-NULL value. */
1089 create_new_frame (CORE_ADDR addr
, CORE_ADDR pc
)
1091 struct frame_info
*fi
;
1095 fprintf_unfiltered (gdb_stdlog
,
1096 "{ create_new_frame (addr=0x%s, pc=0x%s) ",
1097 paddr_nz (addr
), paddr_nz (pc
));
1100 fi
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1102 fi
->next
= create_sentinel_frame (get_current_regcache ());
1104 /* Select/initialize both the unwind function and the frame's type
1106 fi
->unwind
= frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
1109 deprecated_update_frame_base_hack (fi
, addr
);
1110 deprecated_update_frame_pc_hack (fi
, pc
);
1114 fprintf_unfiltered (gdb_stdlog
, "-> ");
1115 fprint_frame (gdb_stdlog
, fi
);
1116 fprintf_unfiltered (gdb_stdlog
, " }\n");
1122 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
1123 innermost frame). Be careful to not fall off the bottom of the
1124 frame chain and onto the sentinel frame. */
1127 get_next_frame (struct frame_info
*this_frame
)
1129 if (this_frame
->level
> 0)
1130 return this_frame
->next
;
1135 /* Observer for the target_changed event. */
1138 frame_observer_target_changed (struct target_ops
*target
)
1140 reinit_frame_cache ();
1143 /* Flush the entire frame cache. */
1146 reinit_frame_cache (void)
1148 struct frame_info
*fi
;
1150 /* Tear down all frame caches. */
1151 for (fi
= current_frame
; fi
!= NULL
; fi
= fi
->prev
)
1153 if (fi
->prologue_cache
&& fi
->unwind
->dealloc_cache
)
1154 fi
->unwind
->dealloc_cache (fi
, fi
->prologue_cache
);
1155 if (fi
->base_cache
&& fi
->base
->unwind
->dealloc_cache
)
1156 fi
->base
->unwind
->dealloc_cache (fi
, fi
->base_cache
);
1159 /* Since we can't really be sure what the first object allocated was */
1160 obstack_free (&frame_cache_obstack
, 0);
1161 obstack_init (&frame_cache_obstack
);
1163 if (current_frame
!= NULL
)
1164 annotate_frames_invalid ();
1166 current_frame
= NULL
; /* Invalidate cache */
1167 select_frame (NULL
);
1169 fprintf_unfiltered (gdb_stdlog
, "{ reinit_frame_cache () }\n");
1172 /* Find where a register is saved (in memory or another register).
1173 The result of frame_register_unwind is just where it is saved
1174 relative to this particular frame. */
1177 frame_register_unwind_location (struct frame_info
*this_frame
, int regnum
,
1178 int *optimizedp
, enum lval_type
*lvalp
,
1179 CORE_ADDR
*addrp
, int *realnump
)
1181 gdb_assert (this_frame
== NULL
|| this_frame
->level
>= 0);
1183 while (this_frame
!= NULL
)
1185 frame_register_unwind (this_frame
, regnum
, optimizedp
, lvalp
,
1186 addrp
, realnump
, NULL
);
1191 if (*lvalp
!= lval_register
)
1195 this_frame
= get_next_frame (this_frame
);
1199 /* Return a "struct frame_info" corresponding to the frame that called
1200 THIS_FRAME. Returns NULL if there is no such frame.
1202 Unlike get_prev_frame, this function always tries to unwind the
1205 static struct frame_info
*
1206 get_prev_frame_1 (struct frame_info
*this_frame
)
1208 struct frame_info
*prev_frame
;
1209 struct frame_id this_id
;
1210 struct gdbarch
*gdbarch
;
1212 gdb_assert (this_frame
!= NULL
);
1213 gdbarch
= get_frame_arch (this_frame
);
1217 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame_1 (this_frame=");
1218 if (this_frame
!= NULL
)
1219 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1221 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1222 fprintf_unfiltered (gdb_stdlog
, ") ");
1225 /* Only try to do the unwind once. */
1226 if (this_frame
->prev_p
)
1230 fprintf_unfiltered (gdb_stdlog
, "-> ");
1231 fprint_frame (gdb_stdlog
, this_frame
->prev
);
1232 fprintf_unfiltered (gdb_stdlog
, " // cached \n");
1234 return this_frame
->prev
;
1237 /* If the frame unwinder hasn't been selected yet, we must do so
1238 before setting prev_p; otherwise the check for misbehaved
1239 sniffers will think that this frame's sniffer tried to unwind
1240 further (see frame_cleanup_after_sniffer). */
1241 if (this_frame
->unwind
== NULL
)
1243 = frame_unwind_find_by_frame (this_frame
, &this_frame
->prologue_cache
);
1245 this_frame
->prev_p
= 1;
1246 this_frame
->stop_reason
= UNWIND_NO_REASON
;
1248 /* Check that this frame's ID was valid. If it wasn't, don't try to
1249 unwind to the prev frame. Be careful to not apply this test to
1250 the sentinel frame. */
1251 this_id
= get_frame_id (this_frame
);
1252 if (this_frame
->level
>= 0 && !frame_id_p (this_id
))
1256 fprintf_unfiltered (gdb_stdlog
, "-> ");
1257 fprint_frame (gdb_stdlog
, NULL
);
1258 fprintf_unfiltered (gdb_stdlog
, " // this ID is NULL }\n");
1260 this_frame
->stop_reason
= UNWIND_NULL_ID
;
1264 /* Check that this frame's ID isn't inner to (younger, below, next)
1265 the next frame. This happens when a frame unwind goes backwards.
1266 This check is valid only if the next frame is NORMAL. See the
1267 comment at frame_id_inner for details. */
1268 if (this_frame
->next
->unwind
->type
== NORMAL_FRAME
1269 && frame_id_inner (get_frame_arch (this_frame
->next
), this_id
,
1270 get_frame_id (this_frame
->next
)))
1274 fprintf_unfiltered (gdb_stdlog
, "-> ");
1275 fprint_frame (gdb_stdlog
, NULL
);
1276 fprintf_unfiltered (gdb_stdlog
, " // this frame ID is inner }\n");
1278 this_frame
->stop_reason
= UNWIND_INNER_ID
;
1282 /* Check that this and the next frame are not identical. If they
1283 are, there is most likely a stack cycle. As with the inner-than
1284 test above, avoid comparing the inner-most and sentinel frames. */
1285 if (this_frame
->level
> 0
1286 && frame_id_eq (this_id
, get_frame_id (this_frame
->next
)))
1290 fprintf_unfiltered (gdb_stdlog
, "-> ");
1291 fprint_frame (gdb_stdlog
, NULL
);
1292 fprintf_unfiltered (gdb_stdlog
, " // this frame has same ID }\n");
1294 this_frame
->stop_reason
= UNWIND_SAME_ID
;
1298 /* Check that this and the next frame do not unwind the PC register
1299 to the same memory location. If they do, then even though they
1300 have different frame IDs, the new frame will be bogus; two
1301 functions can't share a register save slot for the PC. This can
1302 happen when the prologue analyzer finds a stack adjustment, but
1305 This check does assume that the "PC register" is roughly a
1306 traditional PC, even if the gdbarch_unwind_pc method adjusts
1307 it (we do not rely on the value, only on the unwound PC being
1308 dependent on this value). A potential improvement would be
1309 to have the frame prev_pc method and the gdbarch unwind_pc
1310 method set the same lval and location information as
1311 frame_register_unwind. */
1312 if (this_frame
->level
> 0
1313 && gdbarch_pc_regnum (gdbarch
) >= 0
1314 && get_frame_type (this_frame
) == NORMAL_FRAME
1315 && get_frame_type (this_frame
->next
) == NORMAL_FRAME
)
1317 int optimized
, realnum
, nrealnum
;
1318 enum lval_type lval
, nlval
;
1319 CORE_ADDR addr
, naddr
;
1321 frame_register_unwind_location (this_frame
,
1322 gdbarch_pc_regnum (gdbarch
),
1323 &optimized
, &lval
, &addr
, &realnum
);
1324 frame_register_unwind_location (get_next_frame (this_frame
),
1325 gdbarch_pc_regnum (gdbarch
),
1326 &optimized
, &nlval
, &naddr
, &nrealnum
);
1328 if ((lval
== lval_memory
&& lval
== nlval
&& addr
== naddr
)
1329 || (lval
== lval_register
&& lval
== nlval
&& realnum
== nrealnum
))
1333 fprintf_unfiltered (gdb_stdlog
, "-> ");
1334 fprint_frame (gdb_stdlog
, NULL
);
1335 fprintf_unfiltered (gdb_stdlog
, " // no saved PC }\n");
1338 this_frame
->stop_reason
= UNWIND_NO_SAVED_PC
;
1339 this_frame
->prev
= NULL
;
1344 /* Allocate the new frame but do not wire it in to the frame chain.
1345 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
1346 frame->next to pull some fancy tricks (of course such code is, by
1347 definition, recursive). Try to prevent it.
1349 There is no reason to worry about memory leaks, should the
1350 remainder of the function fail. The allocated memory will be
1351 quickly reclaimed when the frame cache is flushed, and the `we've
1352 been here before' check above will stop repeated memory
1353 allocation calls. */
1354 prev_frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1355 prev_frame
->level
= this_frame
->level
+ 1;
1357 /* Don't yet compute ->unwind (and hence ->type). It is computed
1358 on-demand in get_frame_type, frame_register_unwind, and
1361 /* Don't yet compute the frame's ID. It is computed on-demand by
1364 /* The unwound frame ID is validate at the start of this function,
1365 as part of the logic to decide if that frame should be further
1366 unwound, and not here while the prev frame is being created.
1367 Doing this makes it possible for the user to examine a frame that
1368 has an invalid frame ID.
1370 Some very old VAX code noted: [...] For the sake of argument,
1371 suppose that the stack is somewhat trashed (which is one reason
1372 that "info frame" exists). So, return 0 (indicating we don't
1373 know the address of the arglist) if we don't know what frame this
1377 this_frame
->prev
= prev_frame
;
1378 prev_frame
->next
= this_frame
;
1382 fprintf_unfiltered (gdb_stdlog
, "-> ");
1383 fprint_frame (gdb_stdlog
, prev_frame
);
1384 fprintf_unfiltered (gdb_stdlog
, " }\n");
1390 /* Debug routine to print a NULL frame being returned. */
1393 frame_debug_got_null_frame (struct ui_file
*file
,
1394 struct frame_info
*this_frame
,
1399 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame (this_frame=");
1400 if (this_frame
!= NULL
)
1401 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1403 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1404 fprintf_unfiltered (gdb_stdlog
, ") -> // %s}\n", reason
);
1408 /* Is this (non-sentinel) frame in the "main"() function? */
1411 inside_main_func (struct frame_info
*this_frame
)
1413 struct minimal_symbol
*msymbol
;
1416 if (symfile_objfile
== 0)
1418 msymbol
= lookup_minimal_symbol (main_name (), NULL
, symfile_objfile
);
1419 if (msymbol
== NULL
)
1421 /* Make certain that the code, and not descriptor, address is
1423 maddr
= gdbarch_convert_from_func_ptr_addr (get_frame_arch (this_frame
),
1424 SYMBOL_VALUE_ADDRESS (msymbol
),
1426 return maddr
== get_frame_func (this_frame
);
1429 /* Test whether THIS_FRAME is inside the process entry point function. */
1432 inside_entry_func (struct frame_info
*this_frame
)
1434 return (get_frame_func (this_frame
) == entry_point_address ());
1437 /* Return a structure containing various interesting information about
1438 the frame that called THIS_FRAME. Returns NULL if there is entier
1439 no such frame or the frame fails any of a set of target-independent
1440 condition that should terminate the frame chain (e.g., as unwinding
1443 This function should not contain target-dependent tests, such as
1444 checking whether the program-counter is zero. */
1447 get_prev_frame (struct frame_info
*this_frame
)
1449 struct frame_info
*prev_frame
;
1451 /* Return the inner-most frame, when the caller passes in NULL. */
1452 /* NOTE: cagney/2002-11-09: Not sure how this would happen. The
1453 caller should have previously obtained a valid frame using
1454 get_selected_frame() and then called this code - only possibility
1455 I can think of is code behaving badly.
1457 NOTE: cagney/2003-01-10: Talk about code behaving badly. Check
1458 block_innermost_frame(). It does the sequence: frame = NULL;
1459 while (1) { frame = get_prev_frame (frame); .... }. Ulgh! Why
1460 it couldn't be written better, I don't know.
1462 NOTE: cagney/2003-01-11: I suspect what is happening in
1463 block_innermost_frame() is, when the target has no state
1464 (registers, memory, ...), it is still calling this function. The
1465 assumption being that this function will return NULL indicating
1466 that a frame isn't possible, rather than checking that the target
1467 has state and then calling get_current_frame() and
1468 get_prev_frame(). This is a guess mind. */
1469 if (this_frame
== NULL
)
1471 /* NOTE: cagney/2002-11-09: There was a code segment here that
1472 would error out when CURRENT_FRAME was NULL. The comment
1473 that went with it made the claim ...
1475 ``This screws value_of_variable, which just wants a nice
1476 clean NULL return from block_innermost_frame if there are no
1477 frames. I don't think I've ever seen this message happen
1478 otherwise. And returning NULL here is a perfectly legitimate
1481 Per the above, this code shouldn't even be called with a NULL
1483 frame_debug_got_null_frame (gdb_stdlog
, this_frame
, "this_frame NULL");
1484 return current_frame
;
1487 /* There is always a frame. If this assertion fails, suspect that
1488 something should be calling get_selected_frame() or
1489 get_current_frame(). */
1490 gdb_assert (this_frame
!= NULL
);
1492 /* tausq/2004-12-07: Dummy frames are skipped because it doesn't make much
1493 sense to stop unwinding at a dummy frame. One place where a dummy
1494 frame may have an address "inside_main_func" is on HPUX. On HPUX, the
1495 pcsqh register (space register for the instruction at the head of the
1496 instruction queue) cannot be written directly; the only way to set it
1497 is to branch to code that is in the target space. In order to implement
1498 frame dummies on HPUX, the called function is made to jump back to where
1499 the inferior was when the user function was called. If gdb was inside
1500 the main function when we created the dummy frame, the dummy frame will
1501 point inside the main function. */
1502 if (this_frame
->level
>= 0
1503 && get_frame_type (this_frame
) != DUMMY_FRAME
1504 && !backtrace_past_main
1505 && inside_main_func (this_frame
))
1506 /* Don't unwind past main(). Note, this is done _before_ the
1507 frame has been marked as previously unwound. That way if the
1508 user later decides to enable unwinds past main(), that will
1509 automatically happen. */
1511 frame_debug_got_null_frame (gdb_stdlog
, this_frame
, "inside main func");
1515 /* If the user's backtrace limit has been exceeded, stop. We must
1516 add two to the current level; one of those accounts for backtrace_limit
1517 being 1-based and the level being 0-based, and the other accounts for
1518 the level of the new frame instead of the level of the current
1520 if (this_frame
->level
+ 2 > backtrace_limit
)
1522 frame_debug_got_null_frame (gdb_stdlog
, this_frame
,
1523 "backtrace limit exceeded");
1527 /* If we're already inside the entry function for the main objfile,
1528 then it isn't valid. Don't apply this test to a dummy frame -
1529 dummy frame PCs typically land in the entry func. Don't apply
1530 this test to the sentinel frame. Sentinel frames should always
1531 be allowed to unwind. */
1532 /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() -
1533 wasn't checking for "main" in the minimal symbols. With that
1534 fixed asm-source tests now stop in "main" instead of halting the
1535 backtrace in weird and wonderful ways somewhere inside the entry
1536 file. Suspect that tests for inside the entry file/func were
1537 added to work around that (now fixed) case. */
1538 /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
1539 suggested having the inside_entry_func test use the
1540 inside_main_func() msymbol trick (along with entry_point_address()
1541 I guess) to determine the address range of the start function.
1542 That should provide a far better stopper than the current
1544 /* NOTE: tausq/2004-10-09: this is needed if, for example, the compiler
1545 applied tail-call optimizations to main so that a function called
1546 from main returns directly to the caller of main. Since we don't
1547 stop at main, we should at least stop at the entry point of the
1549 if (!backtrace_past_entry
1550 && get_frame_type (this_frame
) != DUMMY_FRAME
&& this_frame
->level
>= 0
1551 && inside_entry_func (this_frame
))
1553 frame_debug_got_null_frame (gdb_stdlog
, this_frame
, "inside entry func");
1557 /* Assume that the only way to get a zero PC is through something
1558 like a SIGSEGV or a dummy frame, and hence that NORMAL frames
1559 will never unwind a zero PC. */
1560 if (this_frame
->level
> 0
1561 && get_frame_type (this_frame
) == NORMAL_FRAME
1562 && get_frame_type (get_next_frame (this_frame
)) == NORMAL_FRAME
1563 && get_frame_pc (this_frame
) == 0)
1565 frame_debug_got_null_frame (gdb_stdlog
, this_frame
, "zero PC");
1569 return get_prev_frame_1 (this_frame
);
1573 get_frame_pc (struct frame_info
*frame
)
1575 gdb_assert (frame
->next
!= NULL
);
1576 return frame_pc_unwind (frame
->next
);
1579 /* Return an address that falls within THIS_FRAME's code block. */
1582 get_frame_address_in_block (struct frame_info
*this_frame
)
1584 /* A draft address. */
1585 CORE_ADDR pc
= get_frame_pc (this_frame
);
1587 struct frame_info
*next_frame
= this_frame
->next
;
1589 /* Calling get_frame_pc returns the resume address for THIS_FRAME.
1590 Normally the resume address is inside the body of the function
1591 associated with THIS_FRAME, but there is a special case: when
1592 calling a function which the compiler knows will never return
1593 (for instance abort), the call may be the very last instruction
1594 in the calling function. The resume address will point after the
1595 call and may be at the beginning of a different function
1598 If THIS_FRAME is a signal frame or dummy frame, then we should
1599 not adjust the unwound PC. For a dummy frame, GDB pushed the
1600 resume address manually onto the stack. For a signal frame, the
1601 OS may have pushed the resume address manually and invoked the
1602 handler (e.g. GNU/Linux), or invoked the trampoline which called
1603 the signal handler - but in either case the signal handler is
1604 expected to return to the trampoline. So in both of these
1605 cases we know that the resume address is executable and
1606 related. So we only need to adjust the PC if THIS_FRAME
1607 is a normal function.
1609 If the program has been interrupted while THIS_FRAME is current,
1610 then clearly the resume address is inside the associated
1611 function. There are three kinds of interruption: debugger stop
1612 (next frame will be SENTINEL_FRAME), operating system
1613 signal or exception (next frame will be SIGTRAMP_FRAME),
1614 or debugger-induced function call (next frame will be
1615 DUMMY_FRAME). So we only need to adjust the PC if
1616 NEXT_FRAME is a normal function.
1618 We check the type of NEXT_FRAME first, since it is already
1619 known; frame type is determined by the unwinder, and since
1620 we have THIS_FRAME we've already selected an unwinder for
1622 if (get_frame_type (next_frame
) == NORMAL_FRAME
1623 && get_frame_type (this_frame
) == NORMAL_FRAME
)
1630 pc_notcurrent (struct frame_info
*frame
)
1632 /* If FRAME is not the innermost frame, that normally means that
1633 FRAME->pc points at the return instruction (which is *after* the
1634 call instruction), and we want to get the line containing the
1635 call (because the call is where the user thinks the program is).
1636 However, if the next frame is either a SIGTRAMP_FRAME or a
1637 DUMMY_FRAME, then the next frame will contain a saved interrupt
1638 PC and such a PC indicates the current (rather than next)
1639 instruction/line, consequently, for such cases, want to get the
1640 line containing fi->pc. */
1641 struct frame_info
*next
= get_next_frame (frame
);
1642 int notcurrent
= (next
!= NULL
&& get_frame_type (next
) == NORMAL_FRAME
);
1647 find_frame_sal (struct frame_info
*frame
, struct symtab_and_line
*sal
)
1649 (*sal
) = find_pc_line (get_frame_pc (frame
), pc_notcurrent (frame
));
1652 /* Per "frame.h", return the ``address'' of the frame. Code should
1653 really be using get_frame_id(). */
1655 get_frame_base (struct frame_info
*fi
)
1657 return get_frame_id (fi
).stack_addr
;
1660 /* High-level offsets into the frame. Used by the debug info. */
1663 get_frame_base_address (struct frame_info
*fi
)
1665 if (get_frame_type (fi
) != NORMAL_FRAME
)
1667 if (fi
->base
== NULL
)
1668 fi
->base
= frame_base_find_by_frame (fi
);
1669 /* Sneaky: If the low-level unwind and high-level base code share a
1670 common unwinder, let them share the prologue cache. */
1671 if (fi
->base
->unwind
== fi
->unwind
)
1672 return fi
->base
->this_base (fi
, &fi
->prologue_cache
);
1673 return fi
->base
->this_base (fi
, &fi
->base_cache
);
1677 get_frame_locals_address (struct frame_info
*fi
)
1680 if (get_frame_type (fi
) != NORMAL_FRAME
)
1682 /* If there isn't a frame address method, find it. */
1683 if (fi
->base
== NULL
)
1684 fi
->base
= frame_base_find_by_frame (fi
);
1685 /* Sneaky: If the low-level unwind and high-level base code share a
1686 common unwinder, let them share the prologue cache. */
1687 if (fi
->base
->unwind
== fi
->unwind
)
1688 return fi
->base
->this_locals (fi
, &fi
->prologue_cache
);
1689 return fi
->base
->this_locals (fi
, &fi
->base_cache
);
1693 get_frame_args_address (struct frame_info
*fi
)
1696 if (get_frame_type (fi
) != NORMAL_FRAME
)
1698 /* If there isn't a frame address method, find it. */
1699 if (fi
->base
== NULL
)
1700 fi
->base
= frame_base_find_by_frame (fi
);
1701 /* Sneaky: If the low-level unwind and high-level base code share a
1702 common unwinder, let them share the prologue cache. */
1703 if (fi
->base
->unwind
== fi
->unwind
)
1704 return fi
->base
->this_args (fi
, &fi
->prologue_cache
);
1705 return fi
->base
->this_args (fi
, &fi
->base_cache
);
1708 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
1709 or -1 for a NULL frame. */
1712 frame_relative_level (struct frame_info
*fi
)
1721 get_frame_type (struct frame_info
*frame
)
1723 if (frame
->unwind
== NULL
)
1724 /* Initialize the frame's unwinder because that's what
1725 provides the frame's type. */
1726 frame
->unwind
= frame_unwind_find_by_frame (frame
, &frame
->prologue_cache
);
1727 return frame
->unwind
->type
;
1731 deprecated_update_frame_pc_hack (struct frame_info
*frame
, CORE_ADDR pc
)
1734 fprintf_unfiltered (gdb_stdlog
,
1735 "{ deprecated_update_frame_pc_hack (frame=%d,pc=0x%s) }\n",
1736 frame
->level
, paddr_nz (pc
));
1737 /* NOTE: cagney/2003-03-11: Some architectures (e.g., Arm) are
1738 maintaining a locally allocated frame object. Since such frames
1739 are not in the frame chain, it isn't possible to assume that the
1740 frame has a next. Sigh. */
1741 if (frame
->next
!= NULL
)
1743 /* While we're at it, update this frame's cached PC value, found
1744 in the next frame. Oh for the day when "struct frame_info"
1745 is opaque and this hack on hack can just go away. */
1746 frame
->next
->prev_pc
.value
= pc
;
1747 frame
->next
->prev_pc
.p
= 1;
1752 deprecated_update_frame_base_hack (struct frame_info
*frame
, CORE_ADDR base
)
1755 fprintf_unfiltered (gdb_stdlog
,
1756 "{ deprecated_update_frame_base_hack (frame=%d,base=0x%s) }\n",
1757 frame
->level
, paddr_nz (base
));
1758 /* See comment in "frame.h". */
1759 frame
->this_id
.value
.stack_addr
= base
;
1762 /* Memory access methods. */
1765 get_frame_memory (struct frame_info
*this_frame
, CORE_ADDR addr
,
1766 gdb_byte
*buf
, int len
)
1768 read_memory (addr
, buf
, len
);
1772 get_frame_memory_signed (struct frame_info
*this_frame
, CORE_ADDR addr
,
1775 return read_memory_integer (addr
, len
);
1779 get_frame_memory_unsigned (struct frame_info
*this_frame
, CORE_ADDR addr
,
1782 return read_memory_unsigned_integer (addr
, len
);
1786 safe_frame_unwind_memory (struct frame_info
*this_frame
,
1787 CORE_ADDR addr
, gdb_byte
*buf
, int len
)
1789 /* NOTE: target_read_memory returns zero on success! */
1790 return !target_read_memory (addr
, buf
, len
);
1793 /* Architecture method. */
1796 get_frame_arch (struct frame_info
*this_frame
)
1798 return current_gdbarch
;
1801 /* Stack pointer methods. */
1804 get_frame_sp (struct frame_info
*this_frame
)
1806 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1807 /* Normality - an architecture that provides a way of obtaining any
1808 frame inner-most address. */
1809 if (gdbarch_unwind_sp_p (gdbarch
))
1810 /* NOTE drow/2008-06-28: gdbarch_unwind_sp could be converted to
1811 operate on THIS_FRAME now. */
1812 return gdbarch_unwind_sp (gdbarch
, this_frame
->next
);
1813 /* Now things are really are grim. Hope that the value returned by
1814 the gdbarch_sp_regnum register is meaningful. */
1815 if (gdbarch_sp_regnum (gdbarch
) >= 0)
1816 return get_frame_register_unsigned (this_frame
,
1817 gdbarch_sp_regnum (gdbarch
));
1818 internal_error (__FILE__
, __LINE__
, _("Missing unwind SP method"));
1821 /* Return the reason why we can't unwind past FRAME. */
1823 enum unwind_stop_reason
1824 get_frame_unwind_stop_reason (struct frame_info
*frame
)
1826 /* If we haven't tried to unwind past this point yet, then assume
1827 that unwinding would succeed. */
1828 if (frame
->prev_p
== 0)
1829 return UNWIND_NO_REASON
;
1831 /* Otherwise, we set a reason when we succeeded (or failed) to
1833 return frame
->stop_reason
;
1836 /* Return a string explaining REASON. */
1839 frame_stop_reason_string (enum unwind_stop_reason reason
)
1843 case UNWIND_NULL_ID
:
1844 return _("unwinder did not report frame ID");
1846 case UNWIND_INNER_ID
:
1847 return _("previous frame inner to this frame (corrupt stack?)");
1849 case UNWIND_SAME_ID
:
1850 return _("previous frame identical to this frame (corrupt stack?)");
1852 case UNWIND_NO_SAVED_PC
:
1853 return _("frame did not save the PC");
1855 case UNWIND_NO_REASON
:
1856 case UNWIND_FIRST_ERROR
:
1858 internal_error (__FILE__
, __LINE__
,
1859 "Invalid frame stop reason");
1863 /* Clean up after a failed (wrong unwinder) attempt to unwind past
1867 frame_cleanup_after_sniffer (void *arg
)
1869 struct frame_info
*frame
= arg
;
1871 /* The sniffer should not allocate a prologue cache if it did not
1872 match this frame. */
1873 gdb_assert (frame
->prologue_cache
== NULL
);
1875 /* No sniffer should extend the frame chain; sniff based on what is
1877 gdb_assert (!frame
->prev_p
);
1879 /* The sniffer should not check the frame's ID; that's circular. */
1880 gdb_assert (!frame
->this_id
.p
);
1882 /* Clear cached fields dependent on the unwinder.
1884 The previous PC is independent of the unwinder, but the previous
1885 function is not (see get_frame_address_in_block). */
1886 frame
->prev_func
.p
= 0;
1887 frame
->prev_func
.addr
= 0;
1889 /* Discard the unwinder last, so that we can easily find it if an assertion
1890 in this function triggers. */
1891 frame
->unwind
= NULL
;
1894 /* Set FRAME's unwinder temporarily, so that we can call a sniffer.
1895 Return a cleanup which should be called if unwinding fails, and
1896 discarded if it succeeds. */
1899 frame_prepare_for_sniffer (struct frame_info
*frame
,
1900 const struct frame_unwind
*unwind
)
1902 gdb_assert (frame
->unwind
== NULL
);
1903 frame
->unwind
= unwind
;
1904 return make_cleanup (frame_cleanup_after_sniffer
, frame
);
1907 extern initialize_file_ftype _initialize_frame
; /* -Wmissing-prototypes */
1909 static struct cmd_list_element
*set_backtrace_cmdlist
;
1910 static struct cmd_list_element
*show_backtrace_cmdlist
;
1913 set_backtrace_cmd (char *args
, int from_tty
)
1915 help_list (set_backtrace_cmdlist
, "set backtrace ", -1, gdb_stdout
);
1919 show_backtrace_cmd (char *args
, int from_tty
)
1921 cmd_show_list (show_backtrace_cmdlist
, from_tty
, "");
1925 _initialize_frame (void)
1927 obstack_init (&frame_cache_obstack
);
1929 observer_attach_target_changed (frame_observer_target_changed
);
1931 add_prefix_cmd ("backtrace", class_maintenance
, set_backtrace_cmd
, _("\
1932 Set backtrace specific variables.\n\
1933 Configure backtrace variables such as the backtrace limit"),
1934 &set_backtrace_cmdlist
, "set backtrace ",
1935 0/*allow-unknown*/, &setlist
);
1936 add_prefix_cmd ("backtrace", class_maintenance
, show_backtrace_cmd
, _("\
1937 Show backtrace specific variables\n\
1938 Show backtrace variables such as the backtrace limit"),
1939 &show_backtrace_cmdlist
, "show backtrace ",
1940 0/*allow-unknown*/, &showlist
);
1942 add_setshow_boolean_cmd ("past-main", class_obscure
,
1943 &backtrace_past_main
, _("\
1944 Set whether backtraces should continue past \"main\"."), _("\
1945 Show whether backtraces should continue past \"main\"."), _("\
1946 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
1947 the backtrace at \"main\". Set this variable if you need to see the rest\n\
1948 of the stack trace."),
1950 show_backtrace_past_main
,
1951 &set_backtrace_cmdlist
,
1952 &show_backtrace_cmdlist
);
1954 add_setshow_boolean_cmd ("past-entry", class_obscure
,
1955 &backtrace_past_entry
, _("\
1956 Set whether backtraces should continue past the entry point of a program."),
1958 Show whether backtraces should continue past the entry point of a program."),
1960 Normally there are no callers beyond the entry point of a program, so GDB\n\
1961 will terminate the backtrace there. Set this variable if you need to see \n\
1962 the rest of the stack trace."),
1964 show_backtrace_past_entry
,
1965 &set_backtrace_cmdlist
,
1966 &show_backtrace_cmdlist
);
1968 add_setshow_integer_cmd ("limit", class_obscure
,
1969 &backtrace_limit
, _("\
1970 Set an upper bound on the number of backtrace levels."), _("\
1971 Show the upper bound on the number of backtrace levels."), _("\
1972 No more than the specified number of frames can be displayed or examined.\n\
1973 Zero is unlimited."),
1975 show_backtrace_limit
,
1976 &set_backtrace_cmdlist
,
1977 &show_backtrace_cmdlist
);
1979 /* Debug this files internals. */
1980 add_setshow_zinteger_cmd ("frame", class_maintenance
, &frame_debug
, _("\
1981 Set frame debugging."), _("\
1982 Show frame debugging."), _("\
1983 When non-zero, frame specific internal debugging is enabled."),
1986 &setdebuglist
, &showdebuglist
);