1 /* Cache and manage frames for GDB, the GNU debugger.
3 Copyright (C) 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000,
4 2001, 2002, 2003, 2004 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 2 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, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
27 #include "inferior.h" /* for inferior_ptid */
29 #include "gdb_assert.h"
30 #include "gdb_string.h"
31 #include "user-regs.h"
32 #include "gdb_obstack.h"
33 #include "dummy-frame.h"
34 #include "sentinel-frame.h"
38 #include "frame-unwind.h"
39 #include "frame-base.h"
44 #include "exceptions.h"
46 static struct frame_info
*get_prev_frame_1 (struct frame_info
*this_frame
);
48 /* We keep a cache of stack frames, each of which is a "struct
49 frame_info". The innermost one gets allocated (in
50 wait_for_inferior) each time the inferior stops; current_frame
51 points to it. Additional frames get allocated (in get_prev_frame)
52 as needed, and are chained through the next and prev fields. Any
53 time that the frame cache becomes invalid (most notably when we
54 execute something, but also if we change how we interpret the
55 frames (e.g. "set heuristic-fence-post" in mips-tdep.c, or anything
56 which reads new symbols)), we should call reinit_frame_cache. */
60 /* Level of this frame. The inner-most (youngest) frame is at level
61 0. As you move towards the outer-most (oldest) frame, the level
62 increases. This is a cached value. It could just as easily be
63 computed by counting back from the selected frame to the inner
65 /* NOTE: cagney/2002-04-05: Perhaps a level of ``-1'' should be
66 reserved to indicate a bogus frame - one that has been created
67 just to keep GDB happy (GDB always needs a frame). For the
68 moment leave this as speculation. */
71 /* The frame's low-level unwinder and corresponding cache. The
72 low-level unwinder is responsible for unwinding register values
73 for the previous frame. The low-level unwind methods are
74 selected based on the presence, or otherwise, of register unwind
75 information such as CFI. */
77 const struct frame_unwind
*unwind
;
79 /* Cached copy of the previous frame's resume address. */
85 /* Cached copy of the previous frame's function address. */
92 /* This frame's ID. */
96 struct frame_id value
;
99 /* The frame's high-level base methods, and corresponding cache.
100 The high level base methods are selected based on the frame's
102 const struct frame_base
*base
;
105 /* Pointers to the next (down, inner, younger) and previous (up,
106 outer, older) frame_info's in the frame cache. */
107 struct frame_info
*next
; /* down, inner, younger */
109 struct frame_info
*prev
; /* up, outer, older */
111 /* The reason why we could not set PREV, or UNWIND_NO_REASON if we
112 could. Only valid when PREV_P is set. */
113 enum unwind_stop_reason stop_reason
;
116 /* Flag to control debugging. */
118 static int frame_debug
;
120 show_frame_debug (struct ui_file
*file
, int from_tty
,
121 struct cmd_list_element
*c
, const char *value
)
123 fprintf_filtered (file
, _("Frame debugging is %s.\n"), value
);
126 /* Flag to indicate whether backtraces should stop at main et.al. */
128 static int backtrace_past_main
;
130 show_backtrace_past_main (struct ui_file
*file
, int from_tty
,
131 struct cmd_list_element
*c
, const char *value
)
133 fprintf_filtered (file
, _("\
134 Whether backtraces should continue past \"main\" is %s.\n"),
138 static int backtrace_past_entry
;
140 show_backtrace_past_entry (struct ui_file
*file
, int from_tty
,
141 struct cmd_list_element
*c
, const char *value
)
143 fprintf_filtered (file
, _("\
144 Whether backtraces should continue past the entry point of a program is %s.\n"),
148 static int backtrace_limit
= INT_MAX
;
150 show_backtrace_limit (struct ui_file
*file
, int from_tty
,
151 struct cmd_list_element
*c
, const char *value
)
153 fprintf_filtered (file
, _("\
154 An upper bound on the number of backtrace levels is %s.\n"),
160 fprint_field (struct ui_file
*file
, const char *name
, int p
, CORE_ADDR addr
)
163 fprintf_unfiltered (file
, "%s=0x%s", name
, paddr_nz (addr
));
165 fprintf_unfiltered (file
, "!%s", name
);
169 fprint_frame_id (struct ui_file
*file
, struct frame_id id
)
171 fprintf_unfiltered (file
, "{");
172 fprint_field (file
, "stack", id
.stack_addr_p
, id
.stack_addr
);
173 fprintf_unfiltered (file
, ",");
174 fprint_field (file
, "code", id
.code_addr_p
, id
.code_addr
);
175 fprintf_unfiltered (file
, ",");
176 fprint_field (file
, "special", id
.special_addr_p
, id
.special_addr
);
177 fprintf_unfiltered (file
, "}");
181 fprint_frame_type (struct ui_file
*file
, enum frame_type type
)
186 fprintf_unfiltered (file
, "NORMAL_FRAME");
189 fprintf_unfiltered (file
, "DUMMY_FRAME");
192 fprintf_unfiltered (file
, "SIGTRAMP_FRAME");
195 fprintf_unfiltered (file
, "<unknown type>");
201 fprint_frame (struct ui_file
*file
, struct frame_info
*fi
)
205 fprintf_unfiltered (file
, "<NULL frame>");
208 fprintf_unfiltered (file
, "{");
209 fprintf_unfiltered (file
, "level=%d", fi
->level
);
210 fprintf_unfiltered (file
, ",");
211 fprintf_unfiltered (file
, "type=");
212 if (fi
->unwind
!= NULL
)
213 fprint_frame_type (file
, fi
->unwind
->type
);
215 fprintf_unfiltered (file
, "<unknown>");
216 fprintf_unfiltered (file
, ",");
217 fprintf_unfiltered (file
, "unwind=");
218 if (fi
->unwind
!= NULL
)
219 gdb_print_host_address (fi
->unwind
, file
);
221 fprintf_unfiltered (file
, "<unknown>");
222 fprintf_unfiltered (file
, ",");
223 fprintf_unfiltered (file
, "pc=");
224 if (fi
->next
!= NULL
&& fi
->next
->prev_pc
.p
)
225 fprintf_unfiltered (file
, "0x%s", paddr_nz (fi
->next
->prev_pc
.value
));
227 fprintf_unfiltered (file
, "<unknown>");
228 fprintf_unfiltered (file
, ",");
229 fprintf_unfiltered (file
, "id=");
231 fprint_frame_id (file
, fi
->this_id
.value
);
233 fprintf_unfiltered (file
, "<unknown>");
234 fprintf_unfiltered (file
, ",");
235 fprintf_unfiltered (file
, "func=");
236 if (fi
->next
!= NULL
&& fi
->next
->prev_func
.p
)
237 fprintf_unfiltered (file
, "0x%s", paddr_nz (fi
->next
->prev_func
.addr
));
239 fprintf_unfiltered (file
, "<unknown>");
240 fprintf_unfiltered (file
, "}");
243 /* Return a frame uniq ID that can be used to, later, re-find the
247 get_frame_id (struct frame_info
*fi
)
251 return null_frame_id
;
256 fprintf_unfiltered (gdb_stdlog
, "{ get_frame_id (fi=%d) ",
258 /* Find the unwinder. */
259 if (fi
->unwind
== NULL
)
260 fi
->unwind
= frame_unwind_find_by_frame (fi
->next
,
261 &fi
->prologue_cache
);
262 /* Find THIS frame's ID. */
263 fi
->unwind
->this_id (fi
->next
, &fi
->prologue_cache
, &fi
->this_id
.value
);
267 fprintf_unfiltered (gdb_stdlog
, "-> ");
268 fprint_frame_id (gdb_stdlog
, fi
->this_id
.value
);
269 fprintf_unfiltered (gdb_stdlog
, " }\n");
272 return fi
->this_id
.value
;
276 frame_unwind_id (struct frame_info
*next_frame
)
278 /* Use prev_frame, and not get_prev_frame. The latter will truncate
279 the frame chain, leading to this function unintentionally
280 returning a null_frame_id (e.g., when a caller requests the frame
281 ID of "main()"s caller. */
282 return get_frame_id (get_prev_frame_1 (next_frame
));
285 const struct frame_id null_frame_id
; /* All zeros. */
288 frame_id_build_special (CORE_ADDR stack_addr
, CORE_ADDR code_addr
,
289 CORE_ADDR special_addr
)
291 struct frame_id id
= null_frame_id
;
292 id
.stack_addr
= stack_addr
;
294 id
.code_addr
= code_addr
;
296 id
.special_addr
= special_addr
;
297 id
.special_addr_p
= 1;
302 frame_id_build (CORE_ADDR stack_addr
, CORE_ADDR code_addr
)
304 struct frame_id id
= null_frame_id
;
305 id
.stack_addr
= stack_addr
;
307 id
.code_addr
= code_addr
;
313 frame_id_build_wild (CORE_ADDR stack_addr
)
315 struct frame_id id
= null_frame_id
;
316 id
.stack_addr
= stack_addr
;
322 frame_id_p (struct frame_id l
)
325 /* The frame is valid iff it has a valid stack address. */
329 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_p (l=");
330 fprint_frame_id (gdb_stdlog
, l
);
331 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", p
);
337 frame_id_eq (struct frame_id l
, struct frame_id r
)
340 if (!l
.stack_addr_p
|| !r
.stack_addr_p
)
341 /* Like a NaN, if either ID is invalid, the result is false.
342 Note that a frame ID is invalid iff it is the null frame ID. */
344 else if (l
.stack_addr
!= r
.stack_addr
)
345 /* If .stack addresses are different, the frames are different. */
347 else if (!l
.code_addr_p
|| !r
.code_addr_p
)
348 /* An invalid code addr is a wild card, always succeed. */
350 else if (l
.code_addr
!= r
.code_addr
)
351 /* If .code addresses are different, the frames are different. */
353 else if (!l
.special_addr_p
|| !r
.special_addr_p
)
354 /* An invalid special addr is a wild card (or unused), always succeed. */
356 else if (l
.special_addr
== r
.special_addr
)
357 /* Frames are equal. */
364 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_eq (l=");
365 fprint_frame_id (gdb_stdlog
, l
);
366 fprintf_unfiltered (gdb_stdlog
, ",r=");
367 fprint_frame_id (gdb_stdlog
, r
);
368 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", eq
);
374 frame_id_inner (struct frame_id l
, struct frame_id r
)
377 if (!l
.stack_addr_p
|| !r
.stack_addr_p
)
378 /* Like NaN, any operation involving an invalid ID always fails. */
381 /* Only return non-zero when strictly inner than. Note that, per
382 comment in "frame.h", there is some fuzz here. Frameless
383 functions are not strictly inner than (same .stack but
384 different .code and/or .special address). */
385 inner
= INNER_THAN (l
.stack_addr
, r
.stack_addr
);
388 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_inner (l=");
389 fprint_frame_id (gdb_stdlog
, l
);
390 fprintf_unfiltered (gdb_stdlog
, ",r=");
391 fprint_frame_id (gdb_stdlog
, r
);
392 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", inner
);
398 frame_find_by_id (struct frame_id id
)
400 struct frame_info
*frame
;
402 /* ZERO denotes the null frame, let the caller decide what to do
403 about it. Should it instead return get_current_frame()? */
404 if (!frame_id_p (id
))
407 for (frame
= get_current_frame ();
409 frame
= get_prev_frame (frame
))
411 struct frame_id
this = get_frame_id (frame
);
412 if (frame_id_eq (id
, this))
413 /* An exact match. */
415 if (frame_id_inner (id
, this))
418 /* Either we're not yet gone far enough out along the frame
419 chain (inner(this,id)), or we're comparing frameless functions
420 (same .base, different .func, no test available). Struggle
421 on until we've definitly gone to far. */
427 frame_pc_unwind (struct frame_info
*this_frame
)
429 if (!this_frame
->prev_pc
.p
)
432 if (this_frame
->unwind
== NULL
)
434 = frame_unwind_find_by_frame (this_frame
->next
,
435 &this_frame
->prologue_cache
);
436 if (this_frame
->unwind
->prev_pc
!= NULL
)
437 /* A per-frame unwinder, prefer it. */
438 pc
= this_frame
->unwind
->prev_pc (this_frame
->next
,
439 &this_frame
->prologue_cache
);
440 else if (gdbarch_unwind_pc_p (current_gdbarch
))
442 /* The right way. The `pure' way. The one true way. This
443 method depends solely on the register-unwind code to
444 determine the value of registers in THIS frame, and hence
445 the value of this frame's PC (resume address). A typical
446 implementation is no more than:
448 frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
449 return extract_unsigned_integer (buf, size of ISA_PC_REGNUM);
451 Note: this method is very heavily dependent on a correct
452 register-unwind implementation, it pays to fix that
453 method first; this method is frame type agnostic, since
454 it only deals with register values, it works with any
455 frame. This is all in stark contrast to the old
456 FRAME_SAVED_PC which would try to directly handle all the
457 different ways that a PC could be unwound. */
458 pc
= gdbarch_unwind_pc (current_gdbarch
, this_frame
);
461 internal_error (__FILE__
, __LINE__
, _("No unwind_pc method"));
462 this_frame
->prev_pc
.value
= pc
;
463 this_frame
->prev_pc
.p
= 1;
465 fprintf_unfiltered (gdb_stdlog
,
466 "{ frame_pc_unwind (this_frame=%d) -> 0x%s }\n",
468 paddr_nz (this_frame
->prev_pc
.value
));
470 return this_frame
->prev_pc
.value
;
474 frame_func_unwind (struct frame_info
*fi
)
476 if (!fi
->prev_func
.p
)
478 /* Make certain that this, and not the adjacent, function is
480 CORE_ADDR addr_in_block
= frame_unwind_address_in_block (fi
);
482 fi
->prev_func
.addr
= get_pc_function_start (addr_in_block
);
484 fprintf_unfiltered (gdb_stdlog
,
485 "{ frame_func_unwind (fi=%d) -> 0x%s }\n",
486 fi
->level
, paddr_nz (fi
->prev_func
.addr
));
488 return fi
->prev_func
.addr
;
492 get_frame_func (struct frame_info
*fi
)
494 return frame_func_unwind (fi
->next
);
498 do_frame_register_read (void *src
, int regnum
, gdb_byte
*buf
)
500 frame_register_read (src
, regnum
, buf
);
505 frame_save_as_regcache (struct frame_info
*this_frame
)
507 struct regcache
*regcache
= regcache_xmalloc (current_gdbarch
);
508 struct cleanup
*cleanups
= make_cleanup_regcache_xfree (regcache
);
509 regcache_save (regcache
, do_frame_register_read
, this_frame
);
510 discard_cleanups (cleanups
);
515 frame_pop (struct frame_info
*this_frame
)
517 /* Make a copy of all the register values unwound from this frame.
518 Save them in a scratch buffer so that there isn't a race between
519 trying to extract the old values from the current_regcache while
520 at the same time writing new values into that same cache. */
521 struct regcache
*scratch
522 = frame_save_as_regcache (get_prev_frame_1 (this_frame
));
523 struct cleanup
*cleanups
= make_cleanup_regcache_xfree (scratch
);
525 /* FIXME: cagney/2003-03-16: It should be possible to tell the
526 target's register cache that it is about to be hit with a burst
527 register transfer and that the sequence of register writes should
528 be batched. The pair target_prepare_to_store() and
529 target_store_registers() kind of suggest this functionality.
530 Unfortunately, they don't implement it. Their lack of a formal
531 definition can lead to targets writing back bogus values
532 (arguably a bug in the target code mind). */
533 /* Now copy those saved registers into the current regcache.
534 Here, regcache_cpy() calls regcache_restore(). */
535 regcache_cpy (current_regcache
, scratch
);
536 do_cleanups (cleanups
);
538 /* We've made right mess of GDB's local state, just discard
540 flush_cached_frames ();
544 frame_register_unwind (struct frame_info
*frame
, int regnum
,
545 int *optimizedp
, enum lval_type
*lvalp
,
546 CORE_ADDR
*addrp
, int *realnump
, gdb_byte
*bufferp
)
548 struct frame_unwind_cache
*cache
;
552 fprintf_unfiltered (gdb_stdlog
, "\
553 { frame_register_unwind (frame=%d,regnum=%d(%s),...) ",
554 frame
->level
, regnum
,
555 frame_map_regnum_to_name (frame
, regnum
));
558 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
559 that the value proper does not need to be fetched. */
560 gdb_assert (optimizedp
!= NULL
);
561 gdb_assert (lvalp
!= NULL
);
562 gdb_assert (addrp
!= NULL
);
563 gdb_assert (realnump
!= NULL
);
564 /* gdb_assert (bufferp != NULL); */
566 /* NOTE: cagney/2002-11-27: A program trying to unwind a NULL frame
567 is broken. There is always a frame. If there, for some reason,
568 isn't a frame, there is some pretty busted code as it should have
569 detected the problem before calling here. */
570 gdb_assert (frame
!= NULL
);
572 /* Find the unwinder. */
573 if (frame
->unwind
== NULL
)
574 frame
->unwind
= frame_unwind_find_by_frame (frame
->next
,
575 &frame
->prologue_cache
);
577 /* Ask this frame to unwind its register. See comment in
578 "frame-unwind.h" for why NEXT frame and this unwind cache are
580 frame
->unwind
->prev_register (frame
->next
, &frame
->prologue_cache
, regnum
,
581 optimizedp
, lvalp
, addrp
, realnump
, bufferp
);
585 fprintf_unfiltered (gdb_stdlog
, "->");
586 fprintf_unfiltered (gdb_stdlog
, " *optimizedp=%d", (*optimizedp
));
587 fprintf_unfiltered (gdb_stdlog
, " *lvalp=%d", (int) (*lvalp
));
588 fprintf_unfiltered (gdb_stdlog
, " *addrp=0x%s", paddr_nz ((*addrp
)));
589 fprintf_unfiltered (gdb_stdlog
, " *bufferp=");
591 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
595 const unsigned char *buf
= bufferp
;
596 fprintf_unfiltered (gdb_stdlog
, "[");
597 for (i
= 0; i
< register_size (current_gdbarch
, regnum
); i
++)
598 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
599 fprintf_unfiltered (gdb_stdlog
, "]");
601 fprintf_unfiltered (gdb_stdlog
, " }\n");
606 frame_register (struct frame_info
*frame
, int regnum
,
607 int *optimizedp
, enum lval_type
*lvalp
,
608 CORE_ADDR
*addrp
, int *realnump
, gdb_byte
*bufferp
)
610 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
611 that the value proper does not need to be fetched. */
612 gdb_assert (optimizedp
!= NULL
);
613 gdb_assert (lvalp
!= NULL
);
614 gdb_assert (addrp
!= NULL
);
615 gdb_assert (realnump
!= NULL
);
616 /* gdb_assert (bufferp != NULL); */
618 /* Obtain the register value by unwinding the register from the next
619 (more inner frame). */
620 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
621 frame_register_unwind (frame
->next
, regnum
, optimizedp
, lvalp
, addrp
,
626 frame_unwind_register (struct frame_info
*frame
, int regnum
, gdb_byte
*buf
)
632 frame_register_unwind (frame
, regnum
, &optimized
, &lval
, &addr
,
637 get_frame_register (struct frame_info
*frame
,
638 int regnum
, gdb_byte
*buf
)
640 frame_unwind_register (frame
->next
, regnum
, buf
);
644 frame_unwind_register_signed (struct frame_info
*frame
, int regnum
)
646 gdb_byte buf
[MAX_REGISTER_SIZE
];
647 frame_unwind_register (frame
, regnum
, buf
);
648 return extract_signed_integer (buf
, register_size (get_frame_arch (frame
),
653 get_frame_register_signed (struct frame_info
*frame
, int regnum
)
655 return frame_unwind_register_signed (frame
->next
, regnum
);
659 frame_unwind_register_unsigned (struct frame_info
*frame
, int regnum
)
661 gdb_byte buf
[MAX_REGISTER_SIZE
];
662 frame_unwind_register (frame
, regnum
, buf
);
663 return extract_unsigned_integer (buf
, register_size (get_frame_arch (frame
),
668 get_frame_register_unsigned (struct frame_info
*frame
, int regnum
)
670 return frame_unwind_register_unsigned (frame
->next
, regnum
);
674 frame_unwind_unsigned_register (struct frame_info
*frame
, int regnum
,
677 gdb_byte buf
[MAX_REGISTER_SIZE
];
678 frame_unwind_register (frame
, regnum
, buf
);
679 (*val
) = extract_unsigned_integer (buf
,
680 register_size (get_frame_arch (frame
),
685 put_frame_register (struct frame_info
*frame
, int regnum
,
688 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
693 frame_register (frame
, regnum
, &optim
, &lval
, &addr
, &realnum
, NULL
);
695 error (_("Attempt to assign to a value that was optimized out."));
700 /* FIXME: write_memory doesn't yet take constant buffers.
702 gdb_byte tmp
[MAX_REGISTER_SIZE
];
703 memcpy (tmp
, buf
, register_size (gdbarch
, regnum
));
704 write_memory (addr
, tmp
, register_size (gdbarch
, regnum
));
708 regcache_cooked_write (current_regcache
, realnum
, buf
);
711 error (_("Attempt to assign to an unmodifiable value."));
715 /* frame_register_read ()
717 Find and return the value of REGNUM for the specified stack frame.
718 The number of bytes copied is REGISTER_SIZE (REGNUM).
720 Returns 0 if the register value could not be found. */
723 frame_register_read (struct frame_info
*frame
, int regnum
,
730 frame_register (frame
, regnum
, &optimized
, &lval
, &addr
, &realnum
, myaddr
);
732 /* FIXME: cagney/2002-05-15: This test is just bogus.
734 It indicates that the target failed to supply a value for a
735 register because it was "not available" at this time. Problem
736 is, the target still has the register and so get saved_register()
737 may be returning a value saved on the stack. */
739 if (register_cached (regnum
) < 0)
740 return 0; /* register value not available */
746 /* Map between a frame register number and its name. A frame register
747 space is a superset of the cooked register space --- it also
748 includes builtin registers. */
751 frame_map_name_to_regnum (struct frame_info
*frame
, const char *name
, int len
)
753 return user_reg_map_name_to_regnum (get_frame_arch (frame
), name
, len
);
757 frame_map_regnum_to_name (struct frame_info
*frame
, int regnum
)
759 return user_reg_map_regnum_to_name (get_frame_arch (frame
), regnum
);
762 /* Create a sentinel frame. */
764 static struct frame_info
*
765 create_sentinel_frame (struct regcache
*regcache
)
767 struct frame_info
*frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
769 /* Explicitly initialize the sentinel frame's cache. Provide it
770 with the underlying regcache. In the future additional
771 information, such as the frame's thread will be added. */
772 frame
->prologue_cache
= sentinel_frame_cache (regcache
);
773 /* For the moment there is only one sentinel frame implementation. */
774 frame
->unwind
= sentinel_frame_unwind
;
775 /* Link this frame back to itself. The frame is self referential
776 (the unwound PC is the same as the pc), so make it so. */
778 /* Make the sentinel frame's ID valid, but invalid. That way all
779 comparisons with it should fail. */
780 frame
->this_id
.p
= 1;
781 frame
->this_id
.value
= null_frame_id
;
784 fprintf_unfiltered (gdb_stdlog
, "{ create_sentinel_frame (...) -> ");
785 fprint_frame (gdb_stdlog
, frame
);
786 fprintf_unfiltered (gdb_stdlog
, " }\n");
791 /* Info about the innermost stack frame (contents of FP register) */
793 static struct frame_info
*current_frame
;
795 /* Cache for frame addresses already read by gdb. Valid only while
796 inferior is stopped. Control variables for the frame cache should
797 be local to this module. */
799 static struct obstack frame_cache_obstack
;
802 frame_obstack_zalloc (unsigned long size
)
804 void *data
= obstack_alloc (&frame_cache_obstack
, size
);
805 memset (data
, 0, size
);
809 /* Return the innermost (currently executing) stack frame. This is
810 split into two functions. The function unwind_to_current_frame()
811 is wrapped in catch exceptions so that, even when the unwind of the
812 sentinel frame fails, the function still returns a stack frame. */
815 unwind_to_current_frame (struct ui_out
*ui_out
, void *args
)
817 struct frame_info
*frame
= get_prev_frame (args
);
818 /* A sentinel frame can fail to unwind, e.g., because its PC value
819 lands in somewhere like start. */
822 current_frame
= frame
;
827 get_current_frame (void)
829 /* First check, and report, the lack of registers. Having GDB
830 report "No stack!" or "No memory" when the target doesn't even
831 have registers is very confusing. Besides, "printcmd.exp"
832 explicitly checks that ``print $pc'' with no registers prints "No
834 if (!target_has_registers
)
835 error (_("No registers."));
836 if (!target_has_stack
)
837 error (_("No stack."));
838 if (!target_has_memory
)
839 error (_("No memory."));
840 if (current_frame
== NULL
)
842 struct frame_info
*sentinel_frame
=
843 create_sentinel_frame (current_regcache
);
844 if (catch_exceptions (uiout
, unwind_to_current_frame
, sentinel_frame
,
845 RETURN_MASK_ERROR
) != 0)
847 /* Oops! Fake a current frame? Is this useful? It has a PC
848 of zero, for instance. */
849 current_frame
= sentinel_frame
;
852 return current_frame
;
855 /* The "selected" stack frame is used by default for local and arg
856 access. May be zero, for no selected frame. */
858 struct frame_info
*deprecated_selected_frame
;
860 /* Return the selected frame. Always non-NULL (unless there isn't an
861 inferior sufficient for creating a frame) in which case an error is
865 get_selected_frame (const char *message
)
867 if (deprecated_selected_frame
== NULL
)
869 if (message
!= NULL
&& (!target_has_registers
871 || !target_has_memory
))
872 error (("%s"), message
);
873 /* Hey! Don't trust this. It should really be re-finding the
874 last selected frame of the currently selected thread. This,
875 though, is better than nothing. */
876 select_frame (get_current_frame ());
878 /* There is always a frame. */
879 gdb_assert (deprecated_selected_frame
!= NULL
);
880 return deprecated_selected_frame
;
883 /* This is a variant of get_selected_frame() which can be called when
884 the inferior does not have a frame; in that case it will return
885 NULL instead of calling error(). */
888 deprecated_safe_get_selected_frame (void)
890 if (!target_has_registers
|| !target_has_stack
|| !target_has_memory
)
892 return get_selected_frame (NULL
);
895 /* Select frame FI (or NULL - to invalidate the current frame). */
898 select_frame (struct frame_info
*fi
)
902 deprecated_selected_frame
= fi
;
903 /* NOTE: cagney/2002-05-04: FI can be NULL. This occurs when the
904 frame is being invalidated. */
905 if (deprecated_selected_frame_level_changed_hook
)
906 deprecated_selected_frame_level_changed_hook (frame_relative_level (fi
));
908 /* FIXME: kseitz/2002-08-28: It would be nice to call
909 selected_frame_level_changed_event() right here, but due to limitations
910 in the current interfaces, we would end up flooding UIs with events
911 because select_frame() is used extensively internally.
913 Once we have frame-parameterized frame (and frame-related) commands,
914 the event notification can be moved here, since this function will only
915 be called when the user's selected frame is being changed. */
917 /* Ensure that symbols for this frame are read in. Also, determine the
918 source language of this frame, and switch to it if desired. */
921 /* We retrieve the frame's symtab by using the frame PC. However
922 we cannot use the frame PC as-is, because it usually points to
923 the instruction following the "call", which is sometimes the
924 first instruction of another function. So we rely on
925 get_frame_address_in_block() which provides us with a PC which
926 is guaranteed to be inside the frame's code block. */
927 s
= find_pc_symtab (get_frame_address_in_block (fi
));
929 && s
->language
!= current_language
->la_language
930 && s
->language
!= language_unknown
931 && language_mode
== language_mode_auto
)
933 set_language (s
->language
);
938 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
939 Always returns a non-NULL value. */
942 create_new_frame (CORE_ADDR addr
, CORE_ADDR pc
)
944 struct frame_info
*fi
;
948 fprintf_unfiltered (gdb_stdlog
,
949 "{ create_new_frame (addr=0x%s, pc=0x%s) ",
950 paddr_nz (addr
), paddr_nz (pc
));
953 fi
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
955 fi
->next
= create_sentinel_frame (current_regcache
);
957 /* Select/initialize both the unwind function and the frame's type
959 fi
->unwind
= frame_unwind_find_by_frame (fi
->next
, &fi
->prologue_cache
);
962 deprecated_update_frame_base_hack (fi
, addr
);
963 deprecated_update_frame_pc_hack (fi
, pc
);
967 fprintf_unfiltered (gdb_stdlog
, "-> ");
968 fprint_frame (gdb_stdlog
, fi
);
969 fprintf_unfiltered (gdb_stdlog
, " }\n");
975 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
976 innermost frame). Be careful to not fall off the bottom of the
977 frame chain and onto the sentinel frame. */
980 get_next_frame (struct frame_info
*this_frame
)
982 if (this_frame
->level
> 0)
983 return this_frame
->next
;
988 /* Observer for the target_changed event. */
991 frame_observer_target_changed (struct target_ops
*target
)
993 flush_cached_frames ();
996 /* Flush the entire frame cache. */
999 flush_cached_frames (void)
1001 /* Since we can't really be sure what the first object allocated was */
1002 obstack_free (&frame_cache_obstack
, 0);
1003 obstack_init (&frame_cache_obstack
);
1005 current_frame
= NULL
; /* Invalidate cache */
1006 select_frame (NULL
);
1007 annotate_frames_invalid ();
1009 fprintf_unfiltered (gdb_stdlog
, "{ flush_cached_frames () }\n");
1012 /* Flush the frame cache, and start a new one if necessary. */
1015 reinit_frame_cache (void)
1017 flush_cached_frames ();
1019 /* FIXME: The inferior_ptid test is wrong if there is a corefile. */
1020 if (PIDGET (inferior_ptid
) != 0)
1022 select_frame (get_current_frame ());
1026 /* Return a "struct frame_info" corresponding to the frame that called
1027 THIS_FRAME. Returns NULL if there is no such frame.
1029 Unlike get_prev_frame, this function always tries to unwind the
1032 static struct frame_info
*
1033 get_prev_frame_1 (struct frame_info
*this_frame
)
1035 struct frame_info
*prev_frame
;
1036 struct frame_id this_id
;
1038 gdb_assert (this_frame
!= NULL
);
1042 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame_1 (this_frame=");
1043 if (this_frame
!= NULL
)
1044 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1046 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1047 fprintf_unfiltered (gdb_stdlog
, ") ");
1050 /* Only try to do the unwind once. */
1051 if (this_frame
->prev_p
)
1055 fprintf_unfiltered (gdb_stdlog
, "-> ");
1056 fprint_frame (gdb_stdlog
, this_frame
->prev
);
1057 fprintf_unfiltered (gdb_stdlog
, " // cached \n");
1059 return this_frame
->prev
;
1061 this_frame
->prev_p
= 1;
1062 this_frame
->stop_reason
= UNWIND_NO_REASON
;
1064 /* Check that this frame's ID was valid. If it wasn't, don't try to
1065 unwind to the prev frame. Be careful to not apply this test to
1066 the sentinel frame. */
1067 this_id
= get_frame_id (this_frame
);
1068 if (this_frame
->level
>= 0 && !frame_id_p (this_id
))
1072 fprintf_unfiltered (gdb_stdlog
, "-> ");
1073 fprint_frame (gdb_stdlog
, NULL
);
1074 fprintf_unfiltered (gdb_stdlog
, " // this ID is NULL }\n");
1076 this_frame
->stop_reason
= UNWIND_NULL_ID
;
1080 /* Check that this frame's ID isn't inner to (younger, below, next)
1081 the next frame. This happens when a frame unwind goes backwards.
1082 Exclude signal trampolines (due to sigaltstack the frame ID can
1083 go backwards) and sentinel frames (the test is meaningless). */
1084 if (this_frame
->next
->level
>= 0
1085 && this_frame
->next
->unwind
->type
!= SIGTRAMP_FRAME
1086 && frame_id_inner (this_id
, get_frame_id (this_frame
->next
)))
1090 fprintf_unfiltered (gdb_stdlog
, "-> ");
1091 fprint_frame (gdb_stdlog
, NULL
);
1092 fprintf_unfiltered (gdb_stdlog
, " // this frame ID is inner }\n");
1094 this_frame
->stop_reason
= UNWIND_INNER_ID
;
1098 /* Check that this and the next frame are not identical. If they
1099 are, there is most likely a stack cycle. As with the inner-than
1100 test above, avoid comparing the inner-most and sentinel frames. */
1101 if (this_frame
->level
> 0
1102 && frame_id_eq (this_id
, get_frame_id (this_frame
->next
)))
1106 fprintf_unfiltered (gdb_stdlog
, "-> ");
1107 fprint_frame (gdb_stdlog
, NULL
);
1108 fprintf_unfiltered (gdb_stdlog
, " // this frame has same ID }\n");
1110 this_frame
->stop_reason
= UNWIND_SAME_ID
;
1114 /* Allocate the new frame but do not wire it in to the frame chain.
1115 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
1116 frame->next to pull some fancy tricks (of course such code is, by
1117 definition, recursive). Try to prevent it.
1119 There is no reason to worry about memory leaks, should the
1120 remainder of the function fail. The allocated memory will be
1121 quickly reclaimed when the frame cache is flushed, and the `we've
1122 been here before' check above will stop repeated memory
1123 allocation calls. */
1124 prev_frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1125 prev_frame
->level
= this_frame
->level
+ 1;
1127 /* Don't yet compute ->unwind (and hence ->type). It is computed
1128 on-demand in get_frame_type, frame_register_unwind, and
1131 /* Don't yet compute the frame's ID. It is computed on-demand by
1134 /* The unwound frame ID is validate at the start of this function,
1135 as part of the logic to decide if that frame should be further
1136 unwound, and not here while the prev frame is being created.
1137 Doing this makes it possible for the user to examine a frame that
1138 has an invalid frame ID.
1140 Some very old VAX code noted: [...] For the sake of argument,
1141 suppose that the stack is somewhat trashed (which is one reason
1142 that "info frame" exists). So, return 0 (indicating we don't
1143 know the address of the arglist) if we don't know what frame this
1147 this_frame
->prev
= prev_frame
;
1148 prev_frame
->next
= this_frame
;
1152 fprintf_unfiltered (gdb_stdlog
, "-> ");
1153 fprint_frame (gdb_stdlog
, prev_frame
);
1154 fprintf_unfiltered (gdb_stdlog
, " }\n");
1160 /* Debug routine to print a NULL frame being returned. */
1163 frame_debug_got_null_frame (struct ui_file
*file
,
1164 struct frame_info
*this_frame
,
1169 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame (this_frame=");
1170 if (this_frame
!= NULL
)
1171 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1173 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1174 fprintf_unfiltered (gdb_stdlog
, ") -> // %s}\n", reason
);
1178 /* Is this (non-sentinel) frame in the "main"() function? */
1181 inside_main_func (struct frame_info
*this_frame
)
1183 struct minimal_symbol
*msymbol
;
1186 if (symfile_objfile
== 0)
1188 msymbol
= lookup_minimal_symbol (main_name (), NULL
, symfile_objfile
);
1189 if (msymbol
== NULL
)
1191 /* Make certain that the code, and not descriptor, address is
1193 maddr
= gdbarch_convert_from_func_ptr_addr (current_gdbarch
,
1194 SYMBOL_VALUE_ADDRESS (msymbol
),
1196 return maddr
== get_frame_func (this_frame
);
1199 /* Test whether THIS_FRAME is inside the process entry point function. */
1202 inside_entry_func (struct frame_info
*this_frame
)
1204 return (get_frame_func (this_frame
) == entry_point_address ());
1207 /* Return a structure containing various interesting information about
1208 the frame that called THIS_FRAME. Returns NULL if there is entier
1209 no such frame or the frame fails any of a set of target-independent
1210 condition that should terminate the frame chain (e.g., as unwinding
1213 This function should not contain target-dependent tests, such as
1214 checking whether the program-counter is zero. */
1217 get_prev_frame (struct frame_info
*this_frame
)
1219 struct frame_info
*prev_frame
;
1221 /* Return the inner-most frame, when the caller passes in NULL. */
1222 /* NOTE: cagney/2002-11-09: Not sure how this would happen. The
1223 caller should have previously obtained a valid frame using
1224 get_selected_frame() and then called this code - only possibility
1225 I can think of is code behaving badly.
1227 NOTE: cagney/2003-01-10: Talk about code behaving badly. Check
1228 block_innermost_frame(). It does the sequence: frame = NULL;
1229 while (1) { frame = get_prev_frame (frame); .... }. Ulgh! Why
1230 it couldn't be written better, I don't know.
1232 NOTE: cagney/2003-01-11: I suspect what is happening in
1233 block_innermost_frame() is, when the target has no state
1234 (registers, memory, ...), it is still calling this function. The
1235 assumption being that this function will return NULL indicating
1236 that a frame isn't possible, rather than checking that the target
1237 has state and then calling get_current_frame() and
1238 get_prev_frame(). This is a guess mind. */
1239 if (this_frame
== NULL
)
1241 /* NOTE: cagney/2002-11-09: There was a code segment here that
1242 would error out when CURRENT_FRAME was NULL. The comment
1243 that went with it made the claim ...
1245 ``This screws value_of_variable, which just wants a nice
1246 clean NULL return from block_innermost_frame if there are no
1247 frames. I don't think I've ever seen this message happen
1248 otherwise. And returning NULL here is a perfectly legitimate
1251 Per the above, this code shouldn't even be called with a NULL
1253 frame_debug_got_null_frame (gdb_stdlog
, this_frame
, "this_frame NULL");
1254 return current_frame
;
1257 /* There is always a frame. If this assertion fails, suspect that
1258 something should be calling get_selected_frame() or
1259 get_current_frame(). */
1260 gdb_assert (this_frame
!= NULL
);
1262 /* tausq/2004-12-07: Dummy frames are skipped because it doesn't make much
1263 sense to stop unwinding at a dummy frame. One place where a dummy
1264 frame may have an address "inside_main_func" is on HPUX. On HPUX, the
1265 pcsqh register (space register for the instruction at the head of the
1266 instruction queue) cannot be written directly; the only way to set it
1267 is to branch to code that is in the target space. In order to implement
1268 frame dummies on HPUX, the called function is made to jump back to where
1269 the inferior was when the user function was called. If gdb was inside
1270 the main function when we created the dummy frame, the dummy frame will
1271 point inside the main function. */
1272 if (this_frame
->level
>= 0
1273 && get_frame_type (this_frame
) != DUMMY_FRAME
1274 && !backtrace_past_main
1275 && inside_main_func (this_frame
))
1276 /* Don't unwind past main(). Note, this is done _before_ the
1277 frame has been marked as previously unwound. That way if the
1278 user later decides to enable unwinds past main(), that will
1279 automatically happen. */
1281 frame_debug_got_null_frame (gdb_stdlog
, this_frame
, "inside main func");
1285 /* If the user's backtrace limit has been exceeded, stop. We must
1286 add two to the current level; one of those accounts for backtrace_limit
1287 being 1-based and the level being 0-based, and the other accounts for
1288 the level of the new frame instead of the level of the current
1290 if (this_frame
->level
+ 2 > backtrace_limit
)
1292 frame_debug_got_null_frame (gdb_stdlog
, this_frame
,
1293 "backtrace limit exceeded");
1297 /* If we're already inside the entry function for the main objfile,
1298 then it isn't valid. Don't apply this test to a dummy frame -
1299 dummy frame PCs typically land in the entry func. Don't apply
1300 this test to the sentinel frame. Sentinel frames should always
1301 be allowed to unwind. */
1302 /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() -
1303 wasn't checking for "main" in the minimal symbols. With that
1304 fixed asm-source tests now stop in "main" instead of halting the
1305 backtrace in weird and wonderful ways somewhere inside the entry
1306 file. Suspect that tests for inside the entry file/func were
1307 added to work around that (now fixed) case. */
1308 /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
1309 suggested having the inside_entry_func test use the
1310 inside_main_func() msymbol trick (along with entry_point_address()
1311 I guess) to determine the address range of the start function.
1312 That should provide a far better stopper than the current
1314 /* NOTE: tausq/2004-10-09: this is needed if, for example, the compiler
1315 applied tail-call optimizations to main so that a function called
1316 from main returns directly to the caller of main. Since we don't
1317 stop at main, we should at least stop at the entry point of the
1319 if (!backtrace_past_entry
1320 && get_frame_type (this_frame
) != DUMMY_FRAME
&& this_frame
->level
>= 0
1321 && inside_entry_func (this_frame
))
1323 frame_debug_got_null_frame (gdb_stdlog
, this_frame
, "inside entry func");
1327 /* Assume that the only way to get a zero PC is through something
1328 like a SIGSEGV or a dummy frame, and hence that NORMAL frames
1329 will never unwind a zero PC. */
1330 if (this_frame
->level
> 0
1331 && get_frame_type (this_frame
) == NORMAL_FRAME
1332 && get_frame_type (get_next_frame (this_frame
)) == NORMAL_FRAME
1333 && get_frame_pc (this_frame
) == 0)
1335 frame_debug_got_null_frame (gdb_stdlog
, this_frame
, "zero PC");
1339 return get_prev_frame_1 (this_frame
);
1343 get_frame_pc (struct frame_info
*frame
)
1345 gdb_assert (frame
->next
!= NULL
);
1346 return frame_pc_unwind (frame
->next
);
1349 /* Return an address of that falls within the frame's code block. */
1352 frame_unwind_address_in_block (struct frame_info
*next_frame
)
1354 /* A draft address. */
1355 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
1357 /* If THIS frame is not inner most (i.e., NEXT isn't the sentinel),
1358 and NEXT is `normal' (i.e., not a sigtramp, dummy, ....) THIS
1359 frame's PC ends up pointing at the instruction fallowing the
1360 "call". Adjust that PC value so that it falls on the call
1361 instruction (which, hopefully, falls within THIS frame's code
1362 block. So far it's proved to be a very good approximation. See
1363 get_frame_type() for why ->type can't be used. */
1364 if (next_frame
->level
>= 0
1365 && get_frame_type (next_frame
) == NORMAL_FRAME
)
1371 get_frame_address_in_block (struct frame_info
*this_frame
)
1373 return frame_unwind_address_in_block (this_frame
->next
);
1377 pc_notcurrent (struct frame_info
*frame
)
1379 /* If FRAME is not the innermost frame, that normally means that
1380 FRAME->pc points at the return instruction (which is *after* the
1381 call instruction), and we want to get the line containing the
1382 call (because the call is where the user thinks the program is).
1383 However, if the next frame is either a SIGTRAMP_FRAME or a
1384 DUMMY_FRAME, then the next frame will contain a saved interrupt
1385 PC and such a PC indicates the current (rather than next)
1386 instruction/line, consequently, for such cases, want to get the
1387 line containing fi->pc. */
1388 struct frame_info
*next
= get_next_frame (frame
);
1389 int notcurrent
= (next
!= NULL
&& get_frame_type (next
) == NORMAL_FRAME
);
1394 find_frame_sal (struct frame_info
*frame
, struct symtab_and_line
*sal
)
1396 (*sal
) = find_pc_line (get_frame_pc (frame
), pc_notcurrent (frame
));
1399 /* Per "frame.h", return the ``address'' of the frame. Code should
1400 really be using get_frame_id(). */
1402 get_frame_base (struct frame_info
*fi
)
1404 return get_frame_id (fi
).stack_addr
;
1407 /* High-level offsets into the frame. Used by the debug info. */
1410 get_frame_base_address (struct frame_info
*fi
)
1412 if (get_frame_type (fi
) != NORMAL_FRAME
)
1414 if (fi
->base
== NULL
)
1415 fi
->base
= frame_base_find_by_frame (fi
->next
);
1416 /* Sneaky: If the low-level unwind and high-level base code share a
1417 common unwinder, let them share the prologue cache. */
1418 if (fi
->base
->unwind
== fi
->unwind
)
1419 return fi
->base
->this_base (fi
->next
, &fi
->prologue_cache
);
1420 return fi
->base
->this_base (fi
->next
, &fi
->base_cache
);
1424 get_frame_locals_address (struct frame_info
*fi
)
1427 if (get_frame_type (fi
) != NORMAL_FRAME
)
1429 /* If there isn't a frame address method, find it. */
1430 if (fi
->base
== NULL
)
1431 fi
->base
= frame_base_find_by_frame (fi
->next
);
1432 /* Sneaky: If the low-level unwind and high-level base code share a
1433 common unwinder, let them share the prologue cache. */
1434 if (fi
->base
->unwind
== fi
->unwind
)
1435 cache
= &fi
->prologue_cache
;
1437 cache
= &fi
->base_cache
;
1438 return fi
->base
->this_locals (fi
->next
, cache
);
1442 get_frame_args_address (struct frame_info
*fi
)
1445 if (get_frame_type (fi
) != NORMAL_FRAME
)
1447 /* If there isn't a frame address method, find it. */
1448 if (fi
->base
== NULL
)
1449 fi
->base
= frame_base_find_by_frame (fi
->next
);
1450 /* Sneaky: If the low-level unwind and high-level base code share a
1451 common unwinder, let them share the prologue cache. */
1452 if (fi
->base
->unwind
== fi
->unwind
)
1453 cache
= &fi
->prologue_cache
;
1455 cache
= &fi
->base_cache
;
1456 return fi
->base
->this_args (fi
->next
, cache
);
1459 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
1460 or -1 for a NULL frame. */
1463 frame_relative_level (struct frame_info
*fi
)
1472 get_frame_type (struct frame_info
*frame
)
1474 if (frame
->unwind
== NULL
)
1475 /* Initialize the frame's unwinder because that's what
1476 provides the frame's type. */
1477 frame
->unwind
= frame_unwind_find_by_frame (frame
->next
,
1478 &frame
->prologue_cache
);
1479 return frame
->unwind
->type
;
1483 deprecated_update_frame_pc_hack (struct frame_info
*frame
, CORE_ADDR pc
)
1486 fprintf_unfiltered (gdb_stdlog
,
1487 "{ deprecated_update_frame_pc_hack (frame=%d,pc=0x%s) }\n",
1488 frame
->level
, paddr_nz (pc
));
1489 /* NOTE: cagney/2003-03-11: Some architectures (e.g., Arm) are
1490 maintaining a locally allocated frame object. Since such frames
1491 are not in the frame chain, it isn't possible to assume that the
1492 frame has a next. Sigh. */
1493 if (frame
->next
!= NULL
)
1495 /* While we're at it, update this frame's cached PC value, found
1496 in the next frame. Oh for the day when "struct frame_info"
1497 is opaque and this hack on hack can just go away. */
1498 frame
->next
->prev_pc
.value
= pc
;
1499 frame
->next
->prev_pc
.p
= 1;
1504 deprecated_update_frame_base_hack (struct frame_info
*frame
, CORE_ADDR base
)
1507 fprintf_unfiltered (gdb_stdlog
,
1508 "{ deprecated_update_frame_base_hack (frame=%d,base=0x%s) }\n",
1509 frame
->level
, paddr_nz (base
));
1510 /* See comment in "frame.h". */
1511 frame
->this_id
.value
.stack_addr
= base
;
1514 /* Memory access methods. */
1517 get_frame_memory (struct frame_info
*this_frame
, CORE_ADDR addr
,
1518 gdb_byte
*buf
, int len
)
1520 read_memory (addr
, buf
, len
);
1524 get_frame_memory_signed (struct frame_info
*this_frame
, CORE_ADDR addr
,
1527 return read_memory_integer (addr
, len
);
1531 get_frame_memory_unsigned (struct frame_info
*this_frame
, CORE_ADDR addr
,
1534 return read_memory_unsigned_integer (addr
, len
);
1538 safe_frame_unwind_memory (struct frame_info
*this_frame
,
1539 CORE_ADDR addr
, gdb_byte
*buf
, int len
)
1541 /* NOTE: read_memory_nobpt returns zero on success! */
1542 return !read_memory_nobpt (addr
, buf
, len
);
1545 /* Architecture method. */
1548 get_frame_arch (struct frame_info
*this_frame
)
1550 return current_gdbarch
;
1553 /* Stack pointer methods. */
1556 get_frame_sp (struct frame_info
*this_frame
)
1558 return frame_sp_unwind (this_frame
->next
);
1562 frame_sp_unwind (struct frame_info
*next_frame
)
1564 /* Normality - an architecture that provides a way of obtaining any
1565 frame inner-most address. */
1566 if (gdbarch_unwind_sp_p (current_gdbarch
))
1567 return gdbarch_unwind_sp (current_gdbarch
, next_frame
);
1568 /* Things are looking grim. If it's the inner-most frame and there
1569 is a TARGET_READ_SP, then that can be used. */
1570 if (next_frame
->level
< 0 && TARGET_READ_SP_P ())
1571 return TARGET_READ_SP ();
1572 /* Now things are really are grim. Hope that the value returned by
1573 the SP_REGNUM register is meaningful. */
1577 frame_unwind_unsigned_register (next_frame
, SP_REGNUM
, &sp
);
1580 internal_error (__FILE__
, __LINE__
, _("Missing unwind SP method"));
1583 /* Return the reason why we can't unwind past FRAME. */
1585 enum unwind_stop_reason
1586 get_frame_unwind_stop_reason (struct frame_info
*frame
)
1588 /* If we haven't tried to unwind past this point yet, then assume
1589 that unwinding would succeed. */
1590 if (frame
->prev_p
== 0)
1591 return UNWIND_NO_REASON
;
1593 /* Otherwise, we set a reason when we succeeded (or failed) to
1595 return frame
->stop_reason
;
1598 /* Return a string explaining REASON. */
1601 frame_stop_reason_string (enum unwind_stop_reason reason
)
1605 case UNWIND_NULL_ID
:
1606 return _("unwinder did not report frame ID");
1608 case UNWIND_INNER_ID
:
1609 return _("previous frame inner to this frame (corrupt stack?)");
1611 case UNWIND_SAME_ID
:
1612 return _("previous frame identical to this frame (corrupt stack?)");
1614 case UNWIND_NO_REASON
:
1615 case UNWIND_FIRST_ERROR
:
1617 internal_error (__FILE__
, __LINE__
,
1618 "Invalid frame stop reason");
1622 extern initialize_file_ftype _initialize_frame
; /* -Wmissing-prototypes */
1624 static struct cmd_list_element
*set_backtrace_cmdlist
;
1625 static struct cmd_list_element
*show_backtrace_cmdlist
;
1628 set_backtrace_cmd (char *args
, int from_tty
)
1630 help_list (set_backtrace_cmdlist
, "set backtrace ", -1, gdb_stdout
);
1634 show_backtrace_cmd (char *args
, int from_tty
)
1636 cmd_show_list (show_backtrace_cmdlist
, from_tty
, "");
1640 _initialize_frame (void)
1642 obstack_init (&frame_cache_obstack
);
1644 observer_attach_target_changed (frame_observer_target_changed
);
1646 add_prefix_cmd ("backtrace", class_maintenance
, set_backtrace_cmd
, _("\
1647 Set backtrace specific variables.\n\
1648 Configure backtrace variables such as the backtrace limit"),
1649 &set_backtrace_cmdlist
, "set backtrace ",
1650 0/*allow-unknown*/, &setlist
);
1651 add_prefix_cmd ("backtrace", class_maintenance
, show_backtrace_cmd
, _("\
1652 Show backtrace specific variables\n\
1653 Show backtrace variables such as the backtrace limit"),
1654 &show_backtrace_cmdlist
, "show backtrace ",
1655 0/*allow-unknown*/, &showlist
);
1657 add_setshow_boolean_cmd ("past-main", class_obscure
,
1658 &backtrace_past_main
, _("\
1659 Set whether backtraces should continue past \"main\"."), _("\
1660 Show whether backtraces should continue past \"main\"."), _("\
1661 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
1662 the backtrace at \"main\". Set this variable if you need to see the rest\n\
1663 of the stack trace."),
1665 show_backtrace_past_main
,
1666 &set_backtrace_cmdlist
,
1667 &show_backtrace_cmdlist
);
1669 add_setshow_boolean_cmd ("past-entry", class_obscure
,
1670 &backtrace_past_entry
, _("\
1671 Set whether backtraces should continue past the entry point of a program."),
1673 Show whether backtraces should continue past the entry point of a program."),
1675 Normally there are no callers beyond the entry point of a program, so GDB\n\
1676 will terminate the backtrace there. Set this variable if you need to see \n\
1677 the rest of the stack trace."),
1679 show_backtrace_past_entry
,
1680 &set_backtrace_cmdlist
,
1681 &show_backtrace_cmdlist
);
1683 add_setshow_integer_cmd ("limit", class_obscure
,
1684 &backtrace_limit
, _("\
1685 Set an upper bound on the number of backtrace levels."), _("\
1686 Show the upper bound on the number of backtrace levels."), _("\
1687 No more than the specified number of frames can be displayed or examined.\n\
1688 Zero is unlimited."),
1690 show_backtrace_limit
,
1691 &set_backtrace_cmdlist
,
1692 &show_backtrace_cmdlist
);
1694 /* Debug this files internals. */
1695 add_setshow_zinteger_cmd ("frame", class_maintenance
, &frame_debug
, _("\
1696 Set frame debugging."), _("\
1697 Show frame debugging."), _("\
1698 When non-zero, frame specific internal debugging is enabled."),
1701 &setdebuglist
, &showdebuglist
);