1 /* Cache and manage frames for GDB, the GNU debugger.
3 Copyright 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000,
4 2001, 2002, 2003 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., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
27 #include "inferior.h" /* for inferior_ptid */
29 #include "gdb_assert.h"
30 #include "gdb_string.h"
31 #include "builtin-regs.h"
32 #include "gdb_obstack.h"
33 #include "dummy-frame.h"
34 #include "sentinel-frame.h"
38 #include "frame-unwind.h"
42 /* Flag to control debugging. */
44 static int frame_debug
;
46 /* Flag to indicate whether backtraces should stop at main. */
48 static int backtrace_below_main
;
50 /* Return a frame uniq ID that can be used to, later, re-find the
54 get_frame_id (struct frame_info
*fi
)
69 const struct frame_id null_frame_id
; /* All zeros. */
72 frame_id_build (CORE_ADDR base
, CORE_ADDR func_or_pc
)
81 frame_id_p (struct frame_id l
)
83 /* The .func can be NULL but the .base cannot. */
88 frame_id_eq (struct frame_id l
, struct frame_id r
)
90 /* If .base is different, the frames are different. */
93 /* Add a test to check that the frame ID's are for the same function
99 frame_id_inner (struct frame_id l
, struct frame_id r
)
101 /* Only return non-zero when strictly inner than. Note that, per
102 comment in "frame.h", there is some fuzz here. Frameless
103 functions are not strictly inner than (same .base but different
105 return INNER_THAN (l
.base
, r
.base
);
109 frame_find_by_id (struct frame_id id
)
111 struct frame_info
*frame
;
113 /* ZERO denotes the null frame, let the caller decide what to do
114 about it. Should it instead return get_current_frame()? */
115 if (!frame_id_p (id
))
118 for (frame
= get_current_frame ();
120 frame
= get_prev_frame (frame
))
122 struct frame_id
this = get_frame_id (frame
);
123 if (frame_id_eq (id
, this))
124 /* An exact match. */
126 if (frame_id_inner (id
, this))
129 /* Either, we're not yet gone far enough out along the frame
130 chain (inner(this,id), or we're comparing frameless functions
131 (same .base, different .func, no test available). Struggle
132 on until we've definitly gone to far. */
138 frame_pc_unwind (struct frame_info
*this_frame
)
140 if (!this_frame
->pc_unwind_cache_p
)
143 if (gdbarch_unwind_pc_p (current_gdbarch
))
145 /* The right way. The `pure' way. The one true way. This
146 method depends solely on the register-unwind code to
147 determine the value of registers in THIS frame, and hence
148 the value of this frame's PC (resume address). A typical
149 implementation is no more than:
151 frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
152 return extract_address (buf, size of ISA_PC_REGNUM);
154 Note: this method is very heavily dependent on a correct
155 register-unwind implementation, it pays to fix that
156 method first; this method is frame type agnostic, since
157 it only deals with register values, it works with any
158 frame. This is all in stark contrast to the old
159 FRAME_SAVED_PC which would try to directly handle all the
160 different ways that a PC could be unwound. */
161 pc
= gdbarch_unwind_pc (current_gdbarch
, this_frame
);
163 else if (this_frame
->level
< 0)
165 /* FIXME: cagney/2003-03-06: Old code and and a sentinel
166 frame. Do like was always done. Fetch the PC's value
167 direct from the global registers array (via read_pc).
168 This assumes that this frame belongs to the current
169 global register cache. The assumption is dangerous. */
172 else if (FRAME_SAVED_PC_P ())
174 /* FIXME: cagney/2003-03-06: Old code, but not a sentinel
175 frame. Do like was always done. Note that this method,
176 unlike unwind_pc(), tries to handle all the different
177 frame cases directly. It fails. */
178 pc
= FRAME_SAVED_PC (this_frame
);
181 internal_error (__FILE__
, __LINE__
, "No gdbarch_unwind_pc method");
182 this_frame
->pc_unwind_cache
= pc
;
183 this_frame
->pc_unwind_cache_p
= 1;
185 return this_frame
->pc_unwind_cache
;
189 frame_pop (struct frame_info
*frame
)
191 /* FIXME: cagney/2003-01-18: There is probably a chicken-egg problem
192 with passing in current_regcache. The pop function needs to be
193 written carefully so as to not overwrite registers whose [old]
194 values are needed to restore other registers. Instead, this code
195 should pass in a scratch cache and, as a second step, restore the
196 registers using that. */
197 frame
->unwind
->pop (frame
, &frame
->unwind_cache
, current_regcache
);
198 flush_cached_frames ();
202 frame_register_unwind (struct frame_info
*frame
, int regnum
,
203 int *optimizedp
, enum lval_type
*lvalp
,
204 CORE_ADDR
*addrp
, int *realnump
, void *bufferp
)
206 struct frame_unwind_cache
*cache
;
208 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
209 that the value proper does not need to be fetched. */
210 gdb_assert (optimizedp
!= NULL
);
211 gdb_assert (lvalp
!= NULL
);
212 gdb_assert (addrp
!= NULL
);
213 gdb_assert (realnump
!= NULL
);
214 /* gdb_assert (bufferp != NULL); */
216 /* NOTE: cagney/2002-11-27: A program trying to unwind a NULL frame
217 is broken. There is always a frame. If there, for some reason,
218 isn't, there is some pretty busted code as it should have
219 detected the problem before calling here. */
220 gdb_assert (frame
!= NULL
);
222 /* Ask this frame to unwind its register. */
223 frame
->unwind
->reg (frame
, &frame
->unwind_cache
, regnum
,
224 optimizedp
, lvalp
, addrp
, realnump
, bufferp
);
228 frame_register (struct frame_info
*frame
, int regnum
,
229 int *optimizedp
, enum lval_type
*lvalp
,
230 CORE_ADDR
*addrp
, int *realnump
, void *bufferp
)
232 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
233 that the value proper does not need to be fetched. */
234 gdb_assert (optimizedp
!= NULL
);
235 gdb_assert (lvalp
!= NULL
);
236 gdb_assert (addrp
!= NULL
);
237 gdb_assert (realnump
!= NULL
);
238 /* gdb_assert (bufferp != NULL); */
240 /* Ulgh! Old code that, for lval_register, sets ADDRP to the offset
241 of the register in the register cache. It should instead return
242 the REGNUM corresponding to that register. Translate the . */
243 if (GET_SAVED_REGISTER_P ())
245 GET_SAVED_REGISTER (bufferp
, optimizedp
, addrp
, frame
, regnum
, lvalp
);
246 /* Compute the REALNUM if the caller wants it. */
247 if (*lvalp
== lval_register
)
250 for (regnum
= 0; regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
; regnum
++)
252 if (*addrp
== register_offset_hack (current_gdbarch
, regnum
))
258 internal_error (__FILE__
, __LINE__
,
259 "Failed to compute the register number corresponding"
260 " to 0x%s", paddr_d (*addrp
));
266 /* Obtain the register value by unwinding the register from the next
267 (more inner frame). */
268 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
269 frame_register_unwind (frame
->next
, regnum
, optimizedp
, lvalp
, addrp
,
274 frame_unwind_register (struct frame_info
*frame
, int regnum
, void *buf
)
280 frame_register_unwind (frame
, regnum
, &optimized
, &lval
, &addr
,
285 frame_unwind_signed_register (struct frame_info
*frame
, int regnum
,
288 void *buf
= alloca (MAX_REGISTER_RAW_SIZE
);
289 frame_unwind_register (frame
, regnum
, buf
);
290 (*val
) = extract_signed_integer (buf
, REGISTER_VIRTUAL_SIZE (regnum
));
294 frame_unwind_unsigned_register (struct frame_info
*frame
, int regnum
,
297 void *buf
= alloca (MAX_REGISTER_RAW_SIZE
);
298 frame_unwind_register (frame
, regnum
, buf
);
299 (*val
) = extract_unsigned_integer (buf
, REGISTER_VIRTUAL_SIZE (regnum
));
303 frame_read_register (struct frame_info
*frame
, int regnum
, void *buf
)
305 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
306 frame_unwind_register (frame
->next
, regnum
, buf
);
310 frame_read_unsigned_register (struct frame_info
*frame
, int regnum
,
313 /* NOTE: cagney/2002-10-31: There is a bit of dogma here - there is
314 always a frame. Both this, and the equivalent
315 frame_read_signed_register() function, can only be called with a
316 valid frame. If, for some reason, this function is called
317 without a frame then the problem isn't here, but rather in the
318 caller. It should of first created a frame and then passed that
320 /* NOTE: cagney/2002-10-31: As a side bar, keep in mind that the
321 ``current_frame'' should not be treated as a special case. While
322 ``get_next_frame (current_frame) == NULL'' currently holds, it
323 should, as far as possible, not be relied upon. In the future,
324 ``get_next_frame (current_frame)'' may instead simply return a
325 normal frame object that simply always gets register values from
326 the register cache. Consequently, frame code should try to avoid
327 tests like ``if get_next_frame() == NULL'' and instead just rely
328 on recursive frame calls (like the below code) when manipulating
330 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
331 frame_unwind_unsigned_register (frame
->next
, regnum
, val
);
335 frame_read_signed_register (struct frame_info
*frame
, int regnum
,
338 /* See note above in frame_read_unsigned_register(). */
339 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
340 frame_unwind_signed_register (frame
->next
, regnum
, val
);
344 generic_unwind_get_saved_register (char *raw_buffer
,
347 struct frame_info
*frame
,
349 enum lval_type
*lvalp
)
354 enum lval_type lvalx
;
356 if (!target_has_registers
)
357 error ("No registers.");
359 /* Keep things simple, ensure that all the pointers (except valuep)
361 if (optimizedp
== NULL
)
362 optimizedp
= &optimizedx
;
368 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
369 frame_register_unwind (frame
->next
, regnum
, optimizedp
, lvalp
, addrp
,
370 &realnumx
, raw_buffer
);
374 get_saved_register (char *raw_buffer
,
377 struct frame_info
*frame
,
379 enum lval_type
*lval
)
381 if (GET_SAVED_REGISTER_P ())
383 GET_SAVED_REGISTER (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
);
386 generic_unwind_get_saved_register (raw_buffer
, optimized
, addrp
, frame
,
390 /* frame_register_read ()
392 Find and return the value of REGNUM for the specified stack frame.
393 The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
395 Returns 0 if the register value could not be found. */
398 frame_register_read (struct frame_info
*frame
, int regnum
, void *myaddr
)
404 frame_register (frame
, regnum
, &optimized
, &lval
, &addr
, &realnum
, myaddr
);
406 /* FIXME: cagney/2002-05-15: This test, is just bogus.
408 It indicates that the target failed to supply a value for a
409 register because it was "not available" at this time. Problem
410 is, the target still has the register and so get saved_register()
411 may be returning a value saved on the stack. */
413 if (register_cached (regnum
) < 0)
414 return 0; /* register value not available */
420 /* Map between a frame register number and its name. A frame register
421 space is a superset of the cooked register space --- it also
422 includes builtin registers. */
425 frame_map_name_to_regnum (const char *name
, int len
)
432 /* Search register name space. */
433 for (i
= 0; i
< NUM_REGS
+ NUM_PSEUDO_REGS
; i
++)
434 if (REGISTER_NAME (i
) && len
== strlen (REGISTER_NAME (i
))
435 && strncmp (name
, REGISTER_NAME (i
), len
) == 0)
440 /* Try builtin registers. */
441 i
= builtin_reg_map_name_to_regnum (name
, len
);
444 /* A builtin register doesn't fall into the architecture's
446 gdb_assert (i
>= NUM_REGS
+ NUM_PSEUDO_REGS
);
454 frame_map_regnum_to_name (int regnum
)
458 if (regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
)
459 return REGISTER_NAME (regnum
);
460 return builtin_reg_map_regnum_to_name (regnum
);
463 /* Create a sentinel frame. */
466 create_sentinel_frame (struct regcache
*regcache
)
468 struct frame_info
*frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
469 frame
->type
= NORMAL_FRAME
;
471 /* Explicitly initialize the sentinel frame's cache. Provide it
472 with the underlying regcache. In the future additional
473 information, such as the frame's thread will be added. */
474 frame
->unwind_cache
= sentinel_frame_cache (regcache
);
475 /* For the moment there is only one sentinel frame implementation. */
476 frame
->unwind
= sentinel_frame_unwind
;
477 /* Link this frame back to itself. The frame is self referential
478 (the unwound PC is the same as the pc), so make it so. */
480 /* Always unwind the PC as part of creating this frame. This
481 ensures that the frame's PC points at something valid. */
482 /* FIXME: cagney/2003-01-10: Problem here. Unwinding a sentinel
483 frame's PC may require information such as the frame's thread's
484 stop reason. Is it possible to get to that? */
485 frame
->pc
= frame_pc_unwind (frame
);
489 /* Info about the innermost stack frame (contents of FP register) */
491 static struct frame_info
*current_frame
;
493 /* Cache for frame addresses already read by gdb. Valid only while
494 inferior is stopped. Control variables for the frame cache should
495 be local to this module. */
497 static struct obstack frame_cache_obstack
;
500 frame_obstack_zalloc (unsigned long size
)
502 void *data
= obstack_alloc (&frame_cache_obstack
, size
);
503 memset (data
, 0, size
);
508 frame_saved_regs_zalloc (struct frame_info
*fi
)
510 fi
->saved_regs
= (CORE_ADDR
*)
511 frame_obstack_zalloc (SIZEOF_FRAME_SAVED_REGS
);
512 return fi
->saved_regs
;
516 get_frame_saved_regs (struct frame_info
*fi
)
518 return fi
->saved_regs
;
521 /* Return the innermost (currently executing) stack frame. This is
522 split into two functions. The function unwind_to_current_frame()
523 is wrapped in catch exceptions so that, even when the unwind of the
524 sentinel frame fails, the function still returns a stack frame. */
527 unwind_to_current_frame (struct ui_out
*ui_out
, void *args
)
529 struct frame_info
*frame
= get_prev_frame (args
);
530 /* A sentinel frame can fail to unwind, eg, because it's PC value
531 lands in somewhere like start. */
534 current_frame
= frame
;
539 get_current_frame (void)
541 if (!target_has_stack
)
543 if (!target_has_registers
)
544 error ("No registers.");
545 if (!target_has_memory
)
546 error ("No memory.");
547 if (current_frame
== NULL
)
549 struct frame_info
*sentinel_frame
=
550 create_sentinel_frame (current_regcache
);
551 if (catch_exceptions (uiout
, unwind_to_current_frame
, sentinel_frame
,
552 NULL
, RETURN_MASK_ERROR
) != 0)
554 /* Oops! Fake a current frame? Is this useful? It has a PC
555 of zero, for instance. */
556 current_frame
= sentinel_frame
;
559 return current_frame
;
562 /* The "selected" stack frame is used by default for local and arg
563 access. May be zero, for no selected frame. */
565 struct frame_info
*deprecated_selected_frame
;
567 /* Return the selected frame. Always non-null (unless there isn't an
568 inferior sufficient for creating a frame) in which case an error is
572 get_selected_frame (void)
574 if (deprecated_selected_frame
== NULL
)
575 /* Hey! Don't trust this. It should really be re-finding the
576 last selected frame of the currently selected thread. This,
577 though, is better than nothing. */
578 select_frame (get_current_frame ());
579 /* There is always a frame. */
580 gdb_assert (deprecated_selected_frame
!= NULL
);
581 return deprecated_selected_frame
;
584 /* Select frame FI (or NULL - to invalidate the current frame). */
587 select_frame (struct frame_info
*fi
)
589 register struct symtab
*s
;
591 deprecated_selected_frame
= fi
;
592 /* NOTE: cagney/2002-05-04: FI can be NULL. This occures when the
593 frame is being invalidated. */
594 if (selected_frame_level_changed_hook
)
595 selected_frame_level_changed_hook (frame_relative_level (fi
));
597 /* FIXME: kseitz/2002-08-28: It would be nice to call
598 selected_frame_level_changed_event right here, but due to limitations
599 in the current interfaces, we would end up flooding UIs with events
600 because select_frame is used extensively internally.
602 Once we have frame-parameterized frame (and frame-related) commands,
603 the event notification can be moved here, since this function will only
604 be called when the users selected frame is being changed. */
606 /* Ensure that symbols for this frame are read in. Also, determine the
607 source language of this frame, and switch to it if desired. */
610 s
= find_pc_symtab (fi
->pc
);
612 && s
->language
!= current_language
->la_language
613 && s
->language
!= language_unknown
614 && language_mode
== language_mode_auto
)
616 set_language (s
->language
);
621 /* Return the register saved in the simplistic ``saved_regs'' cache.
622 If the value isn't here AND a value is needed, try the next inner
626 frame_saved_regs_register_unwind (struct frame_info
*frame
, void **cache
,
627 int regnum
, int *optimizedp
,
628 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
629 int *realnump
, void *bufferp
)
631 /* There is always a frame at this point. And THIS is the frame
632 we're interested in. */
633 gdb_assert (frame
!= NULL
);
634 /* If we're using generic dummy frames, we'd better not be in a call
635 dummy. (generic_call_dummy_register_unwind ought to have been called
637 gdb_assert (!(DEPRECATED_USE_GENERIC_DUMMY_FRAMES
638 && (get_frame_type (frame
) == DUMMY_FRAME
)));
640 /* Only (older) architectures that implement the
641 DEPRECATED_FRAME_INIT_SAVED_REGS method should be using this
643 gdb_assert (DEPRECATED_FRAME_INIT_SAVED_REGS_P ());
645 /* Load the saved_regs register cache. */
646 if (get_frame_saved_regs (frame
) == NULL
)
647 DEPRECATED_FRAME_INIT_SAVED_REGS (frame
);
649 if (get_frame_saved_regs (frame
) != NULL
650 && get_frame_saved_regs (frame
)[regnum
] != 0)
652 if (regnum
== SP_REGNUM
)
654 /* SP register treated specially. */
660 store_address (bufferp
, REGISTER_RAW_SIZE (regnum
),
661 get_frame_saved_regs (frame
)[regnum
]);
665 /* Any other register is saved in memory, fetch it but cache
666 a local copy of its value. */
668 *lvalp
= lval_memory
;
669 *addrp
= get_frame_saved_regs (frame
)[regnum
];
674 /* Save each register value, as it is read in, in a
675 frame based cache. */
676 void **regs
= (*cache
);
679 int sizeof_cache
= ((NUM_REGS
+ NUM_PSEUDO_REGS
)
681 regs
= frame_obstack_zalloc (sizeof_cache
);
684 if (regs
[regnum
] == NULL
)
687 = frame_obstack_zalloc (REGISTER_RAW_SIZE (regnum
));
688 read_memory (get_frame_saved_regs (frame
)[regnum
], regs
[regnum
],
689 REGISTER_RAW_SIZE (regnum
));
691 memcpy (bufferp
, regs
[regnum
], REGISTER_RAW_SIZE (regnum
));
693 /* Read the value in from memory. */
694 read_memory (get_frame_saved_regs (frame
)[regnum
], bufferp
,
695 REGISTER_RAW_SIZE (regnum
));
702 /* No luck, assume this and the next frame have the same register
703 value. Pass the request down the frame chain to the next frame.
704 Hopefully that will find the register's location, either in a
705 register or in memory. */
706 frame_register (frame
, regnum
, optimizedp
, lvalp
, addrp
, realnump
,
711 frame_saved_regs_id_unwind (struct frame_info
*next_frame
, void **cache
,
718 /* Start out by assuming it's NULL. */
719 (*id
) = null_frame_id
;
721 if (frame_relative_level (next_frame
) <= 0)
722 /* FIXME: 2002-11-09: Frameless functions can occure anywhere in
723 the frame chain, not just the inner most frame! The generic,
724 per-architecture, frame code should handle this and the below
725 should simply be removed. */
726 fromleaf
= FRAMELESS_FUNCTION_INVOCATION (next_frame
);
731 /* A frameless inner-most frame. The `FP' (which isn't an
732 architecture frame-pointer register!) of the caller is the same
734 /* FIXME: 2002-11-09: There isn't any reason to special case this
735 edge condition. Instead the per-architecture code should hande
737 base
= get_frame_base (next_frame
);
740 /* Two macros defined in tm.h specify the machine-dependent
741 actions to be performed here.
743 First, get the frame's chain-pointer.
745 If that is zero, the frame is the outermost frame or a leaf
746 called by the outermost frame. This means that if start
747 calls main without a frame, we'll return 0 (which is fine
750 Nope; there's a problem. This also returns when the current
751 routine is a leaf of main. This is unacceptable. We move
752 this to after the ffi test; I'd rather have backtraces from
753 start go curfluy than have an abort called from main not show
755 gdb_assert (FRAME_CHAIN_P ());
756 base
= FRAME_CHAIN (next_frame
);
758 if (!frame_chain_valid (base
, next_frame
))
764 /* FIXME: cagney/2002-06-08: This should probably return the frame's
765 function and not the PC (a.k.a. resume address). */
766 pc
= frame_pc_unwind (next_frame
);
772 frame_saved_regs_pop (struct frame_info
*fi
, void **cache
,
773 struct regcache
*regcache
)
775 gdb_assert (POP_FRAME_P ());
779 const struct frame_unwind trad_frame_unwinder
= {
780 frame_saved_regs_pop
,
781 frame_saved_regs_id_unwind
,
782 frame_saved_regs_register_unwind
784 const struct frame_unwind
*trad_frame_unwind
= &trad_frame_unwinder
;
787 /* Function: get_saved_register
788 Find register number REGNUM relative to FRAME and put its (raw,
789 target format) contents in *RAW_BUFFER.
791 Set *OPTIMIZED if the variable was optimized out (and thus can't be
792 fetched). Note that this is never set to anything other than zero
793 in this implementation.
795 Set *LVAL to lval_memory, lval_register, or not_lval, depending on
796 whether the value was fetched from memory, from a register, or in a
797 strange and non-modifiable way (e.g. a frame pointer which was
798 calculated rather than fetched). We will use not_lval for values
799 fetched from generic dummy frames.
801 Set *ADDRP to the address, either in memory or as a REGISTER_BYTE
802 offset into the registers array. If the value is stored in a dummy
803 frame, set *ADDRP to zero.
805 To use this implementation, define a function called
806 "get_saved_register" in your target code, which simply passes all
807 of its arguments to this function.
809 The argument RAW_BUFFER must point to aligned memory. */
812 deprecated_generic_get_saved_register (char *raw_buffer
, int *optimized
,
814 struct frame_info
*frame
, int regnum
,
815 enum lval_type
*lval
)
817 if (!target_has_registers
)
818 error ("No registers.");
820 gdb_assert (DEPRECATED_FRAME_INIT_SAVED_REGS_P ());
822 /* Normal systems don't optimize out things with register numbers. */
823 if (optimized
!= NULL
)
826 if (addrp
) /* default assumption: not found in memory */
829 /* Note: since the current frame's registers could only have been
830 saved by frames INTERIOR TO the current frame, we skip examining
831 the current frame itself: otherwise, we would be getting the
832 previous frame's registers which were saved by the current frame. */
836 for (frame
= get_next_frame (frame
);
837 frame_relative_level (frame
) >= 0;
838 frame
= get_next_frame (frame
))
840 if (get_frame_type (frame
) == DUMMY_FRAME
)
842 if (lval
) /* found it in a CALL_DUMMY frame */
845 /* FIXME: cagney/2002-06-26: This should be via the
846 gdbarch_register_read() method so that it, on the
847 fly, constructs either a raw or pseudo register
848 from the raw register cache. */
850 (generic_find_dummy_frame (get_frame_pc (frame
),
851 get_frame_base (frame
)),
856 DEPRECATED_FRAME_INIT_SAVED_REGS (frame
);
857 if (get_frame_saved_regs (frame
) != NULL
858 && get_frame_saved_regs (frame
)[regnum
] != 0)
860 if (lval
) /* found it saved on the stack */
862 if (regnum
== SP_REGNUM
)
864 if (raw_buffer
) /* SP register treated specially */
865 store_address (raw_buffer
, REGISTER_RAW_SIZE (regnum
),
866 get_frame_saved_regs (frame
)[regnum
]);
870 if (addrp
) /* any other register */
871 *addrp
= get_frame_saved_regs (frame
)[regnum
];
873 read_memory (get_frame_saved_regs (frame
)[regnum
], raw_buffer
,
874 REGISTER_RAW_SIZE (regnum
));
881 /* If we get thru the loop to this point, it means the register was
882 not saved in any frame. Return the actual live-register value. */
884 if (lval
) /* found it in a live register */
885 *lval
= lval_register
;
887 *addrp
= REGISTER_BYTE (regnum
);
889 deprecated_read_register_gen (regnum
, raw_buffer
);
892 /* Determine the frame's type based on its PC. */
894 static enum frame_type
895 frame_type_from_pc (CORE_ADDR pc
)
897 /* FIXME: cagney/2002-11-24: Can't yet directly call
898 pc_in_dummy_frame() as some architectures don't set
899 PC_IN_CALL_DUMMY() to generic_pc_in_call_dummy() (remember the
900 latter is implemented by simply calling pc_in_dummy_frame). */
901 if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES
902 && DEPRECATED_PC_IN_CALL_DUMMY (pc
, 0, 0))
907 find_pc_partial_function (pc
, &name
, NULL
, NULL
);
908 if (PC_IN_SIGTRAMP (pc
, name
))
909 return SIGTRAMP_FRAME
;
915 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
916 Always returns a non-NULL value. */
919 create_new_frame (CORE_ADDR addr
, CORE_ADDR pc
)
921 struct frame_info
*fi
;
923 fi
= frame_obstack_zalloc (sizeof (struct frame_info
));
927 fi
->next
= create_sentinel_frame (current_regcache
);
928 fi
->type
= frame_type_from_pc (pc
);
930 if (DEPRECATED_INIT_EXTRA_FRAME_INFO_P ())
931 DEPRECATED_INIT_EXTRA_FRAME_INFO (0, fi
);
933 /* Select/initialize an unwind function. */
934 fi
->unwind
= frame_unwind_find_by_pc (current_gdbarch
, fi
->pc
);
939 /* Return the frame that FRAME calls (NULL if FRAME is the innermost
940 frame). Be careful to not fall off the bottom of the frame chain
941 and onto the sentinel frame. */
944 get_next_frame (struct frame_info
*frame
)
946 if (frame
->level
> 0)
952 /* Flush the entire frame cache. */
955 flush_cached_frames (void)
957 /* Since we can't really be sure what the first object allocated was */
958 obstack_free (&frame_cache_obstack
, 0);
959 obstack_init (&frame_cache_obstack
);
961 current_frame
= NULL
; /* Invalidate cache */
963 annotate_frames_invalid ();
966 /* Flush the frame cache, and start a new one if necessary. */
969 reinit_frame_cache (void)
971 flush_cached_frames ();
973 /* FIXME: The inferior_ptid test is wrong if there is a corefile. */
974 if (PIDGET (inferior_ptid
) != 0)
976 select_frame (get_current_frame ());
980 /* Create the previous frame using the deprecated methods
981 INIT_EXTRA_INFO, INIT_FRAME_PC and INIT_FRAME_PC_FIRST. */
983 static struct frame_info
*
984 legacy_get_prev_frame (struct frame_info
*next_frame
)
986 CORE_ADDR address
= 0;
987 struct frame_info
*prev
;
990 /* This code only works on normal frames. A sentinel frame, where
991 the level is -1, should never reach this code. */
992 gdb_assert (next_frame
->level
>= 0);
994 /* On some machines it is possible to call a function without
995 setting up a stack frame for it. On these machines, we
996 define this macro to take two args; a frameinfo pointer
997 identifying a frame and a variable to set or clear if it is
998 or isn't leafless. */
1000 /* Still don't want to worry about this except on the innermost
1001 frame. This macro will set FROMLEAF if NEXT_FRAME is a frameless
1002 function invocation. */
1003 if (next_frame
->level
== 0)
1004 /* FIXME: 2002-11-09: Frameless functions can occure anywhere in
1005 the frame chain, not just the inner most frame! The generic,
1006 per-architecture, frame code should handle this and the below
1007 should simply be removed. */
1008 fromleaf
= FRAMELESS_FUNCTION_INVOCATION (next_frame
);
1013 /* A frameless inner-most frame. The `FP' (which isn't an
1014 architecture frame-pointer register!) of the caller is the same
1016 /* FIXME: 2002-11-09: There isn't any reason to special case this
1017 edge condition. Instead the per-architecture code should hande
1019 address
= get_frame_base (next_frame
);
1022 /* Two macros defined in tm.h specify the machine-dependent
1023 actions to be performed here.
1025 First, get the frame's chain-pointer.
1027 If that is zero, the frame is the outermost frame or a leaf
1028 called by the outermost frame. This means that if start
1029 calls main without a frame, we'll return 0 (which is fine
1032 Nope; there's a problem. This also returns when the current
1033 routine is a leaf of main. This is unacceptable. We move
1034 this to after the ffi test; I'd rather have backtraces from
1035 start go curfluy than have an abort called from main not show
1037 gdb_assert (FRAME_CHAIN_P ());
1038 address
= FRAME_CHAIN (next_frame
);
1040 if (!frame_chain_valid (address
, next_frame
))
1046 /* Create an initially zero previous frame. */
1047 prev
= frame_obstack_zalloc (sizeof (struct frame_info
));
1050 next_frame
->prev
= prev
;
1051 prev
->next
= next_frame
;
1052 prev
->frame
= address
;
1053 prev
->level
= next_frame
->level
+ 1;
1054 /* FIXME: cagney/2002-11-18: Should be setting the frame's type
1055 here, before anything else, and not last. Various INIT functions
1056 are full of work-arounds for the frames type not being set
1057 correctly from the word go. Ulgh! */
1058 prev
->type
= NORMAL_FRAME
;
1060 /* This change should not be needed, FIXME! We should determine
1061 whether any targets *need* DEPRECATED_INIT_FRAME_PC to happen
1062 after DEPRECATED_INIT_EXTRA_FRAME_INFO and come up with a simple
1063 way to express what goes on here.
1065 DEPRECATED_INIT_EXTRA_FRAME_INFO is called from two places:
1066 create_new_frame (where the PC is already set up) and here (where
1067 it isn't). DEPRECATED_INIT_FRAME_PC is only called from here,
1068 always after DEPRECATED_INIT_EXTRA_FRAME_INFO.
1070 The catch is the MIPS, where DEPRECATED_INIT_EXTRA_FRAME_INFO
1071 requires the PC value (which hasn't been set yet). Some other
1072 machines appear to require DEPRECATED_INIT_EXTRA_FRAME_INFO
1073 before they can do DEPRECATED_INIT_FRAME_PC. Phoo.
1075 We shouldn't need DEPRECATED_INIT_FRAME_PC_FIRST to add more
1076 complication to an already overcomplicated part of GDB.
1077 gnu@cygnus.com, 15Sep92.
1079 Assuming that some machines need DEPRECATED_INIT_FRAME_PC after
1080 DEPRECATED_INIT_EXTRA_FRAME_INFO, one possible scheme:
1082 SETUP_INNERMOST_FRAME(): Default version is just create_new_frame
1083 (read_fp ()), read_pc ()). Machines with extra frame info would
1084 do that (or the local equivalent) and then set the extra fields.
1086 SETUP_ARBITRARY_FRAME(argc, argv): Only change here is that
1087 create_new_frame would no longer init extra frame info;
1088 SETUP_ARBITRARY_FRAME would have to do that.
1090 INIT_PREV_FRAME(fromleaf, prev) Replace
1091 DEPRECATED_INIT_EXTRA_FRAME_INFO and DEPRECATED_INIT_FRAME_PC.
1092 This should also return a flag saying whether to keep the new
1093 frame, or whether to discard it, because on some machines (e.g.
1094 mips) it is really awkward to have FRAME_CHAIN_VALID called
1095 BEFORE DEPRECATED_INIT_EXTRA_FRAME_INFO (there is no good way to
1096 get information deduced in FRAME_CHAIN_VALID into the extra
1097 fields of the new frame). std_frame_pc(fromleaf, prev)
1099 This is the default setting for INIT_PREV_FRAME. It just does
1100 what the default DEPRECATED_INIT_FRAME_PC does. Some machines
1101 will call it from INIT_PREV_FRAME (either at the beginning, the
1102 end, or in the middle). Some machines won't use it.
1104 kingdon@cygnus.com, 13Apr93, 31Jan94, 14Dec94. */
1106 /* NOTE: cagney/2002-11-09: Just ignore the above! There is no
1107 reason for things to be this complicated.
1109 The trick is to assume that there is always a frame. Instead of
1110 special casing the inner-most frame, create fake frame
1111 (containing the hardware registers) that is inner to the
1112 user-visible inner-most frame (...) and then unwind from that.
1113 That way architecture code can use use the standard
1114 frame_XX_unwind() functions and not differentiate between the
1115 inner most and any other case.
1117 Since there is always a frame to unwind from, there is always
1118 somewhere (NEXT_FRAME) to store all the info needed to construct
1119 a new (previous) frame without having to first create it. This
1120 means that the convolution below - needing to carefully order a
1121 frame's initialization - isn't needed.
1123 The irony here though, is that FRAME_CHAIN(), at least for a more
1124 up-to-date architecture, always calls FRAME_SAVED_PC(), and
1125 FRAME_SAVED_PC() computes the PC but without first needing the
1126 frame! Instead of the convolution below, we could have simply
1127 called FRAME_SAVED_PC() and been done with it! Note that
1128 FRAME_SAVED_PC() is being superseed by frame_pc_unwind() and that
1129 function does have somewhere to cache that PC value. */
1131 if (DEPRECATED_INIT_FRAME_PC_FIRST_P ())
1132 prev
->pc
= (DEPRECATED_INIT_FRAME_PC_FIRST (fromleaf
, prev
));
1134 if (DEPRECATED_INIT_EXTRA_FRAME_INFO_P ())
1135 DEPRECATED_INIT_EXTRA_FRAME_INFO (fromleaf
, prev
);
1137 /* This entry is in the frame queue now, which is good since
1138 FRAME_SAVED_PC may use that queue to figure out its value (see
1139 tm-sparc.h). We want the pc saved in the inferior frame. */
1140 if (DEPRECATED_INIT_FRAME_PC_P ())
1141 prev
->pc
= DEPRECATED_INIT_FRAME_PC (fromleaf
, prev
);
1143 /* If ->frame and ->pc are unchanged, we are in the process of
1144 getting ourselves into an infinite backtrace. Some architectures
1145 check this in FRAME_CHAIN or thereabouts, but it seems like there
1146 is no reason this can't be an architecture-independent check. */
1147 if (prev
->frame
== next_frame
->frame
1148 && prev
->pc
== next_frame
->pc
)
1150 next_frame
->prev
= NULL
;
1151 obstack_free (&frame_cache_obstack
, prev
);
1155 /* Initialize the code used to unwind the frame PREV based on the PC
1156 (and probably other architectural information). The PC lets you
1157 check things like the debug info at that point (dwarf2cfi?) and
1158 use that to decide how the frame should be unwound. */
1159 prev
->unwind
= frame_unwind_find_by_pc (current_gdbarch
, prev
->pc
);
1161 /* NOTE: cagney/2002-11-18: The code segments, found in
1162 create_new_frame and get_prev_frame(), that initializes the
1163 frames type is subtly different. The latter only updates ->type
1164 when it encounters a SIGTRAMP_FRAME or DUMMY_FRAME. This stops
1165 get_prev_frame() overriding the frame's type when the INIT code
1166 has previously set it. This is really somewhat bogus. The
1167 initialization, as seen in create_new_frame(), should occur
1168 before the INIT function has been called. */
1169 if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES
1170 && (DEPRECATED_PC_IN_CALL_DUMMY_P ()
1171 ? DEPRECATED_PC_IN_CALL_DUMMY (prev
->pc
, 0, 0)
1172 : pc_in_dummy_frame (prev
->pc
)))
1173 prev
->type
= DUMMY_FRAME
;
1176 /* FIXME: cagney/2002-11-10: This should be moved to before the
1177 INIT code above so that the INIT code knows what the frame's
1178 type is (in fact, for a [generic] dummy-frame, the type can
1179 be set and then the entire initialization can be skipped.
1180 Unforunatly, its the INIT code that sets the PC (Hmm, catch
1183 find_pc_partial_function (prev
->pc
, &name
, NULL
, NULL
);
1184 if (PC_IN_SIGTRAMP (prev
->pc
, name
))
1185 prev
->type
= SIGTRAMP_FRAME
;
1186 /* FIXME: cagney/2002-11-11: Leave prev->type alone. Some
1187 architectures are forcing the frame's type in INIT so we
1188 don't want to override it here. Remember, NORMAL_FRAME == 0,
1189 so it all works (just :-/). Once this initialization is
1190 moved to the start of this function, all this nastness will
1197 /* Return a structure containing various interesting information
1198 about the frame that called NEXT_FRAME. Returns NULL
1199 if there is no such frame. */
1202 get_prev_frame (struct frame_info
*next_frame
)
1204 struct frame_info
*prev_frame
;
1206 /* Return the inner-most frame, when the caller passes in NULL. */
1207 /* NOTE: cagney/2002-11-09: Not sure how this would happen. The
1208 caller should have previously obtained a valid frame using
1209 get_selected_frame() and then called this code - only possibility
1210 I can think of is code behaving badly.
1212 NOTE: cagney/2003-01-10: Talk about code behaving badly. Check
1213 block_innermost_frame(). It does the sequence: frame = NULL;
1214 while (1) { frame = get_prev_frame (frame); .... }. Ulgh! Why
1215 it couldn't be written better, I don't know.
1217 NOTE: cagney/2003-01-11: I suspect what is happening is
1218 block_innermost_frame() is, when the target has no state
1219 (registers, memory, ...), still calling this function. The
1220 assumption being that this function will return NULL indicating
1221 that a frame isn't possible, rather than checking that the target
1222 has state and then calling get_current_frame() and
1223 get_prev_frame(). This is a guess mind. */
1224 if (next_frame
== NULL
)
1226 /* NOTE: cagney/2002-11-09: There was a code segment here that
1227 would error out when CURRENT_FRAME was NULL. The comment
1228 that went with it made the claim ...
1230 ``This screws value_of_variable, which just wants a nice
1231 clean NULL return from block_innermost_frame if there are no
1232 frames. I don't think I've ever seen this message happen
1233 otherwise. And returning NULL here is a perfectly legitimate
1236 Per the above, this code shouldn't even be called with a NULL
1238 return current_frame
;
1241 /* There is always a frame. If this assertion fails, suspect that
1242 something should be calling get_selected_frame() or
1243 get_current_frame(). */
1244 gdb_assert (next_frame
!= NULL
);
1246 if (next_frame
->level
>= 0
1247 && !backtrace_below_main
1248 && inside_main_func (get_frame_pc (next_frame
)))
1249 /* Don't unwind past main(), bug always unwind the sentinel frame.
1250 Note, this is done _before_ the frame has been marked as
1251 previously unwound. That way if the user later decides to
1252 allow unwinds past main(), that just happens. */
1255 fprintf_unfiltered (gdb_stdlog
,
1256 "Outermost frame - inside main func.\n");
1260 /* Only try to do the unwind once. */
1261 if (next_frame
->prev_p
)
1262 return next_frame
->prev
;
1263 next_frame
->prev_p
= 1;
1265 /* If we're inside the entry file, it isn't valid. Don't apply this
1266 test to a dummy frame - dummy frame PC's typically land in the
1267 entry file. Don't apply this test to the sentinel frame.
1268 Sentinel frames should always be allowed to unwind. */
1269 /* NOTE: drow/2002-12-25: should there be a way to disable this
1270 check? It assumes a single small entry file, and the way some
1271 debug readers (e.g. dbxread) figure out which object is the
1272 entry file is somewhat hokey. */
1273 /* NOTE: cagney/2003-01-10: If there is a way of disabling this test
1274 then it should probably be moved to before the ->prev_p test,
1276 if (next_frame
->type
!= DUMMY_FRAME
&& next_frame
->level
>= 0
1277 && inside_entry_file (get_frame_pc (next_frame
)))
1280 fprintf_unfiltered (gdb_stdlog
,
1281 "Outermost frame - inside entry file\n");
1285 /* If we're already inside the entry function for the main objfile,
1286 then it isn't valid. Don't apply this test to a dummy frame -
1287 dummy frame PC's typically land in the entry func. Don't apply
1288 this test to the sentinel frame. Sentinel frames should always
1289 be allowed to unwind. */
1290 /* NOTE: cagney/2003-02-25: Don't enable until someone has found
1291 hard evidence that this is needed. */
1293 && next_frame
->type
!= DUMMY_FRAME
&& next_frame
->level
>= 0
1294 && inside_entry_func (get_frame_pc (next_frame
)))
1297 fprintf_unfiltered (gdb_stdlog
,
1298 "Outermost frame - inside entry func\n");
1302 /* If any of the old frame initialization methods are around, use
1303 the legacy get_prev_frame method. Just don't try to unwind a
1304 sentinel frame using that method - it doesn't work. All sentinal
1305 frames use the new unwind code. */
1306 if ((DEPRECATED_INIT_FRAME_PC_P ()
1307 || DEPRECATED_INIT_FRAME_PC_FIRST_P ()
1308 || DEPRECATED_INIT_EXTRA_FRAME_INFO_P ()
1309 || FRAME_CHAIN_P ())
1310 && next_frame
->level
>= 0)
1312 prev_frame
= legacy_get_prev_frame (next_frame
);
1313 if (frame_debug
&& prev_frame
== NULL
)
1314 fprintf_unfiltered (gdb_stdlog
,
1315 "Outermost frame - legacy_get_prev_frame NULL.\n");
1319 /* Allocate the new frame but do not wire it in to the frame chain.
1320 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
1321 frame->next to pull some fancy tricks (of course such code is, by
1322 definition, recursive). Try to prevent it.
1324 There is no reason to worry about memory leaks, should the
1325 remainder of the function fail. The allocated memory will be
1326 quickly reclaimed when the frame cache is flushed, and the `we've
1327 been here before' check above will stop repeated memory
1328 allocation calls. */
1329 prev_frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1330 prev_frame
->level
= next_frame
->level
+ 1;
1332 /* Try to unwind the PC. If that doesn't work, assume we've reached
1333 the oldest frame and simply return. Is there a better sentinal
1334 value? The unwound PC value is then used to initialize the new
1335 previous frame's type.
1337 Note that the pc-unwind is intentionally performed before the
1338 frame chain. This is ok since, for old targets, both
1339 frame_pc_unwind (nee, FRAME_SAVED_PC) and FRAME_CHAIN()) assume
1340 NEXT_FRAME's data structures have already been initialized (using
1341 DEPRECATED_INIT_EXTRA_FRAME_INFO) and hence the call order
1344 By unwinding the PC first, it becomes possible to, in the case of
1345 a dummy frame, avoid also unwinding the frame ID. This is
1346 because (well ignoring the PPC) a dummy frame can be located
1347 using NEXT_FRAME's frame ID. */
1349 prev_frame
->pc
= frame_pc_unwind (next_frame
);
1350 if (prev_frame
->pc
== 0)
1352 /* The allocated PREV_FRAME will be reclaimed when the frame
1353 obstack is next purged. */
1355 fprintf_unfiltered (gdb_stdlog
,
1356 "Outermost frame - unwound PC zero\n");
1359 prev_frame
->type
= frame_type_from_pc (prev_frame
->pc
);
1361 /* Set the unwind functions based on that identified PC. */
1362 prev_frame
->unwind
= frame_unwind_find_by_pc (current_gdbarch
,
1365 /* Find the prev's frame's ID. */
1366 switch (prev_frame
->type
)
1369 /* When unwinding a normal frame, the stack structure is
1370 determined by analyzing the frame's function's code (be it
1371 using brute force prologue analysis, or the dwarf2 CFI). In
1372 the case of a dummy frame, that simply isn't possible. The
1373 The PC is either the program entry point, or some random
1374 address on the stack. Trying to use that PC to apply
1375 standard frame ID unwind techniques is just asking for
1377 if (gdbarch_unwind_dummy_id_p (current_gdbarch
))
1379 /* Assume hand_function_call(), via SAVE_DUMMY_FRAME_TOS,
1380 previously saved the dummy frame's ID. Things only work
1381 if the two return the same value. */
1382 gdb_assert (SAVE_DUMMY_FRAME_TOS_P ());
1383 /* Use an architecture specific method to extract the prev's
1384 dummy ID from the next frame. Note that this method uses
1385 frame_register_unwind to obtain the register values
1386 needed to determine the dummy frame's ID. */
1387 prev_frame
->id
= gdbarch_unwind_dummy_id (current_gdbarch
,
1390 else if (next_frame
->level
< 0)
1392 /* We're unwinding a sentinel frame, the PC of which is
1393 pointing at a stack dummy. Fake up the dummy frame's ID
1394 using the same sequence as is found a traditional
1395 unwinder. Once all architectures supply the
1396 unwind_dummy_id method, this code can go away. */
1397 prev_frame
->id
.base
= read_fp ();
1398 prev_frame
->id
.pc
= read_pc ();
1402 /* Outch! We're not on the innermost frame yet we're trying
1403 to unwind to a dummy. The architecture must provide the
1404 unwind_dummy_id() method. Abandon the unwind process but
1405 only after first warning the user. */
1406 internal_warning (__FILE__
, __LINE__
,
1407 "Missing unwind_dummy_id architecture method");
1412 case SIGTRAMP_FRAME
:
1413 /* FIXME: cagney/2003-03-04: The below call isn't right. It
1414 should instead be doing something like "prev_frame -> unwind
1415 -> id (next_frame, & prev_frame -> unwind_cache, & prev_frame
1416 -> id)" but that requires more extensive (pending) changes. */
1417 next_frame
->unwind
->id (next_frame
, &next_frame
->unwind_cache
,
1419 /* Check that the unwound ID is valid. */
1420 if (!frame_id_p (prev_frame
->id
))
1423 fprintf_unfiltered (gdb_stdlog
,
1424 "Outermost frame - unwound frame ID invalid\n");
1427 /* Check that the new frame isn't inner to (younger, below,
1428 next) the old frame. If that happens the frame unwind is
1430 /* FIXME: cagney/2003-02-25: Ignore the sentinel frame since
1431 that doesn't have a valid frame ID. Should instead set the
1432 sentinel frame's frame ID to a `sentinel'. Leave it until
1433 after the switch to storing the frame ID, instead of the
1434 frame base, in the frame object. */
1435 if (next_frame
->level
>= 0
1436 && frame_id_inner (prev_frame
->id
, get_frame_id (next_frame
)))
1437 error ("Unwound frame inner-to selected frame (corrupt stack?)");
1438 /* Note that, due to frameless functions, the stronger test of
1439 the new frame being outer to the old frame can't be used -
1440 frameless functions differ by only their PC value. */
1443 internal_error (__FILE__
, __LINE__
, "bad switch");
1446 /* FIXME: cagney/2002-12-18: Instead of this hack, should only store
1447 the frame ID in PREV_FRAME. Unfortunatly, some architectures
1448 (HP/UX) still reply on EXTRA_FRAME_INFO and, hence, still poke at
1449 the "struct frame_info" object directly. */
1450 prev_frame
->frame
= prev_frame
->id
.base
;
1453 next_frame
->prev
= prev_frame
;
1454 prev_frame
->next
= next_frame
;
1456 /* FIXME: cagney/2002-01-19: This call will go away. Instead of
1457 initializing extra info, all frames will use the frame_cache
1458 (passed to the unwind functions) to store additional frame info.
1459 Unfortunatly legacy targets can't use legacy_get_prev_frame() to
1460 unwind the sentinel frame and, consequently, are forced to take
1461 this code path and rely on the below call to
1462 DEPRECATED_INIT_EXTRA_FRAME_INFO to initialize the inner-most
1464 if (DEPRECATED_INIT_EXTRA_FRAME_INFO_P ())
1466 gdb_assert (prev_frame
->level
== 0);
1467 DEPRECATED_INIT_EXTRA_FRAME_INFO (0, prev_frame
);
1474 get_frame_pc (struct frame_info
*frame
)
1480 pc_notcurrent (struct frame_info
*frame
)
1482 /* If FRAME is not the innermost frame, that normally means that
1483 FRAME->pc points at the return instruction (which is *after* the
1484 call instruction), and we want to get the line containing the
1485 call (because the call is where the user thinks the program is).
1486 However, if the next frame is either a SIGTRAMP_FRAME or a
1487 DUMMY_FRAME, then the next frame will contain a saved interrupt
1488 PC and such a PC indicates the current (rather than next)
1489 instruction/line, consequently, for such cases, want to get the
1490 line containing fi->pc. */
1491 struct frame_info
*next
= get_next_frame (frame
);
1492 int notcurrent
= (next
!= NULL
&& get_frame_type (next
) == NORMAL_FRAME
);
1497 find_frame_sal (struct frame_info
*frame
, struct symtab_and_line
*sal
)
1499 (*sal
) = find_pc_line (frame
->pc
, pc_notcurrent (frame
));
1502 /* Per "frame.h", return the ``address'' of the frame. Code should
1503 really be using get_frame_id(). */
1505 get_frame_base (struct frame_info
*fi
)
1510 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
1511 or -1 for a NULL frame. */
1514 frame_relative_level (struct frame_info
*fi
)
1523 get_frame_type (struct frame_info
*frame
)
1525 /* Some targets still don't use [generic] dummy frames. Catch them
1527 if (!DEPRECATED_USE_GENERIC_DUMMY_FRAMES
1528 && deprecated_frame_in_dummy (frame
))
1534 deprecated_set_frame_type (struct frame_info
*frame
, enum frame_type type
)
1536 /* Arrrg! See comment in "frame.h". */
1540 #ifdef FRAME_FIND_SAVED_REGS
1541 /* XXX - deprecated. This is a compatibility function for targets
1542 that do not yet implement DEPRECATED_FRAME_INIT_SAVED_REGS. */
1543 /* Find the addresses in which registers are saved in FRAME. */
1546 deprecated_get_frame_saved_regs (struct frame_info
*frame
,
1547 struct frame_saved_regs
*saved_regs_addr
)
1549 if (frame
->saved_regs
== NULL
)
1551 frame
->saved_regs
= (CORE_ADDR
*)
1552 frame_obstack_zalloc (SIZEOF_FRAME_SAVED_REGS
);
1554 if (saved_regs_addr
== NULL
)
1556 struct frame_saved_regs saved_regs
;
1557 FRAME_FIND_SAVED_REGS (frame
, saved_regs
);
1558 memcpy (frame
->saved_regs
, &saved_regs
, SIZEOF_FRAME_SAVED_REGS
);
1562 FRAME_FIND_SAVED_REGS (frame
, *saved_regs_addr
);
1563 memcpy (frame
->saved_regs
, saved_regs_addr
, SIZEOF_FRAME_SAVED_REGS
);
1568 struct frame_extra_info
*
1569 get_frame_extra_info (struct frame_info
*fi
)
1571 return fi
->extra_info
;
1574 struct frame_extra_info
*
1575 frame_extra_info_zalloc (struct frame_info
*fi
, long size
)
1577 fi
->extra_info
= frame_obstack_zalloc (size
);
1578 return fi
->extra_info
;
1582 deprecated_update_frame_pc_hack (struct frame_info
*frame
, CORE_ADDR pc
)
1584 /* See comment in "frame.h". */
1586 /* While we're at it, update this frame's cached PC value, found in
1587 the next frame. Oh, for the day when "struct frame_info" is
1588 opaque and this hack on hack can go. */
1589 gdb_assert (frame
->next
!= NULL
);
1590 frame
->next
->pc_unwind_cache
= pc
;
1591 frame
->next
->pc_unwind_cache_p
= 1;
1595 deprecated_update_frame_base_hack (struct frame_info
*frame
, CORE_ADDR base
)
1597 /* See comment in "frame.h". */
1598 frame
->frame
= base
;
1602 deprecated_set_frame_saved_regs_hack (struct frame_info
*frame
,
1603 CORE_ADDR
*saved_regs
)
1605 frame
->saved_regs
= saved_regs
;
1609 deprecated_set_frame_extra_info_hack (struct frame_info
*frame
,
1610 struct frame_extra_info
*extra_info
)
1612 frame
->extra_info
= extra_info
;
1616 deprecated_set_frame_next_hack (struct frame_info
*fi
,
1617 struct frame_info
*next
)
1623 deprecated_set_frame_prev_hack (struct frame_info
*fi
,
1624 struct frame_info
*prev
)
1630 deprecated_get_frame_context (struct frame_info
*fi
)
1636 deprecated_set_frame_context (struct frame_info
*fi
,
1637 struct context
*context
)
1639 fi
->context
= context
;
1643 deprecated_frame_xmalloc (void)
1645 struct frame_info
*frame
= XMALLOC (struct frame_info
);
1646 memset (frame
, 0, sizeof (struct frame_info
));
1651 deprecated_frame_xmalloc_with_cleanup (long sizeof_saved_regs
,
1652 long sizeof_extra_info
)
1654 struct frame_info
*frame
= deprecated_frame_xmalloc ();
1655 make_cleanup (xfree
, frame
);
1656 if (sizeof_saved_regs
> 0)
1658 frame
->saved_regs
= xcalloc (1, sizeof_saved_regs
);
1659 make_cleanup (xfree
, frame
->saved_regs
);
1661 if (sizeof_extra_info
> 0)
1663 frame
->extra_info
= xcalloc (1, sizeof_extra_info
);
1664 make_cleanup (xfree
, frame
->extra_info
);
1670 _initialize_frame (void)
1672 obstack_init (&frame_cache_obstack
);
1674 /* FIXME: cagney/2003-01-19: This command needs a rename. Suggest
1675 `set backtrace {past,beyond,...}-main'. Also suggest adding `set
1676 backtrace ...-start' to control backtraces past start. The
1677 problem with `below' is that it stops the `up' command. */
1679 add_setshow_boolean_cmd ("backtrace-below-main", class_obscure
,
1680 &backtrace_below_main
, "\
1681 Set whether backtraces should continue past \"main\".\n\
1682 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
1683 the backtrace at \"main\". Set this variable if you need to see the rest\n\
1684 of the stack trace.", "\
1685 Show whether backtraces should continue past \"main\".\n\
1686 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
1687 the backtrace at \"main\". Set this variable if you need to see the rest\n\
1688 of the stack trace.",
1689 NULL
, NULL
, &setlist
, &showlist
);
1692 /* Debug this files internals. */
1693 add_show_from_set (add_set_cmd ("frame", class_maintenance
, var_zinteger
,
1694 &frame_debug
, "Set frame debugging.\n\
1695 When non-zero, frame specific internal debugging is enabled.", &setdebuglist
),