1 /* Definitions for dealing with stack frames, for GDB, the GNU debugger.
3 Copyright 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1996,
4 1997, 1998, 1999, 2000, 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. */
23 #if !defined (FRAME_H)
26 struct symtab_and_line
;
32 /* A legacy unwinder to prop up architectures using the old style
34 extern const struct frame_unwind
*legacy_saved_regs_unwind
;
36 /* The frame object. */
40 /* The frame object's ID. This provides a per-frame unique identifier
41 that can be used to relocate a `struct frame_info' after a target
42 resume or a frame cache destruct. It of course assumes that the
43 inferior hasn't unwound the stack past that frame. */
47 /* The frame's stack address. This shall be constant through out
48 the lifetime of a frame. Note that this requirement applies to
49 not just the function body, but also the prologue and (in theory
50 at least) the epilogue. Since that value needs to fall either on
51 the boundary, or within the frame's address range, the frame's
52 outer-most address (the inner-most address of the previous frame)
53 is used. Watch out for all the legacy targets that still use the
54 function pointer register or stack pointer register. They are
56 /* NOTE: cagney/2002-11-16: The ia64 has two stacks and hence two
57 frame bases. This will need to be expanded to accomodate that. */
59 /* The frame's code address. This shall be constant through out the
60 lifetime of the frame. While the PC (a.k.a. resume address)
61 changes as the function is executed, this code address cannot.
62 Typically, it is set to the address of the entry point of the
63 frame's function (as returned by frame_func_unwind(). */
67 /* Methods for constructing and comparing Frame IDs.
69 NOTE: Given frameless functions A and B, where A calls B (and hence
70 B is inner-to A). The relationships: !eq(A,B); !eq(B,A);
71 !inner(A,B); !inner(B,A); all hold. This is because, while B is
72 inner to A, B is not strictly inner to A (being frameless, they
73 have the same .base value). */
75 /* For convenience. All fields are zero. */
76 extern const struct frame_id null_frame_id
;
78 /* Construct a frame ID. The first parameter is the frame's constant
79 stack address (typically the outer-bound), and the second the
80 frame's constant code address (typically the entry point) (or zero,
81 to indicate a wild card). */
82 extern struct frame_id
frame_id_build (CORE_ADDR stack_addr
,
85 /* Returns non-zero when L is a valid frame (a valid frame has a
87 extern int frame_id_p (struct frame_id l
);
89 /* Returns non-zero when L and R identify the same frame, or, if
90 either L or R have a zero .func, then the same frame base. */
91 extern int frame_id_eq (struct frame_id l
, struct frame_id r
);
93 /* Returns non-zero when L is strictly inner-than R (they have
94 different frame .bases). Neither L, nor R can be `null'. See note
95 above about frameless functions. */
96 extern int frame_id_inner (struct frame_id l
, struct frame_id r
);
99 /* For every stopped thread, GDB tracks two frames: current and
100 selected. Current frame is the inner most frame of the selected
101 thread. Selected frame is the one being examined by the the GDB
102 CLI (selected using `up', `down', ...). The frames are created
103 on-demand (via get_prev_frame()) and then held in a frame cache. */
104 /* FIXME: cagney/2002-11-28: Er, there is a lie here. If you do the
105 sequence: `thread 1; up; thread 2; thread 1' you loose thread 1's
106 selected frame. At present GDB only tracks the selected frame of
107 the current thread. But be warned, that might change. */
108 /* FIXME: cagney/2002-11-14: At any time, only one thread's selected
109 and current frame can be active. Switching threads causes gdb to
110 discard all that cached frame information. Ulgh! Instead, current
111 and selected frame should be bound to a thread. */
113 /* On demand, create the inner most frame using information found in
114 the inferior. If the inner most frame can't be created, throw an
116 extern struct frame_info
*get_current_frame (void);
118 /* Invalidates the frame cache (this function should have been called
119 invalidate_cached_frames).
121 FIXME: cagney/2002-11-28: The only difference between
122 flush_cached_frames() and reinit_frame_cache() is that the latter
123 explicitly sets the selected frame back to the current frame there
124 isn't any real difference (except that one delays the selection of
125 a new frame). Code can instead simply rely on get_selected_frame()
126 to reinit's the selected frame as needed. As for invalidating the
127 cache, there should be two methods one that reverts the thread's
128 selected frame back to current frame (for when the inferior
129 resumes) and one that does not (for when the user modifies the
130 target invalidating the frame cache). */
131 extern void flush_cached_frames (void);
132 extern void reinit_frame_cache (void);
134 /* On demand, create the selected frame and then return it. If the
135 selected frame can not be created, this function throws an error. */
136 /* FIXME: cagney/2002-11-28: At present, when there is no selected
137 frame, this function always returns the current (inner most) frame.
138 It should instead, when a thread has previously had its frame
139 selected (but not resumed) and the frame cache invalidated, find
140 and then return that thread's previously selected frame. */
141 extern struct frame_info
*get_selected_frame (void);
143 /* Select a specific frame. NULL, apparently implies re-select the
145 extern void select_frame (struct frame_info
*);
147 /* Given a FRAME, return the next (more inner, younger) or previous
148 (more outer, older) frame. */
149 extern struct frame_info
*get_prev_frame (struct frame_info
*);
150 extern struct frame_info
*get_next_frame (struct frame_info
*);
152 /* Given a frame's ID, relocate the frame. Returns NULL if the frame
154 extern struct frame_info
*frame_find_by_id (struct frame_id id
);
156 /* Base attributes of a frame: */
158 /* The frame's `resume' address. Where the program will resume in
160 extern CORE_ADDR
get_frame_pc (struct frame_info
*);
162 /* Following on from the `resume' address. Return the entry point
163 address of the function containing that resume address, or zero if
164 that function isn't known. */
165 extern CORE_ADDR
frame_func_unwind (struct frame_info
*fi
);
166 extern CORE_ADDR
get_frame_func (struct frame_info
*fi
);
168 /* Closely related to the resume address, various symbol table
169 attributes that are determined by the PC. Note that for a normal
170 frame, the PC refers to the resume address after the return, and
171 not the call instruction. In such a case, the address is adjusted
172 so that it (approximatly) identifies the call site (and not return
175 NOTE: cagney/2002-11-28: The frame cache could be used to cache the
176 computed value. Working on the assumption that the bottle-neck is
177 in the single step code, and that code causes the frame cache to be
178 constantly flushed, caching things in a frame is probably of little
179 benefit. As they say `show us the numbers'.
181 NOTE: cagney/2002-11-28: Plenty more where this one came from:
182 find_frame_block(), find_frame_partial_function(),
183 find_frame_symtab(), find_frame_function(). Each will need to be
184 carefully considered to determine if the real intent was for it to
185 apply to the PC or the adjusted PC. */
186 extern void find_frame_sal (struct frame_info
*frame
,
187 struct symtab_and_line
*sal
);
189 /* Return the frame base (what ever that is) (DEPRECATED).
191 Old code was trying to use this single method for two conflicting
192 purposes. Such code needs to be updated to use either of:
194 get_frame_id: A low level frame unique identifier, that consists of
195 both a stack and a function address, that can be used to uniquely
196 identify a frame. This value is determined by the frame's
197 low-level unwinder, the stack part [typically] being the
198 top-of-stack of the previous frame, and the function part being the
199 function's start address. Since the correct identification of a
200 frameless function requires both the a stack and function address,
201 the old get_frame_base method was not sufficient.
203 get_frame_base_address: get_frame_locals_address:
204 get_frame_args_address: A set of high-level debug-info dependant
205 addresses that fall within the frame. These addresses almost
206 certainly will not match the stack address part of a frame ID (as
207 returned by get_frame_base). */
209 extern CORE_ADDR
get_frame_base (struct frame_info
*);
211 /* Return the per-frame unique identifer. Can be used to relocate a
212 frame after a frame cache flush (and other similar operations). If
213 FI is NULL, return the null_frame_id. */
214 extern struct frame_id
get_frame_id (struct frame_info
*fi
);
216 /* Assuming that a frame is `normal', return its base-address, or 0 if
217 the information isn't available. NOTE: This address is really only
218 meaningful to the frame's high-level debug info. */
219 extern CORE_ADDR
get_frame_base_address (struct frame_info
*);
221 /* Assuming that a frame is `normal', return the base-address of the
222 local variables, or 0 if the information isn't available. NOTE:
223 This address is really only meaningful to the frame's high-level
224 debug info. Typically, the argument and locals share a single
226 extern CORE_ADDR
get_frame_locals_address (struct frame_info
*);
228 /* Assuming that a frame is `normal', return the base-address of the
229 parameter list, or 0 if that information isn't available. NOTE:
230 This address is really only meaningful to the frame's high-level
231 debug info. Typically, the argument and locals share a single
233 extern CORE_ADDR
get_frame_args_address (struct frame_info
*);
235 /* The frame's level: 0 for innermost, 1 for its caller, ...; or -1
236 for an invalid frame). */
237 extern int frame_relative_level (struct frame_info
*fi
);
239 /* Return the frame's type. Some are real, some are signal
240 trampolines, and some are completly artificial (dummy). */
244 /* The frame's type hasn't yet been defined. This is a catch-all
245 for legacy code that uses really strange technicques, such as
246 deprecated_set_frame_type, to set the frame's type. New code
247 should not use this value. */
249 /* A true stack frame, created by the target program during normal
252 /* A fake frame, created by GDB when performing an inferior function
255 /* In a signal handler, various OSs handle this in various ways.
256 The main thing is that the frame may be far from normal. */
259 extern enum frame_type
get_frame_type (struct frame_info
*);
261 /* FIXME: cagney/2002-11-10: Some targets want to directly mark a
262 frame as being of a specific type. This shouldn't be necessary.
263 PC_IN_SIGTRAMP() indicates a SIGTRAMP_FRAME and
264 DEPRECATED_PC_IN_CALL_DUMMY() indicates a DUMMY_FRAME. I suspect
265 the real problem here is that get_prev_frame() only sets
266 initialized after DEPRECATED_INIT_EXTRA_FRAME_INFO as been called.
267 Consequently, some targets found that the frame's type was wrong
268 and tried to fix it. The correct fix is to modify get_prev_frame()
269 so that it initializes the frame's type before calling any other
271 extern void deprecated_set_frame_type (struct frame_info
*,
272 enum frame_type type
);
274 /* Unwind the stack frame so that the value of REGNUM, in the previous
275 (up, older) frame is returned. If VALUEP is NULL, don't
276 fetch/compute the value. Instead just return the location of the
278 extern void frame_register_unwind (struct frame_info
*frame
, int regnum
,
279 int *optimizedp
, enum lval_type
*lvalp
,
280 CORE_ADDR
*addrp
, int *realnump
,
283 /* More convenient interface to frame_register_unwind(). */
284 /* NOTE: cagney/2002-09-13: Return void as one day these functions may
285 be changed to return an indication that the read succeeded. */
287 extern void frame_unwind_register (struct frame_info
*frame
,
288 int regnum
, void *buf
);
290 extern void frame_unwind_signed_register (struct frame_info
*frame
,
291 int regnum
, LONGEST
*val
);
293 extern void frame_unwind_unsigned_register (struct frame_info
*frame
,
294 int regnum
, ULONGEST
*val
);
296 /* Get the value of the register that belongs to this FRAME. This
297 function is a wrapper to the call sequence ``frame_unwind_register
298 (get_next_frame (FRAME))''. As per frame_register_unwind(), if
299 VALUEP is NULL, the registers value is not fetched/computed. */
301 extern void frame_register (struct frame_info
*frame
, int regnum
,
302 int *optimizedp
, enum lval_type
*lvalp
,
303 CORE_ADDR
*addrp
, int *realnump
,
306 /* More convenient interface to frame_register(). */
307 /* NOTE: cagney/2002-09-13: Return void as one day these functions may
308 be changed to return an indication that the read succeeded. */
310 extern void frame_read_register (struct frame_info
*frame
, int regnum
,
313 extern void frame_read_signed_register (struct frame_info
*frame
,
314 int regnum
, LONGEST
*val
);
316 extern void frame_read_unsigned_register (struct frame_info
*frame
,
317 int regnum
, ULONGEST
*val
);
319 /* Map between a frame register number and its name. A frame register
320 space is a superset of the cooked register space --- it also
321 includes builtin registers. If NAMELEN is negative, use the NAME's
322 length when doing the comparison. */
324 extern int frame_map_name_to_regnum (const char *name
, int namelen
);
325 extern const char *frame_map_regnum_to_name (int regnum
);
327 /* Unwind the PC. Strictly speaking return the resume address of the
328 calling frame. For GDB, `pc' is the resume address and not a
329 specific register. */
331 extern CORE_ADDR
frame_pc_unwind (struct frame_info
*frame
);
333 /* Discard the specified frame. Restoring the registers to the state
335 extern void frame_pop (struct frame_info
*frame
);
337 /* We keep a cache of stack frames, each of which is a "struct
338 frame_info". The innermost one gets allocated (in
339 wait_for_inferior) each time the inferior stops; current_frame
340 points to it. Additional frames get allocated (in
341 get_prev_frame) as needed, and are chained through the next
342 and prev fields. Any time that the frame cache becomes invalid
343 (most notably when we execute something, but also if we change how
344 we interpret the frames (e.g. "set heuristic-fence-post" in
345 mips-tdep.c, or anything which reads new symbols)), we should call
346 reinit_frame_cache. */
350 /* Level of this frame. The inner-most (youngest) frame is at
351 level 0. As you move towards the outer-most (oldest) frame,
352 the level increases. This is a cached value. It could just as
353 easily be computed by counting back from the selected frame to
354 the inner most frame. */
355 /* NOTE: cagney/2002-04-05: Perhaphs a level of ``-1'' should be
356 reserved to indicate a bogus frame - one that has been created
357 just to keep GDB happy (GDB always needs a frame). For the
358 moment leave this as speculation. */
361 /* The frame's type. */
362 /* FIXME: cagney/2003-04-02: Should instead be returning
363 ->unwind->type. Unfortunatly, legacy code is still explicitly
364 setting the type using the method deprecated_set_frame_type.
365 Eliminate that method and this field can be eliminated. */
366 enum frame_type type
;
368 /* For each register, address of where it was saved on entry to
369 the frame, or zero if it was not saved on entry to this frame.
370 This includes special registers such as pc and fp saved in
371 special ways in the stack frame. The SP_REGNUM is even more
372 special, the address here is the sp for the previous frame, not
373 the address where the sp was saved. */
374 /* Allocated by frame_saved_regs_zalloc () which is called /
375 initialized by DEPRECATED_FRAME_INIT_SAVED_REGS(). */
376 CORE_ADDR
*saved_regs
; /*NUM_REGS + NUM_PSEUDO_REGS*/
378 /* Anything extra for this structure that may have been defined
379 in the machine dependent files. */
380 /* Allocated by frame_extra_info_zalloc () which is called /
381 initialized by DEPRECATED_INIT_EXTRA_FRAME_INFO */
382 struct frame_extra_info
*extra_info
;
384 /* If dwarf2 unwind frame informations is used, this structure holds all
385 related unwind data. */
386 struct context
*context
;
388 /* The frame's low-level unwinder and corresponding cache. The
389 low-level unwinder is responsible for unwinding register values
390 for the previous frame. The low-level unwind methods are
391 selected based on the presence, or otherwize, of register
392 unwind information such as CFI. */
393 void *prologue_cache
;
394 const struct frame_unwind
*unwind
;
396 /* Cached copy of the previous frame's resume address. */
402 /* Cached copy of the previous frame's function address. */
409 /* This frame's ID. */
413 struct frame_id value
;
416 /* The frame's high-level base methods, and corresponding cache.
417 The high level base methods are selected based on the frame's
419 const struct frame_base
*base
;
422 /* Pointers to the next (down, inner, younger) and previous (up,
423 outer, older) frame_info's in the frame cache. */
424 struct frame_info
*next
; /* down, inner, younger */
426 struct frame_info
*prev
; /* up, outer, older */
429 /* Values for the source flag to be used in print_frame_info_base(). */
432 /* Print only the source line, like in stepi. */
434 /* Print only the location, i.e. level, address (sometimes)
435 function, args, file, line, line num. */
437 /* Print both of the above. */
439 /* Print location only, but always include the address. */
443 /* Allocate additional space for appendices to a struct frame_info.
444 NOTE: Much of GDB's code works on the assumption that the allocated
445 saved_regs[] array is the size specified below. If you try to make
446 that array smaller, GDB will happily walk off its end. */
448 #ifdef SIZEOF_FRAME_SAVED_REGS
449 #error "SIZEOF_FRAME_SAVED_REGS can not be re-defined"
451 #define SIZEOF_FRAME_SAVED_REGS \
452 (sizeof (CORE_ADDR) * (NUM_REGS+NUM_PSEUDO_REGS))
454 /* Allocate zero initialized memory from the frame cache obstack.
455 Appendices to the frame info (such as the unwind cache) should
456 allocate memory using this method. */
458 extern void *frame_obstack_zalloc (unsigned long size
);
459 #define FRAME_OBSTACK_ZALLOC(TYPE) ((TYPE *) frame_obstack_zalloc (sizeof (TYPE)))
461 /* If legacy_frame_chain_valid() returns zero it means that the given
462 frame is the outermost one and has no caller.
464 This method has been superseeded by the per-architecture
465 frame_unwind_pc() (returns 0 to indicate an invalid return address)
466 and per-frame this_id() (returns a NULL frame ID to indicate an
468 extern int legacy_frame_chain_valid (CORE_ADDR
, struct frame_info
*);
470 extern void generic_save_dummy_frame_tos (CORE_ADDR sp
);
472 extern struct block
*get_frame_block (struct frame_info
*,
473 CORE_ADDR
*addr_in_block
);
475 /* Return the `struct block' that belongs to the selected thread's
476 selected frame. If the inferior has no state, return NULL.
478 NOTE: cagney/2002-11-29:
480 No state? Does the inferior have any execution state (a core file
481 does, an executable does not). At present the code tests
482 `target_has_stack' but I'm left wondering if it should test
483 `target_has_registers' or, even, a merged target_has_state.
485 Should it look at the most recently specified SAL? If the target
486 has no state, should this function try to extract a block from the
487 most recently selected SAL? That way `list foo' would give it some
488 sort of reference point. Then again, perhaphs that would confuse
491 Calls to this function can be broken down into two categories: Code
492 that uses the selected block as an additional, but optional, data
493 point; Code that uses the selected block as a prop, when it should
494 have the relevant frame/block/pc explicitly passed in.
496 The latter can be eliminated by correctly parameterizing the code,
497 the former though is more interesting. Per the "address" command,
498 it occures in the CLI code and makes it possible for commands to
499 work, even when the inferior has no state. */
501 extern struct block
*get_selected_block (CORE_ADDR
*addr_in_block
);
503 extern struct symbol
*get_frame_function (struct frame_info
*);
505 extern CORE_ADDR
frame_address_in_block (struct frame_info
*);
507 extern CORE_ADDR
get_pc_function_start (CORE_ADDR
);
509 extern int frameless_look_for_prologue (struct frame_info
*);
511 extern void print_frame_args (struct symbol
*, struct frame_info
*,
512 int, struct ui_file
*);
514 extern struct frame_info
*find_relative_frame (struct frame_info
*, int *);
516 extern void show_and_print_stack_frame (struct frame_info
*fi
, int level
,
519 extern void print_stack_frame (struct frame_info
*, int, int);
521 extern void show_stack_frame (struct frame_info
*);
523 extern void print_frame_info (struct frame_info
*, int, int, int);
525 extern void show_frame_info (struct frame_info
*, int, int, int);
527 extern struct frame_info
*block_innermost_frame (struct block
*);
529 /* NOTE: cagney/2002-09-13: There is no need for this function.
530 Instead either of frame_unwind_signed_register() or
531 frame_unwind_unsigned_register() can be used. */
532 extern CORE_ADDR
deprecated_read_register_dummy (CORE_ADDR pc
,
534 extern void generic_push_dummy_frame (void);
535 extern void generic_pop_current_frame (void (*)(struct frame_info
*));
536 extern void generic_pop_dummy_frame (void);
538 extern int generic_pc_in_call_dummy (CORE_ADDR pc
,
539 CORE_ADDR sp
, CORE_ADDR fp
);
541 /* NOTE: cagney/2002-06-26: Targets should no longer use this
542 function. Instead, the contents of a dummy frames registers can be
543 obtained by applying: frame_register_unwind to the dummy frame; or
544 frame_register_unwind() to the next outer frame. */
546 extern char *deprecated_generic_find_dummy_frame (CORE_ADDR pc
, CORE_ADDR fp
);
548 void generic_unwind_get_saved_register (char *raw_buffer
,
551 struct frame_info
*frame
,
553 enum lval_type
*lvalp
);
555 /* The function generic_get_saved_register() has been made obsolete.
556 DEPRECATED_GET_SAVED_REGISTER now defaults to the recursive
557 equivalent - generic_unwind_get_saved_register() - so there is no
558 need to even set DEPRECATED_GET_SAVED_REGISTER. Architectures that
559 need to override the register unwind mechanism should modify
561 extern void deprecated_generic_get_saved_register (char *, int *, CORE_ADDR
*,
562 struct frame_info
*, int,
565 extern void generic_save_call_dummy_addr (CORE_ADDR lo
, CORE_ADDR hi
);
567 /* FIXME: cagney/2003-02-02: Should be deprecated or replaced with a
568 function called frame_read_register_p(). This slightly weird (and
569 older) variant of frame_read_register() returns zero (indicating
570 the register is unavailable) if either: the register isn't cached;
571 or the register has been optimized out. Problem is, neither check
572 is exactly correct. A register can't be optimized out (it may not
573 have been saved as part of a function call); The fact that a
574 register isn't in the register cache doesn't mean that the register
575 isn't available (it could have been fetched from memory). */
577 extern int frame_register_read (struct frame_info
*frame
, int regnum
,
581 extern void args_info (char *, int);
583 extern void locals_info (char *, int);
585 extern void (*selected_frame_level_changed_hook
) (int);
587 extern void return_command (char *, int);
590 /* NOTE: cagney/2002-11-27:
592 You might think that the below global can simply be replaced by a
593 call to either get_selected_frame() or select_frame().
595 Unfortunatly, it isn't that easy.
597 The relevant code needs to be audited to determine if it is
598 possible (or pratical) to instead pass the applicable frame in as a
599 parameter. For instance, DEPRECATED_DO_REGISTERS_INFO() relied on
600 the deprecated_selected_frame global, while its replacement,
601 PRINT_REGISTERS_INFO(), is parameterized with the selected frame.
602 The only real exceptions occure at the edge (in the CLI code) where
603 user commands need to pick up the selected frame before proceeding.
605 This is important. GDB is trying to stamp out the hack:
607 saved_frame = deprecated_selected_frame;
608 deprecated_selected_frame = ...;
609 hack_using_global_selected_frame ();
610 deprecated_selected_frame = saved_frame;
614 extern struct frame_info
*deprecated_selected_frame
;
617 /* Create a frame using the specified BASE and PC. */
619 extern struct frame_info
*create_new_frame (CORE_ADDR base
, CORE_ADDR pc
);
622 /* Create/access the frame's `extra info'. The extra info is used by
623 older code to store information such as the analyzed prologue. The
624 zalloc() should only be called by the INIT_EXTRA_INFO method. */
626 extern struct frame_extra_info
*frame_extra_info_zalloc (struct frame_info
*fi
,
628 extern struct frame_extra_info
*get_frame_extra_info (struct frame_info
*fi
);
630 /* Create/access the frame's `saved_regs'. The saved regs are used by
631 older code to store the address of each register (except for
632 SP_REGNUM where the value of the register in the previous frame is
634 extern CORE_ADDR
*frame_saved_regs_zalloc (struct frame_info
*);
635 extern CORE_ADDR
*get_frame_saved_regs (struct frame_info
*);
637 /* FIXME: cagney/2002-12-06: Has the PC in the current frame changed?
638 "infrun.c", Thanks to DECR_PC_AFTER_BREAK, can change the PC after
639 the initial frame create. This puts things back in sync. */
640 extern void deprecated_update_frame_pc_hack (struct frame_info
*frame
,
643 /* FIXME: cagney/2002-12-18: Has the frame's base changed? Or to be
644 more exact, whas that initial guess at the frame's base as returned
645 by read_fp() wrong. If it was, fix it. This shouldn't be
646 necessary since the code should be getting the frame's base correct
648 extern void deprecated_update_frame_base_hack (struct frame_info
*frame
,
651 /* FIXME: cagney/2003-01-04: Explicitly set the frame's saved_regs
652 and/or extra_info. Target code is allocating a fake frame and than
653 initializing that to get around the problem of, when creating the
654 inner most frame, there is no where to cache information such as
655 the prologue analysis. This is fixed by the new unwind mechanism -
656 even the inner most frame has somewhere to store things like the
657 prolog analysis (or at least will once the frame overhaul is
659 extern void deprecated_set_frame_saved_regs_hack (struct frame_info
*frame
,
660 CORE_ADDR
*saved_regs
);
661 extern void deprecated_set_frame_extra_info_hack (struct frame_info
*frame
,
662 struct frame_extra_info
*extra_info
);
664 /* FIXME: cagney/2003-01-04: Allocate a frame from the heap (rather
665 than the frame obstack). Targets do this as a way of saving the
666 prologue analysis from the inner most frame before that frame has
667 been created. By always creating a frame, this problem goes away. */
668 extern struct frame_info
*deprecated_frame_xmalloc (void);
670 /* FIXME: cagney/2003-01-05: Allocate a frame, along with the
671 saved_regs and extra_info. Set up cleanups for all three. Same as
672 for deprecated_frame_xmalloc, targets are calling this when
673 creating a scratch `struct frame_info'. The frame overhaul makes
674 this unnecessary since all frame queries are parameterized with a
675 common cache parameter and a frame. */
676 extern struct frame_info
*deprecated_frame_xmalloc_with_cleanup (long sizeof_saved_regs
,
677 long sizeof_extra_info
);
679 /* FIXME: cagney/2003-01-07: These are just nasty. Code shouldn't be
680 doing this. I suspect it dates back to the days when every field
681 of an allocated structure was explicitly initialized. */
682 extern void deprecated_set_frame_next_hack (struct frame_info
*fi
,
683 struct frame_info
*next
);
684 extern void deprecated_set_frame_prev_hack (struct frame_info
*fi
,
685 struct frame_info
*prev
);
687 /* FIXME: cagney/2003-01-07: Instead of the dwarf2cfi having its own
688 dedicated `struct frame_info . context' field, the code should use
689 the per frame `unwind_cache' that is passed to the
690 frame_pc_unwind(), frame_register_unwind() and frame_id_unwind()
693 See "dummy-frame.c" for an example of how a cfi-frame object can be
694 implemented using this. */
695 extern struct context
*deprecated_get_frame_context (struct frame_info
*fi
);
696 extern void deprecated_set_frame_context (struct frame_info
*fi
,
697 struct context
*context
);
699 /* Return non-zero if the architecture is relying on legacy frame
701 extern int legacy_frame_p (struct gdbarch
*gdbarch
);
703 #endif /* !defined (FRAME_H) */